/*
 * Copyright (c) 2015 -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 <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/kernel.h>
#include <sys/proc.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/sysctl.h>
#include <sys/syslog.h>
#include <sys/ucred.h>
#include <sys/in_cksum.h>
#include <sys/lock.h>

#include <net/if.h>
#include <net/route.h>
#include <net/pfil.h>
#include <net/netmsg2.h>
#include <net/ethernet.h>

#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/in_var.h>
#include <netinet/in_pcb.h>
#include <netinet/ip.h>
#include <netinet/ip_var.h>
#include <netinet/ip_icmp.h>
#include <netinet/tcp.h>
#include <netinet/tcp_timer.h>
#include <netinet/tcp_var.h>
#include <netinet/tcpip.h>
#include <netinet/udp.h>
#include <netinet/udp_var.h>
#include <netinet/ip_divert.h>
#include <netinet/if_ether.h>

#include <net/ipfw3/ip_fw.h>
#include <net/ipfw3_basic/ip_fw3_table.h>

MALLOC_DEFINE(M_IPFW3_TABLE, "IPFW3_TABLE", "mem for ip_fw3 table");

extern struct ipfw3_context	*fw3_ctx[MAXCPU];
extern ip_fw_ctl_t 		*ip_fw3_ctl_table_ptr;

/*
 * activate/create the table by setup the type and reset counts.
 */
void
table_create_dispatch(netmsg_t nmsg)
{
	struct netmsg_table *tbmsg = (struct netmsg_table *)nmsg;
	struct ipfw_ioc_table *ioc_table;
	struct ipfw3_context *ctx = fw3_ctx[mycpuid];
	struct ipfw3_table_context *table_ctx;
	ioc_table = tbmsg->ioc_table;
	int id = ioc_table->id;

	table_ctx = ctx->table_ctx;
	table_ctx += id;
	table_ctx->type = ioc_table->type;
	table_ctx->count = 0;
	strlcpy(table_ctx->name , ioc_table->name, IPFW_TABLE_NAME_LEN);
	if (table_ctx->type == 1) {
		rn_inithead(&table_ctx->mask, NULL, 0);
		rn_inithead(&table_ctx->node, table_ctx->mask,
			    offsetof(struct sockaddr_in, sin_addr));
	} else if (table_ctx->type == 2) {
		rn_inithead(&table_ctx->mask, NULL, 0);
		rn_inithead(&table_ctx->node, table_ctx->mask,
			    offsetof(struct sockaddr, sa_data));
	} else {
		goto done;
	}
done:
	netisr_forwardmsg_all(&nmsg->base, mycpuid + 1);
}

/*
 * clean the table, especially the node
 */
void
table_delete_dispatch(netmsg_t nmsg)
{
	struct netmsg_table *tbmsg = (struct netmsg_table *)nmsg;
	struct ipfw_ioc_table *ioc_tbl;
	struct ipfw3_context *ctx = fw3_ctx[mycpuid];
	struct ipfw3_table_context *table_ctx;

	ioc_tbl = tbmsg->ioc_table;
	table_ctx = ctx->table_ctx;
	table_ctx += ioc_tbl->id;
	table_ctx->count = 0;

	rn_flush(table_ctx->node, flush_table_entry);
	/* XXX: should free the tree: rn_freehead(table_ctx->node) */
	table_ctx->type = 0;
	netisr_forwardmsg_all(&nmsg->base, mycpuid + 1);
}

