clntudp_create man page on BSDi

Man page or keyword search:  
man Server   6284 pages
apropos Keyword Search (all sections)
Output format
BSDi logo
[printable version]



RPC(3N)							  RPC(3N)

NAME
       auth_destroy,   authnone_create,	 authunix_create,  authu-
       nix_create_default,  callrpc,  clnt_broadcast,  clnt_call,
       clnt_destroy,   clnt_create,  clnt_control,  clnt_freeres,
       clnt_geterr, clnt_pcreateerror, clnt_perrno,  clnt_perror,
       clnt_spcreateerror,	 clnt_sperrno,	    clnt_sperror,
       clntraw_create,	    clnttcp_create,	  clntudp_create,
       clntudp_bufcreate,  get_myaddress, pmap_getport, pmap_rmt-
       call, pmap_set,	pmap_unset,  registerrpc,  rpc_createerr,
       svc_destroy,	svc_fdset,     svc_fds,	    svc_freeargs,
       svc_getargs,  svc_getcaller,  svc_getreqset,   svc_getreq,
       svc_register,   svc_run,	  svc_sendreply,  svc_unregister,
       svcerr_auth, svcerr_decode, svcerr_noproc,  svcerr_noprog,
       svcerr_progvers,	    svcerr_systemerr,	 svcerr_weakauth,
       svcraw_create, svctcp_create, svcfd_create, svcudp_bufcre-
       ate,  xdr_accepted_reply, xdr_authunix_parms, xdr_callhdr,
       xdr_callmsg,  xdr_opaque_auth,	xdr_pmap,   xdr_pmaplist,
       xdr_rejected_reply,	xdr_replymsg,	   xprt_register,
       xprt_unregister - library routines  for	remote	procedure
       calls

SYNOPSIS AND DESCRIPTION
       These routines allow C programs to make procedure calls on
       other machines across  the  network.   First,  the  client
       calls  a	 procedure  to	send a data packet to the server.
       Upon receipt of the packet, the server  calls  a	 dispatch
       routine	to  perform the requested service, and then sends
       back a reply.  Finally, the procedure call returns to  the
       client.

       Routines that are used for Secure RPC (DES authentication)
       are described in rpc_secure(3N).	 Secure RPC can	 be  used
       only if DES encryption is available.

       #include <rpc/rpc.h>

       void
       auth_destroy(auth)
       AUTH *auth;

	      A	 macro	that destroys the authentication informa-
	      tion associated  with  auth.   Destruction  usually
	      involves	deallocation  of private data structures.
	      The  use	of  auth  is  undefined	  after	  calling
	      auth_destroy().

       AUTH *
       authnone_create()

	      Create  and  returns  an	RPC authentication handle
	      that  passes  unusable  authentication  information
	      with  each  remote  procedure  call.  This  is  the
	      default authentication used by RPC.

			 16 February 1988			1

RPC(3N)							  RPC(3N)

       AUTH *
       authunix_create(host, uid, gid, len, aup_gids)
       char *host;
       int uid, gid, len, *aup.gids;

	      Create and return an RPC authentication handle that
	      contains authentication information.  The parameter
	      host is the name of the machine on which the infor-
	      mation was created; uid is the user's user ID ; gid
	      is the user's current group ID ; len  and	 aup_gids
	      refer  to	 a  counted  array of groups to which the
	      user belongs.  It is easy to impersonate a user.

       AUTH *
       authunix_create_default()

	      Calls authunix_create() with the appropriate param-
	      eters.

       callrpc(host, prognum, versnum, procnum, inproc, in, outproc, out)
       char *host;
       u_long prognum, versnum, procnum;
       char *in, *out;
       xdrproc_t inproc, outproc;

	      Call  the remote procedure associated with prognum,
	      versnum, and procnum on  the  machine,  host.   The
	      parameter	 in  is	 the  address  of the procedure's
	      argument(s), and out is the  address  of	where  to
	      place  the  result(s); inproc is used to encode the
	      procedure's parameters,  and  outproc  is	 used  to
	      decode   the  procedure's	 results.   This  routine
	      returns zero if it succeeds, or the value	 of  enum
	      clnt_stat cast to an integer if it fails.	 The rou-
	      tine clnt_perrno() is handy for translating failure
	      statuses into messages.

	      Warning:	calling	 remote procedures with this rou-
	      tine   uses   UDP/IP   as	   a	transport;    see
	      clntudp_create() for restrictions.  You do not have
	      control of timeouts or  authentication  using  this
	      routine.

       enum clnt_stat
       clnt_broadcast(prognum, versnum, procnum, inproc, in, outproc, out, eachresult)
       u_long prognum, versnum, procnum;
       char *in, *out;
       xdrproc_t inproc, outproc;
       resultproc_t eachresult;

	      Like  callrpc(),	except the call message is broad-
	      cast to all locally connected broadcast nets.  Each
	      time  it	receives  a  response, this routine calls
	      eachresult(), whose form is:

			 16 February 1988			2

