AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-21 12:30:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove --enable-obsolete-rpc configure flag

Browse Source 
Sun RPC was removed from glibc. This includes rpcgen program, librpcsvc,
and Sun RPC headers. Also test for bug #20790 was removed
(test for rpcgen).

Backward compatibility for old programs is kept only for architectures
and ABIs that have been added in or before version 2.28.

libtirpc is mature enough, librpcsvc and rpcgen are provided in
rpcsvc-proto project.

NOTE: libnsl code depends on Sun RPC (installed libnsl headers use
installed Sun RPC headers), thus --enable-obsolete-rpc was a dependency
for --enable-obsolete-nsl (removed in a previous commit).

The arc ABI list file has to be updated because the port was added
with the sunrpc symbols

Tested-by: Carlos O'Donell <carlos@redhat.com>
Reviewed-by: Carlos O'Donell <carlos@redhat.com>
This commit is contained in:
Petr Vorel 2020-07-13 19:36:35 +02:00 committed by Florian Weimer
parent 3486924dc7
commit 5500cdba40
43 changed files with 35 additions and 9603 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
NEWS
View File

@ -91,6 +91,14 @@ Major new features:
Deprecated and removed features, and other changes affecting compatibility:
* Remove configure option --enable-obsolete-rpc. Sun RPC is removed
from glibc. This includes the rpcgen program, librpcsvc, and the Sun
RPC header files. Backward compatibility for old programs is kept
only for architectures and ABIs that have been added in or before
glibc 2.31. New programs need to use TI-RPC
<http://git.linux-nfs.org/?p=steved/libtirpc.git;a=summary> and
rpcsvc-proto <https://github.com/thkukuk/rpcsvc-proto>.
* Remove configure option --enable-obsolete-nsl. libnsl is only built
as shared library for backward compatibility and the NSS modules "nis"
and "nisplus" are not built at all and libnsl's headers aren't

29
benchtests/strcoll-inputs/filelist#en_US.UTF-8
View File

@ -14107,40 +14107,20 @@ nptl
bits
manual
sunrpc
rpc_hout.c
tst-xdrmem2.c
rpc_util.h
getrpcbynumber_r.c
xdr_intXX_t.c
rpc_tblout.c
svc.c
rpc_svcout.c
get_myaddr.c
getrpcport.c
auth_unix.c
rpc_prot.c
svcauth_des.c
rpc_clntout.c
des_soft.c
thrsvc.c
xdr_rec.c
rpcinfo.c
rpcsvc
sm_inter.x
spray.x
nfs_prot.x
bootparam.h
klm_prot.x
key_prot.x
rstat.x
rusers.x
rex.x
yppasswd.x
mount.x
bootparam_prot.x
rquota.x
nlm_prot.x
rpc_main.c
pmap_prot.c
pmap_prot2.c
rtime.c
@ -14150,7 +14130,6 @@ svc_simple.c
svc_raw.c
getrpcent.c
pmap_rmt.c
rpc_sample.c
pm_getport.c
openchild.c
xdr_stdio.c
@ -14187,11 +14166,8 @@ clnt.h
pmap_clnt.c
xdr.c
bindrsvprt.c
rpc_parse.c
Makefile
rpc_util.c
des_crypt.c
rpc_parse.h
key_call.c
authdes_prot.c
xdr_float.c
@ -14201,7 +14177,6 @@ clnt_gen.c
getrpcbyname_r.c
getrpcbyname.c
clnt_udp.c
proto.h
publickey.c
svc_auth.c
etc.rpc
@ -14212,20 +14187,16 @@ getrpcent_r.c
rpc_common.c
rpc_dtable.c
clnt_unix.c
rpcgen.c
auth_none.c
rpc_scan.c
authuxprot.c
svc_udp.c
Versions
test-rpcent.c
svc_run.c
key_prot.c
rpc_cout.c
pm_getmaps.c
xdr_ref.c
getrpcbynumber.c
rpc_scan.h
ChangeLog.old-ports-arm
libc-abis
configure.ac

4
config.h.in
View File

@ -169,10 +169,6 @@
/* Define if multi-arch DSOs should be generated. */
#undef USE_MULTIARCH
/* Define if obsolete RPC code should be made available for user-level code
to link against. */
#undef LINK_OBSOLETE_RPC
/* Define if Systemtap <sys/sdt.h> probes should be defined. */
#undef USE_STAP_PROBE

1
config.make.in
View File

@ -96,7 +96,6 @@ build-profile = @profile@
build-static-nss = @static_nss@
cross-compiling = @cross_compiling@
force-install = @force_install@
link-obsolete-rpc = @link_obsolete_rpc@
build-crypt = @build_crypt@
build-nscd = @build_nscd@
use-nscd = @use_nscd@

18
configure vendored
View File

@ -673,7 +673,6 @@ base_machine
have_tunables
build_pt_chown
build_nscd
link_obsolete_rpc
libc_cv_static_nss_crypt
libc_cv_nss_crypt
build_crypt
@ -784,7 +783,6 @@ enable_multi_arch
enable_experimental_malloc
enable_crypt
enable_nss_crypt
enable_obsolete_rpc
enable_systemtap
enable_build_nscd
enable_nscd
@ -1455,8 +1453,6 @@ Optional Features:
--disable-crypt do not build nor install the passphrase hashing
library, libcrypt
--enable-nss-crypt enable libcrypt to use nss
--enable-obsolete-rpc build and install the obsolete RPC code for
link-time usage
--enable-systemtap enable systemtap static probe points [default=no]
--disable-build-nscd disable building and installing the nscd daemon
--disable-nscd library functions will not contact the nscd daemon
@ -3636,20 +3632,6 @@ fi
# Check whether --enable-obsolete-rpc was given.
if test "${enable_obsolete_rpc+set}" = set; then :
enableval=$enable_obsolete_rpc; link_obsolete_rpc=$enableval
else
link_obsolete_rpc=no
fi
if test "$link_obsolete_rpc" = yes; then
$as_echo "#define LINK_OBSOLETE_RPC 1" >>confdefs.h
fi
# Check whether --enable-systemtap was given.
if test "${enable_systemtap+set}" = set; then :
enableval=$enable_systemtap; systemtap=$enableval

11
configure.ac
View File

