[thirdparty/systemd.git] / src / hostnamed.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2011 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 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
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <dbus/dbus.h>

#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <dlfcn.h>

#include "util.h"
#include "strv.h"
#include "dbus-common.h"
#include "polkit.h"

#define INTERFACE \
        " <interface name=\"org.freedesktop.hostname1\">\n"             \
        "  <property name=\"Hostname\" type=\"s\" access=\"read\"/>\n"  \
        "  <property name=\"StaticHostname\" type=\"s\" access=\"read\"/>\n" \
        "  <property name=\"PrettyHostname\" type=\"s\" access=\"read\"/>\n" \
        "  <property name=\"IconName\" type=\"s\" access=\"read\"/>\n"  \
        "  <method name=\"SetHostname\">\n"                             \
        "   <arg name=\"name\" type=\"s\" direction=\"in\"/>\n"         \
        "   <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
        "  </method>\n"                                                 \
        "  <method name=\"SetStaticHostname\">\n"                       \
        "   <arg name=\"name\" type=\"s\" direction=\"in\"/>\n"         \
        "   <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
        "  </method>\n"                                                 \
        "  <method name=\"SetPrettyHostname\">\n"                       \
        "   <arg name=\"name\" type=\"s\" direction=\"in\"/>\n"         \
        "   <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
        "  </method>\n"                                                 \
        "  <method name=\"SetIconName\">\n"                             \
        "   <arg name=\"name\" type=\"s\" direction=\"in\"/>\n"         \
        "   <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
        "  </method>\n"                                                 \
        " </interface>\n"

#define INTROSPECTION                                                   \
        DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE                       \
        "<node>\n"                                                      \
        INTERFACE                                                       \
        BUS_PROPERTIES_INTERFACE                                        \
        BUS_INTROSPECTABLE_INTERFACE                                    \
        BUS_PEER_INTERFACE                                              \
        "</node>\n"

#define INTERFACES_LIST                         \
        BUS_GENERIC_INTERFACES_LIST             \
        "org.freedesktop.hostname1\0"

const char hostname_interface[] _introspect_("hostname1") = INTERFACE;

enum {
        PROP_HOSTNAME,
        PROP_STATIC_HOSTNAME,
        PROP_PRETTY_HOSTNAME,
        PROP_ICON_NAME,
        _PROP_MAX
};

static char *data[_PROP_MAX] = {
        NULL,
        NULL,
        NULL,
        NULL
};

static void free_data(void) {
        int p;

        for (p = 0; p < _PROP_MAX; p++) {
                free(data[p]);
                data[p] = NULL;
        }
}

static int read_data(void) {
        int r;

        free_data();

        data[PROP_HOSTNAME] = gethostname_malloc();
        if (!data[PROP_HOSTNAME])
                return -ENOMEM;

        r = read_one_line_file("/etc/hostname", &data[PROP_STATIC_HOSTNAME]);
        if (r < 0 && r != -ENOENT)
                return r;

        r = parse_env_file("/etc/machine-info", NEWLINE,
                           "PRETTY_HOSTNAME", &data[PROP_PRETTY_HOSTNAME],
                           "ICON_NAME", &data[PROP_ICON_NAME],
                           NULL);
        if (r < 0 && r != -ENOENT)
                return r;

        return 0;
}

static bool check_nss(void) {

        void *dl;

        if ((dl = dlopen("libnss_myhostname.so.2", RTLD_LAZY))) {
                dlclose(dl);
                return true;
        }

        return false;
}

static const char* fallback_icon_name(void) {

#if defined(__i386__) || defined(__x86_64__)
        int r;
        char *type;
        unsigned t;
#endif

        if (detect_virtualization(NULL) > 0)
                return "computer-vm";

#if defined(__i386__) || defined(__x86_64__)
        r = read_one_line_file("/sys/class/dmi/id/chassis_type", &type);
        if (r < 0)
                return NULL;

        r = safe_atou(type, &t);
        free(type);

        if (r < 0)
                return NULL;

        /* We only list the really obvious cases here. The DMI data is
           unreliable enough, so let's not do any additional guesswork
           on top of that.

           See the SMBIOS Specification 2.7.1 section 7.4.1 for
           details about the values listed here:

           http://www.dmtf.org/sites/default/files/standards/documents/DSP0134_2.7.1.pdf
         */

        switch (t) {

        case 0x3:
        case 0x4:
        case 0x6:
        case 0x7:
                return "computer-desktop";

        case 0x9:
        case 0xA:
        case 0xE:
                return "computer-laptop";

        case 0x11:
        case 0x1C:
                return "computer-server";
        }

#endif
        return NULL;
}