RPC(3N)							  RPC(3N)

		 eachresult(out, addr)
		 char *out;
		 struct sockaddr_in *addr;

	      where  out  is  the   same   as	out   passed   to
	      clnt_broadcast(),	 except	 that  the  remote proce-
	      dure's output is decoded there; addr points to  the
	      address  of  the machine that sent the results.  If
	      eachresult() returns zero,  clnt_broadcast()  waits
	      for  more replies; otherwise it returns with appro-
	      priate status.

	      Warning: broadcast sockets are limited in	 size  to
	      the  maximum  transfer  unit  of the data link. For
	      ethernet, this value is 1500 bytes.

       enum clnt_stat
       clnt_call(clnt, procnum, inproc, in, outproc, out, tout)
       CLIENT *clnt;
       u_long
       procnum;
       xdrproc_t inproc, outproc;
       char *in, *out;
       struct timeval tout;

	      A macro that calls  the  remote  procedure  procnum
	      associated  with	the client handle, clnt, which is
	      obtained with an RPC client creation  routine  such
	      as  clnt_create().  The parameter in is the address
	      of the procedure's  argument(s),	and  out  is  the
	      address  of where to place the result(s); inproc is
	      used to encode the procedure's parameters, and out-
	      proc  is	used  to  decode the procedure's results;
	      tout is the time allowed for results to come  back.

       clnt_destroy(clnt)
       CLIENT *clnt;

	      A	 macro	that  destroys	the  client's RPC handle.
	      Destruction usually involves deallocation	 of  pri-
	      vate  data  structures, including clnt itself.  Use
	      of clnt is undefined after calling  clnt_destroy().
	      If the RPC library opened the associated socket, it
	      will close it also.  Otherwise, the socket  remains
	      open.

       CLIENT *
       clnt_create(host, prog, vers, proto)
       char *host;
       u_long prog, vers;
       char *proto;

	      Generic  client  creation routine.  host identifies
	      the name of the remote host  where  the  server  is

			 16 February 1988			3

RPC(3N)							  RPC(3N)

	      located.	 proto	indicates which kind of transport
	      protocol to use. The currently supported values for
	      this  field  are "udp" and "tcp".	 Default timeouts
	      are set, but can be modified using  clnt_control().

	      Warning:	Using  UDP  has	 its shortcomings.  Since
	      UDP-based RPC messages can only hold up to 8 Kbytes
	      of  encoded data, this transport cannot be used for
	      procedures that take large arguments or return huge
	      results.

       bool_t
       clnt_control(cl, req, info)
       CLIENT *cl;
       char *info;

	      A macro used to change or retrieve various informa-
	      tion about a client object.  req indicates the type
	      of operation, and info is a pointer to the informa-
	      tion. For both UDP and TCP, the supported values of
	      req and their argument types and what they do are:

	      CLSET_TIMEOUT	  struct timeval      set total timeout
	      CLGET_TIMEOUT	  struct timeval      get total timeout

	      Note:  if you set the timeout using clnt_control(),
	      the timeout parameter passed to clnt_call() will be
	      ignored in all future calls.

	      CLGET_SERVER_ADDR	  struct sockaddr_in  get server's address

	      The following operations are valid for UDP only:

	      CLSET_RETRY_TIMEOUT struct timeval      set the retry timeout
	      CLGET_RETRY_TIMEOUT struct timeval      get the retry timeout

	      The  retry  timeout  is the time that UDP RPC waits
	      for the server to reply before  retransmitting  the
	      request.

       clnt_freeres(clnt, outproc, out)
       CLIENT *clnt;
       xdrproc_t outproc;
       char *out;

	      A	 macro	that  frees  any  data	allocated  by the
	      RPC/XDR system when it decoded the  results  of  an
	      RPC  call.  The parameter out is the address of the
	      results, and outproc is the XDR routine  describing
	      the  results.   This  routine  returns  one  if the
	      results were successfully freed,	and  zero  other-
	      wise.

       void

			 16 February 1988			4

