ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/client.c
Revision: 7075
Committed: Wed Jan 20 11:47:29 2016 UTC (8 years, 2 months ago) by michael
Content type: text/x-csrc
File size: 31974 byte(s)
Log Message:
- Constifications; style cleanups in some places

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 7007 * 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 4564 * 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     #include "log.h"
39 michael 3347 #include "misc.h"
40     #include "server.h"
41 adx 30 #include "send.h"
42     #include "whowas.h"
43 michael 3347 #include "user.h"
44 adx 30 #include "memory.h"
45 michael 1654 #include "mempool.h"
46 adx 30 #include "hostmask.h"
47     #include "listener.h"
48     #include "userhost.h"
49 michael 876 #include "watch.h"
50 michael 1783 #include "rng_mt.h"
51 michael 2682 #include "parse.h"
52 michael 4326 #include "ipcache.h"
53 adx 30
54    
55 michael 4212 dlink_list listing_client_list;
56     dlink_list unknown_list;
57     dlink_list local_client_list;
58     dlink_list local_server_list;
59     dlink_list global_client_list;
60     dlink_list global_server_list;
61     dlink_list oper_list;
62    
63 michael 4578 static mp_pool_t *client_pool, *connection_pool;
64 michael 4212 static dlink_list dead_list, abort_list;
65 adx 30 static dlink_node *eac_next; /* next aborted client to exit */
66    
67    
68     /*
69     * make_client - create a new Client struct and set it to initial state.
70     *
71     * from == NULL, create local client (a client connected
72     * to a socket).
73     * WARNING: This leaves the client in a dangerous
74     * state where fd == -1, dead flag is not set and
75     * the client is on the unknown_list; therefore,
76     * the first thing to do after calling make_client(NULL)
77     * is setting fd to something reasonable. -adx
78     *
79     * from, create remote client (behind a socket
80     * associated with the client defined by
81     * 'from'). ('from' is a local client!!).
82     */
83     struct Client *
84     make_client(struct Client *from)
85     {
86 michael 4976 struct Client *const client_p = mp_pool_get(client_pool);
87 adx 30
88 michael 3235 if (!from)
89 adx 30 {
90 michael 5546 client_p->from = client_p; /* 'from' of local client is self! */
91     client_p->connection = mp_pool_get(connection_pool);
92     client_p->connection->since = CurrentTime;
93     client_p->connection->lasttime = CurrentTime;
94     client_p->connection->firsttime = CurrentTime;
95 michael 4589 client_p->connection->registration = REG_INIT;
96 adx 30
97     /* as good a place as any... */
98 michael 4589 dlinkAdd(client_p, &client_p->connection->lclient_node, &unknown_list);
99 adx 30 }
100     else
101 michael 5546 client_p->from = from;
102 adx 30
103 michael 1360 client_p->idhnext = client_p;
104 michael 5546 client_p->hnext = client_p;
105 michael 2678 SetUnknown(client_p);
106 adx 30 strcpy(client_p->username, "unknown");
107 michael 5730 strcpy(client_p->account, "*");
108 adx 30
109     return client_p;
110     }
111    
112     /*
113     * free_client
114     *
115     * inputs - pointer to client
116     * output - NONE
117     * side effects - client pointed to has its memory freed
118     */
119     static void
120     free_client(struct Client *client_p)
121     {
122     assert(client_p != &me);
123     assert(client_p->hnext == client_p);
124 michael 1360 assert(client_p->idhnext == client_p);
125 adx 30 assert(client_p->channel.head == NULL);
126     assert(dlink_list_length(&client_p->channel) == 0);
127 michael 1360 assert(dlink_list_length(&client_p->whowas) == 0);
128 michael 5591 assert(dlink_list_length(&client_p->svstags) == 0);
129 adx 30
130 michael 7033 xfree(client_p->serv);
131     xfree(client_p->certfp);
132 adx 30
133     if (MyConnect(client_p))
134     {
135 michael 4589 assert(client_p->connection->invited.head == NULL);
136     assert(dlink_list_length(&client_p->connection->invited) == 0);
137     assert(dlink_list_length(&client_p->connection->watches) == 0);
138 michael 6471 assert(HasFlag(client_p, FLAGS_CLOSING) && IsDead(client_p));
139 adx 30
140     /*
141 michael 5588 * Clean up extra sockets from listen {} blocks which have been discarded.
142 adx 30 */
143 michael 4589 if (client_p->connection->listener)
144 adx 30 {
145 michael 4589 listener_release(client_p->connection->listener);
146     client_p->connection->listener = NULL;
147 adx 30 }
148    
149 michael 4589 dbuf_clear(&client_p->connection->buf_recvq);
150     dbuf_clear(&client_p->connection->buf_sendq);
151 adx 30
152 michael 4589 mp_pool_release(client_p->connection);
153 adx 30 }
154    
155 michael 1654 mp_pool_release(client_p);
156 adx 30 }
157    
158 michael 5559 void
159     client_attach_svstag(struct Client *client_p, unsigned int numeric,
160     const char *umodes, const char *const tag)
161     {
162     const struct user_modes *tab = NULL;
163    
164     if (numeric >= ERR_LAST_ERR_MSG || *umodes != '+')
165     return;
166    
167 michael 7075 struct ServicesTag *svstag = xcalloc(sizeof(*svstag));
168 michael 5559 svstag->numeric = numeric;
169     svstag->tag = xstrdup(tag);
170    
171     for (const char *m = umodes + 1; *m; ++m)
172     if ((tab = umode_map[(unsigned char)*m]))
173     svstag->umodes |= tab->flag;
174    
175     if (numeric != RPL_WHOISOPERATOR)
176     dlinkAddTail(svstag, &svstag->node, &client_p->svstags);
177     else
178     dlinkAdd(svstag, &svstag->node, &client_p->svstags);
179     }
180    
181     void
182     client_clear_svstags(struct Client *client_p)
183     {
184     dlink_node *node = NULL, *node_next = NULL;
185    
186     DLINK_FOREACH_SAFE(node, node_next, client_p->svstags.head)
187     {
188     struct ServicesTag *svstag = node->data;
189    
190     dlinkDelete(&svstag->node, &client_p->svstags);
191 michael 7033 xfree(svstag->tag);
192     xfree(svstag);
193 michael 5559 }
194     }
195    
196 adx 30 /* check_pings_list()
197     *
198     * inputs - pointer to list to check
199     * output - NONE
200 michael 2345 * side effects -
201 adx 30 */
202     static void
203     check_pings_list(dlink_list *list)
204     {
205 michael 6960 char buf[32] = ""; /* 32 = sizeof("Ping timeout: 999999999 seconds") */
206 michael 1644 int ping = 0; /* ping time value from client */
207 michael 4801 dlink_node *node = NULL, *node_next = NULL;
208 adx 30
209 michael 4801 DLINK_FOREACH_SAFE(node, node_next, list->head)
210 adx 30 {
211 michael 4801 struct Client *client_p = node->data;
212 adx 30
213     if (IsDead(client_p))
214 michael 4215 continue; /* Ignore it, its been exited already */
215 adx 30
216 michael 6326 if (IsClient(client_p) || IsServer(client_p))
217     ping = get_client_ping(&client_p->connection->confs);
218     else
219 michael 1644 ping = CONNECTTIMEOUT;
220 adx 30
221 michael 4589 if (ping < CurrentTime - client_p->connection->lasttime)
222 adx 30 {
223 michael 6314 if (!HasFlag(client_p, FLAGS_PINGSENT))
224 adx 30 {
225 michael 2182 /*
226 michael 4299 * If we haven't PINGed the connection and we haven't
227 michael 2182 * heard from it in a while, PING it to make sure
228     * it is still alive.
229     */
230 michael 6314 AddFlag(client_p, FLAGS_PINGSENT);
231 michael 4589 client_p->connection->lasttime = CurrentTime - ping;
232 michael 2182 sendto_one(client_p, "PING :%s", ID_or_name(&me, client_p));
233 adx 30 }
234     else
235     {
236 michael 4589 if (CurrentTime - client_p->connection->lasttime >= 2 * ping)
237 adx 30 {
238     /*
239     * If the client/server hasn't talked to us in 2*ping seconds
240     * and it has a ping time, then close its connection.
241     */
242     if (IsServer(client_p) || IsHandshake(client_p))
243 michael 2182 {
244 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
245 michael 2182 "No response from %s, closing link",
246 michael 6426 get_client_name(client_p, SHOW_IP));
247 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_OPER, SEND_NOTICE,
248 michael 2182 "No response from %s, closing link",
249     get_client_name(client_p, MASK_IP));
250     ilog(LOG_TYPE_IRCD, "No response from %s, closing link",
251 michael 6426 get_client_name(client_p, SHOW_IP));
252 michael 2182 }
253 michael 650
254 michael 6855 snprintf(buf, sizeof(buf), "Ping timeout: %ji seconds",
255     (CurrentTime - client_p->connection->lasttime));
256 michael 4215 exit_client(client_p, buf);
257 adx 30 }
258     }
259     }
260     }
261     }
262    
263     /* check_unknowns_list()
264     *
265     * inputs - pointer to list of unknown clients
266     * output - NONE
267     * side effects - unknown clients get marked for termination after n seconds
268     */
269     static void
270     check_unknowns_list(void)
271     {
272 michael 4801 dlink_node *node = NULL, *node_next = NULL;
273 adx 30
274 michael 4801 DLINK_FOREACH_SAFE(node, node_next, unknown_list.head)
275 adx 30 {
276 michael 4801 struct Client *client_p = node->data;
277 adx 30
278 michael 650 /*
279     * Check UNKNOWN connections - if they have been in this state
280 adx 30 * for > 30s, close them.
281     */
282 michael 6471 if (HasFlag(client_p, FLAGS_FINISHED_AUTH) && (CurrentTime - client_p->connection->firsttime) > 30)
283 michael 3171 exit_client(client_p, "Registration timed out");
284 adx 30 }
285     }
286    
287 michael 4215 /*
288     * check_pings - go through the local client list and check activity
289     * kill off stuff that should die
290     *
291     * inputs - NOT USED (from event)
292     * output - next time_t when check_pings() should be called again
293     * side effects -
294     *
295     *
296     * A PING can be sent to clients as necessary.
297     *
298     * Client/Server ping outs are handled.
299     */
300    
301     /*
302     * Addon from adrian. We used to call this after nextping seconds,
303     * however I've changed it to run once a second. This is only for
304     * PING timeouts, not K/etc-line checks (thanks dianora!). Having it
305     * run once a second makes life a lot easier - when a new client connects
306     * and they need a ping in 4 seconds, if nextping was set to 20 seconds
307     * we end up waiting 20 seconds. This is stupid. :-)
308     * I will optimise (hah!) check_pings() once I've finished working on
309     * tidying up other network IO evilnesses.
310     * -- adrian
311     */
312    
313     static void
314 michael 4438 check_pings(void *unused)
315 michael 4215 {
316     check_pings_list(&local_client_list);
317     check_pings_list(&local_server_list);
318     check_unknowns_list();
319     }
320    
321 adx 30 /* check_conf_klines()
322     *
323     * inputs - NONE
324     * output - NONE
325     * side effects - Check all connections for a pending kline against the
326     * client, exit the client if a kline matches.
327     */
328 michael 2345 void
329 adx 30 check_conf_klines(void)
330 michael 2345 {
331 michael 1632 struct MaskItem *conf = NULL;
332 michael 4801 dlink_node *node = NULL, *node_next = NULL;
333 adx 30
334 michael 4801 DLINK_FOREACH_SAFE(node, node_next, local_client_list.head)
335 adx 30 {
336 michael 4801 struct Client *client_p = node->data;
337 adx 30
338 michael 4824 /* If a client is already being exited */
339 michael 4726 if (IsDead(client_p))
340 adx 30 continue;
341    
342 michael 4589 if ((conf = find_conf_by_address(NULL, &client_p->connection->ip, CONF_DLINE,
343     client_p->connection->aftype, NULL, NULL, 1)))
344 adx 30 {
345 michael 2813 conf_try_ban(client_p, conf);
346 michael 5733 continue; /* and go examine next Client */
347 adx 30 }
348    
349 michael 4589 if ((conf = find_conf_by_address(client_p->host, &client_p->connection->ip,
350     CONF_KLINE, client_p->connection->aftype,
351 michael 2739 client_p->username, NULL, 1)))
352 adx 30 {
353 michael 2813 conf_try_ban(client_p, conf);
354 michael 5733 continue; /* and go examine next Client */
355 adx 30 }
356    
357 michael 5751 if ((conf = find_matching_name_conf(CONF_XLINE, client_p->info,
358 michael 1921 NULL, NULL, 0)))
359 adx 30 {
360 michael 2813 conf_try_ban(client_p, conf);
361 michael 5733 continue; /* and go examine next Client */
362 adx 30 }
363     }
364    
365 michael 5733 /* Also check the unknowns list for new dlines */
366 michael 4801 DLINK_FOREACH_SAFE(node, node_next, unknown_list.head)
367 adx 30 {
368 michael 4801 struct Client *client_p = node->data;
369 adx 30
370 michael 4589 if ((conf = find_conf_by_address(NULL, &client_p->connection->ip, CONF_DLINE,
371     client_p->connection->aftype, NULL, NULL, 1)))
372 adx 30 {
373 michael 3930 conf_try_ban(client_p, conf);
374 michael 5733 continue; /* and go examine next Client */
375 adx 30 }
376     }
377     }
378    
379     /*
380 michael 2813 * conf_try_ban
381 adx 30 *
382     * inputs - pointer to client to ban
383 michael 1632 * - pointer to MaskItem
384 adx 30 * output - NONE
385     * side effects - given client_p is banned
386     */
387 michael 2811 void
388 michael 2813 conf_try_ban(struct Client *client_p, struct MaskItem *conf)
389 adx 30 {
390 michael 6944 char ban_type = '?';
391 adx 30
392     switch (conf->type)
393     {
394 michael 1632 case CONF_KLINE:
395 michael 6314 if (HasFlag(client_p, FLAGS_EXEMPTKLINE))
396 michael 2811 {
397 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
398 michael 2811 "KLINE over-ruled for %s, client is kline_exempt",
399     get_client_name(client_p, HIDE_IP));
400     return;
401     }
402    
403 michael 5978 ban_type = 'K';
404 adx 30 break;
405 michael 1632 case CONF_DLINE:
406 michael 4589 if (find_conf_by_address(NULL, &client_p->connection->ip, CONF_EXEMPT,
407     client_p->connection->aftype, NULL, NULL, 1))
408 michael 3930 return;
409 michael 5978 ban_type = 'D';
410 adx 30 break;
411 michael 1632 case CONF_XLINE:
412 michael 6314 if (HasFlag(client_p, FLAGS_EXEMPTXLINE))
413 michael 5986 {
414 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
415 michael 5986 "XLINE over-ruled for %s, client is xline_exempt",
416     get_client_name(client_p, HIDE_IP));
417     return;
418     }
419 michael 6314
420 michael 5978 ban_type = 'X';
421 michael 1632 ++conf->count;
422 adx 30 break;
423     default:
424     assert(0);
425     break;
426     }
427    
428 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE, "%c-line active for %s",
429 michael 5978 ban_type, get_client_name(client_p, HIDE_IP));
430 adx 30
431     if (IsClient(client_p))
432 michael 5978 sendto_one_numeric(client_p, &me, ERR_YOUREBANNEDCREEP, conf->reason);
433 adx 30
434 michael 5978 exit_client(client_p, conf->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 4998
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 4883 struct Client *target_p = find_person(source_p, name);
493 adx 30
494 michael 4883 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 4883 target_p = whowas_get_history(name, (time_t)ConfigGeneral.kill_chase_time_limit);
501    
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 4883 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 4215 * 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 4215 * 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 6962 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 4215 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 4589 if (client_p->connection->aftype == AF_INET)
555 michael 4215 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 4215 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 6309 default: /* HIDE_IP */
562 michael 4215 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 4215 return buf;
568 adx 30 }
569    
570     void
571     free_exited_clients(void)
572     {
573 michael 4801 dlink_node *node = NULL, *node_next = NULL;
574 michael 2345
575 michael 4801 DLINK_FOREACH_SAFE(node, node_next, dead_list.head)
576 adx 30 {
577 michael 4801 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 4215 exit_one_client(struct Client *source_p, const char *comment)
591 adx 30 {
592 michael 4801 dlink_node *node = NULL, *node_next = NULL;
593 adx 30
594     assert(!IsMe(source_p));
595 michael 4215 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 4188 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 6775 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 4215 source_p->host, comment);
611 michael 4883
612 michael 4801 DLINK_FOREACH_SAFE(node, node_next, source_p->channel.head)
613     remove_user_from_channel(node->data);
614 adx 30
615 michael 6941 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 5851 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 4188 dlinkDelete(&source_p->node, &global_client_list);
632 adx 30
633 michael 4801 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 4883
641 adx 30 if (source_p->name[0])
642     hash_del_client(source_p);
643    
644 michael 6314 if (HasFlag(source_p, FLAGS_USERHOST))
645 michael 6442 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 4215 recurse_remove_clients(struct Client *source_p, const char *comment)
665 adx 30 {
666 michael 4801 dlink_node *node = NULL, *node_next = NULL;
667 adx 30
668 michael 4801 DLINK_FOREACH_SAFE(node, node_next, source_p->serv->client_list.head)
669     exit_one_client(node->data, comment);
670 adx 30
671 michael 4801 DLINK_FOREACH_SAFE(node, node_next, source_p->serv->server_list.head)
672 adx 30 {
673 michael 4801 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 4801 dlink_node *node = NULL;
699 adx 30
700 michael 4215 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 6471 if (HasFlag(source_p, FLAGS_CLOSING))
709 adx 30 return;
710    
711 michael 6471 AddFlag(source_p, FLAGS_CLOSING);
712 adx 30
713 michael 4401 if (HasFlag(source_p, FLAGS_IPHASH))
714     {
715     DelFlag(source_p, FLAGS_IPHASH);
716 michael 4589 ipcache_remove_address(&source_p->connection->ip);
717 michael 4401 }
718 adx 30
719 michael 4589 delete_auth(&source_p->connection->auth);
720 adx 30
721 michael 6326 if (IsClient(source_p))
722 adx 30 {
723 michael 4589 time_t on_for = CurrentTime - source_p->connection->firsttime;
724 michael 4883
725 michael 1013 assert(Count.local > 0);
726 michael 4998
727 michael 4883 --Count.local;
728 adx 30
729 michael 1219 if (HasUMode(source_p, UMODE_OPER))
730 michael 4801 if ((node = dlinkFindDelete(&oper_list, source_p)))
731     free_dlink_node(node);
732 adx 30
733 michael 1126 assert(dlinkFind(&local_client_list, source_p));
734 michael 4589 dlinkDelete(&source_p->connection->lclient_node, &local_client_list);
735 michael 1126
736 michael 4589 if (source_p->connection->list_task)
737 michael 3289 free_list_task(source_p);
738 adx 30
739 michael 876 watch_del_watch_list(source_p);
740 michael 5559
741 michael 1618 sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE,
742     "Client exiting: %s (%s@%s) [%s] [%s]",
743 michael 6852 source_p->name, source_p->username, source_p->host,
744     source_p->sockhost, comment);
745 michael 4883
746 michael 6781 ilog(LOG_TYPE_USER, "%s (%3u:%02u:%02u): %s!%s@%s %ju/%ju",
747 michael 6512 date_ctime(source_p->connection->firsttime), (unsigned int)(on_for / 3600),
748 michael 1247 (unsigned int)((on_for % 3600)/60), (unsigned int)(on_for % 60),
749     source_p->name, source_p->username, source_p->host,
750 michael 4589 source_p->connection->send.bytes>>10,
751     source_p->connection->recv.bytes>>10);
752 adx 30 }
753 michael 1571 else if (IsServer(source_p))
754 adx 30 {
755 michael 1571 assert(Count.myserver > 0);
756 michael 4998
757 michael 1571 --Count.myserver;
758 adx 30
759 michael 4212 assert(dlinkFind(&local_server_list, source_p));
760 michael 4589 dlinkDelete(&source_p->connection->lclient_node, &local_server_list);
761 adx 30 }
762 michael 6326 else
763     {
764     assert(dlinkFind(&unknown_list, source_p));
765     dlinkDelete(&source_p->connection->lclient_node, &unknown_list);
766     }
767 adx 30
768     if (!IsDead(source_p))
769     {
770     if (IsServer(source_p))
771     {
772 michael 3171 if (!HasFlag(source_p, FLAGS_SQUIT))
773     {
774     /* for them, we are exiting the network */
775     sendto_one(source_p, ":%s SQUIT %s :%s",
776 michael 3186 me.id, me.id, comment);
777 michael 3171 }
778 adx 30 }
779    
780     sendto_one(source_p, "ERROR :Closing Link: %s (%s)",
781     source_p->host, comment);
782     }
783    
784     close_connection(source_p);
785     }
786 michael 1991 else if (IsClient(source_p) && HasFlag(source_p->servptr, FLAGS_EOB))
787 michael 1976 sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
788 michael 6852 "Client exiting at %s: %s (%s@%s) [%s] [%s]",
789 michael 1976 source_p->servptr->name, source_p->name,
790 michael 6852 source_p->username, source_p->host, source_p->sockhost, comment);
791 adx 30
792     if (IsServer(source_p))
793     {
794 michael 3171 char splitstr[HOSTLEN + HOSTLEN + 2] = "";
795 adx 30
796 michael 5591 assert(source_p->serv);
797     assert(source_p->servptr);
798 adx 30
799     if (ConfigServerHide.hide_servers)
800 michael 887 /*
801 michael 2345 * Set netsplit message to "*.net *.split" to still show
802 adx 30 * that its a split, but hide the servers splitting
803     */
804 michael 3171 strlcpy(splitstr, "*.net *.split", sizeof(splitstr));
805 adx 30 else
806     snprintf(splitstr, sizeof(splitstr), "%s %s",
807     source_p->servptr->name, source_p->name);
808    
809 michael 4212 /* Send SQUIT for source_p in every direction. source_p is already off of local_server_list here */
810 michael 3171 if (!HasFlag(source_p, FLAGS_SQUIT))
811 michael 4963 sendto_server(NULL, 0, 0, "SQUIT %s :%s", source_p->id, comment);
812 adx 30
813 michael 3171 /* Now exit the clients internally */
814     recurse_remove_clients(source_p, splitstr);
815    
816 michael 3247 if (MyConnect(source_p))
817 adx 30 {
818 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
819 michael 6781 "%s was connected for %s. %ju/%ju sendK/recvK.",
820 michael 6570 source_p->name, time_dissect(CurrentTime - source_p->connection->firsttime),
821 michael 4589 source_p->connection->send.bytes >> 10,
822     source_p->connection->recv.bytes >> 10);
823 michael 6781 ilog(LOG_TYPE_IRCD, "%s was connected for %s. %ju/%ju sendK/recvK.",
824 michael 6570 source_p->name, time_dissect(CurrentTime - source_p->connection->firsttime),
825 michael 5588 source_p->connection->send.bytes >> 10,
826     source_p->connection->recv.bytes >> 10);
827 adx 30 }
828     }
829 michael 1219 else if (IsClient(source_p) && !HasFlag(source_p, FLAGS_KILLED))
830 michael 4963 sendto_server(source_p->from, 0, 0, ":%s QUIT :%s",
831 michael 3186 source_p->id, comment);
832 adx 30
833     /* The client *better* be off all of the lists */
834     assert(dlinkFind(&unknown_list, source_p) == NULL);
835     assert(dlinkFind(&local_client_list, source_p) == NULL);
836 michael 4212 assert(dlinkFind(&local_server_list, source_p) == NULL);
837 adx 30 assert(dlinkFind(&oper_list, source_p) == NULL);
838    
839     exit_one_client(source_p, comment);
840     }
841    
842     /*
843     * dead_link_on_write - report a write error if not already dead,
844     * mark it as dead then exit it
845     */
846     void
847     dead_link_on_write(struct Client *client_p, int ierrno)
848     {
849 michael 4801 dlink_node *node;
850 adx 30
851     if (IsDefunct(client_p))
852     return;
853    
854 michael 4589 dbuf_clear(&client_p->connection->buf_recvq);
855     dbuf_clear(&client_p->connection->buf_sendq);
856 adx 30
857     assert(dlinkFind(&abort_list, client_p) == NULL);
858 michael 4801 node = make_dlink_node();
859 adx 30 /* don't let exit_aborted_clients() finish yet */
860 michael 4801 dlinkAddTail(client_p, node, &abort_list);
861 adx 30
862     if (eac_next == NULL)
863 michael 4801 eac_next = node;
864 adx 30
865     SetDead(client_p); /* You are dead my friend */
866     }
867    
868     /*
869     * dead_link_on_read - report a read error if not already dead,
870     * mark it as dead then exit it
871     */
872     void
873     dead_link_on_read(struct Client *client_p, int error)
874     {
875 michael 2691 char errmsg[IRCD_BUFSIZE];
876 adx 30 int current_error;
877    
878     if (IsDefunct(client_p))
879     return;
880    
881 michael 4589 dbuf_clear(&client_p->connection->buf_recvq);
882     dbuf_clear(&client_p->connection->buf_sendq);
883 adx 30
884 michael 4589 current_error = get_sockerr(client_p->connection->fd.fd);
885 adx 30
886     if (IsServer(client_p) || IsHandshake(client_p))
887     {
888     if (error == 0)
889     {
890     /* Admins get the real IP */
891 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
892 michael 2182 "Server %s closed the connection",
893     get_client_name(client_p, SHOW_IP));
894 adx 30
895     /* Opers get a masked IP */
896 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_OPER, SEND_NOTICE,
897 michael 2182 "Server %s closed the connection",
898     get_client_name(client_p, MASK_IP));
899 adx 30
900 michael 1247 ilog(LOG_TYPE_IRCD, "Server %s closed the connection",
901 michael 2182 get_client_name(client_p, SHOW_IP));
902 adx 30 }
903     else
904     {
905 michael 617 report_error(L_ADMIN, "Lost connection to %s: %s",
906 michael 2182 get_client_name(client_p, SHOW_IP), current_error);
907 michael 617 report_error(L_OPER, "Lost connection to %s: %s",
908 michael 2182 get_client_name(client_p, MASK_IP), current_error);
909 adx 30 }
910    
911 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
912 michael 6570 "%s was connected for %s",
913     client_p->name, time_dissect(CurrentTime - client_p->connection->firsttime));
914 adx 30 }
915    
916     if (error == 0)
917     strlcpy(errmsg, "Remote host closed the connection",
918     sizeof(errmsg));
919     else
920 michael 1124 snprintf(errmsg, sizeof(errmsg), "Read error: %s",
921     strerror(current_error));
922 adx 30
923 michael 3171 exit_client(client_p, errmsg);
924 adx 30 }
925    
926     void
927     exit_aborted_clients(void)
928     {
929     dlink_node *ptr;
930     struct Client *target_p;
931     const char *notice;
932    
933     DLINK_FOREACH_SAFE(ptr, eac_next, abort_list.head)
934     {
935     target_p = ptr->data;
936     eac_next = ptr->next;
937    
938     if (target_p == NULL)
939     {
940 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
941 adx 30 "Warning: null client on abort_list!");
942     dlinkDelete(ptr, &abort_list);
943     free_dlink_node(ptr);
944     continue;
945     }
946    
947     dlinkDelete(ptr, &abort_list);
948    
949 michael 6314 if (HasFlag(target_p, FLAGS_SENDQEX))
950 adx 30 notice = "Max SendQ exceeded";
951     else
952     notice = "Write error: connection closed";
953    
954 michael 3171 exit_client(target_p, notice);
955 adx 30 free_dlink_node(ptr);
956     }
957     }
958    
959     /*
960     * accept processing, this adds a form of "caller ID" to ircd
961 michael 887 *
962 adx 30 * If a client puts themselves into "caller ID only" mode,
963 michael 887 * only clients that match a client pointer they have put on
964 adx 30 * the accept list will be allowed to message them.
965     *
966 michael 887 * Diane Bruce, "Dianora" db@db.net
967 adx 30 */
968    
969 michael 887 void
970 michael 4974 del_accept(struct split_nuh_item *accept_p, struct Client *client_p)
971 adx 30 {
972 michael 4974 dlinkDelete(&accept_p->node, &client_p->connection->acceptlist);
973 adx 30
974 michael 7033 xfree(accept_p->nickptr);
975     xfree(accept_p->userptr);
976     xfree(accept_p->hostptr);
977     xfree(accept_p);
978 michael 887 }
979 adx 30
980 michael 887 struct split_nuh_item *
981     find_accept(const char *nick, const char *user,
982 michael 2363 const char *host, struct Client *client_p,
983     int (*cmpfunc)(const char *, const char *))
984 michael 887 {
985 michael 4801 dlink_node *node = NULL;
986 adx 30
987 michael 4801 DLINK_FOREACH(node, client_p->connection->acceptlist.head)
988 adx 30 {
989 michael 4974 struct split_nuh_item *accept_p = node->data;
990 michael 887
991 michael 4974 if (!cmpfunc(accept_p->nickptr, nick) &&
992     !cmpfunc(accept_p->userptr, user) &&
993     !cmpfunc(accept_p->hostptr, host))
994     return accept_p;
995 adx 30 }
996    
997 michael 887 return NULL;
998 adx 30 }
999    
1000 michael 887 /* accept_message()
1001 adx 30 *
1002 michael 887 * inputs - pointer to source client
1003     * - pointer to target client
1004     * output - 1 if accept this message 0 if not
1005     * side effects - See if source is on target's allow list
1006 adx 30 */
1007 michael 887 int
1008     accept_message(struct Client *source,
1009     struct Client *target)
1010 adx 30 {
1011 michael 4801 dlink_node *node = NULL;
1012 adx 30
1013 michael 5452 if (HasFlag(source, FLAGS_SERVICE) ||
1014     (HasUMode(source, UMODE_OPER) && ConfigGeneral.opers_bypass_callerid))
1015     return 1;
1016    
1017 michael 887 if (source == target || find_accept(source->name, source->username,
1018 michael 2363 source->host, target, match))
1019 michael 887 return 1;
1020 adx 30
1021 michael 4661 if (!HasUMode(target, UMODE_CALLERID) && HasUMode(target, UMODE_SOFTCALLERID))
1022 michael 4801 DLINK_FOREACH(node, target->channel.head)
1023     if (IsMember(source, ((struct Membership *)node->data)->chptr))
1024 michael 887 return 1;
1025 adx 30
1026 michael 887 return 0;
1027 adx 30 }
1028    
1029     /* del_all_accepts()
1030     *
1031 michael 887 * inputs - pointer to exiting client
1032     * output - NONE
1033     * side effects - Walk through given clients acceptlist and remove all entries
1034 adx 30 */
1035     void
1036     del_all_accepts(struct Client *client_p)
1037     {
1038 michael 4801 dlink_node *node = NULL, *node_next = NULL;
1039 adx 30
1040 michael 4801 DLINK_FOREACH_SAFE(node, node_next, client_p->connection->acceptlist.head)
1041     del_accept(node->data, client_p);
1042 adx 30 }
1043 michael 1783
1044     unsigned int
1045 michael 5546 client_get_idle_time(const struct Client *source_p,
1046     const struct Client *target_p)
1047 michael 1783 {
1048     unsigned int idle = 0;
1049     unsigned int min_idle = 0;
1050     unsigned int max_idle = 0;
1051 michael 4834 const struct ClassItem *const class = get_class_ptr(&target_p->connection->confs);
1052 michael 1783
1053 michael 1785 if (!(class->flags & CLASS_FLAGS_FAKE_IDLE) || target_p == source_p)
1054 michael 4589 return CurrentTime - target_p->connection->last_privmsg;
1055 michael 4883
1056 michael 1783 if (HasUMode(source_p, UMODE_OPER) &&
1057 michael 1785 !(class->flags & CLASS_FLAGS_HIDE_IDLE_FROM_OPERS))
1058 michael 4589 return CurrentTime - target_p->connection->last_privmsg;
1059 michael 1783
1060     min_idle = class->min_idle;
1061     max_idle = class->max_idle;
1062    
1063     if (min_idle == max_idle)
1064     return min_idle;
1065    
1066     if (class->flags & CLASS_FLAGS_RANDOM_IDLE)
1067     idle = genrand_int32();
1068     else
1069 michael 4589 idle = CurrentTime - target_p->connection->last_privmsg;
1070 michael 1783
1071 michael 3235 if (!max_idle)
1072 michael 1783 idle = 0;
1073     else
1074     idle %= max_idle;
1075    
1076     if (idle < min_idle)
1077     idle = min_idle + (idle % (max_idle - min_idle));
1078    
1079     return idle;
1080     }
1081 michael 4215
1082     /* client_init()
1083     *
1084     * inputs - NONE
1085     * output - NONE
1086     * side effects - initialize client free memory
1087     */
1088     void
1089     client_init(void)
1090     {
1091     static struct event event_ping =
1092     {
1093     .name = "check_pings",
1094     .handler = check_pings,
1095     .when = 5
1096     };
1097    
1098     client_pool = mp_pool_new(sizeof(struct Client), MP_CHUNK_SIZE_CLIENT);
1099 michael 4578 connection_pool = mp_pool_new(sizeof(struct Connection), MP_CHUNK_SIZE_CONNECTION);
1100 michael 4215 event_add(&event_ping, NULL);
1101     }

Properties

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