src/path/path.c

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