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