ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/server.c
Revision: 1483
Committed: Wed Jul 25 19:15:48 2012 UTC (11 years, 8 months ago) by michael
Content type: text/x-csrc
Original Path: ircd-hybrid-8/src/s_serv.c
File size: 45326 byte(s)
Log Message:
- Made Client::away a fixed-size array at the expense of a somewhat higher
  memory consumption

File Contents

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

Properties

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