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