/******************************************************************************
description : sample application
author : dawning
date : 2008.09.30
******************************************************************************/
/*Dawning Information Industry(BeiJing) Corp. Ltd. 1995~*.  All Rights Reserved.*/

#include <string.h>  
#include <stdlib.h>
#include <stdio.h>  
#include <pthread.h>
#include <signal.h>
#include <time.h>
#include <sys/types.h>
#include <netinet/ip.h>

#include "libpag.h"


#define USAG_MSG "\n *** Usage *** : %s [copynum]\n"

#define THREAD_NUM 8
#define SEND_LEN 300 
int COPY_PKT_TIME=0;
int sids[THREAD_NUM];

unsigned char sendpkt[4000] = 
{
0x45,0x00,0x00,0x92,0xc7,0x6b,0x00,0x00,0x00,0x00,0x00,0x00,0xcb,0xd0,0x25,0x63,0xc0,0xa8,0x01,0xbb, //ip head
0x00,0x50,0x07,0xbb,0x78,0x28,0x73,0x3e,0x43,0x23,0x6a,0x7c,0x70,0x12,0x16,0x58,0x76,0xd4,0x00,0x00,//tcp head
0x02,0x04,0x05,0x64,0x01,0x01,0x04,0x02
};

ulong pkts[THREAD_NUM][16];
ulong bytes[THREAD_NUM][16];
ulong old_pkts[THREAD_NUM];
ulong old_bytes[THREAD_NUM];
ulong all_pkts, all_bytes;

int main_loop_flag = 1;
int thread_loop_flag = 1;

char dist[8][2000];

void print_speed_thread(void *ptr)
{
    int i;
    for(i=0; i<THREAD_NUM; i++)
    {
        old_pkts[i] = 0;
        old_bytes[i] = 0;
    }
    
    while(thread_loop_flag)
    {
        sleep(1); 
        printf("\nCurrent speed----- ");
        printf("\n");        
        for(i=0; i<THREAD_NUM; i++) 
        {
            printf("\t Thread[%d]:\t %8lu pps, %8lu M bps\n", i, pkts[i][0] - old_pkts[i], (bytes[i][0] - old_bytes[i]) >> 17);
            old_pkts[i] = pkts[i][0];
            old_bytes[i] = bytes[i][0];
        }

    }
}
//copy pkt
inline void process_pkt(int sid, void *pkt)
{
    int i, j, len;
    char pkttmp[2000];
    unsigned char *p8,*psend;
 	struct iphdr* iph;     
	//printf("process pkt at %p\n",pkt);
    pkts[sid][0]++;
    p8 = (unsigned char*)(pkt);
    //p8+=14;
    len=0;
    iph=(struct iphdr*)p8; 
    len = ntohs((unsigned short)iph->tot_len);
	//printf("len:%d\n",len);
	/*
	printf("len:%d\n",len);
	for(i=0;i<len;i++)
		printf("0x%x ",p8[i]);
	printf("\n");
	*/
//for 1.0 or older revison
//    len = *(__u16 *)p8 &0xffff;

//for tag 1.01
//    len = *(__u16 *)p8 &0xfff;

//for tag 1.1
    //len = p8[1] + ((__u16)(p8[2] & 0x7)<<8);
    bytes[sid][0] += len;
    //copy pkt data
    for(i=0; i<COPY_PKT_TIME; i++) 
          memcpy(pkttmp,p8,len);
	
}

unsigned long next = 1;
void my_srand(unsigned long seed)
{
	next = seed;
}

unsigned my_rand(void)
{
	next = next * 1103515245 + 12345;
        return((unsigned)(next/65536) % 32768);
}

void random_ip(char *pkt)
{
	pkt[0] = my_rand() & 0xFF;
	pkt[1] = my_rand() & 0xFF;
	pkt[2] = my_rand() & 0xFF;
	pkt[3] = my_rand() & 0xFF;
	pkt[4] = my_rand() & 0xFF;
	pkt[5] = my_rand() & 0xFF;
	pkt[6] = my_rand() & 0xFF;
	pkt[7] = my_rand() & 0xFF;
}

