xref: /freebsd/usr.sbin/ypserv/yp_server.c (revision 1e413cf93298b5b97441a21d9a50fdcd0ee9945e)
1 /*
2  * Copyright (c) 1995
3  *	Bill Paul <wpaul@ctr.columbia.edu>.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *	This product includes software developed by Bill Paul.
16  * 4. Neither the name of the author nor the names of any co-contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  */
33 
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD$");
36 
37 #include "yp.h"
38 #include "yp_extern.h"
39 #include <dirent.h>
40 #include <errno.h>
41 #include <stdlib.h>
42 #include <sys/stat.h>
43 #include <sys/param.h>
44 #include <sys/types.h>
45 #include <sys/socket.h>
46 #include <netinet/in.h>
47 #include <arpa/inet.h>
48 #include <rpc/rpc.h>
49 
50 int children = 0;
51 
52 #define	MASTER_STRING	"YP_MASTER_NAME"
53 #define	MASTER_SZ	sizeof(MASTER_STRING) - 1
54 #define	ORDER_STRING	"YP_LAST_MODIFIED"
55 #define	ORDER_SZ	sizeof(ORDER_STRING) - 1
56 
57 static pid_t
58 yp_fork(void)
59 {
60 	if (yp_pid != getpid()) {
61 		yp_error("child %d trying to fork!", getpid());
62 		errno = EEXIST;
63 		return(-1);
64 	}
65 
66 	return(fork());
67 }
68 
69 /*
70  * NIS v2 support. This is where most of the action happens.
71  */
72 
73 void *
74 ypproc_null_2_svc(void *argp, struct svc_req *rqstp)
75 {
76 	static char * result;
77 	static char rval = 0;
78 
79 #ifdef DB_CACHE
80 	if (yp_access(NULL, NULL, (struct svc_req *)rqstp))
81 #else
82 	if (yp_access(NULL, (struct svc_req *)rqstp))
83 #endif
84 		return(NULL);
85 
86 	result = &rval;
87 
88 	return((void *) &result);
89 }
90 
91 bool_t *
92 ypproc_domain_2_svc(domainname *argp, struct svc_req *rqstp)
93 {
94 	static bool_t  result;
95 
96 #ifdef DB_CACHE
97 	if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) {
98 #else
99 	if (yp_access(NULL, (struct svc_req *)rqstp)) {
100 #endif
101 		result = FALSE;
102 		return (&result);
103 	}
104 
105 	if (argp == NULL || yp_validdomain(*argp))
106 		result = FALSE;
107 	else
108 		result = TRUE;
109 
110 	return (&result);
111 }
112 
113 bool_t *
114 ypproc_domain_nonack_2_svc(domainname *argp, struct svc_req *rqstp)
115 {
116 	static bool_t  result;
117 
118 #ifdef DB_CACHE
119 	if (yp_access(NULL, NULL, (struct svc_req *)rqstp))
120 #else
121 	if (yp_access(NULL, (struct svc_req *)rqstp))
122 #endif
123 		return (NULL);
124 
125 	if (argp == NULL || yp_validdomain(*argp))
126 		return (NULL);
127 	else
128 		result = TRUE;
129 
130 	return (&result);
131 }
132 
133 ypresp_val *
134 ypproc_match_2_svc(ypreq_key *argp, struct svc_req *rqstp)
135 {
136 	static ypresp_val  result;
137 
138 	result.val.valdat_val = "";
139 	result.val.valdat_len = 0;
140 
141 #ifdef DB_CACHE
142 	if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
143 #else
144 	if (yp_access(argp->map, (struct svc_req *)rqstp)) {
145 #endif
146 		result.stat = YP_YPERR;
147 		return (&result);
148 	}
149 
150 	if (argp->domain == NULL || argp->map == NULL) {
151 		result.stat = YP_BADARGS;
152 		return (&result);
153 	}
154 
155 	if (yp_select_map(argp->map, argp->domain, NULL, 1) != YP_TRUE) {
156 		result.stat = yp_errno;
157 		return(&result);
158 	}
159 
160 	result.stat = yp_getbykey(&argp->key, &result.val);
161 
162 	/*
163 	 * Do DNS lookups for hosts maps if database lookup failed.
164 	 */
165 
166 #ifdef DB_CACHE
167 	if (do_dns && result.stat != YP_TRUE &&
168 	    (yp_testflag(argp->map, argp->domain, YP_INTERDOMAIN) ||
169 	    (strstr(argp->map, "hosts") || strstr(argp->map, "ipnodes")))) {
170 #else
171 	if (do_dns && result.stat != YP_TRUE &&
172 	    (strstr(argp->map, "hosts") || strstr(argp->map, "ipnodes"))) {
173 #endif
174 		char			nbuf[YPMAXRECORD];
175 
176 		/* NUL terminate! NUL terminate!! NUL TERMINATE!!! */
177 		bcopy(argp->key.keydat_val, nbuf, argp->key.keydat_len);
178 		nbuf[argp->key.keydat_len] = '\0';
179 
180 		if (debug)
181 			yp_error("doing DNS lookup of %s", nbuf);
182 
183 		if (!strcmp(argp->map, "hosts.byname"))
184 			result.stat = yp_async_lookup_name(rqstp, nbuf,
185 			    AF_INET);
186 		else if (!strcmp(argp->map, "hosts.byaddr"))
187 			result.stat = yp_async_lookup_addr(rqstp, nbuf,
188 			    AF_INET);
189 		else if (!strcmp(argp->map, "ipnodes.byname"))
190 			result.stat = yp_async_lookup_name(rqstp, nbuf,
191 			    AF_INET6);
192 		else if (!strcmp(argp->map, "ipnodes.byaddr"))
193 			result.stat = yp_async_lookup_addr(rqstp, nbuf,
194 			    AF_INET6);
195 
196 		if (result.stat == YP_TRUE)
197 			return(NULL);
198 	}
199 
200 	return (&result);
201 }
202 
203 ypresp_key_val *
204 ypproc_first_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
205 {
206 	static ypresp_key_val  result;
207 
208 	result.val.valdat_val = result.key.keydat_val = "";
209 	result.val.valdat_len = result.key.keydat_len = 0;
210 
211 #ifdef DB_CACHE
212 	if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
213 #else
214 	if (yp_access(argp->map, (struct svc_req *)rqstp)) {
215 #endif
216 		result.stat = YP_YPERR;
217 		return (&result);
218 	}
219 
220 	if (argp->domain == NULL) {
221 		result.stat = YP_BADARGS;
222 		return (&result);
223 	}
224 
225 	if (yp_select_map(argp->map, argp->domain, NULL, 0) != YP_TRUE) {
226 		result.stat = yp_errno;
227 		return(&result);
228 	}
229 
230 	result.stat = yp_firstbykey(&result.key, &result.val);
231 
232 	return (&result);
233 }
234 
235 ypresp_key_val *
236 ypproc_next_2_svc(ypreq_key *argp, struct svc_req *rqstp)
237 {
238 	static ypresp_key_val  result;
239 
240 	result.val.valdat_val = result.key.keydat_val = "";
241 	result.val.valdat_len = result.key.keydat_len = 0;
242 
243 #ifdef DB_CACHE
244 	if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
245 #else
246 	if (yp_access(argp->map, (struct svc_req *)rqstp)) {
247 #endif
248 		result.stat = YP_YPERR;
249 		return (&result);
250 	}
251 
252 	if (argp->domain == NULL || argp->map == NULL) {
253 		result.stat = YP_BADARGS;
254 		return (&result);
255 	}
256 
257 	if (yp_select_map(argp->map, argp->domain, &argp->key, 0) != YP_TRUE) {
258 		result.stat = yp_errno;
259 		return(&result);
260 	}
261 
262 	result.key.keydat_len = argp->key.keydat_len;
263 	result.key.keydat_val = argp->key.keydat_val;
264 
265 	result.stat = yp_nextbykey(&result.key, &result.val);
266 
267 	return (&result);
268 }
269 
270 static void
271 ypxfr_callback(ypxfrstat rval, struct sockaddr_in *addr, unsigned int transid,
272     unsigned int prognum, unsigned long port)
273 {
274 	CLIENT *clnt;
275 	int sock = RPC_ANYSOCK;
276 	struct timeval timeout;
277 	yppushresp_xfr ypxfr_resp;
278 	struct rpc_err err;
279 
280 	timeout.tv_sec = 5;
281 	timeout.tv_usec = 0;
282 	addr->sin_port = htons(port);
283 
284 	if ((clnt = clntudp_create(addr,prognum,1,timeout,&sock)) == NULL) {
285 		yp_error("%s: %s", inet_ntoa(addr->sin_addr),
286 		  clnt_spcreateerror("failed to establish callback handle"));
287 		return;
288 	}
289 
290 	ypxfr_resp.status = rval;
291 	ypxfr_resp.transid = transid;
292 
293 	/* Turn the timeout off -- we don't want to block. */
294 	timeout.tv_sec = 0;
295 	if (clnt_control(clnt, CLSET_TIMEOUT, &timeout) == FALSE)
296 		yp_error("failed to set timeout on ypproc_xfr callback");
297 
298 	if (yppushproc_xfrresp_1(&ypxfr_resp, clnt) == NULL) {
299 		clnt_geterr(clnt, &err);
300 		if (err.re_status != RPC_SUCCESS &&
301 		    err.re_status != RPC_TIMEDOUT)
302 			yp_error("%s", clnt_sperror(clnt,
303 				"ypxfr callback failed"));
304 	}
305 
306 	clnt_destroy(clnt);
307 	return;
308 }
309 
310 #define YPXFR_RETURN(CODE) 						\
311 	/* Order is important: send regular RPC reply, then callback */	\
312 	result.xfrstat = CODE; 						\
313 	svc_sendreply(rqstp->rq_xprt, (xdrproc_t)xdr_ypresp_xfr, &result); \
314 	ypxfr_callback(CODE,rqhost,argp->transid, 			\
315 					argp->prog,argp->port); 	\
316 	return(NULL);
317 
318 ypresp_xfr *
319 ypproc_xfr_2_svc(ypreq_xfr *argp, struct svc_req *rqstp)
320 {
321 	static ypresp_xfr  result;
322 	struct sockaddr_in *rqhost;
323 	ypresp_master *mres;
324 	ypreq_nokey mreq;
325 
326 	result.transid = argp->transid;
327 	rqhost = svc_getcaller(rqstp->rq_xprt);
328 
329 #ifdef DB_CACHE
330 	if (yp_access(argp->map_parms.map,
331 			argp->map_parms.domain, (struct svc_req *)rqstp)) {
332 #else
333 	if (yp_access(argp->map_parms.map, (struct svc_req *)rqstp)) {
334 #endif
335 		YPXFR_RETURN(YPXFR_REFUSED)
336 	}
337 
338 
339 	if (argp->map_parms.domain == NULL) {
340 		YPXFR_RETURN(YPXFR_BADARGS)
341 	}
342 
343 	if (yp_validdomain(argp->map_parms.domain)) {
344 		YPXFR_RETURN(YPXFR_NODOM)
345 	}
346 
347 	/*
348 	 * Determine the master host ourselves. The caller may
349 	 * be up to no good. This has the side effect of verifying
350 	 * that the requested map and domain actually exist.
351 	 */
352 
353 	mreq.domain = argp->map_parms.domain;
354 	mreq.map = argp->map_parms.map;
355 
356 	mres = ypproc_master_2_svc(&mreq, rqstp);
357 
358 	if (mres->stat != YP_TRUE) {
359 		yp_error("couldn't find master for map %s@%s",
360 						argp->map_parms.map,
361 						argp->map_parms.domain);
362 		yp_error("host at %s (%s) may be pulling my leg",
363 						argp->map_parms.peer,
364 						inet_ntoa(rqhost->sin_addr));
365 		YPXFR_RETURN(YPXFR_REFUSED)
366 	}
367 
368 	switch (yp_fork()) {
369 	case 0:
370 	{
371 		char g[11], t[11], p[11];
372 		char ypxfr_command[MAXPATHLEN + 2];
373 
374 		snprintf (ypxfr_command, sizeof(ypxfr_command), "%sypxfr", _PATH_LIBEXEC);
375 		snprintf (t, sizeof(t), "%u", argp->transid);
376 		snprintf (g, sizeof(g), "%u", argp->prog);
377 		snprintf (p, sizeof(p), "%u", argp->port);
378 		if (debug) {
379 			close(0); close(1); close(2);
380 		}
381 		if (strcmp(yp_dir, _PATH_YP)) {
382 			execl(ypxfr_command, "ypxfr",
383 			"-d", argp->map_parms.domain,
384 		      	"-h", mres->peer,
385 			"-p", yp_dir, "-C", t,
386 		      	g, inet_ntoa(rqhost->sin_addr),
387 			p, argp->map_parms.map,
388 		      	NULL);
389 		} else {
390 			execl(ypxfr_command, "ypxfr",
391 			"-d", argp->map_parms.domain,
392 		      	"-h", mres->peer,
393 			"-C", t,
394 		      	g, inet_ntoa(rqhost->sin_addr),
395 			p, argp->map_parms.map,
396 		      	NULL);
397 		}
398 		yp_error("ypxfr execl(%s): %s", ypxfr_command, strerror(errno));
399 		YPXFR_RETURN(YPXFR_XFRERR)
400 		/*
401 		 * Just to safe, prevent PR #10970 from biting us in
402 		 * the unlikely case that execing ypxfr fails. We don't
403 		 * want to have any child processes spawned from this
404 		 * child process.
405 		 */
406 		_exit(0);
407 		break;
408 	}
409 	case -1:
410 		yp_error("ypxfr fork(): %s", strerror(errno));
411 		YPXFR_RETURN(YPXFR_XFRERR)
412 		break;
413 	default:
414 		result.xfrstat = YPXFR_SUCC;
415 		children++;
416 		break;
417 	}
418 
419 	return (&result);
420 }
421 #undef YPXFR_RETURN
422 
423 void *
424 ypproc_clear_2_svc(void *argp, struct svc_req *rqstp)
425 {
426 	static char * result;
427 	static char rval = 0;
428 
429 #ifdef DB_CACHE
430 	if (yp_access(NULL, NULL, (struct svc_req *)rqstp))
431 #else
432 	if (yp_access(NULL, (struct svc_req *)rqstp))
433 #endif
434 		return (NULL);
435 #ifdef DB_CACHE
436 	/* clear out the database cache */
437 	yp_flush_all();
438 #endif
439 	/* Re-read the securenets database for the hell of it. */
440 	load_securenets();
441 
442 	result = &rval;
443 	return((void *) &result);
444 }
445 
446 /*
447  * For ypproc_all, we have to send a stream of ypresp_all structures
448  * via TCP, but the XDR filter generated from the yp.x protocol
449  * definition file only serializes one such structure. This means that
450  * to send the whole stream, you need a wrapper which feeds all the
451  * records into the underlying XDR routine until it hits an 'EOF.'
452  * But to use the wrapper, you have to violate the boundaries between
453  * RPC layers by calling svc_sendreply() directly from the ypproc_all
454  * service routine instead of letting the RPC dispatcher do it.
455  *
456  * Bleah.
457  */
458 
459 /*
460  * Custom XDR routine for serialzing results of ypproc_all: keep
461  * reading from the database and spew until we run out of records
462  * or encounter an error.
463  */
464 static bool_t
465 xdr_my_ypresp_all(register XDR *xdrs, ypresp_all *objp)
466 {
467 	while (1) {
468 		/* Get a record. */
469 		if ((objp->ypresp_all_u.val.stat =
470 			yp_nextbykey(&objp->ypresp_all_u.val.key,
471 				     &objp->ypresp_all_u.val.val)) == YP_TRUE) {
472 			objp->more = TRUE;
473 		} else {
474 			objp->more = FALSE;
475 		}
476 
477 		/* Serialize. */
478 		if (!xdr_ypresp_all(xdrs, objp))
479 			return(FALSE);
480 		if (objp->more == FALSE)
481 			return(TRUE);
482 	}
483 }
484 
485 ypresp_all *
486 ypproc_all_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
487 {
488 	static ypresp_all  result;
489 
490 	/*
491 	 * Set this here so that the client will be forced to make
492 	 * at least one attempt to read from us even if all we're
493 	 * doing is returning an error.
494 	 */
495 	result.more = TRUE;
496 	result.ypresp_all_u.val.key.keydat_len = 0;
497 	result.ypresp_all_u.val.key.keydat_val = "";
498 
499 #ifdef DB_CACHE
500 	if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
501 #else
502 	if (yp_access(argp->map, (struct svc_req *)rqstp)) {
503 #endif
504 		result.ypresp_all_u.val.stat = YP_YPERR;
505 		return (&result);
506 	}
507 
508 	if (argp->domain == NULL || argp->map == NULL) {
509 		result.ypresp_all_u.val.stat = YP_BADARGS;
510 		return (&result);
511 	}
512 
513 	/*
514 	 * XXX If we hit the child limit, fail the request.
515 	 * If we don't, and the map is large, we could block for
516 	 * a long time in the parent.
517 	 */
518 	if (children >= MAX_CHILDREN) {
519 		result.ypresp_all_u.val.stat = YP_YPERR;
520 		return(&result);
521 	}
522 
523 	/*
524 	 * The ypproc_all procedure can take a while to complete.
525 	 * Best to handle it in a subprocess so the parent doesn't
526 	 * block. (Is there a better way to do this? Maybe with
527 	 * async socket I/O?)
528 	 */
529 	if (!debug) {
530 		switch (yp_fork()) {
531 		case 0:
532 			break;
533 		case -1:
534 			yp_error("ypall fork(): %s", strerror(errno));
535 			result.ypresp_all_u.val.stat = YP_YPERR;
536 			return(&result);
537 			break;
538 		default:
539 			children++;
540 			return (NULL);
541 			break;
542 		}
543 	}
544 
545 	/*
546 	 * Fix for PR #10971: don't let the child ypserv share
547 	 * DB handles with the parent process.
548 	 */
549 #ifdef DB_CACHE
550 	yp_flush_all();
551 #endif
552 
553 	if (yp_select_map(argp->map, argp->domain,
554 				&result.ypresp_all_u.val.key, 0) != YP_TRUE) {
555 		result.ypresp_all_u.val.stat = yp_errno;
556 		return(&result);
557 	}
558 
559 	/* Kick off the actual data transfer. */
560 	svc_sendreply(rqstp->rq_xprt, (xdrproc_t)xdr_my_ypresp_all, &result);
561 
562 	/*
563 	 * Proper fix for PR #10970: exit here so that we don't risk
564 	 * having a child spawned from this sub-process.
565 	 */
566 	_exit(0);
567 }
568 
569 ypresp_master *
570 ypproc_master_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
571 {
572 	static ypresp_master  result;
573 	static char ypvalbuf[YPMAXRECORD];
574 	keydat key = { MASTER_SZ, MASTER_STRING };
575 	valdat val;
576 
577 	result.peer = "";
578 
579 #ifdef DB_CACHE
580 	if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
581 #else
582 	if (yp_access(argp->map, (struct svc_req *)rqstp)) {
583 #endif
584 		result.stat = YP_YPERR;
585 		return(&result);
586 	}
587 
588 	if (argp->domain == NULL) {
589 		result.stat = YP_BADARGS;
590 		return (&result);
591 	}
592 
593 	if (yp_select_map(argp->map, argp->domain, &key, 1) != YP_TRUE) {
594 		result.stat = yp_errno;
595 		return(&result);
596 	}
597 
598 	/*
599 	 * Note that we copy the data retrieved from the database to
600 	 * a private buffer and NUL terminate the buffer rather than
601 	 * terminating the data in place. We do this because by stuffing
602 	 * a '\0' into data.data, we will actually be corrupting memory
603 	 * allocated by the DB package. This is a bad thing now that we
604 	 * cache DB handles rather than closing the database immediately.
605 	 */
606 	result.stat = yp_getbykey(&key, &val);
607 	if (result.stat == YP_TRUE) {
608 		bcopy(val.valdat_val, &ypvalbuf, val.valdat_len);
609 		ypvalbuf[val.valdat_len] = '\0';
610 		result.peer = ypvalbuf;
611 	} else
612 		result.peer = "";
613 
614 	return (&result);
615 }
616 
617 ypresp_order *
618 ypproc_order_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
619 {
620 	static ypresp_order  result;
621 	keydat key = { ORDER_SZ, ORDER_STRING };
622 	valdat val;
623 
624 	result.ordernum = 0;
625 
626 #ifdef DB_CACHE
627 	if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
628 #else
629 	if (yp_access(argp->map, (struct svc_req *)rqstp)) {
630 #endif
631 		result.stat = YP_YPERR;
632 		return(&result);
633 	}
634 
635 	if (argp->domain == NULL) {
636 		result.stat = YP_BADARGS;
637 		return (&result);
638 	}
639 
640 	/*
641 	 * We could just check the timestamp on the map file,
642 	 * but that's a hack: we'll only know the last time the file
643 	 * was touched, not the last time the database contents were
644 	 * updated.
645 	 */
646 
647 	if (yp_select_map(argp->map, argp->domain, &key, 1) != YP_TRUE) {
648 		result.stat = yp_errno;
649 		return(&result);
650 	}
651 
652 	result.stat = yp_getbykey(&key, &val);
653 
654 	if (result.stat == YP_TRUE)
655 		result.ordernum = atoi(val.valdat_val);
656 	else
657 		result.ordernum = 0;
658 
659 	return (&result);
660 }
661 
662 static void yp_maplist_free(struct ypmaplist *yp_maplist)
663 {
664 	register struct ypmaplist *next;
665 
666 	while (yp_maplist) {
667 		next = yp_maplist->next;
668 		free(yp_maplist->map);
669 		free(yp_maplist);
670 		yp_maplist = next;
671 	}
672 	return;
673 }
674 
675 static struct ypmaplist *
676 yp_maplist_create(const char *domain)
677 {
678 	char yp_mapdir[MAXPATHLEN + 2];
679 	char yp_mapname[MAXPATHLEN + 2];
680 	struct ypmaplist *cur = NULL;
681 	struct ypmaplist *yp_maplist = NULL;
682 	DIR *dird;
683 	struct dirent *dirp;
684 	struct stat statbuf;
685 
686 	snprintf(yp_mapdir, sizeof(yp_mapdir), "%s/%s", yp_dir, domain);
687 
688 	if ((dird = opendir(yp_mapdir)) == NULL) {
689 		yp_error("opendir(%s) failed: %s", yp_mapdir, strerror(errno));
690 		return(NULL);
691 	}
692 
693 	while ((dirp = readdir(dird)) != NULL) {
694 		if (strcmp(dirp->d_name, ".") && strcmp(dirp->d_name, "..")) {
695 			snprintf(yp_mapname, sizeof(yp_mapname), "%s/%s",
696 							yp_mapdir,dirp->d_name);
697 			if (stat(yp_mapname, &statbuf) < 0 ||
698 						!S_ISREG(statbuf.st_mode))
699 				continue;
700 			if ((cur = (struct ypmaplist *)
701 				malloc(sizeof(struct ypmaplist))) == NULL) {
702 				yp_error("malloc() failed");
703 				closedir(dird);
704 				yp_maplist_free(yp_maplist);
705 				return(NULL);
706 			}
707 			if ((cur->map = strdup(dirp->d_name)) == NULL) {
708 				yp_error("strdup() failed: %s",strerror(errno));
709 				closedir(dird);
710 				yp_maplist_free(yp_maplist);
711 				return(NULL);
712 			}
713 			cur->next = yp_maplist;
714 			yp_maplist = cur;
715 			if (debug)
716 				yp_error("map: %s", yp_maplist->map);
717 		}
718 
719 	}
720 	closedir(dird);
721 	return(yp_maplist);
722 }
723 
724 ypresp_maplist *
725 ypproc_maplist_2_svc(domainname *argp, struct svc_req *rqstp)
726 {
727 	static ypresp_maplist  result = { 0, NULL };
728 
729 #ifdef DB_CACHE
730 	if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) {
731 #else
732 	if (yp_access(NULL, (struct svc_req *)rqstp)) {
733 #endif
734 		result.stat = YP_YPERR;
735 		return(&result);
736 	}
737 
738 	if (argp == NULL) {
739 		result.stat = YP_BADARGS;
740 		return (&result);
741 	}
742 
743 	if (yp_validdomain(*argp)) {
744 		result.stat = YP_NODOM;
745 		return (&result);
746 	}
747 
748 	/*
749 	 * We have to construct a linked list for the ypproc_maplist
750 	 * procedure using dynamically allocated memory. Since the XDR
751 	 * layer won't free this list for us, we have to deal with it
752 	 * ourselves. We call yp_maplist_free() first to free any
753 	 * previously allocated data we may have accumulated to insure
754 	 * that we have only one linked list in memory at any given
755 	 * time.
756 	 */
757 
758 	yp_maplist_free(result.maps);
759 
760 	if ((result.maps = yp_maplist_create(*argp)) == NULL) {
761 		yp_error("yp_maplist_create failed");
762 		result.stat = YP_YPERR;
763 		return(&result);
764 	} else
765 		result.stat = YP_TRUE;
766 
767 	return (&result);
768 }
769 
770 /*
771  * NIS v1 support. The nullproc, domain and domain_nonack
772  * functions from v1 are identical to those in v2, so all
773  * we have to do is hand off to them.
774  *
775  * The other functions are mostly just wrappers around their v2
776  * counterparts. For example, for the v1 'match' procedure, we
777  * crack open the argument structure, make a request to the v2
778  * 'match' function, repackage the data into a v1 response and
779  * then send it on its way.
780  *
781  * Note that we don't support the pull, push and get procedures.
782  * There's little documentation available to show what they
783  * do, and I suspect they're meant largely for map transfers
784  * between master and slave servers.
785  */
786 
787 void *
788 ypoldproc_null_1_svc(void *argp, struct svc_req *rqstp)
789 {
790 	return(ypproc_null_2_svc(argp, rqstp));
791 }
792 
793 bool_t *
794 ypoldproc_domain_1_svc(domainname *argp, struct svc_req *rqstp)
795 {
796 	return(ypproc_domain_2_svc(argp, rqstp));
797 }
798 
799 bool_t *
800 ypoldproc_domain_nonack_1_svc(domainname *argp, struct svc_req *rqstp)
801 {
802 	return (ypproc_domain_nonack_2_svc(argp, rqstp));
803 }
804 
805 /*
806  * the 'match' procedure sends a response of type YPRESP_VAL
807  */
808 ypresponse *
809 ypoldproc_match_1_svc(yprequest *argp, struct svc_req *rqstp)
810 {
811 	static ypresponse  result;
812 	ypresp_val *v2_result;
813 
814 	result.yp_resptype = YPRESP_VAL;
815 	result.ypresponse_u.yp_resp_valtype.val.valdat_val = "";
816 	result.ypresponse_u.yp_resp_valtype.val.valdat_len = 0;
817 
818 	if (argp->yp_reqtype != YPREQ_KEY) {
819 		result.ypresponse_u.yp_resp_valtype.stat = YP_BADARGS;
820 		return(&result);
821 	}
822 
823 	v2_result = ypproc_match_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp);
824 	if (v2_result == NULL)
825 		return(NULL);
826 
827 	bcopy(v2_result, &result.ypresponse_u.yp_resp_valtype,
828 	      sizeof(ypresp_val));
829 
830 	return (&result);
831 }
832 
833 /*
834  * the 'first' procedure sends a response of type YPRESP_KEY_VAL
835  */
836 ypresponse *
837 ypoldproc_first_1_svc(yprequest *argp, struct svc_req *rqstp)
838 {
839 	static ypresponse  result;
840 	ypresp_key_val *v2_result;
841 
842 	result.yp_resptype = YPRESP_KEY_VAL;
843 	result.ypresponse_u.yp_resp_key_valtype.val.valdat_val =
844 	result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = "";
845 	result.ypresponse_u.yp_resp_key_valtype.val.valdat_len =
846 	result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0;
847 
848 	if (argp->yp_reqtype != YPREQ_NOKEY) {
849 		result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS;
850 		return(&result);
851 	}
852 
853 	v2_result = ypproc_first_2_svc(&argp->yprequest_u.yp_req_nokeytype,
854 									rqstp);
855 	if (v2_result == NULL)
856 		return(NULL);
857 
858 	bcopy(v2_result, &result.ypresponse_u.yp_resp_key_valtype,
859 	      sizeof(ypresp_key_val));
860 
861 	return (&result);
862 }
863 
864 /*
865  * the 'next' procedure sends a response of type YPRESP_KEY_VAL
866  */
867 ypresponse *
868 ypoldproc_next_1_svc(yprequest *argp, struct svc_req *rqstp)
869 {
870 	static ypresponse  result;
871 	ypresp_key_val *v2_result;
872 
873 	result.yp_resptype = YPRESP_KEY_VAL;
874 	result.ypresponse_u.yp_resp_key_valtype.val.valdat_val =
875 	result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = "";
876 	result.ypresponse_u.yp_resp_key_valtype.val.valdat_len =
877 	result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0;
878 
879 	if (argp->yp_reqtype != YPREQ_KEY) {
880 		result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS;
881 		return(&result);
882 	}
883 
884 	v2_result = ypproc_next_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp);
885 	if (v2_result == NULL)
886 		return(NULL);
887 
888 	bcopy(v2_result, &result.ypresponse_u.yp_resp_key_valtype,
889 	      sizeof(ypresp_key_val));
890 
891 	return (&result);
892 }
893 
894 /*
895  * the 'poll' procedure sends a response of type YPRESP_MAP_PARMS
896  */
897 ypresponse *
898 ypoldproc_poll_1_svc(yprequest *argp, struct svc_req *rqstp)
899 {
900 	static ypresponse  result;
901 	ypresp_master *v2_result1;
902 	ypresp_order *v2_result2;
903 
904 	result.yp_resptype = YPRESP_MAP_PARMS;
905 	result.ypresponse_u.yp_resp_map_parmstype.domain =
906 		argp->yprequest_u.yp_req_nokeytype.domain;
907 	result.ypresponse_u.yp_resp_map_parmstype.map =
908 		argp->yprequest_u.yp_req_nokeytype.map;
909 	/*
910 	 * Hmm... there is no 'status' value in the
911 	 * yp_resp_map_parmstype structure, so I have to
912 	 * guess at what to do to indicate a failure.
913 	 * I hope this is right.
914 	 */
915 	result.ypresponse_u.yp_resp_map_parmstype.ordernum = 0;
916 	result.ypresponse_u.yp_resp_map_parmstype.peer = "";
917 
918 	if (argp->yp_reqtype != YPREQ_MAP_PARMS) {
919 		return(&result);
920 	}
921 
922 	v2_result1 = ypproc_master_2_svc(&argp->yprequest_u.yp_req_nokeytype,
923 									rqstp);
924 	if (v2_result1 == NULL)
925 		return(NULL);
926 
927 	if (v2_result1->stat != YP_TRUE) {
928 		return(&result);
929 	}
930 
931 	v2_result2 = ypproc_order_2_svc(&argp->yprequest_u.yp_req_nokeytype,
932 									rqstp);
933 	if (v2_result2 == NULL)
934 		return(NULL);
935 
936 	if (v2_result2->stat != YP_TRUE) {
937 		return(&result);
938 	}
939 
940 	result.ypresponse_u.yp_resp_map_parmstype.peer =
941 		v2_result1->peer;
942 	result.ypresponse_u.yp_resp_map_parmstype.ordernum =
943 		v2_result2->ordernum;
944 
945 	return (&result);
946 }
947 
948 ypresponse *
949 ypoldproc_push_1_svc(yprequest *argp, struct svc_req *rqstp)
950 {
951 	static ypresponse  result;
952 
953 	/*
954 	 * Not implemented.
955 	 */
956 
957 	return (&result);
958 }
959 
960 ypresponse *
961 ypoldproc_pull_1_svc(yprequest *argp, struct svc_req *rqstp)
962 {
963 	static ypresponse  result;
964 
965 	/*
966 	 * Not implemented.
967 	 */
968 
969 	return (&result);
970 }
971 
972 ypresponse *
973 ypoldproc_get_1_svc(yprequest *argp, struct svc_req *rqstp)
974 {
975 	static ypresponse  result;
976 
977 	/*
978 	 * Not implemented.
979 	 */
980 
981 	return (&result);
982 }
983