xref: /src/usr.sbin/mountd/get_net.c

/* 	$NetBSD: get_net.c,v 1.3 2020/04/23 00:22:01 joerg Exp $	 */

/*
 * Copyright (c) 1989, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Herb Hasler and Rick Macklem at The University of Guelph.
 *
 * 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. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 THE REGENTS 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 <sys/cdefs.h>
__RCSID("$NetBSD: get_net.c,v 1.3 2020/04/23 00:22:01 joerg Exp $");

#include <sys/types.h>
#include <netdb.h>
#include <stdio.h>
#include <limits.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <util.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#include "mountd.h"

#ifdef TEST
int      opt_flags;
const int ninumeric = NI_NUMERICHOST;
int      mountd_debug = 1;
#endif

static int
isdottedquad(const char *cp)
{
	for (;;)
		switch (*cp++) {
		case '\0':
			return 1;
		case '.':
		case '0': case '1': case '2': case '3': case '4':
		case '5': case '6': case '7': case '8': case '9':
			continue;
		default:
			return 0;
		}
}

static int
countones(struct sockaddr *sa)
{
	void *mask;
	int i, bits = 0, bytelen;
	u_int8_t *p;

	switch (sa->sa_family) {
	case AF_INET:
		mask = (u_int8_t *)&((struct sockaddr_in *)sa)->sin_addr;
		bytelen = 4;
		break;
	case AF_INET6:
		mask = (u_int8_t *)&((struct sockaddr_in6 *)sa)->sin6_addr;
		bytelen = 16;
		break;
	default:
		return 0;
	}

	p = mask;

	for (i = 0; i < bytelen; i++, p++) {
		if (*p != 0xff) {
			for (bits = 0; bits < 8; bits++) {
				if (!(*p & (1 << (7 - bits))))
					break;
			}
			break;
		}
	}

	return (i * 8 + bits);
}

/*
 * Translate a net address.
 */
int
get_net(char *cp, struct netmsk *net, int maskflg)
{
	struct netent *np;
	char *nname, *p, *prefp;
	struct sockaddr_in sin, *sinp;
	struct sockaddr *sa;
	struct addrinfo hints, *ai = NULL;
	char netname[NI_MAXHOST];
	long preflen;
	int ecode;

	(void)memset(&sin, 0, sizeof(sin));
	if ((opt_flags & OP_MASKLEN) && !maskflg) {
		p = strchr(cp, '/');
		*p = '\0';
		prefp = p + 1;
	} else {
		p = NULL;	/* XXXGCC -Wuninitialized */
		prefp = NULL;	/* XXXGCC -Wuninitialized */
	}

	if ((np = getnetbyname(cp)) != NULL) {
		sin.sin_family = AF_INET;
		sin.sin_len = sizeof sin;
		sin.sin_addr = inet_makeaddr(np->n_net, 0);
		sa = (struct sockaddr *)&sin;
	} else if (isdottedquad(cp)) {
		/*
		 * Handle dotted quad [or less than quad] notation specially
		 * because getaddrinfo() will parse them in the old style:
		 * i.e. 1.2.3 -> 1.2.0.3 not 1.2.3.0
		 */
		sin.sin_family = AF_INET;
		sin.sin_len = sizeof sin;
		sin.sin_addr = inet_makeaddr(inet_network(cp), 0);
		if (mountd_debug)
			fprintf(stderr, "get_net: '%s' v4 addr %x\n",
			    cp, sin.sin_addr.s_addr);
		sa = (struct sockaddr *)&sin;
	} else {
		memset(&hints, 0, sizeof hints);
		hints.ai_family = AF_UNSPEC;
		hints.ai_flags = AI_NUMERICHOST;
		if (getaddrinfo(cp, NULL, &hints, &ai) == 0)
			sa = ai->ai_addr;
		else
			goto fail;
	}

	/*
	 * Disallow v6 addresses without a specific mask or masklen
	 */
	if (sa->sa_family == AF_INET6 && (!(opt_flags & OP_MASKLEN) || maskflg))
		return 1;

	ecode = getnameinfo(sa, sa->sa_len, netname, sizeof netname,
	    NULL, 0, ninumeric);
	if (ecode != 0)
		goto fail;

	if (maskflg)
		net->nt_len = countones(sa);
	else {
		if (opt_flags & OP_MASKLEN) {
			errno = 0;
			preflen = strtol(prefp, NULL, 10);
			if (preflen == LONG_MIN && errno == ERANGE)
				goto fail;
			net->nt_len = (int)preflen;
			*p = '/';
		}

		if (np)
			nname = np->n_name;
		else {
			if (getnameinfo(sa, sa->sa_len, netname, sizeof netname,
			    NULL, 0, ninumeric) != 0)
				strlcpy(netname, "?", sizeof(netname));
			nname = netname;
		}
		net->nt_name = estrdup(nname);
		memcpy(&net->nt_net, sa, sa->sa_len);
	}

	if (!maskflg && sa->sa_family == AF_INET &&
	    !(opt_flags & (OP_MASK|OP_MASKLEN))) {
		sinp = (struct sockaddr_in *)sa;
		if (IN_CLASSA(sinp->sin_addr.s_addr))
			net->nt_len = 8;
		else if (IN_CLASSB(sinp->sin_addr.s_addr))
			net->nt_len = 16;
		else if (IN_CLASSC(sinp->sin_addr.s_addr))
			net->nt_len = 24;
		else if (IN_CLASSD(sinp->sin_addr.s_addr))
			net->nt_len = 28;
		else
			net->nt_len = 32;	/* XXX */
	}

	if (ai)
		freeaddrinfo(ai);
	return 0;

fail:
	if (ai)
		freeaddrinfo(ai);
	return 1;
}

#ifdef TEST
int
main(int argc, char *argv[])
{
	char buf[1024];
	struct netmsk nm;

	if (get_net(argv[1], &nm, 0))
		errx(EXIT_FAILURE, "get_net failed");

	sockaddr_snprintf(buf, sizeof(buf), "%a:%p", (void *)&nm.nt_net);
	printf("%s %d %s\n", buf, nm.nt_len, nm.nt_name);
	return 0;
}
#endif