ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid-7.2/src/s_serv.c
Revision: 386
Committed: Tue Jan 31 12:40:56 2006 UTC (18 years, 1 month ago) by adx
Content type: text/x-csrc
File size: 70656 byte(s)
Log Message:
+ this should fix sockhost relaying (ThaPrince #1)

File Contents

# Content
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)) ?
896 "0" : target_p->sockhost), 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
904 if (IsConfAwayBurst((struct AccessItem *)map_to_conf(client_p->serv->sconf)))
905 if (!EmptyString(target_p->away))
906 sendto_one(client_p, ":%s AWAY :%s", target_p->name,
907 target_p->away);
908
909 }
910
911 /* client_burst_if_needed()
912 *
913 * inputs - pointer to server
914 * - pointer to client to add
915 * output - NONE
916 * side effects - If this client is not known by this lazyleaf, send it
917 */
918 void
919 client_burst_if_needed(struct Client *client_p, struct Client *target_p)
920 {
921 if (!ServerInfo.hub)
922 return;
923 if (!MyConnect(client_p))
924 return;
925 if (!IsCapable(client_p,CAP_LL))
926 return;
927
928 if ((target_p->lazyLinkClientExists & client_p->localClient->serverMask) == 0)
929 {
930 sendnick_TS(client_p, target_p);
931 add_lazylinkclient(client_p,target_p);
932 }
933 }
934
935 /*
936 * show_capabilities - show current server capabilities
937 *
938 * inputs - pointer to a struct Client
939 * output - pointer to static string
940 * side effects - build up string representing capabilities of server listed
941 */
942 const char *
943 show_capabilities(struct Client *target_p)
944 {
945 static char msgbuf[IRCD_BUFSIZE];
946 char *t = msgbuf;
947 dlink_node *ptr;
948
949 t += ircsprintf(msgbuf, "TS ");
950
951 DLINK_FOREACH(ptr, cap_list.head)
952 {
953 const struct Capability *cap = ptr->data;
954
955 if (IsCapable(target_p, cap->cap))
956 t += ircsprintf(t, "%s ", cap->name);
957 }
958 #ifdef HAVE_LIBCRYPTO
959 if (IsCapable(target_p, CAP_ENC) &&
960 target_p->localClient->in_cipher &&
961 target_p->localClient->out_cipher)
962 t += ircsprintf(t, "ENC:%s ",
963 target_p->localClient->in_cipher->name);
964 #endif
965 *(t - 1) = '\0';
966
967 return(msgbuf);
968 }
969
970 /* make_server()
971 *
972 * inputs - pointer to client struct
973 * output - pointer to struct Server
974 * side effects - add's an Server information block to a client
975 * if it was not previously allocated.
976 */
977 struct Server *
978 make_server(struct Client *client_p)
979 {
980 if (client_p->serv == NULL)
981 {
982 client_p->serv = MyMalloc(sizeof(struct Server));
983 client_p->serv->dep_servers = 1;
984 }
985
986 return client_p->serv;
987 }
988
989 /* server_estab()
990 *
991 * inputs - pointer to a struct Client
992 * output -
993 * side effects -
994 */
995 void
996 server_estab(struct Client *client_p)
997 {
998 struct Client *target_p;
999 struct ConfItem *conf;
1000 struct AccessItem *aconf=NULL;
1001 char *host;
1002 const char *inpath;
1003 static char inpath_ip[HOSTLEN * 2 + USERLEN + 6];
1004 dlink_node *m;
1005 dlink_node *ptr;
1006
1007 assert(client_p != NULL);
1008
1009 strlcpy(inpath_ip, get_client_name(client_p, SHOW_IP), sizeof(inpath_ip));
1010
1011 inpath = get_client_name(client_p, MASK_IP); /* "refresh" inpath with host */
1012 host = client_p->name;
1013
1014 if ((conf = find_conf_name(&client_p->localClient->confs, host, SERVER_TYPE))
1015 == NULL)
1016 {
1017 /* This shouldn't happen, better tell the ops... -A1kmm */
1018 sendto_realops_flags(UMODE_ALL, L_ALL, "Warning: Lost connect{} block "
1019 "for server %s(this shouldn't happen)!", host);
1020 exit_client(client_p, &me, "Lost connect{} block!");
1021 return;
1022 }
1023
1024 MyFree(client_p->localClient->passwd);
1025 client_p->localClient->passwd = NULL;
1026
1027 /* Its got identd, since its a server */
1028 SetGotId(client_p);
1029
1030 /* If there is something in the serv_list, it might be this
1031 * connecting server..
1032 */
1033 if (!ServerInfo.hub && serv_list.head)
1034 {
1035 if (client_p != serv_list.head->data || serv_list.head->next)
1036 {
1037 ServerStats->is_ref++;
1038 sendto_one(client_p, "ERROR :I'm a leaf not a hub");
1039 exit_client(client_p, &me, "I'm a leaf");
1040 return;
1041 }
1042 }
1043
1044 aconf = (struct AccessItem *)map_to_conf(conf);
1045
1046 if (IsUnknown(client_p) && !IsConfCryptLink(aconf))
1047 {
1048 /* jdc -- 1. Use EmptyString(), not [0] index reference.
1049 * 2. Check aconf->spasswd, not aconf->passwd.
1050 */
1051 if (!EmptyString(aconf->spasswd))
1052 {
1053 /* only send ts6 format PASS if we have ts6 enabled */
1054 if (me.id[0] != '\0') /* Send TS 6 form only if id */
1055 sendto_one(client_p, "PASS %s TS %d %s",
1056 aconf->spasswd, TS_CURRENT, me.id);
1057 else
1058 sendto_one(client_p, "PASS %s TS 5",
1059 aconf->spasswd);
1060 }
1061
1062 /* Pass my info to the new server
1063 *
1064 * If trying to negotiate LazyLinks, pass on CAP_LL
1065 * If this is a HUB, pass on CAP_HUB
1066 * Pass on ZIP if supported
1067 * Pass on TB if supported.
1068 * - Dianora
1069 */
1070
1071 send_capabilities(client_p, aconf, (ServerInfo.hub ? CAP_HUB : 0)
1072 | (IsConfLazyLink(aconf) ? CAP_LL : 0)
1073 | (IsConfCompressed(aconf) ? CAP_ZIP : 0)
1074 | (IsConfTopicBurst(aconf) ? CAP_TBURST|CAP_TB : 0), 0);
1075
1076 /* SERVER is the last command sent before switching to ziplinks.
1077 * We set TCPNODELAY on the socket to make sure it gets sent out
1078 * on the wire immediately. Otherwise, it could be sitting in
1079 * a kernel buffer when we start sending zipped data, and the
1080 * parser on the receiving side can't hand both unzipped and zipped
1081 * data in one packet. --Rodder
1082 *
1083 * currently we only need to call send_queued_write,
1084 * Nagle is already disabled at this point --adx
1085 */
1086 sendto_one(client_p, "SERVER %s 1 :%s%s",
1087 my_name_for_link(conf),
1088 ConfigServerHide.hidden ? "(H) " : "",
1089 (me.info[0]) ? (me.info) : "IRCers United");
1090 send_queued_write(client_p);
1091 }
1092
1093 /* Hand the server off to servlink now */
1094 if (IsCapable(client_p, CAP_ENC) || IsCapable(client_p, CAP_ZIP))
1095 {
1096 if (fork_server(client_p) < 0)
1097 {
1098 sendto_realops_flags(UMODE_ALL, L_ADMIN,
1099 "Warning: fork failed for server %s -- check servlink_path (%s)",
1100 get_client_name(client_p, HIDE_IP), ConfigFileEntry.servlink_path);
1101 sendto_realops_flags(UMODE_ALL, L_OPER, "Warning: fork failed for server "
1102 "%s -- check servlink_path (%s)",
1103 get_client_name(client_p, MASK_IP),
1104 ConfigFileEntry.servlink_path);
1105 exit_client(client_p, &me, "fork failed");
1106 return;
1107 }
1108
1109 start_io(client_p);
1110 SetServlink(client_p);
1111 }
1112
1113 /* only send ts6 format SVINFO if we have ts6 enabled */
1114 sendto_one(client_p, "SVINFO %d %d 0 :%lu",
1115 (me.id[0] ? TS_CURRENT : 5), TS_MIN,
1116 (unsigned long)CurrentTime);
1117
1118 /* assumption here is if they passed the correct TS version, they also passed an SID */
1119 if (IsCapable(client_p, CAP_TS6))
1120 hash_add_id(client_p);
1121
1122 /* XXX Does this ever happen? I don't think so -db */
1123 detach_conf(client_p, OPER_TYPE);
1124
1125 /* *WARNING*
1126 ** In the following code in place of plain server's
1127 ** name we send what is returned by get_client_name
1128 ** which may add the "sockhost" after the name. It's
1129 ** *very* *important* that there is a SPACE between
1130 ** the name and sockhost (if present). The receiving
1131 ** server will start the information field from this
1132 ** first blank and thus puts the sockhost into info.
1133 ** ...a bit tricky, but you have been warned, besides
1134 ** code is more neat this way... --msa
1135 */
1136 client_p->servptr = &me;
1137
1138 if (IsClosing(client_p))
1139 return;
1140
1141 SetServer(client_p);
1142
1143 /* Update the capability combination usage counts. -A1kmm */
1144 set_chcap_usage_counts(client_p);
1145
1146 /* Some day, all these lists will be consolidated *sigh* */
1147 dlinkAdd(client_p, &client_p->lnode, &me.serv->servers);
1148
1149 m = dlinkFind(&unknown_list, client_p);
1150 assert(NULL != m);
1151
1152 dlinkDelete(m, &unknown_list);
1153 dlinkAdd(client_p, m, &serv_list);
1154
1155 Count.myserver++;
1156
1157 dlinkAdd(client_p, make_dlink_node(), &global_serv_list);
1158 hash_add_client(client_p);
1159
1160 /* doesnt duplicate client_p->serv if allocated this struct already */
1161 make_server(client_p);
1162
1163 /* fixing eob timings.. -gnp */
1164 client_p->firsttime = CurrentTime;
1165
1166 /* Show the real host/IP to admins */
1167 sendto_realops_flags(UMODE_ALL, L_ADMIN,
1168 "Link with %s established: (%s) link",
1169 inpath_ip,show_capabilities(client_p));
1170 /* Now show the masked hostname/IP to opers */
1171 sendto_realops_flags(UMODE_ALL, L_OPER,
1172 "Link with %s established: (%s) link",
1173 inpath,show_capabilities(client_p));
1174 ilog(L_NOTICE, "Link with %s established: (%s) link",
1175 inpath_ip, show_capabilities(client_p));
1176
1177 client_p->serv->sconf = conf;
1178
1179 if (HasServlink(client_p))
1180 {
1181 /* we won't overflow FD_DESC_SZ here, as it can hold
1182 * client_p->name + 64
1183 */
1184 fd_note(&client_p->localClient->fd, "slink data: %s", client_p->name);
1185 fd_note(&client_p->localClient->ctrlfd, "slink ctrl: %s", client_p->name);
1186 }
1187 else
1188 fd_note(&client_p->localClient->fd, "Server: %s", client_p->name);
1189
1190 /* Old sendto_serv_but_one() call removed because we now
1191 ** need to send different names to different servers
1192 ** (domain name matching) Send new server to other servers.
1193 */
1194 DLINK_FOREACH(ptr, serv_list.head)
1195 {
1196 target_p = ptr->data;
1197
1198 if (target_p == client_p)
1199 continue;
1200
1201 if ((conf = target_p->serv->sconf) &&
1202 match(my_name_for_link(conf), client_p->name))
1203 continue;
1204
1205 if (IsCapable(target_p, CAP_TS6) && HasID(client_p))
1206 sendto_one(target_p, ":%s SID %s 2 %s :%s%s",
1207 me.id, client_p->name, client_p->id,
1208 IsHidden(client_p) ? "(H) " : "",
1209 client_p->info);
1210 else
1211 sendto_one(target_p,":%s SERVER %s 2 :%s%s",
1212 me.name, client_p->name,
1213 IsHidden(client_p) ? "(H) " : "",
1214 client_p->info);
1215 }
1216
1217 /* Pass on my client information to the new server
1218 **
1219 ** First, pass only servers (idea is that if the link gets
1220 ** cancelled beacause the server was already there,
1221 ** there are no NICK's to be cancelled...). Of course,
1222 ** if cancellation occurs, all this info is sent anyway,
1223 ** and I guess the link dies when a read is attempted...? --msa
1224 **
1225 ** Note: Link cancellation to occur at this point means
1226 ** that at least two servers from my fragment are building
1227 ** up connection this other fragment at the same time, it's
1228 ** a race condition, not the normal way of operation...
1229 **
1230 ** ALSO NOTE: using the get_client_name for server names--
1231 ** see previous *WARNING*!!! (Also, original inpath
1232 ** is destroyed...)
1233 */
1234
1235 conf = client_p->serv->sconf;
1236
1237 DLINK_FOREACH_PREV(ptr, global_serv_list.tail)
1238 {
1239 target_p = ptr->data;
1240
1241 /* target_p->from == target_p for target_p == client_p */
1242 if (target_p->from == client_p)
1243 continue;
1244
1245 if (match(my_name_for_link(conf), target_p->name))
1246 continue;
1247
1248 if (IsCapable(client_p, CAP_TS6))
1249 {
1250 if (HasID(target_p))
1251 sendto_one(client_p, ":%s SID %s %d %s :%s%s",
1252 ID(target_p->servptr), target_p->name, target_p->hopcount+1,
1253 target_p->id, IsHidden(target_p) ? "(H) " : "",
1254 target_p->info);
1255 else /* introducing non-ts6 server */
1256 sendto_one(client_p, ":%s SERVER %s %d :%s%s",
1257 ID(target_p->servptr), target_p->name, target_p->hopcount+1,
1258 IsHidden(target_p) ? "(H) " : "", target_p->info);
1259 }
1260 else
1261 sendto_one(client_p, ":%s SERVER %s %d :%s%s",
1262 target_p->servptr->name, target_p->name, target_p->hopcount+1,
1263 IsHidden(target_p) ? "(H) " : "", target_p->info);
1264 }
1265
1266 if ((ServerInfo.hub == 0) && MyConnect(client_p))
1267 uplink = client_p;
1268
1269 server_burst(client_p);
1270 }
1271
1272 static void
1273 start_io(struct Client *server)
1274 {
1275 struct LocalUser *lserver = server->localClient;
1276 int alloclen = 1;
1277 char *buf;
1278 dlink_node *ptr;
1279 struct dbuf_block *block;
1280
1281 /* calculate how many bytes to allocate */
1282 if (IsCapable(server, CAP_ZIP))
1283 alloclen += 6;
1284 #ifdef HAVE_LIBCRYPTO
1285 if (IsCapable(server, CAP_ENC))
1286 alloclen += 16 + lserver->in_cipher->keylen + lserver->out_cipher->keylen;
1287 #endif
1288 alloclen += dbuf_length(&lserver->buf_recvq);
1289 alloclen += dlink_list_length(&lserver->buf_recvq.blocks) * 3;
1290 alloclen += dbuf_length(&lserver->buf_sendq);
1291 alloclen += dlink_list_length(&lserver->buf_sendq.blocks) * 3;
1292
1293 /* initialize servlink control sendq */
1294 lserver->slinkq = buf = MyMalloc(alloclen);
1295 lserver->slinkq_ofs = 0;
1296 lserver->slinkq_len = alloclen;
1297
1298 if (IsCapable(server, CAP_ZIP))
1299 {
1300 /* ziplink */
1301 *buf++ = SLINKCMD_SET_ZIP_OUT_LEVEL;
1302 *buf++ = 0; /* | */
1303 *buf++ = 1; /* \ len is 1 */
1304 *buf++ = ConfigFileEntry.compression_level;
1305 *buf++ = SLINKCMD_START_ZIP_IN;
1306 *buf++ = SLINKCMD_START_ZIP_OUT;
1307 }
1308 #ifdef HAVE_LIBCRYPTO
1309 if (IsCapable(server, CAP_ENC))
1310 {
1311 /* Decryption settings */
1312 *buf++ = SLINKCMD_SET_CRYPT_IN_CIPHER;
1313 *buf++ = 0; /* / (upper 8-bits of len) */
1314 *buf++ = 1; /* \ cipher id is 1 byte (lower 8-bits of len) */
1315 *buf++ = lserver->in_cipher->cipherid;
1316 *buf++ = SLINKCMD_SET_CRYPT_IN_KEY;
1317 *buf++ = 0; /* keylen < 256 */
1318 *buf++ = lserver->in_cipher->keylen;
1319 memcpy(buf, lserver->in_key, lserver->in_cipher->keylen);
1320 buf += lserver->in_cipher->keylen;
1321 /* Encryption settings */
1322 *buf++ = SLINKCMD_SET_CRYPT_OUT_CIPHER;
1323 *buf++ = 0; /* / (upper 8-bits of len) */
1324 *buf++ = 1; /* \ cipher id is 1 byte (lower 8-bits of len) */
1325 *buf++ = lserver->out_cipher->cipherid;
1326 *buf++ = SLINKCMD_SET_CRYPT_OUT_KEY;
1327 *buf++ = 0; /* keylen < 256 */
1328 *buf++ = lserver->out_cipher->keylen;
1329 memcpy(buf, lserver->out_key, lserver->out_cipher->keylen);
1330 buf += lserver->out_cipher->keylen;
1331 *buf++ = SLINKCMD_START_CRYPT_IN;
1332 *buf++ = SLINKCMD_START_CRYPT_OUT;
1333 }
1334 #endif
1335
1336 /* pass the whole recvq to servlink */
1337 DLINK_FOREACH (ptr, lserver->buf_recvq.blocks.head)
1338 {
1339 block = ptr->data;
1340 *buf++ = SLINKCMD_INJECT_RECVQ;
1341 *buf++ = (block->size >> 8);
1342 *buf++ = (block->size & 0xff);
1343 memcpy(buf, &block->data[0], block->size);
1344 buf += block->size;
1345 }
1346
1347 dbuf_clear(&lserver->buf_recvq);
1348
1349 /* pass the whole sendq to servlink */
1350 DLINK_FOREACH (ptr, lserver->buf_sendq.blocks.head)
1351 {
1352 block = ptr->data;
1353 *buf++ = SLINKCMD_INJECT_SENDQ;
1354 *buf++ = (block->size >> 8);
1355 *buf++ = (block->size & 0xff);
1356 memcpy(buf, &block->data[0], block->size);
1357 buf += block->size;
1358 }
1359
1360 dbuf_clear(&lserver->buf_sendq);
1361
1362 /* start io */
1363 *buf++ = SLINKCMD_INIT;
1364
1365 /* schedule a write */
1366 send_queued_slink_write(server);
1367 }
1368
1369 /* fork_server()
1370 *
1371 * inputs - struct Client *server
1372 * output - success: 0 / failure: -1
1373 * side effect - fork, and exec SERVLINK to handle this connection
1374 */
1375 static int
1376 fork_server(struct Client *server)
1377 {
1378 #ifndef HAVE_SOCKETPAIR
1379 return -1;
1380 #else
1381 int i;
1382 int slink_fds[2][2];
1383 /* 0? - ctrl | 1? - data
1384 * ?0 - child | ?1 - parent */
1385
1386 if (socketpair(AF_UNIX, SOCK_STREAM, 0, slink_fds[0]) < 0)
1387 return -1;
1388 if (socketpair(AF_UNIX, SOCK_STREAM, 0, slink_fds[1]) < 0)
1389 goto free_ctrl_fds;
1390
1391 if ((i = fork()) < 0)
1392 {
1393 close(slink_fds[1][0]); close(slink_fds[1][1]);
1394 free_ctrl_fds:
1395 close(slink_fds[0][0]); close(slink_fds[0][1]);
1396 return -1;
1397 }
1398
1399 if (i == 0)
1400 {
1401 char fd_str[3][6]; /* store 3x sizeof("65535") */
1402 char *kid_argv[7];
1403
1404 #ifdef O_ASYNC
1405 fcntl(server->localClient->fd.fd, F_SETFL,
1406 fcntl(server->localClient->fd.fd, F_GETFL, 0) & ~O_ASYNC);
1407 #endif
1408 close_fds(&server->localClient->fd);
1409 close(slink_fds[0][1]);
1410 close(slink_fds[1][1]);
1411
1412 sprintf(fd_str[0], "%d", slink_fds[0][0]);
1413 sprintf(fd_str[1], "%d", slink_fds[1][0]);
1414 sprintf(fd_str[2], "%d", server->localClient->fd.fd);
1415
1416 kid_argv[0] = "-slink";
1417 kid_argv[1] = kid_argv[2] = fd_str[0]; /* ctrl */
1418 kid_argv[3] = kid_argv[4] = fd_str[1]; /* data */
1419 kid_argv[5] = fd_str[2]; /* network */
1420 kid_argv[6] = NULL;
1421
1422 execv(ConfigFileEntry.servlink_path, kid_argv);
1423
1424 _exit(1);
1425 }
1426
1427 /* close the network fd and the child ends of the pipes */
1428 fd_close(&server->localClient->fd);
1429 close(slink_fds[0][0]);
1430 close(slink_fds[1][0]);
1431
1432 execute_callback(setup_socket_cb, slink_fds[0][1]);
1433 execute_callback(setup_socket_cb, slink_fds[1][1]);
1434
1435 fd_open(&server->localClient->ctrlfd, slink_fds[0][1], 1, "slink ctrl");
1436 fd_open(&server->localClient->fd, slink_fds[1][1], 1, "slink data");
1437
1438 read_ctrl_packet(&server->localClient->ctrlfd, server);
1439 read_packet(&server->localClient->fd, server);
1440
1441 return 0;
1442 #endif
1443 }
1444
1445 /* server_burst()
1446 *
1447 * inputs - struct Client pointer server
1448 * -
1449 * output - none
1450 * side effects - send a server burst
1451 * bugs - still too long
1452 */
1453 static void
1454 server_burst(struct Client *client_p)
1455 {
1456 /* Send it in the shortened format with the TS, if
1457 ** it's a TS server; walk the list of channels, sending
1458 ** all the nicks that haven't been sent yet for each
1459 ** channel, then send the channel itself -- it's less
1460 ** obvious than sending all nicks first, but on the
1461 ** receiving side memory will be allocated more nicely
1462 ** saving a few seconds in the handling of a split
1463 ** -orabidoo
1464 */
1465
1466 /* On a "lazy link" hubs send nothing.
1467 * Leafs always have to send nicks plus channels
1468 */
1469 if (IsCapable(client_p, CAP_LL))
1470 {
1471 if (!ServerInfo.hub)
1472 {
1473 /* burst all our info */
1474 burst_all(client_p);
1475
1476 /* Now, ask for channel info on all our current channels */
1477 cjoin_all(client_p);
1478 }
1479 }
1480 else
1481 {
1482 burst_all(client_p);
1483 }
1484
1485 /* EOB stuff is now in burst_all */
1486 /* Always send a PING after connect burst is done */
1487 sendto_one(client_p, "PING :%s", ID_or_name(&me, client_p));
1488 }
1489
1490 /* burst_all()
1491 *
1492 * inputs - pointer to server to send burst to
1493 * output - NONE
1494 * side effects - complete burst of channels/nicks is sent to client_p
1495 */
1496 static void
1497 burst_all(struct Client *client_p)
1498 {
1499 dlink_node *ptr = NULL;
1500
1501 DLINK_FOREACH(ptr, global_channel_list.head)
1502 {
1503 struct Channel *chptr = ptr->data;
1504
1505 if (dlink_list_length(&chptr->members) != 0)
1506 {
1507 burst_members(client_p, chptr);
1508 send_channel_modes(client_p, chptr);
1509
1510 if (IsCapable(client_p, CAP_TBURST) ||
1511 IsCapable(client_p, CAP_TB))
1512 send_tb(client_p, chptr);
1513 }
1514 }
1515
1516 /* also send out those that are not on any channel
1517 */
1518 DLINK_FOREACH(ptr, global_client_list.head)
1519 {
1520 struct Client *target_p = ptr->data;
1521
1522 if (!IsBursted(target_p) && target_p->from != client_p)
1523 sendnick_TS(client_p, target_p);
1524
1525 ClearBursted(target_p);
1526 }
1527
1528 /* We send the time we started the burst, and let the remote host determine an EOB time,
1529 ** as otherwise we end up sending a EOB of 0 Sending here means it gets sent last -- fl
1530 */
1531 /* Its simpler to just send EOB and use the time its been connected.. --fl_ */
1532 if (IsCapable(client_p, CAP_EOB))
1533 sendto_one(client_p, ":%s EOB", ID_or_name(&me, client_p));
1534 }
1535
1536 /*
1537 * send_tb
1538 *
1539 * inputs - pointer to Client
1540 * - pointer to channel
1541 * output - NONE
1542 * side effects - Called on a server burst when
1543 * server is CAP_TB|CAP_TBURST capable
1544 */
1545 static void
1546 send_tb(struct Client *client_p, struct Channel *chptr)
1547 {
1548 /*
1549 * We may also send an empty topic here, but only if topic_time isn't 0,
1550 * i.e. if we had a topic that got unset. This is required for syncing
1551 * topics properly.
1552 *
1553 * Imagine the following scenario: Our downlink introduces a channel
1554 * to us with a TS that is equal to ours, but the channel topic on
1555 * their side got unset while the servers were in splitmode, which means
1556 * their 'topic' is newer. They simply wanted to unset it, so we have to
1557 * deal with it in a more sophisticated fashion instead of just resetting
1558 * it to their old topic they had before. Read m_tburst.c:ms_tburst
1559 * for further information -Michael
1560 */
1561 if (chptr->topic_time != 0)
1562 {
1563 if (IsCapable(client_p, CAP_TBURST))
1564 sendto_one(client_p, ":%s TBURST %lu %s %lu %s :%s",
1565 me.name, (unsigned long)chptr->channelts, chptr->chname,
1566 (unsigned long)chptr->topic_time,
1567 chptr->topic_info ? chptr->topic_info : "",
1568 chptr->topic ? chptr->topic : "");
1569 else if (IsCapable(client_p, CAP_TB))
1570 {
1571 if (ConfigChannel.burst_topicwho)
1572 {
1573 sendto_one(client_p, ":%s TB %s %lu %s :%s",
1574 me.name, chptr->chname,
1575 (unsigned long)chptr->topic_time,
1576 chptr->topic_info, chptr->topic ? chptr->topic : "");
1577 }
1578 else
1579 {
1580 sendto_one(client_p, ":%s TB %s %lu :%s",
1581 me.name, chptr->chname,
1582 (unsigned long)chptr->topic_time,
1583 chptr->topic ? chptr->topic : "");
1584 }
1585 }
1586 }
1587 }
1588
1589 /* cjoin_all()
1590 *
1591 * inputs - server to ask for channel info from
1592 * output - NONE
1593 * side effects - CJOINS for all the leafs known channels is sent
1594 */
1595 static void
1596 cjoin_all(struct Client *client_p)
1597 {
1598 const dlink_node *gptr = NULL;
1599
1600 DLINK_FOREACH(gptr, global_channel_list.head)
1601 {
1602 const struct Channel *chptr = gptr->data;
1603 sendto_one(client_p, ":%s CBURST %s",
1604 me.name, chptr->chname);
1605 }
1606 }
1607
1608 /* burst_channel()
1609 *
1610 * inputs - pointer to server to send sjoins to
1611 * - channel pointer
1612 * output - none
1613 * side effects - All sjoins for channel(s) given by chptr are sent
1614 * for all channel members. ONLY called by hub on
1615 * behalf of a lazylink so client_p is always guarunteed
1616 * to be a LL leaf.
1617 */
1618 void
1619 burst_channel(struct Client *client_p, struct Channel *chptr)
1620 {
1621 burst_ll_members(client_p, chptr);
1622
1623 send_channel_modes(client_p, chptr);
1624 add_lazylinkchannel(client_p,chptr);
1625
1626 if (chptr->topic != NULL && chptr->topic_info != NULL)
1627 {
1628 sendto_one(client_p, ":%s TOPIC %s %s %lu :%s",
1629 me.name, chptr->chname, chptr->topic_info,
1630 (unsigned long)chptr->topic_time, chptr->topic);
1631 }
1632 }
1633
1634 /* add_lazlinkchannel()
1635 *
1636 * inputs - pointer to directly connected leaf server
1637 * being introduced to this hub
1638 * - pointer to channel structure being introduced
1639 * output - NONE
1640 * side effects - The channel pointed to by chptr is now known
1641 * to be on lazyleaf server given by local_server_p.
1642 * mark that in the bit map and add to the list
1643 * of channels to examine after this newly introduced
1644 * server is squit off.
1645 */
1646 static void
1647 add_lazylinkchannel(struct Client *local_server_p, struct Channel *chptr)
1648 {
1649 assert(MyConnect(local_server_p));
1650
1651 chptr->lazyLinkChannelExists |= local_server_p->localClient->serverMask;
1652 dlinkAdd(chptr, make_dlink_node(), &lazylink_channels);
1653 }
1654
1655 /* add_lazylinkclient()
1656 *
1657 * inputs - pointer to directly connected leaf server
1658 * being introduced to this hub
1659 * - pointer to client being introduced
1660 * output - NONE
1661 * side effects - The client pointed to by client_p is now known
1662 * to be on lazyleaf server given by local_server_p.
1663 * mark that in the bit map and add to the list
1664 * of clients to examine after this newly introduced
1665 * server is squit off.
1666 */
1667 void
1668 add_lazylinkclient(struct Client *local_server_p, struct Client *client_p)
1669 {
1670 assert(MyConnect(local_server_p));
1671 client_p->lazyLinkClientExists |= local_server_p->localClient->serverMask;
1672 }
1673
1674 /* remove_lazylink_flags()
1675 *
1676 * inputs - pointer to server quitting
1677 * output - NONE
1678 * side effects - All the channels on the lazylink channel list are examined
1679 * If they hold a bit corresponding to the servermask
1680 * attached to client_p, clear that bit. If this bitmask
1681 * goes to 0, then the channel is no longer known to
1682 * be on any lazylink server, and can be removed from the
1683 * link list.
1684 *
1685 * Similar is done for lazylink clients
1686 *
1687 * This function must be run by the HUB on any exiting
1688 * lazylink leaf server, while the pointer is still valid.
1689 * Hence must be run from client.c in exit_one_client()
1690 *
1691 * The old code scanned all channels, this code only
1692 * scans channels/clients on the lazylink_channels
1693 * lazylink_clients lists.
1694 */
1695 void
1696 remove_lazylink_flags(unsigned long mask)
1697 {
1698 dlink_node *ptr;
1699 dlink_node *next_ptr;
1700 struct Channel *chptr;
1701 struct Client *target_p;
1702 unsigned long clear_mask;
1703
1704 if (!mask) /* On 0 mask, don't do anything */
1705 return;
1706
1707 clear_mask = ~mask;
1708 freeMask |= mask;
1709
1710 DLINK_FOREACH_SAFE(ptr, next_ptr, lazylink_channels.head)
1711 {
1712 chptr = ptr->data;
1713
1714 chptr->lazyLinkChannelExists &= clear_mask;
1715
1716 if (chptr->lazyLinkChannelExists == 0)
1717 {
1718 dlinkDelete(ptr, &lazylink_channels);
1719 free_dlink_node(ptr);
1720 }
1721 }
1722
1723 DLINK_FOREACH(ptr, global_client_list.head)
1724 {
1725 target_p = ptr->data;
1726 target_p->lazyLinkClientExists &= clear_mask;
1727 }
1728 }
1729
1730 /* burst_members()
1731 *
1732 * inputs - pointer to server to send members to
1733 * - dlink_list pointer to membership list to send
1734 * output - NONE
1735 * side effects -
1736 */
1737 static void
1738 burst_members(struct Client *client_p, struct Channel *chptr)
1739 {
1740 struct Client *target_p;
1741 struct Membership *ms;
1742 dlink_node *ptr;
1743
1744 DLINK_FOREACH(ptr, chptr->members.head)
1745 {
1746 ms = ptr->data;
1747 target_p = ms->client_p;
1748
1749 if (!IsBursted(target_p))
1750 {
1751 SetBursted(target_p);
1752
1753 if (target_p->from != client_p)
1754 sendnick_TS(client_p, target_p);
1755 }
1756 }
1757 }
1758
1759 /* burst_ll_members()
1760 *
1761 * inputs - pointer to server to send members to
1762 * - dlink_list pointer to membership list to send
1763 * output - NONE
1764 * side effects - This version also has to check the bitmap for lazylink
1765 */
1766 static void
1767 burst_ll_members(struct Client *client_p, struct Channel *chptr)
1768 {
1769 struct Client *target_p;
1770 struct Membership *ms;
1771 dlink_node *ptr;
1772
1773 DLINK_FOREACH(ptr, chptr->members.head)
1774 {
1775 ms = ptr->data;
1776 target_p = ms->client_p;
1777
1778 if ((target_p->lazyLinkClientExists & client_p->localClient->serverMask) == 0)
1779 {
1780 if (target_p->from != client_p)
1781 {
1782 add_lazylinkclient(client_p,target_p);
1783 sendnick_TS(client_p, target_p);
1784 }
1785 }
1786 }
1787 }
1788
1789 /* set_autoconn()
1790 *
1791 * inputs - struct Client pointer to oper requesting change
1792 * output - none
1793 * side effects - set autoconnect mode
1794 */
1795 void
1796 set_autoconn(struct Client *source_p, const char *name, int newval)
1797 {
1798 struct ConfItem *conf;
1799 struct AccessItem *aconf;
1800
1801 if (name != NULL)
1802 {
1803 conf = find_exact_name_conf(SERVER_TYPE, name, NULL, NULL);
1804 if (conf != NULL)
1805 {
1806 aconf = (struct AccessItem *)map_to_conf(conf);
1807 if (newval)
1808 SetConfAllowAutoConn(aconf);
1809 else
1810 ClearConfAllowAutoConn(aconf);
1811
1812 sendto_realops_flags(UMODE_ALL, L_ALL,
1813 "%s has changed AUTOCONN for %s to %i",
1814 source_p->name, name, newval);
1815 sendto_one(source_p,
1816 ":%s NOTICE %s :AUTOCONN for %s is now set to %i",
1817 me.name, source_p->name, name, newval);
1818 }
1819 else
1820 {
1821 sendto_one(source_p, ":%s NOTICE %s :Can't find %s",
1822 me.name, source_p->name, name);
1823 }
1824 }
1825 else
1826 {
1827 sendto_one(source_p, ":%s NOTICE %s :Please specify a server name!",
1828 me.name, source_p->name);
1829 }
1830 }
1831
1832 void
1833 initServerMask(void)
1834 {
1835 freeMask = 0xFFFFFFFFUL;
1836 }
1837
1838 /* nextFreeMask()
1839 *
1840 * inputs - NONE
1841 * output - unsigned long next unused mask for use in LL
1842 * side effects -
1843 */
1844 unsigned long
1845 nextFreeMask(void)
1846 {
1847 int i;
1848 unsigned long mask = 1;
1849
1850 for (i = 0; i < 32; i++)
1851 {
1852 if (mask & freeMask)
1853 {
1854 freeMask &= ~mask;
1855 return(mask);
1856 }
1857
1858 mask <<= 1;
1859 }
1860
1861 return(0L); /* watch this special case ... */
1862 }
1863
1864 /* New server connection code
1865 * Based upon the stuff floating about in s_bsd.c
1866 * -- adrian
1867 */
1868
1869 /* serv_connect() - initiate a server connection
1870 *
1871 * inputs - pointer to conf
1872 * - pointer to client doing the connect
1873 * output -
1874 * side effects -
1875 *
1876 * This code initiates a connection to a server. It first checks to make
1877 * sure the given server exists. If this is the case, it creates a socket,
1878 * creates a client, saves the socket information in the client, and
1879 * initiates a connection to the server through comm_connect_tcp(). The
1880 * completion of this goes through serv_completed_connection().
1881 *
1882 * We return 1 if the connection is attempted, since we don't know whether
1883 * it suceeded or not, and 0 if it fails in here somewhere.
1884 */
1885 int
1886 serv_connect(struct AccessItem *aconf, struct Client *by)
1887 {
1888 struct ConfItem *conf;
1889 struct Client *client_p;
1890 char buf[HOSTIPLEN];
1891
1892 /* conversion structs */
1893 struct sockaddr_in *v4;
1894 /* Make sure aconf is useful */
1895 assert(aconf != NULL);
1896
1897 if(aconf == NULL)
1898 return (0);
1899
1900 /* XXX should be passing struct ConfItem in the first place */
1901 conf = unmap_conf_item(aconf);
1902
1903 /* log */
1904 irc_getnameinfo((struct sockaddr*)&aconf->ipnum, aconf->ipnum.ss_len,
1905 buf, HOSTIPLEN, NULL, 0, NI_NUMERICHOST);
1906 ilog(L_NOTICE, "Connect to %s[%s] @%s", aconf->user, aconf->host,
1907 buf);
1908
1909 /* Still processing a DNS lookup? -> exit */
1910 if (aconf->dns_query != NULL)
1911 {
1912 sendto_realops_flags(UMODE_ALL, L_OPER,
1913 "Error connecting to %s: Error during DNS lookup", conf->name);
1914 return (0);
1915 }
1916
1917 /* Make sure this server isn't already connected
1918 * Note: aconf should ALWAYS be a valid C: line
1919 */
1920 if ((client_p = find_server(conf->name)) != NULL)
1921 {
1922 sendto_realops_flags(UMODE_ALL, L_ADMIN,
1923 "Server %s already present from %s",
1924 conf->name, get_client_name(client_p, SHOW_IP));
1925 sendto_realops_flags(UMODE_ALL, L_OPER,
1926 "Server %s already present from %s",
1927 conf->name, get_client_name(client_p, MASK_IP));
1928 if (by && IsClient(by) && !MyClient(by))
1929 sendto_one(by, ":%s NOTICE %s :Server %s already present from %s",
1930 me.name, by->name, conf->name,
1931 get_client_name(client_p, MASK_IP));
1932 return (0);
1933 }
1934
1935 /* Create a local client */
1936 client_p = make_client(NULL);
1937
1938 /* Copy in the server, hostname, fd */
1939 strlcpy(client_p->name, conf->name, sizeof(client_p->name));
1940 strlcpy(client_p->host, aconf->host, sizeof(client_p->host));
1941
1942 /* We already converted the ip once, so lets use it - stu */
1943 strlcpy(client_p->sockhost, buf, HOSTIPLEN);
1944
1945 /* create a socket for the server connection */
1946 if (comm_open(&client_p->localClient->fd, aconf->ipnum.ss.ss_family,
1947 SOCK_STREAM, 0, NULL) < 0)
1948 {
1949 /* Eek, failure to create the socket */
1950 report_error(L_ALL,
1951 "opening stream socket to %s: %s", conf->name, errno);
1952 SetDead(client_p);
1953 exit_client(client_p, &me, "Connection failed");
1954 return (0);
1955 }
1956
1957 /* servernames are always guaranteed under HOSTLEN chars */
1958 fd_note(&client_p->localClient->fd, "Server: %s", conf->name);
1959
1960 /* Attach config entries to client here rather than in
1961 * serv_connect_callback(). This to avoid null pointer references.
1962 */
1963 if (!attach_connect_block(client_p, conf->name, aconf->host))
1964 {
1965 sendto_realops_flags(UMODE_ALL, L_ALL,
1966 "Host %s is not enabled for connecting:no C/N-line",
1967 conf->name);
1968 if (by && IsClient(by) && !MyClient(by))
1969 sendto_one(by, ":%s NOTICE %s :Connect to host %s failed.",
1970 me.name, by->name, client_p->name);
1971 SetDead(client_p);
1972 exit_client(client_p, client_p, "Connection failed");
1973 return (0);
1974 }
1975
1976 /* at this point we have a connection in progress and C/N lines
1977 * attached to the client, the socket info should be saved in the
1978 * client and it should either be resolved or have a valid address.
1979 *
1980 * The socket has been connected or connect is in progress.
1981 */
1982 make_server(client_p);
1983
1984 if (by && IsClient(by))
1985 strlcpy(client_p->serv->by, by->name, sizeof(client_p->serv->by));
1986 else
1987 strlcpy(client_p->serv->by, "AutoConn.", sizeof(client_p->serv->by));
1988
1989 SetConnecting(client_p);
1990 dlinkAdd(client_p, &client_p->node, &global_client_list);
1991 /* from def_fam */
1992 client_p->localClient->aftype = aconf->aftype;
1993
1994 /* Now, initiate the connection */
1995 /* XXX assume that a non 0 type means a specific bind address
1996 * for this connect.
1997 */
1998 switch (aconf->aftype)
1999 {
2000 case AF_INET:
2001 v4 = (struct sockaddr_in*)&aconf->my_ipnum;
2002 if (v4->sin_addr.s_addr != 0)
2003 {
2004 struct irc_ssaddr ipn;
2005 memset(&ipn, 0, sizeof(struct irc_ssaddr));
2006 ipn.ss.ss_family = AF_INET;
2007 ipn.ss_port = 0;
2008 memcpy(&ipn, &aconf->my_ipnum, sizeof(struct irc_ssaddr));
2009 comm_connect_tcp(&client_p->localClient->fd, aconf->host, aconf->port,
2010 (struct sockaddr *)&ipn, ipn.ss_len,
2011 serv_connect_callback, client_p, aconf->aftype,
2012 CONNECTTIMEOUT);
2013 }
2014 else if (ServerInfo.specific_ipv4_vhost)
2015 {
2016 struct irc_ssaddr ipn;
2017 memset(&ipn, 0, sizeof(struct irc_ssaddr));
2018 ipn.ss.ss_family = AF_INET;
2019 ipn.ss_port = 0;
2020 memcpy(&ipn, &ServerInfo.ip, sizeof(struct irc_ssaddr));
2021 comm_connect_tcp(&client_p->localClient->fd, aconf->host, aconf->port,
2022 (struct sockaddr *)&ipn, ipn.ss_len,
2023 serv_connect_callback, client_p, aconf->aftype,
2024 CONNECTTIMEOUT);
2025 }
2026 else
2027 comm_connect_tcp(&client_p->localClient->fd, aconf->host, aconf->port,
2028 NULL, 0, serv_connect_callback, client_p, aconf->aftype,
2029 CONNECTTIMEOUT);
2030 break;
2031 #ifdef IPV6
2032 case AF_INET6:
2033 {
2034 struct irc_ssaddr ipn;
2035 struct sockaddr_in6 *v6;
2036 struct sockaddr_in6 *v6conf;
2037
2038 memset(&ipn, 0, sizeof(struct irc_ssaddr));
2039 v6conf = (struct sockaddr_in6 *)&aconf->my_ipnum;
2040 v6 = (struct sockaddr_in6 *)&ipn;
2041
2042 if (memcmp(&v6conf->sin6_addr, &v6->sin6_addr,
2043 sizeof(struct in6_addr)) != 0)
2044 {
2045 memcpy(&ipn, &aconf->my_ipnum, 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 if (ServerInfo.specific_ipv6_vhost)
2055 {
2056 memcpy(&ipn, &ServerInfo.ip6, sizeof(struct irc_ssaddr));
2057 ipn.ss.ss_family = AF_INET6;
2058 ipn.ss_port = 0;
2059 comm_connect_tcp(&client_p->localClient->fd,
2060 aconf->host, aconf->port,
2061 (struct sockaddr *)&ipn, ipn.ss_len,
2062 serv_connect_callback, client_p,
2063 aconf->aftype, CONNECTTIMEOUT);
2064 }
2065 else
2066 comm_connect_tcp(&client_p->localClient->fd,
2067 aconf->host, aconf->port,
2068 NULL, 0, serv_connect_callback, client_p,
2069 aconf->aftype, CONNECTTIMEOUT);
2070 }
2071 #endif
2072 }
2073 return (1);
2074 }
2075
2076 /* serv_connect_callback() - complete a server connection.
2077 *
2078 * This routine is called after the server connection attempt has
2079 * completed. If unsucessful, an error is sent to ops and the client
2080 * is closed. If sucessful, it goes through the initialisation/check
2081 * procedures, the capabilities are sent, and the socket is then
2082 * marked for reading.
2083 */
2084 static void
2085 serv_connect_callback(fde_t *fd, int status, void *data)
2086 {
2087 struct Client *client_p = data;
2088 struct ConfItem *conf=NULL;
2089 struct AccessItem *aconf=NULL;
2090
2091 /* First, make sure its a real client! */
2092 assert(client_p != NULL);
2093 assert(&client_p->localClient->fd == fd);
2094
2095 /* Next, for backward purposes, record the ip of the server */
2096 memcpy(&client_p->localClient->ip, &fd->connect.hostaddr,
2097 sizeof(struct irc_ssaddr));
2098 /* Check the status */
2099 if (status != COMM_OK)
2100 {
2101 /* We have an error, so report it and quit
2102 * Admins get to see any IP, mere opers don't *sigh*
2103 */
2104 if (ConfigServerHide.hide_server_ips)
2105 sendto_realops_flags(UMODE_ALL, L_ADMIN,
2106 "Error connecting to %s: %s",
2107 client_p->name, comm_errstr(status));
2108 else
2109 sendto_realops_flags(UMODE_ALL, L_ADMIN,
2110 "Error connecting to %s[%s]: %s", client_p->name,
2111 client_p->host, comm_errstr(status));
2112
2113 sendto_realops_flags(UMODE_ALL, L_OPER,
2114 "Error connecting to %s: %s",
2115 client_p->name, comm_errstr(status));
2116
2117 /* If a fd goes bad, call dead_link() the socket is no
2118 * longer valid for reading or writing.
2119 */
2120 dead_link_on_write(client_p, 0);
2121 return;
2122 }
2123
2124 /* COMM_OK, so continue the connection procedure */
2125 /* Get the C/N lines */
2126 conf = find_conf_name(&client_p->localClient->confs,
2127 client_p->name, SERVER_TYPE);
2128 if (conf == NULL)
2129 {
2130 sendto_realops_flags(UMODE_ALL, L_ADMIN,
2131 "Lost connect{} block for %s", get_client_name(client_p, HIDE_IP));
2132 sendto_realops_flags(UMODE_ALL, L_OPER,
2133 "Lost connect{} block for %s", get_client_name(client_p, MASK_IP));
2134
2135 exit_client(client_p, &me, "Lost connect{} block");
2136 return;
2137 }
2138
2139 aconf = (struct AccessItem *)map_to_conf(conf);
2140 /* Next, send the initial handshake */
2141 SetHandshake(client_p);
2142
2143 #ifdef HAVE_LIBCRYPTO
2144 /* Handle all CRYPTLINK links in cryptlink_init */
2145 if (IsConfCryptLink(aconf))
2146 {
2147 cryptlink_init(client_p, conf, fd);
2148 return;
2149 }
2150 #endif
2151
2152 /* jdc -- Check and send spasswd, not passwd. */
2153 if (!EmptyString(aconf->spasswd) && (me.id[0] != '\0'))
2154 /* Send TS 6 form only if id */
2155 sendto_one(client_p, "PASS %s TS %d %s",
2156 aconf->spasswd, TS_CURRENT, me.id);
2157 else
2158 sendto_one(client_p, "PASS %s TS 5",
2159 aconf->spasswd);
2160
2161 /* Pass my info to the new server
2162 *
2163 * If trying to negotiate LazyLinks, pass on CAP_LL
2164 * If this is a HUB, pass on CAP_HUB
2165 * Pass on ZIP if supported
2166 * Pass on TB if supported.
2167 * - Dianora
2168 */
2169 send_capabilities(client_p, aconf, (ServerInfo.hub ? CAP_HUB : 0)
2170 | (IsConfLazyLink(aconf) ? CAP_LL : 0)
2171 | (IsConfCompressed(aconf) ? CAP_ZIP : 0)
2172 | (IsConfTopicBurst(aconf) ? CAP_TBURST|CAP_TB : 0), 0);
2173
2174 sendto_one(client_p, "SERVER %s 1 :%s%s",
2175 my_name_for_link(conf),
2176 ConfigServerHide.hidden ? "(H) " : "",
2177 me.info);
2178
2179 /* If we've been marked dead because a send failed, just exit
2180 * here now and save everyone the trouble of us ever existing.
2181 */
2182 if (IsDead(client_p))
2183 {
2184 sendto_realops_flags(UMODE_ALL, L_ADMIN,
2185 "%s[%s] went dead during handshake",
2186 client_p->name,
2187 client_p->host);
2188 sendto_realops_flags(UMODE_ALL, L_OPER,
2189 "%s went dead during handshake", client_p->name);
2190 return;
2191 }
2192
2193 /* don't move to serv_list yet -- we haven't sent a burst! */
2194 /* If we get here, we're ok, so lets start reading some data */
2195 comm_setselect(fd, COMM_SELECT_READ, read_packet, client_p, 0);
2196 }
2197
2198 struct Client *
2199 find_servconn_in_progress(const char *name)
2200 {
2201 dlink_node *ptr;
2202 struct Client *cptr;
2203
2204 DLINK_FOREACH(ptr, unknown_list.head)
2205 {
2206 cptr = ptr->data;
2207
2208 if (cptr && cptr->name[0])
2209 if (match(cptr->name, name) || match(name, cptr->name))
2210 return cptr;
2211 }
2212
2213 return NULL;
2214 }
2215
2216 #ifdef HAVE_LIBCRYPTO
2217 /*
2218 * sends a CRYPTLINK SERV command.
2219 */
2220 void
2221 cryptlink_init(struct Client *client_p, struct ConfItem *conf, fde_t *fd)
2222 {
2223 struct AccessItem *aconf;
2224 char *encrypted;
2225 unsigned char *key_to_send;
2226 char randkey[CIPHERKEYLEN];
2227 int enc_len;
2228
2229 /* get key */
2230 if ((!ServerInfo.rsa_private_key) ||
2231 (!RSA_check_key(ServerInfo.rsa_private_key)) )
2232 {
2233 cryptlink_error(client_p, "SERV", "Invalid RSA private key",
2234 "Invalid RSA private key");
2235 return;
2236 }
2237
2238 aconf = (struct AccessItem *)map_to_conf(conf);
2239
2240 if (aconf->rsa_public_key == NULL)
2241 {
2242 cryptlink_error(client_p, "SERV", "Invalid RSA public key",
2243 "Invalid RSA public key");
2244 return;
2245 }
2246
2247 if (get_randomness((unsigned char *)randkey, CIPHERKEYLEN) != 1)
2248 {
2249 cryptlink_error(client_p, "SERV", "Couldn't generate keyphrase",
2250 "Couldn't generate keyphrase");
2251 return;
2252 }
2253
2254 encrypted = MyMalloc(RSA_size(ServerInfo.rsa_private_key));
2255 enc_len = RSA_public_encrypt(CIPHERKEYLEN,
2256 (unsigned char *)randkey,
2257 (unsigned char *)encrypted,
2258 aconf->rsa_public_key,
2259 RSA_PKCS1_PADDING);
2260
2261 memcpy(client_p->localClient->in_key, randkey, CIPHERKEYLEN);
2262
2263 if (enc_len <= 0)
2264 {
2265 report_crypto_errors();
2266 MyFree(encrypted);
2267 cryptlink_error(client_p, "SERV", "Couldn't encrypt data",
2268 "Couldn't encrypt data");
2269 return;
2270 }
2271
2272 if (!(base64_block(&key_to_send, encrypted, enc_len)))
2273 {
2274 MyFree(encrypted);
2275 cryptlink_error(client_p, "SERV", "Couldn't base64 encode key",
2276 "Couldn't base64 encode key");
2277 return;
2278 }
2279
2280 send_capabilities(client_p, aconf, (ServerInfo.hub ? CAP_HUB : 0)
2281 | (IsConfLazyLink(aconf) ? CAP_LL : 0)
2282 | (IsConfCompressed(aconf) ? CAP_ZIP : 0)
2283 | (IsConfTopicBurst(aconf) ? CAP_TBURST|CAP_TB : 0), CAP_ENC_MASK);
2284
2285 if (me.id[0])
2286 sendto_one(client_p, "PASS . TS %d %s", TS_CURRENT, me.id);
2287
2288 sendto_one(client_p, "CRYPTLINK SERV %s %s :%s%s",
2289 my_name_for_link(conf), key_to_send,
2290 ConfigServerHide.hidden ? "(H) " : "", me.info);
2291
2292 SetHandshake(client_p);
2293 SetWaitAuth(client_p);
2294
2295 MyFree(encrypted);
2296 MyFree(key_to_send);
2297
2298 if (IsDead(client_p))
2299 cryptlink_error(client_p, "SERV", "Went dead during handshake",
2300 "Went dead during handshake");
2301 else if (fd != NULL)
2302 /* If we get here, we're ok, so lets start reading some data */
2303 comm_setselect(fd, COMM_SELECT_READ, read_packet, client_p, 0);
2304 }
2305
2306 void
2307 cryptlink_error(struct Client *client_p, const char *type,
2308 const char *reason, const char *client_reason)
2309 {
2310 sendto_realops_flags(UMODE_ALL, L_ADMIN, "%s: CRYPTLINK %s error - %s",
2311 get_client_name(client_p, SHOW_IP), type, reason);
2312 sendto_realops_flags(UMODE_ALL, L_OPER, "%s: CRYPTLINK %s error - %s",
2313 get_client_name(client_p, MASK_IP), type, reason);
2314 ilog(L_ERROR, "%s: CRYPTLINK %s error - %s",
2315 get_client_name(client_p, SHOW_IP), type, reason);
2316
2317 /* If client_reason isn't NULL, then exit the client with the message
2318 * defined in the call.
2319 */
2320 if ((client_reason != NULL) && (!IsDead(client_p)))
2321 exit_client(client_p, &me, client_reason);
2322 }
2323
2324 static char base64_chars[] =
2325 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
2326
2327 static char base64_values[] =
2328 {
2329 /* 00-15 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2330 /* 16-31 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2331 /* 32-47 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
2332 /* 48-63 */ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, 0, -1, -1,
2333 /* 64-79 */ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2334 /* 80-95 */ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
2335 /* 96-111 */ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2336 /* 112-127 */ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
2337 /* 128-143 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2338 /* 144-159 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2339 /* 160-175 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2340 /* 186-191 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2341 /* 192-207 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2342 /* 208-223 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2343 /* 224-239 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2344 /* 240-255 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
2345 };
2346
2347 /*
2348 * base64_block will allocate and return a new block of memory
2349 * using MyMalloc(). It should be freed after use.
2350 */
2351 int
2352 base64_block(unsigned char **output, char *data, int len)
2353 {
2354 unsigned char *out;
2355 unsigned char *in = (unsigned char*)data;
2356 unsigned long int q_in;
2357 int i;
2358 int count = 0;
2359
2360 out = MyMalloc(((((len + 2) - ((len + 2) % 3)) / 3) * 4) + 1);
2361
2362 /* process 24 bits at a time */
2363 for( i = 0; i < len; i += 3)
2364 {
2365 q_in = 0;
2366
2367 if ( i + 2 < len )
2368 {
2369 q_in = (in[i+2] & 0xc0) << 2;
2370 q_in |= in[i+2];
2371 }
2372
2373 if ( i + 1 < len )
2374 {
2375 q_in |= (in[i+1] & 0x0f) << 10;
2376 q_in |= (in[i+1] & 0xf0) << 12;
2377 }
2378
2379 q_in |= (in[i] & 0x03) << 20;
2380 q_in |= in[i] << 22;
2381
2382 q_in &= 0x3f3f3f3f;
2383
2384 out[count++] = base64_chars[((q_in >> 24) )];
2385 out[count++] = base64_chars[((q_in >> 16) & 0xff)];
2386 out[count++] = base64_chars[((q_in >> 8) & 0xff)];
2387 out[count++] = base64_chars[((q_in ) & 0xff)];
2388 }
2389 if ( (i - len) > 0 )
2390 {
2391 out[count-1] = '=';
2392 if ( (i - len) > 1 )
2393 out[count-2] = '=';
2394 }
2395
2396 out[count] = '\0';
2397 *output = out;
2398 return (count);
2399 }
2400
2401 /*
2402 * unbase64_block will allocate and return a new block of memory
2403 * using MyMalloc(). It should be freed after use.
2404 */
2405 int
2406 unbase64_block(unsigned char **output, char *data, int len)
2407 {
2408 unsigned char *out;
2409 unsigned char *in = (unsigned char*)data;
2410 unsigned long int q_in;
2411 int i;
2412 int count = 0;
2413
2414 if ((len % 4) != 0)
2415 return (0);
2416
2417 out = MyMalloc(((len / 4) * 3) + 1);
2418
2419 /* process 32 bits at a time */
2420 for( i = 0; (i + 3) < len; i+=4)
2421 {
2422 /* compress input (chars a, b, c and d) as follows:
2423 * (after converting ascii -> base64 value)
2424 *
2425 * |00000000aaaaaabbbbbbccccccdddddd|
2426 * | 765432 107654 321076 543210|
2427 */
2428
2429 q_in = 0;
2430
2431 if (base64_values[in[i+3]] > -1)
2432 q_in |= base64_values[in[i+3]] ;
2433 if (base64_values[in[i+2]] > -1)
2434 q_in |= base64_values[in[i+2]] << 6;
2435 if (base64_values[in[i+1]] > -1)
2436 q_in |= base64_values[in[i+1]] << 12;
2437 if (base64_values[in[i ]] > -1)
2438 q_in |= base64_values[in[i ]] << 18;
2439
2440 out[count++] = (q_in >> 16) & 0xff;
2441 out[count++] = (q_in >> 8) & 0xff;
2442 out[count++] = (q_in ) & 0xff;
2443 }
2444
2445 if (in[i-1] == '=') count--;
2446 if (in[i-2] == '=') count--;
2447
2448 out[count] = '\0';
2449 *output = out;
2450 return (count);
2451 }
2452
2453 #endif /* HAVE_LIBCRYPTO */
2454

Properties

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