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