#define NFS_PORT 2049
#endif
+#if SIZEOF_SOCKLEN_T - 0 == 0
+#define socklen_t unsigned int
+#endif
+
extern int nfs_mount_data_version;
extern char *progname;
extern int verbose;
return 1;
}
+/*
+ * Create a socket that is locally bound to a reserved or non-reserved
+ * port. For any failures, RPC_ANYSOCK is returned which will cause
+ * the RPC code to create the socket instead.
+ */
+static int get_socket(struct sockaddr_in *saddr, unsigned int p_prot,
+ int resvp, int conn)
+{
+ int so, cc, type;
+ struct sockaddr_in laddr;
+ socklen_t namelen = sizeof(laddr);
+
+ type = (p_prot == IPPROTO_UDP ? SOCK_DGRAM : SOCK_STREAM);
+ if ((so = socket (AF_INET, type, p_prot)) < 0) {
+ rpc_createerr.cf_stat = RPC_SYSTEMERROR;
+ rpc_createerr.cf_error.re_errno = errno;
+ if (verbose) {
+ fprintf(stderr,
+ "mount: Unable to create %s socket: errno %d (%s)\n",
+ p_prot == IPPROTO_UDP ? "UDP" : "TCP",
+ errno, strerror(errno));
+ }
+ return RPC_ANYSOCK;
+ }
+ laddr.sin_family = AF_INET;
+ laddr.sin_port = 0;
+ laddr.sin_addr.s_addr = htonl(INADDR_ANY);
+ if (resvp) {
+ if (bindresvport(so, &laddr) < 0) {
+ rpc_createerr.cf_stat = RPC_SYSTEMERROR;
+ rpc_createerr.cf_error.re_errno = errno;
+ if (verbose) {
+ fprintf(stderr,
+ "mount: Unable to bindresvport %s socket: errno %d (%s)\n",
+ p_prot == IPPROTO_UDP ? "UDP" : "TCP",
+ errno, strerror(errno));
+ }
+ close(so);
+ return RPC_ANYSOCK;
+ }
+ } else {
+ cc = bind(so, (struct sockaddr *)&laddr, namelen);
+ if (cc < 0) {
+ rpc_createerr.cf_stat = RPC_SYSTEMERROR;
+ rpc_createerr.cf_error.re_errno = errno;
+ if (verbose) {
+ fprintf(stderr,
+ "mount: Unable to bind to %s socket: errno %d (%s)\n",
+ p_prot == IPPROTO_UDP ? "UDP" : "TCP",
+ errno, strerror(errno));
+ }
+ close(so);
+ return RPC_ANYSOCK;
+ }
+ }
+ if (type == SOCK_STREAM || (conn && type == SOCK_DGRAM)) {
+ cc = connect(so, (struct sockaddr *)saddr, namelen);
+ if (cc < 0) {
+ rpc_createerr.cf_stat = RPC_SYSTEMERROR;
+ rpc_createerr.cf_error.re_errno = errno;
+ if (verbose) {
+ fprintf(stderr,
+ "mount: Unable to connect to %s:%d, errno %d (%s)\n",
+ inet_ntoa(saddr->sin_addr), ntohs(saddr->sin_port),
+ errno, strerror(errno));
+ }
+ close(so);
+ return RPC_ANYSOCK;
+ }
+ }
+ return so;
+}
+
/*
* getport() is very similar to pmap_getport() with the exception that
* this version tries to use an ephemeral port, since reserved ports are
clnt_destroy(clnt);
close(msock);
}
+
+/*
+ * Sigh... getport() doesn't actually check the version number.
+ * In order to make sure that the server actually supports the service
+ * we're requesting, we open and RPC client, and fire off a NULL
+ * RPC call.
+ */
+int clnt_ping(struct sockaddr_in *saddr, const unsigned long prog,
+ const unsigned long vers, const unsigned int prot,
+ struct sockaddr_in *caddr)
+{
+ CLIENT *clnt = NULL;
+ int sock, stat;
+ static char clnt_res;
+ struct sockaddr dissolve;
+
+ rpc_createerr.cf_stat = stat = errno = 0;
+ sock = get_socket(saddr, prot, FALSE, TRUE);
+ if (sock == RPC_ANYSOCK) {
+ if (errno == ETIMEDOUT) {
+ /*
+ * TCP timeout. Bubble up the error to see
+ * how it should be handled.
+ */
+ rpc_createerr.cf_stat = RPC_TIMEDOUT;
+ }
+ return 0;
+ }
+
+ if (caddr) {
+ /* Get the address of our end of this connection */
+ socklen_t len = sizeof(*caddr);
+ if (getsockname(sock, caddr, &len) != 0)
+ caddr->sin_family = 0;
+ }
+
+ switch(prot) {
+ case IPPROTO_UDP:
+ /* The socket is connected (so we could getsockname successfully),
+ * but some servers on multi-homed hosts reply from
+ * the wrong address, so if we stay connected, we lose the reply.
+ */
+ dissolve.sa_family = AF_UNSPEC;
+ connect(sock, &dissolve, sizeof(dissolve));
+
+ clnt = clntudp_bufcreate(saddr, prog, vers,
+ RETRY_TIMEOUT, &sock,
+ RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
+ break;
+ case IPPROTO_TCP:
+ clnt = clnttcp_create(saddr, prog, vers, &sock,
+ RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
+ break;
+ }
+ if (!clnt) {
+ close(sock);
+ return 0;
+ }
+ memset(&clnt_res, 0, sizeof(clnt_res));
+ stat = clnt_call(clnt, NULLPROC,
+ (xdrproc_t)xdr_void, (caddr_t)NULL,
+ (xdrproc_t)xdr_void, (caddr_t)&clnt_res,
+ TIMEOUT);
+ if (stat) {
+ clnt_geterr(clnt, &rpc_createerr.cf_error);
+ rpc_createerr.cf_stat = stat;
+ }
+ clnt_destroy(clnt);
+ close(sock);
+
+ if (stat == RPC_SUCCESS)
+ return 1;
+ else
+ return 0;
+}