static int write_data_hostname(void) {
        const char *hn;

        if (isempty(data[PROP_HOSTNAME]))
                hn = "localhost";
        else
                hn = data[PROP_HOSTNAME];

        if (sethostname(hn, strlen(hn)) < 0)
                return -errno;

        return 0;
}

static int write_data_static_hostname(void) {

        if (isempty(data[PROP_STATIC_HOSTNAME])) {

                if (unlink("/etc/hostname") < 0)
                        return errno == ENOENT ? 0 : -errno;

                return 0;
        }

        return write_one_line_file_atomic("/etc/hostname", data[PROP_STATIC_HOSTNAME]);
}

static int write_data_other(void) {

        static const char * const name[_PROP_MAX] = {
                [PROP_PRETTY_HOSTNAME] = "PRETTY_HOSTNAME",
                [PROP_ICON_NAME] = "ICON_NAME"
        };

        char **l = NULL;
        int r, p;

        r = load_env_file("/etc/machine-info", &l);
        if (r < 0 && r != -ENOENT)
                return r;

        for (p = 2; p < _PROP_MAX; p++) {
                char *t, **u;

                assert(name[p]);

                if (isempty(data[p]))  {
                        l = strv_env_unset(l, name[p]);
                        continue;
                }

                if (asprintf(&t, "%s=%s", name[p], strempty(data[p])) < 0) {
                        strv_free(l);
                        return -ENOMEM;
                }

                u = strv_env_set(l, t);
                free(t);
                strv_free(l);

                if (!u)
                        return -ENOMEM;
                l = u;
        }

        if (strv_isempty(l)) {

                if (unlink("/etc/machine-info") < 0)
                        return errno == ENOENT ? 0 : -errno;

                return 0;
        }

        r = write_env_file("/etc/machine-info", l);
        strv_free(l);

        return r;
}

static int bus_hostname_append_icon_name(DBusMessageIter *i, const char *property, void *userdata) {
        const char *name;

        assert(i);
        assert(property);

        if (isempty(data[PROP_ICON_NAME]))
                name = fallback_icon_name();
        else
                name = data[PROP_ICON_NAME];

        return bus_property_append_string(i, property, (void*) name);
}

