From 9f6a77c541994322e7878c971302363b0a5e6180 Mon Sep 17 00:00:00 2001 From: Bill Paul Date: Tue, 31 Jan 1995 09:47:11 +0000 Subject: [PATCH] Obtained from: The NYS project This is a ported/modified version of the yppush program from the yps-0.21 package from the NYS project. This program is used to propagate updated NIS maps from an NIS master to an NIS slave. It's normally invoked by /var/yp/Makefile. This version of yppush has been modified in the following ways: - Cleared up several Linux/BSD incompatibilities, largely involving header files. - converted from GDBM to DB with extreme predjudice. (well, not really...) - removed lots of ugly debugging code that really didn't do anyone any good. - Fixed a couple of inaccurate/badly formatted error messages. - Renamed some functions to avoid collisions with certain YP routines hidden inside libc. - Small signal handling kludge: Linux has different struct sigaction that us. - Incorporated some functions from the yps-0.21 library that yppush was dependent on. Like ypxfr, this works, but could use come cleaning up. --- gnu/usr.bin/yppush/Makefile | 10 + gnu/usr.bin/yppush/yp.h | 292 +++++++++++++++++++++ gnu/usr.bin/yppush/yp_clnt.c | 216 +++++++++++++++ gnu/usr.bin/yppush/yp_xdr.c | 477 ++++++++++++++++++++++++++++++++++ gnu/usr.bin/yppush/ypclnt.c | 128 +++++++++ gnu/usr.bin/yppush/yppush.c | 373 ++++++++++++++++++++++++++ gnu/usr.bin/yppush/yppush_s.c | 156 +++++++++++ 7 files changed, 1652 insertions(+) create mode 100644 gnu/usr.bin/yppush/Makefile create mode 100644 gnu/usr.bin/yppush/yp.h create mode 100644 gnu/usr.bin/yppush/yp_clnt.c create mode 100644 gnu/usr.bin/yppush/yp_xdr.c create mode 100644 gnu/usr.bin/yppush/ypclnt.c create mode 100644 gnu/usr.bin/yppush/yppush.c create mode 100644 gnu/usr.bin/yppush/yppush_s.c diff --git a/gnu/usr.bin/yppush/Makefile b/gnu/usr.bin/yppush/Makefile new file mode 100644 index 000000000000..0306b627e2ab --- /dev/null +++ b/gnu/usr.bin/yppush/Makefile @@ -0,0 +1,10 @@ + +PROG= yppush +MAN8= + +SRCS= yppush.c yppush_s.c yp_clnt.c yp_xdr.c ypclnt.c + +BINOWN= bin +BINMODE=555 + +.include diff --git a/gnu/usr.bin/yppush/yp.h b/gnu/usr.bin/yppush/yp.h new file mode 100644 index 000000000000..da300d4cfc6b --- /dev/null +++ b/gnu/usr.bin/yppush/yp.h @@ -0,0 +1,292 @@ +/* + * $Id$ + */ + +#define YPMAXRECORD 1024 +#define YPMAXDOMAIN 64 +#define YPMAXMAP 64 +#define YPMAXPEER 64 + +enum ypstat { + YP_TRUE = 1, + YP_NOMORE = 2, + YP_FALSE = 0, + YP_NOMAP = -1, + YP_NODOM = -2, + YP_NOKEY = -3, + YP_BADOP = -4, + YP_BADDB = -5, + YP_YPERR = -6, + YP_BADARGS = -7, + YP_VERS = -8, +}; +typedef enum ypstat ypstat; +bool_t __xdr_ypstat(); + + +enum ypxfrstat { + YPXFR_SUCC = 1, + YPXFR_AGE = 2, + YPXFR_NOMAP = -1, + YPXFR_NODOM = -2, + YPXFR_RSRC = -3, + YPXFR_RPC = -4, + YPXFR_MADDR = -5, + YPXFR_YPERR = -6, + YPXFR_BADARGS = -7, + YPXFR_DBM = -8, + YPXFR_FILE = -9, + YPXFR_SKEW = -10, + YPXFR_CLEAR = -11, + YPXFR_FORCE = -12, + YPXFR_XFRERR = -13, + YPXFR_REFUSED = -14, +}; +typedef enum ypxfrstat ypxfrstat; +bool_t __xdr_ypxfrstat(); + + +typedef char *domainname; +bool_t xdr_domainname(); + + +typedef char *mapname; +bool_t xdr_mapname(); + + +typedef char *peername; +bool_t xdr_peername(); + + +typedef struct { + u_int keydat_len; + char *keydat_val; +} keydat; +bool_t xdr_keydat(); + + +typedef struct { + u_int valdat_len; + char *valdat_val; +} valdat; +bool_t xdr_valdat(); + + +struct ypmap_parms { + domainname domain; + mapname map; + u_int ordernum; + peername peer; +}; +typedef struct ypmap_parms ypmap_parms; +bool_t __xdr_ypmap_parms(); + + +struct ypreq_key { + domainname domain; + mapname map; + keydat key; +}; +typedef struct ypreq_key ypreq_key; +bool_t __xdr_ypreq_key(); + + +struct ypreq_nokey { + domainname domain; + mapname map; +}; +typedef struct ypreq_nokey ypreq_nokey; +bool_t __xdr_ypreq_nokey(); + + +struct ypreq_xfr { + ypmap_parms map_parms; + u_int transid; + u_int prog; + u_int port; +}; +typedef struct ypreq_xfr ypreq_xfr; +bool_t __xdr_ypreq_xfr(); + + +struct ypresp_val { + ypstat stat; + valdat val; +}; +typedef struct ypresp_val ypresp_val; +bool_t __xdr_ypresp_val(); + + +struct ypresp_key_val { + ypstat stat; + keydat key; + valdat val; +}; +typedef struct ypresp_key_val ypresp_key_val; +bool_t __xdr_ypresp_key_val(); + + +struct ypresp_master { + ypstat stat; + peername peer; +}; +typedef struct ypresp_master ypresp_master; +bool_t __xdr_ypresp_master(); + + +struct ypresp_order { + ypstat stat; + u_int ordernum; +}; +typedef struct ypresp_order ypresp_order; +bool_t __xdr_ypresp_order(); + + +struct ypresp_all { + bool_t more; + union { + ypresp_key_val val; + } ypresp_all_u; +}; +typedef struct ypresp_all ypresp_all; +bool_t __xdr_ypresp_all(); + + +struct ypresp_xfr { + u_int transid; + ypxfrstat xfrstat; +}; +typedef struct ypresp_xfr ypresp_xfr; +bool_t __xdr_ypresp_xfr(); + + +struct ypmaplist { + mapname map; + struct ypmaplist *next; +}; +typedef struct ypmaplist ypmaplist; +bool_t __xdr_ypmaplist(); + + +struct ypresp_maplist { + ypstat stat; + ypmaplist *maps; +}; +typedef struct ypresp_maplist ypresp_maplist; +bool_t __xdr_ypresp_maplist(); + + +enum yppush_status { + YPPUSH_SUCC = 1, + YPPUSH_AGE = 2, + YPPUSH_NOMAP = -1, + YPPUSH_NODOM = -2, + YPPUSH_RSRC = -3, + YPPUSH_RPC = -4, + YPPUSH_MADDR = -5, + YPPUSH_YPERR = -6, + YPPUSH_BADARGS = -7, + YPPUSH_DBM = -8, + YPPUSH_FILE = -9, + YPPUSH_SKEW = -10, + YPPUSH_CLEAR = -11, + YPPUSH_FORCE = -12, + YPPUSH_XFRERR = -13, + YPPUSH_REFUSED = -14, +}; +typedef enum yppush_status yppush_status; +bool_t __xdr_yppush_status(); + + +struct yppushresp_xfr { + u_int transid; + yppush_status status; +}; +typedef struct yppushresp_xfr yppushresp_xfr; +bool_t __xdr_yppushresp_xfr(); + + +enum ypbind_resptype { + YPBIND_SUCC_VAL = 1, + YPBIND_FAIL_VAL = 2, +}; +typedef enum ypbind_resptype ypbind_resptype; +bool_t __xdr_ypbind_resptype(); + + +struct ypbind_binding { + char ypbind_binding_addr[4]; + char ypbind_binding_port[2]; +}; +typedef struct ypbind_binding ypbind_binding; +bool_t __xdr_ypbind_binding(); + + +struct ypbind_resp { + ypbind_resptype ypbind_status; + union { + u_int ypbind_error; + ypbind_binding ypbind_bindinfo; + } ypbind_resp_u; +}; +typedef struct ypbind_resp ypbind_resp; +bool_t __xdr_ypbind_resp(); + +#define YPBIND_ERR_ERR 1 +#define YPBIND_ERR_NOSERV 2 +#define YPBIND_ERR_RESC 3 + +struct ypbind_setdom { + domainname ypsetdom_domain; + ypbind_binding ypsetdom_binding; + u_int ypsetdom_vers; +}; +typedef struct ypbind_setdom ypbind_setdom; +bool_t __xdr_ypbind_setdom(); + + +#define YPPROG ((u_long)100004) +#define YPVERS ((u_long)2) +#define YPPROC_NULL ((u_long)0) +extern void *ypproc_null_2(); +#define YPPROC_DOMAIN ((u_long)1) +extern bool_t *ypproc_domain_2(); +#define YPPROC_DOMAIN_NONACK ((u_long)2) +extern bool_t *ypproc_domain_nonack_2(); +#define YPPROC_MATCH ((u_long)3) +extern ypresp_val *ypproc_match_2(); +#define YPPROC_FIRST ((u_long)4) +extern ypresp_key_val *ypproc_first_2(); +#define YPPROC_NEXT ((u_long)5) +extern ypresp_key_val *ypproc_next_2(); +#define YPPROC_XFR ((u_long)6) +extern ypresp_xfr *ypproc_xfr_2(); +#define YPPROC_CLEAR ((u_long)7) +extern void *ypproc_clear_2(); +#define YPPROC_ALL ((u_long)8) +extern ypresp_all *ypproc_all_2(); +#define YPPROC_MASTER ((u_long)9) +extern ypresp_master *ypproc_master_2(); +#define YPPROC_ORDER ((u_long)10) +extern ypresp_order *ypproc_order_2(); +#define YPPROC_MAPLIST ((u_long)11) +extern ypresp_maplist *ypproc_maplist_2(); + + +#define YPPUSH_XFRRESPPROG ((u_long)0x40000000) +#define YPPUSH_XFRRESPVERS ((u_long)1) +#define YPPUSHPROC_NULL ((u_long)0) +extern void *yppushproc_null_1(); +#define YPPUSHPROC_XFRRESP ((u_long)1) +extern yppushresp_xfr *yppushproc_xfrresp_1(); + + +#define YPBINDPROG ((u_long)100007) +#define YPBINDVERS ((u_long)2) +#define YPBINDPROC_NULL ((u_long)0) +extern void *ypbindproc_null_2(); +#define YPBINDPROC_DOMAIN ((u_long)1) +extern ypbind_resp *ypbindproc_domain_2(); +#define YPBINDPROC_SETDOM ((u_long)2) +extern void *ypbindproc_setdom_2(); + diff --git a/gnu/usr.bin/yppush/yp_clnt.c b/gnu/usr.bin/yppush/yp_clnt.c new file mode 100644 index 000000000000..32d9007ab4c5 --- /dev/null +++ b/gnu/usr.bin/yppush/yp_clnt.c @@ -0,0 +1,216 @@ +/* + YPS-0.2, NIS-Server for Linux + Copyright (C) 1994 Tobias Reber + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + Modified for use with FreeBSD 2.x by Bill Paul (wpaul@ctr.columbia.edu) + + $Id$ +*/ + +/* + * $Author: root $ + * $Log: yp_clnt.c,v $ + * Revision 0.16 1994/01/02 22:48:22 root + * Added strict prototypes + * + * Revision 0.15 1994/01/02 20:09:39 root + * Added GPL notice + * + * Revision 0.14 1993/12/19 12:42:32 root + * *** empty log message *** + * + * Revision 0.13 1993/06/12 09:39:30 root + * Align with include-4.4 + * + */ + +#include +#include +#include +#include +#include +#include +#include "yp.h" + +#ifdef DEBUG +#define PRINTF(x) printf x +#else +#define PRINTF(x) +#endif + +static struct timeval TIMEOUT = { 25, 0 }; + +void * +ypproc_null_2( int *argp, CLIENT *clnt) +{ + static char res; + + bzero(&res, sizeof(res)); + if (clnt_call(clnt, YPPROC_NULL, xdr_void, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return ((void *)&res); +} + + +bool_t * +ypproc_domain_2( domainname *argp, CLIENT *clnt) +{ + static bool_t res; + + bzero(&res, sizeof(res)); + if (clnt_call(clnt, YPPROC_DOMAIN, xdr_domainname, argp, xdr_bool, &res, TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&res); +} + + +bool_t * +ypproc_domain_nonack_2( domainname *argp, CLIENT *clnt) +{ + static bool_t res; + + bzero(&res, sizeof(res)); + if (clnt_call(clnt, YPPROC_DOMAIN_NONACK, xdr_domainname, argp, xdr_bool, &res, TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&res); +} + + +ypresp_val * +ypproc_match_2( ypreq_key *argp, CLIENT *clnt) +{ + static ypresp_val res; + + bzero(&res, sizeof(res)); + if (clnt_call(clnt, YPPROC_MATCH, __xdr_ypreq_key, argp, __xdr_ypresp_val, &res, TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&res); +} + + +ypresp_key_val * +ypproc_first_2( ypreq_key *argp, CLIENT *clnt) +{ + static ypresp_key_val res; + + bzero(&res, sizeof(res)); + if (clnt_call(clnt, YPPROC_FIRST, __xdr_ypreq_key, argp, __xdr_ypresp_key_val, &res, TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&res); +} + + +ypresp_key_val * +ypproc_next_2( ypreq_key *argp, CLIENT *clnt) +{ + static ypresp_key_val res; + + bzero(&res, sizeof(res)); + if (clnt_call(clnt, YPPROC_NEXT, __xdr_ypreq_key, argp, __xdr_ypresp_key_val, &res, TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&res); +} + + +ypresp_xfr * +ypproc_xfr_2( ypreq_xfr *argp, CLIENT *clnt) +{ + static ypresp_xfr res; + + bzero(&res, sizeof(res)); + if (clnt_call(clnt, YPPROC_XFR, __xdr_ypreq_xfr, argp, __xdr_ypresp_xfr, &res, TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&res); +} + + +void * +ypproc_clear_2( int *argp, CLIENT *clnt) +{ + static char res; + + bzero(&res, sizeof(res)); + if (clnt_call(clnt, YPPROC_CLEAR, xdr_void, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return ((void *)&res); +} + + +ypresp_all * +ypproc_all_2( ypreq_nokey *argp, CLIENT *clnt) +{ + static ypresp_all res; + + bzero(&res, sizeof(res)); + if (clnt_call(clnt, YPPROC_ALL, __xdr_ypreq_nokey, argp, __xdr_ypresp_all, &res, TIMEOUT) != RPC_SUCCESS) { + PRINTF(("ypproc_all_2 retuning NULL\n")); + return (NULL); + } + PRINTF(("ypproc_all_2 retuning non-NULL\n")); + return (&res); +} + + +ypresp_master * +ypproc_master_2( ypreq_nokey *argp, CLIENT *clnt) +{ + static ypresp_master res; + + bzero(&res, sizeof(res)); + if (clnt_call(clnt, YPPROC_MASTER, __xdr_ypreq_nokey, argp, __xdr_ypresp_master, &res, TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&res); +} + + +ypresp_order * +ypproc_order_2( ypreq_nokey *argp, CLIENT *clnt) +{ + static ypresp_order res; + PRINTF (("ypproc_order_2()\n")); + + bzero(&res, sizeof(res)); + if (clnt_call(clnt, YPPROC_ORDER, __xdr_ypreq_nokey, argp, __xdr_ypresp_order, &res, TIMEOUT) != RPC_SUCCESS) { + PRINTF (("ypproc_order_2()\n")); + return (NULL); + } + PRINTF (("ypproc_order_2()\n")); + return (&res); +} + + +ypresp_maplist * +ypproc_maplist_2( domainname *argp, CLIENT *clnt) +{ + static ypresp_maplist res; + + bzero(&res, sizeof(res)); + if (clnt_call(clnt, YPPROC_MAPLIST, xdr_domainname, argp, __xdr_ypresp_maplist, &res, TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&res); +} + diff --git a/gnu/usr.bin/yppush/yp_xdr.c b/gnu/usr.bin/yppush/yp_xdr.c new file mode 100644 index 000000000000..5afc8d9cd2b5 --- /dev/null +++ b/gnu/usr.bin/yppush/yp_xdr.c @@ -0,0 +1,477 @@ +/* + YPS-0.2, NIS-Server for Linux + Copyright (C) 1994 Tobias Reber + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + Modified for use with FreeBSD 2.x by Bill Paul (wpaul@ctr.columbia.edu) + + $Id$ +*/ + +/* + * $Author: root $ + * $Log: yp_xdr.c,v $ + * Revision 0.20 1994/01/02 22:48:22 root + * Added strict prototypes + * + * Revision 0.19 1994/01/02 20:09:39 root + * Added GPL notice + * + * Revision 0.18 1994/01/02 18:06:13 root + * Fixed another bug in __xdr_ypresp_all + * + * Revision 0.17 1993/12/30 22:34:57 root + * *** empty log message *** + * + * Revision 0.16 1993/12/29 00:37:37 root + * Fixed a bug in __xdr_ypresp_key_val + * + * Revision 0.15 1993/06/16 22:54:12 dok235 + * Fix a bug in ypresp_key_val + * + * Revision 0.14 1993/06/12 09:39:30 root + * Align with include-4.4 + * + * Revision 0.13 1993/06/11 21:45:00 root + * Regenned from yp.x, that came with include-4.4 + * + */ + +/* + * Please do not edit this file. + * It was generated using rpcgen. + */ + +#include +#include + +#ifdef DEBUG +#define PRINTF(x) printf x +#define PRLINENO printf(__FILE__ "(%d): ", __LINE__) +#else +#define PRINTF(x) +#define PRLINENO +#endif + +struct { + union { + int (*encoder)(char *, int, char **, int *, char **, int *); + int (*decoder)(int, char *, int, char *, int, char *); + } foreach; + char *data; +} *__xdr_ypall_callback; + +bool_t +__xdr_ypstat(XDR *xdrs, ypstat *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypxfrstat(XDR *xdrs, ypxfrstat *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_domainname(XDR *xdrs, domainname *objp) +{ + + if (!xdr_string(xdrs, objp, YPMAXDOMAIN)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_mapname(XDR *xdrs, mapname *objp) +{ + + if (!xdr_string(xdrs, objp, YPMAXMAP)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_peername(XDR *xdrs, peername *objp) +{ + + if (!xdr_string(xdrs, objp, YPMAXPEER)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +xdr_keydat(XDR *xdrs, keydat *objp) +{ + + if (!xdr_bytes(xdrs, (char **)&objp->keydat_val, (u_int *)&objp->keydat_len, YPMAXRECORD)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +xdr_valdat(XDR *xdrs, valdat *objp) +{ + + if (!xdr_bytes(xdrs, (char **)&objp->valdat_val, (u_int *)&objp->valdat_len, YPMAXRECORD)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypmap_parms(XDR *xdrs, ypmap_parms *objp) +{ + + if (!__xdr_domainname(xdrs, &objp->domain)) { + return (FALSE); + } + if (!__xdr_mapname(xdrs, &objp->map)) { + return (FALSE); + } + if (!xdr_u_int(xdrs, &objp->ordernum)) { + return (FALSE); + } + if (!__xdr_peername(xdrs, &objp->peer)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypreq_key(XDR *xdrs, ypreq_key *objp) +{ + + if (!__xdr_domainname(xdrs, &objp->domain)) { + return (FALSE); + } + if (!__xdr_mapname(xdrs, &objp->map)) { + return (FALSE); + } + if (!xdr_keydat(xdrs, &objp->key)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypreq_nokey(XDR *xdrs, ypreq_nokey *objp) +{ + + if (!__xdr_domainname(xdrs, &objp->domain)) { + return (FALSE); + } + if (!__xdr_mapname(xdrs, &objp->map)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypreq_xfr(XDR *xdrs, ypreq_xfr *objp) +{ + + if (!__xdr_ypmap_parms(xdrs, &objp->map_parms)) { + return (FALSE); + } + if (!xdr_u_int(xdrs, &objp->transid)) { + return (FALSE); + } + if (!xdr_u_int(xdrs, &objp->prog)) { + return (FALSE); + } + if (!xdr_u_int(xdrs, &objp->port)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypresp_val(XDR *xdrs, ypresp_val *objp) +{ + + if (!__xdr_ypstat(xdrs, &objp->stat)) { + return (FALSE); + } + if (!xdr_valdat(xdrs, &objp->val)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypresp_key_val(XDR *xdrs, ypresp_key_val *objp) +{ + + if (!__xdr_ypstat(xdrs, &objp->stat)) { + return (FALSE); + } + if (!xdr_valdat(xdrs, &objp->val)) { + return (FALSE); + } + if (!xdr_keydat(xdrs, &objp->key)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypresp_master(XDR *xdrs, ypresp_master *objp) +{ + + if (!__xdr_ypstat(xdrs, &objp->stat)) { + return (FALSE); + } + if (!__xdr_peername(xdrs, &objp->peer)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypresp_order(XDR *xdrs, ypresp_order *objp) +{ + + if (!__xdr_ypstat(xdrs, &objp->stat)) { + return (FALSE); + } + if (!xdr_u_int(xdrs, &objp->ordernum)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypresp_all(XDR *xdrs, ypresp_all *objp) +{ + int CallAgain = 0; + PRLINENO; + if (xdrs->x_op == XDR_DECODE) { + while(1) { +#if 1 + int s=objp->ypresp_all_u.val.stat; + bzero((char *)objp, sizeof (*objp)); + objp->ypresp_all_u.val.stat=s; +#endif + if (!xdr_bool(xdrs, &objp->more)) { + return (FALSE); + } + switch (objp->more) { + case TRUE: + if (!__xdr_ypresp_key_val(xdrs, &objp->ypresp_all_u.val)) { + return (FALSE); + } + if (CallAgain==0) { + CallAgain=(*(__xdr_ypall_callback->foreach.decoder))( + objp->ypresp_all_u.val.stat, + objp->ypresp_all_u.val.key.keydat_val, + objp->ypresp_all_u.val.key.keydat_len, + objp->ypresp_all_u.val.val.valdat_val, + objp->ypresp_all_u.val.val.valdat_len, + __xdr_ypall_callback->data); + } + break; + case FALSE: + return TRUE; + } +#if 0 + xdrs->x_op=XDR_FREE; + if (!__xdr_ypresp_all(xdrs, objp)) { + return FALSE; + } + xdrs->x_op=XDR_DECODE; +#else + xdr_free(__xdr_ypresp_all, (char *)objp); +#endif + } + } else if (xdrs->x_op == XDR_ENCODE) { + while(1) { + if (!xdr_bool(xdrs, &(objp->more))) { + return (FALSE); + } + if (!__xdr_ypresp_key_val(xdrs, &objp->ypresp_all_u.val)) { + printf("__xdr_ypresp_key_val failed\n"); + return (FALSE); + } + if (objp->ypresp_all_u.val.stat!=YP_TRUE) { + objp->more=FALSE; + if (!xdr_bool(xdrs, &(objp->more))) { + return (FALSE); + } + return(TRUE); + } + objp->ypresp_all_u.val.stat = + (enum ypstat)(*(__xdr_ypall_callback->foreach.encoder))( + objp->ypresp_all_u.val.key.keydat_val, + objp->ypresp_all_u.val.key.keydat_len, + &(objp->ypresp_all_u.val.key.keydat_val), + &(objp->ypresp_all_u.val.key.keydat_len), + &(objp->ypresp_all_u.val.val.valdat_val), + &(objp->ypresp_all_u.val.val.valdat_len)); + } + } else { +#if 0 + bool_t more=objp->more; + if (more==TRUE) { + if (!xdr_bool(xdrs, &objp->more)) { + return FALSE; + } + if (!__xdr_ypresp_key_val(xdrs, &objp->ypresp_all_u.val)) { + return (FALSE); + } + } +#endif + + return(TRUE); + } +} + +bool_t +__xdr_ypresp_xfr(XDR *xdrs, ypresp_xfr *objp) +{ + + if (!xdr_u_int(xdrs, &objp->transid)) { + return (FALSE); + } + if (!__xdr_ypxfrstat(xdrs, &objp->xfrstat)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypmaplist(XDR *xdrs, ypmaplist *objp) +{ + + if (!__xdr_mapname(xdrs, &objp->map)) { + return (FALSE); + } + if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof(ypmaplist), (xdrproc_t)__xdr_ypmaplist)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypresp_maplist(XDR *xdrs, ypresp_maplist *objp) +{ + + if (!__xdr_ypstat(xdrs, &objp->stat)) { + return (FALSE); + } + if (!xdr_pointer(xdrs, (char **)&objp->maps, sizeof(ypmaplist), (xdrproc_t)__xdr_ypmaplist)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_yppush_status(XDR *xdrs, yppush_status *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_yppushresp_xfr(XDR *xdrs, yppushresp_xfr *objp) +{ + + if (!xdr_u_int(xdrs, &objp->transid)) { + return (FALSE); + } + if (!__xdr_yppush_status(xdrs, &objp->status)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypbind_resptype(XDR *xdrs, ypbind_resptype *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypbind_binding(XDR *xdrs, ypbind_binding *objp) +{ + + if (!xdr_opaque(xdrs, objp->ypbind_binding_addr, 4)) { + return (FALSE); + } + if (!xdr_opaque(xdrs, objp->ypbind_binding_port, 2)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypbind_resp(XDR *xdrs, ypbind_resp *objp) +{ + + if (!__xdr_ypbind_resptype(xdrs, &objp->ypbind_status)) { + return (FALSE); + } + switch (objp->ypbind_status) { + case YPBIND_FAIL_VAL: + if (!xdr_u_int(xdrs, &objp->ypbind_resp_u.ypbind_error)) { + return (FALSE); + } + break; + case YPBIND_SUCC_VAL: + if (!__xdr_ypbind_binding(xdrs, &objp->ypbind_resp_u.ypbind_bindinfo)) { + return (FALSE); + } + break; + default: + return (FALSE); + } + return (TRUE); +} + +bool_t +__xdr_ypbind_setdom(XDR *xdrs, ypbind_setdom *objp) +{ + + if (!__xdr_domainname(xdrs, &objp->ypsetdom_domain)) { + return (FALSE); + } + if (!__xdr_ypbind_binding(xdrs, &objp->ypsetdom_binding)) { + return (FALSE); + } + if (!xdr_u_int(xdrs, &objp->ypsetdom_vers)) { + return (FALSE); + } + return (TRUE); +} diff --git a/gnu/usr.bin/yppush/ypclnt.c b/gnu/usr.bin/yppush/ypclnt.c new file mode 100644 index 000000000000..0088754345a4 --- /dev/null +++ b/gnu/usr.bin/yppush/ypclnt.c @@ -0,0 +1,128 @@ +/* + YPS-0.2, NIS-Server for Linux + Copyright (C) 1994 Tobias Reber + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + Modified for use with FreeBSd 2.x by Bill Paul (wpaul@ctr.columbia.edu) + + $Id$ +*/ + +/* + * $Author: root $ + * $Log: ypclnt.c,v $ + * Revision 2.0 1994/01/06 16:58:48 root + * Version 2.0 + * + * Revision 0.17 1994/01/02 22:48:22 root + * Added strict prototypes + * + * Revision 0.16 1994/01/02 20:09:39 root + * Added GPL notice + * + * Revision 0.15 1993/12/30 22:34:57 root + * *** empty log message *** + * + * Revision 0.14 1993/12/19 12:42:32 root + * *** empty log message *** + * + * Revision 0.13 1993/06/12 09:39:30 root + * Align with include-4.4 + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +/* + * ypclnt.h does not have a definition for struct dom_binding, + * although it is used there. It is defined in yp_prot.h, but + * we cannot use it here. + */ +struct dom_binding { + void * m; +}; +#include + +#if 0 +#define SOCKSERVER 0x7f000001 +#endif + +static struct sockaddr_in ServerAddress; +static CLIENT *UdpClient=NULL, *TcpClient=NULL; + +void +_yp_unbind(char *DomainName) +{ + if (UdpClient) clnt_destroy(UdpClient); + UdpClient=NULL; + if (TcpClient) clnt_destroy(TcpClient); + TcpClient=NULL; +} + +int +_yp_bind(struct sockaddr_in *ServerAddress, char *DomainName) +{ + struct sockaddr_in UdpServerAddress, TcpServerAddress; + int UdpSockp, TcpSockp; + static struct timeval Wait = { 5, 0 }; + + if (UdpClient || TcpClient) yp_unbind(DomainName); + + bcopy(ServerAddress, &UdpServerAddress, sizeof(*ServerAddress)); + UdpServerAddress.sin_port=0; + UdpSockp=(RPC_ANYSOCK); + bcopy(ServerAddress, &TcpServerAddress, sizeof(*ServerAddress)); + TcpServerAddress.sin_port=0; + TcpSockp=(RPC_ANYSOCK); + if ((UdpClient=clntudp_create(&UdpServerAddress, YPPROG, YPVERS, + Wait, &UdpSockp))==NULL) { + clnt_pcreateerror("UdpClient"); + return(YPERR_RPC); + } + if ((TcpClient=clnttcp_create(&TcpServerAddress, YPPROG, YPVERS, + &TcpSockp, 0, 0))==NULL) { + clnt_pcreateerror("TcpClient"); + return(YPERR_RPC); + } + return(0); + +} + + +int +_yp_clear(char *DomainName) +{ + void *resp; + int Status; + + do { + if (UdpClient==NULL) + if ((Status=yp_bind(DomainName))) return(Status); + if ((resp=ypproc_clear_2(NULL, UdpClient))==NULL) { + clnt_perror(UdpClient, "_yp_clear"); + _yp_unbind(DomainName); + } + } while(resp==NULL); + return 0; +} diff --git a/gnu/usr.bin/yppush/yppush.c b/gnu/usr.bin/yppush/yppush.c new file mode 100644 index 000000000000..5ca589824282 --- /dev/null +++ b/gnu/usr.bin/yppush/yppush.c @@ -0,0 +1,373 @@ +/* + YPS-0.2, NIS-Server for Linux + Copyright (C) 1994 Tobias Reber + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + Modified for use with FreeBSD 2.x by Bill Paul (wpaul@ctr.columbia.edu) + + $Id$ +*/ +/* + * $Author: root $ + * $Log: yppush.c,v $ + * Revision 2.0 1994/01/06 16:58:08 root + * Version 2.0 + * + * Revision 1.4 1994/01/02 23:00:59 root + * Use -v flag + * + * Revision 1.3 1994/01/02 21:59:08 root + * Strict prototypes + * + * Revision 1.2 1994/01/02 20:10:08 root + * Added GPL notice + * + * Revision 1.1 1994/01/02 18:04:08 root + * Initial revision + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include "yp.h" +/* + * ypclnt.h does not have a definition for struct dom_binding, + * although it is used there. It is defined in yp_prot.h, but + * we cannot use it here. + */ +struct dom_binding { + void * m; +}; +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define PERM_SECURE (S_IRUSR|S_IWUSR) +HASHINFO openinfo = { + 4096, /* bsize */ + 32, /* ffactor */ + 256, /* nelem */ + 2048 * 1024, /* cachesize */ + NULL, /* hash */ + 0 /* lorder */ +}; + +#undef MIN +#define MIN(a,b) ((a)<(b)?(a):(b)) + +static char *DomainName=NULL; +static bool_t Verbose=FALSE; + +static char *ThisHost=NULL; + +static char *MapName; +static u_int MapOrderNum; + +static CLIENT *PushClient=NULL; + +static u_int CallbackTransid; +static u_int CallbackProg=0; +static SVCXPRT *CallbackXprt; + +/* + * This is the rpc server side idle loop + * Wait for input, call server program. + */ + +static void +_svc_run( void) +{ +#ifdef FD_SETSIZE + fd_set readfds; +#else + int readfds; +#endif /* def FD_SETSIZE */ + extern int errno; + struct timeval t; + + t.tv_sec=60; t.tv_usec=0; + + for (;;) { +#ifdef FD_SETSIZE + readfds = svc_fdset; +#else + readfds = svc_fds; +#endif /* def FD_SETSIZE */ + switch (select(_rpc_dtablesize(), &readfds, (void *)0, + (void *)0, &t)) { + case -1: + if (errno == EINTR) { + continue; + } + perror("svc_run: - select failed"); + return; + case 0: + fprintf(stderr, "YPPUSH: Callback timed out\n"); + exit(0); + default: + svc_getreqset(&readfds); + } + } +} + +static void +Usage(void) +{ + fprintf(stderr, "Usage: yppush [ -d domain ] [ -v ] mapname ...\n"); + exit(1); +} + +static char * +getHostName( void) +{ + static char hostname[MAXHOSTNAMELEN+1]; + struct hostent *h; + if (gethostname(hostname, sizeof hostname)!=0) { + perror("YPPUSH: gethostname"); + return NULL; + } + h=gethostbyname(hostname); + if (h!=NULL) { + strncpy(hostname, h->h_name, sizeof (hostname)-1); + hostname[sizeof (hostname)-1]='\0'; + } + return hostname; +} + +static u_int +getOrderNum( void) +{ + char mapPath[MAXPATHLEN]; + DB *db; + DBT o,d; + int i; + + strcpy(mapPath, _PATH_YP); + strcat(mapPath, "/"); + strcat(mapPath, DomainName); + strcat(mapPath, "/"); + strcat(mapPath, MapName); + if ((db = dbopen(mapPath, O_RDWR|O_EXCL, PERM_SECURE, DB_HASH, + &openinfo)) == NULL) { + fprintf(stderr, "YPPUSH: %s: Cannot open\n", mapPath); + return -1; + } + + o.data="YP_LAST_MODIFIED"; o.size=strlen(o.data); + (db->get)(db,&o,&d,0); + if (d.data==NULL) { + fprintf(stderr, "YPPUSH: %s: Cannot determine order number\n", + MapName); + return -1; + } + + for (i=0; iclose)(db); + return atoi(d.data); +} + +static void +doPushClient( const char *targetHost) +{ + struct ypreq_xfr req; + static struct timeval tv={0,0}; + + req.map_parms.domain=DomainName ; + req.map_parms.map=(char *)MapName; + req.map_parms.peer=ThisHost; + req.map_parms.ordernum=MapOrderNum; + req.transid=CallbackTransid; + req.prog=CallbackProg; + req.port=CallbackXprt->xp_port; + + if (Verbose) + printf("%d: %s(%d@%s) -> %s@%s\n", req.transid, + req.map_parms.map, req.map_parms.ordernum, + req.map_parms.peer, targetHost, + req.map_parms.domain); + switch (clnt_call(PushClient, YPPROC_XFR, __xdr_ypreq_xfr, &req, + xdr_void, NULL, tv)) { + case RPC_SUCCESS: + case RPC_TIMEDOUT: + break; + default: + clnt_perror(PushClient, "YPPUSH: Cannot call YPPROC_XFR"); + kill(CallbackTransid, SIGTERM); + } + return; +} + +extern void yppush_xfrrespprog_1(struct svc_req *request, SVCXPRT *xprt); + +static bool_t +registerServer(void) +{ + int s; + s=RPC_ANYSOCK; + CallbackXprt=svcudp_create(s); + if (CallbackXprt==NULL) { + fprintf(stderr, "YPPUSH: Cannot create callback transport.\n"); + return FALSE; + } + for (CallbackProg=0x40000000; CallbackProg<0x5fffffff; CallbackProg++) { + if (svc_register(CallbackXprt, CallbackProg, 1, + yppush_xfrrespprog_1, IPPROTO_UDP)) + return TRUE; + } + return FALSE; +} + +static bool_t +createClient(const char *targetHost) +{ + PushClient=clnt_create((char *)targetHost, YPPROG, YPVERS, "tcp"); + if (PushClient==NULL) { + clnt_pcreateerror("YPPUSH: Cannot create client"); + return FALSE; + } + return TRUE; +} + +static void +doPush( const char *targetHost) +{ + int s; + struct rusage r; + + if (!createClient(targetHost)) + return; + if (!registerServer()) + return; + + switch (CallbackTransid=fork()) { + case -1: + perror("YPPUSH: Cannot fork"); + exit(1); + case 0: + _svc_run(); + exit(0); + default: + close(CallbackXprt->xp_sock); + doPushClient(targetHost); + wait4(CallbackTransid, &s, 0, &r); + svc_unregister(CallbackProg, 1); + CallbackProg=0; + if (PushClient!=NULL) { + clnt_destroy(PushClient); + PushClient=NULL; + } + } +} + +static int +yppushForeach(int status, const char *inKey, int inKeylen, + const char *inVal, int inVallen, const char *data) +{ + char targetHost[YPMAXPEER+1]; + + if (status!=YP_TRUE) return 0; + memcpy(targetHost, inKey, MIN(sizeof (targetHost)-1, inKeylen)); + targetHost[MIN(sizeof (targetHost)-1, inKeylen)]='\0'; + doPush(targetHost); + return 0; +} + +static void +intrHandler(int sig) +{ + if (CallbackProg!=0) + svc_unregister(CallbackProg, 1); + exit(1); +} + +int +main(int argc, char **argv) +{ + char c; + struct ypall_callback f; + enum ypstat y; + struct sigaction a; + + a.sa_handler=intrHandler; + a.sa_mask=0; + /* a.sa_flags=SA_NOMASK; + a.sa_restorer=NULL; */ + sigaction(SIGINT, &a, NULL); + + while((c=getopt(argc, argv, "d:v"))!=EOF) { + switch(c) { + case 'd': + DomainName=optarg; + break; + case 'v': + Verbose=TRUE; + break; + default: + Usage(); + } + } + argc-=optind; + argv+=optind; + if (argc<1) Usage(); + + if (DomainName==NULL) { + if (yp_get_default_domain(&DomainName)!=0) { + fprintf(stderr, "YPPUSH: Cannot get default domain\n"); + exit(1); + } + } + + ThisHost=getHostName(); + if (ThisHost==NULL) { + fprintf(stderr, "YPPUSH: Cannot determine local hostname\n"); + exit(1); + } + + while (*argv) { + MapName=*argv++; + MapOrderNum=getOrderNum(); + if (MapOrderNum==0xffffffff) + continue; + f.foreach=yppushForeach; + y=yp_all(DomainName, "ypservers", &f); + if (y && y!=YP_NOMORE) { + fprintf(stderr, "YPPUSH: Could not read ypservers: %d %s\n", + y, yperr_string(y)); + exit(1); + } + } + exit(0); +} diff --git a/gnu/usr.bin/yppush/yppush_s.c b/gnu/usr.bin/yppush/yppush_s.c new file mode 100644 index 000000000000..89cc8e8345cf --- /dev/null +++ b/gnu/usr.bin/yppush/yppush_s.c @@ -0,0 +1,156 @@ +/* + YPS-0.2, NIS-Server for Linux + Copyright (C) 1994 Tobias Reber + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + Modified for use with FreeBSD 2.x by Bill Paul (wpaul@ctr.columbia.edu) + + $Id$ +*/ +/* + * $Author: root $ + * $Log: yppush_s.c,v $ + * Revision 1.3 1994/01/02 21:59:08 root + * Strict prototypes + * + * Revision 1.2 1994/01/02 20:10:08 root + * Added GPL notice + * + * Revision 1.1 1994/01/02 18:04:08 root + * Initial revision + * + */ + +#include +#include +#include +#include + +enum yppush_status { + YPPUSH_SUCC = 1, + YPPUSH_AGE = 2, + YPPUSH_NOMAP = -1, + YPPUSH_NODOM = -2, + YPPUSH_RSRC = -3, + YPPUSH_RPC = -4, + YPPUSH_MADDR = -5, + YPPUSH_YPERR = -6, + YPPUSH_BADARGS = -7, + YPPUSH_DBM = -8, + YPPUSH_FILE = -9, + YPPUSH_SKEW = -10, + YPPUSH_CLEAR = -11, + YPPUSH_FORCE = -12, + YPPUSH_XFRERR = -13, + YPPUSH_REFUSED = -14, +}; +typedef enum yppush_status yppush_status; +bool_t __xdr_yppush_status(XDR *, void *); + +static inline char * +yppush_err_string(enum yppush_status y) { + switch(y) { + case YPPUSH_SUCC: return "Success"; + case YPPUSH_AGE: return "Master's version not newer"; + case YPPUSH_NOMAP: return "Can't find server for map"; + case YPPUSH_NODOM: return "Domain not supported"; + case YPPUSH_RSRC: return "Local resource alloc failure"; + case YPPUSH_RPC: return "RPC failure talking to server"; + case YPPUSH_MADDR: return "Can't get master address"; + case YPPUSH_YPERR: return "YP server/map db error"; + case YPPUSH_BADARGS: return "Request arguments bad"; + case YPPUSH_DBM: return "Local dbm operation failed"; + case YPPUSH_FILE: return "Local file I/O operation failed"; + case YPPUSH_SKEW: return "Map version skew during transfer"; + case YPPUSH_CLEAR: return "Can't send \"Clear\" req to local ypserv"; + case YPPUSH_FORCE: return "No local order number in map use -f flag."; + case YPPUSH_XFRERR: return "ypxfr error"; + case YPPUSH_REFUSED: return "Transfer request refused by ypserv"; + } +} + +struct yppushresp_xfr { + u_int transid; + yppush_status status; +}; +typedef struct yppushresp_xfr yppushresp_xfr; +bool_t __xdr_yppushresp_xfr(XDR *, void *); + + +#define YPPUSH_XFRRESPPROG ((u_long)0x40000000) +#define YPPUSH_XFRRESPVERS ((u_long)1) + +#define YPPUSHPROC_NULL ((u_long)0) +static inline void * +yppushproc_null_1(void * req, struct svc_req * rqstp) { + static int resp; + return &resp; +} + +#define YPPUSHPROC_XFRRESP ((u_long)1) +static inline void * +yppushproc_xfrresp_1(yppushresp_xfr *req, struct svc_req * rqstp) { + static int resp; + + if (req->status!=YPPUSH_SUCC) + fprintf(stderr, "YPPUSH: %s\n", yppush_err_string(req->status)); + return &resp; +} + +void +yppush_xfrrespprog_1( struct svc_req *rqstp, SVCXPRT *transp) +{ + union { + int fill; + } argument; + char *result; + bool_t (*xdr_argument)(XDR *, void *), (*xdr_result)(XDR *, void *); + char *(*local)( void *, struct svc_req *); + + switch (rqstp->rq_proc) { + case YPPUSHPROC_NULL: + xdr_argument = (bool_t (*)(XDR *, void *))xdr_void; + xdr_result = (bool_t (*)(XDR *, void *))xdr_void; + local = (char *(*)( void *, struct svc_req *)) yppushproc_null_1; + break; + + case YPPUSHPROC_XFRRESP: + xdr_argument = __xdr_yppushresp_xfr; + xdr_result = (bool_t (*)(XDR *, void *))xdr_void; + local = (char *(*)( void *, struct svc_req *)) yppushproc_xfrresp_1; + break; + + default: + svcerr_noproc(transp); + exit(1); + } + bzero((char *)&argument, sizeof(argument)); + if (!svc_getargs(transp, xdr_argument, &argument)) { + svcerr_decode(transp); + exit(1); + } + result = (*local)(&argument, rqstp); + if (result != NULL && !svc_sendreply(transp, xdr_result, result)) { + svcerr_systemerr(transp); + } + if (!svc_freeargs(transp, xdr_argument, &argument)) { + (void)fprintf(stderr, "unable to free arguments\n"); + exit(1); + if (rqstp->rq_proc!=YPPUSHPROC_NULL) + exit(0); + } + exit(0); +}