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
  43 #include <errno.h>
  44 #include <fcntl.h>
  45 #include <stdio.h>
  46 #include <string.h>
  47 #include <stdlib.h>
  48 #include <signal.h>
  49 #include <unistd.h>
  50
  51 #include "ether_cap.h"
  52 #include "common.h"
  53 #include "raw_ip_packet.h"
  54
  55 //#define CAP_DEBUG 1
  56 //-----------------------------------------------------------------------------
  57
  58 //-----------------------------------------------------------------------------
  59 class BPF_CAP_CREATOR {
  60 private:
  61     BPF_CAP * bpfc;
  62
  63 public:
  64     BPF_CAP_CREATOR()
  65         : bpfc(new BPF_CAP())
  66         {
  67         };
  68     ~BPF_CAP_CREATOR()
  69         {
  70         delete bpfc;
  71         };
  72
  73     BPF_CAP * GetCapturer()
  74     {
  75     return bpfc;
  76     };
  77 };
  78 //-----------------------------------------------------------------------------
  79 //-----------------------------------------------------------------------------
  80 //-----------------------------------------------------------------------------
  81 BPF_CAP_CREATOR bcc;
  82 //-----------------------------------------------------------------------------
  83 //-----------------------------------------------------------------------------
  84 //-----------------------------------------------------------------------------
  85 PLUGIN * GetPlugin()
  86 {
  87 return bcc.GetCapturer();
  88 }
  89 //-----------------------------------------------------------------------------
  90 //-----------------------------------------------------------------------------
  91 //-----------------------------------------------------------------------------
  92 int BPF_CAP_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
  93 {
  94 //char sep[]= ", \t\n\r";
  95 //char *s;
  96 std::string ifaces;
  97 //char * str;
  98 //char *p;
  99
 100 iface.erase(iface.begin(), iface.end());
 101
 102 //PARAM_VALUE pv;
 103 //pv.param = "WorkDir";
 104 //vector<PARAM_VALUE>::const_iterator pvi;
 105
 106 if (s.moduleParams.empty())
 107     {
 108     errorStr = "Parameter \'iface\' not found.";
 109     printfd(__FILE__, "Parameter 'iface' not found\n");
 110     return -1;
 111     }
 112
 113 for (unsigned i = 0; i < s.moduleParams.size(); i++)
 114     {
 115     if (s.moduleParams[i].param != "iface")
 116         {
 117         errorStr = "Parameter \'" + s.moduleParams[i].param + "\' unrecognized.";
 118         printfd(__FILE__, "Invalid parameter: '%s'\n", s.moduleParams[i].param.c_str());
 119         return -1;
 120         }
 121     for (unsigned j = 0; j < s.moduleParams[i].value.size(); j++)
 122         {
 123         iface.push_back(s.moduleParams[i].value[j]);
 124         }
 125     }
 126
 127 /*if (cf.ReadString("Iface", &ifaces, "NoIface") < 0)
 128     {
 129     errorStr = "Cannot read parameter \'Iface\' from " + cf.GetFileName();
 130     return -1;
 131     }
 132
 133 str = new char[ifaces.size() + 1];
 134 strcpy(str, ifaces.c_str());
 135 p = str;
 136
 137 while((s = strtok(p, sep)))
 138     {
 139     printfd(__FILE__, "iface[] = %s\n", s);
 140     p = NULL;
 141     iface.push_back(s);
 142     //strncpy(iface[i++], s, DEV_NAME_LEN);
 143     //devNum++;
 144     }
 145
 146 delete[] str;
 147 if (!ifaces.size())
 148     {
 149     errorStr = "Error read parameter \'Iface\' from " + cf.GetFileName();
 150     return -1;
 151     }*/
 152
 153 return 0;
 154 }
 155 //-----------------------------------------------------------------------------
 156 std::string BPF_CAP_SETTINGS::GetIface(unsigned int num)
 157 {
 158 if (num >= iface.size())
 159     {
 160     return "";
 161     }
 162 return iface[num];
 163 }
 164 //-----------------------------------------------------------------------------
 165 //-----------------------------------------------------------------------------
 166 //-----------------------------------------------------------------------------
 167 const std::string BPF_CAP::GetVersion() const
 168 {
 169 return "bpf_cap v.1.0";
 170 }
 171 //-----------------------------------------------------------------------------
 172 BPF_CAP::BPF_CAP()
 173     : nonstop(false),
 174       isRunning(false),
 175       capSock(-1),
 176       traffCnt(NULL)
 177 {
 178 }
 179 //-----------------------------------------------------------------------------
 180 void BPF_CAP::SetSettings(const MODULE_SETTINGS & s)
 181 {
 182 settings = s;
 183 }
 184 //-----------------------------------------------------------------------------
 185 int BPF_CAP::ParseSettings()
 186 {
 187 int ret = capSettings.ParseSettings(settings);
 188 if (ret)
 189     {
 190     errorStr = capSettings.GetStrError();
 191     return ret;
 192     }
 193 return 0;
 194 }
 195 //-----------------------------------------------------------------------------
 196 void BPF_CAP::SetTraffcounter(TRAFFCOUNTER * tc)
 197 {
 198 traffCnt = tc;
 199 }
 200 //-----------------------------------------------------------------------------
 201 const std::string & BPF_CAP::GetStrError() const
 202 {
 203 return errorStr;
 204 }
 205 //-----------------------------------------------------------------------------
 206 int BPF_CAP::Start()
 207 {
 208 if (isRunning)
 209     return 0;
 210
 211 if (BPFCapOpen() < 0)
 212     {
 213     //errorStr = "Cannot open bpf device!";
 214     return -1;
 215     }
 216
 217 nonstop = true;
 218
 219 if (pthread_create(&thread, NULL, Run, this) == 0)
 220     {
 221     return 0;
 222     }
 223
 224 errorStr = "Cannot create thread.";
 225 printfd(__FILE__, "Cannot create thread\n");
 226 return -1;
 227 }
 228 //-----------------------------------------------------------------------------
 229 int BPF_CAP::Stop()
 230 {
 231 if (!isRunning)
 232     return 0;
 233
 234 BPFCapClose();
 235
 236 nonstop = false;
 237
 238 //5 seconds to thread stops itself
 239 int i;
 240 for (i = 0; i < 25; i++)
 241     {
 242     if (!isRunning)
 243         break;
 244
 245     usleep(200000);
 246     }
 247
 248 //after 5 seconds waiting thread still running. now killing it
 249 if (isRunning)
 250     {
 251     //TODO pthread_cancel()
 252     if (pthread_kill(thread, SIGINT))
 253         {
 254         errorStr = "Cannot kill thread.";
 255         printfd(__FILE__, "Cannot kill thread\n");
 256         return -1;
 257         }
 258     }
 259
 260 return 0;
 261 }
 262 //-----------------------------------------------------------------------------
 263 bool BPF_CAP::IsRunning()
 264 {
 265 return isRunning;
 266 }
 267 //-----------------------------------------------------------------------------
 268 void * BPF_CAP::Run(void * d)
 269 {
 270 BPF_CAP * dc = (BPF_CAP *)d;
 271 dc->isRunning = true;
 272
 273 uint8_t hdr[96]; //68 + 14 + 4(size) + 9(SYS_IFACE) + 1(align to 4) = 96
 274
 275 RAW_PACKET *  rpp = (RAW_PACKET *)&hdr[14];
 276 memset(hdr, 0, sizeof(hdr));
 277
 278 rpp->dataLen = -1;
 279 char * iface;
 280
 281 while (dc->nonstop)
 282     {
 283     dc->BPFCapRead((char*)&hdr, 68 + 14, &iface);
 284
 285     if (!(hdr[12] == 0x8 && hdr[13] == 0x0))
 286     {
 287         continue;
 288     }
 289
 290     dc->traffCnt->Process(*rpp);
 291     }
 292
 293 dc->isRunning = false;
 294 return NULL;
 295 }
 296 //-----------------------------------------------------------------------------
 297 uint16_t BPF_CAP::GetStartPosition() const
 298 {
 299 return 0;
 300 }
 301 //-----------------------------------------------------------------------------
 302 uint16_t BPF_CAP::GetStopPosition() const
 303 {
 304 return 0;
 305 }
 306 //-----------------------------------------------------------------------------
 307 int BPF_CAP::BPFCapOpen()
 308 {
 309 //for (int i = 0; i < settings->devNum; i++)
 310 int i = 0;
 311 BPF_DATA bd;
 312 pollfd pd;
 313
 314 while ((bd.iface = capSettings.GetIface(i)) != "")
 315     {
 316     bpfData.push_back(bd);
 317     if (BPFCapOpen(&bpfData[i]) < 0)
 318     {
 319     return -1;
 320     }
 321
 322     pd.events = POLLIN;
 323     pd.fd = bpfData[i].fd;
 324     polld.push_back(pd);
 325     i++;
 326     }
 327
 328 return 0;
 329 }
 330 //-----------------------------------------------------------------------------
 331 //int BPF_CAP::BPFCapOpen(string ifaceToOpen)
 332 int BPF_CAP::BPFCapOpen(BPF_DATA * bd)
 333 {
 334 char devbpf[20];
 335 int i = 0;
 336 int l = BUFF_LEN;
 337 int im = 1;
 338 struct ifreq ifr;
 339
 340 do  {
 341     sprintf(devbpf, "/dev/bpf%d", i);
 342     i++;
 343     bd->fd = open(devbpf, O_RDONLY);
 344     //cd[n].fd = open(devbpf, O_RDONLY);
 345     } while(bd->fd < 0 && errno == EBUSY);
 346       //while(cd[n].fd < 0 && errno == EBUSY);
 347
 348 //if (cd[n].fd < 0)
 349 if (bd->fd < 0)
 350     {
 351     errorStr = "Can't capture packets. Open bpf device for " + bd->iface + " error.";
 352     printfd(__FILE__, "Cannot open BPF device\n");
 353     return -1;
 354     }
 355
 356 //strncpy(ifr.ifr_name, settings->iface[n], sizeof(ifr.ifr_name));
 357 strncpy(ifr.ifr_name, bd->iface.c_str(), sizeof(ifr.ifr_name));
 358
 359 //if (ioctl(cd[n].fd, BIOCSBLEN, (caddr_t)&l) < 0)
 360 if (ioctl(bd->fd, BIOCSBLEN, (caddr_t)&l) < 0)
 361     {
 362     errorStr = bd->iface + " BIOCSBLEN " + std::string(strerror(errno));
 363     printfd(__FILE__, "ioctl failed: '%s'\n", errorStr.c_str());
 364     return -1;
 365     }
 366
 367 //if (ioctl(cd[n].fd, BIOCSETIF, (caddr_t)&ifr) < 0 )
 368 if (ioctl(bd->fd, BIOCSETIF, (caddr_t)&ifr) < 0)
 369     {
 370     errorStr = bd->iface + " BIOCSETIF " + std::string(strerror(errno));
 371     printfd(__FILE__, "ioctl failed: '%s'\n", errorStr.c_str());
 372     return -1;
 373     }
 374
 375 //if (ioctl(cd[n].fd, BIOCIMMEDIATE, &im) < 0 )
 376 if (ioctl(bd->fd, BIOCIMMEDIATE, &im) < 0)
 377     {
 378     errorStr = bd->iface + " BIOCIMMEDIATE " + std::string(strerror(errno));
 379     printfd(__FILE__, "ioctl failed: '%s'\n", errorStr.c_str());
 380     return -1;
 381     }
 382
 383 return bd->fd;
 384 //return 0;
 385 }
 386 //-----------------------------------------------------------------------------
 387 int BPF_CAP::BPFCapClose()
 388 {
 389 for (unsigned int i = 0; i < bpfData.size(); i++)
 390   close(bpfData[i].fd);
 391 return 0;
 392 }
 393 //-----------------------------------------------------------------------------
 394 int BPF_CAP::BPFCapRead(char * buffer, int blen, char ** capIface)
 395 {
 396 poll(&polld[0], polld.size(), -1);
 397
 398 for (unsigned int i = 0; i < polld.size(); i++)
 399     {
 400     if (polld[i].revents & POLLIN)
 401         {
 402         BPFCapRead(buffer, blen, capIface, &bpfData[i]);
 403         polld[i].revents = 0;
 404         return 0;
 405         }
 406     }
 407 return 0;
 408 }
 409 //-----------------------------------------------------------------------------
 410 int BPF_CAP::BPFCapRead(char * buffer, int blen, char **, BPF_DATA * bd)
 411 {
 412 if (bd->canRead)
 413     {
 414     bd->r = read(bd->fd, bd->buffer, BUFF_LEN);
 415     if (bd->r < 0)
 416         {
 417         //printfd(__FILE__, " error read\n");
 418         usleep(20000);
 419         }
 420
 421     bd->p = bd->buffer;
 422     bd->bh = (struct bpf_hdr*)bd->p;
 423     bd->canRead = 0;
 424     }
 425
 426 if(bd->r > bd->sum)
 427     {
 428     memcpy(buffer, (char*)(bd->p) + bd->bh->bh_hdrlen, blen);
 429     //strncpy(iface, settings->iface[n], 9);
 430     //*iface = settings->iface[n];
 431
 432     bd->sum += BPF_WORDALIGN(bd->bh->bh_hdrlen + bd->bh->bh_caplen);
 433     bd->p = bd->p + BPF_WORDALIGN(bd->bh->bh_hdrlen + bd->bh->bh_caplen);
 434     bd->bh = (struct bpf_hdr*)bd->p;
 435     }
 436
 437 if(bd->r <= bd->sum)
 438     {
 439     bd->canRead = 1;
 440     bd->sum = 0;
 441     }
 442
 443 return 0;
 444 }
 445 //-----------------------------------------------------------------------------
 446