/*
 * 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 <sys/param.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/sysctl.h>
#include <sys/time.h>
#include <sys/wait.h>

#include <arpa/inet.h>
#include <ctype.h>
#include <dlfcn.h>
#include <err.h>
#include <errno.h>
#include <grp.h>
#include <limits.h>
#include <netdb.h>
#include <pwd.h>
#include <sysexits.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <timeconv.h>
#include <unistd.h>

#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include <netinet/tcp.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/route.h>
#include <net/ethernet.h>

#include <net/ipfw3/ip_fw3.h>
#include <net/ipfw3_basic/ip_fw3_table.h>
#include <net/ipfw3_basic/ip_fw3_sync.h>
#include <net/ipfw3_basic/ip_fw3_basic.h>
#include <net/ipfw3_nat/ip_fw3_nat.h>
#include <net/dummynet3/ip_dummynet3.h>

#include "ipfw3.h"
#include "ipfw3table.h"

int
lookup_host (char *host, struct in_addr *ipaddr)
{
	struct hostent *he;

	if (!inet_aton(host, ipaddr)) {
		if ((he = gethostbyname(host)) == NULL)
			return(-1);
		*ipaddr = *(struct in_addr *)he->h_addr_list[0];
	}
	return(0);
}


void
table_append(int ac, char *av[])
{
	struct ipfw_ioc_table tbl;
	char *p;
	int size;

	NEXT_ARG;
	if (isdigit(**av))
		tbl.id = atoi(*av);
	else
		errx(EX_USAGE, "table id `%s' invalid", *av);

	if (tbl.id < 0 || tbl.id > IPFW_TABLES_MAX - 1)
		errx(EX_USAGE, "table id `%d' invalid", tbl.id);

	NEXT_ARG;
	if (strcmp(*av, "ip") == 0)
		tbl.type = 1;
	else if (strcmp(*av, "mac") == 0)
		tbl.type = 2;
	else
		errx(EX_USAGE, "table type `%s' not supported", *av);

	NEXT_ARG;
        if (tbl.type == 1) { /* table type ipv4 */
                struct ipfw_ioc_table_ip_entry ip_ent;
                if (!ac)
                        errx(EX_USAGE, "IP address required");

                p = strchr(*av, '/');
                if (p) {
                        *p++ = '\0';
                        ip_ent.masklen = atoi(p);
                        if (ip_ent.masklen > 32)
                                errx(EX_DATAERR, "bad width ``%s''", p);
                } else {
                        ip_ent.masklen = 32;
                }

                if (lookup_host(*av, (struct in_addr *)&ip_ent.addr) != 0)
                        errx(EX_NOHOST, "hostname ``%s'' unknown", *av);

                tbl.ip_ent[0] = ip_ent;
                size = sizeof(tbl) + sizeof(ip_ent);
        } else if (tbl.type == 2) { /* table type mac */
                struct ipfw_ioc_table_mac_entry mac_ent;
                if (!ac)
                        errx(EX_USAGE, "MAC address required");

                mac_ent.addr = *ether_aton(*av);
                tbl.mac_ent[0] = mac_ent;
                size = sizeof(tbl) + sizeof(mac_ent);
        }
	if (do_set_x(IP_FW_TABLE_APPEND, &tbl, size) < 0 )
		errx(EX_USAGE, "do_set_x(IP_FW_TABLE_APPEND) "
			"table `%d' append `%s' failed", tbl.id, *av);
}

