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                 do
 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                 while ((recvfrom(fd,&p2,sizeof(p2),MSG_PEEK,(sockaddr*)&host_address,&host_address_size)<0) && (cycles < 10));
 164
 165                 if (cycles >= 10)
 166                 {
 167                         log(DEFAULT,"ERROR! connection::SendPacket() waited >10000 nanosecs for an ACK. Will resend up to 5 times");
 168                 }
 169                 else
 170                 {
 171                         if (p2.type != PT_ACK_ONLY)
 172                         {
 173                                 log(DEFAULT,"ERROR! connection::SendPacket() received a data response and was expecting a syn!!!");
 174                                 this->state = STATE_CLEAR;
 175                                 return true;
 176                         }
 177
 178                         if (p2.id != p.id)
 179                         {
 180                                 recvfrom(fd,&p2,sizeof(p2),0,(sockaddr*)&host_address,&host_address_size);
 181                                 log(DEFAULT,"ERROR! connection::SendPacket() received an ack for a packet it didnt send!");
 182                                 this->state = STATE_CLEAR;
 183                                 return false;
 184                         }
 185                         else
 186                         {
 187                                 recvfrom(fd,&p2,sizeof(p2),0,(sockaddr*)&host_address,&host_address_size);
 188                                 log(DEFAULT,"Successfully received ACK");
 189                                 this->state = STATE_CLEAR;
 190                                 return true;
 191                                 break;
 192                         }
 193                 }
 194         }
 195         log(DEFAULT,"We never received an ack. Something fishy going on, host is dead.");
 196         this->state = STATE_CLEAR;
 197         return false;
 198
 199 }
 200
 201 bool connection::SendSYN(char* host, int port)
 202 {
 203         sockaddr_in host_address;
 204         in_addr addy;
 205         packet p;
 206
 207         memset((void*)&host_address, 0, sizeof(host_address));
 208
 209         host_address.sin_family = AF_INET;
 210         inet_aton(host,&addy);
 211         host_address.sin_addr = addy;
 212
 213         host_address.sin_port = htons(port);
 214
 215         p.type = PT_SYN_ONLY;
 216         p.key = key;
 217         strcpy(p.data,"");
 218
 219         if (sendto(fd,&p,sizeof(p),0,(sockaddr*)&host_address,sizeof(host_address))<0)
 220         {
 221                 return false;
 222         }
 223         return true;
 224
 225 }
 226
 227 bool connection::SendACK(char* host, int port, int reply_id)
 228 {
 229         sockaddr_in host_address;
 230         in_addr addy;
 231         packet p;
 232
 233         memset((void*)&host_address, 0, sizeof(host_address));
 234
 235         host_address.sin_family = AF_INET;
 236         inet_aton(host,&addy);
 237         host_address.sin_addr = addy;
 238
 239         host_address.sin_port = htons(port);
 240
 241         p.type = PT_ACK_ONLY;
 242         p.key = key;
 243         p.id = reply_id;
 244         strcpy(p.data,"");
 245
 246         if (sendto(fd,&p,sizeof(p),0,(sockaddr*)&host_address,sizeof(host_address))<0)
 247         {
 248                 return false;
 249         }
 250
 251 }
 252
 253
 254 // Generates a server key. This is pseudo-random.
 255 // the server always uses the same server-key in all communications
 256 // across the network. All other servers must remember the server key
 257 // of servers in the network, e.g.:
 258 //
 259 // ServerA:  key=5555555555
 260 // ServerB:  key=6666666666
 261 // I am ServerC: key=77777777777
 262 //
 263 // If ServerC sees a packet from ServerA, and the key stored for ServerA
 264 // is 0, then cache the key as the servers key.
 265 // after this point, any packet from ServerA which does not contain its key,
 266 // 555555555, will be silently dropped.
 267 // This should prevent blind spoofing, as to fake a server you must know its
 268 // assigned key, and to do that you must receive messages that are origintated
 269 // from it or hack the running executable.
 270 //
 271 // During the AUTH phase (when server passwords are checked, the key in any
 272 // packet MUST be 0). Only the initial SERVER/PASS packets may have a key
 273 // of 0 (and any ACK responses to them).
 274 //
 275
 276 long connection::GenKey()
 277 {
 278         srand(time(NULL));
 279         return (random()*time(NULL));
 280 }
 281
 282 // host: in dot notation a.b.c.d
 283 // port: host byte order
 284 bool connection::RecvPacket(char *message, char* host, int &prt, long &theirkey)
 285 {
 286         // returns false if no packet waiting for receive, e.g. EAGAIN or ECONNRESET
 287         sockaddr_in host_address;
 288         socklen_t host_address_size;
 289         packet p;
 290
 291         memset((void*)&host_address, 0, sizeof(host_address));
 292
 293         host_address.sin_family=AF_INET;
 294         host_address_size=sizeof(host_address);
 295
 296         //int recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen);
 297         if (recvfrom(fd,&p,sizeof(p),0,(sockaddr*)&host_address,&host_address_size)<0)
 298         {
 299                 return false;
 300         }
 301
 302         log(DEBUG,"connection::RecvPacket(): received packet type %d '%s' from '%s'",p.type,p.data,inet_ntoa(host_address.sin_addr));
 303
 304         if (p.type == PT_SYN_ONLY)
 305         {
 306                 strcpy(message,p.data);
 307                 strcpy(host,inet_ntoa(host_address.sin_addr));
 308                 prt = ntohs(host_address.sin_port);
 309                 SendACK(host,this->port,p.id);
 310                 return false;
 311         }
 312
 313         if (p.type == PT_ACK_ONLY)
 314         {
 315                 strcpy(message,p.data);
 316                 strcpy(host,inet_ntoa(host_address.sin_addr));
 317                 prt = ntohs(host_address.sin_port);
 318                 this->state = STATE_CLEAR;
 319                 return false;
 320         }
 321
 322         if (p.type == PT_SYN_WITH_DATA)
 323         {
 324                 strcpy(message,p.data);
 325                 strcpy(host,inet_ntoa(host_address.sin_addr));
 326                 theirkey = p.key;
 327                 prt = ntohs(host_address.sin_port); // the port we received it on
 328                 SendACK(host,prt,p.id);
 329                 return true;
 330         }
 331
 332         log(DEBUG,"connection::RecvPacket(): Invalid packet type %d (protocol error)",p.type);
 333         return true;
 334 }
 335