Implement _autofssys, _cladm, _lgrpsys, and _lgrp_home_fast
[kopensolaris-gnu/glibc.git] / sunrpc / clnt_raw.c
index 7e9e6e9..44ea03e 100644 (file)
@@ -38,201 +38,219 @@ static char sccsid[] = "@(#)clnt_raw.c 1.22 87/08/11 Copyr 1984 Sun Micro";
  *
  * Memory based rpc for simple testing and timing.
  * Interface to create an rpc client and server in the same process.
  *
  * Memory based rpc for simple testing and timing.
  * Interface to create an rpc client and server in the same process.
- * This lets us similate rpc and get round trip overhead, without
- * any interference from the kernal.
+ * This lets us simulate rpc and get round trip overhead, without
+ * any interference from the kernel.
  */
 
 #include <rpc/rpc.h>
  */
 
 #include <rpc/rpc.h>
+#include <rpc/svc.h>
+#include <rpc/xdr.h>
+#include <libintl.h>
 
 #define MCALL_MSG_SIZE 24
 
 /*
  * This is the "network" we will be moving stuff over.
  */
 
 #define MCALL_MSG_SIZE 24
 
 /*
  * This is the "network" we will be moving stuff over.
  */
-static struct clntraw_private {
-       CLIENT  client_object;
-       XDR     xdr_stream;
-       char    _raw_buf[UDPMSGSIZE];
-       char    mashl_callmsg[MCALL_MSG_SIZE];
-       u_int   mcnt;
-} *clntraw_private;
-
-static enum clnt_stat  clntraw_call();
-static void            clntraw_abort();
-static void            clntraw_geterr();
-static bool_t          clntraw_freeres();
-static bool_t          clntraw_control();
-static void            clntraw_destroy();
-
-static struct clnt_ops client_ops = {
-       clntraw_call,
-       clntraw_abort,
-       clntraw_geterr,
-       clntraw_freeres,
-       clntraw_destroy,
-       clntraw_control
-};
+struct clntraw_private_s
+  {
+    CLIENT client_object;
+    XDR xdr_stream;
+    char _raw_buf[UDPMSGSIZE];
+    char mashl_callmsg[MCALL_MSG_SIZE];
+    u_int mcnt;
+  };
+#ifdef _RPC_THREAD_SAFE_
+#define clntraw_private RPC_THREAD_VARIABLE(clntraw_private_s)
+#else
+static struct clntraw_private_s *clntraw_private;
+#endif
+
+static enum clnt_stat clntraw_call (CLIENT *, u_long, xdrproc_t, caddr_t,
+                                   xdrproc_t, caddr_t, struct timeval);
+static void clntraw_abort (void);
+static void clntraw_geterr (CLIENT *, struct rpc_err *);
+static bool_t clntraw_freeres (CLIENT *, xdrproc_t, caddr_t);
+static bool_t clntraw_control (CLIENT *, int, char *);
+static void clntraw_destroy (CLIENT *);
 
 
-void   svc_getreq();
+static const struct clnt_ops client_ops =
+{
+  clntraw_call,
+  clntraw_abort,
+  clntraw_geterr,
+  clntraw_freeres,
+  clntraw_destroy,
+  clntraw_control
+};
 
 /*
  * Create a client handle for memory based rpc.
  */
 CLIENT *
 
 /*
  * Create a client handle for memory based rpc.
  */
 CLIENT *
