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