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