模拟网络流量特征的自动提取(第二次更新）

#include<iostream>
#include<map>
#include<cstdlib>
#include<fstream>
#include<string>
//#define sfn 5 //fn为初始网流的数量
#define pn 1 // pn为一个网流中网包的数量
#define n  40 //n为一个网包中载荷信息的数量

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

//该map用于计算在每一个位置下出现的各个字符的数量
void init(int fum) {
    string t;
    string add;
    string res;
    int count = 0;
    ifstream in("11.txt");
    ofstream out("sad.txt");
    if(!in)
        cout << "error" << endl;
    else {
        int i;
        for(i = 0; i < fum;) {
            while(t.size()) {
                add += t;
                getline(in, t, '\n');

            }
            if(add.size() >=3 * n) {
                res = "";
                i++;
                for(int j = 0; j < n * 1.5; j++)
                    res += add[j];
                int size = add.size();
                for(int k = size - n * 1.5; k < size; k++)
                    res += add[k];

                out << res << endl;
                out << endl;

            }
            add = "";

            while(!t.size())
                getline(in, t, '\n');


        }

    }
    out.close();
    in.close();

}
int getRow() {

    string t;
    int count = 0;
    ifstream in("sad.txt");
    if(!in)
        cout << "error" << endl;
    else
        while(getline(in, t, '\n'))
            if(t.size() > 0) {
                // cout << t.size() << endl;;
                // cout<<t<<endl;
                count++;
            }
    in.close();
    return count;


}
void input() {
    sfn = fn = getRow();
    //cout << fn << endl;
    ifstream in("sad.txt");
    if(!in) cout << "error" << endl;
    stmp = (flow *)malloc(sizeof(flow) * fn);
    for(int i = 0; i < fn; i++)
        for(int j = 0; j < n; j++)
            in >> hex >> stmp[i].packet[0][j];
    in.close();
}
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.7 && double(maxn) / sfn >= 0.8) { //val就可以作为网流的特征值,在第一次聚类的时候a即为最小支持度也为最小置信度设为0.5
        cout << dec << x << " " << y << endl;
        cout << maxn << endl;
        cout << hex << 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<max;i++)
         {

           for(int j=0;j<n;j++)
            cout<<hex<<atmp[i].packet[0][j]<<' ';
            cout<<endl;

         }*/
        //cluster atmp的话 出来的特征就是&
        cluster(atmp, max);
        //if btmp也满足条件
        //cluster btmp的话 出来的特征就是|
        //cluster(btmp,fn-max);


    }
}
int main() {
    init(50);  //init里面的参数为网流的个数，将原始数据处理
    input();  //从sad里面读取数据
    /* for(int i=0;i<fn;i++)
     {

        for(int j=0;j<n;j++)
          cout<<hex<<stmp[i].packet[0][j]<<' ';
          cout<<endl;
     }
     */
    cluster(stmp, fn);

    return 0;
}

LGhher