void
table_append_dispatch(netmsg_t nmsg)
{
	struct netmsg_table *tbmsg = (struct netmsg_table *)nmsg;
	struct ipfw_ioc_table *ioc_tbl;
	struct ipfw3_context *ctx = fw3_ctx[mycpuid];
	struct ipfw3_table_context *table_ctx;
	struct radix_node_head *rnh;

	uint8_t mlen;

	ioc_tbl = tbmsg->ioc_table;
	table_ctx = ctx->table_ctx;
	table_ctx += ioc_tbl->id;
	if (table_ctx->type != ioc_tbl->type)
		goto done;

        if (table_ctx->type == 1 ) {
                struct table_ip_entry *ent;

                rnh = table_ctx->node;
                ent = kmalloc(sizeof(struct table_ip_entry),
                                M_IPFW3_TABLE, M_NOWAIT | M_ZERO);

                if (ent == NULL)
                        return;
                mlen = ioc_tbl->ip_ent->masklen;
                ent->addr.sin_len = sizeof(ent->addr);
                ent->mask.sin_len = sizeof(ent->mask);
                ent->mask.sin_addr.s_addr = htonl(~((1 << (32 - mlen)) - 1));
                ent->addr.sin_addr.s_addr = ioc_tbl->ip_ent->addr &
                                                ent->mask.sin_addr.s_addr;

                if (rnh->rnh_addaddr(&ent->addr, &ent->mask, rnh, ent->rn)
                    != NULL)
                        table_ctx->count++;
        } else if (table_ctx->type == 2) {
                struct table_mac_entry *ent;

                rnh = table_ctx->node;
                ent = kmalloc(sizeof(struct table_mac_entry),
                                M_IPFW3_TABLE, M_NOWAIT | M_ZERO);
                if (ent == NULL)
                        return;
                ent->addr.sa_len = offsetof(struct sockaddr, sa_data[6]);
                strncpy(ent->addr.sa_data, ioc_tbl->mac_ent->addr.octet, 6);

                if (rnh->rnh_addaddr(&ent->addr, NULL, rnh, ent->rn) != NULL)
                       table_ctx->count++;
        }

done:
	netisr_forwardmsg_all(&nmsg->base, mycpuid + 1);
}

void
table_remove_dispatch(netmsg_t nmsg)
{
	struct netmsg_table *tbmsg = (struct netmsg_table *)nmsg;
	struct ipfw_ioc_table *ioc_tbl;
	struct ipfw3_context *ctx = fw3_ctx[mycpuid];
	struct ipfw3_table_context *table_ctx;
	struct radix_node_head *rnh;
	struct table_entry *ent;
	struct sockaddr_in sa, mask;
	in_addr_t addr;
	uint8_t mlen;

	ioc_tbl = tbmsg->ioc_table;
	table_ctx = ctx->table_ctx;
	table_ctx += ioc_tbl->id;
	if (table_ctx->type != ioc_tbl->type)
		goto done;

	rnh = table_ctx->node;

	mlen = ioc_tbl->ip_ent->masklen;
	addr = ioc_tbl->ip_ent->addr;

	sa.sin_len = mask.sin_len = 8;
	mask.sin_addr.s_addr = htonl(mlen ? ~((1 << (32 - mlen)) - 1) : 0);
	sa.sin_addr.s_addr = addr & mask.sin_addr.s_addr;

	ent = (struct table_entry *)rnh->rnh_deladdr(&sa, &mask, rnh);
	if (ent != NULL) {
		table_ctx->count--;
		kfree(ent, M_IPFW3_TABLE);
	}
done:
	netisr_forwardmsg_all(&nmsg->base, mycpuid + 1);
}

void
flush_table_entry(struct radix_node *rn)
{
	kfree(rn, M_IPFW3_TABLE);
}

void
table_flush_dispatch(netmsg_t nmsg)
{
	struct netmsg_table *tbmsg = (struct netmsg_table *)nmsg;
	struct ipfw_ioc_table *ioc_tbl;
	struct ipfw3_context *ctx = fw3_ctx[mycpuid];
	struct ipfw3_table_context *table_ctx;
	struct radix_node_head *rnh;

	ioc_tbl = tbmsg->ioc_table;
	table_ctx = ctx->table_ctx;
	table_ctx += ioc_tbl->id;
	rnh = table_ctx->node;
	table_ctx->count = 0;

	rn_flush(rnh, flush_table_entry);
	netisr_forwardmsg_all(&nmsg->base, mycpuid + 1);
}

/*
 * rename the table
 */
void
table_rename_dispatch(netmsg_t nmsg)
{
	struct netmsg_table *tbmsg = (struct netmsg_table *)nmsg;
	struct ipfw_ioc_table *ioc_tbl;
	struct ipfw3_context *ctx = fw3_ctx[mycpuid];
	struct ipfw3_table_context *table_ctx;

	ioc_tbl = tbmsg->ioc_table;
	table_ctx = ctx->table_ctx;
	table_ctx += ioc_tbl->id;
	strlcpy(table_ctx->name, ioc_tbl->name, IPFW_TABLE_NAME_LEN);
	netisr_forwardmsg_all(&nmsg->base, mycpuid + 1);
}

