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