/*
 *
 *  Copyright (C) 2007 Mindspeed Technologies, Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include "cmm.h"
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#define UNKNOWN_CMD	0
#define ICC_CMD		1
#define	BRIDGE_CMD	2

#ifdef WIFI_ENABLE
struct wifi_ff_entry glbl_wifi_ff_ifs[MAX_WIFI_FF_IFS];
#endif

struct list_head l2flow_table[L2FLOW_HASH_TABLE_SIZE];
pthread_mutex_t brMutex = PTHREAD_MUTEX_INITIALIZER;		/*mutex to prevent race condition on the route table*/

#ifdef AUTO_BRIDGE

/* This function allocates and add an entry into flow_table */
static int __cmm_l2flow_del(struct l2flowTable * l2flow_entry)
{
	list_del(&l2flow_entry->list);
	free(l2flow_entry);
	return 0;  
}

/* This function allocates and add an entry into flow_table */
static struct l2flowTable * __cmm_l2flow_add(struct l2flow *l2flowtmp)
{
	unsigned int key;
	struct l2flowTable* l2flow_entry;

	cmm_print(DEBUG_INFO, "%s\n", __func__);

	key = l2flow_hash(l2flowtmp);
	l2flow_entry = malloc(sizeof(*l2flow_entry)); 
	if(!l2flow_entry){
		cmm_print(DEBUG_ERROR, "Out of memory\n");
		goto out;
	}
	memset(l2flow_entry, 0, sizeof(*l2flow_entry));
	memcpy(&l2flow_entry->l2flow, l2flowtmp, sizeof(*l2flowtmp));
	
	list_add(&l2flow_table[key], &l2flow_entry->list);
	
	cmm_print(DEBUG_INFO, "Entry added, hash = %d \n", key);
out:
	return l2flow_entry;
}


static struct l2flowTable * __cmm_l2flow_find(struct l2flow *l2flowtmp)
{
	int key;
	struct list_head *entry;
	struct l2flowTable *table_entry;
	
	key = l2flow_hash(l2flowtmp);
	
	entry = list_first(&l2flow_table[key]);

	while (entry != &l2flow_table[key])
	{
		table_entry = container_of(entry, struct l2flowTable, list);
		if(!cmm_l2flow_cmp(&table_entry->l2flow, l2flowtmp))
			return table_entry; // Found

		entry = list_next(entry);
	}
	return NULL; // Not found 

}
void cmm_l2flow_print(int level, struct l2flow *l2flow_tmp, char nl)
{

	cmm_print(level, "Saddr=%02x:%02x:%02x:%02x:%02x:%02x ", l2flow_tmp->saddr[0], l2flow_tmp->saddr[1],
						l2flow_tmp->saddr[2], l2flow_tmp->saddr[3], l2flow_tmp->saddr[4], l2flow_tmp->saddr[5]);
	cmm_print(level, "Daddr=%02x:%02x:%02x:%02x:%02x:%02x ", l2flow_tmp->daddr[0], l2flow_tmp->daddr[1],
						l2flow_tmp->daddr[2], l2flow_tmp->daddr[3], l2flow_tmp->daddr[4], l2flow_tmp->daddr[5]);
	cmm_print(level, "Ethertype=%04x ", ntohs(l2flow_tmp->ethertype));
	cmm_print(level, "PPPoE session id=%d ", ntohs(l2flow_tmp->session_id));

	cmm_print(level, "Proto=%d ", l2flow_tmp->l3.proto);

	if(l2flow_tmp->l3.proto)
	{
		int family = 0;
		char saddr_buf[INET6_ADDRSTRLEN], daddr_buf[INET6_ADDRSTRLEN];

		if(l2flow_tmp->ethertype == htons(ETH_P_IP))
			family = AF_INET;
		else if (l2flow_tmp->ethertype == htons(ETH_P_IPV6))
			family = AF_INET6;

		if(family)
			cmm_print(level, "   L3 info src=%s dst=%s sport=%d dport=%d ", 
				inet_ntop(family, l2flow_tmp->l3.saddr.all, saddr_buf, INET6_ADDRSTRLEN),
				inet_ntop(family, l2flow_tmp->l3.daddr.all, daddr_buf, INET6_ADDRSTRLEN),
				ntohs(l2flow_tmp->l4.sport), ntohs(l2flow_tmp->l4.dport));
	}
	if(nl)
		cmm_print(level, "\n");
}

int __cmm_l2flow_deregister(FCI_CLIENT* fci_handler, struct l2flow *l2flow_tmp)
{
	struct l2flowTable *l2flow_entry = NULL;

	cmm_print(DEBUG_INFO, "%s\n", __func__);
	cmm_l2flow_print(DEBUG_INFO, l2flow_tmp, 1);
	
	l2flow_entry = __cmm_l2flow_find(l2flow_tmp);
	if(!l2flow_entry){
		cmm_print(DEBUG_INFO, "%s Can't find l2flow entry\n", __func__);
	}
	else{
		if(!cmmFeL2FlowUpdate(fci_handler, REMOVE, l2flow_entry))
			__cmm_l2flow_del(l2flow_entry);
		
		cmm_print(DEBUG_INFO, "%s L2 entry successfully deleted\n", __func__);
	}
	/* In all case it is needed to ack ABM whatever */
	cmm_l2flow_abm_notify(L2FLOW_ENTRY_DEL, L2FLOW_ACK, l2flow_tmp);

	return 0;
}

int __cmm_l2flow_register(FCI_CLIENT* fci_handler, char action, struct l2flow *l2flow_tmp, int iifi_idx, int oifi_idx, int flags, short mark)
{
	struct l2flowTable * entry = NULL;
	char allowed = 0;

	cmm_print(DEBUG_INFO, "%s\n", __func__);
	cmm_l2flow_print(DEBUG_INFO, l2flow_tmp, 0);

	cmm_print(DEBUG_INFO, "Input itf idx = %d ", iifi_idx);
	cmm_print(DEBUG_INFO, "Output itf idx = %d ", oifi_idx);
	cmm_print(DEBUG_INFO, "Mark = %0x4\n", mark);

	
	entry = __cmm_l2flow_find(l2flow_tmp);
	if(!entry){
		if((entry = __cmm_l2flow_add(l2flow_tmp)) == NULL){
			cmm_print(DEBUG_INFO, "%s error l2flow add failed\n", __func__);
			goto fail;
		}
		entry->flags |= FPP_NEEDS_UPDATE;
	}
	
	if(__itf_is_programmed(iifi_idx) && __itf_is_programmed(oifi_idx)){
		cmm_print(DEBUG_INFO, "L2Flow Entry allowed\n", iifi_idx);
		allowed = 1;
	}
	else{
		cmm_print(DEBUG_INFO, "L2Flow Entry not allowed\n", iifi_idx);
		entry->flags &= ~FPP_NEEDS_UPDATE;
	}
	
	if((entry->idev_ifi != iifi_idx) || (entry->odev_ifi  != oifi_idx))
		entry->flags |= FPP_NEEDS_UPDATE;

	entry->idev_ifi = iifi_idx;
	entry->odev_ifi = oifi_idx;
	entry->mark = mark;

	if(allowed){
		if(!cmmFeL2FlowUpdate(fci_handler, ADD|UPDATE, entry))
			cmm_l2flow_abm_notify(L2FLOW_ENTRY_UPDATE, L2FLOW_OFFLOADED | L2FLOW_ACK, &entry->l2flow);
		else
			cmm_l2flow_abm_notify(L2FLOW_ENTRY_UPDATE, L2FLOW_DENIED | L2FLOW_ACK, &entry->l2flow);
	}
	else{
		cmmFeL2FlowUpdate(fci_handler, REMOVE, entry);
		cmm_l2flow_abm_notify(L2FLOW_ENTRY_UPDATE, L2FLOW_DENIED, &entry->l2flow);
	}
		
	return 0;
fail:
	return -1;
}
int __cmm_l2flow_reset(FCI_CLIENT* fci_handler)
{
	int i;
	struct l2flowTable * table_entry = NULL;
	struct list_head *entry;

	if (fci_write(fci_handler, FPP_CMD_RX_L2BRIDGE_FLOW_RESET, 0, NULL))
	{
		cmm_print(DEBUG_ERROR, "Error while trying to reset bridge module\n");
		goto out;
	}
	cmm_print(DEBUG_COMMAND, "Send CMD_RX_L2BRIDGE_FLOW_RESET\n");
	
	for(i= 0 ; i < L2FLOW_HASH_TABLE_SIZE; i++)
		while (!list_empty(&l2flow_table[i]))
		{
			entry = list_first(&l2flow_table[i]);
			table_entry = container_of(entry, struct l2flowTable, list);
			__cmm_l2flow_del(table_entry);
		}
out:
	return 0;
}

