d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
a293037f7c
freebsd-nq/usr.sbin/ypserv/yp_server.c

952 lines
23 KiB
C
Raw Normal View History

Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
/*
* Copyright (c) 1995
* Bill Paul <wpaul@ctr.columbia.edu>. All rights reserved.
*
* 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 author nor the names of any co-contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY Bill Paul 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 Bill Paul 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.
*
*/
Typos in man page. Cosmetics in error strings.
1997-10-29 07:25:05 +00:00
#ifndef lint
static const char rcsid[] =
"$Id$";
#endif /* not lint */
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
#include "yp.h"
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
#include "yp_extern.h"
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
#include <dirent.h>
Typos in man page. Cosmetics in error strings.
1997-10-29 07:25:05 +00:00
#include <errno.h>
#include <stdlib.h>
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
#include <sys/stat.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
A few small tweaks related to ypxfr: - Add a ypxfr_callback() function that we can use to signal failure to yppush(8) in the event that we can't fork()/exec() ypxfr(8). yppush only checks the return status from YPPROC_XFR enough to determine that the RPC succeded: it relies on its callback service to figure out whether or not the transfer actually worked. - Give yp_dblookup.c its own debug variable (ypdb_debug) so that DB access debugging messages can be turned on or off independent of the program's global debug messages. - Have the Makefile rpcgen the ypushresp_xfr_1() client stub for us and nuke the unneeded rule for yp_xdr.c that I left in by mistake (the XDR filters live in libc now).
1995-12-23 21:35:35 +00:00
#include <rpc/rpc.h>
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
int forked = 0;
int children = 0;
Don't initialize structures from other variables; gcc -ansi -pedantic doesn't allow it. Use proper constants instead.
1997-08-10 20:37:48 +00:00
#define MASTER_STRING "YP_MASTER_NAME"
#define MASTER_SZ sizeof(MASTER_STRING) - 1
#define ORDER_STRING "YP_LAST_MODIFIED"
#define ORDER_SZ sizeof(ORDER_STRING) - 1
Performance enhancements (I hope) and new stuff: yp_dblookup.c: - Implement database handle caching. What this means is that instead of opening and closing map databases for each request, we open a database and save the handle (and, if requested, the key index) in an array. This saves a bit of overhead on things like repeated YPPROC_NEXT calls, such as you'd get from getpwent(). Normally, each YPPROC_NEXT would require open()ing the database, seeking to the location supplied by the caller (which is time consuming with hash databases as the R_CURSOR flag doesn't work), reading the data, close()ing the database and then shipping the data off to the caller. The system call overhead is prohibitive, especially with very large maps. By caching the handle to an open database, we elimitate at least the open()/close() system calls, as well as the associated DB setup and tear-down operations, for a large percentage of the time. This improves performance substantially at the cost of consuming a little more memory than before. Note that all the caching support is surrounded by #ifdef DB_CACHE so that this same source module can still be used by other programs that don't need it. - Make yp_open_db() call yp_validdomain(). Doing it here saves cycles when caching is enabled since a hit on the map cache list by definition means that the domain being referenced is valid. - Also make yp_open_db() check for exhaustion of file descriptors, just in case. yp_server.c: - Reorganize things a little to take advantage of the database handle caching. Add a call to yp_flush_all() in ypproc_clear_2_svc(). - Remove calls to yp_validdomain() from some of the service procedures. yp_validdomain() is called inside yp_open_db() now, so procedures that call into the database package don't need to use yp_validdomain() themselves. - Fix a bogosity in ypproc_maplist_2_svc(): don't summarily initiallize the result.maps pointer to NULL. This causes yp_maplist_free() to fail and leaks memory. - Make ypproc_master_2_svc() copy the string it gets from the database package into a private static buffer before trying to NUL terminate it. This is necessary with the DB handle caching: stuffing a NUL into the data returned by DB package will goof it up internally. yp_main.c: - Stuff for DB handle caching: call yp_init_dbs() to clear the handle array and add call to yp_flush_all() to the SIGHUP signal handler. Makefile.yp: - Reorganize to deal with database caching. yp_mkdb(8) can now be used to send a YPPROC_CLEAR signal to ypserv(8). Call it after each map is created to refresh ypserv's cache. - Add support for mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). - Make default location for the netgroups source file be /var/yp/netgroup instead of /etc/netgroup. mkaliases: - New file: script to generate mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). Makefile: - Install Makefile.yp as /var/yp/Makefile.dist and link it to /var/yp/Makefile only if /var/yp/Makefile doesn't already exist. Suggested by Peter Wemm. - Install new mkaliases script in /usr/libexec along with mknetid. - Use somewhat saner approach to generating rpcgen-dependent files as suggested by Garrett Wollman.
1996-04-28 04:38:52 +00:00
Add support for NIS v1 client procedures. The following procedures are currently implemented: YPOLDPROC_NULL YPOLDPROC_DOMAIN YPOLDPROC_DOMAIN_NONACK YPOLDPROC_FIRST YPOLDPROC_NEXT YPOLDPROC_MATCH YPOLDPROC_POLL These are all implemented as wrappers around their v2 counterparts. The YPOLDPROC_PUSH, PULL and GET procedures are not implemented since a) I couldn't figure out exactly what to have them do, and b) I suspect they're used for doing map transfers between master and slave servers, which we already do using the v2 protocol anyway. This means we can server NIS v1 clients but can't be a master or slave with NIS v1-only servers. I think I'll get over it. :) The -k (sunos_4_kludge) flag and associated code has been removed since it is no longer needed. Also tweaked yp_access() to handle both sets of procedures and updated the man page.
1996-02-26 02:34:27 +00:00
/*
* NIS v2 support. This is where most of the action happens.
*/
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
void *
ypproc_null_2_svc(void *argp, struct svc_req *rqstp)
{
static char * result;
static char rval = 0;
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#ifdef DB_CACHE
if (yp_access(NULL, NULL, (struct svc_req *)rqstp))
#else
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
if (yp_access(NULL, (struct svc_req *)rqstp))
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#endif
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
return(NULL);
result = &rval;
return((void *) &result);
}
bool_t *
ypproc_domain_2_svc(domainname *argp, struct svc_req *rqstp)
{
static bool_t result;
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#ifdef DB_CACHE
if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) {
#else
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
if (yp_access(NULL, (struct svc_req *)rqstp)) {
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#endif
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
result = FALSE;
return (&result);
}
if (argp == NULL || yp_validdomain(*argp))
result = FALSE;
else
result = TRUE;
return (&result);
}
bool_t *
ypproc_domain_nonack_2_svc(domainname *argp, struct svc_req *rqstp)
{
static bool_t result;
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#ifdef DB_CACHE
if (yp_access(NULL, NULL, (struct svc_req *)rqstp))
#else
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
if (yp_access(NULL, (struct svc_req *)rqstp))
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#endif
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
return (NULL);
if (argp == NULL || yp_validdomain(*argp))
return (NULL);
else
result = TRUE;
return (&result);
}
ypresp_val *
ypproc_match_2_svc(ypreq_key *argp, struct svc_req *rqstp)
{
static ypresp_val result;
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
result.val.valdat_val = "";
result.val.valdat_len = 0;
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#ifdef DB_CACHE
if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
#else
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
if (yp_access(argp->map, (struct svc_req *)rqstp)) {
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#endif
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
result.stat = YP_YPERR;
return (&result);
}
if (argp->domain == NULL || argp->map == NULL) {
result.stat = YP_BADARGS;
return (&result);
}
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
if (yp_select_map(argp->map, argp->domain, &argp->key, 1) != YP_TRUE) {
result.stat = yp_errno;
return(&result);
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
}
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
result.stat = yp_getbykey(&argp->key, &result.val);
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
/*
* Do DNS lookups for hosts maps if database lookup failed.
*/
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#ifdef DB_CACHE
if (result.stat != YP_TRUE &&
(yp_testflag(argp->map, argp->domain, YP_INTERDOMAIN) ||
(strstr(argp->map, "hosts") && do_dns))) {
#else
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
if (do_dns && result.stat != YP_TRUE && strstr(argp->map, "hosts")) {
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#endif
Fix a very stupid heap corruption bug: in ypproc_match_2_svc(), when we decide to do a DNS lookup, we NUL terminate the key string provided by the client before passing it into the DNS lookup module. This is actually wrong. Assume the key is 'foo.com'. In this case, key.keydat_val will be "foo.com" and key.keydat_len will be 7 (seven characters; the string is not NUL-terminated so it is not 8 as you might expect). The string "foo.com" is actually allocated by the XDR routines when the RPC request is decoded; exactly 7 bytes are allocated. By adding a NUL, the string becomes "foo.com\0", but the '\0' goes into an 8th byte which was never allocated for this string and which could be anywhere. The result is that while the initial request may succeed, we could trash other dynamically allocated structures (like, oh, I dunno, the circular map cache queue?) and SEGV later. This is in fact what happens. The fix is to copy the string into a larger local buffer and NUL-terminate that buffer instead. Crash first reported by: Ricky Chan <ricky@come.net.uk> Bug finally located with: Electric Fence 2.0.5
1997-07-21 17:39:39 +00:00
char nbuf[YPMAXRECORD];
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
/* NUL terminate! NUL terminate!! NUL TERMINATE!!! */
Fix a very stupid heap corruption bug: in ypproc_match_2_svc(), when we decide to do a DNS lookup, we NUL terminate the key string provided by the client before passing it into the DNS lookup module. This is actually wrong. Assume the key is 'foo.com'. In this case, key.keydat_val will be "foo.com" and key.keydat_len will be 7 (seven characters; the string is not NUL-terminated so it is not 8 as you might expect). The string "foo.com" is actually allocated by the XDR routines when the RPC request is decoded; exactly 7 bytes are allocated. By adding a NUL, the string becomes "foo.com\0", but the '\0' goes into an 8th byte which was never allocated for this string and which could be anywhere. The result is that while the initial request may succeed, we could trash other dynamically allocated structures (like, oh, I dunno, the circular map cache queue?) and SEGV later. This is in fact what happens. The fix is to copy the string into a larger local buffer and NUL-terminate that buffer instead. Crash first reported by: Ricky Chan <ricky@come.net.uk> Bug finally located with: Electric Fence 2.0.5
1997-07-21 17:39:39 +00:00
bcopy(argp->key.keydat_val, nbuf, argp->key.keydat_len);
nbuf[argp->key.keydat_len] = '\0';
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
if (debug)
Typos in man page. Cosmetics in error strings.
1997-10-29 07:25:05 +00:00
yp_error("doing DNS lookup of %s", nbuf);
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
if (!strcmp(argp->map, "hosts.byname"))
Fix a very stupid heap corruption bug: in ypproc_match_2_svc(), when we decide to do a DNS lookup, we NUL terminate the key string provided by the client before passing it into the DNS lookup module. This is actually wrong. Assume the key is 'foo.com'. In this case, key.keydat_val will be "foo.com" and key.keydat_len will be 7 (seven characters; the string is not NUL-terminated so it is not 8 as you might expect). The string "foo.com" is actually allocated by the XDR routines when the RPC request is decoded; exactly 7 bytes are allocated. By adding a NUL, the string becomes "foo.com\0", but the '\0' goes into an 8th byte which was never allocated for this string and which could be anywhere. The result is that while the initial request may succeed, we could trash other dynamically allocated structures (like, oh, I dunno, the circular map cache queue?) and SEGV later. This is in fact what happens. The fix is to copy the string into a larger local buffer and NUL-terminate that buffer instead. Crash first reported by: Ricky Chan <ricky@come.net.uk> Bug finally located with: Electric Fence 2.0.5
1997-07-21 17:39:39 +00:00
result.stat = yp_async_lookup_name(rqstp, nbuf);
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
else if (!strcmp(argp->map, "hosts.byaddr"))
Fix a very stupid heap corruption bug: in ypproc_match_2_svc(), when we decide to do a DNS lookup, we NUL terminate the key string provided by the client before passing it into the DNS lookup module. This is actually wrong. Assume the key is 'foo.com'. In this case, key.keydat_val will be "foo.com" and key.keydat_len will be 7 (seven characters; the string is not NUL-terminated so it is not 8 as you might expect). The string "foo.com" is actually allocated by the XDR routines when the RPC request is decoded; exactly 7 bytes are allocated. By adding a NUL, the string becomes "foo.com\0", but the '\0' goes into an 8th byte which was never allocated for this string and which could be anywhere. The result is that while the initial request may succeed, we could trash other dynamically allocated structures (like, oh, I dunno, the circular map cache queue?) and SEGV later. This is in fact what happens. The fix is to copy the string into a larger local buffer and NUL-terminate that buffer instead. Crash first reported by: Ricky Chan <ricky@come.net.uk> Bug finally located with: Electric Fence 2.0.5
1997-07-21 17:39:39 +00:00
result.stat = yp_async_lookup_addr(rqstp, nbuf);
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
if (result.stat == YP_TRUE)
return(NULL);
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
}
return (&result);
}
ypresp_key_val *
ypproc_first_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
{
static ypresp_key_val result;
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
result.val.valdat_val = result.key.keydat_val = "";
result.val.valdat_len = result.key.keydat_len = 0;
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#ifdef DB_CACHE
if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
#else
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
if (yp_access(argp->map, (struct svc_req *)rqstp)) {
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#endif
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
result.stat = YP_YPERR;
return (&result);
}
if (argp->domain == NULL) {
result.stat = YP_BADARGS;
return (&result);
}
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
if (yp_select_map(argp->map, argp->domain, &result.key, 0) != YP_TRUE) {
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
result.stat = yp_errno;
return(&result);
}
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
result.stat = yp_firstbykey(&result.key, &result.val);
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
return (&result);
}
ypresp_key_val *
ypproc_next_2_svc(ypreq_key *argp, struct svc_req *rqstp)
{
static ypresp_key_val result;
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
result.val.valdat_val = result.key.keydat_val = "";
result.val.valdat_len = result.key.keydat_len = 0;
Performance enhancements (I hope) and new stuff: yp_dblookup.c: - Implement database handle caching. What this means is that instead of opening and closing map databases for each request, we open a database and save the handle (and, if requested, the key index) in an array. This saves a bit of overhead on things like repeated YPPROC_NEXT calls, such as you'd get from getpwent(). Normally, each YPPROC_NEXT would require open()ing the database, seeking to the location supplied by the caller (which is time consuming with hash databases as the R_CURSOR flag doesn't work), reading the data, close()ing the database and then shipping the data off to the caller. The system call overhead is prohibitive, especially with very large maps. By caching the handle to an open database, we elimitate at least the open()/close() system calls, as well as the associated DB setup and tear-down operations, for a large percentage of the time. This improves performance substantially at the cost of consuming a little more memory than before. Note that all the caching support is surrounded by #ifdef DB_CACHE so that this same source module can still be used by other programs that don't need it. - Make yp_open_db() call yp_validdomain(). Doing it here saves cycles when caching is enabled since a hit on the map cache list by definition means that the domain being referenced is valid. - Also make yp_open_db() check for exhaustion of file descriptors, just in case. yp_server.c: - Reorganize things a little to take advantage of the database handle caching. Add a call to yp_flush_all() in ypproc_clear_2_svc(). - Remove calls to yp_validdomain() from some of the service procedures. yp_validdomain() is called inside yp_open_db() now, so procedures that call into the database package don't need to use yp_validdomain() themselves. - Fix a bogosity in ypproc_maplist_2_svc(): don't summarily initiallize the result.maps pointer to NULL. This causes yp_maplist_free() to fail and leaks memory. - Make ypproc_master_2_svc() copy the string it gets from the database package into a private static buffer before trying to NUL terminate it. This is necessary with the DB handle caching: stuffing a NUL into the data returned by DB package will goof it up internally. yp_main.c: - Stuff for DB handle caching: call yp_init_dbs() to clear the handle array and add call to yp_flush_all() to the SIGHUP signal handler. Makefile.yp: - Reorganize to deal with database caching. yp_mkdb(8) can now be used to send a YPPROC_CLEAR signal to ypserv(8). Call it after each map is created to refresh ypserv's cache. - Add support for mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). - Make default location for the netgroups source file be /var/yp/netgroup instead of /etc/netgroup. mkaliases: - New file: script to generate mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). Makefile: - Install Makefile.yp as /var/yp/Makefile.dist and link it to /var/yp/Makefile only if /var/yp/Makefile doesn't already exist. Suggested by Peter Wemm. - Install new mkaliases script in /usr/libexec along with mknetid. - Use somewhat saner approach to generating rpcgen-dependent files as suggested by Garrett Wollman.
1996-04-28 04:38:52 +00:00
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#ifdef DB_CACHE
if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
#else
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
if (yp_access(argp->map, (struct svc_req *)rqstp)) {
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#endif
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
result.stat = YP_YPERR;
return (&result);
}
if (argp->domain == NULL || argp->map == NULL) {
result.stat = YP_BADARGS;
return (&result);
}
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
if (yp_select_map(argp->map, argp->domain, &argp->key, 0) != YP_TRUE) {
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
result.stat = yp_errno;
return(&result);
}
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
result.key.keydat_len = argp->key.keydat_len;
result.key.keydat_val = argp->key.keydat_val;
result.stat = yp_nextbykey(&result.key, &result.val);
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
return (&result);
}
A few small tweaks related to ypxfr: - Add a ypxfr_callback() function that we can use to signal failure to yppush(8) in the event that we can't fork()/exec() ypxfr(8). yppush only checks the return status from YPPROC_XFR enough to determine that the RPC succeded: it relies on its callback service to figure out whether or not the transfer actually worked. - Give yp_dblookup.c its own debug variable (ypdb_debug) so that DB access debugging messages can be turned on or off independent of the program's global debug messages. - Have the Makefile rpcgen the ypushresp_xfr_1() client stub for us and nuke the unneeded rule for yp_xdr.c that I left in by mistake (the XDR filters live in libc now).
1995-12-23 21:35:35 +00:00
static void ypxfr_callback(rval,addr,transid,prognum,port)
ypxfrstat rval;
struct sockaddr_in *addr;
unsigned int transid;
unsigned int prognum;
unsigned long port;
{
CLIENT *clnt;
int sock = RPC_ANYSOCK;
struct timeval timeout;
yppushresp_xfr ypxfr_resp;
More changes brought about by testing of yppush (which is almost finished): In yp_server.c: - Modify ypproc_xfr_2_svc() so that it sends both a return status and a yppush callback (if necessary: normally ypxfr is supposed to send the callback once it's done transfering a map, but if we can't get ypxfr off the ground for some reason, we have to send it here instead) and do it in the right order: have to send the reply to the ypproc_xfr request first, then send callback. This requires us to cheat a bit: you're supposed to just return() and let the RPC dispatcher send the reply for you, but we wouldn't be able to send the callback message if we did that, so we have to call svc_sendreply() ourselves, then send the callback, and then return NULL so that the RPC dispatcher won't call svc_sendreply() itself. - Also modify ypproc_xfr_2_svc() so that it doesn't invoke ypxfr with the -f flag: this overrides the order number checks, which prevents us from ever refusing maps that aren't newer than then ones we already have. In yp_access.c: - Fix a typo in the TCP_WRAPPER support code (which is #ifdef'ed out by default): a close paren somehow vanished into the ether.
1996-01-10 16:07:39 +00:00
struct rpc_err err;
A few small tweaks related to ypxfr: - Add a ypxfr_callback() function that we can use to signal failure to yppush(8) in the event that we can't fork()/exec() ypxfr(8). yppush only checks the return status from YPPROC_XFR enough to determine that the RPC succeded: it relies on its callback service to figure out whether or not the transfer actually worked. - Give yp_dblookup.c its own debug variable (ypdb_debug) so that DB access debugging messages can be turned on or off independent of the program's global debug messages. - Have the Makefile rpcgen the ypushresp_xfr_1() client stub for us and nuke the unneeded rule for yp_xdr.c that I left in by mistake (the XDR filters live in libc now).
1995-12-23 21:35:35 +00:00
More changes brought about by testing of yppush (which is almost finished): In yp_server.c: - Modify ypproc_xfr_2_svc() so that it sends both a return status and a yppush callback (if necessary: normally ypxfr is supposed to send the callback once it's done transfering a map, but if we can't get ypxfr off the ground for some reason, we have to send it here instead) and do it in the right order: have to send the reply to the ypproc_xfr request first, then send callback. This requires us to cheat a bit: you're supposed to just return() and let the RPC dispatcher send the reply for you, but we wouldn't be able to send the callback message if we did that, so we have to call svc_sendreply() ourselves, then send the callback, and then return NULL so that the RPC dispatcher won't call svc_sendreply() itself. - Also modify ypproc_xfr_2_svc() so that it doesn't invoke ypxfr with the -f flag: this overrides the order number checks, which prevents us from ever refusing maps that aren't newer than then ones we already have. In yp_access.c: - Fix a typo in the TCP_WRAPPER support code (which is #ifdef'ed out by default): a close paren somehow vanished into the ether.
1996-01-10 16:07:39 +00:00
timeout.tv_sec = 5;
A few small tweaks related to ypxfr: - Add a ypxfr_callback() function that we can use to signal failure to yppush(8) in the event that we can't fork()/exec() ypxfr(8). yppush only checks the return status from YPPROC_XFR enough to determine that the RPC succeded: it relies on its callback service to figure out whether or not the transfer actually worked. - Give yp_dblookup.c its own debug variable (ypdb_debug) so that DB access debugging messages can be turned on or off independent of the program's global debug messages. - Have the Makefile rpcgen the ypushresp_xfr_1() client stub for us and nuke the unneeded rule for yp_xdr.c that I left in by mistake (the XDR filters live in libc now).
1995-12-23 21:35:35 +00:00
timeout.tv_usec = 0;
addr->sin_port = htons(port);
In ypxfr_callback(), the failure to create an RPC CLIENT * handle for the callback is a fatal error for this function; return immediatlely if this happens. Also make the "failed to establish callback handle" error mesaage print the IP address of the target callback host.
1996-10-23 15:49:22 +00:00
if ((clnt = clntudp_create(addr,prognum,1,timeout,&sock)) == NULL) {
yp_error("%s: %s", inet_ntoa(addr->sin_addr),
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
clnt_spcreateerror("failed to establish callback handle"));
In ypxfr_callback(), the failure to create an RPC CLIENT * handle for the callback is a fatal error for this function; return immediatlely if this happens. Also make the "failed to establish callback handle" error mesaage print the IP address of the target callback host.
1996-10-23 15:49:22 +00:00
return;
}
A few small tweaks related to ypxfr: - Add a ypxfr_callback() function that we can use to signal failure to yppush(8) in the event that we can't fork()/exec() ypxfr(8). yppush only checks the return status from YPPROC_XFR enough to determine that the RPC succeded: it relies on its callback service to figure out whether or not the transfer actually worked. - Give yp_dblookup.c its own debug variable (ypdb_debug) so that DB access debugging messages can be turned on or off independent of the program's global debug messages. - Have the Makefile rpcgen the ypushresp_xfr_1() client stub for us and nuke the unneeded rule for yp_xdr.c that I left in by mistake (the XDR filters live in libc now).
1995-12-23 21:35:35 +00:00
ypxfr_resp.status = rval;
ypxfr_resp.transid = transid;
More changes brought about by testing of yppush (which is almost finished): In yp_server.c: - Modify ypproc_xfr_2_svc() so that it sends both a return status and a yppush callback (if necessary: normally ypxfr is supposed to send the callback once it's done transfering a map, but if we can't get ypxfr off the ground for some reason, we have to send it here instead) and do it in the right order: have to send the reply to the ypproc_xfr request first, then send callback. This requires us to cheat a bit: you're supposed to just return() and let the RPC dispatcher send the reply for you, but we wouldn't be able to send the callback message if we did that, so we have to call svc_sendreply() ourselves, then send the callback, and then return NULL so that the RPC dispatcher won't call svc_sendreply() itself. - Also modify ypproc_xfr_2_svc() so that it doesn't invoke ypxfr with the -f flag: this overrides the order number checks, which prevents us from ever refusing maps that aren't newer than then ones we already have. In yp_access.c: - Fix a typo in the TCP_WRAPPER support code (which is #ifdef'ed out by default): a close paren somehow vanished into the ether.
1996-01-10 16:07:39 +00:00
/* Turn the timeout off -- we don't want to block. */
timeout.tv_sec = 0;
if (clnt_control(clnt, CLSET_TIMEOUT, (char *)&timeout) == FALSE)
yp_error("failed to set timeout on ypproc_xfr callback");
if (yppushproc_xfrresp_1(&ypxfr_resp, clnt) == NULL) {
clnt_geterr(clnt, &err);
if (err.re_status != RPC_SUCCESS &&
err.re_status != RPC_TIMEDOUT)
yp_error("%s", clnt_sperror(clnt,
"ypxfr callback failed"));
}
A few small tweaks related to ypxfr: - Add a ypxfr_callback() function that we can use to signal failure to yppush(8) in the event that we can't fork()/exec() ypxfr(8). yppush only checks the return status from YPPROC_XFR enough to determine that the RPC succeded: it relies on its callback service to figure out whether or not the transfer actually worked. - Give yp_dblookup.c its own debug variable (ypdb_debug) so that DB access debugging messages can be turned on or off independent of the program's global debug messages. - Have the Makefile rpcgen the ypushresp_xfr_1() client stub for us and nuke the unneeded rule for yp_xdr.c that I left in by mistake (the XDR filters live in libc now).
1995-12-23 21:35:35 +00:00
clnt_destroy(clnt);
return;
}
Performance enhancements (I hope) and new stuff: yp_dblookup.c: - Implement database handle caching. What this means is that instead of opening and closing map databases for each request, we open a database and save the handle (and, if requested, the key index) in an array. This saves a bit of overhead on things like repeated YPPROC_NEXT calls, such as you'd get from getpwent(). Normally, each YPPROC_NEXT would require open()ing the database, seeking to the location supplied by the caller (which is time consuming with hash databases as the R_CURSOR flag doesn't work), reading the data, close()ing the database and then shipping the data off to the caller. The system call overhead is prohibitive, especially with very large maps. By caching the handle to an open database, we elimitate at least the open()/close() system calls, as well as the associated DB setup and tear-down operations, for a large percentage of the time. This improves performance substantially at the cost of consuming a little more memory than before. Note that all the caching support is surrounded by #ifdef DB_CACHE so that this same source module can still be used by other programs that don't need it. - Make yp_open_db() call yp_validdomain(). Doing it here saves cycles when caching is enabled since a hit on the map cache list by definition means that the domain being referenced is valid. - Also make yp_open_db() check for exhaustion of file descriptors, just in case. yp_server.c: - Reorganize things a little to take advantage of the database handle caching. Add a call to yp_flush_all() in ypproc_clear_2_svc(). - Remove calls to yp_validdomain() from some of the service procedures. yp_validdomain() is called inside yp_open_db() now, so procedures that call into the database package don't need to use yp_validdomain() themselves. - Fix a bogosity in ypproc_maplist_2_svc(): don't summarily initiallize the result.maps pointer to NULL. This causes yp_maplist_free() to fail and leaks memory. - Make ypproc_master_2_svc() copy the string it gets from the database package into a private static buffer before trying to NUL terminate it. This is necessary with the DB handle caching: stuffing a NUL into the data returned by DB package will goof it up internally. yp_main.c: - Stuff for DB handle caching: call yp_init_dbs() to clear the handle array and add call to yp_flush_all() to the SIGHUP signal handler. Makefile.yp: - Reorganize to deal with database caching. yp_mkdb(8) can now be used to send a YPPROC_CLEAR signal to ypserv(8). Call it after each map is created to refresh ypserv's cache. - Add support for mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). - Make default location for the netgroups source file be /var/yp/netgroup instead of /etc/netgroup. mkaliases: - New file: script to generate mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). Makefile: - Install Makefile.yp as /var/yp/Makefile.dist and link it to /var/yp/Makefile only if /var/yp/Makefile doesn't already exist. Suggested by Peter Wemm. - Install new mkaliases script in /usr/libexec along with mknetid. - Use somewhat saner approach to generating rpcgen-dependent files as suggested by Garrett Wollman.
1996-04-28 04:38:52 +00:00
#define YPXFR_RETURN(CODE) \
/* Order is important: send regular RPC reply, then callback */ \
result.xfrstat = CODE; \
svc_sendreply(rqstp->rq_xprt, xdr_ypresp_xfr, (char *)&result); \
ypxfr_callback(CODE,rqhost,argp->transid, \
argp->prog,argp->port); \
return(NULL);
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
ypresp_xfr *
ypproc_xfr_2_svc(ypreq_xfr *argp, struct svc_req *rqstp)
{
static ypresp_xfr result;
A few small tweaks related to ypxfr: - Add a ypxfr_callback() function that we can use to signal failure to yppush(8) in the event that we can't fork()/exec() ypxfr(8). yppush only checks the return status from YPPROC_XFR enough to determine that the RPC succeded: it relies on its callback service to figure out whether or not the transfer actually worked. - Give yp_dblookup.c its own debug variable (ypdb_debug) so that DB access debugging messages can be turned on or off independent of the program's global debug messages. - Have the Makefile rpcgen the ypushresp_xfr_1() client stub for us and nuke the unneeded rule for yp_xdr.c that I left in by mistake (the XDR filters live in libc now).
1995-12-23 21:35:35 +00:00
struct sockaddr_in *rqhost;
Add a sanity test to ypproc_xfr_2_svc(): check that the map and domain in the transfer request actually exist. Technically ypxfr can do this too, but why waste the cycles getting ypxfr off the ground for a transfer we already know is going to fail. Also apply stricter access control rules; ypproc_xfr_2_svc() is in a different class than the normal map access procedures procedures.
1997-04-10 14:12:51 +00:00
ypresp_master *mres;
ypreq_nokey mreq;
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
More changes brought about by testing of yppush (which is almost finished): In yp_server.c: - Modify ypproc_xfr_2_svc() so that it sends both a return status and a yppush callback (if necessary: normally ypxfr is supposed to send the callback once it's done transfering a map, but if we can't get ypxfr off the ground for some reason, we have to send it here instead) and do it in the right order: have to send the reply to the ypproc_xfr request first, then send callback. This requires us to cheat a bit: you're supposed to just return() and let the RPC dispatcher send the reply for you, but we wouldn't be able to send the callback message if we did that, so we have to call svc_sendreply() ourselves, then send the callback, and then return NULL so that the RPC dispatcher won't call svc_sendreply() itself. - Also modify ypproc_xfr_2_svc() so that it doesn't invoke ypxfr with the -f flag: this overrides the order number checks, which prevents us from ever refusing maps that aren't newer than then ones we already have. In yp_access.c: - Fix a typo in the TCP_WRAPPER support code (which is #ifdef'ed out by default): a close paren somehow vanished into the ether.
1996-01-10 16:07:39 +00:00
result.transid = argp->transid;
rqhost = svc_getcaller(rqstp->rq_xprt);
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#ifdef DB_CACHE
if (yp_access(argp->map_parms.map,
argp->map_parms.domain, (struct svc_req *)rqstp)) {
#else
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
if (yp_access(argp->map_parms.map, (struct svc_req *)rqstp)) {
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#endif
Add a sanity test to ypproc_xfr_2_svc(): check that the map and domain in the transfer request actually exist. Technically ypxfr can do this too, but why waste the cycles getting ypxfr off the ground for a transfer we already know is going to fail. Also apply stricter access control rules; ypproc_xfr_2_svc() is in a different class than the normal map access procedures procedures.
1997-04-10 14:12:51 +00:00
YPXFR_RETURN(YPXFR_REFUSED)
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
}
Add a sanity test to ypproc_xfr_2_svc(): check that the map and domain in the transfer request actually exist. Technically ypxfr can do this too, but why waste the cycles getting ypxfr off the ground for a transfer we already know is going to fail. Also apply stricter access control rules; ypproc_xfr_2_svc() is in a different class than the normal map access procedures procedures.
1997-04-10 14:12:51 +00:00
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
if (argp->map_parms.domain == NULL) {
Add a sanity test to ypproc_xfr_2_svc(): check that the map and domain in the transfer request actually exist. Technically ypxfr can do this too, but why waste the cycles getting ypxfr off the ground for a transfer we already know is going to fail. Also apply stricter access control rules; ypproc_xfr_2_svc() is in a different class than the normal map access procedures procedures.
1997-04-10 14:12:51 +00:00
YPXFR_RETURN(YPXFR_BADARGS)
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
}
if (yp_validdomain(argp->map_parms.domain)) {
Add a sanity test to ypproc_xfr_2_svc(): check that the map and domain in the transfer request actually exist. Technically ypxfr can do this too, but why waste the cycles getting ypxfr off the ground for a transfer we already know is going to fail. Also apply stricter access control rules; ypproc_xfr_2_svc() is in a different class than the normal map access procedures procedures.
1997-04-10 14:12:51 +00:00
YPXFR_RETURN(YPXFR_NODOM)
}
/*
* Determine the master host ourselves. The caller may
* be up to no good. This has the side effect of verifying
* that the requested map and domain actually exist.
*/
mreq.domain = argp->map_parms.domain;
mreq.map = argp->map_parms.map;
mres = ypproc_master_2_svc(&mreq, rqstp);
if (mres->stat != YP_TRUE) {
yp_error("couldn't find master for map %s@%s",
argp->map_parms.map,
argp->map_parms.domain);
yp_error("host at %s (%s) may be pulling my leg",
argp->map_parms.peer,
inet_ntoa(rqhost->sin_addr));
YPXFR_RETURN(YPXFR_REFUSED)
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
}
switch(fork()) {
case 0:
{
char g[11], t[11], p[11];
char ypxfr_command[MAXPATHLEN + 2];
sprintf (ypxfr_command, "%sypxfr", _PATH_LIBEXEC);
sprintf (t, "%u", argp->transid);
sprintf (g, "%u", argp->prog);
sprintf (p, "%u", argp->port);
Close PR# 2645: add curly braces where my fevered brain in collusion with my frantic fingers forgot to put them.
1997-02-06 05:28:52 +00:00
if (debug) {
A few small tweaks related to ypxfr: - Add a ypxfr_callback() function that we can use to signal failure to yppush(8) in the event that we can't fork()/exec() ypxfr(8). yppush only checks the return status from YPPROC_XFR enough to determine that the RPC succeded: it relies on its callback service to figure out whether or not the transfer actually worked. - Give yp_dblookup.c its own debug variable (ypdb_debug) so that DB access debugging messages can be turned on or off independent of the program's global debug messages. - Have the Makefile rpcgen the ypushresp_xfr_1() client stub for us and nuke the unneeded rule for yp_xdr.c that I left in by mistake (the XDR filters live in libc now).
1995-12-23 21:35:35 +00:00
close(0); close(1); close(2);
Close PR# 2645: add curly braces where my fevered brain in collusion with my frantic fingers forgot to put them.
1997-02-06 05:28:52 +00:00
}
A few small tweaks related to ypxfr: - Add a ypxfr_callback() function that we can use to signal failure to yppush(8) in the event that we can't fork()/exec() ypxfr(8). yppush only checks the return status from YPPROC_XFR enough to determine that the RPC succeded: it relies on its callback service to figure out whether or not the transfer actually worked. - Give yp_dblookup.c its own debug variable (ypdb_debug) so that DB access debugging messages can be turned on or off independent of the program's global debug messages. - Have the Makefile rpcgen the ypushresp_xfr_1() client stub for us and nuke the unneeded rule for yp_xdr.c that I left in by mistake (the XDR filters live in libc now).
1995-12-23 21:35:35 +00:00
if (strcmp(yp_dir, _PATH_YP)) {
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
execl(ypxfr_command, "ypxfr",
"-d", argp->map_parms.domain,
Add a sanity test to ypproc_xfr_2_svc(): check that the map and domain in the transfer request actually exist. Technically ypxfr can do this too, but why waste the cycles getting ypxfr off the ground for a transfer we already know is going to fail. Also apply stricter access control rules; ypproc_xfr_2_svc() is in a different class than the normal map access procedures procedures.
1997-04-10 14:12:51 +00:00
"-h", mres->peer,
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
"-p", yp_dir, "-C", t,
g, inet_ntoa(rqhost->sin_addr),
p, argp->map_parms.map,
A few small tweaks related to ypxfr: - Add a ypxfr_callback() function that we can use to signal failure to yppush(8) in the event that we can't fork()/exec() ypxfr(8). yppush only checks the return status from YPPROC_XFR enough to determine that the RPC succeded: it relies on its callback service to figure out whether or not the transfer actually worked. - Give yp_dblookup.c its own debug variable (ypdb_debug) so that DB access debugging messages can be turned on or off independent of the program's global debug messages. - Have the Makefile rpcgen the ypushresp_xfr_1() client stub for us and nuke the unneeded rule for yp_xdr.c that I left in by mistake (the XDR filters live in libc now).
1995-12-23 21:35:35 +00:00
NULL);
} else {
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
execl(ypxfr_command, "ypxfr",
"-d", argp->map_parms.domain,
Add a sanity test to ypproc_xfr_2_svc(): check that the map and domain in the transfer request actually exist. Technically ypxfr can do this too, but why waste the cycles getting ypxfr off the ground for a transfer we already know is going to fail. Also apply stricter access control rules; ypproc_xfr_2_svc() is in a different class than the normal map access procedures procedures.
1997-04-10 14:12:51 +00:00
"-h", mres->peer,
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
"-C", t,
g, inet_ntoa(rqhost->sin_addr),
p, argp->map_parms.map,
A few small tweaks related to ypxfr: - Add a ypxfr_callback() function that we can use to signal failure to yppush(8) in the event that we can't fork()/exec() ypxfr(8). yppush only checks the return status from YPPROC_XFR enough to determine that the RPC succeded: it relies on its callback service to figure out whether or not the transfer actually worked. - Give yp_dblookup.c its own debug variable (ypdb_debug) so that DB access debugging messages can be turned on or off independent of the program's global debug messages. - Have the Makefile rpcgen the ypushresp_xfr_1() client stub for us and nuke the unneeded rule for yp_xdr.c that I left in by mistake (the XDR filters live in libc now).
1995-12-23 21:35:35 +00:00
NULL);
}
forked++;
Performance enhancements (I hope) and new stuff: yp_dblookup.c: - Implement database handle caching. What this means is that instead of opening and closing map databases for each request, we open a database and save the handle (and, if requested, the key index) in an array. This saves a bit of overhead on things like repeated YPPROC_NEXT calls, such as you'd get from getpwent(). Normally, each YPPROC_NEXT would require open()ing the database, seeking to the location supplied by the caller (which is time consuming with hash databases as the R_CURSOR flag doesn't work), reading the data, close()ing the database and then shipping the data off to the caller. The system call overhead is prohibitive, especially with very large maps. By caching the handle to an open database, we elimitate at least the open()/close() system calls, as well as the associated DB setup and tear-down operations, for a large percentage of the time. This improves performance substantially at the cost of consuming a little more memory than before. Note that all the caching support is surrounded by #ifdef DB_CACHE so that this same source module can still be used by other programs that don't need it. - Make yp_open_db() call yp_validdomain(). Doing it here saves cycles when caching is enabled since a hit on the map cache list by definition means that the domain being referenced is valid. - Also make yp_open_db() check for exhaustion of file descriptors, just in case. yp_server.c: - Reorganize things a little to take advantage of the database handle caching. Add a call to yp_flush_all() in ypproc_clear_2_svc(). - Remove calls to yp_validdomain() from some of the service procedures. yp_validdomain() is called inside yp_open_db() now, so procedures that call into the database package don't need to use yp_validdomain() themselves. - Fix a bogosity in ypproc_maplist_2_svc(): don't summarily initiallize the result.maps pointer to NULL. This causes yp_maplist_free() to fail and leaks memory. - Make ypproc_master_2_svc() copy the string it gets from the database package into a private static buffer before trying to NUL terminate it. This is necessary with the DB handle caching: stuffing a NUL into the data returned by DB package will goof it up internally. yp_main.c: - Stuff for DB handle caching: call yp_init_dbs() to clear the handle array and add call to yp_flush_all() to the SIGHUP signal handler. Makefile.yp: - Reorganize to deal with database caching. yp_mkdb(8) can now be used to send a YPPROC_CLEAR signal to ypserv(8). Call it after each map is created to refresh ypserv's cache. - Add support for mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). - Make default location for the netgroups source file be /var/yp/netgroup instead of /etc/netgroup. mkaliases: - New file: script to generate mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). Makefile: - Install Makefile.yp as /var/yp/Makefile.dist and link it to /var/yp/Makefile only if /var/yp/Makefile doesn't already exist. Suggested by Peter Wemm. - Install new mkaliases script in /usr/libexec along with mknetid. - Use somewhat saner approach to generating rpcgen-dependent files as suggested by Garrett Wollman.
1996-04-28 04:38:52 +00:00
yp_error("ypxfr execl(%s): %s", ypxfr_command, strerror(errno));
Add a sanity test to ypproc_xfr_2_svc(): check that the map and domain in the transfer request actually exist. Technically ypxfr can do this too, but why waste the cycles getting ypxfr off the ground for a transfer we already know is going to fail. Also apply stricter access control rules; ypproc_xfr_2_svc() is in a different class than the normal map access procedures procedures.
1997-04-10 14:12:51 +00:00
YPXFR_RETURN(YPXFR_XFRERR)
A few small tweaks related to ypxfr: - Add a ypxfr_callback() function that we can use to signal failure to yppush(8) in the event that we can't fork()/exec() ypxfr(8). yppush only checks the return status from YPPROC_XFR enough to determine that the RPC succeded: it relies on its callback service to figure out whether or not the transfer actually worked. - Give yp_dblookup.c its own debug variable (ypdb_debug) so that DB access debugging messages can be turned on or off independent of the program's global debug messages. - Have the Makefile rpcgen the ypushresp_xfr_1() client stub for us and nuke the unneeded rule for yp_xdr.c that I left in by mistake (the XDR filters live in libc now).
1995-12-23 21:35:35 +00:00
break;
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
}
case -1:
yp_error("ypxfr fork(): %s", strerror(errno));
Add a sanity test to ypproc_xfr_2_svc(): check that the map and domain in the transfer request actually exist. Technically ypxfr can do this too, but why waste the cycles getting ypxfr off the ground for a transfer we already know is going to fail. Also apply stricter access control rules; ypproc_xfr_2_svc() is in a different class than the normal map access procedures procedures.
1997-04-10 14:12:51 +00:00
YPXFR_RETURN(YPXFR_XFRERR)
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
break;
default:
More changes brought about by testing of yppush (which is almost finished): In yp_server.c: - Modify ypproc_xfr_2_svc() so that it sends both a return status and a yppush callback (if necessary: normally ypxfr is supposed to send the callback once it's done transfering a map, but if we can't get ypxfr off the ground for some reason, we have to send it here instead) and do it in the right order: have to send the reply to the ypproc_xfr request first, then send callback. This requires us to cheat a bit: you're supposed to just return() and let the RPC dispatcher send the reply for you, but we wouldn't be able to send the callback message if we did that, so we have to call svc_sendreply() ourselves, then send the callback, and then return NULL so that the RPC dispatcher won't call svc_sendreply() itself. - Also modify ypproc_xfr_2_svc() so that it doesn't invoke ypxfr with the -f flag: this overrides the order number checks, which prevents us from ever refusing maps that aren't newer than then ones we already have. In yp_access.c: - Fix a typo in the TCP_WRAPPER support code (which is #ifdef'ed out by default): a close paren somehow vanished into the ether.
1996-01-10 16:07:39 +00:00
result.xfrstat = YPXFR_SUCC;
A few small tweaks related to ypxfr: - Add a ypxfr_callback() function that we can use to signal failure to yppush(8) in the event that we can't fork()/exec() ypxfr(8). yppush only checks the return status from YPPROC_XFR enough to determine that the RPC succeded: it relies on its callback service to figure out whether or not the transfer actually worked. - Give yp_dblookup.c its own debug variable (ypdb_debug) so that DB access debugging messages can be turned on or off independent of the program's global debug messages. - Have the Makefile rpcgen the ypushresp_xfr_1() client stub for us and nuke the unneeded rule for yp_xdr.c that I left in by mistake (the XDR filters live in libc now).
1995-12-23 21:35:35 +00:00
children++;
forked = 0;
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
break;
}
More changes brought about by testing of yppush (which is almost finished): In yp_server.c: - Modify ypproc_xfr_2_svc() so that it sends both a return status and a yppush callback (if necessary: normally ypxfr is supposed to send the callback once it's done transfering a map, but if we can't get ypxfr off the ground for some reason, we have to send it here instead) and do it in the right order: have to send the reply to the ypproc_xfr request first, then send callback. This requires us to cheat a bit: you're supposed to just return() and let the RPC dispatcher send the reply for you, but we wouldn't be able to send the callback message if we did that, so we have to call svc_sendreply() ourselves, then send the callback, and then return NULL so that the RPC dispatcher won't call svc_sendreply() itself. - Also modify ypproc_xfr_2_svc() so that it doesn't invoke ypxfr with the -f flag: this overrides the order number checks, which prevents us from ever refusing maps that aren't newer than then ones we already have. In yp_access.c: - Fix a typo in the TCP_WRAPPER support code (which is #ifdef'ed out by default): a close paren somehow vanished into the ether.
1996-01-10 16:07:39 +00:00
return (&result);
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
}
Performance enhancements (I hope) and new stuff: yp_dblookup.c: - Implement database handle caching. What this means is that instead of opening and closing map databases for each request, we open a database and save the handle (and, if requested, the key index) in an array. This saves a bit of overhead on things like repeated YPPROC_NEXT calls, such as you'd get from getpwent(). Normally, each YPPROC_NEXT would require open()ing the database, seeking to the location supplied by the caller (which is time consuming with hash databases as the R_CURSOR flag doesn't work), reading the data, close()ing the database and then shipping the data off to the caller. The system call overhead is prohibitive, especially with very large maps. By caching the handle to an open database, we elimitate at least the open()/close() system calls, as well as the associated DB setup and tear-down operations, for a large percentage of the time. This improves performance substantially at the cost of consuming a little more memory than before. Note that all the caching support is surrounded by #ifdef DB_CACHE so that this same source module can still be used by other programs that don't need it. - Make yp_open_db() call yp_validdomain(). Doing it here saves cycles when caching is enabled since a hit on the map cache list by definition means that the domain being referenced is valid. - Also make yp_open_db() check for exhaustion of file descriptors, just in case. yp_server.c: - Reorganize things a little to take advantage of the database handle caching. Add a call to yp_flush_all() in ypproc_clear_2_svc(). - Remove calls to yp_validdomain() from some of the service procedures. yp_validdomain() is called inside yp_open_db() now, so procedures that call into the database package don't need to use yp_validdomain() themselves. - Fix a bogosity in ypproc_maplist_2_svc(): don't summarily initiallize the result.maps pointer to NULL. This causes yp_maplist_free() to fail and leaks memory. - Make ypproc_master_2_svc() copy the string it gets from the database package into a private static buffer before trying to NUL terminate it. This is necessary with the DB handle caching: stuffing a NUL into the data returned by DB package will goof it up internally. yp_main.c: - Stuff for DB handle caching: call yp_init_dbs() to clear the handle array and add call to yp_flush_all() to the SIGHUP signal handler. Makefile.yp: - Reorganize to deal with database caching. yp_mkdb(8) can now be used to send a YPPROC_CLEAR signal to ypserv(8). Call it after each map is created to refresh ypserv's cache. - Add support for mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). - Make default location for the netgroups source file be /var/yp/netgroup instead of /etc/netgroup. mkaliases: - New file: script to generate mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). Makefile: - Install Makefile.yp as /var/yp/Makefile.dist and link it to /var/yp/Makefile only if /var/yp/Makefile doesn't already exist. Suggested by Peter Wemm. - Install new mkaliases script in /usr/libexec along with mknetid. - Use somewhat saner approach to generating rpcgen-dependent files as suggested by Garrett Wollman.
1996-04-28 04:38:52 +00:00
#undef YPXFR_RETURN
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
void *
ypproc_clear_2_svc(void *argp, struct svc_req *rqstp)
{
static char * result;
static char rval = 0;
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#ifdef DB_CACHE
if (yp_access(NULL, NULL, (struct svc_req *)rqstp))
#else
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
if (yp_access(NULL, (struct svc_req *)rqstp))
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#endif
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
return (NULL);
Performance enhancements (I hope) and new stuff: yp_dblookup.c: - Implement database handle caching. What this means is that instead of opening and closing map databases for each request, we open a database and save the handle (and, if requested, the key index) in an array. This saves a bit of overhead on things like repeated YPPROC_NEXT calls, such as you'd get from getpwent(). Normally, each YPPROC_NEXT would require open()ing the database, seeking to the location supplied by the caller (which is time consuming with hash databases as the R_CURSOR flag doesn't work), reading the data, close()ing the database and then shipping the data off to the caller. The system call overhead is prohibitive, especially with very large maps. By caching the handle to an open database, we elimitate at least the open()/close() system calls, as well as the associated DB setup and tear-down operations, for a large percentage of the time. This improves performance substantially at the cost of consuming a little more memory than before. Note that all the caching support is surrounded by #ifdef DB_CACHE so that this same source module can still be used by other programs that don't need it. - Make yp_open_db() call yp_validdomain(). Doing it here saves cycles when caching is enabled since a hit on the map cache list by definition means that the domain being referenced is valid. - Also make yp_open_db() check for exhaustion of file descriptors, just in case. yp_server.c: - Reorganize things a little to take advantage of the database handle caching. Add a call to yp_flush_all() in ypproc_clear_2_svc(). - Remove calls to yp_validdomain() from some of the service procedures. yp_validdomain() is called inside yp_open_db() now, so procedures that call into the database package don't need to use yp_validdomain() themselves. - Fix a bogosity in ypproc_maplist_2_svc(): don't summarily initiallize the result.maps pointer to NULL. This causes yp_maplist_free() to fail and leaks memory. - Make ypproc_master_2_svc() copy the string it gets from the database package into a private static buffer before trying to NUL terminate it. This is necessary with the DB handle caching: stuffing a NUL into the data returned by DB package will goof it up internally. yp_main.c: - Stuff for DB handle caching: call yp_init_dbs() to clear the handle array and add call to yp_flush_all() to the SIGHUP signal handler. Makefile.yp: - Reorganize to deal with database caching. yp_mkdb(8) can now be used to send a YPPROC_CLEAR signal to ypserv(8). Call it after each map is created to refresh ypserv's cache. - Add support for mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). - Make default location for the netgroups source file be /var/yp/netgroup instead of /etc/netgroup. mkaliases: - New file: script to generate mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). Makefile: - Install Makefile.yp as /var/yp/Makefile.dist and link it to /var/yp/Makefile only if /var/yp/Makefile doesn't already exist. Suggested by Peter Wemm. - Install new mkaliases script in /usr/libexec along with mknetid. - Use somewhat saner approach to generating rpcgen-dependent files as suggested by Garrett Wollman.
1996-04-28 04:38:52 +00:00
#ifdef DB_CACHE
/* clear out the database cache */
yp_flush_all();
#endif
Add real securenets support. By default, ypserv now uses /var/yp/securenets in the same was as the SunOS ypserv (same format, described in ypserv man page). If the user wants tcpwrapper style access control, they can recompile ypserv to use that instead. This way we get securenets without having to ship libwrap.a and tcpd.h with core FreeBSD distribution. If /var/yp/securenets doesn't exist, ypserv allows all connections.
1996-02-24 22:01:48 +00:00
/* Re-read the securenets database for the hell of it. */
load_securenets();
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
result = &rval;
return((void *) &result);
}
/*
* For ypproc_all, we have to send a stream of ypresp_all structures
* via TCP, but the XDR filter generated from the yp.x protocol
* definition file only serializes one such structure. This means that
* to send the whole stream, you need a wrapper which feeds all the
* records into the underlying XDR routine until it hits an 'EOF.'
* But to use the wrapper, you have to violate the boundaries between
* RPC layers by calling svc_sendreply() directly from the ypproc_all
* service routine instead of letting the RPC dispatcher do it.
*
* Bleah.
*/
/*
Back out the non-forking YPPROC_ALL stuff. Whatever drugs I was doing when I came up with this idea weren't strong enough to help me see it through. If this was a self-contained application and I had complete control over what data got sent through what socket and when, I might be able to get everything to work right without blocking, but instead I have RPC/XDR in between me and the socket layer, and they have their own ideas about what to do. Maybe one day I'll go totally mad and figure out the right way to do this; in the meantime this mess goes on the back burner.
1996-12-03 02:37:39 +00:00
* Custom XDR routine for serialzing results of ypproc_all: keep
* reading from the database and spew until we run out of records
* or encounter an error.
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
*/
static bool_t
xdr_my_ypresp_all(register XDR *xdrs, ypresp_all *objp)
{
Back out the non-forking YPPROC_ALL stuff. Whatever drugs I was doing when I came up with this idea weren't strong enough to help me see it through. If this was a self-contained application and I had complete control over what data got sent through what socket and when, I might be able to get everything to work right without blocking, but instead I have RPC/XDR in between me and the socket layer, and they have their own ideas about what to do. Maybe one day I'll go totally mad and figure out the right way to do this; in the meantime this mess goes on the back burner.
1996-12-03 02:37:39 +00:00
while (1) {
/* Get a record. */
if ((objp->ypresp_all_u.val.stat =
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
yp_nextbykey(&objp->ypresp_all_u.val.key,
&objp->ypresp_all_u.val.val)) == YP_TRUE) {
Back out the non-forking YPPROC_ALL stuff. Whatever drugs I was doing when I came up with this idea weren't strong enough to help me see it through. If this was a self-contained application and I had complete control over what data got sent through what socket and when, I might be able to get everything to work right without blocking, but instead I have RPC/XDR in between me and the socket layer, and they have their own ideas about what to do. Maybe one day I'll go totally mad and figure out the right way to do this; in the meantime this mess goes on the back burner.
1996-12-03 02:37:39 +00:00
objp->more = TRUE;
} else {
objp->more = FALSE;
}
/* Serialize. */
if (!xdr_ypresp_all(xdrs, objp))
return(FALSE);
if (objp->more == FALSE)
return(TRUE);
}
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
}
ypresp_all *
ypproc_all_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
{
static ypresp_all result;
/*
* Set this here so that the client will be forced to make
* at least one attempt to read from us even if all we're
* doing is returning an error.
*/
result.more = TRUE;
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
result.ypresp_all_u.val.key.keydat_len = 0;
result.ypresp_all_u.val.key.keydat_val = "";
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#ifdef DB_CACHE
if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
#else
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
if (yp_access(argp->map, (struct svc_req *)rqstp)) {
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#endif
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
result.ypresp_all_u.val.stat = YP_YPERR;
return (&result);
}
if (argp->domain == NULL || argp->map == NULL) {
result.ypresp_all_u.val.stat = YP_BADARGS;
return (&result);
}
yp_server.c: - Fail YPPROC_ALL requests when we hit the child process limit. This is a little harsh, but it helps prevent the parent from blocking and causing other requests to time out. yp_dnslookup.c: - Check for duplicate RPC transaction IDs that indicate duplicate requests sent due to RPC retransmissions. We don't want to send a second DNS request for the same data while an existing request is in progress. - Fix small formatting bogon in snprintf() in yp_async_lookup_addr().
1997-01-07 06:07:21 +00:00
/*
* XXX If we hit the child limit, fail the request.
* If we don't, and the map is large, we could block for
* a long time in the parent.
*/
if (children >= MAX_CHILDREN) {
result.ypresp_all_u.val.stat = YP_YPERR;
return(&result);
}
Back out the non-forking YPPROC_ALL stuff. Whatever drugs I was doing when I came up with this idea weren't strong enough to help me see it through. If this was a self-contained application and I had complete control over what data got sent through what socket and when, I might be able to get everything to work right without blocking, but instead I have RPC/XDR in between me and the socket layer, and they have their own ideas about what to do. Maybe one day I'll go totally mad and figure out the right way to do this; in the meantime this mess goes on the back burner.
1996-12-03 02:37:39 +00:00
/*
* The ypproc_all procedure can take a while to complete.
* Best to handle it in a subprocess so the parent doesn't
* block. (Is there a better way to do this? Maybe with
* async socket I/O?)
*/
if (!debug && children < MAX_CHILDREN && fork()) {
children++;
forked = 0;
return (NULL);
} else {
forked++;
}
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
if (yp_select_map(argp->map, argp->domain,
&result.ypresp_all_u.val.key, 0) != YP_TRUE) {
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
result.ypresp_all_u.val.stat = yp_errno;
return(&result);
}
/* Kick off the actual data transfer. */
Back out the non-forking YPPROC_ALL stuff. Whatever drugs I was doing when I came up with this idea weren't strong enough to help me see it through. If this was a self-contained application and I had complete control over what data got sent through what socket and when, I might be able to get everything to work right without blocking, but instead I have RPC/XDR in between me and the socket layer, and they have their own ideas about what to do. Maybe one day I'll go totally mad and figure out the right way to do this; in the meantime this mess goes on the back burner.
1996-12-03 02:37:39 +00:00
svc_sendreply(rqstp->rq_xprt, xdr_my_ypresp_all, (char *)&result);
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
/*
* Returning NULL prevents the dispatcher from calling
* svc_sendreply() since we already did it.
*/
return (NULL);
}
ypresp_master *
ypproc_master_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
{
static ypresp_master result;
Performance enhancements (I hope) and new stuff: yp_dblookup.c: - Implement database handle caching. What this means is that instead of opening and closing map databases for each request, we open a database and save the handle (and, if requested, the key index) in an array. This saves a bit of overhead on things like repeated YPPROC_NEXT calls, such as you'd get from getpwent(). Normally, each YPPROC_NEXT would require open()ing the database, seeking to the location supplied by the caller (which is time consuming with hash databases as the R_CURSOR flag doesn't work), reading the data, close()ing the database and then shipping the data off to the caller. The system call overhead is prohibitive, especially with very large maps. By caching the handle to an open database, we elimitate at least the open()/close() system calls, as well as the associated DB setup and tear-down operations, for a large percentage of the time. This improves performance substantially at the cost of consuming a little more memory than before. Note that all the caching support is surrounded by #ifdef DB_CACHE so that this same source module can still be used by other programs that don't need it. - Make yp_open_db() call yp_validdomain(). Doing it here saves cycles when caching is enabled since a hit on the map cache list by definition means that the domain being referenced is valid. - Also make yp_open_db() check for exhaustion of file descriptors, just in case. yp_server.c: - Reorganize things a little to take advantage of the database handle caching. Add a call to yp_flush_all() in ypproc_clear_2_svc(). - Remove calls to yp_validdomain() from some of the service procedures. yp_validdomain() is called inside yp_open_db() now, so procedures that call into the database package don't need to use yp_validdomain() themselves. - Fix a bogosity in ypproc_maplist_2_svc(): don't summarily initiallize the result.maps pointer to NULL. This causes yp_maplist_free() to fail and leaks memory. - Make ypproc_master_2_svc() copy the string it gets from the database package into a private static buffer before trying to NUL terminate it. This is necessary with the DB handle caching: stuffing a NUL into the data returned by DB package will goof it up internally. yp_main.c: - Stuff for DB handle caching: call yp_init_dbs() to clear the handle array and add call to yp_flush_all() to the SIGHUP signal handler. Makefile.yp: - Reorganize to deal with database caching. yp_mkdb(8) can now be used to send a YPPROC_CLEAR signal to ypserv(8). Call it after each map is created to refresh ypserv's cache. - Add support for mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). - Make default location for the netgroups source file be /var/yp/netgroup instead of /etc/netgroup. mkaliases: - New file: script to generate mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). Makefile: - Install Makefile.yp as /var/yp/Makefile.dist and link it to /var/yp/Makefile only if /var/yp/Makefile doesn't already exist. Suggested by Peter Wemm. - Install new mkaliases script in /usr/libexec along with mknetid. - Use somewhat saner approach to generating rpcgen-dependent files as suggested by Garrett Wollman.
1996-04-28 04:38:52 +00:00
static char ypvalbuf[YPMAXRECORD];
Don't initialize structures from other variables; gcc -ansi -pedantic doesn't allow it. Use proper constants instead.
1997-08-10 20:37:48 +00:00
keydat key = { MASTER_SZ, MASTER_STRING };
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
valdat val;
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
In ypproc_master_2_svc(), don't leave result.peer uninitialized when returning an error.
1996-02-29 23:10:38 +00:00
result.peer = "";
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#ifdef DB_CACHE
if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
#else
if (yp_access(argp->map, (struct svc_req *)rqstp)) {
#endif
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
result.stat = YP_YPERR;
return(&result);
}
if (argp->domain == NULL) {
result.stat = YP_BADARGS;
return (&result);
}
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
if (yp_select_map(argp->map, argp->domain, &key, 1) != YP_TRUE) {
result.stat = yp_errno;
return(&result);
}
Performance enhancements (I hope) and new stuff: yp_dblookup.c: - Implement database handle caching. What this means is that instead of opening and closing map databases for each request, we open a database and save the handle (and, if requested, the key index) in an array. This saves a bit of overhead on things like repeated YPPROC_NEXT calls, such as you'd get from getpwent(). Normally, each YPPROC_NEXT would require open()ing the database, seeking to the location supplied by the caller (which is time consuming with hash databases as the R_CURSOR flag doesn't work), reading the data, close()ing the database and then shipping the data off to the caller. The system call overhead is prohibitive, especially with very large maps. By caching the handle to an open database, we elimitate at least the open()/close() system calls, as well as the associated DB setup and tear-down operations, for a large percentage of the time. This improves performance substantially at the cost of consuming a little more memory than before. Note that all the caching support is surrounded by #ifdef DB_CACHE so that this same source module can still be used by other programs that don't need it. - Make yp_open_db() call yp_validdomain(). Doing it here saves cycles when caching is enabled since a hit on the map cache list by definition means that the domain being referenced is valid. - Also make yp_open_db() check for exhaustion of file descriptors, just in case. yp_server.c: - Reorganize things a little to take advantage of the database handle caching. Add a call to yp_flush_all() in ypproc_clear_2_svc(). - Remove calls to yp_validdomain() from some of the service procedures. yp_validdomain() is called inside yp_open_db() now, so procedures that call into the database package don't need to use yp_validdomain() themselves. - Fix a bogosity in ypproc_maplist_2_svc(): don't summarily initiallize the result.maps pointer to NULL. This causes yp_maplist_free() to fail and leaks memory. - Make ypproc_master_2_svc() copy the string it gets from the database package into a private static buffer before trying to NUL terminate it. This is necessary with the DB handle caching: stuffing a NUL into the data returned by DB package will goof it up internally. yp_main.c: - Stuff for DB handle caching: call yp_init_dbs() to clear the handle array and add call to yp_flush_all() to the SIGHUP signal handler. Makefile.yp: - Reorganize to deal with database caching. yp_mkdb(8) can now be used to send a YPPROC_CLEAR signal to ypserv(8). Call it after each map is created to refresh ypserv's cache. - Add support for mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). - Make default location for the netgroups source file be /var/yp/netgroup instead of /etc/netgroup. mkaliases: - New file: script to generate mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). Makefile: - Install Makefile.yp as /var/yp/Makefile.dist and link it to /var/yp/Makefile only if /var/yp/Makefile doesn't already exist. Suggested by Peter Wemm. - Install new mkaliases script in /usr/libexec along with mknetid. - Use somewhat saner approach to generating rpcgen-dependent files as suggested by Garrett Wollman.
1996-04-28 04:38:52 +00:00
/*
* Note that we copy the data retrieved from the database to
* a private buffer and NUL terminate the buffer rather than
* terminating the data in place. We do this because by stuffing
* a '\0' into data.data, we will actually be corrupting memory
* allocated by the DB package. This is a bad thing now that we
* cache DB handles rather than closing the database immediately.
*/
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
result.stat = yp_getbykey(&key, &val);
if (result.stat == YP_TRUE) {
bcopy((char *)val.valdat_val, (char *)&ypvalbuf,
val.valdat_len);
ypvalbuf[val.valdat_len] = '\0';
Performance enhancements (I hope) and new stuff: yp_dblookup.c: - Implement database handle caching. What this means is that instead of opening and closing map databases for each request, we open a database and save the handle (and, if requested, the key index) in an array. This saves a bit of overhead on things like repeated YPPROC_NEXT calls, such as you'd get from getpwent(). Normally, each YPPROC_NEXT would require open()ing the database, seeking to the location supplied by the caller (which is time consuming with hash databases as the R_CURSOR flag doesn't work), reading the data, close()ing the database and then shipping the data off to the caller. The system call overhead is prohibitive, especially with very large maps. By caching the handle to an open database, we elimitate at least the open()/close() system calls, as well as the associated DB setup and tear-down operations, for a large percentage of the time. This improves performance substantially at the cost of consuming a little more memory than before. Note that all the caching support is surrounded by #ifdef DB_CACHE so that this same source module can still be used by other programs that don't need it. - Make yp_open_db() call yp_validdomain(). Doing it here saves cycles when caching is enabled since a hit on the map cache list by definition means that the domain being referenced is valid. - Also make yp_open_db() check for exhaustion of file descriptors, just in case. yp_server.c: - Reorganize things a little to take advantage of the database handle caching. Add a call to yp_flush_all() in ypproc_clear_2_svc(). - Remove calls to yp_validdomain() from some of the service procedures. yp_validdomain() is called inside yp_open_db() now, so procedures that call into the database package don't need to use yp_validdomain() themselves. - Fix a bogosity in ypproc_maplist_2_svc(): don't summarily initiallize the result.maps pointer to NULL. This causes yp_maplist_free() to fail and leaks memory. - Make ypproc_master_2_svc() copy the string it gets from the database package into a private static buffer before trying to NUL terminate it. This is necessary with the DB handle caching: stuffing a NUL into the data returned by DB package will goof it up internally. yp_main.c: - Stuff for DB handle caching: call yp_init_dbs() to clear the handle array and add call to yp_flush_all() to the SIGHUP signal handler. Makefile.yp: - Reorganize to deal with database caching. yp_mkdb(8) can now be used to send a YPPROC_CLEAR signal to ypserv(8). Call it after each map is created to refresh ypserv's cache. - Add support for mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). - Make default location for the netgroups source file be /var/yp/netgroup instead of /etc/netgroup. mkaliases: - New file: script to generate mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). Makefile: - Install Makefile.yp as /var/yp/Makefile.dist and link it to /var/yp/Makefile only if /var/yp/Makefile doesn't already exist. Suggested by Peter Wemm. - Install new mkaliases script in /usr/libexec along with mknetid. - Use somewhat saner approach to generating rpcgen-dependent files as suggested by Garrett Wollman.
1996-04-28 04:38:52 +00:00
result.peer = (char *)&ypvalbuf;
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
} else
result.peer = "";
return (&result);
}
ypresp_order *
ypproc_order_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
{
static ypresp_order result;
Don't initialize structures from other variables; gcc -ansi -pedantic doesn't allow it. Use proper constants instead.
1997-08-10 20:37:48 +00:00
keydat key = { ORDER_SZ, ORDER_STRING };
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
valdat val;
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
result.ordernum = 0;
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#ifdef DB_CACHE
if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
#else
if (yp_access(argp->map, (struct svc_req *)rqstp)) {
#endif
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
result.stat = YP_YPERR;
return(&result);
}
if (argp->domain == NULL) {
result.stat = YP_BADARGS;
return (&result);
}
/*
* We could just check the timestamp on the map file,
* but that's a hack: we'll only know the last time the file
* was touched, not the last time the database contents were
* updated.
*/
Big round o changes: - yp_dblookup.c: Create non-DB specific database access functions. Using these allows access to the underlying database functions without needing explicit knowledge of Berkeley DB. (These are used only when DB_CACHE is #defined. Other programs that use the non-caching functions (yp_mkdb, ypxfr, yppush, rpc.yppasswdd) shouldn't notice the difference.) - yp_dnslookup: Implement async DNS lookups. We send our own DNS requests using UDP and put the request in a queue. When the response arrives, we use the ID in the header to find the corresponsing queue entry and then send the response to the client. We can go about our business and handle other YP requests in the meantime. This way, we can deal with time consuming DNS requests without blocking and without forking. - yp_server.c: Convert to using new non-DB-specific database access functions. This simplifies the code a bit and removes the need for this module to know anything about Berkeley DB. Also convert the ypproc_match_2_svc() function to use the async DNS lookup routines. - yp_main.c: tweak yp_svc_run() to add the resolver socket to the set of descriptors monitored in the select() loop. Also add a timeout to select(); we may get stale DNS requests stuck in the queue which we want to invalidate after a while. If the timeout hits, we decrement the ttl on all pending DNS requests and nuke those requests that aren't handled before ttl hits zero. - yp_extern.h: Add prototypes for new stuff. - yp_svc_udp.c (new file): The async resolver code needs to be able to rummage around inside the RPC UDP transport handle in order to work correcty. There's basically one transport handle, and each time a request comes in, the transaction ID in the handle is changed. This means that if we queue a DNS request, then we handle some other unrelated requests, we will be unable to send the DNS response because the transaction ID and remote address of the client that made the DNS request will have been lost. What we need to do is save the client address and transaction ID in the queue entry for the DNS request, then put the transaction ID and address back in the transport handle when we're ready to reply. (And then we have to undo the change so as not to confuse any other part of the server.) The trouble is that the transaction ID is hidden in an opaque part of the transport handle, and only the code in the svc_udp module in the RPC library knows how to handle it. This file contains a couple of functions that let us read and set the transaction ID in spite of this. This is really a dirty trick and I should be taken out and shot for even thinking about it, but there's no other way to get this stuff to work. - Makefile: add yp_svc_udp.c to SRCS.
1996-12-22 22:30:58 +00:00
if (yp_select_map(argp->map, argp->domain, &key, 1) != YP_TRUE) {
result.stat = yp_errno;
return(&result);
}
result.stat = yp_getbykey(&key, &val);
if (result.stat == YP_TRUE)
result.ordernum = atoi((char *)val.valdat_val);
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
else
result.ordernum = 0;
return (&result);
}
static void yp_maplist_free(yp_maplist)
struct ypmaplist *yp_maplist;
{
register struct ypmaplist *next;
while(yp_maplist) {
next = yp_maplist->next;
free(yp_maplist->map);
free(yp_maplist);
yp_maplist = next;
}
return;
}
static struct ypmaplist *yp_maplist_create(domain)
const char *domain;
{
char yp_mapdir[MAXPATHLEN + 2];
char yp_mapname[MAXPATHLEN + 2];
struct ypmaplist *cur = NULL;
struct ypmaplist *yp_maplist = NULL;
DIR *dird;
struct dirent *dirp;
struct stat statbuf;
snprintf(yp_mapdir, sizeof(yp_mapdir), "%s/%s", yp_dir, domain);
if ((dird = opendir(yp_mapdir)) == NULL) {
Found an instance of yp_error() in yp_maplist_create() that had two %s tokens but only one argument; fixed by putting in missing argument.
1996-01-31 15:21:56 +00:00
yp_error("opendir(%s) failed: %s", yp_mapdir, strerror(errno));
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
return(NULL);
}
while ((dirp = readdir(dird)) != NULL) {
if (strcmp(dirp->d_name, ".") && strcmp(dirp->d_name, "..")) {
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
snprintf(yp_mapname, sizeof(yp_mapname), "%s/%s",
yp_mapdir,dirp->d_name);
if (stat(yp_mapname, &statbuf) < 0 ||
!S_ISREG(statbuf.st_mode))
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
continue;
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
if ((cur = (struct ypmaplist *)
Small touch-ups -- no functional changes. Fix some comments to reflect reality (in some cases I made changes to code but not to the comments). Change some instances of 'inline' to '__inline' to pacify gcc -ansi -pedantic. Use rcsid strings more consistently. Make 'oldaddr' static in yp_access(). Use strcpy()/strcat() in yp_open_db_cache() instead of snprintf(). (Seems to be a little faster this way.)
1996-05-31 16:01:51 +00:00
malloc(sizeof(struct ypmaplist))) == NULL) {
Typos in man page. Cosmetics in error strings.
1997-10-29 07:25:05 +00:00
yp_error("malloc() failed");
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
closedir(dird);
yp_maplist_free(yp_maplist);
return(NULL);
}
if ((cur->map = (char *)strdup(dirp->d_name)) == NULL) {
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
yp_error("strdup() failed: %s",strerror(errno));
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
closedir(dird);
yp_maplist_free(yp_maplist);
return(NULL);
}
cur->next = yp_maplist;
yp_maplist = cur;
if (debug)
yp_error("map: %s", yp_maplist->map);
}
}
closedir(dird);
return(yp_maplist);
}
ypresp_maplist *
ypproc_maplist_2_svc(domainname *argp, struct svc_req *rqstp)
{
Performance enhancements (I hope) and new stuff: yp_dblookup.c: - Implement database handle caching. What this means is that instead of opening and closing map databases for each request, we open a database and save the handle (and, if requested, the key index) in an array. This saves a bit of overhead on things like repeated YPPROC_NEXT calls, such as you'd get from getpwent(). Normally, each YPPROC_NEXT would require open()ing the database, seeking to the location supplied by the caller (which is time consuming with hash databases as the R_CURSOR flag doesn't work), reading the data, close()ing the database and then shipping the data off to the caller. The system call overhead is prohibitive, especially with very large maps. By caching the handle to an open database, we elimitate at least the open()/close() system calls, as well as the associated DB setup and tear-down operations, for a large percentage of the time. This improves performance substantially at the cost of consuming a little more memory than before. Note that all the caching support is surrounded by #ifdef DB_CACHE so that this same source module can still be used by other programs that don't need it. - Make yp_open_db() call yp_validdomain(). Doing it here saves cycles when caching is enabled since a hit on the map cache list by definition means that the domain being referenced is valid. - Also make yp_open_db() check for exhaustion of file descriptors, just in case. yp_server.c: - Reorganize things a little to take advantage of the database handle caching. Add a call to yp_flush_all() in ypproc_clear_2_svc(). - Remove calls to yp_validdomain() from some of the service procedures. yp_validdomain() is called inside yp_open_db() now, so procedures that call into the database package don't need to use yp_validdomain() themselves. - Fix a bogosity in ypproc_maplist_2_svc(): don't summarily initiallize the result.maps pointer to NULL. This causes yp_maplist_free() to fail and leaks memory. - Make ypproc_master_2_svc() copy the string it gets from the database package into a private static buffer before trying to NUL terminate it. This is necessary with the DB handle caching: stuffing a NUL into the data returned by DB package will goof it up internally. yp_main.c: - Stuff for DB handle caching: call yp_init_dbs() to clear the handle array and add call to yp_flush_all() to the SIGHUP signal handler. Makefile.yp: - Reorganize to deal with database caching. yp_mkdb(8) can now be used to send a YPPROC_CLEAR signal to ypserv(8). Call it after each map is created to refresh ypserv's cache. - Add support for mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). - Make default location for the netgroups source file be /var/yp/netgroup instead of /etc/netgroup. mkaliases: - New file: script to generate mail.alias map. Contributed by Mike Murphy (mrm@sceard.com). Makefile: - Install Makefile.yp as /var/yp/Makefile.dist and link it to /var/yp/Makefile only if /var/yp/Makefile doesn't already exist. Suggested by Peter Wemm. - Install new mkaliases script in /usr/libexec along with mknetid. - Use somewhat saner approach to generating rpcgen-dependent files as suggested by Garrett Wollman.
1996-04-28 04:38:52 +00:00
static ypresp_maplist result = { 0, NULL };
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#ifdef DB_CACHE
if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) {
#else
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
if (yp_access(NULL, (struct svc_req *)rqstp)) {
Add support for handling the YP_SECURE and YP_INTERDOMAIN keys from any maps that may have them. If the YP_SECURE key is present, ypserv will only allow access to the map from clients on reserved ports. If the YP_INTERDOMAIN key is present, the server will do DNS lookups for hostnames that it can't find in hosts.byname or hosts.byaddr. This is the same as the -d flag (which is retained for backwards compatibility) but it can be set on a per-map/per-domain basis. Also modified /var/yp/Makefile to add YP_INTERDOMAIN to the hosts.* maps and YP_SECURE to master.passwd.* maps by default.
1996-10-24 18:58:26 +00:00
#endif
Import the new, non-GPL ypserv, written by yours truly. Functionally equivalent to the old ypserv, except that it doesn't support the -p [port] option to force the server to use a particular port. The server stubs and yp.h header file are auto-generated from the yp.x protocol definition file. The auto-generated XDR routines in libc/yp are also used. The database access code has been broken out into a seperate module so that other NIS utilities (ypxfr in particular) can use it. Note that the old mknetid script is being temporarily moved here; it will be replaced by an mknetid program which will eventually have a home under /usr/src/libexec. (The existing script is actually somewhat broken -- it doesn't handle hosts -- but this isn't a big deal at this point since the netid.byname map is really only useful fopr Secure RPC, which we don't have yet.)
1995-12-16 20:54:17 +00:00
result.stat = YP_YPERR;
return(&result);
}
if (argp == NULL) {
result.stat = YP_BADARGS;
return (&result);
}
if (yp_validdomain(*argp)) {
result.stat = YP_NODOM;
return (&result);
}
/*
* We have to construct a linked list for the ypproc_maplist
* procedure using dynamically allocated memory. Since the XDR
* layer won't free this list for us, we have to deal with it
* ourselves. We call yp_maplist_free() first to free any
* previously allocated data we may have accumulated to insure
* that we have only one linked list in memory at any given
* time.
*/
yp_maplist_free(result.maps);
if ((result.maps = yp_maplist_create(*argp)) == NULL) {
yp_error("yp_maplist_create failed");
result.stat = YP_YPERR;
return(&result);
} else
result.stat = YP_TRUE;
return (&result);
}
Add support for NIS v1 client procedures. The following procedures are currently implemented: YPOLDPROC_NULL YPOLDPROC_DOMAIN YPOLDPROC_DOMAIN_NONACK YPOLDPROC_FIRST YPOLDPROC_NEXT YPOLDPROC_MATCH YPOLDPROC_POLL These are all implemented as wrappers around their v2 counterparts. The YPOLDPROC_PUSH, PULL and GET procedures are not implemented since a) I couldn't figure out exactly what to have them do, and b) I suspect they're used for doing map transfers between master and slave servers, which we already do using the v2 protocol anyway. This means we can server NIS v1 clients but can't be a master or slave with NIS v1-only servers. I think I'll get over it. :) The -k (sunos_4_kludge) flag and associated code has been removed since it is no longer needed. Also tweaked yp_access() to handle both sets of procedures and updated the man page.
1996-02-26 02:34:27 +00:00
/*
* NIS v1 support. The nullproc, domain and domain_nonack
* functions from v1 are identical to those in v2, so all
* we have to do is hand off to them.
*
* The other functions are mostly just wrappers around their v2
* counterparts. For example, for the v1 'match' procedure, we
* crack open the argument structure, make a request to the v2
* 'match' function, repackage the data into a v1 response and
* then send it on its way.
*
* Note that we don't support the pull, push and get procedures.
* There's little documentation available to show what they
* do, and I suspect they're meant largely for map transfers
* between master and slave servers.
*/
void *
ypoldproc_null_1_svc(void *argp, struct svc_req *rqstp)
{
return(ypproc_null_2_svc(argp, rqstp));
}
bool_t *
ypoldproc_domain_1_svc(domainname *argp, struct svc_req *rqstp)
{
return(ypproc_domain_2_svc(argp, rqstp));
}
bool_t *
ypoldproc_domain_nonack_1_svc(domainname *argp, struct svc_req *rqstp)
{
return (ypproc_domain_nonack_2_svc(argp, rqstp));
}
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
/*
* the 'match' procedure sends a response of type YPRESP_VAL
*/
Add support for NIS v1 client procedures. The following procedures are currently implemented: YPOLDPROC_NULL YPOLDPROC_DOMAIN YPOLDPROC_DOMAIN_NONACK YPOLDPROC_FIRST YPOLDPROC_NEXT YPOLDPROC_MATCH YPOLDPROC_POLL These are all implemented as wrappers around their v2 counterparts. The YPOLDPROC_PUSH, PULL and GET procedures are not implemented since a) I couldn't figure out exactly what to have them do, and b) I suspect they're used for doing map transfers between master and slave servers, which we already do using the v2 protocol anyway. This means we can server NIS v1 clients but can't be a master or slave with NIS v1-only servers. I think I'll get over it. :) The -k (sunos_4_kludge) flag and associated code has been removed since it is no longer needed. Also tweaked yp_access() to handle both sets of procedures and updated the man page.
1996-02-26 02:34:27 +00:00
ypresponse *
ypoldproc_match_1_svc(yprequest *argp, struct svc_req *rqstp)
{
static ypresponse result;
ypresp_val *v2_result;
result.yp_resptype = YPRESP_VAL;
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
result.ypresponse_u.yp_resp_valtype.val.valdat_val = "";
result.ypresponse_u.yp_resp_valtype.val.valdat_len = 0;
Add support for NIS v1 client procedures. The following procedures are currently implemented: YPOLDPROC_NULL YPOLDPROC_DOMAIN YPOLDPROC_DOMAIN_NONACK YPOLDPROC_FIRST YPOLDPROC_NEXT YPOLDPROC_MATCH YPOLDPROC_POLL These are all implemented as wrappers around their v2 counterparts. The YPOLDPROC_PUSH, PULL and GET procedures are not implemented since a) I couldn't figure out exactly what to have them do, and b) I suspect they're used for doing map transfers between master and slave servers, which we already do using the v2 protocol anyway. This means we can server NIS v1 clients but can't be a master or slave with NIS v1-only servers. I think I'll get over it. :) The -k (sunos_4_kludge) flag and associated code has been removed since it is no longer needed. Also tweaked yp_access() to handle both sets of procedures and updated the man page.
1996-02-26 02:34:27 +00:00
if (argp->yp_reqtype != YPREQ_KEY) {
result.ypresponse_u.yp_resp_valtype.stat = YP_BADARGS;
return(&result);
}
v2_result = ypproc_match_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp);
if (v2_result == NULL)
return(NULL);
bcopy((char *)v2_result,
(char *)&result.ypresponse_u.yp_resp_valtype,
sizeof(ypresp_val));
return (&result);
}
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
/*
* the 'first' procedure sends a response of type YPRESP_KEY_VAL
*/
Add support for NIS v1 client procedures. The following procedures are currently implemented: YPOLDPROC_NULL YPOLDPROC_DOMAIN YPOLDPROC_DOMAIN_NONACK YPOLDPROC_FIRST YPOLDPROC_NEXT YPOLDPROC_MATCH YPOLDPROC_POLL These are all implemented as wrappers around their v2 counterparts. The YPOLDPROC_PUSH, PULL and GET procedures are not implemented since a) I couldn't figure out exactly what to have them do, and b) I suspect they're used for doing map transfers between master and slave servers, which we already do using the v2 protocol anyway. This means we can server NIS v1 clients but can't be a master or slave with NIS v1-only servers. I think I'll get over it. :) The -k (sunos_4_kludge) flag and associated code has been removed since it is no longer needed. Also tweaked yp_access() to handle both sets of procedures and updated the man page.
1996-02-26 02:34:27 +00:00
ypresponse *
ypoldproc_first_1_svc(yprequest *argp, struct svc_req *rqstp)
{
static ypresponse result;
ypresp_key_val *v2_result;
result.yp_resptype = YPRESP_KEY_VAL;
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
result.ypresponse_u.yp_resp_key_valtype.val.valdat_val =
result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = "";
result.ypresponse_u.yp_resp_key_valtype.val.valdat_len =
result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0;
Add support for NIS v1 client procedures. The following procedures are currently implemented: YPOLDPROC_NULL YPOLDPROC_DOMAIN YPOLDPROC_DOMAIN_NONACK YPOLDPROC_FIRST YPOLDPROC_NEXT YPOLDPROC_MATCH YPOLDPROC_POLL These are all implemented as wrappers around their v2 counterparts. The YPOLDPROC_PUSH, PULL and GET procedures are not implemented since a) I couldn't figure out exactly what to have them do, and b) I suspect they're used for doing map transfers between master and slave servers, which we already do using the v2 protocol anyway. This means we can server NIS v1 clients but can't be a master or slave with NIS v1-only servers. I think I'll get over it. :) The -k (sunos_4_kludge) flag and associated code has been removed since it is no longer needed. Also tweaked yp_access() to handle both sets of procedures and updated the man page.
1996-02-26 02:34:27 +00:00
if (argp->yp_reqtype != YPREQ_NOKEY) {
result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS;
return(&result);
}
v2_result = ypproc_first_2_svc(&argp->yprequest_u.yp_req_nokeytype,
rqstp);
if (v2_result == NULL)
return(NULL);
bcopy((char *)v2_result,
(char *)&result.ypresponse_u.yp_resp_key_valtype,
sizeof(ypresp_key_val));
return (&result);
}
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
/*
* the 'next' procedure sends a response of type YPRESP_KEY_VAL
*/
Add support for NIS v1 client procedures. The following procedures are currently implemented: YPOLDPROC_NULL YPOLDPROC_DOMAIN YPOLDPROC_DOMAIN_NONACK YPOLDPROC_FIRST YPOLDPROC_NEXT YPOLDPROC_MATCH YPOLDPROC_POLL These are all implemented as wrappers around their v2 counterparts. The YPOLDPROC_PUSH, PULL and GET procedures are not implemented since a) I couldn't figure out exactly what to have them do, and b) I suspect they're used for doing map transfers between master and slave servers, which we already do using the v2 protocol anyway. This means we can server NIS v1 clients but can't be a master or slave with NIS v1-only servers. I think I'll get over it. :) The -k (sunos_4_kludge) flag and associated code has been removed since it is no longer needed. Also tweaked yp_access() to handle both sets of procedures and updated the man page.
1996-02-26 02:34:27 +00:00
ypresponse *
ypoldproc_next_1_svc(yprequest *argp, struct svc_req *rqstp)
{
static ypresponse result;
ypresp_key_val *v2_result;
result.yp_resptype = YPRESP_KEY_VAL;
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
result.ypresponse_u.yp_resp_key_valtype.val.valdat_val =
result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = "";
result.ypresponse_u.yp_resp_key_valtype.val.valdat_len =
result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0;
Add support for NIS v1 client procedures. The following procedures are currently implemented: YPOLDPROC_NULL YPOLDPROC_DOMAIN YPOLDPROC_DOMAIN_NONACK YPOLDPROC_FIRST YPOLDPROC_NEXT YPOLDPROC_MATCH YPOLDPROC_POLL These are all implemented as wrappers around their v2 counterparts. The YPOLDPROC_PUSH, PULL and GET procedures are not implemented since a) I couldn't figure out exactly what to have them do, and b) I suspect they're used for doing map transfers between master and slave servers, which we already do using the v2 protocol anyway. This means we can server NIS v1 clients but can't be a master or slave with NIS v1-only servers. I think I'll get over it. :) The -k (sunos_4_kludge) flag and associated code has been removed since it is no longer needed. Also tweaked yp_access() to handle both sets of procedures and updated the man page.
1996-02-26 02:34:27 +00:00
if (argp->yp_reqtype != YPREQ_KEY) {
result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS;
return(&result);
}
v2_result = ypproc_next_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp);
if (v2_result == NULL)
return(NULL);
bcopy((char *)v2_result,
(char *)&result.ypresponse_u.yp_resp_key_valtype,
sizeof(ypresp_key_val));
return (&result);
}
Initialize a few more 'result' members in a few places (both in the v2 and v2 service procedures). Also fixed the formatting in a few places to keep everything under 80 columns.
1996-03-01 03:49:47 +00:00
/*
* the 'poll' procedure sends a response of type YPRESP_MAP_PARMS
*/
Add support for NIS v1 client procedures. The following procedures are currently implemented: YPOLDPROC_NULL YPOLDPROC_DOMAIN YPOLDPROC_DOMAIN_NONACK YPOLDPROC_FIRST YPOLDPROC_NEXT YPOLDPROC_MATCH YPOLDPROC_POLL These are all implemented as wrappers around their v2 counterparts. The YPOLDPROC_PUSH, PULL and GET procedures are not implemented since a) I couldn't figure out exactly what to have them do, and b) I suspect they're used for doing map transfers between master and slave servers, which we already do using the v2 protocol anyway. This means we can server NIS v1 clients but can't be a master or slave with NIS v1-only servers. I think I'll get over it. :) The -k (sunos_4_kludge) flag and associated code has been removed since it is no longer needed. Also tweaked yp_access() to handle both sets of procedures and updated the man page.
1996-02-26 02:34:27 +00:00
ypresponse *
ypoldproc_poll_1_svc(yprequest *argp, struct svc_req *rqstp)
{
static ypresponse result;
ypresp_master *v2_result1;
ypresp_order *v2_result2;
result.yp_resptype = YPRESP_MAP_PARMS;
result.ypresponse_u.yp_resp_map_parmstype.domain =
argp->yprequest_u.yp_req_nokeytype.domain;
result.ypresponse_u.yp_resp_map_parmstype.map =
argp->yprequest_u.yp_req_nokeytype.map;
/*
* Hmm... there is no 'status' value in the
* yp_resp_map_parmstype structure, so I have to
* guess at what to do to indicate a failure.
* I hope this is right.
*/
result.ypresponse_u.yp_resp_map_parmstype.ordernum = 0;
result.ypresponse_u.yp_resp_map_parmstype.peer = "";
if (argp->yp_reqtype != YPREQ_MAP_PARMS) {
return(&result);
}
v2_result1 = ypproc_master_2_svc(&argp->yprequest_u.yp_req_nokeytype,
rqstp);
if (v2_result1 == NULL)
return(NULL);
if (v2_result1->stat != YP_TRUE) {
return(&result);
}
v2_result2 = ypproc_order_2_svc(&argp->yprequest_u.yp_req_nokeytype,
rqstp);
if (v2_result2 == NULL)
return(NULL);
if (v2_result2->stat != YP_TRUE) {
return(&result);
}
result.ypresponse_u.yp_resp_map_parmstype.peer =
v2_result1->peer;
result.ypresponse_u.yp_resp_map_parmstype.ordernum =
v2_result2->ordernum;
return (&result);
}
ypresponse *
ypoldproc_push_1_svc(yprequest *argp, struct svc_req *rqstp)
{
static ypresponse result;
/*
* Not implemented.
*/
return (&result);
}
ypresponse *
ypoldproc_pull_1_svc(yprequest *argp, struct svc_req *rqstp)
{
static ypresponse result;
/*
* Not implemented.
*/
return (&result);
}
ypresponse *
ypoldproc_get_1_svc(yprequest *argp, struct svc_req *rqstp)
{
static ypresponse result;
/*
* Not implemented.
*/
return (&result);
}
Reference in New Issue Copy Permalink