Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/ypserv/ypserv/ypserv_db.c	Lines:	0	289	0.0 %
Date:	2017-11-07	Branches:	0	190	0.0 %


/*	$OpenBSD: ypserv_db.c,v 1.30 2015/12/08 07:16:33 mmcc Exp $ */

/*
 * Copyright (c) 1994 Mats O Jansson <moj@stacken.kth.se>
 * Copyright (c) 1996 Charles D. Cranor
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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.
 */

/*
 * major revision/cleanup of Mats' version
 * done by Chuck Cranor <chuck@ccrc.wustl.edu>
 * Jan 1996.
 */

#include <rpc/rpc.h>
#include <rpcsvc/yp.h>
#include <rpcsvc/ypclnt.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <netdb.h>
#include <arpa/nameser.h>
#include <resolv.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/queue.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <syslog.h>
#include <errno.h>
#include "yplog.h"
#include "ypdb.h"
#include "ypdef.h"
#include "ypserv.h"

LIST_HEAD(domainlist, opt_domain);	/* LIST of domains */
LIST_HEAD(maplist, opt_map);		/* LIST of maps (in a domain) */
TAILQ_HEAD(mapq, opt_map);		/* TAILQ of maps (LRU) */

struct opt_map {
	mapname map;			/* map name (malloc'd) */
	DBM	*db;			/* database */
	struct opt_domain *dom;         /* back ptr to our domain */
	int     host_lookup;            /* host lookup */
	int     secure;                 /* secure map? */
	TAILQ_ENTRY(opt_map) mapsq;   /* map queue pointers */
	LIST_ENTRY(opt_map) mapsl;      /* map list pointers */
};

struct opt_domain {
	domainname	domain;         /* domain name (malloc'd) */
	struct maplist	dmaps;          /* the domain's active maps */
	LIST_ENTRY(opt_domain) domsl;	/* global linked list of domains */
};

struct domainlist doms;			/* global list of domains */
struct mapq maps;			/* global queue of maps (LRU) */

extern int usedns;

/*
 * ypdb_init: init the queues and lists
 */
void
ypdb_init(void)
{
	LIST_INIT(&doms);
	TAILQ_INIT(&maps);
}

/*
 * yp_private:
 * Check if key is a YP private key. Return TRUE if it is and
 * ypprivate is FALSE.
 */
static int
yp_private(datum key, int ypprivate)
{
	if (ypprivate)
		return (FALSE);

	if (key.dsize == 0 || key.dptr == NULL)
		return (FALSE);

	if (key.dsize == YP_LAST_LEN &&
	    strncmp(key.dptr, YP_LAST_KEY, YP_LAST_LEN) == 0)
		return(TRUE);
	if (key.dsize == YP_INPUT_LEN &&
	    strncmp(key.dptr, YP_INPUT_KEY, YP_INPUT_LEN) == 0)
		return(TRUE);
	if (key.dsize == YP_OUTPUT_LEN &&
	    strncmp(key.dptr, YP_OUTPUT_KEY, YP_OUTPUT_LEN) == 0)
		return(TRUE);
	if (key.dsize == YP_MASTER_LEN &&
	    strncmp(key.dptr, YP_MASTER_KEY, YP_MASTER_LEN) == 0)
		return(TRUE);
	if (key.dsize == YP_DOMAIN_LEN &&
	    strncmp(key.dptr, YP_DOMAIN_KEY, YP_DOMAIN_LEN) == 0)
		return(TRUE);
	if (key.dsize == YP_INTERDOMAIN_LEN &&
	    strncmp(key.dptr, YP_INTERDOMAIN_KEY, YP_INTERDOMAIN_LEN) == 0)
		return(TRUE);
	if (key.dsize == YP_SECURE_LEN &&
	    strncmp(key.dptr, YP_SECURE_KEY, YP_SECURE_LEN) == 0)
		return(TRUE);
	return(FALSE);
}

/*
 * Close least recent used map. This routine is called when we have
 * no more file descripotors free, or we want to close all maps.
 */
static void
ypdb_close_last(void)
{
	struct opt_map *last;

	if (TAILQ_EMPTY(&maps)) {
		yplog("  ypdb_close_last: LRU list is empty!");
		return;
	}

	last = TAILQ_LAST(&maps, mapq);

	TAILQ_REMOVE(&maps, last, mapsq);	/* remove from LRU circleq */
	LIST_REMOVE(last, mapsl);		/* remove from domain list */

#ifdef DEBUG
	yplog("  ypdb_close_last: closing map %s in domain %s [db=0x%x]",
	    last->map, last->dom->domain, last->db);
#endif

	ypdb_close(last->db);			/* close DB */
	free(last->map);			/* free map name */
	free(last);				/* free map */
}

/*
 * Close all open maps.
 */
void
ypdb_close_all(void)
{

#ifdef DEBUG
	yplog("  ypdb_close_all(): start");
#endif
	while (!TAILQ_EMPTY(&maps))
		ypdb_close_last();
#ifdef DEBUG
	yplog("  ypdb_close_all(): done");
#endif
}

/*
 * Close Database if Open/Close Optimization isn't turned on.
 */
static void
ypdb_close_db(DBM *db)
{
#ifdef DEBUG
	yplog("  ypdb_close_db(0x%x)", db);
#endif
#ifndef OPTDB
	ypdb_close_all();
#endif
}

/*
 * ypdb_open_db
 */
