d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Obtained from: The NYS project

Browse Source 
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.
This commit is contained in:
Bill Paul 1995-01-31 09:47:11 +00:00
parent 2fd1e2091b
commit 9f6a77c541
7 changed files with 1652 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
gnu/usr.bin/yppush/Makefile Normal file
View File

@ -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 <bsd.prog.mk>

292
gnu/usr.bin/yppush/yp.h Normal file
View File

@ -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();

216
gnu/usr.bin/yppush/yp_clnt.c Normal file
View File

@ -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 <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <rpc/rpc.h>
#include <sys/time.h>
#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);
}

477
gnu/usr.bin/yppush/yp_xdr.c Normal file
View File

@ -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 <rpc/rpc.h>
#include <rpcsvc/yp.h>
#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);
}

128
gnu/usr.bin/yppush/ypclnt.c Normal file
View File

@ -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 <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/time.h>
#include <rpc/rpc.h>
#include <rpc/pmap_clnt.h>
#include <rpcsvc/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 <rpcsvc/ypclnt.h>
#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;
}

373
gnu/usr.bin/yppush/yppush.c Normal file
View File

@ -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 <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <rpc/rpc.h>
#include <paths.h>
#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 <rpcsvc/ypclnt.h>
#include <sys/param.h>
#include <sys/resource.h>
#include <sys/wait.h>
#include <ctype.h>
#include <netdb.h>
#include <errno.h>
#include <sys/types.h>
#include <fcntl.h>
#include <db.h>
#include <limits.h>
#include <sys/stat.h>
#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; i<d.size; i++) {
if (!isdigit(*((char *)d.data+i))) {
fprintf(stderr, "YPPUSH: %s: Invalid order number '%s'\n",
MapName, d.data);
return -1;
}
}
(void)(db->close)(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);
}

156
gnu/usr.bin/yppush/yppush_s.c Normal file
View File

@ -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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <rpc/rpc.h>
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);
}