int cmm_l2flow_abm_notify(char action, int flags, struct l2flow * l2flow)
{
	struct rtnl_handle rth;
	char buf[256] __attribute__ ((aligned (4)));
	struct nlmsghdr *nlh = (struct nlmsghdr *)buf;
	struct l2flow_msg *l2m;

	cmm_print(DEBUG_INFO, "%s\n", __func__);

	if (cmm_nl_open(&rth, 0, NETLINK_L2FLOW) < 0) {
		cmm_print(DEBUG_ERROR, "%s::%d: cmm_rtnl_open() failed, %s\n", __func__, __LINE__, strerror(errno));
		goto err0;
	}

	cmm_nlh_init(nlh, sizeof(struct l2flow_msg), L2FLOW_MSG_ENTRY, NLM_F_REQUEST);

	l2m = NLMSG_DATA(nlh);
	memset(l2m, 0, sizeof(struct l2flow_msg));

	l2m->action = action;
	l2m->flags = flags;
	memcpy(l2m->saddr, l2flow->saddr, ETH_ALEN);
	memcpy(l2m->daddr, l2flow->daddr, ETH_ALEN);
	l2m->ethertype = l2flow->ethertype;


	if(l2flow->vlan_tag)
		cmm_addattr16(nlh, sizeof(buf), L2FLOWA_VLAN_TAG, l2flow->vlan_tag);

	if(l2flow->session_id)
		cmm_addattr16(nlh, sizeof(buf), L2FLOWA_PPP_S_ID, l2flow->session_id);

	if(l2flow->l3.proto){
		cmm_addattr_l(nlh, sizeof(buf), L2FLOWA_IP_PROTO, &l2flow->l3.proto, sizeof(l2flow->l3.proto));

		if(l2flow->ethertype == htons(ETH_P_IP)){
			cmm_addattr32(nlh, sizeof(buf), L2FLOWA_IP_SRC, l2flow->l3.saddr.ip);
			cmm_addattr32(nlh, sizeof(buf), L2FLOWA_IP_DST, l2flow->l3.daddr.ip);
		}
		else if(l2flow->ethertype == htons(ETH_P_IPV6)){
			cmm_addattr_l(nlh, sizeof(buf), L2FLOWA_IP_SRC, l2flow->l3.saddr.ip6, 16);
			cmm_addattr_l(nlh, sizeof(buf), L2FLOWA_IP_DST, l2flow->l3.daddr.ip6, 16);
		}
		if((l2flow->l3.proto == IPPROTO_UDP) 
		|| (l2flow->l3.proto == IPPROTO_TCP)){
			cmm_addattr16(nlh, sizeof(buf), L2FLOWA_SPORT, l2flow->l4.sport);
			cmm_addattr16(nlh, sizeof(buf), L2FLOWA_DPORT, l2flow->l4.dport);
		}
	}
	if (cmm_rtnl_send(&rth, nlh) < 0)
		goto err1;

	cmm_rtnl_close(&rth);

	return 0;

err1:
	cmm_rtnl_close(&rth);

err0:
	return -1;
}

int cmm_l2flow_netlink_rcv(const struct sockaddr_nl *who, struct nlmsghdr *nlh, void *arg)
{
	struct rtattr *tb[L2FLOWA_MAX + 1];
	struct cmm_ct *ctx = arg;


	switch (nlh->nlmsg_type) {
	case L2FLOW_MSG_ENTRY:
	case L2FLOW_MSG_RESET:
		break;

	default:
		cmm_print(DEBUG_ERROR, "%s: unsupported ABM netlink message %x\n", __func__, nlh->nlmsg_type);
		goto out;
		break;
	}

	if (nlh->nlmsg_type == L2FLOW_MSG_ENTRY)
	{
		struct l2flow l2flow_tmp;
		struct l2flow_msg * l2msg;
		int oifi_idx = 0;
		int iifi_idx = 0;
		short mark = 0;

		char action;
		

		memset(&l2flow_tmp, 0, sizeof(l2flow_tmp));
		l2msg = NLMSG_DATA(nlh);

		memcpy(l2flow_tmp.saddr, l2msg->saddr, ETH_ALEN);
		memcpy(l2flow_tmp.daddr, l2msg->daddr, ETH_ALEN);
		l2flow_tmp.ethertype = l2msg->ethertype;
		action = l2msg->action;

		cmm_parse_rtattr(tb, L2FLOWA_MAX, L2FLOWA_RTA(l2msg),L2FLOWA_PAYLOAD(nlh));

		if(tb[L2FLOWA_IIF_IDX])
			iifi_idx = *(unsigned int *)RTA_DATA((tb[L2FLOWA_IIF_IDX]));

		if(tb[L2FLOWA_OIF_IDX])
			oifi_idx = *(unsigned int *)RTA_DATA((tb[L2FLOWA_OIF_IDX]));

		if(tb[L2FLOWA_VLAN_TAG])
			l2flow_tmp.vlan_tag = *(unsigned short *)RTA_DATA((tb[L2FLOWA_VLAN_TAG]));
		
		if(tb[L2FLOWA_PPP_S_ID])
			l2flow_tmp.session_id = *(unsigned short *)RTA_DATA((tb[L2FLOWA_PPP_S_ID]));

		if(tb[L2FLOWA_MARK])
			mark = *(unsigned short *)RTA_DATA((tb[L2FLOWA_MARK]));

		if(tb[L2FLOWA_IP_SRC])
			memcpy(&l2flow_tmp.l3.saddr.all, RTA_DATA(tb[L2FLOWA_IP_SRC]), RTA_PAYLOAD(tb[L2FLOWA_IP_SRC]));

		if(tb[L2FLOWA_IP_DST])
			memcpy(&l2flow_tmp.l3.daddr.all, RTA_DATA(tb[L2FLOWA_IP_DST]), RTA_PAYLOAD(tb[L2FLOWA_IP_DST]));

		if(tb[L2FLOWA_IP_PROTO])
			l2flow_tmp.l3.proto=  *(unsigned char *)RTA_DATA(tb[L2FLOWA_IP_PROTO]);
		
		if(tb[L2FLOWA_SPORT])
			l2flow_tmp.l4.sport=  *(unsigned short *)RTA_DATA(tb[L2FLOWA_SPORT]);

		if(tb[L2FLOWA_DPORT])
			l2flow_tmp.l4.dport=  *(unsigned short *)RTA_DATA(tb[L2FLOWA_DPORT]);	

		if((action == L2FLOW_ENTRY_NEW) || (action == L2FLOW_ENTRY_UPDATE))
		{
			__pthread_mutex_lock(&brMutex);
			__cmm_l2flow_register(ctx->fci_handle, action, &l2flow_tmp, iifi_idx, oifi_idx, l2msg->flags, mark);
			__pthread_mutex_unlock(&brMutex);
		}
		else if (action == L2FLOW_ENTRY_DEL)
		{
			__pthread_mutex_lock(&brMutex);
			__cmm_l2flow_deregister(ctx->fci_handle, &l2flow_tmp); 
			__pthread_mutex_unlock(&brMutex);
		}
	}
	else if (nlh->nlmsg_type == L2FLOW_MSG_RESET)
	{
		__pthread_mutex_lock(&brMutex);
		__cmm_l2flow_reset(ctx->fci_handle);
		__pthread_mutex_unlock(&brMutex);
	}
out:
	return RTNL_CB_CONTINUE;

}
#else
int cmm_l2flow_netlink_rcv(const struct sockaddr_nl *who, struct nlmsghdr *nlh, void *arg)
{
	return RTNL_CB_CONTINUE;
}
#endif
#ifdef AUTO_BRIDGE
int cmmBridgeInit(struct cmm_ct *ctx)
{
	fpp_l2_bridge_control_cmd_t br_cmd;

	if (cmm_nl_open(&ctx->rth_abm, L2FLOW_NL_GRP, NETLINK_L2FLOW) < 0)
	{
		cmm_print(DEBUG_CRIT, "%s: Bridge is started in manual mode\n", __func__);
		br_cmd.mode_timeout = FPP_L2_BRIDGE_MODE_MANUAL;
		globalConf.auto_bridge = 0;
		
	}
	else{
		br_cmd.mode_timeout = FPP_L2_BRIDGE_MODE_AUTO;
		cmm_print(DEBUG_CRIT, "%s: Bridge is started in auto mode\n", __func__);
		globalConf.auto_bridge = 1;
	}

	/* Set bridge mode in FPP */
	cmm_print(DEBUG_COMMAND, "Send FPP_CMD_RX_L2BRIDGE_MODE\n");
	if (fci_write(ctx->fci_handle, FPP_CMD_RX_L2BRIDGE_MODE, sizeof(br_cmd), (unsigned short *)&br_cmd)){
		cmm_print(DEBUG_ERROR, "Error while trying to set  bridge mode\n");
		return -1;
	}
	return 0;
}
#else
int cmmBridgeInit(struct cmm_ct *ctx)
{
	globalConf.auto_bridge = 0;
	cmm_print(DEBUG_CRIT, "%s: Bridge is started in manual mode\n", __func__);
	return 0;
}

