2 * ircd-ratbox: A slightly useful 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
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
24 * $Id: client.c 3319 2007-03-29 20:03:06Z jilles $
35 #include "irc_string.h"
36 #include "sprintf_irc.h"
44 #include "s_newconf.h"
60 #include "blacklist.h"
62 #define DEBUG_EXITED_CLIENTS
64 static void check_pings_list(dlink_list
* list
);
65 static void check_unknowns_list(dlink_list
* list
);
66 static void free_exited_clients(void *unused
);
67 static void exit_aborted_clients(void *unused
);
69 static int exit_remote_client(struct Client
*, struct Client
*, struct Client
*,const char *);
70 static int exit_remote_server(struct Client
*, struct Client
*, struct Client
*,const char *);
71 static int exit_local_client(struct Client
*, struct Client
*, struct Client
*,const char *);
72 static int exit_unknown_client(struct Client
*, struct Client
*, struct Client
*,const char *);
73 static int exit_local_server(struct Client
*, struct Client
*, struct Client
*,const char *);
74 static int qs_server(struct Client
*, struct Client
*, struct Client
*, const char *comment
);
76 static EVH check_pings
;
78 extern BlockHeap
*client_heap
;
79 extern BlockHeap
*lclient_heap
;
80 extern BlockHeap
*pclient_heap
;
82 extern char current_uid
[IDLEN
];
92 #ifdef DEBUG_EXITED_CLIENTS
93 static dlink_list dead_remote_list
;
99 struct Client
*client
;
100 char notice
[REASONLEN
];
103 static dlink_list abort_list
;
111 * side effects - initialize client free memory
117 * start off the check ping event .. -- adrian
118 * Every 30 seconds is plenty -- db
120 client_heap
= BlockHeapCreate(sizeof(struct Client
), CLIENT_HEAP_SIZE
);
121 lclient_heap
= BlockHeapCreate(sizeof(struct LocalUser
), LCLIENT_HEAP_SIZE
);
122 pclient_heap
= BlockHeapCreate(sizeof(struct PreClient
), PCLIENT_HEAP_SIZE
);
123 eventAddIsh("check_pings", check_pings
, NULL
, 30);
124 eventAddIsh("free_exited_clients", &free_exited_clients
, NULL
, 4);
125 eventAddIsh("exit_aborted_clients", exit_aborted_clients
, NULL
, 1);
130 * make_client - create a new Client struct and set it to initial state.
132 * from == NULL, create local client (a client connected
135 * from, create remote client (behind a socket
136 * associated with the client defined by
137 * 'from'). ('from' is a local client!!).
140 make_client(struct Client
*from
)
142 struct Client
*client_p
= NULL
;
143 struct LocalUser
*localClient
;
145 client_p
= BlockHeapAlloc(client_heap
);
149 client_p
->from
= client_p
; /* 'from' of local client is self! */
151 localClient
= (struct LocalUser
*) BlockHeapAlloc(lclient_heap
);
152 SetMyConnect(client_p
);
153 client_p
->localClient
= localClient
;
155 client_p
->localClient
->lasttime
= client_p
->localClient
->firsttime
= CurrentTime
;
157 client_p
->localClient
->fd
= -1;
158 client_p
->localClient
->ctrlfd
= -1;
160 client_p
->preClient
= (struct PreClient
*) BlockHeapAlloc(pclient_heap
);
162 /* as good a place as any... */
163 dlinkAdd(client_p
, &client_p
->localClient
->tnode
, &unknown_list
);
166 { /* from is not NULL */
167 client_p
->localClient
= NULL
;
168 client_p
->preClient
= NULL
;
169 client_p
->from
= from
; /* 'from' of local client is self! */
172 SetUnknown(client_p
);
173 strcpy(client_p
->username
, "unknown");
179 free_pre_client(struct Client
*client_p
)
181 struct Blacklist
*blptr
;
183 s_assert(NULL
!= client_p
);
185 if(client_p
->preClient
== NULL
)
188 blptr
= client_p
->preClient
->dnsbl_listed
;
190 unref_blacklist(blptr
);
191 abort_blacklist_queries(client_p
);
192 BlockHeapFree(pclient_heap
, client_p
->preClient
);
193 client_p
->preClient
= NULL
;
197 free_local_client(struct Client
*client_p
)
199 s_assert(NULL
!= client_p
);
200 s_assert(&me
!= client_p
);
202 if(client_p
->localClient
== NULL
)
206 * clean up extra sockets from P-lines which have been discarded.
208 if(client_p
->localClient
->listener
)
210 s_assert(0 < client_p
->localClient
->listener
->ref_count
);
211 if(0 == --client_p
->localClient
->listener
->ref_count
212 && !client_p
->localClient
->listener
->active
)
213 free_listener(client_p
->localClient
->listener
);
214 client_p
->localClient
->listener
= 0;
217 if(client_p
->localClient
->fd
>= 0)
218 comm_close(client_p
->localClient
->fd
);
220 if(client_p
->localClient
->passwd
)
222 memset(client_p
->localClient
->passwd
, 0,
223 strlen(client_p
->localClient
->passwd
));
224 MyFree(client_p
->localClient
->passwd
);
227 MyFree(client_p
->localClient
->challenge
);
228 MyFree(client_p
->localClient
->fullcaps
);
229 MyFree(client_p
->localClient
->opername
);
230 MyFree(client_p
->localClient
->mangledhost
);
232 BlockHeapFree(lclient_heap
, client_p
->localClient
);
233 client_p
->localClient
= NULL
;
237 free_client(struct Client
*client_p
)
239 s_assert(NULL
!= client_p
);
240 s_assert(&me
!= client_p
);
241 free_local_client(client_p
);
242 free_pre_client(client_p
);
243 BlockHeapFree(client_heap
, client_p
);
247 * check_pings - go through the local client list and check activity
248 * kill off stuff that should die
250 * inputs - NOT USED (from event)
251 * output - next time_t when check_pings() should be called again
255 * A PING can be sent to clients as necessary.
257 * Client/Server ping outs are handled.
261 * Addon from adrian. We used to call this after nextping seconds,
262 * however I've changed it to run once a second. This is only for
263 * PING timeouts, not K/etc-line checks (thanks dianora!). Having it
264 * run once a second makes life a lot easier - when a new client connects
265 * and they need a ping in 4 seconds, if nextping was set to 20 seconds
266 * we end up waiting 20 seconds. This is stupid. :-)
267 * I will optimise (hah!) check_pings() once I've finished working on
268 * tidying up other network IO evilnesses.
273 check_pings(void *notused
)
275 check_pings_list(&lclient_list
);
276 check_pings_list(&serv_list
);
277 check_unknowns_list(&unknown_list
);
283 * inputs - pointer to list to check
288 check_pings_list(dlink_list
* list
)
290 char scratch
[32]; /* way too generous but... */
291 struct Client
*client_p
; /* current local client_p being examined */
292 int ping
= 0; /* ping time value from client */
293 dlink_node
*ptr
, *next_ptr
;
295 DLINK_FOREACH_SAFE(ptr
, next_ptr
, list
->head
)
297 client_p
= ptr
->data
;
300 ** Note: No need to notify opers here. It's
301 ** already done when "FLAGS_DEADSOCKET" is set.
303 if(!MyConnect(client_p
) || IsDead(client_p
))
306 if(IsPerson(client_p
))
308 if(!IsExemptKline(client_p
) &&
309 GlobalSetOptions
.idletime
&&
311 !IsIdlelined(client_p
) &&
312 ((CurrentTime
- client_p
->localClient
->last
) > GlobalSetOptions
.idletime
))
314 struct ConfItem
*aconf
;
317 aconf
->status
= CONF_KILL
;
319 DupString(aconf
->host
, client_p
->host
);
320 DupString(aconf
->passwd
, "idle exceeder");
321 DupString(aconf
->user
, client_p
->username
);
323 aconf
->hold
= CurrentTime
+ 60;
324 add_temp_kline(aconf
);
325 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
326 "Idle time limit exceeded for %s - temp k-lining",
327 get_client_name(client_p
, HIDE_IP
));
329 exit_client(client_p
, client_p
, &me
, aconf
->passwd
);
334 if(!IsRegistered(client_p
))
335 ping
= ConfigFileEntry
.connect_timeout
;
337 ping
= get_client_ping(client_p
);
339 if(ping
< (CurrentTime
- client_p
->localClient
->lasttime
))
342 * If the client/server hasnt talked to us in 2*ping seconds
343 * and it has a ping time, then close its connection.
345 if(((CurrentTime
- client_p
->localClient
->lasttime
) >= (2 * ping
)
346 && (client_p
->flags
& FLAGS_PINGSENT
)))
348 if(IsAnyServer(client_p
))
350 sendto_realops_snomask(SNO_GENERAL
, is_remote_connect(client_p
) && !IsServer(client_p
) ? L_NETWIDE
: L_ALL
,
351 "No response from %s, closing link",
352 get_server_name(client_p
, HIDE_IP
));
354 "No response from %s, closing link",
355 log_client_name(client_p
, HIDE_IP
));
357 (void) ircsnprintf(scratch
, sizeof(scratch
),
358 "Ping timeout: %d seconds",
359 (int) (CurrentTime
- client_p
->localClient
->lasttime
));
361 exit_client(client_p
, client_p
, &me
, scratch
);
364 else if((client_p
->flags
& FLAGS_PINGSENT
) == 0)
367 * if we havent PINGed the connection and we havent
368 * heard from it in a while, PING it to make sure
371 client_p
->flags
|= FLAGS_PINGSENT
;
372 /* not nice but does the job */
373 client_p
->localClient
->lasttime
= CurrentTime
- ping
;
374 sendto_one(client_p
, "PING :%s", me
.name
);
383 * check_unknowns_list
385 * inputs - pointer to list of unknown clients
387 * side effects - unknown clients get marked for termination after n seconds
390 check_unknowns_list(dlink_list
* list
)
392 dlink_node
*ptr
, *next_ptr
;
393 struct Client
*client_p
;
395 DLINK_FOREACH_SAFE(ptr
, next_ptr
, list
->head
)
397 client_p
= ptr
->data
;
399 if(IsDead(client_p
) || IsClosing(client_p
))
403 * Check UNKNOWN connections - if they have been in this state
404 * for > 30s, close them.
407 if((CurrentTime
- client_p
->localClient
->firsttime
) > 30)
408 exit_client(client_p
, client_p
, &me
, "Connection timed out");
413 notify_banned_client(struct Client
*client_p
, struct ConfItem
*aconf
, int ban
)
415 static const char conn_closed
[] = "Connection closed";
416 static const char d_lined
[] = "D-lined";
417 static const char k_lined
[] = "K-lined";
418 static const char g_lined
[] = "G-lined";
419 const char *reason
= NULL
;
420 const char *exit_reason
= conn_closed
;
422 if(ConfigFileEntry
.kline_with_reason
&& !EmptyString(aconf
->passwd
))
424 reason
= aconf
->passwd
;
425 exit_reason
= aconf
->passwd
;
429 switch (aconf
->status
)
443 if(ban
== D_LINED
&& !IsPerson(client_p
))
444 sendto_one(client_p
, "NOTICE DLINE :*** You have been D-lined");
446 sendto_one(client_p
, form_str(ERR_YOUREBANNEDCREEP
),
447 me
.name
, client_p
->name
, reason
);
449 exit_client(client_p
, client_p
, &me
,
450 EmptyString(ConfigFileEntry
.kline_reason
) ? exit_reason
:
451 ConfigFileEntry
.kline_reason
);
458 * side effects - Check all connections for a pending k/d/gline against the
459 * client, exit the client if found.
462 check_banned_lines(void)
464 struct Client
*client_p
; /* current local client_p being examined */
465 struct ConfItem
*aconf
= NULL
;
466 dlink_node
*ptr
, *next_ptr
;
468 DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
470 client_p
= ptr
->data
;
475 /* if there is a returned struct ConfItem then kill it */
476 if((aconf
= find_dline((struct sockaddr
*)&client_p
->localClient
->ip
, client_p
->localClient
->ip
.ss_family
)))
478 if(aconf
->status
& CONF_EXEMPTDLINE
)
481 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
482 "DLINE active for %s",
483 get_client_name(client_p
, HIDE_IP
));
485 notify_banned_client(client_p
, aconf
, D_LINED
);
486 continue; /* and go examine next fd/client_p */
489 if(!IsPerson(client_p
))
492 if((aconf
= find_kline(client_p
)) != NULL
)
494 if(IsExemptKline(client_p
))
496 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
497 "KLINE over-ruled for %s, client is kline_exempt [%s@%s]",
498 get_client_name(client_p
, HIDE_IP
),
499 aconf
->user
, aconf
->host
);
503 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
504 "KLINE active for %s",
505 get_client_name(client_p
, HIDE_IP
));
506 notify_banned_client(client_p
, aconf
, K_LINED
);
509 else if((aconf
= find_gline(client_p
)) != NULL
)
511 if(IsExemptKline(client_p
))
513 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
514 "GLINE over-ruled for %s, client is kline_exempt [%s@%s]",
515 get_client_name(client_p
, HIDE_IP
),
516 aconf
->user
, aconf
->host
);
520 if(IsExemptGline(client_p
))
522 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
523 "GLINE over-ruled for %s, client is gline_exempt [%s@%s]",
524 get_client_name(client_p
, HIDE_IP
),
525 aconf
->user
, aconf
->host
);
529 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
530 "GLINE active for %s",
531 get_client_name(client_p
, HIDE_IP
));
533 notify_banned_client(client_p
, aconf
, G_LINED
);
536 else if((aconf
= find_xline(client_p
->info
, 1)) != NULL
)
538 if(IsExemptKline(client_p
))
540 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
541 "XLINE over-ruled for %s, client is kline_exempt [%s]",
542 get_client_name(client_p
, HIDE_IP
),
547 sendto_realops_snomask(SNO_GENERAL
, L_ALL
, "XLINE active for %s",
548 get_client_name(client_p
, HIDE_IP
));
550 (void) exit_client(client_p
, client_p
, &me
, "Bad user info");
555 /* also check the unknowns list for new dlines */
556 DLINK_FOREACH_SAFE(ptr
, next_ptr
, unknown_list
.head
)
558 client_p
= ptr
->data
;
560 if((aconf
= find_dline((struct sockaddr
*)&client_p
->localClient
->ip
,client_p
->localClient
->ip
.ss_family
)))
562 if(aconf
->status
& CONF_EXEMPTDLINE
)
565 notify_banned_client(client_p
, aconf
, D_LINED
);
571 /* check_klines_event()
575 * side effects - check_klines() is called, kline_queued unset
578 check_klines_event(void *unused
)
588 * side effects - all clients will be checked for klines
593 struct Client
*client_p
;
594 struct ConfItem
*aconf
;
596 dlink_node
*next_ptr
;
598 DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
600 client_p
= ptr
->data
;
602 if(IsMe(client_p
) || !IsPerson(client_p
))
605 if((aconf
= find_kline(client_p
)) != NULL
)
607 if(IsExemptKline(client_p
))
609 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
610 "KLINE over-ruled for %s, client is kline_exempt",
611 get_client_name(client_p
, HIDE_IP
));
615 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
616 "KLINE active for %s",
617 get_client_name(client_p
, HIDE_IP
));
619 notify_banned_client(client_p
, aconf
, K_LINED
);
629 * side effects - all clients will be checked for glines
634 struct Client
*client_p
;
635 struct ConfItem
*aconf
;
637 dlink_node
*next_ptr
;
639 DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
641 client_p
= ptr
->data
;
643 if(IsMe(client_p
) || !IsPerson(client_p
))
646 if((aconf
= find_gline(client_p
)) != NULL
)
648 if(IsExemptKline(client_p
))
650 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
651 "GLINE over-ruled for %s, client is kline_exempt",
652 get_client_name(client_p
, HIDE_IP
));
656 if(IsExemptGline(client_p
))
658 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
659 "GLINE over-ruled for %s, client is gline_exempt",
660 get_client_name(client_p
, HIDE_IP
));
664 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
665 "GLINE active for %s",
666 get_client_name(client_p
, HIDE_IP
));
668 notify_banned_client(client_p
, aconf
, K_LINED
);
678 * side effects - all clients will be checked for dlines
683 struct Client
*client_p
;
684 struct ConfItem
*aconf
;
686 dlink_node
*next_ptr
;
688 DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
690 client_p
= ptr
->data
;
695 if((aconf
= find_dline((struct sockaddr
*)&client_p
->localClient
->ip
,client_p
->localClient
->ip
.ss_family
)) != NULL
)
697 if(aconf
->status
& CONF_EXEMPTDLINE
)
700 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
701 "DLINE active for %s",
702 get_client_name(client_p
, HIDE_IP
));
704 notify_banned_client(client_p
, aconf
, D_LINED
);
709 /* dlines need to be checked against unknowns too */
710 DLINK_FOREACH_SAFE(ptr
, next_ptr
, unknown_list
.head
)
712 client_p
= ptr
->data
;
714 if((aconf
= find_dline((struct sockaddr
*)&client_p
->localClient
->ip
,client_p
->localClient
->ip
.ss_family
)) != NULL
)
716 if(aconf
->status
& CONF_EXEMPTDLINE
)
719 notify_banned_client(client_p
, aconf
, D_LINED
);
728 * side effects - all clients will be checked for xlines
733 struct Client
*client_p
;
734 struct ConfItem
*aconf
;
736 dlink_node
*next_ptr
;
738 DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
740 client_p
= ptr
->data
;
742 if(IsMe(client_p
) || !IsPerson(client_p
))
745 if((aconf
= find_xline(client_p
->info
, 1)) != NULL
)
747 if(IsExemptKline(client_p
))
749 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
750 "XLINE over-ruled for %s, client is kline_exempt",
751 get_client_name(client_p
, HIDE_IP
));
755 sendto_realops_snomask(SNO_GENERAL
, L_ALL
, "XLINE active for %s",
756 get_client_name(client_p
, HIDE_IP
));
758 (void) exit_client(client_p
, client_p
, &me
, "Bad user info");
765 * update_client_exit_stats
767 * input - pointer to client
772 update_client_exit_stats(struct Client
*client_p
)
774 if(IsServer(client_p
))
776 sendto_realops_snomask(SNO_EXTERNAL
, L_ALL
,
777 "Server %s split from %s",
778 client_p
->name
, client_p
->servptr
->name
);
779 if(HasSentEob(client_p
))
782 else if(IsClient(client_p
))
787 if(IsInvisible(client_p
))
791 if(splitchecking
&& !splitmode
)
792 check_splitmode(NULL
);
796 * release_client_state
798 * input - pointer to client to release
803 release_client_state(struct Client
*client_p
)
805 if(client_p
->user
!= NULL
)
807 free_user(client_p
->user
, client_p
); /* try this here */
811 if(client_p
->serv
->user
!= NULL
)
812 free_user(client_p
->serv
->user
, client_p
);
813 if(client_p
->serv
->fullcaps
)
814 MyFree(client_p
->serv
->fullcaps
);
815 MyFree(client_p
->serv
);
820 * remove_client_from_list
821 * inputs - point to client to remove
823 * side effects - taken the code from ExitOneClient() for this
824 * and placed it here. - avalon
827 remove_client_from_list(struct Client
*client_p
)
829 s_assert(NULL
!= client_p
);
834 /* A client made with make_client()
835 * is on the unknown_list until removed.
836 * If it =does= happen to exit before its removed from that list
837 * and its =not= on the global_client_list, it will core here.
838 * short circuit that case now -db
840 if(client_p
->node
.prev
== NULL
&& client_p
->node
.next
== NULL
)
843 dlinkDelete(&client_p
->node
, &global_client_list
);
845 update_client_exit_stats(client_p
);
850 * find_person - find person by (nick)name.
851 * inputs - pointer to name
852 * output - return client pointer
856 find_person(const char *name
)
858 struct Client
*c2ptr
;
860 c2ptr
= find_client(name
);
862 if(c2ptr
&& IsPerson(c2ptr
))
868 find_named_person(const char *name
)
870 struct Client
*c2ptr
;
872 c2ptr
= find_named_client(name
);
874 if(c2ptr
&& IsPerson(c2ptr
))
881 * find_chasing - find the client structure for a nick name (user)
882 * using history mechanism if necessary. If the client is not found,
883 * an error message (NO SUCH NICK) is generated. If the client was found
884 * through the history, chasing will be 1 and otherwise 0.
887 find_chasing(struct Client
*source_p
, const char *user
, int *chasing
)
891 if(MyClient(source_p
))
892 who
= find_named_person(user
);
894 who
= find_person(user
);
899 if(who
|| IsDigit(*user
))
902 if(!(who
= get_history(user
, (long) KILLCHASETIMELIMIT
)))
904 sendto_one_numeric(source_p
, ERR_NOSUCHNICK
,
905 form_str(ERR_NOSUCHNICK
), user
);
914 * get_client_name - Return the name of the client
915 * for various tracking and
916 * admin purposes. The main purpose of this function is to
917 * return the "socket host" name of the client, if that
918 * differs from the advertised name (other than case).
919 * But, this can be used to any client structure.
922 * Watch out the allocation of "nbuf", if either source_p->name
923 * or source_p->sockhost gets changed into pointers instead of
924 * directly allocated within the structure...
927 * Function return either a pointer to the structure (source_p) or
928 * to internal buffer (nbuf). *NEVER* use the returned pointer
929 * to modify what it points!!!
933 get_client_name(struct Client
*client
, int showip
)
935 static char nbuf
[HOSTLEN
* 2 + USERLEN
+ 5];
937 s_assert(NULL
!= client
);
941 if(MyConnect(client
))
943 if(!irccmp(client
->name
, client
->host
))
946 if(ConfigFileEntry
.hide_spoof_ips
&&
947 showip
== SHOW_IP
&& IsIPSpoof(client
))
949 #ifdef HIDE_SERVERS_IPS
950 if(IsAnyServer(client
))
954 /* And finally, let's get the host information, ip or name */
958 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]",
959 client
->name
, client
->username
,
963 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@255.255.255.255]",
964 client
->name
, client
->username
);
967 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]",
968 client
->name
, client
->username
, client
->host
);
973 /* As pointed out by Adel Mezibra
974 * Neph|l|m@EFnet. Was missing a return here.
980 get_server_name(struct Client
*target_p
, int showip
)
982 static char nbuf
[HOSTLEN
* 2 + USERLEN
+ 5];
987 if(!MyConnect(target_p
) || !irccmp(target_p
->name
, target_p
->host
))
988 return target_p
->name
;
990 #ifdef HIDE_SERVERS_IPS
991 if(EmptyString(target_p
->name
))
993 ircsnprintf(nbuf
, sizeof(nbuf
), "[%s@255.255.255.255]",
998 return target_p
->name
;
1004 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]",
1005 target_p
->name
, target_p
->username
,
1006 target_p
->sockhost
);
1010 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@255.255.255.255]",
1011 target_p
->name
, target_p
->username
);
1014 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]",
1015 target_p
->name
, target_p
->username
,
1022 /* log_client_name()
1024 * This version is the same as get_client_name, but doesnt contain the
1025 * code that will hide IPs always. This should be used for logfiles.
1028 log_client_name(struct Client
*target_p
, int showip
)
1030 static char nbuf
[HOSTLEN
* 2 + USERLEN
+ 5];
1032 if(target_p
== NULL
)
1035 if(MyConnect(target_p
))
1037 if(irccmp(target_p
->name
, target_p
->host
) == 0)
1038 return target_p
->name
;
1043 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]", target_p
->name
,
1044 target_p
->username
, target_p
->sockhost
);
1048 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@255.255.255.255]",
1049 target_p
->name
, target_p
->username
);
1052 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]", target_p
->name
,
1053 target_p
->username
, target_p
->host
);
1059 return target_p
->name
;
1062 /* is_remote_connect - Returns whether a server was /connect'ed by a remote
1063 * oper (send notices netwide) */
1065 is_remote_connect(struct Client
*client_p
)
1067 struct Client
*oper
;
1069 if (client_p
->serv
== NULL
)
1071 oper
= find_named_person(client_p
->serv
->by
);
1072 return oper
!= NULL
&& IsOper(oper
) && !MyConnect(oper
);
1076 free_exited_clients(void *unused
)
1078 dlink_node
*ptr
, *next
;
1079 struct Client
*target_p
;
1081 DLINK_FOREACH_SAFE(ptr
, next
, dead_list
.head
)
1083 target_p
= ptr
->data
;
1085 #ifdef DEBUG_EXITED_CLIENTS
1087 struct abort_client
*abt
;
1091 DLINK_FOREACH(aptr
, abort_list
.head
)
1094 if(abt
->client
== target_p
)
1097 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1098 "On abort_list: %s stat: %u flags: %u/%u handler: %c",
1099 target_p
->name
, (unsigned int) target_p
->status
,
1100 target_p
->flags
, target_p
->flags2
, target_p
->handler
);
1101 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1102 "Please report this to the ratbox developers!");
1109 dlinkDestroy(ptr
, &dead_list
);
1115 if(ptr
->data
== NULL
)
1117 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1118 "Warning: null client on dead_list!");
1119 dlinkDestroy(ptr
, &dead_list
);
1122 release_client_state(target_p
);
1123 free_client(target_p
);
1124 dlinkDestroy(ptr
, &dead_list
);
1127 #ifdef DEBUG_EXITED_CLIENTS
1128 DLINK_FOREACH_SAFE(ptr
, next
, dead_remote_list
.head
)
1130 target_p
= ptr
->data
;
1132 if(ptr
->data
== NULL
)
1134 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1135 "Warning: null client on dead_list!");
1136 dlinkDestroy(ptr
, &dead_list
);
1139 release_client_state(target_p
);
1140 free_client(target_p
);
1141 dlinkDestroy(ptr
, &dead_remote_list
);
1148 ** Recursively send QUITs and SQUITs for source_p and all its dependent clients
1149 ** and servers to those servers that need them. A server needs the client
1150 ** QUITs if it can't figure them out from the SQUIT (ie pre-TS4) or if it
1151 ** isn't getting the SQUIT because of @#(*&@)# hostmasking. With TS4, once
1152 ** a link gets a SQUIT, it doesn't need any QUIT/SQUITs for clients depending
1153 ** on that one -orabidoo
1156 recurse_send_quits(struct Client
*client_p
, struct Client
*source_p
,
1157 struct Client
*to
, const char *comment1
,
1158 const char *comment
)
1160 struct Client
*target_p
;
1161 dlink_node
*ptr
, *ptr_next
;
1162 /* If this server can handle quit storm (QS) removal
1163 * of dependents, just send the SQUIT
1166 if(IsCapable(to
, CAP_QS
))
1168 sendto_one(to
, "SQUIT %s :%s",
1169 get_id(source_p
, to
), comment
);
1173 DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->users
.head
)
1175 target_p
= ptr
->data
;
1176 sendto_one(to
, ":%s QUIT :%s", target_p
->name
, comment1
);
1178 DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->servers
.head
)
1180 target_p
= ptr
->data
;
1181 recurse_send_quits(client_p
, target_p
, to
, comment1
, comment
);
1183 sendto_one(to
, "SQUIT %s :%s", source_p
->name
, comment
);
1188 ** Remove all clients that depend on source_p; assumes all (S)QUITs have
1189 ** already been sent. we make sure to exit a server's dependent clients
1190 ** and servers before the server itself; exit_one_client takes care of
1191 ** actually removing things off llists. tweaked from +CSr31 -orabidoo
1194 * added sanity test code.... source_p->serv might be NULL...
1197 recurse_remove_clients(struct Client
*source_p
, const char *comment
)
1199 struct Client
*target_p
;
1200 dlink_node
*ptr
, *ptr_next
;
1205 if(source_p
->serv
== NULL
) /* oooops. uh this is actually a major bug */
1208 /* this is very ugly, but it saves cpu :P */
1209 if(ConfigFileEntry
.nick_delay
> 0)
1211 DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->users
.head
)
1213 target_p
= ptr
->data
;
1214 target_p
->flags
|= FLAGS_KILLED
;
1215 add_nd_entry(target_p
->name
);
1217 if(!IsDead(target_p
) && !IsClosing(target_p
))
1218 exit_remote_client(NULL
, target_p
, &me
, comment
);
1223 DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->users
.head
)
1225 target_p
= ptr
->data
;
1226 target_p
->flags
|= FLAGS_KILLED
;
1228 if(!IsDead(target_p
) && !IsClosing(target_p
))
1229 exit_remote_client(NULL
, target_p
, &me
, comment
);
1233 DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->servers
.head
)
1235 target_p
= ptr
->data
;
1236 recurse_remove_clients(target_p
, comment
);
1237 qs_server(NULL
, target_p
, &me
, comment
);
1242 ** Remove *everything* that depends on source_p, from all lists, and sending
1243 ** all necessary QUITs and SQUITs. source_p itself is still on the lists,
1244 ** and its SQUITs have been sent except for the upstream one -orabidoo
1247 remove_dependents(struct Client
*client_p
,
1248 struct Client
*source_p
,
1249 struct Client
*from
, const char *comment
, const char *comment1
)
1252 dlink_node
*ptr
, *next
;
1254 DLINK_FOREACH_SAFE(ptr
, next
, serv_list
.head
)
1258 if(IsMe(to
) || to
== source_p
->from
||
1259 (to
== client_p
&& IsCapable(to
, CAP_QS
)))
1262 recurse_send_quits(client_p
, source_p
, to
, comment1
, comment
);
1265 recurse_remove_clients(source_p
, comment1
);
1269 exit_aborted_clients(void *unused
)
1271 struct abort_client
*abt
;
1272 dlink_node
*ptr
, *next
;
1273 DLINK_FOREACH_SAFE(ptr
, next
, abort_list
.head
)
1277 #ifdef DEBUG_EXITED_CLIENTS
1279 if(dlinkFind(abt
->client
, &dead_list
))
1282 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1283 "On dead_list: %s stat: %u flags: %u/%u handler: %c",
1284 abt
->client
->name
, (unsigned int) abt
->client
->status
,
1285 abt
->client
->flags
, abt
->client
->flags2
, abt
->client
->handler
);
1286 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1287 "Please report this to the ratbox developers!");
1293 s_assert(*((unsigned long*)abt
->client
) != 0xdeadbeef); /* This is lame but its a debug thing */
1294 dlinkDelete(ptr
, &abort_list
);
1296 if(IsAnyServer(abt
->client
))
1297 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1298 "Closing link to %s: %s",
1299 get_server_name(abt
->client
, HIDE_IP
), abt
->notice
);
1301 /* its no longer on abort list - we *must* remove
1302 * FLAGS_CLOSING otherwise exit_client() will not run --fl
1304 abt
->client
->flags
&= ~FLAGS_CLOSING
;
1305 exit_client(abt
->client
, abt
->client
, &me
, abt
->notice
);
1312 * dead_link - Adds client to a list of clients that need an exit_client()
1316 dead_link(struct Client
*client_p
)
1318 struct abort_client
*abt
;
1320 s_assert(!IsMe(client_p
));
1321 if(IsDead(client_p
) || IsClosing(client_p
) || IsMe(client_p
))
1324 abt
= (struct abort_client
*) MyMalloc(sizeof(struct abort_client
));
1326 if(client_p
->flags
& FLAGS_SENDQEX
)
1327 strlcpy(abt
->notice
, "Max SendQ exceeded", sizeof(abt
->notice
));
1329 ircsnprintf(abt
->notice
, sizeof(abt
->notice
), "Write error: %s", strerror(errno
));
1331 abt
->client
= client_p
;
1332 SetIOError(client_p
);
1334 SetClosing(client_p
);
1335 dlinkAdd(abt
, &abt
->node
, &abort_list
);
1339 /* This does the remove of the user from channels..local or remote */
1341 exit_generic_client(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1342 const char *comment
)
1344 dlink_node
*ptr
, *next_ptr
;
1346 if(IsOper(source_p
))
1347 dlinkFindDestroy(source_p
, &oper_list
);
1349 sendto_common_channels_local(source_p
, ":%s!%s@%s QUIT :%s",
1351 source_p
->username
, source_p
->host
, comment
);
1353 remove_user_from_channels(source_p
);
1355 /* Should not be in any channels now */
1356 s_assert(source_p
->user
->channel
.head
== NULL
);
1358 /* Clean up invitefield */
1359 DLINK_FOREACH_SAFE(ptr
, next_ptr
, source_p
->user
->invited
.head
)
1361 del_invite(ptr
->data
, source_p
);
1364 /* Clean up allow lists */
1365 del_all_accepts(source_p
);
1367 add_history(source_p
, 0);
1368 off_history(source_p
);
1370 monitor_signoff(source_p
);
1372 if(has_id(source_p
))
1373 del_from_id_hash(source_p
->id
, source_p
);
1375 del_from_hostname_hash(source_p
->orighost
, source_p
);
1376 del_from_client_hash(source_p
->name
, source_p
);
1377 remove_client_from_list(source_p
);
1381 * Assumes IsPerson(source_p) && !MyConnect(source_p)
1385 exit_remote_client(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1386 const char *comment
)
1388 exit_generic_client(client_p
, source_p
, from
, comment
);
1390 if(source_p
->servptr
&& source_p
->servptr
->serv
)
1392 dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->users
);
1395 if((source_p
->flags
& FLAGS_KILLED
) == 0)
1397 sendto_server(client_p
, NULL
, CAP_TS6
, NOCAPS
,
1398 ":%s QUIT :%s", use_id(source_p
), comment
);
1399 sendto_server(client_p
, NULL
, NOCAPS
, CAP_TS6
,
1400 ":%s QUIT :%s", source_p
->name
, comment
);
1404 #ifdef DEBUG_EXITED_CLIENTS
1405 dlinkAddAlloc(source_p
, &dead_remote_list
);
1407 dlinkAddAlloc(source_p
, &dead_list
);
1409 return(CLIENT_EXITED
);
1413 * This assumes IsUnknown(source_p) == TRUE and MyConnect(source_p) == TRUE
1417 exit_unknown_client(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1418 const char *comment
)
1420 delete_auth_queries(source_p
);
1421 client_flush_input(source_p
);
1422 dlinkDelete(&source_p
->localClient
->tnode
, &unknown_list
);
1424 if(!IsIOError(source_p
))
1425 sendto_one(source_p
, "ERROR :Closing Link: %s (%s)",
1426 source_p
->user
!= NULL
? source_p
->host
: "127.0.0.1",
1429 close_connection(source_p
);
1431 if(has_id(source_p
))
1432 del_from_id_hash(source_p
->id
, source_p
);
1434 del_from_hostname_hash(source_p
->host
, source_p
);
1435 del_from_client_hash(source_p
->name
, source_p
);
1436 remove_client_from_list(source_p
);
1437 free_pre_client(source_p
);
1439 dlinkAddAlloc(source_p
, &dead_list
);
1441 /* Note that we don't need to add unknowns to the dead_list */
1442 return(CLIENT_EXITED
);
1446 exit_remote_server(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1447 const char *comment
)
1449 static char comment1
[(HOSTLEN
*2)+2];
1450 static char newcomment
[BUFSIZE
];
1451 struct Client
*target_p
;
1453 if(ConfigServerHide
.flatten_links
)
1454 strcpy(comment1
, "*.net *.split");
1457 if((source_p
->serv
) && (source_p
->serv
->up
))
1458 strcpy(comment1
, source_p
->serv
->up
);
1460 strcpy(comment1
, "<Unknown>");
1462 strcat(comment1
, " ");
1463 strcat(comment1
, source_p
->name
);
1466 ircsnprintf(newcomment
, sizeof(newcomment
), "by %s: %s",
1467 from
->name
, comment
);
1469 if(source_p
->serv
!= NULL
)
1470 remove_dependents(client_p
, source_p
, from
, IsPerson(from
) ? newcomment
: comment
, comment1
);
1472 if(source_p
->servptr
&& source_p
->servptr
->serv
)
1473 dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->servers
);
1477 dlinkFindDestroy(source_p
, &global_serv_list
);
1478 target_p
= source_p
->from
;
1480 if(target_p
!= NULL
&& IsServer(target_p
) && target_p
!= client_p
&&
1481 !IsMe(target_p
) && (source_p
->flags
& FLAGS_KILLED
) == 0)
1483 sendto_one(target_p
, ":%s SQUIT %s :%s",
1484 get_id(from
, target_p
), get_id(source_p
, target_p
),
1488 if(has_id(source_p
))
1489 del_from_id_hash(source_p
->id
, source_p
);
1491 del_from_client_hash(source_p
->name
, source_p
);
1492 remove_client_from_list(source_p
);
1495 #ifdef DEBUG_EXITED_CLIENTS
1496 dlinkAddAlloc(source_p
, &dead_remote_list
);
1498 dlinkAddAlloc(source_p
, &dead_list
);
1504 qs_server(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1505 const char *comment
)
1507 struct Client
*target_p
;
1509 if(source_p
->servptr
&& source_p
->servptr
->serv
)
1510 dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->servers
);
1514 dlinkFindDestroy(source_p
, &global_serv_list
);
1515 target_p
= source_p
->from
;
1517 if(has_id(source_p
))
1518 del_from_id_hash(source_p
->id
, source_p
);
1520 del_from_client_hash(source_p
->name
, source_p
);
1521 remove_client_from_list(source_p
);
1524 dlinkAddAlloc(source_p
, &dead_list
);
1529 exit_local_server(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1530 const char *comment
)
1532 static char comment1
[(HOSTLEN
*2)+2];
1533 static char newcomment
[BUFSIZE
];
1534 unsigned int sendk
, recvk
;
1536 dlinkDelete(&source_p
->localClient
->tnode
, &serv_list
);
1537 dlinkFindDestroy(source_p
, &global_serv_list
);
1539 unset_chcap_usage_counts(source_p
);
1540 sendk
= source_p
->localClient
->sendK
;
1541 recvk
= source_p
->localClient
->receiveK
;
1543 /* Always show source here, so the server notices show
1544 * which side initiated the split -- jilles
1546 ircsnprintf(newcomment
, sizeof(newcomment
), "by %s: %s",
1547 from
== source_p
? me
.name
: from
->name
, comment
);
1548 if (!IsIOError(source_p
))
1549 sendto_one(source_p
, "SQUIT %s :%s", use_id(source_p
),
1551 if(client_p
!= NULL
&& source_p
!= client_p
&& !IsIOError(source_p
))
1553 sendto_one(source_p
, "ERROR :Closing Link: 127.0.0.1 %s (%s)",
1554 source_p
->name
, comment
);
1557 if(source_p
->servptr
&& source_p
->servptr
->serv
)
1558 dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->servers
);
1563 close_connection(source_p
);
1565 if(ConfigServerHide
.flatten_links
)
1566 strcpy(comment1
, "*.net *.split");
1569 if((source_p
->serv
) && (source_p
->serv
->up
))
1570 strcpy(comment1
, source_p
->serv
->up
);
1572 strcpy(comment1
, "<Unknown>");
1574 strcat(comment1
, " ");
1575 strcat(comment1
, source_p
->name
);
1578 if(source_p
->serv
!= NULL
)
1579 remove_dependents(client_p
, source_p
, from
, IsPerson(from
) ? newcomment
: comment
, comment1
);
1581 sendto_realops_snomask(SNO_GENERAL
, L_ALL
, "%s was connected"
1582 " for %ld seconds. %d/%d sendK/recvK.",
1583 source_p
->name
, CurrentTime
- source_p
->localClient
->firsttime
, sendk
, recvk
);
1585 ilog(L_SERVER
, "%s was connected for %ld seconds. %d/%d sendK/recvK.",
1586 source_p
->name
, CurrentTime
- source_p
->localClient
->firsttime
, sendk
, recvk
);
1588 if(has_id(source_p
))
1589 del_from_id_hash(source_p
->id
, source_p
);
1591 del_from_client_hash(source_p
->name
, source_p
);
1592 remove_client_from_list(source_p
);
1595 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
;
1610 exit_generic_client(client_p
, source_p
, from
, comment
);
1611 clear_monitor(source_p
);
1613 s_assert(IsPerson(source_p
));
1614 client_flush_input(source_p
);
1615 dlinkDelete(&source_p
->localClient
->tnode
, &lclient_list
);
1616 dlinkDelete(&source_p
->lnode
, &me
.serv
->users
);
1618 if(IsOper(source_p
))
1619 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
= CurrentTime
- source_p
->localClient
->firsttime
;
1635 ilog(L_USER
, "%s (%3lu:%02lu:%02lu): %s!%s@%s %d/%d",
1636 myctime(CurrentTime
), on_for
/ 3600,
1637 (on_for
% 3600) / 60, on_for
% 60,
1638 source_p
->name
, source_p
->username
, source_p
->host
,
1639 source_p
->localClient
->sendK
, source_p
->localClient
->receiveK
);
1641 sendto_one(source_p
, "ERROR :Closing Link: %s (%s)", source_p
->host
, comment
);
1642 close_connection(source_p
);
1644 if((source_p
->flags
& FLAGS_KILLED
) == 0)
1646 sendto_server(client_p
, NULL
, CAP_TS6
, NOCAPS
,
1647 ":%s QUIT :%s", use_id(source_p
), comment
);
1648 sendto_server(client_p
, NULL
, NOCAPS
, CAP_TS6
,
1649 ":%s QUIT :%s", source_p
->name
, comment
);
1653 dlinkAddAlloc(source_p
, &dead_list
);
1654 return(CLIENT_EXITED
);
1659 ** exit_client - This is old "m_bye". Name changed, because this is not a
1660 ** protocol function, but a general server utility function.
1662 ** This function exits a client of *any* type (user, server, etc)
1663 ** from this server. Also, this generates all necessary prototol
1664 ** messages that this exit may cause.
1666 ** 1) If the client is a local client, then this implicitly
1667 ** exits all other clients depending on this connection (e.g.
1668 ** remote clients having 'from'-field that points to this.
1670 ** 2) If the client is a remote client, then only this is exited.
1672 ** For convenience, this function returns a suitable value for
1673 ** m_function return value:
1675 ** CLIENT_EXITED if (client_p == source_p)
1676 ** 0 if (client_p != source_p)
1679 exit_client(struct Client
*client_p
, /* The local client originating the
1680 * exit or NULL, if this exit is
1681 * generated by this server for
1683 * This will not get any of the
1684 * generated messages. */
1685 struct Client
*source_p
, /* Client exiting */
1686 struct Client
*from
, /* Client firing off this Exit,
1688 const char *comment
/* Reason for the exit */
1691 hook_data_client_exit hdata
;
1692 if(IsClosing(source_p
))
1695 /* note, this HAS to be here, when we exit a client we attempt to
1696 * send them data, if this generates a write error we must *not* add
1697 * them to the abort list --fl
1699 SetClosing(source_p
);
1701 hdata
.local_link
= client_p
;
1702 hdata
.target
= source_p
;
1704 hdata
.comment
= comment
;
1705 call_hook(h_client_exit
, &hdata
);
1707 if(MyConnect(source_p
))
1709 /* Local clients of various types */
1710 if(IsPerson(source_p
))
1711 return exit_local_client(client_p
, source_p
, from
, comment
);
1712 else if(IsServer(source_p
))
1713 return exit_local_server(client_p
, source_p
, from
, comment
);
1714 /* IsUnknown || IsConnecting || IsHandShake */
1715 else if(!IsReject(source_p
))
1716 return exit_unknown_client(client_p
, source_p
, from
, comment
);
1721 if(IsPerson(source_p
))
1722 return exit_remote_client(client_p
, source_p
, from
, comment
);
1723 else if(IsServer(source_p
))
1724 return exit_remote_server(client_p
, source_p
, from
, comment
);
1731 * Count up local client memory
1734 /* XXX one common Client list now */
1736 count_local_client_memory(size_t * count
, size_t * local_client_memory_used
)
1739 BlockHeapUsage(lclient_heap
, count
, NULL
, &lusage
);
1740 *local_client_memory_used
= lusage
+ (*count
* (sizeof(MemBlock
) + sizeof(struct Client
)));
1744 * Count up remote client memory
1747 count_remote_client_memory(size_t * count
, size_t * remote_client_memory_used
)
1749 size_t lcount
, rcount
;
1750 BlockHeapUsage(lclient_heap
, &lcount
, NULL
, NULL
);
1751 BlockHeapUsage(client_heap
, &rcount
, NULL
, NULL
);
1752 *count
= rcount
- lcount
;
1753 *remote_client_memory_used
= *count
* (sizeof(MemBlock
) + sizeof(struct Client
));
1758 * accept processing, this adds a form of "caller ID" to ircd
1760 * If a client puts themselves into "caller ID only" mode,
1761 * only clients that match a client pointer they have put on
1762 * the accept list will be allowed to message them.
1764 * [ source.on_allow_list ] -> [ target1 ] -> [ target2 ]
1766 * [target.allow_list] -> [ source1 ] -> [source2 ]
1768 * i.e. a target will have a link list of source pointers it will allow
1769 * each source client then has a back pointer pointing back
1770 * to the client that has it on its accept list.
1771 * This allows for exit_one_client to remove these now bogus entries
1772 * from any client having an accept on them.
1777 * inputs - pointer to exiting client
1779 * side effects - Walk through given clients allow_list and on_allow_list
1780 * remove all references to this client
1783 del_all_accepts(struct Client
*client_p
)
1786 dlink_node
*next_ptr
;
1787 struct Client
*target_p
;
1789 if(MyClient(client_p
) && client_p
->localClient
->allow_list
.head
)
1791 /* clear this clients accept list, and remove them from
1792 * everyones on_accept_list
1794 DLINK_FOREACH_SAFE(ptr
, next_ptr
, client_p
->localClient
->allow_list
.head
)
1796 target_p
= ptr
->data
;
1797 dlinkFindDestroy(client_p
, &target_p
->on_allow_list
);
1798 dlinkDestroy(ptr
, &client_p
->localClient
->allow_list
);
1802 /* remove this client from everyones accept list */
1803 DLINK_FOREACH_SAFE(ptr
, next_ptr
, client_p
->on_allow_list
.head
)
1805 target_p
= ptr
->data
;
1806 dlinkFindDestroy(client_p
, &target_p
->localClient
->allow_list
);
1807 dlinkDestroy(ptr
, &client_p
->on_allow_list
);
1812 * show_ip() - asks if the true IP shoudl be shown when source is
1813 * askin for info about target
1815 * Inputs - source_p who is asking
1816 * - target_p who do we want the info on
1817 * Output - returns 1 if clear IP can be showed, otherwise 0
1818 * Side Effects - none
1822 show_ip(struct Client
*source_p
, struct Client
*target_p
)
1824 if(IsAnyServer(target_p
))
1826 #ifndef HIDE_SERVERS_IPS
1827 if(source_p
== NULL
|| IsOper(source_p
))
1832 else if(IsIPSpoof(target_p
))
1834 /* source == NULL indicates message is being sent
1837 if(!ConfigFileEntry
.hide_spoof_ips
&&
1838 (source_p
== NULL
|| MyOper(source_p
)))
1842 else if(IsDynSpoof(target_p
) && (source_p
!= NULL
&& !IsOper(source_p
)))
1849 show_ip_conf(struct ConfItem
*aconf
, struct Client
*source_p
)
1851 if(IsConfDoSpoofIp(aconf
))
1853 if(!ConfigFileEntry
.hide_spoof_ips
&& MyOper(source_p
))
1868 * side effects - Creates a block heap for struct Users
1871 static BlockHeap
*user_heap
;
1875 user_heap
= BlockHeapCreate(sizeof(struct User
), USER_HEAP_SIZE
);
1883 * inputs - pointer to client struct
1884 * output - pointer to struct User
1885 * side effects - add's an User information block to a client
1886 * if it was not previously allocated.
1889 make_user(struct Client
*client_p
)
1893 user
= client_p
->user
;
1896 user
= (struct User
*) BlockHeapAlloc(user_heap
);
1898 client_p
->user
= user
;
1906 * inputs - pointer to client struct
1907 * output - pointer to server_t
1908 * side effects - add's an Server information block to a client
1909 * if it was not previously allocated.
1912 make_server(struct Client
*client_p
)
1914 server_t
*serv
= client_p
->serv
;
1918 serv
= (server_t
*) MyMalloc(sizeof(server_t
));
1919 client_p
->serv
= serv
;
1921 return client_p
->serv
;
1927 * inputs - pointer to user struct
1928 * - pointer to client struct
1930 * side effects - Decrease user reference count by one and release block,
1931 * if count reaches 0
1934 free_user(struct User
*user
, struct Client
*client_p
)
1936 if(--user
->refcnt
<= 0)
1939 MyFree((char *) user
->away
);
1943 if(user
->refcnt
< 0 || user
->invited
.head
|| user
->channel
.head
)
1945 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1946 "* %#lx user (%s!%s@%s) %#lx %#lx %#lx %lu %d *",
1947 (unsigned long) client_p
,
1948 client_p
? client_p
->
1952 (unsigned long) user
,
1953 (unsigned long) user
->invited
.head
,
1954 (unsigned long) user
->channel
.head
,
1955 dlink_list_length(&user
->channel
),
1957 s_assert(!user
->refcnt
);
1958 s_assert(!user
->invited
.head
);
1959 s_assert(!user
->channel
.head
);
1962 BlockHeapFree(user_heap
, user
);
1971 for(i
= 0; i
< 3; i
++)
1972 current_uid
[i
] = me
.id
[i
];
1974 for(i
= 3; i
< 9; i
++)
1975 current_uid
[i
] = 'A';
1977 current_uid
[9] = '\0';
1986 for(i
= 8; i
> 3; i
--)
1988 if(current_uid
[i
] == 'Z')
1990 current_uid
[i
] = '0';
1993 else if(current_uid
[i
] != '9')
1999 current_uid
[i
] = 'A';
2002 /* if this next if() triggers, we're fucked. */
2003 if(current_uid
[3] == 'Z')
2005 current_uid
[i
] = 'A';
2016 * Close the physical connection. This function must make
2017 * MyConnect(client_p) == FALSE, and set client_p->from == NULL.
2020 close_connection(struct Client
*client_p
)
2022 s_assert(client_p
!= NULL
);
2023 if(client_p
== NULL
)
2026 s_assert(MyConnect(client_p
));
2027 if(!MyConnect(client_p
))
2030 if(IsServer(client_p
))
2032 struct server_conf
*server_p
;
2034 ServerStats
->is_sv
++;
2035 ServerStats
->is_sbs
+= client_p
->localClient
->sendB
;
2036 ServerStats
->is_sbr
+= client_p
->localClient
->receiveB
;
2037 ServerStats
->is_sks
+= client_p
->localClient
->sendK
;
2038 ServerStats
->is_skr
+= client_p
->localClient
->receiveK
;
2039 ServerStats
->is_sti
+= CurrentTime
- client_p
->localClient
->firsttime
;
2040 if(ServerStats
->is_sbs
> 2047)
2042 ServerStats
->is_sks
+= (ServerStats
->is_sbs
>> 10);
2043 ServerStats
->is_sbs
&= 0x3ff;
2045 if(ServerStats
->is_sbr
> 2047)
2047 ServerStats
->is_skr
+= (ServerStats
->is_sbr
>> 10);
2048 ServerStats
->is_sbr
&= 0x3ff;
2052 * If the connection has been up for a long amount of time, schedule
2053 * a 'quick' reconnect, else reset the next-connect cycle.
2055 if((server_p
= find_server_conf(client_p
->name
)) != NULL
)
2058 * Reschedule a faster reconnect, if this was a automatically
2059 * connected configuration entry. (Note that if we have had
2060 * a rehash in between, the status has been changed to
2061 * CONF_ILLEGAL). But only do this if it was a "good" link.
2063 server_p
->hold
= time(NULL
);
2065 (server_p
->hold
- client_p
->localClient
->lasttime
>
2066 HANGONGOODLINK
) ? HANGONRETRYDELAY
: ConFreq(server_p
->class);
2070 else if(IsClient(client_p
))
2072 ServerStats
->is_cl
++;
2073 ServerStats
->is_cbs
+= client_p
->localClient
->sendB
;
2074 ServerStats
->is_cbr
+= client_p
->localClient
->receiveB
;
2075 ServerStats
->is_cks
+= client_p
->localClient
->sendK
;
2076 ServerStats
->is_ckr
+= client_p
->localClient
->receiveK
;
2077 ServerStats
->is_cti
+= CurrentTime
- client_p
->localClient
->firsttime
;
2078 if(ServerStats
->is_cbs
> 2047)
2080 ServerStats
->is_cks
+= (ServerStats
->is_cbs
>> 10);
2081 ServerStats
->is_cbs
&= 0x3ff;
2083 if(ServerStats
->is_cbr
> 2047)
2085 ServerStats
->is_ckr
+= (ServerStats
->is_cbr
>> 10);
2086 ServerStats
->is_cbr
&= 0x3ff;
2090 ServerStats
->is_ni
++;
2092 if(-1 < client_p
->localClient
->fd
)
2094 /* attempt to flush any pending dbufs. Evil, but .. -- adrian */
2095 if(!IsIOError(client_p
))
2096 send_queued_write(client_p
->localClient
->fd
, client_p
);
2098 comm_close(client_p
->localClient
->fd
);
2099 client_p
->localClient
->fd
= -1;
2102 if(-1 < client_p
->localClient
->ctrlfd
)
2104 comm_close(client_p
->localClient
->ctrlfd
);
2105 client_p
->localClient
->ctrlfd
= -1;
2108 linebuf_donebuf(&client_p
->localClient
->buf_sendq
);
2109 linebuf_donebuf(&client_p
->localClient
->buf_recvq
);
2110 detach_conf(client_p
);
2112 /* XXX shouldnt really be done here. */
2113 detach_server_conf(client_p
);
2115 client_p
->from
= NULL
; /* ...this should catch them! >:) --msa */
2116 ClearMyConnect(client_p
);
2117 SetIOError(client_p
);
2123 error_exit_client(struct Client
*client_p
, int error
)
2126 * ...hmm, with non-blocking sockets we might get
2127 * here from quite valid reasons, although.. why
2128 * would select report "data available" when there
2129 * wasn't... so, this must be an error anyway... --msa
2130 * actually, EOF occurs when read() returns 0 and
2131 * in due course, select() returns that fd as ready
2132 * for reading even though it ends up being an EOF. -avalon
2135 int current_error
= comm_get_sockerr(client_p
->localClient
->fd
);
2137 SetIOError(client_p
);
2139 if(IsServer(client_p
) || IsHandshake(client_p
))
2141 int connected
= CurrentTime
- client_p
->localClient
->firsttime
;
2145 sendto_realops_snomask(SNO_GENERAL
, is_remote_connect(client_p
) && !IsServer(client_p
) ? L_NETWIDE
: L_ALL
,
2146 "Server %s closed the connection",
2147 get_server_name(client_p
, SHOW_IP
));
2149 ilog(L_SERVER
, "Server %s closed the connection",
2150 log_client_name(client_p
, SHOW_IP
));
2154 sendto_realops_snomask(SNO_GENERAL
, is_remote_connect(client_p
) && !IsServer(client_p
) ? L_NETWIDE
: L_ALL
,
2155 "Lost connection to %s: %s",
2156 client_p
->name
, strerror(current_error
));
2157 ilog(L_SERVER
, "Lost connection to %s: %s",
2158 log_client_name(client_p
, SHOW_IP
), strerror(current_error
));
2161 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
2162 "%s had been connected for %d day%s, %2d:%02d:%02d",
2163 client_p
->name
, connected
/ 86400,
2164 (connected
/ 86400 == 1) ? "" : "s",
2165 (connected
% 86400) / 3600,
2166 (connected
% 3600) / 60, connected
% 60);
2170 strlcpy(errmsg
, "Remote host closed the connection", sizeof(errmsg
));
2172 ircsnprintf(errmsg
, sizeof(errmsg
), "Read error: %s", strerror(current_error
));
2174 exit_client(client_p
, client_p
, &me
, errmsg
);