Browse Source

ajout des fichiers Shell, C++, flex (->C) au projet.

Citnop 3 years ago
parent
commit
cad878e8b2

+ 26 - 0
Makefile

@@ -0,0 +1,26 @@
1
+# aliases
2
+ECHO=/bin/echo
3
+
4
+# targets
5
+help: h
6
+all: preparser
7
+
8
+
9
+# rules
10
+preparser: cleanram 
11
+	#make -C ./preparser/
12
+	cd preparser && make all
13
+	: "Done."
14
+
15
+cleanram: cpp
16
+	#make -C ./cleanRAM/
17
+	cd cleanRAM && make all
18
+
19
+cpp: h
20
+	#make -C ./cpp/
21
+	cd cpp && make 
22
+
23
+# 
24
+h:
25
+	: "'make all' pour tout construire"
26
+

+ 254 - 0
chef/chef_d_orchestre.sh

@@ -0,0 +1,254 @@
1
+#!/bin/bash
2
+RS=/usr/bin/rsync # better copy
3
+res=0 # cmd ok/nok ?
4
+sout () # info
5
+{
6
+	/bin/echo -n -e "\e[33m"
7
+	/bin/echo ${1}
8
+	/bin/echo -n -e "\e[0m"
9
+}
10
+sok () # ok
11
+{
12
+	/bin/echo -n -e "\e[32m"
13
+	/bin/echo ${1}
14
+	/bin/echo -n -e "\e[0m"
15
+}
16
+serr () # nok
17
+{
18
+	/bin/echo -n -e "\e[31m"
19
+	/bin/echo ${1}
20
+	/bin/echo -n -e "\e[0m"
21
+}
22
+sunk () # unk
23
+{
24
+	/bin/echo -n -e "\e[34m"
25
+	/bin/echo ${1}
26
+	/bin/echo -n -e "\e[0m"
27
+}
28
+#-------------------------------------------------------------------------------
29
+
30
+
31
+# Copy
32
+res=0
33
+sout "Copy..."
34
+#${RS} -Phavuz /home/sewan/archive/*.zip /home/administrateur/prod/sandbox/
35
+sok "Copy ok."
36
+#-------------------------------------------------------------------------------
37
+
38
+
39
+# Mov
40
+res=0
41
+sout "Mov..."
42
+for file in /home/administrateur/prod/sandbox/*.zip
43
+do
44
+	echo "${file}"
45
+	f=`echo ${file} | cut -d'.' -f1 | cut -d'/' -f6`
46
+	dir=`echo ${f} | cut -d'-' -f2`
47
+	echo "${f}" "${dir}"
48
+	mkdir -p /home/administrateur/prod/sandbox/${dir} 
49
+	mv ${file} /home/administrateur/prod/sandbox/${dir}/${dir}.zip 2> /dev/null
50
+	res=$(($res + $?))
51
+done
52
+if [ "$res" = "0" ]
53
+then
54
+	sok "Mov ok."
55
+else
56
+	serr "Mov NOK: $res"
57
+fi
58
+#-------------------------------------------------------------------------------
59
+
60
+
61
+# Unzip
62
+res=0
63
+sout "Unzip..."
64
+for i in `cat /home/administrateur/prod/noSite.csv`
65
+do
66
+	if [ -d "/home/administrateur/prod/sandbox/site${i}" ]
67
+	then
68
+		#sok "${i}"
69
+		unzip -qq /home/administrateur/prod/sandbox/site${i}/*.zip -d /home/administrateur/prod/sandbox/site${i}/ 2> /dev/null
70
+		res=$(($res + $?))
71
+		rm -f /home/administrateur/prod/sandbox/site${i}/*.zip
72
+		#res=$(($res + $?)) # on ne veut pas les erreurs de rm
73
+	else
74
+		:
75
+		#sunk "${i}"
76
+	fi
77
+done
78
+if [ "$res" = "0" ] 
79
+then
80
+	sok "Unzip ok."
81
+else
82
+	serr "Unzip NOK: $res"
83
+fi
84
+#-------------------------------------------------------------------------------
85
+
86
+
87
+# Bin2ASCII
88
+res=0
89
+sout "Bin2ASCII..."
90
+for i in `cat /home/administrateur/prod/noSite.csv`
91
+do
92
+	if [ -d "/home/administrateur/prod/sandbox/site${i}" ]
93
+	then
94
+		#sok "${i}"
95
+		/home/administrateur/prod/scripts/bash/nfdumpall.sh /home/administrateur/prod/sandbox/site${i}/
96
+		res=$(($res + $?))
97
+		
98
+	else
99
+		:
100
+		#sunk "${i}"
101
+	fi	
102
+done
103
+if [ "$res" = "0" ]
104
+then
105
+	sok "Bin2ASCII ok."
106
+else
107
+	serr "Bin2ASCII NOK: $res"
108
+fi
109
+#-------------------------------------------------------------------------------
110
+
111
+
112
+# Concaténation
113
+res=0
114
+sout "Ccat"
115
+for i in `cat /home/administrateur/prod/noSite.csv`
116
+do
117
+	if [ -d "/home/administrateur/prod/sandbox/site${i}" ]
118
+	then
119
+		DATE=`/bin/ls /home/administrateur/prod/sandbox/site01/ | grep ascii | head -1 | cut -d'.' -f2 | cut -c1-8` 
120
+		#sok "${i}"
121
+		for heure in 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 
122
+		do 
123
+			for min in 00 15 30 45
124
+			do
125
+				cat /home/administrateur/prod/sandbox/site${i}/ascii.${DATE}-${heure}-${min} >> /home/administrateur/prod/sandbox/site${i}/site${i}.txt
126
+				res=$((res + $?))
127
+			done
128
+		done
129
+	else
130
+		:
131
+		#sunk "${i}"
132
+	fi
133
+done
134
+find /home/administrateur/prod/sandbox/ -name "ascii*" -delete
135
+if [ "$res" = "0" ]
136
+then
137
+	sok "Ccat ok."
138
+else
139
+	serr "Ccat NOK: $res"
140
+fi
141
+#-------------------------------------------------------------------------------
142
+
143
+
144
+# ASCII2csv
145
+res=0
146
+sout "ASCII2csv"
147
+for i in `cat /home/administrateur/prod/noSite.csv`
148
+do
149
+	if [ -d "/home/administrateur/prod/sandbox/site${i}" ]
150
+	then
151
+		#sok "${i}"
152
+		/home/administrateur/prod/preparser/acsvify.out < /home/administrateur/prod/sandbox/site${i}/site${i}.txt > /home/administrateur/prod/sandbox/site${i}/site${i}.csv 
153
+		res=$((res + $?))
154
+		rm -f /home/administrateur/prod/sandbox/site${i}/site${i}.txt
155
+	else
156
+		:
157
+		#sunk "${i}"
158
+	fi
159
+done
160
+if [ "$res" = "0" ]
161
+then
162
+	sok "ASCII2csv ok."
163
+else
164
+	serr "ASCII2csv NOK: $res"
165
+fi
166
+#-------------------------------------------------------------------------------
167
+
168
+
169
+# csv2res
170
+res=0
171
+sout "csv2res"
172
+for i in `cat /home/administrateur/prod/noSite.csv`
173
+do
174
+	if [ "${i}" = "01" ] 
175
+	then 
176
+		j=1
177
+	elif [ "{i}" = "02" ] 
178
+	then 
179
+		j=2
180
+	elif [ "{i}" = "03" ]
181
+	then
182
+		j=3
183
+	elif [ "{i}" = "04" ]
184
+	then
185
+		j=4
186
+	elif [ "{i}" = "05" ]
187
+	then
188
+		j=5
189
+	elif [ "{i}" = "06" ]
190
+	then
191
+		j=6
192
+	elif [ "{i}" = "07" ]
193
+	then
194
+		j=7
195
+	elif [ "{i}" = "08" ]
196
+	then
197
+		j=8
198
+	elif [ "{i}" = "09" ]
199
+	then
200
+		j=9
201
+	else
202
+		j=${i}
203
+	fi
204
+	if [ -d "/home/administrateur/prod/sandbox/site${i}" ] 
205
+	then
206
+		sok "${i}"
207
+		/home/administrateur/prod/parser/graphEchantTabl.out 4 "/home/administrateur/prod/sandbox/site${i}/site${i}.csv" ${j} "/home/administrateur/prod/sandbox/site${i}/res${i}.csv" 
208
+		res=$((res + $?))
209
+		rm -f /home/administrateur/prod/sandbox/site${i}/site${i}.csv
210
+	else
211
+		:
212
+		sunk "${i}"
213
+	fi
214
+done
215
+if [ "$res" = "0" ] 
216
+then
217
+	sok "csv2res ok."
218
+else
219
+	serr "csv2res NOK: $res"
220
+fi
221
+#-------------------------------------------------------------------------------
222
+
223
+
224
+# graphs
225
+res=0
226
+for i in `cat /home/administrateur/prod/noSite.csv`
227
+do
228
+	if [ -d "/home/administrateur/prod/sandbox/site${i}" ] 
229
+	then
230
+		sok "${i}"
231
+		cp -f /home/administrateur/prod/gnuplot/plotgnu.sh /tmp/
232
+		echo 'set title "'"site ${i}"'"' >> /tmp/plotgnu.sh
233
+		echo 'plot "/home/administrateur/prod/sandbox/site'"${i}/site${i}.csv"'" using 1 with boxes lc rgb "blueviolet"' >> /tmp/plotgnu.sh
234
+		/tmp/plotgnu.sh > /home/administrateur/prod/sandbox/site${i}/site${i}.png
235
+		res=$((res + $?))
236
+		#rm -f /tmp/plotgnu.sh
237
+		read attente
238
+	else
239
+		:
240
+		sunk "${i}"
241
+	fi
242
+done
243
+if [ "$res" = "0" ] 
244
+then
245
+	sok "graphs ok."
246
+else
247
+	serr "graphs NOK: $res"
248
+fi
249
+#-------------------------------------------------------------------------------
250
+
251
+#############
252
+sok "Done." #
253
+#############
254
+

+ 23 - 0
cleanRAM/Makefile

@@ -0,0 +1,23 @@
1
+# g++ -O3 -Wall -std=c++14 use2goRAM.cpp -pthread
2
+CC=/usr/bin/g++
3
+RM=/bin/rm
4
+CFLAGS=-Wall -O3 -Werror=conversion -Werror=uninitialized -std=c++14 
5
+LIB=-pthread
6
+
7
+# target
8
+help: h
9
+all: useRAM.out 
10
+
11
+# rules
12
+useRAM.out: useRAM.cpp
13
+	${CC} ${CFLAGS} useRAM.cpp -o useRAM.out ${LIB}
14
+
15
+# aide
16
+h:
17
+	: "make all pour compiler useRAM.out"
18
+	: "make clean pour nettoyer l'environnement"
19
+
20
+# nettoyer
21
+clean:
22
+	${RM} -f ./*.out
23
+

+ 113 - 0
cleanRAM/useRAM.cpp

@@ -0,0 +1,113 @@
1
+#include <iostream>
2
+#include <vector>
3
+#include <pthread.h>
4
+#include <sys/sysinfo.h> // struct sysinfo
5
+#include <thread> // std::thread::hardware_concurrency(); // C++11
6
+#include <semaphore.h> // sem_t, sem_init
7
+#include <error.h>
8
+#include <errno.h>
9
+#include <time.h> // struct timespec
10
+#include <string.h> // memcpy
11
+#include <sstream> // int --> string
12
+
13
+void* threadfunc(void*);
14
+pthread_mutex_t lockLs; // mutex for line++
15
+std::vector<bool> allocfinie;
16
+
17
+
18
+int main(int argc, char* argv[])
19
+{
20
+    int nbProc = std::thread::hardware_concurrency();
21
+    struct sysinfo si; sysinfo (&si); // taille RAM
22
+    long unsigned int allocasize = (si.totalram)/nbProc/2/sizeof(int); // allocation par thread
23
+    //std::cout << "alloc : " << allocasize << '\n';
24
+    for (int i=0;i<nbProc;i++) // [false, false, ..., false] n-fois, nproc
25
+    {
26
+        allocfinie.push_back(false);
27
+    }
28
+    if (int mutinit = pthread_mutex_init(&lockLs, NULL)) // init mutex
29
+    {
30
+        error(1, mutinit, "could not initialize mutex lockLs");
31
+    }
32
+    std::vector<pthread_t> lspth; // pool of threads
33
+    for (int i=0;i<nbProc;i++) // init pool of threads
34
+    {
35
+        pthread_t tmpth;
36
+	void* memAlloc = calloc(1, sizeof(int));
37
+	memAlloc = memcpy(memAlloc, (void*) &allocasize, (size_t) 4);
38
+	if (int rcpth = pthread_create(&tmpth, NULL, threadfunc, memAlloc)) // threads lancés ?
39
+	{
40
+	    std::string tmpmsg = "pthread_create : failed to create worker n°";
41
+	    std::stringstream ss; ss << i; tmpmsg += ss.str();
42
+	    error(1, rcpth, tmpmsg.c_str()); 
43
+	}
44
+	lspth.push_back(tmpth); // if ok : add thread to pool
45
+    }
46
+    for (unsigned int i=0;i<lspth.size();i++) // attente du pool de threads
47
+    {
48
+        if (int rcpth = pthread_join(lspth.at(i),NULL))
49
+        {
50
+            std::string msg = "pthread_join failed : ";
51
+            std::stringstream ss;  ss << i;  msg += ss.str(); // msg += str(n° process)
52
+            error(1, rcpth, msg.c_str()); // le thread worker-n pas arrêté // 1 <=> EXIT_FAILURE
53
+        }
54
+    }
55
+    return 0;
56
+}
57
+
58
+void* threadfunc(void* args)
59
+{
60
+    bool sigfree = false;
61
+    int taille = *(int*) args; // taille à allouer
62
+    std::vector<int> mvi; // vecteur d'int
63
+    //std::cout << "début : " << taille << '\n';
64
+    for (int i=0;i<taille;i++) // allocation
65
+    {
66
+        mvi.push_back(0);
67
+    }
68
+    //std::cin.ignore(); // attente imput user
69
+    //std::cout << "allocation finie" << '\n';
70
+    if (int lock = pthread_mutex_lock(&lockLs)) // prise mutex
71
+    {
72
+        error(1, lock, "failed to lock mutex");
73
+    }
74
+    //std::cout << "mutex pris" << '\n';
75
+    for (unsigned int i=0;i<allocfinie.size();i++) // shout fini
76
+    {
77
+        if (allocfinie.at(i) == false)
78
+	{
79
+	    allocfinie.at(i) = true;
80
+	    break;
81
+	}
82
+    }
83
+    //std::cout << "Prévenu tout le monde" << '\n';
84
+    if (int lock = pthread_mutex_unlock(&lockLs)) // relaxe mutex
85
+    {
86
+        error(1, lock, "failed to unlock mutex");
87
+    }
88
+    //std::cout << "Mutex relâché" << '\n';
89
+    struct timespec sleeptime; sleeptime.tv_sec = 0; sleeptime.tv_nsec = 1'000;
90
+    while (!sigfree) // tous les bool true
91
+    {
92
+        //std::cout << "dodo" << '\n';
93
+        nanosleep(&sleeptime, NULL);
94
+	for (unsigned int i=0;i<allocfinie.size();i++)
95
+	{
96
+	    if (allocfinie.at(i) == false)
97
+	    {
98
+	        break;
99
+	    }
100
+	    sigfree = true;
101
+	}
102
+    }
103
+    //std::cout << "fin attente \n";
104
+    for (int i=0;i<taille;i++) // free
105
+    {
106
+        mvi.pop_back();
107
+    }
108
+    pthread_exit(NULL);
109
+}
110
+
111
+
112
+
113
+

+ 151 - 0
cpp/Data.cpp

@@ -0,0 +1,151 @@
1
+#include "Data.hpp"
2
+
3
+
4
+////////////////////////////////////////////////////////////////////////////////////////////////////
5
+/**
6
+ * \brief 
7
+ * \param 
8
+ * \throws 
9
+ * \return 
10
+ */
11
+Data::Data()
12
+{
13
+	// initialisation du mutex protégeant le vecteur d'échantillonage
14
+	if(int mutinitcs = pthread_mutex_init(&(this->CSmutex), NULL)) // 
15
+	{
16
+		error(1, mutinitcs, "could not initialize mutex CSmutex"); // EXIT_FAILURE
17
+	}
18
+	for (unsigned int i=0;i<86400*ECH;i++)
19
+	{
20
+		this->centisecondes.push_back(0);
21
+	}
22
+}
23
+/**
24
+ * \brief 
25
+ * \param 
26
+ * \throws 
27
+ * \return 
28
+ */
29
+Data::~Data()
30
+{
31
+	
32
+}
33
+////////////////////////////////////////////////////////////////////////////////////////////////////
34
+/**
35
+ * \brief obtenir la centiseconde-ieme valeur du vecteur
36
+ * \param int temps : 0 --> 86400*ECH-1
37
+ * \throws out_of_range 
38
+ * \return int resultat (octets transmis) du vecteur
39
+ */
40
+int Data::getTrafficAt(int temps)
41
+{
42
+	return this->centisecondes.at(temps);
43
+}
44
+/**
45
+ * \brief convertir une string en int
46
+ * \param string chaine à convertir
47
+ * \throws invalid_argument
48
+ * \return int resultat de la conversion
49
+ */
50
+int Data::dureeString(std::string machaine)
51
+{
52
+	return std::stoi(machaine);
53
+}
54
+unsigned int Data::getTaille()
55
+{
56
+	return (unsigned int) this->centisecondes.size();
57
+}
58
+void Data::coutNotNull()
59
+{
60
+	for (unsigned int i=0;i<this->centisecondes.size();i++)
61
+	{
62
+		if (this->centisecondes.at(i) != 0)
63
+		{
64
+			std::cout << i << " : " << this->centisecondes.at(i) << ';';
65
+		}
66
+	}
67
+}
68
+////////////////////////////////////////////////////////////////////////////////////////////////////
69
+/**
70
+ * \brief obtenir la centiseconde-ieme valeur du vecteur
71
+ * \param int traffic, int temps : 0 --> 86400*ECH-1
72
+ * \throws out_of_range 
73
+ * \return bool si succès 
74
+ */
75
+bool Data::setTrafficAt(int traffic, int temps)
76
+{
77
+	this->centisecondes.at(temps) = traffic;
78
+	return true;
79
+}
80
+/**
81
+ * \brief 
82
+ * \param 
83
+ * \throws 
84
+ * \return 
85
+ */
86
+bool Data::add2traffic(int traffic, int temps)
87
+{
88
+	//std::cout << "valeur courante : " << this->centisecondes.at(temps) << " ; valeur en plus : " << traffic << '\n';
89
+	this->centisecondes.at(temps) += traffic;
90
+	return true;
91
+}
92
+/**
93
+ * \brief 
94
+ * \param 
95
+ * \throws 
96
+ * \return 
97
+ */
98
+bool Data::traiterPaquet(Packet* pq)
99
+{
100
+	int debit;
101
+	debit = pq->getTaille() / pq->getDuration(); // existe, car getDuration() >= 1;
102
+	for (int i=0;i<pq->getDuration();i++)
103
+	{
104
+		if (int lockCS = pthread_mutex_lock(&(this->CSmutex))) // lock error // assignation ! => (())
105
+		{
106
+			error(1, lockCS, "traiterPaquet : could not get lock properly"); // EXIT_FAILURE
107
+		}
108
+		this->add2traffic(debit, pq->getTimestamp());
109
+		if (int unlockCS = pthread_mutex_unlock(&(this->CSmutex))) // lock error // assignation ! (())
110
+		{
111
+			error(1, unlockCS, "traiterPaquet : could not release lock properly"); // EXIT_FAILURE
112
+		} // travail, rendre le mutex le plus vite possible => travail après la relaxe		
113
+	}
114
+	return true;
115
+}
116
+////////////////////////////////////////////////////////////////////////////////////////////////////
117
+/**
118
+ * \brief 
119
+ * \param 
120
+ * \throws 
121
+ * \return 
122
+ */
123
+std::string Data::toString()
124
+{
125
+	int somme = 0;
126
+	for (unsigned int i=0;i<this->centisecondes.size();i++)
127
+	{
128
+		somme += this->centisecondes.at(i);
129
+	}
130
+	std::stringstream ss; ss << somme;
131
+	std::cout << ss.str();
132
+	return ss.str();
133
+}
134
+/**
135
+ * \brief 
136
+ * \param 
137
+ * \throws 
138
+ * \return 
139
+ */
140
+void Data::writeout()
141
+{
142
+	std::ofstream outfile("/tmp/bargraph.csv", std::ios_base::out);
143
+	std::stringstream ss; 
144
+	for (unsigned int i=0;i<this->centisecondes.size();i++)
145
+	{
146
+		ss << this->centisecondes.at(i);
147
+		ss << '\n';
148
+	}
149
+	outfile << ss.str();
150
+	outfile.close();
151
+}