static DBusHandlerResult hostname_message_handler(
                DBusConnection *connection,
                DBusMessage *message,
                void *userdata) {

        const BusProperty properties[] = {
                { "org.freedesktop.hostname1", "Hostname",       bus_property_append_string,    "s", data[PROP_HOSTNAME]},
                { "org.freedesktop.hostname1", "StaticHostname", bus_property_append_string,    "s", data[PROP_STATIC_HOSTNAME]},
                { "org.freedesktop.hostname1", "PrettyHostname", bus_property_append_string,    "s", data[PROP_PRETTY_HOSTNAME]},
                { "org.freedesktop.hostname1", "IconName",       bus_hostname_append_icon_name, "s", data[PROP_ICON_NAME]},
                { NULL, NULL, NULL, NULL, NULL }
        };

        DBusMessage *reply = NULL, *changed = NULL;
        DBusError error;
        int r;

        assert(connection);
        assert(message);

        dbus_error_init(&error);

        if (dbus_message_is_method_call(message, "org.freedesktop.hostname1", "SetHostname")) {
                const char *name;
                dbus_bool_t interactive;

                if (!dbus_message_get_args(
                                    message,
                                    &error,
                                    DBUS_TYPE_STRING, &name,
                                    DBUS_TYPE_BOOLEAN, &interactive,
                                    DBUS_TYPE_INVALID))
                        return bus_send_error_reply(connection, message, &error, -EINVAL);

                if (isempty(name))
                        name = data[PROP_STATIC_HOSTNAME];

                if (isempty(name))
                        name = "localhost";

                if (!hostname_is_valid(name))
                        return bus_send_error_reply(connection, message, NULL, -EINVAL);

                if (!streq_ptr(name, data[PROP_HOSTNAME])) {
                        char *h;

                        r = verify_polkit(connection, message, "org.freedesktop.hostname1.set-hostname", interactive, &error);
                        if (r < 0)
                                return bus_send_error_reply(connection, message, &error, r);

                        h = strdup(name);
                        if (!h)
                                goto oom;

                        free(data[PROP_HOSTNAME]);
                        data[PROP_HOSTNAME] = h;

                        r = write_data_hostname();
                        if (r < 0) {
                                log_error("Failed to set host name: %s", strerror(-r));
                                return bus_send_error_reply(connection, message, NULL, r);
                        }

                        log_info("Changed host name to '%s'", strempty(data[PROP_HOSTNAME]));

                        changed = bus_properties_changed_new(
                                        "/org/freedesktop/hostname1",
                                        "org.freedesktop.hostname1",
                                        "Hostname\0");
                        if (!changed)
                                goto oom;
                }

        } else if (dbus_message_is_method_call(message, "org.freedesktop.hostname1", "SetStaticHostname")) {
                const char *name;
                dbus_bool_t interactive;

                if (!dbus_message_get_args(
                                    message,
                                    &error,
                                    DBUS_TYPE_STRING, &name,
                                    DBUS_TYPE_BOOLEAN, &interactive,
                                    DBUS_TYPE_INVALID))
                        return bus_send_error_reply(connection, message, &error, -EINVAL);

                if (isempty(name))
                        name = NULL;

                if (!streq_ptr(name, data[PROP_STATIC_HOSTNAME])) {

                        r = verify_polkit(connection, message, "org.freedesktop.hostname1.set-static-hostname", interactive, &error);
                        if (r < 0)
                                return bus_send_error_reply(connection, message, &error, r);

                        if (isempty(name)) {
                                free(data[PROP_STATIC_HOSTNAME]);
                                data[PROP_STATIC_HOSTNAME] = NULL;
                        } else {
                                char *h;

                                if (!hostname_is_valid(name))
                                        return bus_send_error_reply(connection, message, NULL, -EINVAL);

                                h = strdup(name);
                                if (!h)
                                        goto oom;

                                free(data[PROP_STATIC_HOSTNAME]);
                                data[PROP_STATIC_HOSTNAME] = h;
                        }

                        r = write_data_static_hostname();
                        if (r < 0) {
                                log_error("Failed to write static host name: %s", strerror(-r));
                                return bus_send_error_reply(connection, message, NULL, r);
                        }

                        log_info("Changed static host name to '%s'", strempty(data[PROP_HOSTNAME]));

                        changed = bus_properties_changed_new(
                                        "/org/freedesktop/hostname1",
                                        "org.freedesktop.hostname1",
                                        "StaticHostname\0");
                        if (!changed)
                                goto oom;
                }

        } else if (dbus_message_is_method_call(message, "org.freedesktop.hostname1", "SetPrettyHostname") ||
                   dbus_message_is_method_call(message, "org.freedesktop.hostname1", "SetIconName")) {

                const char *name;
                dbus_bool_t interactive;
                int k;

                if (!dbus_message_get_args(
                                    message,
                                    &error,
                                    DBUS_TYPE_STRING, &name,
                                    DBUS_TYPE_BOOLEAN, &interactive,
                                    DBUS_TYPE_INVALID))
                        return bus_send_error_reply(connection, message, &error, -EINVAL);

                if (isempty(name))
                        name = NULL;

                k = streq(dbus_message_get_member(message), "SetPrettyHostname") ? PROP_PRETTY_HOSTNAME : PROP_ICON_NAME;

                if (!streq_ptr(name, data[k])) {

                        /* Since the pretty hostname should always be
                         * changed at the same time as the static one,
                         * use the same policy action for both... */

                        r = verify_polkit(connection, message, k == PROP_PRETTY_HOSTNAME ?
                                          "org.freedesktop.hostname1.set-static-hostname" :
                                          "org.freedesktop.hostname1.set-machine-info", interactive, &error);
                        if (r < 0)
                                return bus_send_error_reply(connection, message, &error, r);

                        if (isempty(name)) {
                                free(data[k]);
                                data[k] = NULL;
                        } else {
                                char *h;

                                h = strdup(name);
                                if (!h)
                                        goto oom;

                                free(data[k]);
                                data[k] = h;
                        }

                        r = write_data_other();
                        if (r < 0) {
                                log_error("Failed to write machine info: %s", strerror(-r));
                                return bus_send_error_reply(connection, message, NULL, r);
                        }

                        log_info("Changed %s to '%s'", k == PROP_PRETTY_HOSTNAME ? "pretty host name" : "icon name", strempty(data[k]));

                        changed = bus_properties_changed_new(
                                        "/org/freedesktop/hostname1",
                                        "org.freedesktop.hostname1",
                                        k == PROP_PRETTY_HOSTNAME ? "PrettyHostname\0" : "IconName\0");
                        if (!changed)
                                goto oom;
                }

        } else
                return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, properties);

        if (!(reply = dbus_message_new_method_return(message)))
                goto oom;

        if (!dbus_connection_send(connection, reply, NULL))
                goto oom;

        dbus_message_unref(reply);
        reply = NULL;

        if (changed) {

                if (!dbus_connection_send(connection, changed, NULL))
                        goto oom;

                dbus_message_unref(changed);
        }

        return DBUS_HANDLER_RESULT_HANDLED;

