ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/client.c
Revision: 7337
Committed: Sat Feb 20 18:11:30 2016 UTC (8 years, 1 month ago) by michael
Content type: text/x-csrc
File size: 31986 byte(s)
Log Message:
- client.c:exit_client(): improve user logging

File Contents

# User Rev Content
1 adx 30 /*
2 michael 2916 * ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3 adx 30 *
4 michael 7006 * Copyright (c) 1997-2016 ircd-hybrid development team
5 adx 30 *
6     * This program is free software; you can redistribute it and/or modify
7     * it under the terms of the GNU General Public License as published by
8     * the Free Software Foundation; either version 2 of the License, or
9     * (at your option) any later version.
10     *
11     * This program is distributed in the hope that it will be useful,
12     * but WITHOUT ANY WARRANTY; without even the implied warranty of
13     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14     * GNU General Public License for more details.
15     *
16     * You should have received a copy of the GNU General Public License
17     * along with this program; if not, write to the Free Software
18 michael 4565 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19 adx 30 * USA
20     */
21    
22 michael 2916 /*! \file client.c
23     * \brief Controls clients.
24     * \version $Id$
25     */
26    
27 adx 30 #include "stdinc.h"
28 michael 1011 #include "list.h"
29 adx 30 #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 michael 3324 #include "auth.h"
36 adx 30 #include "s_bsd.h"
37 michael 1309 #include "conf.h"
38 michael 7304 #include "conf_gecos.h"
39 michael 1309 #include "log.h"
40 michael 3347 #include "misc.h"
41     #include "server.h"
42 adx 30 #include "send.h"
43     #include "whowas.h"
44 michael 3347 #include "user.h"
45 adx 30 #include "memory.h"
46 michael 1654 #include "mempool.h"
47 adx 30 #include "hostmask.h"
48     #include "listener.h"
49     #include "userhost.h"
50 michael 876 #include "watch.h"
51 michael 1783 #include "rng_mt.h"
52 michael 2682 #include "parse.h"
53 michael 4325 #include "ipcache.h"
54 adx 30
55    
56 michael 4213 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 michael 4579 static mp_pool_t *client_pool, *connection_pool;
65 michael 4213 static dlink_list dead_list, abort_list;
66 adx 30 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 michael 4977 struct Client *const client_p = mp_pool_get(client_pool);
88 adx 30
89 michael 3235 if (!from)
90 adx 30 {
91 michael 5545 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 michael 4588 client_p->connection->registration = REG_INIT;
97 adx 30
98     /* as good a place as any... */
99 michael 4588 dlinkAdd(client_p, &client_p->connection->lclient_node, &unknown_list);
100 adx 30 }
101     else
102 michael 5545 client_p->from = from;
103 adx 30
104 michael 1360 client_p->idhnext = client_p;
105 michael 5545 client_p->hnext = client_p;
106 michael 2678 SetUnknown(client_p);
107 adx 30 strcpy(client_p->username, "unknown");
108 michael 5731 strcpy(client_p->account, "*");
109 adx 30
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 michael 1360 assert(client_p->idhnext == client_p);
126 adx 30 assert(client_p->channel.head == NULL);
127     assert(dlink_list_length(&client_p->channel) == 0);
128 michael 1360 assert(dlink_list_length(&client_p->whowas) == 0);
129 michael 5590 assert(dlink_list_length(&client_p->svstags) == 0);
130 adx 30
131 michael 7032 xfree(client_p->serv);
132     xfree(client_p->certfp);
133 adx 30
134     if (MyConnect(client_p))
135     {
136 michael 4588 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 michael 6470 assert(HasFlag(client_p, FLAGS_CLOSING) && IsDead(client_p));
140 adx 30
141     /*
142 michael 5589 * Clean up extra sockets from listen {} blocks which have been discarded.
143 adx 30 */
144 michael 4588 if (client_p->connection->listener)
145 adx 30 {
146 michael 4588 listener_release(client_p->connection->listener);
147     client_p->connection->listener = NULL;
148 adx 30 }
149    
150 michael 4588 dbuf_clear(&client_p->connection->buf_recvq);
151     dbuf_clear(&client_p->connection->buf_sendq);
152 adx 30
153 michael 4588 mp_pool_release(client_p->connection);
154 adx 30 }
155    
156 michael 1654 mp_pool_release(client_p);
157 adx 30 }
158    
159 michael 5551 void
160 michael 5555 client_attach_svstag(struct Client *client_p, unsigned int numeric,
161 michael 5558 const char *umodes, const char *const tag)
162 michael 5555 {
163 michael 5558 const struct user_modes *tab = NULL;
164 michael 5555
165 michael 5558 if (numeric >= ERR_LAST_ERR_MSG || *umodes != '+')
166 michael 5555 return;
167    
168 michael 7076 struct ServicesTag *svstag = xcalloc(sizeof(*svstag));
169 michael 5555 svstag->numeric = numeric;
170     svstag->tag = xstrdup(tag);
171    
172 michael 5558 for (const char *m = umodes + 1; *m; ++m)
173     if ((tab = umode_map[(unsigned char)*m]))
174     svstag->umodes |= tab->flag;
175    
176 michael 5555 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 michael 5551 client_clear_svstags(struct Client *client_p)
184     {
185 michael 7244 while (client_p->svstags.head)
186 michael 5551 {
187 michael 7244 struct ServicesTag *svstag = client_p->svstags.head->data;
188 michael 5551
189     dlinkDelete(&svstag->node, &client_p->svstags);
190 michael 7032 xfree(svstag->tag);
191     xfree(svstag);
192 michael 5551 }
193     }
194    
195 adx 30 /* check_pings_list()
196     *
197     * inputs - pointer to list to check
198     * output - NONE
199 michael 2345 * side effects -
200 adx 30 */
201     static void
202     check_pings_list(dlink_list *list)
203     {
204 michael 6961 char buf[32] = ""; /* 32 = sizeof("Ping timeout: 999999999 seconds") */
205 michael 7330 unsigned int ping = 0; /* ping time value from client */
206 michael 4800 dlink_node *node = NULL, *node_next = NULL;
207 adx 30
208 michael 4800 DLINK_FOREACH_SAFE(node, node_next, list->head)
209 adx 30 {
210 michael 4800 struct Client *client_p = node->data;
211 adx 30
212     if (IsDead(client_p))
213 michael 4214 continue; /* Ignore it, its been exited already */
214 adx 30
215 michael 6325 if (IsClient(client_p) || IsServer(client_p))
216     ping = get_client_ping(&client_p->connection->confs);
217     else
218 michael 1644 ping = CONNECTTIMEOUT;
219 adx 30
220 michael 4588 if (ping < CurrentTime - client_p->connection->lasttime)
221 adx 30 {
222 michael 6313 if (!HasFlag(client_p, FLAGS_PINGSENT))
223 adx 30 {
224 michael 2182 /*
225 michael 4298 * If we haven't PINGed the connection and we haven't
226 michael 2182 * heard from it in a while, PING it to make sure
227     * it is still alive.
228     */
229 michael 6313 AddFlag(client_p, FLAGS_PINGSENT);
230 michael 4588 client_p->connection->lasttime = CurrentTime - ping;
231 michael 2182 sendto_one(client_p, "PING :%s", ID_or_name(&me, client_p));
232 adx 30 }
233     else
234     {
235 michael 4588 if (CurrentTime - client_p->connection->lasttime >= 2 * ping)
236 adx 30 {
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 michael 2182 {
243 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
244 michael 2182 "No response from %s, closing link",
245 michael 6425 get_client_name(client_p, SHOW_IP));
246 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_OPER, SEND_NOTICE,
247 michael 2182 "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 michael 6425 get_client_name(client_p, SHOW_IP));
251 michael 2182 }
252 michael 650
253 michael 6854 snprintf(buf, sizeof(buf), "Ping timeout: %ji seconds",
254     (CurrentTime - client_p->connection->lasttime));
255 michael 4214 exit_client(client_p, buf);
256 adx 30 }
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 michael 4800 dlink_node *node = NULL, *node_next = NULL;
272 adx 30
273 michael 4800 DLINK_FOREACH_SAFE(node, node_next, unknown_list.head)
274 adx 30 {
275 michael 4800 struct Client *client_p = node->data;
276 adx 30
277 michael 650 /*
278     * Check UNKNOWN connections - if they have been in this state
279 adx 30 * for > 30s, close them.
280     */
281 michael 6470 if (HasFlag(client_p, FLAGS_FINISHED_AUTH) && (CurrentTime - client_p->connection->firsttime) > 30)
282 michael 3171 exit_client(client_p, "Registration timed out");
283 adx 30 }
284     }
285    
286 michael 4214 /*
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 michael 4439 check_pings(void *unused)
313 michael 4214 {
314     check_pings_list(&local_client_list);
315     check_pings_list(&local_server_list);
316     check_unknowns_list();
317     }
318    
319 adx 30 /* 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 michael 2345 void
327 adx 30 check_conf_klines(void)
328 michael 2345 {
329 michael 4800 dlink_node *node = NULL, *node_next = NULL;
330 michael 7304 void *ptr;
331 adx 30
332 michael 4800 DLINK_FOREACH_SAFE(node, node_next, local_client_list.head)
333 adx 30 {
334 michael 4800 struct Client *client_p = node->data;
335 adx 30
336 michael 4823 /* If a client is already being exited */
337 michael 4725 if (IsDead(client_p))
338 adx 30 continue;
339    
340 michael 7304 if ((ptr = find_conf_by_address(NULL, &client_p->connection->ip, CONF_DLINE,
341     client_p->connection->aftype, NULL, NULL, 1)))
342 adx 30 {
343 michael 7304 const struct MaskItem *conf = ptr;
344     conf_try_ban(client_p, CLIENT_BAN_DLINE, conf->reason);
345 michael 5732 continue; /* and go examine next Client */
346 adx 30 }
347    
348 michael 7304 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 adx 30 {
352 michael 7304 const struct MaskItem *conf = ptr;
353     conf_try_ban(client_p, CLIENT_BAN_KLINE, conf->reason);
354 michael 5732 continue; /* and go examine next Client */
355 adx 30 }
356    
357 michael 7304 if ((ptr = gecos_find(client_p->info, match)))
358 adx 30 {
359 michael 7304 const struct GecosItem *conf = ptr;
360     conf_try_ban(client_p, CLIENT_BAN_XLINE, conf->reason);
361 michael 5732 continue; /* and go examine next Client */
362 adx 30 }
363     }
364    
365 michael 5732 /* Also check the unknowns list for new dlines */
366 michael 4800 DLINK_FOREACH_SAFE(node, node_next, unknown_list.head)
367 adx 30 {
368 michael 4800 struct Client *client_p = node->data;
369 adx 30
370 michael 7304 if ((ptr = find_conf_by_address(NULL, &client_p->connection->ip, CONF_DLINE,
371     client_p->connection->aftype, NULL, NULL, 1)))
372 adx 30 {
373 michael 7304 const struct MaskItem *conf = ptr;
374     conf_try_ban(client_p, CLIENT_BAN_DLINE, conf->reason);
375 michael 5732 continue; /* and go examine next Client */
376 adx 30 }
377     }
378     }
379    
380     /*
381 michael 2813 * conf_try_ban
382 adx 30 *
383     * inputs - pointer to client to ban
384 michael 1632 * - pointer to MaskItem
385 adx 30 * output - NONE
386     * side effects - given client_p is banned
387     */
388 michael 2811 void
389 michael 7304 conf_try_ban(struct Client *client_p, int type, const char *reason)
390 adx 30 {
391 michael 6943 char ban_type = '?';
392 adx 30
393 michael 7304 switch (type)
394 adx 30 {
395 michael 7304 case CLIENT_BAN_KLINE:
396 michael 6313 if (HasFlag(client_p, FLAGS_EXEMPTKLINE))
397 michael 2811 {
398 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
399 michael 2811 "KLINE over-ruled for %s, client is kline_exempt",
400     get_client_name(client_p, HIDE_IP));
401     return;
402     }
403    
404 michael 5979 ban_type = 'K';
405 adx 30 break;
406 michael 7304 case CLIENT_BAN_DLINE:
407 michael 4588 if (find_conf_by_address(NULL, &client_p->connection->ip, CONF_EXEMPT,
408     client_p->connection->aftype, NULL, NULL, 1))
409 michael 3929 return;
410 michael 5979 ban_type = 'D';
411 adx 30 break;
412 michael 7304 case CLIENT_BAN_XLINE:
413 michael 6313 if (HasFlag(client_p, FLAGS_EXEMPTXLINE))
414 michael 5985 {
415 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
416 michael 5985 "XLINE over-ruled for %s, client is xline_exempt",
417     get_client_name(client_p, HIDE_IP));
418     return;
419     }
420 michael 6313
421 michael 5979 ban_type = 'X';
422 adx 30 break;
423     default:
424     assert(0);
425     break;
426     }
427    
428 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE, "%c-line active for %s",
429 michael 5979 ban_type, get_client_name(client_p, HIDE_IP));
430 adx 30
431     if (IsClient(client_p))
432 michael 7304 sendto_one_numeric(client_p, &me, ERR_YOUREBANNEDCREEP, reason);
433 adx 30
434 michael 7304 exit_client(client_p, reason);
435 adx 30 }
436    
437     /* update_client_exit_stats()
438     *
439     * input - pointer to client
440     * output - NONE
441 michael 2345 * side effects -
442 adx 30 */
443     static void
444     update_client_exit_stats(struct Client *client_p)
445     {
446 michael 1143 if (IsClient(client_p))
447 adx 30 {
448 michael 1013 assert(Count.total > 0);
449 michael 4999
450 adx 30 --Count.total;
451 michael 1219 if (HasUMode(client_p, UMODE_OPER))
452 adx 30 --Count.oper;
453 michael 1219 if (HasUMode(client_p, UMODE_INVISIBLE))
454 adx 30 --Count.invisi;
455     }
456 michael 1143 else if (IsServer(client_p))
457 michael 1618 sendto_realops_flags(UMODE_EXTERNAL, L_ALL, SEND_NOTICE,
458     "Server %s split from %s",
459 michael 1143 client_p->name, client_p->servptr->name);
460 adx 30 }
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 michael 3170 find_person(const struct Client *const source_p, const char *name)
470 adx 30 {
471 michael 2475 struct Client *target_p = NULL;
472 adx 30
473     if (IsDigit(*name))
474     {
475 michael 3207 if (IsServer(source_p->from))
476 michael 2586 target_p = hash_find_id(name);
477 adx 30 }
478     else
479 michael 2475 target_p = hash_find_client(name);
480 adx 30
481 michael 2475 return (target_p && IsClient(target_p)) ? target_p : NULL;
482 adx 30 }
483    
484     /*
485 michael 2475 * find_chasing - find the client structure for a nick name (name)
486 michael 2345 * using history mechanism if necessary. If the client is not found,
487 michael 3192 * an error message (NO SUCH NICK) is generated.
488 adx 30 */
489     struct Client *
490 michael 3192 find_chasing(struct Client *source_p, const char *name)
491 adx 30 {
492 michael 4884 struct Client *target_p = find_person(source_p, name);
493 adx 30
494 michael 4884 if (target_p)
495     return target_p;
496 adx 30
497 michael 2475 if (IsDigit(*name))
498 michael 1169 return NULL;
499 adx 30
500 michael 7330 target_p = whowas_get_history(name, (uintmax_t)ConfigGeneral.kill_chase_time_limit);
501 michael 4884
502     if (!target_p)
503 adx 30 {
504 michael 3109 sendto_one_numeric(source_p, &me, ERR_NOSUCHNICK, name);
505 michael 1169 return NULL;
506 adx 30 }
507    
508 michael 4884 return target_p;
509 adx 30 }
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 michael 4214 * Watch out the allocation of "buf", if either source_p->name
521 adx 30 * 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 michael 4214 * to internal buffer (buf). *NEVER* use the returned pointer
527 adx 30 * to modify what it points!!!
528     */
529     const char *
530 michael 3235 get_client_name(const struct Client *client_p, enum addr_mask_type type)
531 adx 30 {
532 michael 6963 static char buf[HOSTLEN * 2 + USERLEN + 4]; /* +4 for [,@,],\0 */
533 adx 30
534 michael 3235 if (!MyConnect(client_p))
535     return client_p->name;
536 adx 30
537 michael 3235 if (IsServer(client_p) || IsConnecting(client_p) || IsHandshake(client_p))
538 michael 1340 {
539 michael 3235 if (!irccmp(client_p->name, client_p->host))
540     return client_p->name;
541 michael 1340 else if (ConfigServerHide.hide_server_ips)
542 michael 1328 type = MASK_IP;
543 michael 1340 }
544 adx 30
545     /* And finally, let's get the host information, ip or name */
546 michael 1328 switch (type)
547 adx 30 {
548     case SHOW_IP:
549 michael 4214 snprintf(buf, sizeof(buf), "%s[%s@%s]",
550 michael 3235 client_p->name,
551     client_p->username, client_p->sockhost);
552 michael 1339 break;
553 adx 30 case MASK_IP:
554 michael 4588 if (client_p->connection->aftype == AF_INET)
555 michael 4214 snprintf(buf, sizeof(buf), "%s[%s@255.255.255.255]",
556 michael 3235 client_p->name, client_p->username);
557 michael 1339 else
558 michael 4214 snprintf(buf, sizeof(buf), "%s[%s@ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]",
559 michael 3235 client_p->name, client_p->username);
560 adx 30 break;
561 michael 6310 default: /* HIDE_IP */
562 michael 4214 snprintf(buf, sizeof(buf), "%s[%s@%s]",
563 michael 3235 client_p->name,
564     client_p->username, client_p->host);
565 adx 30 }
566    
567 michael 4214 return buf;
568 adx 30 }
569    
570     void
571     free_exited_clients(void)
572     {
573 michael 4800 dlink_node *node = NULL, *node_next = NULL;
574 michael 2345
575 michael 4800 DLINK_FOREACH_SAFE(node, node_next, dead_list.head)
576 adx 30 {
577 michael 4800 free_client(node->data);
578     dlinkDelete(node, &dead_list);
579     free_dlink_node(node);
580 adx 30 }
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 michael 4214 exit_one_client(struct Client *source_p, const char *comment)
591 adx 30 {
592 michael 4800 dlink_node *node = NULL, *node_next = NULL;
593 adx 30
594     assert(!IsMe(source_p));
595 michael 4214 assert(source_p != &me);
596 adx 30
597 michael 1118 if (IsClient(source_p))
598 adx 30 {
599 michael 3202 dlinkDelete(&source_p->lnode, &source_p->servptr->serv->client_list);
600 michael 4189 dlinkDelete(&source_p->node, &global_client_list);
601 adx 30
602 michael 1118 /*
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 michael 6774 sendto_common_channels_local(source_p, 0, 0, 0, ":%s!%s@%s QUIT :%s",
609 adx 30 source_p->name, source_p->username,
610 michael 4214 source_p->host, comment);
611 michael 4884
612 michael 4800 DLINK_FOREACH_SAFE(node, node_next, source_p->channel.head)
613     remove_user_from_channel(node->data);
614 adx 30
615 michael 6942 client_clear_svstags(source_p);
616    
617 michael 2300 whowas_add_history(source_p, 0);
618     whowas_off_history(source_p);
619 adx 30
620 michael 876 watch_check_hash(source_p, RPL_LOGOFF);
621    
622 michael 889 if (MyConnect(source_p))
623 adx 30 {
624 michael 5852 clear_invites_client(source_p);
625 michael 887 del_all_accepts(source_p);
626 michael 317 }
627 adx 30 }
628 michael 1118 else if (IsServer(source_p))
629     {
630     dlinkDelete(&source_p->lnode, &source_p->servptr->serv->server_list);
631 michael 4189 dlinkDelete(&source_p->node, &global_client_list);
632 adx 30
633 michael 4800 if ((node = dlinkFindDelete(&global_server_list, source_p)))
634     free_dlink_node(node);
635 michael 1118 }
636    
637 adx 30 /* Remove source_p from the client lists */
638 michael 3187 if (source_p->id[0])
639 adx 30 hash_del_id(source_p);
640 michael 4884
641 adx 30 if (source_p->name[0])
642     hash_del_client(source_p);
643    
644 michael 6313 if (HasFlag(source_p, FLAGS_USERHOST))
645 michael 6441 userhost_del(source_p->username, source_p->host, !MyConnect(source_p));
646 adx 30
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 michael 2345 /*
658 adx 30 * Remove all clients that depend on source_p; assumes all (S)QUITs have
659 michael 2345 * 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 adx 30 * actually removing things off llists. tweaked from +CSr31 -orabidoo
662     */
663     static void
664 michael 4214 recurse_remove_clients(struct Client *source_p, const char *comment)
665 adx 30 {
666 michael 4800 dlink_node *node = NULL, *node_next = NULL;
667 adx 30
668 michael 4800 DLINK_FOREACH_SAFE(node, node_next, source_p->serv->client_list.head)
669     exit_one_client(node->data, comment);
670 adx 30
671 michael 4800 DLINK_FOREACH_SAFE(node, node_next, source_p->serv->server_list.head)
672 adx 30 {
673 michael 4800 recurse_remove_clients(node->data, comment);
674     exit_one_client(node->data, comment);
675 adx 30 }
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 michael 1219 * AddFlag(x, FLAGS_KILLED) and propagating a kill or similar message.
684 michael 3171 *
685 michael 1219 * However, it is perfectly correct to call exit_client to force a _server_
686 adx 30 * quit (either local or remote one).
687     *
688 michael 3171 *
689 adx 30 * 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 michael 3171 exit_client(struct Client *source_p, const char *comment)
697 adx 30 {
698 michael 4800 dlink_node *node = NULL;
699 adx 30
700 michael 4214 assert(!IsMe(source_p));
701     assert(source_p != &me);
702    
703 adx 30 if (MyConnect(source_p))
704     {
705     /* DO NOT REMOVE. exit_client can be called twice after a failed
706     * read/write.
707     */
708 michael 6470 if (HasFlag(source_p, FLAGS_CLOSING))
709 adx 30 return;
710    
711 michael 6470 AddFlag(source_p, FLAGS_CLOSING);
712 adx 30
713 michael 4400 if (HasFlag(source_p, FLAGS_IPHASH))
714     {
715     DelFlag(source_p, FLAGS_IPHASH);
716 michael 4588 ipcache_remove_address(&source_p->connection->ip);
717 michael 4400 }
718 adx 30
719 michael 4588 delete_auth(&source_p->connection->auth);
720 adx 30
721 michael 6325 if (IsClient(source_p))
722 adx 30 {
723 michael 1013 assert(Count.local > 0);
724 michael 4999
725 michael 4884 --Count.local;
726 adx 30
727 michael 1219 if (HasUMode(source_p, UMODE_OPER))
728 michael 4800 if ((node = dlinkFindDelete(&oper_list, source_p)))
729     free_dlink_node(node);
730 adx 30
731 michael 1126 assert(dlinkFind(&local_client_list, source_p));
732 michael 4588 dlinkDelete(&source_p->connection->lclient_node, &local_client_list);
733 michael 1126
734 michael 4588 if (source_p->connection->list_task)
735 michael 3289 free_list_task(source_p);
736 adx 30
737 michael 876 watch_del_watch_list(source_p);
738 michael 5551
739 michael 1618 sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE,
740     "Client exiting: %s (%s@%s) [%s] [%s]",
741 michael 6853 source_p->name, source_p->username, source_p->host,
742     source_p->sockhost, comment);
743 michael 4884
744 michael 7337 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 michael 1247 source_p->name, source_p->username, source_p->host,
748 michael 7337 source_p->sockhost, source_p->account,
749     source_p->connection->send.bytes >> 10,
750     source_p->connection->recv.bytes >> 10, source_p->info);
751 adx 30 }
752 michael 1571 else if (IsServer(source_p))
753 adx 30 {
754 michael 1571 assert(Count.myserver > 0);
755 michael 4999
756 michael 1571 --Count.myserver;
757 adx 30
758 michael 4213 assert(dlinkFind(&local_server_list, source_p));
759 michael 4588 dlinkDelete(&source_p->connection->lclient_node, &local_server_list);
760 adx 30 }
761 michael 6325 else
762     {
763     assert(dlinkFind(&unknown_list, source_p));
764     dlinkDelete(&source_p->connection->lclient_node, &unknown_list);
765     }
766 adx 30
767     if (!IsDead(source_p))
768     {
769     if (IsServer(source_p))
770     {
771 michael 3171 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 michael 3186 me.id, me.id, comment);
776 michael 3171 }
777 adx 30 }
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 michael 1991 else if (IsClient(source_p) && HasFlag(source_p->servptr, FLAGS_EOB))
786 michael 1976 sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
787 michael 6853 "Client exiting at %s: %s (%s@%s) [%s] [%s]",
788 michael 1976 source_p->servptr->name, source_p->name,
789 michael 6853 source_p->username, source_p->host, source_p->sockhost, comment);
790 adx 30
791     if (IsServer(source_p))
792     {
793 michael 3171 char splitstr[HOSTLEN + HOSTLEN + 2] = "";
794 adx 30
795 michael 5590 assert(source_p->serv);
796     assert(source_p->servptr);
797 adx 30
798     if (ConfigServerHide.hide_servers)
799 michael 887 /*
800 michael 2345 * Set netsplit message to "*.net *.split" to still show
801 adx 30 * that its a split, but hide the servers splitting
802     */
803 michael 3171 strlcpy(splitstr, "*.net *.split", sizeof(splitstr));
804 adx 30 else
805     snprintf(splitstr, sizeof(splitstr), "%s %s",
806     source_p->servptr->name, source_p->name);
807    
808 michael 4213 /* Send SQUIT for source_p in every direction. source_p is already off of local_server_list here */
809 michael 3171 if (!HasFlag(source_p, FLAGS_SQUIT))
810 michael 4962 sendto_server(NULL, 0, 0, "SQUIT %s :%s", source_p->id, comment);
811 adx 30
812 michael 3171 /* Now exit the clients internally */
813     recurse_remove_clients(source_p, splitstr);
814    
815 michael 3247 if (MyConnect(source_p))
816 adx 30 {
817 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
818 michael 6782 "%s was connected for %s. %ju/%ju sendK/recvK.",
819 michael 6569 source_p->name, time_dissect(CurrentTime - source_p->connection->firsttime),
820 michael 4588 source_p->connection->send.bytes >> 10,
821     source_p->connection->recv.bytes >> 10);
822 michael 6782 ilog(LOG_TYPE_IRCD, "%s was connected for %s. %ju/%ju sendK/recvK.",
823 michael 6569 source_p->name, time_dissect(CurrentTime - source_p->connection->firsttime),
824 michael 5589 source_p->connection->send.bytes >> 10,
825     source_p->connection->recv.bytes >> 10);
826 adx 30 }
827     }
828 michael 1219 else if (IsClient(source_p) && !HasFlag(source_p, FLAGS_KILLED))
829 michael 4962 sendto_server(source_p->from, 0, 0, ":%s QUIT :%s",
830 michael 3186 source_p->id, comment);
831 adx 30
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 michael 4213 assert(dlinkFind(&local_server_list, source_p) == NULL);
836 adx 30 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 michael 4800 dlink_node *node;
849 adx 30
850     if (IsDefunct(client_p))
851     return;
852    
853 michael 4588 dbuf_clear(&client_p->connection->buf_recvq);
854     dbuf_clear(&client_p->connection->buf_sendq);
855 adx 30
856     assert(dlinkFind(&abort_list, client_p) == NULL);
857 michael 4800 node = make_dlink_node();
858 adx 30 /* don't let exit_aborted_clients() finish yet */
859 michael 4800 dlinkAddTail(client_p, node, &abort_list);
860 adx 30
861     if (eac_next == NULL)
862 michael 4800 eac_next = node;
863 adx 30
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 michael 2691 char errmsg[IRCD_BUFSIZE];
875 adx 30 int current_error;
876    
877     if (IsDefunct(client_p))
878     return;
879    
880 michael 4588 dbuf_clear(&client_p->connection->buf_recvq);
881     dbuf_clear(&client_p->connection->buf_sendq);
882 adx 30
883 michael 4588 current_error = get_sockerr(client_p->connection->fd.fd);
884 adx 30
885     if (IsServer(client_p) || IsHandshake(client_p))
886     {
887     if (error == 0)
888     {
889     /* Admins get the real IP */
890 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
891 michael 2182 "Server %s closed the connection",
892     get_client_name(client_p, SHOW_IP));
893 adx 30
894     /* Opers get a masked IP */
895 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_OPER, SEND_NOTICE,
896 michael 2182 "Server %s closed the connection",
897     get_client_name(client_p, MASK_IP));
898 adx 30
899 michael 1247 ilog(LOG_TYPE_IRCD, "Server %s closed the connection",
900 michael 2182 get_client_name(client_p, SHOW_IP));
901 adx 30 }
902     else
903     {
904 michael 617 report_error(L_ADMIN, "Lost connection to %s: %s",
905 michael 2182 get_client_name(client_p, SHOW_IP), current_error);
906 michael 617 report_error(L_OPER, "Lost connection to %s: %s",
907 michael 2182 get_client_name(client_p, MASK_IP), current_error);
908 adx 30 }
909    
910 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
911 michael 6569 "%s was connected for %s",
912     client_p->name, time_dissect(CurrentTime - client_p->connection->firsttime));
913 adx 30 }
914    
915     if (error == 0)
916     strlcpy(errmsg, "Remote host closed the connection",
917     sizeof(errmsg));
918     else
919 michael 1124 snprintf(errmsg, sizeof(errmsg), "Read error: %s",
920     strerror(current_error));
921 adx 30
922 michael 3171 exit_client(client_p, errmsg);
923 adx 30 }
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 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
940 adx 30 "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 michael 6313 if (HasFlag(target_p, FLAGS_SENDQEX))
949 adx 30 notice = "Max SendQ exceeded";
950     else
951     notice = "Write error: connection closed";
952    
953 michael 3171 exit_client(target_p, notice);
954 adx 30 free_dlink_node(ptr);
955     }
956     }
957    
958     /*
959     * accept processing, this adds a form of "caller ID" to ircd
960 michael 887 *
961 adx 30 * If a client puts themselves into "caller ID only" mode,
962 michael 887 * only clients that match a client pointer they have put on
963 adx 30 * the accept list will be allowed to message them.
964     *
965 michael 887 * Diane Bruce, "Dianora" db@db.net
966 adx 30 */
967    
968 michael 887 void
969 michael 4975 del_accept(struct split_nuh_item *accept_p, struct Client *client_p)
970 adx 30 {
971 michael 4975 dlinkDelete(&accept_p->node, &client_p->connection->acceptlist);
972 adx 30
973 michael 7032 xfree(accept_p->nickptr);
974     xfree(accept_p->userptr);
975     xfree(accept_p->hostptr);
976     xfree(accept_p);
977 michael 887 }
978 adx 30
979 michael 887 struct split_nuh_item *
980     find_accept(const char *nick, const char *user,
981 michael 2363 const char *host, struct Client *client_p,
982     int (*cmpfunc)(const char *, const char *))
983 michael 887 {
984 michael 4800 dlink_node *node = NULL;
985 adx 30
986 michael 4800 DLINK_FOREACH(node, client_p->connection->acceptlist.head)
987 adx 30 {
988 michael 4975 struct split_nuh_item *accept_p = node->data;
989 michael 887
990 michael 4975 if (!cmpfunc(accept_p->nickptr, nick) &&
991     !cmpfunc(accept_p->userptr, user) &&
992     !cmpfunc(accept_p->hostptr, host))
993     return accept_p;
994 adx 30 }
995    
996 michael 887 return NULL;
997 adx 30 }
998    
999 michael 887 /* accept_message()
1000 adx 30 *
1001 michael 887 * 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 adx 30 */
1006 michael 887 int
1007     accept_message(struct Client *source,
1008     struct Client *target)
1009 adx 30 {
1010 michael 4800 dlink_node *node = NULL;
1011 adx 30
1012 michael 5451 if (HasFlag(source, FLAGS_SERVICE) ||
1013     (HasUMode(source, UMODE_OPER) && ConfigGeneral.opers_bypass_callerid))
1014     return 1;
1015    
1016 michael 887 if (source == target || find_accept(source->name, source->username,
1017 michael 2363 source->host, target, match))
1018 michael 887 return 1;
1019 adx 30
1020 michael 4660 if (!HasUMode(target, UMODE_CALLERID) && HasUMode(target, UMODE_SOFTCALLERID))
1021 michael 4800 DLINK_FOREACH(node, target->channel.head)
1022     if (IsMember(source, ((struct Membership *)node->data)->chptr))
1023 michael 887 return 1;
1024 adx 30
1025 michael 887 return 0;
1026 adx 30 }
1027    
1028     /* del_all_accepts()
1029     *
1030 michael 887 * inputs - pointer to exiting client
1031     * output - NONE
1032     * side effects - Walk through given clients acceptlist and remove all entries
1033 adx 30 */
1034     void
1035     del_all_accepts(struct Client *client_p)
1036     {
1037 michael 4800 dlink_node *node = NULL, *node_next = NULL;
1038 adx 30
1039 michael 4800 DLINK_FOREACH_SAFE(node, node_next, client_p->connection->acceptlist.head)
1040     del_accept(node->data, client_p);
1041 adx 30 }
1042 michael 1783
1043     unsigned int
1044 michael 5545 client_get_idle_time(const struct Client *source_p,
1045     const struct Client *target_p)
1046 michael 1783 {
1047     unsigned int idle = 0;
1048     unsigned int min_idle = 0;
1049     unsigned int max_idle = 0;
1050 michael 4833 const struct ClassItem *const class = get_class_ptr(&target_p->connection->confs);
1051 michael 1783
1052 michael 1785 if (!(class->flags & CLASS_FLAGS_FAKE_IDLE) || target_p == source_p)
1053 michael 4588 return CurrentTime - target_p->connection->last_privmsg;
1054 michael 4884
1055 michael 1783 if (HasUMode(source_p, UMODE_OPER) &&
1056 michael 1785 !(class->flags & CLASS_FLAGS_HIDE_IDLE_FROM_OPERS))
1057 michael 4588 return CurrentTime - target_p->connection->last_privmsg;
1058 michael 1783
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 michael 4588 idle = CurrentTime - target_p->connection->last_privmsg;
1069 michael 1783
1070 michael 3235 if (!max_idle)
1071 michael 1783 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 michael 4214
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 michael 4579 connection_pool = mp_pool_new(sizeof(struct Connection), MP_CHUNK_SIZE_CONNECTION);
1099 michael 4214 event_add(&event_ping, NULL);
1100     }

Properties

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