freebsd-skq/usr.sbin/rpc.ypxfrd/ypxfrd_main.c

305 lines
7.0 KiB
C
Raw Normal View History

Import rpc.ypxfrd. This server impliments an RPC-based file transfer protocol that allows an NIS slave server to copy a raw map database file from an NIS master. The goal here is to speed up the transfer of very large maps. If you have, for example, an NIS password database with 30,000 records in it, it can take around 8 to 10 minutes to regenerate it (four hash databases are created). As it stands now, ypxfr(8) transfers a map by sucking all the records from ypserv(8) on the master using yp_all() and writing them to a new database using the db(3) library. This adds up to another 8 to 10 minutes, per slave. With as the number of slaves increases, this latency becomes prohibitive. With rpc.ypxfrd, all the slave has to do is copy the already-built hash database file from the master and move it into place. Even with a multi-megabyte file, this reduces the master to slave transfer time to well under a minute. (This is using TCP.) Access restrictions are applied using the same mechanism as in ypserv: you can control access using /var/yp/securenets, and the server will not transmit the master.passwd.* maps unless the transfer request originates on a reserved port. Note: this server is based on my hastily contrived protocol and is _NOT_ compatible with Sun's protocol of the same name. It can't be compatible for a couple of reasons. For one thing, Sun's protocol has not been published anywhere that I know of. It is not included in any of the SunRPC source distributions that I've been able to find. Second, Sun's NIS v2 code uses old style ndbm maps while FreeBSD uses Berkeley DB. The file formats are incompatible, so being able to transfer maps between FreeBSD and SunOS hosts wouldn't do any good anyway. (You could always port the FreeBSD NIS code to SunOS if you really wanted to do it. :) (There's also the little fact that SunOS/SPARC is big-endian and FreeBSD/i386 is little-endian. Berkeley DB can handle byte ordering differences; ndbm probably can't.)
1996-06-05 04:36:55 +00:00
/*
* Copyright (c) 1995, 1996
* 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.
*/
#ifndef lint
static const char rcsid[] =
"$Id: ypxfrd_main.c,v 1.6 1997/10/13 11:22:37 charnier Exp $";
#endif /* not lint */
Import rpc.ypxfrd. This server impliments an RPC-based file transfer protocol that allows an NIS slave server to copy a raw map database file from an NIS master. The goal here is to speed up the transfer of very large maps. If you have, for example, an NIS password database with 30,000 records in it, it can take around 8 to 10 minutes to regenerate it (four hash databases are created). As it stands now, ypxfr(8) transfers a map by sucking all the records from ypserv(8) on the master using yp_all() and writing them to a new database using the db(3) library. This adds up to another 8 to 10 minutes, per slave. With as the number of slaves increases, this latency becomes prohibitive. With rpc.ypxfrd, all the slave has to do is copy the already-built hash database file from the master and move it into place. Even with a multi-megabyte file, this reduces the master to slave transfer time to well under a minute. (This is using TCP.) Access restrictions are applied using the same mechanism as in ypserv: you can control access using /var/yp/securenets, and the server will not transmit the master.passwd.* maps unless the transfer request originates on a reserved port. Note: this server is based on my hastily contrived protocol and is _NOT_ compatible with Sun's protocol of the same name. It can't be compatible for a couple of reasons. For one thing, Sun's protocol has not been published anywhere that I know of. It is not included in any of the SunRPC source distributions that I've been able to find. Second, Sun's NIS v2 code uses old style ndbm maps while FreeBSD uses Berkeley DB. The file formats are incompatible, so being able to transfer maps between FreeBSD and SunOS hosts wouldn't do any good anyway. (You could always port the FreeBSD NIS code to SunOS if you really wanted to do it. :) (There's also the little fact that SunOS/SPARC is big-endian and FreeBSD/i386 is little-endian. Berkeley DB can handle byte ordering differences; ndbm probably can't.)
1996-06-05 04:36:55 +00:00
#include "ypxfrd.h"
#include <err.h>
#include <fcntl.h>
Import rpc.ypxfrd. This server impliments an RPC-based file transfer protocol that allows an NIS slave server to copy a raw map database file from an NIS master. The goal here is to speed up the transfer of very large maps. If you have, for example, an NIS password database with 30,000 records in it, it can take around 8 to 10 minutes to regenerate it (four hash databases are created). As it stands now, ypxfr(8) transfers a map by sucking all the records from ypserv(8) on the master using yp_all() and writing them to a new database using the db(3) library. This adds up to another 8 to 10 minutes, per slave. With as the number of slaves increases, this latency becomes prohibitive. With rpc.ypxfrd, all the slave has to do is copy the already-built hash database file from the master and move it into place. Even with a multi-megabyte file, this reduces the master to slave transfer time to well under a minute. (This is using TCP.) Access restrictions are applied using the same mechanism as in ypserv: you can control access using /var/yp/securenets, and the server will not transmit the master.passwd.* maps unless the transfer request originates on a reserved port. Note: this server is based on my hastily contrived protocol and is _NOT_ compatible with Sun's protocol of the same name. It can't be compatible for a couple of reasons. For one thing, Sun's protocol has not been published anywhere that I know of. It is not included in any of the SunRPC source distributions that I've been able to find. Second, Sun's NIS v2 code uses old style ndbm maps while FreeBSD uses Berkeley DB. The file formats are incompatible, so being able to transfer maps between FreeBSD and SunOS hosts wouldn't do any good anyway. (You could always port the FreeBSD NIS code to SunOS if you really wanted to do it. :) (There's also the little fact that SunOS/SPARC is big-endian and FreeBSD/i386 is little-endian. Berkeley DB can handle byte ordering differences; ndbm probably can't.)
1996-06-05 04:36:55 +00:00
#include <stdio.h>
#include <stdlib.h> /* getenv, exit */
1997-03-11 15:57:44 +00:00
#include <unistd.h>
Import rpc.ypxfrd. This server impliments an RPC-based file transfer protocol that allows an NIS slave server to copy a raw map database file from an NIS master. The goal here is to speed up the transfer of very large maps. If you have, for example, an NIS password database with 30,000 records in it, it can take around 8 to 10 minutes to regenerate it (four hash databases are created). As it stands now, ypxfr(8) transfers a map by sucking all the records from ypserv(8) on the master using yp_all() and writing them to a new database using the db(3) library. This adds up to another 8 to 10 minutes, per slave. With as the number of slaves increases, this latency becomes prohibitive. With rpc.ypxfrd, all the slave has to do is copy the already-built hash database file from the master and move it into place. Even with a multi-megabyte file, this reduces the master to slave transfer time to well under a minute. (This is using TCP.) Access restrictions are applied using the same mechanism as in ypserv: you can control access using /var/yp/securenets, and the server will not transmit the master.passwd.* maps unless the transfer request originates on a reserved port. Note: this server is based on my hastily contrived protocol and is _NOT_ compatible with Sun's protocol of the same name. It can't be compatible for a couple of reasons. For one thing, Sun's protocol has not been published anywhere that I know of. It is not included in any of the SunRPC source distributions that I've been able to find. Second, Sun's NIS v2 code uses old style ndbm maps while FreeBSD uses Berkeley DB. The file formats are incompatible, so being able to transfer maps between FreeBSD and SunOS hosts wouldn't do any good anyway. (You could always port the FreeBSD NIS code to SunOS if you really wanted to do it. :) (There's also the little fact that SunOS/SPARC is big-endian and FreeBSD/i386 is little-endian. Berkeley DB can handle byte ordering differences; ndbm probably can't.)
1996-06-05 04:36:55 +00:00
#include <rpc/pmap_clnt.h> /* for pmap_unset */
#include <string.h> /* strcmp */
#include <signal.h>
#include <sys/ttycom.h> /* TIOCNOTTY */
#ifdef __cplusplus
#include <sysent.h> /* getdtablesize, open */
#endif /* __cplusplus */
#include <memory.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <syslog.h>
#include "ypxfrd_extern.h"
#include <sys/wait.h>
#include <errno.h>
#ifndef SIG_PF
#define SIG_PF void(*)(int)
#endif
#ifdef DEBUG
#define RPC_SVC_FG
#endif
#define _RPCSVC_CLOSEDOWN 120
int _rpcpmstart; /* Started by a port monitor ? */
static int _rpcfdtype;
/* Whether Stream or Datagram ? */
/* States a server can be in wrt request */
#define _IDLE 0
#define _SERVED 1
#define _SERVING 2
extern int _rpcsvcstate; /* Set when a request is serviced */
char *progname = "rpc.ypxfrd";
char *yp_dir = "/var/yp/";
static
void _msgout(char* msg)
{
#ifdef RPC_SVC_FG
if (_rpcpmstart)
syslog(LOG_ERR, msg);
else
warnx("%s", msg);
Import rpc.ypxfrd. This server impliments an RPC-based file transfer protocol that allows an NIS slave server to copy a raw map database file from an NIS master. The goal here is to speed up the transfer of very large maps. If you have, for example, an NIS password database with 30,000 records in it, it can take around 8 to 10 minutes to regenerate it (four hash databases are created). As it stands now, ypxfr(8) transfers a map by sucking all the records from ypserv(8) on the master using yp_all() and writing them to a new database using the db(3) library. This adds up to another 8 to 10 minutes, per slave. With as the number of slaves increases, this latency becomes prohibitive. With rpc.ypxfrd, all the slave has to do is copy the already-built hash database file from the master and move it into place. Even with a multi-megabyte file, this reduces the master to slave transfer time to well under a minute. (This is using TCP.) Access restrictions are applied using the same mechanism as in ypserv: you can control access using /var/yp/securenets, and the server will not transmit the master.passwd.* maps unless the transfer request originates on a reserved port. Note: this server is based on my hastily contrived protocol and is _NOT_ compatible with Sun's protocol of the same name. It can't be compatible for a couple of reasons. For one thing, Sun's protocol has not been published anywhere that I know of. It is not included in any of the SunRPC source distributions that I've been able to find. Second, Sun's NIS v2 code uses old style ndbm maps while FreeBSD uses Berkeley DB. The file formats are incompatible, so being able to transfer maps between FreeBSD and SunOS hosts wouldn't do any good anyway. (You could always port the FreeBSD NIS code to SunOS if you really wanted to do it. :) (There's also the little fact that SunOS/SPARC is big-endian and FreeBSD/i386 is little-endian. Berkeley DB can handle byte ordering differences; ndbm probably can't.)
1996-06-05 04:36:55 +00:00
#else
syslog(LOG_ERR, msg);
#endif
}
static void
closedown(int sig)
{
if (_rpcsvcstate == _IDLE) {
extern fd_set svc_fdset;
static int size;
int i, openfd;
if (_rpcfdtype == SOCK_DGRAM)
exit(0);
if (size == 0) {
size = getdtablesize();
}
for (i = 0, openfd = 0; i < size && openfd < 2; i++)
if (FD_ISSET(i, &svc_fdset))
openfd++;
if (openfd <= 1)
exit(0);
}
if (_rpcsvcstate == _SERVED)
_rpcsvcstate = _IDLE;
(void) signal(SIGALRM, (SIG_PF) closedown);
(void) alarm(_RPCSVC_CLOSEDOWN/2);
}
static void
ypxfrd_svc_run()
{
#ifdef FD_SETSIZE
fd_set readfds;
#else
int readfds;
#endif /* def FD_SETSIZE */
extern int forked;
int pid;
int fd_setsize = _rpc_dtablesize();
/* Establish the identity of the parent ypserv process. */
pid = getpid();
for (;;) {
#ifdef FD_SETSIZE
readfds = svc_fdset;
#else
readfds = svc_fds;
#endif /* def FD_SETSIZE */
switch (select(fd_setsize, &readfds, NULL, NULL,
(struct timeval *)0)) {
case -1:
if (errno == EINTR) {
continue;
}
warn("svc_run: - select failed");
Import rpc.ypxfrd. This server impliments an RPC-based file transfer protocol that allows an NIS slave server to copy a raw map database file from an NIS master. The goal here is to speed up the transfer of very large maps. If you have, for example, an NIS password database with 30,000 records in it, it can take around 8 to 10 minutes to regenerate it (four hash databases are created). As it stands now, ypxfr(8) transfers a map by sucking all the records from ypserv(8) on the master using yp_all() and writing them to a new database using the db(3) library. This adds up to another 8 to 10 minutes, per slave. With as the number of slaves increases, this latency becomes prohibitive. With rpc.ypxfrd, all the slave has to do is copy the already-built hash database file from the master and move it into place. Even with a multi-megabyte file, this reduces the master to slave transfer time to well under a minute. (This is using TCP.) Access restrictions are applied using the same mechanism as in ypserv: you can control access using /var/yp/securenets, and the server will not transmit the master.passwd.* maps unless the transfer request originates on a reserved port. Note: this server is based on my hastily contrived protocol and is _NOT_ compatible with Sun's protocol of the same name. It can't be compatible for a couple of reasons. For one thing, Sun's protocol has not been published anywhere that I know of. It is not included in any of the SunRPC source distributions that I've been able to find. Second, Sun's NIS v2 code uses old style ndbm maps while FreeBSD uses Berkeley DB. The file formats are incompatible, so being able to transfer maps between FreeBSD and SunOS hosts wouldn't do any good anyway. (You could always port the FreeBSD NIS code to SunOS if you really wanted to do it. :) (There's also the little fact that SunOS/SPARC is big-endian and FreeBSD/i386 is little-endian. Berkeley DB can handle byte ordering differences; ndbm probably can't.)
1996-06-05 04:36:55 +00:00
return;
case 0:
continue;
default:
svc_getreqset(&readfds);
if (forked && pid != getpid())
exit(0);
}
}
}
static void reaper(sig)
int sig;
{
int status;
int saved_errno;
saved_errno = errno;
Import rpc.ypxfrd. This server impliments an RPC-based file transfer protocol that allows an NIS slave server to copy a raw map database file from an NIS master. The goal here is to speed up the transfer of very large maps. If you have, for example, an NIS password database with 30,000 records in it, it can take around 8 to 10 minutes to regenerate it (four hash databases are created). As it stands now, ypxfr(8) transfers a map by sucking all the records from ypserv(8) on the master using yp_all() and writing them to a new database using the db(3) library. This adds up to another 8 to 10 minutes, per slave. With as the number of slaves increases, this latency becomes prohibitive. With rpc.ypxfrd, all the slave has to do is copy the already-built hash database file from the master and move it into place. Even with a multi-megabyte file, this reduces the master to slave transfer time to well under a minute. (This is using TCP.) Access restrictions are applied using the same mechanism as in ypserv: you can control access using /var/yp/securenets, and the server will not transmit the master.passwd.* maps unless the transfer request originates on a reserved port. Note: this server is based on my hastily contrived protocol and is _NOT_ compatible with Sun's protocol of the same name. It can't be compatible for a couple of reasons. For one thing, Sun's protocol has not been published anywhere that I know of. It is not included in any of the SunRPC source distributions that I've been able to find. Second, Sun's NIS v2 code uses old style ndbm maps while FreeBSD uses Berkeley DB. The file formats are incompatible, so being able to transfer maps between FreeBSD and SunOS hosts wouldn't do any good anyway. (You could always port the FreeBSD NIS code to SunOS if you really wanted to do it. :) (There's also the little fact that SunOS/SPARC is big-endian and FreeBSD/i386 is little-endian. Berkeley DB can handle byte ordering differences; ndbm probably can't.)
1996-06-05 04:36:55 +00:00
if (sig == SIGHUP) {
load_securenets();
errno = saved_errno;
Import rpc.ypxfrd. This server impliments an RPC-based file transfer protocol that allows an NIS slave server to copy a raw map database file from an NIS master. The goal here is to speed up the transfer of very large maps. If you have, for example, an NIS password database with 30,000 records in it, it can take around 8 to 10 minutes to regenerate it (four hash databases are created). As it stands now, ypxfr(8) transfers a map by sucking all the records from ypserv(8) on the master using yp_all() and writing them to a new database using the db(3) library. This adds up to another 8 to 10 minutes, per slave. With as the number of slaves increases, this latency becomes prohibitive. With rpc.ypxfrd, all the slave has to do is copy the already-built hash database file from the master and move it into place. Even with a multi-megabyte file, this reduces the master to slave transfer time to well under a minute. (This is using TCP.) Access restrictions are applied using the same mechanism as in ypserv: you can control access using /var/yp/securenets, and the server will not transmit the master.passwd.* maps unless the transfer request originates on a reserved port. Note: this server is based on my hastily contrived protocol and is _NOT_ compatible with Sun's protocol of the same name. It can't be compatible for a couple of reasons. For one thing, Sun's protocol has not been published anywhere that I know of. It is not included in any of the SunRPC source distributions that I've been able to find. Second, Sun's NIS v2 code uses old style ndbm maps while FreeBSD uses Berkeley DB. The file formats are incompatible, so being able to transfer maps between FreeBSD and SunOS hosts wouldn't do any good anyway. (You could always port the FreeBSD NIS code to SunOS if you really wanted to do it. :) (There's also the little fact that SunOS/SPARC is big-endian and FreeBSD/i386 is little-endian. Berkeley DB can handle byte ordering differences; ndbm probably can't.)
1996-06-05 04:36:55 +00:00
return;
}
if (sig == SIGCHLD) {
while (wait3(&status, WNOHANG, NULL) > 0)
children--;
} else {
(void) pmap_unset(YPXFRD_FREEBSD_PROG, YPXFRD_FREEBSD_VERS);
exit(0);
}
errno = saved_errno;
return;
Import rpc.ypxfrd. This server impliments an RPC-based file transfer protocol that allows an NIS slave server to copy a raw map database file from an NIS master. The goal here is to speed up the transfer of very large maps. If you have, for example, an NIS password database with 30,000 records in it, it can take around 8 to 10 minutes to regenerate it (four hash databases are created). As it stands now, ypxfr(8) transfers a map by sucking all the records from ypserv(8) on the master using yp_all() and writing them to a new database using the db(3) library. This adds up to another 8 to 10 minutes, per slave. With as the number of slaves increases, this latency becomes prohibitive. With rpc.ypxfrd, all the slave has to do is copy the already-built hash database file from the master and move it into place. Even with a multi-megabyte file, this reduces the master to slave transfer time to well under a minute. (This is using TCP.) Access restrictions are applied using the same mechanism as in ypserv: you can control access using /var/yp/securenets, and the server will not transmit the master.passwd.* maps unless the transfer request originates on a reserved port. Note: this server is based on my hastily contrived protocol and is _NOT_ compatible with Sun's protocol of the same name. It can't be compatible for a couple of reasons. For one thing, Sun's protocol has not been published anywhere that I know of. It is not included in any of the SunRPC source distributions that I've been able to find. Second, Sun's NIS v2 code uses old style ndbm maps while FreeBSD uses Berkeley DB. The file formats are incompatible, so being able to transfer maps between FreeBSD and SunOS hosts wouldn't do any good anyway. (You could always port the FreeBSD NIS code to SunOS if you really wanted to do it. :) (There's also the little fact that SunOS/SPARC is big-endian and FreeBSD/i386 is little-endian. Berkeley DB can handle byte ordering differences; ndbm probably can't.)
1996-06-05 04:36:55 +00:00
}
void usage()
{
fprintf(stderr, "usage: rpc.ypxfrd [-p path]\n");
Import rpc.ypxfrd. This server impliments an RPC-based file transfer protocol that allows an NIS slave server to copy a raw map database file from an NIS master. The goal here is to speed up the transfer of very large maps. If you have, for example, an NIS password database with 30,000 records in it, it can take around 8 to 10 minutes to regenerate it (four hash databases are created). As it stands now, ypxfr(8) transfers a map by sucking all the records from ypserv(8) on the master using yp_all() and writing them to a new database using the db(3) library. This adds up to another 8 to 10 minutes, per slave. With as the number of slaves increases, this latency becomes prohibitive. With rpc.ypxfrd, all the slave has to do is copy the already-built hash database file from the master and move it into place. Even with a multi-megabyte file, this reduces the master to slave transfer time to well under a minute. (This is using TCP.) Access restrictions are applied using the same mechanism as in ypserv: you can control access using /var/yp/securenets, and the server will not transmit the master.passwd.* maps unless the transfer request originates on a reserved port. Note: this server is based on my hastily contrived protocol and is _NOT_ compatible with Sun's protocol of the same name. It can't be compatible for a couple of reasons. For one thing, Sun's protocol has not been published anywhere that I know of. It is not included in any of the SunRPC source distributions that I've been able to find. Second, Sun's NIS v2 code uses old style ndbm maps while FreeBSD uses Berkeley DB. The file formats are incompatible, so being able to transfer maps between FreeBSD and SunOS hosts wouldn't do any good anyway. (You could always port the FreeBSD NIS code to SunOS if you really wanted to do it. :) (There's also the little fact that SunOS/SPARC is big-endian and FreeBSD/i386 is little-endian. Berkeley DB can handle byte ordering differences; ndbm probably can't.)
1996-06-05 04:36:55 +00:00
exit(0);
}
int
Import rpc.ypxfrd. This server impliments an RPC-based file transfer protocol that allows an NIS slave server to copy a raw map database file from an NIS master. The goal here is to speed up the transfer of very large maps. If you have, for example, an NIS password database with 30,000 records in it, it can take around 8 to 10 minutes to regenerate it (four hash databases are created). As it stands now, ypxfr(8) transfers a map by sucking all the records from ypserv(8) on the master using yp_all() and writing them to a new database using the db(3) library. This adds up to another 8 to 10 minutes, per slave. With as the number of slaves increases, this latency becomes prohibitive. With rpc.ypxfrd, all the slave has to do is copy the already-built hash database file from the master and move it into place. Even with a multi-megabyte file, this reduces the master to slave transfer time to well under a minute. (This is using TCP.) Access restrictions are applied using the same mechanism as in ypserv: you can control access using /var/yp/securenets, and the server will not transmit the master.passwd.* maps unless the transfer request originates on a reserved port. Note: this server is based on my hastily contrived protocol and is _NOT_ compatible with Sun's protocol of the same name. It can't be compatible for a couple of reasons. For one thing, Sun's protocol has not been published anywhere that I know of. It is not included in any of the SunRPC source distributions that I've been able to find. Second, Sun's NIS v2 code uses old style ndbm maps while FreeBSD uses Berkeley DB. The file formats are incompatible, so being able to transfer maps between FreeBSD and SunOS hosts wouldn't do any good anyway. (You could always port the FreeBSD NIS code to SunOS if you really wanted to do it. :) (There's also the little fact that SunOS/SPARC is big-endian and FreeBSD/i386 is little-endian. Berkeley DB can handle byte ordering differences; ndbm probably can't.)
1996-06-05 04:36:55 +00:00
main(argc, argv)
int argc;
char *argv[];
{
register SVCXPRT *transp = NULL;
Import rpc.ypxfrd. This server impliments an RPC-based file transfer protocol that allows an NIS slave server to copy a raw map database file from an NIS master. The goal here is to speed up the transfer of very large maps. If you have, for example, an NIS password database with 30,000 records in it, it can take around 8 to 10 minutes to regenerate it (four hash databases are created). As it stands now, ypxfr(8) transfers a map by sucking all the records from ypserv(8) on the master using yp_all() and writing them to a new database using the db(3) library. This adds up to another 8 to 10 minutes, per slave. With as the number of slaves increases, this latency becomes prohibitive. With rpc.ypxfrd, all the slave has to do is copy the already-built hash database file from the master and move it into place. Even with a multi-megabyte file, this reduces the master to slave transfer time to well under a minute. (This is using TCP.) Access restrictions are applied using the same mechanism as in ypserv: you can control access using /var/yp/securenets, and the server will not transmit the master.passwd.* maps unless the transfer request originates on a reserved port. Note: this server is based on my hastily contrived protocol and is _NOT_ compatible with Sun's protocol of the same name. It can't be compatible for a couple of reasons. For one thing, Sun's protocol has not been published anywhere that I know of. It is not included in any of the SunRPC source distributions that I've been able to find. Second, Sun's NIS v2 code uses old style ndbm maps while FreeBSD uses Berkeley DB. The file formats are incompatible, so being able to transfer maps between FreeBSD and SunOS hosts wouldn't do any good anyway. (You could always port the FreeBSD NIS code to SunOS if you really wanted to do it. :) (There's also the little fact that SunOS/SPARC is big-endian and FreeBSD/i386 is little-endian. Berkeley DB can handle byte ordering differences; ndbm probably can't.)
1996-06-05 04:36:55 +00:00
int sock;
int proto = 0;
Import rpc.ypxfrd. This server impliments an RPC-based file transfer protocol that allows an NIS slave server to copy a raw map database file from an NIS master. The goal here is to speed up the transfer of very large maps. If you have, for example, an NIS password database with 30,000 records in it, it can take around 8 to 10 minutes to regenerate it (four hash databases are created). As it stands now, ypxfr(8) transfers a map by sucking all the records from ypserv(8) on the master using yp_all() and writing them to a new database using the db(3) library. This adds up to another 8 to 10 minutes, per slave. With as the number of slaves increases, this latency becomes prohibitive. With rpc.ypxfrd, all the slave has to do is copy the already-built hash database file from the master and move it into place. Even with a multi-megabyte file, this reduces the master to slave transfer time to well under a minute. (This is using TCP.) Access restrictions are applied using the same mechanism as in ypserv: you can control access using /var/yp/securenets, and the server will not transmit the master.passwd.* maps unless the transfer request originates on a reserved port. Note: this server is based on my hastily contrived protocol and is _NOT_ compatible with Sun's protocol of the same name. It can't be compatible for a couple of reasons. For one thing, Sun's protocol has not been published anywhere that I know of. It is not included in any of the SunRPC source distributions that I've been able to find. Second, Sun's NIS v2 code uses old style ndbm maps while FreeBSD uses Berkeley DB. The file formats are incompatible, so being able to transfer maps between FreeBSD and SunOS hosts wouldn't do any good anyway. (You could always port the FreeBSD NIS code to SunOS if you really wanted to do it. :) (There's also the little fact that SunOS/SPARC is big-endian and FreeBSD/i386 is little-endian. Berkeley DB can handle byte ordering differences; ndbm probably can't.)
1996-06-05 04:36:55 +00:00
struct sockaddr_in saddr;
int asize = sizeof (saddr);
int ch;
while ((ch = getopt(argc, argv, "p:h")) != -1) {
Import rpc.ypxfrd. This server impliments an RPC-based file transfer protocol that allows an NIS slave server to copy a raw map database file from an NIS master. The goal here is to speed up the transfer of very large maps. If you have, for example, an NIS password database with 30,000 records in it, it can take around 8 to 10 minutes to regenerate it (four hash databases are created). As it stands now, ypxfr(8) transfers a map by sucking all the records from ypserv(8) on the master using yp_all() and writing them to a new database using the db(3) library. This adds up to another 8 to 10 minutes, per slave. With as the number of slaves increases, this latency becomes prohibitive. With rpc.ypxfrd, all the slave has to do is copy the already-built hash database file from the master and move it into place. Even with a multi-megabyte file, this reduces the master to slave transfer time to well under a minute. (This is using TCP.) Access restrictions are applied using the same mechanism as in ypserv: you can control access using /var/yp/securenets, and the server will not transmit the master.passwd.* maps unless the transfer request originates on a reserved port. Note: this server is based on my hastily contrived protocol and is _NOT_ compatible with Sun's protocol of the same name. It can't be compatible for a couple of reasons. For one thing, Sun's protocol has not been published anywhere that I know of. It is not included in any of the SunRPC source distributions that I've been able to find. Second, Sun's NIS v2 code uses old style ndbm maps while FreeBSD uses Berkeley DB. The file formats are incompatible, so being able to transfer maps between FreeBSD and SunOS hosts wouldn't do any good anyway. (You could always port the FreeBSD NIS code to SunOS if you really wanted to do it. :) (There's also the little fact that SunOS/SPARC is big-endian and FreeBSD/i386 is little-endian. Berkeley DB can handle byte ordering differences; ndbm probably can't.)
1996-06-05 04:36:55 +00:00
switch(ch) {
case 'p':
yp_dir = optarg;
break;
default:
usage();
break;
}
}
load_securenets();
if (getsockname(0, (struct sockaddr *)&saddr, &asize) == 0) {
int ssize = sizeof (int);
if (saddr.sin_family != AF_INET)
exit(1);
if (getsockopt(0, SOL_SOCKET, SO_TYPE,
(char *)&_rpcfdtype, &ssize) == -1)
exit(1);
sock = 0;
_rpcpmstart = 1;
proto = 0;
openlog("rpc.ypxfrd", LOG_PID, LOG_DAEMON);
} else {
#ifndef RPC_SVC_FG
int size;
int pid, i;
pid = fork();
if (pid < 0)
err(1, "fork");
Import rpc.ypxfrd. This server impliments an RPC-based file transfer protocol that allows an NIS slave server to copy a raw map database file from an NIS master. The goal here is to speed up the transfer of very large maps. If you have, for example, an NIS password database with 30,000 records in it, it can take around 8 to 10 minutes to regenerate it (four hash databases are created). As it stands now, ypxfr(8) transfers a map by sucking all the records from ypserv(8) on the master using yp_all() and writing them to a new database using the db(3) library. This adds up to another 8 to 10 minutes, per slave. With as the number of slaves increases, this latency becomes prohibitive. With rpc.ypxfrd, all the slave has to do is copy the already-built hash database file from the master and move it into place. Even with a multi-megabyte file, this reduces the master to slave transfer time to well under a minute. (This is using TCP.) Access restrictions are applied using the same mechanism as in ypserv: you can control access using /var/yp/securenets, and the server will not transmit the master.passwd.* maps unless the transfer request originates on a reserved port. Note: this server is based on my hastily contrived protocol and is _NOT_ compatible with Sun's protocol of the same name. It can't be compatible for a couple of reasons. For one thing, Sun's protocol has not been published anywhere that I know of. It is not included in any of the SunRPC source distributions that I've been able to find. Second, Sun's NIS v2 code uses old style ndbm maps while FreeBSD uses Berkeley DB. The file formats are incompatible, so being able to transfer maps between FreeBSD and SunOS hosts wouldn't do any good anyway. (You could always port the FreeBSD NIS code to SunOS if you really wanted to do it. :) (There's also the little fact that SunOS/SPARC is big-endian and FreeBSD/i386 is little-endian. Berkeley DB can handle byte ordering differences; ndbm probably can't.)
1996-06-05 04:36:55 +00:00
if (pid)
exit(0);
size = getdtablesize();
for (i = 0; i < size; i++)
(void) close(i);
i = open("/dev/console", 2);
(void) dup2(i, 1);
(void) dup2(i, 2);
i = open("/dev/tty", 2);
if (i >= 0) {
(void) ioctl(i, TIOCNOTTY, (char *)NULL);
(void) close(i);
}
openlog("rpc.ypxfrd", LOG_PID, LOG_DAEMON);
#endif
sock = RPC_ANYSOCK;
(void) pmap_unset(YPXFRD_FREEBSD_PROG, YPXFRD_FREEBSD_VERS);
}
if ((_rpcfdtype == 0) || (_rpcfdtype == SOCK_DGRAM)) {
transp = svcudp_create(sock);
if (transp == NULL) {
_msgout("cannot create udp service.");
exit(1);
}
if (!_rpcpmstart)
proto = IPPROTO_UDP;
if (!svc_register(transp, YPXFRD_FREEBSD_PROG, YPXFRD_FREEBSD_VERS, ypxfrd_freebsd_prog_1, proto)) {
_msgout("unable to register (YPXFRD_FREEBSD_PROG, YPXFRD_FREEBSD_VERS, udp).");
exit(1);
}
}
if ((_rpcfdtype == 0) || (_rpcfdtype == SOCK_STREAM)) {
transp = svctcp_create(sock, 0, 0);
if (transp == NULL) {
_msgout("cannot create tcp service.");
exit(1);
}
if (!_rpcpmstart)
proto = IPPROTO_TCP;
if (!svc_register(transp, YPXFRD_FREEBSD_PROG, YPXFRD_FREEBSD_VERS, ypxfrd_freebsd_prog_1, proto)) {
_msgout("unable to register (YPXFRD_FREEBSD_PROG, YPXFRD_FREEBSD_VERS, tcp).");
exit(1);
}
}
if (transp == (SVCXPRT *)NULL) {
_msgout("could not create a handle");
exit(1);
}
if (_rpcpmstart) {
(void) signal(SIGALRM, (SIG_PF) closedown);
(void) alarm(_RPCSVC_CLOSEDOWN/2);
}
(void) signal(SIGPIPE, SIG_IGN);
(void) signal(SIGCHLD, (SIG_PF) reaper);
(void) signal(SIGTERM, (SIG_PF) reaper);
(void) signal(SIGINT, (SIG_PF) reaper);
(void) signal(SIGHUP, (SIG_PF) reaper);
ypxfrd_svc_run();
_msgout("svc_run returned");
exit(1);
/* NOTREACHED */
}