4159ec66b78becc9c7af0feeb63102f185c786dd
[multipath-tools/.git] / libmultipath / alias.c
1 /*
2  * Copyright (c) 2005 Christophe Varoqui
3  * Copyright (c) 2005 Benjamin Marzinski, Redhat
4  */
5 #include <stdlib.h>
6 #include <sys/types.h>
7 #include <sys/stat.h>
8 #include <fcntl.h>
9 #include <errno.h>
10 #include <unistd.h>
11 #include <string.h>
12 #include <limits.h>
13 #include <stdio.h>
14 #include <signal.h>
15
16 #include "debug.h"
17 #include "uxsock.h"
18 #include "alias.h"
19
20
21 /*
22  * significant parts of this file were taken from iscsi-bindings.c of the
23  * linux-iscsi project.
24  * Copyright (C) 2002 Cisco Systems, Inc.
25  *
26  * This program is free software; you can redistribute it and/or modify
27  * it under the terms of the GNU General Public License as published
28  * by the Free Software Foundation; either version 2 of the License, or
29  * (at your option) any later version.
30  *
31  * This program is distributed in the hope that it will be useful, but
32  * WITHOUT ANY WARRANTY; without even the implied warranty of
33  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
34  * General Public License for more details.
35  *
36  * See the file COPYING included with this distribution for more details.
37  */
38
39 static int
40 ensure_directories_exist(char *str, mode_t dir_mode)
41 {
42         char *pathname;
43         char *end;
44         int err;
45
46         pathname = strdup(str);
47         if (!pathname){
48                 condlog(0, "Cannot copy bindings file pathname : %s",
49                         strerror(errno));
50                 return -1;
51         }
52         end = pathname;
53         /* skip leading slashes */
54         while (end && *end && (*end == '/'))
55                 end++;
56
57         while ((end = strchr(end, '/'))) {
58                 /* if there is another slash, make the dir. */
59                 *end = '\0';
60                 err = mkdir(pathname, dir_mode);
61                 if (err && errno != EEXIST) {
62                         condlog(0, "Cannot make directory [%s] : %s",
63                                 pathname, strerror(errno));
64                         free(pathname);
65                         return -1;
66                 }
67                 if (!err)
68                         condlog(3, "Created dir [%s]", pathname);
69                 *end = '/';
70                 end++;
71         }
72         free(pathname);
73         return 0;
74 }
75
76 static void
77 sigalrm(int sig)
78 {
79         /* do nothing */
80 }
81
82 static int
83 lock_bindings_file(int fd)
84 {
85         struct sigaction act, oldact;
86         sigset_t set, oldset;
87         struct flock lock;
88         int err;
89
90         memset(&lock, 0, sizeof(lock));
91         lock.l_type = F_WRLCK;
92         lock.l_whence = SEEK_SET;
93
94         act.sa_handler = sigalrm;
95         sigemptyset(&act.sa_mask);
96         act.sa_flags = 0;
97         sigemptyset(&set);
98         sigaddset(&set, SIGALRM);
99
100         sigaction(SIGALRM, &act, &oldact);
101         sigprocmask(SIG_UNBLOCK, &set, &oldset);
102
103         alarm(BINDINGS_FILE_TIMEOUT);
104         err = fcntl(fd, F_SETLKW, &lock);
105         alarm(0);
106
107         if (err) {
108                 if (errno != EINTR)
109                         condlog(0, "Cannot lock bindings file : %s",
110                                         strerror(errno));
111                 else
112                         condlog(0, "Bindings file is locked. Giving up.");
113         }
114
115         sigprocmask(SIG_SETMASK, &oldset, NULL);
116         sigaction(SIGALRM, &oldact, NULL);
117         return err;
118
119 }
120
121
122 static int
123 open_bindings_file(char *file, int *can_write)
124 {
125         int fd;
126         struct stat s;
127
128         if (ensure_directories_exist(file, 0700))
129                 return -1;
130         *can_write = 1;
131         fd = open(file, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
132         if (fd < 0) {
133                 if (errno == EROFS) {
134                         *can_write = 0;
135                         condlog(3, "Cannot open bindings file [%s] read/write. "
136                                 " trying readonly", file);
137                         fd = open(file, O_RDONLY);
138                         if (fd < 0) {
139                                 condlog(0, "Cannot open bindings file [%s] "
140                                         "readonly : %s", file, strerror(errno));
141                                 return -1;
142                         }
143                 }
144                 else {
145                         condlog(0, "Cannot open bindings file [%s] : %s", file,
146                                 strerror(errno));
147                         return -1;
148                 }
149         }
150         if (*can_write && lock_bindings_file(fd) < 0)
151                 goto fail;
152
153         memset(&s, 0, sizeof(s));
154         if (fstat(fd, &s) < 0){
155                 condlog(0, "Cannot stat bindings file : %s", strerror(errno));
156                 goto fail;
157         }
158         if (s.st_size == 0) {
159                 if (*can_write == 0)
160                         goto fail;
161                 /* If bindings file is empty, write the header */
162                 size_t len = strlen(BINDINGS_FILE_HEADER);
163                 if (write_all(fd, BINDINGS_FILE_HEADER, len) != len) {
164                         condlog(0,
165                                 "Cannot write header to bindings file : %s",
166                                 strerror(errno));
167                         /* cleanup partially written header */
168                         ftruncate(fd, 0);
169                         goto fail;
170                 }
171                 fsync(fd);
172                 condlog(3, "Initialized new bindings file [%s]", file);
173         }
174
175         return fd;
176
177 fail:
178         close(fd);
179         return -1;
180 }
181
182 static int
183 format_devname(char *name, int id, int len, char *prefix)
184 {
185         int pos;
186         int prefix_len = strlen(prefix);
187
188         memset(name,0, len);
189         strcpy(name, prefix);
190         for (pos = len - 1; pos >= prefix_len; pos--) {
191                 name[pos] = 'a' + id % 26;
192                 if (id < 26)
193                         break;
194                 id /= 26;
195                 id--;
196         }
197         memmove(name + prefix_len, name + pos, len - pos);
198         name[prefix_len + len - pos] = '\0';
199         return (prefix_len + len - pos);
200 }
201
202 static int
203 scan_devname(char *alias, char *prefix)
204 {
205         char *c;
206         int i, n = 0;
207
208         if (!prefix || strncmp(alias, prefix, strlen(prefix)))
209                 return -1;
210
211         c = alias + strlen(prefix);
212         while (*c != '\0' && *c != ' ' && *c != '\t') {
213                 i = *c - 'a';
214                 n = ( n * 26 ) + i;
215                 c++;
216                 if (*c < 'a' || *c > 'z')
217                         break;
218                 n++;
219         }
220
221         return n;
222 }
223
224 static int
225 lookup_binding(FILE *f, char *map_wwid, char **map_alias, char *prefix)
226 {
227         char buf[LINE_MAX];
228         unsigned int line_nr = 0;
229         int id = 0;
230
231         *map_alias = NULL;
232
233         while (fgets(buf, LINE_MAX, f)) {
234                 char *c, *alias, *wwid;
235                 int curr_id;
236
237                 line_nr++;
238                 c = strpbrk(buf, "#\n\r");
239                 if (c)
240                         *c = '\0';
241                 alias = strtok(buf, " \t");
242                 if (!alias) /* blank line */
243                         continue;
244                 curr_id = scan_devname(alias, prefix);
245                 if (curr_id >= id)
246                         id = curr_id + 1;
247                 wwid = strtok(NULL, "");
248                 if (!wwid){
249                         condlog(3,
250                                 "Ignoring malformed line %u in bindings file",
251                                 line_nr);
252                         continue;
253                 }
254                 if (strcmp(wwid, map_wwid) == 0){
255                         condlog(3, "Found matching wwid [%s] in bindings file."
256                                 " Setting alias to %s", wwid, alias);
257                         *map_alias = strdup(alias);
258                         if (*map_alias == NULL)
259                                 condlog(0, "Cannot copy alias from bindings "
260                                         "file : %s", strerror(errno));
261                         return id;
262                 }
263         }
264         condlog(3, "No matching wwid [%s] in bindings file.", map_wwid);
265         return id;
266 }
267
268 static int
269 rlookup_binding(FILE *f, char **map_wwid, char *map_alias)
270 {
271         char buf[LINE_MAX];
272         unsigned int line_nr = 0;
273         int id = 0;
274
275         *map_wwid = NULL;
276
277         while (fgets(buf, LINE_MAX, f)) {
278                 char *c, *alias, *wwid;
279                 int curr_id;
280
281                 line_nr++;
282                 c = strpbrk(buf, "#\n\r");
283                 if (c)
284                         *c = '\0';
285                 alias = strtok(buf, " \t");
286                 if (!alias) /* blank line */
287                         continue;
288                 curr_id = scan_devname(alias, NULL); /* TBD: Why this call? */
289                 if (curr_id >= id)
290                         id = curr_id + 1;
291                 wwid = strtok(NULL, " \t");
292                 if (!wwid){
293                         condlog(3,
294                                 "Ignoring malformed line %u in bindings file",
295                                 line_nr);
296                         continue;
297                 }
298                 if (strcmp(alias, map_alias) == 0){
299                         condlog(3, "Found matching alias [%s] in bindings file."
300                                 "\nSetting wwid to %s", alias, wwid);
301                         *map_wwid = strdup(wwid);
302                         if (*map_wwid == NULL)
303                                 condlog(0, "Cannot copy alias from bindings "
304                                         "file : %s", strerror(errno));
305                         return id;
306                 }
307         }
308         condlog(3, "No matching alias [%s] in bindings file.", map_alias);
309         return id;
310 }
311
312 static char *
313 allocate_binding(int fd, char *wwid, int id, char *prefix)
314 {
315         char buf[LINE_MAX];
316         off_t offset;
317         char *alias, *c;
318         int i;
319
320         if (id < 0) {
321                 condlog(0, "Bindings file full. Cannot allocate new binding");
322                 return NULL;
323         }
324
325         i = format_devname(buf, id, LINE_MAX, prefix);
326         c = buf + i;
327         snprintf(c,LINE_MAX - i, " %s\n", wwid);
328         buf[LINE_MAX - 1] = '\0';
329
330         offset = lseek(fd, 0, SEEK_END);
331         if (offset < 0){
332                 condlog(0, "Cannot seek to end of bindings file : %s",
333                         strerror(errno));
334                 return NULL;
335         }
336         if (write_all(fd, buf, strlen(buf)) != strlen(buf)){
337                 condlog(0, "Cannot write binding to bindings file : %s",
338                         strerror(errno));
339                 /* clear partial write */
340                 ftruncate(fd, offset);
341                 return NULL;
342         }
343         c = strchr(buf, ' ');
344         *c = '\0';
345         alias = strdup(buf);
346         if (alias == NULL)
347                 condlog(0, "cannot copy new alias from bindings file : %s",
348                         strerror(errno));
349         else
350                 condlog(3, "Created new binding [%s] for WWID [%s]", alias,
351                         wwid);
352         return alias;
353 }
354
355 char *
356 get_user_friendly_alias(char *wwid, char *file, char *prefix,
357                         int bindings_read_only)
358 {
359         char *alias;
360         int fd, scan_fd, id;
361         FILE *f;
362         int can_write;
363
364         if (!wwid || *wwid == '\0') {
365                 condlog(3, "Cannot find binding for empty WWID");
366                 return NULL;
367         }
368
369         fd = open_bindings_file(file, &can_write);
370         if (fd < 0)
371                 return NULL;
372
373         scan_fd = dup(fd);
374         if (scan_fd < 0) {
375                 condlog(0, "Cannot dup bindings file descriptor : %s",
376                         strerror(errno));
377                 close(fd);
378                 return NULL;
379         }
380
381         f = fdopen(scan_fd, "r");
382         if (!f) {
383                 condlog(0, "cannot fdopen on bindings file descriptor : %s",
384                         strerror(errno));
385                 close(scan_fd);
386                 close(fd);
387                 return NULL;
388         }
389
390         id = lookup_binding(f, wwid, &alias, prefix);
391         if (id < 0) {
392                 fclose(f);
393                 close(scan_fd);
394                 close(fd);
395                 return NULL;
396         }
397
398         if (!alias && can_write && !bindings_read_only)
399                 alias = allocate_binding(fd, wwid, id, prefix);
400
401         fclose(f);
402         close(scan_fd);
403         close(fd);
404         return alias;
405 }
406
407 char *
408 get_user_friendly_wwid(char *alias, char *file)
409 {
410         char *wwid;
411         int fd, scan_fd, id, unused;
412         FILE *f;
413
414         if (!alias || *alias == '\0') {
415                 condlog(3, "Cannot find binding for empty alias");
416                 return NULL;
417         }
418
419         fd = open_bindings_file(file, &unused);
420         if (fd < 0)
421                 return NULL;
422
423         scan_fd = dup(fd);
424         if (scan_fd < 0) {
425                 condlog(0, "Cannot dup bindings file descriptor : %s",
426                         strerror(errno));
427                 close(fd);
428                 return NULL;
429         }
430
431         f = fdopen(scan_fd, "r");
432         if (!f) {
433                 condlog(0, "cannot fdopen on bindings file descriptor : %s",
434                         strerror(errno));
435                 close(scan_fd);
436                 close(fd);
437                 return NULL;
438         }
439
440         id = rlookup_binding(f, &wwid, alias);
441         if (id < 0) {
442                 fclose(f);
443                 close(scan_fd);
444                 close(fd);
445                 return NULL;
446         }
447
448         fclose(f);
449         close(scan_fd);
450         close(fd);
451         return wwid;
452 }