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
50int 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
57static pid_t
58yp_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
73void *
74ypproc_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
91bool_t *
92ypproc_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
113bool_t *
114ypproc_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
133ypresp_val *
134ypproc_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
203ypresp_key_val *
204ypproc_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
235ypresp_key_val *
236ypproc_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
270static void
271ypxfr_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
318ypresp_xfr *
319ypproc_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
423void *
424ypproc_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 */
464static bool_t
465xdr_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
485ypresp_all *
486ypproc_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 */
|
570}
571
572ypresp_master *
573ypproc_master_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
574{
575 static ypresp_master result;
576 static char ypvalbuf[YPMAXRECORD];
577 keydat key = { MASTER_SZ, MASTER_STRING };
578 valdat val;
579
580 result.peer = "";
581
582#ifdef DB_CACHE
583 if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
584#else
585 if (yp_access(argp->map, (struct svc_req *)rqstp)) {
586#endif
587 result.stat = YP_YPERR;
588 return(&result);
589 }
590
591 if (argp->domain == NULL) {
592 result.stat = YP_BADARGS;
593 return (&result);
594 }
595
596 if (yp_select_map(argp->map, argp->domain, &key, 1) != YP_TRUE) {
597 result.stat = yp_errno;
598 return(&result);
599 }
600
601 /*
602 * Note that we copy the data retrieved from the database to
603 * a private buffer and NUL terminate the buffer rather than
604 * terminating the data in place. We do this because by stuffing
605 * a '\0' into data.data, we will actually be corrupting memory
606 * allocated by the DB package. This is a bad thing now that we
607 * cache DB handles rather than closing the database immediately.
608 */
609 result.stat = yp_getbykey(&key, &val);
610 if (result.stat == YP_TRUE) {
611 bcopy(val.valdat_val, &ypvalbuf, val.valdat_len);
612 ypvalbuf[val.valdat_len] = '\0';
613 result.peer = ypvalbuf;
614 } else
615 result.peer = "";
616
617 return (&result);
618}
619
620ypresp_order *
621ypproc_order_2_svc(ypreq_nokey *argp, struct svc_req *rqstp)
622{
623 static ypresp_order result;
624 keydat key = { ORDER_SZ, ORDER_STRING };
625 valdat val;
626
627 result.ordernum = 0;
628
629#ifdef DB_CACHE
630 if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) {
631#else
632 if (yp_access(argp->map, (struct svc_req *)rqstp)) {
633#endif
634 result.stat = YP_YPERR;
635 return(&result);
636 }
637
638 if (argp->domain == NULL) {
639 result.stat = YP_BADARGS;
640 return (&result);
641 }
642
643 /*
644 * We could just check the timestamp on the map file,
645 * but that's a hack: we'll only know the last time the file
646 * was touched, not the last time the database contents were
647 * updated.
648 */
649
650 if (yp_select_map(argp->map, argp->domain, &key, 1) != YP_TRUE) {
651 result.stat = yp_errno;
652 return(&result);
653 }
654
655 result.stat = yp_getbykey(&key, &val);
656
657 if (result.stat == YP_TRUE)
658 result.ordernum = atoi(val.valdat_val);
659 else
660 result.ordernum = 0;
661
662 return (&result);
663}
664
665static void yp_maplist_free(struct ypmaplist *yp_maplist)
666{
667 register struct ypmaplist *next;
668
669 while (yp_maplist) {
670 next = yp_maplist->next;
671 free(yp_maplist->map);
672 free(yp_maplist);
673 yp_maplist = next;
674 }
675 return;
676}
677
678static struct ypmaplist *
679yp_maplist_create(const char *domain)
680{
681 char yp_mapdir[MAXPATHLEN + 2];
682 char yp_mapname[MAXPATHLEN + 2];
683 struct ypmaplist *cur = NULL;
684 struct ypmaplist *yp_maplist = NULL;
685 DIR *dird;
686 struct dirent *dirp;
687 struct stat statbuf;
688
689 snprintf(yp_mapdir, sizeof(yp_mapdir), "%s/%s", yp_dir, domain);
690
691 if ((dird = opendir(yp_mapdir)) == NULL) {
692 yp_error("opendir(%s) failed: %s", yp_mapdir, strerror(errno));
693 return(NULL);
694 }
695
696 while ((dirp = readdir(dird)) != NULL) {
697 if (strcmp(dirp->d_name, ".") && strcmp(dirp->d_name, "..")) {
698 snprintf(yp_mapname, sizeof(yp_mapname), "%s/%s",
699 yp_mapdir,dirp->d_name);
700 if (stat(yp_mapname, &statbuf) < 0 ||
701 !S_ISREG(statbuf.st_mode))
702 continue;
703 if ((cur = (struct ypmaplist *)
704 malloc(sizeof(struct ypmaplist))) == NULL) {
705 yp_error("malloc() failed");
706 closedir(dird);
707 yp_maplist_free(yp_maplist);
708 return(NULL);
709 }
710 if ((cur->map = strdup(dirp->d_name)) == NULL) {
711 yp_error("strdup() failed: %s",strerror(errno));
712 closedir(dird);
713 yp_maplist_free(yp_maplist);
714 return(NULL);
715 }
716 cur->next = yp_maplist;
717 yp_maplist = cur;
718 if (debug)
719 yp_error("map: %s", yp_maplist->map);
720 }
721
722 }
723 closedir(dird);
724 return(yp_maplist);
725}
726
727ypresp_maplist *
728ypproc_maplist_2_svc(domainname *argp, struct svc_req *rqstp)
729{
730 static ypresp_maplist result = { 0, NULL };
731
732#ifdef DB_CACHE
733 if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) {
734#else
735 if (yp_access(NULL, (struct svc_req *)rqstp)) {
736#endif
737 result.stat = YP_YPERR;
738 return(&result);
739 }
740
741 if (argp == NULL) {
742 result.stat = YP_BADARGS;
743 return (&result);
744 }
745
746 if (yp_validdomain(*argp)) {
747 result.stat = YP_NODOM;
748 return (&result);
749 }
750
751 /*
752 * We have to construct a linked list for the ypproc_maplist
753 * procedure using dynamically allocated memory. Since the XDR
754 * layer won't free this list for us, we have to deal with it
755 * ourselves. We call yp_maplist_free() first to free any
756 * previously allocated data we may have accumulated to insure
757 * that we have only one linked list in memory at any given
758 * time.
759 */
760
761 yp_maplist_free(result.maps);
762
763 if ((result.maps = yp_maplist_create(*argp)) == NULL) {
764 yp_error("yp_maplist_create failed");
765 result.stat = YP_YPERR;
766 return(&result);
767 } else
768 result.stat = YP_TRUE;
769
770 return (&result);
771}
772
773/*
774 * NIS v1 support. The nullproc, domain and domain_nonack
775 * functions from v1 are identical to those in v2, so all
776 * we have to do is hand off to them.
777 *
778 * The other functions are mostly just wrappers around their v2
779 * counterparts. For example, for the v1 'match' procedure, we
780 * crack open the argument structure, make a request to the v2
781 * 'match' function, repackage the data into a v1 response and
782 * then send it on its way.
783 *
784 * Note that we don't support the pull, push and get procedures.
785 * There's little documentation available to show what they
786 * do, and I suspect they're meant largely for map transfers
787 * between master and slave servers.
788 */
789
790void *
791ypoldproc_null_1_svc(void *argp, struct svc_req *rqstp)
792{
793 return(ypproc_null_2_svc(argp, rqstp));
794}
795
796bool_t *
797ypoldproc_domain_1_svc(domainname *argp, struct svc_req *rqstp)
798{
799 return(ypproc_domain_2_svc(argp, rqstp));
800}
801
802bool_t *
803ypoldproc_domain_nonack_1_svc(domainname *argp, struct svc_req *rqstp)
804{
805 return (ypproc_domain_nonack_2_svc(argp, rqstp));
806}
807
808/*
809 * the 'match' procedure sends a response of type YPRESP_VAL
810 */
811ypresponse *
812ypoldproc_match_1_svc(yprequest *argp, struct svc_req *rqstp)
813{
814 static ypresponse result;
815 ypresp_val *v2_result;
816
817 result.yp_resptype = YPRESP_VAL;
818 result.ypresponse_u.yp_resp_valtype.val.valdat_val = "";
819 result.ypresponse_u.yp_resp_valtype.val.valdat_len = 0;
820
821 if (argp->yp_reqtype != YPREQ_KEY) {
822 result.ypresponse_u.yp_resp_valtype.stat = YP_BADARGS;
823 return(&result);
824 }
825
826 v2_result = ypproc_match_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp);
827 if (v2_result == NULL)
828 return(NULL);
829
830 bcopy(v2_result, &result.ypresponse_u.yp_resp_valtype,
831 sizeof(ypresp_val));
832
833 return (&result);
834}
835
836/*
837 * the 'first' procedure sends a response of type YPRESP_KEY_VAL
838 */
839ypresponse *
840ypoldproc_first_1_svc(yprequest *argp, struct svc_req *rqstp)
841{
842 static ypresponse result;
843 ypresp_key_val *v2_result;
844
845 result.yp_resptype = YPRESP_KEY_VAL;
846 result.ypresponse_u.yp_resp_key_valtype.val.valdat_val =
847 result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = "";
848 result.ypresponse_u.yp_resp_key_valtype.val.valdat_len =
849 result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0;
850
851 if (argp->yp_reqtype != YPREQ_NOKEY) {
852 result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS;
853 return(&result);
854 }
855
856 v2_result = ypproc_first_2_svc(&argp->yprequest_u.yp_req_nokeytype,
857 rqstp);
858 if (v2_result == NULL)
859 return(NULL);
860
861 bcopy(v2_result, &result.ypresponse_u.yp_resp_key_valtype,
862 sizeof(ypresp_key_val));
863
864 return (&result);
865}
866
867/*
868 * the 'next' procedure sends a response of type YPRESP_KEY_VAL
869 */
870ypresponse *
871ypoldproc_next_1_svc(yprequest *argp, struct svc_req *rqstp)
872{
873 static ypresponse result;
874 ypresp_key_val *v2_result;
875
876 result.yp_resptype = YPRESP_KEY_VAL;
877 result.ypresponse_u.yp_resp_key_valtype.val.valdat_val =
878 result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = "";
879 result.ypresponse_u.yp_resp_key_valtype.val.valdat_len =
880 result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0;
881
882 if (argp->yp_reqtype != YPREQ_KEY) {
883 result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS;
884 return(&result);
885 }
886
887 v2_result = ypproc_next_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp);
888 if (v2_result == NULL)
889 return(NULL);
890
891 bcopy(v2_result, &result.ypresponse_u.yp_resp_key_valtype,
892 sizeof(ypresp_key_val));
893
894 return (&result);
895}
896
897/*
898 * the 'poll' procedure sends a response of type YPRESP_MAP_PARMS
899 */
900ypresponse *
901ypoldproc_poll_1_svc(yprequest *argp, struct svc_req *rqstp)
902{
903 static ypresponse result;
904 ypresp_master *v2_result1;
905 ypresp_order *v2_result2;
906
907 result.yp_resptype = YPRESP_MAP_PARMS;
908 result.ypresponse_u.yp_resp_map_parmstype.domain =
909 argp->yprequest_u.yp_req_nokeytype.domain;
910 result.ypresponse_u.yp_resp_map_parmstype.map =
911 argp->yprequest_u.yp_req_nokeytype.map;
912 /*
913 * Hmm... there is no 'status' value in the
914 * yp_resp_map_parmstype structure, so I have to
915 * guess at what to do to indicate a failure.
916 * I hope this is right.
917 */
918 result.ypresponse_u.yp_resp_map_parmstype.ordernum = 0;
919 result.ypresponse_u.yp_resp_map_parmstype.peer = "";
920
921 if (argp->yp_reqtype != YPREQ_MAP_PARMS) {
922 return(&result);
923 }
924
925 v2_result1 = ypproc_master_2_svc(&argp->yprequest_u.yp_req_nokeytype,
926 rqstp);
927 if (v2_result1 == NULL)
928 return(NULL);
929
930 if (v2_result1->stat != YP_TRUE) {
931 return(&result);
932 }
933
934 v2_result2 = ypproc_order_2_svc(&argp->yprequest_u.yp_req_nokeytype,
935 rqstp);
936 if (v2_result2 == NULL)
937 return(NULL);
938
939 if (v2_result2->stat != YP_TRUE) {
940 return(&result);
941 }
942
943 result.ypresponse_u.yp_resp_map_parmstype.peer =
944 v2_result1->peer;
945 result.ypresponse_u.yp_resp_map_parmstype.ordernum =
946 v2_result2->ordernum;
947
948 return (&result);
949}
950
951ypresponse *
952ypoldproc_push_1_svc(yprequest *argp, struct svc_req *rqstp)
953{
954 static ypresponse result;
955
956 /*
957 * Not implemented.
958 */
959
960 return (&result);
961}
962
963ypresponse *
964ypoldproc_pull_1_svc(yprequest *argp, struct svc_req *rqstp)
965{
966 static ypresponse result;
967
968 /*
969 * Not implemented.
970 */
971
972 return (&result);
973}
974
975ypresponse *
976ypoldproc_get_1_svc(yprequest *argp, struct svc_req *rqstp)
977{
978 static ypresponse result;
979
980 /*
981 * Not implemented.
982 */
983
984 return (&result);
985}
|