@ -376,17 +376,6 @@ AC_SUBST(libc_cv_nss_crypt)
AC_SUBST(libc_cv_static_nss_crypt)
AC_ARG_ENABLE([obsolete-rpc],
AC_HELP_STRING([--enable-obsolete-rpc],
[build and install the obsolete RPC code for link-time usage]),
[link_obsolete_rpc=$enableval],
[link_obsolete_rpc=no])
AC_SUBST(link_obsolete_rpc)
if test "$link_obsolete_rpc" = yes; then
AC_DEFINE(LINK_OBSOLETE_RPC)
fi
AC_ARG_ENABLE([systemtap],
[AS_HELP_STRING([--enable-systemtap],
[enable systemtap static probe points @<:@default=no@:>@])],

7
include/libc-symbols.h
View File

@ -625,12 +625,7 @@ for linking")
# define libc_hidden_tls_proto(name, attrs...) hidden_tls_proto (name, ##attrs)
# define libc_hidden_def(name) hidden_def (name)
# define libc_hidden_weak(name) hidden_weak (name)
# ifdef LINK_OBSOLETE_RPC
/* libc_hidden_nolink_sunrpc should only get used in sunrpc code. */
# define libc_hidden_nolink_sunrpc(name, version) hidden_def (name)
# else
# define libc_hidden_nolink_sunrpc(name, version) hidden_nolink (name, libc, version)
# endif
# define libc_hidden_nolink_sunrpc(name, version) hidden_nolink (name, libc, version)
# define libc_hidden_ver(local, name) hidden_ver (local, name)
# define libc_hidden_data_def(name) hidden_data_def (name)
# define libc_hidden_tls_def(name) hidden_tls_def (name)

8
include/shlib-compat.h
View File

@ -127,15 +127,9 @@
#define compat_symbol_reference_2(local, symbol, name) \
symbol_version_reference (local, symbol, name)
# ifdef LINK_OBSOLETE_RPC
/* Export the symbol for both static and dynamic linking. */
# define libc_sunrpc_symbol(name, aliasname, version) \
strong_alias (name, aliasname)
# else
/* Export the symbol only for shared-library compatibility. */
# define libc_sunrpc_symbol(name, aliasname, version) \
#define libc_sunrpc_symbol(name, aliasname, version) \
compat_symbol (libc, name, aliasname, version);
# endif
/* The TEST_COMPAT macro acts just like the SHLIB_COMPAT macro except
that it does not check IS_IN. It is used by tests that are testing

5
malloc/thread-freeres.c
View File

@ -22,6 +22,7 @@
#include <rpc/rpc.h>
#include <string.h>
#include <tls-internal.h>
#include <shlib-compat.h>
/* Thread shutdown function. Note that this function must be called
for threads during shutdown for correctness reasons. Unlike
@ -30,7 +31,9 @@
void
__libc_thread_freeres (void)
{
call_function_static_weak (__rpc_thread_destroy);
#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_32)
__rpc_thread_destroy ();
#endif
call_function_static_weak (__res_thread_freeres);
__glibc_tls_internal_free ();

4
manual/nss.texi
View File

@ -335,9 +335,7 @@ with a @code{+} character was found NIS was used. This kind of lookup
was removed and now the default value for the services is @code{files}.
libnss_compat no longer depends on libnsl and can be used without NIS.
For all other databases the default value is @code{files} unless
@theglibc{} was configured with @code{--enable-obsolete-rpc} option, in
which case it the default value is @code{nis [NOTFOUND=return] files}.
For all other databases the default value is @code{files}.
@cindex optimizing NSS
A second point is that the user should try to optimize the lookup

6
scripts/build-many-glibcs.py
View File

@ -404,8 +404,6 @@ class Context(object):
{'arch': 'i686', 'ccopts': '-m32 -march=i686'}],
extra_glibcs=[{'variant': 'disable-multi-arch',
'cfg': ['--disable-multi-arch']},
{'variant': 'enable-obsolete',
'cfg': ['--enable-obsolete-rpc']},
{'variant': 'static-pie',
'cfg': ['--enable-static-pie']},
{'variant': 'x32-static-pie',
@ -419,10 +417,6 @@ class Context(object):
'arch': 'i686',
'ccopts': '-m32 -march=i686',
'cfg': ['--disable-multi-arch']},
{'variant': 'enable-obsolete',
'arch': 'i686',
'ccopts': '-m32 -march=i686',
'cfg': ['--enable-obsolete-rpc']},
{'arch': 'i486',
'ccopts': '-m32 -march=i486'},
{'arch': 'i586',

152
sunrpc/Makefile
View File

@ -22,11 +22,13 @@ subdir := sunrpc
include ../Makeconfig
ifdef have-GLIBC_2.31
# The code in this subdirectory is taken from Sun's RPCSRC-4.0
# distribution with some additional changes from the TI-RPC package
# which is also available from Sun. The files are heavily changed to
# compile cleanly and to fit in the GNU environment. All the code
# from Sun's rpc, etc, and rpcgen subdirectories is in this directory;
# from Sun's rpc and etc subdirectories is in this directory;
# the rpc subdirectory contains only the header files. Other than
# that, several files were renamed so as not to exceed 14-character
# file name limits:
@ -44,23 +46,6 @@ include ../Makeconfig
# svc_auth_unix.c -> svc_authux.c
# xdr_reference.c -> xdr_ref.c
rpcsvc = bootparam_prot.x nlm_prot.x rstat.x \
yppasswd.x klm_prot.x rex.x sm_inter.x mount.x \
rusers.x spray.x nfs_prot.x rquota.x key_prot.x
headers-sunrpc = $(addprefix rpc/,auth.h auth_unix.h clnt.h pmap_clnt.h \
pmap_prot.h pmap_rmt.h rpc.h rpc_msg.h \
svc.h svc_auth.h types.h xdr.h auth_des.h \
key_prot.h) \
$(rpcsvc:%=rpcsvc/%) rpcsvc/bootparam.h
headers = rpc/netdb.h
generated += $(rpcsvc:%.x=rpcsvc/%.h) $(rpcsvc:%.x=x%.c) $(rpcsvc:%.x=x%.stmp) \
$(rpcsvc:%.x=rpcsvc/%.stmp) rpcgen
generated-dirs += rpcsvc
ifeq ($(link-obsolete-rpc),yes)
headers += $(headers-sunrpc)
endif
ifeq ($(build-shared),yes)
need-export-routines := auth_des auth_unix clnt_gen clnt_perr clnt_tcp \
clnt_udp get_myaddr key_call netname pm_getport \
@ -75,20 +60,9 @@ routines := auth_none authuxprot clnt_raw clnt_simp \
des_crypt des_impl des_soft key_prot openchild rtime svcauth_des \
clnt_unix svc_unix create_xid $(need-export-routines) \
rpc_gethostbyname
ifneq ($(link-obsolete-rpc),yes)
# We only add the RPC for compatibility to libc.so.
shared-only-routines = $(routines)
endif
endif
ifeq ($(link-obsolete-rpc),yes)
install-bin := rpcgen
rpcgen-objs = rpc_main.o rpc_hout.o rpc_cout.o rpc_parse.o \
rpc_scan.o rpc_util.o rpc_svcout.o rpc_clntout.o \
rpc_tblout.o rpc_sample.o
extra-objs = $(rpcgen-objs) $(addprefix cross-,$(rpcgen-objs))
others += rpcgen
endif
tests = tst-xdrmem tst-xdrmem2 test-rpcent tst-udp-error tst-udp-timeout \
tst-udp-nonblocking
@ -100,22 +74,6 @@ tests += tst-udp-garbage
tests-internal += tst-svc_register
endif
ifeq ($(run-built-tests),yes)
ifeq ($(link-obsolete-rpc),yes)
rpcgen-tests := $(objpfx)bug20790.out
tests-special += $(rpcgen-tests)
endif
endif
ifeq ($(link-obsolete-rpc),yes)
headers += $(rpcsvc:%.x=rpcsvc/%.h)
extra-libs := librpcsvc
extra-libs-others := librpcsvc # Make it in `others' pass, not `lib' pass.
librpcsvc-routines = $(rpcsvc:%.x=x%)
librpcsvc-inhibit-o = .os # Build no shared rpcsvc library.
omit-deps = $(librpcsvc-routines)
endif
ifeq (yes,$(build-shared))
rpc-compat-routines = $(addprefix compat-,$(need-export-routines))
rpc-compat-routines.os = $(addprefix $(objpfx), \
@ -133,19 +91,6 @@ $(rpc-compat-routines.os): $(objpfx)compat-%.os: %.c $(before-compile)
$(compile-command.c) -DEXPORT_RPC_SYMBOLS
endif
CFLAGS-xbootparam_prot.c += -Wno-unused $(PIC-ccflag)
CFLAGS-xnlm_prot.c += -Wno-unused $(PIC-ccflag)
CFLAGS-xrstat.c += -Wno-unused $(PIC-ccflag)
CFLAGS-xyppasswd.c += -Wno-unused $(PIC-ccflag)
CFLAGS-xklm_prot.c += -Wno-unused $(PIC-ccflag)
CFLAGS-xrex.c += -Wno-unused $(PIC-ccflag)
CFLAGS-xsm_inter.c += -Wno-unused $(PIC-ccflag)
CFLAGS-xmount.c += -Wno-unused $(PIC-ccflag)
CFLAGS-xrusers.c += -Wno-unused $(PIC-ccflag)
CFLAGS-xspray.c += -Wno-unused $(PIC-ccflag)
CFLAGS-xnfs_prot.c += -Wno-unused $(PIC-ccflag)
CFLAGS-xrquota.c += -Wno-unused $(PIC-ccflag)
CFLAGS-xkey_prot.c += -Wno-unused $(PIC-ccflag)
CFLAGS-auth_unix.c += -fexceptions
CFLAGS-key_call.c += -fexceptions
CFLAGS-pmap_rmt.c += -fexceptions
@ -159,83 +104,26 @@ $(objpfx)tst-udp-error: $(common-objpfx)linkobj/libc.so
$(objpfx)tst-svc_register: \
$(common-objpfx)linkobj/libc.so $(shared-thread-library)
$(objpfx)rpcgen: $(addprefix $(objpfx),$(rpcgen-objs))
cross-rpcgen-objs := $(addprefix $(objpfx)cross-,$(rpcgen-objs))
# When generic makefile support for build system programs is
# available, it should replace this code. See
# <https://sourceware.org/bugzilla/show_bug.cgi?id=14087>.
$(cross-rpcgen-objs): $(objpfx)cross-%.o: %.c $(before-compile)
$(BUILD_CC) $($(basename $(<F))-CFLAGS) $(ALL_BUILD_CFLAGS) $< \
$(OUTPUT_OPTION) $(native-compile-mkdep-flags) -c
$(objpfx)cross-rpcgen: $(cross-rpcgen-objs)
$(BUILD_CC) $^ $(BUILD_LDFLAGS) -o $@
# This makes sure -DIN_MODULE is passed for all these modules.
cpp-srcs-left := $(rpcgen-objs:.o=.c)
lib := nonlib
include $(patsubst %,$(..)libof-iterator.mk,$(cpp-srcs-left))
# How we run rpcgen to generate sources and headers in the rules below.
# Setting CPP tells it how to run the C preprocessor correctly. Note
# that $(built-program-file) requires that the just-built cross-rpcgen
# binary be the second dependency listed in each rule using rpcgen-cmd.
rpcgen-cmd = CPP='$(CC) -E -x c-header' $(built-program-file) -Y ../scripts
# Generate the rpcsvc headers with rpcgen.
# We use a stamp file to avoid unnessary recompilation each time rpcgen is
# relinked.
$(rpcsvc:%.x=$(objpfx)rpcsvc/%.h): $(objpfx)rpcsvc/%.h: $(objpfx)rpcsvc/%.stmp
@:
$(objpfx)rpcsvc/%.stmp: rpcsvc/%.x $(objpfx)cross-rpcgen
$(make-target-directory)
-@rm -f ${@:stmp=T} $@
$(rpcgen-cmd) -h $< -o ${@:stmp=T}
$(move-if-change) $(@:stmp=T) $(@:stmp=h)
touch $@
# Generate the rpcsvc XDR functions with rpcgen.
$(rpcsvc:%.x=$(objpfx)x%.c): $(objpfx)x%.c: $(objpfx)x%.stmp
@:
$(objpfx)x%.stmp: rpcsvc/%.x $(objpfx)cross-rpcgen
-@rm -f ${@:stmp=T} $@
$(rpcgen-cmd) -c $< -o ${@:stmp=T}
$(move-if-change) $(@:stmp=T) $(@:stmp=c)
touch $@
# The generated source files depend on the corresponding generated headers.
# Gratuitous dependency on generated .c file here just gets it mentioned to
# avoid being an intermediate file and getting removed.
define o-iterator-doit
$(rpcsvc:%.x=$(objpfx)x%$o): $(objpfx)x%$o: $(objpfx)x%.c $(objpfx)rpcsvc/%.h
endef
object-suffixes-left = $(filter-out $(librpcsvc-inhibit-o),$(object-suffixes))
include $(o-iterator)
rpcsvc-dt-files := $(foreach o,$(filter-out $(librpcsvc-inhibit-o),\
$(object-suffixes)),\
$(rpcsvc:%.x=$(objpfx)x%$o.dt))
rpcsvc-depfiles := $(patsubst %.dt,%.d,$(wildcard $(rpcsvc-dt-files))) \
$(wildcard $(rpcsvc-dt-files:.dt=.d))
ifdef rpcsvc-depfiles
ifneq ($(no_deps),t)
-include $(rpcsvc-depfiles)
endif
endif
$(objpfx)thrsvc: $(common-objpfx)linkobj/libc.so $(shared-thread-library)
ifeq ($(run-built-tests),yes)
$(rpcgen-tests): $(objpfx)%.out: %.x $(objpfx)rpcgen
-rm -f $@
$(built-program-cmd) -c $< -o $@; \
$(evaluate-test)
endif
$(objpfx)tst-udp-timeout: $(common-objpfx)linkobj/libc.so
$(objpfx)tst-udp-nonblocking: $(common-objpfx)linkobj/libc.so
$(objpfx)tst-udp-garbage: \
$(common-objpfx)linkobj/libc.so $(shared-thread-library)
else # !have-GLIBC_2.31
routines = $(routines-for-nss)
include ../Rules
ifeq (yes,$(build-shared))
# Create an empty archive, so that Makerules can reference it.
subdir_lib: $(objpfx)librpc_compat_pic.a
$(objpfx)librpc_compat_pic.a: Makefile
$(make-target-directory)
$(AR) cr $@
endif
endif # !have-GLIBC_2.31

1
sunrpc/bug20790.x
View File

@ -1 +0,0 @@
program TPROG { version TVERS { int FUNC(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) = 1; } = 1; } = 1;

65
sunrpc/proto.h
View File

@ -1,65 +0,0 @@
/****** rpc_clntout.c ******/
void write_stubs(void);
void printarglist(proc_list *proc, const char *result,
const char *addargname, const char *addargtype);
/****** rpc_cout.c ******/
void emit (definition *def);
/****** rpc_hout.c ******/
void print_datadef(definition *def);
void print_funcdef(definition *def);
void pxdrfuncdecl(const char *name, int pointerp);
void pprocdef(proc_list *proc, version_list *vp,
const char *addargtype, int server_p, int mode);
void pdeclaration(const char *name, declaration *dec, int tab,
const char *separator);
void print_xdr_func_def (char* name, int pointerp, int i);
/****** rpc_main.c ******/
/* nil */
/****** rpc_parse.c ******/
definition *get_definition(void);
/****** rpc_sample.c ******/
void write_sample_svc(definition *def);
int write_sample_clnt(definition *def);
void add_sample_msg(void);
void write_sample_clnt_main(void);
/****** rpc_scan.c ******/
/* see rpc_scan.h */
/****** rpc_svcout.c ******/
int nullproc(const proc_list *proc);
void write_svc_aux(int nomain);
void write_msg_out(void);
/****** rpc_tblout.c ******/
void write_tables(void);
/****** rpc_util.c ******/
void reinitialize(void);
int streq(const char *a, const char *b);
void error(const char *msg) __attribute__ ((noreturn));
void crash(void) __attribute__ ((noreturn));
void tabify(FILE *f, int tab);
char *make_argname(const char *pname, const char *vname);
void add_type(int len, const char *type);
/* This header is the last one included in all rpc_*.c files,
so we define stuff for cross-rpcgen here to avoid conflicts with
$build's C library and $host's glibc. */
#ifdef IS_IN_build
/* Disable translated messages when built for $build and used in
building glibc. */
#define _(X) (X)
#define textdomain(X) ((void) 0)
#endif

333
sunrpc/rpc_clntout.c
View File

@ -1,333 +0,0 @@
/*
* rpc_clntout.c, Client-stub outputter for the RPC protocol compiler
* Copyright (c) 2010, Oracle America, Inc.
*
* 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 the "Oracle America, 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.
*/
#include <stdio.h>
#include <string.h>
#include "rpc/types.h"
#include "rpc_parse.h"
#include "rpc_util.h"
#include "proto.h"
#define DEFAULT_TIMEOUT 25 /* in seconds */
static const char RESULT[] = "clnt_res";
static void write_program (definition * def);
static void printbody (proc_list * proc);
static const char *ampr (const char *type);
static void printbody (proc_list * proc);
void
write_stubs (void)
{
list *l;
definition *def;
fprintf (fout,
"\n/* Default timeout can be changed using clnt_control() */\n");
fprintf (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)
{
fprintf (fout, "\n");
if (mtflag == 0)
{
ptype (proc->res_prefix, proc->res_type, 1);
fprintf (fout, "*\n");
pvname (proc->proc_name, vp->vers_num);
printarglist (proc, RESULT, "clnt", "CLIENT *");
}
else
{
fprintf (fout, "enum clnt_stat \n");
pvname (proc->proc_name, vp->vers_num);
printarglist (proc, RESULT, "clnt", "CLIENT *");
}
fprintf (fout, "{\n");
printbody (proc);
fprintf (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, const char *result,
const char *addargname, const char *addargtype)
{
decl_list *l;
if (!newstyle)
{ /* old style: always pass argument by reference */
if (Cflag)
{ /* C++ style heading */
fprintf (fout, "(");
ptype (proc->args.decls->decl.prefix,
proc->args.decls->decl.type, 1);
if (mtflag)
{/* Generate result field */
fprintf (fout, "*argp, ");
ptype(proc->res_prefix, proc->res_type, 1);
fprintf (fout, "*%s, %s%s)\n", result, addargtype, addargname);
}
else
fprintf (fout, "*argp, %s%s)\n", addargtype, addargname);
}
else
{
if (!mtflag)
fprintf (fout, "(argp, %s)\n", addargname);
else
fprintf (fout, "(argp, %s, %s)\n", result, addargname);
fprintf (fout, "\t");
ptype (proc->args.decls->decl.prefix,
proc->args.decls->decl.type, 1);
fprintf (fout, "*argp;\n");
if (mtflag)
{
fprintf (fout, "\t");
ptype (proc->res_prefix, proc->res_type, 1);
fprintf (fout, "*%s;\n", result);
}
}
}
else if (streq (proc->args.decls->decl.type, "void"))
{
/* newstyle, 0 argument */
if (mtflag)
{
fprintf (fout, "(");
if (Cflag)
{
ptype(proc->res_prefix, proc->res_type, 1);
fprintf (fout, "*%s, %s%s)\n", result, addargtype, addargname);
}
else
fprintf (fout, "(%s)\n", addargname);
}
else if (Cflag)
fprintf (fout, "(%s%s)\n", addargtype, addargname);
else
fprintf (fout, "(%s)\n", addargname);
}
else
{
/* new style, 1 or multiple arguments */
if (!Cflag)
{
fprintf (fout, "(");
for (l = proc->args.decls; l != NULL; l = l->next)
fprintf (fout, "%s, ", l->decl.name);
if (mtflag)
fprintf (fout, "%s, ", result);
fprintf (fout, "%s)\n", addargname);
for (l = proc->args.decls; l != NULL; l = l->next)
{
pdeclaration (proc->args.argname, &l->decl, 1, ";\n");
}
if (mtflag)
{
fprintf (fout, "\t");
ptype (proc->res_prefix, proc->res_type, 1);
fprintf (fout, "*%s;\n", result);
}
}
else
{ /* C++ style header */
fprintf (fout, "(");
for (l = proc->args.decls; l != NULL; l = l->next)
{
pdeclaration (proc->args.argname, &l->decl, 0, ", ");
}
if (mtflag)
{
ptype (proc->res_prefix, proc->res_type, 1);
fprintf (fout, "*%s, ", result);
}
fprintf (fout, " %s%s)\n", addargtype, addargname);
}
}
if (!Cflag)
fprintf (fout, "\t%s%s;\n", addargtype, addargname);
}
static
const char *
ampr (const 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);
/* int i; */
/* For new style with multiple arguments, need a structure in which
to stuff the arguments. */
if (newstyle && args2)
{
fprintf (fout, "\t%s", proc->args.argname);
fprintf (fout, " arg;\n");
}
if (!mtflag)
{
fprintf (fout, "\tstatic ");
if (streq (proc->res_type, "void"))
{
fprintf (fout, "char ");
}
else
{
ptype (proc->res_prefix, proc->res_type, 0);
}
fprintf (fout, "%s;\n", RESULT);
fprintf (fout, "\n");
fprintf (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 */
if (mtflag)
fprintf (fout, "\t return ");
else
fprintf (fout, "\t if ");
fprintf (fout,
"(clnt_call (clnt, %s, (xdrproc_t) xdr_void, ", proc->proc_name);
fprintf (fout,
"(caddr_t) NULL,\n\t\t(xdrproc_t) xdr_%s, (caddr_t) %s%s,",
stringfix(proc->res_type), (mtflag)?"":ampr(proc->res_type),
RESULT);
if (mtflag)
fprintf (fout, "\n\t\tTIMEOUT));\n\n");
else
fprintf (fout, "\n\t\tTIMEOUT) != RPC_SUCCESS) {\n");
}
else if (newstyle && args2)
{
/* newstyle, multiple arguments: stuff arguments into structure */
for (l = proc->args.decls; l != NULL; l = l->next)
{
fprintf (fout, "\targ.%s = %s;\n",
l->decl.name, l->decl.name);
}
if (mtflag)
fprintf (fout, "\treturn ");
else
fprintf (fout, "\tif ");
fprintf (fout,
"(clnt_call (clnt, %s, (xdrproc_t) xdr_%s", proc->proc_name,
proc->args.argname);
fprintf (fout,
", (caddr_t) &arg,\n\t\t(xdrproc_t) xdr_%s, (caddr_t) %s%s,",
stringfix(proc->res_type), (mtflag)?"":ampr(proc->res_type),
RESULT);
if (mtflag)
fprintf (fout, "\n\t\tTIMEOUT));\n");
else
fprintf (fout, "\n\t\tTIMEOUT) != RPC_SUCCESS) {\n");
}
else
{ /* single argument, new or old style */
if (!mtflag)
fprintf (fout,
"\tif (clnt_call (clnt, %s,\n\t\t(xdrproc_t) xdr_%s, (caddr_t) %s%s,\n\t\t(xdrproc_t) xdr_%s, (caddr_t) %s%s,\n\t\tTIMEOUT) != 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);
else
fprintf(fout,
"\treturn (clnt_call(clnt, %s,\n\t\t(xdrproc_t) xdr_%s, (caddr_t) %s%s,\n\t\t(xdrproc_t) xdr_%s, (caddr_t) %s%s,\n\t\tTIMEOUT));\n",
proc->proc_name,
stringfix (proc->args.decls->decl.type),
(newstyle ? "&" : ""),
(newstyle ? proc->args.decls->decl.name : "argp"),
stringfix (proc->res_type), "",
RESULT);
}
if (!mtflag)
{
fprintf (fout, "\t\treturn (NULL);\n");
fprintf (fout, "\t}\n");
if (streq (proc->res_type, "void"))
{
fprintf (fout, "\treturn ((void *)%s%s);\n",
ampr (proc->res_type), RESULT);
}
else
{
fprintf (fout, "\treturn (%s%s);\n", ampr (proc->res_type), RESULT);
}
}
}

811
sunrpc/rpc_cout.c
View File

@ -1,811 +0,0 @@
/*
* From: @(#)rpc_cout.c 1.13 89/02/22
*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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_cout.c, XDR routine outputter for the RPC protocol compiler
*/
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include "rpc_parse.h"
#include "rpc_util.h"
#include "proto.h"
static void emit_enum (definition * def);
static void emit_program (const definition * def);
static void emit_union (const definition * def);
static void emit_struct (definition * def);
static void emit_typedef (const definition * def);
static void emit_inline (int indent, declaration * decl, int flag);
static void emit_single_in_line (int indent, declaration *decl, int flag,
relation rel);
static int findtype (const definition * def, const char *type);
static int undefined (const char *type);
static void print_generic_header (const char *procname, int pointerp);
static void print_ifopen (int indent, const char *name);
static void print_ifarg (const char *arg);
static void print_ifsizeof (int indent, const char *prefix, const char *type);
static void print_ifclose (int indent);
static void print_ifstat (int indent, const char *prefix, const char *type,
relation rel, const char *amax,
const char *objname, const char *name);
static void print_stat (int indent, const declaration * dec);
static void print_header (const definition * def);
static void print_trailer (void);
static char *upcase (const 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 don't 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:
/* can't happen */
break;
}
print_trailer ();
}
static int
findtype (const definition * def, const 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 (const char *type)
{
definition *def;
def = (definition *) FINDVAL (defined, type, findtype);
return (def == NULL);
}
static void
print_generic_header (const 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");
}
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");
}
}
static void
print_header (const 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 (inlineflag == 0)
return;
/*May cause lint to complain. but ... */
f_print (fout, "\tregister int32_t *buf;\n\n");
}
static void
print_prog_header (const 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, const char *name)
{
tabify (fout, indent);
f_print (fout, " if (!xdr_%s (xdrs", name);
}
static void
print_ifarg (const char *arg)
{
f_print (fout, ", %s", arg);
}
static void
print_ifsizeof (int indent, const char *prefix, const char *type)
{
if (indent)
{
fprintf (fout, ",\n");
tabify (fout, indent);
}
else
fprintf (fout, ", ");
if (streq (type, "bool"))
fprintf (fout, "sizeof (bool_t), (xdrproc_t) xdr_bool");
else
{
fprintf (fout, "sizeof (");
if (undefined (type) && prefix)
{
f_print (fout, "%s ", prefix);
}
fprintf (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");
}
static void
print_ifstat (int indent, const char *prefix, const char *type, relation rel,
const char *amax, const char *objname, const char *name)
{
const char *alt = NULL;
switch (rel)
{
case REL_POINTER:
print_ifopen (indent, "pointer");
print_ifarg ("(char **)");
f_print (fout, "%s", objname);
print_ifsizeof (0, 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 (indent + 1, 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");
}
print_ifarg ("(char **)");
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 (indent + 1, prefix, type);
}
break;
case REL_ALIAS:
print_ifopen (indent, type);
print_ifarg (objname);
break;
}
print_ifclose (indent);
}
static void
emit_enum (definition * def)
{
(void) def;
print_ifopen (1, "enum");
print_ifarg ("(enum_t *) objp");
print_ifclose (1);
}
static void
emit_program (const 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 (const definition * def)
{
declaration *dflt;
case_list *cl;
declaration *cs;
char *object;
const char *vecformat = "objp->%s_u.%s";
const 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
{
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
inline_struct (definition *def, int flag)
{
decl_list *dl;
int i, size;
decl_list *cur = NULL;
decl_list *psav;
bas_type *ptr;
char *sizestr;
const char *plus;
char ptemp[256];
int indent = 1;
if (flag == PUT)
f_print (fout, "\n\tif (xdrs->x_op == XDR_ENCODE) {\n");
else
f_print (fout,
"\t\treturn TRUE;\n\t} else if (xdrs->x_op == XDR_DECODE) {\n");
i = 0;
size = 0;
sizestr = NULL;
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 < inlineflag)
{
/* don't expand into inline code if size < inlineflag */
while (cur != dl)
{
print_stat (indent + 1, &cur->decl);
cur = cur->next;
}
}
else
{
/* were already looking at a xdr_inlineable structure */
tabify (fout, indent + 1);
if (sizestr == NULL)
f_print (fout, "buf = XDR_INLINE (xdrs, %d * BYTES_PER_XDR_UNIT);", size);
else if (size == 0)
f_print (fout,
"buf = XDR_INLINE (xdrs, (%s) * BYTES_PER_XDR_UNIT);",
sizestr);
else
f_print (fout,
"buf = XDR_INLINE (xdrs, (%d + (%s)) * BYTES_PER_XDR_UNIT);",
size, sizestr);
f_print (fout, "\n");
tabify (fout, indent + 1);
fprintf (fout, "if (buf == NULL) {\n");
psav = cur;
while (cur != dl)
{
print_stat (indent + 2, &cur->decl);
cur = cur->next;
}
f_print (fout, "\n\t\t} else {\n");
cur = psav;
while (cur != dl)
{
emit_inline (indent + 1, &cur->decl, flag);
cur = cur->next;
}
tabify (fout, indent + 1);
f_print (fout, "}\n");
}
}
size = 0;
i = 0;
free (sizestr);
sizestr = NULL;
print_stat (indent + 1, &dl->decl);
}
}
if (i > 0)
{
if (sizestr == NULL && size < inlineflag)
{
/* don't expand into inline code if size < inlineflag */
while (cur != dl)
{
print_stat (indent + 1, &cur->decl);
cur = cur->next;
}
}
else
{
/* were already looking at a xdr_inlineable structure */
if (sizestr == NULL)
f_print (fout,
"\t\tbuf = XDR_INLINE (xdrs, %d * BYTES_PER_XDR_UNIT);",
size);
else if (size == 0)
f_print (fout,
"\t\tbuf = XDR_INLINE (xdrs, (%s) * BYTES_PER_XDR_UNIT);",
sizestr);
else
f_print (fout,
"\t\tbuf = XDR_INLINE (xdrs, (%d + %s)* BYTES_PER_XDR_UNIT);",
size, sizestr);
f_print (fout, "\n\t\tif (buf == NULL) {\n");
psav = cur;
while (cur != NULL)
{
print_stat (indent + 2, &cur->decl);
cur = cur->next;
}
f_print (fout, "\t\t} else {\n");
cur = psav;
while (cur != dl)
{
emit_inline (indent + 2, &cur->decl, flag);
cur = cur->next;
}
f_print (fout, "\t\t}\n");
}
}
}
/* this may be const. i haven't traced this one through yet. */
static void
emit_struct (definition * def)
{
decl_list *dl;
int j, size, flag;
bas_type *ptr;
int can_inline;
if (inlineflag == 0)
{
/* No xdr_inlining at all */
for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
print_stat (1, &dl->decl);
return;
}
for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
if (dl->decl.rel == REL_VECTOR)
{
f_print (fout, "\tint i;\n");
break;
}
size = 0;
can_inline = 0;
/*
* Make a first pass and see if inling is possible.
*/
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 >= inlineflag)
{
can_inline = 1;
break; /* can be inlined */
}
size = 0;
}
if (size > inlineflag)
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++)
{
inline_struct (def, flag);
if (flag == PUT)
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 (const definition * def)
{
const char *prefix = def->def.ty.old_prefix;
const char *type = def->def.ty.old_type;
const 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, const declaration * dec)
{
const char *prefix = dec->prefix;
const char *type = dec->type;
const 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 (int indent, declaration * decl, int flag)
{
switch (decl->rel)
{
case REL_ALIAS:
emit_single_in_line (indent, decl, flag, REL_ALIAS);
break;
case REL_VECTOR:
tabify (fout, indent);
f_print (fout, "{\n");
tabify (fout, indent + 1);
f_print (fout, "register %s *genp;\n\n", decl->type);
tabify (fout, indent + 1);
f_print (fout,
"for (i = 0, genp = objp->%s;\n", decl->name);
tabify (fout, indent + 2);
f_print (fout, "i < %s; ++i) {\n", decl->array_max);
emit_single_in_line (indent + 2, decl, flag, REL_VECTOR);
tabify (fout, indent + 1);
f_print (fout, "}\n");
tabify (fout, indent);
f_print (fout, "}\n");
break;
default:
break;
/* ?... do nothing I guess */
}
}
static void
emit_single_in_line (int indent, declaration *decl, int flag, relation rel)
{
char *upp_case;
int freed = 0;
tabify (fout, indent);
if (flag == PUT)
f_print (fout, "IXDR_PUT_");
else
{
if (rel == REL_ALIAS)
f_print (fout, "objp->%s = IXDR_GET_", decl->name);
else
f_print (fout, "*genp++ = IXDR_GET_");
}
upp_case = upcase (decl->type);
/* hack - XX */
if (!strcmp (upp_case, "INT"))
{
free (upp_case);
freed = 1;
/* Casting is safe since the `freed' flag is set. */
upp_case = (char *) "LONG";
}
if (!strcmp (upp_case, "U_INT"))
{
free (upp_case);
freed = 1;
/* Casting is safe since the `freed' flag is set. */
upp_case = (char *) "U_LONG";
}
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 (const char *str)
{
char *ptr, *hptr;
ptr = malloc (strlen (str) + 1);
if (ptr == NULL)
{
f_print (stderr, "malloc failed\n");
exit (1);
}
hptr = ptr;
while (*str != '\0')
*ptr++ = toupper (*str++);
*ptr = '\0';
return hptr;
}

607
sunrpc/rpc_hout.c
View File

@ -1,607 +0,0 @@
/*
* From: @(#)rpc_hout.c 1.12 89/02/22
*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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_hout.c, Header file outputter for the RPC protocol compiler
*/
#include <stdio.h>
#include <ctype.h>
#include "rpc_parse.h"
#include "rpc_util.h"
#include "proto.h"
static void pconstdef (definition * def);
static void pargdef (definition * def);
static void pstructdef (definition * def);
static void puniondef (definition * def);
static void pdefine (const char *name, const char *num);
static int define_printed (proc_list * stop, version_list * start);
static void pprogramdef (definition * def);
static void parglist (proc_list * proc, const char *addargtype);
static void penumdef (definition * def);
static void ptypedef (definition * def);
static int undefined2 (const char *type, const char *stop);
/* store away enough information to allow the XDR functions to be spat
out at the end of the file */
static void
storexdrfuncdecl (const char *name, int pointerp)
{
xdrfunc * xdrptr;
xdrptr = (xdrfunc *) malloc(sizeof (struct xdrfunc));
xdrptr->name = (char *)name;
xdrptr->pointerp = pointerp;
xdrptr->next = NULL;
if (xdrfunc_tail == NULL)
{
xdrfunc_head = xdrptr;
xdrfunc_tail = xdrptr;
}
else
{
xdrfunc_tail->next = xdrptr;
xdrfunc_tail = xdrptr;
}
}
/*
* 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)
{
storexdrfuncdecl(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;
/* ?... shouldn't happen I guess */
}
}
void
print_xdr_func_def (char *name, int pointerp, int i)
{
if (i == 2)
{
f_print (fout, "extern bool_t xdr_%s ();\n", name);
return;
}
else
f_print(fout, "extern bool_t xdr_%s (XDR *, %s%s);\n", name,
name, pointerp ? "*" : "");
}
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;
const 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);
storexdrfuncdecl (name, 1);
f_print (fout, "\n");
}
}
}
static void
pstructdef (definition *def)
{
decl_list *l;
const 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;
const 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 (const char *name, const char *num)
{
f_print (fout, "#define %s %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
pfreeprocdef (const char *name, const char *vers, int mode)
{
f_print (fout, "extern int ");
pvname (name, vers);
if (mode == 1)
f_print (fout,"_freeresult (SVCXPRT *, xdrproc_t, caddr_t);\n");
else
f_print (fout,"_freeresult ();\n");
}
static void
pprogramdef (definition *def)
{
version_list *vers;
proc_list *proc;
int i;
const char *ext;
pargdef (def);
pdefine (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);
}
pdefine (vers->vers_name, vers->vers_num);
/*
* Print out 2 definitions, one for ANSI-C, another for
* old K & R C
*/
if(!Cflag)
{
ext = "extern ";
for (proc = vers->procs; proc != NULL;
proc = proc->next)
{
if (!define_printed(proc, def->def.pr.versions))
{
pdefine (proc->proc_name, proc->proc_num);
}
f_print (fout, "%s", ext);
pprocdef (proc, vers, NULL, 0, 2);
if (mtflag)
{
f_print(fout, "%s", ext);
pprocdef (proc, vers, NULL, 1, 2);
}
}
pfreeprocdef (def->def_name, vers->vers_num, 2);
}
else
{
for (i = 1; i < 3; i++)
{
if (i == 1)
{
f_print (fout, "\n#if defined(__STDC__) || defined(__cplusplus)\n");
ext = "extern ";
}
else
{
f_print (fout, "\n#else /* K&R C */\n");
ext = "extern ";
}
for (proc = vers->procs; proc != NULL; proc = proc->next)
{
if (!define_printed(proc, def->def.pr.versions))
{
pdefine(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);
}
pfreeprocdef (def->def_name, vers->vers_num, i);
}
f_print (fout, "#endif /* K&R C */\n");
}
}
}
void
pprocdef (proc_list * proc, version_list * vp,
const char *addargtype, int server_p, int mode)
{
if (mtflag)
{/* Print MT style stubs */
if (server_p)
f_print (fout, "bool_t ");
else
f_print (fout, "enum clnt_stat ");
}
else
{
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 1 = ANSI-C, mode 2 = K&R C
*/
if (mode == 1)
parglist (proc, addargtype);
else
f_print (fout, "();\n");
}
/* print out argument list of procedure */
static void
parglist (proc_list *proc, const 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, ", ");
}
}
if (mtflag)
{
ptype(proc->res_prefix, proc->res_type, 1);
f_print(fout, "*, ");
}
f_print (fout, "%s);\n", addargtype);
}
static void
penumdef (definition *def)
{
const char *name = def->def_name;
enumval_list *l;
const 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)
{
const char *name = def->def_name;
const 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 (const char *name, declaration * dec, int tab,
const char *separator)
{
char buf[8]; /* enough to hold "struct ", include NUL */
const char *prefix;
const 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, "%s", separator);
}
static int
undefined2 (const char *type, const 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;
}

