Merge "Merge branch 'upstream' into tizen" into tizen
[platform/upstream/cryptsetup.git] / src / utils_blockdev.c
1 /*
2  * Linux block devices helpers
3  *
4  * Copyright (C) 2018-2021 Red Hat, Inc. All rights reserved.
5  * Copyright (C) 2018-2021 Ondrej Kozina
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20  */
21
22 #include "cryptsetup.h"
23 #include <dirent.h>
24 #ifdef HAVE_SYS_SYSMACROS_H
25 # include <sys/sysmacros.h>     /* for major, minor */
26 #endif
27 #include <uuid/uuid.h>
28
29 #define DM_UUID_LEN             129
30 #define DM_BY_ID_PREFIX         "dm-uuid-"
31 #define DM_BY_ID_PREFIX_LEN     8
32 #define DM_UUID_PREFIX          "CRYPT-"
33 #define DM_UUID_PREFIX_LEN      6
34 #define UUID_LEN 37 /* 36 + \0, libuuid ... */
35
36 static int dm_prepare_uuid(const char *type, const char *uuid, char *buf, size_t buflen)
37 {
38         char *ptr, uuid2[UUID_LEN] = {0};
39         uuid_t uu;
40         unsigned i = 0;
41
42         /* Remove '-' chars */
43         if (uuid) {
44                 if (uuid_parse(uuid, uu) < 0) {
45                         log_dbg("Requested UUID %s has invalid format.", uuid);
46                         return 0;
47                 }
48
49                 for (ptr = uuid2, i = 0; i < UUID_LEN; i++)
50                         if (uuid[i] != '-') {
51                                 *ptr = uuid[i];
52                                 ptr++;
53                         }
54         }
55
56         snprintf(buf, buflen, DM_UUID_PREFIX "%s%s%s%s",
57                 type ?: "", type ? "-" : "",
58                 uuid2[0] ? uuid2 : "", uuid2[0] ? "-" : "");
59
60         return 1;
61 }
62
63 /* return number of holders in general, if matched dm_uuid prefix it's returned via dm_name */
64 /* negative value is error */
65 static int lookup_holder_dm_name(const char *dm_uuid, size_t max_len, dev_t devno, char *dm_name, size_t dm_name_length)
66 {
67         struct dirent *entry;
68         char dm_subpath[PATH_MAX], data_dev_dir[PATH_MAX], uuid[max_len];
69         ssize_t s;
70         struct stat st;
71         int dmfd, fd, len, r = 0; /* not found */
72         DIR *dir;
73
74         if (!dm_name || !dm_name_length)
75                 return -EINVAL;
76
77         *dm_name = '\0';
78
79         len = snprintf(data_dev_dir, PATH_MAX, "/sys/dev/block/%u:%u/holders", major(devno), minor(devno));
80         if (len < 0 || len >= PATH_MAX)
81                 return -EINVAL;
82
83         if (!(dir = opendir(data_dev_dir)))
84                 /* map ENOTDIR to ENOENT we'll handle both errors same */
85                 return errno == ENOTDIR ? -ENOENT : -errno;
86
87         while (r != 1 && (entry = readdir(dir))) {
88                 if (entry->d_name[0] == '.' ||
89                     !strncmp(entry->d_name, "..", 2))
90                         continue;
91
92                 /* there's a holder */
93                 r++;
94
95                 /* we already have a dm_name, just count remaining holders */
96                 if (*dm_name != '\0')
97                         continue;
98
99                 len = snprintf(dm_subpath, PATH_MAX, "%s/%s", entry->d_name, "dm");
100                 if (len < 0 || len >= PATH_MAX) {
101                         r = -EINVAL;
102                         break;
103                 }
104
105                 /* looking for dm-X/dm directory, symlinks are fine */
106                 dmfd = openat(dirfd(dir), dm_subpath, O_DIRECTORY | O_RDONLY);
107                 if (dmfd < 0)
108                         continue;
109
110                 fd = openat(dmfd, "uuid", O_RDONLY);
111                 if (fd < 0) {
112                         close(dmfd);
113                         continue;
114                 }
115
116                 if (fstat(fd, &st) || !S_ISREG(st.st_mode)) {
117                         close(fd);
118                         close(dmfd);
119                         continue;
120                 }
121
122                 /* reads binary data */
123                 s = read_buffer(fd, uuid, max_len - 1);
124                 close(fd);
125                 uuid[s > 0 ? s : 0] = '\0';
126                 if (!strncmp(uuid, dm_uuid, strlen(dm_uuid)))
127                         log_dbg("Found candidate device %s", entry->d_name);
128                 else {
129                         close(dmfd);
130                         continue;
131                 }
132
133                 fd = openat(dmfd, "name", O_RDONLY);
134                 if (fd < 0) {
135                         close(dmfd);
136                         continue;
137                 }
138
139                 if (fstat(fd, &st) || !S_ISREG(st.st_mode)) {
140                         close(fd);
141                         close(dmfd);
142                         continue;
143                 }
144
145                 /* reads binary data */
146                 s = read_buffer(fd, dm_name, dm_name_length - 1);
147                 close(fd);
148                 close(dmfd);
149                 if (s > 1) {
150                         dm_name[s-1] = '\0';
151                         log_dbg("Found dm device %s", dm_name);
152                 }
153         }
154
155         closedir(dir);
156
157         return r;
158 }
159
160 int tools_lookup_crypt_device(struct crypt_device *cd, const char *type,
161                 const char *data_device_path, char *name, size_t name_length)
162 {
163         int r;
164         char *c;
165         struct stat st;
166         char dev_uuid[DM_UUID_LEN + DM_BY_ID_PREFIX_LEN] = DM_BY_ID_PREFIX;
167
168         if (!dm_prepare_uuid(type, crypt_get_uuid(cd), dev_uuid + DM_BY_ID_PREFIX_LEN, DM_UUID_LEN))
169                 return -EINVAL;
170
171         c = strrchr(dev_uuid, '-');
172         if (!c)
173                 return -EINVAL;
174
175         /* cut of dm name */
176         *c = '\0';
177
178         log_dbg("Looking for any dm device with prefix: %s", dev_uuid);
179
180         if (stat(data_device_path, &st) < 0)
181                 return -ENODEV;
182
183         if (!S_ISBLK(st.st_mode))
184                 return -ENOTBLK;
185
186         r = lookup_holder_dm_name(dev_uuid + DM_BY_ID_PREFIX_LEN, DM_UUID_LEN,
187                         st.st_rdev, name, name_length);
188         return r;
189 }