projects/stargazer/plugins/capture/divert_freebsd/divert_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 * Author : Boris Mikhailenko <stg34@stg.dp.ua>
  19 */
  20
  21 /*
  22 $Revision: 1.13 $
  23 $Date: 2010/09/10 06:43:03 $
  24 */
  25 #include <stdio.h>
  26 #include <sys/types.h>
  27 #include <sys/socket.h>
  28 #include <netinet/in.h>
  29 #include <string.h>
  30
  31 #include <sys/uio.h>
  32 #include <sys/time.h>
  33 #include <sys/ioctl.h>
  34 #include <sys/poll.h>
  35
  36 #include <errno.h>
  37 #include <fcntl.h>
  38 #include <stdlib.h>
  39 #include <signal.h>
  40 #include <unistd.h>
  41
  42 #include "common.h"
  43 #include "divert_cap.h"
  44
  45 #define BUFF_LEN (16384) /* max mtu -> lo=16436  TODO why?*/
  46
  47 //-----------------------------------------------------------------------------
  48 struct DIVERT_DATA
  49 {
  50 int sock;
  51 short int port;
  52 unsigned char buffer[BUFF_LEN];
  53 char iface[10];
  54 };
  55 //-----------------------------------------------------------------------------
  56 pollfd pollddiv;
  57 DIVERT_DATA cddiv;  //capture data
  58 //-----------------------------------------------------------------------------
  59 class DIVERT_CAP_CREATOR
  60 {
  61 private:
  62     DIVERT_CAP * divc;
  63
  64 public:
  65     DIVERT_CAP_CREATOR()
  66         : divc(new DIVERT_CAP())
  67         {
  68         };
  69     ~DIVERT_CAP_CREATOR()
  70         {
  71         delete divc;
  72         };
  73
  74     DIVERT_CAP * GetCapturer()
  75     {
  76     return divc;
  77     };
  78 };
  79 //-----------------------------------------------------------------------------
  80 //-----------------------------------------------------------------------------
  81 //-----------------------------------------------------------------------------
  82 DIVERT_CAP_CREATOR dcc;
  83 //-----------------------------------------------------------------------------
  84 //-----------------------------------------------------------------------------
  85 //-----------------------------------------------------------------------------
  86 BASE_PLUGIN * GetPlugin()
  87 {
  88 return dcc.GetCapturer();
  89 }
  90 //-----------------------------------------------------------------------------
  91 //-----------------------------------------------------------------------------
  92 //-----------------------------------------------------------------------------
  93 const string DIVERT_CAP::GetVersion() const
  94 {
  95 return "Divert_cap v.1.0";
  96 }
  97 //-----------------------------------------------------------------------------
  98 DIVERT_CAP::DIVERT_CAP()
  99     : port(0),
 100       nonstop(false),
 101       isRunning(false),
 102       traffCnt(NULL)
 103 {
 104 }
 105 //-----------------------------------------------------------------------------
 106 void DIVERT_CAP::SetTraffcounter(TRAFFCOUNTER * tc)
 107 {
 108 traffCnt = tc;
 109 }
 110 //-----------------------------------------------------------------------------
 111 const string & DIVERT_CAP::GetStrError() const
 112 {
 113 return errorStr;
 114 }
 115 //-----------------------------------------------------------------------------
 116 int DIVERT_CAP::Start()
 117 {
 118 if (isRunning)
 119     return 0;
 120
 121 if (DivertCapOpen() < 0)
 122     {
 123     errorStr = "Cannot open socket!";
 124     printfd(__FILE__, "Cannot open socket\n");
 125     return -1;
 126     }
 127
 128 nonstop = true;
 129
 130 if (pthread_create(&thread, NULL, Run, this) == 0)
 131     {
 132     return 0;
 133     }
 134
 135 errorStr = "Cannot create thread.";
 136 printfd(__FILE__, "Cannot create thread\n");
 137 return -1;
 138 }
 139 //-----------------------------------------------------------------------------
 140 int DIVERT_CAP::Stop()
 141 {
 142 if (!isRunning)
 143     return 0;
 144
 145 DivertCapClose();
 146
 147 nonstop = false;
 148
 149 //5 seconds to thread stops itself
 150 int i;
 151 for (i = 0; i < 25; i++)
 152     {
 153     if (!isRunning)
 154         break;
 155
 156     usleep(200000);
 157     }
 158
 159 //after 5 seconds waiting thread still running. now killing it
 160 if (isRunning)
 161     {
 162     if (pthread_kill(thread, SIGINT))
 163         {
 164         errorStr = "Cannot kill thread.";
 165         printfd(__FILE__, "Cannot kill thread\n");
 166         return -1;
 167         }
 168     }
 169
 170 return 0;
 171 }
 172 //-----------------------------------------------------------------------------
 173 bool DIVERT_CAP::IsRunning()
 174 {
 175 return isRunning;
 176 }
 177 //-----------------------------------------------------------------------------
 178 void * DIVERT_CAP::Run(void * d)
 179 {
 180 DIVERT_CAP * dc = (DIVERT_CAP *)d;
 181 dc->isRunning = true;
 182
 183 /*struct ETH_IP
 184 {
 185 uint16_t    ethHdr[8];
 186 RAW_PACKET  rp;
 187 char        padding[4];
 188 char        padding1[8];
 189 };
 190
 191 ETH_IP * ethIP;
 192
 193 char ethip[sizeof(ETH_IP)];
 194
 195 //memset(&ethIP, 0, sizeof(ethIP));
 196 memset(&ethip, 0, sizeof(ETH_IP));
 197
 198 ethIP = (ETH_IP *)&ethip;
 199 ethIP->rp.dataLen = -1;
 200 */
 201 //char * iface = NULL;
 202 char buffer[64];
 203 while (dc->nonstop)
 204     {
 205     RAW_PACKET rp;
 206     dc->DivertCapRead(buffer, 64, NULL);
 207
 208     //printf("%x %x %x %x \n", buffer[0], buffer[4], buffer[8], buffer[12]);
 209     //printf("%x %x %x %x \n", buffer[16], buffer[20], buffer[24], buffer[28]);
 210     //printf("%x %x %x %x \n", buffer[32], buffer[36], buffer[40], buffer[44]);
 211
 212     if (buffer[12] != 0x8)
 213         continue;
 214
 215     memcpy(rp.pckt, &buffer[14], pcktSize);
 216
 217     //dc->traffCnt->Process(*((RAW_PACKET*)( &buffer[14] ))); // - too dirty!
 218     dc->traffCnt->Process(rp);
 219     }
 220
 221 dc->isRunning = false;
 222 return NULL;
 223 }
 224 //-----------------------------------------------------------------------------
 225 uint16_t DIVERT_CAP::GetStartPosition() const
 226 {
 227 return 10;
 228 }
 229 //-----------------------------------------------------------------------------
 230 uint16_t DIVERT_CAP::GetStopPosition() const
 231 {
 232 return 10;
 233 }
 234 //-----------------------------------------------------------------------------
 235 /*****************************************************************************/
 236 /*****************************************************************************/
 237 /*****************************************************************************/
 238 /*****************************************************************************/
 239 /*****************************************************************************/
 240 //-----------------------------------------------------------------------------
 241 int DIVERT_CAP::DivertCapOpen()
 242 {
 243 memset(&pollddiv, 0, sizeof(pollddiv));
 244 memset(&cddiv, 0, sizeof(DIVERT_DATA));
 245
 246 strcpy(cddiv.iface, "foo");
 247 cddiv.port = port;
 248
 249 DivertCapOpen(0);
 250 pollddiv.events = POLLIN;
 251 pollddiv.fd = cddiv.sock;
 252
 253 return 0;
 254 }
 255 //-----------------------------------------------------------------------------
 256 int DIVERT_CAP::DivertCapOpen(int)
 257 {
 258 int ret;
 259 cddiv.sock = socket(PF_INET, SOCK_RAW, IPPROTO_DIVERT);
 260 if (cddiv.sock < 0)
 261     {
 262     errorStr = "Create divert socket error.";
 263     printfd(__FILE__, "Cannot create divert socket\n");
 264     return -1;
 265     }
 266
 267 struct sockaddr_in divAddr;
 268
 269 memset(&divAddr, 0, sizeof(divAddr));
 270
 271 divAddr.sin_family = AF_INET;
 272 divAddr.sin_port = htons(cddiv.port);
 273 divAddr.sin_addr.s_addr = INADDR_ANY;
 274
 275 ret = bind(cddiv.sock, (struct sockaddr *)&divAddr, sizeof(divAddr));
 276
 277 if (ret < 0)
 278     {
 279     errorStr = "Bind divert socket error.";
 280     printfd(__FILE__, "Cannot bind divert socket\n");
 281     return -1;
 282     }
 283
 284 return cddiv.sock;
 285 }
 286 //-----------------------------------------------------------------------------
 287 int DIVERT_CAP::DivertCapRead(char * b, int blen, char ** iface)
 288 {
 289 poll(&pollddiv, 1, -1);
 290
 291 if (pollddiv.revents & POLLIN)
 292     {
 293     DivertCapRead(b, blen, iface, 0);
 294     pollddiv.revents = 0;
 295     return 0;
 296     }
 297
 298 return 0;
 299 }
 300 //-----------------------------------------------------------------------------
 301 int DIVERT_CAP::DivertCapRead(char * b, int blen, char ** iface, int)
 302 {
 303 static char buf[BUFF_LEN];
 304 static struct sockaddr_in divertaddr;
 305 static int bytes;
 306 static socklen_t divertaddrSize = sizeof(divertaddr);
 307
 308 if ((bytes = recvfrom (cddiv.sock, buf, BUFF_LEN,
 309                        0, (struct sockaddr*) &divertaddr, &divertaddrSize)) > 50)
 310     {
 311     memcpy(b + 14, buf, blen - 14);
 312     b[12] = 0x8;
 313
 314     if (iface)
 315         *iface = cddiv.iface;
 316
 317     sendto(cddiv.sock, buf, bytes, 0, (struct sockaddr*)&divertaddr, divertaddrSize);
 318     }
 319
 320 return 0;
 321 }
 322 //-----------------------------------------------------------------------------
 323 int DIVERT_CAP::DivertCapClose()
 324 {
 325 close(cddiv.sock);
 326 return 0;
 327 }
 328 //-----------------------------------------------------------------------------
 329 int DIVERT_CAP::ParseSettings()
 330 {
 331 int p;
 332 PARAM_VALUE pv;
 333 vector<PARAM_VALUE>::const_iterator pvi;
 334
 335 pv.param = "Port";
 336 pvi = find(settings.moduleParams.begin(), settings.moduleParams.end(), pv);
 337 if (pvi == settings.moduleParams.end())
 338     {
 339     port = 15701;
 340     return 0;
 341     }
 342
 343 if (ParseIntInRange(pvi->value[0], 1, 65535, &p))
 344     {
 345     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
 346     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
 347     return -1;
 348     }
 349
 350 port = p;
 351
 352 return 0;
 353 }
 354 //-----------------------------------------------------------------------------
 355 int DIVERT_CAP::ParseIntInRange(const string & str, int min, int max, int * val)
 356 {
 357 if (str2x(str.c_str(), *val))
 358     {
 359     errorStr = "Incorrect value \'" + str + "\'.";
 360     return -1;
 361     }
 362 if (*val < min || *val > max)
 363     {
 364     errorStr = "Value \'" + str + "\' out of range.";
 365     return -1;
 366     }
 367 return 0;
 368 }
 369 //-----------------------------------------------------------------------------
 370 void DIVERT_CAP::SetSettings(const MODULE_SETTINGS & s)
 371 {
 372 settings = s;
 373 }
 374 //-----------------------------------------------------------------------------
 375