#endif
int cmmBridgeControlProcess(char ** keywords, int tabStart, daemon_handle_t daemon_handle)
{
	int cpt = tabStart;
	fpp_l2_bridge_control_cmd_t cmd;
	char rcvBuffer[256];
	char *endptr;
	unsigned int  timeout;
	int rc;

	if(!keywords[cpt])
		goto usage;

	if (strcasecmp(keywords[cpt], "timeout") != 0)
		goto usage;

	if(!keywords[++cpt])
		goto usage;

	/*Get an integer from the string*/
	endptr = NULL;
	timeout = strtoul(keywords[cpt], &endptr, 0);
	if ((keywords[cpt] == endptr) ||  (timeout > UINT16_MAX) || (timeout == 0)){
		cmm_print(DEBUG_ERROR, "%s Timeout must be > 0 and < %d s \n",__func__, UINT16_MAX);
		goto usage;
	}

	cmd.mode_timeout = timeout;
	
	// Send message to forward engine
	cmm_print(DEBUG_COMMAND, "Send FPP_CMD_RX_L2BRIDGE_FLOW_TIMEOUT to FPP\n");
	rc = cmmSendToDaemon(daemon_handle, FPP_CMD_RX_L2BRIDGE_FLOW_TIMEOUT, (unsigned short *) &cmd, sizeof(fpp_l2_bridge_control_cmd_t), rcvBuffer);
	if (rc != 2) /* we expect 2 bytes in response */
	{
		cmm_print(DEBUG_STDERR, "FPP_CMD_RX_L2BRIDGE_FLOW_TIMEOUT unexpected response length %d\n", rc);
		return -1;
	}
	else if ((((u_int16_t*)rcvBuffer)[0]) != FPP_ERR_OK)
	{
		cmm_print(DEBUG_STDERR, "Error %d received from FPP\n", ((u_int16_t*)rcvBuffer)[0]);
		return -1;
	}

	return 0;
usage:
	cmm_print(DEBUG_STDOUT, "Usage: set bridge timeout {timeout value in seconds}\n");
	return -1;
}

/************************************************************
 *
 *
 *
 ************************************************************/
void cmmRxShowPrintHelp()
{
	char buf[128];


	print_all_gemac_ports(buf, 128);
  //	cmm_print(DEBUG_STDOUT, "show rx not yet supported\n");
	cmm_print(DEBUG_STDOUT, "Usage: show rx interface {%s} icc\n"
				"       query rx bridge\n", buf);
}


/************************************************************
 *
 *
 *
 ************************************************************/