DBM *
ypdb_open_db(domainname domain, mapname map, ypstat *status,
    struct opt_map **map_info)
{
	char map_path[PATH_MAX];
	static char   *domain_key = YP_INTERDOMAIN_KEY;
	static char   *secure_key = YP_SECURE_KEY;
	DBM	*db;
	struct opt_domain *d = NULL;
	struct opt_map	*m = NULL;
	datum	k, v;
#ifdef OPTDB
	int	i;
#endif

	/*
	 * check for preloaded domain, map
	 */
	LIST_FOREACH(d, &doms, domsl) {
		if (strcmp(domain, d->domain) == 0)
			break;
	}

	if (d) {
		LIST_FOREACH(m, &d->dmaps, mapsl)
			if (strcmp(map, m->map) == 0)
				break;
	}

	/*
	 * map found open?
	 */
	if (m) {
#ifdef DEBUG
		yplog("  ypdb_open_db: cached open: domain=%s, map=%s, db=0x%x",
		    domain, map, m->db);
#endif
		TAILQ_REMOVE(&maps, m, mapsq);	/* adjust LRU queue */
		TAILQ_INSERT_HEAD(&maps, m, mapsq);
		*status = YP_TRUE;
		if (map_info)
			*map_info = m;
		return(m->db);
	}

	/* Check for illegal charcaters */

	if (strchr(domain, '/')) {
		*status = YP_NODOM;
		return (NULL);
	}
	if (strchr(map, '/')) {
		*status = YP_NOMAP;
		return (NULL);
	}

	/*
	 * open map
	 */
#ifdef OPTDB
	i = 0;
	while (i == 0) {
#endif
		snprintf(map_path, sizeof(map_path), "%s/%s/%s", YP_DB_PATH,
		    domain, map);
		db = ypdb_open(map_path, O_RDONLY, 0444);
#ifdef OPTDB
		if (db == NULL) {
#ifdef DEBUG
			yplog("  ypdb_open_db: errno %d (%s)",
			    errno, sys_errlist[errno]);
#endif
			if (errno == ENFILE || errno == EMFILE) {
				ypdb_close_last();
			} else {
				i = errno;
			}
		} else {
			i = 4711;
		}
	}
#endif
	*status = YP_NOMAP;		/* see note below */
	if (db == NULL) {
		if (errno == ENOENT) {
#ifdef DEBUG
			yplog("  ypdb_open_db: no map %s (domain=%s)",
			    map, domain);
#endif
			return(NULL);
		}
#ifdef DEBUG
		yplog("  ypdb_open_db: ypdb_open FAILED: map %s (domain=%s)",
		    map, domain);
#endif
		return(NULL);
	}

	/*
	 * note: status now YP_NOMAP
	 */

	if (d == NULL) {		/* allocate new domain? */
		d = malloc(sizeof(*d));
		if (d)
			d->domain = strdup(domain);
		if (d == NULL || d->domain == NULL) {
			yplog("  ypdb_open_db: MALLOC failed");
			ypdb_close(db);
			free(d);
			return(NULL);
		}
		LIST_INIT(&d->dmaps);
		LIST_INSERT_HEAD(&doms, d, domsl);
#ifdef DEBUG
		yplog("  ypdb_open_db: NEW DOMAIN %s", domain);
#endif
	}

	/*
	 * m must be NULL since we couldn't find a map.  allocate new one
	 */

	m = malloc(sizeof(*m));
	if (m)
		m->map = strdup(map);
	if (m == NULL || m->map == NULL) {
		free(m);
		yplog("  ypdb_open_db: MALLOC failed");
		ypdb_close(db);
		return(NULL);
	}
	m->db = db;
	m->dom = d;
	m->host_lookup = FALSE;
	TAILQ_INSERT_HEAD(&maps, m, mapsq);
	LIST_INSERT_HEAD(&d->dmaps, m, mapsl);
	if (strcmp(map, YP_HOSTNAME) == 0 || strcmp(map, YP_HOSTADDR) == 0) {
		if (!usedns) {
			k.dptr = domain_key;
			k.dsize = YP_INTERDOMAIN_LEN;
			v = ypdb_fetch(db, k);
			if (v.dptr)
				m->host_lookup = TRUE;
		} else
			m->host_lookup = TRUE;
	}
	m->secure = FALSE;
	k.dptr = secure_key;
	k.dsize = YP_SECURE_LEN;
	v = ypdb_fetch(db, k);
	if (v.dptr)
		m->secure = TRUE;
	*status = YP_TRUE;
	if (map_info)
		*map_info = m;
#ifdef DEBUG
	yplog("  ypdb_open_db: NEW MAP domain=%s, map=%s, hl=%d, s=%d, db=0x%x",
	    domain, map, m->host_lookup, m->secure, m->db);
#endif
	return(m->db);
}

/*
 * lookup host
 */