RPC(3N)							  RPC(3N)

       clnt_geterr(clnt, errp)
       CLIENT *clnt;
       struct rpc_err *errp;

	      A	 macro that copies the error structure out of the
	      client handle to the structure at address errp.

       void
       clnt_pcreateerror(s)
       char *s;

	      Print a message to standard error indicating why	a
	      client  RPC  handle could not be created.	 The mes-
	      sage is prepended with string s and a colon.   Used
	      when     a     clnt_create(),	clntraw_create(),
	      clnttcp_create(), or clntudp_create() call fails.

       void
       clnt_perrno(stat)
       enum clnt_stat stat;

	      Print a message to standard error corresponding  to
	      the   condition  indicated  by  stat.   Used  after
	      callrpc().

       clnt_perror(clnt, s)
       CLIENT *clnt;
       char *s;

	      Print a message to standard error indicating why an
	      RPC  call failed; clnt is the handle used to do the
	      call.  The message is prepended with string s and a
	      colon.  Used after clnt_call().

       char *
       clnt_spcreateerror
       char *s;

	      Like  clnt_pcreateerror(), except that it returns a
	      string instead of printing to the standard error.

	      Bugs: returns pointer to static data that is  over-
	      written on each call.

       char *
       clnt_sperrno(stat)
       enum clnt_stat stat;

	      Take  the	 same  arguments  as  clnt_perrno(),  but
	      instead of sending a message to the standard  error
	      indicating why an RPC call failed, return a pointer
	      to a string which contains the message.  The string
	      ends with a NEWLINE.

			 16 February 1988			5

RPC(3N)							  RPC(3N)

	      clnt_sperrno()  is used instead of clnt_perrno() if
	      the program does not have a standard  error  (as	a
	      program running as a server quite likely does not),
	      or if the programmer does not want the  message  to
	      be  output with printf, or if a message format dif-
	      ferent than that supported by clnt_perrno()  is  to
	      be   used.    Note:   unlike   clnt_sperror()   and
	      clnt_spcreaterror(), clnt_sperrno() returns pointer
	      to  static  data, but the result will not get over-
	      written on each call.

       char *
       clnt_sperror(rpch, s)
       CLIENT *rpch;
       char *s;

	      Like    clnt_perror(),	except	   that	    (like
	      clnt_sperrno())  it  returns  a  string  instead of
	      printing to standard error.

	      Bugs: returns pointer to static data that is  over-
	      written on each call.

       CLIENT *
       clntraw_create(prognum, versnum)
       u_long prognum, versnum;

	      This  routine  creates  a	 toy  RPC  client for the
	      remote  program  prognum,	 version  versnum.    The
	      transport	 used  to pass messages to the service is
	      actually a  buffer  within  the  process's  address
	      space,  so the corresponding RPC server should live
	      in the same  address  space;  see	 svcraw_create().
	      This  allows  simulation	of RPC and acquisition of
	      RPC overheads, such as round  trip  times,  without
	      any  kernel interference. This routine returns NULL
	      if it fails.

       CLIENT *
       clnttcp_create(addr, prognum, versnum, sockp, sendsz, recvsz)
       struct sockaddr_in *addr;
       u_long prognum, versnum;
       int *sockp;
       u_int sendsz, recvsz;

	      This routine creates an RPC client for  the  remote
	      program  prognum,	 version versnum; the client uses
	      TCP/IP  as  a  transport.	 The  remote  program  is
	      located	 at    Internet	   address   *addr.    If
	      addr->sin_port is zero,  then  it	 is  set  to  the
	      actual port that the remote program is listening on
	      (the remote portmap service is consulted	for  this
	      information).  The  parameter sockp is a socket; if
	      it is RPC_ANYSOCK, then this routine  opens  a  new

			 16 February 1988			6

