/*
 * 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>
 *
 * Copyright (c) 2002 Luigi Rizzo
 * Copyright (c) 1996 Alex Nash, Paul Traina, Poul-Henning Kamp
 * Copyright (c) 1994 Ugen J.S.Antsilevich
 *
 * Idea and grammar partially left from:
 * Copyright (c) 1993 Daniel Boulet
 *
 *
 * Redistribution and use in source forms, with and without modification,
 * are permitted provided that this entire comment appears intact.
 *
 * Redistribution in binary form may occur without any restrictions.
 * Obviously, it would be nice if you gave credit where credit is due
 * but requiring it would be too onerous.
 *
 * This software is provided ``AS IS'' without any warranties of any kind.
 *
 */

#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_state.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 "ipfw3basic.h"
#include "ipfw3log.h"
#include "ipfw3set.h"
#include "ipfw3table.h"
#include "ipfw3dummynet.h"
#include "ipfw3state.h"
#include "ipfw3sync.h"
#include "ipfw3nat.h"

#define MAX_ARGS	32
#define WHITESP		" \t\f\v\n\r"
#define IPFW3_LIB_PATH	"/usr/lib/libipfw3%s.so"

int		fw3_socket = -1;	/* main RAW socket */
int		do_acct, 		/* Show packet/byte count */
		do_time, 		/* Show time stamps */
		do_quiet = 1,		/* Be quiet , default is quiet*/
		do_force, 		/* Don't ask for confirmation */
		do_pipe, 		/* this cmd refers to a pipe */
		do_nat, 		/* Nat configuration. */
		do_sort, 		/* field to sort results (0 = no) */
		do_expired, 		/* display expired dynamic rules */
		do_compact, 		/* show rules in compact mode */
		show_sets, 		/* display rule sets */
		verbose;

struct ipfw3_keyword keywords[KEYWORD_SIZE];
struct ipfw3_mapping mappings[MAPPING_SIZE];

int
match_token(struct char_int_map *table, char *string)
{
	while (table->key) {
		if (strcmp(table->key, string) == 0) {
			return table->val;
		}
		table++;
	}
	return 0;
}

void
module_get(char *modules_str, int len)
{
	if (do_get_x(IP_FW_MODULE, modules_str, &len) < 0)
		errx(EX_USAGE, "ipfw3 not loaded.");
}

void
module_list(int ac, char *av[])
{
	void *module_str = NULL;
	int len = 1024;
	if ((module_str = realloc(module_str, len)) == NULL)
		err(EX_OSERR, "realloc");

	module_get(module_str, len);
	printf("%s\n", (char *)module_str);
}

void
module_load(void)
{
	const char *error;
	init_module mod_init_func;
	void *module_lib;
	char module_lib_file[50];
	void *module_str = NULL;
	int len = 1024;

	if ((module_str = realloc(module_str, len)) == NULL)
		err(EX_OSERR, "realloc");

	module_get(module_str, len);

	const char s[2] = ",";
	char *token;
	token = strtok(module_str, s);
	while (token != NULL) {
		sprintf(module_lib_file, IPFW3_LIB_PATH, token);
		token = strtok(NULL, s);
		module_lib = dlopen(module_lib_file, RTLD_LAZY);
		if (!module_lib) {
			fprintf(stderr, "Couldn't open %s: %s\n",
				module_lib_file, dlerror());
			exit(EX_SOFTWARE);
		}
		mod_init_func = dlsym(module_lib, "load_module");
		if ((error = dlerror()))
		{
			fprintf(stderr, "Couldn't find init function: %s\n", error);
			exit(EX_SOFTWARE);
		}
		(*mod_init_func)((register_func)register_ipfw_func,
				(register_keyword)register_ipfw_keyword);
	}
}

void
register_ipfw_keyword(int module, int opcode, char *word, int type)
{
	struct ipfw3_keyword *tmp;

	tmp=keywords;
	for (;;) {
		if (tmp->type == NONE) {
			strcpy(tmp->word, word);
			tmp->module = module;
			tmp->opcode = opcode;
			tmp->type = type;
			break;
		} else {
			if (strcmp(tmp->word, word) == 0)
				errx(EX_USAGE, "keyword `%s' exists", word);
			else
				tmp++;
		}
	}
}

