picnoir/Systemd
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Systemd/src/test/test-fileio.c

997 lines
33 KiB
C
Raw Normal View History

license: LGPL-2.1+ -> LGPL-2.1-or-later
2020-11-09 05:23:58 +01:00
/* SPDX-License-Identifier: LGPL-2.1-or-later */
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
#include <fcntl.h>
test-fileio: cast EOF to (char) before comparing with char explicitly EOF is defined to -1, hence on platforms that have "char" unsigned we can't compare it as-is, except if we accept an implicit cast. let's make it an explicit cast, acknowledging the issue. Fixes: #14118
2019-11-25 15:15:38 +01:00
#include <limits.h>
tree-wide: sort includes Sort the includes accoding to the new coding style.
2015-11-16 22:09:36 +01:00
#include <stdio.h>
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
#include <unistd.h>
util-lib: split out allocation calls into alloc-util.[ch]
2015-10-27 03:01:06 +01:00
#include "alloc-util.h"
Add more tests and fix capability logging
2013-09-19 23:22:59 +02:00
#include "ctype.h"
util-lib: split out env file parsing code into env-file.c It's quite complex, let's split this out. No code changes, just some file rearranging.
2018-11-30 22:08:41 +01:00
#include "env-file.h"
util-lib: split out fd-related operations into fd-util.[ch] There are more than enough to deserve their own .c file, hence move them over.
2015-10-25 13:14:12 +01:00
#include "env-util.h"
#include "fd-util.h"
#include "fileio.h"
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
#include "fs-util.h"
tests: move fileio related tests to test-fileio.c
2016-03-02 23:50:21 +01:00
#include "io-util.h"
util-lib: split string parsing related calls from util.[ch] into parse-util.[ch]
2015-10-26 16:18:16 +01:00
#include "parse-util.h"
util-lib: split out fd-related operations into fd-util.[ch] There are more than enough to deserve their own .c file, hence move them over.
2015-10-25 13:14:12 +01:00
#include "process-util.h"
fileio: beef up READ_FULL_FILE_CONNECT_SOCKET to allow setting sender socket name This beefs up the READ_FULL_FILE_CONNECT_SOCKET logic of read_full_file_full() a bit: when used a sender socket name may be specified. If specified as NULL behaviour is as before: the client socket name is picked by the kernel. But if specified as non-NULL the client can pick a socket name to use when connecting. This is useful to communicate a minimal amount of metainformation from client to server, outside of the transport payload. Specifically, these beefs up the service credential logic to pass an abstract AF_UNIX socket name as client socket name when connecting via READ_FULL_FILE_CONNECT_SOCKET, that includes the requesting unit name and the eventual credential name. This allows servers implementing the trivial credential socket logic to distinguish clients: via a simple getpeername() it can be determined which unit is requesting a credential, and which credential specifically. Example: with this patch in place, in a unit file "waldo.service" a configuration line like the following: LoadCredential=foo:/run/quux/creds.sock will result in a connection to the AF_UNIX socket /run/quux/creds.sock, originating from an abstract namespace AF_UNIX socket: @$RANDOM/unit/waldo.service/foo (The $RANDOM is replaced by some randomized string. This is included in the socket name order to avoid namespace squatting issues: the abstract socket namespace is open to unprivileged users after all, and care needs to be taken not to use guessable names) The services listening on the /run/quux/creds.sock socket may thus easily retrieve the name of the unit the credential is requested for plus the credential name, via a simpler getpeername(), discarding the random preifx and the /unit/ string. This logic uses "/" as separator between the fields, since both unit names and credential names appear in the file system, and thus are designed to use "/" as outer separators. Given that it's a good safe choice to use as separators here, too avoid any conflicts. This is a minimal patch only: the new logic is used only for the unit file credential logic. For other places where we use READ_FULL_FILE_CONNECT_SOCKET it is probably a good idea to use this scheme too, but this should be done carefully in later patches, since the socket names become API that way, and we should determine the right amount of info to pass over.
2020-11-02 12:07:51 +01:00
#include "random-util.h"
fileio: add support for read_full_file() on AF_UNIX stream sockets Optionally, teach read_full_file() the ability to connect to an AF_UNIX socket if the specified path points to one.
2020-07-17 12:26:01 +02:00
#include "rm-rf.h"
#include "socket-util.h"
util-lib: split our string related calls from util.[ch] into its own file string-util.[ch] There are more than enough calls doing string manipulations to deserve its own files, hence do something about it. This patch also sorts the #include blocks of all files that needed to be updated, according to the sorting suggestions from CODING_STYLE. Since pretty much every file needs our string manipulation functions this effectively means that most files have sorted #include blocks now. Also touches a few unrelated include files.
2015-10-24 22:58:24 +02:00
#include "string-util.h"
util-lib: split out fd-related operations into fd-util.[ch] There are more than enough to deserve their own .c file, hence move them over.
2015-10-25 13:14:12 +01:00
#include "strv.h"
tests: use a helper function to parse environment and open logging The advantages are that we save a few lines, and that we can override logging using environment variables in more test executables.
2018-09-13 14:31:13 +02:00
#include "tests.h"
util-lib: split out all temporary file related calls into tmpfiles-util.c This splits out a bunch of functions from fileio.c that have to do with temporary files. Simply to make the header files a bit shorter, and to group things more nicely. No code changes, just some rearranging of source files.
2018-11-30 21:05:27 +01:00
#include "tmpfile-util.h"
util-lib: split out fd-related operations into fd-util.[ch] There are more than enough to deserve their own .c file, hence move them over.
2015-10-25 13:14:12 +01:00
#include "util.h"
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
static void test_parse_env_file(void) {
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
_cleanup_(unlink_tempfilep) char
t[] = "/tmp/test-fileio-in-XXXXXX",
test-fileio: use random name for written file If two instances of test-fileio were run in parallel, they could fail when trying to write the same file. This predictable name in /tmp/ wasn't actually a security issue, because write_env_file would not follow symlinks, so this could be an issue only when running tests in parallel.
2013-07-30 01:49:55 +02:00
p[] = "/tmp/test-fileio-out-XXXXXX";
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
FILE *f;
core/execute: report invalid environment variables from files Because "export key=val" is not supported by systemd, an error is logged where the invalid assignment is coming from. Introduce strv_env_clean_log() to log invalid environment assignments, where logging is possible and allowed. parse_env_file_internal() is modified to allow WHITESPACE in keys, to report the issues later on.
2013-04-17 15:25:02 +02:00
_cleanup_free_ char *one = NULL, *two = NULL, *three = NULL, *four = NULL, *five = NULL,
util-lib: follow shell syntax for escape in quotes Fixes #10659. This changes the behaviour of parsing environment files to more closely follow POSIX shell standards. This has the effect that these variables defined in a file: VAR1='\value' VAR2="\value" Are now interpreted as `\value` instead of interpreting the `\` character and interpreting them as `value`. For more information about the behaviour followed, see: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_02
2019-01-14 22:35:10 +01:00
*six = NULL, *seven = NULL, *eight = NULL, *nine = NULL, *ten = NULL,
*eleven = NULL, *twelve = NULL, *thirteen = NULL;
fileio: write proper env var write-out code This will properly escape all weird chars when writing env var files. With this in place we can now read and write environment files where the values contain arbitrary weird chars. This enables hostnamed and suchlike to finally properly save pretty host names with backlashes or quotes in them.
2013-04-03 19:56:39 +02:00
_cleanup_strv_free_ char **a = NULL, **b = NULL;
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
char **i;
fileio: write proper env var write-out code This will properly escape all weird chars when writing env var files. With this in place we can now read and write environment files where the values contain arbitrary weird chars. This enables hostnamed and suchlike to finally properly save pretty host names with backlashes or quotes in them.
2013-04-03 19:56:39 +02:00
unsigned k;
Introduce fmkostemp_safe and use it in tests No functional change.
2018-10-23 10:50:09 +02:00
int r;
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
Introduce fmkostemp_safe and use it in tests No functional change.
2018-10-23 10:50:09 +02:00
assert_se(fmkostemp_safe(t, "w", &f) == 0);
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
fputs("one=BAR \n"
"# comment\n"
" # comment \n"
fileio.c: do not parse comments after non-whitespace chars systemd does not want to understand comments after the first non-whitespace char occured. key=foo #comment will result into key == "foo #comment" key="foo" #comment will result into key == "foo#comment" "key= #comment" will result into key == "#comment" "key #comment" is an invalid line
2013-04-18 10:15:25 +02:00
" ; comment \n"
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
" two = bar \n"
"invalid line\n"
fileio.c: do not parse comments after non-whitespace chars systemd does not want to understand comments after the first non-whitespace char occured. key=foo #comment will result into key == "foo #comment" key="foo" #comment will result into key == "foo#comment" "key= #comment" will result into key == "#comment" "key #comment" is an invalid line
2013-04-18 10:15:25 +02:00
"invalid line #comment\n"
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
"three = \"333\n"
"xxxx\"\n"
"four = \'44\\\"44\'\n"
util-lib: follow shell syntax for escape in quotes Fixes #10659. This changes the behaviour of parsing environment files to more closely follow POSIX shell standards. This has the effect that these variables defined in a file: VAR1='\value' VAR2="\value" Are now interpreted as `\value` instead of interpreting the `\` character and interpreting them as `value`. For more information about the behaviour followed, see: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_02
2019-01-14 22:35:10 +01:00
"five = \"55\\\"55\" \"FIVE\" cinco \n"
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
"six = seis sechs\\\n"
" sis\n"
fileio.c: do not parse comments after non-whitespace chars systemd does not want to understand comments after the first non-whitespace char occured. key=foo #comment will result into key == "foo #comment" key="foo" #comment will result into key == "foo#comment" "key= #comment" will result into key == "#comment" "key #comment" is an invalid line
2013-04-18 10:15:25 +02:00
"seven=\"sevenval\" #nocomment\n"
"eight=eightval #nocomment\n"
core/execute: report invalid environment variables from files Because "export key=val" is not supported by systemd, an error is logged where the invalid assignment is coming from. Introduce strv_env_clean_log() to log invalid environment assignments, where logging is possible and allowed. parse_env_file_internal() is modified to allow WHITESPACE in keys, to report the issues later on.
2013-04-17 15:25:02 +02:00
"export nine=nineval\n"
env-util,fileio: immediately replace variables in load_env_file_push() strv_env_replace was calling env_match(), which in effect allowed multiple values for the same key to be inserted into the environment block. That's pointless, because APIs to access variables only return a single value (the latest entry), so it's better to keep the block clean, i.e. with just a single entry for each key. Add a new helper function that simply tests if the part before '=' is equal in two strings and use that in strv_env_replace. In load_env_file_push, use strv_env_replace to immediately replace the previous assignment with a matching name. Afaict, none of the callers are materially affected by this change, but it seems like some pointless work was being done, if the same value was set multiple times. We'd go through parsing and assigning the value for each entry. With this change, we handle just the last one.
2017-02-11 05:08:53 +01:00
"ten=ignored\n"
"ten=ignored\n"
util-lib: follow shell syntax for escape in quotes Fixes #10659. This changes the behaviour of parsing environment files to more closely follow POSIX shell standards. This has the effect that these variables defined in a file: VAR1='\value' VAR2="\value" Are now interpreted as `\value` instead of interpreting the `\` character and interpreting them as `value`. For more information about the behaviour followed, see: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_02
2019-01-14 22:35:10 +01:00
"ten=\n"
"eleven=\\value\n"
"twelve=\"\\value\"\n"
"thirteen='\\value'", f);
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
fflush(f);
fclose(f);
fileio: drop "newline" parameter for env file parsers Now that we don't (mis-)use the env file parser to parse kernel command lines there's no need anymore to override the used newline character set. Let's hence drop the argument and just "\n\r" always. This nicely simplifies our code.
2018-11-12 14:04:47 +01:00
r = load_env_file(NULL, t, &a);
core/execute: report invalid environment variables from files Because "export key=val" is not supported by systemd, an error is logged where the invalid assignment is coming from. Introduce strv_env_clean_log() to log invalid environment assignments, where logging is possible and allowed. parse_env_file_internal() is modified to allow WHITESPACE in keys, to report the issues later on.
2013-04-17 15:25:02 +02:00
assert_se(r >= 0);
STRV_FOREACH(i, a)
log_info("Got: <%s>", *i);
scan-build: silence some warnings test-fileio/test-strv: Use the streq_ptr to make build-scan not worry about passing in a null to a nonnull function. test-dhcp-option: Prevent a theoretical null pointer dereference
2013-12-12 23:08:47 +01:00
assert_se(streq_ptr(a[0], "one=BAR"));
assert_se(streq_ptr(a[1], "two=bar"));
assert_se(streq_ptr(a[2], "three=333\nxxxx"));
util-lib: follow shell syntax for escape in quotes Fixes #10659. This changes the behaviour of parsing environment files to more closely follow POSIX shell standards. This has the effect that these variables defined in a file: VAR1='\value' VAR2="\value" Are now interpreted as `\value` instead of interpreting the `\` character and interpreting them as `value`. For more information about the behaviour followed, see: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_02
2019-01-14 22:35:10 +01:00
assert_se(streq_ptr(a[3], "four=44\\\"44"));
assert_se(streq_ptr(a[4], "five=55\"55FIVEcinco"));
scan-build: silence some warnings test-fileio/test-strv: Use the streq_ptr to make build-scan not worry about passing in a null to a nonnull function. test-dhcp-option: Prevent a theoretical null pointer dereference
2013-12-12 23:08:47 +01:00
assert_se(streq_ptr(a[5], "six=seis sechs sis"));
assert_se(streq_ptr(a[6], "seven=sevenval#nocomment"));
assert_se(streq_ptr(a[7], "eight=eightval #nocomment"));
assert_se(streq_ptr(a[8], "export nine=nineval"));
assert_se(streq_ptr(a[9], "ten="));
util-lib: follow shell syntax for escape in quotes Fixes #10659. This changes the behaviour of parsing environment files to more closely follow POSIX shell standards. This has the effect that these variables defined in a file: VAR1='\value' VAR2="\value" Are now interpreted as `\value` instead of interpreting the `\` character and interpreting them as `value`. For more information about the behaviour followed, see: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_02
2019-01-14 22:35:10 +01:00
assert_se(streq_ptr(a[10], "eleven=value"));
assert_se(streq_ptr(a[11], "twelve=\\value"));
assert_se(streq_ptr(a[12], "thirteen=\\value"));
assert_se(a[13] == NULL);
core/execute: report invalid environment variables from files Because "export key=val" is not supported by systemd, an error is logged where the invalid assignment is coming from. Introduce strv_env_clean_log() to log invalid environment assignments, where logging is possible and allowed. parse_env_file_internal() is modified to allow WHITESPACE in keys, to report the issues later on.
2013-04-17 15:25:02 +02:00
env-util: don't include files from src/core/
2014-12-23 19:04:56 +01:00
strv_env_clean(a);
core/execute: report invalid environment variables from files Because "export key=val" is not supported by systemd, an error is logged where the invalid assignment is coming from. Introduce strv_env_clean_log() to log invalid environment assignments, where logging is possible and allowed. parse_env_file_internal() is modified to allow WHITESPACE in keys, to report the issues later on.
2013-04-17 15:25:02 +02:00
k = 0;
STRV_FOREACH(i, b) {
log_info("Got2: <%s>", *i);
assert_se(streq(*i, a[k++]));
}
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
r = parse_env_file(
fileio: drop "newline" parameter for env file parsers Now that we don't (mis-)use the env file parser to parse kernel command lines there's no need anymore to override the used newline character set. Let's hence drop the argument and just "\n\r" always. This nicely simplifies our code.
2018-11-12 14:04:47 +01:00
NULL, t,
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
"one", &one,
"two", &two,
"three", &three,
"four", &four,
"five", &five,
"six", &six,
"seven", &seven,
fileio:parse_env_file_internal() fix environment file parsing parse_env_file_internal() could not parse the following lines correctly: export key="val" key="val"#comment
2013-04-17 11:02:56 +02:00
"eight", &eight,
core/execute: report invalid environment variables from files Because "export key=val" is not supported by systemd, an error is logged where the invalid assignment is coming from. Introduce strv_env_clean_log() to log invalid environment assignments, where logging is possible and allowed. parse_env_file_internal() is modified to allow WHITESPACE in keys, to report the issues later on.
2013-04-17 15:25:02 +02:00
"export nine", &nine,
util-lib: follow shell syntax for escape in quotes Fixes #10659. This changes the behaviour of parsing environment files to more closely follow POSIX shell standards. This has the effect that these variables defined in a file: VAR1='\value' VAR2="\value" Are now interpreted as `\value` instead of interpreting the `\` character and interpreting them as `value`. For more information about the behaviour followed, see: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_02
2019-01-14 22:35:10 +01:00
"ten", &ten,
"eleven", &eleven,
"twelve", &twelve,
"thirteen", &thirteen);
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
assert_se(r >= 0);
log_info("one=[%s]", strna(one));
log_info("two=[%s]", strna(two));
log_info("three=[%s]", strna(three));
log_info("four=[%s]", strna(four));
log_info("five=[%s]", strna(five));
log_info("six=[%s]", strna(six));
log_info("seven=[%s]", strna(seven));
fileio:parse_env_file_internal() fix environment file parsing parse_env_file_internal() could not parse the following lines correctly: export key="val" key="val"#comment
2013-04-17 11:02:56 +02:00
log_info("eight=[%s]", strna(eight));
core/execute: report invalid environment variables from files Because "export key=val" is not supported by systemd, an error is logged where the invalid assignment is coming from. Introduce strv_env_clean_log() to log invalid environment assignments, where logging is possible and allowed. parse_env_file_internal() is modified to allow WHITESPACE in keys, to report the issues later on.
2013-04-17 15:25:02 +02:00
log_info("export nine=[%s]", strna(nine));
log_info("ten=[%s]", strna(nine));
util-lib: follow shell syntax for escape in quotes Fixes #10659. This changes the behaviour of parsing environment files to more closely follow POSIX shell standards. This has the effect that these variables defined in a file: VAR1='\value' VAR2="\value" Are now interpreted as `\value` instead of interpreting the `\` character and interpreting them as `value`. For more information about the behaviour followed, see: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_02
2019-01-14 22:35:10 +01:00
log_info("eleven=[%s]", strna(eleven));
log_info("twelve=[%s]", strna(twelve));
log_info("thirteen=[%s]", strna(thirteen));
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
assert_se(streq(one, "BAR"));
assert_se(streq(two, "bar"));
assert_se(streq(three, "333\nxxxx"));
util-lib: follow shell syntax for escape in quotes Fixes #10659. This changes the behaviour of parsing environment files to more closely follow POSIX shell standards. This has the effect that these variables defined in a file: VAR1='\value' VAR2="\value" Are now interpreted as `\value` instead of interpreting the `\` character and interpreting them as `value`. For more information about the behaviour followed, see: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_02
2019-01-14 22:35:10 +01:00
assert_se(streq(four, "44\\\"44"));
assert_se(streq(five, "55\"55FIVEcinco"));
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
assert_se(streq(six, "seis sechs sis"));
fileio.c: do not parse comments after non-whitespace chars systemd does not want to understand comments after the first non-whitespace char occured. key=foo #comment will result into key == "foo #comment" key="foo" #comment will result into key == "foo#comment" "key= #comment" will result into key == "#comment" "key #comment" is an invalid line
2013-04-18 10:15:25 +02:00
assert_se(streq(seven, "sevenval#nocomment"));
assert_se(streq(eight, "eightval #nocomment"));
core/execute: report invalid environment variables from files Because "export key=val" is not supported by systemd, an error is logged where the invalid assignment is coming from. Introduce strv_env_clean_log() to log invalid environment assignments, where logging is possible and allowed. parse_env_file_internal() is modified to allow WHITESPACE in keys, to report the issues later on.
2013-04-17 15:25:02 +02:00
assert_se(streq(nine, "nineval"));
assert_se(ten == NULL);
util-lib: follow shell syntax for escape in quotes Fixes #10659. This changes the behaviour of parsing environment files to more closely follow POSIX shell standards. This has the effect that these variables defined in a file: VAR1='\value' VAR2="\value" Are now interpreted as `\value` instead of interpreting the `\` character and interpreting them as `value`. For more information about the behaviour followed, see: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_02
2019-01-14 22:35:10 +01:00
assert_se(streq(eleven, "value"));
assert_se(streq(twelve, "\\value"));
assert_se(streq(thirteen, "\\value"));
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
Introduce fmkostemp_safe and use it in tests No functional change.
2018-10-23 10:50:09 +02:00
{
/* prepare a temporary file to write the environment to */
_cleanup_close_ int fd = mkostemp_safe(p);
assert_se(fd >= 0);
}
test-fileio: use random name for written file If two instances of test-fileio were run in parallel, they could fail when trying to write the same file. This predictable name in /tmp/ wasn't actually a security issue, because write_env_file would not follow symlinks, so this could be an issue only when running tests in parallel.
2013-07-30 01:49:55 +02:00
r = write_env_file(p, a);
fileio.c: do not parse comments after non-whitespace chars systemd does not want to understand comments after the first non-whitespace char occured. key=foo #comment will result into key == "foo #comment" key="foo" #comment will result into key == "foo#comment" "key= #comment" will result into key == "#comment" "key #comment" is an invalid line
2013-04-18 10:15:25 +02:00
assert_se(r >= 0);
fileio: drop "newline" parameter for env file parsers Now that we don't (mis-)use the env file parser to parse kernel command lines there's no need anymore to override the used newline character set. Let's hence drop the argument and just "\n\r" always. This nicely simplifies our code.
2018-11-12 14:04:47 +01:00
r = load_env_file(NULL, p, &b);
fileio.c: do not parse comments after non-whitespace chars systemd does not want to understand comments after the first non-whitespace char occured. key=foo #comment will result into key == "foo #comment" key="foo" #comment will result into key == "foo#comment" "key= #comment" will result into key == "#comment" "key #comment" is an invalid line
2013-04-18 10:15:25 +02:00
assert_se(r >= 0);
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
}
test-fileio: test test strings with shell, too
2020-09-11 17:43:05 +02:00
static void test_one_shell_var(const char *file, const char *variable, const char *value) {
_cleanup_free_ char *cmd = NULL, *from_shell = NULL;
test: use pclose() for popen() Coverity CID#1432701.
2020-09-14 22:32:52 +02:00
_cleanup_pclose_ FILE *f = NULL;
test-fileio: test test strings with shell, too
2020-09-11 17:43:05 +02:00
size_t sz;
assert_se(cmd = strjoin(". ", file, " && /bin/echo -n \"$", variable, "\""));
assert_se(f = popen(cmd, "re"));
assert_se(read_full_stream(f, &from_shell, &sz) >= 0);
assert_se(sz == strlen(value));
assert_se(streq(from_shell, value));
}
Allow tabs in environment files bash allows them, and so should we. string_has_cc is changed to allow tabs, and if they are not wanted, they must be now checked for explicitly. There are two other callers, apart from the env file loaders, and one already checked anyway, and the other is changed to check. https://bugs.freedesktop.org/show_bug.cgi?id=68592 https://bugs.gentoo.org/show_bug.cgi?id=481554
2013-09-12 03:50:16 +02:00
static void test_parse_multiline_env_file(void) {
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
_cleanup_(unlink_tempfilep) char
t[] = "/tmp/test-fileio-in-XXXXXX",
Allow tabs in environment files bash allows them, and so should we. string_has_cc is changed to allow tabs, and if they are not wanted, they must be now checked for explicitly. There are two other callers, apart from the env file loaders, and one already checked anyway, and the other is changed to check. https://bugs.freedesktop.org/show_bug.cgi?id=68592 https://bugs.gentoo.org/show_bug.cgi?id=481554
2013-09-12 03:50:16 +02:00
p[] = "/tmp/test-fileio-out-XXXXXX";
FILE *f;
_cleanup_strv_free_ char **a = NULL, **b = NULL;
char **i;
Introduce fmkostemp_safe and use it in tests No functional change.
2018-10-23 10:50:09 +02:00
int r;
Allow tabs in environment files bash allows them, and so should we. string_has_cc is changed to allow tabs, and if they are not wanted, they must be now checked for explicitly. There are two other callers, apart from the env file loaders, and one already checked anyway, and the other is changed to check. https://bugs.freedesktop.org/show_bug.cgi?id=68592 https://bugs.gentoo.org/show_bug.cgi?id=481554
2013-09-12 03:50:16 +02:00
Introduce fmkostemp_safe and use it in tests No functional change.
2018-10-23 10:50:09 +02:00
assert_se(fmkostemp_safe(t, "w", &f) == 0);
Allow tabs in environment files bash allows them, and so should we. string_has_cc is changed to allow tabs, and if they are not wanted, they must be now checked for explicitly. There are two other callers, apart from the env file loaders, and one already checked anyway, and the other is changed to check. https://bugs.freedesktop.org/show_bug.cgi?id=68592 https://bugs.gentoo.org/show_bug.cgi?id=481554
2013-09-12 03:50:16 +02:00
fputs("one=BAR\\\n"
test-fileio: use test strings that are actually valid in shell
2020-09-11 17:42:46 +02:00
"\\ \\ \\ \\ VAR\\\n"
"\\\tGAR\n"
Allow tabs in environment files bash allows them, and so should we. string_has_cc is changed to allow tabs, and if they are not wanted, they must be now checked for explicitly. There are two other callers, apart from the env file loaders, and one already checked anyway, and the other is changed to check. https://bugs.freedesktop.org/show_bug.cgi?id=68592 https://bugs.gentoo.org/show_bug.cgi?id=481554
2013-09-12 03:50:16 +02:00
"#comment\n"
"two=\"bar\\\n"
" var\\\n"
"\tgar\"\n"
"#comment\n"
"tri=\"bar \\\n"
" var \\\n"
"\tgar \"\n", f);
test-fileio: use test strings that are actually valid in shell
2020-09-11 17:42:46 +02:00
assert_se(fflush_and_check(f) >= 0);
Allow tabs in environment files bash allows them, and so should we. string_has_cc is changed to allow tabs, and if they are not wanted, they must be now checked for explicitly. There are two other callers, apart from the env file loaders, and one already checked anyway, and the other is changed to check. https://bugs.freedesktop.org/show_bug.cgi?id=68592 https://bugs.gentoo.org/show_bug.cgi?id=481554
2013-09-12 03:50:16 +02:00
fclose(f);
test-fileio: test test strings with shell, too
2020-09-11 17:43:05 +02:00
test_one_shell_var(t, "one", "BAR VAR\tGAR");
test_one_shell_var(t, "two", "bar var\tgar");
test_one_shell_var(t, "tri", "bar var \tgar ");
fileio: drop "newline" parameter for env file parsers Now that we don't (mis-)use the env file parser to parse kernel command lines there's no need anymore to override the used newline character set. Let's hence drop the argument and just "\n\r" always. This nicely simplifies our code.
2018-11-12 14:04:47 +01:00
r = load_env_file(NULL, t, &a);
Allow tabs in environment files bash allows them, and so should we. string_has_cc is changed to allow tabs, and if they are not wanted, they must be now checked for explicitly. There are two other callers, apart from the env file loaders, and one already checked anyway, and the other is changed to check. https://bugs.freedesktop.org/show_bug.cgi?id=68592 https://bugs.gentoo.org/show_bug.cgi?id=481554
2013-09-12 03:50:16 +02:00
assert_se(r >= 0);
STRV_FOREACH(i, a)
log_info("Got: <%s>", *i);
scan-build: silence some warnings test-fileio/test-strv: Use the streq_ptr to make build-scan not worry about passing in a null to a nonnull function. test-dhcp-option: Prevent a theoretical null pointer dereference
2013-12-12 23:08:47 +01:00
assert_se(streq_ptr(a[0], "one=BAR VAR\tGAR"));
assert_se(streq_ptr(a[1], "two=bar var\tgar"));
assert_se(streq_ptr(a[2], "tri=bar var \tgar "));
Allow tabs in environment files bash allows them, and so should we. string_has_cc is changed to allow tabs, and if they are not wanted, they must be now checked for explicitly. There are two other callers, apart from the env file loaders, and one already checked anyway, and the other is changed to check. https://bugs.freedesktop.org/show_bug.cgi?id=68592 https://bugs.gentoo.org/show_bug.cgi?id=481554
2013-09-12 03:50:16 +02:00
assert_se(a[3] == NULL);
Introduce fmkostemp_safe and use it in tests No functional change.
2018-10-23 10:50:09 +02:00
{
_cleanup_close_ int fd = mkostemp_safe(p);
assert_se(fd >= 0);
}
Allow tabs in environment files bash allows them, and so should we. string_has_cc is changed to allow tabs, and if they are not wanted, they must be now checked for explicitly. There are two other callers, apart from the env file loaders, and one already checked anyway, and the other is changed to check. https://bugs.freedesktop.org/show_bug.cgi?id=68592 https://bugs.gentoo.org/show_bug.cgi?id=481554
2013-09-12 03:50:16 +02:00
r = write_env_file(p, a);
assert_se(r >= 0);
fileio: drop "newline" parameter for env file parsers Now that we don't (mis-)use the env file parser to parse kernel command lines there's no need anymore to override the used newline character set. Let's hence drop the argument and just "\n\r" always. This nicely simplifies our code.
2018-11-12 14:04:47 +01:00
r = load_env_file(NULL, p, &b);
Allow tabs in environment files bash allows them, and so should we. string_has_cc is changed to allow tabs, and if they are not wanted, they must be now checked for explicitly. There are two other callers, apart from the env file loaders, and one already checked anyway, and the other is changed to check. https://bugs.freedesktop.org/show_bug.cgi?id=68592 https://bugs.gentoo.org/show_bug.cgi?id=481554
2013-09-12 03:50:16 +02:00
assert_se(r >= 0);
}
basic: add new merge_env_file function merge_env_file is a new function, that's like load_env_file, but takes a pre-existing environment as an input argument. New environment entries are merged. Variable expansion is performed. Falling back to the process environment is supported (when a flag is set). Alternatively this could be implemented as passing an additional fallback environment array, but later on we're adding another flag to allow braceless expansion, and the two flags can be combined in one arg, so there's less stuff to pass around.
2016-08-04 18:00:00 +02:00
static void test_merge_env_file(void) {
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
_cleanup_(unlink_tempfilep) char t[] = "/tmp/test-fileio-XXXXXX";
test-fileio: close two leaked file handles
2017-09-24 08:59:49 +02:00
_cleanup_fclose_ FILE *f = NULL;
basic: add new merge_env_file function merge_env_file is a new function, that's like load_env_file, but takes a pre-existing environment as an input argument. New environment entries are merged. Variable expansion is performed. Falling back to the process environment is supported (when a flag is set). Alternatively this could be implemented as passing an additional fallback environment array, but later on we're adding another flag to allow braceless expansion, and the two flags can be combined in one arg, so there's less stuff to pass around.
2016-08-04 18:00:00 +02:00
_cleanup_strv_free_ char **a = NULL;
char **i;
Introduce fmkostemp_safe and use it in tests No functional change.
2018-10-23 10:50:09 +02:00
int r;
basic: add new merge_env_file function merge_env_file is a new function, that's like load_env_file, but takes a pre-existing environment as an input argument. New environment entries are merged. Variable expansion is performed. Falling back to the process environment is supported (when a flag is set). Alternatively this could be implemented as passing an additional fallback environment array, but later on we're adding another flag to allow braceless expansion, and the two flags can be combined in one arg, so there's less stuff to pass around.
2016-08-04 18:00:00 +02:00
Introduce fmkostemp_safe and use it in tests No functional change.
2018-10-23 10:50:09 +02:00
assert_se(fmkostemp_safe(t, "w", &f) == 0);
basic: add new merge_env_file function merge_env_file is a new function, that's like load_env_file, but takes a pre-existing environment as an input argument. New environment entries are merged. Variable expansion is performed. Falling back to the process environment is supported (when a flag is set). Alternatively this could be implemented as passing an additional fallback environment array, but later on we're adding another flag to allow braceless expansion, and the two flags can be combined in one arg, so there's less stuff to pass around.
2016-08-04 18:00:00 +02:00
log_info("/* %s (%s) */", __func__, t);
r = write_string_stream(f,
"one=1 \n"
"twelve=${one}2\n"
"twentyone=2${one}\n"
"one=2\n"
Allow braceless variables to be expanded (Only in environment.d files.) We have only basic compatibility with shell syntax, but specifying variables without using braces is probably more common, and I think a lot of people would be surprised if this didn't work.
2017-02-11 20:05:10 +01:00
"twentytwo=2${one}\n"
"xxx_minus_three=$xxx - 3\n"
"xxx=0x$one$one$one\n"
basic: support default and alternate values for env expansion Sometimes it's useful to provide a default value during an environment expansion, if the environment variable isn't already set. For instance $XDG_DATA_DIRS is suppose to default to: /usr/local/share/:/usr/share/ if it's not yet set. That means callers wishing to augment XDG_DATA_DIRS need to manually add those two values. This commit changes replace_env to support the following shell compatible default value syntax: XDG_DATA_DIRS=/foo:${XDG_DATA_DIRS:-/usr/local/share/:/usr/share} Likewise, it's useful to provide an alternate value during an environment expansion, if the environment variable isn't already set. For instance, $LD_LIBRARY_PATH will inadvertently search the current working directory if it starts or ends with a colon, so the following is usually wrong: LD_LIBRARY_PATH=/foo/lib:${LD_LIBRARY_PATH} To address that, this changes replace_env to support the following shell compatible alternate value syntax: LD_LIBRARY_PATH=/foo/lib${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}} [zj: gate the new syntax under REPLACE_ENV_ALLOW_EXTENDED switch, so existing callers are not modified.]
2016-08-09 16:20:22 +02:00
"yyy=${one:-fallback}\n"
"zzz=${one:+replacement}\n"
"zzzz=${foobar:-${nothing}}\n"
"zzzzz=${nothing:+${nothing}}\n"
fileio: make write_string_stream() accept flags parameter Let's make write_string_stream() and write_string_file() more alike, and pass the same flag set so that we can remove a number of boolean parameters.
2017-09-22 20:55:34 +02:00
, WRITE_STRING_FILE_AVOID_NEWLINE);
basic: add new merge_env_file function merge_env_file is a new function, that's like load_env_file, but takes a pre-existing environment as an input argument. New environment entries are merged. Variable expansion is performed. Falling back to the process environment is supported (when a flag is set). Alternatively this could be implemented as passing an additional fallback environment array, but later on we're adding another flag to allow braceless expansion, and the two flags can be combined in one arg, so there's less stuff to pass around.
2016-08-04 18:00:00 +02:00
assert(r >= 0);
r = merge_env_file(&a, NULL, t);
assert_se(r >= 0);
strv_sort(a);
STRV_FOREACH(i, a)
log_info("Got: <%s>", *i);
assert_se(streq(a[0], "one=2"));
assert_se(streq(a[1], "twelve=12"));
assert_se(streq(a[2], "twentyone=21"));
assert_se(streq(a[3], "twentytwo=22"));
Allow braceless variables to be expanded (Only in environment.d files.) We have only basic compatibility with shell syntax, but specifying variables without using braces is probably more common, and I think a lot of people would be surprised if this didn't work.
2017-02-11 20:05:10 +01:00
assert_se(streq(a[4], "xxx=0x222"));
assert_se(streq(a[5], "xxx_minus_three= - 3"));
basic: support default and alternate values for env expansion Sometimes it's useful to provide a default value during an environment expansion, if the environment variable isn't already set. For instance $XDG_DATA_DIRS is suppose to default to: /usr/local/share/:/usr/share/ if it's not yet set. That means callers wishing to augment XDG_DATA_DIRS need to manually add those two values. This commit changes replace_env to support the following shell compatible default value syntax: XDG_DATA_DIRS=/foo:${XDG_DATA_DIRS:-/usr/local/share/:/usr/share} Likewise, it's useful to provide an alternate value during an environment expansion, if the environment variable isn't already set. For instance, $LD_LIBRARY_PATH will inadvertently search the current working directory if it starts or ends with a colon, so the following is usually wrong: LD_LIBRARY_PATH=/foo/lib:${LD_LIBRARY_PATH} To address that, this changes replace_env to support the following shell compatible alternate value syntax: LD_LIBRARY_PATH=/foo/lib${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}} [zj: gate the new syntax under REPLACE_ENV_ALLOW_EXTENDED switch, so existing callers are not modified.]
2016-08-09 16:20:22 +02:00
assert_se(streq(a[6], "yyy=2"));
assert_se(streq(a[7], "zzz=replacement"));
assert_se(streq(a[8], "zzzz="));
assert_se(streq(a[9], "zzzzz="));
assert_se(a[10] == NULL);
basic: add new merge_env_file function merge_env_file is a new function, that's like load_env_file, but takes a pre-existing environment as an input argument. New environment entries are merged. Variable expansion is performed. Falling back to the process environment is supported (when a flag is set). Alternatively this could be implemented as passing an additional fallback environment array, but later on we're adding another flag to allow braceless expansion, and the two flags can be combined in one arg, so there's less stuff to pass around.
2016-08-04 18:00:00 +02:00
r = merge_env_file(&a, NULL, t);
assert_se(r >= 0);
strv_sort(a);
STRV_FOREACH(i, a)
log_info("Got2: <%s>", *i);
assert_se(streq(a[0], "one=2"));
assert_se(streq(a[1], "twelve=12"));
assert_se(streq(a[2], "twentyone=21"));
assert_se(streq(a[3], "twentytwo=22"));
Allow braceless variables to be expanded (Only in environment.d files.) We have only basic compatibility with shell syntax, but specifying variables without using braces is probably more common, and I think a lot of people would be surprised if this didn't work.
2017-02-11 20:05:10 +01:00
assert_se(streq(a[4], "xxx=0x222"));
assert_se(streq(a[5], "xxx_minus_three=0x222 - 3"));
basic: support default and alternate values for env expansion Sometimes it's useful to provide a default value during an environment expansion, if the environment variable isn't already set. For instance $XDG_DATA_DIRS is suppose to default to: /usr/local/share/:/usr/share/ if it's not yet set. That means callers wishing to augment XDG_DATA_DIRS need to manually add those two values. This commit changes replace_env to support the following shell compatible default value syntax: XDG_DATA_DIRS=/foo:${XDG_DATA_DIRS:-/usr/local/share/:/usr/share} Likewise, it's useful to provide an alternate value during an environment expansion, if the environment variable isn't already set. For instance, $LD_LIBRARY_PATH will inadvertently search the current working directory if it starts or ends with a colon, so the following is usually wrong: LD_LIBRARY_PATH=/foo/lib:${LD_LIBRARY_PATH} To address that, this changes replace_env to support the following shell compatible alternate value syntax: LD_LIBRARY_PATH=/foo/lib${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}} [zj: gate the new syntax under REPLACE_ENV_ALLOW_EXTENDED switch, so existing callers are not modified.]
2016-08-09 16:20:22 +02:00
assert_se(streq(a[6], "yyy=2"));
assert_se(streq(a[7], "zzz=replacement"));
assert_se(streq(a[8], "zzzz="));
assert_se(streq(a[9], "zzzzz="));
assert_se(a[10] == NULL);
basic: add new merge_env_file function merge_env_file is a new function, that's like load_env_file, but takes a pre-existing environment as an input argument. New environment entries are merged. Variable expansion is performed. Falling back to the process environment is supported (when a flag is set). Alternatively this could be implemented as passing an additional fallback environment array, but later on we're adding another flag to allow braceless expansion, and the two flags can be combined in one arg, so there's less stuff to pass around.
2016-08-04 18:00:00 +02:00
}
Allow tabs in environment files bash allows them, and so should we. string_has_cc is changed to allow tabs, and if they are not wanted, they must be now checked for explicitly. There are two other callers, apart from the env file loaders, and one already checked anyway, and the other is changed to check. https://bugs.freedesktop.org/show_bug.cgi?id=68592 https://bugs.gentoo.org/show_bug.cgi?id=481554
2013-09-12 03:50:16 +02:00
Tighten checking for variable validity In the future we might want to allow additional syntax (for example "unset VAR". But let's check that the data we're getting does not contain anything unexpected.
2017-02-18 04:56:28 +01:00
static void test_merge_env_file_invalid(void) {
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
_cleanup_(unlink_tempfilep) char t[] = "/tmp/test-fileio-XXXXXX";
test-fileio: close two leaked file handles
2017-09-24 08:59:49 +02:00
_cleanup_fclose_ FILE *f = NULL;
Tighten checking for variable validity In the future we might want to allow additional syntax (for example "unset VAR". But let's check that the data we're getting does not contain anything unexpected.
2017-02-18 04:56:28 +01:00
_cleanup_strv_free_ char **a = NULL;
char **i;
Introduce fmkostemp_safe and use it in tests No functional change.
2018-10-23 10:50:09 +02:00
int r;
Tighten checking for variable validity In the future we might want to allow additional syntax (for example "unset VAR". But let's check that the data we're getting does not contain anything unexpected.
2017-02-18 04:56:28 +01:00
Introduce fmkostemp_safe and use it in tests No functional change.
2018-10-23 10:50:09 +02:00
assert_se(fmkostemp_safe(t, "w", &f) == 0);
Tighten checking for variable validity In the future we might want to allow additional syntax (for example "unset VAR". But let's check that the data we're getting does not contain anything unexpected.
2017-02-18 04:56:28 +01:00
log_info("/* %s (%s) */", __func__, t);
r = write_string_stream(f,
"unset one \n"
"unset one= \n"
"unset one=1 \n"
"one \n"
"one = \n"
"one two =\n"
"\x20two=\n"
"#comment=comment\n"
";comment2=comment2\n"
"#\n"
"\n\n" /* empty line */
fileio: make write_string_stream() accept flags parameter Let's make write_string_stream() and write_string_file() more alike, and pass the same flag set so that we can remove a number of boolean parameters.
2017-09-22 20:55:34 +02:00
, WRITE_STRING_FILE_AVOID_NEWLINE);
Tighten checking for variable validity In the future we might want to allow additional syntax (for example "unset VAR". But let's check that the data we're getting does not contain anything unexpected.
2017-02-18 04:56:28 +01:00
assert(r >= 0);
r = merge_env_file(&a, NULL, t);
assert_se(r >= 0);
STRV_FOREACH(i, a)
log_info("Got: <%s>", *i);
assert_se(strv_isempty(a));
}
journalctl: use _COMM= match for scripts In case of scripts, _EXE is set to the interpreter name, and _COMM is set based on the file name. Add a match for _COMM, and _EXE if the interpreter is not a link (e.g. for yum, the interpreter is /usr/bin/python, but it is a link to /usr/bin/python2, which in turn is a link to /usr/bin/python2.7, at least on Fedora, so we end up with _EXE=/usr/bin/python2.7). I don't think that such link chasing makes sense, because the final _EXE name is more likely to change.
2013-07-19 10:02:50 +02:00
static void test_executable_is_script(void) {
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
_cleanup_(unlink_tempfilep) char t[] = "/tmp/test-fileio-XXXXXX";
_cleanup_fclose_ FILE *f = NULL;
journalctl: use _COMM= match for scripts In case of scripts, _EXE is set to the interpreter name, and _COMM is set based on the file name. Add a match for _COMM, and _EXE if the interpreter is not a link (e.g. for yum, the interpreter is /usr/bin/python, but it is a link to /usr/bin/python2, which in turn is a link to /usr/bin/python2.7, at least on Fedora, so we end up with _EXE=/usr/bin/python2.7). I don't think that such link chasing makes sense, because the final _EXE name is more likely to change.
2013-07-19 10:02:50 +02:00
char *command;
Introduce fmkostemp_safe and use it in tests No functional change.
2018-10-23 10:50:09 +02:00
int r;
journalctl: use _COMM= match for scripts In case of scripts, _EXE is set to the interpreter name, and _COMM is set based on the file name. Add a match for _COMM, and _EXE if the interpreter is not a link (e.g. for yum, the interpreter is /usr/bin/python, but it is a link to /usr/bin/python2, which in turn is a link to /usr/bin/python2.7, at least on Fedora, so we end up with _EXE=/usr/bin/python2.7). I don't think that such link chasing makes sense, because the final _EXE name is more likely to change.
2013-07-19 10:02:50 +02:00
Introduce fmkostemp_safe and use it in tests No functional change.
2018-10-23 10:50:09 +02:00
assert_se(fmkostemp_safe(t, "w", &f) == 0);
journalctl: use _COMM= match for scripts In case of scripts, _EXE is set to the interpreter name, and _COMM is set based on the file name. Add a match for _COMM, and _EXE if the interpreter is not a link (e.g. for yum, the interpreter is /usr/bin/python, but it is a link to /usr/bin/python2, which in turn is a link to /usr/bin/python2.7, at least on Fedora, so we end up with _EXE=/usr/bin/python2.7). I don't think that such link chasing makes sense, because the final _EXE name is more likely to change.
2013-07-19 10:02:50 +02:00
fputs("#! /bin/script -a -b \ngoo goo", f);
fflush(f);
r = executable_is_script(t, &command);
assert_se(r > 0);
assert_se(streq(command, "/bin/script"));
free(command);
r = executable_is_script("/bin/sh", &command);
assert_se(r == 0);
r = executable_is_script("/usr/bin/yum", &command);
assert_se(r > 0 || r == -ENOENT);
if (r > 0) {
assert_se(startswith(command, "/"));
free(command);
}
}
Advertise hibernation only if there's enough free swap Condition that is checked is taken from upower: active(anon) < free swap * 0.98 This is really stupid, because the kernel knows the situation better, e.g. there could be two swap files, and then hibernation would be impossible despite passing this check, or the kernel could start supporting compressed swap and/or compressed hibernation images, and then this this check would be too stringent. Nevertheless, until we have something better, this should at least return a true negative if there's no swap. Logging of capabilities in the journal is changed to not strip leading zeros. I consider this more readable anyway. http://cgit.freedesktop.org/upower/tree/src/up-daemon.c#n613 https://bugzilla.redhat.com/show_bug.cgi?id=1007059
2013-09-14 01:41:52 +02:00
static void test_status_field(void) {
Add more tests and fix capability logging
2013-09-19 23:22:59 +02:00
_cleanup_free_ char *t = NULL, *p = NULL, *s = NULL, *z = NULL;
unsigned long long total = 0, buffers = 0;
Assume that /proc/meminfo can be missing Travis tests are failing, probably because /proc/meminfo is not available in the test environment. The same might be true in some virtualized systems, so just treat missing /proc/meminfo as a sign that hibernation is not possible.
2013-09-15 14:40:16 +02:00
int r;
Advertise hibernation only if there's enough free swap Condition that is checked is taken from upower: active(anon) < free swap * 0.98 This is really stupid, because the kernel knows the situation better, e.g. there could be two swap files, and then hibernation would be impossible despite passing this check, or the kernel could start supporting compressed swap and/or compressed hibernation images, and then this this check would be too stringent. Nevertheless, until we have something better, this should at least return a true negative if there's no swap. Logging of capabilities in the journal is changed to not strip leading zeros. I consider this more readable anyway. http://cgit.freedesktop.org/upower/tree/src/up-daemon.c#n613 https://bugzilla.redhat.com/show_bug.cgi?id=1007059
2013-09-14 01:41:52 +02:00
fileio: make get_status_field() more generic All users of get_status_field() expect the field pattern to occur in the beginning of a line, and the delimiter is ':'. Hardcode this into the function, and also skip any whitespace before ':' to support fields in files like /proc/cpuinfo. Add support for returning the full field value (currently stops on first whitespace). Rename the function so it's easier to ensure all callers switch to new semantics.
2015-09-30 14:57:55 +02:00
assert_se(get_proc_field("/proc/self/status", "Threads", WHITESPACE, &t) == 0);
Advertise hibernation only if there's enough free swap Condition that is checked is taken from upower: active(anon) < free swap * 0.98 This is really stupid, because the kernel knows the situation better, e.g. there could be two swap files, and then hibernation would be impossible despite passing this check, or the kernel could start supporting compressed swap and/or compressed hibernation images, and then this this check would be too stringent. Nevertheless, until we have something better, this should at least return a true negative if there's no swap. Logging of capabilities in the journal is changed to not strip leading zeros. I consider this more readable anyway. http://cgit.freedesktop.org/upower/tree/src/up-daemon.c#n613 https://bugzilla.redhat.com/show_bug.cgi?id=1007059
2013-09-14 01:41:52 +02:00
puts(t);
assert_se(streq(t, "1"));
fileio: make get_status_field() more generic All users of get_status_field() expect the field pattern to occur in the beginning of a line, and the delimiter is ':'. Hardcode this into the function, and also skip any whitespace before ':' to support fields in files like /proc/cpuinfo. Add support for returning the full field value (currently stops on first whitespace). Rename the function so it's easier to ensure all callers switch to new semantics.
2015-09-30 14:57:55 +02:00
r = get_proc_field("/proc/meminfo", "MemTotal", WHITESPACE, &p);
Add more tests and fix capability logging
2013-09-19 23:22:59 +02:00
if (r != -ENOENT) {
test: only use assert_se The asserts used in the tests should never be allowed to be optimized away
2014-10-04 23:51:45 +02:00
assert_se(r == 0);
Add more tests and fix capability logging
2013-09-19 23:22:59 +02:00
puts(p);
assert_se(safe_atollu(p, &total) == 0);
}
Advertise hibernation only if there's enough free swap Condition that is checked is taken from upower: active(anon) < free swap * 0.98 This is really stupid, because the kernel knows the situation better, e.g. there could be two swap files, and then hibernation would be impossible despite passing this check, or the kernel could start supporting compressed swap and/or compressed hibernation images, and then this this check would be too stringent. Nevertheless, until we have something better, this should at least return a true negative if there's no swap. Logging of capabilities in the journal is changed to not strip leading zeros. I consider this more readable anyway. http://cgit.freedesktop.org/upower/tree/src/up-daemon.c#n613 https://bugzilla.redhat.com/show_bug.cgi?id=1007059
2013-09-14 01:41:52 +02:00
fileio: make get_status_field() more generic All users of get_status_field() expect the field pattern to occur in the beginning of a line, and the delimiter is ':'. Hardcode this into the function, and also skip any whitespace before ':' to support fields in files like /proc/cpuinfo. Add support for returning the full field value (currently stops on first whitespace). Rename the function so it's easier to ensure all callers switch to new semantics.
2015-09-30 14:57:55 +02:00
r = get_proc_field("/proc/meminfo", "Buffers", WHITESPACE, &s);
Add more tests and fix capability logging
2013-09-19 23:22:59 +02:00
if (r != -ENOENT) {
test: only use assert_se The asserts used in the tests should never be allowed to be optimized away
2014-10-04 23:51:45 +02:00
assert_se(r == 0);
Add more tests and fix capability logging
2013-09-19 23:22:59 +02:00
puts(s);
assert_se(safe_atollu(s, &buffers) == 0);
}
Advertise hibernation only if there's enough free swap Condition that is checked is taken from upower: active(anon) < free swap * 0.98 This is really stupid, because the kernel knows the situation better, e.g. there could be two swap files, and then hibernation would be impossible despite passing this check, or the kernel could start supporting compressed swap and/or compressed hibernation images, and then this this check would be too stringent. Nevertheless, until we have something better, this should at least return a true negative if there's no swap. Logging of capabilities in the journal is changed to not strip leading zeros. I consider this more readable anyway. http://cgit.freedesktop.org/upower/tree/src/up-daemon.c#n613 https://bugzilla.redhat.com/show_bug.cgi?id=1007059
2013-09-14 01:41:52 +02:00
test-fileio: Remove dead check t cannot be null here
2014-09-30 23:37:10 +02:00
if (p)
test: only use assert_se The asserts used in the tests should never be allowed to be optimized away
2014-10-04 23:51:45 +02:00
assert_se(buffers < total);
Add more tests and fix capability logging
2013-09-19 23:22:59 +02:00
/* Seccomp should be a good test for field full of zeros. */
fileio: make get_status_field() more generic All users of get_status_field() expect the field pattern to occur in the beginning of a line, and the delimiter is ':'. Hardcode this into the function, and also skip any whitespace before ':' to support fields in files like /proc/cpuinfo. Add support for returning the full field value (currently stops on first whitespace). Rename the function so it's easier to ensure all callers switch to new semantics.
2015-09-30 14:57:55 +02:00
r = get_proc_field("/proc/meminfo", "Seccomp", WHITESPACE, &z);
Add more tests and fix capability logging
2013-09-19 23:22:59 +02:00
if (r != -ENOENT) {
test: only use assert_se The asserts used in the tests should never be allowed to be optimized away
2014-10-04 23:51:45 +02:00
assert_se(r == 0);
Add more tests and fix capability logging
2013-09-19 23:22:59 +02:00
puts(z);
assert_se(safe_atollu(z, &buffers) == 0);
}
}
static void test_capeff(void) {
int pid, p;
for (pid = 0; pid < 2; pid++) {
_cleanup_free_ char *capeff = NULL;
int r;
r = get_process_capeff(0, &capeff);
log_info("capeff: '%s' (r=%d)", capeff, r);
tree-wide: use IN_SET macro (#6977)
2017-10-04 16:01:32 +02:00
if (IN_SET(r, -ENOENT, -EPERM))
Add more tests and fix capability logging
2013-09-19 23:22:59 +02:00
return;
test: only use assert_se The asserts used in the tests should never be allowed to be optimized away
2014-10-04 23:51:45 +02:00
assert_se(r == 0);
assert_se(*capeff);
basic: define HEXDIGITS define HEXDIGITS alongside DIGITS, and use it where it's already useful. We'll use it again shortly when parsing MAC addresses.
2016-05-17 15:44:32 +02:00
p = capeff[strspn(capeff, HEXDIGITS)];
test: only use assert_se The asserts used in the tests should never be allowed to be optimized away
2014-10-04 23:51:45 +02:00
assert_se(!p || isspace(p));
Add more tests and fix capability logging
2013-09-19 23:22:59 +02:00
}
Advertise hibernation only if there's enough free swap Condition that is checked is taken from upower: active(anon) < free swap * 0.98 This is really stupid, because the kernel knows the situation better, e.g. there could be two swap files, and then hibernation would be impossible despite passing this check, or the kernel could start supporting compressed swap and/or compressed hibernation images, and then this this check would be too stringent. Nevertheless, until we have something better, this should at least return a true negative if there's no swap. Logging of capabilities in the journal is changed to not strip leading zeros. I consider this more readable anyway. http://cgit.freedesktop.org/upower/tree/src/up-daemon.c#n613 https://bugzilla.redhat.com/show_bug.cgi?id=1007059
2013-09-14 01:41:52 +02:00
}
tests: add tests for fileio.c add tests for: - write_string_stream - write_string_file - sendfile_full
2014-08-16 14:19:07 +02:00
static void test_write_string_stream(void) {
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-write_string_stream-XXXXXX";
_cleanup_fclose_ FILE *f = NULL;
tests: add tests for fileio.c add tests for: - write_string_stream - write_string_file - sendfile_full
2014-08-16 14:19:07 +02:00
int fd;
char buf[64];
fileio: simplify mkostemp_safe() (#4090) According to its manual page, flags given to mkostemp(3) shouldn't include O_RDWR, O_CREAT or O_EXCL flags as these are always included. Beyond those, the only flag that all callers (except a few tests where it probably doesn't matter) use is O_CLOEXEC, so set that unconditionally.
2016-09-13 08:20:38 +02:00
fd = mkostemp_safe(fn);
tests: add tests for fileio.c add tests for: - write_string_stream - write_string_file - sendfile_full
2014-08-16 14:19:07 +02:00
assert_se(fd >= 0);
f = fdopen(fd, "r");
assert_se(f);
fileio: make write_string_stream() accept flags parameter Let's make write_string_stream() and write_string_file() more alike, and pass the same flag set so that we can remove a number of boolean parameters.
2017-09-22 20:55:34 +02:00
assert_se(write_string_stream(f, "boohoo", 0) < 0);
tests: stop using `freopen` in `test-fileio` This helps get around a bug confusing `glibc` and making the test bail out with the following error under `asan` on `x86`: Fatal error: glibc detected an invalid stdio handle Aborted (core dumped) The bug has been reported in https://github.com/google/sanitizers/issues/778, but it is unlikely to be fixed anytime soon.
2018-03-05 22:23:33 +01:00
f = safe_fclose(f);
tests: add tests for fileio.c add tests for: - write_string_stream - write_string_file - sendfile_full
2014-08-16 14:19:07 +02:00
tests: stop using `freopen` in `test-fileio` This helps get around a bug confusing `glibc` and making the test bail out with the following error under `asan` on `x86`: Fatal error: glibc detected an invalid stdio handle Aborted (core dumped) The bug has been reported in https://github.com/google/sanitizers/issues/778, but it is unlikely to be fixed anytime soon.
2018-03-05 22:23:33 +01:00
f = fopen(fn, "r+");
tests: add tests for fileio.c add tests for: - write_string_stream - write_string_file - sendfile_full
2014-08-16 14:19:07 +02:00
assert_se(f);
fileio: make write_string_stream() accept flags parameter Let's make write_string_stream() and write_string_file() more alike, and pass the same flag set so that we can remove a number of boolean parameters.
2017-09-22 20:55:34 +02:00
assert_se(write_string_stream(f, "boohoo", 0) == 0);
tests: add tests for fileio.c add tests for: - write_string_stream - write_string_file - sendfile_full
2014-08-16 14:19:07 +02:00
rewind(f);
assert_se(fgets(buf, sizeof(buf), f));
assert_se(streq(buf, "boohoo\n"));
tests: stop using `freopen` in `test-fileio` This helps get around a bug confusing `glibc` and making the test bail out with the following error under `asan` on `x86`: Fatal error: glibc detected an invalid stdio handle Aborted (core dumped) The bug has been reported in https://github.com/google/sanitizers/issues/778, but it is unlikely to be fixed anytime soon.
2018-03-05 22:23:33 +01:00
f = safe_fclose(f);
tests: add tests for fileio.c add tests for: - write_string_stream - write_string_file - sendfile_full
2014-08-16 14:19:07 +02:00
tests: stop using `freopen` in `test-fileio` This helps get around a bug confusing `glibc` and making the test bail out with the following error under `asan` on `x86`: Fatal error: glibc detected an invalid stdio handle Aborted (core dumped) The bug has been reported in https://github.com/google/sanitizers/issues/778, but it is unlikely to be fixed anytime soon.
2018-03-05 22:23:33 +01:00
f = fopen(fn, "w+");
fileio: add 'enforce_newline' argument to write_string_stream() Add a flag to control whether write_string_stream() should always enforce a trailing newline character in the file.
2015-07-06 23:31:44 +02:00
assert_se(f);
fileio: make write_string_stream() accept flags parameter Let's make write_string_stream() and write_string_file() more alike, and pass the same flag set so that we can remove a number of boolean parameters.
2017-09-22 20:55:34 +02:00
assert_se(write_string_stream(f, "boohoo", WRITE_STRING_FILE_AVOID_NEWLINE) == 0);
fileio: add 'enforce_newline' argument to write_string_stream() Add a flag to control whether write_string_stream() should always enforce a trailing newline character in the file.
2015-07-06 23:31:44 +02:00
rewind(f);
assert_se(fgets(buf, sizeof(buf), f));
printf(">%s<", buf);
assert_se(streq(buf, "boohoo"));
tests: add tests for fileio.c add tests for: - write_string_stream - write_string_file - sendfile_full
2014-08-16 14:19:07 +02:00
}
static void test_write_string_file(void) {
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-write_string_file-XXXXXX";
tests: fix resource & mem leaks
2014-09-18 12:09:10 +02:00
char buf[64] = {};
_cleanup_close_ int fd;
tests: add tests for fileio.c add tests for: - write_string_stream - write_string_file - sendfile_full
2014-08-16 14:19:07 +02:00
fileio: simplify mkostemp_safe() (#4090) According to its manual page, flags given to mkostemp(3) shouldn't include O_RDWR, O_CREAT or O_EXCL flags as these are always included. Beyond those, the only flag that all callers (except a few tests where it probably doesn't matter) use is O_CLOEXEC, so set that unconditionally.
2016-09-13 08:20:38 +02:00
fd = mkostemp_safe(fn);
tests: add tests for fileio.c add tests for: - write_string_stream - write_string_file - sendfile_full
2014-08-16 14:19:07 +02:00
assert_se(fd >= 0);
fileio: consolidate write_string_file*() Merge write_string_file(), write_string_file_no_create() and write_string_file_atomic() into write_string_file() and provide a flags mask that allows combinations of atomic writing, newline appending and automatic file creation. Change all users accordingly.
2015-07-07 01:19:25 +02:00
assert_se(write_string_file(fn, "boohoo", WRITE_STRING_FILE_CREATE) == 0);
tests: add tests for fileio.c add tests for: - write_string_stream - write_string_file - sendfile_full
2014-08-16 14:19:07 +02:00
test: silence a coverity report We check the actual contents of the file on the line after but we might as well also check the number of bytes read here. Found by coverity. Fixes: CID#1237521
2014-09-16 21:59:50 +02:00
assert_se(read(fd, buf, sizeof(buf)) == 7);
tests: add tests for fileio.c add tests for: - write_string_stream - write_string_file - sendfile_full
2014-08-16 14:19:07 +02:00
assert_se(streq(buf, "boohoo\n"));
}
tests: add tests for fileio.c add tests for the following functions: - write_string_file_no_create - load_env_file_pairs
2014-09-02 18:55:31 +02:00
static void test_write_string_file_no_create(void) {
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-write_string_file_no_create-XXXXXX";
tests: add tests for fileio.c add tests for the following functions: - write_string_file_no_create - load_env_file_pairs
2014-09-02 18:55:31 +02:00
_cleanup_close_ int fd;
test: minor modernization Coverity was complaining that read() does not terminate the data. But we did that termination earlier, so covirity is wrong (CID#1402306, CID#1402340). Let's modernize the style a bit nevertheless. (size_t) cast is needed to avoid the warning about comparison, iff the value is not a constant.
2019-07-11 07:54:04 +02:00
char buf[64] = {};
tests: add tests for fileio.c add tests for the following functions: - write_string_file_no_create - load_env_file_pairs
2014-09-02 18:55:31 +02:00
fileio: simplify mkostemp_safe() (#4090) According to its manual page, flags given to mkostemp(3) shouldn't include O_RDWR, O_CREAT or O_EXCL flags as these are always included. Beyond those, the only flag that all callers (except a few tests where it probably doesn't matter) use is O_CLOEXEC, so set that unconditionally.
2016-09-13 08:20:38 +02:00
fd = mkostemp_safe(fn);
tests: add tests for fileio.c add tests for the following functions: - write_string_file_no_create - load_env_file_pairs
2014-09-02 18:55:31 +02:00
assert_se(fd >= 0);
fileio: consolidate write_string_file*() Merge write_string_file(), write_string_file_no_create() and write_string_file_atomic() into write_string_file() and provide a flags mask that allows combinations of atomic writing, newline appending and automatic file creation. Change all users accordingly.
2015-07-07 01:19:25 +02:00
assert_se(write_string_file("/a/file/which/does/not/exists/i/guess", "boohoo", 0) < 0);
assert_se(write_string_file(fn, "boohoo", 0) == 0);
tests: add tests for fileio.c add tests for the following functions: - write_string_file_no_create - load_env_file_pairs
2014-09-02 18:55:31 +02:00
test: minor modernization Coverity was complaining that read() does not terminate the data. But we did that termination earlier, so covirity is wrong (CID#1402306, CID#1402340). Let's modernize the style a bit nevertheless. (size_t) cast is needed to avoid the warning about comparison, iff the value is not a constant.
2019-07-11 07:54:04 +02:00
assert_se(read(fd, buf, sizeof buf) == (ssize_t) strlen("boohoo\n"));
tests: add tests for fileio.c add tests for the following functions: - write_string_file_no_create - load_env_file_pairs
2014-09-02 18:55:31 +02:00
assert_se(streq(buf, "boohoo\n"));
}
util-lib: optionally, when writing a string to a file, verify string on failure With this change, the idiom: r = write_string_file(p, buf, 0); if (r < 0) { if (verify_one_line_file(p, buf) > 0) r = 0; } gets reduced to: r = write_string_file(p, buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE); i.e. when writing the string fails and the new flag WRITE_STRING_FILE_VERIFY_ON_FAILURE is specified we'll not return a failure immediately, but check the contents of the file. If it matches what we wanted to write we suppress the error and exit cleanly.
2015-11-13 00:54:56 +01:00
static void test_write_string_file_verify(void) {
_cleanup_free_ char *buf = NULL, *buf2 = NULL;
int r;
tests: various small fixes for strict systems Don't assume that 4MB can be allocated from stack since there could be smaller DefaultLimitSTACK= in force, so let's use malloc(). NUL terminate the huge strings by hand, also ensure termination in test_lz4_decompress_partial() and optimize the memset() for the string. Some items in /proc and /etc may not be accessible to poor unprivileged users due to e.g. SELinux, BOFH or both, so check for EACCES and EPERM. /var/tmp may be a symlink to /tmp and then path_compare() will always fail, so let's stick to /tmp like elsewhere. /tmp may be mounted with noexec option and then trying to execute scripts from there would fail. Detect and warn if seccomp is already in use, which could make seccomp test fail if the syscalls are already blocked. Unset $TMPDIR so it will not break specifier tests where %T is assumed to be /tmp and %V /var/tmp.
2020-04-23 12:12:23 +02:00
r = read_one_line_file("/proc/version", &buf);
if (ERRNO_IS_PRIVILEGE(r))
return;
assert_se(r >= 0);
tree-wide: do not wrap assert_se in extra parentheses We were inconsitently using them in some cases, but in majority not. Using assignment in assert_se is very common, not an exception like in 'if', so let's drop the extra parens everywhere.
2018-05-14 09:12:12 +02:00
assert_se(buf2 = strjoin(buf, "\n"));
util-lib: optionally, when writing a string to a file, verify string on failure With this change, the idiom: r = write_string_file(p, buf, 0); if (r < 0) { if (verify_one_line_file(p, buf) > 0) r = 0; } gets reduced to: r = write_string_file(p, buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE); i.e. when writing the string fails and the new flag WRITE_STRING_FILE_VERIFY_ON_FAILURE is specified we'll not return a failure immediately, but check the contents of the file. If it matches what we wanted to write we suppress the error and exit cleanly.
2015-11-13 00:54:56 +01:00
test-fileio: fix bogus error when /proc/cmdline contains newlines The kernel does not sanitize /proc/cmdline. E.g. when running under qemu, it is easy to pass a string with newline by mistake. We use read_one_line_file(), so we would read only the first list of the file, and write_string_file(WRITE_STRING_FILE_VERIFY_ON_FAILURE) would fail because the target file is obviously different. Change to a kernel-generated file to avoid the issue. v2: - use /proc/version instead of /proc/uptime for attempted writes, so the test test passes even if test_write_string_file_verify() takes more than 10 ms ;]
2019-12-13 12:21:11 +01:00
r = write_string_file("/proc/version", buf, 0);
tree-wide: use IN_SET macro (#6977)
2017-10-04 16:01:32 +02:00
assert_se(IN_SET(r, -EACCES, -EIO));
test-fileio: fix bogus error when /proc/cmdline contains newlines The kernel does not sanitize /proc/cmdline. E.g. when running under qemu, it is easy to pass a string with newline by mistake. We use read_one_line_file(), so we would read only the first list of the file, and write_string_file(WRITE_STRING_FILE_VERIFY_ON_FAILURE) would fail because the target file is obviously different. Change to a kernel-generated file to avoid the issue. v2: - use /proc/version instead of /proc/uptime for attempted writes, so the test test passes even if test_write_string_file_verify() takes more than 10 ms ;]
2019-12-13 12:21:11 +01:00
r = write_string_file("/proc/version", buf2, 0);
tree-wide: use IN_SET macro (#6977)
2017-10-04 16:01:32 +02:00
assert_se(IN_SET(r, -EACCES, -EIO));
util-lib: optionally, when writing a string to a file, verify string on failure With this change, the idiom: r = write_string_file(p, buf, 0); if (r < 0) { if (verify_one_line_file(p, buf) > 0) r = 0; } gets reduced to: r = write_string_file(p, buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE); i.e. when writing the string fails and the new flag WRITE_STRING_FILE_VERIFY_ON_FAILURE is specified we'll not return a failure immediately, but check the contents of the file. If it matches what we wanted to write we suppress the error and exit cleanly.
2015-11-13 00:54:56 +01:00
test-fileio: fix bogus error when /proc/cmdline contains newlines The kernel does not sanitize /proc/cmdline. E.g. when running under qemu, it is easy to pass a string with newline by mistake. We use read_one_line_file(), so we would read only the first list of the file, and write_string_file(WRITE_STRING_FILE_VERIFY_ON_FAILURE) would fail because the target file is obviously different. Change to a kernel-generated file to avoid the issue. v2: - use /proc/version instead of /proc/uptime for attempted writes, so the test test passes even if test_write_string_file_verify() takes more than 10 ms ;]
2019-12-13 12:21:11 +01:00
assert_se(write_string_file("/proc/version", buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE) == 0);
assert_se(write_string_file("/proc/version", buf2, WRITE_STRING_FILE_VERIFY_ON_FAILURE) == 0);
util-lib: optionally, when writing a string to a file, verify string on failure With this change, the idiom: r = write_string_file(p, buf, 0); if (r < 0) { if (verify_one_line_file(p, buf) > 0) r = 0; } gets reduced to: r = write_string_file(p, buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE); i.e. when writing the string fails and the new flag WRITE_STRING_FILE_VERIFY_ON_FAILURE is specified we'll not return a failure immediately, but check the contents of the file. If it matches what we wanted to write we suppress the error and exit cleanly.
2015-11-13 00:54:56 +01:00
test-fileio: fix bogus error when /proc/cmdline contains newlines The kernel does not sanitize /proc/cmdline. E.g. when running under qemu, it is easy to pass a string with newline by mistake. We use read_one_line_file(), so we would read only the first list of the file, and write_string_file(WRITE_STRING_FILE_VERIFY_ON_FAILURE) would fail because the target file is obviously different. Change to a kernel-generated file to avoid the issue. v2: - use /proc/version instead of /proc/uptime for attempted writes, so the test test passes even if test_write_string_file_verify() takes more than 10 ms ;]
2019-12-13 12:21:11 +01:00
r = write_string_file("/proc/version", buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE|WRITE_STRING_FILE_AVOID_NEWLINE);
tree-wide: use IN_SET macro (#6977)
2017-10-04 16:01:32 +02:00
assert_se(IN_SET(r, -EACCES, -EIO));
test-fileio: fix bogus error when /proc/cmdline contains newlines The kernel does not sanitize /proc/cmdline. E.g. when running under qemu, it is easy to pass a string with newline by mistake. We use read_one_line_file(), so we would read only the first list of the file, and write_string_file(WRITE_STRING_FILE_VERIFY_ON_FAILURE) would fail because the target file is obviously different. Change to a kernel-generated file to avoid the issue. v2: - use /proc/version instead of /proc/uptime for attempted writes, so the test test passes even if test_write_string_file_verify() takes more than 10 ms ;]
2019-12-13 12:21:11 +01:00
assert_se(write_string_file("/proc/version", buf2, WRITE_STRING_FILE_VERIFY_ON_FAILURE|WRITE_STRING_FILE_AVOID_NEWLINE) == 0);
util-lib: optionally, when writing a string to a file, verify string on failure With this change, the idiom: r = write_string_file(p, buf, 0); if (r < 0) { if (verify_one_line_file(p, buf) > 0) r = 0; } gets reduced to: r = write_string_file(p, buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE); i.e. when writing the string fails and the new flag WRITE_STRING_FILE_VERIFY_ON_FAILURE is specified we'll not return a failure immediately, but check the contents of the file. If it matches what we wanted to write we suppress the error and exit cleanly.
2015-11-13 00:54:56 +01:00
}
tests: add tests for fileio.c add tests for the following functions: - write_string_file_no_create - load_env_file_pairs
2014-09-02 18:55:31 +02:00
static void test_load_env_file_pairs(void) {
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-load_env_file_pairs-XXXXXX";
int fd, r;
tests: add tests for fileio.c add tests for the following functions: - write_string_file_no_create - load_env_file_pairs
2014-09-02 18:55:31 +02:00
_cleanup_fclose_ FILE *f = NULL;
_cleanup_strv_free_ char **l = NULL;
char **k, **v;
fileio: simplify mkostemp_safe() (#4090) According to its manual page, flags given to mkostemp(3) shouldn't include O_RDWR, O_CREAT or O_EXCL flags as these are always included. Beyond those, the only flag that all callers (except a few tests where it probably doesn't matter) use is O_CLOEXEC, so set that unconditionally.
2016-09-13 08:20:38 +02:00
fd = mkostemp_safe(fn);
tests: add tests for fileio.c add tests for the following functions: - write_string_file_no_create - load_env_file_pairs
2014-09-02 18:55:31 +02:00
assert_se(fd >= 0);
r = write_string_file(fn,
"NAME=\"Arch Linux\"\n"
"ID=arch\n"
"PRETTY_NAME=\"Arch Linux\"\n"
"ANSI_COLOR=\"0;36\"\n"
"HOME_URL=\"https://www.archlinux.org/\"\n"
"SUPPORT_URL=\"https://bbs.archlinux.org/\"\n"
fileio: consolidate write_string_file*() Merge write_string_file(), write_string_file_no_create() and write_string_file_atomic() into write_string_file() and provide a flags mask that allows combinations of atomic writing, newline appending and automatic file creation. Change all users accordingly.
2015-07-07 01:19:25 +02:00
"BUG_REPORT_URL=\"https://bugs.archlinux.org/\"\n",
WRITE_STRING_FILE_CREATE);
tests: add tests for fileio.c add tests for the following functions: - write_string_file_no_create - load_env_file_pairs
2014-09-02 18:55:31 +02:00
assert_se(r == 0);
f = fdopen(fd, "r");
assert_se(f);
fileio: drop "newline" parameter for env file parsers Now that we don't (mis-)use the env file parser to parse kernel command lines there's no need anymore to override the used newline character set. Let's hence drop the argument and just "\n\r" always. This nicely simplifies our code.
2018-11-12 14:04:47 +01:00
r = load_env_file_pairs(f, fn, &l);
tests: add tests for fileio.c add tests for the following functions: - write_string_file_no_create - load_env_file_pairs
2014-09-02 18:55:31 +02:00
assert_se(r >= 0);
assert_se(strv_length(l) == 14);
STRV_FOREACH_PAIR(k, v, l) {
assert_se(STR_IN_SET(*k, "NAME", "ID", "PRETTY_NAME", "ANSI_COLOR", "HOME_URL", "SUPPORT_URL", "BUG_REPORT_URL"));
printf("%s=%s\n", *k, *v);
if (streq(*k, "NAME")) assert_se(streq(*v, "Arch Linux"));
if (streq(*k, "ID")) assert_se(streq(*v, "arch"));
if (streq(*k, "PRETTY_NAME")) assert_se(streq(*v, "Arch Linux"));
if (streq(*k, "ANSI_COLOR")) assert_se(streq(*v, "0;36"));
if (streq(*k, "HOME_URL")) assert_se(streq(*v, "https://www.archlinux.org/"));
if (streq(*k, "SUPPORT_URL")) assert_se(streq(*v, "https://bbs.archlinux.org/"));
if (streq(*k, "BUG_REPORT_URL")) assert_se(streq(*v, "https://bugs.archlinux.org/"));
}
}
tests: move fileio related tests to test-fileio.c
2016-03-02 23:50:21 +01:00
static void test_search_and_fopen(void) {
const char *dirs[] = {"/tmp/foo/bar", "/tmp", NULL};
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
tests: move fileio related tests to test-fileio.c
2016-03-02 23:50:21 +01:00
char name[] = "/tmp/test-search_and_fopen.XXXXXX";
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
int fd, r;
tests: move fileio related tests to test-fileio.c
2016-03-02 23:50:21 +01:00
FILE *f;
fileio: simplify mkostemp_safe() (#4090) According to its manual page, flags given to mkostemp(3) shouldn't include O_RDWR, O_CREAT or O_EXCL flags as these are always included. Beyond those, the only flag that all callers (except a few tests where it probably doesn't matter) use is O_CLOEXEC, so set that unconditionally.
2016-09-13 08:20:38 +02:00
fd = mkostemp_safe(name);
tests: move fileio related tests to test-fileio.c
2016-03-02 23:50:21 +01:00
assert_se(fd >= 0);
close(fd);
r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
assert_se(r >= 0);
fclose(f);
r = search_and_fopen(name, "r", NULL, dirs, &f);
assert_se(r >= 0);
fclose(f);
r = search_and_fopen(basename(name), "r", "/", dirs, &f);
assert_se(r >= 0);
fclose(f);
r = search_and_fopen("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
assert_se(r < 0);
r = search_and_fopen("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
assert_se(r < 0);
r = unlink(name);
assert_se(r == 0);
r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
assert_se(r < 0);
}
static void test_search_and_fopen_nulstr(void) {
const char dirs[] = "/tmp/foo/bar\0/tmp\0";
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
_cleanup_(unlink_tempfilep) char name[] = "/tmp/test-search_and_fopen.XXXXXX";
int fd, r;
tests: move fileio related tests to test-fileio.c
2016-03-02 23:50:21 +01:00
FILE *f;
fileio: simplify mkostemp_safe() (#4090) According to its manual page, flags given to mkostemp(3) shouldn't include O_RDWR, O_CREAT or O_EXCL flags as these are always included. Beyond those, the only flag that all callers (except a few tests where it probably doesn't matter) use is O_CLOEXEC, so set that unconditionally.
2016-09-13 08:20:38 +02:00
fd = mkostemp_safe(name);
tests: move fileio related tests to test-fileio.c
2016-03-02 23:50:21 +01:00
assert_se(fd >= 0);
close(fd);
r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
assert_se(r >= 0);
fclose(f);
r = search_and_fopen_nulstr(name, "r", NULL, dirs, &f);
assert_se(r >= 0);
fclose(f);
r = search_and_fopen_nulstr("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
assert_se(r < 0);
r = search_and_fopen_nulstr("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
assert_se(r < 0);
r = unlink(name);
assert_se(r == 0);
r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
assert_se(r < 0);
}
static void test_writing_tmpfile(void) {
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
_cleanup_(unlink_tempfilep) char name[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
tests: move fileio related tests to test-fileio.c
2016-03-02 23:50:21 +01:00
_cleanup_free_ char *contents = NULL;
size_t size;
tests: close a leftover file descriptor in `test-fileio` This should make it a bit easier to search for real file descriptor leaks. ``` $ valgrind --leak-check=full --track-fds=yes ./build/test-fileio ... ==29457== ==29457== FILE DESCRIPTORS: 4 open at exit. ==29457== Open file descriptor 3: /tmp/test-systemd_writing_tmpfile.lyV5Rc ==29457== at 0x4B9AD9E: open (open.c:43) ==29457== by 0x4B19B24: __gen_tempname (tempname.c:261) ==29457== by 0x4BA5CC3: mkostemp64 (mkostemp64.c:32) ==29457== by 0x48F739B: mkostemp_safe (fileio.c:1206) ==29457== by 0x10D968: test_writing_tmpfile (test-fileio.c:620) ==29457== by 0x10E930: main (test-fileio.c:767) ==29457== ```
2018-03-05 23:05:46 +01:00
_cleanup_close_ int fd = -1;
tests: move fileio related tests to test-fileio.c
2016-03-02 23:50:21 +01:00
struct iovec iov[3];
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
int r;
tests: move fileio related tests to test-fileio.c
2016-03-02 23:50:21 +01:00
io-util: add new IOVEC_INIT/IOVEC_MAKE macros This adds IOVEC_INIT() and IOVEC_MAKE() for initializing iovec structures from a pointer and a size. On top of these IOVEC_INIT_STRING() and IOVEC_MAKE_STRING() are added which take a string and automatically determine the size of the string using strlen(). This patch removes the old IOVEC_SET_STRING() macro, given that IOVEC_MAKE_STRING() is now useful for similar purposes. Note that the old IOVEC_SET_STRING() invocations were two characters shorter than the new ones using IOVEC_MAKE_STRING(), but I think the new syntax is more readable and more generic as it simply resolves to a C99 literal structure initialization. Moreover, we can use very similar syntax now for initializing strings and pointer+size iovec entries. We canalso use the new macros to initialize function parameters on-the-fly or array definitions. And given that we shouldn't have so many ways to do the same stuff, let's just settle on the new macros. (This also converts some code to use _cleanup_ where dynamically allocated strings were using IOVEC_SET_STRING() before, to modernize things a bit)
2017-09-21 13:52:34 +02:00
iov[0] = IOVEC_MAKE_STRING("abc\n");
iov[1] = IOVEC_MAKE_STRING(ALPHANUMERICAL "\n");
iov[2] = IOVEC_MAKE_STRING("");
tests: move fileio related tests to test-fileio.c
2016-03-02 23:50:21 +01:00
fileio: simplify mkostemp_safe() (#4090) According to its manual page, flags given to mkostemp(3) shouldn't include O_RDWR, O_CREAT or O_EXCL flags as these are always included. Beyond those, the only flag that all callers (except a few tests where it probably doesn't matter) use is O_CLOEXEC, so set that unconditionally.
2016-09-13 08:20:38 +02:00
fd = mkostemp_safe(name);
tests: move fileio related tests to test-fileio.c
2016-03-02 23:50:21 +01:00
printf("tmpfile: %s", name);
r = writev(fd, iov, 3);
assert_se(r >= 0);
r = read_full_file(name, &contents, &size);
assert_se(r == 0);
printf("contents: %s", contents);
assert_se(streq(contents, "abc\n" ALPHANUMERICAL "\n"));
}
static void test_tempfn(void) {
char *ret = NULL, *p;
assert_se(tempfn_xxxxxx("/foo/bar/waldo", NULL, &ret) >= 0);
assert_se(streq_ptr(ret, "/foo/bar/.#waldoXXXXXX"));
free(ret);
assert_se(tempfn_xxxxxx("/foo/bar/waldo", "[miau]", &ret) >= 0);
assert_se(streq_ptr(ret, "/foo/bar/.#[miau]waldoXXXXXX"));
free(ret);
assert_se(tempfn_random("/foo/bar/waldo", NULL, &ret) >= 0);
assert_se(p = startswith(ret, "/foo/bar/.#waldo"));
assert_se(strlen(p) == 16);
assert_se(in_charset(p, "0123456789abcdef"));
free(ret);
assert_se(tempfn_random("/foo/bar/waldo", "[wuff]", &ret) >= 0);
assert_se(p = startswith(ret, "/foo/bar/.#[wuff]waldo"));
assert_se(strlen(p) == 16);
assert_se(in_charset(p, "0123456789abcdef"));
free(ret);
assert_se(tempfn_random_child("/foo/bar/waldo", NULL, &ret) >= 0);
assert_se(p = startswith(ret, "/foo/bar/waldo/.#"));
assert_se(strlen(p) == 16);
assert_se(in_charset(p, "0123456789abcdef"));
free(ret);
assert_se(tempfn_random_child("/foo/bar/waldo", "[kikiriki]", &ret) >= 0);
assert_se(p = startswith(ret, "/foo/bar/waldo/.#[kikiriki]"));
assert_se(strlen(p) == 16);
assert_se(in_charset(p, "0123456789abcdef"));
free(ret);
}
test-fileio: test safe_fgetc directly Non-ascii chars are used so that we get both "positive" and "negative" characters (on the arches where char is signed).
2018-12-18 13:27:59 +01:00
static const char chars[] =
test-fileio: add explicit check for safe_fgetc() with 0xFF
2018-12-20 11:21:36 +01:00
"Aąę„”\n루\377";
test-fileio: test safe_fgetc directly Non-ascii chars are used so that we get both "positive" and "negative" characters (on the arches where char is signed).
2018-12-18 13:27:59 +01:00
macro: introduce DISABLE_WARNING_TYPE_LIMITS and make use of it everywhere
2020-05-25 18:20:52 +02:00
DISABLE_WARNING_TYPE_LIMITS;
test-fileio: avoid warning about ineffective comparison On arm64 with gcc-8.2.1-5.fc29.aarch64: ../src/test/test-fileio.c:645:29: warning: comparison is always false due to limited range of data type [-Wtype-limits] assert_se(c == EOF || safe_fgetc(f, &c) == 1); ^~ Casting c to int is not enough, gcc is able to figure out that the original type was unsigned and still warns. So let's just silence the warning like in test-sizeof.c.
2019-03-20 13:43:35 +01:00
test-fileio: test safe_fgetc directly Non-ascii chars are used so that we get both "positive" and "negative" characters (on the arches where char is signed).
2018-12-18 13:27:59 +01:00
static void test_fgetc(void) {
_cleanup_fclose_ FILE *f = NULL;
char c;
Add fmemopen_unlocked() and use unlocked ops in fuzzers and some other tests This might make things marginially faster. I didn't benchmark though.
2019-04-04 12:24:38 +02:00
f = fmemopen_unlocked((void*) chars, sizeof(chars), "re");
test-fileio: test safe_fgetc directly Non-ascii chars are used so that we get both "positive" and "negative" characters (on the arches where char is signed).
2018-12-18 13:27:59 +01:00
assert_se(f);
test-fileio: cast EOF to (char) before comparing with char explicitly EOF is defined to -1, hence on platforms that have "char" unsigned we can't compare it as-is, except if we accept an implicit cast. let's make it an explicit cast, acknowledging the issue. Fixes: #14118
2019-11-25 15:15:38 +01:00
for (size_t i = 0; i < sizeof(chars); i++) {
test-fileio: test safe_fgetc directly Non-ascii chars are used so that we get both "positive" and "negative" characters (on the arches where char is signed).
2018-12-18 13:27:59 +01:00
assert_se(safe_fgetc(f, &c) == 1);
assert_se(c == chars[i]);
test-fileio: cast EOF to (char) before comparing with char explicitly EOF is defined to -1, hence on platforms that have "char" unsigned we can't compare it as-is, except if we accept an implicit cast. let's make it an explicit cast, acknowledging the issue. Fixes: #14118
2019-11-25 15:15:38 +01:00
if (ungetc(c, f) == EOF) {
/* EOF is -1, and hence we can't push value 255 in this way – if char is signed */
assert_se(c == (char) EOF);
assert_se(CHAR_MIN == -128); /* verify that char is signed on this platform */
} else {
assert_se(safe_fgetc(f, &c) == 1);
assert_se(c == chars[i]);
}
test-fileio: test safe_fgetc directly Non-ascii chars are used so that we get both "positive" and "negative" characters (on the arches where char is signed).
2018-12-18 13:27:59 +01:00
test-fileio: add explicit check for safe_fgetc() with 0xFF
2018-12-20 11:21:36 +01:00
/* But it works when we push it properly cast */
test-fileio: test safe_fgetc directly Non-ascii chars are used so that we get both "positive" and "negative" characters (on the arches where char is signed).
2018-12-18 13:27:59 +01:00
assert_se(ungetc((unsigned char) c, f) != EOF);
assert_se(safe_fgetc(f, &c) == 1);
assert_se(c == chars[i]);
}
assert_se(safe_fgetc(f, &c) == 0);
}
macro: introduce DISABLE_WARNING_TYPE_LIMITS and make use of it everywhere
2020-05-25 18:20:52 +02:00
REENABLE_WARNING;
test-fileio: avoid warning about ineffective comparison On arm64 with gcc-8.2.1-5.fc29.aarch64: ../src/test/test-fileio.c:645:29: warning: comparison is always false due to limited range of data type [-Wtype-limits] assert_se(c == EOF || safe_fgetc(f, &c) == 1); ^~ Casting c to int is not enough, gcc is able to figure out that the original type was unsigned and still warns. So let's just silence the warning like in test-sizeof.c.
2019-03-20 13:43:35 +01:00
test-fileio: also test read_line() with actual files Just in case the real FILE and the one from fmemopen weren't exactly the same.
2017-09-24 09:10:48 +02:00
static const char buffer[] =
"Some test data\n"
test-fileio: test safe_fgetc directly Non-ascii chars are used so that we get both "positive" and "negative" characters (on the arches where char is signed).
2018-12-18 13:27:59 +01:00
"루Non-ascii chars: ąę„”\n"
fileio: make read_line() handle various line endings correctly This adds support for windows line endings. More importantly though with this change a newline followed by EOF is considered a single line end.
2018-12-12 13:41:25 +01:00
"terminators\r\n"
"and even more\n\r"
"now the same with a NUL\n\0"
"and more\r\0"
"and even more\r\n\0"
"and yet even more\n\r\0"
test-fileio: also test read_line() with actual files Just in case the real FILE and the one from fmemopen weren't exactly the same.
2017-09-24 09:10:48 +02:00
"With newlines, and a NUL byte\0"
"\n"
"an empty line\n"
"an ignored line\n"
"and a very long line that is supposed to be truncated, because it is so long\n";
static void test_read_line_one_file(FILE *f) {
fileio: add new helper call read_line() as bounded getline() replacement read_line() is much like getline(), and returns a line read from a FILE*, of arbitrary sizes. In contrast to gets() it will grow the buffer dynamically, and in contrast to getline() it will place a user-specified boundary on the line.
2017-09-22 17:55:53 +02:00
_cleanup_free_ char *line = NULL;
assert_se(read_line(f, (size_t) -1, &line) == 15 && streq(line, "Some test data"));
line = mfree(line);
test-fileio: test safe_fgetc directly Non-ascii chars are used so that we get both "positive" and "negative" characters (on the arches where char is signed).
2018-12-18 13:27:59 +01:00
assert_se(read_line(f, (size_t) -1, &line) > 0 && streq(line, "루Non-ascii chars: ąę„”"));
fileio: make read_line() handle various line endings correctly This adds support for windows line endings. More importantly though with this change a newline followed by EOF is considered a single line end.
2018-12-12 13:41:25 +01:00
line = mfree(line);
assert_se(read_line(f, (size_t) -1, &line) == 13 && streq(line, "terminators"));
line = mfree(line);
assert_se(read_line(f, (size_t) -1, &line) == 15 && streq(line, "and even more"));
line = mfree(line);
assert_se(read_line(f, (size_t) -1, &line) == 25 && streq(line, "now the same with a NUL"));
line = mfree(line);
assert_se(read_line(f, (size_t) -1, &line) == 10 && streq(line, "and more"));
line = mfree(line);
assert_se(read_line(f, (size_t) -1, &line) == 16 && streq(line, "and even more"));
line = mfree(line);
assert_se(read_line(f, (size_t) -1, &line) == 20 && streq(line, "and yet even more"));
line = mfree(line);
fileio: add new helper call read_line() as bounded getline() replacement read_line() is much like getline(), and returns a line read from a FILE*, of arbitrary sizes. In contrast to gets() it will grow the buffer dynamically, and in contrast to getline() it will place a user-specified boundary on the line.
2017-09-22 17:55:53 +02:00
assert_se(read_line(f, 1024, &line) == 30 && streq(line, "With newlines, and a NUL byte"));
line = mfree(line);
assert_se(read_line(f, 1024, &line) == 1 && streq(line, ""));
line = mfree(line);
assert_se(read_line(f, 1024, &line) == 14 && streq(line, "an empty line"));
line = mfree(line);
assert_se(read_line(f, (size_t) -1, NULL) == 16);
assert_se(read_line(f, 16, &line) == -ENOBUFS);
line = mfree(line);
/* read_line() stopped when it hit the limit, that means when we continue reading we'll read at the first
codespell: fix spelling errors
2019-04-27 02:22:40 +02:00
* character after the previous limit. Let's make use of that to continue our test. */
fileio: make read_line() handle various line endings correctly This adds support for windows line endings. More importantly though with this change a newline followed by EOF is considered a single line end.
2018-12-12 13:41:25 +01:00
assert_se(read_line(f, 1024, &line) == 62 && streq(line, "line that is supposed to be truncated, because it is so long"));
fileio: add new helper call read_line() as bounded getline() replacement read_line() is much like getline(), and returns a line read from a FILE*, of arbitrary sizes. In contrast to gets() it will grow the buffer dynamically, and in contrast to getline() it will place a user-specified boundary on the line.
2017-09-22 17:55:53 +02:00
line = mfree(line);
assert_se(read_line(f, 1024, &line) == 0 && streq(line, ""));
}
test-fileio: also test read_line() with actual files Just in case the real FILE and the one from fmemopen weren't exactly the same.
2017-09-24 09:10:48 +02:00
static void test_read_line(void) {
_cleanup_fclose_ FILE *f = NULL;
Add fmemopen_unlocked() and use unlocked ops in fuzzers and some other tests This might make things marginially faster. I didn't benchmark though.
2019-04-04 12:24:38 +02:00
f = fmemopen_unlocked((void*) buffer, sizeof(buffer), "re");
test-fileio: also test read_line() with actual files Just in case the real FILE and the one from fmemopen weren't exactly the same.
2017-09-24 09:10:48 +02:00
assert_se(f);
test_read_line_one_file(f);
}
static void test_read_line2(void) {
fs-util,test: add helper to remove tempfiles This simplifies the use of tempfiles in tests and fixes "leaked" temporary files in test-fileio, test-catalog, test-conf-parser. Not the whole tree is converted.
2018-05-16 11:35:41 +02:00
_cleanup_(unlink_tempfilep) char name[] = "/tmp/test-fileio.XXXXXX";
test-fileio: also test read_line() with actual files Just in case the real FILE and the one from fmemopen weren't exactly the same.
2017-09-24 09:10:48 +02:00
int fd;
_cleanup_fclose_ FILE *f = NULL;
fd = mkostemp_safe(name);
assert_se(fd >= 0);
assert_se((size_t) write(fd, buffer, sizeof(buffer)) == sizeof(buffer));
assert_se(lseek(fd, 0, SEEK_SET) == 0);
assert_se(f = fdopen(fd, "r"));
test_read_line_one_file(f);
}
static void test_read_line3(void) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *line = NULL;
int r;
test-fileio: fix bogus error when /proc/cmdline contains newlines The kernel does not sanitize /proc/cmdline. E.g. when running under qemu, it is easy to pass a string with newline by mistake. We use read_one_line_file(), so we would read only the first list of the file, and write_string_file(WRITE_STRING_FILE_VERIFY_ON_FAILURE) would fail because the target file is obviously different. Change to a kernel-generated file to avoid the issue. v2: - use /proc/version instead of /proc/uptime for attempted writes, so the test test passes even if test_write_string_file_verify() takes more than 10 ms ;]
2019-12-13 12:21:11 +01:00
f = fopen("/proc/uptime", "re");
test-fileio: also test read_line() with actual files Just in case the real FILE and the one from fmemopen weren't exactly the same.
2017-09-24 09:10:48 +02:00
if (!f && IN_SET(errno, ENOENT, EPERM))
return;
assert_se(f);
r = read_line(f, LINE_MAX, &line);
test-fileio: do not use variable before checking return value Coverity is unhappy because we use "line" in the assert that checks the return value. It doesn't matter much, but let's clean this up. Also, let's not assume that /proc/cmdline contains anything. CID #1400219.
2019-03-27 09:18:50 +01:00
assert_se(r >= 0);
if (r == 0)
assert_se(line && isempty(line));
else
assert_se((size_t) r == strlen(line) + 1);
test-fileio: also test read_line() with actual files Just in case the real FILE and the one from fmemopen weren't exactly the same.
2017-09-24 09:10:48 +02:00
assert_se(read_line(f, LINE_MAX, NULL) == 0);
}
tests: add a test that checks read_line() properly handles line endings at EOF As requested here: https://github.com/systemd/systemd/pull/11129#discussion_r241588835
2018-12-14 12:57:32 +01:00
static void test_read_line4(void) {
static const struct {
size_t length;
const char *string;
} eof_endings[] = {
/* Each of these will be followed by EOF and should generate the one same single string */
{ 3, "foo" },
{ 4, "foo\n" },
{ 4, "foo\r" },
{ 4, "foo\0" },
{ 5, "foo\n\0" },
{ 5, "foo\r\0" },
{ 5, "foo\r\n" },
{ 5, "foo\n\r" },
{ 6, "foo\r\n\0" },
{ 6, "foo\n\r\0" },
};
size_t i;
int r;
for (i = 0; i < ELEMENTSOF(eof_endings); i++) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *s = NULL;
Add fmemopen_unlocked() and use unlocked ops in fuzzers and some other tests This might make things marginially faster. I didn't benchmark though.
2019-04-04 12:24:38 +02:00
assert_se(f = fmemopen_unlocked((void*) eof_endings[i].string, eof_endings[i].length, "r"));
tests: add a test that checks read_line() properly handles line endings at EOF As requested here: https://github.com/systemd/systemd/pull/11129#discussion_r241588835
2018-12-14 12:57:32 +01:00
r = read_line(f, (size_t) -1, &s);
assert_se((size_t) r == eof_endings[i].length);
assert_se(streq_ptr(s, "foo"));
assert_se(read_line(f, (size_t) -1, NULL) == 0); /* Ensure we hit EOF */
}
}
test: add test case for read_nul_string()
2018-12-17 11:52:51 +01:00
static void test_read_nul_string(void) {
static const char test[] = "string nr. 1\0"
"string nr. 2\n\0"
fileio: fix read_one_line() when reading bytes > 0x7F Fixes: #11218
2018-12-20 10:21:16 +01:00
"\377empty string follows\0"
test: add test case for read_nul_string()
2018-12-17 11:52:51 +01:00
"\0"
"final string\n is empty\0"
"\0";
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *s = NULL;
Add fmemopen_unlocked() and use unlocked ops in fuzzers and some other tests This might make things marginially faster. I didn't benchmark though.
2019-04-04 12:24:38 +02:00
assert_se(f = fmemopen_unlocked((void*) test, sizeof(test)-1, "r"));
test: add test case for read_nul_string()
2018-12-17 11:52:51 +01:00
assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 13 && streq_ptr(s, "string nr. 1"));
s = mfree(s);
assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 14 && streq_ptr(s, "string nr. 2\n"));
s = mfree(s);
fileio: fix read_one_line() when reading bytes > 0x7F Fixes: #11218
2018-12-20 10:21:16 +01:00
assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 22 && streq_ptr(s, "\377empty string follows"));
test: add test case for read_nul_string()
2018-12-17 11:52:51 +01:00
s = mfree(s);
assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 1 && streq_ptr(s, ""));
s = mfree(s);
assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 23 && streq_ptr(s, "final string\n is empty"));
s = mfree(s);
assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 1 && streq_ptr(s, ""));
s = mfree(s);
assert_se(read_nul_string(f, LONG_LINE_MAX, &s) == 0 && streq_ptr(s, ""));
}
fileio: add support for read_full_file() on AF_UNIX stream sockets Optionally, teach read_full_file() the ability to connect to an AF_UNIX socket if the specified path points to one.
2020-07-17 12:26:01 +02:00
static void test_read_full_file_socket(void) {
_cleanup_(rm_rf_physical_and_freep) char *z = NULL;
_cleanup_close_ int listener = -1;
fileio: beef up READ_FULL_FILE_CONNECT_SOCKET to allow setting sender socket name This beefs up the READ_FULL_FILE_CONNECT_SOCKET logic of read_full_file_full() a bit: when used a sender socket name may be specified. If specified as NULL behaviour is as before: the client socket name is picked by the kernel. But if specified as non-NULL the client can pick a socket name to use when connecting. This is useful to communicate a minimal amount of metainformation from client to server, outside of the transport payload. Specifically, these beefs up the service credential logic to pass an abstract AF_UNIX socket name as client socket name when connecting via READ_FULL_FILE_CONNECT_SOCKET, that includes the requesting unit name and the eventual credential name. This allows servers implementing the trivial credential socket logic to distinguish clients: via a simple getpeername() it can be determined which unit is requesting a credential, and which credential specifically. Example: with this patch in place, in a unit file "waldo.service" a configuration line like the following: LoadCredential=foo:/run/quux/creds.sock will result in a connection to the AF_UNIX socket /run/quux/creds.sock, originating from an abstract namespace AF_UNIX socket: @$RANDOM/unit/waldo.service/foo (The $RANDOM is replaced by some randomized string. This is included in the socket name order to avoid namespace squatting issues: the abstract socket namespace is open to unprivileged users after all, and care needs to be taken not to use guessable names) The services listening on the /run/quux/creds.sock socket may thus easily retrieve the name of the unit the credential is requested for plus the credential name, via a simpler getpeername(), discarding the random preifx and the /unit/ string. This logic uses "/" as separator between the fields, since both unit names and credential names appear in the file system, and thus are designed to use "/" as outer separators. Given that it's a good safe choice to use as separators here, too avoid any conflicts. This is a minimal patch only: the new logic is used only for the unit file credential logic. For other places where we use READ_FULL_FILE_CONNECT_SOCKET it is probably a good idea to use this scheme too, but this should be done carefully in later patches, since the socket names become API that way, and we should determine the right amount of info to pass over.
2020-11-02 12:07:51 +01:00
_cleanup_free_ char *data = NULL, *clientname = NULL;
fileio: add support for read_full_file() on AF_UNIX stream sockets Optionally, teach read_full_file() the ability to connect to an AF_UNIX socket if the specified path points to one.
2020-07-17 12:26:01 +02:00
union sockaddr_union sa;
const char *j;
size_t size;
pid_t pid;
int r;
log_info("/* %s */", __func__);
listener = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0);
assert_se(listener >= 0);
assert_se(mkdtemp_malloc(NULL, &z) >= 0);
j = strjoina(z, "/socket");
assert_se(sockaddr_un_set_path(&sa.un, j) >= 0);
assert_se(bind(listener, &sa.sa, SOCKADDR_UN_LEN(sa.un)) >= 0);
assert_se(listen(listener, 1) >= 0);
fileio: beef up READ_FULL_FILE_CONNECT_SOCKET to allow setting sender socket name This beefs up the READ_FULL_FILE_CONNECT_SOCKET logic of read_full_file_full() a bit: when used a sender socket name may be specified. If specified as NULL behaviour is as before: the client socket name is picked by the kernel. But if specified as non-NULL the client can pick a socket name to use when connecting. This is useful to communicate a minimal amount of metainformation from client to server, outside of the transport payload. Specifically, these beefs up the service credential logic to pass an abstract AF_UNIX socket name as client socket name when connecting via READ_FULL_FILE_CONNECT_SOCKET, that includes the requesting unit name and the eventual credential name. This allows servers implementing the trivial credential socket logic to distinguish clients: via a simple getpeername() it can be determined which unit is requesting a credential, and which credential specifically. Example: with this patch in place, in a unit file "waldo.service" a configuration line like the following: LoadCredential=foo:/run/quux/creds.sock will result in a connection to the AF_UNIX socket /run/quux/creds.sock, originating from an abstract namespace AF_UNIX socket: @$RANDOM/unit/waldo.service/foo (The $RANDOM is replaced by some randomized string. This is included in the socket name order to avoid namespace squatting issues: the abstract socket namespace is open to unprivileged users after all, and care needs to be taken not to use guessable names) The services listening on the /run/quux/creds.sock socket may thus easily retrieve the name of the unit the credential is requested for plus the credential name, via a simpler getpeername(), discarding the random preifx and the /unit/ string. This logic uses "/" as separator between the fields, since both unit names and credential names appear in the file system, and thus are designed to use "/" as outer separators. Given that it's a good safe choice to use as separators here, too avoid any conflicts. This is a minimal patch only: the new logic is used only for the unit file credential logic. For other places where we use READ_FULL_FILE_CONNECT_SOCKET it is probably a good idea to use this scheme too, but this should be done carefully in later patches, since the socket names become API that way, and we should determine the right amount of info to pass over.
2020-11-02 12:07:51 +01:00
/* Bind the *client* socket to some randomized name, to verify that this works correctly. */
assert_se(asprintf(&clientname, "@%" PRIx64 "/test-bindname", random_u64()) >= 0);
fileio: add support for read_full_file() on AF_UNIX stream sockets Optionally, teach read_full_file() the ability to connect to an AF_UNIX socket if the specified path points to one.
2020-07-17 12:26:01 +02:00
r = safe_fork("(server)", FORK_DEATHSIG|FORK_LOG, &pid);
assert_se(r >= 0);
if (r == 0) {
fileio: beef up READ_FULL_FILE_CONNECT_SOCKET to allow setting sender socket name This beefs up the READ_FULL_FILE_CONNECT_SOCKET logic of read_full_file_full() a bit: when used a sender socket name may be specified. If specified as NULL behaviour is as before: the client socket name is picked by the kernel. But if specified as non-NULL the client can pick a socket name to use when connecting. This is useful to communicate a minimal amount of metainformation from client to server, outside of the transport payload. Specifically, these beefs up the service credential logic to pass an abstract AF_UNIX socket name as client socket name when connecting via READ_FULL_FILE_CONNECT_SOCKET, that includes the requesting unit name and the eventual credential name. This allows servers implementing the trivial credential socket logic to distinguish clients: via a simple getpeername() it can be determined which unit is requesting a credential, and which credential specifically. Example: with this patch in place, in a unit file "waldo.service" a configuration line like the following: LoadCredential=foo:/run/quux/creds.sock will result in a connection to the AF_UNIX socket /run/quux/creds.sock, originating from an abstract namespace AF_UNIX socket: @$RANDOM/unit/waldo.service/foo (The $RANDOM is replaced by some randomized string. This is included in the socket name order to avoid namespace squatting issues: the abstract socket namespace is open to unprivileged users after all, and care needs to be taken not to use guessable names) The services listening on the /run/quux/creds.sock socket may thus easily retrieve the name of the unit the credential is requested for plus the credential name, via a simpler getpeername(), discarding the random preifx and the /unit/ string. This logic uses "/" as separator between the fields, since both unit names and credential names appear in the file system, and thus are designed to use "/" as outer separators. Given that it's a good safe choice to use as separators here, too avoid any conflicts. This is a minimal patch only: the new logic is used only for the unit file credential logic. For other places where we use READ_FULL_FILE_CONNECT_SOCKET it is probably a good idea to use this scheme too, but this should be done carefully in later patches, since the socket names become API that way, and we should determine the right amount of info to pass over.
2020-11-02 12:07:51 +01:00
union sockaddr_union peer = {};
socklen_t peerlen = sizeof(peer);
fileio: add support for read_full_file() on AF_UNIX stream sockets Optionally, teach read_full_file() the ability to connect to an AF_UNIX socket if the specified path points to one.
2020-07-17 12:26:01 +02:00
_cleanup_close_ int rfd = -1;
/* child */
rfd = accept4(listener, NULL, 0, SOCK_CLOEXEC);
assert_se(rfd >= 0);
fileio: beef up READ_FULL_FILE_CONNECT_SOCKET to allow setting sender socket name This beefs up the READ_FULL_FILE_CONNECT_SOCKET logic of read_full_file_full() a bit: when used a sender socket name may be specified. If specified as NULL behaviour is as before: the client socket name is picked by the kernel. But if specified as non-NULL the client can pick a socket name to use when connecting. This is useful to communicate a minimal amount of metainformation from client to server, outside of the transport payload. Specifically, these beefs up the service credential logic to pass an abstract AF_UNIX socket name as client socket name when connecting via READ_FULL_FILE_CONNECT_SOCKET, that includes the requesting unit name and the eventual credential name. This allows servers implementing the trivial credential socket logic to distinguish clients: via a simple getpeername() it can be determined which unit is requesting a credential, and which credential specifically. Example: with this patch in place, in a unit file "waldo.service" a configuration line like the following: LoadCredential=foo:/run/quux/creds.sock will result in a connection to the AF_UNIX socket /run/quux/creds.sock, originating from an abstract namespace AF_UNIX socket: @$RANDOM/unit/waldo.service/foo (The $RANDOM is replaced by some randomized string. This is included in the socket name order to avoid namespace squatting issues: the abstract socket namespace is open to unprivileged users after all, and care needs to be taken not to use guessable names) The services listening on the /run/quux/creds.sock socket may thus easily retrieve the name of the unit the credential is requested for plus the credential name, via a simpler getpeername(), discarding the random preifx and the /unit/ string. This logic uses "/" as separator between the fields, since both unit names and credential names appear in the file system, and thus are designed to use "/" as outer separators. Given that it's a good safe choice to use as separators here, too avoid any conflicts. This is a minimal patch only: the new logic is used only for the unit file credential logic. For other places where we use READ_FULL_FILE_CONNECT_SOCKET it is probably a good idea to use this scheme too, but this should be done carefully in later patches, since the socket names become API that way, and we should determine the right amount of info to pass over.
2020-11-02 12:07:51 +01:00
assert_se(getpeername(rfd, &peer.sa, &peerlen) >= 0);
assert_se(peer.un.sun_family == AF_UNIX);
assert_se(peerlen > offsetof(struct sockaddr_un, sun_path));
assert_se(peer.un.sun_path[0] == 0);
assert_se(streq(peer.un.sun_path + 1, clientname + 1));
fileio: add support for read_full_file() on AF_UNIX stream sockets Optionally, teach read_full_file() the ability to connect to an AF_UNIX socket if the specified path points to one.
2020-07-17 12:26:01 +02:00
#define TEST_STR "This is a test\nreally."
assert_se(write(rfd, TEST_STR, strlen(TEST_STR)) == strlen(TEST_STR));
_exit(EXIT_SUCCESS);
}
fileio: teach read_full_file_full() to read from offset/with maximum size
2020-11-04 20:25:06 +01:00
assert_se(read_full_file_full(AT_FDCWD, j, UINT64_MAX, SIZE_MAX, 0, NULL, &data, &size) == -ENXIO);
assert_se(read_full_file_full(AT_FDCWD, j, UINT64_MAX, SIZE_MAX, READ_FULL_FILE_CONNECT_SOCKET, clientname, &data, &size) >= 0);
fileio: add support for read_full_file() on AF_UNIX stream sockets Optionally, teach read_full_file() the ability to connect to an AF_UNIX socket if the specified path points to one.
2020-07-17 12:26:01 +02:00
assert_se(size == strlen(TEST_STR));
assert_se(streq(data, TEST_STR));
assert_se(wait_for_terminate_and_check("(server)", pid, WAIT_LOG) >= 0);
#undef TEST_STR
}
fileio: teach read_full_file_full() to read from offset/with maximum size
2020-11-04 20:25:06 +01:00
static void test_read_full_file_offset_size(void) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_(unlink_and_freep) char *fn = NULL;
_cleanup_free_ char *rbuf = NULL;
size_t rbuf_size;
uint8_t buf[4711];
random_bytes(buf, sizeof(buf));
assert_se(tempfn_random_child(NULL, NULL, &fn) >= 0);
assert_se(f = fopen(fn, "we"));
assert_se(fwrite(buf, 1, sizeof(buf), f) == sizeof(buf));
assert_se(fflush_and_check(f) >= 0);
assert_se(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, SIZE_MAX, 0, NULL, &rbuf, &rbuf_size) >= 0);
assert_se(rbuf_size == sizeof(buf));
assert_se(memcmp(buf, rbuf, rbuf_size) == 0);
rbuf = mfree(rbuf);
assert_se(read_full_file_full(AT_FDCWD, fn, UINT64_MAX, 128, 0, NULL, &rbuf, &rbuf_size) >= 0);
assert_se(rbuf_size == 128);
assert_se(memcmp(buf, rbuf, rbuf_size) == 0);
rbuf = mfree(rbuf);
assert_se(read_full_file_full(AT_FDCWD, fn, 1234, SIZE_MAX, 0, NULL, &rbuf, &rbuf_size) >= 0);
assert_se(rbuf_size == sizeof(buf) - 1234);
assert_se(memcmp(buf + 1234, rbuf, rbuf_size) == 0);
rbuf = mfree(rbuf);
assert_se(read_full_file_full(AT_FDCWD, fn, 2345, 777, 0, NULL, &rbuf, &rbuf_size) >= 0);
assert_se(rbuf_size == 777);
assert_se(memcmp(buf + 2345, rbuf, rbuf_size) == 0);
rbuf = mfree(rbuf);
assert_se(read_full_file_full(AT_FDCWD, fn, 4700, 20, 0, NULL, &rbuf, &rbuf_size) >= 0);
assert_se(rbuf_size == 11);
assert_se(memcmp(buf + 4700, rbuf, rbuf_size) == 0);
rbuf = mfree(rbuf);
assert_se(read_full_file_full(AT_FDCWD, fn, 10000, 99, 0, NULL, &rbuf, &rbuf_size) >= 0);
assert_se(rbuf_size == 0);
rbuf = mfree(rbuf);
}
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
int main(int argc, char *argv[]) {
tests: use a helper function to parse environment and open logging The advantages are that we save a few lines, and that we can override logging using environment variables in more test executables.
2018-09-13 14:31:13 +02:00
test_setup_logging(LOG_DEBUG);
Add more tests and fix capability logging
2013-09-19 23:22:59 +02:00
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
test_parse_env_file();
Allow tabs in environment files bash allows them, and so should we. string_has_cc is changed to allow tabs, and if they are not wanted, they must be now checked for explicitly. There are two other callers, apart from the env file loaders, and one already checked anyway, and the other is changed to check. https://bugs.freedesktop.org/show_bug.cgi?id=68592 https://bugs.gentoo.org/show_bug.cgi?id=481554
2013-09-12 03:50:16 +02:00
test_parse_multiline_env_file();
basic: add new merge_env_file function merge_env_file is a new function, that's like load_env_file, but takes a pre-existing environment as an input argument. New environment entries are merged. Variable expansion is performed. Falling back to the process environment is supported (when a flag is set). Alternatively this could be implemented as passing an additional fallback environment array, but later on we're adding another flag to allow braceless expansion, and the two flags can be combined in one arg, so there's less stuff to pass around.
2016-08-04 18:00:00 +02:00
test_merge_env_file();
Tighten checking for variable validity In the future we might want to allow additional syntax (for example "unset VAR". But let's check that the data we're getting does not contain anything unexpected.
2017-02-18 04:56:28 +01:00
test_merge_env_file_invalid();
journalctl: use _COMM= match for scripts In case of scripts, _EXE is set to the interpreter name, and _COMM is set based on the file name. Add a match for _COMM, and _EXE if the interpreter is not a link (e.g. for yum, the interpreter is /usr/bin/python, but it is a link to /usr/bin/python2, which in turn is a link to /usr/bin/python2.7, at least on Fedora, so we end up with _EXE=/usr/bin/python2.7). I don't think that such link chasing makes sense, because the final _EXE name is more likely to change.
2013-07-19 10:02:50 +02:00
test_executable_is_script();
Advertise hibernation only if there's enough free swap Condition that is checked is taken from upower: active(anon) < free swap * 0.98 This is really stupid, because the kernel knows the situation better, e.g. there could be two swap files, and then hibernation would be impossible despite passing this check, or the kernel could start supporting compressed swap and/or compressed hibernation images, and then this this check would be too stringent. Nevertheless, until we have something better, this should at least return a true negative if there's no swap. Logging of capabilities in the journal is changed to not strip leading zeros. I consider this more readable anyway. http://cgit.freedesktop.org/upower/tree/src/up-daemon.c#n613 https://bugzilla.redhat.com/show_bug.cgi?id=1007059
2013-09-14 01:41:52 +02:00
test_status_field();
Add more tests and fix capability logging
2013-09-19 23:22:59 +02:00
test_capeff();
tests: add tests for fileio.c add tests for: - write_string_stream - write_string_file - sendfile_full
2014-08-16 14:19:07 +02:00
test_write_string_stream();
test_write_string_file();
tests: add tests for fileio.c add tests for the following functions: - write_string_file_no_create - load_env_file_pairs
2014-09-02 18:55:31 +02:00
test_write_string_file_no_create();
util-lib: optionally, when writing a string to a file, verify string on failure With this change, the idiom: r = write_string_file(p, buf, 0); if (r < 0) { if (verify_one_line_file(p, buf) > 0) r = 0; } gets reduced to: r = write_string_file(p, buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE); i.e. when writing the string fails and the new flag WRITE_STRING_FILE_VERIFY_ON_FAILURE is specified we'll not return a failure immediately, but check the contents of the file. If it matches what we wanted to write we suppress the error and exit cleanly.
2015-11-13 00:54:56 +01:00
test_write_string_file_verify();
tests: add tests for fileio.c add tests for the following functions: - write_string_file_no_create - load_env_file_pairs
2014-09-02 18:55:31 +02:00
test_load_env_file_pairs();
tests: move fileio related tests to test-fileio.c
2016-03-02 23:50:21 +01:00
test_search_and_fopen();
test_search_and_fopen_nulstr();
test_writing_tmpfile();
test_tempfn();
test-fileio: test safe_fgetc directly Non-ascii chars are used so that we get both "positive" and "negative" characters (on the arches where char is signed).
2018-12-18 13:27:59 +01:00
test_fgetc();
fileio: add new helper call read_line() as bounded getline() replacement read_line() is much like getline(), and returns a line read from a FILE*, of arbitrary sizes. In contrast to gets() it will grow the buffer dynamically, and in contrast to getline() it will place a user-specified boundary on the line.
2017-09-22 17:55:53 +02:00
test_read_line();
test-fileio: also test read_line() with actual files Just in case the real FILE and the one from fmemopen weren't exactly the same.
2017-09-24 09:10:48 +02:00
test_read_line2();
test_read_line3();
tests: add a test that checks read_line() properly handles line endings at EOF As requested here: https://github.com/systemd/systemd/pull/11129#discussion_r241588835
2018-12-14 12:57:32 +01:00
test_read_line4();
test: add test case for read_nul_string()
2018-12-17 11:52:51 +01:00
test_read_nul_string();
fileio: add support for read_full_file() on AF_UNIX stream sockets Optionally, teach read_full_file() the ability to connect to an AF_UNIX socket if the specified path points to one.
2020-07-17 12:26:01 +02:00
test_read_full_file_socket();
fileio: teach read_full_file_full() to read from offset/with maximum size
2020-11-04 20:25:06 +01:00
test_read_full_file_offset_size();
Add more tests and fix capability logging
2013-09-19 23:22:59 +02:00
shared: rework env file reader Implement this with a proper state machine, so that newlines and escaped chars can appear in string assignments. This should bring the parser much closer to shell.
2013-04-03 19:04:03 +02:00
return 0;
}
Reference in a new issue Copy permalink