/* Shared library add-on to iptables to add CLUSTERIP target support. 

 * (C) 2003 by Harald Welte <laforge@gnumonks.org>

 *

 * Development of this code was funded by SuSE AG, http://www.suse.com/

 */

#include <stdbool.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <getopt.h>

#include <stddef.h>

#if defined(__GLIBC__) && __GLIBC__ == 2

#include <net/ethernet.h>

#else

#include <linux/if_ether.h>

#endif

#include <xtables.h>

#include <linux/netfilter_ipv4/ipt_CLUSTERIP.h>

enum {

	O_NEW = 0,

	O_HASHMODE,

	O_CLUSTERMAC,

	O_TOTAL_NODES,

	O_LOCAL_NODE,

	O_HASH_INIT,

	F_NEW         = 1 << O_NEW,

	F_HASHMODE    = 1 << O_HASHMODE,

	F_CLUSTERMAC  = 1 << O_CLUSTERMAC,

	F_TOTAL_NODES = 1 << O_TOTAL_NODES,

	F_LOCAL_NODE  = 1 << O_LOCAL_NODE,

	F_FULL        = F_NEW | F_HASHMODE | F_CLUSTERMAC |

	                F_TOTAL_NODES | F_LOCAL_NODE,

};

static void CLUSTERIP_help(void)

{

	printf(

"CLUSTERIP target options:\n"

"  --new			 Create a new ClusterIP\n"

"  --hashmode <mode>		 Specify hashing mode\n"

"					sourceip\n"

"					sourceip-sourceport\n"

"					sourceip-sourceport-destport\n"

"  --clustermac <mac>		 Set clusterIP MAC address\n"

"  --total-nodes <num>		 Set number of total nodes in cluster\n"

"  --local-node <num>		 Set the local node number\n"

"  --hash-init <num>		 Set init value of the Jenkins hash\n");

}

#define s struct ipt_clusterip_tgt_info

static const struct xt_option_entry CLUSTERIP_opts[] = {

	{.name = "new", .id = O_NEW, .type = XTTYPE_NONE},

	{.name = "hashmode", .id = O_HASHMODE, .type = XTTYPE_STRING,

	 .also = O_NEW},

	{.name = "clustermac", .id = O_CLUSTERMAC, .type = XTTYPE_ETHERMAC,

	 .also = O_NEW, .flags = XTOPT_PUT, XTOPT_POINTER(s, clustermac)},

	{.name = "total-nodes", .id = O_TOTAL_NODES, .type = XTTYPE_UINT16,

	 .flags = XTOPT_PUT, XTOPT_POINTER(s, num_total_nodes),

	 .also = O_NEW, .max = CLUSTERIP_MAX_NODES},

	{.name = "local-node", .id = O_LOCAL_NODE, .type = XTTYPE_UINT16,

	 .flags = XTOPT_PUT, XTOPT_POINTER(s, local_nodes[0]),

	 .also = O_NEW, .max = CLUSTERIP_MAX_NODES},

	{.name = "hash-init", .id = O_HASH_INIT, .type = XTTYPE_UINT32,

	 .flags = XTOPT_PUT, XTOPT_POINTER(s, hash_initval),

	 .also = O_NEW, .max = UINT_MAX},

	XTOPT_TABLEEND,

};

#undef s

static void CLUSTERIP_parse(struct xt_option_call *cb)