static ypstat
lookup_host(int nametable, int host_lookup, DBM *db, char *keystr,
    ypresp_val *result)
{
	struct hostent *host;
	struct in_addr *addr_name;
	struct in_addr addr_addr;
	static char val[BUFSIZ+1]; /* match libc */
	static char hostname[HOST_NAME_MAX+1];
	char tmpbuf[HOST_NAME_MAX+1 + 20], *v, *ptr;
	size_t len;
	int l;

	if (!host_lookup)
		return(YP_NOKEY);

	if ((_res.options & RES_INIT) == 0)
		res_init();
	bcopy("b", _res.lookups, sizeof("b"));

	if (nametable) {
		host = gethostbyname(keystr);
		if (host == NULL || host->h_addrtype != AF_INET)
			return(YP_NOKEY);
		addr_name = (struct in_addr *) *host->h_addr_list;
		v = val;
		for (; host->h_addr_list[0] != NULL; host->h_addr_list++) {
			addr_name = (struct in_addr *)host->h_addr_list[0];
			snprintf(tmpbuf, sizeof(tmpbuf), "%s %s\n",
			    inet_ntoa(*addr_name), host->h_name);
			len = strlcat(val, tmpbuf, sizeof(val));
			if (len >= sizeof(val))
				break;
			v = val + len;
		}
		result->val.valdat_val = val;
		result->val.valdat_len = v - val;
		return(YP_TRUE);
	}

	inet_aton(keystr, &addr_addr);
	host = gethostbyaddr((char *)&addr_addr, sizeof(addr_addr), AF_INET);
	if (host == NULL) return(YP_NOKEY);

	strncpy((char *)hostname, host->h_name, sizeof(hostname) - 1);
	hostname[sizeof(hostname) - 1] = '\0';
	host = gethostbyname((char *)hostname);
	if (host == NULL)
		return(YP_NOKEY);

	l = 0;
	for (; host->h_addr_list[0] != NULL; host->h_addr_list++)
		if (!bcmp(host->h_addr_list[0], &addr_addr, sizeof(addr_addr)))
			l++;
	if (l == 0) {
		yplog("lookup_host: address %s not listed for host %s\n",
		    inet_ntoa(addr_addr), hostname);
		syslog(LOG_NOTICE,
		    "ypserv: address %s not listed for host %s\n",
		    inet_ntoa(addr_addr), hostname);
		return(YP_NOKEY);
	}

	len = snprintf(val, sizeof(val), "%s %s", keystr, host->h_name);
	if (len == (size_t)-1 || len >= sizeof(val))
		return(YP_YPERR);
	v = val + len;
	while ((ptr = *(host->h_aliases)) != NULL) {
		strlcat(val, " ", sizeof(val));
		len = strlcat(val, ptr, sizeof(val));
		if (len >= sizeof(val))
			break;
		v = val + len;
		host->h_aliases++;
	}
	result->val.valdat_val = val;
	result->val.valdat_len = v - val;

	return(YP_TRUE);
}

ypresp_val
ypdb_get_record(domainname domain, mapname map, keydat key, int ypprivate)
{
	static	ypresp_val res;
	static	char keystr[YPMAXRECORD+1];
	DBM	*db;
	datum	k, v;
	int	host_lookup = 0, hn;
	struct opt_map *map_info = NULL;

	bzero(&res, sizeof(res));

	db = ypdb_open_db(domain, map, &res.stat, &map_info);
	if (!db || res.stat < 0)
		return(res);
	if (map_info)
		host_lookup = map_info->host_lookup;

	k.dptr = key.keydat_val;
	k.dsize = key.keydat_len;

	if (yp_private(k, ypprivate)) {
		res.stat = YP_NOKEY;
		goto done;
	}

	v = ypdb_fetch(db, k);

	if (v.dptr == NULL) {
		res.stat = YP_NOKEY;
		if ((hn = strcmp(map, YP_HOSTNAME)) != 0 &&
		    strcmp(map, YP_HOSTADDR) != 0)
			goto done;
		/* note: lookup_host needs null terminated string */
		strncpy(keystr, key.keydat_val, key.keydat_len);
		keystr[key.keydat_len] = '\0';
		res.stat = lookup_host((hn == 0) ? TRUE : FALSE,
		    host_lookup, db, keystr, &res);
	} else {
		res.val.valdat_val = v.dptr;
		res.val.valdat_len = v.dsize;
	}

done:
	ypdb_close_db(db);
	return(res);
}

ypresp_key_val
ypdb_get_first(domainname domain, mapname map, int ypprivate)
{
	static ypresp_key_val res;
	DBM	*db;
	datum	k, v;

	bzero(&res, sizeof(res));

	db = ypdb_open_db(domain, map, &res.stat, NULL);

	if (res.stat >= 0) {
		k = ypdb_firstkey(db);

		while (yp_private(k, ypprivate))
			k = ypdb_nextkey(db);

		if (k.dptr == NULL) {
			res.stat = YP_NOKEY;
		} else {
			res.key.keydat_val = k.dptr;
			res.key.keydat_len = k.dsize;
			v = ypdb_fetch(db, k);
			if (v.dptr == NULL) {
				res.stat = YP_NOKEY;
			} else {
				res.val.valdat_val = v.dptr;
				res.val.valdat_len = v.dsize;
			}
		}
	}
	ypdb_close_db(db);
	return (res);
}

ypresp_key_val
ypdb_get_next(domainname domain, mapname map, keydat key, int ypprivate)
{
	static ypresp_key_val res;
	DBM	*db;
	datum	k, v, n;

	bzero(&res, sizeof(res));
	db = ypdb_open_db(domain, map, &res.stat, NULL);

	if (res.stat >= 0) {
		n.dptr = key.keydat_val;
		n.dsize = key.keydat_len;
		v.dptr = NULL;
		v.dsize = 0;
		k.dptr = NULL;
		k.dsize = 0;

		n = ypdb_setkey(db, n);

		if (n.dptr != NULL)
			k = ypdb_nextkey(db);
		else
			k.dptr = NULL;

		if (k.dptr != NULL) {
			while (yp_private(k, ypprivate))
				k = ypdb_nextkey(db);
		}

		if (k.dptr == NULL) {
			res.stat = YP_NOMORE;
		} else {
			res.key.keydat_val = k.dptr;
			res.key.keydat_len = k.dsize;
			v = ypdb_fetch(db, k);
			if (v.dptr == NULL) {
				res.stat = YP_NOMORE;
			} else {
				res.val.valdat_val = v.dptr;
				res.val.valdat_len = v.dsize;
			}
		}
	}
	ypdb_close_db(db);
	return (res);
}

