模拟网络流量特征的自动提取(第一次大致算法框架)

  LGhher

#include<iostream>
#include<map>
#include<cstdlib>

#define sfn 5 //fn为初始网流的数量
#define pn 1 // pn为一个网流中网包的数量
#define n  2 //n为一个网包中载荷信息的数量

int fn=sfn;
//因为pn和n不是动态的所以不用定义初始值
using namespace std;
struct flow {  //flow即为网流
    int  packet[pn][n];//网流矩阵
};
struct location{     //location为可以作为特征值的位置
     int x,y;
};
flow *stmp=(flow *)malloc(sizeof(flow)*fn);
map<int, int>M[pn][n]; //pn，n可以看为位置信息

//该map用于计算在每一个位置下出现的各个字符的数量

void input() {

    stmp[0].packet[0][0] = 3;
    stmp[0].packet[0][1] = 7;
    stmp[1].packet[0][0] = 3;
    stmp[1].packet[0][1] = 7;
    stmp[2].packet[0][0] = 3;
    stmp[2].packet[0][1] = 7;
    stmp[3].packet[0][0] = 4;
    stmp[3].packet[0][1] = 8;
    stmp[4].packet[0][0] = 3;
    stmp[4].packet[0][1] = 10;

}
int maxn = 0, x, y, val; //x,y,val分别最横坐标，纵坐标以及频率最高的值
void frequency(flow *tmp,int i, int j, int k) {

    int num = tmp[k].packet[i][j];
    if(M[i][j].count(num)) //判断num这个特征有没有在坐标（i，j）这个位置出现过
        M[i][j][num]++;
    else
        M[i][j][num] = 1;
    if(M[i][j][num] > maxn) {
        x = i;
        y = j;
        maxn = M[i][j][num];
        val = tmp[k].packet[i][j];
    }

}
void cluster(flow *tmp,int fn) {

  maxn=0;
    for(int i = 0; i < pn; i++)
        for(int j = 0; j < n; j++)
            M[i][j].clear();

    for(int i = 0; i < pn; i++)
        for(int j = 0; j < n; j++)
            for(int k = 0; k < fn; k++)
                if(tmp[k].packet[i][j]>=256)
                   continue;
                else
                frequency(tmp,i, j, k);
    if(double(maxn) / fn > 0.5) { //val就可以作为网流的特征值,在第一次聚类的时候a即为最小支持度也为最小置信度设为0.5
        cout << double(maxn) / fn << endl;
        cout << x << " " << y << endl;
        cout << maxn << " " << val << endl;
        int max=maxn;
        //假如maxn和fn-maxn都满足继续分层聚类的条件，动态分配maxn个数组和fn-maxn个数组用于分层聚类
    /*
    for(int k=0;k<fn;k++)
     if(tmp[k].packet[x][y]==val)
     将第k个网流赋给maxn大小的数组中其中一项
     else
     将第k个网流赋给fn-maxn大小的数组其中一项

     然后继续将这个两个网流聚类
     */
     //atmp为下方的网流，btmp为有右方的网络
    flow *atmp=(flow *)malloc(sizeof(flow)*max);
    flow *btmp=(flow *)malloc(sizeof(flow)*(fn-max));
    int i1=0,j1=0;
   for(int k=0;k<fn;k++)
     if(tmp[k].packet[x][y]==val)
         atmp[i1++]=tmp[k];
     else
         btmp[j1++]=tmp[k];

         free(tmp);

   for(int k=0;k<max;k++)//x，y这个位置已经为特征值，+256为了下次不再计算此位置
      atmp[k].packet[x][y]+=256;
   /*  for(int i=0;i<maxn;i++)
    cout<<atmp[i].packet[0][0]<<" "<<atmp[i].packet[0][1]<<endl;
    */
     //cluster atmp的话 出来的特征就是&
    cluster(atmp,max);
     //if btmp也满足条件
    //cluster btmp的话 出来的特征就是|
     cluster(btmp,fn-max);


        }
    }
int main() {

     input();

    cluster(stmp,fn);

    return 0;
}