/*
 *
 *  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 <net/if.h>
#include <linux/if_vlan.h>
#include <linux/sockios.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <ctype.h>

#include "libcmm.h"
#include "cmm.h"
#include "fpp.h"
#include "itf.h"
#include "module_pktcap.h"

#define MIN_SLICE_VALUE		40
#define MAX_SLICE_VALUE		1518
#define SNAP_LENGTH          	96


int PktCapSliceProcess(daemon_handle_t daemon_handle, int argc, char *argv[])
{

        cmm_command_t           cmd;
        cmm_response_t          res;
        fpp_pktcap_slice_cmd_t 	*pktcap_cmd;
	unsigned char		port_id;
	unsigned short		slice;
	char buf[128];

	
	if (argc != 2)
		goto usage;
		
	if ((char)(port_id = get_port_id(argv[0])) < 0)
		goto usage;


	if (! isdigit(*argv[1]))
		goto usage;
	
	slice = atoi(argv[1]);

	if ( (slice < MIN_SLICE_VALUE )||(slice > MAX_SLICE_VALUE))
	{
		cmm_print(DEBUG_ERROR,"slice value should be between(%d-%d)", MIN_SLICE_VALUE, MAX_SLICE_VALUE);
		return -1;
	}

	memset(&cmd, 0 , sizeof(cmd));
        memset(&res, 0 , sizeof(res));
	
	
	cmd.func 	= FPP_CMD_PKTCAP_SLICE;
	cmd.length 	= sizeof(fpp_pktcap_slice_cmd_t);
	pktcap_cmd	= (fpp_pktcap_slice_cmd_t*)&cmd.buf;
	pktcap_cmd->action	= FPP_PKTCAP_SLICE;
	pktcap_cmd->ifindex	= port_id;
	pktcap_cmd->slice	= slice;
	if (cmm_send(daemon_handle, &cmd, 0) != 0) {
                cmm_print(DEBUG_ERROR,"Error sending message to CMM, error = `%s'\n", strerror(errno));
                return -1;
        }

        if (cmm_recv(daemon_handle, &res, 0) < 0) {
                cmm_print(DEBUG_ERROR,"Error receiving message from CMM, error = `%s'\n", strerror(errno));
                return -1;
        }

        if (res.rc != FPP_ERR_OK) {
                cmm_print(DEBUG_ERROR,"Error from CMM, error = `%d'\n", res.rc);
                return -1;
        }
	
        return CLI_OK;
usage:
	print_all_gemac_ports(buf, 128);
	cmm_print(DEBUG_ERROR, "Usage: pktcapture  slice <%s> <value>\n", buf);
        return -1;
}

int PktCapStatProcess(daemon_handle_t daemon_handle, int argc, char *argv[])
{
        cmm_command_t           cmd;
        cmm_response_t          res;
        fpp_pktcap_status_cmd_t        *pktcap_cmd;
        unsigned char           port_id;
        unsigned char		status;
	char 			buf[128];


	if (argc != 2)
		goto usage;

	if ((char)(port_id = get_port_id(argv[0])) < 0)
		goto usage;


        if (strcmp(argv[1] , "enable") == 0)
                status = PKTCAP_IFSTATUS_ENABLE;
        else if (strcmp(argv[1], "disable") == 0)
                status = PKTCAP_IFSTATUS_DISABLE;
        else
                goto usage;
	

        memset(&cmd, 0 , sizeof(cmd));
        memset(&res, 0 , sizeof(res));

        
        cmd.func        = FPP_CMD_PKTCAP_IFSTATUS;
        cmd.length      = sizeof(fpp_pktcap_status_cmd_t);
        pktcap_cmd      = (fpp_pktcap_status_cmd_t*)&cmd.buf;
        pktcap_cmd->action      = FPP_PKTCAP_STATUS;
        pktcap_cmd->ifindex     = port_id;
        pktcap_cmd->status      = status;

        if (cmm_send(daemon_handle, &cmd, 0) != 0) {
                cmm_print(DEBUG_ERROR,"Error sending message to CMM, error = `%s'\n", strerror(errno));
                return -1;
        }

        if (cmm_recv(daemon_handle, &res, 0) < 0) {
                cmm_print(DEBUG_ERROR,"Error receiving message from CMM, error = `%s'\n", strerror(errno));
                return -1;
        }

        if (res.rc != FPP_ERR_OK) {
                cmm_print(DEBUG_ERROR,"Error from CMM, error = `%d'\n", res.rc);
                return -1;
        }

        return CLI_OK;
usage:
	print_all_gemac_ports(buf, 128);
	cmm_print(DEBUG_ERROR, "Usage: pktcapture status <%s> <enable|disable>\n", buf);
        return CLI_OK;

}


int PktCapFilterProcess(daemon_handle_t daemon_handle, int argc, char *argv[])
{
	cmm_command_t           cmd;
        cmm_response_t          res;
        struct bpf_program fd = {0,NULL};
        fpp_pktcap_flf_cmd_t *pFlfCmd = NULL;
        int port_id = 0, fgmts = 0;
	int length = 0, seqno = 0;
	char buf[128];

        if (argc < 2)
                goto usage;

	if ((char)(port_id = get_port_id(argv[0])) < 0)
		goto usage;

	
	cmd.func        = FPP_CMD_PKTCAP_FLF;
	cmd.length      = sizeof(fpp_pktcap_flf_cmd_t);
	pFlfCmd =	(fpp_pktcap_flf_cmd_t* )&cmd.buf; 

	if( strlen(argv[1]) >= 1024 )
	{
		cmm_print(DEBUG_ERROR,"Error Filter too long \n");
		goto usage;
	}
	

        pcap_t *pd = pcap_open_dead(DLT_EN10MB, SNAP_LENGTH);
        if(pd)
	{
		if(pcap_compile(pd, &fd, argv[1], 1, 0)<0)
		{
			cmm_print(DEBUG_ERROR,"Error Invalid filter string \n");
			goto done;
		}

		if(( fd.bf_len == 1)&& ( fd.bf_insns[0].code == BPF_RET ))// Filter reset !!	
			goto reset_flf;

		pFlfCmd->ifindex = port_id;
		pFlfCmd->flen = length = fd.bf_len & 0xFFFF;

		if(Check_BPFfilter(fd.bf_insns, fd.bf_len))
		{
			cmm_print(DEBUG_ERROR,"Error This filter combination is not supported by FLF\n");
			goto done;
		}
			
		if(fd.bf_len > MAX_FLF_INSTRUCTIONS) 
		{
			cmm_print(DEBUG_ERROR,"Warning: Filter could be too expensive");
			length = MAX_FLF_INSTRUCTIONS;	
			fgmts = (fd.bf_len / MAX_FLF_INSTRUCTIONS);
			if( fd.bf_len % MAX_FLF_INSTRUCTIONS )
				++fgmts; // Account for one more fragment;
		}
		do
		{
			
			memcpy(pFlfCmd->filter, &fd.bf_insns[seqno * MAX_FLF_INSTRUCTIONS], length * sizeof(struct bpf_insn));

			pFlfCmd->mfg     = ((( fgmts - (seqno + 1)) > 0) << 3 ) | (seqno & 0x7);
					

			/* Push to FPP */
			if (cmm_send(daemon_handle, &cmd, 0) != 0) {
				cmm_print(DEBUG_ERROR,"Error sending message to CMM, error = `%s'\n", strerror(errno));
				goto reset_flf;
			}

			if (cmm_recv(daemon_handle, &res, 0) < 0) {
				cmm_print(DEBUG_ERROR,"Error receiving message from CMM, error = `%s'\n", strerror(errno));
				goto reset_flf;
			}

			if (res.rc != FPP_ERR_OK) {
				cmm_print(DEBUG_ERROR,"Error from CMM, error = `%d'\n", res.rc);
				goto reset_flf;
			}
			pFlfCmd->flen = (fd.bf_len - (++seqno * MAX_FLF_INSTRUCTIONS));
			if( pFlfCmd->flen / MAX_FLF_INSTRUCTIONS)
			{
				length = pFlfCmd->flen = MAX_FLF_INSTRUCTIONS;
				continue;
			}
			else
				length = pFlfCmd->flen;
			

		}while(seqno < fgmts);
	}

