src/login/sysfs-show.c

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