]> git.netwichtig.de Git - user/henk/code/inspircd.git/blob - src/connection.cpp
More fixes to class 'packet'
[user/henk/code/inspircd.git] / 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 <vector>
8 #include <string>
9 #include <deque>
10 #include "inspircd.h"
11 #include "modules.h"
12
13 using namespace std;
14
15 extern std::vector<Module*> modules;
16 extern std::vector<ircd_module*> factory;
17
18 extern int MODCOUNT;
19
20 connection::connection()
21 {
22         fd = 0;
23 }
24
25
26 bool connection::CreateListener(char* host, int p)
27 {
28         sockaddr_in host_address;
29         int flags;
30         in_addr addy;
31         int on = 0;
32         struct linger linger = { 0 };
33         
34         this->port = p;
35         
36         fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
37         if (fd <= 0)
38         {
39                 return false;
40         }
41
42         memset((void*)&host_address, 0, sizeof(host_address));
43
44         host_address.sin_family = AF_INET;
45
46         if (!strcmp(host,""))
47         {
48                 host_address.sin_addr.s_addr = htonl(INADDR_ANY);
49         }
50         else
51         {
52                 inet_aton(host,&addy);
53                 host_address.sin_addr = addy;
54         }
55
56         host_address.sin_port = htons(p);
57
58         if (bind(fd,(sockaddr*)&host_address,sizeof(host_address))<0)
59         {
60                 return false;
61         }
62
63         // make the socket non-blocking
64         flags = fcntl(fd, F_GETFL, 0);
65         fcntl(fd, F_SETFL, flags | O_NONBLOCK);
66
67         this->port = p;
68
69         setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,(const char*)&on,sizeof(on));
70         linger.l_onoff = 1;
71         linger.l_linger = 0;
72         setsockopt(fd,SOL_SOCKET,SO_LINGER,(const char*)&linger,sizeof(linger));
73         
74         // attempt to increase socket sendq and recvq as high as its possible
75         // to get them on linux.
76         int sendbuf = 32768;
77         int recvbuf = 32768;
78         setsockopt(fd,SOL_SOCKET,SO_SNDBUF,(const void *)&sendbuf,sizeof(sendbuf)); 
79         setsockopt(fd,SOL_SOCKET,SO_RCVBUF,(const void *)&recvbuf,sizeof(sendbuf));
80         
81         listen(this->fd,5);
82
83         return true;
84 }
85
86 char* ircd_connector::GetServerIP()
87 {
88         return this->host;
89 }
90
91 int ircd_connector::GetServerPort()
92 {
93         return this->port;
94 }
95
96 bool ircd_connector::SetHostAndPort(char* host, int port)
97 {
98         strncpy(this->host,host,160);
99         this->port = port;
100         return true;
101 }
102
103 bool ircd_connector::SetHostAddress(char* host, int port)
104 {
105         strncpy(this->host,host,160);
106         this->port = port;
107         memset((void*)&addr, 0, sizeof(addr));
108         addr.sin_family = AF_INET;
109         inet_aton(host,&addr.sin_addr);
110         addr.sin_port = htons(port);
111         return true;
112 }
113
114 void ircd_connector::SetServerPort(int p)
115 {
116         this->port = p;
117 }
118
119
120 bool ircd_connector::MakeOutboundConnection(char* host, int port)
121 {
122         hostent* hoste = gethostbyname(host);
123         if (!hoste)
124         {
125                 WriteOpers("Failed to look up hostname for %s, using as an ip address",host);
126                 this->SetHostAddress(host,port);
127                 SetHostAndPort(host,port);
128         }
129         else
130         {
131                 WriteOpers("Found hostname for %s",host);
132                 this->SetHostAddress(hoste->h_addr,port);
133                 SetHostAndPort(hoste->h_addr,port);
134         }
135
136         this->fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
137         if (this->fd >= 0)
138         {
139                 if(connect(this->fd, (sockaddr*)&addr,sizeof(addr)))
140                 {
141                         WriteOpers("connect() failed for %s",host);
142                         return false;
143                 }
144                 int flags = fcntl(this->fd, F_GETFL, 0);
145                 fcntl(this->fd, F_SETFL, flags | O_NONBLOCK);
146                 int sendbuf = 32768;
147                 int recvbuf = 32768;
148                 setsockopt(this->fd,SOL_SOCKET,SO_SNDBUF,(const void *)&sendbuf,sizeof(sendbuf)); 
149                 setsockopt(this->fd,SOL_SOCKET,SO_RCVBUF,(const void *)&recvbuf,sizeof(sendbuf));
150                 return true;
151         }
152         else
153         {
154                 WriteOpers("socket() failed!");
155         }
156
157         return false;
158 }
159
160
161 bool connection::BeginLink(char* targethost, int port, char* password, char* servername, int myport)
162 {
163         char connect[MAXBUF];
164         
165         ircd_connector connector;
166         
167         if (this->fd)
168         {
169                 if (connector.MakeOutboundConnection(targethost,port))
170                 {
171                         // targethost has been turned into an ip...
172                         // we dont want this as the server name.
173                         connector.SetServerName(servername);
174                         sprintf(connect,"S %s %s %d :%s",getservername().c_str(),password,myport,getserverdesc().c_str());
175                         connector.SetState(STATE_NOAUTH_OUTBOUND);
176                         connector.SetHostAndPort(targethost, port);
177                         this->connectors.push_back(connector);
178                         return this->SendPacket(connect, servername);
179                 }
180                 else
181                 {
182                         connector.SetState(STATE_DISCONNECTED);
183                         WriteOpers("Could not create outbound connection to %s:%d",targethost,port);
184                 }
185         }
186         return false;
187 }
188
189 bool connection::MeshCookie(char* targethost, int port, long cookie, char* servername)
190 {
191         char connect[MAXBUF];
192         
193         ircd_connector connector;
194         
195         WriteOpers("Establishing meshed link to %s:%d",servername,port);
196
197         if (this->fd)
198         {
199                 if (connector.MakeOutboundConnection(targethost,port))
200                 {
201                         // targethost has been turned into an ip...
202                         // we dont want this as the server name.
203                         connector.SetServerName(servername);
204                         sprintf(connect,"- %d %s :%s",cookie,getservername().c_str(),getserverdesc().c_str());
205                         connector.SetState(STATE_NOAUTH_OUTBOUND);
206                         connector.SetHostAndPort(targethost, port);
207                         connector.SetState(STATE_CONNECTED);
208                         this->connectors.push_back(connector);
209                         return this->SendPacket(connect, servername);
210                 }
211                 else
212                 {
213                         connector.SetState(STATE_DISCONNECTED);
214                         WriteOpers("Could not create outbound connection to %s:%d",targethost,port);
215                 }
216         }
217         return false;
218 }
219
220 bool connection::AddIncoming(int fd, char* targethost, int sourceport)
221 {
222         char connect[MAXBUF];
223         
224         ircd_connector connector;
225         
226         // targethost has been turned into an ip...
227         // we dont want this as the server name.
228         connector.SetServerName(targethost);
229         connector.SetDescriptor(fd);
230         connector.SetState(STATE_NOAUTH_INBOUND);
231         int flags = fcntl(fd, F_GETFL, 0);
232         fcntl(fd, F_SETFL, flags | O_NONBLOCK);
233         int sendbuf = 32768;
234         int recvbuf = 32768;
235         setsockopt(fd,SOL_SOCKET,SO_SNDBUF,(const void *)&sendbuf,sizeof(sendbuf)); 
236         setsockopt(fd,SOL_SOCKET,SO_RCVBUF,(const void *)&recvbuf,sizeof(sendbuf));
237         connector.SetHostAndPort(targethost, sourceport);
238         connector.SetState(STATE_NOAUTH_INBOUND);
239         log(DEBUG,"connection::AddIncoming() Added connection: %s:%d",targethost,sourceport);
240         this->connectors.push_back(connector);
241         return true;
242 }
243
244 void connection::TerminateLink(char* targethost)
245 {
246         // this locates the targethost in the connection::connectors vector of the class,
247         // and terminates it by sending it an SQUIT token and closing its descriptor.
248         // TerminateLink with a null string causes a terminate of ALL links
249 }
250
251
252 // Returns a pointer to the connector for 'host'
253 ircd_connector* connection::FindHost(std::string host)
254 {
255         for (int i = 0; i < this->connectors.size(); i++)
256         {
257                 if (this->connectors[i].GetServerName() == host)
258                 {
259                         return &this->connectors[i];
260                 }
261         }
262         return NULL;
263 }
264
265 std::string ircd_connector::GetServerName()
266 {
267         return this->servername;
268 }
269
270 std::string ircd_connector::GetDescription()
271 {
272         return this->description;
273 }
274
275 void ircd_connector::SetServerName(std::string serv)
276 {
277         this->servername = serv;
278 }
279
280 void ircd_connector::SetDescription(std::string desc)
281 {
282         this->servername = desc;
283 }
284
285
286 int ircd_connector::GetDescriptor()
287 {
288         return this->fd;
289 }
290
291 int ircd_connector::GetState()
292 {
293         return this->state;
294 }
295
296
297 void ircd_connector::SetState(int state)
298 {
299         this->state = state;
300         if (state == STATE_DISCONNECTED)
301         {
302                 NetSendMyRoutingTable();
303         }
304 }
305
306 void ircd_connector::CloseConnection()
307 {
308         int flags = fcntl(this->fd, F_GETFL, 0);
309         fcntl(this->fd, F_SETFL, flags ^ O_NONBLOCK);
310         close(this->fd);
311         flags = fcntl(this->fd, F_GETFL, 0);
312         fcntl(this->fd, F_SETFL, flags | O_NONBLOCK);
313 }
314
315 void ircd_connector::SetDescriptor(int fd)
316 {
317         this->fd = fd;
318 }
319
320 bool connection::SendPacket(char *message, const char* host)
321 {
322         ircd_connector* cn = this->FindHost(host);
323         
324         if (!strchr(message,'\n'))
325         {
326                 strncat(message,"\n",MAXBUF);
327         }
328
329         if (cn)
330         {
331                 log(DEBUG,"main: Connection::SendPacket() sent '%s' to %s",message,cn->GetServerName().c_str());
332                 
333                 if (cn->GetState() == STATE_DISCONNECTED)
334                 {
335                         log(DEBUG,"Main route to %s is down, seeking alternative",host);
336                         // this route is down, we must re-route the packet through an available point in the mesh.
337                         for (int k = 0; k < this->connectors.size(); k++)
338                         {
339                                 // search for another point in the mesh which can 'reach' where we want to go
340                                 for (int m = 0; m < this->connectors[k].routes.size(); m++)
341                                 {
342                                         if (!strcasecmp(this->connectors[k].routes[m].c_str(),host))
343                                         {
344                                                 log(DEBUG,"Found alternative route for packet: %s",this->connectors[k].GetServerName().c_str());
345                                                 char buffer[MAXBUF];
346                                                 snprintf(buffer,MAXBUF,"R %s %s",host,message);
347                                                 this->SendPacket(buffer,this->connectors[k].GetServerName().c_str());
348                                                 return true;
349                                         }
350                                 }
351                         }
352                         char buffer[MAXBUF];
353                         snprintf(buffer,MAXBUF,"& %s",host);
354                         NetSendToAllExcept(host,buffer);
355                         log(DEBUG,"There are no routes to %s, we're gonna boot the server off!",host);
356                         DoSplit(host);
357                         return false;
358                 }
359
360                 // returns false if the packet could not be sent (e.g. target host down)
361                 if (send(cn->GetDescriptor(),message,strlen(message),0)<0)
362                 {
363                         log(DEBUG,"send() failed for Connection::SendPacket(): %s",strerror(errno));
364                         log(DEBUG,"Disabling connector: %s",cn->GetServerName().c_str());
365                         cn->CloseConnection();
366                         cn->SetState(STATE_DISCONNECTED);
367                         return false;
368                 }
369                 return true;
370         }
371 }
372
373 // receives a packet from any where there is data waiting, first come, first served
374 // fills the message and host values with the host where the data came from.
375
376 bool connection::RecvPacket(std::deque<std::string> &messages, char* host)
377 {
378         char data[32767];
379         memset(data, 0, 32767);
380         for (int i = 0; i < this->connectors.size(); i++)
381         {
382                 if (this->connectors[i].GetState() != STATE_DISCONNECTED)
383                 {
384                         // returns false if the packet could not be sent (e.g. target host down)
385                         int rcvsize = 0;
386                         rcvsize = recv(this->connectors[i].GetDescriptor(),data,32767,0);
387                         if (rcvsize == -1)
388                         {
389                                 if (errno != EAGAIN)
390                                 {
391                                         log(DEBUG,"recv() failed for Connection::RecvPacket(): %s",strerror(errno));
392                                         log(DEBUG,"Disabling connector: %s",this->connectors[i].GetServerName().c_str());
393                                         this->connectors[i].CloseConnection();
394                                         this->connectors[i].SetState(STATE_DISCONNECTED);
395                                 }
396                         }
397                         if (rcvsize > 0)
398                         {
399                                 char* l = strtok(data,"\n");
400                                 while (l)
401                                 {
402                                         char sanitized[32767];
403                                         memset(sanitized, 0, 32767);
404                                         int ptt = 0;
405                                         for (int pt = 0; pt < strlen(l); pt++)
406                                         {
407                                                 if (l[pt] != '\r')
408                                                 {
409                                                         sanitized[ptt++] = l[pt];
410                                                 }
411                                         }
412                                         sanitized[ptt] = '\0';
413                                         if (strlen(sanitized))
414                                         {
415                                                 messages.push_back(sanitized);
416                                                 strncpy(host,this->connectors[i].GetServerName().c_str(),160);
417                                                 log(DEBUG,"main: Connection::RecvPacket() got '%s' from %s",sanitized,host);
418                                                 
419                                         }
420                                         l = strtok(NULL,"\n");
421                                 }
422                                 return true;
423                         }
424                 }
425         }
426         // nothing new yet -- message and host will be undefined
427         return false;
428 }
429
430 long connection::GenKey()
431 {
432         srand(time(NULL));
433         return (random()*time(NULL));
434 }
435