xref: /illumos-gate/usr/src/cmd/ypcmd/ypserv_proc.c (revision 2a8bcb4efb45d99ac41c94a75c396b362c414f7f)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  * Copyright (c) 2016 by Delphix. All rights reserved.
26  */
27 
28 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
29 /*	  All Rights Reserved  	*/
30 
31 /*
32  * Portions of this source code were derived from Berkeley 4.3 BSD
33  * under license from the Regents of the University of California.
34  */
35 
36 /*
37  *
38  * This contains YP server code which supplies the set of functions
39  * requested using rpc.   The top level functions in this module
40  * are those which have symbols of the form YPPROC_xxxx defined in
41  * yp_prot.h, and symbols of the form YPOLDPROC_xxxx defined in ypsym.h.
42  * The latter exist to provide compatibility to the old version of the yp
43  * protocol/server, and may emulate the behavior of the previous software
44  * by invoking some other program.
45  *
46  * This module also contains functions which are used by (and only by) the
47  * top-level functions here.
48  */
49 
50 #include <sys/types.h>
51 #include <sys/socket.h>
52 #include <netinet/in.h>
53 #include <arpa/inet.h>
54 #include <dirent.h>
55 #include <limits.h>
56 #include <sys/systeminfo.h>
57 #include <rpc/rpc.h>
58 #include <string.h>
59 #include <malloc.h>
60 #include <stdlib.h>
61 #include <unistd.h>
62 #include <stdio.h>
63 #include "ypsym.h"
64 #include "ypdefs.h"
65 #include <ctype.h>
66 
67 /* Use shim version of DBM calls */
68 #include "shim.h"
69 #include "shim_hooks.h"
70 
71 USE_YP_PREFIX
72 USE_YP_SECURE
73 USE_YP_INTERDOMAIN
74 
75 #ifndef	YPXFR_PROC
76 #define	YPXFR_PROC "/usr/lib/netsvc/yp/ypxfr"
77 #endif
78 static char ypxfr_proc[] = YPXFR_PROC;
79 #ifndef	YPPUSH_PROC
80 #define	YPPUSH_PROC "/usr/lib/netsvc/yp/yppush"
81 #endif
82 static char yppush_proc[] = YPPUSH_PROC;
83 struct yppriv_sym {
84     char *sym;
85     unsigned len;
86 };
87 static	char err_fork[] = "ypserv:  %s fork failure.\n";
88 #define	FORK_ERR logprintf(err_fork, fun)
89 static char err_execl[] = "ypserv:  %s execl failure.\n";
90 #define	EXEC_ERR logprintf(err_execl, fun)
91 static char err_respond[] = "ypserv: %s can't respond to rpc request.\n";
92 #define	RESPOND_ERR logprintf(err_respond, fun)
93 static char err_free[] = "ypserv: %s can't free args.\n";
94 #define	FREE_ERR logprintf(err_free, fun)
95 static char err_map[] = "ypserv: %s no such map or access denied.\n";
96 #define	MAP_ERR logprintf(err_map, fun)
97 static char err_vers[] = "ypserv: %s version not supported.\n";
98 #define	VERS_ERR logprintf(err_vers, fun)
99 
100 static void ypfilter(DBM *fdb, datum *inkey, datum *outkey, datum *val,
101 			uint_t *status, bool_t update);
102 static bool isypsym(datum *key);
103 static bool xdrypserv_ypall(XDR *xdrs, struct ypreq_nokey *req);
104 static int multihomed(struct ypreq_key req, struct ypresp_val *resp,
105 			SVCXPRT *xprt, DBM *fdb);
106 static int omultihomed(struct yprequest req, struct ypresponse *resp,
107 			SVCXPRT *xprt, DBM *fdb);
108 
109 
110 /* For DNS forwarding */
111 extern bool dnsforward;
112 extern bool client_setup_failure;
113 extern int resolv_pid;
114 extern CLIENT *resolv_client;
115 extern char *resolv_tp;
116 
117 /*
118  * This determines whether or not a passed domain is served by this
119  * server, and returns a boolean.  Used by both old and new protocol
120  * versions.
121  */
122 void
ypdomain(SVCXPRT * transp,bool always_respond)123 ypdomain(SVCXPRT *transp, bool always_respond)
124 {
125 	char domain_name[YPMAXDOMAIN + 1];
126 	char *pdomain_name = domain_name;
127 	bool isserved;
128 	char *fun = "ypdomain";
129 	struct netbuf *nbuf;
130 	sa_family_t af;
131 
132 	memset(domain_name, 0, sizeof (domain_name));
133 
134 	if (!svc_getargs(transp, (xdrproc_t)xdr_ypdomain_wrap_string,
135 				(caddr_t)&pdomain_name)) {
136 		svcerr_decode(transp);
137 		return;
138 	}
139 
140 	/*
141 	 * If the file /var/yp/securenets is present on the server, and if
142 	 * the hostname is present in the file, then let the client bind to
143 	 * the server.
144 	 */
145 	nbuf = svc_getrpccaller(transp);
146 	af = ((struct sockaddr_storage *)nbuf->buf)->ss_family;
147 	if (af != AF_INET && af != AF_INET6) {
148 		logprintf("Protocol incorrect\n");
149 		return;
150 	}
151 
152 	if (!(check_secure_net_ti(nbuf, fun))) {
153 		MAP_ERR;
154 		return;
155 	}
156 
157 	isserved = ypcheck_domain(domain_name);
158 
159 	if (isserved || always_respond) {
160 
161 		if (!svc_sendreply(transp, xdr_bool, (char *)&isserved)) {
162 		    RESPOND_ERR;
163 		}
164 		if (!isserved)
165 			logprintf("Domain %s not supported\n",
166 					domain_name);
167 
168 	} else {
169 		/*
170 		 * This case is the one in which the domain is not
171 		 * supported, and in which we are not to respond in the
172 		 * unsupported case.  We are going to make an error happen
173 		 * to allow the portmapper to end its wait without the
174 		 * normal timeout period.  The assumption here is that
175 		 * the only process in the world which is using the function
176 		 * in its no-answer-if-nack form is the portmapper, which is
177 		 * doing the krock for pseudo-broadcast.  If some poor fool
178 		 * calls this function as a single-cast message, the nack
179 		 * case will look like an incomprehensible error.  Sigh...
180 		 * (The traditional Unix disclaimer)
181 		 */
182 
183 		svcerr_decode(transp);
184 		logprintf("Domain %s not supported (broadcast)\n",
185 				domain_name);
186 	}
187 }
188 
189 /*
190  * This implements the yp "match" function.
191  */
192 void
ypmatch(SVCXPRT * transp,struct svc_req * rqstp)193 ypmatch(SVCXPRT *transp, struct svc_req *rqstp)
194 {
195 	struct ypreq_key req;
196 	struct ypresp_val resp;
197 	char *fun = "ypmatch";
198 	DBM *fdb;
199 
200 	memset(&req, 0, sizeof (req));
201 	memset(&resp, 0, sizeof (resp));
202 	resp.status = (unsigned)YP_NOKEY;
203 
204 	if (!svc_getargs(transp, (xdrproc_t)xdr_ypreq_key, (char *)&req)) {
205 		svcerr_decode(transp);
206 		return;
207 	}
208 
209 	/*
210 	 * sanity check the map name and to a DBM lookup
211 	 * also perform an access check...
212 	 */
213 	if ((fdb = ypset_current_map(req.map, req.domain,
214 					&resp.status)) != NULL &&
215 		yp_map_access(transp, &resp.status, fdb)) {
216 
217 		/* Check with the DBM database */
218 		resp.valdat = dbm_fetch(fdb, req.keydat);
219 		if (resp.valdat.dptr != NULL) {
220 			resp.status = YP_TRUE;
221 			if (!silent)
222 				printf("%s: dbm: %40.40s\n",
223 					fun, resp.valdat.dptr);
224 			goto send_reply;
225 		}
226 
227 		/*
228 		 * If we're being asked to match YP_SECURE or YP_INTERDOMAIN
229 		 * and we haven't found it in the dbm file, then we don't
230 		 * really want to waste any more time.  Specifically, we don't
231 		 * want to ask DNS
232 		 */
233 		if (req.keydat.dsize == 0 ||
234 		    req.keydat.dptr == NULL ||
235 		    req.keydat.dptr[0] == '\0' ||
236 	strncmp(req.keydat.dptr, yp_secure, req.keydat.dsize) == 0 ||
237 	strncmp(req.keydat.dptr, yp_interdomain, req.keydat.dsize) == 0) {
238 			goto send_reply;
239 		}
240 
241 		/* Let's try the YP_MULTI_ hack... */
242 #ifdef MINUS_C_OPTION
243 		if (multiflag == TRUE && multihomed(req, &resp, transp, fdb))
244 			goto send_reply;
245 #else
246 		if (multihomed(req, &resp, transp, fdb))
247 			goto send_reply;
248 #endif
249 
250 		/*
251 		 * Let's try DNS, but if client_setup_failure is set,
252 		 * we have tried DNS in the past and failed, there is
253 		 * no reason in forcing an infinite loop by turning
254 		 * off DNS in setup_resolv() only to turn it back on
255 		 * again here.
256 		 */
257 		if (!dnsforward && !client_setup_failure) {
258 			datum idkey, idval;
259 			idkey.dptr = yp_interdomain;
260 			idkey.dsize = yp_interdomain_sz;
261 			idval = dbm_fetch(fdb, idkey);
262 			if (idval.dptr)
263 				dnsforward = TRUE;
264 		}
265 
266 		if (dnsforward) {
267 			if (!resolv_pid || !resolv_client) {
268 				setup_resolv(&dnsforward, &resolv_pid,
269 						&resolv_client, resolv_tp, 0);
270 				if (resolv_client == NULL)
271 					client_setup_failure = TRUE;
272 			}
273 
274 			if (resolv_req(&dnsforward, &resolv_client,
275 						&resolv_pid, resolv_tp,
276 						rqstp->rq_xprt, &req,
277 						req.map) == TRUE)
278 				goto free_args;
279 		}
280 	}
281 	send_reply:
282 
283 	if (!svc_sendreply(transp, (xdrproc_t)xdr_ypresp_val,
284 				(caddr_t)&resp)) {
285 		RESPOND_ERR;
286 	}
287 
288 	free_args:
289 
290 	if (!svc_freeargs(transp, (xdrproc_t)xdr_ypreq_key,
291 				(char *)&req)) {
292 		FREE_ERR;
293 	}
294 }
295 
296 
297 /*
298  * This implements the yp "get first" function.
299  */
300 void
ypfirst(SVCXPRT * transp)301 ypfirst(SVCXPRT *transp)
302 {
303 	struct ypreq_nokey req;
304 	struct ypresp_key_val resp;
305 	char *fun = "ypfirst";
306 	DBM *fdb;
307 
308 	memset(&req, 0, sizeof (req));
309 	memset(&resp, 0, sizeof (resp));
310 
311 	if (!svc_getargs(transp,
312 				(xdrproc_t)xdr_ypreq_nokey,
313 				(char *)&req)) {
314 		svcerr_decode(transp);
315 		return;
316 	}
317 
318 	if ((fdb = ypset_current_map(req.map, req.domain,
319 					&resp.status)) != NULL &&
320 		yp_map_access(transp, &resp.status, fdb)) {
321 		ypfilter(fdb, NULL,
322 			&resp.keydat, &resp.valdat, &resp.status, FALSE);
323 	}
324 
325 	if (!svc_sendreply(transp,
326 				(xdrproc_t)xdr_ypresp_key_val,
327 				(char *)&resp)) {
328 		RESPOND_ERR;
329 	}
330 
331 	if (!svc_freeargs(transp, (xdrproc_t)xdr_ypreq_nokey,
332 				(char *)&req)) {
333 		FREE_ERR;
334 	}
335 }
336 
337 /*
338  * This implements the yp "get next" function.
339  */
340 void
ypnext(SVCXPRT * transp)341 ypnext(SVCXPRT *transp)
342 {
343 	struct ypreq_key req;
344 	struct ypresp_key_val resp;
345 	char *fun = "ypnext";
346 	DBM *fdb;
347 
348 	memset(&req, 0, sizeof (req));
349 	memset(&resp, 0, sizeof (resp));
350 
351 	if (!svc_getargs(transp, (xdrproc_t)xdr_ypreq_key, (char *)&req)) {
352 		svcerr_decode(transp);
353 		return;
354 	}
355 
356 	if ((fdb = ypset_current_map(req.map, req.domain,
357 					&resp.status)) != NULL &&
358 		yp_map_access(transp, &resp.status, fdb)) {
359 		ypfilter(fdb, &req.keydat,
360 			&resp.keydat, &resp.valdat, &resp.status, FALSE);
361 	}
362 
363 	if (!svc_sendreply(transp,
364 				(xdrproc_t)xdr_ypresp_key_val,
365 				(char *)&resp)) {
366 		RESPOND_ERR;
367 	}
368 
369 	if (!svc_freeargs(transp,
370 				(xdrproc_t)xdr_ypreq_key,
371 				(char *)&req)) {
372 		FREE_ERR;
373 	}
374 }
375 
376 /*
377  * This implements the "transfer map" function.  It takes the domain
378  * and map names and the callback information provided by the
379  * requester (yppush on some node), and execs a ypxfr process to do
380  * the actual transfer.
381  */
382 void
ypxfr(SVCXPRT * transp,int prog)383 ypxfr(SVCXPRT *transp, int prog)
384 {
385 	struct ypreq_newxfr newreq;
386 	struct ypreq_xfr oldreq;
387 	struct ypresp_val resp;  /* not returned to the caller */
388 	char transid[32];
389 	char proto[32];
390 	char name[256];
391 	char *pdomain, *pmap;
392 	pid_t pid = -1;
393 	char *fun = "ypxfr";
394 	DBM *fdb;
395 
396 	if (prog == YPPROC_NEWXFR) {
397 		memset(&newreq, 0, sizeof (newreq));
398 		if (!svc_getargs(transp, (xdrproc_t)xdr_ypreq_newxfr,
399 				(char *)&newreq)) {
400 			svcerr_decode(transp);
401 			return;
402 		}
403 
404 #ifdef OPCOM_DEBUG
405 		fprintf(stderr, "newreq:\n"
406 			"\tmap_parms:\n"
407 			"\t\tdomain:    %s\n"
408 			"\t\tmap:       %s\n"
409 			"\t\tordernum:  %u\n"
410 			"\t\towner:     %s\n"
411 			"\ttransid:    %u\n"
412 			"\tproto:      %u\n"
413 			"\tname:       %s\n\n",
414 			newreq.map_parms.domain,
415 			newreq.map_parms.map,
416 			newreq.map_parms.ordernum,
417 			newreq.map_parms.owner,
418 			newreq.transid,
419 			newreq.proto,
420 			newreq.name);
421 #endif
422 		sprintf(transid, "%u", newreq.transid);
423 		sprintf(proto, "%u", newreq.proto);
424 		sprintf(name, "%s", newreq.ypxfr_owner);
425 		pdomain = newreq.ypxfr_domain;
426 		pmap = newreq.ypxfr_map;
427 	} else if (prog == YPPROC_XFR) {
428 		memset(&oldreq, 0, sizeof (oldreq));
429 		if (!svc_getargs(transp,
430 					(xdrproc_t)xdr_ypreq_xfr,
431 					(char *)&oldreq)) {
432 		    svcerr_decode(transp);
433 		    return;
434 		}
435 
436 #ifdef OPCOM_DEBUG
437 		fprintf(stderr, "oldreq:\n"
438 			"\tmap_parms:\n"
439 			"\t\tdomain:    %s\n"
440 			"\t\tmap:       %s\n"
441 			"\t\tordernum:  %u\n"
442 			"\t\towner:     %s\n"
443 			"\ttransid:    %u\n"
444 			"\tproto:      %u\n"
445 			"\tport:       %u\n\n",
446 			oldreq.map_parms.domain,
447 			oldreq.map_parms.map,
448 			oldreq.map_parms.ordernum,
449 			oldreq.map_parms.owner,
450 			oldreq.transid,
451 			oldreq.proto,
452 			oldreq.port);
453 #endif
454 
455 		sprintf(transid, "%u", oldreq.transid);
456 		sprintf(proto, "%u", oldreq.proto);
457 		sprintf(name, "%s", oldreq.ypxfr_owner);
458 		pdomain = oldreq.ypxfr_domain;
459 		pmap = oldreq.ypxfr_map;
460 	} else {
461 		VERS_ERR;
462 	}
463 
464 	/* Check that the map exists and is accessible */
465 	if ((fdb = ypset_current_map(pmap, pdomain, &resp.status)) != NULL &&
466 		yp_map_access(transp, &resp.status, fdb)) {
467 
468 		pid = vfork();
469 		if (pid == -1) {
470 			FORK_ERR;
471 		} else if (pid == 0) {
472 		    if (prog == YPPROC_NEWXFR || prog == YPPROC_XFR) {
473 #ifdef OPCOM_DEBUG
474 			fprintf(stderr,
475 				"EXECL: %s, -d, %s, -C, %s, %s, %s, %s\n",
476 				ypxfr_proc, pdomain,
477 				transid, proto, name, pmap);
478 #endif
479 			if (execl(ypxfr_proc, "ypxfr", "-d",
480 					pdomain, "-C", transid, proto,
481 					name, pmap, NULL))
482 			    EXEC_ERR;
483 		    } else {
484 			VERS_ERR;
485 		    }
486 		    _exit(1);
487 		}
488 
489 	} else {
490 		MAP_ERR;
491 	}
492 	if (!svc_sendreply(transp, xdr_void, 0)) {
493 		RESPOND_ERR;
494 	}
495 
496 	if (prog == YPPROC_NEWXFR) {
497 		if (!svc_freeargs(transp,
498 					(xdrproc_t)xdr_ypreq_newxfr,
499 					(char *)&newreq)) {
500 		    FREE_ERR;
501 		}
502 	}
503 }
504 
505 /*
506  * This implements the "get all" function.
507  */
508 void
ypall(SVCXPRT * transp)509 ypall(SVCXPRT *transp)
510 {
511 	struct ypreq_nokey req;
512 	struct ypresp_val resp;  /* not returned to the caller */
513 	pid_t pid;
514 	char *fun = "ypall";
515 	DBM *fdb;
516 
517 	req.domain = req.map = NULL;
518 
519 	memset((char *)&req, 0, sizeof (req));
520 
521 	if (!svc_getargs(transp,
522 				(xdrproc_t)xdr_ypreq_nokey,
523 				(char *)&req)) {
524 		svcerr_decode(transp);
525 		return;
526 	}
527 
528 	pid = fork1();
529 
530 	if (pid) {
531 
532 		if (pid == -1) {
533 			FORK_ERR;
534 		}
535 
536 		if (!svc_freeargs(transp,
537 					(xdrproc_t)xdr_ypreq_nokey,
538 					(char *)&req)) {
539 			FREE_ERR;
540 		}
541 
542 		return;
543 	}
544 
545 	/*
546 	 * access control hack:  If denied then invalidate the map name.
547 	 */
548 	ypclr_current_map();
549 	if ((fdb = ypset_current_map(req.map,
550 		req.domain, &resp.status)) != NULL &&
551 		!yp_map_access(transp, &resp.status, fdb)) {
552 
553 		req.map[0] = '-';
554 	}
555 
556 	/*
557 	 * This is the child process.  The work gets done by xdrypserv_ypall/
558 	 * we must clear the "current map" first so that we do not
559 	 * share a seek pointer with the parent server.
560 	 */
561 
562 	if (!svc_sendreply(transp,
563 				(xdrproc_t)xdrypserv_ypall,
564 				(char *)&req)) {
565 		RESPOND_ERR;
566 	}
567 
568 	if (!svc_freeargs(transp,
569 				(xdrproc_t)xdr_ypreq_nokey,
570 				(char *)&req)) {
571 		FREE_ERR;
572 	}
573 
574 	/*
575 	 * In yptol mode we may start a cache update thread within a child
576 	 * process. It is thus important that child processes do not exit,
577 	 * killing any such threads, before the thread has completed.
578 	 */
579 	if (yptol_mode) {
580 		thr_join(0, NULL, NULL);
581 	}
582 
583 	exit(0);
584 }
585 
586 /*
587  * This implements the "get master name" function.
588  */
589 void
ypmaster(SVCXPRT * transp)590 ypmaster(SVCXPRT *transp)
591 {
592 	struct ypreq_nokey req;
593 	struct ypresp_master resp;
594 	char *nullstring = "";
595 	char *fun = "ypmaster";
596 	DBM *fdb;
597 
598 	memset((char *)&req, 0, sizeof (req));
599 	resp.master = nullstring;
600 	resp.status = YP_TRUE;
601 
602 	if (!svc_getargs(transp,
603 				(xdrproc_t)xdr_ypreq_nokey,
604 				(char *)&req)) {
605 		svcerr_decode(transp);
606 		return;
607 	}
608 
609 	if ((fdb = ypset_current_map(req.map,
610 		req.domain, &resp.status)) != NULL &&
611 		yp_map_access(transp, &resp.status, fdb)) {
612 
613 		if (!ypget_map_master(&resp.master, fdb)) {
614 			resp.status = (unsigned)YP_BADDB;
615 		}
616 	}
617 
618 	if (!svc_sendreply(transp,
619 				(xdrproc_t)xdr_ypresp_master,
620 				(char *)&resp)) {
621 		RESPOND_ERR;
622 	}
623 
624 	if (!svc_freeargs(transp,
625 				(xdrproc_t)xdr_ypreq_nokey,
626 				(char *)&req)) {
627 		FREE_ERR;
628 	}
629 }
630 
631 /*
632  * This implements the "get order number" function.
633  */
634 void
yporder(SVCXPRT * transp)635 yporder(SVCXPRT *transp)
636 {
637 	struct ypreq_nokey req;
638 	struct ypresp_order resp;
639 	char *fun = "yporder";
640 	DBM *fdb;
641 
642 	req.domain = req.map = NULL;
643 	resp.status  = YP_TRUE;
644 	resp.ordernum  = 0;
645 
646 	memset((char *)&req, 0, sizeof (req));
647 
648 	if (!svc_getargs(transp,
649 				(xdrproc_t)xdr_ypreq_nokey,
650 				(char *)&req)) {
651 		svcerr_decode(transp);
652 		return;
653 	}
654 
655 	resp.ordernum = 0;
656 
657 	if ((fdb = ypset_current_map(req.map,
658 					req.domain,
659 					&resp.status)) != NULL &&
660 		yp_map_access(transp, &resp.status, fdb)) {
661 
662 		if (!ypget_map_order(req.map, req.domain, &resp.ordernum)) {
663 			resp.status = (unsigned)YP_BADDB;
664 		}
665 	}
666 
667 	if (!svc_sendreply(transp,
668 				(xdrproc_t)xdr_ypresp_order,
669 				(char *)&resp)) {
670 		RESPOND_ERR;
671 	}
672 
673 	if (!svc_freeargs(transp,
674 				(xdrproc_t)xdr_ypreq_nokey,
675 				(char *)&req)) {
676 		FREE_ERR;
677 	}
678 }
679 
680 void
ypmaplist(SVCXPRT * transp)681 ypmaplist(SVCXPRT *transp)
682 {
683 	char domain_name[YPMAXDOMAIN + 1];
684 	char *pdomain = domain_name;
685 	char *fun = "ypmaplist";
686 	struct ypresp_maplist maplist;
687 	struct ypmaplist *tmp;
688 
689 	maplist.list = (struct ypmaplist *)NULL;
690 
691 	memset(domain_name, 0, sizeof (domain_name));
692 
693 	if (!svc_getargs(transp,
694 				(xdrproc_t)xdr_ypdomain_wrap_string,
695 				(caddr_t)&pdomain)) {
696 		svcerr_decode(transp);
697 		return;
698 	}
699 
700 	maplist.status = yplist_maps(domain_name, &maplist.list);
701 
702 	if (!svc_sendreply(transp,
703 				(xdrproc_t)xdr_ypresp_maplist,
704 				(char *)&maplist)) {
705 		RESPOND_ERR;
706 	}
707 
708 	while (maplist.list) {
709 		tmp = maplist.list->ypml_next;
710 		free((char *)maplist.list);
711 		maplist.list = tmp;
712 	}
713 }
714 
715 /*
716  * Ancillary functions used by the top-level functions within this
717  * module
718  */
719 
720 /*
721  * This returns TRUE if a given key is a yp-private symbol, otherwise
722  * FALSE
723  */
724 static bool
isypsym(datum * key)725 isypsym(datum *key)
726 {
727 	if ((key->dptr == NULL) ||
728 		(key->dsize < yp_prefix_sz) ||
729 		memcmp(yp_prefix, key->dptr, yp_prefix_sz) ||
730 		(!memcmp(key->dptr, "YP_MULTI_", 9))) {
731 		return (FALSE);
732 	}
733 	return (TRUE);
734 }
735 
736 /*
737  * This provides private-symbol filtration for the enumeration functions.
738  */
739 static void
ypfilter(DBM * fdb,datum * inkey,datum * outkey,datum * val,uint_t * status,bool_t update)740 ypfilter(DBM *fdb, datum *inkey, datum *outkey, datum *val, uint_t *status,
741 							bool_t update)
742 {
743 	datum k;
744 
745 	if (inkey) {
746 
747 		if (isypsym(inkey)) {
748 			*status = (unsigned)YP_BADARGS;
749 			return;
750 		}
751 
752 		k = dbm_do_nextkey(fdb, *inkey);
753 	} else {
754 		k = dbm_firstkey(fdb);
755 	}
756 
757 	while (k.dptr && isypsym(&k)) {
758 		k = dbm_nextkey(fdb);
759 	}
760 
761 	if (k.dptr == NULL) {
762 		*status = YP_NOMORE;
763 		return;
764 	}
765 
766 	*outkey = k;
767 
768 	/*
769 	 * In N2L mode we must call a version of dbm_fetch() that either does
770 	 * or does not check for entry updates. In non N2L mode both of these
771 	 * will end up doing a normal dbm_fetch().
772 	 */
773 	if (update)
774 		*val = shim_dbm_fetch(fdb, k);
775 	else
776 		*val = shim_dbm_fetch_noupdate(fdb, k);
777 
778 	if (val->dptr != NULL) {
779 		*status = YP_TRUE;
780 	} else {
781 		*status = (unsigned)YP_BADDB;
782 	}
783 }
784 
785 /*
786  * Serializes a stream of struct ypresp_key_val's.  This is used
787  * only by the ypserv side of the transaction.
788  */
789 static bool
xdrypserv_ypall(XDR * xdrs,struct ypreq_nokey * req)790 xdrypserv_ypall(XDR *xdrs, struct ypreq_nokey *req)
791 {
792 	bool_t more = TRUE;
793 	struct ypresp_key_val resp;
794 	DBM *fdb;
795 
796 	resp.keydat.dptr = resp.valdat.dptr = (char *)NULL;
797 	resp.keydat.dsize = resp.valdat.dsize = 0;
798 
799 	if ((fdb = ypset_current_map(req->map, req->domain,
800 					&resp.status)) != NULL) {
801 		ypfilter(fdb, (datum *) NULL, &resp.keydat, &resp.valdat,
802 				&resp.status, FALSE);
803 
804 		while (resp.status == YP_TRUE) {
805 			if (!xdr_bool(xdrs, &more)) {
806 				return (FALSE);
807 			}
808 
809 			if (!xdr_ypresp_key_val(xdrs, &resp)) {
810 				return (FALSE);
811 			}
812 
813 			ypfilter(fdb, &resp.keydat, &resp.keydat, &resp.valdat,
814 					&resp.status, FALSE);
815 		}
816 	}
817 
818 	if (!xdr_bool(xdrs, &more)) {
819 		return (FALSE);
820 	}
821 
822 	if (!xdr_ypresp_key_val(xdrs, &resp)) {
823 		return (FALSE);
824 	}
825 
826 	more = FALSE;
827 
828 	if (!xdr_bool(xdrs, &more)) {
829 		return (FALSE);
830 	}
831 
832 	return (TRUE);
833 }
834 
835 /*
836  * Additions for sparc cluster support
837  */
838 
839 /*
840  * Check for special multihomed host cookie in the key.  If there,
841  * collect the addresses from the comma separated list and return
842  * the one that's nearest the client.
843  */
844 static int
multihomed(struct ypreq_key req,struct ypresp_val * resp,SVCXPRT * xprt,DBM * fdb)845 multihomed(struct ypreq_key req, struct ypresp_val *resp,
846 		SVCXPRT *xprt, DBM *fdb)
847 {
848 	char *cp, *bp;
849 	ulong_t bestaddr, call_addr;
850 	struct netbuf *nbuf;
851 	char name[PATH_MAX];
852 	static char localbuf[_PBLKSIZ];	/* buffer for multihomed IPv6 addr */
853 
854 	if (strcmp(req.map, "hosts.byname") &&
855 			strcmp(req.map, "ipnodes.byname"))
856 		/* default status is YP_NOKEY */
857 		return (0);
858 
859 	if (strncmp(req.keydat.dptr, "YP_MULTI_", 9)) {
860 		datum tmpname;
861 
862 		strncpy(name, "YP_MULTI_", 9);
863 		strncpy(name + 9, req.keydat.dptr, req.keydat.dsize);
864 		tmpname.dsize = req.keydat.dsize + 9;
865 		tmpname.dptr = name;
866 		resp->valdat = dbm_fetch(fdb, tmpname);
867 	} else {
868 		/*
869 		 * Return whole line (for debugging) if YP_MULTI_hostnam
870 		 * is specified.
871 		 */
872 		resp->valdat = dbm_fetch(fdb, req.keydat);
873 		if (resp->valdat.dptr != NULL)
874 			return (1);
875 	}
876 
877 	if (resp->valdat.dptr == NULL)
878 		return (0);
879 
880 	strncpy(name, req.keydat.dptr, req.keydat.dsize);
881 	name[req.keydat.dsize] = NULL;
882 
883 	if (strcmp(req.map, "ipnodes.byname") == 0) {
884 		/*
885 		 * This section handles multihomed IPv6 addresses.
886 		 * It returns all the IPv6 addresses one per line and only
887 		 * the requested hostname is returned.  NO aliases will be
888 		 * returned.  This is done exactly the same way DNS forwarding
889 		 * daemon handles multihomed hosts.
890 		 * New IPv6 enabled clients should be able to handle this
891 		 * information returned.  The sorting is also the client's
892 		 * responsibility.
893 		 */
894 
895 		char *buf, *endbuf;
896 
897 		if ((buf = strdup(resp->valdat.dptr)) == NULL) /* no memory */
898 			return (0);
899 		if ((bp = strtok(buf, " \t")) == NULL) { /* no address field */
900 			free(buf);
901 			return (0);
902 		}
903 		if ((cp = strtok(NULL, "")) == NULL) { /* no host field */
904 			free(buf);
905 			return (0);
906 		}
907 		if ((cp = strtok(bp, ",")) != NULL) { /* multihomed host */
908 			int bsize;
909 
910 			localbuf[0] = '\0';
911 			bsize = sizeof (localbuf);
912 			endbuf = localbuf;
913 
914 			while (cp) {
915 				if ((strlen(cp) + strlen(name)) >= bsize) {
916 					/* out of range */
917 					break;
918 				}
919 				sprintf(endbuf, "%s %s\n", cp, name);
920 				cp = strtok(NULL, ",");
921 				endbuf = &endbuf[strlen(endbuf)];
922 				bsize = &localbuf[sizeof (localbuf)] - endbuf;
923 			}
924 			resp->valdat.dptr = localbuf;
925 			resp->valdat.dsize = strlen(localbuf);
926 		}
927 
928 		free(buf);
929 		/* remove trailing newline */
930 		if (resp->valdat.dsize &&
931 			resp->valdat.dptr[resp->valdat.dsize-1] == '\n') {
932 			resp->valdat.dptr[resp->valdat.dsize-1] = '\0';
933 			resp->valdat.dsize -= 1;
934 		}
935 
936 		resp->status = YP_TRUE;
937 		return (1);
938 	}
939 	nbuf = svc_getrpccaller(xprt);
940 	/*
941 	 * OK, now I have a netbuf structure which I'm supposed to
942 	 * treat as opaque...  I hate transport independance!
943 	 * So, we're just gonna doit wrong...  By wrong I mean that
944 	 * we assume that the buf part of the netbuf structure is going
945 	 * to be a sockaddr_in.  We'll then check the assumed family
946 	 * member and hope that we find AF_INET in there...  if not
947 	 * then we can't continue.
948 	 */
949 	if (((struct sockaddr_in *)(nbuf->buf))->sin_family != AF_INET)
950 		return (0);
951 
952 	call_addr = ((struct sockaddr_in *)(nbuf->buf))->sin_addr.s_addr;
953 
954 	cp = resp->valdat.dptr;
955 	if ((bp = strtok(cp, " \t")) == NULL) /* no address field */
956 		return (0);
957 	if ((cp = strtok(NULL, "")) == NULL)  /* no host field */
958 		return (0);
959 	bp = strtok(bp, ",");
960 
961 	bestaddr = inet_addr(bp);
962 	while (cp = strtok(NULL, ",")) {
963 		ulong_t taddr;
964 
965 		taddr = inet_addr(cp);
966 		if (ntohl(call_addr ^ taddr) < ntohl(call_addr ^ bestaddr))
967 			bestaddr = taddr;
968 	}
969 	cp = resp->valdat.dptr;
970 	sprintf(cp, "%s %s", inet_ntoa(*(struct in_addr *)&bestaddr), name);
971 	resp->valdat.dsize = strlen(cp);
972 
973 	resp->status = YP_TRUE;
974 
975 	return (1);
976 }
977 
978 /* V1 dispatch routines */
979 void
ypoldmatch(SVCXPRT * transp,struct svc_req * rqstp)980 ypoldmatch(SVCXPRT *transp, struct svc_req *rqstp)
981 {
982 	bool dbmop_ok = TRUE;
983 	struct yprequest req;
984 	struct ypreq_key nrq;
985 	struct ypresponse resp;
986 	char *fun = "ypoldmatch";
987 	DBM *fdb;
988 
989 	memset((void *) &req, 0, sizeof (req));
990 	memset((void *) &resp, 0, sizeof (resp));
991 
992 	if (!svc_getargs(transp,
993 				(xdrproc_t)_xdr_yprequest,
994 				(caddr_t)&req)) {
995 		svcerr_decode(transp);
996 		return;
997 	}
998 
999 	if (req.yp_reqtype != YPMATCH_REQTYPE) {
1000 		resp.ypmatch_resp_status = (unsigned)YP_BADARGS;
1001 		dbmop_ok = FALSE;
1002 	}
1003 
1004 	if (dbmop_ok &&
1005 		(((fdb = ypset_current_map(req.ypmatch_req_map,
1006 						req.ypmatch_req_domain,
1007 						&resp.ypmatch_resp_status))
1008 						!= NULL) &&
1009 						yp_map_access(transp,
1010 						&resp.ypmatch_resp_status,
1011 						fdb))) {
1012 
1013 		/* Check with the DBM database */
1014 		resp.ypmatch_resp_valdat = dbm_fetch(fdb,
1015 						req.ypmatch_req_keydat);
1016 
1017 		if (resp.ypmatch_resp_valptr != NULL) {
1018 			resp.ypmatch_resp_status = YP_TRUE;
1019 			if (!silent)
1020 				printf("%s: dbm: %s\n",
1021 					fun, resp.ypmatch_resp_valptr);
1022 			goto send_oldreply;
1023 		}
1024 
1025 		/*
1026 		 * If we're being asked to match YP_SECURE or YP_INTERDOMAIN
1027 		 * and we haven't found it in the dbm file, then we don't
1028 		 * really want to waste any more time.  Specifically, we don't
1029 		 * want to ask DNS
1030 		 */
1031 		if (req.ypmatch_req_keysize == 0 ||
1032 		    req.ypmatch_req_keyptr == NULL ||
1033 		    req.ypmatch_req_keyptr[0] == '\0' ||
1034 		    strncmp(req.ypmatch_req_keyptr, "YP_SECURE", 9) == 0 ||
1035 		    strncmp(req.ypmatch_req_keyptr, "YP_INTERDOMAIN", 14) == 0)
1036 
1037 		    goto send_oldreply;
1038 
1039 		/* Let's try the YP_MULTI_ hack... */
1040 #ifdef MINUS_C_OPTION
1041 		if (multiflag == TRUE && omultihomed(req, &resp, transp, fdb))
1042 			goto send_oldreply;
1043 #else
1044 		if (omultihomed(req, &resp, transp, fdb))
1045 			goto send_oldreply;
1046 #endif
1047 
1048 		/* Let's try DNS */
1049 		if (!dnsforward) {
1050 			USE_YP_INTERDOMAIN
1051 			datum idkey, idval;
1052 			idkey.dptr = yp_interdomain;
1053 			idkey.dsize = yp_interdomain_sz;
1054 			idval = dbm_fetch(fdb, idkey);
1055 			if (idval.dptr)
1056 				dnsforward = TRUE;
1057 		}
1058 
1059 		if (dnsforward) {
1060 		    if (!resolv_pid)
1061 			setup_resolv(&dnsforward, &resolv_pid, &resolv_client,
1062 					resolv_tp, 0);
1063 
1064 		    if (req.yp_reqtype == YPREQ_KEY) {
1065 			nrq = req.yp_reqbody.yp_req_keytype;
1066 
1067 			resolv_req(&dnsforward, &resolv_client, &resolv_pid,
1068 					resolv_tp, rqstp->rq_xprt,
1069 					&nrq, nrq.map);
1070 		    }
1071 		    return;
1072 		}
1073 	}
1074 
1075 	send_oldreply:
1076 
1077 	if (!svc_sendreply(transp,
1078 				(xdrproc_t)_xdr_ypresponse,
1079 				(caddr_t)&resp)) {
1080 		RESPOND_ERR;
1081 	}
1082 
1083 	if (!svc_freeargs(transp,
1084 				(xdrproc_t)_xdr_yprequest,
1085 				(char *)&req)) {
1086 		FREE_ERR;
1087 	}
1088 }
1089 
1090 void
ypoldfirst(SVCXPRT * transp)1091 ypoldfirst(SVCXPRT *transp)
1092 {
1093 	bool dbmop_ok = TRUE;
1094 	struct yprequest req;
1095 	struct ypresponse resp;
1096 	char *fun = "ypoldfirst";
1097 	DBM *fdb;
1098 
1099 	memset((void *) &req, 0, sizeof (req));
1100 	memset((void *) &resp, 0, sizeof (resp));
1101 
1102 	if (!svc_getargs(transp,
1103 				(xdrproc_t)_xdr_yprequest,
1104 				(caddr_t)&req)) {
1105 		svcerr_decode(transp);
1106 		return;
1107 	}
1108 
1109 	if (req.yp_reqtype != YPFIRST_REQTYPE) {
1110 		resp.ypfirst_resp_status = (unsigned)YP_BADARGS;
1111 		dbmop_ok = FALSE;
1112 	}
1113 
1114 	if (dbmop_ok &&
1115 		((fdb = ypset_current_map(req.ypfirst_req_map,
1116 						req.ypfirst_req_domain,
1117 						&resp.ypfirst_resp_status))
1118 						!= NULL) &&
1119 						yp_map_access(transp,
1120 						&resp.ypfirst_resp_status,
1121 						fdb)) {
1122 
1123 		resp.ypfirst_resp_keydat = dbm_firstkey(fdb);
1124 
1125 		if (resp.ypfirst_resp_keyptr != NULL) {
1126 			resp.ypfirst_resp_valdat =
1127 				dbm_fetch(fdb, resp.ypfirst_resp_keydat);
1128 
1129 			if (resp.ypfirst_resp_valptr != NULL) {
1130 				resp.ypfirst_resp_status = YP_TRUE;
1131 			} else {
1132 				resp.ypfirst_resp_status = (unsigned)YP_BADDB;
1133 			}
1134 		} else {
1135 			resp.ypfirst_resp_status = (unsigned)YP_NOKEY;
1136 		}
1137 	}
1138 
1139 	resp.yp_resptype = YPFIRST_RESPTYPE;
1140 
1141 	if (!svc_sendreply(transp,
1142 				(xdrproc_t)_xdr_ypresponse,
1143 				(caddr_t)&resp)) {
1144 		RESPOND_ERR;
1145 	}
1146 
1147 	if (!svc_freeargs(transp,
1148 				(xdrproc_t)_xdr_yprequest,
1149 				(caddr_t)&req)) {
1150 		FREE_ERR;
1151 	}
1152 }
1153 
1154 void
ypoldnext(SVCXPRT * transp)1155 ypoldnext(SVCXPRT *transp)
1156 {
1157 	bool dbmop_ok = TRUE;
1158 	struct yprequest req;
1159 	struct ypresponse resp;
1160 	char *fun = "ypoldnext";
1161 	DBM *fdb;
1162 
1163 	memset((void *) &req, 0, sizeof (req));
1164 	memset((void *) &resp, 0, sizeof (resp));
1165 
1166 	if (!svc_getargs(transp,
1167 				(xdrproc_t)_xdr_yprequest,
1168 				(caddr_t)&req)) {
1169 		svcerr_decode(transp);
1170 		return;
1171 	}
1172 
1173 	if (req.yp_reqtype != YPNEXT_REQTYPE) {
1174 		resp.ypnext_resp_status = (unsigned)YP_BADARGS;
1175 		dbmop_ok = FALSE;
1176 	}
1177 
1178 	if (dbmop_ok &&
1179 		((fdb = ypset_current_map(req.ypnext_req_map,
1180 					req.ypnext_req_domain,
1181 					&resp.ypnext_resp_status)) != NULL &&
1182 		yp_map_access(transp, &resp.ypnext_resp_status, fdb))) {
1183 
1184 		resp.ypnext_resp_keydat = dbm_nextkey(fdb);
1185 
1186 		if (resp.ypnext_resp_keyptr != NULL) {
1187 			resp.ypnext_resp_valdat =
1188 			dbm_fetch(fdb, resp.ypnext_resp_keydat);
1189 
1190 			if (resp.ypnext_resp_valptr != NULL) {
1191 				resp.ypnext_resp_status = YP_TRUE;
1192 			} else {
1193 				resp.ypnext_resp_status = (unsigned)YP_BADDB;
1194 			}
1195 		} else {
1196 			resp.ypnext_resp_status = (unsigned)YP_NOMORE;
1197 		}
1198 	}
1199 
1200 	resp.yp_resptype = YPNEXT_RESPTYPE;
1201 
1202 	if (!svc_sendreply(transp,
1203 				(xdrproc_t)_xdr_ypresponse,
1204 				(caddr_t)&resp)) {
1205 		RESPOND_ERR;
1206 	}
1207 
1208 	if (!svc_freeargs(transp,
1209 				(xdrproc_t)_xdr_yprequest,
1210 				(caddr_t)&req)) {
1211 		FREE_ERR;
1212 	}
1213 }
1214 
1215 /*
1216  * This retrieves the order number and master peer name from the map.
1217  * The conditions for the various message fields are: domain is filled
1218  * in iff the domain exists.  map is filled in iff the map exists.
1219  * order number is filled in iff it's in the map.  owner is filled in
1220  * iff the master peer is in the map.
1221  */
1222 void
ypoldpoll(SVCXPRT * transp)1223 ypoldpoll(SVCXPRT *transp)
1224 {
1225 	struct yprequest req;
1226 	struct ypresponse resp;
1227 	char *map = "";
1228 	char *domain = "";
1229 	char *owner = "";
1230 	uint_t error;
1231 	char *fun = "ypoldpoll";
1232 	DBM *fdb;
1233 
1234 	memset((void *) &req, 0, sizeof (req));
1235 	memset((void *) &resp, 0, sizeof (resp));
1236 
1237 	if (!svc_getargs(transp,
1238 				(xdrproc_t)_xdr_yprequest,
1239 				(caddr_t)&req)) {
1240 		svcerr_decode(transp);
1241 		return;
1242 	}
1243 
1244 	if (req.yp_reqtype == YPPOLL_REQTYPE) {
1245 		if (strcmp(req.yppoll_req_domain, "yp_private") == 0 ||
1246 			strcmp(req.yppoll_req_map, "ypdomains") == 0 ||
1247 			strcmp(req.yppoll_req_map, "ypmaps") == 0) {
1248 
1249 			/*
1250 			 * Backward comatibility for 2.0 NIS servers
1251 			 */
1252 			domain = req.yppoll_req_domain;
1253 			map = req.yppoll_req_map;
1254 		} else if ((fdb = ypset_current_map(req.yppoll_req_map,
1255 				req.yppoll_req_domain,
1256 				&error)) != NULL) {
1257 			domain = req.yppoll_req_domain;
1258 			map = req.yppoll_req_map;
1259 			ypget_map_order(map, domain,
1260 					&resp.yppoll_resp_ordernum);
1261 			ypget_map_master(&owner, fdb);
1262 		} else {
1263 			switch ((int)error) {
1264 			case YP_BADDB:
1265 				map = req.yppoll_req_map;
1266 				/* Fall through to set the domain too. */
1267 
1268 			case YP_NOMAP:
1269 				domain = req.yppoll_req_domain;
1270 				break;
1271 			}
1272 		}
1273 	}
1274 
1275 	resp.yp_resptype = YPPOLL_RESPTYPE;
1276 	resp.yppoll_resp_domain = domain;
1277 	resp.yppoll_resp_map = map;
1278 	resp.yppoll_resp_owner = owner;
1279 
1280 	if (!svc_sendreply(transp,
1281 				(xdrproc_t)_xdr_ypresponse,
1282 				(caddr_t)&resp)) {
1283 		RESPOND_ERR;
1284 	}
1285 
1286 	if (!svc_freeargs(transp,
1287 				(xdrproc_t)_xdr_yprequest,
1288 				(caddr_t)&req)) {
1289 		FREE_ERR;
1290 	}
1291 }
1292 
1293 void
ypoldpush(SVCXPRT * transp)1294 ypoldpush(SVCXPRT *transp)
1295 {
1296 	struct yprequest req;
1297 	struct ypresp_val resp;
1298 	pid_t pid = -1;
1299 	char *fun = "ypoldpush";
1300 	DBM *fdb;
1301 
1302 	memset((void *) &req, 0, sizeof (req));
1303 
1304 	if (!svc_getargs(transp,
1305 				(xdrproc_t)_xdr_yprequest,
1306 				(caddr_t)&req)) {
1307 		svcerr_decode(transp);
1308 		return;
1309 	}
1310 
1311 	if (((fdb = ypset_current_map(req.yppush_req_map,
1312 					req.yppush_req_domain,
1313 					&resp.status)) != NULL) &&
1314 		(yp_map_access(transp, &resp.status, fdb))) {
1315 
1316 		pid = vfork();
1317 	}
1318 
1319 	if (pid == -1) {
1320 		FORK_ERR;
1321 	} else if (pid == 0) {
1322 		ypclr_current_map();
1323 
1324 		if (execl(yppush_proc, "yppush", "-d", req.yppush_req_domain,
1325 				req.yppush_req_map, NULL)) {
1326 			EXEC_ERR;
1327 		}
1328 		_exit(1);
1329 	}
1330 
1331 	if (!svc_sendreply(transp,
1332 				(xdrproc_t)xdr_void,
1333 				(caddr_t)NULL)) {
1334 		RESPOND_ERR;
1335 	}
1336 
1337 	if (!svc_freeargs(transp,
1338 				(xdrproc_t)_xdr_yprequest,
1339 				(caddr_t)&req)) {
1340 		FREE_ERR;
1341 	}
1342 }
1343 
1344 void
ypoldpull(SVCXPRT * transp)1345 ypoldpull(SVCXPRT *transp)
1346 {
1347 	struct yprequest req;
1348 	struct ypresp_val resp;
1349 	pid_t pid = -1;
1350 	char *fun = "ypoldpull";
1351 	DBM *fdb;
1352 
1353 	memset((void *) &req, 0, sizeof (req));
1354 
1355 	if (!svc_getargs(transp,
1356 				(xdrproc_t)_xdr_yprequest,
1357 				(caddr_t)&req)) {
1358 		svcerr_decode(transp);
1359 		return;
1360 	}
1361 
1362 	if (req.yp_reqtype == YPPULL_REQTYPE) {
1363 
1364 		if (((fdb = ypset_current_map(req.yppull_req_map,
1365 						req.yppull_req_domain,
1366 						&resp.status)) == NULL) ||
1367 			(yp_map_access(transp, &resp.status, fdb))) {
1368 			pid = vfork();
1369 		}
1370 
1371 		if (pid == -1) {
1372 			FORK_ERR;
1373 		} else if (pid == 0) {
1374 			ypclr_current_map();
1375 
1376 			if (execl(ypxfr_proc, "ypxfr", "-d",
1377 					req.yppull_req_domain,
1378 					req.yppull_req_map, NULL)) {
1379 				EXEC_ERR;
1380 			}
1381 			_exit(1);
1382 		}
1383 	}
1384 
1385 	if (!svc_freeargs(transp,
1386 				(xdrproc_t)_xdr_yprequest,
1387 				(caddr_t)&req)) {
1388 		FREE_ERR;
1389 	}
1390 }
1391 
1392 void
ypoldget(SVCXPRT * transp)1393 ypoldget(SVCXPRT *transp)
1394 {
1395 	struct yprequest req;
1396 	struct ypresp_val resp;
1397 	pid_t pid = -1;
1398 	char *fun = "ypoldget";
1399 	DBM *fdb;
1400 
1401 	memset((void *) &req, 0, sizeof (req));
1402 
1403 	if (!svc_getargs(transp,
1404 				(xdrproc_t)_xdr_yprequest,
1405 				(caddr_t)&req)) {
1406 		svcerr_decode(transp);
1407 		return;
1408 	}
1409 
1410 	if (!svc_sendreply(transp, xdr_void, 0)) {
1411 		RESPOND_ERR;
1412 	}
1413 
1414 	if (req.yp_reqtype == YPGET_REQTYPE) {
1415 
1416 		if (((fdb = ypset_current_map(req.ypget_req_map,
1417 						req.ypget_req_domain,
1418 						&resp.status)) == NULL) ||
1419 			(yp_map_access(transp, &resp.status, fdb))) {
1420 
1421 			pid = vfork();
1422 		}
1423 
1424 		if (pid == -1) {
1425 			FORK_ERR;
1426 		} else if (pid == 0) {
1427 
1428 			ypclr_current_map();
1429 
1430 			if (execl(ypxfr_proc, "ypxfr", "-d",
1431 					req.ypget_req_domain, "-h",
1432 					req.ypget_req_owner,
1433 					req.ypget_req_map, NULL)) {
1434 
1435 				EXEC_ERR;
1436 			}
1437 			_exit(1);
1438 		}
1439 	}
1440 
1441 	if (!svc_freeargs(transp,
1442 				(xdrproc_t)_xdr_yprequest,
1443 				(caddr_t)&req)) {
1444 		RESPOND_ERR;
1445 	}
1446 }
1447 
1448 static int
omultihomed(struct yprequest req,struct ypresponse * resp,SVCXPRT * xprt,DBM * fdb)1449 omultihomed(struct yprequest req,
1450 	    struct ypresponse *resp, SVCXPRT *xprt, DBM *fdb)
1451 {
1452 	char *cp, *bp;
1453 	char name[PATH_MAX];
1454 	struct netbuf *nbuf;
1455 	ulong_t bestaddr, call_addr;
1456 
1457 	if (strcmp(req.ypmatch_req_map, "hosts.byname"))
1458 		return (0);
1459 
1460 	if (strncmp(req.ypmatch_req_keyptr, "YP_MULTI_", 9)) {
1461 		datum tmpname;
1462 
1463 		strncpy(name, "YP_MULTI_", 9);
1464 		strncpy(name + 9, req.ypmatch_req_keyptr,
1465 			req.ypmatch_req_keysize);
1466 		tmpname.dsize = req.ypmatch_req_keysize + 9;
1467 		tmpname.dptr = name;
1468 		resp->ypmatch_resp_valdat = dbm_fetch(fdb, tmpname);
1469 	} else {
1470 		resp->ypmatch_resp_valdat =
1471 			dbm_fetch(fdb, req.ypmatch_req_keydat);
1472 		if (resp->ypmatch_resp_valptr != NULL)
1473 			return (1);
1474 	}
1475 
1476 	if (resp->ypmatch_resp_valptr == NULL)
1477 		return (0);
1478 
1479 	strncpy(name, req.ypmatch_req_keyptr, req.ypmatch_req_keysize);
1480 	name[req.ypmatch_req_keysize] = NULL;
1481 
1482 	nbuf = svc_getrpccaller(xprt);
1483 
1484 	/*
1485 	 * OK, now I have a netbuf structure which I'm supposed to treat
1486 	 * as opaque...  I hate transport independance!  So, we're just
1487 	 * gonna doit wrong...  By wrong I mean that we assume that the
1488 	 * buf part of the netbuf structure is going to be a sockaddr_in.
1489 	 * We'll then check the assumed family member and hope that we
1490 	 * find AF_INET in there...  if not then we can't continue.
1491 	 */
1492 	if (((struct sockaddr_in *)(nbuf->buf))->sin_family != AF_INET)
1493 		return (0);
1494 
1495 	call_addr = ((struct sockaddr_in *)(nbuf->buf))->sin_addr.s_addr;
1496 
1497 	cp = resp->ypmatch_resp_valptr;
1498 	if ((bp = strtok(cp, "\t")) == NULL)	/* No address field */
1499 		return (0);
1500 	if ((cp = strtok(NULL, "")) == NULL)	/* No host field */
1501 		return (0);
1502 	bp = strtok(bp, ",");
1503 
1504 	bestaddr = inet_addr(bp);
1505 	while (cp = strtok(NULL, ",")) {
1506 		ulong_t taddr;
1507 
1508 		taddr = inet_addr(cp);
1509 		if (ntohl(call_addr ^ taddr) < ntohl(call_addr ^ bestaddr))
1510 			bestaddr = taddr;
1511 	}
1512 
1513 	cp = resp->ypmatch_resp_valptr;
1514 	sprintf(cp, "%s %s", inet_ntoa(*(struct in_addr *)&bestaddr), name);
1515 	resp->ypmatch_resp_valsize = strlen(cp);
1516 
1517 	resp->ypmatch_resp_status = YP_TRUE;
1518 
1519 	return (1);
1520 }
1521