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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1652 - (show annotations)
Tue Nov 13 20:28:53 2012 UTC (7 years, 7 months ago) by michael
File MIME type: text/x-chdr
File size: 43875 byte(s)
- changed match() polarity. match() now returns 0 on match and 1 on non-match
  This cleans up several places where function pointers of different matching
  functions like irccmp/strcmp/match are passed to other functions.
- added improved collapse() to match.c

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 "list.h"
31 #include "channel.h"
32 #include "channel_mode.h"
33 #include "client.h"
34 #include "dbuf.h"
35 #include "event.h"
36 #include "fdlist.h"
37 #include "hash.h"
38 #include "irc_string.h"
39 #include "sprintf_irc.h"
40 #include "ircd.h"
41 #include "ircd_defs.h"
42 #include "s_bsd.h"
43 #include "numeric.h"
44 #include "packet.h"
45 #include "irc_res.h"
46 #include "conf.h"
47 #include "s_serv.h"
48 #include "log.h"
49 #include "s_misc.h"
50 #include "s_user.h"
51 #include "send.h"
52 #include "memory.h"
53 #include "channel.h" /* chcap_usage_counts stuff...*/
54 #include "parse.h"
55
56 #define MIN_CONN_FREQ 300
57
58 static dlink_list cap_list = { NULL, NULL, 0 };
59 static void server_burst(struct Client *);
60 static void burst_all(struct Client *);
61 static void send_tb(struct Client *client_p, struct Channel *chptr);
62
63 static CNCB serv_connect_callback;
64
65 static void burst_members(struct Client *, struct Channel *);
66
67 /*
68 * write_links_file
69 *
70 * inputs - void pointer which is not used
71 * output - NONE
72 * side effects - called from an event, write out list of linked servers
73 * but in no particular order.
74 */
75 void
76 write_links_file(void* notused)
77 {
78 MessageFileLine *next_mptr = NULL;
79 MessageFileLine *mptr = NULL;
80 MessageFileLine *currentMessageLine = NULL;
81 MessageFileLine *newMessageLine = NULL;
82 MessageFile *MessageFileptr = &ConfigFileEntry.linksfile;
83 FILE *file;
84 char buff[512];
85 dlink_node *ptr;
86
87 if ((file = fopen(MessageFileptr->fileName, "w")) == NULL)
88 return;
89
90 for (mptr = MessageFileptr->contentsOfFile; mptr; mptr = next_mptr)
91 {
92 next_mptr = mptr->next;
93 MyFree(mptr);
94 }
95
96 MessageFileptr->contentsOfFile = NULL;
97
98 DLINK_FOREACH(ptr, global_serv_list.head)
99 {
100 const struct Client *target_p = ptr->data;
101
102 /* skip ourselves, we send ourselves in /links */
103 if (IsMe(target_p))
104 continue;
105
106 /* skip hidden servers */
107 if (IsHidden(target_p))
108 continue;
109
110 newMessageLine = MyMalloc(sizeof(MessageFileLine));
111
112 /*
113 * Attempt to format the file in such a way it follows the usual links output
114 * ie "servername uplink :hops info"
115 * Mostly for aesthetic reasons - makes it look pretty in mIRC ;)
116 * - madmax
117 */
118 snprintf(newMessageLine->line, sizeof(newMessageLine->line), "%s %s :1 %s",
119 target_p->name, me.name, target_p->info);
120
121 if (MessageFileptr->contentsOfFile)
122 {
123 if (currentMessageLine)
124 currentMessageLine->next = newMessageLine;
125 currentMessageLine = newMessageLine;
126 }
127 else
128 {
129 MessageFileptr->contentsOfFile = newMessageLine;
130 currentMessageLine = newMessageLine;
131 }
132
133 snprintf(buff, sizeof(buff), "%s %s :1 %s\n",
134 target_p->name, me.name, target_p->info);
135 fputs(buff, file);
136 }
137
138 fclose(file);
139 }
140
141 /* hunt_server()
142 * Do the basic thing in delivering the message (command)
143 * across the relays to the specific server (server) for
144 * actions.
145 *
146 * Note: The command is a format string and *MUST* be
147 * of prefixed style (e.g. ":%s COMMAND %s ...").
148 * Command can have only max 8 parameters.
149 *
150 * server parv[server] is the parameter identifying the
151 * target server.
152 *
153 * *WARNING*
154 * parv[server] is replaced with the pointer to the
155 * real servername from the matched client (I'm lazy
156 * now --msa).
157 *
158 * returns: (see #defines)
159 */
160 int
161 hunt_server(struct Client *client_p, struct Client *source_p, const char *command,
162 int server, int parc, char *parv[])
163 {
164 struct Client *target_p = NULL;
165 struct Client *target_tmp = NULL;
166 dlink_node *ptr;
167 int wilds;
168
169 /* Assume it's me, if no server */
170 if (parc <= server || EmptyString(parv[server]))
171 return HUNTED_ISME;
172
173 if (!strcmp(parv[server], me.id) || !match(parv[server], me.name))
174 return HUNTED_ISME;
175
176 /* These are to pickup matches that would cause the following
177 * message to go in the wrong direction while doing quick fast
178 * non-matching lookups.
179 */
180 if (MyClient(source_p))
181 target_p = hash_find_client(parv[server]);
182 else
183 target_p = find_person(client_p, parv[server]);
184
185 if (target_p)
186 if (target_p->from == source_p->from && !MyConnect(target_p))
187 target_p = NULL;
188
189 if (target_p == NULL && (target_p = hash_find_server(parv[server])))
190 if (target_p->from == source_p->from && !MyConnect(target_p))
191 target_p = NULL;
192
193 collapse(parv[server]);
194 wilds = has_wildcards(parv[server]);
195
196 /* Again, if there are no wild cards involved in the server
197 * name, use the hash lookup
198 */
199 if (target_p == NULL)
200 {
201 if (!wilds)
202 {
203 if (!(target_p = hash_find_server(parv[server])))
204 {
205 sendto_one(source_p, form_str(ERR_NOSUCHSERVER),
206 me.name, source_p->name, parv[server]);
207 return(HUNTED_NOSUCH);
208 }
209 }
210 else
211 {
212 DLINK_FOREACH(ptr, global_client_list.head)
213 {
214 target_tmp = ptr->data;
215
216 if (!match(parv[server], target_tmp->name))
217 {
218 if (target_tmp->from == source_p->from && !MyConnect(target_tmp))
219 continue;
220 target_p = ptr->data;
221
222 if (IsRegistered(target_p) && (target_p != client_p))
223 break;
224 }
225 }
226 }
227 }
228
229 if (target_p != NULL)
230 {
231 if(!IsRegistered(target_p))
232 {
233 sendto_one(source_p, form_str(ERR_NOSUCHSERVER),
234 me.name, source_p->name, parv[server]);
235 return HUNTED_NOSUCH;
236 }
237
238 if (IsMe(target_p) || MyClient(target_p))
239 return HUNTED_ISME;
240
241 if (match(target_p->name, parv[server]))
242 parv[server] = target_p->name;
243
244 /* This is a little kludgy but should work... */
245 if (IsClient(source_p) &&
246 ((MyConnect(target_p) && IsCapable(target_p, CAP_TS6)) ||
247 (!MyConnect(target_p) && IsCapable(target_p->from, CAP_TS6))))
248 parv[0] = ID(source_p);
249
250 sendto_one(target_p, command, parv[0],
251 parv[1], parv[2], parv[3], parv[4],
252 parv[5], parv[6], parv[7], parv[8]);
253 return(HUNTED_PASS);
254 }
255
256 sendto_one(source_p, form_str(ERR_NOSUCHSERVER),
257 me.name, source_p->name, parv[server]);
258 return(HUNTED_NOSUCH);
259 }
260
261 /* try_connections()
262 *
263 * inputs - void pointer which is not used
264 * output - NONE
265 * side effects -
266 * scan through configuration and try new connections.
267 * Returns the calendar time when the next call to this
268 * function should be made latest. (No harm done if this
269 * is called earlier or later...)
270 */
271 void
272 try_connections(void *unused)
273 {
274 dlink_node *ptr = NULL;
275 struct MaskItem *conf;
276 int confrq;
277
278 /* TODO: change this to set active flag to 0 when added to event! --Habeeb */
279 if (GlobalSetOptions.autoconn == 0)
280 return;
281
282 DLINK_FOREACH(ptr, server_items.head)
283 {
284 conf = ptr->data;
285
286 assert(conf->type == CONF_SERVER);
287
288 /* Also when already connecting! (update holdtimes) --SRB
289 */
290 if (!conf->port ||!IsConfAllowAutoConn(conf))
291 continue;
292
293
294 /* Skip this entry if the use of it is still on hold until
295 * future. Otherwise handle this entry (and set it on hold
296 * until next time). Will reset only hold times, if already
297 * made one successfull connection... [this algorithm is
298 * a bit fuzzy... -- msa >;) ]
299 */
300 if (conf->until > CurrentTime)
301 continue;
302
303 if (conf->class == NULL)
304 confrq = DEFAULT_CONNECTFREQUENCY;
305 else
306 {
307 confrq = conf->class->con_freq;
308 if (confrq < MIN_CONN_FREQ)
309 confrq = MIN_CONN_FREQ;
310 }
311
312 conf->until = CurrentTime + confrq;
313
314 /* Found a CONNECT config with port specified, scan clients
315 * and see if this server is already connected?
316 */
317 if (hash_find_server(conf->name) != NULL)
318 continue;
319
320 if (conf->class->ref_count < conf->class->max_total)
321 {
322 /* Go to the end of the list, if not already last */
323 if (ptr->next != NULL)
324 {
325 dlinkDelete(ptr, &server_items);
326 dlinkAddTail(conf, &conf->node, &server_items);
327 }
328
329 if (find_servconn_in_progress(conf->name))
330 return;
331
332 /* We used to only print this if serv_connect() actually
333 * succeeded, but since comm_tcp_connect() can call the callback
334 * immediately if there is an error, we were getting error messages
335 * in the wrong order. SO, we just print out the activated line,
336 * and let serv_connect() / serv_connect_callback() print an
337 * error afterwards if it fails.
338 * -- adrian
339 */
340 if (ConfigServerHide.hide_server_ips)
341 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
342 "Connection to %s activated.",
343 conf->name);
344 else
345 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
346 "Connection to %s[%s] activated.",
347 conf->name, conf->host);
348
349 serv_connect(conf, NULL);
350 /* We connect only one at time... */
351 return;
352 }
353 }
354 }
355
356 int
357 valid_servname(const char *name)
358 {
359 unsigned int length = 0;
360 unsigned int dots = 0;
361 const char *p = name;
362
363 for (; *p; ++p)
364 {
365 if (!IsServChar(*p))
366 return 0;
367
368 ++length;
369
370 if (*p == '.')
371 ++dots;
372 }
373
374 return dots != 0 && length <= HOSTLEN;
375 }
376
377 int
378 check_server(const char *name, struct Client *client_p)
379 {
380 dlink_node *ptr;
381 struct MaskItem *conf = NULL;
382 struct MaskItem *server_conf = NULL;
383 int error = -1;
384
385 assert(client_p != NULL);
386
387 /* loop through looking for all possible connect items that might work */
388 DLINK_FOREACH(ptr, server_items.head)
389 {
390 conf = ptr->data;
391
392 if (match(name, conf->name))
393 continue;
394
395 error = -3;
396
397 /* XXX: Fix me for IPv6 */
398 /* XXX sockhost is the IPv4 ip as a string */
399 if (!match(conf->host, client_p->host) ||
400 !match(conf->host, client_p->sockhost))
401 {
402 error = -2;
403
404 if (!match_conf_password(client_p->localClient->passwd, conf))
405 return -2;
406
407 server_conf = conf;
408 }
409 }
410
411 if (server_conf == NULL)
412 return(error);
413
414 attach_conf(client_p, server_conf);
415
416
417 if (server_conf != NULL)
418 {
419 struct sockaddr_in *v4;
420 #ifdef IPV6
421 struct sockaddr_in6 *v6;
422 #endif
423 switch (server_conf->aftype)
424 {
425 #ifdef IPV6
426 case AF_INET6:
427 v6 = (struct sockaddr_in6 *)&server_conf->addr;
428
429 if (IN6_IS_ADDR_UNSPECIFIED(&v6->sin6_addr))
430 memcpy(&server_conf->addr, &client_p->localClient->ip, sizeof(struct irc_ssaddr));
431 break;
432 #endif
433 case AF_INET:
434 v4 = (struct sockaddr_in *)&server_conf->addr;
435
436 if (v4->sin_addr.s_addr == INADDR_NONE)
437 memcpy(&server_conf->addr, &client_p->localClient->ip, sizeof(struct irc_ssaddr));
438 break;
439 }
440 }
441
442 return(0);
443 }
444
445 /* add_capability()
446 *
447 * inputs - string name of CAPAB
448 * - int flag of capability
449 * output - NONE
450 * side effects - Adds given capability name and bit mask to
451 * current supported capabilities. This allows
452 * modules to dynamically add or subtract their capability.
453 */
454 void
455 add_capability(const char *capab_name, int cap_flag, int add_to_default)
456 {
457 struct Capability *cap = MyMalloc(sizeof(*cap));
458
459 cap->name = xstrdup(capab_name);
460 cap->cap = cap_flag;
461 dlinkAdd(cap, &cap->node, &cap_list);
462
463 if (add_to_default)
464 default_server_capabs |= cap_flag;
465 }
466
467 /* delete_capability()
468 *
469 * inputs - string name of CAPAB
470 * output - NONE
471 * side effects - delete given capability from ones known.
472 */
473 int
474 delete_capability(const char *capab_name)
475 {
476 dlink_node *ptr;
477 dlink_node *next_ptr;
478 struct Capability *cap;
479
480 DLINK_FOREACH_SAFE(ptr, next_ptr, cap_list.head)
481 {
482 cap = ptr->data;
483
484 if (cap->cap != 0)
485 {
486 if (irccmp(cap->name, capab_name) == 0)
487 {
488 default_server_capabs &= ~(cap->cap);
489 dlinkDelete(ptr, &cap_list);
490 MyFree(cap->name);
491 cap->name = NULL;
492 MyFree(cap);
493 }
494 }
495 }
496
497 return 0;
498 }
499
500 /*
501 * find_capability()
502 *
503 * inputs - string name of capab to find
504 * output - 0 if not found CAPAB otherwise
505 * side effects - none
506 */
507 int
508 find_capability(const char *capab)
509 {
510 const dlink_node *ptr = NULL;
511
512 DLINK_FOREACH(ptr, cap_list.head)
513 {
514 const struct Capability *cap = ptr->data;
515
516 if (cap->cap && !irccmp(cap->name, capab))
517 return cap->cap;
518 }
519
520 return 0;
521 }
522
523 /* send_capabilities()
524 *
525 * inputs - Client pointer to send to
526 * - int flag of capabilities that this server can send
527 * output - NONE
528 * side effects - send the CAPAB line to a server -orabidoo
529 *
530 */
531 void
532 send_capabilities(struct Client *client_p, int cap_can_send)
533 {
534 struct Capability *cap=NULL;
535 char msgbuf[IRCD_BUFSIZE];
536 char *t;
537 int tl;
538 dlink_node *ptr;
539
540 t = msgbuf;
541
542 DLINK_FOREACH(ptr, cap_list.head)
543 {
544 cap = ptr->data;
545
546 if (cap->cap & (cap_can_send|default_server_capabs))
547 {
548 tl = ircsprintf(t, "%s ", cap->name);
549 t += tl;
550 }
551 }
552
553 *(t - 1) = '\0';
554 sendto_one(client_p, "CAPAB :%s", msgbuf);
555 }
556
557 /* sendnick_TS()
558 *
559 * inputs - client (server) to send nick towards
560 * - client to send nick for
561 * output - NONE
562 * side effects - NICK message is sent towards given client_p
563 */
564 void
565 sendnick_TS(struct Client *client_p, struct Client *target_p)
566 {
567 static char ubuf[12];
568
569 if (!IsClient(target_p))
570 return;
571
572 send_umode(NULL, target_p, 0, SEND_UMODES, ubuf);
573
574 if (ubuf[0] == '\0')
575 {
576 ubuf[0] = '+';
577 ubuf[1] = '\0';
578 }
579
580 if (IsCapable(client_p, CAP_SVS))
581 {
582 if (HasID(target_p) && IsCapable(client_p, CAP_TS6))
583 sendto_one(client_p, ":%s UID %s %d %lu %s %s %s %s %s %s :%s",
584 target_p->servptr->id,
585 target_p->name, target_p->hopcount + 1,
586 (unsigned long) target_p->tsinfo,
587 ubuf, target_p->username, target_p->host,
588 (MyClient(target_p) && IsIPSpoof(target_p)) ?
589 "0" : target_p->sockhost, target_p->id,
590 target_p->svid, target_p->info);
591 else
592 sendto_one(client_p, "NICK %s %d %lu %s %s %s %s %s :%s",
593 target_p->name, target_p->hopcount + 1,
594 (unsigned long) target_p->tsinfo,
595 ubuf, target_p->username, target_p->host,
596 target_p->servptr->name, target_p->svid,
597 target_p->info);
598 }
599 else
600 {
601 if (HasID(target_p) && IsCapable(client_p, CAP_TS6))
602 sendto_one(client_p, ":%s UID %s %d %lu %s %s %s %s %s :%s",
603 target_p->servptr->id,
604 target_p->name, target_p->hopcount + 1,
605 (unsigned long) target_p->tsinfo,
606 ubuf, target_p->username, target_p->host,
607 (MyClient(target_p) && IsIPSpoof(target_p)) ?
608 "0" : target_p->sockhost, target_p->id, target_p->info);
609 else
610 sendto_one(client_p, "NICK %s %d %lu %s %s %s %s :%s",
611 target_p->name, target_p->hopcount + 1,
612 (unsigned long) target_p->tsinfo,
613 ubuf, target_p->username, target_p->host,
614 target_p->servptr->name, target_p->info);
615 }
616
617 if (target_p->away[0])
618 sendto_one(client_p, ":%s AWAY :%s", ID_or_name(target_p, client_p),
619 target_p->away);
620
621 }
622
623 /*
624 * show_capabilities - show current server capabilities
625 *
626 * inputs - pointer to a struct Client
627 * output - pointer to static string
628 * side effects - build up string representing capabilities of server listed
629 */
630 const char *
631 show_capabilities(struct Client *target_p)
632 {
633 static char msgbuf[IRCD_BUFSIZE];
634 char *t = msgbuf;
635 dlink_node *ptr;
636
637 t += ircsprintf(msgbuf, "TS ");
638
639 DLINK_FOREACH(ptr, cap_list.head)
640 {
641 const struct Capability *cap = ptr->data;
642
643 if (IsCapable(target_p, cap->cap))
644 t += ircsprintf(t, "%s ", cap->name);
645 }
646
647 *(t - 1) = '\0';
648 return msgbuf;
649 }
650
651 /* make_server()
652 *
653 * inputs - pointer to client struct
654 * output - pointer to struct Server
655 * side effects - add's an Server information block to a client
656 * if it was not previously allocated.
657 */
658 struct Server *
659 make_server(struct Client *client_p)
660 {
661 if (client_p->serv == NULL)
662 client_p->serv = MyMalloc(sizeof(struct Server));
663
664 return client_p->serv;
665 }
666
667 /* server_estab()
668 *
669 * inputs - pointer to a struct Client
670 * output -
671 * side effects -
672 */
673 void
674 server_estab(struct Client *client_p)
675 {
676 struct Client *target_p;
677 struct MaskItem *conf = NULL;
678 char *host;
679 const char *inpath;
680 static char inpath_ip[HOSTLEN * 2 + USERLEN + 6];
681 dlink_node *ptr;
682 #ifdef HAVE_LIBCRYPTO
683 const COMP_METHOD *compression = NULL, *expansion = NULL;
684 #endif
685
686 assert(client_p != NULL);
687
688 strlcpy(inpath_ip, get_client_name(client_p, SHOW_IP), sizeof(inpath_ip));
689
690 inpath = get_client_name(client_p, MASK_IP); /* "refresh" inpath with host */
691 host = client_p->name;
692
693 if ((conf = find_conf_name(&client_p->localClient->confs, host, CONF_SERVER))
694 == NULL)
695 {
696 /* This shouldn't happen, better tell the ops... -A1kmm */
697 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
698 "Warning: Lost connect{} block "
699 "for server %s(this shouldn't happen)!", host);
700 exit_client(client_p, &me, "Lost connect{} block!");
701 return;
702 }
703
704 MyFree(client_p->localClient->passwd);
705 client_p->localClient->passwd = NULL;
706
707 /* Its got identd, since its a server */
708 SetGotId(client_p);
709
710 /* If there is something in the serv_list, it might be this
711 * connecting server..
712 */
713 if (!ServerInfo.hub && serv_list.head)
714 {
715 if (client_p != serv_list.head->data || serv_list.head->next)
716 {
717 ++ServerStats.is_ref;
718 sendto_one(client_p, "ERROR :I'm a leaf not a hub");
719 exit_client(client_p, &me, "I'm a leaf");
720 return;
721 }
722 }
723
724 if (IsUnknown(client_p))
725 {
726 /* jdc -- 1. Use EmptyString(), not [0] index reference.
727 * 2. Check conf->spasswd, not conf->passwd.
728 */
729 if (!EmptyString(conf->spasswd))
730 sendto_one(client_p, "PASS %s TS %d %s",
731 conf->spasswd, TS_CURRENT, me.id);
732
733 send_capabilities(client_p, 0);
734
735 sendto_one(client_p, "SERVER %s 1 :%s%s",
736 me.name, ConfigServerHide.hidden ? "(H) " : "", me.info);
737 }
738
739 sendto_one(client_p, "SVINFO %d %d 0 :%lu", TS_CURRENT, TS_MIN,
740 (unsigned long)CurrentTime);
741
742 /* assumption here is if they passed the correct TS version, they also passed an SID */
743 if (IsCapable(client_p, CAP_TS6))
744 hash_add_id(client_p);
745
746 /* XXX Does this ever happen? I don't think so -db */
747 detach_conf(client_p, CONF_OPER);
748
749 /* *WARNING*
750 ** In the following code in place of plain server's
751 ** name we send what is returned by get_client_name
752 ** which may add the "sockhost" after the name. It's
753 ** *very* *important* that there is a SPACE between
754 ** the name and sockhost (if present). The receiving
755 ** server will start the information field from this
756 ** first blank and thus puts the sockhost into info.
757 ** ...a bit tricky, but you have been warned, besides
758 ** code is more neat this way... --msa
759 */
760 client_p->servptr = &me;
761
762 if (IsClosing(client_p))
763 return;
764
765 SetServer(client_p);
766
767 /* Update the capability combination usage counts. -A1kmm */
768 set_chcap_usage_counts(client_p);
769
770 /* Some day, all these lists will be consolidated *sigh* */
771 dlinkAdd(client_p, &client_p->lnode, &me.serv->server_list);
772
773 assert(dlinkFind(&unknown_list, client_p));
774
775 dlink_move_node(&client_p->localClient->lclient_node,
776 &unknown_list, &serv_list);
777
778 Count.myserver++;
779
780 dlinkAdd(client_p, make_dlink_node(), &global_serv_list);
781 hash_add_client(client_p);
782
783 /* doesnt duplicate client_p->serv if allocated this struct already */
784 make_server(client_p);
785
786 /* fixing eob timings.. -gnp */
787 client_p->localClient->firsttime = CurrentTime;
788
789 if (find_matching_name_conf(CONF_SERVICE, client_p->name, NULL, NULL, 0))
790 AddFlag(client_p, FLAGS_SERVICE);
791
792 /* Show the real host/IP to admins */
793 #ifdef HAVE_LIBCRYPTO
794 if (client_p->localClient->fd.ssl)
795 {
796 compression = SSL_get_current_compression(client_p->localClient->fd.ssl);
797 expansion = SSL_get_current_expansion(client_p->localClient->fd.ssl);
798
799 sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
800 "Link with %s established: [SSL: %s, Compression/Expansion method: %s/%s] (Capabilities: %s)",
801 inpath_ip, ssl_get_cipher(client_p->localClient->fd.ssl),
802 compression ? SSL_COMP_get_name(compression) : "NONE",
803 expansion ? SSL_COMP_get_name(expansion) : "NONE",
804 show_capabilities(client_p));
805 /* Now show the masked hostname/IP to opers */
806 sendto_realops_flags(UMODE_ALL, L_OPER, SEND_NOTICE,
807 "Link with %s established: [SSL: %s, Compression/Expansion method: %s/%s] (Capabilities: %s)",
808 inpath, ssl_get_cipher(client_p->localClient->fd.ssl),
809 compression ? SSL_COMP_get_name(compression) : "NONE",
810 expansion ? SSL_COMP_get_name(expansion) : "NONE",
811 show_capabilities(client_p));
812 ilog(LOG_TYPE_IRCD, "Link with %s established: [SSL: %s, Compression/Expansion method: %s/%s] (Capabilities: %s)",
813 inpath_ip, ssl_get_cipher(client_p->localClient->fd.ssl),
814 compression ? SSL_COMP_get_name(compression) : "NONE",
815 expansion ? SSL_COMP_get_name(expansion) : "NONE",
816 show_capabilities(client_p));
817 }
818 else
819 #endif
820 {
821 sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
822 "Link with %s established: (Capabilities: %s)",
823 inpath_ip, show_capabilities(client_p));
824 /* Now show the masked hostname/IP to opers */
825 sendto_realops_flags(UMODE_ALL, L_OPER, SEND_NOTICE,
826 "Link with %s established: (Capabilities: %s)",
827 inpath, show_capabilities(client_p));
828 ilog(LOG_TYPE_IRCD, "Link with %s established: (Capabilities: %s)",
829 inpath_ip, show_capabilities(client_p));
830 }
831
832 fd_note(&client_p->localClient->fd, "Server: %s", client_p->name);
833
834 /* Old sendto_serv_but_one() call removed because we now
835 ** need to send different names to different servers
836 ** (domain name matching) Send new server to other servers.
837 */
838 DLINK_FOREACH(ptr, serv_list.head)
839 {
840 target_p = ptr->data;
841
842 if (target_p == client_p)
843 continue;
844
845 if (IsCapable(target_p, CAP_TS6) && HasID(client_p))
846 sendto_one(target_p, ":%s SID %s 2 %s :%s%s",
847 me.id, client_p->name, client_p->id,
848 IsHidden(client_p) ? "(H) " : "",
849 client_p->info);
850 else
851 sendto_one(target_p,":%s SERVER %s 2 :%s%s",
852 me.name, client_p->name,
853 IsHidden(client_p) ? "(H) " : "",
854 client_p->info);
855 }
856
857 /* Pass on my client information to the new server
858 **
859 ** First, pass only servers (idea is that if the link gets
860 ** cancelled beacause the server was already there,
861 ** there are no NICK's to be cancelled...). Of course,
862 ** if cancellation occurs, all this info is sent anyway,
863 ** and I guess the link dies when a read is attempted...? --msa
864 **
865 ** Note: Link cancellation to occur at this point means
866 ** that at least two servers from my fragment are building
867 ** up connection this other fragment at the same time, it's
868 ** a race condition, not the normal way of operation...
869 **
870 ** ALSO NOTE: using the get_client_name for server names--
871 ** see previous *WARNING*!!! (Also, original inpath
872 ** is destroyed...)
873 */
874
875 DLINK_FOREACH_PREV(ptr, global_serv_list.tail)
876 {
877 target_p = ptr->data;
878
879 /* target_p->from == target_p for target_p == client_p */
880 if (IsMe(target_p) || target_p->from == client_p)
881 continue;
882
883 if (IsCapable(client_p, CAP_TS6))
884 {
885 if (HasID(target_p))
886 sendto_one(client_p, ":%s SID %s %d %s :%s%s",
887 ID(target_p->servptr), target_p->name, target_p->hopcount+1,
888 target_p->id, IsHidden(target_p) ? "(H) " : "",
889 target_p->info);
890 else /* introducing non-ts6 server */
891 sendto_one(client_p, ":%s SERVER %s %d :%s%s",
892 ID(target_p->servptr), target_p->name, target_p->hopcount+1,
893 IsHidden(target_p) ? "(H) " : "", target_p->info);
894 }
895 else
896 sendto_one(client_p, ":%s SERVER %s %d :%s%s",
897 target_p->servptr->name, target_p->name, target_p->hopcount+1,
898 IsHidden(target_p) ? "(H) " : "", target_p->info);
899 }
900
901 server_burst(client_p);
902 }
903
904 /* server_burst()
905 *
906 * inputs - struct Client pointer server
907 * -
908 * output - none
909 * side effects - send a server burst
910 * bugs - still too long
911 */
912 static void
913 server_burst(struct Client *client_p)
914 {
915 /* Send it in the shortened format with the TS, if
916 ** it's a TS server; walk the list of channels, sending
917 ** all the nicks that haven't been sent yet for each
918 ** channel, then send the channel itself -- it's less
919 ** obvious than sending all nicks first, but on the
920 ** receiving side memory will be allocated more nicely
921 ** saving a few seconds in the handling of a split
922 ** -orabidoo
923 */
924
925 burst_all(client_p);
926
927 /* EOB stuff is now in burst_all */
928 /* Always send a PING after connect burst is done */
929 sendto_one(client_p, "PING :%s", ID_or_name(&me, client_p));
930 }
931
932 /* burst_all()
933 *
934 * inputs - pointer to server to send burst to
935 * output - NONE
936 * side effects - complete burst of channels/nicks is sent to client_p
937 */
938 static void
939 burst_all(struct Client *client_p)
940 {
941 dlink_node *ptr = NULL;
942
943 DLINK_FOREACH(ptr, global_channel_list.head)
944 {
945 struct Channel *chptr = ptr->data;
946
947 if (dlink_list_length(&chptr->members) != 0)
948 {
949 burst_members(client_p, chptr);
950 send_channel_modes(client_p, chptr);
951
952 if (IsCapable(client_p, CAP_TBURST))
953 send_tb(client_p, chptr);
954 }
955 }
956
957 /* also send out those that are not on any channel
958 */
959 DLINK_FOREACH(ptr, global_client_list.head)
960 {
961 struct Client *target_p = ptr->data;
962
963 if (!HasFlag(target_p, FLAGS_BURSTED) && target_p->from != client_p)
964 sendnick_TS(client_p, target_p);
965
966 DelFlag(target_p, FLAGS_BURSTED);
967 }
968
969 /* We send the time we started the burst, and let the remote host determine an EOB time,
970 ** as otherwise we end up sending a EOB of 0 Sending here means it gets sent last -- fl
971 */
972 /* Its simpler to just send EOB and use the time its been connected.. --fl_ */
973 if (IsCapable(client_p, CAP_EOB))
974 sendto_one(client_p, ":%s EOB", ID_or_name(&me, client_p));
975 }
976
977 /*
978 * send_tb
979 *
980 * inputs - pointer to Client
981 * - pointer to channel
982 * output - NONE
983 * side effects - Called on a server burst when
984 * server is CAP_TBURST capable
985 */
986 static void
987 send_tb(struct Client *client_p, struct Channel *chptr)
988 {
989 /*
990 * We may also send an empty topic here, but only if topic_time isn't 0,
991 * i.e. if we had a topic that got unset. This is required for syncing
992 * topics properly.
993 *
994 * Imagine the following scenario: Our downlink introduces a channel
995 * to us with a TS that is equal to ours, but the channel topic on
996 * their side got unset while the servers were in splitmode, which means
997 * their 'topic' is newer. They simply wanted to unset it, so we have to
998 * deal with it in a more sophisticated fashion instead of just resetting
999 * it to their old topic they had before. Read m_tburst.c:ms_tburst
1000 * for further information -Michael
1001 */
1002 if (chptr->topic_time != 0)
1003 sendto_one(client_p, ":%s TBURST %lu %s %lu %s :%s",
1004 ID_or_name(&me, client_p),
1005 (unsigned long)chptr->channelts, chptr->chname,
1006 (unsigned long)chptr->topic_time,
1007 chptr->topic_info,
1008 chptr->topic);
1009 }
1010
1011 /* burst_members()
1012 *
1013 * inputs - pointer to server to send members to
1014 * - dlink_list pointer to membership list to send
1015 * output - NONE
1016 * side effects -
1017 */
1018 static void
1019 burst_members(struct Client *client_p, struct Channel *chptr)
1020 {
1021 struct Client *target_p;
1022 struct Membership *ms;
1023 dlink_node *ptr;
1024
1025 DLINK_FOREACH(ptr, chptr->members.head)
1026 {
1027 ms = ptr->data;
1028 target_p = ms->client_p;
1029
1030 if (!HasFlag(target_p, FLAGS_BURSTED))
1031 {
1032 AddFlag(target_p, FLAGS_BURSTED);
1033
1034 if (target_p->from != client_p)
1035 sendnick_TS(client_p, target_p);
1036 }
1037 }
1038 }
1039
1040 /* New server connection code
1041 * Based upon the stuff floating about in s_bsd.c
1042 * -- adrian
1043 */
1044
1045 /* serv_connect() - initiate a server connection
1046 *
1047 * inputs - pointer to conf
1048 * - pointer to client doing the connect
1049 * output -
1050 * side effects -
1051 *
1052 * This code initiates a connection to a server. It first checks to make
1053 * sure the given server exists. If this is the case, it creates a socket,
1054 * creates a client, saves the socket information in the client, and
1055 * initiates a connection to the server through comm_connect_tcp(). The
1056 * completion of this goes through serv_completed_connection().
1057 *
1058 * We return 1 if the connection is attempted, since we don't know whether
1059 * it suceeded or not, and 0 if it fails in here somewhere.
1060 */
1061 int
1062 serv_connect(struct MaskItem *conf, struct Client *by)
1063 {
1064 struct Client *client_p;
1065 char buf[HOSTIPLEN + 1];
1066
1067 /* conversion structs */
1068 struct sockaddr_in *v4;
1069 /* Make sure conf is useful */
1070 assert(conf != NULL);
1071
1072
1073 getnameinfo((struct sockaddr *)&conf->addr, conf->addr.ss_len,
1074 buf, sizeof(buf), NULL, 0, NI_NUMERICHOST);
1075 ilog(LOG_TYPE_IRCD, "Connect to %s[%s] @%s", conf->name, conf->host,
1076 buf);
1077
1078 /* Still processing a DNS lookup? -> exit */
1079 if (conf->dns_pending)
1080 {
1081 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1082 "Error connecting to %s: DNS lookup for connect{} in progress.",
1083 conf->name);
1084 return (0);
1085 }
1086
1087 if (conf->dns_failed)
1088 {
1089 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1090 "Error connecting to %s: DNS lookup for connect{} failed.",
1091 conf->name);
1092 return (0);
1093 }
1094
1095 /* Make sure this server isn't already connected
1096 * Note: conf should ALWAYS be a valid C: line
1097 */
1098 if ((client_p = hash_find_server(conf->name)) != NULL)
1099 {
1100 sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
1101 "Server %s already present from %s",
1102 conf->name, get_client_name(client_p, SHOW_IP));
1103 sendto_realops_flags(UMODE_ALL, L_OPER, SEND_NOTICE,
1104 "Server %s already present from %s",
1105 conf->name, get_client_name(client_p, MASK_IP));
1106 if (by && IsClient(by) && !MyClient(by))
1107 sendto_one(by, ":%s NOTICE %s :Server %s already present from %s",
1108 me.name, by->name, conf->name,
1109 get_client_name(client_p, MASK_IP));
1110 return (0);
1111 }
1112
1113 /* Create a local client */
1114 client_p = make_client(NULL);
1115
1116 /* Copy in the server, hostname, fd */
1117 strlcpy(client_p->name, conf->name, sizeof(client_p->name));
1118 strlcpy(client_p->host, conf->host, sizeof(client_p->host));
1119
1120 /* We already converted the ip once, so lets use it - stu */
1121 strlcpy(client_p->sockhost, buf, sizeof(client_p->sockhost));
1122
1123 /* create a socket for the server connection */
1124 if (comm_open(&client_p->localClient->fd, conf->addr.ss.ss_family,
1125 SOCK_STREAM, 0, NULL) < 0)
1126 {
1127 /* Eek, failure to create the socket */
1128 report_error(L_ALL,
1129 "opening stream socket to %s: %s", conf->name, errno);
1130 SetDead(client_p);
1131 exit_client(client_p, &me, "Connection failed");
1132 return (0);
1133 }
1134
1135 /* servernames are always guaranteed under HOSTLEN chars */
1136 fd_note(&client_p->localClient->fd, "Server: %s", conf->name);
1137
1138 /* Attach config entries to client here rather than in
1139 * serv_connect_callback(). This to avoid null pointer references.
1140 */
1141 if (!attach_connect_block(client_p, conf->name, conf->host))
1142 {
1143 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1144 "Host %s is not enabled for connecting: no connect{} block",
1145 conf->name);
1146 if (by && IsClient(by) && !MyClient(by))
1147 sendto_one(by, ":%s NOTICE %s :Connect to host %s failed.",
1148 me.name, by->name, client_p->name);
1149 SetDead(client_p);
1150 exit_client(client_p, client_p, "Connection failed");
1151 return (0);
1152 }
1153
1154 /* at this point we have a connection in progress and C/N lines
1155 * attached to the client, the socket info should be saved in the
1156 * client and it should either be resolved or have a valid address.
1157 *
1158 * The socket has been connected or connect is in progress.
1159 */
1160 make_server(client_p);
1161
1162 if (by && IsClient(by))
1163 strlcpy(client_p->serv->by, by->name, sizeof(client_p->serv->by));
1164 else
1165 strlcpy(client_p->serv->by, "AutoConn.", sizeof(client_p->serv->by));
1166
1167 SetConnecting(client_p);
1168 dlinkAdd(client_p, &client_p->node, &global_client_list);
1169 /* from def_fam */
1170 client_p->localClient->aftype = conf->aftype;
1171
1172 /* Now, initiate the connection */
1173 /* XXX assume that a non 0 type means a specific bind address
1174 * for this connect.
1175 */
1176 switch (conf->aftype)
1177 {
1178 case AF_INET:
1179 v4 = (struct sockaddr_in*)&conf->bind;
1180 if (v4->sin_addr.s_addr != 0)
1181 {
1182 struct irc_ssaddr ipn;
1183 memset(&ipn, 0, sizeof(struct irc_ssaddr));
1184 ipn.ss.ss_family = AF_INET;
1185 ipn.ss_port = 0;
1186 memcpy(&ipn, &conf->bind, sizeof(struct irc_ssaddr));
1187 comm_connect_tcp(&client_p->localClient->fd, conf->host, conf->port,
1188 (struct sockaddr *)&ipn, ipn.ss_len,
1189 serv_connect_callback, client_p, conf->aftype,
1190 CONNECTTIMEOUT);
1191 }
1192 else if (ServerInfo.specific_ipv4_vhost)
1193 {
1194 struct irc_ssaddr ipn;
1195 memset(&ipn, 0, sizeof(struct irc_ssaddr));
1196 ipn.ss.ss_family = AF_INET;
1197 ipn.ss_port = 0;
1198 memcpy(&ipn, &ServerInfo.ip, sizeof(struct irc_ssaddr));
1199 comm_connect_tcp(&client_p->localClient->fd, conf->host, conf->port,
1200 (struct sockaddr *)&ipn, ipn.ss_len,
1201 serv_connect_callback, client_p, conf->aftype,
1202 CONNECTTIMEOUT);
1203 }
1204 else
1205 comm_connect_tcp(&client_p->localClient->fd, conf->host, conf->port,
1206 NULL, 0, serv_connect_callback, client_p, conf->aftype,
1207 CONNECTTIMEOUT);
1208 break;
1209 #ifdef IPV6
1210 case AF_INET6:
1211 {
1212 struct irc_ssaddr ipn;
1213 struct sockaddr_in6 *v6;
1214 struct sockaddr_in6 *v6conf;
1215
1216 memset(&ipn, 0, sizeof(struct irc_ssaddr));
1217 v6conf = (struct sockaddr_in6 *)&conf->bind;
1218 v6 = (struct sockaddr_in6 *)&ipn;
1219
1220 if (memcmp(&v6conf->sin6_addr, &v6->sin6_addr,
1221 sizeof(struct in6_addr)) != 0)
1222 {
1223 memcpy(&ipn, &conf->bind, sizeof(struct irc_ssaddr));
1224 ipn.ss.ss_family = AF_INET6;
1225 ipn.ss_port = 0;
1226 comm_connect_tcp(&client_p->localClient->fd,
1227 conf->host, conf->port,
1228 (struct sockaddr *)&ipn, ipn.ss_len,
1229 serv_connect_callback, client_p,
1230 conf->aftype, CONNECTTIMEOUT);
1231 }
1232 else if (ServerInfo.specific_ipv6_vhost)
1233 {
1234 memcpy(&ipn, &ServerInfo.ip6, sizeof(struct irc_ssaddr));
1235 ipn.ss.ss_family = AF_INET6;
1236 ipn.ss_port = 0;
1237 comm_connect_tcp(&client_p->localClient->fd,
1238 conf->host, conf->port,
1239 (struct sockaddr *)&ipn, ipn.ss_len,
1240 serv_connect_callback, client_p,
1241 conf->aftype, CONNECTTIMEOUT);
1242 }
1243 else
1244 comm_connect_tcp(&client_p->localClient->fd,
1245 conf->host, conf->port,
1246 NULL, 0, serv_connect_callback, client_p,
1247 conf->aftype, CONNECTTIMEOUT);
1248 }
1249 #endif
1250 }
1251 return (1);
1252 }
1253
1254 #ifdef HAVE_LIBCRYPTO
1255 static void
1256 finish_ssl_server_handshake(struct Client *client_p)
1257 {
1258 struct MaskItem *conf = NULL;
1259
1260 conf = find_conf_name(&client_p->localClient->confs,
1261 client_p->name, CONF_SERVER);
1262 if (conf == NULL)
1263 {
1264 sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
1265 "Lost connect{} block for %s", get_client_name(client_p, HIDE_IP));
1266 sendto_realops_flags(UMODE_ALL, L_OPER, SEND_NOTICE,
1267 "Lost connect{} block for %s", get_client_name(client_p, MASK_IP));
1268
1269 exit_client(client_p, &me, "Lost connect{} block");
1270 return;
1271 }
1272
1273 /* jdc -- Check and send spasswd, not passwd. */
1274 if (!EmptyString(conf->spasswd))
1275 sendto_one(client_p, "PASS %s TS %d %s",
1276 conf->spasswd, TS_CURRENT, me.id);
1277
1278 send_capabilities(client_p, 0);
1279
1280 sendto_one(client_p, "SERVER %s 1 :%s%s",
1281 me.name, ConfigServerHide.hidden ? "(H) " : "",
1282 me.info);
1283
1284 /* If we've been marked dead because a send failed, just exit
1285 * here now and save everyone the trouble of us ever existing.
1286 */
1287 if (IsDead(client_p))
1288 {
1289 sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
1290 "%s[%s] went dead during handshake",
1291 client_p->name,
1292 client_p->host);
1293 sendto_realops_flags(UMODE_ALL, L_OPER, SEND_NOTICE,
1294 "%s went dead during handshake", client_p->name);
1295 return;
1296 }
1297
1298 /* don't move to serv_list yet -- we haven't sent a burst! */
1299 /* If we get here, we're ok, so lets start reading some data */
1300 comm_setselect(&client_p->localClient->fd, COMM_SELECT_READ, read_packet, client_p, 0);
1301 }
1302
1303 static void
1304 ssl_server_handshake(fde_t *fd, struct Client *client_p)
1305 {
1306 int ret;
1307 int err;
1308
1309 ret = SSL_connect(client_p->localClient->fd.ssl);
1310
1311 if (ret <= 0)
1312 {
1313 switch ((err = SSL_get_error(client_p->localClient->fd.ssl, ret)))
1314 {
1315 case SSL_ERROR_WANT_WRITE:
1316 comm_setselect(&client_p->localClient->fd, COMM_SELECT_WRITE,
1317 (PF *)ssl_server_handshake, client_p, 0);
1318 return;
1319 case SSL_ERROR_WANT_READ:
1320 comm_setselect(&client_p->localClient->fd, COMM_SELECT_READ,
1321 (PF *)ssl_server_handshake, client_p, 0);
1322 return;
1323 default:
1324 {
1325 const char *sslerr = ERR_error_string(ERR_get_error(), NULL);
1326 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1327 "Error connecting to %s: %s", client_p->name,
1328 sslerr ? sslerr : "unknown SSL error");
1329 exit_client(client_p, client_p, "Error during SSL handshake");
1330 return;
1331 }
1332 }
1333 }
1334
1335 finish_ssl_server_handshake(client_p);
1336 }
1337
1338 static void
1339 ssl_connect_init(struct Client *client_p, struct MaskItem *conf, fde_t *fd)
1340 {
1341 if ((client_p->localClient->fd.ssl = SSL_new(ServerInfo.client_ctx)) == NULL)
1342 {
1343 ilog(LOG_TYPE_IRCD, "SSL_new() ERROR! -- %s",
1344 ERR_error_string(ERR_get_error(), NULL));
1345 SetDead(client_p);
1346 exit_client(client_p, client_p, "SSL_new failed");
1347 return;
1348 }
1349
1350 SSL_set_fd(fd->ssl, fd->fd);
1351
1352 if (!EmptyString(conf->cipher_list))
1353 SSL_set_cipher_list(client_p->localClient->fd.ssl, conf->cipher_list);
1354
1355 ssl_server_handshake(NULL, client_p);
1356 }
1357 #endif
1358
1359 /* serv_connect_callback() - complete a server connection.
1360 *
1361 * This routine is called after the server connection attempt has
1362 * completed. If unsucessful, an error is sent to ops and the client
1363 * is closed. If sucessful, it goes through the initialisation/check
1364 * procedures, the capabilities are sent, and the socket is then
1365 * marked for reading.
1366 */
1367 static void
1368 serv_connect_callback(fde_t *fd, int status, void *data)
1369 {
1370 struct Client *client_p = data;
1371 struct MaskItem *conf = NULL;
1372
1373 /* First, make sure its a real client! */
1374 assert(client_p != NULL);
1375 assert(&client_p->localClient->fd == fd);
1376
1377 /* Next, for backward purposes, record the ip of the server */
1378 memcpy(&client_p->localClient->ip, &fd->connect.hostaddr,
1379 sizeof(struct irc_ssaddr));
1380 /* Check the status */
1381 if (status != COMM_OK)
1382 {
1383 /* We have an error, so report it and quit
1384 * Admins get to see any IP, mere opers don't *sigh*
1385 */
1386 if (ConfigServerHide.hide_server_ips)
1387 sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
1388 "Error connecting to %s: %s",
1389 client_p->name, comm_errstr(status));
1390 else
1391 sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
1392 "Error connecting to %s[%s]: %s", client_p->name,
1393 client_p->host, comm_errstr(status));
1394
1395 sendto_realops_flags(UMODE_ALL, L_OPER, SEND_NOTICE,
1396 "Error connecting to %s: %s",
1397 client_p->name, comm_errstr(status));
1398
1399 /* If a fd goes bad, call dead_link() the socket is no
1400 * longer valid for reading or writing.
1401 */
1402 dead_link_on_write(client_p, 0);
1403 return;
1404 }
1405
1406 /* COMM_OK, so continue the connection procedure */
1407 /* Get the C/N lines */
1408 conf = find_conf_name(&client_p->localClient->confs,
1409 client_p->name, CONF_SERVER);
1410 if (conf == NULL)
1411 {
1412 sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
1413 "Lost connect{} block for %s", get_client_name(client_p, HIDE_IP));
1414 sendto_realops_flags(UMODE_ALL, L_OPER, SEND_NOTICE,
1415 "Lost connect{} block for %s", get_client_name(client_p, MASK_IP));
1416
1417 exit_client(client_p, &me, "Lost connect{} block");
1418 return;
1419 }
1420
1421 /* Next, send the initial handshake */
1422 SetHandshake(client_p);
1423
1424 #ifdef HAVE_LIBCRYPTO
1425 if (IsConfSSL(conf))
1426 {
1427 ssl_connect_init(client_p, conf, fd);
1428 return;
1429 }
1430 #endif
1431
1432 /* jdc -- Check and send spasswd, not passwd. */
1433 if (!EmptyString(conf->spasswd))
1434 sendto_one(client_p, "PASS %s TS %d %s",
1435 conf->spasswd, TS_CURRENT, me.id);
1436
1437 send_capabilities(client_p, 0);
1438
1439 sendto_one(client_p, "SERVER %s 1 :%s%s",
1440 me.name, ConfigServerHide.hidden ? "(H) " : "",
1441 me.info);
1442
1443 /* If we've been marked dead because a send failed, just exit
1444 * here now and save everyone the trouble of us ever existing.
1445 */
1446 if (IsDead(client_p))
1447 {
1448 sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
1449 "%s[%s] went dead during handshake",
1450 client_p->name,
1451 client_p->host);
1452 sendto_realops_flags(UMODE_ALL, L_OPER, SEND_NOTICE,
1453 "%s went dead during handshake", client_p->name);
1454 return;
1455 }
1456
1457 /* don't move to serv_list yet -- we haven't sent a burst! */
1458 /* If we get here, we're ok, so lets start reading some data */
1459 comm_setselect(fd, COMM_SELECT_READ, read_packet, client_p, 0);
1460 }
1461
1462 struct Client *
1463 find_servconn_in_progress(const char *name)
1464 {
1465 dlink_node *ptr;
1466 struct Client *cptr;
1467
1468 DLINK_FOREACH(ptr, unknown_list.head)
1469 {
1470 cptr = ptr->data;
1471
1472 if (cptr && cptr->name[0])
1473 if (!match(name, cptr->name))
1474 return cptr;
1475 }
1476
1477 return NULL;
1478 }

Properties

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

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