diff options
| -rw-r--r-- | gnu/usr.sbin/ypserv/Makefile | 14 | ||||
| -rw-r--r-- | gnu/usr.sbin/ypserv/dnslookup.c | 111 | ||||
| -rw-r--r-- | gnu/usr.sbin/ypserv/server.c | 1327 | ||||
| -rw-r--r-- | gnu/usr.sbin/ypserv/system.h | 67 | ||||
| -rw-r--r-- | gnu/usr.sbin/ypserv/yp.h | 611 | ||||
| -rw-r--r-- | gnu/usr.sbin/ypserv/yp_svc.c | 393 | ||||
| -rw-r--r-- | gnu/usr.sbin/ypserv/yp_xdr.c | 415 |
7 files changed, 2938 insertions, 0 deletions
diff --git a/gnu/usr.sbin/ypserv/Makefile b/gnu/usr.sbin/ypserv/Makefile new file mode 100644 index 0000000..8310fee --- /dev/null +++ b/gnu/usr.sbin/ypserv/Makefile @@ -0,0 +1,14 @@ +# From: @(#)Makefile 8.3 (Berkeley) 4/2/94 + +PROG= ypserv +SRCS= dnslookup.c yp_svc.c yp_xdr.c server.c + +CFLAGS+=-Wall -DTCP_WRAPPER=0 -DTCPW_FACILITY=LOG_AUTH +CFLAGS+=-DINSTDIR='"/usr/libexec"' + +BINOWN= bin +BINMODE=555 + +MAN8= + +.include <bsd.prog.mk> diff --git a/gnu/usr.sbin/ypserv/dnslookup.c b/gnu/usr.sbin/ypserv/dnslookup.c new file mode 100644 index 0000000..395e08c --- /dev/null +++ b/gnu/usr.sbin/ypserv/dnslookup.c @@ -0,0 +1,111 @@ +/* + * Copyright (c) 1995 Bill Paul (wpaul@ctr.columbia.edu) + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Bill Paul. + * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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. + * + * $Id$ + */ + +/* +** Do standard and reverse DNS lookups using the resolver library. +** Take care of all the dirty work here so the main program only has to +** pass us a pointer to an array of characters. +** +** We have to use direct resolver calls here otherwise the YP server +** could end up looping by calling itself over and over again until +** it disappeared up its own belly button. +*/ + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <netdb.h> +#include <netinet/in.h> +#include <sys/socket.h> +#include <arpa/inet.h> + +extern struct hostent *_gethostbydnsname(); +extern struct hostent *_gethostbydnsaddr(); + +char *parse(hp) +struct hostent *hp; +{ +char *result; +int len,i; +struct in_addr addr; + + len = 16 + strlen(hp->h_name); + for (i = 0; hp->h_aliases[i]; i++) + len += strlen(hp->h_aliases[i]) + 1; + + result = (char *)malloc(len + 1); + bzero(result, len+1); + + bcopy(hp->h_addr, &addr, sizeof(struct in_addr)); + strcat(result, (char *)inet_ntoa(addr)); + strcat(result, " "); + strcat(result, hp->h_name); + + for (i = 0; hp->h_aliases[i]; i++) + { + strcat(result, " "); + strcat(result, hp->h_aliases[i]); + } + + return (result); +} + +char *dnsname(address) +char *address; +{ +struct hostent *hp; + + if (strchr(address, '@')) + return (NULL); + if ((hp = (struct hostent *)_gethostbydnsname(address)) == NULL) + return (NULL); + + return(parse(hp)); +} + +char *dnsaddr(address) +char *address; +{ +struct hostent *hp; +struct in_addr addr; + + if (strchr(address, '@')) + return (NULL); + if (!inet_aton(address, &addr)) + return (NULL); + if ((hp = (struct hostent *)_gethostbydnsaddr(&addr, + sizeof(unsigned long), AF_INET)) == NULL) + return (NULL); + + return(parse(hp)); +} diff --git a/gnu/usr.sbin/ypserv/server.c b/gnu/usr.sbin/ypserv/server.c new file mode 100644 index 0000000..1ed70bc --- /dev/null +++ b/gnu/usr.sbin/ypserv/server.c @@ -0,0 +1,1327 @@ +/* +** server.c YP server routines. +** +** Copyright (c) 1993 Signum Support AB, Sweden +** +** This file is part of the NYS YP Server. +** +** The NYS YP Server 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. +** +** The NYS YP Server 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 the NYS YP Server; see the file COPYING. If +** not, write to the Free Software Foundation, Inc., 675 Mass Ave, +** Cambridge, MA 02139, USA. +** +** Author: Peter Eriksson <pen@signum.se> +** Ported to FreeBSD and hacked all to pieces +** by Bill Paul <wpaul@ctr.columbia.edu> +** +** $Id$ +** +*/ + +#include "system.h" + +#include <stdio.h> +#include <stdlib.h> +#include <fcntl.h> +#include <dirent.h> +#include <string.h> +#include <limits.h> +#include <db.h> +#include <unistd.h> +#include <sys/stat.h> +#include <rpc/rpc.h> +#include "yp.h" +#include <sys/socket.h> +#include <arpa/inet.h> +#include <netdb.h> +#include <syslog.h> +#include <sys/param.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <sys/time.h> +#include <sys/resource.h> + +#if __STDC__ +#include <stdarg.h> +#else +#include <varargs.h> +#endif + +#define PERM_SECURE (S_IRUSR|S_IWUSR) +HASHINFO openinfo = { + 4096, /* bsize */ + 32, /* ffactor */ + 256, /* nelem */ + 2048 * 1024, /* cachesize */ + NULL, /* hash */ + 0, /* lorder */ +}; + +#if TCP_WRAPPER +#include "log_tcp.h" +int allow_severity=LOG_INFO; +int deny_severity=LOG_WARNING; +#endif + +void verr __P((const char *, _BSD_VA_LIST_)); +void Perror __P((const char *, ...)); + +extern char *dnsname(); +extern char *dnsaddr(); +extern char *_gethostbydnsaddr(); + +extern char *progname; +extern int errno; + +int debug_flag = 0; +int dns_flag = 0; + + +void verr(fmt, ap) + const char *fmt; + _BSD_VA_LIST_ ap; + +{ + if (debug_flag) + vfprintf(stderr, fmt, ap); + else + vsyslog(LOG_AUTH, fmt, ap); +} + +void +#ifdef __STDC__ +Perror(const char *fmt, ...) +#else +Perror(fmt, va_list) + const char *fmt; + va_dcl +#endif +{ + va_list ap; +#ifdef __STDC__ + va_start(ap, fmt); +#else + va_start(ap); +#endif + verr(fmt,ap); + va_end(ap); +} + + +/* +** Return 1 if request comes from an authorized host +** +** XXX This function should implement the "securenets" functionality +*/ +static int is_valid_host(struct sockaddr_in *sin) +{ +#if TCP_WRAPPER + extern int hosts_ctl(char *, char *, char *, char *); + int status; + static long oldaddr=0; /* so we dont log multiple times */ + static int oldstatus=-1; + char *h=NULL; + +#ifdef TRYRESOLVE + struct hostent *hp; + + hp = _gethostbydnsaddr((char *) &sin->sin_addr.s_addr, + sizeof (sin->sin_addr.s_addr), AF_INET); + + h = (hp && hp->h_name) ? hp->h_name : NULL; +#endif + + status = hosts_ctl(progname, + h?h:FROM_UNKNOWN, + inet_ntoa(sin->sin_addr), + ""); + + if (sin->sin_addr.s_addr != oldaddr || status != oldstatus ) { + syslog(status?allow_severity:deny_severity, + "%sconnect from %s\n",status?"":"refused ", + h?h:inet_ntoa(sin->sin_addr)); + oldaddr=sin->sin_addr.s_addr; + oldstatus=status; + } + return status; +#else + return 1; +#endif +} + + +void *ypproc_null_2_svc(void *dummy, + struct svc_req *rqstp) +{ + static int foo; + struct sockaddr_in *rqhost; + + + rqhost = svc_getcaller(rqstp->rq_xprt); + if (!is_valid_host(rqhost)) + return NULL; + + if (debug_flag) + Perror("ypproc_null() [From: %s:%d]\n", + inet_ntoa(rqhost->sin_addr), + ntohs(rqhost->sin_port)); + + return (void *) &foo; +} + + +/* +** Return 1 if the name is a valid domain name served by us, else 0. +*/ +static int is_valid_domain(const char *domain) +{ + struct stat sbuf; + + + if (domain == NULL || + strcmp(domain, "binding") == 0 || + strcmp(domain, "..") == 0 || + strcmp(domain, ".") == 0 || + strchr(domain, '/')) + return 0; + + if (stat(domain, &sbuf) < 0 || !S_ISDIR(sbuf.st_mode)) + return 0; + + return 1; +} + + + +bool_t *ypproc_domain_2_svc(domainname *name, + struct svc_req *rqstp) +{ + static bool_t result; + struct sockaddr_in *rqhost; + + + rqhost = svc_getcaller(rqstp->rq_xprt); + + if (debug_flag) + Perror("ypproc_domain(\"%s\") [From: %s:%d]\n", + *name, + inet_ntoa(rqhost->sin_addr), + ntohs(rqhost->sin_port)); + + if (!is_valid_host(rqhost)) + { + if (debug_flag) + Perror("\t-> Ignored (not a valid source host)\n"); + + return NULL; + } + + if (is_valid_domain(*name)) + result = TRUE; + else + result = FALSE; + + if (debug_flag) + Perror("\t-> %s.\n", + (result == TRUE ? "Ok" : "Not served by us")); + + return &result; +} + + +bool_t *ypproc_domain_nonack_2_svc(domainname *name, + struct svc_req *rqstp) +{ + static bool_t result; + struct sockaddr_in *rqhost; + + + rqhost = svc_getcaller(rqstp->rq_xprt); + + if (debug_flag) + Perror("ypproc_domain_nonack(\"%s\") [From: %s:%d]\n", + *name, + inet_ntoa(rqhost->sin_addr), + ntohs(rqhost->sin_port)); + + if (!is_valid_host(rqhost)) + { + if (debug_flag) + Perror("\t-> Ignored (not a valid source host)\n"); + + return NULL; + } + + if (!is_valid_domain(*name)) + { + if (debug_flag) + Perror("\t-> Ignored (not a valid domain)\n"); + + /* Bail out and don't return any RPC value */ + return NULL; + } + + if (debug_flag) + Perror("\t-> OK.\n"); + + result = TRUE; + return &result; +} + + +/* +** Open a DB database +*/ +static DB *open_database(const char *domain, + const char *map) +{ + DB *dbp; + char buf[1025]; + + + if (map[0] == '.' || strchr(map, '/')) + return 0; + + strcpy(buf, domain); + strcat(buf, "/"); + strcat(buf, map); + + dbp = dbopen(buf,O_RDONLY|O_EXCL, PERM_SECURE, DB_HASH, &openinfo); + + if (debug_flag > 1 && dbp == NULL) + Perror("dbopen(): ",strerror(errno)); + + return dbp; +} + + +#define F_ALL 0x01 +#define F_NEXT 0x02 + +/* +** Get a record from a DB database. +** This looks ugly because it emulates the behavior of the original +** GDBM-based routines. Blech. +*/ +int read_database(DB *dbp, + const DBT *ikey, + DBT *okey, + DBT *dval, + int flags) +{ + int first_flag = 0; + DBT nkey, ckey, dummyval; + + + if (ikey == NULL || ikey->data == NULL) + { + (dbp->seq)(dbp,&ckey,&dummyval,R_FIRST); + first_flag = 1; + } + else + { + if ((flags & F_NEXT)) + { + /* + ** This crap would be unnecessary if R_CURSOR actually worked. + */ + (dbp->seq)(dbp,&ckey,&dummyval,R_FIRST); + while(strncmp((char *)ikey->data,ckey.data,(int)ikey->size) || + ikey->size != ckey.size) + (dbp->seq)(dbp,&ckey,&dummyval,R_NEXT); + if ((dbp->seq)(dbp,&ckey,&dummyval,R_NEXT)) + ckey.data = NULL; + free(dummyval.data); + } + else + ckey = *ikey; + } + + if (ckey.data == NULL) + { + return (flags & F_NEXT) ? YP_NOMORE : YP_NOKEY; + } + + while (1) + { + if ((dbp->get)(dbp,&ckey,dval,0)) + { + /* Free key, unless it comes from the caller! */ + if (ikey == NULL || ckey.data != ikey->data) + free(ckey.data); + + if (ikey && ikey->data != NULL) + { + return YP_NOKEY; + } + else + if (first_flag) + return YP_BADDB; + else + return YP_FALSE; + } + + if ((flags & F_ALL) || strncmp(ckey.data, "YP_", 3) != 0) + { + if (okey) + *okey = ckey; + else if (ikey == NULL || ikey->data != ckey.data) + free(ckey.data); + + return YP_TRUE; + } + + /* Free old value */ + free(dval->data); + + if ((dbp->seq)(dbp,&nkey,&dummyval,R_NEXT)) + nkey.data = NULL; + free(dummyval.data); + + /* Free old key, unless it comes from the caller! */ + if (ikey == NULL || ckey.data != ikey->data) + free(ckey.data); + + if (ckey.data == NULL || nkey.data == NULL) + return YP_NOMORE; + + ckey = nkey; + } +} + + +/* +** Get the DateTimeModified value for a certain map database +*/ +static unsigned long get_dtm(const char *domain, + const char *map) +{ + struct stat sbuf; + char buf[1025]; + + + strcpy(buf, domain); + strcat(buf, "/"); + strcat(buf, map); + + if (stat(buf, &sbuf) < 0) + return 0; + else + return (unsigned long) sbuf.st_mtime; +} + + +/* +** YP function "MATCH" implementation +*/ +ypresp_val *ypproc_match_2_svc(ypreq_key *key, + struct svc_req *rqstp) +{ + static ypresp_val result; + struct sockaddr_in *rqhost; + + + rqhost = svc_getcaller(rqstp->rq_xprt); + + if (debug_flag) + { + Perror("ypproc_match(): [From: %s:%d]\n", + inet_ntoa(rqhost->sin_addr), + ntohs(rqhost->sin_port)); + + Perror("\t\tdomainname = \"%s\"\n", + key->domain); + Perror("\t\tmapname = \"%s\"\n", + key->map); + Perror("\t\tkeydat = \"%.*s\"\n", + (int) key->key.keydat_len, + key->key.keydat_val); + } + + if (!is_valid_host(rqhost)) + { + if (debug_flag) + Perror("\t-> Ignored (not a valid source host)\n"); + + return NULL; + } + + /* + ** If this request deals with master.passwd.* and it didn't + ** originate on a privileged port (< 1024), return a YP_YPERR. + ** This is our half-assed way of preventing non-root users + ** on NIS clients from getting at the real password map. Bah. + */ + + if (strstr(key->map, "master.passwd") != NULL && + ntohs(rqhost->sin_port) > 1023) + { + result.stat = YP_YPERR; + return &result; + } + + result.val.valdat_len = 0; + if (result.val.valdat_val) + { + free(result.val.valdat_val); + result.val.valdat_val = NULL; + } + + if (key->domain[0] == '\0' || key->map[0] == '\0') + result.stat = YP_BADARGS; + else if (!is_valid_domain(key->domain)) + result.stat = YP_NODOM; + else + { + DBT rdat, qdat; + + DB *dbp = open_database(key->domain, key->map); + if (dbp == NULL) + result.stat = YP_NOMAP; + else + { + qdat.size = key->key.keydat_len; + qdat.data = key->key.keydat_val; + + result.stat = read_database(dbp, &qdat, NULL, &rdat, F_ALL); + + if (result.stat == YP_TRUE) + { + result.val.valdat_len = rdat.size; + result.val.valdat_val = rdat.data; + } + + (void)(dbp->close)(dbp); + } + } + + if (debug_flag) + { + if (result.stat == YP_TRUE) + Perror("\t-> Value = \"%.*s\"\n", + (int) result.val.valdat_len, + result.val.valdat_val); + else + Perror("\t-> Error #%d\n", result.stat); + } + + + /* + ** Do the jive thing if we didn't find the host in the YP map + ** and we have enabled the magic DNS lookup stuff. + ** + ** XXX Perhaps this should be done in a sub-process for performance + ** reasons. Later. + */ + if (result.stat != YP_TRUE && dns_flag) + { + char *cp = NULL; + + key->key.keydat_val[key->key.keydat_len] = '\0'; + + if (debug_flag) + Perror("Doing DNS lookup of %s\n", key->key.keydat_val); + + if (strcmp(key->map, "hosts.byname") == 0) + cp = dnsname(key->key.keydat_val); + else if (strcmp(key->map, "hosts.byaddr") == 0) + cp = dnsaddr(key->key.keydat_val); + + if (cp) + { + + if (debug_flag) + Perror("\t-> OK (%s)\n", cp); + + result.val.valdat_len = strlen(cp); + result.val.valdat_val = cp; + result.stat = YP_TRUE; + } + else + { + if (debug_flag) + { + Perror("\t-> Not Found\n"); + Perror("DNS lookup: %s",strerror(errno)); + } + + result.stat = YP_NOKEY; + } + } + + return &result; +} + + + +ypresp_key_val *ypproc_first_2_svc(ypreq_nokey *key, + struct svc_req *rqstp) +{ + static ypresp_key_val result; + struct sockaddr_in *rqhost; + + + rqhost = svc_getcaller(rqstp->rq_xprt); + + if (debug_flag) + { + Perror("ypproc_first(): [From: %s:%d]\n", + inet_ntoa(rqhost->sin_addr), + ntohs(rqhost->sin_port)); + + Perror("\tdomainname = \"%s\"\n", key->domain); + Perror("\tmapname = \"%s\"\n", key->map); +#if 0 + Perror("\tkeydat = \"%.*s\"\n", + (int) key->key.keydat_len, + key->key.keydat_val); +#endif + } + + if (!is_valid_host(rqhost)) + { + if (debug_flag) + Perror("\t-> Ignored (not a valid source host)\n"); + + return NULL; + } + + /* + ** If this request deals with master.passwd.* and it didn't + ** originate on a privileged port (< 1024), return a YP_YPERR. + ** This is our half-assed way of preventing non-root users + ** on NIS clients from getting at the real password map. Bah. + */ + + if (strstr(key->map, "master.passwd") != NULL && + ntohs(rqhost->sin_port) > 1023) + { + result.stat = YP_YPERR; + return &result; + } + + result.key.keydat_len = 0; + if (result.key.keydat_val) + { + free(result.key.keydat_val); + result.key.keydat_val = NULL; + } + + result.val.valdat_len = 0; + if (result.val.valdat_val) + { + free(result.val.valdat_val); + result.val.valdat_val = NULL; + } + + if (key->map[0] == '\0' || key->domain[0] == '\0') + result.stat = YP_BADARGS; + else if (!is_valid_domain(key->domain)) + result.stat = YP_NODOM; + else + { + DBT dkey, dval; + + DB *dbp = open_database(key->domain, key->map); + if (dbp == NULL) + result.stat = YP_NOMAP; + else + { + result.stat = read_database(dbp, NULL, &dkey, &dval, 0); + + if (result.stat == YP_TRUE) + { + result.key.keydat_len = dkey.size; + result.key.keydat_val = dkey.data; + + result.val.valdat_len = dval.size; + result.val.valdat_val = dval.data; + } + + (void)(dbp->close)(dbp); + } + } + + if (debug_flag) + { + if (result.stat == YP_TRUE) + Perror("\t-> Key = \"%.*s\", Value = \"%.*s\"\n", + (int) result.key.keydat_len, + result.key.keydat_val, + (int) result.val.valdat_len, + result.val.valdat_val); + + else + Perror("\t-> Error #%d\n", result.stat); + } + + return &result; +} + + +ypresp_key_val *ypproc_next_2_svc(ypreq_key *key, + struct svc_req *rqstp) +{ + static ypresp_key_val result; + struct sockaddr_in *rqhost; + + + rqhost = svc_getcaller(rqstp->rq_xprt); + + if (debug_flag) + { + Perror("ypproc_next(): [From: %s:%d]\n", + inet_ntoa(rqhost->sin_addr), + ntohs(rqhost->sin_port)); + + Perror("\tdomainname = \"%s\"\n", key->domain); + Perror("\tmapname = \"%s\"\n", key->map); + Perror("\tkeydat = \"%.*s\"\n", + (int) key->key.keydat_len, + key->key.keydat_val); + } + + if (!is_valid_host(rqhost)) + { + if (debug_flag) + Perror("\t-> Ignored (not a valid source host)\n"); + + return NULL; + } + + /* + ** If this request deals with master.passwd.* and it didn't + ** originate on a privileged port (< 1024), return a YP_YPERR. + ** This is our half-assed way of preventing non-root users + ** on NIS clients from getting at the real password map. Bah. + */ + + if (strstr(key->map, "master.passwd") != NULL && + ntohs(rqhost->sin_port) > 1023) + { + result.stat = YP_YPERR; + return &result; + } + + result.key.keydat_len = 0; + if (result.key.keydat_val) + { + free(result.key.keydat_val); + result.key.keydat_val = NULL; + } + + result.val.valdat_len = 0; + if (result.val.valdat_val) + { + free(result.val.valdat_val); + result.val.valdat_val = NULL; + } + + if (key->map[0] == '\0' || key->domain[0] == '\0') + result.stat = YP_BADARGS; + else if (!is_valid_domain(key->domain)) + result.stat = YP_NODOM; + else + { + DBT dkey, dval, okey; + + + DB *dbp = open_database(key->domain, key->map); + if (dbp == NULL) + result.stat = YP_NOMAP; + else + { + dkey.size = key->key.keydat_len; + dkey.data = key->key.keydat_val; + + result.stat = read_database(dbp, &dkey, &okey, &dval, F_NEXT); + + if (result.stat == YP_TRUE) + { + result.key.keydat_len = okey.size; + result.key.keydat_val = okey.data; + + result.val.valdat_len = dval.size; + result.val.valdat_val = dval.data; + } + (void)(dbp->close)(dbp); + } + } + + if (debug_flag) + { + if (result.stat == YP_TRUE) + Perror("\t-> Key = \"%.*s\", Value = \"%.*s\"\n", + (int) result.key.keydat_len, + result.key.keydat_val, + (int) result.val.valdat_len, + result.val.valdat_val); + else + Perror("\t-> Error #%d\n", result.stat); + } + + return &result; +} + + + +static void print_ypmap_parms(const struct ypmap_parms *pp) +{ + Perror("\t\tdomain = \"%s\"\n", pp->domain); + Perror("\t\tmap = \"%s\"\n", pp->map); + Perror("\t\tordernum = %u\n", pp->ordernum); + Perror("\t\tpeer = \"%s\"\n", pp->peer); +} + + +/* +** Stole the ypxfr implementation from the yps package. +*/ +ypresp_xfr *ypproc_xfr_2_svc(ypreq_xfr *xfr, + struct svc_req *rqstp) +{ + static ypresp_xfr result; + struct sockaddr_in *rqhost; + char ypxfr_command[MAXPATHLEN]; + + rqhost = svc_getcaller(rqstp->rq_xprt); + + if (debug_flag) + { + Perror("ypproc_xfr_2_svc(): [From: %s:%d]\n\tmap_parms:\n", + inet_ntoa(rqhost->sin_addr), + ntohs(rqhost->sin_port)); + + print_ypmap_parms(&xfr->map_parms); + Perror("\t\ttransid = %u\n", xfr->transid); + Perror("\t\tprog = %u\n", xfr->prog); + Perror("\t\tport = %u\n", xfr->port); + } + + if (!is_valid_host(rqhost)) + { + if (debug_flag) + Perror("\t-> Ignored (not a valid source host)\n"); + + return NULL; + } + + /* + ** If this request originates on a non-privileged port (< 1024), + ** refuse it. We really only need to guard the master.passwd.* + ** maps, but what the hell. + ** This is our half-assed way of preventing non-root users + ** on NIS clients from getting at the real password map. Bah. + */ + + if (ntohs(rqhost->sin_port) > 1023) + { + result.xfrstat = YPXFR_REFUSED; + return &result; + } + + switch(fork()) + { + case 0: + { + char g[11], t[11], p[11]; + + sprintf (ypxfr_command, "%s/ypxfr", INSTDIR); + sprintf (t, "%u", xfr->transid); + sprintf (g, "%u", xfr->prog); + sprintf (p, "%u", xfr->port); + execl(ypxfr_command, "ypxfr", "-d", xfr->map_parms.domain, "-h", + xfr->map_parms.peer, "-f", "-C", t, g, + inet_ntoa(rqhost->sin_addr), p, xfr->map_parms.map, NULL); + Perror("ypxfr execl(): %s",strerror(errno)); + exit(0); + } + case -1: + Perror("fork(): %s",strerror(errno)); + result.xfrstat = YPXFR_XFRERR; + default: + { + int st; + + wait4(-1, &st, WNOHANG, NULL); + result.xfrstat = YPXFR_SUCC; + break; + } + } + + result.transid = xfr->transid; + return &result; +} + + +void *ypproc_clear_2_svc(void *dummy, + struct svc_req *rqstp) +{ + static int foo; + struct sockaddr_in *rqhost; + + + rqhost = svc_getcaller(rqstp->rq_xprt); + + if (debug_flag) + Perror("ypproc_clear_2_svc() [From: %s:%d]\n", + inet_ntoa(rqhost->sin_addr), + ntohs(rqhost->sin_port)); + + if (!is_valid_host(rqhost)) + { + if (debug_flag) + Perror("\t-> Ignored (not a valid source host)\n"); + + return NULL; + } + + return (void *) &foo; +} + + +static int ypall_close(void *data) +{ + DB *locptr; + + if (debug_flag && data == NULL) + { + Perror("ypall_close() called with NULL pointer.\n"); + return 0; + } + + locptr = (DB *)data; + (void)(locptr->close)(locptr); + return 0; +} + + +static int ypall_encode(ypresp_key_val *val, + void *data) +{ + DBT dkey, dval, okey; + + dkey.data = val->key.keydat_val; + dkey.size = val->key.keydat_len; + + val->stat = read_database((DB *) data, &dkey, &okey, &dval, F_NEXT); + + if (val->stat == YP_TRUE) + { + val->key.keydat_val = okey.data; + val->key.keydat_len = okey.size; + + val->val.valdat_val = dval.data; + val->val.valdat_len = dval.size; + } + + + return val->stat; +} + + +ypresp_all *ypproc_all_2_svc(ypreq_nokey *nokey, + struct svc_req *rqstp) +{ + static ypresp_all result; + extern __xdr_ypall_cb_t __xdr_ypall_cb; + struct sockaddr_in *rqhost; + + + rqhost = svc_getcaller(rqstp->rq_xprt); + + if (debug_flag) + { + Perror("ypproc_all_2_svc(): [From: %s:%d]\n", + inet_ntoa(rqhost->sin_addr), + ntohs(rqhost->sin_port)); + + Perror("\t\tdomain = \"%s\"\n", nokey->domain); + Perror("\t\tmap = \"%s\"\n", nokey->map); + } + + if (!is_valid_host(rqhost)) + { + if (debug_flag) + Perror("\t-> Ignored (not a valid source host)\n"); + + return NULL; + } + + __xdr_ypall_cb.u.encode = NULL; + __xdr_ypall_cb.u.close = NULL; + __xdr_ypall_cb.data = NULL; + + result.more = TRUE; + + /* + ** If this request deals with master.passwd.* and it didn't + ** originate on a privileged port (< 1024), return a YP_YPERR. + ** This is our half-assed way of preventing non-root users + ** on NIS clients from getting at the real password map. Bah. + */ + + if (strstr(nokey->map, "master.passwd") != NULL && + ntohs(rqhost->sin_port) > 1023) + { + result.ypresp_all_u.val.stat = YP_YPERR; + return &result; + } + + if (nokey->map[0] == '\0' || nokey->domain[0] == '\0') + result.ypresp_all_u.val.stat = YP_BADARGS; + else if (!is_valid_domain(nokey->domain)) + result.ypresp_all_u.val.stat = YP_NODOM; + else + { + DBT dkey, dval; + + DB *dbp = open_database(nokey->domain, nokey->map); + if (dbp == NULL) + result.ypresp_all_u.val.stat = YP_NOMAP; + else + { + result.ypresp_all_u.val.stat = read_database(dbp, + NULL, + &dkey, + &dval, + 0); + + if (result.ypresp_all_u.val.stat == YP_TRUE) + { + result.ypresp_all_u.val.key.keydat_len = dkey.size; + result.ypresp_all_u.val.key.keydat_val = dkey.data; + + result.ypresp_all_u.val.val.valdat_len = dval.size; + result.ypresp_all_u.val.val.valdat_val = dval.data; + + __xdr_ypall_cb.u.encode = ypall_encode; + __xdr_ypall_cb.u.close = ypall_close; + __xdr_ypall_cb.data = (void *) dbp; + + return &result; + } + + (void)(dbp->close)(dbp); + } + } + + return &result; +} + + +ypresp_master *ypproc_master_2_svc(ypreq_nokey *nokey, + struct svc_req *rqstp) +{ + static ypresp_master result; + struct sockaddr_in *rqhost; + + + rqhost = svc_getcaller(rqstp->rq_xprt); + + if (debug_flag) + { + Perror("ypproc_master_2_svc(): [From: %s:%d]\n", + inet_ntoa(rqhost->sin_addr), + ntohs(rqhost->sin_port)); + + Perror("\t\tdomain = \"%s\"\n", nokey->domain); + Perror("\t\tmap = \"%s\"\n", nokey->map); + } + + if (!is_valid_host(rqhost)) + { + if (debug_flag) + Perror("\t-> Ignored (not a valid source host)\n"); + + return NULL; + } + + /* + ** If this request deals with master.passwd.* and it didn't + ** originate on a privileged port (< 1024), return a YP_YPERR. + ** This is our half-assed way of preventing non-root users + ** on NIS clients from getting at the real password map. Bah. + */ + + if (strstr(nokey->map, "master.passwd") != NULL && + ntohs(rqhost->sin_port) > 1023) + { + result.stat = YP_YPERR; + return &result; + } + + if (result.peer) + { + free(result.peer); + result.peer = NULL; + } + + if (nokey->domain[0] == '\0') + result.stat = YP_BADARGS; + else if (!is_valid_domain(nokey->domain)) + result.stat = YP_NODOM; + else + { + DB *dbp = open_database(nokey->domain, nokey->map); + if (dbp == NULL) + result.stat = YP_NOMAP; + else + { + DBT key, val; + + key.size = sizeof("YP_MASTER_NAME")-1; + key.data = "YP_MASTER_NAME"; + + if ((dbp->get)(dbp,&key,&val,0)) + val.data = NULL; + + if (val.data == NULL) + { + /* No YP_MASTER_NAME record in map? Assume we are Master */ + static char hostbuf[1025]; + + gethostname((char *)&hostbuf, sizeof(hostbuf)-1); + Perror("Hostname: [%s]",hostbuf); + result.peer = strdup(hostbuf); + } + else + { + *(((char *)val.data)+val.size) = '\0'; + result.peer = val.data; + } + + result.stat = YP_TRUE; + (void)(dbp->close)(dbp); + } + } + + if (result.peer == NULL) + result.peer = strdup(""); + + if (debug_flag) + Perror("\t-> Peer = \"%s\"\n", result.peer); + + return &result; +} + + +ypresp_order *ypproc_order_2_svc(ypreq_nokey *nokey, + struct svc_req *rqstp) +{ + static ypresp_order result; + struct sockaddr_in *rqhost; + + + rqhost = svc_getcaller(rqstp->rq_xprt); + + if (debug_flag) + { + Perror("ypproc_order_2_svc(): [From: %s:%d]\n", + inet_ntoa(rqhost->sin_addr), + ntohs(rqhost->sin_port)); + + Perror("\t\tdomain = \"%s\"\n", nokey->domain); + Perror("\t\tmap = \"%s\"\n", nokey->map); + } + + if (!is_valid_host(rqhost)) + { + if (debug_flag) + Perror("\t-> Ignored (not a valid source host)\n"); + + return NULL; + } + + /* + ** If this request deals with master.passwd.* and it didn't + ** originate on a privileged port (< 1024), return a YP_YPERR. + ** This is our half-assed way of preventing non-root users + ** on NIS clients from getting at the real password map. Bah. + */ + + if (strstr(nokey->map, "master.passwd") != NULL && + ntohs(rqhost->sin_port) > 1023) + { + result.stat = YP_YPERR; + return &result; + } + + result.ordernum = 0; + + if (nokey->domain[0] == '\0') + result.stat = YP_BADARGS; + else if (!is_valid_domain(nokey->domain)) + result.stat = YP_NODOM; + else + { + DB *dbp = open_database(nokey->domain, nokey->map); + if (dbp == NULL) + result.stat = YP_NOMAP; + else + { + DBT key, val; + + key.size = sizeof("YP_LAST_MODIFIED")-1; + key.data = "YP_LAST_MODIFIED"; + + (dbp->get)(dbp,&key,&val,0); + if (val.data == NULL) + { + /* No YP_LAST_MODIFIED record in map? Use DTM timestamp.. */ + result.ordernum = get_dtm(nokey->domain, nokey->map); + } + else + { + result.ordernum = atoi(val.data); + free(val.data); + } + + result.stat = YP_TRUE; + (void)(dbp->close)(dbp); + } + } + + if (debug_flag) + Perror("-> Order # %d\n", result.ordernum); + + return &result; +} + + +static void free_maplist(ypmaplist *mlp) +{ + ypmaplist *next; + + while (mlp != NULL) + { + next = mlp->next; + free(mlp->map); + free(mlp); + mlp = next; + } +} + +static int add_maplist(ypmaplist **mlhp, + char *map) +{ + ypmaplist *mlp; + + if (!strncmp(map, ".", strlen(map)) || !strncmp(map, "..", strlen(map))) + return 0; + + mlp = malloc(sizeof(*mlp)); + if (mlp == NULL) + return -1; + + mlp->map = strdup(map); + if (mlp->map == NULL) + { + free(mlp); + return -1; + } + + mlp->next = *mlhp; + *mlhp = mlp; + + return 0; +} + + +ypresp_maplist *ypproc_maplist_2_svc(domainname *name, + struct svc_req *rqstp) +{ + static ypresp_maplist result; + struct sockaddr_in *rqhost; + + + rqhost = svc_getcaller(rqstp->rq_xprt); + + if (debug_flag) + { + Perror("ypproc_maplist_2_svc(): [From: %s:%d]\n", + inet_ntoa(rqhost->sin_addr), + ntohs(rqhost->sin_port)); + + Perror("\t\tdomain = \"%s\"\n", *name); + } + + if (!is_valid_host(rqhost)) + { + if (debug_flag) + Perror("\t-> Ignored (not a valid source host)\n"); + + return NULL; + } + + if (result.maps) + free_maplist(result.maps); + + result.maps = NULL; + + if ((*name)[0] == '\0') + result.stat = YP_BADARGS; + else if (!is_valid_domain(*name)) + result.stat = YP_NODOM; + else + { + DIR *dp; + char dirname[MAXPATHLEN]; + + sprintf(dirname,"./%s",*name); + dp = opendir(dirname); + if (dp == NULL) + { + if (debug_flag) + { + Perror("%s: opendir: %s", progname,strerror(errno)); + } + + result.stat = YP_BADDB; + } + else + { + struct dirent *dep; + + while ((dep = readdir(dp)) != NULL) + if (add_maplist(&result.maps, dep->d_name) < 0) + { + result.stat = YP_YPERR; + break; + } + closedir(dp); + result.stat = YP_TRUE; + } + } + + if (debug_flag) + { + if (result.stat == YP_TRUE) + { + ypmaplist *p; + + p = result.maps; + Perror("-> "); + while (p->next) + { + Perror("%s,", p->map); + p = p->next; + } + putc('\n', stderr); + } + else + Perror("\t-> Error #%d\n", result.stat); + } + + return &result; +} diff --git a/gnu/usr.sbin/ypserv/system.h b/gnu/usr.sbin/ypserv/system.h new file mode 100644 index 0000000..838430a --- /dev/null +++ b/gnu/usr.sbin/ypserv/system.h @@ -0,0 +1,67 @@ +/* + * $Id$ + */ + +#if (defined(__sun__) || defined(sun)) && !defined(__svr4__) + +/* Stupid SunOS 4 doesn't have prototypes in the header files */ + +/* Some includes just to make the compiler be quiet */ +#include <stdio.h> +#include <sys/types.h> +#include <sys/socket.h> + +extern int fprintf(FILE *fp, const char *format, ...); +extern int _flsbuf(unsigned char c, FILE *fp); +extern int puts(const char *str); +extern int printf(const char *format, ...); + +extern int chdir(const char *path); +extern int gethostname(char *buf, int bufsize); +extern int atoi(const char *str); +extern int perror(const char *str); + +extern int socket (int af, int type, int protocol); +extern int bind (int s, struct sockaddr *name, int namelen); +extern int chdir (const char *path); + +#endif + + +#if (defined(__sun__) || defined(sun)) && defined(__svr4__) + +extern char *strdup(const char *str); + +#define NEED_GETHOSTNAME +#define NEED_SVCSOC_H + +#endif + + +#if defined(hpux) || defined(__hpux__) + +/* HP is really... Ah well. */ + +#define _INCLUDE_HPUX_SOURCE +#define _INCLUDE_XOPEN_SOURCE +#define _INCLUDE_POSIX_SOURCE +#define _INCLUDE_AES_SOURCE + +extern void svcerr_systemerr(); +#endif + + +#if defined(linux) || defined(__linux__) + +/* Need this because some header files doesn't check for __linux__ */ +#if !defined(linux) +#define linux linux +#endif + +/* Needed for non-ANSI prototypes */ +#define _SVID_SOURCE + +/* Needed for gethostname() */ +#define _BSD_SOURCE + +#endif diff --git a/gnu/usr.sbin/ypserv/yp.h b/gnu/usr.sbin/ypserv/yp.h new file mode 100644 index 0000000..fde95cd --- /dev/null +++ b/gnu/usr.sbin/ypserv/yp.h @@ -0,0 +1,611 @@ +/* + * And thus spoke RPCGEN: + * Please do not edit this file. + * It was generated using rpcgen. + * + * And thus replied Lpd@NannyMUD: + * Who cares? :-) /Peter Eriksson <pen@signum.se> + * + * + * Modification history: + * 940716 pen@signum.se Change "ypreq_key" to "ypreq_nokey" for FIRST. + * + * $Id$ + */ + +#ifndef _YP_H_RPCGEN +#define _YP_H_RPCGEN + +#include <rpc/rpc.h> +#ifdef NEED_SVCSOC_H +#include <rpc/svc_soc.h> +#endif + +#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; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypstat(XDR *, ypstat*); +#elif __STDC__ +extern bool_t __xdr_ypstat(XDR *, ypstat*); +#else /* Old Style C */ +bool_t __xdr_ypstat(); +#endif /* Old Style C */ + + +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; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypxfrstat(XDR *, ypxfrstat*); +#elif __STDC__ +extern bool_t __xdr_ypxfrstat(XDR *, ypxfrstat*); +#else /* Old Style C */ +bool_t __xdr_ypxfrstat(); +#endif /* Old Style C */ + + +typedef char *domainname; +#ifdef __cplusplus +extern "C" bool_t __xdr_domainname(XDR *, domainname*); +#elif __STDC__ +extern bool_t __xdr_domainname(XDR *, domainname*); +#else /* Old Style C */ +bool_t __xdr_domainname(); +#endif /* Old Style C */ + + +typedef char *mapname; +#ifdef __cplusplus +extern "C" bool_t __xdr_mapname(XDR *, mapname*); +#elif __STDC__ +extern bool_t __xdr_mapname(XDR *, mapname*); +#else /* Old Style C */ +bool_t __xdr_mapname(); +#endif /* Old Style C */ + + +typedef char *peername; +#ifdef __cplusplus +extern "C" bool_t __xdr_peername(XDR *, peername*); +#elif __STDC__ +extern bool_t __xdr_peername(XDR *, peername*); +#else /* Old Style C */ +bool_t __xdr_peername(); +#endif /* Old Style C */ + + +typedef struct { + u_int keydat_len; + char *keydat_val; +} keydat; +#ifdef __cplusplus +extern "C" bool_t __xdr_keydat(XDR *, keydat*); +#elif __STDC__ +extern bool_t __xdr_keydat(XDR *, keydat*); +#else /* Old Style C */ +bool_t __xdr_keydat(); +#endif /* Old Style C */ + + +typedef struct { + u_int valdat_len; + char *valdat_val; +} valdat; +#ifdef __cplusplus +extern "C" bool_t __xdr_valdat(XDR *, valdat*); +#elif __STDC__ +extern bool_t __xdr_valdat(XDR *, valdat*); +#else /* Old Style C */ +bool_t __xdr_valdat(); +#endif /* Old Style C */ + + +struct ypmap_parms { + domainname domain; + mapname map; + u_int ordernum; + peername peer; +}; +typedef struct ypmap_parms ypmap_parms; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypmap_parms(XDR *, ypmap_parms*); +#elif __STDC__ +extern bool_t __xdr_ypmap_parms(XDR *, ypmap_parms*); +#else /* Old Style C */ +bool_t __xdr_ypmap_parms(); +#endif /* Old Style C */ + + +struct ypreq_key { + domainname domain; + mapname map; + keydat key; +}; +typedef struct ypreq_key ypreq_key; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypreq_key(XDR *, ypreq_key*); +#elif __STDC__ +extern bool_t __xdr_ypreq_key(XDR *, ypreq_key*); +#else /* Old Style C */ +bool_t __xdr_ypreq_key(); +#endif /* Old Style C */ + + +struct ypreq_nokey { + domainname domain; + mapname map; +}; +typedef struct ypreq_nokey ypreq_nokey; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypreq_nokey(XDR *, ypreq_nokey*); +#elif __STDC__ +extern bool_t __xdr_ypreq_nokey(XDR *, ypreq_nokey*); +#else /* Old Style C */ +bool_t __xdr_ypreq_nokey(); +#endif /* Old Style C */ + + +struct ypreq_xfr { + ypmap_parms map_parms; + u_int transid; + u_int prog; + u_int port; +}; +typedef struct ypreq_xfr ypreq_xfr; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypreq_xfr(XDR *, ypreq_xfr*); +#elif __STDC__ +extern bool_t __xdr_ypreq_xfr(XDR *, ypreq_xfr*); +#else /* Old Style C */ +bool_t __xdr_ypreq_xfr(); +#endif /* Old Style C */ + + +struct ypresp_val { + ypstat stat; + valdat val; +}; +typedef struct ypresp_val ypresp_val; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypresp_val(XDR *, ypresp_val*); +#elif __STDC__ +extern bool_t __xdr_ypresp_val(XDR *, ypresp_val*); +#else /* Old Style C */ +bool_t __xdr_ypresp_val(); +#endif /* Old Style C */ + + +struct ypresp_key_val { + ypstat stat; + keydat key; + valdat val; +}; +typedef struct ypresp_key_val ypresp_key_val; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypresp_key_val(XDR *, ypresp_key_val*); +#elif __STDC__ +extern bool_t __xdr_ypresp_key_val(XDR *, ypresp_key_val*); +#else /* Old Style C */ +bool_t __xdr_ypresp_key_val(); +#endif /* Old Style C */ + + +struct ypresp_master { + ypstat stat; + peername peer; +}; +typedef struct ypresp_master ypresp_master; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypresp_master(XDR *, ypresp_master*); +#elif __STDC__ +extern bool_t __xdr_ypresp_master(XDR *, ypresp_master*); +#else /* Old Style C */ +bool_t __xdr_ypresp_master(); +#endif /* Old Style C */ + + +struct ypresp_order { + ypstat stat; + u_int ordernum; +}; +typedef struct ypresp_order ypresp_order; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypresp_order(XDR *, ypresp_order*); +#elif __STDC__ +extern bool_t __xdr_ypresp_order(XDR *, ypresp_order*); +#else /* Old Style C */ +bool_t __xdr_ypresp_order(); +#endif /* Old Style C */ + + +typedef struct +{ + struct + { + int (*encode)(ypresp_key_val *val, void *data); + int (*close)(void *data); + } u; + void *data; +} __xdr_ypall_cb_t; + + +struct ypresp_all { + bool_t more; + union { + ypresp_key_val val; + } ypresp_all_u; +}; +typedef struct ypresp_all ypresp_all; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypresp_all(XDR *, ypresp_all*); +#elif __STDC__ +extern bool_t __xdr_ypresp_all(XDR *, ypresp_all*); +#else /* Old Style C */ +bool_t __xdr_ypresp_all(); +#endif /* Old Style C */ + + +struct ypresp_xfr { + u_int transid; + ypxfrstat xfrstat; +}; +typedef struct ypresp_xfr ypresp_xfr; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypresp_xfr(XDR *, ypresp_xfr*); +#elif __STDC__ +extern bool_t __xdr_ypresp_xfr(XDR *, ypresp_xfr*); +#else /* Old Style C */ +bool_t __xdr_ypresp_xfr(); +#endif /* Old Style C */ + + +struct ypmaplist { + mapname map; + struct ypmaplist *next; +}; +typedef struct ypmaplist ypmaplist; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypmaplist(XDR *, ypmaplist*); +#elif __STDC__ +extern bool_t __xdr_ypmaplist(XDR *, ypmaplist*); +#else /* Old Style C */ +bool_t __xdr_ypmaplist(); +#endif /* Old Style C */ + + +struct ypresp_maplist { + ypstat stat; + ypmaplist *maps; +}; +typedef struct ypresp_maplist ypresp_maplist; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypresp_maplist(XDR *, ypresp_maplist*); +#elif __STDC__ +extern bool_t __xdr_ypresp_maplist(XDR *, ypresp_maplist*); +#else /* Old Style C */ +bool_t __xdr_ypresp_maplist(); +#endif /* Old Style C */ + + +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; +#ifdef __cplusplus +extern "C" bool_t __xdr_yppush_status(XDR *, yppush_status*); +#elif __STDC__ +extern bool_t __xdr_yppush_status(XDR *, yppush_status*); +#else /* Old Style C */ +bool_t __xdr_yppush_status(); +#endif /* Old Style C */ + + +struct yppushresp_xfr { + u_int transid; + yppush_status status; +}; +typedef struct yppushresp_xfr yppushresp_xfr; +#ifdef __cplusplus +extern "C" bool_t __xdr_yppushresp_xfr(XDR *, yppushresp_xfr*); +#elif __STDC__ +extern bool_t __xdr_yppushresp_xfr(XDR *, yppushresp_xfr*); +#else /* Old Style C */ +bool_t __xdr_yppushresp_xfr(); +#endif /* Old Style C */ + + +enum ypbind_resptype { + YPBIND_SUCC_VAL = 1, + YPBIND_FAIL_VAL = 2 +}; +typedef enum ypbind_resptype ypbind_resptype; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypbind_resptype(XDR *, ypbind_resptype*); +#elif __STDC__ +extern bool_t __xdr_ypbind_resptype(XDR *, ypbind_resptype*); +#else /* Old Style C */ +bool_t __xdr_ypbind_resptype(); +#endif /* Old Style C */ + + +struct ypbind_binding { + char ypbind_binding_addr[4]; + char ypbind_binding_port[2]; +}; +typedef struct ypbind_binding ypbind_binding; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypbind_binding(XDR *, ypbind_binding*); +#elif __STDC__ +extern bool_t __xdr_ypbind_binding(XDR *, ypbind_binding*); +#else /* Old Style C */ +bool_t __xdr_ypbind_binding(); +#endif /* Old Style C */ + + +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; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypbind_resp(XDR *, ypbind_resp*); +#elif __STDC__ +extern bool_t __xdr_ypbind_resp(XDR *, ypbind_resp*); +#else /* Old Style C */ +bool_t __xdr_ypbind_resp(); +#endif /* Old Style C */ + +#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; +#ifdef __cplusplus +extern "C" bool_t __xdr_ypbind_setdom(XDR *, ypbind_setdom*); +#elif __STDC__ +extern bool_t __xdr_ypbind_setdom(XDR *, ypbind_setdom*); +#else /* Old Style C */ +bool_t __xdr_ypbind_setdom(); +#endif /* Old Style C */ + + +#define YPPROG ((u_long)100004) +#define YPVERS ((u_long)2) + +#ifdef __cplusplus +#define YPPROC_NULL ((u_long)0) +extern "C" void * ypproc_null_2(void *, CLIENT *); +extern "C" void * ypproc_null_2_svc(void *, struct svc_req *); +#define YPPROC_DOMAIN ((u_long)1) +extern "C" bool_t * ypproc_domain_2(domainname *, CLIENT *); +extern "C" bool_t * ypproc_domain_2_svc(domainname *, struct svc_req *); +#define YPPROC_DOMAIN_NONACK ((u_long)2) +extern "C" bool_t * ypproc_domain_nonack_2(domainname *, CLIENT *); +extern "C" bool_t * ypproc_domain_nonack_2_svc(domainname *, struct svc_req *); +#define YPPROC_MATCH ((u_long)3) +extern "C" ypresp_val * ypproc_match_2(ypreq_key *, CLIENT *); +extern "C" ypresp_val * ypproc_match_2_svc(ypreq_key *, struct svc_req *); +#define YPPROC_FIRST ((u_long)4) +extern "C" ypresp_key_val * ypproc_first_2(ypreq_nokey *, CLIENT *); +extern "C" ypresp_key_val * ypproc_first_2_svc(ypreq_nokey *, struct svc_req *); +#define YPPROC_NEXT ((u_long)5) +extern "C" ypresp_key_val * ypproc_next_2(ypreq_key *, CLIENT *); +extern "C" ypresp_key_val * ypproc_next_2_svc(ypreq_key *, struct svc_req *); +#define YPPROC_XFR ((u_long)6) +extern "C" ypresp_xfr * ypproc_xfr_2(ypreq_xfr *, CLIENT *); +extern "C" ypresp_xfr * ypproc_xfr_2_svc(ypreq_xfr *, struct svc_req *); +#define YPPROC_CLEAR ((u_long)7) +extern "C" void * ypproc_clear_2(void *, CLIENT *); +extern "C" void * ypproc_clear_2_svc(void *, struct svc_req *); +#define YPPROC_ALL ((u_long)8) +extern "C" ypresp_all * ypproc_all_2(ypreq_nokey *, CLIENT *); +extern "C" ypresp_all * ypproc_all_2_svc(ypreq_nokey *, struct svc_req *); +#define YPPROC_MASTER ((u_long)9) +extern "C" ypresp_master * ypproc_master_2(ypreq_nokey *, CLIENT *); +extern "C" ypresp_master * ypproc_master_2_svc(ypreq_nokey *, struct svc_req *); +#define YPPROC_ORDER ((u_long)10) +extern "C" ypresp_order * ypproc_order_2(ypreq_nokey *, CLIENT *); +extern "C" ypresp_order * ypproc_order_2_svc(ypreq_nokey *, struct svc_req *); +#define YPPROC_MAPLIST ((u_long)11) +extern "C" ypresp_maplist * ypproc_maplist_2(domainname *, CLIENT *); +extern "C" ypresp_maplist * ypproc_maplist_2_svc(domainname *, struct svc_req *); + +#elif __STDC__ +#define YPPROC_NULL ((u_long)0) +extern void * ypproc_null_2(void *, CLIENT *); +extern void * ypproc_null_2_svc(void *, struct svc_req *); +#define YPPROC_DOMAIN ((u_long)1) +extern bool_t * ypproc_domain_2(domainname *, CLIENT *); +extern bool_t * ypproc_domain_2_svc(domainname *, struct svc_req *); +#define YPPROC_DOMAIN_NONACK ((u_long)2) +extern bool_t * ypproc_domain_nonack_2(domainname *, CLIENT *); +extern bool_t * ypproc_domain_nonack_2_svc(domainname *, struct svc_req *); +#define YPPROC_MATCH ((u_long)3) +extern ypresp_val * ypproc_match_2(ypreq_key *, CLIENT *); +extern ypresp_val * ypproc_match_2_svc(ypreq_key *, struct svc_req *); +#define YPPROC_FIRST ((u_long)4) +extern ypresp_key_val * ypproc_first_2(ypreq_nokey *, CLIENT *); +extern ypresp_key_val * ypproc_first_2_svc(ypreq_nokey *, struct svc_req *); +#define YPPROC_NEXT ((u_long)5) +extern ypresp_key_val * ypproc_next_2(ypreq_key *, CLIENT *); +extern ypresp_key_val * ypproc_next_2_svc(ypreq_key *, struct svc_req *); +#define YPPROC_XFR ((u_long)6) +extern ypresp_xfr * ypproc_xfr_2(ypreq_xfr *, CLIENT *); +extern ypresp_xfr * ypproc_xfr_2_svc(ypreq_xfr *, struct svc_req *); +#define YPPROC_CLEAR ((u_long)7) +extern void * ypproc_clear_2(void *, CLIENT *); +extern void * ypproc_clear_2_svc(void *, struct svc_req *); +#define YPPROC_ALL ((u_long)8) +extern ypresp_all * ypproc_all_2(ypreq_nokey *, CLIENT *); +extern ypresp_all * ypproc_all_2_svc(ypreq_nokey *, struct svc_req *); +#define YPPROC_MASTER ((u_long)9) +extern ypresp_master * ypproc_master_2(ypreq_nokey *, CLIENT *); +extern ypresp_master * ypproc_master_2_svc(ypreq_nokey *, struct svc_req *); +#define YPPROC_ORDER ((u_long)10) +extern ypresp_order * ypproc_order_2(ypreq_nokey *, CLIENT *); +extern ypresp_order * ypproc_order_2_svc(ypreq_nokey *, struct svc_req *); +#define YPPROC_MAPLIST ((u_long)11) +extern ypresp_maplist * ypproc_maplist_2(domainname *, CLIENT *); +extern ypresp_maplist * ypproc_maplist_2_svc(domainname *, struct svc_req *); + +#else /* Old Style C */ +#define YPPROC_NULL ((u_long)0) +extern void * ypproc_null_2(); +extern void * ypproc_null_2_svc(); +#define YPPROC_DOMAIN ((u_long)1) +extern bool_t * ypproc_domain_2(); +extern bool_t * ypproc_domain_2_svc(); +#define YPPROC_DOMAIN_NONACK ((u_long)2) +extern bool_t * ypproc_domain_nonack_2(); +extern bool_t * ypproc_domain_nonack_2_svc(); +#define YPPROC_MATCH ((u_long)3) +extern ypresp_val * ypproc_match_2(); +extern ypresp_val * ypproc_match_2_svc(); +#define YPPROC_FIRST ((u_long)4) +extern ypresp_key_val * ypproc_first_2(); +extern ypresp_key_val * ypproc_first_2_svc(); +#define YPPROC_NEXT ((u_long)5) +extern ypresp_key_val * ypproc_next_2(); +extern ypresp_key_val * ypproc_next_2_svc(); +#define YPPROC_XFR ((u_long)6) +extern ypresp_xfr * ypproc_xfr_2(); +extern ypresp_xfr * ypproc_xfr_2_svc(); +#define YPPROC_CLEAR ((u_long)7) +extern void * ypproc_clear_2(); +extern void * ypproc_clear_2_svc(); +#define YPPROC_ALL ((u_long)8) +extern ypresp_all * ypproc_all_2(); +extern ypresp_all * ypproc_all_2_svc(); +#define YPPROC_MASTER ((u_long)9) +extern ypresp_master * ypproc_master_2(); +extern ypresp_master * ypproc_master_2_svc(); +#define YPPROC_ORDER ((u_long)10) +extern ypresp_order * ypproc_order_2(); +extern ypresp_order * ypproc_order_2_svc(); +#define YPPROC_MAPLIST ((u_long)11) +extern ypresp_maplist * ypproc_maplist_2(); +extern ypresp_maplist * ypproc_maplist_2_svc(); +#endif /* Old Style C */ + +#define YPPUSH_XFRRESPPROG ((u_long)0x40000000) +#define YPPUSH_XFRRESPVERS ((u_long)1) + +#ifdef __cplusplus +#define YPPUSHPROC_NULL ((u_long)0) +extern "C" void * yppushproc_null_1(void *, CLIENT *); +extern "C" void * yppushproc_null_1_svc(void *, struct svc_req *); +#define YPPUSHPROC_XFRRESP ((u_long)1) +extern "C" yppushresp_xfr * yppushproc_xfrresp_1(void *, CLIENT *); +extern "C" yppushresp_xfr * yppushproc_xfrresp_1_svc(void *, struct svc_req *); + +#elif __STDC__ +#define YPPUSHPROC_NULL ((u_long)0) +extern void * yppushproc_null_1(void *, CLIENT *); +extern void * yppushproc_null_1_svc(void *, struct svc_req *); +#define YPPUSHPROC_XFRRESP ((u_long)1) +extern yppushresp_xfr * yppushproc_xfrresp_1(void *, CLIENT *); +extern yppushresp_xfr * yppushproc_xfrresp_1_svc(void *, struct svc_req *); + +#else /* Old Style C */ +#define YPPUSHPROC_NULL ((u_long)0) +extern void * yppushproc_null_1(); +extern void * yppushproc_null_1_svc(); +#define YPPUSHPROC_XFRRESP ((u_long)1) +extern yppushresp_xfr * yppushproc_xfrresp_1(); +extern yppushresp_xfr * yppushproc_xfrresp_1_svc(); +#endif /* Old Style C */ + +#define YPBINDPROG ((u_long)100007) +#define YPBINDVERS ((u_long)2) + +#ifdef __cplusplus +#define YPBINDPROC_NULL ((u_long)0) +extern "C" void * ypbindproc_null_2(void *, CLIENT *); +extern "C" void * ypbindproc_null_2_svc(void *, struct svc_req *); +#define YPBINDPROC_DOMAIN ((u_long)1) +extern "C" ypbind_resp * ypbindproc_domain_2(domainname *, CLIENT *); +extern "C" ypbind_resp * ypbindproc_domain_2_svc(domainname *, struct svc_req *); +#define YPBINDPROC_SETDOM ((u_long)2) +extern "C" void * ypbindproc_setdom_2(ypbind_setdom *, CLIENT *); +extern "C" void * ypbindproc_setdom_2_svc(ypbind_setdom *, struct svc_req *); + +#elif __STDC__ +#define YPBINDPROC_NULL ((u_long)0) +extern void * ypbindproc_null_2(void *, CLIENT *); +extern void * ypbindproc_null_2_svc(void *, struct svc_req *); +#define YPBINDPROC_DOMAIN ((u_long)1) +extern ypbind_resp * ypbindproc_domain_2(domainname *, CLIENT *); +extern ypbind_resp * ypbindproc_domain_2_svc(domainname *, struct svc_req *); +#define YPBINDPROC_SETDOM ((u_long)2) +extern void * ypbindproc_setdom_2(ypbind_setdom *, CLIENT *); +extern void * ypbindproc_setdom_2_svc(ypbind_setdom *, struct svc_req *); + +#else /* Old Style C */ +#define YPBINDPROC_NULL ((u_long)0) +extern void * ypbindproc_null_2(); +extern void * ypbindproc_null_2_svc(); +#define YPBINDPROC_DOMAIN ((u_long)1) +extern ypbind_resp * ypbindproc_domain_2(); +extern ypbind_resp * ypbindproc_domain_2_svc(); +#define YPBINDPROC_SETDOM ((u_long)2) +extern void * ypbindproc_setdom_2(); +extern void * ypbindproc_setdom_2_svc(); +#endif /* Old Style C */ + +#endif /* !_YP_H_RPCGEN */ diff --git a/gnu/usr.sbin/ypserv/yp_svc.c b/gnu/usr.sbin/ypserv/yp_svc.c new file mode 100644 index 0000000..fc525cd --- /dev/null +++ b/gnu/usr.sbin/ypserv/yp_svc.c @@ -0,0 +1,393 @@ +/* + * And thus spoke RPCGEN: + * Please do not edit this file. + * It was generated using rpcgen. + * + * And thus replied Lpd@NannyMUD: + * Who cares? :-) /Peter Eriksson <pen@signum.se> + * + * $Id$ + */ + +#include "system.h" + +#include "yp.h" +#include <stdio.h> +#include <stdlib.h> +#include <rpc/pmap_clnt.h> +#include <string.h> +#include <memory.h> +#include <unistd.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <syslog.h> +#include <errno.h> +#include <paths.h> + +extern int errno; +extern void Perror(); + +#ifdef __STDC__ +#define SIG_PF void(*)(int) +#endif + +static void +ypprog_2(struct svc_req *rqstp, register SVCXPRT *transp) +{ + union { + domainname ypproc_domain_2_arg; + domainname ypproc_domain_nonack_2_arg; + ypreq_key ypproc_match_2_arg; + ypreq_key ypproc_first_2_arg; + ypreq_key ypproc_next_2_arg; + ypreq_xfr ypproc_xfr_2_arg; + ypreq_nokey ypproc_all_2_arg; + ypreq_nokey ypproc_master_2_arg; + ypreq_nokey ypproc_order_2_arg; + domainname ypproc_maplist_2_arg; + } argument; + char *result; + xdrproc_t __xdr_argument, __xdr_result; + char *(*local)(char *, struct svc_req *); + + switch (rqstp->rq_proc) { + case YPPROC_NULL: + __xdr_argument = (xdrproc_t) xdr_void; + __xdr_result = (xdrproc_t) xdr_void; + local = (char *(*)(char *, struct svc_req *)) ypproc_null_2_svc; + break; + + case YPPROC_DOMAIN: + __xdr_argument = (xdrproc_t) __xdr_domainname; + __xdr_result = (xdrproc_t) xdr_bool; + local = (char *(*)(char *, struct svc_req *)) ypproc_domain_2_svc; + break; + + case YPPROC_DOMAIN_NONACK: + __xdr_argument = (xdrproc_t) __xdr_domainname; + __xdr_result = (xdrproc_t) xdr_bool; + local = (char *(*)(char *, struct svc_req *)) ypproc_domain_nonack_2_svc; + break; + + case YPPROC_MATCH: + __xdr_argument = (xdrproc_t) __xdr_ypreq_key; + __xdr_result = (xdrproc_t) __xdr_ypresp_val; + local = (char *(*)(char *, struct svc_req *)) ypproc_match_2_svc; + break; + + case YPPROC_FIRST: +#if 0 /* Bug in Sun's yp.x RPC prototype file */ + __xdr_argument = (xdrproc_t) __xdr_ypreq_key; +#else + __xdr_argument = (xdrproc_t) __xdr_ypreq_nokey; +#endif + __xdr_result = (xdrproc_t) __xdr_ypresp_key_val; + local = (char *(*)(char *, struct svc_req *)) ypproc_first_2_svc; + break; + + case YPPROC_NEXT: + __xdr_argument = (xdrproc_t) __xdr_ypreq_key; + __xdr_result = (xdrproc_t) __xdr_ypresp_key_val; + local = (char *(*)(char *, struct svc_req *)) ypproc_next_2_svc; + break; + + case YPPROC_XFR: + __xdr_argument = (xdrproc_t) __xdr_ypreq_xfr; + __xdr_result = (xdrproc_t) __xdr_ypresp_xfr; + local = (char *(*)(char *, struct svc_req *)) ypproc_xfr_2_svc; + break; + + case YPPROC_CLEAR: + __xdr_argument = (xdrproc_t) xdr_void; + __xdr_result = (xdrproc_t) xdr_void; + local = (char *(*)(char *, struct svc_req *)) ypproc_clear_2_svc; + break; + + case YPPROC_ALL: + __xdr_argument = (xdrproc_t) __xdr_ypreq_nokey; + __xdr_result = (xdrproc_t) __xdr_ypresp_all; + local = (char *(*)(char *, struct svc_req *)) ypproc_all_2_svc; + break; + + case YPPROC_MASTER: + __xdr_argument = (xdrproc_t) __xdr_ypreq_nokey; + __xdr_result = (xdrproc_t) __xdr_ypresp_master; + local = (char *(*)(char *, struct svc_req *)) ypproc_master_2_svc; + break; + + case YPPROC_ORDER: + __xdr_argument = (xdrproc_t) __xdr_ypreq_nokey; + __xdr_result = (xdrproc_t) __xdr_ypresp_order; + local = (char *(*)(char *, struct svc_req *)) ypproc_order_2_svc; + break; + + case YPPROC_MAPLIST: + __xdr_argument = (xdrproc_t) __xdr_domainname; + __xdr_result = (xdrproc_t) __xdr_ypresp_maplist; + local = (char *(*)(char *, struct svc_req *)) ypproc_maplist_2_svc; + break; + + default: + svcerr_noproc(transp); + return; + } + (void) memset((char *)&argument, 0, sizeof (argument)); + if (!svc_getargs(transp, __xdr_argument, (caddr_t) &argument)) { + svcerr_decode(transp); + return; + } + result = (*local)((char *)&argument, rqstp); + if (result != NULL && !svc_sendreply(transp, __xdr_result, result)) { + svcerr_systemerr(transp); + } + if (!svc_freeargs(transp, __xdr_argument, (caddr_t) &argument)) { + fprintf(stderr, "unable to free arguments"); + exit(1); + } + return; +} + +#if 0 +static void +yppush_xfrrespprog_1(struct svc_req *rqstp, register SVCXPRT *transp) +{ + union { + int fill; + } argument; + char *result; + xdrproc_t __xdr_argument, __xdr_result; + char *(*local)(char *, struct svc_req *); + + switch (rqstp->rq_proc) { + case YPPUSHPROC_NULL: + __xdr_argument = (xdrproc_t) xdr_void; + __xdr_result = (xdrproc_t) xdr_void; + local = (char *(*)(char *, struct svc_req *)) yppushproc_null_1_svc; + break; + + case YPPUSHPROC_XFRRESP: + __xdr_argument = (xdrproc_t) xdr_void; + __xdr_result = (xdrproc_t) __xdr_yppushresp_xfr; + local = (char *(*)(char *, struct svc_req *)) yppushproc_xfrresp_1_svc; + break; + + default: + svcerr_noproc(transp); + return; + } + (void) memset((char *)&argument, 0, sizeof (argument)); + if (!svc_getargs(transp, __xdr_argument, (caddr_t) &argument)) { + svcerr_decode(transp); + return; + } + result = (*local)((char *)&argument, rqstp); + if (result != NULL && !svc_sendreply(transp, __xdr_result, result)) { + svcerr_systemerr(transp); + } + if (!svc_freeargs(transp, __xdr_argument, (caddr_t) &argument)) { + fprintf(stderr, "unable to free arguments"); + exit(1); + } + return; +} + +static void +ypbindprog_2(struct svc_req *rqstp, register SVCXPRT *transp) +{ + union { + domainname ypbindproc_domain_2_arg; + ypbind_setdom ypbindproc_setdom_2_arg; + } argument; + char *result; + xdrproc_t __xdr_argument, __xdr_result; + char *(*local)(char *, struct svc_req *); + + switch (rqstp->rq_proc) { + case YPBINDPROC_NULL: + __xdr_argument = (xdrproc_t) xdr_void; + __xdr_result = (xdrproc_t) xdr_void; + local = (char *(*)(char *, struct svc_req *)) ypbindproc_null_2_svc; + break; + + case YPBINDPROC_DOMAIN: + __xdr_argument = (xdrproc_t) __xdr_domainname; + __xdr_result = (xdrproc_t) __xdr_ypbind_resp; + local = (char *(*)(char *, struct svc_req *)) ypbindproc_domain_2_svc; + break; + + case YPBINDPROC_SETDOM: + __xdr_argument = (xdrproc_t) __xdr_ypbind_setdom; + __xdr_result = (xdrproc_t) xdr_void; + local = (char *(*)(char *, struct svc_req *)) ypbindproc_setdom_2_svc; + break; + + default: + svcerr_noproc(transp); + return; + } + (void) memset((char *)&argument, 0, sizeof (argument)); + if (!svc_getargs(transp, __xdr_argument, (caddr_t) &argument)) { + svcerr_decode(transp); + return; + } + result = (*local)((char *)&argument, rqstp); + if (result != NULL && !svc_sendreply(transp, __xdr_result, result)) { + svcerr_systemerr(transp); + } + if (!svc_freeargs(transp, __xdr_argument, (caddr_t) &argument)) { + fprintf(stderr, "unable to free arguments"); + exit(1); + } + return; +} +#endif + +extern int debug_flag; +extern int dns_flag; + +#ifndef _PATH_YP +#define _PATH_YP "/var/yp" +#endif +char *path_ypdb = _PATH_YP; + +char *progname; + + +int main(int argc, char **argv) +{ + register SVCXPRT *transp; + int i; + int my_port = -1; + int my_socket; + struct sockaddr_in socket_address; + int result; + + + progname = strrchr (argv[0], '/'); + if (progname == (char *) NULL) + progname = argv[0]; + else + progname++; + + openlog(progname, LOG_PID, TCPW_FACILITY); + + for (i = 1; i < argc && argv[i][0] == '-'; i++) + { + if (strcmp(argv[i], "-debug") == 0 || strcmp(argv[i], "-d") == 0) + debug_flag = 1; + else if (strcmp(argv[i], "-dns") == 0 || strcmp(argv[i], "-b") == 0) + dns_flag = 1; + else if ((argv[i][1] == 'p') && (argv[i][2] >= '0') && (argv[i][2] <= '9')) + my_port = atoi(argv[i] + 2); + else + { + fprintf(stderr, "%s: Unknown command line switch: %s\n", + progname, + argv[i]); + exit(1); + } + } + + if (!debug_flag) + if(daemon(0,0)) + { + perror("daemon()"); + exit (1); + } + + if (debug_flag) + Perror("[Welcome to the NYS YP Server, version 0.11]\n"); + + if (i < argc) + { + path_ypdb = argv[i]; + if (debug_flag) + Perror("Using database directory: %s\n", path_ypdb); + } + + /* Change current directory to database location */ + if (chdir(path_ypdb) < 0) + { + Perror("%s: chdir: %", argv[0], strerror(errno)); + exit(1); + } + + (void) pmap_unset(YPPROG, YPVERS); + + if (my_port >= 0) + { + my_socket = socket (AF_INET, SOCK_DGRAM, 0); + if (my_socket < 0) + { + Perror("%s: can not create UDP: %s", + progname, strerror(errno)); + exit (1); + } + + socket_address.sin_family = AF_INET; + socket_address.sin_addr.s_addr = htonl (INADDR_ANY); + socket_address.sin_port = htons (my_port); + + result = bind (my_socket, (struct sockaddr *) &socket_address, + sizeof (socket_address)); + if (result < 0) + { + Perror("%s: can not create UDP: %s", + progname, strerror(errno)); + exit (1); + } + } + else + my_socket = RPC_ANYSOCK; + + transp = svcudp_create(my_socket); + if (transp == NULL) { + Perror("cannot create udp service."); + exit(1); + } + if (!svc_register(transp, YPPROG, YPVERS, ypprog_2, IPPROTO_UDP)) { + Perror("unable to register (YPPROG, YPVERS, udp)."); + exit(1); + } + + if (my_port >= 0) + { + my_socket = socket (AF_INET, SOCK_STREAM, 0); + if (my_socket < 0) + { + Perror("%s: can not create TCP: %s", + progname, strerror(errno)); + exit (1); + } + + socket_address.sin_family = AF_INET; + socket_address.sin_addr.s_addr = htonl (INADDR_ANY); + socket_address.sin_port = htons (my_port); + + result = bind (my_socket, (struct sockaddr *) &socket_address, + sizeof (socket_address)); + if (result < 0) + { + Perror("%s: can not create TCP: %s", + progname, strerror(errno)); + exit (1); + } + } + else + my_socket = RPC_ANYSOCK; + + transp = svctcp_create(my_socket, 0, 0); + if (transp == NULL) { + Perror("%s: cannot create tcp service\n", progname); + exit(1); + } + if (!svc_register(transp, YPPROG, YPVERS, ypprog_2, IPPROTO_TCP)) { + Perror("%s: unable to register (YPPROG, YPVERS, tcp)\n", progname); + exit(1); + } + + svc_run(); + Perror("svc_run returned"); + exit(1); + /* NOTREACHED */ +} diff --git a/gnu/usr.sbin/ypserv/yp_xdr.c b/gnu/usr.sbin/ypserv/yp_xdr.c new file mode 100644 index 0000000..bb70473 --- /dev/null +++ b/gnu/usr.sbin/ypserv/yp_xdr.c @@ -0,0 +1,415 @@ +/* + * And thus spoke RPCGEN: + * Please do not edit this file. + * It was generated using rpcgen. + * + * And thus replied Lpd@NannyMUD: + * Who cares? :-) /Peter Eriksson <pen@signum.se> + * + * + * Modification history: + * 940616 pen@signum.se Major cleanups. + * 940713 pen@signum.se Added SunOS 4 prototypes. + * + * $Id$ + */ + +#include "system.h" + + +#include "yp.h" + +#ifndef NULL +#define NULL 0 +#endif + +__xdr_ypall_cb_t __xdr_ypall_cb; + +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 0 /* The Sun-supplied yp.x RPC input file have these in the wrong order */ + if (!__xdr_keydat(xdrs, &objp->key)) + return FALSE; + + if (!__xdr_valdat(xdrs, &objp->val)) + return FALSE; +#else + if (!__xdr_valdat(xdrs, &objp->val)) + return FALSE; + + if (!__xdr_keydat(xdrs, &objp->key)) + return FALSE; +#endif + 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) +{ + if (xdrs->x_op == XDR_ENCODE) + { + while (1) + { + if (!xdr_bool(xdrs, &objp->more)) + { + if (__xdr_ypall_cb.u.close != NULL) + (*(__xdr_ypall_cb.u.close))(__xdr_ypall_cb.data); + + __xdr_ypall_cb.data = NULL; + + return FALSE; + } + + if (!__xdr_ypresp_key_val(xdrs, &objp->ypresp_all_u.val)) + { + if (__xdr_ypall_cb.u.close != NULL) + (*(__xdr_ypall_cb.u.close))(__xdr_ypall_cb.data); + + __xdr_ypall_cb.data = NULL; + + return FALSE; + } + + if (objp->ypresp_all_u.val.stat != YP_TRUE) + { + objp->more = FALSE; + + if (__xdr_ypall_cb.u.close != NULL) + (*(__xdr_ypall_cb.u.close))(__xdr_ypall_cb.data); + + __xdr_ypall_cb.data = NULL; + + if (!xdr_bool(xdrs, &objp->more)) + return FALSE; + + return TRUE; + } + + if ((*__xdr_ypall_cb.u.encode)(&objp->ypresp_all_u.val, + __xdr_ypall_cb.data) == YP_NOKEY) + objp->more = FALSE; + } + } + +#ifdef NOTYET /* This code isn't needed in the server */ + else if (xdrs->x_op == XDR_DECODE) + { + int more = 0; + + + while (1) + { + 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 (more == 0) + more = (*__xdr_ypall_callback->foreach.decoder) + (&objp->ypresp_all_u.val, __xdr_ypall_callback->data); + break; + + case FALSE: + return TRUE; + + default: + return FALSE; + } + } + 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; +} |
