lib/canonicalize.c

   1 /*
   2  * canonicalize.c -- canonicalize pathname by removing symlinks
   3  *
   4  * This file may be distributed under the terms of the
   5  * GNU Lesser General Public License.
   6  *
   7  * Copyright (C) 2009-2013 Karel Zak <kzak@redhat.com>
   8  */
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include <ctype.h>
  12 #include <unistd.h>
  13 #include <errno.h>
  14 #include <stdlib.h>
  15 #include <sys/types.h>
  16 #include <sys/stat.h>
  17 #include <sys/wait.h>
  18
  19 #include "canonicalize.h"
  20 #include "pathnames.h"
  21 #include "all-io.h"
  22 #include "strutils.h"
  23
  24 /*
  25  * Converts private "dm-N" names to "/dev/mapper/<name>"
  26  *
  27  * Since 2.6.29 (patch 784aae735d9b0bba3f8b9faef4c8b30df3bf0128) kernel sysfs
  28  * provides the real DM device names in /sys/block/<ptname>/dm/name
  29  */
  30 char *__canonicalize_dm_name(const char *prefix, const char *ptname)
  31 {
  32         FILE    *f;
  33         size_t  sz;
  34         char    path[256], name[sizeof(path) - sizeof(_PATH_DEV_MAPPER)], *res = NULL;
  35
  36         if (!ptname || !*ptname)
  37                 return NULL;
  38
  39         if (!prefix)
  40                 prefix = "";
  41
  42         snprintf(path, sizeof(path), "%s/sys/block/%s/dm/name", prefix, ptname);
  43         if (!(f = fopen(path, "r" UL_CLOEXECSTR)))
  44                 return NULL;
  45
  46         /* read "<name>\n" from sysfs */
  47         if (fgets(name, sizeof(name), f) && (sz = strlen(name)) > 1) {
  48                 name[sz - 1] = '\0';
  49                 snprintf(path, sizeof(path), _PATH_DEV_MAPPER "/%s", name);
  50
  51                 if ((prefix && *prefix) || access(path, F_OK) == 0)
  52                         res = strdup(path);
  53         }
  54         fclose(f);
  55         return res;
  56 }
  57
  58 char *canonicalize_dm_name(const char *ptname)
  59 {
  60         return __canonicalize_dm_name(NULL, ptname);
  61 }
  62
  63 static int is_dm_devname(char *canonical, char **name)
  64 {
  65         struct stat sb;
  66         char *p = strrchr(canonical, '/');
  67
  68         *name = NULL;
  69
  70         if (!p
  71             || strncmp(p, "/dm-", 4) != 0
  72             || !isdigit(*(p + 4))
  73             || stat(canonical, &sb) != 0
  74             || !S_ISBLK(sb.st_mode))
  75                 return 0;
  76
  77         *name = p + 1;
  78         return 1;
  79 }
  80
  81 /*
  82  * This function does not canonicalize the path! It just prepends CWD before a
  83  * relative path. If the path is no relative than returns NULL. The path does
  84  * not have to exist.
  85  */
  86 char *absolute_path(const char *path)
  87 {
  88         char cwd[PATH_MAX], *res, *p;
  89         size_t psz, csz;
  90
  91         if (!is_relative_path(path)) {
  92                 errno = EINVAL;
  93                 return NULL;
  94         }
  95         if (!getcwd(cwd, sizeof(cwd)))
  96                 return NULL;
  97
  98         /* simple clean up */
  99         if (startswith(path, "./"))
 100                 path += 2;
 101         else if (strcmp(path, ".") == 0)
 102                 path = NULL;
 103
 104         if (!path || !*path)
 105                 return strdup(cwd);
 106
 107         csz = strlen(cwd);
 108         psz = strlen(path);
 109
 110         p = res = malloc(csz + 1 + psz + 1);
 111         if (!res)
 112                 return NULL;
 113
 114         p = mempcpy(p, cwd, csz);
 115         *p++ = '/';
 116         memcpy(p, path, psz + 1);
 117
 118         return res;
 119 }
 120
 121 char *canonicalize_path(const char *path)
 122 {
 123         char *canonical, *dmname;
 124
 125         if (!path || !*path)
 126                 return NULL;
 127
 128         canonical = realpath(path, NULL);
 129         if (!canonical)
 130                 return strdup(path);
 131
 132         if (is_dm_devname(canonical, &dmname)) {
 133                 char *dm = canonicalize_dm_name(dmname);
 134                 if (dm) {
 135                         free(canonical);
 136                         return dm;
 137                 }
 138         }
 139
 140         return canonical;
 141 }
 142
 143 char *canonicalize_path_restricted(const char *path)
 144 {
 145         char *canonical = NULL;
 146         int errsv = 0;
 147         int pipes[2];
 148         ssize_t len;
 149         pid_t pid;
 150
 151         if (!path || !*path)
 152                 return NULL;
 153
 154         if (pipe(pipes) != 0)
 155                 return NULL;
 156
 157         /*
 158          * To accurately assume identity of getuid() we must use setuid()
 159          * but if we do that, we lose ability to reassume euid of 0, so
 160          * we fork to do the check to keep euid intact.
 161          */
 162         pid = fork();
 163         switch (pid) {
 164         case -1:
 165                 close(pipes[0]);
 166                 close(pipes[1]);
 167                 return NULL;                    /* fork error */
 168         case 0:
 169                 close(pipes[0]);                /* close unused end */
 170                 pipes[0] = -1;
 171                 errno = 0;
 172
 173                 if (drop_permissions() != 0)
 174                         canonical = NULL;       /* failed */
 175                 else {
 176                         char *dmname = NULL;
 177
 178                         canonical = realpath(path, NULL);
 179                         if (canonical && is_dm_devname(canonical, &dmname)) {
 180                                 char *dm = canonicalize_dm_name(dmname);
 181                                 if (dm) {
 182                                         free(canonical);
 183                                         canonical = dm;
 184                                 }
 185                         }
 186                 }
 187
 188                 len = canonical ? (ssize_t) strlen(canonical) :
 189                           errno ? -errno : -EINVAL;
 190
 191                 /* send length or errno */
 192                 write_all(pipes[1], (char *) &len, sizeof(len));
 193                 if (canonical)
 194                         write_all(pipes[1], canonical, len);
 195                 exit(0);
 196         default:
 197                 break;
 198         }
 199
 200         close(pipes[1]);                /* close unused end */
 201         pipes[1] = -1;
 202
 203         /* read size or -errno */
 204         if (read_all(pipes[0], (char *) &len, sizeof(len)) != sizeof(len))
 205                 goto done;
 206         if (len < 0) {
 207                 errsv = -len;
 208                 goto done;
 209         }
 210
 211         canonical = malloc(len + 1);
 212         if (!canonical) {
 213                 errsv = ENOMEM;
 214                 goto done;
 215         }
 216         /* read path */
 217         if (read_all(pipes[0], canonical, len) != len) {
 218                 errsv = errno;
 219                 goto done;
 220         }
 221         canonical[len] = '\0';
 222 done:
 223         if (errsv) {
 224                 free(canonical);
 225                 canonical = NULL;
 226         }
 227         close(pipes[0]);
 228
 229         /* We make a best effort to reap child */
 230         ignore_result( waitpid(pid, NULL, 0) );
 231
 232         errno = errsv;
 233         return canonical;
 234 }
 235
 236
 237 #ifdef TEST_PROGRAM_CANONICALIZE
 238 int main(int argc, char **argv)
 239 {
 240         if (argc < 2) {
 241                 fprintf(stderr, "usage: %s <device>\n", argv[0]);
 242                 exit(EXIT_FAILURE);
 243         }
 244
 245         fprintf(stdout, "orig: %s\n", argv[1]);
 246         fprintf(stdout, "real: %s\n", canonicalize_path(argv[1]));
 247         exit(EXIT_SUCCESS);
 248 }
 249 #endif