int cmmRxQueryProcess(char ** keywords, int tabStart, daemon_handle_t daemon_handle)
{
	int cpt = tabStart;
	unsigned int cmdToSend = 0; /* bits field*/
	int rcvBytes = 0;
 	char rcvBuffer[256];
 	char null_mac[6] = {0,0,0,0,0,0};

	//goto help
	if(!keywords[cpt])
		goto help;
	if(strcasecmp(keywords[cpt], "bridge") == 0)
	{
		cmdToSend |= CMD_BIT(FPP_CMD_RX_L2BRIDGE_QUERY_STATUS);
	}
	else
		goto keyword_error;

	if(TEST_CMD_BIT(cmdToSend, FPP_CMD_RX_L2BRIDGE_QUERY_STATUS))
	{
		int count = 0;
		char input_interface[IFNAMSIZ];
		char output_interface[IFNAMSIZ];
		char pkt_priority[16];
		char vlan_priority[16];
		char queue_modifier[16];
		fpp_l2_bridge_query_status_response_t *pStatusResponse = (fpp_l2_bridge_query_status_response_t *)rcvBuffer;
		fpp_l2_bridge_query_entry_response_t *pEntryResponse = (fpp_l2_bridge_query_entry_response_t *)rcvBuffer;

		while( 1 )
		{
			// Send CMD_RX_L2BRIDGE_QUERY_STATUS command
			rcvBytes = cmmSendToDaemon(daemon_handle, FPP_CMD_RX_L2BRIDGE_QUERY_STATUS, NULL, 0, rcvBuffer);
			if ( rcvBytes != sizeof(fpp_l2_bridge_query_status_response_t) )
			{
				cmm_print(DEBUG_STDERR, "ERROR: Unexpected result returned from FPP rc:%04x\n",
					  (rcvBytes < sizeof(unsigned short) ) ? 
								0 : *((unsigned short *) rcvBuffer)
				  );
				goto exit;
			}
			
			if (pStatusResponse->eof)
			    	break;

			cmm_print(DEBUG_STDOUT, "Interface %s Status: %s\n", 
					pStatusResponse->ifname, pStatusResponse->status ? "ON":"OFF");
		}
#if 0
		// Send CMD_RX_L2BRIDGE_QUERY_STATUS command
		rcvBytes = cmmSendToDaemon(daemon_handle, FPP_CMD_RX_L2BRIDGE_QUERY_STATUS, NULL, 0, rcvBuffer);
		if (rcvBytes != sizeof(fpp_l2_bridge_query_status_response_t) + sizeof(unsigned short))
		{
			cmm_print(DEBUG_STDERR, "ERROR: Unexpected result returned from FPP rc:%04x\n",
				  (rcvBytes < sizeof(unsigned short) ) ? 0 : *((unsigned short *) rcvBuffer)
			  );
			goto exit;
		}
#ifdef WIFI_ENABLE
		cmm_print(DEBUG_STDOUT, "Interface %s (WAN) Status: %s\nInterface %s (LAN) Status: %s\nInterface %s (WIFI) Status: %s\nInterface %s (WIFI) Status: %s\n",
						WAN_INTERFACE_NAME,
						( pStatusResponse->status & (1 << WAN_PORT_ID))? "ON" : "OFF",
						LAN_INTERFACE_NAME,
						( pStatusResponse->status & (1 << LAN_PORT_ID))? "ON" : "OFF",
						WIFI_INTERFACE_NAME0,
						( pStatusResponse->status & (1 << WIFI_PORT0)) ? "ON" : "OFF",
						WIFI_INTERFACE_NAME1,
						( pStatusResponse->status & (1 << WIFI_PORT1)) ? "ON" : "OFF");
#else
		cmm_print(DEBUG_STDOUT, "Interface %s (WAN) Status: %s\nInterface %s (LAN) Status: %s\n",
						WAN_INTERFACE_NAME,
						( pStatusResponse->status & (1 << WAN_PORT_ID))? "ON" : "OFF",
						LAN_INTERFACE_NAME,
						( pStatusResponse->status & (1 << LAN_PORT_ID))? "ON" : "OFF");
#endif
#endif
		while (1)
		{
			char sessionid_buf[32];
			rcvBytes = cmmSendToDaemon(daemon_handle, FPP_CMD_RX_L2BRIDGE_QUERY_ENTRY, NULL, 0, rcvBuffer);
			if (rcvBytes != sizeof(fpp_l2_bridge_query_entry_response_t))
			{
				cmm_print(DEBUG_STDERR, "ERROR: CMD_RX_L2BRIDGE_QUERY_ENTRY Unexpected result returned from FPP rc:%04x - received %d - expected %d\n",
				  	(rcvBytes < sizeof(unsigned short) ) ? 0 : *((unsigned short *) rcvBuffer),
					rcvBytes,
					sizeof(fpp_l2_bridge_query_entry_response_t)
			  	);
				goto exit;
			}
			if (pEntryResponse->eof)
			    	break;
			if (pEntryResponse->input_interface >= GEM_PORTS)
				strcpy(input_interface, pEntryResponse->input_name);	
			else	
				get_port_name(pEntryResponse->input_interface, input_interface, IFNAMSIZ);
			
			if (pEntryResponse->input_vlan != 0xFFFF)
				sprintf(input_interface + strlen(input_interface), ".%d", pEntryResponse->input_vlan);

			if (pEntryResponse->output_interface >= GEM_PORTS)
				strcpy(output_interface, pEntryResponse->output_name);	
			else	
				get_port_name(pEntryResponse->output_interface, output_interface, IFNAMSIZ);
			
			if (pEntryResponse->output_vlan != 0xFFFF)
				sprintf(output_interface + strlen(output_interface), ".%d", pEntryResponse->output_vlan);
			if (pEntryResponse->pkt_priority == 0x8000)
				strcpy(pkt_priority, "vlan");
			else
				sprintf(pkt_priority, "%d", pEntryResponse->pkt_priority);
			if (pEntryResponse->vlan_priority == 0x8000)
				strcpy(vlan_priority, "copy");
			else
				sprintf(vlan_priority, "%d", pEntryResponse->vlan_priority);
			
			if (pEntryResponse->session_id != 0)
				sprintf(sessionid_buf, "SessionId=%d ", pEntryResponse->session_id);
			else
				sessionid_buf[0] = '\0';

			if(pEntryResponse->queue_modifier == FPP_BRIDGE_QMOD_DSCP)
				strcpy(queue_modifier, "dscp");
			else
				strcpy(queue_modifier, "none");	


			if ((!memcmp(pEntryResponse->srcaddr, null_mac, 6)) && (pEntryResponse->ethertype == 0))
				cmm_print(DEBUG_STDOUT, "Input=%-6s "
				                "DA=%02X:%02X:%02X:%02X:%02X:%02X "
				                "SA=       *          "
						  "Type=  *  "
						  "Queue=%-s "
						  "Qmod=%-s "
						  "VLANPrio=%-s "
						  "%s"
						  "Output=%s\n",
						    input_interface,
						    pEntryResponse->destaddr[0], pEntryResponse->destaddr[1], pEntryResponse->destaddr[2],
						    pEntryResponse->destaddr[3], pEntryResponse->destaddr[4], pEntryResponse->destaddr[5],
						    pkt_priority, queue_modifier, vlan_priority, sessionid_buf, output_interface);
			else if (!memcmp(pEntryResponse->srcaddr, null_mac, 6))
				cmm_print(DEBUG_STDOUT, "Input=%-6s "
				                "DA=%02X:%02X:%02X:%02X:%02X:%02X "
				                "SA=       *          "
						  "Type=%04X "
						  "Queue=%-s "
						  "Qmod=%-s "
						  "VLANPrio=%-s "
						  "%s"
						  "Output=%s\n",
						    input_interface,
						    pEntryResponse->destaddr[0], pEntryResponse->destaddr[1], pEntryResponse->destaddr[2],
						    pEntryResponse->destaddr[3], pEntryResponse->destaddr[4], pEntryResponse->destaddr[5],
						    pEntryResponse->ethertype, pkt_priority, queue_modifier, vlan_priority, sessionid_buf, output_interface);
			else if (pEntryResponse->ethertype == 0)
				cmm_print(DEBUG_STDOUT, "Input=%-6s "
				                "DA=%02X:%02X:%02X:%02X:%02X:%02X "
				                "SA=%02X:%02X:%02X:%02X:%02X:%02X "
						  "Type=  *  "
						  "Queue=%-s "
						  "Qmod=%-s "
						  "VLANPrio=%-s "
						  "%s"
						  "Output=%s\n",
						    input_interface,
						    pEntryResponse->destaddr[0], pEntryResponse->destaddr[1], pEntryResponse->destaddr[2],
						    pEntryResponse->destaddr[3], pEntryResponse->destaddr[4], pEntryResponse->destaddr[5],
						    pEntryResponse->srcaddr[0], pEntryResponse->srcaddr[1], pEntryResponse->srcaddr[2],
						    pEntryResponse->srcaddr[3], pEntryResponse->srcaddr[4], pEntryResponse->srcaddr[5],
						    pkt_priority, queue_modifier, vlan_priority, sessionid_buf, output_interface);

			else	
			cmm_print(DEBUG_STDOUT, "Input=%-6s "
				                "DA=%02X:%02X:%02X:%02X:%02X:%02X "
				                "SA=%02X:%02X:%02X:%02X:%02X:%02X "
						  "Type=%04X "
						  "Queue=%-s "
						  "Qmod=%-s "
						  "VLANPrio=%-s "
						  "%s"
						  "Output=%s\n",
						    input_interface,
						    pEntryResponse->destaddr[0], pEntryResponse->destaddr[1], pEntryResponse->destaddr[2],
						    pEntryResponse->destaddr[3], pEntryResponse->destaddr[4], pEntryResponse->destaddr[5],
						    pEntryResponse->srcaddr[0], pEntryResponse->srcaddr[1], pEntryResponse->srcaddr[2],
						    pEntryResponse->srcaddr[3], pEntryResponse->srcaddr[4], pEntryResponse->srcaddr[5],
						    pEntryResponse->ethertype, pkt_priority, queue_modifier, vlan_priority, sessionid_buf, output_interface);
			count++;
		}
		cmm_print(DEBUG_STDOUT, "\n%d Bridge Table Entries found\n", count);
	}

        return 0;

keyword_error:
	cmm_print(DEBUG_STDERR, "ERROR: Unknown keyword %s\n", keywords[cpt]);

help:
	cmmRxShowPrintHelp();

exit:
	return -1;
}