oom:
        if (reply)
                dbus_message_unref(reply);

        if (changed)
                dbus_message_unref(changed);

        dbus_error_free(&error);

        return DBUS_HANDLER_RESULT_NEED_MEMORY;
}

static int connect_bus(DBusConnection **_bus) {
        static const DBusObjectPathVTable hostname_vtable = {
                .message_function = hostname_message_handler
        };
        DBusError error;
        DBusConnection *bus = NULL;
        int r;

        assert(_bus);

        dbus_error_init(&error);

        bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
        if (!bus) {
                log_error("Failed to get system D-Bus connection: %s", bus_error_message(&error));
                r = -ECONNREFUSED;
                goto fail;
        }

        if (!dbus_connection_register_object_path(bus, "/org/freedesktop/hostname1", &hostname_vtable, NULL)) {
                log_error("Not enough memory");
                r = -ENOMEM;
                goto fail;
        }

        if (dbus_bus_request_name(bus, "org.freedesktop.hostname1", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) < 0) {
                log_error("Failed to register name on bus: %s", error.message);
                r = -EEXIST;
                goto fail;
        }

        if (_bus)
                *_bus = bus;

        return 0;

fail:
        dbus_connection_close(bus);
        dbus_connection_unref(bus);

        dbus_error_free(&error);

        return r;
}

int main(int argc, char *argv[]) {
        int r;
        DBusConnection *bus = NULL;

        log_set_target(LOG_TARGET_AUTO);
        log_parse_environment();
        log_open();

        if (argc == 2 && streq(argv[1], "--introspect")) {
                fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
                      "<node>\n", stdout);
                fputs(hostname_interface, stdout);
                fputs("</node>\n", stdout);
                return 0;
        }

        if (argc != 1) {
                log_error("This program takes no arguments.");
                r = -EINVAL;
                goto finish;
        }

        if (!check_nss())
                log_warning("Warning: nss-myhostname is not installed. Changing the local hostname might make it unresolveable. Please install nss-myhostname!");

        umask(0022);

        r = read_data();
        if (r < 0) {
                log_error("Failed to read hostname data: %s", strerror(-r));
                goto finish;
        }

        r = connect_bus(&bus);
        if (r < 0)
                goto finish;

        while (dbus_connection_read_write_dispatch(bus, -1))
                ;

        r = 0;

finish:
        free_data();

        if (bus) {
                dbus_connection_flush(bus);
                dbus_connection_close(bus);
                dbus_connection_unref(bus);
        }

        return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
Commit	Line	Data
7640a5de LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
41550d40	6	Copyright 2011 Lennart Poettering
7640a5de LP	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <dbus/dbus.h>
	23
	24	#include <errno.h>
	25	#include <string.h>
	26	#include <unistd.h>
c2a14cf0	27	#include <dlfcn.h>
7640a5de LP	28
	29	#include "util.h"
	30	#include "strv.h"
	31	#include "dbus-common.h"
f401e48c	32	#include "polkit.h"
7640a5de	33
91f9dcaf	34	#define INTERFACE \
7640a5de LP	35	" <interface name=\"org.freedesktop.hostname1\">\n" \
	36	" <property name=\"Hostname\" type=\"s\" access=\"read\"/>\n" \
	37	" <property name=\"StaticHostname\" type=\"s\" access=\"read\"/>\n" \
	38	" <property name=\"PrettyHostname\" type=\"s\" access=\"read\"/>\n" \
	39	" <property name=\"IconName\" type=\"s\" access=\"read\"/>\n" \
	40	" <method name=\"SetHostname\">\n" \
	41	" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
	42	" <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
	43	" </method>\n" \
	44	" <method name=\"SetStaticHostname\">\n" \
	45	" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
	46	" <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
	47	" </method>\n" \
	48	" <method name=\"SetPrettyHostname\">\n" \
	49	" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
	50	" <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
	51	" </method>\n" \
	52	" <method name=\"SetIconName\">\n" \
	53	" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
	54	" <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
	55	" </method>\n" \
91f9dcaf LP	56	" </interface>\n"
	57
	58	#define INTROSPECTION \
	59	DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \
	60	"<node>\n" \
	61	INTERFACE \
7640a5de LP	62	BUS_PROPERTIES_INTERFACE \
	63	BUS_INTROSPECTABLE_INTERFACE \
	64	BUS_PEER_INTERFACE \
	65	"</node>\n"
	66
	67	#define INTERFACES_LIST \
	68	BUS_GENERIC_INTERFACES_LIST \
	69	"org.freedesktop.hostname1\0"
	70
