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.40 2006/06/09 14:01:07 maxim Exp $
36 #include "yp_extern.h"
41 #include <sys/param.h>
42 #include <sys/types.h>
43 #include <sys/socket.h>
44 #include <netinet/in.h>
45 #include <arpa/inet.h>
50 #define MASTER_STRING "YP_MASTER_NAME"
51 #define MASTER_SZ sizeof(MASTER_STRING) - 1
52 #define ORDER_STRING "YP_LAST_MODIFIED"
53 #define ORDER_SZ sizeof(ORDER_STRING) - 1
58 if (yp_pid
!= getpid()) {
59 yp_error("child %d trying to fork!", getpid());
68 * NIS v2 support. This is where most of the action happens.
72 ypproc_null_2_svc(void *argp
, struct svc_req
*rqstp
)
78 if (yp_access(NULL
, NULL
, (struct svc_req
*)rqstp
))
80 if (yp_access(NULL
, (struct svc_req
*)rqstp
))
86 return((void *) &result
);
90 ypproc_domain_2_svc(domainname
*argp
, struct svc_req
*rqstp
)
95 if (yp_access(NULL
, NULL
, (struct svc_req
*)rqstp
)) {
97 if (yp_access(NULL
, (struct svc_req
*)rqstp
)) {
103 if (argp
== NULL
|| yp_validdomain(*argp
))
112 ypproc_domain_nonack_2_svc(domainname
*argp
, struct svc_req
*rqstp
)
114 static bool_t result
;
117 if (yp_access(NULL
, NULL
, (struct svc_req
*)rqstp
))
119 if (yp_access(NULL
, (struct svc_req
*)rqstp
))
123 if (argp
== NULL
|| yp_validdomain(*argp
))
132 ypproc_match_2_svc(ypreq_key
*argp
, struct svc_req
*rqstp
)
134 static ypresp_val result
;
136 result
.val
.valdat_val
= "";
137 result
.val
.valdat_len
= 0;
140 if (yp_access(argp
->map
, argp
->domain
, (struct svc_req
*)rqstp
)) {
142 if (yp_access(argp
->map
, (struct svc_req
*)rqstp
)) {
144 result
.stat
= YP_YPERR
;
148 if (argp
->domain
== NULL
|| argp
->map
== NULL
) {
149 result
.stat
= YP_BADARGS
;
153 if (yp_select_map(argp
->map
, argp
->domain
, NULL
, 1) != YP_TRUE
) {
154 result
.stat
= yp_errno
;
158 result
.stat
= yp_getbykey(&argp
->key
, &result
.val
);
161 * Do DNS lookups for hosts maps if database lookup failed.
165 if (do_dns
&& result
.stat
!= YP_TRUE
&&
166 (yp_testflag(argp
->map
, argp
->domain
, YP_INTERDOMAIN
) ||
167 (strstr(argp
->map
, "hosts") || strstr(argp
->map
, "ipnodes")))) {
169 if (do_dns
&& result
.stat
!= YP_TRUE
&&
170 (strstr(argp
->map
, "hosts") || strstr(argp
->map
, "ipnodes"))) {
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
,
184 else if (!strcmp(argp
->map
, "hosts.byaddr"))
185 result
.stat
= yp_async_lookup_addr(rqstp
, nbuf
,
187 else if (!strcmp(argp
->map
, "ipnodes.byname"))
188 result
.stat
= yp_async_lookup_name(rqstp
, nbuf
,
190 else if (!strcmp(argp
->map
, "ipnodes.byaddr"))
191 result
.stat
= yp_async_lookup_addr(rqstp
, nbuf
,
194 if (result
.stat
== YP_TRUE
)
202 ypproc_first_2_svc(ypreq_nokey
*argp
, struct svc_req
*rqstp
)
204 static ypresp_key_val result
;
206 result
.val
.valdat_val
= result
.key
.keydat_val
= "";
207 result
.val
.valdat_len
= result
.key
.keydat_len
= 0;
210 if (yp_access(argp
->map
, argp
->domain
, (struct svc_req
*)rqstp
)) {
212 if (yp_access(argp
->map
, (struct svc_req
*)rqstp
)) {
214 result
.stat
= YP_YPERR
;
218 if (argp
->domain
== NULL
) {
219 result
.stat
= YP_BADARGS
;
223 if (yp_select_map(argp
->map
, argp
->domain
, NULL
, 0) != YP_TRUE
) {
224 result
.stat
= yp_errno
;
228 result
.stat
= yp_firstbykey(&result
.key
, &result
.val
);
234 ypproc_next_2_svc(ypreq_key
*argp
, struct svc_req
*rqstp
)
236 static ypresp_key_val result
;
238 result
.val
.valdat_val
= result
.key
.keydat_val
= "";
239 result
.val
.valdat_len
= result
.key
.keydat_len
= 0;
242 if (yp_access(argp
->map
, argp
->domain
, (struct svc_req
*)rqstp
)) {
244 if (yp_access(argp
->map
, (struct svc_req
*)rqstp
)) {
246 result
.stat
= YP_YPERR
;
250 if (argp
->domain
== NULL
|| argp
->map
== NULL
) {
251 result
.stat
= YP_BADARGS
;
255 if (yp_select_map(argp
->map
, argp
->domain
, &argp
->key
, 0) != YP_TRUE
) {
256 result
.stat
= yp_errno
;
260 result
.key
.keydat_len
= argp
->key
.keydat_len
;
261 result
.key
.keydat_val
= argp
->key
.keydat_val
;
263 result
.stat
= yp_nextbykey(&result
.key
, &result
.val
);
269 ypxfr_callback(ypxfrstat rval
, struct sockaddr_in
*addr
, unsigned int transid
,
270 unsigned int prognum
, unsigned long port
)
273 int sock
= RPC_ANYSOCK
;
274 struct timeval timeout
;
275 yppushresp_xfr ypxfr_resp
;
280 addr
->sin_port
= htons(port
);
282 if ((clnt
= clntudp_create(addr
,prognum
,1,timeout
,&sock
)) == NULL
) {
283 yp_error("%s: %s", inet_ntoa(addr
->sin_addr
),
284 clnt_spcreateerror("failed to establish callback handle"));
288 ypxfr_resp
.status
= rval
;
289 ypxfr_resp
.transid
= transid
;
291 /* Turn the timeout off -- we don't want to block. */
293 if (clnt_control(clnt
, CLSET_TIMEOUT
, &timeout
) == FALSE
)
294 yp_error("failed to set timeout on ypproc_xfr callback");
296 if (yppushproc_xfrresp_1(&ypxfr_resp
, clnt
) == NULL
) {
297 clnt_geterr(clnt
, &err
);
298 if (err
.re_status
!= RPC_SUCCESS
&&
299 err
.re_status
!= RPC_TIMEDOUT
)
300 yp_error("%s", clnt_sperror(clnt
,
301 "ypxfr callback failed"));
308 #define YPXFR_RETURN(CODE) \
309 /* Order is important: send regular RPC reply, then callback */ \
310 result.xfrstat = CODE; \
311 svc_sendreply(rqstp->rq_xprt, (xdrproc_t)xdr_ypresp_xfr, &result); \
312 ypxfr_callback(CODE,rqhost,argp->transid, \
313 argp->prog,argp->port); \
317 ypproc_xfr_2_svc(ypreq_xfr
*argp
, struct svc_req
*rqstp
)
319 static ypresp_xfr result
;
320 struct sockaddr_in
*rqhost
;
324 result
.transid
= argp
->transid
;
325 rqhost
= svc_getcaller(rqstp
->rq_xprt
);
328 if (yp_access(argp
->map_parms
.map
,
329 argp
->map_parms
.domain
, (struct svc_req
*)rqstp
)) {
331 if (yp_access(argp
->map_parms
.map
, (struct svc_req
*)rqstp
)) {
333 YPXFR_RETURN(YPXFR_REFUSED
)
337 if (argp
->map_parms
.domain
== NULL
) {
338 YPXFR_RETURN(YPXFR_BADARGS
)
341 if (yp_validdomain(argp
->map_parms
.domain
)) {
342 YPXFR_RETURN(YPXFR_NODOM
)
346 * Determine the master host ourselves. The caller may
347 * be up to no good. This has the side effect of verifying
348 * that the requested map and domain actually exist.
351 mreq
.domain
= argp
->map_parms
.domain
;
352 mreq
.map
= argp
->map_parms
.map
;
354 mres
= ypproc_master_2_svc(&mreq
, rqstp
);
356 if (mres
->stat
!= YP_TRUE
) {
357 yp_error("couldn't find master for map %s@%s",
359 argp
->map_parms
.domain
);
360 yp_error("host at %s (%s) may be pulling my leg",
361 argp
->map_parms
.peer
,
362 inet_ntoa(rqhost
->sin_addr
));
363 YPXFR_RETURN(YPXFR_REFUSED
)
369 char g
[11], t
[11], p
[11];
370 char ypxfr_command
[MAXPATHLEN
+ 2];
372 snprintf (ypxfr_command
, sizeof(ypxfr_command
), "%sypxfr", _PATH_LIBEXEC
);
373 snprintf (t
, sizeof(t
), "%u", argp
->transid
);
374 snprintf (g
, sizeof(g
), "%u", argp
->prog
);
375 snprintf (p
, sizeof(p
), "%u", argp
->port
);
377 close(0); close(1); close(2);
379 if (strcmp(yp_dir
, _PATH_YP
)) {
380 execl(ypxfr_command
, "ypxfr",
381 "-d", argp
->map_parms
.domain
,
383 "-p", yp_dir
, "-C", t
,
384 g
, inet_ntoa(rqhost
->sin_addr
),
385 p
, argp
->map_parms
.map
,
388 execl(ypxfr_command
, "ypxfr",
389 "-d", argp
->map_parms
.domain
,
392 g
, inet_ntoa(rqhost
->sin_addr
),
393 p
, argp
->map_parms
.map
,
396 yp_error("ypxfr execl(%s): %s", ypxfr_command
, strerror(errno
));
397 YPXFR_RETURN(YPXFR_XFRERR
)
399 * Just to safe, prevent PR #10970 from biting us in
400 * the unlikely case that execing ypxfr fails. We don't
401 * want to have any child processes spawned from this
408 yp_error("ypxfr fork(): %s", strerror(errno
));
409 YPXFR_RETURN(YPXFR_XFRERR
)
412 result
.xfrstat
= YPXFR_SUCC
;
422 ypproc_clear_2_svc(void *argp
, struct svc_req
*rqstp
)
424 static char * result
;
425 static char rval
= 0;
428 if (yp_access(NULL
, NULL
, (struct svc_req
*)rqstp
))
430 if (yp_access(NULL
, (struct svc_req
*)rqstp
))
434 /* clear out the database cache */
437 /* Re-read the securenets database for the hell of it. */
441 return((void *) &result
);
445 * For ypproc_all, we have to send a stream of ypresp_all structures
446 * via TCP, but the XDR filter generated from the yp.x protocol
447 * definition file only serializes one such structure. This means that
448 * to send the whole stream, you need a wrapper which feeds all the
449 * records into the underlying XDR routine until it hits an 'EOF.'
450 * But to use the wrapper, you have to violate the boundaries between
451 * RPC layers by calling svc_sendreply() directly from the ypproc_all
452 * service routine instead of letting the RPC dispatcher do it.
458 * Custom XDR routine for serialzing results of ypproc_all: keep
459 * reading from the database and spew until we run out of records
460 * or encounter an error.
463 xdr_my_ypresp_all(XDR
*xdrs
, ypresp_all
*objp
)
467 if ((objp
->ypresp_all_u
.val
.stat
=
468 yp_nextbykey(&objp
->ypresp_all_u
.val
.key
,
469 &objp
->ypresp_all_u
.val
.val
)) == YP_TRUE
) {
476 if (!xdr_ypresp_all(xdrs
, objp
))
478 if (objp
->more
== FALSE
)
484 ypproc_all_2_svc(ypreq_nokey
*argp
, struct svc_req
*rqstp
)
486 static ypresp_all result
;
489 * Set this here so that the client will be forced to make
490 * at least one attempt to read from us even if all we're
491 * doing is returning an error.
494 result
.ypresp_all_u
.val
.key
.keydat_len
= 0;
495 result
.ypresp_all_u
.val
.key
.keydat_val
= "";
498 if (yp_access(argp
->map
, argp
->domain
, (struct svc_req
*)rqstp
)) {
500 if (yp_access(argp
->map
, (struct svc_req
*)rqstp
)) {
502 result
.ypresp_all_u
.val
.stat
= YP_YPERR
;
506 if (argp
->domain
== NULL
|| argp
->map
== NULL
) {
507 result
.ypresp_all_u
.val
.stat
= YP_BADARGS
;
512 * XXX If we hit the child limit, fail the request.
513 * If we don't, and the map is large, we could block for
514 * a long time in the parent.
516 if (children
>= MAX_CHILDREN
) {
517 result
.ypresp_all_u
.val
.stat
= YP_YPERR
;
522 * The ypproc_all procedure can take a while to complete.
523 * Best to handle it in a subprocess so the parent doesn't
524 * block. (Is there a better way to do this? Maybe with
532 yp_error("ypall fork(): %s", strerror(errno
));
533 result
.ypresp_all_u
.val
.stat
= YP_YPERR
;
544 * Fix for PR #10971: don't let the child ypserv share
545 * DB handles with the parent process.
551 if (yp_select_map(argp
->map
, argp
->domain
,
552 &result
.ypresp_all_u
.val
.key
, 0) != YP_TRUE
) {
553 result
.ypresp_all_u
.val
.stat
= yp_errno
;
557 /* Kick off the actual data transfer. */
558 svc_sendreply(rqstp
->rq_xprt
, (xdrproc_t
)xdr_my_ypresp_all
, &result
);
561 * Proper fix for PR #10970: exit here so that we don't risk
562 * having a child spawned from this sub-process.
568 ypproc_master_2_svc(ypreq_nokey
*argp
, struct svc_req
*rqstp
)
570 static ypresp_master result
;
571 static char ypvalbuf
[YPMAXRECORD
];
572 keydat key
= { MASTER_SZ
, MASTER_STRING
};
578 if (yp_access(argp
->map
, argp
->domain
, (struct svc_req
*)rqstp
)) {
580 if (yp_access(argp
->map
, (struct svc_req
*)rqstp
)) {
582 result
.stat
= YP_YPERR
;
586 if (argp
->domain
== NULL
) {
587 result
.stat
= YP_BADARGS
;
591 if (yp_select_map(argp
->map
, argp
->domain
, &key
, 1) != YP_TRUE
) {
592 result
.stat
= yp_errno
;
597 * Note that we copy the data retrieved from the database to
598 * a private buffer and NUL terminate the buffer rather than
599 * terminating the data in place. We do this because by stuffing
600 * a '\0' into data.data, we will actually be corrupting memory
601 * allocated by the DB package. This is a bad thing now that we
602 * cache DB handles rather than closing the database immediately.
604 result
.stat
= yp_getbykey(&key
, &val
);
605 if (result
.stat
== YP_TRUE
) {
606 bcopy(val
.valdat_val
, &ypvalbuf
, val
.valdat_len
);
607 ypvalbuf
[val
.valdat_len
] = '\0';
608 result
.peer
= ypvalbuf
;
616 ypproc_order_2_svc(ypreq_nokey
*argp
, struct svc_req
*rqstp
)
618 static ypresp_order result
;
619 keydat key
= { ORDER_SZ
, ORDER_STRING
};
625 if (yp_access(argp
->map
, argp
->domain
, (struct svc_req
*)rqstp
)) {
627 if (yp_access(argp
->map
, (struct svc_req
*)rqstp
)) {
629 result
.stat
= YP_YPERR
;
633 if (argp
->domain
== NULL
) {
634 result
.stat
= YP_BADARGS
;
639 * We could just check the timestamp on the map file,
640 * but that's a hack: we'll only know the last time the file
641 * was touched, not the last time the database contents were
645 if (yp_select_map(argp
->map
, argp
->domain
, &key
, 1) != YP_TRUE
) {
646 result
.stat
= yp_errno
;
650 result
.stat
= yp_getbykey(&key
, &val
);
652 if (result
.stat
== YP_TRUE
)
653 result
.ordernum
= atoi(val
.valdat_val
);
661 yp_maplist_free(struct ypmaplist
*yp_maplist
)
663 struct ypmaplist
*next
;
666 next
= yp_maplist
->next
;
667 free(yp_maplist
->map
);
674 static struct ypmaplist
*
675 yp_maplist_create(const char *domain
)
677 char yp_mapdir
[MAXPATHLEN
+ 2];
678 char yp_mapname
[MAXPATHLEN
+ 2];
679 struct ypmaplist
*cur
= NULL
;
680 struct ypmaplist
*yp_maplist
= NULL
;
685 snprintf(yp_mapdir
, sizeof(yp_mapdir
), "%s/%s", yp_dir
, domain
);
687 if ((dird
= opendir(yp_mapdir
)) == NULL
) {
688 yp_error("opendir(%s) failed: %s", yp_mapdir
, strerror(errno
));
692 while ((dirp
= readdir(dird
)) != NULL
) {
693 if (strcmp(dirp
->d_name
, ".") && strcmp(dirp
->d_name
, "..")) {
694 snprintf(yp_mapname
, sizeof(yp_mapname
), "%s/%s",
695 yp_mapdir
,dirp
->d_name
);
696 if (stat(yp_mapname
, &statbuf
) < 0 ||
697 !S_ISREG(statbuf
.st_mode
))
699 if ((cur
= (struct ypmaplist
*)
700 malloc(sizeof(struct ypmaplist
))) == NULL
) {
701 yp_error("malloc() failed");
703 yp_maplist_free(yp_maplist
);
706 if ((cur
->map
= strdup(dirp
->d_name
)) == NULL
) {
707 yp_error("strdup() failed: %s",strerror(errno
));
709 yp_maplist_free(yp_maplist
);
713 cur
->next
= yp_maplist
;
716 yp_error("map: %s", yp_maplist
->map
);
725 ypproc_maplist_2_svc(domainname
*argp
, struct svc_req
*rqstp
)
727 static ypresp_maplist result
= { 0, NULL
};
730 if (yp_access(NULL
, NULL
, (struct svc_req
*)rqstp
)) {
732 if (yp_access(NULL
, (struct svc_req
*)rqstp
)) {
734 result
.stat
= YP_YPERR
;
739 result
.stat
= YP_BADARGS
;
743 if (yp_validdomain(*argp
)) {
744 result
.stat
= YP_NODOM
;
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
758 yp_maplist_free(result
.maps
);
760 if ((result
.maps
= yp_maplist_create(*argp
)) == NULL
) {
761 yp_error("yp_maplist_create failed");
762 result
.stat
= YP_YPERR
;
765 result
.stat
= YP_TRUE
;
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.
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.
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.
788 ypoldproc_null_1_svc(void *argp
, struct svc_req
*rqstp
)
790 return(ypproc_null_2_svc(argp
, rqstp
));
794 ypoldproc_domain_1_svc(domainname
*argp
, struct svc_req
*rqstp
)
796 return(ypproc_domain_2_svc(argp
, rqstp
));
800 ypoldproc_domain_nonack_1_svc(domainname
*argp
, struct svc_req
*rqstp
)
802 return (ypproc_domain_nonack_2_svc(argp
, rqstp
));
806 * the 'match' procedure sends a response of type YPRESP_VAL
809 ypoldproc_match_1_svc(yprequest
*argp
, struct svc_req
*rqstp
)
811 static ypresponse result
;
812 ypresp_val
*v2_result
;
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;
818 if (argp
->yp_reqtype
!= YPREQ_KEY
) {
819 result
.ypresponse_u
.yp_resp_valtype
.stat
= YP_BADARGS
;
823 v2_result
= ypproc_match_2_svc(&argp
->yprequest_u
.yp_req_keytype
,rqstp
);
824 if (v2_result
== NULL
)
827 bcopy(v2_result
, &result
.ypresponse_u
.yp_resp_valtype
,
834 * the 'first' procedure sends a response of type YPRESP_KEY_VAL
837 ypoldproc_first_1_svc(yprequest
*argp
, struct svc_req
*rqstp
)
839 static ypresponse result
;
840 ypresp_key_val
*v2_result
;
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;
848 if (argp
->yp_reqtype
!= YPREQ_NOKEY
) {
849 result
.ypresponse_u
.yp_resp_key_valtype
.stat
= YP_BADARGS
;
853 v2_result
= ypproc_first_2_svc(&argp
->yprequest_u
.yp_req_nokeytype
,
855 if (v2_result
== NULL
)
858 bcopy(v2_result
, &result
.ypresponse_u
.yp_resp_key_valtype
,
859 sizeof(ypresp_key_val
));
865 * the 'next' procedure sends a response of type YPRESP_KEY_VAL
868 ypoldproc_next_1_svc(yprequest
*argp
, struct svc_req
*rqstp
)
870 static ypresponse result
;
871 ypresp_key_val
*v2_result
;
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;
879 if (argp
->yp_reqtype
!= YPREQ_KEY
) {
880 result
.ypresponse_u
.yp_resp_key_valtype
.stat
= YP_BADARGS
;
884 v2_result
= ypproc_next_2_svc(&argp
->yprequest_u
.yp_req_keytype
,rqstp
);
885 if (v2_result
== NULL
)
888 bcopy(v2_result
, &result
.ypresponse_u
.yp_resp_key_valtype
,
889 sizeof(ypresp_key_val
));
895 * the 'poll' procedure sends a response of type YPRESP_MAP_PARMS
898 ypoldproc_poll_1_svc(yprequest
*argp
, struct svc_req
*rqstp
)
900 static ypresponse result
;
901 ypresp_master
*v2_result1
;
902 ypresp_order
*v2_result2
;
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
;
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.
915 result
.ypresponse_u
.yp_resp_map_parmstype
.ordernum
= 0;
916 result
.ypresponse_u
.yp_resp_map_parmstype
.peer
= "";
918 if (argp
->yp_reqtype
!= YPREQ_MAP_PARMS
) {
922 v2_result1
= ypproc_master_2_svc(&argp
->yprequest_u
.yp_req_nokeytype
,
924 if (v2_result1
== NULL
)
927 if (v2_result1
->stat
!= YP_TRUE
) {
931 v2_result2
= ypproc_order_2_svc(&argp
->yprequest_u
.yp_req_nokeytype
,
933 if (v2_result2
== NULL
)
936 if (v2_result2
->stat
!= YP_TRUE
) {
940 result
.ypresponse_u
.yp_resp_map_parmstype
.peer
=
942 result
.ypresponse_u
.yp_resp_map_parmstype
.ordernum
=
943 v2_result2
->ordernum
;
949 ypoldproc_push_1_svc(yprequest
*argp
, struct svc_req
*rqstp
)
951 static ypresponse result
;
961 ypoldproc_pull_1_svc(yprequest
*argp
, struct svc_req
*rqstp
)
963 static ypresponse result
;
973 ypoldproc_get_1_svc(yprequest
*argp
, struct svc_req
*rqstp
)
975 static ypresponse result
;