-clntraw_create(prog, vers)
-       u_long prog;
-       u_long vers;
+clntraw_create (u_long prog, u_long vers)
 {
 {
-       register struct clntraw_private *clp = clntraw_private;
-       struct rpc_msg call_msg;
-       XDR *xdrs = &clp->xdr_stream;
-       CLIENT  *client = &clp->client_object;
-
-       if (clp == 0) {
-               clp = (struct clntraw_private *)calloc(1, sizeof (*clp));
-               if (clp == 0)
-                       return (0);
-               clntraw_private = clp;
-       }
-       /*
-        * pre-serialize the staic part of the call msg and stash it away
-        */
-       call_msg.rm_direction = CALL;
-       call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
-       call_msg.rm_call.cb_prog = prog;
-       call_msg.rm_call.cb_vers = vers;
-       xdrmem_create(xdrs, clp->mashl_callmsg, MCALL_MSG_SIZE, XDR_ENCODE);
-       if (! xdr_callhdr(xdrs, &call_msg)) {
-               perror(_("clnt_raw.c - Fatal header serialization error."));
-       }
-       clp->mcnt = XDR_GETPOS(xdrs);
-       XDR_DESTROY(xdrs);
-
-       /*
-        * Set xdrmem for client/server shared buffer
-        */
-       xdrmem_create(xdrs, clp->_raw_buf, UDPMSGSIZE, XDR_FREE);
-
-       /*
-        * create client handle
-        */
-       client->cl_ops = &client_ops;
-       client->cl_auth = authnone_create();
-       return (client);
+  struct clntraw_private_s *clp = clntraw_private;
+  struct rpc_msg call_msg;
+  XDR *xdrs;
+  CLIENT *client;
+
+  if (clp == 0)
+    {
+      clp = (struct clntraw_private_s *) calloc (1, sizeof (*clp));
+      if (clp == 0)
+       return (0);
+      clntraw_private = clp;
+    }
+  xdrs = &clp->xdr_stream;
+  client = &clp->client_object;
+  /*
+   * pre-serialize the static part of the call msg and stash it away
+   */
+  call_msg.rm_direction = CALL;
+  call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
+  call_msg.rm_call.cb_prog = prog;
+  call_msg.rm_call.cb_vers = vers;
+  INTUSE(xdrmem_create) (xdrs, clp->mashl_callmsg, MCALL_MSG_SIZE, XDR_ENCODE);
+  if (!INTUSE(xdr_callhdr) (xdrs, &call_msg))
+    {
+      perror (_ ("clnt_raw.c: fatal header serialization error"));
+    }
+  clp->mcnt = XDR_GETPOS (xdrs);
+  XDR_DESTROY (xdrs);
+
+  /*
+   * Set xdrmem for client/server shared buffer
+   */
+  INTUSE(xdrmem_create) (xdrs, clp->_raw_buf, UDPMSGSIZE, XDR_FREE);
+
+  /*
+   * create client handle
+   */
+  client->cl_ops = (struct clnt_ops *) &client_ops;
+  client->cl_auth = INTUSE(authnone_create) ();
+  return client;
 }
 
 static enum clnt_stat
 }
 
 static enum clnt_stat
