ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf.c
Revision: 3171
Committed: Sun Mar 16 11:51:48 2014 UTC (10 years ago) by michael
Content type: text/x-csrc
File size: 58459 byte(s)
Log Message:
- Incorporate Adam's exit_client/quit storm cleanups
  Note: QS is mandatory now

File Contents

# User Rev Content
1 adx 30 /*
2 michael 2916 * ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3 adx 30 *
4 michael 2916 * Copyright (c) 1997-2014 ircd-hybrid development team
5 adx 30 *
6     * This program is free software; you can redistribute it and/or modify
7     * it under the terms of the GNU General Public License as published by
8     * the Free Software Foundation; either version 2 of the License, or
9     * (at your option) any later version.
10     *
11     * This program is distributed in the hope that it will be useful,
12     * but WITHOUT ANY WARRANTY; without even the implied warranty of
13     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14     * GNU General Public License for more details.
15     *
16     * You should have received a copy of the GNU General Public License
17     * along with this program; if not, write to the Free Software
18     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19     * USA
20     */
21    
22 michael 2916 /*! \file conf.c
23     * \brief Configuration file functions.
24     * \version $Id$
25     */
26    
27 adx 30 #include "stdinc.h"
28 michael 1011 #include "list.h"
29 adx 30 #include "ircd_defs.h"
30 michael 1309 #include "conf.h"
31 adx 30 #include "s_serv.h"
32     #include "resv.h"
33     #include "channel.h"
34     #include "client.h"
35     #include "event.h"
36     #include "hook.h"
37     #include "irc_string.h"
38     #include "s_bsd.h"
39     #include "ircd.h"
40     #include "listener.h"
41     #include "hostmask.h"
42     #include "modules.h"
43     #include "numeric.h"
44     #include "fdlist.h"
45 michael 1309 #include "log.h"
46 adx 30 #include "send.h"
47     #include "s_gline.h"
48     #include "memory.h"
49 michael 1654 #include "mempool.h"
50 adx 30 #include "irc_res.h"
51     #include "userhost.h"
52     #include "s_user.h"
53     #include "channel_mode.h"
54 michael 1243 #include "parse.h"
55     #include "s_misc.h"
56 michael 1622 #include "conf_db.h"
57 michael 1632 #include "conf_class.h"
58 michael 2150 #include "motd.h"
59 adx 30
60 michael 2872
61 michael 3022 struct config_channel_entry ConfigChannel;
62 adx 30 struct config_server_hide ConfigServerHide;
63 michael 2872 struct config_file_entry ConfigFileEntry;
64     struct logging_entry ConfigLoggingEntry = { .use_logging = 1 };
65     struct server_info ServerInfo;
66     struct admin_info AdminInfo;
67 adx 30
68     /* general conf items link list root, other than k lines etc. */
69 michael 1157 dlink_list service_items = { NULL, NULL, 0 };
70 adx 30 dlink_list server_items = { NULL, NULL, 0 };
71     dlink_list cluster_items = { NULL, NULL, 0 };
72     dlink_list oconf_items = { NULL, NULL, 0 };
73     dlink_list uconf_items = { NULL, NULL, 0 };
74     dlink_list xconf_items = { NULL, NULL, 0 };
75     dlink_list nresv_items = { NULL, NULL, 0 };
76 michael 2174 dlink_list cresv_items = { NULL, NULL, 0 };
77 adx 30
78     extern unsigned int lineno;
79     extern char linebuf[];
80     extern char conffilebuf[IRCD_BUFSIZE];
81     extern int yyparse(); /* defined in y.tab.c */
82    
83 michael 967 struct conf_parser_context conf_parser_ctx = { 0, 0, NULL };
84    
85 adx 30 /* internally defined functions */
86 michael 1325 static void read_conf(FILE *);
87 adx 30 static void clear_out_old_conf(void);
88     static void expire_tklines(dlink_list *);
89     static void garbage_collect_ip_entries(void);
90     static int hash_ip(struct irc_ssaddr *);
91 michael 1644 static int verify_access(struct Client *);
92 michael 1632 static int attach_iline(struct Client *, struct MaskItem *);
93 adx 30 static struct ip_entry *find_or_add_ip(struct irc_ssaddr *);
94 michael 1632 static dlink_list *map_to_list(enum maskitem_type);
95 adx 30 static int find_user_host(struct Client *, char *, char *, char *, unsigned int);
96    
97    
98     /* usually, with hash tables, you use a prime number...
99     * but in this case I am dealing with ip addresses,
100     * not ascii strings.
101     */
102     #define IP_HASH_SIZE 0x1000
103    
104     struct ip_entry
105     {
106     struct irc_ssaddr ip;
107 michael 1644 unsigned int count;
108 adx 30 time_t last_attempt;
109     struct ip_entry *next;
110     };
111    
112     static struct ip_entry *ip_hash_table[IP_HASH_SIZE];
113 michael 1654 static mp_pool_t *ip_entry_pool = NULL;
114 adx 30 static int ip_entries_count = 0;
115    
116    
117     /* conf_dns_callback()
118     *
119 michael 1632 * inputs - pointer to struct MaskItem
120 adx 30 * - pointer to DNSReply reply
121     * output - none
122     * side effects - called when resolver query finishes
123     * if the query resulted in a successful search, hp will contain
124     * a non-null pointer, otherwise hp will be null.
125     * if successful save hp in the conf item it was called with
126     */
127     static void
128 michael 992 conf_dns_callback(void *vptr, const struct irc_ssaddr *addr, const char *name)
129 adx 30 {
130 michael 1632 struct MaskItem *conf = vptr;
131 adx 30
132 michael 1632 conf->dns_pending = 0;
133 adx 30
134 michael 992 if (addr != NULL)
135 michael 1632 memcpy(&conf->addr, addr, sizeof(conf->addr));
136 michael 992 else
137 michael 1632 conf->dns_failed = 1;
138 adx 30 }
139    
140     /* conf_dns_lookup()
141     *
142     * do a nameserver lookup of the conf host
143     * if the conf entry is currently doing a ns lookup do nothing, otherwise
144     * allocate a dns_query and start ns lookup.
145     */
146     static void
147 michael 1632 conf_dns_lookup(struct MaskItem *conf)
148 adx 30 {
149 michael 1632 if (!conf->dns_pending)
150 adx 30 {
151 michael 1632 conf->dns_pending = 1;
152     gethost_byname(conf_dns_callback, conf, conf->host);
153 adx 30 }
154     }
155    
156 michael 1632 struct MaskItem *
157     conf_make(enum maskitem_type type)
158     {
159     struct MaskItem *conf = MyMalloc(sizeof(*conf));
160     dlink_list *list = NULL;
161    
162     conf->type = type;
163     conf->active = 1;
164     conf->aftype = AF_INET;
165    
166     if ((list = map_to_list(type)))
167     dlinkAdd(conf, &conf->node, list);
168     return conf;
169     }
170    
171     void
172     conf_free(struct MaskItem *conf)
173     {
174     dlink_node *ptr = NULL, *ptr_next = NULL;
175 michael 1636 dlink_list *list = NULL;
176    
177     if (conf->node.next)
178     if ((list = map_to_list(conf->type)))
179     dlinkDelete(&conf->node, list);
180    
181 michael 1632 MyFree(conf->name);
182    
183     if (conf->dns_pending)
184     delete_resolver_queries(conf);
185     if (conf->passwd != NULL)
186     memset(conf->passwd, 0, strlen(conf->passwd));
187     if (conf->spasswd != NULL)
188     memset(conf->spasswd, 0, strlen(conf->spasswd));
189    
190     conf->class = NULL;
191    
192     MyFree(conf->passwd);
193     MyFree(conf->spasswd);
194     MyFree(conf->reason);
195 michael 2228 MyFree(conf->certfp);
196 michael 1632 MyFree(conf->user);
197     MyFree(conf->host);
198     #ifdef HAVE_LIBCRYPTO
199     MyFree(conf->cipher_list);
200    
201     if (conf->rsa_public_key)
202     RSA_free(conf->rsa_public_key);
203     #endif
204     DLINK_FOREACH_SAFE(ptr, ptr_next, conf->hub_list.head)
205     {
206     MyFree(ptr->data);
207 michael 2736 dlinkDelete(ptr, &conf->hub_list);
208 michael 1632 free_dlink_node(ptr);
209     }
210    
211     DLINK_FOREACH_SAFE(ptr, ptr_next, conf->leaf_list.head)
212     {
213     MyFree(ptr->data);
214 michael 2736 dlinkDelete(ptr, &conf->leaf_list);
215 michael 1632 free_dlink_node(ptr);
216     }
217 adx 30
218 michael 1858 DLINK_FOREACH_SAFE(ptr, ptr_next, conf->exempt_list.head)
219     {
220     struct exempt *exptr = ptr->data;
221    
222 michael 2736 dlinkDelete(ptr, &conf->exempt_list);
223 michael 1858 MyFree(exptr->name);
224     MyFree(exptr->user);
225     MyFree(exptr->host);
226     MyFree(exptr);
227     }
228    
229 michael 1636 MyFree(conf);
230 adx 30 }
231    
232     /* check_client()
233     *
234     * inputs - pointer to client
235     * output - 0 = Success
236     * NOT_AUTHORIZED (-1) = Access denied (no I line match)
237     * IRCD_SOCKET_ERROR (-2) = Bad socket.
238     * I_LINE_FULL (-3) = I-line is full
239     * TOO_MANY (-4) = Too many connections from hostname
240     * BANNED_CLIENT (-5) = K-lined
241     * side effects - Ordinary client access check.
242     * Look for conf lines which have the same
243     * status as the flags passed.
244     */
245 michael 1644 int
246     check_client(struct Client *source_p)
247 adx 30 {
248     int i;
249 michael 2916
250 michael 1644 if ((i = verify_access(source_p)))
251 michael 2916 ilog(LOG_TYPE_IRCD, "Access denied: %s[%s]",
252 adx 30 source_p->name, source_p->sockhost);
253    
254     switch (i)
255     {
256     case TOO_MANY:
257 michael 1618 sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
258 adx 30 "Too many on IP for %s (%s).",
259 michael 2182 get_client_name(source_p, SHOW_IP),
260     source_p->sockhost);
261 michael 1247 ilog(LOG_TYPE_IRCD, "Too many connections on IP from %s.",
262 michael 2182 get_client_name(source_p, SHOW_IP));
263 michael 896 ++ServerStats.is_ref;
264 michael 3171 exit_client(source_p, "No more connections allowed on that IP");
265 adx 30 break;
266    
267     case I_LINE_FULL:
268 michael 1618 sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
269     "auth{} block is full for %s (%s).",
270 michael 2182 get_client_name(source_p, SHOW_IP),
271     source_p->sockhost);
272 michael 1247 ilog(LOG_TYPE_IRCD, "Too many connections from %s.",
273 michael 2182 get_client_name(source_p, SHOW_IP));
274 michael 896 ++ServerStats.is_ref;
275 michael 3171 exit_client(source_p, "No more connections allowed in your connection class");
276 adx 30 break;
277    
278     case NOT_AUTHORIZED:
279 michael 896 ++ServerStats.is_ref;
280 adx 30 /* jdc - lists server name & port connections are on */
281     /* a purely cosmetical change */
282 michael 1618 sendto_realops_flags(UMODE_UNAUTH, L_ALL, SEND_NOTICE,
283 michael 2182 "Unauthorized client connection from %s [%s] on [%s/%u].",
284     get_client_name(source_p, SHOW_IP),
285     source_p->sockhost,
286     source_p->localClient->listener->name,
287     source_p->localClient->listener->port);
288 michael 1247 ilog(LOG_TYPE_IRCD,
289 michael 2182 "Unauthorized client connection from %s on [%s/%u].",
290     get_client_name(source_p, SHOW_IP),
291     source_p->localClient->listener->name,
292     source_p->localClient->listener->port);
293 adx 30
294 michael 3171 exit_client(source_p, "You are not authorized to use this server");
295 adx 30 break;
296 michael 891
297 adx 30 case BANNED_CLIENT:
298 michael 3171 exit_client(source_p, "Banned");
299 michael 896 ++ServerStats.is_ref;
300 adx 30 break;
301    
302     case 0:
303     default:
304     break;
305     }
306    
307 michael 1644 return (i < 0 ? 0 : 1);
308 adx 30 }
309    
310     /* verify_access()
311     *
312     * inputs - pointer to client to verify
313     * output - 0 if success -'ve if not
314     * side effect - find the first (best) I line to attach.
315     */
316     static int
317 michael 1644 verify_access(struct Client *client_p)
318 adx 30 {
319 michael 1949 struct MaskItem *conf = NULL;
320 adx 30 char non_ident[USERLEN + 1] = { '~', '\0' };
321    
322     if (IsGotId(client_p))
323     {
324 michael 1632 conf = find_address_conf(client_p->host, client_p->username,
325 michael 2182 &client_p->localClient->ip,
326     client_p->localClient->aftype,
327 adx 30 client_p->localClient->passwd);
328     }
329     else
330     {
331 michael 2182 strlcpy(non_ident + 1, client_p->username, sizeof(non_ident) - 1);
332 michael 1632 conf = find_address_conf(client_p->host,non_ident,
333 michael 2182 &client_p->localClient->ip,
334     client_p->localClient->aftype,
335     client_p->localClient->passwd);
336 adx 30 }
337    
338 michael 1632 if (conf != NULL)
339 adx 30 {
340 michael 1921 if (IsConfClient(conf))
341 adx 30 {
342 michael 1632 if (IsConfRedir(conf))
343 adx 30 {
344 michael 3109 sendto_one_numeric(client_p, &me, RPL_REDIR,
345     conf->name ? conf->name : "",
346     conf->port);
347 michael 2182 return NOT_AUTHORIZED;
348 adx 30 }
349    
350 michael 1632 if (IsConfDoIdentd(conf))
351 michael 2182 SetNeedId(client_p);
352 adx 30
353     /* Thanks for spoof idea amm */
354 michael 1632 if (IsConfDoSpoofIp(conf))
355 adx 30 {
356 michael 1632 if (!ConfigFileEntry.hide_spoof_ips && IsConfSpoofNotice(conf))
357 michael 1618 sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
358     "%s spoofing: %s as %s",
359 adx 30 client_p->name, client_p->host, conf->name);
360     strlcpy(client_p->host, conf->name, sizeof(client_p->host));
361 michael 2138 AddFlag(client_p, FLAGS_IP_SPOOFING | FLAGS_AUTH_SPOOF);
362 adx 30 }
363    
364 michael 2182 return attach_iline(client_p, conf);
365 adx 30 }
366 michael 1921 else if (IsConfKill(conf) || (ConfigFileEntry.glines && IsConfGline(conf)))
367 adx 30 {
368 michael 1632 if (IsConfGline(conf))
369 michael 3110 sendto_one_notice(client_p, &me, ":*** G-lined");
370     sendto_one_notice(client_p, &me, ":*** Banned: %s", conf->reason);
371 michael 2182 return BANNED_CLIENT;
372 adx 30 }
373     }
374    
375 michael 2182 return NOT_AUTHORIZED;
376 adx 30 }
377    
378     /* attach_iline()
379     *
380     * inputs - client pointer
381     * - conf pointer
382     * output -
383     * side effects - do actual attach
384     */
385     static int
386 michael 1632 attach_iline(struct Client *client_p, struct MaskItem *conf)
387 adx 30 {
388 michael 1632 struct ClassItem *class = NULL;
389 adx 30 struct ip_entry *ip_found;
390     int a_limit_reached = 0;
391 michael 1644 unsigned int local = 0, global = 0, ident = 0;
392 adx 30
393 michael 2317 assert(conf->class);
394    
395 adx 30 ip_found = find_or_add_ip(&client_p->localClient->ip);
396     ip_found->count++;
397     SetIpHash(client_p);
398    
399 michael 1632 class = conf->class;
400 adx 30
401     count_user_host(client_p->username, client_p->host,
402     &global, &local, &ident);
403    
404     /* XXX blah. go down checking the various silly limits
405     * setting a_limit_reached if any limit is reached.
406     * - Dianora
407     */
408 michael 1632 if (class->max_total != 0 && class->ref_count >= class->max_total)
409 adx 30 a_limit_reached = 1;
410 michael 1632 else if (class->max_perip != 0 && ip_found->count > class->max_perip)
411 adx 30 a_limit_reached = 1;
412 michael 1632 else if (class->max_local != 0 && local >= class->max_local)
413 adx 30 a_limit_reached = 1;
414 michael 1632 else if (class->max_global != 0 && global >= class->max_global)
415 adx 30 a_limit_reached = 1;
416 michael 1632 else if (class->max_ident != 0 && ident >= class->max_ident &&
417 adx 30 client_p->username[0] != '~')
418     a_limit_reached = 1;
419    
420     if (a_limit_reached)
421     {
422 michael 1632 if (!IsConfExemptLimits(conf))
423 michael 624 return TOO_MANY; /* Already at maximum allowed */
424 adx 30
425 michael 3110 sendto_one_notice(client_p, &me, ":*** Your connection class is full, "
426     "but you have exceed_limit = yes;");
427 adx 30 }
428    
429     return attach_conf(client_p, conf);
430     }
431    
432     /* init_ip_hash_table()
433     *
434     * inputs - NONE
435     * output - NONE
436     * side effects - allocate memory for ip_entry(s)
437     * - clear the ip hash table
438     */
439     void
440     init_ip_hash_table(void)
441     {
442 michael 1964 ip_entry_pool = mp_pool_new(sizeof(struct ip_entry), MP_CHUNK_SIZE_IP_ENTRY);
443 adx 30 memset(ip_hash_table, 0, sizeof(ip_hash_table));
444     }
445    
446     /* find_or_add_ip()
447     *
448     * inputs - pointer to struct irc_ssaddr
449     * output - pointer to a struct ip_entry
450     * side effects -
451     *
452     * If the ip # was not found, a new struct ip_entry is created, and the ip
453     * count set to 0.
454     */
455     static struct ip_entry *
456     find_or_add_ip(struct irc_ssaddr *ip_in)
457     {
458     struct ip_entry *ptr, *newptr;
459     int hash_index = hash_ip(ip_in), res;
460     struct sockaddr_in *v4 = (struct sockaddr_in *)ip_in, *ptr_v4;
461     #ifdef IPV6
462     struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)ip_in, *ptr_v6;
463     #endif
464    
465     for (ptr = ip_hash_table[hash_index]; ptr; ptr = ptr->next)
466     {
467     #ifdef IPV6
468     if (ptr->ip.ss.ss_family != ip_in->ss.ss_family)
469     continue;
470     if (ip_in->ss.ss_family == AF_INET6)
471     {
472     ptr_v6 = (struct sockaddr_in6 *)&ptr->ip;
473     res = memcmp(&v6->sin6_addr, &ptr_v6->sin6_addr, sizeof(struct in6_addr));
474     }
475     else
476     #endif
477     {
478     ptr_v4 = (struct sockaddr_in *)&ptr->ip;
479     res = memcmp(&v4->sin_addr, &ptr_v4->sin_addr, sizeof(struct in_addr));
480     }
481     if (res == 0)
482     {
483     /* Found entry already in hash, return it. */
484     return ptr;
485     }
486     }
487    
488     if (ip_entries_count >= 2 * hard_fdlimit)
489     garbage_collect_ip_entries();
490    
491 michael 1654 newptr = mp_pool_get(ip_entry_pool);
492     memset(newptr, 0, sizeof(*newptr));
493 adx 30 ip_entries_count++;
494     memcpy(&newptr->ip, ip_in, sizeof(struct irc_ssaddr));
495    
496     newptr->next = ip_hash_table[hash_index];
497     ip_hash_table[hash_index] = newptr;
498    
499     return newptr;
500     }
501    
502     /* remove_one_ip()
503     *
504     * inputs - unsigned long IP address value
505     * output - NONE
506     * side effects - The ip address given, is looked up in ip hash table
507     * and number of ip#'s for that ip decremented.
508     * If ip # count reaches 0 and has expired,
509     * the struct ip_entry is returned to the ip_entry_heap
510     */
511     void
512     remove_one_ip(struct irc_ssaddr *ip_in)
513     {
514     struct ip_entry *ptr;
515     struct ip_entry *last_ptr = NULL;
516     int hash_index = hash_ip(ip_in), res;
517     struct sockaddr_in *v4 = (struct sockaddr_in *)ip_in, *ptr_v4;
518     #ifdef IPV6
519     struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)ip_in, *ptr_v6;
520     #endif
521    
522     for (ptr = ip_hash_table[hash_index]; ptr; ptr = ptr->next)
523     {
524     #ifdef IPV6
525     if (ptr->ip.ss.ss_family != ip_in->ss.ss_family)
526     continue;
527     if (ip_in->ss.ss_family == AF_INET6)
528     {
529     ptr_v6 = (struct sockaddr_in6 *)&ptr->ip;
530     res = memcmp(&v6->sin6_addr, &ptr_v6->sin6_addr, sizeof(struct in6_addr));
531     }
532     else
533     #endif
534     {
535     ptr_v4 = (struct sockaddr_in *)&ptr->ip;
536     res = memcmp(&v4->sin_addr, &ptr_v4->sin_addr, sizeof(struct in_addr));
537     }
538     if (res)
539     continue;
540     if (ptr->count > 0)
541     ptr->count--;
542     if (ptr->count == 0 &&
543 michael 2182 (CurrentTime-ptr->last_attempt) >= ConfigFileEntry.throttle_time)
544 adx 30 {
545     if (last_ptr != NULL)
546 michael 2182 last_ptr->next = ptr->next;
547 adx 30 else
548 michael 2182 ip_hash_table[hash_index] = ptr->next;
549 adx 30
550 michael 1654 mp_pool_release(ptr);
551 adx 30 ip_entries_count--;
552     return;
553     }
554     last_ptr = ptr;
555     }
556     }
557    
558     /* hash_ip()
559     *
560     * input - pointer to an irc_inaddr
561     * output - integer value used as index into hash table
562     * side effects - hopefully, none
563     */
564     static int
565     hash_ip(struct irc_ssaddr *addr)
566     {
567     if (addr->ss.ss_family == AF_INET)
568     {
569     struct sockaddr_in *v4 = (struct sockaddr_in *)addr;
570     int hash;
571 michael 1032 uint32_t ip;
572 adx 30
573     ip = ntohl(v4->sin_addr.s_addr);
574     hash = ((ip >> 12) + ip) & (IP_HASH_SIZE-1);
575     return hash;
576     }
577     #ifdef IPV6
578     else
579     {
580     int hash;
581     struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)addr;
582 michael 1032 uint32_t *ip = (uint32_t *)&v6->sin6_addr.s6_addr;
583 adx 30
584     hash = ip[0] ^ ip[3];
585 michael 2916 hash ^= hash >> 16;
586     hash ^= hash >> 8;
587 adx 30 hash = hash & (IP_HASH_SIZE - 1);
588     return hash;
589     }
590     #else
591     return 0;
592     #endif
593     }
594    
595     /* count_ip_hash()
596     *
597 michael 2916 * inputs - pointer to counter of number of ips hashed
598 adx 30 * - pointer to memory used for ip hash
599     * output - returned via pointers input
600     * side effects - NONE
601     *
602     * number of hashed ip #'s is counted up, plus the amount of memory
603     * used in the hash.
604     */
605     void
606 michael 948 count_ip_hash(unsigned int *number_ips_stored, uint64_t *mem_ips_stored)
607 adx 30 {
608     struct ip_entry *ptr;
609     int i;
610    
611     *number_ips_stored = 0;
612     *mem_ips_stored = 0;
613    
614     for (i = 0; i < IP_HASH_SIZE; i++)
615     {
616     for (ptr = ip_hash_table[i]; ptr; ptr = ptr->next)
617     {
618     *number_ips_stored += 1;
619     *mem_ips_stored += sizeof(struct ip_entry);
620     }
621     }
622     }
623    
624     /* garbage_collect_ip_entries()
625     *
626     * input - NONE
627     * output - NONE
628     * side effects - free up all ip entries with no connections
629     */
630     static void
631     garbage_collect_ip_entries(void)
632     {
633     struct ip_entry *ptr;
634     struct ip_entry *last_ptr;
635     struct ip_entry *next_ptr;
636     int i;
637    
638     for (i = 0; i < IP_HASH_SIZE; i++)
639     {
640     last_ptr = NULL;
641    
642     for (ptr = ip_hash_table[i]; ptr; ptr = next_ptr)
643     {
644     next_ptr = ptr->next;
645    
646     if (ptr->count == 0 &&
647     (CurrentTime - ptr->last_attempt) >= ConfigFileEntry.throttle_time)
648     {
649     if (last_ptr != NULL)
650     last_ptr->next = ptr->next;
651     else
652     ip_hash_table[i] = ptr->next;
653 michael 1654 mp_pool_release(ptr);
654 adx 30 ip_entries_count--;
655     }
656     else
657     last_ptr = ptr;
658     }
659     }
660     }
661    
662     /* detach_conf()
663     *
664     * inputs - pointer to client to detach
665     * - type of conf to detach
666     * output - 0 for success, -1 for failure
667     * side effects - Disassociate configuration from the client.
668     * Also removes a class from the list if marked for deleting.
669     */
670 michael 1632 void
671     detach_conf(struct Client *client_p, enum maskitem_type type)
672 adx 30 {
673 michael 1632 dlink_node *ptr = NULL, *next_ptr = NULL;
674 adx 30
675     DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->confs.head)
676     {
677 michael 1645 struct MaskItem *conf = ptr->data;
678 adx 30
679 michael 1645 assert(conf->type & (CONF_CLIENT | CONF_OPER | CONF_SERVER));
680     assert(conf->ref_count > 0);
681     assert(conf->class->ref_count > 0);
682 adx 30
683 michael 1645 if (!(conf->type & type))
684     continue;
685 michael 671
686 michael 1645 dlinkDelete(ptr, &client_p->localClient->confs);
687     free_dlink_node(ptr);
688 michael 1644
689 michael 2278 if (conf->type == CONF_CLIENT)
690 michael 1645 remove_from_cidr_check(&client_p->localClient->ip, conf->class);
691 adx 30
692 michael 1645 if (--conf->class->ref_count == 0 && conf->class->active == 0)
693     {
694     class_free(conf->class);
695     conf->class = NULL;
696 adx 30 }
697 michael 1645
698     if (--conf->ref_count == 0 && conf->active == 0)
699     conf_free(conf);
700 adx 30 }
701     }
702    
703     /* attach_conf()
704     *
705     * inputs - client pointer
706     * - conf pointer
707     * output -
708     * side effects - Associate a specific configuration entry to a *local*
709     * client (this is the one which used in accepting the
710     * connection). Note, that this automatically changes the
711     * attachment if there was an old one...
712     */
713     int
714 michael 1632 attach_conf(struct Client *client_p, struct MaskItem *conf)
715 adx 30 {
716     if (dlinkFind(&client_p->localClient->confs, conf) != NULL)
717     return 1;
718    
719 michael 1632 if (conf->type == CONF_CLIENT)
720     if (cidr_limit_reached(IsConfExemptLimits(conf),
721     &client_p->localClient->ip, conf->class))
722 michael 1394 return TOO_MANY; /* Already at maximum allowed */
723 adx 30
724 michael 1632 conf->class->ref_count++;
725 michael 1644 conf->ref_count++;
726 adx 30
727     dlinkAdd(conf, make_dlink_node(), &client_p->localClient->confs);
728    
729     return 0;
730     }
731    
732     /* attach_connect_block()
733     *
734     * inputs - pointer to server to attach
735     * - name of server
736     * - hostname of server
737     * output - true (1) if both are found, otherwise return false (0)
738     * side effects - find connect block and attach them to connecting client
739     */
740     int
741     attach_connect_block(struct Client *client_p, const char *name,
742     const char *host)
743     {
744     dlink_node *ptr;
745 michael 1632 struct MaskItem *conf = NULL;
746 adx 30
747     assert(client_p != NULL);
748     assert(host != NULL);
749    
750     if (client_p == NULL || host == NULL)
751     return 0;
752    
753     DLINK_FOREACH(ptr, server_items.head)
754     {
755     conf = ptr->data;
756    
757 michael 1652 if (match(conf->name, name) || match(conf->host, host))
758 adx 30 continue;
759    
760     attach_conf(client_p, conf);
761     return -1;
762     }
763    
764     return 0;
765     }
766    
767     /* find_conf_name()
768     *
769     * inputs - pointer to conf link list to search
770     * - pointer to name to find
771     * - int mask of type of conf to find
772     * output - NULL or pointer to conf found
773     * side effects - find a conf entry which matches the name
774     * and has the given mask.
775     */
776 michael 1632 struct MaskItem *
777     find_conf_name(dlink_list *list, const char *name, enum maskitem_type type)
778 adx 30 {
779     dlink_node *ptr;
780 michael 1632 struct MaskItem* conf;
781 adx 30
782     DLINK_FOREACH(ptr, list->head)
783     {
784     conf = ptr->data;
785 michael 2916
786 adx 30 if (conf->type == type)
787     {
788     if (conf->name && (irccmp(conf->name, name) == 0 ||
789 michael 1652 !match(conf->name, name)))
790 adx 30 return conf;
791     }
792     }
793    
794     return NULL;
795     }
796    
797     /* map_to_list()
798     *
799     * inputs - ConfType conf
800     * output - pointer to dlink_list to use
801     * side effects - none
802     */
803     static dlink_list *
804 michael 1632 map_to_list(enum maskitem_type type)
805 adx 30 {
806     switch(type)
807     {
808 michael 1632 case CONF_XLINE:
809 adx 30 return(&xconf_items);
810     break;
811 michael 1632 case CONF_ULINE:
812 adx 30 return(&uconf_items);
813     break;
814 michael 1632 case CONF_NRESV:
815 adx 30 return(&nresv_items);
816     break;
817 michael 1825 case CONF_CRESV:
818 michael 2174 return(&cresv_items);
819 michael 1632 case CONF_OPER:
820 adx 30 return(&oconf_items);
821     break;
822 michael 1632 case CONF_SERVER:
823 adx 30 return(&server_items);
824     break;
825 michael 1632 case CONF_SERVICE:
826 michael 1172 return(&service_items);
827     break;
828 michael 1632 case CONF_CLUSTER:
829 adx 30 return(&cluster_items);
830     break;
831     default:
832     return NULL;
833     }
834     }
835    
836     /* find_matching_name_conf()
837     *
838     * inputs - type of link list to look in
839     * - pointer to name string to find
840     * - pointer to user
841     * - pointer to host
842 michael 1644 * - optional flags to match on as well
843 michael 1632 * output - NULL or pointer to found struct MaskItem
844 adx 30 * side effects - looks for a match on name field
845     */
846 michael 1632 struct MaskItem *
847     find_matching_name_conf(enum maskitem_type type, const char *name, const char *user,
848 michael 1644 const char *host, unsigned int flags)
849 adx 30 {
850     dlink_node *ptr=NULL;
851 michael 1632 struct MaskItem *conf=NULL;
852 adx 30 dlink_list *list_p = map_to_list(type);
853    
854     switch (type)
855     {
856 michael 1632 case CONF_SERVICE:
857 michael 1157 DLINK_FOREACH(ptr, list_p->head)
858     {
859     conf = ptr->data;
860    
861     if (EmptyString(conf->name))
862     continue;
863     if ((name != NULL) && !irccmp(name, conf->name))
864     return conf;
865     }
866     break;
867    
868 michael 1632 case CONF_XLINE:
869     case CONF_ULINE:
870     case CONF_NRESV:
871 michael 1825 case CONF_CRESV:
872 adx 30 DLINK_FOREACH(ptr, list_p->head)
873     {
874     conf = ptr->data;
875    
876     if (EmptyString(conf->name))
877 michael 2182 continue;
878 michael 1653 if ((name != NULL) && !match(conf->name, name))
879 adx 30 {
880 michael 2182 if ((user == NULL && (host == NULL)))
881     return conf;
882     if ((conf->flags & flags) != flags)
883 adx 30 continue;
884 michael 2182 if (EmptyString(conf->user) || EmptyString(conf->host))
885     return conf;
886     if (!match(conf->user, user) && !match(conf->host, host))
887     return conf;
888 adx 30 }
889     }
890     break;
891    
892 michael 1632 case CONF_SERVER:
893 adx 30 DLINK_FOREACH(ptr, list_p->head)
894     {
895     conf = ptr->data;
896    
897 michael 1652 if ((name != NULL) && !match(name, conf->name))
898 adx 30 return conf;
899 michael 1652 else if ((host != NULL) && !match(host, conf->host))
900 adx 30 return conf;
901     }
902     break;
903 michael 2916
904 adx 30 default:
905     break;
906     }
907     return NULL;
908     }
909    
910     /* find_exact_name_conf()
911     *
912     * inputs - type of link list to look in
913     * - pointer to name string to find
914     * - pointer to user
915     * - pointer to host
916 michael 1632 * output - NULL or pointer to found struct MaskItem
917 adx 30 * side effects - looks for an exact match on name field
918     */
919 michael 1632 struct MaskItem *
920     find_exact_name_conf(enum maskitem_type type, const struct Client *who, const char *name,
921 adx 30 const char *user, const char *host)
922     {
923     dlink_node *ptr = NULL;
924 michael 1632 struct MaskItem *conf;
925     dlink_list *list_p = map_to_list(type);
926 adx 30
927     switch(type)
928     {
929 michael 1632 case CONF_XLINE:
930     case CONF_ULINE:
931     case CONF_NRESV:
932 michael 1825 case CONF_CRESV:
933 adx 30
934     DLINK_FOREACH(ptr, list_p->head)
935     {
936     conf = ptr->data;
937 michael 1632
938 adx 30 if (EmptyString(conf->name))
939 michael 2182 continue;
940 michael 2916
941 adx 30 if (irccmp(conf->name, name) == 0)
942     {
943 michael 2182 if ((user == NULL && (host == NULL)))
944     return conf;
945     if (EmptyString(conf->user) || EmptyString(conf->host))
946     return conf;
947     if (!match(conf->user, user) && !match(conf->host, host))
948     return conf;
949 adx 30 }
950     }
951     break;
952    
953 michael 1632 case CONF_OPER:
954 adx 30 DLINK_FOREACH(ptr, list_p->head)
955     {
956     conf = ptr->data;
957 michael 1285
958 adx 30 if (EmptyString(conf->name))
959 michael 1285 continue;
960    
961     if (!irccmp(conf->name, name))
962 adx 30 {
963 michael 1285 if (!who)
964     return conf;
965 michael 1632 if (EmptyString(conf->user) || EmptyString(conf->host))
966 michael 1636 return NULL;
967 michael 1652 if (!match(conf->user, who->username))
968 michael 1285 {
969 michael 1632 switch (conf->htype)
970 michael 1285 {
971     case HM_HOST:
972 michael 1652 if (!match(conf->host, who->host) || !match(conf->host, who->sockhost))
973 michael 1637 if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
974     return conf;
975 michael 1285 break;
976     case HM_IPV4:
977     if (who->localClient->aftype == AF_INET)
978 michael 1632 if (match_ipv4(&who->localClient->ip, &conf->addr, conf->bits))
979 michael 1637 if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
980     return conf;
981 michael 1285 break;
982     #ifdef IPV6
983     case HM_IPV6:
984     if (who->localClient->aftype == AF_INET6)
985 michael 1632 if (match_ipv6(&who->localClient->ip, &conf->addr, conf->bits))
986 michael 1637 if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
987     return conf;
988 michael 1285 break;
989     #endif
990     default:
991     assert(0);
992     }
993     }
994 adx 30 }
995     }
996 michael 1285
997 adx 30 break;
998    
999 michael 1632 case CONF_SERVER:
1000 adx 30 DLINK_FOREACH(ptr, list_p->head)
1001     {
1002     conf = ptr->data;
1003 michael 1632
1004 adx 30 if (EmptyString(conf->name))
1005 michael 2182 continue;
1006 michael 2916
1007 adx 30 if (name == NULL)
1008     {
1009 michael 2182 if (EmptyString(conf->host))
1010     continue;
1011     if (irccmp(conf->host, host) == 0)
1012     return conf;
1013 adx 30 }
1014     else if (irccmp(conf->name, name) == 0)
1015 michael 2182 return conf;
1016 adx 30 }
1017 michael 2182
1018 adx 30 break;
1019    
1020     default:
1021     break;
1022     }
1023 michael 2182
1024     return NULL;
1025 adx 30 }
1026    
1027     /* rehash()
1028     *
1029     * Actual REHASH service routine. Called with sig == 0 if it has been called
1030     * as a result of an operator issuing this command, else assume it has been
1031     * called as a result of the server receiving a HUP signal.
1032     */
1033     int
1034     rehash(int sig)
1035     {
1036     if (sig != 0)
1037 michael 1618 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1038 michael 2830 "Got signal SIGHUP, reloading configuration file(s)");
1039 adx 30
1040     restart_resolver();
1041 michael 1001
1042 adx 30 /* don't close listeners until we know we can go ahead with the rehash */
1043    
1044     /* Check to see if we magically got(or lost) IPv6 support */
1045     check_can_use_v6();
1046    
1047     read_conf_files(0);
1048    
1049     if (ServerInfo.description != NULL)
1050     strlcpy(me.info, ServerInfo.description, sizeof(me.info));
1051    
1052     load_conf_modules();
1053    
1054     rehashed_klines = 1;
1055    
1056 michael 1831 return 0;
1057 adx 30 }
1058    
1059     /* set_default_conf()
1060     *
1061     * inputs - NONE
1062     * output - NONE
1063     * side effects - Set default values here.
1064     * This is called **PRIOR** to parsing the
1065     * configuration file. If you want to do some validation
1066     * of values later, put them in validate_conf().
1067     */
1068     static void
1069     set_default_conf(void)
1070     {
1071     /* verify init_class() ran, this should be an unnecessary check
1072     * but its not much work.
1073     */
1074 michael 1644 assert(class_default == class_get_list()->tail->data);
1075 adx 30
1076     #ifdef HAVE_LIBCRYPTO
1077     ServerInfo.rsa_private_key = NULL;
1078     ServerInfo.rsa_private_key_file = NULL;
1079     #endif
1080    
1081     /* ServerInfo.name is not rehashable */
1082     /* ServerInfo.name = ServerInfo.name; */
1083     ServerInfo.description = NULL;
1084 michael 1646 ServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
1085     ServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
1086 adx 30
1087     memset(&ServerInfo.ip, 0, sizeof(ServerInfo.ip));
1088     ServerInfo.specific_ipv4_vhost = 0;
1089     memset(&ServerInfo.ip6, 0, sizeof(ServerInfo.ip6));
1090     ServerInfo.specific_ipv6_vhost = 0;
1091    
1092     ServerInfo.max_clients = MAXCLIENTS_MAX;
1093 michael 1751 ServerInfo.max_nick_length = 9;
1094     ServerInfo.max_topic_length = 80;
1095 michael 956
1096     ServerInfo.hub = 0;
1097 adx 30 ServerInfo.dns_host.sin_addr.s_addr = 0;
1098     ServerInfo.dns_host.sin_port = 0;
1099     AdminInfo.name = NULL;
1100     AdminInfo.email = NULL;
1101     AdminInfo.description = NULL;
1102    
1103 michael 1831 log_del_all();
1104 michael 1247
1105 adx 30 ConfigLoggingEntry.use_logging = 1;
1106    
1107 michael 1243 ConfigChannel.disable_fake_channels = 0;
1108 adx 30 ConfigChannel.knock_delay = 300;
1109     ConfigChannel.knock_delay_channel = 60;
1110 michael 1432 ConfigChannel.max_chans_per_user = 25;
1111 michael 1444 ConfigChannel.max_chans_per_oper = 50;
1112 adx 30 ConfigChannel.max_bans = 25;
1113     ConfigChannel.default_split_user_count = 0;
1114     ConfigChannel.default_split_server_count = 0;
1115 michael 1243 ConfigChannel.no_join_on_split = 0;
1116     ConfigChannel.no_create_on_split = 0;
1117 adx 30
1118 michael 1243 ConfigServerHide.flatten_links = 0;
1119 adx 30 ConfigServerHide.links_delay = 300;
1120 michael 1243 ConfigServerHide.hidden = 0;
1121     ConfigServerHide.hide_servers = 0;
1122 michael 1851 ConfigServerHide.hide_services = 0;
1123 michael 1646 ConfigServerHide.hidden_name = xstrdup(NETWORK_NAME_DEFAULT);
1124 michael 1243 ConfigServerHide.hide_server_ips = 0;
1125 michael 2196 ConfigServerHide.disable_remote_commands = 0;
1126 adx 30
1127 michael 1646 ConfigFileEntry.service_name = xstrdup(SERVICE_NAME_DEFAULT);
1128 michael 876 ConfigFileEntry.max_watch = WATCHSIZE_DEFAULT;
1129 michael 2283 ConfigFileEntry.cycle_on_host_change = 1;
1130 michael 1459 ConfigFileEntry.glines = 0;
1131     ConfigFileEntry.gline_time = 12 * 3600;
1132     ConfigFileEntry.gline_request_time = GLINE_REQUEST_EXPIRE_DEFAULT;
1133 adx 30 ConfigFileEntry.gline_min_cidr = 16;
1134     ConfigFileEntry.gline_min_cidr6 = 48;
1135 michael 1243 ConfigFileEntry.invisible_on_connect = 1;
1136     ConfigFileEntry.tkline_expire_notices = 1;
1137     ConfigFileEntry.hide_spoof_ips = 1;
1138     ConfigFileEntry.ignore_bogus_ts = 0;
1139     ConfigFileEntry.disable_auth = 0;
1140 adx 30 ConfigFileEntry.kill_chase_time_limit = 90;
1141 michael 1119 ConfigFileEntry.default_floodcount = 8;
1142 michael 1243 ConfigFileEntry.failed_oper_notice = 1;
1143 michael 1119 ConfigFileEntry.dots_in_ident = 0;
1144 adx 30 ConfigFileEntry.min_nonwildcard = 4;
1145     ConfigFileEntry.min_nonwildcard_simple = 3;
1146     ConfigFileEntry.max_accept = 20;
1147 michael 1243 ConfigFileEntry.anti_nick_flood = 0;
1148 adx 30 ConfigFileEntry.max_nick_time = 20;
1149     ConfigFileEntry.max_nick_changes = 5;
1150 michael 1119 ConfigFileEntry.anti_spam_exit_message_time = 0;
1151 adx 30 ConfigFileEntry.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
1152 michael 1119 ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;
1153 michael 1243 ConfigFileEntry.warn_no_nline = 1;
1154     ConfigFileEntry.stats_o_oper_only = 0;
1155 adx 30 ConfigFileEntry.stats_k_oper_only = 1; /* masked */
1156     ConfigFileEntry.stats_i_oper_only = 1; /* masked */
1157 michael 1243 ConfigFileEntry.stats_P_oper_only = 0;
1158 michael 2269 ConfigFileEntry.stats_u_oper_only = 0;
1159 adx 30 ConfigFileEntry.caller_id_wait = 60;
1160 michael 1243 ConfigFileEntry.opers_bypass_callerid = 0;
1161 adx 30 ConfigFileEntry.pace_wait = 10;
1162     ConfigFileEntry.pace_wait_simple = 1;
1163 michael 1243 ConfigFileEntry.short_motd = 0;
1164     ConfigFileEntry.ping_cookie = 0;
1165     ConfigFileEntry.no_oper_flood = 0;
1166     ConfigFileEntry.true_no_oper_flood = 0;
1167     ConfigFileEntry.oper_pass_resv = 1;
1168 adx 30 ConfigFileEntry.max_targets = MAX_TARGETS_DEFAULT;
1169 michael 1119 ConfigFileEntry.oper_only_umodes = UMODE_DEBUG;
1170 adx 264 ConfigFileEntry.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE |
1171 michael 1119 UMODE_OPERWALL | UMODE_WALLOP;
1172 michael 1243 ConfigFileEntry.use_egd = 0;
1173 adx 30 ConfigFileEntry.egdpool_path = NULL;
1174     ConfigFileEntry.throttle_time = 10;
1175     }
1176    
1177     static void
1178     validate_conf(void)
1179     {
1180     if (ConfigFileEntry.ts_warn_delta < TS_WARN_DELTA_MIN)
1181     ConfigFileEntry.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
1182    
1183     if (ConfigFileEntry.ts_max_delta < TS_MAX_DELTA_MIN)
1184     ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;
1185    
1186     if (ServerInfo.network_name == NULL)
1187 michael 1646 ServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
1188 adx 30
1189     if (ServerInfo.network_desc == NULL)
1190 michael 1646 ServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
1191 adx 30
1192 michael 1157 if (ConfigFileEntry.service_name == NULL)
1193 michael 1646 ConfigFileEntry.service_name = xstrdup(SERVICE_NAME_DEFAULT);
1194 michael 1157
1195 michael 876 ConfigFileEntry.max_watch = IRCD_MAX(ConfigFileEntry.max_watch, WATCHSIZE_MIN);
1196 adx 30 }
1197    
1198 michael 2916 /* read_conf()
1199 michael 1363 *
1200     * inputs - file descriptor pointing to config file to use
1201     * output - None
1202     * side effects - Read configuration file.
1203     */
1204     static void
1205     read_conf(FILE *file)
1206     {
1207     lineno = 0;
1208    
1209     set_default_conf(); /* Set default values prior to conf parsing */
1210     conf_parser_ctx.pass = 1;
1211 michael 2182 yyparse(); /* pick up the classes first */
1212 michael 1363
1213     rewind(file);
1214    
1215     conf_parser_ctx.pass = 2;
1216     yyparse(); /* Load the values from the conf */
1217     validate_conf(); /* Check to make sure some values are still okay. */
1218     /* Some global values are also loaded here. */
1219 michael 1632 class_delete_marked(); /* Make sure classes are valid */
1220 michael 1363 }
1221    
1222 adx 30 /* lookup_confhost()
1223     *
1224     * start DNS lookups of all hostnames in the conf
1225     * line and convert an IP addresses in a.b.c.d number for to IP#s.
1226     */
1227 michael 1647 void
1228 michael 1632 lookup_confhost(struct MaskItem *conf)
1229 adx 30 {
1230     struct addrinfo hints, *res;
1231    
1232     /* Do name lookup now on hostnames given and store the
1233     * ip numbers in conf structure.
1234     */
1235     memset(&hints, 0, sizeof(hints));
1236    
1237     hints.ai_family = AF_UNSPEC;
1238     hints.ai_socktype = SOCK_STREAM;
1239    
1240     /* Get us ready for a bind() and don't bother doing dns lookup */
1241     hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
1242    
1243 michael 1632 if (getaddrinfo(conf->host, NULL, &hints, &res))
1244 adx 30 {
1245 michael 1632 conf_dns_lookup(conf);
1246 adx 30 return;
1247     }
1248    
1249     assert(res != NULL);
1250    
1251 michael 1632 memcpy(&conf->addr, res->ai_addr, res->ai_addrlen);
1252     conf->addr.ss_len = res->ai_addrlen;
1253     conf->addr.ss.ss_family = res->ai_family;
1254    
1255 michael 1123 freeaddrinfo(res);
1256 adx 30 }
1257    
1258     /* conf_connect_allowed()
1259     *
1260     * inputs - pointer to inaddr
1261     * - int type ipv4 or ipv6
1262     * output - BANNED or accepted
1263     * side effects - none
1264     */
1265     int
1266     conf_connect_allowed(struct irc_ssaddr *addr, int aftype)
1267     {
1268     struct ip_entry *ip_found;
1269 michael 1632 struct MaskItem *conf = find_dline_conf(addr, aftype);
1270 adx 30
1271     /* DLINE exempt also gets you out of static limits/pacing... */
1272 michael 1636 if (conf && (conf->type == CONF_EXEMPT))
1273 adx 30 return 0;
1274    
1275 michael 1632 if (conf != NULL)
1276 adx 30 return BANNED_CLIENT;
1277    
1278     ip_found = find_or_add_ip(addr);
1279    
1280     if ((CurrentTime - ip_found->last_attempt) <
1281     ConfigFileEntry.throttle_time)
1282     {
1283     ip_found->last_attempt = CurrentTime;
1284     return TOO_FAST;
1285     }
1286    
1287     ip_found->last_attempt = CurrentTime;
1288     return 0;
1289     }
1290    
1291     /* cleanup_tklines()
1292     *
1293     * inputs - NONE
1294     * output - NONE
1295     * side effects - call function to expire temporary k/d lines
1296     * This is an event started off in ircd.c
1297     */
1298     void
1299     cleanup_tklines(void *notused)
1300     {
1301 michael 1369 hostmask_expire_temporary();
1302 michael 2916 expire_tklines(&xconf_items);
1303 michael 1628 expire_tklines(&nresv_items);
1304 michael 2174 expire_tklines(&cresv_items);
1305 adx 30 }
1306    
1307     /* expire_tklines()
1308     *
1309     * inputs - tkline list pointer
1310     * output - NONE
1311     * side effects - expire tklines
1312     */
1313     static void
1314     expire_tklines(dlink_list *tklist)
1315     {
1316     dlink_node *ptr;
1317     dlink_node *next_ptr;
1318 michael 1632 struct MaskItem *conf;
1319 adx 30
1320     DLINK_FOREACH_SAFE(ptr, next_ptr, tklist->head)
1321     {
1322     conf = ptr->data;
1323    
1324 michael 1649 if (!conf->until || conf->until > CurrentTime)
1325 michael 1644 continue;
1326    
1327 michael 1632 if (conf->type == CONF_XLINE)
1328 adx 30 {
1329 michael 1644 if (ConfigFileEntry.tkline_expire_notices)
1330     sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1331 michael 1618 "Temporary X-line for [%s] expired", conf->name);
1332 michael 1644 conf_free(conf);
1333 adx 30 }
1334 michael 1825 else if (conf->type == CONF_NRESV || conf->type == CONF_CRESV)
1335 adx 30 {
1336 michael 1644 if (ConfigFileEntry.tkline_expire_notices)
1337     sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1338 adx 30 "Temporary RESV for [%s] expired", conf->name);
1339 michael 1644 conf_free(conf);
1340 adx 30 }
1341     }
1342     }
1343    
1344     /* oper_privs_as_string()
1345     *
1346 michael 58 * inputs - pointer to client_p
1347 adx 30 * output - pointer to static string showing oper privs
1348     * side effects - return as string, the oper privs as derived from port
1349     */
1350 michael 58 static const struct oper_privs
1351     {
1352 michael 1644 const unsigned int flag;
1353 michael 58 const unsigned char c;
1354     } flag_list[] = {
1355 michael 2012 { OPER_FLAG_ADMIN, 'A' },
1356     { OPER_FLAG_REMOTEBAN, 'B' },
1357     { OPER_FLAG_DIE, 'D' },
1358     { OPER_FLAG_GLINE, 'G' },
1359     { OPER_FLAG_REHASH, 'H' },
1360     { OPER_FLAG_K, 'K' },
1361     { OPER_FLAG_OPERWALL, 'L' },
1362     { OPER_FLAG_KILL, 'N' },
1363     { OPER_FLAG_KILL_REMOTE, 'O' },
1364     { OPER_FLAG_CONNECT, 'P' },
1365     { OPER_FLAG_CONNECT_REMOTE, 'Q' },
1366     { OPER_FLAG_SQUIT, 'R' },
1367     { OPER_FLAG_SQUIT_REMOTE, 'S' },
1368     { OPER_FLAG_UNKLINE, 'U' },
1369 michael 2852 { OPER_FLAG_XLINE, 'X' },
1370 michael 1294 { 0, '\0' }
1371 michael 58 };
1372 adx 30
1373     char *
1374     oper_privs_as_string(const unsigned int port)
1375     {
1376 michael 2694 static char privs_out[IRCD_BUFSIZE];
1377 michael 58 char *privs_ptr = privs_out;
1378 michael 1644 const struct oper_privs *opriv = flag_list;
1379 adx 30
1380 michael 1644 for (; opriv->flag; ++opriv)
1381 michael 58 {
1382 michael 1644 if (port & opriv->flag)
1383     *privs_ptr++ = opriv->c;
1384 michael 58 else
1385 michael 1644 *privs_ptr++ = ToLower(opriv->c);
1386 michael 58 }
1387    
1388     *privs_ptr = '\0';
1389    
1390 adx 30 return privs_out;
1391     }
1392    
1393     /*
1394     * Input: A client to find the active oper{} name for.
1395     * Output: The nick!user@host{oper} of the oper.
1396     * "oper" is server name for remote opers
1397     * Side effects: None.
1398     */
1399 michael 1364 const char *
1400 adx 30 get_oper_name(const struct Client *client_p)
1401     {
1402 michael 3009 const dlink_node *cnode = NULL;
1403 adx 30 /* +5 for !,@,{,} and null */
1404 michael 1147 static char buffer[NICKLEN + USERLEN + HOSTLEN + HOSTLEN + 5];
1405 adx 30
1406     if (MyConnect(client_p))
1407     {
1408 michael 1364 if ((cnode = client_p->localClient->confs.head))
1409 adx 30 {
1410 michael 3009 const struct MaskItem *conf = cnode->data;
1411 adx 30
1412 michael 1632 if (IsConfOperator(conf))
1413 adx 30 {
1414 michael 2182 snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
1415 michael 1147 client_p->username, client_p->host, conf->name);
1416 michael 2182 return buffer;
1417 adx 30 }
1418     }
1419    
1420 michael 2916 /* Probably should assert here for now. If there is an oper out there
1421 adx 30 * with no oper{} conf attached, it would be good for us to know...
1422     */
1423     assert(0); /* Oper without oper conf! */
1424     }
1425    
1426 michael 1147 snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
1427 michael 2182 client_p->username, client_p->host, client_p->servptr->name);
1428 adx 30 return buffer;
1429     }
1430    
1431     /* read_conf_files()
1432     *
1433     * inputs - cold start YES or NO
1434     * output - none
1435     * side effects - read all conf files needed, ircd.conf kline.conf etc.
1436     */
1437     void
1438     read_conf_files(int cold)
1439     {
1440     const char *filename;
1441 michael 2694 char chanmodes[IRCD_BUFSIZE];
1442     char chanlimit[IRCD_BUFSIZE];
1443 adx 30
1444 michael 967 conf_parser_ctx.boot = cold;
1445 michael 1622 filename = ConfigFileEntry.configfile;
1446 adx 30
1447     /* We need to know the initial filename for the yyerror() to report
1448     FIXME: The full path is in conffilenamebuf first time since we
1449     dont know anything else
1450    
1451 michael 2916 - Gozem 2002-07-21
1452 adx 30 */
1453     strlcpy(conffilebuf, filename, sizeof(conffilebuf));
1454    
1455 michael 1325 if ((conf_parser_ctx.conf_file = fopen(filename, "r")) == NULL)
1456 adx 30 {
1457     if (cold)
1458     {
1459 michael 1247 ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
1460 adx 30 filename, strerror(errno));
1461     exit(-1);
1462     }
1463     else
1464     {
1465 michael 1618 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1466 michael 2182 "Unable to read configuration file '%s': %s",
1467     filename, strerror(errno));
1468 adx 30 return;
1469     }
1470     }
1471    
1472     if (!cold)
1473     clear_out_old_conf();
1474    
1475 michael 967 read_conf(conf_parser_ctx.conf_file);
1476 michael 1325 fclose(conf_parser_ctx.conf_file);
1477 adx 30
1478 michael 1831 log_reopen_all();
1479    
1480 michael 1751 add_isupport("NICKLEN", NULL, ServerInfo.max_nick_length);
1481 adx 30 add_isupport("NETWORK", ServerInfo.network_name, -1);
1482 michael 1751
1483     snprintf(chanmodes, sizeof(chanmodes), "beI:%d", ConfigChannel.max_bans);
1484 adx 30 add_isupport("MAXLIST", chanmodes, -1);
1485     add_isupport("MAXTARGETS", NULL, ConfigFileEntry.max_targets);
1486 michael 1474 add_isupport("CHANTYPES", "#", -1);
1487 michael 1147
1488 michael 1474 snprintf(chanlimit, sizeof(chanlimit), "#:%d",
1489 michael 1751 ConfigChannel.max_chans_per_user);
1490 adx 30 add_isupport("CHANLIMIT", chanlimit, -1);
1491 michael 1751 snprintf(chanmodes, sizeof(chanmodes), "%s", "beI,k,l,imnprstORS");
1492 michael 100 add_isupport("CHANNELLEN", NULL, LOCAL_CHANNELLEN);
1493 michael 1751 add_isupport("TOPICLEN", NULL, ServerInfo.max_topic_length);
1494 adx 30 add_isupport("CHANMODES", chanmodes, -1);
1495    
1496     /*
1497     * message_locale may have changed. rebuild isupport since it relies
1498     * on strlen(form_str(RPL_ISUPPORT))
1499     */
1500     rebuild_isupport_message_line();
1501     }
1502    
1503     /* clear_out_old_conf()
1504     *
1505     * inputs - none
1506     * output - none
1507     * side effects - Clear out the old configuration
1508     */
1509     static void
1510     clear_out_old_conf(void)
1511     {
1512     dlink_node *ptr = NULL, *next_ptr = NULL;
1513 michael 1632 struct MaskItem *conf;
1514 adx 30 dlink_list *free_items [] = {
1515 michael 1383 &server_items, &oconf_items,
1516 michael 1921 &uconf_items, &xconf_items,
1517 michael 2174 &nresv_items, &cluster_items, &service_items, &cresv_items, NULL
1518 adx 30 };
1519    
1520     dlink_list ** iterator = free_items; /* C is dumb */
1521    
1522     /* We only need to free anything allocated by yyparse() here.
1523     * Resetting structs, etc, is taken care of by set_default_conf().
1524     */
1525 michael 2916
1526 adx 30 for (; *iterator != NULL; iterator++)
1527     {
1528     DLINK_FOREACH_SAFE(ptr, next_ptr, (*iterator)->head)
1529     {
1530     conf = ptr->data;
1531 michael 1632
1532     dlinkDelete(&conf->node, map_to_list(conf->type));
1533    
1534 adx 30 /* XXX This is less than pretty */
1535 michael 1632 if (conf->type == CONF_SERVER || conf->type == CONF_OPER)
1536 adx 30 {
1537 michael 1644 if (!conf->ref_count)
1538 michael 2182 conf_free(conf);
1539 adx 30 }
1540 michael 1921 else if (conf->type == CONF_XLINE)
1541 adx 30 {
1542 michael 1649 if (!conf->until)
1543 michael 1632 conf_free(conf);
1544 adx 30 }
1545     else
1546 michael 1632 conf_free(conf);
1547 adx 30 }
1548     }
1549    
1550 michael 2150 motd_clear();
1551    
1552 michael 671 /*
1553     * don't delete the class table, rather mark all entries
1554 michael 1632 * for deletion. The table is cleaned up by class_delete_marked. - avalon
1555 adx 30 */
1556 michael 1632 class_mark_for_deletion();
1557 michael 671
1558 adx 30 clear_out_address_conf();
1559    
1560     /* clean out module paths */
1561     mod_clear_paths();
1562    
1563     /* clean out ServerInfo */
1564     MyFree(ServerInfo.description);
1565     ServerInfo.description = NULL;
1566     MyFree(ServerInfo.network_name);
1567     ServerInfo.network_name = NULL;
1568     MyFree(ServerInfo.network_desc);
1569     ServerInfo.network_desc = NULL;
1570     MyFree(ConfigFileEntry.egdpool_path);
1571     ConfigFileEntry.egdpool_path = NULL;
1572     #ifdef HAVE_LIBCRYPTO
1573     if (ServerInfo.rsa_private_key != NULL)
1574     {
1575     RSA_free(ServerInfo.rsa_private_key);
1576     ServerInfo.rsa_private_key = NULL;
1577     }
1578    
1579     MyFree(ServerInfo.rsa_private_key_file);
1580     ServerInfo.rsa_private_key_file = NULL;
1581 michael 1316
1582     if (ServerInfo.server_ctx)
1583     SSL_CTX_set_options(ServerInfo.server_ctx, SSL_OP_NO_SSLv2|
1584     SSL_OP_NO_SSLv3|
1585     SSL_OP_NO_TLSv1);
1586     if (ServerInfo.client_ctx)
1587     SSL_CTX_set_options(ServerInfo.client_ctx, SSL_OP_NO_SSLv2|
1588     SSL_OP_NO_SSLv3|
1589     SSL_OP_NO_TLSv1);
1590 adx 30 #endif
1591    
1592     /* clean out AdminInfo */
1593     MyFree(AdminInfo.name);
1594     AdminInfo.name = NULL;
1595     MyFree(AdminInfo.email);
1596     AdminInfo.email = NULL;
1597     MyFree(AdminInfo.description);
1598     AdminInfo.description = NULL;
1599    
1600     /* clean out listeners */
1601     close_listeners();
1602    
1603     /* clean out general */
1604 michael 1157 MyFree(ConfigFileEntry.service_name);
1605     ConfigFileEntry.service_name = NULL;
1606 adx 30 }
1607    
1608     /* conf_add_class_to_conf()
1609     *
1610     * inputs - pointer to config item
1611     * output - NONE
1612 michael 2916 * side effects - Add a class pointer to a conf
1613 adx 30 */
1614     void
1615 michael 1632 conf_add_class_to_conf(struct MaskItem *conf, const char *class_name)
1616 adx 30 {
1617 michael 2916 if (class_name == NULL)
1618 adx 30 {
1619 michael 1632 conf->class = class_default;
1620 michael 671
1621 michael 1632 if (conf->type == CONF_CLIENT)
1622 michael 1618 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1623 michael 2182 "Warning *** Defaulting to default class for %s@%s",
1624     conf->user, conf->host);
1625 adx 30 else
1626 michael 1618 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1627 michael 2182 "Warning *** Defaulting to default class for %s",
1628     conf->name);
1629 adx 30 }
1630     else
1631 michael 1632 conf->class = class_find(class_name, 1);
1632 adx 30
1633 michael 1632 if (conf->class == NULL)
1634 adx 30 {
1635 michael 1632 if (conf->type == CONF_CLIENT)
1636 michael 1618 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1637 michael 2182 "Warning *** Defaulting to default class for %s@%s",
1638     conf->user, conf->host);
1639 adx 30 else
1640 michael 1618 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1641 michael 2182 "Warning *** Defaulting to default class for %s",
1642     conf->name);
1643 michael 1632 conf->class = class_default;
1644 adx 30 }
1645     }
1646    
1647     /* yyerror()
1648     *
1649     * inputs - message from parser
1650     * output - NONE
1651     * side effects - message to opers and log file entry is made
1652     */
1653     void
1654     yyerror(const char *msg)
1655     {
1656     char newlinebuf[IRCD_BUFSIZE];
1657    
1658 michael 967 if (conf_parser_ctx.pass != 1)
1659 adx 30 return;
1660    
1661     strip_tabs(newlinebuf, linebuf, sizeof(newlinebuf));
1662 michael 1751 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1663 michael 1618 "\"%s\", line %u: %s: %s",
1664 adx 30 conffilebuf, lineno + 1, msg, newlinebuf);
1665 michael 1247 ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
1666 adx 30 conffilebuf, lineno + 1, msg, newlinebuf);
1667     }
1668    
1669 michael 1751 void
1670     conf_error_report(const char *msg)
1671     {
1672     char newlinebuf[IRCD_BUFSIZE];
1673    
1674     strip_tabs(newlinebuf, linebuf, sizeof(newlinebuf));
1675     sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1676     "\"%s\", line %u: %s: %s",
1677     conffilebuf, lineno + 1, msg, newlinebuf);
1678     ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
1679     conffilebuf, lineno + 1, msg, newlinebuf);
1680     }
1681    
1682 adx 30 /*
1683     * valid_tkline()
1684 michael 2916 *
1685 adx 30 * inputs - pointer to ascii string to check
1686     * - whether the specified time is in seconds or minutes
1687     * output - -1 not enough parameters
1688     * - 0 if not an integer number, else the number
1689     * side effects - none
1690     * Originally written by Dianora (Diane, db@db.net)
1691     */
1692     time_t
1693 michael 2313 valid_tkline(const char *data, const int minutes)
1694 adx 30 {
1695 michael 2313 const unsigned char *p = (const unsigned char *)data;
1696     unsigned char tmpch = '\0';
1697 adx 30 time_t result = 0;
1698    
1699 michael 2313 while ((tmpch = *p++))
1700 adx 30 {
1701 michael 2313 if (!IsDigit(tmpch))
1702 michael 1121 return 0;
1703 michael 1120
1704     result *= 10;
1705 michael 2313 result += (tmpch & 0xF);
1706 adx 30 }
1707    
1708 michael 1120 /*
1709 michael 2916 * In the degenerate case where oper does a /quote kline 0 user@host :reason
1710 adx 30 * i.e. they specifically use 0, I am going to return 1 instead
1711     * as a return value of non-zero is used to flag it as a temporary kline
1712     */
1713     if (result == 0)
1714     result = 1;
1715    
1716 michael 2916 /*
1717 adx 30 * If the incoming time is in seconds convert it to minutes for the purpose
1718     * of this calculation
1719     */
1720     if (!minutes)
1721 michael 2916 result = result / 60;
1722 adx 30
1723     if (result > MAX_TDKLINE_TIME)
1724     result = MAX_TDKLINE_TIME;
1725    
1726 michael 2313 result = result * 60; /* turn it into seconds */
1727 adx 30
1728     return result;
1729     }
1730    
1731 michael 2130 /* valid_wild_card_simple()
1732     *
1733     * inputs - data to check for sufficient non-wildcard characters
1734     * outputs - 1 if valid, else 0
1735     * side effects - none
1736     */
1737     int
1738     valid_wild_card_simple(const char *data)
1739     {
1740     const unsigned char *p = (const unsigned char *)data;
1741     unsigned char tmpch = '\0';
1742     int nonwild = 0;
1743    
1744     while ((tmpch = *p++))
1745     {
1746     if (tmpch == '\\')
1747     {
1748     ++p;
1749     if (++nonwild >= ConfigFileEntry.min_nonwildcard_simple)
1750     return 1;
1751     }
1752     else if (!IsMWildChar(tmpch))
1753     {
1754     if (++nonwild >= ConfigFileEntry.min_nonwildcard_simple)
1755     return 1;
1756     }
1757     }
1758    
1759     return 0;
1760     }
1761    
1762 adx 30 /* valid_wild_card()
1763     *
1764     * input - pointer to client
1765     * - int flag, 0 for no warning oper 1 for warning oper
1766     * - count of following varargs to check
1767     * output - 0 if not valid, 1 if valid
1768     * side effects - NOTICE is given to source_p if warn is 1
1769     */
1770     int
1771     valid_wild_card(struct Client *source_p, int warn, int count, ...)
1772     {
1773     char tmpch;
1774     int nonwild = 0;
1775     va_list args;
1776    
1777     /*
1778     * Now we must check the user and host to make sure there
1779     * are at least NONWILDCHARS non-wildcard characters in
1780     * them, otherwise assume they are attempting to kline
1781     * *@* or some variant of that. This code will also catch
1782     * people attempting to kline *@*.tld, as long as NONWILDCHARS
1783     * is greater than 3. In that case, there are only 3 non-wild
1784     * characters (tld), so if NONWILDCHARS is 4, the kline will
1785     * be disallowed.
1786     * -wnder
1787     */
1788    
1789     va_start(args, count);
1790    
1791     while (count--)
1792     {
1793 michael 2133 const char *p = va_arg(args, const char *);
1794 adx 30 if (p == NULL)
1795     continue;
1796    
1797     while ((tmpch = *p++))
1798     {
1799     if (!IsKWildChar(tmpch))
1800     {
1801     /*
1802     * If we find enough non-wild characters, we can
1803     * break - no point in searching further.
1804     */
1805     if (++nonwild >= ConfigFileEntry.min_nonwildcard)
1806 michael 2659 {
1807     va_end(args);
1808 adx 30 return 1;
1809 michael 2659 }
1810 adx 30 }
1811     }
1812     }
1813    
1814     if (warn)
1815 michael 3110 sendto_one_notice(source_p, &me,
1816     ":Please include at least %d non-wildcard characters with the mask",
1817     ConfigFileEntry.min_nonwildcard);
1818 michael 2659 va_end(args);
1819 adx 30 return 0;
1820     }
1821    
1822     /* XXX should this go into a separate file ? -Dianora */
1823     /* parse_aline
1824     *
1825     * input - pointer to cmd name being used
1826     * - pointer to client using cmd
1827     * - parc parameter count
1828     * - parv[] list of parameters to parse
1829     * - parse_flags bit map of things to test
1830     * - pointer to user or string to parse into
1831     * - pointer to host or NULL to parse into if non NULL
1832 michael 2916 * - pointer to optional tkline time or NULL
1833 adx 30 * - pointer to target_server to parse into if non NULL
1834     * - pointer to reason to parse into
1835     *
1836     * output - 1 if valid, -1 if not valid
1837     * side effects - A generalised k/d/x etc. line parser,
1838     * "ALINE [time] user@host|string [ON] target :reason"
1839     * will parse returning a parsed user, host if
1840     * h_p pointer is non NULL, string otherwise.
1841     * if tkline_time pointer is non NULL a tk line will be set
1842     * to non zero if found.
1843     * if tkline_time pointer is NULL and tk line is found,
1844     * error is reported.
1845     * if target_server is NULL and an "ON" is found error
1846     * is reported.
1847     * if reason pointer is NULL ignore pointer,
1848 db 936 * this allows use of parse_a_line in unkline etc.
1849 adx 30 *
1850     * - Dianora
1851     */
1852     int
1853     parse_aline(const char *cmd, struct Client *source_p,
1854 michael 2182 int parc, char **parv,
1855     int parse_flags, char **up_p, char **h_p, time_t *tkline_time,
1856     char **target_server, char **reason)
1857 adx 30 {
1858     int found_tkline_time=0;
1859     static char def_reason[] = "No Reason";
1860     static char user[USERLEN*4+1];
1861     static char host[HOSTLEN*4+1];
1862    
1863     parv++;
1864     parc--;
1865    
1866     found_tkline_time = valid_tkline(*parv, TK_MINUTES);
1867    
1868     if (found_tkline_time != 0)
1869     {
1870     parv++;
1871     parc--;
1872    
1873     if (tkline_time != NULL)
1874     *tkline_time = found_tkline_time;
1875     else
1876     {
1877 michael 3110 sendto_one_notice(source_p, &me, ":temp_line not supported by %s", cmd);
1878 adx 30 return -1;
1879     }
1880     }
1881    
1882     if (parc == 0)
1883     {
1884 michael 3109 sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1885 adx 30 return -1;
1886     }
1887    
1888     if (h_p == NULL)
1889     *up_p = *parv;
1890     else
1891     {
1892     if (find_user_host(source_p, *parv, user, host, parse_flags) == 0)
1893     return -1;
1894    
1895     *up_p = user;
1896     *h_p = host;
1897     }
1898 michael 2916
1899 adx 30 parc--;
1900     parv++;
1901    
1902     if (parc != 0)
1903     {
1904     if (irccmp(*parv, "ON") == 0)
1905     {
1906     parc--;
1907     parv++;
1908    
1909     if (target_server == NULL)
1910     {
1911 michael 3110 sendto_one_notice(source_p, &me, ":ON server not supported by %s", cmd);
1912 michael 2182 return -1;
1913 adx 30 }
1914    
1915 michael 1219 if (!HasOFlag(source_p, OPER_FLAG_REMOTEBAN))
1916 adx 30 {
1917 michael 3109 sendto_one_numeric(source_p, &me, ERR_NOPRIVS, "remoteban");
1918 adx 30 return -1;
1919     }
1920    
1921     if (parc == 0 || EmptyString(*parv))
1922     {
1923 michael 3109 sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1924 michael 2182 return -1;
1925 adx 30 }
1926    
1927     *target_server = *parv;
1928     parc--;
1929     parv++;
1930     }
1931     else
1932     {
1933     /* Make sure target_server *is* NULL if no ON server found
1934     * caller probably NULL'd it first, but no harm to do it again -db
1935     */
1936     if (target_server != NULL)
1937 michael 2182 *target_server = NULL;
1938 adx 30 }
1939     }
1940    
1941     if (h_p != NULL)
1942     {
1943     if (strchr(user, '!') != NULL)
1944     {
1945 michael 3110 sendto_one_notice(source_p, &me, ":Invalid character '!' in kline");
1946 adx 30 return -1;
1947     }
1948    
1949 michael 1243 if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 2, *up_p, *h_p))
1950 adx 30 return -1;
1951     }
1952     else
1953 michael 1243 if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 1, *up_p))
1954 adx 30 return -1;
1955    
1956     if (reason != NULL)
1957     {
1958 michael 867 if (parc != 0 && !EmptyString(*parv))
1959 adx 30 {
1960     *reason = *parv;
1961 michael 1243 if (!valid_comment(source_p, *reason, 1))
1962 michael 2182 return -1;
1963 adx 30 }
1964     else
1965     *reason = def_reason;
1966     }
1967    
1968     return 1;
1969     }
1970    
1971     /* find_user_host()
1972     *
1973     * inputs - pointer to client placing kline
1974     * - pointer to user_host_or_nick
1975     * - pointer to user buffer
1976     * - pointer to host buffer
1977     * output - 0 if not ok to kline, 1 to kline i.e. if valid user host
1978     * side effects -
1979     */
1980     static int
1981     find_user_host(struct Client *source_p, char *user_host_or_nick,
1982     char *luser, char *lhost, unsigned int flags)
1983     {
1984     struct Client *target_p = NULL;
1985     char *hostp = NULL;
1986    
1987     if (lhost == NULL)
1988     {
1989     strlcpy(luser, user_host_or_nick, USERLEN*4 + 1);
1990     return 1;
1991     }
1992    
1993     if ((hostp = strchr(user_host_or_nick, '@')) || *user_host_or_nick == '*')
1994     {
1995     /* Explicit user@host mask given */
1996    
1997 michael 593 if (hostp != NULL) /* I'm a little user@host */
1998 adx 30 {
1999     *(hostp++) = '\0'; /* short and squat */
2000     if (*user_host_or_nick)
2001 michael 2182 strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
2002 adx 30 else
2003 michael 2182 strcpy(luser, "*");
2004    
2005 adx 30 if (*hostp)
2006 michael 2182 strlcpy(lhost, hostp, HOSTLEN + 1); /* here is my host */
2007 adx 30 else
2008 michael 2182 strcpy(lhost, "*");
2009 adx 30 }
2010     else
2011     {
2012     luser[0] = '*'; /* no @ found, assume its *@somehost */
2013 michael 2182 luser[1] = '\0';
2014 adx 30 strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
2015     }
2016 michael 2916
2017 adx 30 return 1;
2018     }
2019 michael 1518 else
2020 adx 30 {
2021     /* Try to find user@host mask from nick */
2022     /* Okay to use source_p as the first param, because source_p == client_p */
2023 michael 2916 if ((target_p =
2024 michael 2475 find_chasing(source_p, user_host_or_nick, NULL)) == NULL)
2025 adx 30 return 0;
2026    
2027     if (IsExemptKline(target_p))
2028     {
2029     if (!IsServer(source_p))
2030 michael 3110 sendto_one_notice(source_p, &me, ":%s is E-lined", target_p->name);
2031 adx 30 return 0;
2032     }
2033    
2034     /*
2035     * turn the "user" bit into "*user", blow away '~'
2036     * if found in original user name (non-idented)
2037     */
2038     strlcpy(luser, target_p->username, USERLEN*4 + 1);
2039    
2040     if (target_p->username[0] == '~')
2041     luser[0] = '*';
2042    
2043     if (target_p->sockhost[0] == '\0' ||
2044     (target_p->sockhost[0] == '0' && target_p->sockhost[1] == '\0'))
2045     strlcpy(lhost, target_p->host, HOSTLEN*4 + 1);
2046     else
2047     strlcpy(lhost, target_p->sockhost, HOSTLEN*4 + 1);
2048     return 1;
2049     }
2050    
2051     return 0;
2052     }
2053    
2054     /* valid_comment()
2055     *
2056     * inputs - pointer to client
2057     * - pointer to comment
2058     * output - 0 if no valid comment,
2059     * - 1 if valid
2060     * side effects - truncates reason where necessary
2061     */
2062     int
2063     valid_comment(struct Client *source_p, char *comment, int warn)
2064     {
2065     if (strlen(comment) > REASONLEN)
2066     comment[REASONLEN-1] = '\0';
2067    
2068     return 1;
2069     }
2070    
2071     /* match_conf_password()
2072     *
2073     * inputs - pointer to given password
2074     * - pointer to Conf
2075     * output - 1 or 0 if match
2076     * side effects - none
2077     */
2078     int
2079 michael 1632 match_conf_password(const char *password, const struct MaskItem *conf)
2080 adx 30 {
2081     const char *encr = NULL;
2082    
2083 michael 1632 if (EmptyString(password) || EmptyString(conf->passwd))
2084 adx 30 return 0;
2085    
2086 michael 1632 if (conf->flags & CONF_FLAGS_ENCRYPTED)
2087     encr = crypt(password, conf->passwd);
2088 adx 30 else
2089     encr = password;
2090    
2091 michael 1632 return !strcmp(encr, conf->passwd);
2092 adx 30 }
2093    
2094     /*
2095     * cluster_a_line
2096     *
2097     * inputs - client sending the cluster
2098     * - command name "KLINE" "XLINE" etc.
2099     * - capab -- CAP_KLN etc. from s_serv.h
2100 michael 1309 * - cluster type -- CLUSTER_KLINE etc. from conf.h
2101 adx 30 * - pattern and args to send along
2102     * output - none
2103     * side effects - Take source_p send the pattern with args given
2104     * along to all servers that match capab and cluster type
2105     */
2106     void
2107     cluster_a_line(struct Client *source_p, const char *command,
2108 michael 593 int capab, int cluster_type, const char *pattern, ...)
2109 adx 30 {
2110     va_list args;
2111     char buffer[IRCD_BUFSIZE];
2112 michael 593 const dlink_node *ptr = NULL;
2113 adx 30
2114     va_start(args, pattern);
2115     vsnprintf(buffer, sizeof(buffer), pattern, args);
2116     va_end(args);
2117    
2118     DLINK_FOREACH(ptr, cluster_items.head)
2119     {
2120 michael 1632 const struct MaskItem *conf = ptr->data;
2121 adx 30
2122     if (conf->flags & cluster_type)
2123     sendto_match_servs(source_p, conf->name, CAP_CLUSTER|capab,
2124 michael 2182 "%s %s %s", command, conf->name, buffer);
2125 adx 30 }
2126     }
2127    
2128     /*
2129     * split_nuh
2130     *
2131     * inputs - pointer to original mask (modified in place)
2132     * - pointer to pointer where nick should go
2133     * - pointer to pointer where user should go
2134     * - pointer to pointer where host should go
2135     * output - NONE
2136     * side effects - mask is modified in place
2137     * If nick pointer is NULL, ignore writing to it
2138     * this allows us to use this function elsewhere.
2139     *
2140     * mask nick user host
2141     * ---------------------- ------- ------- ------
2142     * Dianora!db@db.net Dianora db db.net
2143     * Dianora Dianora * *
2144     * db.net * * db.net
2145     * OR if nick pointer is NULL
2146     * Dianora - * Dianora
2147     * Dianora! Dianora * *
2148     * Dianora!@ Dianora * *
2149     * Dianora!db Dianora db *
2150     * Dianora!@db.net Dianora * db.net
2151     * db@db.net * db db.net
2152     * !@ * * *
2153     * @ * * *
2154     * ! * * *
2155     */
2156     void
2157 michael 593 split_nuh(struct split_nuh_item *const iptr)
2158 adx 30 {
2159     char *p = NULL, *q = NULL;
2160    
2161 michael 593 if (iptr->nickptr)
2162     strlcpy(iptr->nickptr, "*", iptr->nicksize);
2163     if (iptr->userptr)
2164     strlcpy(iptr->userptr, "*", iptr->usersize);
2165     if (iptr->hostptr)
2166     strlcpy(iptr->hostptr, "*", iptr->hostsize);
2167    
2168     if ((p = strchr(iptr->nuhmask, '!')))
2169 adx 30 {
2170     *p = '\0';
2171    
2172 michael 593 if (iptr->nickptr && *iptr->nuhmask != '\0')
2173     strlcpy(iptr->nickptr, iptr->nuhmask, iptr->nicksize);
2174 adx 30
2175 michael 2525 if ((q = strchr(++p, '@')))
2176     {
2177 michael 593 *q++ = '\0';
2178    
2179 adx 30 if (*p != '\0')
2180 michael 593 strlcpy(iptr->userptr, p, iptr->usersize);
2181 adx 30
2182 michael 593 if (*q != '\0')
2183     strlcpy(iptr->hostptr, q, iptr->hostsize);
2184 adx 30 }
2185     else
2186     {
2187     if (*p != '\0')
2188 michael 593 strlcpy(iptr->userptr, p, iptr->usersize);
2189 adx 30 }
2190     }
2191 michael 593 else
2192 adx 30 {
2193 michael 593 /* No ! found so lets look for a user@host */
2194     if ((p = strchr(iptr->nuhmask, '@')))
2195 adx 30 {
2196 michael 593 /* if found a @ */
2197     *p++ = '\0';
2198 adx 30
2199 michael 593 if (*iptr->nuhmask != '\0')
2200     strlcpy(iptr->userptr, iptr->nuhmask, iptr->usersize);
2201 adx 30
2202 michael 593 if (*p != '\0')
2203     strlcpy(iptr->hostptr, p, iptr->hostsize);
2204 adx 30 }
2205 michael 593 else
2206 adx 30 {
2207 michael 593 /* no @ found */
2208     if (!iptr->nickptr || strpbrk(iptr->nuhmask, ".:"))
2209     strlcpy(iptr->hostptr, iptr->nuhmask, iptr->hostsize);
2210 adx 30 else
2211 michael 593 strlcpy(iptr->nickptr, iptr->nuhmask, iptr->nicksize);
2212 adx 30 }
2213     }
2214     }

Properties

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