ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid-8/src/s_serv.c
Revision: 30
Committed: Sun Oct 2 20:03:27 2005 UTC (18 years, 5 months ago) by adx
Content type: text/x-csrc
Original Path: ircd-hybrid/src/s_serv.c
File size: 69110 byte(s)
Log Message:
- imported sources
- can be moved later according to the directory/branching scheme,
  but we need the svn up

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

Properties

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