done:
        if(fd.bf_insns) free(fd.bf_insns);
	if(pd) pcap_close(pd);
        return CLI_OK;

usage:
	print_all_gemac_ports(buf, 128);
	cmm_print(DEBUG_ERROR, "Usage: pktcapture filter <%s> <string>\n", buf);
	return CLI_OK;

reset_flf:
	cmm_print(DEBUG_ERROR, "Resetting filter");
	/* cleanup structures got from library */
        if(fd.bf_insns) free(fd.bf_insns);
	if(pd) pcap_close(pd);

	/* reset length */
	pFlfCmd->ifindex = port_id;
	pFlfCmd->flen    = 0;

	if (cmm_send(daemon_handle, &cmd, 0) != 0) {
		cmm_print(DEBUG_ERROR,"Error sending message to CMM, error = `%s'\n", strerror(errno));
		return -1;
	}
	if (cmm_recv(daemon_handle, &res, 0) < 0) {
		cmm_print(DEBUG_ERROR,"Error receiving message from CMM, error = `%s'\n", strerror(errno));
		return -1;
	}
	if (res.rc != FPP_ERR_OK) {
		cmm_print(DEBUG_ERROR,"Error from CMM, error = `%d'\n", res.rc);
		return -1;
	}
        return CLI_OK;
}

/* 
 * The purpose of this function is to ensure the filter is compatible with our 
 * version of BPF interpretor in FPP.
 * As libpcap version changes further, with changes in the filter corresponding changes 
 * will also have to be made in fpp. 
 */