/*
 * list all the overview information about each table
 */
int
ip_fw3_ctl_table_list(struct sockopt *sopt)
{
	struct ipfw3_context *ctx = fw3_ctx[mycpuid];
	struct ipfw3_table_context *table_ctx = ctx->table_ctx;
	struct ipfw_ioc_table *ioc_table;
	int i, error = 0, size;

	size = IPFW_TABLES_MAX * sizeof(struct ipfw_ioc_table);
	if (sopt->sopt_valsize < size) {
		/* sopt_val is not big enough */
		bzero(sopt->sopt_val, sopt->sopt_valsize);
		return 0;
	}
	ioc_table = (struct ipfw_ioc_table *)sopt->sopt_val;
	for (i = 0; i < IPFW_TABLES_MAX; i++, ioc_table++, table_ctx++) {
		ioc_table->id = i;
		ioc_table->type = table_ctx->type;
		ioc_table->count = table_ctx->count;
		strlcpy(ioc_table->name, table_ctx->name, IPFW_TABLE_NAME_LEN);
	}
	sopt->sopt_valsize = size;
	return error;
}

/*
 * remove an item from the table
 */
int
ip_fw3_ctl_table_remove(struct sockopt *sopt)
{
	struct netmsg_table tbmsg;
	bzero(&tbmsg,sizeof(tbmsg));
	tbmsg.ioc_table = sopt->sopt_val;
	netmsg_init(&tbmsg.base, NULL, &curthread->td_msgport,
			0, table_remove_dispatch);
	netisr_domsg(&tbmsg.base, 0);
	return tbmsg.retval;
}

/*
 * flush everything inside the table
 */
int
ip_fw3_ctl_table_flush(struct sockopt *sopt)
{
	struct netmsg_table tbmsg;
	bzero(&tbmsg,sizeof(tbmsg));
	tbmsg.ioc_table = sopt->sopt_val;
	netmsg_init(&tbmsg.base, NULL, &curthread->td_msgport,
			0, table_flush_dispatch);
	netisr_domsg(&tbmsg.base, 0);
	return tbmsg.retval;
}

/*
 * dump the entries into the ioc_table
 */
int
dump_table_ip_entry(struct radix_node *rn, void *arg)
{
	struct table_ip_entry *ent = (struct table_ip_entry *)rn;
	struct ipfw_ioc_table_ip_entry *ioc_ent;
	struct ipfw_ioc_table *tbl = arg;
        struct sockaddr_in *addr, *mask;

        addr = &ent->addr;
        mask = &ent->mask;

	ioc_ent = &tbl->ip_ent[tbl->count];
	if (in_nullhost(mask->sin_addr))
		ioc_ent->masklen = 0;
	else
		ioc_ent->masklen = 33 - ffs(ntohl(mask->sin_addr.s_addr));
	ioc_ent->addr = addr->sin_addr.s_addr;
	tbl->count++;
	return (0);
}

int
dump_table_mac_entry(struct radix_node *rn, void *arg)
{
	struct table_mac_entry *ent = (struct table_mac_entry *)rn;
	struct ipfw_ioc_table_mac_entry *ioc_ent;
	struct ipfw_ioc_table *tbl = arg;
	ioc_ent = &tbl->mac_ent[tbl->count];
        strncpy(ioc_ent->addr.octet, ent->addr.sa_data, 6);
	tbl->count++;
	return (0);
}

/*
 * get and display all items in the table
 */
