projects/stargazer/plugins/capture/ether_linux/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@stargazer.dp.ua>
  23 */
  24
  25 /*
  26 $Revision: 1.23 $
  27 $Date: 2009/12/13 13:45:13 $
  28 */
  29
  30
  31 #include <sys/socket.h>
  32 #include <arpa/inet.h>
  33 #include <netinet/in.h>
  34 #include <sys/types.h>
  35 #include <stdio.h>
  36 #include <string.h>
  37 #include <errno.h>
  38 #include <stdlib.h>
  39 #include <unistd.h>
  40 #include <linux/if_ether.h>
  41 #include <linux/if_packet.h>
  42 #include <signal.h>
  43
  44 #include <sys/ioctl.h>
  45 #include <net/if.h>
  46
  47 #include "ether_cap.h"
  48 #include "common.h"
  49 #include "raw_ip_packet.h"
  50
  51 //#define CAP_DEBUG 1
  52
  53
  54 //-----------------------------------------------------------------------------
  55 class ETHER_CAP_CREATOR
  56 {
  57 private:
  58     ETHER_CAP * ec;
  59
  60 public:
  61     ETHER_CAP_CREATOR()
  62         : ec(new ETHER_CAP())
  63         {
  64         };
  65     ~ETHER_CAP_CREATOR()
  66         {
  67         delete ec;
  68         };
  69
  70     ETHER_CAP * GetCapturer()
  71         {
  72         return ec;
  73         };
  74 };
  75 //-----------------------------------------------------------------------------
  76 //-----------------------------------------------------------------------------
  77 //-----------------------------------------------------------------------------
  78 ETHER_CAP_CREATOR ecc;
  79 //-----------------------------------------------------------------------------
  80 //-----------------------------------------------------------------------------
  81 //-----------------------------------------------------------------------------
  82 BASE_PLUGIN * GetPlugin()
  83 {
  84 return ecc.GetCapturer();
  85 }
  86 //-----------------------------------------------------------------------------
  87 //-----------------------------------------------------------------------------
  88 //-----------------------------------------------------------------------------
  89 const string ETHER_CAP::GetVersion() const
  90 {
  91 return "Ether_cap v.1.2";
  92 }
  93 //-----------------------------------------------------------------------------
  94 ETHER_CAP::ETHER_CAP()
  95 {
  96 isRunning = false;
  97 nonstop = false;
  98 }
  99 //-----------------------------------------------------------------------------
 100 void ETHER_CAP::SetTraffcounter(TRAFFCOUNTER * tc)
 101 {
 102 traffCnt = tc;
 103 }
 104 //-----------------------------------------------------------------------------
 105 const string & ETHER_CAP::GetStrError() const
 106 {
 107 return errorStr;
 108 }
 109 //-----------------------------------------------------------------------------
 110 int ETHER_CAP::Start()
 111 {
 112 if (isRunning)
 113     return 0;
 114
 115 if (EthCapOpen() < 0)
 116     {
 117     errorStr = "Cannot open socket!";
 118     printfd(__FILE__, "Cannot open socket\n");
 119     return -1;
 120     }
 121
 122 nonstop = true;
 123
 124 if (pthread_create(&thread, NULL, Run, this) == 0)
 125     {
 126     return 0;
 127     }
 128
 129 errorStr = "Cannot create thread.";
 130 printfd(__FILE__, "Cannot create thread\n");
 131 return -1;
 132 }
 133 //-----------------------------------------------------------------------------
 134 int ETHER_CAP::Stop()
 135 {
 136 if (!isRunning)
 137     return 0;
 138
 139 nonstop = false;
 140
 141 //5 seconds to thread stops itself
 142 for (int i = 0; i < 25 && isRunning; i++)
 143     {
 144     usleep(200000);
 145     }
 146 //after 5 seconds waiting thread still running. now killing it
 147 if (isRunning)
 148     {
 149     if (pthread_kill(thread, SIGUSR1))
 150         {
 151         errorStr = "Cannot kill thread.";
 152         return -1;
 153         }
 154     for (int i = 0; i < 25 && isRunning; ++i)
 155         usleep(200000);
 156     if (isRunning)
 157         {
 158         errorStr = "ETHER_CAP not stopped.";
 159         printfd(__FILE__, "Cannot stop thread\n");
 160         return -1;
 161         }
 162     else
 163         {
 164         pthread_join(thread, NULL);
 165         }
 166     }
 167
 168 EthCapClose();
 169 return 0;
 170 }
 171 //-----------------------------------------------------------------------------
 172 bool ETHER_CAP::IsRunning()
 173 {
 174 return isRunning;
 175 }
 176 //-----------------------------------------------------------------------------
 177 void * ETHER_CAP::Run(void * d)
 178 {
 179 ETHER_CAP * dc = (ETHER_CAP *)d;
 180 dc->isRunning = true;
 181
 182 struct ETH_IP
 183 {
 184 uint16_t    ethHdr[8];
 185 RAW_PACKET  rp;
 186 char        padding[4];
 187 char        padding1[8];
 188 };
 189
 190 ETH_IP * ethIP;
 191
 192 char ethip[sizeof(ETH_IP)];
 193
 194 memset(&ethip, 0, sizeof(ETH_IP));
 195
 196 ethIP = (ETH_IP *)&ethip;
 197 ethIP->rp.dataLen = -1;
 198
 199 char * iface = NULL;
 200
 201 while (dc->nonstop)
 202     {
 203     if (dc->EthCapRead(&ethip, 68 + 14, &iface))
 204         {
 205         continue;
 206         }
 207
 208     if (ethIP->ethHdr[7] != 0x8)
 209         continue;
 210
 211     dc->traffCnt->Process(ethIP->rp);
 212     }
 213
 214 dc->isRunning = false;
 215 return NULL;
 216 }
 217 //-----------------------------------------------------------------------------
 218 uint16_t ETHER_CAP::GetStartPosition() const
 219 {
 220 return 10;
 221 }
 222 //-----------------------------------------------------------------------------
 223 uint16_t ETHER_CAP::GetStopPosition() const
 224 {
 225 return 10;
 226 }
 227 //-----------------------------------------------------------------------------
 228 int ETHER_CAP::EthCapOpen()
 229 {
 230 capSock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
 231 return capSock;
 232 }
 233 //-----------------------------------------------------------------------------
 234 int ETHER_CAP::EthCapClose()
 235 {
 236 close(capSock);
 237 return 0;
 238 }
 239 //-----------------------------------------------------------------------------
 240 int ETHER_CAP::EthCapRead(void * buffer, int blen, char **)
 241 {
 242 struct sockaddr_ll  addr;
 243 int addrLen, res;
 244
 245 if (!WaitPackets(capSock))
 246     {
 247     return ENODATA;
 248     }
 249
 250 addrLen = sizeof(addr);
 251
 252 res = recvfrom(capSock, ((char*)buffer) + 2, blen, 0, (struct sockaddr *)&addr, (socklen_t*)&addrLen);
 253
 254 if (-1 == res)
 255     {
 256     if (errno != EINTR)
 257         {
 258         printfd(__FILE__, "Error on recvfrom: '%s'\n", strerror(errno));
 259         }
 260     return ENODATA;
 261     }
 262
 263 return 0;
 264 }
 265 //-----------------------------------------------------------------------------
 266 bool ETHER_CAP::WaitPackets(int sd) const
 267 {
 268 fd_set rfds;
 269 FD_ZERO(&rfds);
 270 FD_SET(sd, &rfds);
 271
 272 struct timeval tv;
 273 tv.tv_sec = 0;
 274 tv.tv_usec = 500000;
 275
 276 int res = select(sd + 1, &rfds, NULL, NULL, &tv);
 277 if (res == -1) // Error
 278     {
 279     if (errno != EINTR)
 280         {
 281         printfd(__FILE__, "Error on select: '%s'\n", strerror(errno));
 282         }
 283     return false;
 284     }
 285
 286 if (res == 0) // Timeout
 287     {
 288     return false;
 289     }
 290
 291 return true;
 292 }