19b22eea280d2028dd607ae5911c9687e91fc588
[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         struct in_addr  addr = sin->sin_addr;
137         struct hostent  *hp;
138         struct rmtabent *rep;
139         nfs_export      *exp;
140         FILE            *fp;
141         int             lockid;
142
143         if ((lockid = xflock(_PATH_RMTABLCK, "w")) < 0)
144                 return;
145         if (!(hp = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET))) {
146                 xlog(L_ERROR, "can't get hostname of %s", inet_ntoa(addr));
147                 goto out_unlock;
148         }
149         hp = hostent_dup (hp);
150
151         if (!setrmtabent("r"))
152                 goto out_free;
153
154         if (!(fp = fsetrmtabent(_PATH_RMTABTMP, "w")))
155                 goto out_close;
156
157         while ((rep = getrmtabent(1, NULL)) != NULL) {
158                 if (strcmp(rep->r_client, hp->h_name) == 0 &&
159                     (exp = auth_authenticate("umountall", sin, rep->r_path)))
160                         continue;
161                 fputrmtabent(fp, rep, NULL);
162         }
163         if (slink_safe_rename(_PATH_RMTABTMP, _PATH_RMTAB) < 0) {
164                 xlog(L_ERROR, "couldn't rename %s to %s",
165                                 _PATH_RMTABTMP, _PATH_RMTAB);
166         }
167         fendrmtabent(fp);
168 out_close:
169         endrmtabent();  /* close & unlink */
170 out_free:
171         free (hp);
172 out_unlock:
173         xfunlock(lockid);
174 }
175
176 mountlist
177 mountlist_list(void)
178 {
179         static mountlist        mlist = NULL;
180         static time_t           last_mtime = 0;
181         mountlist               m;
182         struct rmtabent         *rep;
183         struct stat             stb;
184         int                     lockid;
185         struct in_addr          addr;
186         struct hostent          *he;
187
188         if ((lockid = xflock(_PATH_RMTABLCK, "r")) < 0)
189                 return NULL;
190         if (stat(_PATH_RMTAB, &stb) < 0) {
191                 xlog(L_ERROR, "can't stat %s: %s",
192                                 _PATH_RMTAB, strerror(errno));
193                 xfunlock(lockid);
194                 return NULL;
195         }
196         if (stb.st_mtime != last_mtime) {
197                 while (mlist) {
198                         mlist = (m = mlist)->ml_next;
199                         xfree(m->ml_hostname);
200                         xfree(m->ml_directory);
201                         xfree(m);
202                 }
203                 last_mtime = stb.st_mtime;
204
205                 setrmtabent("r");
206                 while ((rep = getrmtabent(1, NULL)) != NULL) {
207                         m = (mountlist) xmalloc(sizeof(*m));
208
209                         if (reverse_resolve &&
210                            inet_aton((const char *) rep->r_client, &addr) &&
211                            (he = gethostbyaddr(&addr, sizeof(addr), AF_INET)))
212                                 m->ml_hostname = xstrdup(he->h_name);
213                         else
214                                 m->ml_hostname = xstrdup(rep->r_client);
215
216                         m->ml_directory = xstrdup(rep->r_path);
217                         m->ml_next = mlist;
218                         mlist = m;
219                 }
220                 endrmtabent();
221         }
222         xfunlock(lockid);
223
224         return mlist;
225 }