/* * Copyright (c) 1995 * Bill Paul . All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Bill Paul. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * */ #include __FBSDID("$FreeBSD$"); #include "yp.h" #include "yp_extern.h" #include #include #include #include #include #include #include #include #include #include int children = 0; #define MASTER_STRING "YP_MASTER_NAME" #define MASTER_SZ sizeof(MASTER_STRING) - 1 #define ORDER_STRING "YP_LAST_MODIFIED" #define ORDER_SZ sizeof(ORDER_STRING) - 1 static pid_t yp_fork(void) { if (yp_pid != getpid()) { yp_error("child %d trying to fork!", getpid()); errno = EEXIST; return(-1); } return(fork()); } /* * NIS v2 support. This is where most of the action happens. */ void * ypproc_null_2_svc(void *argp, struct svc_req *rqstp) { static char * result; static char rval = 0; #ifdef DB_CACHE if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) #else if (yp_access(NULL, (struct svc_req *)rqstp)) #endif return(NULL); result = &rval; return((void *) &result); } bool_t * ypproc_domain_2_svc(domainname *argp, struct svc_req *rqstp) { static bool_t result; #ifdef DB_CACHE if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) { #else if (yp_access(NULL, (struct svc_req *)rqstp)) { #endif result = FALSE; return (&result); } if (argp == NULL || yp_validdomain(*argp)) result = FALSE; else result = TRUE; return (&result); } bool_t * ypproc_domain_nonack_2_svc(domainname *argp, struct svc_req *rqstp) { static bool_t result; #ifdef DB_CACHE if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) #else if (yp_access(NULL, (struct svc_req *)rqstp)) #endif return (NULL); if (argp == NULL || yp_validdomain(*argp)) return (NULL); else result = TRUE; return (&result); } ypresp_val * ypproc_match_2_svc(ypreq_key *argp, struct svc_req *rqstp) { static ypresp_val result; result.val.valdat_val = ""; result.val.valdat_len = 0; #ifdef DB_CACHE if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) { #else if (yp_access(argp->map, (struct svc_req *)rqstp)) { #endif result.stat = YP_YPERR; return (&result); } if (argp->domain == NULL || argp->map == NULL) { result.stat = YP_BADARGS; return (&result); } if (yp_select_map(argp->map, argp->domain, NULL, 1) != YP_TRUE) { result.stat = yp_errno; return(&result); } result.stat = yp_getbykey(&argp->key, &result.val); /* * Do DNS lookups for hosts maps if database lookup failed. */ #ifdef DB_CACHE if (do_dns && result.stat != YP_TRUE && (yp_testflag(argp->map, argp->domain, YP_INTERDOMAIN) || (strstr(argp->map, "hosts") || strstr(argp->map, "ipnodes")))) { #else if (do_dns && result.stat != YP_TRUE && (strstr(argp->map, "hosts") || strstr(argp->map, "ipnodes"))) { #endif char nbuf[YPMAXRECORD]; /* NUL terminate! NUL terminate!! NUL TERMINATE!!! */ bcopy(argp->key.keydat_val, nbuf, argp->key.keydat_len); nbuf[argp->key.keydat_len] = '\0'; if (debug) yp_error("doing DNS lookup of %s", nbuf); if (!strcmp(argp->map, "hosts.byname")) result.stat = yp_async_lookup_name(rqstp, nbuf, AF_INET); else if (!strcmp(argp->map, "hosts.byaddr")) result.stat = yp_async_lookup_addr(rqstp, nbuf, AF_INET); else if (!strcmp(argp->map, "ipnodes.byname")) result.stat = yp_async_lookup_name(rqstp, nbuf, AF_INET6); else if (!strcmp(argp->map, "ipnodes.byaddr")) result.stat = yp_async_lookup_addr(rqstp, nbuf, AF_INET6); if (result.stat == YP_TRUE) return(NULL); } return (&result); } ypresp_key_val * ypproc_first_2_svc(ypreq_nokey *argp, struct svc_req *rqstp) { static ypresp_key_val result; result.val.valdat_val = result.key.keydat_val = ""; result.val.valdat_len = result.key.keydat_len = 0; #ifdef DB_CACHE if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) { #else if (yp_access(argp->map, (struct svc_req *)rqstp)) { #endif result.stat = YP_YPERR; return (&result); } if (argp->domain == NULL) { result.stat = YP_BADARGS; return (&result); } if (yp_select_map(argp->map, argp->domain, NULL, 0) != YP_TRUE) { result.stat = yp_errno; return(&result); } result.stat = yp_firstbykey(&result.key, &result.val); return (&result); } ypresp_key_val * ypproc_next_2_svc(ypreq_key *argp, struct svc_req *rqstp) { static ypresp_key_val result; result.val.valdat_val = result.key.keydat_val = ""; result.val.valdat_len = result.key.keydat_len = 0; #ifdef DB_CACHE if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) { #else if (yp_access(argp->map, (struct svc_req *)rqstp)) { #endif result.stat = YP_YPERR; return (&result); } if (argp->domain == NULL || argp->map == NULL) { result.stat = YP_BADARGS; return (&result); } if (yp_select_map(argp->map, argp->domain, &argp->key, 0) != YP_TRUE) { result.stat = yp_errno; return(&result); } result.key.keydat_len = argp->key.keydat_len; result.key.keydat_val = argp->key.keydat_val; result.stat = yp_nextbykey(&result.key, &result.val); return (&result); } static void ypxfr_callback(ypxfrstat rval, struct sockaddr_in *addr, unsigned int transid, unsigned int prognum, unsigned long port) { CLIENT *clnt; int sock = RPC_ANYSOCK; struct timeval timeout; yppushresp_xfr ypxfr_resp; struct rpc_err err; timeout.tv_sec = 5; timeout.tv_usec = 0; addr->sin_port = htons(port); if ((clnt = clntudp_create(addr,prognum,1,timeout,&sock)) == NULL) { yp_error("%s: %s", inet_ntoa(addr->sin_addr), clnt_spcreateerror("failed to establish callback handle")); return; } ypxfr_resp.status = rval; ypxfr_resp.transid = transid; /* Turn the timeout off -- we don't want to block. */ timeout.tv_sec = 0; if (clnt_control(clnt, CLSET_TIMEOUT, &timeout) == FALSE) yp_error("failed to set timeout on ypproc_xfr callback"); if (yppushproc_xfrresp_1(&ypxfr_resp, clnt) == NULL) { clnt_geterr(clnt, &err); if (err.re_status != RPC_SUCCESS && err.re_status != RPC_TIMEDOUT) yp_error("%s", clnt_sperror(clnt, "ypxfr callback failed")); } clnt_destroy(clnt); return; } #define YPXFR_RETURN(CODE) \ /* Order is important: send regular RPC reply, then callback */ \ result.xfrstat = CODE; \ svc_sendreply(rqstp->rq_xprt, (xdrproc_t)xdr_ypresp_xfr, &result); \ ypxfr_callback(CODE,rqhost,argp->transid, \ argp->prog,argp->port); \ return(NULL); ypresp_xfr * ypproc_xfr_2_svc(ypreq_xfr *argp, struct svc_req *rqstp) { static ypresp_xfr result; struct sockaddr_in *rqhost; ypresp_master *mres; ypreq_nokey mreq; result.transid = argp->transid; rqhost = svc_getcaller(rqstp->rq_xprt); #ifdef DB_CACHE if (yp_access(argp->map_parms.map, argp->map_parms.domain, (struct svc_req *)rqstp)) { #else if (yp_access(argp->map_parms.map, (struct svc_req *)rqstp)) { #endif YPXFR_RETURN(YPXFR_REFUSED) } if (argp->map_parms.domain == NULL) { YPXFR_RETURN(YPXFR_BADARGS) } if (yp_validdomain(argp->map_parms.domain)) { YPXFR_RETURN(YPXFR_NODOM) } /* * Determine the master host ourselves. The caller may * be up to no good. This has the side effect of verifying * that the requested map and domain actually exist. */ mreq.domain = argp->map_parms.domain; mreq.map = argp->map_parms.map; mres = ypproc_master_2_svc(&mreq, rqstp); if (mres->stat != YP_TRUE) { yp_error("couldn't find master for map %s@%s", argp->map_parms.map, argp->map_parms.domain); yp_error("host at %s (%s) may be pulling my leg", argp->map_parms.peer, inet_ntoa(rqhost->sin_addr)); YPXFR_RETURN(YPXFR_REFUSED) } switch (yp_fork()) { case 0: { char g[11], t[11], p[11]; char ypxfr_command[MAXPATHLEN + 2]; snprintf (ypxfr_command, sizeof(ypxfr_command), "%sypxfr", _PATH_LIBEXEC); snprintf (t, sizeof(t), "%u", argp->transid); snprintf (g, sizeof(g), "%u", argp->prog); snprintf (p, sizeof(p), "%u", argp->port); if (debug) { close(0); close(1); close(2); } if (strcmp(yp_dir, _PATH_YP)) { execl(ypxfr_command, "ypxfr", "-d", argp->map_parms.domain, "-h", mres->peer, "-p", yp_dir, "-C", t, g, inet_ntoa(rqhost->sin_addr), p, argp->map_parms.map, NULL); } else { execl(ypxfr_command, "ypxfr", "-d", argp->map_parms.domain, "-h", mres->peer, "-C", t, g, inet_ntoa(rqhost->sin_addr), p, argp->map_parms.map, NULL); } yp_error("ypxfr execl(%s): %s", ypxfr_command, strerror(errno)); YPXFR_RETURN(YPXFR_XFRERR) /* * Just to safe, prevent PR #10970 from biting us in * the unlikely case that execing ypxfr fails. We don't * want to have any child processes spawned from this * child process. */ _exit(0); break; } case -1: yp_error("ypxfr fork(): %s", strerror(errno)); YPXFR_RETURN(YPXFR_XFRERR) break; default: result.xfrstat = YPXFR_SUCC; children++; break; } return (&result); } #undef YPXFR_RETURN void * ypproc_clear_2_svc(void *argp, struct svc_req *rqstp) { static char * result; static char rval = 0; #ifdef DB_CACHE if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) #else if (yp_access(NULL, (struct svc_req *)rqstp)) #endif return (NULL); #ifdef DB_CACHE /* clear out the database cache */ yp_flush_all(); #endif /* Re-read the securenets database for the hell of it. */ load_securenets(); result = &rval; return((void *) &result); } /* * For ypproc_all, we have to send a stream of ypresp_all structures * via TCP, but the XDR filter generated from the yp.x protocol * definition file only serializes one such structure. This means that * to send the whole stream, you need a wrapper which feeds all the * records into the underlying XDR routine until it hits an 'EOF.' * But to use the wrapper, you have to violate the boundaries between * RPC layers by calling svc_sendreply() directly from the ypproc_all * service routine instead of letting the RPC dispatcher do it. * * Bleah. */ /* * Custom XDR routine for serialzing results of ypproc_all: keep * reading from the database and spew until we run out of records * or encounter an error. */ static bool_t xdr_my_ypresp_all(register XDR *xdrs, ypresp_all *objp) { while (1) { /* Get a record. */ if ((objp->ypresp_all_u.val.stat = yp_nextbykey(&objp->ypresp_all_u.val.key, &objp->ypresp_all_u.val.val)) == YP_TRUE) { objp->more = TRUE; } else { objp->more = FALSE; } /* Serialize. */ if (!xdr_ypresp_all(xdrs, objp)) return(FALSE); if (objp->more == FALSE) return(TRUE); } } ypresp_all * ypproc_all_2_svc(ypreq_nokey *argp, struct svc_req *rqstp) { static ypresp_all result; /* * Set this here so that the client will be forced to make * at least one attempt to read from us even if all we're * doing is returning an error. */ result.more = TRUE; result.ypresp_all_u.val.key.keydat_len = 0; result.ypresp_all_u.val.key.keydat_val = ""; #ifdef DB_CACHE if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) { #else if (yp_access(argp->map, (struct svc_req *)rqstp)) { #endif result.ypresp_all_u.val.stat = YP_YPERR; return (&result); } if (argp->domain == NULL || argp->map == NULL) { result.ypresp_all_u.val.stat = YP_BADARGS; return (&result); } /* * XXX If we hit the child limit, fail the request. * If we don't, and the map is large, we could block for * a long time in the parent. */ if (children >= MAX_CHILDREN) { result.ypresp_all_u.val.stat = YP_YPERR; return(&result); } /* * The ypproc_all procedure can take a while to complete. * Best to handle it in a subprocess so the parent doesn't * block. (Is there a better way to do this? Maybe with * async socket I/O?) */ if (!debug) { switch (yp_fork()) { case 0: break; case -1: yp_error("ypall fork(): %s", strerror(errno)); result.ypresp_all_u.val.stat = YP_YPERR; return(&result); break; default: children++; return (NULL); break; } } /* * Fix for PR #10971: don't let the child ypserv share * DB handles with the parent process. */ #ifdef DB_CACHE yp_flush_all(); #endif if (yp_select_map(argp->map, argp->domain, &result.ypresp_all_u.val.key, 0) != YP_TRUE) { result.ypresp_all_u.val.stat = yp_errno; return(&result); } /* Kick off the actual data transfer. */ svc_sendreply(rqstp->rq_xprt, (xdrproc_t)xdr_my_ypresp_all, &result); /* * Proper fix for PR #10970: exit here so that we don't risk * having a child spawned from this sub-process. */ if (!debug) _exit(0); return &result; } ypresp_master * ypproc_master_2_svc(ypreq_nokey *argp, struct svc_req *rqstp) { static ypresp_master result; static char ypvalbuf[YPMAXRECORD]; keydat key = { MASTER_SZ, MASTER_STRING }; valdat val; result.peer = ""; #ifdef DB_CACHE if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) { #else if (yp_access(argp->map, (struct svc_req *)rqstp)) { #endif result.stat = YP_YPERR; return(&result); } if (argp->domain == NULL) { result.stat = YP_BADARGS; return (&result); } if (yp_select_map(argp->map, argp->domain, &key, 1) != YP_TRUE) { result.stat = yp_errno; return(&result); } /* * Note that we copy the data retrieved from the database to * a private buffer and NUL terminate the buffer rather than * terminating the data in place. We do this because by stuffing * a '\0' into data.data, we will actually be corrupting memory * allocated by the DB package. This is a bad thing now that we * cache DB handles rather than closing the database immediately. */ result.stat = yp_getbykey(&key, &val); if (result.stat == YP_TRUE) { bcopy(val.valdat_val, &ypvalbuf, val.valdat_len); ypvalbuf[val.valdat_len] = '\0'; result.peer = ypvalbuf; } else result.peer = ""; return (&result); } ypresp_order * ypproc_order_2_svc(ypreq_nokey *argp, struct svc_req *rqstp) { static ypresp_order result; keydat key = { ORDER_SZ, ORDER_STRING }; valdat val; result.ordernum = 0; #ifdef DB_CACHE if (yp_access(argp->map, argp->domain, (struct svc_req *)rqstp)) { #else if (yp_access(argp->map, (struct svc_req *)rqstp)) { #endif result.stat = YP_YPERR; return(&result); } if (argp->domain == NULL) { result.stat = YP_BADARGS; return (&result); } /* * We could just check the timestamp on the map file, * but that's a hack: we'll only know the last time the file * was touched, not the last time the database contents were * updated. */ if (yp_select_map(argp->map, argp->domain, &key, 1) != YP_TRUE) { result.stat = yp_errno; return(&result); } result.stat = yp_getbykey(&key, &val); if (result.stat == YP_TRUE) result.ordernum = atoi(val.valdat_val); else result.ordernum = 0; return (&result); } static void yp_maplist_free(struct ypmaplist *yp_maplist) { register struct ypmaplist *next; while (yp_maplist) { next = yp_maplist->next; free(yp_maplist->map); free(yp_maplist); yp_maplist = next; } return; } static struct ypmaplist * yp_maplist_create(const char *domain) { char yp_mapdir[MAXPATHLEN + 2]; char yp_mapname[MAXPATHLEN + 2]; struct ypmaplist *cur = NULL; struct ypmaplist *yp_maplist = NULL; DIR *dird; struct dirent *dirp; struct stat statbuf; snprintf(yp_mapdir, sizeof(yp_mapdir), "%s/%s", yp_dir, domain); if ((dird = opendir(yp_mapdir)) == NULL) { yp_error("opendir(%s) failed: %s", yp_mapdir, strerror(errno)); return(NULL); } while ((dirp = readdir(dird)) != NULL) { if (strcmp(dirp->d_name, ".") && strcmp(dirp->d_name, "..")) { snprintf(yp_mapname, sizeof(yp_mapname), "%s/%s", yp_mapdir,dirp->d_name); if (stat(yp_mapname, &statbuf) < 0 || !S_ISREG(statbuf.st_mode)) continue; if ((cur = (struct ypmaplist *) malloc(sizeof(struct ypmaplist))) == NULL) { yp_error("malloc() failed"); closedir(dird); yp_maplist_free(yp_maplist); return(NULL); } if ((cur->map = strdup(dirp->d_name)) == NULL) { yp_error("strdup() failed: %s",strerror(errno)); closedir(dird); yp_maplist_free(yp_maplist); return(NULL); } cur->next = yp_maplist; yp_maplist = cur; if (debug) yp_error("map: %s", yp_maplist->map); } } closedir(dird); return(yp_maplist); } ypresp_maplist * ypproc_maplist_2_svc(domainname *argp, struct svc_req *rqstp) { static ypresp_maplist result = { 0, NULL }; #ifdef DB_CACHE if (yp_access(NULL, NULL, (struct svc_req *)rqstp)) { #else if (yp_access(NULL, (struct svc_req *)rqstp)) { #endif result.stat = YP_YPERR; return(&result); } if (argp == NULL) { result.stat = YP_BADARGS; return (&result); } if (yp_validdomain(*argp)) { result.stat = YP_NODOM; return (&result); } /* * We have to construct a linked list for the ypproc_maplist * procedure using dynamically allocated memory. Since the XDR * layer won't free this list for us, we have to deal with it * ourselves. We call yp_maplist_free() first to free any * previously allocated data we may have accumulated to insure * that we have only one linked list in memory at any given * time. */ yp_maplist_free(result.maps); if ((result.maps = yp_maplist_create(*argp)) == NULL) { yp_error("yp_maplist_create failed"); result.stat = YP_YPERR; return(&result); } else result.stat = YP_TRUE; return (&result); } /* * NIS v1 support. The nullproc, domain and domain_nonack * functions from v1 are identical to those in v2, so all * we have to do is hand off to them. * * The other functions are mostly just wrappers around their v2 * counterparts. For example, for the v1 'match' procedure, we * crack open the argument structure, make a request to the v2 * 'match' function, repackage the data into a v1 response and * then send it on its way. * * Note that we don't support the pull, push and get procedures. * There's little documentation available to show what they * do, and I suspect they're meant largely for map transfers * between master and slave servers. */ void * ypoldproc_null_1_svc(void *argp, struct svc_req *rqstp) { return(ypproc_null_2_svc(argp, rqstp)); } bool_t * ypoldproc_domain_1_svc(domainname *argp, struct svc_req *rqstp) { return(ypproc_domain_2_svc(argp, rqstp)); } bool_t * ypoldproc_domain_nonack_1_svc(domainname *argp, struct svc_req *rqstp) { return (ypproc_domain_nonack_2_svc(argp, rqstp)); } /* * the 'match' procedure sends a response of type YPRESP_VAL */ ypresponse * ypoldproc_match_1_svc(yprequest *argp, struct svc_req *rqstp) { static ypresponse result; ypresp_val *v2_result; result.yp_resptype = YPRESP_VAL; result.ypresponse_u.yp_resp_valtype.val.valdat_val = ""; result.ypresponse_u.yp_resp_valtype.val.valdat_len = 0; if (argp->yp_reqtype != YPREQ_KEY) { result.ypresponse_u.yp_resp_valtype.stat = YP_BADARGS; return(&result); } v2_result = ypproc_match_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp); if (v2_result == NULL) return(NULL); bcopy(v2_result, &result.ypresponse_u.yp_resp_valtype, sizeof(ypresp_val)); return (&result); } /* * the 'first' procedure sends a response of type YPRESP_KEY_VAL */ ypresponse * ypoldproc_first_1_svc(yprequest *argp, struct svc_req *rqstp) { static ypresponse result; ypresp_key_val *v2_result; result.yp_resptype = YPRESP_KEY_VAL; result.ypresponse_u.yp_resp_key_valtype.val.valdat_val = result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = ""; result.ypresponse_u.yp_resp_key_valtype.val.valdat_len = result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0; if (argp->yp_reqtype != YPREQ_NOKEY) { result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS; return(&result); } v2_result = ypproc_first_2_svc(&argp->yprequest_u.yp_req_nokeytype, rqstp); if (v2_result == NULL) return(NULL); bcopy(v2_result, &result.ypresponse_u.yp_resp_key_valtype, sizeof(ypresp_key_val)); return (&result); } /* * the 'next' procedure sends a response of type YPRESP_KEY_VAL */ ypresponse * ypoldproc_next_1_svc(yprequest *argp, struct svc_req *rqstp) { static ypresponse result; ypresp_key_val *v2_result; result.yp_resptype = YPRESP_KEY_VAL; result.ypresponse_u.yp_resp_key_valtype.val.valdat_val = result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = ""; result.ypresponse_u.yp_resp_key_valtype.val.valdat_len = result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0; if (argp->yp_reqtype != YPREQ_KEY) { result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS; return(&result); } v2_result = ypproc_next_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp); if (v2_result == NULL) return(NULL); bcopy(v2_result, &result.ypresponse_u.yp_resp_key_valtype, sizeof(ypresp_key_val)); return (&result); } /* * the 'poll' procedure sends a response of type YPRESP_MAP_PARMS */ ypresponse * ypoldproc_poll_1_svc(yprequest *argp, struct svc_req *rqstp) { static ypresponse result; ypresp_master *v2_result1; ypresp_order *v2_result2; result.yp_resptype = YPRESP_MAP_PARMS; result.ypresponse_u.yp_resp_map_parmstype.domain = argp->yprequest_u.yp_req_nokeytype.domain; result.ypresponse_u.yp_resp_map_parmstype.map = argp->yprequest_u.yp_req_nokeytype.map; /* * Hmm... there is no 'status' value in the * yp_resp_map_parmstype structure, so I have to * guess at what to do to indicate a failure. * I hope this is right. */ result.ypresponse_u.yp_resp_map_parmstype.ordernum = 0; result.ypresponse_u.yp_resp_map_parmstype.peer = ""; if (argp->yp_reqtype != YPREQ_MAP_PARMS) { return(&result); } v2_result1 = ypproc_master_2_svc(&argp->yprequest_u.yp_req_nokeytype, rqstp); if (v2_result1 == NULL) return(NULL); if (v2_result1->stat != YP_TRUE) { return(&result); } v2_result2 = ypproc_order_2_svc(&argp->yprequest_u.yp_req_nokeytype, rqstp); if (v2_result2 == NULL) return(NULL); if (v2_result2->stat != YP_TRUE) { return(&result); } result.ypresponse_u.yp_resp_map_parmstype.peer = v2_result1->peer; result.ypresponse_u.yp_resp_map_parmstype.ordernum = v2_result2->ordernum; return (&result); } ypresponse * ypoldproc_push_1_svc(yprequest *argp, struct svc_req *rqstp) { static ypresponse result; /* * Not implemented. */ return (&result); } ypresponse * ypoldproc_pull_1_svc(yprequest *argp, struct svc_req *rqstp) { static ypresponse result; /* * Not implemented. */ return (&result); } ypresponse * ypoldproc_get_1_svc(yprequest *argp, struct svc_req *rqstp) { static ypresponse result; /* * Not implemented. */ return (&result); }