]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/capture/cap_nf/cap_nf.cpp
fb7d2cc5b0f291d4ffa846be6857008bb0e8499d
[stg.git] / projects / stargazer / plugins / capture / cap_nf / cap_nf.cpp
1 /*
2  *    This program is free software; you can redistribute it and/or modify
3  *    it under the terms of the GNU General Public License as published by
4  *    the Free Software Foundation; either version 2 of the License, or
5  *    (at your option) any later version.
6  *
7  *    This program is distributed in the hope that it will be useful,
8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  *    GNU General Public License for more details.
11  *
12  *    You should have received a copy of the GNU General Public License
13  *    along with this program; if not, write to the Free Software
14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
15  */
16
17 /*
18 Date: 16.05.2008
19 */
20
21 /*
22 * Author : Maxim Mamontov <faust@stg.dp.ua>
23 */
24
25 /*
26 $Revision: 1.11 $
27 $Date: 2010/09/10 06:41:06 $
28 $Author: faust $
29 */
30 #include <sys/types.h>
31 #include <sys/socket.h>
32 #include <netinet/in.h>
33 #include <arpa/inet.h>
34 #include <unistd.h>
35
36 #include <csignal>
37 #include <cerrno>
38 #include <cstring>
39
40 #include <vector>
41
42 #include "stg/common.h" 
43 #include "stg/raw_ip_packet.h"
44 #include "stg/traffcounter.h"
45 #include "stg/plugin_creator.h"
46 #include "cap_nf.h"
47
48 PLUGIN_CREATOR<NF_CAP> cnc;
49
50 PLUGIN * GetPlugin()
51 {
52 return cnc.GetPlugin();
53 }
54
55 NF_CAP::NF_CAP()
56     : traffCnt(NULL),
57       settings(),
58       tidTCP(),
59       tidUDP(),
60       runningTCP(false),
61       runningUDP(false),
62       stoppedTCP(true),
63       stoppedUDP(true),
64       portT(0),
65       portU(0),
66       sockTCP(-1),
67       sockUDP(-1),
68       errorStr()
69 {
70 }
71
72 NF_CAP::~NF_CAP()
73 {
74 }
75
76 int NF_CAP::ParseSettings()
77 {
78 std::vector<PARAM_VALUE>::iterator it;
79 for (it = settings.moduleParams.begin(); it != settings.moduleParams.end(); ++it)
80     {
81     if (it->param == "TCPPort")
82         {
83         if (str2x(it->value[0], portT))
84             {
85             errorStr = "Invalid TCPPort value";
86             printfd(__FILE__, "Error: Invalid TCPPort value\n");
87             return -1;
88             }
89         continue;
90         }
91     if (it->param == "UDPPort")
92         {
93         if (str2x(it->value[0], portU))
94             {
95             errorStr = "Invalid UDPPort value";
96             printfd(__FILE__, "Error: Invalid UDPPort value\n");
97             return -1;
98             }
99         continue;
100         }
101     printfd(__FILE__, "'%s' is not a valid module param\n", it->param.c_str());
102     }
103 return 0;
104 }
105
106 int NF_CAP::Start()
107 {
108 if (portU > 0)
109     {
110     if (OpenUDP())
111         {
112         return -1;
113         }
114     runningUDP = true;
115     if (pthread_create(&tidUDP, NULL, RunUDP, this))
116         {
117         runningUDP = false;
118         CloseUDP();
119         errorStr = "Cannot create UDP thread";
120         printfd(__FILE__, "Error: Cannot create UDP thread\n");
121         return -1;
122         }
123     }
124 if (portT > 0)
125     {
126     if (OpenTCP())
127         {
128         return -1;
129         }
130     runningTCP = true;
131     if (pthread_create(&tidTCP, NULL, RunTCP, this))
132         {
133         runningTCP = false;
134         CloseTCP();
135         errorStr = "Cannot create TCP thread";
136         printfd(__FILE__, "Error: Cannot create TCP thread\n");
137         return -1;
138         }
139     }
140 return 0;
141 }
142
143 int NF_CAP::Stop()
144 {
145 runningTCP = runningUDP = false;
146 if (portU && !stoppedUDP)
147     {
148     CloseUDP();
149     for (int i = 0; i < 25 && !stoppedUDP; ++i)
150         {
151         struct timespec ts = {0, 200000000};
152         nanosleep(&ts, NULL);
153         }
154     if (stoppedUDP)
155         {
156         pthread_join(tidUDP, NULL);
157         }
158     else
159         {
160         if (pthread_kill(tidUDP, SIGUSR1))
161             {
162             errorStr = "Error sending signal to UDP thread";
163             printfd(__FILE__, "Error: Error sending signal to UDP thread\n");
164             return -1;
165             }
166         printfd(__FILE__, "UDP thread NOT stopped\n");
167         }
168     }
169 if (portT && !stoppedTCP)
170     {
171     CloseTCP();
172     for (int i = 0; i < 25 && !stoppedTCP; ++i)
173         {
174         struct timespec ts = {0, 200000000};
175         nanosleep(&ts, NULL);
176         }
177     if (stoppedTCP)
178         {
179         pthread_join(tidTCP, NULL);
180         }
181     else
182         {
183         if (pthread_kill(tidTCP, SIGUSR1))
184             {
185             errorStr = "Error sending signal to TCP thread";
186             printfd(__FILE__, "Error: Error sending signal to TCP thread\n");
187             return -1;
188             }
189         printfd(__FILE__, "TCP thread NOT stopped\n");
190         }
191     }
192 return 0;
193 }
194
195 bool NF_CAP::OpenUDP()
196 {
197 struct sockaddr_in sin;
198 sockUDP = socket(PF_INET, SOCK_DGRAM, 0);
199 if (sockUDP <= 0)
200     {
201     errorStr = "Error opening UDP socket";
202     printfd(__FILE__, "Error: Error opening UDP socket\n");
203     return true;
204     }
205 sin.sin_family = AF_INET;
206 sin.sin_port = htons(portU);
207 sin.sin_addr.s_addr = inet_addr("0.0.0.0");
208 if (bind(sockUDP, (struct sockaddr *)&sin, sizeof(sin)))
209     {
210     errorStr = "Error binding UDP socket";
211     printfd(__FILE__, "Error: Error binding UDP socket\n");
212     return true;
213     }
214 return false;
215 }
216
217 bool NF_CAP::OpenTCP()
218 {
219 struct sockaddr_in sin;
220 sockTCP = socket(PF_INET, SOCK_STREAM, 0);
221 if (sockTCP <= 0)
222     {
223     errorStr = "Error opening TCP socket";
224     printfd(__FILE__, "Error: Error opening TCP socket\n");
225     return true;
226     }
227 sin.sin_family = AF_INET;
228 sin.sin_port = htons(portT);
229 sin.sin_addr.s_addr = inet_addr("0.0.0.0");
230 if (bind(sockTCP, (struct sockaddr *)&sin, sizeof(sin)))
231     {
232     errorStr = "Error binding TCP socket";
233     printfd(__FILE__, "Error: Error binding TCP socket\n");
234     return true;
235     }
236 if (listen(sockTCP, 1))
237     {
238     errorStr = "Error listening on TCP socket";
239     printfd(__FILE__, "Error: Error listening TCP socket\n");
240     return true;
241     }
242 return false;
243 }
244
245 void * NF_CAP::RunUDP(void * c)
246 {
247 NF_CAP * cap = static_cast<NF_CAP *>(c);
248 uint8_t buf[BUF_SIZE];
249 int res;
250 struct sockaddr_in sin;
251 socklen_t slen;
252 cap->stoppedUDP = false;
253 while (cap->runningUDP)
254     {
255     if (!WaitPackets(cap->sockUDP))
256         {
257         continue;
258         }
259
260     // Data
261     slen = sizeof(sin);
262     res = recvfrom(cap->sockUDP, buf, BUF_SIZE, 0, reinterpret_cast<struct sockaddr *>(&sin), &slen);
263     if (!cap->runningUDP)
264         break;
265
266     if (res == 0) // EOF
267         {
268         continue;
269         }
270
271     if (res < 24)
272         {
273         if (errno != EINTR)
274             {
275             cap->errorStr = "Invalid data received";
276             printfd(__FILE__, "Error: Invalid data received through UDP\n");
277             }
278         continue;
279         }
280
281     cap->ParseBuffer(buf, res);
282     }
283 cap->stoppedUDP = true;
284 return NULL;
285 }
286
287 void * NF_CAP::RunTCP(void * c)
288 {
289 NF_CAP * cap = static_cast<NF_CAP *>(c);
290 uint8_t buf[BUF_SIZE];
291 int res;
292 int sd;
293 struct sockaddr_in sin;
294 socklen_t slen;
295 cap->stoppedTCP = false;
296 while (cap->runningTCP)
297     {
298     if (!WaitPackets(cap->sockTCP))
299         {
300         continue;
301         }
302
303     // Data
304     slen = sizeof(sin);
305     sd = accept(cap->sockTCP, reinterpret_cast<struct sockaddr *>(&sin), &slen);
306     if (!cap->runningTCP)
307         break;
308
309     if (sd <= 0)
310         {
311         if (errno != EINTR)
312             {
313             cap->errorStr = "Error accepting connection";
314             printfd(__FILE__, "Error: Error accepting connection\n");
315             }
316         continue;
317         }
318
319     if (!WaitPackets(sd))
320         {
321         close(sd);
322         continue;
323         }
324
325     res = recv(sd, buf, BUF_SIZE, MSG_WAITALL);
326     close(sd);
327
328     if (!cap->runningTCP)
329         break;
330
331     if (res == 0) // EOF
332         {
333         continue;
334         }
335
336     // Wrong logic!
337     // Need to check actual data length and wait all data to receive
338     if (res < 24)
339         {
340         if (errno != EINTR)
341             {
342             cap->errorStr = "Invalid data received";
343             printfd(__FILE__, "Error: Invalid data received through TCP\n");
344             }
345         continue;
346         }
347
348     cap->ParseBuffer(buf, res);
349     }
350 cap->stoppedTCP = true;
351 return NULL;
352 }
353
354 void NF_CAP::ParseBuffer(uint8_t * buf, int size)
355 {
356 RAW_PACKET ip;
357 NF_HEADER * hdr = reinterpret_cast<NF_HEADER *>(buf);
358 if (htons(hdr->version) != 5)
359     {
360     return;
361     }
362
363 int packets = htons(hdr->count);
364
365 if (packets < 0 || packets > 30)
366     {
367     return;
368     }
369
370 if (24 + 48 * packets != size)
371     {
372     // See 'wrong logic' upper
373     return;
374     }
375
376 for (int i = 0; i < packets; ++i)
377     {
378     NF_DATA * data = reinterpret_cast<NF_DATA *>(buf + 24 + i * 48);
379
380     ip.rawPacket.header.ipHeader.ip_v = 4;
381     ip.rawPacket.header.ipHeader.ip_hl = 5;
382     ip.rawPacket.header.ipHeader.ip_p = data->proto;
383     ip.dataLen = ntohl(data->octets);
384     ip.rawPacket.header.ipHeader.ip_src.s_addr = data->srcAddr;
385     ip.rawPacket.header.ipHeader.ip_dst.s_addr = data->dstAddr;
386     ip.rawPacket.header.sPort = data->srcPort;
387     ip.rawPacket.header.dPort = data->dstPort;
388
389     traffCnt->Process(ip);
390     }
391 }