+ 52 - 0
cpp/Data.hpp

@@ -0,0 +1,52 @@
1
+#ifndef DATA_HPP
2
+#define DATA_HPP
3
+
4
+#include <iostream>
5
+#include <fstream> // ifstream
6
+#include <vector>
7
+#include <sstream>
8
+#include <string>
9
+#include <exception>
10
+#include <stdexcept>
11
+#include <error.h> // error
12
+#include <errno.h> // perror
13
+#include <algorithm> // std::max
14
+#include <pthread.h> // pthread_t, POSIX threads
15
+#include "Packet.hpp"
16
+
17
+#define ECH 100 // echantillonage. mettre entre 1 et 100. 1 <=> échantillonné par s. 100 <=> par 0.01s
18
+
19
+
20
+/**
21
+ * \brief classe Data. stocke 24h <=> 86'400s <=> 8'640'000cs de données échantillonées.
22
+ * Constructeur Data(),  
23
+ * \param None
24
+ * \return None
25
+ * \throws None
26
+ */
27
+class Data
28
+{
29
+	private:
30
+		// Attributes
31
+		pthread_mutex_t CSmutex;
32
+		std::vector<int> centisecondes;
33
+	
34
+	public:
35
+		// Constructeurs
36
+		Data();
37
+		~Data();
38
+		// Getters
39
+		int getTrafficAt(int);
40
+		void coutNotNull();
41
+		unsigned int getTaille();
42
+		// Setters
43
+		bool setTrafficAt(int traffic, int temps);
44
+		bool add2traffic(int traffic, int temps);
45
+		bool traiterPaquet(Packet*);
46
+		int dureeString(std::string);
47
+		// toString
48
+		std::string toString();
49
+		void writeout();
50
+		
51
+};
52
+#endif

