Initial revision
[nfs-utils.git] / utils / statd / rmtcall.c
1 /*
2  * Copyright (C) 1996, 1999 Olaf Kirch
3  * Modified by Jeffrey A. Uphoff, 1997-1999.
4  * Modified by H.J. Lu, 1998.
5  *
6  * NSM for Linux.
7  */
8
9 /*
10  * After reboot, notify all hosts on our notify list. In order not to
11  * hang statd with delivery to dead hosts, we perform all RPC calls in
12  * parallel.
13  *
14  * It would have been nice to use the portmapper's rmtcall feature,
15  * but that's not possible for security reasons (the portmapper would
16  * have to forward the call with root privs for most statd's, which
17  * it won't if it's worth its money).
18  */
19
20 #include "config.h"
21
22 #include <sys/types.h>
23 #include <sys/socket.h>
24 #include <sys/time.h>
25 #include <netinet/in.h>
26 #include <arpa/inet.h>
27 #include <rpc/rpc.h>
28 #include <rpc/pmap_prot.h>
29 #include <rpc/pmap_rmt.h>
30 #include <netdb.h>
31 #include <string.h>
32 #include <unistd.h>
33 #include "sm_inter.h"
34 #include "statd.h"
35 #include "notlist.h"
36 #include "log.h"
37
38 #define MAXMSGSIZE      (2048 / sizeof(unsigned int))
39
40 static unsigned long    xid = 0;        /* RPC XID counter */
41 static int              sockfd = -1;    /* notify socket */
42
43 /*
44  * Initialize callback socket
45  */
46 static int
47 get_socket(void)
48 {
49         struct sockaddr_in      sin;
50
51         if (sockfd >= 0)
52                 return sockfd;
53
54         if ((sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
55                 log(L_CRIT, "Can't create socket: %m");
56                 return -1;
57         }
58
59         FD_SET(sockfd, &SVC_FDSET);
60
61         memset(&sin, 0, sizeof(sin));
62         sin.sin_family = AF_INET;
63         if (bindresvport(sockfd, &sin) < 0) {
64                 dprintf(L_WARNING,
65                         "process_hosts: can't bind to reserved port\n");
66         }
67
68         return sockfd;
69 }
70
71 /*
72  * Try to resolve host name for notify/callback request
73  *
74  * When compiled with RESTRICTED_STATD defined, we expect all
75  * host names to be dotted quads. See monitor.c for details. --okir
76  */
77 #ifdef RESTRICTED_STATD
78 static int
79 try_to_resolve(notify_list *lp)
80 {
81         char            *hname;
82
83         if (NL_TYPE(lp) == NOTIFY_REBOOT)
84                 hname = NL_MON_NAME(lp);
85         else
86                 hname = NL_MY_NAME(lp);
87         if (!inet_aton(hname, &(NL_ADDR(lp)))) {
88                 log(L_ERROR, "%s is not an dotted-quad address", hname);
89                 NL_TIMES(lp) = 0;
90                 return 0;
91         }
92
93         /* XXX: In order to handle multi-homed hosts, we could do
94          * a reverse lookup, a forward lookup, and cycle through
95          * all the addresses.
96          */
97         return 1;
98 }
99 #else
100 static int
101 try_to_resolve(notify_list *lp)
102 {
103         struct hostent  *hp;
104         char            *hname;
105
106         if (NL_TYPE(lp) == NOTIFY_REBOOT)
107                 hname = NL_MON_NAME(lp);
108         else
109                 hname = NL_MY_NAME(lp);
110
111         dprintf(L_DEBUG, "Trying to resolve %s.", hname);
112         if (!(hp = gethostbyname(hname))) {
113                 herror("gethostbyname");
114                 NL_TIMES(lp) -= 1;
115                 return 0;
116         }
117
118         if (hp->h_addrtype != AF_INET) {
119                 log(L_ERROR, "%s is not an AF_INET address", hname);
120                 NL_TIMES(lp) = 0;
121                 return 0;
122         }
123
124         /* FIXME: should try all addresses for multi-homed hosts in
125          * alternation because one interface might be down/unreachable. */
126         NL_ADDR(lp) = *(struct in_addr *) hp->h_addr;
127
128         dprintf(L_DEBUG, "address of %s is %s", hname, inet_ntoa(NL_ADDR(lp)));
129         return 1;
130 }
131 #endif
132
133 static unsigned long
134 xmit_call(int sockfd, struct sockaddr_in *sin,
135           u_int32_t prog, u_int32_t vers, u_int32_t proc,
136           xdrproc_t func, void *obj)
137 /*              __u32 prog, __u32 vers, __u32 proc, xdrproc_t func, void *obj) */
138 {
139         unsigned int            msgbuf[MAXMSGSIZE], msglen;
140         struct rpc_msg          mesg;
141         struct pmap             pmap;
142         XDR                     xdr, *xdrs = &xdr;
143         int                     err;
144
145         if (!xid)
146                 xid = getpid() + time(NULL);
147
148         mesg.rm_xid = ++xid;
149         mesg.rm_direction = CALL;
150         mesg.rm_call.cb_rpcvers = 2;
151         if (sin->sin_port == 0) {
152                 sin->sin_port = htons(PMAPPORT);
153                 mesg.rm_call.cb_prog = PMAPPROG;
154                 mesg.rm_call.cb_vers = PMAPVERS;
155                 mesg.rm_call.cb_proc = PMAPPROC_GETPORT;
156                 pmap.pm_prog = prog;
157                 pmap.pm_vers = vers;
158                 pmap.pm_prot = IPPROTO_UDP;
159                 pmap.pm_port = 0;
160                 func = (xdrproc_t) xdr_pmap;
161                 obj  = &pmap;
162         } else {
163                 mesg.rm_call.cb_prog = prog;
164                 mesg.rm_call.cb_vers = vers;
165                 mesg.rm_call.cb_proc = proc;
166         }
167         mesg.rm_call.cb_cred.oa_flavor = AUTH_NULL;
168         mesg.rm_call.cb_cred.oa_base = (caddr_t) NULL;
169         mesg.rm_call.cb_cred.oa_length = 0;
170         mesg.rm_call.cb_verf.oa_flavor = AUTH_NULL;
171         mesg.rm_call.cb_verf.oa_base = (caddr_t) NULL;
172         mesg.rm_call.cb_verf.oa_length = 0;
173
174         /* Create XDR memory object for encoding */
175         xdrmem_create(xdrs, (caddr_t) msgbuf, sizeof(msgbuf), XDR_ENCODE);
176
177         /* Encode the RPC header part and payload */
178         if (!xdr_callmsg(xdrs, &mesg) || !func(xdrs, obj)) {
179                 dprintf(L_WARNING, "xmit_mesg: can't encode RPC message!\n");
180                 xdr_destroy(xdrs);
181                 return 0;
182         }
183
184         /* Get overall length of datagram */
185         msglen = xdr_getpos(xdrs);
186
187         if ((err = sendto(sockfd, msgbuf, msglen, 0,
188                         (struct sockaddr *) sin, sizeof(*sin))) < 0) {
189                 dprintf(L_WARNING, "xmit_mesg: sendto failed: %m");
190         } else if (err != msglen) {
191                 dprintf(L_WARNING, "xmit_mesg: short write: %m\n");
192         }
193
194         xdr_destroy(xdrs);
195
196         return err == msglen? xid : 0;
197 }
198
199 static notify_list *
200 recv_rply(int sockfd, struct sockaddr_in *sin, u_long *portp)
201 {
202         unsigned int            msgbuf[MAXMSGSIZE], msglen;
203         struct rpc_msg          mesg;
204         notify_list             *lp = NULL;
205         XDR                     xdr, *xdrs = &xdr;
206         int                     alen = sizeof(*sin);
207
208         /* Receive message */
209         if ((msglen = recvfrom(sockfd, msgbuf, sizeof(msgbuf), 0,
210                         (struct sockaddr *) sin, &alen)) < 0) {
211                 dprintf(L_WARNING, "recv_rply: recvfrom failed: %m");
212                 return NULL;
213         }
214
215         /* Create XDR object for decoding buffer */
216         xdrmem_create(xdrs, (caddr_t) msgbuf, msglen, XDR_DECODE);
217
218         memset(&mesg, 0, sizeof(mesg));
219         mesg.rm_reply.rp_acpt.ar_results.where = NULL;
220         mesg.rm_reply.rp_acpt.ar_results.proc = (xdrproc_t) xdr_void;
221
222         if (!xdr_replymsg(xdrs, &mesg)) {
223                 log(L_WARNING, "recv_rply: can't decode RPC message!\n");
224                 goto done;
225         }
226
227         if (mesg.rm_reply.rp_stat != 0) {
228                 log(L_WARNING, "recv_rply: [%s] RPC status %d\n", 
229                                 inet_ntoa(sin->sin_addr),
230                                 mesg.rm_reply.rp_stat);
231                 goto done;
232         }
233         if (mesg.rm_reply.rp_acpt.ar_stat != 0) {
234                 log(L_WARNING, "recv_rply: [%s] RPC status %d\n",
235                                 inet_ntoa(sin->sin_addr),
236                                 mesg.rm_reply.rp_acpt.ar_stat);
237                 goto done;
238         }
239
240         for (lp = notify; lp != NULL; lp = lp->next) {
241                 if (lp->xid != xid)
242                         continue;
243                 if (lp->addr.s_addr != sin->sin_addr.s_addr) {
244                         char addr [18];
245                         strncpy (addr, inet_ntoa(lp->addr),
246                                  sizeof (addr) - 1);
247                         addr [sizeof (addr) - 1] = '\0';
248                         dprintf(L_WARNING, "address mismatch: "
249                                 "expected %s, got %s\n",
250                                 addr, inet_ntoa(sin->sin_addr));
251                 }
252                 if (lp->port == 0) {
253                         if (!xdr_u_long(xdrs, portp)) {
254                                 log(L_WARNING, "recv_rply: [%s] "
255                                         "can't decode reply body!\n",
256                                         inet_ntoa(sin->sin_addr));
257                                 lp = NULL;
258                                 goto done;
259                         }
260                 }
261                 break;
262         }
263
264 done:
265         xdr_destroy(xdrs);
266         return lp;
267 }
268
269 /*
270  * Notify operation for a single list entry
271  */
272 static int
273 process_entry(int sockfd, notify_list *lp)
274 {
275         struct sockaddr_in      sin;
276         struct status           new_status;
277         xdrproc_t               func;
278         void                    *objp;
279         u_int32_t               proc, vers, prog;
280 /*      __u32                   proc, vers, prog; */
281
282         if (lp->addr.s_addr == INADDR_ANY && !try_to_resolve(lp))
283                 return NL_TIMES(lp);
284         if (NL_TIMES(lp) == 0) {
285                 log(L_DEBUG, "Cannot notify %s, giving up.\n",
286                                         inet_ntoa(NL_ADDR(lp)));
287                 return 0;
288         }
289
290         memset(&sin, 0, sizeof(sin));
291         sin.sin_family = AF_INET;
292         sin.sin_port   = lp->port;
293         sin.sin_addr   = lp->addr;
294
295         switch (NL_TYPE(lp)) {
296         case NOTIFY_REBOOT:
297                 prog = SM_PROG;
298                 vers = SM_VERS;
299                 proc = SM_NOTIFY;
300                 func = (xdrproc_t) xdr_stat_chge;
301                 objp = &SM_stat_chge;
302                 break;
303         case NOTIFY_CALLBACK:
304                 prog = NL_MY_PROG(lp);
305                 vers = NL_MY_VERS(lp);
306                 proc = NL_MY_PROC(lp);
307                 func = (xdrproc_t) xdr_status;
308                 objp = &new_status;
309                 new_status.mon_name = NL_MON_NAME(lp);
310                 new_status.state    = NL_STATE(lp);
311                 memcpy(new_status.priv, NL_PRIV(lp), SM_PRIV_SIZE);
312                 break;
313         default:
314                 log(L_ERROR, "notify_host: unknown notify type %d",
315                                 NL_TYPE(lp));
316                 return 0;
317         }
318
319         lp->xid = xmit_call(sockfd, &sin, prog, vers, proc, func, objp);
320         if (!lp->xid) {
321                 log(L_WARNING, "notify_host: failed to notify %s\n",
322                                 inet_ntoa(lp->addr));
323         }
324         NL_TIMES(lp) -= 1;
325
326         return 1;
327 }
328
329 /*
330  * Process a datagram received on the notify socket
331  */
332 int
333 process_reply(FD_SET_TYPE *rfds)
334 {
335         struct sockaddr_in      sin;
336         notify_list             *lp;
337         u_long                  port;
338
339         if (sockfd == -1 || !FD_ISSET(sockfd, rfds))
340                 return 0;
341
342         if (!(lp = recv_rply(sockfd, &sin, &port)))
343                 return 1;
344
345         if (lp->port == 0) {
346                 if (port != 0) {
347                         lp->port = htons((unsigned short) port);
348                         process_entry(sockfd, lp);
349                         NL_WHEN(lp) = time(NULL) + NOTIFY_TIMEOUT;
350                         nlist_remove(&notify, lp);
351                         nlist_insert_timer(&notify, lp);
352                         return 1;
353                 }
354                 log(L_WARNING, "recv_rply: [%s] service %d not registered",
355                         inet_ntoa(lp->addr),
356                         NL_TYPE(lp) == NOTIFY_REBOOT? SM_PROG : NL_MY_PROG(lp));
357         } else if (NL_TYPE(lp) == NOTIFY_REBOOT) {
358                 dprintf(L_DEBUG, "Notification of %s succeeded.",
359                         NL_MON_NAME(lp));
360                 xunlink(SM_BAK_DIR, NL_MON_NAME(lp), 0);
361         } else {
362                 dprintf(L_DEBUG, "Callback to %s (for %d) succeeded.",
363                         NL_MY_NAME(lp), NL_MON_NAME(lp));
364         }
365         nlist_free(&notify, lp);
366         return 1;
367 }
368
369 /*
370  * Process a notify list, either for notifying remote hosts after reboot
371  * or for calling back (local) statd clients when the remote has notified
372  * us of a crash. 
373  */
374 int
375 process_notify_list(void)
376 {
377         notify_list     *entry;
378         time_t          now;
379         int             fd;
380
381         if ((fd = get_socket()) < 0)
382                 return 0;
383
384         while ((entry = notify) != NULL && NL_WHEN(entry) < time(&now)) {
385                 if (process_entry(fd, entry)) {
386                         NL_WHEN(entry) = time(NULL) + NOTIFY_TIMEOUT;
387                         nlist_remove(&notify, entry);
388                         nlist_insert_timer(&notify, entry);
389                 } else if (NL_TYPE(entry) == NOTIFY_CALLBACK) {
390                         log(L_ERROR,
391                                 "Can't callback %s (%d,%d), giving up.",
392                                         NL_MY_NAME(entry),
393                                         NL_MY_PROG(entry),
394                                         NL_MY_VERS(entry));
395                         nlist_free(&notify, entry);
396                 } else {
397                         log(L_ERROR,
398                                 "Can't notify %s, giving up.",
399                                         NL_MON_NAME(entry));
400                         xunlink(SM_BAK_DIR, NL_MON_NAME(entry), 0);
401                         nlist_free(&notify, entry);
402                 }
403         }
404
405         return 1;
406 }