]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/capture/pcap/pcap_cap.cpp
Verbose BLOWFISH_CTX failures.
[stg.git] / projects / stargazer / plugins / capture / pcap / pcap_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 * Author : Maxim Mamontov <faust@stargazer.dp.ua>
19 */
20
21 #include "pcap_cap.h"
22
23 #include "stg/traffcounter.h"
24 #include "stg/common.h"
25 #include "stg/raw_ip_packet.h"
26
27 #include <signal.h>
28
29 //-----------------------------------------------------------------------------
30 //-----------------------------------------------------------------------------
31 //-----------------------------------------------------------------------------
32 namespace
33 {
34
35 const size_t SNAP_LEN = 1518;
36 const size_t ETHER_ADDR_LEN = 6;
37
38 struct ETH
39 {
40 u_char     ether_dhost[ETHER_ADDR_LEN];    /* destination host address */
41 u_char     ether_shost[ETHER_ADDR_LEN];    /* source host address */
42 u_short    ether_type;                     /* IP? ARP? RARP? etc */
43 };
44
45 }
46
47 //-----------------------------------------------------------------------------
48 //-----------------------------------------------------------------------------
49 //-----------------------------------------------------------------------------
50 extern "C" STG::Plugin* GetPlugin()
51 {
52     static PCAP_CAP plugin;
53     return &plugin;
54 }
55 //-----------------------------------------------------------------------------
56 //-----------------------------------------------------------------------------
57 //-----------------------------------------------------------------------------
58 std::string PCAP_CAP::GetVersion() const
59 {
60 return "pcap_cap v.1.0";
61 }
62 //-----------------------------------------------------------------------------
63 PCAP_CAP::PCAP_CAP()
64     : isRunning(false),
65       traffCnt(NULL),
66       logger(STG::PluginLogger::get("pcap_cap"))
67 {
68 }
69 //-----------------------------------------------------------------------------
70 int PCAP_CAP::ParseSettings()
71 {
72 devices.erase(devices.begin(), devices.end());
73
74 if (settings.moduleParams.empty())
75     {
76     devices.push_back(DEV());
77     logger("Defaulting to pseudo-device 'any'.");
78     return 0;
79     }
80
81 for (size_t i = 0; i < settings.moduleParams.size(); i++)
82     if (settings.moduleParams[i].param == "interfaces")
83         for (size_t j = 0; j < settings.moduleParams[i].value.size(); j++)
84             devices.push_back(DEV(settings.moduleParams[i].value[j]));
85
86 for (size_t i = 0; i < settings.moduleParams.size(); i++)
87     if (settings.moduleParams[i].param == "filters")
88         for (size_t j = 0; j < settings.moduleParams[i].value.size(); j++)
89             if (j < devices.size())
90                 devices[j].filterExpression = settings.moduleParams[i].value[j];
91
92 if (devices.empty())
93     {
94     devices.push_back(DEV());
95     logger("Defaulting to pseudo-device 'all'.");
96     return 0;
97     }
98
99 return 0;
100 }
101 //-----------------------------------------------------------------------------
102 int PCAP_CAP::Start()
103 {
104 if (isRunning)
105     return 0;
106
107 DEV_MAP::iterator it(devices.begin());
108 while (it != devices.end())
109     {
110     bpf_u_int32 mask;
111     bpf_u_int32 net;
112     char errbuf[PCAP_ERRBUF_SIZE];
113
114     /* get network number and mask associated with capture device */
115     if (pcap_lookupnet(it->device.c_str(), &net, &mask, errbuf) == -1)
116         {
117         errorStr = "Couldn't get netmask for device " + it->device + ": " + errbuf;
118         logger(errorStr);
119         printfd(__FILE__, "%s\n", errorStr.c_str());
120         return -1;
121         }
122
123     /* open capture device */
124     it->handle = pcap_open_live(it->device.c_str(), SNAP_LEN, 1, 1000, errbuf);
125     if (it->handle == NULL)
126         {
127         errorStr = "Couldn't open device " + it->device + ": " + errbuf;
128         logger(errorStr);
129         printfd(__FILE__, "%s\n", errorStr.c_str());
130         return -1;
131         }
132
133     if (pcap_setnonblock(it->handle, true, errbuf) == -1)
134         {
135         errorStr = "Couldn't put device " + it->device + " into non-blocking mode: " + errbuf;
136         logger(errorStr);
137         printfd(__FILE__, "%s\n", errorStr.c_str());
138         return -1;
139         }
140
141     /* make sure we're capturing on an Ethernet device [2] */
142     if (pcap_datalink(it->handle) != DLT_EN10MB)
143         {
144         errorStr = it->device + " is not an Ethernet";
145         logger(errorStr);
146         printfd(__FILE__, "%s\n", errorStr.c_str());
147         return -1;
148         }
149
150     /* compile the filter expression */
151     if (pcap_compile(it->handle, &it->filter, it->filterExpression.c_str(), 0, net) == -1)
152         {
153         errorStr = "Couldn't parse filter " + it->filterExpression + ": " + pcap_geterr(it->handle);
154         logger(errorStr);
155         printfd(__FILE__, "%s\n", errorStr.c_str());
156         return -1;
157         }
158
159     /* apply the compiled filter */
160     if (pcap_setfilter(it->handle, &it->filter) == -1)
161         {
162         errorStr = "Couldn't install filter " + it->filterExpression + ": " + pcap_geterr(it->handle);
163         logger(errorStr);
164         printfd(__FILE__, "%s\n", errorStr.c_str());
165         return -1;
166         }
167
168     it->fd = pcap_get_selectable_fd(it->handle);
169     if (it->fd == -1)
170         {
171         errorStr = "Couldn't get a file descriptor for " + it->device + ": " + pcap_geterr(it->handle);
172         logger(errorStr);
173         printfd(__FILE__, "%s\n", errorStr.c_str());
174         return -1;
175         }
176
177     ++it;
178     }
179
180 m_thread = std::jthread([this](auto token){ Run(std::move(token)); });
181
182 return 0;
183 }
184 //-----------------------------------------------------------------------------
185 int PCAP_CAP::Stop()
186 {
187 if (!isRunning)
188     return 0;
189
190 m_thread.request_stop();
191
192 //5 seconds to thread stops itself
193 for (int i = 0; i < 25 && isRunning; i++)
194     {
195     struct timespec ts = {0, 200000000};
196     nanosleep(&ts, NULL);
197     }
198 //after 5 seconds waiting thread still running. now killing it
199 if (isRunning)
200     m_thread.detach();
201 else
202     m_thread.join();
203
204 for (DEV_MAP::iterator it(devices.begin()); it != devices.end(); ++it)
205     {
206     pcap_freecode(&it->filter);
207     pcap_close(it->handle);
208     }
209
210 return 0;
211 }
212 //-----------------------------------------------------------------------------
213 void PCAP_CAP::Run(std::stop_token token)
214 {
215 sigset_t signalSet;
216 sigfillset(&signalSet);
217 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
218
219 isRunning = true;
220
221 fd_set fds;
222 FD_ZERO(&fds);
223 int maxFd = 0;
224 for (DEV_MAP::const_iterator it(devices.begin()); it != devices.end(); ++it)
225     {
226     FD_SET(it->fd, &fds);
227     maxFd = std::max(maxFd, it->fd);
228     }
229
230 while (!token.stop_requested())
231     {
232     fd_set rfds = fds;
233     struct timeval tv = {0, 500000};
234
235     if (select(maxFd + 1, &rfds, NULL, NULL, &tv) > 0)
236         TryRead(rfds);
237     }
238
239 isRunning = false;
240 }
241
242 void PCAP_CAP::TryRead(const fd_set & set)
243 {
244 for (DEV_MAP::const_iterator it(devices.begin()); it != devices.end(); ++it)
245     if (FD_ISSET(it->fd, &set))
246         TryReadDev(*it);
247 }
248
249 void PCAP_CAP::TryReadDev(const DEV & dev)
250 {
251 struct pcap_pkthdr * header;
252 const u_char * packet;
253 if (pcap_next_ex(dev.handle, &header, &packet) == -1)
254     {
255     printfd(__FILE__, "Failed to read data from '%s': %s\n", dev.device.c_str(), pcap_geterr(dev.handle));
256     return;
257     }
258
259 const ETH * eth = reinterpret_cast<const ETH *>(packet);
260 if (eth->ether_type != 0x8)
261     return;
262
263 STG::RawPacket ip;
264 memcpy(&ip.rawPacket, packet + 14, sizeof(ip.rawPacket));
265 traffCnt->process(ip);
266 }