]> git.stg.codes - stg.git/blob - stargazer/plugins/capture/cap_nf/cap_nf.cpp
ce42d911ad728d5845af8a37c34078e126ce820b
[stg.git] / 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 namespace
49 {
50 PLUGIN_CREATOR<NF_CAP> cnc;
51 }
52
53 extern "C" PLUGIN * GetPlugin();
54
55 PLUGIN * GetPlugin()
56 {
57 return cnc.GetPlugin();
58 }
59
60 NF_CAP::NF_CAP()
61     : traffCnt(NULL),
62       runningTCP(false),
63       runningUDP(false),
64       stoppedTCP(true),
65       stoppedUDP(true),
66       portT(0),
67       portU(0),
68       sockTCP(-1),
69       sockUDP(-1),
70       logger(GetPluginLogger(GetStgLogger(), "cap_nf"))
71 {
72 }
73
74 NF_CAP::~NF_CAP()
75 {
76 }
77
78 int NF_CAP::ParseSettings()
79 {
80 std::vector<PARAM_VALUE>::iterator it;
81 for (it = settings.moduleParams.begin(); it != settings.moduleParams.end(); ++it)
82     {
83     if (it->param == "TCPPort" && !it->value.empty())
84         {
85         if (str2x(it->value[0], portT))
86             {
87             errorStr = "Invalid TCPPort value";
88             printfd(__FILE__, "Error: Invalid TCPPort value\n");
89             return -1;
90             }
91         continue;
92         }
93     if (it->param == "UDPPort" && !it->value.empty())
94         {
95         if (str2x(it->value[0], portU))
96             {
97             errorStr = "Invalid UDPPort value";
98             printfd(__FILE__, "Error: Invalid UDPPort value\n");
99             return -1;
100             }
101         continue;
102         }
103     printfd(__FILE__, "'%s' is not a valid module param\n", it->param.c_str());
104     }
105 return 0;
106 }
107
108 int NF_CAP::Start()
109 {
110 if (portU > 0)
111     {
112     if (OpenUDP())
113         {
114         return -1;
115         }
116     runningUDP = true;
117     if (pthread_create(&tidUDP, NULL, RunUDP, this))
118         {
119         runningUDP = false;
120         CloseUDP();
121         errorStr = "Cannot create UDP thread";
122         logger("Cannot create UDP thread.");
123         printfd(__FILE__, "Error: Cannot create UDP thread\n");
124         return -1;
125         }
126     }
127 if (portT > 0)
128     {
129     if (OpenTCP())
130         {
131         return -1;
132         }
133     runningTCP = true;
134     if (pthread_create(&tidTCP, NULL, RunTCP, this))
135         {
136         runningTCP = false;
137         CloseTCP();
138         logger("Cannot create TCP thread.");
139         errorStr = "Cannot create TCP thread";
140         printfd(__FILE__, "Error: Cannot create TCP thread\n");
141         return -1;
142         }
143     }
144 return 0;
145 }
146
147 int NF_CAP::Stop()
148 {
149 runningTCP = runningUDP = false;
150 if (portU && !stoppedUDP)
151     {
152     CloseUDP();
153     for (int i = 0; i < 25 && !stoppedUDP; ++i)
154         {
155         struct timespec ts = {0, 200000000};
156         nanosleep(&ts, NULL);
157         }
158     if (stoppedUDP)
159         {
160         pthread_join(tidUDP, NULL);
161         }
162     else
163         {
164         if (pthread_kill(tidUDP, SIGUSR1))
165             {
166             errorStr = "Error sending signal to UDP thread";
167             logger("Error sending sugnal to UDP thread.");
168             printfd(__FILE__, "Error: Error sending signal to UDP thread\n");
169             return -1;
170             }
171         printfd(__FILE__, "UDP thread NOT stopped\n");
172         logger("Cannot stop UDP thread.");
173         }
174     }
175 if (portT && !stoppedTCP)
176     {
177     CloseTCP();
178     for (int i = 0; i < 25 && !stoppedTCP; ++i)
179         {
180         struct timespec ts = {0, 200000000};
181         nanosleep(&ts, NULL);
182         }
183     if (stoppedTCP)
184         {
185         pthread_join(tidTCP, NULL);
186         }
187     else
188         {
189         if (pthread_kill(tidTCP, SIGUSR1))
190             {
191             errorStr = "Error sending signal to TCP thread";
192             logger("Error sending signal to TCP thread.");
193             printfd(__FILE__, "Error: Error sending signal to TCP thread\n");
194             return -1;
195             }
196         printfd(__FILE__, "TCP thread NOT stopped\n");
197         logger("Cannot stop TCP thread.");
198         }
199     }
200 return 0;
201 }
202
203 bool NF_CAP::OpenUDP()
204 {
205 struct sockaddr_in sin;
206 sockUDP = socket(PF_INET, SOCK_DGRAM, 0);
207 if (sockUDP <= 0)
208     {
209     errorStr = "Error opening UDP socket";
210     logger("Cannot create UDP socket: %s", strerror(errno));
211     printfd(__FILE__, "Error: Error opening UDP socket\n");
212     return true;
213     }
214 sin.sin_family = AF_INET;
215 sin.sin_port = htons(portU);
216 sin.sin_addr.s_addr = inet_addr("0.0.0.0");
217 if (bind(sockUDP, (struct sockaddr *)&sin, sizeof(sin)))
218     {
219     errorStr = "Error binding UDP socket";
220     logger("Cannot bind UDP socket: %s", strerror(errno));
221     printfd(__FILE__, "Error: Error binding UDP socket\n");
222     return true;
223     }
224 return false;
225 }
226
227 bool NF_CAP::OpenTCP()
228 {
229 struct sockaddr_in sin;
230 sockTCP = socket(PF_INET, SOCK_STREAM, 0);
231 if (sockTCP <= 0)
232     {
233     errorStr = "Error opening TCP socket";
234     logger("Cannot create TCP socket: %s", strerror(errno));
235     printfd(__FILE__, "Error: Error opening TCP socket\n");
236     return true;
237     }
238 sin.sin_family = AF_INET;
239 sin.sin_port = htons(portT);
240 sin.sin_addr.s_addr = inet_addr("0.0.0.0");
241 if (bind(sockTCP, (struct sockaddr *)&sin, sizeof(sin)))
242     {
243     errorStr = "Error binding TCP socket";
244     logger("Cannot bind TCP socket: %s", strerror(errno));
245     printfd(__FILE__, "Error: Error binding TCP socket\n");
246     return true;
247     }
248 if (listen(sockTCP, 1))
249     {
250     errorStr = "Error listening on TCP socket";
251     logger("Cannot listen on TCP socket: %s", strerror(errno));
252     printfd(__FILE__, "Error: Error listening TCP socket\n");
253     return true;
254     }
255 return false;
256 }
257
258 void * NF_CAP::RunUDP(void * c)
259 {
260 sigset_t signalSet;
261 sigfillset(&signalSet);
262 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
263
264 NF_CAP * cap = static_cast<NF_CAP *>(c);
265 cap->stoppedUDP = false;
266 while (cap->runningUDP)
267     {
268     if (!WaitPackets(cap->sockUDP))
269         {
270         continue;
271         }
272
273     // Data
274     struct sockaddr_in sin;
275     socklen_t slen = sizeof(sin);
276     uint8_t buf[BUF_SIZE];
277     ssize_t res = recvfrom(cap->sockUDP, buf, BUF_SIZE, 0, reinterpret_cast<struct sockaddr *>(&sin), &slen);
278     if (!cap->runningUDP)
279         break;
280
281     if (res < 0)
282         {
283         cap->logger("recvfrom error: %s", strerror(errno));
284         continue;
285         }
286
287     if (res == 0) // EOF
288         {
289         continue;
290         }
291
292     if (res < 24)
293         {
294         if (errno != EINTR)
295             {
296             cap->errorStr = "Invalid data received";
297             printfd(__FILE__, "Error: Invalid data received through UDP\n");
298             }
299         continue;
300         }
301
302     cap->ParseBuffer(buf, res);
303     }
304 cap->stoppedUDP = true;
305 return NULL;
306 }
307
308 void * NF_CAP::RunTCP(void * c)
309 {
310 sigset_t signalSet;
311 sigfillset(&signalSet);
312 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
313
314 NF_CAP * cap = static_cast<NF_CAP *>(c);
315 cap->stoppedTCP = false;
316 while (cap->runningTCP)
317     {
318     if (!WaitPackets(cap->sockTCP))
319         {
320         continue;
321         }
322
323     // Data
324     struct sockaddr_in sin;
325     socklen_t slen = sizeof(sin);
326     int sd = accept(cap->sockTCP, reinterpret_cast<struct sockaddr *>(&sin), &slen);
327     if (!cap->runningTCP)
328         break;
329
330     if (sd <= 0)
331         {
332         if (sd < 0)
333             cap->logger("accept error: %s", strerror(errno));
334         continue;
335         }
336
337     if (!WaitPackets(sd))
338         {
339         close(sd);
340         continue;
341         }
342
343     uint8_t buf[BUF_SIZE];
344     ssize_t res = recv(sd, buf, BUF_SIZE, MSG_WAITALL);
345
346     if (res < 0)
347         cap->logger("recv error: %s", strerror(errno));
348
349     close(sd);
350
351     if (!cap->runningTCP)
352         break;
353
354     if (res == 0) // EOF
355         {
356         continue;
357         }
358
359     // Wrong logic!
360     // Need to check actual data length and wait all data to receive
361     if (res < 24)
362         {
363         continue;
364         }
365
366     cap->ParseBuffer(buf, res);
367     }
368 cap->stoppedTCP = true;
369 return NULL;
370 }
371
372 void NF_CAP::ParseBuffer(uint8_t * buf, ssize_t size)
373 {
374 RAW_PACKET ip;
375 NF_HEADER * hdr = reinterpret_cast<NF_HEADER *>(buf);
376 if (htons(hdr->version) != 5)
377     {
378     return;
379     }
380
381 int packets = htons(hdr->count);
382
383 if (packets < 0 || packets > 30)
384     {
385     return;
386     }
387
388 if (24 + 48 * packets != size)
389     {
390     // See 'wrong logic' upper
391     return;
392     }
393
394 for (int i = 0; i < packets; ++i)
395     {
396     NF_DATA * data = reinterpret_cast<NF_DATA *>(buf + 24 + i * 48);
397
398     ip.rawPacket.header.ipHeader.ip_v = 4;
399     ip.rawPacket.header.ipHeader.ip_hl = 5;
400     ip.rawPacket.header.ipHeader.ip_p = data->proto;
401     ip.dataLen = ntohl(data->octets);
402     ip.rawPacket.header.ipHeader.ip_src.s_addr = data->srcAddr;
403     ip.rawPacket.header.ipHeader.ip_dst.s_addr = data->dstAddr;
404     ip.rawPacket.header.sPort = data->srcPort;
405     ip.rawPacket.header.dPort = data->dstPort;
406
407     traffCnt->Process(ip);
408     }
409 }