void
register_ipfw_func(int module, int opcode, parser_func parser, shower_func shower)
{
	struct ipfw3_mapping *tmp;

	tmp = mappings;
	while (1) {
		if (tmp->type == NONE) {
			tmp->module = module;
			tmp->opcode = opcode;
			tmp->parser = parser;
			tmp->shower = shower;
			tmp->type = IN_USE;
			break;
		} else {
			if (tmp->opcode == opcode && tmp->module == module) {
				errx(EX_USAGE, "func `%d' of module `%d' exists",
					opcode, module);
				break;
			} else {
				tmp++;
			}
		}
	}
}

/*
 * this func need to check whether 'or' need to be printed,
 * when the filter is the first filter with 'or' when dont print
 * when not first and same as previous, then print or and no filter name
 * when not first but different from previous, print name without 'or'
 * show_or = 1: show or and ignore filter name
 * show_or = 0: show filter name ignore or
 */
void prev_show_chk(ipfw_insn *cmd, uint8_t *prev_module, uint8_t *prev_opcode,
		int *show_or)
{
	if (cmd->len & F_OR) {
		if (*prev_module == 0 && *prev_opcode == 0) {
			/* first cmd with 'or' flag */
			*show_or = 0;
			*prev_module = cmd->module;
			*prev_opcode = cmd->opcode;
		} else if (cmd->module == *prev_module &&
				cmd->opcode == *prev_opcode) {
			/* cmd same as previous, same module and opcode */
			*show_or = 1;
		} else {
			/* cmd different from prev*/
			*show_or = 0;
			*prev_module = cmd->module;
			*prev_opcode = cmd->opcode;

		}
	} else {
		*show_or = 0;
		*prev_module = 0;
		*prev_opcode = 0;
	}
}

/*
 * word can be: proto from to other
 * proto show proto
 * from show from
 * to show to
 * other show all other filters
 */
int show_filter(ipfw_insn *cmd, char *word, int type)
{
	struct ipfw3_keyword *k;
	struct ipfw3_mapping *m;
	shower_func fn;
	int i, j, show_or;
	uint8_t prev_module, prev_opcode;

	k = keywords;
	m = mappings;
	for (i = 1; i < KEYWORD_SIZE; i++, k++) {
		if (k->type == type) {
			if (k->module == cmd->module &&
					k->opcode == cmd->opcode) {
				for (j = 1; j < MAPPING_SIZE; j++, m++) {
					if (m->type == IN_USE &&
						k->module == m->module &&
						k->opcode == m->opcode) {
						prev_show_chk(cmd, &prev_module,
							&prev_opcode, &show_or);
						if (cmd->len & F_NOT)
							printf(" not");

						fn = m->shower;
						(*fn)(cmd, show_or);
						return 1;
					}
				}
			}
		}
	}
	return 0;
}

void
help(void)
{
	fprintf(stderr, "usage: ipfw3 [options]\n"
			"	ipfw3 add [rulenum] [set id] action filters\n"
			"	ipfw3 delete [rulenum]\n"
			"	ipfw3 flush\n"
			"	ipfw3 list [rulenum]\n"
			"	ipfw3 show [rulenum]\n"
			"	ipfw3 zero [rulenum]\n"
			"	ipfw3 set [show|enable|disable]\n"
			"	ipfw3 module\n"
			"	ipfw3 [enable|disable]\n"
			"	ipfw3 log [reset|off|on]\n"
			"	ipfw3 nat [config|show|delete]\n"
			"	ipfw3 pipe [config|show|delete]\n"
			"	ipfw3 state [add|delete|list|show]\n"
			"	ipfw3 nat [config|show]\n"
			"\nsee ipfw3 manpage for details\n");
	exit(EX_USAGE);
}

void
rule_delete(int ac, char *av[])
{
	int error, rulenum;

	NEXT_ARG;

	while (ac && isdigit(**av)) {
		rulenum = atoi(*av);
		error = do_set_x(IP_FW_DEL, &rulenum, sizeof(int));
		if (error) {
			err(EX_OSERR, "do_get_x(IP_FW_DEL)");
		}
		NEXT_ARG;
	}
}

/*
 * helper function, updates the pointer to cmd with the length
 * of the current command, and also cleans up the first word of
 * the new command in case it has been clobbered before.
 */
ipfw_insn*
next_cmd(ipfw_insn *cmd)
{
	cmd += F_LEN(cmd);
	bzero(cmd, sizeof(*cmd));
	return cmd;
}

/*
 * Parse arguments and assemble the microinstructions which make up a rule.
 * Rules are added into the 'rulebuf' and then copied in the correct order
 * into the actual rule.
 *
 *
 */
