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