/*
 * Copyright (c) 2014 - 2018 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Bill Yuan <bycn82@dragonflybsd.org>
 *
 * 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 DragonFly Project 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 COPYRIGHT HOLDERS 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
 * COPYRIGHT HOLDERS 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 <err.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sysexits.h>

#include <net/if.h>
#include <net/route.h>
#include <net/pfil.h>
#include <netinet/in.h>

#include <net/ipfw3/ip_fw3.h>
#include "../../../sbin/ipfw3/ipfw3.h"
#include "ipfw3_layer2.h"

/*
 * Returns the number of bits set (from left) in a contiguous bitmask,
 * or -1 if the mask is not contiguous.
 * XXX this needs a proper fix.
 * This effectively works on masks in big-endian (network) format.
 * when compiled on little endian architectures.
 *
 * First bit is bit 7 of the first byte -- note, for MAC addresses,
 * the first bit on the wire is bit 0 of the first byte.
 * len is the max length in bits.
 */
static int
contigmask(u_char *p, int len)
{
	int i, n;
	for (i = 0; i < len ; i++) {
		if ( (p[i/8] & (1 << (7 - (i%8)))) == 0) /* first bit unset */
			break;
	}
	for (n = i + 1; n < len; n++) {
		if ( (p[n/8] & (1 << (7 - (n%8)))) != 0)
			return -1; /* mask not contiguous */
	}
	return i;
}

/*
 * prints a MAC address/mask pair
 */
