src/login/sysfs-show.c

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