libtirpc: add patches to fix a number of issues

libtirpc-0005-rpcent-mark-getrpcbyname-name-argument-as-const-char.patch
fixes build failures like
http://autobuild.buildroot.org/results/7a3a751fe02c639ca75c575ca7fe20a72372b8d6/build-end.log.

libtirpc-0006-rpcent-remove-prototypes-of-reentrant-variants.patch
ensures that functions not implemented by libtirpc are not described
in a header file. It also allows to remove those prototypes that were
not matching the functions available in glibc or uClibc, causing
mismatch in prototypes.

libtirpc-0007-doc-Makefile.am-fix-out-of-tree-installation.patch is a
minor fix.

The following patches (8 to 9) allow libtirpc to provide sufficient
things to be able to build rpcbind on top of it.

All these patches have been submitted upstream on the libtirpc-devel@
mailing list.

Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
Acked-by: Arnout Vandecappelle (Essensium/Mind) <arnout@mind.be>
Signed-off-by: Peter Korsgaard <jacmet@sunsite.dk>

1 files changed, 6504 insertions, 0 deletions

diff --git a/package/libtirpc/libtirpc-0008-Add-rpcgen-program-from-nfs-utils-sources.patch b/package/libtirpc/libtirpc-0008-Add-rpcgen-program-from-nfs-utils-sources.patch
new file mode 100644
index 000000000..27c60649d
--- /dev/null
+++ b/package/libtirpc/libtirpc-0008-Add-rpcgen-program-from-nfs-utils-sources.patch
@@ -0,0 +1,6504 @@
+From 8a1ee148ea860c20fa4e076839e5681412a11f7e 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         |   12 +-
+ 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, 6342 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 1a7596b..afb4e38 100644
+--- a/Makefile.am
++++ b/Makefile.am
+@@ -1,4 +1,4 @@
+-SUBDIRS = src man doc
++SUBDIRS = src man doc rpcgen
+ ACLOCAL_AMFLAGS = -I m4
+ 
+ nobase_include_HEADERS = tirpc/netconfig.h \
+diff --git a/configure.ac b/configure.ac
+index 487ec83..7f35b48 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -29,6 +29,16 @@ AC_CHECK_HEADER(netinet/ip6.h,
+ 
+ AC_CHECK_LIB([pthread], [pthread_create])
+ 
++AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
+ 
+-AC_CONFIG_FILES([Makefile src/Makefile man/Makefile doc/Makefile])
++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
+-- 
+1.7.9.5
+