#include <pcap.h>
#include <net/bpf.h>
#include <time.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>

#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <netinet/udp.h>
#include <netinet/if_ether.h>
#include <netinet/in.h>

#include <net/if.h>
#include <net/ethernet.h>
#include <arpa/inet.h>

#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/types.h>


#include <string>
#include <set>
#include <ncurses.h>

using namespace std;


#define PROMISCOUS        1
#define NONPROMISCUOUS    0

#define PORT_NUM        65536

// 뮤텍스 잠금용 뮤텍스 잠금 변수
pthread_mutex_t  m_lock = PTHREAD_MUTEX_INITIALIZER; 

// 포트별 카운트와 사이즈를 저장하기 위한 구조체
typedef struct _port_count
{
    int count;
    int size;
} port_count;

// 0-64435 범위의 모든 IP 패킷에 대한 카운팅 
// 정보를 저장한다. 
static port_count gport_count[PORT_NUM];

// IP및 TCP헤더 구조체
struct ip        *iph;
struct tcphdr    *tcph;

static WINDOW *infoview;

// 통계검사를 할때 PORT_NUM만큼 루프를 도는건 
// 자원낭비다. 대부분의 PORT의 경우 
// 카운팅이 0일 것이기 때문이다. 
// 그래서 카운팅된 PORT만 별도로 저장하는 자료구조를 
// 준비해서 
// 통계시 이 자료구조에 등록된 포트에 대해서만 
// 통계를 내도록 한다. 
set<int> port_set; 

// 현재 IP를 얻어온다.
ulong GetIP(char *);

// 사용자가 Ctrl+C를 눌렀을 때 
// 실행되는 시그널 핸들러로 프로그램을 종료한다.
void sigint(int signo)
{
    endwin();    
    printf("Exit\n");
    exit(0);
}

// 포트 카운트 통계정보를 얻어와서 화면에 
// 출력한다.
void *staticsview(void *data)
{
    int prev_count = 0;
    int prev_size  = 0;
    int count = 0;
    int size  = 0;
    int loop_num = 1;
    time_t current_time = time((time_t *)NULL);
    set<int>::iterator si;
    while(1)
    {
        // 10초 단위로 통계를 낸다.
        sleep(10);
        
        pthread_mutex_lock(&m_lock);
        si = port_set.begin();
        count = 0;
        size  = 0;
        // 만약 등록된 포트가 200이상이라면 
        // 포트 스캐닝 공격이 있었다고 간주하고 
        // WARN을 발생한다. 
        if (port_set.size() > 200)
        {
            mvprintw(19, 1,"WARN  : PORT SCANNING %s %d", 
                ctime(&current_time), port_set.size());
        }

        // 포트 통계를 낸다.
        // 포트 카운트가 5이하인 포트의 정보는 삭제한다. 
        while(si != port_set.end())
        {
            count += gport_count[*si].count;
            size  += gport_count[*si].size; 
            if (gport_count[*si].count < 5) 
            {
                port_set.erase(si);
            }
            *si++;
        }
        pthread_mutex_unlock(&m_lock);
        // 포트 통계 정보를 화면에 출력한다. 
        mvprintw(20, 1,"TOTAL : %11d  %d", count, size);
        mvprintw(21, 1,"AVG   : %11d  %d", count/loop_num, size/loop_num);
        mvprintw(22, 1,"DIFF  : %11d  %d", abs(count - prev_count), 
                                        abs(size - prev_size));
        prev_count = count;
        prev_size  = size;

        loop_num++;
    }
}

// 화면 초기화를 한다. 
// 뒷배경은 파란색, 글자의 색은 하얀색으로 한다.
void init_scr()
{
    initscr();
    start_color();
    init_pair(1, COLOR_WHITE, COLOR_BLUE);
    curs_set(2);
    noecho();
    keypad(stdscr, TRUE);
}

