ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/server.c
Revision: 885
Committed: Wed Oct 31 18:09:24 2007 UTC (16 years, 5 months ago) by michael
Content type: text/x-csrc
Original Path: ircd-hybrid-7.2/src/s_serv.c
File size: 63720 byte(s)
Log Message:
- Removed LazyLinks in 7.2 to stop people from asking why we keep
  broken code for half a decade. LL will be implemented in a smarter
  fashion in due time

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

Properties

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