]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/capture/pcap/pcap_cap.cpp
57a5a8781d22ea1ba8c86b3db6a50c332a204ff1
[stg.git] / projects / stargazer / plugins / capture / pcap / pcap_cap.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 * Author : Maxim Mamontov <faust@stargazer.dp.ua>
19 */
20
21 #include "pcap_cap.h"
22
23 #include "stg/traffcounter.h"
24 #include "stg/plugin_creator.h"
25 #include "stg/common.h"
26 #include "stg/raw_ip_packet.h"
27
28 #include <signal.h>
29
30 //-----------------------------------------------------------------------------
31 //-----------------------------------------------------------------------------
32 //-----------------------------------------------------------------------------
33 namespace
34 {
35 PLUGIN_CREATOR<PCAP_CAP> pcc;
36
37 const size_t SNAP_LEN = 1518;
38 const size_t ETHER_ADDR_LEN = 6;
39
40 struct ETH
41 {
42 u_char     ether_dhost[ETHER_ADDR_LEN];    /* destination host address */
43 u_char     ether_shost[ETHER_ADDR_LEN];    /* source host address */
44 u_short    ether_type;                     /* IP? ARP? RARP? etc */
45 };
46
47 }
48
49 extern "C" PLUGIN * GetPlugin();
50 //-----------------------------------------------------------------------------
51 //-----------------------------------------------------------------------------
52 //-----------------------------------------------------------------------------
53 PLUGIN * GetPlugin()
54 {
55 return pcc.GetPlugin();
56 }
57 //-----------------------------------------------------------------------------
58 //-----------------------------------------------------------------------------
59 //-----------------------------------------------------------------------------
60 std::string PCAP_CAP::GetVersion() const
61 {
62 return "pcap_cap v.1.0";
63 }
64 //-----------------------------------------------------------------------------
65 PCAP_CAP::PCAP_CAP()
66     : errorStr(),
67       thread(),
68       nonstop(false),
69       isRunning(false),
70       traffCnt(NULL),
71       logger(GetPluginLogger(GetStgLogger(), "cap_pcap"))
72 {
73 }
74 //-----------------------------------------------------------------------------
75 int PCAP_CAP::ParseSettings()
76 {
77 devices.erase(devices.begin(), devices.end());
78
79 if (settings.moduleParams.empty())
80     {
81     devices.push_back(DEV());
82     logger("Defaulting to pseudo-device 'all'.");
83     return 0;
84     }
85
86 for (size_t i = 0; i < settings.moduleParams.size(); i++)
87     if (settings.moduleParams[i].param == "interfaces")
88         for (size_t j = 0; j < settings.moduleParams[i].value.size(); j++)
89             devices.push_back(DEV(settings.moduleParams[i].value[j]));
90
91 for (size_t i = 0; i < settings.moduleParams.size(); i++)
92     if (settings.moduleParams[i].param == "filters")
93         for (size_t j = 0; j < settings.moduleParams[i].value.size(); j++)
94             if (j < devices.size())
95                 devices[j].filterExpression = settings.moduleParams[i].value[j];
96
97 if (devices.empty())
98     {
99     devices.push_back(DEV());
100     logger("Defaulting to pseudo-device 'all'.");
101     return 0;
102     }
103
104 return 0;
105 }
106 //-----------------------------------------------------------------------------
107 int PCAP_CAP::Start()
108 {
109 if (isRunning)
110     return 0;
111
112 DEV_MAP::iterator it(devices.begin());
113 while (it != devices.end())
114     {
115     bpf_u_int32 mask;
116     bpf_u_int32 net;
117     char errbuf[PCAP_ERRBUF_SIZE];
118
119     /* get network number and mask associated with capture device */
120     if (pcap_lookupnet(it->device.c_str(), &net, &mask, errbuf) == -1)
121         {
122         errorStr = "Couldn't get netmask for device " + it->device + ": " + errbuf;
123         logger(errorStr);
124         printfd(__FILE__, "%s\n", errorStr.c_str());
125         return -1;
126         }
127
128     /* open capture device */
129     it->handle = pcap_open_live(it->device.c_str(), SNAP_LEN, 1, 1000, errbuf);
130     if (it->handle == NULL)
131         {
132         errorStr = "Couldn't open device " + it->device + ": " + errbuf;
133         logger(errorStr);
134         printfd(__FILE__, "%s\n", errorStr.c_str());
135         return -1;
136         }
137
138     if (pcap_setnonblock(it->handle, true, errbuf) == -1)
139         {
140         errorStr = "Couldn't put device " + it->device + " into non-blocking mode: " + errbuf;
141         logger(errorStr);
142         printfd(__FILE__, "%s\n", errorStr.c_str());
143         return -1;
144         }
145
146     /* make sure we're capturing on an Ethernet device [2] */
147     if (pcap_datalink(it->handle) != DLT_EN10MB)
148         {
149         errorStr = it->device + " is not an Ethernet";
150         logger(errorStr);
151         printfd(__FILE__, "%s\n", errorStr.c_str());
152         return -1;
153         }
154
155     /* compile the filter expression */
156     if (pcap_compile(it->handle, &it->filter, it->filterExpression.c_str(), 0, net) == -1)
157         {
158         errorStr = "Couldn't parse filter " + it->filterExpression + ": " + pcap_geterr(it->handle);
159         logger(errorStr);
160         printfd(__FILE__, "%s\n", errorStr.c_str());
161         return -1;
162         }
163
164     /* apply the compiled filter */
165     if (pcap_setfilter(it->handle, &it->filter) == -1)
166         {
167         errorStr = "Couldn't install filter " + it->filterExpression + ": " + pcap_geterr(it->handle);
168         logger(errorStr);
169         printfd(__FILE__, "%s\n", errorStr.c_str());
170         return -1;
171         }
172
173     it->fd = pcap_get_selectable_fd(it->handle);
174     if (it->fd == -1)
175         {
176         errorStr = "Couldn't get a file descriptor for " + it->device + ": " + pcap_geterr(it->handle);
177         logger(errorStr);
178         printfd(__FILE__, "%s\n", errorStr.c_str());
179         return -1;
180         }
181
182     ++it;
183     }
184
185 nonstop = true;
186
187 if (pthread_create(&thread, NULL, Run, this))
188     {
189     errorStr = "Cannot create thread.";
190     logger("Cannot create thread.");
191     printfd(__FILE__, "Cannot create thread\n");
192     return -1;
193     }
194
195 return 0;
196 }
197 //-----------------------------------------------------------------------------
198 int PCAP_CAP::Stop()
199 {
200 if (!isRunning)
201     return 0;
202
203 nonstop = false;
204
205 //5 seconds to thread stops itself
206 for (int i = 0; i < 25 && isRunning; i++)
207     {
208     struct timespec ts = {0, 200000000};
209     nanosleep(&ts, NULL);
210     }
211 //after 5 seconds waiting thread still running. now killing it
212 if (isRunning)
213     {
214     if (pthread_kill(thread, SIGUSR1))
215         {
216         errorStr = "Cannot kill thread.";
217         logger("Cannot send signal to thread.");
218         return -1;
219         }
220     for (int i = 0; i < 25 && isRunning; ++i)
221         {
222         struct timespec ts = {0, 200000000};
223         nanosleep(&ts, NULL);
224         }
225     if (isRunning)
226         {
227         errorStr = "PCAP_CAP not stopped.";
228         logger("Cannot stop thread.");
229         printfd(__FILE__, "Cannot stop thread\n");
230         return -1;
231         }
232     }
233
234 pthread_join(thread, NULL);
235
236 for (DEV_MAP::iterator it(devices.begin()); it != devices.end(); ++it)
237     {
238     pcap_freecode(&it->filter);
239     pcap_close(it->handle);
240     }
241
242 return 0;
243 }
244 //-----------------------------------------------------------------------------
245 void * PCAP_CAP::Run(void * d)
246 {
247 sigset_t signalSet;
248 sigfillset(&signalSet);
249 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
250
251 PCAP_CAP * dc = static_cast<PCAP_CAP *>(d);
252 dc->isRunning = true;
253
254 fd_set fds;
255 FD_ZERO(&fds);
256 int maxFd = 0;
257 for (DEV_MAP::const_iterator it(dc->devices.begin()); it != dc->devices.end(); ++it)
258     {
259     FD_SET(it->fd, &fds);
260     maxFd = std::max(maxFd, it->fd);
261     }
262
263 while (dc->nonstop)
264     {
265     fd_set rfds = fds;
266     struct timeval tv = {0, 500000};
267
268     if (select(maxFd + 1, &rfds, NULL, NULL, &tv) > 0)
269         dc->TryRead(rfds);
270     }
271
272 dc->isRunning = false;
273 return NULL;
274 }
275
276 void PCAP_CAP::TryRead(const fd_set & set)
277 {
278 for (DEV_MAP::const_iterator it(devices.begin()); it != devices.end(); ++it)
279     if (FD_ISSET(it->fd, &set))
280         TryReadDev(*it);
281 }
282
283 void PCAP_CAP::TryReadDev(const DEV & dev)
284 {
285 struct pcap_pkthdr * header;
286 const u_char * packet;
287 if (pcap_next_ex(dev.handle, &header, &packet) == -1)
288     {
289     printfd(__FILE__, "Failed to read data from '%s': %s\n", dev.device.c_str(), pcap_geterr(dev.handle));
290     return;
291     }
292
293 const ETH * eth = reinterpret_cast<const ETH *>(packet);
294 if (eth->ether_type != 0x8)
295     return;
296
297 RAW_PACKET ip;
298 memcpy(&ip.rawPacket, packet + 14, sizeof(ip.rawPacket));
299 traffCnt->Process(ip);
300 }