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