int Check_BPFfilter(struct bpf_insn *filter, int flen)
{
        struct bpf_insn *ftest;
        int pc;

        if (flen == 0 || flen > (3*MAX_FLF_INSTRUCTIONS))
                return -EINVAL;

        /* check the filter code now */
        for (pc = 0; pc < flen; pc++) {
                ftest = &filter[pc];

                /* Only allow valid instructions */
                switch (ftest->code) {
                case BPF_ALU|BPF_ADD|BPF_K:
                case BPF_ALU|BPF_ADD|BPF_X:
                case BPF_ALU|BPF_SUB|BPF_K:
                case BPF_ALU|BPF_SUB|BPF_X:
                case BPF_ALU|BPF_MUL|BPF_K:
                case BPF_ALU|BPF_MUL|BPF_X:
                case BPF_ALU|BPF_DIV|BPF_X:
                case BPF_ALU|BPF_AND|BPF_K:
                case BPF_ALU|BPF_AND|BPF_X:
                case BPF_ALU|BPF_OR|BPF_K:
                case BPF_ALU|BPF_OR|BPF_X:
                case BPF_ALU|BPF_LSH|BPF_K:
                case BPF_ALU|BPF_LSH|BPF_X:
                case BPF_ALU|BPF_RSH|BPF_K:
                case BPF_ALU|BPF_RSH|BPF_X:
                case BPF_ALU|BPF_NEG:
                case BPF_LD|BPF_W|BPF_ABS:
                case BPF_LD|BPF_H|BPF_ABS:
                case BPF_LD|BPF_B|BPF_ABS:
                case BPF_LD|BPF_W|BPF_LEN:
                case BPF_LD|BPF_W|BPF_IND:
                case BPF_LD|BPF_H|BPF_IND:
                case BPF_LD|BPF_B|BPF_IND:
                case BPF_LD|BPF_IMM:
                case BPF_LDX|BPF_W|BPF_LEN:
                case BPF_LDX|BPF_B|BPF_MSH:
                case BPF_LDX|BPF_IMM:
                case BPF_MISC|BPF_TAX:
                case BPF_MISC|BPF_TXA:
                case BPF_RET|BPF_K:
                case BPF_RET|BPF_A:
                        break;

                /* Some instructions need special checks */

                case BPF_ALU|BPF_DIV|BPF_K:
                        /* check for division by zero */
                        if (ftest->k == 0)
                                return -EINVAL;
                        break;

                case BPF_LD|BPF_MEM:
                case BPF_LDX|BPF_MEM:
                case BPF_ST:
                case BPF_STX:
                        /* check for invalid memory addresses */
                        if (ftest->k >= BPF_MEMWORDS)
                                return -EINVAL;
                        break;

                case BPF_JMP|BPF_JA:
	                /*
 	                 * Note, the large ftest->k might cause loops.
	                 * Compare this with conditional jumps below,
                         * where offsets are limited. --ANK (981016)
                         */
                        if (ftest->k >= (unsigned)(flen-pc-1))
                                return -EINVAL;
                        break;

                case BPF_JMP|BPF_JEQ|BPF_K:
                case BPF_JMP|BPF_JEQ|BPF_X:
                case BPF_JMP|BPF_JGE|BPF_K:
                case BPF_JMP|BPF_JGE|BPF_X:
                case BPF_JMP|BPF_JGT|BPF_K:
                case BPF_JMP|BPF_JGT|BPF_X:
                case BPF_JMP|BPF_JSET|BPF_K:
                case BPF_JMP|BPF_JSET|BPF_X:
                        /* for conditionals both must be safe */
                        if (pc + ftest->jt + 1 >= flen ||
                            pc + ftest->jf + 1 >= flen)
                                return -EINVAL;
                        break;

                default:
                        return -EINVAL;
                }
        }

        return (BPF_CLASS(filter[flen - 1].code) == BPF_RET) ? 0 : -EINVAL;
}


int PktCapQueryProcess(struct cli_def *cli, daemon_handle_t daemon_handle) 
{
	/* Query fpp for the details */
       	char rcvBuffer[256];
	fpp_pktcap_query_cmd_t *pktcap_cmd; 
	int ii;

        pktcap_cmd      = (fpp_pktcap_query_cmd_t*)&rcvBuffer;
	

	if ((cmmSendToDaemon(daemon_handle, FPP_CMD_PKTCAP_QUERY, pktcap_cmd, 
							0, pktcap_cmd)) < sizeof(fpp_pktcap_query_cmd_t))
	{
                cmm_print(DEBUG_ERROR,"Error sending message to CMM, error = `%s'\n", strerror(errno));
                return -1;
        }

	for (ii = 0; ii < GEM_PORTS; ii++)
	{
		cli_print(cli, "slice  <%s> %d \n", port_table[ii].logical_name, pktcap_cmd[port_table[ii].port_id].slice);
	}

	for (ii = 0; ii < GEM_PORTS; ii++)
	{
		cli_print(cli, "status <%s> %d \n", port_table[ii].logical_name, pktcap_cmd[port_table[ii].port_id].status);
	}

        return CLI_OK;
}