int
ip_fw3_ctl_table_show(struct sockopt *sopt)
{
	struct ipfw3_context *ctx = fw3_ctx[mycpuid];
	struct ipfw3_table_context *table_ctx;
	struct radix_node_head *rnh;
	struct ipfw_ioc_table *tbl;
	void *data;
	int size;

	int *id = (int *)sopt->sopt_val;
	table_ctx = ctx->table_ctx;
	table_ctx += *id;
        if (table_ctx->type == 1) {
                size = table_ctx->count * sizeof(struct ipfw_ioc_table_ip_entry) +
                                sizeof(struct ipfw_ioc_table);
                if (sopt->sopt_valsize < size) {
                        /* sopt_val is not big enough */
                        bzero(sopt->sopt_val, sopt->sopt_valsize);
                        return 0;
                }
                data = kmalloc(size, M_IPFW3_TABLE, M_NOWAIT | M_ZERO);
                tbl = (struct ipfw_ioc_table *)data;
                tbl->id = *id;
                tbl->type = table_ctx->type;
		strlcpy(tbl->name, table_ctx->name, IPFW_TABLE_NAME_LEN);
                rnh = table_ctx->node;
                rnh->rnh_walktree(rnh, dump_table_ip_entry, tbl);
                bcopy(tbl, sopt->sopt_val, size);
                sopt->sopt_valsize = size;
                kfree(data, M_IPFW3_TABLE);
        } else if (table_ctx->type == 2) {
                size = table_ctx->count * sizeof(struct ipfw_ioc_table_mac_entry) +
                                sizeof(struct ipfw_ioc_table);
                if (sopt->sopt_valsize < size) {
                        /* sopt_val is not big enough */
                        bzero(sopt->sopt_val, sopt->sopt_valsize);
                        return 0;
                }
                data = kmalloc(size, M_IPFW3_TABLE, M_NOWAIT | M_ZERO);
                tbl = (struct ipfw_ioc_table *)data;
                tbl->id = *id;
                tbl->type = table_ctx->type;
		strlcpy(tbl->name, table_ctx->name, IPFW_TABLE_NAME_LEN);
                rnh = table_ctx->node;
                rnh->rnh_walktree(rnh, dump_table_mac_entry, tbl);
                bcopy(tbl, sopt->sopt_val, size);
                sopt->sopt_valsize = size;
                kfree(data, M_IPFW3_TABLE);
        }
	return 0;
}

/*
 * test whether the ip is in the table
 */
int
ip_fw3_ctl_table_test(struct sockopt *sopt)
{
	struct ipfw3_context *ctx = fw3_ctx[mycpuid];
	struct ipfw3_table_context *table_ctx;
	struct radix_node_head *rnh;
	struct ipfw_ioc_table *tbl;

	tbl = (struct ipfw_ioc_table *)sopt->sopt_val;
	table_ctx = ctx->table_ctx;
	table_ctx += tbl->id;

        if (table_ctx->type != tbl->type)
                goto done;

        rnh = table_ctx->node;
        if (tbl->type == 1) {
                struct sockaddr_in sa;
                sa.sin_len = 8;
                sa.sin_addr.s_addr = tbl->ip_ent->addr;

                if (rnh->rnh_lookup(&sa, NULL, rnh) != NULL)
                        return 0;
        } else if (tbl->type == 2) {
                struct sockaddr sa;
                sa.sa_len = 8;
                strncpy(sa.sa_data, tbl->mac_ent->addr.octet, 6);

                if (rnh->rnh_lookup(&sa, NULL, rnh) != NULL)
                        return 0;
        } else {
                /* XXX TODO */
        }
done:
	return 1;
}

/*
 * activate the table
 */
int
ip_fw3_ctl_table_create(struct sockopt *sopt)
{
	struct netmsg_table tbmsg;
	bzero(&tbmsg,sizeof(tbmsg));
	tbmsg.ioc_table = sopt->sopt_val;
	netmsg_init(&tbmsg.base, NULL, &curthread->td_msgport,
			0, table_create_dispatch);
	netisr_domsg(&tbmsg.base, 0);
	return tbmsg.retval;
}

/*
 * deactivate the table
 */
int
ip_fw3_ctl_table_delete(struct sockopt *sopt)
{
	struct netmsg_table tbmsg;
	bzero(&tbmsg,sizeof(tbmsg));
	tbmsg.ioc_table = sopt->sopt_val;
	netmsg_init(&tbmsg.base, NULL, &curthread->td_msgport,
			0, table_delete_dispatch);
	netisr_domsg(&tbmsg.base, 0);
	return tbmsg.retval;
}

/*
 * append an item into the table
 */