+ 146 - 0
cpp/Packet.cpp

@@ -0,0 +1,146 @@
1
+#include "Packet.hpp"
2
+
3
+
4
+////////////////////////////////////////////////////////////////////////////////////////////////////
5
+/**
6
+ * \brief 
7
+ * \param 
8
+ * \throws 
9
+ * \return 
10
+ */
11
+Packet::Packet(int timestamp, int duration, 
12
+				std::string ipsrc, std::string ipdst, 
13
+				uint16_t srcport, uint16_t dstport, 
14
+				int taille)
15
+{
16
+	this->timestamp = timestamp;
17
+	if (duration <= 1)
18
+	{
19
+		this->duration = 1;
20
+	}
21
+	else
22
+	{
23
+		this->duration = duration;
24
+	}
25
+	this->ipsrc = ipsrc;
26
+	this->ipdst = ipdst;
27
+	this->srcport = srcport;
28
+	this->dstport = dstport;
29
+	this->taille = taille;
30
+}
31
+/**
32
+ * \brief 
33
+ * \param 
34
+ * \throws 
35
+ * \return 
36
+ */
37
+Packet::~Packet()
38
+{
39
+	
40
+}
41
+////////////////////////////////////////////////////////////////////////////////////////////////////
42
+/**
43
+ * \brief 
44
+ * \param 
45
+ * \throws 
46
+ * \return 
47
+ */
48
+int Packet::getTimestamp()
49
+{
50
+	return this->timestamp;
51
+}
52
+/**
53
+ * \brief 
54
+ * \param 
55
+ * \throws 
56
+ * \return 
57
+ */
58
+int Packet::getDuration()
59
+{
60
+	return this->duration;
61
+}
62
+/**
63
+ * \brief 
64
+ * \param 
65
+ * \throws 
66
+ * \return 
67
+ */
68
+std::string Packet::getIPsrc()
69
+{
70
+	return this->ipsrc;
71
+}
72
+/**
73
+ * \brief 
74
+ * \param 
75
+ * \throws 
76
+ * \return 
77
+ */
78
+std::string Packet::getIPdst()
79
+{
80
+	return this->ipdst;
81
+}
82
+/**
83
+ * \brief 
84
+ * \param 
85
+ * \throws 
86
+ * \return 
87
+ */
88
+int Packet::getTaille()
89
+{
90
+	return this->taille;
91
+}
92
+/**
93
+ * \brief 
94
+ * \param 
95
+ * \throws 
96
+ * \return 
97
+ */
98
+uint16_t Packet::getSrcPort()
99
+{
100
+	return this->srcport;
101
+}
102
+/**
103
+ * \brief 
104
+ * \param 
105
+ * \throws 
106
+ * \return 
107
+ */
108
+uint16_t Packet::getDstPort()
109
+{
110
+	return this->dstport;
111
+}
112
+////////////////////////////////////////////////////////////////////////////////////////////////////
113
+/**
114
+ * \brief 
115
+ * \param 
116
+ * \throws 
117
+ * \return 
118
+ */
119
+bool Packet::setDuration(int duree)
120
+{
121
+	if (duree <= 1)
122
+	{
123
+		this->duration = 1;
124
+	}
125
+	else
126
+	{
127
+		this->duration = duree;
128
+	}
129
+	return true;
130
+}
131
+////////////////////////////////////////////////////////////////////////////////////////////////////
132
+/**
133
+ * \brief 
134
+ * \param 
135
+ * \throws 
136
+ * \return 
137
+ */
138
+std::string Packet::toString()
139
+{
140
+	return std::to_string(this->timestamp) + ";" 
141
+			+ std::to_string(this->duration) + ";" 
142
+			+ this->ipsrc + ";" + this->ipdst + ";" 
143
+			+ std::to_string(this->srcport) + ";" 
144
+			+ std::to_string(this->dstport) + ";" 
145
+			+ std::to_string(this->taille);
146
+}

+ 57 - 0
cpp/Packet.hpp

@@ -0,0 +1,57 @@
1
+#ifndef PACKET_HPP
2
+#define PACKET_HPP
3
+
4
+#include <iostream>
5
+#include <vector>
6
+#include <exception>
7
+#include <stdexcept>
8
+#include <algorithm> // std::max
9
+
10
+#define ECH 100 // echantillonage. mettre entre 1 et 100. 1 <=> échantillonné par s. 100 <=> par 0.01s
11
+
12
+
13
+/**
14
+ * \brief classe Packet.
15
+ * Constructeur Packet(),  
16
+ * \param None
17
+ * \return None
18
+ * \throws None
19
+ */
20
+class Packet
21
+{
22
+	private:
23
+		// Attributes
24
+		int timestamp; // (h*3600 + m*60 + s)*ECH /** \brief timestamp de début de paquet */
25
+		int duration; // d*ECH /** \brief durée d'émission */
26
+		std::string ipsrc; // a.b.c.d /** \brief ip source */
27
+		std::string ipdst; // /** \brief ip destination */
28
+		int taille; // en octets /** \brief taille de la transmission */
29
+		uint16_t srcport; // port source
30
+		uint16_t dstport; // port destination
31
+		
32
+	public:
33
+		// Constructeurs
34
+		//Packet();
35
+		Packet(int timestamp, int duration, 
36
+				std::string ipsrc, std::string ipdst, 
37
+				uint16_t srcport, uint16_t dstport, int taille);
38
+		~Packet();
39
+		// Getters
40
+		int getTimestamp();
41
+		int getDuration();
42
+		std::string getIPsrc();
43
+		std::string getIPdst();
44
+		int getTaille(); // fr parce que size...
45
+		uint16_t getSrcPort();
46
+		uint16_t getDstPort();
47
+		// Setters
48
+		bool setTimestamp(int);
49
+		bool setDuration(int);
50
+		bool setIPsrc(std::string); // bool cause no exception
51
+		bool setIPdst(std::string);
52
+		bool setTaille();
53
+		// toString
54
+		std::string toString();
55
+		
56
+};
57
+#endif

+ 114 - 0
cpp/Traffic.cpp

@@ -0,0 +1,114 @@
1
+#include "Traffic.hpp"
2
+
3
+
4
+////////////////////////////////////////////////////////////////////////////////////////////////////
5
+/**
6
+ * \brief 
7
+ * \param 
8
+ * \throws 
9
+ * \return 
10
+ */
11
+Traffic::Traffic()
12
+{
13
+	this->taille = 0;
14
+	//this->listPackets.reserve(1'000'000); // pas utilisé
15
+}
16
+/**
17
+ * \brief 
18
+ * \param 
19
+ * \throws 
20
+ * \return 
21
+ */
22
+Traffic::~Traffic()
23
+{
24
+	
25
+}
26
+////////////////////////////////////////////////////////////////////////////////////////////////////
27
+/**
28
+ * \brief 
29
+ * \param 
30
+ * \throws 
31
+ * \return 
32
+ */
33
+int Traffic::getNbPackets()
34
+{
35
+	return (int) listPackets.size();
36
+}
37
+/**
38
+ * \brief 
39
+ * \param 
40
+ * \throws 
41
+ * \return 
42
+ */
43
+int Traffic::getTaille()
44
+{
45
+	return this->taille;
46
+}
47
+/**
48
+ * \brief 
49
+ * \param 
50
+ * \throws 
51
+ * \return 
52
+ */
53
+std::string Traffic::getIP()
54
+{
55
+	return this->ip;
56
+}
57
+/**
58
+ * \brief 
59
+ * \param 
60
+ * \throws 
61
+ * \return 
62
+ */
63
+Packet Traffic::getPacket(int index)
64
+{
65
+	return this->listPackets.at(index);
66
+}
67
+////////////////////////////////////////////////////////////////////////////////////////////////////
68
+/**
69
+ * \brief 
70
+ * \param 
71
+ * \throws 
72
+ * \return 
73
+ */
74
+bool Traffic::addPacket(Packet paquet)
75
+{
76
+	this->listPackets.push_back(paquet);
77
+	return true;
78
+}
79
+/**
80
+ * \brief 
81
+ * \param 
82
+ * \throws 
83
+ * \return 
84
+ */
85
+bool Traffic::setIP(std::string nvIP)
86
+{
87
+	this->ip = nvIP;
88
+	return true;
89
+}
90
+/**
91
+ * \brief 
92
+ * \param 
93
+ * \throws 
94
+ * \return 
95
+ */
96
+bool Traffic::add2taille(int taillepq)
97
+{
98
+	this->taille += taillepq;
99
+	return true;
100
+}
101
+////////////////////////////////////////////////////////////////////////////////////////////////////
102
+/**
103
+ * \brief 
104
+ * \param 
105
+ * \throws 
106
+ * \return 
107
+ */
108
+std::string Traffic::toString()
109
+{
110
+	std::stringstream ss; ss << this->taille;
111
+	std::string tmpch = this->ip + " " + ss.str();
112
+	std::cout << tmpch;
113
+	return tmpch;
114
+}

+ 50 - 0
cpp/Traffic.hpp

@@ -0,0 +1,50 @@
1
+#ifndef TRAFFIC_HPP
2
+#define TRAFFIC_HPP
3
+
4
+#include <iostream>
5
+#include <sstream>
6
+#include <string>
7
+#include <vector>
8
+#include <exception>
9
+#include <stdexcept>
10
+#include <algorithm> // std::max
11
+#include "Packet.hpp"
12
+
13
+#define ECH 100 // echantillonage. mettre entre 1 et 100. 1 <=> échantillonné par s. 100 <=> par 0.01s
14
+
15
+
16
+/**
17
+ * \brief class Traffic
18
+ * use to sort paquets (with listPackets)
19
+ * or use to make stats (without)
20
+ * \param None
21
+ * \return None
22
+ * \throws None
23
+ */
24
+class Traffic
25
+{
26
+	private:
27
+		// Attributes
28
+		std::vector<Packet> listPackets;
29
+		std::string ip;
30
+		bool isIPsrc = false;
31
+		int taille;
32
+		
33
+	public:
34
+		// Constructeur
35
+		Traffic();
36
+		~Traffic();
37
+		// Getters
38
+		Packet getPacket(int);
39
+		std::string getIP();
40
+		bool ipissrc();
41
+		int getNbPackets();
42
+		int getTaille();
43
+		// Setters
44
+		bool addPacket(Packet);
45
+		bool setIP(std::string);
46
+		bool add2taille(int);
47
+		// toString
48
+		std::string toString();
49
+};
50
+#endif

+ 588 - 0
cpp/main.cpp

