From: Yann E. MORIN Date: Thu, 27 Nov 2014 21:28:46 +0000 (+0100) Subject: package/libtirpc: rename patches X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=5acbbad05cfccc86236657750a57157ec58b1c1b;p=buildroot.git package/libtirpc: rename patches Signed-off-by: "Yann E. MORIN" Signed-off-by: Peter Korsgaard --- diff --git a/package/libtirpc/0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch b/package/libtirpc/0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch new file mode 100644 index 0000000000..9bcca8aa94 --- /dev/null +++ b/package/libtirpc/0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch @@ -0,0 +1,70 @@ +From 4285205401faeb12b4ed7ebbc4658af9eae73eb4 Mon Sep 17 00:00:00 2001 +From: Thomas Petazzoni +Date: Sat, 23 Jun 2012 21:57:39 +0200 +Subject: [PATCH] Disable parts of TIRPC requiring NIS support + +Signed-off-by: Thomas Petazzoni +--- + src/Makefile.am | 3 +-- + src/rpc_soc.c | 2 ++ + tirpc/rpc/auth.h | 3 +++ + 3 files changed, 6 insertions(+), 2 deletions(-) + +diff --git a/src/Makefile.am b/src/Makefile.am +index 3029b78..b5db263 100644 +--- a/src/Makefile.am ++++ b/src/Makefile.am +@@ -50,8 +50,7 @@ libtirpc_la_SOURCES = auth_none.c auth_unix.c authunix_prot.c bindresvport.c cln + pmap_prot.c pmap_prot2.c pmap_rmt.c rpc_prot.c rpc_commondata.c \ + rpc_callmsg.c rpc_generic.c rpc_soc.c rpcb_clnt.c rpcb_prot.c \ + rpcb_st_xdr.c svc.c svc_auth.c svc_dg.c svc_auth_unix.c svc_auth_none.c \ +- svc_generic.c svc_raw.c svc_run.c svc_simple.c svc_vc.c getpeereid.c \ +- auth_time.c auth_des.c authdes_prot.c ++ svc_generic.c svc_raw.c svc_run.c svc_simple.c svc_vc.c getpeereid.c + + ## XDR + libtirpc_la_SOURCES += xdr.c xdr_rec.c xdr_array.c xdr_float.c xdr_mem.c xdr_reference.c xdr_stdio.c +diff --git a/src/rpc_soc.c b/src/rpc_soc.c +index 4213ca0..2603548 100644 +--- a/src/rpc_soc.c ++++ b/src/rpc_soc.c +@@ -520,6 +520,7 @@ clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult) + (resultproc_t) rpc_wrap_bcast, "udp"); + } + ++#if 0 + /* + * Create the client des authentication object. Obsoleted by + * authdes_seccreate(). +@@ -551,6 +552,7 @@ fallback: + dummy = authdes_seccreate(servername, window, NULL, ckey); + return (dummy); + } ++#endif + + /* + * Create a client handle for a unix connection. Obsoleted by clnt_vc_create() +diff --git a/tirpc/rpc/auth.h b/tirpc/rpc/auth.h +index 4ce11f0..b894e44 100644 +--- a/tirpc/rpc/auth.h ++++ b/tirpc/rpc/auth.h +@@ -305,6 +305,8 @@ extern AUTH *authunix_create(char *, uid_t, uid_t, int, uid_t *); + extern AUTH *authunix_create_default(void); /* takes no parameters */ + extern AUTH *authnone_create(void); /* takes no parameters */ + __END_DECLS ++ ++#if 0 + /* + * DES style authentication + * AUTH *authsecdes_create(servername, window, timehost, ckey) +@@ -318,6 +320,7 @@ extern AUTH *authdes_create (char *, u_int, struct sockaddr *, des_block *); + extern AUTH *authdes_seccreate (const char *, const u_int, const char *, + const des_block *); + __END_DECLS ++#endif + + __BEGIN_DECLS + extern bool_t xdr_opaque_auth (XDR *, struct opaque_auth *); +-- +2.0.0 + diff --git a/package/libtirpc/0002-uClibc-without-RPC-support-does-not-install-rpcent.h.patch b/package/libtirpc/0002-uClibc-without-RPC-support-does-not-install-rpcent.h.patch new file mode 100644 index 0000000000..6ec5d8e43d --- /dev/null +++ b/package/libtirpc/0002-uClibc-without-RPC-support-does-not-install-rpcent.h.patch @@ -0,0 +1,29 @@ +From a20f33ad121fb1e9d1fbc31a0044546450677e7a Mon Sep 17 00:00:00 2001 +From: Thomas Petazzoni +Date: Sat, 23 Jun 2012 21:58:07 +0200 +Subject: [PATCH] uClibc without RPC support does not install rpcent.h + +Signed-off-by: Thomas Petazzoni +--- + tirpc/rpc/rpcent.h | 5 +++-- + 1 file changed, 3 insertions(+), 2 deletions(-) + +diff --git a/tirpc/rpc/rpcent.h b/tirpc/rpc/rpcent.h +index c865e51..45775ed 100644 +--- a/tirpc/rpc/rpcent.h ++++ b/tirpc/rpc/rpcent.h +@@ -46,8 +46,9 @@ + + __BEGIN_DECLS + +-/* These are defined in /usr/include/rpc/netdb.h */ +-#if 0 ++/* These are defined in /usr/include/rpc/netdb.h, unless we are using ++ the C library without RPC support. */ ++#if defined(__UCLIBC__) && !defined(__UCLIBC_HAS_RPC__) + struct rpcent { + char *r_name; /* name of server for this rpc program */ + char **r_aliases; /* alias list */ +-- +2.0.0 + diff --git a/package/libtirpc/0003-Make-IPv6-support-optional.patch b/package/libtirpc/0003-Make-IPv6-support-optional.patch new file mode 100644 index 0000000000..ad8ce653e0 --- /dev/null +++ b/package/libtirpc/0003-Make-IPv6-support-optional.patch @@ -0,0 +1,26 @@ +From fbe5fccf0e3bdaae3defc66a288176797fd12a17 Mon Sep 17 00:00:00 2001 +From: Thomas Petazzoni +Date: Sun, 24 Jun 2012 21:40:21 +0200 +Subject: [PATCH] Make IPv6 support optional + +Signed-off-by: Thomas Petazzoni +--- + src/Makefile.am | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/Makefile.am b/src/Makefile.am +index b5db263..f086255 100644 +--- a/src/Makefile.am ++++ b/src/Makefile.am +@@ -7,7 +7,7 @@ + + noinst_HEADERS = rpc_com.h + +-AM_CPPFLAGS = -I$(top_srcdir)/tirpc -DPORTMAP -DINET6 \ ++AM_CPPFLAGS = -I$(top_srcdir)/tirpc -DPORTMAP \ + -D_GNU_SOURCE -Wall -pipe + + lib_LTLIBRARIES = libtirpc.la +-- +2.0.0 + diff --git a/package/libtirpc/0004-Add-rpcgen-program-from-nfs-utils-sources.patch b/package/libtirpc/0004-Add-rpcgen-program-from-nfs-utils-sources.patch new file mode 100644 index 0000000000..195803ca04 --- /dev/null +++ b/package/libtirpc/0004-Add-rpcgen-program-from-nfs-utils-sources.patch @@ -0,0 +1,6505 @@ +From c4c4550dafabda05d78ca4aa9969db8a4f70affe Mon Sep 17 00:00:00 2001 +From: Thomas Petazzoni +Date: Sat, 10 Nov 2012 16:21:01 +0100 +Subject: [PATCH] Add rpcgen program from nfs-utils sources + +Signed-off-by: Thomas Petazzoni +--- + Makefile.am | 2 +- + configure.ac | 14 +- + rpcgen/Makefile.am | 22 ++ + rpcgen/rpc_clntout.c | 217 ++++++++++ + rpcgen/rpc_cout.c | 706 +++++++++++++++++++++++++++++++++ + rpcgen/rpc_hout.c | 490 +++++++++++++++++++++++ + rpcgen/rpc_main.c | 1067 ++++++++++++++++++++++++++++++++++++++++++++++++++ + rpcgen/rpc_output.h | 16 + + rpcgen/rpc_parse.c | 609 ++++++++++++++++++++++++++++ + rpcgen/rpc_parse.h | 166 ++++++++ + rpcgen/rpc_sample.c | 247 ++++++++++++ + rpcgen/rpc_scan.c | 474 ++++++++++++++++++++++ + rpcgen/rpc_scan.h | 103 +++++ + rpcgen/rpc_svcout.c | 882 +++++++++++++++++++++++++++++++++++++++++ + rpcgen/rpc_tblout.c | 165 ++++++++ + rpcgen/rpc_util.c | 479 ++++++++++++++++++++++ + rpcgen/rpc_util.h | 166 ++++++++ + rpcgen/rpcgen.1 | 521 ++++++++++++++++++++++++ + 18 files changed, 6344 insertions(+), 2 deletions(-) + create mode 100644 rpcgen/Makefile.am + create mode 100644 rpcgen/rpc_clntout.c + create mode 100644 rpcgen/rpc_cout.c + create mode 100644 rpcgen/rpc_hout.c + create mode 100644 rpcgen/rpc_main.c + create mode 100644 rpcgen/rpc_output.h + create mode 100644 rpcgen/rpc_parse.c + create mode 100644 rpcgen/rpc_parse.h + create mode 100644 rpcgen/rpc_sample.c + create mode 100644 rpcgen/rpc_scan.c + create mode 100644 rpcgen/rpc_scan.h + create mode 100644 rpcgen/rpc_svcout.c + create mode 100644 rpcgen/rpc_tblout.c + create mode 100644 rpcgen/rpc_util.c + create mode 100644 rpcgen/rpc_util.h + create mode 100644 rpcgen/rpcgen.1 + +diff --git a/Makefile.am b/Makefile.am +index 9b812eb..6edf029 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -1,4 +1,4 @@ +-SUBDIRS = src man doc ++SUBDIRS = src man doc rpcgen + ACLOCAL_AMFLAGS = -I m4 + + noinst_HEADERS = tirpc/reentrant.h \ +diff --git a/configure.ac b/configure.ac +index 11df020..4110225 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -34,5 +34,17 @@ AC_CHECK_LIB([pthread], [pthread_create]) + AC_CHECK_LIB([nsl], [yp_get_default_domain]) + + +-AC_CONFIG_FILES([Makefile src/Makefile man/Makefile doc/Makefile]) ++AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes) ++ ++AC_MSG_CHECKING([for a C compiler for build tools]) ++if test $cross_compiling = yes; then ++ AC_CHECK_PROGS(CC_FOR_BUILD, gcc cc) ++else ++ CC_FOR_BUILD=$CC ++fi ++AC_MSG_RESULT([$CC_FOR_BUILD]) ++AC_SUBST(CC_FOR_BUILD) ++ ++AC_CONFIG_FILES([Makefile src/Makefile man/Makefile doc/Makefile rpcgen/Makefile]) ++ + AC_OUTPUT(libtirpc.pc) +diff --git a/rpcgen/Makefile.am b/rpcgen/Makefile.am +new file mode 100644 +index 0000000..2277b6f +--- /dev/null ++++ b/rpcgen/Makefile.am +@@ -0,0 +1,22 @@ ++COMPILE = $(CC_FOR_BUILD) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ ++ $(CPPFLAGS_FOR_BUILD) $(AM_CFLAGS) $(CFLAGS_FOR_BUILD) ++LINK = $(CC_FOR_BUILD) $(AM_CFLAGS) $(CFLAGS_FOR_BUILD) $(AM_LDFLAGS) $(LDFLAGS_FOR_BUILD) -o $@ ++ ++bin_PROGRAMS = rpcgen ++ ++rpcgen_SOURCES = \ ++ rpc_clntout.c \ ++ rpc_cout.c \ ++ rpc_hout.c \ ++ rpc_main.c \ ++ rpc_parse.c \ ++ rpc_sample.c \ ++ rpc_scan.c \ ++ rpc_svcout.c \ ++ rpc_tblout.c \ ++ rpc_util.c \ ++ rpc_parse.h \ ++ rpc_scan.h \ ++ rpc_util.h ++ ++dist_man1_MANS = rpcgen.1 +diff --git a/rpcgen/rpc_clntout.c b/rpcgen/rpc_clntout.c +new file mode 100644 +index 0000000..e2f4382 +--- /dev/null ++++ b/rpcgen/rpc_clntout.c +@@ -0,0 +1,217 @@ ++/* ++ * Copyright (c) 2009, Sun Microsystems, Inc. ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are met: ++ * - Redistributions of source code must retain the above copyright notice, ++ * this list of conditions and the following disclaimer. ++ * - Redistributions in binary form must reproduce the above copyright notice, ++ * this list of conditions and the following disclaimer in the documentation ++ * and/or other materials provided with the distribution. ++ * - Neither the name of Sun Microsystems, Inc. nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++#if 0 ++static char sccsid[] = "@(#)rpc_clntout.c 1.11 89/02/22 (C) 1987 SMI"; ++#endif ++ ++/* ++ * rpc_clntout.c, Client-stub outputter for the RPC protocol compiler ++ * Copyright (C) 1987, Sun Microsytsems, Inc. ++ */ ++#include ++#include ++#include ++#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 ++#include ++#include ++#include ++#include ++#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 ++#include ++#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 ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#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" : 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 \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 \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 \n"); ++ ++ f_print(fout, "#include \n"); ++ f_print(fout, "#include /* getenv, exit */\n"); ++ if (Cflag) { ++ f_print (fout, "#include /* for pmap_unset */\n"); ++ f_print (fout, "#include /* 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 \n"); ++ timerflag = 1; ++ } ++ ++#ifndef linux ++ if( !tirpcflag && inetdflag ) ++ f_print(fout, "#include /* TIOCNOTTY */\n"); ++#else ++ if( !tirpcflag ) ++ f_print(fout, "#include /* TIOCNOTTY */\n"); ++#endif ++ if( Cflag && (inetdflag || pmflag ) ) { ++ f_print(fout, "#ifdef __cplusplus\n"); ++ f_print(fout, "#include /* getdtablesize, open */\n"); ++ f_print(fout, "#endif /* __cplusplus */\n"); ++ ++ if( tirpcflag ) ++ f_print(fout, "#include /* setsid */\n"); ++ } ++ if( tirpcflag ) ++ f_print(fout, "#include \n"); ++ ++ f_print(fout, "#include \n"); ++#ifndef linux ++ f_print(fout, "#include \n"); ++#endif ++ if (inetdflag || !tirpcflag ) { ++ f_print(fout, "#include \n"); ++ f_print(fout, "#include \n"); ++ } ++ ++ if ( (netflag || pmflag) && tirpcflag ) { ++ f_print(fout, "#include \n"); ++ } ++ if (/*timerflag &&*/ tirpcflag) ++ f_print(fout, "#include /* rlimit */\n"); ++ if (logflag || inetdflag || pmflag) { ++#ifdef linux ++ f_print(fout, "#include \n"); ++#else ++ f_print(fout, "#ifdef SYSLOG\n"); ++ f_print(fout, "#include \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 /* for memset */\n"); ++ if (infile && (include = extendfile(infile, ".h"))) { ++ f_print(fout, "#include \"%s\"\n", include); ++ free(include); ++ } else ++ f_print(fout, "#include \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 \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 \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 ++#include ++#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 ++#include ++#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 ++#include ++#include ++#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 ++#include ++#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 ++#include ++#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 ++#include ++#include ++#include ++#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 ++ ++#define alloc(size) malloc((unsigned)(size)) ++#define ALLOC(object) (object *) malloc(sizeof(object)) ++ ++#define s_print (void) sprintf ++#define f_print (void) fprintf ++ ++struct list { ++ definition *val; ++ struct list *next; ++}; ++typedef struct list list; ++ ++#define PUT 1 ++#define GET 2 ++ ++/* ++ * Global variables ++ */ ++#define MAXLINESIZE 1024 ++extern char curline[MAXLINESIZE]; ++extern char *where; ++extern int linenum; ++ ++extern char *infilename; ++extern FILE *fout; ++extern FILE *fin; ++ ++extern list *defined; ++ ++ ++extern bas_type *typ_list_h; ++extern bas_type *typ_list_t; ++ ++/* ++ * All the option flags ++ */ ++extern int inetdflag; ++extern int pmflag; ++extern int tblflag; ++extern int logflag; ++extern int newstyle; ++extern int Cflag; /* C++ flag */ ++extern int tirpcflag; /* flag for generating tirpc code */ ++extern int Inline; /* if this is 0, then do not generate inline code */ ++ ++/* ++ * Other flags related with inetd jumpstart. ++ */ ++extern int indefinitewait; ++extern int exitnow; ++extern int timerflag; ++ ++extern int nonfatalerrors; ++ ++/* ++ * rpc_util routines ++ */ ++void storeval(); ++ ++#define STOREVAL(list,item) \ ++ storeval(list,item) ++ ++definition *findval(); ++ ++#define FINDVAL(list,item,finder) \ ++ findval(list, item, finder) ++ ++ ++/* ++ * rpc_cout routines ++ */ ++void cprint(void); ++void emit(definition *); ++ ++/* ++ * rpc_hout routines ++ */ ++void print_datadef(definition *); ++void print_funcdef(definition *); ++ ++/* ++ * rpc_svcout routines ++ */ ++void write_most(char *, int, int); ++void write_register(void); ++void write_netid_register(char *); ++void write_nettype_register(char *); ++void write_inetd_register(char *); ++void write_rest(void); ++void write_programs(char *); ++void write_svc_aux(int); ++ ++/* ++ * rpc_clntout routines ++ */ ++void write_stubs(void); ++void printarglist(proc_list *, char *, char *); ++ ++/* ++ * rpc_tblout routines ++ */ ++void write_tables(void); ++ ++/* ++ * rpc_util ++ */ ++void pvname_svc(char *, char *); ++void pvname(char *, char *); ++void ptype(char *, char *, int); ++char * make_argname(char *, char *); ++void add_type(int, char *); ++void reinitialize(void); ++void crash(void); ++void error(char *); ++char *fixtype(char *); ++char *stringfix(char *); ++char *locase(char *); ++int isvectordef(char *, relation); ++int streq(char *, char *); ++void tabify(FILE *, int); ++void record_open(char *); ++bas_type *find_type(char *type); ++ ++/* ++ * rpc_sample ++ */ ++void write_sample_svc(definition *); ++int write_sample_clnt(definition *); ++void write_sample_clnt_main(void); ++void add_sample_msg(void); +diff --git a/rpcgen/rpcgen.1 b/rpcgen/rpcgen.1 +new file mode 100644 +index 0000000..89df7ed +--- /dev/null ++++ b/rpcgen/rpcgen.1 +@@ -0,0 +1,521 @@ ++.\" @(#)rpcgen.1 1.35 93/06/02 SMI ++.\" $FreeBSD: src/usr.bin/rpcgen/rpcgen.1,v 1.12.2.4 2002/06/21 15:28:50 charnier Exp $ ++.\" Copyright 1985-1993 Sun Microsystems, Inc. ++.Dd March 28, 1993 ++.Dt RPCGEN 1 ++.Os ++.Sh NAME ++.Nm rpcgen ++.Nd an RPC protocol compiler ++.Sh SYNOPSIS ++.Nm ++.Ar infile ++.Nm ++.Op Fl a ++.Op Fl b ++.Op Fl C ++.Oo ++.Fl D Ns Ar name Ns Op Ar =value ++.Oc ++.Op Fl i Ar size ++.Op Fl I Op Fl K Ar seconds ++.Op Fl L ++.Op Fl M ++.Op Fl N ++.Op Fl T ++.Op Fl Y Ar pathname ++.Ar infile ++.Nm ++.Oo ++.Fl c | ++.Fl h | ++.Fl l | ++.Fl m | ++.Fl t | ++.Fl \&Sc | ++.Fl \&Ss | ++.Fl \&Sm ++.Oc ++.Op Fl o Ar outfile ++.Op Ar infile ++.Nm ++.Op Fl s Ar nettype ++.Op Fl o Ar outfile ++.Op Ar infile ++.Nm ++.Op Fl n Ar netid ++.Op Fl o Ar outfile ++.Op Ar infile ++.\" .SH AVAILABILITY ++.\" .LP ++.\" SUNWcsu ++.Sh DESCRIPTION ++The ++.Nm ++utility is a tool that generates C code to implement an ++.Tn RPC ++protocol. ++The input to ++.Nm ++is a language similar to C known as ++.Tn RPC ++Language (Remote Procedure Call Language). ++.Pp ++The ++.Nm ++utility is normally used as in the first synopsis where ++it takes an input file and generates three output files. ++If the ++.Ar infile ++is named ++.Pa proto.x , ++then ++.Nm ++generates a header in ++.Pa proto.h , ++XDR routines in ++.Pa proto_xdr.c , ++server-side stubs in ++.Pa proto_svc.c , ++and client-side stubs in ++.Pa proto_clnt.c . ++With the ++.Fl T ++option, ++it also generates the ++.Tn RPC ++dispatch table in ++.Pa proto_tbl.i . ++.Pp ++The ++.Nm ++utility can also generate sample client and server files ++that can be customized to suit a particular application. ++The ++.Fl \&Sc , ++.Fl \&Ss ++and ++.Fl \&Sm ++options generate sample client, server and makefile, respectively. ++The ++.Fl a ++option generates all files, including sample files. ++If the ++.Ar infile ++is ++.Pa proto.x , ++then the client side sample file is written to ++.Pa proto_client.c , ++the server side sample file to ++.Pa proto_server.c ++and the sample makefile to ++.Pa makefile.proto . ++.Pp ++The server created can be started both by the port monitors ++(for example, ++.Xr inetd 8 ) ++or by itself. ++When it is started by a port monitor, ++it creates servers only for the transport for which ++the file descriptor ++.Em 0 ++was passed. ++The name of the transport must be specified ++by setting up the environment variable ++.Ev PM_TRANSPORT . ++When the server generated by ++.Nm ++is executed, ++it creates server handles for all the transports ++specified in ++.Ev NETPATH ++environment variable, ++or if it is unset, ++it creates server handles for all the visible transports from ++.Pa /etc/netconfig ++file. ++Note: ++the transports are chosen at run time and not at compile time. ++When the server is self-started, ++it backgrounds itself by default. ++A special define symbol ++.Em RPC_SVC_FG ++can be used to run the server process in foreground. ++.Pp ++The second synopsis provides special features which allow ++for the creation of more sophisticated ++.Tn RPC ++servers. ++These features include support for user provided ++.Em #defines ++and ++.Tn RPC ++dispatch tables. ++The entries in the ++.Tn RPC ++dispatch table contain: ++.Bl -bullet -offset indent -compact ++.It ++pointers to the service routine corresponding to that procedure, ++.It ++a pointer to the input and output arguments, ++.It ++the size of these routines. ++.El ++A server can use the dispatch table to check authorization ++and then to execute the service routine; ++a client library may use it to deal with the details of storage ++management and XDR data conversion. ++.Pp ++The other three synopses shown above are used when ++one does not want to generate all the output files, ++but only a particular one. ++See the ++.Sx EXAMPLES ++section below for examples of ++.Nm ++usage. ++When ++.Nm ++is executed with the ++.Fl s ++option, ++it creates servers for that particular class of transports. ++When ++executed with the ++.Fl n ++option, ++it creates a server for the transport specified by ++.Ar netid . ++If ++.Ar infile ++is not specified, ++.Nm ++accepts the standard input. ++.Pp ++The C preprocessor, ++.Em cc -E ++is run on the input file before it is actually interpreted by ++.Nm . ++For each type of output file, ++.Nm ++defines a special preprocessor symbol for use by the ++.Nm ++programmer: ++.Bl -tag -width indent ++.It RPC_HDR ++defined when compiling into headers ++.It RPC_XDR ++defined when compiling into XDR routines ++.It RPC_SVC ++defined when compiling into server-side stubs ++.It RPC_CLNT ++defined when compiling into client-side stubs ++.It RPC_TBL ++defined when compiling into RPC dispatch tables ++.El ++.Pp ++Any line beginning with ++.Dq % ++is passed directly into the output file, ++uninterpreted by ++.Nm . ++To specify the path name of the C preprocessor use ++.Fl Y ++flag. ++.Pp ++For every data type referred to in ++.Ar infile , ++.Nm ++assumes that there exists a ++routine with the string ++.Em xdr_ ++prepended to the name of the data type. ++If this routine does not exist in the ++.Tn RPC/XDR ++library, it must be provided. ++Providing an undefined data type ++allows customization of ++.Xr xdr 3 ++routines. ++.Sh OPTIONS ++The following options are available: ++.Bl -tag -width indent ++.It Fl a ++Generate all files, including sample files. ++.It Fl b ++Backward compatibility mode. ++Generate transport specific ++.Tn RPC ++code for older versions ++of the operating system. ++.Pp ++Note: in ++.Fx , ++this compatibility flag is turned on by ++default since ++.Fx ++supports only the older ++.Tn ONC RPC ++library. ++.It Fl c ++Compile into ++.Tn XDR ++routines. ++.It Fl C ++Generate header and stub files which can be used with ++.Tn ANSI ++C compilers. Headers generated with this flag can also be ++used with C++ programs. ++.It Fl D Ns Ar name ++.It Fl D Ns Ar name=value ++.\".It Fl D Ns Ar name Ns Op Ar =value ++Define a symbol ++.Ar name . ++Equivalent to the ++.Em #define ++directive in the source. ++If no ++.Ar value ++is given, ++.Ar value ++is defined as ++.Em 1 . ++This option may be specified more than once. ++.It Fl h ++Compile into C data-definitions (a header). ++.Fl T ++option can be used in conjunction to produce a ++header which supports ++.Tn RPC ++dispatch tables. ++.It Fl i Ar size ++Size at which to start generating inline code. ++This option is useful for optimization. ++The default size is 5. ++.Pp ++Note: in order to provide backwards compatibility with the older ++.Nm ++on the ++.Fx ++platform, the default is actually 0 (which means ++that inline code generation is disabled by default). You must specify ++a non-zero value explicitly to override this default. ++.It Fl I ++Compile support for ++.Xr inetd 8 ++in the server side stubs. ++Such servers can be self-started or can be started by ++.Nm inetd . ++When the server is self-started, it backgrounds itself by default. ++A special define symbol ++.Em RPC_SVC_FG ++can be used to run the ++server process in foreground, or the user may simply compile without ++the ++.Fl I ++option. ++.Pp ++If there are no pending client requests, the ++.Nm inetd ++servers exit after 120 seconds (default). ++The default can be changed with the ++.Fl K ++option. ++All the error messages for ++.Nm inetd ++servers ++are always logged with ++.Xr syslog 3 . ++.\" .IP ++.\" Note: ++.\" this option is supported for backward compatibility only. ++.\" By default, ++.\" .B rpcgen ++.\" generates servers that can be invoked through portmonitors. ++.Pp ++.It Fl K Ar seconds ++By default, services created using ++.Nm ++and invoked through ++port monitors wait 120 seconds ++after servicing a request before exiting. ++That interval can be changed using the ++.Fl K ++flag. ++To create a server that exits immediately upon servicing a request, ++use ++.Fl K Ar 0 . ++To create a server that never exits, the appropriate argument is ++.Fl k Ar -1 . ++.Pp ++When monitoring for a server, ++some portmonitors ++.Em always ++spawn a new process in response to a service request. ++If it is known that a server will be used with such a monitor, the ++server should exit immediately on completion. ++For such servers, ++.Nm ++should be used with ++.Fl K Ar 0 . ++.It Fl l ++Compile into client-side stubs. ++.It Fl L ++When the servers are started in foreground, use ++.Xr syslog 3 ++to log the server errors instead of printing them on the standard ++error. ++.It Fl m ++Compile into server-side stubs, ++but do not generate a ++.Qq main ++routine. ++This option is useful for doing callback-routines ++and for users who need to write their own ++.Qq main ++routine to do initialization. ++.It Fl M ++Generate multithread-safe stubs for passing arguments and results between ++rpcgen generated code and user written code. ++This option is useful ++for users who want to use threads in their code. ++However, the ++.Xr rpc_svc_calls 3 ++functions are not yet MT-safe, which means that rpcgen generated server-side ++code will not be MT-safe. ++.It Fl N ++This option allows procedures to have multiple arguments. ++It also uses the style of parameter passing that closely resembles C. ++So, when passing an argument to a remote procedure, you do not have to ++pass a pointer to the argument, but can pass the argument itself. ++This behavior is different from the old style of ++.Nm ++generated code. ++To maintain backward compatibility, ++this option is not the default. ++.It Fl n Ar netid ++Compile into server-side stubs for the transport ++specified by ++.Ar netid . ++There should be an entry for ++.Ar netid ++in the ++netconfig database. ++This option may be specified more than once, ++so as to compile a server that serves multiple transports. ++.It Fl o Ar outfile ++Specify the name of the output file. ++If none is specified, ++standard output is used ++( ++.Fl c , ++.Fl h , ++.Fl l , ++.Fl m , ++.Fl n , ++.Fl s , ++.Fl \&Sc , ++.Fl \&Sm , ++.Fl \&Ss , ++and ++.Fl t ++modes only). ++.It Fl s Ar nettype ++Compile into server-side stubs for all the ++transports belonging to the class ++.Ar nettype . ++The supported classes are ++.Em netpath , ++.Em visible , ++.Em circuit_n , ++.Em circuit_v , ++.Em datagram_n , ++.Em datagram_v , ++.Em tcp , ++and ++.Em udp ++(see ++.Xr rpc 3 ++for the meanings associated with these classes). ++This option may be specified more than once. ++Note: ++the transports are chosen at run time and not at compile time. ++.It Fl \&Sc ++Generate sample client code that uses remote procedure calls. ++.It Fl \&Sm ++Generate a sample ++.Pa Makefile ++which can be used for compiling the application. ++.It Fl \&Ss ++Generate sample server code that uses remote procedure calls. ++.It Fl t ++Compile into ++.Tn RPC ++dispatch table. ++.It Fl T ++Generate the code to support ++.Tn RPC ++dispatch tables. ++.Pp ++The options ++.Fl c , ++.Fl h , ++.Fl l , ++.Fl m , ++.Fl s , ++.Fl \&Sc , ++.Fl \&Sm , ++.Fl \&Ss , ++and ++.Fl t ++are used exclusively to generate a particular type of file, ++while the options ++.Fl D ++and ++.Fl T ++are global and can be used with the other options. ++.It Fl Y Ar pathname ++Give the name of the directory where ++.Nm ++will start looking for the C-preprocessor. ++.El ++.Sh EXAMPLES ++The following example: ++.Dl example% rpcgen -T prot.x ++.Pp ++generates all the five files: ++.Pa prot.h , ++.Pa prot_clnt.c , ++.Pa prot_svc.c , ++.Pa prot_xdr.c ++and ++.Pa prot_tbl.i . ++.Pp ++The following example sends the C data-definitions (header) ++to the standard output. ++.Dl example% rpcgen -h prot.x ++.Pp ++To send the test version of the ++.Fl D Ns Ar TEST , ++server side stubs for ++all the transport belonging to the class ++.Ar datagram_n ++to standard output, use: ++.Dl example% rpcgen -s datagram_n -DTEST prot.x ++.Pp ++To create the server side stubs for the transport indicated ++by ++.Ar netid ++tcp, ++use: ++.Dl example% rpcgen -n tcp -o prot_svc.c prot.x ++.Sh SEE ALSO ++.Xr cc 1 , ++.Xr rpc 3 , ++.Xr syslog 3 , ++.Xr inetd 8 ++.\" .BR rpc_svc_calls (3) ++.Rs ++.%T The rpcgen chapter in the NETP manual ++.Re +-- +2.0.0 + diff --git a/package/libtirpc/0005-Automatically-generate-XDR-header-files-from-.x-sour.patch b/package/libtirpc/0005-Automatically-generate-XDR-header-files-from-.x-sour.patch new file mode 100644 index 0000000000..3c1c82d0c7 --- /dev/null +++ b/package/libtirpc/0005-Automatically-generate-XDR-header-files-from-.x-sour.patch @@ -0,0 +1,1004 @@ +From 99ecb155efdfcf474c5701ab7e6ad1cbe88f500f Mon Sep 17 00:00:00 2001 +From: Thomas Petazzoni +Date: Sat, 10 Nov 2012 17:29:53 +0100 +Subject: [PATCH] Automatically generate XDR header files from .x sources using + rpcgen + +Signed-off-by: Thomas Petazzoni +--- + Makefile.am | 22 +- + src/Makefile.am | 2 +- + tirpc/rpc/rpcb_prot.h | 797 -------------------------------------------------- + tirpc/rpcsvc/crypt.h | 109 ------- + 4 files changed, 20 insertions(+), 910 deletions(-) + delete mode 100644 tirpc/rpc/rpcb_prot.h + delete mode 100644 tirpc/rpcsvc/crypt.h + +diff --git a/Makefile.am b/Makefile.am +index 6edf029..4e4dc32 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -1,6 +1,10 @@ + SUBDIRS = src man doc rpcgen + ACLOCAL_AMFLAGS = -I m4 + ++GENFILES = \ ++ tirpc/rpcsvc/crypt.h \ ++ tirpc/rpc/rpcb_prot.h ++ + noinst_HEADERS = tirpc/reentrant.h \ + tirpc/getpeereid.h \ + tirpc/libc_private.h \ +@@ -8,7 +12,6 @@ noinst_HEADERS = tirpc/reentrant.h \ + + nobase_include_HEADERS = tirpc/netconfig.h \ + tirpc/rpcsvc/crypt.x \ +- tirpc/rpcsvc/crypt.h \ + tirpc/rpc/xdr.h \ + tirpc/rpc/types.h \ + tirpc/rpc/svc_soc.h \ +@@ -20,7 +23,6 @@ nobase_include_HEADERS = tirpc/netconfig.h \ + tirpc/rpc/rpcent.h \ + tirpc/rpc/rpc_com.h \ + tirpc/rpc/rpcb_prot.x \ +- tirpc/rpc/rpcb_prot.h \ + tirpc/rpc/rpcb_clnt.h \ + tirpc/rpc/raw.h \ + tirpc/rpc/pmap_rmt.h \ +@@ -37,7 +39,21 @@ nobase_include_HEADERS = tirpc/netconfig.h \ + tirpc/rpc/auth.h \ + tirpc/rpc/auth_gss.h \ + tirpc/rpc/auth_des.h +- ++ ++nobase_nodist_include_HEADERS = $(GENFILES) ++BUILT_SOURCES = $(GENFILES) ++ ++$(GENFILES): %.h: %.x $(top_builddir)/rpcgen/rpcgen ++ mkdir -p $(dir $@) ++ $(top_builddir)/rpcgen/rpcgen -h -o $@ $< ++ ++$(top_builddir)/rpcgen/rpcgen: force ++ cd rpcgen && $(MAKE) ++ ++force: ++ ++CLEANFILES = $(GENFILES) ++ + pkgconfigdir=$(libdir)/pkgconfig + pkgconfig_DATA = libtirpc.pc + +diff --git a/src/Makefile.am b/src/Makefile.am +index f086255..a9db71b 100644 +--- a/src/Makefile.am ++++ b/src/Makefile.am +@@ -8,7 +8,7 @@ + noinst_HEADERS = rpc_com.h + + AM_CPPFLAGS = -I$(top_srcdir)/tirpc -DPORTMAP \ +- -D_GNU_SOURCE -Wall -pipe ++ -D_GNU_SOURCE -Wall -pipe -I$(top_builddir)/tirpc + + lib_LTLIBRARIES = libtirpc.la + +diff --git a/tirpc/rpc/rpcb_prot.h b/tirpc/rpc/rpcb_prot.h +deleted file mode 100644 +index 7ae48b8..0000000 +--- a/tirpc/rpc/rpcb_prot.h ++++ /dev/null +@@ -1,797 +0,0 @@ +-/* +- * Please do not edit this file. +- * It was generated using rpcgen. +- */ +- +-#ifndef _RPCB_PROT_H_RPCGEN +-#define _RPCB_PROT_H_RPCGEN +- +-#include +- +-#ifndef IXDR_GET_INT32 +-#define IXDR_GET_INT32(buf) IXDR_GET_LONG((buf)) +-#endif +-#ifndef IXDR_PUT_INT32 +-#define IXDR_PUT_INT32(buf, v) IXDR_PUT_LONG((buf), (v)) +-#endif +-#ifndef IXDR_GET_U_INT32 +-#define IXDR_GET_U_INT32(buf) IXDR_GET_U_LONG((buf)) +-#endif +-#ifndef IXDR_PUT_U_INT32 +-#define IXDR_PUT_U_INT32(buf, v) IXDR_PUT_U_LONG((buf), (v)) +-#endif +-/* +- * $FreeBSD: src/include/rpc/rpcb_prot.x,v 1.3 2002/03/13 10:29:06 obrien Exp $ +- * +- * Copyright (c) 2009, Sun Microsystems, Inc. +- * All rights reserved. +- * +- * Redistribution and use in source and binary forms, with or without +- * modification, are permitted provided that the following conditions are met: +- * - Redistributions of source code must retain the above copyright notice, +- * this list of conditions and the following disclaimer. +- * - Redistributions in binary form must reproduce the above copyright notice, +- * this list of conditions and the following disclaimer in the documentation +- * and/or other materials provided with the distribution. +- * - Neither the name of Sun Microsystems, Inc. nor the names of its +- * contributors may be used to endorse or promote products derived +- * from this software without specific prior written permission. +- * +- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +- * POSSIBILITY OF SUCH DAMAGE. +- */ +-/* +- * Copyright (c) 1988 by Sun Microsystems, Inc. +- */ +-/* from rpcb_prot.x */ +- +-/* #pragma ident "@(#)rpcb_prot.x 1.5 94/04/29 SMI" */ +- +-#ifndef _KERNEL +- +- +-/* +- * The following procedures are supported by the protocol in version 3: +- * +- * RPCBPROC_NULL() returns () +- * takes nothing, returns nothing +- * +- * RPCBPROC_SET(rpcb) returns (bool_t) +- * TRUE is success, FALSE is failure. Registers the tuple +- * [prog, vers, address, owner, netid]. +- * Finds out owner and netid information on its own. +- * +- * RPCBPROC_UNSET(rpcb) returns (bool_t) +- * TRUE is success, FALSE is failure. Un-registers tuple +- * [prog, vers, netid]. addresses is ignored. +- * If netid is NULL, unregister all. +- * +- * RPCBPROC_GETADDR(rpcb) returns (string). +- * 0 is failure. Otherwise returns the universal address where the +- * triple [prog, vers, netid] is registered. Ignore address and owner. +- * +- * RPCBPROC_DUMP() RETURNS (rpcblist_ptr) +- * used to dump the entire rpcbind maps +- * +- * RPCBPROC_CALLIT(rpcb_rmtcallargs) +- * RETURNS (rpcb_rmtcallres); +- * Calls the procedure on the remote machine. If it is not registered, +- * this procedure is quiet; i.e. it does not return error information!!! +- * This routine only passes null authentication parameters. +- * It has no interface to xdr routines for RPCBPROC_CALLIT. +- * +- * RPCBPROC_GETTIME() returns (int). +- * Gets the remote machines time +- * +- * RPCBPROC_UADDR2TADDR(strint) RETURNS (struct netbuf) +- * Returns the netbuf address from universal address. +- * +- * RPCBPROC_TADDR2UADDR(struct netbuf) RETURNS (string) +- * Returns the universal address from netbuf address. +- * +- * END OF RPCBIND VERSION 3 PROCEDURES +- */ +-/* +- * Except for RPCBPROC_CALLIT, the procedures above are carried over to +- * rpcbind version 4. Those below are added or modified for version 4. +- * NOTE: RPCBPROC_BCAST HAS THE SAME FUNCTIONALITY AND PROCEDURE NUMBER +- * AS RPCBPROC_CALLIT. +- * +- * RPCBPROC_BCAST(rpcb_rmtcallargs) +- * RETURNS (rpcb_rmtcallres); +- * Calls the procedure on the remote machine. If it is not registered, +- * this procedure IS quiet; i.e. it DOES NOT return error information!!! +- * This routine should be used for broadcasting and nothing else. +- * +- * RPCBPROC_GETVERSADDR(rpcb) returns (string). +- * 0 is failure. Otherwise returns the universal address where the +- * triple [prog, vers, netid] is registered. Ignore address and owner. +- * Same as RPCBPROC_GETADDR except that if the given version number +- * is not available, the address is not returned. +- * +- * RPCBPROC_INDIRECT(rpcb_rmtcallargs) +- * RETURNS (rpcb_rmtcallres); +- * Calls the procedure on the remote machine. If it is not registered, +- * this procedure is NOT quiet; i.e. it DOES return error information!!! +- * as any normal application would expect. +- * +- * RPCBPROC_GETADDRLIST(rpcb) returns (rpcb_entry_list_ptr). +- * Same as RPCBPROC_GETADDR except that it returns a list of all the +- * addresses registered for the combination (prog, vers) (for all +- * transports). +- * +- * RPCBPROC_GETSTAT(void) returns (rpcb_stat_byvers) +- * Returns the statistics about the kind of requests received by rpcbind. +- */ +- +-/* +- * A mapping of (program, version, network ID) to address +- */ +- +-struct rpcb { +- rpcprog_t r_prog; +- rpcvers_t r_vers; +- char *r_netid; +- char *r_addr; +- char *r_owner; +-}; +-typedef struct rpcb rpcb; +-#ifdef __cplusplus +-extern "C" bool_t xdr_rpcb(XDR *, rpcb*); +-#elif __STDC__ +-extern bool_t xdr_rpcb(XDR *, rpcb*); +-#else /* Old Style C */ +-bool_t xdr_rpcb(); +-#endif /* Old Style C */ +- +- +-typedef rpcb RPCB; +- +- +-/* +- * A list of mappings +- * +- * Below are two definitions for the rpcblist structure. This is done because +- * xdr_rpcblist() is specified to take a struct rpcblist **, rather than a +- * struct rpcblist * that rpcgen would produce. One version of the rpcblist +- * structure (actually called rp__list) is used with rpcgen, and the other is +- * defined only in the header file for compatibility with the specified +- * interface. +- */ +- +-struct rp__list { +- rpcb rpcb_map; +- struct rp__list *rpcb_next; +-}; +-typedef struct rp__list rp__list; +-#ifdef __cplusplus +-extern "C" bool_t xdr_rp__list(XDR *, rp__list*); +-#elif __STDC__ +-extern bool_t xdr_rp__list(XDR *, rp__list*); +-#else /* Old Style C */ +-bool_t xdr_rp__list(); +-#endif /* Old Style C */ +- +- +-typedef rp__list *rpcblist_ptr; +-#ifdef __cplusplus +-extern "C" bool_t xdr_rpcblist_ptr(XDR *, rpcblist_ptr*); +-#elif __STDC__ +-extern bool_t xdr_rpcblist_ptr(XDR *, rpcblist_ptr*); +-#else /* Old Style C */ +-bool_t xdr_rpcblist_ptr(); +-#endif /* Old Style C */ +- +- +-typedef struct rp__list rpcblist; +-typedef struct rp__list RPCBLIST; +- +-#ifndef __cplusplus +-struct rpcblist { +- RPCB rpcb_map; +- struct rpcblist *rpcb_next; +-}; +-#endif +- +-#ifdef __cplusplus +-extern "C" { +-#endif +-extern bool_t xdr_rpcblist(XDR *, rpcblist**); +-#ifdef __cplusplus +-} +-#endif +- +- +-/* +- * Arguments of remote calls +- */ +- +-struct rpcb_rmtcallargs { +- rpcprog_t prog; +- rpcvers_t vers; +- rpcproc_t proc; +- struct { +- u_int args_len; +- char *args_val; +- } args; +-}; +-typedef struct rpcb_rmtcallargs rpcb_rmtcallargs; +-#ifdef __cplusplus +-extern "C" bool_t xdr_rpcb_rmtcallargs(XDR *, rpcb_rmtcallargs*); +-#elif __STDC__ +-extern bool_t xdr_rpcb_rmtcallargs(XDR *, rpcb_rmtcallargs*); +-#else /* Old Style C */ +-bool_t xdr_rpcb_rmtcallargs(); +-#endif /* Old Style C */ +- +- +-/* +- * Client-side only representation of rpcb_rmtcallargs structure. +- * +- * The routine that XDRs the rpcb_rmtcallargs structure must deal with the +- * opaque arguments in the "args" structure. xdr_rpcb_rmtcallargs() needs to +- * be passed the XDR routine that knows the args' structure. This routine +- * doesn't need to go over-the-wire (and it wouldn't make sense anyway) since +- * the application being called already knows the args structure. So we use a +- * different "XDR" structure on the client side, r_rpcb_rmtcallargs, which +- * includes the args' XDR routine. +- */ +-struct r_rpcb_rmtcallargs { +- rpcprog_t prog; +- rpcvers_t vers; +- rpcproc_t proc; +- struct { +- u_int args_len; +- char *args_val; +- } args; +- xdrproc_t xdr_args; /* encodes args */ +-}; +- +- +-/* +- * Results of the remote call +- */ +- +-struct rpcb_rmtcallres { +- char *addr; +- struct { +- u_int results_len; +- char *results_val; +- } results; +-}; +-typedef struct rpcb_rmtcallres rpcb_rmtcallres; +-#ifdef __cplusplus +-extern "C" bool_t xdr_rpcb_rmtcallres(XDR *, rpcb_rmtcallres*); +-#elif __STDC__ +-extern bool_t xdr_rpcb_rmtcallres(XDR *, rpcb_rmtcallres*); +-#else /* Old Style C */ +-bool_t xdr_rpcb_rmtcallres(); +-#endif /* Old Style C */ +- +- +-/* +- * Client-side only representation of rpcb_rmtcallres structure. +- */ +-struct r_rpcb_rmtcallres { +- char *addr; +- struct { +- u_int32_t results_len; +- char *results_val; +- } results; +- xdrproc_t xdr_res; /* decodes results */ +-}; +- +-/* +- * rpcb_entry contains a merged address of a service on a particular +- * transport, plus associated netconfig information. A list of rpcb_entrys +- * is returned by RPCBPROC_GETADDRLIST. See netconfig.h for values used +- * in r_nc_* fields. +- */ +- +-struct rpcb_entry { +- char *r_maddr; +- char *r_nc_netid; +- u_int r_nc_semantics; +- char *r_nc_protofmly; +- char *r_nc_proto; +-}; +-typedef struct rpcb_entry rpcb_entry; +-#ifdef __cplusplus +-extern "C" bool_t xdr_rpcb_entry(XDR *, rpcb_entry*); +-#elif __STDC__ +-extern bool_t xdr_rpcb_entry(XDR *, rpcb_entry*); +-#else /* Old Style C */ +-bool_t xdr_rpcb_entry(); +-#endif /* Old Style C */ +- +- +-/* +- * A list of addresses supported by a service. +- */ +- +-struct rpcb_entry_list { +- rpcb_entry rpcb_entry_map; +- struct rpcb_entry_list *rpcb_entry_next; +-}; +-typedef struct rpcb_entry_list rpcb_entry_list; +-#ifdef __cplusplus +-extern "C" bool_t xdr_rpcb_entry_list(XDR *, rpcb_entry_list*); +-#elif __STDC__ +-extern bool_t xdr_rpcb_entry_list(XDR *, rpcb_entry_list*); +-#else /* Old Style C */ +-bool_t xdr_rpcb_entry_list(); +-#endif /* Old Style C */ +- +- +-typedef rpcb_entry_list *rpcb_entry_list_ptr; +-#ifdef __cplusplus +-extern "C" bool_t xdr_rpcb_entry_list_ptr(XDR *, rpcb_entry_list_ptr*); +-#elif __STDC__ +-extern bool_t xdr_rpcb_entry_list_ptr(XDR *, rpcb_entry_list_ptr*); +-#else /* Old Style C */ +-bool_t xdr_rpcb_entry_list_ptr(); +-#endif /* Old Style C */ +- +- +-/* +- * rpcbind statistics +- */ +- +-#define rpcb_highproc_2 RPCBPROC_CALLIT +-#define rpcb_highproc_3 RPCBPROC_TADDR2UADDR +-#define rpcb_highproc_4 RPCBPROC_GETSTAT +-#define RPCBSTAT_HIGHPROC 13 +-#define RPCBVERS_STAT 3 +-#define RPCBVERS_4_STAT 2 +-#define RPCBVERS_3_STAT 1 +-#define RPCBVERS_2_STAT 0 +- +-/* Link list of all the stats about getport and getaddr */ +- +-struct rpcbs_addrlist { +- rpcprog_t prog; +- rpcvers_t vers; +- int success; +- int failure; +- char *netid; +- struct rpcbs_addrlist *next; +-}; +-typedef struct rpcbs_addrlist rpcbs_addrlist; +-#ifdef __cplusplus +-extern "C" bool_t xdr_rpcbs_addrlist(XDR *, rpcbs_addrlist*); +-#elif __STDC__ +-extern bool_t xdr_rpcbs_addrlist(XDR *, rpcbs_addrlist*); +-#else /* Old Style C */ +-bool_t xdr_rpcbs_addrlist(); +-#endif /* Old Style C */ +- +- +-/* Link list of all the stats about rmtcall */ +- +-struct rpcbs_rmtcalllist { +- rpcprog_t prog; +- rpcvers_t vers; +- rpcproc_t proc; +- int success; +- int failure; +- int indirect; +- char *netid; +- struct rpcbs_rmtcalllist *next; +-}; +-typedef struct rpcbs_rmtcalllist rpcbs_rmtcalllist; +-#ifdef __cplusplus +-extern "C" bool_t xdr_rpcbs_rmtcalllist(XDR *, rpcbs_rmtcalllist*); +-#elif __STDC__ +-extern bool_t xdr_rpcbs_rmtcalllist(XDR *, rpcbs_rmtcalllist*); +-#else /* Old Style C */ +-bool_t xdr_rpcbs_rmtcalllist(); +-#endif /* Old Style C */ +- +- +-typedef int rpcbs_proc[RPCBSTAT_HIGHPROC]; +-#ifdef __cplusplus +-extern "C" bool_t xdr_rpcbs_proc(XDR *, rpcbs_proc); +-#elif __STDC__ +-extern bool_t xdr_rpcbs_proc(XDR *, rpcbs_proc); +-#else /* Old Style C */ +-bool_t xdr_rpcbs_proc(); +-#endif /* Old Style C */ +- +- +-typedef rpcbs_addrlist *rpcbs_addrlist_ptr; +-#ifdef __cplusplus +-extern "C" bool_t xdr_rpcbs_addrlist_ptr(XDR *, rpcbs_addrlist_ptr*); +-#elif __STDC__ +-extern bool_t xdr_rpcbs_addrlist_ptr(XDR *, rpcbs_addrlist_ptr*); +-#else /* Old Style C */ +-bool_t xdr_rpcbs_addrlist_ptr(); +-#endif /* Old Style C */ +- +- +-typedef rpcbs_rmtcalllist *rpcbs_rmtcalllist_ptr; +-#ifdef __cplusplus +-extern "C" bool_t xdr_rpcbs_rmtcalllist_ptr(XDR *, rpcbs_rmtcalllist_ptr*); +-#elif __STDC__ +-extern bool_t xdr_rpcbs_rmtcalllist_ptr(XDR *, rpcbs_rmtcalllist_ptr*); +-#else /* Old Style C */ +-bool_t xdr_rpcbs_rmtcalllist_ptr(); +-#endif /* Old Style C */ +- +- +-struct rpcb_stat { +- rpcbs_proc info; +- int setinfo; +- int unsetinfo; +- rpcbs_addrlist_ptr addrinfo; +- rpcbs_rmtcalllist_ptr rmtinfo; +-}; +-typedef struct rpcb_stat rpcb_stat; +-#ifdef __cplusplus +-extern "C" bool_t xdr_rpcb_stat(XDR *, rpcb_stat*); +-#elif __STDC__ +-extern bool_t xdr_rpcb_stat(XDR *, rpcb_stat*); +-#else /* Old Style C */ +-bool_t xdr_rpcb_stat(); +-#endif /* Old Style C */ +- +- +-/* +- * One rpcb_stat structure is returned for each version of rpcbind +- * being monitored. +- */ +- +-typedef rpcb_stat rpcb_stat_byvers[RPCBVERS_STAT]; +-#ifdef __cplusplus +-extern "C" bool_t xdr_rpcb_stat_byvers(XDR *, rpcb_stat_byvers); +-#elif __STDC__ +-extern bool_t xdr_rpcb_stat_byvers(XDR *, rpcb_stat_byvers); +-#else /* Old Style C */ +-bool_t xdr_rpcb_stat_byvers(); +-#endif /* Old Style C */ +- +- +-/* +- * We don't define netbuf in RPCL, since it would contain structure member +- * names that would conflict with the definition of struct netbuf in +- * . Instead we merely declare the XDR routine xdr_netbuf() here, +- * and implement it ourselves in rpc/rpcb_prot.c. +- */ +-#ifdef __cplusplus +-extern "C" bool_t xdr_netbuf(XDR *, struct netbuf *); +- +-#else /* __STDC__ */ +-extern bool_t xdr_netbuf(XDR *, struct netbuf *); +- +-#endif +- +-#define RPCBVERS_3 RPCBVERS +-#define RPCBVERS_4 RPCBVERS4 +- +-#define _PATH_RPCBINDSOCK "/var/run/rpcbind.sock" +- +-#else /* ndef _KERNEL */ +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/* +- * A mapping of (program, version, network ID) to address +- */ +-struct rpcb { +- rpcprog_t r_prog; /* program number */ +- rpcvers_t r_vers; /* version number */ +- char *r_netid; /* network id */ +- char *r_addr; /* universal address */ +- char *r_owner; /* owner of the mapping */ +-}; +-typedef struct rpcb RPCB; +- +-/* +- * A list of mappings +- */ +-struct rpcblist { +- RPCB rpcb_map; +- struct rpcblist *rpcb_next; +-}; +-typedef struct rpcblist RPCBLIST; +-typedef struct rpcblist *rpcblist_ptr; +- +-/* +- * Remote calls arguments +- */ +-struct rpcb_rmtcallargs { +- rpcprog_t prog; /* program number */ +- rpcvers_t vers; /* version number */ +- rpcproc_t proc; /* procedure number */ +- u_int32_t arglen; /* arg len */ +- caddr_t args_ptr; /* argument */ +- xdrproc_t xdr_args; /* XDR routine for argument */ +-}; +-typedef struct rpcb_rmtcallargs rpcb_rmtcallargs; +- +-/* +- * Remote calls results +- */ +-struct rpcb_rmtcallres { +- char *addr_ptr; /* remote universal address */ +- u_int32_t resultslen; /* results length */ +- caddr_t results_ptr; /* results */ +- xdrproc_t xdr_results; /* XDR routine for result */ +-}; +-typedef struct rpcb_rmtcallres rpcb_rmtcallres; +- +-struct rpcb_entry { +- char *r_maddr; +- char *r_nc_netid; +- unsigned int r_nc_semantics; +- char *r_nc_protofmly; +- char *r_nc_proto; +-}; +-typedef struct rpcb_entry rpcb_entry; +- +-/* +- * A list of addresses supported by a service. +- */ +- +-struct rpcb_entry_list { +- rpcb_entry rpcb_entry_map; +- struct rpcb_entry_list *rpcb_entry_next; +-}; +-typedef struct rpcb_entry_list rpcb_entry_list; +- +-typedef rpcb_entry_list *rpcb_entry_list_ptr; +- +-/* +- * rpcbind statistics +- */ +- +-#define rpcb_highproc_2 RPCBPROC_CALLIT +-#define rpcb_highproc_3 RPCBPROC_TADDR2UADDR +-#define rpcb_highproc_4 RPCBPROC_GETSTAT +-#define RPCBSTAT_HIGHPROC 13 +-#define RPCBVERS_STAT 3 +-#define RPCBVERS_4_STAT 2 +-#define RPCBVERS_3_STAT 1 +-#define RPCBVERS_2_STAT 0 +- +-/* Link list of all the stats about getport and getaddr */ +- +-struct rpcbs_addrlist { +- rpcprog_t prog; +- rpcvers_t vers; +- int success; +- int failure; +- char *netid; +- struct rpcbs_addrlist *next; +-}; +-typedef struct rpcbs_addrlist rpcbs_addrlist; +- +-/* Link list of all the stats about rmtcall */ +- +-struct rpcbs_rmtcalllist { +- rpcprog_t prog; +- rpcvers_t vers; +- rpcproc_t proc; +- int success; +- int failure; +- int indirect; +- char *netid; +- struct rpcbs_rmtcalllist *next; +-}; +-typedef struct rpcbs_rmtcalllist rpcbs_rmtcalllist; +- +-typedef int rpcbs_proc[RPCBSTAT_HIGHPROC]; +- +-typedef rpcbs_addrlist *rpcbs_addrlist_ptr; +- +-typedef rpcbs_rmtcalllist *rpcbs_rmtcalllist_ptr; +- +-struct rpcb_stat { +- rpcbs_proc info; +- int setinfo; +- int unsetinfo; +- rpcbs_addrlist_ptr addrinfo; +- rpcbs_rmtcalllist_ptr rmtinfo; +-}; +-typedef struct rpcb_stat rpcb_stat; +- +-/* +- * One rpcb_stat structure is returned for each version of rpcbind +- * being monitored. +- */ +- +-typedef rpcb_stat rpcb_stat_byvers[RPCBVERS_STAT]; +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif /* ndef _KERNEL */ +- +-#define RPCBPROG ((u_int32_t)100000) +-#define RPCBVERS ((u_int32_t)3) +- +-#ifdef __cplusplus +-#define RPCBPROC_SET ((u_int32_t)1) +-extern "C" bool_t * rpcbproc_set_3(rpcb *, CLIENT *); +-extern "C" bool_t * rpcbproc_set_3_svc(rpcb *, struct svc_req *); +-#define RPCBPROC_UNSET ((u_int32_t)2) +-extern "C" bool_t * rpcbproc_unset_3(rpcb *, CLIENT *); +-extern "C" bool_t * rpcbproc_unset_3_svc(rpcb *, struct svc_req *); +-#define RPCBPROC_GETADDR ((u_int32_t)3) +-extern "C" char ** rpcbproc_getaddr_3(rpcb *, CLIENT *); +-extern "C" char ** rpcbproc_getaddr_3_svc(rpcb *, struct svc_req *); +-#define RPCBPROC_DUMP ((u_int32_t)4) +-extern "C" rpcblist_ptr * rpcbproc_dump_3(void *, CLIENT *); +-extern "C" rpcblist_ptr * rpcbproc_dump_3_svc(void *, struct svc_req *); +-#define RPCBPROC_CALLIT ((u_int32_t)5) +-extern "C" rpcb_rmtcallres * rpcbproc_callit_3(rpcb_rmtcallargs *, CLIENT *); +-extern "C" rpcb_rmtcallres * rpcbproc_callit_3_svc(rpcb_rmtcallargs *, struct svc_req *); +-#define RPCBPROC_GETTIME ((u_int32_t)6) +-extern "C" u_int * rpcbproc_gettime_3(void *, CLIENT *); +-extern "C" u_int * rpcbproc_gettime_3_svc(void *, struct svc_req *); +-#define RPCBPROC_UADDR2TADDR ((u_int32_t)7) +-extern "C" struct netbuf * rpcbproc_uaddr2taddr_3(char **, CLIENT *); +-extern "C" struct netbuf * rpcbproc_uaddr2taddr_3_svc(char **, struct svc_req *); +-#define RPCBPROC_TADDR2UADDR ((u_int32_t)8) +-extern "C" char ** rpcbproc_taddr2uaddr_3(struct netbuf *, CLIENT *); +-extern "C" char ** rpcbproc_taddr2uaddr_3_svc(struct netbuf *, struct svc_req *); +- +-#elif __STDC__ +-#define RPCBPROC_SET ((u_int32_t)1) +-extern bool_t * rpcbproc_set_3(rpcb *, CLIENT *); +-extern bool_t * rpcbproc_set_3_svc(rpcb *, struct svc_req *); +-#define RPCBPROC_UNSET ((u_int32_t)2) +-extern bool_t * rpcbproc_unset_3(rpcb *, CLIENT *); +-extern bool_t * rpcbproc_unset_3_svc(rpcb *, struct svc_req *); +-#define RPCBPROC_GETADDR ((u_int32_t)3) +-extern char ** rpcbproc_getaddr_3(rpcb *, CLIENT *); +-extern char ** rpcbproc_getaddr_3_svc(rpcb *, struct svc_req *); +-#define RPCBPROC_DUMP ((u_int32_t)4) +-extern rpcblist_ptr * rpcbproc_dump_3(void *, CLIENT *); +-extern rpcblist_ptr * rpcbproc_dump_3_svc(void *, struct svc_req *); +-#define RPCBPROC_CALLIT ((u_int32_t)5) +-extern rpcb_rmtcallres * rpcbproc_callit_3(rpcb_rmtcallargs *, CLIENT *); +-extern rpcb_rmtcallres * rpcbproc_callit_3_svc(rpcb_rmtcallargs *, struct svc_req *); +-#define RPCBPROC_GETTIME ((u_int32_t)6) +-extern u_int * rpcbproc_gettime_3(void *, CLIENT *); +-extern u_int * rpcbproc_gettime_3_svc(void *, struct svc_req *); +-#define RPCBPROC_UADDR2TADDR ((u_int32_t)7) +-extern struct netbuf * rpcbproc_uaddr2taddr_3(char **, CLIENT *); +-extern struct netbuf * rpcbproc_uaddr2taddr_3_svc(char **, struct svc_req *); +-#define RPCBPROC_TADDR2UADDR ((u_int32_t)8) +-extern char ** rpcbproc_taddr2uaddr_3(struct netbuf *, CLIENT *); +-extern char ** rpcbproc_taddr2uaddr_3_svc(struct netbuf *, struct svc_req *); +- +-#else /* Old Style C */ +-#define RPCBPROC_SET ((u_int32_t)1) +-extern bool_t * rpcbproc_set_3(); +-extern bool_t * rpcbproc_set_3_svc(); +-#define RPCBPROC_UNSET ((u_int32_t)2) +-extern bool_t * rpcbproc_unset_3(); +-extern bool_t * rpcbproc_unset_3_svc(); +-#define RPCBPROC_GETADDR ((u_int32_t)3) +-extern char ** rpcbproc_getaddr_3(); +-extern char ** rpcbproc_getaddr_3_svc(); +-#define RPCBPROC_DUMP ((u_int32_t)4) +-extern rpcblist_ptr * rpcbproc_dump_3(); +-extern rpcblist_ptr * rpcbproc_dump_3_svc(); +-#define RPCBPROC_CALLIT ((u_int32_t)5) +-extern rpcb_rmtcallres * rpcbproc_callit_3(); +-extern rpcb_rmtcallres * rpcbproc_callit_3_svc(); +-#define RPCBPROC_GETTIME ((u_int32_t)6) +-extern u_int * rpcbproc_gettime_3(); +-extern u_int * rpcbproc_gettime_3_svc(); +-#define RPCBPROC_UADDR2TADDR ((u_int32_t)7) +-extern struct netbuf * rpcbproc_uaddr2taddr_3(); +-extern struct netbuf * rpcbproc_uaddr2taddr_3_svc(); +-#define RPCBPROC_TADDR2UADDR ((u_int32_t)8) +-extern char ** rpcbproc_taddr2uaddr_3(); +-extern char ** rpcbproc_taddr2uaddr_3_svc(); +-#endif /* Old Style C */ +-#define RPCBVERS4 ((u_int32_t)4) +- +-#ifdef __cplusplus +-extern "C" bool_t * rpcbproc_set_4(rpcb *, CLIENT *); +-extern "C" bool_t * rpcbproc_set_4_svc(rpcb *, struct svc_req *); +-extern "C" bool_t * rpcbproc_unset_4(rpcb *, CLIENT *); +-extern "C" bool_t * rpcbproc_unset_4_svc(rpcb *, struct svc_req *); +-extern "C" char ** rpcbproc_getaddr_4(rpcb *, CLIENT *); +-extern "C" char ** rpcbproc_getaddr_4_svc(rpcb *, struct svc_req *); +-extern "C" rpcblist_ptr * rpcbproc_dump_4(void *, CLIENT *); +-extern "C" rpcblist_ptr * rpcbproc_dump_4_svc(void *, struct svc_req *); +-#define RPCBPROC_BCAST ((u_int32_t)RPCBPROC_CALLIT) +-extern "C" rpcb_rmtcallres * rpcbproc_bcast_4(rpcb_rmtcallargs *, CLIENT *); +-extern "C" rpcb_rmtcallres * rpcbproc_bcast_4_svc(rpcb_rmtcallargs *, struct svc_req *); +-extern "C" u_int * rpcbproc_gettime_4(void *, CLIENT *); +-extern "C" u_int * rpcbproc_gettime_4_svc(void *, struct svc_req *); +-extern "C" struct netbuf * rpcbproc_uaddr2taddr_4(char **, CLIENT *); +-extern "C" struct netbuf * rpcbproc_uaddr2taddr_4_svc(char **, struct svc_req *); +-extern "C" char ** rpcbproc_taddr2uaddr_4(struct netbuf *, CLIENT *); +-extern "C" char ** rpcbproc_taddr2uaddr_4_svc(struct netbuf *, struct svc_req *); +-#define RPCBPROC_GETVERSADDR ((u_int32_t)9) +-extern "C" char ** rpcbproc_getversaddr_4(rpcb *, CLIENT *); +-extern "C" char ** rpcbproc_getversaddr_4_svc(rpcb *, struct svc_req *); +-#define RPCBPROC_INDIRECT ((u_int32_t)10) +-extern "C" rpcb_rmtcallres * rpcbproc_indirect_4(rpcb_rmtcallargs *, CLIENT *); +-extern "C" rpcb_rmtcallres * rpcbproc_indirect_4_svc(rpcb_rmtcallargs *, struct svc_req *); +-#define RPCBPROC_GETADDRLIST ((u_int32_t)11) +-extern "C" rpcb_entry_list_ptr * rpcbproc_getaddrlist_4(rpcb *, CLIENT *); +-extern "C" rpcb_entry_list_ptr * rpcbproc_getaddrlist_4_svc(rpcb *, struct svc_req *); +-#define RPCBPROC_GETSTAT ((u_int32_t)12) +-extern "C" rpcb_stat * rpcbproc_getstat_4(void *, CLIENT *); +-extern "C" rpcb_stat * rpcbproc_getstat_4_svc(void *, struct svc_req *); +- +-#elif __STDC__ +-extern bool_t * rpcbproc_set_4(rpcb *, CLIENT *); +-extern bool_t * rpcbproc_set_4_svc(rpcb *, struct svc_req *); +-extern bool_t * rpcbproc_unset_4(rpcb *, CLIENT *); +-extern bool_t * rpcbproc_unset_4_svc(rpcb *, struct svc_req *); +-extern char ** rpcbproc_getaddr_4(rpcb *, CLIENT *); +-extern char ** rpcbproc_getaddr_4_svc(rpcb *, struct svc_req *); +-extern rpcblist_ptr * rpcbproc_dump_4(void *, CLIENT *); +-extern rpcblist_ptr * rpcbproc_dump_4_svc(void *, struct svc_req *); +-#define RPCBPROC_BCAST ((u_int32_t)RPCBPROC_CALLIT) +-extern rpcb_rmtcallres * rpcbproc_bcast_4(rpcb_rmtcallargs *, CLIENT *); +-extern rpcb_rmtcallres * rpcbproc_bcast_4_svc(rpcb_rmtcallargs *, struct svc_req *); +-extern u_int * rpcbproc_gettime_4(void *, CLIENT *); +-extern u_int * rpcbproc_gettime_4_svc(void *, struct svc_req *); +-extern struct netbuf * rpcbproc_uaddr2taddr_4(char **, CLIENT *); +-extern struct netbuf * rpcbproc_uaddr2taddr_4_svc(char **, struct svc_req *); +-extern char ** rpcbproc_taddr2uaddr_4(struct netbuf *, CLIENT *); +-extern char ** rpcbproc_taddr2uaddr_4_svc(struct netbuf *, struct svc_req *); +-#define RPCBPROC_GETVERSADDR ((u_int32_t)9) +-extern char ** rpcbproc_getversaddr_4(rpcb *, CLIENT *); +-extern char ** rpcbproc_getversaddr_4_svc(rpcb *, struct svc_req *); +-#define RPCBPROC_INDIRECT ((u_int32_t)10) +-extern rpcb_rmtcallres * rpcbproc_indirect_4(rpcb_rmtcallargs *, CLIENT *); +-extern rpcb_rmtcallres * rpcbproc_indirect_4_svc(rpcb_rmtcallargs *, struct svc_req *); +-#define RPCBPROC_GETADDRLIST ((u_int32_t)11) +-extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4(rpcb *, CLIENT *); +-extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4_svc(rpcb *, struct svc_req *); +-#define RPCBPROC_GETSTAT ((u_int32_t)12) +-extern rpcb_stat * rpcbproc_getstat_4(void *, CLIENT *); +-extern rpcb_stat * rpcbproc_getstat_4_svc(void *, struct svc_req *); +- +-#else /* Old Style C */ +-extern bool_t * rpcbproc_set_4(); +-extern bool_t * rpcbproc_set_4_svc(); +-extern bool_t * rpcbproc_unset_4(); +-extern bool_t * rpcbproc_unset_4_svc(); +-extern char ** rpcbproc_getaddr_4(); +-extern char ** rpcbproc_getaddr_4_svc(); +-extern rpcblist_ptr * rpcbproc_dump_4(); +-extern rpcblist_ptr * rpcbproc_dump_4_svc(); +-#define RPCBPROC_BCAST ((u_int32_t)RPCBPROC_CALLIT) +-extern rpcb_rmtcallres * rpcbproc_bcast_4(); +-extern rpcb_rmtcallres * rpcbproc_bcast_4_svc(); +-extern u_int * rpcbproc_gettime_4(); +-extern u_int * rpcbproc_gettime_4_svc(); +-extern struct netbuf * rpcbproc_uaddr2taddr_4(); +-extern struct netbuf * rpcbproc_uaddr2taddr_4_svc(); +-extern char ** rpcbproc_taddr2uaddr_4(); +-extern char ** rpcbproc_taddr2uaddr_4_svc(); +-#define RPCBPROC_GETVERSADDR ((u_int32_t)9) +-extern char ** rpcbproc_getversaddr_4(); +-extern char ** rpcbproc_getversaddr_4_svc(); +-#define RPCBPROC_INDIRECT ((u_int32_t)10) +-extern rpcb_rmtcallres * rpcbproc_indirect_4(); +-extern rpcb_rmtcallres * rpcbproc_indirect_4_svc(); +-#define RPCBPROC_GETADDRLIST ((u_int32_t)11) +-extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4(); +-extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4_svc(); +-#define RPCBPROC_GETSTAT ((u_int32_t)12) +-extern rpcb_stat * rpcbproc_getstat_4(); +-extern rpcb_stat * rpcbproc_getstat_4_svc(); +-#endif /* Old Style C */ +- +-#endif /* !_RPCB_PROT_H_RPCGEN */ +diff --git a/tirpc/rpcsvc/crypt.h b/tirpc/rpcsvc/crypt.h +deleted file mode 100644 +index da1f9cc..0000000 +--- a/tirpc/rpcsvc/crypt.h ++++ /dev/null +@@ -1,109 +0,0 @@ +-/* +- * Please do not edit this file. +- * It was generated using rpcgen. +- */ +- +-#ifndef _CRYPT_H_RPCGEN +-#define _CRYPT_H_RPCGEN +- +-#include +- +-#ifndef IXDR_GET_INT32 +-#define IXDR_GET_INT32(buf) IXDR_GET_LONG((buf)) +-#endif +-#ifndef IXDR_PUT_INT32 +-#define IXDR_PUT_INT32(buf, v) IXDR_PUT_LONG((buf), (v)) +-#endif +-#ifndef IXDR_GET_U_INT32 +-#define IXDR_GET_U_INT32(buf) IXDR_GET_U_LONG((buf)) +-#endif +-#ifndef IXDR_PUT_U_INT32 +-#define IXDR_PUT_U_INT32(buf, v) IXDR_PUT_U_LONG((buf), (v)) +-#endif +- +-enum des_dir { +- ENCRYPT_DES = 0, +- DECRYPT_DES = 1, +-}; +-typedef enum des_dir des_dir; +-#ifdef __cplusplus +-extern "C" bool_t xdr_des_dir(XDR *, des_dir*); +-#elif __STDC__ +-extern bool_t xdr_des_dir(XDR *, des_dir*); +-#else /* Old Style C */ +-bool_t xdr_des_dir(); +-#endif /* Old Style C */ +- +- +-enum des_mode { +- CBC_DES = 0, +- ECB_DES = 1, +-}; +-typedef enum des_mode des_mode; +-#ifdef __cplusplus +-extern "C" bool_t xdr_des_mode(XDR *, des_mode*); +-#elif __STDC__ +-extern bool_t xdr_des_mode(XDR *, des_mode*); +-#else /* Old Style C */ +-bool_t xdr_des_mode(); +-#endif /* Old Style C */ +- +- +-struct desargs { +- u_char des_key[8]; +- des_dir des_dir; +- des_mode des_mode; +- u_char des_ivec[8]; +- struct { +- u_int desbuf_len; +- char *desbuf_val; +- } desbuf; +-}; +-typedef struct desargs desargs; +-#ifdef __cplusplus +-extern "C" bool_t xdr_desargs(XDR *, desargs*); +-#elif __STDC__ +-extern bool_t xdr_desargs(XDR *, desargs*); +-#else /* Old Style C */ +-bool_t xdr_desargs(); +-#endif /* Old Style C */ +- +- +-struct desresp { +- struct { +- u_int desbuf_len; +- char *desbuf_val; +- } desbuf; +- u_char des_ivec[8]; +- int stat; +-}; +-typedef struct desresp desresp; +-#ifdef __cplusplus +-extern "C" bool_t xdr_desresp(XDR *, desresp*); +-#elif __STDC__ +-extern bool_t xdr_desresp(XDR *, desresp*); +-#else /* Old Style C */ +-bool_t xdr_desresp(); +-#endif /* Old Style C */ +- +- +-#define CRYPT_PROG ((u_int32_t)600100029) +-#define CRYPT_VERS ((u_int32_t)1) +- +-#ifdef __cplusplus +-#define DES_CRYPT ((u_int32_t)1) +-extern "C" desresp * des_crypt_1(desargs *, CLIENT *); +-extern "C" desresp * des_crypt_1_svc(desargs *, struct svc_req *); +- +-#elif __STDC__ +-#define DES_CRYPT ((u_int32_t)1) +-extern desresp * des_crypt_1(desargs *, CLIENT *); +-extern desresp * des_crypt_1_svc(desargs *, struct svc_req *); +- +-#else /* Old Style C */ +-#define DES_CRYPT ((u_int32_t)1) +-extern desresp * des_crypt_1(); +-extern desresp * des_crypt_1_svc(); +-#endif /* Old Style C */ +- +-#endif /* !_CRYPT_H_RPCGEN */ +-- +2.0.0 + diff --git a/package/libtirpc/0006-Add-more-XDR-files-needed-to-build-rpcbind-on-top-of.patch b/package/libtirpc/0006-Add-more-XDR-files-needed-to-build-rpcbind-on-top-of.patch new file mode 100644 index 0000000000..638918bdf1 --- /dev/null +++ b/package/libtirpc/0006-Add-more-XDR-files-needed-to-build-rpcbind-on-top-of.patch @@ -0,0 +1,1651 @@ +From 008a9c8ac3a84ffcc46a0eedb5b13862b279190c Mon Sep 17 00:00:00 2001 +From: Thomas Petazzoni +Date: Sat, 10 Nov 2012 17:45:03 +0100 +Subject: [PATCH] Add more XDR files needed to build rpcbind on top of libtirpc + +Signed-off-by: Thomas Petazzoni +--- + Makefile.am | 6 + + tirpc/rpcsvc/mount.x | 257 ++++++++++ + tirpc/rpcsvc/nfs_prot.x | 1266 +++++++++++++++++++++++++++++++++++++++++++++++ + tirpc/rpcsvc/rquota.x | 67 +++ + 4 files changed, 1596 insertions(+) + create mode 100644 tirpc/rpcsvc/mount.x + create mode 100644 tirpc/rpcsvc/nfs_prot.x + create mode 100644 tirpc/rpcsvc/rquota.x + +diff --git a/Makefile.am b/Makefile.am +index 4e4dc32..b7ae979 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -3,6 +3,9 @@ ACLOCAL_AMFLAGS = -I m4 + + GENFILES = \ + tirpc/rpcsvc/crypt.h \ ++ tirpc/rpcsvc/mount.h \ ++ tirpc/rpcsvc/nfs_prot.h \ ++ tirpc/rpcsvc/rquota.h \ + tirpc/rpc/rpcb_prot.h + + noinst_HEADERS = tirpc/reentrant.h \ +@@ -12,6 +15,9 @@ noinst_HEADERS = tirpc/reentrant.h \ + + nobase_include_HEADERS = tirpc/netconfig.h \ + tirpc/rpcsvc/crypt.x \ ++ tirpc/rpcsvc/mount.x \ ++ tirpc/rpcsvc/nfs_prot.x \ ++ tirpc/rpcsvc/rquota.x \ + tirpc/rpc/xdr.h \ + tirpc/rpc/types.h \ + tirpc/rpc/svc_soc.h \ +diff --git a/tirpc/rpcsvc/mount.x b/tirpc/rpcsvc/mount.x +new file mode 100644 +index 0000000..f68a06f +--- /dev/null ++++ b/tirpc/rpcsvc/mount.x +@@ -0,0 +1,257 @@ ++/* ++ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for ++ * unrestricted use provided that this legend is included on all tape ++ * media and as a part of the software program in whole or part. Users ++ * may copy or modify Sun RPC without charge, but are not authorized ++ * to license or distribute it to anyone else except as part of a product or ++ * program developed by the user. ++ * ++ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE ++ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. ++ * ++ * Sun RPC is provided with no support and without any obligation on the ++ * part of Sun Microsystems, Inc. to assist in its use, correction, ++ * modification or enhancement. ++ * ++ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE ++ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC ++ * OR ANY PART THEREOF. ++ * ++ * In no event will Sun Microsystems, Inc. be liable for any lost revenue ++ * or profits or other special, indirect and consequential damages, even if ++ * Sun has been advised of the possibility of such damages. ++ * ++ * Sun Microsystems, Inc. ++ * 2550 Garcia Avenue ++ * Mountain View, California 94043 ++ */ ++ ++/* ++ * Protocol description for the mount program ++ */ ++ ++#ifndef RPC_HDR ++%#ifndef lint ++%/*static char sccsid[] = "from: @(#)mount.x 1.2 87/09/18 Copyr 1987 Sun Micro";*/ ++%/*static char sccsid[] = "from: @(#)mount.x 2.1 88/08/01 4.0 RPCSRC";*/ ++%static const char rcsid[] = ++% "$FreeBSD: src/include/rpcsvc/mount.x,v 1.6 1999/08/27 23:45:08 peter Exp $"; ++%#endif /* not lint */ ++#endif ++ ++const MNTPATHLEN = 1024; /* maximum bytes in a pathname argument */ ++const MNTNAMLEN = 255; /* maximum bytes in a name argument */ ++const FHSIZE = 32; /* size in bytes of a file handle */ ++#ifdef WANT_NFS3 ++const FHSIZE3 = 64; /* size in bytes of a file handle (v3) */ ++#endif ++ ++/* ++ * The fhandle is the file handle that the server passes to the client. ++ * All file operations are done using the file handles to refer to a file ++ * or a directory. The file handle can contain whatever information the ++ * server needs to distinguish an individual file. ++ */ ++typedef opaque fhandle[FHSIZE]; ++#ifdef WANT_NFS3 ++typedef opaque fhandle3; ++#endif ++ ++/* ++ * If a status of zero is returned, the call completed successfully, and ++ * a file handle for the directory follows. A non-zero status indicates ++ * some sort of error. The status corresponds with UNIX error numbers. ++ */ ++union fhstatus switch (unsigned fhs_status) { ++case 0: ++ fhandle fhs_fhandle; ++default: ++ void; ++}; ++ ++#ifdef WANT_NFS3 ++/* ++ * Status codes returned by the version 3 mount call. ++ */ ++enum mountstat3 { ++ MNT3_OK = 0, /* no error */ ++ MNT3ERR_PERM = 1, /* Not owner */ ++ MNT3ERR_NOENT = 2, /* No such file or directory */ ++ MNT3ERR_IO = 5, /* I/O error */ ++ MNT3ERR_ACCES = 13, /* Permission denied */ ++ MNT3ERR_NOTDIR = 20, /* Not a directory */ ++ MNT3ERR_INVAL = 22, /* Invalid argument */ ++ MNT3ERR_NAMETOOLONG = 63, /* Filename too long */ ++ MNT3ERR_NOTSUPP = 10004, /* Operation not supported */ ++ MNT3ERR_SERVERFAULT = 10006 /* A failure on the server */ ++}; ++ ++struct mountres3_ok { ++ fhandle3 fhandle; ++ int auth_flavors<>; ++}; ++ ++union mountres3 switch (mountstat3 fhs_status) { ++case 0: ++ mountres3_ok mountinfo; ++default: ++ void; ++}; ++#endif ++ ++/* ++ * The type dirpath is the pathname of a directory ++ */ ++typedef string dirpath; ++ ++/* ++ * The type name is used for arbitrary names (hostnames, groupnames) ++ */ ++typedef string name; ++ ++/* ++ * A list of who has what mounted ++ */ ++typedef struct mountbody *mountlist; ++struct mountbody { ++ name ml_hostname; ++ dirpath ml_directory; ++ mountlist ml_next; ++}; ++ ++/* ++ * A list of netgroups ++ */ ++typedef struct groupnode *groups; ++struct groupnode { ++ name gr_name; ++ groups gr_next; ++}; ++ ++/* ++ * A list of what is exported and to whom ++ */ ++typedef struct exportnode *exports; ++struct exportnode { ++ dirpath ex_dir; ++ groups ex_groups; ++ exports ex_next; ++}; ++ ++program MOUNTPROG { ++ /* ++ * Version one of the mount protocol communicates with version two ++ * of the NFS protocol. Version three communicates with ++ * version three of the NFS protocol. The only connecting ++ * point is the fhandle structure, which is the same for both ++ * protocols. ++ */ ++ version MOUNTVERS { ++ /* ++ * Does no work. It is made available in all RPC services ++ * to allow server reponse testing and timing ++ */ ++ void ++ MOUNTPROC_NULL(void) = 0; ++ ++ /* ++ * If fhs_status is 0, then fhs_fhandle contains the ++ * file handle for the directory. This file handle may ++ * be used in the NFS protocol. This procedure also adds ++ * a new entry to the mount list for this client mounting ++ * the directory. ++ * Unix authentication required. ++ */ ++ fhstatus ++ MOUNTPROC_MNT(dirpath) = 1; ++ ++ /* ++ * Returns the list of remotely mounted filesystems. The ++ * mountlist contains one entry for each hostname and ++ * directory pair. ++ */ ++ mountlist ++ MOUNTPROC_DUMP(void) = 2; ++ ++ /* ++ * Removes the mount list entry for the directory ++ * Unix authentication required. ++ */ ++ void ++ MOUNTPROC_UMNT(dirpath) = 3; ++ ++ /* ++ * Removes all of the mount list entries for this client ++ * Unix authentication required. ++ */ ++ void ++ MOUNTPROC_UMNTALL(void) = 4; ++ ++ /* ++ * Returns a list of all the exported filesystems, and which ++ * machines are allowed to import it. ++ */ ++ exports ++ MOUNTPROC_EXPORT(void) = 5; ++ ++ /* ++ * Identical to MOUNTPROC_EXPORT above ++ */ ++ exports ++ MOUNTPROC_EXPORTALL(void) = 6; ++ } = 1; ++#ifdef WANT_NFS3 ++ version MOUNTVERS3 { ++ /* ++ * Does no work. It is made available in all RPC services ++ * to allow server reponse testing and timing ++ */ ++ void ++ MOUNTPROC_NULL(void) = 0; ++ ++ /* ++ * If mountres3.fhs_status is MNT3_OK, then ++ * mountres3.mountinfo contains the file handle for ++ * the directory and a list of acceptable ++ * authentication flavors. This file handle may only ++ * be used in the NFS version 3 protocol. This ++ * procedure also results in the server adding a new ++ * entry to its mount list recording that this client ++ * has mounted the directory. AUTH_UNIX authentication ++ * or better is required. ++ */ ++ mountres3 ++ MOUNTPROC_MNT(dirpath) = 1; ++ ++ /* ++ * Returns the list of remotely mounted filesystems. The ++ * mountlist contains one entry for each hostname and ++ * directory pair. ++ */ ++ mountlist ++ MOUNTPROC_DUMP(void) = 2; ++ ++ /* ++ * Removes the mount list entry for the directory ++ * Unix authentication required. ++ */ ++ void ++ MOUNTPROC_UMNT(dirpath) = 3; ++ ++ /* ++ * Removes all of the mount list entries for this client ++ * Unix authentication required. ++ */ ++ void ++ MOUNTPROC_UMNTALL(void) = 4; ++ ++ /* ++ * Returns a list of all the exported filesystems, and which ++ * machines are allowed to import it. ++ */ ++ exports ++ MOUNTPROC_EXPORT(void) = 5; ++ } = 3; ++#endif ++} = 100005; +diff --git a/tirpc/rpcsvc/nfs_prot.x b/tirpc/rpcsvc/nfs_prot.x +new file mode 100644 +index 0000000..01564f8 +--- /dev/null ++++ b/tirpc/rpcsvc/nfs_prot.x +@@ -0,0 +1,1266 @@ ++/* ++ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for ++ * unrestricted use provided that this legend is included on all tape ++ * media and as a part of the software program in whole or part. Users ++ * may copy or modify Sun RPC without charge, but are not authorized ++ * to license or distribute it to anyone else except as part of a product or ++ * program developed by the user. ++ * ++ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE ++ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. ++ * ++ * Sun RPC is provided with no support and without any obligation on the ++ * part of Sun Microsystems, Inc. to assist in its use, correction, ++ * modification or enhancement. ++ * ++ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE ++ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC ++ * OR ANY PART THEREOF. ++ * ++ * In no event will Sun Microsystems, Inc. be liable for any lost revenue ++ * or profits or other special, indirect and consequential damages, even if ++ * Sun has been advised of the possibility of such damages. ++ * ++ * Sun Microsystems, Inc. ++ * 2550 Garcia Avenue ++ * Mountain View, California 94043 ++ */ ++ ++#ifndef RPC_HDR ++%#ifndef lint ++%/*static char sccsid[] = "from: @(#)nfs_prot.x 1.2 87/10/12 Copyr 1987 Sun Micro";*/ ++%/*static char sccsid[] = "from: @(#)nfs_prot.x 2.1 88/08/01 4.0 RPCSRC";*/ ++%static const char rcsid[] = ++% "$FreeBSD: src/include/rpcsvc/nfs_prot.x,v 1.7 1999/08/27 23:45:08 peter Exp $"; ++%#endif /* not lint */ ++#endif ++ ++const NFS_PORT = 2049; ++const NFS_MAXDATA = 8192; ++const NFS_MAXPATHLEN = 1024; ++const NFS_MAXNAMLEN = 255; ++const NFS_FHSIZE = 32; ++const NFS_COOKIESIZE = 4; ++const NFS_FIFO_DEV = -1; /* size kludge for named pipes */ ++ ++/* ++ * File types ++ */ ++const NFSMODE_FMT = 0170000; /* type of file */ ++const NFSMODE_DIR = 0040000; /* directory */ ++const NFSMODE_CHR = 0020000; /* character special */ ++const NFSMODE_BLK = 0060000; /* block special */ ++const NFSMODE_REG = 0100000; /* regular */ ++const NFSMODE_LNK = 0120000; /* symbolic link */ ++const NFSMODE_SOCK = 0140000; /* socket */ ++const NFSMODE_FIFO = 0010000; /* fifo */ ++ ++/* ++ * Error status ++ */ ++enum nfsstat { ++ NFS_OK= 0, /* no error */ ++ NFSERR_PERM=1, /* Not owner */ ++ NFSERR_NOENT=2, /* No such file or directory */ ++ NFSERR_IO=5, /* I/O error */ ++ NFSERR_NXIO=6, /* No such device or address */ ++ NFSERR_ACCES=13, /* Permission denied */ ++ NFSERR_EXIST=17, /* File exists */ ++ NFSERR_NODEV=19, /* No such device */ ++ NFSERR_NOTDIR=20, /* Not a directory*/ ++ NFSERR_ISDIR=21, /* Is a directory */ ++ NFSERR_FBIG=27, /* File too large */ ++ NFSERR_NOSPC=28, /* No space left on device */ ++ NFSERR_ROFS=30, /* Read-only file system */ ++ NFSERR_NAMETOOLONG=63, /* File name too long */ ++ NFSERR_NOTEMPTY=66, /* Directory not empty */ ++ NFSERR_DQUOT=69, /* Disc quota exceeded */ ++ NFSERR_STALE=70, /* Stale NFS file handle */ ++ NFSERR_WFLUSH=99 /* write cache flushed */ ++}; ++ ++/* ++ * File types ++ */ ++enum ftype { ++ NFNON = 0, /* non-file */ ++ NFREG = 1, /* regular file */ ++ NFDIR = 2, /* directory */ ++ NFBLK = 3, /* block special */ ++ NFCHR = 4, /* character special */ ++ NFLNK = 5, /* symbolic link */ ++ NFSOCK = 6, /* unix domain sockets */ ++ NFBAD = 7, /* unused */ ++ NFFIFO = 8 /* named pipe */ ++}; ++ ++/* ++ * File access handle ++ */ ++struct nfs_fh { ++ opaque data[NFS_FHSIZE]; ++}; ++ ++/* ++ * Timeval ++ */ ++struct nfstime { ++ unsigned seconds; ++ unsigned useconds; ++}; ++ ++ ++/* ++ * File attributes ++ */ ++struct fattr { ++ ftype type; /* file type */ ++ unsigned mode; /* protection mode bits */ ++ unsigned nlink; /* # hard links */ ++ unsigned uid; /* owner user id */ ++ unsigned gid; /* owner group id */ ++ unsigned size; /* file size in bytes */ ++ unsigned blocksize; /* prefered block size */ ++ unsigned rdev; /* special device # */ ++ unsigned blocks; /* Kb of disk used by file */ ++ unsigned fsid; /* device # */ ++ unsigned fileid; /* inode # */ ++ nfstime atime; /* time of last access */ ++ nfstime mtime; /* time of last modification */ ++ nfstime ctime; /* time of last change */ ++}; ++ ++/* ++ * File attributes which can be set ++ */ ++struct sattr { ++ unsigned mode; /* protection mode bits */ ++ unsigned uid; /* owner user id */ ++ unsigned gid; /* owner group id */ ++ unsigned size; /* file size in bytes */ ++ nfstime atime; /* time of last access */ ++ nfstime mtime; /* time of last modification */ ++}; ++ ++ ++typedef string filename; ++typedef string nfspath; ++ ++/* ++ * Reply status with file attributes ++ */ ++union attrstat switch (nfsstat status) { ++case NFS_OK: ++ fattr attributes; ++default: ++ void; ++}; ++ ++struct sattrargs { ++ nfs_fh file; ++ sattr attributes; ++}; ++ ++/* ++ * Arguments for directory operations ++ */ ++struct diropargs { ++ nfs_fh dir; /* directory file handle */ ++ filename name; /* name (up to NFS_MAXNAMLEN bytes) */ ++}; ++ ++struct diropokres { ++ nfs_fh file; ++ fattr attributes; ++}; ++ ++/* ++ * Results from directory operation ++ */ ++union diropres switch (nfsstat status) { ++case NFS_OK: ++ diropokres diropres; ++default: ++ void; ++}; ++ ++union readlinkres switch (nfsstat status) { ++case NFS_OK: ++ nfspath data; ++default: ++ void; ++}; ++ ++/* ++ * Arguments to remote read ++ */ ++struct readargs { ++ nfs_fh file; /* handle for file */ ++ unsigned offset; /* byte offset in file */ ++ unsigned count; /* immediate read count */ ++ unsigned totalcount; /* total read count (from this offset)*/ ++}; ++ ++/* ++ * Status OK portion of remote read reply ++ */ ++struct readokres { ++ fattr attributes; /* attributes, need for pagin*/ ++ opaque data; ++}; ++ ++union readres switch (nfsstat status) { ++case NFS_OK: ++ readokres reply; ++default: ++ void; ++}; ++ ++/* ++ * Arguments to remote write ++ */ ++struct writeargs { ++ nfs_fh file; /* handle for file */ ++ unsigned beginoffset; /* beginning byte offset in file */ ++ unsigned offset; /* current byte offset in file */ ++ unsigned totalcount; /* total write count (to this offset)*/ ++ opaque data; ++}; ++ ++struct createargs { ++ diropargs where; ++ sattr attributes; ++}; ++ ++struct renameargs { ++ diropargs from; ++ diropargs to; ++}; ++ ++struct linkargs { ++ nfs_fh from; ++ diropargs to; ++}; ++ ++struct symlinkargs { ++ diropargs from; ++ nfspath to; ++ sattr attributes; ++}; ++ ++ ++typedef opaque nfscookie[NFS_COOKIESIZE]; ++ ++/* ++ * Arguments to readdir ++ */ ++struct readdirargs { ++ nfs_fh dir; /* directory handle */ ++ nfscookie cookie; ++ unsigned count; /* number of directory bytes to read */ ++}; ++ ++struct entry { ++ unsigned fileid; ++ filename name; ++ nfscookie cookie; ++ entry *nextentry; ++}; ++ ++struct dirlist { ++ entry *entries; ++ bool eof; ++}; ++ ++union readdirres switch (nfsstat status) { ++case NFS_OK: ++ dirlist reply; ++default: ++ void; ++}; ++ ++struct statfsokres { ++ unsigned tsize; /* preferred transfer size in bytes */ ++ unsigned bsize; /* fundamental file system block size */ ++ unsigned blocks; /* total blocks in file system */ ++ unsigned bfree; /* free blocks in fs */ ++ unsigned bavail; /* free blocks avail to non-superuser */ ++}; ++ ++union statfsres switch (nfsstat status) { ++case NFS_OK: ++ statfsokres reply; ++default: ++ void; ++}; ++ ++#ifdef WANT_NFS3 ++ ++/* ++ * NFSv3 constants and types ++ */ ++const NFS3_FHSIZE = 64; /* maximum size in bytes of a file handle */ ++const NFS3_COOKIEVERFSIZE = 8; /* size of a cookie verifier for READDIR */ ++const NFS3_CREATEVERFSIZE = 8; /* size of the verifier used for CREATE */ ++const NFS3_WRITEVERFSIZE = 8; /* size of the verifier used for WRITE */ ++ ++typedef unsigned hyper uint64; ++typedef hyper int64; ++typedef unsigned long uint32; ++typedef long int32; ++typedef string filename3<>; ++typedef string nfspath3<>; ++typedef uint64 fileid3; ++typedef uint64 cookie3; ++typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE]; ++typedef opaque createverf3[NFS3_CREATEVERFSIZE]; ++typedef opaque writeverf3[NFS3_WRITEVERFSIZE]; ++typedef uint32 uid3; ++typedef uint32 gid3; ++typedef uint64 size3; ++typedef uint64 offset3; ++typedef uint32 mode3; ++typedef uint32 count3; ++ ++/* ++ * Error status (v3) ++ */ ++enum nfsstat3 { ++ NFS3_OK = 0, ++ NFS3ERR_PERM = 1, ++ NFS3ERR_NOENT = 2, ++ NFS3ERR_IO = 5, ++ NFS3ERR_NXIO = 6, ++ NFS3ERR_ACCES = 13, ++ NFS3ERR_EXIST = 17, ++ NFS3ERR_XDEV = 18, ++ NFS3ERR_NODEV = 19, ++ NFS3ERR_NOTDIR = 20, ++ NFS3ERR_ISDIR = 21, ++ NFS3ERR_INVAL = 22, ++ NFS3ERR_FBIG = 27, ++ NFS3ERR_NOSPC = 28, ++ NFS3ERR_ROFS = 30, ++ NFS3ERR_MLINK = 31, ++ NFS3ERR_NAMETOOLONG = 63, ++ NFS3ERR_NOTEMPTY = 66, ++ NFS3ERR_DQUOT = 69, ++ NFS3ERR_STALE = 70, ++ NFS3ERR_REMOTE = 71, ++ NFS3ERR_BADHANDLE = 10001, ++ NFS3ERR_NOT_SYNC = 10002, ++ NFS3ERR_BAD_COOKIE = 10003, ++ NFS3ERR_NOTSUPP = 10004, ++ NFS3ERR_TOOSMALL = 10005, ++ NFS3ERR_SERVERFAULT = 10006, ++ NFS3ERR_BADTYPE = 10007, ++ NFS3ERR_JUKEBOX = 10008 ++}; ++ ++/* ++ * File types (v3) ++ */ ++enum ftype3 { ++ NF3REG = 1, /* regular file */ ++ NF3DIR = 2, /* directory */ ++ NF3BLK = 3, /* block special */ ++ NF3CHR = 4, /* character special */ ++ NF3LNK = 5, /* symbolic link */ ++ NF3SOCK = 6, /* unix domain sockets */ ++ NF3FIFO = 7 /* named pipe */ ++}; ++ ++struct specdata3 { ++ uint32 specdata1; ++ uint32 specdata2; ++}; ++ ++/* ++ * File access handle (v3) ++ */ ++struct nfs_fh3 { ++ opaque data; ++}; ++ ++/* ++ * Timeval (v3) ++ */ ++struct nfstime3 { ++ uint32 seconds; ++ uint32 nseconds; ++}; ++ ++ ++/* ++ * File attributes (v3) ++ */ ++struct fattr3 { ++ ftype3 type; /* file type */ ++ mode3 mode; /* protection mode bits */ ++ uint32 nlink; /* # hard links */ ++ uid3 uid; /* owner user id */ ++ gid3 gid; /* owner group id */ ++ size3 size; /* file size in bytes */ ++ size3 used; /* prefered block size */ ++ specdata3 rdev; /* special device # */ ++ uint64 fsid; /* device # */ ++ fileid3 fileid; /* inode # */ ++ nfstime3 atime; /* time of last access */ ++ nfstime3 mtime; /* time of last modification */ ++ nfstime3 ctime; /* time of last change */ ++}; ++ ++union post_op_attr switch (bool attributes_follow) { ++case TRUE: ++ fattr3 attributes; ++case FALSE: ++ void; ++}; ++ ++struct wcc_attr { ++ size3 size; ++ nfstime3 mtime; ++ nfstime3 ctime; ++}; ++ ++union pre_op_attr switch (bool attributes_follow) { ++case TRUE: ++ wcc_attr attributes; ++case FALSE: ++ void; ++}; ++ ++struct wcc_data { ++ pre_op_attr before; ++ post_op_attr after; ++}; ++ ++union post_op_fh3 switch (bool handle_follows) { ++case TRUE: ++ nfs_fh3 handle; ++case FALSE: ++ void; ++}; ++ ++/* ++ * File attributes which can be set (v3) ++ */ ++enum time_how { ++ DONT_CHANGE = 0, ++ SET_TO_SERVER_TIME = 1, ++ SET_TO_CLIENT_TIME = 2 ++}; ++ ++union set_mode3 switch (bool set_it) { ++case TRUE: ++ mode3 mode; ++default: ++ void; ++}; ++ ++union set_uid3 switch (bool set_it) { ++case TRUE: ++ uid3 uid; ++default: ++ void; ++}; ++ ++union set_gid3 switch (bool set_it) { ++case TRUE: ++ gid3 gid; ++default: ++ void; ++}; ++ ++union set_size3 switch (bool set_it) { ++case TRUE: ++ size3 size; ++default: ++ void; ++}; ++ ++union set_atime switch (time_how set_it) { ++case SET_TO_CLIENT_TIME: ++ nfstime3 atime; ++default: ++ void; ++}; ++ ++union set_mtime switch (time_how set_it) { ++case SET_TO_CLIENT_TIME: ++ nfstime3 mtime; ++default: ++ void; ++}; ++ ++struct sattr3 { ++ set_mode3 mode; ++ set_uid3 uid; ++ set_gid3 gid; ++ set_size3 size; ++ set_atime atime; ++ set_mtime mtime; ++}; ++ ++/* ++ * Arguments for directory operations (v3) ++ */ ++struct diropargs3 { ++ nfs_fh3 dir; /* directory file handle */ ++ filename3 name; /* name (up to NFS_MAXNAMLEN bytes) */ ++}; ++ ++/* ++ * Arguments to getattr (v3). ++ */ ++struct GETATTR3args { ++ nfs_fh3 object; ++}; ++ ++struct GETATTR3resok { ++ fattr3 obj_attributes; ++}; ++ ++union GETATTR3res switch (nfsstat3 status) { ++case NFS3_OK: ++ GETATTR3resok resok; ++default: ++ void; ++}; ++ ++/* ++ * Arguments to setattr (v3). ++ */ ++union sattrguard3 switch (bool check) { ++case TRUE: ++ nfstime3 obj_ctime; ++case FALSE: ++ void; ++}; ++ ++struct SETATTR3args { ++ nfs_fh3 object; ++ sattr3 new_attributes; ++ sattrguard3 guard; ++}; ++ ++struct SETATTR3resok { ++ wcc_data obj_wcc; ++}; ++ ++struct SETATTR3resfail { ++ wcc_data obj_wcc; ++}; ++ ++union SETATTR3res switch (nfsstat3 status) { ++case NFS3_OK: ++ SETATTR3resok resok; ++default: ++ SETATTR3resfail resfail; ++}; ++ ++/* ++ * Arguments to lookup (v3). ++ */ ++struct LOOKUP3args { ++ diropargs3 what; ++}; ++ ++struct LOOKUP3resok { ++ nfs_fh3 object; ++ post_op_attr obj_attributes; ++ post_op_attr dir_attributes; ++}; ++ ++struct LOOKUP3resfail { ++ post_op_attr dir_attributes; ++}; ++ ++union LOOKUP3res switch (nfsstat3 status) { ++case NFS3_OK: ++ LOOKUP3resok resok; ++default: ++ LOOKUP3resfail resfail; ++}; ++ ++/* ++ * Arguments to access (v3). ++ */ ++const ACCESS3_READ = 0x0001; ++const ACCESS3_LOOKUP = 0x0002; ++const ACCESS3_MODIFY = 0x0004; ++const ACCESS3_EXTEND = 0x0008; ++const ACCESS3_DELETE = 0x0010; ++const ACCESS3_EXECUTE = 0x0020; ++ ++struct ACCESS3args { ++ nfs_fh3 object; ++ uint32 access; ++}; ++ ++struct ACCESS3resok { ++ post_op_attr obj_attributes; ++ uint32 access; ++}; ++ ++struct ACCESS3resfail { ++ post_op_attr obj_attributes; ++}; ++ ++union ACCESS3res switch (nfsstat3 status) { ++case NFS3_OK: ++ ACCESS3resok resok; ++default: ++ ACCESS3resfail resfail; ++}; ++ ++/* ++ * Arguments to readlink (v3). ++ */ ++struct READLINK3args { ++ nfs_fh3 symlink; ++}; ++ ++struct READLINK3resok { ++ post_op_attr symlink_attributes; ++ nfspath3 data; ++}; ++ ++struct READLINK3resfail { ++ post_op_attr symlink_attributes; ++}; ++ ++union READLINK3res switch (nfsstat3 status) { ++case NFS3_OK: ++ READLINK3resok resok; ++default: ++ READLINK3resfail resfail; ++}; ++ ++/* ++ * Arguments to read (v3). ++ */ ++struct READ3args { ++ nfs_fh3 file; ++ offset3 offset; ++ count3 count; ++}; ++ ++struct READ3resok { ++ post_op_attr file_attributes; ++ count3 count; ++ bool eof; ++ opaque data<>; ++}; ++ ++struct READ3resfail { ++ post_op_attr file_attributes; ++}; ++ ++/* XXX: solaris 2.6 uses ``nfsstat'' here */ ++union READ3res switch (nfsstat3 status) { ++case NFS3_OK: ++ READ3resok resok; ++default: ++ READ3resfail resfail; ++}; ++ ++/* ++ * Arguments to write (v3). ++ */ ++enum stable_how { ++ UNSTABLE = 0, ++ DATA_SYNC = 1, ++ FILE_SYNC = 2 ++}; ++ ++struct WRITE3args { ++ nfs_fh3 file; ++ offset3 offset; ++ count3 count; ++ stable_how stable; ++ opaque data<>; ++}; ++ ++struct WRITE3resok { ++ wcc_data file_wcc; ++ count3 count; ++ stable_how committed; ++ writeverf3 verf; ++}; ++ ++struct WRITE3resfail { ++ wcc_data file_wcc; ++}; ++ ++union WRITE3res switch (nfsstat3 status) { ++case NFS3_OK: ++ WRITE3resok resok; ++default: ++ WRITE3resfail resfail; ++}; ++ ++/* ++ * Arguments to create (v3). ++ */ ++enum createmode3 { ++ UNCHECKED = 0, ++ GUARDED = 1, ++ EXCLUSIVE = 2 ++}; ++ ++union createhow3 switch (createmode3 mode) { ++case UNCHECKED: ++case GUARDED: ++ sattr3 obj_attributes; ++case EXCLUSIVE: ++ createverf3 verf; ++}; ++ ++struct CREATE3args { ++ diropargs3 where; ++ createhow3 how; ++}; ++ ++struct CREATE3resok { ++ post_op_fh3 obj; ++ post_op_attr obj_attributes; ++ wcc_data dir_wcc; ++}; ++ ++struct CREATE3resfail { ++ wcc_data dir_wcc; ++}; ++ ++union CREATE3res switch (nfsstat3 status) { ++case NFS3_OK: ++ CREATE3resok resok; ++default: ++ CREATE3resfail resfail; ++}; ++ ++/* ++ * Arguments to mkdir (v3). ++ */ ++struct MKDIR3args { ++ diropargs3 where; ++ sattr3 attributes; ++}; ++ ++struct MKDIR3resok { ++ post_op_fh3 obj; ++ post_op_attr obj_attributes; ++ wcc_data dir_wcc; ++}; ++ ++struct MKDIR3resfail { ++ wcc_data dir_wcc; ++}; ++ ++union MKDIR3res switch (nfsstat3 status) { ++case NFS3_OK: ++ MKDIR3resok resok; ++default: ++ MKDIR3resfail resfail; ++}; ++ ++/* ++ * Arguments to symlink (v3). ++ */ ++struct symlinkdata3 { ++ sattr3 symlink_attributes; ++ nfspath3 symlink_data; ++}; ++ ++struct SYMLINK3args { ++ diropargs3 where; ++ symlinkdata3 symlink; ++}; ++ ++struct SYMLINK3resok { ++ post_op_fh3 obj; ++ post_op_attr obj_attributes; ++ wcc_data dir_wcc; ++}; ++ ++struct SYMLINK3resfail { ++ wcc_data dir_wcc; ++}; ++ ++union SYMLINK3res switch (nfsstat3 status) { ++case NFS3_OK: ++ SYMLINK3resok resok; ++default: ++ SYMLINK3resfail resfail; ++}; ++ ++/* ++ * Arguments to mknod (v3). ++ */ ++struct devicedata3 { ++ sattr3 dev_attributes; ++ specdata3 spec; ++}; ++ ++union mknoddata3 switch (ftype3 type) { ++case NF3CHR: ++case NF3BLK: ++ devicedata3 device; ++case NF3SOCK: ++case NF3FIFO: ++ sattr3 pipe_attributes; ++default: ++ void; ++}; ++ ++struct MKNOD3args { ++ diropargs3 where; ++ mknoddata3 what; ++}; ++ ++struct MKNOD3resok { ++ post_op_fh3 obj; ++ post_op_attr obj_attributes; ++ wcc_data dir_wcc; ++}; ++ ++struct MKNOD3resfail { ++ wcc_data dir_wcc; ++}; ++ ++union MKNOD3res switch (nfsstat3 status) { ++case NFS3_OK: ++ MKNOD3resok resok; ++default: ++ MKNOD3resfail resfail; ++}; ++ ++/* ++ * Arguments to remove (v3). ++ */ ++struct REMOVE3args { ++ diropargs3 object; ++}; ++ ++struct REMOVE3resok { ++ wcc_data dir_wcc; ++}; ++ ++struct REMOVE3resfail { ++ wcc_data dir_wcc; ++}; ++ ++union REMOVE3res switch (nfsstat3 status) { ++case NFS3_OK: ++ REMOVE3resok resok; ++default: ++ REMOVE3resfail resfail; ++}; ++ ++/* ++ * Arguments to rmdir (v3). ++ */ ++struct RMDIR3args { ++ diropargs3 object; ++}; ++ ++struct RMDIR3resok { ++ wcc_data dir_wcc; ++}; ++ ++struct RMDIR3resfail { ++ wcc_data dir_wcc; ++}; ++ ++union RMDIR3res switch (nfsstat3 status) { ++case NFS3_OK: ++ RMDIR3resok resok; ++default: ++ RMDIR3resfail resfail; ++}; ++ ++/* ++ * Arguments to rename (v3). ++ */ ++struct RENAME3args { ++ diropargs3 from; ++ diropargs3 to; ++}; ++ ++struct RENAME3resok { ++ wcc_data fromdir_wcc; ++ wcc_data todir_wcc; ++}; ++ ++struct RENAME3resfail { ++ wcc_data fromdir_wcc; ++ wcc_data todir_wcc; ++}; ++ ++union RENAME3res switch (nfsstat3 status) { ++case NFS3_OK: ++ RENAME3resok resok; ++default: ++ RENAME3resfail resfail; ++}; ++ ++/* ++ * Arguments to link (v3). ++ */ ++struct LINK3args { ++ nfs_fh3 file; ++ diropargs3 link; ++}; ++ ++struct LINK3resok { ++ post_op_attr file_attributes; ++ wcc_data linkdir_wcc; ++}; ++ ++struct LINK3resfail { ++ post_op_attr file_attributes; ++ wcc_data linkdir_wcc; ++}; ++ ++union LINK3res switch (nfsstat3 status) { ++case NFS3_OK: ++ LINK3resok resok; ++default: ++ LINK3resfail resfail; ++}; ++ ++/* ++ * Arguments to readdir (v3). ++ */ ++struct READDIR3args { ++ nfs_fh3 dir; ++ cookie3 cookie; ++ cookieverf3 cookieverf; ++ count3 count; ++}; ++ ++struct entry3 { ++ fileid3 fileid; ++ filename3 name; ++ cookie3 cookie; ++ entry3 *nextentry; ++}; ++ ++struct dirlist3 { ++ entry3 *entries; ++ bool eof; ++}; ++ ++struct READDIR3resok { ++ post_op_attr dir_attributes; ++ cookieverf3 cookieverf; ++ dirlist3 reply; ++}; ++ ++struct READDIR3resfail { ++ post_op_attr dir_attributes; ++}; ++ ++union READDIR3res switch (nfsstat3 status) { ++case NFS3_OK: ++ READDIR3resok resok; ++default: ++ READDIR3resfail resfail; ++}; ++ ++/* ++ * Arguments to readdirplus (v3). ++ */ ++struct READDIRPLUS3args { ++ nfs_fh3 dir; ++ cookie3 cookie; ++ cookieverf3 cookieverf; ++ count3 dircount; ++ count3 maxcount; ++}; ++ ++struct entryplus3 { ++ fileid3 fileid; ++ filename3 name; ++ cookie3 cookie; ++ post_op_attr name_attributes; ++ post_op_fh3 name_handle; ++ entryplus3 *nextentry; ++}; ++ ++struct dirlistplus3 { ++ entryplus3 *entries; ++ bool eof; ++}; ++ ++struct READDIRPLUS3resok { ++ post_op_attr dir_attributes; ++ cookieverf3 cookieverf; ++ dirlistplus3 reply; ++}; ++ ++struct READDIRPLUS3resfail { ++ post_op_attr dir_attributes; ++}; ++ ++union READDIRPLUS3res switch (nfsstat3 status) { ++case NFS3_OK: ++ READDIRPLUS3resok resok; ++default: ++ READDIRPLUS3resfail resfail; ++}; ++ ++/* ++ * Arguments to fsstat (v3). ++ */ ++struct FSSTAT3args { ++ nfs_fh3 fsroot; ++}; ++ ++struct FSSTAT3resok { ++ post_op_attr obj_attributes; ++ size3 tbytes; ++ size3 fbytes; ++ size3 abytes; ++ size3 tfiles; ++ size3 ffiles; ++ size3 afiles; ++ uint32 invarsec; ++}; ++ ++struct FSSTAT3resfail { ++ post_op_attr obj_attributes; ++}; ++ ++union FSSTAT3res switch (nfsstat3 status) { ++case NFS3_OK: ++ FSSTAT3resok resok; ++default: ++ FSSTAT3resfail resfail; ++}; ++ ++/* ++ * Arguments to fsinfo (v3). ++ */ ++const FSF3_LINK = 0x0001; ++const FSF3_SYMLINK = 0x0002; ++const FSF3_HOMOGENEOUS = 0x0008; ++const FSF3_CANSETTIME = 0x0010; ++ ++struct FSINFO3args { ++ nfs_fh3 fsroot; ++}; ++ ++struct FSINFO3resok { ++ post_op_attr obj_attributes; ++ uint32 rtmax; ++ uint32 rtpref; ++ uint32 rtmult; ++ uint32 wtmax; ++ uint32 wtpref; ++ uint32 wtmult; ++ uint32 dtpref; ++ size3 maxfilesize; ++ nfstime3 time_delta; ++ uint32 properties; ++}; ++ ++struct FSINFO3resfail { ++ post_op_attr obj_attributes; ++}; ++ ++union FSINFO3res switch (nfsstat3 status) { ++case NFS3_OK: ++ FSINFO3resok resok; ++default: ++ FSINFO3resfail resfail; ++}; ++ ++/* ++ * Arguments to pathconf (v3). ++ */ ++struct PATHCONF3args { ++ nfs_fh3 object; ++}; ++ ++struct PATHCONF3resok { ++ post_op_attr obj_attributes; ++ uint32 linkmax; ++ uint32 name_max; ++ bool no_trunc; ++ bool chown_restricted; ++ bool case_insensitive; ++ bool case_preserving; ++}; ++ ++struct PATHCONF3resfail { ++ post_op_attr obj_attributes; ++}; ++ ++union PATHCONF3res switch (nfsstat3 status) { ++case NFS3_OK: ++ PATHCONF3resok resok; ++default: ++ PATHCONF3resfail resfail; ++}; ++ ++/* ++ * Arguments to commit (v3). ++ */ ++struct COMMIT3args { ++ nfs_fh3 file; ++ offset3 offset; ++ count3 count; ++}; ++ ++struct COMMIT3resok { ++ wcc_data file_wcc; ++ writeverf3 verf; ++}; ++ ++struct COMMIT3resfail { ++ wcc_data file_wcc; ++}; ++ ++union COMMIT3res switch (nfsstat3 status) { ++case NFS3_OK: ++ COMMIT3resok resok; ++default: ++ COMMIT3resfail resfail; ++}; ++ ++#endif /* WANT_NFS3 */ ++ ++/* ++ * Remote file service routines ++ */ ++program NFS_PROGRAM { ++ version NFS_VERSION { ++ void ++ NFSPROC_NULL(void) = 0; ++ ++ attrstat ++ NFSPROC_GETATTR(nfs_fh) = 1; ++ ++ attrstat ++ NFSPROC_SETATTR(sattrargs) = 2; ++ ++ void ++ NFSPROC_ROOT(void) = 3; ++ ++ diropres ++ NFSPROC_LOOKUP(diropargs) = 4; ++ ++ readlinkres ++ NFSPROC_READLINK(nfs_fh) = 5; ++ ++ readres ++ NFSPROC_READ(readargs) = 6; ++ ++ void ++ NFSPROC_WRITECACHE(void) = 7; ++ ++ attrstat ++ NFSPROC_WRITE(writeargs) = 8; ++ ++ diropres ++ NFSPROC_CREATE(createargs) = 9; ++ ++ nfsstat ++ NFSPROC_REMOVE(diropargs) = 10; ++ ++ nfsstat ++ NFSPROC_RENAME(renameargs) = 11; ++ ++ nfsstat ++ NFSPROC_LINK(linkargs) = 12; ++ ++ nfsstat ++ NFSPROC_SYMLINK(symlinkargs) = 13; ++ ++ diropres ++ NFSPROC_MKDIR(createargs) = 14; ++ ++ nfsstat ++ NFSPROC_RMDIR(diropargs) = 15; ++ ++ readdirres ++ NFSPROC_READDIR(readdirargs) = 16; ++ ++ statfsres ++ NFSPROC_STATFS(nfs_fh) = 17; ++ } = 2; ++} = 100003; ++#ifdef WANT_NFS3 ++program NFS3_PROGRAM { ++ version NFS_V3 { ++ void ++ NFSPROC3_NULL(void) = 0; ++ ++ GETATTR3res ++ NFSPROC3_GETATTR(GETATTR3args) = 1; ++ ++ SETATTR3res ++ NFSPROC3_SETATTR(SETATTR3args) = 2; ++ ++ LOOKUP3res ++ NFSPROC3_LOOKUP(LOOKUP3args) = 3; ++ ++ ACCESS3res ++ NFSPROC3_ACCESS(ACCESS3args) = 4; ++ ++ READLINK3res ++ NFSPROC3_READLINK(READLINK3args) = 5; ++ ++ READ3res ++ NFSPROC3_READ(READ3args) = 6; ++ ++ WRITE3res ++ NFSPROC3_WRITE(WRITE3args) = 7; ++ ++ CREATE3res ++ NFSPROC3_CREATE(CREATE3args) = 8; ++ ++ MKDIR3res ++ NFSPROC3_MKDIR(MKDIR3args) = 9; ++ ++ SYMLINK3res ++ NFSPROC3_SYMLINK(SYMLINK3args) = 10; ++ ++ MKNOD3res ++ NFSPROC3_MKNOD(MKNOD3args) = 11; ++ ++ REMOVE3res ++ NFSPROC3_REMOVE(REMOVE3args) = 12; ++ ++ RMDIR3res ++ NFSPROC3_RMDIR(RMDIR3args) = 13; ++ ++ RENAME3res ++ NFSPROC3_RENAME(RENAME3args) = 14; ++ ++ LINK3res ++ NFSPROC3_LINK(LINK3args) = 15; ++ ++ READDIR3res ++ NFSPROC3_READDIR(READDIR3args) = 16; ++ ++ READDIRPLUS3res ++ NFSPROC3_READDIRPLUS(READDIRPLUS3args) = 17; ++ ++ FSSTAT3res ++ NFSPROC3_FSSTAT(FSSTAT3args) = 18; ++ ++ FSINFO3res ++ NFSPROC3_FSINFO(FSINFO3args) = 19; ++ ++ PATHCONF3res ++ NFSPROC3_PATHCONF(PATHCONF3args) = 20; ++ ++ COMMIT3res ++ NFSPROC3_COMMIT(COMMIT3args) = 21; ++ } = 3; ++} = 100003; ++#endif ++ +diff --git a/tirpc/rpcsvc/rquota.x b/tirpc/rpcsvc/rquota.x +new file mode 100644 +index 0000000..72864d1 +--- /dev/null ++++ b/tirpc/rpcsvc/rquota.x +@@ -0,0 +1,67 @@ ++/* ++ * Remote quota protocol ++ * Requires unix authentication ++ */ ++ ++#ifndef RPC_HDR ++%#ifndef lint ++%/*static char sccsid[] = "from: @(#)rquota.x 1.2 87/09/20 Copyr 1987 Sun Micro";*/ ++%/*static char sccsid[] = "from: @(#)rquota.x 2.1 88/08/01 4.0 RPCSRC";*/ ++%static const char rcsid[] = ++% "$FreeBSD: src/include/rpcsvc/rquota.x,v 1.6 1999/08/27 23:45:10 peter Exp $"; ++%#endif /* not lint */ ++#endif ++ ++const RQ_PATHLEN = 1024; ++ ++struct getquota_args { ++ string gqa_pathp; /* path to filesystem of interest */ ++ int gqa_uid; /* inquire about quota for uid */ ++}; ++ ++/* ++ * remote quota structure ++ */ ++struct rquota { ++ int rq_bsize; /* block size for block counts */ ++ bool rq_active; /* indicates whether quota is active */ ++ unsigned int rq_bhardlimit; /* absolute limit on disk blks alloc */ ++ unsigned int rq_bsoftlimit; /* preferred limit on disk blks */ ++ unsigned int rq_curblocks; /* current block count */ ++ unsigned int rq_fhardlimit; /* absolute limit on allocated files */ ++ unsigned int rq_fsoftlimit; /* preferred file limit */ ++ unsigned int rq_curfiles; /* current # allocated files */ ++ unsigned int rq_btimeleft; /* time left for excessive disk use */ ++ unsigned int rq_ftimeleft; /* time left for excessive files */ ++}; ++ ++enum gqr_status { ++ Q_OK = 1, /* quota returned */ ++ Q_NOQUOTA = 2, /* noquota for uid */ ++ Q_EPERM = 3 /* no permission to access quota */ ++}; ++ ++union getquota_rslt switch (gqr_status status) { ++case Q_OK: ++ rquota gqr_rquota; /* valid if status == Q_OK */ ++case Q_NOQUOTA: ++ void; ++case Q_EPERM: ++ void; ++}; ++ ++program RQUOTAPROG { ++ version RQUOTAVERS { ++ /* ++ * Get all quotas ++ */ ++ getquota_rslt ++ RQUOTAPROC_GETQUOTA(getquota_args) = 1; ++ ++ /* ++ * Get active quotas only ++ */ ++ getquota_rslt ++ RQUOTAPROC_GETACTIVEQUOTA(getquota_args) = 2; ++ } = 1; ++} = 100011; +-- +2.0.0 + diff --git a/package/libtirpc/libtirpc-0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch b/package/libtirpc/libtirpc-0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch deleted file mode 100644 index 9bcca8aa94..0000000000 --- a/package/libtirpc/libtirpc-0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch +++ /dev/null @@ -1,70 +0,0 @@ -From 4285205401faeb12b4ed7ebbc4658af9eae73eb4 Mon Sep 17 00:00:00 2001 -From: Thomas Petazzoni -Date: Sat, 23 Jun 2012 21:57:39 +0200 -Subject: [PATCH] Disable parts of TIRPC requiring NIS support - -Signed-off-by: Thomas Petazzoni ---- - src/Makefile.am | 3 +-- - src/rpc_soc.c | 2 ++ - tirpc/rpc/auth.h | 3 +++ - 3 files changed, 6 insertions(+), 2 deletions(-) - -diff --git a/src/Makefile.am b/src/Makefile.am -index 3029b78..b5db263 100644 ---- a/src/Makefile.am -+++ b/src/Makefile.am -@@ -50,8 +50,7 @@ libtirpc_la_SOURCES = auth_none.c auth_unix.c authunix_prot.c bindresvport.c cln - pmap_prot.c pmap_prot2.c pmap_rmt.c rpc_prot.c rpc_commondata.c \ - rpc_callmsg.c rpc_generic.c rpc_soc.c rpcb_clnt.c rpcb_prot.c \ - rpcb_st_xdr.c svc.c svc_auth.c svc_dg.c svc_auth_unix.c svc_auth_none.c \ -- svc_generic.c svc_raw.c svc_run.c svc_simple.c svc_vc.c getpeereid.c \ -- auth_time.c auth_des.c authdes_prot.c -+ svc_generic.c svc_raw.c svc_run.c svc_simple.c svc_vc.c getpeereid.c - - ## XDR - libtirpc_la_SOURCES += xdr.c xdr_rec.c xdr_array.c xdr_float.c xdr_mem.c xdr_reference.c xdr_stdio.c -diff --git a/src/rpc_soc.c b/src/rpc_soc.c -index 4213ca0..2603548 100644 ---- a/src/rpc_soc.c -+++ b/src/rpc_soc.c -@@ -520,6 +520,7 @@ clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult) - (resultproc_t) rpc_wrap_bcast, "udp"); - } - -+#if 0 - /* - * Create the client des authentication object. Obsoleted by - * authdes_seccreate(). -@@ -551,6 +552,7 @@ fallback: - dummy = authdes_seccreate(servername, window, NULL, ckey); - return (dummy); - } -+#endif - - /* - * Create a client handle for a unix connection. Obsoleted by clnt_vc_create() -diff --git a/tirpc/rpc/auth.h b/tirpc/rpc/auth.h -index 4ce11f0..b894e44 100644 ---- a/tirpc/rpc/auth.h -+++ b/tirpc/rpc/auth.h -@@ -305,6 +305,8 @@ extern AUTH *authunix_create(char *, uid_t, uid_t, int, uid_t *); - extern AUTH *authunix_create_default(void); /* takes no parameters */ - extern AUTH *authnone_create(void); /* takes no parameters */ - __END_DECLS -+ -+#if 0 - /* - * DES style authentication - * AUTH *authsecdes_create(servername, window, timehost, ckey) -@@ -318,6 +320,7 @@ extern AUTH *authdes_create (char *, u_int, struct sockaddr *, des_block *); - extern AUTH *authdes_seccreate (const char *, const u_int, const char *, - const des_block *); - __END_DECLS -+#endif - - __BEGIN_DECLS - extern bool_t xdr_opaque_auth (XDR *, struct opaque_auth *); --- -2.0.0 - diff --git a/package/libtirpc/libtirpc-0002-uClibc-without-RPC-support-does-not-install-rpcent.h.patch b/package/libtirpc/libtirpc-0002-uClibc-without-RPC-support-does-not-install-rpcent.h.patch deleted file mode 100644 index 6ec5d8e43d..0000000000 --- a/package/libtirpc/libtirpc-0002-uClibc-without-RPC-support-does-not-install-rpcent.h.patch +++ /dev/null @@ -1,29 +0,0 @@ -From a20f33ad121fb1e9d1fbc31a0044546450677e7a Mon Sep 17 00:00:00 2001 -From: Thomas Petazzoni -Date: Sat, 23 Jun 2012 21:58:07 +0200 -Subject: [PATCH] uClibc without RPC support does not install rpcent.h - -Signed-off-by: Thomas Petazzoni ---- - tirpc/rpc/rpcent.h | 5 +++-- - 1 file changed, 3 insertions(+), 2 deletions(-) - -diff --git a/tirpc/rpc/rpcent.h b/tirpc/rpc/rpcent.h -index c865e51..45775ed 100644 ---- a/tirpc/rpc/rpcent.h -+++ b/tirpc/rpc/rpcent.h -@@ -46,8 +46,9 @@ - - __BEGIN_DECLS - --/* These are defined in /usr/include/rpc/netdb.h */ --#if 0 -+/* These are defined in /usr/include/rpc/netdb.h, unless we are using -+ the C library without RPC support. */ -+#if defined(__UCLIBC__) && !defined(__UCLIBC_HAS_RPC__) - struct rpcent { - char *r_name; /* name of server for this rpc program */ - char **r_aliases; /* alias list */ --- -2.0.0 - diff --git a/package/libtirpc/libtirpc-0004-Make-IPv6-support-optional.patch b/package/libtirpc/libtirpc-0004-Make-IPv6-support-optional.patch deleted file mode 100644 index ad8ce653e0..0000000000 --- a/package/libtirpc/libtirpc-0004-Make-IPv6-support-optional.patch +++ /dev/null @@ -1,26 +0,0 @@ -From fbe5fccf0e3bdaae3defc66a288176797fd12a17 Mon Sep 17 00:00:00 2001 -From: Thomas Petazzoni -Date: Sun, 24 Jun 2012 21:40:21 +0200 -Subject: [PATCH] Make IPv6 support optional - -Signed-off-by: Thomas Petazzoni ---- - src/Makefile.am | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - -diff --git a/src/Makefile.am b/src/Makefile.am -index b5db263..f086255 100644 ---- a/src/Makefile.am -+++ b/src/Makefile.am -@@ -7,7 +7,7 @@ - - noinst_HEADERS = rpc_com.h - --AM_CPPFLAGS = -I$(top_srcdir)/tirpc -DPORTMAP -DINET6 \ -+AM_CPPFLAGS = -I$(top_srcdir)/tirpc -DPORTMAP \ - -D_GNU_SOURCE -Wall -pipe - - lib_LTLIBRARIES = libtirpc.la --- -2.0.0 - 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 deleted file mode 100644 index 195803ca04..0000000000 --- a/package/libtirpc/libtirpc-0008-Add-rpcgen-program-from-nfs-utils-sources.patch +++ /dev/null @@ -1,6505 +0,0 @@ -From c4c4550dafabda05d78ca4aa9969db8a4f70affe Mon Sep 17 00:00:00 2001 -From: Thomas Petazzoni -Date: Sat, 10 Nov 2012 16:21:01 +0100 -Subject: [PATCH] Add rpcgen program from nfs-utils sources - -Signed-off-by: Thomas Petazzoni ---- - Makefile.am | 2 +- - configure.ac | 14 +- - rpcgen/Makefile.am | 22 ++ - rpcgen/rpc_clntout.c | 217 ++++++++++ - rpcgen/rpc_cout.c | 706 +++++++++++++++++++++++++++++++++ - rpcgen/rpc_hout.c | 490 +++++++++++++++++++++++ - rpcgen/rpc_main.c | 1067 ++++++++++++++++++++++++++++++++++++++++++++++++++ - rpcgen/rpc_output.h | 16 + - rpcgen/rpc_parse.c | 609 ++++++++++++++++++++++++++++ - rpcgen/rpc_parse.h | 166 ++++++++ - rpcgen/rpc_sample.c | 247 ++++++++++++ - rpcgen/rpc_scan.c | 474 ++++++++++++++++++++++ - rpcgen/rpc_scan.h | 103 +++++ - rpcgen/rpc_svcout.c | 882 +++++++++++++++++++++++++++++++++++++++++ - rpcgen/rpc_tblout.c | 165 ++++++++ - rpcgen/rpc_util.c | 479 ++++++++++++++++++++++ - rpcgen/rpc_util.h | 166 ++++++++ - rpcgen/rpcgen.1 | 521 ++++++++++++++++++++++++ - 18 files changed, 6344 insertions(+), 2 deletions(-) - create mode 100644 rpcgen/Makefile.am - create mode 100644 rpcgen/rpc_clntout.c - create mode 100644 rpcgen/rpc_cout.c - create mode 100644 rpcgen/rpc_hout.c - create mode 100644 rpcgen/rpc_main.c - create mode 100644 rpcgen/rpc_output.h - create mode 100644 rpcgen/rpc_parse.c - create mode 100644 rpcgen/rpc_parse.h - create mode 100644 rpcgen/rpc_sample.c - create mode 100644 rpcgen/rpc_scan.c - create mode 100644 rpcgen/rpc_scan.h - create mode 100644 rpcgen/rpc_svcout.c - create mode 100644 rpcgen/rpc_tblout.c - create mode 100644 rpcgen/rpc_util.c - create mode 100644 rpcgen/rpc_util.h - create mode 100644 rpcgen/rpcgen.1 - -diff --git a/Makefile.am b/Makefile.am -index 9b812eb..6edf029 100644 ---- a/Makefile.am -+++ b/Makefile.am -@@ -1,4 +1,4 @@ --SUBDIRS = src man doc -+SUBDIRS = src man doc rpcgen - ACLOCAL_AMFLAGS = -I m4 - - noinst_HEADERS = tirpc/reentrant.h \ -diff --git a/configure.ac b/configure.ac -index 11df020..4110225 100644 ---- a/configure.ac -+++ b/configure.ac -@@ -34,5 +34,17 @@ AC_CHECK_LIB([pthread], [pthread_create]) - AC_CHECK_LIB([nsl], [yp_get_default_domain]) - - --AC_CONFIG_FILES([Makefile src/Makefile man/Makefile doc/Makefile]) -+AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes) -+ -+AC_MSG_CHECKING([for a C compiler for build tools]) -+if test $cross_compiling = yes; then -+ AC_CHECK_PROGS(CC_FOR_BUILD, gcc cc) -+else -+ CC_FOR_BUILD=$CC -+fi -+AC_MSG_RESULT([$CC_FOR_BUILD]) -+AC_SUBST(CC_FOR_BUILD) -+ -+AC_CONFIG_FILES([Makefile src/Makefile man/Makefile doc/Makefile rpcgen/Makefile]) -+ - AC_OUTPUT(libtirpc.pc) -diff --git a/rpcgen/Makefile.am b/rpcgen/Makefile.am -new file mode 100644 -index 0000000..2277b6f ---- /dev/null -+++ b/rpcgen/Makefile.am -@@ -0,0 +1,22 @@ -+COMPILE = $(CC_FOR_BUILD) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ -+ $(CPPFLAGS_FOR_BUILD) $(AM_CFLAGS) $(CFLAGS_FOR_BUILD) -+LINK = $(CC_FOR_BUILD) $(AM_CFLAGS) $(CFLAGS_FOR_BUILD) $(AM_LDFLAGS) $(LDFLAGS_FOR_BUILD) -o $@ -+ -+bin_PROGRAMS = rpcgen -+ -+rpcgen_SOURCES = \ -+ rpc_clntout.c \ -+ rpc_cout.c \ -+ rpc_hout.c \ -+ rpc_main.c \ -+ rpc_parse.c \ -+ rpc_sample.c \ -+ rpc_scan.c \ -+ rpc_svcout.c \ -+ rpc_tblout.c \ -+ rpc_util.c \ -+ rpc_parse.h \ -+ rpc_scan.h \ -+ rpc_util.h -+ -+dist_man1_MANS = rpcgen.1 -diff --git a/rpcgen/rpc_clntout.c b/rpcgen/rpc_clntout.c -new file mode 100644 -index 0000000..e2f4382 ---- /dev/null -+++ b/rpcgen/rpc_clntout.c -@@ -0,0 +1,217 @@ -+/* -+ * Copyright (c) 2009, Sun Microsystems, Inc. -+ * All rights reserved. -+ * -+ * Redistribution and use in source and binary forms, with or without -+ * modification, are permitted provided that the following conditions are met: -+ * - Redistributions of source code must retain the above copyright notice, -+ * this list of conditions and the following disclaimer. -+ * - Redistributions in binary form must reproduce the above copyright notice, -+ * this list of conditions and the following disclaimer in the documentation -+ * and/or other materials provided with the distribution. -+ * - Neither the name of Sun Microsystems, Inc. nor the names of its -+ * contributors may be used to endorse or promote products derived -+ * from this software without specific prior written permission. -+ * -+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE -+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -+ * POSSIBILITY OF SUCH DAMAGE. -+ */ -+ -+#if 0 -+static char sccsid[] = "@(#)rpc_clntout.c 1.11 89/02/22 (C) 1987 SMI"; -+#endif -+ -+/* -+ * rpc_clntout.c, Client-stub outputter for the RPC protocol compiler -+ * Copyright (C) 1987, Sun Microsytsems, Inc. -+ */ -+#include -+#include -+#include -+#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 -+#include -+#include -+#include -+#include -+#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 -+#include -+#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 -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#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" : 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 \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 \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 \n"); -+ -+ f_print(fout, "#include \n"); -+ f_print(fout, "#include /* getenv, exit */\n"); -+ if (Cflag) { -+ f_print (fout, "#include /* for pmap_unset */\n"); -+ f_print (fout, "#include /* 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 \n"); -+ timerflag = 1; -+ } -+ -+#ifndef linux -+ if( !tirpcflag && inetdflag ) -+ f_print(fout, "#include /* TIOCNOTTY */\n"); -+#else -+ if( !tirpcflag ) -+ f_print(fout, "#include /* TIOCNOTTY */\n"); -+#endif -+ if( Cflag && (inetdflag || pmflag ) ) { -+ f_print(fout, "#ifdef __cplusplus\n"); -+ f_print(fout, "#include /* getdtablesize, open */\n"); -+ f_print(fout, "#endif /* __cplusplus */\n"); -+ -+ if( tirpcflag ) -+ f_print(fout, "#include /* setsid */\n"); -+ } -+ if( tirpcflag ) -+ f_print(fout, "#include \n"); -+ -+ f_print(fout, "#include \n"); -+#ifndef linux -+ f_print(fout, "#include \n"); -+#endif -+ if (inetdflag || !tirpcflag ) { -+ f_print(fout, "#include \n"); -+ f_print(fout, "#include \n"); -+ } -+ -+ if ( (netflag || pmflag) && tirpcflag ) { -+ f_print(fout, "#include \n"); -+ } -+ if (/*timerflag &&*/ tirpcflag) -+ f_print(fout, "#include /* rlimit */\n"); -+ if (logflag || inetdflag || pmflag) { -+#ifdef linux -+ f_print(fout, "#include \n"); -+#else -+ f_print(fout, "#ifdef SYSLOG\n"); -+ f_print(fout, "#include \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 /* for memset */\n"); -+ if (infile && (include = extendfile(infile, ".h"))) { -+ f_print(fout, "#include \"%s\"\n", include); -+ free(include); -+ } else -+ f_print(fout, "#include \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 \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 \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 -+#include -+#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 -+#include -+#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 -+#include -+#include -+#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 -+#include -+#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 -+#include -+#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 -+#include -+#include -+#include -+#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 -+ -+#define alloc(size) malloc((unsigned)(size)) -+#define ALLOC(object) (object *) malloc(sizeof(object)) -+ -+#define s_print (void) sprintf -+#define f_print (void) fprintf -+ -+struct list { -+ definition *val; -+ struct list *next; -+}; -+typedef struct list list; -+ -+#define PUT 1 -+#define GET 2 -+ -+/* -+ * Global variables -+ */ -+#define MAXLINESIZE 1024 -+extern char curline[MAXLINESIZE]; -+extern char *where; -+extern int linenum; -+ -+extern char *infilename; -+extern FILE *fout; -+extern FILE *fin; -+ -+extern list *defined; -+ -+ -+extern bas_type *typ_list_h; -+extern bas_type *typ_list_t; -+ -+/* -+ * All the option flags -+ */ -+extern int inetdflag; -+extern int pmflag; -+extern int tblflag; -+extern int logflag; -+extern int newstyle; -+extern int Cflag; /* C++ flag */ -+extern int tirpcflag; /* flag for generating tirpc code */ -+extern int Inline; /* if this is 0, then do not generate inline code */ -+ -+/* -+ * Other flags related with inetd jumpstart. -+ */ -+extern int indefinitewait; -+extern int exitnow; -+extern int timerflag; -+ -+extern int nonfatalerrors; -+ -+/* -+ * rpc_util routines -+ */ -+void storeval(); -+ -+#define STOREVAL(list,item) \ -+ storeval(list,item) -+ -+definition *findval(); -+ -+#define FINDVAL(list,item,finder) \ -+ findval(list, item, finder) -+ -+ -+/* -+ * rpc_cout routines -+ */ -+void cprint(void); -+void emit(definition *); -+ -+/* -+ * rpc_hout routines -+ */ -+void print_datadef(definition *); -+void print_funcdef(definition *); -+ -+/* -+ * rpc_svcout routines -+ */ -+void write_most(char *, int, int); -+void write_register(void); -+void write_netid_register(char *); -+void write_nettype_register(char *); -+void write_inetd_register(char *); -+void write_rest(void); -+void write_programs(char *); -+void write_svc_aux(int); -+ -+/* -+ * rpc_clntout routines -+ */ -+void write_stubs(void); -+void printarglist(proc_list *, char *, char *); -+ -+/* -+ * rpc_tblout routines -+ */ -+void write_tables(void); -+ -+/* -+ * rpc_util -+ */ -+void pvname_svc(char *, char *); -+void pvname(char *, char *); -+void ptype(char *, char *, int); -+char * make_argname(char *, char *); -+void add_type(int, char *); -+void reinitialize(void); -+void crash(void); -+void error(char *); -+char *fixtype(char *); -+char *stringfix(char *); -+char *locase(char *); -+int isvectordef(char *, relation); -+int streq(char *, char *); -+void tabify(FILE *, int); -+void record_open(char *); -+bas_type *find_type(char *type); -+ -+/* -+ * rpc_sample -+ */ -+void write_sample_svc(definition *); -+int write_sample_clnt(definition *); -+void write_sample_clnt_main(void); -+void add_sample_msg(void); -diff --git a/rpcgen/rpcgen.1 b/rpcgen/rpcgen.1 -new file mode 100644 -index 0000000..89df7ed ---- /dev/null -+++ b/rpcgen/rpcgen.1 -@@ -0,0 +1,521 @@ -+.\" @(#)rpcgen.1 1.35 93/06/02 SMI -+.\" $FreeBSD: src/usr.bin/rpcgen/rpcgen.1,v 1.12.2.4 2002/06/21 15:28:50 charnier Exp $ -+.\" Copyright 1985-1993 Sun Microsystems, Inc. -+.Dd March 28, 1993 -+.Dt RPCGEN 1 -+.Os -+.Sh NAME -+.Nm rpcgen -+.Nd an RPC protocol compiler -+.Sh SYNOPSIS -+.Nm -+.Ar infile -+.Nm -+.Op Fl a -+.Op Fl b -+.Op Fl C -+.Oo -+.Fl D Ns Ar name Ns Op Ar =value -+.Oc -+.Op Fl i Ar size -+.Op Fl I Op Fl K Ar seconds -+.Op Fl L -+.Op Fl M -+.Op Fl N -+.Op Fl T -+.Op Fl Y Ar pathname -+.Ar infile -+.Nm -+.Oo -+.Fl c | -+.Fl h | -+.Fl l | -+.Fl m | -+.Fl t | -+.Fl \&Sc | -+.Fl \&Ss | -+.Fl \&Sm -+.Oc -+.Op Fl o Ar outfile -+.Op Ar infile -+.Nm -+.Op Fl s Ar nettype -+.Op Fl o Ar outfile -+.Op Ar infile -+.Nm -+.Op Fl n Ar netid -+.Op Fl o Ar outfile -+.Op Ar infile -+.\" .SH AVAILABILITY -+.\" .LP -+.\" SUNWcsu -+.Sh DESCRIPTION -+The -+.Nm -+utility is a tool that generates C code to implement an -+.Tn RPC -+protocol. -+The input to -+.Nm -+is a language similar to C known as -+.Tn RPC -+Language (Remote Procedure Call Language). -+.Pp -+The -+.Nm -+utility is normally used as in the first synopsis where -+it takes an input file and generates three output files. -+If the -+.Ar infile -+is named -+.Pa proto.x , -+then -+.Nm -+generates a header in -+.Pa proto.h , -+XDR routines in -+.Pa proto_xdr.c , -+server-side stubs in -+.Pa proto_svc.c , -+and client-side stubs in -+.Pa proto_clnt.c . -+With the -+.Fl T -+option, -+it also generates the -+.Tn RPC -+dispatch table in -+.Pa proto_tbl.i . -+.Pp -+The -+.Nm -+utility can also generate sample client and server files -+that can be customized to suit a particular application. -+The -+.Fl \&Sc , -+.Fl \&Ss -+and -+.Fl \&Sm -+options generate sample client, server and makefile, respectively. -+The -+.Fl a -+option generates all files, including sample files. -+If the -+.Ar infile -+is -+.Pa proto.x , -+then the client side sample file is written to -+.Pa proto_client.c , -+the server side sample file to -+.Pa proto_server.c -+and the sample makefile to -+.Pa makefile.proto . -+.Pp -+The server created can be started both by the port monitors -+(for example, -+.Xr inetd 8 ) -+or by itself. -+When it is started by a port monitor, -+it creates servers only for the transport for which -+the file descriptor -+.Em 0 -+was passed. -+The name of the transport must be specified -+by setting up the environment variable -+.Ev PM_TRANSPORT . -+When the server generated by -+.Nm -+is executed, -+it creates server handles for all the transports -+specified in -+.Ev NETPATH -+environment variable, -+or if it is unset, -+it creates server handles for all the visible transports from -+.Pa /etc/netconfig -+file. -+Note: -+the transports are chosen at run time and not at compile time. -+When the server is self-started, -+it backgrounds itself by default. -+A special define symbol -+.Em RPC_SVC_FG -+can be used to run the server process in foreground. -+.Pp -+The second synopsis provides special features which allow -+for the creation of more sophisticated -+.Tn RPC -+servers. -+These features include support for user provided -+.Em #defines -+and -+.Tn RPC -+dispatch tables. -+The entries in the -+.Tn RPC -+dispatch table contain: -+.Bl -bullet -offset indent -compact -+.It -+pointers to the service routine corresponding to that procedure, -+.It -+a pointer to the input and output arguments, -+.It -+the size of these routines. -+.El -+A server can use the dispatch table to check authorization -+and then to execute the service routine; -+a client library may use it to deal with the details of storage -+management and XDR data conversion. -+.Pp -+The other three synopses shown above are used when -+one does not want to generate all the output files, -+but only a particular one. -+See the -+.Sx EXAMPLES -+section below for examples of -+.Nm -+usage. -+When -+.Nm -+is executed with the -+.Fl s -+option, -+it creates servers for that particular class of transports. -+When -+executed with the -+.Fl n -+option, -+it creates a server for the transport specified by -+.Ar netid . -+If -+.Ar infile -+is not specified, -+.Nm -+accepts the standard input. -+.Pp -+The C preprocessor, -+.Em cc -E -+is run on the input file before it is actually interpreted by -+.Nm . -+For each type of output file, -+.Nm -+defines a special preprocessor symbol for use by the -+.Nm -+programmer: -+.Bl -tag -width indent -+.It RPC_HDR -+defined when compiling into headers -+.It RPC_XDR -+defined when compiling into XDR routines -+.It RPC_SVC -+defined when compiling into server-side stubs -+.It RPC_CLNT -+defined when compiling into client-side stubs -+.It RPC_TBL -+defined when compiling into RPC dispatch tables -+.El -+.Pp -+Any line beginning with -+.Dq % -+is passed directly into the output file, -+uninterpreted by -+.Nm . -+To specify the path name of the C preprocessor use -+.Fl Y -+flag. -+.Pp -+For every data type referred to in -+.Ar infile , -+.Nm -+assumes that there exists a -+routine with the string -+.Em xdr_ -+prepended to the name of the data type. -+If this routine does not exist in the -+.Tn RPC/XDR -+library, it must be provided. -+Providing an undefined data type -+allows customization of -+.Xr xdr 3 -+routines. -+.Sh OPTIONS -+The following options are available: -+.Bl -tag -width indent -+.It Fl a -+Generate all files, including sample files. -+.It Fl b -+Backward compatibility mode. -+Generate transport specific -+.Tn RPC -+code for older versions -+of the operating system. -+.Pp -+Note: in -+.Fx , -+this compatibility flag is turned on by -+default since -+.Fx -+supports only the older -+.Tn ONC RPC -+library. -+.It Fl c -+Compile into -+.Tn XDR -+routines. -+.It Fl C -+Generate header and stub files which can be used with -+.Tn ANSI -+C compilers. Headers generated with this flag can also be -+used with C++ programs. -+.It Fl D Ns Ar name -+.It Fl D Ns Ar name=value -+.\".It Fl D Ns Ar name Ns Op Ar =value -+Define a symbol -+.Ar name . -+Equivalent to the -+.Em #define -+directive in the source. -+If no -+.Ar value -+is given, -+.Ar value -+is defined as -+.Em 1 . -+This option may be specified more than once. -+.It Fl h -+Compile into C data-definitions (a header). -+.Fl T -+option can be used in conjunction to produce a -+header which supports -+.Tn RPC -+dispatch tables. -+.It Fl i Ar size -+Size at which to start generating inline code. -+This option is useful for optimization. -+The default size is 5. -+.Pp -+Note: in order to provide backwards compatibility with the older -+.Nm -+on the -+.Fx -+platform, the default is actually 0 (which means -+that inline code generation is disabled by default). You must specify -+a non-zero value explicitly to override this default. -+.It Fl I -+Compile support for -+.Xr inetd 8 -+in the server side stubs. -+Such servers can be self-started or can be started by -+.Nm inetd . -+When the server is self-started, it backgrounds itself by default. -+A special define symbol -+.Em RPC_SVC_FG -+can be used to run the -+server process in foreground, or the user may simply compile without -+the -+.Fl I -+option. -+.Pp -+If there are no pending client requests, the -+.Nm inetd -+servers exit after 120 seconds (default). -+The default can be changed with the -+.Fl K -+option. -+All the error messages for -+.Nm inetd -+servers -+are always logged with -+.Xr syslog 3 . -+.\" .IP -+.\" Note: -+.\" this option is supported for backward compatibility only. -+.\" By default, -+.\" .B rpcgen -+.\" generates servers that can be invoked through portmonitors. -+.Pp -+.It Fl K Ar seconds -+By default, services created using -+.Nm -+and invoked through -+port monitors wait 120 seconds -+after servicing a request before exiting. -+That interval can be changed using the -+.Fl K -+flag. -+To create a server that exits immediately upon servicing a request, -+use -+.Fl K Ar 0 . -+To create a server that never exits, the appropriate argument is -+.Fl k Ar -1 . -+.Pp -+When monitoring for a server, -+some portmonitors -+.Em always -+spawn a new process in response to a service request. -+If it is known that a server will be used with such a monitor, the -+server should exit immediately on completion. -+For such servers, -+.Nm -+should be used with -+.Fl K Ar 0 . -+.It Fl l -+Compile into client-side stubs. -+.It Fl L -+When the servers are started in foreground, use -+.Xr syslog 3 -+to log the server errors instead of printing them on the standard -+error. -+.It Fl m -+Compile into server-side stubs, -+but do not generate a -+.Qq main -+routine. -+This option is useful for doing callback-routines -+and for users who need to write their own -+.Qq main -+routine to do initialization. -+.It Fl M -+Generate multithread-safe stubs for passing arguments and results between -+rpcgen generated code and user written code. -+This option is useful -+for users who want to use threads in their code. -+However, the -+.Xr rpc_svc_calls 3 -+functions are not yet MT-safe, which means that rpcgen generated server-side -+code will not be MT-safe. -+.It Fl N -+This option allows procedures to have multiple arguments. -+It also uses the style of parameter passing that closely resembles C. -+So, when passing an argument to a remote procedure, you do not have to -+pass a pointer to the argument, but can pass the argument itself. -+This behavior is different from the old style of -+.Nm -+generated code. -+To maintain backward compatibility, -+this option is not the default. -+.It Fl n Ar netid -+Compile into server-side stubs for the transport -+specified by -+.Ar netid . -+There should be an entry for -+.Ar netid -+in the -+netconfig database. -+This option may be specified more than once, -+so as to compile a server that serves multiple transports. -+.It Fl o Ar outfile -+Specify the name of the output file. -+If none is specified, -+standard output is used -+( -+.Fl c , -+.Fl h , -+.Fl l , -+.Fl m , -+.Fl n , -+.Fl s , -+.Fl \&Sc , -+.Fl \&Sm , -+.Fl \&Ss , -+and -+.Fl t -+modes only). -+.It Fl s Ar nettype -+Compile into server-side stubs for all the -+transports belonging to the class -+.Ar nettype . -+The supported classes are -+.Em netpath , -+.Em visible , -+.Em circuit_n , -+.Em circuit_v , -+.Em datagram_n , -+.Em datagram_v , -+.Em tcp , -+and -+.Em udp -+(see -+.Xr rpc 3 -+for the meanings associated with these classes). -+This option may be specified more than once. -+Note: -+the transports are chosen at run time and not at compile time. -+.It Fl \&Sc -+Generate sample client code that uses remote procedure calls. -+.It Fl \&Sm -+Generate a sample -+.Pa Makefile -+which can be used for compiling the application. -+.It Fl \&Ss -+Generate sample server code that uses remote procedure calls. -+.It Fl t -+Compile into -+.Tn RPC -+dispatch table. -+.It Fl T -+Generate the code to support -+.Tn RPC -+dispatch tables. -+.Pp -+The options -+.Fl c , -+.Fl h , -+.Fl l , -+.Fl m , -+.Fl s , -+.Fl \&Sc , -+.Fl \&Sm , -+.Fl \&Ss , -+and -+.Fl t -+are used exclusively to generate a particular type of file, -+while the options -+.Fl D -+and -+.Fl T -+are global and can be used with the other options. -+.It Fl Y Ar pathname -+Give the name of the directory where -+.Nm -+will start looking for the C-preprocessor. -+.El -+.Sh EXAMPLES -+The following example: -+.Dl example% rpcgen -T prot.x -+.Pp -+generates all the five files: -+.Pa prot.h , -+.Pa prot_clnt.c , -+.Pa prot_svc.c , -+.Pa prot_xdr.c -+and -+.Pa prot_tbl.i . -+.Pp -+The following example sends the C data-definitions (header) -+to the standard output. -+.Dl example% rpcgen -h prot.x -+.Pp -+To send the test version of the -+.Fl D Ns Ar TEST , -+server side stubs for -+all the transport belonging to the class -+.Ar datagram_n -+to standard output, use: -+.Dl example% rpcgen -s datagram_n -DTEST prot.x -+.Pp -+To create the server side stubs for the transport indicated -+by -+.Ar netid -+tcp, -+use: -+.Dl example% rpcgen -n tcp -o prot_svc.c prot.x -+.Sh SEE ALSO -+.Xr cc 1 , -+.Xr rpc 3 , -+.Xr syslog 3 , -+.Xr inetd 8 -+.\" .BR rpc_svc_calls (3) -+.Rs -+.%T The rpcgen chapter in the NETP manual -+.Re --- -2.0.0 - diff --git a/package/libtirpc/libtirpc-0009-Automatically-generate-XDR-header-files-from-.x-sour.patch b/package/libtirpc/libtirpc-0009-Automatically-generate-XDR-header-files-from-.x-sour.patch deleted file mode 100644 index 3c1c82d0c7..0000000000 --- a/package/libtirpc/libtirpc-0009-Automatically-generate-XDR-header-files-from-.x-sour.patch +++ /dev/null @@ -1,1004 +0,0 @@ -From 99ecb155efdfcf474c5701ab7e6ad1cbe88f500f Mon Sep 17 00:00:00 2001 -From: Thomas Petazzoni -Date: Sat, 10 Nov 2012 17:29:53 +0100 -Subject: [PATCH] Automatically generate XDR header files from .x sources using - rpcgen - -Signed-off-by: Thomas Petazzoni ---- - Makefile.am | 22 +- - src/Makefile.am | 2 +- - tirpc/rpc/rpcb_prot.h | 797 -------------------------------------------------- - tirpc/rpcsvc/crypt.h | 109 ------- - 4 files changed, 20 insertions(+), 910 deletions(-) - delete mode 100644 tirpc/rpc/rpcb_prot.h - delete mode 100644 tirpc/rpcsvc/crypt.h - -diff --git a/Makefile.am b/Makefile.am -index 6edf029..4e4dc32 100644 ---- a/Makefile.am -+++ b/Makefile.am -@@ -1,6 +1,10 @@ - SUBDIRS = src man doc rpcgen - ACLOCAL_AMFLAGS = -I m4 - -+GENFILES = \ -+ tirpc/rpcsvc/crypt.h \ -+ tirpc/rpc/rpcb_prot.h -+ - noinst_HEADERS = tirpc/reentrant.h \ - tirpc/getpeereid.h \ - tirpc/libc_private.h \ -@@ -8,7 +12,6 @@ noinst_HEADERS = tirpc/reentrant.h \ - - nobase_include_HEADERS = tirpc/netconfig.h \ - tirpc/rpcsvc/crypt.x \ -- tirpc/rpcsvc/crypt.h \ - tirpc/rpc/xdr.h \ - tirpc/rpc/types.h \ - tirpc/rpc/svc_soc.h \ -@@ -20,7 +23,6 @@ nobase_include_HEADERS = tirpc/netconfig.h \ - tirpc/rpc/rpcent.h \ - tirpc/rpc/rpc_com.h \ - tirpc/rpc/rpcb_prot.x \ -- tirpc/rpc/rpcb_prot.h \ - tirpc/rpc/rpcb_clnt.h \ - tirpc/rpc/raw.h \ - tirpc/rpc/pmap_rmt.h \ -@@ -37,7 +39,21 @@ nobase_include_HEADERS = tirpc/netconfig.h \ - tirpc/rpc/auth.h \ - tirpc/rpc/auth_gss.h \ - tirpc/rpc/auth_des.h -- -+ -+nobase_nodist_include_HEADERS = $(GENFILES) -+BUILT_SOURCES = $(GENFILES) -+ -+$(GENFILES): %.h: %.x $(top_builddir)/rpcgen/rpcgen -+ mkdir -p $(dir $@) -+ $(top_builddir)/rpcgen/rpcgen -h -o $@ $< -+ -+$(top_builddir)/rpcgen/rpcgen: force -+ cd rpcgen && $(MAKE) -+ -+force: -+ -+CLEANFILES = $(GENFILES) -+ - pkgconfigdir=$(libdir)/pkgconfig - pkgconfig_DATA = libtirpc.pc - -diff --git a/src/Makefile.am b/src/Makefile.am -index f086255..a9db71b 100644 ---- a/src/Makefile.am -+++ b/src/Makefile.am -@@ -8,7 +8,7 @@ - noinst_HEADERS = rpc_com.h - - AM_CPPFLAGS = -I$(top_srcdir)/tirpc -DPORTMAP \ -- -D_GNU_SOURCE -Wall -pipe -+ -D_GNU_SOURCE -Wall -pipe -I$(top_builddir)/tirpc - - lib_LTLIBRARIES = libtirpc.la - -diff --git a/tirpc/rpc/rpcb_prot.h b/tirpc/rpc/rpcb_prot.h -deleted file mode 100644 -index 7ae48b8..0000000 ---- a/tirpc/rpc/rpcb_prot.h -+++ /dev/null -@@ -1,797 +0,0 @@ --/* -- * Please do not edit this file. -- * It was generated using rpcgen. -- */ -- --#ifndef _RPCB_PROT_H_RPCGEN --#define _RPCB_PROT_H_RPCGEN -- --#include -- --#ifndef IXDR_GET_INT32 --#define IXDR_GET_INT32(buf) IXDR_GET_LONG((buf)) --#endif --#ifndef IXDR_PUT_INT32 --#define IXDR_PUT_INT32(buf, v) IXDR_PUT_LONG((buf), (v)) --#endif --#ifndef IXDR_GET_U_INT32 --#define IXDR_GET_U_INT32(buf) IXDR_GET_U_LONG((buf)) --#endif --#ifndef IXDR_PUT_U_INT32 --#define IXDR_PUT_U_INT32(buf, v) IXDR_PUT_U_LONG((buf), (v)) --#endif --/* -- * $FreeBSD: src/include/rpc/rpcb_prot.x,v 1.3 2002/03/13 10:29:06 obrien Exp $ -- * -- * Copyright (c) 2009, Sun Microsystems, Inc. -- * All rights reserved. -- * -- * Redistribution and use in source and binary forms, with or without -- * modification, are permitted provided that the following conditions are met: -- * - Redistributions of source code must retain the above copyright notice, -- * this list of conditions and the following disclaimer. -- * - Redistributions in binary form must reproduce the above copyright notice, -- * this list of conditions and the following disclaimer in the documentation -- * and/or other materials provided with the distribution. -- * - Neither the name of Sun Microsystems, Inc. nor the names of its -- * contributors may be used to endorse or promote products derived -- * from this software without specific prior written permission. -- * -- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE -- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -- * POSSIBILITY OF SUCH DAMAGE. -- */ --/* -- * Copyright (c) 1988 by Sun Microsystems, Inc. -- */ --/* from rpcb_prot.x */ -- --/* #pragma ident "@(#)rpcb_prot.x 1.5 94/04/29 SMI" */ -- --#ifndef _KERNEL -- -- --/* -- * The following procedures are supported by the protocol in version 3: -- * -- * RPCBPROC_NULL() returns () -- * takes nothing, returns nothing -- * -- * RPCBPROC_SET(rpcb) returns (bool_t) -- * TRUE is success, FALSE is failure. Registers the tuple -- * [prog, vers, address, owner, netid]. -- * Finds out owner and netid information on its own. -- * -- * RPCBPROC_UNSET(rpcb) returns (bool_t) -- * TRUE is success, FALSE is failure. Un-registers tuple -- * [prog, vers, netid]. addresses is ignored. -- * If netid is NULL, unregister all. -- * -- * RPCBPROC_GETADDR(rpcb) returns (string). -- * 0 is failure. Otherwise returns the universal address where the -- * triple [prog, vers, netid] is registered. Ignore address and owner. -- * -- * RPCBPROC_DUMP() RETURNS (rpcblist_ptr) -- * used to dump the entire rpcbind maps -- * -- * RPCBPROC_CALLIT(rpcb_rmtcallargs) -- * RETURNS (rpcb_rmtcallres); -- * Calls the procedure on the remote machine. If it is not registered, -- * this procedure is quiet; i.e. it does not return error information!!! -- * This routine only passes null authentication parameters. -- * It has no interface to xdr routines for RPCBPROC_CALLIT. -- * -- * RPCBPROC_GETTIME() returns (int). -- * Gets the remote machines time -- * -- * RPCBPROC_UADDR2TADDR(strint) RETURNS (struct netbuf) -- * Returns the netbuf address from universal address. -- * -- * RPCBPROC_TADDR2UADDR(struct netbuf) RETURNS (string) -- * Returns the universal address from netbuf address. -- * -- * END OF RPCBIND VERSION 3 PROCEDURES -- */ --/* -- * Except for RPCBPROC_CALLIT, the procedures above are carried over to -- * rpcbind version 4. Those below are added or modified for version 4. -- * NOTE: RPCBPROC_BCAST HAS THE SAME FUNCTIONALITY AND PROCEDURE NUMBER -- * AS RPCBPROC_CALLIT. -- * -- * RPCBPROC_BCAST(rpcb_rmtcallargs) -- * RETURNS (rpcb_rmtcallres); -- * Calls the procedure on the remote machine. If it is not registered, -- * this procedure IS quiet; i.e. it DOES NOT return error information!!! -- * This routine should be used for broadcasting and nothing else. -- * -- * RPCBPROC_GETVERSADDR(rpcb) returns (string). -- * 0 is failure. Otherwise returns the universal address where the -- * triple [prog, vers, netid] is registered. Ignore address and owner. -- * Same as RPCBPROC_GETADDR except that if the given version number -- * is not available, the address is not returned. -- * -- * RPCBPROC_INDIRECT(rpcb_rmtcallargs) -- * RETURNS (rpcb_rmtcallres); -- * Calls the procedure on the remote machine. If it is not registered, -- * this procedure is NOT quiet; i.e. it DOES return error information!!! -- * as any normal application would expect. -- * -- * RPCBPROC_GETADDRLIST(rpcb) returns (rpcb_entry_list_ptr). -- * Same as RPCBPROC_GETADDR except that it returns a list of all the -- * addresses registered for the combination (prog, vers) (for all -- * transports). -- * -- * RPCBPROC_GETSTAT(void) returns (rpcb_stat_byvers) -- * Returns the statistics about the kind of requests received by rpcbind. -- */ -- --/* -- * A mapping of (program, version, network ID) to address -- */ -- --struct rpcb { -- rpcprog_t r_prog; -- rpcvers_t r_vers; -- char *r_netid; -- char *r_addr; -- char *r_owner; --}; --typedef struct rpcb rpcb; --#ifdef __cplusplus --extern "C" bool_t xdr_rpcb(XDR *, rpcb*); --#elif __STDC__ --extern bool_t xdr_rpcb(XDR *, rpcb*); --#else /* Old Style C */ --bool_t xdr_rpcb(); --#endif /* Old Style C */ -- -- --typedef rpcb RPCB; -- -- --/* -- * A list of mappings -- * -- * Below are two definitions for the rpcblist structure. This is done because -- * xdr_rpcblist() is specified to take a struct rpcblist **, rather than a -- * struct rpcblist * that rpcgen would produce. One version of the rpcblist -- * structure (actually called rp__list) is used with rpcgen, and the other is -- * defined only in the header file for compatibility with the specified -- * interface. -- */ -- --struct rp__list { -- rpcb rpcb_map; -- struct rp__list *rpcb_next; --}; --typedef struct rp__list rp__list; --#ifdef __cplusplus --extern "C" bool_t xdr_rp__list(XDR *, rp__list*); --#elif __STDC__ --extern bool_t xdr_rp__list(XDR *, rp__list*); --#else /* Old Style C */ --bool_t xdr_rp__list(); --#endif /* Old Style C */ -- -- --typedef rp__list *rpcblist_ptr; --#ifdef __cplusplus --extern "C" bool_t xdr_rpcblist_ptr(XDR *, rpcblist_ptr*); --#elif __STDC__ --extern bool_t xdr_rpcblist_ptr(XDR *, rpcblist_ptr*); --#else /* Old Style C */ --bool_t xdr_rpcblist_ptr(); --#endif /* Old Style C */ -- -- --typedef struct rp__list rpcblist; --typedef struct rp__list RPCBLIST; -- --#ifndef __cplusplus --struct rpcblist { -- RPCB rpcb_map; -- struct rpcblist *rpcb_next; --}; --#endif -- --#ifdef __cplusplus --extern "C" { --#endif --extern bool_t xdr_rpcblist(XDR *, rpcblist**); --#ifdef __cplusplus --} --#endif -- -- --/* -- * Arguments of remote calls -- */ -- --struct rpcb_rmtcallargs { -- rpcprog_t prog; -- rpcvers_t vers; -- rpcproc_t proc; -- struct { -- u_int args_len; -- char *args_val; -- } args; --}; --typedef struct rpcb_rmtcallargs rpcb_rmtcallargs; --#ifdef __cplusplus --extern "C" bool_t xdr_rpcb_rmtcallargs(XDR *, rpcb_rmtcallargs*); --#elif __STDC__ --extern bool_t xdr_rpcb_rmtcallargs(XDR *, rpcb_rmtcallargs*); --#else /* Old Style C */ --bool_t xdr_rpcb_rmtcallargs(); --#endif /* Old Style C */ -- -- --/* -- * Client-side only representation of rpcb_rmtcallargs structure. -- * -- * The routine that XDRs the rpcb_rmtcallargs structure must deal with the -- * opaque arguments in the "args" structure. xdr_rpcb_rmtcallargs() needs to -- * be passed the XDR routine that knows the args' structure. This routine -- * doesn't need to go over-the-wire (and it wouldn't make sense anyway) since -- * the application being called already knows the args structure. So we use a -- * different "XDR" structure on the client side, r_rpcb_rmtcallargs, which -- * includes the args' XDR routine. -- */ --struct r_rpcb_rmtcallargs { -- rpcprog_t prog; -- rpcvers_t vers; -- rpcproc_t proc; -- struct { -- u_int args_len; -- char *args_val; -- } args; -- xdrproc_t xdr_args; /* encodes args */ --}; -- -- --/* -- * Results of the remote call -- */ -- --struct rpcb_rmtcallres { -- char *addr; -- struct { -- u_int results_len; -- char *results_val; -- } results; --}; --typedef struct rpcb_rmtcallres rpcb_rmtcallres; --#ifdef __cplusplus --extern "C" bool_t xdr_rpcb_rmtcallres(XDR *, rpcb_rmtcallres*); --#elif __STDC__ --extern bool_t xdr_rpcb_rmtcallres(XDR *, rpcb_rmtcallres*); --#else /* Old Style C */ --bool_t xdr_rpcb_rmtcallres(); --#endif /* Old Style C */ -- -- --/* -- * Client-side only representation of rpcb_rmtcallres structure. -- */ --struct r_rpcb_rmtcallres { -- char *addr; -- struct { -- u_int32_t results_len; -- char *results_val; -- } results; -- xdrproc_t xdr_res; /* decodes results */ --}; -- --/* -- * rpcb_entry contains a merged address of a service on a particular -- * transport, plus associated netconfig information. A list of rpcb_entrys -- * is returned by RPCBPROC_GETADDRLIST. See netconfig.h for values used -- * in r_nc_* fields. -- */ -- --struct rpcb_entry { -- char *r_maddr; -- char *r_nc_netid; -- u_int r_nc_semantics; -- char *r_nc_protofmly; -- char *r_nc_proto; --}; --typedef struct rpcb_entry rpcb_entry; --#ifdef __cplusplus --extern "C" bool_t xdr_rpcb_entry(XDR *, rpcb_entry*); --#elif __STDC__ --extern bool_t xdr_rpcb_entry(XDR *, rpcb_entry*); --#else /* Old Style C */ --bool_t xdr_rpcb_entry(); --#endif /* Old Style C */ -- -- --/* -- * A list of addresses supported by a service. -- */ -- --struct rpcb_entry_list { -- rpcb_entry rpcb_entry_map; -- struct rpcb_entry_list *rpcb_entry_next; --}; --typedef struct rpcb_entry_list rpcb_entry_list; --#ifdef __cplusplus --extern "C" bool_t xdr_rpcb_entry_list(XDR *, rpcb_entry_list*); --#elif __STDC__ --extern bool_t xdr_rpcb_entry_list(XDR *, rpcb_entry_list*); --#else /* Old Style C */ --bool_t xdr_rpcb_entry_list(); --#endif /* Old Style C */ -- -- --typedef rpcb_entry_list *rpcb_entry_list_ptr; --#ifdef __cplusplus --extern "C" bool_t xdr_rpcb_entry_list_ptr(XDR *, rpcb_entry_list_ptr*); --#elif __STDC__ --extern bool_t xdr_rpcb_entry_list_ptr(XDR *, rpcb_entry_list_ptr*); --#else /* Old Style C */ --bool_t xdr_rpcb_entry_list_ptr(); --#endif /* Old Style C */ -- -- --/* -- * rpcbind statistics -- */ -- --#define rpcb_highproc_2 RPCBPROC_CALLIT --#define rpcb_highproc_3 RPCBPROC_TADDR2UADDR --#define rpcb_highproc_4 RPCBPROC_GETSTAT --#define RPCBSTAT_HIGHPROC 13 --#define RPCBVERS_STAT 3 --#define RPCBVERS_4_STAT 2 --#define RPCBVERS_3_STAT 1 --#define RPCBVERS_2_STAT 0 -- --/* Link list of all the stats about getport and getaddr */ -- --struct rpcbs_addrlist { -- rpcprog_t prog; -- rpcvers_t vers; -- int success; -- int failure; -- char *netid; -- struct rpcbs_addrlist *next; --}; --typedef struct rpcbs_addrlist rpcbs_addrlist; --#ifdef __cplusplus --extern "C" bool_t xdr_rpcbs_addrlist(XDR *, rpcbs_addrlist*); --#elif __STDC__ --extern bool_t xdr_rpcbs_addrlist(XDR *, rpcbs_addrlist*); --#else /* Old Style C */ --bool_t xdr_rpcbs_addrlist(); --#endif /* Old Style C */ -- -- --/* Link list of all the stats about rmtcall */ -- --struct rpcbs_rmtcalllist { -- rpcprog_t prog; -- rpcvers_t vers; -- rpcproc_t proc; -- int success; -- int failure; -- int indirect; -- char *netid; -- struct rpcbs_rmtcalllist *next; --}; --typedef struct rpcbs_rmtcalllist rpcbs_rmtcalllist; --#ifdef __cplusplus --extern "C" bool_t xdr_rpcbs_rmtcalllist(XDR *, rpcbs_rmtcalllist*); --#elif __STDC__ --extern bool_t xdr_rpcbs_rmtcalllist(XDR *, rpcbs_rmtcalllist*); --#else /* Old Style C */ --bool_t xdr_rpcbs_rmtcalllist(); --#endif /* Old Style C */ -- -- --typedef int rpcbs_proc[RPCBSTAT_HIGHPROC]; --#ifdef __cplusplus --extern "C" bool_t xdr_rpcbs_proc(XDR *, rpcbs_proc); --#elif __STDC__ --extern bool_t xdr_rpcbs_proc(XDR *, rpcbs_proc); --#else /* Old Style C */ --bool_t xdr_rpcbs_proc(); --#endif /* Old Style C */ -- -- --typedef rpcbs_addrlist *rpcbs_addrlist_ptr; --#ifdef __cplusplus --extern "C" bool_t xdr_rpcbs_addrlist_ptr(XDR *, rpcbs_addrlist_ptr*); --#elif __STDC__ --extern bool_t xdr_rpcbs_addrlist_ptr(XDR *, rpcbs_addrlist_ptr*); --#else /* Old Style C */ --bool_t xdr_rpcbs_addrlist_ptr(); --#endif /* Old Style C */ -- -- --typedef rpcbs_rmtcalllist *rpcbs_rmtcalllist_ptr; --#ifdef __cplusplus --extern "C" bool_t xdr_rpcbs_rmtcalllist_ptr(XDR *, rpcbs_rmtcalllist_ptr*); --#elif __STDC__ --extern bool_t xdr_rpcbs_rmtcalllist_ptr(XDR *, rpcbs_rmtcalllist_ptr*); --#else /* Old Style C */ --bool_t xdr_rpcbs_rmtcalllist_ptr(); --#endif /* Old Style C */ -- -- --struct rpcb_stat { -- rpcbs_proc info; -- int setinfo; -- int unsetinfo; -- rpcbs_addrlist_ptr addrinfo; -- rpcbs_rmtcalllist_ptr rmtinfo; --}; --typedef struct rpcb_stat rpcb_stat; --#ifdef __cplusplus --extern "C" bool_t xdr_rpcb_stat(XDR *, rpcb_stat*); --#elif __STDC__ --extern bool_t xdr_rpcb_stat(XDR *, rpcb_stat*); --#else /* Old Style C */ --bool_t xdr_rpcb_stat(); --#endif /* Old Style C */ -- -- --/* -- * One rpcb_stat structure is returned for each version of rpcbind -- * being monitored. -- */ -- --typedef rpcb_stat rpcb_stat_byvers[RPCBVERS_STAT]; --#ifdef __cplusplus --extern "C" bool_t xdr_rpcb_stat_byvers(XDR *, rpcb_stat_byvers); --#elif __STDC__ --extern bool_t xdr_rpcb_stat_byvers(XDR *, rpcb_stat_byvers); --#else /* Old Style C */ --bool_t xdr_rpcb_stat_byvers(); --#endif /* Old Style C */ -- -- --/* -- * We don't define netbuf in RPCL, since it would contain structure member -- * names that would conflict with the definition of struct netbuf in -- * . Instead we merely declare the XDR routine xdr_netbuf() here, -- * and implement it ourselves in rpc/rpcb_prot.c. -- */ --#ifdef __cplusplus --extern "C" bool_t xdr_netbuf(XDR *, struct netbuf *); -- --#else /* __STDC__ */ --extern bool_t xdr_netbuf(XDR *, struct netbuf *); -- --#endif -- --#define RPCBVERS_3 RPCBVERS --#define RPCBVERS_4 RPCBVERS4 -- --#define _PATH_RPCBINDSOCK "/var/run/rpcbind.sock" -- --#else /* ndef _KERNEL */ --#ifdef __cplusplus --extern "C" { --#endif -- --/* -- * A mapping of (program, version, network ID) to address -- */ --struct rpcb { -- rpcprog_t r_prog; /* program number */ -- rpcvers_t r_vers; /* version number */ -- char *r_netid; /* network id */ -- char *r_addr; /* universal address */ -- char *r_owner; /* owner of the mapping */ --}; --typedef struct rpcb RPCB; -- --/* -- * A list of mappings -- */ --struct rpcblist { -- RPCB rpcb_map; -- struct rpcblist *rpcb_next; --}; --typedef struct rpcblist RPCBLIST; --typedef struct rpcblist *rpcblist_ptr; -- --/* -- * Remote calls arguments -- */ --struct rpcb_rmtcallargs { -- rpcprog_t prog; /* program number */ -- rpcvers_t vers; /* version number */ -- rpcproc_t proc; /* procedure number */ -- u_int32_t arglen; /* arg len */ -- caddr_t args_ptr; /* argument */ -- xdrproc_t xdr_args; /* XDR routine for argument */ --}; --typedef struct rpcb_rmtcallargs rpcb_rmtcallargs; -- --/* -- * Remote calls results -- */ --struct rpcb_rmtcallres { -- char *addr_ptr; /* remote universal address */ -- u_int32_t resultslen; /* results length */ -- caddr_t results_ptr; /* results */ -- xdrproc_t xdr_results; /* XDR routine for result */ --}; --typedef struct rpcb_rmtcallres rpcb_rmtcallres; -- --struct rpcb_entry { -- char *r_maddr; -- char *r_nc_netid; -- unsigned int r_nc_semantics; -- char *r_nc_protofmly; -- char *r_nc_proto; --}; --typedef struct rpcb_entry rpcb_entry; -- --/* -- * A list of addresses supported by a service. -- */ -- --struct rpcb_entry_list { -- rpcb_entry rpcb_entry_map; -- struct rpcb_entry_list *rpcb_entry_next; --}; --typedef struct rpcb_entry_list rpcb_entry_list; -- --typedef rpcb_entry_list *rpcb_entry_list_ptr; -- --/* -- * rpcbind statistics -- */ -- --#define rpcb_highproc_2 RPCBPROC_CALLIT --#define rpcb_highproc_3 RPCBPROC_TADDR2UADDR --#define rpcb_highproc_4 RPCBPROC_GETSTAT --#define RPCBSTAT_HIGHPROC 13 --#define RPCBVERS_STAT 3 --#define RPCBVERS_4_STAT 2 --#define RPCBVERS_3_STAT 1 --#define RPCBVERS_2_STAT 0 -- --/* Link list of all the stats about getport and getaddr */ -- --struct rpcbs_addrlist { -- rpcprog_t prog; -- rpcvers_t vers; -- int success; -- int failure; -- char *netid; -- struct rpcbs_addrlist *next; --}; --typedef struct rpcbs_addrlist rpcbs_addrlist; -- --/* Link list of all the stats about rmtcall */ -- --struct rpcbs_rmtcalllist { -- rpcprog_t prog; -- rpcvers_t vers; -- rpcproc_t proc; -- int success; -- int failure; -- int indirect; -- char *netid; -- struct rpcbs_rmtcalllist *next; --}; --typedef struct rpcbs_rmtcalllist rpcbs_rmtcalllist; -- --typedef int rpcbs_proc[RPCBSTAT_HIGHPROC]; -- --typedef rpcbs_addrlist *rpcbs_addrlist_ptr; -- --typedef rpcbs_rmtcalllist *rpcbs_rmtcalllist_ptr; -- --struct rpcb_stat { -- rpcbs_proc info; -- int setinfo; -- int unsetinfo; -- rpcbs_addrlist_ptr addrinfo; -- rpcbs_rmtcalllist_ptr rmtinfo; --}; --typedef struct rpcb_stat rpcb_stat; -- --/* -- * One rpcb_stat structure is returned for each version of rpcbind -- * being monitored. -- */ -- --typedef rpcb_stat rpcb_stat_byvers[RPCBVERS_STAT]; -- --#ifdef __cplusplus --} --#endif -- --#endif /* ndef _KERNEL */ -- --#define RPCBPROG ((u_int32_t)100000) --#define RPCBVERS ((u_int32_t)3) -- --#ifdef __cplusplus --#define RPCBPROC_SET ((u_int32_t)1) --extern "C" bool_t * rpcbproc_set_3(rpcb *, CLIENT *); --extern "C" bool_t * rpcbproc_set_3_svc(rpcb *, struct svc_req *); --#define RPCBPROC_UNSET ((u_int32_t)2) --extern "C" bool_t * rpcbproc_unset_3(rpcb *, CLIENT *); --extern "C" bool_t * rpcbproc_unset_3_svc(rpcb *, struct svc_req *); --#define RPCBPROC_GETADDR ((u_int32_t)3) --extern "C" char ** rpcbproc_getaddr_3(rpcb *, CLIENT *); --extern "C" char ** rpcbproc_getaddr_3_svc(rpcb *, struct svc_req *); --#define RPCBPROC_DUMP ((u_int32_t)4) --extern "C" rpcblist_ptr * rpcbproc_dump_3(void *, CLIENT *); --extern "C" rpcblist_ptr * rpcbproc_dump_3_svc(void *, struct svc_req *); --#define RPCBPROC_CALLIT ((u_int32_t)5) --extern "C" rpcb_rmtcallres * rpcbproc_callit_3(rpcb_rmtcallargs *, CLIENT *); --extern "C" rpcb_rmtcallres * rpcbproc_callit_3_svc(rpcb_rmtcallargs *, struct svc_req *); --#define RPCBPROC_GETTIME ((u_int32_t)6) --extern "C" u_int * rpcbproc_gettime_3(void *, CLIENT *); --extern "C" u_int * rpcbproc_gettime_3_svc(void *, struct svc_req *); --#define RPCBPROC_UADDR2TADDR ((u_int32_t)7) --extern "C" struct netbuf * rpcbproc_uaddr2taddr_3(char **, CLIENT *); --extern "C" struct netbuf * rpcbproc_uaddr2taddr_3_svc(char **, struct svc_req *); --#define RPCBPROC_TADDR2UADDR ((u_int32_t)8) --extern "C" char ** rpcbproc_taddr2uaddr_3(struct netbuf *, CLIENT *); --extern "C" char ** rpcbproc_taddr2uaddr_3_svc(struct netbuf *, struct svc_req *); -- --#elif __STDC__ --#define RPCBPROC_SET ((u_int32_t)1) --extern bool_t * rpcbproc_set_3(rpcb *, CLIENT *); --extern bool_t * rpcbproc_set_3_svc(rpcb *, struct svc_req *); --#define RPCBPROC_UNSET ((u_int32_t)2) --extern bool_t * rpcbproc_unset_3(rpcb *, CLIENT *); --extern bool_t * rpcbproc_unset_3_svc(rpcb *, struct svc_req *); --#define RPCBPROC_GETADDR ((u_int32_t)3) --extern char ** rpcbproc_getaddr_3(rpcb *, CLIENT *); --extern char ** rpcbproc_getaddr_3_svc(rpcb *, struct svc_req *); --#define RPCBPROC_DUMP ((u_int32_t)4) --extern rpcblist_ptr * rpcbproc_dump_3(void *, CLIENT *); --extern rpcblist_ptr * rpcbproc_dump_3_svc(void *, struct svc_req *); --#define RPCBPROC_CALLIT ((u_int32_t)5) --extern rpcb_rmtcallres * rpcbproc_callit_3(rpcb_rmtcallargs *, CLIENT *); --extern rpcb_rmtcallres * rpcbproc_callit_3_svc(rpcb_rmtcallargs *, struct svc_req *); --#define RPCBPROC_GETTIME ((u_int32_t)6) --extern u_int * rpcbproc_gettime_3(void *, CLIENT *); --extern u_int * rpcbproc_gettime_3_svc(void *, struct svc_req *); --#define RPCBPROC_UADDR2TADDR ((u_int32_t)7) --extern struct netbuf * rpcbproc_uaddr2taddr_3(char **, CLIENT *); --extern struct netbuf * rpcbproc_uaddr2taddr_3_svc(char **, struct svc_req *); --#define RPCBPROC_TADDR2UADDR ((u_int32_t)8) --extern char ** rpcbproc_taddr2uaddr_3(struct netbuf *, CLIENT *); --extern char ** rpcbproc_taddr2uaddr_3_svc(struct netbuf *, struct svc_req *); -- --#else /* Old Style C */ --#define RPCBPROC_SET ((u_int32_t)1) --extern bool_t * rpcbproc_set_3(); --extern bool_t * rpcbproc_set_3_svc(); --#define RPCBPROC_UNSET ((u_int32_t)2) --extern bool_t * rpcbproc_unset_3(); --extern bool_t * rpcbproc_unset_3_svc(); --#define RPCBPROC_GETADDR ((u_int32_t)3) --extern char ** rpcbproc_getaddr_3(); --extern char ** rpcbproc_getaddr_3_svc(); --#define RPCBPROC_DUMP ((u_int32_t)4) --extern rpcblist_ptr * rpcbproc_dump_3(); --extern rpcblist_ptr * rpcbproc_dump_3_svc(); --#define RPCBPROC_CALLIT ((u_int32_t)5) --extern rpcb_rmtcallres * rpcbproc_callit_3(); --extern rpcb_rmtcallres * rpcbproc_callit_3_svc(); --#define RPCBPROC_GETTIME ((u_int32_t)6) --extern u_int * rpcbproc_gettime_3(); --extern u_int * rpcbproc_gettime_3_svc(); --#define RPCBPROC_UADDR2TADDR ((u_int32_t)7) --extern struct netbuf * rpcbproc_uaddr2taddr_3(); --extern struct netbuf * rpcbproc_uaddr2taddr_3_svc(); --#define RPCBPROC_TADDR2UADDR ((u_int32_t)8) --extern char ** rpcbproc_taddr2uaddr_3(); --extern char ** rpcbproc_taddr2uaddr_3_svc(); --#endif /* Old Style C */ --#define RPCBVERS4 ((u_int32_t)4) -- --#ifdef __cplusplus --extern "C" bool_t * rpcbproc_set_4(rpcb *, CLIENT *); --extern "C" bool_t * rpcbproc_set_4_svc(rpcb *, struct svc_req *); --extern "C" bool_t * rpcbproc_unset_4(rpcb *, CLIENT *); --extern "C" bool_t * rpcbproc_unset_4_svc(rpcb *, struct svc_req *); --extern "C" char ** rpcbproc_getaddr_4(rpcb *, CLIENT *); --extern "C" char ** rpcbproc_getaddr_4_svc(rpcb *, struct svc_req *); --extern "C" rpcblist_ptr * rpcbproc_dump_4(void *, CLIENT *); --extern "C" rpcblist_ptr * rpcbproc_dump_4_svc(void *, struct svc_req *); --#define RPCBPROC_BCAST ((u_int32_t)RPCBPROC_CALLIT) --extern "C" rpcb_rmtcallres * rpcbproc_bcast_4(rpcb_rmtcallargs *, CLIENT *); --extern "C" rpcb_rmtcallres * rpcbproc_bcast_4_svc(rpcb_rmtcallargs *, struct svc_req *); --extern "C" u_int * rpcbproc_gettime_4(void *, CLIENT *); --extern "C" u_int * rpcbproc_gettime_4_svc(void *, struct svc_req *); --extern "C" struct netbuf * rpcbproc_uaddr2taddr_4(char **, CLIENT *); --extern "C" struct netbuf * rpcbproc_uaddr2taddr_4_svc(char **, struct svc_req *); --extern "C" char ** rpcbproc_taddr2uaddr_4(struct netbuf *, CLIENT *); --extern "C" char ** rpcbproc_taddr2uaddr_4_svc(struct netbuf *, struct svc_req *); --#define RPCBPROC_GETVERSADDR ((u_int32_t)9) --extern "C" char ** rpcbproc_getversaddr_4(rpcb *, CLIENT *); --extern "C" char ** rpcbproc_getversaddr_4_svc(rpcb *, struct svc_req *); --#define RPCBPROC_INDIRECT ((u_int32_t)10) --extern "C" rpcb_rmtcallres * rpcbproc_indirect_4(rpcb_rmtcallargs *, CLIENT *); --extern "C" rpcb_rmtcallres * rpcbproc_indirect_4_svc(rpcb_rmtcallargs *, struct svc_req *); --#define RPCBPROC_GETADDRLIST ((u_int32_t)11) --extern "C" rpcb_entry_list_ptr * rpcbproc_getaddrlist_4(rpcb *, CLIENT *); --extern "C" rpcb_entry_list_ptr * rpcbproc_getaddrlist_4_svc(rpcb *, struct svc_req *); --#define RPCBPROC_GETSTAT ((u_int32_t)12) --extern "C" rpcb_stat * rpcbproc_getstat_4(void *, CLIENT *); --extern "C" rpcb_stat * rpcbproc_getstat_4_svc(void *, struct svc_req *); -- --#elif __STDC__ --extern bool_t * rpcbproc_set_4(rpcb *, CLIENT *); --extern bool_t * rpcbproc_set_4_svc(rpcb *, struct svc_req *); --extern bool_t * rpcbproc_unset_4(rpcb *, CLIENT *); --extern bool_t * rpcbproc_unset_4_svc(rpcb *, struct svc_req *); --extern char ** rpcbproc_getaddr_4(rpcb *, CLIENT *); --extern char ** rpcbproc_getaddr_4_svc(rpcb *, struct svc_req *); --extern rpcblist_ptr * rpcbproc_dump_4(void *, CLIENT *); --extern rpcblist_ptr * rpcbproc_dump_4_svc(void *, struct svc_req *); --#define RPCBPROC_BCAST ((u_int32_t)RPCBPROC_CALLIT) --extern rpcb_rmtcallres * rpcbproc_bcast_4(rpcb_rmtcallargs *, CLIENT *); --extern rpcb_rmtcallres * rpcbproc_bcast_4_svc(rpcb_rmtcallargs *, struct svc_req *); --extern u_int * rpcbproc_gettime_4(void *, CLIENT *); --extern u_int * rpcbproc_gettime_4_svc(void *, struct svc_req *); --extern struct netbuf * rpcbproc_uaddr2taddr_4(char **, CLIENT *); --extern struct netbuf * rpcbproc_uaddr2taddr_4_svc(char **, struct svc_req *); --extern char ** rpcbproc_taddr2uaddr_4(struct netbuf *, CLIENT *); --extern char ** rpcbproc_taddr2uaddr_4_svc(struct netbuf *, struct svc_req *); --#define RPCBPROC_GETVERSADDR ((u_int32_t)9) --extern char ** rpcbproc_getversaddr_4(rpcb *, CLIENT *); --extern char ** rpcbproc_getversaddr_4_svc(rpcb *, struct svc_req *); --#define RPCBPROC_INDIRECT ((u_int32_t)10) --extern rpcb_rmtcallres * rpcbproc_indirect_4(rpcb_rmtcallargs *, CLIENT *); --extern rpcb_rmtcallres * rpcbproc_indirect_4_svc(rpcb_rmtcallargs *, struct svc_req *); --#define RPCBPROC_GETADDRLIST ((u_int32_t)11) --extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4(rpcb *, CLIENT *); --extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4_svc(rpcb *, struct svc_req *); --#define RPCBPROC_GETSTAT ((u_int32_t)12) --extern rpcb_stat * rpcbproc_getstat_4(void *, CLIENT *); --extern rpcb_stat * rpcbproc_getstat_4_svc(void *, struct svc_req *); -- --#else /* Old Style C */ --extern bool_t * rpcbproc_set_4(); --extern bool_t * rpcbproc_set_4_svc(); --extern bool_t * rpcbproc_unset_4(); --extern bool_t * rpcbproc_unset_4_svc(); --extern char ** rpcbproc_getaddr_4(); --extern char ** rpcbproc_getaddr_4_svc(); --extern rpcblist_ptr * rpcbproc_dump_4(); --extern rpcblist_ptr * rpcbproc_dump_4_svc(); --#define RPCBPROC_BCAST ((u_int32_t)RPCBPROC_CALLIT) --extern rpcb_rmtcallres * rpcbproc_bcast_4(); --extern rpcb_rmtcallres * rpcbproc_bcast_4_svc(); --extern u_int * rpcbproc_gettime_4(); --extern u_int * rpcbproc_gettime_4_svc(); --extern struct netbuf * rpcbproc_uaddr2taddr_4(); --extern struct netbuf * rpcbproc_uaddr2taddr_4_svc(); --extern char ** rpcbproc_taddr2uaddr_4(); --extern char ** rpcbproc_taddr2uaddr_4_svc(); --#define RPCBPROC_GETVERSADDR ((u_int32_t)9) --extern char ** rpcbproc_getversaddr_4(); --extern char ** rpcbproc_getversaddr_4_svc(); --#define RPCBPROC_INDIRECT ((u_int32_t)10) --extern rpcb_rmtcallres * rpcbproc_indirect_4(); --extern rpcb_rmtcallres * rpcbproc_indirect_4_svc(); --#define RPCBPROC_GETADDRLIST ((u_int32_t)11) --extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4(); --extern rpcb_entry_list_ptr * rpcbproc_getaddrlist_4_svc(); --#define RPCBPROC_GETSTAT ((u_int32_t)12) --extern rpcb_stat * rpcbproc_getstat_4(); --extern rpcb_stat * rpcbproc_getstat_4_svc(); --#endif /* Old Style C */ -- --#endif /* !_RPCB_PROT_H_RPCGEN */ -diff --git a/tirpc/rpcsvc/crypt.h b/tirpc/rpcsvc/crypt.h -deleted file mode 100644 -index da1f9cc..0000000 ---- a/tirpc/rpcsvc/crypt.h -+++ /dev/null -@@ -1,109 +0,0 @@ --/* -- * Please do not edit this file. -- * It was generated using rpcgen. -- */ -- --#ifndef _CRYPT_H_RPCGEN --#define _CRYPT_H_RPCGEN -- --#include -- --#ifndef IXDR_GET_INT32 --#define IXDR_GET_INT32(buf) IXDR_GET_LONG((buf)) --#endif --#ifndef IXDR_PUT_INT32 --#define IXDR_PUT_INT32(buf, v) IXDR_PUT_LONG((buf), (v)) --#endif --#ifndef IXDR_GET_U_INT32 --#define IXDR_GET_U_INT32(buf) IXDR_GET_U_LONG((buf)) --#endif --#ifndef IXDR_PUT_U_INT32 --#define IXDR_PUT_U_INT32(buf, v) IXDR_PUT_U_LONG((buf), (v)) --#endif -- --enum des_dir { -- ENCRYPT_DES = 0, -- DECRYPT_DES = 1, --}; --typedef enum des_dir des_dir; --#ifdef __cplusplus --extern "C" bool_t xdr_des_dir(XDR *, des_dir*); --#elif __STDC__ --extern bool_t xdr_des_dir(XDR *, des_dir*); --#else /* Old Style C */ --bool_t xdr_des_dir(); --#endif /* Old Style C */ -- -- --enum des_mode { -- CBC_DES = 0, -- ECB_DES = 1, --}; --typedef enum des_mode des_mode; --#ifdef __cplusplus --extern "C" bool_t xdr_des_mode(XDR *, des_mode*); --#elif __STDC__ --extern bool_t xdr_des_mode(XDR *, des_mode*); --#else /* Old Style C */ --bool_t xdr_des_mode(); --#endif /* Old Style C */ -- -- --struct desargs { -- u_char des_key[8]; -- des_dir des_dir; -- des_mode des_mode; -- u_char des_ivec[8]; -- struct { -- u_int desbuf_len; -- char *desbuf_val; -- } desbuf; --}; --typedef struct desargs desargs; --#ifdef __cplusplus --extern "C" bool_t xdr_desargs(XDR *, desargs*); --#elif __STDC__ --extern bool_t xdr_desargs(XDR *, desargs*); --#else /* Old Style C */ --bool_t xdr_desargs(); --#endif /* Old Style C */ -- -- --struct desresp { -- struct { -- u_int desbuf_len; -- char *desbuf_val; -- } desbuf; -- u_char des_ivec[8]; -- int stat; --}; --typedef struct desresp desresp; --#ifdef __cplusplus --extern "C" bool_t xdr_desresp(XDR *, desresp*); --#elif __STDC__ --extern bool_t xdr_desresp(XDR *, desresp*); --#else /* Old Style C */ --bool_t xdr_desresp(); --#endif /* Old Style C */ -- -- --#define CRYPT_PROG ((u_int32_t)600100029) --#define CRYPT_VERS ((u_int32_t)1) -- --#ifdef __cplusplus --#define DES_CRYPT ((u_int32_t)1) --extern "C" desresp * des_crypt_1(desargs *, CLIENT *); --extern "C" desresp * des_crypt_1_svc(desargs *, struct svc_req *); -- --#elif __STDC__ --#define DES_CRYPT ((u_int32_t)1) --extern desresp * des_crypt_1(desargs *, CLIENT *); --extern desresp * des_crypt_1_svc(desargs *, struct svc_req *); -- --#else /* Old Style C */ --#define DES_CRYPT ((u_int32_t)1) --extern desresp * des_crypt_1(); --extern desresp * des_crypt_1_svc(); --#endif /* Old Style C */ -- --#endif /* !_CRYPT_H_RPCGEN */ --- -2.0.0 - diff --git a/package/libtirpc/libtirpc-0010-Add-more-XDR-files-needed-to-build-rpcbind-on-top-of.patch b/package/libtirpc/libtirpc-0010-Add-more-XDR-files-needed-to-build-rpcbind-on-top-of.patch deleted file mode 100644 index 638918bdf1..0000000000 --- a/package/libtirpc/libtirpc-0010-Add-more-XDR-files-needed-to-build-rpcbind-on-top-of.patch +++ /dev/null @@ -1,1651 +0,0 @@ -From 008a9c8ac3a84ffcc46a0eedb5b13862b279190c Mon Sep 17 00:00:00 2001 -From: Thomas Petazzoni -Date: Sat, 10 Nov 2012 17:45:03 +0100 -Subject: [PATCH] Add more XDR files needed to build rpcbind on top of libtirpc - -Signed-off-by: Thomas Petazzoni ---- - Makefile.am | 6 + - tirpc/rpcsvc/mount.x | 257 ++++++++++ - tirpc/rpcsvc/nfs_prot.x | 1266 +++++++++++++++++++++++++++++++++++++++++++++++ - tirpc/rpcsvc/rquota.x | 67 +++ - 4 files changed, 1596 insertions(+) - create mode 100644 tirpc/rpcsvc/mount.x - create mode 100644 tirpc/rpcsvc/nfs_prot.x - create mode 100644 tirpc/rpcsvc/rquota.x - -diff --git a/Makefile.am b/Makefile.am -index 4e4dc32..b7ae979 100644 ---- a/Makefile.am -+++ b/Makefile.am -@@ -3,6 +3,9 @@ ACLOCAL_AMFLAGS = -I m4 - - GENFILES = \ - tirpc/rpcsvc/crypt.h \ -+ tirpc/rpcsvc/mount.h \ -+ tirpc/rpcsvc/nfs_prot.h \ -+ tirpc/rpcsvc/rquota.h \ - tirpc/rpc/rpcb_prot.h - - noinst_HEADERS = tirpc/reentrant.h \ -@@ -12,6 +15,9 @@ noinst_HEADERS = tirpc/reentrant.h \ - - nobase_include_HEADERS = tirpc/netconfig.h \ - tirpc/rpcsvc/crypt.x \ -+ tirpc/rpcsvc/mount.x \ -+ tirpc/rpcsvc/nfs_prot.x \ -+ tirpc/rpcsvc/rquota.x \ - tirpc/rpc/xdr.h \ - tirpc/rpc/types.h \ - tirpc/rpc/svc_soc.h \ -diff --git a/tirpc/rpcsvc/mount.x b/tirpc/rpcsvc/mount.x -new file mode 100644 -index 0000000..f68a06f ---- /dev/null -+++ b/tirpc/rpcsvc/mount.x -@@ -0,0 +1,257 @@ -+/* -+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for -+ * unrestricted use provided that this legend is included on all tape -+ * media and as a part of the software program in whole or part. Users -+ * may copy or modify Sun RPC without charge, but are not authorized -+ * to license or distribute it to anyone else except as part of a product or -+ * program developed by the user. -+ * -+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE -+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR -+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. -+ * -+ * Sun RPC is provided with no support and without any obligation on the -+ * part of Sun Microsystems, Inc. to assist in its use, correction, -+ * modification or enhancement. -+ * -+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE -+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC -+ * OR ANY PART THEREOF. -+ * -+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue -+ * or profits or other special, indirect and consequential damages, even if -+ * Sun has been advised of the possibility of such damages. -+ * -+ * Sun Microsystems, Inc. -+ * 2550 Garcia Avenue -+ * Mountain View, California 94043 -+ */ -+ -+/* -+ * Protocol description for the mount program -+ */ -+ -+#ifndef RPC_HDR -+%#ifndef lint -+%/*static char sccsid[] = "from: @(#)mount.x 1.2 87/09/18 Copyr 1987 Sun Micro";*/ -+%/*static char sccsid[] = "from: @(#)mount.x 2.1 88/08/01 4.0 RPCSRC";*/ -+%static const char rcsid[] = -+% "$FreeBSD: src/include/rpcsvc/mount.x,v 1.6 1999/08/27 23:45:08 peter Exp $"; -+%#endif /* not lint */ -+#endif -+ -+const MNTPATHLEN = 1024; /* maximum bytes in a pathname argument */ -+const MNTNAMLEN = 255; /* maximum bytes in a name argument */ -+const FHSIZE = 32; /* size in bytes of a file handle */ -+#ifdef WANT_NFS3 -+const FHSIZE3 = 64; /* size in bytes of a file handle (v3) */ -+#endif -+ -+/* -+ * The fhandle is the file handle that the server passes to the client. -+ * All file operations are done using the file handles to refer to a file -+ * or a directory. The file handle can contain whatever information the -+ * server needs to distinguish an individual file. -+ */ -+typedef opaque fhandle[FHSIZE]; -+#ifdef WANT_NFS3 -+typedef opaque fhandle3; -+#endif -+ -+/* -+ * If a status of zero is returned, the call completed successfully, and -+ * a file handle for the directory follows. A non-zero status indicates -+ * some sort of error. The status corresponds with UNIX error numbers. -+ */ -+union fhstatus switch (unsigned fhs_status) { -+case 0: -+ fhandle fhs_fhandle; -+default: -+ void; -+}; -+ -+#ifdef WANT_NFS3 -+/* -+ * Status codes returned by the version 3 mount call. -+ */ -+enum mountstat3 { -+ MNT3_OK = 0, /* no error */ -+ MNT3ERR_PERM = 1, /* Not owner */ -+ MNT3ERR_NOENT = 2, /* No such file or directory */ -+ MNT3ERR_IO = 5, /* I/O error */ -+ MNT3ERR_ACCES = 13, /* Permission denied */ -+ MNT3ERR_NOTDIR = 20, /* Not a directory */ -+ MNT3ERR_INVAL = 22, /* Invalid argument */ -+ MNT3ERR_NAMETOOLONG = 63, /* Filename too long */ -+ MNT3ERR_NOTSUPP = 10004, /* Operation not supported */ -+ MNT3ERR_SERVERFAULT = 10006 /* A failure on the server */ -+}; -+ -+struct mountres3_ok { -+ fhandle3 fhandle; -+ int auth_flavors<>; -+}; -+ -+union mountres3 switch (mountstat3 fhs_status) { -+case 0: -+ mountres3_ok mountinfo; -+default: -+ void; -+}; -+#endif -+ -+/* -+ * The type dirpath is the pathname of a directory -+ */ -+typedef string dirpath; -+ -+/* -+ * The type name is used for arbitrary names (hostnames, groupnames) -+ */ -+typedef string name; -+ -+/* -+ * A list of who has what mounted -+ */ -+typedef struct mountbody *mountlist; -+struct mountbody { -+ name ml_hostname; -+ dirpath ml_directory; -+ mountlist ml_next; -+}; -+ -+/* -+ * A list of netgroups -+ */ -+typedef struct groupnode *groups; -+struct groupnode { -+ name gr_name; -+ groups gr_next; -+}; -+ -+/* -+ * A list of what is exported and to whom -+ */ -+typedef struct exportnode *exports; -+struct exportnode { -+ dirpath ex_dir; -+ groups ex_groups; -+ exports ex_next; -+}; -+ -+program MOUNTPROG { -+ /* -+ * Version one of the mount protocol communicates with version two -+ * of the NFS protocol. Version three communicates with -+ * version three of the NFS protocol. The only connecting -+ * point is the fhandle structure, which is the same for both -+ * protocols. -+ */ -+ version MOUNTVERS { -+ /* -+ * Does no work. It is made available in all RPC services -+ * to allow server reponse testing and timing -+ */ -+ void -+ MOUNTPROC_NULL(void) = 0; -+ -+ /* -+ * If fhs_status is 0, then fhs_fhandle contains the -+ * file handle for the directory. This file handle may -+ * be used in the NFS protocol. This procedure also adds -+ * a new entry to the mount list for this client mounting -+ * the directory. -+ * Unix authentication required. -+ */ -+ fhstatus -+ MOUNTPROC_MNT(dirpath) = 1; -+ -+ /* -+ * Returns the list of remotely mounted filesystems. The -+ * mountlist contains one entry for each hostname and -+ * directory pair. -+ */ -+ mountlist -+ MOUNTPROC_DUMP(void) = 2; -+ -+ /* -+ * Removes the mount list entry for the directory -+ * Unix authentication required. -+ */ -+ void -+ MOUNTPROC_UMNT(dirpath) = 3; -+ -+ /* -+ * Removes all of the mount list entries for this client -+ * Unix authentication required. -+ */ -+ void -+ MOUNTPROC_UMNTALL(void) = 4; -+ -+ /* -+ * Returns a list of all the exported filesystems, and which -+ * machines are allowed to import it. -+ */ -+ exports -+ MOUNTPROC_EXPORT(void) = 5; -+ -+ /* -+ * Identical to MOUNTPROC_EXPORT above -+ */ -+ exports -+ MOUNTPROC_EXPORTALL(void) = 6; -+ } = 1; -+#ifdef WANT_NFS3 -+ version MOUNTVERS3 { -+ /* -+ * Does no work. It is made available in all RPC services -+ * to allow server reponse testing and timing -+ */ -+ void -+ MOUNTPROC_NULL(void) = 0; -+ -+ /* -+ * If mountres3.fhs_status is MNT3_OK, then -+ * mountres3.mountinfo contains the file handle for -+ * the directory and a list of acceptable -+ * authentication flavors. This file handle may only -+ * be used in the NFS version 3 protocol. This -+ * procedure also results in the server adding a new -+ * entry to its mount list recording that this client -+ * has mounted the directory. AUTH_UNIX authentication -+ * or better is required. -+ */ -+ mountres3 -+ MOUNTPROC_MNT(dirpath) = 1; -+ -+ /* -+ * Returns the list of remotely mounted filesystems. The -+ * mountlist contains one entry for each hostname and -+ * directory pair. -+ */ -+ mountlist -+ MOUNTPROC_DUMP(void) = 2; -+ -+ /* -+ * Removes the mount list entry for the directory -+ * Unix authentication required. -+ */ -+ void -+ MOUNTPROC_UMNT(dirpath) = 3; -+ -+ /* -+ * Removes all of the mount list entries for this client -+ * Unix authentication required. -+ */ -+ void -+ MOUNTPROC_UMNTALL(void) = 4; -+ -+ /* -+ * Returns a list of all the exported filesystems, and which -+ * machines are allowed to import it. -+ */ -+ exports -+ MOUNTPROC_EXPORT(void) = 5; -+ } = 3; -+#endif -+} = 100005; -diff --git a/tirpc/rpcsvc/nfs_prot.x b/tirpc/rpcsvc/nfs_prot.x -new file mode 100644 -index 0000000..01564f8 ---- /dev/null -+++ b/tirpc/rpcsvc/nfs_prot.x -@@ -0,0 +1,1266 @@ -+/* -+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for -+ * unrestricted use provided that this legend is included on all tape -+ * media and as a part of the software program in whole or part. Users -+ * may copy or modify Sun RPC without charge, but are not authorized -+ * to license or distribute it to anyone else except as part of a product or -+ * program developed by the user. -+ * -+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE -+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR -+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. -+ * -+ * Sun RPC is provided with no support and without any obligation on the -+ * part of Sun Microsystems, Inc. to assist in its use, correction, -+ * modification or enhancement. -+ * -+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE -+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC -+ * OR ANY PART THEREOF. -+ * -+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue -+ * or profits or other special, indirect and consequential damages, even if -+ * Sun has been advised of the possibility of such damages. -+ * -+ * Sun Microsystems, Inc. -+ * 2550 Garcia Avenue -+ * Mountain View, California 94043 -+ */ -+ -+#ifndef RPC_HDR -+%#ifndef lint -+%/*static char sccsid[] = "from: @(#)nfs_prot.x 1.2 87/10/12 Copyr 1987 Sun Micro";*/ -+%/*static char sccsid[] = "from: @(#)nfs_prot.x 2.1 88/08/01 4.0 RPCSRC";*/ -+%static const char rcsid[] = -+% "$FreeBSD: src/include/rpcsvc/nfs_prot.x,v 1.7 1999/08/27 23:45:08 peter Exp $"; -+%#endif /* not lint */ -+#endif -+ -+const NFS_PORT = 2049; -+const NFS_MAXDATA = 8192; -+const NFS_MAXPATHLEN = 1024; -+const NFS_MAXNAMLEN = 255; -+const NFS_FHSIZE = 32; -+const NFS_COOKIESIZE = 4; -+const NFS_FIFO_DEV = -1; /* size kludge for named pipes */ -+ -+/* -+ * File types -+ */ -+const NFSMODE_FMT = 0170000; /* type of file */ -+const NFSMODE_DIR = 0040000; /* directory */ -+const NFSMODE_CHR = 0020000; /* character special */ -+const NFSMODE_BLK = 0060000; /* block special */ -+const NFSMODE_REG = 0100000; /* regular */ -+const NFSMODE_LNK = 0120000; /* symbolic link */ -+const NFSMODE_SOCK = 0140000; /* socket */ -+const NFSMODE_FIFO = 0010000; /* fifo */ -+ -+/* -+ * Error status -+ */ -+enum nfsstat { -+ NFS_OK= 0, /* no error */ -+ NFSERR_PERM=1, /* Not owner */ -+ NFSERR_NOENT=2, /* No such file or directory */ -+ NFSERR_IO=5, /* I/O error */ -+ NFSERR_NXIO=6, /* No such device or address */ -+ NFSERR_ACCES=13, /* Permission denied */ -+ NFSERR_EXIST=17, /* File exists */ -+ NFSERR_NODEV=19, /* No such device */ -+ NFSERR_NOTDIR=20, /* Not a directory*/ -+ NFSERR_ISDIR=21, /* Is a directory */ -+ NFSERR_FBIG=27, /* File too large */ -+ NFSERR_NOSPC=28, /* No space left on device */ -+ NFSERR_ROFS=30, /* Read-only file system */ -+ NFSERR_NAMETOOLONG=63, /* File name too long */ -+ NFSERR_NOTEMPTY=66, /* Directory not empty */ -+ NFSERR_DQUOT=69, /* Disc quota exceeded */ -+ NFSERR_STALE=70, /* Stale NFS file handle */ -+ NFSERR_WFLUSH=99 /* write cache flushed */ -+}; -+ -+/* -+ * File types -+ */ -+enum ftype { -+ NFNON = 0, /* non-file */ -+ NFREG = 1, /* regular file */ -+ NFDIR = 2, /* directory */ -+ NFBLK = 3, /* block special */ -+ NFCHR = 4, /* character special */ -+ NFLNK = 5, /* symbolic link */ -+ NFSOCK = 6, /* unix domain sockets */ -+ NFBAD = 7, /* unused */ -+ NFFIFO = 8 /* named pipe */ -+}; -+ -+/* -+ * File access handle -+ */ -+struct nfs_fh { -+ opaque data[NFS_FHSIZE]; -+}; -+ -+/* -+ * Timeval -+ */ -+struct nfstime { -+ unsigned seconds; -+ unsigned useconds; -+}; -+ -+ -+/* -+ * File attributes -+ */ -+struct fattr { -+ ftype type; /* file type */ -+ unsigned mode; /* protection mode bits */ -+ unsigned nlink; /* # hard links */ -+ unsigned uid; /* owner user id */ -+ unsigned gid; /* owner group id */ -+ unsigned size; /* file size in bytes */ -+ unsigned blocksize; /* prefered block size */ -+ unsigned rdev; /* special device # */ -+ unsigned blocks; /* Kb of disk used by file */ -+ unsigned fsid; /* device # */ -+ unsigned fileid; /* inode # */ -+ nfstime atime; /* time of last access */ -+ nfstime mtime; /* time of last modification */ -+ nfstime ctime; /* time of last change */ -+}; -+ -+/* -+ * File attributes which can be set -+ */ -+struct sattr { -+ unsigned mode; /* protection mode bits */ -+ unsigned uid; /* owner user id */ -+ unsigned gid; /* owner group id */ -+ unsigned size; /* file size in bytes */ -+ nfstime atime; /* time of last access */ -+ nfstime mtime; /* time of last modification */ -+}; -+ -+ -+typedef string filename; -+typedef string nfspath; -+ -+/* -+ * Reply status with file attributes -+ */ -+union attrstat switch (nfsstat status) { -+case NFS_OK: -+ fattr attributes; -+default: -+ void; -+}; -+ -+struct sattrargs { -+ nfs_fh file; -+ sattr attributes; -+}; -+ -+/* -+ * Arguments for directory operations -+ */ -+struct diropargs { -+ nfs_fh dir; /* directory file handle */ -+ filename name; /* name (up to NFS_MAXNAMLEN bytes) */ -+}; -+ -+struct diropokres { -+ nfs_fh file; -+ fattr attributes; -+}; -+ -+/* -+ * Results from directory operation -+ */ -+union diropres switch (nfsstat status) { -+case NFS_OK: -+ diropokres diropres; -+default: -+ void; -+}; -+ -+union readlinkres switch (nfsstat status) { -+case NFS_OK: -+ nfspath data; -+default: -+ void; -+}; -+ -+/* -+ * Arguments to remote read -+ */ -+struct readargs { -+ nfs_fh file; /* handle for file */ -+ unsigned offset; /* byte offset in file */ -+ unsigned count; /* immediate read count */ -+ unsigned totalcount; /* total read count (from this offset)*/ -+}; -+ -+/* -+ * Status OK portion of remote read reply -+ */ -+struct readokres { -+ fattr attributes; /* attributes, need for pagin*/ -+ opaque data; -+}; -+ -+union readres switch (nfsstat status) { -+case NFS_OK: -+ readokres reply; -+default: -+ void; -+}; -+ -+/* -+ * Arguments to remote write -+ */ -+struct writeargs { -+ nfs_fh file; /* handle for file */ -+ unsigned beginoffset; /* beginning byte offset in file */ -+ unsigned offset; /* current byte offset in file */ -+ unsigned totalcount; /* total write count (to this offset)*/ -+ opaque data; -+}; -+ -+struct createargs { -+ diropargs where; -+ sattr attributes; -+}; -+ -+struct renameargs { -+ diropargs from; -+ diropargs to; -+}; -+ -+struct linkargs { -+ nfs_fh from; -+ diropargs to; -+}; -+ -+struct symlinkargs { -+ diropargs from; -+ nfspath to; -+ sattr attributes; -+}; -+ -+ -+typedef opaque nfscookie[NFS_COOKIESIZE]; -+ -+/* -+ * Arguments to readdir -+ */ -+struct readdirargs { -+ nfs_fh dir; /* directory handle */ -+ nfscookie cookie; -+ unsigned count; /* number of directory bytes to read */ -+}; -+ -+struct entry { -+ unsigned fileid; -+ filename name; -+ nfscookie cookie; -+ entry *nextentry; -+}; -+ -+struct dirlist { -+ entry *entries; -+ bool eof; -+}; -+ -+union readdirres switch (nfsstat status) { -+case NFS_OK: -+ dirlist reply; -+default: -+ void; -+}; -+ -+struct statfsokres { -+ unsigned tsize; /* preferred transfer size in bytes */ -+ unsigned bsize; /* fundamental file system block size */ -+ unsigned blocks; /* total blocks in file system */ -+ unsigned bfree; /* free blocks in fs */ -+ unsigned bavail; /* free blocks avail to non-superuser */ -+}; -+ -+union statfsres switch (nfsstat status) { -+case NFS_OK: -+ statfsokres reply; -+default: -+ void; -+}; -+ -+#ifdef WANT_NFS3 -+ -+/* -+ * NFSv3 constants and types -+ */ -+const NFS3_FHSIZE = 64; /* maximum size in bytes of a file handle */ -+const NFS3_COOKIEVERFSIZE = 8; /* size of a cookie verifier for READDIR */ -+const NFS3_CREATEVERFSIZE = 8; /* size of the verifier used for CREATE */ -+const NFS3_WRITEVERFSIZE = 8; /* size of the verifier used for WRITE */ -+ -+typedef unsigned hyper uint64; -+typedef hyper int64; -+typedef unsigned long uint32; -+typedef long int32; -+typedef string filename3<>; -+typedef string nfspath3<>; -+typedef uint64 fileid3; -+typedef uint64 cookie3; -+typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE]; -+typedef opaque createverf3[NFS3_CREATEVERFSIZE]; -+typedef opaque writeverf3[NFS3_WRITEVERFSIZE]; -+typedef uint32 uid3; -+typedef uint32 gid3; -+typedef uint64 size3; -+typedef uint64 offset3; -+typedef uint32 mode3; -+typedef uint32 count3; -+ -+/* -+ * Error status (v3) -+ */ -+enum nfsstat3 { -+ NFS3_OK = 0, -+ NFS3ERR_PERM = 1, -+ NFS3ERR_NOENT = 2, -+ NFS3ERR_IO = 5, -+ NFS3ERR_NXIO = 6, -+ NFS3ERR_ACCES = 13, -+ NFS3ERR_EXIST = 17, -+ NFS3ERR_XDEV = 18, -+ NFS3ERR_NODEV = 19, -+ NFS3ERR_NOTDIR = 20, -+ NFS3ERR_ISDIR = 21, -+ NFS3ERR_INVAL = 22, -+ NFS3ERR_FBIG = 27, -+ NFS3ERR_NOSPC = 28, -+ NFS3ERR_ROFS = 30, -+ NFS3ERR_MLINK = 31, -+ NFS3ERR_NAMETOOLONG = 63, -+ NFS3ERR_NOTEMPTY = 66, -+ NFS3ERR_DQUOT = 69, -+ NFS3ERR_STALE = 70, -+ NFS3ERR_REMOTE = 71, -+ NFS3ERR_BADHANDLE = 10001, -+ NFS3ERR_NOT_SYNC = 10002, -+ NFS3ERR_BAD_COOKIE = 10003, -+ NFS3ERR_NOTSUPP = 10004, -+ NFS3ERR_TOOSMALL = 10005, -+ NFS3ERR_SERVERFAULT = 10006, -+ NFS3ERR_BADTYPE = 10007, -+ NFS3ERR_JUKEBOX = 10008 -+}; -+ -+/* -+ * File types (v3) -+ */ -+enum ftype3 { -+ NF3REG = 1, /* regular file */ -+ NF3DIR = 2, /* directory */ -+ NF3BLK = 3, /* block special */ -+ NF3CHR = 4, /* character special */ -+ NF3LNK = 5, /* symbolic link */ -+ NF3SOCK = 6, /* unix domain sockets */ -+ NF3FIFO = 7 /* named pipe */ -+}; -+ -+struct specdata3 { -+ uint32 specdata1; -+ uint32 specdata2; -+}; -+ -+/* -+ * File access handle (v3) -+ */ -+struct nfs_fh3 { -+ opaque data; -+}; -+ -+/* -+ * Timeval (v3) -+ */ -+struct nfstime3 { -+ uint32 seconds; -+ uint32 nseconds; -+}; -+ -+ -+/* -+ * File attributes (v3) -+ */ -+struct fattr3 { -+ ftype3 type; /* file type */ -+ mode3 mode; /* protection mode bits */ -+ uint32 nlink; /* # hard links */ -+ uid3 uid; /* owner user id */ -+ gid3 gid; /* owner group id */ -+ size3 size; /* file size in bytes */ -+ size3 used; /* prefered block size */ -+ specdata3 rdev; /* special device # */ -+ uint64 fsid; /* device # */ -+ fileid3 fileid; /* inode # */ -+ nfstime3 atime; /* time of last access */ -+ nfstime3 mtime; /* time of last modification */ -+ nfstime3 ctime; /* time of last change */ -+}; -+ -+union post_op_attr switch (bool attributes_follow) { -+case TRUE: -+ fattr3 attributes; -+case FALSE: -+ void; -+}; -+ -+struct wcc_attr { -+ size3 size; -+ nfstime3 mtime; -+ nfstime3 ctime; -+}; -+ -+union pre_op_attr switch (bool attributes_follow) { -+case TRUE: -+ wcc_attr attributes; -+case FALSE: -+ void; -+}; -+ -+struct wcc_data { -+ pre_op_attr before; -+ post_op_attr after; -+}; -+ -+union post_op_fh3 switch (bool handle_follows) { -+case TRUE: -+ nfs_fh3 handle; -+case FALSE: -+ void; -+}; -+ -+/* -+ * File attributes which can be set (v3) -+ */ -+enum time_how { -+ DONT_CHANGE = 0, -+ SET_TO_SERVER_TIME = 1, -+ SET_TO_CLIENT_TIME = 2 -+}; -+ -+union set_mode3 switch (bool set_it) { -+case TRUE: -+ mode3 mode; -+default: -+ void; -+}; -+ -+union set_uid3 switch (bool set_it) { -+case TRUE: -+ uid3 uid; -+default: -+ void; -+}; -+ -+union set_gid3 switch (bool set_it) { -+case TRUE: -+ gid3 gid; -+default: -+ void; -+}; -+ -+union set_size3 switch (bool set_it) { -+case TRUE: -+ size3 size; -+default: -+ void; -+}; -+ -+union set_atime switch (time_how set_it) { -+case SET_TO_CLIENT_TIME: -+ nfstime3 atime; -+default: -+ void; -+}; -+ -+union set_mtime switch (time_how set_it) { -+case SET_TO_CLIENT_TIME: -+ nfstime3 mtime; -+default: -+ void; -+}; -+ -+struct sattr3 { -+ set_mode3 mode; -+ set_uid3 uid; -+ set_gid3 gid; -+ set_size3 size; -+ set_atime atime; -+ set_mtime mtime; -+}; -+ -+/* -+ * Arguments for directory operations (v3) -+ */ -+struct diropargs3 { -+ nfs_fh3 dir; /* directory file handle */ -+ filename3 name; /* name (up to NFS_MAXNAMLEN bytes) */ -+}; -+ -+/* -+ * Arguments to getattr (v3). -+ */ -+struct GETATTR3args { -+ nfs_fh3 object; -+}; -+ -+struct GETATTR3resok { -+ fattr3 obj_attributes; -+}; -+ -+union GETATTR3res switch (nfsstat3 status) { -+case NFS3_OK: -+ GETATTR3resok resok; -+default: -+ void; -+}; -+ -+/* -+ * Arguments to setattr (v3). -+ */ -+union sattrguard3 switch (bool check) { -+case TRUE: -+ nfstime3 obj_ctime; -+case FALSE: -+ void; -+}; -+ -+struct SETATTR3args { -+ nfs_fh3 object; -+ sattr3 new_attributes; -+ sattrguard3 guard; -+}; -+ -+struct SETATTR3resok { -+ wcc_data obj_wcc; -+}; -+ -+struct SETATTR3resfail { -+ wcc_data obj_wcc; -+}; -+ -+union SETATTR3res switch (nfsstat3 status) { -+case NFS3_OK: -+ SETATTR3resok resok; -+default: -+ SETATTR3resfail resfail; -+}; -+ -+/* -+ * Arguments to lookup (v3). -+ */ -+struct LOOKUP3args { -+ diropargs3 what; -+}; -+ -+struct LOOKUP3resok { -+ nfs_fh3 object; -+ post_op_attr obj_attributes; -+ post_op_attr dir_attributes; -+}; -+ -+struct LOOKUP3resfail { -+ post_op_attr dir_attributes; -+}; -+ -+union LOOKUP3res switch (nfsstat3 status) { -+case NFS3_OK: -+ LOOKUP3resok resok; -+default: -+ LOOKUP3resfail resfail; -+}; -+ -+/* -+ * Arguments to access (v3). -+ */ -+const ACCESS3_READ = 0x0001; -+const ACCESS3_LOOKUP = 0x0002; -+const ACCESS3_MODIFY = 0x0004; -+const ACCESS3_EXTEND = 0x0008; -+const ACCESS3_DELETE = 0x0010; -+const ACCESS3_EXECUTE = 0x0020; -+ -+struct ACCESS3args { -+ nfs_fh3 object; -+ uint32 access; -+}; -+ -+struct ACCESS3resok { -+ post_op_attr obj_attributes; -+ uint32 access; -+}; -+ -+struct ACCESS3resfail { -+ post_op_attr obj_attributes; -+}; -+ -+union ACCESS3res switch (nfsstat3 status) { -+case NFS3_OK: -+ ACCESS3resok resok; -+default: -+ ACCESS3resfail resfail; -+}; -+ -+/* -+ * Arguments to readlink (v3). -+ */ -+struct READLINK3args { -+ nfs_fh3 symlink; -+}; -+ -+struct READLINK3resok { -+ post_op_attr symlink_attributes; -+ nfspath3 data; -+}; -+ -+struct READLINK3resfail { -+ post_op_attr symlink_attributes; -+}; -+ -+union READLINK3res switch (nfsstat3 status) { -+case NFS3_OK: -+ READLINK3resok resok; -+default: -+ READLINK3resfail resfail; -+}; -+ -+/* -+ * Arguments to read (v3). -+ */ -+struct READ3args { -+ nfs_fh3 file; -+ offset3 offset; -+ count3 count; -+}; -+ -+struct READ3resok { -+ post_op_attr file_attributes; -+ count3 count; -+ bool eof; -+ opaque data<>; -+}; -+ -+struct READ3resfail { -+ post_op_attr file_attributes; -+}; -+ -+/* XXX: solaris 2.6 uses ``nfsstat'' here */ -+union READ3res switch (nfsstat3 status) { -+case NFS3_OK: -+ READ3resok resok; -+default: -+ READ3resfail resfail; -+}; -+ -+/* -+ * Arguments to write (v3). -+ */ -+enum stable_how { -+ UNSTABLE = 0, -+ DATA_SYNC = 1, -+ FILE_SYNC = 2 -+}; -+ -+struct WRITE3args { -+ nfs_fh3 file; -+ offset3 offset; -+ count3 count; -+ stable_how stable; -+ opaque data<>; -+}; -+ -+struct WRITE3resok { -+ wcc_data file_wcc; -+ count3 count; -+ stable_how committed; -+ writeverf3 verf; -+}; -+ -+struct WRITE3resfail { -+ wcc_data file_wcc; -+}; -+ -+union WRITE3res switch (nfsstat3 status) { -+case NFS3_OK: -+ WRITE3resok resok; -+default: -+ WRITE3resfail resfail; -+}; -+ -+/* -+ * Arguments to create (v3). -+ */ -+enum createmode3 { -+ UNCHECKED = 0, -+ GUARDED = 1, -+ EXCLUSIVE = 2 -+}; -+ -+union createhow3 switch (createmode3 mode) { -+case UNCHECKED: -+case GUARDED: -+ sattr3 obj_attributes; -+case EXCLUSIVE: -+ createverf3 verf; -+}; -+ -+struct CREATE3args { -+ diropargs3 where; -+ createhow3 how; -+}; -+ -+struct CREATE3resok { -+ post_op_fh3 obj; -+ post_op_attr obj_attributes; -+ wcc_data dir_wcc; -+}; -+ -+struct CREATE3resfail { -+ wcc_data dir_wcc; -+}; -+ -+union CREATE3res switch (nfsstat3 status) { -+case NFS3_OK: -+ CREATE3resok resok; -+default: -+ CREATE3resfail resfail; -+}; -+ -+/* -+ * Arguments to mkdir (v3). -+ */ -+struct MKDIR3args { -+ diropargs3 where; -+ sattr3 attributes; -+}; -+ -+struct MKDIR3resok { -+ post_op_fh3 obj; -+ post_op_attr obj_attributes; -+ wcc_data dir_wcc; -+}; -+ -+struct MKDIR3resfail { -+ wcc_data dir_wcc; -+}; -+ -+union MKDIR3res switch (nfsstat3 status) { -+case NFS3_OK: -+ MKDIR3resok resok; -+default: -+ MKDIR3resfail resfail; -+}; -+ -+/* -+ * Arguments to symlink (v3). -+ */ -+struct symlinkdata3 { -+ sattr3 symlink_attributes; -+ nfspath3 symlink_data; -+}; -+ -+struct SYMLINK3args { -+ diropargs3 where; -+ symlinkdata3 symlink; -+}; -+ -+struct SYMLINK3resok { -+ post_op_fh3 obj; -+ post_op_attr obj_attributes; -+ wcc_data dir_wcc; -+}; -+ -+struct SYMLINK3resfail { -+ wcc_data dir_wcc; -+}; -+ -+union SYMLINK3res switch (nfsstat3 status) { -+case NFS3_OK: -+ SYMLINK3resok resok; -+default: -+ SYMLINK3resfail resfail; -+}; -+ -+/* -+ * Arguments to mknod (v3). -+ */ -+struct devicedata3 { -+ sattr3 dev_attributes; -+ specdata3 spec; -+}; -+ -+union mknoddata3 switch (ftype3 type) { -+case NF3CHR: -+case NF3BLK: -+ devicedata3 device; -+case NF3SOCK: -+case NF3FIFO: -+ sattr3 pipe_attributes; -+default: -+ void; -+}; -+ -+struct MKNOD3args { -+ diropargs3 where; -+ mknoddata3 what; -+}; -+ -+struct MKNOD3resok { -+ post_op_fh3 obj; -+ post_op_attr obj_attributes; -+ wcc_data dir_wcc; -+}; -+ -+struct MKNOD3resfail { -+ wcc_data dir_wcc; -+}; -+ -+union MKNOD3res switch (nfsstat3 status) { -+case NFS3_OK: -+ MKNOD3resok resok; -+default: -+ MKNOD3resfail resfail; -+}; -+ -+/* -+ * Arguments to remove (v3). -+ */ -+struct REMOVE3args { -+ diropargs3 object; -+}; -+ -+struct REMOVE3resok { -+ wcc_data dir_wcc; -+}; -+ -+struct REMOVE3resfail { -+ wcc_data dir_wcc; -+}; -+ -+union REMOVE3res switch (nfsstat3 status) { -+case NFS3_OK: -+ REMOVE3resok resok; -+default: -+ REMOVE3resfail resfail; -+}; -+ -+/* -+ * Arguments to rmdir (v3). -+ */ -+struct RMDIR3args { -+ diropargs3 object; -+}; -+ -+struct RMDIR3resok { -+ wcc_data dir_wcc; -+}; -+ -+struct RMDIR3resfail { -+ wcc_data dir_wcc; -+}; -+ -+union RMDIR3res switch (nfsstat3 status) { -+case NFS3_OK: -+ RMDIR3resok resok; -+default: -+ RMDIR3resfail resfail; -+}; -+ -+/* -+ * Arguments to rename (v3). -+ */ -+struct RENAME3args { -+ diropargs3 from; -+ diropargs3 to; -+}; -+ -+struct RENAME3resok { -+ wcc_data fromdir_wcc; -+ wcc_data todir_wcc; -+}; -+ -+struct RENAME3resfail { -+ wcc_data fromdir_wcc; -+ wcc_data todir_wcc; -+}; -+ -+union RENAME3res switch (nfsstat3 status) { -+case NFS3_OK: -+ RENAME3resok resok; -+default: -+ RENAME3resfail resfail; -+}; -+ -+/* -+ * Arguments to link (v3). -+ */ -+struct LINK3args { -+ nfs_fh3 file; -+ diropargs3 link; -+}; -+ -+struct LINK3resok { -+ post_op_attr file_attributes; -+ wcc_data linkdir_wcc; -+}; -+ -+struct LINK3resfail { -+ post_op_attr file_attributes; -+ wcc_data linkdir_wcc; -+}; -+ -+union LINK3res switch (nfsstat3 status) { -+case NFS3_OK: -+ LINK3resok resok; -+default: -+ LINK3resfail resfail; -+}; -+ -+/* -+ * Arguments to readdir (v3). -+ */ -+struct READDIR3args { -+ nfs_fh3 dir; -+ cookie3 cookie; -+ cookieverf3 cookieverf; -+ count3 count; -+}; -+ -+struct entry3 { -+ fileid3 fileid; -+ filename3 name; -+ cookie3 cookie; -+ entry3 *nextentry; -+}; -+ -+struct dirlist3 { -+ entry3 *entries; -+ bool eof; -+}; -+ -+struct READDIR3resok { -+ post_op_attr dir_attributes; -+ cookieverf3 cookieverf; -+ dirlist3 reply; -+}; -+ -+struct READDIR3resfail { -+ post_op_attr dir_attributes; -+}; -+ -+union READDIR3res switch (nfsstat3 status) { -+case NFS3_OK: -+ READDIR3resok resok; -+default: -+ READDIR3resfail resfail; -+}; -+ -+/* -+ * Arguments to readdirplus (v3). -+ */ -+struct READDIRPLUS3args { -+ nfs_fh3 dir; -+ cookie3 cookie; -+ cookieverf3 cookieverf; -+ count3 dircount; -+ count3 maxcount; -+}; -+ -+struct entryplus3 { -+ fileid3 fileid; -+ filename3 name; -+ cookie3 cookie; -+ post_op_attr name_attributes; -+ post_op_fh3 name_handle; -+ entryplus3 *nextentry; -+}; -+ -+struct dirlistplus3 { -+ entryplus3 *entries; -+ bool eof; -+}; -+ -+struct READDIRPLUS3resok { -+ post_op_attr dir_attributes; -+ cookieverf3 cookieverf; -+ dirlistplus3 reply; -+}; -+ -+struct READDIRPLUS3resfail { -+ post_op_attr dir_attributes; -+}; -+ -+union READDIRPLUS3res switch (nfsstat3 status) { -+case NFS3_OK: -+ READDIRPLUS3resok resok; -+default: -+ READDIRPLUS3resfail resfail; -+}; -+ -+/* -+ * Arguments to fsstat (v3). -+ */ -+struct FSSTAT3args { -+ nfs_fh3 fsroot; -+}; -+ -+struct FSSTAT3resok { -+ post_op_attr obj_attributes; -+ size3 tbytes; -+ size3 fbytes; -+ size3 abytes; -+ size3 tfiles; -+ size3 ffiles; -+ size3 afiles; -+ uint32 invarsec; -+}; -+ -+struct FSSTAT3resfail { -+ post_op_attr obj_attributes; -+}; -+ -+union FSSTAT3res switch (nfsstat3 status) { -+case NFS3_OK: -+ FSSTAT3resok resok; -+default: -+ FSSTAT3resfail resfail; -+}; -+ -+/* -+ * Arguments to fsinfo (v3). -+ */ -+const FSF3_LINK = 0x0001; -+const FSF3_SYMLINK = 0x0002; -+const FSF3_HOMOGENEOUS = 0x0008; -+const FSF3_CANSETTIME = 0x0010; -+ -+struct FSINFO3args { -+ nfs_fh3 fsroot; -+}; -+ -+struct FSINFO3resok { -+ post_op_attr obj_attributes; -+ uint32 rtmax; -+ uint32 rtpref; -+ uint32 rtmult; -+ uint32 wtmax; -+ uint32 wtpref; -+ uint32 wtmult; -+ uint32 dtpref; -+ size3 maxfilesize; -+ nfstime3 time_delta; -+ uint32 properties; -+}; -+ -+struct FSINFO3resfail { -+ post_op_attr obj_attributes; -+}; -+ -+union FSINFO3res switch (nfsstat3 status) { -+case NFS3_OK: -+ FSINFO3resok resok; -+default: -+ FSINFO3resfail resfail; -+}; -+ -+/* -+ * Arguments to pathconf (v3). -+ */ -+struct PATHCONF3args { -+ nfs_fh3 object; -+}; -+ -+struct PATHCONF3resok { -+ post_op_attr obj_attributes; -+ uint32 linkmax; -+ uint32 name_max; -+ bool no_trunc; -+ bool chown_restricted; -+ bool case_insensitive; -+ bool case_preserving; -+}; -+ -+struct PATHCONF3resfail { -+ post_op_attr obj_attributes; -+}; -+ -+union PATHCONF3res switch (nfsstat3 status) { -+case NFS3_OK: -+ PATHCONF3resok resok; -+default: -+ PATHCONF3resfail resfail; -+}; -+ -+/* -+ * Arguments to commit (v3). -+ */ -+struct COMMIT3args { -+ nfs_fh3 file; -+ offset3 offset; -+ count3 count; -+}; -+ -+struct COMMIT3resok { -+ wcc_data file_wcc; -+ writeverf3 verf; -+}; -+ -+struct COMMIT3resfail { -+ wcc_data file_wcc; -+}; -+ -+union COMMIT3res switch (nfsstat3 status) { -+case NFS3_OK: -+ COMMIT3resok resok; -+default: -+ COMMIT3resfail resfail; -+}; -+ -+#endif /* WANT_NFS3 */ -+ -+/* -+ * Remote file service routines -+ */ -+program NFS_PROGRAM { -+ version NFS_VERSION { -+ void -+ NFSPROC_NULL(void) = 0; -+ -+ attrstat -+ NFSPROC_GETATTR(nfs_fh) = 1; -+ -+ attrstat -+ NFSPROC_SETATTR(sattrargs) = 2; -+ -+ void -+ NFSPROC_ROOT(void) = 3; -+ -+ diropres -+ NFSPROC_LOOKUP(diropargs) = 4; -+ -+ readlinkres -+ NFSPROC_READLINK(nfs_fh) = 5; -+ -+ readres -+ NFSPROC_READ(readargs) = 6; -+ -+ void -+ NFSPROC_WRITECACHE(void) = 7; -+ -+ attrstat -+ NFSPROC_WRITE(writeargs) = 8; -+ -+ diropres -+ NFSPROC_CREATE(createargs) = 9; -+ -+ nfsstat -+ NFSPROC_REMOVE(diropargs) = 10; -+ -+ nfsstat -+ NFSPROC_RENAME(renameargs) = 11; -+ -+ nfsstat -+ NFSPROC_LINK(linkargs) = 12; -+ -+ nfsstat -+ NFSPROC_SYMLINK(symlinkargs) = 13; -+ -+ diropres -+ NFSPROC_MKDIR(createargs) = 14; -+ -+ nfsstat -+ NFSPROC_RMDIR(diropargs) = 15; -+ -+ readdirres -+ NFSPROC_READDIR(readdirargs) = 16; -+ -+ statfsres -+ NFSPROC_STATFS(nfs_fh) = 17; -+ } = 2; -+} = 100003; -+#ifdef WANT_NFS3 -+program NFS3_PROGRAM { -+ version NFS_V3 { -+ void -+ NFSPROC3_NULL(void) = 0; -+ -+ GETATTR3res -+ NFSPROC3_GETATTR(GETATTR3args) = 1; -+ -+ SETATTR3res -+ NFSPROC3_SETATTR(SETATTR3args) = 2; -+ -+ LOOKUP3res -+ NFSPROC3_LOOKUP(LOOKUP3args) = 3; -+ -+ ACCESS3res -+ NFSPROC3_ACCESS(ACCESS3args) = 4; -+ -+ READLINK3res -+ NFSPROC3_READLINK(READLINK3args) = 5; -+ -+ READ3res -+ NFSPROC3_READ(READ3args) = 6; -+ -+ WRITE3res -+ NFSPROC3_WRITE(WRITE3args) = 7; -+ -+ CREATE3res -+ NFSPROC3_CREATE(CREATE3args) = 8; -+ -+ MKDIR3res -+ NFSPROC3_MKDIR(MKDIR3args) = 9; -+ -+ SYMLINK3res -+ NFSPROC3_SYMLINK(SYMLINK3args) = 10; -+ -+ MKNOD3res -+ NFSPROC3_MKNOD(MKNOD3args) = 11; -+ -+ REMOVE3res -+ NFSPROC3_REMOVE(REMOVE3args) = 12; -+ -+ RMDIR3res -+ NFSPROC3_RMDIR(RMDIR3args) = 13; -+ -+ RENAME3res -+ NFSPROC3_RENAME(RENAME3args) = 14; -+ -+ LINK3res -+ NFSPROC3_LINK(LINK3args) = 15; -+ -+ READDIR3res -+ NFSPROC3_READDIR(READDIR3args) = 16; -+ -+ READDIRPLUS3res -+ NFSPROC3_READDIRPLUS(READDIRPLUS3args) = 17; -+ -+ FSSTAT3res -+ NFSPROC3_FSSTAT(FSSTAT3args) = 18; -+ -+ FSINFO3res -+ NFSPROC3_FSINFO(FSINFO3args) = 19; -+ -+ PATHCONF3res -+ NFSPROC3_PATHCONF(PATHCONF3args) = 20; -+ -+ COMMIT3res -+ NFSPROC3_COMMIT(COMMIT3args) = 21; -+ } = 3; -+} = 100003; -+#endif -+ -diff --git a/tirpc/rpcsvc/rquota.x b/tirpc/rpcsvc/rquota.x -new file mode 100644 -index 0000000..72864d1 ---- /dev/null -+++ b/tirpc/rpcsvc/rquota.x -@@ -0,0 +1,67 @@ -+/* -+ * Remote quota protocol -+ * Requires unix authentication -+ */ -+ -+#ifndef RPC_HDR -+%#ifndef lint -+%/*static char sccsid[] = "from: @(#)rquota.x 1.2 87/09/20 Copyr 1987 Sun Micro";*/ -+%/*static char sccsid[] = "from: @(#)rquota.x 2.1 88/08/01 4.0 RPCSRC";*/ -+%static const char rcsid[] = -+% "$FreeBSD: src/include/rpcsvc/rquota.x,v 1.6 1999/08/27 23:45:10 peter Exp $"; -+%#endif /* not lint */ -+#endif -+ -+const RQ_PATHLEN = 1024; -+ -+struct getquota_args { -+ string gqa_pathp; /* path to filesystem of interest */ -+ int gqa_uid; /* inquire about quota for uid */ -+}; -+ -+/* -+ * remote quota structure -+ */ -+struct rquota { -+ int rq_bsize; /* block size for block counts */ -+ bool rq_active; /* indicates whether quota is active */ -+ unsigned int rq_bhardlimit; /* absolute limit on disk blks alloc */ -+ unsigned int rq_bsoftlimit; /* preferred limit on disk blks */ -+ unsigned int rq_curblocks; /* current block count */ -+ unsigned int rq_fhardlimit; /* absolute limit on allocated files */ -+ unsigned int rq_fsoftlimit; /* preferred file limit */ -+ unsigned int rq_curfiles; /* current # allocated files */ -+ unsigned int rq_btimeleft; /* time left for excessive disk use */ -+ unsigned int rq_ftimeleft; /* time left for excessive files */ -+}; -+ -+enum gqr_status { -+ Q_OK = 1, /* quota returned */ -+ Q_NOQUOTA = 2, /* noquota for uid */ -+ Q_EPERM = 3 /* no permission to access quota */ -+}; -+ -+union getquota_rslt switch (gqr_status status) { -+case Q_OK: -+ rquota gqr_rquota; /* valid if status == Q_OK */ -+case Q_NOQUOTA: -+ void; -+case Q_EPERM: -+ void; -+}; -+ -+program RQUOTAPROG { -+ version RQUOTAVERS { -+ /* -+ * Get all quotas -+ */ -+ getquota_rslt -+ RQUOTAPROC_GETQUOTA(getquota_args) = 1; -+ -+ /* -+ * Get active quotas only -+ */ -+ getquota_rslt -+ RQUOTAPROC_GETACTIVEQUOTA(getquota_args) = 2; -+ } = 1; -+} = 100011; --- -2.0.0 -