ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/client.c
Revision: 7987
Committed: Tue Mar 14 00:28:58 2017 UTC (7 years ago) by michael
Content type: text/x-csrc
File size: 31362 byte(s)
Log Message:
- client.c: stylistic changes

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

Properties

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