void
table_remove(int ac, char *av[])
{
	struct ipfw_ioc_table tbl;
	struct ipfw_ioc_table_ip_entry ip_ent;
	char *p;
	int size;

	NEXT_ARG;
	if (isdigit(**av))
		tbl.id = atoi(*av);
	else
		errx(EX_USAGE, "table id `%s' invalid", *av);

	if (tbl.id < 0 || tbl.id > IPFW_TABLES_MAX - 1)
		errx(EX_USAGE, "table id `%d' invalid", tbl.id);

	NEXT_ARG;
	if (strcmp(*av, "ip") == 0)
		tbl.type = 1;
	else if (strcmp(*av, "mac") == 0)
		tbl.type = 2;
	else
		errx(EX_USAGE, "table type `%s' not supported", *av);

	NEXT_ARG;
	if (!ac)
		errx(EX_USAGE, "IP address required");
	p = strchr(*av, '/');
	if (p) {
		*p++ = '\0';
		ip_ent.masklen = atoi(p);
		if (ip_ent.masklen > 32)
			errx(EX_DATAERR, "bad width ``%s''", p);
	} else {
		ip_ent.masklen = 32;
	}

	if (lookup_host(*av, (struct in_addr *)&ip_ent.addr) != 0)
		errx(EX_NOHOST, "hostname ``%s'' unknown", *av);

	tbl.ip_ent[0] = ip_ent;
	size = sizeof(tbl) + sizeof(ip_ent);
	if (do_set_x(IP_FW_TABLE_REMOVE, &tbl, size) < 0 ) {
		errx(EX_USAGE, "do_set_x(IP_FW_TABLE_REMOVE) "
			"table `%d' append `%s' failed", tbl.id, *av);
	}
}

void
table_flush(int ac, char *av[])
{
	struct ipfw_ioc_table ioc_table;
	struct ipfw_ioc_table *t = &ioc_table;

	NEXT_ARG;
	if (isdigit(**av)) {
		t->id = atoi(*av);
		if (t->id < 0 || t->id > IPFW_TABLES_MAX - 1)
			errx(EX_USAGE, "table id `%d' invalid", t->id);
	} else {
		errx(EX_USAGE, "table id `%s' invalid", *av);
	}
	if (do_set_x(IP_FW_TABLE_FLUSH, t, sizeof(struct ipfw_ioc_table)) < 0 )
		errx(EX_USAGE, "do_set_x(IP_FW_TABLE_FLUSH) "
					"table `%s' flush failed", *av);
}

void
table_list(int ac, char *av[])
{
	struct ipfw_ioc_table *ioc_table;
	int i, count, nbytes, nalloc = 1024;
	void *data = NULL;
	NEXT_ARG;
	if (strcmp(*av, "list") == 0) {
		nbytes = nalloc;
		while (nbytes >= nalloc) {
			nalloc = nalloc * 2 ;
			nbytes = nalloc;
			if ((data = realloc(data, nbytes)) == NULL)
				err(EX_OSERR, "realloc");
			if (do_get_x(IP_FW_TABLE_LIST, data, &nbytes) < 0)
				err(EX_OSERR, "do_get_x(IP_FW_TABLE_LIST)");
		}
		ioc_table = (struct ipfw_ioc_table *)data;
		count = nbytes / sizeof(struct ipfw_ioc_table);
		for (i = 0; i < count; i++, ioc_table++) {
			if (ioc_table->type > 0) {
				printf("table %d",ioc_table->id);
				if (ioc_table->type == 1)
					printf(" type ip");
				else if (ioc_table->type == 2)
					printf(" type mac");
				printf(" count %d",ioc_table->count);
				if (strlen(ioc_table->name) > 0)
					printf(" name %s",ioc_table->name);
				printf("\n");

			}
		}
	} else {
		errx(EX_USAGE, "ipfw3 table `%s' delete invalid", *av);
	}
}

void
table_print(struct ipfw_ioc_table * tbl)
{
	int i;
        if (tbl->type == 0)
                errx(EX_USAGE, "table %d is not in use", tbl->id);

        printf("table %d", tbl->id);
        if (tbl->type == 1)
                printf(" type ip");
        else if (tbl->type == 2)
                printf(" type mac");

        printf(" count %d", tbl->count);
	if (strlen(tbl->name) > 0)
		printf(" name %s", tbl->name);

	printf("\n");

        if (tbl->type == 1) {
                struct ipfw_ioc_table_ip_entry *ip_ent;
                ip_ent = tbl->ip_ent;
                for (i = 0; i < tbl->count; i++) {
                        printf("%s", inet_ntoa(*(struct in_addr *)&ip_ent->addr));
                        printf("/%d ", ip_ent->masklen);
                        printf("\n");
                        ip_ent++;
                }
        } else if (tbl->type == 2) {
                struct ipfw_ioc_table_mac_entry *mac_ent;
                mac_ent = tbl->mac_ent;
                for (i = 0; i < tbl->count; i++) {
                        printf("%s", ether_ntoa(&mac_ent->addr));
                        printf("\n");
                        mac_ent++;
                }
        }
}