/************************************************************
 *
 *
 *
 ************************************************************/
int cmmRxShowProcess(char ** keywords, int tabStart, daemon_handle_t daemon_handle)
{
	int cpt = tabStart;
	unsigned int cmdToSend = 0; /* bits field*/
	int rcvBytes = 0;
 	char rcvBuffer[256];

	fpp_rx_icc_disable_cmd_t showCmd;  // same structure used for show
	fpp_rx_icc_show_return_cmd_t *iccStatus;

	//goto help
	if(!keywords[cpt])
		goto help;
	if(strcasecmp(keywords[cpt], "interface") == 0)
	{
		if(!keywords[++cpt])
			goto help;
		
		if ((showCmd.interface = get_port_id(keywords[cpt])) < 0)
			goto keyword_error;

		if(!keywords[++cpt])
			goto help;
		if(strcasecmp(keywords[cpt], "icc") == 0)
			cmdToSend |= CMD_BIT(FPP_CMD_RX_CNG_SHOW);
		else
			goto keyword_error;
	}
	else
		goto keyword_error;


	if(TEST_CMD_BIT(cmdToSend, FPP_CMD_RX_CNG_SHOW))
	{
		// Send CMD_RX_CNG_SHOW command
		rcvBytes = cmmSendToDaemon(daemon_handle, FPP_CMD_RX_CNG_SHOW, & showCmd, sizeof(showCmd), rcvBuffer);

		if ( rcvBytes < (sizeof(fpp_rx_icc_show_return_cmd_t) - sizeof(unsigned short)) )
		{
			cmm_print(DEBUG_STDERR, "ERROR: Unexpected returned result from FPP rc:%04x\n",
				  (rcvBytes < sizeof(unsigned short) ) ? 0 : *((unsigned short *) rcvBuffer)
			  );
			goto exit;
		}
		else
		{
			iccStatus = (fpp_rx_icc_show_return_cmd_t *)(rcvBuffer);
			cmm_print(DEBUG_STDOUT, "State: %s\n" "Acc: %d\n" "onThr: %d\n" "offThr: %d\n",
					(iccStatus->state & 1 )? "Enabled":"Disabled\n", iccStatus->acc_value, iccStatus->on_thr, iccStatus->off_thr);
			if (iccStatus->state & 0xfe)
			    cmm_print(DEBUG_STDOUT, "Flags: 0x%02x\n", iccStatus->state & 0xfe);
			
		}
	}

	return 0;

keyword_error:
	cmm_print(DEBUG_STDERR, "ERROR: Unknown keyword %s\n", keywords[cpt]);

help:
	cmmRxShowPrintHelp();

exit:
	return -1;

}


/************************************************************
 *
 *
 *
 ************************************************************/
void cmmRxSetPrintHelp(int cmd_type)
{
	char buf[128];


	print_all_gemac_ports(buf, 128);

	if (cmd_type == UNKNOWN_CMD || cmd_type == ICC_CMD)
	{
	    cmm_print(DEBUG_STDOUT, 
                  "Usage: set rx interface {%s} [icc {on|off}]\n"
                  "                             [acc {acc_value}]\n"
                  "                             [on_thr {on_thr value}]\n"
                  "                             [off_thr {off_thr value}]\n"
                  "                             [flag {flag value}]\n"
                  "                             [val1 {val1 value}]\n"
                  "                             [val2 {val2 value}]\n", buf);
	}
	if (cmd_type == UNKNOWN_CMD)
	{
	    cmm_print(DEBUG_STDOUT, "\n");
	}
	if (cmd_type == UNKNOWN_CMD || cmd_type == BRIDGE_CMD)
	{
#ifdef WIFI_ENABLE
	    //FIXME : Now interface names are hardcoded to ath0/ath1. Need to 
	    //        find solution to get interface names from config file.	
	    cmm_print(DEBUG_STDOUT, 
                  "Usage: set rx interface {%s|<wi-fi interface>} [bridge {on|off|add|remove}]\n"
                  "                add / remove options:\n"
                  "                                      [da {dest_addr value}]\n"
                  "                                      [sa {src_addr value}]\n"
                  "                                      [type {ethertype value}]\n"
                  "                add options:\n"
                  "                                      [queue {output queue base value 0-31|vlan}]\n"
                  "                                      [vlanprio {priority value|copy}]\n"
                  "                                      [sessionid {session id value}]\n"
                  "                                      [output {interface}]\n"
		  "                                      [qmod {output queue modifier dscp|none}]\n", buf);
#else
	    cmm_print(DEBUG_STDOUT, 
                  "Usage: set rx interface {%s} [bridge {on|off|add|remove}]\n"
                  "                add / remove options:\n"
                  "                                      [da {dest_addr value}]\n"
                  "                                      [sa {src_addr value}]\n"
                  "                                      [type {ethertype value}]\n"
                  "                add options:\n"
                  "                                      [queue {output queue base value 0-31|vlan}]\n"
                  "                                      [vlanprio {priority value|copy}]\n"
                  "                                      [sessionid {session id value}]\n"
                  "                                      [output {interface}]\n"
		  "                                      [qmod {output queue modifier dscp|none}]\n", buf);
#endif
	}
}


/************************************************************
 *
 *
 *
 ************************************************************/
static int parse_interface(char *pstring, unsigned short *pinterface_number );
static int parse_interface_vlan(char *pstring, unsigned short *pinterface_number, unsigned short *pvlan_id);

