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