/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Common (shared) routines used by in.routed daemon and the
 * the rtquery utility program
 */

#include "defs.h"
#include <ctype.h>

/* Return the classical netmask for an IP address. */
in_addr_t			/* host byte order */
std_mask(in_addr_t addr)	/* network byte order */
{
	addr = ntohl(addr);

	if (addr == 0)		/* default route has mask 0 */
		return (0);
	if (IN_CLASSA(addr))
		return (IN_CLASSA_NET);
	if (IN_CLASSB(addr))
		return (IN_CLASSB_NET);
	if (IN_CLASSC(addr))
		return (IN_CLASSC_NET);
	return (IN_CLASSE_NET);
}

/*
 * Get a network number as a name or a number, with an optional "/xx"
 * netmask.
 */
boolean_t					/* 0=bad */
getnet(const char *name,
    in_addr_t *netp,			/* network in host byte order */
    in_addr_t *maskp)			/* masks are always in host order */
{
	int i;
	struct netent *np;
	in_addr_t mask;			/* in host byte order */
	struct in_addr in;		/* a network and so host byte order */
	char hname[MAXHOSTNAMELEN+1];
	char *mname, *p;


	/*
	 * The "name" argument of this function can be one of
	 * the follwoing:
	 *	a) network name/mask
	 *	b) network name
	 *	c) network number/mask
	 *	d) network number
	 *	e) host IP address/mask
	 *	f) host IP address
	 *	g) "default"
	 *
	 * Detect and separate "1.2.3.4/24"
	 */
	if (NULL != (mname = strrchr(name, '/'))) {
		i = (int)(mname - name);
		if (i > (int)sizeof (hname)-1)	/* name too long */
			return (_B_FALSE);
		(void) memmove(hname, name, i);
		hname[i] = '\0';
		mname++;
		name = hname;
	}

	if ((in.s_addr = inet_network(name)) == (in_addr_t)-1) {
		if (mname == NULL && strcasecmp(name, "default") == 0)
			in.s_addr = ntohl(RIP_DEFAULT);
		else if ((np = getnetbyname(name)) != NULL)
			in.s_addr = np->n_net;
		else
			return (_B_FALSE);
	}
	/* Left-align the host-byte-order result from above. */
	if (0 == (in.s_addr & 0xff000000))
		in.s_addr <<= 8;
	if (0 == (in.s_addr & 0xff000000))
		in.s_addr <<= 8;
	if (0 == (in.s_addr & 0xff000000))
		in.s_addr <<= 8;

	if (mname == NULL) {
		mask = std_mask(htonl(in.s_addr));
		if ((~mask & in.s_addr) != 0)
			mask = HOST_MASK;
	} else {
		mask = (uint32_t)strtoul(mname, &p, 0);
		if (*p != '\0' || mask > 32 || mname == p)
			return (_B_FALSE);
		if (mask != 0)
			mask = HOST_MASK << (32-mask);
	}

	/* must have mask of 0 with default */
	if (mask != 0 && in.s_addr == RIP_DEFAULT)
		return (_B_FALSE);
	/* no host bits allowed in a network number */
	if ((~mask & in.s_addr) != 0)
		return (_B_FALSE);
	/* require non-zero network number */
	if ((mask & in.s_addr) == 0 && in.s_addr != RIP_DEFAULT)
		return (_B_FALSE);
	if ((in.s_addr >> 24) == 0 && in.s_addr != RIP_DEFAULT)
		return (_B_FALSE);
	if ((in.s_addr >> 24) == 0xff)
		return (_B_FALSE);

	*netp = in.s_addr;
	*maskp = mask;
	return (_B_TRUE);
}

/*
 * Convert string to printable characters
 */
char *
qstring(const uchar_t *srcp, int len)
{
	/*
	 * Authentication schemes for RIPv2 uses the space of an
	 * 20-octet route entry.
	 */
	static char buf[8*20+1];
	char *prcp, *tmp_ptr;
	uchar_t c;
	const uchar_t *s2;

	s2 = srcp + len;
	while (s2 > srcp && *--s2 == '\0')
		len--;
	for (prcp = buf; len != 0 && prcp < &buf[sizeof (buf)-1]; len--) {
		c = *srcp++;
		if (isprint(c) && c != '\\') {
			*prcp++ = c;
			continue;
		}

		*prcp++ = '\\';
		tmp_ptr = strchr("\\\\\nn\rr\tt\bb\aa\ff", c);
		if (tmp_ptr != NULL)
			*prcp++ = tmp_ptr[1];
		else
			prcp += snprintf(prcp,
			    (sizeof (buf) - (strlen(buf)+1)), "%o", c);
	}
	*prcp = '\0';
	return (buf);
}

/* like strtok(), but honoring backslash and not changing the source string */
int			/* 0=ok, -1=bad */
parse_quote(char **linep,	/* look here */
    const char *delims,		/* for these delimiters */
    char *delimp,		/* 0 or put found delimiter here */
    char *buf,			/* copy token to here */
    int	lim)			/* at most this many bytes */
{
	char c = '\0', *pc;
	const char *p;


	pc =  *linep;
	if (*pc == '\0')
		return (-1);

	while (lim != 0) {
		c = *pc++;
		if (c == '\0')
			break;

		if (c == '\\' && *pc != '\0') {
			c = *pc++;
			switch (c) {
			case 'n':
				c = '\n';
				break;
			case 'r':
				c = '\r';
				break;
			case 't':
				c = '\t';
				break;
			case 'b':
				c = '\b';
			}
			if (c >= '0' && c <= '7') {
				c -= '0';
				if (*pc >= '0' && *pc <= '7') {
					c = (c<<3)+(*pc++ - '0');
					if (*pc >= '0' && *pc <= '7')
					    c = (c<<3)+(*pc++ - '0');
				}
			}

		} else {
			for (p = delims; *p != '\0'; ++p) {
				if (*p == c || isspace(c) && *p == ' ')
					goto exit;
			}
		}

		*buf++ = c;
		--lim;
	}
exit:
	if (lim == 0)
		return (-1);

	*buf = '\0';			/* terminate copy of token */
	if (delimp != NULL)
		*delimp = c;		/* return delimiter */
	*linep = pc-1;			/* say where we ended */
	return (0);
}

/*
 * Find the option buffer in the msg corresponding to cmsg_type.
 */
void *
find_ancillary(struct msghdr *msg, int cmsg_type)
{
	struct cmsghdr *cmsg;

	for (cmsg = CMSG_FIRSTHDR(msg); cmsg != NULL;
	    cmsg = CMSG_NXTHDR(msg, cmsg)) {
		if (cmsg->cmsg_level == IPPROTO_IP &&
		    cmsg->cmsg_type == cmsg_type) {
			return (CMSG_DATA(cmsg));
		}
	}
	return (NULL);
}