]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/capture/ether_freebsd/ether_cap.cpp
README converted from KOI8 to UTF8
[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 <string>
52 #include <vector>
53
54 #include "ether_cap.h"
55 #include "common.h"
56 #include "raw_ip_packet.h"
57
58 using namespace std;
59
60 //#define CAP_DEBUG 1
61 //-----------------------------------------------------------------------------
62
63 //-----------------------------------------------------------------------------
64 class BPF_CAP_CREATOR
65 {
66 private:
67     BPF_CAP * bpfc;
68
69 public:
70     BPF_CAP_CREATOR()
71         : bpfc(new BPF_CAP())
72         {
73         };
74     ~BPF_CAP_CREATOR()
75         {
76         delete bpfc;
77         };
78
79     BPF_CAP * GetCapturer()
80     {
81     return bpfc;
82     };
83 };
84 //-----------------------------------------------------------------------------
85 //-----------------------------------------------------------------------------
86 //-----------------------------------------------------------------------------
87 BPF_CAP_CREATOR bcc;
88 //-----------------------------------------------------------------------------
89 //-----------------------------------------------------------------------------
90 //-----------------------------------------------------------------------------
91 BASE_PLUGIN * GetPlugin()
92 {
93 return bcc.GetCapturer();
94 }
95 //-----------------------------------------------------------------------------
96 //-----------------------------------------------------------------------------
97 //-----------------------------------------------------------------------------
98 int BPF_CAP_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
99 {
100 //char sep[]= ", \t\n\r";
101 //char *s;
102 string ifaces;
103 //char * str;
104 //char *p;
105
106 iface.erase(iface.begin(), iface.end());
107
108 //PARAM_VALUE pv;
109 //pv.param = "WorkDir";
110 //vector<PARAM_VALUE>::const_iterator pvi;
111
112 if (s.moduleParams.empty())
113     {
114     errorStr = "Parameter \'iface\' not found.";
115     printfd(__FILE__, "Parameter 'iface' not found\n");
116     return -1;
117     }
118
119 for (unsigned i = 0; i < s.moduleParams.size(); i++)
120     {
121     if (s.moduleParams[i].param != "iface")
122         {
123         errorStr = "Parameter \'" + s.moduleParams[i].param + "\' unrecognized.";
124         printfd(__FILE__, "Invalid parameter: '%s'\n", s.moduleParams[i].param.c_str());
125         return -1;
126         }
127     for (unsigned j = 0; j < s.moduleParams[i].value.size(); j++)
128         {
129         iface.push_back(s.moduleParams[i].value[j]);
130         }
131     }
132
133 /*if (cf.ReadString("Iface", &ifaces, "NoIface") < 0)
134     {
135     errorStr = "Cannot read parameter \'Iface\' from " + cf.GetFileName();
136     return -1;
137     }
138
139 str = new char[ifaces.size() + 1];
140 strcpy(str, ifaces.c_str());
141 p = str;
142
143 while((s = strtok(p, sep)))
144     {
145     printfd(__FILE__, "iface[] = %s\n", s);
146     p = NULL;
147     iface.push_back(s);
148     //strncpy(iface[i++], s, DEV_NAME_LEN);
149     //devNum++;
150     }
151
152 delete[] str;
153 if (!ifaces.size())
154     {
155     errorStr = "Error read parameter \'Iface\' from " + cf.GetFileName();
156     return -1;
157     }*/
158
159 return 0;
160 }
161 //-----------------------------------------------------------------------------
162 string BPF_CAP_SETTINGS::GetIface(unsigned int num)
163 {
164 if (num >= iface.size())
165     {
166     return "";
167     }
168 return iface[num];
169 }
170 //-----------------------------------------------------------------------------
171 //-----------------------------------------------------------------------------
172 //-----------------------------------------------------------------------------
173 const string BPF_CAP::GetVersion() const
174 {
175 return "bpf_cap v.1.0";
176 }
177 //-----------------------------------------------------------------------------
178 BPF_CAP::BPF_CAP()
179     : nonstop(false),
180       isRunning(false),
181       capSock(-1),
182       traffCnt(NULL)
183 {
184 }
185 //-----------------------------------------------------------------------------
186 void BPF_CAP::SetSettings(const MODULE_SETTINGS & s)
187 {
188 settings = s;
189 }
190 //-----------------------------------------------------------------------------
191 int BPF_CAP::ParseSettings()
192 {
193 int ret = capSettings.ParseSettings(settings);
194 if (ret)
195     {
196     errorStr = capSettings.GetStrError();
197     return ret;
198     }
199 return 0;
200 }
201 //-----------------------------------------------------------------------------
202 void BPF_CAP::SetTraffcounter(TRAFFCOUNTER * tc)
203 {
204 traffCnt = tc;
205 }
206 //-----------------------------------------------------------------------------
207 const string & BPF_CAP::GetStrError() const
208 {
209 return errorStr;
210 }
211 //-----------------------------------------------------------------------------
212 int BPF_CAP::Start()
213 {
214 if (isRunning)
215     return 0;
216
217 if (BPFCapOpen() < 0)
218     {
219     //errorStr = "Cannot open bpf device!";
220     return -1;
221     }
222
223 nonstop = true;
224
225 if (pthread_create(&thread, NULL, Run, this) == 0)
226     {
227     return 0;
228     }
229
230 errorStr = "Cannot create thread.";
231 printfd(__FILE__, "Cannot create thread\n");
232 return -1;
233 }
234 //-----------------------------------------------------------------------------
235 int BPF_CAP::Stop()
236 {
237 if (!isRunning)
238     return 0;
239
240 BPFCapClose();
241
242 nonstop = false;
243
244 //5 seconds to thread stops itself
245 int i;
246 for (i = 0; i < 25; i++)
247     {
248     if (!isRunning)
249         break;
250
251     usleep(200000);
252     }
253
254 //after 5 seconds waiting thread still running. now killing it
255 if (isRunning)
256     {
257     //TODO pthread_cancel()
258     if (pthread_kill(thread, SIGINT))
259         {
260         errorStr = "Cannot kill thread.";
261         printfd(__FILE__, "Cannot kill thread\n");
262         return -1;
263         }
264     }
265
266 return 0;
267 }
268 //-----------------------------------------------------------------------------
269 bool BPF_CAP::IsRunning()
270 {
271 return isRunning;
272 }
273 //-----------------------------------------------------------------------------
274 void * BPF_CAP::Run(void * d)
275 {
276 BPF_CAP * dc = (BPF_CAP *)d;
277 dc->isRunning = true;
278
279 uint8_t hdr[96]; //68 + 14 + 4(size) + 9(SYS_IFACE) + 1(align to 4) = 96
280
281 RAW_PACKET *  rpp = (RAW_PACKET *)&hdr[14];
282 memset(hdr, 0, sizeof(hdr));
283
284 rpp->dataLen = -1;
285 char * iface;
286
287 while (dc->nonstop)
288     {
289     dc->BPFCapRead((char*)&hdr, 68 + 14, &iface);
290
291     if (!(hdr[12] == 0x8 && hdr[13] == 0x0))
292     {
293         continue;
294     }
295
296     dc->traffCnt->Process(*rpp);
297     }
298
299 dc->isRunning = false;
300 return NULL;
301 }
302 //-----------------------------------------------------------------------------
303 uint16_t BPF_CAP::GetStartPosition() const
304 {
305 return 0;
306 }
307 //-----------------------------------------------------------------------------
308 uint16_t BPF_CAP::GetStopPosition() const
309 {
310 return 0;
311 }
312 //-----------------------------------------------------------------------------
313 int BPF_CAP::BPFCapOpen()
314 {
315 //for (int i = 0; i < settings->devNum; i++)
316 int i = 0;
317 BPF_DATA bd;
318 pollfd pd;
319
320 while ((bd.iface = capSettings.GetIface(i)) != "")
321     {
322     bpfData.push_back(bd);
323     if (BPFCapOpen(&bpfData[i]) < 0)
324     {
325     return -1;
326     }
327
328     pd.events = POLLIN;
329     pd.fd = bpfData[i].fd;
330     polld.push_back(pd);
331     i++;
332     }
333
334 return 0;
335 }
336 //-----------------------------------------------------------------------------
337 //int BPF_CAP::BPFCapOpen(string ifaceToOpen)
338 int BPF_CAP::BPFCapOpen(BPF_DATA * bd)
339 {
340 char devbpf[20];
341 int i = 0;
342 int l = BUFF_LEN;
343 int im = 1;
344 struct ifreq ifr;
345
346 do  {
347     sprintf(devbpf, "/dev/bpf%d", i);
348     i++;
349     bd->fd = open(devbpf, O_RDONLY);
350     //cd[n].fd = open(devbpf, O_RDONLY);
351     } while(bd->fd < 0 && errno == EBUSY);
352       //while(cd[n].fd < 0 && errno == EBUSY);
353
354 //if (cd[n].fd < 0)
355 if (bd->fd < 0)
356     {
357     errorStr = "Can't capture packets. Open bpf device for " + bd->iface + " error.";
358     printfd(__FILE__, "Cannot open BPF device\n");
359     return -1;
360     }
361
362 //strncpy(ifr.ifr_name, settings->iface[n], sizeof(ifr.ifr_name));
363 strncpy(ifr.ifr_name, bd->iface.c_str(), sizeof(ifr.ifr_name));
364
365 //if (ioctl(cd[n].fd, BIOCSBLEN, (caddr_t)&l) < 0)
366 if (ioctl(bd->fd, BIOCSBLEN, (caddr_t)&l) < 0)
367     {
368     errorStr = bd->iface + " BIOCSBLEN " + string(strerror(errno));
369     printfd(__FILE__, "ioctl failed: '%s'\n", errorStr.c_str());
370     return -1;
371     }
372
373 //if (ioctl(cd[n].fd, BIOCSETIF, (caddr_t)&ifr) < 0 )
374 if (ioctl(bd->fd, BIOCSETIF, (caddr_t)&ifr) < 0)
375     {
376     errorStr = bd->iface + " BIOCSETIF " + string(strerror(errno));
377     printfd(__FILE__, "ioctl failed: '%s'\n", errorStr.c_str());
378     return -1;
379     }
380
381 //if (ioctl(cd[n].fd, BIOCIMMEDIATE, &im) < 0 )
382 if (ioctl(bd->fd, BIOCIMMEDIATE, &im) < 0)
383     {
384     errorStr = bd->iface + " BIOCIMMEDIATE " + string(strerror(errno));
385     printfd(__FILE__, "ioctl failed: '%s'\n", errorStr.c_str());
386     return -1;
387     }
388
389 return bd->fd;
390 //return 0;
391 }
392 //-----------------------------------------------------------------------------
393 int BPF_CAP::BPFCapClose()
394 {
395 for (unsigned int i = 0; i < bpfData.size(); i++)
396   close(bpfData[i].fd);
397 return 0;
398 }
399 //-----------------------------------------------------------------------------
400 int BPF_CAP::BPFCapRead(char * buffer, int blen, char ** capIface)
401 {
402 poll(&polld[0], polld.size(), -1);
403
404 for (unsigned int i = 0; i < polld.size(); i++)
405     {
406     if (polld[i].revents & POLLIN)
407         {
408         BPFCapRead(buffer, blen, capIface, &bpfData[i]);
409         polld[i].revents = 0;
410         return 0;
411         }
412     }
413 return 0;
414 }
415 //-----------------------------------------------------------------------------
416 int BPF_CAP::BPFCapRead(char * buffer, int blen, char **, BPF_DATA * bd)
417 {
418 if (bd->canRead)
419     {
420     bd->r = read(bd->fd, bd->buffer, BUFF_LEN);
421     if (bd->r < 0)
422         {
423         //printfd(__FILE__, " error read\n");
424         usleep(20000);
425         }
426
427     bd->p = bd->buffer;
428     bd->bh = (struct bpf_hdr*)bd->p;
429     bd->canRead = 0;
430     }
431
432 if(bd->r > bd->sum)
433     {
434     memcpy(buffer, (char*)(bd->p) + bd->bh->bh_hdrlen, blen);
435     //strncpy(iface, settings->iface[n], 9);
436     //*iface = settings->iface[n];
437
438     bd->sum += BPF_WORDALIGN(bd->bh->bh_hdrlen + bd->bh->bh_caplen);
439     bd->p = bd->p + BPF_WORDALIGN(bd->bh->bh_hdrlen + bd->bh->bh_caplen);
440     bd->bh = (struct bpf_hdr*)bd->p;
441     }
442
443 if(bd->r <= bd->sum)
444     {
445     bd->canRead = 1;
446     bd->sum = 0;
447     }
448
449 return 0;
450 }
451 //-----------------------------------------------------------------------------
452