--- /dev/null
+From 4285205401faeb12b4ed7ebbc4658af9eae73eb4 Mon Sep 17 00:00:00 2001
+From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+Date: Sat, 23 Jun 2012 21:57:39 +0200
+Subject: [PATCH] Disable parts of TIRPC requiring NIS support
+
+Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+---
+ src/Makefile.am | 3 +--
+ src/rpc_soc.c | 2 ++
+ tirpc/rpc/auth.h | 3 +++
+ 3 files changed, 6 insertions(+), 2 deletions(-)
+
+diff --git a/src/Makefile.am b/src/Makefile.am
+index 3029b78..b5db263 100644
+--- a/src/Makefile.am
++++ b/src/Makefile.am
+@@ -50,8 +50,7 @@ libtirpc_la_SOURCES = auth_none.c auth_unix.c authunix_prot.c bindresvport.c cln
+ pmap_prot.c pmap_prot2.c pmap_rmt.c rpc_prot.c rpc_commondata.c \
+ rpc_callmsg.c rpc_generic.c rpc_soc.c rpcb_clnt.c rpcb_prot.c \
+ rpcb_st_xdr.c svc.c svc_auth.c svc_dg.c svc_auth_unix.c svc_auth_none.c \
+- svc_generic.c svc_raw.c svc_run.c svc_simple.c svc_vc.c getpeereid.c \
+- auth_time.c auth_des.c authdes_prot.c
++ svc_generic.c svc_raw.c svc_run.c svc_simple.c svc_vc.c getpeereid.c
+
+ ## XDR
+ libtirpc_la_SOURCES += xdr.c xdr_rec.c xdr_array.c xdr_float.c xdr_mem.c xdr_reference.c xdr_stdio.c
+diff --git a/src/rpc_soc.c b/src/rpc_soc.c
+index 4213ca0..2603548 100644
+--- a/src/rpc_soc.c
++++ b/src/rpc_soc.c
+@@ -520,6 +520,7 @@ clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult)
+ (resultproc_t) rpc_wrap_bcast, "udp");
+ }
+
++#if 0
+ /*
+ * Create the client des authentication object. Obsoleted by
+ * authdes_seccreate().
+@@ -551,6 +552,7 @@ fallback:
+ dummy = authdes_seccreate(servername, window, NULL, ckey);
+ return (dummy);
+ }
++#endif
+
+ /*
+ * Create a client handle for a unix connection. Obsoleted by clnt_vc_create()
+diff --git a/tirpc/rpc/auth.h b/tirpc/rpc/auth.h
+index 4ce11f0..b894e44 100644
+--- a/tirpc/rpc/auth.h
++++ b/tirpc/rpc/auth.h
+@@ -305,6 +305,8 @@ extern AUTH *authunix_create(char *, uid_t, uid_t, int, uid_t *);
+ extern AUTH *authunix_create_default(void); /* takes no parameters */
+ extern AUTH *authnone_create(void); /* takes no parameters */
+ __END_DECLS
++
++#if 0
+ /*
+ * DES style authentication
+ * AUTH *authsecdes_create(servername, window, timehost, ckey)
+@@ -318,6 +320,7 @@ extern AUTH *authdes_create (char *, u_int, struct sockaddr *, des_block *);
+ extern AUTH *authdes_seccreate (const char *, const u_int, const char *,
+ const des_block *);
+ __END_DECLS
++#endif
+
+ __BEGIN_DECLS
+ extern bool_t xdr_opaque_auth (XDR *, struct opaque_auth *);
+--
+2.0.0
+
--- /dev/null
+From a20f33ad121fb1e9d1fbc31a0044546450677e7a Mon Sep 17 00:00:00 2001
+From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+Date: Sat, 23 Jun 2012 21:58:07 +0200
+Subject: [PATCH] uClibc without RPC support does not install rpcent.h
+
+Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+---
+ tirpc/rpc/rpcent.h | 5 +++--
+ 1 file changed, 3 insertions(+), 2 deletions(-)
+
+diff --git a/tirpc/rpc/rpcent.h b/tirpc/rpc/rpcent.h
+index c865e51..45775ed 100644
+--- a/tirpc/rpc/rpcent.h
++++ b/tirpc/rpc/rpcent.h
+@@ -46,8 +46,9 @@
+
+ __BEGIN_DECLS
+
+-/* These are defined in /usr/include/rpc/netdb.h */
+-#if 0
++/* These are defined in /usr/include/rpc/netdb.h, unless we are using
++ the C library without RPC support. */
++#if defined(__UCLIBC__) && !defined(__UCLIBC_HAS_RPC__)
+ struct rpcent {
+ char *r_name; /* name of server for this rpc program */
+ char **r_aliases; /* alias list */
+--
+2.0.0
+
--- /dev/null
+From fbe5fccf0e3bdaae3defc66a288176797fd12a17 Mon Sep 17 00:00:00 2001
+From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+Date: Sun, 24 Jun 2012 21:40:21 +0200
+Subject: [PATCH] Make IPv6 support optional
+
+Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+---
+ src/Makefile.am | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/src/Makefile.am b/src/Makefile.am
+index b5db263..f086255 100644
+--- a/src/Makefile.am
++++ b/src/Makefile.am
+@@ -7,7 +7,7 @@
+
+ noinst_HEADERS = rpc_com.h
+
+-AM_CPPFLAGS = -I$(top_srcdir)/tirpc -DPORTMAP -DINET6 \
++AM_CPPFLAGS = -I$(top_srcdir)/tirpc -DPORTMAP \
+ -D_GNU_SOURCE -Wall -pipe
+
+ lib_LTLIBRARIES = libtirpc.la
+--
+2.0.0
+
--- /dev/null
+From c4c4550dafabda05d78ca4aa9969db8a4f70affe Mon Sep 17 00:00:00 2001
+From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+Date: Sat, 10 Nov 2012 16:21:01 +0100
+Subject: [PATCH] Add rpcgen program from nfs-utils sources
+
+Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+---
+ Makefile.am | 2 +-
+ configure.ac | 14 +-
+ rpcgen/Makefile.am | 22 ++
+ rpcgen/rpc_clntout.c | 217 ++++++++++
+ rpcgen/rpc_cout.c | 706 +++++++++++++++++++++++++++++++++
+ rpcgen/rpc_hout.c | 490 +++++++++++++++++++++++
+ rpcgen/rpc_main.c | 1067 ++++++++++++++++++++++++++++++++++++++++++++++++++
+ rpcgen/rpc_output.h | 16 +
+ rpcgen/rpc_parse.c | 609 ++++++++++++++++++++++++++++
+ rpcgen/rpc_parse.h | 166 ++++++++
+ rpcgen/rpc_sample.c | 247 ++++++++++++
+ rpcgen/rpc_scan.c | 474 ++++++++++++++++++++++
+ rpcgen/rpc_scan.h | 103 +++++
+ rpcgen/rpc_svcout.c | 882 +++++++++++++++++++++++++++++++++++++++++
+ rpcgen/rpc_tblout.c | 165 ++++++++
+ rpcgen/rpc_util.c | 479 ++++++++++++++++++++++
+ rpcgen/rpc_util.h | 166 ++++++++
+ rpcgen/rpcgen.1 | 521 ++++++++++++++++++++++++
+ 18 files changed, 6344 insertions(+), 2 deletions(-)
+ create mode 100644 rpcgen/Makefile.am
+ create mode 100644 rpcgen/rpc_clntout.c
+ create mode 100644 rpcgen/rpc_cout.c
+ create mode 100644 rpcgen/rpc_hout.c
+ create mode 100644 rpcgen/rpc_main.c
+ create mode 100644 rpcgen/rpc_output.h
+ create mode 100644 rpcgen/rpc_parse.c
+ create mode 100644 rpcgen/rpc_parse.h
+ create mode 100644 rpcgen/rpc_sample.c
+ create mode 100644 rpcgen/rpc_scan.c
+ create mode 100644 rpcgen/rpc_scan.h
+ create mode 100644 rpcgen/rpc_svcout.c
+ create mode 100644 rpcgen/rpc_tblout.c
+ create mode 100644 rpcgen/rpc_util.c
+ create mode 100644 rpcgen/rpc_util.h
+ create mode 100644 rpcgen/rpcgen.1
+
+diff --git a/Makefile.am b/Makefile.am
+index 9b812eb..6edf029 100644
+--- a/Makefile.am
++++ b/Makefile.am
+@@ -1,4 +1,4 @@
+-SUBDIRS = src man doc
++SUBDIRS = src man doc rpcgen
+ ACLOCAL_AMFLAGS = -I m4
+
+ noinst_HEADERS = tirpc/reentrant.h \
+diff --git a/configure.ac b/configure.ac
+index 11df020..4110225 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -34,5 +34,17 @@ AC_CHECK_LIB([pthread], [pthread_create])
+ AC_CHECK_LIB([nsl], [yp_get_default_domain])
+
+
+-AC_CONFIG_FILES([Makefile src/Makefile man/Makefile doc/Makefile])
++AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
++
++AC_MSG_CHECKING([for a C compiler for build tools])
++if test $cross_compiling = yes; then
++ AC_CHECK_PROGS(CC_FOR_BUILD, gcc cc)
++else
++ CC_FOR_BUILD=$CC
++fi
++AC_MSG_RESULT([$CC_FOR_BUILD])
++AC_SUBST(CC_FOR_BUILD)
++
++AC_CONFIG_FILES([Makefile src/Makefile man/Makefile doc/Makefile rpcgen/Makefile])
++
+ AC_OUTPUT(libtirpc.pc)
+diff --git a/rpcgen/Makefile.am b/rpcgen/Makefile.am
+new file mode 100644
+index 0000000..2277b6f
+--- /dev/null
++++ b/rpcgen/Makefile.am
+@@ -0,0 +1,22 @@
++COMPILE = $(CC_FOR_BUILD) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
++ $(CPPFLAGS_FOR_BUILD) $(AM_CFLAGS) $(CFLAGS_FOR_BUILD)
++LINK = $(CC_FOR_BUILD) $(AM_CFLAGS) $(CFLAGS_FOR_BUILD) $(AM_LDFLAGS) $(LDFLAGS_FOR_BUILD) -o $@
++
++bin_PROGRAMS = rpcgen
++
++rpcgen_SOURCES = \
++ rpc_clntout.c \
++ rpc_cout.c \
++ rpc_hout.c \
++ rpc_main.c \
++ rpc_parse.c \
++ rpc_sample.c \
++ rpc_scan.c \
++ rpc_svcout.c \
++ rpc_tblout.c \
++ rpc_util.c \
++ rpc_parse.h \
++ rpc_scan.h \
++ rpc_util.h
++
++dist_man1_MANS = rpcgen.1
+diff --git a/rpcgen/rpc_clntout.c b/rpcgen/rpc_clntout.c
+new file mode 100644
+index 0000000..e2f4382
+--- /dev/null
++++ b/rpcgen/rpc_clntout.c
+@@ -0,0 +1,217 @@
++/*
++ * Copyright (c) 2009, Sun Microsystems, Inc.
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are met:
++ * - Redistributions of source code must retain the above copyright notice,
++ * this list of conditions and the following disclaimer.
++ * - Redistributions in binary form must reproduce the above copyright notice,
++ * this list of conditions and the following disclaimer in the documentation
++ * and/or other materials provided with the distribution.
++ * - Neither the name of Sun Microsystems, Inc. nor the names of its
++ * contributors may be used to endorse or promote products derived
++ * from this software without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++
++#if 0
++static char sccsid[] = "@(#)rpc_clntout.c 1.11 89/02/22 (C) 1987 SMI";
++#endif
++
++/*
++ * rpc_clntout.c, Client-stub outputter for the RPC protocol compiler
++ * Copyright (C) 1987, Sun Microsytsems, Inc.
++ */
++#include <stdio.h>
++#include <string.h>
++#include <rpc/types.h>
++#include "rpc_parse.h"
++#include "rpc_util.h"
++#include "rpc_output.h"
++
++/* extern pdeclaration(); */
++/* void printarglist(); */
++
++#define DEFAULT_TIMEOUT 25 /* in seconds */
++static char RESULT[] = "clnt_res";
++
++static void write_program(definition *def);
++static void printbody(proc_list *proc);
++
++
++void
++write_stubs(void)
++{
++ list *l;
++ definition *def;
++
++ f_print(fout,
++ "\n/* Default timeout can be changed using clnt_control() */\n");
++ f_print(fout, "static struct timeval TIMEOUT = { %d, 0 };\n",
++ DEFAULT_TIMEOUT);
++ for (l = defined; l != NULL; l = l->next) {
++ def = (definition *) l->val;
++ if (def->def_kind == DEF_PROGRAM) {
++ write_program(def);
++ }
++ }
++}
++
++static void
++write_program(definition *def)
++{
++ version_list *vp;
++ proc_list *proc;
++
++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
++ for (proc = vp->procs; proc != NULL; proc = proc->next) {
++ f_print(fout, "\n");
++ ptype(proc->res_prefix, proc->res_type, 1);
++ f_print(fout, "*\n");
++ pvname(proc->proc_name, vp->vers_num);
++ printarglist(proc, "clnt", "CLIENT *");
++ f_print(fout, "{\n");
++ printbody(proc);
++ f_print(fout, "}\n");
++ }
++ }
++}
++
++/*
++ * Writes out declarations of procedure's argument list.
++ * In either ANSI C style, in one of old rpcgen style (pass by reference),
++ * or new rpcgen style (multiple arguments, pass by value);
++ */
++
++/* sample addargname = "clnt"; sample addargtype = "CLIENT * " */
++
++void
++printarglist(proc_list *proc, char *addargname, char *addargtype)
++{
++
++ decl_list *l;
++
++ if (!newstyle) { /* old style: always pass arg by reference */
++ if (Cflag) { /* C++ style heading */
++ f_print(fout, "(");
++ ptype(proc->args.decls->decl.prefix, proc->args.decls->decl.type, 1);
++ f_print(fout, "*argp, %s%s)\n", addargtype, addargname);
++ } else {
++ f_print(fout, "(argp, %s)\n", addargname);
++ f_print(fout, "\t");
++ ptype(proc->args.decls->decl.prefix, proc->args.decls->decl.type, 1);
++ f_print(fout, "*argp;\n");
++ }
++ } else if (streq(proc->args.decls->decl.type, "void")) {
++ /* newstyle, 0 argument */
++ if (Cflag)
++ f_print(fout, "(%s%s)\n", addargtype, addargname);
++ else
++ f_print(fout, "(%s)\n", addargname);
++ } else {
++ /* new style, 1 or multiple arguments */
++ if (!Cflag) {
++ f_print(fout, "(");
++ for (l = proc->args.decls; l != NULL; l = l->next)
++ f_print(fout, "%s, ", l->decl.name);
++ f_print(fout, "%s)\n", addargname);
++ for (l = proc->args.decls; l != NULL; l = l->next) {
++ pdeclaration(proc->args.argname, &l->decl, 1, ";\n");
++ }
++ } else { /* C++ style header */
++ f_print(fout, "(");
++ for (l = proc->args.decls; l != NULL; l = l->next) {
++ pdeclaration(proc->args.argname, &l->decl, 0, ", ");
++ }
++ f_print(fout, " %s%s)\n", addargtype, addargname);
++ }
++ }
++
++ if (!Cflag)
++ f_print(fout, "\t%s%s;\n", addargtype, addargname);
++}
++
++
++
++static char *
++ampr(char *type)
++{
++ if (isvectordef(type, REL_ALIAS)) {
++ return ("");
++ } else {
++ return ("&");
++ }
++}
++
++static void
++printbody(proc_list *proc)
++{
++ decl_list *l;
++ bool_t args2 = (proc->arg_num > 1);
++
++ /* For new style with multiple arguments, need a structure in which
++ * to stuff the arguments. */
++ if (newstyle && args2) {
++ f_print(fout, "\t%s", proc->args.argname);
++ f_print(fout, " arg;\n");
++ }
++ f_print(fout, "\tstatic ");
++ if (streq(proc->res_type, "void")) {
++ f_print(fout, "char ");
++ } else {
++ ptype(proc->res_prefix, proc->res_type, 0);
++ }
++ f_print(fout, "%s;\n", RESULT);
++ f_print(fout, "\n");
++ f_print(fout, "\tmemset((char *)%s%s, 0, sizeof(%s));\n",
++ ampr(proc->res_type), RESULT, RESULT);
++ if (newstyle && !args2 && (streq(proc->args.decls->decl.type, "void"))) {
++ /* newstyle, 0 arguments */
++ f_print(fout,
++ "\tif (clnt_call(clnt, %s, (xdrproc_t) xdr_void, (caddr_t) NULL, "
++ "(xdrproc_t) xdr_%s, (caddr_t) %s%s, TIMEOUT) != RPC_SUCCESS) {\n",
++ proc->proc_name,
++ stringfix(proc->res_type), ampr(proc->res_type), RESULT);
++
++ } else if (newstyle && args2) {
++ /* newstyle, multiple arguments: stuff arguments into structure */
++ for (l = proc->args.decls; l != NULL; l = l->next) {
++ f_print(fout, "\targ.%s = %s;\n",
++ l->decl.name, l->decl.name);
++ }
++ f_print(fout,
++ "\tif (clnt_call(clnt, %s, (xdrproc_t) xdr_%s, (caddr_t) &arg, "
++ "(xdrproc_t) xdr_%s, (caddr_t) %s%s, TIMEOUT) != RPC_SUCCESS) {\n",
++ proc->proc_name, proc->args.argname,
++ stringfix(proc->res_type), ampr(proc->res_type), RESULT);
++ } else { /* single argument, new or old style */
++ f_print(fout,
++ "\tif (clnt_call(clnt, %s, (xdrproc_t) xdr_%s, "
++ "(caddr_t) %s%s, (xdrproc_t) xdr_%s, (caddr_t) %s%s, TIMEOUT) != RPC_SUCCESS) {\n",
++ proc->proc_name,
++ stringfix(proc->args.decls->decl.type),
++ (newstyle ? "&" : ""),
++ (newstyle ? proc->args.decls->decl.name : "argp"),
++ stringfix(proc->res_type), ampr(proc->res_type), RESULT);
++ }
++ f_print(fout, "\t\treturn (NULL);\n");
++ f_print(fout, "\t}\n");
++ if (streq(proc->res_type, "void")) {
++ f_print(fout, "\treturn ((void *)%s%s);\n",
++ ampr(proc->res_type), RESULT);
++ } else {
++ f_print(fout, "\treturn (%s%s);\n", ampr(proc->res_type), RESULT);
++ }
++}
+diff --git a/rpcgen/rpc_cout.c b/rpcgen/rpc_cout.c
+new file mode 100644
+index 0000000..a61214f
+--- /dev/null
++++ b/rpcgen/rpc_cout.c
+@@ -0,0 +1,706 @@
++/*
++ * Copyright (c) 2009, Sun Microsystems, Inc.
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are met:
++ * - Redistributions of source code must retain the above copyright notice,
++ * this list of conditions and the following disclaimer.
++ * - Redistributions in binary form must reproduce the above copyright notice,
++ * this list of conditions and the following disclaimer in the documentation
++ * and/or other materials provided with the distribution.
++ * - Neither the name of Sun Microsystems, Inc. nor the names of its
++ * contributors may be used to endorse or promote products derived
++ * from this software without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++
++#if 0
++static char sccsid[] = "@(#)rpc_cout.c 1.13 89/02/22 (C) 1987 SMI";
++#endif
++
++/*
++ * rpc_cout.c, XDR routine outputter for the RPC protocol compiler
++ */
++#include <stdio.h>
++#include <string.h>
++#include <stdlib.h>
++#include <malloc.h>
++#include <ctype.h>
++#include "rpc_parse.h"
++#include "rpc_util.h"
++
++static int findtype(definition *def, char *type);
++static int undefined(char *type);
++static void print_generic_header(char *procname, int pointerp);
++static void print_header(definition *def);
++static void print_prog_header(proc_list *plist);
++static void print_trailer(void);
++static void print_ifopen(int indent, char *name);
++static void print_ifarg(char *arg);
++static void print_ifsizeof(char *prefix, char *type);
++static void print_ifclose(int indent);
++static void print_ifstat(int indent, char *prefix, char *type, relation rel,
++ char *amax, char *objname, char *name);
++static void emit_enum(definition *def);
++static void emit_program(definition *def);
++static void emit_union(definition *def);
++static void emit_struct(definition *def);
++static void emit_typedef(definition *def);
++static void print_stat(int indent, declaration *dec);
++static void emit_inline(declaration *decl, int flag);
++static void emit_single_in_line(declaration *decl, int flag, relation rel);
++static char * upcase(char *str);
++
++/*
++ * Emit the C-routine for the given definition
++ */
++void
++emit(definition *def)
++{
++ if (def->def_kind == DEF_CONST) {
++ return;
++ }
++ if (def->def_kind == DEF_PROGRAM) {
++ emit_program(def);
++ return;
++ }
++ if (def->def_kind == DEF_TYPEDEF) {
++ /* now we need to handle declarations like
++ * struct typedef foo foo;
++ * since we dont want this to be expanded into 2 calls
++ * to xdr_foo */
++
++ if (strcmp(def->def.ty.old_type, def->def_name) == 0)
++ return;
++ };
++
++ print_header(def);
++ switch (def->def_kind) {
++ case DEF_UNION:
++ emit_union(def);
++ break;
++ case DEF_ENUM:
++ emit_enum(def);
++ break;
++ case DEF_STRUCT:
++ emit_struct(def);
++ break;
++ case DEF_TYPEDEF:
++ emit_typedef(def);
++ break;
++ default:
++ break;
++ }
++ print_trailer();
++}
++
++static int
++findtype(definition *def, char *type)
++{
++
++ if (def->def_kind == DEF_PROGRAM || def->def_kind == DEF_CONST) {
++ return (0);
++ } else {
++ return (streq(def->def_name, type));
++ }
++}
++
++static int
++undefined(char *type)
++{
++ definition *def;
++
++ def = (definition *) FINDVAL(defined, type, findtype);
++
++ return (def == NULL);
++}
++
++
++static void
++print_generic_header(char *procname, int pointerp)
++{
++ f_print(fout, "\n");
++ f_print(fout, "bool_t\n");
++ if (Cflag) {
++ f_print(fout, "xdr_%s(", procname);
++ f_print(fout, "XDR *xdrs, ");
++ f_print(fout, "%s ", procname);
++ if (pointerp)
++ f_print(fout, "*");
++ f_print(fout, "objp)\n{\n\n");
++ } else {
++ f_print(fout, "xdr_%s(xdrs, objp)\n", procname);
++ f_print(fout, "\tXDR *xdrs;\n");
++ f_print(fout, "\t%s ", procname);
++ if (pointerp)
++ f_print(fout, "*");
++ f_print(fout, "objp;\n{\n\n");
++ }
++}
++
++static void
++print_header(definition *def)
++{
++ print_generic_header(def->def_name,
++ def->def_kind != DEF_TYPEDEF ||
++ !isvectordef(def->def.ty.old_type, def->def.ty.rel));
++
++ /* Now add Inline support */
++
++
++ if (Inline == 0)
++ return;
++}
++
++static void
++print_prog_header(proc_list *plist)
++{
++ print_generic_header(plist->args.argname, 1);
++}
++
++static void
++print_trailer(void)
++{
++ f_print(fout, "\treturn (TRUE);\n");
++ f_print(fout, "}\n");
++}
++
++
++static void
++print_ifopen(int indent, char *name)
++{
++ tabify(fout, indent);
++ f_print(fout, " if (!xdr_%s(xdrs", name);
++}
++
++static void
++print_ifarg(char *arg)
++{
++ f_print(fout, ", %s", arg);
++}
++
++static void
++print_ifsizeof(char *prefix, char *type)
++{
++ if (streq(type, "bool")) {
++ f_print(fout, ", sizeof(bool_t), (xdrproc_t)xdr_bool");
++ } else {
++ f_print(fout, ", sizeof(");
++ if (undefined(type) && prefix) {
++ f_print(fout, "%s ", prefix);
++ }
++ f_print(fout, "%s), (xdrproc_t)xdr_%s", type, type);
++ }
++}
++
++static void
++print_ifclose(int indent)
++{
++ f_print(fout, ")) {\n");
++ tabify(fout, indent);
++ f_print(fout, "\t return (FALSE);\n");
++ tabify(fout, indent);
++ f_print(fout, " }\n");
++}
++
++static void
++print_ifstat(int indent, char *prefix, char *type, relation rel,
++ char *amax, char *objname, char *name)
++{
++ char *alt = NULL;
++
++ switch (rel) {
++ case REL_POINTER:
++ print_ifopen(indent, "pointer");
++ print_ifarg("(char **)");
++ f_print(fout, "%s", objname);
++ print_ifsizeof(prefix, type);
++ break;
++ case REL_VECTOR:
++ if (streq(type, "string")) {
++ alt = "string";
++ } else if (streq(type, "opaque")) {
++ alt = "opaque";
++ }
++ if (alt) {
++ print_ifopen(indent, alt);
++ print_ifarg(objname);
++ } else {
++ print_ifopen(indent, "vector");
++ print_ifarg("(char *)");
++ f_print(fout, "%s", objname);
++ }
++ print_ifarg(amax);
++ if (!alt) {
++ print_ifsizeof(prefix, type);
++ }
++ break;
++ case REL_ARRAY:
++ if (streq(type, "string")) {
++ alt = "string";
++ } else if (streq(type, "opaque")) {
++ alt = "bytes";
++ }
++ if (streq(type, "string")) {
++ print_ifopen(indent, alt);
++ print_ifarg(objname);
++ } else {
++ if (alt) {
++ print_ifopen(indent, alt);
++ } else {
++ print_ifopen(indent, "array");
++ }
++ /* The (void*) avoids a gcc-4.1 warning */
++ print_ifarg("(char **)(void*)");
++ if (*objname == '&') {
++ f_print(fout, "%s.%s_val, (u_int *)%s.%s_len",
++ objname, name, objname, name);
++ } else {
++ f_print(fout, "&%s->%s_val, (u_int *)&%s->%s_len",
++ objname, name, objname, name);
++ }
++ }
++ print_ifarg(amax);
++ if (!alt) {
++ print_ifsizeof(prefix, type);
++ }
++ break;
++ case REL_ALIAS:
++ print_ifopen(indent, type);
++ print_ifarg(objname);
++ break;
++ }
++ print_ifclose(indent);
++}
++
++static void
++emit_enum(definition *def)
++{
++ print_ifopen(1, "enum");
++ print_ifarg("(enum_t *)objp");
++ print_ifclose(1);
++}
++
++static void
++emit_program(definition *def)
++{
++ decl_list *dl;
++ version_list *vlist;
++ proc_list *plist;
++
++ for (vlist = def->def.pr.versions; vlist != NULL; vlist = vlist->next)
++ for (plist = vlist->procs; plist != NULL; plist = plist->next) {
++ if (!newstyle || plist->arg_num < 2)
++ continue;/* old style, or single argument */
++ print_prog_header(plist);
++ for (dl = plist->args.decls; dl != NULL; dl = dl->next)
++ print_stat(1, &dl->decl);
++ print_trailer();
++ }
++}
++
++
++static void
++emit_union(definition *def)
++{
++ declaration *dflt;
++ case_list *cl;
++ declaration *cs;
++ char *object;
++ char *vecformat = "objp->%s_u.%s";
++ char *format = "&objp->%s_u.%s";
++
++ print_stat(1,&def->def.un.enum_decl);
++ f_print(fout, "\tswitch (objp->%s) {\n", def->def.un.enum_decl.name);
++ for (cl = def->def.un.cases; cl != NULL; cl = cl->next) {
++
++ f_print(fout, "\tcase %s:\n", cl->case_name);
++ if(cl->contflag == 1) /* a continued case statement */
++ continue;
++ cs = &cl->case_decl;
++ if (!streq(cs->type, "void")) {
++ object = alloc(strlen(def->def_name) + strlen(format) +
++ strlen(cs->name) + 1);
++ if (isvectordef (cs->type, cs->rel)) {
++ s_print(object, vecformat, def->def_name,
++ cs->name);
++ } else {
++ s_print(object, format, def->def_name,
++ cs->name);
++ }
++ print_ifstat(2, cs->prefix, cs->type, cs->rel, cs->array_max,
++ object, cs->name);
++ free(object);
++ }
++ f_print(fout, "\t\tbreak;\n");
++ }
++ dflt = def->def.un.default_decl;
++ if (dflt != NULL) {
++ if (!streq(dflt->type, "void")) {
++ f_print(fout, "\tdefault:\n");
++ object = alloc(strlen(def->def_name) + strlen(format) +
++ strlen(dflt->name) + 1);
++ if (isvectordef (dflt->type, dflt->rel)) {
++ s_print(object, vecformat, def->def_name,
++ dflt->name);
++ } else {
++ s_print(object, format, def->def_name,
++ dflt->name);
++ }
++
++ print_ifstat(2, dflt->prefix, dflt->type, dflt->rel,
++ dflt->array_max, object, dflt->name);
++ free(object);
++ f_print(fout, "\t\tbreak;\n");
++ } else {
++ /* Avoid gcc warnings about `value not handled in switch' */
++ f_print(fout, "\tdefault:\n");
++ f_print(fout, "\t\tbreak;\n");
++ }
++ } else {
++ f_print(fout, "\tdefault:\n");
++ f_print(fout, "\t\treturn (FALSE);\n");
++ }
++
++ f_print(fout, "\t}\n");
++}
++
++static void
++emit_struct(definition *def)
++{
++ decl_list *dl;
++ int i, j, size, flag;
++ decl_list *cur = NULL, *psav;
++ bas_type *ptr;
++ char *sizestr, *plus;
++ char ptemp[256];
++ int can_inline;
++ const char *buf_declaration;
++
++
++ if (Inline == 0) {
++ for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
++ print_stat(1, &dl->decl);
++ } else {
++ size = 0;
++ can_inline = 0;
++ for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
++ if ((dl->decl.prefix == NULL) && ((ptr = find_type(dl->decl.type)) != NULL) && ((dl->decl.rel == REL_ALIAS) || (dl->decl.rel == REL_VECTOR))) {
++
++ if (dl->decl.rel == REL_ALIAS)
++ size += ptr->length;
++ else {
++ can_inline = 1;
++ break; /* can be inlined */
++ };
++ } else {
++ if (size >= Inline) {
++ can_inline = 1;
++ break; /* can be inlined */
++ }
++ size = 0;
++ }
++ if (size > Inline)
++ can_inline = 1;
++
++ if (can_inline == 0) { /* can not inline, drop back to old mode */
++ for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
++ print_stat(1, &dl->decl);
++ return;
++ };
++
++
++
++
++ flag = PUT;
++ for (j = 0; j < 2; j++) {
++
++ if (flag == PUT)
++ f_print(fout, "\n\t if (xdrs->x_op == XDR_ENCODE) {\n");
++ else
++ f_print(fout, "\n \t return (TRUE);\n\t} else if (xdrs->x_op == XDR_DECODE) {\n");
++
++
++ i = 0;
++ size = 0;
++ sizestr = NULL;
++ buf_declaration = "int32_t *";
++ for (dl = def->def.st.decls; dl != NULL; dl = dl->next) { /* xxx */
++
++ /* now walk down the list and check for basic types */
++ if ((dl->decl.prefix == NULL) && ((ptr = find_type(dl->decl.type)) != NULL) && ((dl->decl.rel == REL_ALIAS) || (dl->decl.rel == REL_VECTOR))) {
++ if (i == 0)
++ cur = dl;
++ i++;
++
++ if (dl->decl.rel == REL_ALIAS)
++ size += ptr->length;
++ else {
++ /* this is required to handle arrays */
++
++ if (sizestr == NULL)
++ plus = " ";
++ else
++ plus = "+";
++
++ if (ptr->length != 1)
++ s_print(ptemp, " %s %s * %d", plus, dl->decl.array_max, ptr->length);
++ else
++ s_print(ptemp, " %s %s ", plus, dl->decl.array_max);
++
++ /*now concatenate to sizestr !!!! */
++ if (sizestr == NULL)
++ sizestr = strdup(ptemp);
++ else {
++ sizestr = realloc(sizestr, strlen(sizestr) + strlen(ptemp) + 1);
++ if (sizestr == NULL) {
++
++ f_print(stderr, "Fatal error : no memory \n");
++ crash();
++ };
++ sizestr = strcat(sizestr, ptemp); /*build up length of array */
++
++ }
++ }
++
++ } else {
++ if (i > 0)
++ {
++ if (sizestr == NULL && size < Inline) {
++ /* don't expand into inline code if size < inline */
++ while (cur != dl) {
++ print_stat(1, &cur->decl);
++ cur = cur->next;
++ }
++ } else {
++
++
++
++ /* were already looking at a xdr_inlineable structure */
++ if (sizestr == NULL)
++ f_print(fout, "\t %sbuf = XDR_INLINE(xdrs,%d * BYTES_PER_XDR_UNIT);",
++ buf_declaration, size);
++ else if (size == 0)
++ f_print(fout,
++ "\t %sbuf = XDR_INLINE(xdrs,%s * BYTES_PER_XDR_UNIT);",
++ buf_declaration, sizestr);
++ else
++ f_print(fout,
++ "\t %sbuf = XDR_INLINE(xdrs,(%d + %s)* BYTES_PER_XDR_UNIT);",
++ buf_declaration, size, sizestr);
++ buf_declaration = "";
++
++ f_print(fout, "\n\t if (buf == NULL) {\n");
++
++ psav = cur;
++ while (cur != dl) {
++ print_stat(2, &cur->decl);
++ cur = cur->next;
++ }
++
++ f_print(fout, "\n\t }\n\t else {\n");
++
++ cur = psav;
++ while (cur != dl) {
++ emit_inline(&cur->decl, flag);
++ cur = cur->next;
++ }
++
++ f_print(fout, "\t }\n");
++ }
++ }
++ size = 0;
++ i = 0;
++ sizestr = NULL;
++ print_stat(1, &dl->decl);
++ }
++
++ }
++ if (i > 0)
++ {
++ if (sizestr == NULL && size < Inline) {
++ /* don't expand into inline code if size < inline */
++ while (cur != dl) {
++ print_stat(1, &cur->decl);
++ cur = cur->next;
++ }
++ } else {
++
++ /* were already looking at a xdr_inlineable structure */
++ if (sizestr == NULL)
++ f_print(fout, "\t\t%sbuf = XDR_INLINE(xdrs,%d * BYTES_PER_XDR_UNIT);",
++ buf_declaration, size);
++ else if (size == 0)
++ f_print(fout,
++ "\t\t%sbuf = XDR_INLINE(xdrs,%s * BYTES_PER_XDR_UNIT);",
++ buf_declaration, sizestr);
++ else
++ f_print(fout,
++ "\t\t%sbuf = XDR_INLINE(xdrs,(%d + %s)* BYTES_PER_XDR_UNIT);",
++ buf_declaration, size, sizestr);
++ buf_declaration = "";
++
++ f_print(fout, "\n\t\tif (buf == NULL) {\n");
++
++ psav = cur;
++ while (cur != NULL) {
++ print_stat(2, &cur->decl);
++ cur = cur->next;
++ }
++ f_print(fout, "\n\t }\n\t else {\n");
++
++ cur = psav;
++ while (cur != dl) {
++ emit_inline(&cur->decl, flag);
++ cur = cur->next;
++ }
++
++ f_print(fout, "\t }\n");
++
++ }
++ }
++ flag = GET;
++ }
++ f_print(fout, "\t return(TRUE);\n\t}\n\n");
++
++ /* now take care of XDR_FREE case */
++
++ for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
++ print_stat(1, &dl->decl);
++ }
++}
++
++
++
++
++static void
++emit_typedef(definition *def)
++{
++ char *prefix = def->def.ty.old_prefix;
++ char *type = def->def.ty.old_type;
++ char *amax = def->def.ty.array_max;
++ relation rel = def->def.ty.rel;
++
++
++ print_ifstat(1, prefix, type, rel, amax, "objp", def->def_name);
++}
++
++static void
++print_stat(int indent, declaration *dec)
++{
++ char *prefix = dec->prefix;
++ char *type = dec->type;
++ char *amax = dec->array_max;
++ relation rel = dec->rel;
++ char name[256];
++
++ if (isvectordef(type, rel)) {
++ s_print(name, "objp->%s", dec->name);
++ } else {
++ s_print(name, "&objp->%s", dec->name);
++ }
++ print_ifstat(indent, prefix, type, rel, amax, name, dec->name);
++}
++
++
++static void
++emit_inline(declaration *decl, int flag)
++{
++
++ /*check whether an array or not */
++
++ switch (decl->rel) {
++ case REL_ALIAS:
++ emit_single_in_line(decl, flag, REL_ALIAS);
++ break;
++ case REL_VECTOR:
++ f_print(fout, "\t\t{ register %s *genp; \n", decl->type);
++ f_print(fout, "\t\t int i;\n");
++ f_print(fout, "\t\t for ( i = 0,genp=objp->%s;\n \t\t\ti < %s; i++){\n\t\t",
++ decl->name, decl->array_max);
++ emit_single_in_line(decl, flag, REL_VECTOR);
++ f_print(fout, "\t\t }\n\t\t };\n");
++ break;
++ default:
++ break;
++ }
++}
++
++static void
++emit_single_in_line(declaration *decl, int flag, relation rel)
++{
++ char *upp_case;
++ int freed=0;
++
++ if(flag == PUT)
++ f_print(fout,"\t\t (void) IXDR_PUT_");
++ else
++ if(rel== REL_ALIAS)
++ f_print(fout,"\t\t objp->%s = IXDR_GET_",decl->name);
++ else
++ f_print(fout,"\t\t *genp++ = IXDR_GET_");
++
++ upp_case=upcase(decl->type);
++
++ /* hack - XX */
++ if(strcmp(upp_case,"INT") == 0)
++ {
++ free(upp_case);
++ freed=1;
++ upp_case="INT32";
++ }
++
++ if(strcmp(upp_case,"U_INT") == 0)
++ {
++ free(upp_case);
++ freed=1;
++ upp_case="U_INT32";
++ }
++
++
++ if(flag == PUT)
++ if(rel== REL_ALIAS)
++ f_print(fout,"%s(buf,objp->%s);\n",upp_case,decl->name);
++ else
++ f_print(fout,"%s(buf,*genp++);\n",upp_case);
++
++ else
++ f_print(fout,"%s(buf);\n",upp_case);
++ if(!freed)
++ free(upp_case);
++
++}
++
++
++static char *
++upcase(char *str)
++{
++ char *ptr, *hptr;
++
++
++ ptr = (char *) malloc(strlen(str)+1);
++ if (ptr == (char *) NULL) {
++ f_print(stderr, "malloc failed \n");
++ exit(1);
++ };
++
++ hptr = ptr;
++ while (*str != '\0')
++ *ptr++ = toupper(*str++);
++
++ *ptr = '\0';
++ return (hptr);
++
++}
+diff --git a/rpcgen/rpc_hout.c b/rpcgen/rpc_hout.c
+new file mode 100644
+index 0000000..ea1cb24
+--- /dev/null
++++ b/rpcgen/rpc_hout.c
+@@ -0,0 +1,490 @@
++/*
++ * Copyright (c) 2009, Sun Microsystems, Inc.
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are met:
++ * - Redistributions of source code must retain the above copyright notice,
++ * this list of conditions and the following disclaimer.
++ * - Redistributions in binary form must reproduce the above copyright notice,
++ * this list of conditions and the following disclaimer in the documentation
++ * and/or other materials provided with the distribution.
++ * - Neither the name of Sun Microsystems, Inc. nor the names of its
++ * contributors may be used to endorse or promote products derived
++ * from this software without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++
++#if 0
++static char sccsid[] = "@(#)rpc_hout.c 1.12 89/02/22 (C) 1987 SMI";
++#endif
++
++/*
++ * rpc_hout.c, Header file outputter for the RPC protocol compiler
++ */
++#include <stdio.h>
++#include <ctype.h>
++#include "rpc_parse.h"
++#include "rpc_util.h"
++#include "rpc_output.h"
++
++
++static int undefined2(char *type, char *stop);
++static void pxdrfuncdecl(char *name, int pointerp);
++static void pconstdef(definition *def);
++static void pargdef(definition *def);
++static void pstructdef(definition *def);
++static void puniondef(definition *def);
++static void pdefine(char *name, char *num);
++static void puldefine(char *name, char *num);
++static int define_printed(proc_list *stop, version_list *start);
++static void pprogramdef(definition *def);
++static void pprocdef(proc_list *proc, version_list *vp,
++ char *addargtype, int server_p, int mode);
++static void parglist(proc_list *proc, char *addargtype);
++static void penumdef(definition *def);
++static void ptypedef(definition *def);
++
++/*
++ * Print the C-version of an xdr definition
++ */
++void
++print_datadef(definition *def)
++{
++
++ if (def->def_kind == DEF_PROGRAM ) /* handle data only */
++ return;
++
++ if (def->def_kind != DEF_CONST) {
++ f_print(fout, "\n");
++ }
++ switch (def->def_kind) {
++ case DEF_STRUCT:
++ pstructdef(def);
++ break;
++ case DEF_UNION:
++ puniondef(def);
++ break;
++ case DEF_ENUM:
++ penumdef(def);
++ break;
++ case DEF_TYPEDEF:
++ ptypedef(def);
++ break;
++ case DEF_PROGRAM:
++ pprogramdef(def);
++ break;
++ case DEF_CONST:
++ pconstdef(def);
++ break;
++ }
++ if (def->def_kind != DEF_PROGRAM && def->def_kind != DEF_CONST) {
++ pxdrfuncdecl( def->def_name,
++ def->def_kind != DEF_TYPEDEF ||
++ !isvectordef(def->def.ty.old_type, def->def.ty.rel));
++
++ }
++}
++
++
++void
++print_funcdef(definition *def)
++{
++ switch (def->def_kind) {
++ case DEF_PROGRAM:
++ f_print(fout, "\n");
++ pprogramdef(def);
++ break;
++ default:
++ break;
++ }
++}
++
++static void
++pxdrfuncdecl(char *name, int pointerp)
++{
++ f_print(fout,
++ "#ifdef __cplusplus \n"
++ "extern \"C\" bool_t xdr_%s(XDR *, %s%s);\n"
++ "#elif __STDC__ \n"
++ "extern bool_t xdr_%s(XDR *, %s%s);\n"
++ "#else /* Old Style C */ \n"
++ "bool_t xdr_%s();\n"
++ "#endif /* Old Style C */ \n\n",
++ name, name, pointerp ? "*" : "",
++ name, name, pointerp ? "*" : "",
++ name);
++}
++
++
++static void
++pconstdef(definition *def)
++{
++ pdefine(def->def_name, def->def.co);
++}
++
++/* print out the definitions for the arguments of functions in the
++ header file
++*/
++static void
++pargdef(definition *def)
++{
++ decl_list *l;
++ version_list *vers;
++ char *name;
++ proc_list *plist;
++
++
++ for (vers = def->def.pr.versions; vers != NULL; vers = vers->next) {
++ for(plist = vers->procs; plist != NULL;
++ plist = plist->next) {
++
++ if (!newstyle || plist->arg_num < 2) {
++ continue; /* old style or single args */
++ }
++ name = plist->args.argname;
++ f_print(fout, "struct %s {\n", name);
++ for (l = plist->args.decls;
++ l != NULL; l = l->next) {
++ pdeclaration(name, &l->decl, 1, ";\n" );
++ }
++ f_print(fout, "};\n");
++ f_print(fout, "typedef struct %s %s;\n", name, name);
++ pxdrfuncdecl(name, 0);
++ f_print( fout, "\n" );
++ }
++ }
++
++}
++
++
++static void
++pstructdef(definition *def)
++{
++ decl_list *l;
++ char *name = def->def_name;
++
++ f_print(fout, "struct %s {\n", name);
++ for (l = def->def.st.decls; l != NULL; l = l->next) {
++ pdeclaration(name, &l->decl, 1, ";\n");
++ }
++ f_print(fout, "};\n");
++ f_print(fout, "typedef struct %s %s;\n", name, name);
++}
++
++static void
++puniondef(definition *def)
++{
++ case_list *l;
++ char *name = def->def_name;
++ declaration *decl;
++
++ f_print(fout, "struct %s {\n", name);
++ decl = &def->def.un.enum_decl;
++ if (streq(decl->type, "bool")) {
++ f_print(fout, "\tbool_t %s;\n", decl->name);
++ } else {
++ f_print(fout, "\t%s %s;\n", decl->type, decl->name);
++ }
++ f_print(fout, "\tunion {\n");
++ for (l = def->def.un.cases; l != NULL; l = l->next) {
++ if (l->contflag == 0)
++ pdeclaration(name, &l->case_decl, 2, ";\n");
++ }
++ decl = def->def.un.default_decl;
++ if (decl && !streq(decl->type, "void")) {
++ pdeclaration(name, decl, 2, ";\n");
++ }
++ f_print(fout, "\t} %s_u;\n", name);
++ f_print(fout, "};\n");
++ f_print(fout, "typedef struct %s %s;\n", name, name);
++}
++
++static void
++pdefine(char *name, char *num)
++{
++ f_print(fout, "#define %s %s\n", name, num);
++}
++
++static void
++puldefine(char *name, char *num)
++{
++ f_print(fout, "#define %s ((u_int32_t)%s)\n", name, num);
++}
++
++static int
++define_printed(proc_list *stop, version_list *start)
++{
++ version_list *vers;
++ proc_list *proc;
++
++ for (vers = start; vers != NULL; vers = vers->next) {
++ for (proc = vers->procs; proc != NULL; proc = proc->next) {
++ if (proc == stop) {
++ return (0);
++ } else if (streq(proc->proc_name, stop->proc_name)) {
++ return (1);
++ }
++ }
++ }
++ abort();
++ /* NOTREACHED */
++}
++
++static void
++pprogramdef(definition *def)
++{
++ version_list *vers;
++ proc_list *proc;
++ int i;
++ char *ext;
++
++ pargdef(def);
++
++ puldefine(def->def_name, def->def.pr.prog_num);
++ for (vers = def->def.pr.versions; vers != NULL; vers = vers->next) {
++ if (tblflag) {
++ f_print(fout, "extern struct rpcgen_table %s_%s_table[];\n",
++ locase(def->def_name), vers->vers_num);
++ f_print(fout, "extern %s_%s_nproc;\n",
++ locase(def->def_name), vers->vers_num);
++ }
++ puldefine(vers->vers_name, vers->vers_num);
++
++ /*
++ * Print out 3 definitions, one for ANSI-C, another for C++,
++ * a third for old style C
++ */
++
++ for (i = 0; i < 3; i++) {
++ if (i == 0) {
++ f_print(fout, "\n#ifdef __cplusplus\n");
++ ext = "extern \"C\" ";
++ } else if (i == 1) {
++ f_print(fout, "\n#elif __STDC__\n");
++ ext = "extern ";
++ } else {
++ f_print(fout, "\n#else /* Old Style C */ \n");
++ ext = "extern ";
++ }
++
++
++ for (proc = vers->procs; proc != NULL; proc = proc->next) {
++ if (!define_printed(proc, def->def.pr.versions)) {
++ puldefine(proc->proc_name, proc->proc_num);
++ }
++ f_print(fout, "%s", ext);
++ pprocdef(proc, vers, "CLIENT *", 0, i);
++ f_print(fout, "%s", ext);
++ pprocdef(proc, vers, "struct svc_req *", 1, i);
++
++ }
++
++ }
++ f_print(fout, "#endif /* Old Style C */ \n");
++ }
++}
++
++static void
++pprocdef(proc_list *proc, version_list *vp, char *addargtype,
++ int server_p, int mode)
++{
++ ptype(proc->res_prefix, proc->res_type, 1);
++ f_print(fout, "* ");
++ if (server_p)
++ pvname_svc(proc->proc_name, vp->vers_num);
++ else
++ pvname(proc->proc_name, vp->vers_num);
++
++ /*
++ * mode 0 == cplusplus, mode 1 = ANSI-C, mode 2 = old style C
++ */
++ if (mode == 0 || mode == 1)
++ parglist(proc, addargtype);
++ else
++ f_print(fout, "();\n");
++}
++
++
++
++/* print out argument list of procedure */
++static void
++parglist(proc_list *proc, char *addargtype)
++{
++ decl_list *dl;
++
++ f_print(fout, "(");
++
++ if (proc->arg_num < 2 && newstyle &&
++ streq(proc->args.decls->decl.type, "void")) {
++ /* 0 argument in new style: do nothing */
++ } else {
++ for (dl = proc->args.decls; dl != NULL; dl = dl->next) {
++ ptype(dl->decl.prefix, dl->decl.type, 1);
++ if (!newstyle)
++ f_print(fout, "*"); /* old style passes by reference */
++
++ f_print(fout, ", ");
++ }
++ }
++
++ f_print(fout, "%s);\n", addargtype);
++}
++
++static void
++penumdef(definition *def)
++{
++ char *name = def->def_name;
++ enumval_list *l;
++ char *last = NULL;
++ int count = 0;
++
++ f_print(fout, "enum %s {\n", name);
++ for (l = def->def.en.vals; l != NULL; l = l->next) {
++ f_print(fout, "\t%s", l->name);
++ if (l->assignment) {
++ f_print(fout, " = %s", l->assignment);
++ last = l->assignment;
++ count = 1;
++ } else {
++ if (last == NULL) {
++ f_print(fout, " = %d", count++);
++ } else {
++ f_print(fout, " = %s + %d", last, count++);
++ }
++ }
++ f_print(fout, ",\n");
++ }
++ f_print(fout, "};\n");
++ f_print(fout, "typedef enum %s %s;\n", name, name);
++}
++
++static void
++ptypedef(definition *def)
++{
++ char *name = def->def_name;
++ char *old = def->def.ty.old_type;
++ char prefix[8]; /* enough to contain "struct ", including NUL */
++ relation rel = def->def.ty.rel;
++
++
++ if (!streq(name, old)) {
++ if (streq(old, "string")) {
++ old = "char";
++ rel = REL_POINTER;
++ } else if (streq(old, "opaque")) {
++ old = "char";
++ } else if (streq(old, "bool")) {
++ old = "bool_t";
++ }
++ if (undefined2(old, name) && def->def.ty.old_prefix) {
++ s_print(prefix, "%s ", def->def.ty.old_prefix);
++ } else {
++ prefix[0] = 0;
++ }
++ f_print(fout, "typedef ");
++ switch (rel) {
++ case REL_ARRAY:
++ f_print(fout, "struct {\n");
++ f_print(fout, "\tu_int %s_len;\n", name);
++ f_print(fout, "\t%s%s *%s_val;\n", prefix, old, name);
++ f_print(fout, "} %s", name);
++ break;
++ case REL_POINTER:
++ f_print(fout, "%s%s *%s", prefix, old, name);
++ break;
++ case REL_VECTOR:
++ f_print(fout, "%s%s %s[%s]", prefix, old, name,
++ def->def.ty.array_max);
++ break;
++ case REL_ALIAS:
++ f_print(fout, "%s%s %s", prefix, old, name);
++ break;
++ }
++ f_print(fout, ";\n");
++ }
++}
++
++void
++pdeclaration(char *name, declaration *dec, int tab, char *separator)
++{
++ char buf[8]; /* enough to hold "struct ", include NUL */
++ char *prefix;
++ char *type;
++
++ if (streq(dec->type, "void")) {
++ return;
++ }
++ tabify(fout, tab);
++ if (streq(dec->type, name) && !dec->prefix) {
++ f_print(fout, "struct ");
++ }
++ if (streq(dec->type, "string")) {
++ f_print(fout, "char *%s", dec->name);
++ } else {
++ prefix = "";
++ if (streq(dec->type, "bool")) {
++ type = "bool_t";
++ } else if (streq(dec->type, "opaque")) {
++ type = "char";
++ } else {
++ if (dec->prefix) {
++ s_print(buf, "%s ", dec->prefix);
++ prefix = buf;
++ }
++ type = dec->type;
++ }
++ switch (dec->rel) {
++ case REL_ALIAS:
++ f_print(fout, "%s%s %s", prefix, type, dec->name);
++ break;
++ case REL_VECTOR:
++ f_print(fout, "%s%s %s[%s]", prefix, type, dec->name,
++ dec->array_max);
++ break;
++ case REL_POINTER:
++ f_print(fout, "%s%s *%s", prefix, type, dec->name);
++ break;
++ case REL_ARRAY:
++ f_print(fout, "struct {\n");
++ tabify(fout, tab);
++ f_print(fout, "\tu_int %s_len;\n", dec->name);
++ tabify(fout, tab);
++ f_print(fout, "\t%s%s *%s_val;\n", prefix, type, dec->name);
++ tabify(fout, tab);
++ f_print(fout, "} %s", dec->name);
++ break;
++ }
++ }
++ f_print(fout, separator );
++}
++
++static int
++undefined2(char *type, char *stop)
++{
++ list *l;
++ definition *def;
++
++ for (l = defined; l != NULL; l = l->next) {
++ def = (definition *) l->val;
++ if (def->def_kind != DEF_PROGRAM) {
++ if (streq(def->def_name, stop)) {
++ return (1);
++ } else if (streq(def->def_name, type)) {
++ return (0);
++ }
++ }
++ }
++ return (1);
++}
+diff --git a/rpcgen/rpc_main.c b/rpcgen/rpc_main.c
+new file mode 100644
+index 0000000..28aa60c
+--- /dev/null
++++ b/rpcgen/rpc_main.c
+@@ -0,0 +1,1067 @@
++/*
++ * Copyright (c) 2009, Sun Microsystems, Inc.
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are met:
++ * - Redistributions of source code must retain the above copyright notice,
++ * this list of conditions and the following disclaimer.
++ * - Redistributions in binary form must reproduce the above copyright notice,
++ * this list of conditions and the following disclaimer in the documentation
++ * and/or other materials provided with the distribution.
++ * - Neither the name of Sun Microsystems, Inc. nor the names of its
++ * contributors may be used to endorse or promote products derived
++ * from this software without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++
++#if 0
++static char sccsid[] = "@(#)rpc_main.c 1.30 89/03/30 (C) 1987 SMI";
++#endif
++
++/*
++ * rpc_main.c, Top level of the RPC protocol compiler.
++ */
++
++#include <sys/types.h>
++#include <sys/param.h>
++#include <sys/file.h>
++#include <sys/stat.h>
++#include <stdio.h>
++#include <string.h>
++#include <stdlib.h>
++#include <unistd.h>
++#include <ctype.h>
++#include <errno.h>
++#include "rpc_parse.h"
++#include "rpc_util.h"
++#include "rpc_scan.h"
++
++struct commandline {
++ int cflag; /* xdr C routines */
++ int hflag; /* header file */
++ int lflag; /* client side stubs */
++ int mflag; /* server side stubs */
++ int nflag; /* netid flag */
++ int sflag; /* server stubs for the given transport */
++ int tflag; /* dispatch Table file */
++ int Ssflag; /* produce server sample code */
++ int Scflag; /* produce client sample code */
++ char *infile; /* input module name */
++ char *outfile; /* output module name */
++};
++
++static char * extendfile(char *file, char *ext);
++static void open_output(char *infile, char *outfile);
++static void add_warning(void);
++static void clear_args(void);
++static void open_input(char *infile, char *define);
++static int check_nettype(char *name, char **list_to_check);
++static void c_output(char *infile, char *define, int extend, char *outfile);
++static void c_initialize(void);
++static char * generate_guard(char *pathname);
++static void h_output(char *infile, char *define, int extend, char *outfile);
++static void s_output(int argc, char **argv, char *infile,
++ char *define, int extend, char *outfile,
++ int nomain, int netflag);
++static void l_output(char *infile, char *define, int extend, char *outfile);
++static void t_output(char *infile, char *define, int extend, char *outfile);
++static void svc_output(char *, char *, int, char *);
++static void clnt_output(char *, char *, int, char *);
++static int do_registers(int argc, char **argv);
++static void addarg(char *cp);
++static void putarg(int where, char *cp);
++static void checkfiles(char *infile, char *outfile);
++static int parseargs(int argc, char **argv, struct commandline *cmd);
++static void usage(void);
++static void options_usage(void);
++
++/*
++extern void write_sample_svc();
++int write_sample_clnt();
++void write_sample_clnt_main();
++
++static svc_output();
++ */
++
++#define EXTEND 1 /* alias for TRUE */
++#define DONT_EXTEND 0 /* alias for FALSE */
++
++#define SVR4_CPP "/usr/ccs/lib/cpp"
++#define SUNOS_CPP "/lib/cpp"
++static int cppDefined = 0; /* explicit path for C preprocessor */
++
++
++static char *cmdname;
++
++static char *svcclosetime = "120";
++static char *CPP = SVR4_CPP;
++static char CPPFLAGS[] = "-C";
++static char pathbuf[MAXPATHLEN + 1];
++static char *allv[] = {
++ "rpcgen", "-s", "udp", "-s", "tcp",
++};
++static int allc = sizeof(allv)/sizeof(allv[0]);
++static char *allnv[] = {
++ "rpcgen", "-s", "netpath",
++};
++static int allnc = sizeof(allnv)/sizeof(allnv[0]);
++
++/*
++ * machinations for handling expanding argument list
++ */
++#if 0
++static void addarg(); /* add another argument to the list */
++static void putarg(); /* put argument at specified location */
++static void clear_args(); /* clear argument list */
++static void checkfiles(); /* check if out file already exists */
++#endif
++
++
++
++#define ARGLISTLEN 20
++#define FIXEDARGS 2
++
++static char *arglist[ARGLISTLEN];
++static int argcount = FIXEDARGS;
++
++
++int nonfatalerrors; /* errors */
++int inetdflag/* = 1*/; /* Support for inetd */ /* is now the default */
++int pmflag; /* Support for port monitors */
++int logflag; /* Use syslog instead of fprintf for errors */
++int tblflag; /* Support for dispatch table file */
++
++/* length at which to start doing an inline */
++#define INLINE 3
++
++int Inline = INLINE; /* length at which to start doing an inline. 3 = default
++ * if 0, no xdr_inline code */
++
++int indefinitewait; /* If started by port monitors, hang till it wants */
++int exitnow; /* If started by port monitors, exit after the call */
++int timerflag; /* TRUE if !indefinite && !exitnow */
++int newstyle; /* newstyle of passing arguments (by value) */
++int Cflag = 0 ; /* ANSI C syntax */
++static int allfiles; /* generate all files */
++#ifdef linux
++int tirpcflag = 0; /* no tirpc by default */
++#else
++int tirpcflag = 1; /* generating code for tirpc, by default */
++#endif
++
++int
++main(int argc, char **argv)
++{
++ struct commandline cmd;
++
++ (void) memset((char *) &cmd, 0, sizeof(struct commandline));
++ clear_args();
++ if (!parseargs(argc, argv, &cmd))
++ usage();
++
++ if (cmd.cflag || cmd.hflag || cmd.lflag || cmd.tflag || cmd.sflag ||
++ cmd.mflag || cmd.nflag || cmd.Ssflag || cmd.Scflag) {
++ checkfiles(cmd.infile, cmd.outfile);
++ } else
++ checkfiles(cmd.infile, NULL);
++
++ if (cmd.cflag) {
++ c_output(cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile);
++ } else if (cmd.hflag) {
++ h_output(cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile);
++ } else if (cmd.lflag) {
++ l_output(cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile);
++ } else if (cmd.sflag || cmd.mflag || (cmd.nflag)) {
++ s_output(argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND,
++ cmd.outfile, cmd.mflag, cmd.nflag);
++ } else if (cmd.tflag) {
++ t_output(cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile);
++ } else if (cmd.Ssflag) {
++ svc_output(cmd.infile, "-DRPC_SERVER", DONT_EXTEND, cmd.outfile);
++ } else if (cmd.Scflag) {
++ clnt_output(cmd.infile, "-DRPC_CLIENT", DONT_EXTEND, cmd.outfile);
++ } else {
++ /* the rescans are required, since cpp may effect input */
++ c_output(cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c");
++ reinitialize();
++ h_output(cmd.infile, "-DRPC_HDR", EXTEND, ".h");
++ reinitialize();
++ l_output(cmd.infile, "-DRPC_CLNT", EXTEND, "_clnt.c");
++ reinitialize();
++ if (inetdflag || !tirpcflag)
++ s_output(allc, allv, cmd.infile, "-DRPC_SVC", EXTEND,
++ "_svc.c", cmd.mflag, cmd.nflag);
++ else
++ s_output(allnc, allnv, cmd.infile, "-DRPC_SVC",
++ EXTEND, "_svc.c", cmd.mflag, cmd.nflag);
++ if (tblflag) {
++ reinitialize();
++ t_output(cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.i");
++ }
++ if (allfiles) {
++ reinitialize();
++ svc_output(cmd.infile, "-DRPC_SERVER", EXTEND, "_server.c");
++ }
++ if (allfiles) {
++ reinitialize();
++ clnt_output(cmd.infile, "-DRPC_CLIENT", EXTEND, "_client.c");
++ }
++ }
++ exit(nonfatalerrors);
++ /* NOTREACHED */
++}
++
++/*
++ * add extension to filename
++ */
++static char *
++extendfile(char *file, char *ext)
++{
++ char *res;
++ char *p;
++
++ res = alloc(strlen(file) + strlen(ext) + 1);
++ if (res == NULL) {
++ abort();
++ }
++ p = strrchr(file, '.');
++ if (p == NULL) {
++ p = file + strlen(file);
++ }
++ (void) strcpy(res, file);
++ (void) strcpy(res + (p - file), ext);
++ return (res);
++}
++
++/*
++ * Open output file with given extension
++ */
++static void
++open_output(char *infile, char *outfile)
++{
++
++ if (outfile == NULL) {
++ fout = stdout;
++ return;
++ }
++
++ if (infile != NULL && streq(outfile, infile)) {
++ f_print(stderr, "%s: output would overwrite %s\n", cmdname,
++ infile);
++ crash();
++ }
++ fout = fopen(outfile, "w");
++ if (fout == NULL) {
++ f_print(stderr, "%s: unable to open ", cmdname);
++ perror(outfile);
++ crash();
++ }
++ record_open(outfile);
++
++}
++
++static void
++add_warning(void)
++{
++ f_print(fout, "/*\n");
++ f_print(fout, " * Please do not edit this file.\n");
++ f_print(fout, " * It was generated using rpcgen.\n");
++ f_print(fout, " */\n\n");
++}
++
++/* clear list of arguments */
++static void
++clear_args(void)
++{
++ int i;
++ for( i=FIXEDARGS; i<ARGLISTLEN; i++ )
++ arglist[i] = NULL;
++ argcount = FIXEDARGS;
++}
++
++/*
++ * Open input file with given define for C-preprocessor
++ */
++static void
++open_input(char *infile, char *define)
++{
++ int pd[2];
++
++ infilename = (infile == NULL) ? "<stdin>" : infile;
++ (void) pipe(pd);
++ switch (fork()) {
++ case 0:
++ putarg(0, "cpp");
++ putarg(1, CPPFLAGS);
++ addarg(define);
++ addarg(infile);
++ addarg((char *)NULL);
++ (void) close(1);
++ (void) dup2(pd[1], 1);
++ (void) close(pd[0]);
++ if (cppDefined)
++ execv(CPP, arglist);
++ else {
++ execvp("cpp", arglist);
++ if (errno == ENOENT)
++ execvp(SVR4_CPP, arglist);
++ if (errno == ENOENT)
++ execvp(SUNOS_CPP, arglist);
++ }
++ perror("execv");
++ exit(1);
++ case -1:
++ perror("fork");
++ exit(1);
++ }
++ (void) close(pd[1]);
++ fin = fdopen(pd[0], "r");
++ if (fin == NULL) {
++ f_print(stderr, "%s: ", cmdname);
++ perror(infilename);
++ crash();
++ }
++}
++
++/* valid tirpc nettypes */
++static char* valid_ti_nettypes[] =
++{
++ "netpath",
++ "visible",
++ "circuit_v",
++ "datagram_v",
++ "circuit_n",
++ "datagram_n",
++ "udp",
++ "tcp",
++ "raw",
++ NULL
++};
++
++/* valid inetd nettypes */
++static char* valid_i_nettypes[] =
++{
++ "udp",
++ "tcp",
++ NULL
++};
++
++static int
++check_nettype(char *name, char **list_to_check)
++{
++ int i;
++ for( i = 0; list_to_check[i] != NULL; i++ ) {
++ if( strcmp( name, list_to_check[i] ) == 0 ) {
++ return 1;
++ }
++ }
++ f_print( stderr, "illegal nettype :\'%s\'\n", name );
++ return 0;
++}
++
++/*
++ * Compile into an XDR routine output file
++ */
++
++static void
++c_output(char *infile, char *define, int extend, char *outfile)
++{
++ definition *def;
++ char *include;
++ char *outfilename;
++ long tell;
++
++ c_initialize();
++ open_input(infile, define);
++ outfilename = extend ? extendfile(infile, outfile) : outfile;
++ open_output(infile, outfilename);
++ add_warning();
++ if (infile && (include = extendfile(infile, ".h"))) {
++ f_print(fout, "#include \"%s\"\n", include);
++ free(include);
++ /* .h file already contains rpc/rpc.h */
++ } else
++ f_print(fout, "#include <rpc/rpc.h>\n");
++ tell = ftell(fout);
++ while ((def = get_definition()) != NULL) {
++ emit(def);
++ }
++ if (extend && tell == ftell(fout)) {
++ (void) unlink(outfilename);
++ }
++}
++
++
++static void
++c_initialize(void)
++{
++
++ /* add all the starting basic types */
++
++ add_type(1,"int");
++ add_type(1,"int32_t");
++ add_type(1,"short");
++ add_type(1,"bool");
++
++ add_type(1,"u_int");
++ add_type(1,"u_int32_t");
++ add_type(1,"u_short");
++
++}
++
++char rpcgen_table_dcl[] = "struct rpcgen_table {\n\
++ char *(*proc)();\n\
++ xdrproc_t xdr_arg;\n\
++ unsigned len_arg;\n\
++ xdrproc_t xdr_res;\n\
++ unsigned len_res;\n\
++};\n";
++
++
++static char *
++generate_guard(char *pathname)
++{
++ char* filename, *guard, *tmp;
++
++ filename = strrchr(pathname, '/' ); /* find last component */
++ filename = ((filename == 0) ? pathname : filename+1);
++ guard = strdup(filename);
++ /* convert to upper case */
++ tmp = guard;
++ while (*tmp) {
++ if (islower(*tmp))
++ *tmp = toupper(*tmp);
++ tmp++;
++ }
++
++ guard = extendfile(guard, "_H_RPCGEN");
++ return( guard );
++}
++
++/*
++ * Compile into an XDR header file
++ */
++static void
++h_output(char *infile, char *define, int extend, char *outfile)
++{
++ definition *def;
++ char *outfilename;
++ long tell;
++ char *guard;
++ list *l;
++
++ open_input(infile, define);
++ outfilename = extend ? extendfile(infile, outfile) : outfile;
++ open_output(infile, outfilename);
++ add_warning();
++ guard = generate_guard( outfilename ? outfilename: infile );
++
++ f_print(fout,"#ifndef _%s\n#define _%s\n\n", guard,
++ guard);
++
++ f_print(fout, "#include <rpc/rpc.h>\n\n");
++
++ f_print(fout, "#ifndef IXDR_GET_INT32\n");
++ f_print(fout, "#define IXDR_GET_INT32(buf) IXDR_GET_LONG((buf))\n");
++ f_print(fout, "#endif\n");
++ f_print(fout, "#ifndef IXDR_PUT_INT32\n");
++ f_print(fout, "#define IXDR_PUT_INT32(buf, v) IXDR_PUT_LONG((buf), (v))\n");
++ f_print(fout, "#endif\n");
++ f_print(fout, "#ifndef IXDR_GET_U_INT32\n");
++ f_print(fout, "#define IXDR_GET_U_INT32(buf) IXDR_GET_U_LONG((buf))\n");
++ f_print(fout, "#endif\n");
++ f_print(fout, "#ifndef IXDR_PUT_U_INT32\n");
++ f_print(fout, "#define IXDR_PUT_U_INT32(buf, v) IXDR_PUT_U_LONG((buf), (v))\n");
++ f_print(fout, "#endif\n");
++
++ tell = ftell(fout);
++ /* print data definitions */
++ while ((def = get_definition()) != NULL) {
++ print_datadef(def);
++ }
++
++ /* print function declarations.
++ Do this after data definitions because they might be used as
++ arguments for functions */
++ for (l = defined; l != NULL; l = l->next) {
++ print_funcdef(l->val);
++ }
++ if (extend && tell == ftell(fout)) {
++ (void) unlink(outfilename);
++ } else if (tblflag) {
++ f_print(fout, rpcgen_table_dcl);
++ }
++ f_print(fout, "\n#endif /* !_%s */\n", guard);
++}
++
++/*
++ * Compile into an RPC service
++ */
++static void
++s_output(int argc, char **argv, char *infile, char *define, int extend,
++ char *outfile, int nomain, int netflag)
++{
++ char *include;
++ definition *def;
++ int foundprogram = 0;
++ char *outfilename;
++
++ open_input(infile, define);
++ outfilename = extend ? extendfile(infile, outfile) : outfile;
++ open_output(infile, outfilename);
++ add_warning();
++ if (infile && (include = extendfile(infile, ".h"))) {
++ f_print(fout, "#include \"%s\"\n", include);
++ free(include);
++ } else
++ f_print(fout, "#include <rpc/rpc.h>\n");
++
++ f_print(fout, "#include <stdio.h>\n");
++ f_print(fout, "#include <stdlib.h>/* getenv, exit */\n");
++ if (Cflag) {
++ f_print (fout, "#include <rpc/pmap_clnt.h> /* for pmap_unset */\n");
++ f_print (fout, "#include <string.h> /* strcmp */ \n");
++ }
++ if (strcmp(svcclosetime, "-1") == 0)
++ indefinitewait = 1;
++ else if (strcmp(svcclosetime, "0") == 0)
++ exitnow = 1;
++ else if (inetdflag || pmflag) {
++ f_print(fout, "#include <signal.h>\n");
++ timerflag = 1;
++ }
++
++#ifndef linux
++ if( !tirpcflag && inetdflag )
++ f_print(fout, "#include <sys/ttycom.h>/* TIOCNOTTY */\n");
++#else
++ if( !tirpcflag )
++ f_print(fout, "#include <sys/ioctl.h>/* TIOCNOTTY */\n");
++#endif
++ if( Cflag && (inetdflag || pmflag ) ) {
++ f_print(fout, "#ifdef __cplusplus\n");
++ f_print(fout, "#include <sysent.h> /* getdtablesize, open */\n");
++ f_print(fout, "#endif /* __cplusplus */\n");
++
++ if( tirpcflag )
++ f_print(fout, "#include <unistd.h> /* setsid */\n");
++ }
++ if( tirpcflag )
++ f_print(fout, "#include <sys/types.h>\n");
++
++ f_print(fout, "#include <memory.h>\n");
++#ifndef linux
++ f_print(fout, "#include <stropts.h>\n");
++#endif
++ if (inetdflag || !tirpcflag ) {
++ f_print(fout, "#include <sys/socket.h>\n");
++ f_print(fout, "#include <netinet/in.h>\n");
++ }
++
++ if ( (netflag || pmflag) && tirpcflag ) {
++ f_print(fout, "#include <netconfig.h>\n");
++ }
++ if (/*timerflag &&*/ tirpcflag)
++ f_print(fout, "#include <sys/resource.h> /* rlimit */\n");
++ if (logflag || inetdflag || pmflag) {
++#ifdef linux
++ f_print(fout, "#include <syslog.h>\n");
++#else
++ f_print(fout, "#ifdef SYSLOG\n");
++ f_print(fout, "#include <syslog.h>\n");
++ f_print(fout, "#else\n");
++ f_print(fout, "#define LOG_ERR 1\n");
++ f_print(fout, "#define openlog(a, b, c)\n");
++ f_print(fout, "#endif\n");
++#endif
++ }
++
++ /* for ANSI-C */
++ f_print(fout, "\n#ifdef __STDC__\n#define SIG_PF void(*)(int)\n#endif\n");
++
++ f_print(fout, "\n#ifdef DEBUG\n#define RPC_SVC_FG\n#endif\n");
++ if (timerflag)
++ f_print(fout, "\n#define _RPCSVC_CLOSEDOWN %s\n", svcclosetime);
++ while ((def = get_definition()) != NULL) {
++ foundprogram |= (def->def_kind == DEF_PROGRAM);
++ }
++ if (extend && !foundprogram) {
++ (void) unlink(outfilename);
++ return;
++ }
++ write_most(infile, netflag, nomain);
++ if (!nomain) {
++ if( !do_registers(argc, argv) ) {
++ if (outfilename)
++ (void) unlink(outfilename);
++ usage();
++ }
++ write_rest();
++ }
++}
++
++/*
++ * generate client side stubs
++ */
++static void
++l_output(char *infile, char *define, int extend, char *outfile)
++{
++ char *include;
++ definition *def;
++ int foundprogram = 0;
++ char *outfilename;
++
++ open_input(infile, define);
++ outfilename = extend ? extendfile(infile, outfile) : outfile;
++ open_output(infile, outfilename);
++ add_warning();
++ if (Cflag)
++ f_print (fout, "#include <memory.h> /* for memset */\n");
++ if (infile && (include = extendfile(infile, ".h"))) {
++ f_print(fout, "#include \"%s\"\n", include);
++ free(include);
++ } else
++ f_print(fout, "#include <rpc/rpc.h>\n");
++ while ((def = get_definition()) != NULL) {
++ foundprogram |= (def->def_kind == DEF_PROGRAM);
++ }
++ if (extend && !foundprogram) {
++ (void) unlink(outfilename);
++ return;
++ }
++ write_stubs();
++}
++
++/*
++ * generate the dispatch table
++ */
++static void
++t_output(char *infile, char *define, int extend, char *outfile)
++{
++ definition *def;
++ int foundprogram = 0;
++ char *outfilename;
++
++ open_input(infile, define);
++ outfilename = extend ? extendfile(infile, outfile) : outfile;
++ open_output(infile, outfilename);
++ add_warning();
++ while ((def = get_definition()) != NULL) {
++ foundprogram |= (def->def_kind == DEF_PROGRAM);
++ }
++ if (extend && !foundprogram) {
++ (void) unlink(outfilename);
++ return;
++ }
++ write_tables();
++}
++
++/* sample routine for the server template */
++static void
++svc_output(char *infile, char *define, int extend, char *outfile)
++{
++ definition *def;
++ char *include;
++ char *outfilename;
++ long tell;
++
++ open_input(infile, define);
++ outfilename = extend ? extendfile(infile, outfile) : outfile;
++ checkfiles(infile,outfilename); /*check if outfile already exists.
++ if so, print an error message and exit*/
++ open_output(infile, outfilename);
++ add_sample_msg();
++
++ if (infile && (include = extendfile(infile, ".h"))) {
++ f_print(fout, "#include \"%s\"\n", include);
++ free(include);
++ } else
++ f_print(fout, "#include <rpc/rpc.h>\n");
++
++ tell = ftell(fout);
++ while ((def = get_definition()) != NULL) {
++ write_sample_svc(def);
++ }
++ if (extend && tell == ftell(fout)) {
++ (void) unlink(outfilename);
++ }
++}
++
++
++/* sample main routine for client */
++static void
++clnt_output(char *infile, char *define, int extend, char *outfile)
++{
++ definition *def;
++ char *include;
++ char *outfilename;
++ long tell;
++ int has_program = 0;
++
++ open_input(infile, define);
++ outfilename = extend ? extendfile(infile, outfile) : outfile;
++ checkfiles(infile, outfilename); /*check if outfile already exists.
++ if so, print an error message and exit*/
++
++ open_output(infile, outfilename);
++ add_sample_msg();
++ if (infile && (include = extendfile(infile, ".h"))) {
++ f_print(fout, "#include \"%s\"\n", include);
++ free(include);
++ } else
++ f_print(fout, "#include <rpc/rpc.h>\n");
++ tell = ftell(fout);
++ while ((def = get_definition()) != NULL) {
++ has_program += write_sample_clnt(def);
++ }
++
++ if (has_program)
++ write_sample_clnt_main();
++
++ if (extend && tell == ftell(fout)) {
++ (void) unlink(outfilename);
++ }
++}
++
++/*
++ * Perform registrations for service output
++ * Return 0 if failed; 1 otherwise.
++ */
++static int
++do_registers(int argc, char **argv)
++{
++ int i;
++
++ if (inetdflag || !tirpcflag) {
++ for (i = 1; i < argc; i++) {
++ if (streq(argv[i], "-s")) {
++ if (!check_nettype(argv[i + 1], valid_i_nettypes))
++ return 0;
++ write_inetd_register(argv[i + 1]);
++ i++;
++ }
++ }
++ } else {
++ for (i = 1; i < argc; i++)
++ if (streq(argv[i], "-s")) {
++ if (!check_nettype(argv[i + 1], valid_ti_nettypes))
++ return 0;
++ write_nettype_register(argv[i + 1]);
++ i++;
++ } else if (streq(argv[i], "-n")) {
++ write_netid_register(argv[i + 1]);
++ i++;
++ }
++ }
++ return 1;
++}
++
++/*
++ * Add another argument to the arg list
++ */
++static void
++addarg(char *cp)
++{
++ if (argcount >= ARGLISTLEN) {
++ f_print(stderr, "rpcgen: too many defines\n");
++ crash();
++ /*NOTREACHED*/
++ }
++ arglist[argcount++] = cp;
++
++}
++
++static void
++putarg(int where, char *cp)
++{
++ if (where >= ARGLISTLEN) {
++ f_print(stderr, "rpcgen: arglist coding error\n");
++ crash();
++ /*NOTREACHED*/
++ }
++ arglist[where] = cp;
++
++}
++
++/*
++ * if input file is stdin and an output file is specified then complain
++ * if the file already exists. Otherwise the file may get overwritten
++ * If input file does not exist, exit with an error
++ */
++
++static void
++checkfiles(char *infile, char *outfile)
++{
++
++ struct stat buf;
++
++ if(infile) /* infile ! = NULL */
++ if(stat(infile,&buf) < 0)
++ {
++ perror(infile);
++ crash();
++ };
++ if (outfile) {
++ if (stat(outfile, &buf) < 0)
++ return; /* file does not exist */
++ else {
++ f_print(stderr,
++ "file '%s' already exists and may be overwritten\n", outfile);
++ crash();
++ }
++ }
++}
++
++/*
++ * Parse command line arguments
++ */
++static int
++parseargs(int argc, char **argv, struct commandline *cmd)
++{
++ int i;
++ int j;
++ char c;
++ char flag[(1 << 8 * sizeof(char))];
++ int nflags;
++
++ cmdname = argv[0];
++ cmd->infile = cmd->outfile = NULL;
++ if (argc < 2) {
++ return (0);
++ }
++ allfiles = 0;
++ flag['c'] = 0;
++ flag['h'] = 0;
++ flag['l'] = 0;
++ flag['m'] = 0;
++ flag['o'] = 0;
++ flag['s'] = 0;
++ flag['n'] = 0;
++ flag['t'] = 0;
++ flag['S'] = 0;
++ flag['C'] = 0;
++ for (i = 1; i < argc; i++) {
++ if (argv[i][0] != '-') {
++ if (cmd->infile) {
++ f_print( stderr, "Cannot specify more than one input file!\n");
++
++ return (0);
++ }
++ cmd->infile = argv[i];
++ } else {
++ for (j = 1; argv[i][j] != 0; j++) {
++ c = argv[i][j];
++ switch (c) {
++ case 'a':
++ allfiles = 1;
++ break;
++ case 'c':
++ case 'h':
++ case 'l':
++ case 'm':
++ case 't':
++ if (flag[(int) c]) {
++ return (0);
++ }
++ flag[(int) c] = 1;
++ break;
++ case 'S':
++ /* sample flag: Ss or Sc.
++ Ss means set flag['S'];
++ Sc means set flag['C']; */
++ c = argv[i][++j]; /* get next char */
++ if( c == 's' )
++ c = 'S';
++ else if( c == 'c' )
++ c = 'C';
++ else
++ return( 0 );
++
++ if (flag[(int) c]) {
++ return (0);
++ }
++ flag[(int) c] = 1;
++ break;
++ case 'C': /* ANSI C syntax */
++ Cflag = 1;
++ break;
++
++ case 'b': /* turn TIRPC flag off for
++ generating backward compatible
++ */
++ tirpcflag = 0;
++ break;
++
++ case 'I':
++ inetdflag = 1;
++ break;
++ case 'N':
++ newstyle = 1;
++ break;
++ case 'L':
++ logflag = 1;
++ break;
++ case 'K':
++ if (++i == argc) {
++ return (0);
++ }
++ svcclosetime = argv[i];
++ goto nextarg;
++ case 'T':
++ tblflag = 1;
++ break;
++ case 'i' :
++ if (++i == argc) {
++ return (0);
++ }
++ Inline = atoi(argv[i]);
++ goto nextarg;
++ case 'n':
++ case 'o':
++ case 's':
++ if (argv[i][j - 1] != '-' ||
++ argv[i][j + 1] != 0) {
++ return (0);
++ }
++ flag[(int) c] = 1;
++ if (++i == argc) {
++ return (0);
++ }
++ if (c == 's') {
++ if (!streq(argv[i], "udp") &&
++ !streq(argv[i], "tcp")) {
++ return (0);
++ }
++ } else if (c == 'o') {
++ if (cmd->outfile) {
++ return (0);
++ }
++ cmd->outfile = argv[i];
++ }
++ goto nextarg;
++ case 'D':
++ if (argv[i][j - 1] != '-') {
++ return (0);
++ }
++ (void) addarg(argv[i]);
++ goto nextarg;
++ case 'Y':
++ if (++i == argc) {
++ return (0);
++ }
++ (void) strcpy(pathbuf, argv[i]);
++ (void) strcat(pathbuf, "/cpp");
++ CPP = pathbuf;
++ cppDefined = 1;
++ goto nextarg;
++
++
++
++ default:
++ return (0);
++ }
++ }
++ nextarg:
++ ;
++ }
++ }
++
++ cmd->cflag = flag['c'];
++ cmd->hflag = flag['h'];
++ cmd->lflag = flag['l'];
++ cmd->mflag = flag['m'];
++ cmd->nflag = flag['n'];
++ cmd->sflag = flag['s'];
++ cmd->tflag = flag['t'];
++ cmd->Ssflag = flag['S'];
++ cmd->Scflag = flag['C'];
++
++ if( tirpcflag ) {
++ pmflag = inetdflag ? 0 : 1; /* pmflag or inetdflag is always TRUE */
++ if( (inetdflag && cmd->nflag)) { /* netid not allowed with inetdflag */
++ f_print(stderr, "Cannot use netid flag with inetd flag!\n");
++ return (0);
++ }
++ } else { /* 4.1 mode */
++ pmflag = 0; /* set pmflag only in tirpcmode */
++ inetdflag = 1; /* inetdflag is TRUE by default */
++ if( cmd->nflag ) { /* netid needs TIRPC */
++ f_print( stderr, "Cannot use netid flag without TIRPC!\n");
++ return( 0 );
++ }
++ }
++
++ if( newstyle && ( tblflag || cmd->tflag) ) {
++ f_print( stderr, "Cannot use table flags with newstyle!\n");
++ return( 0 );
++ }
++
++ /* check no conflicts with file generation flags */
++ nflags = cmd->cflag + cmd->hflag + cmd->lflag + cmd->mflag +
++ cmd->sflag + cmd->nflag + cmd->tflag + cmd->Ssflag + cmd->Scflag;
++
++ if (nflags == 0) {
++ if (cmd->outfile != NULL || cmd->infile == NULL) {
++ return (0);
++ }
++ } else if (nflags > 1) {
++ f_print( stderr, "Cannot have more than one file generation flag!\n");
++ return (0);
++ }
++ return (1);
++}
++
++static void
++usage(void)
++{
++ f_print(stderr, "usage: %s infile\n", cmdname);
++ f_print(stderr, "\t%s [-a][-b][-C][-Dname[=value]] -i size [-I [-K seconds]] [-L][-N][-T] infile\n",
++ cmdname);
++ f_print(stderr, "\t%s [-c | -h | -l | -m | -t | -Sc | -Ss] [-o outfile] [infile]\n",
++ cmdname);
++ f_print(stderr, "\t%s [-s nettype]* [-o outfile] [infile]\n", cmdname);
++ f_print(stderr, "\t%s [-n netid]* [-o outfile] [infile]\n", cmdname);
++ options_usage();
++ exit(1);
++}
++
++static void
++options_usage(void)
++{
++ f_print(stderr, "options:\n");
++ f_print(stderr, "-a\t\tgenerate all files, including samples\n");
++ f_print(stderr, "-b\t\tbackward compatibility mode (generates code for SunOS 4.1)\n");
++ f_print(stderr, "-c\t\tgenerate XDR routines\n");
++ f_print(stderr, "-C\t\tANSI C mode\n");
++ f_print(stderr, "-Dname[=value]\tdefine a symbol (same as #define)\n");
++ f_print(stderr, "-h\t\tgenerate header file\n");
++ f_print(stderr, "-i size\t\tsize at which to start generating inline code\n");
++ f_print(stderr, "-I\t\tgenerate code for inetd support in server (for SunOS 4.1)\n");
++ f_print(stderr, "-K seconds\tserver exits after K seconds of inactivity\n");
++ f_print(stderr, "-l\t\tgenerate client side stubs\n");
++ f_print(stderr, "-L\t\tserver errors will be printed to syslog\n");
++ f_print(stderr, "-m\t\tgenerate server side stubs\n");
++ f_print(stderr, "-n netid\tgenerate server code that supports named netid\n");
++ f_print(stderr, "-N\t\tsupports multiple arguments and call-by-value\n");
++ f_print(stderr, "-o outfile\tname of the output file\n");
++ f_print(stderr, "-s nettype\tgenerate server code that supports named nettype\n");
++ f_print(stderr, "-Sc\t\tgenerate sample client code that uses remote procedures\n");
++ f_print(stderr, "-Ss\t\tgenerate sample server code that defines remote procedures\n");
++ f_print(stderr, "-t\t\tgenerate RPC dispatch table\n");
++ f_print(stderr, "-T\t\tgenerate code to support RPC dispatch tables\n");
++ f_print(stderr, "-Y path\t\tdirectory name to find C preprocessor (cpp)\n");
++
++ exit(1);
++}
+diff --git a/rpcgen/rpc_output.h b/rpcgen/rpc_output.h
+new file mode 100644
+index 0000000..eb25a60
+--- /dev/null
++++ b/rpcgen/rpc_output.h
+@@ -0,0 +1,16 @@
++/*
++ * rpc_output.h
++ *
++ * Declarations for output functions
++ *
++ */
++
++#ifndef RPCGEN_NEW_OUTPUT_H
++#define RPCGEN_NEW_OUTPUT_H
++
++void write_msg_out(void);
++int nullproc(proc_list *);
++void printarglist(proc_list *, char *, char *);
++void pdeclaration(char *, declaration *, int, char *);
++
++#endif /* RPCGEN_NEW_OUTPUT_H */
+diff --git a/rpcgen/rpc_parse.c b/rpcgen/rpc_parse.c
+new file mode 100644
+index 0000000..b53a553
+--- /dev/null
++++ b/rpcgen/rpc_parse.c
+@@ -0,0 +1,609 @@
++/*
++ * Copyright (c) 2009, Sun Microsystems, Inc.
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are met:
++ * - Redistributions of source code must retain the above copyright notice,
++ * this list of conditions and the following disclaimer.
++ * - Redistributions in binary form must reproduce the above copyright notice,
++ * this list of conditions and the following disclaimer in the documentation
++ * and/or other materials provided with the distribution.
++ * - Neither the name of Sun Microsystems, Inc. nor the names of its
++ * contributors may be used to endorse or promote products derived
++ * from this software without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++
++#if 0
++static char sccsid[] = "@(#)rpc_parse.c 1.8 89/02/22 (C) 1987 SMI";
++#endif
++
++/*
++ * rpc_parse.c, Parser for the RPC protocol compiler
++ * Copyright (C) 1987 Sun Microsystems, Inc.
++ */
++#include <stdio.h>
++#include <string.h>
++#include "rpc/types.h"
++#include "rpc_scan.h"
++#include "rpc_parse.h"
++#include "rpc_util.h"
++
++#define ARGNAME "arg"
++
++/*
++extern char *make_argname();
++extern char *strdup();
++ */
++
++static void isdefined(definition *defp);
++static void def_struct(definition *defp);
++static void def_program(definition *defp);
++static void def_enum(definition *defp);
++static void def_const(definition *defp);
++static void def_union(definition *defp);
++static void check_type_name(char *name, int new_type);
++static void def_typedef(definition *defp);
++static void get_declaration(declaration *dec, defkind dkind);
++static void get_prog_declaration(declaration *dec, defkind dkind, int num);
++static void get_type(char **prefixp, char **typep, defkind dkind);
++static void unsigned_dec(char **typep);
++
++/*
++ * return the next definition you see
++ */
++definition *
++get_definition(void)
++{
++ definition *defp;
++ token tok;
++
++ defp = ALLOC(definition);
++ get_token(&tok);
++ switch (tok.kind) {
++ case TOK_STRUCT:
++ def_struct(defp);
++ break;
++ case TOK_UNION:
++ def_union(defp);
++ break;
++ case TOK_TYPEDEF:
++ def_typedef(defp);
++ break;
++ case TOK_ENUM:
++ def_enum(defp);
++ break;
++ case TOK_PROGRAM:
++ def_program(defp);
++ break;
++ case TOK_CONST:
++ def_const(defp);
++ break;
++ case TOK_EOF:
++ free(defp);
++ return (NULL);
++ default:
++ error("definition keyword expected");
++ }
++ scan(TOK_SEMICOLON, &tok);
++ isdefined(defp);
++ return (defp);
++}
++
++static void
++isdefined(definition *defp)
++{
++ STOREVAL(&defined, defp);
++}
++
++static void
++def_struct(definition *defp)
++{
++ token tok;
++ declaration dec;
++ decl_list *decls;
++ decl_list **tailp;
++
++ defp->def_kind = DEF_STRUCT;
++
++ scan(TOK_IDENT, &tok);
++ defp->def_name = tok.str;
++ scan(TOK_LBRACE, &tok);
++ tailp = &defp->def.st.decls;
++ do {
++ get_declaration(&dec, DEF_STRUCT);
++ decls = ALLOC(decl_list);
++ decls->decl = dec;
++ *tailp = decls;
++ tailp = &decls->next;
++ scan(TOK_SEMICOLON, &tok);
++ peek(&tok);
++ } while (tok.kind != TOK_RBRACE);
++ get_token(&tok);
++ *tailp = NULL;
++}
++
++static void
++def_program(definition *defp)
++{
++ token tok;
++ declaration dec;
++ decl_list *decls;
++ decl_list **tailp;
++ version_list *vlist;
++ version_list **vtailp;
++ proc_list *plist;
++ proc_list **ptailp;
++ int num_args;
++ bool_t isvoid = FALSE; /* whether first argument is void */
++ defp->def_kind = DEF_PROGRAM;
++ scan(TOK_IDENT, &tok);
++ defp->def_name = tok.str;
++ scan(TOK_LBRACE, &tok);
++ vtailp = &defp->def.pr.versions;
++ tailp = &defp->def.st.decls;
++ scan(TOK_VERSION, &tok);
++ do {
++ scan(TOK_IDENT, &tok);
++ vlist = ALLOC(version_list);
++ vlist->vers_name = tok.str;
++ scan(TOK_LBRACE, &tok);
++ ptailp = &vlist->procs;
++ do {
++ /* get result type */
++ plist = ALLOC(proc_list);
++ get_type(&plist->res_prefix, &plist->res_type,
++ DEF_PROGRAM);
++ if (streq(plist->res_type, "opaque")) {
++ error("illegal result type");
++ }
++ scan(TOK_IDENT, &tok);
++ plist->proc_name = tok.str;
++ scan(TOK_LPAREN, &tok);
++ /* get args - first one*/
++ num_args = 1;
++ isvoid = FALSE;
++ /* type of DEF_PROGRAM in the first
++ * get_prog_declaration and DEF_STURCT in the next
++ * allows void as argument if it is the only argument
++ */
++ get_prog_declaration(&dec, DEF_PROGRAM, num_args);
++ if (streq(dec.type, "void"))
++ isvoid = TRUE;
++ decls = ALLOC(decl_list);
++ plist->args.decls = decls;
++ decls->decl = dec;
++ tailp = &decls->next;
++ /* get args */
++ while(peekscan(TOK_COMMA, &tok)) {
++ num_args++;
++ get_prog_declaration(&dec, DEF_STRUCT,
++ num_args);
++ decls = ALLOC(decl_list);
++ decls->decl = dec;
++ *tailp = decls;
++ if (streq(dec.type, "void"))
++ isvoid = TRUE;
++ tailp = &decls->next;
++ }
++ /* multiple arguments are only allowed in newstyle */
++ if( !newstyle && num_args > 1 ) {
++ error("only one argument is allowed" );
++ }
++ if (isvoid && num_args > 1) {
++ error("illegal use of void in program definition");
++ }
++ *tailp = NULL;
++ scan(TOK_RPAREN, &tok);
++ scan(TOK_EQUAL, &tok);
++ scan_num(&tok);
++ scan(TOK_SEMICOLON, &tok);
++ plist->proc_num = tok.str;
++ plist->arg_num = num_args;
++ *ptailp = plist;
++ ptailp = &plist->next;
++ peek(&tok);
++ } while (tok.kind != TOK_RBRACE);
++ *ptailp = NULL;
++ *vtailp = vlist;
++ vtailp = &vlist->next;
++ scan(TOK_RBRACE, &tok);
++ scan(TOK_EQUAL, &tok);
++ scan_num(&tok);
++ vlist->vers_num = tok.str;
++ /* make the argument structure name for each arg*/
++ for(plist = vlist->procs; plist != NULL;
++ plist = plist->next) {
++ plist->args.argname = make_argname(plist->proc_name,
++ vlist->vers_num);
++ /* free the memory ??*/
++ }
++ scan(TOK_SEMICOLON, &tok);
++ scan2(TOK_VERSION, TOK_RBRACE, &tok);
++ } while (tok.kind == TOK_VERSION);
++ scan(TOK_EQUAL, &tok);
++ scan_num(&tok);
++ defp->def.pr.prog_num = tok.str;
++ *vtailp = NULL;
++}
++
++
++static void
++def_enum(definition *defp)
++{
++ token tok;
++ enumval_list *elist;
++ enumval_list **tailp;
++
++ defp->def_kind = DEF_ENUM;
++ scan(TOK_IDENT, &tok);
++ defp->def_name = tok.str;
++ scan(TOK_LBRACE, &tok);
++ tailp = &defp->def.en.vals;
++ do {
++ scan(TOK_IDENT, &tok);
++ elist = ALLOC(enumval_list);
++ elist->name = tok.str;
++ elist->assignment = NULL;
++ scan3(TOK_COMMA, TOK_RBRACE, TOK_EQUAL, &tok);
++ if (tok.kind == TOK_EQUAL) {
++ scan_num(&tok);
++ elist->assignment = tok.str;
++ scan2(TOK_COMMA, TOK_RBRACE, &tok);
++ }
++ *tailp = elist;
++ tailp = &elist->next;
++ } while (tok.kind != TOK_RBRACE);
++ *tailp = NULL;
++}
++
++static void
++def_const(definition *defp)
++{
++ token tok;
++
++ defp->def_kind = DEF_CONST;
++ scan(TOK_IDENT, &tok);
++ defp->def_name = tok.str;
++ scan(TOK_EQUAL, &tok);
++ scan2(TOK_IDENT, TOK_STRCONST, &tok);
++ defp->def.co = tok.str;
++}
++
++static void
++def_union(definition *defp)
++{
++ token tok;
++ declaration dec;
++ case_list *cases;
++ case_list **tailp;
++
++ defp->def_kind = DEF_UNION;
++ scan(TOK_IDENT, &tok);
++ defp->def_name = tok.str;
++ scan(TOK_SWITCH, &tok);
++ scan(TOK_LPAREN, &tok);
++ get_declaration(&dec, DEF_UNION);
++ defp->def.un.enum_decl = dec;
++ tailp = &defp->def.un.cases;
++ scan(TOK_RPAREN, &tok);
++ scan(TOK_LBRACE, &tok);
++ scan(TOK_CASE, &tok);
++ while (tok.kind == TOK_CASE) {
++ scan2(TOK_IDENT, TOK_CHARCONST, &tok);
++ cases = ALLOC(case_list);
++ cases->case_name = tok.str;
++ scan(TOK_COLON, &tok);
++ /* now peek at next token */
++ if(peekscan(TOK_CASE,&tok))
++ {
++
++ do
++ {
++ scan2(TOK_IDENT, TOK_CHARCONST, &tok);
++ cases->contflag=1; /* continued case statement */
++ *tailp = cases;
++ tailp = &cases->next;
++ cases = ALLOC(case_list);
++ cases->case_name = tok.str;
++ scan(TOK_COLON, &tok);
++
++ }while(peekscan(TOK_CASE,&tok));
++ }
++
++ get_declaration(&dec, DEF_UNION);
++ cases->case_decl = dec;
++ cases->contflag=0; /* no continued case statement */
++ *tailp = cases;
++ tailp = &cases->next;
++ scan(TOK_SEMICOLON, &tok);
++
++ scan3(TOK_CASE, TOK_DEFAULT, TOK_RBRACE, &tok);
++ }
++ *tailp = NULL;
++ if (tok.kind == TOK_DEFAULT) {
++ scan(TOK_COLON, &tok);
++ get_declaration(&dec, DEF_UNION);
++ defp->def.un.default_decl = ALLOC(declaration);
++ *defp->def.un.default_decl = dec;
++ scan(TOK_SEMICOLON, &tok);
++ scan(TOK_RBRACE, &tok);
++ } else {
++ defp->def.un.default_decl = NULL;
++ }
++}
++
++static char* reserved_words[] =
++{
++ "array",
++ "bytes",
++ "destroy",
++ "free",
++ "getpos",
++ "inline",
++ "pointer",
++ "reference",
++ "setpos",
++ "sizeof",
++ "union",
++ "vector",
++ NULL
++ };
++
++static char* reserved_types[] =
++{
++ "opaque",
++ "string",
++ NULL
++ };
++
++/* check that the given name is not one that would eventually result in
++ xdr routines that would conflict with internal XDR routines. */
++static void
++check_type_name(char *name, int new_type)
++{
++ int i;
++ char tmp[100];
++
++ for( i = 0; reserved_words[i] != NULL; i++ ) {
++ if( strcmp( name, reserved_words[i] ) == 0 ) {
++ sprintf(tmp,
++ "illegal (reserved) name :\'%s\' in type definition", name );
++ error(tmp);
++ }
++ }
++ if( new_type ) {
++ for( i = 0; reserved_types[i] != NULL; i++ ) {
++ if( strcmp( name, reserved_types[i] ) == 0 ) {
++ sprintf(tmp,
++ "illegal (reserved) name :\'%s\' in type definition", name );
++ error(tmp);
++ }
++ }
++ }
++}
++
++static void
++def_typedef(definition *defp)
++{
++ declaration dec;
++
++ defp->def_kind = DEF_TYPEDEF;
++ get_declaration(&dec, DEF_TYPEDEF);
++ defp->def_name = dec.name;
++ check_type_name( dec.name, 1 );
++ defp->def.ty.old_prefix = dec.prefix;
++ defp->def.ty.old_type = dec.type;
++ defp->def.ty.rel = dec.rel;
++ defp->def.ty.array_max = dec.array_max;
++}
++
++static void
++get_declaration(declaration *dec, defkind dkind)
++{
++ token tok;
++
++ get_type(&dec->prefix, &dec->type, dkind);
++ dec->rel = REL_ALIAS;
++ if (streq(dec->type, "void")) {
++ return;
++ }
++
++ check_type_name( dec->type, 0 );
++
++ scan2(TOK_STAR, TOK_IDENT, &tok);
++ if (tok.kind == TOK_STAR) {
++ dec->rel = REL_POINTER;
++ scan(TOK_IDENT, &tok);
++ }
++ dec->name = tok.str;
++ if (peekscan(TOK_LBRACKET, &tok)) {
++ if (dec->rel == REL_POINTER) {
++ error("no array-of-pointer declarations -- use typedef");
++ }
++ dec->rel = REL_VECTOR;
++ scan_num(&tok);
++ dec->array_max = tok.str;
++ scan(TOK_RBRACKET, &tok);
++ } else if (peekscan(TOK_LANGLE, &tok)) {
++ if (dec->rel == REL_POINTER) {
++ error("no array-of-pointer declarations -- use typedef");
++ }
++ dec->rel = REL_ARRAY;
++ if (peekscan(TOK_RANGLE, &tok)) {
++ dec->array_max = "~0"; /* unspecified size, use max */
++ } else {
++ scan_num(&tok);
++ dec->array_max = tok.str;
++ scan(TOK_RANGLE, &tok);
++ }
++ }
++ if (streq(dec->type, "opaque")) {
++ if (dec->rel != REL_ARRAY && dec->rel != REL_VECTOR) {
++ error("array declaration expected");
++ }
++ } else if (streq(dec->type, "string")) {
++ if (dec->rel != REL_ARRAY) {
++ error("variable-length array declaration expected");
++ }
++ }
++}
++
++
++static void
++get_prog_declaration(declaration *dec, defkind dkind, int num)
++{
++ token tok;
++ char name[10]; /* argument name */
++
++ if (dkind == DEF_PROGRAM) {
++ peek(&tok);
++ if (tok.kind == TOK_RPAREN) { /* no arguments */
++ dec->rel = REL_ALIAS;
++ dec->type = "void";
++ dec->prefix = NULL;
++ dec->name = NULL;
++ return;
++ }
++ }
++ get_type(&dec->prefix, &dec->type, dkind);
++ dec->rel = REL_ALIAS;
++ if (peekscan(TOK_IDENT, &tok)) /* optional name of argument */
++ strcpy(name, tok.str);
++ else
++ sprintf(name, "%s%d", ARGNAME, num); /* default name of argument */
++
++ dec->name = (char *) strdup(name);
++
++ if (streq(dec->type, "void")) {
++ return;
++ }
++
++ if (streq(dec->type, "opaque")) {
++ error("opaque -- illegal argument type");
++ }
++ if (peekscan(TOK_STAR, &tok)) {
++ if (streq(dec->type, "string")) {
++ error("pointer to string not allowed in program arguments\n");
++ }
++ dec->rel = REL_POINTER;
++ if (peekscan(TOK_IDENT, &tok)) /* optional name of argument */
++ dec->name = strdup(tok.str);
++ }
++ if (peekscan(TOK_LANGLE, &tok)) {
++ if (!streq(dec->type, "string")) {
++ error("arrays cannot be declared as arguments to procedures -- use typedef");
++ }
++ dec->rel = REL_ARRAY;
++ if (peekscan(TOK_RANGLE, &tok)) {
++ dec->array_max = "~0";/* unspecified size, use max */
++ } else {
++ scan_num(&tok);
++ dec->array_max = tok.str;
++ scan(TOK_RANGLE, &tok);
++ }
++ }
++ if (streq(dec->type, "string")) {
++ if (dec->rel != REL_ARRAY) { /* .x specifies just string as
++ * type of argument
++ * - make it string<>
++ */
++ dec->rel = REL_ARRAY;
++ dec->array_max = "~0";/* unspecified size, use max */
++ }
++ }
++}
++
++
++
++static void
++get_type(char **prefixp, char **typep, defkind dkind)
++{
++ token tok;
++
++ *prefixp = NULL;
++ get_token(&tok);
++ switch (tok.kind) {
++ case TOK_IDENT:
++ *typep = tok.str;
++ break;
++ case TOK_STRUCT:
++ case TOK_ENUM:
++ case TOK_UNION:
++ *prefixp = tok.str;
++ scan(TOK_IDENT, &tok);
++ *typep = tok.str;
++ break;
++ case TOK_UNSIGNED:
++ unsigned_dec(typep);
++ break;
++ case TOK_SHORT:
++ *typep = "short";
++ (void) peekscan(TOK_INT, &tok);
++ break;
++ case TOK_INT32:
++ *typep = "int32_t";
++ (void) peekscan(TOK_INT, &tok);
++ break;
++ case TOK_VOID:
++ if (dkind != DEF_UNION && dkind != DEF_PROGRAM) {
++ error("voids allowed only inside union and program definitions with one argument");
++ }
++ *typep = tok.str;
++ break;
++ case TOK_STRING:
++ case TOK_OPAQUE:
++ case TOK_CHAR:
++ case TOK_INT:
++ case TOK_FLOAT:
++ case TOK_DOUBLE:
++ case TOK_BOOL:
++ *typep = tok.str;
++ break;
++ default:
++ error("expected type specifier");
++ }
++}
++
++static void
++unsigned_dec(char **typep)
++{
++ token tok;
++
++ peek(&tok);
++ switch (tok.kind) {
++ case TOK_CHAR:
++ get_token(&tok);
++ *typep = "u_char";
++ break;
++ case TOK_SHORT:
++ get_token(&tok);
++ *typep = "u_short";
++ (void) peekscan(TOK_INT, &tok);
++ break;
++ case TOK_INT32:
++ get_token(&tok);
++ *typep = "u_int32_";
++ (void) peekscan(TOK_INT, &tok);
++ break;
++ case TOK_INT:
++ get_token(&tok);
++ *typep = "u_int";
++ break;
++ default:
++ *typep = "u_int";
++ break;
++ }
++}
+diff --git a/rpcgen/rpc_parse.h b/rpcgen/rpc_parse.h
+new file mode 100644
+index 0000000..2afae10
+--- /dev/null
++++ b/rpcgen/rpc_parse.h
+@@ -0,0 +1,166 @@
++/*
++ * Copyright (c) 2009, Sun Microsystems, Inc.
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are met:
++ * - Redistributions of source code must retain the above copyright notice,
++ * this list of conditions and the following disclaimer.
++ * - Redistributions in binary form must reproduce the above copyright notice,
++ * this list of conditions and the following disclaimer in the documentation
++ * and/or other materials provided with the distribution.
++ * - Neither the name of Sun Microsystems, Inc. nor the names of its
++ * contributors may be used to endorse or promote products derived
++ * from this software without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++
++/* @(#)rpc_parse.h 1.3 90/08/29 (C) 1987 SMI */
++
++/*
++ * rpc_parse.h, Definitions for the RPCL parser
++ */
++
++enum defkind {
++ DEF_CONST,
++ DEF_STRUCT,
++ DEF_UNION,
++ DEF_ENUM,
++ DEF_TYPEDEF,
++ DEF_PROGRAM
++};
++typedef enum defkind defkind;
++
++typedef char *const_def;
++
++enum relation {
++ REL_VECTOR, /* fixed length array */
++ REL_ARRAY, /* variable length array */
++ REL_POINTER, /* pointer */
++ REL_ALIAS, /* simple */
++};
++typedef enum relation relation;
++
++struct typedef_def {
++ char *old_prefix;
++ char *old_type;
++ relation rel;
++ char *array_max;
++};
++typedef struct typedef_def typedef_def;
++
++struct enumval_list {
++ char *name;
++ char *assignment;
++ struct enumval_list *next;
++};
++typedef struct enumval_list enumval_list;
++
++struct enum_def {
++ enumval_list *vals;
++};
++typedef struct enum_def enum_def;
++
++struct declaration {
++ char *prefix;
++ char *type;
++ char *name;
++ relation rel;
++ char *array_max;
++};
++typedef struct declaration declaration;
++
++struct decl_list {
++ declaration decl;
++ struct decl_list *next;
++};
++typedef struct decl_list decl_list;
++
++struct struct_def {
++ decl_list *decls;
++};
++typedef struct struct_def struct_def;
++
++struct case_list {
++ char *case_name;
++ int contflag;
++ declaration case_decl;
++ struct case_list *next;
++};
++typedef struct case_list case_list;
++
++struct union_def {
++ declaration enum_decl;
++ case_list *cases;
++ declaration *default_decl;
++};
++typedef struct union_def union_def;
++
++struct arg_list {
++ char *argname; /* name of struct for arg*/
++ decl_list *decls;
++};
++
++typedef struct arg_list arg_list;
++
++struct proc_list {
++ char *proc_name;
++ char *proc_num;
++ arg_list args;
++ int arg_num;
++ char *res_type;
++ char *res_prefix;
++ struct proc_list *next;
++};
++typedef struct proc_list proc_list;
++
++struct version_list {
++ char *vers_name;
++ char *vers_num;
++ proc_list *procs;
++ struct version_list *next;
++};
++typedef struct version_list version_list;
++
++struct program_def {
++ char *prog_num;
++ version_list *versions;
++};
++typedef struct program_def program_def;
++
++struct definition {
++ char *def_name;
++ defkind def_kind;
++ union {
++ const_def co;
++ struct_def st;
++ union_def un;
++ enum_def en;
++ typedef_def ty;
++ program_def pr;
++ } def;
++};
++typedef struct definition definition;
++
++definition *get_definition();
++
++
++struct bas_type
++{
++ char *name;
++ int length;
++ struct bas_type *next;
++};
++
++typedef struct bas_type bas_type;
+diff --git a/rpcgen/rpc_sample.c b/rpcgen/rpc_sample.c
+new file mode 100644
+index 0000000..2b5c81b
+--- /dev/null
++++ b/rpcgen/rpc_sample.c
+@@ -0,0 +1,247 @@
++/*
++ * Copyright (c) 2009, Sun Microsystems, Inc.
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are met:
++ * - Redistributions of source code must retain the above copyright notice,
++ * this list of conditions and the following disclaimer.
++ * - Redistributions in binary form must reproduce the above copyright notice,
++ * this list of conditions and the following disclaimer in the documentation
++ * and/or other materials provided with the distribution.
++ * - Neither the name of Sun Microsystems, Inc. nor the names of its
++ * contributors may be used to endorse or promote products derived
++ * from this software without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++
++#if 0
++static char sccsid[] = "@(#)rpc_sample.c 1.1 90/08/30 (C) 1987 SMI";
++
++#endif
++
++/*
++ * rpc_sample.c, Sample client-server code outputter for the RPC protocol compiler
++ */
++
++#include <stdio.h>
++#include <string.h>
++#include "rpc_parse.h"
++#include "rpc_util.h"
++
++
++static char RQSTP[] = "rqstp";
++
++static void write_sample_client(char *program_name, version_list *vp);
++static void write_sample_server(definition * def);
++static void return_type(proc_list *plist);
++
++void
++write_sample_svc(definition *def)
++{
++ if (def->def_kind != DEF_PROGRAM)
++ return;
++ write_sample_server(def);
++}
++
++
++int
++write_sample_clnt(definition *def)
++{
++ version_list *vp;
++ int count = 0;
++
++ if (def->def_kind != DEF_PROGRAM)
++ return (0);
++ /* generate sample code for each version */
++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
++ write_sample_client(def->def_name, vp);
++ ++count;
++ }
++ return (count);
++}
++
++
++static void
++write_sample_client(char *program_name, version_list *vp)
++{
++ proc_list *proc;
++ int i;
++ decl_list *l;
++
++ f_print(fout, "\n\nvoid\n");
++ pvname(program_name, vp->vers_num);
++ if (Cflag)
++ f_print(fout, "( char* host )\n{\n");
++ else
++ f_print(fout, "(host)\nchar *host;\n{\n");
++ f_print(fout, "\tCLIENT *clnt;\n");
++
++ i = 0;
++ for (proc = vp->procs; proc != NULL; proc = proc->next) {
++ f_print(fout, "\t");
++ ptype(proc->res_prefix, proc->res_type, 1);
++ f_print(fout, " *result_%d;\n", ++i);
++ /* print out declarations for arguments */
++ if (proc->arg_num < 2 && !newstyle) {
++ f_print(fout, "\t");
++ if (!streq(proc->args.decls->decl.type, "void"))
++ ptype(proc->args.decls->decl.prefix, proc->args.decls->decl.type, 1);
++ else
++ f_print(fout, "char* "); /* cannot have "void" type */
++ f_print(fout, " ");
++ pvname(proc->proc_name, vp->vers_num);
++ f_print(fout, "_arg;\n");
++ } else if (!streq(proc->args.decls->decl.type, "void")) {
++ for (l = proc->args.decls; l != NULL; l = l->next) {
++ f_print(fout, "\t");
++ ptype(l->decl.prefix, l->decl.type, 1);
++ f_print(fout, " ");
++ pvname(proc->proc_name, vp->vers_num);
++ f_print(fout, "_%s;\n", l->decl.name);
++ /* pdeclaration(proc->args.argname, &l->decl, 1, ";\n" );*/
++ }
++ }
++ }
++
++ /* generate creation of client handle */
++ f_print(fout, "\tclnt = clnt_create(host, %s, %s, \"%s\");\n",
++ program_name, vp->vers_name, tirpcflag ? "netpath" : "udp");
++ f_print(fout, "\tif (clnt == NULL) {\n");
++ f_print(fout, "\t\tclnt_pcreateerror(host);\n");
++ f_print(fout, "\t\texit(1);\n\t}\n");
++
++ /* generate calls to procedures */
++ i = 0;
++ for (proc = vp->procs; proc != NULL; proc = proc->next) {
++ f_print(fout, "\tresult_%d = ", ++i);
++ pvname(proc->proc_name, vp->vers_num);
++ if (proc->arg_num < 2 && !newstyle) {
++ f_print(fout, "(");
++ if (streq(proc->args.decls->decl.type, "void")) /* cast to void* */
++ f_print(fout, "(void*)");
++ f_print(fout, "&");
++ pvname(proc->proc_name, vp->vers_num);
++ f_print(fout, "_arg, clnt);\n");
++ } else if (streq(proc->args.decls->decl.type, "void")) {
++ f_print(fout, "(clnt);\n");
++ } else {
++ f_print(fout, "(");
++ for (l = proc->args.decls; l != NULL; l = l->next) {
++ pvname(proc->proc_name, vp->vers_num);
++ f_print(fout, "_%s, ", l->decl.name);
++ }
++ f_print(fout, "clnt);\n");
++ }
++ f_print(fout, "\tif (result_%d == NULL) {\n", i);
++ f_print(fout, "\t\tclnt_perror(clnt, \"call failed:\");\n");
++ f_print(fout, "\t}\n");
++ }
++
++ f_print(fout, "\tclnt_destroy( clnt );\n");
++ f_print(fout, "}\n");
++}
++
++static void
++write_sample_server(definition * def)
++{
++ version_list *vp;
++ proc_list *proc;
++
++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
++ for (proc = vp->procs; proc != NULL; proc = proc->next) {
++ f_print(fout, "\n");
++ /* if( Cflag )
++ f_print( fout, "extern \"C\"{\n");
++*/
++ return_type(proc);
++ f_print(fout, "* \n");
++ if (Cflag)
++ pvname_svc(proc->proc_name, vp->vers_num);
++ else
++ pvname(proc->proc_name, vp->vers_num);
++ printarglist(proc, RQSTP, "struct svc_req *");
++
++ f_print(fout, "{\n");
++ f_print(fout, "\n\tstatic ");
++ if (!streq(proc->res_type, "void"))
++ return_type(proc);
++ else
++ f_print(fout, "char*"); /* cannot have void type */
++ /* f_print(fout, " result;\n", proc->res_type); */
++ f_print(fout, " result;\n");
++ f_print(fout,
++ "\n\t/*\n\t * insert server code here\n\t */\n\n");
++ if (!streq(proc->res_type, "void"))
++ f_print(fout, "\treturn(&result);\n}\n");
++ else /* cast back to void * */
++ f_print(fout, "\treturn((void*) &result);\n}\n");
++ /* if( Cflag)
++ f_print( fout, "};\n");
++*/
++
++ }
++ }
++}
++
++
++
++static void
++return_type(proc_list *plist)
++{
++ ptype( plist->res_prefix, plist->res_type, 1 );
++}
++
++void
++add_sample_msg(void)
++{
++ f_print(fout, "/*\n");
++ f_print(fout, " * This is sample code generated by rpcgen.\n");
++ f_print(fout, " * These are only templates and you can use them\n");
++ f_print(fout, " * as a guideline for developing your own functions.\n");
++ f_print(fout, " */\n\n");
++}
++
++void
++write_sample_clnt_main(void)
++{
++ list *l;
++ definition *def;
++ version_list *vp;
++
++ f_print(fout, "\n\n" );
++ if( Cflag )
++ f_print(fout,"main( int argc, char* argv[] )\n{\n" );
++ else
++ f_print(fout, "main(argc, argv)\nint argc;\nchar *argv[];\n{\n" );
++
++ f_print(fout, "\tchar *host;");
++ f_print(fout, "\n\n\tif(argc < 2) {");
++ f_print(fout, "\n\t\tprintf(\"usage: %%s server_host\\n\", argv[0]);\n" );
++ f_print(fout, "\t\texit(1);\n\t}");
++ f_print(fout, "\n\thost = argv[1];\n");
++
++ for (l = defined; l != NULL; l = l->next) {
++ def = l->val;
++ if (def->def_kind != DEF_PROGRAM) {
++ continue;
++ }
++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
++ f_print( fout, "\t" );
++ pvname(def->def_name, vp->vers_num);
++ f_print( fout, "( host );\n" );
++ }
++ }
++ f_print(fout, "}\n");
++}
+diff --git a/rpcgen/rpc_scan.c b/rpcgen/rpc_scan.c
+new file mode 100644
+index 0000000..f58fa9f
+--- /dev/null
++++ b/rpcgen/rpc_scan.c
+@@ -0,0 +1,474 @@
++/*
++ * Copyright (c) 2009, Sun Microsystems, Inc.
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are met:
++ * - Redistributions of source code must retain the above copyright notice,
++ * this list of conditions and the following disclaimer.
++ * - Redistributions in binary form must reproduce the above copyright notice,
++ * this list of conditions and the following disclaimer in the documentation
++ * and/or other materials provided with the distribution.
++ * - Neither the name of Sun Microsystems, Inc. nor the names of its
++ * contributors may be used to endorse or promote products derived
++ * from this software without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++
++#if 0
++static char sccsid[] = "@(#)rpc_scan.c 1.11 89/02/22 (C) 1987 SMI";
++#endif
++
++/*
++ * rpc_scan.c, Scanner for the RPC protocol compiler
++ * Copyright (C) 1987, Sun Microsystems, Inc.
++ */
++#include <stdio.h>
++#include <ctype.h>
++#include <string.h>
++#include "rpc_scan.h"
++#include "rpc_parse.h"
++#include "rpc_util.h"
++
++static void unget_token(token *tokp);
++static void findstrconst(char **str, char **val);
++static void findchrconst(char **str, char **val);
++static void findconst(char **str, char **val);
++static void findkind(char **mark, token *tokp);
++static int cppline(char *line);
++static int directive(char *line);
++static void printdirective(char *line);
++static void docppline(char *line, int *lineno, char **fname);
++
++#define startcomment(where) (where[0] == '/' && where[1] == '*')
++#define endcomment(where) (where[-1] == '*' && where[0] == '/')
++
++static int pushed = 0; /* is a token pushed */
++static token lasttok; /* last token, if pushed */
++
++/*
++ * scan expecting 1 given token
++ */
++void
++scan(tok_kind expect, token *tokp)
++{
++ get_token(tokp);
++ if (tokp->kind != expect) {
++ expected1(expect);
++ }
++}
++
++/*
++ * scan expecting any of the 2 given tokens
++ */
++void
++scan2(tok_kind expect1, tok_kind expect2, token *tokp)
++{
++ get_token(tokp);
++ if (tokp->kind != expect1 && tokp->kind != expect2) {
++ expected2(expect1, expect2);
++ }
++}
++
++/*
++ * scan expecting any of the 3 given token
++ */
++void
++scan3(tok_kind expect1, tok_kind expect2, tok_kind expect3, token *tokp)
++{
++ get_token(tokp);
++ if (tokp->kind != expect1 && tokp->kind != expect2
++ && tokp->kind != expect3) {
++ expected3(expect1, expect2, expect3);
++ }
++}
++
++/*
++ * scan expecting a constant, possibly symbolic
++ */
++void
++scan_num(token *tokp)
++{
++ get_token(tokp);
++ switch (tokp->kind) {
++ case TOK_IDENT:
++ break;
++ default:
++ error("constant or identifier expected");
++ }
++}
++
++/*
++ * Peek at the next token
++ */
++void
++peek(token *tokp)
++{
++ get_token(tokp);
++ unget_token(tokp);
++}
++
++/*
++ * Peek at the next token and scan it if it matches what you expect
++ */
++int
++peekscan(tok_kind expect, token *tokp)
++{
++ peek(tokp);
++ if (tokp->kind == expect) {
++ get_token(tokp);
++ return (1);
++ }
++ return (0);
++}
++
++/*
++ * Get the next token, printing out any directive that are encountered.
++ */
++void
++get_token(token *tokp)
++{
++ int commenting;
++
++ if (pushed) {
++ pushed = 0;
++ *tokp = lasttok;
++ return;
++ }
++ commenting = 0;
++ for (;;) {
++ if (*where == 0) {
++ for (;;) {
++ if (!fgets(curline, MAXLINESIZE, fin)) {
++ tokp->kind = TOK_EOF;
++ *where = 0;
++ return;
++ }
++ linenum++;
++ if (commenting) {
++ break;
++ } else if (cppline(curline)) {
++ docppline(curline, &linenum,
++ &infilename);
++ } else if (directive(curline)) {
++ printdirective(curline);
++ } else {
++ break;
++ }
++ }
++ where = curline;
++ } else if (isspace(*where)) {
++ while (isspace(*where)) {
++ where++; /* eat */
++ }
++ } else if (commenting) {
++ for (where++; *where; where++) {
++ if (endcomment(where)) {
++ where++;
++ commenting--;
++ break;
++ }
++ }
++ } else if (startcomment(where)) {
++ where += 2;
++ commenting++;
++ } else {
++ break;
++ }
++ }
++
++ /*
++ * 'where' is not whitespace, comment or directive Must be a token!
++ */
++ switch (*where) {
++ case ':':
++ tokp->kind = TOK_COLON;
++ where++;
++ break;
++ case ';':
++ tokp->kind = TOK_SEMICOLON;
++ where++;
++ break;
++ case ',':
++ tokp->kind = TOK_COMMA;
++ where++;
++ break;
++ case '=':
++ tokp->kind = TOK_EQUAL;
++ where++;
++ break;
++ case '*':
++ tokp->kind = TOK_STAR;
++ where++;
++ break;
++ case '[':
++ tokp->kind = TOK_LBRACKET;
++ where++;
++ break;
++ case ']':
++ tokp->kind = TOK_RBRACKET;
++ where++;
++ break;
++ case '{':
++ tokp->kind = TOK_LBRACE;
++ where++;
++ break;
++ case '}':
++ tokp->kind = TOK_RBRACE;
++ where++;
++ break;
++ case '(':
++ tokp->kind = TOK_LPAREN;
++ where++;
++ break;
++ case ')':
++ tokp->kind = TOK_RPAREN;
++ where++;
++ break;
++ case '<':
++ tokp->kind = TOK_LANGLE;
++ where++;
++ break;
++ case '>':
++ tokp->kind = TOK_RANGLE;
++ where++;
++ break;
++
++ case '"':
++ tokp->kind = TOK_STRCONST;
++ findstrconst(&where, &tokp->str);
++ break;
++ case '\'':
++ tokp->kind = TOK_CHARCONST;
++ findchrconst(&where, &tokp->str);
++ break;
++
++ case '-':
++ case '0':
++ case '1':
++ case '2':
++ case '3':
++ case '4':
++ case '5':
++ case '6':
++ case '7':
++ case '8':
++ case '9':
++ tokp->kind = TOK_IDENT;
++ findconst(&where, &tokp->str);
++ break;
++
++ default:
++ if (!(isalpha(*where) || *where == '_')) {
++ char buf[100];
++ char *p;
++
++ s_print(buf, "illegal character in file: ");
++ p = buf + strlen(buf);
++ if (isprint(*where)) {
++ s_print(p, "%c", *where);
++ } else {
++ s_print(p, "%d", *where);
++ }
++ error(buf);
++ }
++ findkind(&where, tokp);
++ break;
++ }
++}
++
++static void
++unget_token(token *tokp)
++{
++ lasttok = *tokp;
++ pushed = 1;
++}
++
++static void
++findstrconst(char **str, char **val)
++{
++ char *p;
++ int size;
++
++ p = *str;
++ do {
++ *p++;
++ } while (*p && *p != '"');
++ if (*p == 0) {
++ error("unterminated string constant");
++ }
++ p++;
++ size = p - *str;
++ *val = alloc(size + 1);
++ (void) strncpy(*val, *str, size);
++ (*val)[size] = 0;
++ *str = p;
++}
++
++static void
++findchrconst(char **str, char **val)
++{
++ char *p;
++ int size;
++
++ p = *str;
++ do {
++ *p++;
++ } while (*p && *p != '\'');
++ if (*p == 0) {
++ error("unterminated string constant");
++ }
++ p++;
++ size = p - *str;
++ if (size != 3) {
++ error("empty char string");
++ }
++ *val = alloc(size + 1);
++ (void) strncpy(*val, *str, size);
++ (*val)[size] = 0;
++ *str = p;
++}
++
++static void
++findconst(char **str, char **val)
++{
++ char *p;
++ int size;
++
++ p = *str;
++ if (*p == '0' && *(p + 1) == 'x') {
++ p++;
++ do {
++ p++;
++ } while (isxdigit(*p));
++ } else {
++ do {
++ p++;
++ } while (isdigit(*p));
++ }
++ size = p - *str;
++ *val = alloc(size + 1);
++ (void) strncpy(*val, *str, size);
++ (*val)[size] = 0;
++ *str = p;
++}
++
++static token symbols[] = {
++ {TOK_CONST, "const"},
++ {TOK_UNION, "union"},
++ {TOK_SWITCH, "switch"},
++ {TOK_CASE, "case"},
++ {TOK_DEFAULT, "default"},
++ {TOK_STRUCT, "struct"},
++ {TOK_TYPEDEF, "typedef"},
++ {TOK_ENUM, "enum"},
++ {TOK_OPAQUE, "opaque"},
++ {TOK_BOOL, "bool"},
++ {TOK_VOID, "void"},
++ {TOK_CHAR, "char"},
++ {TOK_INT, "int"},
++ {TOK_UNSIGNED, "unsigned"},
++ {TOK_SHORT, "short"},
++ {TOK_INT32, "int32"},
++ {TOK_FLOAT, "float"},
++ {TOK_DOUBLE, "double"},
++ {TOK_STRING, "string"},
++ {TOK_PROGRAM, "program"},
++ {TOK_VERSION, "version"},
++ {TOK_EOF, "??????"},
++};
++
++static void
++findkind(char **mark, token *tokp)
++{
++ int len;
++ token *s;
++ char *str;
++
++ str = *mark;
++ for (s = symbols; s->kind != TOK_EOF; s++) {
++ len = strlen(s->str);
++ if (strncmp(str, s->str, len) == 0) {
++ if (!isalnum(str[len]) && str[len] != '_') {
++ tokp->kind = s->kind;
++ tokp->str = s->str;
++ *mark = str + len;
++ return;
++ }
++ }
++ }
++ tokp->kind = TOK_IDENT;
++ for (len = 0; isalnum(str[len]) || str[len] == '_'; len++);
++ tokp->str = alloc(len + 1);
++ (void) strncpy(tokp->str, str, len);
++ tokp->str[len] = 0;
++ *mark = str + len;
++}
++
++static int
++cppline(char *line)
++{
++ return (line == curline && *line == '#');
++}
++
++static int
++directive(char *line)
++{
++ return (line == curline && *line == '%');
++}
++
++static void
++printdirective(char *line)
++{
++ f_print(fout, "%s", line + 1);
++}
++
++static void
++docppline(char *line, int *lineno, char **fname)
++{
++ char *file;
++ int num;
++ char *p;
++
++ line++;
++ while (isspace(*line)) {
++ line++;
++ }
++ num = atoi(line);
++ while (isdigit(*line)) {
++ line++;
++ }
++ while (isspace(*line)) {
++ line++;
++ }
++ if (*line != '"') {
++ error("preprocessor error");
++ }
++ line++;
++ p = file = alloc(strlen(line) + 1);
++ while (*line && *line != '"') {
++ *p++ = *line++;
++ }
++ if (*line == 0) {
++ error("preprocessor error");
++ }
++ *p = 0;
++ if (*file == 0) {
++ *fname = NULL;
++ free(file);
++ } else {
++ *fname = file;
++ }
++ *lineno = num - 1;
++}
+diff --git a/rpcgen/rpc_scan.h b/rpcgen/rpc_scan.h
+new file mode 100644
+index 0000000..16f688c
+--- /dev/null
++++ b/rpcgen/rpc_scan.h
+@@ -0,0 +1,103 @@
++/*
++ * Copyright (c) 2009, Sun Microsystems, Inc.
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are met:
++ * - Redistributions of source code must retain the above copyright notice,
++ * this list of conditions and the following disclaimer.
++ * - Redistributions in binary form must reproduce the above copyright notice,
++ * this list of conditions and the following disclaimer in the documentation
++ * and/or other materials provided with the distribution.
++ * - Neither the name of Sun Microsystems, Inc. nor the names of its
++ * contributors may be used to endorse or promote products derived
++ * from this software without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++
++/* @(#)rpc_scan.h 1.3 90/08/29 (C) 1987 SMI */
++
++/*
++ * rpc_scan.h, Definitions for the RPCL scanner
++ */
++
++/*
++ * kinds of tokens
++ */
++enum tok_kind {
++ TOK_IDENT,
++ TOK_CHARCONST,
++ TOK_STRCONST,
++ TOK_LPAREN,
++ TOK_RPAREN,
++ TOK_LBRACE,
++ TOK_RBRACE,
++ TOK_LBRACKET,
++ TOK_RBRACKET,
++ TOK_LANGLE,
++ TOK_RANGLE,
++ TOK_STAR,
++ TOK_COMMA,
++ TOK_EQUAL,
++ TOK_COLON,
++ TOK_SEMICOLON,
++ TOK_CONST,
++ TOK_STRUCT,
++ TOK_UNION,
++ TOK_SWITCH,
++ TOK_CASE,
++ TOK_DEFAULT,
++ TOK_ENUM,
++ TOK_TYPEDEF,
++ TOK_INT,
++ TOK_SHORT,
++ TOK_INT32,
++ TOK_UNSIGNED,
++ TOK_FLOAT,
++ TOK_DOUBLE,
++ TOK_OPAQUE,
++ TOK_CHAR,
++ TOK_STRING,
++ TOK_BOOL,
++ TOK_VOID,
++ TOK_PROGRAM,
++ TOK_VERSION,
++ TOK_EOF
++};
++typedef enum tok_kind tok_kind;
++
++/*
++ * a token
++ */
++struct token {
++ tok_kind kind;
++ char *str;
++};
++typedef struct token token;
++
++
++/*
++ * routine interface
++ */
++void scan();
++void scan2();
++void scan3();
++void scan_num();
++void peek();
++int peekscan();
++void get_token();
++void expected1(tok_kind);
++void expected2(tok_kind, tok_kind);
++void expected3(tok_kind, tok_kind, tok_kind);
++
+diff --git a/rpcgen/rpc_svcout.c b/rpcgen/rpc_svcout.c
+new file mode 100644
+index 0000000..284a529
+--- /dev/null
++++ b/rpcgen/rpc_svcout.c
+@@ -0,0 +1,882 @@
++/*
++ * Copyright (c) 2009, Sun Microsystems, Inc.
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are met:
++ * - Redistributions of source code must retain the above copyright notice,
++ * this list of conditions and the following disclaimer.
++ * - Redistributions in binary form must reproduce the above copyright notice,
++ * this list of conditions and the following disclaimer in the documentation
++ * and/or other materials provided with the distribution.
++ * - Neither the name of Sun Microsystems, Inc. nor the names of its
++ * contributors may be used to endorse or promote products derived
++ * from this software without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++
++#if 0
++ static char sccsid[] = "@(#)rpc_svcout.c 1.29 89/03/30 (C) 1987 SMI";
++#endif
++
++/*
++ * rpc_svcout.c, Server-skeleton outputter for the RPC protocol compiler
++ */
++#include <stdio.h>
++#include <string.h>
++#include "rpc_parse.h"
++#include "rpc_util.h"
++#include "rpc_output.h"
++
++static void write_real_program(definition *def);
++static void write_program(definition *def, char *storage);
++static void printerr(char *err, char *transp);
++static void printif(char *proc, char *transp, char *prefix, char *arg);
++static void write_inetmost(char *infile);
++static void print_return(char *space);
++static void print_pmapunset(char *space);
++static void print_err_message(char *space);
++static void write_timeout_func(void);
++static void write_pm_most(char *infile, int netflag);
++static void write_rpc_svc_fg(char *infile, char *sp);
++static void open_log_file(char *infile, char *sp);
++
++static char RQSTP[] = "rqstp";
++static char TRANSP[] = "transp";
++static char ARG[] = "argument";
++static char RESULT[] = "result";
++static char ROUTINE[] = "local";
++
++char _errbuf[256]; /* For all messages */
++
++static void
++p_xdrfunc(char *rname, char *typename)
++{
++ if (Cflag)
++ f_print(fout, "\t\txdr_%s = (xdrproc_t) xdr_%s;\n", rname,
++ stringfix(typename));
++ else
++ f_print(fout, "\t\txdr_%s = xdr_%s;\n", rname, stringfix(typename));
++}
++
++void
++internal_proctype(proc_list *plist)
++{
++ f_print(fout, "static ");
++ ptype( plist->res_prefix, plist->res_type, 1 );
++ f_print( fout, "*" );
++}
++
++
++/*
++ * write most of the service, that is, everything but the registrations.
++ */
++void
++write_most(char *infile, int netflag, int nomain)
++{
++ if (inetdflag || pmflag) {
++ char* var_type;
++ var_type = (nomain? "extern" : "static");
++ f_print(fout, "%s int _rpcpmstart;", var_type );
++ f_print(fout, "\t\t/* Started by a port monitor ? */\n");
++ f_print(fout, "%s int _rpcfdtype;", var_type );
++ f_print(fout, "\t\t/* Whether Stream or Datagram ? */\n");
++ if (timerflag) {
++ f_print(fout, "%s int _rpcsvcdirty;", var_type );
++ f_print(fout, "\t/* Still serving ? */\n");
++ }
++ write_svc_aux( nomain );
++ }
++ /* write out dispatcher and stubs */
++ write_programs( nomain? (char *)NULL : "static" );
++
++ if( nomain )
++ return;
++
++ f_print(fout, "\nmain()\n");
++ f_print(fout, "{\n");
++ if (inetdflag) {
++ write_inetmost(infile); /* Includes call to write_rpc_svc_fg() */
++ } else {
++ if( tirpcflag ) {
++ if (netflag) {
++ f_print(fout, "\tregister SVCXPRT *%s;\n", TRANSP);
++ f_print(fout, "\tstruct netconfig *nconf = NULL;\n");
++ }
++ f_print(fout, "\tpid_t pid;\n");
++ f_print(fout, "\tint i;\n");
++ f_print(fout, "\tchar mname[FMNAMESZ + 1];\n\n");
++ write_pm_most(infile, netflag);
++ f_print(fout, "\telse {\n");
++ write_rpc_svc_fg(infile, "\t\t");
++ f_print(fout, "\t}\n");
++ } else {
++ f_print(fout, "\tregister SVCXPRT *%s;\n", TRANSP);
++ f_print(fout, "\n");
++ print_pmapunset("\t");
++ }
++ }
++
++ if (logflag && !inetdflag) {
++ open_log_file(infile, "\t");
++ }
++}
++
++/*
++ * write a registration for the given transport
++ */
++void
++write_netid_register(char *transp)
++{
++ list *l;
++ definition *def;
++ version_list *vp;
++ char *sp;
++ char tmpbuf[32];
++
++ sp = "";
++ f_print(fout, "\n");
++ f_print(fout, "%s\tnconf = getnetconfigent(\"%s\");\n", sp, transp);
++ f_print(fout, "%s\tif (nconf == NULL) {\n", sp);
++ (void) sprintf(_errbuf, "cannot find %s netid.", transp);
++ sprintf(tmpbuf, "%s\t\t", sp);
++ print_err_message(tmpbuf);
++ f_print(fout, "%s\t\texit(1);\n", sp);
++ f_print(fout, "%s\t}\n", sp);
++ f_print(fout, "%s\t%s = svc_tli_create(RPC_ANYFD, nconf, 0, 0, 0);\n",
++ sp, TRANSP);
++ f_print(fout, "%s\tif (%s == NULL) {\n", sp, TRANSP);
++ (void) sprintf(_errbuf, "cannot create %s service.", transp);
++ print_err_message(tmpbuf);
++ f_print(fout, "%s\t\texit(1);\n", sp);
++ f_print(fout, "%s\t}\n", sp);
++
++ for (l = defined; l != NULL; l = l->next) {
++ def = (definition *) l->val;
++ if (def->def_kind != DEF_PROGRAM) {
++ continue;
++ }
++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
++ f_print(fout,
++ "%s\t(void) rpcb_unset(%s, %s, nconf);\n",
++ sp, def->def_name, vp->vers_name);
++ f_print(fout,
++ "%s\tif (!svc_reg(%s, %s, %s, ",
++ sp, TRANSP, def->def_name, vp->vers_name);
++ pvname(def->def_name, vp->vers_num);
++ f_print(fout, ", nconf)) {\n");
++ (void) sprintf(_errbuf, "unable to register (%s, %s, %s).",
++ def->def_name, vp->vers_name, transp);
++ print_err_message(tmpbuf);
++ f_print(fout, "%s\t\texit(1);\n", sp);
++ f_print(fout, "%s\t}\n", sp);
++ }
++ }
++ f_print(fout, "%s\tfreenetconfigent(nconf);\n", sp);
++}
++
++/*
++ * write a registration for the given transport for TLI
++ */
++void
++write_nettype_register(char *transp)
++{
++ list *l;
++ definition *def;
++ version_list *vp;
++
++ for (l = defined; l != NULL; l = l->next) {
++ def = (definition *) l->val;
++ if (def->def_kind != DEF_PROGRAM) {
++ continue;
++ }
++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
++ f_print(fout, "\tif (!svc_create(");
++ pvname(def->def_name, vp->vers_num);
++ f_print(fout, ", %s, %s, \"%s\")) {\n ",
++ def->def_name, vp->vers_name, transp);
++ (void) sprintf(_errbuf,
++ "unable to create (%s, %s) for %s.",
++ def->def_name, vp->vers_name, transp);
++ print_err_message("\t\t");
++ f_print(fout, "\t\texit(1);\n");
++ f_print(fout, "\t}\n");
++ }
++ }
++}
++
++/*
++ * write the rest of the service
++ */
++void
++write_rest(void)
++{
++ f_print(fout, "\n");
++ if (inetdflag) {
++ f_print(fout, "\tif (%s == (SVCXPRT *)NULL) {\n", TRANSP);
++ (void) sprintf(_errbuf, "could not create a handle");
++ print_err_message("\t\t");
++ f_print(fout, "\t\texit(1);\n");
++ f_print(fout, "\t}\n");
++ if (timerflag) {
++ f_print(fout, "\tif (_rpcpmstart) {\n");
++ f_print(fout,
++ "\t\t(void) signal(SIGALRM, %s closedown);\n",
++ Cflag? "(SIG_PF)" : "(void(*)())" );
++ f_print(fout, "\t\t(void) alarm(_RPCSVC_CLOSEDOWN);\n");
++ f_print(fout, "\t}\n");
++ }
++ }
++ f_print(fout, "\tsvc_run();\n");
++ (void) sprintf(_errbuf, "svc_run returned");
++ print_err_message("\t");
++ f_print(fout, "\texit(1);\n");
++ f_print(fout, "\t/* NOTREACHED */\n");
++ f_print(fout, "}\n");
++}
++
++void
++write_programs(char *storage)
++{
++ list *l;
++ definition *def;
++
++ /* write out stubs for procedure definitions */
++ for (l = defined; l != NULL; l = l->next) {
++ def = (definition *) l->val;
++ if (def->def_kind == DEF_PROGRAM) {
++ write_real_program(def);
++ }
++ }
++
++ /* write out dispatcher for each program */
++ for (l = defined; l != NULL; l = l->next) {
++ def = (definition *) l->val;
++ if (def->def_kind == DEF_PROGRAM) {
++ write_program(def, storage);
++ }
++ }
++
++
++}
++
++/* write out definition of internal function (e.g. _printmsg_1(...))
++ which calls server's defintion of actual function (e.g. printmsg_1(...)).
++ Unpacks single user argument of printmsg_1 to call-by-value format
++ expected by printmsg_1. */
++static void
++write_real_program(definition *def)
++{
++ version_list *vp;
++ proc_list *proc;
++ decl_list *l;
++
++ if( !newstyle ) return; /* not needed for old style */
++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
++ for (proc = vp->procs; proc != NULL; proc = proc->next) {
++ f_print(fout, "\n");
++ internal_proctype(proc);
++ f_print(fout, "\n_");
++ pvname(proc->proc_name, vp->vers_num);
++ if( Cflag ) {
++ f_print(fout, "(" );
++ /* arg name */
++ if (proc->arg_num > 1)
++ f_print(fout, proc->args.argname);
++ else
++ ptype(proc->args.decls->decl.prefix,
++ proc->args.decls->decl.type, 0);
++ f_print(fout, " *argp, struct svc_req *%s)\n",
++ RQSTP);
++ } else {
++ f_print(fout, "(argp, %s)\n", RQSTP );
++ /* arg name */
++ if (proc->arg_num > 1)
++ f_print(fout, "\t%s *argp;\n", proc->args.argname);
++ else {
++ f_print(fout, "\t");
++ ptype(proc->args.decls->decl.prefix,
++ proc->args.decls->decl.type, 0);
++ f_print(fout, " *argp;\n");
++ }
++ f_print(fout, " struct svc_req *%s;\n", RQSTP);
++ }
++
++ f_print(fout, "{\n");
++ f_print(fout, "\treturn(");
++ if( Cflag )
++ pvname_svc(proc->proc_name, vp->vers_num);
++ else
++ pvname(proc->proc_name, vp->vers_num);
++ f_print(fout, "(");
++ if (proc->arg_num < 2) { /* single argument */
++ if (!streq( proc->args.decls->decl.type, "void"))
++ f_print(fout, "*argp, "); /* non-void */
++ } else {
++ for (l = proc->args.decls; l != NULL; l = l->next)
++ f_print(fout, "argp->%s, ", l->decl.name);
++ }
++ f_print(fout, "%s));\n}\n", RQSTP);
++ }
++ }
++}
++
++static void
++write_program(definition *def, char *storage)
++{
++ version_list *vp;
++ proc_list *proc;
++ int filled;
++
++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
++ f_print(fout, "\n");
++ if (storage != NULL) {
++ f_print(fout, "%s ", storage);
++ }
++ f_print(fout, "void\n");
++ pvname(def->def_name, vp->vers_num);
++
++ if (Cflag) {
++ f_print(fout, "(struct svc_req *%s, ", RQSTP);
++ f_print(fout, "register SVCXPRT *%s)\n", TRANSP);
++ } else {
++ f_print(fout, "(%s, %s)\n", RQSTP, TRANSP);
++ f_print(fout, " struct svc_req *%s;\n", RQSTP);
++ f_print(fout, " register SVCXPRT *%s;\n", TRANSP);
++ }
++
++ f_print(fout, "{\n");
++
++ filled = 0;
++ f_print(fout, "\tunion {\n");
++ for (proc = vp->procs; proc != NULL; proc = proc->next) {
++ if (proc->arg_num < 2) { /* single argument */
++ if (streq(proc->args.decls->decl.type,
++ "void")) {
++ continue;
++ }
++ filled = 1;
++ f_print(fout, "\t\t");
++ ptype(proc->args.decls->decl.prefix,
++ proc->args.decls->decl.type, 0);
++ pvname(proc->proc_name, vp->vers_num);
++ f_print(fout, "_arg;\n");
++
++ }
++ else {
++ filled = 1;
++ f_print(fout, "\t\t%s", proc->args.argname);
++ f_print(fout, " ");
++ pvname(proc->proc_name, vp->vers_num);
++ f_print(fout, "_arg;\n");
++ }
++ }
++ if (!filled) {
++ f_print(fout, "\t\tint fill;\n");
++ }
++ f_print(fout, "\t} %s;\n", ARG);
++ f_print(fout, "\tchar *%s;\n", RESULT);
++
++ if (Cflag) {
++ f_print(fout, "\txdrproc_t xdr_%s, xdr_%s;\n", ARG, RESULT);
++ f_print(fout,
++ "\tchar *(*%s)(char *, struct svc_req *);\n",
++ ROUTINE);
++ } else {
++ f_print(fout, "\tbool_t (*xdr_%s)(), (*xdr_%s)();\n", ARG, RESULT);
++ f_print(fout, "\tchar *(*%s)();\n", ROUTINE);
++ }
++
++ f_print(fout, "\n");
++
++ if (timerflag)
++ f_print(fout, "\t_rpcsvcdirty = 1;\n");
++ f_print(fout, "\tswitch (%s->rq_proc) {\n", RQSTP);
++ if (!nullproc(vp->procs)) {
++ f_print(fout, "\tcase NULLPROC:\n");
++ f_print(fout,
++ "\t\t(void) svc_sendreply(%s, (xdrproc_t) xdr_void, (char *)NULL);\n",
++ TRANSP);
++ print_return("\t\t");
++ f_print(fout, "\n");
++ }
++ for (proc = vp->procs; proc != NULL; proc = proc->next) {
++ f_print(fout, "\tcase %s:\n", proc->proc_name);
++ if (proc->arg_num < 2) { /* single argument */
++ p_xdrfunc( ARG, proc->args.decls->decl.type);
++ } else {
++ p_xdrfunc( ARG, proc->args.argname);
++ }
++ p_xdrfunc( RESULT, proc->res_type);
++ if( Cflag )
++ f_print(fout,
++ "\t\t%s = (char *(*)(char *, struct svc_req *)) ",
++ ROUTINE);
++ else
++ f_print(fout, "\t\t%s = (char *(*)()) ", ROUTINE);
++
++ if (newstyle) { /* new style: calls internal routine */
++ f_print(fout,"_");
++ }
++ /* Not sure about the following...
++ * rpc_hout always generates foobar_1_svc for
++ * the service procedure, so why should we use
++ * foobar_1 here?! --okir */
++#if 0
++ if( Cflag && !newstyle )
++ pvname_svc(proc->proc_name, vp->vers_num);
++ else
++ pvname(proc->proc_name, vp->vers_num);
++#else
++ pvname_svc(proc->proc_name, vp->vers_num);
++#endif
++ f_print(fout, ";\n");
++ f_print(fout, "\t\tbreak;\n\n");
++ }
++ f_print(fout, "\tdefault:\n");
++ printerr("noproc", TRANSP);
++ print_return("\t\t");
++ f_print(fout, "\t}\n");
++
++ f_print(fout, "\t(void) memset((char *)&%s, 0, sizeof (%s));\n", ARG, ARG);
++ if (Cflag)
++ printif("getargs", TRANSP, "(caddr_t) &", ARG);
++ else
++ printif("getargs", TRANSP, "&", ARG);
++ printerr("decode", TRANSP);
++ print_return("\t\t");
++ f_print(fout, "\t}\n");
++
++ if (Cflag)
++ f_print(fout, "\t%s = (*%s)((char *)&%s, %s);\n",
++ RESULT, ROUTINE, ARG, RQSTP);
++ else
++ f_print(fout, "\t%s = (*%s)(&%s, %s);\n",
++ RESULT, ROUTINE, ARG, RQSTP);
++ f_print(fout,
++ "\tif (%s != NULL && !svc_sendreply(%s, "
++ "(xdrproc_t) xdr_%s, %s)) {\n",
++ RESULT, TRANSP, RESULT, RESULT);
++ printerr("systemerr", TRANSP);
++ f_print(fout, "\t}\n");
++
++ if (Cflag)
++ printif("freeargs", TRANSP, "(caddr_t) &", ARG);
++ else
++ printif("freeargs", TRANSP, "&", ARG);
++ (void) sprintf(_errbuf, "unable to free arguments");
++ print_err_message("\t\t");
++ f_print(fout, "\t\texit(1);\n");
++ f_print(fout, "\t}\n");
++ print_return("\t");
++ f_print(fout, "}\n");
++ }
++}
++
++static void
++printerr(char *err, char *transp)
++{
++ f_print(fout, "\t\tsvcerr_%s(%s);\n", err, transp);
++}
++
++static void
++printif(char *proc, char *transp, char *prefix, char *arg)
++{
++ f_print(fout, "\tif (!svc_%s(%s, (xdrproc_t) xdr_%s, (caddr_t) %s%s)) {\n",
++ proc, transp, arg, prefix, arg);
++}
++
++int
++nullproc(proc_list *proc)
++{
++ for (; proc != NULL; proc = proc->next) {
++ if (streq(proc->proc_num, "0")) {
++ return (1);
++ }
++ }
++ return (0);
++}
++
++static void
++write_inetmost(char *infile)
++{
++ f_print(fout, "\tregister SVCXPRT *%s;\n", TRANSP);
++ f_print(fout, "\tint sock;\n");
++ f_print(fout, "\tint proto;\n");
++ f_print(fout, "\tstruct sockaddr_in saddr;\n");
++ f_print(fout, "\tint asize = sizeof (saddr);\n");
++ f_print(fout, "\n");
++ f_print(fout,
++ "\tif (getsockname(0, (struct sockaddr *)&saddr, &asize) == 0) {\n");
++ f_print(fout, "\t\tint ssize = sizeof (int);\n\n");
++ f_print(fout, "\t\tif (saddr.sin_family != AF_INET)\n");
++ f_print(fout, "\t\t\texit(1);\n");
++ f_print(fout, "\t\tif (getsockopt(0, SOL_SOCKET, SO_TYPE,\n");
++ f_print(fout, "\t\t\t\t(char *)&_rpcfdtype, &ssize) == -1)\n");
++ f_print(fout, "\t\t\texit(1);\n");
++ f_print(fout, "\t\tsock = 0;\n");
++ f_print(fout, "\t\t_rpcpmstart = 1;\n");
++ f_print(fout, "\t\tproto = 0;\n");
++ open_log_file(infile, "\t\t");
++ f_print(fout, "\t} else {\n");
++ write_rpc_svc_fg(infile, "\t\t");
++ f_print(fout, "\t\tsock = RPC_ANYSOCK;\n");
++ print_pmapunset("\t\t");
++ f_print(fout, "\t}\n");
++}
++
++static void
++print_return(char *space)
++{
++ if (exitnow)
++ f_print(fout, "%sexit(0);\n", space);
++ else {
++ if (timerflag)
++ f_print(fout, "%s_rpcsvcdirty = 0;\n", space);
++ f_print(fout, "%sreturn;\n", space);
++ }
++}
++
++static void
++print_pmapunset(char *space)
++{
++ list *l;
++ definition *def;
++ version_list *vp;
++
++ for (l = defined; l != NULL; l = l->next) {
++ def = (definition *) l->val;
++ if (def->def_kind == DEF_PROGRAM) {
++ for (vp = def->def.pr.versions; vp != NULL;
++ vp = vp->next) {
++ f_print(fout, "%s(void) pmap_unset(%s, %s);\n",
++ space, def->def_name, vp->vers_name);
++ }
++ }
++ }
++}
++
++static void
++print_err_message(char *space)
++{
++ if (logflag)
++ f_print(fout, "%ssyslog(LOG_ERR, \"%s\");\n", space, _errbuf);
++ else if (inetdflag || pmflag)
++ f_print(fout, "%s_msgout(\"%s\");\n", space, _errbuf);
++ else
++ f_print(fout, "%sfprintf(stderr, \"%s\");\n", space, _errbuf);
++}
++
++/*
++ * Write the server auxiliary function ( _msgout, timeout)
++ */
++void
++write_svc_aux(int nomain)
++{
++ if (!logflag)
++ write_msg_out();
++ if( !nomain )
++ write_timeout_func();
++}
++
++/*
++ * Write the _msgout function
++ */
++void
++write_msg_out(void)
++{
++ f_print(fout, "\n");
++ f_print(fout, "static\n");
++ if( !Cflag ) {
++ f_print(fout, "void _msgout(msg)\n");
++ f_print(fout, "\tchar *msg;\n");
++ } else {
++ f_print(fout, "void _msgout(char* msg)\n");
++ }
++ f_print(fout, "{\n");
++ f_print(fout, "#ifdef RPC_SVC_FG\n");
++ if (inetdflag || pmflag)
++ f_print(fout, "\tif (_rpcpmstart)\n");
++ f_print(fout, "\t\tsyslog(LOG_ERR, \"%%s\", msg);\n");
++ f_print(fout, "\telse\n");
++ f_print(fout, "\t\t(void) fprintf(stderr, \"%%s\\n\", msg);\n");
++ f_print(fout, "#else\n");
++ f_print(fout, "\tsyslog(LOG_ERR, \"%%s\", msg);\n");
++ f_print(fout, "#endif\n");
++ f_print(fout, "}\n");
++}
++
++/*
++ * Write the timeout function
++ */
++static void
++write_timeout_func(void)
++{
++ if (!timerflag)
++ return;
++ f_print(fout, "\n");
++ f_print(fout, "static void\n");
++ f_print(fout, "closedown()\n");
++ f_print(fout, "{\n");
++ f_print(fout, "\tif (_rpcsvcdirty == 0) {\n");
++ f_print(fout, "\t\tstatic int size;\n");
++ f_print(fout, "\t\tint i, openfd;\n");
++ if (tirpcflag && pmflag) {
++ f_print(fout, "\t\tstruct t_info tinfo;\n\n");
++ f_print(fout, "\t\tif (!t_getinfo(0, &tinfo) && (tinfo.servtype == T_CLTS))\n");
++ } else {
++ f_print(fout, "\n\t\tif (_rpcfdtype == SOCK_DGRAM)\n");
++ }
++ f_print(fout, "\t\t\texit(0);\n");
++ f_print(fout, "\t\tif (size == 0) {\n");
++ if( tirpcflag ) {
++ f_print(fout, "\t\t\tstruct rlimit rl;\n\n");
++ f_print(fout, "\t\t\trl.rlim_max = 0;\n");
++ f_print(fout, "\t\t\tgetrlimit(RLIMIT_NOFILE, &rl);\n");
++ f_print(fout, "\t\t\tif ((size = rl.rlim_max) == 0)\n");
++ f_print(fout, "\t\t\t\treturn;\n");
++ } else {
++ f_print(fout, "\t\t\tsize = getdtablesize();\n");
++ }
++ f_print(fout, "\t\t}\n");
++ f_print(fout, "\t\tfor (i = 0, openfd = 0; i < size && openfd < 2; i++)\n");
++ f_print(fout, "\t\t\tif (FD_ISSET(i, &svc_fdset))\n");
++ f_print(fout, "\t\t\t\topenfd++;\n");
++ f_print(fout, "\t\tif (openfd <= 1)\n");
++ f_print(fout, "\t\t\texit(0);\n");
++ f_print(fout, "\t}\n");
++ f_print(fout, "\t(void) alarm(_RPCSVC_CLOSEDOWN);\n");
++ f_print(fout, "}\n");
++}
++
++/*
++ * Write the most of port monitor support
++ */
++static void
++write_pm_most(char *infile, int netflag)
++{
++ list *l;
++ definition *def;
++ version_list *vp;
++
++ f_print(fout, "\tif (!ioctl(0, I_LOOK, mname) &&\n");
++ f_print(fout, "\t\t(!strcmp(mname, \"sockmod\") ||");
++ f_print(fout, " !strcmp(mname, \"timod\"))) {\n");
++ f_print(fout, "\t\tchar *netid;\n");
++ if (!netflag) { /* Not included by -n option */
++ f_print(fout, "\t\tstruct netconfig *nconf = NULL;\n");
++ f_print(fout, "\t\tSVCXPRT *%s;\n", TRANSP);
++ }
++ if( timerflag )
++ f_print(fout, "\t\tint pmclose;\n");
++/* not necessary, defined in /usr/include/stdlib */
++/* f_print(fout, "\t\textern char *getenv();\n");*/
++ f_print(fout, "\n");
++ f_print(fout, "\t\t_rpcpmstart = 1;\n");
++ if (logflag)
++ open_log_file(infile, "\t\t");
++ f_print(fout, "\t\tif ((netid = getenv(\"NLSPROVIDER\")) == NULL) {\n");
++ sprintf(_errbuf, "cannot get transport name");
++ print_err_message("\t\t\t");
++ f_print(fout, "\t\t} else if ((nconf = getnetconfigent(netid)) == NULL) {\n");
++ sprintf(_errbuf, "cannot get transport info");
++ print_err_message("\t\t\t");
++ f_print(fout, "\t\t}\n");
++ /*
++ * A kludgy support for inetd services. Inetd only works with
++ * sockmod, and RPC works only with timod, hence all this jugglery
++ */
++ f_print(fout, "\t\tif (strcmp(mname, \"sockmod\") == 0) {\n");
++ f_print(fout, "\t\t\tif (ioctl(0, I_POP, 0) || ioctl(0, I_PUSH, \"timod\")) {\n");
++ sprintf(_errbuf, "could not get the right module");
++ print_err_message("\t\t\t\t");
++ f_print(fout, "\t\t\t\texit(1);\n");
++ f_print(fout, "\t\t\t}\n");
++ f_print(fout, "\t\t}\n");
++ if( timerflag )
++ f_print(fout, "\t\tpmclose = (t_getstate(0) != T_DATAXFER);\n");
++ f_print(fout, "\t\tif ((%s = svc_tli_create(0, nconf, NULL, 0, 0)) == NULL) {\n",
++ TRANSP);
++ sprintf(_errbuf, "cannot create server handle");
++ print_err_message("\t\t\t");
++ f_print(fout, "\t\t\texit(1);\n");
++ f_print(fout, "\t\t}\n");
++ f_print(fout, "\t\tif (nconf)\n");
++ f_print(fout, "\t\t\tfreenetconfigent(nconf);\n");
++ for (l = defined; l != NULL; l = l->next) {
++ def = (definition *) l->val;
++ if (def->def_kind != DEF_PROGRAM) {
++ continue;
++ }
++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
++ f_print(fout,
++ "\t\tif (!svc_reg(%s, %s, %s, ",
++ TRANSP, def->def_name, vp->vers_name);
++ pvname(def->def_name, vp->vers_num);
++ f_print(fout, ", 0)) {\n");
++ (void) sprintf(_errbuf, "unable to register (%s, %s).",
++ def->def_name, vp->vers_name);
++ print_err_message("\t\t\t");
++ f_print(fout, "\t\t\texit(1);\n");
++ f_print(fout, "\t\t}\n");
++ }
++ }
++ if (timerflag) {
++ f_print(fout, "\t\tif (pmclose) {\n");
++ f_print(fout, "\t\t\t(void) signal(SIGALRM, %s closedown);\n",
++ Cflag? "(SIG_PF)" : "(void(*)())" );
++ f_print(fout, "\t\t\t(void) alarm(_RPCSVC_CLOSEDOWN);\n");
++ f_print(fout, "\t\t}\n");
++ }
++ f_print(fout, "\t\tsvc_run();\n");
++ f_print(fout, "\t\texit(1);\n");
++ f_print(fout, "\t\t/* NOTREACHED */\n");
++ f_print(fout, "\t}\n");
++}
++
++/*
++ * Support for backgrounding the server if self started.
++ */
++static void
++write_rpc_svc_fg(char *infile, char *sp)
++{
++ f_print(fout, "#ifndef RPC_SVC_FG\n");
++ f_print(fout, "%sint size;\n", sp);
++ if( tirpcflag )
++ f_print(fout, "%sstruct rlimit rl;\n", sp);
++ if (inetdflag)
++ f_print(fout, "%sint pid, i;\n\n", sp);
++ f_print(fout, "%spid = fork();\n", sp);
++ f_print(fout, "%sif (pid < 0) {\n", sp);
++ f_print(fout, "%s\tperror(\"cannot fork\");\n", sp);
++ f_print(fout, "%s\texit(1);\n", sp);
++ f_print(fout, "%s}\n", sp);
++ f_print(fout, "%sif (pid)\n", sp);
++ f_print(fout, "%s\texit(0);\n", sp);
++ /* get number of file descriptors */
++ if( tirpcflag ) {
++ f_print(fout, "%srl.rlim_max = 0;\n", sp);
++ f_print(fout, "%sgetrlimit(RLIMIT_NOFILE, &rl);\n", sp);
++ f_print(fout, "%sif ((size = rl.rlim_max) == 0)\n", sp);
++ f_print(fout, "%s\texit(1);\n", sp);
++ } else {
++ f_print(fout, "%ssize = getdtablesize();\n", sp);
++ }
++
++ f_print(fout, "%sfor (i = 0; i < size; i++)\n", sp);
++ f_print(fout, "%s\t(void) close(i);\n", sp);
++ /* Redirect stderr and stdout to console */
++ f_print(fout, "%si = open(\"/dev/console\", 2);\n", sp);
++ f_print(fout, "%s(void) dup2(i, 1);\n", sp);
++ f_print(fout, "%s(void) dup2(i, 2);\n", sp);
++ /* This removes control of the controlling terminal */
++ if( tirpcflag )
++ f_print(fout, "%ssetsid();\n", sp);
++ else {
++ f_print(fout, "%si = open(\"/dev/tty\", 2);\n", sp);
++ f_print(fout, "%sif (i >= 0) {\n", sp);
++ f_print(fout, "%s\t(void) ioctl(i, TIOCNOTTY, (char *)NULL);\n", sp);;
++ f_print(fout, "%s\t(void) close(i);\n", sp);
++ f_print(fout, "%s}\n", sp);
++ }
++ if (!logflag)
++ open_log_file(infile, sp);
++ f_print(fout, "#endif\n");
++ if (logflag)
++ open_log_file(infile, sp);
++}
++
++static void
++open_log_file(char *infile, char *sp)
++{
++ char *s;
++
++ s = strrchr(infile, '.');
++ if (s)
++ *s = '\0';
++ f_print(fout,"%sopenlog(\"%s\", LOG_PID, LOG_DAEMON);\n", sp, infile);
++ if (s)
++ *s = '.';
++}
++
++
++
++
++/*
++ * write a registration for the given transport for Inetd
++ */
++void
++write_inetd_register(char *transp)
++{
++ list *l;
++ definition *def;
++ version_list *vp;
++ char *sp;
++ int isudp;
++ char tmpbuf[32];
++
++ if (inetdflag)
++ sp = "\t";
++ else
++ sp = "";
++ if (streq(transp, "udp"))
++ isudp = 1;
++ else
++ isudp = 0;
++ f_print(fout, "\n");
++ if (inetdflag) {
++ f_print(fout, "\tif ((_rpcfdtype == 0) || (_rpcfdtype == %s)) {\n",
++ isudp ? "SOCK_DGRAM" : "SOCK_STREAM");
++ }
++ f_print(fout, "%s\t%s = svc%s_create(%s",
++ sp, TRANSP, transp, inetdflag? "sock": "RPC_ANYSOCK");
++ if (!isudp)
++ f_print(fout, ", 0, 0");
++ f_print(fout, ");\n");
++ f_print(fout, "%s\tif (%s == NULL) {\n", sp, TRANSP);
++ (void) sprintf(_errbuf, "cannot create %s service.", transp);
++ (void) sprintf(tmpbuf, "%s\t\t", sp);
++ print_err_message(tmpbuf);
++ f_print(fout, "%s\t\texit(1);\n", sp);
++ f_print(fout, "%s\t}\n", sp);
++
++ if (inetdflag) {
++ f_print(fout, "%s\tif (!_rpcpmstart)\n\t", sp);
++ f_print(fout, "%s\tproto = IPPROTO_%s;\n",
++ sp, isudp ? "UDP": "TCP");
++ }
++ for (l = defined; l != NULL; l = l->next) {
++ def = (definition *) l->val;
++ if (def->def_kind != DEF_PROGRAM) {
++ continue;
++ }
++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
++ f_print(fout, "%s\tif (!svc_register(%s, %s, %s, ",
++ sp, TRANSP, def->def_name, vp->vers_name);
++ pvname(def->def_name, vp->vers_num);
++ if (inetdflag)
++ f_print(fout, ", proto)) {\n");
++ else
++ f_print(fout, ", IPPROTO_%s)) {\n",
++ isudp ? "UDP": "TCP");
++ (void) sprintf(_errbuf, "unable to register (%s, %s, %s).",
++ def->def_name, vp->vers_name, transp);
++ print_err_message(tmpbuf);
++ f_print(fout, "%s\t\texit(1);\n", sp);
++ f_print(fout, "%s\t}\n", sp);
++ }
++ }
++ if (inetdflag)
++ f_print(fout, "\t}\n");
++}
+diff --git a/rpcgen/rpc_tblout.c b/rpcgen/rpc_tblout.c
+new file mode 100644
+index 0000000..ae002f7
+--- /dev/null
++++ b/rpcgen/rpc_tblout.c
+@@ -0,0 +1,165 @@
++/*
++ * Copyright (c) 2009, Sun Microsystems, Inc.
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are met:
++ * - Redistributions of source code must retain the above copyright notice,
++ * this list of conditions and the following disclaimer.
++ * - Redistributions in binary form must reproduce the above copyright notice,
++ * this list of conditions and the following disclaimer in the documentation
++ * and/or other materials provided with the distribution.
++ * - Neither the name of Sun Microsystems, Inc. nor the names of its
++ * contributors may be used to endorse or promote products derived
++ * from this software without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++
++#if 0
++static char sccsid[] = "@(#)rpc_tblout.c 1.4 89/02/22 (C) 1988 SMI";
++#endif
++
++/*
++ * rpc_tblout.c, Dispatch table outputter for the RPC protocol compiler
++ */
++#include <stdio.h>
++#include <string.h>
++#include "rpc_parse.h"
++#include "rpc_util.h"
++#include "rpc_output.h"
++
++static void write_table(definition *def);
++static void printit(char *prefix, char *type);
++
++#define TABSIZE 8
++#define TABCOUNT 5
++#define TABSTOP (TABSIZE*TABCOUNT)
++
++static char tabstr[TABCOUNT+1] = "\t\t\t\t\t";
++
++static char tbl_hdr[] = "struct rpcgen_table %s_table[] = {\n";
++static char tbl_end[] = "};\n";
++
++static char null_entry[] = "\n\t(char *(*)())0,\n\
++ \t(xdrproc_t) xdr_void,\t\t\t0,\n\
++ \t(xdrproc_t) xdr_void,\t\t\t0,\n";
++
++
++static char tbl_nproc[] = "int %s_nproc =\n\tsizeof(%s_table)/sizeof(%s_table[0]);\n\n";
++
++void
++write_tables(void)
++{
++ list *l;
++ definition *def;
++
++ f_print(fout, "\n");
++ for (l = defined; l != NULL; l = l->next) {
++ def = (definition *) l->val;
++ if (def->def_kind == DEF_PROGRAM) {
++ write_table(def);
++ }
++ }
++}
++
++static void
++write_table(definition *def)
++{
++ version_list *vp;
++ proc_list *proc;
++ int current;
++ int expected;
++ char progvers[100];
++ int warning;
++
++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
++ warning = 0;
++ s_print(progvers, "%s_%s",
++ locase(def->def_name), vp->vers_num);
++ /* print the table header */
++ f_print(fout, tbl_hdr, progvers);
++
++ if (nullproc(vp->procs)) {
++ expected = 0;
++ } else {
++ expected = 1;
++ f_print(fout, null_entry);
++ }
++ for (proc = vp->procs; proc != NULL; proc = proc->next) {
++ current = atoi(proc->proc_num);
++ if (current != expected++) {
++ f_print(fout,
++ "\n/*\n * WARNING: table out of order\n */\n");
++ if (warning == 0) {
++ f_print(stderr,
++ "WARNING %s table is out of order\n",
++ progvers);
++ warning = 1;
++ nonfatalerrors = 1;
++ }
++ expected = current + 1;
++ }
++ f_print(fout, "\n\t(char *(*)())RPCGEN_ACTION(");
++
++ /* routine to invoke */
++ if( Cflag && !newstyle )
++ pvname_svc(proc->proc_name, vp->vers_num);
++ else {
++ if( newstyle )
++ f_print( fout, "_"); /* calls internal func */
++ pvname(proc->proc_name, vp->vers_num);
++ }
++ f_print(fout, "),\n");
++
++ /* argument info */
++ if( proc->arg_num > 1 )
++ printit((char*) NULL, proc->args.argname );
++ else
++ /* do we have to do something special for newstyle */
++ printit( proc->args.decls->decl.prefix,
++ proc->args.decls->decl.type );
++ /* result info */
++ printit(proc->res_prefix, proc->res_type);
++ }
++
++ /* print the table trailer */
++ f_print(fout, tbl_end);
++ f_print(fout, tbl_nproc, progvers, progvers, progvers);
++ }
++}
++
++static void
++printit(char *prefix, char *type)
++{
++ int len;
++ int tabs;
++
++
++ len = fprintf(fout, "\txdr_%s,", stringfix(type));
++ /* account for leading tab expansion */
++ len += TABSIZE - 1;
++ /* round up to tabs required */
++ tabs = (TABSTOP - len + TABSIZE - 1)/TABSIZE;
++ f_print(fout, "%s", &tabstr[TABCOUNT-tabs]);
++
++ if (streq(type, "void")) {
++ f_print(fout, "0");
++ } else {
++ f_print(fout, "sizeof ( ");
++ /* XXX: should "follow" be 1 ??? */
++ ptype(prefix, type, 0);
++ f_print(fout, ")");
++ }
++ f_print(fout, ",\n");
++}
+diff --git a/rpcgen/rpc_util.c b/rpcgen/rpc_util.c
+new file mode 100644
+index 0000000..b67be57
+--- /dev/null
++++ b/rpcgen/rpc_util.c
+@@ -0,0 +1,479 @@
++/*
++ * Copyright (c) 2009, Sun Microsystems, Inc.
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are met:
++ * - Redistributions of source code must retain the above copyright notice,
++ * this list of conditions and the following disclaimer.
++ * - Redistributions in binary form must reproduce the above copyright notice,
++ * this list of conditions and the following disclaimer in the documentation
++ * and/or other materials provided with the distribution.
++ * - Neither the name of Sun Microsystems, Inc. nor the names of its
++ * contributors may be used to endorse or promote products derived
++ * from this software without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++
++#if 0
++static char sccsid[] = "@(#)rpc_util.c 1.11 89/02/22 (C) 1987 SMI";
++#endif
++
++/*
++ * rpc_util.c, Utility routines for the RPC protocol compiler
++ */
++#include <stdio.h>
++#include <memory.h>
++#include <ctype.h>
++#include <unistd.h>
++#include "rpc_scan.h"
++#include "rpc_parse.h"
++#include "rpc_util.h"
++
++static void printwhere(void);
++
++
++#define ARGEXT "argument"
++
++char curline[MAXLINESIZE]; /* current read line */
++char *where = curline; /* current point in line */
++int linenum = 0; /* current line number */
++
++char *infilename; /* input filename */
++
++#define NFILES 7
++char *outfiles[NFILES]; /* output file names */
++int nfiles;
++
++FILE *fout; /* file pointer of current output */
++FILE *fin; /* file pointer of current input */
++
++list *defined; /* list of defined things */
++
++/*
++ * Reinitialize the world
++ */
++void
++reinitialize(void)
++{
++ memset(curline, 0, MAXLINESIZE);
++ where = curline;
++ linenum = 0;
++ defined = NULL;
++}
++
++/*
++ * string equality
++ */
++int
++streq(char *a, char *b)
++{
++ return (strcmp(a, b) == 0);
++}
++
++/*
++ * find a value in a list
++ */
++definition *
++findval(list *lst, char *val, int (*cmp)(definition *, char *))
++{
++
++ for (; lst != NULL; lst = lst->next) {
++ if ((*cmp) (lst->val, val)) {
++ return (lst->val);
++ }
++ }
++ return (NULL);
++}
++
++/*
++ * store a value in a list
++ */
++void
++storeval(lstp, val)
++ list **lstp;
++ definition *val;
++{
++ list **l;
++ list *lst;
++
++
++ for (l = lstp; *l != NULL; l = (list **) & (*l)->next);
++ lst = ALLOC(list);
++ lst->val = val;
++ lst->next = NULL;
++ *l = lst;
++}
++
++static int
++findit(definition *def, char *type)
++{
++ return (streq(def->def_name, type));
++}
++
++static char *
++fixit(char *type, char *orig)
++{
++ definition *def;
++
++ def = (definition *) FINDVAL(defined, type, findit);
++ if (def == NULL || def->def_kind != DEF_TYPEDEF) {
++ return (orig);
++ }
++ switch (def->def.ty.rel) {
++ case REL_VECTOR:
++ return (def->def.ty.old_type);
++ case REL_ALIAS:
++ return (fixit(def->def.ty.old_type, orig));
++ default:
++ return (orig);
++ }
++}
++
++char *
++fixtype(char *type)
++{
++ return (fixit(type, type));
++}
++
++char *
++stringfix(char *type)
++{
++ if (streq(type, "string")) {
++ return ("wrapstring");
++ } else {
++ return (type);
++ }
++}
++
++void
++ptype(char *prefix, char *type, int follow)
++{
++ if (prefix != NULL) {
++ if (streq(prefix, "enum")) {
++ f_print(fout, "enum ");
++ } else {
++ f_print(fout, "struct ");
++ }
++ }
++ if (streq(type, "bool")) {
++ f_print(fout, "bool_t ");
++ } else if (streq(type, "string")) {
++ f_print(fout, "char *");
++ } else {
++ f_print(fout, "%s ", follow ? fixtype(type) : type);
++ }
++}
++
++static int
++typedefed(definition *def, char *type)
++{
++ if (def->def_kind != DEF_TYPEDEF || def->def.ty.old_prefix != NULL) {
++ return (0);
++ } else {
++ return (streq(def->def_name, type));
++ }
++}
++
++int
++isvectordef(char *type, relation rel)
++{
++ definition *def;
++
++ for (;;) {
++ switch (rel) {
++ case REL_VECTOR:
++ return (!streq(type, "string"));
++ case REL_ARRAY:
++ return (0);
++ case REL_POINTER:
++ return (0);
++ case REL_ALIAS:
++ def = (definition *) FINDVAL(defined, type, typedefed);
++ if (def == NULL) {
++ return (0);
++ }
++ type = def->def.ty.old_type;
++ rel = def->def.ty.rel;
++ }
++ }
++}
++
++char *
++locase(char *str)
++{
++ char c;
++ static char buf[100];
++ char *p = buf;
++
++ while ((c = *str++) != '\0') {
++ *p++ = (c >= 'A' && c <= 'Z') ? (c - 'A' + 'a') : c;
++ }
++ *p = 0;
++ return (buf);
++}
++
++void
++pvname_svc(char *pname, char *vnum)
++{
++ f_print(fout, "%s_%s_svc", locase(pname), vnum);
++}
++
++void
++pvname(char *pname, char *vnum)
++{
++ f_print(fout, "%s_%s", locase(pname), vnum);
++}
++
++/*
++ * print a useful (?) error message, and then die
++ */
++void
++error(char *msg)
++{
++ printwhere();
++ f_print(stderr, "%s, line %d: ", infilename, linenum);
++ f_print(stderr, "%s\n", msg);
++ crash();
++}
++
++/*
++ * Something went wrong, unlink any files that we may have created and then
++ * die.
++ */
++void
++crash(void)
++{
++ int i;
++
++ for (i = 0; i < nfiles; i++) {
++ (void) unlink(outfiles[i]);
++ }
++ exit(1);
++}
++
++void
++record_open(char *file)
++{
++ if (nfiles < NFILES) {
++ outfiles[nfiles++] = file;
++ } else {
++ f_print(stderr, "too many files!\n");
++ crash();
++ }
++}
++
++static char expectbuf[100];
++static char *toktostr();
++
++/*
++ * error, token encountered was not the expected one
++ */
++void
++expected1(exp1)
++ tok_kind exp1;
++{
++ s_print(expectbuf, "expected '%s'",
++ toktostr(exp1));
++ error(expectbuf);
++}
++
++/*
++ * error, token encountered was not one of two expected ones
++ */
++void
++expected2(exp1, exp2)
++ tok_kind exp1, exp2;
++{
++ s_print(expectbuf, "expected '%s' or '%s'",
++ toktostr(exp1),
++ toktostr(exp2));
++ error(expectbuf);
++}
++
++/*
++ * error, token encountered was not one of 3 expected ones
++ */
++void
++expected3(exp1, exp2, exp3)
++ tok_kind exp1, exp2, exp3;
++{
++ s_print(expectbuf, "expected '%s', '%s' or '%s'",
++ toktostr(exp1),
++ toktostr(exp2),
++ toktostr(exp3));
++ error(expectbuf);
++}
++
++void
++tabify(f, tab)
++ FILE *f;
++ int tab;
++{
++ while (tab--) {
++ (void) fputc('\t', f);
++ }
++}
++
++
++static token tokstrings[] = {
++ {TOK_IDENT, "identifier"},
++ {TOK_CONST, "const"},
++ {TOK_RPAREN, ")"},
++ {TOK_LPAREN, "("},
++ {TOK_RBRACE, "}"},
++ {TOK_LBRACE, "{"},
++ {TOK_LBRACKET, "["},
++ {TOK_RBRACKET, "]"},
++ {TOK_STAR, "*"},
++ {TOK_COMMA, ","},
++ {TOK_EQUAL, "="},
++ {TOK_COLON, ":"},
++ {TOK_SEMICOLON, ";"},
++ {TOK_UNION, "union"},
++ {TOK_STRUCT, "struct"},
++ {TOK_SWITCH, "switch"},
++ {TOK_CASE, "case"},
++ {TOK_DEFAULT, "default"},
++ {TOK_ENUM, "enum"},
++ {TOK_TYPEDEF, "typedef"},
++ {TOK_INT, "int"},
++ {TOK_SHORT, "short"},
++ {TOK_INT32, "int32"},
++ {TOK_UNSIGNED, "unsigned"},
++ {TOK_DOUBLE, "double"},
++ {TOK_FLOAT, "float"},
++ {TOK_CHAR, "char"},
++ {TOK_STRING, "string"},
++ {TOK_OPAQUE, "opaque"},
++ {TOK_BOOL, "bool"},
++ {TOK_VOID, "void"},
++ {TOK_PROGRAM, "program"},
++ {TOK_VERSION, "version"},
++ {TOK_EOF, "??????"}
++};
++
++static char *
++toktostr(kind)
++ tok_kind kind;
++{
++ token *sp;
++
++ for (sp = tokstrings; sp->kind != TOK_EOF && sp->kind != kind; sp++);
++ return (sp->str);
++}
++
++static void
++printbuf(void)
++{
++ char c;
++ int i;
++ int cnt;
++
++# define TABSIZE 4
++
++ for (i = 0; (c = curline[i]) != '\0'; i++) {
++ if (c == '\t') {
++ cnt = 8 - (i % TABSIZE);
++ c = ' ';
++ } else {
++ cnt = 1;
++ }
++ while (cnt--) {
++ (void) fputc(c, stderr);
++ }
++ }
++}
++
++static void
++printwhere(void)
++{
++ int i;
++ char c;
++ int cnt;
++
++ printbuf();
++ for (i = 0; i < where - curline; i++) {
++ c = curline[i];
++ if (c == '\t') {
++ cnt = 8 - (i % TABSIZE);
++ } else {
++ cnt = 1;
++ }
++ while (cnt--) {
++ (void) fputc('^', stderr);
++ }
++ }
++ (void) fputc('\n', stderr);
++}
++
++char *
++make_argname(char *pname, char *vname)
++{
++ char *name;
++
++ name = malloc(strlen(pname) + strlen(vname) + strlen(ARGEXT) + 3);
++ if (!name) {
++ fprintf(stderr, "failed in malloc");
++ exit(1);
++ }
++ sprintf(name, "%s_%s_%s", locase(pname), vname, ARGEXT);
++ return(name);
++}
++
++bas_type *typ_list_h;
++bas_type *typ_list_t;
++
++void
++add_type(int len, char *type)
++{
++ bas_type *ptr;
++
++
++ if ((ptr = (bas_type *) malloc(sizeof(bas_type))) == (bas_type *) NULL) {
++ fprintf(stderr, "failed in malloc");
++ exit(1);
++ }
++ ptr->name = type;
++ ptr->length = len;
++ ptr->next = NULL;
++ if (typ_list_t == NULL) {
++
++ typ_list_t = ptr;
++ typ_list_h = ptr;
++ } else {
++
++ typ_list_t->next = ptr;
++ typ_list_t = ptr;
++ }
++}
++
++
++bas_type *
++find_type(char *type)
++{
++ bas_type *ptr;
++
++ ptr = typ_list_h;
++
++
++ while (ptr != NULL) {
++ if (strcmp(ptr->name, type) == 0)
++ return (ptr);
++ else
++ ptr = ptr->next;
++ };
++ return (NULL);
++}
++
+diff --git a/rpcgen/rpc_util.h b/rpcgen/rpc_util.h
+new file mode 100644
+index 0000000..fa115be
+--- /dev/null
++++ b/rpcgen/rpc_util.h
+@@ -0,0 +1,166 @@
++/*
++ * Copyright (c) 2009, Sun Microsystems, Inc.
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are met:
++ * - Redistributions of source code must retain the above copyright notice,
++ * this list of conditions and the following disclaimer.
++ * - Redistributions in binary form must reproduce the above copyright notice,
++ * this list of conditions and the following disclaimer in the documentation
++ * and/or other materials provided with the distribution.
++ * - Neither the name of Sun Microsystems, Inc. nor the names of its
++ * contributors may be used to endorse or promote products derived
++ * from this software without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++
++/* @(#)rpc_util.h 1.5 90/08/29 (C) 1987 SMI */
++
++/*
++ * rpc_util.h, Useful definitions for the RPC protocol compiler
++ */
++
++#include <stdlib.h>
++
++#define alloc(size) malloc((unsigned)(size))
++#define ALLOC(object) (object *) malloc(sizeof(object))
++
++#define s_print (void) sprintf
++#define f_print (void) fprintf
++
++struct list {
++ definition *val;
++ struct list *next;
++};
++typedef struct list list;
++
++#define PUT 1
++#define GET 2
++
++/*
++ * Global variables
++ */
++#define MAXLINESIZE 1024
++extern char curline[MAXLINESIZE];
++extern char *where;
++extern int linenum;
++
++extern char *infilename;
++extern FILE *fout;
++extern FILE *fin;
++
++extern list *defined;
++
++
++extern bas_type *typ_list_h;
++extern bas_type *typ_list_t;
++
++/*
++ * All the option flags
++ */
++extern int inetdflag;
++extern int pmflag;
++extern int tblflag;
++extern int logflag;
++extern int newstyle;
++extern int Cflag; /* C++ flag */
++extern int tirpcflag; /* flag for generating tirpc code */
++extern int Inline; /* if this is 0, then do not generate inline code */
++
++/*
++ * Other flags related with inetd jumpstart.
++ */
++extern int indefinitewait;
++extern int exitnow;
++extern int timerflag;
++
++extern int nonfatalerrors;
++
++/*
++ * rpc_util routines
++ */
++void storeval();
++
++#define STOREVAL(list,item) \
++ storeval(list,item)
++
++definition *findval();
++
++#define FINDVAL(list,item,finder) \
++ findval(list, item, finder)
++
++
++/*
++ * rpc_cout routines
++ */
++void cprint(void);
++void emit(definition *);
++
++/*
++ * rpc_hout routines
++ */
++void print_datadef(definition *);
++void print_funcdef(definition *);
++
++/*
++ * rpc_svcout routines
++ */
++void write_most(char *, int, int);
++void write_register(void);
++void write_netid_register(char *);
++void write_nettype_register(char *);
++void write_inetd_register(char *);
++void write_rest(void);
++void write_programs(char *);
++void write_svc_aux(int);
++
++/*
++ * rpc_clntout routines
++ */
++void write_stubs(void);
++void printarglist(proc_list *, char *, char *);
++
++/*
++ * rpc_tblout routines
++ */
++void write_tables(void);
++
++/*
++ * rpc_util
++ */
++void pvname_svc(char *, char *);
++void pvname(char *, char *);
++void ptype(char *, char *, int);
++char * make_argname(char *, char *);
++void add_type(int, char *);
++void reinitialize(void);
++void crash(void);
++void error(char *);
++char *fixtype(char *);
++char *stringfix(char *);
++char *locase(char *);
++int isvectordef(char *, relation);
++int streq(char *, char *);
++void tabify(FILE *, int);
++void record_open(char *);
++bas_type *find_type(char *type);
++
++/*
++ * rpc_sample
++ */
++void write_sample_svc(definition *);
++int write_sample_clnt(definition *);
++void write_sample_clnt_main(void);
++void add_sample_msg(void);
+diff --git a/rpcgen/rpcgen.1 b/rpcgen/rpcgen.1
+new file mode 100644
+index 0000000..89df7ed
+--- /dev/null
++++ b/rpcgen/rpcgen.1
+@@ -0,0 +1,521 @@
++.\" @(#)rpcgen.1 1.35 93/06/02 SMI
++.\" $FreeBSD: src/usr.bin/rpcgen/rpcgen.1,v 1.12.2.4 2002/06/21 15:28:50 charnier Exp $
++.\" Copyright 1985-1993 Sun Microsystems, Inc.
++.Dd March 28, 1993
++.Dt RPCGEN 1
++.Os
++.Sh NAME
++.Nm rpcgen
++.Nd an RPC protocol compiler
++.Sh SYNOPSIS
++.Nm
++.Ar infile
++.Nm
++.Op Fl a
++.Op Fl b
++.Op Fl C
++.Oo
++.Fl D Ns Ar name Ns Op Ar =value
++.Oc
++.Op Fl i Ar size
++.Op Fl I Op Fl K Ar seconds
++.Op Fl L
++.Op Fl M
++.Op Fl N
++.Op Fl T
++.Op Fl Y Ar pathname
++.Ar infile
++.Nm
++.Oo
++.Fl c |
++.Fl h |
++.Fl l |
++.Fl m |
++.Fl t |
++.Fl \&Sc |
++.Fl \&Ss |
++.Fl \&Sm
++.Oc
++.Op Fl o Ar outfile
++.Op Ar infile
++.Nm
++.Op Fl s Ar nettype
++.Op Fl o Ar outfile
++.Op Ar infile
++.Nm
++.Op Fl n Ar netid
++.Op Fl o Ar outfile
++.Op Ar infile
++.\" .SH AVAILABILITY
++.\" .LP
++.\" SUNWcsu
++.Sh DESCRIPTION
++The
++.Nm
++utility is a tool that generates C code to implement an
++.Tn RPC
++protocol.
++The input to
++.Nm
++is a language similar to C known as
++.Tn RPC
++Language (Remote Procedure Call Language).
++.Pp
++The
++.Nm
++utility is normally used as in the first synopsis where
++it takes an input file and generates three output files.
++If the
++.Ar infile
++is named
++.Pa proto.x ,
++then
++.Nm
++generates a header in
++.Pa proto.h ,
++XDR routines in
++.Pa proto_xdr.c ,
++server-side stubs in
++.Pa proto_svc.c ,
++and client-side stubs in
++.Pa proto_clnt.c .
++With the
++.Fl T
++option,
++it also generates the
++.Tn RPC
++dispatch table in
++.Pa proto_tbl.i .
++.Pp
++The
++.Nm
++utility can also generate sample client and server files
++that can be customized to suit a particular application.
++The
++.Fl \&Sc ,
++.Fl \&Ss
++and
++.Fl \&Sm
++options generate sample client, server and makefile, respectively.
++The
++.Fl a
++option generates all files, including sample files.
++If the
++.Ar infile
++is
++.Pa proto.x ,
++then the client side sample file is written to
++.Pa proto_client.c ,
++the server side sample file to
++.Pa proto_server.c
++and the sample makefile to
++.Pa makefile.proto .
++.Pp
++The server created can be started both by the port monitors
++(for example,
++.Xr inetd 8 )
++or by itself.
++When it is started by a port monitor,
++it creates servers only for the transport for which
++the file descriptor
++.Em 0
++was passed.
++The name of the transport must be specified
++by setting up the environment variable
++.Ev PM_TRANSPORT .
++When the server generated by
++.Nm
++is executed,
++it creates server handles for all the transports
++specified in
++.Ev NETPATH
++environment variable,
++or if it is unset,
++it creates server handles for all the visible transports from
++.Pa /etc/netconfig
++file.
++Note:
++the transports are chosen at run time and not at compile time.
++When the server is self-started,
++it backgrounds itself by default.
++A special define symbol
++.Em RPC_SVC_FG
++can be used to run the server process in foreground.
++.Pp
++The second synopsis provides special features which allow
++for the creation of more sophisticated
++.Tn RPC
++servers.
++These features include support for user provided
++.Em #defines
++and
++.Tn RPC
++dispatch tables.
++The entries in the
++.Tn RPC
++dispatch table contain:
++.Bl -bullet -offset indent -compact
++.It
++pointers to the service routine corresponding to that procedure,
++.It
++a pointer to the input and output arguments,
++.It
++the size of these routines.
++.El
++A server can use the dispatch table to check authorization
++and then to execute the service routine;
++a client library may use it to deal with the details of storage
++management and XDR data conversion.
++.Pp
++The other three synopses shown above are used when
++one does not want to generate all the output files,
++but only a particular one.
++See the
++.Sx EXAMPLES
++section below for examples of
++.Nm
++usage.
++When
++.Nm
++is executed with the
++.Fl s
++option,
++it creates servers for that particular class of transports.
++When
++executed with the
++.Fl n
++option,
++it creates a server for the transport specified by
++.Ar netid .
++If
++.Ar infile
++is not specified,
++.Nm
++accepts the standard input.
++.Pp
++The C preprocessor,
++.Em cc -E
++is run on the input file before it is actually interpreted by
++.Nm .
++For each type of output file,
++.Nm
++defines a special preprocessor symbol for use by the
++.Nm
++programmer:
++.Bl -tag -width indent
++.It RPC_HDR
++defined when compiling into headers
++.It RPC_XDR
++defined when compiling into XDR routines
++.It RPC_SVC
++defined when compiling into server-side stubs
++.It RPC_CLNT
++defined when compiling into client-side stubs
++.It RPC_TBL
++defined when compiling into RPC dispatch tables
++.El
++.Pp
++Any line beginning with
++.Dq %
++is passed directly into the output file,
++uninterpreted by
++.Nm .
++To specify the path name of the C preprocessor use
++.Fl Y
++flag.
++.Pp
++For every data type referred to in
++.Ar infile ,
++.Nm
++assumes that there exists a
++routine with the string
++.Em xdr_
++prepended to the name of the data type.
++If this routine does not exist in the
++.Tn RPC/XDR
++library, it must be provided.
++Providing an undefined data type
++allows customization of
++.Xr xdr 3
++routines.
++.Sh OPTIONS
++The following options are available:
++.Bl -tag -width indent
++.It Fl a
++Generate all files, including sample files.
++.It Fl b
++Backward compatibility mode.
++Generate transport specific
++.Tn RPC
++code for older versions
++of the operating system.
++.Pp
++Note: in
++.Fx ,
++this compatibility flag is turned on by
++default since
++.Fx
++supports only the older
++.Tn ONC RPC
++library.
++.It Fl c
++Compile into
++.Tn XDR
++routines.
++.It Fl C
++Generate header and stub files which can be used with
++.Tn ANSI
++C compilers. Headers generated with this flag can also be
++used with C++ programs.
++.It Fl D Ns Ar name
++.It Fl D Ns Ar name=value
++.\".It Fl D Ns Ar name Ns Op Ar =value
++Define a symbol
++.Ar name .
++Equivalent to the
++.Em #define
++directive in the source.
++If no
++.Ar value
++is given,
++.Ar value
++is defined as
++.Em 1 .
++This option may be specified more than once.
++.It Fl h
++Compile into C data-definitions (a header).
++.Fl T
++option can be used in conjunction to produce a
++header which supports
++.Tn RPC
++dispatch tables.
++.It Fl i Ar size
++Size at which to start generating inline code.
++This option is useful for optimization.
++The default size is 5.
++.Pp
++Note: in order to provide backwards compatibility with the older
++.Nm
++on the
++.Fx
++platform, the default is actually 0 (which means
++that inline code generation is disabled by default). You must specify
++a non-zero value explicitly to override this default.
++.It Fl I
++Compile support for
++.Xr inetd 8
++in the server side stubs.
++Such servers can be self-started or can be started by
++.Nm inetd .
++When the server is self-started, it backgrounds itself by default.
++A special define symbol
++.Em RPC_SVC_FG
++can be used to run the
++server process in foreground, or the user may simply compile without
++the
++.Fl I
++option.
++.Pp
++If there are no pending client requests, the
++.Nm inetd
++servers exit after 120 seconds (default).
++The default can be changed with the
++.Fl K
++option.
++All the error messages for
++.Nm inetd
++servers
++are always logged with
++.Xr syslog 3 .
++.\" .IP
++.\" Note:
++.\" this option is supported for backward compatibility only.
++.\" By default,
++.\" .B rpcgen
++.\" generates servers that can be invoked through portmonitors.
++.Pp
++.It Fl K Ar seconds
++By default, services created using
++.Nm
++and invoked through
++port monitors wait 120 seconds
++after servicing a request before exiting.
++That interval can be changed using the
++.Fl K
++flag.
++To create a server that exits immediately upon servicing a request,
++use
++.Fl K Ar 0 .
++To create a server that never exits, the appropriate argument is
++.Fl k Ar -1 .
++.Pp
++When monitoring for a server,
++some portmonitors
++.Em always
++spawn a new process in response to a service request.
++If it is known that a server will be used with such a monitor, the
++server should exit immediately on completion.
++For such servers,
++.Nm
++should be used with
++.Fl K Ar 0 .
++.It Fl l
++Compile into client-side stubs.
++.It Fl L
++When the servers are started in foreground, use
++.Xr syslog 3
++to log the server errors instead of printing them on the standard
++error.
++.It Fl m
++Compile into server-side stubs,
++but do not generate a
++.Qq main
++routine.
++This option is useful for doing callback-routines
++and for users who need to write their own
++.Qq main
++routine to do initialization.
++.It Fl M
++Generate multithread-safe stubs for passing arguments and results between
++rpcgen generated code and user written code.
++This option is useful
++for users who want to use threads in their code.
++However, the
++.Xr rpc_svc_calls 3
++functions are not yet MT-safe, which means that rpcgen generated server-side
++code will not be MT-safe.
++.It Fl N
++This option allows procedures to have multiple arguments.
++It also uses the style of parameter passing that closely resembles C.
++So, when passing an argument to a remote procedure, you do not have to
++pass a pointer to the argument, but can pass the argument itself.
++This behavior is different from the old style of
++.Nm
++generated code.
++To maintain backward compatibility,
++this option is not the default.
++.It Fl n Ar netid
++Compile into server-side stubs for the transport
++specified by
++.Ar netid .
++There should be an entry for
++.Ar netid
++in the
++netconfig database.
++This option may be specified more than once,
++so as to compile a server that serves multiple transports.
++.It Fl o Ar outfile
++Specify the name of the output file.
++If none is specified,
++standard output is used
++(
++.Fl c ,
++.Fl h ,
++.Fl l ,
++.Fl m ,
++.Fl n ,
++.Fl s ,
++.Fl \&Sc ,
++.Fl \&Sm ,
++.Fl \&Ss ,
++and
++.Fl t
++modes only).
++.It Fl s Ar nettype
++Compile into server-side stubs for all the
++transports belonging to the class
++.Ar nettype .
++The supported classes are
++.Em netpath ,
++.Em visible ,
++.Em circuit_n ,
++.Em circuit_v ,
++.Em datagram_n ,
++.Em datagram_v ,
++.Em tcp ,
++and
++.Em udp
++(see
++.Xr rpc 3
++for the meanings associated with these classes).
++This option may be specified more than once.
++Note:
++the transports are chosen at run time and not at compile time.
++.It Fl \&Sc
++Generate sample client code that uses remote procedure calls.
++.It Fl \&Sm
++Generate a sample
++.Pa Makefile
++which can be used for compiling the application.
++.It Fl \&Ss
++Generate sample server code that uses remote procedure calls.
++.It Fl t
++Compile into
++.Tn RPC
++dispatch table.
++.It Fl T
++Generate the code to support
++.Tn RPC
++dispatch tables.
++.Pp
++The options
++.Fl c ,
++.Fl h ,
++.Fl l ,
++.Fl m ,
++.Fl s ,
++.Fl \&Sc ,
++.Fl \&Sm ,
++.Fl \&Ss ,
++and
++.Fl t
++are used exclusively to generate a particular type of file,
++while the options
++.Fl D
++and
++.Fl T
++are global and can be used with the other options.
++.It Fl Y Ar pathname
++Give the name of the directory where
++.Nm
++will start looking for the C-preprocessor.
++.El
++.Sh EXAMPLES
++The following example:
++.Dl example% rpcgen -T prot.x
++.Pp
++generates all the five files:
++.Pa prot.h ,
++.Pa prot_clnt.c ,
++.Pa prot_svc.c ,
++.Pa prot_xdr.c
++and
++.Pa prot_tbl.i .
++.Pp
++The following example sends the C data-definitions (header)
++to the standard output.
++.Dl example% rpcgen -h prot.x
++.Pp
++To send the test version of the
++.Fl D Ns Ar TEST ,
++server side stubs for
++all the transport belonging to the class
++.Ar datagram_n
++to standard output, use:
++.Dl example% rpcgen -s datagram_n -DTEST prot.x
++.Pp
++To create the server side stubs for the transport indicated
++by
++.Ar netid
++tcp,
++use:
++.Dl example% rpcgen -n tcp -o prot_svc.c prot.x
++.Sh SEE ALSO
++.Xr cc 1 ,
++.Xr rpc 3 ,
++.Xr syslog 3 ,
++.Xr inetd 8
++.\" .BR rpc_svc_calls (3)
++.Rs
++.%T The rpcgen chapter in the NETP manual
++.Re
+--
+2.0.0
+
--- /dev/null
+From 99ecb155efdfcf474c5701ab7e6ad1cbe88f500f Mon Sep 17 00:00:00 2001
+From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+Date: Sat, 10 Nov 2012 17:29:53 +0100
+Subject: [PATCH] Automatically generate XDR header files from .x sources using
+ rpcgen
+
+Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+---
+ Makefile.am | 22 +-
+ src/Makefile.am | 2 +-
+ tirpc/rpc/rpcb_prot.h | 797 --------------------------------------------------
+ tirpc/rpcsvc/crypt.h | 109 -------
+ 4 files changed, 20 insertions(+), 910 deletions(-)
+ delete mode 100644 tirpc/rpc/rpcb_prot.h
+ delete mode 100644 tirpc/rpcsvc/crypt.h
+
+diff --git a/Makefile.am b/Makefile.am
+index 6edf029..4e4dc32 100644
+--- a/Makefile.am
++++ b/Makefile.am
+@@ -1,6 +1,10 @@
+ SUBDIRS = src man doc rpcgen
+ ACLOCAL_AMFLAGS = -I m4
+
++GENFILES = \
++ tirpc/rpcsvc/crypt.h \
++ tirpc/rpc/rpcb_prot.h
++
+ noinst_HEADERS = tirpc/reentrant.h \
+ tirpc/getpeereid.h \
+ tirpc/libc_private.h \
+@@ -8,7 +12,6 @@ noinst_HEADERS = tirpc/reentrant.h \
+
+ nobase_include_HEADERS = tirpc/netconfig.h \
+ tirpc/rpcsvc/crypt.x \
+- tirpc/rpcsvc/crypt.h \
+ tirpc/rpc/xdr.h \
+ tirpc/rpc/types.h \
+ tirpc/rpc/svc_soc.h \
+@@ -20,7 +23,6 @@ nobase_include_HEADERS = tirpc/netconfig.h \
+ tirpc/rpc/rpcent.h \
+ tirpc/rpc/rpc_com.h \
+ tirpc/rpc/rpcb_prot.x \
+- tirpc/rpc/rpcb_prot.h \
+ tirpc/rpc/rpcb_clnt.h \
+ tirpc/rpc/raw.h \
+ tirpc/rpc/pmap_rmt.h \
+@@ -37,7 +39,21 @@ nobase_include_HEADERS = tirpc/netconfig.h \
+ tirpc/rpc/auth.h \
+ tirpc/rpc/auth_gss.h \
+ tirpc/rpc/auth_des.h
+-
++
++nobase_nodist_include_HEADERS = $(GENFILES)
++BUILT_SOURCES = $(GENFILES)
++
++$(GENFILES): %.h: %.x $(top_builddir)/rpcgen/rpcgen
++ mkdir -p $(dir $@)
++ $(top_builddir)/rpcgen/rpcgen -h -o $@ $<
++
++$(top_builddir)/rpcgen/rpcgen: force
++ cd rpcgen && $(MAKE)
++
++force:
++
++CLEANFILES = $(GENFILES)
++
+ pkgconfigdir=$(libdir)/pkgconfig
+ pkgconfig_DATA = libtirpc.pc
+
+diff --git a/src/Makefile.am b/src/Makefile.am
+index f086255..a9db71b 100644
+--- a/src/Makefile.am
++++ b/src/Makefile.am
+@@ -8,7 +8,7 @@
+ noinst_HEADERS = rpc_com.h
+
+ AM_CPPFLAGS = -I$(top_srcdir)/tirpc -DPORTMAP \
+- -D_GNU_SOURCE -Wall -pipe
++ -D_GNU_SOURCE -Wall -pipe -I$(top_builddir)/tirpc
+
+ lib_LTLIBRARIES = libtirpc.la
+
+diff --git a/tirpc/rpc/rpcb_prot.h b/tirpc/rpc/rpcb_prot.h
+deleted file mode 100644
+index 7ae48b8..0000000
+--- a/tirpc/rpc/rpcb_prot.h
++++ /dev/null
+@@ -1,797 +0,0 @@
+-/*
+- * Please do not edit this file.
+- * It was generated using rpcgen.
+- */
+-
+-#ifndef _RPCB_PROT_H_RPCGEN
+-#define _RPCB_PROT_H_RPCGEN
+-
+-#include <rpc/rpc.h>
+-
+-#ifndef IXDR_GET_INT32
+-#define IXDR_GET_INT32(buf) IXDR_GET_LONG((buf))
+-#endif
+-#ifndef IXDR_PUT_INT32
+-#define IXDR_PUT_INT32(buf, v) IXDR_PUT_LONG((buf), (v))
+-#endif
+-#ifndef IXDR_GET_U_INT32
+-#define IXDR_GET_U_INT32(buf) IXDR_GET_U_LONG((buf))
+-#endif
+-#ifndef IXDR_PUT_U_INT32
+-#define IXDR_PUT_U_INT32(buf, v) IXDR_PUT_U_LONG((buf), (v))
+-#endif
+-/*
+- * $FreeBSD: src/include/rpc/rpcb_prot.x,v 1.3 2002/03/13 10:29:06 obrien Exp $
+- *
+- * Copyright (c) 2009, Sun Microsystems, Inc.
+- * All rights reserved.
+- *
+- * Redistribution and use in source and binary forms, with or without
+- * modification, are permitted provided that the following conditions are met:
+- * - Redistributions of source code must retain the above copyright notice,
+- * this list of conditions and the following disclaimer.
+- * - Redistributions in binary form must reproduce the above copyright notice,
+- * this list of conditions and the following disclaimer in the documentation
+- * and/or other materials provided with the distribution.
+- * - Neither the name of Sun Microsystems, Inc. nor the names of its
+- * contributors may be used to endorse or promote products derived
+- * from this software without specific prior written permission.
+- *
+- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+- * POSSIBILITY OF SUCH DAMAGE.
+- */
+-/*
+- * Copyright (c) 1988 by Sun Microsystems, Inc.
+- */
+-/* from rpcb_prot.x */
+-
+-/* #pragma ident "@(#)rpcb_prot.x 1.5 94/04/29 SMI" */
+-
+-#ifndef _KERNEL
+-
+-
+-/*
+- * The following procedures are supported by the protocol in version 3:
+- *
+- * RPCBPROC_NULL() returns ()
+- * takes nothing, returns nothing
+- *
+- * RPCBPROC_SET(rpcb) returns (bool_t)
+- * TRUE is success, FALSE is failure. Registers the tuple
+- * [prog, vers, address, owner, netid].
+- * Finds out owner and netid information on its own.
+- *
+- * RPCBPROC_UNSET(rpcb) returns (bool_t)
+- * TRUE is success, FALSE is failure. Un-registers tuple
+- * [prog, vers, netid]. addresses is ignored.
+- * If netid is NULL, unregister all.
+- *
+- * RPCBPROC_GETADDR(rpcb) returns (string).
+- * 0 is failure. Otherwise returns the universal address where the
+- * triple [prog, vers, netid] is registered. Ignore address and owner.
+- *
+- * RPCBPROC_DUMP() RETURNS (rpcblist_ptr)
+- * used to dump the entire rpcbind maps
+- *
+- * RPCBPROC_CALLIT(rpcb_rmtcallargs)
+- * RETURNS (rpcb_rmtcallres);
+- * Calls the procedure on the remote machine. If it is not registered,
+- * this procedure is quiet; i.e. it does not return error information!!!
+- * This routine only passes null authentication parameters.
+- * It has no interface to xdr routines for RPCBPROC_CALLIT.
+- *
+- * RPCBPROC_GETTIME() returns (int).
+- * Gets the remote machines time
+- *
+- * RPCBPROC_UADDR2TADDR(strint) RETURNS (struct netbuf)
+- * Returns the netbuf address from universal address.
+- *
+- * RPCBPROC_TADDR2UADDR(struct netbuf) RETURNS (string)
+- * Returns the universal address from netbuf address.
+- *
+- * END OF RPCBIND VERSION 3 PROCEDURES
+- */
+-/*
+- * Except for RPCBPROC_CALLIT, the procedures above are carried over to
+- * rpcbind version 4. Those below are added or modified for version 4.
+- * NOTE: RPCBPROC_BCAST HAS THE SAME FUNCTIONALITY AND PROCEDURE NUMBER
+- * AS RPCBPROC_CALLIT.
+- *
+- * RPCBPROC_BCAST(rpcb_rmtcallargs)
+- * RETURNS (rpcb_rmtcallres);
+- * Calls the procedure on the remote machine. If it is not registered,
+- * this procedure IS quiet; i.e. it DOES NOT return error information!!!
+- * This routine should be used for broadcasting and nothing else.
+- *
+- * RPCBPROC_GETVERSADDR(rpcb) returns (string).
+- * 0 is failure. Otherwise returns the universal address where the
+- * triple [prog, vers, netid] is registered. Ignore address and owner.
+- * Same as RPCBPROC_GETADDR except that if the given version number
+- * is not available, the address is not returned.
+- *
+- * RPCBPROC_INDIRECT(rpcb_rmtcallargs)
+- * RETURNS (rpcb_rmtcallres);
+- * Calls the procedure on the remote machine. If it is not registered,
+- * this procedure is NOT quiet; i.e. it DOES return error information!!!
+- * as any normal application would expect.
+- *
+- * RPCBPROC_GETADDRLIST(rpcb) returns (rpcb_entry_list_ptr).
+- * Same as RPCBPROC_GETADDR except that it returns a list of all the
+- * addresses registered for the combination (prog, vers) (for all
+- * transports).
+- *
+- * RPCBPROC_GETSTAT(void) returns (rpcb_stat_byvers)
+- * Returns the statistics about the kind of requests received by rpcbind.
+- */
+-
+-/*
+- * A mapping of (program, version, network ID) to address
+- */
+-
+-struct rpcb {
+- rpcprog_t r_prog;
+- rpcvers_t r_vers;
+- char *r_netid;
+- char *r_addr;
+- char *r_owner;
+-};
+-typedef struct rpcb rpcb;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_rpcb(XDR *, rpcb*);
+-#elif __STDC__
+-extern bool_t xdr_rpcb(XDR *, rpcb*);
+-#else /* Old Style C */
+-bool_t xdr_rpcb();
+-#endif /* Old Style C */
+-
+-
+-typedef rpcb RPCB;
+-
+-
+-/*
+- * A list of mappings
+- *
+- * Below are two definitions for the rpcblist structure. This is done because
+- * xdr_rpcblist() is specified to take a struct rpcblist **, rather than a
+- * struct rpcblist * that rpcgen would produce. One version of the rpcblist
+- * structure (actually called rp__list) is used with rpcgen, and the other is
+- * defined only in the header file for compatibility with the specified
+- * interface.
+- */
+-
+-struct rp__list {
+- rpcb rpcb_map;
+- struct rp__list *rpcb_next;
+-};
+-typedef struct rp__list rp__list;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_rp__list(XDR *, rp__list*);
+-#elif __STDC__
+-extern bool_t xdr_rp__list(XDR *, rp__list*);
+-#else /* Old Style C */
+-bool_t xdr_rp__list();
+-#endif /* Old Style C */
+-
+-
+-typedef rp__list *rpcblist_ptr;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_rpcblist_ptr(XDR *, rpcblist_ptr*);
+-#elif __STDC__
+-extern bool_t xdr_rpcblist_ptr(XDR *, rpcblist_ptr*);
+-#else /* Old Style C */
+-bool_t xdr_rpcblist_ptr();
+-#endif /* Old Style C */
+-
+-
+-typedef struct rp__list rpcblist;
+-typedef struct rp__list RPCBLIST;
+-
+-#ifndef __cplusplus
+-struct rpcblist {
+- RPCB rpcb_map;
+- struct rpcblist *rpcb_next;
+-};
+-#endif
+-
+-#ifdef __cplusplus
+-extern "C" {
+-#endif
+-extern bool_t xdr_rpcblist(XDR *, rpcblist**);
+-#ifdef __cplusplus
+-}
+-#endif
+-
+-
+-/*
+- * Arguments of remote calls
+- */
+-
+-struct rpcb_rmtcallargs {
+- rpcprog_t prog;
+- rpcvers_t vers;
+- rpcproc_t proc;
+- struct {
+- u_int args_len;
+- char *args_val;
+- } args;
+-};
+-typedef struct rpcb_rmtcallargs rpcb_rmtcallargs;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_rpcb_rmtcallargs(XDR *, rpcb_rmtcallargs*);
+-#elif __STDC__
+-extern bool_t xdr_rpcb_rmtcallargs(XDR *, rpcb_rmtcallargs*);
+-#else /* Old Style C */
+-bool_t xdr_rpcb_rmtcallargs();
+-#endif /* Old Style C */
+-
+-
+-/*
+- * Client-side only representation of rpcb_rmtcallargs structure.
+- *
+- * The routine that XDRs the rpcb_rmtcallargs structure must deal with the
+- * opaque arguments in the "args" structure. xdr_rpcb_rmtcallargs() needs to
+- * be passed the XDR routine that knows the args' structure. This routine
+- * doesn't need to go over-the-wire (and it wouldn't make sense anyway) since
+- * the application being called already knows the args structure. So we use a
+- * different "XDR" structure on the client side, r_rpcb_rmtcallargs, which
+- * includes the args' XDR routine.
+- */
+-struct r_rpcb_rmtcallargs {
+- rpcprog_t prog;
+- rpcvers_t vers;
+- rpcproc_t proc;
+- struct {
+- u_int args_len;
+- char *args_val;
+- } args;
+- xdrproc_t xdr_args; /* encodes args */
+-};
+-
+-
+-/*
+- * Results of the remote call
+- */
+-
+-struct rpcb_rmtcallres {
+- char *addr;
+- struct {
+- u_int results_len;
+- char *results_val;
+- } results;
+-};
+-typedef struct rpcb_rmtcallres rpcb_rmtcallres;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_rpcb_rmtcallres(XDR *, rpcb_rmtcallres*);
+-#elif __STDC__
+-extern bool_t xdr_rpcb_rmtcallres(XDR *, rpcb_rmtcallres*);
+-#else /* Old Style C */
+-bool_t xdr_rpcb_rmtcallres();
+-#endif /* Old Style C */
+-
+-
+-/*
+- * Client-side only representation of rpcb_rmtcallres structure.
+- */
+-struct r_rpcb_rmtcallres {
+- char *addr;
+- struct {
+- u_int32_t results_len;
+- char *results_val;
+- } results;
+- xdrproc_t xdr_res; /* decodes results */
+-};
+-
+-/*
+- * rpcb_entry contains a merged address of a service on a particular
+- * transport, plus associated netconfig information. A list of rpcb_entrys
+- * is returned by RPCBPROC_GETADDRLIST. See netconfig.h for values used
+- * in r_nc_* fields.
+- */
+-
+-struct rpcb_entry {
+- char *r_maddr;
+- char *r_nc_netid;
+- u_int r_nc_semantics;
+- char *r_nc_protofmly;
+- char *r_nc_proto;
+-};
+-typedef struct rpcb_entry rpcb_entry;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_rpcb_entry(XDR *, rpcb_entry*);
+-#elif __STDC__
+-extern bool_t xdr_rpcb_entry(XDR *, rpcb_entry*);
+-#else /* Old Style C */
+-bool_t xdr_rpcb_entry();
+-#endif /* Old Style C */
+-
+-
+-/*
+- * A list of addresses supported by a service.
+- */
+-
+-struct rpcb_entry_list {
+- rpcb_entry rpcb_entry_map;
+- struct rpcb_entry_list *rpcb_entry_next;
+-};
+-typedef struct rpcb_entry_list rpcb_entry_list;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_rpcb_entry_list(XDR *, rpcb_entry_list*);
+-#elif __STDC__
+-extern bool_t xdr_rpcb_entry_list(XDR *, rpcb_entry_list*);
+-#else /* Old Style C */
+-bool_t xdr_rpcb_entry_list();
+-#endif /* Old Style C */
+-
+-
+-typedef rpcb_entry_list *rpcb_entry_list_ptr;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_rpcb_entry_list_ptr(XDR *, rpcb_entry_list_ptr*);
+-#elif __STDC__
+-extern bool_t xdr_rpcb_entry_list_ptr(XDR *, rpcb_entry_list_ptr*);
+-#else /* Old Style C */
+-bool_t xdr_rpcb_entry_list_ptr();
+-#endif /* Old Style C */
+-
+-
+-/*
+- * rpcbind statistics
+- */
+-
+-#define rpcb_highproc_2 RPCBPROC_CALLIT
+-#define rpcb_highproc_3 RPCBPROC_TADDR2UADDR
+-#define rpcb_highproc_4 RPCBPROC_GETSTAT
+-#define RPCBSTAT_HIGHPROC 13
+-#define RPCBVERS_STAT 3
+-#define RPCBVERS_4_STAT 2
+-#define RPCBVERS_3_STAT 1
+-#define RPCBVERS_2_STAT 0
+-
+-/* Link list of all the stats about getport and getaddr */
+-
+-struct rpcbs_addrlist {
+- rpcprog_t prog;
+- rpcvers_t vers;
+- int success;
+- int failure;
+- char *netid;
+- struct rpcbs_addrlist *next;
+-};
+-typedef struct rpcbs_addrlist rpcbs_addrlist;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_rpcbs_addrlist(XDR *, rpcbs_addrlist*);
+-#elif __STDC__
+-extern bool_t xdr_rpcbs_addrlist(XDR *, rpcbs_addrlist*);
+-#else /* Old Style C */
+-bool_t xdr_rpcbs_addrlist();
+-#endif /* Old Style C */
+-
+-
+-/* Link list of all the stats about rmtcall */
+-
+-struct rpcbs_rmtcalllist {
+- rpcprog_t prog;
+- rpcvers_t vers;
+- rpcproc_t proc;
+- int success;
+- int failure;
+- int indirect;
+- char *netid;
+- struct rpcbs_rmtcalllist *next;
+-};
+-typedef struct rpcbs_rmtcalllist rpcbs_rmtcalllist;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_rpcbs_rmtcalllist(XDR *, rpcbs_rmtcalllist*);
+-#elif __STDC__
+-extern bool_t xdr_rpcbs_rmtcalllist(XDR *, rpcbs_rmtcalllist*);
+-#else /* Old Style C */
+-bool_t xdr_rpcbs_rmtcalllist();
+-#endif /* Old Style C */
+-
+-
+-typedef int rpcbs_proc[RPCBSTAT_HIGHPROC];
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_rpcbs_proc(XDR *, rpcbs_proc);
+-#elif __STDC__
+-extern bool_t xdr_rpcbs_proc(XDR *, rpcbs_proc);
+-#else /* Old Style C */
+-bool_t xdr_rpcbs_proc();
+-#endif /* Old Style C */
+-
+-
+-typedef rpcbs_addrlist *rpcbs_addrlist_ptr;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_rpcbs_addrlist_ptr(XDR *, rpcbs_addrlist_ptr*);
+-#elif __STDC__
+-extern bool_t xdr_rpcbs_addrlist_ptr(XDR *, rpcbs_addrlist_ptr*);
+-#else /* Old Style C */
+-bool_t xdr_rpcbs_addrlist_ptr();
+-#endif /* Old Style C */
+-
+-
+-typedef rpcbs_rmtcalllist *rpcbs_rmtcalllist_ptr;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_rpcbs_rmtcalllist_ptr(XDR *, rpcbs_rmtcalllist_ptr*);
+-#elif __STDC__
+-extern bool_t xdr_rpcbs_rmtcalllist_ptr(XDR *, rpcbs_rmtcalllist_ptr*);
+-#else /* Old Style C */
+-bool_t xdr_rpcbs_rmtcalllist_ptr();
+-#endif /* Old Style C */
+-
+-
+-struct rpcb_stat {
+- rpcbs_proc info;
+- int setinfo;
+- int unsetinfo;
+- rpcbs_addrlist_ptr addrinfo;
+- rpcbs_rmtcalllist_ptr rmtinfo;
+-};
+-typedef struct rpcb_stat rpcb_stat;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_rpcb_stat(XDR *, rpcb_stat*);
+-#elif __STDC__
+-extern bool_t xdr_rpcb_stat(XDR *, rpcb_stat*);
+-#else /* Old Style C */
+-bool_t xdr_rpcb_stat();
+-#endif /* Old Style C */
+-
+-
+-/*
+- * One rpcb_stat structure is returned for each version of rpcbind
+- * being monitored.
+- */
+-
+-typedef rpcb_stat rpcb_stat_byvers[RPCBVERS_STAT];
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_rpcb_stat_byvers(XDR *, rpcb_stat_byvers);
+-#elif __STDC__
+-extern bool_t xdr_rpcb_stat_byvers(XDR *, rpcb_stat_byvers);
+-#else /* Old Style C */
+-bool_t xdr_rpcb_stat_byvers();
+-#endif /* Old Style C */
+-
+-
+-/*
+- * We don't define netbuf in RPCL, since it would contain structure member
+- * names that would conflict with the definition of struct netbuf in
+- * <tiuser.h>. Instead we merely declare the XDR routine xdr_netbuf() here,
+- * and implement it ourselves in rpc/rpcb_prot.c.
+- */
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_netbuf(XDR *, struct netbuf *);
+-
+-#else /* __STDC__ */
+-extern bool_t xdr_netbuf(XDR *, struct netbuf *);
+-
+-#endif
+-
+-#define RPCBVERS_3 RPCBVERS
+-#define RPCBVERS_4 RPCBVERS4
+-
+-#define _PATH_RPCBINDSOCK "/var/run/rpcbind.sock"
+-
+-#else /* ndef _KERNEL */
+-#ifdef __cplusplus
+-extern "C" {
+-#endif
+-
+-/*
+- * A mapping of (program, version, network ID) to address
+- */
+-struct rpcb {
+- rpcprog_t r_prog; /* program number */
+- rpcvers_t r_vers; /* version number */
+- char *r_netid; /* network id */
+- char *r_addr; /* universal address */
+- char *r_owner; /* owner of the mapping */
+-};
+-typedef struct rpcb RPCB;
+-
+-/*
+- * A list of mappings
+- */
+-struct rpcblist {
+- RPCB rpcb_map;
+- struct rpcblist *rpcb_next;
+-};
+-typedef struct rpcblist RPCBLIST;
+-typedef struct rpcblist *rpcblist_ptr;
+-
+-/*
+- * Remote calls arguments
+- */
+-struct rpcb_rmtcallargs {
+- rpcprog_t prog; /* program number */
+- rpcvers_t vers; /* version number */
+- rpcproc_t proc; /* procedure number */
+- u_int32_t arglen; /* arg len */
+- caddr_t args_ptr; /* argument */
+- xdrproc_t xdr_args; /* XDR routine for argument */
+-};
+-typedef struct rpcb_rmtcallargs rpcb_rmtcallargs;
+-
+-/*
+- * Remote calls results
+- */
+-struct rpcb_rmtcallres {
+- char *addr_ptr; /* remote universal address */
+- u_int32_t resultslen; /* results length */
+- caddr_t results_ptr; /* results */
+- xdrproc_t xdr_results; /* XDR routine for result */
+-};
+-typedef struct rpcb_rmtcallres rpcb_rmtcallres;
+-
+-struct rpcb_entry {
+- char *r_maddr;
+- char *r_nc_netid;
+- unsigned int r_nc_semantics;
+- char *r_nc_protofmly;
+- char *r_nc_proto;
+-};
+-typedef struct rpcb_entry rpcb_entry;
+-
+-/*
+- * A list of addresses supported by a service.
+- */
+-
+-struct rpcb_entry_list {
+- rpcb_entry rpcb_entry_map;
+- struct rpcb_entry_list *rpcb_entry_next;
+-};
+-typedef struct rpcb_entry_list rpcb_entry_list;
+-
+-typedef rpcb_entry_list *rpcb_entry_list_ptr;
+-
+-/*
+- * rpcbind statistics
+- */
+-
+-#define rpcb_highproc_2 RPCBPROC_CALLIT
+-#define rpcb_highproc_3 RPCBPROC_TADDR2UADDR
+-#define rpcb_highproc_4 RPCBPROC_GETSTAT
+-#define RPCBSTAT_HIGHPROC 13
+-#define RPCBVERS_STAT 3
+-#define RPCBVERS_4_STAT 2
+-#define RPCBVERS_3_STAT 1
+-#define RPCBVERS_2_STAT 0
+-
+-/* Link list of all the stats about getport and getaddr */
+-
+-struct rpcbs_addrlist {
+- rpcprog_t prog;
+- rpcvers_t vers;
+- int success;
+- int failure;
+- char *netid;
+- struct rpcbs_addrlist *next;
+-};
+-typedef struct rpcbs_addrlist rpcbs_addrlist;
+-
+-/* Link list of all the stats about rmtcall */
+-
+-struct rpcbs_rmtcalllist {
+- rpcprog_t prog;
+- rpcvers_t vers;
+- rpcproc_t proc;
+- int success;
+- int failure;
+- int indirect;
+- char *netid;
+- struct rpcbs_rmtcalllist *next;
+-};
+-typedef struct rpcbs_rmtcalllist rpcbs_rmtcalllist;
+-
+-typedef int rpcbs_proc[RPCBSTAT_HIGHPROC];
+-
+-typedef rpcbs_addrlist *rpcbs_addrlist_ptr;
+-
+-typedef rpcbs_rmtcalllist *rpcbs_rmtcalllist_ptr;
+-
+-struct rpcb_stat {
+- rpcbs_proc info;
+- int setinfo;
+- int unsetinfo;
+- rpcbs_addrlist_ptr addrinfo;
+- rpcbs_rmtcalllist_ptr rmtinfo;
+-};
+-typedef struct rpcb_stat rpcb_stat;
+-
+-/*
+- * One rpcb_stat structure is returned for each version of rpcbind
+- * being monitored.
+- */
+-
+-typedef rpcb_stat rpcb_stat_byvers[RPCBVERS_STAT];
+-
+-#ifdef __cplusplus
+-}
+-#endif
+-
+-#endif /* ndef _KERNEL */
+-
+-#define RPCBPROG ((u_int32_t)100000)
+-#define RPCBVERS ((u_int32_t)3)
+-
+-#ifdef __cplusplus
+-#define RPCBPROC_SET ((u_int32_t)1)
+-extern "C" bool_t * rpcbproc_set_3(rpcb *, CLIENT *);
+-extern "C" bool_t * rpcbproc_set_3_svc(rpcb *, struct svc_req *);
+-#define RPCBPROC_UNSET ((u_int32_t)2)
+-extern "C" bool_t * rpcbproc_unset_3(rpcb *, CLIENT *);
+-extern "C" bool_t * rpcbproc_unset_3_svc(rpcb *, struct svc_req *);
+-#define RPCBPROC_GETADDR ((u_int32_t)3)
+-extern "C" char ** rpcbproc_getaddr_3(rpcb *, CLIENT *);
+-extern "C" char ** rpcbproc_getaddr_3_svc(rpcb *, struct svc_req *);
+-#define RPCBPROC_DUMP ((u_int32_t)4)
+-extern "C" rpcblist_ptr * rpcbproc_dump_3(void *, CLIENT *);
+-extern "C" rpcblist_ptr * rpcbproc_dump_3_svc(void *, struct svc_req *);
+-#define RPCBPROC_CALLIT ((u_int32_t)5)
+-extern "C" rpcb_rmtcallres * rpcbproc_callit_3(rpcb_rmtcallargs *, CLIENT *);
+-extern "C" rpcb_rmtcallres * rpcbproc_callit_3_svc(rpcb_rmtcallargs *, struct svc_req *);
+-#define RPCBPROC_GETTIME ((u_int32_t)6)
+-extern "C" u_int * rpcbproc_gettime_3(void *, CLIENT *);
+-extern "C" u_int * rpcbproc_gettime_3_svc(void *, struct svc_req *);
+-#define RPCBPROC_UADDR2TADDR ((u_int32_t)7)
+-extern "C" struct netbuf * rpcbproc_uaddr2taddr_3(char **, CLIENT *);
+-extern "C" struct netbuf * rpcbproc_uaddr2taddr_3_svc(char **, struct svc_req *);
+-#define RPCBPROC_TADDR2UADDR ((u_int32_t)8)
+-extern "C" char ** rpcbproc_taddr2uaddr_3(struct netbuf *, CLIENT *);
+-extern "C" char ** rpcbproc_taddr2uaddr_3_svc(struct netbuf *, struct svc_req *);
+-
+-#elif __STDC__
+-#define RPCBPROC_SET ((u_int32_t)1)
+-extern bool_t * rpcbproc_set_3(rpcb *, CLIENT *);
+-extern bool_t * rpcbproc_set_3_svc(rpcb *, struct svc_req *);
+-#define RPCBPROC_UNSET ((u_int32_t)2)
+-extern bool_t * rpcbproc_unset_3(rpcb *, CLIENT *);
+-extern bool_t * rpcbproc_unset_3_svc(rpcb *, struct svc_req *);
+-#define RPCBPROC_GETADDR ((u_int32_t)3)
+-extern char ** rpcbproc_getaddr_3(rpcb *, CLIENT *);
+-extern char ** rpcbproc_getaddr_3_svc(rpcb *, struct svc_req *);
+-#define RPCBPROC_DUMP ((u_int32_t)4)
+-extern rpcblist_ptr * rpcbproc_dump_3(void *, CLIENT *);
+-extern rpcblist_ptr * rpcbproc_dump_3_svc(void *, struct svc_req *);
+-#define RPCBPROC_CALLIT ((u_int32_t)5)
+-extern rpcb_rmtcallres * rpcbproc_callit_3(rpcb_rmtcallargs *, CLIENT *);
+-extern rpcb_rmtcallres * rpcbproc_callit_3_svc(rpcb_rmtcallargs *, struct svc_req *);
+-#define RPCBPROC_GETTIME ((u_int32_t)6)
+-extern u_int * rpcbproc_gettime_3(void *, CLIENT *);
+-extern u_int * rpcbproc_gettime_3_svc(void *, struct svc_req *);
+-#define RPCBPROC_UADDR2TADDR ((u_int32_t)7)
+-extern struct netbuf * rpcbproc_uaddr2taddr_3(char **, CLIENT *);
+-extern struct netbuf * rpcbproc_uaddr2taddr_3_svc(char **, struct svc_req *);
+-#define RPCBPROC_TADDR2UADDR ((u_int32_t)8)
+-extern char ** rpcbproc_taddr2uaddr_3(struct netbuf *, CLIENT *);
+-extern char ** rpcbproc_taddr2uaddr_3_svc(struct netbuf *, struct svc_req *);
+-
+-#else /* Old Style C */
+-#define RPCBPROC_SET ((u_int32_t)1)
+-extern bool_t * rpcbproc_set_3();
+-extern bool_t * rpcbproc_set_3_svc();
+-#define RPCBPROC_UNSET ((u_int32_t)2)
+-extern bool_t * rpcbproc_unset_3();
+-extern bool_t * rpcbproc_unset_3_svc();
+-#define RPCBPROC_GETADDR ((u_int32_t)3)
+-extern char ** rpcbproc_getaddr_3();
+-extern char ** rpcbproc_getaddr_3_svc();
+-#define RPCBPROC_DUMP ((u_int32_t)4)
+-extern rpcblist_ptr * rpcbproc_dump_3();
+-extern rpcblist_ptr * rpcbproc_dump_3_svc();
+-#define RPCBPROC_CALLIT ((u_int32_t)5)
+-extern rpcb_rmtcallres * rpcbproc_callit_3();
+-extern rpcb_rmtcallres * rpcbproc_callit_3_svc();
+-#define RPCBPROC_GETTIME ((u_int32_t)6)
+-extern u_int * rpcbproc_gettime_3();
+-extern u_int * rpcbproc_gettime_3_svc();
+-#define RPCBPROC_UADDR2TADDR ((u_int32_t)7)
+-extern struct netbuf * rpcbproc_uaddr2taddr_3();
+-extern struct netbuf * rpcbproc_uaddr2taddr_3_svc();
+-#define RPCBPROC_TADDR2UADDR ((u_int32_t)8)
+-extern char ** rpcbproc_taddr2uaddr_3();
+-extern char ** rpcbproc_taddr2uaddr_3_svc();
+-#endif /* Old Style C */
+-#define RPCBVERS4 ((u_int32_t)4)
+-
+-#ifdef __cplusplus
+-extern "C" bool_t * rpcbproc_set_4(rpcb *, CLIENT *);
+-extern "C" bool_t * rpcbproc_set_4_svc(rpcb *, struct svc_req *);
+-extern "C" bool_t * rpcbproc_unset_4(rpcb *, CLIENT *);
+-extern "C" bool_t * rpcbproc_unset_4_svc(rpcb *, struct svc_req *);
+-extern "C" char ** rpcbproc_getaddr_4(rpcb *, CLIENT *);
+-extern "C" char ** rpcbproc_getaddr_4_svc(rpcb *, struct svc_req *);
+-extern "C" rpcblist_ptr * rpcbproc_dump_4(void *, CLIENT *);
+-extern "C" rpcblist_ptr * rpcbproc_dump_4_svc(void *, struct svc_req *);
+-#define RPCBPROC_BCAST ((u_int32_t)RPCBPROC_CALLIT)
+-extern "C" rpcb_rmtcallres * rpcbproc_bcast_4(rpcb_rmtcallargs *, CLIENT *);
+-extern "C" rpcb_rmtcallres * rpcbproc_bcast_4_svc(rpcb_rmtcallargs *, struct svc_req *);
+-extern "C" u_int * rpcbproc_gettime_4(void *, CLIENT *);
+-extern "C" u_int * rpcbproc_gettime_4_svc(void *, struct svc_req *);
+-extern "C" struct netbuf * rpcbproc_uaddr2taddr_4(char **, CLIENT *);
+-extern "C" struct netbuf * rpcbproc_uaddr2taddr_4_svc(char **, struct svc_req *);
+-extern "C" char ** rpcbproc_taddr2uaddr_4(struct netbuf *, CLIENT *);
+-extern "C" char ** rpcbproc_taddr2uaddr_4_svc(struct netbuf *, struct svc_req *);
+-#define RPCBPROC_GETVERSADDR ((u_int32_t)9)
+-extern "C" char ** rpcbproc_getversaddr_4(rpcb *, CLIENT *);
+-extern "C" char ** rpcbproc_getversaddr_4_svc(rpcb *, struct svc_req *);
+-#define RPCBPROC_INDIRECT ((u_int32_t)10)
+-extern "C" rpcb_rmtcallres * rpcbproc_indirect_4(rpcb_rmtcallargs *, CLIENT *);
+-extern "C" rpcb_rmtcallres * rpcbproc_indirect_4_svc(rpcb_rmtcallargs *, struct svc_req *);
+-#define RPCBPROC_GETADDRLIST ((u_int32_t)11)
+-extern "C" rpcb_entry_list_ptr * rpcbproc_getaddrlist_4(rpcb *, CLIENT *);
+-extern "C" rpcb_entry_list_ptr * rpcbproc_getaddrlist_4_svc(rpcb *, struct svc_req *);
+-#define RPCBPROC_GETSTAT ((u_int32_t)12)
+-extern "C" rpcb_stat * rpcbproc_getstat_4(void *, CLIENT *);
+-extern "C" rpcb_stat * rpcbproc_getstat_4_svc(void *, struct svc_req *);
+-
+-#elif __STDC__
+-extern bool_t * rpcbproc_set_4(rpcb *, CLIENT *);
+-extern bool_t * rpcbproc_set_4_svc(rpcb *, struct svc_req *);
+-extern bool_t * rpcbproc_unset_4(rpcb *, CLIENT *);
+-extern bool_t * rpcbproc_unset_4_svc(rpcb *, struct svc_req *);
+-extern char ** rpcbproc_getaddr_4(rpcb *, CLIENT *);
+-extern char ** rpcbproc_getaddr_4_svc(rpcb *, struct svc_req *);
+-extern rpcblist_ptr * rpcbproc_dump_4(void *, CLIENT *);
+-extern rpcblist_ptr * rpcbproc_dump_4_svc(void *, struct svc_req *);
+-#define RPCBPROC_BCAST ((u_int32_t)RPCBPROC_CALLIT)
+-extern rpcb_rmtcallres * rpcbproc_bcast_4(rpcb_rmtcallargs *, CLIENT *);
+-extern rpcb_rmtcallres * rpcbproc_bcast_4_svc(rpcb_rmtcallargs *, struct svc_req *);
+-extern u_int * rpcbproc_gettime_4(void *, CLIENT *);
+-extern u_int * rpcbproc_gettime_4_svc(void *, struct svc_req *);
+-extern struct netbuf * rpcbproc_uaddr2taddr_4(char **, CLIENT *);
+-extern struct netbuf * rpcbproc_uaddr2taddr_4_svc(char **, struct svc_req *);
+-extern char ** rpcbproc_taddr2uaddr_4(struct netbuf *, CLIENT *);
+-extern char ** rpcbproc_taddr2uaddr_4_svc(struct netbuf *, struct svc_req *);
+-#define RPCBPROC_GETVERSADDR ((u_int32_t)9)
+-extern char ** rpcbproc_getversaddr_4(rpcb *, CLIENT *);
+-extern char ** rpcbproc_getversaddr_4_svc(rpcb *, struct svc_req *);
+-#define RPCBPROC_INDIRECT ((u_int32_t)10)
+-extern rpcb_rmtcallres * rpcbproc_indirect_4(rpcb_rmtcallargs *, CLIENT *);
+-extern rpcb_rmtcallres * rpcbproc_indirect_4_svc(rpcb_rmtcallargs *, struct svc_req *);
+-#define RPCBPROC_GETADDRLIST ((u_int32_t)11)
+-extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4(rpcb *, CLIENT *);
+-extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4_svc(rpcb *, struct svc_req *);
+-#define RPCBPROC_GETSTAT ((u_int32_t)12)
+-extern rpcb_stat * rpcbproc_getstat_4(void *, CLIENT *);
+-extern rpcb_stat * rpcbproc_getstat_4_svc(void *, struct svc_req *);
+-
+-#else /* Old Style C */
+-extern bool_t * rpcbproc_set_4();
+-extern bool_t * rpcbproc_set_4_svc();
+-extern bool_t * rpcbproc_unset_4();
+-extern bool_t * rpcbproc_unset_4_svc();
+-extern char ** rpcbproc_getaddr_4();
+-extern char ** rpcbproc_getaddr_4_svc();
+-extern rpcblist_ptr * rpcbproc_dump_4();
+-extern rpcblist_ptr * rpcbproc_dump_4_svc();
+-#define RPCBPROC_BCAST ((u_int32_t)RPCBPROC_CALLIT)
+-extern rpcb_rmtcallres * rpcbproc_bcast_4();
+-extern rpcb_rmtcallres * rpcbproc_bcast_4_svc();
+-extern u_int * rpcbproc_gettime_4();
+-extern u_int * rpcbproc_gettime_4_svc();
+-extern struct netbuf * rpcbproc_uaddr2taddr_4();
+-extern struct netbuf * rpcbproc_uaddr2taddr_4_svc();
+-extern char ** rpcbproc_taddr2uaddr_4();
+-extern char ** rpcbproc_taddr2uaddr_4_svc();
+-#define RPCBPROC_GETVERSADDR ((u_int32_t)9)
+-extern char ** rpcbproc_getversaddr_4();
+-extern char ** rpcbproc_getversaddr_4_svc();
+-#define RPCBPROC_INDIRECT ((u_int32_t)10)
+-extern rpcb_rmtcallres * rpcbproc_indirect_4();
+-extern rpcb_rmtcallres * rpcbproc_indirect_4_svc();
+-#define RPCBPROC_GETADDRLIST ((u_int32_t)11)
+-extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4();
+-extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4_svc();
+-#define RPCBPROC_GETSTAT ((u_int32_t)12)
+-extern rpcb_stat * rpcbproc_getstat_4();
+-extern rpcb_stat * rpcbproc_getstat_4_svc();
+-#endif /* Old Style C */
+-
+-#endif /* !_RPCB_PROT_H_RPCGEN */
+diff --git a/tirpc/rpcsvc/crypt.h b/tirpc/rpcsvc/crypt.h
+deleted file mode 100644
+index da1f9cc..0000000
+--- a/tirpc/rpcsvc/crypt.h
++++ /dev/null
+@@ -1,109 +0,0 @@
+-/*
+- * Please do not edit this file.
+- * It was generated using rpcgen.
+- */
+-
+-#ifndef _CRYPT_H_RPCGEN
+-#define _CRYPT_H_RPCGEN
+-
+-#include <rpc/rpc.h>
+-
+-#ifndef IXDR_GET_INT32
+-#define IXDR_GET_INT32(buf) IXDR_GET_LONG((buf))
+-#endif
+-#ifndef IXDR_PUT_INT32
+-#define IXDR_PUT_INT32(buf, v) IXDR_PUT_LONG((buf), (v))
+-#endif
+-#ifndef IXDR_GET_U_INT32
+-#define IXDR_GET_U_INT32(buf) IXDR_GET_U_LONG((buf))
+-#endif
+-#ifndef IXDR_PUT_U_INT32
+-#define IXDR_PUT_U_INT32(buf, v) IXDR_PUT_U_LONG((buf), (v))
+-#endif
+-
+-enum des_dir {
+- ENCRYPT_DES = 0,
+- DECRYPT_DES = 1,
+-};
+-typedef enum des_dir des_dir;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_des_dir(XDR *, des_dir*);
+-#elif __STDC__
+-extern bool_t xdr_des_dir(XDR *, des_dir*);
+-#else /* Old Style C */
+-bool_t xdr_des_dir();
+-#endif /* Old Style C */
+-
+-
+-enum des_mode {
+- CBC_DES = 0,
+- ECB_DES = 1,
+-};
+-typedef enum des_mode des_mode;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_des_mode(XDR *, des_mode*);
+-#elif __STDC__
+-extern bool_t xdr_des_mode(XDR *, des_mode*);
+-#else /* Old Style C */
+-bool_t xdr_des_mode();
+-#endif /* Old Style C */
+-
+-
+-struct desargs {
+- u_char des_key[8];
+- des_dir des_dir;
+- des_mode des_mode;
+- u_char des_ivec[8];
+- struct {
+- u_int desbuf_len;
+- char *desbuf_val;
+- } desbuf;
+-};
+-typedef struct desargs desargs;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_desargs(XDR *, desargs*);
+-#elif __STDC__
+-extern bool_t xdr_desargs(XDR *, desargs*);
+-#else /* Old Style C */
+-bool_t xdr_desargs();
+-#endif /* Old Style C */
+-
+-
+-struct desresp {
+- struct {
+- u_int desbuf_len;
+- char *desbuf_val;
+- } desbuf;
+- u_char des_ivec[8];
+- int stat;
+-};
+-typedef struct desresp desresp;
+-#ifdef __cplusplus
+-extern "C" bool_t xdr_desresp(XDR *, desresp*);
+-#elif __STDC__
+-extern bool_t xdr_desresp(XDR *, desresp*);
+-#else /* Old Style C */
+-bool_t xdr_desresp();
+-#endif /* Old Style C */
+-
+-
+-#define CRYPT_PROG ((u_int32_t)600100029)
+-#define CRYPT_VERS ((u_int32_t)1)
+-
+-#ifdef __cplusplus
+-#define DES_CRYPT ((u_int32_t)1)
+-extern "C" desresp * des_crypt_1(desargs *, CLIENT *);
+-extern "C" desresp * des_crypt_1_svc(desargs *, struct svc_req *);
+-
+-#elif __STDC__
+-#define DES_CRYPT ((u_int32_t)1)
+-extern desresp * des_crypt_1(desargs *, CLIENT *);
+-extern desresp * des_crypt_1_svc(desargs *, struct svc_req *);
+-
+-#else /* Old Style C */
+-#define DES_CRYPT ((u_int32_t)1)
+-extern desresp * des_crypt_1();
+-extern desresp * des_crypt_1_svc();
+-#endif /* Old Style C */
+-
+-#endif /* !_CRYPT_H_RPCGEN */
+--
+2.0.0
+
--- /dev/null
+From 008a9c8ac3a84ffcc46a0eedb5b13862b279190c Mon Sep 17 00:00:00 2001
+From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+Date: Sat, 10 Nov 2012 17:45:03 +0100
+Subject: [PATCH] Add more XDR files needed to build rpcbind on top of libtirpc
+
+Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+---
+ Makefile.am | 6 +
+ tirpc/rpcsvc/mount.x | 257 ++++++++++
+ tirpc/rpcsvc/nfs_prot.x | 1266 +++++++++++++++++++++++++++++++++++++++++++++++
+ tirpc/rpcsvc/rquota.x | 67 +++
+ 4 files changed, 1596 insertions(+)
+ create mode 100644 tirpc/rpcsvc/mount.x
+ create mode 100644 tirpc/rpcsvc/nfs_prot.x
+ create mode 100644 tirpc/rpcsvc/rquota.x
+
+diff --git a/Makefile.am b/Makefile.am
+index 4e4dc32..b7ae979 100644
+--- a/Makefile.am
++++ b/Makefile.am
+@@ -3,6 +3,9 @@ ACLOCAL_AMFLAGS = -I m4
+
+ GENFILES = \
+ tirpc/rpcsvc/crypt.h \
++ tirpc/rpcsvc/mount.h \
++ tirpc/rpcsvc/nfs_prot.h \
++ tirpc/rpcsvc/rquota.h \
+ tirpc/rpc/rpcb_prot.h
+
+ noinst_HEADERS = tirpc/reentrant.h \
+@@ -12,6 +15,9 @@ noinst_HEADERS = tirpc/reentrant.h \
+
+ nobase_include_HEADERS = tirpc/netconfig.h \
+ tirpc/rpcsvc/crypt.x \
++ tirpc/rpcsvc/mount.x \
++ tirpc/rpcsvc/nfs_prot.x \
++ tirpc/rpcsvc/rquota.x \
+ tirpc/rpc/xdr.h \
+ tirpc/rpc/types.h \
+ tirpc/rpc/svc_soc.h \
+diff --git a/tirpc/rpcsvc/mount.x b/tirpc/rpcsvc/mount.x
+new file mode 100644
+index 0000000..f68a06f
+--- /dev/null
++++ b/tirpc/rpcsvc/mount.x
+@@ -0,0 +1,257 @@
++/*
++ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
++ * unrestricted use provided that this legend is included on all tape
++ * media and as a part of the software program in whole or part. Users
++ * may copy or modify Sun RPC without charge, but are not authorized
++ * to license or distribute it to anyone else except as part of a product or
++ * program developed by the user.
++ *
++ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
++ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
++ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
++ *
++ * Sun RPC is provided with no support and without any obligation on the
++ * part of Sun Microsystems, Inc. to assist in its use, correction,
++ * modification or enhancement.
++ *
++ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
++ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
++ * OR ANY PART THEREOF.
++ *
++ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
++ * or profits or other special, indirect and consequential damages, even if
++ * Sun has been advised of the possibility of such damages.
++ *
++ * Sun Microsystems, Inc.
++ * 2550 Garcia Avenue
++ * Mountain View, California 94043
++ */
++
++/*
++ * Protocol description for the mount program
++ */
++
++#ifndef RPC_HDR
++%#ifndef lint
++%/*static char sccsid[] = "from: @(#)mount.x 1.2 87/09/18 Copyr 1987 Sun Micro";*/
++%/*static char sccsid[] = "from: @(#)mount.x 2.1 88/08/01 4.0 RPCSRC";*/
++%static const char rcsid[] =
++% "$FreeBSD: src/include/rpcsvc/mount.x,v 1.6 1999/08/27 23:45:08 peter Exp $";
++%#endif /* not lint */
++#endif
++
++const MNTPATHLEN = 1024; /* maximum bytes in a pathname argument */
++const MNTNAMLEN = 255; /* maximum bytes in a name argument */
++const FHSIZE = 32; /* size in bytes of a file handle */
++#ifdef WANT_NFS3
++const FHSIZE3 = 64; /* size in bytes of a file handle (v3) */
++#endif
++
++/*
++ * The fhandle is the file handle that the server passes to the client.
++ * All file operations are done using the file handles to refer to a file
++ * or a directory. The file handle can contain whatever information the
++ * server needs to distinguish an individual file.
++ */
++typedef opaque fhandle[FHSIZE];
++#ifdef WANT_NFS3
++typedef opaque fhandle3<FHSIZE3>;
++#endif
++
++/*
++ * If a status of zero is returned, the call completed successfully, and
++ * a file handle for the directory follows. A non-zero status indicates
++ * some sort of error. The status corresponds with UNIX error numbers.
++ */
++union fhstatus switch (unsigned fhs_status) {
++case 0:
++ fhandle fhs_fhandle;
++default:
++ void;
++};
++
++#ifdef WANT_NFS3
++/*
++ * Status codes returned by the version 3 mount call.
++ */
++enum mountstat3 {
++ MNT3_OK = 0, /* no error */
++ MNT3ERR_PERM = 1, /* Not owner */
++ MNT3ERR_NOENT = 2, /* No such file or directory */
++ MNT3ERR_IO = 5, /* I/O error */
++ MNT3ERR_ACCES = 13, /* Permission denied */
++ MNT3ERR_NOTDIR = 20, /* Not a directory */
++ MNT3ERR_INVAL = 22, /* Invalid argument */
++ MNT3ERR_NAMETOOLONG = 63, /* Filename too long */
++ MNT3ERR_NOTSUPP = 10004, /* Operation not supported */
++ MNT3ERR_SERVERFAULT = 10006 /* A failure on the server */
++};
++
++struct mountres3_ok {
++ fhandle3 fhandle;
++ int auth_flavors<>;
++};
++
++union mountres3 switch (mountstat3 fhs_status) {
++case 0:
++ mountres3_ok mountinfo;
++default:
++ void;
++};
++#endif
++
++/*
++ * The type dirpath is the pathname of a directory
++ */
++typedef string dirpath<MNTPATHLEN>;
++
++/*
++ * The type name is used for arbitrary names (hostnames, groupnames)
++ */
++typedef string name<MNTNAMLEN>;
++
++/*
++ * A list of who has what mounted
++ */
++typedef struct mountbody *mountlist;
++struct mountbody {
++ name ml_hostname;
++ dirpath ml_directory;
++ mountlist ml_next;
++};
++
++/*
++ * A list of netgroups
++ */
++typedef struct groupnode *groups;
++struct groupnode {
++ name gr_name;
++ groups gr_next;
++};
++
++/*
++ * A list of what is exported and to whom
++ */
++typedef struct exportnode *exports;
++struct exportnode {
++ dirpath ex_dir;
++ groups ex_groups;
++ exports ex_next;
++};
++
++program MOUNTPROG {
++ /*
++ * Version one of the mount protocol communicates with version two
++ * of the NFS protocol. Version three communicates with
++ * version three of the NFS protocol. The only connecting
++ * point is the fhandle structure, which is the same for both
++ * protocols.
++ */
++ version MOUNTVERS {
++ /*
++ * Does no work. It is made available in all RPC services
++ * to allow server reponse testing and timing
++ */
++ void
++ MOUNTPROC_NULL(void) = 0;
++
++ /*
++ * If fhs_status is 0, then fhs_fhandle contains the
++ * file handle for the directory. This file handle may
++ * be used in the NFS protocol. This procedure also adds
++ * a new entry to the mount list for this client mounting
++ * the directory.
++ * Unix authentication required.
++ */
++ fhstatus
++ MOUNTPROC_MNT(dirpath) = 1;
++
++ /*
++ * Returns the list of remotely mounted filesystems. The
++ * mountlist contains one entry for each hostname and
++ * directory pair.
++ */
++ mountlist
++ MOUNTPROC_DUMP(void) = 2;
++
++ /*
++ * Removes the mount list entry for the directory
++ * Unix authentication required.
++ */
++ void
++ MOUNTPROC_UMNT(dirpath) = 3;
++
++ /*
++ * Removes all of the mount list entries for this client
++ * Unix authentication required.
++ */
++ void
++ MOUNTPROC_UMNTALL(void) = 4;
++
++ /*
++ * Returns a list of all the exported filesystems, and which
++ * machines are allowed to import it.
++ */
++ exports
++ MOUNTPROC_EXPORT(void) = 5;
++
++ /*
++ * Identical to MOUNTPROC_EXPORT above
++ */
++ exports
++ MOUNTPROC_EXPORTALL(void) = 6;
++ } = 1;
++#ifdef WANT_NFS3
++ version MOUNTVERS3 {
++ /*
++ * Does no work. It is made available in all RPC services
++ * to allow server reponse testing and timing
++ */
++ void
++ MOUNTPROC_NULL(void) = 0;
++
++ /*
++ * If mountres3.fhs_status is MNT3_OK, then
++ * mountres3.mountinfo contains the file handle for
++ * the directory and a list of acceptable
++ * authentication flavors. This file handle may only
++ * be used in the NFS version 3 protocol. This
++ * procedure also results in the server adding a new
++ * entry to its mount list recording that this client
++ * has mounted the directory. AUTH_UNIX authentication
++ * or better is required.
++ */
++ mountres3
++ MOUNTPROC_MNT(dirpath) = 1;
++
++ /*
++ * Returns the list of remotely mounted filesystems. The
++ * mountlist contains one entry for each hostname and
++ * directory pair.
++ */
++ mountlist
++ MOUNTPROC_DUMP(void) = 2;
++
++ /*
++ * Removes the mount list entry for the directory
++ * Unix authentication required.
++ */
++ void
++ MOUNTPROC_UMNT(dirpath) = 3;
++
++ /*
++ * Removes all of the mount list entries for this client
++ * Unix authentication required.
++ */
++ void
++ MOUNTPROC_UMNTALL(void) = 4;
++
++ /*
++ * Returns a list of all the exported filesystems, and which
++ * machines are allowed to import it.
++ */
++ exports
++ MOUNTPROC_EXPORT(void) = 5;
++ } = 3;
++#endif
++} = 100005;
+diff --git a/tirpc/rpcsvc/nfs_prot.x b/tirpc/rpcsvc/nfs_prot.x
+new file mode 100644
+index 0000000..01564f8
+--- /dev/null
++++ b/tirpc/rpcsvc/nfs_prot.x
+@@ -0,0 +1,1266 @@
++/*
++ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
++ * unrestricted use provided that this legend is included on all tape
++ * media and as a part of the software program in whole or part. Users
++ * may copy or modify Sun RPC without charge, but are not authorized
++ * to license or distribute it to anyone else except as part of a product or
++ * program developed by the user.
++ *
++ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
++ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
++ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
++ *
++ * Sun RPC is provided with no support and without any obligation on the
++ * part of Sun Microsystems, Inc. to assist in its use, correction,
++ * modification or enhancement.
++ *
++ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
++ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
++ * OR ANY PART THEREOF.
++ *
++ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
++ * or profits or other special, indirect and consequential damages, even if
++ * Sun has been advised of the possibility of such damages.
++ *
++ * Sun Microsystems, Inc.
++ * 2550 Garcia Avenue
++ * Mountain View, California 94043
++ */
++
++#ifndef RPC_HDR
++%#ifndef lint
++%/*static char sccsid[] = "from: @(#)nfs_prot.x 1.2 87/10/12 Copyr 1987 Sun Micro";*/
++%/*static char sccsid[] = "from: @(#)nfs_prot.x 2.1 88/08/01 4.0 RPCSRC";*/
++%static const char rcsid[] =
++% "$FreeBSD: src/include/rpcsvc/nfs_prot.x,v 1.7 1999/08/27 23:45:08 peter Exp $";
++%#endif /* not lint */
++#endif
++
++const NFS_PORT = 2049;
++const NFS_MAXDATA = 8192;
++const NFS_MAXPATHLEN = 1024;
++const NFS_MAXNAMLEN = 255;
++const NFS_FHSIZE = 32;
++const NFS_COOKIESIZE = 4;
++const NFS_FIFO_DEV = -1; /* size kludge for named pipes */
++
++/*
++ * File types
++ */
++const NFSMODE_FMT = 0170000; /* type of file */
++const NFSMODE_DIR = 0040000; /* directory */
++const NFSMODE_CHR = 0020000; /* character special */
++const NFSMODE_BLK = 0060000; /* block special */
++const NFSMODE_REG = 0100000; /* regular */
++const NFSMODE_LNK = 0120000; /* symbolic link */
++const NFSMODE_SOCK = 0140000; /* socket */
++const NFSMODE_FIFO = 0010000; /* fifo */
++
++/*
++ * Error status
++ */
++enum nfsstat {
++ NFS_OK= 0, /* no error */
++ NFSERR_PERM=1, /* Not owner */
++ NFSERR_NOENT=2, /* No such file or directory */
++ NFSERR_IO=5, /* I/O error */
++ NFSERR_NXIO=6, /* No such device or address */
++ NFSERR_ACCES=13, /* Permission denied */
++ NFSERR_EXIST=17, /* File exists */
++ NFSERR_NODEV=19, /* No such device */
++ NFSERR_NOTDIR=20, /* Not a directory*/
++ NFSERR_ISDIR=21, /* Is a directory */
++ NFSERR_FBIG=27, /* File too large */
++ NFSERR_NOSPC=28, /* No space left on device */
++ NFSERR_ROFS=30, /* Read-only file system */
++ NFSERR_NAMETOOLONG=63, /* File name too long */
++ NFSERR_NOTEMPTY=66, /* Directory not empty */
++ NFSERR_DQUOT=69, /* Disc quota exceeded */
++ NFSERR_STALE=70, /* Stale NFS file handle */
++ NFSERR_WFLUSH=99 /* write cache flushed */
++};
++
++/*
++ * File types
++ */
++enum ftype {
++ NFNON = 0, /* non-file */
++ NFREG = 1, /* regular file */
++ NFDIR = 2, /* directory */
++ NFBLK = 3, /* block special */
++ NFCHR = 4, /* character special */
++ NFLNK = 5, /* symbolic link */
++ NFSOCK = 6, /* unix domain sockets */
++ NFBAD = 7, /* unused */
++ NFFIFO = 8 /* named pipe */
++};
++
++/*
++ * File access handle
++ */
++struct nfs_fh {
++ opaque data[NFS_FHSIZE];
++};
++
++/*
++ * Timeval
++ */
++struct nfstime {
++ unsigned seconds;
++ unsigned useconds;
++};
++
++
++/*
++ * File attributes
++ */
++struct fattr {
++ ftype type; /* file type */
++ unsigned mode; /* protection mode bits */
++ unsigned nlink; /* # hard links */
++ unsigned uid; /* owner user id */
++ unsigned gid; /* owner group id */
++ unsigned size; /* file size in bytes */
++ unsigned blocksize; /* prefered block size */
++ unsigned rdev; /* special device # */
++ unsigned blocks; /* Kb of disk used by file */
++ unsigned fsid; /* device # */
++ unsigned fileid; /* inode # */
++ nfstime atime; /* time of last access */
++ nfstime mtime; /* time of last modification */
++ nfstime ctime; /* time of last change */
++};
++
++/*
++ * File attributes which can be set
++ */
++struct sattr {
++ unsigned mode; /* protection mode bits */
++ unsigned uid; /* owner user id */
++ unsigned gid; /* owner group id */
++ unsigned size; /* file size in bytes */
++ nfstime atime; /* time of last access */
++ nfstime mtime; /* time of last modification */
++};
++
++
++typedef string filename<NFS_MAXNAMLEN>;
++typedef string nfspath<NFS_MAXPATHLEN>;
++
++/*
++ * Reply status with file attributes
++ */
++union attrstat switch (nfsstat status) {
++case NFS_OK:
++ fattr attributes;
++default:
++ void;
++};
++
++struct sattrargs {
++ nfs_fh file;
++ sattr attributes;
++};
++
++/*
++ * Arguments for directory operations
++ */
++struct diropargs {
++ nfs_fh dir; /* directory file handle */
++ filename name; /* name (up to NFS_MAXNAMLEN bytes) */
++};
++
++struct diropokres {
++ nfs_fh file;
++ fattr attributes;
++};
++
++/*
++ * Results from directory operation
++ */
++union diropres switch (nfsstat status) {
++case NFS_OK:
++ diropokres diropres;
++default:
++ void;
++};
++
++union readlinkres switch (nfsstat status) {
++case NFS_OK:
++ nfspath data;
++default:
++ void;
++};
++
++/*
++ * Arguments to remote read
++ */
++struct readargs {
++ nfs_fh file; /* handle for file */
++ unsigned offset; /* byte offset in file */
++ unsigned count; /* immediate read count */
++ unsigned totalcount; /* total read count (from this offset)*/
++};
++
++/*
++ * Status OK portion of remote read reply
++ */
++struct readokres {
++ fattr attributes; /* attributes, need for pagin*/
++ opaque data<NFS_MAXDATA>;
++};
++
++union readres switch (nfsstat status) {
++case NFS_OK:
++ readokres reply;
++default:
++ void;
++};
++
++/*
++ * Arguments to remote write
++ */
++struct writeargs {
++ nfs_fh file; /* handle for file */
++ unsigned beginoffset; /* beginning byte offset in file */
++ unsigned offset; /* current byte offset in file */
++ unsigned totalcount; /* total write count (to this offset)*/
++ opaque data<NFS_MAXDATA>;
++};
++
++struct createargs {
++ diropargs where;
++ sattr attributes;
++};
++
++struct renameargs {
++ diropargs from;
++ diropargs to;
++};
++
++struct linkargs {
++ nfs_fh from;
++ diropargs to;
++};
++
++struct symlinkargs {
++ diropargs from;
++ nfspath to;
++ sattr attributes;
++};
++
++
++typedef opaque nfscookie[NFS_COOKIESIZE];
++
++/*
++ * Arguments to readdir
++ */
++struct readdirargs {
++ nfs_fh dir; /* directory handle */
++ nfscookie cookie;
++ unsigned count; /* number of directory bytes to read */
++};
++
++struct entry {
++ unsigned fileid;
++ filename name;
++ nfscookie cookie;
++ entry *nextentry;
++};
++
++struct dirlist {
++ entry *entries;
++ bool eof;
++};
++
++union readdirres switch (nfsstat status) {
++case NFS_OK:
++ dirlist reply;
++default:
++ void;
++};
++
++struct statfsokres {
++ unsigned tsize; /* preferred transfer size in bytes */
++ unsigned bsize; /* fundamental file system block size */
++ unsigned blocks; /* total blocks in file system */
++ unsigned bfree; /* free blocks in fs */
++ unsigned bavail; /* free blocks avail to non-superuser */
++};
++
++union statfsres switch (nfsstat status) {
++case NFS_OK:
++ statfsokres reply;
++default:
++ void;
++};
++
++#ifdef WANT_NFS3
++
++/*
++ * NFSv3 constants and types
++ */
++const NFS3_FHSIZE = 64; /* maximum size in bytes of a file handle */
++const NFS3_COOKIEVERFSIZE = 8; /* size of a cookie verifier for READDIR */
++const NFS3_CREATEVERFSIZE = 8; /* size of the verifier used for CREATE */
++const NFS3_WRITEVERFSIZE = 8; /* size of the verifier used for WRITE */
++
++typedef unsigned hyper uint64;
++typedef hyper int64;
++typedef unsigned long uint32;
++typedef long int32;
++typedef string filename3<>;
++typedef string nfspath3<>;
++typedef uint64 fileid3;
++typedef uint64 cookie3;
++typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
++typedef opaque createverf3[NFS3_CREATEVERFSIZE];
++typedef opaque writeverf3[NFS3_WRITEVERFSIZE];
++typedef uint32 uid3;
++typedef uint32 gid3;
++typedef uint64 size3;
++typedef uint64 offset3;
++typedef uint32 mode3;
++typedef uint32 count3;
++
++/*
++ * Error status (v3)
++ */
++enum nfsstat3 {
++ NFS3_OK = 0,
++ NFS3ERR_PERM = 1,
++ NFS3ERR_NOENT = 2,
++ NFS3ERR_IO = 5,
++ NFS3ERR_NXIO = 6,
++ NFS3ERR_ACCES = 13,
++ NFS3ERR_EXIST = 17,
++ NFS3ERR_XDEV = 18,
++ NFS3ERR_NODEV = 19,
++ NFS3ERR_NOTDIR = 20,
++ NFS3ERR_ISDIR = 21,
++ NFS3ERR_INVAL = 22,
++ NFS3ERR_FBIG = 27,
++ NFS3ERR_NOSPC = 28,
++ NFS3ERR_ROFS = 30,
++ NFS3ERR_MLINK = 31,
++ NFS3ERR_NAMETOOLONG = 63,
++ NFS3ERR_NOTEMPTY = 66,
++ NFS3ERR_DQUOT = 69,
++ NFS3ERR_STALE = 70,
++ NFS3ERR_REMOTE = 71,
++ NFS3ERR_BADHANDLE = 10001,
++ NFS3ERR_NOT_SYNC = 10002,
++ NFS3ERR_BAD_COOKIE = 10003,
++ NFS3ERR_NOTSUPP = 10004,
++ NFS3ERR_TOOSMALL = 10005,
++ NFS3ERR_SERVERFAULT = 10006,
++ NFS3ERR_BADTYPE = 10007,
++ NFS3ERR_JUKEBOX = 10008
++};
++
++/*
++ * File types (v3)
++ */
++enum ftype3 {
++ NF3REG = 1, /* regular file */
++ NF3DIR = 2, /* directory */
++ NF3BLK = 3, /* block special */
++ NF3CHR = 4, /* character special */
++ NF3LNK = 5, /* symbolic link */
++ NF3SOCK = 6, /* unix domain sockets */
++ NF3FIFO = 7 /* named pipe */
++};
++
++struct specdata3 {
++ uint32 specdata1;
++ uint32 specdata2;
++};
++
++/*
++ * File access handle (v3)
++ */
++struct nfs_fh3 {
++ opaque data<NFS3_FHSIZE>;
++};
++
++/*
++ * Timeval (v3)
++ */
++struct nfstime3 {
++ uint32 seconds;
++ uint32 nseconds;
++};
++
++
++/*
++ * File attributes (v3)
++ */
++struct fattr3 {
++ ftype3 type; /* file type */
++ mode3 mode; /* protection mode bits */
++ uint32 nlink; /* # hard links */
++ uid3 uid; /* owner user id */
++ gid3 gid; /* owner group id */
++ size3 size; /* file size in bytes */
++ size3 used; /* prefered block size */
++ specdata3 rdev; /* special device # */
++ uint64 fsid; /* device # */
++ fileid3 fileid; /* inode # */
++ nfstime3 atime; /* time of last access */
++ nfstime3 mtime; /* time of last modification */
++ nfstime3 ctime; /* time of last change */
++};
++
++union post_op_attr switch (bool attributes_follow) {
++case TRUE:
++ fattr3 attributes;
++case FALSE:
++ void;
++};
++
++struct wcc_attr {
++ size3 size;
++ nfstime3 mtime;
++ nfstime3 ctime;
++};
++
++union pre_op_attr switch (bool attributes_follow) {
++case TRUE:
++ wcc_attr attributes;
++case FALSE:
++ void;
++};
++
++struct wcc_data {
++ pre_op_attr before;
++ post_op_attr after;
++};
++
++union post_op_fh3 switch (bool handle_follows) {
++case TRUE:
++ nfs_fh3 handle;
++case FALSE:
++ void;
++};
++
++/*
++ * File attributes which can be set (v3)
++ */
++enum time_how {
++ DONT_CHANGE = 0,
++ SET_TO_SERVER_TIME = 1,
++ SET_TO_CLIENT_TIME = 2
++};
++
++union set_mode3 switch (bool set_it) {
++case TRUE:
++ mode3 mode;
++default:
++ void;
++};
++
++union set_uid3 switch (bool set_it) {
++case TRUE:
++ uid3 uid;
++default:
++ void;
++};
++
++union set_gid3 switch (bool set_it) {
++case TRUE:
++ gid3 gid;
++default:
++ void;
++};
++
++union set_size3 switch (bool set_it) {
++case TRUE:
++ size3 size;
++default:
++ void;
++};
++
++union set_atime switch (time_how set_it) {
++case SET_TO_CLIENT_TIME:
++ nfstime3 atime;
++default:
++ void;
++};
++
++union set_mtime switch (time_how set_it) {
++case SET_TO_CLIENT_TIME:
++ nfstime3 mtime;
++default:
++ void;
++};
++
++struct sattr3 {
++ set_mode3 mode;
++ set_uid3 uid;
++ set_gid3 gid;
++ set_size3 size;
++ set_atime atime;
++ set_mtime mtime;
++};
++
++/*
++ * Arguments for directory operations (v3)
++ */
++struct diropargs3 {
++ nfs_fh3 dir; /* directory file handle */
++ filename3 name; /* name (up to NFS_MAXNAMLEN bytes) */
++};
++
++/*
++ * Arguments to getattr (v3).
++ */
++struct GETATTR3args {
++ nfs_fh3 object;
++};
++
++struct GETATTR3resok {
++ fattr3 obj_attributes;
++};
++
++union GETATTR3res switch (nfsstat3 status) {
++case NFS3_OK:
++ GETATTR3resok resok;
++default:
++ void;
++};
++
++/*
++ * Arguments to setattr (v3).
++ */
++union sattrguard3 switch (bool check) {
++case TRUE:
++ nfstime3 obj_ctime;
++case FALSE:
++ void;
++};
++
++struct SETATTR3args {
++ nfs_fh3 object;
++ sattr3 new_attributes;
++ sattrguard3 guard;
++};
++
++struct SETATTR3resok {
++ wcc_data obj_wcc;
++};
++
++struct SETATTR3resfail {
++ wcc_data obj_wcc;
++};
++
++union SETATTR3res switch (nfsstat3 status) {
++case NFS3_OK:
++ SETATTR3resok resok;
++default:
++ SETATTR3resfail resfail;
++};
++
++/*
++ * Arguments to lookup (v3).
++ */
++struct LOOKUP3args {
++ diropargs3 what;
++};
++
++struct LOOKUP3resok {
++ nfs_fh3 object;
++ post_op_attr obj_attributes;
++ post_op_attr dir_attributes;
++};
++
++struct LOOKUP3resfail {
++ post_op_attr dir_attributes;
++};
++
++union LOOKUP3res switch (nfsstat3 status) {
++case NFS3_OK:
++ LOOKUP3resok resok;
++default:
++ LOOKUP3resfail resfail;
++};
++
++/*
++ * Arguments to access (v3).
++ */
++const ACCESS3_READ = 0x0001;
++const ACCESS3_LOOKUP = 0x0002;
++const ACCESS3_MODIFY = 0x0004;
++const ACCESS3_EXTEND = 0x0008;
++const ACCESS3_DELETE = 0x0010;
++const ACCESS3_EXECUTE = 0x0020;
++
++struct ACCESS3args {
++ nfs_fh3 object;
++ uint32 access;
++};
++
++struct ACCESS3resok {
++ post_op_attr obj_attributes;
++ uint32 access;
++};
++
++struct ACCESS3resfail {
++ post_op_attr obj_attributes;
++};
++
++union ACCESS3res switch (nfsstat3 status) {
++case NFS3_OK:
++ ACCESS3resok resok;
++default:
++ ACCESS3resfail resfail;
++};
++
++/*
++ * Arguments to readlink (v3).
++ */
++struct READLINK3args {
++ nfs_fh3 symlink;
++};
++
++struct READLINK3resok {
++ post_op_attr symlink_attributes;
++ nfspath3 data;
++};
++
++struct READLINK3resfail {
++ post_op_attr symlink_attributes;
++};
++
++union READLINK3res switch (nfsstat3 status) {
++case NFS3_OK:
++ READLINK3resok resok;
++default:
++ READLINK3resfail resfail;
++};
++
++/*
++ * Arguments to read (v3).
++ */
++struct READ3args {
++ nfs_fh3 file;
++ offset3 offset;
++ count3 count;
++};
++
++struct READ3resok {
++ post_op_attr file_attributes;
++ count3 count;
++ bool eof;
++ opaque data<>;
++};
++
++struct READ3resfail {
++ post_op_attr file_attributes;
++};
++
++/* XXX: solaris 2.6 uses ``nfsstat'' here */
++union READ3res switch (nfsstat3 status) {
++case NFS3_OK:
++ READ3resok resok;
++default:
++ READ3resfail resfail;
++};
++
++/*
++ * Arguments to write (v3).
++ */
++enum stable_how {
++ UNSTABLE = 0,
++ DATA_SYNC = 1,
++ FILE_SYNC = 2
++};
++
++struct WRITE3args {
++ nfs_fh3 file;
++ offset3 offset;
++ count3 count;
++ stable_how stable;
++ opaque data<>;
++};
++
++struct WRITE3resok {
++ wcc_data file_wcc;
++ count3 count;
++ stable_how committed;
++ writeverf3 verf;
++};
++
++struct WRITE3resfail {
++ wcc_data file_wcc;
++};
++
++union WRITE3res switch (nfsstat3 status) {
++case NFS3_OK:
++ WRITE3resok resok;
++default:
++ WRITE3resfail resfail;
++};
++
++/*
++ * Arguments to create (v3).
++ */
++enum createmode3 {
++ UNCHECKED = 0,
++ GUARDED = 1,
++ EXCLUSIVE = 2
++};
++
++union createhow3 switch (createmode3 mode) {
++case UNCHECKED:
++case GUARDED:
++ sattr3 obj_attributes;
++case EXCLUSIVE:
++ createverf3 verf;
++};
++
++struct CREATE3args {
++ diropargs3 where;
++ createhow3 how;
++};
++
++struct CREATE3resok {
++ post_op_fh3 obj;
++ post_op_attr obj_attributes;
++ wcc_data dir_wcc;
++};
++
++struct CREATE3resfail {
++ wcc_data dir_wcc;
++};
++
++union CREATE3res switch (nfsstat3 status) {
++case NFS3_OK:
++ CREATE3resok resok;
++default:
++ CREATE3resfail resfail;
++};
++
++/*
++ * Arguments to mkdir (v3).
++ */
++struct MKDIR3args {
++ diropargs3 where;
++ sattr3 attributes;
++};
++
++struct MKDIR3resok {
++ post_op_fh3 obj;
++ post_op_attr obj_attributes;
++ wcc_data dir_wcc;
++};
++
++struct MKDIR3resfail {
++ wcc_data dir_wcc;
++};
++
++union MKDIR3res switch (nfsstat3 status) {
++case NFS3_OK:
++ MKDIR3resok resok;
++default:
++ MKDIR3resfail resfail;
++};
++
++/*
++ * Arguments to symlink (v3).
++ */
++struct symlinkdata3 {
++ sattr3 symlink_attributes;
++ nfspath3 symlink_data;
++};
++
++struct SYMLINK3args {
++ diropargs3 where;
++ symlinkdata3 symlink;
++};
++
++struct SYMLINK3resok {
++ post_op_fh3 obj;
++ post_op_attr obj_attributes;
++ wcc_data dir_wcc;
++};
++
++struct SYMLINK3resfail {
++ wcc_data dir_wcc;
++};
++
++union SYMLINK3res switch (nfsstat3 status) {
++case NFS3_OK:
++ SYMLINK3resok resok;
++default:
++ SYMLINK3resfail resfail;
++};
++
++/*
++ * Arguments to mknod (v3).
++ */
++struct devicedata3 {
++ sattr3 dev_attributes;
++ specdata3 spec;
++};
++
++union mknoddata3 switch (ftype3 type) {
++case NF3CHR:
++case NF3BLK:
++ devicedata3 device;
++case NF3SOCK:
++case NF3FIFO:
++ sattr3 pipe_attributes;
++default:
++ void;
++};
++
++struct MKNOD3args {
++ diropargs3 where;
++ mknoddata3 what;
++};
++
++struct MKNOD3resok {
++ post_op_fh3 obj;
++ post_op_attr obj_attributes;
++ wcc_data dir_wcc;
++};
++
++struct MKNOD3resfail {
++ wcc_data dir_wcc;
++};
++
++union MKNOD3res switch (nfsstat3 status) {
++case NFS3_OK:
++ MKNOD3resok resok;
++default:
++ MKNOD3resfail resfail;
++};
++
++/*
++ * Arguments to remove (v3).
++ */
++struct REMOVE3args {
++ diropargs3 object;
++};
++
++struct REMOVE3resok {
++ wcc_data dir_wcc;
++};
++
++struct REMOVE3resfail {
++ wcc_data dir_wcc;
++};
++
++union REMOVE3res switch (nfsstat3 status) {
++case NFS3_OK:
++ REMOVE3resok resok;
++default:
++ REMOVE3resfail resfail;
++};
++
++/*
++ * Arguments to rmdir (v3).
++ */
++struct RMDIR3args {
++ diropargs3 object;
++};
++
++struct RMDIR3resok {
++ wcc_data dir_wcc;
++};
++
++struct RMDIR3resfail {
++ wcc_data dir_wcc;
++};
++
++union RMDIR3res switch (nfsstat3 status) {
++case NFS3_OK:
++ RMDIR3resok resok;
++default:
++ RMDIR3resfail resfail;
++};
++
++/*
++ * Arguments to rename (v3).
++ */
++struct RENAME3args {
++ diropargs3 from;
++ diropargs3 to;
++};
++
++struct RENAME3resok {
++ wcc_data fromdir_wcc;
++ wcc_data todir_wcc;
++};
++
++struct RENAME3resfail {
++ wcc_data fromdir_wcc;
++ wcc_data todir_wcc;
++};
++
++union RENAME3res switch (nfsstat3 status) {
++case NFS3_OK:
++ RENAME3resok resok;
++default:
++ RENAME3resfail resfail;
++};
++
++/*
++ * Arguments to link (v3).
++ */
++struct LINK3args {
++ nfs_fh3 file;
++ diropargs3 link;
++};
++
++struct LINK3resok {
++ post_op_attr file_attributes;
++ wcc_data linkdir_wcc;
++};
++
++struct LINK3resfail {
++ post_op_attr file_attributes;
++ wcc_data linkdir_wcc;
++};
++
++union LINK3res switch (nfsstat3 status) {
++case NFS3_OK:
++ LINK3resok resok;
++default:
++ LINK3resfail resfail;
++};
++
++/*
++ * Arguments to readdir (v3).
++ */
++struct READDIR3args {
++ nfs_fh3 dir;
++ cookie3 cookie;
++ cookieverf3 cookieverf;
++ count3 count;
++};
++
++struct entry3 {
++ fileid3 fileid;
++ filename3 name;
++ cookie3 cookie;
++ entry3 *nextentry;
++};
++
++struct dirlist3 {
++ entry3 *entries;
++ bool eof;
++};
++
++struct READDIR3resok {
++ post_op_attr dir_attributes;
++ cookieverf3 cookieverf;
++ dirlist3 reply;
++};
++
++struct READDIR3resfail {
++ post_op_attr dir_attributes;
++};
++
++union READDIR3res switch (nfsstat3 status) {
++case NFS3_OK:
++ READDIR3resok resok;
++default:
++ READDIR3resfail resfail;
++};
++
++/*
++ * Arguments to readdirplus (v3).
++ */
++struct READDIRPLUS3args {
++ nfs_fh3 dir;
++ cookie3 cookie;
++ cookieverf3 cookieverf;
++ count3 dircount;
++ count3 maxcount;
++};
++
++struct entryplus3 {
++ fileid3 fileid;
++ filename3 name;
++ cookie3 cookie;
++ post_op_attr name_attributes;
++ post_op_fh3 name_handle;
++ entryplus3 *nextentry;
++};
++
++struct dirlistplus3 {
++ entryplus3 *entries;
++ bool eof;
++};
++
++struct READDIRPLUS3resok {
++ post_op_attr dir_attributes;
++ cookieverf3 cookieverf;
++ dirlistplus3 reply;
++};
++
++struct READDIRPLUS3resfail {
++ post_op_attr dir_attributes;
++};
++
++union READDIRPLUS3res switch (nfsstat3 status) {
++case NFS3_OK:
++ READDIRPLUS3resok resok;
++default:
++ READDIRPLUS3resfail resfail;
++};
++
++/*
++ * Arguments to fsstat (v3).
++ */
++struct FSSTAT3args {
++ nfs_fh3 fsroot;
++};
++
++struct FSSTAT3resok {
++ post_op_attr obj_attributes;
++ size3 tbytes;
++ size3 fbytes;
++ size3 abytes;
++ size3 tfiles;
++ size3 ffiles;
++ size3 afiles;
++ uint32 invarsec;
++};
++
++struct FSSTAT3resfail {
++ post_op_attr obj_attributes;
++};
++
++union FSSTAT3res switch (nfsstat3 status) {
++case NFS3_OK:
++ FSSTAT3resok resok;
++default:
++ FSSTAT3resfail resfail;
++};
++
++/*
++ * Arguments to fsinfo (v3).
++ */
++const FSF3_LINK = 0x0001;
++const FSF3_SYMLINK = 0x0002;
++const FSF3_HOMOGENEOUS = 0x0008;
++const FSF3_CANSETTIME = 0x0010;
++
++struct FSINFO3args {
++ nfs_fh3 fsroot;
++};
++
++struct FSINFO3resok {
++ post_op_attr obj_attributes;
++ uint32 rtmax;
++ uint32 rtpref;
++ uint32 rtmult;
++ uint32 wtmax;
++ uint32 wtpref;
++ uint32 wtmult;
++ uint32 dtpref;
++ size3 maxfilesize;
++ nfstime3 time_delta;
++ uint32 properties;
++};
++
++struct FSINFO3resfail {
++ post_op_attr obj_attributes;
++};
++
++union FSINFO3res switch (nfsstat3 status) {
++case NFS3_OK:
++ FSINFO3resok resok;
++default:
++ FSINFO3resfail resfail;
++};
++
++/*
++ * Arguments to pathconf (v3).
++ */
++struct PATHCONF3args {
++ nfs_fh3 object;
++};
++
++struct PATHCONF3resok {
++ post_op_attr obj_attributes;
++ uint32 linkmax;
++ uint32 name_max;
++ bool no_trunc;
++ bool chown_restricted;
++ bool case_insensitive;
++ bool case_preserving;
++};
++
++struct PATHCONF3resfail {
++ post_op_attr obj_attributes;
++};
++
++union PATHCONF3res switch (nfsstat3 status) {
++case NFS3_OK:
++ PATHCONF3resok resok;
++default:
++ PATHCONF3resfail resfail;
++};
++
++/*
++ * Arguments to commit (v3).
++ */
++struct COMMIT3args {
++ nfs_fh3 file;
++ offset3 offset;
++ count3 count;
++};
++
++struct COMMIT3resok {
++ wcc_data file_wcc;
++ writeverf3 verf;
++};
++
++struct COMMIT3resfail {
++ wcc_data file_wcc;
++};
++
++union COMMIT3res switch (nfsstat3 status) {
++case NFS3_OK:
++ COMMIT3resok resok;
++default:
++ COMMIT3resfail resfail;
++};
++
++#endif /* WANT_NFS3 */
++
++/*
++ * Remote file service routines
++ */
++program NFS_PROGRAM {
++ version NFS_VERSION {
++ void
++ NFSPROC_NULL(void) = 0;
++
++ attrstat
++ NFSPROC_GETATTR(nfs_fh) = 1;
++
++ attrstat
++ NFSPROC_SETATTR(sattrargs) = 2;
++
++ void
++ NFSPROC_ROOT(void) = 3;
++
++ diropres
++ NFSPROC_LOOKUP(diropargs) = 4;
++
++ readlinkres
++ NFSPROC_READLINK(nfs_fh) = 5;
++
++ readres
++ NFSPROC_READ(readargs) = 6;
++
++ void
++ NFSPROC_WRITECACHE(void) = 7;
++
++ attrstat
++ NFSPROC_WRITE(writeargs) = 8;
++
++ diropres
++ NFSPROC_CREATE(createargs) = 9;
++
++ nfsstat
++ NFSPROC_REMOVE(diropargs) = 10;
++
++ nfsstat
++ NFSPROC_RENAME(renameargs) = 11;
++
++ nfsstat
++ NFSPROC_LINK(linkargs) = 12;
++
++ nfsstat
++ NFSPROC_SYMLINK(symlinkargs) = 13;
++
++ diropres
++ NFSPROC_MKDIR(createargs) = 14;
++
++ nfsstat
++ NFSPROC_RMDIR(diropargs) = 15;
++
++ readdirres
++ NFSPROC_READDIR(readdirargs) = 16;
++
++ statfsres
++ NFSPROC_STATFS(nfs_fh) = 17;
++ } = 2;
++} = 100003;
++#ifdef WANT_NFS3
++program NFS3_PROGRAM {
++ version NFS_V3 {
++ void
++ NFSPROC3_NULL(void) = 0;
++
++ GETATTR3res
++ NFSPROC3_GETATTR(GETATTR3args) = 1;
++
++ SETATTR3res
++ NFSPROC3_SETATTR(SETATTR3args) = 2;
++
++ LOOKUP3res
++ NFSPROC3_LOOKUP(LOOKUP3args) = 3;
++
++ ACCESS3res
++ NFSPROC3_ACCESS(ACCESS3args) = 4;
++
++ READLINK3res
++ NFSPROC3_READLINK(READLINK3args) = 5;
++
++ READ3res
++ NFSPROC3_READ(READ3args) = 6;
++
++ WRITE3res
++ NFSPROC3_WRITE(WRITE3args) = 7;
++
++ CREATE3res
++ NFSPROC3_CREATE(CREATE3args) = 8;
++
++ MKDIR3res
++ NFSPROC3_MKDIR(MKDIR3args) = 9;
++
++ SYMLINK3res
++ NFSPROC3_SYMLINK(SYMLINK3args) = 10;
++
++ MKNOD3res
++ NFSPROC3_MKNOD(MKNOD3args) = 11;
++
++ REMOVE3res
++ NFSPROC3_REMOVE(REMOVE3args) = 12;
++
++ RMDIR3res
++ NFSPROC3_RMDIR(RMDIR3args) = 13;
++
++ RENAME3res
++ NFSPROC3_RENAME(RENAME3args) = 14;
++
++ LINK3res
++ NFSPROC3_LINK(LINK3args) = 15;
++
++ READDIR3res
++ NFSPROC3_READDIR(READDIR3args) = 16;
++
++ READDIRPLUS3res
++ NFSPROC3_READDIRPLUS(READDIRPLUS3args) = 17;
++
++ FSSTAT3res
++ NFSPROC3_FSSTAT(FSSTAT3args) = 18;
++
++ FSINFO3res
++ NFSPROC3_FSINFO(FSINFO3args) = 19;
++
++ PATHCONF3res
++ NFSPROC3_PATHCONF(PATHCONF3args) = 20;
++
++ COMMIT3res
++ NFSPROC3_COMMIT(COMMIT3args) = 21;
++ } = 3;
++} = 100003;
++#endif
++
+diff --git a/tirpc/rpcsvc/rquota.x b/tirpc/rpcsvc/rquota.x
+new file mode 100644
+index 0000000..72864d1
+--- /dev/null
++++ b/tirpc/rpcsvc/rquota.x
+@@ -0,0 +1,67 @@
++/*
++ * Remote quota protocol
++ * Requires unix authentication
++ */
++
++#ifndef RPC_HDR
++%#ifndef lint
++%/*static char sccsid[] = "from: @(#)rquota.x 1.2 87/09/20 Copyr 1987 Sun Micro";*/
++%/*static char sccsid[] = "from: @(#)rquota.x 2.1 88/08/01 4.0 RPCSRC";*/
++%static const char rcsid[] =
++% "$FreeBSD: src/include/rpcsvc/rquota.x,v 1.6 1999/08/27 23:45:10 peter Exp $";
++%#endif /* not lint */
++#endif
++
++const RQ_PATHLEN = 1024;
++
++struct getquota_args {
++ string gqa_pathp<RQ_PATHLEN>; /* path to filesystem of interest */
++ int gqa_uid; /* inquire about quota for uid */
++};
++
++/*
++ * remote quota structure
++ */
++struct rquota {
++ int rq_bsize; /* block size for block counts */
++ bool rq_active; /* indicates whether quota is active */
++ unsigned int rq_bhardlimit; /* absolute limit on disk blks alloc */
++ unsigned int rq_bsoftlimit; /* preferred limit on disk blks */
++ unsigned int rq_curblocks; /* current block count */
++ unsigned int rq_fhardlimit; /* absolute limit on allocated files */
++ unsigned int rq_fsoftlimit; /* preferred file limit */
++ unsigned int rq_curfiles; /* current # allocated files */
++ unsigned int rq_btimeleft; /* time left for excessive disk use */
++ unsigned int rq_ftimeleft; /* time left for excessive files */
++};
++
++enum gqr_status {
++ Q_OK = 1, /* quota returned */
++ Q_NOQUOTA = 2, /* noquota for uid */
++ Q_EPERM = 3 /* no permission to access quota */
++};
++
++union getquota_rslt switch (gqr_status status) {
++case Q_OK:
++ rquota gqr_rquota; /* valid if status == Q_OK */
++case Q_NOQUOTA:
++ void;
++case Q_EPERM:
++ void;
++};
++
++program RQUOTAPROG {
++ version RQUOTAVERS {
++ /*
++ * Get all quotas
++ */
++ getquota_rslt
++ RQUOTAPROC_GETQUOTA(getquota_args) = 1;
++
++ /*
++ * Get active quotas only
++ */
++ getquota_rslt
++ RQUOTAPROC_GETACTIVEQUOTA(getquota_args) = 2;
++ } = 1;
++} = 100011;
+--
+2.0.0
+
+++ /dev/null
-From 4285205401faeb12b4ed7ebbc4658af9eae73eb4 Mon Sep 17 00:00:00 2001
-From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
-Date: Sat, 23 Jun 2012 21:57:39 +0200
-Subject: [PATCH] Disable parts of TIRPC requiring NIS support
-
-Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
----
- src/Makefile.am | 3 +--
- src/rpc_soc.c | 2 ++
- tirpc/rpc/auth.h | 3 +++
- 3 files changed, 6 insertions(+), 2 deletions(-)
-
-diff --git a/src/Makefile.am b/src/Makefile.am
-index 3029b78..b5db263 100644
---- a/src/Makefile.am
-+++ b/src/Makefile.am
-@@ -50,8 +50,7 @@ libtirpc_la_SOURCES = auth_none.c auth_unix.c authunix_prot.c bindresvport.c cln
- pmap_prot.c pmap_prot2.c pmap_rmt.c rpc_prot.c rpc_commondata.c \
- rpc_callmsg.c rpc_generic.c rpc_soc.c rpcb_clnt.c rpcb_prot.c \
- rpcb_st_xdr.c svc.c svc_auth.c svc_dg.c svc_auth_unix.c svc_auth_none.c \
-- svc_generic.c svc_raw.c svc_run.c svc_simple.c svc_vc.c getpeereid.c \
-- auth_time.c auth_des.c authdes_prot.c
-+ svc_generic.c svc_raw.c svc_run.c svc_simple.c svc_vc.c getpeereid.c
-
- ## XDR
- libtirpc_la_SOURCES += xdr.c xdr_rec.c xdr_array.c xdr_float.c xdr_mem.c xdr_reference.c xdr_stdio.c
-diff --git a/src/rpc_soc.c b/src/rpc_soc.c
-index 4213ca0..2603548 100644
---- a/src/rpc_soc.c
-+++ b/src/rpc_soc.c
-@@ -520,6 +520,7 @@ clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult)
- (resultproc_t) rpc_wrap_bcast, "udp");
- }
-
-+#if 0
- /*
- * Create the client des authentication object. Obsoleted by
- * authdes_seccreate().
-@@ -551,6 +552,7 @@ fallback:
- dummy = authdes_seccreate(servername, window, NULL, ckey);
- return (dummy);
- }
-+#endif
-
- /*
- * Create a client handle for a unix connection. Obsoleted by clnt_vc_create()
-diff --git a/tirpc/rpc/auth.h b/tirpc/rpc/auth.h
-index 4ce11f0..b894e44 100644
---- a/tirpc/rpc/auth.h
-+++ b/tirpc/rpc/auth.h
-@@ -305,6 +305,8 @@ extern AUTH *authunix_create(char *, uid_t, uid_t, int, uid_t *);
- extern AUTH *authunix_create_default(void); /* takes no parameters */
- extern AUTH *authnone_create(void); /* takes no parameters */
- __END_DECLS
-+
-+#if 0
- /*
- * DES style authentication
- * AUTH *authsecdes_create(servername, window, timehost, ckey)
-@@ -318,6 +320,7 @@ extern AUTH *authdes_create (char *, u_int, struct sockaddr *, des_block *);
- extern AUTH *authdes_seccreate (const char *, const u_int, const char *,
- const des_block *);
- __END_DECLS
-+#endif
-
- __BEGIN_DECLS
- extern bool_t xdr_opaque_auth (XDR *, struct opaque_auth *);
---
-2.0.0
-
+++ /dev/null
-From a20f33ad121fb1e9d1fbc31a0044546450677e7a Mon Sep 17 00:00:00 2001
-From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
-Date: Sat, 23 Jun 2012 21:58:07 +0200
-Subject: [PATCH] uClibc without RPC support does not install rpcent.h
-
-Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
----
- tirpc/rpc/rpcent.h | 5 +++--
- 1 file changed, 3 insertions(+), 2 deletions(-)
-
-diff --git a/tirpc/rpc/rpcent.h b/tirpc/rpc/rpcent.h
-index c865e51..45775ed 100644
---- a/tirpc/rpc/rpcent.h
-+++ b/tirpc/rpc/rpcent.h
-@@ -46,8 +46,9 @@
-
- __BEGIN_DECLS
-
--/* These are defined in /usr/include/rpc/netdb.h */
--#if 0
-+/* These are defined in /usr/include/rpc/netdb.h, unless we are using
-+ the C library without RPC support. */
-+#if defined(__UCLIBC__) && !defined(__UCLIBC_HAS_RPC__)
- struct rpcent {
- char *r_name; /* name of server for this rpc program */
- char **r_aliases; /* alias list */
---
-2.0.0
-
+++ /dev/null
-From fbe5fccf0e3bdaae3defc66a288176797fd12a17 Mon Sep 17 00:00:00 2001
-From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
-Date: Sun, 24 Jun 2012 21:40:21 +0200
-Subject: [PATCH] Make IPv6 support optional
-
-Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
----
- src/Makefile.am | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/src/Makefile.am b/src/Makefile.am
-index b5db263..f086255 100644
---- a/src/Makefile.am
-+++ b/src/Makefile.am
-@@ -7,7 +7,7 @@
-
- noinst_HEADERS = rpc_com.h
-
--AM_CPPFLAGS = -I$(top_srcdir)/tirpc -DPORTMAP -DINET6 \
-+AM_CPPFLAGS = -I$(top_srcdir)/tirpc -DPORTMAP \
- -D_GNU_SOURCE -Wall -pipe
-
- lib_LTLIBRARIES = libtirpc.la
---
-2.0.0
-
+++ /dev/null
-From c4c4550dafabda05d78ca4aa9969db8a4f70affe Mon Sep 17 00:00:00 2001
-From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
-Date: Sat, 10 Nov 2012 16:21:01 +0100
-Subject: [PATCH] Add rpcgen program from nfs-utils sources
-
-Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
----
- Makefile.am | 2 +-
- configure.ac | 14 +-
- rpcgen/Makefile.am | 22 ++
- rpcgen/rpc_clntout.c | 217 ++++++++++
- rpcgen/rpc_cout.c | 706 +++++++++++++++++++++++++++++++++
- rpcgen/rpc_hout.c | 490 +++++++++++++++++++++++
- rpcgen/rpc_main.c | 1067 ++++++++++++++++++++++++++++++++++++++++++++++++++
- rpcgen/rpc_output.h | 16 +
- rpcgen/rpc_parse.c | 609 ++++++++++++++++++++++++++++
- rpcgen/rpc_parse.h | 166 ++++++++
- rpcgen/rpc_sample.c | 247 ++++++++++++
- rpcgen/rpc_scan.c | 474 ++++++++++++++++++++++
- rpcgen/rpc_scan.h | 103 +++++
- rpcgen/rpc_svcout.c | 882 +++++++++++++++++++++++++++++++++++++++++
- rpcgen/rpc_tblout.c | 165 ++++++++
- rpcgen/rpc_util.c | 479 ++++++++++++++++++++++
- rpcgen/rpc_util.h | 166 ++++++++
- rpcgen/rpcgen.1 | 521 ++++++++++++++++++++++++
- 18 files changed, 6344 insertions(+), 2 deletions(-)
- create mode 100644 rpcgen/Makefile.am
- create mode 100644 rpcgen/rpc_clntout.c
- create mode 100644 rpcgen/rpc_cout.c
- create mode 100644 rpcgen/rpc_hout.c
- create mode 100644 rpcgen/rpc_main.c
- create mode 100644 rpcgen/rpc_output.h
- create mode 100644 rpcgen/rpc_parse.c
- create mode 100644 rpcgen/rpc_parse.h
- create mode 100644 rpcgen/rpc_sample.c
- create mode 100644 rpcgen/rpc_scan.c
- create mode 100644 rpcgen/rpc_scan.h
- create mode 100644 rpcgen/rpc_svcout.c
- create mode 100644 rpcgen/rpc_tblout.c
- create mode 100644 rpcgen/rpc_util.c
- create mode 100644 rpcgen/rpc_util.h
- create mode 100644 rpcgen/rpcgen.1
-
-diff --git a/Makefile.am b/Makefile.am
-index 9b812eb..6edf029 100644
---- a/Makefile.am
-+++ b/Makefile.am
-@@ -1,4 +1,4 @@
--SUBDIRS = src man doc
-+SUBDIRS = src man doc rpcgen
- ACLOCAL_AMFLAGS = -I m4
-
- noinst_HEADERS = tirpc/reentrant.h \
-diff --git a/configure.ac b/configure.ac
-index 11df020..4110225 100644
---- a/configure.ac
-+++ b/configure.ac
-@@ -34,5 +34,17 @@ AC_CHECK_LIB([pthread], [pthread_create])
- AC_CHECK_LIB([nsl], [yp_get_default_domain])
-
-
--AC_CONFIG_FILES([Makefile src/Makefile man/Makefile doc/Makefile])
-+AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
-+
-+AC_MSG_CHECKING([for a C compiler for build tools])
-+if test $cross_compiling = yes; then
-+ AC_CHECK_PROGS(CC_FOR_BUILD, gcc cc)
-+else
-+ CC_FOR_BUILD=$CC
-+fi
-+AC_MSG_RESULT([$CC_FOR_BUILD])
-+AC_SUBST(CC_FOR_BUILD)
-+
-+AC_CONFIG_FILES([Makefile src/Makefile man/Makefile doc/Makefile rpcgen/Makefile])
-+
- AC_OUTPUT(libtirpc.pc)
-diff --git a/rpcgen/Makefile.am b/rpcgen/Makefile.am
-new file mode 100644
-index 0000000..2277b6f
---- /dev/null
-+++ b/rpcgen/Makefile.am
-@@ -0,0 +1,22 @@
-+COMPILE = $(CC_FOR_BUILD) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
-+ $(CPPFLAGS_FOR_BUILD) $(AM_CFLAGS) $(CFLAGS_FOR_BUILD)
-+LINK = $(CC_FOR_BUILD) $(AM_CFLAGS) $(CFLAGS_FOR_BUILD) $(AM_LDFLAGS) $(LDFLAGS_FOR_BUILD) -o $@
-+
-+bin_PROGRAMS = rpcgen
-+
-+rpcgen_SOURCES = \
-+ rpc_clntout.c \
-+ rpc_cout.c \
-+ rpc_hout.c \
-+ rpc_main.c \
-+ rpc_parse.c \
-+ rpc_sample.c \
-+ rpc_scan.c \
-+ rpc_svcout.c \
-+ rpc_tblout.c \
-+ rpc_util.c \
-+ rpc_parse.h \
-+ rpc_scan.h \
-+ rpc_util.h
-+
-+dist_man1_MANS = rpcgen.1
-diff --git a/rpcgen/rpc_clntout.c b/rpcgen/rpc_clntout.c
-new file mode 100644
-index 0000000..e2f4382
---- /dev/null
-+++ b/rpcgen/rpc_clntout.c
-@@ -0,0 +1,217 @@
-+/*
-+ * Copyright (c) 2009, Sun Microsystems, Inc.
-+ * All rights reserved.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions are met:
-+ * - Redistributions of source code must retain the above copyright notice,
-+ * this list of conditions and the following disclaimer.
-+ * - Redistributions in binary form must reproduce the above copyright notice,
-+ * this list of conditions and the following disclaimer in the documentation
-+ * and/or other materials provided with the distribution.
-+ * - Neither the name of Sun Microsystems, Inc. nor the names of its
-+ * contributors may be used to endorse or promote products derived
-+ * from this software without specific prior written permission.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-+ * POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+#if 0
-+static char sccsid[] = "@(#)rpc_clntout.c 1.11 89/02/22 (C) 1987 SMI";
-+#endif
-+
-+/*
-+ * rpc_clntout.c, Client-stub outputter for the RPC protocol compiler
-+ * Copyright (C) 1987, Sun Microsytsems, Inc.
-+ */
-+#include <stdio.h>
-+#include <string.h>
-+#include <rpc/types.h>
-+#include "rpc_parse.h"
-+#include "rpc_util.h"
-+#include "rpc_output.h"
-+
-+/* extern pdeclaration(); */
-+/* void printarglist(); */
-+
-+#define DEFAULT_TIMEOUT 25 /* in seconds */
-+static char RESULT[] = "clnt_res";
-+
-+static void write_program(definition *def);
-+static void printbody(proc_list *proc);
-+
-+
-+void
-+write_stubs(void)
-+{
-+ list *l;
-+ definition *def;
-+
-+ f_print(fout,
-+ "\n/* Default timeout can be changed using clnt_control() */\n");
-+ f_print(fout, "static struct timeval TIMEOUT = { %d, 0 };\n",
-+ DEFAULT_TIMEOUT);
-+ for (l = defined; l != NULL; l = l->next) {
-+ def = (definition *) l->val;
-+ if (def->def_kind == DEF_PROGRAM) {
-+ write_program(def);
-+ }
-+ }
-+}
-+
-+static void
-+write_program(definition *def)
-+{
-+ version_list *vp;
-+ proc_list *proc;
-+
-+ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
-+ for (proc = vp->procs; proc != NULL; proc = proc->next) {
-+ f_print(fout, "\n");
-+ ptype(proc->res_prefix, proc->res_type, 1);
-+ f_print(fout, "*\n");
-+ pvname(proc->proc_name, vp->vers_num);
-+ printarglist(proc, "clnt", "CLIENT *");
-+ f_print(fout, "{\n");
-+ printbody(proc);
-+ f_print(fout, "}\n");
-+ }
-+ }
-+}
-+
-+/*
-+ * Writes out declarations of procedure's argument list.
-+ * In either ANSI C style, in one of old rpcgen style (pass by reference),
-+ * or new rpcgen style (multiple arguments, pass by value);
-+ */
-+
-+/* sample addargname = "clnt"; sample addargtype = "CLIENT * " */
-+
-+void
-+printarglist(proc_list *proc, char *addargname, char *addargtype)
-+{
-+
-+ decl_list *l;
-+
-+ if (!newstyle) { /* old style: always pass arg by reference */
-+ if (Cflag) { /* C++ style heading */
-+ f_print(fout, "(");
-+ ptype(proc->args.decls->decl.prefix, proc->args.decls->decl.type, 1);
-+ f_print(fout, "*argp, %s%s)\n", addargtype, addargname);
-+ } else {
-+ f_print(fout, "(argp, %s)\n", addargname);
-+ f_print(fout, "\t");
-+ ptype(proc->args.decls->decl.prefix, proc->args.decls->decl.type, 1);
-+ f_print(fout, "*argp;\n");
-+ }
-+ } else if (streq(proc->args.decls->decl.type, "void")) {
-+ /* newstyle, 0 argument */
-+ if (Cflag)
-+ f_print(fout, "(%s%s)\n", addargtype, addargname);
-+ else
-+ f_print(fout, "(%s)\n", addargname);
-+ } else {
-+ /* new style, 1 or multiple arguments */
-+ if (!Cflag) {
-+ f_print(fout, "(");
-+ for (l = proc->args.decls; l != NULL; l = l->next)
-+ f_print(fout, "%s, ", l->decl.name);
-+ f_print(fout, "%s)\n", addargname);
-+ for (l = proc->args.decls; l != NULL; l = l->next) {
-+ pdeclaration(proc->args.argname, &l->decl, 1, ";\n");
-+ }
-+ } else { /* C++ style header */
-+ f_print(fout, "(");
-+ for (l = proc->args.decls; l != NULL; l = l->next) {
-+ pdeclaration(proc->args.argname, &l->decl, 0, ", ");
-+ }
-+ f_print(fout, " %s%s)\n", addargtype, addargname);
-+ }
-+ }
-+
-+ if (!Cflag)
-+ f_print(fout, "\t%s%s;\n", addargtype, addargname);
-+}
-+
-+
-+
-+static char *
-+ampr(char *type)
-+{
-+ if (isvectordef(type, REL_ALIAS)) {
-+ return ("");
-+ } else {
-+ return ("&");
-+ }
-+}
-+
-+static void
-+printbody(proc_list *proc)
-+{
-+ decl_list *l;
-+ bool_t args2 = (proc->arg_num > 1);
-+
-+ /* For new style with multiple arguments, need a structure in which
-+ * to stuff the arguments. */
-+ if (newstyle && args2) {
-+ f_print(fout, "\t%s", proc->args.argname);
-+ f_print(fout, " arg;\n");
-+ }
-+ f_print(fout, "\tstatic ");
-+ if (streq(proc->res_type, "void")) {
-+ f_print(fout, "char ");
-+ } else {
-+ ptype(proc->res_prefix, proc->res_type, 0);
-+ }
-+ f_print(fout, "%s;\n", RESULT);
-+ f_print(fout, "\n");
-+ f_print(fout, "\tmemset((char *)%s%s, 0, sizeof(%s));\n",
-+ ampr(proc->res_type), RESULT, RESULT);
-+ if (newstyle && !args2 && (streq(proc->args.decls->decl.type, "void"))) {
-+ /* newstyle, 0 arguments */
-+ f_print(fout,
-+ "\tif (clnt_call(clnt, %s, (xdrproc_t) xdr_void, (caddr_t) NULL, "
-+ "(xdrproc_t) xdr_%s, (caddr_t) %s%s, TIMEOUT) != RPC_SUCCESS) {\n",
-+ proc->proc_name,
-+ stringfix(proc->res_type), ampr(proc->res_type), RESULT);
-+
-+ } else if (newstyle && args2) {
-+ /* newstyle, multiple arguments: stuff arguments into structure */
-+ for (l = proc->args.decls; l != NULL; l = l->next) {
-+ f_print(fout, "\targ.%s = %s;\n",
-+ l->decl.name, l->decl.name);
-+ }
-+ f_print(fout,
-+ "\tif (clnt_call(clnt, %s, (xdrproc_t) xdr_%s, (caddr_t) &arg, "
-+ "(xdrproc_t) xdr_%s, (caddr_t) %s%s, TIMEOUT) != RPC_SUCCESS) {\n",
-+ proc->proc_name, proc->args.argname,
-+ stringfix(proc->res_type), ampr(proc->res_type), RESULT);
-+ } else { /* single argument, new or old style */
-+ f_print(fout,
-+ "\tif (clnt_call(clnt, %s, (xdrproc_t) xdr_%s, "
-+ "(caddr_t) %s%s, (xdrproc_t) xdr_%s, (caddr_t) %s%s, TIMEOUT) != RPC_SUCCESS) {\n",
-+ proc->proc_name,
-+ stringfix(proc->args.decls->decl.type),
-+ (newstyle ? "&" : ""),
-+ (newstyle ? proc->args.decls->decl.name : "argp"),
-+ stringfix(proc->res_type), ampr(proc->res_type), RESULT);
-+ }
-+ f_print(fout, "\t\treturn (NULL);\n");
-+ f_print(fout, "\t}\n");
-+ if (streq(proc->res_type, "void")) {
-+ f_print(fout, "\treturn ((void *)%s%s);\n",
-+ ampr(proc->res_type), RESULT);
-+ } else {
-+ f_print(fout, "\treturn (%s%s);\n", ampr(proc->res_type), RESULT);
-+ }
-+}
-diff --git a/rpcgen/rpc_cout.c b/rpcgen/rpc_cout.c
-new file mode 100644
-index 0000000..a61214f
---- /dev/null
-+++ b/rpcgen/rpc_cout.c
-@@ -0,0 +1,706 @@
-+/*
-+ * Copyright (c) 2009, Sun Microsystems, Inc.
-+ * All rights reserved.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions are met:
-+ * - Redistributions of source code must retain the above copyright notice,
-+ * this list of conditions and the following disclaimer.
-+ * - Redistributions in binary form must reproduce the above copyright notice,
-+ * this list of conditions and the following disclaimer in the documentation
-+ * and/or other materials provided with the distribution.
-+ * - Neither the name of Sun Microsystems, Inc. nor the names of its
-+ * contributors may be used to endorse or promote products derived
-+ * from this software without specific prior written permission.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-+ * POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+#if 0
-+static char sccsid[] = "@(#)rpc_cout.c 1.13 89/02/22 (C) 1987 SMI";
-+#endif
-+
-+/*
-+ * rpc_cout.c, XDR routine outputter for the RPC protocol compiler
-+ */
-+#include <stdio.h>
-+#include <string.h>
-+#include <stdlib.h>
-+#include <malloc.h>
-+#include <ctype.h>
-+#include "rpc_parse.h"
-+#include "rpc_util.h"
-+
-+static int findtype(definition *def, char *type);
-+static int undefined(char *type);
-+static void print_generic_header(char *procname, int pointerp);
-+static void print_header(definition *def);
-+static void print_prog_header(proc_list *plist);
-+static void print_trailer(void);
-+static void print_ifopen(int indent, char *name);
-+static void print_ifarg(char *arg);
-+static void print_ifsizeof(char *prefix, char *type);
-+static void print_ifclose(int indent);
-+static void print_ifstat(int indent, char *prefix, char *type, relation rel,
-+ char *amax, char *objname, char *name);
-+static void emit_enum(definition *def);
-+static void emit_program(definition *def);
-+static void emit_union(definition *def);
-+static void emit_struct(definition *def);
-+static void emit_typedef(definition *def);
-+static void print_stat(int indent, declaration *dec);
-+static void emit_inline(declaration *decl, int flag);
-+static void emit_single_in_line(declaration *decl, int flag, relation rel);
-+static char * upcase(char *str);
-+
-+/*
-+ * Emit the C-routine for the given definition
-+ */
-+void
-+emit(definition *def)
-+{
-+ if (def->def_kind == DEF_CONST) {
-+ return;
-+ }
-+ if (def->def_kind == DEF_PROGRAM) {
-+ emit_program(def);
-+ return;
-+ }
-+ if (def->def_kind == DEF_TYPEDEF) {
-+ /* now we need to handle declarations like
-+ * struct typedef foo foo;
-+ * since we dont want this to be expanded into 2 calls
-+ * to xdr_foo */
-+
-+ if (strcmp(def->def.ty.old_type, def->def_name) == 0)
-+ return;
-+ };
-+
-+ print_header(def);
-+ switch (def->def_kind) {
-+ case DEF_UNION:
-+ emit_union(def);
-+ break;
-+ case DEF_ENUM:
-+ emit_enum(def);
-+ break;
-+ case DEF_STRUCT:
-+ emit_struct(def);
-+ break;
-+ case DEF_TYPEDEF:
-+ emit_typedef(def);
-+ break;
-+ default:
-+ break;
-+ }
-+ print_trailer();
-+}
-+
-+static int
-+findtype(definition *def, char *type)
-+{
-+
-+ if (def->def_kind == DEF_PROGRAM || def->def_kind == DEF_CONST) {
-+ return (0);
-+ } else {
-+ return (streq(def->def_name, type));
-+ }
-+}
-+
-+static int
-+undefined(char *type)
-+{
-+ definition *def;
-+
-+ def = (definition *) FINDVAL(defined, type, findtype);
-+
-+ return (def == NULL);
-+}
-+
-+
-+static void
-+print_generic_header(char *procname, int pointerp)
-+{
-+ f_print(fout, "\n");
-+ f_print(fout, "bool_t\n");
-+ if (Cflag) {
-+ f_print(fout, "xdr_%s(", procname);
-+ f_print(fout, "XDR *xdrs, ");
-+ f_print(fout, "%s ", procname);
-+ if (pointerp)
-+ f_print(fout, "*");
-+ f_print(fout, "objp)\n{\n\n");
-+ } else {
-+ f_print(fout, "xdr_%s(xdrs, objp)\n", procname);
-+ f_print(fout, "\tXDR *xdrs;\n");
-+ f_print(fout, "\t%s ", procname);
-+ if (pointerp)
-+ f_print(fout, "*");
-+ f_print(fout, "objp;\n{\n\n");
-+ }
-+}
-+
-+static void
-+print_header(definition *def)
-+{
-+ print_generic_header(def->def_name,
-+ def->def_kind != DEF_TYPEDEF ||
-+ !isvectordef(def->def.ty.old_type, def->def.ty.rel));
-+
-+ /* Now add Inline support */
-+
-+
-+ if (Inline == 0)
-+ return;
-+}
-+
-+static void
-+print_prog_header(proc_list *plist)
-+{
-+ print_generic_header(plist->args.argname, 1);
-+}
-+
-+static void
-+print_trailer(void)
-+{
-+ f_print(fout, "\treturn (TRUE);\n");
-+ f_print(fout, "}\n");
-+}
-+
-+
-+static void
-+print_ifopen(int indent, char *name)
-+{
-+ tabify(fout, indent);
-+ f_print(fout, " if (!xdr_%s(xdrs", name);
-+}
-+
-+static void
-+print_ifarg(char *arg)
-+{
-+ f_print(fout, ", %s", arg);
-+}
-+
-+static void
-+print_ifsizeof(char *prefix, char *type)
-+{
-+ if (streq(type, "bool")) {
-+ f_print(fout, ", sizeof(bool_t), (xdrproc_t)xdr_bool");
-+ } else {
-+ f_print(fout, ", sizeof(");
-+ if (undefined(type) && prefix) {
-+ f_print(fout, "%s ", prefix);
-+ }
-+ f_print(fout, "%s), (xdrproc_t)xdr_%s", type, type);
-+ }
-+}
-+
-+static void
-+print_ifclose(int indent)
-+{
-+ f_print(fout, ")) {\n");
-+ tabify(fout, indent);
-+ f_print(fout, "\t return (FALSE);\n");
-+ tabify(fout, indent);
-+ f_print(fout, " }\n");
-+}
-+
-+static void
-+print_ifstat(int indent, char *prefix, char *type, relation rel,
-+ char *amax, char *objname, char *name)
-+{
-+ char *alt = NULL;
-+
-+ switch (rel) {
-+ case REL_POINTER:
-+ print_ifopen(indent, "pointer");
-+ print_ifarg("(char **)");
-+ f_print(fout, "%s", objname);
-+ print_ifsizeof(prefix, type);
-+ break;
-+ case REL_VECTOR:
-+ if (streq(type, "string")) {
-+ alt = "string";
-+ } else if (streq(type, "opaque")) {
-+ alt = "opaque";
-+ }
-+ if (alt) {
-+ print_ifopen(indent, alt);
-+ print_ifarg(objname);
-+ } else {
-+ print_ifopen(indent, "vector");
-+ print_ifarg("(char *)");
-+ f_print(fout, "%s", objname);
-+ }
-+ print_ifarg(amax);
-+ if (!alt) {
-+ print_ifsizeof(prefix, type);
-+ }
-+ break;
-+ case REL_ARRAY:
-+ if (streq(type, "string")) {
-+ alt = "string";
-+ } else if (streq(type, "opaque")) {
-+ alt = "bytes";
-+ }
-+ if (streq(type, "string")) {
-+ print_ifopen(indent, alt);
-+ print_ifarg(objname);
-+ } else {
-+ if (alt) {
-+ print_ifopen(indent, alt);
-+ } else {
-+ print_ifopen(indent, "array");
-+ }
-+ /* The (void*) avoids a gcc-4.1 warning */
-+ print_ifarg("(char **)(void*)");
-+ if (*objname == '&') {
-+ f_print(fout, "%s.%s_val, (u_int *)%s.%s_len",
-+ objname, name, objname, name);
-+ } else {
-+ f_print(fout, "&%s->%s_val, (u_int *)&%s->%s_len",
-+ objname, name, objname, name);
-+ }
-+ }
-+ print_ifarg(amax);
-+ if (!alt) {
-+ print_ifsizeof(prefix, type);
-+ }
-+ break;
-+ case REL_ALIAS:
-+ print_ifopen(indent, type);
-+ print_ifarg(objname);
-+ break;
-+ }
-+ print_ifclose(indent);
-+}
-+
-+static void
-+emit_enum(definition *def)
-+{
-+ print_ifopen(1, "enum");
-+ print_ifarg("(enum_t *)objp");
-+ print_ifclose(1);
-+}
-+
-+static void
-+emit_program(definition *def)
-+{
-+ decl_list *dl;
-+ version_list *vlist;
-+ proc_list *plist;
-+
-+ for (vlist = def->def.pr.versions; vlist != NULL; vlist = vlist->next)
-+ for (plist = vlist->procs; plist != NULL; plist = plist->next) {
-+ if (!newstyle || plist->arg_num < 2)
-+ continue;/* old style, or single argument */
-+ print_prog_header(plist);
-+ for (dl = plist->args.decls; dl != NULL; dl = dl->next)
-+ print_stat(1, &dl->decl);
-+ print_trailer();
-+ }
-+}
-+
-+
-+static void
-+emit_union(definition *def)
-+{
-+ declaration *dflt;
-+ case_list *cl;
-+ declaration *cs;
-+ char *object;
-+ char *vecformat = "objp->%s_u.%s";
-+ char *format = "&objp->%s_u.%s";
-+
-+ print_stat(1,&def->def.un.enum_decl);
-+ f_print(fout, "\tswitch (objp->%s) {\n", def->def.un.enum_decl.name);
-+ for (cl = def->def.un.cases; cl != NULL; cl = cl->next) {
-+
-+ f_print(fout, "\tcase %s:\n", cl->case_name);
-+ if(cl->contflag == 1) /* a continued case statement */
-+ continue;
-+ cs = &cl->case_decl;
-+ if (!streq(cs->type, "void")) {
-+ object = alloc(strlen(def->def_name) + strlen(format) +
-+ strlen(cs->name) + 1);
-+ if (isvectordef (cs->type, cs->rel)) {
-+ s_print(object, vecformat, def->def_name,
-+ cs->name);
-+ } else {
-+ s_print(object, format, def->def_name,
-+ cs->name);
-+ }
-+ print_ifstat(2, cs->prefix, cs->type, cs->rel, cs->array_max,
-+ object, cs->name);
-+ free(object);
-+ }
-+ f_print(fout, "\t\tbreak;\n");
-+ }
-+ dflt = def->def.un.default_decl;
-+ if (dflt != NULL) {
-+ if (!streq(dflt->type, "void")) {
-+ f_print(fout, "\tdefault:\n");
-+ object = alloc(strlen(def->def_name) + strlen(format) +
-+ strlen(dflt->name) + 1);
-+ if (isvectordef (dflt->type, dflt->rel)) {
-+ s_print(object, vecformat, def->def_name,
-+ dflt->name);
-+ } else {
-+ s_print(object, format, def->def_name,
-+ dflt->name);
-+ }
-+
-+ print_ifstat(2, dflt->prefix, dflt->type, dflt->rel,
-+ dflt->array_max, object, dflt->name);
-+ free(object);
-+ f_print(fout, "\t\tbreak;\n");
-+ } else {
-+ /* Avoid gcc warnings about `value not handled in switch' */
-+ f_print(fout, "\tdefault:\n");
-+ f_print(fout, "\t\tbreak;\n");
-+ }
-+ } else {
-+ f_print(fout, "\tdefault:\n");
-+ f_print(fout, "\t\treturn (FALSE);\n");
-+ }
-+
-+ f_print(fout, "\t}\n");
-+}
-+
-+static void
-+emit_struct(definition *def)
-+{
-+ decl_list *dl;
-+ int i, j, size, flag;
-+ decl_list *cur = NULL, *psav;
-+ bas_type *ptr;
-+ char *sizestr, *plus;
-+ char ptemp[256];
-+ int can_inline;
-+ const char *buf_declaration;
-+
-+
-+ if (Inline == 0) {
-+ for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
-+ print_stat(1, &dl->decl);
-+ } else {
-+ size = 0;
-+ can_inline = 0;
-+ for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
-+ if ((dl->decl.prefix == NULL) && ((ptr = find_type(dl->decl.type)) != NULL) && ((dl->decl.rel == REL_ALIAS) || (dl->decl.rel == REL_VECTOR))) {
-+
-+ if (dl->decl.rel == REL_ALIAS)
-+ size += ptr->length;
-+ else {
-+ can_inline = 1;
-+ break; /* can be inlined */
-+ };
-+ } else {
-+ if (size >= Inline) {
-+ can_inline = 1;
-+ break; /* can be inlined */
-+ }
-+ size = 0;
-+ }
-+ if (size > Inline)
-+ can_inline = 1;
-+
-+ if (can_inline == 0) { /* can not inline, drop back to old mode */
-+ for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
-+ print_stat(1, &dl->decl);
-+ return;
-+ };
-+
-+
-+
-+
-+ flag = PUT;
-+ for (j = 0; j < 2; j++) {
-+
-+ if (flag == PUT)
-+ f_print(fout, "\n\t if (xdrs->x_op == XDR_ENCODE) {\n");
-+ else
-+ f_print(fout, "\n \t return (TRUE);\n\t} else if (xdrs->x_op == XDR_DECODE) {\n");
-+
-+
-+ i = 0;
-+ size = 0;
-+ sizestr = NULL;
-+ buf_declaration = "int32_t *";
-+ for (dl = def->def.st.decls; dl != NULL; dl = dl->next) { /* xxx */
-+
-+ /* now walk down the list and check for basic types */
-+ if ((dl->decl.prefix == NULL) && ((ptr = find_type(dl->decl.type)) != NULL) && ((dl->decl.rel == REL_ALIAS) || (dl->decl.rel == REL_VECTOR))) {
-+ if (i == 0)
-+ cur = dl;
-+ i++;
-+
-+ if (dl->decl.rel == REL_ALIAS)
-+ size += ptr->length;
-+ else {
-+ /* this is required to handle arrays */
-+
-+ if (sizestr == NULL)
-+ plus = " ";
-+ else
-+ plus = "+";
-+
-+ if (ptr->length != 1)
-+ s_print(ptemp, " %s %s * %d", plus, dl->decl.array_max, ptr->length);
-+ else
-+ s_print(ptemp, " %s %s ", plus, dl->decl.array_max);
-+
-+ /*now concatenate to sizestr !!!! */
-+ if (sizestr == NULL)
-+ sizestr = strdup(ptemp);
-+ else {
-+ sizestr = realloc(sizestr, strlen(sizestr) + strlen(ptemp) + 1);
-+ if (sizestr == NULL) {
-+
-+ f_print(stderr, "Fatal error : no memory \n");
-+ crash();
-+ };
-+ sizestr = strcat(sizestr, ptemp); /*build up length of array */
-+
-+ }
-+ }
-+
-+ } else {
-+ if (i > 0)
-+ {
-+ if (sizestr == NULL && size < Inline) {
-+ /* don't expand into inline code if size < inline */
-+ while (cur != dl) {
-+ print_stat(1, &cur->decl);
-+ cur = cur->next;
-+ }
-+ } else {
-+
-+
-+
-+ /* were already looking at a xdr_inlineable structure */
-+ if (sizestr == NULL)
-+ f_print(fout, "\t %sbuf = XDR_INLINE(xdrs,%d * BYTES_PER_XDR_UNIT);",
-+ buf_declaration, size);
-+ else if (size == 0)
-+ f_print(fout,
-+ "\t %sbuf = XDR_INLINE(xdrs,%s * BYTES_PER_XDR_UNIT);",
-+ buf_declaration, sizestr);
-+ else
-+ f_print(fout,
-+ "\t %sbuf = XDR_INLINE(xdrs,(%d + %s)* BYTES_PER_XDR_UNIT);",
-+ buf_declaration, size, sizestr);
-+ buf_declaration = "";
-+
-+ f_print(fout, "\n\t if (buf == NULL) {\n");
-+
-+ psav = cur;
-+ while (cur != dl) {
-+ print_stat(2, &cur->decl);
-+ cur = cur->next;
-+ }
-+
-+ f_print(fout, "\n\t }\n\t else {\n");
-+
-+ cur = psav;
-+ while (cur != dl) {
-+ emit_inline(&cur->decl, flag);
-+ cur = cur->next;
-+ }
-+
-+ f_print(fout, "\t }\n");
-+ }
-+ }
-+ size = 0;
-+ i = 0;
-+ sizestr = NULL;
-+ print_stat(1, &dl->decl);
-+ }
-+
-+ }
-+ if (i > 0)
-+ {
-+ if (sizestr == NULL && size < Inline) {
-+ /* don't expand into inline code if size < inline */
-+ while (cur != dl) {
-+ print_stat(1, &cur->decl);
-+ cur = cur->next;
-+ }
-+ } else {
-+
-+ /* were already looking at a xdr_inlineable structure */
-+ if (sizestr == NULL)
-+ f_print(fout, "\t\t%sbuf = XDR_INLINE(xdrs,%d * BYTES_PER_XDR_UNIT);",
-+ buf_declaration, size);
-+ else if (size == 0)
-+ f_print(fout,
-+ "\t\t%sbuf = XDR_INLINE(xdrs,%s * BYTES_PER_XDR_UNIT);",
-+ buf_declaration, sizestr);
-+ else
-+ f_print(fout,
-+ "\t\t%sbuf = XDR_INLINE(xdrs,(%d + %s)* BYTES_PER_XDR_UNIT);",
-+ buf_declaration, size, sizestr);
-+ buf_declaration = "";
-+
-+ f_print(fout, "\n\t\tif (buf == NULL) {\n");
-+
-+ psav = cur;
-+ while (cur != NULL) {
-+ print_stat(2, &cur->decl);
-+ cur = cur->next;
-+ }
-+ f_print(fout, "\n\t }\n\t else {\n");
-+
-+ cur = psav;
-+ while (cur != dl) {
-+ emit_inline(&cur->decl, flag);
-+ cur = cur->next;
-+ }
-+
-+ f_print(fout, "\t }\n");
-+
-+ }
-+ }
-+ flag = GET;
-+ }
-+ f_print(fout, "\t return(TRUE);\n\t}\n\n");
-+
-+ /* now take care of XDR_FREE case */
-+
-+ for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
-+ print_stat(1, &dl->decl);
-+ }
-+}
-+
-+
-+
-+
-+static void
-+emit_typedef(definition *def)
-+{
-+ char *prefix = def->def.ty.old_prefix;
-+ char *type = def->def.ty.old_type;
-+ char *amax = def->def.ty.array_max;
-+ relation rel = def->def.ty.rel;
-+
-+
-+ print_ifstat(1, prefix, type, rel, amax, "objp", def->def_name);
-+}
-+
-+static void
-+print_stat(int indent, declaration *dec)
-+{
-+ char *prefix = dec->prefix;
-+ char *type = dec->type;
-+ char *amax = dec->array_max;
-+ relation rel = dec->rel;
-+ char name[256];
-+
-+ if (isvectordef(type, rel)) {
-+ s_print(name, "objp->%s", dec->name);
-+ } else {
-+ s_print(name, "&objp->%s", dec->name);
-+ }
-+ print_ifstat(indent, prefix, type, rel, amax, name, dec->name);
-+}
-+
-+
-+static void
-+emit_inline(declaration *decl, int flag)
-+{
-+
-+ /*check whether an array or not */
-+
-+ switch (decl->rel) {
-+ case REL_ALIAS:
-+ emit_single_in_line(decl, flag, REL_ALIAS);
-+ break;
-+ case REL_VECTOR:
-+ f_print(fout, "\t\t{ register %s *genp; \n", decl->type);
-+ f_print(fout, "\t\t int i;\n");
-+ f_print(fout, "\t\t for ( i = 0,genp=objp->%s;\n \t\t\ti < %s; i++){\n\t\t",
-+ decl->name, decl->array_max);
-+ emit_single_in_line(decl, flag, REL_VECTOR);
-+ f_print(fout, "\t\t }\n\t\t };\n");
-+ break;
-+ default:
-+ break;
-+ }
-+}
-+
-+static void
-+emit_single_in_line(declaration *decl, int flag, relation rel)
-+{
-+ char *upp_case;
-+ int freed=0;
-+
-+ if(flag == PUT)
-+ f_print(fout,"\t\t (void) IXDR_PUT_");
-+ else
-+ if(rel== REL_ALIAS)
-+ f_print(fout,"\t\t objp->%s = IXDR_GET_",decl->name);
-+ else
-+ f_print(fout,"\t\t *genp++ = IXDR_GET_");
-+
-+ upp_case=upcase(decl->type);
-+
-+ /* hack - XX */
-+ if(strcmp(upp_case,"INT") == 0)
-+ {
-+ free(upp_case);
-+ freed=1;
-+ upp_case="INT32";
-+ }
-+
-+ if(strcmp(upp_case,"U_INT") == 0)
-+ {
-+ free(upp_case);
-+ freed=1;
-+ upp_case="U_INT32";
-+ }
-+
-+
-+ if(flag == PUT)
-+ if(rel== REL_ALIAS)
-+ f_print(fout,"%s(buf,objp->%s);\n",upp_case,decl->name);
-+ else
-+ f_print(fout,"%s(buf,*genp++);\n",upp_case);
-+
-+ else
-+ f_print(fout,"%s(buf);\n",upp_case);
-+ if(!freed)
-+ free(upp_case);
-+
-+}
-+
-+
-+static char *
-+upcase(char *str)
-+{
-+ char *ptr, *hptr;
-+
-+
-+ ptr = (char *) malloc(strlen(str)+1);
-+ if (ptr == (char *) NULL) {
-+ f_print(stderr, "malloc failed \n");
-+ exit(1);
-+ };
-+
-+ hptr = ptr;
-+ while (*str != '\0')
-+ *ptr++ = toupper(*str++);
-+
-+ *ptr = '\0';
-+ return (hptr);
-+
-+}
-diff --git a/rpcgen/rpc_hout.c b/rpcgen/rpc_hout.c
-new file mode 100644
-index 0000000..ea1cb24
---- /dev/null
-+++ b/rpcgen/rpc_hout.c
-@@ -0,0 +1,490 @@
-+/*
-+ * Copyright (c) 2009, Sun Microsystems, Inc.
-+ * All rights reserved.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions are met:
-+ * - Redistributions of source code must retain the above copyright notice,
-+ * this list of conditions and the following disclaimer.
-+ * - Redistributions in binary form must reproduce the above copyright notice,
-+ * this list of conditions and the following disclaimer in the documentation
-+ * and/or other materials provided with the distribution.
-+ * - Neither the name of Sun Microsystems, Inc. nor the names of its
-+ * contributors may be used to endorse or promote products derived
-+ * from this software without specific prior written permission.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-+ * POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+#if 0
-+static char sccsid[] = "@(#)rpc_hout.c 1.12 89/02/22 (C) 1987 SMI";
-+#endif
-+
-+/*
-+ * rpc_hout.c, Header file outputter for the RPC protocol compiler
-+ */
-+#include <stdio.h>
-+#include <ctype.h>
-+#include "rpc_parse.h"
-+#include "rpc_util.h"
-+#include "rpc_output.h"
-+
-+
-+static int undefined2(char *type, char *stop);
-+static void pxdrfuncdecl(char *name, int pointerp);
-+static void pconstdef(definition *def);
-+static void pargdef(definition *def);
-+static void pstructdef(definition *def);
-+static void puniondef(definition *def);
-+static void pdefine(char *name, char *num);
-+static void puldefine(char *name, char *num);
-+static int define_printed(proc_list *stop, version_list *start);
-+static void pprogramdef(definition *def);
-+static void pprocdef(proc_list *proc, version_list *vp,
-+ char *addargtype, int server_p, int mode);
-+static void parglist(proc_list *proc, char *addargtype);
-+static void penumdef(definition *def);
-+static void ptypedef(definition *def);
-+
-+/*
-+ * Print the C-version of an xdr definition
-+ */
-+void
-+print_datadef(definition *def)
-+{
-+
-+ if (def->def_kind == DEF_PROGRAM ) /* handle data only */
-+ return;
-+
-+ if (def->def_kind != DEF_CONST) {
-+ f_print(fout, "\n");
-+ }
-+ switch (def->def_kind) {
-+ case DEF_STRUCT:
-+ pstructdef(def);
-+ break;
-+ case DEF_UNION:
-+ puniondef(def);
-+ break;
-+ case DEF_ENUM:
-+ penumdef(def);
-+ break;
-+ case DEF_TYPEDEF:
-+ ptypedef(def);
-+ break;
-+ case DEF_PROGRAM:
-+ pprogramdef(def);
-+ break;
-+ case DEF_CONST:
-+ pconstdef(def);
-+ break;
-+ }
-+ if (def->def_kind != DEF_PROGRAM && def->def_kind != DEF_CONST) {
-+ pxdrfuncdecl( def->def_name,
-+ def->def_kind != DEF_TYPEDEF ||
-+ !isvectordef(def->def.ty.old_type, def->def.ty.rel));
-+
-+ }
-+}
-+
-+
-+void
-+print_funcdef(definition *def)
-+{
-+ switch (def->def_kind) {
-+ case DEF_PROGRAM:
-+ f_print(fout, "\n");
-+ pprogramdef(def);
-+ break;
-+ default:
-+ break;
-+ }
-+}
-+
-+static void
-+pxdrfuncdecl(char *name, int pointerp)
-+{
-+ f_print(fout,
-+ "#ifdef __cplusplus \n"
-+ "extern \"C\" bool_t xdr_%s(XDR *, %s%s);\n"
-+ "#elif __STDC__ \n"
-+ "extern bool_t xdr_%s(XDR *, %s%s);\n"
-+ "#else /* Old Style C */ \n"
-+ "bool_t xdr_%s();\n"
-+ "#endif /* Old Style C */ \n\n",
-+ name, name, pointerp ? "*" : "",
-+ name, name, pointerp ? "*" : "",
-+ name);
-+}
-+
-+
-+static void
-+pconstdef(definition *def)
-+{
-+ pdefine(def->def_name, def->def.co);
-+}
-+
-+/* print out the definitions for the arguments of functions in the
-+ header file
-+*/
-+static void
-+pargdef(definition *def)
-+{
-+ decl_list *l;
-+ version_list *vers;
-+ char *name;
-+ proc_list *plist;
-+
-+
-+ for (vers = def->def.pr.versions; vers != NULL; vers = vers->next) {
-+ for(plist = vers->procs; plist != NULL;
-+ plist = plist->next) {
-+
-+ if (!newstyle || plist->arg_num < 2) {
-+ continue; /* old style or single args */
-+ }
-+ name = plist->args.argname;
-+ f_print(fout, "struct %s {\n", name);
-+ for (l = plist->args.decls;
-+ l != NULL; l = l->next) {
-+ pdeclaration(name, &l->decl, 1, ";\n" );
-+ }
-+ f_print(fout, "};\n");
-+ f_print(fout, "typedef struct %s %s;\n", name, name);
-+ pxdrfuncdecl(name, 0);
-+ f_print( fout, "\n" );
-+ }
-+ }
-+
-+}
-+
-+
-+static void
-+pstructdef(definition *def)
-+{
-+ decl_list *l;
-+ char *name = def->def_name;
-+
-+ f_print(fout, "struct %s {\n", name);
-+ for (l = def->def.st.decls; l != NULL; l = l->next) {
-+ pdeclaration(name, &l->decl, 1, ";\n");
-+ }
-+ f_print(fout, "};\n");
-+ f_print(fout, "typedef struct %s %s;\n", name, name);
-+}
-+
-+static void
-+puniondef(definition *def)
-+{
-+ case_list *l;
-+ char *name = def->def_name;
-+ declaration *decl;
-+
-+ f_print(fout, "struct %s {\n", name);
-+ decl = &def->def.un.enum_decl;
-+ if (streq(decl->type, "bool")) {
-+ f_print(fout, "\tbool_t %s;\n", decl->name);
-+ } else {
-+ f_print(fout, "\t%s %s;\n", decl->type, decl->name);
-+ }
-+ f_print(fout, "\tunion {\n");
-+ for (l = def->def.un.cases; l != NULL; l = l->next) {
-+ if (l->contflag == 0)
-+ pdeclaration(name, &l->case_decl, 2, ";\n");
-+ }
-+ decl = def->def.un.default_decl;
-+ if (decl && !streq(decl->type, "void")) {
-+ pdeclaration(name, decl, 2, ";\n");
-+ }
-+ f_print(fout, "\t} %s_u;\n", name);
-+ f_print(fout, "};\n");
-+ f_print(fout, "typedef struct %s %s;\n", name, name);
-+}
-+
-+static void
-+pdefine(char *name, char *num)
-+{
-+ f_print(fout, "#define %s %s\n", name, num);
-+}
-+
-+static void
-+puldefine(char *name, char *num)
-+{
-+ f_print(fout, "#define %s ((u_int32_t)%s)\n", name, num);
-+}
-+
-+static int
-+define_printed(proc_list *stop, version_list *start)
-+{
-+ version_list *vers;
-+ proc_list *proc;
-+
-+ for (vers = start; vers != NULL; vers = vers->next) {
-+ for (proc = vers->procs; proc != NULL; proc = proc->next) {
-+ if (proc == stop) {
-+ return (0);
-+ } else if (streq(proc->proc_name, stop->proc_name)) {
-+ return (1);
-+ }
-+ }
-+ }
-+ abort();
-+ /* NOTREACHED */
-+}
-+
-+static void
-+pprogramdef(definition *def)
-+{
-+ version_list *vers;
-+ proc_list *proc;
-+ int i;
-+ char *ext;
-+
-+ pargdef(def);
-+
-+ puldefine(def->def_name, def->def.pr.prog_num);
-+ for (vers = def->def.pr.versions; vers != NULL; vers = vers->next) {
-+ if (tblflag) {
-+ f_print(fout, "extern struct rpcgen_table %s_%s_table[];\n",
-+ locase(def->def_name), vers->vers_num);
-+ f_print(fout, "extern %s_%s_nproc;\n",
-+ locase(def->def_name), vers->vers_num);
-+ }
-+ puldefine(vers->vers_name, vers->vers_num);
-+
-+ /*
-+ * Print out 3 definitions, one for ANSI-C, another for C++,
-+ * a third for old style C
-+ */
-+
-+ for (i = 0; i < 3; i++) {
-+ if (i == 0) {
-+ f_print(fout, "\n#ifdef __cplusplus\n");
-+ ext = "extern \"C\" ";
-+ } else if (i == 1) {
-+ f_print(fout, "\n#elif __STDC__\n");
-+ ext = "extern ";
-+ } else {
-+ f_print(fout, "\n#else /* Old Style C */ \n");
-+ ext = "extern ";
-+ }
-+
-+
-+ for (proc = vers->procs; proc != NULL; proc = proc->next) {
-+ if (!define_printed(proc, def->def.pr.versions)) {
-+ puldefine(proc->proc_name, proc->proc_num);
-+ }
-+ f_print(fout, "%s", ext);
-+ pprocdef(proc, vers, "CLIENT *", 0, i);
-+ f_print(fout, "%s", ext);
-+ pprocdef(proc, vers, "struct svc_req *", 1, i);
-+
-+ }
-+
-+ }
-+ f_print(fout, "#endif /* Old Style C */ \n");
-+ }
-+}
-+
-+static void
-+pprocdef(proc_list *proc, version_list *vp, char *addargtype,
-+ int server_p, int mode)
-+{
-+ ptype(proc->res_prefix, proc->res_type, 1);
-+ f_print(fout, "* ");
-+ if (server_p)
-+ pvname_svc(proc->proc_name, vp->vers_num);
-+ else
-+ pvname(proc->proc_name, vp->vers_num);
-+
-+ /*
-+ * mode 0 == cplusplus, mode 1 = ANSI-C, mode 2 = old style C
-+ */
-+ if (mode == 0 || mode == 1)
-+ parglist(proc, addargtype);
-+ else
-+ f_print(fout, "();\n");
-+}
-+
-+
-+
-+/* print out argument list of procedure */
-+static void
-+parglist(proc_list *proc, char *addargtype)
-+{
-+ decl_list *dl;
-+
-+ f_print(fout, "(");
-+
-+ if (proc->arg_num < 2 && newstyle &&
-+ streq(proc->args.decls->decl.type, "void")) {
-+ /* 0 argument in new style: do nothing */
-+ } else {
-+ for (dl = proc->args.decls; dl != NULL; dl = dl->next) {
-+ ptype(dl->decl.prefix, dl->decl.type, 1);
-+ if (!newstyle)
-+ f_print(fout, "*"); /* old style passes by reference */
-+
-+ f_print(fout, ", ");
-+ }
-+ }
-+
-+ f_print(fout, "%s);\n", addargtype);
-+}
-+
-+static void
-+penumdef(definition *def)
-+{
-+ char *name = def->def_name;
-+ enumval_list *l;
-+ char *last = NULL;
-+ int count = 0;
-+
-+ f_print(fout, "enum %s {\n", name);
-+ for (l = def->def.en.vals; l != NULL; l = l->next) {
-+ f_print(fout, "\t%s", l->name);
-+ if (l->assignment) {
-+ f_print(fout, " = %s", l->assignment);
-+ last = l->assignment;
-+ count = 1;
-+ } else {
-+ if (last == NULL) {
-+ f_print(fout, " = %d", count++);
-+ } else {
-+ f_print(fout, " = %s + %d", last, count++);
-+ }
-+ }
-+ f_print(fout, ",\n");
-+ }
-+ f_print(fout, "};\n");
-+ f_print(fout, "typedef enum %s %s;\n", name, name);
-+}
-+
-+static void
-+ptypedef(definition *def)
-+{
-+ char *name = def->def_name;
-+ char *old = def->def.ty.old_type;
-+ char prefix[8]; /* enough to contain "struct ", including NUL */
-+ relation rel = def->def.ty.rel;
-+
-+
-+ if (!streq(name, old)) {
-+ if (streq(old, "string")) {
-+ old = "char";
-+ rel = REL_POINTER;
-+ } else if (streq(old, "opaque")) {
-+ old = "char";
-+ } else if (streq(old, "bool")) {
-+ old = "bool_t";
-+ }
-+ if (undefined2(old, name) && def->def.ty.old_prefix) {
-+ s_print(prefix, "%s ", def->def.ty.old_prefix);
-+ } else {
-+ prefix[0] = 0;
-+ }
-+ f_print(fout, "typedef ");
-+ switch (rel) {
-+ case REL_ARRAY:
-+ f_print(fout, "struct {\n");
-+ f_print(fout, "\tu_int %s_len;\n", name);
-+ f_print(fout, "\t%s%s *%s_val;\n", prefix, old, name);
-+ f_print(fout, "} %s", name);
-+ break;
-+ case REL_POINTER:
-+ f_print(fout, "%s%s *%s", prefix, old, name);
-+ break;
-+ case REL_VECTOR:
-+ f_print(fout, "%s%s %s[%s]", prefix, old, name,
-+ def->def.ty.array_max);
-+ break;
-+ case REL_ALIAS:
-+ f_print(fout, "%s%s %s", prefix, old, name);
-+ break;
-+ }
-+ f_print(fout, ";\n");
-+ }
-+}
-+
-+void
-+pdeclaration(char *name, declaration *dec, int tab, char *separator)
-+{
-+ char buf[8]; /* enough to hold "struct ", include NUL */
-+ char *prefix;
-+ char *type;
-+
-+ if (streq(dec->type, "void")) {
-+ return;
-+ }
-+ tabify(fout, tab);
-+ if (streq(dec->type, name) && !dec->prefix) {
-+ f_print(fout, "struct ");
-+ }
-+ if (streq(dec->type, "string")) {
-+ f_print(fout, "char *%s", dec->name);
-+ } else {
-+ prefix = "";
-+ if (streq(dec->type, "bool")) {
-+ type = "bool_t";
-+ } else if (streq(dec->type, "opaque")) {
-+ type = "char";
-+ } else {
-+ if (dec->prefix) {
-+ s_print(buf, "%s ", dec->prefix);
-+ prefix = buf;
-+ }
-+ type = dec->type;
-+ }
-+ switch (dec->rel) {
-+ case REL_ALIAS:
-+ f_print(fout, "%s%s %s", prefix, type, dec->name);
-+ break;
-+ case REL_VECTOR:
-+ f_print(fout, "%s%s %s[%s]", prefix, type, dec->name,
-+ dec->array_max);
-+ break;
-+ case REL_POINTER:
-+ f_print(fout, "%s%s *%s", prefix, type, dec->name);
-+ break;
-+ case REL_ARRAY:
-+ f_print(fout, "struct {\n");
-+ tabify(fout, tab);
-+ f_print(fout, "\tu_int %s_len;\n", dec->name);
-+ tabify(fout, tab);
-+ f_print(fout, "\t%s%s *%s_val;\n", prefix, type, dec->name);
-+ tabify(fout, tab);
-+ f_print(fout, "} %s", dec->name);
-+ break;
-+ }
-+ }
-+ f_print(fout, separator );
-+}
-+
-+static int
-+undefined2(char *type, char *stop)
-+{
-+ list *l;
-+ definition *def;
-+
-+ for (l = defined; l != NULL; l = l->next) {
-+ def = (definition *) l->val;
-+ if (def->def_kind != DEF_PROGRAM) {
-+ if (streq(def->def_name, stop)) {
-+ return (1);
-+ } else if (streq(def->def_name, type)) {
-+ return (0);
-+ }
-+ }
-+ }
-+ return (1);
-+}
-diff --git a/rpcgen/rpc_main.c b/rpcgen/rpc_main.c
-new file mode 100644
-index 0000000..28aa60c
---- /dev/null
-+++ b/rpcgen/rpc_main.c
-@@ -0,0 +1,1067 @@
-+/*
-+ * Copyright (c) 2009, Sun Microsystems, Inc.
-+ * All rights reserved.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions are met:
-+ * - Redistributions of source code must retain the above copyright notice,
-+ * this list of conditions and the following disclaimer.
-+ * - Redistributions in binary form must reproduce the above copyright notice,
-+ * this list of conditions and the following disclaimer in the documentation
-+ * and/or other materials provided with the distribution.
-+ * - Neither the name of Sun Microsystems, Inc. nor the names of its
-+ * contributors may be used to endorse or promote products derived
-+ * from this software without specific prior written permission.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-+ * POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+#if 0
-+static char sccsid[] = "@(#)rpc_main.c 1.30 89/03/30 (C) 1987 SMI";
-+#endif
-+
-+/*
-+ * rpc_main.c, Top level of the RPC protocol compiler.
-+ */
-+
-+#include <sys/types.h>
-+#include <sys/param.h>
-+#include <sys/file.h>
-+#include <sys/stat.h>
-+#include <stdio.h>
-+#include <string.h>
-+#include <stdlib.h>
-+#include <unistd.h>
-+#include <ctype.h>
-+#include <errno.h>
-+#include "rpc_parse.h"
-+#include "rpc_util.h"
-+#include "rpc_scan.h"
-+
-+struct commandline {
-+ int cflag; /* xdr C routines */
-+ int hflag; /* header file */
-+ int lflag; /* client side stubs */
-+ int mflag; /* server side stubs */
-+ int nflag; /* netid flag */
-+ int sflag; /* server stubs for the given transport */
-+ int tflag; /* dispatch Table file */
-+ int Ssflag; /* produce server sample code */
-+ int Scflag; /* produce client sample code */
-+ char *infile; /* input module name */
-+ char *outfile; /* output module name */
-+};
-+
-+static char * extendfile(char *file, char *ext);
-+static void open_output(char *infile, char *outfile);
-+static void add_warning(void);
-+static void clear_args(void);
-+static void open_input(char *infile, char *define);
-+static int check_nettype(char *name, char **list_to_check);
-+static void c_output(char *infile, char *define, int extend, char *outfile);
-+static void c_initialize(void);
-+static char * generate_guard(char *pathname);
-+static void h_output(char *infile, char *define, int extend, char *outfile);
-+static void s_output(int argc, char **argv, char *infile,
-+ char *define, int extend, char *outfile,
-+ int nomain, int netflag);
-+static void l_output(char *infile, char *define, int extend, char *outfile);
-+static void t_output(char *infile, char *define, int extend, char *outfile);
-+static void svc_output(char *, char *, int, char *);
-+static void clnt_output(char *, char *, int, char *);
-+static int do_registers(int argc, char **argv);
-+static void addarg(char *cp);
-+static void putarg(int where, char *cp);
-+static void checkfiles(char *infile, char *outfile);
-+static int parseargs(int argc, char **argv, struct commandline *cmd);
-+static void usage(void);
-+static void options_usage(void);
-+
-+/*
-+extern void write_sample_svc();
-+int write_sample_clnt();
-+void write_sample_clnt_main();
-+
-+static svc_output();
-+ */
-+
-+#define EXTEND 1 /* alias for TRUE */
-+#define DONT_EXTEND 0 /* alias for FALSE */
-+
-+#define SVR4_CPP "/usr/ccs/lib/cpp"
-+#define SUNOS_CPP "/lib/cpp"
-+static int cppDefined = 0; /* explicit path for C preprocessor */
-+
-+
-+static char *cmdname;
-+
-+static char *svcclosetime = "120";
-+static char *CPP = SVR4_CPP;
-+static char CPPFLAGS[] = "-C";
-+static char pathbuf[MAXPATHLEN + 1];
-+static char *allv[] = {
-+ "rpcgen", "-s", "udp", "-s", "tcp",
-+};
-+static int allc = sizeof(allv)/sizeof(allv[0]);
-+static char *allnv[] = {
-+ "rpcgen", "-s", "netpath",
-+};
-+static int allnc = sizeof(allnv)/sizeof(allnv[0]);
-+
-+/*
-+ * machinations for handling expanding argument list
-+ */
-+#if 0
-+static void addarg(); /* add another argument to the list */
-+static void putarg(); /* put argument at specified location */
-+static void clear_args(); /* clear argument list */
-+static void checkfiles(); /* check if out file already exists */
-+#endif
-+
-+
-+
-+#define ARGLISTLEN 20
-+#define FIXEDARGS 2
-+
-+static char *arglist[ARGLISTLEN];
-+static int argcount = FIXEDARGS;
-+
-+
-+int nonfatalerrors; /* errors */
-+int inetdflag/* = 1*/; /* Support for inetd */ /* is now the default */
-+int pmflag; /* Support for port monitors */
-+int logflag; /* Use syslog instead of fprintf for errors */
-+int tblflag; /* Support for dispatch table file */
-+
-+/* length at which to start doing an inline */
-+#define INLINE 3
-+
-+int Inline = INLINE; /* length at which to start doing an inline. 3 = default
-+ * if 0, no xdr_inline code */
-+
-+int indefinitewait; /* If started by port monitors, hang till it wants */
-+int exitnow; /* If started by port monitors, exit after the call */
-+int timerflag; /* TRUE if !indefinite && !exitnow */
-+int newstyle; /* newstyle of passing arguments (by value) */
-+int Cflag = 0 ; /* ANSI C syntax */
-+static int allfiles; /* generate all files */
-+#ifdef linux
-+int tirpcflag = 0; /* no tirpc by default */
-+#else
-+int tirpcflag = 1; /* generating code for tirpc, by default */
-+#endif
-+
-+int
-+main(int argc, char **argv)
-+{
-+ struct commandline cmd;
-+
-+ (void) memset((char *) &cmd, 0, sizeof(struct commandline));
-+ clear_args();
-+ if (!parseargs(argc, argv, &cmd))
-+ usage();
-+
-+ if (cmd.cflag || cmd.hflag || cmd.lflag || cmd.tflag || cmd.sflag ||
-+ cmd.mflag || cmd.nflag || cmd.Ssflag || cmd.Scflag) {
-+ checkfiles(cmd.infile, cmd.outfile);
-+ } else
-+ checkfiles(cmd.infile, NULL);
-+
-+ if (cmd.cflag) {
-+ c_output(cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile);
-+ } else if (cmd.hflag) {
-+ h_output(cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile);
-+ } else if (cmd.lflag) {
-+ l_output(cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile);
-+ } else if (cmd.sflag || cmd.mflag || (cmd.nflag)) {
-+ s_output(argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND,
-+ cmd.outfile, cmd.mflag, cmd.nflag);
-+ } else if (cmd.tflag) {
-+ t_output(cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile);
-+ } else if (cmd.Ssflag) {
-+ svc_output(cmd.infile, "-DRPC_SERVER", DONT_EXTEND, cmd.outfile);
-+ } else if (cmd.Scflag) {
-+ clnt_output(cmd.infile, "-DRPC_CLIENT", DONT_EXTEND, cmd.outfile);
-+ } else {
-+ /* the rescans are required, since cpp may effect input */
-+ c_output(cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c");
-+ reinitialize();
-+ h_output(cmd.infile, "-DRPC_HDR", EXTEND, ".h");
-+ reinitialize();
-+ l_output(cmd.infile, "-DRPC_CLNT", EXTEND, "_clnt.c");
-+ reinitialize();
-+ if (inetdflag || !tirpcflag)
-+ s_output(allc, allv, cmd.infile, "-DRPC_SVC", EXTEND,
-+ "_svc.c", cmd.mflag, cmd.nflag);
-+ else
-+ s_output(allnc, allnv, cmd.infile, "-DRPC_SVC",
-+ EXTEND, "_svc.c", cmd.mflag, cmd.nflag);
-+ if (tblflag) {
-+ reinitialize();
-+ t_output(cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.i");
-+ }
-+ if (allfiles) {
-+ reinitialize();
-+ svc_output(cmd.infile, "-DRPC_SERVER", EXTEND, "_server.c");
-+ }
-+ if (allfiles) {
-+ reinitialize();
-+ clnt_output(cmd.infile, "-DRPC_CLIENT", EXTEND, "_client.c");
-+ }
-+ }
-+ exit(nonfatalerrors);
-+ /* NOTREACHED */
-+}
-+
-+/*
-+ * add extension to filename
-+ */
-+static char *
-+extendfile(char *file, char *ext)
-+{
-+ char *res;
-+ char *p;
-+
-+ res = alloc(strlen(file) + strlen(ext) + 1);
-+ if (res == NULL) {
-+ abort();
-+ }
-+ p = strrchr(file, '.');
-+ if (p == NULL) {
-+ p = file + strlen(file);
-+ }
-+ (void) strcpy(res, file);
-+ (void) strcpy(res + (p - file), ext);
-+ return (res);
-+}
-+
-+/*
-+ * Open output file with given extension
-+ */
-+static void
-+open_output(char *infile, char *outfile)
-+{
-+
-+ if (outfile == NULL) {
-+ fout = stdout;
-+ return;
-+ }
-+
-+ if (infile != NULL && streq(outfile, infile)) {
-+ f_print(stderr, "%s: output would overwrite %s\n", cmdname,
-+ infile);
-+ crash();
-+ }
-+ fout = fopen(outfile, "w");
-+ if (fout == NULL) {
-+ f_print(stderr, "%s: unable to open ", cmdname);
-+ perror(outfile);
-+ crash();
-+ }
-+ record_open(outfile);
-+
-+}
-+
-+static void
-+add_warning(void)
-+{
-+ f_print(fout, "/*\n");
-+ f_print(fout, " * Please do not edit this file.\n");
-+ f_print(fout, " * It was generated using rpcgen.\n");
-+ f_print(fout, " */\n\n");
-+}
-+
-+/* clear list of arguments */
-+static void
-+clear_args(void)
-+{
-+ int i;
-+ for( i=FIXEDARGS; i<ARGLISTLEN; i++ )
-+ arglist[i] = NULL;
-+ argcount = FIXEDARGS;
-+}
-+
-+/*
-+ * Open input file with given define for C-preprocessor
-+ */
-+static void
-+open_input(char *infile, char *define)
-+{
-+ int pd[2];
-+
-+ infilename = (infile == NULL) ? "<stdin>" : infile;
-+ (void) pipe(pd);
-+ switch (fork()) {
-+ case 0:
-+ putarg(0, "cpp");
-+ putarg(1, CPPFLAGS);
-+ addarg(define);
-+ addarg(infile);
-+ addarg((char *)NULL);
-+ (void) close(1);
-+ (void) dup2(pd[1], 1);
-+ (void) close(pd[0]);
-+ if (cppDefined)
-+ execv(CPP, arglist);
-+ else {
-+ execvp("cpp", arglist);
-+ if (errno == ENOENT)
-+ execvp(SVR4_CPP, arglist);
-+ if (errno == ENOENT)
-+ execvp(SUNOS_CPP, arglist);
-+ }
-+ perror("execv");
-+ exit(1);
-+ case -1:
-+ perror("fork");
-+ exit(1);
-+ }
-+ (void) close(pd[1]);
-+ fin = fdopen(pd[0], "r");
-+ if (fin == NULL) {
-+ f_print(stderr, "%s: ", cmdname);
-+ perror(infilename);
-+ crash();
-+ }
-+}
-+
-+/* valid tirpc nettypes */
-+static char* valid_ti_nettypes[] =
-+{
-+ "netpath",
-+ "visible",
-+ "circuit_v",
-+ "datagram_v",
-+ "circuit_n",
-+ "datagram_n",
-+ "udp",
-+ "tcp",
-+ "raw",
-+ NULL
-+};
-+
-+/* valid inetd nettypes */
-+static char* valid_i_nettypes[] =
-+{
-+ "udp",
-+ "tcp",
-+ NULL
-+};
-+
-+static int
-+check_nettype(char *name, char **list_to_check)
-+{
-+ int i;
-+ for( i = 0; list_to_check[i] != NULL; i++ ) {
-+ if( strcmp( name, list_to_check[i] ) == 0 ) {
-+ return 1;
-+ }
-+ }
-+ f_print( stderr, "illegal nettype :\'%s\'\n", name );
-+ return 0;
-+}
-+
-+/*
-+ * Compile into an XDR routine output file
-+ */
-+
-+static void
-+c_output(char *infile, char *define, int extend, char *outfile)
-+{
-+ definition *def;
-+ char *include;
-+ char *outfilename;
-+ long tell;
-+
-+ c_initialize();
-+ open_input(infile, define);
-+ outfilename = extend ? extendfile(infile, outfile) : outfile;
-+ open_output(infile, outfilename);
-+ add_warning();
-+ if (infile && (include = extendfile(infile, ".h"))) {
-+ f_print(fout, "#include \"%s\"\n", include);
-+ free(include);
-+ /* .h file already contains rpc/rpc.h */
-+ } else
-+ f_print(fout, "#include <rpc/rpc.h>\n");
-+ tell = ftell(fout);
-+ while ((def = get_definition()) != NULL) {
-+ emit(def);
-+ }
-+ if (extend && tell == ftell(fout)) {
-+ (void) unlink(outfilename);
-+ }
-+}
-+
-+
-+static void
-+c_initialize(void)
-+{
-+
-+ /* add all the starting basic types */
-+
-+ add_type(1,"int");
-+ add_type(1,"int32_t");
-+ add_type(1,"short");
-+ add_type(1,"bool");
-+
-+ add_type(1,"u_int");
-+ add_type(1,"u_int32_t");
-+ add_type(1,"u_short");
-+
-+}
-+
-+char rpcgen_table_dcl[] = "struct rpcgen_table {\n\
-+ char *(*proc)();\n\
-+ xdrproc_t xdr_arg;\n\
-+ unsigned len_arg;\n\
-+ xdrproc_t xdr_res;\n\
-+ unsigned len_res;\n\
-+};\n";
-+
-+
-+static char *
-+generate_guard(char *pathname)
-+{
-+ char* filename, *guard, *tmp;
-+
-+ filename = strrchr(pathname, '/' ); /* find last component */
-+ filename = ((filename == 0) ? pathname : filename+1);
-+ guard = strdup(filename);
-+ /* convert to upper case */
-+ tmp = guard;
-+ while (*tmp) {
-+ if (islower(*tmp))
-+ *tmp = toupper(*tmp);
-+ tmp++;
-+ }
-+
-+ guard = extendfile(guard, "_H_RPCGEN");
-+ return( guard );
-+}
-+
-+/*
-+ * Compile into an XDR header file
-+ */
-+static void
-+h_output(char *infile, char *define, int extend, char *outfile)
-+{
-+ definition *def;
-+ char *outfilename;
-+ long tell;
-+ char *guard;
-+ list *l;
-+
-+ open_input(infile, define);
-+ outfilename = extend ? extendfile(infile, outfile) : outfile;
-+ open_output(infile, outfilename);
-+ add_warning();
-+ guard = generate_guard( outfilename ? outfilename: infile );
-+
-+ f_print(fout,"#ifndef _%s\n#define _%s\n\n", guard,
-+ guard);
-+
-+ f_print(fout, "#include <rpc/rpc.h>\n\n");
-+
-+ f_print(fout, "#ifndef IXDR_GET_INT32\n");
-+ f_print(fout, "#define IXDR_GET_INT32(buf) IXDR_GET_LONG((buf))\n");
-+ f_print(fout, "#endif\n");
-+ f_print(fout, "#ifndef IXDR_PUT_INT32\n");
-+ f_print(fout, "#define IXDR_PUT_INT32(buf, v) IXDR_PUT_LONG((buf), (v))\n");
-+ f_print(fout, "#endif\n");
-+ f_print(fout, "#ifndef IXDR_GET_U_INT32\n");
-+ f_print(fout, "#define IXDR_GET_U_INT32(buf) IXDR_GET_U_LONG((buf))\n");
-+ f_print(fout, "#endif\n");
-+ f_print(fout, "#ifndef IXDR_PUT_U_INT32\n");
-+ f_print(fout, "#define IXDR_PUT_U_INT32(buf, v) IXDR_PUT_U_LONG((buf), (v))\n");
-+ f_print(fout, "#endif\n");
-+
-+ tell = ftell(fout);
-+ /* print data definitions */
-+ while ((def = get_definition()) != NULL) {
-+ print_datadef(def);
-+ }
-+
-+ /* print function declarations.
-+ Do this after data definitions because they might be used as
-+ arguments for functions */
-+ for (l = defined; l != NULL; l = l->next) {
-+ print_funcdef(l->val);
-+ }
-+ if (extend && tell == ftell(fout)) {
-+ (void) unlink(outfilename);
-+ } else if (tblflag) {
-+ f_print(fout, rpcgen_table_dcl);
-+ }
-+ f_print(fout, "\n#endif /* !_%s */\n", guard);
-+}
-+
-+/*
-+ * Compile into an RPC service
-+ */
-+static void
-+s_output(int argc, char **argv, char *infile, char *define, int extend,
-+ char *outfile, int nomain, int netflag)
-+{
-+ char *include;
-+ definition *def;
-+ int foundprogram = 0;
-+ char *outfilename;
-+
-+ open_input(infile, define);
-+ outfilename = extend ? extendfile(infile, outfile) : outfile;
-+ open_output(infile, outfilename);
-+ add_warning();
-+ if (infile && (include = extendfile(infile, ".h"))) {
-+ f_print(fout, "#include \"%s\"\n", include);
-+ free(include);
-+ } else
-+ f_print(fout, "#include <rpc/rpc.h>\n");
-+
-+ f_print(fout, "#include <stdio.h>\n");
-+ f_print(fout, "#include <stdlib.h>/* getenv, exit */\n");
-+ if (Cflag) {
-+ f_print (fout, "#include <rpc/pmap_clnt.h> /* for pmap_unset */\n");
-+ f_print (fout, "#include <string.h> /* strcmp */ \n");
-+ }
-+ if (strcmp(svcclosetime, "-1") == 0)
-+ indefinitewait = 1;
-+ else if (strcmp(svcclosetime, "0") == 0)
-+ exitnow = 1;
-+ else if (inetdflag || pmflag) {
-+ f_print(fout, "#include <signal.h>\n");
-+ timerflag = 1;
-+ }
-+
-+#ifndef linux
-+ if( !tirpcflag && inetdflag )
-+ f_print(fout, "#include <sys/ttycom.h>/* TIOCNOTTY */\n");
-+#else
-+ if( !tirpcflag )
-+ f_print(fout, "#include <sys/ioctl.h>/* TIOCNOTTY */\n");
-+#endif
-+ if( Cflag && (inetdflag || pmflag ) ) {
-+ f_print(fout, "#ifdef __cplusplus\n");
-+ f_print(fout, "#include <sysent.h> /* getdtablesize, open */\n");
-+ f_print(fout, "#endif /* __cplusplus */\n");
-+
-+ if( tirpcflag )
-+ f_print(fout, "#include <unistd.h> /* setsid */\n");
-+ }
-+ if( tirpcflag )
-+ f_print(fout, "#include <sys/types.h>\n");
-+
-+ f_print(fout, "#include <memory.h>\n");
-+#ifndef linux
-+ f_print(fout, "#include <stropts.h>\n");
-+#endif
-+ if (inetdflag || !tirpcflag ) {
-+ f_print(fout, "#include <sys/socket.h>\n");
-+ f_print(fout, "#include <netinet/in.h>\n");
-+ }
-+
-+ if ( (netflag || pmflag) && tirpcflag ) {
-+ f_print(fout, "#include <netconfig.h>\n");
-+ }
-+ if (/*timerflag &&*/ tirpcflag)
-+ f_print(fout, "#include <sys/resource.h> /* rlimit */\n");
-+ if (logflag || inetdflag || pmflag) {
-+#ifdef linux
-+ f_print(fout, "#include <syslog.h>\n");
-+#else
-+ f_print(fout, "#ifdef SYSLOG\n");
-+ f_print(fout, "#include <syslog.h>\n");
-+ f_print(fout, "#else\n");
-+ f_print(fout, "#define LOG_ERR 1\n");
-+ f_print(fout, "#define openlog(a, b, c)\n");
-+ f_print(fout, "#endif\n");
-+#endif
-+ }
-+
-+ /* for ANSI-C */
-+ f_print(fout, "\n#ifdef __STDC__\n#define SIG_PF void(*)(int)\n#endif\n");
-+
-+ f_print(fout, "\n#ifdef DEBUG\n#define RPC_SVC_FG\n#endif\n");
-+ if (timerflag)
-+ f_print(fout, "\n#define _RPCSVC_CLOSEDOWN %s\n", svcclosetime);
-+ while ((def = get_definition()) != NULL) {
-+ foundprogram |= (def->def_kind == DEF_PROGRAM);
-+ }
-+ if (extend && !foundprogram) {
-+ (void) unlink(outfilename);
-+ return;
-+ }
-+ write_most(infile, netflag, nomain);
-+ if (!nomain) {
-+ if( !do_registers(argc, argv) ) {
-+ if (outfilename)
-+ (void) unlink(outfilename);
-+ usage();
-+ }
-+ write_rest();
-+ }
-+}
-+
-+/*
-+ * generate client side stubs
-+ */
-+static void
-+l_output(char *infile, char *define, int extend, char *outfile)
-+{
-+ char *include;
-+ definition *def;
-+ int foundprogram = 0;
-+ char *outfilename;
-+
-+ open_input(infile, define);
-+ outfilename = extend ? extendfile(infile, outfile) : outfile;
-+ open_output(infile, outfilename);
-+ add_warning();
-+ if (Cflag)
-+ f_print (fout, "#include <memory.h> /* for memset */\n");
-+ if (infile && (include = extendfile(infile, ".h"))) {
-+ f_print(fout, "#include \"%s\"\n", include);
-+ free(include);
-+ } else
-+ f_print(fout, "#include <rpc/rpc.h>\n");
-+ while ((def = get_definition()) != NULL) {
-+ foundprogram |= (def->def_kind == DEF_PROGRAM);
-+ }
-+ if (extend && !foundprogram) {
-+ (void) unlink(outfilename);
-+ return;
-+ }
-+ write_stubs();
-+}
-+
-+/*
-+ * generate the dispatch table
-+ */
-+static void
-+t_output(char *infile, char *define, int extend, char *outfile)
-+{
-+ definition *def;
-+ int foundprogram = 0;
-+ char *outfilename;
-+
-+ open_input(infile, define);
-+ outfilename = extend ? extendfile(infile, outfile) : outfile;
-+ open_output(infile, outfilename);
-+ add_warning();
-+ while ((def = get_definition()) != NULL) {
-+ foundprogram |= (def->def_kind == DEF_PROGRAM);
-+ }
-+ if (extend && !foundprogram) {
-+ (void) unlink(outfilename);
-+ return;
-+ }
-+ write_tables();
-+}
-+
-+/* sample routine for the server template */
-+static void
-+svc_output(char *infile, char *define, int extend, char *outfile)
-+{
-+ definition *def;
-+ char *include;
-+ char *outfilename;
-+ long tell;
-+
-+ open_input(infile, define);
-+ outfilename = extend ? extendfile(infile, outfile) : outfile;
-+ checkfiles(infile,outfilename); /*check if outfile already exists.
-+ if so, print an error message and exit*/
-+ open_output(infile, outfilename);
-+ add_sample_msg();
-+
-+ if (infile && (include = extendfile(infile, ".h"))) {
-+ f_print(fout, "#include \"%s\"\n", include);
-+ free(include);
-+ } else
-+ f_print(fout, "#include <rpc/rpc.h>\n");
-+
-+ tell = ftell(fout);
-+ while ((def = get_definition()) != NULL) {
-+ write_sample_svc(def);
-+ }
-+ if (extend && tell == ftell(fout)) {
-+ (void) unlink(outfilename);
-+ }
-+}
-+
-+
-+/* sample main routine for client */
-+static void
-+clnt_output(char *infile, char *define, int extend, char *outfile)
-+{
-+ definition *def;
-+ char *include;
-+ char *outfilename;
-+ long tell;
-+ int has_program = 0;
-+
-+ open_input(infile, define);
-+ outfilename = extend ? extendfile(infile, outfile) : outfile;
-+ checkfiles(infile, outfilename); /*check if outfile already exists.
-+ if so, print an error message and exit*/
-+
-+ open_output(infile, outfilename);
-+ add_sample_msg();
-+ if (infile && (include = extendfile(infile, ".h"))) {
-+ f_print(fout, "#include \"%s\"\n", include);
-+ free(include);
-+ } else
-+ f_print(fout, "#include <rpc/rpc.h>\n");
-+ tell = ftell(fout);
-+ while ((def = get_definition()) != NULL) {
-+ has_program += write_sample_clnt(def);
-+ }
-+
-+ if (has_program)
-+ write_sample_clnt_main();
-+
-+ if (extend && tell == ftell(fout)) {
-+ (void) unlink(outfilename);
-+ }
-+}
-+
-+/*
-+ * Perform registrations for service output
-+ * Return 0 if failed; 1 otherwise.
-+ */
-+static int
-+do_registers(int argc, char **argv)
-+{
-+ int i;
-+
-+ if (inetdflag || !tirpcflag) {
-+ for (i = 1; i < argc; i++) {
-+ if (streq(argv[i], "-s")) {
-+ if (!check_nettype(argv[i + 1], valid_i_nettypes))
-+ return 0;
-+ write_inetd_register(argv[i + 1]);
-+ i++;
-+ }
-+ }
-+ } else {
-+ for (i = 1; i < argc; i++)
-+ if (streq(argv[i], "-s")) {
-+ if (!check_nettype(argv[i + 1], valid_ti_nettypes))
-+ return 0;
-+ write_nettype_register(argv[i + 1]);
-+ i++;
-+ } else if (streq(argv[i], "-n")) {
-+ write_netid_register(argv[i + 1]);
-+ i++;
-+ }
-+ }
-+ return 1;
-+}
-+
-+/*
-+ * Add another argument to the arg list
-+ */
-+static void
-+addarg(char *cp)
-+{
-+ if (argcount >= ARGLISTLEN) {
-+ f_print(stderr, "rpcgen: too many defines\n");
-+ crash();
-+ /*NOTREACHED*/
-+ }
-+ arglist[argcount++] = cp;
-+
-+}
-+
-+static void
-+putarg(int where, char *cp)
-+{
-+ if (where >= ARGLISTLEN) {
-+ f_print(stderr, "rpcgen: arglist coding error\n");
-+ crash();
-+ /*NOTREACHED*/
-+ }
-+ arglist[where] = cp;
-+
-+}
-+
-+/*
-+ * if input file is stdin and an output file is specified then complain
-+ * if the file already exists. Otherwise the file may get overwritten
-+ * If input file does not exist, exit with an error
-+ */
-+
-+static void
-+checkfiles(char *infile, char *outfile)
-+{
-+
-+ struct stat buf;
-+
-+ if(infile) /* infile ! = NULL */
-+ if(stat(infile,&buf) < 0)
-+ {
-+ perror(infile);
-+ crash();
-+ };
-+ if (outfile) {
-+ if (stat(outfile, &buf) < 0)
-+ return; /* file does not exist */
-+ else {
-+ f_print(stderr,
-+ "file '%s' already exists and may be overwritten\n", outfile);
-+ crash();
-+ }
-+ }
-+}
-+
-+/*
-+ * Parse command line arguments
-+ */
-+static int
-+parseargs(int argc, char **argv, struct commandline *cmd)
-+{
-+ int i;
-+ int j;
-+ char c;
-+ char flag[(1 << 8 * sizeof(char))];
-+ int nflags;
-+
-+ cmdname = argv[0];
-+ cmd->infile = cmd->outfile = NULL;
-+ if (argc < 2) {
-+ return (0);
-+ }
-+ allfiles = 0;
-+ flag['c'] = 0;
-+ flag['h'] = 0;
-+ flag['l'] = 0;
-+ flag['m'] = 0;
-+ flag['o'] = 0;
-+ flag['s'] = 0;
-+ flag['n'] = 0;
-+ flag['t'] = 0;
-+ flag['S'] = 0;
-+ flag['C'] = 0;
-+ for (i = 1; i < argc; i++) {
-+ if (argv[i][0] != '-') {
-+ if (cmd->infile) {
-+ f_print( stderr, "Cannot specify more than one input file!\n");
-+
-+ return (0);
-+ }
-+ cmd->infile = argv[i];
-+ } else {
-+ for (j = 1; argv[i][j] != 0; j++) {
-+ c = argv[i][j];
-+ switch (c) {
-+ case 'a':
-+ allfiles = 1;
-+ break;
-+ case 'c':
-+ case 'h':
-+ case 'l':
-+ case 'm':
-+ case 't':
-+ if (flag[(int) c]) {
-+ return (0);
-+ }
-+ flag[(int) c] = 1;
-+ break;
-+ case 'S':
-+ /* sample flag: Ss or Sc.
-+ Ss means set flag['S'];
-+ Sc means set flag['C']; */
-+ c = argv[i][++j]; /* get next char */
-+ if( c == 's' )
-+ c = 'S';
-+ else if( c == 'c' )
-+ c = 'C';
-+ else
-+ return( 0 );
-+
-+ if (flag[(int) c]) {
-+ return (0);
-+ }
-+ flag[(int) c] = 1;
-+ break;
-+ case 'C': /* ANSI C syntax */
-+ Cflag = 1;
-+ break;
-+
-+ case 'b': /* turn TIRPC flag off for
-+ generating backward compatible
-+ */
-+ tirpcflag = 0;
-+ break;
-+
-+ case 'I':
-+ inetdflag = 1;
-+ break;
-+ case 'N':
-+ newstyle = 1;
-+ break;
-+ case 'L':
-+ logflag = 1;
-+ break;
-+ case 'K':
-+ if (++i == argc) {
-+ return (0);
-+ }
-+ svcclosetime = argv[i];
-+ goto nextarg;
-+ case 'T':
-+ tblflag = 1;
-+ break;
-+ case 'i' :
-+ if (++i == argc) {
-+ return (0);
-+ }
-+ Inline = atoi(argv[i]);
-+ goto nextarg;
-+ case 'n':
-+ case 'o':
-+ case 's':
-+ if (argv[i][j - 1] != '-' ||
-+ argv[i][j + 1] != 0) {
-+ return (0);
-+ }
-+ flag[(int) c] = 1;
-+ if (++i == argc) {
-+ return (0);
-+ }
-+ if (c == 's') {
-+ if (!streq(argv[i], "udp") &&
-+ !streq(argv[i], "tcp")) {
-+ return (0);
-+ }
-+ } else if (c == 'o') {
-+ if (cmd->outfile) {
-+ return (0);
-+ }
-+ cmd->outfile = argv[i];
-+ }
-+ goto nextarg;
-+ case 'D':
-+ if (argv[i][j - 1] != '-') {
-+ return (0);
-+ }
-+ (void) addarg(argv[i]);
-+ goto nextarg;
-+ case 'Y':
-+ if (++i == argc) {
-+ return (0);
-+ }
-+ (void) strcpy(pathbuf, argv[i]);
-+ (void) strcat(pathbuf, "/cpp");
-+ CPP = pathbuf;
-+ cppDefined = 1;
-+ goto nextarg;
-+
-+
-+
-+ default:
-+ return (0);
-+ }
-+ }
-+ nextarg:
-+ ;
-+ }
-+ }
-+
-+ cmd->cflag = flag['c'];
-+ cmd->hflag = flag['h'];
-+ cmd->lflag = flag['l'];
-+ cmd->mflag = flag['m'];
-+ cmd->nflag = flag['n'];
-+ cmd->sflag = flag['s'];
-+ cmd->tflag = flag['t'];
-+ cmd->Ssflag = flag['S'];
-+ cmd->Scflag = flag['C'];
-+
-+ if( tirpcflag ) {
-+ pmflag = inetdflag ? 0 : 1; /* pmflag or inetdflag is always TRUE */
-+ if( (inetdflag && cmd->nflag)) { /* netid not allowed with inetdflag */
-+ f_print(stderr, "Cannot use netid flag with inetd flag!\n");
-+ return (0);
-+ }
-+ } else { /* 4.1 mode */
-+ pmflag = 0; /* set pmflag only in tirpcmode */
-+ inetdflag = 1; /* inetdflag is TRUE by default */
-+ if( cmd->nflag ) { /* netid needs TIRPC */
-+ f_print( stderr, "Cannot use netid flag without TIRPC!\n");
-+ return( 0 );
-+ }
-+ }
-+
-+ if( newstyle && ( tblflag || cmd->tflag) ) {
-+ f_print( stderr, "Cannot use table flags with newstyle!\n");
-+ return( 0 );
-+ }
-+
-+ /* check no conflicts with file generation flags */
-+ nflags = cmd->cflag + cmd->hflag + cmd->lflag + cmd->mflag +
-+ cmd->sflag + cmd->nflag + cmd->tflag + cmd->Ssflag + cmd->Scflag;
-+
-+ if (nflags == 0) {
-+ if (cmd->outfile != NULL || cmd->infile == NULL) {
-+ return (0);
-+ }
-+ } else if (nflags > 1) {
-+ f_print( stderr, "Cannot have more than one file generation flag!\n");
-+ return (0);
-+ }
-+ return (1);
-+}
-+
-+static void
-+usage(void)
-+{
-+ f_print(stderr, "usage: %s infile\n", cmdname);
-+ f_print(stderr, "\t%s [-a][-b][-C][-Dname[=value]] -i size [-I [-K seconds]] [-L][-N][-T] infile\n",
-+ cmdname);
-+ f_print(stderr, "\t%s [-c | -h | -l | -m | -t | -Sc | -Ss] [-o outfile] [infile]\n",
-+ cmdname);
-+ f_print(stderr, "\t%s [-s nettype]* [-o outfile] [infile]\n", cmdname);
-+ f_print(stderr, "\t%s [-n netid]* [-o outfile] [infile]\n", cmdname);
-+ options_usage();
-+ exit(1);
-+}
-+
-+static void
-+options_usage(void)
-+{
-+ f_print(stderr, "options:\n");
-+ f_print(stderr, "-a\t\tgenerate all files, including samples\n");
-+ f_print(stderr, "-b\t\tbackward compatibility mode (generates code for SunOS 4.1)\n");
-+ f_print(stderr, "-c\t\tgenerate XDR routines\n");
-+ f_print(stderr, "-C\t\tANSI C mode\n");
-+ f_print(stderr, "-Dname[=value]\tdefine a symbol (same as #define)\n");
-+ f_print(stderr, "-h\t\tgenerate header file\n");
-+ f_print(stderr, "-i size\t\tsize at which to start generating inline code\n");
-+ f_print(stderr, "-I\t\tgenerate code for inetd support in server (for SunOS 4.1)\n");
-+ f_print(stderr, "-K seconds\tserver exits after K seconds of inactivity\n");
-+ f_print(stderr, "-l\t\tgenerate client side stubs\n");
-+ f_print(stderr, "-L\t\tserver errors will be printed to syslog\n");
-+ f_print(stderr, "-m\t\tgenerate server side stubs\n");
-+ f_print(stderr, "-n netid\tgenerate server code that supports named netid\n");
-+ f_print(stderr, "-N\t\tsupports multiple arguments and call-by-value\n");
-+ f_print(stderr, "-o outfile\tname of the output file\n");
-+ f_print(stderr, "-s nettype\tgenerate server code that supports named nettype\n");
-+ f_print(stderr, "-Sc\t\tgenerate sample client code that uses remote procedures\n");
-+ f_print(stderr, "-Ss\t\tgenerate sample server code that defines remote procedures\n");
-+ f_print(stderr, "-t\t\tgenerate RPC dispatch table\n");
-+ f_print(stderr, "-T\t\tgenerate code to support RPC dispatch tables\n");
-+ f_print(stderr, "-Y path\t\tdirectory name to find C preprocessor (cpp)\n");
-+
-+ exit(1);
-+}
-diff --git a/rpcgen/rpc_output.h b/rpcgen/rpc_output.h
-new file mode 100644
-index 0000000..eb25a60
---- /dev/null
-+++ b/rpcgen/rpc_output.h
-@@ -0,0 +1,16 @@
-+/*
-+ * rpc_output.h
-+ *
-+ * Declarations for output functions
-+ *
-+ */
-+
-+#ifndef RPCGEN_NEW_OUTPUT_H
-+#define RPCGEN_NEW_OUTPUT_H
-+
-+void write_msg_out(void);
-+int nullproc(proc_list *);
-+void printarglist(proc_list *, char *, char *);
-+void pdeclaration(char *, declaration *, int, char *);
-+
-+#endif /* RPCGEN_NEW_OUTPUT_H */
-diff --git a/rpcgen/rpc_parse.c b/rpcgen/rpc_parse.c
-new file mode 100644
-index 0000000..b53a553
---- /dev/null
-+++ b/rpcgen/rpc_parse.c
-@@ -0,0 +1,609 @@
-+/*
-+ * Copyright (c) 2009, Sun Microsystems, Inc.
-+ * All rights reserved.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions are met:
-+ * - Redistributions of source code must retain the above copyright notice,
-+ * this list of conditions and the following disclaimer.
-+ * - Redistributions in binary form must reproduce the above copyright notice,
-+ * this list of conditions and the following disclaimer in the documentation
-+ * and/or other materials provided with the distribution.
-+ * - Neither the name of Sun Microsystems, Inc. nor the names of its
-+ * contributors may be used to endorse or promote products derived
-+ * from this software without specific prior written permission.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-+ * POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+#if 0
-+static char sccsid[] = "@(#)rpc_parse.c 1.8 89/02/22 (C) 1987 SMI";
-+#endif
-+
-+/*
-+ * rpc_parse.c, Parser for the RPC protocol compiler
-+ * Copyright (C) 1987 Sun Microsystems, Inc.
-+ */
-+#include <stdio.h>
-+#include <string.h>
-+#include "rpc/types.h"
-+#include "rpc_scan.h"
-+#include "rpc_parse.h"
-+#include "rpc_util.h"
-+
-+#define ARGNAME "arg"
-+
-+/*
-+extern char *make_argname();
-+extern char *strdup();
-+ */
-+
-+static void isdefined(definition *defp);
-+static void def_struct(definition *defp);
-+static void def_program(definition *defp);
-+static void def_enum(definition *defp);
-+static void def_const(definition *defp);
-+static void def_union(definition *defp);
-+static void check_type_name(char *name, int new_type);
-+static void def_typedef(definition *defp);
-+static void get_declaration(declaration *dec, defkind dkind);
-+static void get_prog_declaration(declaration *dec, defkind dkind, int num);
-+static void get_type(char **prefixp, char **typep, defkind dkind);
-+static void unsigned_dec(char **typep);
-+
-+/*
-+ * return the next definition you see
-+ */
-+definition *
-+get_definition(void)
-+{
-+ definition *defp;
-+ token tok;
-+
-+ defp = ALLOC(definition);
-+ get_token(&tok);
-+ switch (tok.kind) {
-+ case TOK_STRUCT:
-+ def_struct(defp);
-+ break;
-+ case TOK_UNION:
-+ def_union(defp);
-+ break;
-+ case TOK_TYPEDEF:
-+ def_typedef(defp);
-+ break;
-+ case TOK_ENUM:
-+ def_enum(defp);
-+ break;
-+ case TOK_PROGRAM:
-+ def_program(defp);
-+ break;
-+ case TOK_CONST:
-+ def_const(defp);
-+ break;
-+ case TOK_EOF:
-+ free(defp);
-+ return (NULL);
-+ default:
-+ error("definition keyword expected");
-+ }
-+ scan(TOK_SEMICOLON, &tok);
-+ isdefined(defp);
-+ return (defp);
-+}
-+
-+static void
-+isdefined(definition *defp)
-+{
-+ STOREVAL(&defined, defp);
-+}
-+
-+static void
-+def_struct(definition *defp)
-+{
-+ token tok;
-+ declaration dec;
-+ decl_list *decls;
-+ decl_list **tailp;
-+
-+ defp->def_kind = DEF_STRUCT;
-+
-+ scan(TOK_IDENT, &tok);
-+ defp->def_name = tok.str;
-+ scan(TOK_LBRACE, &tok);
-+ tailp = &defp->def.st.decls;
-+ do {
-+ get_declaration(&dec, DEF_STRUCT);
-+ decls = ALLOC(decl_list);
-+ decls->decl = dec;
-+ *tailp = decls;
-+ tailp = &decls->next;
-+ scan(TOK_SEMICOLON, &tok);
-+ peek(&tok);
-+ } while (tok.kind != TOK_RBRACE);
-+ get_token(&tok);
-+ *tailp = NULL;
-+}
-+
-+static void
-+def_program(definition *defp)
-+{
-+ token tok;
-+ declaration dec;
-+ decl_list *decls;
-+ decl_list **tailp;
-+ version_list *vlist;
-+ version_list **vtailp;
-+ proc_list *plist;
-+ proc_list **ptailp;
-+ int num_args;
-+ bool_t isvoid = FALSE; /* whether first argument is void */
-+ defp->def_kind = DEF_PROGRAM;
-+ scan(TOK_IDENT, &tok);
-+ defp->def_name = tok.str;
-+ scan(TOK_LBRACE, &tok);
-+ vtailp = &defp->def.pr.versions;
-+ tailp = &defp->def.st.decls;
-+ scan(TOK_VERSION, &tok);
-+ do {
-+ scan(TOK_IDENT, &tok);
-+ vlist = ALLOC(version_list);
-+ vlist->vers_name = tok.str;
-+ scan(TOK_LBRACE, &tok);
-+ ptailp = &vlist->procs;
-+ do {
-+ /* get result type */
-+ plist = ALLOC(proc_list);
-+ get_type(&plist->res_prefix, &plist->res_type,
-+ DEF_PROGRAM);
-+ if (streq(plist->res_type, "opaque")) {
-+ error("illegal result type");
-+ }
-+ scan(TOK_IDENT, &tok);
-+ plist->proc_name = tok.str;
-+ scan(TOK_LPAREN, &tok);
-+ /* get args - first one*/
-+ num_args = 1;
-+ isvoid = FALSE;
-+ /* type of DEF_PROGRAM in the first
-+ * get_prog_declaration and DEF_STURCT in the next
-+ * allows void as argument if it is the only argument
-+ */
-+ get_prog_declaration(&dec, DEF_PROGRAM, num_args);
-+ if (streq(dec.type, "void"))
-+ isvoid = TRUE;
-+ decls = ALLOC(decl_list);
-+ plist->args.decls = decls;
-+ decls->decl = dec;
-+ tailp = &decls->next;
-+ /* get args */
-+ while(peekscan(TOK_COMMA, &tok)) {
-+ num_args++;
-+ get_prog_declaration(&dec, DEF_STRUCT,
-+ num_args);
-+ decls = ALLOC(decl_list);
-+ decls->decl = dec;
-+ *tailp = decls;
-+ if (streq(dec.type, "void"))
-+ isvoid = TRUE;
-+ tailp = &decls->next;
-+ }
-+ /* multiple arguments are only allowed in newstyle */
-+ if( !newstyle && num_args > 1 ) {
-+ error("only one argument is allowed" );
-+ }
-+ if (isvoid && num_args > 1) {
-+ error("illegal use of void in program definition");
-+ }
-+ *tailp = NULL;
-+ scan(TOK_RPAREN, &tok);
-+ scan(TOK_EQUAL, &tok);
-+ scan_num(&tok);
-+ scan(TOK_SEMICOLON, &tok);
-+ plist->proc_num = tok.str;
-+ plist->arg_num = num_args;
-+ *ptailp = plist;
-+ ptailp = &plist->next;
-+ peek(&tok);
-+ } while (tok.kind != TOK_RBRACE);
-+ *ptailp = NULL;
-+ *vtailp = vlist;
-+ vtailp = &vlist->next;
-+ scan(TOK_RBRACE, &tok);
-+ scan(TOK_EQUAL, &tok);
-+ scan_num(&tok);
-+ vlist->vers_num = tok.str;
-+ /* make the argument structure name for each arg*/
-+ for(plist = vlist->procs; plist != NULL;
-+ plist = plist->next) {
-+ plist->args.argname = make_argname(plist->proc_name,
-+ vlist->vers_num);
-+ /* free the memory ??*/
-+ }
-+ scan(TOK_SEMICOLON, &tok);
-+ scan2(TOK_VERSION, TOK_RBRACE, &tok);
-+ } while (tok.kind == TOK_VERSION);
-+ scan(TOK_EQUAL, &tok);
-+ scan_num(&tok);
-+ defp->def.pr.prog_num = tok.str;
-+ *vtailp = NULL;
-+}
-+
-+
-+static void
-+def_enum(definition *defp)
-+{
-+ token tok;
-+ enumval_list *elist;
-+ enumval_list **tailp;
-+
-+ defp->def_kind = DEF_ENUM;
-+ scan(TOK_IDENT, &tok);
-+ defp->def_name = tok.str;
-+ scan(TOK_LBRACE, &tok);
-+ tailp = &defp->def.en.vals;
-+ do {
-+ scan(TOK_IDENT, &tok);
-+ elist = ALLOC(enumval_list);
-+ elist->name = tok.str;
-+ elist->assignment = NULL;
-+ scan3(TOK_COMMA, TOK_RBRACE, TOK_EQUAL, &tok);
-+ if (tok.kind == TOK_EQUAL) {
-+ scan_num(&tok);
-+ elist->assignment = tok.str;
-+ scan2(TOK_COMMA, TOK_RBRACE, &tok);
-+ }
-+ *tailp = elist;
-+ tailp = &elist->next;
-+ } while (tok.kind != TOK_RBRACE);
-+ *tailp = NULL;
-+}
-+
-+static void
-+def_const(definition *defp)
-+{
-+ token tok;
-+
-+ defp->def_kind = DEF_CONST;
-+ scan(TOK_IDENT, &tok);
-+ defp->def_name = tok.str;
-+ scan(TOK_EQUAL, &tok);
-+ scan2(TOK_IDENT, TOK_STRCONST, &tok);
-+ defp->def.co = tok.str;
-+}
-+
-+static void
-+def_union(definition *defp)
-+{
-+ token tok;
-+ declaration dec;
-+ case_list *cases;
-+ case_list **tailp;
-+
-+ defp->def_kind = DEF_UNION;
-+ scan(TOK_IDENT, &tok);
-+ defp->def_name = tok.str;
-+ scan(TOK_SWITCH, &tok);
-+ scan(TOK_LPAREN, &tok);
-+ get_declaration(&dec, DEF_UNION);
-+ defp->def.un.enum_decl = dec;
-+ tailp = &defp->def.un.cases;
-+ scan(TOK_RPAREN, &tok);
-+ scan(TOK_LBRACE, &tok);
-+ scan(TOK_CASE, &tok);
-+ while (tok.kind == TOK_CASE) {
-+ scan2(TOK_IDENT, TOK_CHARCONST, &tok);
-+ cases = ALLOC(case_list);
-+ cases->case_name = tok.str;
-+ scan(TOK_COLON, &tok);
-+ /* now peek at next token */
-+ if(peekscan(TOK_CASE,&tok))
-+ {
-+
-+ do
-+ {
-+ scan2(TOK_IDENT, TOK_CHARCONST, &tok);
-+ cases->contflag=1; /* continued case statement */
-+ *tailp = cases;
-+ tailp = &cases->next;
-+ cases = ALLOC(case_list);
-+ cases->case_name = tok.str;
-+ scan(TOK_COLON, &tok);
-+
-+ }while(peekscan(TOK_CASE,&tok));
-+ }
-+
-+ get_declaration(&dec, DEF_UNION);
-+ cases->case_decl = dec;
-+ cases->contflag=0; /* no continued case statement */
-+ *tailp = cases;
-+ tailp = &cases->next;
-+ scan(TOK_SEMICOLON, &tok);
-+
-+ scan3(TOK_CASE, TOK_DEFAULT, TOK_RBRACE, &tok);
-+ }
-+ *tailp = NULL;
-+ if (tok.kind == TOK_DEFAULT) {
-+ scan(TOK_COLON, &tok);
-+ get_declaration(&dec, DEF_UNION);
-+ defp->def.un.default_decl = ALLOC(declaration);
-+ *defp->def.un.default_decl = dec;
-+ scan(TOK_SEMICOLON, &tok);
-+ scan(TOK_RBRACE, &tok);
-+ } else {
-+ defp->def.un.default_decl = NULL;
-+ }
-+}
-+
-+static char* reserved_words[] =
-+{
-+ "array",
-+ "bytes",
-+ "destroy",
-+ "free",
-+ "getpos",
-+ "inline",
-+ "pointer",
-+ "reference",
-+ "setpos",
-+ "sizeof",
-+ "union",
-+ "vector",
-+ NULL
-+ };
-+
-+static char* reserved_types[] =
-+{
-+ "opaque",
-+ "string",
-+ NULL
-+ };
-+
-+/* check that the given name is not one that would eventually result in
-+ xdr routines that would conflict with internal XDR routines. */
-+static void
-+check_type_name(char *name, int new_type)
-+{
-+ int i;
-+ char tmp[100];
-+
-+ for( i = 0; reserved_words[i] != NULL; i++ ) {
-+ if( strcmp( name, reserved_words[i] ) == 0 ) {
-+ sprintf(tmp,
-+ "illegal (reserved) name :\'%s\' in type definition", name );
-+ error(tmp);
-+ }
-+ }
-+ if( new_type ) {
-+ for( i = 0; reserved_types[i] != NULL; i++ ) {
-+ if( strcmp( name, reserved_types[i] ) == 0 ) {
-+ sprintf(tmp,
-+ "illegal (reserved) name :\'%s\' in type definition", name );
-+ error(tmp);
-+ }
-+ }
-+ }
-+}
-+
-+static void
-+def_typedef(definition *defp)
-+{
-+ declaration dec;
-+
-+ defp->def_kind = DEF_TYPEDEF;
-+ get_declaration(&dec, DEF_TYPEDEF);
-+ defp->def_name = dec.name;
-+ check_type_name( dec.name, 1 );
-+ defp->def.ty.old_prefix = dec.prefix;
-+ defp->def.ty.old_type = dec.type;
-+ defp->def.ty.rel = dec.rel;
-+ defp->def.ty.array_max = dec.array_max;
-+}
-+
-+static void
-+get_declaration(declaration *dec, defkind dkind)
-+{
-+ token tok;
-+
-+ get_type(&dec->prefix, &dec->type, dkind);
-+ dec->rel = REL_ALIAS;
-+ if (streq(dec->type, "void")) {
-+ return;
-+ }
-+
-+ check_type_name( dec->type, 0 );
-+
-+ scan2(TOK_STAR, TOK_IDENT, &tok);
-+ if (tok.kind == TOK_STAR) {
-+ dec->rel = REL_POINTER;
-+ scan(TOK_IDENT, &tok);
-+ }
-+ dec->name = tok.str;
-+ if (peekscan(TOK_LBRACKET, &tok)) {
-+ if (dec->rel == REL_POINTER) {
-+ error("no array-of-pointer declarations -- use typedef");
-+ }
-+ dec->rel = REL_VECTOR;
-+ scan_num(&tok);
-+ dec->array_max = tok.str;
-+ scan(TOK_RBRACKET, &tok);
-+ } else if (peekscan(TOK_LANGLE, &tok)) {
-+ if (dec->rel == REL_POINTER) {
-+ error("no array-of-pointer declarations -- use typedef");
-+ }
-+ dec->rel = REL_ARRAY;
-+ if (peekscan(TOK_RANGLE, &tok)) {
-+ dec->array_max = "~0"; /* unspecified size, use max */
-+ } else {
-+ scan_num(&tok);
-+ dec->array_max = tok.str;
-+ scan(TOK_RANGLE, &tok);
-+ }
-+ }
-+ if (streq(dec->type, "opaque")) {
-+ if (dec->rel != REL_ARRAY && dec->rel != REL_VECTOR) {
-+ error("array declaration expected");
-+ }
-+ } else if (streq(dec->type, "string")) {
-+ if (dec->rel != REL_ARRAY) {
-+ error("variable-length array declaration expected");
-+ }
-+ }
-+}
-+
-+
-+static void
-+get_prog_declaration(declaration *dec, defkind dkind, int num)
-+{
-+ token tok;
-+ char name[10]; /* argument name */
-+
-+ if (dkind == DEF_PROGRAM) {
-+ peek(&tok);
-+ if (tok.kind == TOK_RPAREN) { /* no arguments */
-+ dec->rel = REL_ALIAS;
-+ dec->type = "void";
-+ dec->prefix = NULL;
-+ dec->name = NULL;
-+ return;
-+ }
-+ }
-+ get_type(&dec->prefix, &dec->type, dkind);
-+ dec->rel = REL_ALIAS;
-+ if (peekscan(TOK_IDENT, &tok)) /* optional name of argument */
-+ strcpy(name, tok.str);
-+ else
-+ sprintf(name, "%s%d", ARGNAME, num); /* default name of argument */
-+
-+ dec->name = (char *) strdup(name);
-+
-+ if (streq(dec->type, "void")) {
-+ return;
-+ }
-+
-+ if (streq(dec->type, "opaque")) {
-+ error("opaque -- illegal argument type");
-+ }
-+ if (peekscan(TOK_STAR, &tok)) {
-+ if (streq(dec->type, "string")) {
-+ error("pointer to string not allowed in program arguments\n");
-+ }
-+ dec->rel = REL_POINTER;
-+ if (peekscan(TOK_IDENT, &tok)) /* optional name of argument */
-+ dec->name = strdup(tok.str);
-+ }
-+ if (peekscan(TOK_LANGLE, &tok)) {
-+ if (!streq(dec->type, "string")) {
-+ error("arrays cannot be declared as arguments to procedures -- use typedef");
-+ }
-+ dec->rel = REL_ARRAY;
-+ if (peekscan(TOK_RANGLE, &tok)) {
-+ dec->array_max = "~0";/* unspecified size, use max */
-+ } else {
-+ scan_num(&tok);
-+ dec->array_max = tok.str;
-+ scan(TOK_RANGLE, &tok);
-+ }
-+ }
-+ if (streq(dec->type, "string")) {
-+ if (dec->rel != REL_ARRAY) { /* .x specifies just string as
-+ * type of argument
-+ * - make it string<>
-+ */
-+ dec->rel = REL_ARRAY;
-+ dec->array_max = "~0";/* unspecified size, use max */
-+ }
-+ }
-+}
-+
-+
-+
-+static void
-+get_type(char **prefixp, char **typep, defkind dkind)
-+{
-+ token tok;
-+
-+ *prefixp = NULL;
-+ get_token(&tok);
-+ switch (tok.kind) {
-+ case TOK_IDENT:
-+ *typep = tok.str;
-+ break;
-+ case TOK_STRUCT:
-+ case TOK_ENUM:
-+ case TOK_UNION:
-+ *prefixp = tok.str;
-+ scan(TOK_IDENT, &tok);
-+ *typep = tok.str;
-+ break;
-+ case TOK_UNSIGNED:
-+ unsigned_dec(typep);
-+ break;
-+ case TOK_SHORT:
-+ *typep = "short";
-+ (void) peekscan(TOK_INT, &tok);
-+ break;
-+ case TOK_INT32:
-+ *typep = "int32_t";
-+ (void) peekscan(TOK_INT, &tok);
-+ break;
-+ case TOK_VOID:
-+ if (dkind != DEF_UNION && dkind != DEF_PROGRAM) {
-+ error("voids allowed only inside union and program definitions with one argument");
-+ }
-+ *typep = tok.str;
-+ break;
-+ case TOK_STRING:
-+ case TOK_OPAQUE:
-+ case TOK_CHAR:
-+ case TOK_INT:
-+ case TOK_FLOAT:
-+ case TOK_DOUBLE:
-+ case TOK_BOOL:
-+ *typep = tok.str;
-+ break;
-+ default:
-+ error("expected type specifier");
-+ }
-+}
-+
-+static void
-+unsigned_dec(char **typep)
-+{
-+ token tok;
-+
-+ peek(&tok);
-+ switch (tok.kind) {
-+ case TOK_CHAR:
-+ get_token(&tok);
-+ *typep = "u_char";
-+ break;
-+ case TOK_SHORT:
-+ get_token(&tok);
-+ *typep = "u_short";
-+ (void) peekscan(TOK_INT, &tok);
-+ break;
-+ case TOK_INT32:
-+ get_token(&tok);
-+ *typep = "u_int32_";
-+ (void) peekscan(TOK_INT, &tok);
-+ break;
-+ case TOK_INT:
-+ get_token(&tok);
-+ *typep = "u_int";
-+ break;
-+ default:
-+ *typep = "u_int";
-+ break;
-+ }
-+}
-diff --git a/rpcgen/rpc_parse.h b/rpcgen/rpc_parse.h
-new file mode 100644
-index 0000000..2afae10
---- /dev/null
-+++ b/rpcgen/rpc_parse.h
-@@ -0,0 +1,166 @@
-+/*
-+ * Copyright (c) 2009, Sun Microsystems, Inc.
-+ * All rights reserved.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions are met:
-+ * - Redistributions of source code must retain the above copyright notice,
-+ * this list of conditions and the following disclaimer.
-+ * - Redistributions in binary form must reproduce the above copyright notice,
-+ * this list of conditions and the following disclaimer in the documentation
-+ * and/or other materials provided with the distribution.
-+ * - Neither the name of Sun Microsystems, Inc. nor the names of its
-+ * contributors may be used to endorse or promote products derived
-+ * from this software without specific prior written permission.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-+ * POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+/* @(#)rpc_parse.h 1.3 90/08/29 (C) 1987 SMI */
-+
-+/*
-+ * rpc_parse.h, Definitions for the RPCL parser
-+ */
-+
-+enum defkind {
-+ DEF_CONST,
-+ DEF_STRUCT,
-+ DEF_UNION,
-+ DEF_ENUM,
-+ DEF_TYPEDEF,
-+ DEF_PROGRAM
-+};
-+typedef enum defkind defkind;
-+
-+typedef char *const_def;
-+
-+enum relation {
-+ REL_VECTOR, /* fixed length array */
-+ REL_ARRAY, /* variable length array */
-+ REL_POINTER, /* pointer */
-+ REL_ALIAS, /* simple */
-+};
-+typedef enum relation relation;
-+
-+struct typedef_def {
-+ char *old_prefix;
-+ char *old_type;
-+ relation rel;
-+ char *array_max;
-+};
-+typedef struct typedef_def typedef_def;
-+
-+struct enumval_list {
-+ char *name;
-+ char *assignment;
-+ struct enumval_list *next;
-+};
-+typedef struct enumval_list enumval_list;
-+
-+struct enum_def {
-+ enumval_list *vals;
-+};
-+typedef struct enum_def enum_def;
-+
-+struct declaration {
-+ char *prefix;
-+ char *type;
-+ char *name;
-+ relation rel;
-+ char *array_max;
-+};
-+typedef struct declaration declaration;
-+
-+struct decl_list {
-+ declaration decl;
-+ struct decl_list *next;
-+};
-+typedef struct decl_list decl_list;
-+
-+struct struct_def {
-+ decl_list *decls;
-+};
-+typedef struct struct_def struct_def;
-+
-+struct case_list {
-+ char *case_name;
-+ int contflag;
-+ declaration case_decl;
-+ struct case_list *next;
-+};
-+typedef struct case_list case_list;
-+
-+struct union_def {
-+ declaration enum_decl;
-+ case_list *cases;
-+ declaration *default_decl;
-+};
-+typedef struct union_def union_def;
-+
-+struct arg_list {
-+ char *argname; /* name of struct for arg*/
-+ decl_list *decls;
-+};
-+
-+typedef struct arg_list arg_list;
-+
-+struct proc_list {
-+ char *proc_name;
-+ char *proc_num;
-+ arg_list args;
-+ int arg_num;
-+ char *res_type;
-+ char *res_prefix;
-+ struct proc_list *next;
-+};
-+typedef struct proc_list proc_list;
-+
-+struct version_list {
-+ char *vers_name;
-+ char *vers_num;
-+ proc_list *procs;
-+ struct version_list *next;
-+};
-+typedef struct version_list version_list;
-+
-+struct program_def {
-+ char *prog_num;
-+ version_list *versions;
-+};
-+typedef struct program_def program_def;
-+
-+struct definition {
-+ char *def_name;
-+ defkind def_kind;
-+ union {
-+ const_def co;
-+ struct_def st;
-+ union_def un;
-+ enum_def en;
-+ typedef_def ty;
-+ program_def pr;
-+ } def;
-+};
-+typedef struct definition definition;
-+
-+definition *get_definition();
-+
-+
-+struct bas_type
-+{
-+ char *name;
-+ int length;
-+ struct bas_type *next;
-+};
-+
-+typedef struct bas_type bas_type;
-diff --git a/rpcgen/rpc_sample.c b/rpcgen/rpc_sample.c
-new file mode 100644
-index 0000000..2b5c81b
---- /dev/null
-+++ b/rpcgen/rpc_sample.c
-@@ -0,0 +1,247 @@
-+/*
-+ * Copyright (c) 2009, Sun Microsystems, Inc.
-+ * All rights reserved.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions are met:
-+ * - Redistributions of source code must retain the above copyright notice,
-+ * this list of conditions and the following disclaimer.
-+ * - Redistributions in binary form must reproduce the above copyright notice,
-+ * this list of conditions and the following disclaimer in the documentation
-+ * and/or other materials provided with the distribution.
-+ * - Neither the name of Sun Microsystems, Inc. nor the names of its
-+ * contributors may be used to endorse or promote products derived
-+ * from this software without specific prior written permission.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-+ * POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+#if 0
-+static char sccsid[] = "@(#)rpc_sample.c 1.1 90/08/30 (C) 1987 SMI";
-+
-+#endif
-+
-+/*
-+ * rpc_sample.c, Sample client-server code outputter for the RPC protocol compiler
-+ */
-+
-+#include <stdio.h>
-+#include <string.h>
-+#include "rpc_parse.h"
-+#include "rpc_util.h"
-+
-+
-+static char RQSTP[] = "rqstp";
-+
-+static void write_sample_client(char *program_name, version_list *vp);
-+static void write_sample_server(definition * def);
-+static void return_type(proc_list *plist);
-+
-+void
-+write_sample_svc(definition *def)
-+{
-+ if (def->def_kind != DEF_PROGRAM)
-+ return;
-+ write_sample_server(def);
-+}
-+
-+
-+int
-+write_sample_clnt(definition *def)
-+{
-+ version_list *vp;
-+ int count = 0;
-+
-+ if (def->def_kind != DEF_PROGRAM)
-+ return (0);
-+ /* generate sample code for each version */
-+ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
-+ write_sample_client(def->def_name, vp);
-+ ++count;
-+ }
-+ return (count);
-+}
-+
-+
-+static void
-+write_sample_client(char *program_name, version_list *vp)
-+{
-+ proc_list *proc;
-+ int i;
-+ decl_list *l;
-+
-+ f_print(fout, "\n\nvoid\n");
-+ pvname(program_name, vp->vers_num);
-+ if (Cflag)
-+ f_print(fout, "( char* host )\n{\n");
-+ else
-+ f_print(fout, "(host)\nchar *host;\n{\n");
-+ f_print(fout, "\tCLIENT *clnt;\n");
-+
-+ i = 0;
-+ for (proc = vp->procs; proc != NULL; proc = proc->next) {
-+ f_print(fout, "\t");
-+ ptype(proc->res_prefix, proc->res_type, 1);
-+ f_print(fout, " *result_%d;\n", ++i);
-+ /* print out declarations for arguments */
-+ if (proc->arg_num < 2 && !newstyle) {
-+ f_print(fout, "\t");
-+ if (!streq(proc->args.decls->decl.type, "void"))
-+ ptype(proc->args.decls->decl.prefix, proc->args.decls->decl.type, 1);
-+ else
-+ f_print(fout, "char* "); /* cannot have "void" type */
-+ f_print(fout, " ");
-+ pvname(proc->proc_name, vp->vers_num);
-+ f_print(fout, "_arg;\n");
-+ } else if (!streq(proc->args.decls->decl.type, "void")) {
-+ for (l = proc->args.decls; l != NULL; l = l->next) {
-+ f_print(fout, "\t");
-+ ptype(l->decl.prefix, l->decl.type, 1);
-+ f_print(fout, " ");
-+ pvname(proc->proc_name, vp->vers_num);
-+ f_print(fout, "_%s;\n", l->decl.name);
-+ /* pdeclaration(proc->args.argname, &l->decl, 1, ";\n" );*/
-+ }
-+ }
-+ }
-+
-+ /* generate creation of client handle */
-+ f_print(fout, "\tclnt = clnt_create(host, %s, %s, \"%s\");\n",
-+ program_name, vp->vers_name, tirpcflag ? "netpath" : "udp");
-+ f_print(fout, "\tif (clnt == NULL) {\n");
-+ f_print(fout, "\t\tclnt_pcreateerror(host);\n");
-+ f_print(fout, "\t\texit(1);\n\t}\n");
-+
-+ /* generate calls to procedures */
-+ i = 0;
-+ for (proc = vp->procs; proc != NULL; proc = proc->next) {
-+ f_print(fout, "\tresult_%d = ", ++i);
-+ pvname(proc->proc_name, vp->vers_num);
-+ if (proc->arg_num < 2 && !newstyle) {
-+ f_print(fout, "(");
-+ if (streq(proc->args.decls->decl.type, "void")) /* cast to void* */
-+ f_print(fout, "(void*)");
-+ f_print(fout, "&");
-+ pvname(proc->proc_name, vp->vers_num);
-+ f_print(fout, "_arg, clnt);\n");
-+ } else if (streq(proc->args.decls->decl.type, "void")) {
-+ f_print(fout, "(clnt);\n");
-+ } else {
-+ f_print(fout, "(");
-+ for (l = proc->args.decls; l != NULL; l = l->next) {
-+ pvname(proc->proc_name, vp->vers_num);
-+ f_print(fout, "_%s, ", l->decl.name);
-+ }
-+ f_print(fout, "clnt);\n");
-+ }
-+ f_print(fout, "\tif (result_%d == NULL) {\n", i);
-+ f_print(fout, "\t\tclnt_perror(clnt, \"call failed:\");\n");
-+ f_print(fout, "\t}\n");
-+ }
-+
-+ f_print(fout, "\tclnt_destroy( clnt );\n");
-+ f_print(fout, "}\n");
-+}
-+
-+static void
-+write_sample_server(definition * def)
-+{
-+ version_list *vp;
-+ proc_list *proc;
-+
-+ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
-+ for (proc = vp->procs; proc != NULL; proc = proc->next) {
-+ f_print(fout, "\n");
-+ /* if( Cflag )
-+ f_print( fout, "extern \"C\"{\n");
-+*/
-+ return_type(proc);
-+ f_print(fout, "* \n");
-+ if (Cflag)
-+ pvname_svc(proc->proc_name, vp->vers_num);
-+ else
-+ pvname(proc->proc_name, vp->vers_num);
-+ printarglist(proc, RQSTP, "struct svc_req *");
-+
-+ f_print(fout, "{\n");
-+ f_print(fout, "\n\tstatic ");
-+ if (!streq(proc->res_type, "void"))
-+ return_type(proc);
-+ else
-+ f_print(fout, "char*"); /* cannot have void type */
-+ /* f_print(fout, " result;\n", proc->res_type); */
-+ f_print(fout, " result;\n");
-+ f_print(fout,
-+ "\n\t/*\n\t * insert server code here\n\t */\n\n");
-+ if (!streq(proc->res_type, "void"))
-+ f_print(fout, "\treturn(&result);\n}\n");
-+ else /* cast back to void * */
-+ f_print(fout, "\treturn((void*) &result);\n}\n");
-+ /* if( Cflag)
-+ f_print( fout, "};\n");
-+*/
-+
-+ }
-+ }
-+}
-+
-+
-+
-+static void
-+return_type(proc_list *plist)
-+{
-+ ptype( plist->res_prefix, plist->res_type, 1 );
-+}
-+
-+void
-+add_sample_msg(void)
-+{
-+ f_print(fout, "/*\n");
-+ f_print(fout, " * This is sample code generated by rpcgen.\n");
-+ f_print(fout, " * These are only templates and you can use them\n");
-+ f_print(fout, " * as a guideline for developing your own functions.\n");
-+ f_print(fout, " */\n\n");
-+}
-+
-+void
-+write_sample_clnt_main(void)
-+{
-+ list *l;
-+ definition *def;
-+ version_list *vp;
-+
-+ f_print(fout, "\n\n" );
-+ if( Cflag )
-+ f_print(fout,"main( int argc, char* argv[] )\n{\n" );
-+ else
-+ f_print(fout, "main(argc, argv)\nint argc;\nchar *argv[];\n{\n" );
-+
-+ f_print(fout, "\tchar *host;");
-+ f_print(fout, "\n\n\tif(argc < 2) {");
-+ f_print(fout, "\n\t\tprintf(\"usage: %%s server_host\\n\", argv[0]);\n" );
-+ f_print(fout, "\t\texit(1);\n\t}");
-+ f_print(fout, "\n\thost = argv[1];\n");
-+
-+ for (l = defined; l != NULL; l = l->next) {
-+ def = l->val;
-+ if (def->def_kind != DEF_PROGRAM) {
-+ continue;
-+ }
-+ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
-+ f_print( fout, "\t" );
-+ pvname(def->def_name, vp->vers_num);
-+ f_print( fout, "( host );\n" );
-+ }
-+ }
-+ f_print(fout, "}\n");
-+}
-diff --git a/rpcgen/rpc_scan.c b/rpcgen/rpc_scan.c
-new file mode 100644
-index 0000000..f58fa9f
---- /dev/null
-+++ b/rpcgen/rpc_scan.c
-@@ -0,0 +1,474 @@
-+/*
-+ * Copyright (c) 2009, Sun Microsystems, Inc.
-+ * All rights reserved.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions are met:
-+ * - Redistributions of source code must retain the above copyright notice,
-+ * this list of conditions and the following disclaimer.
-+ * - Redistributions in binary form must reproduce the above copyright notice,
-+ * this list of conditions and the following disclaimer in the documentation
-+ * and/or other materials provided with the distribution.
-+ * - Neither the name of Sun Microsystems, Inc. nor the names of its
-+ * contributors may be used to endorse or promote products derived
-+ * from this software without specific prior written permission.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-+ * POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+#if 0
-+static char sccsid[] = "@(#)rpc_scan.c 1.11 89/02/22 (C) 1987 SMI";
-+#endif
-+
-+/*
-+ * rpc_scan.c, Scanner for the RPC protocol compiler
-+ * Copyright (C) 1987, Sun Microsystems, Inc.
-+ */
-+#include <stdio.h>
-+#include <ctype.h>
-+#include <string.h>
-+#include "rpc_scan.h"
-+#include "rpc_parse.h"
-+#include "rpc_util.h"
-+
-+static void unget_token(token *tokp);
-+static void findstrconst(char **str, char **val);
-+static void findchrconst(char **str, char **val);
-+static void findconst(char **str, char **val);
-+static void findkind(char **mark, token *tokp);
-+static int cppline(char *line);
-+static int directive(char *line);
-+static void printdirective(char *line);
-+static void docppline(char *line, int *lineno, char **fname);
-+
-+#define startcomment(where) (where[0] == '/' && where[1] == '*')
-+#define endcomment(where) (where[-1] == '*' && where[0] == '/')
-+
-+static int pushed = 0; /* is a token pushed */
-+static token lasttok; /* last token, if pushed */
-+
-+/*
-+ * scan expecting 1 given token
-+ */
-+void
-+scan(tok_kind expect, token *tokp)
-+{
-+ get_token(tokp);
-+ if (tokp->kind != expect) {
-+ expected1(expect);
-+ }
-+}
-+
-+/*
-+ * scan expecting any of the 2 given tokens
-+ */
-+void
-+scan2(tok_kind expect1, tok_kind expect2, token *tokp)
-+{
-+ get_token(tokp);
-+ if (tokp->kind != expect1 && tokp->kind != expect2) {
-+ expected2(expect1, expect2);
-+ }
-+}
-+
-+/*
-+ * scan expecting any of the 3 given token
-+ */
-+void
-+scan3(tok_kind expect1, tok_kind expect2, tok_kind expect3, token *tokp)
-+{
-+ get_token(tokp);
-+ if (tokp->kind != expect1 && tokp->kind != expect2
-+ && tokp->kind != expect3) {
-+ expected3(expect1, expect2, expect3);
-+ }
-+}
-+
-+/*
-+ * scan expecting a constant, possibly symbolic
-+ */
-+void
-+scan_num(token *tokp)
-+{
-+ get_token(tokp);
-+ switch (tokp->kind) {
-+ case TOK_IDENT:
-+ break;
-+ default:
-+ error("constant or identifier expected");
-+ }
-+}
-+
-+/*
-+ * Peek at the next token
-+ */
-+void
-+peek(token *tokp)
-+{
-+ get_token(tokp);
-+ unget_token(tokp);
-+}
-+
-+/*
-+ * Peek at the next token and scan it if it matches what you expect
-+ */
-+int
-+peekscan(tok_kind expect, token *tokp)
-+{
-+ peek(tokp);
-+ if (tokp->kind == expect) {
-+ get_token(tokp);
-+ return (1);
-+ }
-+ return (0);
-+}
-+
-+/*
-+ * Get the next token, printing out any directive that are encountered.
-+ */
-+void
-+get_token(token *tokp)
-+{
-+ int commenting;
-+
-+ if (pushed) {
-+ pushed = 0;
-+ *tokp = lasttok;
-+ return;
-+ }
-+ commenting = 0;
-+ for (;;) {
-+ if (*where == 0) {
-+ for (;;) {
-+ if (!fgets(curline, MAXLINESIZE, fin)) {
-+ tokp->kind = TOK_EOF;
-+ *where = 0;
-+ return;
-+ }
-+ linenum++;
-+ if (commenting) {
-+ break;
-+ } else if (cppline(curline)) {
-+ docppline(curline, &linenum,
-+ &infilename);
-+ } else if (directive(curline)) {
-+ printdirective(curline);
-+ } else {
-+ break;
-+ }
-+ }
-+ where = curline;
-+ } else if (isspace(*where)) {
-+ while (isspace(*where)) {
-+ where++; /* eat */
-+ }
-+ } else if (commenting) {
-+ for (where++; *where; where++) {
-+ if (endcomment(where)) {
-+ where++;
-+ commenting--;
-+ break;
-+ }
-+ }
-+ } else if (startcomment(where)) {
-+ where += 2;
-+ commenting++;
-+ } else {
-+ break;
-+ }
-+ }
-+
-+ /*
-+ * 'where' is not whitespace, comment or directive Must be a token!
-+ */
-+ switch (*where) {
-+ case ':':
-+ tokp->kind = TOK_COLON;
-+ where++;
-+ break;
-+ case ';':
-+ tokp->kind = TOK_SEMICOLON;
-+ where++;
-+ break;
-+ case ',':
-+ tokp->kind = TOK_COMMA;
-+ where++;
-+ break;
-+ case '=':
-+ tokp->kind = TOK_EQUAL;
-+ where++;
-+ break;
-+ case '*':
-+ tokp->kind = TOK_STAR;
-+ where++;
-+ break;
-+ case '[':
-+ tokp->kind = TOK_LBRACKET;
-+ where++;
-+ break;
-+ case ']':
-+ tokp->kind = TOK_RBRACKET;
-+ where++;
-+ break;
-+ case '{':
-+ tokp->kind = TOK_LBRACE;
-+ where++;
-+ break;
-+ case '}':
-+ tokp->kind = TOK_RBRACE;
-+ where++;
-+ break;
-+ case '(':
-+ tokp->kind = TOK_LPAREN;
-+ where++;
-+ break;
-+ case ')':
-+ tokp->kind = TOK_RPAREN;
-+ where++;
-+ break;
-+ case '<':
-+ tokp->kind = TOK_LANGLE;
-+ where++;
-+ break;
-+ case '>':
-+ tokp->kind = TOK_RANGLE;
-+ where++;
-+ break;
-+
-+ case '"':
-+ tokp->kind = TOK_STRCONST;
-+ findstrconst(&where, &tokp->str);
-+ break;
-+ case '\'':
-+ tokp->kind = TOK_CHARCONST;
-+ findchrconst(&where, &tokp->str);
-+ break;
-+
-+ case '-':
-+ case '0':
-+ case '1':
-+ case '2':
-+ case '3':
-+ case '4':
-+ case '5':
-+ case '6':
-+ case '7':
-+ case '8':
-+ case '9':
-+ tokp->kind = TOK_IDENT;
-+ findconst(&where, &tokp->str);
-+ break;
-+
-+ default:
-+ if (!(isalpha(*where) || *where == '_')) {
-+ char buf[100];
-+ char *p;
-+
-+ s_print(buf, "illegal character in file: ");
-+ p = buf + strlen(buf);
-+ if (isprint(*where)) {
-+ s_print(p, "%c", *where);
-+ } else {
-+ s_print(p, "%d", *where);
-+ }
-+ error(buf);
-+ }
-+ findkind(&where, tokp);
-+ break;
-+ }
-+}
-+
-+static void
-+unget_token(token *tokp)
-+{
-+ lasttok = *tokp;
-+ pushed = 1;
-+}
-+
-+static void
-+findstrconst(char **str, char **val)
-+{
-+ char *p;
-+ int size;
-+
-+ p = *str;
-+ do {
-+ *p++;
-+ } while (*p && *p != '"');
-+ if (*p == 0) {
-+ error("unterminated string constant");
-+ }
-+ p++;
-+ size = p - *str;
-+ *val = alloc(size + 1);
-+ (void) strncpy(*val, *str, size);
-+ (*val)[size] = 0;
-+ *str = p;
-+}
-+
-+static void
-+findchrconst(char **str, char **val)
-+{
-+ char *p;
-+ int size;
-+
-+ p = *str;
-+ do {
-+ *p++;
-+ } while (*p && *p != '\'');
-+ if (*p == 0) {
-+ error("unterminated string constant");
-+ }
-+ p++;
-+ size = p - *str;
-+ if (size != 3) {
-+ error("empty char string");
-+ }
-+ *val = alloc(size + 1);
-+ (void) strncpy(*val, *str, size);
-+ (*val)[size] = 0;
-+ *str = p;
-+}
-+
-+static void
-+findconst(char **str, char **val)
-+{
-+ char *p;
-+ int size;
-+
-+ p = *str;
-+ if (*p == '0' && *(p + 1) == 'x') {
-+ p++;
-+ do {
-+ p++;
-+ } while (isxdigit(*p));
-+ } else {
-+ do {
-+ p++;
-+ } while (isdigit(*p));
-+ }
-+ size = p - *str;
-+ *val = alloc(size + 1);
-+ (void) strncpy(*val, *str, size);
-+ (*val)[size] = 0;
-+ *str = p;
-+}
-+
-+static token symbols[] = {
-+ {TOK_CONST, "const"},
-+ {TOK_UNION, "union"},
-+ {TOK_SWITCH, "switch"},
-+ {TOK_CASE, "case"},
-+ {TOK_DEFAULT, "default"},
-+ {TOK_STRUCT, "struct"},
-+ {TOK_TYPEDEF, "typedef"},
-+ {TOK_ENUM, "enum"},
-+ {TOK_OPAQUE, "opaque"},
-+ {TOK_BOOL, "bool"},
-+ {TOK_VOID, "void"},
-+ {TOK_CHAR, "char"},
-+ {TOK_INT, "int"},
-+ {TOK_UNSIGNED, "unsigned"},
-+ {TOK_SHORT, "short"},
-+ {TOK_INT32, "int32"},
-+ {TOK_FLOAT, "float"},
-+ {TOK_DOUBLE, "double"},
-+ {TOK_STRING, "string"},
-+ {TOK_PROGRAM, "program"},
-+ {TOK_VERSION, "version"},
-+ {TOK_EOF, "??????"},
-+};
-+
-+static void
-+findkind(char **mark, token *tokp)
-+{
-+ int len;
-+ token *s;
-+ char *str;
-+
-+ str = *mark;
-+ for (s = symbols; s->kind != TOK_EOF; s++) {
-+ len = strlen(s->str);
-+ if (strncmp(str, s->str, len) == 0) {
-+ if (!isalnum(str[len]) && str[len] != '_') {
-+ tokp->kind = s->kind;
-+ tokp->str = s->str;
-+ *mark = str + len;
-+ return;
-+ }
-+ }
-+ }
-+ tokp->kind = TOK_IDENT;
-+ for (len = 0; isalnum(str[len]) || str[len] == '_'; len++);
-+ tokp->str = alloc(len + 1);
-+ (void) strncpy(tokp->str, str, len);
-+ tokp->str[len] = 0;
-+ *mark = str + len;
-+}
-+
-+static int
-+cppline(char *line)
-+{
-+ return (line == curline && *line == '#');
-+}
-+
-+static int
-+directive(char *line)
-+{
-+ return (line == curline && *line == '%');
-+}
-+
-+static void
-+printdirective(char *line)
-+{
-+ f_print(fout, "%s", line + 1);
-+}
-+
-+static void
-+docppline(char *line, int *lineno, char **fname)
-+{
-+ char *file;
-+ int num;
-+ char *p;
-+
-+ line++;
-+ while (isspace(*line)) {
-+ line++;
-+ }
-+ num = atoi(line);
-+ while (isdigit(*line)) {
-+ line++;
-+ }
-+ while (isspace(*line)) {
-+ line++;
-+ }
-+ if (*line != '"') {
-+ error("preprocessor error");
-+ }
-+ line++;
-+ p = file = alloc(strlen(line) + 1);
-+ while (*line && *line != '"') {
-+ *p++ = *line++;
-+ }
-+ if (*line == 0) {
-+ error("preprocessor error");
-+ }
-+ *p = 0;
-+ if (*file == 0) {
-+ *fname = NULL;
-+ free(file);
-+ } else {
-+ *fname = file;
-+ }
-+ *lineno = num - 1;
-+}
-diff --git a/rpcgen/rpc_scan.h b/rpcgen/rpc_scan.h
-new file mode 100644
-index 0000000..16f688c
---- /dev/null
-+++ b/rpcgen/rpc_scan.h
-@@ -0,0 +1,103 @@
-+/*
-+ * Copyright (c) 2009, Sun Microsystems, Inc.
-+ * All rights reserved.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions are met:
-+ * - Redistributions of source code must retain the above copyright notice,
-+ * this list of conditions and the following disclaimer.
-+ * - Redistributions in binary form must reproduce the above copyright notice,
-+ * this list of conditions and the following disclaimer in the documentation
-+ * and/or other materials provided with the distribution.
-+ * - Neither the name of Sun Microsystems, Inc. nor the names of its
-+ * contributors may be used to endorse or promote products derived
-+ * from this software without specific prior written permission.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-+ * POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+/* @(#)rpc_scan.h 1.3 90/08/29 (C) 1987 SMI */
-+
-+/*
-+ * rpc_scan.h, Definitions for the RPCL scanner
-+ */
-+
-+/*
-+ * kinds of tokens
-+ */
-+enum tok_kind {
-+ TOK_IDENT,
-+ TOK_CHARCONST,
-+ TOK_STRCONST,
-+ TOK_LPAREN,
-+ TOK_RPAREN,
-+ TOK_LBRACE,
-+ TOK_RBRACE,
-+ TOK_LBRACKET,
-+ TOK_RBRACKET,
-+ TOK_LANGLE,
-+ TOK_RANGLE,
-+ TOK_STAR,
-+ TOK_COMMA,
-+ TOK_EQUAL,
-+ TOK_COLON,
-+ TOK_SEMICOLON,
-+ TOK_CONST,
-+ TOK_STRUCT,
-+ TOK_UNION,
-+ TOK_SWITCH,
-+ TOK_CASE,
-+ TOK_DEFAULT,
-+ TOK_ENUM,
-+ TOK_TYPEDEF,
-+ TOK_INT,
-+ TOK_SHORT,
-+ TOK_INT32,
-+ TOK_UNSIGNED,
-+ TOK_FLOAT,
-+ TOK_DOUBLE,
-+ TOK_OPAQUE,
-+ TOK_CHAR,
-+ TOK_STRING,
-+ TOK_BOOL,
-+ TOK_VOID,
-+ TOK_PROGRAM,
-+ TOK_VERSION,
-+ TOK_EOF
-+};
-+typedef enum tok_kind tok_kind;
-+
-+/*
-+ * a token
-+ */
-+struct token {
-+ tok_kind kind;
-+ char *str;
-+};
-+typedef struct token token;
-+
-+
-+/*
-+ * routine interface
-+ */
-+void scan();
-+void scan2();
-+void scan3();
-+void scan_num();
-+void peek();
-+int peekscan();
-+void get_token();
-+void expected1(tok_kind);
-+void expected2(tok_kind, tok_kind);
-+void expected3(tok_kind, tok_kind, tok_kind);
-+
-diff --git a/rpcgen/rpc_svcout.c b/rpcgen/rpc_svcout.c
-new file mode 100644
-index 0000000..284a529
---- /dev/null
-+++ b/rpcgen/rpc_svcout.c
-@@ -0,0 +1,882 @@
-+/*
-+ * Copyright (c) 2009, Sun Microsystems, Inc.
-+ * All rights reserved.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions are met:
-+ * - Redistributions of source code must retain the above copyright notice,
-+ * this list of conditions and the following disclaimer.
-+ * - Redistributions in binary form must reproduce the above copyright notice,
-+ * this list of conditions and the following disclaimer in the documentation
-+ * and/or other materials provided with the distribution.
-+ * - Neither the name of Sun Microsystems, Inc. nor the names of its
-+ * contributors may be used to endorse or promote products derived
-+ * from this software without specific prior written permission.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-+ * POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+#if 0
-+ static char sccsid[] = "@(#)rpc_svcout.c 1.29 89/03/30 (C) 1987 SMI";
-+#endif
-+
-+/*
-+ * rpc_svcout.c, Server-skeleton outputter for the RPC protocol compiler
-+ */
-+#include <stdio.h>
-+#include <string.h>
-+#include "rpc_parse.h"
-+#include "rpc_util.h"
-+#include "rpc_output.h"
-+
-+static void write_real_program(definition *def);
-+static void write_program(definition *def, char *storage);
-+static void printerr(char *err, char *transp);
-+static void printif(char *proc, char *transp, char *prefix, char *arg);
-+static void write_inetmost(char *infile);
-+static void print_return(char *space);
-+static void print_pmapunset(char *space);
-+static void print_err_message(char *space);
-+static void write_timeout_func(void);
-+static void write_pm_most(char *infile, int netflag);
-+static void write_rpc_svc_fg(char *infile, char *sp);
-+static void open_log_file(char *infile, char *sp);
-+
-+static char RQSTP[] = "rqstp";
-+static char TRANSP[] = "transp";
-+static char ARG[] = "argument";
-+static char RESULT[] = "result";
-+static char ROUTINE[] = "local";
-+
-+char _errbuf[256]; /* For all messages */
-+
-+static void
-+p_xdrfunc(char *rname, char *typename)
-+{
-+ if (Cflag)
-+ f_print(fout, "\t\txdr_%s = (xdrproc_t) xdr_%s;\n", rname,
-+ stringfix(typename));
-+ else
-+ f_print(fout, "\t\txdr_%s = xdr_%s;\n", rname, stringfix(typename));
-+}
-+
-+void
-+internal_proctype(proc_list *plist)
-+{
-+ f_print(fout, "static ");
-+ ptype( plist->res_prefix, plist->res_type, 1 );
-+ f_print( fout, "*" );
-+}
-+
-+
-+/*
-+ * write most of the service, that is, everything but the registrations.
-+ */
-+void
-+write_most(char *infile, int netflag, int nomain)
-+{
-+ if (inetdflag || pmflag) {
-+ char* var_type;
-+ var_type = (nomain? "extern" : "static");
-+ f_print(fout, "%s int _rpcpmstart;", var_type );
-+ f_print(fout, "\t\t/* Started by a port monitor ? */\n");
-+ f_print(fout, "%s int _rpcfdtype;", var_type );
-+ f_print(fout, "\t\t/* Whether Stream or Datagram ? */\n");
-+ if (timerflag) {
-+ f_print(fout, "%s int _rpcsvcdirty;", var_type );
-+ f_print(fout, "\t/* Still serving ? */\n");
-+ }
-+ write_svc_aux( nomain );
-+ }
-+ /* write out dispatcher and stubs */
-+ write_programs( nomain? (char *)NULL : "static" );
-+
-+ if( nomain )
-+ return;
-+
-+ f_print(fout, "\nmain()\n");
-+ f_print(fout, "{\n");
-+ if (inetdflag) {
-+ write_inetmost(infile); /* Includes call to write_rpc_svc_fg() */
-+ } else {
-+ if( tirpcflag ) {
-+ if (netflag) {
-+ f_print(fout, "\tregister SVCXPRT *%s;\n", TRANSP);
-+ f_print(fout, "\tstruct netconfig *nconf = NULL;\n");
-+ }
-+ f_print(fout, "\tpid_t pid;\n");
-+ f_print(fout, "\tint i;\n");
-+ f_print(fout, "\tchar mname[FMNAMESZ + 1];\n\n");
-+ write_pm_most(infile, netflag);
-+ f_print(fout, "\telse {\n");
-+ write_rpc_svc_fg(infile, "\t\t");
-+ f_print(fout, "\t}\n");
-+ } else {
-+ f_print(fout, "\tregister SVCXPRT *%s;\n", TRANSP);
-+ f_print(fout, "\n");
-+ print_pmapunset("\t");
-+ }
-+ }
-+
-+ if (logflag && !inetdflag) {
-+ open_log_file(infile, "\t");
-+ }
-+}
-+
-+/*
-+ * write a registration for the given transport
-+ */
-+void
-+write_netid_register(char *transp)
-+{
-+ list *l;
-+ definition *def;
-+ version_list *vp;
-+ char *sp;
-+ char tmpbuf[32];
-+
-+ sp = "";
-+ f_print(fout, "\n");
-+ f_print(fout, "%s\tnconf = getnetconfigent(\"%s\");\n", sp, transp);
-+ f_print(fout, "%s\tif (nconf == NULL) {\n", sp);
-+ (void) sprintf(_errbuf, "cannot find %s netid.", transp);
-+ sprintf(tmpbuf, "%s\t\t", sp);
-+ print_err_message(tmpbuf);
-+ f_print(fout, "%s\t\texit(1);\n", sp);
-+ f_print(fout, "%s\t}\n", sp);
-+ f_print(fout, "%s\t%s = svc_tli_create(RPC_ANYFD, nconf, 0, 0, 0);\n",
-+ sp, TRANSP);
-+ f_print(fout, "%s\tif (%s == NULL) {\n", sp, TRANSP);
-+ (void) sprintf(_errbuf, "cannot create %s service.", transp);
-+ print_err_message(tmpbuf);
-+ f_print(fout, "%s\t\texit(1);\n", sp);
-+ f_print(fout, "%s\t}\n", sp);
-+
-+ for (l = defined; l != NULL; l = l->next) {
-+ def = (definition *) l->val;
-+ if (def->def_kind != DEF_PROGRAM) {
-+ continue;
-+ }
-+ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
-+ f_print(fout,
-+ "%s\t(void) rpcb_unset(%s, %s, nconf);\n",
-+ sp, def->def_name, vp->vers_name);
-+ f_print(fout,
-+ "%s\tif (!svc_reg(%s, %s, %s, ",
-+ sp, TRANSP, def->def_name, vp->vers_name);
-+ pvname(def->def_name, vp->vers_num);
-+ f_print(fout, ", nconf)) {\n");
-+ (void) sprintf(_errbuf, "unable to register (%s, %s, %s).",
-+ def->def_name, vp->vers_name, transp);
-+ print_err_message(tmpbuf);
-+ f_print(fout, "%s\t\texit(1);\n", sp);
-+ f_print(fout, "%s\t}\n", sp);
-+ }
-+ }
-+ f_print(fout, "%s\tfreenetconfigent(nconf);\n", sp);
-+}
-+
-+/*
-+ * write a registration for the given transport for TLI
-+ */
-+void
-+write_nettype_register(char *transp)
-+{
-+ list *l;
-+ definition *def;
-+ version_list *vp;
-+
-+ for (l = defined; l != NULL; l = l->next) {
-+ def = (definition *) l->val;
-+ if (def->def_kind != DEF_PROGRAM) {
-+ continue;
-+ }
-+ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
-+ f_print(fout, "\tif (!svc_create(");
-+ pvname(def->def_name, vp->vers_num);
-+ f_print(fout, ", %s, %s, \"%s\")) {\n ",
-+ def->def_name, vp->vers_name, transp);
-+ (void) sprintf(_errbuf,
-+ "unable to create (%s, %s) for %s.",
-+ def->def_name, vp->vers_name, transp);
-+ print_err_message("\t\t");
-+ f_print(fout, "\t\texit(1);\n");
-+ f_print(fout, "\t}\n");
-+ }
-+ }
-+}
-+
-+/*
-+ * write the rest of the service
-+ */
-+void
-+write_rest(void)
-+{
-+ f_print(fout, "\n");
-+ if (inetdflag) {
-+ f_print(fout, "\tif (%s == (SVCXPRT *)NULL) {\n", TRANSP);
-+ (void) sprintf(_errbuf, "could not create a handle");
-+ print_err_message("\t\t");
-+ f_print(fout, "\t\texit(1);\n");
-+ f_print(fout, "\t}\n");
-+ if (timerflag) {
-+ f_print(fout, "\tif (_rpcpmstart) {\n");
-+ f_print(fout,
-+ "\t\t(void) signal(SIGALRM, %s closedown);\n",
-+ Cflag? "(SIG_PF)" : "(void(*)())" );
-+ f_print(fout, "\t\t(void) alarm(_RPCSVC_CLOSEDOWN);\n");
-+ f_print(fout, "\t}\n");
-+ }
-+ }
-+ f_print(fout, "\tsvc_run();\n");
-+ (void) sprintf(_errbuf, "svc_run returned");
-+ print_err_message("\t");
-+ f_print(fout, "\texit(1);\n");
-+ f_print(fout, "\t/* NOTREACHED */\n");
-+ f_print(fout, "}\n");
-+}
-+
-+void
-+write_programs(char *storage)
-+{
-+ list *l;
-+ definition *def;
-+
-+ /* write out stubs for procedure definitions */
-+ for (l = defined; l != NULL; l = l->next) {
-+ def = (definition *) l->val;
-+ if (def->def_kind == DEF_PROGRAM) {
-+ write_real_program(def);
-+ }
-+ }
-+
-+ /* write out dispatcher for each program */
-+ for (l = defined; l != NULL; l = l->next) {
-+ def = (definition *) l->val;
-+ if (def->def_kind == DEF_PROGRAM) {
-+ write_program(def, storage);
-+ }
-+ }
-+
-+
-+}
-+
-+/* write out definition of internal function (e.g. _printmsg_1(...))
-+ which calls server's defintion of actual function (e.g. printmsg_1(...)).
-+ Unpacks single user argument of printmsg_1 to call-by-value format
-+ expected by printmsg_1. */
-+static void
-+write_real_program(definition *def)
-+{
-+ version_list *vp;
-+ proc_list *proc;
-+ decl_list *l;
-+
-+ if( !newstyle ) return; /* not needed for old style */
-+ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
-+ for (proc = vp->procs; proc != NULL; proc = proc->next) {
-+ f_print(fout, "\n");
-+ internal_proctype(proc);
-+ f_print(fout, "\n_");
-+ pvname(proc->proc_name, vp->vers_num);
-+ if( Cflag ) {
-+ f_print(fout, "(" );
-+ /* arg name */
-+ if (proc->arg_num > 1)
-+ f_print(fout, proc->args.argname);
-+ else
-+ ptype(proc->args.decls->decl.prefix,
-+ proc->args.decls->decl.type, 0);
-+ f_print(fout, " *argp, struct svc_req *%s)\n",
-+ RQSTP);
-+ } else {
-+ f_print(fout, "(argp, %s)\n", RQSTP );
-+ /* arg name */
-+ if (proc->arg_num > 1)
-+ f_print(fout, "\t%s *argp;\n", proc->args.argname);
-+ else {
-+ f_print(fout, "\t");
-+ ptype(proc->args.decls->decl.prefix,
-+ proc->args.decls->decl.type, 0);
-+ f_print(fout, " *argp;\n");
-+ }
-+ f_print(fout, " struct svc_req *%s;\n", RQSTP);
-+ }
-+
-+ f_print(fout, "{\n");
-+ f_print(fout, "\treturn(");
-+ if( Cflag )
-+ pvname_svc(proc->proc_name, vp->vers_num);
-+ else
-+ pvname(proc->proc_name, vp->vers_num);
-+ f_print(fout, "(");
-+ if (proc->arg_num < 2) { /* single argument */
-+ if (!streq( proc->args.decls->decl.type, "void"))
-+ f_print(fout, "*argp, "); /* non-void */
-+ } else {
-+ for (l = proc->args.decls; l != NULL; l = l->next)
-+ f_print(fout, "argp->%s, ", l->decl.name);
-+ }
-+ f_print(fout, "%s));\n}\n", RQSTP);
-+ }
-+ }
-+}
-+
-+static void
-+write_program(definition *def, char *storage)
-+{
-+ version_list *vp;
-+ proc_list *proc;
-+ int filled;
-+
-+ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
-+ f_print(fout, "\n");
-+ if (storage != NULL) {
-+ f_print(fout, "%s ", storage);
-+ }
-+ f_print(fout, "void\n");
-+ pvname(def->def_name, vp->vers_num);
-+
-+ if (Cflag) {
-+ f_print(fout, "(struct svc_req *%s, ", RQSTP);
-+ f_print(fout, "register SVCXPRT *%s)\n", TRANSP);
-+ } else {
-+ f_print(fout, "(%s, %s)\n", RQSTP, TRANSP);
-+ f_print(fout, " struct svc_req *%s;\n", RQSTP);
-+ f_print(fout, " register SVCXPRT *%s;\n", TRANSP);
-+ }
-+
-+ f_print(fout, "{\n");
-+
-+ filled = 0;
-+ f_print(fout, "\tunion {\n");
-+ for (proc = vp->procs; proc != NULL; proc = proc->next) {
-+ if (proc->arg_num < 2) { /* single argument */
-+ if (streq(proc->args.decls->decl.type,
-+ "void")) {
-+ continue;
-+ }
-+ filled = 1;
-+ f_print(fout, "\t\t");
-+ ptype(proc->args.decls->decl.prefix,
-+ proc->args.decls->decl.type, 0);
-+ pvname(proc->proc_name, vp->vers_num);
-+ f_print(fout, "_arg;\n");
-+
-+ }
-+ else {
-+ filled = 1;
-+ f_print(fout, "\t\t%s", proc->args.argname);
-+ f_print(fout, " ");
-+ pvname(proc->proc_name, vp->vers_num);
-+ f_print(fout, "_arg;\n");
-+ }
-+ }
-+ if (!filled) {
-+ f_print(fout, "\t\tint fill;\n");
-+ }
-+ f_print(fout, "\t} %s;\n", ARG);
-+ f_print(fout, "\tchar *%s;\n", RESULT);
-+
-+ if (Cflag) {
-+ f_print(fout, "\txdrproc_t xdr_%s, xdr_%s;\n", ARG, RESULT);
-+ f_print(fout,
-+ "\tchar *(*%s)(char *, struct svc_req *);\n",
-+ ROUTINE);
-+ } else {
-+ f_print(fout, "\tbool_t (*xdr_%s)(), (*xdr_%s)();\n", ARG, RESULT);
-+ f_print(fout, "\tchar *(*%s)();\n", ROUTINE);
-+ }
-+
-+ f_print(fout, "\n");
-+
-+ if (timerflag)
-+ f_print(fout, "\t_rpcsvcdirty = 1;\n");
-+ f_print(fout, "\tswitch (%s->rq_proc) {\n", RQSTP);
-+ if (!nullproc(vp->procs)) {
-+ f_print(fout, "\tcase NULLPROC:\n");
-+ f_print(fout,
-+ "\t\t(void) svc_sendreply(%s, (xdrproc_t) xdr_void, (char *)NULL);\n",
-+ TRANSP);
-+ print_return("\t\t");
-+ f_print(fout, "\n");
-+ }
-+ for (proc = vp->procs; proc != NULL; proc = proc->next) {
-+ f_print(fout, "\tcase %s:\n", proc->proc_name);
-+ if (proc->arg_num < 2) { /* single argument */
-+ p_xdrfunc( ARG, proc->args.decls->decl.type);
-+ } else {
-+ p_xdrfunc( ARG, proc->args.argname);
-+ }
-+ p_xdrfunc( RESULT, proc->res_type);
-+ if( Cflag )
-+ f_print(fout,
-+ "\t\t%s = (char *(*)(char *, struct svc_req *)) ",
-+ ROUTINE);
-+ else
-+ f_print(fout, "\t\t%s = (char *(*)()) ", ROUTINE);
-+
-+ if (newstyle) { /* new style: calls internal routine */
-+ f_print(fout,"_");
-+ }
-+ /* Not sure about the following...
-+ * rpc_hout always generates foobar_1_svc for
-+ * the service procedure, so why should we use
-+ * foobar_1 here?! --okir */
-+#if 0
-+ if( Cflag && !newstyle )
-+ pvname_svc(proc->proc_name, vp->vers_num);
-+ else
-+ pvname(proc->proc_name, vp->vers_num);
-+#else
-+ pvname_svc(proc->proc_name, vp->vers_num);
-+#endif
-+ f_print(fout, ";\n");
-+ f_print(fout, "\t\tbreak;\n\n");
-+ }
-+ f_print(fout, "\tdefault:\n");
-+ printerr("noproc", TRANSP);
-+ print_return("\t\t");
-+ f_print(fout, "\t}\n");
-+
-+ f_print(fout, "\t(void) memset((char *)&%s, 0, sizeof (%s));\n", ARG, ARG);
-+ if (Cflag)
-+ printif("getargs", TRANSP, "(caddr_t) &", ARG);
-+ else
-+ printif("getargs", TRANSP, "&", ARG);
-+ printerr("decode", TRANSP);
-+ print_return("\t\t");
-+ f_print(fout, "\t}\n");
-+
-+ if (Cflag)
-+ f_print(fout, "\t%s = (*%s)((char *)&%s, %s);\n",
-+ RESULT, ROUTINE, ARG, RQSTP);
-+ else
-+ f_print(fout, "\t%s = (*%s)(&%s, %s);\n",
-+ RESULT, ROUTINE, ARG, RQSTP);
-+ f_print(fout,
-+ "\tif (%s != NULL && !svc_sendreply(%s, "
-+ "(xdrproc_t) xdr_%s, %s)) {\n",
-+ RESULT, TRANSP, RESULT, RESULT);
-+ printerr("systemerr", TRANSP);
-+ f_print(fout, "\t}\n");
-+
-+ if (Cflag)
-+ printif("freeargs", TRANSP, "(caddr_t) &", ARG);
-+ else
-+ printif("freeargs", TRANSP, "&", ARG);
-+ (void) sprintf(_errbuf, "unable to free arguments");
-+ print_err_message("\t\t");
-+ f_print(fout, "\t\texit(1);\n");
-+ f_print(fout, "\t}\n");
-+ print_return("\t");
-+ f_print(fout, "}\n");
-+ }
-+}
-+
-+static void
-+printerr(char *err, char *transp)
-+{
-+ f_print(fout, "\t\tsvcerr_%s(%s);\n", err, transp);
-+}
-+
-+static void
-+printif(char *proc, char *transp, char *prefix, char *arg)
-+{
-+ f_print(fout, "\tif (!svc_%s(%s, (xdrproc_t) xdr_%s, (caddr_t) %s%s)) {\n",
-+ proc, transp, arg, prefix, arg);
-+}
-+
-+int
-+nullproc(proc_list *proc)
-+{
-+ for (; proc != NULL; proc = proc->next) {
-+ if (streq(proc->proc_num, "0")) {
-+ return (1);
-+ }
-+ }
-+ return (0);
-+}
-+
-+static void
-+write_inetmost(char *infile)
-+{
-+ f_print(fout, "\tregister SVCXPRT *%s;\n", TRANSP);
-+ f_print(fout, "\tint sock;\n");
-+ f_print(fout, "\tint proto;\n");
-+ f_print(fout, "\tstruct sockaddr_in saddr;\n");
-+ f_print(fout, "\tint asize = sizeof (saddr);\n");
-+ f_print(fout, "\n");
-+ f_print(fout,
-+ "\tif (getsockname(0, (struct sockaddr *)&saddr, &asize) == 0) {\n");
-+ f_print(fout, "\t\tint ssize = sizeof (int);\n\n");
-+ f_print(fout, "\t\tif (saddr.sin_family != AF_INET)\n");
-+ f_print(fout, "\t\t\texit(1);\n");
-+ f_print(fout, "\t\tif (getsockopt(0, SOL_SOCKET, SO_TYPE,\n");
-+ f_print(fout, "\t\t\t\t(char *)&_rpcfdtype, &ssize) == -1)\n");
-+ f_print(fout, "\t\t\texit(1);\n");
-+ f_print(fout, "\t\tsock = 0;\n");
-+ f_print(fout, "\t\t_rpcpmstart = 1;\n");
-+ f_print(fout, "\t\tproto = 0;\n");
-+ open_log_file(infile, "\t\t");
-+ f_print(fout, "\t} else {\n");
-+ write_rpc_svc_fg(infile, "\t\t");
-+ f_print(fout, "\t\tsock = RPC_ANYSOCK;\n");
-+ print_pmapunset("\t\t");
-+ f_print(fout, "\t}\n");
-+}
-+
-+static void
-+print_return(char *space)
-+{
-+ if (exitnow)
-+ f_print(fout, "%sexit(0);\n", space);
-+ else {
-+ if (timerflag)
-+ f_print(fout, "%s_rpcsvcdirty = 0;\n", space);
-+ f_print(fout, "%sreturn;\n", space);
-+ }
-+}
-+
-+static void
-+print_pmapunset(char *space)
-+{
-+ list *l;
-+ definition *def;
-+ version_list *vp;
-+
-+ for (l = defined; l != NULL; l = l->next) {
-+ def = (definition *) l->val;
-+ if (def->def_kind == DEF_PROGRAM) {
-+ for (vp = def->def.pr.versions; vp != NULL;
-+ vp = vp->next) {
-+ f_print(fout, "%s(void) pmap_unset(%s, %s);\n",
-+ space, def->def_name, vp->vers_name);
-+ }
-+ }
-+ }
-+}
-+
-+static void
-+print_err_message(char *space)
-+{
-+ if (logflag)
-+ f_print(fout, "%ssyslog(LOG_ERR, \"%s\");\n", space, _errbuf);
-+ else if (inetdflag || pmflag)
-+ f_print(fout, "%s_msgout(\"%s\");\n", space, _errbuf);
-+ else
-+ f_print(fout, "%sfprintf(stderr, \"%s\");\n", space, _errbuf);
-+}
-+
-+/*
-+ * Write the server auxiliary function ( _msgout, timeout)
-+ */
-+void
-+write_svc_aux(int nomain)
-+{
-+ if (!logflag)
-+ write_msg_out();
-+ if( !nomain )
-+ write_timeout_func();
-+}
-+
-+/*
-+ * Write the _msgout function
-+ */
-+void
-+write_msg_out(void)
-+{
-+ f_print(fout, "\n");
-+ f_print(fout, "static\n");
-+ if( !Cflag ) {
-+ f_print(fout, "void _msgout(msg)\n");
-+ f_print(fout, "\tchar *msg;\n");
-+ } else {
-+ f_print(fout, "void _msgout(char* msg)\n");
-+ }
-+ f_print(fout, "{\n");
-+ f_print(fout, "#ifdef RPC_SVC_FG\n");
-+ if (inetdflag || pmflag)
-+ f_print(fout, "\tif (_rpcpmstart)\n");
-+ f_print(fout, "\t\tsyslog(LOG_ERR, \"%%s\", msg);\n");
-+ f_print(fout, "\telse\n");
-+ f_print(fout, "\t\t(void) fprintf(stderr, \"%%s\\n\", msg);\n");
-+ f_print(fout, "#else\n");
-+ f_print(fout, "\tsyslog(LOG_ERR, \"%%s\", msg);\n");
-+ f_print(fout, "#endif\n");
-+ f_print(fout, "}\n");
-+}
-+
-+/*
-+ * Write the timeout function
-+ */
-+static void
-+write_timeout_func(void)
-+{
-+ if (!timerflag)
-+ return;
-+ f_print(fout, "\n");
-+ f_print(fout, "static void\n");
-+ f_print(fout, "closedown()\n");
-+ f_print(fout, "{\n");
-+ f_print(fout, "\tif (_rpcsvcdirty == 0) {\n");
-+ f_print(fout, "\t\tstatic int size;\n");
-+ f_print(fout, "\t\tint i, openfd;\n");
-+ if (tirpcflag && pmflag) {
-+ f_print(fout, "\t\tstruct t_info tinfo;\n\n");
-+ f_print(fout, "\t\tif (!t_getinfo(0, &tinfo) && (tinfo.servtype == T_CLTS))\n");
-+ } else {
-+ f_print(fout, "\n\t\tif (_rpcfdtype == SOCK_DGRAM)\n");
-+ }
-+ f_print(fout, "\t\t\texit(0);\n");
-+ f_print(fout, "\t\tif (size == 0) {\n");
-+ if( tirpcflag ) {
-+ f_print(fout, "\t\t\tstruct rlimit rl;\n\n");
-+ f_print(fout, "\t\t\trl.rlim_max = 0;\n");
-+ f_print(fout, "\t\t\tgetrlimit(RLIMIT_NOFILE, &rl);\n");
-+ f_print(fout, "\t\t\tif ((size = rl.rlim_max) == 0)\n");
-+ f_print(fout, "\t\t\t\treturn;\n");
-+ } else {
-+ f_print(fout, "\t\t\tsize = getdtablesize();\n");
-+ }
-+ f_print(fout, "\t\t}\n");
-+ f_print(fout, "\t\tfor (i = 0, openfd = 0; i < size && openfd < 2; i++)\n");
-+ f_print(fout, "\t\t\tif (FD_ISSET(i, &svc_fdset))\n");
-+ f_print(fout, "\t\t\t\topenfd++;\n");
-+ f_print(fout, "\t\tif (openfd <= 1)\n");
-+ f_print(fout, "\t\t\texit(0);\n");
-+ f_print(fout, "\t}\n");
-+ f_print(fout, "\t(void) alarm(_RPCSVC_CLOSEDOWN);\n");
-+ f_print(fout, "}\n");
-+}
-+
-+/*
-+ * Write the most of port monitor support
-+ */
-+static void
-+write_pm_most(char *infile, int netflag)
-+{
-+ list *l;
-+ definition *def;
-+ version_list *vp;
-+
-+ f_print(fout, "\tif (!ioctl(0, I_LOOK, mname) &&\n");
-+ f_print(fout, "\t\t(!strcmp(mname, \"sockmod\") ||");
-+ f_print(fout, " !strcmp(mname, \"timod\"))) {\n");
-+ f_print(fout, "\t\tchar *netid;\n");
-+ if (!netflag) { /* Not included by -n option */
-+ f_print(fout, "\t\tstruct netconfig *nconf = NULL;\n");
-+ f_print(fout, "\t\tSVCXPRT *%s;\n", TRANSP);
-+ }
-+ if( timerflag )
-+ f_print(fout, "\t\tint pmclose;\n");
-+/* not necessary, defined in /usr/include/stdlib */
-+/* f_print(fout, "\t\textern char *getenv();\n");*/
-+ f_print(fout, "\n");
-+ f_print(fout, "\t\t_rpcpmstart = 1;\n");
-+ if (logflag)
-+ open_log_file(infile, "\t\t");
-+ f_print(fout, "\t\tif ((netid = getenv(\"NLSPROVIDER\")) == NULL) {\n");
-+ sprintf(_errbuf, "cannot get transport name");
-+ print_err_message("\t\t\t");
-+ f_print(fout, "\t\t} else if ((nconf = getnetconfigent(netid)) == NULL) {\n");
-+ sprintf(_errbuf, "cannot get transport info");
-+ print_err_message("\t\t\t");
-+ f_print(fout, "\t\t}\n");
-+ /*
-+ * A kludgy support for inetd services. Inetd only works with
-+ * sockmod, and RPC works only with timod, hence all this jugglery
-+ */
-+ f_print(fout, "\t\tif (strcmp(mname, \"sockmod\") == 0) {\n");
-+ f_print(fout, "\t\t\tif (ioctl(0, I_POP, 0) || ioctl(0, I_PUSH, \"timod\")) {\n");
-+ sprintf(_errbuf, "could not get the right module");
-+ print_err_message("\t\t\t\t");
-+ f_print(fout, "\t\t\t\texit(1);\n");
-+ f_print(fout, "\t\t\t}\n");
-+ f_print(fout, "\t\t}\n");
-+ if( timerflag )
-+ f_print(fout, "\t\tpmclose = (t_getstate(0) != T_DATAXFER);\n");
-+ f_print(fout, "\t\tif ((%s = svc_tli_create(0, nconf, NULL, 0, 0)) == NULL) {\n",
-+ TRANSP);
-+ sprintf(_errbuf, "cannot create server handle");
-+ print_err_message("\t\t\t");
-+ f_print(fout, "\t\t\texit(1);\n");
-+ f_print(fout, "\t\t}\n");
-+ f_print(fout, "\t\tif (nconf)\n");
-+ f_print(fout, "\t\t\tfreenetconfigent(nconf);\n");
-+ for (l = defined; l != NULL; l = l->next) {
-+ def = (definition *) l->val;
-+ if (def->def_kind != DEF_PROGRAM) {
-+ continue;
-+ }
-+ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
-+ f_print(fout,
-+ "\t\tif (!svc_reg(%s, %s, %s, ",
-+ TRANSP, def->def_name, vp->vers_name);
-+ pvname(def->def_name, vp->vers_num);
-+ f_print(fout, ", 0)) {\n");
-+ (void) sprintf(_errbuf, "unable to register (%s, %s).",
-+ def->def_name, vp->vers_name);
-+ print_err_message("\t\t\t");
-+ f_print(fout, "\t\t\texit(1);\n");
-+ f_print(fout, "\t\t}\n");
-+ }
-+ }
-+ if (timerflag) {
-+ f_print(fout, "\t\tif (pmclose) {\n");
-+ f_print(fout, "\t\t\t(void) signal(SIGALRM, %s closedown);\n",
-+ Cflag? "(SIG_PF)" : "(void(*)())" );
-+ f_print(fout, "\t\t\t(void) alarm(_RPCSVC_CLOSEDOWN);\n");
-+ f_print(fout, "\t\t}\n");
-+ }
-+ f_print(fout, "\t\tsvc_run();\n");
-+ f_print(fout, "\t\texit(1);\n");
-+ f_print(fout, "\t\t/* NOTREACHED */\n");
-+ f_print(fout, "\t}\n");
-+}
-+
-+/*
-+ * Support for backgrounding the server if self started.
-+ */
-+static void
-+write_rpc_svc_fg(char *infile, char *sp)
-+{
-+ f_print(fout, "#ifndef RPC_SVC_FG\n");
-+ f_print(fout, "%sint size;\n", sp);
-+ if( tirpcflag )
-+ f_print(fout, "%sstruct rlimit rl;\n", sp);
-+ if (inetdflag)
-+ f_print(fout, "%sint pid, i;\n\n", sp);
-+ f_print(fout, "%spid = fork();\n", sp);
-+ f_print(fout, "%sif (pid < 0) {\n", sp);
-+ f_print(fout, "%s\tperror(\"cannot fork\");\n", sp);
-+ f_print(fout, "%s\texit(1);\n", sp);
-+ f_print(fout, "%s}\n", sp);
-+ f_print(fout, "%sif (pid)\n", sp);
-+ f_print(fout, "%s\texit(0);\n", sp);
-+ /* get number of file descriptors */
-+ if( tirpcflag ) {
-+ f_print(fout, "%srl.rlim_max = 0;\n", sp);
-+ f_print(fout, "%sgetrlimit(RLIMIT_NOFILE, &rl);\n", sp);
-+ f_print(fout, "%sif ((size = rl.rlim_max) == 0)\n", sp);
-+ f_print(fout, "%s\texit(1);\n", sp);
-+ } else {
-+ f_print(fout, "%ssize = getdtablesize();\n", sp);
-+ }
-+
-+ f_print(fout, "%sfor (i = 0; i < size; i++)\n", sp);
-+ f_print(fout, "%s\t(void) close(i);\n", sp);
-+ /* Redirect stderr and stdout to console */
-+ f_print(fout, "%si = open(\"/dev/console\", 2);\n", sp);
-+ f_print(fout, "%s(void) dup2(i, 1);\n", sp);
-+ f_print(fout, "%s(void) dup2(i, 2);\n", sp);
-+ /* This removes control of the controlling terminal */
-+ if( tirpcflag )
-+ f_print(fout, "%ssetsid();\n", sp);
-+ else {
-+ f_print(fout, "%si = open(\"/dev/tty\", 2);\n", sp);
-+ f_print(fout, "%sif (i >= 0) {\n", sp);
-+ f_print(fout, "%s\t(void) ioctl(i, TIOCNOTTY, (char *)NULL);\n", sp);;
-+ f_print(fout, "%s\t(void) close(i);\n", sp);
-+ f_print(fout, "%s}\n", sp);
-+ }
-+ if (!logflag)
-+ open_log_file(infile, sp);
-+ f_print(fout, "#endif\n");
-+ if (logflag)
-+ open_log_file(infile, sp);
-+}
-+
-+static void
-+open_log_file(char *infile, char *sp)
-+{
-+ char *s;
-+
-+ s = strrchr(infile, '.');
-+ if (s)
-+ *s = '\0';
-+ f_print(fout,"%sopenlog(\"%s\", LOG_PID, LOG_DAEMON);\n", sp, infile);
-+ if (s)
-+ *s = '.';
-+}
-+
-+
-+
-+
-+/*
-+ * write a registration for the given transport for Inetd
-+ */
-+void
-+write_inetd_register(char *transp)
-+{
-+ list *l;
-+ definition *def;
-+ version_list *vp;
-+ char *sp;
-+ int isudp;
-+ char tmpbuf[32];
-+
-+ if (inetdflag)
-+ sp = "\t";
-+ else
-+ sp = "";
-+ if (streq(transp, "udp"))
-+ isudp = 1;
-+ else
-+ isudp = 0;
-+ f_print(fout, "\n");
-+ if (inetdflag) {
-+ f_print(fout, "\tif ((_rpcfdtype == 0) || (_rpcfdtype == %s)) {\n",
-+ isudp ? "SOCK_DGRAM" : "SOCK_STREAM");
-+ }
-+ f_print(fout, "%s\t%s = svc%s_create(%s",
-+ sp, TRANSP, transp, inetdflag? "sock": "RPC_ANYSOCK");
-+ if (!isudp)
-+ f_print(fout, ", 0, 0");
-+ f_print(fout, ");\n");
-+ f_print(fout, "%s\tif (%s == NULL) {\n", sp, TRANSP);
-+ (void) sprintf(_errbuf, "cannot create %s service.", transp);
-+ (void) sprintf(tmpbuf, "%s\t\t", sp);
-+ print_err_message(tmpbuf);
-+ f_print(fout, "%s\t\texit(1);\n", sp);
-+ f_print(fout, "%s\t}\n", sp);
-+
-+ if (inetdflag) {
-+ f_print(fout, "%s\tif (!_rpcpmstart)\n\t", sp);
-+ f_print(fout, "%s\tproto = IPPROTO_%s;\n",
-+ sp, isudp ? "UDP": "TCP");
-+ }
-+ for (l = defined; l != NULL; l = l->next) {
-+ def = (definition *) l->val;
-+ if (def->def_kind != DEF_PROGRAM) {
-+ continue;
-+ }
-+ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
-+ f_print(fout, "%s\tif (!svc_register(%s, %s, %s, ",
-+ sp, TRANSP, def->def_name, vp->vers_name);
-+ pvname(def->def_name, vp->vers_num);
-+ if (inetdflag)
-+ f_print(fout, ", proto)) {\n");
-+ else
-+ f_print(fout, ", IPPROTO_%s)) {\n",
-+ isudp ? "UDP": "TCP");
-+ (void) sprintf(_errbuf, "unable to register (%s, %s, %s).",
-+ def->def_name, vp->vers_name, transp);
-+ print_err_message(tmpbuf);
-+ f_print(fout, "%s\t\texit(1);\n", sp);
-+ f_print(fout, "%s\t}\n", sp);
-+ }
-+ }
-+ if (inetdflag)
-+ f_print(fout, "\t}\n");
-+}
-diff --git a/rpcgen/rpc_tblout.c b/rpcgen/rpc_tblout.c
-new file mode 100644
-index 0000000..ae002f7
---- /dev/null
-+++ b/rpcgen/rpc_tblout.c
-@@ -0,0 +1,165 @@
-+/*
-+ * Copyright (c) 2009, Sun Microsystems, Inc.
-+ * All rights reserved.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions are met:
-+ * - Redistributions of source code must retain the above copyright notice,
-+ * this list of conditions and the following disclaimer.
-+ * - Redistributions in binary form must reproduce the above copyright notice,
-+ * this list of conditions and the following disclaimer in the documentation
-+ * and/or other materials provided with the distribution.
-+ * - Neither the name of Sun Microsystems, Inc. nor the names of its
-+ * contributors may be used to endorse or promote products derived
-+ * from this software without specific prior written permission.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-+ * POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+#if 0
-+static char sccsid[] = "@(#)rpc_tblout.c 1.4 89/02/22 (C) 1988 SMI";
-+#endif
-+
-+/*
-+ * rpc_tblout.c, Dispatch table outputter for the RPC protocol compiler
-+ */
-+#include <stdio.h>
-+#include <string.h>
-+#include "rpc_parse.h"
-+#include "rpc_util.h"
-+#include "rpc_output.h"
-+
-+static void write_table(definition *def);
-+static void printit(char *prefix, char *type);
-+
-+#define TABSIZE 8
-+#define TABCOUNT 5
-+#define TABSTOP (TABSIZE*TABCOUNT)
-+
-+static char tabstr[TABCOUNT+1] = "\t\t\t\t\t";
-+
-+static char tbl_hdr[] = "struct rpcgen_table %s_table[] = {\n";
-+static char tbl_end[] = "};\n";
-+
-+static char null_entry[] = "\n\t(char *(*)())0,\n\
-+ \t(xdrproc_t) xdr_void,\t\t\t0,\n\
-+ \t(xdrproc_t) xdr_void,\t\t\t0,\n";
-+
-+
-+static char tbl_nproc[] = "int %s_nproc =\n\tsizeof(%s_table)/sizeof(%s_table[0]);\n\n";
-+
-+void
-+write_tables(void)
-+{
-+ list *l;
-+ definition *def;
-+
-+ f_print(fout, "\n");
-+ for (l = defined; l != NULL; l = l->next) {
-+ def = (definition *) l->val;
-+ if (def->def_kind == DEF_PROGRAM) {
-+ write_table(def);
-+ }
-+ }
-+}
-+
-+static void
-+write_table(definition *def)
-+{
-+ version_list *vp;
-+ proc_list *proc;
-+ int current;
-+ int expected;
-+ char progvers[100];
-+ int warning;
-+
-+ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
-+ warning = 0;
-+ s_print(progvers, "%s_%s",
-+ locase(def->def_name), vp->vers_num);
-+ /* print the table header */
-+ f_print(fout, tbl_hdr, progvers);
-+
-+ if (nullproc(vp->procs)) {
-+ expected = 0;
-+ } else {
-+ expected = 1;
-+ f_print(fout, null_entry);
-+ }
-+ for (proc = vp->procs; proc != NULL; proc = proc->next) {
-+ current = atoi(proc->proc_num);
-+ if (current != expected++) {
-+ f_print(fout,
-+ "\n/*\n * WARNING: table out of order\n */\n");
-+ if (warning == 0) {
-+ f_print(stderr,
-+ "WARNING %s table is out of order\n",
-+ progvers);
-+ warning = 1;
-+ nonfatalerrors = 1;
-+ }
-+ expected = current + 1;
-+ }
-+ f_print(fout, "\n\t(char *(*)())RPCGEN_ACTION(");
-+
-+ /* routine to invoke */
-+ if( Cflag && !newstyle )
-+ pvname_svc(proc->proc_name, vp->vers_num);
-+ else {
-+ if( newstyle )
-+ f_print( fout, "_"); /* calls internal func */
-+ pvname(proc->proc_name, vp->vers_num);
-+ }
-+ f_print(fout, "),\n");
-+
-+ /* argument info */
-+ if( proc->arg_num > 1 )
-+ printit((char*) NULL, proc->args.argname );
-+ else
-+ /* do we have to do something special for newstyle */
-+ printit( proc->args.decls->decl.prefix,
-+ proc->args.decls->decl.type );
-+ /* result info */
-+ printit(proc->res_prefix, proc->res_type);
-+ }
-+
-+ /* print the table trailer */
-+ f_print(fout, tbl_end);
-+ f_print(fout, tbl_nproc, progvers, progvers, progvers);
-+ }
-+}
-+
-+static void
-+printit(char *prefix, char *type)
-+{
-+ int len;
-+ int tabs;
-+
-+
-+ len = fprintf(fout, "\txdr_%s,", stringfix(type));
-+ /* account for leading tab expansion */
-+ len += TABSIZE - 1;
-+ /* round up to tabs required */
-+ tabs = (TABSTOP - len + TABSIZE - 1)/TABSIZE;
-+ f_print(fout, "%s", &tabstr[TABCOUNT-tabs]);
-+
-+ if (streq(type, "void")) {
-+ f_print(fout, "0");
-+ } else {
-+ f_print(fout, "sizeof ( ");
-+ /* XXX: should "follow" be 1 ??? */
-+ ptype(prefix, type, 0);
-+ f_print(fout, ")");
-+ }
-+ f_print(fout, ",\n");
-+}
-diff --git a/rpcgen/rpc_util.c b/rpcgen/rpc_util.c
-new file mode 100644
-index 0000000..b67be57
---- /dev/null
-+++ b/rpcgen/rpc_util.c
-@@ -0,0 +1,479 @@
-+/*
-+ * Copyright (c) 2009, Sun Microsystems, Inc.
-+ * All rights reserved.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions are met:
-+ * - Redistributions of source code must retain the above copyright notice,
-+ * this list of conditions and the following disclaimer.
-+ * - Redistributions in binary form must reproduce the above copyright notice,
-+ * this list of conditions and the following disclaimer in the documentation
-+ * and/or other materials provided with the distribution.
-+ * - Neither the name of Sun Microsystems, Inc. nor the names of its
-+ * contributors may be used to endorse or promote products derived
-+ * from this software without specific prior written permission.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-+ * POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+#if 0
-+static char sccsid[] = "@(#)rpc_util.c 1.11 89/02/22 (C) 1987 SMI";
-+#endif
-+
-+/*
-+ * rpc_util.c, Utility routines for the RPC protocol compiler
-+ */
-+#include <stdio.h>
-+#include <memory.h>
-+#include <ctype.h>
-+#include <unistd.h>
-+#include "rpc_scan.h"
-+#include "rpc_parse.h"
-+#include "rpc_util.h"
-+
-+static void printwhere(void);
-+
-+
-+#define ARGEXT "argument"
-+
-+char curline[MAXLINESIZE]; /* current read line */
-+char *where = curline; /* current point in line */
-+int linenum = 0; /* current line number */
-+
-+char *infilename; /* input filename */
-+
-+#define NFILES 7
-+char *outfiles[NFILES]; /* output file names */
-+int nfiles;
-+
-+FILE *fout; /* file pointer of current output */
-+FILE *fin; /* file pointer of current input */
-+
-+list *defined; /* list of defined things */
-+
-+/*
-+ * Reinitialize the world
-+ */
-+void
-+reinitialize(void)
-+{
-+ memset(curline, 0, MAXLINESIZE);
-+ where = curline;
-+ linenum = 0;
-+ defined = NULL;
-+}
-+
-+/*
-+ * string equality
-+ */
-+int
-+streq(char *a, char *b)
-+{
-+ return (strcmp(a, b) == 0);
-+}
-+
-+/*
-+ * find a value in a list
-+ */
-+definition *
-+findval(list *lst, char *val, int (*cmp)(definition *, char *))
-+{
-+
-+ for (; lst != NULL; lst = lst->next) {
-+ if ((*cmp) (lst->val, val)) {
-+ return (lst->val);
-+ }
-+ }
-+ return (NULL);
-+}
-+
-+/*
-+ * store a value in a list
-+ */
-+void
-+storeval(lstp, val)
-+ list **lstp;
-+ definition *val;
-+{
-+ list **l;
-+ list *lst;
-+
-+
-+ for (l = lstp; *l != NULL; l = (list **) & (*l)->next);
-+ lst = ALLOC(list);
-+ lst->val = val;
-+ lst->next = NULL;
-+ *l = lst;
-+}
-+
-+static int
-+findit(definition *def, char *type)
-+{
-+ return (streq(def->def_name, type));
-+}
-+
-+static char *
-+fixit(char *type, char *orig)
-+{
-+ definition *def;
-+
-+ def = (definition *) FINDVAL(defined, type, findit);
-+ if (def == NULL || def->def_kind != DEF_TYPEDEF) {
-+ return (orig);
-+ }
-+ switch (def->def.ty.rel) {
-+ case REL_VECTOR:
-+ return (def->def.ty.old_type);
-+ case REL_ALIAS:
-+ return (fixit(def->def.ty.old_type, orig));
-+ default:
-+ return (orig);
-+ }
-+}
-+
-+char *
-+fixtype(char *type)
-+{
-+ return (fixit(type, type));
-+}
-+
-+char *
-+stringfix(char *type)
-+{
-+ if (streq(type, "string")) {
-+ return ("wrapstring");
-+ } else {
-+ return (type);
-+ }
-+}
-+
-+void
-+ptype(char *prefix, char *type, int follow)
-+{
-+ if (prefix != NULL) {
-+ if (streq(prefix, "enum")) {
-+ f_print(fout, "enum ");
-+ } else {
-+ f_print(fout, "struct ");
-+ }
-+ }
-+ if (streq(type, "bool")) {
-+ f_print(fout, "bool_t ");
-+ } else if (streq(type, "string")) {
-+ f_print(fout, "char *");
-+ } else {
-+ f_print(fout, "%s ", follow ? fixtype(type) : type);
-+ }
-+}
-+
-+static int
-+typedefed(definition *def, char *type)
-+{
-+ if (def->def_kind != DEF_TYPEDEF || def->def.ty.old_prefix != NULL) {
-+ return (0);
-+ } else {
-+ return (streq(def->def_name, type));
-+ }
-+}
-+
-+int
-+isvectordef(char *type, relation rel)
-+{
-+ definition *def;
-+
-+ for (;;) {
-+ switch (rel) {
-+ case REL_VECTOR:
-+ return (!streq(type, "string"));
-+ case REL_ARRAY:
-+ return (0);
-+ case REL_POINTER:
-+ return (0);
-+ case REL_ALIAS:
-+ def = (definition *) FINDVAL(defined, type, typedefed);
-+ if (def == NULL) {
-+ return (0);
-+ }
-+ type = def->def.ty.old_type;
-+ rel = def->def.ty.rel;
-+ }
-+ }
-+}
-+
-+char *
-+locase(char *str)
-+{
-+ char c;
-+ static char buf[100];
-+ char *p = buf;
-+
-+ while ((c = *str++) != '\0') {
-+ *p++ = (c >= 'A' && c <= 'Z') ? (c - 'A' + 'a') : c;
-+ }
-+ *p = 0;
-+ return (buf);
-+}
-+
-+void
-+pvname_svc(char *pname, char *vnum)
-+{
-+ f_print(fout, "%s_%s_svc", locase(pname), vnum);
-+}
-+
-+void
-+pvname(char *pname, char *vnum)
-+{
-+ f_print(fout, "%s_%s", locase(pname), vnum);
-+}
-+
-+/*
-+ * print a useful (?) error message, and then die
-+ */
-+void
-+error(char *msg)
-+{
-+ printwhere();
-+ f_print(stderr, "%s, line %d: ", infilename, linenum);
-+ f_print(stderr, "%s\n", msg);
-+ crash();
-+}
-+
-+/*
-+ * Something went wrong, unlink any files that we may have created and then
-+ * die.
-+ */
-+void
-+crash(void)
-+{
-+ int i;
-+
-+ for (i = 0; i < nfiles; i++) {
-+ (void) unlink(outfiles[i]);
-+ }
-+ exit(1);
-+}
-+
-+void
-+record_open(char *file)
-+{
-+ if (nfiles < NFILES) {
-+ outfiles[nfiles++] = file;
-+ } else {
-+ f_print(stderr, "too many files!\n");
-+ crash();
-+ }
-+}
-+
-+static char expectbuf[100];
-+static char *toktostr();
-+
-+/*
-+ * error, token encountered was not the expected one
-+ */
-+void
-+expected1(exp1)
-+ tok_kind exp1;
-+{
-+ s_print(expectbuf, "expected '%s'",
-+ toktostr(exp1));
-+ error(expectbuf);
-+}
-+
-+/*
-+ * error, token encountered was not one of two expected ones
-+ */
-+void
-+expected2(exp1, exp2)
-+ tok_kind exp1, exp2;
-+{
-+ s_print(expectbuf, "expected '%s' or '%s'",
-+ toktostr(exp1),
-+ toktostr(exp2));
-+ error(expectbuf);
-+}
-+
-+/*
-+ * error, token encountered was not one of 3 expected ones
-+ */
-+void
-+expected3(exp1, exp2, exp3)
-+ tok_kind exp1, exp2, exp3;
-+{
-+ s_print(expectbuf, "expected '%s', '%s' or '%s'",
-+ toktostr(exp1),
-+ toktostr(exp2),
-+ toktostr(exp3));
-+ error(expectbuf);
-+}
-+
-+void
-+tabify(f, tab)
-+ FILE *f;
-+ int tab;
-+{
-+ while (tab--) {
-+ (void) fputc('\t', f);
-+ }
-+}
-+
-+
-+static token tokstrings[] = {
-+ {TOK_IDENT, "identifier"},
-+ {TOK_CONST, "const"},
-+ {TOK_RPAREN, ")"},
-+ {TOK_LPAREN, "("},
-+ {TOK_RBRACE, "}"},
-+ {TOK_LBRACE, "{"},
-+ {TOK_LBRACKET, "["},
-+ {TOK_RBRACKET, "]"},
-+ {TOK_STAR, "*"},
-+ {TOK_COMMA, ","},
-+ {TOK_EQUAL, "="},
-+ {TOK_COLON, ":"},
-+ {TOK_SEMICOLON, ";"},
-+ {TOK_UNION, "union"},
-+ {TOK_STRUCT, "struct"},
-+ {TOK_SWITCH, "switch"},
-+ {TOK_CASE, "case"},
-+ {TOK_DEFAULT, "default"},
-+ {TOK_ENUM, "enum"},
-+ {TOK_TYPEDEF, "typedef"},
-+ {TOK_INT, "int"},
-+ {TOK_SHORT, "short"},
-+ {TOK_INT32, "int32"},
-+ {TOK_UNSIGNED, "unsigned"},
-+ {TOK_DOUBLE, "double"},
-+ {TOK_FLOAT, "float"},
-+ {TOK_CHAR, "char"},
-+ {TOK_STRING, "string"},
-+ {TOK_OPAQUE, "opaque"},
-+ {TOK_BOOL, "bool"},
-+ {TOK_VOID, "void"},
-+ {TOK_PROGRAM, "program"},
-+ {TOK_VERSION, "version"},
-+ {TOK_EOF, "??????"}
-+};
-+
-+static char *
-+toktostr(kind)
-+ tok_kind kind;
-+{
-+ token *sp;
-+
-+ for (sp = tokstrings; sp->kind != TOK_EOF && sp->kind != kind; sp++);
-+ return (sp->str);
-+}
-+
-+static void
-+printbuf(void)
-+{
-+ char c;
-+ int i;
-+ int cnt;
-+
-+# define TABSIZE 4
-+
-+ for (i = 0; (c = curline[i]) != '\0'; i++) {
-+ if (c == '\t') {
-+ cnt = 8 - (i % TABSIZE);
-+ c = ' ';
-+ } else {
-+ cnt = 1;
-+ }
-+ while (cnt--) {
-+ (void) fputc(c, stderr);
-+ }
-+ }
-+}
-+
-+static void
-+printwhere(void)
-+{
-+ int i;
-+ char c;
-+ int cnt;
-+
-+ printbuf();
-+ for (i = 0; i < where - curline; i++) {
-+ c = curline[i];
-+ if (c == '\t') {
-+ cnt = 8 - (i % TABSIZE);
-+ } else {
-+ cnt = 1;
-+ }
-+ while (cnt--) {
-+ (void) fputc('^', stderr);
-+ }
-+ }
-+ (void) fputc('\n', stderr);
-+}
-+
-+char *
-+make_argname(char *pname, char *vname)
-+{
-+ char *name;
-+
-+ name = malloc(strlen(pname) + strlen(vname) + strlen(ARGEXT) + 3);
-+ if (!name) {
-+ fprintf(stderr, "failed in malloc");
-+ exit(1);
-+ }
-+ sprintf(name, "%s_%s_%s", locase(pname), vname, ARGEXT);
-+ return(name);
-+}
-+
-+bas_type *typ_list_h;
-+bas_type *typ_list_t;
-+
-+void
-+add_type(int len, char *type)
-+{
-+ bas_type *ptr;
-+
-+
-+ if ((ptr = (bas_type *) malloc(sizeof(bas_type))) == (bas_type *) NULL) {
-+ fprintf(stderr, "failed in malloc");
-+ exit(1);
-+ }
-+ ptr->name = type;
-+ ptr->length = len;
-+ ptr->next = NULL;
-+ if (typ_list_t == NULL) {
-+
-+ typ_list_t = ptr;
-+ typ_list_h = ptr;
-+ } else {
-+
-+ typ_list_t->next = ptr;
-+ typ_list_t = ptr;
-+ }
-+}
-+
-+
-+bas_type *
-+find_type(char *type)
-+{
-+ bas_type *ptr;
-+
-+ ptr = typ_list_h;
-+
-+
-+ while (ptr != NULL) {
-+ if (strcmp(ptr->name, type) == 0)
-+ return (ptr);
-+ else
-+ ptr = ptr->next;
-+ };
-+ return (NULL);
-+}
-+
-diff --git a/rpcgen/rpc_util.h b/rpcgen/rpc_util.h
-new file mode 100644
-index 0000000..fa115be
---- /dev/null
-+++ b/rpcgen/rpc_util.h
-@@ -0,0 +1,166 @@
-+/*
-+ * Copyright (c) 2009, Sun Microsystems, Inc.
-+ * All rights reserved.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions are met:
-+ * - Redistributions of source code must retain the above copyright notice,
-+ * this list of conditions and the following disclaimer.
-+ * - Redistributions in binary form must reproduce the above copyright notice,
-+ * this list of conditions and the following disclaimer in the documentation
-+ * and/or other materials provided with the distribution.
-+ * - Neither the name of Sun Microsystems, Inc. nor the names of its
-+ * contributors may be used to endorse or promote products derived
-+ * from this software without specific prior written permission.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-+ * POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+/* @(#)rpc_util.h 1.5 90/08/29 (C) 1987 SMI */
-+
-+/*
-+ * rpc_util.h, Useful definitions for the RPC protocol compiler
-+ */
-+
-+#include <stdlib.h>
-+
-+#define alloc(size) malloc((unsigned)(size))
-+#define ALLOC(object) (object *) malloc(sizeof(object))
-+
-+#define s_print (void) sprintf
-+#define f_print (void) fprintf
-+
-+struct list {
-+ definition *val;
-+ struct list *next;
-+};
-+typedef struct list list;
-+
-+#define PUT 1
-+#define GET 2
-+
-+/*
-+ * Global variables
-+ */
-+#define MAXLINESIZE 1024
-+extern char curline[MAXLINESIZE];
-+extern char *where;
-+extern int linenum;
-+
-+extern char *infilename;
-+extern FILE *fout;
-+extern FILE *fin;
-+
-+extern list *defined;
-+
-+
-+extern bas_type *typ_list_h;
-+extern bas_type *typ_list_t;
-+
-+/*
-+ * All the option flags
-+ */
-+extern int inetdflag;
-+extern int pmflag;
-+extern int tblflag;
-+extern int logflag;
-+extern int newstyle;
-+extern int Cflag; /* C++ flag */
-+extern int tirpcflag; /* flag for generating tirpc code */
-+extern int Inline; /* if this is 0, then do not generate inline code */
-+
-+/*
-+ * Other flags related with inetd jumpstart.
-+ */
-+extern int indefinitewait;
-+extern int exitnow;
-+extern int timerflag;
-+
-+extern int nonfatalerrors;
-+
-+/*
-+ * rpc_util routines
-+ */
-+void storeval();
-+
-+#define STOREVAL(list,item) \
-+ storeval(list,item)
-+
-+definition *findval();
-+
-+#define FINDVAL(list,item,finder) \
-+ findval(list, item, finder)
-+
-+
-+/*
-+ * rpc_cout routines
-+ */
-+void cprint(void);
-+void emit(definition *);
-+
-+/*
-+ * rpc_hout routines
-+ */
-+void print_datadef(definition *);
-+void print_funcdef(definition *);
-+
-+/*
-+ * rpc_svcout routines
-+ */
-+void write_most(char *, int, int);
-+void write_register(void);
-+void write_netid_register(char *);
-+void write_nettype_register(char *);
-+void write_inetd_register(char *);
-+void write_rest(void);
-+void write_programs(char *);
-+void write_svc_aux(int);
-+
-+/*
-+ * rpc_clntout routines
-+ */
-+void write_stubs(void);
-+void printarglist(proc_list *, char *, char *);
-+
-+/*
-+ * rpc_tblout routines
-+ */
-+void write_tables(void);
-+
-+/*
-+ * rpc_util
-+ */
-+void pvname_svc(char *, char *);
-+void pvname(char *, char *);
-+void ptype(char *, char *, int);
-+char * make_argname(char *, char *);
-+void add_type(int, char *);
-+void reinitialize(void);
-+void crash(void);
-+void error(char *);
-+char *fixtype(char *);
-+char *stringfix(char *);
-+char *locase(char *);
-+int isvectordef(char *, relation);
-+int streq(char *, char *);
-+void tabify(FILE *, int);
-+void record_open(char *);
-+bas_type *find_type(char *type);
-+
-+/*
-+ * rpc_sample
-+ */
-+void write_sample_svc(definition *);
-+int write_sample_clnt(definition *);
-+void write_sample_clnt_main(void);
-+void add_sample_msg(void);
-diff --git a/rpcgen/rpcgen.1 b/rpcgen/rpcgen.1
-new file mode 100644
-index 0000000..89df7ed
---- /dev/null
-+++ b/rpcgen/rpcgen.1
-@@ -0,0 +1,521 @@
-+.\" @(#)rpcgen.1 1.35 93/06/02 SMI
-+.\" $FreeBSD: src/usr.bin/rpcgen/rpcgen.1,v 1.12.2.4 2002/06/21 15:28:50 charnier Exp $
-+.\" Copyright 1985-1993 Sun Microsystems, Inc.
-+.Dd March 28, 1993
-+.Dt RPCGEN 1
-+.Os
-+.Sh NAME
-+.Nm rpcgen
-+.Nd an RPC protocol compiler
-+.Sh SYNOPSIS
-+.Nm
-+.Ar infile
-+.Nm
-+.Op Fl a
-+.Op Fl b
-+.Op Fl C
-+.Oo
-+.Fl D Ns Ar name Ns Op Ar =value
-+.Oc
-+.Op Fl i Ar size
-+.Op Fl I Op Fl K Ar seconds
-+.Op Fl L
-+.Op Fl M
-+.Op Fl N
-+.Op Fl T
-+.Op Fl Y Ar pathname
-+.Ar infile
-+.Nm
-+.Oo
-+.Fl c |
-+.Fl h |
-+.Fl l |
-+.Fl m |
-+.Fl t |
-+.Fl \&Sc |
-+.Fl \&Ss |
-+.Fl \&Sm
-+.Oc
-+.Op Fl o Ar outfile
-+.Op Ar infile
-+.Nm
-+.Op Fl s Ar nettype
-+.Op Fl o Ar outfile
-+.Op Ar infile
-+.Nm
-+.Op Fl n Ar netid
-+.Op Fl o Ar outfile
-+.Op Ar infile
-+.\" .SH AVAILABILITY
-+.\" .LP
-+.\" SUNWcsu
-+.Sh DESCRIPTION
-+The
-+.Nm
-+utility is a tool that generates C code to implement an
-+.Tn RPC
-+protocol.
-+The input to
-+.Nm
-+is a language similar to C known as
-+.Tn RPC
-+Language (Remote Procedure Call Language).
-+.Pp
-+The
-+.Nm
-+utility is normally used as in the first synopsis where
-+it takes an input file and generates three output files.
-+If the
-+.Ar infile
-+is named
-+.Pa proto.x ,
-+then
-+.Nm
-+generates a header in
-+.Pa proto.h ,
-+XDR routines in
-+.Pa proto_xdr.c ,
-+server-side stubs in
-+.Pa proto_svc.c ,
-+and client-side stubs in
-+.Pa proto_clnt.c .
-+With the
-+.Fl T
-+option,
-+it also generates the
-+.Tn RPC
-+dispatch table in
-+.Pa proto_tbl.i .
-+.Pp
-+The
-+.Nm
-+utility can also generate sample client and server files
-+that can be customized to suit a particular application.
-+The
-+.Fl \&Sc ,
-+.Fl \&Ss
-+and
-+.Fl \&Sm
-+options generate sample client, server and makefile, respectively.
-+The
-+.Fl a
-+option generates all files, including sample files.
-+If the
-+.Ar infile
-+is
-+.Pa proto.x ,
-+then the client side sample file is written to
-+.Pa proto_client.c ,
-+the server side sample file to
-+.Pa proto_server.c
-+and the sample makefile to
-+.Pa makefile.proto .
-+.Pp
-+The server created can be started both by the port monitors
-+(for example,
-+.Xr inetd 8 )
-+or by itself.
-+When it is started by a port monitor,
-+it creates servers only for the transport for which
-+the file descriptor
-+.Em 0
-+was passed.
-+The name of the transport must be specified
-+by setting up the environment variable
-+.Ev PM_TRANSPORT .
-+When the server generated by
-+.Nm
-+is executed,
-+it creates server handles for all the transports
-+specified in
-+.Ev NETPATH
-+environment variable,
-+or if it is unset,
-+it creates server handles for all the visible transports from
-+.Pa /etc/netconfig
-+file.
-+Note:
-+the transports are chosen at run time and not at compile time.
-+When the server is self-started,
-+it backgrounds itself by default.
-+A special define symbol
-+.Em RPC_SVC_FG
-+can be used to run the server process in foreground.
-+.Pp
-+The second synopsis provides special features which allow
-+for the creation of more sophisticated
-+.Tn RPC
-+servers.
-+These features include support for user provided
-+.Em #defines
-+and
-+.Tn RPC
-+dispatch tables.
-+The entries in the
-+.Tn RPC
-+dispatch table contain:
-+.Bl -bullet -offset indent -compact
-+.It
-+pointers to the service routine corresponding to that procedure,
-+.It
-+a pointer to the input and output arguments,
-+.It
-+the size of these routines.
-+.El
-+A server can use the dispatch table to check authorization
-+and then to execute the service routine;
-+a client library may use it to deal with the details of storage
-+management and XDR data conversion.
-+.Pp
-+The other three synopses shown above are used when
-+one does not want to generate all the output files,
-+but only a particular one.
-+See the
-+.Sx EXAMPLES
-+section below for examples of
-+.Nm
-+usage.
-+When
-+.Nm
-+is executed with the
-+.Fl s
-+option,
-+it creates servers for that particular class of transports.
-+When
-+executed with the
-+.Fl n
-+option,
-+it creates a server for the transport specified by
-+.Ar netid .
-+If
-+.Ar infile
-+is not specified,
-+.Nm
-+accepts the standard input.
-+.Pp
-+The C preprocessor,
-+.Em cc -E
-+is run on the input file before it is actually interpreted by
-+.Nm .
-+For each type of output file,
-+.Nm
-+defines a special preprocessor symbol for use by the
-+.Nm
-+programmer:
-+.Bl -tag -width indent
-+.It RPC_HDR
-+defined when compiling into headers
-+.It RPC_XDR
-+defined when compiling into XDR routines
-+.It RPC_SVC
-+defined when compiling into server-side stubs
-+.It RPC_CLNT
-+defined when compiling into client-side stubs
-+.It RPC_TBL
-+defined when compiling into RPC dispatch tables
-+.El
-+.Pp
-+Any line beginning with
-+.Dq %
-+is passed directly into the output file,
-+uninterpreted by
-+.Nm .
-+To specify the path name of the C preprocessor use
-+.Fl Y
-+flag.
-+.Pp
-+For every data type referred to in
-+.Ar infile ,
-+.Nm
-+assumes that there exists a
-+routine with the string
-+.Em xdr_
-+prepended to the name of the data type.
-+If this routine does not exist in the
-+.Tn RPC/XDR
-+library, it must be provided.
-+Providing an undefined data type
-+allows customization of
-+.Xr xdr 3
-+routines.
-+.Sh OPTIONS
-+The following options are available:
-+.Bl -tag -width indent
-+.It Fl a
-+Generate all files, including sample files.
-+.It Fl b
-+Backward compatibility mode.
-+Generate transport specific
-+.Tn RPC
-+code for older versions
-+of the operating system.
-+.Pp
-+Note: in
-+.Fx ,
-+this compatibility flag is turned on by
-+default since
-+.Fx
-+supports only the older
-+.Tn ONC RPC
-+library.
-+.It Fl c
-+Compile into
-+.Tn XDR
-+routines.
-+.It Fl C
-+Generate header and stub files which can be used with
-+.Tn ANSI
-+C compilers. Headers generated with this flag can also be
-+used with C++ programs.
-+.It Fl D Ns Ar name
-+.It Fl D Ns Ar name=value
-+.\".It Fl D Ns Ar name Ns Op Ar =value
-+Define a symbol
-+.Ar name .
-+Equivalent to the
-+.Em #define
-+directive in the source.
-+If no
-+.Ar value
-+is given,
-+.Ar value
-+is defined as
-+.Em 1 .
-+This option may be specified more than once.
-+.It Fl h
-+Compile into C data-definitions (a header).
-+.Fl T
-+option can be used in conjunction to produce a
-+header which supports
-+.Tn RPC
-+dispatch tables.
-+.It Fl i Ar size
-+Size at which to start generating inline code.
-+This option is useful for optimization.
-+The default size is 5.
-+.Pp
-+Note: in order to provide backwards compatibility with the older
-+.Nm
-+on the
-+.Fx
-+platform, the default is actually 0 (which means
-+that inline code generation is disabled by default). You must specify
-+a non-zero value explicitly to override this default.
-+.It Fl I
-+Compile support for
-+.Xr inetd 8
-+in the server side stubs.
-+Such servers can be self-started or can be started by
-+.Nm inetd .
-+When the server is self-started, it backgrounds itself by default.
-+A special define symbol
-+.Em RPC_SVC_FG
-+can be used to run the
-+server process in foreground, or the user may simply compile without
-+the
-+.Fl I
-+option.
-+.Pp
-+If there are no pending client requests, the
-+.Nm inetd
-+servers exit after 120 seconds (default).
-+The default can be changed with the
-+.Fl K
-+option.
-+All the error messages for
-+.Nm inetd
-+servers
-+are always logged with
-+.Xr syslog 3 .
-+.\" .IP
-+.\" Note:
-+.\" this option is supported for backward compatibility only.
-+.\" By default,
-+.\" .B rpcgen
-+.\" generates servers that can be invoked through portmonitors.
-+.Pp
-+.It Fl K Ar seconds
-+By default, services created using
-+.Nm
-+and invoked through
-+port monitors wait 120 seconds
-+after servicing a request before exiting.
-+That interval can be changed using the
-+.Fl K
-+flag.
-+To create a server that exits immediately upon servicing a request,
-+use
-+.Fl K Ar 0 .
-+To create a server that never exits, the appropriate argument is
-+.Fl k Ar -1 .
-+.Pp
-+When monitoring for a server,
-+some portmonitors
-+.Em always
-+spawn a new process in response to a service request.
-+If it is known that a server will be used with such a monitor, the
-+server should exit immediately on completion.
-+For such servers,
-+.Nm
-+should be used with
-+.Fl K Ar 0 .
-+.It Fl l
-+Compile into client-side stubs.
-+.It Fl L
-+When the servers are started in foreground, use
-+.Xr syslog 3
-+to log the server errors instead of printing them on the standard
-+error.
-+.It Fl m
-+Compile into server-side stubs,
-+but do not generate a
-+.Qq main
-+routine.
-+This option is useful for doing callback-routines
-+and for users who need to write their own
-+.Qq main
-+routine to do initialization.
-+.It Fl M
-+Generate multithread-safe stubs for passing arguments and results between
-+rpcgen generated code and user written code.
-+This option is useful
-+for users who want to use threads in their code.
-+However, the
-+.Xr rpc_svc_calls 3
-+functions are not yet MT-safe, which means that rpcgen generated server-side
-+code will not be MT-safe.
-+.It Fl N
-+This option allows procedures to have multiple arguments.
-+It also uses the style of parameter passing that closely resembles C.
-+So, when passing an argument to a remote procedure, you do not have to
-+pass a pointer to the argument, but can pass the argument itself.
-+This behavior is different from the old style of
-+.Nm
-+generated code.
-+To maintain backward compatibility,
-+this option is not the default.
-+.It Fl n Ar netid
-+Compile into server-side stubs for the transport
-+specified by
-+.Ar netid .
-+There should be an entry for
-+.Ar netid
-+in the
-+netconfig database.
-+This option may be specified more than once,
-+so as to compile a server that serves multiple transports.
-+.It Fl o Ar outfile
-+Specify the name of the output file.
-+If none is specified,
-+standard output is used
-+(
-+.Fl c ,
-+.Fl h ,
-+.Fl l ,
-+.Fl m ,
-+.Fl n ,
-+.Fl s ,
-+.Fl \&Sc ,
-+.Fl \&Sm ,
-+.Fl \&Ss ,
-+and
-+.Fl t
-+modes only).
-+.It Fl s Ar nettype
-+Compile into server-side stubs for all the
-+transports belonging to the class
-+.Ar nettype .
-+The supported classes are
-+.Em netpath ,
-+.Em visible ,
-+.Em circuit_n ,
-+.Em circuit_v ,
-+.Em datagram_n ,
-+.Em datagram_v ,
-+.Em tcp ,
-+and
-+.Em udp
-+(see
-+.Xr rpc 3
-+for the meanings associated with these classes).
-+This option may be specified more than once.
-+Note:
-+the transports are chosen at run time and not at compile time.
-+.It Fl \&Sc
-+Generate sample client code that uses remote procedure calls.
-+.It Fl \&Sm
-+Generate a sample
-+.Pa Makefile
-+which can be used for compiling the application.
-+.It Fl \&Ss
-+Generate sample server code that uses remote procedure calls.
-+.It Fl t
-+Compile into
-+.Tn RPC
-+dispatch table.
-+.It Fl T
-+Generate the code to support
-+.Tn RPC
-+dispatch tables.
-+.Pp
-+The options
-+.Fl c ,
-+.Fl h ,
-+.Fl l ,
-+.Fl m ,
-+.Fl s ,
-+.Fl \&Sc ,
-+.Fl \&Sm ,
-+.Fl \&Ss ,
-+and
-+.Fl t
-+are used exclusively to generate a particular type of file,
-+while the options
-+.Fl D
-+and
-+.Fl T
-+are global and can be used with the other options.
-+.It Fl Y Ar pathname
-+Give the name of the directory where
-+.Nm
-+will start looking for the C-preprocessor.
-+.El
-+.Sh EXAMPLES
-+The following example:
-+.Dl example% rpcgen -T prot.x
-+.Pp
-+generates all the five files:
-+.Pa prot.h ,
-+.Pa prot_clnt.c ,
-+.Pa prot_svc.c ,
-+.Pa prot_xdr.c
-+and
-+.Pa prot_tbl.i .
-+.Pp
-+The following example sends the C data-definitions (header)
-+to the standard output.
-+.Dl example% rpcgen -h prot.x
-+.Pp
-+To send the test version of the
-+.Fl D Ns Ar TEST ,
-+server side stubs for
-+all the transport belonging to the class
-+.Ar datagram_n
-+to standard output, use:
-+.Dl example% rpcgen -s datagram_n -DTEST prot.x
-+.Pp
-+To create the server side stubs for the transport indicated
-+by
-+.Ar netid
-+tcp,
-+use:
-+.Dl example% rpcgen -n tcp -o prot_svc.c prot.x
-+.Sh SEE ALSO
-+.Xr cc 1 ,
-+.Xr rpc 3 ,
-+.Xr syslog 3 ,
-+.Xr inetd 8
-+.\" .BR rpc_svc_calls (3)
-+.Rs
-+.%T The rpcgen chapter in the NETP manual
-+.Re
---
-2.0.0
-
+++ /dev/null
-From 99ecb155efdfcf474c5701ab7e6ad1cbe88f500f Mon Sep 17 00:00:00 2001
-From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
-Date: Sat, 10 Nov 2012 17:29:53 +0100
-Subject: [PATCH] Automatically generate XDR header files from .x sources using
- rpcgen
-
-Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
----
- Makefile.am | 22 +-
- src/Makefile.am | 2 +-
- tirpc/rpc/rpcb_prot.h | 797 --------------------------------------------------
- tirpc/rpcsvc/crypt.h | 109 -------
- 4 files changed, 20 insertions(+), 910 deletions(-)
- delete mode 100644 tirpc/rpc/rpcb_prot.h
- delete mode 100644 tirpc/rpcsvc/crypt.h
-
-diff --git a/Makefile.am b/Makefile.am
-index 6edf029..4e4dc32 100644
---- a/Makefile.am
-+++ b/Makefile.am
-@@ -1,6 +1,10 @@
- SUBDIRS = src man doc rpcgen
- ACLOCAL_AMFLAGS = -I m4
-
-+GENFILES = \
-+ tirpc/rpcsvc/crypt.h \
-+ tirpc/rpc/rpcb_prot.h
-+
- noinst_HEADERS = tirpc/reentrant.h \
- tirpc/getpeereid.h \
- tirpc/libc_private.h \
-@@ -8,7 +12,6 @@ noinst_HEADERS = tirpc/reentrant.h \
-
- nobase_include_HEADERS = tirpc/netconfig.h \
- tirpc/rpcsvc/crypt.x \
-- tirpc/rpcsvc/crypt.h \
- tirpc/rpc/xdr.h \
- tirpc/rpc/types.h \
- tirpc/rpc/svc_soc.h \
-@@ -20,7 +23,6 @@ nobase_include_HEADERS = tirpc/netconfig.h \
- tirpc/rpc/rpcent.h \
- tirpc/rpc/rpc_com.h \
- tirpc/rpc/rpcb_prot.x \
-- tirpc/rpc/rpcb_prot.h \
- tirpc/rpc/rpcb_clnt.h \
- tirpc/rpc/raw.h \
- tirpc/rpc/pmap_rmt.h \
-@@ -37,7 +39,21 @@ nobase_include_HEADERS = tirpc/netconfig.h \
- tirpc/rpc/auth.h \
- tirpc/rpc/auth_gss.h \
- tirpc/rpc/auth_des.h
--
-+
-+nobase_nodist_include_HEADERS = $(GENFILES)
-+BUILT_SOURCES = $(GENFILES)
-+
-+$(GENFILES): %.h: %.x $(top_builddir)/rpcgen/rpcgen
-+ mkdir -p $(dir $@)
-+ $(top_builddir)/rpcgen/rpcgen -h -o $@ $<
-+
-+$(top_builddir)/rpcgen/rpcgen: force
-+ cd rpcgen && $(MAKE)
-+
-+force:
-+
-+CLEANFILES = $(GENFILES)
-+
- pkgconfigdir=$(libdir)/pkgconfig
- pkgconfig_DATA = libtirpc.pc
-
-diff --git a/src/Makefile.am b/src/Makefile.am
-index f086255..a9db71b 100644
---- a/src/Makefile.am
-+++ b/src/Makefile.am
-@@ -8,7 +8,7 @@
- noinst_HEADERS = rpc_com.h
-
- AM_CPPFLAGS = -I$(top_srcdir)/tirpc -DPORTMAP \
-- -D_GNU_SOURCE -Wall -pipe
-+ -D_GNU_SOURCE -Wall -pipe -I$(top_builddir)/tirpc
-
- lib_LTLIBRARIES = libtirpc.la
-
-diff --git a/tirpc/rpc/rpcb_prot.h b/tirpc/rpc/rpcb_prot.h
-deleted file mode 100644
-index 7ae48b8..0000000
---- a/tirpc/rpc/rpcb_prot.h
-+++ /dev/null
-@@ -1,797 +0,0 @@
--/*
-- * Please do not edit this file.
-- * It was generated using rpcgen.
-- */
--
--#ifndef _RPCB_PROT_H_RPCGEN
--#define _RPCB_PROT_H_RPCGEN
--
--#include <rpc/rpc.h>
--
--#ifndef IXDR_GET_INT32
--#define IXDR_GET_INT32(buf) IXDR_GET_LONG((buf))
--#endif
--#ifndef IXDR_PUT_INT32
--#define IXDR_PUT_INT32(buf, v) IXDR_PUT_LONG((buf), (v))
--#endif
--#ifndef IXDR_GET_U_INT32
--#define IXDR_GET_U_INT32(buf) IXDR_GET_U_LONG((buf))
--#endif
--#ifndef IXDR_PUT_U_INT32
--#define IXDR_PUT_U_INT32(buf, v) IXDR_PUT_U_LONG((buf), (v))
--#endif
--/*
-- * $FreeBSD: src/include/rpc/rpcb_prot.x,v 1.3 2002/03/13 10:29:06 obrien Exp $
-- *
-- * Copyright (c) 2009, Sun Microsystems, Inc.
-- * All rights reserved.
-- *
-- * Redistribution and use in source and binary forms, with or without
-- * modification, are permitted provided that the following conditions are met:
-- * - Redistributions of source code must retain the above copyright notice,
-- * this list of conditions and the following disclaimer.
-- * - Redistributions in binary form must reproduce the above copyright notice,
-- * this list of conditions and the following disclaimer in the documentation
-- * and/or other materials provided with the distribution.
-- * - Neither the name of Sun Microsystems, Inc. nor the names of its
-- * contributors may be used to endorse or promote products derived
-- * from this software without specific prior written permission.
-- *
-- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-- * POSSIBILITY OF SUCH DAMAGE.
-- */
--/*
-- * Copyright (c) 1988 by Sun Microsystems, Inc.
-- */
--/* from rpcb_prot.x */
--
--/* #pragma ident "@(#)rpcb_prot.x 1.5 94/04/29 SMI" */
--
--#ifndef _KERNEL
--
--
--/*
-- * The following procedures are supported by the protocol in version 3:
-- *
-- * RPCBPROC_NULL() returns ()
-- * takes nothing, returns nothing
-- *
-- * RPCBPROC_SET(rpcb) returns (bool_t)
-- * TRUE is success, FALSE is failure. Registers the tuple
-- * [prog, vers, address, owner, netid].
-- * Finds out owner and netid information on its own.
-- *
-- * RPCBPROC_UNSET(rpcb) returns (bool_t)
-- * TRUE is success, FALSE is failure. Un-registers tuple
-- * [prog, vers, netid]. addresses is ignored.
-- * If netid is NULL, unregister all.
-- *
-- * RPCBPROC_GETADDR(rpcb) returns (string).
-- * 0 is failure. Otherwise returns the universal address where the
-- * triple [prog, vers, netid] is registered. Ignore address and owner.
-- *
-- * RPCBPROC_DUMP() RETURNS (rpcblist_ptr)
-- * used to dump the entire rpcbind maps
-- *
-- * RPCBPROC_CALLIT(rpcb_rmtcallargs)
-- * RETURNS (rpcb_rmtcallres);
-- * Calls the procedure on the remote machine. If it is not registered,
-- * this procedure is quiet; i.e. it does not return error information!!!
-- * This routine only passes null authentication parameters.
-- * It has no interface to xdr routines for RPCBPROC_CALLIT.
-- *
-- * RPCBPROC_GETTIME() returns (int).
-- * Gets the remote machines time
-- *
-- * RPCBPROC_UADDR2TADDR(strint) RETURNS (struct netbuf)
-- * Returns the netbuf address from universal address.
-- *
-- * RPCBPROC_TADDR2UADDR(struct netbuf) RETURNS (string)
-- * Returns the universal address from netbuf address.
-- *
-- * END OF RPCBIND VERSION 3 PROCEDURES
-- */
--/*
-- * Except for RPCBPROC_CALLIT, the procedures above are carried over to
-- * rpcbind version 4. Those below are added or modified for version 4.
-- * NOTE: RPCBPROC_BCAST HAS THE SAME FUNCTIONALITY AND PROCEDURE NUMBER
-- * AS RPCBPROC_CALLIT.
-- *
-- * RPCBPROC_BCAST(rpcb_rmtcallargs)
-- * RETURNS (rpcb_rmtcallres);
-- * Calls the procedure on the remote machine. If it is not registered,
-- * this procedure IS quiet; i.e. it DOES NOT return error information!!!
-- * This routine should be used for broadcasting and nothing else.
-- *
-- * RPCBPROC_GETVERSADDR(rpcb) returns (string).
-- * 0 is failure. Otherwise returns the universal address where the
-- * triple [prog, vers, netid] is registered. Ignore address and owner.
-- * Same as RPCBPROC_GETADDR except that if the given version number
-- * is not available, the address is not returned.
-- *
-- * RPCBPROC_INDIRECT(rpcb_rmtcallargs)
-- * RETURNS (rpcb_rmtcallres);
-- * Calls the procedure on the remote machine. If it is not registered,
-- * this procedure is NOT quiet; i.e. it DOES return error information!!!
-- * as any normal application would expect.
-- *
-- * RPCBPROC_GETADDRLIST(rpcb) returns (rpcb_entry_list_ptr).
-- * Same as RPCBPROC_GETADDR except that it returns a list of all the
-- * addresses registered for the combination (prog, vers) (for all
-- * transports).
-- *
-- * RPCBPROC_GETSTAT(void) returns (rpcb_stat_byvers)
-- * Returns the statistics about the kind of requests received by rpcbind.
-- */
--
--/*
-- * A mapping of (program, version, network ID) to address
-- */
--
--struct rpcb {
-- rpcprog_t r_prog;
-- rpcvers_t r_vers;
-- char *r_netid;
-- char *r_addr;
-- char *r_owner;
--};
--typedef struct rpcb rpcb;
--#ifdef __cplusplus
--extern "C" bool_t xdr_rpcb(XDR *, rpcb*);
--#elif __STDC__
--extern bool_t xdr_rpcb(XDR *, rpcb*);
--#else /* Old Style C */
--bool_t xdr_rpcb();
--#endif /* Old Style C */
--
--
--typedef rpcb RPCB;
--
--
--/*
-- * A list of mappings
-- *
-- * Below are two definitions for the rpcblist structure. This is done because
-- * xdr_rpcblist() is specified to take a struct rpcblist **, rather than a
-- * struct rpcblist * that rpcgen would produce. One version of the rpcblist
-- * structure (actually called rp__list) is used with rpcgen, and the other is
-- * defined only in the header file for compatibility with the specified
-- * interface.
-- */
--
--struct rp__list {
-- rpcb rpcb_map;
-- struct rp__list *rpcb_next;
--};
--typedef struct rp__list rp__list;
--#ifdef __cplusplus
--extern "C" bool_t xdr_rp__list(XDR *, rp__list*);
--#elif __STDC__
--extern bool_t xdr_rp__list(XDR *, rp__list*);
--#else /* Old Style C */
--bool_t xdr_rp__list();
--#endif /* Old Style C */
--
--
--typedef rp__list *rpcblist_ptr;
--#ifdef __cplusplus
--extern "C" bool_t xdr_rpcblist_ptr(XDR *, rpcblist_ptr*);
--#elif __STDC__
--extern bool_t xdr_rpcblist_ptr(XDR *, rpcblist_ptr*);
--#else /* Old Style C */
--bool_t xdr_rpcblist_ptr();
--#endif /* Old Style C */
--
--
--typedef struct rp__list rpcblist;
--typedef struct rp__list RPCBLIST;
--
--#ifndef __cplusplus
--struct rpcblist {
-- RPCB rpcb_map;
-- struct rpcblist *rpcb_next;
--};
--#endif
--
--#ifdef __cplusplus
--extern "C" {
--#endif
--extern bool_t xdr_rpcblist(XDR *, rpcblist**);
--#ifdef __cplusplus
--}
--#endif
--
--
--/*
-- * Arguments of remote calls
-- */
--
--struct rpcb_rmtcallargs {
-- rpcprog_t prog;
-- rpcvers_t vers;
-- rpcproc_t proc;
-- struct {
-- u_int args_len;
-- char *args_val;
-- } args;
--};
--typedef struct rpcb_rmtcallargs rpcb_rmtcallargs;
--#ifdef __cplusplus
--extern "C" bool_t xdr_rpcb_rmtcallargs(XDR *, rpcb_rmtcallargs*);
--#elif __STDC__
--extern bool_t xdr_rpcb_rmtcallargs(XDR *, rpcb_rmtcallargs*);
--#else /* Old Style C */
--bool_t xdr_rpcb_rmtcallargs();
--#endif /* Old Style C */
--
--
--/*
-- * Client-side only representation of rpcb_rmtcallargs structure.
-- *
-- * The routine that XDRs the rpcb_rmtcallargs structure must deal with the
-- * opaque arguments in the "args" structure. xdr_rpcb_rmtcallargs() needs to
-- * be passed the XDR routine that knows the args' structure. This routine
-- * doesn't need to go over-the-wire (and it wouldn't make sense anyway) since
-- * the application being called already knows the args structure. So we use a
-- * different "XDR" structure on the client side, r_rpcb_rmtcallargs, which
-- * includes the args' XDR routine.
-- */
--struct r_rpcb_rmtcallargs {
-- rpcprog_t prog;
-- rpcvers_t vers;
-- rpcproc_t proc;
-- struct {
-- u_int args_len;
-- char *args_val;
-- } args;
-- xdrproc_t xdr_args; /* encodes args */
--};
--
--
--/*
-- * Results of the remote call
-- */
--
--struct rpcb_rmtcallres {
-- char *addr;
-- struct {
-- u_int results_len;
-- char *results_val;
-- } results;
--};
--typedef struct rpcb_rmtcallres rpcb_rmtcallres;
--#ifdef __cplusplus
--extern "C" bool_t xdr_rpcb_rmtcallres(XDR *, rpcb_rmtcallres*);
--#elif __STDC__
--extern bool_t xdr_rpcb_rmtcallres(XDR *, rpcb_rmtcallres*);
--#else /* Old Style C */
--bool_t xdr_rpcb_rmtcallres();
--#endif /* Old Style C */
--
--
--/*
-- * Client-side only representation of rpcb_rmtcallres structure.
-- */
--struct r_rpcb_rmtcallres {
-- char *addr;
-- struct {
-- u_int32_t results_len;
-- char *results_val;
-- } results;
-- xdrproc_t xdr_res; /* decodes results */
--};
--
--/*
-- * rpcb_entry contains a merged address of a service on a particular
-- * transport, plus associated netconfig information. A list of rpcb_entrys
-- * is returned by RPCBPROC_GETADDRLIST. See netconfig.h for values used
-- * in r_nc_* fields.
-- */
--
--struct rpcb_entry {
-- char *r_maddr;
-- char *r_nc_netid;
-- u_int r_nc_semantics;
-- char *r_nc_protofmly;
-- char *r_nc_proto;
--};
--typedef struct rpcb_entry rpcb_entry;
--#ifdef __cplusplus
--extern "C" bool_t xdr_rpcb_entry(XDR *, rpcb_entry*);
--#elif __STDC__
--extern bool_t xdr_rpcb_entry(XDR *, rpcb_entry*);
--#else /* Old Style C */
--bool_t xdr_rpcb_entry();
--#endif /* Old Style C */
--
--
--/*
-- * A list of addresses supported by a service.
-- */
--
--struct rpcb_entry_list {
-- rpcb_entry rpcb_entry_map;
-- struct rpcb_entry_list *rpcb_entry_next;
--};
--typedef struct rpcb_entry_list rpcb_entry_list;
--#ifdef __cplusplus
--extern "C" bool_t xdr_rpcb_entry_list(XDR *, rpcb_entry_list*);
--#elif __STDC__
--extern bool_t xdr_rpcb_entry_list(XDR *, rpcb_entry_list*);
--#else /* Old Style C */
--bool_t xdr_rpcb_entry_list();
--#endif /* Old Style C */
--
--
--typedef rpcb_entry_list *rpcb_entry_list_ptr;
--#ifdef __cplusplus
--extern "C" bool_t xdr_rpcb_entry_list_ptr(XDR *, rpcb_entry_list_ptr*);
--#elif __STDC__
--extern bool_t xdr_rpcb_entry_list_ptr(XDR *, rpcb_entry_list_ptr*);
--#else /* Old Style C */
--bool_t xdr_rpcb_entry_list_ptr();
--#endif /* Old Style C */
--
--
--/*
-- * rpcbind statistics
-- */
--
--#define rpcb_highproc_2 RPCBPROC_CALLIT
--#define rpcb_highproc_3 RPCBPROC_TADDR2UADDR
--#define rpcb_highproc_4 RPCBPROC_GETSTAT
--#define RPCBSTAT_HIGHPROC 13
--#define RPCBVERS_STAT 3
--#define RPCBVERS_4_STAT 2
--#define RPCBVERS_3_STAT 1
--#define RPCBVERS_2_STAT 0
--
--/* Link list of all the stats about getport and getaddr */
--
--struct rpcbs_addrlist {
-- rpcprog_t prog;
-- rpcvers_t vers;
-- int success;
-- int failure;
-- char *netid;
-- struct rpcbs_addrlist *next;
--};
--typedef struct rpcbs_addrlist rpcbs_addrlist;
--#ifdef __cplusplus
--extern "C" bool_t xdr_rpcbs_addrlist(XDR *, rpcbs_addrlist*);
--#elif __STDC__
--extern bool_t xdr_rpcbs_addrlist(XDR *, rpcbs_addrlist*);
--#else /* Old Style C */
--bool_t xdr_rpcbs_addrlist();
--#endif /* Old Style C */
--
--
--/* Link list of all the stats about rmtcall */
--
--struct rpcbs_rmtcalllist {
-- rpcprog_t prog;
-- rpcvers_t vers;
-- rpcproc_t proc;
-- int success;
-- int failure;
-- int indirect;
-- char *netid;
-- struct rpcbs_rmtcalllist *next;
--};
--typedef struct rpcbs_rmtcalllist rpcbs_rmtcalllist;
--#ifdef __cplusplus
--extern "C" bool_t xdr_rpcbs_rmtcalllist(XDR *, rpcbs_rmtcalllist*);
--#elif __STDC__
--extern bool_t xdr_rpcbs_rmtcalllist(XDR *, rpcbs_rmtcalllist*);
--#else /* Old Style C */
--bool_t xdr_rpcbs_rmtcalllist();
--#endif /* Old Style C */
--
--
--typedef int rpcbs_proc[RPCBSTAT_HIGHPROC];
--#ifdef __cplusplus
--extern "C" bool_t xdr_rpcbs_proc(XDR *, rpcbs_proc);
--#elif __STDC__
--extern bool_t xdr_rpcbs_proc(XDR *, rpcbs_proc);
--#else /* Old Style C */
--bool_t xdr_rpcbs_proc();
--#endif /* Old Style C */
--
--
--typedef rpcbs_addrlist *rpcbs_addrlist_ptr;
--#ifdef __cplusplus
--extern "C" bool_t xdr_rpcbs_addrlist_ptr(XDR *, rpcbs_addrlist_ptr*);
--#elif __STDC__
--extern bool_t xdr_rpcbs_addrlist_ptr(XDR *, rpcbs_addrlist_ptr*);
--#else /* Old Style C */
--bool_t xdr_rpcbs_addrlist_ptr();
--#endif /* Old Style C */
--
--
--typedef rpcbs_rmtcalllist *rpcbs_rmtcalllist_ptr;
--#ifdef __cplusplus
--extern "C" bool_t xdr_rpcbs_rmtcalllist_ptr(XDR *, rpcbs_rmtcalllist_ptr*);
--#elif __STDC__
--extern bool_t xdr_rpcbs_rmtcalllist_ptr(XDR *, rpcbs_rmtcalllist_ptr*);
--#else /* Old Style C */
--bool_t xdr_rpcbs_rmtcalllist_ptr();
--#endif /* Old Style C */
--
--
--struct rpcb_stat {
-- rpcbs_proc info;
-- int setinfo;
-- int unsetinfo;
-- rpcbs_addrlist_ptr addrinfo;
-- rpcbs_rmtcalllist_ptr rmtinfo;
--};
--typedef struct rpcb_stat rpcb_stat;
--#ifdef __cplusplus
--extern "C" bool_t xdr_rpcb_stat(XDR *, rpcb_stat*);
--#elif __STDC__
--extern bool_t xdr_rpcb_stat(XDR *, rpcb_stat*);
--#else /* Old Style C */
--bool_t xdr_rpcb_stat();
--#endif /* Old Style C */
--
--
--/*
-- * One rpcb_stat structure is returned for each version of rpcbind
-- * being monitored.
-- */
--
--typedef rpcb_stat rpcb_stat_byvers[RPCBVERS_STAT];
--#ifdef __cplusplus
--extern "C" bool_t xdr_rpcb_stat_byvers(XDR *, rpcb_stat_byvers);
--#elif __STDC__
--extern bool_t xdr_rpcb_stat_byvers(XDR *, rpcb_stat_byvers);
--#else /* Old Style C */
--bool_t xdr_rpcb_stat_byvers();
--#endif /* Old Style C */
--
--
--/*
-- * We don't define netbuf in RPCL, since it would contain structure member
-- * names that would conflict with the definition of struct netbuf in
-- * <tiuser.h>. Instead we merely declare the XDR routine xdr_netbuf() here,
-- * and implement it ourselves in rpc/rpcb_prot.c.
-- */
--#ifdef __cplusplus
--extern "C" bool_t xdr_netbuf(XDR *, struct netbuf *);
--
--#else /* __STDC__ */
--extern bool_t xdr_netbuf(XDR *, struct netbuf *);
--
--#endif
--
--#define RPCBVERS_3 RPCBVERS
--#define RPCBVERS_4 RPCBVERS4
--
--#define _PATH_RPCBINDSOCK "/var/run/rpcbind.sock"
--
--#else /* ndef _KERNEL */
--#ifdef __cplusplus
--extern "C" {
--#endif
--
--/*
-- * A mapping of (program, version, network ID) to address
-- */
--struct rpcb {
-- rpcprog_t r_prog; /* program number */
-- rpcvers_t r_vers; /* version number */
-- char *r_netid; /* network id */
-- char *r_addr; /* universal address */
-- char *r_owner; /* owner of the mapping */
--};
--typedef struct rpcb RPCB;
--
--/*
-- * A list of mappings
-- */
--struct rpcblist {
-- RPCB rpcb_map;
-- struct rpcblist *rpcb_next;
--};
--typedef struct rpcblist RPCBLIST;
--typedef struct rpcblist *rpcblist_ptr;
--
--/*
-- * Remote calls arguments
-- */
--struct rpcb_rmtcallargs {
-- rpcprog_t prog; /* program number */
-- rpcvers_t vers; /* version number */
-- rpcproc_t proc; /* procedure number */
-- u_int32_t arglen; /* arg len */
-- caddr_t args_ptr; /* argument */
-- xdrproc_t xdr_args; /* XDR routine for argument */
--};
--typedef struct rpcb_rmtcallargs rpcb_rmtcallargs;
--
--/*
-- * Remote calls results
-- */
--struct rpcb_rmtcallres {
-- char *addr_ptr; /* remote universal address */
-- u_int32_t resultslen; /* results length */
-- caddr_t results_ptr; /* results */
-- xdrproc_t xdr_results; /* XDR routine for result */
--};
--typedef struct rpcb_rmtcallres rpcb_rmtcallres;
--
--struct rpcb_entry {
-- char *r_maddr;
-- char *r_nc_netid;
-- unsigned int r_nc_semantics;
-- char *r_nc_protofmly;
-- char *r_nc_proto;
--};
--typedef struct rpcb_entry rpcb_entry;
--
--/*
-- * A list of addresses supported by a service.
-- */
--
--struct rpcb_entry_list {
-- rpcb_entry rpcb_entry_map;
-- struct rpcb_entry_list *rpcb_entry_next;
--};
--typedef struct rpcb_entry_list rpcb_entry_list;
--
--typedef rpcb_entry_list *rpcb_entry_list_ptr;
--
--/*
-- * rpcbind statistics
-- */
--
--#define rpcb_highproc_2 RPCBPROC_CALLIT
--#define rpcb_highproc_3 RPCBPROC_TADDR2UADDR
--#define rpcb_highproc_4 RPCBPROC_GETSTAT
--#define RPCBSTAT_HIGHPROC 13
--#define RPCBVERS_STAT 3
--#define RPCBVERS_4_STAT 2
--#define RPCBVERS_3_STAT 1
--#define RPCBVERS_2_STAT 0
--
--/* Link list of all the stats about getport and getaddr */
--
--struct rpcbs_addrlist {
-- rpcprog_t prog;
-- rpcvers_t vers;
-- int success;
-- int failure;
-- char *netid;
-- struct rpcbs_addrlist *next;
--};
--typedef struct rpcbs_addrlist rpcbs_addrlist;
--
--/* Link list of all the stats about rmtcall */
--
--struct rpcbs_rmtcalllist {
-- rpcprog_t prog;
-- rpcvers_t vers;
-- rpcproc_t proc;
-- int success;
-- int failure;
-- int indirect;
-- char *netid;
-- struct rpcbs_rmtcalllist *next;
--};
--typedef struct rpcbs_rmtcalllist rpcbs_rmtcalllist;
--
--typedef int rpcbs_proc[RPCBSTAT_HIGHPROC];
--
--typedef rpcbs_addrlist *rpcbs_addrlist_ptr;
--
--typedef rpcbs_rmtcalllist *rpcbs_rmtcalllist_ptr;
--
--struct rpcb_stat {
-- rpcbs_proc info;
-- int setinfo;
-- int unsetinfo;
-- rpcbs_addrlist_ptr addrinfo;
-- rpcbs_rmtcalllist_ptr rmtinfo;
--};
--typedef struct rpcb_stat rpcb_stat;
--
--/*
-- * One rpcb_stat structure is returned for each version of rpcbind
-- * being monitored.
-- */
--
--typedef rpcb_stat rpcb_stat_byvers[RPCBVERS_STAT];
--
--#ifdef __cplusplus
--}
--#endif
--
--#endif /* ndef _KERNEL */
--
--#define RPCBPROG ((u_int32_t)100000)
--#define RPCBVERS ((u_int32_t)3)
--
--#ifdef __cplusplus
--#define RPCBPROC_SET ((u_int32_t)1)
--extern "C" bool_t * rpcbproc_set_3(rpcb *, CLIENT *);
--extern "C" bool_t * rpcbproc_set_3_svc(rpcb *, struct svc_req *);
--#define RPCBPROC_UNSET ((u_int32_t)2)
--extern "C" bool_t * rpcbproc_unset_3(rpcb *, CLIENT *);
--extern "C" bool_t * rpcbproc_unset_3_svc(rpcb *, struct svc_req *);
--#define RPCBPROC_GETADDR ((u_int32_t)3)
--extern "C" char ** rpcbproc_getaddr_3(rpcb *, CLIENT *);
--extern "C" char ** rpcbproc_getaddr_3_svc(rpcb *, struct svc_req *);
--#define RPCBPROC_DUMP ((u_int32_t)4)
--extern "C" rpcblist_ptr * rpcbproc_dump_3(void *, CLIENT *);
--extern "C" rpcblist_ptr * rpcbproc_dump_3_svc(void *, struct svc_req *);
--#define RPCBPROC_CALLIT ((u_int32_t)5)
--extern "C" rpcb_rmtcallres * rpcbproc_callit_3(rpcb_rmtcallargs *, CLIENT *);
--extern "C" rpcb_rmtcallres * rpcbproc_callit_3_svc(rpcb_rmtcallargs *, struct svc_req *);
--#define RPCBPROC_GETTIME ((u_int32_t)6)
--extern "C" u_int * rpcbproc_gettime_3(void *, CLIENT *);
--extern "C" u_int * rpcbproc_gettime_3_svc(void *, struct svc_req *);
--#define RPCBPROC_UADDR2TADDR ((u_int32_t)7)
--extern "C" struct netbuf * rpcbproc_uaddr2taddr_3(char **, CLIENT *);
--extern "C" struct netbuf * rpcbproc_uaddr2taddr_3_svc(char **, struct svc_req *);
--#define RPCBPROC_TADDR2UADDR ((u_int32_t)8)
--extern "C" char ** rpcbproc_taddr2uaddr_3(struct netbuf *, CLIENT *);
--extern "C" char ** rpcbproc_taddr2uaddr_3_svc(struct netbuf *, struct svc_req *);
--
--#elif __STDC__
--#define RPCBPROC_SET ((u_int32_t)1)
--extern bool_t * rpcbproc_set_3(rpcb *, CLIENT *);
--extern bool_t * rpcbproc_set_3_svc(rpcb *, struct svc_req *);
--#define RPCBPROC_UNSET ((u_int32_t)2)
--extern bool_t * rpcbproc_unset_3(rpcb *, CLIENT *);
--extern bool_t * rpcbproc_unset_3_svc(rpcb *, struct svc_req *);
--#define RPCBPROC_GETADDR ((u_int32_t)3)
--extern char ** rpcbproc_getaddr_3(rpcb *, CLIENT *);
--extern char ** rpcbproc_getaddr_3_svc(rpcb *, struct svc_req *);
--#define RPCBPROC_DUMP ((u_int32_t)4)
--extern rpcblist_ptr * rpcbproc_dump_3(void *, CLIENT *);
--extern rpcblist_ptr * rpcbproc_dump_3_svc(void *, struct svc_req *);
--#define RPCBPROC_CALLIT ((u_int32_t)5)
--extern rpcb_rmtcallres * rpcbproc_callit_3(rpcb_rmtcallargs *, CLIENT *);
--extern rpcb_rmtcallres * rpcbproc_callit_3_svc(rpcb_rmtcallargs *, struct svc_req *);
--#define RPCBPROC_GETTIME ((u_int32_t)6)
--extern u_int * rpcbproc_gettime_3(void *, CLIENT *);
--extern u_int * rpcbproc_gettime_3_svc(void *, struct svc_req *);
--#define RPCBPROC_UADDR2TADDR ((u_int32_t)7)
--extern struct netbuf * rpcbproc_uaddr2taddr_3(char **, CLIENT *);
--extern struct netbuf * rpcbproc_uaddr2taddr_3_svc(char **, struct svc_req *);
--#define RPCBPROC_TADDR2UADDR ((u_int32_t)8)
--extern char ** rpcbproc_taddr2uaddr_3(struct netbuf *, CLIENT *);
--extern char ** rpcbproc_taddr2uaddr_3_svc(struct netbuf *, struct svc_req *);
--
--#else /* Old Style C */
--#define RPCBPROC_SET ((u_int32_t)1)
--extern bool_t * rpcbproc_set_3();
--extern bool_t * rpcbproc_set_3_svc();
--#define RPCBPROC_UNSET ((u_int32_t)2)
--extern bool_t * rpcbproc_unset_3();
--extern bool_t * rpcbproc_unset_3_svc();
--#define RPCBPROC_GETADDR ((u_int32_t)3)
--extern char ** rpcbproc_getaddr_3();
--extern char ** rpcbproc_getaddr_3_svc();
--#define RPCBPROC_DUMP ((u_int32_t)4)
--extern rpcblist_ptr * rpcbproc_dump_3();
--extern rpcblist_ptr * rpcbproc_dump_3_svc();
--#define RPCBPROC_CALLIT ((u_int32_t)5)
--extern rpcb_rmtcallres * rpcbproc_callit_3();
--extern rpcb_rmtcallres * rpcbproc_callit_3_svc();
--#define RPCBPROC_GETTIME ((u_int32_t)6)
--extern u_int * rpcbproc_gettime_3();
--extern u_int * rpcbproc_gettime_3_svc();
--#define RPCBPROC_UADDR2TADDR ((u_int32_t)7)
--extern struct netbuf * rpcbproc_uaddr2taddr_3();
--extern struct netbuf * rpcbproc_uaddr2taddr_3_svc();
--#define RPCBPROC_TADDR2UADDR ((u_int32_t)8)
--extern char ** rpcbproc_taddr2uaddr_3();
--extern char ** rpcbproc_taddr2uaddr_3_svc();
--#endif /* Old Style C */
--#define RPCBVERS4 ((u_int32_t)4)
--
--#ifdef __cplusplus
--extern "C" bool_t * rpcbproc_set_4(rpcb *, CLIENT *);
--extern "C" bool_t * rpcbproc_set_4_svc(rpcb *, struct svc_req *);
--extern "C" bool_t * rpcbproc_unset_4(rpcb *, CLIENT *);
--extern "C" bool_t * rpcbproc_unset_4_svc(rpcb *, struct svc_req *);
--extern "C" char ** rpcbproc_getaddr_4(rpcb *, CLIENT *);
--extern "C" char ** rpcbproc_getaddr_4_svc(rpcb *, struct svc_req *);
--extern "C" rpcblist_ptr * rpcbproc_dump_4(void *, CLIENT *);
--extern "C" rpcblist_ptr * rpcbproc_dump_4_svc(void *, struct svc_req *);
--#define RPCBPROC_BCAST ((u_int32_t)RPCBPROC_CALLIT)
--extern "C" rpcb_rmtcallres * rpcbproc_bcast_4(rpcb_rmtcallargs *, CLIENT *);
--extern "C" rpcb_rmtcallres * rpcbproc_bcast_4_svc(rpcb_rmtcallargs *, struct svc_req *);
--extern "C" u_int * rpcbproc_gettime_4(void *, CLIENT *);
--extern "C" u_int * rpcbproc_gettime_4_svc(void *, struct svc_req *);
--extern "C" struct netbuf * rpcbproc_uaddr2taddr_4(char **, CLIENT *);
--extern "C" struct netbuf * rpcbproc_uaddr2taddr_4_svc(char **, struct svc_req *);
--extern "C" char ** rpcbproc_taddr2uaddr_4(struct netbuf *, CLIENT *);
--extern "C" char ** rpcbproc_taddr2uaddr_4_svc(struct netbuf *, struct svc_req *);
--#define RPCBPROC_GETVERSADDR ((u_int32_t)9)
--extern "C" char ** rpcbproc_getversaddr_4(rpcb *, CLIENT *);
--extern "C" char ** rpcbproc_getversaddr_4_svc(rpcb *, struct svc_req *);
--#define RPCBPROC_INDIRECT ((u_int32_t)10)
--extern "C" rpcb_rmtcallres * rpcbproc_indirect_4(rpcb_rmtcallargs *, CLIENT *);
--extern "C" rpcb_rmtcallres * rpcbproc_indirect_4_svc(rpcb_rmtcallargs *, struct svc_req *);
--#define RPCBPROC_GETADDRLIST ((u_int32_t)11)
--extern "C" rpcb_entry_list_ptr * rpcbproc_getaddrlist_4(rpcb *, CLIENT *);
--extern "C" rpcb_entry_list_ptr * rpcbproc_getaddrlist_4_svc(rpcb *, struct svc_req *);
--#define RPCBPROC_GETSTAT ((u_int32_t)12)
--extern "C" rpcb_stat * rpcbproc_getstat_4(void *, CLIENT *);
--extern "C" rpcb_stat * rpcbproc_getstat_4_svc(void *, struct svc_req *);
--
--#elif __STDC__
--extern bool_t * rpcbproc_set_4(rpcb *, CLIENT *);
--extern bool_t * rpcbproc_set_4_svc(rpcb *, struct svc_req *);
--extern bool_t * rpcbproc_unset_4(rpcb *, CLIENT *);
--extern bool_t * rpcbproc_unset_4_svc(rpcb *, struct svc_req *);
--extern char ** rpcbproc_getaddr_4(rpcb *, CLIENT *);
--extern char ** rpcbproc_getaddr_4_svc(rpcb *, struct svc_req *);
--extern rpcblist_ptr * rpcbproc_dump_4(void *, CLIENT *);
--extern rpcblist_ptr * rpcbproc_dump_4_svc(void *, struct svc_req *);
--#define RPCBPROC_BCAST ((u_int32_t)RPCBPROC_CALLIT)
--extern rpcb_rmtcallres * rpcbproc_bcast_4(rpcb_rmtcallargs *, CLIENT *);
--extern rpcb_rmtcallres * rpcbproc_bcast_4_svc(rpcb_rmtcallargs *, struct svc_req *);
--extern u_int * rpcbproc_gettime_4(void *, CLIENT *);
--extern u_int * rpcbproc_gettime_4_svc(void *, struct svc_req *);
--extern struct netbuf * rpcbproc_uaddr2taddr_4(char **, CLIENT *);
--extern struct netbuf * rpcbproc_uaddr2taddr_4_svc(char **, struct svc_req *);
--extern char ** rpcbproc_taddr2uaddr_4(struct netbuf *, CLIENT *);
--extern char ** rpcbproc_taddr2uaddr_4_svc(struct netbuf *, struct svc_req *);
--#define RPCBPROC_GETVERSADDR ((u_int32_t)9)
--extern char ** rpcbproc_getversaddr_4(rpcb *, CLIENT *);
--extern char ** rpcbproc_getversaddr_4_svc(rpcb *, struct svc_req *);
--#define RPCBPROC_INDIRECT ((u_int32_t)10)
--extern rpcb_rmtcallres * rpcbproc_indirect_4(rpcb_rmtcallargs *, CLIENT *);
--extern rpcb_rmtcallres * rpcbproc_indirect_4_svc(rpcb_rmtcallargs *, struct svc_req *);
--#define RPCBPROC_GETADDRLIST ((u_int32_t)11)
--extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4(rpcb *, CLIENT *);
--extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4_svc(rpcb *, struct svc_req *);
--#define RPCBPROC_GETSTAT ((u_int32_t)12)
--extern rpcb_stat * rpcbproc_getstat_4(void *, CLIENT *);
--extern rpcb_stat * rpcbproc_getstat_4_svc(void *, struct svc_req *);
--
--#else /* Old Style C */
--extern bool_t * rpcbproc_set_4();
--extern bool_t * rpcbproc_set_4_svc();
--extern bool_t * rpcbproc_unset_4();
--extern bool_t * rpcbproc_unset_4_svc();
--extern char ** rpcbproc_getaddr_4();
--extern char ** rpcbproc_getaddr_4_svc();
--extern rpcblist_ptr * rpcbproc_dump_4();
--extern rpcblist_ptr * rpcbproc_dump_4_svc();
--#define RPCBPROC_BCAST ((u_int32_t)RPCBPROC_CALLIT)
--extern rpcb_rmtcallres * rpcbproc_bcast_4();
--extern rpcb_rmtcallres * rpcbproc_bcast_4_svc();
--extern u_int * rpcbproc_gettime_4();
--extern u_int * rpcbproc_gettime_4_svc();
--extern struct netbuf * rpcbproc_uaddr2taddr_4();
--extern struct netbuf * rpcbproc_uaddr2taddr_4_svc();
--extern char ** rpcbproc_taddr2uaddr_4();
--extern char ** rpcbproc_taddr2uaddr_4_svc();
--#define RPCBPROC_GETVERSADDR ((u_int32_t)9)
--extern char ** rpcbproc_getversaddr_4();
--extern char ** rpcbproc_getversaddr_4_svc();
--#define RPCBPROC_INDIRECT ((u_int32_t)10)
--extern rpcb_rmtcallres * rpcbproc_indirect_4();
--extern rpcb_rmtcallres * rpcbproc_indirect_4_svc();
--#define RPCBPROC_GETADDRLIST ((u_int32_t)11)
--extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4();
--extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4_svc();
--#define RPCBPROC_GETSTAT ((u_int32_t)12)
--extern rpcb_stat * rpcbproc_getstat_4();
--extern rpcb_stat * rpcbproc_getstat_4_svc();
--#endif /* Old Style C */
--
--#endif /* !_RPCB_PROT_H_RPCGEN */
-diff --git a/tirpc/rpcsvc/crypt.h b/tirpc/rpcsvc/crypt.h
-deleted file mode 100644
-index da1f9cc..0000000
---- a/tirpc/rpcsvc/crypt.h
-+++ /dev/null
-@@ -1,109 +0,0 @@
--/*
-- * Please do not edit this file.
-- * It was generated using rpcgen.
-- */
--
--#ifndef _CRYPT_H_RPCGEN
--#define _CRYPT_H_RPCGEN
--
--#include <rpc/rpc.h>
--
--#ifndef IXDR_GET_INT32
--#define IXDR_GET_INT32(buf) IXDR_GET_LONG((buf))
--#endif
--#ifndef IXDR_PUT_INT32
--#define IXDR_PUT_INT32(buf, v) IXDR_PUT_LONG((buf), (v))
--#endif
--#ifndef IXDR_GET_U_INT32
--#define IXDR_GET_U_INT32(buf) IXDR_GET_U_LONG((buf))
--#endif
--#ifndef IXDR_PUT_U_INT32
--#define IXDR_PUT_U_INT32(buf, v) IXDR_PUT_U_LONG((buf), (v))
--#endif
--
--enum des_dir {
-- ENCRYPT_DES = 0,
-- DECRYPT_DES = 1,
--};
--typedef enum des_dir des_dir;
--#ifdef __cplusplus
--extern "C" bool_t xdr_des_dir(XDR *, des_dir*);
--#elif __STDC__
--extern bool_t xdr_des_dir(XDR *, des_dir*);
--#else /* Old Style C */
--bool_t xdr_des_dir();
--#endif /* Old Style C */
--
--
--enum des_mode {
-- CBC_DES = 0,
-- ECB_DES = 1,
--};
--typedef enum des_mode des_mode;
--#ifdef __cplusplus
--extern "C" bool_t xdr_des_mode(XDR *, des_mode*);
--#elif __STDC__
--extern bool_t xdr_des_mode(XDR *, des_mode*);
--#else /* Old Style C */
--bool_t xdr_des_mode();
--#endif /* Old Style C */
--
--
--struct desargs {
-- u_char des_key[8];
-- des_dir des_dir;
-- des_mode des_mode;
-- u_char des_ivec[8];
-- struct {
-- u_int desbuf_len;
-- char *desbuf_val;
-- } desbuf;
--};
--typedef struct desargs desargs;
--#ifdef __cplusplus
--extern "C" bool_t xdr_desargs(XDR *, desargs*);
--#elif __STDC__
--extern bool_t xdr_desargs(XDR *, desargs*);
--#else /* Old Style C */
--bool_t xdr_desargs();
--#endif /* Old Style C */
--
--
--struct desresp {
-- struct {
-- u_int desbuf_len;
-- char *desbuf_val;
-- } desbuf;
-- u_char des_ivec[8];
-- int stat;
--};
--typedef struct desresp desresp;
--#ifdef __cplusplus
--extern "C" bool_t xdr_desresp(XDR *, desresp*);
--#elif __STDC__
--extern bool_t xdr_desresp(XDR *, desresp*);
--#else /* Old Style C */
--bool_t xdr_desresp();
--#endif /* Old Style C */
--
--
--#define CRYPT_PROG ((u_int32_t)600100029)
--#define CRYPT_VERS ((u_int32_t)1)
--
--#ifdef __cplusplus
--#define DES_CRYPT ((u_int32_t)1)
--extern "C" desresp * des_crypt_1(desargs *, CLIENT *);
--extern "C" desresp * des_crypt_1_svc(desargs *, struct svc_req *);
--
--#elif __STDC__
--#define DES_CRYPT ((u_int32_t)1)
--extern desresp * des_crypt_1(desargs *, CLIENT *);
--extern desresp * des_crypt_1_svc(desargs *, struct svc_req *);
--
--#else /* Old Style C */
--#define DES_CRYPT ((u_int32_t)1)
--extern desresp * des_crypt_1();
--extern desresp * des_crypt_1_svc();
--#endif /* Old Style C */
--
--#endif /* !_CRYPT_H_RPCGEN */
---
-2.0.0
-
+++ /dev/null
-From 008a9c8ac3a84ffcc46a0eedb5b13862b279190c Mon Sep 17 00:00:00 2001
-From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
-Date: Sat, 10 Nov 2012 17:45:03 +0100
-Subject: [PATCH] Add more XDR files needed to build rpcbind on top of libtirpc
-
-Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
----
- Makefile.am | 6 +
- tirpc/rpcsvc/mount.x | 257 ++++++++++
- tirpc/rpcsvc/nfs_prot.x | 1266 +++++++++++++++++++++++++++++++++++++++++++++++
- tirpc/rpcsvc/rquota.x | 67 +++
- 4 files changed, 1596 insertions(+)
- create mode 100644 tirpc/rpcsvc/mount.x
- create mode 100644 tirpc/rpcsvc/nfs_prot.x
- create mode 100644 tirpc/rpcsvc/rquota.x
-
-diff --git a/Makefile.am b/Makefile.am
-index 4e4dc32..b7ae979 100644
---- a/Makefile.am
-+++ b/Makefile.am
-@@ -3,6 +3,9 @@ ACLOCAL_AMFLAGS = -I m4
-
- GENFILES = \
- tirpc/rpcsvc/crypt.h \
-+ tirpc/rpcsvc/mount.h \
-+ tirpc/rpcsvc/nfs_prot.h \
-+ tirpc/rpcsvc/rquota.h \
- tirpc/rpc/rpcb_prot.h
-
- noinst_HEADERS = tirpc/reentrant.h \
-@@ -12,6 +15,9 @@ noinst_HEADERS = tirpc/reentrant.h \
-
- nobase_include_HEADERS = tirpc/netconfig.h \
- tirpc/rpcsvc/crypt.x \
-+ tirpc/rpcsvc/mount.x \
-+ tirpc/rpcsvc/nfs_prot.x \
-+ tirpc/rpcsvc/rquota.x \
- tirpc/rpc/xdr.h \
- tirpc/rpc/types.h \
- tirpc/rpc/svc_soc.h \
-diff --git a/tirpc/rpcsvc/mount.x b/tirpc/rpcsvc/mount.x
-new file mode 100644
-index 0000000..f68a06f
---- /dev/null
-+++ b/tirpc/rpcsvc/mount.x
-@@ -0,0 +1,257 @@
-+/*
-+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
-+ * unrestricted use provided that this legend is included on all tape
-+ * media and as a part of the software program in whole or part. Users
-+ * may copy or modify Sun RPC without charge, but are not authorized
-+ * to license or distribute it to anyone else except as part of a product or
-+ * program developed by the user.
-+ *
-+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
-+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
-+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
-+ *
-+ * Sun RPC is provided with no support and without any obligation on the
-+ * part of Sun Microsystems, Inc. to assist in its use, correction,
-+ * modification or enhancement.
-+ *
-+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
-+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
-+ * OR ANY PART THEREOF.
-+ *
-+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
-+ * or profits or other special, indirect and consequential damages, even if
-+ * Sun has been advised of the possibility of such damages.
-+ *
-+ * Sun Microsystems, Inc.
-+ * 2550 Garcia Avenue
-+ * Mountain View, California 94043
-+ */
-+
-+/*
-+ * Protocol description for the mount program
-+ */
-+
-+#ifndef RPC_HDR
-+%#ifndef lint
-+%/*static char sccsid[] = "from: @(#)mount.x 1.2 87/09/18 Copyr 1987 Sun Micro";*/
-+%/*static char sccsid[] = "from: @(#)mount.x 2.1 88/08/01 4.0 RPCSRC";*/
-+%static const char rcsid[] =
-+% "$FreeBSD: src/include/rpcsvc/mount.x,v 1.6 1999/08/27 23:45:08 peter Exp $";
-+%#endif /* not lint */
-+#endif
-+
-+const MNTPATHLEN = 1024; /* maximum bytes in a pathname argument */
-+const MNTNAMLEN = 255; /* maximum bytes in a name argument */
-+const FHSIZE = 32; /* size in bytes of a file handle */
-+#ifdef WANT_NFS3
-+const FHSIZE3 = 64; /* size in bytes of a file handle (v3) */
-+#endif
-+
-+/*
-+ * The fhandle is the file handle that the server passes to the client.
-+ * All file operations are done using the file handles to refer to a file
-+ * or a directory. The file handle can contain whatever information the
-+ * server needs to distinguish an individual file.
-+ */
-+typedef opaque fhandle[FHSIZE];
-+#ifdef WANT_NFS3
-+typedef opaque fhandle3<FHSIZE3>;
-+#endif
-+
-+/*
-+ * If a status of zero is returned, the call completed successfully, and
-+ * a file handle for the directory follows. A non-zero status indicates
-+ * some sort of error. The status corresponds with UNIX error numbers.
-+ */
-+union fhstatus switch (unsigned fhs_status) {
-+case 0:
-+ fhandle fhs_fhandle;
-+default:
-+ void;
-+};
-+
-+#ifdef WANT_NFS3
-+/*
-+ * Status codes returned by the version 3 mount call.
-+ */
-+enum mountstat3 {
-+ MNT3_OK = 0, /* no error */
-+ MNT3ERR_PERM = 1, /* Not owner */
-+ MNT3ERR_NOENT = 2, /* No such file or directory */
-+ MNT3ERR_IO = 5, /* I/O error */
-+ MNT3ERR_ACCES = 13, /* Permission denied */
-+ MNT3ERR_NOTDIR = 20, /* Not a directory */
-+ MNT3ERR_INVAL = 22, /* Invalid argument */
-+ MNT3ERR_NAMETOOLONG = 63, /* Filename too long */
-+ MNT3ERR_NOTSUPP = 10004, /* Operation not supported */
-+ MNT3ERR_SERVERFAULT = 10006 /* A failure on the server */
-+};
-+
-+struct mountres3_ok {
-+ fhandle3 fhandle;
-+ int auth_flavors<>;
-+};
-+
-+union mountres3 switch (mountstat3 fhs_status) {
-+case 0:
-+ mountres3_ok mountinfo;
-+default:
-+ void;
-+};
-+#endif
-+
-+/*
-+ * The type dirpath is the pathname of a directory
-+ */
-+typedef string dirpath<MNTPATHLEN>;
-+
-+/*
-+ * The type name is used for arbitrary names (hostnames, groupnames)
-+ */
-+typedef string name<MNTNAMLEN>;
-+
-+/*
-+ * A list of who has what mounted
-+ */
-+typedef struct mountbody *mountlist;
-+struct mountbody {
-+ name ml_hostname;
-+ dirpath ml_directory;
-+ mountlist ml_next;
-+};
-+
-+/*
-+ * A list of netgroups
-+ */
-+typedef struct groupnode *groups;
-+struct groupnode {
-+ name gr_name;
-+ groups gr_next;
-+};
-+
-+/*
-+ * A list of what is exported and to whom
-+ */
-+typedef struct exportnode *exports;
-+struct exportnode {
-+ dirpath ex_dir;
-+ groups ex_groups;
-+ exports ex_next;
-+};
-+
-+program MOUNTPROG {
-+ /*
-+ * Version one of the mount protocol communicates with version two
-+ * of the NFS protocol. Version three communicates with
-+ * version three of the NFS protocol. The only connecting
-+ * point is the fhandle structure, which is the same for both
-+ * protocols.
-+ */
-+ version MOUNTVERS {
-+ /*
-+ * Does no work. It is made available in all RPC services
-+ * to allow server reponse testing and timing
-+ */
-+ void
-+ MOUNTPROC_NULL(void) = 0;
-+
-+ /*
-+ * If fhs_status is 0, then fhs_fhandle contains the
-+ * file handle for the directory. This file handle may
-+ * be used in the NFS protocol. This procedure also adds
-+ * a new entry to the mount list for this client mounting
-+ * the directory.
-+ * Unix authentication required.
-+ */
-+ fhstatus
-+ MOUNTPROC_MNT(dirpath) = 1;
-+
-+ /*
-+ * Returns the list of remotely mounted filesystems. The
-+ * mountlist contains one entry for each hostname and
-+ * directory pair.
-+ */
-+ mountlist
-+ MOUNTPROC_DUMP(void) = 2;
-+
-+ /*
-+ * Removes the mount list entry for the directory
-+ * Unix authentication required.
-+ */
-+ void
-+ MOUNTPROC_UMNT(dirpath) = 3;
-+
-+ /*
-+ * Removes all of the mount list entries for this client
-+ * Unix authentication required.
-+ */
-+ void
-+ MOUNTPROC_UMNTALL(void) = 4;
-+
-+ /*
-+ * Returns a list of all the exported filesystems, and which
-+ * machines are allowed to import it.
-+ */
-+ exports
-+ MOUNTPROC_EXPORT(void) = 5;
-+
-+ /*
-+ * Identical to MOUNTPROC_EXPORT above
-+ */
-+ exports
-+ MOUNTPROC_EXPORTALL(void) = 6;
-+ } = 1;
-+#ifdef WANT_NFS3
-+ version MOUNTVERS3 {
-+ /*
-+ * Does no work. It is made available in all RPC services
-+ * to allow server reponse testing and timing
-+ */
-+ void
-+ MOUNTPROC_NULL(void) = 0;
-+
-+ /*
-+ * If mountres3.fhs_status is MNT3_OK, then
-+ * mountres3.mountinfo contains the file handle for
-+ * the directory and a list of acceptable
-+ * authentication flavors. This file handle may only
-+ * be used in the NFS version 3 protocol. This
-+ * procedure also results in the server adding a new
-+ * entry to its mount list recording that this client
-+ * has mounted the directory. AUTH_UNIX authentication
-+ * or better is required.
-+ */
-+ mountres3
-+ MOUNTPROC_MNT(dirpath) = 1;
-+
-+ /*
-+ * Returns the list of remotely mounted filesystems. The
-+ * mountlist contains one entry for each hostname and
-+ * directory pair.
-+ */
-+ mountlist
-+ MOUNTPROC_DUMP(void) = 2;
-+
-+ /*
-+ * Removes the mount list entry for the directory
-+ * Unix authentication required.
-+ */
-+ void
-+ MOUNTPROC_UMNT(dirpath) = 3;
-+
-+ /*
-+ * Removes all of the mount list entries for this client
-+ * Unix authentication required.
-+ */
-+ void
-+ MOUNTPROC_UMNTALL(void) = 4;
-+
-+ /*
-+ * Returns a list of all the exported filesystems, and which
-+ * machines are allowed to import it.
-+ */
-+ exports
-+ MOUNTPROC_EXPORT(void) = 5;
-+ } = 3;
-+#endif
-+} = 100005;
-diff --git a/tirpc/rpcsvc/nfs_prot.x b/tirpc/rpcsvc/nfs_prot.x
-new file mode 100644
-index 0000000..01564f8
---- /dev/null
-+++ b/tirpc/rpcsvc/nfs_prot.x
-@@ -0,0 +1,1266 @@
-+/*
-+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
-+ * unrestricted use provided that this legend is included on all tape
-+ * media and as a part of the software program in whole or part. Users
-+ * may copy or modify Sun RPC without charge, but are not authorized
-+ * to license or distribute it to anyone else except as part of a product or
-+ * program developed by the user.
-+ *
-+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
-+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
-+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
-+ *
-+ * Sun RPC is provided with no support and without any obligation on the
-+ * part of Sun Microsystems, Inc. to assist in its use, correction,
-+ * modification or enhancement.
-+ *
-+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
-+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
-+ * OR ANY PART THEREOF.
-+ *
-+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
-+ * or profits or other special, indirect and consequential damages, even if
-+ * Sun has been advised of the possibility of such damages.
-+ *
-+ * Sun Microsystems, Inc.
-+ * 2550 Garcia Avenue
-+ * Mountain View, California 94043
-+ */
-+
-+#ifndef RPC_HDR
-+%#ifndef lint
-+%/*static char sccsid[] = "from: @(#)nfs_prot.x 1.2 87/10/12 Copyr 1987 Sun Micro";*/
-+%/*static char sccsid[] = "from: @(#)nfs_prot.x 2.1 88/08/01 4.0 RPCSRC";*/
-+%static const char rcsid[] =
-+% "$FreeBSD: src/include/rpcsvc/nfs_prot.x,v 1.7 1999/08/27 23:45:08 peter Exp $";
-+%#endif /* not lint */
-+#endif
-+
-+const NFS_PORT = 2049;
-+const NFS_MAXDATA = 8192;
-+const NFS_MAXPATHLEN = 1024;
-+const NFS_MAXNAMLEN = 255;
-+const NFS_FHSIZE = 32;
-+const NFS_COOKIESIZE = 4;
-+const NFS_FIFO_DEV = -1; /* size kludge for named pipes */
-+
-+/*
-+ * File types
-+ */
-+const NFSMODE_FMT = 0170000; /* type of file */
-+const NFSMODE_DIR = 0040000; /* directory */
-+const NFSMODE_CHR = 0020000; /* character special */
-+const NFSMODE_BLK = 0060000; /* block special */
-+const NFSMODE_REG = 0100000; /* regular */
-+const NFSMODE_LNK = 0120000; /* symbolic link */
-+const NFSMODE_SOCK = 0140000; /* socket */
-+const NFSMODE_FIFO = 0010000; /* fifo */
-+
-+/*
-+ * Error status
-+ */
-+enum nfsstat {
-+ NFS_OK= 0, /* no error */
-+ NFSERR_PERM=1, /* Not owner */
-+ NFSERR_NOENT=2, /* No such file or directory */
-+ NFSERR_IO=5, /* I/O error */
-+ NFSERR_NXIO=6, /* No such device or address */
-+ NFSERR_ACCES=13, /* Permission denied */
-+ NFSERR_EXIST=17, /* File exists */
-+ NFSERR_NODEV=19, /* No such device */
-+ NFSERR_NOTDIR=20, /* Not a directory*/
-+ NFSERR_ISDIR=21, /* Is a directory */
-+ NFSERR_FBIG=27, /* File too large */
-+ NFSERR_NOSPC=28, /* No space left on device */
-+ NFSERR_ROFS=30, /* Read-only file system */
-+ NFSERR_NAMETOOLONG=63, /* File name too long */
-+ NFSERR_NOTEMPTY=66, /* Directory not empty */
-+ NFSERR_DQUOT=69, /* Disc quota exceeded */
-+ NFSERR_STALE=70, /* Stale NFS file handle */
-+ NFSERR_WFLUSH=99 /* write cache flushed */
-+};
-+
-+/*
-+ * File types
-+ */
-+enum ftype {
-+ NFNON = 0, /* non-file */
-+ NFREG = 1, /* regular file */
-+ NFDIR = 2, /* directory */
-+ NFBLK = 3, /* block special */
-+ NFCHR = 4, /* character special */
-+ NFLNK = 5, /* symbolic link */
-+ NFSOCK = 6, /* unix domain sockets */
-+ NFBAD = 7, /* unused */
-+ NFFIFO = 8 /* named pipe */
-+};
-+
-+/*
-+ * File access handle
-+ */
-+struct nfs_fh {
-+ opaque data[NFS_FHSIZE];
-+};
-+
-+/*
-+ * Timeval
-+ */
-+struct nfstime {
-+ unsigned seconds;
-+ unsigned useconds;
-+};
-+
-+
-+/*
-+ * File attributes
-+ */
-+struct fattr {
-+ ftype type; /* file type */
-+ unsigned mode; /* protection mode bits */
-+ unsigned nlink; /* # hard links */
-+ unsigned uid; /* owner user id */
-+ unsigned gid; /* owner group id */
-+ unsigned size; /* file size in bytes */
-+ unsigned blocksize; /* prefered block size */
-+ unsigned rdev; /* special device # */
-+ unsigned blocks; /* Kb of disk used by file */
-+ unsigned fsid; /* device # */
-+ unsigned fileid; /* inode # */
-+ nfstime atime; /* time of last access */
-+ nfstime mtime; /* time of last modification */
-+ nfstime ctime; /* time of last change */
-+};
-+
-+/*
-+ * File attributes which can be set
-+ */
-+struct sattr {
-+ unsigned mode; /* protection mode bits */
-+ unsigned uid; /* owner user id */
-+ unsigned gid; /* owner group id */
-+ unsigned size; /* file size in bytes */
-+ nfstime atime; /* time of last access */
-+ nfstime mtime; /* time of last modification */
-+};
-+
-+
-+typedef string filename<NFS_MAXNAMLEN>;
-+typedef string nfspath<NFS_MAXPATHLEN>;
-+
-+/*
-+ * Reply status with file attributes
-+ */
-+union attrstat switch (nfsstat status) {
-+case NFS_OK:
-+ fattr attributes;
-+default:
-+ void;
-+};
-+
-+struct sattrargs {
-+ nfs_fh file;
-+ sattr attributes;
-+};
-+
-+/*
-+ * Arguments for directory operations
-+ */
-+struct diropargs {
-+ nfs_fh dir; /* directory file handle */
-+ filename name; /* name (up to NFS_MAXNAMLEN bytes) */
-+};
-+
-+struct diropokres {
-+ nfs_fh file;
-+ fattr attributes;
-+};
-+
-+/*
-+ * Results from directory operation
-+ */
-+union diropres switch (nfsstat status) {
-+case NFS_OK:
-+ diropokres diropres;
-+default:
-+ void;
-+};
-+
-+union readlinkres switch (nfsstat status) {
-+case NFS_OK:
-+ nfspath data;
-+default:
-+ void;
-+};
-+
-+/*
-+ * Arguments to remote read
-+ */
-+struct readargs {
-+ nfs_fh file; /* handle for file */
-+ unsigned offset; /* byte offset in file */
-+ unsigned count; /* immediate read count */
-+ unsigned totalcount; /* total read count (from this offset)*/
-+};
-+
-+/*
-+ * Status OK portion of remote read reply
-+ */
-+struct readokres {
-+ fattr attributes; /* attributes, need for pagin*/
-+ opaque data<NFS_MAXDATA>;
-+};
-+
-+union readres switch (nfsstat status) {
-+case NFS_OK:
-+ readokres reply;
-+default:
-+ void;
-+};
-+
-+/*
-+ * Arguments to remote write
-+ */
-+struct writeargs {
-+ nfs_fh file; /* handle for file */
-+ unsigned beginoffset; /* beginning byte offset in file */
-+ unsigned offset; /* current byte offset in file */
-+ unsigned totalcount; /* total write count (to this offset)*/
-+ opaque data<NFS_MAXDATA>;
-+};
-+
-+struct createargs {
-+ diropargs where;
-+ sattr attributes;
-+};
-+
-+struct renameargs {
-+ diropargs from;
-+ diropargs to;
-+};
-+
-+struct linkargs {
-+ nfs_fh from;
-+ diropargs to;
-+};
-+
-+struct symlinkargs {
-+ diropargs from;
-+ nfspath to;
-+ sattr attributes;
-+};
-+
-+
-+typedef opaque nfscookie[NFS_COOKIESIZE];
-+
-+/*
-+ * Arguments to readdir
-+ */
-+struct readdirargs {
-+ nfs_fh dir; /* directory handle */
-+ nfscookie cookie;
-+ unsigned count; /* number of directory bytes to read */
-+};
-+
-+struct entry {
-+ unsigned fileid;
-+ filename name;
-+ nfscookie cookie;
-+ entry *nextentry;
-+};
-+
-+struct dirlist {
-+ entry *entries;
-+ bool eof;
-+};
-+
-+union readdirres switch (nfsstat status) {
-+case NFS_OK:
-+ dirlist reply;
-+default:
-+ void;
-+};
-+
-+struct statfsokres {
-+ unsigned tsize; /* preferred transfer size in bytes */
-+ unsigned bsize; /* fundamental file system block size */
-+ unsigned blocks; /* total blocks in file system */
-+ unsigned bfree; /* free blocks in fs */
-+ unsigned bavail; /* free blocks avail to non-superuser */
-+};
-+
-+union statfsres switch (nfsstat status) {
-+case NFS_OK:
-+ statfsokres reply;
-+default:
-+ void;
-+};
-+
-+#ifdef WANT_NFS3
-+
-+/*
-+ * NFSv3 constants and types
-+ */
-+const NFS3_FHSIZE = 64; /* maximum size in bytes of a file handle */
-+const NFS3_COOKIEVERFSIZE = 8; /* size of a cookie verifier for READDIR */
-+const NFS3_CREATEVERFSIZE = 8; /* size of the verifier used for CREATE */
-+const NFS3_WRITEVERFSIZE = 8; /* size of the verifier used for WRITE */
-+
-+typedef unsigned hyper uint64;
-+typedef hyper int64;
-+typedef unsigned long uint32;
-+typedef long int32;
-+typedef string filename3<>;
-+typedef string nfspath3<>;
-+typedef uint64 fileid3;
-+typedef uint64 cookie3;
-+typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
-+typedef opaque createverf3[NFS3_CREATEVERFSIZE];
-+typedef opaque writeverf3[NFS3_WRITEVERFSIZE];
-+typedef uint32 uid3;
-+typedef uint32 gid3;
-+typedef uint64 size3;
-+typedef uint64 offset3;
-+typedef uint32 mode3;
-+typedef uint32 count3;
-+
-+/*
-+ * Error status (v3)
-+ */
-+enum nfsstat3 {
-+ NFS3_OK = 0,
-+ NFS3ERR_PERM = 1,
-+ NFS3ERR_NOENT = 2,
-+ NFS3ERR_IO = 5,
-+ NFS3ERR_NXIO = 6,
-+ NFS3ERR_ACCES = 13,
-+ NFS3ERR_EXIST = 17,
-+ NFS3ERR_XDEV = 18,
-+ NFS3ERR_NODEV = 19,
-+ NFS3ERR_NOTDIR = 20,
-+ NFS3ERR_ISDIR = 21,
-+ NFS3ERR_INVAL = 22,
-+ NFS3ERR_FBIG = 27,
-+ NFS3ERR_NOSPC = 28,
-+ NFS3ERR_ROFS = 30,
-+ NFS3ERR_MLINK = 31,
-+ NFS3ERR_NAMETOOLONG = 63,
-+ NFS3ERR_NOTEMPTY = 66,
-+ NFS3ERR_DQUOT = 69,
-+ NFS3ERR_STALE = 70,
-+ NFS3ERR_REMOTE = 71,
-+ NFS3ERR_BADHANDLE = 10001,
-+ NFS3ERR_NOT_SYNC = 10002,
-+ NFS3ERR_BAD_COOKIE = 10003,
-+ NFS3ERR_NOTSUPP = 10004,
-+ NFS3ERR_TOOSMALL = 10005,
-+ NFS3ERR_SERVERFAULT = 10006,
-+ NFS3ERR_BADTYPE = 10007,
-+ NFS3ERR_JUKEBOX = 10008
-+};
-+
-+/*
-+ * File types (v3)
-+ */
-+enum ftype3 {
-+ NF3REG = 1, /* regular file */
-+ NF3DIR = 2, /* directory */
-+ NF3BLK = 3, /* block special */
-+ NF3CHR = 4, /* character special */
-+ NF3LNK = 5, /* symbolic link */
-+ NF3SOCK = 6, /* unix domain sockets */
-+ NF3FIFO = 7 /* named pipe */
-+};
-+
-+struct specdata3 {
-+ uint32 specdata1;
-+ uint32 specdata2;
-+};
-+
-+/*
-+ * File access handle (v3)
-+ */
-+struct nfs_fh3 {
-+ opaque data<NFS3_FHSIZE>;
-+};
-+
-+/*
-+ * Timeval (v3)
-+ */
-+struct nfstime3 {
-+ uint32 seconds;
-+ uint32 nseconds;
-+};
-+
-+
-+/*
-+ * File attributes (v3)
-+ */
-+struct fattr3 {
-+ ftype3 type; /* file type */
-+ mode3 mode; /* protection mode bits */
-+ uint32 nlink; /* # hard links */
-+ uid3 uid; /* owner user id */
-+ gid3 gid; /* owner group id */
-+ size3 size; /* file size in bytes */
-+ size3 used; /* prefered block size */
-+ specdata3 rdev; /* special device # */
-+ uint64 fsid; /* device # */
-+ fileid3 fileid; /* inode # */
-+ nfstime3 atime; /* time of last access */
-+ nfstime3 mtime; /* time of last modification */
-+ nfstime3 ctime; /* time of last change */
-+};
-+
-+union post_op_attr switch (bool attributes_follow) {
-+case TRUE:
-+ fattr3 attributes;
-+case FALSE:
-+ void;
-+};
-+
-+struct wcc_attr {
-+ size3 size;
-+ nfstime3 mtime;
-+ nfstime3 ctime;
-+};
-+
-+union pre_op_attr switch (bool attributes_follow) {
-+case TRUE:
-+ wcc_attr attributes;
-+case FALSE:
-+ void;
-+};
-+
-+struct wcc_data {
-+ pre_op_attr before;
-+ post_op_attr after;
-+};
-+
-+union post_op_fh3 switch (bool handle_follows) {
-+case TRUE:
-+ nfs_fh3 handle;
-+case FALSE:
-+ void;
-+};
-+
-+/*
-+ * File attributes which can be set (v3)
-+ */
-+enum time_how {
-+ DONT_CHANGE = 0,
-+ SET_TO_SERVER_TIME = 1,
-+ SET_TO_CLIENT_TIME = 2
-+};
-+
-+union set_mode3 switch (bool set_it) {
-+case TRUE:
-+ mode3 mode;
-+default:
-+ void;
-+};
-+
-+union set_uid3 switch (bool set_it) {
-+case TRUE:
-+ uid3 uid;
-+default:
-+ void;
-+};
-+
-+union set_gid3 switch (bool set_it) {
-+case TRUE:
-+ gid3 gid;
-+default:
-+ void;
-+};
-+
-+union set_size3 switch (bool set_it) {
-+case TRUE:
-+ size3 size;
-+default:
-+ void;
-+};
-+
-+union set_atime switch (time_how set_it) {
-+case SET_TO_CLIENT_TIME:
-+ nfstime3 atime;
-+default:
-+ void;
-+};
-+
-+union set_mtime switch (time_how set_it) {
-+case SET_TO_CLIENT_TIME:
-+ nfstime3 mtime;
-+default:
-+ void;
-+};
-+
-+struct sattr3 {
-+ set_mode3 mode;
-+ set_uid3 uid;
-+ set_gid3 gid;
-+ set_size3 size;
-+ set_atime atime;
-+ set_mtime mtime;
-+};
-+
-+/*
-+ * Arguments for directory operations (v3)
-+ */
-+struct diropargs3 {
-+ nfs_fh3 dir; /* directory file handle */
-+ filename3 name; /* name (up to NFS_MAXNAMLEN bytes) */
-+};
-+
-+/*
-+ * Arguments to getattr (v3).
-+ */
-+struct GETATTR3args {
-+ nfs_fh3 object;
-+};
-+
-+struct GETATTR3resok {
-+ fattr3 obj_attributes;
-+};
-+
-+union GETATTR3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ GETATTR3resok resok;
-+default:
-+ void;
-+};
-+
-+/*
-+ * Arguments to setattr (v3).
-+ */
-+union sattrguard3 switch (bool check) {
-+case TRUE:
-+ nfstime3 obj_ctime;
-+case FALSE:
-+ void;
-+};
-+
-+struct SETATTR3args {
-+ nfs_fh3 object;
-+ sattr3 new_attributes;
-+ sattrguard3 guard;
-+};
-+
-+struct SETATTR3resok {
-+ wcc_data obj_wcc;
-+};
-+
-+struct SETATTR3resfail {
-+ wcc_data obj_wcc;
-+};
-+
-+union SETATTR3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ SETATTR3resok resok;
-+default:
-+ SETATTR3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to lookup (v3).
-+ */
-+struct LOOKUP3args {
-+ diropargs3 what;
-+};
-+
-+struct LOOKUP3resok {
-+ nfs_fh3 object;
-+ post_op_attr obj_attributes;
-+ post_op_attr dir_attributes;
-+};
-+
-+struct LOOKUP3resfail {
-+ post_op_attr dir_attributes;
-+};
-+
-+union LOOKUP3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ LOOKUP3resok resok;
-+default:
-+ LOOKUP3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to access (v3).
-+ */
-+const ACCESS3_READ = 0x0001;
-+const ACCESS3_LOOKUP = 0x0002;
-+const ACCESS3_MODIFY = 0x0004;
-+const ACCESS3_EXTEND = 0x0008;
-+const ACCESS3_DELETE = 0x0010;
-+const ACCESS3_EXECUTE = 0x0020;
-+
-+struct ACCESS3args {
-+ nfs_fh3 object;
-+ uint32 access;
-+};
-+
-+struct ACCESS3resok {
-+ post_op_attr obj_attributes;
-+ uint32 access;
-+};
-+
-+struct ACCESS3resfail {
-+ post_op_attr obj_attributes;
-+};
-+
-+union ACCESS3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ ACCESS3resok resok;
-+default:
-+ ACCESS3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to readlink (v3).
-+ */
-+struct READLINK3args {
-+ nfs_fh3 symlink;
-+};
-+
-+struct READLINK3resok {
-+ post_op_attr symlink_attributes;
-+ nfspath3 data;
-+};
-+
-+struct READLINK3resfail {
-+ post_op_attr symlink_attributes;
-+};
-+
-+union READLINK3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ READLINK3resok resok;
-+default:
-+ READLINK3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to read (v3).
-+ */
-+struct READ3args {
-+ nfs_fh3 file;
-+ offset3 offset;
-+ count3 count;
-+};
-+
-+struct READ3resok {
-+ post_op_attr file_attributes;
-+ count3 count;
-+ bool eof;
-+ opaque data<>;
-+};
-+
-+struct READ3resfail {
-+ post_op_attr file_attributes;
-+};
-+
-+/* XXX: solaris 2.6 uses ``nfsstat'' here */
-+union READ3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ READ3resok resok;
-+default:
-+ READ3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to write (v3).
-+ */
-+enum stable_how {
-+ UNSTABLE = 0,
-+ DATA_SYNC = 1,
-+ FILE_SYNC = 2
-+};
-+
-+struct WRITE3args {
-+ nfs_fh3 file;
-+ offset3 offset;
-+ count3 count;
-+ stable_how stable;
-+ opaque data<>;
-+};
-+
-+struct WRITE3resok {
-+ wcc_data file_wcc;
-+ count3 count;
-+ stable_how committed;
-+ writeverf3 verf;
-+};
-+
-+struct WRITE3resfail {
-+ wcc_data file_wcc;
-+};
-+
-+union WRITE3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ WRITE3resok resok;
-+default:
-+ WRITE3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to create (v3).
-+ */
-+enum createmode3 {
-+ UNCHECKED = 0,
-+ GUARDED = 1,
-+ EXCLUSIVE = 2
-+};
-+
-+union createhow3 switch (createmode3 mode) {
-+case UNCHECKED:
-+case GUARDED:
-+ sattr3 obj_attributes;
-+case EXCLUSIVE:
-+ createverf3 verf;
-+};
-+
-+struct CREATE3args {
-+ diropargs3 where;
-+ createhow3 how;
-+};
-+
-+struct CREATE3resok {
-+ post_op_fh3 obj;
-+ post_op_attr obj_attributes;
-+ wcc_data dir_wcc;
-+};
-+
-+struct CREATE3resfail {
-+ wcc_data dir_wcc;
-+};
-+
-+union CREATE3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ CREATE3resok resok;
-+default:
-+ CREATE3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to mkdir (v3).
-+ */
-+struct MKDIR3args {
-+ diropargs3 where;
-+ sattr3 attributes;
-+};
-+
-+struct MKDIR3resok {
-+ post_op_fh3 obj;
-+ post_op_attr obj_attributes;
-+ wcc_data dir_wcc;
-+};
-+
-+struct MKDIR3resfail {
-+ wcc_data dir_wcc;
-+};
-+
-+union MKDIR3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ MKDIR3resok resok;
-+default:
-+ MKDIR3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to symlink (v3).
-+ */
-+struct symlinkdata3 {
-+ sattr3 symlink_attributes;
-+ nfspath3 symlink_data;
-+};
-+
-+struct SYMLINK3args {
-+ diropargs3 where;
-+ symlinkdata3 symlink;
-+};
-+
-+struct SYMLINK3resok {
-+ post_op_fh3 obj;
-+ post_op_attr obj_attributes;
-+ wcc_data dir_wcc;
-+};
-+
-+struct SYMLINK3resfail {
-+ wcc_data dir_wcc;
-+};
-+
-+union SYMLINK3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ SYMLINK3resok resok;
-+default:
-+ SYMLINK3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to mknod (v3).
-+ */
-+struct devicedata3 {
-+ sattr3 dev_attributes;
-+ specdata3 spec;
-+};
-+
-+union mknoddata3 switch (ftype3 type) {
-+case NF3CHR:
-+case NF3BLK:
-+ devicedata3 device;
-+case NF3SOCK:
-+case NF3FIFO:
-+ sattr3 pipe_attributes;
-+default:
-+ void;
-+};
-+
-+struct MKNOD3args {
-+ diropargs3 where;
-+ mknoddata3 what;
-+};
-+
-+struct MKNOD3resok {
-+ post_op_fh3 obj;
-+ post_op_attr obj_attributes;
-+ wcc_data dir_wcc;
-+};
-+
-+struct MKNOD3resfail {
-+ wcc_data dir_wcc;
-+};
-+
-+union MKNOD3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ MKNOD3resok resok;
-+default:
-+ MKNOD3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to remove (v3).
-+ */
-+struct REMOVE3args {
-+ diropargs3 object;
-+};
-+
-+struct REMOVE3resok {
-+ wcc_data dir_wcc;
-+};
-+
-+struct REMOVE3resfail {
-+ wcc_data dir_wcc;
-+};
-+
-+union REMOVE3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ REMOVE3resok resok;
-+default:
-+ REMOVE3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to rmdir (v3).
-+ */
-+struct RMDIR3args {
-+ diropargs3 object;
-+};
-+
-+struct RMDIR3resok {
-+ wcc_data dir_wcc;
-+};
-+
-+struct RMDIR3resfail {
-+ wcc_data dir_wcc;
-+};
-+
-+union RMDIR3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ RMDIR3resok resok;
-+default:
-+ RMDIR3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to rename (v3).
-+ */
-+struct RENAME3args {
-+ diropargs3 from;
-+ diropargs3 to;
-+};
-+
-+struct RENAME3resok {
-+ wcc_data fromdir_wcc;
-+ wcc_data todir_wcc;
-+};
-+
-+struct RENAME3resfail {
-+ wcc_data fromdir_wcc;
-+ wcc_data todir_wcc;
-+};
-+
-+union RENAME3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ RENAME3resok resok;
-+default:
-+ RENAME3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to link (v3).
-+ */
-+struct LINK3args {
-+ nfs_fh3 file;
-+ diropargs3 link;
-+};
-+
-+struct LINK3resok {
-+ post_op_attr file_attributes;
-+ wcc_data linkdir_wcc;
-+};
-+
-+struct LINK3resfail {
-+ post_op_attr file_attributes;
-+ wcc_data linkdir_wcc;
-+};
-+
-+union LINK3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ LINK3resok resok;
-+default:
-+ LINK3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to readdir (v3).
-+ */
-+struct READDIR3args {
-+ nfs_fh3 dir;
-+ cookie3 cookie;
-+ cookieverf3 cookieverf;
-+ count3 count;
-+};
-+
-+struct entry3 {
-+ fileid3 fileid;
-+ filename3 name;
-+ cookie3 cookie;
-+ entry3 *nextentry;
-+};
-+
-+struct dirlist3 {
-+ entry3 *entries;
-+ bool eof;
-+};
-+
-+struct READDIR3resok {
-+ post_op_attr dir_attributes;
-+ cookieverf3 cookieverf;
-+ dirlist3 reply;
-+};
-+
-+struct READDIR3resfail {
-+ post_op_attr dir_attributes;
-+};
-+
-+union READDIR3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ READDIR3resok resok;
-+default:
-+ READDIR3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to readdirplus (v3).
-+ */
-+struct READDIRPLUS3args {
-+ nfs_fh3 dir;
-+ cookie3 cookie;
-+ cookieverf3 cookieverf;
-+ count3 dircount;
-+ count3 maxcount;
-+};
-+
-+struct entryplus3 {
-+ fileid3 fileid;
-+ filename3 name;
-+ cookie3 cookie;
-+ post_op_attr name_attributes;
-+ post_op_fh3 name_handle;
-+ entryplus3 *nextentry;
-+};
-+
-+struct dirlistplus3 {
-+ entryplus3 *entries;
-+ bool eof;
-+};
-+
-+struct READDIRPLUS3resok {
-+ post_op_attr dir_attributes;
-+ cookieverf3 cookieverf;
-+ dirlistplus3 reply;
-+};
-+
-+struct READDIRPLUS3resfail {
-+ post_op_attr dir_attributes;
-+};
-+
-+union READDIRPLUS3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ READDIRPLUS3resok resok;
-+default:
-+ READDIRPLUS3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to fsstat (v3).
-+ */
-+struct FSSTAT3args {
-+ nfs_fh3 fsroot;
-+};
-+
-+struct FSSTAT3resok {
-+ post_op_attr obj_attributes;
-+ size3 tbytes;
-+ size3 fbytes;
-+ size3 abytes;
-+ size3 tfiles;
-+ size3 ffiles;
-+ size3 afiles;
-+ uint32 invarsec;
-+};
-+
-+struct FSSTAT3resfail {
-+ post_op_attr obj_attributes;
-+};
-+
-+union FSSTAT3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ FSSTAT3resok resok;
-+default:
-+ FSSTAT3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to fsinfo (v3).
-+ */
-+const FSF3_LINK = 0x0001;
-+const FSF3_SYMLINK = 0x0002;
-+const FSF3_HOMOGENEOUS = 0x0008;
-+const FSF3_CANSETTIME = 0x0010;
-+
-+struct FSINFO3args {
-+ nfs_fh3 fsroot;
-+};
-+
-+struct FSINFO3resok {
-+ post_op_attr obj_attributes;
-+ uint32 rtmax;
-+ uint32 rtpref;
-+ uint32 rtmult;
-+ uint32 wtmax;
-+ uint32 wtpref;
-+ uint32 wtmult;
-+ uint32 dtpref;
-+ size3 maxfilesize;
-+ nfstime3 time_delta;
-+ uint32 properties;
-+};
-+
-+struct FSINFO3resfail {
-+ post_op_attr obj_attributes;
-+};
-+
-+union FSINFO3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ FSINFO3resok resok;
-+default:
-+ FSINFO3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to pathconf (v3).
-+ */
-+struct PATHCONF3args {
-+ nfs_fh3 object;
-+};
-+
-+struct PATHCONF3resok {
-+ post_op_attr obj_attributes;
-+ uint32 linkmax;
-+ uint32 name_max;
-+ bool no_trunc;
-+ bool chown_restricted;
-+ bool case_insensitive;
-+ bool case_preserving;
-+};
-+
-+struct PATHCONF3resfail {
-+ post_op_attr obj_attributes;
-+};
-+
-+union PATHCONF3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ PATHCONF3resok resok;
-+default:
-+ PATHCONF3resfail resfail;
-+};
-+
-+/*
-+ * Arguments to commit (v3).
-+ */
-+struct COMMIT3args {
-+ nfs_fh3 file;
-+ offset3 offset;
-+ count3 count;
-+};
-+
-+struct COMMIT3resok {
-+ wcc_data file_wcc;
-+ writeverf3 verf;
-+};
-+
-+struct COMMIT3resfail {
-+ wcc_data file_wcc;
-+};
-+
-+union COMMIT3res switch (nfsstat3 status) {
-+case NFS3_OK:
-+ COMMIT3resok resok;
-+default:
-+ COMMIT3resfail resfail;
-+};
-+
-+#endif /* WANT_NFS3 */
-+
-+/*
-+ * Remote file service routines
-+ */
-+program NFS_PROGRAM {
-+ version NFS_VERSION {
-+ void
-+ NFSPROC_NULL(void) = 0;
-+
-+ attrstat
-+ NFSPROC_GETATTR(nfs_fh) = 1;
-+
-+ attrstat
-+ NFSPROC_SETATTR(sattrargs) = 2;
-+
-+ void
-+ NFSPROC_ROOT(void) = 3;
-+
-+ diropres
-+ NFSPROC_LOOKUP(diropargs) = 4;
-+
-+ readlinkres
-+ NFSPROC_READLINK(nfs_fh) = 5;
-+
-+ readres
-+ NFSPROC_READ(readargs) = 6;
-+
-+ void
-+ NFSPROC_WRITECACHE(void) = 7;
-+
-+ attrstat
-+ NFSPROC_WRITE(writeargs) = 8;
-+
-+ diropres
-+ NFSPROC_CREATE(createargs) = 9;
-+
-+ nfsstat
-+ NFSPROC_REMOVE(diropargs) = 10;
-+
-+ nfsstat
-+ NFSPROC_RENAME(renameargs) = 11;
-+
-+ nfsstat
-+ NFSPROC_LINK(linkargs) = 12;
-+
-+ nfsstat
-+ NFSPROC_SYMLINK(symlinkargs) = 13;
-+
-+ diropres
-+ NFSPROC_MKDIR(createargs) = 14;
-+
-+ nfsstat
-+ NFSPROC_RMDIR(diropargs) = 15;
-+
-+ readdirres
-+ NFSPROC_READDIR(readdirargs) = 16;
-+
-+ statfsres
-+ NFSPROC_STATFS(nfs_fh) = 17;
-+ } = 2;
-+} = 100003;
-+#ifdef WANT_NFS3
-+program NFS3_PROGRAM {
-+ version NFS_V3 {
-+ void
-+ NFSPROC3_NULL(void) = 0;
-+
-+ GETATTR3res
-+ NFSPROC3_GETATTR(GETATTR3args) = 1;
-+
-+ SETATTR3res
-+ NFSPROC3_SETATTR(SETATTR3args) = 2;
-+
-+ LOOKUP3res
-+ NFSPROC3_LOOKUP(LOOKUP3args) = 3;
-+
-+ ACCESS3res
-+ NFSPROC3_ACCESS(ACCESS3args) = 4;
-+
-+ READLINK3res
-+ NFSPROC3_READLINK(READLINK3args) = 5;
-+
-+ READ3res
-+ NFSPROC3_READ(READ3args) = 6;
-+
-+ WRITE3res
-+ NFSPROC3_WRITE(WRITE3args) = 7;
-+
-+ CREATE3res
-+ NFSPROC3_CREATE(CREATE3args) = 8;
-+
-+ MKDIR3res
-+ NFSPROC3_MKDIR(MKDIR3args) = 9;
-+
-+ SYMLINK3res
-+ NFSPROC3_SYMLINK(SYMLINK3args) = 10;
-+
-+ MKNOD3res
-+ NFSPROC3_MKNOD(MKNOD3args) = 11;
-+
-+ REMOVE3res
-+ NFSPROC3_REMOVE(REMOVE3args) = 12;
-+
-+ RMDIR3res
-+ NFSPROC3_RMDIR(RMDIR3args) = 13;
-+
-+ RENAME3res
-+ NFSPROC3_RENAME(RENAME3args) = 14;
-+
-+ LINK3res
-+ NFSPROC3_LINK(LINK3args) = 15;
-+
-+ READDIR3res
-+ NFSPROC3_READDIR(READDIR3args) = 16;
-+
-+ READDIRPLUS3res
-+ NFSPROC3_READDIRPLUS(READDIRPLUS3args) = 17;
-+
-+ FSSTAT3res
-+ NFSPROC3_FSSTAT(FSSTAT3args) = 18;
-+
-+ FSINFO3res
-+ NFSPROC3_FSINFO(FSINFO3args) = 19;
-+
-+ PATHCONF3res
-+ NFSPROC3_PATHCONF(PATHCONF3args) = 20;
-+
-+ COMMIT3res
-+ NFSPROC3_COMMIT(COMMIT3args) = 21;
-+ } = 3;
-+} = 100003;
-+#endif
-+
-diff --git a/tirpc/rpcsvc/rquota.x b/tirpc/rpcsvc/rquota.x
-new file mode 100644
-index 0000000..72864d1
---- /dev/null
-+++ b/tirpc/rpcsvc/rquota.x
-@@ -0,0 +1,67 @@
-+/*
-+ * Remote quota protocol
-+ * Requires unix authentication
-+ */
-+
-+#ifndef RPC_HDR
-+%#ifndef lint
-+%/*static char sccsid[] = "from: @(#)rquota.x 1.2 87/09/20 Copyr 1987 Sun Micro";*/
-+%/*static char sccsid[] = "from: @(#)rquota.x 2.1 88/08/01 4.0 RPCSRC";*/
-+%static const char rcsid[] =
-+% "$FreeBSD: src/include/rpcsvc/rquota.x,v 1.6 1999/08/27 23:45:10 peter Exp $";
-+%#endif /* not lint */
-+#endif
-+
-+const RQ_PATHLEN = 1024;
-+
-+struct getquota_args {
-+ string gqa_pathp<RQ_PATHLEN>; /* path to filesystem of interest */
-+ int gqa_uid; /* inquire about quota for uid */
-+};
-+
-+/*
-+ * remote quota structure
-+ */
-+struct rquota {
-+ int rq_bsize; /* block size for block counts */
-+ bool rq_active; /* indicates whether quota is active */
-+ unsigned int rq_bhardlimit; /* absolute limit on disk blks alloc */
-+ unsigned int rq_bsoftlimit; /* preferred limit on disk blks */
-+ unsigned int rq_curblocks; /* current block count */
-+ unsigned int rq_fhardlimit; /* absolute limit on allocated files */
-+ unsigned int rq_fsoftlimit; /* preferred file limit */
-+ unsigned int rq_curfiles; /* current # allocated files */
-+ unsigned int rq_btimeleft; /* time left for excessive disk use */
-+ unsigned int rq_ftimeleft; /* time left for excessive files */
-+};
-+
-+enum gqr_status {
-+ Q_OK = 1, /* quota returned */
-+ Q_NOQUOTA = 2, /* noquota for uid */
-+ Q_EPERM = 3 /* no permission to access quota */
-+};
-+
-+union getquota_rslt switch (gqr_status status) {
-+case Q_OK:
-+ rquota gqr_rquota; /* valid if status == Q_OK */
-+case Q_NOQUOTA:
-+ void;
-+case Q_EPERM:
-+ void;
-+};
-+
-+program RQUOTAPROG {
-+ version RQUOTAVERS {
-+ /*
-+ * Get all quotas
-+ */
-+ getquota_rslt
-+ RQUOTAPROC_GETQUOTA(getquota_args) = 1;
-+
-+ /*
-+ * Get active quotas only
-+ */
-+ getquota_rslt
-+ RQUOTAPROC_GETACTIVEQUOTA(getquota_args) = 2;
-+ } = 1;
-+} = 100011;
---
-2.0.0
-
projects / buildroot.git / commitdiff