2 * charybdis: an 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 William Pitcock
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
25 * $Id: client.c 3514 2007-06-06 16:25:21Z nenolod $
40 #include "s_newconf.h"
53 #include "blacklist.h"
56 #include "irc_dictionary.h"
60 #define DEBUG_EXITED_CLIENTS
62 static void check_pings_list(rb_dlink_list
* list
);
63 static void check_unknowns_list(rb_dlink_list
* list
);
64 static void free_exited_clients(void *unused
);
65 static void exit_aborted_clients(void *unused
);
67 static int exit_remote_client(struct Client
*, struct Client
*, struct Client
*,const char *);
68 static int exit_remote_server(struct Client
*, struct Client
*, struct Client
*,const char *);
69 static int exit_local_client(struct Client
*, struct Client
*, struct Client
*,const char *);
70 static int exit_unknown_client(struct Client
*, struct Client
*, struct Client
*,const char *);
71 static int exit_local_server(struct Client
*, struct Client
*, struct Client
*,const char *);
72 static int qs_server(struct Client
*, struct Client
*, struct Client
*, const char *comment
);
74 static EVH check_pings
;
76 static rb_bh
*client_heap
= NULL
;
77 static rb_bh
*lclient_heap
= NULL
;
78 static rb_bh
*pclient_heap
= NULL
;
79 static rb_bh
*user_heap
= NULL
;
80 static rb_bh
*away_heap
= NULL
;
81 static char current_uid
[IDLEN
];
82 static int32_t current_connid
= 0;
84 struct Dictionary
*nd_dict
= NULL
;
92 rb_dlink_list dead_list
;
93 #ifdef DEBUG_EXITED_CLIENTS
94 static rb_dlink_list dead_remote_list
;
100 struct Client
*client
;
101 char notice
[REASONLEN
];
104 static rb_dlink_list abort_list
;
112 * side effects - initialize client free memory
118 * start off the check ping event .. -- adrian
119 * Every 30 seconds is plenty -- db
121 client_heap
= rb_bh_create(sizeof(struct Client
), CLIENT_HEAP_SIZE
, "client_heap");
122 lclient_heap
= rb_bh_create(sizeof(struct LocalUser
), LCLIENT_HEAP_SIZE
, "lclient_heap");
123 pclient_heap
= rb_bh_create(sizeof(struct PreClient
), PCLIENT_HEAP_SIZE
, "pclient_heap");
124 user_heap
= rb_bh_create(sizeof(struct User
), USER_HEAP_SIZE
, "user_heap");
125 away_heap
= rb_bh_create(AWAYLEN
, AWAY_HEAP_SIZE
, "away_heap");
127 rb_event_addish("check_pings", check_pings
, NULL
, 30);
128 rb_event_addish("free_exited_clients", &free_exited_clients
, NULL
, 4);
129 rb_event_addish("exit_aborted_clients", exit_aborted_clients
, NULL
, 1);
130 rb_event_add("flood_recalc", flood_recalc
, NULL
, 1);
132 nd_dict
= irc_dictionary_create("nickdelay", irccmp
);
137 * make_client - create a new Client struct and set it to initial state.
139 * from == NULL, create local client (a client connected
142 * from, create remote client (behind a socket
143 * associated with the client defined by
144 * 'from'). ('from' is a local client!!).
147 make_client(struct Client
*from
)
149 struct Client
*client_p
= NULL
;
150 struct LocalUser
*localClient
;
152 client_p
= rb_bh_alloc(client_heap
);
156 client_p
->from
= client_p
; /* 'from' of local client is self! */
158 localClient
= rb_bh_alloc(lclient_heap
);
159 SetMyConnect(client_p
);
160 client_p
->localClient
= localClient
;
162 client_p
->localClient
->lasttime
= client_p
->localClient
->firsttime
= rb_current_time();
164 client_p
->localClient
->F
= NULL
;
166 if(current_connid
+1 == 0)
169 client_p
->localClient
->connid
= ++current_connid
;
171 if(current_connid
+1 == 0)
174 client_p
->localClient
->zconnid
= ++current_connid
;
175 add_to_cli_connid_hash(client_p
);
177 client_p
->preClient
= rb_bh_alloc(pclient_heap
);
179 /* as good a place as any... */
180 rb_dlinkAdd(client_p
, &client_p
->localClient
->tnode
, &unknown_list
);
183 { /* from is not NULL */
184 client_p
->localClient
= NULL
;
185 client_p
->preClient
= NULL
;
186 client_p
->from
= from
; /* 'from' of local client is self! */
189 SetUnknown(client_p
);
190 strcpy(client_p
->username
, "unknown");
196 free_pre_client(struct Client
*client_p
)
198 struct Blacklist
*blptr
;
200 s_assert(NULL
!= client_p
);
202 if(client_p
->preClient
== NULL
)
205 blptr
= client_p
->preClient
->dnsbl_listed
;
207 unref_blacklist(blptr
);
208 s_assert(rb_dlink_list_length(&client_p
->preClient
->dnsbl_queries
) == 0);
210 rb_bh_free(pclient_heap
, client_p
->preClient
);
211 client_p
->preClient
= NULL
;
215 free_local_client(struct Client
*client_p
)
217 s_assert(NULL
!= client_p
);
218 s_assert(&me
!= client_p
);
220 if(client_p
->localClient
== NULL
)
224 * clean up extra sockets from P-lines which have been discarded.
226 if(client_p
->localClient
->listener
)
228 s_assert(0 < client_p
->localClient
->listener
->ref_count
);
229 if(0 == --client_p
->localClient
->listener
->ref_count
230 && !client_p
->localClient
->listener
->active
)
231 free_listener(client_p
->localClient
->listener
);
232 client_p
->localClient
->listener
= 0;
235 del_from_cli_connid_hash(client_p
);
236 if(client_p
->localClient
->F
!= NULL
)
238 rb_close(client_p
->localClient
->F
);
241 if(client_p
->localClient
->passwd
)
243 memset(client_p
->localClient
->passwd
, 0,
244 strlen(client_p
->localClient
->passwd
));
245 rb_free(client_p
->localClient
->passwd
);
248 rb_free(client_p
->localClient
->auth_user
);
249 rb_free(client_p
->localClient
->challenge
);
250 rb_free(client_p
->localClient
->fullcaps
);
251 rb_free(client_p
->localClient
->opername
);
252 rb_free(client_p
->localClient
->mangledhost
);
253 if (client_p
->localClient
->privset
)
254 privilegeset_unref(client_p
->localClient
->privset
);
257 ssld_decrement_clicount(client_p
->localClient
->ssl_ctl
);
259 if(IsCapable(client_p
, CAP_ZIP
))
260 ssld_decrement_clicount(client_p
->localClient
->z_ctl
);
262 rb_bh_free(lclient_heap
, client_p
->localClient
);
263 client_p
->localClient
= NULL
;
267 free_client(struct Client
*client_p
)
269 s_assert(NULL
!= client_p
);
270 s_assert(&me
!= client_p
);
271 free_local_client(client_p
);
272 free_pre_client(client_p
);
273 rb_free(client_p
->certfp
);
274 rb_bh_free(client_heap
, client_p
);
278 * check_pings - go through the local client list and check activity
279 * kill off stuff that should die
281 * inputs - NOT USED (from event)
282 * output - next time_t when check_pings() should be called again
286 * A PING can be sent to clients as necessary.
288 * Client/Server ping outs are handled.
292 * Addon from adrian. We used to call this after nextping seconds,
293 * however I've changed it to run once a second. This is only for
294 * PING timeouts, not K/etc-line checks (thanks dianora!). Having it
295 * run once a second makes life a lot easier - when a new client connects
296 * and they need a ping in 4 seconds, if nextping was set to 20 seconds
297 * we end up waiting 20 seconds. This is stupid. :-)
298 * I will optimise (hah!) check_pings() once I've finished working on
299 * tidying up other network IO evilnesses.
304 check_pings(void *notused
)
306 check_pings_list(&lclient_list
);
307 check_pings_list(&serv_list
);
308 check_unknowns_list(&unknown_list
);
314 * inputs - pointer to list to check
319 check_pings_list(rb_dlink_list
* list
)
321 char scratch
[32]; /* way too generous but... */
322 struct Client
*client_p
; /* current local client_p being examined */
323 int ping
= 0; /* ping time value from client */
324 rb_dlink_node
*ptr
, *next_ptr
;
326 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, list
->head
)
328 client_p
= ptr
->data
;
330 if(!MyConnect(client_p
) || IsDead(client_p
))
333 ping
= get_client_ping(client_p
);
335 if(ping
< (rb_current_time() - client_p
->localClient
->lasttime
))
338 * If the client/server hasnt talked to us in 2*ping seconds
339 * and it has a ping time, then close its connection.
341 if(((rb_current_time() - client_p
->localClient
->lasttime
) >= (2 * ping
)
342 && (client_p
->flags
& FLAGS_PINGSENT
)))
344 if(IsServer(client_p
))
346 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
347 "No response from %s, closing link",
350 "No response from %s, closing link",
351 log_client_name(client_p
, HIDE_IP
));
353 (void) rb_snprintf(scratch
, sizeof(scratch
),
354 "Ping timeout: %d seconds",
355 (int) (rb_current_time() - client_p
->localClient
->lasttime
));
357 exit_client(client_p
, client_p
, &me
, scratch
);
360 else if((client_p
->flags
& FLAGS_PINGSENT
) == 0)
363 * if we havent PINGed the connection and we havent
364 * heard from it in a while, PING it to make sure
367 client_p
->flags
|= FLAGS_PINGSENT
;
368 /* not nice but does the job */
369 client_p
->localClient
->lasttime
= rb_current_time() - ping
;
370 sendto_one(client_p
, "PING :%s", me
.name
);
379 * check_unknowns_list
381 * inputs - pointer to list of unknown clients
383 * side effects - unknown clients get marked for termination after n seconds
386 check_unknowns_list(rb_dlink_list
* list
)
388 rb_dlink_node
*ptr
, *next_ptr
;
389 struct Client
*client_p
;
392 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, list
->head
)
394 client_p
= ptr
->data
;
396 if(IsDead(client_p
) || IsClosing(client_p
))
399 /* still has DNSbls to validate against */
400 if(client_p
->preClient
!= NULL
&&
401 rb_dlink_list_length(&client_p
->preClient
->dnsbl_queries
) > 0)
405 * Check UNKNOWN connections - if they have been in this state
406 * for > 30s, close them.
409 timeout
= IsAnyServer(client_p
) ? ConfigFileEntry
.connect_timeout
: 30;
410 if((rb_current_time() - client_p
->localClient
->firsttime
) > timeout
)
412 if(IsAnyServer(client_p
))
414 sendto_realops_snomask(SNO_GENERAL
, is_remote_connect(client_p
) ? L_NETWIDE
: L_ALL
,
415 "No response from %s, closing link",
418 "No response from %s, closing link",
419 log_client_name(client_p
, HIDE_IP
));
421 exit_client(client_p
, client_p
, &me
, "Connection timed out");
427 notify_banned_client(struct Client
*client_p
, struct ConfItem
*aconf
, int ban
)
429 static const char conn_closed
[] = "Connection closed";
430 static const char d_lined
[] = "D-lined";
431 static const char k_lined
[] = "K-lined";
432 const char *reason
= NULL
;
433 const char *exit_reason
= conn_closed
;
435 if(ConfigFileEntry
.kline_with_reason
)
437 reason
= get_user_ban_reason(aconf
);
438 exit_reason
= reason
;
442 reason
= aconf
->status
== D_LINED
? d_lined
: k_lined
;
445 if(ban
== D_LINED
&& !IsPerson(client_p
))
446 sendto_one(client_p
, "NOTICE DLINE :*** You have been D-lined");
448 sendto_one(client_p
, form_str(ERR_YOUREBANNEDCREEP
),
449 me
.name
, client_p
->name
, reason
);
451 exit_client(client_p
, client_p
, &me
,
452 EmptyString(ConfigFileEntry
.kline_reason
) ? exit_reason
:
453 ConfigFileEntry
.kline_reason
);
460 * side effects - Check all connections for a pending k/dline against the
461 * client, exit the client if found.
464 check_banned_lines(void)
471 /* check_klines_event()
475 * side effects - check_klines() is called, kline_queued unset
478 check_klines_event(void *unused
)
488 * side effects - all clients will be checked for klines
493 struct Client
*client_p
;
494 struct ConfItem
*aconf
;
496 rb_dlink_node
*next_ptr
;
498 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
500 client_p
= ptr
->data
;
502 if(IsMe(client_p
) || !IsPerson(client_p
))
505 if((aconf
= find_kline(client_p
)) != NULL
)
507 if(IsExemptKline(client_p
))
509 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
510 "KLINE over-ruled for %s, client is kline_exempt [%s@%s]",
511 get_client_name(client_p
, HIDE_IP
),
512 aconf
->user
, aconf
->host
);
516 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
517 "KLINE active for %s",
518 get_client_name(client_p
, HIDE_IP
));
520 notify_banned_client(client_p
, aconf
, K_LINED
);
530 * side effects - all clients will be checked for dlines
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
;
547 if((aconf
= find_dline((struct sockaddr
*)&client_p
->localClient
->ip
,client_p
->localClient
->ip
.ss_family
)) != NULL
)
549 if(aconf
->status
& CONF_EXEMPTDLINE
)
552 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
553 "DLINE active for %s",
554 get_client_name(client_p
, HIDE_IP
));
556 notify_banned_client(client_p
, aconf
, D_LINED
);
561 /* dlines need to be checked against unknowns too */
562 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, unknown_list
.head
)
564 client_p
= ptr
->data
;
566 if((aconf
= find_dline((struct sockaddr
*)&client_p
->localClient
->ip
,client_p
->localClient
->ip
.ss_family
)) != NULL
)
568 if(aconf
->status
& CONF_EXEMPTDLINE
)
571 notify_banned_client(client_p
, aconf
, D_LINED
);
580 * side effects - all clients will be checked for xlines
585 struct Client
*client_p
;
586 struct ConfItem
*aconf
;
588 rb_dlink_node
*next_ptr
;
590 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
592 client_p
= ptr
->data
;
594 if(IsMe(client_p
) || !IsPerson(client_p
))
597 if((aconf
= find_xline(client_p
->info
, 1)) != NULL
)
599 if(IsExemptKline(client_p
))
601 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
602 "XLINE over-ruled for %s, client is kline_exempt [%s]",
603 get_client_name(client_p
, HIDE_IP
),
608 sendto_realops_snomask(SNO_GENERAL
, L_ALL
, "XLINE active for %s",
609 get_client_name(client_p
, HIDE_IP
));
611 (void) exit_client(client_p
, client_p
, &me
, "Bad user info");
619 * inputs - resv, reason, time
621 * side effects - all local clients matching resv will be FNC'd
624 resv_nick_fnc(const char *mask
, const char *reason
, int temp_time
)
626 struct Client
*client_p
, *target_p
;
628 rb_dlink_node
*next_ptr
;
630 char note
[NICKLEN
+10];
632 if (!ConfigFileEntry
.resv_fnc
)
635 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
637 client_p
= ptr
->data
;
639 if(IsMe(client_p
) || !IsPerson(client_p
) || IsExemptResv(client_p
))
642 /* Skip users that already have UID nicks. */
643 if(IsDigit(client_p
->name
[0]))
646 if(match_esc(mask
, client_p
->name
))
651 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
652 "RESV forced nick change for %s!%s@%s to %s; nick matched [%s] (%s)",
653 client_p
->name
, client_p
->username
, client_p
->host
, nick
, mask
, reason
);
655 sendto_realops_snomask(SNO_NCHANGE
, L_ALL
,
656 "Nick change: From %s to %s [%s@%s]",
657 client_p
->name
, nick
, client_p
->username
, client_p
->host
);
662 sendto_one_notice(client_p
,
663 ":*** Nick %s is temporarily unavailable on this server.",
668 sendto_one_notice(client_p
,
669 ":*** Nick %s is no longer available on this server.",
673 /* Do all of the nick-changing gymnastics. */
674 client_p
->tsinfo
= rb_current_time();
675 add_history(client_p
, 1);
677 monitor_signoff(client_p
);
679 invalidate_bancache_user(client_p
);
681 sendto_common_channels_local(client_p
, NOCAPS
, NOCAPS
, ":%s!%s@%s NICK :%s",
682 client_p
->name
, client_p
->username
, client_p
->host
, nick
);
683 sendto_server(client_p
, NULL
, CAP_TS6
, NOCAPS
, ":%s NICK %s :%ld",
684 use_id(client_p
), nick
, (long) client_p
->tsinfo
);
686 del_from_client_hash(client_p
->name
, client_p
);
687 rb_strlcpy(client_p
->name
, nick
, sizeof(client_p
->name
));
688 add_to_client_hash(nick
, client_p
);
690 monitor_signon(client_p
);
692 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, client_p
->on_allow_list
.head
)
694 target_p
= ptr
->data
;
695 rb_dlinkFindDestroy(client_p
, &target_p
->localClient
->allow_list
);
696 rb_dlinkDestroy(ptr
, &client_p
->on_allow_list
);
699 rb_snprintf(note
, sizeof(note
), "Nick: %s", nick
);
700 rb_note(client_p
->localClient
->F
, note
);
706 * update_client_exit_stats
708 * input - pointer to client
713 update_client_exit_stats(struct Client
*client_p
)
715 if(IsServer(client_p
))
717 sendto_realops_snomask(SNO_EXTERNAL
, L_ALL
,
718 "Server %s split from %s",
719 client_p
->name
, client_p
->servptr
->name
);
720 if(HasSentEob(client_p
))
723 else if(IsClient(client_p
))
728 if(IsInvisible(client_p
))
732 if(splitchecking
&& !splitmode
)
733 check_splitmode(NULL
);
737 * release_client_state
739 * input - pointer to client to release
744 release_client_state(struct Client
*client_p
)
746 if(client_p
->user
!= NULL
)
748 free_user(client_p
->user
, client_p
); /* try this here */
752 if(client_p
->serv
->user
!= NULL
)
753 free_user(client_p
->serv
->user
, client_p
);
754 if(client_p
->serv
->fullcaps
)
755 rb_free(client_p
->serv
->fullcaps
);
756 rb_free(client_p
->serv
);
761 * remove_client_from_list
762 * inputs - point to client to remove
764 * side effects - taken the code from ExitOneClient() for this
765 * and placed it here. - avalon
768 remove_client_from_list(struct Client
*client_p
)
770 s_assert(NULL
!= client_p
);
775 /* A client made with make_client()
776 * is on the unknown_list until removed.
777 * If it =does= happen to exit before its removed from that list
778 * and its =not= on the global_client_list, it will core here.
779 * short circuit that case now -db
781 if(client_p
->node
.prev
== NULL
&& client_p
->node
.next
== NULL
)
784 rb_dlinkDelete(&client_p
->node
, &global_client_list
);
786 update_client_exit_stats(client_p
);
792 * input - nickname to check, flag for nick from local client
793 * output - 0 if erroneous, else 1
797 clean_nick(const char *nick
, int loc_client
)
801 /* nicks cant start with a digit or -, and must have a length */
802 if(*nick
== '-' || *nick
== '\0')
805 if(loc_client
&& IsDigit(*nick
))
811 if(!IsNickChar(*nick
))
816 if(len
>= NICKLEN
&& (unsigned int)len
>= ConfigFileEntry
.nicklen
)
823 * find_person - find person by (nick)name.
824 * inputs - pointer to name
825 * output - return client pointer
829 find_person(const char *name
)
831 struct Client
*c2ptr
;
833 c2ptr
= find_client(name
);
835 if(c2ptr
&& IsPerson(c2ptr
))
841 find_named_person(const char *name
)
843 struct Client
*c2ptr
;
845 c2ptr
= find_named_client(name
);
847 if(c2ptr
&& IsPerson(c2ptr
))
854 * find_chasing - find the client structure for a nick name (user)
855 * using history mechanism if necessary. If the client is not found,
856 * an error message (NO SUCH NICK) is generated. If the client was found
857 * through the history, chasing will be 1 and otherwise 0.
860 find_chasing(struct Client
*source_p
, const char *user
, int *chasing
)
864 if(MyClient(source_p
))
865 who
= find_named_person(user
);
867 who
= find_person(user
);
872 if(who
|| IsDigit(*user
))
875 if(!(who
= get_history(user
, (long) KILLCHASETIMELIMIT
)))
877 sendto_one_numeric(source_p
, ERR_NOSUCHNICK
,
878 form_str(ERR_NOSUCHNICK
), user
);
887 * get_client_name - Return the name of the client
888 * for various tracking and
889 * admin purposes. The main purpose of this function is to
890 * return the "socket host" name of the client, if that
891 * differs from the advertised name (other than case).
892 * But, this can be used to any client structure.
895 * Watch out the allocation of "nbuf", if either source_p->name
896 * or source_p->sockhost gets changed into pointers instead of
897 * directly allocated within the structure...
900 * Function return either a pointer to the structure (source_p) or
901 * to internal buffer (nbuf). *NEVER* use the returned pointer
902 * to modify what it points!!!
906 get_client_name(struct Client
*client
, int showip
)
908 static char nbuf
[HOSTLEN
* 2 + USERLEN
+ 5];
910 s_assert(NULL
!= client
);
914 if(MyConnect(client
))
916 if(!irccmp(client
->name
, client
->host
))
919 if(ConfigFileEntry
.hide_spoof_ips
&&
920 showip
== SHOW_IP
&& IsIPSpoof(client
))
922 if(IsAnyServer(client
))
925 /* And finally, let's get the host information, ip or name */
929 rb_snprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]",
930 client
->name
, client
->username
,
934 rb_snprintf(nbuf
, sizeof(nbuf
), "%s[%s@255.255.255.255]",
935 client
->name
, client
->username
);
938 rb_snprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]",
939 client
->name
, client
->username
, client
->host
);
944 /* As pointed out by Adel Mezibra
945 * Neph|l|m@EFnet. Was missing a return here.
952 * This version is the same as get_client_name, but doesnt contain the
953 * code that will hide IPs always. This should be used for logfiles.
956 log_client_name(struct Client
*target_p
, int showip
)
958 static char nbuf
[HOSTLEN
* 2 + USERLEN
+ 5];
963 if(MyConnect(target_p
))
965 if(irccmp(target_p
->name
, target_p
->host
) == 0)
966 return target_p
->name
;
971 rb_snprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]", target_p
->name
,
972 target_p
->username
, target_p
->sockhost
);
976 rb_snprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]", target_p
->name
,
977 target_p
->username
, target_p
->host
);
983 return target_p
->name
;
986 /* is_remote_connect - Returns whether a server was /connect'ed by a remote
987 * oper (send notices netwide) */
989 is_remote_connect(struct Client
*client_p
)
993 if (client_p
->serv
== NULL
)
995 oper
= find_named_person(client_p
->serv
->by
);
996 return oper
!= NULL
&& IsOper(oper
) && !MyConnect(oper
);
1000 free_exited_clients(void *unused
)
1002 rb_dlink_node
*ptr
, *next
;
1003 struct Client
*target_p
;
1005 RB_DLINK_FOREACH_SAFE(ptr
, next
, dead_list
.head
)
1007 target_p
= ptr
->data
;
1009 #ifdef DEBUG_EXITED_CLIENTS
1011 struct abort_client
*abt
;
1012 rb_dlink_node
*aptr
;
1015 RB_DLINK_FOREACH(aptr
, abort_list
.head
)
1018 if(abt
->client
== target_p
)
1021 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1022 "On abort_list: %s stat: %u flags: %u/%u handler: %c",
1023 target_p
->name
, (unsigned int) target_p
->status
,
1024 target_p
->flags
, target_p
->flags2
, target_p
->handler
);
1025 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1026 "Please report this to the charybdis developers!");
1033 rb_dlinkDestroy(ptr
, &dead_list
);
1039 if(ptr
->data
== NULL
)
1041 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1042 "Warning: null client on dead_list!");
1043 rb_dlinkDestroy(ptr
, &dead_list
);
1046 release_client_state(target_p
);
1047 free_client(target_p
);
1048 rb_dlinkDestroy(ptr
, &dead_list
);
1051 #ifdef DEBUG_EXITED_CLIENTS
1052 RB_DLINK_FOREACH_SAFE(ptr
, next
, dead_remote_list
.head
)
1054 target_p
= ptr
->data
;
1056 if(ptr
->data
== NULL
)
1058 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1059 "Warning: null client on dead_list!");
1060 rb_dlinkDestroy(ptr
, &dead_list
);
1063 release_client_state(target_p
);
1064 free_client(target_p
);
1065 rb_dlinkDestroy(ptr
, &dead_remote_list
);
1072 ** Remove all clients that depend on source_p; assumes all (S)QUITs have
1073 ** already been sent. we make sure to exit a server's dependent clients
1074 ** and servers before the server itself; exit_one_client takes care of
1075 ** actually removing things off llists. tweaked from +CSr31 -orabidoo
1078 * added sanity test code.... source_p->serv might be NULL...
1081 recurse_remove_clients(struct Client
*source_p
, const char *comment
)
1083 struct Client
*target_p
;
1084 rb_dlink_node
*ptr
, *ptr_next
;
1089 if(source_p
->serv
== NULL
) /* oooops. uh this is actually a major bug */
1092 /* this is very ugly, but it saves cpu :P */
1093 if(ConfigFileEntry
.nick_delay
> 0)
1095 RB_DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->users
.head
)
1097 target_p
= ptr
->data
;
1098 target_p
->flags
|= FLAGS_KILLED
;
1099 add_nd_entry(target_p
->name
);
1101 if(!IsDead(target_p
) && !IsClosing(target_p
))
1102 exit_remote_client(NULL
, target_p
, &me
, comment
);
1107 RB_DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->users
.head
)
1109 target_p
= ptr
->data
;
1110 target_p
->flags
|= FLAGS_KILLED
;
1112 if(!IsDead(target_p
) && !IsClosing(target_p
))
1113 exit_remote_client(NULL
, target_p
, &me
, comment
);
1117 RB_DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->servers
.head
)
1119 target_p
= ptr
->data
;
1120 recurse_remove_clients(target_p
, comment
);
1121 qs_server(NULL
, target_p
, &me
, comment
);
1126 ** Remove *everything* that depends on source_p, from all lists, and sending
1127 ** all necessary SQUITs. source_p itself is still on the lists,
1128 ** and its SQUITs have been sent except for the upstream one -orabidoo
1131 remove_dependents(struct Client
*client_p
,
1132 struct Client
*source_p
,
1133 struct Client
*from
, const char *comment
, const char *comment1
)
1136 rb_dlink_node
*ptr
, *next
;
1138 RB_DLINK_FOREACH_SAFE(ptr
, next
, serv_list
.head
)
1142 if(IsMe(to
) || to
== source_p
->from
|| to
== client_p
)
1145 sendto_one(to
, "SQUIT %s :%s", get_id(source_p
, to
), comment
);
1148 recurse_remove_clients(source_p
, comment1
);
1152 exit_aborted_clients(void *unused
)
1154 struct abort_client
*abt
;
1155 rb_dlink_node
*ptr
, *next
;
1156 RB_DLINK_FOREACH_SAFE(ptr
, next
, abort_list
.head
)
1160 #ifdef DEBUG_EXITED_CLIENTS
1162 if(rb_dlinkFind(abt
->client
, &dead_list
))
1165 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1166 "On dead_list: %s stat: %u flags: %u/%u handler: %c",
1167 abt
->client
->name
, (unsigned int) abt
->client
->status
,
1168 abt
->client
->flags
, abt
->client
->flags2
, abt
->client
->handler
);
1169 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1170 "Please report this to the charybdis developers!");
1176 s_assert(*((unsigned long*)abt
->client
) != 0xdeadbeef); /* This is lame but its a debug thing */
1177 rb_dlinkDelete(ptr
, &abort_list
);
1179 if(IsAnyServer(abt
->client
))
1180 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1181 "Closing link to %s: %s",
1182 abt
->client
->name
, abt
->notice
);
1184 /* its no longer on abort list - we *must* remove
1185 * FLAGS_CLOSING otherwise exit_client() will not run --fl
1187 abt
->client
->flags
&= ~FLAGS_CLOSING
;
1188 exit_client(abt
->client
, abt
->client
, &me
, abt
->notice
);
1195 * dead_link - Adds client to a list of clients that need an exit_client()
1199 dead_link(struct Client
*client_p
, int sendqex
)
1201 struct abort_client
*abt
;
1203 s_assert(!IsMe(client_p
));
1204 if(IsDead(client_p
) || IsClosing(client_p
) || IsMe(client_p
))
1207 abt
= (struct abort_client
*) rb_malloc(sizeof(struct abort_client
));
1210 rb_strlcpy(abt
->notice
, "Max SendQ exceeded", sizeof(abt
->notice
));
1212 rb_snprintf(abt
->notice
, sizeof(abt
->notice
), "Write error: %s", strerror(errno
));
1214 abt
->client
= client_p
;
1215 SetIOError(client_p
);
1217 SetClosing(client_p
);
1218 rb_dlinkAdd(abt
, &abt
->node
, &abort_list
);
1222 /* This does the remove of the user from channels..local or remote */
1224 exit_generic_client(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1225 const char *comment
)
1227 rb_dlink_node
*ptr
, *next_ptr
;
1229 if(IsOper(source_p
))
1230 rb_dlinkFindDestroy(source_p
, &oper_list
);
1232 sendto_common_channels_local(source_p
, NOCAPS
, NOCAPS
, ":%s!%s@%s QUIT :%s",
1234 source_p
->username
, source_p
->host
, comment
);
1236 remove_user_from_channels(source_p
);
1238 /* Should not be in any channels now */
1239 s_assert(source_p
->user
->channel
.head
== NULL
);
1241 /* Clean up invitefield */
1242 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, source_p
->user
->invited
.head
)
1244 del_invite(ptr
->data
, source_p
);
1247 /* Clean up allow lists */
1248 del_all_accepts(source_p
);
1250 add_history(source_p
, 0);
1251 off_history(source_p
);
1253 monitor_signoff(source_p
);
1255 if(has_id(source_p
))
1256 del_from_id_hash(source_p
->id
, source_p
);
1258 del_from_hostname_hash(source_p
->orighost
, source_p
);
1259 del_from_client_hash(source_p
->name
, source_p
);
1260 remove_client_from_list(source_p
);
1264 * Assumes IsPerson(source_p) && !MyConnect(source_p)
1268 exit_remote_client(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1269 const char *comment
)
1271 exit_generic_client(client_p
, source_p
, from
, comment
);
1273 if(source_p
->servptr
&& source_p
->servptr
->serv
)
1275 rb_dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->users
);
1278 if((source_p
->flags
& FLAGS_KILLED
) == 0)
1280 sendto_server(client_p
, NULL
, CAP_TS6
, NOCAPS
,
1281 ":%s QUIT :%s", use_id(source_p
), comment
);
1285 #ifdef DEBUG_EXITED_CLIENTS
1286 rb_dlinkAddAlloc(source_p
, &dead_remote_list
);
1288 rb_dlinkAddAlloc(source_p
, &dead_list
);
1290 return(CLIENT_EXITED
);
1294 * This assumes IsUnknown(source_p) == TRUE and MyConnect(source_p) == TRUE
1298 exit_unknown_client(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1299 const char *comment
)
1301 delete_auth_queries(source_p
);
1302 abort_blacklist_queries(source_p
);
1303 rb_dlinkDelete(&source_p
->localClient
->tnode
, &unknown_list
);
1305 if(!IsIOError(source_p
))
1306 sendto_one(source_p
, "ERROR :Closing Link: %s (%s)",
1307 source_p
->user
!= NULL
? source_p
->host
: "127.0.0.1",
1310 close_connection(source_p
);
1312 if(has_id(source_p
))
1313 del_from_id_hash(source_p
->id
, source_p
);
1315 del_from_hostname_hash(source_p
->host
, source_p
);
1316 del_from_client_hash(source_p
->name
, source_p
);
1317 remove_client_from_list(source_p
);
1319 rb_dlinkAddAlloc(source_p
, &dead_list
);
1321 /* Note that we don't need to add unknowns to the dead_list */
1322 return(CLIENT_EXITED
);
1326 exit_remote_server(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1327 const char *comment
)
1329 static char comment1
[(HOSTLEN
*2)+2];
1330 static char newcomment
[BUFSIZE
];
1331 struct Client
*target_p
;
1333 if(ConfigServerHide
.flatten_links
)
1334 strcpy(comment1
, "*.net *.split");
1337 strcpy(comment1
, source_p
->servptr
->name
);
1338 strcat(comment1
, " ");
1339 strcat(comment1
, source_p
->name
);
1342 rb_snprintf(newcomment
, sizeof(newcomment
), "by %s: %s",
1343 from
->name
, comment
);
1345 if(source_p
->serv
!= NULL
)
1346 remove_dependents(client_p
, source_p
, from
, IsPerson(from
) ? newcomment
: comment
, comment1
);
1348 if(source_p
->servptr
&& source_p
->servptr
->serv
)
1349 rb_dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->servers
);
1353 rb_dlinkFindDestroy(source_p
, &global_serv_list
);
1354 target_p
= source_p
->from
;
1356 if(target_p
!= NULL
&& IsServer(target_p
) && target_p
!= client_p
&&
1357 !IsMe(target_p
) && (source_p
->flags
& FLAGS_KILLED
) == 0)
1359 sendto_one(target_p
, ":%s SQUIT %s :%s",
1360 get_id(from
, target_p
), get_id(source_p
, target_p
),
1364 if(has_id(source_p
))
1365 del_from_id_hash(source_p
->id
, source_p
);
1367 del_from_client_hash(source_p
->name
, source_p
);
1368 remove_client_from_list(source_p
);
1369 scache_split(source_p
->serv
->nameinfo
);
1372 #ifdef DEBUG_EXITED_CLIENTS
1373 rb_dlinkAddAlloc(source_p
, &dead_remote_list
);
1375 rb_dlinkAddAlloc(source_p
, &dead_list
);
1381 qs_server(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1382 const char *comment
)
1384 if(source_p
->servptr
&& source_p
->servptr
->serv
)
1385 rb_dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->servers
);
1389 rb_dlinkFindDestroy(source_p
, &global_serv_list
);
1391 if(has_id(source_p
))
1392 del_from_id_hash(source_p
->id
, source_p
);
1394 del_from_client_hash(source_p
->name
, source_p
);
1395 remove_client_from_list(source_p
);
1396 scache_split(source_p
->serv
->nameinfo
);
1399 rb_dlinkAddAlloc(source_p
, &dead_list
);
1404 exit_local_server(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1405 const char *comment
)
1407 static char comment1
[(HOSTLEN
*2)+2];
1408 static char newcomment
[BUFSIZE
];
1409 unsigned int sendk
, recvk
;
1411 rb_dlinkDelete(&source_p
->localClient
->tnode
, &serv_list
);
1412 rb_dlinkFindDestroy(source_p
, &global_serv_list
);
1414 sendk
= source_p
->localClient
->sendK
;
1415 recvk
= source_p
->localClient
->receiveK
;
1417 /* Always show source here, so the server notices show
1418 * which side initiated the split -- jilles
1420 rb_snprintf(newcomment
, sizeof(newcomment
), "by %s: %s",
1421 from
== source_p
? me
.name
: from
->name
, comment
);
1422 if (!IsIOError(source_p
))
1423 sendto_one(source_p
, "SQUIT %s :%s", use_id(source_p
),
1425 if(client_p
!= NULL
&& source_p
!= client_p
&& !IsIOError(source_p
))
1427 sendto_one(source_p
, "ERROR :Closing Link: 127.0.0.1 %s (%s)",
1428 source_p
->name
, comment
);
1431 if(source_p
->servptr
&& source_p
->servptr
->serv
)
1432 rb_dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->servers
);
1437 close_connection(source_p
);
1439 if(ConfigServerHide
.flatten_links
)
1440 strcpy(comment1
, "*.net *.split");
1443 strcpy(comment1
, source_p
->servptr
->name
);
1444 strcat(comment1
, " ");
1445 strcat(comment1
, source_p
->name
);
1448 if(source_p
->serv
!= NULL
)
1449 remove_dependents(client_p
, source_p
, from
, IsPerson(from
) ? newcomment
: comment
, comment1
);
1451 sendto_realops_snomask(SNO_GENERAL
, L_ALL
, "%s was connected"
1452 " for %ld seconds. %d/%d sendK/recvK.",
1453 source_p
->name
, (long) rb_current_time() - source_p
->localClient
->firsttime
, sendk
, recvk
);
1455 ilog(L_SERVER
, "%s was connected for %ld seconds. %d/%d sendK/recvK.",
1456 source_p
->name
, (long) rb_current_time() - source_p
->localClient
->firsttime
, sendk
, recvk
);
1458 if(has_id(source_p
))
1459 del_from_id_hash(source_p
->id
, source_p
);
1461 del_from_client_hash(source_p
->name
, source_p
);
1462 remove_client_from_list(source_p
);
1463 scache_split(source_p
->serv
->nameinfo
);
1466 rb_dlinkAddAlloc(source_p
, &dead_list
);
1472 * This assumes IsPerson(source_p) == TRUE && MyConnect(source_p) == TRUE
1476 exit_local_client(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1477 const char *comment
)
1479 unsigned long on_for
;
1482 exit_generic_client(client_p
, source_p
, from
, comment
);
1483 clear_monitor(source_p
);
1485 s_assert(IsPerson(source_p
));
1486 rb_dlinkDelete(&source_p
->localClient
->tnode
, &lclient_list
);
1487 rb_dlinkDelete(&source_p
->lnode
, &me
.serv
->users
);
1489 if(IsOper(source_p
))
1490 rb_dlinkFindDestroy(source_p
, &local_oper_list
);
1492 sendto_realops_snomask(SNO_CCONN
, L_ALL
,
1493 "Client exiting: %s (%s@%s) [%s] [%s]",
1495 source_p
->username
, source_p
->host
, comment
,
1496 show_ip(NULL
, source_p
) ? source_p
->sockhost
: "255.255.255.255");
1498 sendto_realops_snomask(SNO_CCONNEXT
, L_ALL
,
1499 "CLIEXIT %s %s %s %s 0 %s",
1500 source_p
->name
, source_p
->username
, source_p
->host
,
1501 show_ip(NULL
, source_p
) ? source_p
->sockhost
: "255.255.255.255",
1504 on_for
= rb_current_time() - source_p
->localClient
->firsttime
;
1506 ilog(L_USER
, "%s (%3lu:%02lu:%02lu): %s!%s@%s %s %d/%d",
1507 rb_ctime(rb_current_time(), tbuf
, sizeof(tbuf
)), on_for
/ 3600,
1508 (on_for
% 3600) / 60, on_for
% 60,
1509 source_p
->name
, source_p
->username
, source_p
->host
,
1511 source_p
->localClient
->sendK
, source_p
->localClient
->receiveK
);
1513 sendto_one(source_p
, "ERROR :Closing Link: %s (%s)", source_p
->host
, comment
);
1514 close_connection(source_p
);
1516 if((source_p
->flags
& FLAGS_KILLED
) == 0)
1518 sendto_server(client_p
, NULL
, CAP_TS6
, NOCAPS
,
1519 ":%s QUIT :%s", use_id(source_p
), comment
);
1523 rb_dlinkAddAlloc(source_p
, &dead_list
);
1524 return(CLIENT_EXITED
);
1529 ** exit_client - This is old "m_bye". Name changed, because this is not a
1530 ** protocol function, but a general server utility function.
1532 ** This function exits a client of *any* type (user, server, etc)
1533 ** from this server. Also, this generates all necessary prototol
1534 ** messages that this exit may cause.
1536 ** 1) If the client is a local client, then this implicitly
1537 ** exits all other clients depending on this connection (e.g.
1538 ** remote clients having 'from'-field that points to this.
1540 ** 2) If the client is a remote client, then only this is exited.
1542 ** For convenience, this function returns a suitable value for
1543 ** m_function return value:
1545 ** CLIENT_EXITED if (client_p == source_p)
1546 ** 0 if (client_p != source_p)
1549 exit_client(struct Client
*client_p
, /* The local client originating the
1550 * exit or NULL, if this exit is
1551 * generated by this server for
1553 * This will not get any of the
1554 * generated messages. */
1555 struct Client
*source_p
, /* Client exiting */
1556 struct Client
*from
, /* Client firing off this Exit,
1558 const char *comment
/* Reason for the exit */
1561 hook_data_client_exit hdata
;
1562 if(IsClosing(source_p
))
1565 /* note, this HAS to be here, when we exit a client we attempt to
1566 * send them data, if this generates a write error we must *not* add
1567 * them to the abort list --fl
1569 SetClosing(source_p
);
1571 hdata
.local_link
= client_p
;
1572 hdata
.target
= source_p
;
1574 hdata
.comment
= comment
;
1575 call_hook(h_client_exit
, &hdata
);
1577 if(MyConnect(source_p
))
1579 /* Local clients of various types */
1580 if(IsPerson(source_p
))
1581 return exit_local_client(client_p
, source_p
, from
, comment
);
1582 else if(IsServer(source_p
))
1583 return exit_local_server(client_p
, source_p
, from
, comment
);
1584 /* IsUnknown || IsConnecting || IsHandShake */
1585 else if(!IsReject(source_p
))
1586 return exit_unknown_client(client_p
, source_p
, from
, comment
);
1591 if(IsPerson(source_p
))
1592 return exit_remote_client(client_p
, source_p
, from
, comment
);
1593 else if(IsServer(source_p
))
1594 return exit_remote_server(client_p
, source_p
, from
, comment
);
1601 * Count up local client memory
1604 /* XXX one common Client list now */
1606 count_local_client_memory(size_t * count
, size_t * local_client_memory_used
)
1609 rb_bh_usage(lclient_heap
, count
, NULL
, &lusage
, NULL
);
1610 *local_client_memory_used
= lusage
+ (*count
* (sizeof(void *) + sizeof(struct Client
)));
1614 * Count up remote client memory
1617 count_remote_client_memory(size_t * count
, size_t * remote_client_memory_used
)
1619 size_t lcount
, rcount
;
1620 rb_bh_usage(lclient_heap
, &lcount
, NULL
, NULL
, NULL
);
1621 rb_bh_usage(client_heap
, &rcount
, NULL
, NULL
, NULL
);
1622 *count
= rcount
- lcount
;
1623 *remote_client_memory_used
= *count
* (sizeof(void *) + sizeof(struct Client
));
1628 * accept processing, this adds a form of "caller ID" to ircd
1630 * If a client puts themselves into "caller ID only" mode,
1631 * only clients that match a client pointer they have put on
1632 * the accept list will be allowed to message them.
1634 * [ source.on_allow_list ] -> [ target1 ] -> [ target2 ]
1636 * [target.allow_list] -> [ source1 ] -> [source2 ]
1638 * i.e. a target will have a link list of source pointers it will allow
1639 * each source client then has a back pointer pointing back
1640 * to the client that has it on its accept list.
1641 * This allows for exit_one_client to remove these now bogus entries
1642 * from any client having an accept on them.
1647 * inputs - pointer to exiting client
1649 * side effects - Walk through given clients allow_list and on_allow_list
1650 * remove all references to this client
1653 del_all_accepts(struct Client
*client_p
)
1656 rb_dlink_node
*next_ptr
;
1657 struct Client
*target_p
;
1659 if(MyClient(client_p
) && client_p
->localClient
->allow_list
.head
)
1661 /* clear this clients accept list, and remove them from
1662 * everyones on_accept_list
1664 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, client_p
->localClient
->allow_list
.head
)
1666 target_p
= ptr
->data
;
1667 rb_dlinkFindDestroy(client_p
, &target_p
->on_allow_list
);
1668 rb_dlinkDestroy(ptr
, &client_p
->localClient
->allow_list
);
1672 /* remove this client from everyones accept list */
1673 RB_DLINK_FOREACH_SAFE(ptr
, next_ptr
, client_p
->on_allow_list
.head
)
1675 target_p
= ptr
->data
;
1676 rb_dlinkFindDestroy(client_p
, &target_p
->localClient
->allow_list
);
1677 rb_dlinkDestroy(ptr
, &client_p
->on_allow_list
);
1682 * show_ip() - asks if the true IP should be shown when source is
1683 * asking for info about target
1685 * Inputs - source_p who is asking
1686 * - target_p who do we want the info on
1687 * Output - returns 1 if clear IP can be shown, otherwise 0
1688 * Side Effects - none
1692 show_ip(struct Client
*source_p
, struct Client
*target_p
)
1694 if(IsAnyServer(target_p
))
1698 else if(IsIPSpoof(target_p
))
1700 /* source == NULL indicates message is being sent
1703 if(!ConfigFileEntry
.hide_spoof_ips
&&
1704 (source_p
== NULL
|| MyOper(source_p
)))
1708 else if(IsDynSpoof(target_p
) && (source_p
!= NULL
&& !IsOper(source_p
)))
1715 show_ip_conf(struct ConfItem
*aconf
, struct Client
*source_p
)
1717 if(IsConfDoSpoofIp(aconf
))
1719 if(!ConfigFileEntry
.hide_spoof_ips
&& MyOper(source_p
))
1729 show_ip_whowas(struct Whowas
*whowas
, struct Client
*source_p
)
1731 if(whowas
->flags
& WHOWAS_IP_SPOOFING
)
1732 if(ConfigFileEntry
.hide_spoof_ips
|| !MyOper(source_p
))
1734 if(whowas
->flags
& WHOWAS_DYNSPOOF
)
1735 if(!IsOper(source_p
))
1743 * inputs - pointer to client struct
1744 * output - pointer to struct User
1745 * side effects - add's an User information block to a client
1746 * if it was not previously allocated.
1749 make_user(struct Client
*client_p
)
1753 user
= client_p
->user
;
1756 user
= (struct User
*) rb_bh_alloc(user_heap
);
1758 client_p
->user
= user
;
1766 * inputs - pointer to client struct
1767 * output - pointer to server_t
1768 * side effects - add's an Server information block to a client
1769 * if it was not previously allocated.
1772 make_server(struct Client
*client_p
)
1774 struct Server
*serv
= client_p
->serv
;
1778 serv
= (struct Server
*) rb_malloc(sizeof(struct Server
));
1779 client_p
->serv
= serv
;
1781 return client_p
->serv
;
1787 * inputs - pointer to user struct
1788 * - pointer to client struct
1790 * side effects - Decrease user reference count by one and release block,
1791 * if count reaches 0
1794 free_user(struct User
*user
, struct Client
*client_p
)
1796 free_away(client_p
);
1798 if(--user
->refcnt
<= 0)
1801 rb_free((char *) user
->away
);
1805 if(user
->refcnt
< 0 || user
->invited
.head
|| user
->channel
.head
)
1807 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1808 "* %#lx user (%s!%s@%s) %#lx %#lx %#lx %lu %d *",
1809 (unsigned long) client_p
,
1810 client_p
? client_p
->
1814 (unsigned long) user
,
1815 (unsigned long) user
->invited
.head
,
1816 (unsigned long) user
->channel
.head
,
1817 rb_dlink_list_length(&user
->channel
),
1819 s_assert(!user
->refcnt
);
1820 s_assert(!user
->invited
.head
);
1821 s_assert(!user
->channel
.head
);
1824 rb_bh_free(user_heap
, user
);
1829 allocate_away(struct Client
*client_p
)
1831 if(client_p
->user
->away
== NULL
)
1832 client_p
->user
->away
= rb_bh_alloc(away_heap
);
1837 free_away(struct Client
*client_p
)
1839 if(client_p
->user
!= NULL
&& client_p
->user
->away
!= NULL
) {
1840 rb_bh_free(away_heap
, client_p
->user
->away
);
1841 client_p
->user
->away
= NULL
;
1850 for(i
= 0; i
< 3; i
++)
1851 current_uid
[i
] = me
.id
[i
];
1853 for(i
= 3; i
< 9; i
++)
1854 current_uid
[i
] = 'A';
1856 current_uid
[9] = '\0';
1865 for(i
= 8; i
> 3; i
--)
1867 if(current_uid
[i
] == 'Z')
1869 current_uid
[i
] = '0';
1872 else if(current_uid
[i
] != '9')
1878 current_uid
[i
] = 'A';
1881 /* if this next if() triggers, we're fucked. */
1882 if(current_uid
[3] == 'Z')
1884 current_uid
[i
] = 'A';
1895 * Close the physical connection. This function must make
1896 * MyConnect(client_p) == FALSE, and set client_p->from == NULL.
1899 close_connection(struct Client
*client_p
)
1901 s_assert(client_p
!= NULL
);
1902 if(client_p
== NULL
)
1905 s_assert(MyConnect(client_p
));
1906 if(!MyConnect(client_p
))
1909 if(IsServer(client_p
))
1911 struct server_conf
*server_p
;
1913 ServerStats
.is_sv
++;
1914 ServerStats
.is_sbs
+= client_p
->localClient
->sendB
;
1915 ServerStats
.is_sbr
+= client_p
->localClient
->receiveB
;
1916 ServerStats
.is_sti
+= (unsigned long long)(rb_current_time() - client_p
->localClient
->firsttime
);
1919 * If the connection has been up for a long amount of time, schedule
1920 * a 'quick' reconnect, else reset the next-connect cycle.
1922 if((server_p
= find_server_conf(client_p
->name
)) != NULL
)
1925 * Reschedule a faster reconnect, if this was a automatically
1926 * connected configuration entry. (Note that if we have had
1927 * a rehash in between, the status has been changed to
1928 * CONF_ILLEGAL). But only do this if it was a "good" link.
1930 server_p
->hold
= time(NULL
);
1932 (server_p
->hold
- client_p
->localClient
->lasttime
>
1933 HANGONGOODLINK
) ? HANGONRETRYDELAY
: ConFreq(server_p
->class);
1937 else if(IsClient(client_p
))
1939 ServerStats
.is_cl
++;
1940 ServerStats
.is_cbs
+= client_p
->localClient
->sendB
;
1941 ServerStats
.is_cbr
+= client_p
->localClient
->receiveB
;
1942 ServerStats
.is_cti
+= (unsigned long long)(rb_current_time() - client_p
->localClient
->firsttime
);
1945 ServerStats
.is_ni
++;
1947 if(client_p
->localClient
->F
!= NULL
)
1949 /* attempt to flush any pending dbufs. Evil, but .. -- adrian */
1950 if(!IsIOError(client_p
))
1951 send_queued(client_p
);
1953 del_from_cli_connid_hash(client_p
);
1954 rb_close(client_p
->localClient
->F
);
1955 client_p
->localClient
->F
= NULL
;
1958 rb_linebuf_donebuf(&client_p
->localClient
->buf_sendq
);
1959 rb_linebuf_donebuf(&client_p
->localClient
->buf_recvq
);
1960 detach_conf(client_p
);
1962 /* XXX shouldnt really be done here. */
1963 detach_server_conf(client_p
);
1965 client_p
->from
= NULL
; /* ...this should catch them! >:) --msa */
1966 ClearMyConnect(client_p
);
1967 SetIOError(client_p
);
1973 error_exit_client(struct Client
*client_p
, int error
)
1976 * ...hmm, with non-blocking sockets we might get
1977 * here from quite valid reasons, although.. why
1978 * would select report "data available" when there
1979 * wasn't... so, this must be an error anyway... --msa
1980 * actually, EOF occurs when read() returns 0 and
1981 * in due course, select() returns that fd as ready
1982 * for reading even though it ends up being an EOF. -avalon
1985 int current_error
= rb_get_sockerr(client_p
->localClient
->F
);
1987 SetIOError(client_p
);
1989 if(IsServer(client_p
) || IsHandshake(client_p
))
1993 sendto_realops_snomask(SNO_GENERAL
, is_remote_connect(client_p
) && !IsServer(client_p
) ? L_NETWIDE
: L_ALL
,
1994 "Server %s closed the connection",
1997 ilog(L_SERVER
, "Server %s closed the connection",
1998 log_client_name(client_p
, SHOW_IP
));
2002 sendto_realops_snomask(SNO_GENERAL
, is_remote_connect(client_p
) && !IsServer(client_p
) ? L_NETWIDE
: L_ALL
,
2003 "Lost connection to %s: %s",
2004 client_p
->name
, strerror(current_error
));
2005 ilog(L_SERVER
, "Lost connection to %s: %s",
2006 log_client_name(client_p
, SHOW_IP
), strerror(current_error
));
2011 rb_strlcpy(errmsg
, "Remote host closed the connection", sizeof(errmsg
));
2013 rb_snprintf(errmsg
, sizeof(errmsg
), "Read error: %s", strerror(current_error
));
2015 exit_client(client_p
, client_p
, &me
, errmsg
);