ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/client.c
Revision: 7796
Committed: Tue Oct 18 17:26:37 2016 UTC (7 years, 5 months ago) by michael
Content type: text/x-csrc
File size: 31950 byte(s)
Log Message:
- Minor style corrections and constifications

File Contents

# Content
1 /*
2 * ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3 *
4 * Copyright (c) 1997-2016 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
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19 * USA
20 */
21
22 /*! \file client.c
23 * \brief Controls clients.
24 * \version $Id$
25 */
26
27 #include "stdinc.h"
28 #include "list.h"
29 #include "client.h"
30 #include "event.h"
31 #include "hash.h"
32 #include "irc_string.h"
33 #include "ircd.h"
34 #include "numeric.h"
35 #include "auth.h"
36 #include "s_bsd.h"
37 #include "conf.h"
38 #include "conf_gecos.h"
39 #include "log.h"
40 #include "misc.h"
41 #include "server.h"
42 #include "send.h"
43 #include "whowas.h"
44 #include "user.h"
45 #include "memory.h"
46 #include "mempool.h"
47 #include "hostmask.h"
48 #include "listener.h"
49 #include "userhost.h"
50 #include "watch.h"
51 #include "rng_mt.h"
52 #include "parse.h"
53 #include "ipcache.h"
54
55
56 dlink_list listing_client_list;
57 dlink_list unknown_list;
58 dlink_list local_client_list;
59 dlink_list local_server_list;
60 dlink_list global_client_list;
61 dlink_list global_server_list;
62 dlink_list oper_list;
63
64 static mp_pool_t *client_pool, *connection_pool;
65 static dlink_list dead_list, abort_list;
66 static dlink_node *eac_next; /* next aborted client to exit */
67
68
69 /*
70 * make_client - create a new Client struct and set it to initial state.
71 *
72 * from == NULL, create local client (a client connected
73 * to a socket).
74 * WARNING: This leaves the client in a dangerous
75 * state where fd == -1, dead flag is not set and
76 * the client is on the unknown_list; therefore,
77 * the first thing to do after calling make_client(NULL)
78 * is setting fd to something reasonable. -adx
79 *
80 * from, create remote client (behind a socket
81 * associated with the client defined by
82 * 'from'). ('from' is a local client!!).
83 */
84 struct Client *
85 make_client(struct Client *from)
86 {
87 struct Client *const client_p = mp_pool_get(client_pool);
88
89 if (from)
90 client_p->from = from;
91 else
92 {
93 client_p->from = client_p; /* 'from' of local client is self! */
94 client_p->connection = mp_pool_get(connection_pool);
95 client_p->connection->since = CurrentTime;
96 client_p->connection->lasttime = CurrentTime;
97 client_p->connection->firsttime = CurrentTime;
98 client_p->connection->registration = REG_INIT;
99
100 /* as good a place as any... */
101 dlinkAdd(client_p, &client_p->connection->lclient_node, &unknown_list);
102 }
103
104 client_p->idhnext = client_p;
105 client_p->hnext = client_p;
106 SetUnknown(client_p);
107 strcpy(client_p->username, "unknown");
108 strcpy(client_p->account, "*");
109
110 return client_p;
111 }
112
113 /*
114 * free_client
115 *
116 * inputs - pointer to client
117 * output - NONE
118 * side effects - client pointed to has its memory freed
119 */
120 static void
121 free_client(struct Client *client_p)
122 {
123 assert(client_p != &me);
124 assert(client_p->hnext == client_p);
125 assert(client_p->idhnext == client_p);
126 assert(client_p->channel.head == NULL);
127 assert(dlink_list_length(&client_p->channel) == 0);
128 assert(dlink_list_length(&client_p->whowas_list) == 0);
129 assert(dlink_list_length(&client_p->svstags) == 0);
130
131 xfree(client_p->serv);
132 xfree(client_p->certfp);
133
134 if (MyConnect(client_p))
135 {
136 assert(client_p->connection->invited.head == NULL);
137 assert(dlink_list_length(&client_p->connection->invited) == 0);
138 assert(dlink_list_length(&client_p->connection->watches) == 0);
139 assert(HasFlag(client_p, FLAGS_CLOSING) && IsDead(client_p));
140
141 /*
142 * Clean up extra sockets from listen {} blocks which have been discarded.
143 */
144 if (client_p->connection->listener)
145 {
146 listener_release(client_p->connection->listener);
147 client_p->connection->listener = NULL;
148 }
149
150 dbuf_clear(&client_p->connection->buf_recvq);
151 dbuf_clear(&client_p->connection->buf_sendq);
152
153 mp_pool_release(client_p->connection);
154 }
155
156 mp_pool_release(client_p);
157 }
158
159 void
160 client_attach_svstag(struct Client *client_p, unsigned int numeric,
161 const char *umodes, const char *tag)
162 {
163 const struct user_modes *tab = NULL;
164
165 if (numeric >= ERR_LAST_ERR_MSG || *umodes != '+')
166 return;
167
168 struct ServicesTag *svstag = xcalloc(sizeof(*svstag));
169 svstag->numeric = numeric;
170 svstag->tag = xstrdup(tag);
171
172 for (const char *m = umodes + 1; *m; ++m)
173 if ((tab = umode_map[(unsigned char)*m]))
174 svstag->umodes |= tab->flag;
175
176 if (numeric != RPL_WHOISOPERATOR)
177 dlinkAddTail(svstag, &svstag->node, &client_p->svstags);
178 else
179 dlinkAdd(svstag, &svstag->node, &client_p->svstags);
180 }
181
182 void
183 client_clear_svstags(struct Client *client_p)
184 {
185 while (client_p->svstags.head)
186 {
187 struct ServicesTag *svstag = client_p->svstags.head->data;
188
189 dlinkDelete(&svstag->node, &client_p->svstags);
190 xfree(svstag->tag);
191 xfree(svstag);
192 }
193 }
194
195 /* check_pings_list()
196 *
197 * inputs - pointer to list to check
198 * output - NONE
199 * side effects -
200 */
201 static void
202 check_pings_list(dlink_list *list)
203 {
204 char buf[32] = ""; /* 32 = sizeof("Ping timeout: 999999999 seconds") */
205 unsigned int ping = 0; /* ping time value from client */
206 dlink_node *node = NULL, *node_next = NULL;
207
208 DLINK_FOREACH_SAFE(node, node_next, list->head)
209 {
210 struct Client *client_p = node->data;
211
212 if (IsDead(client_p))
213 continue; /* Ignore it, its been exited already */
214
215 if (IsClient(client_p) || IsServer(client_p))
216 ping = get_client_ping(&client_p->connection->confs);
217 else
218 ping = CONNECTTIMEOUT;
219
220 if (ping < CurrentTime - client_p->connection->lasttime)
221 {
222 if (!HasFlag(client_p, FLAGS_PINGSENT))
223 {
224 /*
225 * If we haven't PINGed the connection and we haven't
226 * heard from it in a while, PING it to make sure
227 * it is still alive.
228 */
229 AddFlag(client_p, FLAGS_PINGSENT);
230 client_p->connection->lasttime = CurrentTime - ping;
231 sendto_one(client_p, "PING :%s", ID_or_name(&me, client_p));
232 }
233 else
234 {
235 if (CurrentTime - client_p->connection->lasttime >= 2 * ping)
236 {
237 /*
238 * If the client/server hasn't talked to us in 2*ping seconds
239 * and it has a ping time, then close its connection.
240 */
241 if (IsServer(client_p) || IsHandshake(client_p))
242 {
243 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
244 "No response from %s, closing link",
245 get_client_name(client_p, SHOW_IP));
246 sendto_realops_flags(UMODE_SERVNOTICE, L_OPER, SEND_NOTICE,
247 "No response from %s, closing link",
248 get_client_name(client_p, MASK_IP));
249 ilog(LOG_TYPE_IRCD, "No response from %s, closing link",
250 get_client_name(client_p, SHOW_IP));
251 }
252
253 snprintf(buf, sizeof(buf), "Ping timeout: %ji seconds",
254 (CurrentTime - client_p->connection->lasttime));
255 exit_client(client_p, buf);
256 }
257 }
258 }
259 }
260 }
261
262 /* check_unknowns_list()
263 *
264 * inputs - pointer to list of unknown clients
265 * output - NONE
266 * side effects - unknown clients get marked for termination after n seconds
267 */
268 static void
269 check_unknowns_list(void)
270 {
271 dlink_node *node = NULL, *node_next = NULL;
272
273 DLINK_FOREACH_SAFE(node, node_next, unknown_list.head)
274 {
275 struct Client *client_p = node->data;
276
277 /*
278 * Check UNKNOWN connections - if they have been in this state
279 * for > 30s, close them.
280 */
281 if (HasFlag(client_p, FLAGS_FINISHED_AUTH) && (CurrentTime - client_p->connection->firsttime) > 30)
282 exit_client(client_p, "Registration timed out");
283 }
284 }
285
286 /*
287 * check_pings - go through the local client list and check activity
288 * kill off stuff that should die
289 *
290 * inputs - NOT USED (from event)
291 * side effects -
292 *
293 *
294 * A PING can be sent to clients as necessary.
295 *
296 * Client/Server ping outs are handled.
297 */
298
299 /*
300 * Addon from adrian. We used to call this after nextping seconds,
301 * however I've changed it to run once a second. This is only for
302 * PING timeouts, not K/etc-line checks (thanks dianora!). Having it
303 * run once a second makes life a lot easier - when a new client connects
304 * and they need a ping in 4 seconds, if nextping was set to 20 seconds
305 * we end up waiting 20 seconds. This is stupid. :-)
306 * I will optimise (hah!) check_pings() once I've finished working on
307 * tidying up other network IO evilnesses.
308 * -- adrian
309 */
310
311 static void
312 check_pings(void *unused)
313 {
314 check_pings_list(&local_client_list);
315 check_pings_list(&local_server_list);
316 check_unknowns_list();
317 }
318
319 /* check_conf_klines()
320 *
321 * inputs - NONE
322 * output - NONE
323 * side effects - Check all connections for a pending kline against the
324 * client, exit the client if a kline matches.
325 */
326 void
327 check_conf_klines(void)
328 {
329 dlink_node *node = NULL, *node_next = NULL;
330 const void *ptr;
331
332 DLINK_FOREACH_SAFE(node, node_next, local_client_list.head)
333 {
334 struct Client *client_p = node->data;
335
336 /* If a client is already being exited */
337 if (IsDead(client_p))
338 continue;
339
340 if ((ptr = find_conf_by_address(NULL, &client_p->connection->ip, CONF_DLINE,
341 client_p->connection->aftype, NULL, NULL, 1)))
342 {
343 const struct MaskItem *conf = ptr;
344 conf_try_ban(client_p, CLIENT_BAN_DLINE, conf->reason);
345 continue; /* and go examine next Client */
346 }
347
348 if ((ptr = find_conf_by_address(client_p->host, &client_p->connection->ip,
349 CONF_KLINE, client_p->connection->aftype,
350 client_p->username, NULL, 1)))
351 {
352 const struct MaskItem *conf = ptr;
353 conf_try_ban(client_p, CLIENT_BAN_KLINE, conf->reason);
354 continue; /* and go examine next Client */
355 }
356
357 if ((ptr = gecos_find(client_p->info, match)))
358 {
359 const struct GecosItem *conf = ptr;
360 conf_try_ban(client_p, CLIENT_BAN_XLINE, conf->reason);
361 continue; /* and go examine next Client */
362 }
363 }
364
365 /* Also check the unknowns list for new dlines */
366 DLINK_FOREACH_SAFE(node, node_next, unknown_list.head)
367 {
368 struct Client *client_p = node->data;
369
370 if ((ptr = find_conf_by_address(NULL, &client_p->connection->ip, CONF_DLINE,
371 client_p->connection->aftype, NULL, NULL, 1)))
372 {
373 const struct MaskItem *conf = ptr;
374 conf_try_ban(client_p, CLIENT_BAN_DLINE, conf->reason);
375 continue; /* and go examine next Client */
376 }
377 }
378 }
379
380 /*
381 * conf_try_ban
382 *
383 * inputs - pointer to client to ban
384 * - pointer to MaskItem
385 * output - NONE
386 * side effects - given client_p is banned
387 */
388 void
389 conf_try_ban(struct Client *client_p, int type, const char *reason)
390 {
391 char ban_type = '?';
392
393 switch (type)
394 {
395 case CLIENT_BAN_KLINE:
396 if (HasFlag(client_p, FLAGS_EXEMPTKLINE))
397 {
398 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
399 "KLINE over-ruled for %s, client is kline_exempt",
400 get_client_name(client_p, HIDE_IP));
401 return;
402 }
403
404 ban_type = 'K';
405 break;
406 case CLIENT_BAN_DLINE:
407 if (find_conf_by_address(NULL, &client_p->connection->ip, CONF_EXEMPT,
408 client_p->connection->aftype, NULL, NULL, 1))
409 return;
410 ban_type = 'D';
411 break;
412 case CLIENT_BAN_XLINE:
413 if (HasFlag(client_p, FLAGS_EXEMPTXLINE))
414 {
415 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
416 "XLINE over-ruled for %s, client is xline_exempt",
417 get_client_name(client_p, HIDE_IP));
418 return;
419 }
420
421 ban_type = 'X';
422 break;
423 default:
424 assert(0);
425 break;
426 }
427
428 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE, "%c-line active for %s",
429 ban_type, get_client_name(client_p, HIDE_IP));
430
431 if (IsClient(client_p))
432 sendto_one_numeric(client_p, &me, ERR_YOUREBANNEDCREEP, reason);
433
434 exit_client(client_p, reason);
435 }
436
437 /* update_client_exit_stats()
438 *
439 * input - pointer to client
440 * output - NONE
441 * side effects -
442 */
443 static void
444 update_client_exit_stats(struct Client *client_p)
445 {
446 if (IsClient(client_p))
447 {
448 assert(Count.total > 0);
449
450 --Count.total;
451 if (HasUMode(client_p, UMODE_OPER))
452 --Count.oper;
453 if (HasUMode(client_p, UMODE_INVISIBLE))
454 --Count.invisi;
455 }
456 else if (IsServer(client_p))
457 sendto_realops_flags(UMODE_EXTERNAL, L_ALL, SEND_NOTICE,
458 "Server %s split from %s",
459 client_p->name, client_p->servptr->name);
460 }
461
462 /* find_person()
463 *
464 * inputs - pointer to name
465 * output - return client pointer
466 * side effects - find person by (nick)name
467 */
468 struct Client *
469 find_person(const struct Client *source_p, const char *name)
470 {
471 struct Client *target_p = NULL;
472
473 if (IsDigit(*name))
474 {
475 if (IsServer(source_p->from))
476 target_p = hash_find_id(name);
477 }
478 else
479 target_p = hash_find_client(name);
480
481 return (target_p && IsClient(target_p)) ? target_p : NULL;
482 }
483
484 /*
485 * find_chasing - find the client structure for a nick name (name)
486 * using history mechanism if necessary. If the client is not found,
487 * an error message (NO SUCH NICK) is generated.
488 */
489 struct Client *
490 find_chasing(struct Client *source_p, const char *name)
491 {
492 struct Client *target_p = find_person(source_p, name);
493
494 if (target_p)
495 return target_p;
496
497 if (IsDigit(*name))
498 return NULL;
499
500 target_p = whowas_get_history(name, ConfigGeneral.kill_chase_time_limit);
501 if (!target_p)
502 sendto_one_numeric(source_p, &me, ERR_NOSUCHNICK, name);
503
504 return target_p;
505 }
506
507 /*
508 * get_client_name - Return the name of the client
509 * for various tracking and
510 * admin purposes. The main purpose of this function is to
511 * return the "socket host" name of the client, if that
512 * differs from the advertised name (other than case).
513 * But, this can be used to any client structure.
514 *
515 * NOTE 1:
516 * Watch out the allocation of "buf", if either source_p->name
517 * or source_p->sockhost gets changed into pointers instead of
518 * directly allocated within the structure...
519 *
520 * NOTE 2:
521 * Function return either a pointer to the structure (source_p) or
522 * to internal buffer (buf). *NEVER* use the returned pointer
523 * to modify what it points!!!
524 */
525 const char *
526 get_client_name(const struct Client *client_p, enum addr_mask_type type)
527 {
528 static char buf[HOSTLEN * 2 + USERLEN + 4]; /* +4 for [,@,],\0 */
529
530 if (!MyConnect(client_p))
531 return client_p->name;
532
533 if (IsServer(client_p) || IsConnecting(client_p) || IsHandshake(client_p))
534 {
535 if (!irccmp(client_p->name, client_p->host))
536 return client_p->name;
537 else if (ConfigServerHide.hide_server_ips)
538 type = MASK_IP;
539 }
540
541 /* And finally, let's get the host information, ip or name */
542 switch (type)
543 {
544 case SHOW_IP:
545 snprintf(buf, sizeof(buf), "%s[%s@%s]",
546 client_p->name,
547 client_p->username, client_p->sockhost);
548 break;
549 case MASK_IP:
550 if (client_p->connection->aftype == AF_INET)
551 snprintf(buf, sizeof(buf), "%s[%s@255.255.255.255]",
552 client_p->name, client_p->username);
553 else
554 snprintf(buf, sizeof(buf), "%s[%s@ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]",
555 client_p->name, client_p->username);
556 break;
557 default: /* HIDE_IP */
558 snprintf(buf, sizeof(buf), "%s[%s@%s]",
559 client_p->name,
560 client_p->username, client_p->host);
561 }
562
563 return buf;
564 }
565
566 void
567 free_exited_clients(void)
568 {
569 dlink_node *node = NULL, *node_next = NULL;
570
571 DLINK_FOREACH_SAFE(node, node_next, dead_list.head)
572 {
573 free_client(node->data);
574 dlinkDelete(node, &dead_list);
575 free_dlink_node(node);
576 }
577 }
578
579 /*
580 * Exit one client, local or remote. Assuming all dependents have
581 * been already removed, and socket closed for local client.
582 *
583 * The only messages generated are QUITs on channels.
584 */
585 static void
586 exit_one_client(struct Client *source_p, const char *comment)
587 {
588 dlink_node *node = NULL, *node_next = NULL;
589
590 assert(!IsMe(source_p));
591 assert(source_p != &me);
592
593 if (IsClient(source_p))
594 {
595 dlinkDelete(&source_p->lnode, &source_p->servptr->serv->client_list);
596 dlinkDelete(&source_p->node, &global_client_list);
597
598 /*
599 * If a person is on a channel, send a QUIT notice
600 * to every client (person) on the same channel (so
601 * that the client can show the "**signoff" message).
602 * (Note: The notice is to the local clients *only*)
603 */
604 sendto_common_channels_local(source_p, 0, 0, 0, ":%s!%s@%s QUIT :%s",
605 source_p->name, source_p->username,
606 source_p->host, comment);
607
608 DLINK_FOREACH_SAFE(node, node_next, source_p->channel.head)
609 remove_user_from_channel(node->data);
610
611 client_clear_svstags(source_p);
612
613 whowas_add_history(source_p, 0);
614 whowas_off_history(source_p);
615
616 watch_check_hash(source_p, RPL_LOGOFF);
617
618 if (MyConnect(source_p))
619 {
620 clear_invite_list(&source_p->connection->invited);
621 del_all_accepts(source_p);
622 }
623 }
624 else if (IsServer(source_p))
625 {
626 dlinkDelete(&source_p->lnode, &source_p->servptr->serv->server_list);
627 dlinkDelete(&source_p->node, &global_client_list);
628
629 if ((node = dlinkFindDelete(&global_server_list, source_p)))
630 free_dlink_node(node);
631 }
632
633 /* Remove source_p from the client lists */
634 if (source_p->id[0])
635 hash_del_id(source_p);
636
637 if (source_p->name[0])
638 hash_del_client(source_p);
639
640 if (HasFlag(source_p, FLAGS_USERHOST))
641 userhost_del(source_p->sockhost, !MyConnect(source_p));
642
643 update_client_exit_stats(source_p);
644
645 /* Check to see if the client isn't already on the dead list */
646 assert(dlinkFind(&dead_list, source_p) == NULL);
647
648 /* add to dead client dlist */
649 SetDead(source_p);
650 dlinkAdd(source_p, make_dlink_node(), &dead_list);
651 }
652
653 /*
654 * Remove all clients that depend on source_p; assumes all (S)QUITs have
655 * already been sent. we make sure to exit a server's dependent clients
656 * and servers before the server itself; exit_one_client takes care of
657 * actually removing things off llists. tweaked from +CSr31 -orabidoo
658 */
659 static void
660 recurse_remove_clients(struct Client *source_p, const char *comment)
661 {
662 dlink_node *node = NULL, *node_next = NULL;
663
664 DLINK_FOREACH_SAFE(node, node_next, source_p->serv->client_list.head)
665 exit_one_client(node->data, comment);
666
667 DLINK_FOREACH_SAFE(node, node_next, source_p->serv->server_list.head)
668 {
669 recurse_remove_clients(node->data, comment);
670 exit_one_client(node->data, comment);
671 }
672 }
673
674 /*
675 * exit_client - exit a client of any type. Generally, you can use
676 * this on any struct Client, regardless of its state.
677 *
678 * Note, you shouldn't exit remote _users_ without first doing
679 * AddFlag(x, FLAGS_KILLED) and propagating a kill or similar message.
680 *
681 * However, it is perfectly correct to call exit_client to force a _server_
682 * quit (either local or remote one).
683 *
684 *
685 * inputs: - a client pointer that is going to be exited
686 * output: none
687 * side effects: the client is delinked from all lists, disconnected,
688 * and the rest of IRC network is notified of the exit.
689 * Client memory is scheduled to be freed
690 */
691 void
692 exit_client(struct Client *source_p, const char *comment)
693 {
694 dlink_node *node = NULL;
695
696 assert(!IsMe(source_p));
697 assert(source_p != &me);
698
699 if (MyConnect(source_p))
700 {
701 /* DO NOT REMOVE. exit_client can be called twice after a failed
702 * read/write.
703 */
704 if (HasFlag(source_p, FLAGS_CLOSING))
705 return;
706
707 AddFlag(source_p, FLAGS_CLOSING);
708
709 if (HasFlag(source_p, FLAGS_IPHASH))
710 {
711 DelFlag(source_p, FLAGS_IPHASH);
712 ipcache_remove_address(&source_p->connection->ip);
713 }
714
715 delete_auth(&source_p->connection->auth);
716
717 if (IsClient(source_p))
718 {
719 assert(Count.local > 0);
720
721 --Count.local;
722
723 if (HasUMode(source_p, UMODE_OPER))
724 if ((node = dlinkFindDelete(&oper_list, source_p)))
725 free_dlink_node(node);
726
727 assert(dlinkFind(&local_client_list, source_p));
728 dlinkDelete(&source_p->connection->lclient_node, &local_client_list);
729
730 if (source_p->connection->list_task)
731 free_list_task(source_p);
732
733 watch_del_watch_list(source_p);
734
735 sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE,
736 "Client exiting: %s (%s@%s) [%s] [%s]",
737 source_p->name, source_p->username, source_p->host,
738 source_p->sockhost, comment);
739
740 ilog(LOG_TYPE_USER, "%s (%ju): %s!%s@%s %s %s %ju/%ju :%s",
741 date_ctime(source_p->connection->firsttime),
742 CurrentTime - source_p->connection->firsttime,
743 source_p->name, source_p->username, source_p->host,
744 source_p->sockhost, source_p->account,
745 source_p->connection->send.bytes >> 10,
746 source_p->connection->recv.bytes >> 10, source_p->info);
747 }
748 else if (IsServer(source_p))
749 {
750 assert(Count.myserver > 0);
751
752 --Count.myserver;
753
754 assert(dlinkFind(&local_server_list, source_p));
755 dlinkDelete(&source_p->connection->lclient_node, &local_server_list);
756 }
757 else
758 {
759 assert(dlinkFind(&unknown_list, source_p));
760 dlinkDelete(&source_p->connection->lclient_node, &unknown_list);
761 }
762
763 if (!IsDead(source_p))
764 {
765 if (IsServer(source_p))
766 {
767 if (!HasFlag(source_p, FLAGS_SQUIT))
768 {
769 /* for them, we are exiting the network */
770 sendto_one(source_p, ":%s SQUIT %s :%s",
771 me.id, me.id, comment);
772 }
773 }
774
775 sendto_one(source_p, "ERROR :Closing Link: %s (%s)",
776 source_p->host, comment);
777 }
778
779 close_connection(source_p);
780 }
781 else if (IsClient(source_p) && HasFlag(source_p->servptr, FLAGS_EOB))
782 sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
783 "Client exiting at %s: %s (%s@%s) [%s] [%s]",
784 source_p->servptr->name, source_p->name,
785 source_p->username, source_p->host, source_p->sockhost, comment);
786
787 if (IsServer(source_p))
788 {
789 char splitstr[HOSTLEN + HOSTLEN + 2] = "";
790
791 assert(source_p->serv);
792 assert(source_p->servptr);
793
794 if (ConfigServerHide.hide_servers)
795 /*
796 * Set netsplit message to "*.net *.split" to still show
797 * that its a split, but hide the servers splitting
798 */
799 strlcpy(splitstr, "*.net *.split", sizeof(splitstr));
800 else
801 snprintf(splitstr, sizeof(splitstr), "%s %s",
802 source_p->servptr->name, source_p->name);
803
804 /* Send SQUIT for source_p in every direction. source_p is already off of local_server_list here */
805 if (!HasFlag(source_p, FLAGS_SQUIT))
806 sendto_server(NULL, 0, 0, "SQUIT %s :%s", source_p->id, comment);
807
808 /* Now exit the clients internally */
809 recurse_remove_clients(source_p, splitstr);
810
811 if (MyConnect(source_p))
812 {
813 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
814 "%s was connected for %s. %ju/%ju sendK/recvK.",
815 source_p->name, time_dissect(CurrentTime - source_p->connection->firsttime),
816 source_p->connection->send.bytes >> 10,
817 source_p->connection->recv.bytes >> 10);
818 ilog(LOG_TYPE_IRCD, "%s was connected for %s. %ju/%ju sendK/recvK.",
819 source_p->name, time_dissect(CurrentTime - source_p->connection->firsttime),
820 source_p->connection->send.bytes >> 10,
821 source_p->connection->recv.bytes >> 10);
822 }
823 }
824 else if (IsClient(source_p) && !HasFlag(source_p, FLAGS_KILLED))
825 sendto_server(source_p->from, 0, 0, ":%s QUIT :%s",
826 source_p->id, comment);
827
828 /* The client *better* be off all of the lists */
829 assert(dlinkFind(&unknown_list, source_p) == NULL);
830 assert(dlinkFind(&local_client_list, source_p) == NULL);
831 assert(dlinkFind(&local_server_list, source_p) == NULL);
832 assert(dlinkFind(&oper_list, source_p) == NULL);
833
834 exit_one_client(source_p, comment);
835 }
836
837 /*
838 * dead_link_on_write - report a write error if not already dead,
839 * mark it as dead then exit it
840 */
841 void
842 dead_link_on_write(struct Client *client_p, int ierrno)
843 {
844 dlink_node *node;
845
846 if (IsDefunct(client_p))
847 return;
848
849 dbuf_clear(&client_p->connection->buf_recvq);
850 dbuf_clear(&client_p->connection->buf_sendq);
851
852 assert(dlinkFind(&abort_list, client_p) == NULL);
853 node = make_dlink_node();
854 /* don't let exit_aborted_clients() finish yet */
855 dlinkAddTail(client_p, node, &abort_list);
856
857 if (eac_next == NULL)
858 eac_next = node;
859
860 SetDead(client_p); /* You are dead my friend */
861 }
862
863 /*
864 * dead_link_on_read - report a read error if not already dead,
865 * mark it as dead then exit it
866 */
867 void
868 dead_link_on_read(struct Client *client_p, int error)
869 {
870 char errmsg[IRCD_BUFSIZE];
871 int current_error;
872
873 if (IsDefunct(client_p))
874 return;
875
876 dbuf_clear(&client_p->connection->buf_recvq);
877 dbuf_clear(&client_p->connection->buf_sendq);
878
879 current_error = get_sockerr(client_p->connection->fd.fd);
880
881 if (IsServer(client_p) || IsHandshake(client_p))
882 {
883 if (error == 0)
884 {
885 /* Admins get the real IP */
886 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
887 "Server %s closed the connection",
888 get_client_name(client_p, SHOW_IP));
889
890 /* Opers get a masked IP */
891 sendto_realops_flags(UMODE_SERVNOTICE, L_OPER, SEND_NOTICE,
892 "Server %s closed the connection",
893 get_client_name(client_p, MASK_IP));
894
895 ilog(LOG_TYPE_IRCD, "Server %s closed the connection",
896 get_client_name(client_p, SHOW_IP));
897 }
898 else
899 {
900 report_error(L_ADMIN, "Lost connection to %s: %s",
901 get_client_name(client_p, SHOW_IP), current_error);
902 report_error(L_OPER, "Lost connection to %s: %s",
903 get_client_name(client_p, MASK_IP), current_error);
904 }
905
906 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
907 "%s was connected for %s",
908 client_p->name, time_dissect(CurrentTime - client_p->connection->firsttime));
909 }
910
911 if (error == 0)
912 strlcpy(errmsg, "Remote host closed the connection",
913 sizeof(errmsg));
914 else
915 snprintf(errmsg, sizeof(errmsg), "Read error: %s",
916 strerror(current_error));
917
918 exit_client(client_p, errmsg);
919 }
920
921 void
922 exit_aborted_clients(void)
923 {
924 dlink_node *ptr;
925 struct Client *target_p;
926 const char *notice;
927
928 DLINK_FOREACH_SAFE(ptr, eac_next, abort_list.head)
929 {
930 target_p = ptr->data;
931 eac_next = ptr->next;
932
933 if (target_p == NULL)
934 {
935 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
936 "Warning: null client on abort_list!");
937 dlinkDelete(ptr, &abort_list);
938 free_dlink_node(ptr);
939 continue;
940 }
941
942 dlinkDelete(ptr, &abort_list);
943
944 if (HasFlag(target_p, FLAGS_SENDQEX))
945 notice = "Max SendQ exceeded";
946 else
947 notice = "Write error: connection closed";
948
949 exit_client(target_p, notice);
950 free_dlink_node(ptr);
951 }
952 }
953
954 /*
955 * accept processing, this adds a form of "caller ID" to ircd
956 *
957 * If a client puts themselves into "caller ID only" mode,
958 * only clients that match a client pointer they have put on
959 * the accept list will be allowed to message them.
960 *
961 * Diane Bruce, "Dianora" db@db.net
962 */
963
964 void
965 del_accept(struct split_nuh_item *accept_p, struct Client *client_p)
966 {
967 dlinkDelete(&accept_p->node, &client_p->connection->acceptlist);
968
969 xfree(accept_p->nickptr);
970 xfree(accept_p->userptr);
971 xfree(accept_p->hostptr);
972 xfree(accept_p);
973 }
974
975 struct split_nuh_item *
976 find_accept(const char *nick, const char *user,
977 const char *host, struct Client *client_p,
978 int (*cmpfunc)(const char *, const char *))
979 {
980 dlink_node *node = NULL;
981
982 DLINK_FOREACH(node, client_p->connection->acceptlist.head)
983 {
984 struct split_nuh_item *accept_p = node->data;
985
986 if (!cmpfunc(accept_p->nickptr, nick) &&
987 !cmpfunc(accept_p->userptr, user) &&
988 !cmpfunc(accept_p->hostptr, host))
989 return accept_p;
990 }
991
992 return NULL;
993 }
994
995 /* accept_message()
996 *
997 * inputs - pointer to source client
998 * - pointer to target client
999 * output - 1 if accept this message 0 if not
1000 * side effects - See if source is on target's allow list
1001 */
1002 int
1003 accept_message(struct Client *source,
1004 struct Client *target)
1005 {
1006 dlink_node *node = NULL;
1007
1008 if (HasFlag(source, FLAGS_SERVICE) ||
1009 (HasUMode(source, UMODE_OPER) && ConfigGeneral.opers_bypass_callerid))
1010 return 1;
1011
1012 if (source == target || find_accept(source->name, source->username,
1013 source->host, target, match))
1014 return 1;
1015
1016 if (!HasUMode(target, UMODE_CALLERID) && HasUMode(target, UMODE_SOFTCALLERID))
1017 DLINK_FOREACH(node, target->channel.head)
1018 if (IsMember(source, ((struct Membership *)node->data)->chptr))
1019 return 1;
1020
1021 return 0;
1022 }
1023
1024 /* del_all_accepts()
1025 *
1026 * inputs - pointer to exiting client
1027 * output - NONE
1028 * side effects - Walk through given clients acceptlist and remove all entries
1029 */
1030 void
1031 del_all_accepts(struct Client *client_p)
1032 {
1033 dlink_node *node = NULL, *node_next = NULL;
1034
1035 DLINK_FOREACH_SAFE(node, node_next, client_p->connection->acceptlist.head)
1036 del_accept(node->data, client_p);
1037 }
1038
1039 unsigned int
1040 client_get_idle_time(const struct Client *source_p,
1041 const struct Client *target_p)
1042 {
1043 unsigned int idle = 0;
1044 unsigned int min_idle = 0;
1045 unsigned int max_idle = 0;
1046 const struct ClassItem *const class = get_class_ptr(&target_p->connection->confs);
1047
1048 if (!(class->flags & CLASS_FLAGS_FAKE_IDLE) || target_p == source_p)
1049 return CurrentTime - target_p->connection->last_privmsg;
1050
1051 if (HasUMode(source_p, UMODE_OPER) &&
1052 !(class->flags & CLASS_FLAGS_HIDE_IDLE_FROM_OPERS))
1053 return CurrentTime - target_p->connection->last_privmsg;
1054
1055 min_idle = class->min_idle;
1056 max_idle = class->max_idle;
1057
1058 if (min_idle == max_idle)
1059 return min_idle;
1060
1061 if (class->flags & CLASS_FLAGS_RANDOM_IDLE)
1062 idle = genrand_int32();
1063 else
1064 idle = CurrentTime - target_p->connection->last_privmsg;
1065
1066 if (!max_idle)
1067 idle = 0;
1068 else
1069 idle %= max_idle;
1070
1071 if (idle < min_idle)
1072 idle = min_idle + (idle % (max_idle - min_idle));
1073
1074 return idle;
1075 }
1076
1077 /* client_init()
1078 *
1079 * inputs - NONE
1080 * output - NONE
1081 * side effects - initialize client free memory
1082 */
1083 void
1084 client_init(void)
1085 {
1086 static struct event event_ping =
1087 {
1088 .name = "check_pings",
1089 .handler = check_pings,
1090 .when = 5
1091 };
1092
1093 client_pool = mp_pool_new(sizeof(struct Client), MP_CHUNK_SIZE_CLIENT);
1094 connection_pool = mp_pool_new(sizeof(struct Connection), MP_CHUNK_SIZE_CONNECTION);
1095 event_add(&event_ping, NULL);
1096 }

Properties

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