//threads dealing with packets 
void thread(void *ptr)
{

    int sid;
    void *pkt;
    
    int i;
    void* psend;
    int sendlen=SEND_LEN;
    int pkt_type;

    sid = *((int *)ptr);
        
    //process pkts    
    while(thread_loop_flag)
    {
	    do
	    {
		    psend = pag_getsendbuf(sid);
		    //printf("sizeofpsend=%d psend=%p\n",sizeof(psend),psend);
		    if (psend == NULL) 
		    {
			    usleep(500);
		    }
	    }
	    while(psend == NULL);
	    //usleep(1);
	    //printf("sizeofpsend=%d psend=%p\n",sizeof(psend),psend);
	    //sleep(1);
	    memcpy(psend, sendpkt, sendlen);
//		random_ip(psend + 26);

	    //pkt_type = pkt_type ^ 1;
	    pag_send(0, sid, sendlen);
	    //send_count++;
    	pkts[sid][0]++;
    		bytes[sid][0] += sendlen;

    }
}

//signal response function
void stop_loop(int sig)
{
    main_loop_flag = 0;
}

int main(int argc, char *argv[])
{
    struct timeval ts, te;
    double sec; 
    ulong all_pkts, all_bytes;
    sigset_t set;
    pthread_t tids[THREAD_NUM],tx_tids[THREAD_NUM];
    pthread_t tid,tx_tid;
    int i;
    
    if(argc >2)
    {
        printf(USAG_MSG, argv[0]);
        return -1;
    }
    if(argc ==2)
        COPY_PKT_TIME=atoi(argv[1]);
    //open a device 
    //check returned device id


    if(pag_open() < 0)
    {
        printf("### Error : can not open device! ###\n");
        return -1;
    }
    
    //create processing threads 
	
	my_srand(time(NULL));
    for(i=0; i<THREAD_NUM; i++)
    {
        sids[i] = i;
        if(pthread_create(&tids[i], NULL, (void *)thread, (void *)&sids[i]) != 0)   
        {
            printf("### Error: Can not creat threads!\n");    
            pag_close();
            return -1;
        }
    }   
    //create printing thread
   // if(argc == 1)
    {
        if(pthread_create(&tid, NULL, (void *)print_speed_thread, NULL) != 0)   
        {
            printf("### Error: Can not creat threads!\n");    
            pag_close();
            return -1;
        }
    }

    
    //wait for stop signal    
    sigemptyset(&set);
    sigprocmask(SIG_SETMASK, &set, NULL);
    signal(SIGINT, stop_loop);
    
    //loop recieving pkts
    gettimeofday(&ts, NULL);      
    while(main_loop_flag) usleep(10);      
    gettimeofday(&te, NULL);  
    
    //stop threads
    thread_loop_flag = 0;
    usleep(200);
    
      
    //close device
    pag_close();    
    

    sec = (float)(te.tv_sec - ts.tv_sec) + ((float)(te.tv_usec - ts.tv_usec)) / 1000000.f;   
    printf("\n");        
    printf("Pkts recieved in threads: \n");
    all_pkts = 0;
    all_bytes = 0;
    for(i=0; i<THREAD_NUM; i++) 
    {
        printf("\t Thread[%d]:\t <%8lu> pkts, <%8lu M> bytes\n", i, pkts[i][0], bytes[i][0] >> 20);
        all_pkts += pkts[i][0];
        all_bytes += bytes[i][0];
    }
    printf("Total : %lu pkts,  %lu bytes\n", all_pkts, all_bytes);
    printf("Speed : < %lu > pps, < %lu M > bps\n", (ulong)(all_pkts / sec), (ulong)((all_bytes >> 17) / sec));
    printf("\n");        

    return 0;
}