void
rule_add(int ac, char *av[], uint8_t insert)
{
	/*
	 * rules are added into the 'rulebuf' and then copied in
	 * the correct order into the actual rule.
	 * Some things that need to go out of order (prob, action etc.)
	 * go into actbuf[].
	 */
	static uint32_t rulebuf[IPFW_RULE_SIZE_MAX];
	static uint32_t actbuf[IPFW_RULE_SIZE_MAX];
	static uint32_t othbuf[IPFW_RULE_SIZE_MAX];
	static uint32_t cmdbuf[IPFW_RULE_SIZE_MAX];

	ipfw_insn *src, *dst, *cmd, *action, *other;
	ipfw_insn *prev;
	char *prev_av;
	ipfw_insn *the_comment = NULL;
	struct ipfw_ioc_rule *rule;
	struct ipfw3_keyword *key;
	struct ipfw3_mapping *map;
	parser_func fn;
	int i, j;

	bzero(actbuf, sizeof(actbuf)); 		/* actions go here */
	bzero(othbuf, sizeof(actbuf)); 		/* others */
	bzero(cmdbuf, sizeof(cmdbuf)); 		/* filters */
	bzero(rulebuf, sizeof(rulebuf));

	rule = (struct ipfw_ioc_rule *)rulebuf;
	cmd = (ipfw_insn *)cmdbuf;
	action = (ipfw_insn *)actbuf;
	other = (ipfw_insn *)othbuf;

	rule->insert = insert;

	NEED2("need more parameters");
	NEXT_ARG;

	/* [rule N]	-- Rule number optional */
	if (ac && isdigit(**av)) {
		rule->rulenum = atoi(*av);
		NEXT_ARG;
	}

	/* [set N]	-- set number (0..30), optional */
	if (ac > 1 && !strncmp(*av, "set", strlen(*av))) {
		int set = strtoul(av[1], NULL, 10);
		if (set < 0 || set > 30)
			errx(EX_DATAERR, "illegal set %s", av[1]);
		rule->set = set;
		av += 2; ac -= 2;
	}

	/*
	 * parse before
	 */
	for (;;) {
		for (i = 0, key = keywords; i < KEYWORD_SIZE; i++, key++) {
			if (key->type == BEFORE &&
				strcmp(key->word, *av) == 0) {
				for (j = 0, map = mappings;
					j < MAPPING_SIZE; j++, map++) {
					if (map->type == IN_USE &&
						map->module == key->module &&
						map->opcode == key->opcode ) {
						fn = map->parser;
						(*fn)(&other, &ac, &av);
						break;
					}
				}
				break;
			}
		}
		if (i >= KEYWORD_SIZE) {
			break;
		} else if (F_LEN(other) > 0) {
			if (other->module == MODULE_BASIC_ID &&
				other->opcode == O_BASIC_CHECK_STATE) {
				other = next_cmd(other);
				goto done;
			}
			other = next_cmd(other);
		}
	}

	/*
	 * parse actions
	 *
	 * only accept 1 action
	 */
	NEED1("missing action");
	for (i = 0, key = keywords; i < KEYWORD_SIZE; i++, key++) {
		if (ac > 0 && key->type == ACTION &&
			strcmp(key->word, *av) == 0) {
			for (j = 0, map = mappings;
					j < MAPPING_SIZE; j++, map++) {
				if (map->type == IN_USE &&
					map->module == key->module &&
					map->opcode == key->opcode) {
					fn = map->parser;
					(*fn)(&action, &ac, &av);
					break;
				}
			}
			break;
		}
	}
	if (F_LEN(action) > 0)
		action = next_cmd(action);

	/*
	 * parse protocol
	 */
	if (strcmp(*av, "proto") == 0){
		NEXT_ARG;
	}

	NEED1("missing protocol");
	for (i = 0, key = keywords; i < KEYWORD_SIZE; i++, key++) {
		if (key->type == PROTO &&
			strcmp(key->word, "proto") == 0) {
			for (j = 0, map = mappings;
					j < MAPPING_SIZE; j++, map++) {
				if (map->type == IN_USE &&
					map->module == key->module &&
					map->opcode == key->opcode ) {
					fn = map->parser;
					(*fn)(&cmd, &ac, &av);
					break;
				}
			}
			break;
		}
	}
	if (F_LEN(cmd) > 0)
		cmd = next_cmd(cmd);

	/*
	 * other filters
	 */
	while (ac > 0) {
		char *s, *cur;		/* current filter */
		ipfw_insn_u32 *cmd32; 	/* alias for cmd */

		s = *av;
		cmd32 = (ipfw_insn_u32 *)cmd;
		if (strcmp(*av, "or") == 0) {
			if (prev == NULL)
				errx(EX_USAGE, "'or' should"
						"between two filters\n");
			prev->len |= F_OR;
			cmd->len = F_OR;
			*av = prev_av;
		}
		if (strcmp(*av, "not") == 0) {
			if (cmd->len & F_NOT)
				errx(EX_USAGE, "double \"not\" not allowed\n");
			cmd->len = F_NOT;
			NEXT_ARG;
			continue;
		}
		cur = *av;
		for (i = 0, key = keywords; i < KEYWORD_SIZE; i++, key++) {
			if ((key->type == FILTER ||
                                key->type == AFTER ||
                                key->type == FROM ||
                                key->type == TO) &&
				strcmp(key->word, cur) == 0) {
				for (j = 0, map = mappings;
					j< MAPPING_SIZE; j++, map++) {
					if (map->type == IN_USE &&
						map->module == key->module &&
						map->opcode == key->opcode ) {
						fn = map->parser;
						(*fn)(&cmd, &ac, &av);
						break;
					}
				}
				break;
			} else if (i == KEYWORD_SIZE - 1) {
				errx(EX_USAGE, "bad command `%s'", cur);
			}
		}
		if (i >= KEYWORD_SIZE) {
			break;
		} else if (F_LEN(cmd) > 0) {
			prev = cmd;
			prev_av = cur;
			cmd = next_cmd(cmd);
		}
	}

done:
	if (ac>0)
		errx(EX_USAGE, "bad command `%s'", *av);

	/*
	 * Now copy stuff into the rule.
	 * [filters][others][action][comment]
	 */
	dst = (ipfw_insn *)rule->cmd;
	/*
	 * copy all filters, except comment
	 */
	src = (ipfw_insn *)cmdbuf;
	for (src = (ipfw_insn *)cmdbuf; src != cmd; src += i) {
		/* pick comment out */
		i = F_LEN(src);
		if (src->module == MODULE_BASIC_ID &&
				src->opcode == O_BASIC_COMMENT) {
			the_comment=src;
		} else {
			bcopy(src, dst, i * sizeof(u_int32_t));
			dst = (ipfw_insn *)((uint32_t *)dst + i);
		}
	}

	/*
	 * start action section, it begin with others
	 */
	rule->act_ofs = (uint32_t *)dst - (uint32_t *)(rule->cmd);

	/*
	 * copy all other others
	 */
	for (src = (ipfw_insn *)othbuf; src != other; src += i) {
		i = F_LEN(src);
		bcopy(src, dst, i * sizeof(u_int32_t));
		dst = (ipfw_insn *)((uint32_t *)dst + i);
	}

	/* copy the action to the end of rule */
	src = (ipfw_insn *)actbuf;
	i = F_LEN(src);
	bcopy(src, dst, i * sizeof(u_int32_t));
	dst = (ipfw_insn *)((uint32_t *)dst + i);

	/*
	 * comment place behind the action
	 */
	if (the_comment != NULL) {
		i = F_LEN(the_comment);
		bcopy(the_comment, dst, i * sizeof(u_int32_t));
		dst = (ipfw_insn *)((uint32_t *)dst + i);
	}

	rule->cmd_len = (u_int32_t *)dst - (u_int32_t *)(rule->cmd);
	i = (void *)dst - (void *)rule;
	if (do_set_x(IP_FW_ADD, (void *)rule, i) == -1) {
		err(EX_UNAVAILABLE, "setsockopt(%s)", "IP_FW_ADD");
	}
	if (!do_quiet)
		rule_show(rule, 10, 10);
}

