src/path/path.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <errno.h>
   4 #include <getopt.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7
   8 #include "sd-path.h"
   9
  10 #include "alloc-util.h"
  11 #include "log.h"
  12 #include "macro.h"
  13 #include "string-util.h"
  14 #include "util.h"
  15
  16 static const char *arg_suffix = NULL;
  17
  18 static const char* const path_table[_SD_PATH_MAX] = {
  19         [SD_PATH_TEMPORARY] = "temporary",
  20         [SD_PATH_TEMPORARY_LARGE] = "temporary-large",
  21         [SD_PATH_SYSTEM_BINARIES] = "system-binaries",
  22         [SD_PATH_SYSTEM_INCLUDE] = "system-include",
  23         [SD_PATH_SYSTEM_LIBRARY_PRIVATE] = "system-library-private",
  24         [SD_PATH_SYSTEM_LIBRARY_ARCH] = "system-library-arch",
  25         [SD_PATH_SYSTEM_SHARED] = "system-shared",
  26         [SD_PATH_SYSTEM_CONFIGURATION_FACTORY] = "system-configuration-factory",
  27         [SD_PATH_SYSTEM_STATE_FACTORY] = "system-state-factory",
  28         [SD_PATH_SYSTEM_CONFIGURATION] = "system-configuration",
  29         [SD_PATH_SYSTEM_RUNTIME] = "system-runtime",
  30         [SD_PATH_SYSTEM_RUNTIME_LOGS] = "system-runtime-logs",
  31         [SD_PATH_SYSTEM_STATE_PRIVATE] = "system-state-private",
  32         [SD_PATH_SYSTEM_STATE_LOGS] = "system-state-logs",
  33         [SD_PATH_SYSTEM_STATE_CACHE] = "system-state-cache",
  34         [SD_PATH_SYSTEM_STATE_SPOOL] = "system-state-spool",
  35         [SD_PATH_USER_BINARIES] = "user-binaries",
  36         [SD_PATH_USER_LIBRARY_PRIVATE] = "user-library-private",
  37         [SD_PATH_USER_LIBRARY_ARCH] = "user-library-arch",
  38         [SD_PATH_USER_SHARED] = "user-shared",
  39         [SD_PATH_USER_CONFIGURATION] = "user-configuration",
  40         [SD_PATH_USER_RUNTIME] = "user-runtime",
  41         [SD_PATH_USER_STATE_CACHE] = "user-state-cache",
  42         [SD_PATH_USER] = "user",
  43         [SD_PATH_USER_DOCUMENTS] = "user-documents",
  44         [SD_PATH_USER_MUSIC] = "user-music",
  45         [SD_PATH_USER_PICTURES] = "user-pictures",
  46         [SD_PATH_USER_VIDEOS] = "user-videos",
  47         [SD_PATH_USER_DOWNLOAD] = "user-download",
  48         [SD_PATH_USER_PUBLIC] = "user-public",
  49         [SD_PATH_USER_TEMPLATES] = "user-templates",
  50         [SD_PATH_USER_DESKTOP] = "user-desktop",
  51         [SD_PATH_SEARCH_BINARIES] = "search-binaries",
  52         [SD_PATH_SEARCH_BINARIES_DEFAULT] = "search-binaries-default",
  53         [SD_PATH_SEARCH_LIBRARY_PRIVATE] = "search-library-private",
  54         [SD_PATH_SEARCH_LIBRARY_ARCH] = "search-library-arch",
  55         [SD_PATH_SEARCH_SHARED] = "search-shared",
  56         [SD_PATH_SEARCH_CONFIGURATION_FACTORY] = "search-configuration-factory",
  57         [SD_PATH_SEARCH_STATE_FACTORY] = "search-state-factory",
  58         [SD_PATH_SEARCH_CONFIGURATION] = "search-configuration",
  59 };
  60
  61 static int list_homes(void) {
  62         uint64_t i = 0;
  63         int r = 0;
  64
  65         for (i = 0; i < ELEMENTSOF(path_table); i++) {
  66                 _cleanup_free_ char *p = NULL;
  67                 int q;
  68
  69                 q = sd_path_home(i, arg_suffix, &p);
  70                 if (q == -ENXIO)
  71                         continue;
  72                 if (q < 0) {
  73                         log_error_errno(r, "Failed to query %s: %m", path_table[i]);
  74                         r = q;
  75                         continue;
  76                 }
  77
  78                 printf("%s: %s\n", path_table[i], p);
  79         }
  80
  81         return r;
  82 }
  83
  84 static int print_home(const char *n) {
  85         uint64_t i = 0;
  86         int r;
  87
  88         for (i = 0; i < ELEMENTSOF(path_table); i++) {
  89                 if (streq(path_table[i], n)) {
  90                         _cleanup_free_ char *p = NULL;
  91
  92                         r = sd_path_home(i, arg_suffix, &p);
  93                         if (r < 0)
  94                                 return log_error_errno(r, "Failed to query %s: %m", n);
  95
  96                         printf("%s\n", p);
  97                         return 0;
  98                 }
  99         }
 100
 101         log_error("Path %s not known.", n);
 102         return -EOPNOTSUPP;
 103 }
 104
 105 static void help(void) {
 106         printf("%s [OPTIONS...] [NAME...]\n\n"
 107                "Show system and user paths.\n\n"
 108                "  -h --help             Show this help\n"
 109                "     --version          Show package version\n"
 110                "     --suffix=SUFFIX    Suffix to append to paths\n",
 111                program_invocation_short_name);
 112 }
 113
 114 static int parse_argv(int argc, char *argv[]) {
 115
 116         enum {
 117                 ARG_VERSION = 0x100,
 118                 ARG_SUFFIX,
 119         };
 120
 121         static const struct option options[] = {
 122                 { "help",      no_argument,       NULL, 'h'           },
 123                 { "version",   no_argument,       NULL, ARG_VERSION   },
 124                 { "suffix",    required_argument, NULL, ARG_SUFFIX    },
 125                 {}
 126         };
 127
 128         int c;
 129
 130         assert(argc >= 0);
 131         assert(argv);
 132
 133         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
 134
 135                 switch (c) {
 136
 137                 case 'h':
 138                         help();
 139                         return 0;
 140
 141                 case ARG_VERSION:
 142                         return version();
 143
 144                 case ARG_SUFFIX:
 145                         arg_suffix = optarg;
 146                         break;
 147
 148                 case '?':
 149                         return -EINVAL;
 150
 151                 default:
 152                         assert_not_reached("Unhandled option");
 153                 }
 154
 155         return 1;
 156 }
 157
 158 int main(int argc, char* argv[]) {
 159         int r;
 160
 161         log_parse_environment();
 162         log_open();
 163
 164         r = parse_argv(argc, argv);
 165         if (r <= 0)
 166                 goto finish;
 167
 168         if (argc > optind) {
 169                 int i, q;
 170
 171                 for (i = optind; i < argc; i++) {
 172                         q = print_home(argv[i]);
 173                         if (q < 0)
 174                                 r = q;
 175                 }
 176         } else
 177                 r = list_homes();
 178
 179 finish:
 180         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 181 }