RPC(3N)							  RPC(3N)

	      one  and	sets  sockp.   Since  TCP-based	 RPC uses
	      buffered I/O , the user may specify the size of the
	      send and receive buffers with the parameters sendsz
	      and  recvsz;  values  of	 zero	choose	 suitable
	      defaults.	 This routine returns NULL if it fails.

       CLIENT *
       clntudp_create(addr, prognum, versnum, wait, sockp)
       struct sockaddr_in *addr;
       u_long prognum, versnum;
       struct timeval wait;
       int *sockp;

	      This  routine  creates an RPC client for the remote
	      program prognum, version versnum; the  client  uses
	      use  UDP/IP  as  a transport. The remote program is
	      located	at    Internet	  address    addr.     If
	      addr->sin_port  is  zero,	 then it is set to actual
	      port that the remote program is listening	 on  (the
	      remote portmap service is consulted for this infor-
	      mation). The parameter sockp is a socket; if it  is
	      RPC_ANYSOCK,  then this routine opens a new one and
	      sets sockp.  The UDP  transport  resends	the  call
	      message  in intervals of wait time until a response
	      is received or until the call times out.	The total
	      time  for	 the  call  to	time  out is specified by
	      clnt_call().

	      Warning: since UDP-based RPC messages can only hold
	      up to 8 Kbytes of encoded data, this transport can-
	      not be used for procedures that  take  large  argu-
	      ments or return huge results.

       CLIENT *
       clntudp_bufcreate(addr, prognum, versnum, wait, sockp, sendsize, recosize)
       struct sockaddr_in *addr;
       u_long prognum, versnum;
       struct timeval wait;
       int *sockp;
       unsigned int sendsize;
       unsigned int recosize;

	      This  routine  creates an RPC client for the remote
	      program prognum, on versnum; the	client	uses  use
	      UDP/IP  as  a  transport.	 The  remote  program  is
	      located	at    Internet	  address    addr.     If
	      addr->sin_port  is  zero,	 then it is set to actual
	      port that the remote program is listening	 on  (the
	      remote portmap service is consulted for this infor-
	      mation). The parameter sockp is a socket; if it  is
	      RPC_ANYSOCK,  then this routine opens a new one and
	      sets sockp.  The UDP  transport  resends	the  call
	      message  in intervals of wait time until a response
	      is received or until the call times out.	The total

			 16 February 1988			7

