shaba/systemd-stable
1
1
Fork 0
mirror of https://github.com/systemd/systemd-stable.git synced 2024-12-22 13:33:56 +03:00
Code

Merge branch 'hostnamectl-dot-v2'

Browse Source 
Manual merge of https://github.com/systemd/systemd/pull/751.
This commit is contained in:
Zbigniew Jędrzejewski-Szmek 2015-08-05 21:01:06 -04:00
commit 73974f6768
18 changed files with 223 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -194,6 +194,7 @@
/test-firewall-util
/test-hashmap
/test-hostname
/test-hostname-util
/test-icmp6-rs
/test-id128
/test-inhibit

7
Makefile.am
View File

@ -1392,6 +1392,7 @@ tests += \
test-utf8 \
test-ellipsize \
test-util \
test-hostname-util \
test-process-util \
test-terminal-util \
test-path-lookup \
@ -1672,6 +1673,12 @@ test_util_SOURCES = \
test_util_LDADD = \
libshared.la
test_hostname_util_SOURCES = \
src/test/test-hostname-util.c
test_hostname_util_LDADD = \
libshared.la
test_process_util_SOURCES = \
src/test/test-process-util.c

37
src/basic/hostname-util.c
View File

@ -61,14 +61,22 @@ static bool hostname_valid_char(char c) {
c == '.';
}
bool hostname_is_valid(const char *s) {
/**
* Check if s looks like a valid host name or fqdn. This does not do
* full DNS validation, but only checks if the name is composed of
* allowed characters and the length is not above the maximum allowed
* by Linux (c.f. dns_name_is_valid()). Trailing dot is allowed if
* relax is true and at least two components are present in the name.
*/
bool hostname_is_valid(const char *s, bool relax) {
const char *p;
bool dot;
unsigned dots = 0;
if (isempty(s))
return false;
/* Doesn't accept empty hostnames, hostnames with trailing or
/* Doesn't accept empty hostnames, hostnames with
* leading dots, and hostnames with multiple dots in a
* sequence. Also ensures that the length stays below
* HOST_NAME_MAX. */
@ -79,6 +87,7 @@ bool hostname_is_valid(const char *s) {
return false;
dot = true;
dots ++;
} else {
if (!hostname_valid_char(*p))
return false;
@ -87,7 +96,7 @@ bool hostname_is_valid(const char *s) {
}
}
if (dot)
if (dot && (dots < 2 || !relax))
return false;
if (p-s > HOST_NAME_MAX)
@ -96,7 +105,7 @@ bool hostname_is_valid(const char *s) {
return true;
}
char* hostname_cleanup(char *s, bool lowercase) {
char* hostname_cleanup(char *s) {
char *p, *d;
bool dot;
@ -110,7 +119,7 @@ char* hostname_cleanup(char *s, bool lowercase) {
*(d++) = '.';
dot = true;
} else if (hostname_valid_char(*p)) {
*(d++) = lowercase ? tolower(*p) : *p;
*(d++) = *p;
dot = false;
}
@ -132,14 +141,14 @@ bool is_localhost(const char *hostname) {
/* This tries to identify local host and domain names
* described in RFC6761 plus the redhatism of .localdomain */
return streq(hostname, "localhost") ||
streq(hostname, "localhost.") ||
streq(hostname, "localdomain.") ||
streq(hostname, "localdomain") ||
endswith(hostname, ".localhost") ||
endswith(hostname, ".localhost.") ||
endswith(hostname, ".localdomain") ||
endswith(hostname, ".localdomain.");
return strcaseeq(hostname, "localhost") ||
strcaseeq(hostname, "localhost.") ||
strcaseeq(hostname, "localdomain.") ||
strcaseeq(hostname, "localdomain") ||
endswith_no_case(hostname, ".localhost") ||
endswith_no_case(hostname, ".localhost.") ||
endswith_no_case(hostname, ".localdomain") ||
endswith_no_case(hostname, ".localdomain.");
}
int sethostname_idempotent(const char *s) {
@ -176,7 +185,7 @@ int read_hostname_config(const char *path, char **hostname) {
truncate_nl(l);
if (l[0] != '\0' && l[0] != '#') {
/* found line with value */
name = hostname_cleanup(l, false);
name = hostname_cleanup(l);
name = strdup(name);
if (!name)
return -ENOMEM;

4
src/basic/hostname-util.h
View File

@ -29,8 +29,8 @@ bool hostname_is_set(void);
char* gethostname_malloc(void);
bool hostname_is_valid(const char *s) _pure_;
char* hostname_cleanup(char *s, bool lowercase);
bool hostname_is_valid(const char *s, bool relax) _pure_;
char* hostname_cleanup(char *s);
bool is_localhost(const char *hostname);

2
src/basic/util.c
View File

@ -3008,7 +3008,7 @@ char* strshorten(char *s, size_t l) {
bool machine_name_is_valid(const char *s) {
if (!hostname_is_valid(s))
if (!hostname_is_valid(s, false))
return false;
/* Machine names should be useful hostnames, but also be

5
src/basic/util.h
View File

@ -864,6 +864,11 @@ int unquote_first_word(const char **p, char **ret, UnquoteFlags flags);
int unquote_first_word_and_warn(const char **p, char **ret, UnquoteFlags flags, const char *unit, const char *filename, unsigned line, const char *rvalue);
int unquote_many_words(const char **p, UnquoteFlags flags, ...) _sentinel_;
static inline void free_and_replace(char **s, char *v) {
free(*s);
*s = v;
}
int free_and_strdup(char **p, const char *s);
#define INOTIFY_EVENT_MAX (sizeof(struct inotify_event) + NAME_MAX + 1)

8
src/firstboot/firstboot.c
View File

@ -386,12 +386,13 @@ static int prompt_hostname(void) {
break;
}
if (!hostname_is_valid(h)) {
if (!hostname_is_valid(h, true)) {
log_error("Specified hostname invalid.");
continue;
}
arg_hostname = h;
/* Get rid of the trailing dot that we allow, but don't want to see */
arg_hostname = hostname_cleanup(h);
h = NULL;
break;
}
@ -772,11 +773,12 @@ static int parse_argv(int argc, char *argv[]) {
break;
case ARG_HOSTNAME:
if (!hostname_is_valid(optarg)) {
if (!hostname_is_valid(optarg, true)) {
log_error("Host name %s is not valid.", optarg);
return -EINVAL;
}
hostname_cleanup(optarg);
r = free_and_strdup(&arg_hostname, optarg);
if (r < 0)
return log_oom();

21
src/hostname/hostnamectl.c
View File

@ -252,7 +252,7 @@ static int set_simple_string(sd_bus *bus, const char *method, const char *value)
static int set_hostname(sd_bus *bus, char **args, unsigned n) {
_cleanup_free_ char *h = NULL;
const char *hostname = args[1];
char *hostname = args[1];
int r;
assert(args);
@ -270,17 +270,16 @@ static int set_hostname(sd_bus *bus, char **args, unsigned n) {
* just set the passed hostname as static/dynamic
* hostname. */
h = strdup(hostname);
if (!h)
return log_oom();
hostname_cleanup(h, true);
if (arg_static && streq(h, hostname))
if (arg_static && hostname_is_valid(hostname, true)) {
p = "";
else {
p = hostname;
hostname = h;
/* maybe get rid of trailing dot */
hostname = hostname_cleanup(hostname);
} else {
p = h = strdup(hostname);
if (!p)
return log_oom();
hostname_cleanup(hostname);
}
r = set_simple_string(bus, "SetPrettyHostname", p);

4
src/hostname/hostnamed.c
View File

@ -424,7 +424,7 @@ static int method_set_hostname(sd_bus_message *m, void *userdata, sd_bus_error *
if (isempty(name))
name = "localhost";
if (!hostname_is_valid(name))
if (!hostname_is_valid(name, false))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid hostname '%s'", name);
if (streq_ptr(name, c->data[PROP_HOSTNAME]))
@ -501,7 +501,7 @@ static int method_set_static_hostname(sd_bus_message *m, void *userdata, sd_bus_
} else {
char *h;
if (!hostname_is_valid(name))
if (!hostname_is_valid(name, false))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid static hostname '%s'", name);
h = strdup(name);

2
src/import/pull-dkr.c
View File

@ -719,7 +719,7 @@ static int dkr_pull_job_on_header(PullJob *j, const char *header, size_t sz) {
return log_oom();
STRV_FOREACH(k, l) {
if (!hostname_is_valid(*k)) {
if (!hostname_is_valid(*k, false)) {
log_error("Registry hostname is not valid.");
strv_free(l);
return -EBADMSG;

2
src/journal-remote/journal-gatewayd.c
View File

@ -797,7 +797,7 @@ static int request_handler_machine(
"\"cutoff_to_realtime\" : \"%"PRIu64"\" }\n",
SD_ID128_FORMAT_VAL(mid),
SD_ID128_FORMAT_VAL(bid),
hostname_cleanup(hostname, false),
hostname_cleanup(hostname),
os_name ? os_name : "Linux",
v ? v : "bare",
usage,

2
src/journal/journalctl.c
View File

@ -1526,7 +1526,7 @@ static int setup_keys(void) {
hn = gethostname_malloc();
if (hn) {
hostname_cleanup(hn, false);
hostname_cleanup(hn);
fprintf(stderr, "\nThe keys have been generated for host %s/" SD_ID128_FORMAT_STR ".\n", hn, SD_ID128_FORMAT_VAL(machine));
} else
fprintf(stderr, "\nThe keys have been generated for host " SD_ID128_FORMAT_STR ".\n", SD_ID128_FORMAT_VAL(machine));

5
src/libsystemd-network/sd-dhcp-lease.c
View File

@ -561,11 +561,10 @@ int dhcp_lease_parse_options(uint8_t code, uint8_t len, const uint8_t *option,
if (e)
*e = 0;
if (!hostname_is_valid(hostname) || is_localhost(hostname))
if (!hostname_is_valid(hostname, false) || is_localhost(hostname))
break;
free(lease->hostname);
lease->hostname = hostname;
free_and_replace(&lease->hostname, hostname);
hostname = NULL;
break;

5
src/locale/localed.c
View File

@ -99,11 +99,6 @@ static const char* nonempty(const char *s) {
return isempty(s) ? NULL : s;
}
static void free_and_replace(char **s, char *v) {
free(*s);
*s = v;
}
static bool startswith_comma(const char *s, const char *prefix) {
const char *t;

4
src/network/networkd-network.c
View File

@ -839,14 +839,14 @@ int config_parse_hostname(const char *unit,
if (r < 0)
return r;
if (!hostname_is_valid(hn)) {
if (!hostname_is_valid(hn, true)) {
log_syntax(unit, LOG_ERR, filename, line, EINVAL, "hostname is not valid, ignoring assignment: %s", rvalue);
free(hn);
return 0;
}
*hostname = hn;
*hostname = hostname_cleanup(hn);
return 0;
}

2
src/nspawn/nspawn.c
View File

@ -4002,7 +4002,7 @@ static int determine_names(void) {
if (!arg_machine)
return log_oom();
hostname_cleanup(arg_machine, false);
hostname_cleanup(arg_machine);
if (!machine_name_is_valid(arg_machine)) {
log_error("Failed to determine machine name automatically, please use -M.");
return -EINVAL;

159
src/test/test-hostname-util.c Normal file
View File

@ -0,0 +1,159 @@
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
/***
This file is part of systemd.
Copyright 2010 Lennart Poettering
Copyright 2013 Thomas H.P. Andersen
Copyright 2015 Zbigniew Jędrzejewski-Szmek
systemd is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
systemd is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
#include "util.h"
#include "fileio.h"
#include "hostname-util.h"
static void test_hostname_is_valid(void) {
assert_se(hostname_is_valid("foobar", false));
assert_se(hostname_is_valid("foobar.com", false));
assert_se(!hostname_is_valid("foobar.com.", false));
assert_se(hostname_is_valid("fooBAR", false));
assert_se(hostname_is_valid("fooBAR.com", false));
assert_se(!hostname_is_valid("fooBAR.", false));
assert_se(!hostname_is_valid("fooBAR.com.", false));
assert_se(!hostname_is_valid("fööbar", false));
assert_se(!hostname_is_valid("", false));
assert_se(!hostname_is_valid(".", false));
assert_se(!hostname_is_valid("..", false));
assert_se(!hostname_is_valid("foobar.", false));
assert_se(!hostname_is_valid(".foobar", false));
assert_se(!hostname_is_valid("foo..bar", false));
assert_se(!hostname_is_valid("foo.bar..", false));
assert_se(!hostname_is_valid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", false));
assert_se(hostname_is_valid("foobar", true));
assert_se(hostname_is_valid("foobar.com", true));
assert_se(hostname_is_valid("foobar.com.", true));
assert_se(hostname_is_valid("fooBAR", true));
assert_se(hostname_is_valid("fooBAR.com", true));
assert_se(!hostname_is_valid("fooBAR.", true));
assert_se(hostname_is_valid("fooBAR.com.", true));
assert_se(!hostname_is_valid("fööbar", true));
assert_se(!hostname_is_valid("", true));
assert_se(!hostname_is_valid(".", true));
assert_se(!hostname_is_valid("..", true));
assert_se(!hostname_is_valid("foobar.", true));
assert_se(!hostname_is_valid(".foobar", true));
assert_se(!hostname_is_valid("foo..bar", true));
assert_se(!hostname_is_valid("foo.bar..", true));
assert_se(!hostname_is_valid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", true));
}
static void test_hostname_cleanup(void) {
char *s;
s = strdupa("foobar");
assert_se(streq(hostname_cleanup(s), "foobar"));
s = strdupa("foobar.com");
assert_se(streq(hostname_cleanup(s), "foobar.com"));
s = strdupa("foobar.com.");
assert_se(streq(hostname_cleanup(s), "foobar.com"));
s = strdupa("fooBAR");
assert_se(streq(hostname_cleanup(s), "fooBAR"));
s = strdupa("fooBAR.com");
assert_se(streq(hostname_cleanup(s), "fooBAR.com"));
s = strdupa("fooBAR.");
assert_se(streq(hostname_cleanup(s), "fooBAR"));
s = strdupa("fooBAR.com.");
assert_se(streq(hostname_cleanup(s), "fooBAR.com"));
s = strdupa("fööbar");
assert_se(streq(hostname_cleanup(s), "fbar"));
s = strdupa("");
assert_se(isempty(hostname_cleanup(s)));
s = strdupa(".");
assert_se(isempty(hostname_cleanup(s)));
s = strdupa("..");
assert_se(isempty(hostname_cleanup(s)));
s = strdupa("foobar.");
assert_se(streq(hostname_cleanup(s), "foobar"));
s = strdupa(".foobar");
assert_se(streq(hostname_cleanup(s), "foobar"));
s = strdupa("foo..bar");
assert_se(streq(hostname_cleanup(s), "foo.bar"));
s = strdupa("foo.bar..");
assert_se(streq(hostname_cleanup(s), "foo.bar"));
s = strdupa("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
assert_se(streq(hostname_cleanup(s), "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
}
static void test_read_hostname_config(void) {
char path[] = "/tmp/hostname.XXXXXX";
char *hostname;
int fd;
fd = mkostemp_safe(path, O_RDWR|O_CLOEXEC);
assert(fd > 0);
close(fd);
/* simple hostname */
write_string_file(path, "foo", WRITE_STRING_FILE_CREATE);
assert_se(read_hostname_config(path, &hostname) == 0);
assert_se(streq(hostname, "foo"));
hostname = mfree(hostname);
/* with comment */
write_string_file(path, "# comment\nfoo", WRITE_STRING_FILE_CREATE);
assert_se(read_hostname_config(path, &hostname) == 0);
assert_se(hostname);
assert_se(streq(hostname, "foo"));
hostname = mfree(hostname);
/* with comment and extra whitespace */
write_string_file(path, "# comment\n\n foo ", WRITE_STRING_FILE_CREATE);
assert_se(read_hostname_config(path, &hostname) == 0);
assert_se(hostname);
assert_se(streq(hostname, "foo"));
hostname = mfree(hostname);
/* cleans up name */
write_string_file(path, "!foo/bar.com", WRITE_STRING_FILE_CREATE);
assert_se(read_hostname_config(path, &hostname) == 0);
assert_se(hostname);
assert_se(streq(hostname, "foobar.com"));
hostname = mfree(hostname);
/* no value set */
hostname = (char*) 0x1234;
write_string_file(path, "# nothing here\n", WRITE_STRING_FILE_CREATE);
assert_se(read_hostname_config(path, &hostname) == -ENOENT);
assert_se(hostname == (char*) 0x1234); /* does not touch argument on error */
/* nonexisting file */
assert_se(read_hostname_config("/non/existing", &hostname) == -ENOENT);
assert_se(hostname == (char*) 0x1234); /* does not touch argument on error */
unlink(path);
}
int main(int argc, char *argv[]) {
log_parse_environment();
log_open();
test_hostname_is_valid();
test_hostname_cleanup();
test_read_hostname_config();
return 0;
}

65
src/test/test-util.c
View File

@ -38,7 +38,6 @@
#include "conf-parser.h"
#include "virt.h"
#include "process-util.h"
#include "hostname-util.h"
#include "signal-util.h"
static void test_streq_ptr(void) {
@ -868,68 +867,6 @@ static void test_memdup_multiply(void) {
free(dup);
}
static void test_hostname_is_valid(void) {
assert_se(hostname_is_valid("foobar"));
assert_se(hostname_is_valid("foobar.com"));
assert_se(!hostname_is_valid("fööbar"));
assert_se(!hostname_is_valid(""));
assert_se(!hostname_is_valid("."));
assert_se(!hostname_is_valid(".."));
assert_se(!hostname_is_valid("foobar."));
assert_se(!hostname_is_valid(".foobar"));
assert_se(!hostname_is_valid("foo..bar"));
assert_se(!hostname_is_valid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
}
static void test_read_hostname_config(void) {
char path[] = "/tmp/hostname.XXXXXX";
char *hostname;
int fd;
fd = mkostemp_safe(path, O_RDWR|O_CLOEXEC);
assert(fd > 0);
close(fd);
/* simple hostname */
write_string_file(path, "foo", WRITE_STRING_FILE_CREATE);
assert_se(read_hostname_config(path, &hostname) == 0);
assert_se(streq(hostname, "foo"));
hostname = mfree(hostname);
/* with comment */
write_string_file(path, "# comment\nfoo", WRITE_STRING_FILE_CREATE);
assert_se(read_hostname_config(path, &hostname) == 0);
assert_se(hostname);
assert_se(streq(hostname, "foo"));
hostname = mfree(hostname);
/* with comment and extra whitespace */
write_string_file(path, "# comment\n\n foo ", WRITE_STRING_FILE_CREATE);
assert_se(read_hostname_config(path, &hostname) == 0);
assert_se(hostname);
assert_se(streq(hostname, "foo"));
hostname = mfree(hostname);
/* cleans up name */
write_string_file(path, "!foo/bar.com", WRITE_STRING_FILE_CREATE);
assert_se(read_hostname_config(path, &hostname) == 0);
assert_se(hostname);
assert_se(streq(hostname, "foobar.com"));
hostname = mfree(hostname);
/* no value set */
hostname = (char*) 0x1234;
write_string_file(path, "# nothing here\n", WRITE_STRING_FILE_CREATE);
assert_se(read_hostname_config(path, &hostname) == -ENOENT);
assert_se(hostname == (char*) 0x1234); /* does not touch argument on error */
/* nonexisting file */
assert_se(read_hostname_config("/non/existing", &hostname) == -ENOENT);
assert_se(hostname == (char*) 0x1234); /* does not touch argument on error */
unlink(path);
}
static void test_u64log2(void) {
assert_se(u64log2(0) == 0);
assert_se(u64log2(8) == 3);
@ -2179,8 +2116,6 @@ int main(int argc, char *argv[]) {
test_foreach_word();
test_foreach_word_quoted();
test_memdup_multiply();
test_hostname_is_valid();
test_read_hostname_config();
test_u64log2();
test_protect_errno();
test_parse_size();