{

	struct ipt_clusterip_tgt_info *cipinfo = cb->data;

	xtables_option_parse(cb);

	switch (cb->entry->id) {

	case O_NEW:

		cipinfo->flags |= CLUSTERIP_FLAG_NEW;

		break;

	case O_HASHMODE:

		if (strcmp(cb->arg, "sourceip") == 0)

			cipinfo->hash_mode = CLUSTERIP_HASHMODE_SIP;

		else if (strcmp(cb->arg, "sourceip-sourceport") == 0)

			cipinfo->hash_mode = CLUSTERIP_HASHMODE_SIP_SPT;

		else if (strcmp(cb->arg, "sourceip-sourceport-destport") == 0)

			cipinfo->hash_mode = CLUSTERIP_HASHMODE_SIP_SPT_DPT;

		else

			xtables_error(PARAMETER_PROBLEM, "Unknown hashmode \"%s\"\n",

				   cb->arg);

		break;

	case O_CLUSTERMAC:

		if (!(cipinfo->clustermac[0] & 0x01))

			xtables_error(PARAMETER_PROBLEM, "MAC has to be a multicast ethernet address\n");

		break;

	case O_LOCAL_NODE:

		cipinfo->num_local_nodes = 1;

		break;

	}

}

static void CLUSTERIP_check(struct xt_fcheck_call *cb)

{

	if (cb->xflags == 0)

		return;

	if ((cb->xflags & F_FULL) == F_FULL)

		return;

	xtables_error(PARAMETER_PROBLEM, "CLUSTERIP target: Invalid parameter combination\n");

}

static const char *hashmode2str(enum clusterip_hashmode mode)

{

	const char *retstr;

	switch (mode) {

		case CLUSTERIP_HASHMODE_SIP:

			retstr = "sourceip";

			break;

		case CLUSTERIP_HASHMODE_SIP_SPT:

			retstr = "sourceip-sourceport";

			break;

		case CLUSTERIP_HASHMODE_SIP_SPT_DPT:

			retstr = "sourceip-sourceport-destport";

			break;

		default:

			retstr = "unknown-error";

			break;

	}

	return retstr;

}

static const char *mac2str(const uint8_t mac[ETH_ALEN])

{

	static char buf[ETH_ALEN*3];

	sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",

		mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);

	return buf;

}

static void CLUSTERIP_print(const void *ip,

                            const struct xt_entry_target *target, int numeric)

{

	const struct ipt_clusterip_tgt_info *cipinfo =

		(const struct ipt_clusterip_tgt_info *)target->data;

	if (!(cipinfo->flags & CLUSTERIP_FLAG_NEW)) {

		printf(" CLUSTERIP");

		return;

	}

	printf(" CLUSTERIP hashmode=%s clustermac=%s total_nodes=%u local_node=%u hash_init=%u",

		hashmode2str(cipinfo->hash_mode),

		mac2str(cipinfo->clustermac),

		cipinfo->num_total_nodes,

		cipinfo->local_nodes[0],

		cipinfo->hash_initval);

}

static void CLUSTERIP_save(const void *ip, const struct xt_entry_target *target)

{

	const struct ipt_clusterip_tgt_info *cipinfo =

		(const struct ipt_clusterip_tgt_info *)target->data;

	/* if this is not a new entry, we don't need to save target

	 * parameters */

	if (!(cipinfo->flags & CLUSTERIP_FLAG_NEW))

		return;

	printf(" --new --hashmode %s --clustermac %s --total-nodes %d --local-node %d --hash-init %u",

	       hashmode2str(cipinfo->hash_mode),

	       mac2str(cipinfo->clustermac),

	       cipinfo->num_total_nodes,

	       cipinfo->local_nodes[0],

	       cipinfo->hash_initval);

}

static struct xtables_target clusterip_tg_reg = {

	.name		= "CLUSTERIP",

	.version	= XTABLES_VERSION,

	.family		= NFPROTO_IPV4,

	.size		= XT_ALIGN(sizeof(struct ipt_clusterip_tgt_info)),

	.userspacesize	= offsetof(struct ipt_clusterip_tgt_info, config),

 	.help		= CLUSTERIP_help,

	.x6_parse	= CLUSTERIP_parse,

	.x6_fcheck	= CLUSTERIP_check,

	.print		= CLUSTERIP_print,

	.save		= CLUSTERIP_save,

	.x6_options	= CLUSTERIP_opts,

};

void _init(void)

{

	xtables_register_target(&clusterip_tg_reg);

}