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.
|
|
|
|
*/
|
|
|
|
|
2003-05-03 21:06:42 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
1997-10-29 07:25:05 +00:00
|
|
|
|
1995-12-16 20:54:17 +00:00
|
|
|
/*
|
|
|
|
* ypserv startup function.
|
|
|
|
* We need out own main() since we have to do some additional work
|
|
|
|
* that rpcgen won't do for us. Most of this file was generated using
|
|
|
|
* rpcgen.new, and later modified.
|
|
|
|
*/
|
|
|
|
|
2009-12-13 15:19:01 +00:00
|
|
|
#include <sys/types.h>
|
2011-10-25 10:33:26 +00:00
|
|
|
#include <sys/mman.h>
|
2009-12-13 15:19:01 +00:00
|
|
|
#include <sys/queue.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/wait.h>
|
1995-12-16 20:54:17 +00:00
|
|
|
#include "yp.h"
|
1997-10-29 07:25:05 +00:00
|
|
|
#include <err.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <memory.h>
|
1995-12-16 20:54:17 +00:00
|
|
|
#include <stdio.h>
|
1997-10-29 07:25:05 +00:00
|
|
|
#include <signal.h>
|
2009-12-13 15:19:01 +00:00
|
|
|
#include <stdarg.h>
|
1995-12-16 20:54:17 +00:00
|
|
|
#include <stdlib.h> /* getenv, exit */
|
|
|
|
#include <string.h> /* strcmp */
|
1997-10-29 07:25:05 +00:00
|
|
|
#include <syslog.h>
|
|
|
|
#include <unistd.h>
|
1995-12-16 20:54:17 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
#include <sysent.h> /* getdtablesize, open */
|
|
|
|
#endif /* __cplusplus */
|
|
|
|
#include <netinet/in.h>
|
2009-12-13 15:19:01 +00:00
|
|
|
#include <netdb.h>
|
1995-12-16 20:54:17 +00:00
|
|
|
#include "yp_extern.h"
|
2009-12-13 15:19:01 +00:00
|
|
|
#include <netconfig.h>
|
1995-12-16 20:54:17 +00:00
|
|
|
#include <rpc/rpc.h>
|
2009-12-13 15:19:01 +00:00
|
|
|
#include <rpc/rpc_com.h>
|
1995-12-16 20:54:17 +00:00
|
|
|
|
|
|
|
#ifndef SIG_PF
|
|
|
|
#define SIG_PF void(*)(int)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define _RPCSVC_CLOSEDOWN 120
|
|
|
|
int _rpcpmstart; /* Started by a port monitor ? */
|
|
|
|
static int _rpcfdtype;
|
|
|
|
/* Whether Stream or Datagram ? */
|
2009-12-13 15:19:01 +00:00
|
|
|
static int _rpcaf;
|
|
|
|
static int _rpcfd;
|
|
|
|
|
1995-12-16 20:54:17 +00:00
|
|
|
/* States a server can be in wrt request */
|
|
|
|
|
|
|
|
#define _IDLE 0
|
|
|
|
#define _SERVED 1
|
|
|
|
#define _SERVING 2
|
|
|
|
|
2009-12-13 15:19:01 +00:00
|
|
|
extern void ypprog_1(struct svc_req *, SVCXPRT *);
|
|
|
|
extern void ypprog_2(struct svc_req *, SVCXPRT *);
|
2002-02-06 13:30:31 +00:00
|
|
|
extern int _rpc_dtablesize(void);
|
1995-12-16 20:54:17 +00:00
|
|
|
extern int _rpcsvcstate; /* Set when a request is serviced */
|
|
|
|
char *progname = "ypserv";
|
|
|
|
char *yp_dir = _PATH_YP;
|
Fix a bug in the database handle caching. This has to do with the way the
underlying database code works. When dealing with first/next queries, you
have the notion of a database 'cursor,' which is essentially a file pointer
for the database. To select the first entry, you do a fetch with the
R_FIRST flag set, then you can use the R_NEXT flag to enumerate the other
entries in the database. Unfortunately, doing a direct fetch with no flag
does _not_ set the 'cursor,' so you can't do a direct fetch and then
enumerate the table from there.
The bug is that cached handles generated as the result of a YPPROC_MATCH
were being treated as though they were the same as handles generated by
a YPPROC_FIRST, which is not the case. The manifestation is that if you
do a 'ypmatch first-key-in-map map' followed by a yp_first()/yp_next()
pair, the yp_first() and yp_next() both return the first key in the
table, which makes the entry appear to be duplicated.
A couple smaller things since I'm here:
- yp_main.c and yp_error.c both have a global 'int debug' in them.
For some reason, our cc/ld doesn't flag this as a multiply defined
symbol even though it should. Removed the declaration from yp_main.c;
we want the one in yp_error.c.
- The Makefile wasn't installing ypinit in the right place.
1998-02-11 19:15:32 +00:00
|
|
|
/*int debug = 0;*/
|
1995-12-16 20:54:17 +00:00
|
|
|
int do_dns = 0;
|
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
|
|
|
int resfd;
|
1995-12-16 20:54:17 +00:00
|
|
|
|
2009-12-13 15:19:01 +00:00
|
|
|
struct socklistent {
|
|
|
|
int sle_sock;
|
|
|
|
struct sockaddr_storage sle_ss;
|
|
|
|
SLIST_ENTRY(socklistent) sle_next;
|
2008-02-03 17:39:37 +00:00
|
|
|
};
|
2009-12-13 15:19:01 +00:00
|
|
|
static SLIST_HEAD(, socklistent) sle_head =
|
2009-12-28 22:56:30 +00:00
|
|
|
SLIST_HEAD_INITIALIZER(sle_head);
|
2009-12-13 15:19:01 +00:00
|
|
|
|
|
|
|
struct bindaddrlistent {
|
|
|
|
const char *ble_hostname;
|
|
|
|
SLIST_ENTRY(bindaddrlistent) ble_next;
|
2008-02-03 17:39:37 +00:00
|
|
|
};
|
2009-12-13 15:19:01 +00:00
|
|
|
static SLIST_HEAD(, bindaddrlistent) ble_head =
|
2009-12-28 22:56:30 +00:00
|
|
|
SLIST_HEAD_INITIALIZER(ble_head);
|
2009-12-13 15:19:01 +00:00
|
|
|
|
|
|
|
static char *servname = "0";
|
2008-02-03 17:39:37 +00:00
|
|
|
|
1995-12-16 20:54:17 +00:00
|
|
|
static
|
2009-12-13 15:19:01 +00:00
|
|
|
void _msgout(char* msg, ...)
|
1995-12-16 20:54:17 +00:00
|
|
|
{
|
2009-12-13 15:19:01 +00:00
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, msg);
|
1995-12-16 20:54:17 +00:00
|
|
|
if (debug) {
|
|
|
|
if (_rpcpmstart)
|
2009-12-13 15:19:01 +00:00
|
|
|
vsyslog(LOG_ERR, msg, ap);
|
1995-12-16 20:54:17 +00:00
|
|
|
else
|
2009-12-13 15:19:01 +00:00
|
|
|
vwarnx(msg, ap);
|
1995-12-16 20:54:17 +00:00
|
|
|
} else
|
2009-12-13 15:19:01 +00:00
|
|
|
vsyslog(LOG_ERR, msg, ap);
|
|
|
|
va_end(ap);
|
1995-12-16 20:54:17 +00:00
|
|
|
}
|
|
|
|
|
1999-04-29 20:24:00 +00:00
|
|
|
pid_t yp_pid;
|
|
|
|
|
1996-12-03 02:37:39 +00:00
|
|
|
static void
|
2002-02-06 15:26:07 +00:00
|
|
|
yp_svc_run(void)
|
1996-12-03 02:37:39 +00:00
|
|
|
{
|
|
|
|
#ifdef FD_SETSIZE
|
|
|
|
fd_set readfds;
|
|
|
|
#else
|
|
|
|
int readfds;
|
|
|
|
#endif /* def FD_SETSIZE */
|
|
|
|
int fd_setsize = _rpc_dtablesize();
|
1996-12-30 18:51:59 +00:00
|
|
|
struct timeval timeout;
|
1996-12-03 02:37:39 +00:00
|
|
|
|
|
|
|
/* Establish the identity of the parent ypserv process. */
|
1999-04-29 20:24:00 +00:00
|
|
|
yp_pid = getpid();
|
1996-12-03 02:37:39 +00:00
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
#ifdef FD_SETSIZE
|
|
|
|
readfds = svc_fdset;
|
|
|
|
#else
|
|
|
|
readfds = svc_fds;
|
|
|
|
#endif /* def FD_SETSIZE */
|
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
|
|
|
|
1996-12-25 18:10:35 +00:00
|
|
|
FD_SET(resfd, &readfds);
|
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
|
|
|
|
1996-12-30 18:51:59 +00:00
|
|
|
timeout.tv_sec = RESOLVER_TIMEOUT;
|
|
|
|
timeout.tv_usec = 0;
|
1996-12-03 02:37:39 +00:00
|
|
|
switch (select(fd_setsize, &readfds, NULL, NULL,
|
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
|
|
|
&timeout)) {
|
1996-12-03 02:37:39 +00:00
|
|
|
case -1:
|
|
|
|
if (errno == EINTR) {
|
|
|
|
continue;
|
|
|
|
}
|
1997-10-29 07:25:05 +00:00
|
|
|
warn("svc_run: - select failed");
|
1996-12-03 02:37:39 +00:00
|
|
|
return;
|
|
|
|
case 0:
|
1999-04-29 20:24:00 +00:00
|
|
|
if (getpid() == yp_pid)
|
|
|
|
yp_prune_dnsq();
|
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
|
|
|
break;
|
1996-12-03 02:37:39 +00:00
|
|
|
default:
|
1999-04-29 20:24:00 +00:00
|
|
|
if (getpid() == yp_pid) {
|
|
|
|
if (FD_ISSET(resfd, &readfds)) {
|
|
|
|
yp_run_dnsq();
|
|
|
|
FD_CLR(resfd, &readfds);
|
|
|
|
}
|
|
|
|
svc_getreqset(&readfds);
|
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
|
|
|
}
|
1996-12-03 02:37:39 +00:00
|
|
|
}
|
1999-04-29 20:24:00 +00:00
|
|
|
if (yp_pid != getpid())
|
1999-02-10 16:16:14 +00:00
|
|
|
_exit(0);
|
1996-12-03 02:37:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-02-06 15:26:07 +00:00
|
|
|
static void
|
|
|
|
unregister(void)
|
1995-12-16 20:54:17 +00:00
|
|
|
{
|
2009-12-13 15:19:01 +00:00
|
|
|
(void)svc_unreg(YPPROG, YPVERS);
|
|
|
|
(void)svc_unreg(YPPROG, YPOLDVERS);
|
1995-12-16 20:54:17 +00:00
|
|
|
}
|
|
|
|
|
2002-02-06 15:26:07 +00:00
|
|
|
static void
|
|
|
|
reaper(int sig)
|
1995-12-16 20:54:17 +00:00
|
|
|
{
|
1998-06-04 15:11:32 +00:00
|
|
|
int status;
|
|
|
|
int saved_errno;
|
|
|
|
|
|
|
|
saved_errno = errno;
|
1995-12-16 20:54:17 +00:00
|
|
|
|
1996-02-24 22:01:48 +00:00
|
|
|
if (sig == SIGHUP) {
|
|
|
|
load_securenets();
|
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
|
|
|
|
yp_flush_all();
|
|
|
|
#endif
|
1998-06-04 15:11:32 +00:00
|
|
|
errno = saved_errno;
|
1996-02-24 22:01:48 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
1995-12-16 20:54:17 +00:00
|
|
|
if (sig == SIGCHLD) {
|
|
|
|
while (wait3(&status, WNOHANG, NULL) > 0)
|
|
|
|
children--;
|
|
|
|
} else {
|
|
|
|
unregister();
|
|
|
|
exit(0);
|
|
|
|
}
|
1998-06-04 15:11:32 +00:00
|
|
|
errno = saved_errno;
|
|
|
|
return;
|
1995-12-16 20:54:17 +00:00
|
|
|
}
|
|
|
|
|
2002-02-06 15:26:07 +00:00
|
|
|
static void
|
|
|
|
usage(void)
|
1995-12-16 20:54:17 +00:00
|
|
|
{
|
2011-06-20 15:22:47 +00:00
|
|
|
fprintf(stderr, "usage: ypserv [-h addr] [-d] [-n] [-p path] [-P port]\n");
|
1995-12-16 20:54:17 +00:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
closedown(int sig)
|
|
|
|
{
|
|
|
|
if (_rpcsvcstate == _IDLE) {
|
|
|
|
extern fd_set svc_fdset;
|
|
|
|
static int size;
|
|
|
|
int i, openfd;
|
|
|
|
|
|
|
|
if (_rpcfdtype == SOCK_DGRAM) {
|
|
|
|
unregister();
|
|
|
|
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) {
|
|
|
|
unregister();
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (_rpcsvcstate == _SERVED)
|
|
|
|
_rpcsvcstate = _IDLE;
|
|
|
|
|
|
|
|
(void) signal(SIGALRM, (SIG_PF) closedown);
|
|
|
|
(void) alarm(_RPCSVC_CLOSEDOWN/2);
|
|
|
|
}
|
|
|
|
|
2009-12-13 15:19:01 +00:00
|
|
|
static int
|
|
|
|
create_service(const int sock, const struct netconfig *nconf,
|
|
|
|
const struct __rpc_sockinfo *si)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
SVCXPRT *transp;
|
|
|
|
struct addrinfo hints, *res, *res0;
|
|
|
|
struct socklistent *slep;
|
|
|
|
struct bindaddrlistent *blep;
|
|
|
|
struct netbuf svcaddr;
|
|
|
|
|
|
|
|
SLIST_INIT(&sle_head);
|
|
|
|
memset(&hints, 0, sizeof(hints));
|
|
|
|
memset(&svcaddr, 0, sizeof(svcaddr));
|
|
|
|
|
|
|
|
hints.ai_family = si->si_af;
|
|
|
|
hints.ai_socktype = si->si_socktype;
|
|
|
|
hints.ai_protocol = si->si_proto;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Build socketlist from bindaddrlist.
|
|
|
|
*/
|
|
|
|
if (sock == RPC_ANYFD) {
|
|
|
|
SLIST_FOREACH(blep, &ble_head, ble_next) {
|
|
|
|
if (blep->ble_hostname == NULL)
|
|
|
|
hints.ai_flags = AI_PASSIVE;
|
|
|
|
else
|
|
|
|
hints.ai_flags = 0;
|
|
|
|
error = getaddrinfo(blep->ble_hostname, servname,
|
|
|
|
&hints, &res0);
|
|
|
|
if (error) {
|
|
|
|
_msgout("getaddrinfo(): %s",
|
|
|
|
gai_strerror(error));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
for (res = res0; res; res = res->ai_next) {
|
|
|
|
int s;
|
|
|
|
|
|
|
|
s = __rpc_nconf2fd(nconf);
|
|
|
|
if (s < 0) {
|
|
|
|
if (errno == EPROTONOSUPPORT)
|
|
|
|
_msgout("unsupported"
|
|
|
|
" transport: %s",
|
|
|
|
nconf->nc_netid);
|
|
|
|
else
|
|
|
|
_msgout("cannot create"
|
|
|
|
" %s socket: %s",
|
|
|
|
nconf->nc_netid,
|
|
|
|
strerror(errno));
|
|
|
|
freeaddrinfo(res0);
|
|
|
|
return -1;
|
|
|
|
}
|
2010-01-20 09:29:07 +00:00
|
|
|
if (bindresvport_sa(s, res->ai_addr) == -1) {
|
|
|
|
if ((errno != EPERM) ||
|
|
|
|
(bind(s, res->ai_addr,
|
|
|
|
res->ai_addrlen) == -1)) {
|
|
|
|
_msgout("cannot bind "
|
|
|
|
"%s socket: %s",
|
|
|
|
nconf->nc_netid,
|
|
|
|
strerror(errno));
|
|
|
|
freeaddrinfo(res0);
|
|
|
|
close(sock);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-12-13 15:19:01 +00:00
|
|
|
}
|
|
|
|
if (nconf->nc_semantics != NC_TPI_CLTS)
|
|
|
|
listen(s, SOMAXCONN);
|
|
|
|
|
|
|
|
slep = malloc(sizeof(*slep));
|
|
|
|
if (slep == NULL) {
|
|
|
|
_msgout("malloc failed: %s",
|
|
|
|
strerror(errno));
|
|
|
|
freeaddrinfo(res0);
|
|
|
|
close(s);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
memset(slep, 0, sizeof(*slep));
|
|
|
|
memcpy(&slep->sle_ss,
|
|
|
|
(struct sockaddr *)(res->ai_addr),
|
|
|
|
sizeof(res->ai_addr));
|
|
|
|
slep->sle_sock = s;
|
|
|
|
SLIST_INSERT_HEAD(&sle_head, slep, sle_next);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If servname == "0", redefine it by using
|
|
|
|
* the bound socket.
|
|
|
|
*/
|
|
|
|
if (strncmp("0", servname, 1) == 0) {
|
|
|
|
struct sockaddr *sap;
|
|
|
|
socklen_t slen;
|
2012-01-17 20:39:33 +00:00
|
|
|
char *sname;
|
2009-12-13 15:19:01 +00:00
|
|
|
|
|
|
|
sname = malloc(NI_MAXSERV);
|
|
|
|
if (sname == NULL) {
|
|
|
|
_msgout("malloc(): %s",
|
|
|
|
strerror(errno));
|
|
|
|
freeaddrinfo(res0);
|
|
|
|
close(s);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
memset(sname, 0, NI_MAXSERV);
|
|
|
|
|
|
|
|
sap = (struct sockaddr *)&slep->sle_ss;
|
|
|
|
slen = sizeof(*sap);
|
|
|
|
error = getsockname(s, sap, &slen);
|
|
|
|
if (error) {
|
|
|
|
_msgout("getsockname(): %s",
|
|
|
|
strerror(errno));
|
|
|
|
freeaddrinfo(res0);
|
|
|
|
close(s);
|
2011-12-21 20:27:41 +00:00
|
|
|
free(sname);
|
2009-12-13 15:19:01 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
error = getnameinfo(sap, slen,
|
|
|
|
NULL, 0,
|
|
|
|
sname, NI_MAXSERV,
|
|
|
|
NI_NUMERICHOST | NI_NUMERICSERV);
|
|
|
|
if (error) {
|
|
|
|
_msgout("getnameinfo(): %s",
|
|
|
|
strerror(errno));
|
|
|
|
freeaddrinfo(res0);
|
|
|
|
close(s);
|
2011-12-21 20:27:41 +00:00
|
|
|
free(sname);
|
2009-12-13 15:19:01 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
servname = sname;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
freeaddrinfo(res0);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
slep = malloc(sizeof(*slep));
|
|
|
|
if (slep == NULL) {
|
|
|
|
_msgout("malloc failed: %s", strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
memset(slep, 0, sizeof(*slep));
|
|
|
|
slep->sle_sock = sock;
|
|
|
|
SLIST_INSERT_HEAD(&sle_head, slep, sle_next);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Traverse socketlist and create rpc service handles for each socket.
|
|
|
|
*/
|
|
|
|
SLIST_FOREACH(slep, &sle_head, sle_next) {
|
|
|
|
if (nconf->nc_semantics == NC_TPI_CLTS)
|
|
|
|
transp = svc_dg_create(slep->sle_sock, 0, 0);
|
|
|
|
else
|
|
|
|
transp = svc_vc_create(slep->sle_sock, RPC_MAXDATASIZE,
|
|
|
|
RPC_MAXDATASIZE);
|
|
|
|
if (transp == NULL) {
|
|
|
|
_msgout("unable to create service: %s",
|
|
|
|
nconf->nc_netid);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!svc_reg(transp, YPPROG, YPOLDVERS, ypprog_1, NULL)) {
|
|
|
|
svc_destroy(transp);
|
|
|
|
close(slep->sle_sock);
|
|
|
|
_msgout("unable to register (YPPROG, YPOLDVERS, %s):"
|
|
|
|
" %s", nconf->nc_netid, strerror(errno));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!svc_reg(transp, YPPROG, YPVERS, ypprog_2, NULL)) {
|
|
|
|
svc_destroy(transp);
|
|
|
|
close(slep->sle_sock);
|
|
|
|
_msgout("unable to register (YPPROG, YPVERS, %s): %s",
|
|
|
|
nconf->nc_netid, strerror(errno));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while(!(SLIST_EMPTY(&sle_head)))
|
|
|
|
SLIST_REMOVE_HEAD(&sle_head, sle_next);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Register RPC service to rpcbind by using AI_PASSIVE address.
|
|
|
|
*/
|
|
|
|
hints.ai_flags = AI_PASSIVE;
|
|
|
|
error = getaddrinfo(NULL, servname, &hints, &res0);
|
|
|
|
if (error) {
|
|
|
|
_msgout("getaddrinfo(): %s", gai_strerror(error));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
svcaddr.buf = res0->ai_addr;
|
|
|
|
svcaddr.len = res0->ai_addrlen;
|
|
|
|
|
|
|
|
if (si->si_af == AF_INET) {
|
|
|
|
/* XXX: ignore error intentionally */
|
|
|
|
rpcb_set(YPPROG, YPOLDVERS, nconf, &svcaddr);
|
|
|
|
}
|
|
|
|
/* XXX: ignore error intentionally */
|
|
|
|
rpcb_set(YPPROG, YPVERS, nconf, &svcaddr);
|
|
|
|
freeaddrinfo(res0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
1997-10-29 07:25:05 +00:00
|
|
|
int
|
2002-02-06 15:26:07 +00:00
|
|
|
main(int argc, char *argv[])
|
1995-12-16 20:54:17 +00:00
|
|
|
{
|
|
|
|
int ch;
|
2009-12-13 15:19:01 +00:00
|
|
|
int error;
|
2010-01-20 16:50:13 +00:00
|
|
|
int ntrans;
|
2009-12-13 15:19:01 +00:00
|
|
|
|
|
|
|
void *nc_handle;
|
|
|
|
struct netconfig *nconf;
|
|
|
|
struct __rpc_sockinfo si;
|
|
|
|
struct bindaddrlistent *blep;
|
|
|
|
|
|
|
|
memset(&si, 0, sizeof(si));
|
|
|
|
SLIST_INIT(&ble_head);
|
1995-12-16 20:54:17 +00:00
|
|
|
|
2009-12-13 15:19:01 +00:00
|
|
|
while ((ch = getopt(argc, argv, "dh:np:P:")) != -1) {
|
2002-02-06 13:30:31 +00:00
|
|
|
switch (ch) {
|
1995-12-16 20:54:17 +00:00
|
|
|
case 'd':
|
1995-12-23 21:35:35 +00:00
|
|
|
debug = ypdb_debug = 1;
|
1995-12-16 20:54:17 +00:00
|
|
|
break;
|
2009-12-13 15:19:01 +00:00
|
|
|
case 'h':
|
|
|
|
blep = malloc(sizeof(*blep));
|
|
|
|
if (blep == NULL)
|
|
|
|
err(1, "malloc() failed: -h %s", optarg);
|
|
|
|
blep->ble_hostname = optarg;
|
|
|
|
SLIST_INSERT_HEAD(&ble_head, blep, ble_next);
|
|
|
|
break;
|
1995-12-16 20:54:17 +00:00
|
|
|
case 'n':
|
|
|
|
do_dns = 1;
|
|
|
|
break;
|
|
|
|
case 'p':
|
|
|
|
yp_dir = optarg;
|
|
|
|
break;
|
2008-02-03 17:39:37 +00:00
|
|
|
case 'P':
|
2009-12-13 15:19:01 +00:00
|
|
|
servname = optarg;
|
2008-02-03 17:39:37 +00:00
|
|
|
break;
|
1995-12-16 20:54:17 +00:00
|
|
|
default:
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
}
|
2009-12-13 15:19:01 +00:00
|
|
|
/*
|
|
|
|
* Add "anyaddr" entry if no -h is specified.
|
|
|
|
*/
|
|
|
|
if (SLIST_EMPTY(&ble_head)) {
|
|
|
|
blep = malloc(sizeof(*blep));
|
|
|
|
if (blep == NULL)
|
|
|
|
err(1, "malloc() failed");
|
|
|
|
memset(blep, 0, sizeof(*blep));
|
|
|
|
SLIST_INSERT_HEAD(&ble_head, blep, ble_next);
|
|
|
|
}
|
1995-12-16 20:54:17 +00:00
|
|
|
|
1996-02-24 22:01:48 +00:00
|
|
|
load_securenets();
|
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_init_resolver();
|
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
|
|
|
|
yp_init_dbs();
|
|
|
|
#endif
|
2009-12-13 15:19:01 +00:00
|
|
|
nc_handle = setnetconfig();
|
|
|
|
if (nc_handle == NULL)
|
|
|
|
err(1, "cannot read %s", NETCONFIG);
|
|
|
|
if (__rpc_fd2sockinfo(0, &si) != 0) {
|
|
|
|
/* invoked from inetd */
|
1995-12-16 20:54:17 +00:00
|
|
|
_rpcpmstart = 1;
|
2009-12-13 15:19:01 +00:00
|
|
|
_rpcfdtype = si.si_socktype;
|
|
|
|
_rpcaf = si.si_af;
|
|
|
|
_rpcfd = 0;
|
1997-10-29 07:25:05 +00:00
|
|
|
openlog("ypserv", LOG_PID, LOG_DAEMON);
|
1995-12-16 20:54:17 +00:00
|
|
|
} else {
|
2009-12-13 15:19:01 +00:00
|
|
|
/* standalone mode */
|
1995-12-16 20:54:17 +00:00
|
|
|
if (!debug) {
|
|
|
|
if (daemon(0,0)) {
|
1996-05-31 16:01:51 +00:00
|
|
|
err(1,"cannot fork");
|
1995-12-16 20:54:17 +00:00
|
|
|
}
|
1997-10-29 07:25:05 +00:00
|
|
|
openlog("ypserv", LOG_PID, LOG_DAEMON);
|
1995-12-16 20:54:17 +00:00
|
|
|
}
|
2009-12-13 15:19:01 +00:00
|
|
|
_rpcpmstart = 0;
|
|
|
|
_rpcaf = AF_INET;
|
|
|
|
_rpcfd = RPC_ANYFD;
|
|
|
|
unregister();
|
1995-12-16 20:54:17 +00:00
|
|
|
}
|
|
|
|
|
2011-10-25 10:33:26 +00:00
|
|
|
if (madvise(NULL, 0, MADV_PROTECT) != 0)
|
|
|
|
_msgout("madvise(): %s", strerror(errno));
|
|
|
|
|
2008-02-03 17:39:37 +00:00
|
|
|
/*
|
2009-12-13 15:19:01 +00:00
|
|
|
* Create RPC service for each transport.
|
2008-02-03 17:39:37 +00:00
|
|
|
*/
|
2010-01-20 16:50:13 +00:00
|
|
|
ntrans = 0;
|
2009-12-13 15:19:01 +00:00
|
|
|
while((nconf = getnetconfig(nc_handle))) {
|
|
|
|
if ((nconf->nc_flag & NC_VISIBLE)) {
|
|
|
|
if (__rpc_nconf2sockinfo(nconf, &si) == 0) {
|
2010-01-20 16:50:13 +00:00
|
|
|
_msgout("cannot get information for %s. "
|
|
|
|
"Ignored.", nconf->nc_netid);
|
|
|
|
continue;
|
2009-12-13 15:19:01 +00:00
|
|
|
}
|
|
|
|
if (_rpcpmstart) {
|
|
|
|
if (si.si_socktype != _rpcfdtype ||
|
|
|
|
si.si_af != _rpcaf)
|
|
|
|
continue;
|
|
|
|
} else if (si.si_af != _rpcaf)
|
|
|
|
continue;
|
|
|
|
error = create_service(_rpcfd, nconf, &si);
|
|
|
|
if (error) {
|
|
|
|
endnetconfig(nc_handle);
|
|
|
|
exit(1);
|
|
|
|
}
|
2010-01-20 16:50:13 +00:00
|
|
|
ntrans++;
|
1995-12-16 20:54:17 +00:00
|
|
|
}
|
|
|
|
}
|
2009-12-13 15:19:01 +00:00
|
|
|
endnetconfig(nc_handle);
|
|
|
|
while(!(SLIST_EMPTY(&ble_head)))
|
|
|
|
SLIST_REMOVE_HEAD(&ble_head, ble_next);
|
2010-01-20 16:50:13 +00:00
|
|
|
if (ntrans == 0) {
|
|
|
|
_msgout("no transport is available. Aborted.");
|
|
|
|
exit(1);
|
|
|
|
}
|
1995-12-16 20:54:17 +00:00
|
|
|
if (_rpcpmstart) {
|
|
|
|
(void) signal(SIGALRM, (SIG_PF) closedown);
|
|
|
|
(void) alarm(_RPCSVC_CLOSEDOWN/2);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Make sure SIGPIPE doesn't blow us away while servicing TCP
|
|
|
|
* connections.
|
|
|
|
*/
|
|
|
|
(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);
|
|
|
|
yp_svc_run();
|
|
|
|
_msgout("svc_run returned");
|
|
|
|
exit(1);
|
|
|
|
/* NOTREACHED */
|
|
|
|
}
|