void
table_show(int ac, char *av[])
{
	int nbytes, nalloc = 1024;
	void *data = NULL;
	NEXT_ARG;
	if (isdigit(**av)) {
		nbytes = nalloc;
		while (nbytes >= nalloc) {
			nalloc = nalloc * 2 + 256;
			nbytes = nalloc;
			if (data == NULL) {
				if ((data = malloc(nbytes)) == NULL) {
					err(EX_OSERR, "malloc");
				}
			} else if ((data = realloc(data, nbytes)) == NULL) {
				err(EX_OSERR, "realloc");
			}
			/* store table id in the header of data */
			int *head = (int *)data;
			*head = atoi(*av);
			if (*head < 0 || *head > IPFW_TABLES_MAX - 1)
				errx(EX_USAGE, "table id `%d' invalid", *head);
			if (do_get_x(IP_FW_TABLE_SHOW, data, &nbytes) < 0)
				err(EX_OSERR, "do_get_x(IP_FW_TABLE_LIST)");
			struct ipfw_ioc_table *tbl;
			tbl = (struct ipfw_ioc_table *)data;
			table_print(tbl);
		}
	} else {
		errx(EX_USAGE, "ipfw3 table `%s' show invalid", *av);
	}
}

void
table_create(int ac, char *av[])
{
	struct ipfw_ioc_table ioc_table;
	struct ipfw_ioc_table *t = &ioc_table;

	NEXT_ARG;
	if (ac < 2)
		errx(EX_USAGE, "table parameters invalid");
	if (isdigit(**av)) {
		t->id = atoi(*av);
		if (t->id < 0 || t->id > IPFW_TABLES_MAX - 1)
			errx(EX_USAGE, "table id `%d' invalid", t->id);
	} else {
		errx(EX_USAGE, "table id `%s' invalid", *av);
	}
	NEXT_ARG;
	if (strcmp(*av, "ip") == 0)
		t->type = 1;
	else if (strcmp(*av, "mac") == 0)
		t->type = 2;
	else
		errx(EX_USAGE, "table type `%s' not supported", *av);

	NEXT_ARG;
	memset(t->name, 0, IPFW_TABLE_NAME_LEN);
	if (ac == 2 && strcmp(*av, "name") == 0) {
		NEXT_ARG;
		if (strlen(*av) < IPFW_TABLE_NAME_LEN) {
			strncpy(t->name, *av, strlen(*av));
		} else {
			errx(EX_USAGE, "table name `%s' too long", *av);
		}
	} else if (ac == 1) {
		errx(EX_USAGE, "table `%s' invalid", *av);
	}

	if (do_set_x(IP_FW_TABLE_CREATE, t, sizeof(struct ipfw_ioc_table)) < 0)
		errx(EX_USAGE, "do_set_x(IP_FW_TABLE_CREATE) "
					"table `%d' in use", t->id);
}

void
table_delete(int ac, char *av[])
{
	struct ipfw_ioc_table ioc_table;
	struct ipfw_ioc_table *t = &ioc_table;

	NEXT_ARG;
	if (isdigit(**av)) {
		t->id = atoi(*av);
		if (t->id < 0 || t->id > IPFW_TABLES_MAX - 1)
			errx(EX_USAGE, "table id `%d' invalid", t->id);
	} else {
		errx(EX_USAGE, "table id `%s' invalid", *av);
	}
	if (t->id < 0 || t->id > IPFW_TABLES_MAX - 1)
		errx(EX_USAGE, "table id `%d' invalid", t->id);

	if (do_set_x(IP_FW_TABLE_DELETE, t, sizeof(struct ipfw_ioc_table)) < 0)
		errx(EX_USAGE, "do_set_x(IP_FW_TABLE_DELETE) "
					"table `%s' delete failed", *av);
}

