projects/stargazer/plugins/capture/cap_nf/cap_nf.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: 16.05.2008
  19 */
  20
  21 /*
  22 * Author : Maxim Mamontov <faust@stg.dp.ua>
  23 */
  24
  25 /*
  26 $Revision: 1.11 $
  27 $Date: 2010/09/10 06:41:06 $
  28 $Author: faust $
  29 */
  30 #include <sys/types.h>
  31 #include <sys/socket.h>
  32 #include <netinet/in.h>
  33 #include <arpa/inet.h>
  34 #include <unistd.h>
  35
  36 #include <csignal>
  37 #include <cerrno>
  38 #include <cstring>
  39
  40 #include <vector>
  41
  42 #include "stg/common.h"
  43 #include "stg/raw_ip_packet.h"
  44 #include "stg/traffcounter.h"
  45 #include "stg/plugin_creator.h"
  46 #include "cap_nf.h"
  47
  48 PLUGIN_CREATOR<NF_CAP> cnc;
  49
  50 PLUGIN * GetPlugin()
  51 {
  52 return cnc.GetPlugin();
  53 }
  54
  55 NF_CAP::NF_CAP()
  56     : traffCnt(NULL),
  57       settings(),
  58       tidTCP(),
  59       tidUDP(),
  60       runningTCP(false),
  61       runningUDP(false),
  62       stoppedTCP(true),
  63       stoppedUDP(true),
  64       portT(0),
  65       portU(0),
  66       sockTCP(-1),
  67       sockUDP(-1),
  68       errorStr(),
  69       logger(GetPluginLogger(GetStgLogger(), "cap_nf"))
  70 {
  71 }
  72
  73 NF_CAP::~NF_CAP()
  74 {
  75 }
  76
  77 int NF_CAP::ParseSettings()
  78 {
  79 std::vector<PARAM_VALUE>::iterator it;
  80 for (it = settings.moduleParams.begin(); it != settings.moduleParams.end(); ++it)
  81     {
  82     if (it->param == "TCPPort")
  83         {
  84         if (str2x(it->value[0], portT))
  85             {
  86             errorStr = "Invalid TCPPort value";
  87             printfd(__FILE__, "Error: Invalid TCPPort value\n");
  88             return -1;
  89             }
  90         continue;
  91         }
  92     if (it->param == "UDPPort")
  93         {
  94         if (str2x(it->value[0], portU))
  95             {
  96             errorStr = "Invalid UDPPort value";
  97             printfd(__FILE__, "Error: Invalid UDPPort value\n");
  98             return -1;
  99             }
 100         continue;
 101         }
 102     printfd(__FILE__, "'%s' is not a valid module param\n", it->param.c_str());
 103     }
 104 return 0;
 105 }
 106
 107 int NF_CAP::Start()
 108 {
 109 if (portU > 0)
 110     {
 111     if (OpenUDP())
 112         {
 113         return -1;
 114         }
 115     runningUDP = true;
 116     if (pthread_create(&tidUDP, NULL, RunUDP, this))
 117         {
 118         runningUDP = false;
 119         CloseUDP();
 120         errorStr = "Cannot create UDP thread";
 121         printfd(__FILE__, "Error: Cannot create UDP thread\n");
 122         return -1;
 123         }
 124     }
 125 if (portT > 0)
 126     {
 127     if (OpenTCP())
 128         {
 129         return -1;
 130         }
 131     runningTCP = true;
 132     if (pthread_create(&tidTCP, NULL, RunTCP, this))
 133         {
 134         runningTCP = false;
 135         CloseTCP();
 136         errorStr = "Cannot create TCP thread";
 137         printfd(__FILE__, "Error: Cannot create TCP thread\n");
 138         return -1;
 139         }
 140     }
 141 return 0;
 142 }
 143
 144 int NF_CAP::Stop()
 145 {
 146 runningTCP = runningUDP = false;
 147 if (portU && !stoppedUDP)
 148     {
 149     CloseUDP();
 150     for (int i = 0; i < 25 && !stoppedUDP; ++i)
 151         {
 152         struct timespec ts = {0, 200000000};
 153         nanosleep(&ts, NULL);
 154         }
 155     if (stoppedUDP)
 156         {
 157         pthread_join(tidUDP, NULL);
 158         }
 159     else
 160         {
 161         if (pthread_kill(tidUDP, SIGUSR1))
 162             {
 163             errorStr = "Error sending signal to UDP thread";
 164             printfd(__FILE__, "Error: Error sending signal to UDP thread\n");
 165             return -1;
 166             }
 167         printfd(__FILE__, "UDP thread NOT stopped\n");
 168         }
 169     }
 170 if (portT && !stoppedTCP)
 171     {
 172     CloseTCP();
 173     for (int i = 0; i < 25 && !stoppedTCP; ++i)
 174         {
 175         struct timespec ts = {0, 200000000};
 176         nanosleep(&ts, NULL);
 177         }
 178     if (stoppedTCP)
 179         {
 180         pthread_join(tidTCP, NULL);
 181         }
 182     else
 183         {
 184         if (pthread_kill(tidTCP, SIGUSR1))
 185             {
 186             errorStr = "Error sending signal to TCP thread";
 187             printfd(__FILE__, "Error: Error sending signal to TCP thread\n");
 188             return -1;
 189             }
 190         printfd(__FILE__, "TCP thread NOT stopped\n");
 191         }
 192     }
 193 return 0;
 194 }
 195
 196 bool NF_CAP::OpenUDP()
 197 {
 198 struct sockaddr_in sin;
 199 sockUDP = socket(PF_INET, SOCK_DGRAM, 0);
 200 if (sockUDP <= 0)
 201     {
 202     errorStr = "Error opening UDP socket";
 203     printfd(__FILE__, "Error: Error opening UDP socket\n");
 204     return true;
 205     }
 206 sin.sin_family = AF_INET;
 207 sin.sin_port = htons(portU);
 208 sin.sin_addr.s_addr = inet_addr("0.0.0.0");
 209 if (bind(sockUDP, (struct sockaddr *)&sin, sizeof(sin)))
 210     {
 211     errorStr = "Error binding UDP socket";
 212     printfd(__FILE__, "Error: Error binding UDP socket\n");
 213     return true;
 214     }
 215 return false;
 216 }
 217
 218 bool NF_CAP::OpenTCP()
 219 {
 220 struct sockaddr_in sin;
 221 sockTCP = socket(PF_INET, SOCK_STREAM, 0);
 222 if (sockTCP <= 0)
 223     {
 224     errorStr = "Error opening TCP socket";
 225     printfd(__FILE__, "Error: Error opening TCP socket\n");
 226     return true;
 227     }
 228 sin.sin_family = AF_INET;
 229 sin.sin_port = htons(portT);
 230 sin.sin_addr.s_addr = inet_addr("0.0.0.0");
 231 if (bind(sockTCP, (struct sockaddr *)&sin, sizeof(sin)))
 232     {
 233     errorStr = "Error binding TCP socket";
 234     printfd(__FILE__, "Error: Error binding TCP socket\n");
 235     return true;
 236     }
 237 if (listen(sockTCP, 1))
 238     {
 239     errorStr = "Error listening on TCP socket";
 240     printfd(__FILE__, "Error: Error listening TCP socket\n");
 241     return true;
 242     }
 243 return false;
 244 }
 245
 246 void * NF_CAP::RunUDP(void * c)
 247 {
 248 sigset_t signalSet;
 249 sigfillset(&signalSet);
 250 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 251
 252 NF_CAP * cap = static_cast<NF_CAP *>(c);
 253 uint8_t buf[BUF_SIZE];
 254 int res;
 255 struct sockaddr_in sin;
 256 socklen_t slen;
 257 cap->stoppedUDP = false;
 258 while (cap->runningUDP)
 259     {
 260     if (!WaitPackets(cap->sockUDP))
 261         {
 262         continue;
 263         }
 264
 265     // Data
 266     slen = sizeof(sin);
 267     res = recvfrom(cap->sockUDP, buf, BUF_SIZE, 0, reinterpret_cast<struct sockaddr *>(&sin), &slen);
 268     if (!cap->runningUDP)
 269         break;
 270
 271     if (res == 0) // EOF
 272         {
 273         continue;
 274         }
 275
 276     if (res < 24)
 277         {
 278         if (errno != EINTR)
 279             {
 280             cap->errorStr = "Invalid data received";
 281             printfd(__FILE__, "Error: Invalid data received through UDP\n");
 282             }
 283         continue;
 284         }
 285
 286     cap->ParseBuffer(buf, res);
 287     }
 288 cap->stoppedUDP = true;
 289 return NULL;
 290 }
 291
 292 void * NF_CAP::RunTCP(void * c)
 293 {
 294 sigset_t signalSet;
 295 sigfillset(&signalSet);
 296 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 297
 298 NF_CAP * cap = static_cast<NF_CAP *>(c);
 299 uint8_t buf[BUF_SIZE];
 300 int res;
 301 int sd;
 302 struct sockaddr_in sin;
 303 socklen_t slen;
 304 cap->stoppedTCP = false;
 305 while (cap->runningTCP)
 306     {
 307     if (!WaitPackets(cap->sockTCP))
 308         {
 309         continue;
 310         }
 311
 312     // Data
 313     slen = sizeof(sin);
 314     sd = accept(cap->sockTCP, reinterpret_cast<struct sockaddr *>(&sin), &slen);
 315     if (!cap->runningTCP)
 316         break;
 317
 318     if (sd <= 0)
 319         {
 320         if (errno != EINTR)
 321             {
 322             cap->errorStr = "Error accepting connection";
 323             printfd(__FILE__, "Error: Error accepting connection\n");
 324             }
 325         continue;
 326         }
 327
 328     if (!WaitPackets(sd))
 329         {
 330         close(sd);
 331         continue;
 332         }
 333
 334     res = recv(sd, buf, BUF_SIZE, MSG_WAITALL);
 335     close(sd);
 336
 337     if (!cap->runningTCP)
 338         break;
 339
 340     if (res == 0) // EOF
 341         {
 342         continue;
 343         }
 344
 345     // Wrong logic!
 346     // Need to check actual data length and wait all data to receive
 347     if (res < 24)
 348         {
 349         if (errno != EINTR)
 350             {
 351             cap->errorStr = "Invalid data received";
 352             printfd(__FILE__, "Error: Invalid data received through TCP\n");
 353             }
 354         continue;
 355         }
 356
 357     cap->ParseBuffer(buf, res);
 358     }
 359 cap->stoppedTCP = true;
 360 return NULL;
 361 }
 362
 363 void NF_CAP::ParseBuffer(uint8_t * buf, int size)
 364 {
 365 RAW_PACKET ip;
 366 NF_HEADER * hdr = reinterpret_cast<NF_HEADER *>(buf);
 367 if (htons(hdr->version) != 5)
 368     {
 369     return;
 370     }
 371
 372 int packets = htons(hdr->count);
 373
 374 if (packets < 0 || packets > 30)
 375     {
 376     return;
 377     }
 378
 379 if (24 + 48 * packets != size)
 380     {
 381     // See 'wrong logic' upper
 382     return;
 383     }
 384
 385 for (int i = 0; i < packets; ++i)
 386     {
 387     NF_DATA * data = reinterpret_cast<NF_DATA *>(buf + 24 + i * 48);
 388
 389     ip.rawPacket.header.ipHeader.ip_v = 4;
 390     ip.rawPacket.header.ipHeader.ip_hl = 5;
 391     ip.rawPacket.header.ipHeader.ip_p = data->proto;
 392     ip.dataLen = ntohl(data->octets);
 393     ip.rawPacket.header.ipHeader.ip_src.s_addr = data->srcAddr;
 394     ip.rawPacket.header.ipHeader.ip_dst.s_addr = data->dstAddr;
 395     ip.rawPacket.header.sPort = data->srcPort;
 396     ip.rawPacket.header.dPort = data->dstPort;
 397
 398     traffCnt->Process(ip);
 399     }
 400 }