src/connection.cpp

   1 #include <connection.h>
   2 #include <unistd.h>
   3 #include <fcntl.h>
   4 #include <sys/errno.h>
   5 #include <sys/ioctl.h>
   6 #include <sys/utsname.h>
   7 #include "inspircd.h"
   8 #include "modules.h"
   9
  10 extern std::vector<Module*> modules;
  11 extern std::vector<ircd_module*> factory;
  12
  13 extern int MODCOUNT;
  14
  15 #define STATE_CLEAR 1
  16 #define STATE_WAIT_FOR_ACK 2
  17
  18 packet::packet()
  19 {
  20         srand(time(NULL));
  21         id = random();
  22 }
  23
  24 packet::~packet()
  25 {
  26 }
  27
  28 connection::connection()
  29 {
  30         key = GenKey();
  31         fd = 0;
  32         state = STATE_CLEAR;
  33 }
  34
  35
  36 bool connection::CreateListener(char* host, int p)
  37 {
  38         sockaddr_in host_address;
  39         int flags;
  40         in_addr addy;
  41         int on = 0;
  42         struct linger linger = { 0 };
  43
  44         fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
  45         if (fd <= 0)
  46         {
  47                 return false;
  48         }
  49
  50         memset((void*)&host_address, 0, sizeof(host_address));
  51
  52         host_address.sin_family = AF_INET;
  53
  54         if (!strcmp(host,""))
  55         {
  56                 host_address.sin_addr.s_addr = htonl(INADDR_ANY);
  57         }
  58         else
  59         {
  60                 inet_aton(host,&addy);
  61                 host_address.sin_addr = addy;
  62         }
  63
  64         host_address.sin_port = htons(p);
  65
  66         if (bind(fd,(sockaddr*)&host_address,sizeof(host_address))<0)
  67         {
  68                 return false;
  69         }
  70
  71         // make the socket non-blocking
  72         flags = fcntl(fd, F_GETFL, 0);
  73         fcntl(fd, F_SETFL, flags | O_NONBLOCK);
  74
  75         this->port = p;
  76
  77     setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,(const char*)&on,sizeof(on));
  78     linger.l_onoff = 1;
  79     linger.l_linger = 0;
  80     setsockopt(fd,SOL_SOCKET,SO_LINGER,(const char*)&linger,sizeof(linger));
  81
  82         return true;
  83 }
  84
  85 bool connection::BeginLink(char* targethost, int port, char* password)
  86 {
  87         char connect[MAXBUF];
  88
  89         if (this->fd)
  90         {
  91                 sprintf(connect,"S %s %s :%s",getservername().c_str(),password,getserverdesc().c_str());
  92                 this->haspassed = false;
  93                 return this->SendPacket(connect, targethost, port, 0);
  94         }
  95         return false;
  96 }
  97
  98 // targethost: in dot notation a.b.c.d
  99 void connection::TerminateLink(char* targethost)
 100 {
 101 }
 102
 103 // host: in dot notation a.b.c.d
 104 // port: host byte order
 105 bool connection::SendPacket(char *message, char* host, int port, long ourkey)
 106 {
 107         sockaddr_in host_address;
 108         in_addr addy;
 109         packet p;
 110
 111         memset((void*)&host_address, 0, sizeof(host_address));
 112
 113         host_address.sin_family = AF_INET;
 114         inet_aton(host,&addy);
 115         host_address.sin_addr = addy;
 116
 117         host_address.sin_port = htons(port);
 118
 119         strcpy(p.data,message);
 120         p.type = PT_SYN_WITH_DATA;
 121         p.key = ourkey;
 122
 123
 124         FOREACH_MOD OnPacketTransmit(p.data);
 125
 126         log(DEBUG,"main: Connection::SendPacket() sent '%s' to %s:%d",p.data,host,port);
 127
 128         // returns false if the packet could not be sent (e.g. target host down)
 129         if (sendto(this->fd,&p,sizeof(p),0,(sockaddr*)&host_address,sizeof(host_address))<0)
 130         {
 131                 log(DEBUG,"sendto() failed for Connection::SendPacket() with a packet of size %d",sizeof(p));
 132                 return false;
 133         }
 134         this->state = STATE_WAIT_FOR_ACK;
 135
 136
 137         // host_address remains unchanged. we only want to receive from where we just sent the packet to.
 138
 139         // retry the packet up to 5 times
 140         for (int retries = 0; retries < 5; retries++)
 141         {
 142                 socklen_t host_address_size;
 143                 host_address.sin_family=AF_INET;
 144                 host_address_size=sizeof(host_address);
 145
 146                 // wait for ack, or timeout.
 147                 // if reached a timeout, send again.
 148                 // the packet id in the ack must match that in the original packet
 149                 // this MUST operate in lock/step fashion!!!
 150                 int cycles = 0;
 151                 packet p2;
 152                 while ((recvfrom(fd,&p2,sizeof(p2),0,(sockaddr*)&host_address,&host_address_size)<0) && (cycles < 10))
 153                 {
 154                         fd_set sfd;
 155                         timeval tval;
 156                         tval.tv_usec = 100;
 157                         tval.tv_sec = 0;
 158                         FD_ZERO(&sfd);
 159                         FD_SET(fd,&sfd);
 160                         int res = select(65535, &sfd, NULL, NULL, &tval);
 161                         cycles++;
 162                 }
 163                 if (cycles >= 10)
 164                 {
 165                         log(DEFAULT,"ERROR! connection::SendPacket() waited >1000 nanosecs for an ACK. Will resend up to 5 times");
 166                 }
 167                 else
 168                 {
 169                         if (p2.id != p.id)
 170                         {
 171                                 log(DEFAULT,"ERROR! connection::SendPacket() received an ack for a packet it didnt send!");
 172                                 this->state = STATE_CLEAR;
 173                                 return false;
 174                         }
 175                         else
 176                         {
 177                                 log(DEFAULT,"Successfully received ACK");
 178                                 this->state = STATE_CLEAR;
 179                                 return true;
 180                                 break;
 181                         }
 182                 }
 183         }
 184         log(DEFAULT,"We never received an ack. Something fishy going on, host is dead.");
 185         this->state = STATE_CLEAR;
 186         return false;
 187
 188 }
 189
 190 bool connection::SendSYN(char* host, int port)
 191 {
 192         sockaddr_in host_address;
 193         in_addr addy;
 194         packet p;
 195
 196         memset((void*)&host_address, 0, sizeof(host_address));
 197
 198         host_address.sin_family = AF_INET;
 199         inet_aton(host,&addy);
 200         host_address.sin_addr = addy;
 201
 202         host_address.sin_port = htons(port);
 203
 204         p.type = PT_SYN_ONLY;
 205         p.key = key;
 206         strcpy(p.data,"");
 207
 208         if (sendto(fd,&p,sizeof(p),0,(sockaddr*)&host_address,sizeof(host_address))<0)
 209         {
 210                 return false;
 211         }
 212         return true;
 213
 214 }
 215
 216 bool connection::SendACK(char* host, int port, int reply_id)
 217 {
 218         sockaddr_in host_address;
 219         in_addr addy;
 220         packet p;
 221
 222         memset((void*)&host_address, 0, sizeof(host_address));
 223
 224         host_address.sin_family = AF_INET;
 225         inet_aton(host,&addy);
 226         host_address.sin_addr = addy;
 227
 228         host_address.sin_port = htons(port);
 229
 230         p.type = PT_ACK_ONLY;
 231         p.key = key;
 232         p.id = reply_id;
 233         strcpy(p.data,"");
 234
 235         if (sendto(fd,&p,sizeof(p),0,(sockaddr*)&host_address,sizeof(host_address))<0)
 236         {
 237                 return false;
 238         }
 239
 240 }
 241
 242
 243 // Generates a server key. This is pseudo-random.
 244 // the server always uses the same server-key in all communications
 245 // across the network. All other servers must remember the server key
 246 // of servers in the network, e.g.:
 247 //
 248 // ServerA:  key=5555555555
 249 // ServerB:  key=6666666666
 250 // I am ServerC: key=77777777777
 251 //
 252 // If ServerC sees a packet from ServerA, and the key stored for ServerA
 253 // is 0, then cache the key as the servers key.
 254 // after this point, any packet from ServerA which does not contain its key,
 255 // 555555555, will be silently dropped.
 256 // This should prevent blind spoofing, as to fake a server you must know its
 257 // assigned key, and to do that you must receive messages that are origintated
 258 // from it or hack the running executable.
 259 //
 260 // During the AUTH phase (when server passwords are checked, the key in any
 261 // packet MUST be 0). Only the initial SERVER/PASS packets may have a key
 262 // of 0 (and any ACK responses to them).
 263 //
 264
 265 long connection::GenKey()
 266 {
 267         srand(time(NULL));
 268         return (random()*time(NULL));
 269 }
 270
 271 // host: in dot notation a.b.c.d
 272 // port: host byte order
 273 bool connection::RecvPacket(char *message, char* host, int &prt, long &theirkey)
 274 {
 275         // returns false if no packet waiting for receive, e.g. EAGAIN or ECONNRESET
 276         sockaddr_in host_address;
 277         socklen_t host_address_size;
 278         packet p;
 279
 280         memset((void*)&host_address, 0, sizeof(host_address));
 281
 282         host_address.sin_family=AF_INET;
 283         host_address_size=sizeof(host_address);
 284
 285         if (recvfrom(fd,&p,sizeof(p),0,(sockaddr*)&host_address,&host_address_size)<0)
 286         {
 287                 return false;
 288         }
 289
 290         log(DEBUG,"connection::RecvPacket(): received packet type %d '%s'",p.type,p.data);
 291
 292         if (p.type == PT_SYN_ONLY)
 293         {
 294                 strcpy(message,p.data);
 295                 strcpy(host,inet_ntoa(host_address.sin_addr));
 296                 prt = ntohs(host_address.sin_port);
 297                 SendACK(host,this->port,p.id);
 298                 return false;
 299         }
 300
 301         if (p.type == PT_ACK_ONLY)
 302         {
 303                 strcpy(message,p.data);
 304                 strcpy(host,inet_ntoa(host_address.sin_addr));
 305                 prt = ntohs(host_address.sin_port);
 306                 this->state = STATE_CLEAR;
 307                 return false;
 308         }
 309
 310         if (p.type == PT_SYN_WITH_DATA)
 311         {
 312                 strcpy(message,p.data);
 313                 strcpy(host,inet_ntoa(host_address.sin_addr));
 314                 theirkey = p.key;
 315                 prt = ntohs(host_address.sin_port);
 316                 SendACK(host,this->port,p.id);
 317                 return true;
 318         }
 319
 320         log(DEBUG,"connection::RecvPacket(): Invalid packet type %d (protocol error)",p.type);
 321         return true;
 322 }
 323