ba0fcf6f6814ec9bb105f62022454fad34149d60
[nfs-utils.git] / utils / mountd / rmtab.c
1 /*
2  * utils/mountd/rmtab.c
3  *
4  * Manage the rmtab file for mountd.
5  *
6  * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
7  */
8
9 #ifdef HAVE_CONFIG_H
10 #include <config.h>
11 #endif
12
13 #include <sys/types.h>
14 #include <sys/stat.h>
15 #include <unistd.h>
16 #include <netinet/in.h>
17 #include <arpa/inet.h>
18 #include <netdb.h>
19 #include "xmalloc.h"
20 #include "misc.h"
21 #include "exportfs.h"
22 #include "xio.h"
23 #include "mountd.h"
24 #include "ha-callout.h"
25
26 #include <limits.h> /* PATH_MAX */
27 #include <errno.h>
28
29 extern int reverse_resolve;
30
31 /* If new path is a link do not destroy it but place the
32  * file where the link points.
33  */
34
35 static int 
36 slink_safe_rename(const char * oldpath, const char * newpath)
37 {
38         int r;
39         struct stat s;
40         char slink_path[PATH_MAX];
41         const char *real_newpath = newpath;
42
43         if ((lstat(newpath, &s) == 0) && S_ISLNK(s.st_mode)) {
44                 /* New path is a symbolic link, do not destroy but follow */
45                 if ((r = readlink(newpath, slink_path, PATH_MAX - 1)) == -1)
46                         return -1;
47                 slink_path[r] = '\0';
48                 real_newpath = slink_path;
49         }
50
51         return rename(oldpath, real_newpath);
52 }
53
54 void
55 mountlist_add(char *host, const char *path)
56 {
57         struct rmtabent xe;
58         struct rmtabent *rep;
59         int             lockid;
60         long            pos;
61
62         if ((lockid = xflock(_PATH_RMTABLCK, "a")) < 0)
63                 return;
64         setrmtabent("r+");
65         while ((rep = getrmtabent(1, &pos)) != NULL) {
66                 if (strcmp (rep->r_client,
67                             host) == 0
68                     && strcmp(rep->r_path, path) == 0) {
69                         rep->r_count++;
70                         /* PRC: do the HA callout: */
71                         ha_callout("mount", rep->r_client, rep->r_path, rep->r_count);
72                         putrmtabent(rep, &pos);
73                         endrmtabent();
74                         xfunlock(lockid);
75                         return;
76                 }
77         }
78         endrmtabent();
79         strncpy(xe.r_client, host,
80                 sizeof (xe.r_client) - 1);
81         xe.r_client [sizeof (xe.r_client) - 1] = '\0';
82         strncpy(xe.r_path, path, sizeof (xe.r_path) - 1);
83         xe.r_path [sizeof (xe.r_path) - 1] = '\0';
84         xe.r_count = 1;
85         if (setrmtabent("a")) {
86                 /* PRC: do the HA callout: */
87                 ha_callout("mount", xe.r_client, xe.r_path, xe.r_count);
88                 putrmtabent(&xe, NULL);
89                 endrmtabent();
90         }
91         xfunlock(lockid);
92 }
93
94 void
95 mountlist_del(char *hname, const char *path)
96 {
97         struct rmtabent *rep;
98         FILE            *fp;
99         int             lockid;
100         int             match;
101
102         if ((lockid = xflock(_PATH_RMTABLCK, "w")) < 0)
103                 return;
104         if (!setrmtabent("r")) {
105                 xfunlock(lockid);
106                 return;
107         }
108         if (!(fp = fsetrmtabent(_PATH_RMTABTMP, "w"))) {
109                 endrmtabent();
110                 xfunlock(lockid);
111                 return;
112         }
113         while ((rep = getrmtabent(1, NULL)) != NULL) {
114                 match = !strcmp (rep->r_client, hname)
115                         && !strcmp(rep->r_path, path);
116                 if (match) {
117                         rep->r_count--;
118                         /* PRC: do the HA callout: */
119                         ha_callout("unmount", rep->r_client, rep->r_path, rep->r_count);
120                 }
121                 if (!match || rep->r_count)
122                         fputrmtabent(fp, rep, NULL);
123         }
124         if (slink_safe_rename(_PATH_RMTABTMP, _PATH_RMTAB) < 0) {
125                 xlog(L_ERROR, "couldn't rename %s to %s",
126                                 _PATH_RMTABTMP, _PATH_RMTAB);
127         }
128         endrmtabent();  /* close & unlink */
129         fendrmtabent(fp);
130         xfunlock(lockid);
131 }
132
133 void
134 mountlist_del_all(struct sockaddr_in *sin)
135 {
136         char            *hostname;
137         struct rmtabent *rep;
138         nfs_export      *exp;
139         FILE            *fp;
140         int             lockid;
141
142         if ((lockid = xflock(_PATH_RMTABLCK, "w")) < 0)
143                 return;
144         hostname = host_canonname((struct sockaddr *)sin);
145         if (hostname == NULL) {
146                 char buf[INET_ADDRSTRLEN];
147                 xlog(L_ERROR, "can't get hostname of %s",
148                         host_ntop((struct sockaddr *)sin, buf, sizeof(buf)));
149                 goto out_unlock;
150         }
151
152         if (!setrmtabent("r"))
153                 goto out_free;
154
155         if (!(fp = fsetrmtabent(_PATH_RMTABTMP, "w")))
156                 goto out_close;
157
158         while ((rep = getrmtabent(1, NULL)) != NULL) {
159                 if (strcmp(rep->r_client, hostname) == 0 &&
160                     (exp = auth_authenticate("umountall", sin, rep->r_path)))
161                         continue;
162                 fputrmtabent(fp, rep, NULL);
163         }
164         if (slink_safe_rename(_PATH_RMTABTMP, _PATH_RMTAB) < 0) {
165                 xlog(L_ERROR, "couldn't rename %s to %s",
166                                 _PATH_RMTABTMP, _PATH_RMTAB);
167         }
168         fendrmtabent(fp);
169 out_close:
170         endrmtabent();  /* close & unlink */
171 out_free:
172         free(hostname);
173 out_unlock:
174         xfunlock(lockid);
175 }
176
177 mountlist
178 mountlist_list(void)
179 {
180         static mountlist        mlist = NULL;
181         static time_t           last_mtime = 0;
182         mountlist               m;
183         struct rmtabent         *rep;
184         struct stat             stb;
185         int                     lockid;
186         struct in_addr          addr;
187         struct hostent          *he;
188
189         if ((lockid = xflock(_PATH_RMTABLCK, "r")) < 0)
190                 return NULL;
191         if (stat(_PATH_RMTAB, &stb) < 0) {
192                 xlog(L_ERROR, "can't stat %s: %s",
193                                 _PATH_RMTAB, strerror(errno));
194                 xfunlock(lockid);
195                 return NULL;
196         }
197         if (stb.st_mtime != last_mtime) {
198                 while (mlist) {
199                         mlist = (m = mlist)->ml_next;
200                         xfree(m->ml_hostname);
201                         xfree(m->ml_directory);
202                         xfree(m);
203                 }
204                 last_mtime = stb.st_mtime;
205
206                 setrmtabent("r");
207                 while ((rep = getrmtabent(1, NULL)) != NULL) {
208                         m = (mountlist) xmalloc(sizeof(*m));
209
210                         if (reverse_resolve &&
211                            inet_aton((const char *) rep->r_client, &addr) &&
212                            (he = gethostbyaddr(&addr, sizeof(addr), AF_INET)))
213                                 m->ml_hostname = xstrdup(he->h_name);
214                         else
215                                 m->ml_hostname = xstrdup(rep->r_client);
216
217                         m->ml_directory = xstrdup(rep->r_path);
218                         m->ml_next = mlist;
219                         mlist = m;
220                 }
221                 endrmtabent();
222         }
223         xfunlock(lockid);
224
225         return mlist;
226 }