-clntraw_call(h, proc, xargs, argsp, xresults, resultsp, timeout)
-       CLIENT *h;
-       u_long proc;
-       xdrproc_t xargs;
-       caddr_t argsp;
-       xdrproc_t xresults;
-       caddr_t resultsp;
-       struct timeval timeout;
+clntraw_call (h, proc, xargs, argsp, xresults, resultsp, timeout)
+     CLIENT *h;
+     u_long proc;
+     xdrproc_t xargs;
+     caddr_t argsp;
+     xdrproc_t xresults;
+     caddr_t resultsp;
+     struct timeval timeout;
 {
 {
-       register struct clntraw_private *clp = clntraw_private;
-       register XDR *xdrs = &clp->xdr_stream;
-       struct rpc_msg msg;
-       enum clnt_stat status;
-       struct rpc_err error;
-
-       if (clp == 0)
-               return (RPC_FAILED);
+  struct clntraw_private_s *clp = clntraw_private;
+  XDR *xdrs = &clp->xdr_stream;
+  struct rpc_msg msg;
+  enum clnt_stat status;
+  struct rpc_err error;
+
+  if (clp == NULL)
+    return RPC_FAILED;
 call_again:
 call_again:
-       /*
-        * send request
-        */
-       xdrs->x_op = XDR_ENCODE;
-       XDR_SETPOS(xdrs, 0);
-       ((struct rpc_msg *)clp->mashl_callmsg)->rm_xid ++ ;
-       if ((! XDR_PUTBYTES(xdrs, clp->mashl_callmsg, clp->mcnt)) ||
-           (! XDR_PUTLONG(xdrs, (long *)&proc)) ||
-           (! AUTH_MARSHALL(h->cl_auth, xdrs)) ||
-           (! (*xargs)(xdrs, argsp))) {
-               return (RPC_CANTENCODEARGS);
+  /*
+   * send request
+   */
+  xdrs->x_op = XDR_ENCODE;
+  XDR_SETPOS (xdrs, 0);
+  ((struct rpc_msg *) clp->mashl_callmsg)->rm_xid++;
+  if ((!XDR_PUTBYTES (xdrs, clp->mashl_callmsg, clp->mcnt)) ||
+      (!XDR_PUTLONG (xdrs, (long *) &proc)) ||
+      (!AUTH_MARSHALL (h->cl_auth, xdrs)) ||
+      (!(*xargs) (xdrs, argsp)))
+    {
+      return (RPC_CANTENCODEARGS);
+    }
+  (void) XDR_GETPOS (xdrs);    /* called just to cause overhead */
+
+  /*
+   * We have to call server input routine here because this is
+   * all going on in one process. Yuk.
+   */
+  INTUSE(svc_getreq) (1);
+
+  /*
+   * get results
+   */
+  xdrs->x_op = XDR_DECODE;
+  XDR_SETPOS (xdrs, 0);
+  msg.acpted_rply.ar_verf = _null_auth;
+  msg.acpted_rply.ar_results.where = resultsp;
+  msg.acpted_rply.ar_results.proc = xresults;
+  if (!INTUSE(xdr_replymsg) (xdrs, &msg))
+    return RPC_CANTDECODERES;
+  _seterr_reply (&msg, &error);
+  status = error.re_status;
+
+  if (status == RPC_SUCCESS)
+    {
+      if (!AUTH_VALIDATE (h->cl_auth, &msg.acpted_rply.ar_verf))
+       {
+         status = RPC_AUTHERROR;
+       }
+    }                          /* end successful completion */
+  else
+    {
+      if (AUTH_REFRESH (h->cl_auth))
+       goto call_again;
+    }                          /* end of unsuccessful completion */
+
+  if (status == RPC_SUCCESS)
+    {
+      if (!AUTH_VALIDATE (h->cl_auth, &msg.acpted_rply.ar_verf))
+       {
+         status = RPC_AUTHERROR;
        }
        }
-       (void)XDR_GETPOS(xdrs);  /* called just to cause overhead */
-
-       /*
-        * We have to call server input routine here because this is
-        * all going on in one process. Yuk.
-        */
-       svc_getreq(1);
-
-       /*
-        * get results
-        */
-       xdrs->x_op = XDR_DECODE;
-       XDR_SETPOS(xdrs, 0);
-       msg.acpted_rply.ar_verf = _null_auth;
-       msg.acpted_rply.ar_results.where = resultsp;
-       msg.acpted_rply.ar_results.proc = xresults;
-       if (! xdr_replymsg(xdrs, &msg))
-               return (RPC_CANTDECODERES);
-       _seterr_reply(&msg, &error);
-       status = error.re_status;
-
-       if (status == RPC_SUCCESS) {
-               if (! AUTH_VALIDATE(h->cl_auth, &msg.acpted_rply.ar_verf)) {
-                       status = RPC_AUTHERROR;
-               }
-       }  /* end successful completion */
-       else {
-               if (AUTH_REFRESH(h->cl_auth))
-                       goto call_again;
-       }  /* end of unsuccessful completion */
-
-       if (status == RPC_SUCCESS) {
-               if (! AUTH_VALIDATE(h->cl_auth, &msg.acpted_rply.ar_verf)) {
-                       status = RPC_AUTHERROR;
-               }
-               if (msg.acpted_rply.ar_verf.oa_base != NULL) {
-                       xdrs->x_op = XDR_FREE;
-                       (void)xdr_opaque_auth(xdrs, &(msg.acpted_rply.ar_verf));
-               }
+      if (msg.acpted_rply.ar_verf.oa_base != NULL)
+       {
+         xdrs->x_op = XDR_FREE;
+         (void) INTUSE(xdr_opaque_auth) (xdrs, &(msg.acpted_rply.ar_verf));
        }
        }
+    }
 
 
-       return (status);
+  return status;
 }
 
 static void
 }
 
 static void
-clntraw_geterr()
+clntraw_geterr (CLIENT *cl, struct rpc_err *err)
 {
 }
 
 
 static bool_t
 {
 }
 
 
 static bool_t
-clntraw_freeres(cl, xdr_res, res_ptr)
-       CLIENT *cl;
-       xdrproc_t xdr_res;
-       caddr_t res_ptr;
+clntraw_freeres (cl, xdr_res, res_ptr)
+     CLIENT *cl;
+     xdrproc_t xdr_res;
+     caddr_t res_ptr;
 {
 {
-       register struct clntraw_private *clp = clntraw_private;
-       register XDR *xdrs = &clp->xdr_stream;
-       bool_t rval;
+  struct clntraw_private_s *clp = clntraw_private;
+  XDR *xdrs = &clp->xdr_stream;
+  bool_t rval;
 
 
-       if (clp == 0)
-       {
-               rval = (bool_t) RPC_FAILED;
-               return (rval);
-       }
-       xdrs->x_op = XDR_FREE;
-       return ((*xdr_res)(xdrs, res_ptr));
+  if (clp == NULL)
+    {
+      rval = (bool_t) RPC_FAILED;
+      return rval;
+    }
+  xdrs->x_op = XDR_FREE;
+  return (*xdr_res) (xdrs, res_ptr);
 }
 
 static void
 }
 
 static void
-clntraw_abort()
+clntraw_abort (void)
 {
 }
 
 static bool_t
 {
 }
 
 static bool_t
-clntraw_control()
+clntraw_control (CLIENT *cl, int i, char *c)
 {
 {
-       return (FALSE);
+  return FALSE;
 }
 
 static void
 }
 
 static void
-clntraw_destroy()
+clntraw_destroy (CLIENT *cl)
 {
 }
 {
 }