void
rule_zero(int ac, char *av[])
{
	int rulenum;
	int failed = EX_OK;

	NEXT_ARG;

	if (!ac) {
		/* clear all entries */
		if (do_set_x(IP_FW_ZERO, NULL, 0) < 0)
			err(EX_UNAVAILABLE, "do_set_x(IP_FW_ZERO)");
		if (!do_quiet)
			printf("Accounting cleared.\n");
		return;
	}

	while (ac) {
		/* Rule number */
		if (isdigit(**av)) {
			rulenum = atoi(*av);
			NEXT_ARG;
			if (do_set_x(IP_FW_ZERO, &rulenum, sizeof rulenum)) {
				warn("rule %u: do_set_x(IP_FW_ZERO)", rulenum);
				failed = EX_UNAVAILABLE;
			} else if (!do_quiet)
				printf("Entry %d cleared\n", rulenum);
		} else {
			errx(EX_USAGE, "invalid rule number ``%s''", *av);
		}
	}
	if (failed != EX_OK)
		exit(failed);
}

void
rule_flush(void)
{
	int cmd = IP_FW_FLUSH;
	if (do_pipe) {
		cmd = IP_DUMMYNET_FLUSH;
	}
	if (!do_force) {
		int c;

		printf("Are you sure? [yn] ");
		fflush(stdout);
		do {
			c = toupper(getc(stdin));
			while (c != '\n' && getc(stdin) != '\n')
				if (feof(stdin))
					return; /* and do not flush */
		} while (c != 'Y' && c != 'N');
		if (c == 'N')	/* user said no */
			return;
	}
	if (do_set_x(cmd, NULL, 0) < 0 ) {
		if (do_pipe)
			errx(EX_USAGE, "pipe/queue in use");
		else
			errx(EX_USAGE, "do_set_x(IP_FW_FLUSH) failed");
	}
	if (!do_quiet) {
		printf("Flushed all %s.\n", do_pipe ? "pipes" : "rules");
	}
}

