src/hostname/hostnamectl.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2012 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 <getopt.h>
  23 #include <locale.h>
  24 #include <stdbool.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "sd-bus.h"
  29 #include "sd-id128.h"
  30
  31 #include "architecture.h"
  32 #include "bus-error.h"
  33 #include "bus-util.h"
  34 #include "hostname-util.h"
  35 #include "spawn-polkit-agent.h"
  36 #include "util.h"
  37
  38 static bool arg_ask_password = true;
  39 static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
  40 static char *arg_host = NULL;
  41 static bool arg_transient = false;
  42 static bool arg_pretty = false;
  43 static bool arg_static = false;
  44
  45 static void polkit_agent_open_if_enabled(void) {
  46
  47         /* Open the polkit agent as a child process if necessary */
  48         if (!arg_ask_password)
  49                 return;
  50
  51         if (arg_transport != BUS_TRANSPORT_LOCAL)
  52                 return;
  53
  54         polkit_agent_open();
  55 }
  56
  57 typedef struct StatusInfo {
  58         char *hostname;
  59         char *static_hostname;
  60         char *pretty_hostname;
  61         char *icon_name;
  62         char *chassis;
  63         char *deployment;
  64         char *location;
  65         char *kernel_name;
  66         char *kernel_release;
  67         char *os_pretty_name;
  68         char *os_cpe_name;
  69         char *virtualization;
  70         char *architecture;
  71 } StatusInfo;
  72
  73 static void print_status_info(StatusInfo *i) {
  74         sd_id128_t mid = {}, bid = {};
  75         int r;
  76
  77         assert(i);
  78
  79         printf("   Static hostname: %s\n", strna(i->static_hostname));
  80
  81         if (!isempty(i->pretty_hostname) &&
  82             !streq_ptr(i->pretty_hostname, i->static_hostname))
  83                 printf("   Pretty hostname: %s\n", i->pretty_hostname);
  84
  85         if (!isempty(i->hostname) &&
  86             !streq_ptr(i->hostname, i->static_hostname))
  87                 printf("Transient hostname: %s\n", i->hostname);
  88
  89         if (!isempty(i->icon_name))
  90                 printf("         Icon name: %s\n",
  91                        strna(i->icon_name));
  92
  93         if (!isempty(i->chassis))
  94                 printf("           Chassis: %s\n",
  95                        strna(i->chassis));
  96
  97         if (!isempty(i->deployment))
  98                 printf("        Deployment: %s\n", i->deployment);
  99
 100         if (!isempty(i->location))
 101                 printf("          Location: %s\n", i->location);
 102
 103         r = sd_id128_get_machine(&mid);
 104         if (r >= 0)
 105                 printf("        Machine ID: " SD_ID128_FORMAT_STR "\n", SD_ID128_FORMAT_VAL(mid));
 106
 107         r = sd_id128_get_boot(&bid);
 108         if (r >= 0)
 109                 printf("           Boot ID: " SD_ID128_FORMAT_STR "\n", SD_ID128_FORMAT_VAL(bid));
 110
 111         if (!isempty(i->virtualization))
 112                 printf("    Virtualization: %s\n", i->virtualization);
 113
 114         if (!isempty(i->os_pretty_name))
 115                 printf("  Operating System: %s\n", i->os_pretty_name);
 116
 117         if (!isempty(i->os_cpe_name))
 118                 printf("       CPE OS Name: %s\n", i->os_cpe_name);
 119
 120         if (!isempty(i->kernel_name) && !isempty(i->kernel_release))
 121                 printf("            Kernel: %s %s\n", i->kernel_name, i->kernel_release);
 122
 123         if (!isempty(i->architecture))
 124                 printf("      Architecture: %s\n", i->architecture);
 125
 126 }
 127
 128 static int show_one_name(sd_bus *bus, const char* attr) {
 129         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
 130         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 131         const char *s;
 132         int r;
 133
 134         r = sd_bus_get_property(
 135                         bus,
 136                         "org.freedesktop.hostname1",
 137                         "/org/freedesktop/hostname1",
 138                         "org.freedesktop.hostname1",
 139                         attr,
 140                         &error, &reply, "s");
 141         if (r < 0) {
 142                 log_error("Could not get property: %s", bus_error_message(&error, -r));
 143                 return r;
 144         }
 145
 146         r = sd_bus_message_read(reply, "s", &s);
 147         if (r < 0)
 148                 return bus_log_parse_error(r);
 149
 150         printf("%s\n", s);
 151
 152         return 0;
 153 }
 154
 155 static int show_all_names(sd_bus *bus) {
 156         StatusInfo info = {};
 157
 158         static const struct bus_properties_map hostname_map[]  = {
 159                 { "Hostname",                  "s", NULL, offsetof(StatusInfo, hostname)        },
 160                 { "StaticHostname",            "s", NULL, offsetof(StatusInfo, static_hostname) },
 161                 { "PrettyHostname",            "s", NULL, offsetof(StatusInfo, pretty_hostname) },
 162                 { "IconName",                  "s", NULL, offsetof(StatusInfo, icon_name)       },
 163                 { "Chassis",                   "s", NULL, offsetof(StatusInfo, chassis)         },
 164                 { "Deployment",                "s", NULL, offsetof(StatusInfo, deployment)      },
 165                 { "Location",                  "s", NULL, offsetof(StatusInfo, location)        },
 166                 { "KernelName",                "s", NULL, offsetof(StatusInfo, kernel_name)     },
 167                 { "KernelRelease",             "s", NULL, offsetof(StatusInfo, kernel_release)  },
 168                 { "OperatingSystemPrettyName", "s", NULL, offsetof(StatusInfo, os_pretty_name)  },
 169                 { "OperatingSystemCPEName",    "s", NULL, offsetof(StatusInfo, os_cpe_name)     },
 170                 {}
 171         };
 172
 173         static const struct bus_properties_map manager_map[] = {
 174                 { "Virtualization",            "s", NULL, offsetof(StatusInfo, virtualization)  },
 175                 { "Architecture",              "s", NULL, offsetof(StatusInfo, architecture)    },
 176                 {}
 177         };
 178
 179         int r;
 180
 181         r = bus_map_all_properties(bus,
 182                                    "org.freedesktop.hostname1",
 183                                    "/org/freedesktop/hostname1",
 184                                    hostname_map,
 185                                    &info);
 186         if (r < 0)
 187                 goto fail;
 188
 189         bus_map_all_properties(bus,
 190                                "org.freedesktop.systemd1",
 191                                "/org/freedesktop/systemd1",
 192                                manager_map,
 193                                &info);
 194
 195         print_status_info(&info);
 196
 197 fail:
 198         free(info.hostname);
 199         free(info.static_hostname);
 200         free(info.pretty_hostname);
 201         free(info.icon_name);
 202         free(info.chassis);
 203         free(info.deployment);
 204         free(info.location);
 205         free(info.kernel_name);
 206         free(info.kernel_release);
 207         free(info.os_pretty_name);
 208         free(info.os_cpe_name);
 209         free(info.virtualization);
 210         free(info.architecture);
 211
 212         return r;
 213 }
 214
 215 static int show_status(sd_bus *bus, char **args, unsigned n) {
 216         assert(args);
 217
 218         if (arg_pretty || arg_static || arg_transient) {
 219                 const char *attr;
 220
 221                 if (!!arg_static + !!arg_pretty + !!arg_transient > 1) {
 222                         log_error("Cannot query more than one name type at a time");
 223                         return -EINVAL;
 224                 }
 225
 226                 attr = arg_pretty ? "PrettyHostname" :
 227                         arg_static ? "StaticHostname" : "Hostname";
 228
 229                 return show_one_name(bus, attr);
 230         } else
 231                 return show_all_names(bus);
 232 }
 233
 234 static int set_simple_string(sd_bus *bus, const char *method, const char *value) {
 235         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 236         int r = 0;
 237
 238         polkit_agent_open_if_enabled();
 239
 240         r = sd_bus_call_method(
 241                         bus,
 242                         "org.freedesktop.hostname1",
 243                         "/org/freedesktop/hostname1",
 244                         "org.freedesktop.hostname1",
 245                         method,
 246                         &error, NULL,
 247                         "sb", value, arg_ask_password);
 248         if (r < 0)
 249                 log_error("Could not set property: %s", bus_error_message(&error, -r));
 250         return r;
 251 }
 252
 253 static int set_hostname(sd_bus *bus, char **args, unsigned n) {
 254         _cleanup_free_ char *h = NULL;
 255         char *hostname = args[1];
 256         int r;
 257
 258         assert(args);
 259         assert(n == 2);
 260
 261         if (!arg_pretty && !arg_static && !arg_transient)
 262                 arg_pretty = arg_static = arg_transient = true;
 263
 264         if (arg_pretty) {
 265                 const char *p;
 266
 267                 /* If the passed hostname is already valid, then
 268                  * assume the user doesn't know anything about pretty
 269                  * hostnames, so let's unset the pretty hostname, and
 270                  * just set the passed hostname as static/dynamic
 271                  * hostname. */
 272
 273                 if (arg_static && hostname_is_valid(hostname, true)) {
 274                         p = "";
 275                         /* maybe get rid of trailing dot */
 276                         hostname = hostname_cleanup(hostname);
 277                 } else {
 278                         p = h = strdup(hostname);
 279                         if (!p)
 280                                 return log_oom();
 281
 282                         hostname_cleanup(hostname);
 283                 }
 284
 285                 r = set_simple_string(bus, "SetPrettyHostname", p);
 286                 if (r < 0)
 287                         return r;
 288         }
 289
 290         if (arg_static) {
 291                 r = set_simple_string(bus, "SetStaticHostname", hostname);
 292                 if (r < 0)
 293                         return r;
 294         }
 295
 296         if (arg_transient) {
 297                 r = set_simple_string(bus, "SetHostname", hostname);
 298                 if (r < 0)
 299                         return r;
 300         }
 301
 302         return 0;
 303 }
 304
 305 static int set_icon_name(sd_bus *bus, char **args, unsigned n) {
 306         assert(args);
 307         assert(n == 2);
 308
 309         return set_simple_string(bus, "SetIconName", args[1]);
 310 }
 311
 312 static int set_chassis(sd_bus *bus, char **args, unsigned n) {
 313         assert(args);
 314         assert(n == 2);
 315
 316         return set_simple_string(bus, "SetChassis", args[1]);
 317 }
 318
 319 static int set_deployment(sd_bus *bus, char **args, unsigned n) {
 320         assert(args);
 321         assert(n == 2);
 322
 323         return set_simple_string(bus, "SetDeployment", args[1]);
 324 }
 325
 326 static int set_location(sd_bus *bus, char **args, unsigned n) {
 327         assert(args);
 328         assert(n == 2);
 329
 330         return set_simple_string(bus, "SetLocation", args[1]);
 331 }
 332
 333 static void help(void) {
 334         printf("%s [OPTIONS...] COMMAND ...\n\n"
 335                "Query or change system hostname.\n\n"
 336                "  -h --help              Show this help\n"
 337                "     --version           Show package version\n"
 338                "     --no-ask-password   Do not prompt for password\n"
 339                "  -H --host=[USER@]HOST  Operate on remote host\n"
 340                "  -M --machine=CONTAINER Operate on local container\n"
 341                "     --transient         Only set transient hostname\n"
 342                "     --static            Only set static hostname\n"
 343                "     --pretty            Only set pretty hostname\n\n"
 344                "Commands:\n"
 345                "  status                 Show current hostname settings\n"
 346                "  set-hostname NAME      Set system hostname\n"
 347                "  set-icon-name NAME     Set icon name for host\n"
 348                "  set-chassis NAME       Set chassis type for host\n"
 349                "  set-deployment NAME    Set deployment environment for host\n"
 350                "  set-location NAME      Set location for host\n"
 351                , program_invocation_short_name);
 352 }
 353
 354 static int parse_argv(int argc, char *argv[]) {
 355
 356         enum {
 357                 ARG_VERSION = 0x100,
 358                 ARG_NO_ASK_PASSWORD,
 359                 ARG_TRANSIENT,
 360                 ARG_STATIC,
 361                 ARG_PRETTY
 362         };
 363
 364         static const struct option options[] = {
 365                 { "help",            no_argument,       NULL, 'h'                 },
 366                 { "version",         no_argument,       NULL, ARG_VERSION         },
 367                 { "transient",       no_argument,       NULL, ARG_TRANSIENT       },
 368                 { "static",          no_argument,       NULL, ARG_STATIC          },
 369                 { "pretty",          no_argument,       NULL, ARG_PRETTY          },
 370                 { "host",            required_argument, NULL, 'H'                 },
 371                 { "machine",         required_argument, NULL, 'M'                 },
 372                 { "no-ask-password", no_argument,       NULL, ARG_NO_ASK_PASSWORD },
 373                 {}
 374         };
 375
 376         int c;
 377
 378         assert(argc >= 0);
 379         assert(argv);
 380
 381         while ((c = getopt_long(argc, argv, "hH:M:", options, NULL)) >= 0)
 382
 383                 switch (c) {
 384
 385                 case 'h':
 386                         help();
 387                         return 0;
 388
 389                 case ARG_VERSION:
 390                         return version();
 391
 392                 case 'H':
 393                         arg_transport = BUS_TRANSPORT_REMOTE;
 394                         arg_host = optarg;
 395                         break;
 396
 397                 case 'M':
 398                         arg_transport = BUS_TRANSPORT_MACHINE;
 399                         arg_host = optarg;
 400                         break;
 401
 402                 case ARG_TRANSIENT:
 403                         arg_transient = true;
 404                         break;
 405
 406                 case ARG_PRETTY:
 407                         arg_pretty = true;
 408                         break;
 409
 410                 case ARG_STATIC:
 411                         arg_static = true;
 412                         break;
 413
 414                 case ARG_NO_ASK_PASSWORD:
 415                         arg_ask_password = false;
 416                         break;
 417
 418                 case '?':
 419                         return -EINVAL;
 420
 421                 default:
 422                         assert_not_reached("Unhandled option");
 423                 }
 424
 425         return 1;
 426 }
 427
 428 static int hostnamectl_main(sd_bus *bus, int argc, char *argv[]) {
 429
 430         static const struct {
 431                 const char* verb;
 432                 const enum {
 433                         MORE,
 434                         LESS,
 435                         EQUAL
 436                 } argc_cmp;
 437                 const int argc;
 438                 int (* const dispatch)(sd_bus *bus, char **args, unsigned n);
 439         } verbs[] = {
 440                 { "status",           LESS,  1, show_status    },
 441                 { "set-hostname",     EQUAL, 2, set_hostname   },
 442                 { "set-icon-name",    EQUAL, 2, set_icon_name  },
 443                 { "set-chassis",      EQUAL, 2, set_chassis    },
 444                 { "set-deployment",   EQUAL, 2, set_deployment },
 445                 { "set-location",     EQUAL, 2, set_location   },
 446         };
 447
 448         int left;
 449         unsigned i;
 450
 451         assert(argc >= 0);
 452         assert(argv);
 453
 454         left = argc - optind;
 455
 456         if (left <= 0)
 457                 /* Special rule: no arguments means "status" */
 458                 i = 0;
 459         else {
 460                 if (streq(argv[optind], "help")) {
 461                         help();
 462                         return 0;
 463                 }
 464
 465                 for (i = 0; i < ELEMENTSOF(verbs); i++)
 466                         if (streq(argv[optind], verbs[i].verb))
 467                                 break;
 468
 469                 if (i >= ELEMENTSOF(verbs)) {
 470                         log_error("Unknown operation %s", argv[optind]);
 471                         return -EINVAL;
 472                 }
 473         }
 474
 475         switch (verbs[i].argc_cmp) {
 476
 477         case EQUAL:
 478                 if (left != verbs[i].argc) {
 479                         log_error("Invalid number of arguments.");
 480                         return -EINVAL;
 481                 }
 482
 483                 break;
 484
 485         case MORE:
 486                 if (left < verbs[i].argc) {
 487                         log_error("Too few arguments.");
 488                         return -EINVAL;
 489                 }
 490
 491                 break;
 492
 493         case LESS:
 494                 if (left > verbs[i].argc) {
 495                         log_error("Too many arguments.");
 496                         return -EINVAL;
 497                 }
 498
 499                 break;
 500
 501         default:
 502                 assert_not_reached("Unknown comparison operator.");
 503         }
 504
 505         return verbs[i].dispatch(bus, argv + optind, left);
 506 }
 507
 508 int main(int argc, char *argv[]) {
 509         _cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
 510         int r;
 511
 512         setlocale(LC_ALL, "");
 513         log_parse_environment();
 514         log_open();
 515
 516         r = parse_argv(argc, argv);
 517         if (r <= 0)
 518                 goto finish;
 519
 520         r = bus_connect_transport(arg_transport, arg_host, false, &bus);
 521         if (r < 0) {
 522                 log_error_errno(r, "Failed to create bus connection: %m");
 523                 goto finish;
 524         }
 525
 526         r = hostnamectl_main(bus, argc, argv);
 527
 528 finish:
 529         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 530 }