@@ -0,0 +1,588 @@
1
+/// Main du parser/statistik-maker du projet YaPLog
2
+#include "main.hpp"
3
+
4
+
5
+/**
6
+ * \brief Fonction principale.
7
+ * Initialise les mutexes. Lance les threads. Attends la fin d'exécution.
8
+ * \param int argc : nombre de paramètres (4), char* argv[] : liste de paramètres
9
+ * \throws None
10
+ * \return int : 0 <=> EXIT_SUCCESS, 1 <=> EXIT_FAILURE
11
+ */
12
+int main(int argc, char **argv)
13
+{
14
+	//std::vector<std::string> hm = genHourMin();
15
+	std::string nomFic = argv[2]; //* nom des fichiers à lire */ nomFic += hm[64]; // "1600"... suffixes.
16
+	std::cout << "nb de CPU/cœurs détectés : " << std::thread::hardware_concurrency() << std::endl;
17
+	if (argc < 5) // program needs: -number of threads to launch, and -file, -no site. -OutFile
18
+	{
19
+		std::cerr << "\e[33m" << "usage :" << "\e[0m" << 
20
+			" ./graphEchantTabl <nombre (pair de préférence) de threads> </path/file> <nosite> <outfile>" << '\n';
21
+		std::cerr << "\e[32m" << "exemple :" << "\e[0m" << 
22
+			" ./graphEchantTabl 4 /home/administrateur/archive/ascii_nfcapd.1745 110" <<
23
+			" /home/administrateur/ex_res.csv" << std::endl;
24
+		exit(1); // EXIT_FAILURE
25
+	}
26
+	int nbWorkerThread;// = atoi(argv[1]); // param -> int
27
+	try
28
+	{
29
+		std::string tmparg1 = argv[1];
30
+		nbWorkerThread = std::stoi(tmparg1);
31
+	}
32
+	catch (std::exception const & e)
33
+	{
34
+		std::cerr << "\e[32m" << "Parse 1st argument error" << "\e[0m" << std::endl;
35
+		exit(1);
36
+	}
37
+	NomFicOut = argv[4]; // nom du fichier où écrire
38
+	// au moins 1 worker, pas plus de 16 (!), optimal : nombre de CPU/cœurs, probablement 2 ou 4.
39
+	if (nbWorkerThread < 1 || nbWorkerThread > 16) 
40
+	{
41
+		// EINVAL 22 /* Invalid argument */, /usr/include/asm-generic/errno-base.h
42
+		errno = 22; perror("nombre de threads invalide"); 
43
+		std::cerr << "\e[33m" << "nbWorkerThread =" << "\e[0m" << " " << nbWorkerThread << std::endl;
44
+		exit(1);
45
+	}
46
+	if (nbWorkerThread%2 != 0) // si nombre impair
47
+	{
48
+		std::cerr << "\e[33m" << "Attention" << "\e[0m" << 
49
+			", selon l'architecture choisie, il n'est pas évident qu'un nombre impair " <<
50
+			"de threads soit optimal" << std::endl;
51
+		// cf. speedtests :
52
+		// passage 1 -> 2 CPU : gain *3.37
53
+		// passage 2 -> 3 CPU : gain *1.12
54
+		// passage 3 -> 4 CPU : gain *1.67
55
+	}
56
+	// le fichier passé en paramètres existe-t-il ?
57
+	if (!couldFindFile(nomFic))
58
+	{
59
+		std::cerr << "\e[33m" << "Erreur :" << "\e[0m" << " fichier introuvable." << std::endl;
60
+		exit(1);
61
+	}
62
+	nomSite += argv[3]; // global variable which holds site reference name.
63
+	// initialize mutexes & verify status : ok/nok?
64
+	if(int mutinitfq = pthread_mutex_init(&fileQmutex, NULL)) // 
65
+	{
66
+		error(1, mutinitfq, "could not initialize mutex fileQmutex"); // EXIT_FAILURE
67
+	}
68
+	if(int mutinitres = pthread_mutex_init(&resQTmutex, NULL))
69
+	{
70
+		error(1, mutinitres, "could not initialize mutex resQTmutex"); // EXIT_FAILURE
71
+	}
72
+	if(int mutinitres = pthread_mutex_init(&resQDmutex, NULL))
73
+	{
74
+		error(1, mutinitres, "could not initialize mutex resQDmutex"); // EXIT_FAILURE
75
+	}
76
+	// declare 2 threads + pool of threads.
77
+	std::vector<pthread_t> lswk; // list/pool of workers
78
+	pthread_t tr, tw; // read, "write"
79
+	int rclswk; // status du pool de threads.
80
+	int rctr, rctw; // status du lancement des thread : ok/nok
81
+	// lancement des threads
82
+	rctr = pthread_create(&tr, NULL, thread_lecture, argv[2]); // crée threads lecteur
83
+	if (rctr) // vérification que le thread lecteur est lancé
84
+	{
85
+		error(1, rctr, "pthread_create : lecture"); // le thread lecture pas lancé 
86
+	}
87
+	for (int i=0;i<nbWorkerThread;i++) // crée pool de thread
88
+	{
89
+		pthread_t tmp; // descripteur de thread temporaire qui va être remplacé par lswk[..]
90
+		void* numeroThread = calloc(1, sizeof(int)); // allouer un int
91
+		numeroThread = memcpy(numeroThread, (void*) &i, (size_t) 4); // copie i dans numeroThread
92
+			// lance le thread, rclswk est le résultat du lancement, threadworker est la fonction, 
93
+			// tmp est le thread (va dans la liste), numeroThread le n° du thread :
94
+		rclswk = pthread_create(&tmp, NULL, threadworker, numeroThread);  
95
+		lswk.push_back(tmp); // tmp --> lswk[..]
96
+		if (rclswk) // vérification que les threads workers sont lancés
97
+		{
98
+			std::string msg = "pthread_create : failed to create worker n°";
99
+			std::stringstream ss;  ss << i;  msg += ss.str(); // msg += str(n° process)
100
+			error(1, rclswk, msg.c_str()); // le thread worker-n pas lancé // 1 <=> EXIT_FAILURE
101
+		}
102
+		std::cout << "thread n°" << i << " lancé." << std::endl;
103
+	}
104
+	
105
+	std::cout << ".............................main()..............................." << std::endl;
106
+	
107
+	rctr = pthread_join(tr, NULL); // attente thread lecture
108
+	if (rctr) // vérification que le thread lecteur est bien arrêté
109
+	{
110
+		error(1, rctr, "pthread_join : lecture"); // le thread lecture pas arrêté 
111
+	}
112
+	for (unsigned int i=0;i<lswk.size();i++) // attente du pool de workers
113
+	{
114
+		rclswk = pthread_join(lswk.at(i), NULL);
115
+		if (rclswk)
116
+		{
117
+			std::string msg = "pthread_join : worker ";
118
+			std::stringstream ss;  ss << i;  msg += ss.str(); // msg += str(n° process)
119
+			error(1, rclswk, msg.c_str()); // le thread worker-n pas arrêté // 1 <=> EXIT_FAILURE
120
+		}
121
+	} // fins des threads lecture et workers
122
+	rctw = pthread_create(&tw, NULL, threadwrite, NULL); // lancement du thread writer
123
+	if (rctw) // vérification que le thread écrivain est bien lancé
124
+	{
125
+		error(1, rctw, "pthread_create : écriture"); // le thread écriture pas lancé 
126
+	}
127
+	rctw = pthread_join(tw, NULL); // attente terminaison du writer
128
+	if (rctw) // vérification que le thread écrivain est bien arrêté
129
+	{
130
+		error(1, rctw, "pthread_join : écriture"); // le thread écriture pas arrêté 
131
+	}
132
+	
133
+	std::cout << "fin du main" << std::endl;
134
+	return 0;
135
+}
136
+
137
+////////////////////////////////////////////////////////////////////////////////////////////////////
138
+/**
139
+ * \brief thread lecteur. 
140
+ * lit le fichier en entrée et le charge 100 000 entrées dans une queue.
141
+ * \param (char*) (void*) nom du fichier à lire
142
+ * \throws None
143
+ * \return None. pthread_exit(NULL);
144
+ */
145
+void* thread_lecture(void* args)
146
+{
147
+	std::cout << "début du thread de lecture" << '\n';
148
+	//struct timespec sleeptime; sleeptime.tv_sec = 0; sleeptime.tv_nsec = NBLN/100; // fct nb ln à traiter.
149
+	// we know args is (char*), call with argv[2]. Mandatory cast from (void*) with -Werror=conversion
150
+	std::ifstream infile((char*) args, std::ios_base::in); 
151
+	int lockFile; // résultat de la prise de mutex. status : ok/nok ?
152
+	std::string ligne; // là on lit infile avec getline
153
+	// std::cout << args << std::endl; // ptrfic
154
+	// std::cout << "blablablablablablablablablablablablablablabla" << (char*) args << std::endl; // nomfic
155
+	while (!endoffile)
156
+	{
157
+		//std::cout << "1" << '\n'; 
158
+		if ((lockFile = pthread_mutex_lock(&fileQmutex))) // lock error // assignation ! => (())
159
+		{
160
+			// 1 <=> EXIT_FAILURE
161
+			error(1, lockFile, "thread_lecture : could not get lock properly"); 
162
+		}
163
+		//std::cout << "2" << '\n';
164
+		while (fileQ.size() < NBLN)
165
+		{
166
+			//std::cout << "3" << '\n';
167
+			//while (getline(infile, ligne, '\n')) // lire tout d'un coup, moins rapide.
168
+			while (getline(infile, ligne, '\n') && fileQ.size() < NBLN) // lire 100 000 lignes.
169
+			{
170
+				//std::cout << "9" << '\n';
171
+				fileQ.push(ligne);
172
+				std::cout << fileQ.size() << '\n';
173
+			}
174
+			if (infile.eof()) // end of file ----
175
+			{
176
+				endoffile = true; // sortir du while (!endoffile)
177
+				break; // sortir du while (fileQ.size() < SIZE)
178
+			}
179
+		}
180
+		// end of file ----
181
+		//std::cout << "4" << '\n';
182
+		// nanosleep(&sleeptime, NULL); // mettre le lecteur en pause n'accélère pas.
183
+		if ((lockFile = pthread_mutex_unlock(&fileQmutex)))
184
+		{
185
+			// 1 <=> EXIT_FAILURE
186
+			error(1, lockFile, "thread_lecture : could not release lock properly"); 
187
+		}
188
+		//std::cout << "5" << '\n';
189
+		//std::cin.ignore(); // ???
190
+	}
191
+	infile.close();
192
+	std::cout << "fin du thread de lecture" << std::endl;
193
+	// end thread.
194
+	pthread_exit(NULL);
195
+}
196
+/**
197
+ * \brief thread travailleur.
198
+ * \param (int) (void*) args : numéro du worker
199
+ * \throws None
200
+ * \return None. pthread_exit(NULL);
201
+ */
202
+void* threadworker(void* args)
203
+{
204
+	int idth = *(int*) args; // args est un int : numéro du worker, 0..15
205
+	free(args); // calloc(1, sizeof(int))
206
+	std::cout << "début du thread de travail " << idth << "." << '\n';
207
+	// attendre, au début la fileQ est vide, et on prendrait/relâcherait plusieurs fois un lock.
208
+	struct timespec sleeptime;
209
+	sleeptime.tv_sec = 0;
210
+	sleeptime.tv_nsec = NBLN*1000; // fonction du nombre de lignes initial à traiter.
211
+	nanosleep(&sleeptime, NULL); // attente "sleeptime"
212
+	const std::regex rgx("(\\d{4}[-]\\d{2}[-]\\d{2})(;)\
213
+(\\d{2}[:]\\d{2}[:]\\d{2})([.])(\\d{3})(;)(\\d+[.]\\d{3})(;)\
214
+([A-Z0-9]+)(;)(\\d{1,3}[.]\\d{1,3}[.]\\d{1,3}[.]\\d{1,3})([:])([0-9]{1,5})(([.]\\d+)?)(;;)\
215
+(\\d{1,3}[.]\\d{1,3}[.]\\d{1,3}[.]\\d{1,3})([:])([0-9]{1,5})(([.]\\d+)?)(;)(\\d+)(;)\
216
+(\\d+)(;)(1)");
217
+	std::smatch regsrxmatch;
218
+	std::vector<Traffic>* lsTraf = new std::vector<Traffic>(); // SELECT Packet WHERE ip/port IS ...
219
+	Data* myData = new Data(); // journée échantillonnée
220
+	std::cout << "fin d'attente " << '\n';
221
+	std::regex regPtclSiteStr;
222
+	std::smatch matchPtclSiteIp;
223
+	try
224
+	{
225
+		 regPtclSiteStr = site2ipsubnet(nomSite, "/home/administrateur/site2ip.csv");
226
+	}
227
+	catch(std::exception const& sece)
228
+	{
229
+		std::cerr << "site2ipsubnet() : " << sece.what() << "\e[33m " << nomSite << " \e[0m" << std::endl;
230
+		exit(1);
231
+	}
232
+	catch(...)
233
+	{
234
+		std::cerr << "default site2ipsubnet()..." << std::endl;
235
+		exit(1);
236
+	}
237
+	do 
238
+	{
239
+		int lockFile;
240
+		std::string ligne;
241
+		while (fileQ.size() > 0)
242
+		{
243
+			// attente pour la lecture non-concurrente de fileQ
244
+			if ((lockFile = pthread_mutex_lock(&fileQmutex))) // lock error // assignation ! => (())
245
+			{
246
+				error(1, lockFile, "threadworker : could not get lock properly"); // EXIT_FAILURE
247
+			}
248
+			if (fileQ.size() > 0) // récupérer et vire la plus vieille entrée de la queue si non vide
249
+			{
250
+				ligne = fileQ.front(); // récupérer la plus vieille entrée de la file dans la ligne
251
+				fileQ.pop(); // supprime la plus vieille entrée
252
+			}
253
+			else
254
+			{
255
+				std::cerr << "\e[33m" << "erreur imprévue" << "\e[0m" << '\n';
256
+			}
257
+			// relaxe du verrou
258
+			if ((lockFile = pthread_mutex_unlock(&fileQmutex))) // lock error // assignation ! (())
259
+			{
260
+				error(1, lockFile, "threadworker : could not release lock properly"); 
261
+			} // travail, rendre le mutex le plus vite possible => travail après la relaxe
262
+			///
263
+			std::string ipdst;
264
+			if (regex_search(ligne, regsrxmatch, rgx))
265
+			{
266
+				ipdst = regsrxmatch[17]; // 11 : src, 17 : dst
267
+				if (regex_search(ipdst, matchPtclSiteIp, regPtclSiteStr))
268
+				{
269
+					// Packet(int timestamp, int duration, 
270
+					// 		std::string ipsrc, std::string ipdst, 
271
+					//		uint16_t srcport, uint16_t dstport, int taille);
272
+					std::cout << idth;
273
+					//std::cout << "DEBUG1 : " << date2epoch(regsrxmatch[3], regsrxmatch[5]) << '\n';
274
+					//std::cout << "DEBUG2 : " << stoi(regsrxmatch[25]) << '\n';
275
+					//std::cin.ignore();
276
+					Packet* curPaq = 
277
+						new Packet(date2epoch(regsrxmatch[3], regsrxmatch[5]), 
278
+						stoi(regsrxmatch[7]), regsrxmatch[11], regsrxmatch[17], 
279
+						(uint16_t) stoi(regsrxmatch[13]), (uint16_t) stoi(regsrxmatch[19]), 
280
+						stoi(regsrxmatch[25]));
281
+					/// makeDataTraffic(Packet* pq, Data* dt, std::vector<Traffic>* lstf)
282
+					makeDataTraffic(curPaq, myData, lsTraf); // trois pointeurs passés, non const.
283
+					//~ delete curPaq; // job de la fonction fille makeDataTraffic()					
284
+				}
285
+				else
286
+				{
287
+					std::cerr << "\e[33m" << "Destination invalide." << "\e[0m" << " : " << ligne << " does not match : " << site2ipsubnet(nomSite, "/home/administrateur/site2ip.csv") << ", got : " << regsrxmatch[17] << '\n';
288
+				}
289
+			}
290
+			else
291
+			{
292
+				std::cerr << "\e[33m" << "Ligne invalide." << "\e[0m" << " : " << ligne << '\n';
293
+			}
294
+			/// // fin travail
295
+		}
296
+	} while (endoffile == false || fileQ.size() != 0);
297
+	std::cout << " fin fic " << endoffile << " fic taille " << fileQ.size() << '\n'; 
298
+	// on passe au thread finaliseur // prise du mutex, et test ok.
299
+	if (int lockQTraf = pthread_mutex_lock(&resQTmutex)) // lock Traffic mutex
300
+	{
301
+		// EXIT_FAILURE
302
+		std::string tmpmsg = "threadworker n°";
303
+		std::stringstream ss; ss << idth; tmpmsg += ss.str();
304
+		tmpmsg += " : could not get lock properly for Traffic";
305
+		error(1, lockQTraf, tmpmsg.c_str());
306
+	}
307
+	resQT.push_back(lsTraf); // append std::vector<Traffic>*
308
+	if (int unlockQTraf = pthread_mutex_unlock(&resQTmutex)) // relaxe du mutex, et test ok
309
+	{
310
+		std::string tmpmsg = "threadworker n°";
311
+		std::stringstream ss; ss << idth; tmpmsg += ss.str();
312
+		tmpmsg += " : could not release lock properly for Traffic";
313
+		error(1, unlockQTraf, tmpmsg.c_str()); // unlock error // EXIT_FAILURE
314
+	}
315
+	if (int lockQDraf = pthread_mutex_lock(&resQDmutex)) // lock Data mutex
316
+	{
317
+		std::string tmpmsg = "threadworker n°";
318
+		std::stringstream ss; ss << idth; tmpmsg += ss.str();
319
+		tmpmsg += " : could not get lock properly for Data";
320
+		error(1, lockQDraf, tmpmsg.c_str()); // lock error, EXIT_FAILURE
321
+	}
322
+	resQD.push_back(myData); // append Data*
323
+	if (int unlockQDraf = pthread_mutex_unlock(&resQDmutex)) // relaxe du mutex, et test ok
324
+	{
325
+		std::string tmpmsg = "threadworker n°";
326
+		std::stringstream ss; ss << idth; tmpmsg += ss.str();
327
+		tmpmsg += " : could not release lock properly for Data";
328
+		error(1, unlockQDraf, tmpmsg.c_str()); // lock error, EXIT_FAILURE
329
+	}
330
+	// fin du thread
331
+	std::cout << "je suis le thread n°" << idth << " et mon v est de taille : " << lsTraf->size() << std::endl;
332
+	pthread_exit(NULL); // fin du thread.
333
+}
334
+/**
335
+ * \brief thread écrivain. finalise le traitement de la donnée
336
+ * Somme les Data. appelle moyData() / sma() pour moyenner
337
+ * \param None. "args" obligatoire pour une fonction de thread POSIX, non utilisée
338
+ * \throws None
339
+ * \return None. pthread_exit(NULL);
340
+ */
341
+void* threadwrite(void* args)
342
+{
343
+	std::cout << "début du thread d'écriture" << '\n';
344
+	// free/delete
345
+	/// Traffic()
346
+	std::cout << "taille de resQT : " << resQT.size() << '\n';
347
+	for (unsigned int i=0;i<resQT.size();i++)
348
+	{
349
+		//for (unsigned int j=0;j<resQT.at(i)->size();j++)
350
+		{
351
+			std::cout << "Attempting to free Traffic n°" << i << '\n'; // << ", " << j << '\n';
352
+			//std::vector<std::vector<Traffic>*> onomnomnom;
353
+			//resQT.at(i)->at(j).toString();
354
+			//delete &(resQT.at(i)->at(j));
355
+			//delete &(resQT.at(i));
356
+		}
357
+	}
358
+	/// Data
359
+	Data* resval = new Data();
360
+	for (unsigned int i=0;i<resQD.size();i++)
361
+	{
362
+		for (unsigned int temps=0;temps<resQD.at(i)->getTaille();temps++)
363
+		{
364
+			resval->add2traffic(resQD.at(i)->getTrafficAt(temps), temps);
365
+		}
366
+		std::cout << "Attempting to free Data n°" << i << '\n';
367
+		//resQD.at(i)->toString();
368
+		//resQD.at(i)->writeout();
369
+		std::cin.ignore();
370
+		delete resQD.at(i);
371
+	}
372
+	std::cin.ignore(); //
373
+	
374
+	//~moyData(resval); // moyenne + écriture
375
+	sma(resval);
376
+	
377
+	//resval->writeout(); // écriture des données.
378
+	//
379
+	std::cout << "fin du thread d'écriture" << std::endl;
380
+	pthread_exit(NULL);
381
+}
382
+////////////////////////////////////////////////////////////////////////////////////////////////////
383
+inline bool couldFindFile (const std::string& name) 
384
+{
385
+	struct stat buffer; 
386
+	return (stat (name.c_str(), &buffer) == 0); 
387
+}
388
+/**
389
+ * \brief (hh:mm:ss, ms) --> cs
390
+ * horodatage en centisecondes.
391
+ * \param string "hh:mm:ss", string "ms"
392
+ * \throws None
393
+ * \return int cs
394
+ */
395
+int date2epoch(std::string h, std::string ms)
396
+{
397
+	int res = -1;
398
+	const std::regex rgxh("(\\d{2})([:])(\\d{2})([:])(\\d{2})");
399
+	std::smatch regsrxmatch;
400
+	//const std::regex rgxms("(\d{3})");
401
+	if (regex_search(h, regsrxmatch, rgxh))
402
+	{
403
+		res = stoi(regsrxmatch[1])*3600*ECH // heure -> ech
404
+			+ stoi(regsrxmatch[3])*60*ECH   // min
405
+			+ stoi(regsrxmatch[5])*ECH      // s
406
+			+ static_cast<int>((ECH)*stof(ms)/(1000)); // ms -> ech
407
+	}
408
+	return res;
409
+}
410
+/**
411
+ * \brief Range un Packet dans un Data (et potentiellement un Traffic)
412
+ * \param Packet*, Data*, vector<Traffic>
413
+ * \throws None
414
+ * \return bool : true si ok.
415
+ */
416
+bool makeDataTraffic(Packet* pq, Data* dt, std::vector<Traffic>* lstf)
417
+{
418
+	/*
419
+	/// Traffic()
420
+	//std::cout << "entrée dans le SIGSEGV" << std::endl;
421
+	bool pqRangeDansTraf = false; // a-t-on rangé le paquet dans un des traffics existants ?
422
+	//std::cin.ignore();
423
+	//std::cout << lstf->size() << std::endl;
424
+	//std::cin.ignore();
425
+	if (lstf->size() != 0)
426
+	{
427
+		for (unsigned int i=0;i<lstf->size();i++)
428
+		{
429
+			//std::cout << "boucle 1" << std::endl;
430
+			if (lstf->at(i).getIP() == pq->getIPsrc())
431
+			{
432
+				lstf->at(i).add2taille(pq->getTaille());
433
+				pqRangeDansTraf = true;
434
+				break; // unicité des trafics, inutile de continuer le for
435
+			}
436
+		}
437
+	}
438
+	else
439
+	{
440
+		__asm__("nop");
441
+	}
442
+	if (!pqRangeDansTraf)
443
+	{
444
+		Traffic* tmpTraf = new Traffic();
445
+		tmpTraf->setIP(pq->getIPsrc());
446
+		lstf->push_back(*tmpTraf);
447
+	}
448
+	*/
449
+	
450
+	/// Data()
451
+	dt->traiterPaquet(pq);
452
+	//std::cout << "coutNotNull() : " ;
453
+	//dt->coutNotNull();
454
+	//std::cout << " ; fin coutNotNull()" << '\n';
455
+	///
456
+	delete pq; // Enfant free()/delete
457
+	return true;
458
+}
459
+/**
460
+ * \brief Réalise la moyenne à partir d'une instance Data
461
+ * journée échantillonnée --> moyennée.
462
+ * \param Data* vecData
463
+ * \throws None
464
+ * \return bool : true si ok.
465
+ */
466
+bool moyData(Data* vData)
467
+{
468
+	std::cout << "début de moyData" << '\n';
469
+	// déclaration
470
+	std::vector<int> resval; // [0, 0, ..., 0], 86 400 fois
471
+	resval.reserve(86'400); //'// vecteur de secondes => taille connue
472
+	// initialisation
473
+	for (unsigned int i=0;i<86'400;i++)//'// 86 400 valeurs
474
+	{
475
+		resval.push_back(0);
476
+	}
477
+	std::cout << "Fin initialisation" << '\n';
478
+	// travail
479
+	for (unsigned int i=0;i<86'400;i++) //' //  86 400s
480
+	{
481
+		int somme = 0;
482
+		for (unsigned int j=0;j<ECH;j++)
483
+		{
484
+			somme += vData->getTrafficAt(i*ECH + j);
485
+		}
486
+		resval.at(i) = somme;
487
+	}
488
+	std::cout << "Fin travail" << '\n';
489
+	// écriture
490
+	std::ofstream outfile("/tmp/bargraph.csv", std::ios_base::out);
491
+	std::stringstream ss; 
492
+	for (unsigned int i=0;i<86'400;i++) //'// 
493
+	{
494
+		ss << resval.at(i);
495
+		ss << '\n';
496
+	}
497
+	outfile << ss.str();
498
+	outfile.close();
499
+	std::cout << "Fin écriture" << '\n';
500
+	return true;
501
+}
502
+/**
503
+ * \brief Réalise une moyenne Simple Moving Average à partir d'une instance Data
504
+ * journée échantillonnée --> moyennée.
505
+ * \param Data* vecData
506
+ * \throws None
507
+ * \return bool : true si ok.
508
+ */
509
+bool sma(Data* vData)
510
+{
511
+	// https://en.wikipedia.org/wiki/Moving_average
512
+	std::cout << "début de moyData" << '\n';
513
+	// déclaration
514
+	//std::vector<int> resval; // [0, 0, ..., 0], 86 400 fois
515
+	std::vector<uint64_t> resval; // [0, 0, ..., 0], 86 400 fois
516
+	resval.reserve(86'400); //'// vecteur de secondes => taille connue
517
+	// initialisation
518
+	for (unsigned int i=0;i<86'400;i++)//'// 86 400 valeurs
519
+	{
520
+		resval.push_back((uint64_t) 0);
521
+	}
522
+	std::cout << "Fin initialisation" << '\n';
523
+	// travail
524
+	
525
+	///
526
+	/*
527
+	int pas = 30; // moyenne sur 10 (?) secondes, échantillonnage centiseconde
528
+	int somme = 0; // init 0;
529
+	std::queue<int> movAvgQ;
530
+	for (int i=0;i<pas*ECH;i++) // taille de la queue : pas*ECH. 10s
531
+	{
532
+		movAvgQ.push(vData->getTrafficAt(i));
533
+		somme += movAvgQ.back(); // <=> somme += vData->getTrafficAt(i);
534
+	}
535
+	for (int i=0;i<ECH*86'400;i++) //'// 1234 -> 2345 -> 3456 -> 4567 -> 5678 -> 6789 -> 789 -> 89 -> 9
536
+	{
537
+		if (i%ECH == 0) // 
538
+		{
539
+			resval.at(i/ECH) = somme*pas/ECH;
540
+		}
541
+		somme -= movAvgQ.front(); // <=> somme -= vData->getTrafficAt(...);
542
+		movAvgQ.pop(); // pop front
543
+		if (i<ECH*86'400-pas*ECH)
544
+		{
545
+			movAvgQ.push(vData->getTrafficAt(i)); // push back
546
+			somme += movAvgQ.back(); // <=> somme += vData->getTrafficAt(i);			
547
+		}
548
+	}
549
+	*/
550
+	///
551
+	int pas = 30; // moyenne sur 10 (?) secondes, échantillonnage centiseconde
552
+	uint64_t somme = 0; // init 0;
553
+	std::queue<uint64_t> movAvgQ; 
554
+	for (int i=0;i<pas*ECH;i++) // taille de la queue : pas*ECH. 10s
555
+	{
556
+		movAvgQ.push((uint64_t) vData->getTrafficAt(i));
557
+		somme += movAvgQ.back(); // <=> somme += vData->getTrafficAt(i);
558
+	}
559
+	for (int i=0;i<ECH*86'400;i++) //'// 1234 -> 2345 -> 3456 -> 4567 -> 5678 -> 6789 -> 789 -> 89 -> 9
560
+	{
561
+		if (i%ECH == 0) // 
562
+		{
563
+			resval.at(i/ECH) = somme/pas/ECH; // moy faite sur pas*ECH
564
+		}
565
+		somme -= movAvgQ.front(); // <=> somme -= vData->getTrafficAt(...);
566
+		movAvgQ.pop(); // pop front
567
+		if (i<ECH*86'400-pas*ECH)
568
+		{
569
+			movAvgQ.push((uint64_t) vData->getTrafficAt(i)); // push back
570
+			somme += movAvgQ.back(); // <=> somme += vData->getTrafficAt(i);			
571
+		}
572
+	}
573
+	///
574
+	
575
+	std::cout << "Fin travail" << '\n';
576
+	// écriture
577
+	std::ofstream outfile(NomFicOut, std::ios_base::out);
578
+	std::stringstream ss; 
579
+	for (unsigned int i=0;i<86'400;i++) //'// 
580
+	{
581
+		ss << resval.at(i);
582
+		ss << '\n';
583
+	}
584
+	outfile << ss.str();
585
+	outfile.close();
586
+	std::cout << "Fin écriture" << '\n';
587
+	return true;
588
+}

+ 63 - 0
cpp/main.hpp

@@ -0,0 +1,63 @@
1
+#ifndef MAIN_HPP
2
+#define MAIN_HPP
3
+
4
+#include <iostream> // cin, cout, cerr.
5
+#include <stdlib.h> // itoa()
6
+#include <stdio.h> // itoa()
7
+#include <cstring> // c strings
8
+#include <exception> // oore
9
+#include <fstream> // ifstream
10
+#include <string> // std::string
11
+#include <sstream> // int --> string
12
+#include <iterator> 
13
+#include <regex> // const std::regex, std::smatch
14
+#include <unistd.h> // struct stat, open
15
+#include <sys/stat.h> // open
16
+#include <pthread.h> // pthread_t, POSIX threads
17
+#include <error.h> // error
18
+#include <errno.h> // perror
19
+#include <queue> // std::queue
20
+#include <time.h> // struct timespec
21
+#include <atomic> // std::atomic<bool>
22
+#include <algorithm> // std::max
23
+#include <thread> // std::thread::hardware_concurrency(); // C++11
24
+//#include <deque>
25
+
26
+#include "Data.hpp" // Data().
27
+#include "Packet.hpp" // Packet().
28
+#include "Traffic.hpp" // Traffic().
29
+#include "pontisiteip.hpp" // n° site --> ip/mask
30
+
31
+#define ECH 100
32
+#define NBLN 100'000 // '// nombre de lignes => poids en RAM. ~300o/obj + poids ligne ~120 => 
33
+						 // poids : ~550o/entrée. 100 000 <=> ~50-100 Mo de RAM. 
34
+						 // temps d'attente des threads correspondant.
35
+
36
+pthread_mutex_t fileQmutex; // mutex for this.line++
37
+std::queue<std::string> fileQ; // queue where thread_lecture writes, and thread[12]worker read.
38
+								// allouée par lecteur. vidée par workers
39
+pthread_mutex_t resQTmutex; // mutex for this.line++
40
+std::vector<std::vector<Traffic>*> resQT; // list of objects for Traffic threadwrite
41
+									// allouée par workers, vidée par écrivain.
42
+pthread_mutex_t resQDmutex;
43
+std::vector<Data*> resQD; // list of objects Data for threadwrite
44
+									// allouée par workers, vidée par écrivain.
45
+std::string nomSite("");		// nom du site
46
+
47
+//using namespace std; // bad practice
48
+inline bool couldFindFile(const std::string&); // fastest way to verify if std::string "filepath" exists. 
49
+int date2epoch(std::string, std::string); // (hh:mm:ss, ms) --> ms
50
+bool makeDataTraffic(Packet*, Data*, std::vector<Traffic>*); // Paquet --> (Data & Traffic)
51
+bool moyData(Data*);
52
+bool sma(Data*);
53
+
54
+// 3 fonctions de threads. 1 read, n-workers identiques (au paramètre près, 1 writer.
55
+void* thread_lecture(void*); // 1 <= lecture sur disque.
56
+void* threadworker(void*);   // n, n fonction du nombre de cœurs/proc
57
+void* threadwrite(void*);    // 1 <= finaliseur, écrivain.
58
+
59
+// std::atomic<bool> au lieu de bool pour le multithread, risque de std::out_of_range_exception sinon.
60
+std::atomic<bool> endoffile(false); // a-t-on fini de lire le fichier en entier ? 
61
+int nbFichier = (int) genHourMin().size(); // nombre de fichiers (15 min) à lire par site. 1 --> 96.
62
+std::string NomFicOut; // fichier où écrire les résultats de la journée
63
+#endif

+ 190 - 0
cpp/pontisiteip.cpp

@@ -0,0 +1,190 @@
1
+#include "pontisiteip.hpp"
2
+
3
+/**
4
+ * \brief lien numéro de site (Ponticelli) --> IP/masque
5
+ * Renvoie une regex correspondant au numéro de site en paramètre.
6
+ * Nécessaire pour déterminer qui est la src/dst dans un flow.
7
+ * \param std::string nosite in [1..~135]
8
+ * std::string nomFicIpMaskSites = "site2ip.csv"
9
+ * \return std::string "ip/mask" for regex
10
+ * \throws std::invalid_argument si le numéro du site est invalide.
11
+ */
12
+std::string site2ipsubnet(std::string nosite, std::string nomFicIpMaskSites)
13
+{
14
+	std::string ligne, octet("\\d{1,3}");
15
+	std::string point("[.]");
16
+	std::string retval("128[.]");
17
+	std::ifstream infile(nomFicIpMaskSites, std::ios_base::in);
18
+	//std::stringstream ss; 
19
+	std::smatch regsrxmatch;
20
+	while (getline(infile, ligne, '\n')) 
21
+	{
22
+		//                                      1   2   3   4   5   6  7  8  9  1  11
23
+		// exemple : "110;128.137.0.0/16" --> (110)(;)(128)(.)(137)(.)(0)(.)(0)(/)(16)
24
+		const std::regex rgx("(\\d{1,3}[a-zA-Z]{0,2})\
25
+(;)(\\d{1,3})([.])(\\d{1,3})([.])(\\d{1,3})([.])(\\d{1,3})\
26
+(/)(\\d{2})");
27
+		if (regex_search(ligne, regsrxmatch, rgx)) // ligne de nomFicIpMaskSites ok.
28
+		{
29
+			if (regsrxmatch[1] == nosite) // nosite <=> ligne de nomFicIpMaskSites.
30
+			{
31
+				retval += regsrxmatch[5];
32
+				retval += point; // += existe, pas +
33
+				if (regsrxmatch[11] == "16")
34
+				{
35
+					retval += octet + point + octet;
36
+					return retval; // /16
37
+				}
38
+				else if (regsrxmatch[11] == "24")
39
+				{
40
+					retval += regsrxmatch[7];
41
+					retval += point + octet; // += existe, pas +
42
+					return retval; // /24
43
+				}
44
+			}
45
+			// sinon pas la bonne ligne, on continue l'itération sur les lignes 
46
+		}
47
+		else // ligne de nomFicIpMaskSites incorrecte. format : 110;128.137.0.0/16
48
+		{
49
+			std::cerr << "\e[33m" << "Regex not matched!" << "\e[0m" << "\nLe fichier " 
50
+				<< nomFicIpMaskSites << " contient probablement une entrée non formatée" << std::endl;
51
+		}
52
+	}
53
+	throw std::invalid_argument("Numéro de site invalide");
54
+}
55
+/**
56
+ * \brief 
57
+ * \param 
58
+ * \throws 
59
+ * \return 
60
+ */
61
+std::vector<std::string> genHourMin()
62
+{
63
+	std::vector<std::string> resval;
64
+	//*
65
+	resval.push_back("0000");
66
+	resval.push_back("0015");
67
+	resval.push_back("0030");
68
+	resval.push_back("0045");
69
+	resval.push_back("0100");
70
+	resval.push_back("0115");
71
+	resval.push_back("0130");
72
+	resval.push_back("0145");
73
+	resval.push_back("0200");
74
+	resval.push_back("0215");
75
+	resval.push_back("0230");
76
+	resval.push_back("0245");
77
+	resval.push_back("0300");
78
+	resval.push_back("0315");
79
+	resval.push_back("0330");
80
+	resval.push_back("0345");
81
+	resval.push_back("0400");
82
+	resval.push_back("0415");
83
+	resval.push_back("0430");
84
+	resval.push_back("0445");
85
+	resval.push_back("0500");
86
+	resval.push_back("0515");
87
+	resval.push_back("0530");
88
+	resval.push_back("0545");
89
+	resval.push_back("0600");
90
+	resval.push_back("0615");
91
+	resval.push_back("0630");
92
+	resval.push_back("0645");
93
+	//*/
94
+	resval.push_back("0700"); // 0
95
+	resval.push_back("0715");
96
+	resval.push_back("0730");
97
+	resval.push_back("0745");
98
+	resval.push_back("0800"); // 4
99
+	resval.push_back("0815");
100
+	resval.push_back("0830");
101
+	resval.push_back("0845");
102
+	resval.push_back("0900"); // 8
103
+	resval.push_back("0915");
104
+	resval.push_back("0930");
105
+	resval.push_back("0945");
106
+	resval.push_back("1000"); // 12 
107
+	resval.push_back("1015");
108
+	resval.push_back("1030");
109
+	resval.push_back("1045");
110
+	resval.push_back("1100"); // 16
111
+	resval.push_back("1115");
112
+	resval.push_back("1130");
113
+	resval.push_back("1145");
114
+	resval.push_back("1200"); // 20
115
+	resval.push_back("1215");
116
+	resval.push_back("1230");
117
+	resval.push_back("1245");
118
+	resval.push_back("1300"); // 24
119
+	resval.push_back("1315");
120
+	resval.push_back("1330");
121
+	resval.push_back("1345");
122
+	resval.push_back("1400"); // 28
123
+	resval.push_back("1415");
124
+	resval.push_back("1430");
125
+	resval.push_back("1445");
126
+	resval.push_back("1500"); // 32
127
+	resval.push_back("1515");
128
+	resval.push_back("1530");
129
+	resval.push_back("1545");
130
+	resval.push_back("1600"); // 36
131
+	resval.push_back("1615");
132
+	resval.push_back("1630");
133
+	resval.push_back("1645");
134
+	resval.push_back("1700"); // 40
135
+	resval.push_back("1715");
136
+	resval.push_back("1730");
137
+	resval.push_back("1745");
138
+	resval.push_back("1800"); // 44
139
+	resval.push_back("1815");
140
+	resval.push_back("1830");
141
+	resval.push_back("1845");
142
+	resval.push_back("1900"); // 48
143
+	resval.push_back("1915");
144
+	resval.push_back("1930");
145
+	resval.push_back("1945");
146
+	resval.push_back("2000"); // 52
147
+	//*
148
+	resval.push_back("2015");
149
+	resval.push_back("2030");
150
+	resval.push_back("2045");
151
+	resval.push_back("2100");
152
+	resval.push_back("2115");
153
+	resval.push_back("2130");
154
+	resval.push_back("2145");
155
+	resval.push_back("2200");
156
+	resval.push_back("2215");
157
+	resval.push_back("2230");
158
+	resval.push_back("2245");
159
+	resval.push_back("2300");
160
+	resval.push_back("2315");
161
+	resval.push_back("2330");
162
+	resval.push_back("2345");
163
+	//*/
164
+	/* 
165
+	std::vector<std::string> resval;
166
+	int preoffset = 0;
167
+	int postoffset = 0;
168
+	std::stringstream ss; 
169
+	if (preoffset < postoffset && preoffset >= 0 && postoffset >= 0)
170
+	{
171
+		for (int i=0+offset;i<96-postoffset;i++)
172
+		{   
173
+				if (i < 40-preoffset)
174
+				{
175
+						ss << 0;
176
+				}   
177
+				ss << i/4;
178
+				ss << i%4 + ((i%4)*2)/4;
179
+				ss << (5*i)%10;
180
+				resval.push_back(ss.str());
181
+				ss.str(std::string());
182
+		}
183
+		for (unsigned int i=0;i<resval.size();i++)
184
+		{
185
+				std::cout << resval.at(i) << '\n';
186
+		}
187
+	}
188
+	//*/
189
+	return resval;
190
+}

+ 15 - 0
cpp/pontisiteip.hpp

@@ -0,0 +1,15 @@
1
+#ifndef PONTISITEIP_HPP
2
+#define PONTISITEIP_HPP
3
+
4
+#include <iostream>
5
+#include <fstream> // ifstream
6
+#include <string>
7
+#include <sstream>
8
+#include <exception>
9
+#include <stdexcept> 
10
+#include <regex> // const std::regex, std::smatch
11
+
12
+std::string site2ipsubnet(std::string nosite, std::string nomFicIpMaskSites);
13
+std::vector<std::string> genHourMin();
14
+
15
+#endif

+ 13 - 0
genHourMin/genHourMin.py

@@ -0,0 +1,13 @@
1
+#!/usr/bin/python3
2
+
3
+import re
4
+import os
5
+
6
+
7
+for heure in range(24):
8
+    if heure < 10:
9
+        heure = '0' +  str(heure)
10
+    for m in ['00', '15', '30', '45']:
11
+        print('resval', '.push_back("', heure, m, '");', sep='')
12
+
13
+

+ 11 - 0
gnuplot/plotgnu.sh

@@ -0,0 +1,11 @@
1
+#!/usr/bin/gnuplot
2
+
3
+reset 
4
+#set title ""
5
+set terminal png size 21600,720 #480,720960,3840,7680,15360,23040,30720
6
+set grid
7
+set xrange [ 1 : 86400 ]
8
+set xtics ( "1h" 3600, "2h" 7200, "3h" 10800, "4h" 14400, "5h" 18000, "6h" 21600, "7h" 25200, "8h" 28800, "9h" 32400, "10h" 36000, "11h" 39600, "12h" 43200, "13h" 46800, "14h" 50400, "15h" 54000, "16h" 57600, "17h" 61200, "18h" 64800, "19h" 68400, "20h" 72000, "21h" 75600, "22h" 79200, "23h" 82800, "24h" 86400 )
9
+
10
+plot "/tmp/toplot.csv" using 1 with boxes lc rgb "blueviolet"
11
+

+ 55 - 0
nfcapd2ascii/nfdumpall.sh

@@ -0,0 +1,55 @@
1
+#!/bin/bash
2
+
3
+echo -e "\e[35m"
4
+
5
+DIR=${1} # passé en paramètres
6
+LS=/bin/ls
7
+NFDUMP=/usr/local/bin/nfdump
8
+DATE=`/bin/ls -lrthp --color=always --time-style=long-iso ${DIR} | grep nfcapd | head -1 | cut -d ' ' -f8 | cut -d '.' -f2 | cut -c1-8` #YYYYMMDD
9
+RM=/bin/rm
10
+
11
+echo ${DIR}
12
+echo $DATE 
13
+
14
+
15
+
16
+matin () {
17
+for heure in 00 01 02 03 04 05 06 07 
18
+do 
19
+    for min in 00 15 30 45
20
+    do
21
+        ${NFDUMP} -r  ${DIR}/nfcapd.${DATE}${heure}${min} > ${DIR}/ascii.${DATE}-${heure}-${min} 2> /dev/null 
22
+	${RM} -f ${DIR}/nfcapd.${DATE}${heure}${min} 
23
+    done
24
+done
25
+}
26
+
27
+midi () {
28
+for heure in 08 09 10 11 12 13 14 15
29
+do 
30
+    for min in 00 15 30 45
31
+    do
32
+        ${NFDUMP} -r  ${DIR}/nfcapd.${DATE}${heure}${min} > ${DIR}/ascii.${DATE}-${heure}-${min} 2> /dev/null 
33
+	${RM} -f ${DIR}/nfcapd.${DATE}${heure}${min} 
34
+    done
35
+done
36
+}
37
+
38
+soir () {
39
+for heure in 16 17 18 19 20 21 22 23
40
+do 
41
+    for min in 00 15 30 45
42
+    do
43
+        ${NFDUMP} -r  ${DIR}/nfcapd.${DATE}${heure}${min} > ${DIR}/ascii.${DATE}-${heure}-${min} 2> /dev/null 
44
+	${RM} -f ${DIR}/nfcapd.${DATE}${heure}${min} 
45
+    done
46
+done
47
+}
48
+
49
+matin &
50
+midi &
51
+soir &
52
+wait
53
+echo "Done"
54
+echo -e "\e[0m"
55
+

+ 12 - 0
nfcapd2ascii/nfdumponemono.sh

@@ -0,0 +1,12 @@
1
+#!/bin/bash
2
+
3
+LS=/bin/ls
4
+NFDUMP=/usr/local/bin/nfdump
5
+
6
+for heure in 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23
7
+do 
8
+    for min in 00 15 30 45
9
+    do
10
+        ${NFDUMP} -r /home/administrateur/dump/nfcapd.20160705${heure}${min} >> /home/administrateur/zdata/toto.txt
11
+    done
12
+done

+ 34 - 0
preparser/Makefile

@@ -0,0 +1,34 @@
1
+CC=/usr/bin/gcc
2
+CFLAGS=-O3 -Wall 
3
+FLEX=/usr/bin/flex
4
+RM=/bin/rm
5
+
6
+
7
+# target
8
+help: h
9
+all: csvify.out acsvify.out
10
+
11
+
12
+# rules
13
+h:
14
+	: "make all pour construire"
15
+	: "make clean pour nettoyer l'environnement"
16
+
17
+csvify.out: lex.yy.c
18
+	${CC} ${CFLAGS} lex.yy.c -o csvify.out
19
+	${RM} -f lex.yy.c 
20
+
21
+acsvify.out: alex.yy.c 
22
+	${CC} ${CFLAGS} alex.yy.c -o acsvify.out
23
+	${RM} -f alex.yy.c
24
+
25
+lex.yy.c: csvify.l
26
+	${FLEX} csvify.l
27
+
28
+alex.yy.c: acsvify.l
29
+	${FLEX} -o alex.yy.c acsvify.l 
30
+
31
+# nettoyer
32
+clean: 
33
+	${RM} -f lex.yy.c *.out 
34
+

+ 130 - 0
preparser/acsvify.l

@@ -0,0 +1,130 @@
1
+/**
2
+ * Lexeur pour les fichier de log Nagios.
3
+ * À utiliser après les avoir convertis du format binaire vers un format texte 
4
+ * avec la commande :
5
+ * $ ndfump -r /path/nfcapd.date > fichierResultat.txt
6
+ * sur le fichier <fichierResultat.txt>
7
+ *
8
+ * Compiler avec : 
9
+ * $ flex *.l
10
+ * $ gcc -Wall lex.yy.c -o monPrgm.out
11
+ *
12
+ * Exécuter avec :
13
+ * $ ./monPrgm.out < fichierResultat.txt
14
+ * 
15
+ * Ce lexeur affiche la couleur à l'aide des macros echog, echob, echoy, echor.
16
+ * Pour la retirer, remplacer les echo[gbyr] par echo.
17
+ *
18
+ * Retirer la couleur est nécessaire lors de l'écriture d'un fichier de logs 
19
+ * nettoyé vers une destination ainsi :
20
+ * $ ./monPrgm.out < fichierResultat.txt > fichierClean.csv
21
+ *
22
+ */
23
+
24
+%option nounput noinput
25
+%option noyywrap
26
+
27
+%{
28
+#include <stdio.h>
29
+#include <stdlib.h>
30
+#include <string.h>
31
+
32
+#define RED(str)   "\e[31m" str "\e[0m"
33
+#define GREEN(str) "\e[32m" str "\e[0m"
34
+
35
+#define YLW(str)  "\e[33m" str "\e[0m"
36
+#define BLUE(str)  "\e[34m" str "\e[0m"
37
+
38
+#define VLT(str)  "\e[35m" str "\e[0m"
39
+#define BLCL(str)  "\e[36m" str "\e[0m"
40
+
41
+
42
+void echo(){
43
+    fprintf(stdout, "%s", yytext);
44
+}
45
+void echog(char *lex_cat) {
46
+    fprintf(stdout,GREEN("%s"), yytext); 
47
+}
48
+void echob(char *lex_cat) {
49
+    fprintf(stdout,BLUE("%s"), yytext); 
50
+}
51
+void echor(char *lex_cat) {
52
+    fprintf(stdout,RED("%s"), yytext); 
53
+}
54
+void echoy(char *lex_cat) {
55
+    fprintf(stdout,YLW("%s"), yytext); 
56
+}
57
+void echov(char *lex_cat) {
58
+    fprintf(stdout,VLT("%s"), yytext); 
59
+}
60
+void blank(){
61
+    fprintf(stdout,";");
62
+}
63
+
64
+void echoM()
65
+{
66
+    int idx = 0;
67
+    int dot = 0;
68
+    while (dot == 0)
69
+    {
70
+        if (yytext[idx] == '.')
71
+        {
72
+            dot++;
73
+        }
74
+        else
75
+        {
76
+            fprintf(stdout, "%c", yytext[idx]);
77
+        }
78
+        idx++;
79
+    }
80
+    fprintf(stdout, "%c", yytext[idx]);
81
+    fprintf(stdout, "00000");
82
+}
83
+%}
84
+
85
+INT                 [1-9]+[0-9]*
86
+FLOAT               [0-9]+[.][0-9]+
87
+ENTETE              Date[ ]first[ ]seen[ ]+Duration[ ]Proto[ ]+Src[ ]IP[ ]Addr[:]Port[ ]+Dst[ ]IP[ ]Addr[:]Port[ ]+Packets[ ]+Bytes[ ]Flows
88
+SPACE               [ ]
89
+MEGA                [0-9]+[.][0-9][ ]M
90
+SPACES              [ ][ ]+
91
+DATE                [0-9][0-9][0-9][0-9][-][0-1][0-9][-][0-3][0-9]
92
+HOUR                [0-2][0-9][:][0-6][0-9][:][0-6][0-9][.][0-9]{1,3}
93
+IPV4PORT            [0-9]{1,3}[.][0-9]{1,3}[.][0-9]{1,3}[.][0-9]{1,3}[:](([0-9]{1,5})|([0-9][.][0-9]))
94
+ARROW               [-][>]
95
+PROTO               (UDP)|(TCP)|(ICMP)|(IPv6)|(IPv4)
96
+UNWANTED            ^[a-zA-Z]+([ ][a-zA-Z]+)*[:].*$
97
+
98
+
99
+%%
100
+
101
+
102
+{ENTETE}              ; /* { printf("Date first seen;Duration Proto;Src IP Addr:Port;Dst IP Addr:Port;Packets;Byte Flows"); } */
103
+{PROTO}               { echo("PROTO"); }
104
+{IPV4PORT}            { echo("IP"); }
105
+{UNWANTED}            ;
106
+{MEGA}                { echoM(); }
107
+{FLOAT}               { echo("NUM"); }
108
+{INT}                 { echo("NUM"); }
109
+{SPACES}              { blank(); }
110
+{SPACE}               { blank(); }
111
+{DATE}                { echo("DATE"); }
112
+{HOUR}                { echo("HOUR"); }
113
+{ARROW}               ;
114
+
115
+
116
+.                   ; /* { std::cout << std::endl; } // */
117
+
118
+
119
+%%
120
+
121
+
122
+
123
+
124
+int main(int argc, char** argv) 
125
+{
126
+    // lex through the input:
127
+    yylex();
128
+    return 0;
129
+}
130
+

+ 132 - 0
preparser/csvify.l

@@ -0,0 +1,132 @@
1
+/**
2
+ * Lexeur pour les fichier de log Nagios.
3
+ * À utiliser après les avoir com=nverti du format binaire vers un format texte 
4
+ * avec la commande :
5
+ * $ ndfump -r /path/nfcapd.date > fichierResultat.txt
6
+ * sur le fichier <fichierResultat.txt>
7
+ *
8
+ * Compiler avec : 
9
+ * $ flex *.l
10
+ * $ gcc -Wall lex.yy.c -o monPrgm.out
11
+ *
12
+ * Exécuter avec :
13
+ * $ ./monPrgm.out < fichierResultat.txt
14
+ * 
15
+ * Ce lexeur affiche la couleur à l'aide des macros echog, echob, echoy, echor.
16
+ * Pour la retirer, remplacer les echo[gbyr] par echo.
17
+ *
18
+ * Retirer la couleur est nécessaire lors de l'écriture d'un fichier de logs 
19
+ * nettoyé vers une destination ainsi :
20
+ * $ ./monPrgm.out < fichierResultat.txt > fichierClean.csv
21
+ *
22
+ */
23
+
24
+%option nounput noinput
25
+%option noyywrap
26
+
27
+%{
28
+#include <stdio.h>
29
+#include <stdlib.h>
30
+
31
+#define RED(str)   "\e[31m" str "\e[0m"
32
+#define GREEN(str) "\e[32m" str "\e[0m"
33
+
34
+#define YLW(str)  "\e[33m" str "\e[0m"
35
+#define BLUE(str)  "\e[34m" str "\e[0m"
36
+
37
+#define VLT(str)  "\e[35m" str "\e[0m"
38
+#define BLCL(str)  "\e[36m" str "\e[0m"
39
+
40
+
41
+void echo(){
42
+    fprintf(stdout, "%s", yytext);
43
+}
44
+void echog(char *lex_cat) {
45
+    fprintf(stdout,GREEN("%s"), yytext); 
46
+}
47
+void echob(char *lex_cat) {
48
+    fprintf(stdout,BLUE("%s"), yytext); 
49
+}
50
+void echor(char *lex_cat) {
51
+    fprintf(stdout,RED("%s"), yytext); 
52
+}
53
+void echoy(char *lex_cat) {
54
+    fprintf(stdout,YLW("%s"), yytext); 
55
+}
56
+void echov(char *lex_cat) {
57
+    fprintf(stdout,VLT("%s"), yytext); 
58
+}
59
+void blank(){
60
+    fprintf(stdout,";");
61
+}
62
+void echoM()
63
+{
64
+    fprintf(stdout, "\e[34m"); // début couleur
65
+    int idx = 0;
66
+    int dot = 0;
67
+    while (dot == 0)
68
+    {
69
+        if (yytext[idx] == '.')
70
+        {
71
+            dot++;
72
+        }
73
+        else
74
+        {
75
+            fprintf(stdout, "%c", yytext[idx]);
76
+        }
77
+        idx++;
78
+    }
79
+    fprintf(stdout, "%c", yytext[idx]);
80
+    fprintf(stdout, "00000");
81
+    fprintf(stdout, "\e[0m"); // fin couleur
82
+}
83
+
84
+
85
+%}
86
+
87
+INT                 [1-9]+[0-9]*
88
+FLOAT               [0-9]+[.][0-9]+
89
+ENTETE              Date[ ]first[ ]seen[ ]+Duration[ ]Proto[ ]+Src[ ]IP[ ]Addr[:]Port[ ]+Dst[ ]IP[ ]Addr[:]Port[ ]+Packets[ ]+Bytes[ ]Flows
90
+SPACE               [ ]
91
+MEGA                [0-9]+[.][0-9][ ]M
92
+SPACES              [ ][ ]+
93
+DATE                [0-9][0-9][0-9][0-9][-][0-1][0-9][-][0-3][0-9]
94
+HOUR                [0-2][0-9][:][0-6][0-9][:][0-6][0-9][.][0-9]{1,3}
95
+IPV4PORT            [0-9]{1,3}[.][0-9]{1,3}[.][0-9]{1,3}[.][0-9]{1,3}[:](([0-9]{1,5})|([0-9][.][0-9]))
96
+ARROW               [-][>]
97
+PROTO               (UDP)|(TCP)|(ICMP)|(IPv6)|(IPv4)
98
+UNWANTED            ^[a-zA-Z]+([ ][a-zA-Z]+)*[:].*$
99
+
100
+
101
+%%
102
+
103
+
104
+{ENTETE}              ; /* { printf("Date first seen;Duration Proto;Src IP Addr:Port;Dst IP Addr:Port;Packets;Byte Flows"); } */
105
+{PROTO}               { echov("PROTO"); }
106
+{IPV4PORT}            { echog("IP"); }
107
+{UNWANTED}            ;
108
+{MEGA}                { echoM(); }
109
+{FLOAT}               { echob("NUM"); }
110
+{INT}                 { echob("NUM"); }
111
+{SPACES}              { blank(); }
112
+{SPACE}               { blank(); }
113
+{DATE}                { echor("DATE"); }
114
+{HOUR}                { echor("HOUR"); }
115
+{ARROW}               ;
116
+
117
+
118
+.                   ; /* { std::cout << std::endl; } // */
119
+
120
+
121
+%%
122
+
123
+
124
+
125
+
126
+int main(int argc, char** argv) 
127
+{
128
+    // lex through the input:
129
+    yylex();
130
+    return 0;
131
+}
132
+