91f9dcaf LP	71	const char hostname_interface[] _introspect_("hostname1") = INTERFACE;
91f9dcaf LP	72
7640a5de LP	73	enum {
	74	PROP_HOSTNAME,
	75	PROP_STATIC_HOSTNAME,
	76	PROP_PRETTY_HOSTNAME,
	77	PROP_ICON_NAME,
	78	_PROP_MAX
	79	};
	80
	81	static char *data[_PROP_MAX] = {
	82	NULL,
	83	NULL,
	84	NULL,
	85	NULL
	86	};
	87
	88	static void free_data(void) {
	89	int p;
	90
	91	for (p = 0; p < _PROP_MAX; p++) {
	92	free(data[p]);
	93	data[p] = NULL;
	94	}
	95	}
	96
	97	static int read_data(void) {
	98	int r;
	99
	100	free_data();
	101
	102	data[PROP_HOSTNAME] = gethostname_malloc();
	103	if (!data[PROP_HOSTNAME])
	104	return -ENOMEM;
	105
	106	r = read_one_line_file("/etc/hostname", &data[PROP_STATIC_HOSTNAME]);
	107	if (r < 0 && r != -ENOENT)
	108	return r;
	109
	110	r = parse_env_file("/etc/machine-info", NEWLINE,
	111	"PRETTY_HOSTNAME", &data[PROP_PRETTY_HOSTNAME],
	112	"ICON_NAME", &data[PROP_ICON_NAME],
	113	NULL);
	114	if (r < 0 && r != -ENOENT)
	115	return r;
	116
	117	return 0;
	118	}
	119
c2a14cf0 LP	120	static bool check_nss(void) {
	121
	122	void *dl;
	123
	124	if ((dl = dlopen("libnss_myhostname.so.2", RTLD_LAZY))) {
	125	dlclose(dl);
	126	return true;
	127	}
	128
	129	return false;
	130	}
	131
7640a5de LP	132	static const char* fallback_icon_name(void) {
	133
	134	#if defined(__i386__) \|\| defined(__x86_64__)
	135	int r;
	136	char *type;
	137	unsigned t;
	138	#endif
	139
	140	if (detect_virtualization(NULL) > 0)
	141	return "computer-vm";
	142
	143	#if defined(__i386__) \|\| defined(__x86_64__)
	144	r = read_one_line_file("/sys/class/dmi/id/chassis_type", &type);
	145	if (r < 0)
	146	return NULL;
	147
	148	r = safe_atou(type, &t);
	149	free(type);
	150
	151	if (r < 0)
	152	return NULL;
	153
	154	/* We only list the really obvious cases here. The DMI data is
	155	unreliable enough, so let's not do any additional guesswork
41550d40 LP	156	on top of that.
	157
	158	See the SMBIOS Specification 2.7.1 section 7.4.1 for
	159	details about the values listed here:
	160
	161	http://www.dmtf.org/sites/default/files/standards/documents/DSP0134_2.7.1.pdf
	162	*/
7640a5de LP	163
	164	switch (t) {
	165
	166	case 0x3:
	167	case 0x4:
	168	case 0x6:
	169	case 0x7:
	170	return "computer-desktop";
	171
	172	case 0x9:
	173	case 0xA:
	174	case 0xE:
	175	return "computer-laptop";
	176
	177	case 0x11:
41550d40	178	case 0x1C:
7640a5de LP	179	return "computer-server";
	180	}
	181
	182	#endif
	183	return NULL;
	184	}
	185
	186	static int write_data_hostname(void) {
	187	const char *hn;
	188
	189	if (isempty(data[PROP_HOSTNAME]))
	190	hn = "localhost";
	191	else
	192	hn = data[PROP_HOSTNAME];
	193
	194	if (sethostname(hn, strlen(hn)) < 0)
	195	return -errno;
	196
	197	return 0;
	198	}
	199
	200	static int write_data_static_hostname(void) {
	201
	202	if (isempty(data[PROP_STATIC_HOSTNAME])) {
	203
	204	if (unlink("/etc/hostname") < 0)
	205	return errno == ENOENT ? 0 : -errno;
	206
	207	return 0;
	208	}
	209
34ca941c	210	return write_one_line_file_atomic("/etc/hostname", data[PROP_STATIC_HOSTNAME]);
7640a5de LP	211	}
	212
	213	static int write_data_other(void) {
4f34ed54	214
7640a5de LP	215	static const char * const name[_PROP_MAX] = {
	216	[PROP_PRETTY_HOSTNAME] = "PRETTY_HOSTNAME",
	217	[PROP_ICON_NAME] = "ICON_NAME"
	218	};
	219
	220	char **l = NULL;
	221	int r, p;
	222
	223	r = load_env_file("/etc/machine-info", &l);
	224	if (r < 0 && r != -ENOENT)
	225	return r;
	226
	227	for (p = 2; p < _PROP_MAX; p++) {
	228	char t, *u;
	229
	230	assert(name[p]);
	231
	232	if (isempty(data[p])) {
	233	l = strv_env_unset(l, name[p]);
	234	continue;
	235	}
	236
	237	if (asprintf(&t, "%s=%s", name[p], strempty(data[p])) < 0) {
	238	strv_free(l);
	239	return -ENOMEM;
	240	}
	241
	242	u = strv_env_set(l, t);
	243	free(t);
	244	strv_free(l);
	245
	246	if (!u)
	247	return -ENOMEM;
	248	l = u;
	249	}
	250
	251	if (strv_isempty(l)) {
	252
	253	if (unlink("/etc/machine-info") < 0)
	254	return errno == ENOENT ? 0 : -errno;
	255
	256	return 0;
	257	}
	258
	259	r = write_env_file("/etc/machine-info", l);
	260	strv_free(l);
	261
	262	return r;
	263	}
	264
