/[svn]/ircd-hybrid-7.2/src/s_serv.c
ViewVC logotype

Contents of /ircd-hybrid-7.2/src/s_serv.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 329 - (show annotations)
Sun Dec 25 10:45:42 2005 UTC (14 years, 7 months ago) by michael
File MIME type: text/x-chdr
File size: 69982 byte(s)
- Finish off TBURST (untested)

1 /*
2 * ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3 * s_serv.c: Server related functions.
4 *
5 * Copyright (C) 2005 by the past and present ircd coders, and others.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20 * USA
21 *
22 * $Id$
23 */
24
25 #include "stdinc.h"
26 #ifdef HAVE_LIBCRYPTO
27 #include <openssl/rsa.h>
28 #include "rsa.h"
29 #endif
30 #include "tools.h"
31 #include "channel.h"
32 #include "channel_mode.h"
33 #include "client.h"
34 #include "common.h"
35 #include "dbuf.h"
36 #include "event.h"
37 #include "fdlist.h"
38 #include "hash.h"
39 #include "irc_string.h"
40 #include "inet_misc.h"
41 #include "sprintf_irc.h"
42 #include "ircd.h"
43 #include "ircd_defs.h"
44 #include "s_bsd.h"
45 #include "irc_getnameinfo.h"
46 #include "list.h"
47 #include "numeric.h"
48 #include "packet.h"
49 #include "irc_res.h"
50 #include "s_conf.h"
51 #include "s_serv.h"
52 #include "s_log.h"
53 #include "s_stats.h"
54 #include "s_user.h"
55 #include "send.h"
56 #include "memory.h"
57 #include "channel.h" /* chcap_usage_counts stuff...*/
58
59 #define MIN_CONN_FREQ 300
60
61 struct Client *uplink = NULL;
62
63
64 static dlink_list cap_list = { NULL, NULL, 0 };
65 static unsigned long freeMask;
66 static void server_burst(struct Client *);
67 static int fork_server(struct Client *);
68 static void burst_all(struct Client *);
69 static void cjoin_all(struct Client *);
70 static void send_tb(struct Client *client_p, struct Channel *chptr);
71
72 static CNCB serv_connect_callback;
73
74 static void start_io(struct Client *);
75 static void burst_members(struct Client *, struct Channel *);
76 static void burst_ll_members(struct Client *, struct Channel *);
77 static void add_lazylinkchannel(struct Client *, struct Channel *);
78
79 static SlinkRplHnd slink_error;
80 static SlinkRplHnd slink_zipstats;
81
82
83 #ifdef HAVE_LIBCRYPTO
84 struct EncCapability CipherTable[] =
85 {
86 #ifdef HAVE_EVP_BF_CFB
87 { "BF/168", CAP_ENC_BF_168, 24, CIPHER_BF },
88 { "BF/128", CAP_ENC_BF_128, 16, CIPHER_BF },
89 #endif
90 #ifdef HAVE_EVP_CAST5_CFB
91 { "CAST/128", CAP_ENC_CAST_128, 16, CIPHER_CAST },
92 #endif
93 #ifdef HAVE_EVP_IDEA_CFB
94 { "IDEA/128", CAP_ENC_IDEA_128, 16, CIPHER_IDEA },
95 #endif
96 #ifdef HAVE_EVP_RC5_32_12_16_CFB
97 { "RC5.16/128", CAP_ENC_RC5_16_128, 16, CIPHER_RC5_16 },
98 { "RC5.12/128", CAP_ENC_RC5_12_128, 16, CIPHER_RC5_12 },
99 { "RC5.8/128", CAP_ENC_RC5_8_128, 16, CIPHER_RC5_8 },
100 #endif
101 #ifdef HAVE_EVP_DES_EDE3_CFB
102 { "3DES/168", CAP_ENC_3DES_168, 24, CIPHER_3DES },
103 #endif
104 #ifdef HAVE_EVP_DES_CFB
105 { "DES/56", CAP_ENC_DES_56, 8, CIPHER_DES },
106 #endif
107 { 0, 0, 0, 0 }
108 };
109 #endif
110
111 struct SlinkRplDef slinkrpltab[] = {
112 { SLINKRPL_ERROR, slink_error, SLINKRPL_FLAG_DATA },
113 { SLINKRPL_ZIPSTATS, slink_zipstats, SLINKRPL_FLAG_DATA },
114 { 0, 0, 0 },
115 };
116
117
118 void
119 slink_error(unsigned int rpl, unsigned int len, unsigned char *data,
120 struct Client *server_p)
121 {
122 assert(rpl == SLINKRPL_ERROR);
123 assert(len < 256);
124
125 data[len-1] = '\0';
126
127 sendto_realops_flags(UMODE_ALL, L_ALL, "SlinkError for %s: %s",
128 server_p->name, data);
129 /* XXX should this be exit_client? */
130 exit_client(server_p, &me, "servlink error -- terminating link");
131 }
132
133 void
134 slink_zipstats(unsigned int rpl, unsigned int len, unsigned char *data,
135 struct Client *server_p)
136 {
137 struct ZipStats zipstats;
138 unsigned long in = 0, in_wire = 0, out = 0, out_wire = 0;
139 int i = 0;
140
141 assert(rpl == SLINKRPL_ZIPSTATS);
142 assert(len == 16);
143 assert(IsCapable(server_p, CAP_ZIP));
144
145 /* Yes, it needs to be done this way, no we cannot let the compiler
146 * work with the pointer to the structure. This works around a GCC
147 * bug on SPARC that affects all versions at the time of this writing.
148 * I will feed you to the creatures living in RMS's beard if you do
149 * not leave this as is, without being sure that you are not causing
150 * regression for most of our installed SPARC base.
151 * -jmallett, 04/27/2002
152 */
153 memcpy(&zipstats, &server_p->localClient->zipstats, sizeof(struct ZipStats));
154
155 in |= (data[i++] << 24);
156 in |= (data[i++] << 16);
157 in |= (data[i++] << 8);
158 in |= (data[i++] );
159
160 in_wire |= (data[i++] << 24);
161 in_wire |= (data[i++] << 16);
162 in_wire |= (data[i++] << 8);
163 in_wire |= (data[i++] );
164
165 out |= (data[i++] << 24);
166 out |= (data[i++] << 16);
167 out |= (data[i++] << 8);
168 out |= (data[i++] );
169
170 out_wire |= (data[i++] << 24);
171 out_wire |= (data[i++] << 16);
172 out_wire |= (data[i++] << 8);
173 out_wire |= (data[i++] );
174
175 /* This macro adds b to a if a plus b is not an overflow, and sets the
176 * value of a to b if it is.
177 * Add and Set if No Overflow.
178 */
179 #define ASNO(a, b) a = (a + b >= a ? a + b : b)
180
181 ASNO(zipstats.in, in);
182 ASNO(zipstats.out, out);
183 ASNO(zipstats.in_wire, in_wire);
184 ASNO(zipstats.out_wire, out_wire);
185
186 if (zipstats.in > 0)
187 zipstats.in_ratio = (((double)(zipstats.in - zipstats.in_wire) /
188 (double)zipstats.in) * 100.00);
189 else
190 zipstats.in_ratio = 0;
191
192 if (zipstats.out > 0)
193 zipstats.out_ratio = (((double)(zipstats.out - zipstats.out_wire) /
194 (double)zipstats.out) * 100.00);
195 else
196 zipstats.out_ratio = 0;
197
198 memcpy(&server_p->localClient->zipstats, &zipstats, sizeof (struct ZipStats));
199 }
200
201 void
202 collect_zipstats(void *unused)
203 {
204 dlink_node *ptr;
205 struct Client *target_p;
206
207 DLINK_FOREACH(ptr, serv_list.head)
208 {
209 target_p = ptr->data;
210
211 if (IsCapable(target_p, CAP_ZIP))
212 {
213 /* only bother if we haven't already got something queued... */
214 if (!target_p->localClient->slinkq)
215 {
216 target_p->localClient->slinkq = MyMalloc(1); /* sigh.. */
217 target_p->localClient->slinkq[0] = SLINKCMD_ZIPSTATS;
218 target_p->localClient->slinkq_ofs = 0;
219 target_p->localClient->slinkq_len = 1;
220 send_queued_slink_write(target_p);
221 }
222 }
223 }
224 }
225
226 #ifdef HAVE_LIBCRYPTO
227 struct EncCapability *
228 check_cipher(struct Client *client_p, struct AccessItem *aconf)
229 {
230 struct EncCapability *epref = NULL;
231
232 /* Use connect{} specific info if available */
233 if (aconf->cipher_preference)
234 epref = aconf->cipher_preference;
235 else if (ConfigFileEntry.default_cipher_preference)
236 epref = ConfigFileEntry.default_cipher_preference;
237
238 /*
239 * If the server supports the capability in hand, return the matching
240 * conf struct. Otherwise, return NULL (an error).
241 */
242 if (epref && IsCapableEnc(client_p, epref->cap))
243 return epref;
244
245 return NULL;
246 }
247 #endif /* HAVE_LIBCRYPTO */
248
249 /* my_name_for_link()
250 * return wildcard name of my server name
251 * according to given config entry --Jto
252 */
253 const char *
254 my_name_for_link(struct ConfItem *conf)
255 {
256 struct AccessItem *aconf;
257
258 aconf = (struct AccessItem *)map_to_conf(conf);
259 if (aconf->fakename != NULL)
260 return(aconf->fakename);
261 else
262 return(me.name);
263 }
264
265 /*
266 * write_links_file
267 *
268 * inputs - void pointer which is not used
269 * output - NONE
270 * side effects - called from an event, write out list of linked servers
271 * but in no particular order.
272 */
273 void
274 write_links_file(void* notused)
275 {
276 MessageFileLine *next_mptr = 0;
277 MessageFileLine *mptr = 0;
278 MessageFileLine *currentMessageLine = 0;
279 MessageFileLine *newMessageLine = 0;
280 MessageFile *MessageFileptr;
281 const char *p;
282 FBFILE *file;
283 char buff[512];
284 dlink_node *ptr;
285
286 MessageFileptr = &ConfigFileEntry.linksfile;
287
288 if ((file = fbopen(MessageFileptr->fileName, "w")) == NULL)
289 return;
290
291 for (mptr = MessageFileptr->contentsOfFile; mptr; mptr = next_mptr)
292 {
293 next_mptr = mptr->next;
294 MyFree(mptr);
295 }
296
297 MessageFileptr->contentsOfFile = NULL;
298 currentMessageLine = NULL;
299
300 DLINK_FOREACH(ptr, global_serv_list.head)
301 {
302 size_t nbytes = 0;
303 struct Client *target_p = ptr->data;
304
305 /* skip ourselves, we send ourselves in /links */
306 if (IsMe(target_p))
307 continue;
308
309 /* skip hidden servers */
310 if (IsHidden(target_p) && !ConfigServerHide.disable_hidden)
311 continue;
312
313 if (target_p->info[0])
314 p = target_p->info;
315 else
316 p = "(Unknown Location)";
317
318 newMessageLine = MyMalloc(sizeof(MessageFileLine));
319
320 /* Attempt to format the file in such a way it follows the usual links output
321 * ie "servername uplink :hops info"
322 * Mostly for aesthetic reasons - makes it look pretty in mIRC ;)
323 * - madmax
324 */
325
326 /*
327 * For now, check this ircsprintf wont overflow - it shouldnt on a
328 * default config but it is configurable..
329 * This should be changed to an snprintf at some point, but I'm wanting to
330 * know if this is a cause of a bug - cryogen
331 */
332 assert(strlen(target_p->name) + strlen(me.name) + 6 + strlen(p) <=
333 MESSAGELINELEN);
334 ircsprintf(newMessageLine->line, "%s %s :1 %s",
335 target_p->name, me.name, p);
336 newMessageLine->next = NULL;
337
338 if (MessageFileptr->contentsOfFile)
339 {
340 if (currentMessageLine)
341 currentMessageLine->next = newMessageLine;
342 currentMessageLine = newMessageLine;
343 }
344 else
345 {
346 MessageFileptr->contentsOfFile = newMessageLine;
347 currentMessageLine = newMessageLine;
348 }
349
350 nbytes = ircsprintf(buff, "%s %s :1 %s\n", target_p->name, me.name, p);
351 fbputs(buff, file, nbytes);
352 }
353
354 fbclose(file);
355 }
356
357 /* hunt_server()
358 * Do the basic thing in delivering the message (command)
359 * across the relays to the specific server (server) for
360 * actions.
361 *
362 * Note: The command is a format string and *MUST* be
363 * of prefixed style (e.g. ":%s COMMAND %s ...").
364 * Command can have only max 8 parameters.
365 *
366 * server parv[server] is the parameter identifying the
367 * target server.
368 *
369 * *WARNING*
370 * parv[server] is replaced with the pointer to the
371 * real servername from the matched client (I'm lazy
372 * now --msa).
373 *
374 * returns: (see #defines)
375 */
376 int
377 hunt_server(struct Client *client_p, struct Client *source_p, const char *command,
378 int server, int parc, char *parv[])
379 {
380 struct Client *target_p = NULL;
381 struct Client *target_tmp = NULL;
382 dlink_node *ptr;
383 int wilds;
384
385 /* Assume it's me, if no server
386 */
387 if (parc <= server || EmptyString(parv[server]) ||
388 match(me.name, parv[server]) ||
389 match(parv[server], me.name) ||
390 !strcmp(parv[server], me.id))
391 return(HUNTED_ISME);
392
393 /* These are to pickup matches that would cause the following
394 * message to go in the wrong direction while doing quick fast
395 * non-matching lookups.
396 */
397 if (MyClient(source_p))
398 target_p = find_client(parv[server]);
399 else
400 target_p = find_person(client_p, parv[server]);
401
402 if (target_p)
403 if (target_p->from == source_p->from && !MyConnect(target_p))
404 target_p = NULL;
405
406 if (target_p == NULL && (target_p = find_server(parv[server])))
407 if (target_p->from == source_p->from && !MyConnect(target_p))
408 target_p = NULL;
409
410 collapse(parv[server]);
411 wilds = (strchr(parv[server], '?') || strchr(parv[server], '*'));
412
413 /* Again, if there are no wild cards involved in the server
414 * name, use the hash lookup
415 */
416 if (target_p == NULL)
417 {
418 if (!wilds)
419 {
420 if (!(target_p = find_server(parv[server])))
421 {
422 sendto_one(source_p, form_str(ERR_NOSUCHSERVER),
423 me.name, parv[0], parv[server]);
424 return(HUNTED_NOSUCH);
425 }
426 }
427 else
428 {
429 DLINK_FOREACH(ptr, global_client_list.head)
430 {
431 target_tmp = ptr->data;
432
433 if (match(parv[server], target_tmp->name))
434 {
435 if (target_tmp->from == source_p->from && !MyConnect(target_tmp))
436 continue;
437 target_p = ptr->data;
438
439 if (IsRegistered(target_p) && (target_p != client_p))
440 break;
441 }
442 }
443 }
444 }
445
446 if (target_p != NULL)
447 {
448 if(!IsRegistered(target_p))
449 {
450 sendto_one(source_p, form_str(ERR_NOSUCHSERVER),
451 me.name, parv[0], parv[server]);
452 return HUNTED_NOSUCH;
453 }
454
455 if (IsMe(target_p) || MyClient(target_p))
456 return HUNTED_ISME;
457
458 if (!match(target_p->name, parv[server]))
459 parv[server] = target_p->name;
460
461 /* Deal with lazylinks */
462 client_burst_if_needed(target_p, source_p);
463
464 /* This is a little kludgy but should work... */
465 if (IsClient(source_p) &&
466 ((MyConnect(target_p) && IsCapable(target_p, CAP_TS6)) ||
467 (!MyConnect(target_p) && IsCapable(target_p->from, CAP_TS6))))
468 parv[0] = ID(source_p);
469
470 sendto_one(target_p, command, parv[0],
471 parv[1], parv[2], parv[3], parv[4],
472 parv[5], parv[6], parv[7], parv[8]);
473 return(HUNTED_PASS);
474 }
475
476 sendto_one(source_p, form_str(ERR_NOSUCHSERVER),
477 me.name, parv[0], parv[server]);
478 return(HUNTED_NOSUCH);
479 }
480
481 /* try_connections()
482 *
483 * inputs - void pointer which is not used
484 * output - NONE
485 * side effects -
486 * scan through configuration and try new connections.
487 * Returns the calendar time when the next call to this
488 * function should be made latest. (No harm done if this
489 * is called earlier or later...)
490 */
491 void
492 try_connections(void *unused)
493 {
494 dlink_node *ptr;
495 struct ConfItem *conf;
496 struct AccessItem *aconf;
497 struct ClassItem *cltmp;
498 int confrq;
499
500 /* TODO: change this to set active flag to 0 when added to event! --Habeeb */
501 if (GlobalSetOptions.autoconn == 0)
502 return;
503
504 DLINK_FOREACH(ptr, server_items.head)
505 {
506 conf = ptr->data;
507 aconf = (struct AccessItem *)map_to_conf(conf);
508
509 /* Also when already connecting! (update holdtimes) --SRB
510 */
511 if (!(aconf->status & CONF_SERVER) || aconf->port <= 0 ||
512 !(IsConfAllowAutoConn(aconf)))
513 continue;
514
515 cltmp = (struct ClassItem *)map_to_conf(aconf->class_ptr);
516
517 /* Skip this entry if the use of it is still on hold until
518 * future. Otherwise handle this entry (and set it on hold
519 * until next time). Will reset only hold times, if already
520 * made one successfull connection... [this algorithm is
521 * a bit fuzzy... -- msa >;) ]
522 */
523 if (aconf->hold > CurrentTime)
524 continue;
525
526 if (cltmp == NULL)
527 confrq = DEFAULT_CONNECTFREQUENCY;
528 else
529 {
530 confrq = ConFreq(cltmp);
531 if (confrq < MIN_CONN_FREQ )
532 confrq = MIN_CONN_FREQ;
533 }
534
535 aconf->hold = CurrentTime + confrq;
536
537 /* Found a CONNECT config with port specified, scan clients
538 * and see if this server is already connected?
539 */
540 if (find_server(conf->name) != NULL)
541 continue;
542
543 if (CurrUserCount(cltmp) < MaxTotal(cltmp))
544 {
545 /* Go to the end of the list, if not already last */
546 if (ptr->next != NULL)
547 {
548 dlinkDelete(ptr, &server_items);
549 dlinkAddTail(conf, &conf->node, &server_items);
550 }
551
552 if (find_servconn_in_progress(conf->name))
553 return;
554
555 /* We used to only print this if serv_connect() actually
556 * succeeded, but since comm_tcp_connect() can call the callback
557 * immediately if there is an error, we were getting error messages
558 * in the wrong order. SO, we just print out the activated line,
559 * and let serv_connect() / serv_connect_callback() print an
560 * error afterwards if it fails.
561 * -- adrian
562 */
563 if (ConfigServerHide.hide_server_ips)
564 sendto_realops_flags(UMODE_ALL, L_ALL, "Connection to %s activated.",
565 conf->name);
566 else
567 sendto_realops_flags(UMODE_ALL, L_ALL, "Connection to %s[%s] activated.",
568 conf->name, aconf->host);
569
570 serv_connect(aconf, NULL);
571 /* We connect only one at time... */
572 return;
573 }
574 }
575 }
576
577 int
578 check_server(const char *name, struct Client *client_p, int cryptlink)
579 {
580 dlink_node *ptr;
581 struct ConfItem *conf = NULL;
582 struct ConfItem *server_conf = NULL;
583 struct AccessItem *server_aconf = NULL;
584 struct AccessItem *aconf = NULL;
585 int error = -1;
586
587 assert(client_p != NULL);
588
589 if (client_p == NULL)
590 return(error);
591
592 if (strlen(name) > HOSTLEN)
593 return(-4);
594
595 /* loop through looking for all possible connect items that might work */
596 DLINK_FOREACH(ptr, server_items.head)
597 {
598 conf = ptr->data;
599 aconf = (struct AccessItem *)map_to_conf(conf);
600
601 if (!match(name, conf->name))
602 continue;
603
604 error = -3;
605
606 /* XXX: Fix me for IPv6 */
607 /* XXX sockhost is the IPv4 ip as a string */
608 if (match(aconf->host, client_p->host) ||
609 match(aconf->host, client_p->sockhost))
610 {
611 error = -2;
612 #ifdef HAVE_LIBCRYPTO
613 if (cryptlink && IsConfCryptLink(aconf))
614 {
615 if (aconf->rsa_public_key)
616 server_conf = conf;
617 }
618 else if (!(cryptlink || IsConfCryptLink(aconf)))
619 #endif /* HAVE_LIBCRYPTO */
620 {
621 /* A NULL password is as good as a bad one */
622 if (EmptyString(client_p->localClient->passwd))
623 return(-2);
624
625 /* code in s_conf.c should not have allowed this to be NULL */
626 if (aconf->passwd == NULL)
627 return(-2);
628
629 if (IsConfEncrypted(aconf))
630 {
631 if (strcmp(aconf->passwd,
632 (const char *)crypt(client_p->localClient->passwd,
633 aconf->passwd)) == 0)
634 server_conf = conf;
635 }
636 else
637 {
638 if (strcmp(aconf->passwd, client_p->localClient->passwd) == 0)
639 server_conf = conf;
640 }
641 }
642 }
643 }
644
645 if (server_conf == NULL)
646 return(error);
647
648 attach_conf(client_p, server_conf);
649
650 /* Now find all leaf or hub config items for this server */
651 DLINK_FOREACH(ptr, hub_items.head)
652 {
653 conf = ptr->data;
654
655 if (!match(name, conf->name))
656 continue;
657 attach_conf(client_p, conf);
658 }
659
660 DLINK_FOREACH(ptr, leaf_items.head)
661 {
662 conf = ptr->data;
663
664 if (!match(name, conf->name))
665 continue;
666 attach_conf(client_p, conf);
667 }
668
669 server_aconf = (struct AccessItem *)map_to_conf(server_conf);
670
671 if (!IsConfLazyLink(server_aconf))
672 ClearCap(client_p, CAP_LL);
673 #ifdef HAVE_LIBZ /* otherwise, clear it unconditionally */
674 if (!IsConfCompressed(server_aconf))
675 #endif
676 ClearCap(client_p, CAP_ZIP);
677 if (!IsConfCryptLink(server_aconf))
678 ClearCap(client_p, CAP_ENC);
679 if (!IsConfTopicBurst(server_aconf))
680 {
681 ClearCap(client_p, CAP_TB);
682 ClearCap(client_p, CAP_TBURST);
683 }
684
685 /* Don't unset CAP_HUB here even if the server isn't a hub,
686 * it only indicates if the server thinks it's lazylinks are
687 * leafs or not.. if you unset it, bad things will happen
688 */
689 if (aconf != NULL)
690 {
691 struct sockaddr_in *v4;
692 #ifdef IPV6
693 struct sockaddr_in6 *v6;
694 #endif
695 switch (aconf->aftype)
696 {
697 #ifdef IPV6
698 case AF_INET6:
699 v6 = (struct sockaddr_in6 *)&aconf->ipnum;
700
701 if (IN6_IS_ADDR_UNSPECIFIED(&v6->sin6_addr))
702 memcpy(&aconf->ipnum, &client_p->localClient->ip, sizeof(struct irc_ssaddr));
703 break;
704 #endif
705 case AF_INET:
706 v4 = (struct sockaddr_in *)&aconf->ipnum;
707
708 if (v4->sin_addr.s_addr == INADDR_NONE)
709 memcpy(&aconf->ipnum, &client_p->localClient->ip, sizeof(struct irc_ssaddr));
710 break;
711 }
712 }
713
714 return(0);
715 }
716
717 /* add_capability()
718 *
719 * inputs - string name of CAPAB
720 * - int flag of capability
721 * output - NONE
722 * side effects - Adds given capability name and bit mask to
723 * current supported capabilities. This allows
724 * modules to dynamically add or subtract their capability.
725 */
726 void
727 add_capability(const char *capab_name, int cap_flag, int add_to_default)
728 {
729 struct Capability *cap;
730
731 cap = (struct Capability *)MyMalloc(sizeof(*cap));
732 DupString(cap->name, capab_name);
733 cap->cap = cap_flag;
734 dlinkAdd(cap, &cap->node, &cap_list);
735 if (add_to_default)
736 default_server_capabs |= cap_flag;
737 }
738
739 /* delete_capability()
740 *
741 * inputs - string name of CAPAB
742 * output - NONE
743 * side effects - delete given capability from ones known.
744 */
745 int
746 delete_capability(const char *capab_name)
747 {
748 dlink_node *ptr;
749 dlink_node *next_ptr;
750 struct Capability *cap;
751
752 DLINK_FOREACH_SAFE(ptr, next_ptr, cap_list.head)
753 {
754 cap = ptr->data;
755
756 if (cap->cap != 0)
757 {
758 if (irccmp(cap->name, capab_name) == 0)
759 {
760 default_server_capabs &= ~(cap->cap);
761 dlinkDelete(ptr, &cap_list);
762 MyFree(cap->name);
763 cap->name = NULL;
764 MyFree(cap);
765 }
766 }
767 }
768
769 return(0);
770 }
771
772 /*
773 * find_capability()
774 *
775 * inputs - string name of capab to find
776 * output - 0 if not found CAPAB otherwise
777 * side effects - none
778 */
779 int
780 find_capability(const char *capab)
781 {
782 dlink_node *ptr;
783 struct Capability *cap;
784
785 DLINK_FOREACH(ptr, cap_list.head)
786 {
787 cap = ptr->data;
788
789 if (cap->cap != 0)
790 {
791 if (irccmp(cap->name, capab) == 0)
792 return(cap->cap);
793 }
794 }
795 return(0);
796 }
797
798 /* send_capabilities()
799 *
800 * inputs - Client pointer to send to
801 * - Pointer to AccessItem (for crypt)
802 * - int flag of capabilities that this server can send
803 * - int flag of encryption capabilities
804 * output - NONE
805 * side effects - send the CAPAB line to a server -orabidoo
806 *
807 */
808 void
809 send_capabilities(struct Client *client_p, struct AccessItem *aconf,
810 int cap_can_send, int enc_can_send)
811 {
812 struct Capability *cap=NULL;
813 char msgbuf[IRCD_BUFSIZE];
814 char *t;
815 int tl;
816 dlink_node *ptr;
817 #ifdef HAVE_LIBCRYPTO
818 const struct EncCapability *epref = NULL;
819 char *capend;
820 int sent_cipher = 0;
821 #endif
822
823 t = msgbuf;
824
825 DLINK_FOREACH(ptr, cap_list.head)
826 {
827 cap = ptr->data;
828
829 if (cap->cap & (cap_can_send|default_server_capabs))
830 {
831 tl = ircsprintf(t, "%s ", cap->name);
832 t += tl;
833 }
834 }
835 #ifdef HAVE_LIBCRYPTO
836 if (enc_can_send)
837 {
838 capend = t;
839 strcpy(t, "ENC:");
840 t += 4;
841
842 /* use connect{} specific info if available */
843 if (aconf->cipher_preference)
844 epref = aconf->cipher_preference;
845 else if (ConfigFileEntry.default_cipher_preference)
846 epref = ConfigFileEntry.default_cipher_preference;
847
848 if (epref && (epref->cap & enc_can_send))
849 {
850 /* Leave the space -- it is removed later. */
851 tl = ircsprintf(t, "%s ", epref->name);
852 t += tl;
853 sent_cipher = 1;
854 }
855
856 if (!sent_cipher)
857 t = capend; /* truncate string before ENC:, below */
858 }
859 #endif
860 *(t - 1) = '\0';
861 sendto_one(client_p, "CAPAB :%s", msgbuf);
862 }
863
864 /* sendnick_TS()
865 *
866 * inputs - client (server) to send nick towards
867 * - client to send nick for
868 * output - NONE
869 * side effects - NICK message is sent towards given client_p
870 */
871 void
872 sendnick_TS(struct Client *client_p, struct Client *target_p)
873 {
874 static char ubuf[12];
875
876 if (!IsClient(target_p))
877 return;
878
879 send_umode(NULL, target_p, 0, IsOperHiddenAdmin(target_p) ?
880 SEND_UMODES & ~UMODE_ADMIN : SEND_UMODES, ubuf);
881
882 if (ubuf[0] == '\0')
883 {
884 ubuf[0] = '+';
885 ubuf[1] = '\0';
886 }
887
888 /* XXX Both of these need to have a :me.name or :mySID!?!?! */
889 if (HasID(target_p) && IsCapable(client_p, CAP_TS6))
890 sendto_one(client_p, ":%s UID %s %d %lu %s %s %s %s %s :%s",
891 target_p->servptr->id,
892 target_p->name, target_p->hopcount + 1,
893 (unsigned long) target_p->tsinfo,
894 ubuf, target_p->username, target_p->host,
895 ((MyClient(target_p)&&!IsIPSpoof(target_p))?target_p->sockhost:"0"),
896 target_p->id, target_p->info);
897 else
898 sendto_one(client_p, "NICK %s %d %lu %s %s %s %s :%s",
899 target_p->name, target_p->hopcount + 1,
900 (unsigned long) target_p->tsinfo,
901 ubuf, target_p->username, target_p->host,
902 target_p->servptr->name, target_p->info);
903 if (IsConfAwayBurst((struct AccessItem *)map_to_conf(client_p->serv->sconf)))
904 if (!EmptyString(target_p->away))
905 sendto_one(client_p, ":%s AWAY :%s", target_p->name,
906 target_p->away);
907
908 }
909
910 /* client_burst_if_needed()
911 *
912 * inputs - pointer to server
913 * - pointer to client to add
914 * output - NONE
915 * side effects - If this client is not known by this lazyleaf, send it
916 */
917 void
918 client_burst_if_needed(struct Client *client_p, struct Client *target_p)
919 {
920 if (!ServerInfo.hub)
921 return;
922 if (!MyConnect(client_p))
923 return;
924 if (!IsCapable(client_p,CAP_LL))
925 return;
926
927 if ((target_p->lazyLinkClientExists & client_p->localClient->serverMask) == 0)
928 {
929 sendnick_TS(client_p, target_p);
930 add_lazylinkclient(client_p,target_p);
931 }
932 }
933
934 /*
935 * show_capabilities - show current server capabilities
936 *
937 * inputs - pointer to a struct Client
938 * output - pointer to static string
939 * side effects - build up string representing capabilities of server listed
940 */
941 const char *
942 show_capabilities(struct Client *target_p)
943 {
944 static char msgbuf[IRCD_BUFSIZE];
945 char *t = msgbuf;
946 dlink_node *ptr;
947
948 t += ircsprintf(msgbuf, "TS ");
949
950 DLINK_FOREACH(ptr, cap_list.head)
951 {
952 const struct Capability *cap = ptr->data;
953
954 if (IsCapable(target_p, cap->cap))
955 t += ircsprintf(t, "%s ", cap->name);
956 }
957 #ifdef HAVE_LIBCRYPTO
958 if (IsCapable(target_p, CAP_ENC) &&
959 target_p->localClient->in_cipher &&
960 target_p->localClient->out_cipher)
961 t += ircsprintf(t, "ENC:%s ",
962 target_p->localClient->in_cipher->name);
963 #endif
964 *(t - 1) = '\0';
965
966 return(msgbuf);
967 }
968
969 /* make_server()
970 *
971 * inputs - pointer to client struct
972 * output - pointer to struct Server
973 * side effects - add's an Server information block to a client
974 * if it was not previously allocated.
975 */
976 struct Server *
977 make_server(struct Client *client_p)
978 {
979 if (client_p->serv == NULL)
980 {
981 client_p->serv = MyMalloc(sizeof(struct Server));
982 client_p->serv->dep_servers = 1;
983 }
984
985 return client_p->serv;
986 }
987
988 /* server_estab()
989 *
990 * inputs - pointer to a struct Client
991 * output -
992 * side effects -
993 */
994 void
995 server_estab(struct Client *client_p)
996 {
997 struct Client *target_p;
998 struct ConfItem *conf;
999 struct AccessItem *aconf=NULL;
1000 char *host;
1001 const char *inpath;
1002 static char inpath_ip[HOSTLEN * 2 + USERLEN + 6];
1003 dlink_node *m;
1004 dlink_node *ptr;
1005
1006 assert(client_p != NULL);
1007
1008 strlcpy(inpath_ip, get_client_name(client_p, SHOW_IP), sizeof(inpath_ip));
1009
1010 inpath = get_client_name(client_p, MASK_IP); /* "refresh" inpath with host */
1011 host = client_p->name;
1012
1013 if ((conf = find_conf_name(&client_p->localClient->confs, host, SERVER_TYPE))
1014 == NULL)
1015 {
1016 /* This shouldn't happen, better tell the ops... -A1kmm */
1017 sendto_realops_flags(UMODE_ALL, L_ALL, "Warning: Lost connect{} block "
1018 "for server %s(this shouldn't happen)!", host);
1019 exit_client(client_p, &me, "Lost connect{} block!");
1020 return;
1021 }
1022
1023 MyFree(client_p->localClient->passwd);
1024 client_p->localClient->passwd = NULL;
1025
1026 /* Its got identd, since its a server */
1027 SetGotId(client_p);
1028
1029 /* If there is something in the serv_list, it might be this
1030 * connecting server..
1031 */
1032 if (!ServerInfo.hub && serv_list.head)
1033 {
1034 if (client_p != serv_list.head->data || serv_list.head->next)
1035 {
1036 ServerStats->is_ref++;
1037 sendto_one(client_p, "ERROR :I'm a leaf not a hub");
1038 exit_client(client_p, &me, "I'm a leaf");
1039 return;
1040 }
1041 }
1042
1043 aconf = (struct AccessItem *)map_to_conf(conf);
1044
1045 if (IsUnknown(client_p) && !IsConfCryptLink(aconf))
1046 {
1047 /* jdc -- 1. Use EmptyString(), not [0] index reference.
1048 * 2. Check aconf->spasswd, not aconf->passwd.
1049 */
1050 if (!EmptyString(aconf->spasswd))
1051 {
1052 /* only send ts6 format PASS if we have ts6 enabled */
1053 if (me.id[0] != '\0') /* Send TS 6 form only if id */
1054 sendto_one(client_p, "PASS %s TS %d %s",
1055 aconf->spasswd, TS_CURRENT, me.id);
1056 else
1057 sendto_one(client_p, "PASS %s TS 5",
1058 aconf->spasswd);
1059 }
1060
1061 /* Pass my info to the new server
1062 *
1063 * If trying to negotiate LazyLinks, pass on CAP_LL
1064 * If this is a HUB, pass on CAP_HUB
1065 * Pass on ZIP if supported
1066 * Pass on TB if supported.
1067 * - Dianora
1068 */
1069
1070 send_capabilities(client_p, aconf, (ServerInfo.hub ? CAP_HUB : 0)
1071 | (IsConfLazyLink(aconf) ? CAP_LL : 0)
1072 | (IsConfCompressed(aconf) ? CAP_ZIP : 0)
1073 | (IsConfTopicBurst(aconf) ? CAP_TBURST|CAP_TB : 0), 0);
1074
1075 /* SERVER is the last command sent before switching to ziplinks.
1076 * We set TCPNODELAY on the socket to make sure it gets sent out
1077 * on the wire immediately. Otherwise, it could be sitting in
1078 * a kernel buffer when we start sending zipped data, and the
1079 * parser on the receiving side can't hand both unzipped and zipped
1080 * data in one packet. --Rodder
1081 *
1082 * currently we only need to call send_queued_write,
1083 * Nagle is already disabled at this point --adx
1084 */
1085 sendto_one(client_p, "SERVER %s 1 :%s%s",
1086 my_name_for_link(conf),
1087 ConfigServerHide.hidden ? "(H) " : "",
1088 (me.info[0]) ? (me.info) : "IRCers United");
1089 send_queued_write(client_p);
1090 }
1091
1092 /* Hand the server off to servlink now */
1093 if (IsCapable(client_p, CAP_ENC) || IsCapable(client_p, CAP_ZIP))
1094 {
1095 if (fork_server(client_p) < 0)
1096 {
1097 sendto_realops_flags(UMODE_ALL, L_ADMIN,
1098 "Warning: fork failed for server %s -- check servlink_path (%s)",
1099 get_client_name(client_p, HIDE_IP), ConfigFileEntry.servlink_path);
1100 sendto_realops_flags(UMODE_ALL, L_OPER, "Warning: fork failed for server "
1101 "%s -- check servlink_path (%s)",
1102 get_client_name(client_p, MASK_IP),
1103 ConfigFileEntry.servlink_path);
1104 exit_client(client_p, &me, "fork failed");
1105 return;
1106 }
1107
1108 start_io(client_p);
1109 SetServlink(client_p);
1110 }
1111
1112 /* only send ts6 format SVINFO if we have ts6 enabled */
1113 sendto_one(client_p, "SVINFO %d %d 0 :%lu",
1114 (me.id[0] ? TS_CURRENT : 5), TS_MIN,
1115 (unsigned long)CurrentTime);
1116
1117 /* assumption here is if they passed the correct TS version, they also passed an SID */
1118 if (IsCapable(client_p, CAP_TS6))
1119 hash_add_id(client_p);
1120
1121 /* XXX Does this ever happen? I don't think so -db */
1122 detach_conf(client_p, OPER_TYPE);
1123
1124 /* *WARNING*
1125 ** In the following code in place of plain server's
1126 ** name we send what is returned by get_client_name
1127 ** which may add the "sockhost" after the name. It's
1128 ** *very* *important* that there is a SPACE between
1129 ** the name and sockhost (if present). The receiving
1130 ** server will start the information field from this
1131 ** first blank and thus puts the sockhost into info.
1132 ** ...a bit tricky, but you have been warned, besides
1133 ** code is more neat this way... --msa
1134 */
1135 client_p->servptr = &me;
1136
1137 if (IsClosing(client_p))
1138 return;
1139
1140 SetServer(client_p);
1141
1142 /* Update the capability combination usage counts. -A1kmm */
1143 set_chcap_usage_counts(client_p);
1144
1145 /* Some day, all these lists will be consolidated *sigh* */
1146 dlinkAdd(client_p, &client_p->lnode, &me.serv->servers);
1147
1148 m = dlinkFind(&unknown_list, client_p);
1149 assert(NULL != m);
1150
1151 dlinkDelete(m, &unknown_list);
1152 dlinkAdd(client_p, m, &serv_list);
1153
1154 Count.myserver++;
1155
1156 dlinkAdd(client_p, make_dlink_node(), &global_serv_list);
1157 hash_add_client(client_p);
1158
1159 /* doesnt duplicate client_p->serv if allocated this struct already */
1160 make_server(client_p);
1161
1162 /* fixing eob timings.. -gnp */
1163 client_p->firsttime = CurrentTime;
1164
1165 /* Show the real host/IP to admins */
1166 sendto_realops_flags(UMODE_ALL, L_ADMIN,
1167 "Link with %s established: (%s) link",
1168 inpath_ip,show_capabilities(client_p));
1169 /* Now show the masked hostname/IP to opers */
1170 sendto_realops_flags(UMODE_ALL, L_OPER,
1171 "Link with %s established: (%s) link",
1172 inpath,show_capabilities(client_p));
1173 ilog(L_NOTICE, "Link with %s established: (%s) link",
1174 inpath_ip, show_capabilities(client_p));
1175
1176 client_p->serv->sconf = conf;
1177
1178 if (HasServlink(client_p))
1179 {
1180 /* we won't overflow FD_DESC_SZ here, as it can hold
1181 * client_p->name + 64
1182 */
1183 fd_note(&client_p->localClient->fd, "slink data: %s", client_p->name);
1184 fd_note(&client_p->localClient->ctrlfd, "slink ctrl: %s", client_p->name);
1185 }
1186 else
1187 fd_note(&client_p->localClient->fd, "Server: %s", client_p->name);
1188
1189 /* Old sendto_serv_but_one() call removed because we now
1190 ** need to send different names to different servers
1191 ** (domain name matching) Send new server to other servers.
1192 */
1193 DLINK_FOREACH(ptr, serv_list.head)
1194 {
1195 target_p = ptr->data;
1196
1197 if (target_p == client_p)
1198 continue;
1199
1200 if ((conf = target_p->serv->sconf) &&
1201 match(my_name_for_link(conf), client_p->name))
1202 continue;
1203
1204 if (IsCapable(target_p, CAP_TS6) && HasID(client_p))
1205 sendto_one(target_p, ":%s SID %s 2 %s :%s%s",
1206 me.id, client_p->name, client_p->id,
1207 IsHidden(client_p) ? "(H) " : "",
1208 client_p->info);
1209 else
1210 sendto_one(target_p,":%s SERVER %s 2 :%s%s",
1211 me.name, client_p->name,
1212 IsHidden(client_p) ? "(H) " : "",
1213 client_p->info);
1214 }
1215
1216 /* Pass on my client information to the new server
1217 **
1218 ** First, pass only servers (idea is that if the link gets
1219 ** cancelled beacause the server was already there,
1220 ** there are no NICK's to be cancelled...). Of course,
1221 ** if cancellation occurs, all this info is sent anyway,
1222 ** and I guess the link dies when a read is attempted...? --msa
1223 **
1224 ** Note: Link cancellation to occur at this point means
1225 ** that at least two servers from my fragment are building
1226 ** up connection this other fragment at the same time, it's
1227 ** a race condition, not the normal way of operation...
1228 **
1229 ** ALSO NOTE: using the get_client_name for server names--
1230 ** see previous *WARNING*!!! (Also, original inpath
1231 ** is destroyed...)
1232 */
1233
1234 conf = client_p->serv->sconf;
1235
1236 DLINK_FOREACH_PREV(ptr, global_serv_list.tail)
1237 {
1238 target_p = ptr->data;
1239
1240 /* target_p->from == target_p for target_p == client_p */
1241 if (target_p->from == client_p)
1242 continue;
1243
1244 if (match(my_name_for_link(conf), target_p->name))
1245 continue;
1246
1247 if (IsCapable(client_p, CAP_TS6))
1248 {
1249 if (HasID(target_p))
1250 sendto_one(client_p, ":%s SID %s %d %s :%s%s",
1251 ID(target_p->servptr), target_p->name, target_p->hopcount+1,
1252 target_p->id, IsHidden(target_p) ? "(H) " : "",
1253 target_p->info);
1254 else /* introducing non-ts6 server */
1255 sendto_one(client_p, ":%s SERVER %s %d :%s%s",
1256 ID(target_p->servptr), target_p->name, target_p->hopcount+1,
1257 IsHidden(target_p) ? "(H) " : "", target_p->info);
1258 }
1259 else
1260 sendto_one(client_p, ":%s SERVER %s %d :%s%s",
1261 target_p->servptr->name, target_p->name, target_p->hopcount+1,
1262 IsHidden(target_p) ? "(H) " : "", target_p->info);
1263 }
1264
1265 if ((ServerInfo.hub == 0) && MyConnect(client_p))
1266 uplink = client_p;
1267
1268 server_burst(client_p);
1269 }
1270
1271 static void
1272 start_io(struct Client *server)
1273 {
1274 struct LocalUser *lserver = server->localClient;
1275 int alloclen = 1;
1276 char *buf;
1277 dlink_node *ptr;
1278 struct dbuf_block *block;
1279
1280 /* calculate how many bytes to allocate */
1281 if (IsCapable(server, CAP_ZIP))
1282 alloclen += 6;
1283 #ifdef HAVE_LIBCRYPTO
1284 if (IsCapable(server, CAP_ENC))
1285 alloclen += 16 + lserver->in_cipher->keylen + lserver->out_cipher->keylen;
1286 #endif
1287 alloclen += dbuf_length(&lserver->buf_recvq);
1288 alloclen += dlink_list_length(&lserver->buf_recvq.blocks) * 3;
1289 alloclen += dbuf_length(&lserver->buf_sendq);
1290 alloclen += dlink_list_length(&lserver->buf_sendq.blocks) * 3;
1291
1292 /* initialize servlink control sendq */
1293 lserver->slinkq = buf = MyMalloc(alloclen);
1294 lserver->slinkq_ofs = 0;
1295 lserver->slinkq_len = alloclen;
1296
1297 if (IsCapable(server, CAP_ZIP))
1298 {
1299 /* ziplink */
1300 *buf++ = SLINKCMD_SET_ZIP_OUT_LEVEL;
1301 *buf++ = 0; /* | */
1302 *buf++ = 1; /* \ len is 1 */
1303 *buf++ = ConfigFileEntry.compression_level;
1304 *buf++ = SLINKCMD_START_ZIP_IN;
1305 *buf++ = SLINKCMD_START_ZIP_OUT;
1306 }
1307 #ifdef HAVE_LIBCRYPTO
1308 if (IsCapable(server, CAP_ENC))
1309 {
1310 /* Decryption settings */
1311 *buf++ = SLINKCMD_SET_CRYPT_IN_CIPHER;
1312 *buf++ = 0; /* / (upper 8-bits of len) */
1313 *buf++ = 1; /* \ cipher id is 1 byte (lower 8-bits of len) */
1314 *buf++ = lserver->in_cipher->cipherid;
1315 *buf++ = SLINKCMD_SET_CRYPT_IN_KEY;
1316 *buf++ = 0; /* keylen < 256 */
1317 *buf++ = lserver->in_cipher->keylen;
1318 memcpy(buf, lserver->in_key, lserver->in_cipher->keylen);
1319 buf += lserver->in_cipher->keylen;
1320 /* Encryption settings */
1321 *buf++ = SLINKCMD_SET_CRYPT_OUT_CIPHER;
1322 *buf++ = 0; /* / (upper 8-bits of len) */
1323 *buf++ = 1; /* \ cipher id is 1 byte (lower 8-bits of len) */
1324 *buf++ = lserver->out_cipher->cipherid;
1325 *buf++ = SLINKCMD_SET_CRYPT_OUT_KEY;
1326 *buf++ = 0; /* keylen < 256 */
1327 *buf++ = lserver->out_cipher->keylen;
1328 memcpy(buf, lserver->out_key, lserver->out_cipher->keylen);
1329 buf += lserver->out_cipher->keylen;
1330 *buf++ = SLINKCMD_START_CRYPT_IN;
1331 *buf++ = SLINKCMD_START_CRYPT_OUT;
1332 }
1333 #endif
1334
1335 /* pass the whole recvq to servlink */
1336 DLINK_FOREACH (ptr, lserver->buf_recvq.blocks.head)
1337 {
1338 block = ptr->data;
1339 *buf++ = SLINKCMD_INJECT_RECVQ;
1340 *buf++ = (block->size >> 8);
1341 *buf++ = (block->size & 0xff);
1342 memcpy(buf, &block->data[0], block->size);
1343 buf += block->size;
1344 }
1345
1346 dbuf_clear(&lserver->buf_recvq);
1347
1348 /* pass the whole sendq to servlink */
1349 DLINK_FOREACH (ptr, lserver->buf_sendq.blocks.head)
1350 {
1351 block = ptr->data;
1352 *buf++ = SLINKCMD_INJECT_SENDQ;
1353 *buf++ = (block->size >> 8);
1354 *buf++ = (block->size & 0xff);
1355 memcpy(buf, &block->data[0], block->size);
1356 buf += block->size;
1357 }
1358
1359 dbuf_clear(&lserver->buf_sendq);
1360
1361 /* start io */
1362 *buf++ = SLINKCMD_INIT;
1363
1364 /* schedule a write */
1365 send_queued_slink_write(server);
1366 }
1367
1368 /* fork_server()
1369 *
1370 * inputs - struct Client *server
1371 * output - success: 0 / failure: -1
1372 * side effect - fork, and exec SERVLINK to handle this connection
1373 */
1374 static int
1375 fork_server(struct Client *server)
1376 {
1377 #ifndef HAVE_SOCKETPAIR
1378 return -1;
1379 #else
1380 int i;
1381 int slink_fds[2][2];
1382 /* 0? - ctrl | 1? - data
1383 * ?0 - child | ?1 - parent */
1384
1385 if (socketpair(AF_UNIX, SOCK_STREAM, 0, slink_fds[0]) < 0)
1386 return -1;
1387 if (socketpair(AF_UNIX, SOCK_STREAM, 0, slink_fds[1]) < 0)
1388 goto free_ctrl_fds;
1389
1390 if ((i = fork()) < 0)
1391 {
1392 close(slink_fds[1][0]); close(slink_fds[1][1]);
1393 free_ctrl_fds:
1394 close(slink_fds[0][0]); close(slink_fds[0][1]);
1395 return -1;
1396 }
1397
1398 if (i == 0)
1399 {
1400 char fd_str[3][6]; /* store 3x sizeof("65535") */
1401 char *kid_argv[7];
1402
1403 #ifdef O_ASYNC
1404 fcntl(server->localClient->fd.fd, F_SETFL,
1405 fcntl(server->localClient->fd.fd, F_GETFL, 0) & ~O_ASYNC);
1406 #endif
1407 close_fds(&server->localClient->fd);
1408 close(slink_fds[0][1]);
1409 close(slink_fds[1][1]);
1410
1411 sprintf(fd_str[0], "%d", slink_fds[0][0]);
1412 sprintf(fd_str[1], "%d", slink_fds[1][0]);
1413 sprintf(fd_str[2], "%d", server->localClient->fd.fd);
1414
1415 kid_argv[0] = "-slink";
1416 kid_argv[1] = kid_argv[2] = fd_str[0]; /* ctrl */
1417 kid_argv[3] = kid_argv[4] = fd_str[1]; /* data */
1418 kid_argv[5] = fd_str[2]; /* network */
1419 kid_argv[6] = NULL;
1420
1421 execv(ConfigFileEntry.servlink_path, kid_argv);
1422
1423 _exit(1);
1424 }
1425
1426 /* close the network fd and the child ends of the pipes */
1427 fd_close(&server->localClient->fd);
1428 close(slink_fds[0][0]);
1429 close(slink_fds[1][0]);
1430
1431 execute_callback(setup_socket_cb, slink_fds[0][1]);
1432 execute_callback(setup_socket_cb, slink_fds[1][1]);
1433
1434 fd_open(&server->localClient->ctrlfd, slink_fds[0][1], 1, "slink ctrl");
1435 fd_open(&server->localClient->fd, slink_fds[1][1], 1, "slink data");
1436
1437 read_ctrl_packet(&server->localClient->ctrlfd, server);
1438 read_packet(&server->localClient->fd, server);
1439
1440 return 0;
1441 #endif
1442 }
1443
1444 /* server_burst()
1445 *
1446 * inputs - struct Client pointer server
1447 * -
1448 * output - none
1449 * side effects - send a server burst
1450 * bugs - still too long
1451 */
1452 static void
1453 server_burst(struct Client *client_p)
1454 {
1455 /* Send it in the shortened format with the TS, if
1456 ** it's a TS server; walk the list of channels, sending
1457 ** all the nicks that haven't been sent yet for each
1458 ** channel, then send the channel itself -- it's less
1459 ** obvious than sending all nicks first, but on the
1460 ** receiving side memory will be allocated more nicely
1461 ** saving a few seconds in the handling of a split
1462 ** -orabidoo
1463 */
1464
1465 /* On a "lazy link" hubs send nothing.
1466 * Leafs always have to send nicks plus channels
1467 */
1468 if (IsCapable(client_p, CAP_LL))
1469 {
1470 if (!ServerInfo.hub)
1471 {
1472 /* burst all our info */
1473 burst_all(client_p);
1474
1475 /* Now, ask for channel info on all our current channels */
1476 cjoin_all(client_p);
1477 }
1478 }
1479 else
1480 {
1481 burst_all(client_p);
1482 }
1483
1484 /* EOB stuff is now in burst_all */
1485 /* Always send a PING after connect burst is done */
1486 sendto_one(client_p, "PING :%s", ID_or_name(&me, client_p));
1487 }
1488
1489 /* burst_all()
1490 *
1491 * inputs - pointer to server to send burst to
1492 * output - NONE
1493 * side effects - complete burst of channels/nicks is sent to client_p
1494 */
1495 static void
1496 burst_all(struct Client *client_p)
1497 {
1498 dlink_node *ptr = NULL;
1499
1500 DLINK_FOREACH(ptr, global_channel_list.head)
1501 {
1502 struct Channel *chptr = ptr->data;
1503
1504 if (dlink_list_length(&chptr->members) != 0)
1505 {
1506 burst_members(client_p, chptr);
1507 send_channel_modes(client_p, chptr);
1508
1509 if (IsCapable(client_p, CAP_TBURST) ||
1510 IsCapable(client_p, CAP_TB))
1511 send_tb(client_p, chptr);
1512 }
1513 }
1514
1515 /* also send out those that are not on any channel
1516 */
1517 DLINK_FOREACH(ptr, global_client_list.head)
1518 {
1519 struct Client *target_p = ptr->data;
1520
1521 if (!IsBursted(target_p) && target_p->from != client_p)
1522 sendnick_TS(client_p, target_p);
1523
1524 ClearBursted(target_p);
1525 }
1526
1527 /* We send the time we started the burst, and let the remote host determine an EOB time,
1528 ** as otherwise we end up sending a EOB of 0 Sending here means it gets sent last -- fl
1529 */
1530 /* Its simpler to just send EOB and use the time its been connected.. --fl_ */
1531 if (IsCapable(client_p, CAP_EOB))
1532 sendto_one(client_p, ":%s EOB", ID_or_name(&me, client_p));
1533 }
1534
1535 /*
1536 * send_tb
1537 *
1538 * inputs - pointer to Client
1539 * - pointer to channel
1540 * output - NONE
1541 * side effects - Called on a server burst when
1542 * server is CAP_TB|CAP_TBURST capable
1543 */
1544 static void
1545 send_tb(struct Client *client_p, struct Channel *chptr)
1546 {
1547 /*
1548 * XXX - Logic here isn't right either. What if the topic got unset?
1549 * We would need to send an empty TOPIC to reset the topic from the
1550 * other side
1551 */
1552 if (chptr->topic != NULL)
1553 {
1554 if (IsCapable(client_p, CAP_TBURST))
1555 sendto_one(client_p, ":%s TBURST %lu %s %lu %s :%s",
1556 me.name, (unsigned long)chptr->channelts, chptr->chname,
1557 (unsigned long)chptr->topic_time, chptr->topic_info,
1558 chptr->topic);
1559 else if (IsCapable(client_p, CAP_TB))
1560 {
1561 if (ConfigChannel.burst_topicwho)
1562 {
1563 sendto_one(client_p, ":%s TB %s %lu %s :%s",
1564 me.name, chptr->chname,
1565 (unsigned long)chptr->topic_time,
1566 chptr->topic_info, chptr->topic);
1567 }
1568 else
1569 {
1570 sendto_one(client_p, ":%s TB %s %lu :%s",
1571 me.name, chptr->chname,
1572 (unsigned long)chptr->topic_time, chptr->topic);
1573 }
1574 }
1575 }
1576 }
1577
1578 /* cjoin_all()
1579 *
1580 * inputs - server to ask for channel info from
1581 * output - NONE
1582 * side effects - CJOINS for all the leafs known channels is sent
1583 */
1584 static void
1585 cjoin_all(struct Client *client_p)
1586 {
1587 const dlink_node *gptr = NULL;
1588
1589 DLINK_FOREACH(gptr, global_channel_list.head)
1590 {
1591 const struct Channel *chptr = gptr->data;
1592 sendto_one(client_p, ":%s CBURST %s",
1593 me.name, chptr->chname);
1594 }
1595 }
1596
1597 /* burst_channel()
1598 *
1599 * inputs - pointer to server to send sjoins to
1600 * - channel pointer
1601 * output - none
1602 * side effects - All sjoins for channel(s) given by chptr are sent
1603 * for all channel members. ONLY called by hub on
1604 * behalf of a lazylink so client_p is always guarunteed
1605 * to be a LL leaf.
1606 */
1607 void
1608 burst_channel(struct Client *client_p, struct Channel *chptr)
1609 {
1610 burst_ll_members(client_p, chptr);
1611
1612 send_channel_modes(client_p, chptr);
1613 add_lazylinkchannel(client_p,chptr);
1614
1615 if (chptr->topic != NULL && chptr->topic_info != NULL)
1616 {
1617 sendto_one(client_p, ":%s TOPIC %s %s %lu :%s",
1618 me.name, chptr->chname, chptr->topic_info,
1619 (unsigned long)chptr->topic_time, chptr->topic);
1620 }
1621 }
1622
1623 /* add_lazlinkchannel()
1624 *
1625 * inputs - pointer to directly connected leaf server
1626 * being introduced to this hub
1627 * - pointer to channel structure being introduced
1628 * output - NONE
1629 * side effects - The channel pointed to by chptr is now known
1630 * to be on lazyleaf server given by local_server_p.
1631 * mark that in the bit map and add to the list
1632 * of channels to examine after this newly introduced
1633 * server is squit off.
1634 */
1635 static void
1636 add_lazylinkchannel(struct Client *local_server_p, struct Channel *chptr)
1637 {
1638 assert(MyConnect(local_server_p));
1639
1640 chptr->lazyLinkChannelExists |= local_server_p->localClient->serverMask;
1641 dlinkAdd(chptr, make_dlink_node(), &lazylink_channels);
1642 }
1643
1644 /* add_lazylinkclient()
1645 *
1646 * inputs - pointer to directly connected leaf server
1647 * being introduced to this hub
1648 * - pointer to client being introduced
1649 * output - NONE
1650 * side effects - The client pointed to by client_p is now known
1651 * to be on lazyleaf server given by local_server_p.
1652 * mark that in the bit map and add to the list
1653 * of clients to examine after this newly introduced
1654 * server is squit off.
1655 */
1656 void
1657 add_lazylinkclient(struct Client *local_server_p, struct Client *client_p)
1658 {
1659 assert(MyConnect(local_server_p));
1660 client_p->lazyLinkClientExists |= local_server_p->localClient->serverMask;
1661 }
1662
1663 /* remove_lazylink_flags()
1664 *
1665 * inputs - pointer to server quitting
1666 * output - NONE
1667 * side effects - All the channels on the lazylink channel list are examined
1668 * If they hold a bit corresponding to the servermask
1669 * attached to client_p, clear that bit. If this bitmask
1670 * goes to 0, then the channel is no longer known to
1671 * be on any lazylink server, and can be removed from the
1672 * link list.
1673 *
1674 * Similar is done for lazylink clients
1675 *
1676 * This function must be run by the HUB on any exiting
1677 * lazylink leaf server, while the pointer is still valid.
1678 * Hence must be run from client.c in exit_one_client()
1679 *
1680 * The old code scanned all channels, this code only
1681 * scans channels/clients on the lazylink_channels
1682 * lazylink_clients lists.
1683 */
1684 void
1685 remove_lazylink_flags(unsigned long mask)
1686 {
1687 dlink_node *ptr;
1688 dlink_node *next_ptr;
1689 struct Channel *chptr;
1690 struct Client *target_p;
1691 unsigned long clear_mask;
1692
1693 if (!mask) /* On 0 mask, don't do anything */
1694 return;
1695
1696 clear_mask = ~mask;
1697 freeMask |= mask;
1698
1699 DLINK_FOREACH_SAFE(ptr, next_ptr, lazylink_channels.head)
1700 {
1701 chptr = ptr->data;
1702
1703 chptr->lazyLinkChannelExists &= clear_mask;
1704
1705 if (chptr->lazyLinkChannelExists == 0)
1706 {
1707 dlinkDelete(ptr, &lazylink_channels);
1708 free_dlink_node(ptr);
1709 }
1710 }
1711
1712 DLINK_FOREACH(ptr, global_client_list.head)
1713 {
1714 target_p = ptr->data;
1715 target_p->lazyLinkClientExists &= clear_mask;
1716 }
1717 }
1718
1719 /* burst_members()
1720 *
1721 * inputs - pointer to server to send members to
1722 * - dlink_list pointer to membership list to send
1723 * output - NONE
1724 * side effects -
1725 */
1726 static void
1727 burst_members(struct Client *client_p, struct Channel *chptr)
1728 {
1729 struct Client *target_p;
1730 struct Membership *ms;
1731 dlink_node *ptr;
1732
1733 DLINK_FOREACH(ptr, chptr->members.head)
1734 {
1735 ms = ptr->data;
1736 target_p = ms->client_p;
1737
1738 if (!IsBursted(target_p))
1739 {
1740 SetBursted(target_p);
1741
1742 if (target_p->from != client_p)
1743 sendnick_TS(client_p, target_p);
1744 }
1745 }
1746 }
1747
1748 /* burst_ll_members()
1749 *
1750 * inputs - pointer to server to send members to
1751 * - dlink_list pointer to membership list to send
1752 * output - NONE
1753 * side effects - This version also has to check the bitmap for lazylink
1754 */
1755 static void
1756 burst_ll_members(struct Client *client_p, struct Channel *chptr)
1757 {
1758 struct Client *target_p;
1759 struct Membership *ms;
1760 dlink_node *ptr;
1761
1762 DLINK_FOREACH(ptr, chptr->members.head)
1763 {
1764 ms = ptr->data;
1765 target_p = ms->client_p;
1766
1767 if ((target_p->lazyLinkClientExists & client_p->localClient->serverMask) == 0)
1768 {
1769 if (target_p->from != client_p)
1770 {
1771 add_lazylinkclient(client_p,target_p);
1772 sendnick_TS(client_p, target_p);
1773 }
1774 }
1775 }
1776 }
1777
1778 /* set_autoconn()
1779 *
1780 * inputs - struct Client pointer to oper requesting change
1781 * output - none
1782 * side effects - set autoconnect mode
1783 */
1784 void
1785 set_autoconn(struct Client *source_p, const char *name, int newval)
1786 {
1787 struct ConfItem *conf;
1788 struct AccessItem *aconf;
1789
1790 if (name != NULL)
1791 {
1792 conf = find_exact_name_conf(SERVER_TYPE, name, NULL, NULL);
1793 if (conf != NULL)
1794 {
1795 aconf = (struct AccessItem *)map_to_conf(conf);
1796 if (newval)
1797 SetConfAllowAutoConn(aconf);
1798 else
1799 ClearConfAllowAutoConn(aconf);
1800
1801 sendto_realops_flags(UMODE_ALL, L_ALL,
1802 "%s has changed AUTOCONN for %s to %i",
1803 source_p->name, name, newval);
1804 sendto_one(source_p,
1805 ":%s NOTICE %s :AUTOCONN for %s is now set to %i",
1806 me.name, source_p->name, name, newval);
1807 }
1808 else
1809 {
1810 sendto_one(source_p, ":%s NOTICE %s :Can't find %s",
1811 me.name, source_p->name, name);
1812 }
1813 }
1814 else
1815 {
1816 sendto_one(source_p, ":%s NOTICE %s :Please specify a server name!",
1817 me.name, source_p->name);
1818 }
1819 }
1820
1821 void
1822 initServerMask(void)
1823 {
1824 freeMask = 0xFFFFFFFFUL;
1825 }
1826
1827 /* nextFreeMask()
1828 *
1829 * inputs - NONE
1830 * output - unsigned long next unused mask for use in LL
1831 * side effects -
1832 */
1833 unsigned long
1834 nextFreeMask(void)
1835 {
1836 int i;
1837 unsigned long mask = 1;
1838
1839 for (i = 0; i < 32; i++)
1840 {
1841 if (mask & freeMask)
1842 {
1843 freeMask &= ~mask;
1844 return(mask);
1845 }
1846
1847 mask <<= 1;
1848 }
1849
1850 return(0L); /* watch this special case ... */
1851 }
1852
1853 /* New server connection code
1854 * Based upon the stuff floating about in s_bsd.c
1855 * -- adrian
1856 */
1857
1858 /* serv_connect() - initiate a server connection
1859 *
1860 * inputs - pointer to conf
1861 * - pointer to client doing the connect
1862 * output -
1863 * side effects -
1864 *
1865 * This code initiates a connection to a server. It first checks to make
1866 * sure the given server exists. If this is the case, it creates a socket,
1867 * creates a client, saves the socket information in the client, and
1868 * initiates a connection to the server through comm_connect_tcp(). The
1869 * completion of this goes through serv_completed_connection().
1870 *
1871 * We return 1 if the connection is attempted, since we don't know whether
1872 * it suceeded or not, and 0 if it fails in here somewhere.
1873 */
1874 int
1875 serv_connect(struct AccessItem *aconf, struct Client *by)
1876 {
1877 struct ConfItem *conf;
1878 struct Client *client_p;
1879 char buf[HOSTIPLEN];
1880
1881 /* conversion structs */
1882 struct sockaddr_in *v4;
1883 /* Make sure aconf is useful */
1884 assert(aconf != NULL);
1885
1886 if(aconf == NULL)
1887 return (0);
1888
1889 /* XXX should be passing struct ConfItem in the first place */
1890 conf = unmap_conf_item(aconf);
1891
1892 /* log */
1893 irc_getnameinfo((struct sockaddr*)&aconf->ipnum, aconf->ipnum.ss_len,
1894 buf, HOSTIPLEN, NULL, 0, NI_NUMERICHOST);
1895 ilog(L_NOTICE, "Connect to %s[%s] @%s", aconf->user, aconf->host,
1896 buf);
1897
1898 /* Still processing a DNS lookup? -> exit */
1899 if (aconf->dns_query != NULL)
1900 {
1901 sendto_realops_flags(UMODE_ALL, L_OPER,
1902 "Error connecting to %s: Error during DNS lookup", conf->name);
1903 return (0);
1904 }
1905
1906 /* Make sure this server isn't already connected
1907 * Note: aconf should ALWAYS be a valid C: line
1908 */
1909 if ((client_p = find_server(conf->name)) != NULL)
1910 {
1911 sendto_realops_flags(UMODE_ALL, L_ADMIN,
1912 "Server %s already present from %s",
1913 conf->name, get_client_name(client_p, SHOW_IP));
1914 sendto_realops_flags(UMODE_ALL, L_OPER,
1915 "Server %s already present from %s",
1916 conf->name, get_client_name(client_p, MASK_IP));
1917 if (by && IsClient(by) && !MyClient(by))
1918 sendto_one(by, ":%s NOTICE %s :Server %s already present from %s",
1919 me.name, by->name, conf->name,
1920 get_client_name(client_p, MASK_IP));
1921 return (0);
1922 }
1923
1924 /* Create a local client */
1925 client_p = make_client(NULL);
1926
1927 /* Copy in the server, hostname, fd */
1928 strlcpy(client_p->name, conf->name, sizeof(client_p->name));
1929 strlcpy(client_p->host, aconf->host, sizeof(client_p->host));
1930
1931 /* We already converted the ip once, so lets use it - stu */
1932 strlcpy(client_p->sockhost, buf, HOSTIPLEN);
1933
1934 /* create a socket for the server connection */
1935 if (comm_open(&client_p->localClient->fd, aconf->ipnum.ss.ss_family,
1936 SOCK_STREAM, 0, NULL) < 0)
1937 {
1938 /* Eek, failure to create the socket */
1939 report_error(L_ALL,
1940 "opening stream socket to %s: %s", conf->name, errno);
1941 SetDead(client_p);
1942 exit_client(client_p, &me, "Connection failed");
1943 return (0);
1944 }
1945
1946 /* servernames are always guaranteed under HOSTLEN chars */
1947 fd_note(&client_p->localClient->fd, "Server: %s", conf->name);
1948
1949 /* Attach config entries to client here rather than in
1950 * serv_connect_callback(). This to avoid null pointer references.
1951 */
1952 if (!attach_connect_block(client_p, conf->name, aconf->host))
1953 {
1954 sendto_realops_flags(UMODE_ALL, L_ALL,
1955 "Host %s is not enabled for connecting:no C/N-line",
1956 conf->name);
1957 if (by && IsClient(by) && !MyClient(by))
1958 sendto_one(by, ":%s NOTICE %s :Connect to host %s failed.",
1959 me.name, by->name, client_p->name);
1960 SetDead(client_p);
1961 exit_client(client_p, client_p, "Connection failed");
1962 return (0);
1963 }
1964
1965 /* at this point we have a connection in progress and C/N lines
1966 * attached to the client, the socket info should be saved in the
1967 * client and it should either be resolved or have a valid address.
1968 *
1969 * The socket has been connected or connect is in progress.
1970 */
1971 make_server(client_p);
1972
1973 if (by && IsClient(by))
1974 strlcpy(client_p->serv->by, by->name, sizeof(client_p->serv->by));
1975 else
1976 strlcpy(client_p->serv->by, "AutoConn.", sizeof(client_p->serv->by));
1977
1978 SetConnecting(client_p);
1979 dlinkAdd(client_p, &client_p->node, &global_client_list);
1980 /* from def_fam */
1981 client_p->localClient->aftype = aconf->aftype;
1982
1983 /* Now, initiate the connection */
1984 /* XXX assume that a non 0 type means a specific bind address
1985 * for this connect.
1986 */
1987 switch (aconf->aftype)
1988 {
1989 case AF_INET:
1990 v4 = (struct sockaddr_in*)&aconf->my_ipnum;
1991 if (v4->sin_addr.s_addr != 0)
1992 {
1993 struct irc_ssaddr ipn;
1994 memset(&ipn, 0, sizeof(struct irc_ssaddr));
1995 ipn.ss.ss_family = AF_INET;
1996 ipn.ss_port = 0;
1997 memcpy(&ipn, &aconf->my_ipnum, sizeof(struct irc_ssaddr));
1998 comm_connect_tcp(&client_p->localClient->fd, aconf->host, aconf->port,
1999 (struct sockaddr *)&ipn, ipn.ss_len,
2000 serv_connect_callback, client_p, aconf->aftype,
2001 CONNECTTIMEOUT);
2002 }
2003 else if (ServerInfo.specific_ipv4_vhost)
2004 {
2005 struct irc_ssaddr ipn;
2006 memset(&ipn, 0, sizeof(struct irc_ssaddr));
2007 ipn.ss.ss_family = AF_INET;
2008 ipn.ss_port = 0;
2009 memcpy(&ipn, &ServerInfo.ip, sizeof(struct irc_ssaddr));
2010 comm_connect_tcp(&client_p->localClient->fd, aconf->host, aconf->port,
2011 (struct sockaddr *)&ipn, ipn.ss_len,
2012 serv_connect_callback, client_p, aconf->aftype,
2013 CONNECTTIMEOUT);
2014 }
2015 else
2016 comm_connect_tcp(&client_p->localClient->fd, aconf->host, aconf->port,
2017 NULL, 0, serv_connect_callback, client_p, aconf->aftype,
2018 CONNECTTIMEOUT);
2019 break;
2020 #ifdef IPV6
2021 case AF_INET6:
2022 {
2023 struct irc_ssaddr ipn;
2024 struct sockaddr_in6 *v6;
2025 struct sockaddr_in6 *v6conf;
2026
2027 memset(&ipn, 0, sizeof(struct irc_ssaddr));
2028 v6conf = (struct sockaddr_in6 *)&aconf->my_ipnum;
2029 v6 = (struct sockaddr_in6 *)&ipn;
2030
2031 if (memcmp(&v6conf->sin6_addr, &v6->sin6_addr,
2032 sizeof(struct in6_addr)) != 0)
2033 {
2034 memcpy(&ipn, &aconf->my_ipnum, sizeof(struct irc_ssaddr));
2035 ipn.ss.ss_family = AF_INET6;
2036 ipn.ss_port = 0;
2037 comm_connect_tcp(&client_p->localClient->fd,
2038 aconf->host, aconf->port,
2039 (struct sockaddr *)&ipn, ipn.ss_len,
2040 serv_connect_callback, client_p,
2041 aconf->aftype, CONNECTTIMEOUT);
2042 }
2043 else if (ServerInfo.specific_ipv6_vhost)
2044 {
2045 memcpy(&ipn, &ServerInfo.ip6, sizeof(struct irc_ssaddr));
2046 ipn.ss.ss_family = AF_INET6;
2047 ipn.ss_port = 0;
2048 comm_connect_tcp(&client_p->localClient->fd,
2049 aconf->host, aconf->port,
2050 (struct sockaddr *)&ipn, ipn.ss_len,
2051 serv_connect_callback, client_p,
2052 aconf->aftype, CONNECTTIMEOUT);
2053 }
2054 else
2055 comm_connect_tcp(&client_p->localClient->fd,
2056 aconf->host, aconf->port,
2057 NULL, 0, serv_connect_callback, client_p,
2058 aconf->aftype, CONNECTTIMEOUT);
2059 }
2060 #endif
2061 }
2062 return (1);
2063 }
2064
2065 /* serv_connect_callback() - complete a server connection.
2066 *
2067 * This routine is called after the server connection attempt has
2068 * completed. If unsucessful, an error is sent to ops and the client
2069 * is closed. If sucessful, it goes through the initialisation/check
2070 * procedures, the capabilities are sent, and the socket is then
2071 * marked for reading.
2072 */
2073 static void
2074 serv_connect_callback(fde_t *fd, int status, void *data)
2075 {
2076 struct Client *client_p = data;
2077 struct ConfItem *conf=NULL;
2078 struct AccessItem *aconf=NULL;
2079
2080 /* First, make sure its a real client! */
2081 assert(client_p != NULL);
2082 assert(&client_p->localClient->fd == fd);
2083
2084 /* Next, for backward purposes, record the ip of the server */
2085 memcpy(&client_p->localClient->ip, &fd->connect.hostaddr,
2086 sizeof(struct irc_ssaddr));
2087 /* Check the status */
2088 if (status != COMM_OK)
2089 {
2090 /* We have an error, so report it and quit
2091 * Admins get to see any IP, mere opers don't *sigh*
2092 */
2093 if (ConfigServerHide.hide_server_ips)
2094 sendto_realops_flags(UMODE_ALL, L_ADMIN,
2095 "Error connecting to %s: %s",
2096 client_p->name, comm_errstr(status));
2097 else
2098 sendto_realops_flags(UMODE_ALL, L_ADMIN,
2099 "Error connecting to %s[%s]: %s", client_p->name,
2100 client_p->host, comm_errstr(status));
2101
2102 sendto_realops_flags(UMODE_ALL, L_OPER,
2103 "Error connecting to %s: %s",
2104 client_p->name, comm_errstr(status));
2105
2106 /* If a fd goes bad, call dead_link() the socket is no
2107 * longer valid for reading or writing.
2108 */
2109 dead_link_on_write(client_p, 0);
2110 return;
2111 }
2112
2113 /* COMM_OK, so continue the connection procedure */
2114 /* Get the C/N lines */
2115 conf = find_conf_name(&client_p->localClient->confs,
2116 client_p->name, SERVER_TYPE);
2117 if (conf == NULL)
2118 {
2119 sendto_realops_flags(UMODE_ALL, L_ADMIN,
2120 "Lost connect{} block for %s", get_client_name(client_p, HIDE_IP));
2121 sendto_realops_flags(UMODE_ALL, L_OPER,
2122 "Lost connect{} block for %s", get_client_name(client_p, MASK_IP));
2123
2124 exit_client(client_p, &me, "Lost connect{} block");
2125 return;
2126 }
2127
2128 aconf = (struct AccessItem *)map_to_conf(conf);
2129 /* Next, send the initial handshake */
2130 SetHandshake(client_p);
2131
2132 #ifdef HAVE_LIBCRYPTO
2133 /* Handle all CRYPTLINK links in cryptlink_init */
2134 if (IsConfCryptLink(aconf))
2135 {
2136 cryptlink_init(client_p, conf, fd);
2137 return;
2138 }
2139 #endif
2140
2141 /* jdc -- Check and send spasswd, not passwd. */
2142 if (!EmptyString(aconf->spasswd) && (me.id[0] != '\0'))
2143 /* Send TS 6 form only if id */
2144 sendto_one(client_p, "PASS %s TS %d %s",
2145 aconf->spasswd, TS_CURRENT, me.id);
2146 else
2147 sendto_one(client_p, "PASS %s TS 5",
2148 aconf->spasswd);
2149
2150 /* Pass my info to the new server
2151 *
2152 * If trying to negotiate LazyLinks, pass on CAP_LL
2153 * If this is a HUB, pass on CAP_HUB
2154 * Pass on ZIP if supported
2155 * Pass on TB if supported.
2156 * - Dianora
2157 */
2158 send_capabilities(client_p, aconf, (ServerInfo.hub ? CAP_HUB : 0)
2159 | (IsConfLazyLink(aconf) ? CAP_LL : 0)
2160 | (IsConfCompressed(aconf) ? CAP_ZIP : 0)
2161 | (IsConfTopicBurst(aconf) ? CAP_TBURST|CAP_TB : 0), 0);
2162
2163 sendto_one(client_p, "SERVER %s 1 :%s%s",
2164 my_name_for_link(conf),
2165 ConfigServerHide.hidden ? "(H) " : "",
2166 me.info);
2167
2168 /* If we've been marked dead because a send failed, just exit
2169 * here now and save everyone the trouble of us ever existing.
2170 */
2171 if (IsDead(client_p))
2172 {
2173 sendto_realops_flags(UMODE_ALL, L_ADMIN,
2174 "%s[%s] went dead during handshake",
2175 client_p->name,
2176 client_p->host);
2177 sendto_realops_flags(UMODE_ALL, L_OPER,
2178 "%s went dead during handshake", client_p->name);
2179 return;
2180 }
2181
2182 /* don't move to serv_list yet -- we haven't sent a burst! */
2183 /* If we get here, we're ok, so lets start reading some data */
2184 comm_setselect(fd, COMM_SELECT_READ, read_packet, client_p, 0);
2185 }
2186
2187 struct Client *
2188 find_servconn_in_progress(const char *name)
2189 {
2190 dlink_node *ptr;
2191 struct Client *cptr;
2192
2193 DLINK_FOREACH(ptr, unknown_list.head)
2194 {
2195 cptr = ptr->data;
2196
2197 if (cptr && cptr->name[0])
2198 if (match(cptr->name, name) || match(name, cptr->name))
2199 return cptr;
2200 }
2201
2202 return NULL;
2203 }
2204
2205 #ifdef HAVE_LIBCRYPTO
2206 /*
2207 * sends a CRYPTLINK SERV command.
2208 */
2209 void
2210 cryptlink_init(struct Client *client_p, struct ConfItem *conf, fde_t *fd)
2211 {
2212 struct AccessItem *aconf;
2213 char *encrypted;
2214 unsigned char *key_to_send;
2215 char randkey[CIPHERKEYLEN];
2216 int enc_len;
2217
2218 /* get key */
2219 if ((!ServerInfo.rsa_private_key) ||
2220 (!RSA_check_key(ServerInfo.rsa_private_key)) )
2221 {
2222 cryptlink_error(client_p, "SERV", "Invalid RSA private key",
2223 "Invalid RSA private key");
2224 return;
2225 }
2226
2227 aconf = (struct AccessItem *)map_to_conf(conf);
2228
2229 if (aconf->rsa_public_key == NULL)
2230 {
2231 cryptlink_error(client_p, "SERV", "Invalid RSA public key",
2232 "Invalid RSA public key");
2233 return;
2234 }
2235
2236 if (get_randomness((unsigned char *)randkey, CIPHERKEYLEN) != 1)
2237 {
2238 cryptlink_error(client_p, "SERV", "Couldn't generate keyphrase",
2239 "Couldn't generate keyphrase");
2240 return;
2241 }
2242
2243 encrypted = MyMalloc(RSA_size(ServerInfo.rsa_private_key));
2244 enc_len = RSA_public_encrypt(CIPHERKEYLEN,
2245 (unsigned char *)randkey,
2246 (unsigned char *)encrypted,
2247 aconf->rsa_public_key,
2248 RSA_PKCS1_PADDING);
2249
2250 memcpy(client_p->localClient->in_key, randkey, CIPHERKEYLEN);
2251
2252 if (enc_len <= 0)
2253 {
2254 report_crypto_errors();
2255 MyFree(encrypted);
2256 cryptlink_error(client_p, "SERV", "Couldn't encrypt data",
2257 "Couldn't encrypt data");
2258 return;
2259 }
2260
2261 if (!(base64_block(&key_to_send, encrypted, enc_len)))
2262 {
2263 MyFree(encrypted);
2264 cryptlink_error(client_p, "SERV", "Couldn't base64 encode key",
2265 "Couldn't base64 encode key");
2266 return;
2267 }
2268
2269 send_capabilities(client_p, aconf, (ServerInfo.hub ? CAP_HUB : 0)
2270 | (IsConfLazyLink(aconf) ? CAP_LL : 0)
2271 | (IsConfCompressed(aconf) ? CAP_ZIP : 0)
2272 | (IsConfTopicBurst(aconf) ? CAP_TBURST|CAP_TB : 0), CAP_ENC_MASK);
2273
2274 if (me.id[0])
2275 sendto_one(client_p, "PASS . TS %d %s", TS_CURRENT, me.id);
2276
2277 sendto_one(client_p, "CRYPTLINK SERV %s %s :%s%s",
2278 my_name_for_link(conf), key_to_send,
2279 ConfigServerHide.hidden ? "(H) " : "", me.info);
2280
2281 SetHandshake(client_p);
2282 SetWaitAuth(client_p);
2283
2284 MyFree(encrypted);
2285 MyFree(key_to_send);
2286
2287 if (IsDead(client_p))
2288 cryptlink_error(client_p, "SERV", "Went dead during handshake",
2289 "Went dead during handshake");
2290 else if (fd != NULL)
2291 /* If we get here, we're ok, so lets start reading some data */
2292 comm_setselect(fd, COMM_SELECT_READ, read_packet, client_p, 0);
2293 }
2294
2295 void
2296 cryptlink_error(struct Client *client_p, const char *type,
2297 const char *reason, const char *client_reason)
2298 {
2299 sendto_realops_flags(UMODE_ALL, L_ADMIN, "%s: CRYPTLINK %s error - %s",
2300 get_client_name(client_p, SHOW_IP), type, reason);
2301 sendto_realops_flags(UMODE_ALL, L_OPER, "%s: CRYPTLINK %s error - %s",
2302 get_client_name(client_p, MASK_IP), type, reason);
2303 ilog(L_ERROR, "%s: CRYPTLINK %s error - %s",
2304 get_client_name(client_p, SHOW_IP), type, reason);
2305
2306 /* If client_reason isn't NULL, then exit the client with the message
2307 * defined in the call.
2308 */
2309 if ((client_reason != NULL) && (!IsDead(client_p)))
2310 exit_client(client_p, &me, client_reason);
2311 }
2312
2313 static char base64_chars[] =
2314 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
2315
2316 static char base64_values[] =
2317 {
2318 /* 00-15 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2319 /* 16-31 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2320 /* 32-47 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
2321 /* 48-63 */ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, 0, -1, -1,
2322 /* 64-79 */ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2323 /* 80-95 */ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
2324 /* 96-111 */ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2325 /* 112-127 */ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
2326 /* 128-143 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2327 /* 144-159 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2328 /* 160-175 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2329 /* 186-191 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2330 /* 192-207 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2331 /* 208-223 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2332 /* 224-239 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2333 /* 240-255 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
2334 };
2335
2336 /*
2337 * base64_block will allocate and return a new block of memory
2338 * using MyMalloc(). It should be freed after use.
2339 */
2340 int
2341 base64_block(unsigned char **output, char *data, int len)
2342 {
2343 unsigned char *out;
2344 unsigned char *in = (unsigned char*)data;
2345 unsigned long int q_in;
2346 int i;
2347 int count = 0;
2348
2349 out = MyMalloc(((((len + 2) - ((len + 2) % 3)) / 3) * 4) + 1);
2350
2351 /* process 24 bits at a time */
2352 for( i = 0; i < len; i += 3)
2353 {
2354 q_in = 0;
2355
2356 if ( i + 2 < len )
2357 {
2358 q_in = (in[i+2] & 0xc0) << 2;
2359 q_in |= in[i+2];
2360 }
2361
2362 if ( i + 1 < len )
2363 {
2364 q_in |= (in[i+1] & 0x0f) << 10;
2365 q_in |= (in[i+1] & 0xf0) << 12;
2366 }
2367
2368 q_in |= (in[i] & 0x03) << 20;
2369 q_in |= in[i] << 22;
2370
2371 q_in &= 0x3f3f3f3f;
2372
2373 out[count++] = base64_chars[((q_in >> 24) )];
2374 out[count++] = base64_chars[((q_in >> 16) & 0xff)];
2375 out[count++] = base64_chars[((q_in >> 8) & 0xff)];
2376 out[count++] = base64_chars[((q_in ) & 0xff)];
2377 }
2378 if ( (i - len) > 0 )
2379 {
2380 out[count-1] = '=';
2381 if ( (i - len) > 1 )
2382 out[count-2] = '=';
2383 }
2384
2385 out[count] = '\0';
2386 *output = out;
2387 return (count);
2388 }
2389
2390 /*
2391 * unbase64_block will allocate and return a new block of memory
2392 * using MyMalloc(). It should be freed after use.
2393 */
2394 int
2395 unbase64_block(unsigned char **output, char *data, int len)
2396 {
2397 unsigned char *out;
2398 unsigned char *in = (unsigned char*)data;
2399 unsigned long int q_in;
2400 int i;
2401 int count = 0;
2402
2403 if ((len % 4) != 0)
2404 return (0);
2405
2406 out = MyMalloc(((len / 4) * 3) + 1);
2407
2408 /* process 32 bits at a time */
2409 for( i = 0; (i + 3) < len; i+=4)
2410 {
2411 /* compress input (chars a, b, c and d) as follows:
2412 * (after converting ascii -> base64 value)
2413 *
2414 * |00000000aaaaaabbbbbbccccccdddddd|
2415 * | 765432 107654 321076 543210|
2416 */
2417
2418 q_in = 0;
2419
2420 if (base64_values[in[i+3]] > -1)
2421 q_in |= base64_values[in[i+3]] ;
2422 if (base64_values[in[i+2]] > -1)
2423 q_in |= base64_values[in[i+2]] << 6;
2424 if (base64_values[in[i+1]] > -1)
2425 q_in |= base64_values[in[i+1]] << 12;
2426 if (base64_values[in[i ]] > -1)
2427 q_in |= base64_values[in[i ]] << 18;
2428
2429 out[count++] = (q_in >> 16) & 0xff;
2430 out[count++] = (q_in >> 8) & 0xff;
2431 out[count++] = (q_in ) & 0xff;
2432 }
2433
2434 if (in[i-1] == '=') count--;
2435 if (in[i-2] == '=') count--;
2436
2437 out[count] = '\0';
2438 *output = out;
2439 return (count);
2440 }
2441
2442 #endif /* HAVE_LIBCRYPTO */
2443

Properties

Name Value
svn:eol-style native
svn:keywords Id Revision

svnadmin@ircd-hybrid.org
ViewVC Help
Powered by ViewVC 1.1.28