chiark / gitweb /
doc: disable "make check" for gtk-doc
[elogind.git] / src / hostname / hostnamed.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2011 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 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   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser 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>
27 #include <dlfcn.h>
28
29 #include "util.h"
30 #include "strv.h"
31 #include "dbus-common.h"
32 #include "polkit.h"
33 #include "def.h"
34 #include "virt.h"
35
36 #define INTERFACE \
37         " <interface name=\"org.freedesktop.hostname1\">\n"             \
38         "  <property name=\"Hostname\" type=\"s\" access=\"read\"/>\n"  \
39         "  <property name=\"StaticHostname\" type=\"s\" access=\"read\"/>\n" \
40         "  <property name=\"PrettyHostname\" type=\"s\" access=\"read\"/>\n" \
41         "  <property name=\"IconName\" type=\"s\" access=\"read\"/>\n"  \
42         "  <property name=\"Chassis\" type=\"s\" access=\"read\"/>\n"   \
43         "  <method name=\"SetHostname\">\n"                             \
44         "   <arg name=\"name\" type=\"s\" direction=\"in\"/>\n"         \
45         "   <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
46         "  </method>\n"                                                 \
47         "  <method name=\"SetStaticHostname\">\n"                       \
48         "   <arg name=\"name\" type=\"s\" direction=\"in\"/>\n"         \
49         "   <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
50         "  </method>\n"                                                 \
51         "  <method name=\"SetPrettyHostname\">\n"                       \
52         "   <arg name=\"name\" type=\"s\" direction=\"in\"/>\n"         \
53         "   <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
54         "  </method>\n"                                                 \
55         "  <method name=\"SetIconName\">\n"                             \
56         "   <arg name=\"name\" type=\"s\" direction=\"in\"/>\n"         \
57         "   <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
58         "  </method>\n"                                                 \
59         "  <method name=\"SetChassis\">\n"                              \
60         "   <arg name=\"name\" type=\"s\" direction=\"in\"/>\n"         \
61         "   <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
62         "  </method>\n"                                                 \
63         " </interface>\n"
64
65 #define INTROSPECTION                                                   \
66         DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE                       \
67         "<node>\n"                                                      \
68         INTERFACE                                                       \
69         BUS_PROPERTIES_INTERFACE                                        \
70         BUS_INTROSPECTABLE_INTERFACE                                    \
71         BUS_PEER_INTERFACE                                              \
72         "</node>\n"
73
74 #define INTERFACES_LIST                         \
75         BUS_GENERIC_INTERFACES_LIST             \
76         "org.freedesktop.hostname1\0"
77
78 const char hostname_interface[] _introspect_("hostname1") = INTERFACE;
79
80 enum {
81         PROP_HOSTNAME,
82         PROP_STATIC_HOSTNAME,
83         PROP_PRETTY_HOSTNAME,
84         PROP_ICON_NAME,
85         PROP_CHASSIS,
86         _PROP_MAX
87 };
88
89 static char *data[_PROP_MAX] = {
90         NULL,
91         NULL,
92         NULL,
93         NULL,
94         NULL
95 };
96
97 static usec_t remain_until = 0;
98
99 static void free_data(void) {
100         int p;
101
102         for (p = 0; p < _PROP_MAX; p++) {
103                 free(data[p]);
104                 data[p] = NULL;
105         }
106 }
107
108 static int read_data(void) {
109         int r;
110
111         free_data();
112
113         data[PROP_HOSTNAME] = gethostname_malloc();
114         if (!data[PROP_HOSTNAME])
115                 return -ENOMEM;
116
117         r = read_one_line_file("/etc/hostname", &data[PROP_STATIC_HOSTNAME]);
118         if (r < 0 && r != -ENOENT)
119                 return r;
120
121         r = parse_env_file("/etc/machine-info", NEWLINE,
122                            "PRETTY_HOSTNAME", &data[PROP_PRETTY_HOSTNAME],
123                            "ICON_NAME", &data[PROP_ICON_NAME],
124                            "CHASSIS", &data[PROP_CHASSIS],
125                            NULL);
126         if (r < 0 && r != -ENOENT)
127                 return r;
128
129         return 0;
130 }
131
132 static bool check_nss(void) {
133         void *dl;
134
135         dl = dlopen("libnss_myhostname.so.2", RTLD_LAZY);
136         if (dl) {
137                 dlclose(dl);
138                 return true;
139         }
140
141         return false;
142 }
143
144 static bool valid_chassis(const char *chassis) {
145
146         assert(chassis);
147
148         return nulstr_contains(
149                         "vm\0"
150                         "container\0"
151                         "desktop\0"
152                         "laptop\0"
153                         "server\0"
154                         "tablet\0"
155                         "handset\0",
156                         chassis);
157 }
158
159 static const char* fallback_chassis(void) {
160         int r;
161         char *type;
162         unsigned t;
163         Virtualization v;
164
165         v = detect_virtualization(NULL);
166
167         if (v == VIRTUALIZATION_VM)
168                 return "vm";
169         if (v == VIRTUALIZATION_CONTAINER)
170                 return "container";
171
172         r = read_one_line_file("/sys/firmware/acpi/pm_profile", &type);
173         if (r < 0)
174                 goto try_dmi;
175
176         r = safe_atou(type, &t);
177         free(type);
178         if (r < 0)
179                 goto try_dmi;
180
181         /* We only list the really obvious cases here as the ACPI data
182          * is not really super reliable.
183          *
184          * See the ACPI 5.0 Spec Section 5.2.9.1 for details:
185          *
186          * http://www.acpi.info/DOWNLOADS/ACPIspec50.pdf
187          */
188
189         switch(t) {
190
191         case 1:
192         case 3:
193         case 6:
194                 return "desktop";
195
196         case 2:
197                 return "laptop";
198
199         case 4:
200         case 5:
201         case 7:
202                 return "server";
203
204         case 8:
205                 return "tablet";
206         }
207
208 try_dmi:
209         r = read_one_line_file("/sys/class/dmi/id/chassis_type", &type);
210         if (r < 0)
211                 return NULL;
212
213         r = safe_atou(type, &t);
214         free(type);
215         if (r < 0)
216                 return NULL;
217
218         /* We only list the really obvious cases here. The DMI data is
219            unreliable enough, so let's not do any additional guesswork
220            on top of that.
221
222            See the SMBIOS Specification 2.7.1 section 7.4.1 for
223            details about the values listed here:
224
225            http://www.dmtf.org/sites/default/files/standards/documents/DSP0134_2.7.1.pdf
226          */
227
228         switch (t) {
229
230         case 0x3:
231         case 0x4:
232         case 0x6:
233         case 0x7:
234                 return "desktop";
235
236         case 0x8:
237         case 0x9:
238         case 0xA:
239         case 0xE:
240                 return "laptop";
241
242         case 0xB:
243                 return "handset";
244
245         case 0x11:
246         case 0x1C:
247                 return "server";
248         }
249
250         return NULL;
251 }
252
253 static char* fallback_icon_name(void) {
254         const char *chassis;
255
256         if (!isempty(data[PROP_CHASSIS]))
257                 return strappend("computer-", data[PROP_CHASSIS]);
258
259         chassis = fallback_chassis();
260         if (chassis)
261                 return strappend("computer-", chassis);
262
263         return strdup("computer");
264 }
265
266 static int write_data_hostname(void) {
267         const char *hn;
268
269         if (isempty(data[PROP_HOSTNAME]))
270                 hn = "localhost";
271         else
272                 hn = data[PROP_HOSTNAME];
273
274         if (sethostname(hn, strlen(hn)) < 0)
275                 return -errno;
276
277         return 0;
278 }
279
280 static int write_data_static_hostname(void) {
281
282         if (isempty(data[PROP_STATIC_HOSTNAME])) {
283
284                 if (unlink("/etc/hostname") < 0)
285                         return errno == ENOENT ? 0 : -errno;
286
287                 return 0;
288         }
289
290         return write_one_line_file_atomic("/etc/hostname", data[PROP_STATIC_HOSTNAME]);
291 }
292
293 static int write_data_other(void) {
294
295         static const char * const name[_PROP_MAX] = {
296                 [PROP_PRETTY_HOSTNAME] = "PRETTY_HOSTNAME",
297                 [PROP_ICON_NAME] = "ICON_NAME",
298                 [PROP_CHASSIS] = "CHASSIS"
299         };
300
301         char **l = NULL;
302         int r, p;
303
304         r = load_env_file("/etc/machine-info", &l);
305         if (r < 0 && r != -ENOENT)
306                 return r;
307
308         for (p = 2; p < _PROP_MAX; p++) {
309                 char *t, **u;
310
311                 assert(name[p]);
312
313                 if (isempty(data[p]))  {
314                         strv_env_unset(l, name[p]);
315                         continue;
316                 }
317
318                 if (asprintf(&t, "%s=%s", name[p], strempty(data[p])) < 0) {
319                         strv_free(l);
320                         return -ENOMEM;
321                 }
322
323                 u = strv_env_set(l, t);
324                 free(t);
325                 strv_free(l);
326
327                 if (!u)
328                         return -ENOMEM;
329                 l = u;
330         }
331
332         if (strv_isempty(l)) {
333
334                 if (unlink("/etc/machine-info") < 0)
335                         return errno == ENOENT ? 0 : -errno;
336
337                 return 0;
338         }
339
340         r = write_env_file("/etc/machine-info", l);
341         strv_free(l);
342
343         return r;
344 }
345
346 static int bus_hostname_append_icon_name(DBusMessageIter *i, const char *property, void *userdata) {
347         const char *name;
348         _cleanup_free_ char *n = NULL;
349
350         assert(i);
351         assert(property);
352
353         if (isempty(data[PROP_ICON_NAME]))
354                 name = n = fallback_icon_name();
355         else
356                 name = data[PROP_ICON_NAME];
357
358         return bus_property_append_string(i, property, (void*) name);
359 }
360
361 static int bus_hostname_append_chassis(DBusMessageIter *i, const char *property, void *userdata) {
362         const char *name;
363
364         assert(i);
365         assert(property);
366
367         if (isempty(data[PROP_CHASSIS]))
368                 name = fallback_chassis();
369         else
370                 name = data[PROP_CHASSIS];
371
372         return bus_property_append_string(i, property, (void*) name);
373 }
374
375 static const BusProperty bus_hostname_properties[] = {
376         { "Hostname",       bus_property_append_string,    "s", sizeof(data[0])*PROP_HOSTNAME,        true },
377         { "StaticHostname", bus_property_append_string,    "s", sizeof(data[0])*PROP_STATIC_HOSTNAME, true },
378         { "PrettyHostname", bus_property_append_string,    "s", sizeof(data[0])*PROP_PRETTY_HOSTNAME, true },
379         { "IconName",       bus_hostname_append_icon_name, "s", sizeof(data[0])*PROP_ICON_NAME,       true },
380         { "Chassis",        bus_hostname_append_chassis,   "s", sizeof(data[0])*PROP_CHASSIS,         true },
381         { NULL, }
382 };
383
384 static const BusBoundProperties bps[] = {
385         { "org.freedesktop.hostname1", bus_hostname_properties, data },
386         { NULL, }
387 };
388
389 static DBusHandlerResult hostname_message_handler(
390                 DBusConnection *connection,
391                 DBusMessage *message,
392                 void *userdata) {
393
394
395         DBusMessage *reply = NULL, *changed = NULL;
396         DBusError error;
397         int r;
398
399         assert(connection);
400         assert(message);
401
402         dbus_error_init(&error);
403
404         if (dbus_message_is_method_call(message, "org.freedesktop.hostname1", "SetHostname")) {
405                 const char *name;
406                 dbus_bool_t interactive;
407
408                 if (!dbus_message_get_args(
409                                     message,
410                                     &error,
411                                     DBUS_TYPE_STRING, &name,
412                                     DBUS_TYPE_BOOLEAN, &interactive,
413                                     DBUS_TYPE_INVALID))
414                         return bus_send_error_reply(connection, message, &error, -EINVAL);
415
416                 if (isempty(name))
417                         name = data[PROP_STATIC_HOSTNAME];
418
419                 if (isempty(name))
420                         name = "localhost";
421
422                 if (!hostname_is_valid(name))
423                         return bus_send_error_reply(connection, message, NULL, -EINVAL);
424
425                 if (!streq_ptr(name, data[PROP_HOSTNAME])) {
426                         char *h;
427
428                         r = verify_polkit(connection, message, "org.freedesktop.hostname1.set-hostname", interactive, NULL, &error);
429                         if (r < 0)
430                                 return bus_send_error_reply(connection, message, &error, r);
431
432                         h = strdup(name);
433                         if (!h)
434                                 goto oom;
435
436                         free(data[PROP_HOSTNAME]);
437                         data[PROP_HOSTNAME] = h;
438
439                         r = write_data_hostname();
440                         if (r < 0) {
441                                 log_error("Failed to set host name: %s", strerror(-r));
442                                 return bus_send_error_reply(connection, message, NULL, r);
443                         }
444
445                         log_info("Changed host name to '%s'", strempty(data[PROP_HOSTNAME]));
446
447                         changed = bus_properties_changed_new(
448                                         "/org/freedesktop/hostname1",
449                                         "org.freedesktop.hostname1",
450                                         "Hostname\0");
451                         if (!changed)
452                                 goto oom;
453                 }
454
455         } else if (dbus_message_is_method_call(message, "org.freedesktop.hostname1", "SetStaticHostname")) {
456                 const char *name;
457                 dbus_bool_t interactive;
458
459                 if (!dbus_message_get_args(
460                                     message,
461                                     &error,
462                                     DBUS_TYPE_STRING, &name,
463                                     DBUS_TYPE_BOOLEAN, &interactive,
464                                     DBUS_TYPE_INVALID))
465                         return bus_send_error_reply(connection, message, &error, -EINVAL);
466
467                 if (isempty(name))
468                         name = NULL;
469
470                 if (!streq_ptr(name, data[PROP_STATIC_HOSTNAME])) {
471
472                         r = verify_polkit(connection, message, "org.freedesktop.hostname1.set-static-hostname", interactive, NULL, &error);
473                         if (r < 0)
474                                 return bus_send_error_reply(connection, message, &error, r);
475
476                         if (isempty(name)) {
477                                 free(data[PROP_STATIC_HOSTNAME]);
478                                 data[PROP_STATIC_HOSTNAME] = NULL;
479                         } else {
480                                 char *h;
481
482                                 if (!hostname_is_valid(name))
483                                         return bus_send_error_reply(connection, message, NULL, -EINVAL);
484
485                                 h = strdup(name);
486                                 if (!h)
487                                         goto oom;
488
489                                 free(data[PROP_STATIC_HOSTNAME]);
490                                 data[PROP_STATIC_HOSTNAME] = h;
491                         }
492
493                         r = write_data_static_hostname();
494                         if (r < 0) {
495                                 log_error("Failed to write static host name: %s", strerror(-r));
496                                 return bus_send_error_reply(connection, message, NULL, r);
497                         }
498
499                         log_info("Changed static host name to '%s'", strempty(data[PROP_STATIC_HOSTNAME]));
500
501                         changed = bus_properties_changed_new(
502                                         "/org/freedesktop/hostname1",
503                                         "org.freedesktop.hostname1",
504                                         "StaticHostname\0");
505                         if (!changed)
506                                 goto oom;
507                 }
508
509         } else if (dbus_message_is_method_call(message, "org.freedesktop.hostname1", "SetPrettyHostname") ||
510                    dbus_message_is_method_call(message, "org.freedesktop.hostname1", "SetIconName") ||
511                    dbus_message_is_method_call(message, "org.freedesktop.hostname1", "SetChassis")) {
512
513                 const char *name;
514                 dbus_bool_t interactive;
515                 int k;
516
517                 if (!dbus_message_get_args(
518                                     message,
519                                     &error,
520                                     DBUS_TYPE_STRING, &name,
521                                     DBUS_TYPE_BOOLEAN, &interactive,
522                                     DBUS_TYPE_INVALID))
523                         return bus_send_error_reply(connection, message, &error, -EINVAL);
524
525                 if (isempty(name))
526                         name = NULL;
527
528                 k = streq(dbus_message_get_member(message), "SetPrettyHostname") ? PROP_PRETTY_HOSTNAME :
529                         streq(dbus_message_get_member(message), "SetChassis") ? PROP_CHASSIS : PROP_ICON_NAME;
530
531                 if (!streq_ptr(name, data[k])) {
532
533                         /* Since the pretty hostname should always be
534                          * changed at the same time as the static one,
535                          * use the same policy action for both... */
536
537                         r = verify_polkit(connection, message, k == PROP_PRETTY_HOSTNAME ?
538                                           "org.freedesktop.hostname1.set-static-hostname" :
539                                           "org.freedesktop.hostname1.set-machine-info", interactive, NULL, &error);
540                         if (r < 0)
541                                 return bus_send_error_reply(connection, message, &error, r);
542
543                         if (isempty(name)) {
544                                 free(data[k]);
545                                 data[k] = NULL;
546                         } else {
547                                 char *h;
548
549                                 /* The icon name might ultimately be
550                                  * used as file name, so better be
551                                  * safe than sorry */
552                                 if (k == PROP_ICON_NAME && !filename_is_safe(name))
553                                         return bus_send_error_reply(connection, message, NULL, -EINVAL);
554                                 if (k == PROP_PRETTY_HOSTNAME && !string_is_safe(name))
555                                         return bus_send_error_reply(connection, message, NULL, -EINVAL);
556                                 if (k == PROP_CHASSIS && !valid_chassis(name))
557                                         return bus_send_error_reply(connection, message, NULL, -EINVAL);
558
559                                 h = strdup(name);
560                                 if (!h)
561                                         goto oom;
562
563                                 free(data[k]);
564                                 data[k] = h;
565                         }
566
567                         r = write_data_other();
568                         if (r < 0) {
569                                 log_error("Failed to write machine info: %s", strerror(-r));
570                                 return bus_send_error_reply(connection, message, NULL, r);
571                         }
572
573                         log_info("Changed %s to '%s'",
574                                  k == PROP_PRETTY_HOSTNAME ? "pretty host name" :
575                                  k == PROP_CHASSIS ? "chassis" : "icon name", strempty(data[k]));
576
577                         changed = bus_properties_changed_new(
578                                         "/org/freedesktop/hostname1",
579                                         "org.freedesktop.hostname1",
580                                         k == PROP_PRETTY_HOSTNAME ? "PrettyHostname\0" :
581                                         k == PROP_CHASSIS ? "Chassis\0" : "IconName\0");
582                         if (!changed)
583                                 goto oom;
584                 }
585
586         } else
587                 return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, bps);
588
589         reply = dbus_message_new_method_return(message);
590         if (!reply)
591                 goto oom;
592
593         if (!dbus_connection_send(connection, reply, NULL))
594                 goto oom;
595
596         dbus_message_unref(reply);
597         reply = NULL;
598
599         if (changed) {
600
601                 if (!dbus_connection_send(connection, changed, NULL))
602                         goto oom;
603
604                 dbus_message_unref(changed);
605         }
606
607         return DBUS_HANDLER_RESULT_HANDLED;
608
609 oom:
610         if (reply)
611                 dbus_message_unref(reply);
612
613         if (changed)
614                 dbus_message_unref(changed);
615
616         dbus_error_free(&error);
617
618         return DBUS_HANDLER_RESULT_NEED_MEMORY;
619 }
620
621 static int connect_bus(DBusConnection **_bus) {
622         static const DBusObjectPathVTable hostname_vtable = {
623                 .message_function = hostname_message_handler
624         };
625         DBusError error;
626         DBusConnection *bus = NULL;
627         int r;
628
629         assert(_bus);
630
631         dbus_error_init(&error);
632
633         bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
634         if (!bus) {
635                 log_error("Failed to get system D-Bus connection: %s", bus_error_message(&error));
636                 r = -ECONNREFUSED;
637                 goto fail;
638         }
639
640         dbus_connection_set_exit_on_disconnect(bus, FALSE);
641
642         if (!dbus_connection_register_object_path(bus, "/org/freedesktop/hostname1", &hostname_vtable, NULL) ||
643             !dbus_connection_add_filter(bus, bus_exit_idle_filter, &remain_until, NULL)) {
644                 r = log_oom();
645                 goto fail;
646         }
647
648         r = dbus_bus_request_name(bus, "org.freedesktop.hostname1", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error);
649         if (dbus_error_is_set(&error)) {
650                 log_error("Failed to register name on bus: %s", bus_error_message(&error));
651                 r = -EEXIST;
652                 goto fail;
653         }
654
655         if (r != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
656                 log_error("Failed to acquire name.");
657                 r = -EEXIST;
658                 goto fail;
659         }
660
661         if (_bus)
662                 *_bus = bus;
663
664         return 0;
665
666 fail:
667         dbus_connection_close(bus);
668         dbus_connection_unref(bus);
669
670         dbus_error_free(&error);
671
672         return r;
673 }
674
675 int main(int argc, char *argv[]) {
676         int r;
677         DBusConnection *bus = NULL;
678         bool exiting = false;
679
680         log_set_target(LOG_TARGET_AUTO);
681         log_parse_environment();
682         log_open();
683
684         umask(0022);
685
686         if (argc == 2 && streq(argv[1], "--introspect")) {
687                 fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
688                       "<node>\n", stdout);
689                 fputs(hostname_interface, stdout);
690                 fputs("</node>\n", stdout);
691                 return 0;
692         }
693
694         if (argc != 1) {
695                 log_error("This program takes no arguments.");
696                 r = -EINVAL;
697                 goto finish;
698         }
699
700         if (!check_nss())
701                 log_warning("Warning: nss-myhostname is not installed. Changing the local hostname might make it unresolveable. Please install nss-myhostname!");
702
703         r = read_data();
704         if (r < 0) {
705                 log_error("Failed to read hostname data: %s", strerror(-r));
706                 goto finish;
707         }
708
709         r = connect_bus(&bus);
710         if (r < 0)
711                 goto finish;
712
713         remain_until = now(CLOCK_MONOTONIC) + DEFAULT_EXIT_USEC;
714         for (;;) {
715
716                 if (!dbus_connection_read_write_dispatch(bus, exiting ? -1 : (int) (DEFAULT_EXIT_USEC/USEC_PER_MSEC)))
717                         break;
718
719                 if (!exiting && remain_until < now(CLOCK_MONOTONIC)) {
720                         exiting = true;
721                         bus_async_unregister_and_exit(bus, "org.freedesktop.hostname1");
722                 }
723         }
724
725         r = 0;
726
727 finish:
728         free_data();
729
730         if (bus) {
731                 dbus_connection_flush(bus);
732                 dbus_connection_close(bus);
733                 dbus_connection_unref(bus);
734         }
735
736         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
737 }