int main(int argc, char **argv)
{
    char *dev;
    int  n;

    bpf_u_int32  netp;
    bpf_u_int32  maskp;    

    char errbuf[PCAP_ERRBUF_SIZE];
    int ret;
    struct pcap_pkthdr hdr;
    const u_char *packet;
    struct ether_header *ep;    
    struct ip *iph;
    struct sockaddr_in *sin;

    ulong myip; 
    unsigned short ether_type;
    pthread_t thread_i;

    // SIGINT에 대한 시그널 핸들러를 등록한다.    
    // 사용자가 Ctrl+C를 이용해서 SIGINT를 발생시키면 
    // endwin()을 호출하고 프로그램을 종료한다.  
    if(signal(SIGINT, sigint) == SIG_ERR)
    {
        perror("signal setting error : ");
        exit(0);
    } 

    // 화면을 초기화 시킨다.
    init_scr();
    bkgd(COLOR_PAIR(1));
    infoview = subwin(stdscr, 1, 80, 0, 0);

    // 통계 쓰레드 생성
    if ((n = pthread_create(&thread_i, NULL, staticsview, NULL)) != 0)
    {
        perror("thread create error ");
        exit(0);    
    }

    pcap_t *pcd;
    dev = pcap_lookupdev(errbuf);
    if (dev == NULL)
    {
        printf("%s\n", errbuf);
        exit(1);
    }
    myip = GetIP(dev);
    sin->sin_addr.s_addr =  myip;

    move(1,1);
    printw("DEV IS %s : %s", dev, inet_ntoa(sin->sin_addr));
    ret = pcap_lookupnet(dev, &netp, &maskp, errbuf);
    if (ret == -1) 
    {
        printf("%s\n", errbuf);
        exit(1);
    }
    refresh();

    pcd = pcap_open_live(dev, BUFSIZ, NONPROMISCUOUS, -1, errbuf);
    if (pcd == NULL)
    {
        printf("%s\n", errbuf);
        exit(1);
    }

    memset(gport_count, 0x00, PORT_NUM*sizeof(port_count));
    int i = 0;
    int k;
    set<int>::iterator si;

    for (;packet=(const unsigned char *)pcap_next(pcd, &hdr);)
    {
        ep = (struct ether_header *)packet;
        packet += sizeof(struct ether_header);    
        ether_type = ntohs(ep->ether_type); 
        // 패킷이 IP기반일 경우 카운팅을 실시한다.
        if(ether_type == ETHERTYPE_IP)
        {
            iph = (struct ip *)packet;
            if (myip == iph->ip_dst.s_addr)    
            {
                tcph = (struct tcphdr *)(packet + iph->ip_hl * 4);
                gport_count[ntohs(tcph->dest)].count++;
                gport_count[ntohs(tcph->dest)].size += ntohs(iph->ip_len);
                port_set.insert(ntohs(tcph->dest));

                pthread_mutex_lock(&m_lock);
                si = port_set.begin();
                k = 0;
                // 카운팅된 정보는 실시간으로 화면에 출력한다.
                while (si != port_set.end())        
                {
                    if (gport_count[*si].count > 5)
                    {
                        mvprintw(k+2, 1,"%6d : %11d %11d", *si, 
                            gport_count[*si].count,
                            gport_count[*si].size); 
                        k++;
                    }
                    *si++;
                }
                pthread_mutex_unlock(&m_lock);
                refresh();
            }
            i++;
        }
    }
    endwin();
}


ulong GetIP(char *device)
{
    struct ifreq ifr;
    struct sockaddr_in *sin;
    int fd ;

    memset((void *)&ifr, 0x00, sizeof(ifr));
    fd = socket(AF_INET, SOCK_STREAM, 0);
    if(fd < 0)
    {
        perror("socket ");
        exit(0);
    }
    strncpy(ifr.ifr_name, device, 12);

    ioctl(fd, SIOCGIFADDR, (char *)&ifr);
    sin = (struct sockaddr_in *)&ifr.ifr_addr;

    close(fd);
    return (ulong)sin->sin_addr.s_addr;
}
		

# g++ -o jpsd jpsd.cc -lpthread -lpcap -lpthread