]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/capture/ether_freebsd/ether_cap.cpp
12d35aa696e4fe9b9ea6abcafbb70fe14397dcb4
[stg.git] / projects / stargazer / plugins / capture / ether_freebsd / ether_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 Date: 18.09.2002
19 */
20
21 /*
22 * Author : Boris Mikhailenko <stg34@stg.dp.ua>
23 */
24
25 /*
26 $Revision: 1.19 $
27 $Date: 2009/03/24 11:20:15 $
28 $Author: faust $
29 */
30
31 #include <sys/types.h>
32 #include <sys/uio.h>
33 #include <sys/socket.h>
34 #include <sys/time.h>
35 #include <sys/ioctl.h>
36 #include <sys/poll.h>
37
38 #include <net/bpf.h>
39 #include <net/if.h>
40 #include <netinet/in.h>
41 #include <arpa/inet.h>
42 #include <fcntl.h>
43 #include <unistd.h>
44
45 #include <cerrno>
46 #include <cstdio>
47 #include <cstring>
48 #include <cstdlib>
49 #include <csignal>
50
51 #include "stg/common.h"
52 #include "stg/raw_ip_packet.h"
53 #include "stg/traffcounter.h"
54 #include "stg/plugin_creator.h"
55
56 #include "ether_cap.h"
57
58 //#define CAP_DEBUG 1
59
60 //-----------------------------------------------------------------------------
61 //-----------------------------------------------------------------------------
62 //-----------------------------------------------------------------------------
63 namespace
64 {
65 PLUGIN_CREATOR<BPF_CAP> bcc;
66 }
67
68 extern "C" PLUGIN * GetPlugin();
69 //-----------------------------------------------------------------------------
70 //-----------------------------------------------------------------------------
71 //-----------------------------------------------------------------------------
72 PLUGIN * GetPlugin()
73 {
74 return bcc.GetPlugin();
75 }
76 //-----------------------------------------------------------------------------
77 //-----------------------------------------------------------------------------
78 //-----------------------------------------------------------------------------
79 int BPF_CAP_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
80 {
81 iface.erase(iface.begin(), iface.end());
82
83 if (s.moduleParams.empty())
84     {
85     errorStr = "Parameter \'iface\' not found.";
86     printfd(__FILE__, "Parameter 'iface' not found\n");
87     return -1;
88     }
89
90 for (unsigned i = 0; i < s.moduleParams.size(); i++)
91     {
92     if (s.moduleParams[i].param != "iface")
93         {
94         errorStr = "Parameter \'" + s.moduleParams[i].param + "\' unrecognized.";
95         printfd(__FILE__, "Invalid parameter: '%s'\n", s.moduleParams[i].param.c_str());
96         return -1;
97         }
98     for (unsigned j = 0; j < s.moduleParams[i].value.size(); j++)
99         {
100         iface.push_back(s.moduleParams[i].value[j]);
101         }
102     }
103
104 return 0;
105 }
106 //-----------------------------------------------------------------------------
107 std::string BPF_CAP_SETTINGS::GetIface(unsigned int num)
108 {
109 if (num >= iface.size())
110     {
111     return "";
112     }
113 return iface[num];
114 }
115 //-----------------------------------------------------------------------------
116 //-----------------------------------------------------------------------------
117 //-----------------------------------------------------------------------------
118 std::string BPF_CAP::GetVersion() const
119 {
120 return "bpf_cap v.1.0";
121 }
122 //-----------------------------------------------------------------------------
123 BPF_CAP::BPF_CAP()
124     : capSettings(),
125       errorStr(),
126       bpfData(),
127       polld(),
128       thread(),
129       nonstop(false),
130       isRunning(false),
131       capSock(-1),
132       settings(),
133       traffCnt(NULL),
134       logger(GetPluginLogger(GetStgLogger(), "cap_ether"))
135 {
136 }
137 //-----------------------------------------------------------------------------
138 int BPF_CAP::ParseSettings()
139 {
140 int ret = capSettings.ParseSettings(settings);
141 if (ret)
142     {
143     errorStr = capSettings.GetStrError();
144     return ret;
145     }
146 return 0;
147 }
148 //-----------------------------------------------------------------------------
149 int BPF_CAP::Start()
150 {
151 if (isRunning)
152     return 0;
153
154 if (BPFCapOpen() < 0)
155     {
156     //errorStr = "Cannot open bpf device!";
157     return -1;
158     }
159
160 nonstop = true;
161
162 if (pthread_create(&thread, NULL, Run, this))
163     {
164     errorStr = "Cannot create thread.";
165     logger("Cannot create thread.");
166     printfd(__FILE__, "Cannot create thread\n");
167     return -1;
168     }
169
170 return 0;
171 }
172 //-----------------------------------------------------------------------------
173 int BPF_CAP::Stop()
174 {
175 if (!isRunning)
176     return 0;
177
178 BPFCapClose();
179
180 nonstop = false;
181
182 //5 seconds to thread stops itself
183 int i;
184 for (i = 0; i < 25; i++)
185     {
186     if (!isRunning)
187         break;
188
189     struct timespec ts = {0, 200000000};
190     nanosleep(&ts, NULL);
191     }
192
193 //after 5 seconds waiting thread still running. now killing it
194 if (isRunning)
195     {
196     //TODO pthread_cancel()
197     if (pthread_kill(thread, SIGINT))
198         {
199         errorStr = "Cannot kill thread.";
200         logger("Cannot send signal to thread.");
201         printfd(__FILE__, "Cannot kill thread\n");
202         return -1;
203         }
204     }
205
206 return 0;
207 }
208 //-----------------------------------------------------------------------------
209 void * BPF_CAP::Run(void * d)
210 {
211 sigset_t signalSet;
212 sigfillset(&signalSet);
213 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
214
215 BPF_CAP * dc = static_cast<BPF_CAP *>(d);
216 dc->isRunning = true;
217
218 uint8_t hdr[96]; //68 + 14 + 4(size) + 9(SYS_IFACE) + 1(align to 4) = 96
219
220 RAW_PACKET *  rpp = (RAW_PACKET *)&hdr[14];
221 memset(hdr, 0, sizeof(hdr));
222
223 rpp->dataLen = -1;
224 char * iface;
225
226 while (dc->nonstop)
227     {
228     if (dc->BPFCapRead((char*)&hdr, 68 + 14, &iface))
229         continue;
230
231     if (!(hdr[12] == 0x8 && hdr[13] == 0x0))
232         continue;
233
234     dc->traffCnt->Process(*rpp);
235     }
236
237 dc->isRunning = false;
238 return NULL;
239 }
240 //-----------------------------------------------------------------------------
241 int BPF_CAP::BPFCapOpen()
242 {
243 int i = 0;
244 BPF_DATA bd;
245 pollfd pd;
246
247 while ((bd.iface = capSettings.GetIface(i)) != "")
248     {
249     bpfData.push_back(bd);
250     if (BPFCapOpen(&bpfData[i]) < 0)
251         {
252         return -1;
253         }
254
255     pd.events = POLLIN;
256     pd.fd = bpfData[i].fd;
257     polld.push_back(pd);
258     i++;
259     }
260
261 return 0;
262 }
263 //-----------------------------------------------------------------------------
264 int BPF_CAP::BPFCapOpen(BPF_DATA * bd)
265 {
266 char devbpf[20];
267 int i = 0;
268 int l = BUFF_LEN;
269 int im = 1;
270 struct ifreq ifr;
271
272 do
273     {
274     sprintf(devbpf, "/dev/bpf%d", i);
275     i++;
276     bd->fd = open(devbpf, O_RDONLY);
277     } while(bd->fd < 0 && errno == EBUSY);
278
279 if (bd->fd < 0)
280     {
281     errorStr = "Can't capture packets. Open bpf device for " + bd->iface + " error.";
282     logger("Cannot open device for interface '%s': %s", bd->iface.c_str(), strerror(errno));
283     printfd(__FILE__, "Cannot open BPF device\n");
284     return -1;
285     }
286
287 strncpy(ifr.ifr_name, bd->iface.c_str(), sizeof(ifr.ifr_name));
288
289 if (ioctl(bd->fd, BIOCSBLEN, (caddr_t)&l) < 0)
290     {
291     errorStr = bd->iface + " BIOCSBLEN " + std::string(strerror(errno));
292     logger("ioctl (BIOCSBLEN) error for interface '%s': %s", bd->iface, strerror(errno));
293     printfd(__FILE__, "ioctl failed: '%s'\n", errorStr.c_str());
294     return -1;
295     }
296
297 if (ioctl(bd->fd, BIOCSETIF, (caddr_t)&ifr) < 0)
298     {
299     errorStr = bd->iface + " BIOCSETIF " + std::string(strerror(errno));
300     logger("ioctl (BIOCSETIF) error for interface '%s': %s", bd->iface, strerror(errno));
301     printfd(__FILE__, "ioctl failed: '%s'\n", errorStr.c_str());
302     return -1;
303     }
304
305 if (ioctl(bd->fd, BIOCIMMEDIATE, &im) < 0)
306     {
307     errorStr = bd->iface + " BIOCIMMEDIATE " + std::string(strerror(errno));
308     logger("ioctl (BIOCIMMEDIATE) error for interface '%s': %s", bd->iface, strerror(errno));
309     printfd(__FILE__, "ioctl failed: '%s'\n", errorStr.c_str());
310     return -1;
311     }
312
313 return bd->fd;
314 }
315 //-----------------------------------------------------------------------------
316 int BPF_CAP::BPFCapClose()
317 {
318 for (unsigned int i = 0; i < bpfData.size(); i++)
319     close(bpfData[i].fd);
320 return 0;
321 }
322 //-----------------------------------------------------------------------------
323 int BPF_CAP::BPFCapRead(char * buffer, int blen, char ** capIface)
324 {
325 poll(&polld[0], polld.size(), -1);
326
327 for (unsigned int i = 0; i < polld.size(); i++)
328     {
329     if (polld[i].revents & POLLIN)
330         {
331         if (BPFCapRead(buffer, blen, capIface, &bpfData[i]))
332             {
333             polld[i].revents = 0;
334             continue;
335             }
336         polld[i].revents = 0;
337         return 0;
338         }
339     }
340 return -1;
341 }
342 //-----------------------------------------------------------------------------
343 int BPF_CAP::BPFCapRead(char * buffer, int blen, char **, BPF_DATA * bd)
344 {
345 if (bd->canRead)
346     {
347     bd->r = read(bd->fd, bd->buffer, BUFF_LEN);
348     if (bd->r < 0)
349         {
350         logger("read error: %s", strerror(errno));
351         struct timespec ts = {0, 20000000};
352         nanosleep(&ts, NULL);
353         return -1;
354         }
355
356     bd->p = bd->buffer;
357     bd->bh = (struct bpf_hdr*)bd->p;
358     bd->canRead = 0;
359     }
360
361 if(bd->r > bd->sum)
362     {
363     memcpy(buffer, (char*)(bd->p) + bd->bh->bh_hdrlen, blen);
364
365     bd->sum += BPF_WORDALIGN(bd->bh->bh_hdrlen + bd->bh->bh_caplen);
366     bd->p = bd->p + BPF_WORDALIGN(bd->bh->bh_hdrlen + bd->bh->bh_caplen);
367     bd->bh = (struct bpf_hdr*)bd->p;
368     }
369
370 if(bd->r <= bd->sum)
371     {
372     bd->canRead = 1;
373     bd->sum = 0;
374     }
375
376 return 0;
377 }
378 //-----------------------------------------------------------------------------