int cmmRxSetProcess(char ** keywords, int tabStart, daemon_handle_t daemon_handle)
{
	int cmd_type = UNKNOWN_CMD;
	int cpt = tabStart;
	unsigned int cmdToSend = 0; /* bits field*/
	char * endptr;
	unsigned int tmp;
        int rcvBytes = 0;
	char *pinterface;
	unsigned short interface;

	fpp_rx_icc_enable_cmd_t enableCmd;
	fpp_rx_icc_disable_cmd_t disableCmd;

	fpp_l2_bridge_enable_cmd_t bridgeEnableCmd;
	fpp_l2_bridge_add_entry_cmd_t bridgeAddCmd;
	fpp_l2_bridge_remove_entry_cmd_t bridgeRemoveCmd;

	char rcvBuffer[256];

	if(!keywords[cpt])
		goto help;

	if(strcasecmp(keywords[cpt], "interface") == 0)
	{
		if(!keywords[++cpt])
			goto help;
		pinterface = keywords[cpt];
	}
	else
		goto keyword_error;

	if(!keywords[++cpt])
		goto help;

   if(strcasecmp(keywords[cpt], "icc") == 0)
   {		
       		cmd_type = ICC_CMD;
		if(!keywords[++cpt])
			goto help;

		if(strcasecmp(keywords[cpt], "on") == 0)
		{
			cmdToSend |= CMD_BIT(FPP_CMD_RX_CNG_ENABLE);
			memset(&enableCmd, 0, sizeof(enableCmd));
			if (parse_icc_interface(pinterface, &interface, 2) < 0)
				goto help;
			enableCmd.interface = interface;

			cpt++;

			while (keywords[cpt] != NULL)
			{
				if(strcasecmp(keywords[cpt], "acc") == 0)
				{
					if(!keywords[++cpt])
						goto help;

				    /*Get an integer from the string*/
				    endptr = NULL;
				    tmp = strtoul(keywords[cpt], &endptr, 0);
				    if ((keywords[cpt] == endptr) || (tmp > USHRT_MAX))
				    {
				        cmm_print(DEBUG_CRIT, "icc ERROR: acc must be a number between 1 and %d\n", USHRT_MAX);
				        goto help;
				    }

				    enableCmd.acc_value = tmp;
				}
				else if(strcasecmp(keywords[cpt], "on_thr") == 0)
				{
				    if(!keywords[++cpt])
				        goto help;

				    /*Get an integer from the string*/
				    endptr = NULL;
				    tmp = strtoul(keywords[cpt], &endptr, 0);
				    if ((keywords[cpt] == endptr) || (tmp > USHRT_MAX))
				    {
				        cmm_print(DEBUG_CRIT, "icc ERROR: on_thr must be a number between 1 and %d\n", USHRT_MAX);
				        goto help;
				    }

				    enableCmd.on_thr = tmp;
				}
				else if(strcasecmp(keywords[cpt], "off_thr") == 0)
				{
				    if(!keywords[++cpt])
				        goto help;

				    /*Get an integer from the string*/
				    endptr = NULL;
				    tmp = strtoul(keywords[cpt], &endptr, 0);
				    if ((keywords[cpt] == endptr) || (tmp > USHRT_MAX))
				    {
				        cmm_print(DEBUG_CRIT, "icc ERROR: off_thr must be a number between 1 and %d\n", USHRT_MAX);
				        goto help;
				    }

				    enableCmd.off_thr = tmp;
				}
				else if (strncasecmp(keywords[cpt],"flag",1) == 0) {
				    if(!keywords[++cpt])
				        goto help;
				    endptr = NULL;
				    tmp = strtoul(keywords[cpt], &endptr, 0);
				    enableCmd.flag = tmp;
				}
				else if (strcasecmp(keywords[cpt],"val1") == 0) {
				    if(!keywords[++cpt])
				        goto help;
				    endptr = NULL;
				    tmp = strtoul(keywords[cpt], &endptr, 0);
				    enableCmd.val1 = tmp;
				}
				else if (strcasecmp(keywords[cpt],"val2") == 0) {
				    if(!keywords[++cpt])
				        goto help;
				    endptr = NULL;
				    tmp = strtoul(keywords[cpt], &endptr, 0);
				    enableCmd.val1 = tmp;
				}
				else
				    goto help;
			
				cpt ++;
			}
		}
		else if(strcasecmp(keywords[cpt], "off") == 0)
		{
			cmdToSend |= CMD_BIT(FPP_CMD_RX_CNG_DISABLE);
			memset(&disableCmd, 0, sizeof(disableCmd));
			if (parse_icc_interface(pinterface, &interface, 2) < 0)
				goto help;
			disableCmd.interface = interface;
		}
		else
			goto keyword_error;
   }
   else if(strcasecmp(keywords[cpt], "bridge") == 0)
   {		
       		cmd_type = BRIDGE_CMD;
		if(!keywords[++cpt])
			goto help;

		if(strcasecmp(keywords[cpt], "on") == 0)
		{
			if (keywords[++cpt])
				goto help;
			cmdToSend |= CMD_BIT(FPP_CMD_RX_L2BRIDGE_ENABLE);
			memset(&bridgeEnableCmd, 0, sizeof(bridgeEnableCmd));
			bridgeEnableCmd.enable_flag = 1;
			bridgeEnableCmd.interface = 0xffff;
		
			strcpy (&bridgeEnableCmd.input_name[0], pinterface);
				
		}
		else if(strcasecmp(keywords[cpt], "off") == 0)
		{
			if (keywords[++cpt])
				goto help;
			cmdToSend |= CMD_BIT(FPP_CMD_RX_L2BRIDGE_ENABLE);
			memset(&bridgeEnableCmd, 0, sizeof(bridgeEnableCmd));
			bridgeEnableCmd.enable_flag = 0;
			bridgeEnableCmd.interface = 0xffff;
			strcpy (&bridgeEnableCmd.input_name[0], pinterface);
		}
		else if(strcasecmp(keywords[cpt], "add") == 0)
		{
			cmdToSend |= CMD_BIT(FPP_CMD_RX_L2BRIDGE_ADD);
			memset(&bridgeAddCmd, 0, sizeof(bridgeAddCmd));
			strcpy(bridgeAddCmd.input_name, pinterface);
			bridgeAddCmd.input_interface = 0xffff;
			bridgeAddCmd.input_vlan = 0xffff;
			bridgeAddCmd.output_interface = 0xffff;
			bridgeAddCmd.output_vlan = 0xFFFF;
			while (keywords[++cpt] != NULL)
			{
				if(strcasecmp(keywords[cpt], "da") == 0)
				{
					if(!keywords[++cpt])
						goto help;
					if (!parse_macaddr(keywords[cpt], bridgeAddCmd.destaddr))
					{
						cmm_print(DEBUG_CRIT, "bridge ERROR: bad MAC address: %s\n", keywords[cpt]);
						goto help;
					}
				}
				else if(strcasecmp(keywords[cpt], "sa") == 0)
				{
					if(!keywords[++cpt])
						goto help;
					if (!parse_macaddr(keywords[cpt], bridgeAddCmd.srcaddr))
					{
						cmm_print(DEBUG_CRIT, "bridge ERROR: bad MAC address: %s\n", keywords[cpt]);
						goto help;
					}
				}
				else if(strcasecmp(keywords[cpt], "type") == 0)
				{
					if(!keywords[++cpt])
						goto help;
					tmp = strtoul(keywords[cpt], &endptr, 0);
					if ((keywords[cpt] == endptr) || (tmp > 0xFFFF))
					{
					    cmm_print(DEBUG_CRIT, "bridge ERROR: bad ETHERTYPE value: %s\n", keywords[cpt]);
					    goto help;
					}
					bridgeAddCmd.ethertype = (unsigned short)tmp;
				}
				else if(strcasecmp(keywords[cpt], "prio") == 0)
				{
					if(!keywords[++cpt])
						goto help;
					if (strcasecmp(keywords[cpt], "vlan") == 0)
						bridgeAddCmd.pkt_priority = 0x8000;
					else
					{
						tmp = strtoul(keywords[cpt], &endptr, 0);
						if ((keywords[cpt] == endptr) || (tmp > 7))
						{
					    		cmm_print(DEBUG_CRIT, "bridge ERROR: bad PRIORITY value: %s\n", keywords[cpt]);
					    		goto help;
						}
						bridgeAddCmd.pkt_priority = (unsigned short)tmp;
					}
				}
				else if(strcasecmp(keywords[cpt], "queue") == 0)
				{
					if(!keywords[++cpt])
						goto help;
					if (strcasecmp(keywords[cpt], "vlan") == 0)
						bridgeAddCmd.pkt_priority = 0x8000;
					else
					{
						tmp = strtoul(keywords[cpt], &endptr, 0);
						if ((keywords[cpt] == endptr) || (tmp >= FPP_NUM_QUEUES))
						{
					    		cmm_print(DEBUG_CRIT, "bridge ERROR: bad QUEUE value: %s\n", keywords[cpt]);
					    		goto help;
						}
						bridgeAddCmd.pkt_priority = (unsigned short)tmp;
					}
				}
				else if(strcasecmp(keywords[cpt], "vlanprio") == 0)
				{
					if(!keywords[++cpt])
						goto help;
					if (strcasecmp(keywords[cpt], "copy") == 0)
						bridgeAddCmd.vlan_priority = 0x8000;
					else
					{
						tmp = strtoul(keywords[cpt], &endptr, 0);
						if ((keywords[cpt] == endptr) || (tmp > 7))
						{
					    		cmm_print(DEBUG_CRIT, "bridge ERROR: bad VLAN PRIORITY value: %s\n", keywords[cpt]);
					    		goto help;
						}
						bridgeAddCmd.vlan_priority = (unsigned short)tmp;
					}
				}
				else if(strcasecmp(keywords[cpt], "sessionid") == 0)
				{
					if(!keywords[++cpt])
						goto help;
					tmp = strtoul(keywords[cpt], &endptr, 0);
					if ((keywords[cpt] == endptr) || (tmp > 0xFFFF))
					{
					    cmm_print(DEBUG_CRIT, "bridge ERROR: bad SESSION ID value: %s\n", keywords[cpt]);
					    goto help;
					}
					bridgeAddCmd.session_id = (unsigned short)tmp;
				}
				else if(strcasecmp(keywords[cpt], "output") == 0)
				{
					if(!keywords[++cpt])
						goto help;
					bridgeAddCmd.output_interface = 0xFFFF;
					bridgeAddCmd.input_interface  = 0xFFFF;
					bridgeAddCmd.output_vlan = 0xFFFF;
					strcpy(bridgeAddCmd.output_name, keywords[cpt]);
					strcpy(bridgeAddCmd.input_name, pinterface);
				}
				else if(strcasecmp(keywords[cpt], "qmod") == 0)
				{
					if(!keywords[++cpt])
						goto help;
					if (strcasecmp(keywords[cpt], "dscp") == 0)
						bridgeAddCmd.queue_modifier = FPP_BRIDGE_QMOD_DSCP;
					else if(strcasecmp(keywords[cpt], "none") == 0)
						bridgeAddCmd.queue_modifier = FPP_BRIDGE_QMOD_NONE;
					else {
						bridgeAddCmd.queue_modifier = FPP_BRIDGE_QMOD_NONE;
						cmm_print(DEBUG_CRIT, "bridge ERROR: bad QUEUE MODIFIER  value: %s\n", keywords[cpt]);
					    	goto help;
					}
				}
				else
				    goto help;
			}
		}
		else if(strcasecmp(keywords[cpt], "remove") == 0)
		{
			cmdToSend |= CMD_BIT(FPP_CMD_RX_L2BRIDGE_REMOVE);
			memset(&bridgeRemoveCmd, 0, sizeof(bridgeRemoveCmd));
			strcpy(bridgeRemoveCmd.input_name, pinterface);
			bridgeRemoveCmd.input_interface = 0xffff;
			bridgeRemoveCmd.input_vlan = 0xffff;
			while (keywords[++cpt] != NULL)
			{
				if(strcasecmp(keywords[cpt], "da") == 0)
				{
					if(!keywords[++cpt])
						goto help;
					if (!parse_macaddr(keywords[cpt], bridgeRemoveCmd.destaddr))
					{
						cmm_print(DEBUG_CRIT, "bridge ERROR: bad MAC address: %s\n", keywords[cpt]);
						goto help;
					}
				}
				else if(strcasecmp(keywords[cpt], "sa") == 0)
				{
					if(!keywords[++cpt])
						goto help;
					if (!parse_macaddr(keywords[cpt], bridgeRemoveCmd.srcaddr))
					{
						cmm_print(DEBUG_CRIT, "bridge ERROR: bad MAC address: %s\n", keywords[cpt]);
						goto help;
					}
				}
				else if(strcasecmp(keywords[cpt], "type") == 0)
				{
					if(!keywords[++cpt])
						goto help;
					tmp = strtoul(keywords[cpt], &endptr, 0);
					if ((keywords[cpt] == endptr) || (tmp > 0xFFFF))
					{
					    cmm_print(DEBUG_CRIT, "bridge ERROR: bad ETHERTYPE value: %s\n", keywords[cpt]);
					    goto help;
					}
					bridgeRemoveCmd.ethertype = (unsigned short)tmp;
				}
				else if(strcasecmp(keywords[cpt], "sessionid") == 0)
				{
					if(!keywords[++cpt])
						goto help;
					tmp = strtoul(keywords[cpt], &endptr, 0);
					if ((keywords[cpt] == endptr) || (tmp > 0xFFFF))
					{
					    cmm_print(DEBUG_CRIT, "bridge ERROR: bad SESSION ID value: %s\n", keywords[cpt]);
					    goto help;
					}
					bridgeRemoveCmd.session_id = (unsigned short)tmp;
				}
				else
				    goto help;
			}
		}
		else
			goto keyword_error;
   }
   else
       goto keyword_error;

	/*
	 * Parsing have been performed
	 * Now send the right commands
	 */
	if(TEST_CMD_BIT(cmdToSend, FPP_CMD_RX_L2BRIDGE_ENABLE))
	{
		// Send CMD_RX_L2BRIDGE_ENABLE command
		rcvBytes = cmmSendToDaemon(daemon_handle, FPP_CMD_RX_L2BRIDGE_ENABLE, & bridgeEnableCmd, sizeof(bridgeEnableCmd), rcvBuffer);
	}
        
	if(TEST_CMD_BIT(cmdToSend, FPP_CMD_RX_L2BRIDGE_ADD))
	{
		// Send CMD_RX_L2BRIDGE_ADD command
		rcvBytes = cmmSendToDaemon(daemon_handle, FPP_CMD_RX_L2BRIDGE_ADD, & bridgeAddCmd, sizeof(bridgeAddCmd), rcvBuffer);
	}
        
	if(TEST_CMD_BIT(cmdToSend, FPP_CMD_RX_L2BRIDGE_REMOVE))
	{
		// Send CMD_RX_L2BRIDGE_REMOVE command
		rcvBytes = cmmSendToDaemon(daemon_handle, FPP_CMD_RX_L2BRIDGE_REMOVE, & bridgeRemoveCmd, sizeof(bridgeRemoveCmd), rcvBuffer);
	}
        
	if(TEST_CMD_BIT(cmdToSend, FPP_CMD_RX_CNG_DISABLE))
	{
		// Send CMD_RX_CNG_DISABLE command
		rcvBytes = cmmSendToDaemon(daemon_handle, FPP_CMD_RX_CNG_DISABLE, & disableCmd, sizeof(disableCmd), rcvBuffer);
	}
	
	if(TEST_CMD_BIT(cmdToSend, FPP_CMD_RX_CNG_ENABLE))
	{
		// Send CMD_RX_CNG_ENABLE command
		rcvBytes = cmmSendToDaemon(daemon_handle, FPP_CMD_RX_CNG_ENABLE, & enableCmd, sizeof(enableCmd), rcvBuffer);
	}
        
	if ((rcvBytes != 2) || *((unsigned short *) rcvBuffer)) {
	  cmm_print(DEBUG_STDERR, "ERROR: Unexpected result returned from FPP rc:%04x\n",
		    (rcvBytes < sizeof(unsigned short) ) ? 0 : *((unsigned short *) rcvBuffer)
		    );
          return -1;
	}

	return 0;

keyword_error:
	cmm_print(DEBUG_CRIT, "ERROR: Unknown keyword %s\n", keywords[cpt]);

help:
	cmmRxSetPrintHelp(cmd_type);
	return -1;
}

