ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/client.c
Revision: 3207
Committed: Tue Mar 25 15:19:02 2014 UTC (10 years ago) by michael
Content type: text/x-csrc
Original Path: ircd-hybrid/trunk/src/client.c
File size: 33720 byte(s)
Log Message:
- client.c: optimized find_person(). Removed pointless test.

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

Properties

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