ypresp_order
ypdb_get_order(domainname domain, mapname map)
{
	static ypresp_order res;
	static char   *order_key = YP_LAST_KEY;
	char   order[MAX_LAST_LEN+1];
	DBM	*db;
	datum	k, v;

	bzero(&res, sizeof(res));
	db = ypdb_open_db(domain, map, &res.stat, NULL);

	if (res.stat >= 0) {
		k.dptr = order_key;
		k.dsize = YP_LAST_LEN;

		v = ypdb_fetch(db, k);
		if (v.dptr == NULL) {
			res.stat = YP_NOKEY;
		} else {
			strncpy(order, v.dptr, v.dsize);
			order[v.dsize] = '\0';
			res.ordernum = (u_int32_t)atol(order);
		}
	}
	ypdb_close_db(db);
	return (res);
}

ypresp_master
ypdb_get_master(domainname domain, mapname map)
{
	static ypresp_master res;
	static char   *master_key = YP_MASTER_KEY;
	static char   master[MAX_MASTER_LEN+1];
	DBM	*db;
	datum	k, v;

	bzero(&res, sizeof(res));
	db = ypdb_open_db(domain, map, &res.stat, NULL);

	if (res.stat >= 0) {
		k.dptr = master_key;
		k.dsize = YP_MASTER_LEN;

		v = ypdb_fetch(db, k);
		if (v.dptr == NULL) {
			res.stat = YP_NOKEY;
		} else {
			strncpy(master, v.dptr, v.dsize);
			master[v.dsize] = '\0';
			res.peer = (peername) &master;
		}
	}
	ypdb_close_db(db);
	return (res);
}

bool_t
ypdb_xdr_get_all(XDR *xdrs, ypreq_nokey *req)
{
	static ypresp_all resp;
	DBM	*db;
	datum	k, v;

	bzero(&resp, sizeof(resp));

	/*
	 * open db, and advance past any private keys we may see
	 */
	db = ypdb_open_db(req->domain, req->map,
	    &resp.ypresp_all_u.val.stat, NULL);
	if (!db || resp.ypresp_all_u.val.stat < 0)
		return(FALSE);
	k = ypdb_firstkey(db);
	while (yp_private(k, FALSE))
		k = ypdb_nextkey(db);

	while (1) {
		if (k.dptr == NULL)
			break;

		v = ypdb_fetch(db, k);
		if (v.dptr == NULL)
			break;

		resp.more = TRUE;
		resp.ypresp_all_u.val.stat = YP_TRUE;
		resp.ypresp_all_u.val.key.keydat_val = k.dptr;
		resp.ypresp_all_u.val.key.keydat_len = k.dsize;
		resp.ypresp_all_u.val.val.valdat_val = v.dptr;
		resp.ypresp_all_u.val.val.valdat_len = v.dsize;

		if (!xdr_ypresp_all(xdrs, &resp)) {
#ifdef DEBUG
			yplog("  ypdb_xdr_get_all: xdr_ypresp_all failed");
#endif
			return(FALSE);
		}

		/* advance past private keys */
		k = ypdb_nextkey(db);
		while (yp_private(k, FALSE))
			k = ypdb_nextkey(db);
	}

	bzero(&resp, sizeof(resp));
	resp.ypresp_all_u.val.stat = YP_NOKEY;
	resp.more = FALSE;

	if (!xdr_ypresp_all(xdrs, &resp)) {
#ifdef DEBUG
		yplog("  ypdb_xdr_get_all: final xdr_ypresp_all failed");
#endif
		return(FALSE);
	}
	ypdb_close_db(db);
	return (TRUE);
}

