3 * Bill Paul <wpaul@ctr.columbia.edu>. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
32 * $FreeBSD: src/usr.sbin/ypserv/yp_server.c,v 1.31.2.1 2002/02/15 00:47:00 des Exp $
33 * $DragonFly: src/usr.sbin/ypserv/yp_server.c,v 1.3 2004/03/31 23:20:22 cpressey Exp $
37 #include "yp_extern.h"
42 #include <sys/param.h>
43 #include <sys/types.h>
44 #include <sys/socket.h>
45 #include <netinet/in.h>
46 #include <arpa/inet.h>
51 #define MASTER_STRING "YP_MASTER_NAME"
52 #define MASTER_SZ sizeof(MASTER_STRING) - 1
53 #define ORDER_STRING "YP_LAST_MODIFIED"
54 #define ORDER_SZ sizeof(ORDER_STRING) - 1
59 if (yp_pid != getpid()) {
60 yp_error("child %d trying to fork!", getpid());
69 * NIS v2 support. This is where most of the action happens.
73 ypproc_null_2_svc(void *argp, struct svc_req *rqstp)
79 if (yp_access(NULL, NULL, (struct svc_req *)rqstp))
81 if (yp_access(NULL, (struct svc_req *)rqstp))
87 return((void *) &result);
91 ypproc_domain_2_svc(domainname *argp, struct svc_req *rqstp)
96 if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) {
98 if (yp_access(NULL, (struct svc_req *)rqstp)) {
104 if (argp == NULL || yp_validdomain(*argp))
113 ypproc_domain_nonack_2_svc(domainname *argp, struct svc_req *rqstp)
115 static bool_t result;
118 if (yp_access(NULL, NULL, (struct svc_req *)rqstp))
120 if (yp_access(NULL, (struct svc_req *)rqstp))
124 if (argp == NULL || yp_validdomain(*argp))
133 ypproc_match_2_svc(ypreq_key *argp, struct svc_req *rqstp)
135 static ypresp_val result;
137 result.val.valdat_val = "";
138 result.val.valdat_len = 0;
141 if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
143 if (yp_access(argp->map, (struct svc_req *)rqstp)) {
145 result.stat = YP_YPERR;
149 if (argp->domain == NULL || argp->map == NULL) {
150 result.stat = YP_BADARGS;
154 if (yp_select_map(argp->map, argp->domain, NULL, 1) != YP_TRUE) {
155 result.stat = yp_errno;
159 result.stat = yp_getbykey(&argp->key, &result.val);
162 * Do DNS lookups for hosts maps if database lookup failed.
166 if (result.stat != YP_TRUE &&
167 (yp_testflag(argp->map, argp->domain, YP_INTERDOMAIN) ||
168 (strstr(argp->map, "hosts") && do_dns))) {
170 if (do_dns && result.stat != YP_TRUE && strstr(argp->map, "hosts")) {
172 char nbuf[YPMAXRECORD];
174 /* NUL terminate! NUL terminate!! NUL TERMINATE!!! */
175 bcopy(argp->key.keydat_val, nbuf, argp->key.keydat_len);
176 nbuf[argp->key.keydat_len] = '\0';
179 yp_error("doing DNS lookup of %s", nbuf);
181 if (!strcmp(argp->map, "hosts.byname"))
182 result.stat = yp_async_lookup_name(rqstp, nbuf);
183 else if (!strcmp(argp->map, "hosts.byaddr"))
184 result.stat = yp_async_lookup_addr(rqstp, nbuf);
186 if (result.stat == YP_TRUE)
194 ypproc_first_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
196 static ypresp_key_val result;
198 result.val.valdat_val = result.key.keydat_val = "";
199 result.val.valdat_len = result.key.keydat_len = 0;
202 if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
204 if (yp_access(argp->map, (struct svc_req *)rqstp)) {
206 result.stat = YP_YPERR;
210 if (argp->domain == NULL) {
211 result.stat = YP_BADARGS;
215 if (yp_select_map(argp->map, argp->domain, NULL, 0) != YP_TRUE) {
216 result.stat = yp_errno;
220 result.stat = yp_firstbykey(&result.key, &result.val);
226 ypproc_next_2_svc(ypreq_key *argp, struct svc_req *rqstp)
228 static ypresp_key_val result;
230 result.val.valdat_val = result.key.keydat_val = "";
231 result.val.valdat_len = result.key.keydat_len = 0;
234 if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
236 if (yp_access(argp->map, (struct svc_req *)rqstp)) {
238 result.stat = YP_YPERR;
242 if (argp->domain == NULL || argp->map == NULL) {
243 result.stat = YP_BADARGS;
247 if (yp_select_map(argp->map, argp->domain, &argp->key, 0) != YP_TRUE) {
248 result.stat = yp_errno;
252 result.key.keydat_len = argp->key.keydat_len;
253 result.key.keydat_val = argp->key.keydat_val;
255 result.stat = yp_nextbykey(&result.key, &result.val);
260 static void ypxfr_callback(rval,addr,transid,prognum,port)
262 struct sockaddr_in *addr;
263 unsigned int transid;
264 unsigned int prognum;
268 int sock = RPC_ANYSOCK;
269 struct timeval timeout;
270 yppushresp_xfr ypxfr_resp;
275 addr->sin_port = htons(port);
277 if ((clnt = clntudp_create(addr,prognum,1,timeout,&sock)) == NULL) {
278 yp_error("%s: %s", inet_ntoa(addr->sin_addr),
279 clnt_spcreateerror("failed to establish callback handle"));
283 ypxfr_resp.status = rval;
284 ypxfr_resp.transid = transid;
286 /* Turn the timeout off -- we don't want to block. */
288 if (clnt_control(clnt, CLSET_TIMEOUT, (char *)&timeout) == FALSE)
289 yp_error("failed to set timeout on ypproc_xfr callback");
291 if (yppushproc_xfrresp_1(&ypxfr_resp, clnt) == NULL) {
292 clnt_geterr(clnt, &err);
293 if (err.re_status != RPC_SUCCESS &&
294 err.re_status != RPC_TIMEDOUT)
295 yp_error("%s", clnt_sperror(clnt,
296 "ypxfr callback failed"));
303 #define YPXFR_RETURN(CODE) \
304 /* Order is important: send regular RPC reply, then callback */ \
305 result.xfrstat = CODE; \
306 svc_sendreply(rqstp->rq_xprt, xdr_ypresp_xfr, (char *)&result); \
307 ypxfr_callback(CODE,rqhost,argp->transid, \
308 argp->prog,argp->port); \
312 ypproc_xfr_2_svc(ypreq_xfr *argp, struct svc_req *rqstp)
314 static ypresp_xfr result;
315 struct sockaddr_in *rqhost;
319 result.transid = argp->transid;
320 rqhost = svc_getcaller(rqstp->rq_xprt);
323 if (yp_access(argp->map_parms.map,
324 argp->map_parms.domain, (struct svc_req *)rqstp)) {
326 if (yp_access(argp->map_parms.map, (struct svc_req *)rqstp)) {
328 YPXFR_RETURN(YPXFR_REFUSED)
332 if (argp->map_parms.domain == NULL) {
333 YPXFR_RETURN(YPXFR_BADARGS)
336 if (yp_validdomain(argp->map_parms.domain)) {
337 YPXFR_RETURN(YPXFR_NODOM)
341 * Determine the master host ourselves. The caller may
342 * be up to no good. This has the side effect of verifying
343 * that the requested map and domain actually exist.
346 mreq.domain = argp->map_parms.domain;
347 mreq.map = argp->map_parms.map;
349 mres = ypproc_master_2_svc(&mreq, rqstp);
351 if (mres->stat != YP_TRUE) {
352 yp_error("couldn't find master for map %s@%s",
354 argp->map_parms.domain);
355 yp_error("host at %s (%s) may be pulling my leg",
356 argp->map_parms.peer,
357 inet_ntoa(rqhost->sin_addr));
358 YPXFR_RETURN(YPXFR_REFUSED)
364 char g[11], t[11], p[11];
365 char ypxfr_command[MAXPATHLEN + 2];
367 sprintf (ypxfr_command, "%sypxfr", _PATH_LIBEXEC);
368 sprintf (t, "%u", argp->transid);
369 sprintf (g, "%u", argp->prog);
370 sprintf (p, "%u", argp->port);
372 close(0); close(1); close(2);
374 if (strcmp(yp_dir, _PATH_YP)) {
375 execl(ypxfr_command, "ypxfr",
376 "-d", argp->map_parms.domain,
378 "-p", yp_dir, "-C", t,
379 g, inet_ntoa(rqhost->sin_addr),
380 p, argp->map_parms.map,
383 execl(ypxfr_command, "ypxfr",
384 "-d", argp->map_parms.domain,
387 g, inet_ntoa(rqhost->sin_addr),
388 p, argp->map_parms.map,
391 yp_error("ypxfr execl(%s): %s", ypxfr_command, strerror(errno));
392 YPXFR_RETURN(YPXFR_XFRERR)
394 * Just to safe, prevent PR #10970 from biting us in
395 * the unlikely case that execing ypxfr fails. We don't
396 * want to have any child processes spawned from this
403 yp_error("ypxfr fork(): %s", strerror(errno));
404 YPXFR_RETURN(YPXFR_XFRERR)
407 result.xfrstat = YPXFR_SUCC;
417 ypproc_clear_2_svc(void *argp, struct svc_req *rqstp)
419 static char * result;
420 static char rval = 0;
423 if (yp_access(NULL, NULL, (struct svc_req *)rqstp))
425 if (yp_access(NULL, (struct svc_req *)rqstp))
429 /* clear out the database cache */
432 /* Re-read the securenets database for the hell of it. */
436 return((void *) &result);
440 * For ypproc_all, we have to send a stream of ypresp_all structures
441 * via TCP, but the XDR filter generated from the yp.x protocol
442 * definition file only serializes one such structure. This means that
443 * to send the whole stream, you need a wrapper which feeds all the
444 * records into the underlying XDR routine until it hits an 'EOF.'
445 * But to use the wrapper, you have to violate the boundaries between
446 * RPC layers by calling svc_sendreply() directly from the ypproc_all
447 * service routine instead of letting the RPC dispatcher do it.
453 * Custom XDR routine for serialzing results of ypproc_all: keep
454 * reading from the database and spew until we run out of records
455 * or encounter an error.
458 xdr_my_ypresp_all(XDR *xdrs, ypresp_all *objp)
462 if ((objp->ypresp_all_u.val.stat =
463 yp_nextbykey(&objp->ypresp_all_u.val.key,
464 &objp->ypresp_all_u.val.val)) == YP_TRUE) {
471 if (!xdr_ypresp_all(xdrs, objp))
473 if (objp->more == FALSE)
479 ypproc_all_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
481 static ypresp_all result;
484 * Set this here so that the client will be forced to make
485 * at least one attempt to read from us even if all we're
486 * doing is returning an error.
489 result.ypresp_all_u.val.key.keydat_len = 0;
490 result.ypresp_all_u.val.key.keydat_val = "";
493 if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
495 if (yp_access(argp->map, (struct svc_req *)rqstp)) {
497 result.ypresp_all_u.val.stat = YP_YPERR;
501 if (argp->domain == NULL || argp->map == NULL) {
502 result.ypresp_all_u.val.stat = YP_BADARGS;
507 * XXX If we hit the child limit, fail the request.
508 * If we don't, and the map is large, we could block for
509 * a long time in the parent.
511 if (children >= MAX_CHILDREN) {
512 result.ypresp_all_u.val.stat = YP_YPERR;
517 * The ypproc_all procedure can take a while to complete.
518 * Best to handle it in a subprocess so the parent doesn't
519 * block. (Is there a better way to do this? Maybe with
527 yp_error("ypall fork(): %s", strerror(errno));
528 result.ypresp_all_u.val.stat = YP_YPERR;
539 * Fix for PR #10971: don't let the child ypserv share
540 * DB handles with the parent process.
546 if (yp_select_map(argp->map, argp->domain,
547 &result.ypresp_all_u.val.key, 0) != YP_TRUE) {
548 result.ypresp_all_u.val.stat = yp_errno;
552 /* Kick off the actual data transfer. */
553 svc_sendreply(rqstp->rq_xprt, xdr_my_ypresp_all, (char *)&result);
556 * Proper fix for PR #10970: exit here so that we don't risk
557 * having a child spawned from this sub-process.
563 ypproc_master_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
565 static ypresp_master result;
566 static char ypvalbuf[YPMAXRECORD];
567 keydat key = { MASTER_SZ, MASTER_STRING };
573 if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
575 if (yp_access(argp->map, (struct svc_req *)rqstp)) {
577 result.stat = YP_YPERR;
581 if (argp->domain == NULL) {
582 result.stat = YP_BADARGS;
586 if (yp_select_map(argp->map, argp->domain, &key, 1) != YP_TRUE) {
587 result.stat = yp_errno;
592 * Note that we copy the data retrieved from the database to
593 * a private buffer and NUL terminate the buffer rather than
594 * terminating the data in place. We do this because by stuffing
595 * a '\0' into data.data, we will actually be corrupting memory
596 * allocated by the DB package. This is a bad thing now that we
597 * cache DB handles rather than closing the database immediately.
599 result.stat = yp_getbykey(&key, &val);
600 if (result.stat == YP_TRUE) {
601 bcopy((char *)val.valdat_val, (char *)&ypvalbuf,
603 ypvalbuf[val.valdat_len] = '\0';
604 result.peer = (char *)&ypvalbuf;
612 ypproc_order_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
614 static ypresp_order result;
615 keydat key = { ORDER_SZ, ORDER_STRING };
621 if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
623 if (yp_access(argp->map, (struct svc_req *)rqstp)) {
625 result.stat = YP_YPERR;
629 if (argp->domain == NULL) {
630 result.stat = YP_BADARGS;
635 * We could just check the timestamp on the map file,
636 * but that's a hack: we'll only know the last time the file
637 * was touched, not the last time the database contents were
641 if (yp_select_map(argp->map, argp->domain, &key, 1) != YP_TRUE) {
642 result.stat = yp_errno;
646 result.stat = yp_getbykey(&key, &val);
648 if (result.stat == YP_TRUE)
649 result.ordernum = atoi((char *)val.valdat_val);
656 static void yp_maplist_free(struct ypmaplist *yp_maplist)
658 struct ypmaplist *next;
661 next = yp_maplist->next;
662 free(yp_maplist->map);
669 static struct ypmaplist *yp_maplist_create(const char *domain)
671 char yp_mapdir[MAXPATHLEN + 2];
672 char yp_mapname[MAXPATHLEN + 2];
673 struct ypmaplist *cur = NULL;
674 struct ypmaplist *yp_maplist = NULL;
679 snprintf(yp_mapdir, sizeof(yp_mapdir), "%s/%s", yp_dir, domain);
681 if ((dird = opendir(yp_mapdir)) == NULL) {
682 yp_error("opendir(%s) failed: %s", yp_mapdir, strerror(errno));
686 while ((dirp = readdir(dird)) != NULL) {
687 if (strcmp(dirp->d_name, ".") && strcmp(dirp->d_name, "..")) {
688 snprintf(yp_mapname, sizeof(yp_mapname), "%s/%s",
689 yp_mapdir,dirp->d_name);
690 if (stat(yp_mapname, &statbuf) < 0 ||
691 !S_ISREG(statbuf.st_mode))
693 if ((cur = (struct ypmaplist *)
694 malloc(sizeof(struct ypmaplist))) == NULL) {
695 yp_error("malloc() failed");
697 yp_maplist_free(yp_maplist);
700 if ((cur->map = (char *)strdup(dirp->d_name)) == NULL) {
701 yp_error("strdup() failed: %s",strerror(errno));
703 yp_maplist_free(yp_maplist);
706 cur->next = yp_maplist;
709 yp_error("map: %s", yp_maplist->map);
718 ypproc_maplist_2_svc(domainname *argp, struct svc_req *rqstp)
720 static ypresp_maplist result = { 0, NULL };
723 if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) {
725 if (yp_access(NULL, (struct svc_req *)rqstp)) {
727 result.stat = YP_YPERR;
732 result.stat = YP_BADARGS;
736 if (yp_validdomain(*argp)) {
737 result.stat = YP_NODOM;
742 * We have to construct a linked list for the ypproc_maplist
743 * procedure using dynamically allocated memory. Since the XDR
744 * layer won't free this list for us, we have to deal with it
745 * ourselves. We call yp_maplist_free() first to free any
746 * previously allocated data we may have accumulated to insure
747 * that we have only one linked list in memory at any given
751 yp_maplist_free(result.maps);
753 if ((result.maps = yp_maplist_create(*argp)) == NULL) {
754 yp_error("yp_maplist_create failed");
755 result.stat = YP_YPERR;
758 result.stat = YP_TRUE;
764 * NIS v1 support. The nullproc, domain and domain_nonack
765 * functions from v1 are identical to those in v2, so all
766 * we have to do is hand off to them.
768 * The other functions are mostly just wrappers around their v2
769 * counterparts. For example, for the v1 'match' procedure, we
770 * crack open the argument structure, make a request to the v2
771 * 'match' function, repackage the data into a v1 response and
772 * then send it on its way.
774 * Note that we don't support the pull, push and get procedures.
775 * There's little documentation available to show what they
776 * do, and I suspect they're meant largely for map transfers
777 * between master and slave servers.
781 ypoldproc_null_1_svc(void *argp, struct svc_req *rqstp)
783 return(ypproc_null_2_svc(argp, rqstp));
787 ypoldproc_domain_1_svc(domainname *argp, struct svc_req *rqstp)
789 return(ypproc_domain_2_svc(argp, rqstp));
793 ypoldproc_domain_nonack_1_svc(domainname *argp, struct svc_req *rqstp)
795 return (ypproc_domain_nonack_2_svc(argp, rqstp));
799 * the 'match' procedure sends a response of type YPRESP_VAL
802 ypoldproc_match_1_svc(yprequest *argp, struct svc_req *rqstp)
804 static ypresponse result;
805 ypresp_val *v2_result;
807 result.yp_resptype = YPRESP_VAL;
808 result.ypresponse_u.yp_resp_valtype.val.valdat_val = "";
809 result.ypresponse_u.yp_resp_valtype.val.valdat_len = 0;
811 if (argp->yp_reqtype != YPREQ_KEY) {
812 result.ypresponse_u.yp_resp_valtype.stat = YP_BADARGS;
816 v2_result = ypproc_match_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp);
817 if (v2_result == NULL)
820 bcopy((char *)v2_result,
821 (char *)&result.ypresponse_u.yp_resp_valtype,
828 * the 'first' procedure sends a response of type YPRESP_KEY_VAL
831 ypoldproc_first_1_svc(yprequest *argp, struct svc_req *rqstp)
833 static ypresponse result;
834 ypresp_key_val *v2_result;
836 result.yp_resptype = YPRESP_KEY_VAL;
837 result.ypresponse_u.yp_resp_key_valtype.val.valdat_val =
838 result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = "";
839 result.ypresponse_u.yp_resp_key_valtype.val.valdat_len =
840 result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0;
842 if (argp->yp_reqtype != YPREQ_NOKEY) {
843 result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS;
847 v2_result = ypproc_first_2_svc(&argp->yprequest_u.yp_req_nokeytype,
849 if (v2_result == NULL)
852 bcopy((char *)v2_result,
853 (char *)&result.ypresponse_u.yp_resp_key_valtype,
854 sizeof(ypresp_key_val));
860 * the 'next' procedure sends a response of type YPRESP_KEY_VAL
863 ypoldproc_next_1_svc(yprequest *argp, struct svc_req *rqstp)
865 static ypresponse result;
866 ypresp_key_val *v2_result;
868 result.yp_resptype = YPRESP_KEY_VAL;
869 result.ypresponse_u.yp_resp_key_valtype.val.valdat_val =
870 result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = "";
871 result.ypresponse_u.yp_resp_key_valtype.val.valdat_len =
872 result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0;
874 if (argp->yp_reqtype != YPREQ_KEY) {
875 result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS;
879 v2_result = ypproc_next_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp);
880 if (v2_result == NULL)
883 bcopy((char *)v2_result,
884 (char *)&result.ypresponse_u.yp_resp_key_valtype,
885 sizeof(ypresp_key_val));
891 * the 'poll' procedure sends a response of type YPRESP_MAP_PARMS
894 ypoldproc_poll_1_svc(yprequest *argp, struct svc_req *rqstp)
896 static ypresponse result;
897 ypresp_master *v2_result1;
898 ypresp_order *v2_result2;
900 result.yp_resptype = YPRESP_MAP_PARMS;
901 result.ypresponse_u.yp_resp_map_parmstype.domain =
902 argp->yprequest_u.yp_req_nokeytype.domain;
903 result.ypresponse_u.yp_resp_map_parmstype.map =
904 argp->yprequest_u.yp_req_nokeytype.map;
906 * Hmm... there is no 'status' value in the
907 * yp_resp_map_parmstype structure, so I have to
908 * guess at what to do to indicate a failure.
909 * I hope this is right.
911 result.ypresponse_u.yp_resp_map_parmstype.ordernum = 0;
912 result.ypresponse_u.yp_resp_map_parmstype.peer = "";
914 if (argp->yp_reqtype != YPREQ_MAP_PARMS) {
918 v2_result1 = ypproc_master_2_svc(&argp->yprequest_u.yp_req_nokeytype,
920 if (v2_result1 == NULL)
923 if (v2_result1->stat != YP_TRUE) {
927 v2_result2 = ypproc_order_2_svc(&argp->yprequest_u.yp_req_nokeytype,
929 if (v2_result2 == NULL)
932 if (v2_result2->stat != YP_TRUE) {
936 result.ypresponse_u.yp_resp_map_parmstype.peer =
938 result.ypresponse_u.yp_resp_map_parmstype.ordernum =
939 v2_result2->ordernum;
945 ypoldproc_push_1_svc(yprequest *argp, struct svc_req *rqstp)
947 static ypresponse result;
957 ypoldproc_pull_1_svc(yprequest *argp, struct svc_req *rqstp)
959 static ypresponse result;
969 ypoldproc_get_1_svc(yprequest *argp, struct svc_req *rqstp)
971 static ypresponse result;