void
table_test(int ac, char *av[])
{
	struct ipfw_ioc_table tbl;
	int size;

	NEXT_ARG;
	if (isdigit(**av))
		tbl.id = atoi(*av);
	else
		errx(EX_USAGE, "table id `%s' invalid", *av);

	if (tbl.id < 0 || tbl.id > IPFW_TABLES_MAX - 1)
		errx(EX_USAGE, "table id `%d' invalid", tbl.id);

	NEXT_ARG;
	if (strcmp(*av, "ip") == 0)
		tbl.type = 1;
	else if (strcmp(*av, "mac") == 0)
		tbl.type = 2;
	else
		errx(EX_USAGE, "table type `%s' not supported", *av);

	NEXT_ARG;
        if (tbl.type == 1) { /* table type ipv4 */
                struct ipfw_ioc_table_ip_entry ip_ent;
                if (lookup_host(*av, (struct in_addr *)&ip_ent.addr) != 0)
                        errx(EX_NOHOST, "hostname ``%s'' unknown", *av);

                tbl.ip_ent[0] = ip_ent;
                size = sizeof(tbl) + sizeof(ip_ent);
        } else if (tbl.type == 2) { /* table type mac */
                struct ipfw_ioc_table_mac_entry mac_ent;
                if (!ac)
                        errx(EX_USAGE, "MAC address required");

                mac_ent.addr = *ether_aton(*av);
                tbl.mac_ent[0] = mac_ent;
                size = sizeof(tbl) + sizeof(mac_ent);
        }
	if (do_set_x(IP_FW_TABLE_TEST, &tbl, size) < 0 ) {
		printf("NO, %s not exists in table %d\n", *av, tbl.id);
	} else {
		printf("YES, %s exists in table %d\n", *av, tbl.id);
	}
}

static void
table_rename(int ac, char *av[])
{
	struct ipfw_ioc_table tbl;
	int size;

	bzero(&tbl, sizeof(tbl));
	NEXT_ARG;
	if (isdigit(**av))
		tbl.id = atoi(*av);
	else
		errx(EX_USAGE, "table id `%s' invalid", *av);

	if (tbl.id < 0 || tbl.id > IPFW_TABLES_MAX - 1)
		errx(EX_USAGE, "table id `%d' invalid", tbl.id);

	NEXT_ARG;
	strlcpy(tbl.name, *av, IPFW_TABLE_NAME_LEN);
	size = sizeof(tbl);
	if (do_set_x(IP_FW_TABLE_RENAME, &tbl, size) < 0 )
		errx(EX_USAGE, "do_set_x(IP_FW_TABLE_RENAME) "
					"table `%d' not in use", tbl.id);
}

void
table_main(int ac, char **av)
{
	if (!strncmp(*av, "append", strlen(*av))) {
		table_append(ac, av);
	} else if (!strncmp(*av, "add", strlen(*av))) {
		table_append(ac, av);
	} else if (!strncmp(*av, "remove", strlen(*av))) {
		table_remove(ac, av);
	} else if (!strncmp(*av, "flush", strlen(*av))) {
		table_flush(ac, av);
	} else if (!strncmp(*av, "list", strlen(*av))) {
		table_list(ac, av);
	} else if (!strncmp(*av, "show", strlen(*av))) {
		table_show(ac, av);
	} else if (!strncmp(*av, "type", strlen(*av))) {
		table_create(ac, av);
	} else if (!strncmp(*av, "delete", strlen(*av))) {
		table_delete(ac, av);
	} else if (!strncmp(*av, "test", strlen(*av))) {
		table_test(ac,av);
	} else if (!strncmp(*av, "name", strlen(*av))) {
		table_rename(ac, av);
	} else {
		errx(EX_USAGE, "bad ipfw table command `%s'", *av);
	}
}