static void
print_mac(u_char *addr, u_char *mask)
{
	int l = contigmask(mask, 48);

	if (l == 0) {
		printf(" any");
	} else {
		printf(" %02x:%02x:%02x:%02x:%02x:%02x",
			addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
		if (l == -1) {
			printf("&%02x:%02x:%02x:%02x:%02x:%02x",
				mask[0], mask[1], mask[2],
				mask[3], mask[4], mask[5]);
		} else if (l < 48) {
			printf("/%d", l);
		}
	}
}

static void
get_mac_addr_mask(char *p, u_char *addr, u_char *mask)
{
	int i, l;

	for (i = 0; i < 6; i++)
		addr[i] = mask[i] = 0;
	if (!strcmp(p, "any"))
		return;

	for (i = 0; *p && i < 6; i++, p++) {
		addr[i] = strtol(p, &p, 16);
		if (*p != ':') /* we start with the mask */
			break;
	}
	if (*p == '/') { /* mask len */
		l = strtol(p + 1, &p, 0);
		for (i = 0; l > 0; l -= 8, i++)
			mask[i] = (l >=8) ? 0xff : (~0) << (8-l);
	} else if (*p == '&') { /* mask */
		for (i = 0, p++; *p && i < 6; i++, p++) {
			mask[i] = strtol(p, &p, 16);
			if (*p != ':')
				break;
		}
	} else if (*p == '\0') {
		for (i = 0; i < 6; i++)
			mask[i] = 0xff;
	}
	for (i = 0; i < 6; i++)
		addr[i] &= mask[i];
}

void
parse_layer2(ipfw_insn **cmd, int *ac, char **av[])
{
	(*cmd)->opcode = O_LAYER2_LAYER2;
	(*cmd)->module = MODULE_LAYER2_ID;
	(*cmd)->len |= LEN_OF_IPFWINSN;
	NEXT_ARG1;
}

void
parse_mac_from(ipfw_insn **cmd, int *ac, char **av[])
{
	NEED(*ac, 2, "mac-from src");
	NEXT_ARG1;
	if (strcmp(**av, "table") == 0) {
		NEED(*ac, 2, "mac-from table N");
		NEXT_ARG1;
		(*cmd)->opcode = O_LAYER2_MAC_SRC_LOOKUP;
		(*cmd)->module = MODULE_LAYER2_ID;
		(*cmd)->len |= F_INSN_SIZE(ipfw_insn);
		(*cmd)->arg1 = strtoul(**av, NULL, 10);
		NEXT_ARG1;
	} else {
		(*cmd)->opcode = O_LAYER2_MAC_SRC;
		(*cmd)->module = MODULE_LAYER2_ID;
		(*cmd)->len |= F_INSN_SIZE(ipfw_insn_mac);
		ipfw_insn_mac *mac = (ipfw_insn_mac *)(*cmd);
		/* src */
		get_mac_addr_mask(**av, &(mac->addr[6]), &(mac->mask[6]));
		NEXT_ARG1;
	}
}

void
parse_mac_to(ipfw_insn **cmd, int *ac, char **av[])
{
	NEED(*ac, 2, "mac-to dst");
	NEXT_ARG1;
	if (strcmp(**av, "table") == 0) {
		NEED(*ac, 2, "mac-to table N");
		NEXT_ARG1;
		(*cmd)->opcode = O_LAYER2_MAC_DST_LOOKUP;
		(*cmd)->module = MODULE_LAYER2_ID;
		(*cmd)->len |= F_INSN_SIZE(ipfw_insn);
		(*cmd)->arg1 = strtoul(**av, NULL, 10);
		NEXT_ARG1;
	} else {
		(*cmd)->opcode = O_LAYER2_MAC_DST;
		(*cmd)->module = MODULE_LAYER2_ID;
		(*cmd)->len |= F_INSN_SIZE(ipfw_insn_mac);
		ipfw_insn_mac *mac = (ipfw_insn_mac *)(*cmd);
		/* dst */
		get_mac_addr_mask(**av, mac->addr, mac->mask);
		NEXT_ARG1;
	}
}


void
parse_mac(ipfw_insn **cmd, int *ac, char **av[])
{
	NEED(*ac, 3, "mac dst src");
	NEXT_ARG1;
	(*cmd)->opcode = O_LAYER2_MAC;
	(*cmd)->module = MODULE_LAYER2_ID;
	(*cmd)->len |= F_INSN_SIZE(ipfw_insn_mac);
	ipfw_insn_mac *mac = (ipfw_insn_mac *)(*cmd);
	get_mac_addr_mask(**av, mac->addr, mac->mask);	/* dst */
	NEXT_ARG1;
	get_mac_addr_mask(**av, &(mac->addr[6]), &(mac->mask[6])); /* src */
	NEXT_ARG1;
}

void
show_layer2(ipfw_insn *cmd, int show_or)
{
	printf(" layer2");
}

void
show_mac(ipfw_insn *cmd, int show_or)
{
	ipfw_insn_mac *m = (ipfw_insn_mac *)cmd;
	if (show_or)
		printf(" or");
	else
		printf(" mac");
	print_mac( m->addr, m->mask);
	print_mac( m->addr + 6, m->mask + 6);
}

void
show_mac_from(ipfw_insn *cmd, int show_or)
{
	ipfw_insn_mac *m = (ipfw_insn_mac *)cmd;
	if (show_or)
		printf(" or");
	else
		printf(" mac-from");
	print_mac( m->addr + 6, m->mask + 6);
}

void
show_mac_from_lookup(ipfw_insn *cmd, int show_or)
{
	printf(" mac-from table %d", cmd->arg1);
}

void
show_mac_to(ipfw_insn *cmd, int show_or)
{
	ipfw_insn_mac *m = (ipfw_insn_mac *)cmd;
	if (show_or)
		printf(" or");
	else
		printf(" mac-to");
	print_mac( m->addr, m->mask);
}

void
show_mac_to_lookup(ipfw_insn *cmd, int show_or)
{
	printf(" mac-to table %d", cmd->arg1);
}

void
load_module(register_func function, register_keyword keyword)
{
	keyword(MODULE_LAYER2_ID, O_LAYER2_LAYER2, "layer2", FILTER);
	function(MODULE_LAYER2_ID, O_LAYER2_LAYER2,
			(parser_func)parse_layer2, (shower_func)show_layer2);

	keyword(MODULE_LAYER2_ID, O_LAYER2_MAC, "mac", FILTER);
	function(MODULE_LAYER2_ID, O_LAYER2_MAC,
			(parser_func)parse_mac,(shower_func)show_mac);
	keyword(MODULE_LAYER2_ID, O_LAYER2_MAC_SRC, "mac-from", FROM);
	function(MODULE_LAYER2_ID, O_LAYER2_MAC_SRC,
			(parser_func)parse_mac_from,(shower_func)show_mac_from);
	keyword(MODULE_LAYER2_ID, O_LAYER2_MAC_SRC_LOOKUP,
			"mac-from-[table]", FROM);
	function(MODULE_LAYER2_ID, O_LAYER2_MAC_SRC_LOOKUP,
			(parser_func)parse_mac_from,
			(shower_func)show_mac_from_lookup);

	keyword(MODULE_LAYER2_ID, O_LAYER2_MAC_DST, "mac-to", TO);
	function(MODULE_LAYER2_ID, O_LAYER2_MAC_DST,
			(parser_func)parse_mac_to,(shower_func)show_mac_to);
	keyword(MODULE_LAYER2_ID, O_LAYER2_MAC_DST_LOOKUP,
			"mac-to-[table]", TO);
	function(MODULE_LAYER2_ID, O_LAYER2_MAC_DST_LOOKUP,
			(parser_func)parse_mac_to,
			(shower_func)show_mac_to_lookup);
}