/*********************************************************************************
 *
 *
 *
 ********************************************************************************/
int cmmL2BridgeProcessClientCmd(FCI_CLIENT* fci_handle, int fc, u_int8_t *cmd_buf, u_int16_t cmd_len, u_int16_t *res_buf, u_int16_t *res_len)
{
	fpp_l2_bridge_enable_cmd_t *bridgeEnableCmd;
	fpp_l2_bridge_add_entry_cmd_t *bridgeAddCmd;
	fpp_l2_bridge_remove_entry_cmd_t *bridgeRemoveCmd;
	unsigned short vlan_id, interface;
	
	cmm_print(DEBUG_INFO, "%s\n", __func__);

	res_buf[0] = CMMD_ERR_WRONG_COMMAND_SIZE;

	switch(fc)
	{
		case FPP_CMD_RX_L2BRIDGE_ENABLE:
			cmm_print(DEBUG_INFO, "2 %s\n", __func__);
			bridgeEnableCmd = (fpp_l2_bridge_enable_cmd_t *)cmd_buf;
			*res_len = 2;
			if( cmd_len < sizeof(fpp_l2_bridge_enable_cmd_t) )
			{
				cmm_print(DEBUG_ERROR, "%s: Bridge enable command size too small(%d, %d)\n", 
						__func__, cmd_len, sizeof(fpp_l2_bridge_enable_cmd_t));
				return 0;
			}
			
			if( parse_interface(bridgeEnableCmd->input_name, &interface) < 0 )
			{
				cmm_print(DEBUG_ERROR, "%s: Bridge enable command with unknown interface: %s\n",
						__func__, bridgeEnableCmd->input_name);
				res_buf[0] = CMMD_ERR_NOT_CONFIGURED;
				return 0; 
			}
			bridgeEnableCmd->interface = interface;
			
			goto FCI_CMD; 

		case FPP_CMD_RX_L2BRIDGE_ADD:
			bridgeAddCmd = (fpp_l2_bridge_add_entry_cmd_t *)cmd_buf;
			*res_len = 2;
			if( cmd_len < sizeof(fpp_l2_bridge_add_entry_cmd_t) )
			{
				cmm_print(DEBUG_ERROR, "%s: Bridge add command size too small(%d, %d)\n", 
						__func__, cmd_len, sizeof(fpp_l2_bridge_add_entry_cmd_t));
				return 0;
			}
			
			if( parse_interface_vlan(bridgeAddCmd->input_name, &interface, &vlan_id) < 0 )
			{
				cmm_print(DEBUG_ERROR, "%s: Bridge add command with unknown interface: %s\n",
						__func__, bridgeAddCmd->input_name);
				res_buf[0] = CMMD_ERR_NOT_CONFIGURED;
				return 0; 
			}
			bridgeAddCmd->input_interface = interface;
			bridgeAddCmd->input_vlan = vlan_id;

		/* FIXME : output interface should be provided by the user */
		//	bridgeAddCmd->output_interface = interface == GEMAC0_PORT ? GEMAC1_PORT : GEMAC0_PORT;
		//	bridgeAddCmd->output_vlan = 0xFFFF;

		//	if (!strlen(bridgeAddCmd->output_name))
		//		goto FCI_CMD;

			if( parse_interface_vlan(bridgeAddCmd->output_name, &interface, &vlan_id) == 0 )
			{
				bridgeAddCmd->output_interface = interface;
				bridgeAddCmd->output_vlan = vlan_id;
			}
			else
			{
				bridgeAddCmd->output_interface = 0xFFFF;
				bridgeAddCmd->input_interface  = 0xFFFF;
				bridgeAddCmd->output_vlan = 0xFFFF;
			}	
			goto FCI_CMD;
 
		case FPP_CMD_RX_L2BRIDGE_REMOVE:
			bridgeRemoveCmd = (fpp_l2_bridge_remove_entry_cmd_t *)cmd_buf;
			*res_len = 2;
			if( cmd_len < sizeof(fpp_l2_bridge_remove_entry_cmd_t) )
			{
				cmm_print(DEBUG_ERROR, "%s: Bridge remove command size too small(%d, %d)\n", 
						__func__, cmd_len, sizeof(fpp_l2_bridge_remove_entry_cmd_t));
				return 0;
			}
			
			if( parse_interface_vlan(bridgeRemoveCmd->input_name, &interface, &vlan_id) < 0 )
			{
				cmm_print(DEBUG_ERROR, "%s: Bridge remove command with unknown interface: %s\n",
						__func__, bridgeRemoveCmd->input_name);
				res_buf[0] = CMMD_ERR_NOT_CONFIGURED;
				return 0; 
			}
			
			bridgeRemoveCmd->input_interface = interface;
			bridgeRemoveCmd->input_vlan = vlan_id;
					
			goto FCI_CMD;

		case FPP_CMD_RX_L2BRIDGE_QUERY_STATUS:
		case FPP_CMD_RX_L2BRIDGE_QUERY_ENTRY:
			goto FCI_CMD;
	}
FCI_CMD:
	return fci_cmd(fci_handle, fc, (u_int16_t*)cmd_buf, cmd_len, res_buf, res_len);
	
}
  
