(client_ops): Mark as const.
[kopensolaris-gnu/glibc.git] / sunrpc / clnt_udp.c
index 1e2fe65..f4a46b5 100644 (file)
@@ -39,6 +39,7 @@ static char sccsid[] = "@(#)clnt_udp.c 1.39 87/08/11 Copyr 1984 Sun Micro";
 
 #include <stdio.h>
 #include <unistd.h>
+#include <libintl.h>
 #include <rpc/rpc.h>
 #include <rpc/xdr.h>
 #include <rpc/clnt.h>
@@ -48,8 +49,19 @@ static char sccsid[] = "@(#)clnt_udp.c 1.39 87/08/11 Copyr 1984 Sun Micro";
 #include <netdb.h>
 #include <errno.h>
 #include <rpc/pmap_clnt.h>
+#include <net/if.h>
+#include <ifaddrs.h>
+#ifdef USE_IN_LIBIO
+# include <wchar.h>
+#endif
+
+#ifdef IP_RECVERR
+#include <errqueue.h>
+#include <sys/uio.h>
+#endif
 
 extern bool_t xdr_opaque_auth (XDR *, struct opaque_auth *);
+extern u_long _create_xid (void);
 
 /*
  * UDP bases client side rpc operations
@@ -109,41 +121,28 @@ struct cu_data
  * sent and received.
  */
 CLIENT *
-clntudp_bufcreate (raddr, program, version, wait, sockp, sendsz, recvsz)
-     struct sockaddr_in *raddr;
-     u_long program;
-     u_long version;
-     struct timeval wait;
-     int *sockp;
-     u_int sendsz;
-     u_int recvsz;
+clntudp_bufcreate (struct sockaddr_in *raddr, u_long program, u_long version,
+                  struct timeval wait, int *sockp, u_int sendsz,
+                  u_int recvsz)
 {
   CLIENT *cl;
   struct cu_data *cu = NULL;
-  struct timeval now;
   struct rpc_msg call_msg;
 
   cl = (CLIENT *) mem_alloc (sizeof (CLIENT));
-  if (cl == NULL)
-    {
-      (void) fprintf (stderr, _("clntudp_create: out of memory\n"));
-      rpc_createerr.cf_stat = RPC_SYSTEMERROR;
-      rpc_createerr.cf_error.re_errno = errno;
-      goto fooy;
-    }
   sendsz = ((sendsz + 3) / 4) * 4;
   recvsz = ((recvsz + 3) / 4) * 4;
   cu = (struct cu_data *) mem_alloc (sizeof (*cu) + sendsz + recvsz);
-  if (cu == NULL)
+  if (cl == NULL || cu == NULL)
     {
-      (void) fprintf (stderr, _("clntudp_create: out of memory\n"));
-      rpc_createerr.cf_stat = RPC_SYSTEMERROR;
-      rpc_createerr.cf_error.re_errno = errno;
+      struct rpc_createerr *ce = &get_rpc_createerr ();
+      (void) __fxprintf (NULL, "%s", _("clntudp_create: out of memory\n"));
+      ce->cf_stat = RPC_SYSTEMERROR;
+      ce->cf_error.re_errno = ENOMEM;
       goto fooy;
     }
   cu->cu_outbuf = &cu->cu_inbuf[recvsz];
 
-  (void) gettimeofday (&now, (struct timezone *) 0);
   if (raddr->sin_port == 0)
     {
       u_short port;
@@ -163,14 +162,13 @@ clntudp_bufcreate (raddr, program, version, wait, sockp, sendsz, recvsz)
   cu->cu_total.tv_usec = -1;
   cu->cu_sendsz = sendsz;
   cu->cu_recvsz = recvsz;
-  call_msg.rm_xid = getpid () ^ now.tv_sec ^ now.tv_usec;
+  call_msg.rm_xid = _create_xid ();
   call_msg.rm_direction = CALL;
   call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
   call_msg.rm_call.cb_prog = program;
   call_msg.rm_call.cb_vers = version;
-  xdrmem_create (&(cu->cu_outxdrs), cu->cu_outbuf,
-                sendsz, XDR_ENCODE);
-  if (!xdr_callhdr (&(cu->cu_outxdrs), &call_msg))
+  INTUSE(xdrmem_create) (&(cu->cu_outxdrs), cu->cu_outbuf, sendsz, XDR_ENCODE);
+  if (!INTUSE(xdr_callhdr) (&(cu->cu_outxdrs), &call_msg))
     {
       goto fooy;
     }
@@ -179,17 +177,24 @@ clntudp_bufcreate (raddr, program, version, wait, sockp, sendsz, recvsz)
     {
       int dontblock = 1;
 
-      *sockp = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+      *sockp = __socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
       if (*sockp < 0)
        {
-         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
-         rpc_createerr.cf_error.re_errno = errno;
+         struct rpc_createerr *ce = &get_rpc_createerr ();
+         ce->cf_stat = RPC_SYSTEMERROR;
+         ce->cf_error.re_errno = errno;
          goto fooy;
        }
       /* attempt to bind to prov port */
       (void) bindresvport (*sockp, (struct sockaddr_in *) 0);
       /* the sockets rpc controls are non-blocking */
-      (void) ioctl (*sockp, FIONBIO, (char *) &dontblock);
+      (void) __ioctl (*sockp, FIONBIO, (char *) &dontblock);
+#ifdef IP_RECVERR
+      {
+       int on = 1;
+       __setsockopt (*sockp, SOL_IP, IP_RECVERR, &on, sizeof(on));
+      }
+#endif
       cu->cu_closeit = TRUE;
     }
   else
@@ -197,7 +202,7 @@ clntudp_bufcreate (raddr, program, version, wait, sockp, sendsz, recvsz)
       cu->cu_closeit = FALSE;
     }
   cu->cu_sock = *sockp;
-  cl->cl_auth = authnone_create ();
+  cl->cl_auth = INTUSE(authnone_create) ();
   return cl;
 fooy:
   if (cu)
@@ -206,6 +211,7 @@ fooy:
     mem_free ((caddr_t) cl, sizeof (CLIENT));
   return (CLIENT *) NULL;
 }
