ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/client.c
Revision: 7340
Committed: Sat Feb 20 18:55:03 2016 UTC (8 years, 1 month ago) by michael
Content type: text/x-csrc
File size: 31980 byte(s)
Log Message:
- client_attach_svstag(): remove excessive 'const'

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 {
91 client_p->from = client_p; /* 'from' of local client is self! */
92 client_p->connection = mp_pool_get(connection_pool);
93 client_p->connection->since = CurrentTime;
94 client_p->connection->lasttime = CurrentTime;
95 client_p->connection->firsttime = CurrentTime;
96 client_p->connection->registration = REG_INIT;
97
98 /* as good a place as any... */
99 dlinkAdd(client_p, &client_p->connection->lclient_node, &unknown_list);
100 }
101 else
102 client_p->from = from;
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) == 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 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 *const 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, (uintmax_t)ConfigGeneral.kill_chase_time_limit);
501
502 if (!target_p)
503 {
504 sendto_one_numeric(source_p, &me, ERR_NOSUCHNICK, name);
505 return NULL;
506 }
507
508 return target_p;
509 }
510
511 /*
512 * get_client_name - Return the name of the client
513 * for various tracking and
514 * admin purposes. The main purpose of this function is to
515 * return the "socket host" name of the client, if that
516 * differs from the advertised name (other than case).
517 * But, this can be used to any client structure.
518 *
519 * NOTE 1:
520 * Watch out the allocation of "buf", if either source_p->name
521 * or source_p->sockhost gets changed into pointers instead of
522 * directly allocated within the structure...
523 *
524 * NOTE 2:
525 * Function return either a pointer to the structure (source_p) or
526 * to internal buffer (buf). *NEVER* use the returned pointer
527 * to modify what it points!!!
528 */
529 const char *
530 get_client_name(const struct Client *client_p, enum addr_mask_type type)
531 {
532 static char buf[HOSTLEN * 2 + USERLEN + 4]; /* +4 for [,@,],\0 */
533
534 if (!MyConnect(client_p))
535 return client_p->name;
536
537 if (IsServer(client_p) || IsConnecting(client_p) || IsHandshake(client_p))
538 {
539 if (!irccmp(client_p->name, client_p->host))
540 return client_p->name;
541 else if (ConfigServerHide.hide_server_ips)
542 type = MASK_IP;
543 }
544
545 /* And finally, let's get the host information, ip or name */
546 switch (type)
547 {
548 case SHOW_IP:
549 snprintf(buf, sizeof(buf), "%s[%s@%s]",
550 client_p->name,
551 client_p->username, client_p->sockhost);
552 break;
553 case MASK_IP:
554 if (client_p->connection->aftype == AF_INET)
555 snprintf(buf, sizeof(buf), "%s[%s@255.255.255.255]",
556 client_p->name, client_p->username);
557 else
558 snprintf(buf, sizeof(buf), "%s[%s@ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]",
559 client_p->name, client_p->username);
560 break;
561 default: /* HIDE_IP */
562 snprintf(buf, sizeof(buf), "%s[%s@%s]",
563 client_p->name,
564 client_p->username, client_p->host);
565 }
566
567 return buf;
568 }
569
570 void
571 free_exited_clients(void)
572 {
573 dlink_node *node = NULL, *node_next = NULL;
574
575 DLINK_FOREACH_SAFE(node, node_next, dead_list.head)
576 {
577 free_client(node->data);
578 dlinkDelete(node, &dead_list);
579 free_dlink_node(node);
580 }
581 }
582
583 /*
584 * Exit one client, local or remote. Assuming all dependents have
585 * been already removed, and socket closed for local client.
586 *
587 * The only messages generated are QUITs on channels.
588 */
589 static void
590 exit_one_client(struct Client *source_p, const char *comment)
591 {
592 dlink_node *node = NULL, *node_next = NULL;
593
594 assert(!IsMe(source_p));
595 assert(source_p != &me);
596
597 if (IsClient(source_p))
598 {
599 dlinkDelete(&source_p->lnode, &source_p->servptr->serv->client_list);
600 dlinkDelete(&source_p->node, &global_client_list);
601
602 /*
603 * If a person is on a channel, send a QUIT notice
604 * to every client (person) on the same channel (so
605 * that the client can show the "**signoff" message).
606 * (Note: The notice is to the local clients *only*)
607 */
608 sendto_common_channels_local(source_p, 0, 0, 0, ":%s!%s@%s QUIT :%s",
609 source_p->name, source_p->username,
610 source_p->host, comment);
611
612 DLINK_FOREACH_SAFE(node, node_next, source_p->channel.head)
613 remove_user_from_channel(node->data);
614
615 client_clear_svstags(source_p);
616
617 whowas_add_history(source_p, 0);
618 whowas_off_history(source_p);
619
620 watch_check_hash(source_p, RPL_LOGOFF);
621
622 if (MyConnect(source_p))
623 {
624 clear_invites_client(source_p);
625 del_all_accepts(source_p);
626 }
627 }
628 else if (IsServer(source_p))
629 {
630 dlinkDelete(&source_p->lnode, &source_p->servptr->serv->server_list);
631 dlinkDelete(&source_p->node, &global_client_list);
632
633 if ((node = dlinkFindDelete(&global_server_list, source_p)))
634 free_dlink_node(node);
635 }
636
637 /* Remove source_p from the client lists */
638 if (source_p->id[0])
639 hash_del_id(source_p);
640
641 if (source_p->name[0])
642 hash_del_client(source_p);
643
644 if (HasFlag(source_p, FLAGS_USERHOST))
645 userhost_del(source_p->username, source_p->host, !MyConnect(source_p));
646
647 update_client_exit_stats(source_p);
648
649 /* Check to see if the client isn't already on the dead list */
650 assert(dlinkFind(&dead_list, source_p) == NULL);
651
652 /* add to dead client dlist */
653 SetDead(source_p);
654 dlinkAdd(source_p, make_dlink_node(), &dead_list);
655 }
656
657 /*
658 * Remove all clients that depend on source_p; assumes all (S)QUITs have
659 * already been sent. we make sure to exit a server's dependent clients
660 * and servers before the server itself; exit_one_client takes care of
661 * actually removing things off llists. tweaked from +CSr31 -orabidoo
662 */
663 static void
664 recurse_remove_clients(struct Client *source_p, const char *comment)
665 {
666 dlink_node *node = NULL, *node_next = NULL;
667
668 DLINK_FOREACH_SAFE(node, node_next, source_p->serv->client_list.head)
669 exit_one_client(node->data, comment);
670
671 DLINK_FOREACH_SAFE(node, node_next, source_p->serv->server_list.head)
672 {
673 recurse_remove_clients(node->data, comment);
674 exit_one_client(node->data, comment);
675 }
676 }
677
678 /*
679 * exit_client - exit a client of any type. Generally, you can use
680 * this on any struct Client, regardless of its state.
681 *
682 * Note, you shouldn't exit remote _users_ without first doing
683 * AddFlag(x, FLAGS_KILLED) and propagating a kill or similar message.
684 *
685 * However, it is perfectly correct to call exit_client to force a _server_
686 * quit (either local or remote one).
687 *
688 *
689 * inputs: - a client pointer that is going to be exited
690 * output: none
691 * side effects: the client is delinked from all lists, disconnected,
692 * and the rest of IRC network is notified of the exit.
693 * Client memory is scheduled to be freed
694 */
695 void
696 exit_client(struct Client *source_p, const char *comment)
697 {
698 dlink_node *node = NULL;
699
700 assert(!IsMe(source_p));
701 assert(source_p != &me);
702
703 if (MyConnect(source_p))
704 {
705 /* DO NOT REMOVE. exit_client can be called twice after a failed
706 * read/write.
707 */
708 if (HasFlag(source_p, FLAGS_CLOSING))
709 return;
710
711 AddFlag(source_p, FLAGS_CLOSING);
712
713 if (HasFlag(source_p, FLAGS_IPHASH))
714 {
715 DelFlag(source_p, FLAGS_IPHASH);
716 ipcache_remove_address(&source_p->connection->ip);
717 }
718
719 delete_auth(&source_p->connection->auth);
720
721 if (IsClient(source_p))
722 {
723 assert(Count.local > 0);
724
725 --Count.local;
726
727 if (HasUMode(source_p, UMODE_OPER))
728 if ((node = dlinkFindDelete(&oper_list, source_p)))
729 free_dlink_node(node);
730
731 assert(dlinkFind(&local_client_list, source_p));
732 dlinkDelete(&source_p->connection->lclient_node, &local_client_list);
733
734 if (source_p->connection->list_task)
735 free_list_task(source_p);
736
737 watch_del_watch_list(source_p);
738
739 sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE,
740 "Client exiting: %s (%s@%s) [%s] [%s]",
741 source_p->name, source_p->username, source_p->host,
742 source_p->sockhost, comment);
743
744 ilog(LOG_TYPE_USER, "%s (%ju): %s!%s@%s %s %s %ju/%ju :%s",
745 date_ctime(source_p->connection->firsttime),
746 CurrentTime - source_p->connection->firsttime,
747 source_p->name, source_p->username, source_p->host,
748 source_p->sockhost, source_p->account,
749 source_p->connection->send.bytes >> 10,
750 source_p->connection->recv.bytes >> 10, source_p->info);
751 }
752 else if (IsServer(source_p))
753 {
754 assert(Count.myserver > 0);
755
756 --Count.myserver;
757
758 assert(dlinkFind(&local_server_list, source_p));
759 dlinkDelete(&source_p->connection->lclient_node, &local_server_list);
760 }
761 else
762 {
763 assert(dlinkFind(&unknown_list, source_p));
764 dlinkDelete(&source_p->connection->lclient_node, &unknown_list);
765 }
766
767 if (!IsDead(source_p))
768 {
769 if (IsServer(source_p))
770 {
771 if (!HasFlag(source_p, FLAGS_SQUIT))
772 {
773 /* for them, we are exiting the network */
774 sendto_one(source_p, ":%s SQUIT %s :%s",
775 me.id, me.id, comment);
776 }
777 }
778
779 sendto_one(source_p, "ERROR :Closing Link: %s (%s)",
780 source_p->host, comment);
781 }
782
783 close_connection(source_p);
784 }
785 else if (IsClient(source_p) && HasFlag(source_p->servptr, FLAGS_EOB))
786 sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
787 "Client exiting at %s: %s (%s@%s) [%s] [%s]",
788 source_p->servptr->name, source_p->name,
789 source_p->username, source_p->host, source_p->sockhost, comment);
790
791 if (IsServer(source_p))
792 {
793 char splitstr[HOSTLEN + HOSTLEN + 2] = "";
794
795 assert(source_p->serv);
796 assert(source_p->servptr);
797
798 if (ConfigServerHide.hide_servers)
799 /*
800 * Set netsplit message to "*.net *.split" to still show
801 * that its a split, but hide the servers splitting
802 */
803 strlcpy(splitstr, "*.net *.split", sizeof(splitstr));
804 else
805 snprintf(splitstr, sizeof(splitstr), "%s %s",
806 source_p->servptr->name, source_p->name);
807
808 /* Send SQUIT for source_p in every direction. source_p is already off of local_server_list here */
809 if (!HasFlag(source_p, FLAGS_SQUIT))
810 sendto_server(NULL, 0, 0, "SQUIT %s :%s", source_p->id, comment);
811
812 /* Now exit the clients internally */
813 recurse_remove_clients(source_p, splitstr);
814
815 if (MyConnect(source_p))
816 {
817 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
818 "%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 ilog(LOG_TYPE_IRCD, "%s was connected for %s. %ju/%ju sendK/recvK.",
823 source_p->name, time_dissect(CurrentTime - source_p->connection->firsttime),
824 source_p->connection->send.bytes >> 10,
825 source_p->connection->recv.bytes >> 10);
826 }
827 }
828 else if (IsClient(source_p) && !HasFlag(source_p, FLAGS_KILLED))
829 sendto_server(source_p->from, 0, 0, ":%s QUIT :%s",
830 source_p->id, comment);
831
832 /* The client *better* be off all of the lists */
833 assert(dlinkFind(&unknown_list, source_p) == NULL);
834 assert(dlinkFind(&local_client_list, source_p) == NULL);
835 assert(dlinkFind(&local_server_list, source_p) == NULL);
836 assert(dlinkFind(&oper_list, source_p) == NULL);
837
838 exit_one_client(source_p, comment);
839 }
840
841 /*
842 * dead_link_on_write - report a write error if not already dead,
843 * mark it as dead then exit it
844 */
845 void
846 dead_link_on_write(struct Client *client_p, int ierrno)
847 {
848 dlink_node *node;
849
850 if (IsDefunct(client_p))
851 return;
852
853 dbuf_clear(&client_p->connection->buf_recvq);
854 dbuf_clear(&client_p->connection->buf_sendq);
855
856 assert(dlinkFind(&abort_list, client_p) == NULL);
857 node = make_dlink_node();
858 /* don't let exit_aborted_clients() finish yet */
859 dlinkAddTail(client_p, node, &abort_list);
860
861 if (eac_next == NULL)
862 eac_next = node;
863
864 SetDead(client_p); /* You are dead my friend */
865 }
866
867 /*
868 * dead_link_on_read - report a read error if not already dead,
869 * mark it as dead then exit it
870 */
871 void
872 dead_link_on_read(struct Client *client_p, int error)
873 {
874 char errmsg[IRCD_BUFSIZE];
875 int current_error;
876
877 if (IsDefunct(client_p))
878 return;
879
880 dbuf_clear(&client_p->connection->buf_recvq);
881 dbuf_clear(&client_p->connection->buf_sendq);
882
883 current_error = get_sockerr(client_p->connection->fd.fd);
884
885 if (IsServer(client_p) || IsHandshake(client_p))
886 {
887 if (error == 0)
888 {
889 /* Admins get the real IP */
890 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
891 "Server %s closed the connection",
892 get_client_name(client_p, SHOW_IP));
893
894 /* Opers get a masked IP */
895 sendto_realops_flags(UMODE_SERVNOTICE, L_OPER, SEND_NOTICE,
896 "Server %s closed the connection",
897 get_client_name(client_p, MASK_IP));
898
899 ilog(LOG_TYPE_IRCD, "Server %s closed the connection",
900 get_client_name(client_p, SHOW_IP));
901 }
902 else
903 {
904 report_error(L_ADMIN, "Lost connection to %s: %s",
905 get_client_name(client_p, SHOW_IP), current_error);
906 report_error(L_OPER, "Lost connection to %s: %s",
907 get_client_name(client_p, MASK_IP), current_error);
908 }
909
910 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
911 "%s was connected for %s",
912 client_p->name, time_dissect(CurrentTime - client_p->connection->firsttime));
913 }
914
915 if (error == 0)
916 strlcpy(errmsg, "Remote host closed the connection",
917 sizeof(errmsg));
918 else
919 snprintf(errmsg, sizeof(errmsg), "Read error: %s",
920 strerror(current_error));
921
922 exit_client(client_p, errmsg);
923 }
924
925 void
926 exit_aborted_clients(void)
927 {
928 dlink_node *ptr;
929 struct Client *target_p;
930 const char *notice;
931
932 DLINK_FOREACH_SAFE(ptr, eac_next, abort_list.head)
933 {
934 target_p = ptr->data;
935 eac_next = ptr->next;
936
937 if (target_p == NULL)
938 {
939 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
940 "Warning: null client on abort_list!");
941 dlinkDelete(ptr, &abort_list);
942 free_dlink_node(ptr);
943 continue;
944 }
945
946 dlinkDelete(ptr, &abort_list);
947
948 if (HasFlag(target_p, FLAGS_SENDQEX))
949 notice = "Max SendQ exceeded";
950 else
951 notice = "Write error: connection closed";
952
953 exit_client(target_p, notice);
954 free_dlink_node(ptr);
955 }
956 }
957
958 /*
959 * accept processing, this adds a form of "caller ID" to ircd
960 *
961 * If a client puts themselves into "caller ID only" mode,
962 * only clients that match a client pointer they have put on
963 * the accept list will be allowed to message them.
964 *
965 * Diane Bruce, "Dianora" db@db.net
966 */
967
968 void
969 del_accept(struct split_nuh_item *accept_p, struct Client *client_p)
970 {
971 dlinkDelete(&accept_p->node, &client_p->connection->acceptlist);
972
973 xfree(accept_p->nickptr);
974 xfree(accept_p->userptr);
975 xfree(accept_p->hostptr);
976 xfree(accept_p);
977 }
978
979 struct split_nuh_item *
980 find_accept(const char *nick, const char *user,
981 const char *host, struct Client *client_p,
982 int (*cmpfunc)(const char *, const char *))
983 {
984 dlink_node *node = NULL;
985
986 DLINK_FOREACH(node, client_p->connection->acceptlist.head)
987 {
988 struct split_nuh_item *accept_p = node->data;
989
990 if (!cmpfunc(accept_p->nickptr, nick) &&
991 !cmpfunc(accept_p->userptr, user) &&
992 !cmpfunc(accept_p->hostptr, host))
993 return accept_p;
994 }
995
996 return NULL;
997 }
998
999 /* accept_message()
1000 *
1001 * inputs - pointer to source client
1002 * - pointer to target client
1003 * output - 1 if accept this message 0 if not
1004 * side effects - See if source is on target's allow list
1005 */
1006 int
1007 accept_message(struct Client *source,
1008 struct Client *target)
1009 {
1010 dlink_node *node = NULL;
1011
1012 if (HasFlag(source, FLAGS_SERVICE) ||
1013 (HasUMode(source, UMODE_OPER) && ConfigGeneral.opers_bypass_callerid))
1014 return 1;
1015
1016 if (source == target || find_accept(source->name, source->username,
1017 source->host, target, match))
1018 return 1;
1019
1020 if (!HasUMode(target, UMODE_CALLERID) && HasUMode(target, UMODE_SOFTCALLERID))
1021 DLINK_FOREACH(node, target->channel.head)
1022 if (IsMember(source, ((struct Membership *)node->data)->chptr))
1023 return 1;
1024
1025 return 0;
1026 }
1027
1028 /* del_all_accepts()
1029 *
1030 * inputs - pointer to exiting client
1031 * output - NONE
1032 * side effects - Walk through given clients acceptlist and remove all entries
1033 */
1034 void
1035 del_all_accepts(struct Client *client_p)
1036 {
1037 dlink_node *node = NULL, *node_next = NULL;
1038
1039 DLINK_FOREACH_SAFE(node, node_next, client_p->connection->acceptlist.head)
1040 del_accept(node->data, client_p);
1041 }
1042
1043 unsigned int
1044 client_get_idle_time(const struct Client *source_p,
1045 const struct Client *target_p)
1046 {
1047 unsigned int idle = 0;
1048 unsigned int min_idle = 0;
1049 unsigned int max_idle = 0;
1050 const struct ClassItem *const class = get_class_ptr(&target_p->connection->confs);
1051
1052 if (!(class->flags & CLASS_FLAGS_FAKE_IDLE) || target_p == source_p)
1053 return CurrentTime - target_p->connection->last_privmsg;
1054
1055 if (HasUMode(source_p, UMODE_OPER) &&
1056 !(class->flags & CLASS_FLAGS_HIDE_IDLE_FROM_OPERS))
1057 return CurrentTime - target_p->connection->last_privmsg;
1058
1059 min_idle = class->min_idle;
1060 max_idle = class->max_idle;
1061
1062 if (min_idle == max_idle)
1063 return min_idle;
1064
1065 if (class->flags & CLASS_FLAGS_RANDOM_IDLE)
1066 idle = genrand_int32();
1067 else
1068 idle = CurrentTime - target_p->connection->last_privmsg;
1069
1070 if (!max_idle)
1071 idle = 0;
1072 else
1073 idle %= max_idle;
1074
1075 if (idle < min_idle)
1076 idle = min_idle + (idle % (max_idle - min_idle));
1077
1078 return idle;
1079 }
1080
1081 /* client_init()
1082 *
1083 * inputs - NONE
1084 * output - NONE
1085 * side effects - initialize client free memory
1086 */
1087 void
1088 client_init(void)
1089 {
1090 static struct event event_ping =
1091 {
1092 .name = "check_pings",
1093 .handler = check_pings,
1094 .when = 5
1095 };
1096
1097 client_pool = mp_pool_new(sizeof(struct Client), MP_CHUNK_SIZE_CLIENT);
1098 connection_pool = mp_pool_new(sizeof(struct Connection), MP_CHUNK_SIZE_CONNECTION);
1099 event_add(&event_ping, NULL);
1100 }

Properties

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