int parse_icc_interface(char *pstring, unsigned short *pinterface_number, int num_interfaces)
{
	u_int32_t interface;

	if ((short)(*pinterface_number = get_port_id(pstring)) < 0)
	{
		if (parse_value(pstring, &interface, num_interfaces - 1) == 0)
		{
			*pinterface_number = interface;
		}
		else
		{
			return -1;
		}
	}

	return 0;	
}

static int parse_interface(char *pstring, unsigned short *pinterface_number)
{
	if ((short)(*pinterface_number = get_port_id(pstring)) < 0)
	{
#ifdef WIFI_ENABLE
		int i, ret;

		__pthread_mutex_lock(&itf_table.lock);
		ret = __itf_is_programmed(if_nametoindex(pstring));
		__pthread_mutex_unlock(&itf_table.lock);

		if( ret <= 0 )
			return -1;

		for (i = 0; i < MAX_WIFI_FF_IFS; i++)	
		{
			if( !strcmp(pstring, glbl_wifi_ff_ifs[i].ifname) && glbl_wifi_ff_ifs[i].used )
			{
				*pinterface_number = WIFI_PORT0 + i;
				break;
			}
		}
	
		if( i >= MAX_WIFI_FF_IFS )
#endif
			return -1;
	}
	return 0;
}

static int parse_interface_vlan(char *pstring, unsigned short *pinterface_number, unsigned short *pvlan_id)
{
	char interface[16];
	char *pperiod;
	char *peos;
	unsigned long vlan_id;
	strncpy(interface, pstring, sizeof(interface) - 1);
	pperiod = strchr(interface, '.');
	if (pperiod)
	    	*pperiod++ = '\0';
	if ((short)(*pinterface_number = get_port_id(pstring)) < 0)
	{
#ifdef WIFI_ENABLE
		int i, ret;
		
		__pthread_mutex_lock(&itf_table.lock);
		ret = __itf_is_programmed(if_nametoindex(interface));
		__pthread_mutex_unlock(&itf_table.lock);

		if( ret <= 0 )
			return -1;

		for (i = 0; i < MAX_WIFI_FF_IFS; i++)	
		{
			if( !strcmp(interface, glbl_wifi_ff_ifs[i].ifname) &&  glbl_wifi_ff_ifs[i].used )
			{
				*pinterface_number = WIFI_PORT0 + 1;
				break;
			}
		}
		
		if( i >= MAX_WIFI_FF_IFS )
#endif
			return -1;
	}

	if (pperiod)
	{
		vlan_id = strtoul(pperiod, &peos, 10);
		if (peos == pperiod || *peos != '\0' || vlan_id > 4094)
		{
			cmm_print(DEBUG_CRIT, "ERROR: Invalid VLAN specification: %s\n", pstring);
			return -1;
		}
		*pvlan_id = (unsigned short)vlan_id;
	}
	else
		*pvlan_id = 0xFFFF;

	return 0;
}

int parse_macaddr(char *pstring, unsigned char *pmacaddr)
{
    int i, n;
    unsigned long nextbyte;
    char *endp;
    for (i = 0; i < 6; i++)
    {
	nextbyte = strtoul(pstring, &endp, 16);
	n = endp - pstring;
	if (n < 1 || n > 2)
	    return 0;
	if ((i < 5 && *endp != ':') || (i == 5 && *endp != '\0'))
	    return 0;
	*pmacaddr++ = (unsigned char)nextbyte;
	pstring = endp + 1;
    }
    return 1;
}