RPC(3N)							  RPC(3N)

	      time  for	 the  call  to	time  out is specified by
	      clnt_call().

	      This allows the user to specify the maximun  packet
	      size  for	 sending and receiving UDP-based RPC mes-
	      sages.

       void
       get_myaddress(addr)
       struct sockaddr_in *addr;

	      Stuff the machine's IP address into *addr,  without
	      consulting  the  library	routines  that	deal with
	      /etc/hosts.  The	port  number  is  always  set  to
	      htons(PMAPPORT).

       struct pmaplist *
       pmap_getmaps(addr)
       struct sockaddr_in *addr;

	      A	 user  interface  to  the  portmap service, which
	      returns a list of the current  RPC  program-to-port
	      mappings	on  the host located at IP address *addr.
	      This  routine  can  return  NULL	.   The	  command
	      `rpcinfo -p' uses this routine.

       u_short
       pmap_getport(addr, prognum, versnum, protocol)
       struct sockaddr_in *addr;
       u_long prognum, versnum, protocol;

	      A	 user  interface  to  the  portmap service, which
	      returns the port number on which	waits  a  service
	      that  supports program number prognum, version ver-
	      snum, and speaks the transport protocol  associated
	      with  protocol.	The  value  of	protocol  is most
	      likely IPPROTO_UDP or IPPROTO_TCP.  A return  value
	      of  zero	means  that the mapping does not exist or
	      that the RPC system failed to  contact  the  remote
	      portmap  service.	  In  the latter case, the global
	      variable rpc_createerr() contains the RPC status.

       enum clnt_stat
       pmap_rmtcall(addr, prognum, versnum, procnum, inproc, in, outproc, out, tout, portp)
       struct sockaddr_in *addr;
       u_long prognum, versnum, procnum;
       char *in, *out;
       xdrproc_t inproc, outproc;
       struct timeval tout;
       u_long *portp;

	      A user interface	to  the	 portmap  service,  which
	      instructs	 portmap  on the host at IP address *addr
	      to make an RPC call on your behalf to  a	procedure

			 16 February 1988			8

RPC(3N)							  RPC(3N)

	      on  that	host.  The parameter *portp will be modi-
	      fied to the program's port number if the	procedure
	      succeeds.	 The  definitions of other parameters are
	      discussed in callrpc() and clnt_call().  This  pro-
	      cedure  should  be  used	for  a "ping" and nothing
	      else.  See also clnt_broadcast().

       pmap_set(prognum, versnum, protocol, port)
       u_long prognum, versnum, protocol;
       u_short port;

	      A user interface	to  the	 portmap  service,  which
	      establishes    a	 mapping   between   the   triple
	      [prognum,versnum,protocol]   and	 port	on    the
	      machine's portmap service. The value of protocol is
	      most likely IPPROTO_UDP or IPPROTO_TCP.  This  rou-
	      tine  returns  one  if it succeeds, zero otherwise.
	      Automatically done by svc_register().

       pmap_unset(prognum, versnum)
       u_long prognum, versnum;

	      A user interface	to  the	 portmap  service,  which
	      destroys	  all	 mapping   between   the   triple
	      [prognum,versnum,*]  and	ports  on  the	machine's
	      portmap  service.	 This  routine	returns one if it
	      succeeds, zero otherwise.

       registerrpc(prognum, versnum, procnum, procname, inproc, outproc)
       u_long prognum, versnum, procnum;
       char *(*procname) () ;
       xdrproc_t inproc, outproc;

	      Register procedure procname with	the  RPC  service
	      package.	If a request arrives for program prognum,
	      version versnum, and procedure procnum, procname is
	      called with a pointer to its parameter(s); progname
	      should return a pointer to  its  static  result(s);
	      inproc  is used to decode the parameters while out-
	      proc is used to encode the results.   This  routine
	      returns zero if the registration succeeded, -1 oth-
	      erwise.

	      Warning: remote procedures registered in this  form
	      are   accessed  using  the  UDP/IP  transport;  see
	      svcudp_create() for restrictions.

       struct rpc_createerr	rpc_createerr;

	      A global variable whose value is	set  by	 any  RPC
	      client creation routine that does not succeed.  Use
	      the routine clnt_pcreateerror() to print the reason
	      why.

			 16 February 1988			9

RPC(3N)							  RPC(3N)

       svc_destroy(xprt)
       SVCXPRT *
       xprt;

	      A	 macro	that  destroys	the RPC service transport
	      handle, xprt.  Destruction usually involves deallo-
	      cation  of  private data structures, including xprt
	      itself.  Use of xprt  is	undefined  after  calling
	      this routine.

       fd_set svc_fdset;

	      A global variable reflecting the RPC service side's
	      read file descriptor bit mask; it is suitable as	a
	      parameter	 to  the select system call. This is only
	      of interest if a service implementor does not  call
	      svc_run(),  but  rather  does  his own asynchronous
	      event processing.	 This variable is  read-only  (do
	      not pass its address to select!), yet it may change
	      after calls to svc_getreqset() or any creation rou-
	      tines.

       int svc_fds;

	      Similar to svc_fedset(), but limited to 32 descrip-
	      tors. This interface is obsoleted by svc_fdset().

       svc_freeargs(xprt, inproc, in)
       SVCXPRT *xprt;
       xdrproc_t inproc;
       char *in;

	      A macro  that  frees  any	 data  allocated  by  the
	      RPC/XDR  system  when it decoded the arguments to a
	      service procedure using svc_getargs().   This  rou-
	      tine  returns  1	if  the results were successfully
	      freed, and zero otherwise.

       svc_getargs(xprt, inproc, in)
       SVCXPRT *xprt;
       xdrproc_t inproc;
       char *in;

	      A macro  that  decodes  the  arguments  of  an  RPC
	      request  associated  with the RPC service transport
	      handle, xprt.  The  parameter  in	 is  the  address
	      where  the  arguments will be placed; inproc is the
	      XDR routine used to  decode  the	arguments.   This
	      routine  returns one if decoding succeeds, and zero
	      otherwise.

       struct sockaddr_in *
       svc_getcaller(xprt)
       SVCXPRT *xprt;

			 16 February 1988		       10

RPC(3N)							  RPC(3N)

	      The approved way of getting the network address  of
	      the  caller  of a procedure associated with the RPC
	      service transport handle, xprt.

       svc_getreqset(rdfds)
       fd_set *rdfds;

	      This routine is  only  of	 interest  if  a  service
	      implementor  does	 not  call svc_run(), but instead
	      implements custom	 asynchronous  event  processing.
	      It is called when the select system call has deter-
	      mined that an RPC request has arrived on	some  RPC
	      socket(s)	 ;  rdfds  is  the  resultant  read  file
	      descriptor bit mask.  The routine returns when  all
	      sockets  associated  with	 the  value of rdfds have
	      been serviced.

       svc_getreq(rdfds)
       int rdfds;

	      Similar  to  svc_getreqset(),  but  limited  to  32
	      descriptors.   This   interface	is  obsoleted  by
	      svc_getreqset().

       svc_register(xprt, prognum, versnum, dispatch, protocol)
       SVCXPRT *xprt;
       u_long prognum, versnum;
       void (*dispatch) ();
       u_long protocol;

	      Associates prognum and  versnum  with  the  service
	      dispatch procedure, dispatch.  If protocol is zero,
	      the service is not registered with the portmap ser-
	      vice.   If  protocol is non-zero, then a mapping of
	      the    triple	[prognum,versnum,protocol]     to
	      xprt->xp_port is established with the local portmap
	      service (generally protocol is zero, IPPROTO_UDP or
	      IPPROTO_TCP ).  The procedure dispatch has the fol-
	      lowing form:
		 dispatch(request, xprt)
		 struct svc_req *request;
		 SVCXPRT *xprt;

	      The svc_register() routine returns one if	 it  suc-
	      ceeds, and zero otherwise.

       svc_run()

	      This  routine  never  returns.  It  waits	 for  RPC
	      requests to arrive, and calls the appropriate  ser-
	      vice procedure using svc_getreq() when one arrives.
	      This procedure is usually waiting	 for  a	 select()
	      system call to return.

			 16 February 1988		       11

RPC(3N)							  RPC(3N)

       svc_sendreply(xprt, outproc, out)
       SVCXPRT *xprt;
       xdrproc_t outproc;
       char *out;

	      Called by an RPC service's dispatch routine to send
	      the results of a remote procedure call.  The param-
	      eter  xprt  is  the  request's associated transport
	      handle; outproc is the XDR routine which is used to
	      encode  the  results; and out is the address of the
	      results.	This routine returns one if it	succeeds,
	      zero otherwise.

       void
       svc_unregister(prognum, versnum)
       u_long prognum, versnum;

	      Remove  all mapping of the double [prognum,versnum]
	      to   dispatch   routines,	  and	of   the   triple
	      [prognum,versnum,*] to port number.

       void
       svcerr_auth(xprt, why)
       SVCXPRT *xprt;
       enum auth_stat why;

	      Called  by  a service dispatch routine that refuses
	      to perform  a  remote  procedure	call  due  to  an
	      authentication error.

       void
       svcerr_decode(xprt)
       SVCXPRT *xprt;

	      Called  by  a  service dispatch routine that cannot
	      successfully  decode  its	 parameters.   See   also
	      svc_getargs().

       void
       svcerr_noproc(xprt)
       SVCXPRT *xprt;

	      Called  by a service dispatch routine that does not
	      implement the  procedure	number	that  the  caller
	      requests.

       void
       svcerr_noprog(xprt)
       SVCXPRT *xprt;

	      Called  when  the desired program is not registered
	      with the RPC package. Service implementors  usually
	      do not need this routine.

			 16 February 1988		       12

RPC(3N)							  RPC(3N)

       void
       svcerr_progvers(xprt)
       SVCXPRT *xprt;

	      Called when the desired version of a program is not
	      registered with the RPC package. Service	implemen-
	      tors usually do not need this routine.

       void
       svcerr_systemerr(xprt)
       SVCXPRT *xprt;

	      Called  by  a  service  dispatch	routine	 when  it
	      detects a system error not covered by any	 particu-
	      lar  protocol.   For  example,  if a service can no
	      longer allocate storage, it may call this	 routine.

       void
       svcerr_weakauth(xprt)
       SVCXPRT *xprt;

	      Called  by  a service dispatch routine that refuses
	      to perform a remote procedure call due to	 insuffi-
	      cient authentication parameters.	The routine calls
	      svcerr_auth(xprt, AUTH_TOOWEAK).

       SVCXPRT *
       svcraw_create()

	      This routine creates a toy RPC  service  transport,
	      to  which	 it  returns a pointer.	 The transport is
	      really a buffer within the process's address space,
	      so  the corresponding RPC client should live in the
	      same address  space;  see	 clntraw_create().   This
	      routine allows simulation of RPC and acquisition of
	      RPC overheads (such as round trip	 times),  without
	      any kernel interference.	This routine returns NULL
	      if it fails.

       SVCXPRT *
       svctcp_create(sock, send_buf_size, recv_buf_size)
       int sock;
       u_int send_buf_size, recv_buf_size;

	      This routine creates  a  TCP/IP-based  RPC  service
	      transport,  to  which  it	 returns  a pointer.  The
	      transport is associated with the socket sock, which
	      may  be  RPC_ANYSOCK, in which case a new socket is
	      created.	If the socket is not bound to a local TCP
	      port,  then  this	 routine binds it to an arbitrary
	      port.  Upon completion, xprt->xp_sock is the trans-
	      port's  socket descriptor, and xprt->xp_port is the
	      transport's port number.	This routine returns NULL
	      if  it fails. Since TCP-based RPC uses buffered I/O

			 16 February 1988		       13

RPC(3N)							  RPC(3N)

	      , users may specify the size of buffers; values  of
	      zero choose suitable defaults.

       SVCXPRT *
       svcfd_create(fd, sendsize, recvsize)
       int fd;
       u_int sendsize;
       u_int recvsize;

	      Create  a	 service  on  top of any open descriptor.
	      Typically, this descriptor is  a	connected  socket
	      for  a  stream  protocol such as TCP.  sendsize and
	      recvsize indicate sizes for the  send  and  receive
	      buffers.	If they are zero, a reasonable default is
	      chosen.

       SVCXPRT *
       svcudp_bufcreate(sock, sendsize, recosize)
       int sock;

	      This routine creates  a  UDP/IP-based  RPC  service
	      transport,  to  which  it	 returns  a pointer.  The
	      transport is associated with the socket sock, which
	      may  be RPC_ANYSOCK , in which case a new socket is
	      created.	If the socket is not bound to a local UDP
	      port,  then  this	 routine binds it to an arbitrary
	      port. Upon completion, xprt->xp_sock is the  trans-
	      port's  socket descriptor, and xprt->xp_port is the
	      transport's port number.	This routine returns NULL
	      if it fails.

	      This  allows the user to specify the maximun packet
	      size for sending and receiving UDP-based	RPC  mes-
	      sages.

       xdr_accepted_reply(xdrs, ar)
       XDR *xdrs;
       struct accepted_reply *ar;

	      Used  for encoding RPC reply messages. This routine
	      is useful for users who wish to generate	RPC-style
	      messages without using the RPC package.

       xdr_authunix_parms(xdrs, aupp)
       XDR *xdrs;
       struct authunix_parms *aupp;

	      Used  for describing UNIX credentials. This routine
	      is useful for users who wish to generate these cre-
	      dentials without using the RPC authentication pack-
	      age.

       void
       xdr_callhdr(xdrs, chdr)

			 16 February 1988		       14

RPC(3N)							  RPC(3N)

       XDR *xdrs;
       struct rpc_msg *chdr;

	      Used for describing RPC call header messages.  This
	      routine  is  useful  for users who wish to generate
	      RPC-style messages without using the RPC package.

       xdr_callmsg(xdrs, cmsg)
       XDR *xdrs;
       struct rpc_msg *cmsg;

	      Used for describing RPC call messages.   This  rou-
	      tine  is useful for users who wish to generate RPC-
	      style messages without using the RPC package.

       xdr_opaque_auth(xdrs, ap)
       XDR *xdrs;
       struct opaque_auth *ap;

	      Used for describing RPC authentication  information
	      messages.	  This	routine	 is  useful for users who
	      wish to generate RPC-style messages  without  using
	      the RPC package.

       xdr_pmap(xdrs, regs)
       XDR *xdrs;
       struct pmap *regs;

	      Used  for	 describing parameters to various portmap
	      procedures, externally.  This routine is useful for
	      users who wish to generate these parameters without
	      using the pmap interface.

       xdr_pmaplist(xdrs, rp)
       XDR *xdrs;
       struct pmaplist **rp;

	      Used for describing a list of port mappings, exter-
	      nally.   This  routine is useful for users who wish
	      to generate these parameters without using the pmap
	      interface.

       xdr_rejected_reply(xdrs, rr)
       XDR *xdrs;
       struct rejected_reply *rr;

	      Used  for describing RPC reply messages.	This rou-
	      tine is useful for users who wish to generate  RPC-
	      style messages without using the RPC package.

       xdr_replymsg(xdrs, rmsg)
       XDR *xdrs;
       struct rpc_msg *rmsg;

			 16 February 1988		       15

RPC(3N)							  RPC(3N)

	      Used  for describing RPC reply messages.	This rou-
	      tine is useful for users who wish to  generate  RPC
	      style messages without using the RPC package.

       void
       xprt_register(xprt)
       SVCXPRT *xprt;

	      After  RPC  service  transport handles are created,
	      they should register themselves with the	RPC  ser-
	      vice  package.   This  routine  modifies the global
	      variable svc_fds().  Service  implementors  usually
	      do not need this routine.

       void
       xprt_unregister(xprt)
       SVCXPRT *xprt;

	      Before   an   RPC	  service   transport  handle  is
	      destroyed, it should unregister itself with the RPC
	      service  package.	 This routine modifies the global
	      variable svc_fds().  Service  implementors  usually
	      do not need this routine.

SEE ALSO
       rpc_secure(3N), xdr(3N)
       The following manuals:
	      Remote Procedure Calls: Protocol Specification
	      Remote Procedure Call Programming Guide
	      rpcgen Programming Guide
       RPC:   Remote   Procedure   Call	 Protocol  Specification,
       RFC1050, Sun Microsystems, Inc., USC-ISI.

			 16 February 1988		       16

[top]

List of man pages available for BSDi

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net