7640a5de LP	265	static int bus_hostname_append_icon_name(DBusMessageIter i, const char property, void *userdata) {
	266	const char *name;
	267
	268	assert(i);
	269	assert(property);
	270
	271	if (isempty(data[PROP_ICON_NAME]))
	272	name = fallback_icon_name();
	273	else
	274	name = data[PROP_ICON_NAME];
	275
	276	return bus_property_append_string(i, property, (void*) name);
	277	}
	278
	279	static DBusHandlerResult hostname_message_handler(
	280	DBusConnection *connection,
	281	DBusMessage *message,
	282	void *userdata) {
	283
	284	const BusProperty properties[] = {
	285	{ "org.freedesktop.hostname1", "Hostname", bus_property_append_string, "s", data[PROP_HOSTNAME]},
	286	{ "org.freedesktop.hostname1", "StaticHostname", bus_property_append_string, "s", data[PROP_STATIC_HOSTNAME]},
	287	{ "org.freedesktop.hostname1", "PrettyHostname", bus_property_append_string, "s", data[PROP_PRETTY_HOSTNAME]},
	288	{ "org.freedesktop.hostname1", "IconName", bus_hostname_append_icon_name, "s", data[PROP_ICON_NAME]},
	289	{ NULL, NULL, NULL, NULL, NULL }
	290	};
	291
	292	DBusMessage reply = NULL, changed = NULL;
	293	DBusError error;
	294	int r;
	295
	296	assert(connection);
	297	assert(message);
	298
	299	dbus_error_init(&error);
	300
	301	if (dbus_message_is_method_call(message, "org.freedesktop.hostname1", "SetHostname")) {
	302	const char *name;
	303	dbus_bool_t interactive;
	304
	305	if (!dbus_message_get_args(
	306	message,
	307	&error,
	308	DBUS_TYPE_STRING, &name,
	309	DBUS_TYPE_BOOLEAN, &interactive,
	310	DBUS_TYPE_INVALID))
	311	return bus_send_error_reply(connection, message, &error, -EINVAL);
	312
	313	if (isempty(name))
	314	name = data[PROP_STATIC_HOSTNAME];
	315
	316	if (isempty(name))
	317	name = "localhost";
	318
	319	if (!hostname_is_valid(name))
	320	return bus_send_error_reply(connection, message, NULL, -EINVAL);
	321
	322	if (!streq_ptr(name, data[PROP_HOSTNAME])) {
	323	char *h;
	324
	325	r = verify_polkit(connection, message, "org.freedesktop.hostname1.set-hostname", interactive, &error);
	326	if (r < 0)
	327	return bus_send_error_reply(connection, message, &error, r);
	328
329	h = strdup(name);
330	if (!h)
331	goto oom;
332
333	free(data[PROP_HOSTNAME]);
334	data[PROP_HOSTNAME] = h;
335
336	r = write_data_hostname();
4f34ed54 LP	337	if (r < 0) {
4f34ed54 LP	338	log_error("Failed to set host name: %s", strerror(-r));
7640a5de	339	return bus_send_error_reply(connection, message, NULL, r);
4f34ed54	340	}
7640a5de	341
4f34ed54	342	log_info("Changed host name to '%s'", strempty(data[PROP_HOSTNAME]));
7640a5de LP	343
	344	changed = bus_properties_changed_new(
	345	"/org/freedesktop/hostname1",
	346	"org.freedesktop.hostname1",
	347	"Hostname\0");
	348	if (!changed)
	349	goto oom;
	350	}
	351
	352	} else if (dbus_message_is_method_call(message, "org.freedesktop.hostname1", "SetStaticHostname")) {
	353	const char *name;
	354	dbus_bool_t interactive;
	355
	356	if (!dbus_message_get_args(
	357	message,
	358	&error,
	359	DBUS_TYPE_STRING, &name,
	360	DBUS_TYPE_BOOLEAN, &interactive,
	361	DBUS_TYPE_INVALID))
	362	return bus_send_error_reply(connection, message, &error, -EINVAL);
	363
	364	if (isempty(name))
	365	name = NULL;
	366
	367	if (!streq_ptr(name, data[PROP_STATIC_HOSTNAME])) {
	368
	369	r = verify_polkit(connection, message, "org.freedesktop.hostname1.set-static-hostname", interactive, &error);
	370	if (r < 0)
	371	return bus_send_error_reply(connection, message, &error, r);
	372
	373	if (isempty(name)) {
	374	free(data[PROP_STATIC_HOSTNAME]);
	375	data[PROP_STATIC_HOSTNAME] = NULL;
	376	} else {
	377	char *h;
	378
	379	if (!hostname_is_valid(name))
	380	return bus_send_error_reply(connection, message, NULL, -EINVAL);
	381
	382	h = strdup(name);
	383	if (!h)
	384	goto oom;
	385
	386	free(data[PROP_STATIC_HOSTNAME]);
	387	data[PROP_STATIC_HOSTNAME] = h;
	388	}
	389
	390	r = write_data_static_hostname();
4f34ed54 LP	391	if (r < 0) {
4f34ed54 LP	392	log_error("Failed to write static host name: %s", strerror(-r));
7640a5de	393	return bus_send_error_reply(connection, message, NULL, r);
4f34ed54	394	}
7640a5de	395
4f34ed54	396	log_info("Changed static host name to '%s'", strempty(data[PROP_HOSTNAME]));
7640a5de LP	397
	398	changed = bus_properties_changed_new(
	399	"/org/freedesktop/hostname1",
	400	"org.freedesktop.hostname1",
	401	"StaticHostname\0");
	402	if (!changed)
	403	goto oom;
	404	}
	405
	406	} else if (dbus_message_is_method_call(message, "org.freedesktop.hostname1", "SetPrettyHostname") \|\|
	407	dbus_message_is_method_call(message, "org.freedesktop.hostname1", "SetIconName")) {
	408
	409	const char *name;
	410	dbus_bool_t interactive;
	411	int k;
	412
	413	if (!dbus_message_get_args(
	414	message,
	415	&error,
	416	DBUS_TYPE_STRING, &name,
	417	DBUS_TYPE_BOOLEAN, &interactive,
	418	DBUS_TYPE_INVALID))
	419	return bus_send_error_reply(connection, message, &error, -EINVAL);
	420
	421	if (isempty(name))
	422	name = NULL;
	423
	424	k = streq(dbus_message_get_member(message), "SetPrettyHostname") ? PROP_PRETTY_HOSTNAME : PROP_ICON_NAME;
	425
	426	if (!streq_ptr(name, data[k])) {
	427
88a07670 LP	428	/* Since the pretty hostname should always be
	429	* changed at the same time as the static one,
	430	* use the same policy action for both... */
	431
	432	r = verify_polkit(connection, message, k == PROP_PRETTY_HOSTNAME ?
	433	"org.freedesktop.hostname1.set-static-hostname" :
	434	"org.freedesktop.hostname1.set-machine-info", interactive, &error);
7640a5de LP	435	if (r < 0)
	436	return bus_send_error_reply(connection, message, &error, r);
	437
	438	if (isempty(name)) {
	439	free(data[k]);
	440	data[k] = NULL;
	441	} else {
	442	char *h;
	443
	444	h = strdup(name);
	445	if (!h)
	446	goto oom;
	447
	448	free(data[k]);
	449	data[k] = h;
	450	}
	451
	452	r = write_data_other();
4f34ed54 LP	453	if (r < 0) {
4f34ed54 LP	454	log_error("Failed to write machine info: %s", strerror(-r));
7640a5de	455	return bus_send_error_reply(connection, message, NULL, r);
4f34ed54	456	}
7640a5de	457
4f34ed54	458	log_info("Changed %s to '%s'", k == PROP_PRETTY_HOSTNAME ? "pretty host name" : "icon name", strempty(data[k]));
7640a5de LP	459
	460	changed = bus_properties_changed_new(
	461	"/org/freedesktop/hostname1",
	462	"org.freedesktop.hostname1",
	463	k == PROP_PRETTY_HOSTNAME ? "PrettyHostname\0" : "IconName\0");
	464	if (!changed)
	465	goto oom;
	466	}
	467
	468	} else
	469	return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, properties);
	470
	471	if (!(reply = dbus_message_new_method_return(message)))
	472	goto oom;
	473
	474	if (!dbus_connection_send(connection, reply, NULL))
	475	goto oom;
	476
	477	dbus_message_unref(reply);
	478	reply = NULL;
	479
	480	if (changed) {
	481
	482	if (!dbus_connection_send(connection, changed, NULL))
	483	goto oom;
	484
	485	dbus_message_unref(changed);
	486	}
	487
	488	return DBUS_HANDLER_RESULT_HANDLED;
	489
	490	oom:
	491	if (reply)
	492	dbus_message_unref(reply);
	493
	494	if (changed)
	495	dbus_message_unref(changed);
	496
	497	dbus_error_free(&error);
	498
	499	return DBUS_HANDLER_RESULT_NEED_MEMORY;
	500	}
	501
