2 * Solanum: a slightly advanced ircd
3 * client.c: Controls clients.
5 * Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
6 * Copyright (C) 1996-2002 Hybrid Development Team
7 * Copyright (C) 2002-2005 ircd-ratbox development team
8 * Copyright (C) 2007 Ariadne Conill <ariadne@dereferenced.org>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
37 #include "s_newconf.h"
52 #include "rb_dictionary.h"
57 #define DEBUG_EXITED_CLIENTS
59 static void check_pings_list(rb_dlink_list
* list
);
60 static void check_unknowns_list(rb_dlink_list
* list
);
61 static void free_exited_clients(void *unused
);
62 static void exit_aborted_clients(void *unused
);
64 static int exit_remote_client(struct Client
*, struct Client
*, struct Client
*,const char *);
65 static int exit_remote_server(struct Client
*, struct Client
*, struct Client
*,const char *);
66 static int exit_local_client(struct Client
*, struct Client
*, struct Client
*,const char *);
67 static int exit_unknown_client(struct Client
*, struct Client
*, struct Client
*,const char *);
68 static int exit_local_server(struct Client
*, struct Client
*, struct Client
*,const char *);
69 static int qs_server(struct Client
*, struct Client
*, struct Client
*, const char *comment
);
71 static EVH check_pings
;
73 static rb_bh
*client_heap
= NULL
;
74 static rb_bh
*lclient_heap
= NULL
;
75 static rb_bh
*pclient_heap
= NULL
;
76 static rb_bh
*user_heap
= NULL
;
77 static rb_bh
*away_heap
= NULL
;
78 static char current_uid
[IDLEN
];
79 static uint32_t current_connid
= 0;
81 rb_dictionary
*nd_dict
= NULL
;
83 rb_dlink_list dead_list
;
84 #ifdef DEBUG_EXITED_CLIENTS
85 static rb_dlink_list dead_remote_list
;
91 struct Client
*client
;
92 char notice
[REASONLEN
];
95 static rb_dlink_list abort_list
;
103 * side effects - initialize client free memory
109 * start off the check ping event .. -- adrian
110 * Every 30 seconds is plenty -- db
112 client_heap
= rb_bh_create(sizeof(struct Client
), CLIENT_HEAP_SIZE
, "client_heap");
113 lclient_heap
= rb_bh_create(sizeof(struct LocalUser
), LCLIENT_HEAP_SIZE
, "lclient_heap");
114 pclient_heap
= rb_bh_create(sizeof(struct PreClient
), PCLIENT_HEAP_SIZE
, "pclient_heap");
115 user_heap
= rb_bh_create(sizeof(struct User
), USER_HEAP_SIZE
, "user_heap");
116 away_heap
= rb_bh_create(AWAYLEN
, AWAY_HEAP_SIZE
, "away_heap");
118 rb_event_addish("check_pings", check_pings
, NULL
, 30);
119 rb_event_addish("free_exited_clients", &free_exited_clients
, NULL
, 4);
120 rb_event_addish("exit_aborted_clients", exit_aborted_clients
, NULL
, 1);
121 rb_event_add("flood_recalc", flood_recalc
, NULL
, 1);
123 nd_dict
= rb_dictionary_create("nickdelay", irccmp
);
127 * connid_get - allocate a connid
130 * outputs - a connid token which is used to represent a logical circuit
131 * side effects - current_connid is incremented, possibly multiple times.
132 * the association of the connid to it's client is committed.
135 connid_get(struct Client
*client_p
)
137 s_assert(MyConnect(client_p
));
138 if (!MyConnect(client_p
))
141 /* find a connid that is available */
142 while (find_cli_connid_hash(++current_connid
) != NULL
)
144 /* handle wraparound, current_connid must NEVER be 0 */
145 if (current_connid
== 0)
149 add_to_cli_connid_hash(client_p
, current_connid
);
150 rb_dlinkAddAlloc(RB_UINT_TO_POINTER(current_connid
), &client_p
->localClient
->connids
);
152 return current_connid
;
156 * connid_put - free a connid
158 * inputs - connid to free
160 * side effects - connid bookkeeping structures are freed
163 connid_put(uint32_t id
)
165 struct Client
*client_p
;
171 client_p
= find_cli_connid_hash(id
);
172 if (client_p
== NULL
)
175 del_from_cli_connid_hash(id
);
176 rb_dlinkFindDestroy(RB_UINT_TO_POINTER(id
), &client_p
->localClient
->connids
);
180 * client_release_connids - release any connids still attached to a client
182 * inputs - client to garbage collect
184 * side effects - client's connids are garbage collected
187 client_release_connids(struct Client
*client_p
)
189 rb_dlink_node
*ptr
, *ptr2
;
191 if (client_p
->localClient
->connids
.head
)
192 s_assert(MyConnect(client_p
));
194 if (!MyConnect(client_p
))
197 RB_DLINK_FOREACH_SAFE(ptr
, ptr2
, client_p
->localClient
->connids
.head
)
198 connid_put(RB_POINTER_TO_UINT(ptr
->data
));
202 * make_client - create a new Client struct and set it to initial state.
204 * from == NULL, create local client (a client connected
207 * from, create remote client (behind a socket
208 * associated with the client defined by
209 * 'from'). ('from' is a local client!!).
212 make_client(struct Client
*from
)
214 struct Client
*client_p
= NULL
;
215 struct LocalUser
*localClient
;
217 client_p
= rb_bh_alloc(client_heap
);
221 client_p
->from
= client_p
; /* 'from' of local client is self! */
223 localClient
= rb_bh_alloc(lclient_heap
);
224 SetMyConnect(client_p
);
225 client_p
->localClient
= localClient
;
227 client_p
->localClient
->lasttime
= client_p
->localClient
->firsttime
= rb_current_time();
229 client_p
->localClient
->F
= NULL
;
231 client_p
->preClient
= rb_bh_alloc(pclient_heap
);
233 /* as good a place as any... */
234 rb_dlinkAdd(client_p
, &client_p
->localClient
->tnode
, &unknown_list
);
237 { /* from is not NULL */
238 client_p
->localClient
= NULL
;
239 client_p
->preClient
= NULL
;
240 client_p
->from
= from
; /* 'from' of local client is self! */
243 SetUnknown(client_p
);
244 rb_strlcpy(client_p
->username
, "unknown", sizeof(client_p
->username
));
250 free_pre_client(struct Client
*client_p
)
252 s_assert(NULL
!= client_p
);
254 if(client_p
->preClient
== NULL
)
257 s_assert(client_p
->preClient
->auth
.cid
== 0);
259 rb_free(client_p
->preClient
->auth
.data
);
260 rb_free(client_p
->preClient
->auth
.reason
);
262 rb_bh_free(pclient_heap
, client_p
->preClient
);
263 client_p
->preClient
= NULL
;
267 free_local_client(struct Client
*client_p
)
269 s_assert(NULL
!= client_p
);
270 s_assert(&me
!= client_p
);
272 if(client_p
->localClient
== NULL
)
276 * clean up extra sockets from P-lines which have been discarded.
278 if(client_p
->localClient
->listener
)
280 s_assert(0 < client_p
->localClient
->listener
->ref_count
);
281 if(0 == --client_p
->localClient
->listener
->ref_count
282 && !client_p
->localClient
->listener
->active
)
283 free_listener(client_p
->localClient
->listener
);
284 client_p
->localClient
->listener
= 0;
287 client_release_connids(client_p
);
288 if(client_p
->localClient
->F
!= NULL
)
290 rb_close(client_p
->localClient
->F
);
293 if(client_p
->localClient
->passwd
)
295 memset(client_p
->localClient
->passwd
, 0,
296 strlen(client_p
->localClient
->passwd
));
297 rb_free(client_p
->localClient
->passwd
);
300 rb_free(client_p
->localClient
->auth_user
);
301 rb_free(client_p
->localClient
->challenge
);
302 rb_free(client_p
->localClient
->fullcaps
);
303 rb_free(client_p
->localClient
->mangledhost
);
306 ssld_decrement_clicount(client_p
->localClient
->ssl_ctl
);
308 rb_free(client_p
->localClient
->cipher_string
);
310 if (IsCapable(client_p
, CAP_ZIP
))
311 ssld_decrement_clicount(client_p
->localClient
->z_ctl
);
313 rb_free(client_p
->localClient
->zipstats
);
315 if (client_p
->localClient
->ws_ctl
!= NULL
)
316 wsockd_decrement_clicount(client_p
->localClient
->ws_ctl
);
318 rb_bh_free(lclient_heap
, client_p
->localClient
);
319 client_p
->localClient
= NULL
;
323 free_client(struct Client
*client_p
)
325 s_assert(NULL
!= client_p
);
326 s_assert(&me
!= client_p
);
327 free_local_client(client_p
);
328 free_pre_client(client_p
);
329 rb_free(client_p
->certfp
);
330 rb_bh_free(client_heap
, client_p
);
334 * check_pings - go through the local client list and check activity
335 * kill off stuff that should die
337 * inputs - NOT USED (from event)
338 * output - next time_t when check_pings() should be called again
342 * A PING can be sent to clients as necessary.
344 * Client/Server ping outs are handled.
348 * Addon from adrian. We used to call this after nextping seconds,
349 * however I've changed it to run once a second. This is only for
350 * PING timeouts, not K/etc-line checks (thanks dianora!). Having it
351 * run once a second makes life a lot easier - when a new client connects
352 * and they need a ping in 4 seconds, if nextping was set to 20 seconds
353 * we end up waiting 20 seconds. This is stupid. :-)
354 * I will optimise (hah!) check_pings() once I've finished working on
355 * tidying up other network IO evilnesses.
360 check_pings(void *notused
)
362 check_pings_list(&lclient_list
);
363 check_pings_list(&serv_list
);
364 check_unknowns_list(&unknown_list
);
370 * inputs - pointer to list to check
375 check_pings_list(rb_dlink_list
* list
)
377 char scratch
[32]; /* way too generous but... */
378 struct Client
*client_p
; /* current local client_p being examined */
379 int ping
= 0; /* ping time value from client */
380 rb_dlink_node
*ptr
, *next_ptr
;
382 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, list
->head
)
384 client_p
= ptr
->data
;
386 if(!MyConnect(client_p
) || IsDead(client_p
))
389 ping
= get_client_ping(client_p
);
391 if(ping
< (rb_current_time() - client_p
->localClient
->lasttime
))
394 * If the client/server hasnt talked to us in 2*ping seconds
395 * and it has a ping time, then close its connection.
397 if(((rb_current_time() - client_p
->localClient
->lasttime
) >= (2 * ping
)
398 && (client_p
->flags
& FLAGS_PINGSENT
)))
400 if(IsServer(client_p
))
402 sendto_realops_snomask(SNO_GENERAL
, L_NETWIDE
,
403 "No response from %s, closing link",
406 "No response from %s, closing link",
407 log_client_name(client_p
, HIDE_IP
));
409 (void) snprintf(scratch
, sizeof(scratch
),
410 "Ping timeout: %d seconds",
411 (int) (rb_current_time() - client_p
->localClient
->lasttime
));
413 exit_client(client_p
, client_p
, &me
, scratch
);
416 else if((client_p
->flags
& FLAGS_PINGSENT
) == 0)
419 * if we havent PINGed the connection and we havent
420 * heard from it in a while, PING it to make sure
423 client_p
->flags
|= FLAGS_PINGSENT
;
424 /* not nice but does the job */
425 client_p
->localClient
->lasttime
= rb_current_time() - ping
;
426 sendto_one(client_p
, "PING :%s", me
.name
);
435 * check_unknowns_list
437 * inputs - pointer to list of unknown clients
439 * side effects - unknown clients get marked for termination after n seconds
442 check_unknowns_list(rb_dlink_list
* list
)
444 rb_dlink_node
*ptr
, *next_ptr
;
445 struct Client
*client_p
;
448 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, list
->head
)
450 client_p
= ptr
->data
;
452 if(IsDead(client_p
) || IsClosing(client_p
))
455 /* Still querying with authd */
456 if(client_p
->preClient
!= NULL
&& client_p
->preClient
->auth
.cid
!= 0)
460 * Check UNKNOWN connections - if they have been in this state
461 * for > 30s, close them.
464 timeout
= IsAnyServer(client_p
) ? ConfigFileEntry
.connect_timeout
: 30;
465 if((rb_current_time() - client_p
->localClient
->firsttime
) > timeout
)
467 if(IsAnyServer(client_p
))
469 sendto_realops_snomask(SNO_GENERAL
, L_NETWIDE
,
470 "No response from %s, closing link",
473 "No response from %s, closing link",
474 log_client_name(client_p
, HIDE_IP
));
476 exit_client(client_p
, client_p
, &me
, "Connection timed out");
482 notify_banned_client(struct Client
*client_p
, struct ConfItem
*aconf
, int ban
)
484 static const char conn_closed
[] = "Connection closed";
485 static const char d_lined
[] = "D-lined";
486 static const char k_lined
[] = "K-lined";
487 const char *reason
= NULL
;
488 const char *exit_reason
= conn_closed
;
490 if(ConfigFileEntry
.kline_with_reason
)
492 reason
= get_user_ban_reason(aconf
);
493 exit_reason
= reason
;
497 reason
= aconf
->status
== D_LINED
? d_lined
: k_lined
;
500 if(ban
== D_LINED
&& !IsPerson(client_p
))
501 sendto_one(client_p
, "NOTICE DLINE :*** You have been D-lined");
503 sendto_one(client_p
, form_str(ERR_YOUREBANNEDCREEP
),
504 me
.name
, client_p
->name
, reason
);
506 exit_client(client_p
, client_p
, &me
,
507 EmptyString(ConfigFileEntry
.kline_reason
) ? exit_reason
:
508 ConfigFileEntry
.kline_reason
);
515 * side effects - Check all connections for a pending k/dline against the
516 * client, exit the client if found.
519 check_banned_lines(void)
530 * side effects - all clients will be checked for klines
535 struct Client
*client_p
;
536 struct ConfItem
*aconf
;
538 rb_dlink_node
*next_ptr
;
540 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
542 client_p
= ptr
->data
;
544 if(IsMe(client_p
) || !IsPerson(client_p
))
547 if((aconf
= find_kline(client_p
)) != NULL
)
549 if(IsExemptKline(client_p
))
551 sendto_realops_snomask(SNO_GENERAL
, L_NETWIDE
,
552 "KLINE over-ruled for %s, client is kline_exempt [%s@%s]",
553 get_client_name(client_p
, HIDE_IP
),
554 aconf
->user
, aconf
->host
);
558 sendto_realops_snomask(SNO_GENERAL
, L_NETWIDE
,
559 "KLINE active for %s (%s@%s)",
560 get_client_name(client_p
, HIDE_IP
), aconf
->user
, aconf
->host
);
562 notify_banned_client(client_p
, aconf
, K_LINED
);
571 * This process needs to be kept in sync with find_kline() aka find_conf_by_address().
573 * inputs - pointer to kline to check
575 * side effects - all clients will be checked against given kline
578 check_one_kline(struct ConfItem
*kline
)
580 struct Client
*client_p
;
582 rb_dlink_node
*next_ptr
;
585 struct rb_sockaddr_storage sockaddr
;
586 struct sockaddr_in ip4
;
588 masktype
= parse_netmask(kline
->host
, (struct sockaddr_storage
*)&sockaddr
, &bits
);
590 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
594 client_p
= ptr
->data
;
596 if(IsMe(client_p
) || !IsPerson(client_p
))
599 if(!match(kline
->user
, client_p
->username
))
602 /* match one kline */
606 if (IsConfDoSpoofIp(client_p
->localClient
->att_conf
) &&
607 IsConfKlineSpoof(client_p
->localClient
->att_conf
))
609 if (client_p
->localClient
->ip
.ss_family
== AF_INET6
&& sockaddr
.ss_family
== AF_INET
&&
610 rb_ipv4_from_ipv6((struct sockaddr_in6
*)&client_p
->localClient
->ip
, &ip4
)
611 && comp_with_mask_sock((struct sockaddr
*)&ip4
, (struct sockaddr
*)&sockaddr
, bits
))
613 else if (client_p
->localClient
->ip
.ss_family
== sockaddr
.ss_family
&&
614 comp_with_mask_sock((struct sockaddr
*)&client_p
->localClient
->ip
,
615 (struct sockaddr
*)&sockaddr
, bits
))
619 if (match(kline
->host
, client_p
->orighost
))
621 if (IsConfDoSpoofIp(client_p
->localClient
->att_conf
) &&
622 IsConfKlineSpoof(client_p
->localClient
->att_conf
))
624 if (match(kline
->host
, client_p
->sockhost
))
632 if(IsExemptKline(client_p
))
634 sendto_realops_snomask(SNO_GENERAL
, L_NETWIDE
,
635 "KLINE over-ruled for %s, client is kline_exempt [%s@%s]",
636 get_client_name(client_p
, HIDE_IP
),
637 kline
->user
, kline
->host
);
641 sendto_realops_snomask(SNO_GENERAL
, L_NETWIDE
,
642 "KLINE active for %s (%s@%s)",
643 get_client_name(client_p
, HIDE_IP
), kline
->user
, kline
->host
);
645 notify_banned_client(client_p
, kline
, K_LINED
);
654 * side effects - all clients will be checked for dlines
659 struct Client
*client_p
;
660 struct ConfItem
*aconf
;
662 rb_dlink_node
*next_ptr
;
664 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
666 client_p
= ptr
->data
;
671 if((aconf
= find_dline((struct sockaddr
*)&client_p
->localClient
->ip
, GET_SS_FAMILY(&client_p
->localClient
->ip
))) != NULL
)
673 if(aconf
->status
& CONF_EXEMPTDLINE
)
676 sendto_realops_snomask(SNO_GENERAL
, L_NETWIDE
,
677 "DLINE active for %s (%s)",
678 get_client_name(client_p
, HIDE_IP
), aconf
->host
);
680 notify_banned_client(client_p
, aconf
, D_LINED
);
685 /* dlines need to be checked against unknowns too */
686 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, unknown_list
.head
)
688 client_p
= ptr
->data
;
690 if((aconf
= find_dline((struct sockaddr
*)&client_p
->localClient
->ip
, GET_SS_FAMILY(&client_p
->localClient
->ip
))) != NULL
)
692 if(aconf
->status
& CONF_EXEMPTDLINE
)
695 notify_banned_client(client_p
, aconf
, D_LINED
);
704 * side effects - all clients will be checked for xlines
709 struct Client
*client_p
;
710 struct ConfItem
*aconf
;
712 rb_dlink_node
*next_ptr
;
714 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
716 client_p
= ptr
->data
;
718 if(IsMe(client_p
) || !IsPerson(client_p
))
721 if((aconf
= find_xline(client_p
->info
, 1)) != NULL
)
723 if(IsExemptKline(client_p
))
725 sendto_realops_snomask(SNO_GENERAL
, L_NETWIDE
,
726 "XLINE over-ruled for %s, client is kline_exempt [%s]",
727 get_client_name(client_p
, HIDE_IP
),
732 sendto_realops_snomask(SNO_GENERAL
, L_NETWIDE
,
733 "XLINE active for %s (%s)",
734 get_client_name(client_p
, HIDE_IP
), aconf
->host
);
736 (void) exit_client(client_p
, client_p
, &me
, "Bad user info");
744 * inputs - resv, reason, time
746 * side effects - all local clients matching resv will be FNC'd
749 resv_nick_fnc(const char *mask
, const char *reason
, int temp_time
)
751 struct Client
*client_p
, *target_p
;
753 rb_dlink_node
*next_ptr
;
755 char note
[NICKLEN
+10];
757 if (!ConfigFileEntry
.resv_fnc
)
760 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
762 client_p
= ptr
->data
;
764 if(IsMe(client_p
) || !IsPerson(client_p
) || IsExemptResv(client_p
))
767 /* Skip users that already have UID nicks. */
768 if(IsDigit(client_p
->name
[0]))
771 if(match_esc(mask
, client_p
->name
))
776 sendto_realops_snomask(SNO_GENERAL
, L_NETWIDE
,
777 "RESV forced nick change for %s!%s@%s to %s; nick matched [%s] (%s)",
778 client_p
->name
, client_p
->username
, client_p
->host
, nick
, mask
, reason
);
780 sendto_realops_snomask(SNO_NCHANGE
, L_NETWIDE
,
781 "Nick change: From %s to %s [%s@%s]",
782 client_p
->name
, nick
, client_p
->username
, client_p
->host
);
787 sendto_one_notice(client_p
,
788 ":*** Nick %s is temporarily unavailable on this server.",
793 sendto_one_notice(client_p
,
794 ":*** Nick %s is no longer available on this server.",
798 /* Do all of the nick-changing gymnastics. */
799 client_p
->tsinfo
= rb_current_time();
800 whowas_add_history(client_p
, 1);
802 monitor_signoff(client_p
);
804 invalidate_bancache_user(client_p
);
806 sendto_common_channels_local(client_p
, NOCAPS
, NOCAPS
, ":%s!%s@%s NICK :%s",
807 client_p
->name
, client_p
->username
, client_p
->host
, nick
);
808 sendto_server(client_p
, NULL
, CAP_TS6
, NOCAPS
, ":%s NICK %s :%ld",
809 use_id(client_p
), nick
, (long) client_p
->tsinfo
);
811 del_from_client_hash(client_p
->name
, client_p
);
812 rb_strlcpy(client_p
->name
, nick
, sizeof(client_p
->name
));
813 add_to_client_hash(nick
, client_p
);
815 monitor_signon(client_p
);
817 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, client_p
->on_allow_list
.head
)
819 target_p
= ptr
->data
;
820 rb_dlinkFindDestroy(client_p
, &target_p
->localClient
->allow_list
);
821 rb_dlinkDestroy(ptr
, &client_p
->on_allow_list
);
824 snprintf(note
, sizeof(note
), "Nick: %s", nick
);
825 rb_note(client_p
->localClient
->F
, note
);
831 * update_client_exit_stats
833 * input - pointer to client
838 update_client_exit_stats(struct Client
*client_p
)
840 if(IsServer(client_p
))
842 sendto_realops_snomask(SNO_EXTERNAL
, L_ALL
,
843 "Server %s split from %s",
844 client_p
->name
, client_p
->servptr
->name
);
845 if(HasSentEob(client_p
))
848 else if(IsClient(client_p
))
853 if(IsInvisible(client_p
))
857 if(splitchecking
&& !splitmode
)
858 check_splitmode(NULL
);
862 * release_client_state
864 * input - pointer to client to release
869 release_client_state(struct Client
*client_p
)
871 if(client_p
->user
!= NULL
)
873 free_user(client_p
->user
, client_p
); /* try this here */
877 if(client_p
->serv
->user
!= NULL
)
878 free_user(client_p
->serv
->user
, client_p
);
879 if(client_p
->serv
->fullcaps
)
880 rb_free(client_p
->serv
->fullcaps
);
881 rb_free(client_p
->serv
);
886 * remove_client_from_list
887 * inputs - point to client to remove
889 * side effects - taken the code from ExitOneClient() for this
890 * and placed it here. - avalon
893 remove_client_from_list(struct Client
*client_p
)
895 s_assert(NULL
!= client_p
);
900 /* A client made with make_client()
901 * is on the unknown_list until removed.
902 * If it =does= happen to exit before its removed from that list
903 * and its =not= on the global_client_list, it will core here.
904 * short circuit that case now -db
906 if(client_p
->node
.prev
== NULL
&& client_p
->node
.next
== NULL
)
909 rb_dlinkDelete(&client_p
->node
, &global_client_list
);
911 update_client_exit_stats(client_p
);
917 * input - nickname to check, flag for nick from local client
918 * output - 0 if erroneous, else 1
922 clean_nick(const char *nick
, int loc_client
)
926 /* nicks cant start with a digit or -, and must have a length */
927 if(*nick
== '-' || *nick
== '\0')
930 if(loc_client
&& IsDigit(*nick
))
936 if(!IsNickChar(*nick
))
941 if(len
>= NICKLEN
&& (unsigned int)len
>= ConfigFileEntry
.nicklen
)
948 * find_person - find person by (nick)name.
949 * inputs - pointer to name
950 * output - return client pointer
954 find_person(const char *name
)
956 struct Client
*c2ptr
;
958 c2ptr
= find_client(name
);
960 if(c2ptr
&& IsPerson(c2ptr
))
966 find_named_person(const char *name
)
968 struct Client
*c2ptr
;
970 c2ptr
= find_named_client(name
);
972 if(c2ptr
&& IsPerson(c2ptr
))
979 * find_chasing - find the client structure for a nick name (user)
980 * using history mechanism if necessary. If the client is not found,
981 * an error message (NO SUCH NICK) is generated. If the client was found
982 * through the history, chasing will be 1 and otherwise 0.
985 find_chasing(struct Client
*source_p
, const char *user
, int *chasing
)
989 if(MyClient(source_p
))
990 who
= find_named_person(user
);
992 who
= find_person(user
);
997 if(who
|| IsDigit(*user
))
1000 if(!(who
= whowas_get_history(user
, (long) KILLCHASETIMELIMIT
)))
1002 sendto_one_numeric(source_p
, ERR_NOSUCHNICK
,
1003 form_str(ERR_NOSUCHNICK
), user
);
1012 * get_client_name - Return the name of the client
1013 * for various tracking and
1014 * admin purposes. The main purpose of this function is to
1015 * return the "socket host" name of the client, if that
1016 * differs from the advertised name (other than case).
1017 * But, this can be used to any client structure.
1020 * Watch out the allocation of "nbuf", if either source_p->name
1021 * or source_p->sockhost gets changed into pointers instead of
1022 * directly allocated within the structure...
1025 * Function return either a pointer to the structure (source_p) or
1026 * to internal buffer (nbuf). *NEVER* use the returned pointer
1027 * to modify what it points!!!
1031 get_client_name(struct Client
*client
, int showip
)
1033 static char nbuf
[HOSTLEN
* 2 + USERLEN
+ 5];
1035 s_assert(NULL
!= client
);
1039 if(MyConnect(client
))
1041 if(!irccmp(client
->name
, client
->host
))
1042 return client
->name
;
1044 if(ConfigFileEntry
.hide_spoof_ips
&&
1045 showip
== SHOW_IP
&& IsIPSpoof(client
))
1047 if(IsAnyServer(client
))
1050 /* And finally, let's get the host information, ip or name */
1054 snprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]",
1055 client
->name
, client
->username
,
1059 snprintf(nbuf
, sizeof(nbuf
), "%s[%s@255.255.255.255]",
1060 client
->name
, client
->username
);
1063 snprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]",
1064 client
->name
, client
->username
, client
->host
);
1069 /* As pointed out by Adel Mezibra
1070 * Neph|l|m@EFnet. Was missing a return here.
1072 return client
->name
;
1075 /* log_client_name()
1077 * This version is the same as get_client_name, but doesnt contain the
1078 * code that will hide IPs always. This should be used for logfiles.
1081 log_client_name(struct Client
*target_p
, int showip
)
1083 static char nbuf
[HOSTLEN
* 2 + USERLEN
+ 5];
1085 if(target_p
== NULL
)
1088 if(MyConnect(target_p
))
1090 if(irccmp(target_p
->name
, target_p
->host
) == 0)
1091 return target_p
->name
;
1096 snprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]", target_p
->name
,
1097 target_p
->username
, target_p
->sockhost
);
1101 snprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]", target_p
->name
,
1102 target_p
->username
, target_p
->host
);
1108 return target_p
->name
;
1111 /* is_remote_connect - Returns whether a server was /connect'ed by a remote
1112 * oper (send notices netwide) */
1114 is_remote_connect(struct Client
*client_p
)
1116 struct Client
*oper
;
1118 if (client_p
->serv
== NULL
)
1120 oper
= find_named_person(client_p
->serv
->by
);
1121 return oper
!= NULL
&& IsOper(oper
) && !MyConnect(oper
);
1125 free_exited_clients(void *unused
)
1127 rb_dlink_node
*ptr
, *next
;
1128 struct Client
*target_p
;
1130 RB_DLINK_FOREACH_SAFE(ptr
, next
, dead_list
.head
)
1132 target_p
= ptr
->data
;
1134 #ifdef DEBUG_EXITED_CLIENTS
1136 struct abort_client
*abt
;
1137 rb_dlink_node
*aptr
;
1140 RB_DLINK_FOREACH(aptr
, abort_list
.head
)
1143 if(abt
->client
== target_p
)
1146 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1147 "On abort_list: %s stat: %u flags: %llu handler: %c",
1148 target_p
->name
, (unsigned int) target_p
->status
,
1149 (unsigned long long)target_p
->flags
, target_p
->handler
);
1150 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1151 "Please report this to the solanum developers!");
1158 rb_dlinkDestroy(ptr
, &dead_list
);
1164 if(ptr
->data
== NULL
)
1166 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1167 "Warning: null client on dead_list!");
1168 rb_dlinkDestroy(ptr
, &dead_list
);
1171 release_client_state(target_p
);
1172 free_client(target_p
);
1173 rb_dlinkDestroy(ptr
, &dead_list
);
1176 #ifdef DEBUG_EXITED_CLIENTS
1177 RB_DLINK_FOREACH_SAFE(ptr
, next
, dead_remote_list
.head
)
1179 target_p
= ptr
->data
;
1181 if(ptr
->data
== NULL
)
1183 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1184 "Warning: null client on dead_list!");
1185 rb_dlinkDestroy(ptr
, &dead_list
);
1188 release_client_state(target_p
);
1189 free_client(target_p
);
1190 rb_dlinkDestroy(ptr
, &dead_remote_list
);
1197 ** Remove all clients that depend on source_p; assumes all (S)QUITs have
1198 ** already been sent. we make sure to exit a server's dependent clients
1199 ** and servers before the server itself; exit_one_client takes care of
1200 ** actually removing things off llists. tweaked from +CSr31 -orabidoo
1203 * added sanity test code.... source_p->serv might be NULL...
1206 recurse_remove_clients(struct Client
*source_p
, const char *comment
)
1208 struct Client
*target_p
;
1209 rb_dlink_node
*ptr
, *ptr_next
;
1214 if(source_p
->serv
== NULL
) /* oooops. uh this is actually a major bug */
1217 /* this is very ugly, but it saves cpu :P */
1218 if(ConfigFileEntry
.nick_delay
> 0)
1220 RB_DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->users
.head
)
1222 target_p
= ptr
->data
;
1223 target_p
->flags
|= FLAGS_KILLED
;
1224 add_nd_entry(target_p
->name
);
1226 if(!IsDead(target_p
) && !IsClosing(target_p
))
1227 exit_remote_client(NULL
, target_p
, &me
, comment
);
1232 RB_DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->users
.head
)
1234 target_p
= ptr
->data
;
1235 target_p
->flags
|= FLAGS_KILLED
;
1237 if(!IsDead(target_p
) && !IsClosing(target_p
))
1238 exit_remote_client(NULL
, target_p
, &me
, comment
);
1242 RB_DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->servers
.head
)
1244 target_p
= ptr
->data
;
1245 recurse_remove_clients(target_p
, comment
);
1246 qs_server(NULL
, target_p
, &me
, comment
);
1251 ** Remove *everything* that depends on source_p, from all lists, and sending
1252 ** all necessary SQUITs. source_p itself is still on the lists,
1253 ** and its SQUITs have been sent except for the upstream one -orabidoo
1256 remove_dependents(struct Client
*client_p
,
1257 struct Client
*source_p
,
1258 struct Client
*from
, const char *comment
, const char *comment1
)
1261 rb_dlink_node
*ptr
, *next
;
1263 RB_DLINK_FOREACH_SAFE(ptr
, next
, serv_list
.head
)
1267 if(IsMe(to
) || to
== source_p
->from
|| to
== client_p
)
1270 sendto_one(to
, "SQUIT %s :%s", get_id(source_p
, to
), comment
);
1273 recurse_remove_clients(source_p
, comment1
);
1277 exit_aborted_clients(void *unused
)
1279 struct abort_client
*abt
;
1280 rb_dlink_node
*ptr
, *next
;
1281 RB_DLINK_FOREACH_SAFE(ptr
, next
, abort_list
.head
)
1285 #ifdef DEBUG_EXITED_CLIENTS
1287 if(rb_dlinkFind(abt
->client
, &dead_list
))
1290 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1291 "On dead_list: %s stat: %u flags: %llu handler: %c",
1292 abt
->client
->name
, (unsigned int) abt
->client
->status
,
1293 (unsigned long long)abt
->client
->flags
, abt
->client
->handler
);
1294 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1295 "Please report this to the solanum developers!");
1301 s_assert(*((unsigned long*)abt
->client
) != 0xdeadbeef); /* This is lame but its a debug thing */
1302 rb_dlinkDelete(ptr
, &abort_list
);
1304 if(IsAnyServer(abt
->client
))
1305 sendto_realops_snomask(SNO_GENERAL
, L_NETWIDE
,
1306 "Closing link to %s: %s",
1307 abt
->client
->name
, abt
->notice
);
1309 /* its no longer on abort list - we *must* remove
1310 * FLAGS_CLOSING otherwise exit_client() will not run --fl
1312 abt
->client
->flags
&= ~FLAGS_CLOSING
;
1313 exit_client(abt
->client
, abt
->client
, &me
, abt
->notice
);
1320 * dead_link - Adds client to a list of clients that need an exit_client()
1323 dead_link(struct Client
*client_p
, int sendqex
)
1325 struct abort_client
*abt
;
1327 s_assert(!IsMe(client_p
));
1328 if(IsDead(client_p
) || IsClosing(client_p
) || IsMe(client_p
))
1331 abt
= (struct abort_client
*) rb_malloc(sizeof(struct abort_client
));
1334 rb_strlcpy(abt
->notice
, "Max SendQ exceeded", sizeof(abt
->notice
));
1336 snprintf(abt
->notice
, sizeof(abt
->notice
), "Write error: %s", strerror(errno
));
1338 abt
->client
= client_p
;
1339 SetIOError(client_p
);
1341 SetClosing(client_p
);
1342 rb_dlinkAdd(abt
, &abt
->node
, &abort_list
);
1346 /* This does the remove of the user from channels..local or remote */
1348 exit_generic_client(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1349 const char *comment
)
1351 rb_dlink_node
*ptr
, *next_ptr
;
1353 if(IsOper(source_p
))
1354 rb_dlinkFindDestroy(source_p
, &oper_list
);
1356 sendto_common_channels_local(source_p
, NOCAPS
, NOCAPS
, ":%s!%s@%s QUIT :%s",
1358 source_p
->username
, source_p
->host
, comment
);
1360 remove_user_from_channels(source_p
);
1362 /* Should not be in any channels now */
1363 s_assert(source_p
->user
->channel
.head
== NULL
);
1365 /* Clean up invitefield */
1366 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, source_p
->user
->invited
.head
)
1368 del_invite(ptr
->data
, source_p
);
1371 /* Clean up allow lists */
1372 del_all_accepts(source_p
);
1374 whowas_add_history(source_p
, 0);
1375 whowas_off_history(source_p
);
1377 monitor_signoff(source_p
);
1379 if(has_id(source_p
))
1380 del_from_id_hash(source_p
->id
, source_p
);
1382 del_from_hostname_hash(source_p
->orighost
, source_p
);
1383 del_from_client_hash(source_p
->name
, source_p
);
1384 remove_client_from_list(source_p
);
1388 * Assumes IsPerson(source_p) && !MyConnect(source_p)
1392 exit_remote_client(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1393 const char *comment
)
1395 exit_generic_client(client_p
, source_p
, from
, comment
);
1397 if(source_p
->servptr
&& source_p
->servptr
->serv
)
1399 rb_dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->users
);
1402 if((source_p
->flags
& FLAGS_KILLED
) == 0)
1404 sendto_server(client_p
, NULL
, CAP_TS6
, NOCAPS
,
1405 ":%s QUIT :%s", use_id(source_p
), comment
);
1409 #ifdef DEBUG_EXITED_CLIENTS
1410 rb_dlinkAddAlloc(source_p
, &dead_remote_list
);
1412 rb_dlinkAddAlloc(source_p
, &dead_list
);
1414 return(CLIENT_EXITED
);
1418 * This assumes IsUnknown(source_p) == true and MyConnect(source_p) == true
1422 exit_unknown_client(struct Client
*client_p
, /* The local client originating the
1423 * exit or NULL, if this exit is
1424 * generated by this server for
1426 * This will not get any of the
1427 * generated messages. */
1428 struct Client
*source_p
, /* Client exiting */
1429 struct Client
*from
, /* Client firing off this Exit,
1431 const char *comment
)
1433 authd_abort_client(source_p
);
1434 rb_dlinkDelete(&source_p
->localClient
->tnode
, &unknown_list
);
1436 if(!IsIOError(source_p
))
1437 sendto_one(source_p
, "ERROR :Closing Link: %s (%s)",
1438 source_p
->user
!= NULL
? source_p
->host
: "127.0.0.1",
1441 close_connection(source_p
);
1443 if(has_id(source_p
))
1444 del_from_id_hash(source_p
->id
, source_p
);
1446 del_from_hostname_hash(source_p
->host
, source_p
);
1447 if (!IsAnyServer(source_p
))
1448 del_from_client_hash(source_p
->name
, source_p
);
1449 remove_client_from_list(source_p
);
1451 rb_dlinkAddAlloc(source_p
, &dead_list
);
1453 /* Note that we don't need to add unknowns to the dead_list */
1454 return(CLIENT_EXITED
);
1458 exit_remote_server(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1459 const char *comment
)
1461 static char comment1
[(HOSTLEN
*2)+2];
1462 static char newcomment
[BUFSIZE
];
1463 struct Client
*target_p
;
1465 if(ConfigServerHide
.flatten_links
)
1466 strcpy(comment1
, "*.net *.split");
1469 strcpy(comment1
, source_p
->servptr
->name
);
1470 strcat(comment1
, " ");
1471 strcat(comment1
, source_p
->name
);
1474 snprintf(newcomment
, sizeof(newcomment
), "by %s: %s",
1475 from
->name
, comment
);
1477 remove_dependents(client_p
, source_p
, from
, IsPerson(from
) ? newcomment
: comment
, comment1
);
1479 rb_dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->servers
);
1481 rb_dlinkFindDestroy(source_p
, &global_serv_list
);
1482 target_p
= source_p
->from
;
1484 if(target_p
!= NULL
&& IsServer(target_p
) && target_p
!= client_p
&&
1485 !IsMe(target_p
) && (source_p
->flags
& FLAGS_KILLED
) == 0)
1487 sendto_one(target_p
, ":%s SQUIT %s :%s",
1488 get_id(from
, target_p
), get_id(source_p
, target_p
),
1492 if(has_id(source_p
))
1493 del_from_id_hash(source_p
->id
, source_p
);
1495 del_from_client_hash(source_p
->name
, source_p
);
1496 remove_client_from_list(source_p
);
1498 scache_split(source_p
->serv
->nameinfo
);
1501 #ifdef DEBUG_EXITED_CLIENTS
1502 rb_dlinkAddAlloc(source_p
, &dead_remote_list
);
1504 rb_dlinkAddAlloc(source_p
, &dead_list
);
1510 qs_server(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1511 const char *comment
)
1513 if(source_p
->servptr
&& source_p
->servptr
->serv
)
1514 rb_dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->servers
);
1518 rb_dlinkFindDestroy(source_p
, &global_serv_list
);
1520 if(has_id(source_p
))
1521 del_from_id_hash(source_p
->id
, source_p
);
1523 del_from_client_hash(source_p
->name
, source_p
);
1524 remove_client_from_list(source_p
);
1525 scache_split(source_p
->serv
->nameinfo
);
1528 rb_dlinkAddAlloc(source_p
, &dead_list
);
1533 exit_local_server(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1534 const char *comment
)
1536 static char comment1
[(HOSTLEN
*2)+2];
1537 static char newcomment
[BUFSIZE
];
1538 unsigned int sendk
, recvk
;
1540 rb_dlinkDelete(&source_p
->localClient
->tnode
, &serv_list
);
1541 rb_dlinkFindDestroy(source_p
, &global_serv_list
);
1543 sendk
= source_p
->localClient
->sendK
;
1544 recvk
= source_p
->localClient
->receiveK
;
1546 /* Always show source here, so the server notices show
1547 * which side initiated the split -- jilles
1549 snprintf(newcomment
, sizeof(newcomment
), "by %s: %s",
1550 from
== source_p
? me
.name
: from
->name
, comment
);
1551 if (!IsIOError(source_p
))
1552 sendto_one(source_p
, "SQUIT %s :%s", use_id(source_p
),
1554 if(client_p
!= NULL
&& source_p
!= client_p
&& !IsIOError(source_p
))
1556 sendto_one(source_p
, "ERROR :Closing Link: 127.0.0.1 %s (%s)",
1557 source_p
->name
, comment
);
1560 if(source_p
->servptr
&& source_p
->servptr
->serv
)
1561 rb_dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->servers
);
1566 close_connection(source_p
);
1568 if(ConfigServerHide
.flatten_links
)
1569 strcpy(comment1
, "*.net *.split");
1572 strcpy(comment1
, source_p
->servptr
->name
);
1573 strcat(comment1
, " ");
1574 strcat(comment1
, source_p
->name
);
1577 if(source_p
->serv
!= NULL
)
1578 remove_dependents(client_p
, source_p
, from
, IsPerson(from
) ? newcomment
: comment
, comment1
);
1580 sendto_realops_snomask(SNO_GENERAL
, L_ALL
, "%s was connected"
1581 " for %ld seconds. %d/%d sendK/recvK.",
1582 source_p
->name
, (long) rb_current_time() - source_p
->localClient
->firsttime
, sendk
, recvk
);
1584 ilog(L_SERVER
, "%s was connected for %ld seconds. %d/%d sendK/recvK.",
1585 source_p
->name
, (long) rb_current_time() - source_p
->localClient
->firsttime
, sendk
, recvk
);
1587 if(has_id(source_p
))
1588 del_from_id_hash(source_p
->id
, source_p
);
1590 del_from_client_hash(source_p
->name
, source_p
);
1591 remove_client_from_list(source_p
);
1592 scache_split(source_p
->serv
->nameinfo
);
1595 rb_dlinkAddAlloc(source_p
, &dead_list
);
1601 * This assumes IsPerson(source_p) == true && MyConnect(source_p) == true
1605 exit_local_client(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1606 const char *comment
)
1608 unsigned long on_for
;
1611 exit_generic_client(client_p
, source_p
, from
, comment
);
1612 clear_monitor(source_p
);
1614 s_assert(IsPerson(source_p
));
1615 rb_dlinkDelete(&source_p
->localClient
->tnode
, &lclient_list
);
1616 rb_dlinkDelete(&source_p
->lnode
, &me
.serv
->users
);
1618 if(IsOper(source_p
))
1619 rb_dlinkFindDestroy(source_p
, &local_oper_list
);
1621 sendto_realops_snomask(SNO_CCONN
, L_ALL
,
1622 "Client exiting: %s (%s@%s) [%s] [%s]",
1624 source_p
->username
, source_p
->host
, comment
,
1625 show_ip(NULL
, source_p
) ? source_p
->sockhost
: "255.255.255.255");
1627 sendto_realops_snomask(SNO_CCONNEXT
, L_ALL
,
1628 "CLIEXIT %s %s %s %s 0 %s",
1629 source_p
->name
, source_p
->username
, source_p
->host
,
1630 show_ip(NULL
, source_p
) ? source_p
->sockhost
: "255.255.255.255",
1633 on_for
= rb_current_time() - source_p
->localClient
->firsttime
;
1635 ilog(L_USER
, "%s (%3lu:%02lu:%02lu): %s!%s@%s %s %d/%d",
1636 rb_ctime(rb_current_time(), tbuf
, sizeof(tbuf
)), on_for
/ 3600,
1637 (on_for
% 3600) / 60, on_for
% 60,
1638 source_p
->name
, source_p
->username
, source_p
->host
,
1640 source_p
->localClient
->sendK
, source_p
->localClient
->receiveK
);
1642 sendto_one(source_p
, "ERROR :Closing Link: %s (%s)", source_p
->host
, comment
);
1643 close_connection(source_p
);
1645 if((source_p
->flags
& FLAGS_KILLED
) == 0)
1647 sendto_server(client_p
, NULL
, CAP_TS6
, NOCAPS
,
1648 ":%s QUIT :%s", use_id(source_p
), comment
);
1652 rb_dlinkAddAlloc(source_p
, &dead_list
);
1653 return(CLIENT_EXITED
);
1658 ** exit_client - This is old "m_bye". Name changed, because this is not a
1659 ** protocol function, but a general server utility function.
1661 ** This function exits a client of *any* type (user, server, etc)
1662 ** from this server. Also, this generates all necessary prototol
1663 ** messages that this exit may cause.
1665 ** 1) If the client is a local client, then this implicitly
1666 ** exits all other clients depending on this connection (e.g.
1667 ** remote clients having 'from'-field that points to this.
1669 ** 2) If the client is a remote client, then only this is exited.
1671 ** For convenience, this function returns a suitable value for
1672 ** m_function return value:
1674 ** CLIENT_EXITED if (client_p == source_p)
1675 ** 0 if (client_p != source_p)
1678 exit_client(struct Client
*client_p
, /* The local client originating the
1679 * exit or NULL, if this exit is
1680 * generated by this server for
1682 * This will not get any of the
1683 * generated messages. */
1684 struct Client
*source_p
, /* Client exiting */
1685 struct Client
*from
, /* Client firing off this Exit,
1687 const char *comment
/* Reason for the exit */
1692 hook_data_client_exit hdata
;
1693 if(IsClosing(source_p
))
1696 /* note, this HAS to be here, when we exit a client we attempt to
1697 * send them data, if this generates a write error we must *not* add
1698 * them to the abort list --fl
1700 SetClosing(source_p
);
1702 hdata
.local_link
= client_p
;
1703 hdata
.target
= source_p
;
1705 hdata
.comment
= comment
;
1706 call_hook(h_client_exit
, &hdata
);
1708 if(MyConnect(source_p
))
1710 /* Local clients of various types */
1711 if(IsPerson(source_p
))
1712 ret
= exit_local_client(client_p
, source_p
, from
, comment
);
1713 else if(IsServer(source_p
))
1714 ret
= exit_local_server(client_p
, source_p
, from
, comment
);
1715 /* IsUnknown || IsConnecting || IsHandShake */
1716 else if(!IsReject(source_p
))
1717 ret
= exit_unknown_client(client_p
, source_p
, from
, comment
);
1722 if(IsPerson(source_p
))
1723 ret
= exit_remote_client(client_p
, source_p
, from
, comment
);
1724 else if(IsServer(source_p
))
1725 ret
= exit_remote_server(client_p
, source_p
, from
, comment
);
1728 call_hook(h_after_client_exit
, NULL
);
1734 * Count up local client memory
1737 /* XXX one common Client list now */
1739 count_local_client_memory(size_t * count
, size_t * local_client_memory_used
)
1742 rb_bh_usage(lclient_heap
, count
, NULL
, &lusage
, NULL
);
1743 *local_client_memory_used
= lusage
+ (*count
* (sizeof(void *) + sizeof(struct Client
)));
1747 * Count up remote client memory
1750 count_remote_client_memory(size_t * count
, size_t * remote_client_memory_used
)
1752 size_t lcount
, rcount
;
1753 rb_bh_usage(lclient_heap
, &lcount
, NULL
, NULL
, NULL
);
1754 rb_bh_usage(client_heap
, &rcount
, NULL
, NULL
, NULL
);
1755 *count
= rcount
- lcount
;
1756 *remote_client_memory_used
= *count
* (sizeof(void *) + sizeof(struct Client
));
1761 * accept processing, this adds a form of "caller ID" to ircd
1763 * If a client puts themselves into "caller ID only" mode,
1764 * only clients that match a client pointer they have put on
1765 * the accept list will be allowed to message them.
1767 * [ source.on_allow_list ] -> [ target1 ] -> [ target2 ]
1769 * [target.allow_list] -> [ source1 ] -> [source2 ]
1771 * i.e. a target will have a link list of source pointers it will allow
1772 * each source client then has a back pointer pointing back
1773 * to the client that has it on its accept list.
1774 * This allows for exit_one_client to remove these now bogus entries
1775 * from any client having an accept on them.
1780 * inputs - pointer to exiting client
1782 * side effects - Walk through given clients allow_list and on_allow_list
1783 * remove all references to this client
1786 del_all_accepts(struct Client
*client_p
)
1789 rb_dlink_node
*next_ptr
;
1790 struct Client
*target_p
;
1792 if(MyClient(client_p
) && client_p
->localClient
->allow_list
.head
)
1794 /* clear this clients accept list, and remove them from
1795 * everyones on_accept_list
1797 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, client_p
->localClient
->allow_list
.head
)
1799 target_p
= ptr
->data
;
1800 rb_dlinkFindDestroy(client_p
, &target_p
->on_allow_list
);
1801 rb_dlinkDestroy(ptr
, &client_p
->localClient
->allow_list
);
1805 /* remove this client from everyones accept list */
1806 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, client_p
->on_allow_list
.head
)
1808 target_p
= ptr
->data
;
1809 rb_dlinkFindDestroy(client_p
, &target_p
->localClient
->allow_list
);
1810 rb_dlinkDestroy(ptr
, &client_p
->on_allow_list
);
1815 * show_ip() - asks if the true IP should be shown when source is
1816 * asking for info about target
1818 * Inputs - source_p who is asking
1819 * - target_p who do we want the info on
1820 * Output - returns 1 if clear IP can be shown, otherwise 0
1821 * Side Effects - none
1825 show_ip(struct Client
*source_p
, struct Client
*target_p
)
1827 if(IsAnyServer(target_p
))
1831 else if(IsIPSpoof(target_p
))
1833 /* source == NULL indicates message is being sent
1836 if(!ConfigFileEntry
.hide_spoof_ips
&&
1837 (source_p
== NULL
|| HasPrivilege(source_p
, "auspex:hostname")))
1841 else if(IsDynSpoof(target_p
) && (source_p
!= NULL
&& !HasPrivilege(source_p
, "auspex:hostname")))
1848 show_ip_conf(struct ConfItem
*aconf
, struct Client
*source_p
)
1850 if(IsConfDoSpoofIp(aconf
))
1852 if(!ConfigFileEntry
.hide_spoof_ips
&& MyOper(source_p
))
1862 show_ip_whowas(struct Whowas
*whowas
, struct Client
*source_p
)
1864 if(whowas
->flags
& WHOWAS_IP_SPOOFING
)
1865 if(ConfigFileEntry
.hide_spoof_ips
|| !MyOper(source_p
))
1867 if(whowas
->flags
& WHOWAS_DYNSPOOF
)
1868 if(!IsOper(source_p
))
1876 * inputs - pointer to client struct
1877 * output - pointer to struct User
1878 * side effects - add's an User information block to a client
1879 * if it was not previously allocated.
1882 make_user(struct Client
*client_p
)
1886 user
= client_p
->user
;
1889 user
= (struct User
*) rb_bh_alloc(user_heap
);
1891 client_p
->user
= user
;
1899 * inputs - pointer to client struct
1900 * output - pointer to server_t
1901 * side effects - add's an Server information block to a client
1902 * if it was not previously allocated.
1905 make_server(struct Client
*client_p
)
1907 struct Server
*serv
= client_p
->serv
;
1911 serv
= (struct Server
*) rb_malloc(sizeof(struct Server
));
1912 client_p
->serv
= serv
;
1914 return client_p
->serv
;
1920 * inputs - pointer to user struct
1921 * - pointer to client struct
1923 * side effects - Decrease user reference count by one and release block,
1924 * if count reaches 0
1927 free_user(struct User
*user
, struct Client
*client_p
)
1929 free_away(client_p
);
1931 if(--user
->refcnt
<= 0)
1934 rb_free((char *) user
->away
);
1935 rb_free(user
->opername
);
1937 privilegeset_unref(user
->privset
);
1941 if(user
->refcnt
< 0 || user
->invited
.head
|| user
->channel
.head
)
1943 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1944 "* %p user (%s!%s@%s) %p %p %p %lu %d *",
1946 client_p
? client_p
->
1953 rb_dlink_list_length(&user
->channel
),
1955 s_assert(!user
->refcnt
);
1956 s_assert(!user
->invited
.head
);
1957 s_assert(!user
->channel
.head
);
1960 rb_bh_free(user_heap
, user
);
1965 allocate_away(struct Client
*client_p
)
1967 if(client_p
->user
->away
== NULL
)
1968 client_p
->user
->away
= rb_bh_alloc(away_heap
);
1973 free_away(struct Client
*client_p
)
1975 if(client_p
->user
!= NULL
&& client_p
->user
->away
!= NULL
) {
1976 rb_bh_free(away_heap
, client_p
->user
->away
);
1977 client_p
->user
->away
= NULL
;
1986 for(i
= 0; i
< 3; i
++)
1987 current_uid
[i
] = me
.id
[i
];
1989 for(i
= 3; i
< 9; i
++)
1990 current_uid
[i
] = 'A';
1992 current_uid
[9] = '\0';
1999 static int flipped
= 0;
2003 for(i
= 8; i
> 3; i
--)
2005 if(current_uid
[i
] == 'Z')
2007 current_uid
[i
] = '0';
2010 else if(current_uid
[i
] != '9')
2016 current_uid
[i
] = 'A';
2019 /* if this next if() triggers, we're fucked. */
2020 if(current_uid
[3] == 'Z')
2022 current_uid
[i
] = 'A';
2028 /* if this happens..well, i'm not sure what to say, but lets handle it correctly */
2029 if(rb_unlikely(flipped
))
2031 /* this slows down uid generation a bit... */
2032 if(find_id(current_uid
) != NULL
)
2040 * Close the physical connection. This function must make
2041 * MyConnect(client_p) == FALSE, and set client_p->from == NULL.
2044 close_connection(struct Client
*client_p
)
2046 s_assert(client_p
!= NULL
);
2047 if(client_p
== NULL
)
2050 s_assert(MyConnect(client_p
));
2051 if(!MyConnect(client_p
))
2054 if(IsServer(client_p
))
2056 struct server_conf
*server_p
;
2058 ServerStats
.is_sv
++;
2059 ServerStats
.is_sbs
+= client_p
->localClient
->sendB
;
2060 ServerStats
.is_sbr
+= client_p
->localClient
->receiveB
;
2061 ServerStats
.is_sti
+= (unsigned long long)(rb_current_time() - client_p
->localClient
->firsttime
);
2064 * If the connection has been up for a long amount of time, schedule
2065 * a 'quick' reconnect, else reset the next-connect cycle.
2067 if((server_p
= find_server_conf(client_p
->name
)) != NULL
)
2070 * Reschedule a faster reconnect, if this was a automatically
2071 * connected configuration entry. (Note that if we have had
2072 * a rehash in between, the status has been changed to
2073 * CONF_ILLEGAL). But only do this if it was a "good" link.
2075 server_p
->hold
= time(NULL
);
2077 (server_p
->hold
- client_p
->localClient
->lasttime
>
2078 HANGONGOODLINK
) ? HANGONRETRYDELAY
: ConFreq(server_p
->class);
2082 else if(IsClient(client_p
))
2084 ServerStats
.is_cl
++;
2085 ServerStats
.is_cbs
+= client_p
->localClient
->sendB
;
2086 ServerStats
.is_cbr
+= client_p
->localClient
->receiveB
;
2087 ServerStats
.is_cti
+= (unsigned long long)(rb_current_time() - client_p
->localClient
->firsttime
);
2090 ServerStats
.is_ni
++;
2092 client_release_connids(client_p
);
2094 if(client_p
->localClient
->F
!= NULL
)
2096 /* attempt to flush any pending dbufs. Evil, but .. -- adrian */
2097 if(!IsIOError(client_p
))
2098 send_queued(client_p
);
2100 rb_close(client_p
->localClient
->F
);
2101 client_p
->localClient
->F
= NULL
;
2104 rb_linebuf_donebuf(&client_p
->localClient
->buf_sendq
);
2105 rb_linebuf_donebuf(&client_p
->localClient
->buf_recvq
);
2106 detach_conf(client_p
);
2108 /* XXX shouldnt really be done here. */
2109 detach_server_conf(client_p
);
2111 client_p
->from
= NULL
; /* ...this should catch them! >:) --msa */
2112 ClearMyConnect(client_p
);
2113 SetIOError(client_p
);
2119 error_exit_client(struct Client
*client_p
, int error
)
2122 * ...hmm, with non-blocking sockets we might get
2123 * here from quite valid reasons, although.. why
2124 * would select report "data available" when there
2125 * wasn't... so, this must be an error anyway... --msa
2126 * actually, EOF occurs when read() returns 0 and
2127 * in due course, select() returns that fd as ready
2128 * for reading even though it ends up being an EOF. -avalon
2131 int current_error
= rb_get_sockerr(client_p
->localClient
->F
);
2133 SetIOError(client_p
);
2135 if(IsServer(client_p
) || IsHandshake(client_p
))
2139 sendto_realops_snomask(SNO_GENERAL
, L_NETWIDE
,
2140 "Server %s closed the connection",
2143 ilog(L_SERVER
, "Server %s closed the connection",
2144 log_client_name(client_p
, SHOW_IP
));
2148 sendto_realops_snomask(SNO_GENERAL
, L_NETWIDE
,
2149 "Lost connection to %s: %s",
2150 client_p
->name
, strerror(current_error
));
2151 ilog(L_SERVER
, "Lost connection to %s: %s",
2152 log_client_name(client_p
, SHOW_IP
), strerror(current_error
));
2157 rb_strlcpy(errmsg
, "Remote host closed the connection", sizeof(errmsg
));
2159 snprintf(errmsg
, sizeof(errmsg
), "Read error: %s", strerror(current_error
));
2161 exit_client(client_p
, client_p
, &me
, errmsg
);