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 }