src/shared/pretty-print.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <sys/utsname.h>
   4 #include <errno.h>
   5 #include <stdio.h>
   6
   7 #include "alloc-util.h"
   8 #include "conf-files.h"
   9 #include "def.h"
  10 #include "env-util.h"
  11 #include "fd-util.h"
  12 #include "fileio.h"
  13 #include "pager.h"
  14 #include "path-util.h"
  15 #include "pretty-print.h"
  16 #include "string-util.h"
  17 #include "strv.h"
  18 #include "terminal-util.h"
  19 #include "util.h"
  20
  21 static bool urlify_enabled(void) {
  22         static int cached_urlify_enabled = -1;
  23
  24         /* Unfortunately 'less' doesn't support links like this yet 😭, hence let's disable this as long as there's a
  25          * pager in effect. Let's drop this check as soon as less got fixed a and enough time passed so that it's safe
  26          * to assume that a link-enabled 'less' version has hit most installations. */
  27
  28         if (cached_urlify_enabled < 0) {
  29                 int val;
  30
  31                 val = getenv_bool("SYSTEMD_URLIFY");
  32                 if (val >= 0)
  33                         cached_urlify_enabled = val;
  34                 else
  35                         cached_urlify_enabled = colors_enabled() && !pager_have();
  36         }
  37
  38         return cached_urlify_enabled;
  39 }
  40
  41 int terminal_urlify(const char *url, const char *text, char **ret) {
  42         char *n;
  43
  44         assert(url);
  45
  46         /* Takes an URL and a pretty string and formats it as clickable link for the terminal. See
  47          * https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda for details. */
  48
  49         if (isempty(text))
  50                 text = url;
  51
  52         if (urlify_enabled())
  53                 n = strjoin("\x1B]8;;", url, "\a", text, "\x1B]8;;\a");
  54         else
  55                 n = strdup(text);
  56         if (!n)
  57                 return -ENOMEM;
  58
  59         *ret = n;
  60         return 0;
  61 }
  62
  63 int file_url_from_path(const char *path, char **ret) {
  64         _cleanup_free_ char *absolute = NULL;
  65         struct utsname u;
  66         char *url = NULL;
  67         int r;
  68
  69         if (uname(&u) < 0)
  70                 return -errno;
  71
  72         if (!path_is_absolute(path)) {
  73                 r = path_make_absolute_cwd(path, &absolute);
  74                 if (r < 0)
  75                         return r;
  76
  77                 path = absolute;
  78         }
  79
  80         /* As suggested by https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda, let's include the local
  81          * hostname here. Note that we don't use gethostname_malloc() or gethostname_strict() since we are interested
  82          * in the raw string the kernel has set, whatever it may be, under the assumption that terminals are not overly
  83          * careful with validating the strings either. */
  84
  85         url = strjoin("file://", u.nodename, path);
  86         if (!url)
  87                 return -ENOMEM;
  88
  89         *ret = url;
  90         return 0;
  91 }
  92
  93 int terminal_urlify_path(const char *path, const char *text, char **ret) {
  94         _cleanup_free_ char *url = NULL;
  95         int r;
  96
  97         assert(path);
  98
  99         /* Much like terminal_urlify() above, but takes a file system path as input
 100          * and turns it into a proper file:// URL first. */
 101
 102         if (isempty(path))
 103                 return -EINVAL;
 104
 105         if (isempty(text))
 106                 text = path;
 107
 108         if (!urlify_enabled()) {
 109                 char *n;
 110
 111                 n = strdup(text);
 112                 if (!n)
 113                         return -ENOMEM;
 114
 115                 *ret = n;
 116                 return 0;
 117         }
 118
 119         r = file_url_from_path(path, &url);
 120         if (r < 0)
 121                 return r;
 122
 123         return terminal_urlify(url, text, ret);
 124 }
 125
 126 int terminal_urlify_man(const char *page, const char *section, char **ret) {
 127         const char *url, *text;
 128
 129         url = strjoina("man:", page, "(", section, ")");
 130         text = strjoina(page, "(", section, ") man page");
 131
 132         return terminal_urlify(url, text, ret);
 133 }
 134
 135 static int cat_file(const char *filename, bool newline) {
 136         _cleanup_fclose_ FILE *f = NULL;
 137         _cleanup_free_ char *urlified = NULL;
 138         int r;
 139
 140         f = fopen(filename, "re");
 141         if (!f)
 142                 return -errno;
 143
 144         r = terminal_urlify_path(filename, NULL, &urlified);
 145         if (r < 0)
 146                 return r;
 147
 148         printf("%s%s# %s%s\n",
 149                newline ? "\n" : "",
 150                ansi_highlight_blue(),
 151                urlified,
 152                ansi_normal());
 153         fflush(stdout);
 154
 155         for (;;) {
 156                 _cleanup_free_ char *line = NULL;
 157
 158                 r = read_line(f, LONG_LINE_MAX, &line);
 159                 if (r < 0)
 160                         return log_error_errno(r, "Failed to read \"%s\": %m", filename);
 161                 if (r == 0)
 162                         break;
 163
 164                 puts(line);
 165         }
 166
 167         return 0;
 168 }
 169
 170 int cat_files(const char *file, char **dropins, CatFlags flags) {
 171         char **path;
 172         int r;
 173
 174         if (file) {
 175                 r = cat_file(file, false);
 176                 if (r == -ENOENT && (flags & CAT_FLAGS_MAIN_FILE_OPTIONAL))
 177                         printf("%s# config file %s not found%s\n",
 178                                ansi_highlight_magenta(),
 179                                file,
 180                                ansi_normal());
 181                 else if (r < 0)
 182                         return log_warning_errno(r, "Failed to cat %s: %m", file);
 183         }
 184
 185         STRV_FOREACH(path, dropins) {
 186                 r = cat_file(*path, file || path != dropins);
 187                 if (r < 0)
 188                         return log_warning_errno(r, "Failed to cat %s: %m", *path);
 189         }
 190
 191         return 0;
 192 }
 193
 194 void print_separator(void) {
 195
 196         /* Outputs a separator line that resolves to whitespace when copied from the terminal. We do that by outputting
 197          * one line filled with spaces with ANSI underline set, followed by a second (empty) line. */
 198
 199         if (underline_enabled()) {
 200                 size_t i, c;
 201
 202                 c = columns();
 203
 204                 flockfile(stdout);
 205                 fputs_unlocked(ANSI_UNDERLINE, stdout);
 206
 207                 for (i = 0; i < c; i++)
 208                         fputc_unlocked(' ', stdout);
 209
 210                 fputs_unlocked(ANSI_NORMAL "\n\n", stdout);
 211                 funlockfile(stdout);
 212         } else
 213                 fputs("\n\n", stdout);
 214 }
 215
 216 static int guess_type(const char **name, char ***prefixes, bool *is_collection, const char **extension) {
 217         /* Try to figure out if name is like tmpfiles.d/ or systemd/system-presets/,
 218          * i.e. a collection of directories without a main config file. */
 219
 220         _cleanup_free_ char *n = NULL;
 221         bool usr = false, run = false, coll = false;
 222         const char *ext = ".conf";
 223         /* This is static so that the array doesn't get deallocated when we exit the function */
 224         static const char* const std_prefixes[] = { CONF_PATHS(""), NULL };
 225         static const char* const usr_prefixes[] = { CONF_PATHS_USR(""), NULL };
 226         static const char* const run_prefixes[] = { "/run/", NULL };
 227
 228         if (path_equal(*name, "environment.d"))
 229                 /* Special case: we need to include /etc/environment in the search path, even
 230                  * though the whole concept is called environment.d. */
 231                 *name = "environment";
 232
 233         n = strdup(*name);
 234         if (!n)
 235                 return log_oom();
 236
 237         delete_trailing_chars(n, "/");
 238
 239         if (endswith(n, ".d"))
 240                 coll = true;
 241
 242         if (path_equal(n, "environment"))
 243                 usr = true;
 244
 245         if (path_equal(n, "udev/hwdb.d"))
 246                 ext = ".hwdb";
 247
 248         if (path_equal(n, "udev/rules.d"))
 249                 ext = ".rules";
 250
 251         if (path_equal(n, "kernel/install.d"))
 252                 ext = ".install";
 253
 254         if (path_equal(n, "systemd/ntp-units.d")) {
 255                 coll = true;
 256                 ext = ".list";
 257         }
 258
 259         if (path_equal(n, "systemd/relabel-extra.d")) {
 260                 coll = run = true;
 261                 ext = ".relabel";
 262         }
 263
 264         if (PATH_IN_SET(n, "systemd/system-preset", "systemd/user-preset")) {
 265                 coll = true;
 266                 ext = ".preset";
 267         }
 268
 269         if (path_equal(n, "systemd/user-preset"))
 270                 usr = true;
 271
 272         *prefixes = (char**) (usr ? usr_prefixes : run ? run_prefixes : std_prefixes);
 273         *is_collection = coll;
 274         *extension = ext;
 275         return 0;
 276 }
 277
 278 int conf_files_cat(const char *root, const char *name) {
 279         _cleanup_strv_free_ char **dirs = NULL, **files = NULL;
 280         _cleanup_free_ char *path = NULL;
 281         char **prefixes, **prefix;
 282         bool is_collection;
 283         const char *extension;
 284         char **t;
 285         int r;
 286
 287         r = guess_type(&name, &prefixes, &is_collection, &extension);
 288         if (r < 0)
 289                 return r;
 290
 291         STRV_FOREACH(prefix, prefixes) {
 292                 assert(endswith(*prefix, "/"));
 293                 r = strv_extendf(&dirs, "%s%s%s", *prefix, name,
 294                                  is_collection ? "" : ".d");
 295                 if (r < 0)
 296                         return log_error_errno(r, "Failed to build directory list: %m");
 297         }
 298
 299         r = conf_files_list_strv(&files, extension, root, 0, (const char* const*) dirs);
 300         if (r < 0)
 301                 return log_error_errno(r, "Failed to query file list: %m");
 302
 303         if (!is_collection) {
 304                 path = path_join(root, "/etc", name);
 305                 if (!path)
 306                         return log_oom();
 307         }
 308
 309         if (DEBUG_LOGGING) {
 310                 log_debug("Looking for configuration in:");
 311                 if (path)
 312                         log_debug("   %s", path);
 313                 STRV_FOREACH(t, dirs)
 314                         log_debug("   %s/*%s", *t, extension);
 315         }
 316
 317         /* show */
 318         return cat_files(path, files, CAT_FLAGS_MAIN_FILE_OPTIONAL);
 319 }