yp_server.c revision 16044
112891Swpaul/* 212891Swpaul * Copyright (c) 1995 312891Swpaul * Bill Paul <wpaul@ctr.columbia.edu>. All rights reserved. 412891Swpaul * 512891Swpaul * Redistribution and use in source and binary forms, with or without 612891Swpaul * modification, are permitted provided that the following conditions 712891Swpaul * are met: 812891Swpaul * 1. Redistributions of source code must retain the above copyright 912891Swpaul * notice, this list of conditions and the following disclaimer. 1012891Swpaul * 2. Redistributions in binary form must reproduce the above copyright 1112891Swpaul * notice, this list of conditions and the following disclaimer in the 1212891Swpaul * documentation and/or other materials provided with the distribution. 1312891Swpaul * 3. All advertising materials mentioning features or use of this software 1412891Swpaul * must display the following acknowledgement: 1512891Swpaul * This product includes software developed by Bill Paul. 1612891Swpaul * 4. Neither the name of the author nor the names of any co-contributors 1712891Swpaul * may be used to endorse or promote products derived from this software 1812891Swpaul * without specific prior written permission. 1912891Swpaul * 2012891Swpaul * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND 2112891Swpaul * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 2212891Swpaul * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 2312891Swpaul * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR CONTRIBUTORS BE LIABLE 2412891Swpaul * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2512891Swpaul * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2612891Swpaul * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2712891Swpaul * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2812891Swpaul * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2912891Swpaul * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 3012891Swpaul * SUCH DAMAGE. 3112891Swpaul * 3212891Swpaul */ 3312891Swpaul 3412891Swpaul#include "yp_extern.h" 3512891Swpaul#include "yp.h" 3612891Swpaul#include <stdlib.h> 3712891Swpaul#include <dirent.h> 3812891Swpaul#include <sys/stat.h> 3912891Swpaul#include <sys/param.h> 4012891Swpaul#include <errno.h> 4112891Swpaul#include <sys/types.h> 4212891Swpaul#include <sys/socket.h> 4312891Swpaul#include <netinet/in.h> 4412891Swpaul#include <arpa/inet.h> 4512997Swpaul#include <rpc/rpc.h> 4612891Swpaul 4712891Swpaul#ifndef lint 4816044Swpaulstatic const char rcsid[] = "$Id: yp_server.c,v 1.9 1996/04/28 04:38:52 wpaul Exp $"; 4912891Swpaul#endif /* not lint */ 5012891Swpaul 5112891Swpaulint forked = 0; 5212891Swpaulint children = 0; 5312891SwpaulDB *spec_dbp = NULL; /* Special global DB handle for ypproc_all. */ 5415426Swpaulchar *master_string = "YP_MASTER_NAME"; 5515426Swpaulchar *order_string = "YP_LAST_MODIFIED"; 5612891Swpaul 5714262Swpaul/* 5814262Swpaul * NIS v2 support. This is where most of the action happens. 5914262Swpaul */ 6014262Swpaul 6112891Swpaulvoid * 6212891Swpaulypproc_null_2_svc(void *argp, struct svc_req *rqstp) 6312891Swpaul{ 6412891Swpaul static char * result; 6512891Swpaul static char rval = 0; 6612891Swpaul 6712891Swpaul if (yp_access(NULL, (struct svc_req *)rqstp)) 6812891Swpaul return(NULL); 6912891Swpaul 7012891Swpaul result = &rval; 7112891Swpaul 7212891Swpaul return((void *) &result); 7312891Swpaul} 7412891Swpaul 7512891Swpaulbool_t * 7612891Swpaulypproc_domain_2_svc(domainname *argp, struct svc_req *rqstp) 7712891Swpaul{ 7812891Swpaul static bool_t result; 7912891Swpaul 8012891Swpaul if (yp_access(NULL, (struct svc_req *)rqstp)) { 8112891Swpaul result = FALSE; 8212891Swpaul return (&result); 8312891Swpaul } 8412891Swpaul 8512891Swpaul if (argp == NULL || yp_validdomain(*argp)) 8612891Swpaul result = FALSE; 8712891Swpaul else 8812891Swpaul result = TRUE; 8912891Swpaul 9012891Swpaul return (&result); 9112891Swpaul} 9212891Swpaul 9312891Swpaulbool_t * 9412891Swpaulypproc_domain_nonack_2_svc(domainname *argp, struct svc_req *rqstp) 9512891Swpaul{ 9612891Swpaul static bool_t result; 9712891Swpaul 9812891Swpaul if (yp_access(NULL, (struct svc_req *)rqstp)) 9912891Swpaul return (NULL); 10012891Swpaul 10112891Swpaul if (argp == NULL || yp_validdomain(*argp)) 10212891Swpaul return (NULL); 10312891Swpaul else 10412891Swpaul result = TRUE; 10512891Swpaul 10612891Swpaul return (&result); 10712891Swpaul} 10812891Swpaul 10912891Swpaulypresp_val * 11012891Swpaulypproc_match_2_svc(ypreq_key *argp, struct svc_req *rqstp) 11112891Swpaul{ 11212891Swpaul static ypresp_val result; 11312891Swpaul DBT key, data; 11412891Swpaul 11514304Swpaul result.val.valdat_val = ""; 11614304Swpaul result.val.valdat_len = 0; 11714304Swpaul 11812891Swpaul if (yp_access(argp->map, (struct svc_req *)rqstp)) { 11912891Swpaul result.stat = YP_YPERR; 12012891Swpaul return (&result); 12112891Swpaul } 12212891Swpaul 12312891Swpaul if (argp->domain == NULL || argp->map == NULL) { 12412891Swpaul result.stat = YP_BADARGS; 12512891Swpaul return (&result); 12612891Swpaul } 12712891Swpaul 12812891Swpaul key.size = argp->key.keydat_len; 12912891Swpaul key.data = argp->key.keydat_val; 13012891Swpaul 13115426Swpaul if ((result.stat = yp_get_record(argp->domain, argp->map, 13215426Swpaul &key, &data, 1)) == YP_TRUE) { 13312891Swpaul result.val.valdat_len = data.size; 13412891Swpaul result.val.valdat_val = data.data; 13512891Swpaul } 13612891Swpaul 13712891Swpaul /* 13812891Swpaul * Do DNS lookups for hosts maps if database lookup failed. 13912891Swpaul */ 14012891Swpaul 14112891Swpaul if (do_dns && result.stat != YP_TRUE && strstr(argp->map, "hosts")) { 14212997Swpaul char *rval = NULL; 14312891Swpaul 14412891Swpaul /* DNS lookups can take time -- do them in a subprocess */ 14512891Swpaul 14612891Swpaul if (!debug && children < MAX_CHILDREN && fork()) { 14712891Swpaul children++; 14812891Swpaul forked = 0; 14912891Swpaul /* 15012891Swpaul * Returning NULL here prevents svc_sendreply() 15112891Swpaul * from being called by the parent. This is vital 15212891Swpaul * since having both the parent and the child process 15312891Swpaul * call it would confuse the client. 15412891Swpaul */ 15512891Swpaul return (NULL); 15612891Swpaul } else { 15712891Swpaul forked++; 15812891Swpaul } 15912891Swpaul 16012891Swpaul if (debug) 16112891Swpaul yp_error("Doing DNS lookup of %.*s", 16212891Swpaul argp->key.keydat_len, 16312891Swpaul argp->key.keydat_val); 16412891Swpaul 16512891Swpaul /* NUL terminate! NUL terminate!! NUL TERMINATE!!! */ 16612891Swpaul argp->key.keydat_val[argp->key.keydat_len] = '\0'; 16712891Swpaul 16812891Swpaul if (!strcmp(argp->map, "hosts.byname")) 16912891Swpaul rval = yp_dnsname((char *)argp->key.keydat_val); 17012891Swpaul else if (!strcmp(argp->map, "hosts.byaddr")) 17112891Swpaul rval = yp_dnsaddr((const char *)argp->key.keydat_val); 17212891Swpaul 17312891Swpaul 17412891Swpaul if (rval) { 17512891Swpaul if (debug) 17614304Swpaul yp_error("DNS lookup successful. Result: %s", 17714304Swpaul rval); 17812891Swpaul result.val.valdat_len = strlen(rval); 17912891Swpaul result.val.valdat_val = rval; 18012891Swpaul result.stat = YP_TRUE; 18112891Swpaul } else { 18212891Swpaul if (debug) 18312891Swpaul yp_error("DNS lookup failed."); 18412891Swpaul result.stat = YP_NOKEY; 18512891Swpaul } 18612891Swpaul } 18712891Swpaul 18812891Swpaul return (&result); 18912891Swpaul} 19012891Swpaul 19112891Swpaulypresp_key_val * 19212891Swpaulypproc_first_2_svc(ypreq_nokey *argp, struct svc_req *rqstp) 19312891Swpaul{ 19412891Swpaul static ypresp_key_val result; 19512891Swpaul DBT key, data; 19612891Swpaul DB *dbp; 19712891Swpaul 19814304Swpaul result.val.valdat_val = result.key.keydat_val = ""; 19914304Swpaul result.val.valdat_len = result.key.keydat_len = 0; 20014304Swpaul 20112891Swpaul if (yp_access(argp->map, (struct svc_req *)rqstp)) { 20212891Swpaul result.stat = YP_YPERR; 20312891Swpaul return (&result); 20412891Swpaul } 20512891Swpaul 20612891Swpaul if (argp->domain == NULL) { 20712891Swpaul result.stat = YP_BADARGS; 20812891Swpaul return (&result); 20912891Swpaul } 21012891Swpaul 21115426Swpaul#ifdef DB_CACHE 21215426Swpaul if ((dbp = yp_open_db_cache(argp->domain, argp->map, NULL, 0)) == NULL) { 21315426Swpaul#else 21412891Swpaul if ((dbp = yp_open_db(argp->domain, argp->map)) == NULL) { 21515426Swpaul#endif 21612891Swpaul result.stat = yp_errno; 21712891Swpaul return(&result); 21812891Swpaul } 21912891Swpaul 22012891Swpaul key.data = NULL; 22112891Swpaul key.size = 0; 22212891Swpaul 22315426Swpaul if ((result.stat = yp_first_record(dbp, &key, &data, 0)) == YP_TRUE) { 22412891Swpaul result.key.keydat_len = key.size; 22512891Swpaul result.key.keydat_val = key.data; 22612891Swpaul result.val.valdat_len = data.size; 22712891Swpaul result.val.valdat_val = data.data; 22812891Swpaul } 22915426Swpaul#ifndef DB_CACHE 23015426Swpaul (void)(dbp->close)(dbp); 23115426Swpaul#endif 23212891Swpaul return (&result); 23312891Swpaul} 23412891Swpaul 23512891Swpaulypresp_key_val * 23612891Swpaulypproc_next_2_svc(ypreq_key *argp, struct svc_req *rqstp) 23712891Swpaul{ 23812891Swpaul static ypresp_key_val result; 23912891Swpaul DBT key, data; 24012891Swpaul DB *dbp; 24112891Swpaul 24214304Swpaul result.val.valdat_val = result.key.keydat_val = ""; 24314304Swpaul result.val.valdat_len = result.key.keydat_len = 0; 24415426Swpaul 24512891Swpaul if (yp_access(argp->map, (struct svc_req *)rqstp)) { 24612891Swpaul result.stat = YP_YPERR; 24712891Swpaul return (&result); 24812891Swpaul } 24912891Swpaul 25012891Swpaul if (argp->domain == NULL || argp->map == NULL) { 25112891Swpaul result.stat = YP_BADARGS; 25212891Swpaul return (&result); 25312891Swpaul } 25412891Swpaul 25515426Swpaul#ifdef DB_CACHE 25615426Swpaul if ((dbp = yp_open_db_cache(argp->domain, argp->map, 25715426Swpaul argp->key.keydat_val, 25815426Swpaul argp->key.keydat_len)) == NULL) { 25915426Swpaul#else 26012891Swpaul if ((dbp = yp_open_db(argp->domain, argp->map)) == NULL) { 26115426Swpaul#endif 26212891Swpaul result.stat = yp_errno; 26312891Swpaul return(&result); 26412891Swpaul } 26512891Swpaul 26612891Swpaul key.size = argp->key.keydat_len; 26712891Swpaul key.data = argp->key.keydat_val; 26812891Swpaul 26915426Swpaul if ((result.stat = yp_next_record(dbp, &key, &data,0,0)) == YP_TRUE) { 27012891Swpaul result.key.keydat_len = key.size; 27112891Swpaul result.key.keydat_val = key.data; 27212891Swpaul result.val.valdat_len = data.size; 27312891Swpaul result.val.valdat_val = data.data; 27412891Swpaul } 27515426Swpaul#ifndef DB_CACHE 27615426Swpaul (void)(dbp->close)(dbp); 27715426Swpaul#endif 27812891Swpaul return (&result); 27912891Swpaul} 28012891Swpaul 28112997Swpaulstatic void ypxfr_callback(rval,addr,transid,prognum,port) 28212997Swpaul ypxfrstat rval; 28312997Swpaul struct sockaddr_in *addr; 28412997Swpaul unsigned int transid; 28512997Swpaul unsigned int prognum; 28612997Swpaul unsigned long port; 28712997Swpaul{ 28812997Swpaul CLIENT *clnt; 28912997Swpaul int sock = RPC_ANYSOCK; 29012997Swpaul struct timeval timeout; 29112997Swpaul yppushresp_xfr ypxfr_resp; 29213375Swpaul struct rpc_err err; 29312997Swpaul 29413375Swpaul timeout.tv_sec = 5; 29512997Swpaul timeout.tv_usec = 0; 29612997Swpaul addr->sin_port = htons(port); 29712997Swpaul 29812997Swpaul if ((clnt = clntudp_create(addr, prognum, 1, timeout, &sock)) == NULL) 29912997Swpaul yp_error("%s", clnt_spcreateerror("failed to establish \ 30012997Swpaulcallback handle")); 30112997Swpaul 30212997Swpaul ypxfr_resp.status = rval; 30312997Swpaul ypxfr_resp.transid = transid; 30412997Swpaul 30513375Swpaul /* Turn the timeout off -- we don't want to block. */ 30613375Swpaul timeout.tv_sec = 0; 30713375Swpaul if (clnt_control(clnt, CLSET_TIMEOUT, (char *)&timeout) == FALSE) 30813375Swpaul yp_error("failed to set timeout on ypproc_xfr callback"); 30912997Swpaul 31013375Swpaul if (yppushproc_xfrresp_1(&ypxfr_resp, clnt) == NULL) { 31113375Swpaul clnt_geterr(clnt, &err); 31213375Swpaul if (err.re_status != RPC_SUCCESS && 31313375Swpaul err.re_status != RPC_TIMEDOUT) 31413375Swpaul yp_error("%s", clnt_sperror(clnt, 31513375Swpaul "ypxfr callback failed")); 31613375Swpaul } 31713375Swpaul 31812997Swpaul clnt_destroy(clnt); 31912997Swpaul return; 32012997Swpaul} 32112997Swpaul 32215426Swpaul#define YPXFR_RETURN(CODE) \ 32315426Swpaul /* Order is important: send regular RPC reply, then callback */ \ 32415426Swpaul result.xfrstat = CODE; \ 32515426Swpaul svc_sendreply(rqstp->rq_xprt, xdr_ypresp_xfr, (char *)&result); \ 32615426Swpaul ypxfr_callback(CODE,rqhost,argp->transid, \ 32715426Swpaul argp->prog,argp->port); \ 32815426Swpaul return(NULL); 32915426Swpaul 33012891Swpaulypresp_xfr * 33112891Swpaulypproc_xfr_2_svc(ypreq_xfr *argp, struct svc_req *rqstp) 33212891Swpaul{ 33312891Swpaul static ypresp_xfr result; 33412997Swpaul struct sockaddr_in *rqhost; 33512891Swpaul 33613375Swpaul result.transid = argp->transid; 33713375Swpaul rqhost = svc_getcaller(rqstp->rq_xprt); 33813375Swpaul 33912891Swpaul if (yp_access(argp->map_parms.map, (struct svc_req *)rqstp)) { 34015426Swpaul YPXFR_RETURN(YPXFR_REFUSED); 34112891Swpaul } 34212891Swpaul 34312891Swpaul if (argp->map_parms.domain == NULL) { 34415426Swpaul YPXFR_RETURN(YPXFR_BADARGS); 34512891Swpaul } 34612891Swpaul 34712891Swpaul if (yp_validdomain(argp->map_parms.domain)) { 34815426Swpaul YPXFR_RETURN(YPXFR_NODOM); 34912891Swpaul } 35012891Swpaul 35112891Swpaul switch(fork()) { 35212891Swpaul case 0: 35312891Swpaul { 35412891Swpaul char g[11], t[11], p[11]; 35512891Swpaul char ypxfr_command[MAXPATHLEN + 2]; 35612891Swpaul 35712891Swpaul sprintf (ypxfr_command, "%sypxfr", _PATH_LIBEXEC); 35812891Swpaul sprintf (t, "%u", argp->transid); 35912891Swpaul sprintf (g, "%u", argp->prog); 36012891Swpaul sprintf (p, "%u", argp->port); 36112997Swpaul if (debug) 36212997Swpaul close(0); close(1); close(2); 36312997Swpaul if (strcmp(yp_dir, _PATH_YP)) { 36414304Swpaul execl(ypxfr_command, "ypxfr", 36514304Swpaul "-d", argp->map_parms.domain, 36614304Swpaul "-h", argp->map_parms.peer, 36714304Swpaul "-p", yp_dir, "-C", t, 36814304Swpaul g, inet_ntoa(rqhost->sin_addr), 36914304Swpaul p, argp->map_parms.map, 37012997Swpaul NULL); 37112997Swpaul } else { 37214304Swpaul execl(ypxfr_command, "ypxfr", 37314304Swpaul "-d", argp->map_parms.domain, 37414304Swpaul "-h", argp->map_parms.peer, 37514304Swpaul "-C", t, 37614304Swpaul g, inet_ntoa(rqhost->sin_addr), 37714304Swpaul p, argp->map_parms.map, 37812997Swpaul NULL); 37912997Swpaul } 38012997Swpaul forked++; 38115426Swpaul yp_error("ypxfr execl(%s): %s", ypxfr_command, strerror(errno)); 38215426Swpaul YPXFR_RETURN(YPXFR_XFRERR); 38312997Swpaul break; 38412891Swpaul } 38512891Swpaul case -1: 38612891Swpaul yp_error("ypxfr fork(): %s", strerror(errno)); 38715426Swpaul YPXFR_RETURN(YPXFR_XFRERR); 38812891Swpaul break; 38912891Swpaul default: 39013375Swpaul result.xfrstat = YPXFR_SUCC; 39112997Swpaul children++; 39212997Swpaul forked = 0; 39312891Swpaul break; 39412891Swpaul } 39513375Swpaul 39613375Swpaul return (&result); 39712891Swpaul} 39815426Swpaul#undef YPXFR_RETURN 39912891Swpaul 40012891Swpaulvoid * 40112891Swpaulypproc_clear_2_svc(void *argp, struct svc_req *rqstp) 40212891Swpaul{ 40312891Swpaul static char * result; 40412891Swpaul static char rval = 0; 40512891Swpaul 40612891Swpaul if (yp_access(NULL, (struct svc_req *)rqstp)) 40712891Swpaul return (NULL); 40815426Swpaul#ifdef DB_CACHE 40915426Swpaul /* clear out the database cache */ 41015426Swpaul yp_flush_all(); 41115426Swpaul#endif 41214240Swpaul /* Re-read the securenets database for the hell of it. */ 41314240Swpaul load_securenets(); 41414240Swpaul 41512891Swpaul result = &rval; 41612891Swpaul return((void *) &result); 41712891Swpaul} 41812891Swpaul 41912891Swpaul/* 42012891Swpaul * For ypproc_all, we have to send a stream of ypresp_all structures 42112891Swpaul * via TCP, but the XDR filter generated from the yp.x protocol 42212891Swpaul * definition file only serializes one such structure. This means that 42312891Swpaul * to send the whole stream, you need a wrapper which feeds all the 42412891Swpaul * records into the underlying XDR routine until it hits an 'EOF.' 42512891Swpaul * But to use the wrapper, you have to violate the boundaries between 42612891Swpaul * RPC layers by calling svc_sendreply() directly from the ypproc_all 42712891Swpaul * service routine instead of letting the RPC dispatcher do it. 42812891Swpaul * 42912891Swpaul * Bleah. 43012891Swpaul */ 43112891Swpaul 43212891Swpaul/* 43312891Swpaul * Custom XDR routine for serialzing results of ypproc_all: keep 43412891Swpaul * reading from the database and spew until we run out of records 43512891Swpaul * or encounter an error. 43612891Swpaul */ 43712891Swpaulstatic bool_t 43812891Swpaulxdr_my_ypresp_all(register XDR *xdrs, ypresp_all *objp) 43912891Swpaul{ 44015426Swpaul DBT key = { NULL, 0 } , data = { NULL, 0 }; 44112891Swpaul 44212891Swpaul while (1) { 44312891Swpaul /* Get a record. */ 44412891Swpaul if ((objp->ypresp_all_u.val.stat = 44515426Swpaul yp_next_record(spec_dbp,&key,&data,1,0)) == YP_TRUE) { 44612891Swpaul objp->ypresp_all_u.val.val.valdat_len = data.size; 44712891Swpaul objp->ypresp_all_u.val.val.valdat_val = data.data; 44812891Swpaul objp->ypresp_all_u.val.key.keydat_len = key.size; 44912891Swpaul objp->ypresp_all_u.val.key.keydat_val = key.data; 45012891Swpaul objp->more = TRUE; 45112891Swpaul } else { 45212891Swpaul objp->more = FALSE; 45312891Swpaul } 45412891Swpaul 45512891Swpaul /* Serialize. */ 45612891Swpaul if (!xdr_ypresp_all(xdrs, objp)) 45712891Swpaul return(FALSE); 45812891Swpaul if (objp->more == FALSE) 45912891Swpaul return(TRUE); 46012891Swpaul } 46112891Swpaul} 46212891Swpaul 46312891Swpaulypresp_all * 46412891Swpaulypproc_all_2_svc(ypreq_nokey *argp, struct svc_req *rqstp) 46512891Swpaul{ 46612891Swpaul static ypresp_all result; 46712891Swpaul 46812891Swpaul /* 46912891Swpaul * Set this here so that the client will be forced to make 47012891Swpaul * at least one attempt to read from us even if all we're 47112891Swpaul * doing is returning an error. 47212891Swpaul */ 47312891Swpaul result.more = TRUE; 47414304Swpaul result.ypresp_all_u.val.key.keydat_len = 0; 47514304Swpaul result.ypresp_all_u.val.key.keydat_val = ""; 47612891Swpaul 47712891Swpaul if (yp_access(argp->map, (struct svc_req *)rqstp)) { 47812891Swpaul result.ypresp_all_u.val.stat = YP_YPERR; 47912891Swpaul return (&result); 48012891Swpaul } 48112891Swpaul 48212891Swpaul if (argp->domain == NULL || argp->map == NULL) { 48312891Swpaul result.ypresp_all_u.val.stat = YP_BADARGS; 48412891Swpaul return (&result); 48512891Swpaul } 48612891Swpaul 48712891Swpaul /* 48812891Swpaul * The ypproc_all procedure can take a while to complete. 48912891Swpaul * Best to handle it in a subprocess so the parent doesn't 49015426Swpaul * block. (Is there a better way to do this? Maybe with 49115426Swpaul * async socket I/O?) 49212891Swpaul */ 49312891Swpaul if (!debug && children < MAX_CHILDREN && fork()) { 49412891Swpaul children++; 49512891Swpaul forked = 0; 49612891Swpaul return (NULL); 49712891Swpaul } else { 49812891Swpaul forked++; 49912891Swpaul } 50012891Swpaul 50115426Swpaul#ifndef DB_CACHE 50212891Swpaul if ((spec_dbp = yp_open_db(argp->domain, argp->map)) == NULL) { 50312891Swpaul result.ypresp_all_u.val.stat = yp_errno; 50412891Swpaul return(&result); 50512891Swpaul } 50615426Swpaul#else 50715426Swpaul if ((spec_dbp = yp_open_db_cache(argp->domain, argp->map, NULL, 0)) == NULL) { 50815426Swpaul result.ypresp_all_u.val.stat = yp_errno; 50915426Swpaul return(&result); 51015426Swpaul } 51115426Swpaul#endif 51212891Swpaul 51312891Swpaul /* Kick off the actual data transfer. */ 51412891Swpaul svc_sendreply(rqstp->rq_xprt, xdr_my_ypresp_all, (char *)&result); 51512891Swpaul 51615426Swpaul#ifndef DB_CACHE 51712891Swpaul (void)(spec_dbp->close)(spec_dbp); 51815426Swpaul#endif 51912891Swpaul /* 52012891Swpaul * Returning NULL prevents the dispatcher from calling 52112891Swpaul * svc_sendreply() since we already did it. 52212891Swpaul */ 52312891Swpaul return (NULL); 52412891Swpaul} 52512891Swpaul 52612891Swpaulypresp_master * 52712891Swpaulypproc_master_2_svc(ypreq_nokey *argp, struct svc_req *rqstp) 52812891Swpaul{ 52912891Swpaul static ypresp_master result; 53015426Swpaul static char ypvalbuf[YPMAXRECORD]; 53115426Swpaul DBT key, data; 53212891Swpaul 53314303Swpaul result.peer = ""; 53414303Swpaul 53512891Swpaul if (yp_access(NULL, (struct svc_req *)rqstp)) { 53612891Swpaul result.stat = YP_YPERR; 53712891Swpaul return(&result); 53812891Swpaul } 53912891Swpaul 54012891Swpaul if (argp->domain == NULL) { 54112891Swpaul result.stat = YP_BADARGS; 54212891Swpaul return (&result); 54312891Swpaul } 54412891Swpaul 54515426Swpaul key.data = master_string; 54615426Swpaul key.size = strlen(master_string); 54712891Swpaul 54815426Swpaul /* 54915426Swpaul * Note that we copy the data retrieved from the database to 55015426Swpaul * a private buffer and NUL terminate the buffer rather than 55115426Swpaul * terminating the data in place. We do this because by stuffing 55215426Swpaul * a '\0' into data.data, we will actually be corrupting memory 55315426Swpaul * allocated by the DB package. This is a bad thing now that we 55415426Swpaul * cache DB handles rather than closing the database immediately. 55515426Swpaul */ 55615426Swpaul if ((result.stat = yp_get_record(argp->domain, argp->map, 55715426Swpaul &key, &data, 1)) == YP_TRUE) { 55815426Swpaul bcopy((char *)data.data, (char *)&ypvalbuf, data.size); 55915426Swpaul ypvalbuf[data.size] = '\0'; 56015426Swpaul result.peer = (char *)&ypvalbuf; 56112891Swpaul } else 56212891Swpaul result.peer = ""; 56312891Swpaul 56412891Swpaul return (&result); 56512891Swpaul} 56612891Swpaul 56712891Swpaulypresp_order * 56812891Swpaulypproc_order_2_svc(ypreq_nokey *argp, struct svc_req *rqstp) 56912891Swpaul{ 57012891Swpaul static ypresp_order result; 57112891Swpaul DBT key,data; 57212891Swpaul 57314304Swpaul result.ordernum = 0; 57414304Swpaul 57512891Swpaul if (yp_access(NULL, (struct svc_req *)rqstp)) { 57612891Swpaul result.stat = YP_YPERR; 57712891Swpaul return(&result); 57812891Swpaul } 57912891Swpaul 58012891Swpaul if (argp->domain == NULL) { 58112891Swpaul result.stat = YP_BADARGS; 58212891Swpaul return (&result); 58312891Swpaul } 58412891Swpaul 58512891Swpaul /* 58612891Swpaul * We could just check the timestamp on the map file, 58712891Swpaul * but that's a hack: we'll only know the last time the file 58812891Swpaul * was touched, not the last time the database contents were 58912891Swpaul * updated. 59012891Swpaul */ 59112891Swpaul 59215426Swpaul key.data = order_string; 59315426Swpaul key.size = strlen(order_string); 59412891Swpaul 59515426Swpaul if ((result.stat = yp_get_record(argp->domain, argp->map, 59615426Swpaul &key, &data, 1)) == YP_TRUE) 59712891Swpaul result.ordernum = atoi((char *)data.data); 59812891Swpaul else 59912891Swpaul result.ordernum = 0; 60012891Swpaul 60115426Swpaul 60212891Swpaul return (&result); 60312891Swpaul} 60412891Swpaul 60512891Swpaulstatic void yp_maplist_free(yp_maplist) 60612891Swpaul struct ypmaplist *yp_maplist; 60712891Swpaul{ 60812891Swpaul register struct ypmaplist *next; 60912891Swpaul 61012891Swpaul while(yp_maplist) { 61112891Swpaul next = yp_maplist->next; 61212891Swpaul free(yp_maplist->map); 61312891Swpaul free(yp_maplist); 61412891Swpaul yp_maplist = next; 61512891Swpaul } 61612891Swpaul return; 61712891Swpaul} 61812891Swpaul 61912891Swpaulstatic struct ypmaplist *yp_maplist_create(domain) 62012891Swpaul const char *domain; 62112891Swpaul{ 62212891Swpaul char yp_mapdir[MAXPATHLEN + 2]; 62312891Swpaul char yp_mapname[MAXPATHLEN + 2]; 62412891Swpaul struct ypmaplist *cur = NULL; 62512891Swpaul struct ypmaplist *yp_maplist = NULL; 62612891Swpaul DIR *dird; 62712891Swpaul struct dirent *dirp; 62812891Swpaul struct stat statbuf; 62912891Swpaul 63012891Swpaul snprintf(yp_mapdir, sizeof(yp_mapdir), "%s/%s", yp_dir, domain); 63112891Swpaul 63212891Swpaul if ((dird = opendir(yp_mapdir)) == NULL) { 63313800Swpaul yp_error("opendir(%s) failed: %s", yp_mapdir, strerror(errno)); 63412891Swpaul return(NULL); 63512891Swpaul } 63612891Swpaul 63712891Swpaul while ((dirp = readdir(dird)) != NULL) { 63812891Swpaul if (strcmp(dirp->d_name, ".") && strcmp(dirp->d_name, "..")) { 63914304Swpaul snprintf(yp_mapname, sizeof(yp_mapname), "%s/%s", 64014304Swpaul yp_mapdir,dirp->d_name); 64114304Swpaul if (stat(yp_mapname, &statbuf) < 0 || 64214304Swpaul !S_ISREG(statbuf.st_mode)) 64312891Swpaul continue; 64414304Swpaul if ((cur = (struct ypmaplist *) 64516044Swpaul malloc(sizeof(struct ypmaplist))) == NULL) { 64614304Swpaul yp_error("malloc() failed: %s",strerror(errno)); 64712891Swpaul closedir(dird); 64812891Swpaul yp_maplist_free(yp_maplist); 64912891Swpaul return(NULL); 65012891Swpaul } 65112891Swpaul if ((cur->map = (char *)strdup(dirp->d_name)) == NULL) { 65214304Swpaul yp_error("strdup() failed: %s",strerror(errno)); 65312891Swpaul closedir(dird); 65412891Swpaul yp_maplist_free(yp_maplist); 65512891Swpaul return(NULL); 65612891Swpaul } 65712891Swpaul cur->next = yp_maplist; 65812891Swpaul yp_maplist = cur; 65912891Swpaul if (debug) 66012891Swpaul yp_error("map: %s", yp_maplist->map); 66112891Swpaul } 66212891Swpaul 66312891Swpaul } 66412891Swpaul closedir(dird); 66512891Swpaul return(yp_maplist); 66612891Swpaul} 66712891Swpaul 66812891Swpaulypresp_maplist * 66912891Swpaulypproc_maplist_2_svc(domainname *argp, struct svc_req *rqstp) 67012891Swpaul{ 67115426Swpaul static ypresp_maplist result = { 0, NULL }; 67212891Swpaul 67312891Swpaul if (yp_access(NULL, (struct svc_req *)rqstp)) { 67412891Swpaul result.stat = YP_YPERR; 67512891Swpaul return(&result); 67612891Swpaul } 67712891Swpaul 67812891Swpaul if (argp == NULL) { 67912891Swpaul result.stat = YP_BADARGS; 68012891Swpaul return (&result); 68112891Swpaul } 68212891Swpaul 68312891Swpaul if (yp_validdomain(*argp)) { 68412891Swpaul result.stat = YP_NODOM; 68512891Swpaul return (&result); 68612891Swpaul } 68712891Swpaul 68812891Swpaul /* 68912891Swpaul * We have to construct a linked list for the ypproc_maplist 69012891Swpaul * procedure using dynamically allocated memory. Since the XDR 69112891Swpaul * layer won't free this list for us, we have to deal with it 69212891Swpaul * ourselves. We call yp_maplist_free() first to free any 69312891Swpaul * previously allocated data we may have accumulated to insure 69412891Swpaul * that we have only one linked list in memory at any given 69512891Swpaul * time. 69612891Swpaul */ 69712891Swpaul 69812891Swpaul yp_maplist_free(result.maps); 69912891Swpaul 70012891Swpaul if ((result.maps = yp_maplist_create(*argp)) == NULL) { 70112891Swpaul yp_error("yp_maplist_create failed"); 70212891Swpaul result.stat = YP_YPERR; 70312891Swpaul return(&result); 70412891Swpaul } else 70512891Swpaul result.stat = YP_TRUE; 70612891Swpaul 70712891Swpaul return (&result); 70812891Swpaul} 70914262Swpaul 71014262Swpaul/* 71114262Swpaul * NIS v1 support. The nullproc, domain and domain_nonack 71214262Swpaul * functions from v1 are identical to those in v2, so all 71314262Swpaul * we have to do is hand off to them. 71414262Swpaul * 71514262Swpaul * The other functions are mostly just wrappers around their v2 71614262Swpaul * counterparts. For example, for the v1 'match' procedure, we 71714262Swpaul * crack open the argument structure, make a request to the v2 71814262Swpaul * 'match' function, repackage the data into a v1 response and 71914262Swpaul * then send it on its way. 72014262Swpaul * 72114262Swpaul * Note that we don't support the pull, push and get procedures. 72214262Swpaul * There's little documentation available to show what they 72314262Swpaul * do, and I suspect they're meant largely for map transfers 72414262Swpaul * between master and slave servers. 72514262Swpaul */ 72614262Swpaul 72714262Swpaulvoid * 72814262Swpaulypoldproc_null_1_svc(void *argp, struct svc_req *rqstp) 72914262Swpaul{ 73014262Swpaul return(ypproc_null_2_svc(argp, rqstp)); 73114262Swpaul} 73214262Swpaul 73314262Swpaulbool_t * 73414262Swpaulypoldproc_domain_1_svc(domainname *argp, struct svc_req *rqstp) 73514262Swpaul{ 73614262Swpaul return(ypproc_domain_2_svc(argp, rqstp)); 73714262Swpaul} 73814262Swpaul 73914262Swpaulbool_t * 74014262Swpaulypoldproc_domain_nonack_1_svc(domainname *argp, struct svc_req *rqstp) 74114262Swpaul{ 74214262Swpaul return (ypproc_domain_nonack_2_svc(argp, rqstp)); 74314262Swpaul} 74414262Swpaul 74514304Swpaul/* 74614304Swpaul * the 'match' procedure sends a response of type YPRESP_VAL 74714304Swpaul */ 74814262Swpaulypresponse * 74914262Swpaulypoldproc_match_1_svc(yprequest *argp, struct svc_req *rqstp) 75014262Swpaul{ 75114262Swpaul static ypresponse result; 75214262Swpaul ypresp_val *v2_result; 75314262Swpaul 75414262Swpaul result.yp_resptype = YPRESP_VAL; 75514304Swpaul result.ypresponse_u.yp_resp_valtype.val.valdat_val = ""; 75614304Swpaul result.ypresponse_u.yp_resp_valtype.val.valdat_len = 0; 75714262Swpaul 75814262Swpaul if (argp->yp_reqtype != YPREQ_KEY) { 75914262Swpaul result.ypresponse_u.yp_resp_valtype.stat = YP_BADARGS; 76014262Swpaul return(&result); 76114262Swpaul } 76214262Swpaul 76314262Swpaul v2_result = ypproc_match_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp); 76414262Swpaul if (v2_result == NULL) 76514262Swpaul return(NULL); 76614262Swpaul 76714262Swpaul bcopy((char *)v2_result, 76814262Swpaul (char *)&result.ypresponse_u.yp_resp_valtype, 76914262Swpaul sizeof(ypresp_val)); 77014262Swpaul 77114262Swpaul return (&result); 77214262Swpaul} 77314262Swpaul 77414304Swpaul/* 77514304Swpaul * the 'first' procedure sends a response of type YPRESP_KEY_VAL 77614304Swpaul */ 77714262Swpaulypresponse * 77814262Swpaulypoldproc_first_1_svc(yprequest *argp, struct svc_req *rqstp) 77914262Swpaul{ 78014262Swpaul static ypresponse result; 78114262Swpaul ypresp_key_val *v2_result; 78214262Swpaul 78314262Swpaul result.yp_resptype = YPRESP_KEY_VAL; 78414304Swpaul result.ypresponse_u.yp_resp_key_valtype.val.valdat_val = 78514304Swpaul result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = ""; 78614304Swpaul result.ypresponse_u.yp_resp_key_valtype.val.valdat_len = 78714304Swpaul result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0; 78814262Swpaul 78914262Swpaul if (argp->yp_reqtype != YPREQ_NOKEY) { 79014262Swpaul result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS; 79114262Swpaul return(&result); 79214262Swpaul } 79314262Swpaul 79414262Swpaul v2_result = ypproc_first_2_svc(&argp->yprequest_u.yp_req_nokeytype, 79514262Swpaul rqstp); 79614262Swpaul if (v2_result == NULL) 79714262Swpaul return(NULL); 79814262Swpaul 79914262Swpaul bcopy((char *)v2_result, 80014262Swpaul (char *)&result.ypresponse_u.yp_resp_key_valtype, 80114262Swpaul sizeof(ypresp_key_val)); 80214262Swpaul 80314262Swpaul return (&result); 80414262Swpaul} 80514262Swpaul 80614304Swpaul/* 80714304Swpaul * the 'next' procedure sends a response of type YPRESP_KEY_VAL 80814304Swpaul */ 80914262Swpaulypresponse * 81014262Swpaulypoldproc_next_1_svc(yprequest *argp, struct svc_req *rqstp) 81114262Swpaul{ 81214262Swpaul static ypresponse result; 81314262Swpaul ypresp_key_val *v2_result; 81414262Swpaul 81514262Swpaul result.yp_resptype = YPRESP_KEY_VAL; 81614304Swpaul result.ypresponse_u.yp_resp_key_valtype.val.valdat_val = 81714304Swpaul result.ypresponse_u.yp_resp_key_valtype.key.keydat_val = ""; 81814304Swpaul result.ypresponse_u.yp_resp_key_valtype.val.valdat_len = 81914304Swpaul result.ypresponse_u.yp_resp_key_valtype.key.keydat_len = 0; 82014262Swpaul 82114262Swpaul if (argp->yp_reqtype != YPREQ_KEY) { 82214262Swpaul result.ypresponse_u.yp_resp_key_valtype.stat = YP_BADARGS; 82314262Swpaul return(&result); 82414262Swpaul } 82514262Swpaul 82614262Swpaul v2_result = ypproc_next_2_svc(&argp->yprequest_u.yp_req_keytype,rqstp); 82714262Swpaul if (v2_result == NULL) 82814262Swpaul return(NULL); 82914262Swpaul 83014262Swpaul bcopy((char *)v2_result, 83114262Swpaul (char *)&result.ypresponse_u.yp_resp_key_valtype, 83214262Swpaul sizeof(ypresp_key_val)); 83314262Swpaul 83414262Swpaul return (&result); 83514262Swpaul} 83614262Swpaul 83714304Swpaul/* 83814304Swpaul * the 'poll' procedure sends a response of type YPRESP_MAP_PARMS 83914304Swpaul */ 84014262Swpaulypresponse * 84114262Swpaulypoldproc_poll_1_svc(yprequest *argp, struct svc_req *rqstp) 84214262Swpaul{ 84314262Swpaul static ypresponse result; 84414262Swpaul ypresp_master *v2_result1; 84514262Swpaul ypresp_order *v2_result2; 84614262Swpaul 84714262Swpaul result.yp_resptype = YPRESP_MAP_PARMS; 84814262Swpaul result.ypresponse_u.yp_resp_map_parmstype.domain = 84914262Swpaul argp->yprequest_u.yp_req_nokeytype.domain; 85014262Swpaul result.ypresponse_u.yp_resp_map_parmstype.map = 85114262Swpaul argp->yprequest_u.yp_req_nokeytype.map; 85214262Swpaul /* 85314262Swpaul * Hmm... there is no 'status' value in the 85414262Swpaul * yp_resp_map_parmstype structure, so I have to 85514262Swpaul * guess at what to do to indicate a failure. 85614262Swpaul * I hope this is right. 85714262Swpaul */ 85814262Swpaul result.ypresponse_u.yp_resp_map_parmstype.ordernum = 0; 85914262Swpaul result.ypresponse_u.yp_resp_map_parmstype.peer = ""; 86014262Swpaul 86114262Swpaul if (argp->yp_reqtype != YPREQ_MAP_PARMS) { 86214262Swpaul return(&result); 86314262Swpaul } 86414262Swpaul 86514262Swpaul v2_result1 = ypproc_master_2_svc(&argp->yprequest_u.yp_req_nokeytype, 86614262Swpaul rqstp); 86714262Swpaul if (v2_result1 == NULL) 86814262Swpaul return(NULL); 86914262Swpaul 87014262Swpaul if (v2_result1->stat != YP_TRUE) { 87114262Swpaul return(&result); 87214262Swpaul } 87314262Swpaul 87414262Swpaul v2_result2 = ypproc_order_2_svc(&argp->yprequest_u.yp_req_nokeytype, 87514262Swpaul rqstp); 87614262Swpaul if (v2_result2 == NULL) 87714262Swpaul return(NULL); 87814262Swpaul 87914262Swpaul if (v2_result2->stat != YP_TRUE) { 88014262Swpaul return(&result); 88114262Swpaul } 88214262Swpaul 88314262Swpaul result.ypresponse_u.yp_resp_map_parmstype.peer = 88414262Swpaul v2_result1->peer; 88514262Swpaul result.ypresponse_u.yp_resp_map_parmstype.ordernum = 88614262Swpaul v2_result2->ordernum; 88714262Swpaul 88814262Swpaul return (&result); 88914262Swpaul} 89014262Swpaul 89114262Swpaulypresponse * 89214262Swpaulypoldproc_push_1_svc(yprequest *argp, struct svc_req *rqstp) 89314262Swpaul{ 89414262Swpaul static ypresponse result; 89514262Swpaul 89614262Swpaul /* 89714262Swpaul * Not implemented. 89814262Swpaul */ 89914262Swpaul 90014262Swpaul return (&result); 90114262Swpaul} 90214262Swpaul 90314262Swpaulypresponse * 90414262Swpaulypoldproc_pull_1_svc(yprequest *argp, struct svc_req *rqstp) 90514262Swpaul{ 90614262Swpaul static ypresponse result; 90714262Swpaul 90814262Swpaul /* 90914262Swpaul * Not implemented. 91014262Swpaul */ 91114262Swpaul 91214262Swpaul return (&result); 91314262Swpaul} 91414262Swpaul 91514262Swpaulypresponse * 91614262Swpaulypoldproc_get_1_svc(yprequest *argp, struct svc_req *rqstp) 91714262Swpaul{ 91814262Swpaul static ypresponse result; 91914262Swpaul 92014262Swpaul /* 92114262Swpaul * Not implemented. 92214262Swpaul */ 92314262Swpaul 92414262Swpaul return (&result); 92514262Swpaul} 926