void
rule_list(int ac, char *av[])
{
	struct ipfw_ioc_rule *rule;

	void *data = NULL;
	int bcwidth, nbytes, pcwidth, width;
	int nalloc = 1024;
	int the_rule_num = 0;
	int total_len;

	NEXT_ARG;

	/* get rules or pipes from kernel, resizing array as necessary */
	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_GET, data, &nbytes) < 0)
			err(EX_OSERR, "do_get_x(IP_FW_GET)");
	}

	/*
	 * Count static rules.
	 */
	rule = data;
	bcwidth = pcwidth = 0;
	if (do_acct) {
		total_len = 0;
		for (rule = data; rule != NULL; rule = (void *)rule + IOC_RULESIZE(rule)) {
			/* packet counter */
			width = snprintf(NULL, 0, "%ju", (uintmax_t)rule->pcnt);
			if (width > pcwidth)
				pcwidth = width;

			/* byte counter */
			width = snprintf(NULL, 0, "%ju", (uintmax_t)rule->bcnt);
			if (width > bcwidth)
				bcwidth = width;

			total_len += IOC_RULESIZE(rule);
			if (total_len == nbytes) {
				break;
			}
		}
	}


	if (ac == 1) {
		the_rule_num = atoi(*av);
	}

	total_len = 0;
	for (rule = data; rule != NULL; rule = (void *)rule + IOC_RULESIZE(rule)) {
		if(the_rule_num == 0 || rule->rulenum == the_rule_num) {
			rule_show(rule, pcwidth, bcwidth);
		}
		total_len += IOC_RULESIZE(rule);
		if (total_len == nbytes) {
			break;
		}
	}

}