1451
sunrpc/rpc_main.c
View File

File diff suppressed because it is too large Load Diff

687
sunrpc/rpc_parse.c
View File

@ -1,687 +0,0 @@
/*
* From: @(#)rpc_parse.c 1.8 89/02/22
*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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.c, Parser for the RPC protocol compiler
* Copyright (C) 1987 Sun Microsystems, Inc.
*/
#include <stdio.h>
#include <string.h>
#include "rpc/types.h"
#include "rpc_scan.h"
#include "rpc_parse.h"
#include "rpc_util.h"
#include "proto.h"
#define ARGNAME "arg"
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 (const 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 (const char **prefixp, const char **typep, defkind dkind);
static void unsigned_dec (const 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 *tcase; */
case_list **tailp;
#if 0
int flag;
#endif
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 0
flag = 0;
#endif
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));
}
#if 0
else if (flag)
{
*tailp = cases;
tailp = &cases->next;
cases = ALLOC (case_list);
};
#endif
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 const char *reserved_words[] =
{
"array",
"bytes",
"destroy",
"free",
"getpos",
"inline",
"pointer",
"reference",
"setpos",
"sizeof",
"union",
"vector",
NULL
};
static const 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 (const 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 /* arg number */ )
{
token tok;
char name[MAXLINESIZE]; /* 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 (const char **prefixp, const 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_LONG:
*typep = "long";
(void) peekscan (TOK_INT, &tok);
break;
case TOK_HYPER:
*typep = "quad_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 (const 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_LONG:
get_token (&tok);
*typep = "u_long";
(void) peekscan (TOK_INT, &tok);
break;
case TOK_HYPER:
get_token (&tok);
*typep = "u_quad_t";
(void) peekscan(TOK_INT, &tok);
break;
case TOK_INT:
get_token (&tok);
*typep = "u_int";
break;
default:
*typep = "u_int";
break;
}
}

165
sunrpc/rpc_parse.h
View File

@ -1,165 +0,0 @@
/* @(#)rpc_parse.h 1.3 90/08/29
*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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, Definitions for the RPCL parser
*/
enum defkind {
DEF_CONST,
DEF_STRUCT,
DEF_UNION,
DEF_ENUM,
DEF_TYPEDEF,
DEF_PROGRAM
};
typedef enum defkind defkind;
typedef const 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 {
const char *old_prefix;
const char *old_type;
relation rel;
const char *array_max;
};
typedef struct typedef_def typedef_def;
struct enumval_list {
const char *name;
const 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 {
const char *prefix;
const char *type;
const char *name;
relation rel;
const 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 {
const 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 {
const char *argname; /* name of struct for arg*/
decl_list *decls;
};
typedef struct arg_list arg_list;
struct proc_list {
const char *proc_name;
const char *proc_num;
arg_list args;
int arg_num;
const char *res_type;
const char *res_prefix;
struct proc_list *next;
};
typedef struct proc_list proc_list;
struct version_list {
const char *vers_name;
const char *vers_num;
proc_list *procs;
struct version_list *next;
};
typedef struct version_list version_list;
struct program_def {
const char *prog_num;
version_list *versions;
};
typedef struct program_def program_def;
struct definition {
const 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(void);
struct bas_type
{
const char *name;
int length;
struct bas_type *next;
};
typedef struct bas_type bas_type;

336
sunrpc/rpc_sample.c
View File

@ -1,336 +0,0 @@
/*
* From: @(#)rpc_sample.c 1.1 90/08/30
*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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_sample.c, Sample client-server code outputter for the RPC protocol compiler
*/
#include <stdio.h>
#include <string.h>
#include "rpc_parse.h"
#include "rpc_util.h"
#include "proto.h"
static const char RQSTP[] = "rqstp";
static void write_sample_client (const 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 (const 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");
++i;
if (mtflag)
{
f_print (fout, "enum clnt_stat retval_%d;\n\t", i);
ptype (proc->res_prefix, proc->res_type, 1);
if (!streq (proc->res_type, "void"))
f_print (fout, "result_%d;\n", i);
else
fprintf (fout, "*result_%d;\n", i);
}
else
{
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);
f_print (fout, " ");
}
else
f_print (fout, "char *"); /* cannot have "void" type */
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);
if (strcmp (l->decl.type, "string") == 1)
f_print (fout, " ");
pvname (proc->proc_name, vp->vers_num);
f_print (fout, "_%s;\n", l->decl.name);
}
}
}
/* generate creation of client handle */
f_print(fout, "\n#ifndef\tDEBUG\n");
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");
f_print(fout, "#endif\t/* DEBUG */\n\n");
/* generate calls to procedures */
i = 0;
for (proc = vp->procs; proc != NULL; proc = proc->next)
{
if (mtflag)
f_print(fout, "\tretval_%d = ",++i);
else
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);
if (mtflag)
f_print(fout, "_arg, &result_%d, clnt);\n", i);
else
f_print (fout, "_arg, clnt);\n");
}
else if (streq (proc->args.decls->decl.type, "void"))
{
if (mtflag)
f_print (fout, "(&result_%d, clnt);\n", i);
else
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);
}
if (mtflag)
f_print(fout, "&result_%d, ", i);
f_print (fout, "clnt);\n");
}
if (mtflag)
{
f_print(fout, "\tif (retval_%d != RPC_SUCCESS) {\n", i);
}
else
{
f_print(fout, "\tif (result_%d == (", i);
ptype(proc->res_prefix, proc->res_type, 1);
f_print(fout, "*) NULL) {\n");
}
f_print(fout, "\t\tclnt_perror (clnt, \"call failed\");\n");
f_print(fout, "\t}\n");
}
f_print (fout, "#ifndef\tDEBUG\n");
f_print (fout, "\tclnt_destroy (clnt);\n");
f_print (fout, "#endif\t /* DEBUG */\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 (!mtflag)
{
return_type (proc);
f_print (fout, "*\n");
}
else
f_print (fout, "bool_t\n");
if (Cflag || mtflag)
pvname_svc (proc->proc_name, vp->vers_num);
else
pvname(proc->proc_name, vp->vers_num);
printarglist(proc, "result", RQSTP, "struct svc_req *");
f_print(fout, "{\n");
if (!mtflag)
{
f_print(fout, "\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");
}
else
f_print(fout, "\tbool_t retval;\n");
fprintf (fout, "\n\t/*\n\t * insert server code here\n\t */\n\n");
if (!mtflag)
{
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");
}
else
f_print(fout, "\treturn retval;\n}\n");
}
/* put in sample freeing routine */
if (mtflag)
{
f_print(fout, "\nint\n");
pvname(def->def_name, vp->vers_num);
if (Cflag)
f_print(fout,"_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)\n");
else
{
f_print(fout,"_freeresult (transp, xdr_result, result)\n");
f_print(fout,"\tSVCXPRT *transp;\n");
f_print(fout,"\txdrproc_t xdr_result;\n");
f_print(fout,"\tcaddr_t result;\n");
}
f_print(fout, "{\n");
f_print(fout, "\txdr_free (xdr_result, result);\n");
f_print(fout,
"\n\t/*\n\t * Insert additional freeing code here, if needed\n\t */\n");
f_print(fout, "\n\treturn 1;\n}\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, "int\nmain (int argc, char *argv[])\n{\n");
else
f_print (fout, "int\nmain (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, "exit (0);\n}\n");
}

544
sunrpc/rpc_scan.c
View File

@ -1,544 +0,0 @@
/*
* From: @(#)rpc_scan.c 1.11 89/02/22
*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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.c, Scanner for the RPC protocol compiler
* Copyright (C) 1987, Sun Microsystems, Inc.
*/
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <libintl.h>
#include "rpc_scan.h"
#include "rpc_parse.h"
#include "rpc_util.h"
#include "proto.h"
#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 */
static void unget_token (token * tokp);
static void findstrconst (const char **str, const char **val);
static void findchrconst (const char **str, const char **val);
static void findconst (const char **str, const char **val);
static void findkind (const char **mark, token * tokp);
static int cppline (const char *line);
static int directive (const char *line);
static void printdirective (const char *line);
static void docppline (const char *line, int *lineno, const char **fname);
/*
* 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;
*curline = 0;
where = curline;
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 (const char **str, const char **val)
{
const char *p;
char *tmp;
int size;
p = *str;
do
{
p++;
}
while (*p && *p != '"');
if (*p == 0)
{
error (_("unterminated string constant"));
}
p++;
size = p - *str;
tmp = alloc (size + 1);
strncpy (tmp, *str, size);
tmp[size] = 0;
*val = tmp;
*str = p;
}
static void
findchrconst (const char **str, const char **val)
{
const char *p;
char *tmp;
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"));
}
tmp = alloc (size + 1);
strncpy (tmp, *str, size);
tmp[size] = 0;
*val = tmp;
*str = p;
}
static void
findconst (const char **str, const char **val)
{
const char *p;
char *tmp;
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;
tmp = alloc (size + 1);
strncpy (tmp, *str, size);
tmp[size] = 0;
*val = tmp;
*str = p;
}
static const 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_LONG, "long"},
{TOK_HYPER, "hyper"},
{TOK_FLOAT, "float"},
{TOK_DOUBLE, "double"},
{TOK_STRING, "string"},
{TOK_PROGRAM, "program"},
{TOK_VERSION, "version"},
{TOK_EOF, "??????"},
};
static void
findkind (const char **mark, token *tokp)
{
int len;
const token *s;
const char *str;
char *tmp;
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++);
tmp = alloc (len + 1);
strncpy (tmp, str, len);
tmp[len] = 0;
tokp->str = tmp;
*mark = str + len;
}
static int
cppline (const char *line)
{
return line == curline && *line == '#';
}
static int
directive (const char *line)
{
return line == curline && *line == '%';
}
static void
printdirective (const char *line)
{
f_print (fout, "%s", line + 1);
}
static void
docppline (const char *line, int *lineno, const 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)
{
free (file);
*fname = NULL;
}
else
{
*fname = file;
}
*lineno = num - 1;
}

104
sunrpc/rpc_scan.h
View File

@ -1,104 +0,0 @@
/* @(#)rpc_scan.h 1.3 90/08/29 */
/*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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, 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_LONG,
TOK_HYPER,
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;
const char *str;
};
typedef struct token token;
/*
* routine interface
*/
void scan(tok_kind expect, token *tokp);
void scan2(tok_kind expect1, tok_kind expect2, token *tokp);
void scan3(tok_kind expect1, tok_kind expect2, tok_kind expect3, token *tokp);
void scan_num(token *tokp);
void peek(token *tokp);
int peekscan(tok_kind expect, token *tokp);
void get_token(token *tokp);
void expected1(tok_kind exp1) __attribute__ ((noreturn));
void expected2(tok_kind exp1, tok_kind exp2) __attribute__ ((noreturn));
void expected3(tok_kind exp1, tok_kind exp2, tok_kind exp3)
__attribute__ ((noreturn));

1093
sunrpc/rpc_svcout.c
View File

File diff suppressed because it is too large Load Diff

178
sunrpc/rpc_tblout.c
View File

@ -1,178 +0,0 @@
/*
* From: @(#)rpc_tblout.c 1.4 89/02/22
*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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_tblout.c, Dispatch table outputter for the RPC protocol compiler
*/
#include <stdio.h>
#include <string.h>
#include "rpc_parse.h"
#include "rpc_util.h"
#include "proto.h"
#define TABSIZE 8
#define TABCOUNT 5
#define TABSTOP (TABSIZE*TABCOUNT)
static const char tabstr[TABCOUNT + 1] = "\t\t\t\t\t";
static const char tbl_hdr[] = "struct rpcgen_table %s_table[] = {\n";
static const char tbl_end[] = "};\n";
static const 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 const char tbl_nproc[] = "int %s_nproc =\n\tsizeof(%s_table)/sizeof(%s_table[0]);\n\n";
static void write_table (const definition * def);
static void printit (const char *prefix, const char *type);
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 (const 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 (const char *prefix, const 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");
}

525
sunrpc/rpc_util.c
View File

@ -1,525 +0,0 @@
/*
* From: @(#)rpc_util.c 1.11 89/02/22
*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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.c, Utility routines for the RPC protocol compiler
*/
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include "rpc_scan.h"
#include "rpc_parse.h"
#include "rpc_util.h"
#include "proto.h"
#define ARGEXT "argument"
char curline[MAXLINESIZE]; /* current read line */
const char *where = curline; /* current point in line */
int linenum = 0; /* current line number */
const char *infilename; /* input filename */
#define NFILES 7
const 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 */
static int findit (const definition * def, const char *type);
static const char *fixit (const char *type, const char *orig);
static int typedefed (const definition * def, const char *type);
static const char *toktostr (tok_kind kind);
static void printbuf (void);
static void printwhere (void);
/*
* Reinitialize the world
*/
void
reinitialize (void)
{
memset (curline, 0, MAXLINESIZE);
where = curline;
linenum = 0;
defined = NULL;
}
/*
* string equality
*/
int
streq (const char *a, const char *b)
{
return strcmp (a, b) == 0;
}
/*
* find a value in a list
*/
definition *
findval (list *lst, const char *val,
int (*cmp) (const definition *, const 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 (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 (const definition * def, const char *type)
{
return streq (def->def_name, type);
}
static const char *
fixit (const char *type, const char *orig)
{
definition *def;
def = findval (defined, type, findit);
if (def == NULL || def->def_kind != DEF_TYPEDEF)
{
return orig;
}
switch (def->def.ty.rel)
{
case REL_VECTOR:
if (streq (def->def.ty.old_type, "opaque"))
return ("char");
else
return (def->def.ty.old_type);
case REL_ALIAS:
return (fixit (def->def.ty.old_type, orig));
default:
return orig;
}
}
const char *
fixtype (const char *type)
{
return fixit (type, type);
}
const char *
stringfix (const char *type)
{
if (streq (type, "string"))
{
return "wrapstring";
}
else
{
return type;
}
}
void
ptype (const char *prefix, const 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 (const definition * def, const 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 (const 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 = findval (defined, type, typedefed);
if (def == NULL)
{
return 0;
}
type = def->def.ty.old_type;
rel = def->def.ty.rel;
}
}
}
char *
locase (const 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 (const char *pname, const char *vnum)
{
f_print (fout, "%s_%s_svc", locase (pname), vnum);
}
void
pvname (const char *pname, const char *vnum)
{
f_print (fout, "%s_%s", locase (pname), vnum);
}
/*
* print a useful (?) error message, and then die
*/
void
error (const 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++)
{
unlink (outfiles[i]);
}
exit (1);
}
void
record_open (const char *file)
{
if (nfiles < NFILES)
{
outfiles[nfiles++] = file;
}
else
{
f_print (stderr, "too many files!\n");
crash ();
}
}
static char expectbuf[100];
/*
* error, token encountered was not the expected one
*/
void
expected1 (tok_kind exp1)
{
s_print (expectbuf, "expected '%s'",
toktostr (exp1));
error (expectbuf);
}
/*
* error, token encountered was not one of two expected ones
*/
void
expected2 (tok_kind exp1, tok_kind 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 (tok_kind exp1, tok_kind exp2, tok_kind exp3)
{
s_print (expectbuf, "expected '%s', '%s' or '%s'",
toktostr (exp1),
toktostr (exp2),
toktostr (exp3));
error (expectbuf);
}
void
tabify (FILE * f, int tab)
{
while (tab--)
{
(void) fputc ('\t', f);
}
}
static const 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_LONG, "long"},
{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 const char *
toktostr (tok_kind kind)
{
const 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 (const char *pname, const 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, const char *type)
{
bas_type *ptr;
if ((ptr = malloc (sizeof (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 (const 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;
}

154
sunrpc/rpc_util.h
View File

@ -1,154 +0,0 @@
/* @(#)rpc_util.h 1.5 90/08/29 */
/*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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, Useful definitions for the RPC protocol compiler
*/
#include <stdlib.h>
#define alloc(size) malloc((unsigned)(size))
#define ALLOC(object) (object *) malloc(sizeof(object))
#define s_print (void) sprintf
#define f_print (void) fprintf
struct list {
definition *val;
struct list *next;
};
typedef struct list list;
struct xdrfunc {
char *name;
int pointerp;
struct xdrfunc *next;
};
typedef struct xdrfunc xdrfunc;
#define PUT 1
#define GET 2
/*
* Global variables
*/
#define MAXLINESIZE 1024
extern char curline[MAXLINESIZE];
extern const char *where;
extern int linenum;
extern const char *infilename;
extern FILE *fout;
extern FILE *fin;
extern list *defined;
extern bas_type *typ_list_h;
extern bas_type *typ_list_t;
extern xdrfunc *xdrfunc_head, *xdrfunc_tail;
/*
* 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 CCflag; /* C++ flag */
extern int tirpcflag; /* flag for generating tirpc code */
extern int inlineflag; /* if this is 0, then do not generate inline code */
extern int mtflag;
/*
* Other flags related with inetd jumpstart.
*/
extern int indefinitewait;
extern int exitnow;
extern int timerflag;
extern int nonfatalerrors;
/*
* rpc_util routines
*/
void storeval(list **lstp, definition *val);
#define STOREVAL(list,item) storeval(list,item)
definition *findval(list *lst, const char *val,
int (*cmp)(const definition *, const char *));
#define FINDVAL(list,item,finder) findval(list, item, finder)
const char *fixtype(const char *type);
const char *stringfix(const char *type);
char *locase(const char *str);
void pvname_svc(const char *pname, const char *vnum);
void pvname(const char *pname, const char *vnum);
void ptype(const char *prefix, const char *type, int follow);
int isvectordef(const char *type, relation rel);
int streq(const char *a, const char *b);
void error(const char *msg);
void tabify(FILE *f, int tab);
void record_open(const char *file);
bas_type *find_type(const char *type);
/*
* rpc_cout routines
*/
void emit(definition *def);
/*
* rpc_hout routines
*/
void print_datadef(definition *def);
void print_funcdef(definition *def);
/*
* rpc_svcout routines
*/
void write_most(const char *infile, int netflag, int nomain);
void write_register(void);
void write_rest(void);
void write_programs(const char *storage);
void write_svc_aux(int nomain);
void write_inetd_register(const char *transp);
void write_netid_register(const char *);
void write_nettype_register(const char *);
/*
* rpc_clntout routines
*/
void write_stubs(void);
/*
* rpc_tblout routines
*/
void write_tables(void);

2
sunrpc/rpcgen.c
View File

@ -1,2 +0,0 @@
/* Empty file expected by glibc's standard build rules for
executables. */

23
sunrpc/rpcsvc/bootparam.h
View File

@ -1,23 +0,0 @@
/* Copyright (C) 1999-2020 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#ifndef _RPCSVC_BOOTPARAM_H
#define _RPCSVC_BOOTPARAM_H
#include <rpcsvc/bootparam_prot.h>
#endif /* _RPCSVC_BOOTPARAM_H */

97
sunrpc/rpcsvc/bootparam_prot.x
View File

@ -1,97 +0,0 @@
/* @(#)bootparam_prot.x 2.1 88/08/01 4.0 RPCSRC */
/*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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 for bootparms service.
* There are two procedures:
* WHOAMI takes a net address and returns a client name and also a
* likely net address for routing
* GETFILE takes a client name and file identifier and returns the
* server name, server net address and pathname for the file.
* file identifiers typically include root, swap, pub and dump
*/
#ifdef RPC_HDR
%#include <rpc/types.h>
%#include <sys/time.h>
%#include <sys/errno.h>
%#include <nfs/nfs.h>
#endif
const MAX_MACHINE_NAME = 255;
const MAX_PATH_LEN = 1024;
const MAX_FILEID = 32;
const IP_ADDR_TYPE = 1;
typedef string bp_machine_name_t<MAX_MACHINE_NAME>;
typedef string bp_path_t<MAX_PATH_LEN>;
typedef string bp_fileid_t<MAX_FILEID>;
struct ip_addr_t {
char net;
char host;
char lh;
char impno;
};
union bp_address switch (int address_type) {
case IP_ADDR_TYPE:
ip_addr_t ip_addr;
};
struct bp_whoami_arg {
bp_address client_address;
};
struct bp_whoami_res {
bp_machine_name_t client_name;
bp_machine_name_t domain_name;
bp_address router_address;
};
struct bp_getfile_arg {
bp_machine_name_t client_name;
bp_fileid_t file_id;
};
struct bp_getfile_res {
bp_machine_name_t server_name;
bp_address server_address;
bp_path_t server_path;
};
program BOOTPARAMPROG {
version BOOTPARAMVERS {
bp_whoami_res BOOTPARAMPROC_WHOAMI(bp_whoami_arg) = 1;
bp_getfile_res BOOTPARAMPROC_GETFILE(bp_getfile_arg) = 2;
} = 1;
} = 100026;

283
sunrpc/rpcsvc/key_prot.x
View File

@ -1,283 +0,0 @@
/*
* Key server protocol definition
* Copyright (c) 2010, Oracle America, Inc.
*
* 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 the "Oracle America, 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.
*
* The keyserver is a public key storage/encryption/decryption service
* The encryption method used is based on the Diffie-Hellman exponential
* key exchange technology.
*
* The key server is local to each machine, akin to the portmapper.
* Under TI-RPC, communication with the keyserver is through the
* loopback transport.
*
* NOTE: This .x file generates the USER level headers for the keyserver.
* the KERNEL level headers are created by hand as they kernel has special
* requirements.
*/
%#if 0
%#pragma ident "@(#)key_prot.x 1.7 94/04/29 SMI"
%#endif
%
%/* Copyright (c) 1990, 1991 Sun Microsystems, Inc. */
%
%/*
% * Compiled from key_prot.x using rpcgen.
% * DO NOT EDIT THIS FILE!
% * This is NOT source code!
% */
/*
* PROOT and MODULUS define the way the Diffie-Hellman key is generated.
*
* MODULUS should be chosen as a prime of the form: MODULUS == 2*p + 1,
* where p is also prime.
*
* PROOT satisfies the following two conditions:
* (1) (PROOT ** 2) % MODULUS != 1
* (2) (PROOT ** p) % MODULUS != 1
*
*/
const PROOT = 3;
const HEXMODULUS = "d4a0ba0250b6fd2ec626e7efd637df76c716e22d0944b88b";
const HEXKEYBYTES = 48; /* HEXKEYBYTES == strlen(HEXMODULUS) */
const KEYSIZE = 192; /* KEYSIZE == bit length of key */
const KEYBYTES = 24; /* byte length of key */
/*
* The first 16 hex digits of the encrypted secret key are used as
* a checksum in the database.
*/
const KEYCHECKSUMSIZE = 16;
/*
* status of operation
*/
enum keystatus {
KEY_SUCCESS, /* no problems */
KEY_NOSECRET, /* no secret key stored */
KEY_UNKNOWN, /* unknown netname */
KEY_SYSTEMERR /* system error (out of memory, encryption failure) */
};
typedef opaque keybuf[HEXKEYBYTES]; /* store key in hex */
typedef string netnamestr<MAXNETNAMELEN>;
/*
* Argument to ENCRYPT or DECRYPT
*/
struct cryptkeyarg {
netnamestr remotename;
des_block deskey;
};
/*
* Argument to ENCRYPT_PK or DECRYPT_PK
*/
struct cryptkeyarg2 {
netnamestr remotename;
netobj remotekey; /* Contains a length up to 1024 bytes */
des_block deskey;
};
/*
* Result of ENCRYPT, DECRYPT, ENCRYPT_PK, and DECRYPT_PK
*/
union cryptkeyres switch (keystatus status) {
case KEY_SUCCESS:
des_block deskey;
default:
void;
};
const MAXGIDS = 16; /* max number of gids in gid list */
/*
* Unix credential
*/
struct unixcred {
u_int uid;
u_int gid;
u_int gids<MAXGIDS>;
};
/*
* Result returned from GETCRED
*/
union getcredres switch (keystatus status) {
case KEY_SUCCESS:
unixcred cred;
default:
void;
};
/*
* key_netstarg;
*/
struct key_netstarg {
keybuf st_priv_key;
keybuf st_pub_key;
netnamestr st_netname;
};
union key_netstres switch (keystatus status){
case KEY_SUCCESS:
key_netstarg knet;
default:
void;
};
#ifdef RPC_HDR
%
%#ifndef opaque
%#define opaque char
%#endif
%
#endif
program KEY_PROG {
version KEY_VERS {
/*
* This is my secret key.
* Store it for me.
*/
keystatus
KEY_SET(keybuf) = 1;
/*
* I want to talk to X.
* Encrypt a conversation key for me.
*/
cryptkeyres
KEY_ENCRYPT(cryptkeyarg) = 2;
/*
* X just sent me a message.
* Decrypt the conversation key for me.
*/
cryptkeyres
KEY_DECRYPT(cryptkeyarg) = 3;
/*
* Generate a secure conversation key for me
*/
des_block
KEY_GEN(void) = 4;
/*
* Get me the uid, gid and group-access-list associated
* with this netname (for kernel which cannot use NIS)
*/
getcredres
KEY_GETCRED(netnamestr) = 5;
} = 1;
version KEY_VERS2 {
/*
* #######
* Procedures 1-5 are identical to version 1
* #######
*/
/*
* This is my secret key.
* Store it for me.
*/
keystatus
KEY_SET(keybuf) = 1;
/*
* I want to talk to X.
* Encrypt a conversation key for me.
*/
cryptkeyres
KEY_ENCRYPT(cryptkeyarg) = 2;
/*
* X just sent me a message.
* Decrypt the conversation key for me.
*/
cryptkeyres
KEY_DECRYPT(cryptkeyarg) = 3;
/*
* Generate a secure conversation key for me
*/
des_block
KEY_GEN(void) = 4;
/*
* Get me the uid, gid and group-access-list associated
* with this netname (for kernel which cannot use NIS)
*/
getcredres
KEY_GETCRED(netnamestr) = 5;
/*
* I want to talk to X. and I know X's public key
* Encrypt a conversation key for me.
*/
cryptkeyres
KEY_ENCRYPT_PK(cryptkeyarg2) = 6;
/*
* X just sent me a message. and I know X's public key
* Decrypt the conversation key for me.
*/
cryptkeyres
KEY_DECRYPT_PK(cryptkeyarg2) = 7;
/*
* Store my public key, netname and private key.
*/
keystatus
KEY_NET_PUT(key_netstarg) = 8;
/*
* Retrieve my public key, netname and private key.
*/
key_netstres
KEY_NET_GET(void) = 9;
/*
* Return me the conversation key that is constructed
* from my secret key and this publickey.
*/
cryptkeyres
KEY_GET_CONV(keybuf) = 10;
} = 2;
} = 100029;

130
sunrpc/rpcsvc/klm_prot.x
View File

@ -1,130 +0,0 @@
/* @(#)klm_prot.x 2.1 88/08/01 4.0 RPCSRC */
/*
* Kernel/lock manager protocol definition
* Copyright (c) 2010, Oracle America, Inc.
*
* 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 the "Oracle America, 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.
*
* protocol used between the UNIX kernel (the "client") and the
* local lock manager. The local lock manager is a deamon running
* above the kernel.
*/
const LM_MAXSTRLEN = 1024;
/*
* lock manager status returns
*/
enum klm_stats {
klm_granted = 0, /* lock is granted */
klm_denied = 1, /* lock is denied */
klm_denied_nolocks = 2, /* no lock entry available */
klm_working = 3 /* lock is being processed */
};
/*
* lock manager lock identifier
*/
struct klm_lock {
string server_name<LM_MAXSTRLEN>;
netobj fh; /* a counted file handle */
int pid; /* holder of the lock */
unsigned l_offset; /* beginning offset of the lock */
unsigned l_len; /* byte length of the lock;
* zero means through end of file */
};
/*
* lock holder identifier
*/
struct klm_holder {
bool exclusive; /* FALSE if shared lock */
int svid; /* holder of the lock (pid) */
unsigned l_offset; /* beginning offset of the lock */
unsigned l_len; /* byte length of the lock;
* zero means through end of file */
};
/*
* reply to KLM_LOCK / KLM_UNLOCK / KLM_CANCEL
*/
struct klm_stat {
klm_stats stat;
};
/*
* reply to a KLM_TEST call
*/
union klm_testrply switch (klm_stats stat) {
case klm_denied:
struct klm_holder holder;
default: /* All other cases return no arguments */
void;
};
/*
* arguments to KLM_LOCK
*/
struct klm_lockargs {
bool block;
bool exclusive;
struct klm_lock alock;
};
/*
* arguments to KLM_TEST
*/
struct klm_testargs {
bool exclusive;
struct klm_lock alock;
};
/*
* arguments to KLM_UNLOCK
*/
struct klm_unlockargs {
struct klm_lock alock;
};
program KLM_PROG {
version KLM_VERS {
klm_testrply KLM_TEST (struct klm_testargs) = 1;
klm_stat KLM_LOCK (struct klm_lockargs) = 2;
klm_stat KLM_CANCEL (struct klm_lockargs) = 3;
/* klm_granted=> the cancel request fails due to lock is already granted */
/* klm_denied=> the cancel request successfully aborts
lock request */
klm_stat KLM_UNLOCK (struct klm_unlockargs) = 4;
} = 1;
} = 100020;

161
sunrpc/rpcsvc/mount.x
View File

@ -1,161 +0,0 @@
/* @(#)mount.x 2.1 88/08/01 4.0 RPCSRC */
/*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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.
*/
/*
* Protocol description for the mount program
*/
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 */
/*
* 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];
/*
* 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;
};
/*
* The type dirpath is the pathname of a directory
*/
typedef string dirpath<MNTPATHLEN>;
/*
* The type name is used for arbitrary names (hostnames, groupnames)
*/
typedef string name<MNTNAMLEN>;
/*
* A list of who has what mounted
*/
typedef struct mountbody *mountlist;
struct mountbody {
name ml_hostname;
dirpath ml_directory;
mountlist ml_next;
};
/*
* A list of netgroups
*/
typedef struct groupnode *groups;
struct groupnode {
name gr_name;
groups gr_next;
};
/*
* A list of what is exported and to whom
*/
typedef struct exportnode *exports;
struct exportnode {
dirpath ex_dir;
groups ex_groups;
exports ex_next;
};
program MOUNTPROG {
/*
* Version one of the mount protocol communicates with version two
* of the NFS protocol. 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 response 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;
} = 100005;

352
sunrpc/rpcsvc/nfs_prot.x
View File

@ -1,352 +0,0 @@
/* @(#)nfs_prot.x 2.1 88/08/01 4.0 RPCSRC */
/*
* nfs_prot.x 1.2 87/10/12
* Copyright (c) 2010, Oracle America, Inc.
*
* 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 the "Oracle America, 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.
*/
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; /* preferred block size */
unsigned rdev; /* special device # */
unsigned blocks; /* Kb of disk used by file */
unsigned fsid; /* device # */
unsigned fileid; /* inode # */
nfstime atime; /* time of last access */
nfstime mtime; /* time of last modification */
nfstime ctime; /* time of last change */
};
/*
* File attributes which can be set
*/
struct sattr {
unsigned mode; /* protection mode bits */
unsigned uid; /* owner user id */
unsigned gid; /* owner group id */
unsigned size; /* file size in bytes */
nfstime atime; /* time of last access */
nfstime mtime; /* time of last modification */
};
typedef string filename<NFS_MAXNAMLEN>;
typedef string nfspath<NFS_MAXPATHLEN>;
/*
* Reply status with file attributes
*/
union attrstat switch (nfsstat status) {
case NFS_OK:
fattr attributes;
default:
void;
};
struct sattrargs {
nfs_fh file;
sattr attributes;
};
/*
* Arguments for directory operations
*/
struct diropargs {
nfs_fh dir; /* directory file handle */
filename name; /* name (up to NFS_MAXNAMLEN bytes) */
};
struct diropokres {
nfs_fh file;
fattr attributes;
};
/*
* Results from directory operation
*/
union diropres switch (nfsstat status) {
case NFS_OK:
diropokres diropres;
default:
void;
};
union readlinkres switch (nfsstat status) {
case NFS_OK:
nfspath data;
default:
void;
};
/*
* Arguments to remote read
*/
struct readargs {
nfs_fh file; /* handle for file */
unsigned offset; /* byte offset in file */
unsigned count; /* immediate read count */
unsigned totalcount; /* total read count (from this offset)*/
};
/*
* Status OK portion of remote read reply
*/
struct readokres {
fattr attributes; /* attributes, need for pagin*/
opaque data<NFS_MAXDATA>;
};
union readres switch (nfsstat status) {
case NFS_OK:
readokres reply;
default:
void;
};
/*
* Arguments to remote write
*/
struct writeargs {
nfs_fh file; /* handle for file */
unsigned beginoffset; /* beginning byte offset in file */
unsigned offset; /* current byte offset in file */
unsigned totalcount; /* total write count (to this offset)*/
opaque data<NFS_MAXDATA>;
};
struct createargs {
diropargs where;
sattr attributes;
};
struct renameargs {
diropargs from;
diropargs to;
};
struct linkargs {
nfs_fh from;
diropargs to;
};
struct symlinkargs {
diropargs from;
nfspath to;
sattr attributes;
};
typedef opaque nfscookie[NFS_COOKIESIZE];
/*
* Arguments to readdir
*/
struct readdirargs {
nfs_fh dir; /* directory handle */
nfscookie cookie;
unsigned count; /* number of directory bytes to read */
};
struct entry {
unsigned fileid;
filename name;
nfscookie cookie;
entry *nextentry;
};
struct dirlist {
entry *entries;
bool eof;
};
union readdirres switch (nfsstat status) {
case NFS_OK:
dirlist reply;
default:
void;
};
struct statfsokres {
unsigned tsize; /* preferred transfer size in bytes */
unsigned bsize; /* fundamental file system block size */
unsigned blocks; /* total blocks in file system */
unsigned bfree; /* free blocks in fs */
unsigned bavail; /* free blocks avail to non-superuser */
};
union statfsres switch (nfsstat status) {
case NFS_OK:
statfsokres reply;
default:
void;
};
/*
* 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;

203
sunrpc/rpcsvc/nlm_prot.x
View File

@ -1,203 +0,0 @@
/* @(#)nlm_prot.x 2.1 88/08/01 4.0 RPCSRC */
/*
* Network lock manager protocol definition
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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.
*
* protocol used between local lock manager and remote lock manager
*/
#ifdef RPC_HDR
%#define LM_MAXSTRLEN 1024
%#define MAXNAMELEN LM_MAXSTRLEN+1
#endif
/*
* status of a call to the lock manager
*/
enum nlm_stats {
nlm_granted = 0,
nlm_denied = 1,
nlm_denied_nolocks = 2,
nlm_blocked = 3,
nlm_denied_grace_period = 4
};
struct nlm_holder {
bool exclusive;
int svid;
netobj oh;
unsigned l_offset;
unsigned l_len;
};
union nlm_testrply switch (nlm_stats stat) {
case nlm_denied:
struct nlm_holder holder;
default:
void;
};
struct nlm_stat {
nlm_stats stat;
};
struct nlm_res {
netobj cookie;
nlm_stat stat;
};
struct nlm_testres {
netobj cookie;
nlm_testrply stat;
};
struct nlm_lock {
string caller_name<LM_MAXSTRLEN>;
netobj fh; /* identify a file */
netobj oh; /* identify owner of a lock */
int svid; /* generated from pid for svid */
unsigned l_offset;
unsigned l_len;
};
struct nlm_lockargs {
netobj cookie;
bool block;
bool exclusive;
struct nlm_lock alock;
bool reclaim; /* used for recovering locks */
int state; /* specify local status monitor state */
};
struct nlm_cancargs {
netobj cookie;
bool block;
bool exclusive;
struct nlm_lock alock;
};
struct nlm_testargs {
netobj cookie;
bool exclusive;
struct nlm_lock alock;
};
struct nlm_unlockargs {
netobj cookie;
struct nlm_lock alock;
};
#ifdef RPC_HDR
%/*
% * The following enums are actually bit encoded for efficient
% * boolean algebra.... DON'T change them.....
% */
#endif
enum fsh_mode {
fsm_DN = 0, /* deny none */
fsm_DR = 1, /* deny read */
fsm_DW = 2, /* deny write */
fsm_DRW = 3 /* deny read/write */
};
enum fsh_access {
fsa_NONE = 0, /* for completeness */
fsa_R = 1, /* read only */
fsa_W = 2, /* write only */
fsa_RW = 3 /* read/write */
};
struct nlm_share {
string caller_name<LM_MAXSTRLEN>;
netobj fh;
netobj oh;
fsh_mode mode;
fsh_access access;
};
struct nlm_shareargs {
netobj cookie;
nlm_share share;
bool reclaim;
};
struct nlm_shareres {
netobj cookie;
nlm_stats stat;
int sequence;
};
struct nlm_notify {
string name<MAXNAMELEN>;
long state;
};
/*
* Over-the-wire protocol used between the network lock managers
*/
program NLM_PROG {
version NLM_VERS {
nlm_testres NLM_TEST(struct nlm_testargs) = 1;
nlm_res NLM_LOCK(struct nlm_lockargs) = 2;
nlm_res NLM_CANCEL(struct nlm_cancargs) = 3;
nlm_res NLM_UNLOCK(struct nlm_unlockargs) = 4;
/*
* remote lock manager call-back to grant lock
*/
nlm_res NLM_GRANTED(struct nlm_testargs)= 5;
/*
* message passing style of requesting lock
*/
void NLM_TEST_MSG(struct nlm_testargs) = 6;
void NLM_LOCK_MSG(struct nlm_lockargs) = 7;
void NLM_CANCEL_MSG(struct nlm_cancargs) =8;
void NLM_UNLOCK_MSG(struct nlm_unlockargs) = 9;
void NLM_GRANTED_MSG(struct nlm_testargs) = 10;
void NLM_TEST_RES(nlm_testres) = 11;
void NLM_LOCK_RES(nlm_res) = 12;
void NLM_CANCEL_RES(nlm_res) = 13;
void NLM_UNLOCK_RES(nlm_res) = 14;
void NLM_GRANTED_RES(nlm_res) = 15;
} = 1;
version NLM_VERSX {
nlm_shareres NLM_SHARE(nlm_shareargs) = 20;
nlm_shareres NLM_UNSHARE(nlm_shareargs) = 21;
nlm_res NLM_NM_LOCK(nlm_lockargs) = 22;
void NLM_FREE_ALL(nlm_notify) = 23;
} = 3;
} = 100021;

229
sunrpc/rpcsvc/rex.x
View File

@ -1,229 +0,0 @@
/* @(#)rex.x 2.1 88/08/01 4.0 RPCSRC */
/*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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.
*/
/*
* Remote execution (rex) protocol specification
*/
const STRINGSIZE = 1024;
typedef string rexstring<1024>;
/*
* values to pass to REXPROC_SIGNAL
*/
const SIGINT = 2; /* interrupt */
/*
* Values for rst_flags, below
*/
const REX_INTERACTIVE = 1; /* interactive mode */
struct rex_start {
rexstring rst_cmd<>; /* list of command and args */
rexstring rst_host; /* working directory host name */
rexstring rst_fsname; /* working directory file system name */
rexstring rst_dirwithin;/* working directory within file system */
rexstring rst_env<>; /* list of environment */
unsigned int rst_port0; /* port for stdin */
unsigned int rst_port1; /* port for stdout */
unsigned int rst_port2; /* port for stderr */
unsigned int rst_flags; /* options - see const above */
};
struct rex_result {
int rlt_stat; /* integer status code */
rexstring rlt_message; /* string message for human consumption */
};
struct sgttyb {
unsigned four; /* always equals 4 */
opaque chars[4];
/* chars[0] == input speed */
/* chars[1] == output speed */
/* chars[2] == kill character */
/* chars[3] == erase character */
unsigned flags;
};
/* values for speeds above (baud rates) */
const B0 = 0;
const B50 = 1;
const B75 = 2;
const B110 = 3;
const B134 = 4;
const B150 = 5;
const B200 = 6;
const B300 = 7;
const B600 = 8;
const B1200 = 9;
const B1800 = 10;
const B2400 = 11;
const B4800 = 12;
const B9600 = 13;
const B19200 = 14;
const B38400 = 15;
/* values for flags above */
const TANDEM = 0x00000001; /* send stopc on out q full */
const CBREAK = 0x00000002; /* half-cooked mode */
const LCASE = 0x00000004; /* simulate lower case */
const ECHO = 0x00000008; /* echo input */
const CRMOD = 0x00000010; /* map \r to \r\n on output */
const RAW = 0x00000020; /* no i/o processing */
const ODDP = 0x00000040; /* get/send odd parity */
const EVENP = 0x00000080; /* get/send even parity */
const ANYP = 0x000000c0; /* get any parity/send none */
const NLDELAY = 0x00000300; /* \n delay */
const NL0 = 0x00000000;
const NL1 = 0x00000100; /* tty 37 */
const NL2 = 0x00000200; /* vt05 */
const NL3 = 0x00000300;
const TBDELAY = 0x00000c00; /* horizontal tab delay */
const TAB0 = 0x00000000;
const TAB1 = 0x00000400; /* tty 37 */
const TAB2 = 0x00000800;
const XTABS = 0x00000c00; /* expand tabs on output */
const CRDELAY = 0x00003000; /* \r delay */
const CR0 = 0x00000000;
const CR1 = 0x00001000; /* tn 300 */
const CR2 = 0x00002000; /* tty 37 */
const CR3 = 0x00003000; /* concept 100 */
const VTDELAY = 0x00004000; /* vertical tab delay */
const FF0 = 0x00000000;
const FF1 = 0x00004000; /* tty 37 */
const BSDELAY = 0x00008000; /* \b delay */
const BS0 = 0x00000000;
const BS1 = 0x00008000;
const CRTBS = 0x00010000; /* do backspacing for crt */
const PRTERA = 0x00020000; /* \ ... / erase */
const CRTERA = 0x00040000; /* " \b " to wipe out char */
const TILDE = 0x00080000; /* hazeltine tilde kludge */
const MDMBUF = 0x00100000; /* start/stop output on carrier intr */
const LITOUT = 0x00200000; /* literal output */
const TOSTOP = 0x00400000; /* SIGTTOU on background output */
const FLUSHO = 0x00800000; /* flush output to terminal */
const NOHANG = 0x01000000; /* no SIGHUP on carrier drop */
const L001000 = 0x02000000;
const CRTKIL = 0x04000000; /* kill line with " \b " */
const PASS8 = 0x08000000;
const CTLECH = 0x10000000; /* echo control chars as ^X */
const PENDIN = 0x20000000; /* tp->t_rawq needs reread */
const DECCTQ = 0x40000000; /* only ^Q starts after ^S */
const NOFLSH = 0x80000000; /* no output flush on signal */
struct tchars {
unsigned six; /* always equals 6 */
opaque chars[6];
/* chars[0] == interrupt char */
/* chars[1] == quit char */
/* chars[2] == start output char */
/* chars[3] == stop output char */
/* chars[4] == end-of-file char */
/* chars[5] == input delimiter (like nl) */
};
struct ltchars {
unsigned six; /* always equals 6 */
opaque chars[6];
/* chars[0] == stop process signal */
/* chars[1] == delayed stop process signal */
/* chars[2] == reprint line */
/* chars[3] == flush output */
/* chars[4] == word erase */
/* chars[5] == literal next character */
unsigned mode;
};
struct rex_ttysize {
int ts_lines;
int ts_cols;
};
struct rex_ttymode {
sgttyb basic; /* standard unix tty flags */
tchars more; /* interrupt, kill characters, etc. */
ltchars yetmore; /* special Berkeley characters */
unsigned andmore; /* and Berkeley modes */
};
/* values for andmore above */
const LCRTBS = 0x0001; /* do backspacing for crt */
const LPRTERA = 0x0002; /* \ ... / erase */
const LCRTERA = 0x0004; /* " \b " to wipe out char */
const LTILDE = 0x0008; /* hazeltine tilde kludge */
const LMDMBUF = 0x0010; /* start/stop output on carrier intr */
const LLITOUT = 0x0020; /* literal output */
const LTOSTOP = 0x0040; /* SIGTTOU on background output */
const LFLUSHO = 0x0080; /* flush output to terminal */
const LNOHANG = 0x0100; /* no SIGHUP on carrier drop */
const LL001000 = 0x0200;
const LCRTKIL = 0x0400; /* kill line with " \b " */
const LPASS8 = 0x0800;
const LCTLECH = 0x1000; /* echo control chars as ^X */
const LPENDIN = 0x2000; /* needs reread */
const LDECCTQ = 0x4000; /* only ^Q starts after ^S */
const LNOFLSH = 0x8000; /* no output flush on signal */
program REXPROG {
version REXVERS {
/*
* Start remote execution
*/
rex_result
REXPROC_START(rex_start) = 1;
/*
* Wait for remote execution to terminate
*/
rex_result
REXPROC_WAIT(void) = 2;
/*
* Send tty modes
*/
void
REXPROC_MODES(rex_ttymode) = 3;
/*
* Send window size change
*/
void
REXPROC_WINCH(rex_ttysize) = 4;
/*
* Send other signal
*/
void
REXPROC_SIGNAL(int) = 5;
} = 1;
} = 100017;

61
sunrpc/rpcsvc/rquota.x
View File

@ -1,61 +0,0 @@
/* @(#)rquota.x 2.1 88/08/01 4.0 RPCSRC */
/* @(#)rquota.x 1.2 87/09/20 Copyr 1987 Sun Micro */
/*
* Remote quota protocol
* Requires unix authentication
*/
const RQ_PATHLEN = 1024;
struct getquota_args {
string gqa_pathp<RQ_PATHLEN>; /* path to filesystem of interest */
int gqa_uid; /* inquire about quota for uid */
};
/*
* remote quota structure
*/
struct rquota {
int rq_bsize; /* block size for block counts */
bool rq_active; /* indicates whether quota is active */
unsigned int rq_bhardlimit; /* absolute limit on disk blks alloc */
unsigned int rq_bsoftlimit; /* preferred limit on disk blks */
unsigned int rq_curblocks; /* current block count */
unsigned int rq_fhardlimit; /* absolute limit on allocated files */
unsigned int rq_fsoftlimit; /* preferred file limit */
unsigned int rq_curfiles; /* current # allocated files */
unsigned int rq_btimeleft; /* time left for excessive disk use */
unsigned int rq_ftimeleft; /* time left for excessive files */
};
enum gqr_status {
Q_OK = 1, /* quota returned */
Q_NOQUOTA = 2, /* noquota for uid */
Q_EPERM = 3 /* no permission to access quota */
};
union getquota_rslt switch (gqr_status status) {
case Q_OK:
rquota gqr_rquota; /* valid if status == Q_OK */
case Q_NOQUOTA:
void;
case Q_EPERM:
void;
};
program RQUOTAPROG {
version RQUOTAVERS {
/*
* Get all quotas
*/
getquota_rslt
RQUOTAPROC_GETQUOTA(getquota_args) = 1;
/*
* Get active quotas only
*/
getquota_rslt
RQUOTAPROC_GETACTIVEQUOTA(getquota_args) = 2;
} = 1;
} = 100011;

145
sunrpc/rpcsvc/rstat.x
View File

@ -1,145 +0,0 @@
/* @(#)rstat.x 2.2 88/08/01 4.0 RPCSRC */
/*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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.
*/
/*
* Gather statistics on remote machines
*/
#ifdef RPC_HDR
%#ifndef FSCALE
%/*
% * Scale factor for scaled integers used to count load averages.
% */
%#define FSHIFT 8 /* bits to right of fixed binary point */
%#define FSCALE (1<<FSHIFT)
%
%#endif /* ndef FSCALE */
#endif /* def RPC_HDR */
const CPUSTATES = 4;
const DK_NDRIVE = 4;
/*
* GMT since 0:00, January 1, 1970
*/
struct rstat_timeval {
unsigned int tv_sec; /* seconds */
unsigned int tv_usec; /* and microseconds */
};
struct statstime { /* RSTATVERS_TIME */
int cp_time[CPUSTATES];
int dk_xfer[DK_NDRIVE];
unsigned int v_pgpgin; /* these are cumulative sum */
unsigned int v_pgpgout;
unsigned int v_pswpin;
unsigned int v_pswpout;
unsigned int v_intr;
int if_ipackets;
int if_ierrors;
int if_oerrors;
int if_collisions;
unsigned int v_swtch;
int avenrun[3]; /* scaled by FSCALE */
rstat_timeval boottime;
rstat_timeval curtime;
int if_opackets;
};
struct statsswtch { /* RSTATVERS_SWTCH */
int cp_time[CPUSTATES];
int dk_xfer[DK_NDRIVE];
unsigned int v_pgpgin; /* these are cumulative sum */
unsigned int v_pgpgout;
unsigned int v_pswpin;
unsigned int v_pswpout;
unsigned int v_intr;
int if_ipackets;
int if_ierrors;
int if_oerrors;
int if_collisions;
unsigned int v_swtch;
unsigned int avenrun[3];/* scaled by FSCALE */
rstat_timeval boottime;
int if_opackets;
};
struct stats { /* RSTATVERS_ORIG */
int cp_time[CPUSTATES];
int dk_xfer[DK_NDRIVE];
unsigned int v_pgpgin; /* these are cumulative sum */
unsigned int v_pgpgout;
unsigned int v_pswpin;
unsigned int v_pswpout;
unsigned int v_intr;
int if_ipackets;
int if_ierrors;
int if_oerrors;
int if_collisions;
int if_opackets;
};
program RSTATPROG {
/*
* Newest version includes current time and context switching info
*/
version RSTATVERS_TIME {
statstime
RSTATPROC_STATS(void) = 1;
unsigned int
RSTATPROC_HAVEDISK(void) = 2;
} = 3;
/*
* Does not have current time
*/
version RSTATVERS_SWTCH {
statsswtch
RSTATPROC_STATS(void) = 1;
unsigned int
RSTATPROC_HAVEDISK(void) = 2;
} = 2;
/*
* Old version has no info about current time or context switching
*/
version RSTATVERS_ORIG {
stats
RSTATPROC_STATS(void) = 1;
unsigned int
RSTATPROC_HAVEDISK(void) = 2;
} = 1;
} = 100001;

228
sunrpc/rpcsvc/rusers.x
View File

@ -1,228 +0,0 @@
/*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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.
*/
%/*
% * Find out about remote users
% */
const RUSERS_MAXUSERLEN = 32;
const RUSERS_MAXLINELEN = 32;
const RUSERS_MAXHOSTLEN = 257;
struct rusers_utmp {
string ut_user<RUSERS_MAXUSERLEN>; /* aka ut_name */
string ut_line<RUSERS_MAXLINELEN>; /* device */
string ut_host<RUSERS_MAXHOSTLEN>; /* host user logged on from */
int ut_type; /* type of entry */
int ut_time; /* time entry was made */
unsigned int ut_idle; /* minutes idle */
};
typedef rusers_utmp utmp_array<>;
#ifdef RPC_HDR
%
%/*
% * Values for ut_type field above.
% */
#endif
const RUSERS_EMPTY = 0;
const RUSERS_RUN_LVL = 1;
const RUSERS_BOOT_TIME = 2;
const RUSERS_OLD_TIME = 3;
const RUSERS_NEW_TIME = 4;
const RUSERS_INIT_PROCESS = 5;
const RUSERS_LOGIN_PROCESS = 6;
const RUSERS_USER_PROCESS = 7;
const RUSERS_DEAD_PROCESS = 8;
const RUSERS_ACCOUNTING = 9;
program RUSERSPROG {
version RUSERSVERS_3 {
int
RUSERSPROC_NUM(void) = 1;
utmp_array
RUSERSPROC_NAMES(void) = 2;
utmp_array
RUSERSPROC_ALLNAMES(void) = 3;
} = 3;
} = 100002;
#ifdef RPC_HDR
%
%
%#ifdef __cplusplus
%extern "C" {
%#endif
%
%#include <rpc/xdr.h>
%
%/*
% * The following structures are used by version 2 of the rusersd protocol.
% * They were not developed with rpcgen, so they do not appear as RPCL.
% */
%
%#define RUSERSVERS_IDLE 2
%#define RUSERSVERS 3 /* current version */
%#define MAXUSERS 100
%
%/*
% * This is the structure used in version 2 of the rusersd RPC service.
% * It corresponds to the utmp structure for BSD systems.
% */
%struct ru_utmp {
% char ut_line[8]; /* tty name */
% char ut_name[8]; /* user id */
% char ut_host[16]; /* host name, if remote */
% long int ut_time; /* time on */
%};
%
%struct utmparr {
% struct ru_utmp **uta_arr;
% int uta_cnt;
%};
%typedef struct utmparr utmparr;
%
%extern bool_t xdr_utmparr (XDR *xdrs, struct utmparr *objp) __THROW;
%
%struct utmpidle {
% struct ru_utmp ui_utmp;
% unsigned int ui_idle;
%};
%
%struct utmpidlearr {
% struct utmpidle **uia_arr;
% int uia_cnt;
%};
%
%extern bool_t xdr_utmpidlearr (XDR *xdrs, struct utmpidlearr *objp) __THROW;
%
%#ifdef __cplusplus
%}
%#endif
#endif
#ifdef RPC_XDR
%bool_t xdr_utmp (XDR *xdrs, struct ru_utmp *objp);
%
%bool_t
%xdr_utmp (XDR *xdrs, struct ru_utmp *objp)
%{
% /* Since the fields are char foo [xxx], we should not free them. */
% if (xdrs->x_op != XDR_FREE)
% {
% char *ptr;
% unsigned int size;
% ptr = objp->ut_line;
% size = sizeof (objp->ut_line);
% if (!xdr_bytes (xdrs, &ptr, &size, size)) {
% return (FALSE);
% }
% ptr = objp->ut_name;
% size = sizeof (objp->ut_name);
% if (!xdr_bytes (xdrs, &ptr, &size, size)) {
% return (FALSE);
% }
% ptr = objp->ut_host;
% size = sizeof (objp->ut_host);
% if (!xdr_bytes (xdrs, &ptr, &size, size)) {
% return (FALSE);
% }
% }
% if (!xdr_long(xdrs, &objp->ut_time)) {
% return (FALSE);
% }
% return (TRUE);
%}
%
%bool_t xdr_utmpptr(XDR *xdrs, struct ru_utmp **objpp);
%
%bool_t
%xdr_utmpptr (XDR *xdrs, struct ru_utmp **objpp)
%{
% if (!xdr_reference(xdrs, (char **) objpp, sizeof (struct ru_utmp),
% (xdrproc_t) xdr_utmp)) {
% return (FALSE);
% }
% return (TRUE);
%}
%
%bool_t
%xdr_utmparr (XDR *xdrs, struct utmparr *objp)
%{
% if (!xdr_array(xdrs, (char **)&objp->uta_arr, (u_int *)&objp->uta_cnt,
% MAXUSERS, sizeof(struct ru_utmp *),
% (xdrproc_t) xdr_utmpptr)) {
% return (FALSE);
% }
% return (TRUE);
%}
%
%bool_t xdr_utmpidle(XDR *xdrs, struct utmpidle *objp);
%
%bool_t
%xdr_utmpidle (XDR *xdrs, struct utmpidle *objp)
%{
% if (!xdr_utmp(xdrs, &objp->ui_utmp)) {
% return (FALSE);
% }
% if (!xdr_u_int(xdrs, &objp->ui_idle)) {
% return (FALSE);
% }
% return (TRUE);
%}
%
%bool_t xdr_utmpidleptr(XDR *xdrs, struct utmpidle **objp);
%
%bool_t
%xdr_utmpidleptr (XDR *xdrs, struct utmpidle **objpp)
%{
% if (!xdr_reference(xdrs, (char **) objpp, sizeof (struct utmpidle),
% (xdrproc_t) xdr_utmpidle)) {
% return (FALSE);
% }
% return (TRUE);
%}
%
%bool_t
%xdr_utmpidlearr (XDR *xdrs, struct utmpidlearr *objp)
%{
% if (!xdr_array(xdrs, (char **)&objp->uia_arr, (u_int *)&objp->uia_cnt,
% MAXUSERS, sizeof(struct utmpidle *),
% (xdrproc_t) xdr_utmpidleptr)) {
% return (FALSE);
% }
% return (TRUE);
%}
#endif

110
sunrpc/rpcsvc/sm_inter.x
View File

@ -1,110 +0,0 @@
/*
* Status monitor protocol specification
* Copyright (c) 2010, Oracle America, Inc.
*
* 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 the "Oracle America, 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.
*/
program SM_PROG {
version SM_VERS {
/* res_stat = stat_succ if status monitor agrees to monitor */
/* res_stat = stat_fail if status monitor cannot monitor */
/* if res_stat == stat_succ, state = state number of site sm_name */
struct sm_stat_res SM_STAT(struct sm_name) = 1;
/* res_stat = stat_succ if status monitor agrees to monitor */
/* res_stat = stat_fail if status monitor cannot monitor */
/* stat consists of state number of local site */
struct sm_stat_res SM_MON(struct mon) = 2;
/* stat consists of state number of local site */
struct sm_stat SM_UNMON(struct mon_id) = 3;
/* stat consists of state number of local site */
struct sm_stat SM_UNMON_ALL(struct my_id) = 4;
void SM_SIMU_CRASH(void) = 5;
} = 1;
} = 100024;
const SM_MAXSTRLEN = 1024;
struct sm_name {
string mon_name<SM_MAXSTRLEN>;
};
struct my_id {
string my_name<SM_MAXSTRLEN>; /* name of the site initiating the monitoring request*/
int my_prog; /* rpc program # of the requesting process */
int my_vers; /* rpc version # of the requesting process */
int my_proc; /* rpc procedure # of the requesting process */
};
struct mon_id {
string mon_name<SM_MAXSTRLEN>; /* name of the site to be monitored */
struct my_id my_id;
};
struct mon{
struct mon_id mon_id;
opaque priv[16]; /* private information to store at monitor for requesting process */
};
/*
* state # of status monitor monotonically increases each time
* status of the site changes:
* an even number (>= 0) indicates the site is down and
* an odd number (> 0) indicates the site is up;
*/
struct sm_stat {
int state; /* state # of status monitor */
};
enum res {
stat_succ = 0, /* status monitor agrees to monitor */
stat_fail = 1 /* status monitor cannot monitor */
};
struct sm_stat_res {
res res_stat;
int state;
};
/*
* structure of the status message sent back by the status monitor
* when monitor site status changes
*/
struct status {
string mon_name<SM_MAXSTRLEN>;
int state;
opaque priv[16]; /* stored private information */
};

84
sunrpc/rpcsvc/spray.x
View File

@ -1,84 +0,0 @@
/* @(#)spray.x 2.1 88/08/01 4.0 RPCSRC */
/*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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.
*/
/*
* Spray a server with packets
* Useful for testing flakiness of network interfaces
*/
const SPRAYMAX = 8845; /* max amount can spray */
/*
* GMT since 0:00, 1 January 1970
*/
struct spraytimeval {
unsigned int sec;
unsigned int usec;
};
/*
* spray statistics
*/
struct spraycumul {
unsigned int counter;
spraytimeval clock;
};
/*
* spray data
*/
typedef opaque sprayarr<SPRAYMAX>;
program SPRAYPROG {
version SPRAYVERS {
/*
* Just throw away the data and increment the counter
* This call never returns, so the client should always
* time it out.
*/
void
SPRAYPROC_SPRAY(sprayarr) = 1;
/*
* Get the value of the counter and elapsed time since
* last CLEAR.
*/
spraycumul
SPRAYPROC_GET(void) = 2;
/*
* Clear the counter and reset the elapsed time
*/
void
SPRAYPROC_CLEAR(void) = 3;
} = 1;
} = 100012;

61
sunrpc/rpcsvc/yppasswd.x
View File

@ -1,61 +0,0 @@
/* @(#)yppasswd.x 2.1 88/08/01 4.0 RPCSRC */
/*
* Copyright (c) 2010, Oracle America, Inc.
* 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 the "Oracle America, 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.
*/
/*
* YP password update protocol
* Requires unix authentication
*/
program YPPASSWDPROG {
version YPPASSWDVERS {
/*
* Update my passwd entry
*/
int
YPPASSWDPROC_UPDATE(yppasswd) = 1;
} = 1;
} = 100009;
struct passwd {
string pw_name<>; /* username */
string pw_passwd<>; /* encrypted password */
int pw_uid; /* user id */
int pw_gid; /* group id */
string pw_gecos<>; /* in real life name */
string pw_dir<>; /* home directory */
string pw_shell<>; /* default shell */
};
struct yppasswd {
string oldpass<>; /* unencrypted old password */
passwd newpw; /* new passwd entry */
};

162
sysdeps/unix/sysv/linux/arc/libc.abilist
View File

@ -265,9 +265,6 @@ GLIBC_2.32 __iswupper_l F
GLIBC_2.32 __iswxdigit_l F
GLIBC_2.32 __isxdigit_l F
GLIBC_2.32 __ivaliduser F
GLIBC_2.32 __key_decryptsession_pk_LOCAL D 0x4
GLIBC_2.32 __key_encryptsession_pk_LOCAL D 0x4
GLIBC_2.32 __key_gendes_LOCAL D 0x4
GLIBC_2.32 __libc_allocate_rtsig F
GLIBC_2.32 __libc_calloc F
GLIBC_2.32 __libc_current_sigrtmax F
@ -348,10 +345,6 @@ GLIBC_2.32 __res_nclose F
GLIBC_2.32 __res_ninit F
GLIBC_2.32 __res_randomid F
GLIBC_2.32 __res_state F
GLIBC_2.32 __rpc_thread_createerr F
GLIBC_2.32 __rpc_thread_svc_fdset F
GLIBC_2.32 __rpc_thread_svc_max_pollfd F
GLIBC_2.32 __rpc_thread_svc_pollfd F
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 __sbrk F
GLIBC_2.32 __sched_cpualloc F
@ -494,7 +487,6 @@ GLIBC_2.32 __xpg_sigpause F
GLIBC_2.32 __xpg_strerror_r F
GLIBC_2.32 __xstat F
GLIBC_2.32 __xstat64 F
GLIBC_2.32 _authenticate F
GLIBC_2.32 _dl_mcount_wrapper F
GLIBC_2.32 _dl_mcount_wrapper_check F
GLIBC_2.32 _environ D 0x4
@ -508,7 +500,6 @@ GLIBC_2.32 _mcount F
GLIBC_2.32 _nl_default_dirname D 0x12
GLIBC_2.32 _nl_domain_bindings D 0x4
GLIBC_2.32 _nl_msg_cat_cntr D 0x4
GLIBC_2.32 _null_auth D 0xc
GLIBC_2.32 _obstack_allocated_p F
GLIBC_2.32 _obstack_begin F
GLIBC_2.32 _obstack_begin_1 F
@ -517,8 +508,6 @@ GLIBC_2.32 _obstack_memory_used F
GLIBC_2.32 _obstack_newchunk F
GLIBC_2.32 _res D 0x200
GLIBC_2.32 _res_hconf D 0x30
GLIBC_2.32 _rpc_dtablesize F
GLIBC_2.32 _seterr_reply F
GLIBC_2.32 _setjmp F
GLIBC_2.32 _tolower F
GLIBC_2.32 _toupper F
@ -566,12 +555,6 @@ GLIBC_2.32 atof F
GLIBC_2.32 atoi F
GLIBC_2.32 atol F
GLIBC_2.32 atoll F
GLIBC_2.32 authdes_create F
GLIBC_2.32 authdes_getucred F
GLIBC_2.32 authdes_pk_create F
GLIBC_2.32 authnone_create F
GLIBC_2.32 authunix_create F
GLIBC_2.32 authunix_create_default F
GLIBC_2.32 backtrace F
GLIBC_2.32 backtrace_symbols F
GLIBC_2.32 backtrace_symbols_fd F
@ -591,14 +574,12 @@ GLIBC_2.32 c16rtomb F
GLIBC_2.32 c32rtomb F
GLIBC_2.32 cacheflush F
GLIBC_2.32 calloc F
GLIBC_2.32 callrpc F
GLIBC_2.32 canonicalize_file_name F
GLIBC_2.32 capget F
GLIBC_2.32 capset F
GLIBC_2.32 catclose F
GLIBC_2.32 catgets F
GLIBC_2.32 catopen F
GLIBC_2.32 cbc_crypt F
GLIBC_2.32 cfgetispeed F
GLIBC_2.32 cfgetospeed F
GLIBC_2.32 cfmakeraw F
@ -613,19 +594,6 @@ GLIBC_2.32 chroot F
GLIBC_2.32 clearenv F
GLIBC_2.32 clearerr F
GLIBC_2.32 clearerr_unlocked F
GLIBC_2.32 clnt_broadcast F
GLIBC_2.32 clnt_create F
GLIBC_2.32 clnt_pcreateerror F
GLIBC_2.32 clnt_perrno F
GLIBC_2.32 clnt_perror F
GLIBC_2.32 clnt_spcreateerror F
GLIBC_2.32 clnt_sperrno F
GLIBC_2.32 clnt_sperror F
GLIBC_2.32 clntraw_create F
GLIBC_2.32 clnttcp_create F
GLIBC_2.32 clntudp_bufcreate F
GLIBC_2.32 clntudp_create F
GLIBC_2.32 clntunix_create F
GLIBC_2.32 clock F
GLIBC_2.32 clock_adjtime F
GLIBC_2.32 clock_getcpuclockid F
@ -654,7 +622,6 @@ GLIBC_2.32 daylight D 0x4
GLIBC_2.32 dcgettext F
GLIBC_2.32 dcngettext F
GLIBC_2.32 delete_module F
GLIBC_2.32 des_setparity F
GLIBC_2.32 dgettext F
GLIBC_2.32 difftime F
GLIBC_2.32 dirfd F
@ -671,7 +638,6 @@ GLIBC_2.32 dup3 F
GLIBC_2.32 duplocale F
GLIBC_2.32 dysize F
GLIBC_2.32 eaccess F
GLIBC_2.32 ecb_crypt F
GLIBC_2.32 ecvt F
GLIBC_2.32 ecvt_r F
GLIBC_2.32 endaliasent F
@ -863,7 +829,6 @@ GLIBC_2.32 gai_strerror F
GLIBC_2.32 gcvt F
GLIBC_2.32 get_avphys_pages F
GLIBC_2.32 get_current_dir_name F
GLIBC_2.32 get_myaddress F
GLIBC_2.32 get_nprocs F
GLIBC_2.32 get_nprocs_conf F
GLIBC_2.32 get_phys_pages F
@ -933,7 +898,6 @@ GLIBC_2.32 getnetent F
GLIBC_2.32 getnetent_r F
GLIBC_2.32 getnetgrent F
GLIBC_2.32 getnetgrent_r F
GLIBC_2.32 getnetname F
GLIBC_2.32 getopt F
GLIBC_2.32 getopt_long F
GLIBC_2.32 getopt_long_only F
@ -952,7 +916,6 @@ GLIBC_2.32 getprotobynumber_r F
GLIBC_2.32 getprotoent F
GLIBC_2.32 getprotoent_r F
GLIBC_2.32 getpt F
GLIBC_2.32 getpublickey F
GLIBC_2.32 getpw F
GLIBC_2.32 getpwent F
GLIBC_2.32 getpwent_r F
@ -971,10 +934,8 @@ GLIBC_2.32 getrpcbynumber F
GLIBC_2.32 getrpcbynumber_r F
GLIBC_2.32 getrpcent F
GLIBC_2.32 getrpcent_r F
GLIBC_2.32 getrpcport F
GLIBC_2.32 getrusage F
GLIBC_2.32 gets F
GLIBC_2.32 getsecretkey F
GLIBC_2.32 getservbyname F
GLIBC_2.32 getservbyname_r F
GLIBC_2.32 getservbyport F
@ -1043,7 +1004,6 @@ GLIBC_2.32 hcreate_r F
GLIBC_2.32 hdestroy F
GLIBC_2.32 hdestroy_r F
GLIBC_2.32 herror F
GLIBC_2.32 host2netname F
GLIBC_2.32 hsearch F
GLIBC_2.32 hsearch_r F
GLIBC_2.32 hstrerror F
@ -1166,15 +1126,6 @@ GLIBC_2.32 isxdigit F
GLIBC_2.32 isxdigit_l F
GLIBC_2.32 jrand48 F
GLIBC_2.32 jrand48_r F
GLIBC_2.32 key_decryptsession F
GLIBC_2.32 key_decryptsession_pk F
GLIBC_2.32 key_encryptsession F
GLIBC_2.32 key_encryptsession_pk F
GLIBC_2.32 key_gendes F
GLIBC_2.32 key_get_conv F
GLIBC_2.32 key_secretkey_is_set F
GLIBC_2.32 key_setnet F
GLIBC_2.32 key_setsecret F
GLIBC_2.32 kill F
GLIBC_2.32 killpg F
GLIBC_2.32 klogctl F
@ -1291,8 +1242,6 @@ GLIBC_2.32 munmap F
GLIBC_2.32 muntrace F
GLIBC_2.32 name_to_handle_at F
GLIBC_2.32 nanosleep F
GLIBC_2.32 netname2host F
GLIBC_2.32 netname2user F
GLIBC_2.32 newlocale F
GLIBC_2.32 nftw F
GLIBC_2.32 nftw64 F
@ -1327,7 +1276,6 @@ GLIBC_2.32 opterr D 0x4
GLIBC_2.32 optind D 0x4
GLIBC_2.32 optopt D 0x4
GLIBC_2.32 parse_printf_format F
GLIBC_2.32 passwd2des F
GLIBC_2.32 pathconf F
GLIBC_2.32 pause F
GLIBC_2.32 pclose F
@ -1341,11 +1289,6 @@ GLIBC_2.32 pkey_free F
GLIBC_2.32 pkey_get F
GLIBC_2.32 pkey_mprotect F
GLIBC_2.32 pkey_set F
GLIBC_2.32 pmap_getmaps F
GLIBC_2.32 pmap_getport F
GLIBC_2.32 pmap_rmtcall F
GLIBC_2.32 pmap_set F
GLIBC_2.32 pmap_unset F
GLIBC_2.32 poll F
GLIBC_2.32 popen F
GLIBC_2.32 posix_fadvise F
@ -1516,7 +1459,6 @@ GLIBC_2.32 register_printf_function F
GLIBC_2.32 register_printf_modifier F
GLIBC_2.32 register_printf_specifier F
GLIBC_2.32 register_printf_type F
GLIBC_2.32 registerrpc F
GLIBC_2.32 remap_file_pages F
GLIBC_2.32 remove F
GLIBC_2.32 removexattr F
@ -1532,11 +1474,9 @@ GLIBC_2.32 rexec_af F
GLIBC_2.32 rexecoptions D 0x4
GLIBC_2.32 rindex F
GLIBC_2.32 rmdir F
GLIBC_2.32 rpc_createerr D 0x10
GLIBC_2.32 rpmatch F
GLIBC_2.32 rresvport F
GLIBC_2.32 rresvport_af F
GLIBC_2.32 rtime F
GLIBC_2.32 ruserok F
GLIBC_2.32 ruserok_af F
GLIBC_2.32 ruserpass F
@ -1772,34 +1712,6 @@ GLIBC_2.32 strverscmp F
GLIBC_2.32 strxfrm F
GLIBC_2.32 strxfrm_l F
GLIBC_2.32 stty F
GLIBC_2.32 svc_exit F
GLIBC_2.32 svc_fdset D 0x80
GLIBC_2.32 svc_getreq F
GLIBC_2.32 svc_getreq_common F
GLIBC_2.32 svc_getreq_poll F
GLIBC_2.32 svc_getreqset F
GLIBC_2.32 svc_max_pollfd D 0x4
GLIBC_2.32 svc_pollfd D 0x4
GLIBC_2.32 svc_register F
GLIBC_2.32 svc_run F
GLIBC_2.32 svc_sendreply F
GLIBC_2.32 svc_unregister F
GLIBC_2.32 svcauthdes_stats D 0xc
GLIBC_2.32 svcerr_auth F
GLIBC_2.32 svcerr_decode F
GLIBC_2.32 svcerr_noproc F
GLIBC_2.32 svcerr_noprog F
GLIBC_2.32 svcerr_progvers F
GLIBC_2.32 svcerr_systemerr F
GLIBC_2.32 svcerr_weakauth F
GLIBC_2.32 svcfd_create F
GLIBC_2.32 svcraw_create F
GLIBC_2.32 svctcp_create F
GLIBC_2.32 svcudp_bufcreate F
GLIBC_2.32 svcudp_create F
GLIBC_2.32 svcudp_enablecache F
GLIBC_2.32 svcunix_create F
GLIBC_2.32 svcunixfd_create F
GLIBC_2.32 swab F
GLIBC_2.32 swapcontext F
GLIBC_2.32 swapoff F
@ -1890,7 +1802,6 @@ GLIBC_2.32 unshare F
GLIBC_2.32 updwtmp F
GLIBC_2.32 updwtmpx F
GLIBC_2.32 uselocale F
GLIBC_2.32 user2netname F
GLIBC_2.32 usleep F
GLIBC_2.32 utime F
GLIBC_2.32 utimensat F
@ -2010,76 +1921,3 @@ GLIBC_2.32 wprintf F
GLIBC_2.32 write F
GLIBC_2.32 writev F
GLIBC_2.32 wscanf F
GLIBC_2.32 xdecrypt F
GLIBC_2.32 xdr_accepted_reply F
GLIBC_2.32 xdr_array F
GLIBC_2.32 xdr_authdes_cred F
GLIBC_2.32 xdr_authdes_verf F
GLIBC_2.32 xdr_authunix_parms F
GLIBC_2.32 xdr_bool F
GLIBC_2.32 xdr_bytes F
GLIBC_2.32 xdr_callhdr F
GLIBC_2.32 xdr_callmsg F
GLIBC_2.32 xdr_char F
GLIBC_2.32 xdr_cryptkeyarg F
GLIBC_2.32 xdr_cryptkeyarg2 F
GLIBC_2.32 xdr_cryptkeyres F
GLIBC_2.32 xdr_des_block F
GLIBC_2.32 xdr_double F
GLIBC_2.32 xdr_enum F
GLIBC_2.32 xdr_float F
GLIBC_2.32 xdr_free F
GLIBC_2.32 xdr_getcredres F
GLIBC_2.32 xdr_hyper F
GLIBC_2.32 xdr_int F
GLIBC_2.32 xdr_int16_t F
GLIBC_2.32 xdr_int32_t F
GLIBC_2.32 xdr_int64_t F
GLIBC_2.32 xdr_int8_t F
GLIBC_2.32 xdr_key_netstarg F
GLIBC_2.32 xdr_key_netstres F
GLIBC_2.32 xdr_keybuf F
GLIBC_2.32 xdr_keystatus F
GLIBC_2.32 xdr_long F
GLIBC_2.32 xdr_longlong_t F
GLIBC_2.32 xdr_netnamestr F
GLIBC_2.32 xdr_netobj F
GLIBC_2.32 xdr_opaque F
GLIBC_2.32 xdr_opaque_auth F
GLIBC_2.32 xdr_pmap F
GLIBC_2.32 xdr_pmaplist F
GLIBC_2.32 xdr_pointer F
GLIBC_2.32 xdr_quad_t F
GLIBC_2.32 xdr_reference F
GLIBC_2.32 xdr_rejected_reply F
GLIBC_2.32 xdr_replymsg F
GLIBC_2.32 xdr_rmtcall_args F
GLIBC_2.32 xdr_rmtcallres F
GLIBC_2.32 xdr_short F
GLIBC_2.32 xdr_sizeof F
GLIBC_2.32 xdr_string F
GLIBC_2.32 xdr_u_char F
GLIBC_2.32 xdr_u_hyper F
GLIBC_2.32 xdr_u_int F
GLIBC_2.32 xdr_u_long F
GLIBC_2.32 xdr_u_longlong_t F
GLIBC_2.32 xdr_u_quad_t F
GLIBC_2.32 xdr_u_short F
GLIBC_2.32 xdr_uint16_t F
GLIBC_2.32 xdr_uint32_t F
GLIBC_2.32 xdr_uint64_t F
GLIBC_2.32 xdr_uint8_t F
GLIBC_2.32 xdr_union F
GLIBC_2.32 xdr_unixcred F
GLIBC_2.32 xdr_vector F
GLIBC_2.32 xdr_void F
GLIBC_2.32 xdr_wrapstring F
GLIBC_2.32 xdrmem_create F
GLIBC_2.32 xdrrec_create F
GLIBC_2.32 xdrrec_endofrecord F
GLIBC_2.32 xdrrec_eof F
GLIBC_2.32 xdrrec_skiprecord F
GLIBC_2.32 xdrstdio_create F
GLIBC_2.32 xencrypt F
GLIBC_2.32 xprt_register F
GLIBC_2.32 xprt_unregister F