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