void
rule_show(struct ipfw_ioc_rule *rule, int pcwidth, int bcwidth)
{
	static int twidth = 0;
	ipfw_insn *cmd;
	int l;

	u_int32_t set_disable = rule->sets;

	if (set_disable & (1 << rule->set)) { /* disabled */
		if (!show_sets)
			return;
		else
			printf("# DISABLED ");
	}
	if (do_compact) {
		printf("%u", rule->rulenum);
	} else {
		printf("%05u", rule->rulenum);
	}

	if (do_acct) {
		if (do_compact) {
			printf(" %ju %ju", (uintmax_t)rule->pcnt,
						(uintmax_t)rule->bcnt);
		} else {
			printf(" %*ju %*ju", pcwidth, (uintmax_t)rule->pcnt,
				bcwidth, (uintmax_t)rule->bcnt);
		}
	}

	if (do_time == 1) {
		char timestr[30];

		if (twidth == 0) {
			strcpy(timestr, ctime((time_t *)&twidth));
			*strchr(timestr, '\n') = '\0';
			twidth = strlen(timestr);
		}
		if (rule->timestamp) {
			time_t t = _long_to_time(rule->timestamp);

			strcpy(timestr, ctime(&t));
			*strchr(timestr, '\n') = '\0';
			printf(" %s", timestr);
		} else {
			printf(" %*s", twidth, " ");
		}
	} else if (do_time == 2) {
		printf( " %10u", rule->timestamp);
	}

	if (show_sets)
		printf(" set %d", rule->set);


	struct ipfw3_keyword *k;
	struct ipfw3_mapping *m;
	shower_func fn, comment_fn = NULL;
	ipfw_insn *comment_cmd;
	int i, j, changed;

	/*
	 * show others and actions
	 */
	for (l = rule->cmd_len - rule->act_ofs, cmd = ACTION_PTR(rule);
		l > 0; l -= F_LEN(cmd),
		cmd = (ipfw_insn *)((uint32_t *)cmd + F_LEN(cmd))) {
		k = keywords;
		m = mappings;
		for (i = 1; i< KEYWORD_SIZE; i++, k++) {
			if ( k->module == cmd->module && k->opcode == cmd->opcode ) {
				for (j = 1; j< MAPPING_SIZE; j++, m++) {
					if (m->type == IN_USE &&
						m->module == cmd->module &&
						m->opcode == cmd->opcode) {
						if (cmd->module == MODULE_BASIC_ID &&
							cmd->opcode == O_BASIC_COMMENT) {
							comment_fn = m->shower;
							comment_cmd = cmd;
						} else {
							fn = m->shower;
							(*fn)(cmd, 0);
						}
						if (cmd->module == MODULE_BASIC_ID &&
							cmd->opcode ==
								O_BASIC_CHECK_STATE) {
							goto done;
						}
						break;
					}
				}
				break;
			}
		}
	}

	/*
	 * show proto
	 */
	changed=0;
	for (l = rule->act_ofs, cmd = rule->cmd; l > 0; l -= F_LEN(cmd),
			cmd = (ipfw_insn *)((uint32_t *)cmd + F_LEN(cmd))) {
		changed = show_filter(cmd, "proto", PROTO);
	}
	if (!changed && !do_quiet)
		printf(" ip");

	/*
	 * show from
	 */
	changed = 0;
	for (l = rule->act_ofs, cmd = rule->cmd; l > 0; l -= F_LEN(cmd),
			cmd = (ipfw_insn *)((uint32_t *)cmd + F_LEN(cmd))) {
		changed = show_filter(cmd, "from", FROM);
	}
	if (!changed && !do_quiet)
		printf(" from any");

	/*
	 * show to
	 */
	changed = 0;
	for (l = rule->act_ofs, cmd = rule->cmd; l > 0; l -= F_LEN(cmd),
			cmd = (ipfw_insn *)((uint32_t *)cmd + F_LEN(cmd))) {
		changed = show_filter(cmd, "to", TO);
	}
	if (!changed && !do_quiet)
		printf(" to any");

	/*
	 * show other filters
	 */
	l = rule->act_ofs;
	cmd = rule->cmd;
	m = mappings;
	for ( ; l > 0; ) {
		show_filter(cmd, "other", FILTER);
		l -= F_LEN(cmd);
		cmd=(ipfw_insn *)((uint32_t *)cmd + F_LEN(cmd));
	}

	/* show the comment in the end */
	if (comment_fn != NULL) {
		(*comment_fn)(comment_cmd, 0);
	}
done:
	printf("\n");
}

/*
 * do_set_x - extended version of do_set
 * insert a x_header in the beginning of the rule buf
 * and call setsockopt() with IP_FW_X.
 */
int
do_set_x(int optname, void *rule, int optlen)
{
	int len, *newbuf, retval;
	ip_fw_x_header *x_header;

	if (fw3_socket < 0)
		err(EX_UNAVAILABLE, "socket not avaialble");

	len = optlen + sizeof(ip_fw_x_header);
	newbuf = malloc(len);
	if (newbuf == NULL)
		err(EX_OSERR, "malloc newbuf in do_set_x");

	bzero(newbuf, len);
	x_header = (ip_fw_x_header *)newbuf;
	x_header->opcode = optname;
	/* copy the rule into the newbuf, just after the x_header*/
	bcopy(rule, ++x_header, optlen);
	retval = setsockopt(fw3_socket, IPPROTO_IP, IP_FW_X, newbuf, len);
	free(newbuf);
	return retval;
}

/*
 * same as do_set_x
 */
int
do_get_x(int optname, void *rule, int *optlen)
{
	int len, *newbuf, retval;
	ip_fw_x_header *x_header;

	if (fw3_socket < 0)
		err(EX_UNAVAILABLE, "socket not avaialble");

	len = *optlen + sizeof(ip_fw_x_header);
	newbuf = malloc(len);
	if (newbuf == NULL)
		err(EX_OSERR, "malloc newbuf in do_get_x");

	bzero(newbuf, len);
	x_header = (ip_fw_x_header *)newbuf;
	x_header->opcode = optname;
	/* copy the rule into the newbuf, just after the x_header*/
	bcopy(rule, ++x_header, *optlen);
	retval = getsockopt(fw3_socket, IPPROTO_IP, IP_FW_X, newbuf, &len);
	bcopy(newbuf, rule, len);
	free(newbuf);
	*optlen = len;
	return retval;
}

