src/login/sysfs-show.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 Lennart Poettering
   6 ***/
   7
   8 #include <errno.h>
   9 #include <string.h>
  10
  11 #include "libudev.h"
  12
  13 #include "alloc-util.h"
  14 #include "locale-util.h"
  15 #include "path-util.h"
  16 #include "string-util.h"
  17 #include "sysfs-show.h"
  18 #include "terminal-util.h"
  19 #include "udev-util.h"
  20 #include "util.h"
  21
  22 static int show_sysfs_one(
  23                 struct udev *udev,
  24                 const char *seat,
  25                 struct udev_list_entry **item,
  26                 const char *sub,
  27                 const char *prefix,
  28                 unsigned n_columns,
  29                 OutputFlags flags) {
  30
  31         size_t max_width;
  32
  33         assert(udev);
  34         assert(seat);
  35         assert(item);
  36         assert(prefix);
  37
  38         if (flags & OUTPUT_FULL_WIDTH)
  39                 max_width = (size_t) -1;
  40         else if (n_columns < 10)
  41                 max_width = 10;
  42         else
  43                 max_width = n_columns;
  44
  45         while (*item) {
  46                 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
  47                 struct udev_list_entry *next, *lookahead;
  48                 const char *sn, *name, *sysfs, *subsystem, *sysname;
  49                 _cleanup_free_ char *k = NULL, *l = NULL;
  50                 bool is_master;
  51
  52                 sysfs = udev_list_entry_get_name(*item);
  53                 if (!path_startswith(sysfs, sub))
  54                         return 0;
  55
  56                 d = udev_device_new_from_syspath(udev, sysfs);
  57                 if (!d) {
  58                         *item = udev_list_entry_get_next(*item);
  59                         continue;
  60                 }
  61
  62                 sn = udev_device_get_property_value(d, "ID_SEAT");
  63                 if (isempty(sn))
  64                         sn = "seat0";
  65
  66                 /* Explicitly also check for tag 'seat' here */
  67                 if (!streq(seat, sn) || !udev_device_has_tag(d, "seat")) {
  68                         *item = udev_list_entry_get_next(*item);
  69                         continue;
  70                 }
  71
  72                 is_master = udev_device_has_tag(d, "master-of-seat");
  73
  74                 name = udev_device_get_sysattr_value(d, "name");
  75                 if (!name)
  76                         name = udev_device_get_sysattr_value(d, "id");
  77                 subsystem = udev_device_get_subsystem(d);
  78                 sysname = udev_device_get_sysname(d);
  79
  80                 /* Look if there's more coming after this */
  81                 lookahead = next = udev_list_entry_get_next(*item);
  82                 while (lookahead) {
  83                         const char *lookahead_sysfs;
  84
  85                         lookahead_sysfs = udev_list_entry_get_name(lookahead);
  86
  87                         if (path_startswith(lookahead_sysfs, sub) &&
  88                             !path_startswith(lookahead_sysfs, sysfs)) {
  89                                 _cleanup_udev_device_unref_ struct udev_device *lookahead_d = NULL;
  90
  91                                 lookahead_d = udev_device_new_from_syspath(udev, lookahead_sysfs);
  92                                 if (lookahead_d) {
  93                                         const char *lookahead_sn;
  94
  95                                         lookahead_sn = udev_device_get_property_value(d, "ID_SEAT");
  96                                         if (isempty(lookahead_sn))
  97                                                 lookahead_sn = "seat0";
  98
  99                                         if (streq(seat, lookahead_sn) && udev_device_has_tag(lookahead_d, "seat"))
 100                                                 break;
 101                                 }
 102                         }
 103
 104                         lookahead = udev_list_entry_get_next(lookahead);
 105                 }
 106
 107                 k = ellipsize(sysfs, max_width, 20);
 108                 if (!k)
 109                         return -ENOMEM;
 110
 111                 printf("%s%s%s\n", prefix, special_glyph(lookahead ? TREE_BRANCH : TREE_RIGHT), k);
 112
 113                 if (asprintf(&l,
 114                              "%s%s:%s%s%s%s",
 115                              is_master ? "[MASTER] " : "",
 116                              subsystem, sysname,
 117                              name ? " \"" : "", strempty(name), name ? "\"" : "") < 0)
 118                         return -ENOMEM;
 119
 120                 free(k);
 121                 k = ellipsize(l, max_width, 70);
 122                 if (!k)
 123                         return -ENOMEM;
 124
 125                 printf("%s%s%s\n", prefix, lookahead ? special_glyph(TREE_VERTICAL) : "  ", k);
 126
 127                 *item = next;
 128                 if (*item) {
 129                         _cleanup_free_ char *p = NULL;
 130
 131                         p = strappend(prefix, lookahead ? special_glyph(TREE_VERTICAL) : "  ");
 132                         if (!p)
 133                                 return -ENOMEM;
 134
 135                         show_sysfs_one(udev, seat, item, sysfs, p,
 136                                        n_columns == (unsigned) -1 || n_columns < 2 ? n_columns : n_columns - 2,
 137                                        flags);
 138                 }
 139         }
 140
 141         return 0;
 142 }
 143
 144 int show_sysfs(const char *seat, const char *prefix, unsigned n_columns, OutputFlags flags) {
 145         _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
 146         _cleanup_udev_unref_ struct udev *udev = NULL;
 147         struct udev_list_entry *first = NULL;
 148         int r;
 149
 150         if (n_columns <= 0)
 151                 n_columns = columns();
 152
 153         prefix = strempty(prefix);
 154
 155         if (isempty(seat))
 156                 seat = "seat0";
 157
 158         udev = udev_new();
 159         if (!udev)
 160                 return -ENOMEM;
 161
 162         e = udev_enumerate_new(udev);
 163         if (!e)
 164                 return -ENOMEM;
 165
 166         if (!streq(seat, "seat0"))
 167                 r = udev_enumerate_add_match_tag(e, seat);
 168         else
 169                 r = udev_enumerate_add_match_tag(e, "seat");
 170         if (r < 0)
 171                 return r;
 172
 173         r = udev_enumerate_add_match_is_initialized(e);
 174         if (r < 0)
 175                 return r;
 176
 177         r = udev_enumerate_scan_devices(e);
 178         if (r < 0)
 179                 return r;
 180
 181         first = udev_enumerate_get_list_entry(e);
 182         if (first)
 183                 show_sysfs_one(udev, seat, &first, "/", prefix, n_columns, flags);
 184         else
 185                 printf("%s%s%s\n", prefix, special_glyph(TREE_RIGHT), "(none)");
 186
 187         return r;
 188 }