+INTDEF (clntudp_bufcreate)
 
 CLIENT *
 clntudp_create (raddr, program, version, wait, sockp)
@@ -215,9 +221,33 @@ clntudp_create (raddr, program, version, wait, sockp)
      struct timeval wait;
      int *sockp;
 {
+  return INTUSE(clntudp_bufcreate) (raddr, program, version, wait, sockp,
+                                   UDPMSGSIZE, UDPMSGSIZE);
+}
+INTDEF (clntudp_create)
+
+static int
+is_network_up (int sock)
+{
+  struct ifaddrs *ifa;
+
+  if (getifaddrs (&ifa) != 0)
+    return 0;
+
+  struct ifaddrs *run = ifa;
+  while (run != NULL)
+    {
+      if ((run->ifa_flags & IFF_UP) != 0
+         && run->ifa_addr != NULL
+         && run->ifa_addr->sa_family == AF_INET)
+       break;
+
+      run = run->ifa_next;
+    }
+
+  freeifaddrs (ifa);
 
-  return clntudp_bufcreate (raddr, program, version, wait, sockp,
-                           UDPMSGSIZE, UDPMSGSIZE);
+  return run != NULL;
 }
 
 static enum clnt_stat
@@ -245,6 +275,7 @@ clntudp_call (cl, proc, xargs, argsp, xresults, resultsp, utimeout)
   bool_t ok;
   int nrefreshes = 2;          /* number of times to refresh cred */
   struct timeval timeout;