int
ipfw3_main(int ac, char **av)
{
	int ch;

	if (ac == 1)
		help();

	/* Set the force flag for non-interactive processes */
	do_force = !isatty(STDIN_FILENO);

	optind = optreset = 1;
	while ((ch = getopt(ac, av, "hs:acefStTv")) != -1)
		switch (ch) {
		case 'h': /* help */
			help();
			break; 	/* NOTREACHED */

		case 's': /* sort */
			do_sort = atoi(optarg);
			break;
		case 'a':
			do_acct = 1;
			break;
		case 'c':
			do_compact = 1;
			break;
		case 'e':
			do_expired = 1;
			break;
		case 'f':
			do_force = 1;
			break;
		case 'S':
			show_sets = 1;
			break;
		case 't':
			do_time = 1;
			break;
		case 'T':
			do_time = 2;
			break;
		case 'v':
			do_quiet = 0;
			verbose++;
			break;
		default:
			help();
		}

	ac -= optind;
	av += optind;
	NEED1("bad arguments, for usage summary ``ipfw3''");

	/*
	 * optional: pipe or queue or nat
	 */
	do_nat = 0;
	do_pipe = 0;
	if (!strncmp(*av, "nat", strlen(*av)))
		do_nat = 1;
	else if (!strncmp(*av, "pipe", strlen(*av))) {
		do_pipe = 1;
	} else if (!strncmp(*av, "queue", strlen(*av))) {
		do_pipe = 2;
	}
	NEED1("missing command");

	/*
	 * for pipes and queues and nat we normally say 'pipe NN config'
	 * but the code is easier to parse as 'pipe config NN'
	 * so we swap the two arguments.
	 */
	if ((do_pipe || do_nat) && ac > 2 && isdigit(*(av[1]))) {
		char *p = av[1];
		av[1] = av[2];
		av[2] = p;
	}

	if (!strncmp(*av, "add", strlen(*av))) {
		module_load();
		rule_add(ac, av, 0);
	} else if (!strncmp(*av, "insert", strlen(*av))) {
		module_load();
		rule_add(ac, av, 1);
	} else if (!strncmp(*av, "delete", strlen(*av))) {
		rule_delete(ac, av);
	} else if (!strncmp(*av, "flush", strlen(*av))) {
		rule_flush();
	} else if (!strncmp(*av, "list", strlen(*av))) {
		module_load();
		rule_list(ac, av);
	} else if (!strncmp(*av, "show", strlen(*av))) {
		do_acct++;
		module_load();
		rule_list(ac, av);
	} else if (!strncmp(*av, "zero", strlen(*av))) {
		rule_zero(ac, av);
	} else if (!strncmp(*av, "set", strlen(*av))) {
		set_main(ac, av);
	} else if (!strncmp(*av, "module", strlen(*av))) {
		NEXT_ARG;
		if (!strncmp(*av, "list", strlen(*av))) {
			module_list(ac, av);
		} else {
			errx(EX_USAGE, "bad ipfw3 module command `%s'", *av);
		}
	} else if (!strncmp(*av, "log", strlen(*av))) {
		NEXT_ARG;
		log_main(ac, av);
	} else if (!strncmp(*av, "nat", strlen(*av))) {
		NEXT_ARG;
		nat_main(ac, av);
	} else if (!strncmp(*av, "pipe", strlen(*av)) ||
		!strncmp(*av, "queue", strlen(*av))) {
		NEXT_ARG;
		dummynet_main(ac, av);
	} else if (!strncmp(*av, "state", strlen(*av))) {
		NEXT_ARG;
		state_main(ac, av);
	} else if (!strncmp(*av, "table", strlen(*av))) {
		if (ac > 2 && isdigit(*(av[1]))) {
			char *p = av[1];
			av[1] = av[2];
			av[2] = p;
		}
		NEXT_ARG;
		table_main(ac, av);
	} else if (!strncmp(*av, "sync", strlen(*av))) {
		NEXT_ARG;
		sync_main(ac, av);
	} else {
		errx(EX_USAGE, "bad ipfw3 command `%s'", *av);
	}
	return 0;
}

