* Copyright (C) 1996, 1999 Olaf Kirch
* Modified by Jeffrey A. Uphoff, 1997-1999.
* Modified by H.J. Lu, 1998.
+ * Modified by Lon Hohberger, Oct. 2000
+ * - Bugfix handling client responses.
+ * - Paranoia on NOTIFY_CALLBACK case
*
* NSM for Linux.
*/
* it won't if it's worth its money).
*/
-#include "config.h"
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
+#include <net/if.h>
#include <arpa/inet.h>
#include <rpc/rpc.h>
#include <rpc/pmap_prot.h>
#include <rpc/pmap_rmt.h>
+#include <time.h>
#include <netdb.h>
#include <string.h>
#include <unistd.h>
+#ifdef HAVE_IFADDRS_H
+#include <ifaddrs.h>
+#endif /* HAVE_IFADDRS_H */
#include "sm_inter.h"
#include "statd.h"
#include "notlist.h"
#include "log.h"
+#include "ha-callout.h"
#define MAXMSGSIZE (2048 / sizeof(unsigned int))
/*
* Initialize callback socket
*/
-static int
-get_socket(void)
+int
+statd_get_socket(int port)
{
struct sockaddr_in sin;
return sockfd;
if ((sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
- log(L_CRIT, "Can't create socket: %m");
+ note(N_CRIT, "Can't create socket: %m");
return -1;
}
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
+ sin.sin_addr.s_addr = INADDR_ANY;
+ /*
+ * If a local hostname is given (-n option to statd), bind to the address
+ * specified. This is required to support clients that ignore the mon_name in
+ * the statd protocol but use the source address from the request packet.
+ */
+ if (MY_NAME) {
+ struct hostent *hp = gethostbyname(MY_NAME);
+ if (hp)
+ sin.sin_addr = *(struct in_addr *) hp->h_addr;
+ }
+ if (port != 0) {
+ sin.sin_port = htons(port);
+ if (bind(sockfd, &sin, sizeof(sin)) == 0)
+ goto out_success;
+ note(N_CRIT, "statd: failed to bind to outgoing port, %d\n"
+ " falling back on randomly chosen port\n", port);
+ }
if (bindresvport(sockfd, &sin) < 0) {
- dprintf(L_WARNING,
+ dprintf(N_WARNING,
"process_hosts: can't bind to reserved port\n");
}
-
+out_success:
return sockfd;
}
+#ifdef HAVE_IFADDRS_H
+/*
+ * Using the NL_ADDR(lp), reset (if needed) the hostname
+ * that will be put in the SM_NOTIFY to the hostname
+ * that is associated with the network interface
+ * that was monitored
+ */
+static void
+reset_my_name(notify_list *lp)
+{
+ struct ifaddrs *ifa = NULL, *ifap;
+ struct in_addr netaddr, tmp;
+ struct sockaddr_in *sin, *nsin;
+ struct hostent *hp;
+
+ netaddr.s_addr = inet_netof(NL_ADDR(lp));
+ if (getifaddrs(&ifa) >= 0) {
+ for (ifap = ifa; ifap != NULL; ifap = ifap->ifa_next) {
+ if (!(ifap->ifa_flags & IFF_UP))
+ continue;
+
+ note(N_DEBUG, "ifa_name %s\n", ifap->ifa_name);
+ if (ifap->ifa_addr == NULL)
+ continue;
+ if (ifap->ifa_addr->sa_family != AF_INET)
+ continue;
+
+ sin = (struct sockaddr_in *)ifap->ifa_addr;
+ nsin = (struct sockaddr_in *)ifap->ifa_netmask;
+ tmp.s_addr = sin->sin_addr.s_addr & nsin->sin_addr.s_addr;
+ if (memcmp(&tmp.s_addr, &netaddr.s_addr, sizeof(netaddr.s_addr)))
+ continue;
+ hp = gethostbyaddr((char *)&sin->sin_addr,
+ sizeof(sin->sin_addr), AF_INET);
+ if (hp == NULL)
+ continue;
+ if (strcmp(NL_MY_NAME(lp), hp->h_name)) {
+ free(NL_MY_NAME(lp));
+ NL_MY_NAME(lp)= strdup(hp->h_name);
+ note(N_DEBUG, "NL_MY_NAME %s\n", NL_MY_NAME(lp));
+ }
+ }
+ }
+ return;
+}
+#endif /* HAVE_IFADDRS_H */
/*
* Try to resolve host name for notify/callback request
*
else
hname = NL_MY_NAME(lp);
if (!inet_aton(hname, &(NL_ADDR(lp)))) {
- log(L_ERROR, "%s is not an dotted-quad address", hname);
+ note(N_ERROR, "%s is not an dotted-quad address", hname);
NL_TIMES(lp) = 0;
return 0;
}
else
hname = NL_MY_NAME(lp);
- dprintf(L_DEBUG, "Trying to resolve %s.", hname);
+ dprintf(N_DEBUG, "Trying to resolve %s.", hname);
if (!(hp = gethostbyname(hname))) {
herror("gethostbyname");
NL_TIMES(lp) -= 1;
}
if (hp->h_addrtype != AF_INET) {
- log(L_ERROR, "%s is not an AF_INET address", hname);
+ note(N_ERROR, "%s is not an AF_INET address", hname);
NL_TIMES(lp) = 0;
return 0;
}
* alternation because one interface might be down/unreachable. */
NL_ADDR(lp) = *(struct in_addr *) hp->h_addr;
- dprintf(L_DEBUG, "address of %s is %s", hname, inet_ntoa(NL_ADDR(lp)));
+ dprintf(N_DEBUG, "address of %s is %s", hname, inet_ntoa(NL_ADDR(lp)));
return 1;
}
#endif
/* Encode the RPC header part and payload */
if (!xdr_callmsg(xdrs, &mesg) || !func(xdrs, obj)) {
- dprintf(L_WARNING, "xmit_mesg: can't encode RPC message!\n");
+ dprintf(N_WARNING, "xmit_mesg: can't encode RPC message!\n");
xdr_destroy(xdrs);
return 0;
}
if ((err = sendto(sockfd, msgbuf, msglen, 0,
(struct sockaddr *) sin, sizeof(*sin))) < 0) {
- dprintf(L_WARNING, "xmit_mesg: sendto failed: %m");
+ dprintf(N_WARNING, "xmit_mesg: sendto failed: %m");
} else if (err != msglen) {
- dprintf(L_WARNING, "xmit_mesg: short write: %m\n");
+ dprintf(N_WARNING, "xmit_mesg: short write: %m\n");
}
xdr_destroy(xdrs);
/* Receive message */
if ((msglen = recvfrom(sockfd, msgbuf, sizeof(msgbuf), 0,
(struct sockaddr *) sin, &alen)) < 0) {
- dprintf(L_WARNING, "recv_rply: recvfrom failed: %m");
+ dprintf(N_WARNING, "recv_rply: recvfrom failed: %m");
return NULL;
}
mesg.rm_reply.rp_acpt.ar_results.proc = (xdrproc_t) xdr_void;
if (!xdr_replymsg(xdrs, &mesg)) {
- log(L_WARNING, "recv_rply: can't decode RPC message!\n");
+ note(N_WARNING, "recv_rply: can't decode RPC message!\n");
goto done;
}
if (mesg.rm_reply.rp_stat != 0) {
- log(L_WARNING, "recv_rply: [%s] RPC status %d\n",
+ note(N_WARNING, "recv_rply: [%s] RPC status %d\n",
inet_ntoa(sin->sin_addr),
mesg.rm_reply.rp_stat);
goto done;
}
if (mesg.rm_reply.rp_acpt.ar_stat != 0) {
- log(L_WARNING, "recv_rply: [%s] RPC status %d\n",
+ note(N_WARNING, "recv_rply: [%s] RPC status %d\n",
inet_ntoa(sin->sin_addr),
mesg.rm_reply.rp_acpt.ar_stat);
goto done;
}
for (lp = notify; lp != NULL; lp = lp->next) {
- if (lp->xid != xid)
+ /* LH - this was a bug... it should have been checking
+ * the xid from the response message from the client,
+ * not the static, internal xid */
+ if (lp->xid != mesg.rm_xid)
continue;
if (lp->addr.s_addr != sin->sin_addr.s_addr) {
char addr [18];
strncpy (addr, inet_ntoa(lp->addr),
sizeof (addr) - 1);
addr [sizeof (addr) - 1] = '\0';
- dprintf(L_WARNING, "address mismatch: "
+ dprintf(N_WARNING, "address mismatch: "
"expected %s, got %s\n",
addr, inet_ntoa(sin->sin_addr));
}
if (lp->port == 0) {
if (!xdr_u_long(xdrs, portp)) {
- log(L_WARNING, "recv_rply: [%s] "
+ note(N_WARNING, "recv_rply: [%s] "
"can't decode reply body!\n",
inet_ntoa(sin->sin_addr));
lp = NULL;
{
struct sockaddr_in sin;
struct status new_status;
+ stat_chge new_stat;
xdrproc_t func;
void *objp;
u_int32_t proc, vers, prog;
if (lp->addr.s_addr == INADDR_ANY && !try_to_resolve(lp))
return NL_TIMES(lp);
if (NL_TIMES(lp) == 0) {
- log(L_DEBUG, "Cannot notify %s, giving up.\n",
+ note(N_DEBUG, "Cannot notify %s, giving up.\n",
inet_ntoa(NL_ADDR(lp)));
return 0;
}
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = lp->port;
- sin.sin_addr = lp->addr;
+ /* LH - moved address into switch */
switch (NL_TYPE(lp)) {
case NOTIFY_REBOOT:
prog = SM_PROG;
vers = SM_VERS;
proc = SM_NOTIFY;
+
+ /* Use source address for notify replies */
+ sin.sin_addr = lp->addr;
+ /*
+ * Unless a static hostname has been defined
+ * set the NL_MY_NAME(lp) hostname to the
+ * one associated with the network interface
+ */
+#ifdef HAVE_IFADDRS_H
+ if (!(run_mode & STATIC_HOSTNAME))
+ reset_my_name(lp);
+#endif /* HAVE_IFADDRS_H */
func = (xdrproc_t) xdr_stat_chge;
- objp = &SM_stat_chge;
+ new_stat.state = MY_STATE;
+ new_stat.mon_name = NL_MY_NAME(lp);
+
+ objp = &new_stat;
break;
case NOTIFY_CALLBACK:
prog = NL_MY_PROG(lp);
vers = NL_MY_VERS(lp);
proc = NL_MY_PROC(lp);
+
+ /* __FORCE__ loopback for callbacks to lockd ... */
+ /* Just in case we somehow ignored it thus far */
+ sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+
func = (xdrproc_t) xdr_status;
objp = &new_status;
new_status.mon_name = NL_MON_NAME(lp);
memcpy(new_status.priv, NL_PRIV(lp), SM_PRIV_SIZE);
break;
default:
- log(L_ERROR, "notify_host: unknown notify type %d",
+ note(N_ERROR, "notify_host: unknown notify type %d",
NL_TYPE(lp));
return 0;
}
lp->xid = xmit_call(sockfd, &sin, prog, vers, proc, func, objp);
if (!lp->xid) {
- log(L_WARNING, "notify_host: failed to notify %s\n",
+ note(N_WARNING, "notify_host: failed to notify %s\n",
inet_ntoa(lp->addr));
}
NL_TIMES(lp) -= 1;
nlist_insert_timer(¬ify, lp);
return 1;
}
- log(L_WARNING, "recv_rply: [%s] service %d not registered",
+ note(N_WARNING, "recv_rply: [%s] service %d not registered",
inet_ntoa(lp->addr),
NL_TYPE(lp) == NOTIFY_REBOOT? SM_PROG : NL_MY_PROG(lp));
} else if (NL_TYPE(lp) == NOTIFY_REBOOT) {
- dprintf(L_DEBUG, "Notification of %s succeeded.",
+ dprintf(N_DEBUG, "Notification of %s succeeded.",
NL_MON_NAME(lp));
xunlink(SM_BAK_DIR, NL_MON_NAME(lp), 0);
} else {
- dprintf(L_DEBUG, "Callback to %s (for %d) succeeded.",
+ dprintf(N_DEBUG, "Callback to %s (for %d) succeeded.",
NL_MY_NAME(lp), NL_MON_NAME(lp));
}
nlist_free(¬ify, lp);
time_t now;
int fd;
- if ((fd = get_socket()) < 0)
+ if ((fd = statd_get_socket(0)) < 0)
return 0;
while ((entry = notify) != NULL && NL_WHEN(entry) < time(&now)) {
nlist_remove(¬ify, entry);
nlist_insert_timer(¬ify, entry);
} else if (NL_TYPE(entry) == NOTIFY_CALLBACK) {
- log(L_ERROR,
+ note(N_ERROR,
"Can't callback %s (%d,%d), giving up.",
NL_MY_NAME(entry),
NL_MY_PROG(entry),
NL_MY_VERS(entry));
nlist_free(¬ify, entry);
} else {
- log(L_ERROR,
+ note(N_ERROR,
"Can't notify %s, giving up.",
NL_MON_NAME(entry));
+ /* PRC: do the HA callout */
+ ha_callout("del-client", NL_MON_NAME(entry), NL_MY_NAME(entry), -1);
xunlink(SM_BAK_DIR, NL_MON_NAME(entry), 0);
nlist_free(¬ify, entry);
}
projects / nfs-utils.git / blobdiff