+  int anyup;                   /* any network interface up */
 
   if (cu->cu_total.tv_usec == -1)
     {
@@ -266,7 +297,7 @@ call_again:
   /*
    * the transaction is the first thing in the out buffer
    */
-  (*(u_short *) (cu->cu_outbuf))++;
+  (*(uint32_t *) (cu->cu_outbuf))++;
   if ((!XDR_PUTLONG (xdrs, (long *) &proc)) ||
       (!AUTH_MARSHALL (cl->cl_auth, xdrs)) ||
       (!(*xargs) (xdrs, argsp)))
@@ -274,8 +305,8 @@ call_again:
   outlen = (int) XDR_GETPOS (xdrs);
 
 send_again:
-  if (sendto (cu->cu_sock, cu->cu_outbuf, outlen, 0,
-             (struct sockaddr *) &(cu->cu_raddr), cu->cu_rlen)
+  if (__sendto (cu->cu_sock, cu->cu_outbuf, outlen, 0,
+               (struct sockaddr *) &(cu->cu_raddr), cu->cu_rlen)
       != outlen)
     {
       cu->cu_error.re_errno = errno;
@@ -300,12 +331,20 @@ send_again:
   reply_msg.acpted_rply.ar_results.proc = xresults;
   fd.fd = cu->cu_sock;
   fd.events = POLLIN;
+  anyup = 0;
   for (;;)
     {
-      switch (__poll(&fd, 1, milliseconds))
+      switch (__poll (&fd, 1, milliseconds))
        {
 
        case 0:
+         if (anyup == 0)
+           {
+             anyup = is_network_up (cu->cu_sock);
+             if (!anyup)
+               return (cu->cu_error.re_status = RPC_CANTRECV);
+           }
+
          time_waited.tv_sec += cu->cu_wait.tv_sec;
          time_waited.tv_usec += cu->cu_wait.tv_usec;
          while (time_waited.tv_usec >= 1000000)
@@ -329,12 +368,53 @@ send_again:
          cu->cu_error.re_errno = errno;
          return (cu->cu_error.re_status = RPC_CANTRECV);
        }
+#ifdef IP_RECVERR
+      if (fd.revents & POLLERR)
+       {
+         struct msghdr msg;
+         struct cmsghdr *cmsg;
+         struct sock_extended_err *e;
+         struct sockaddr_in err_addr;
+         struct iovec iov;
+         char *cbuf = (char *) alloca (outlen + 256);
+         int ret;
+
+         iov.iov_base = cbuf + 256;
+         iov.iov_len = outlen;
+         msg.msg_name = (void *) &err_addr;
+         msg.msg_namelen = sizeof (err_addr);
+         msg.msg_iov = &iov;
+         msg.msg_iovlen = 1;
+         msg.msg_flags = 0;
+         msg.msg_control = cbuf;
+         msg.msg_controllen = 256;
+         ret = __recvmsg (cu->cu_sock, &msg, MSG_ERRQUEUE);
+         if (ret >= 0
+             && memcmp (cbuf + 256, cu->cu_outbuf, ret) == 0
+             && (msg.msg_flags & MSG_ERRQUEUE)
+             && ((msg.msg_namelen == 0
+                  && ret >= 12)
+                 || (msg.msg_namelen == sizeof (err_addr)
+                     && err_addr.sin_family == AF_INET
+                     && memcmp (&err_addr.sin_addr, &cu->cu_raddr.sin_addr,
+                                sizeof (err_addr.sin_addr)) == 0
+                     && err_addr.sin_port == cu->cu_raddr.sin_port)))
+           for (cmsg = CMSG_FIRSTHDR (&msg); cmsg;
+                cmsg = CMSG_NXTHDR (&msg, cmsg))
+             if (cmsg->cmsg_level == SOL_IP && cmsg->cmsg_type == IP_RECVERR)
+               {
+                 e = (struct sock_extended_err *) CMSG_DATA(cmsg);
+                 cu->cu_error.re_errno = e->ee_errno;
+                 return (cu->cu_error.re_status = RPC_CANTRECV);
+               }
+       }
+#endif
       do
        {
          fromlen = sizeof (struct sockaddr);
-         inlen = recvfrom (cu->cu_sock, cu->cu_inbuf,
-                           (int) cu->cu_recvsz, 0,
-                           (struct sockaddr *) &from, &fromlen);
+         inlen = __recvfrom (cu->cu_sock, cu->cu_inbuf,
+                             (int) cu->cu_recvsz, 0,
+                             (struct sockaddr *) &from, &fromlen);
        }
       while (inlen < 0 && errno == EINTR);
       if (inlen < 0)
@@ -360,8 +440,8 @@ send_again:
   /*
    * now decode and validate the response
    */
-  xdrmem_create (&reply_xdrs, cu->cu_inbuf, (u_int) inlen, XDR_DECODE);
-  ok = xdr_replymsg (&reply_xdrs, &reply_msg);
+  INTUSE(xdrmem_create) (&reply_xdrs, cu->cu_inbuf, (u_int) inlen, XDR_DECODE);
+  ok = INTUSE(xdr_replymsg) (&reply_xdrs, &reply_msg);
   /* XDR_DESTROY(&reply_xdrs);  save a few cycles on noop destroy */
   if (ok)
     {
@@ -377,8 +457,8 @@ send_again:
          if (reply_msg.acpted_rply.ar_verf.oa_base != NULL)
            {
              xdrs->x_op = XDR_FREE;
-             (void) xdr_opaque_auth (xdrs,
-                                     &(reply_msg.acpted_rply.ar_verf));
+             (void) INTUSE(xdr_opaque_auth) (xdrs,
+                                             &(reply_msg.acpted_rply.ar_verf));
            }
        }                       /* end successful completion */
       else
@@ -511,7 +591,7 @@ clntudp_destroy (CLIENT *cl)
 
   if (cu->cu_closeit)
     {
-      (void) close (cu->cu_sock);
+      (void) __close (cu->cu_sock);
     }
   XDR_DESTROY (&(cu->cu_outxdrs));
   mem_free ((caddr_t) cu, (sizeof (*cu) + cu->cu_sendsz + cu->cu_recvsz));