int
ip_fw3_ctl_table_append(struct sockopt *sopt)
{
	struct netmsg_table tbmsg;
	bzero(&tbmsg,sizeof(tbmsg));
	tbmsg.ioc_table = sopt->sopt_val;
	netmsg_init(&tbmsg.base, NULL, &curthread->td_msgport,
			0, table_append_dispatch);
	netisr_domsg(&tbmsg.base, 0);
	return tbmsg.retval;
}

/*
 * rename an table
 */
int
ip_fw3_ctl_table_rename(struct sockopt *sopt)
{
	struct netmsg_table tbmsg;
	bzero(&tbmsg,sizeof(tbmsg));
	tbmsg.ioc_table = sopt->sopt_val;
	netmsg_init(&tbmsg.base, NULL, &curthread->td_msgport,
			0, table_rename_dispatch);
	netisr_domsg(&tbmsg.base, 0);
	return tbmsg.retval;
}

/*
 * sockopt handler
 */
int
ip_fw3_ctl_table_sockopt(struct sockopt *sopt)
{
	int error = 0;
	switch (sopt->sopt_name) {
		case IP_FW_TABLE_CREATE:
			error = ip_fw3_ctl_table_create(sopt);
			break;
		case IP_FW_TABLE_DELETE:
			error = ip_fw3_ctl_table_delete(sopt);
			break;
		case IP_FW_TABLE_APPEND:
			error = ip_fw3_ctl_table_append(sopt);
			break;
		case IP_FW_TABLE_REMOVE:
			error = ip_fw3_ctl_table_remove(sopt);
			break;
		case IP_FW_TABLE_LIST:
			error = ip_fw3_ctl_table_list(sopt);
			break;
		case IP_FW_TABLE_FLUSH:
			error = ip_fw3_ctl_table_flush(sopt);
			break;
		case IP_FW_TABLE_SHOW:
			error = ip_fw3_ctl_table_show(sopt);
			break;
		case IP_FW_TABLE_TEST:
			error = ip_fw3_ctl_table_test(sopt);
			break;
		case IP_FW_TABLE_RENAME:
			error = ip_fw3_ctl_table_rename(sopt);
			break;
		default:
			kprintf("ipfw table invalid socket option %d\n",
				sopt->sopt_name);
	}
	return error;
}

/*
 * it will be invoked during init of ipfw3
 * this function will prepare the tables
 */
void
ip_fw3_table_init_dispatch(netmsg_t nmsg)
{
	struct ipfw3_context *ctx = fw3_ctx[mycpuid];
	ctx->table_ctx = kmalloc(sizeof(struct ipfw3_table_context) * IPFW_TABLES_MAX,
			M_IPFW3_TABLE, M_WAITOK | M_ZERO);
	netisr_forwardmsg_all(&nmsg->base, mycpuid + 1);
}

void
ip_fw3_table_fini_dispatch(netmsg_t nmsg)
{
	struct ipfw3_table_context *table_ctx, *tmp_table;
	int id;
	table_ctx = fw3_ctx[mycpuid]->table_ctx;
	tmp_table = table_ctx;
	for (id = 0; id < IPFW_TABLES_MAX; id++, table_ctx++) {
		rn_flush(table_ctx->node, flush_table_entry);
		/* XXX: should free the tree: rn_freehead(table_ctx->node) */
	}
	kfree(tmp_table, M_IPFW3_TABLE);

	netisr_forwardmsg_all(&nmsg->base, mycpuid + 1);
}


void
ip_fw3_table_fini(void)
{
	struct netmsg_base msg;

	netmsg_init(&msg, NULL, &curthread->td_msgport,
		0, ip_fw3_table_fini_dispatch);

	netisr_domsg(&msg, 0);
}

void
ip_fw3_table_init(void)
{
	struct netmsg_base msg;

	ip_fw3_ctl_table_ptr = ip_fw3_ctl_table_sockopt;
	netmsg_init(&msg, NULL, &curthread->td_msgport,
		0, ip_fw3_table_init_dispatch);
	netisr_domsg(&msg, 0);
}


void
ip_fw3_table_modevent(int type)
{
	switch (type) {
		case MOD_LOAD:
			ip_fw3_table_init();
			break;
		case MOD_UNLOAD:
			ip_fw3_table_fini();
			break;
	}
}