d0baa06f LP	502	static int connect_bus(DBusConnection **_bus) {
d0baa06f LP	503	static const DBusObjectPathVTable hostname_vtable = {
7640a5de LP	504	.message_function = hostname_message_handler
7640a5de LP	505	};
7640a5de	506	DBusError error;
d0baa06f	507	DBusConnection *bus = NULL;
7640a5de LP	508	int r;
7640a5de LP	509
d0baa06f LP	510	assert(_bus);
d0baa06f LP	511
7640a5de LP	512	dbus_error_init(&error);
7640a5de LP	513
d0baa06f LP	514	bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
d0baa06f LP	515	if (!bus) {
a2e52832	516	log_error("Failed to get system D-Bus connection: %s", bus_error_message(&error));
d0baa06f LP	517	r = -ECONNREFUSED;
	518	goto fail;
	519	}
	520
	521	if (!dbus_connection_register_object_path(bus, "/org/freedesktop/hostname1", &hostname_vtable, NULL)) {
	522	log_error("Not enough memory");
	523	r = -ENOMEM;
	524	goto fail;
	525	}
	526
	527	if (dbus_bus_request_name(bus, "org.freedesktop.hostname1", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) < 0) {
	528	log_error("Failed to register name on bus: %s", error.message);
	529	r = -EEXIST;
	530	goto fail;
	531	}
	532
	533	if (_bus)
	534	*_bus = bus;
	535
	536	return 0;
	537
	538	fail:
	539	dbus_connection_close(bus);
	540	dbus_connection_unref(bus);
	541
	542	dbus_error_free(&error);
	543
	544	return r;
	545	}
	546
	547	int main(int argc, char *argv[]) {
	548	int r;
	549	DBusConnection *bus = NULL;
	550
7640a5de LP	551	log_set_target(LOG_TARGET_AUTO);
	552	log_parse_environment();
	553	log_open();
	554
91f9dcaf LP	555	if (argc == 2 && streq(argv[1], "--introspect")) {
	556	fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
	557	"<node>\n", stdout);
	558	fputs(hostname_interface, stdout);
	559	fputs("</node>\n", stdout);
	560	return 0;
	561	}
	562
7640a5de LP	563	if (argc != 1) {
	564	log_error("This program takes no arguments.");
	565	r = -EINVAL;
	566	goto finish;
	567	}
	568
c2a14cf0 LP	569	if (!check_nss())
	570	log_warning("Warning: nss-myhostname is not installed. Changing the local hostname might make it unresolveable. Please install nss-myhostname!");
	571
7640a5de LP	572	umask(0022);
	573
	574	r = read_data();
	575	if (r < 0) {
	576	log_error("Failed to read hostname data: %s", strerror(-r));
	577	goto finish;
	578	}
	579
d0baa06f LP	580	r = connect_bus(&bus);
d0baa06f LP	581	if (r < 0)
7640a5de	582	goto finish;
7640a5de LP	583
	584	while (dbus_connection_read_write_dispatch(bus, -1))
	585	;
	586
	587	r = 0;
	588
	589	finish:
	590	free_data();
	591
	592	if (bus) {
	593	dbus_connection_flush(bus);
	594	dbus_connection_close(bus);
	595	dbus_connection_unref(bus);
	596	}
	597
7640a5de LP	598	return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
7640a5de LP	599	}