int
ypdb_secure(domainname domain, mapname map)
{
	static	ypresp_val res;
	DBM	*db;
	int	secure;
	struct opt_map *map_info = NULL;

	bzero(&res, sizeof(res));
	secure = FALSE;

	db = ypdb_open_db(domain, map, &res.stat, &map_info);
	if (!db || res.stat < 0)
		return(secure);			/* ? */
	if (map_info)
		secure = map_info->secure;

	ypdb_close_db(db);
	return(secure);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: ypserv_db.c,v 1.30 2015/12/08 07:16:33 mmcc Exp $ */
2
3			/*
4			* Copyright (c) 1994 Mats O Jansson <moj@stacken.kth.se>
5			* Copyright (c) 1996 Charles D. Cranor
6			* All rights reserved.
7			*
8			* Redistribution and use in source and binary forms, with or without
9			* modification, are permitted provided that the following conditions
10			* are met:
11			* 1. Redistributions of source code must retain the above copyright
12			* notice, this list of conditions and the following disclaimer.
13			* 2. Redistributions in binary form must reproduce the above copyright
14			* notice, this list of conditions and the following disclaimer in the
15			* documentation and/or other materials provided with the distribution.
16			*
17			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
18			* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19			* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
21			* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27			* SUCH DAMAGE.
28			*/
29
30			/*
31			* major revision/cleanup of Mats' version
32			* done by Chuck Cranor <chuck@ccrc.wustl.edu>
33			* Jan 1996.
34			*/
35
36			#include <rpc/rpc.h>
37			#include <rpcsvc/yp.h>
38			#include <rpcsvc/ypclnt.h>
39			#include <sys/stat.h>
40			#include <fcntl.h>
41			#include <string.h>
42			#include <stdio.h>
43			#include <stdlib.h>
44			#include <netdb.h>
45			#include <arpa/nameser.h>
46			#include <resolv.h>
47			#include <sys/types.h>
48			#include <sys/socket.h>
49			#include <sys/queue.h>
50			#include <netinet/in.h>
51			#include <arpa/inet.h>
52			#include <syslog.h>
53			#include <errno.h>
54			#include "yplog.h"
55			#include "ypdb.h"
56			#include "ypdef.h"
57			#include "ypserv.h"
58
59			LIST_HEAD(domainlist, opt_domain); /* LIST of domains */
60			LIST_HEAD(maplist, opt_map); /* LIST of maps (in a domain) */
61			TAILQ_HEAD(mapq, opt_map); /* TAILQ of maps (LRU) */
62
63			struct opt_map {
64			mapname map; /* map name (malloc'd) */
65			DBM db; / database */
66			struct opt_domain dom; / back ptr to our domain */
67			int host_lookup; /* host lookup */
68			int secure; /* secure map? */
69			TAILQ_ENTRY(opt_map) mapsq; /* map queue pointers */
70			LIST_ENTRY(opt_map) mapsl; /* map list pointers */
71			};
72
73			struct opt_domain {
74			domainname domain; /* domain name (malloc'd) */
75			struct maplist dmaps; /* the domain's active maps */
76			LIST_ENTRY(opt_domain) domsl; /* global linked list of domains */
77			};
78
79			struct domainlist doms; /* global list of domains */
80			struct mapq maps; /* global queue of maps (LRU) */
81
82			extern int usedns;
83
84			/*
85			* ypdb_init: init the queues and lists
86			*/
87			void
88			ypdb_init(void)
89			{
90			LIST_INIT(&doms);
91			TAILQ_INIT(&maps);
92			}
93
94			/*
95			* yp_private:
96			* Check if key is a YP private key. Return TRUE if it is and
97			* ypprivate is FALSE.
98			*/
99			static int
100			yp_private(datum key, int ypprivate)
101			{
102			if (ypprivate)
103			return (FALSE);
104
105			if (key.dsize == 0 \|\| key.dptr == NULL)
106			return (FALSE);
107
108			if (key.dsize == YP_LAST_LEN &&
109			strncmp(key.dptr, YP_LAST_KEY, YP_LAST_LEN) == 0)
110			return(TRUE);
111			if (key.dsize == YP_INPUT_LEN &&
112			strncmp(key.dptr, YP_INPUT_KEY, YP_INPUT_LEN) == 0)
113			return(TRUE);
114			if (key.dsize == YP_OUTPUT_LEN &&
115			strncmp(key.dptr, YP_OUTPUT_KEY, YP_OUTPUT_LEN) == 0)
116			return(TRUE);
117			if (key.dsize == YP_MASTER_LEN &&
118			strncmp(key.dptr, YP_MASTER_KEY, YP_MASTER_LEN) == 0)
119			return(TRUE);
120			if (key.dsize == YP_DOMAIN_LEN &&
121			strncmp(key.dptr, YP_DOMAIN_KEY, YP_DOMAIN_LEN) == 0)
122			return(TRUE);
123			if (key.dsize == YP_INTERDOMAIN_LEN &&
124			strncmp(key.dptr, YP_INTERDOMAIN_KEY, YP_INTERDOMAIN_LEN) == 0)
125			return(TRUE);
126			if (key.dsize == YP_SECURE_LEN &&
127			strncmp(key.dptr, YP_SECURE_KEY, YP_SECURE_LEN) == 0)
128			return(TRUE);
129			return(FALSE);
130			}
131
132			/*
133			* Close least recent used map. This routine is called when we have
134			* no more file descripotors free, or we want to close all maps.
135			*/
136			static void
137			ypdb_close_last(void)
138			{
139			struct opt_map *last;
140
141			if (TAILQ_EMPTY(&maps)) {
142			yplog(" ypdb_close_last: LRU list is empty!");
143			return;
144			}
145
146			last = TAILQ_LAST(&maps, mapq);
147
148			TAILQ_REMOVE(&maps, last, mapsq); /* remove from LRU circleq */
149			LIST_REMOVE(last, mapsl); /* remove from domain list */
150
151			#ifdef DEBUG
152			yplog(" ypdb_close_last: closing map %s in domain %s [db=0x%x]",
153			last->map, last->dom->domain, last->db);
154			#endif
155
156			ypdb_close(last->db); /* close DB */
157			free(last->map); /* free map name */
158			free(last); /* free map */
159			}
160
161			/*
162			* Close all open maps.
163			*/
164			void
165			ypdb_close_all(void)
166			{
167
168			#ifdef DEBUG
169			yplog(" ypdb_close_all(): start");
170			#endif
171			while (!TAILQ_EMPTY(&maps))
172			ypdb_close_last();
173			#ifdef DEBUG
174			yplog(" ypdb_close_all(): done");
175			#endif
176			}
177
178			/*
179			* Close Database if Open/Close Optimization isn't turned on.
180			*/
181			static void
182			ypdb_close_db(DBM *db)
183			{
184			#ifdef DEBUG
185			yplog(" ypdb_close_db(0x%x)", db);
186			#endif
187			#ifndef OPTDB
188			ypdb_close_all();
189			#endif
190			}
191
192			/*
193			* ypdb_open_db
194			*/
195			DBM *
196			ypdb_open_db(domainname domain, mapname map, ypstat *status,
197			struct opt_map **map_info)
198			{
199			char map_path[PATH_MAX];
200			static char *domain_key = YP_INTERDOMAIN_KEY;
201			static char *secure_key = YP_SECURE_KEY;
202			DBM *db;
203			struct opt_domain *d = NULL;
204			struct opt_map *m = NULL;
205			datum k, v;
206			#ifdef OPTDB
207			int i;
208			#endif
209
210			/*
211			* check for preloaded domain, map
212			*/
213			LIST_FOREACH(d, &doms, domsl) {
214			if (strcmp(domain, d->domain) == 0)
215			break;
216			}
217
218			if (d) {
219			LIST_FOREACH(m, &d->dmaps, mapsl)
220			if (strcmp(map, m->map) == 0)
221			break;
222			}
223
224			/*
225			* map found open?
226			*/
227			if (m) {
228			#ifdef DEBUG
229			yplog(" ypdb_open_db: cached open: domain=%s, map=%s, db=0x%x",
230			domain, map, m->db);
231			#endif
232			TAILQ_REMOVE(&maps, m, mapsq); /* adjust LRU queue */
233			TAILQ_INSERT_HEAD(&maps, m, mapsq);
234			*status = YP_TRUE;
235			if (map_info)
236			*map_info = m;
237			return(m->db);
238			}
239
240			/* Check for illegal charcaters */
241
242			if (strchr(domain, '/')) {
243			*status = YP_NODOM;
244			return (NULL);
245			}
246			if (strchr(map, '/')) {
247			*status = YP_NOMAP;
248			return (NULL);
249			}
250
251			/*
252			* open map
253			*/
254			#ifdef OPTDB
255			i = 0;
256			while (i == 0) {
257			#endif
258			snprintf(map_path, sizeof(map_path), "%s/%s/%s", YP_DB_PATH,
259			domain, map);
260			db = ypdb_open(map_path, O_RDONLY, 0444);
261			#ifdef OPTDB
262			if (db == NULL) {
263			#ifdef DEBUG
264			yplog(" ypdb_open_db: errno %d (%s)",
265			errno, sys_errlist[errno]);
266			#endif
267			if (errno == ENFILE \|\| errno == EMFILE) {
268			ypdb_close_last();
269			} else {
270			i = errno;
271			}
272			} else {
273			i = 4711;
274			}
275			}
276			#endif
277			status = YP_NOMAP; / see note below */
278			if (db == NULL) {
279			if (errno == ENOENT) {
280			#ifdef DEBUG
281			yplog(" ypdb_open_db: no map %s (domain=%s)",
282			map, domain);
283			#endif
284			return(NULL);
285			}
286			#ifdef DEBUG
287			yplog(" ypdb_open_db: ypdb_open FAILED: map %s (domain=%s)",
288			map, domain);
289			#endif
290			return(NULL);
291			}
292
293			/*
294			* note: status now YP_NOMAP
295			*/
296
297			if (d == NULL) { /* allocate new domain? */
298			d = malloc(sizeof(*d));
299			if (d)
300			d->domain = strdup(domain);
301			if (d == NULL \|\| d->domain == NULL) {
302			yplog(" ypdb_open_db: MALLOC failed");
303			ypdb_close(db);
304			free(d);
305			return(NULL);
306			}
307			LIST_INIT(&d->dmaps);
308			LIST_INSERT_HEAD(&doms, d, domsl);
309			#ifdef DEBUG
310			yplog(" ypdb_open_db: NEW DOMAIN %s", domain);
311			#endif
312			}
313
314			/*
315			* m must be NULL since we couldn't find a map. allocate new one
316			*/
317
318			m = malloc(sizeof(*m));
319			if (m)
320			m->map = strdup(map);
321			if (m == NULL \|\| m->map == NULL) {
322			free(m);
323			yplog(" ypdb_open_db: MALLOC failed");
324			ypdb_close(db);
325			return(NULL);
326			}
327			m->db = db;
328			m->dom = d;
329			m->host_lookup = FALSE;
330			TAILQ_INSERT_HEAD(&maps, m, mapsq);
331			LIST_INSERT_HEAD(&d->dmaps, m, mapsl);
332			if (strcmp(map, YP_HOSTNAME) == 0 \|\| strcmp(map, YP_HOSTADDR) == 0) {
333			if (!usedns) {
334			k.dptr = domain_key;
335			k.dsize = YP_INTERDOMAIN_LEN;
336			v = ypdb_fetch(db, k);
337			if (v.dptr)
338			m->host_lookup = TRUE;
339			} else
340			m->host_lookup = TRUE;
341			}
342			m->secure = FALSE;
343			k.dptr = secure_key;
344			k.dsize = YP_SECURE_LEN;
345			v = ypdb_fetch(db, k);
346			if (v.dptr)
347			m->secure = TRUE;
348			*status = YP_TRUE;
349			if (map_info)
350			*map_info = m;
351			#ifdef DEBUG
352			yplog(" ypdb_open_db: NEW MAP domain=%s, map=%s, hl=%d, s=%d, db=0x%x",
353			domain, map, m->host_lookup, m->secure, m->db);
354			#endif
355			return(m->db);
356			}
357
358			/*
359			* lookup host
360			*/
361			static ypstat
362			lookup_host(int nametable, int host_lookup, DBM db, char keystr,
363			ypresp_val *result)
364			{
365			struct hostent *host;
366			struct in_addr *addr_name;
367			struct in_addr addr_addr;
368			static char val[BUFSIZ+1]; /* match libc */
369			static char hostname[HOST_NAME_MAX+1];
370			char tmpbuf[HOST_NAME_MAX+1 + 20], v, ptr;
371			size_t len;
372			int l;
373
374			if (!host_lookup)
375			return(YP_NOKEY);
376
377			if ((_res.options & RES_INIT) == 0)
378			res_init();
379			bcopy("b", _res.lookups, sizeof("b"));
380
381			if (nametable) {
382			host = gethostbyname(keystr);
383			if (host == NULL \|\| host->h_addrtype != AF_INET)
384			return(YP_NOKEY);
385			addr_name = (struct in_addr ) host->h_addr_list;
386			v = val;
387			for (; host->h_addr_list[0] != NULL; host->h_addr_list++) {
388			addr_name = (struct in_addr *)host->h_addr_list[0];
389			snprintf(tmpbuf, sizeof(tmpbuf), "%s %s\n",
390			inet_ntoa(*addr_name), host->h_name);
391			len = strlcat(val, tmpbuf, sizeof(val));
392			if (len >= sizeof(val))
393			break;
394			v = val + len;
395			}
396			result->val.valdat_val = val;
397			result->val.valdat_len = v - val;
398			return(YP_TRUE);
399			}
400
401			inet_aton(keystr, &addr_addr);
402			host = gethostbyaddr((char *)&addr_addr, sizeof(addr_addr), AF_INET);
403			if (host == NULL) return(YP_NOKEY);
404
405			strncpy((char *)hostname, host->h_name, sizeof(hostname) - 1);
406			hostname[sizeof(hostname) - 1] = '\0';
407			host = gethostbyname((char *)hostname);
408			if (host == NULL)
409			return(YP_NOKEY);
410
411			l = 0;
412			for (; host->h_addr_list[0] != NULL; host->h_addr_list++)
413			if (!bcmp(host->h_addr_list[0], &addr_addr, sizeof(addr_addr)))
414			l++;
415			if (l == 0) {
416			yplog("lookup_host: address %s not listed for host %s\n",
417			inet_ntoa(addr_addr), hostname);
418			syslog(LOG_NOTICE,
419			"ypserv: address %s not listed for host %s\n",
420			inet_ntoa(addr_addr), hostname);
421			return(YP_NOKEY);
422			}
423
424			len = snprintf(val, sizeof(val), "%s %s", keystr, host->h_name);
425			if (len == (size_t)-1 \|\| len >= sizeof(val))
426			return(YP_YPERR);
427			v = val + len;
428			while ((ptr = *(host->h_aliases)) != NULL) {
429			strlcat(val, " ", sizeof(val));
430			len = strlcat(val, ptr, sizeof(val));
431			if (len >= sizeof(val))
432			break;
433			v = val + len;
434			host->h_aliases++;
435			}
436			result->val.valdat_val = val;
437			result->val.valdat_len = v - val;
438
439			return(YP_TRUE);
440			}
441
442			ypresp_val
443			ypdb_get_record(domainname domain, mapname map, keydat key, int ypprivate)
444			{
445			static ypresp_val res;
446			static char keystr[YPMAXRECORD+1];
447			DBM *db;
448			datum k, v;
449			int host_lookup = 0, hn;
450			struct opt_map *map_info = NULL;
451
452			bzero(&res, sizeof(res));
453
454			db = ypdb_open_db(domain, map, &res.stat, &map_info);
455			if (!db \|\| res.stat < 0)
456			return(res);
457			if (map_info)
458			host_lookup = map_info->host_lookup;
459
460			k.dptr = key.keydat_val;
461			k.dsize = key.keydat_len;
462
463			if (yp_private(k, ypprivate)) {
464			res.stat = YP_NOKEY;
465			goto done;
466			}
467
468			v = ypdb_fetch(db, k);
469
470			if (v.dptr == NULL) {
471			res.stat = YP_NOKEY;
472			if ((hn = strcmp(map, YP_HOSTNAME)) != 0 &&
473			strcmp(map, YP_HOSTADDR) != 0)
474			goto done;
475			/* note: lookup_host needs null terminated string */
476			strncpy(keystr, key.keydat_val, key.keydat_len);
477			keystr[key.keydat_len] = '\0';
478			res.stat = lookup_host((hn == 0) ? TRUE : FALSE,
479			host_lookup, db, keystr, &res);
480			} else {
481			res.val.valdat_val = v.dptr;
482			res.val.valdat_len = v.dsize;
483			}
484
485			done:
486			ypdb_close_db(db);
487			return(res);
488			}
489
490			ypresp_key_val
491			ypdb_get_first(domainname domain, mapname map, int ypprivate)
492			{
493			static ypresp_key_val res;
494			DBM *db;
495			datum k, v;
496
497			bzero(&res, sizeof(res));
498
499			db = ypdb_open_db(domain, map, &res.stat, NULL);
500
501			if (res.stat >= 0) {
502			k = ypdb_firstkey(db);
503
504			while (yp_private(k, ypprivate))
505			k = ypdb_nextkey(db);
506
507			if (k.dptr == NULL) {
508			res.stat = YP_NOKEY;
509			} else {
510			res.key.keydat_val = k.dptr;
511			res.key.keydat_len = k.dsize;
512			v = ypdb_fetch(db, k);
513			if (v.dptr == NULL) {
514			res.stat = YP_NOKEY;
515			} else {
516			res.val.valdat_val = v.dptr;
517			res.val.valdat_len = v.dsize;
518			}
519			}
520			}
521			ypdb_close_db(db);
522			return (res);
523			}
524
525			ypresp_key_val
526			ypdb_get_next(domainname domain, mapname map, keydat key, int ypprivate)
527			{
528			static ypresp_key_val res;
529			DBM *db;
530			datum k, v, n;
531
532			bzero(&res, sizeof(res));
533			db = ypdb_open_db(domain, map, &res.stat, NULL);
534
535			if (res.stat >= 0) {
536			n.dptr = key.keydat_val;
537			n.dsize = key.keydat_len;
538			v.dptr = NULL;
539			v.dsize = 0;
540			k.dptr = NULL;
541			k.dsize = 0;
542
543			n = ypdb_setkey(db, n);
544
545			if (n.dptr != NULL)
546			k = ypdb_nextkey(db);
547			else
548			k.dptr = NULL;
549
550			if (k.dptr != NULL) {
551			while (yp_private(k, ypprivate))
552			k = ypdb_nextkey(db);
553			}
554
555			if (k.dptr == NULL) {
556			res.stat = YP_NOMORE;
557			} else {
558			res.key.keydat_val = k.dptr;
559			res.key.keydat_len = k.dsize;
560			v = ypdb_fetch(db, k);
561			if (v.dptr == NULL) {
562			res.stat = YP_NOMORE;
563			} else {
564			res.val.valdat_val = v.dptr;
565			res.val.valdat_len = v.dsize;
566			}
567			}
568			}
569			ypdb_close_db(db);
570			return (res);
571			}
572
573			ypresp_order
574			ypdb_get_order(domainname domain, mapname map)
575			{
576			static ypresp_order res;
577			static char *order_key = YP_LAST_KEY;
578			char order[MAX_LAST_LEN+1];
579			DBM *db;
580			datum k, v;
581
582			bzero(&res, sizeof(res));
583			db = ypdb_open_db(domain, map, &res.stat, NULL);
584
585			if (res.stat >= 0) {
586			k.dptr = order_key;
587			k.dsize = YP_LAST_LEN;
588
589			v = ypdb_fetch(db, k);
590			if (v.dptr == NULL) {
591			res.stat = YP_NOKEY;
592			} else {
593			strncpy(order, v.dptr, v.dsize);
594			order[v.dsize] = '\0';
595			res.ordernum = (u_int32_t)atol(order);
596			}
597			}
598			ypdb_close_db(db);
599			return (res);
600			}
601
602			ypresp_master
603			ypdb_get_master(domainname domain, mapname map)
604			{
605			static ypresp_master res;
606			static char *master_key = YP_MASTER_KEY;
607			static char master[MAX_MASTER_LEN+1];
608			DBM *db;
609			datum k, v;
610
611			bzero(&res, sizeof(res));
612			db = ypdb_open_db(domain, map, &res.stat, NULL);
613
614			if (res.stat >= 0) {
615			k.dptr = master_key;
616			k.dsize = YP_MASTER_LEN;
617
618			v = ypdb_fetch(db, k);
619			if (v.dptr == NULL) {
620			res.stat = YP_NOKEY;
621			} else {
622			strncpy(master, v.dptr, v.dsize);
623			master[v.dsize] = '\0';
624			res.peer = (peername) &master;
625			}
626			}
627			ypdb_close_db(db);
628			return (res);
629			}
630
631			bool_t
632			ypdb_xdr_get_all(XDR xdrs, ypreq_nokey req)
633			{
634			static ypresp_all resp;
635			DBM *db;
636			datum k, v;
637
638			bzero(&resp, sizeof(resp));
639
640			/*
641			* open db, and advance past any private keys we may see
642			*/
643			db = ypdb_open_db(req->domain, req->map,
644			&resp.ypresp_all_u.val.stat, NULL);
645			if (!db \|\| resp.ypresp_all_u.val.stat < 0)
646			return(FALSE);
647			k = ypdb_firstkey(db);
648			while (yp_private(k, FALSE))
649			k = ypdb_nextkey(db);
650
651			while (1) {
652			if (k.dptr == NULL)
653			break;
654
655			v = ypdb_fetch(db, k);
656			if (v.dptr == NULL)
657			break;
658
659			resp.more = TRUE;
660			resp.ypresp_all_u.val.stat = YP_TRUE;
661			resp.ypresp_all_u.val.key.keydat_val = k.dptr;
662			resp.ypresp_all_u.val.key.keydat_len = k.dsize;
663			resp.ypresp_all_u.val.val.valdat_val = v.dptr;
664			resp.ypresp_all_u.val.val.valdat_len = v.dsize;
665
666			if (!xdr_ypresp_all(xdrs, &resp)) {
667			#ifdef DEBUG
668			yplog(" ypdb_xdr_get_all: xdr_ypresp_all failed");
669			#endif
670			return(FALSE);
671			}
672
673			/* advance past private keys */
674			k = ypdb_nextkey(db);
675			while (yp_private(k, FALSE))
676			k = ypdb_nextkey(db);
677			}
678
679			bzero(&resp, sizeof(resp));
680			resp.ypresp_all_u.val.stat = YP_NOKEY;
681			resp.more = FALSE;
682
683			if (!xdr_ypresp_all(xdrs, &resp)) {
684			#ifdef DEBUG
685			yplog(" ypdb_xdr_get_all: final xdr_ypresp_all failed");
686			#endif
687			return(FALSE);
688			}
689			ypdb_close_db(db);
690			return (TRUE);
691			}
692
693			int
694			ypdb_secure(domainname domain, mapname map)
695			{
696			static ypresp_val res;
697			DBM *db;
698			int secure;
699			struct opt_map *map_info = NULL;
700
701			bzero(&res, sizeof(res));
702			secure = FALSE;
703
704			db = ypdb_open_db(domain, map, &res.stat, &map_info);
705			if (!db \|\| res.stat < 0)
706			return(secure); /* ? */
707			if (map_info)
708			secure = map_info->secure;
709
710			ypdb_close_db(db);
711			return(secure);
712			}