void
ipfw3_readfile(int ac, char *av[])
{
	char	buf[BUFSIZ];
	char	*a, *p, *args[MAX_ARGS], *cmd = NULL;
	char	linename[17];
	int	i=0, lineno=0, qflag=0, pflag=0, status;
	FILE	*f = NULL;
	pid_t	preproc = 0;
	int	c;

	while ((c = getopt(ac, av, "D:U:p:q")) != -1) {
		switch (c) {
		case 'D':
			if (!pflag)
				errx(EX_USAGE, "-D requires -p");
			if (i > MAX_ARGS - 2)
				errx(EX_USAGE, "too many -D or -U options");
			args[i++] = "-D";
			args[i++] = optarg;
			break;

		case 'U':
			if (!pflag)
				errx(EX_USAGE, "-U requires -p");
			if (i > MAX_ARGS - 2)
				errx(EX_USAGE, "too many -D or -U options");
			args[i++] = "-U";
			args[i++] = optarg;
			break;

		case 'p':
			pflag = 1;
			cmd = optarg;
			args[0] = cmd;
			i = 1;
			break;

		case 'q':
			qflag = 1;
			break;

		default:
			errx(EX_USAGE, "bad arguments, for usage"
			    " summary ``ipfw''");
		}
	}

	av += optind;
	ac -= optind;
	if (ac != 1)
		errx(EX_USAGE, "extraneous filename arguments");

	if ((f = fopen(av[0], "r")) == NULL)
		err(EX_UNAVAILABLE, "fopen: %s", av[0]);

	if (pflag) {
		/* pipe through preprocessor (cpp or m4) */
		int pipedes[2];

		args[i] = NULL;

		if (pipe(pipedes) == -1)
			err(EX_OSERR, "cannot create pipe");

		switch ((preproc = fork())) {
		case -1:
			err(EX_OSERR, "cannot fork");

		case 0:
			/* child */
			if (dup2(fileno(f), 0) == -1 ||
			    dup2(pipedes[1], 1) == -1) {
				err(EX_OSERR, "dup2()");
			}
			fclose(f);
			close(pipedes[1]);
			close(pipedes[0]);
			execvp(cmd, args);
			err(EX_OSERR, "execvp(%s) failed", cmd);

		default:
			/* parent */
			fclose(f);
			close(pipedes[1]);
			if ((f = fdopen(pipedes[0], "r")) == NULL) {
				int savederrno = errno;

				kill(preproc, SIGTERM);
				errno = savederrno;
				err(EX_OSERR, "fdopen()");
			}
		}
	}

	while (fgets(buf, BUFSIZ, f)) {
		lineno++;
		sprintf(linename, "Line %d", lineno);
		args[0] = linename;

		if (*buf == '#')
			continue;
		if ((p = strchr(buf, '#')) != NULL)
			*p = '\0';
		i = 1;
		if (qflag)
			args[i++] = "-q";
		for (a = strtok(buf, WHITESP); a && i < MAX_ARGS;
			a = strtok(NULL, WHITESP), i++) {
			args[i] = a;
		}

		if (i == (qflag? 2: 1))
			continue;
		if (i == MAX_ARGS)
			errx(EX_USAGE, "%s: too many arguments", linename);

		args[i] = NULL;
		ipfw3_main(i, args);
	}
	fclose(f);
	if (pflag) {
		if (waitpid(preproc, &status, 0) == -1)
			errx(EX_OSERR, "waitpid()");
		if (WIFEXITED(status) && WEXITSTATUS(status) != EX_OK)
			errx(EX_UNAVAILABLE, "preprocessor exited with status %d",
				WEXITSTATUS(status));
		else if (WIFSIGNALED(status))
			errx(EX_UNAVAILABLE, "preprocessor exited with signal %d",
				WTERMSIG(status));
	}
}

int
main(int ac, char *av[])
{
	fw3_socket = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
	if (fw3_socket < 0)
		err(EX_UNAVAILABLE, "socket");

	memset(keywords, 0, LEN_FW3_KEYWORD * KEYWORD_SIZE);
	memset(mappings, 0, LEN_FW3_MAPPING * MAPPING_SIZE);

	prepare_default_funcs();

	if (ac > 1 && av[ac - 1][0] == '/' && access(av[ac - 1], R_OK) == 0)
		ipfw3_readfile(ac, av);
	else
		ipfw3_main(ac, av);
	return EX_OK;
}