ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/client.c
Revision: 6442
Committed: Thu Aug 27 17:05:51 2015 UTC (8 years, 7 months ago) by michael
Content type: text/x-csrc
File size: 32570 byte(s)
Log Message:
- Rename functions in userhost.c to comply with naming convention

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 5346 * Copyright (c) 1997-2015 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     MyFree(client_p->serv);
131 michael 2229 MyFree(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 adx 30 assert(IsClosing(client_p) && IsDead(client_p));
139    
140 michael 4589 MyFree(client_p->connection->challenge_response);
141 michael 5546 client_p->connection->challenge_response = NULL;
142 michael 4589 MyFree(client_p->connection->challenge_operator);
143     client_p->connection->challenge_operator = NULL;
144 adx 30
145     /*
146 michael 5588 * Clean up extra sockets from listen {} blocks which have been discarded.
147 adx 30 */
148 michael 4589 if (client_p->connection->listener)
149 adx 30 {
150 michael 4589 listener_release(client_p->connection->listener);
151     client_p->connection->listener = NULL;
152 adx 30 }
153    
154 michael 4589 dbuf_clear(&client_p->connection->buf_recvq);
155     dbuf_clear(&client_p->connection->buf_sendq);
156 adx 30
157 michael 4589 mp_pool_release(client_p->connection);
158 adx 30 }
159    
160 michael 1654 mp_pool_release(client_p);
161 adx 30 }
162    
163 michael 5559 void
164     client_attach_svstag(struct Client *client_p, unsigned int numeric,
165     const char *umodes, const char *const tag)
166     {
167     struct ServicesTag *svstag = NULL;
168     const struct user_modes *tab = NULL;
169    
170     if (numeric >= ERR_LAST_ERR_MSG || *umodes != '+')
171     return;
172    
173     svstag = MyCalloc(sizeof(*svstag));
174     svstag->numeric = numeric;
175     svstag->tag = xstrdup(tag);
176    
177     for (const char *m = umodes + 1; *m; ++m)
178     if ((tab = umode_map[(unsigned char)*m]))
179     svstag->umodes |= tab->flag;
180    
181     if (numeric != RPL_WHOISOPERATOR)
182     dlinkAddTail(svstag, &svstag->node, &client_p->svstags);
183     else
184     dlinkAdd(svstag, &svstag->node, &client_p->svstags);
185     }
186    
187     void
188     client_clear_svstags(struct Client *client_p)
189     {
190     dlink_node *node = NULL, *node_next = NULL;
191    
192     DLINK_FOREACH_SAFE(node, node_next, client_p->svstags.head)
193     {
194     struct ServicesTag *svstag = node->data;
195    
196     dlinkDelete(&svstag->node, &client_p->svstags);
197     MyFree(svstag->tag);
198     MyFree(svstag);
199     }
200     }
201    
202 adx 30 /* check_pings_list()
203     *
204     * inputs - pointer to list to check
205     * output - NONE
206 michael 2345 * side effects -
207 adx 30 */
208     static void
209     check_pings_list(dlink_list *list)
210     {
211 michael 4215 char buf[IRCD_BUFSIZE] = "";
212 michael 1644 int ping = 0; /* ping time value from client */
213 michael 4801 dlink_node *node = NULL, *node_next = NULL;
214 adx 30
215 michael 4801 DLINK_FOREACH_SAFE(node, node_next, list->head)
216 adx 30 {
217 michael 4801 struct Client *client_p = node->data;
218 adx 30
219     if (IsDead(client_p))
220 michael 4215 continue; /* Ignore it, its been exited already */
221 adx 30
222 michael 6326 if (IsClient(client_p) || IsServer(client_p))
223     ping = get_client_ping(&client_p->connection->confs);
224     else
225 michael 1644 ping = CONNECTTIMEOUT;
226 adx 30
227 michael 4589 if (ping < CurrentTime - client_p->connection->lasttime)
228 adx 30 {
229 michael 6314 if (!HasFlag(client_p, FLAGS_PINGSENT))
230 adx 30 {
231 michael 2182 /*
232 michael 4299 * If we haven't PINGed the connection and we haven't
233 michael 2182 * heard from it in a while, PING it to make sure
234     * it is still alive.
235     */
236 michael 6314 AddFlag(client_p, FLAGS_PINGSENT);
237 michael 4589 client_p->connection->lasttime = CurrentTime - ping;
238 michael 2182 sendto_one(client_p, "PING :%s", ID_or_name(&me, client_p));
239 adx 30 }
240     else
241     {
242 michael 4589 if (CurrentTime - client_p->connection->lasttime >= 2 * ping)
243 adx 30 {
244     /*
245     * If the client/server hasn't talked to us in 2*ping seconds
246     * and it has a ping time, then close its connection.
247     */
248     if (IsServer(client_p) || IsHandshake(client_p))
249 michael 2182 {
250 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
251 michael 2182 "No response from %s, closing link",
252 michael 6426 get_client_name(client_p, SHOW_IP));
253 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_OPER, SEND_NOTICE,
254 michael 2182 "No response from %s, closing link",
255     get_client_name(client_p, MASK_IP));
256     ilog(LOG_TYPE_IRCD, "No response from %s, closing link",
257 michael 6426 get_client_name(client_p, SHOW_IP));
258 michael 2182 }
259 michael 650
260 michael 4215 snprintf(buf, sizeof(buf), "Ping timeout: %d seconds",
261 michael 4589 (int)(CurrentTime - client_p->connection->lasttime));
262 michael 4215 exit_client(client_p, buf);
263 adx 30 }
264     }
265     }
266     }
267     }
268    
269     /* check_unknowns_list()
270     *
271     * inputs - pointer to list of unknown clients
272     * output - NONE
273     * side effects - unknown clients get marked for termination after n seconds
274     */
275     static void
276     check_unknowns_list(void)
277     {
278 michael 4801 dlink_node *node = NULL, *node_next = NULL;
279 adx 30
280 michael 4801 DLINK_FOREACH_SAFE(node, node_next, unknown_list.head)
281 adx 30 {
282 michael 4801 struct Client *client_p = node->data;
283 adx 30
284 michael 650 /*
285     * Check UNKNOWN connections - if they have been in this state
286 adx 30 * for > 30s, close them.
287     */
288 michael 4589 if (IsAuthFinished(client_p) && (CurrentTime - client_p->connection->firsttime) > 30)
289 michael 3171 exit_client(client_p, "Registration timed out");
290 adx 30 }
291     }
292    
293 michael 4215 /*
294     * check_pings - go through the local client list and check activity
295     * kill off stuff that should die
296     *
297     * inputs - NOT USED (from event)
298     * output - next time_t when check_pings() should be called again
299     * side effects -
300     *
301     *
302     * A PING can be sent to clients as necessary.
303     *
304     * Client/Server ping outs are handled.
305     */
306    
307     /*
308     * Addon from adrian. We used to call this after nextping seconds,
309     * however I've changed it to run once a second. This is only for
310     * PING timeouts, not K/etc-line checks (thanks dianora!). Having it
311     * run once a second makes life a lot easier - when a new client connects
312     * and they need a ping in 4 seconds, if nextping was set to 20 seconds
313     * we end up waiting 20 seconds. This is stupid. :-)
314     * I will optimise (hah!) check_pings() once I've finished working on
315     * tidying up other network IO evilnesses.
316     * -- adrian
317     */
318    
319     static void
320 michael 4438 check_pings(void *unused)
321 michael 4215 {
322     check_pings_list(&local_client_list);
323     check_pings_list(&local_server_list);
324     check_unknowns_list();
325     }
326    
327 adx 30 /* check_conf_klines()
328     *
329     * inputs - NONE
330     * output - NONE
331     * side effects - Check all connections for a pending kline against the
332     * client, exit the client if a kline matches.
333     */
334 michael 2345 void
335 adx 30 check_conf_klines(void)
336 michael 2345 {
337 michael 1632 struct MaskItem *conf = NULL;
338 michael 4801 dlink_node *node = NULL, *node_next = NULL;
339 adx 30
340 michael 4801 DLINK_FOREACH_SAFE(node, node_next, local_client_list.head)
341 adx 30 {
342 michael 4801 struct Client *client_p = node->data;
343 adx 30
344 michael 4824 /* If a client is already being exited */
345 michael 4726 if (IsDead(client_p))
346 adx 30 continue;
347    
348 michael 4589 if ((conf = find_conf_by_address(NULL, &client_p->connection->ip, CONF_DLINE,
349     client_p->connection->aftype, NULL, NULL, 1)))
350 adx 30 {
351 michael 2813 conf_try_ban(client_p, conf);
352 michael 5733 continue; /* and go examine next Client */
353 adx 30 }
354    
355 michael 4589 if ((conf = find_conf_by_address(client_p->host, &client_p->connection->ip,
356     CONF_KLINE, client_p->connection->aftype,
357 michael 2739 client_p->username, NULL, 1)))
358 adx 30 {
359 michael 2813 conf_try_ban(client_p, conf);
360 michael 5733 continue; /* and go examine next Client */
361 adx 30 }
362    
363 michael 5751 if ((conf = find_matching_name_conf(CONF_XLINE, client_p->info,
364 michael 1921 NULL, NULL, 0)))
365 adx 30 {
366 michael 2813 conf_try_ban(client_p, conf);
367 michael 5733 continue; /* and go examine next Client */
368 adx 30 }
369     }
370    
371 michael 5733 /* Also check the unknowns list for new dlines */
372 michael 4801 DLINK_FOREACH_SAFE(node, node_next, unknown_list.head)
373 adx 30 {
374 michael 4801 struct Client *client_p = node->data;
375 adx 30
376 michael 4589 if ((conf = find_conf_by_address(NULL, &client_p->connection->ip, CONF_DLINE,
377     client_p->connection->aftype, NULL, NULL, 1)))
378 adx 30 {
379 michael 3930 conf_try_ban(client_p, conf);
380 michael 5733 continue; /* and go examine next Client */
381 adx 30 }
382     }
383     }
384    
385     /*
386 michael 2813 * conf_try_ban
387 adx 30 *
388     * inputs - pointer to client to ban
389 michael 1632 * - pointer to MaskItem
390 adx 30 * output - NONE
391     * side effects - given client_p is banned
392     */
393 michael 2811 void
394 michael 2813 conf_try_ban(struct Client *client_p, struct MaskItem *conf)
395 adx 30 {
396 michael 5978 char ban_type = '\0';
397 adx 30
398     switch (conf->type)
399     {
400 michael 1632 case CONF_KLINE:
401 michael 6314 if (HasFlag(client_p, FLAGS_EXEMPTKLINE))
402 michael 2811 {
403 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
404 michael 2811 "KLINE over-ruled for %s, client is kline_exempt",
405     get_client_name(client_p, HIDE_IP));
406     return;
407     }
408    
409 michael 5978 ban_type = 'K';
410 adx 30 break;
411 michael 1632 case CONF_DLINE:
412 michael 4589 if (find_conf_by_address(NULL, &client_p->connection->ip, CONF_EXEMPT,
413     client_p->connection->aftype, NULL, NULL, 1))
414 michael 3930 return;
415 michael 5978 ban_type = 'D';
416 adx 30 break;
417 michael 1632 case CONF_XLINE:
418 michael 6314 if (HasFlag(client_p, FLAGS_EXEMPTXLINE))
419 michael 5986 {
420 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
421 michael 5986 "XLINE over-ruled for %s, client is xline_exempt",
422     get_client_name(client_p, HIDE_IP));
423     return;
424     }
425 michael 6314
426 michael 5978 ban_type = 'X';
427 michael 1632 ++conf->count;
428 adx 30 break;
429     default:
430     assert(0);
431     break;
432     }
433    
434 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE, "%c-line active for %s",
435 michael 5978 ban_type, get_client_name(client_p, HIDE_IP));
436 adx 30
437     if (IsClient(client_p))
438 michael 5978 sendto_one_numeric(client_p, &me, ERR_YOUREBANNEDCREEP, conf->reason);
439 adx 30
440 michael 5978 exit_client(client_p, conf->reason);
441 adx 30 }
442    
443     /* update_client_exit_stats()
444     *
445     * input - pointer to client
446     * output - NONE
447 michael 2345 * side effects -
448 adx 30 */
449     static void
450     update_client_exit_stats(struct Client *client_p)
451     {
452 michael 1143 if (IsClient(client_p))
453 adx 30 {
454 michael 1013 assert(Count.total > 0);
455 michael 4998
456 adx 30 --Count.total;
457 michael 1219 if (HasUMode(client_p, UMODE_OPER))
458 adx 30 --Count.oper;
459 michael 1219 if (HasUMode(client_p, UMODE_INVISIBLE))
460 adx 30 --Count.invisi;
461     }
462 michael 1143 else if (IsServer(client_p))
463 michael 1618 sendto_realops_flags(UMODE_EXTERNAL, L_ALL, SEND_NOTICE,
464     "Server %s split from %s",
465 michael 1143 client_p->name, client_p->servptr->name);
466 adx 30 }
467    
468     /* find_person()
469     *
470     * inputs - pointer to name
471     * output - return client pointer
472     * side effects - find person by (nick)name
473     */
474     struct Client *
475 michael 3170 find_person(const struct Client *const source_p, const char *name)
476 adx 30 {
477 michael 2475 struct Client *target_p = NULL;
478 adx 30
479     if (IsDigit(*name))
480     {
481 michael 3207 if (IsServer(source_p->from))
482 michael 2586 target_p = hash_find_id(name);
483 adx 30 }
484     else
485 michael 2475 target_p = hash_find_client(name);
486 adx 30
487 michael 2475 return (target_p && IsClient(target_p)) ? target_p : NULL;
488 adx 30 }
489    
490     /*
491 michael 2475 * find_chasing - find the client structure for a nick name (name)
492 michael 2345 * using history mechanism if necessary. If the client is not found,
493 michael 3192 * an error message (NO SUCH NICK) is generated.
494 adx 30 */
495     struct Client *
496 michael 3192 find_chasing(struct Client *source_p, const char *name)
497 adx 30 {
498 michael 4883 struct Client *target_p = find_person(source_p, name);
499 adx 30
500 michael 4883 if (target_p)
501     return target_p;
502 adx 30
503 michael 2475 if (IsDigit(*name))
504 michael 1169 return NULL;
505 adx 30
506 michael 4883 target_p = whowas_get_history(name, (time_t)ConfigGeneral.kill_chase_time_limit);
507    
508     if (!target_p)
509 adx 30 {
510 michael 3109 sendto_one_numeric(source_p, &me, ERR_NOSUCHNICK, name);
511 michael 1169 return NULL;
512 adx 30 }
513    
514 michael 4883 return target_p;
515 adx 30 }
516    
517     /*
518     * get_client_name - Return the name of the client
519     * for various tracking and
520     * admin purposes. The main purpose of this function is to
521     * return the "socket host" name of the client, if that
522     * differs from the advertised name (other than case).
523     * But, this can be used to any client structure.
524     *
525     * NOTE 1:
526 michael 4215 * Watch out the allocation of "buf", if either source_p->name
527 adx 30 * or source_p->sockhost gets changed into pointers instead of
528     * directly allocated within the structure...
529     *
530     * NOTE 2:
531     * Function return either a pointer to the structure (source_p) or
532 michael 4215 * to internal buffer (buf). *NEVER* use the returned pointer
533 adx 30 * to modify what it points!!!
534     */
535     const char *
536 michael 3235 get_client_name(const struct Client *client_p, enum addr_mask_type type)
537 adx 30 {
538 michael 4215 static char buf[HOSTLEN * 2 + USERLEN + 5];
539 adx 30
540 michael 3235 if (!MyConnect(client_p))
541     return client_p->name;
542 adx 30
543 michael 3235 if (IsServer(client_p) || IsConnecting(client_p) || IsHandshake(client_p))
544 michael 1340 {
545 michael 3235 if (!irccmp(client_p->name, client_p->host))
546     return client_p->name;
547 michael 1340 else if (ConfigServerHide.hide_server_ips)
548 michael 1328 type = MASK_IP;
549 michael 1340 }
550 adx 30
551     /* And finally, let's get the host information, ip or name */
552 michael 1328 switch (type)
553 adx 30 {
554     case SHOW_IP:
555 michael 4215 snprintf(buf, sizeof(buf), "%s[%s@%s]",
556 michael 3235 client_p->name,
557     client_p->username, client_p->sockhost);
558 michael 1339 break;
559 adx 30 case MASK_IP:
560 michael 4589 if (client_p->connection->aftype == AF_INET)
561 michael 4215 snprintf(buf, sizeof(buf), "%s[%s@255.255.255.255]",
562 michael 3235 client_p->name, client_p->username);
563 michael 1339 else
564 michael 4215 snprintf(buf, sizeof(buf), "%s[%s@ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]",
565 michael 3235 client_p->name, client_p->username);
566 adx 30 break;
567 michael 6309 default: /* HIDE_IP */
568 michael 4215 snprintf(buf, sizeof(buf), "%s[%s@%s]",
569 michael 3235 client_p->name,
570     client_p->username, client_p->host);
571 adx 30 }
572    
573 michael 4215 return buf;
574 adx 30 }
575    
576     void
577     free_exited_clients(void)
578     {
579 michael 4801 dlink_node *node = NULL, *node_next = NULL;
580 michael 2345
581 michael 4801 DLINK_FOREACH_SAFE(node, node_next, dead_list.head)
582 adx 30 {
583 michael 4801 free_client(node->data);
584     dlinkDelete(node, &dead_list);
585     free_dlink_node(node);
586 adx 30 }
587     }
588    
589     /*
590     * Exit one client, local or remote. Assuming all dependents have
591     * been already removed, and socket closed for local client.
592     *
593     * The only messages generated are QUITs on channels.
594     */
595     static void
596 michael 4215 exit_one_client(struct Client *source_p, const char *comment)
597 adx 30 {
598 michael 4801 dlink_node *node = NULL, *node_next = NULL;
599 adx 30
600     assert(!IsMe(source_p));
601 michael 4215 assert(source_p != &me);
602 adx 30
603 michael 1118 if (IsClient(source_p))
604 adx 30 {
605 michael 3202 dlinkDelete(&source_p->lnode, &source_p->servptr->serv->client_list);
606 michael 4188 dlinkDelete(&source_p->node, &global_client_list);
607 adx 30
608 michael 1118 /*
609     * If a person is on a channel, send a QUIT notice
610     * to every client (person) on the same channel (so
611     * that the client can show the "**signoff" message).
612     * (Note: The notice is to the local clients *only*)
613     */
614 michael 1734 sendto_common_channels_local(source_p, 0, 0, ":%s!%s@%s QUIT :%s",
615 adx 30 source_p->name, source_p->username,
616 michael 4215 source_p->host, comment);
617 michael 4883
618 michael 4801 DLINK_FOREACH_SAFE(node, node_next, source_p->channel.head)
619     remove_user_from_channel(node->data);
620 adx 30
621 michael 2300 whowas_add_history(source_p, 0);
622     whowas_off_history(source_p);
623 adx 30
624 michael 876 watch_check_hash(source_p, RPL_LOGOFF);
625    
626 michael 889 if (MyConnect(source_p))
627 adx 30 {
628 michael 5851 clear_invites_client(source_p);
629 michael 887 del_all_accepts(source_p);
630 michael 317 }
631 adx 30 }
632 michael 1118 else if (IsServer(source_p))
633     {
634     dlinkDelete(&source_p->lnode, &source_p->servptr->serv->server_list);
635 michael 4188 dlinkDelete(&source_p->node, &global_client_list);
636 adx 30
637 michael 4801 if ((node = dlinkFindDelete(&global_server_list, source_p)))
638     free_dlink_node(node);
639 michael 1118 }
640    
641 adx 30 /* Remove source_p from the client lists */
642 michael 3187 if (source_p->id[0])
643 adx 30 hash_del_id(source_p);
644 michael 4883
645 adx 30 if (source_p->name[0])
646     hash_del_client(source_p);
647    
648 michael 6314 if (HasFlag(source_p, FLAGS_USERHOST))
649 michael 6442 userhost_del(source_p->username, source_p->host, !MyConnect(source_p));
650 adx 30
651     update_client_exit_stats(source_p);
652    
653     /* Check to see if the client isn't already on the dead list */
654     assert(dlinkFind(&dead_list, source_p) == NULL);
655    
656     /* add to dead client dlist */
657     SetDead(source_p);
658     dlinkAdd(source_p, make_dlink_node(), &dead_list);
659     }
660    
661 michael 2345 /*
662 adx 30 * Remove all clients that depend on source_p; assumes all (S)QUITs have
663 michael 2345 * already been sent. we make sure to exit a server's dependent clients
664     * and servers before the server itself; exit_one_client takes care of
665 adx 30 * actually removing things off llists. tweaked from +CSr31 -orabidoo
666     */
667     static void
668 michael 4215 recurse_remove_clients(struct Client *source_p, const char *comment)
669 adx 30 {
670 michael 4801 dlink_node *node = NULL, *node_next = NULL;
671 adx 30
672 michael 4801 DLINK_FOREACH_SAFE(node, node_next, source_p->serv->client_list.head)
673     exit_one_client(node->data, comment);
674 adx 30
675 michael 4801 DLINK_FOREACH_SAFE(node, node_next, source_p->serv->server_list.head)
676 adx 30 {
677 michael 4801 recurse_remove_clients(node->data, comment);
678     exit_one_client(node->data, comment);
679 adx 30 }
680     }
681    
682     /*
683     * exit_client - exit a client of any type. Generally, you can use
684     * this on any struct Client, regardless of its state.
685     *
686     * Note, you shouldn't exit remote _users_ without first doing
687 michael 1219 * AddFlag(x, FLAGS_KILLED) and propagating a kill or similar message.
688 michael 3171 *
689 michael 1219 * However, it is perfectly correct to call exit_client to force a _server_
690 adx 30 * quit (either local or remote one).
691     *
692 michael 3171 *
693 adx 30 * inputs: - a client pointer that is going to be exited
694     * output: none
695     * side effects: the client is delinked from all lists, disconnected,
696     * and the rest of IRC network is notified of the exit.
697     * Client memory is scheduled to be freed
698     */
699     void
700 michael 3171 exit_client(struct Client *source_p, const char *comment)
701 adx 30 {
702 michael 4801 dlink_node *node = NULL;
703 adx 30
704 michael 4215 assert(!IsMe(source_p));
705     assert(source_p != &me);
706    
707 adx 30 if (MyConnect(source_p))
708     {
709     /* DO NOT REMOVE. exit_client can be called twice after a failed
710     * read/write.
711     */
712     if (IsClosing(source_p))
713     return;
714    
715     SetClosing(source_p);
716    
717 michael 4401 if (HasFlag(source_p, FLAGS_IPHASH))
718     {
719     DelFlag(source_p, FLAGS_IPHASH);
720 michael 4589 ipcache_remove_address(&source_p->connection->ip);
721 michael 4401 }
722 adx 30
723 michael 4589 delete_auth(&source_p->connection->auth);
724 adx 30
725 michael 6326 if (IsClient(source_p))
726 adx 30 {
727 michael 4589 time_t on_for = CurrentTime - source_p->connection->firsttime;
728 michael 4883
729 michael 1013 assert(Count.local > 0);
730 michael 4998
731 michael 4883 --Count.local;
732 adx 30
733 michael 1219 if (HasUMode(source_p, UMODE_OPER))
734 michael 4801 if ((node = dlinkFindDelete(&oper_list, source_p)))
735     free_dlink_node(node);
736 adx 30
737 michael 1126 assert(dlinkFind(&local_client_list, source_p));
738 michael 4589 dlinkDelete(&source_p->connection->lclient_node, &local_client_list);
739 michael 1126
740 michael 4589 if (source_p->connection->list_task)
741 michael 3289 free_list_task(source_p);
742 adx 30
743 michael 876 watch_del_watch_list(source_p);
744 michael 5559 client_clear_svstags(source_p);
745    
746 michael 1618 sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE,
747     "Client exiting: %s (%s@%s) [%s] [%s]",
748 adx 30 source_p->name, source_p->username, source_p->host, comment,
749 michael 4968 source_p->sockhost);
750 michael 4883
751 michael 1247 ilog(LOG_TYPE_USER, "%s (%3u:%02u:%02u): %s!%s@%s %llu/%llu",
752 michael 4589 myctime(source_p->connection->firsttime), (unsigned int)(on_for / 3600),
753 michael 1247 (unsigned int)((on_for % 3600)/60), (unsigned int)(on_for % 60),
754     source_p->name, source_p->username, source_p->host,
755 michael 4589 source_p->connection->send.bytes>>10,
756     source_p->connection->recv.bytes>>10);
757 adx 30 }
758 michael 1571 else if (IsServer(source_p))
759 adx 30 {
760 michael 1571 assert(Count.myserver > 0);
761 michael 4998
762 michael 1571 --Count.myserver;
763 adx 30
764 michael 4212 assert(dlinkFind(&local_server_list, source_p));
765 michael 4589 dlinkDelete(&source_p->connection->lclient_node, &local_server_list);
766 adx 30 }
767 michael 6326 else
768     {
769     assert(dlinkFind(&unknown_list, source_p));
770     dlinkDelete(&source_p->connection->lclient_node, &unknown_list);
771     }
772 adx 30
773     if (!IsDead(source_p))
774     {
775     if (IsServer(source_p))
776     {
777 michael 3171 if (!HasFlag(source_p, FLAGS_SQUIT))
778     {
779     /* for them, we are exiting the network */
780     sendto_one(source_p, ":%s SQUIT %s :%s",
781 michael 3186 me.id, me.id, comment);
782 michael 3171 }
783 adx 30 }
784    
785     sendto_one(source_p, "ERROR :Closing Link: %s (%s)",
786     source_p->host, comment);
787     }
788    
789     close_connection(source_p);
790     }
791 michael 1991 else if (IsClient(source_p) && HasFlag(source_p->servptr, FLAGS_EOB))
792 michael 1976 sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
793     "Client exiting at %s: %s (%s@%s) [%s]",
794     source_p->servptr->name, source_p->name,
795     source_p->username, source_p->host, comment);
796 adx 30
797     if (IsServer(source_p))
798     {
799 michael 3171 char splitstr[HOSTLEN + HOSTLEN + 2] = "";
800 adx 30
801 michael 5591 assert(source_p->serv);
802     assert(source_p->servptr);
803 adx 30
804     if (ConfigServerHide.hide_servers)
805 michael 887 /*
806 michael 2345 * Set netsplit message to "*.net *.split" to still show
807 adx 30 * that its a split, but hide the servers splitting
808     */
809 michael 3171 strlcpy(splitstr, "*.net *.split", sizeof(splitstr));
810 adx 30 else
811     snprintf(splitstr, sizeof(splitstr), "%s %s",
812     source_p->servptr->name, source_p->name);
813    
814 michael 4212 /* Send SQUIT for source_p in every direction. source_p is already off of local_server_list here */
815 michael 3171 if (!HasFlag(source_p, FLAGS_SQUIT))
816 michael 4963 sendto_server(NULL, 0, 0, "SQUIT %s :%s", source_p->id, comment);
817 adx 30
818 michael 3171 /* Now exit the clients internally */
819     recurse_remove_clients(source_p, splitstr);
820    
821 michael 3247 if (MyConnect(source_p))
822 adx 30 {
823 michael 4589 int connected = CurrentTime - source_p->connection->firsttime;
824 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
825 michael 4574 "%s was connected for %d day%s, %2d:%02d:%02d. %llu/%llu sendK/recvK.",
826     source_p->name, connected/86400, (connected/86400 == 1) ? "" : "s",
827     (connected % 86400) / 3600, (connected % 3600) / 60, connected % 60,
828 michael 4589 source_p->connection->send.bytes >> 10,
829     source_p->connection->recv.bytes >> 10);
830 michael 4574 ilog(LOG_TYPE_IRCD, "%s was connected for %d day%s, %2d:%02d:%02d. %llu/%llu sendK/recvK.",
831     source_p->name, connected/86400, (connected/86400 == 1) ? "" : "s",
832 michael 5588 (connected % 86400) / 3600, (connected % 3600) / 60, connected % 60,
833     source_p->connection->send.bytes >> 10,
834     source_p->connection->recv.bytes >> 10);
835 adx 30 }
836     }
837 michael 1219 else if (IsClient(source_p) && !HasFlag(source_p, FLAGS_KILLED))
838 michael 4963 sendto_server(source_p->from, 0, 0, ":%s QUIT :%s",
839 michael 3186 source_p->id, comment);
840 adx 30
841     /* The client *better* be off all of the lists */
842     assert(dlinkFind(&unknown_list, source_p) == NULL);
843     assert(dlinkFind(&local_client_list, source_p) == NULL);
844 michael 4212 assert(dlinkFind(&local_server_list, source_p) == NULL);
845 adx 30 assert(dlinkFind(&oper_list, source_p) == NULL);
846    
847     exit_one_client(source_p, comment);
848     }
849    
850     /*
851     * dead_link_on_write - report a write error if not already dead,
852     * mark it as dead then exit it
853     */
854     void
855     dead_link_on_write(struct Client *client_p, int ierrno)
856     {
857 michael 4801 dlink_node *node;
858 adx 30
859     if (IsDefunct(client_p))
860     return;
861    
862 michael 4589 dbuf_clear(&client_p->connection->buf_recvq);
863     dbuf_clear(&client_p->connection->buf_sendq);
864 adx 30
865     assert(dlinkFind(&abort_list, client_p) == NULL);
866 michael 4801 node = make_dlink_node();
867 adx 30 /* don't let exit_aborted_clients() finish yet */
868 michael 4801 dlinkAddTail(client_p, node, &abort_list);
869 adx 30
870     if (eac_next == NULL)
871 michael 4801 eac_next = node;
872 adx 30
873     SetDead(client_p); /* You are dead my friend */
874     }
875    
876     /*
877     * dead_link_on_read - report a read error if not already dead,
878     * mark it as dead then exit it
879     */
880     void
881     dead_link_on_read(struct Client *client_p, int error)
882     {
883 michael 2691 char errmsg[IRCD_BUFSIZE];
884 adx 30 int current_error;
885    
886     if (IsDefunct(client_p))
887     return;
888    
889 michael 4589 dbuf_clear(&client_p->connection->buf_recvq);
890     dbuf_clear(&client_p->connection->buf_sendq);
891 adx 30
892 michael 4589 current_error = get_sockerr(client_p->connection->fd.fd);
893 adx 30
894     if (IsServer(client_p) || IsHandshake(client_p))
895     {
896 michael 4589 int connected = CurrentTime - client_p->connection->firsttime;
897 michael 2345
898 adx 30 if (error == 0)
899     {
900     /* Admins get the real IP */
901 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
902 michael 2182 "Server %s closed the connection",
903     get_client_name(client_p, SHOW_IP));
904 adx 30
905     /* Opers get a masked IP */
906 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_OPER, SEND_NOTICE,
907 michael 2182 "Server %s closed the connection",
908     get_client_name(client_p, MASK_IP));
909 adx 30
910 michael 1247 ilog(LOG_TYPE_IRCD, "Server %s closed the connection",
911 michael 2182 get_client_name(client_p, SHOW_IP));
912 adx 30 }
913     else
914     {
915 michael 617 report_error(L_ADMIN, "Lost connection to %s: %s",
916 michael 2182 get_client_name(client_p, SHOW_IP), current_error);
917 michael 617 report_error(L_OPER, "Lost connection to %s: %s",
918 michael 2182 get_client_name(client_p, MASK_IP), current_error);
919 adx 30 }
920    
921 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
922 michael 4574 "%s was connected for %d day%s, %2d:%02d:%02d",
923 michael 2182 client_p->name, connected/86400,
924     (connected/86400 == 1) ? "" : "s",
925     (connected % 86400) / 3600, (connected % 3600) / 60,
926     connected % 60);
927 adx 30 }
928    
929     if (error == 0)
930     strlcpy(errmsg, "Remote host closed the connection",
931     sizeof(errmsg));
932     else
933 michael 1124 snprintf(errmsg, sizeof(errmsg), "Read error: %s",
934     strerror(current_error));
935 adx 30
936 michael 3171 exit_client(client_p, errmsg);
937 adx 30 }
938    
939     void
940     exit_aborted_clients(void)
941     {
942     dlink_node *ptr;
943     struct Client *target_p;
944     const char *notice;
945    
946     DLINK_FOREACH_SAFE(ptr, eac_next, abort_list.head)
947     {
948     target_p = ptr->data;
949     eac_next = ptr->next;
950    
951     if (target_p == NULL)
952     {
953 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
954 adx 30 "Warning: null client on abort_list!");
955     dlinkDelete(ptr, &abort_list);
956     free_dlink_node(ptr);
957     continue;
958     }
959    
960     dlinkDelete(ptr, &abort_list);
961    
962 michael 6314 if (HasFlag(target_p, FLAGS_SENDQEX))
963 adx 30 notice = "Max SendQ exceeded";
964     else
965     notice = "Write error: connection closed";
966    
967 michael 3171 exit_client(target_p, notice);
968 adx 30 free_dlink_node(ptr);
969     }
970     }
971    
972     /*
973     * accept processing, this adds a form of "caller ID" to ircd
974 michael 887 *
975 adx 30 * If a client puts themselves into "caller ID only" mode,
976 michael 887 * only clients that match a client pointer they have put on
977 adx 30 * the accept list will be allowed to message them.
978     *
979 michael 887 * Diane Bruce, "Dianora" db@db.net
980 adx 30 */
981    
982 michael 887 void
983 michael 4974 del_accept(struct split_nuh_item *accept_p, struct Client *client_p)
984 adx 30 {
985 michael 4974 dlinkDelete(&accept_p->node, &client_p->connection->acceptlist);
986 adx 30
987 michael 4974 MyFree(accept_p->nickptr);
988     MyFree(accept_p->userptr);
989     MyFree(accept_p->hostptr);
990     MyFree(accept_p);
991 michael 887 }
992 adx 30
993 michael 887 struct split_nuh_item *
994     find_accept(const char *nick, const char *user,
995 michael 2363 const char *host, struct Client *client_p,
996     int (*cmpfunc)(const char *, const char *))
997 michael 887 {
998 michael 4801 dlink_node *node = NULL;
999 adx 30
1000 michael 4801 DLINK_FOREACH(node, client_p->connection->acceptlist.head)
1001 adx 30 {
1002 michael 4974 struct split_nuh_item *accept_p = node->data;
1003 michael 887
1004 michael 4974 if (!cmpfunc(accept_p->nickptr, nick) &&
1005     !cmpfunc(accept_p->userptr, user) &&
1006     !cmpfunc(accept_p->hostptr, host))
1007     return accept_p;
1008 adx 30 }
1009    
1010 michael 887 return NULL;
1011 adx 30 }
1012    
1013 michael 887 /* accept_message()
1014 adx 30 *
1015 michael 887 * inputs - pointer to source client
1016     * - pointer to target client
1017     * output - 1 if accept this message 0 if not
1018     * side effects - See if source is on target's allow list
1019 adx 30 */
1020 michael 887 int
1021     accept_message(struct Client *source,
1022     struct Client *target)
1023 adx 30 {
1024 michael 4801 dlink_node *node = NULL;
1025 adx 30
1026 michael 5452 if (HasFlag(source, FLAGS_SERVICE) ||
1027     (HasUMode(source, UMODE_OPER) && ConfigGeneral.opers_bypass_callerid))
1028     return 1;
1029    
1030 michael 887 if (source == target || find_accept(source->name, source->username,
1031 michael 2363 source->host, target, match))
1032 michael 887 return 1;
1033 adx 30
1034 michael 4661 if (!HasUMode(target, UMODE_CALLERID) && HasUMode(target, UMODE_SOFTCALLERID))
1035 michael 4801 DLINK_FOREACH(node, target->channel.head)
1036     if (IsMember(source, ((struct Membership *)node->data)->chptr))
1037 michael 887 return 1;
1038 adx 30
1039 michael 887 return 0;
1040 adx 30 }
1041    
1042     /* del_all_accepts()
1043     *
1044 michael 887 * inputs - pointer to exiting client
1045     * output - NONE
1046     * side effects - Walk through given clients acceptlist and remove all entries
1047 adx 30 */
1048     void
1049     del_all_accepts(struct Client *client_p)
1050     {
1051 michael 4801 dlink_node *node = NULL, *node_next = NULL;
1052 adx 30
1053 michael 4801 DLINK_FOREACH_SAFE(node, node_next, client_p->connection->acceptlist.head)
1054     del_accept(node->data, client_p);
1055 adx 30 }
1056 michael 1783
1057     unsigned int
1058 michael 5546 client_get_idle_time(const struct Client *source_p,
1059     const struct Client *target_p)
1060 michael 1783 {
1061     unsigned int idle = 0;
1062     unsigned int min_idle = 0;
1063     unsigned int max_idle = 0;
1064 michael 4834 const struct ClassItem *const class = get_class_ptr(&target_p->connection->confs);
1065 michael 1783
1066 michael 1785 if (!(class->flags & CLASS_FLAGS_FAKE_IDLE) || target_p == source_p)
1067 michael 4589 return CurrentTime - target_p->connection->last_privmsg;
1068 michael 4883
1069 michael 1783 if (HasUMode(source_p, UMODE_OPER) &&
1070 michael 1785 !(class->flags & CLASS_FLAGS_HIDE_IDLE_FROM_OPERS))
1071 michael 4589 return CurrentTime - target_p->connection->last_privmsg;
1072 michael 1783
1073     min_idle = class->min_idle;
1074     max_idle = class->max_idle;
1075    
1076     if (min_idle == max_idle)
1077     return min_idle;
1078    
1079     if (class->flags & CLASS_FLAGS_RANDOM_IDLE)
1080     idle = genrand_int32();
1081     else
1082 michael 4589 idle = CurrentTime - target_p->connection->last_privmsg;
1083 michael 1783
1084 michael 3235 if (!max_idle)
1085 michael 1783 idle = 0;
1086     else
1087     idle %= max_idle;
1088    
1089     if (idle < min_idle)
1090     idle = min_idle + (idle % (max_idle - min_idle));
1091    
1092     return idle;
1093     }
1094 michael 4215
1095     /* client_init()
1096     *
1097     * inputs - NONE
1098     * output - NONE
1099     * side effects - initialize client free memory
1100     */
1101     void
1102     client_init(void)
1103     {
1104     static struct event event_ping =
1105     {
1106     .name = "check_pings",
1107     .handler = check_pings,
1108     .when = 5
1109     };
1110    
1111     client_pool = mp_pool_new(sizeof(struct Client), MP_CHUNK_SIZE_CLIENT);
1112 michael 4578 connection_pool = mp_pool_new(sizeof(struct Connection), MP_CHUNK_SIZE_CONNECTION);
1113 michael 4215 event_add(&event_ping, NULL);
1114     }

Properties

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