1 |
|
/* |
2 |
|
* ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd) |
3 |
|
* |
4 |
< |
* Copyright (c) 1997-2016 ircd-hybrid development team |
4 |
> |
* Copyright (c) 1997-2020 ircd-hybrid development team |
5 |
|
* |
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 |
27 |
|
#include "stdinc.h" |
28 |
|
#include "list.h" |
29 |
|
#include "ircd_defs.h" |
30 |
+ |
#include "parse.h" |
31 |
|
#include "conf.h" |
32 |
|
#include "conf_cluster.h" |
33 |
|
#include "conf_gecos.h" |
51 |
|
#include "send.h" |
52 |
|
#include "memory.h" |
53 |
|
#include "res.h" |
53 |
– |
#include "userhost.h" |
54 |
|
#include "user.h" |
55 |
|
#include "channel_mode.h" |
56 |
– |
#include "parse.h" |
56 |
|
#include "misc.h" |
57 |
|
#include "conf_db.h" |
58 |
|
#include "conf_class.h" |
95 |
|
{ |
96 |
|
struct MaskItem *const conf = vptr; |
97 |
|
|
98 |
< |
conf->dns_pending = 0; |
98 |
> |
conf->dns_pending = false; |
99 |
|
|
100 |
|
if (addr) |
101 |
< |
memcpy(&conf->addr, addr, sizeof(conf->addr)); |
101 |
> |
*conf->addr = *addr; |
102 |
|
else |
103 |
< |
conf->dns_failed = 1; |
103 |
> |
conf->dns_failed = true; |
104 |
|
} |
105 |
|
|
106 |
< |
/* conf_dns_lookup() |
106 |
> |
/* conf_resolve_host() |
107 |
|
* |
108 |
< |
* do a nameserver lookup of the conf host |
109 |
< |
* if the conf entry is currently doing a ns lookup do nothing, otherwise |
111 |
< |
* allocate a dns_query and start ns lookup. |
108 |
> |
* start DNS lookups of all hostnames in the conf |
109 |
> |
* line and convert an IP addresses in a.b.c.d number for to IP#s. |
110 |
|
*/ |
111 |
< |
static void |
111 |
> |
void |
112 |
|
conf_dns_lookup(struct MaskItem *conf) |
113 |
|
{ |
114 |
< |
if (conf->dns_pending) |
114 |
> |
struct addrinfo hints, *res; |
115 |
> |
|
116 |
> |
/* |
117 |
> |
* Do name lookup now on hostnames given and store the |
118 |
> |
* ip numbers in conf structure. |
119 |
> |
*/ |
120 |
> |
memset(&hints, 0, sizeof(hints)); |
121 |
> |
|
122 |
> |
hints.ai_family = AF_UNSPEC; |
123 |
> |
hints.ai_socktype = SOCK_STREAM; |
124 |
> |
|
125 |
> |
/* Get us ready for a bind() and don't bother doing dns lookup */ |
126 |
> |
hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST; |
127 |
> |
|
128 |
> |
if (getaddrinfo(conf->host, NULL, &hints, &res)) |
129 |
> |
{ |
130 |
> |
/* |
131 |
> |
* By this point conf->host possibly is not a numerical network address. Do a nameserver |
132 |
> |
* lookup of the conf host. If the conf entry is currently doing a ns lookup do nothing. |
133 |
> |
*/ |
134 |
> |
if (conf->dns_pending == true) |
135 |
> |
return; |
136 |
> |
|
137 |
> |
conf->dns_pending = true; |
138 |
> |
|
139 |
> |
if (conf->aftype == AF_INET) |
140 |
> |
gethost_byname_type(conf_dns_callback, conf, conf->host, T_A); |
141 |
> |
else |
142 |
> |
gethost_byname_type(conf_dns_callback, conf, conf->host, T_AAAA); |
143 |
|
return; |
144 |
+ |
} |
145 |
|
|
146 |
< |
conf->dns_pending = 1; |
146 |
> |
assert(res); |
147 |
|
|
148 |
< |
if (conf->aftype == AF_INET) |
149 |
< |
gethost_byname_type(conf_dns_callback, conf, conf->host, T_A); |
150 |
< |
else |
151 |
< |
gethost_byname_type(conf_dns_callback, conf, conf->host, T_AAAA); |
148 |
> |
memcpy(conf->addr, res->ai_addr, res->ai_addrlen); |
149 |
> |
conf->addr->ss_len = res->ai_addrlen; |
150 |
> |
|
151 |
> |
freeaddrinfo(res); |
152 |
|
} |
153 |
|
|
154 |
|
/* map_to_list() |
180 |
|
dlink_list *list = NULL; |
181 |
|
|
182 |
|
conf->type = type; |
183 |
< |
conf->active = 1; |
183 |
> |
conf->active = true; |
184 |
|
conf->aftype = AF_INET; |
185 |
|
|
186 |
|
if ((list = map_to_list(type))) |
199 |
|
|
200 |
|
xfree(conf->name); |
201 |
|
|
202 |
< |
if (conf->dns_pending) |
202 |
> |
if (conf->dns_pending == true) |
203 |
|
delete_resolver_queries(conf); |
204 |
|
if (conf->passwd) |
205 |
|
memset(conf->passwd, 0, strlen(conf->passwd)); |
215 |
|
xfree(conf->whois); |
216 |
|
xfree(conf->user); |
217 |
|
xfree(conf->host); |
218 |
+ |
xfree(conf->addr); |
219 |
+ |
xfree(conf->bind); |
220 |
|
xfree(conf->cipher_list); |
221 |
|
|
222 |
|
DLINK_FOREACH_SAFE(node, node_next, conf->hub_list.head) |
244 |
|
* side effects - do actual attach |
245 |
|
*/ |
246 |
|
static int |
247 |
< |
attach_iline(struct Client *client_p, struct MaskItem *conf) |
247 |
> |
attach_iline(struct Client *client, struct MaskItem *conf) |
248 |
|
{ |
249 |
|
const struct ClassItem *const class = conf->class; |
250 |
< |
struct ip_entry *ip_found; |
251 |
< |
int a_limit_reached = 0; |
252 |
< |
unsigned int local = 0, global = 0; |
253 |
< |
|
254 |
< |
ip_found = ipcache_find_or_add_address(&client_p->connection->ip); |
255 |
< |
ip_found->count++; |
227 |
< |
AddFlag(client_p, FLAGS_IPHASH); |
228 |
< |
|
229 |
< |
userhost_count(client_p->sockhost, &global, &local); |
230 |
< |
|
231 |
< |
/* XXX blah. go down checking the various silly limits |
232 |
< |
* setting a_limit_reached if any limit is reached. |
233 |
< |
* - Dianora |
234 |
< |
*/ |
250 |
> |
bool a_limit_reached = false; |
251 |
> |
|
252 |
> |
struct ip_entry *ipcache = ipcache_record_find_or_add(&client->ip); |
253 |
> |
++ipcache->count_local; |
254 |
> |
AddFlag(client, FLAGS_IPHASH); |
255 |
> |
|
256 |
|
if (class->max_total && class->ref_count >= class->max_total) |
257 |
< |
a_limit_reached = 1; |
258 |
< |
else if (class->max_perip && ip_found->count > class->max_perip) |
259 |
< |
a_limit_reached = 1; |
260 |
< |
else if (class->max_local && local >= class->max_local) /* XXX: redundant */ |
261 |
< |
a_limit_reached = 1; |
262 |
< |
else if (class->max_global && global >= class->max_global) |
242 |
< |
a_limit_reached = 1; |
257 |
> |
a_limit_reached = true; |
258 |
> |
else if (class->max_perip_local && ipcache->count_local > class->max_perip_local) |
259 |
> |
a_limit_reached = true; |
260 |
> |
else if (class->max_perip_global && |
261 |
> |
(ipcache->count_local + ipcache->count_remote) > class->max_perip_global) |
262 |
> |
a_limit_reached = true; |
263 |
|
|
264 |
< |
if (a_limit_reached) |
264 |
> |
if (a_limit_reached == true) |
265 |
|
{ |
266 |
|
if (!IsConfExemptLimits(conf)) |
267 |
|
return TOO_MANY; /* Already at maximum allowed */ |
268 |
|
|
269 |
< |
sendto_one_notice(client_p, &me, ":*** Your connection class is full, " |
269 |
> |
sendto_one_notice(client, &me, ":*** Your connection class is full, " |
270 |
|
"but you have exceed_limit = yes;"); |
271 |
|
} |
272 |
|
|
273 |
< |
return attach_conf(client_p, conf); |
273 |
> |
return conf_attach(client, conf); |
274 |
|
} |
275 |
|
|
276 |
|
/* verify_access() |
280 |
|
* side effect - find the first (best) I line to attach. |
281 |
|
*/ |
282 |
|
static int |
283 |
< |
verify_access(struct Client *client_p) |
283 |
> |
verify_access(struct Client *client) |
284 |
|
{ |
285 |
< |
struct MaskItem *conf = NULL; |
285 |
> |
struct MaskItem *conf; |
286 |
|
|
287 |
< |
if (HasFlag(client_p, FLAGS_GOTID)) |
288 |
< |
{ |
289 |
< |
conf = find_address_conf(client_p->host, client_p->username, |
270 |
< |
&client_p->connection->ip, |
271 |
< |
client_p->connection->aftype, |
272 |
< |
client_p->connection->password); |
273 |
< |
} |
287 |
> |
if (HasFlag(client, FLAGS_GOTID)) |
288 |
> |
conf = find_address_conf(client->host, client->username, &client->ip, |
289 |
> |
client->connection->password); |
290 |
|
else |
291 |
|
{ |
292 |
|
char non_ident[USERLEN + 1] = "~"; |
293 |
|
|
294 |
< |
strlcpy(non_ident + 1, client_p->username, sizeof(non_ident) - 1); |
295 |
< |
conf = find_address_conf(client_p->host, non_ident, |
296 |
< |
&client_p->connection->ip, |
281 |
< |
client_p->connection->aftype, |
282 |
< |
client_p->connection->password); |
294 |
> |
strlcpy(non_ident + 1, client->username, sizeof(non_ident) - 1); |
295 |
> |
conf = find_address_conf(client->host, non_ident, &client->ip, |
296 |
> |
client->connection->password); |
297 |
|
} |
298 |
|
|
299 |
< |
if (!conf) |
299 |
> |
if (conf == NULL) |
300 |
|
return NOT_AUTHORIZED; |
301 |
|
|
302 |
|
assert(IsConfClient(conf) || IsConfKill(conf)); |
303 |
|
|
304 |
< |
if (IsConfClient(conf)) |
304 |
> |
if (IsConfKill(conf)) |
305 |
|
{ |
306 |
< |
if (IsConfRedir(conf)) |
307 |
< |
{ |
308 |
< |
sendto_one_numeric(client_p, &me, RPL_REDIR, |
295 |
< |
conf->name ? conf->name : "", |
296 |
< |
conf->port); |
297 |
< |
return NOT_AUTHORIZED; |
298 |
< |
} |
306 |
> |
sendto_one_notice(client, &me, ":*** Banned: %s", conf->reason); |
307 |
> |
return BANNED_CLIENT; |
308 |
> |
} |
309 |
|
|
310 |
< |
if (IsConfDoSpoofIp(conf)) |
311 |
< |
{ |
312 |
< |
if (IsConfSpoofNotice(conf)) |
313 |
< |
sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE, "%s spoofing: %s as %s", |
314 |
< |
client_p->name, client_p->host, conf->name); |
310 |
> |
if (IsConfRedir(conf)) |
311 |
> |
{ |
312 |
> |
sendto_one_numeric(client, &me, RPL_REDIR, |
313 |
> |
conf->name ? conf->name : "", |
314 |
> |
conf->port); |
315 |
> |
return NOT_AUTHORIZED; |
316 |
> |
} |
317 |
|
|
318 |
< |
strlcpy(client_p->host, conf->name, sizeof(client_p->host)); |
319 |
< |
} |
318 |
> |
/* Preserve x->host in x->realhost before it gets overwritten. */ |
319 |
> |
strlcpy(client->realhost, client->host, sizeof(client->realhost)); |
320 |
|
|
321 |
< |
return attach_iline(client_p, conf); |
322 |
< |
} |
321 |
> |
if (IsConfDoSpoofIp(conf)) |
322 |
> |
strlcpy(client->host, conf->name, sizeof(client->host)); |
323 |
|
|
324 |
< |
sendto_one_notice(client_p, &me, ":*** Banned: %s", conf->reason); |
313 |
< |
return BANNED_CLIENT; |
324 |
> |
return attach_iline(client, conf); |
325 |
|
} |
326 |
|
|
327 |
|
/* check_client() |
337 |
|
* Look for conf lines which have the same |
338 |
|
* status as the flags passed. |
339 |
|
*/ |
340 |
< |
int |
341 |
< |
check_client(struct Client *source_p) |
340 |
> |
bool |
341 |
> |
conf_check_client(struct Client *client) |
342 |
|
{ |
343 |
|
int i; |
344 |
|
|
345 |
< |
if ((i = verify_access(source_p))) |
345 |
> |
if ((i = verify_access(client))) |
346 |
|
ilog(LOG_TYPE_IRCD, "Access denied: %s[%s]", |
347 |
< |
source_p->name, source_p->sockhost); |
347 |
> |
client->name, client->sockhost); |
348 |
|
|
349 |
|
switch (i) |
350 |
|
{ |
351 |
|
case TOO_MANY: |
352 |
< |
sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE, |
352 |
> |
sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE, |
353 |
|
"Too many on IP for %s (%s).", |
354 |
< |
get_client_name(source_p, SHOW_IP), |
355 |
< |
source_p->sockhost); |
354 |
> |
client_get_name(client, SHOW_IP), |
355 |
> |
client->sockhost); |
356 |
|
ilog(LOG_TYPE_IRCD, "Too many connections on IP from %s.", |
357 |
< |
get_client_name(source_p, SHOW_IP)); |
357 |
> |
client_get_name(client, SHOW_IP)); |
358 |
|
++ServerStats.is_ref; |
359 |
< |
exit_client(source_p, "No more connections allowed on that IP"); |
359 |
> |
exit_client(client, "No more connections allowed on that IP"); |
360 |
|
break; |
361 |
|
|
362 |
|
case I_LINE_FULL: |
363 |
< |
sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE, |
363 |
> |
sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE, |
364 |
|
"auth {} block is full for %s (%s).", |
365 |
< |
get_client_name(source_p, SHOW_IP), |
366 |
< |
source_p->sockhost); |
365 |
> |
client_get_name(client, SHOW_IP), |
366 |
> |
client->sockhost); |
367 |
|
ilog(LOG_TYPE_IRCD, "Too many connections from %s.", |
368 |
< |
get_client_name(source_p, SHOW_IP)); |
368 |
> |
client_get_name(client, SHOW_IP)); |
369 |
|
++ServerStats.is_ref; |
370 |
< |
exit_client(source_p, "No more connections allowed in your connection class"); |
370 |
> |
exit_client(client, "No more connections allowed in your connection class"); |
371 |
|
break; |
372 |
|
|
373 |
|
case NOT_AUTHORIZED: |
374 |
< |
/* jdc - lists server name & port connections are on */ |
375 |
< |
/* a purely cosmetical change */ |
376 |
< |
sendto_realops_flags(UMODE_UNAUTH, L_ALL, SEND_NOTICE, |
377 |
< |
"Unauthorized client connection from %s on [%s/%u].", |
378 |
< |
get_client_name(source_p, SHOW_IP), |
368 |
< |
source_p->connection->listener->name, |
369 |
< |
source_p->connection->listener->port); |
370 |
< |
ilog(LOG_TYPE_IRCD, "Unauthorized client connection from %s on [%s/%u].", |
371 |
< |
get_client_name(source_p, SHOW_IP), |
372 |
< |
source_p->connection->listener->name, |
373 |
< |
source_p->connection->listener->port); |
374 |
< |
|
374 |
> |
sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE, |
375 |
> |
"Unauthorized client connection from %s.", |
376 |
> |
client_get_name(client, SHOW_IP)); |
377 |
> |
ilog(LOG_TYPE_IRCD, "Unauthorized client connection from %s.", |
378 |
> |
client_get_name(client, SHOW_IP)); |
379 |
|
++ServerStats.is_ref; |
380 |
< |
exit_client(source_p, "You are not authorized to use this server"); |
380 |
> |
exit_client(client, "You are not authorized to use this server"); |
381 |
|
break; |
382 |
|
|
383 |
|
case BANNED_CLIENT: |
384 |
|
++ServerStats.is_ref; |
385 |
< |
exit_client(source_p, "Banned"); |
385 |
> |
exit_client(client, "Banned"); |
386 |
|
break; |
387 |
|
|
388 |
|
case 0: |
390 |
|
break; |
391 |
|
} |
392 |
|
|
393 |
< |
return !(i < 0); |
393 |
> |
if (i < 0) |
394 |
> |
return false; |
395 |
> |
return true; |
396 |
|
} |
397 |
|
|
398 |
< |
/* detach_conf() |
399 |
< |
* |
400 |
< |
* inputs - pointer to client to detach |
401 |
< |
* - type of conf to detach |
396 |
< |
* output - 0 for success, -1 for failure |
397 |
< |
* side effects - Disassociate configuration from the client. |
398 |
< |
* Also removes a class from the list if marked for deleting. |
398 |
> |
/*! \brief Disassociate configuration from the client. Also removes a class |
399 |
> |
* from the list if marked for deleting. |
400 |
> |
* \param client Client to operate on |
401 |
> |
* \param type Type of conf to detach |
402 |
|
*/ |
403 |
|
void |
404 |
< |
detach_conf(struct Client *client_p, enum maskitem_type type) |
404 |
> |
conf_detach(struct Client *client, enum maskitem_type type) |
405 |
|
{ |
406 |
< |
dlink_node *node = NULL, *node_next = NULL; |
406 |
> |
dlink_node *node, *node_next; |
407 |
|
|
408 |
< |
DLINK_FOREACH_SAFE(node, node_next, client_p->connection->confs.head) |
408 |
> |
DLINK_FOREACH_SAFE(node, node_next, client->connection->confs.head) |
409 |
|
{ |
410 |
|
struct MaskItem *conf = node->data; |
411 |
|
|
416 |
|
if (!(conf->type & type)) |
417 |
|
continue; |
418 |
|
|
419 |
< |
dlinkDelete(node, &client_p->connection->confs); |
419 |
> |
dlinkDelete(node, &client->connection->confs); |
420 |
|
free_dlink_node(node); |
421 |
|
|
422 |
|
if (conf->type == CONF_CLIENT) |
423 |
< |
remove_from_cidr_check(&client_p->connection->ip, conf->class); |
423 |
> |
class_ip_limit_remove(conf->class, &client->ip); |
424 |
|
|
425 |
< |
if (--conf->class->ref_count == 0 && conf->class->active == 0) |
425 |
> |
if (--conf->class->ref_count == 0 && conf->class->active == false) |
426 |
|
{ |
427 |
|
class_free(conf->class); |
428 |
|
conf->class = NULL; |
429 |
|
} |
430 |
|
|
431 |
< |
if (--conf->ref_count == 0 && conf->active == 0) |
431 |
> |
if (--conf->ref_count == 0 && conf->active == false) |
432 |
|
conf_free(conf); |
433 |
|
} |
434 |
|
} |
435 |
|
|
436 |
< |
/* attach_conf() |
437 |
< |
* |
438 |
< |
* inputs - client pointer |
439 |
< |
* - conf pointer |
440 |
< |
* output - |
438 |
< |
* side effects - Associate a specific configuration entry to a *local* |
439 |
< |
* client (this is the one which used in accepting the |
440 |
< |
* connection). Note, that this automatically changes the |
441 |
< |
* attachment if there was an old one... |
436 |
> |
/*! \brief Associate a specific configuration entry to a *local* client (this |
437 |
> |
* is the one which used in accepting the connection). Note, that this |
438 |
> |
* automatically changes the attachment if there was an old one. |
439 |
> |
* \param client Client to attach the conf to |
440 |
> |
* \param conf Configuration record to attach |
441 |
|
*/ |
442 |
|
int |
443 |
< |
attach_conf(struct Client *client_p, struct MaskItem *conf) |
443 |
> |
conf_attach(struct Client *client, struct MaskItem *conf) |
444 |
|
{ |
445 |
< |
if (dlinkFind(&client_p->connection->confs, conf)) |
445 |
> |
if (dlinkFind(&client->connection->confs, conf)) |
446 |
|
return 1; |
447 |
|
|
448 |
|
if (conf->type == CONF_CLIENT) |
449 |
< |
if (cidr_limit_reached(IsConfExemptLimits(conf), |
451 |
< |
&client_p->connection->ip, conf->class)) |
449 |
> |
if (class_ip_limit_add(conf->class, &client->ip, IsConfExemptLimits(conf)) == true) |
450 |
|
return TOO_MANY; /* Already at maximum allowed */ |
451 |
|
|
452 |
|
conf->class->ref_count++; |
453 |
|
conf->ref_count++; |
454 |
|
|
455 |
< |
dlinkAdd(conf, make_dlink_node(), &client_p->connection->confs); |
458 |
< |
|
459 |
< |
return 0; |
460 |
< |
} |
461 |
< |
|
462 |
< |
/* attach_connect_block() |
463 |
< |
* |
464 |
< |
* inputs - pointer to server to attach |
465 |
< |
* - name of server |
466 |
< |
* - hostname of server |
467 |
< |
* output - true (1) if both are found, otherwise return false (0) |
468 |
< |
* side effects - find connect block and attach them to connecting client |
469 |
< |
*/ |
470 |
< |
int |
471 |
< |
attach_connect_block(struct Client *client_p, const char *name, |
472 |
< |
const char *host) |
473 |
< |
{ |
474 |
< |
dlink_node *node = NULL; |
475 |
< |
|
476 |
< |
assert(host); |
477 |
< |
|
478 |
< |
DLINK_FOREACH(node, connect_items.head) |
479 |
< |
{ |
480 |
< |
struct MaskItem *conf = node->data; |
481 |
< |
|
482 |
< |
if (irccmp(conf->name, name) || |
483 |
< |
irccmp(conf->host, host)) |
484 |
< |
continue; |
485 |
< |
|
486 |
< |
attach_conf(client_p, conf); |
487 |
< |
return 1; |
488 |
< |
} |
455 |
> |
dlinkAdd(conf, make_dlink_node(), &client->connection->confs); |
456 |
|
|
457 |
|
return 0; |
458 |
|
} |
485 |
|
return NULL; |
486 |
|
} |
487 |
|
|
488 |
< |
/* find_matching_name_conf() |
489 |
< |
* |
490 |
< |
* inputs - type of link list to look in |
524 |
< |
* - pointer to name string to find |
525 |
< |
* - pointer to user |
526 |
< |
* - pointer to host |
527 |
< |
* - optional flags to match on as well |
528 |
< |
* output - NULL or pointer to found struct MaskItem |
529 |
< |
* side effects - looks for a match on name field |
488 |
> |
/*! \brief Find a connect {} conf that has a name that matches \a name. |
489 |
> |
* \param name Name to match |
490 |
> |
* \param compare Pointer to function to be used for string matching |
491 |
|
*/ |
492 |
|
struct MaskItem * |
493 |
< |
connect_find(const char *name, const char *host, int (*compare)(const char *, const char *)) |
493 |
> |
connect_find(const char *name, int (*compare)(const char *, const char *)) |
494 |
|
{ |
495 |
< |
dlink_node *node = NULL; |
495 |
> |
dlink_node *node; |
496 |
|
|
497 |
|
DLINK_FOREACH(node, connect_items.head) |
498 |
|
{ |
499 |
|
struct MaskItem *conf = node->data; |
500 |
|
|
501 |
< |
if (name && !compare(name, conf->name)) |
541 |
< |
return conf; |
542 |
< |
if (host && !compare(host, conf->host)) |
501 |
> |
if (compare(name, conf->name) == 0) |
502 |
|
return conf; |
503 |
|
} |
504 |
|
|
515 |
|
* side effects - looks for an exact match on name field |
516 |
|
*/ |
517 |
|
struct MaskItem * |
518 |
< |
operator_find(const struct Client *who, const char *name) |
518 |
> |
operator_find(const struct Client *client, const char *name) |
519 |
|
{ |
520 |
< |
dlink_node *node = NULL; |
520 |
> |
dlink_node *node; |
521 |
|
|
522 |
|
DLINK_FOREACH(node, operator_items.head) |
523 |
|
{ |
524 |
|
struct MaskItem *conf = node->data; |
525 |
|
|
526 |
< |
if (!irccmp(conf->name, name)) |
526 |
> |
if (irccmp(conf->name, name) == 0) |
527 |
|
{ |
528 |
< |
if (!who) |
528 |
> |
if (client == NULL) |
529 |
|
return conf; |
530 |
|
|
531 |
< |
if (!match(conf->user, who->username)) |
531 |
> |
if (conf->class->max_total && |
532 |
> |
conf->class->max_total <= conf->class->ref_count) |
533 |
> |
continue; |
534 |
> |
|
535 |
> |
if (match(conf->user, client->username) == 0) |
536 |
|
{ |
537 |
|
switch (conf->htype) |
538 |
|
{ |
539 |
|
case HM_HOST: |
540 |
< |
if (!match(conf->host, who->host) || !match(conf->host, who->sockhost)) |
541 |
< |
if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total) |
542 |
< |
return conf; |
580 |
< |
break; |
581 |
< |
case HM_IPV4: |
582 |
< |
if (who->connection->aftype == AF_INET) |
583 |
< |
if (match_ipv4(&who->connection->ip, &conf->addr, conf->bits)) |
584 |
< |
if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total) |
585 |
< |
return conf; |
540 |
> |
if (match(conf->host, client->realhost) == 0 || |
541 |
> |
match(conf->host, client->sockhost) == 0 || match(conf->host, client->host) == 0) |
542 |
> |
return conf; |
543 |
|
break; |
544 |
|
case HM_IPV6: |
545 |
< |
if (who->connection->aftype == AF_INET6) |
546 |
< |
if (match_ipv6(&who->connection->ip, &conf->addr, conf->bits)) |
547 |
< |
if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total) |
591 |
< |
return conf; |
545 |
> |
case HM_IPV4: |
546 |
> |
if (address_compare(&client->ip, conf->addr, false, false, conf->bits) == true) |
547 |
> |
return conf; |
548 |
|
break; |
549 |
|
default: |
550 |
|
assert(0); |
556 |
|
return NULL; |
557 |
|
} |
558 |
|
|
559 |
< |
/* set_default_conf() |
559 |
> |
/* conf_set_defaults() |
560 |
|
* |
561 |
|
* inputs - NONE |
562 |
|
* output - NONE |
566 |
|
* of values later, put them in validate_conf(). |
567 |
|
*/ |
568 |
|
static void |
569 |
< |
set_default_conf(void) |
569 |
> |
conf_set_defaults(void) |
570 |
|
{ |
571 |
< |
/* verify init_class() ran, this should be an unnecessary check |
572 |
< |
* but its not much work. |
571 |
> |
/* |
572 |
> |
* Verify init_class() ran, this should be an unnecessary check |
573 |
> |
* but it's not much work. |
574 |
|
*/ |
575 |
|
assert(class_default == class_get_list()->tail->data); |
576 |
|
|
577 |
|
ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT); |
578 |
|
ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT); |
622 |
– |
|
623 |
– |
memset(&ConfigServerInfo.ip, 0, sizeof(ConfigServerInfo.ip)); |
624 |
– |
ConfigServerInfo.specific_ipv4_vhost = 0; |
625 |
– |
memset(&ConfigServerInfo.ip6, 0, sizeof(ConfigServerInfo.ip6)); |
626 |
– |
ConfigServerInfo.specific_ipv6_vhost = 0; |
627 |
– |
|
579 |
|
ConfigServerInfo.default_max_clients = MAXCLIENTS_MAX; |
580 |
|
ConfigServerInfo.max_nick_length = 9; |
581 |
|
ConfigServerInfo.max_topic_length = 80; |
582 |
|
ConfigServerInfo.hub = 0; |
632 |
– |
ConfigServerInfo.libgeoip_database_options = 0; |
583 |
|
|
584 |
< |
log_del_all(); |
584 |
> |
log_iterate(log_free); |
585 |
|
|
586 |
|
ConfigLog.use_logging = 1; |
587 |
|
|
588 |
+ |
ConfigChannel.enable_extbans = 0; |
589 |
|
ConfigChannel.disable_fake_channels = 0; |
590 |
|
ConfigChannel.invite_client_count = 10; |
591 |
|
ConfigChannel.invite_client_time = 300; |
596 |
|
ConfigChannel.knock_delay_channel = 60; |
597 |
|
ConfigChannel.max_channels = 25; |
598 |
|
ConfigChannel.max_invites = 20; |
599 |
< |
ConfigChannel.max_bans = 25; |
599 |
> |
ConfigChannel.max_bans = 100; |
600 |
> |
ConfigChannel.max_bans_large = 500; |
601 |
|
ConfigChannel.default_join_flood_count = 18; |
602 |
|
ConfigChannel.default_join_flood_time = 6; |
603 |
|
|
620 |
|
ConfigGeneral.kline_min_cidr = 16; |
621 |
|
ConfigGeneral.kline_min_cidr6 = 48; |
622 |
|
ConfigGeneral.invisible_on_connect = 1; |
671 |
– |
ConfigGeneral.tkline_expire_notices = 1; |
672 |
– |
ConfigGeneral.ignore_bogus_ts = 0; |
623 |
|
ConfigGeneral.disable_auth = 0; |
624 |
|
ConfigGeneral.kill_chase_time_limit = 90; |
625 |
|
ConfigGeneral.default_floodcount = 8; |
644 |
|
ConfigGeneral.stats_P_oper_only = 0; |
645 |
|
ConfigGeneral.stats_u_oper_only = 0; |
646 |
|
ConfigGeneral.caller_id_wait = 60; |
647 |
< |
ConfigGeneral.opers_bypass_callerid = 0; |
647 |
> |
ConfigGeneral.opers_bypass_callerid = 1; |
648 |
|
ConfigGeneral.pace_wait = 10; |
649 |
|
ConfigGeneral.pace_wait_simple = 1; |
650 |
|
ConfigGeneral.short_motd = 0; |
652 |
|
ConfigGeneral.no_oper_flood = 0; |
653 |
|
ConfigGeneral.max_targets = MAX_TARGETS_DEFAULT; |
654 |
|
ConfigGeneral.oper_only_umodes = UMODE_DEBUG | UMODE_LOCOPS | UMODE_HIDDEN | UMODE_FARCONNECT | |
655 |
< |
UMODE_UNAUTH | UMODE_EXTERNAL | UMODE_BOTS | UMODE_NCHANGE | |
656 |
< |
UMODE_SPY | UMODE_FULL | UMODE_SKILL | UMODE_REJ | UMODE_CCONN; |
657 |
< |
ConfigGeneral.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE | UMODE_WALLOP; |
655 |
> |
UMODE_EXTERNAL | UMODE_FLOOD | UMODE_NCHANGE | |
656 |
> |
UMODE_SPY | UMODE_SKILL | UMODE_REJ | UMODE_CCONN; |
657 |
> |
ConfigGeneral.oper_umodes = UMODE_FLOOD | UMODE_LOCOPS | UMODE_SERVNOTICE | UMODE_WALLOP; |
658 |
|
ConfigGeneral.throttle_count = 1; |
659 |
|
ConfigGeneral.throttle_time = 1; |
660 |
|
} |
661 |
|
|
662 |
|
static void |
663 |
< |
validate_conf(void) |
663 |
> |
conf_validate(void) |
664 |
|
{ |
665 |
|
if (EmptyString(ConfigServerInfo.network_name)) |
666 |
|
ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT); |
669 |
|
ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT); |
670 |
|
} |
671 |
|
|
672 |
< |
/* read_conf() |
672 |
> |
/* conf_read() |
673 |
|
* |
674 |
|
* inputs - file descriptor pointing to config file to use |
675 |
|
* output - None |
676 |
|
* side effects - Read configuration file. |
677 |
|
*/ |
678 |
|
static void |
679 |
< |
read_conf(FILE *file) |
679 |
> |
conf_read(FILE *file) |
680 |
|
{ |
681 |
|
lineno = 1; |
682 |
|
|
683 |
< |
set_default_conf(); /* Set default values prior to conf parsing */ |
683 |
> |
conf_set_defaults(); /* Set default values prior to conf parsing */ |
684 |
|
conf_parser_ctx.pass = 1; |
685 |
|
yyparse(); /* Pick up the classes first */ |
686 |
|
|
688 |
|
|
689 |
|
conf_parser_ctx.pass = 2; |
690 |
|
yyparse(); /* Load the values from the conf */ |
691 |
< |
validate_conf(); /* Check to make sure some values are still okay. */ |
691 |
> |
conf_validate(); /* Check to make sure some values are still okay. */ |
692 |
|
/* Some global values are also loaded here. */ |
693 |
|
whowas_trim(); /* Attempt to trim whowas list if necessary */ |
694 |
|
class_delete_marked(); /* Delete unused classes that are marked for deletion */ |
701 |
|
* called as a result of the server receiving a HUP signal. |
702 |
|
*/ |
703 |
|
void |
704 |
< |
conf_rehash(int sig) |
704 |
> |
conf_rehash(bool sig) |
705 |
|
{ |
706 |
< |
if (sig) |
706 |
> |
if (sig == true) |
707 |
|
{ |
708 |
|
sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE, |
709 |
|
"Got signal SIGHUP, reloading configuration file(s)"); |
714 |
|
|
715 |
|
/* don't close listeners until we know we can go ahead with the rehash */ |
716 |
|
|
717 |
< |
read_conf_files(0); |
717 |
> |
conf_read_files(false); |
718 |
|
|
719 |
|
load_conf_modules(); |
720 |
|
check_conf_klines(); |
721 |
|
} |
722 |
|
|
773 |
– |
/* lookup_confhost() |
774 |
– |
* |
775 |
– |
* start DNS lookups of all hostnames in the conf |
776 |
– |
* line and convert an IP addresses in a.b.c.d number for to IP#s. |
777 |
– |
*/ |
778 |
– |
void |
779 |
– |
lookup_confhost(struct MaskItem *conf) |
780 |
– |
{ |
781 |
– |
struct addrinfo hints, *res; |
782 |
– |
|
783 |
– |
/* |
784 |
– |
* Do name lookup now on hostnames given and store the |
785 |
– |
* ip numbers in conf structure. |
786 |
– |
*/ |
787 |
– |
memset(&hints, 0, sizeof(hints)); |
788 |
– |
|
789 |
– |
hints.ai_family = AF_UNSPEC; |
790 |
– |
hints.ai_socktype = SOCK_STREAM; |
791 |
– |
|
792 |
– |
/* Get us ready for a bind() and don't bother doing dns lookup */ |
793 |
– |
hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST; |
794 |
– |
|
795 |
– |
if (getaddrinfo(conf->host, NULL, &hints, &res)) |
796 |
– |
{ |
797 |
– |
conf_dns_lookup(conf); |
798 |
– |
return; |
799 |
– |
} |
800 |
– |
|
801 |
– |
assert(res); |
802 |
– |
|
803 |
– |
memcpy(&conf->addr, res->ai_addr, res->ai_addrlen); |
804 |
– |
conf->addr.ss_len = res->ai_addrlen; |
805 |
– |
conf->addr.ss.ss_family = res->ai_family; |
806 |
– |
|
807 |
– |
freeaddrinfo(res); |
808 |
– |
} |
809 |
– |
|
723 |
|
/* conf_connect_allowed() |
724 |
|
* |
725 |
|
* inputs - pointer to inaddr |
728 |
|
* side effects - none |
729 |
|
*/ |
730 |
|
int |
731 |
< |
conf_connect_allowed(struct irc_ssaddr *addr, int aftype) |
731 |
> |
conf_connect_allowed(struct irc_ssaddr *addr) |
732 |
|
{ |
733 |
< |
struct ip_entry *ip_found = NULL; |
821 |
< |
const struct MaskItem *conf = find_dline_conf(addr, aftype); |
733 |
> |
const struct MaskItem *conf = find_dline_conf(addr); |
734 |
|
|
735 |
|
if (conf) |
736 |
|
{ |
740 |
|
return BANNED_CLIENT; |
741 |
|
} |
742 |
|
|
743 |
< |
ip_found = ipcache_find_or_add_address(addr); |
744 |
< |
|
833 |
< |
if ((CurrentTime - ip_found->last_attempt) < ConfigGeneral.throttle_time) |
743 |
> |
struct ip_entry *ip_found = ipcache_record_find_or_add(addr); |
744 |
> |
if ((event_base->time.sec_monotonic - ip_found->last_attempt) < ConfigGeneral.throttle_time) |
745 |
|
{ |
746 |
|
if (ip_found->connection_count >= ConfigGeneral.throttle_count) |
747 |
|
return TOO_FAST; |
751 |
|
else |
752 |
|
ip_found->connection_count = 1; |
753 |
|
|
754 |
< |
ip_found->last_attempt = CurrentTime; |
754 |
> |
ip_found->last_attempt = event_base->time.sec_monotonic; |
755 |
|
return 0; |
756 |
|
} |
757 |
|
|
770 |
|
resv_expire(); |
771 |
|
} |
772 |
|
|
862 |
– |
/* oper_privs_as_string() |
863 |
– |
* |
864 |
– |
* inputs - pointer to client_p |
865 |
– |
* output - pointer to static string showing oper privs |
866 |
– |
* side effects - return as string, the oper privs as derived from port |
867 |
– |
*/ |
868 |
– |
static const struct oper_flags |
869 |
– |
{ |
870 |
– |
const unsigned int flag; |
871 |
– |
const unsigned char c; |
872 |
– |
} flag_table[] = { |
873 |
– |
{ OPER_FLAG_ADMIN, 'A' }, |
874 |
– |
{ OPER_FLAG_CLOSE, 'B' }, |
875 |
– |
{ OPER_FLAG_CONNECT, 'C' }, |
876 |
– |
{ OPER_FLAG_CONNECT_REMOTE, 'D' }, |
877 |
– |
{ OPER_FLAG_DIE, 'E' }, |
878 |
– |
{ OPER_FLAG_DLINE, 'F' }, |
879 |
– |
{ OPER_FLAG_GLOBOPS, 'G' }, |
880 |
– |
{ OPER_FLAG_JOIN_RESV, 'H' }, |
881 |
– |
{ OPER_FLAG_KILL, 'I' }, |
882 |
– |
{ OPER_FLAG_KILL_REMOTE, 'J' }, |
883 |
– |
{ OPER_FLAG_KLINE, 'K' }, |
884 |
– |
{ OPER_FLAG_LOCOPS, 'L' }, |
885 |
– |
{ OPER_FLAG_MODULE, 'M' }, |
886 |
– |
{ OPER_FLAG_NICK_RESV, 'N' }, |
887 |
– |
{ OPER_FLAG_OPME, 'O' }, |
888 |
– |
{ OPER_FLAG_REHASH, 'P' }, |
889 |
– |
{ OPER_FLAG_REMOTEBAN, 'Q' }, |
890 |
– |
{ OPER_FLAG_RESTART, 'R' }, |
891 |
– |
{ OPER_FLAG_RESV, 'S' }, |
892 |
– |
{ OPER_FLAG_SET, 'T' }, |
893 |
– |
{ OPER_FLAG_SQUIT, 'U' }, |
894 |
– |
{ OPER_FLAG_SQUIT_REMOTE, 'V' }, |
895 |
– |
{ OPER_FLAG_UNDLINE, 'W' }, |
896 |
– |
{ OPER_FLAG_UNKLINE, 'X' }, |
897 |
– |
{ OPER_FLAG_UNRESV, 'Y' }, |
898 |
– |
{ OPER_FLAG_UNXLINE, 'Z' }, |
899 |
– |
{ OPER_FLAG_WALLOPS, 'a' }, |
900 |
– |
{ OPER_FLAG_XLINE, 'b' }, |
901 |
– |
{ 0, '\0' } |
902 |
– |
}; |
903 |
– |
|
904 |
– |
const char * |
905 |
– |
oper_privs_as_string(const unsigned int flags) |
906 |
– |
{ |
907 |
– |
static char buf[sizeof(flag_table) / sizeof(struct oper_flags)]; |
908 |
– |
char *p = buf; |
909 |
– |
|
910 |
– |
for (const struct oper_flags *tab = flag_table; tab->flag; ++tab) |
911 |
– |
if (flags & tab->flag) |
912 |
– |
*p++ = tab->c; |
913 |
– |
|
914 |
– |
if (p == buf) |
915 |
– |
*p++ = '0'; |
916 |
– |
|
917 |
– |
*p = '\0'; |
918 |
– |
|
919 |
– |
return buf; |
920 |
– |
} |
921 |
– |
|
773 |
|
/* |
774 |
|
* Input: A client to find the active operator {} name for. |
775 |
|
* Output: The nick!user@host{oper} of the oper. |
777 |
|
* Side effects: None. |
778 |
|
*/ |
779 |
|
const char * |
780 |
< |
get_oper_name(const struct Client *client_p) |
780 |
> |
get_oper_name(const struct Client *client) |
781 |
|
{ |
782 |
|
static char buffer[IRCD_BUFSIZE]; |
783 |
|
|
784 |
< |
if (IsServer(client_p)) |
785 |
< |
return client_p->name; |
784 |
> |
if (IsServer(client)) |
785 |
> |
return client->name; |
786 |
|
|
787 |
< |
if (MyConnect(client_p)) |
787 |
> |
if (MyConnect(client)) |
788 |
|
{ |
789 |
< |
const dlink_node *const node = client_p->connection->confs.head; |
789 |
> |
const dlink_node *const node = client->connection->confs.head; |
790 |
|
|
791 |
|
if (node) |
792 |
|
{ |
794 |
|
|
795 |
|
if (conf->type == CONF_OPER) |
796 |
|
{ |
797 |
< |
snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name, |
798 |
< |
client_p->username, client_p->host, conf->name); |
797 |
> |
snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client->name, |
798 |
> |
client->username, client->host, conf->name); |
799 |
|
return buffer; |
800 |
|
} |
801 |
|
} |
807 |
|
assert(0); /* Oper without oper conf! */ |
808 |
|
} |
809 |
|
|
810 |
< |
snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name, |
811 |
< |
client_p->username, client_p->host, client_p->servptr->name); |
810 |
> |
snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client->name, |
811 |
> |
client->username, client->host, client->servptr->name); |
812 |
|
return buffer; |
813 |
|
} |
814 |
|
|
815 |
< |
/* clear_out_old_conf() |
815 |
> |
/* conf_clear() |
816 |
|
* |
817 |
|
* inputs - none |
818 |
|
* output - none |
819 |
|
* side effects - Clear out the old configuration |
820 |
|
*/ |
821 |
|
static void |
822 |
< |
clear_out_old_conf(void) |
822 |
> |
conf_clear(void) |
823 |
|
{ |
824 |
|
dlink_node *node = NULL, *node_next = NULL; |
825 |
|
dlink_list *free_items [] = { |
829 |
|
dlink_list ** iterator = free_items; /* C is dumb */ |
830 |
|
|
831 |
|
/* We only need to free anything allocated by yyparse() here. |
832 |
< |
* Resetting structs, etc, is taken care of by set_default_conf(). |
832 |
> |
* Resetting structs, etc, is taken care of by conf_set_defaults(). |
833 |
|
*/ |
834 |
|
|
835 |
|
for (; *iterator; iterator++) |
838 |
|
{ |
839 |
|
struct MaskItem *conf = node->data; |
840 |
|
|
841 |
< |
conf->active = 0; |
841 |
> |
conf->active = false; |
842 |
|
dlinkDelete(&conf->node, *iterator); |
843 |
|
|
844 |
|
if (!conf->ref_count) |
870 |
|
|
871 |
|
pseudo_clear(); /* Clear pseudo {} items */ |
872 |
|
|
1022 |
– |
#ifdef HAVE_LIBGEOIP |
1023 |
– |
GeoIP_delete(GeoIPv4_ctx); |
1024 |
– |
GeoIPv4_ctx = NULL; |
1025 |
– |
GeoIP_delete(GeoIPv6_ctx); |
1026 |
– |
GeoIPv6_ctx = NULL; |
1027 |
– |
#endif |
1028 |
– |
|
873 |
|
/* Clean out ConfigServerInfo */ |
874 |
|
xfree(ConfigServerInfo.description); |
875 |
|
ConfigServerInfo.description = NULL; |
877 |
|
ConfigServerInfo.network_name = NULL; |
878 |
|
xfree(ConfigServerInfo.network_desc); |
879 |
|
ConfigServerInfo.network_desc = NULL; |
1036 |
– |
xfree(ConfigServerInfo.libgeoip_ipv6_database_file); |
1037 |
– |
ConfigServerInfo.libgeoip_ipv6_database_file = NULL; |
1038 |
– |
xfree(ConfigServerInfo.libgeoip_ipv4_database_file); |
1039 |
– |
ConfigServerInfo.libgeoip_ipv4_database_file = NULL; |
880 |
|
xfree(ConfigServerInfo.rsa_private_key_file); |
881 |
|
ConfigServerInfo.rsa_private_key_file = NULL; |
882 |
< |
xfree(ConfigServerInfo.ssl_certificate_file); |
883 |
< |
ConfigServerInfo.ssl_certificate_file = NULL; |
884 |
< |
xfree(ConfigServerInfo.ssl_dh_param_file); |
885 |
< |
ConfigServerInfo.ssl_dh_param_file = NULL; |
886 |
< |
xfree(ConfigServerInfo.ssl_dh_elliptic_curve); |
887 |
< |
ConfigServerInfo.ssl_dh_elliptic_curve = NULL; |
888 |
< |
xfree(ConfigServerInfo.ssl_cipher_list); |
889 |
< |
ConfigServerInfo.ssl_cipher_list = NULL; |
890 |
< |
xfree(ConfigServerInfo.ssl_message_digest_algorithm); |
891 |
< |
ConfigServerInfo.ssl_message_digest_algorithm = NULL; |
882 |
> |
xfree(ConfigServerInfo.tls_certificate_file); |
883 |
> |
ConfigServerInfo.tls_certificate_file = NULL; |
884 |
> |
xfree(ConfigServerInfo.tls_dh_param_file); |
885 |
> |
ConfigServerInfo.tls_dh_param_file = NULL; |
886 |
> |
xfree(ConfigServerInfo.tls_supported_groups); |
887 |
> |
ConfigServerInfo.tls_supported_groups = NULL; |
888 |
> |
xfree(ConfigServerInfo.tls_cipher_list); |
889 |
> |
ConfigServerInfo.tls_cipher_list = NULL; |
890 |
> |
xfree(ConfigServerInfo.tls_cipher_suites); |
891 |
> |
ConfigServerInfo.tls_cipher_suites = NULL; |
892 |
> |
xfree(ConfigServerInfo.tls_message_digest_algorithm); |
893 |
> |
ConfigServerInfo.tls_message_digest_algorithm = NULL; |
894 |
|
|
895 |
|
/* Clean out ConfigAdminInfo */ |
896 |
|
xfree(ConfigAdminInfo.name); |
900 |
|
xfree(ConfigAdminInfo.description); |
901 |
|
ConfigAdminInfo.description = NULL; |
902 |
|
|
903 |
+ |
/* Clean out ConfigServerHide */ |
904 |
|
xfree(ConfigServerHide.flatten_links_file); |
905 |
|
ConfigServerHide.flatten_links_file = NULL; |
906 |
+ |
xfree(ConfigServerHide.hidden_name); |
907 |
+ |
ConfigServerHide.hidden_name = NULL; |
908 |
|
|
909 |
|
/* Clean out listeners */ |
910 |
|
listener_close_marked(); |
911 |
|
} |
912 |
|
|
913 |
|
static void |
914 |
< |
conf_handle_tls(int cold) |
914 |
> |
conf_handle_tls(bool cold) |
915 |
|
{ |
916 |
< |
if (!tls_new_cred()) |
916 |
> |
if (tls_new_credentials() == false) |
917 |
|
{ |
918 |
< |
if (cold) |
918 |
> |
if (cold == true) |
919 |
|
{ |
920 |
|
ilog(LOG_TYPE_IRCD, "Error while initializing TLS"); |
921 |
|
exit(EXIT_FAILURE); |
936 |
|
* side effects - read all conf files needed, ircd.conf kline.conf etc. |
937 |
|
*/ |
938 |
|
void |
939 |
< |
read_conf_files(int cold) |
939 |
> |
conf_read_files(bool cold) |
940 |
|
{ |
941 |
< |
const char *filename = NULL; |
1097 |
< |
char chanmodes[IRCD_BUFSIZE] = ""; |
1098 |
< |
char chanlimit[IRCD_BUFSIZE] = ""; |
941 |
> |
char buf[IRCD_BUFSIZE]; |
942 |
|
|
943 |
|
conf_parser_ctx.boot = cold; |
944 |
< |
filename = ConfigGeneral.configfile; |
944 |
> |
conf_parser_ctx.conf_file = fopen(ConfigGeneral.configfile, "r"); |
945 |
|
|
946 |
< |
/* We need to know the initial filename for the yyerror() to report |
1104 |
< |
FIXME: The full path is in conffilenamebuf first time since we |
1105 |
< |
don't know anything else |
1106 |
< |
|
1107 |
< |
- Gozem 2002-07-21 |
1108 |
< |
*/ |
1109 |
< |
strlcpy(conffilebuf, filename, sizeof(conffilebuf)); |
1110 |
< |
|
1111 |
< |
if ((conf_parser_ctx.conf_file = fopen(filename, "r")) == NULL) |
946 |
> |
if (conf_parser_ctx.conf_file == NULL) |
947 |
|
{ |
948 |
< |
if (cold) |
948 |
> |
if (cold == true) |
949 |
|
{ |
950 |
|
ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s", |
951 |
< |
filename, strerror(errno)); |
951 |
> |
ConfigGeneral.configfile, strerror(errno)); |
952 |
|
exit(EXIT_FAILURE); |
953 |
|
} |
954 |
|
else |
955 |
|
{ |
956 |
|
sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE, |
957 |
|
"Unable to read configuration file '%s': %s", |
958 |
< |
filename, strerror(errno)); |
958 |
> |
ConfigGeneral.configfile, strerror(errno)); |
959 |
|
return; |
960 |
|
} |
961 |
|
} |
962 |
|
|
963 |
< |
if (!cold) |
964 |
< |
clear_out_old_conf(); |
963 |
> |
/* |
964 |
> |
* We need to know the initial filename for the yyerror() to report |
965 |
> |
* |
966 |
> |
* FIXME: The full path is in conffilenamebuf first time since we |
967 |
> |
* don't know anything else |
968 |
> |
* |
969 |
> |
* - Gozem 2002-07-21 |
970 |
> |
*/ |
971 |
> |
strlcpy(conffilebuf, ConfigGeneral.configfile, sizeof(conffilebuf)); |
972 |
> |
|
973 |
> |
if (cold == false) |
974 |
> |
conf_clear(); |
975 |
|
|
976 |
< |
read_conf(conf_parser_ctx.conf_file); |
976 |
> |
conf_read(conf_parser_ctx.conf_file); |
977 |
|
fclose(conf_parser_ctx.conf_file); |
978 |
|
|
979 |
< |
log_reopen_all(); |
979 |
> |
log_iterate(log_reopen); |
980 |
|
conf_handle_tls(cold); |
981 |
|
|
982 |
|
isupport_add("NICKLEN", NULL, ConfigServerInfo.max_nick_length); |
983 |
|
isupport_add("NETWORK", ConfigServerInfo.network_name, -1); |
984 |
|
|
985 |
< |
snprintf(chanmodes, sizeof(chanmodes), "beI:%u", ConfigChannel.max_bans); |
986 |
< |
isupport_add("MAXLIST", chanmodes, -1); |
985 |
> |
snprintf(buf, sizeof(buf), "beI:%u", ConfigChannel.max_bans); |
986 |
> |
isupport_add("MAXLIST", buf, -1); |
987 |
> |
|
988 |
|
isupport_add("MAXTARGETS", NULL, ConfigGeneral.max_targets); |
989 |
|
isupport_add("CHANTYPES", "#", -1); |
990 |
|
|
991 |
< |
snprintf(chanlimit, sizeof(chanlimit), "#:%u", |
992 |
< |
ConfigChannel.max_channels); |
993 |
< |
isupport_add("CHANLIMIT", chanlimit, -1); |
1148 |
< |
snprintf(chanmodes, sizeof(chanmodes), "%s", "beI,k,l,cimnprstCMORST"); |
991 |
> |
snprintf(buf, sizeof(buf), "#:%u", ConfigChannel.max_channels); |
992 |
> |
isupport_add("CHANLIMIT", buf, -1); |
993 |
> |
|
994 |
|
isupport_add("CHANNELLEN", NULL, CHANNELLEN); |
995 |
|
isupport_add("TOPICLEN", NULL, ConfigServerInfo.max_topic_length); |
996 |
< |
isupport_add("CHANMODES", chanmodes, -1); |
996 |
> |
|
997 |
> |
snprintf(buf, sizeof(buf), "%s", "beI,k,l,cimnprstuCKLMNORST"); |
998 |
> |
isupport_add("CHANMODES", buf, -1); |
999 |
|
} |
1000 |
|
|
1001 |
|
/* conf_add_class_to_conf() |
1007 |
|
void |
1008 |
|
conf_add_class_to_conf(struct MaskItem *conf, const char *name) |
1009 |
|
{ |
1010 |
< |
if (EmptyString(name) || (conf->class = class_find(name, 1)) == NULL) |
1010 |
> |
if (EmptyString(name) || (conf->class = class_find(name, true)) == NULL) |
1011 |
|
{ |
1012 |
|
conf->class = class_default; |
1013 |
|
|
1091 |
|
* If the incoming time is in seconds convert it to minutes for the purpose |
1092 |
|
* of this calculation |
1093 |
|
*/ |
1094 |
< |
if (!minutes) |
1094 |
> |
if (minutes == 0) |
1095 |
|
result = result / 60; |
1096 |
|
|
1097 |
|
if (result > MAX_TDKLINE_TIME) |
1108 |
|
* outputs - 1 if valid, else 0 |
1109 |
|
* side effects - none |
1110 |
|
*/ |
1111 |
< |
int |
1111 |
> |
bool |
1112 |
|
valid_wild_card_simple(const char *data) |
1113 |
|
{ |
1114 |
|
const unsigned char *p = (const unsigned char *)data; |
1121 |
|
{ |
1122 |
|
++p; |
1123 |
|
if (++nonwild >= ConfigGeneral.min_nonwildcard_simple) |
1124 |
< |
return 1; |
1124 |
> |
return true; |
1125 |
|
} |
1126 |
|
else if (!IsMWildChar(tmpch)) |
1127 |
|
{ |
1128 |
|
if (++nonwild >= ConfigGeneral.min_nonwildcard_simple) |
1129 |
< |
return 1; |
1129 |
> |
return true; |
1130 |
|
} |
1131 |
|
else |
1132 |
|
++wild; |
1133 |
|
} |
1134 |
|
|
1135 |
< |
return !wild; |
1135 |
> |
return wild == 0; |
1136 |
|
} |
1137 |
|
|
1138 |
|
/* valid_wild_card() |
1141 |
|
* - int flag, 0 for no warning oper 1 for warning oper |
1142 |
|
* - count of following varargs to check |
1143 |
|
* output - 0 if not valid, 1 if valid |
1144 |
< |
* side effects - NOTICE is given to source_p if warn is 1 |
1144 |
> |
* side effects - NOTICE is given to client if warn is 1 |
1145 |
|
*/ |
1146 |
< |
int |
1146 |
> |
bool |
1147 |
|
valid_wild_card(int count, ...) |
1148 |
|
{ |
1149 |
|
unsigned char tmpch = '\0'; |
1181 |
|
if (++nonwild >= ConfigGeneral.min_nonwildcard) |
1182 |
|
{ |
1183 |
|
va_end(args); |
1184 |
< |
return 1; |
1184 |
> |
return true; |
1185 |
|
} |
1186 |
|
} |
1187 |
|
} |
1188 |
|
} |
1189 |
|
|
1190 |
|
va_end(args); |
1191 |
< |
return 0; |
1345 |
< |
} |
1346 |
< |
|
1347 |
< |
/* find_user_host() |
1348 |
< |
* |
1349 |
< |
* inputs - pointer to client placing kline |
1350 |
< |
* - pointer to user_host_or_nick |
1351 |
< |
* - pointer to user buffer |
1352 |
< |
* - pointer to host buffer |
1353 |
< |
* output - 0 if not ok to kline, 1 to kline i.e. if valid user host |
1354 |
< |
* side effects - |
1355 |
< |
*/ |
1356 |
< |
static int |
1357 |
< |
find_user_host(struct Client *source_p, char *user_host_or_nick, |
1358 |
< |
char *luser, char *lhost) |
1359 |
< |
{ |
1360 |
< |
struct Client *target_p = NULL; |
1361 |
< |
char *hostp = NULL; |
1362 |
< |
|
1363 |
< |
if (lhost == NULL) |
1364 |
< |
{ |
1365 |
< |
strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); |
1366 |
< |
return 1; |
1367 |
< |
} |
1368 |
< |
|
1369 |
< |
if ((hostp = strchr(user_host_or_nick, '@')) || *user_host_or_nick == '*') |
1370 |
< |
{ |
1371 |
< |
/* Explicit user@host mask given */ |
1372 |
< |
if (hostp) /* I'm a little user@host */ |
1373 |
< |
{ |
1374 |
< |
*(hostp++) = '\0'; /* short and squat */ |
1375 |
< |
|
1376 |
< |
if (*user_host_or_nick) |
1377 |
< |
strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */ |
1378 |
< |
else |
1379 |
< |
strcpy(luser, "*"); |
1380 |
< |
|
1381 |
< |
if (*hostp) |
1382 |
< |
strlcpy(lhost, hostp, HOSTLEN + 1); /* here is my host */ |
1383 |
< |
else |
1384 |
< |
strcpy(lhost, "*"); |
1385 |
< |
} |
1386 |
< |
else |
1387 |
< |
{ |
1388 |
< |
luser[0] = '*'; /* no @ found, assume its *@somehost */ |
1389 |
< |
luser[1] = '\0'; |
1390 |
< |
strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1); |
1391 |
< |
} |
1392 |
< |
|
1393 |
< |
return 1; |
1394 |
< |
} |
1395 |
< |
else |
1396 |
< |
{ |
1397 |
< |
/* Try to find user@host mask from nick */ |
1398 |
< |
/* Okay to use source_p as the first param, because source_p == client_p */ |
1399 |
< |
if ((target_p = |
1400 |
< |
find_chasing(source_p, user_host_or_nick)) == NULL) |
1401 |
< |
return 0; /* find_chasing sends ERR_NOSUCHNICK */ |
1402 |
< |
|
1403 |
< |
if (HasFlag(target_p, FLAGS_EXEMPTKLINE)) |
1404 |
< |
{ |
1405 |
< |
if (IsClient(source_p)) |
1406 |
< |
sendto_one_notice(source_p, &me, ":%s is E-lined", target_p->name); |
1407 |
< |
return 0; |
1408 |
< |
} |
1409 |
< |
|
1410 |
< |
/* |
1411 |
< |
* Turn the "user" bit into "*user", blow away '~' |
1412 |
< |
* if found in original user name (non-idented) |
1413 |
< |
*/ |
1414 |
< |
strlcpy(luser, target_p->username, USERLEN*4 + 1); |
1415 |
< |
|
1416 |
< |
if (target_p->username[0] == '~') |
1417 |
< |
luser[0] = '*'; |
1418 |
< |
|
1419 |
< |
strlcpy(lhost, target_p->sockhost, HOSTLEN*4 + 1); |
1420 |
< |
return 1; |
1421 |
< |
} |
1422 |
< |
|
1423 |
< |
return 0; |
1191 |
> |
return false; |
1192 |
|
} |
1193 |
|
|
1194 |
|
/* XXX should this go into a separate file ? -Dianora */ |
1221 |
|
* |
1222 |
|
* - Dianora |
1223 |
|
*/ |
1224 |
< |
int |
1225 |
< |
parse_aline(const char *cmd, struct Client *source_p, |
1458 |
< |
int parc, char **parv, |
1459 |
< |
char **up_p, char **h_p, uintmax_t *tkline_time, |
1460 |
< |
char **target_server, char **reason) |
1224 |
> |
bool |
1225 |
> |
parse_aline(const char *cmd, struct Client *client, int parc, char **parv, struct aline_ctx *aline) |
1226 |
|
{ |
1462 |
– |
uintmax_t found_tkline_time=0; |
1227 |
|
static char default_reason[] = CONF_NOREASON; |
1228 |
< |
static char user[USERLEN*4+1]; |
1229 |
< |
static char host[HOSTLEN*4+1]; |
1228 |
> |
static char user[USERLEN * 2 + 1]; |
1229 |
> |
static char host[HOSTLEN * 2 + 1]; |
1230 |
|
|
1231 |
< |
parv++; |
1232 |
< |
parc--; |
1231 |
> |
++parv; |
1232 |
> |
--parc; |
1233 |
|
|
1234 |
< |
found_tkline_time = valid_tkline(*parv, TK_MINUTES); |
1471 |
< |
|
1472 |
< |
if (found_tkline_time) |
1234 |
> |
if (aline->add == true && (aline->duration = valid_tkline(*parv, TK_MINUTES))) |
1235 |
|
{ |
1236 |
< |
parv++; |
1237 |
< |
parc--; |
1476 |
< |
|
1477 |
< |
if (tkline_time) |
1478 |
< |
*tkline_time = found_tkline_time; |
1479 |
< |
else |
1480 |
< |
{ |
1481 |
< |
sendto_one_notice(source_p, &me, ":temp_line not supported by %s", cmd); |
1482 |
< |
return 0; |
1483 |
< |
} |
1236 |
> |
++parv; |
1237 |
> |
--parc; |
1238 |
|
} |
1239 |
|
|
1240 |
|
if (parc == 0) |
1241 |
|
{ |
1242 |
< |
sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd); |
1243 |
< |
return 0; |
1242 |
> |
sendto_one_numeric(client, &me, ERR_NEEDMOREPARAMS, cmd); |
1243 |
> |
return false; |
1244 |
|
} |
1245 |
|
|
1246 |
< |
if (h_p == NULL) |
1247 |
< |
*up_p = *parv; |
1246 |
> |
if (aline->simple_mask == true) |
1247 |
> |
{ |
1248 |
> |
aline->mask = *parv; |
1249 |
> |
aline->user = NULL; |
1250 |
> |
aline->host = NULL; |
1251 |
> |
} |
1252 |
|
else |
1253 |
|
{ |
1254 |
< |
if (find_user_host(source_p, *parv, user, host) == 0) |
1497 |
< |
return 0; |
1254 |
> |
struct split_nuh_item nuh; |
1255 |
|
|
1256 |
< |
*up_p = user; |
1257 |
< |
*h_p = host; |
1256 |
> |
nuh.nuhmask = *parv; |
1257 |
> |
nuh.nickptr = NULL; |
1258 |
> |
nuh.userptr = user; |
1259 |
> |
nuh.hostptr = host; |
1260 |
> |
|
1261 |
> |
nuh.nicksize = 0; |
1262 |
> |
nuh.usersize = sizeof(user); |
1263 |
> |
nuh.hostsize = sizeof(host); |
1264 |
> |
|
1265 |
> |
split_nuh(&nuh); |
1266 |
> |
|
1267 |
> |
aline->mask = NULL; |
1268 |
> |
aline->user = user; |
1269 |
> |
aline->host = host; |
1270 |
|
} |
1271 |
|
|
1272 |
< |
parc--; |
1273 |
< |
parv++; |
1272 |
> |
++parv; |
1273 |
> |
--parc; |
1274 |
|
|
1275 |
|
if (parc) |
1276 |
|
{ |
1277 |
|
if (irccmp(*parv, "ON") == 0) |
1278 |
|
{ |
1279 |
< |
parc--; |
1280 |
< |
parv++; |
1279 |
> |
++parv; |
1280 |
> |
--parc; |
1281 |
|
|
1282 |
< |
if (!HasOFlag(source_p, OPER_FLAG_REMOTEBAN)) |
1282 |
> |
if (!HasOFlag(client, OPER_FLAG_REMOTEBAN)) |
1283 |
|
{ |
1284 |
< |
sendto_one_numeric(source_p, &me, ERR_NOPRIVS, "remoteban"); |
1285 |
< |
return 0; |
1284 |
> |
sendto_one_numeric(client, &me, ERR_NOPRIVS, "remoteban"); |
1285 |
> |
return false; |
1286 |
|
} |
1287 |
|
|
1288 |
|
if (parc == 0 || EmptyString(*parv)) |
1289 |
|
{ |
1290 |
< |
sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd); |
1291 |
< |
return 0; |
1290 |
> |
sendto_one_numeric(client, &me, ERR_NEEDMOREPARAMS, cmd); |
1291 |
> |
return false; |
1292 |
|
} |
1293 |
|
|
1294 |
< |
*target_server = *parv; |
1295 |
< |
parc--; |
1296 |
< |
parv++; |
1294 |
> |
aline->server = *parv; |
1295 |
> |
++parv; |
1296 |
> |
--parc; |
1297 |
|
} |
1298 |
|
else |
1299 |
< |
{ |
1531 |
< |
/* Make sure target_server *is* NULL if no ON server found |
1532 |
< |
* caller probably NULL'd it first, but no harm to do it again -db |
1533 |
< |
*/ |
1534 |
< |
if (target_server) |
1535 |
< |
*target_server = NULL; |
1536 |
< |
} |
1299 |
> |
aline->server = NULL; |
1300 |
|
} |
1301 |
|
|
1302 |
< |
if (reason) |
1302 |
> |
if (aline->add == true) |
1303 |
|
{ |
1304 |
< |
if (parc && !EmptyString(*parv)) |
1305 |
< |
*reason = *parv; |
1304 |
> |
if (parc == 0 || EmptyString(*parv)) |
1305 |
> |
aline->reason = default_reason; |
1306 |
|
else |
1307 |
< |
*reason = default_reason; |
1307 |
> |
aline->reason = *parv; |
1308 |
|
} |
1309 |
|
|
1310 |
< |
return 1; |
1310 |
> |
return true; |
1311 |
|
} |
1312 |
|
|
1313 |
|
/* match_conf_password() |
1317 |
|
* output - 1 or 0 if match |
1318 |
|
* side effects - none |
1319 |
|
*/ |
1320 |
< |
int |
1320 |
> |
bool |
1321 |
|
match_conf_password(const char *password, const struct MaskItem *conf) |
1322 |
|
{ |
1323 |
|
const char *encr = NULL; |
1324 |
|
|
1325 |
|
if (EmptyString(password) || EmptyString(conf->passwd)) |
1326 |
< |
return 0; |
1326 |
> |
return false; |
1327 |
|
|
1328 |
|
if (conf->flags & CONF_FLAGS_ENCRYPTED) |
1329 |
|
encr = crypt(password, conf->passwd); |
1330 |
|
else |
1331 |
|
encr = password; |
1332 |
|
|
1333 |
< |
return encr && !strcmp(encr, conf->passwd); |
1333 |
> |
return encr && strcmp(encr, conf->passwd) == 0; |
1334 |
|
} |
1335 |
|
|
1336 |
|
/* |
1415 |
|
else |
1416 |
|
{ |
1417 |
|
/* No @ found */ |
1418 |
< |
if (!iptr->nickptr || strpbrk(iptr->nuhmask, ".:")) |
1418 |
> |
if (iptr->nickptr == NULL || strpbrk(iptr->nuhmask, ".:")) |
1419 |
|
strlcpy(iptr->hostptr, iptr->nuhmask, iptr->hostsize); |
1420 |
|
else |
1421 |
|
strlcpy(iptr->nickptr, iptr->nuhmask, iptr->nicksize); |