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 $
36 #include "irc_string.h"
37 #include "sprintf_irc.h"
45 #include "s_newconf.h"
61 #include "blacklist.h"
64 #include "irc_dictionary.h"
66 #define DEBUG_EXITED_CLIENTS
68 static void check_pings_list(dlink_list
* list
);
69 static void check_unknowns_list(dlink_list
* list
);
70 static void free_exited_clients(void *unused
);
71 static void exit_aborted_clients(void *unused
);
73 static int exit_remote_client(struct Client
*, struct Client
*, struct Client
*,const char *);
74 static int exit_remote_server(struct Client
*, struct Client
*, struct Client
*,const char *);
75 static int exit_local_client(struct Client
*, struct Client
*, struct Client
*,const char *);
76 static int exit_unknown_client(struct Client
*, struct Client
*, struct Client
*,const char *);
77 static int exit_local_server(struct Client
*, struct Client
*, struct Client
*,const char *);
78 static int qs_server(struct Client
*, struct Client
*, struct Client
*, const char *comment
);
80 static EVH check_pings
;
82 extern BlockHeap
*client_heap
;
83 extern BlockHeap
*lclient_heap
;
84 extern BlockHeap
*pclient_heap
;
86 extern char current_uid
[IDLEN
];
88 struct Dictionary
*nd_dict
= NULL
;
98 #ifdef DEBUG_EXITED_CLIENTS
99 static dlink_list dead_remote_list
;
105 struct Client
*client
;
106 char notice
[REASONLEN
];
109 static dlink_list abort_list
;
117 * side effects - initialize client free memory
123 * start off the check ping event .. -- adrian
124 * Every 30 seconds is plenty -- db
126 client_heap
= BlockHeapCreate(sizeof(struct Client
), CLIENT_HEAP_SIZE
);
127 lclient_heap
= BlockHeapCreate(sizeof(struct LocalUser
), LCLIENT_HEAP_SIZE
);
128 pclient_heap
= BlockHeapCreate(sizeof(struct PreClient
), PCLIENT_HEAP_SIZE
);
129 eventAddIsh("check_pings", check_pings
, NULL
, 30);
130 eventAddIsh("free_exited_clients", &free_exited_clients
, NULL
, 4);
131 eventAddIsh("exit_aborted_clients", exit_aborted_clients
, NULL
, 1);
133 nd_dict
= irc_dictionary_create(irccmp
);
138 * make_client - create a new Client struct and set it to initial state.
140 * from == NULL, create local client (a client connected
143 * from, create remote client (behind a socket
144 * associated with the client defined by
145 * 'from'). ('from' is a local client!!).
148 make_client(struct Client
*from
)
150 struct Client
*client_p
= NULL
;
151 struct LocalUser
*localClient
;
153 client_p
= BlockHeapAlloc(client_heap
);
157 client_p
->from
= client_p
; /* 'from' of local client is self! */
159 localClient
= (struct LocalUser
*) BlockHeapAlloc(lclient_heap
);
160 SetMyConnect(client_p
);
161 client_p
->localClient
= localClient
;
163 client_p
->localClient
->lasttime
= client_p
->localClient
->firsttime
= CurrentTime
;
165 client_p
->localClient
->fd
= -1;
166 client_p
->localClient
->ctrlfd
= -1;
168 client_p
->preClient
= (struct PreClient
*) BlockHeapAlloc(pclient_heap
);
170 /* as good a place as any... */
171 dlinkAdd(client_p
, &client_p
->localClient
->tnode
, &unknown_list
);
174 { /* from is not NULL */
175 client_p
->localClient
= NULL
;
176 client_p
->preClient
= NULL
;
177 client_p
->from
= from
; /* 'from' of local client is self! */
180 SetUnknown(client_p
);
181 strcpy(client_p
->username
, "unknown");
187 free_pre_client(struct Client
*client_p
)
189 struct Blacklist
*blptr
;
191 s_assert(NULL
!= client_p
);
193 if(client_p
->preClient
== NULL
)
196 blptr
= client_p
->preClient
->dnsbl_listed
;
198 unref_blacklist(blptr
);
199 abort_blacklist_queries(client_p
);
200 BlockHeapFree(pclient_heap
, client_p
->preClient
);
201 client_p
->preClient
= NULL
;
205 free_local_client(struct Client
*client_p
)
207 s_assert(NULL
!= client_p
);
208 s_assert(&me
!= client_p
);
210 if(client_p
->localClient
== NULL
)
214 * clean up extra sockets from P-lines which have been discarded.
216 if(client_p
->localClient
->listener
)
218 s_assert(0 < client_p
->localClient
->listener
->ref_count
);
219 if(0 == --client_p
->localClient
->listener
->ref_count
220 && !client_p
->localClient
->listener
->active
)
221 free_listener(client_p
->localClient
->listener
);
222 client_p
->localClient
->listener
= 0;
225 if(client_p
->localClient
->fd
>= 0)
226 comm_close(client_p
->localClient
->fd
);
228 if(client_p
->localClient
->passwd
)
230 memset(client_p
->localClient
->passwd
, 0,
231 strlen(client_p
->localClient
->passwd
));
232 MyFree(client_p
->localClient
->passwd
);
235 MyFree(client_p
->localClient
->challenge
);
236 MyFree(client_p
->localClient
->fullcaps
);
237 MyFree(client_p
->localClient
->opername
);
238 MyFree(client_p
->localClient
->mangledhost
);
240 BlockHeapFree(lclient_heap
, client_p
->localClient
);
241 client_p
->localClient
= NULL
;
245 free_client(struct Client
*client_p
)
247 s_assert(NULL
!= client_p
);
248 s_assert(&me
!= client_p
);
249 free_local_client(client_p
);
250 free_pre_client(client_p
);
251 BlockHeapFree(client_heap
, client_p
);
255 * check_pings - go through the local client list and check activity
256 * kill off stuff that should die
258 * inputs - NOT USED (from event)
259 * output - next time_t when check_pings() should be called again
263 * A PING can be sent to clients as necessary.
265 * Client/Server ping outs are handled.
269 * Addon from adrian. We used to call this after nextping seconds,
270 * however I've changed it to run once a second. This is only for
271 * PING timeouts, not K/etc-line checks (thanks dianora!). Having it
272 * run once a second makes life a lot easier - when a new client connects
273 * and they need a ping in 4 seconds, if nextping was set to 20 seconds
274 * we end up waiting 20 seconds. This is stupid. :-)
275 * I will optimise (hah!) check_pings() once I've finished working on
276 * tidying up other network IO evilnesses.
281 check_pings(void *notused
)
283 check_pings_list(&lclient_list
);
284 check_pings_list(&serv_list
);
285 check_unknowns_list(&unknown_list
);
291 * inputs - pointer to list to check
296 check_pings_list(dlink_list
* list
)
298 char scratch
[32]; /* way too generous but... */
299 struct Client
*client_p
; /* current local client_p being examined */
300 int ping
= 0; /* ping time value from client */
301 dlink_node
*ptr
, *next_ptr
;
303 DLINK_FOREACH_SAFE(ptr
, next_ptr
, list
->head
)
305 client_p
= ptr
->data
;
308 ** Note: No need to notify opers here. It's
309 ** already done when "FLAGS_DEADSOCKET" is set.
311 if(!MyConnect(client_p
) || IsDead(client_p
))
314 if(IsPerson(client_p
))
316 if(!IsExemptKline(client_p
) &&
317 GlobalSetOptions
.idletime
&&
319 !IsIdlelined(client_p
) &&
320 ((CurrentTime
- client_p
->localClient
->last
) > GlobalSetOptions
.idletime
))
322 struct ConfItem
*aconf
;
325 aconf
->status
= CONF_KILL
;
327 DupString(aconf
->host
, client_p
->host
);
328 DupString(aconf
->passwd
, "idle exceeder");
329 DupString(aconf
->user
, client_p
->username
);
331 aconf
->hold
= CurrentTime
+ 60;
332 add_temp_kline(aconf
);
333 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
334 "Idle time limit exceeded for %s - temp k-lining",
335 get_client_name(client_p
, HIDE_IP
));
337 exit_client(client_p
, client_p
, &me
, aconf
->passwd
);
342 ping
= get_client_ping(client_p
);
344 if(ping
< (CurrentTime
- client_p
->localClient
->lasttime
))
347 * If the client/server hasnt talked to us in 2*ping seconds
348 * and it has a ping time, then close its connection.
350 if(((CurrentTime
- client_p
->localClient
->lasttime
) >= (2 * ping
)
351 && (client_p
->flags
& FLAGS_PINGSENT
)))
353 if(IsServer(client_p
))
355 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
356 "No response from %s, closing link",
357 get_server_name(client_p
, HIDE_IP
));
359 "No response from %s, closing link",
360 log_client_name(client_p
, HIDE_IP
));
362 (void) ircsnprintf(scratch
, sizeof(scratch
),
363 "Ping timeout: %d seconds",
364 (int) (CurrentTime
- client_p
->localClient
->lasttime
));
366 exit_client(client_p
, client_p
, &me
, scratch
);
369 else if((client_p
->flags
& FLAGS_PINGSENT
) == 0)
372 * if we havent PINGed the connection and we havent
373 * heard from it in a while, PING it to make sure
376 client_p
->flags
|= FLAGS_PINGSENT
;
377 /* not nice but does the job */
378 client_p
->localClient
->lasttime
= CurrentTime
- ping
;
379 sendto_one(client_p
, "PING :%s", me
.name
);
388 * check_unknowns_list
390 * inputs - pointer to list of unknown clients
392 * side effects - unknown clients get marked for termination after n seconds
395 check_unknowns_list(dlink_list
* list
)
397 dlink_node
*ptr
, *next_ptr
;
398 struct Client
*client_p
;
401 DLINK_FOREACH_SAFE(ptr
, next_ptr
, list
->head
)
403 client_p
= ptr
->data
;
405 if(IsDead(client_p
) || IsClosing(client_p
))
409 * Check UNKNOWN connections - if they have been in this state
410 * for > 30s, close them.
413 timeout
= IsAnyServer(client_p
) ? ConfigFileEntry
.connect_timeout
: 30;
414 if((CurrentTime
- client_p
->localClient
->firsttime
) > timeout
)
416 if(IsAnyServer(client_p
))
418 sendto_realops_snomask(SNO_GENERAL
, is_remote_connect(client_p
) ? L_NETWIDE
: L_ALL
,
419 "No response from %s, closing link",
420 get_server_name(client_p
, HIDE_IP
));
422 "No response from %s, closing link",
423 log_client_name(client_p
, HIDE_IP
));
425 exit_client(client_p
, client_p
, &me
, "Connection timed out");
431 notify_banned_client(struct Client
*client_p
, struct ConfItem
*aconf
, int ban
)
433 static const char conn_closed
[] = "Connection closed";
434 static const char d_lined
[] = "D-lined";
435 static const char k_lined
[] = "K-lined";
436 static const char g_lined
[] = "G-lined";
437 const char *reason
= NULL
;
438 const char *exit_reason
= conn_closed
;
440 if(ConfigFileEntry
.kline_with_reason
&& !EmptyString(aconf
->passwd
))
442 reason
= aconf
->passwd
;
443 exit_reason
= aconf
->passwd
;
447 switch (aconf
->status
)
461 if(ban
== D_LINED
&& !IsPerson(client_p
))
462 sendto_one(client_p
, "NOTICE DLINE :*** You have been D-lined");
464 sendto_one(client_p
, form_str(ERR_YOUREBANNEDCREEP
),
465 me
.name
, client_p
->name
, reason
);
467 exit_client(client_p
, client_p
, &me
,
468 EmptyString(ConfigFileEntry
.kline_reason
) ? exit_reason
:
469 ConfigFileEntry
.kline_reason
);
476 * side effects - Check all connections for a pending k/d/gline against the
477 * client, exit the client if found.
480 check_banned_lines(void)
482 struct Client
*client_p
; /* current local client_p being examined */
483 struct ConfItem
*aconf
= NULL
;
484 dlink_node
*ptr
, *next_ptr
;
486 DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
488 client_p
= ptr
->data
;
493 /* if there is a returned struct ConfItem then kill it */
494 if((aconf
= find_dline((struct sockaddr
*)&client_p
->localClient
->ip
, client_p
->localClient
->ip
.ss_family
)))
496 if(aconf
->status
& CONF_EXEMPTDLINE
)
499 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
500 "DLINE active for %s",
501 get_client_name(client_p
, HIDE_IP
));
503 notify_banned_client(client_p
, aconf
, D_LINED
);
504 continue; /* and go examine next fd/client_p */
507 if(!IsPerson(client_p
))
510 if((aconf
= find_kline(client_p
)) != NULL
)
512 if(IsExemptKline(client_p
))
514 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
515 "KLINE over-ruled for %s, client is kline_exempt [%s@%s]",
516 get_client_name(client_p
, HIDE_IP
),
517 aconf
->user
, aconf
->host
);
521 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
522 "KLINE active for %s",
523 get_client_name(client_p
, HIDE_IP
));
524 notify_banned_client(client_p
, aconf
, K_LINED
);
527 else if((aconf
= find_gline(client_p
)) != NULL
)
529 if(IsExemptKline(client_p
))
531 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
532 "GLINE over-ruled for %s, client is kline_exempt [%s@%s]",
533 get_client_name(client_p
, HIDE_IP
),
534 aconf
->user
, aconf
->host
);
538 if(IsExemptGline(client_p
))
540 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
541 "GLINE over-ruled for %s, client is gline_exempt [%s@%s]",
542 get_client_name(client_p
, HIDE_IP
),
543 aconf
->user
, aconf
->host
);
547 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
548 "GLINE active for %s",
549 get_client_name(client_p
, HIDE_IP
));
551 notify_banned_client(client_p
, aconf
, G_LINED
);
554 else if((aconf
= find_xline(client_p
->info
, 1)) != NULL
)
556 if(IsExemptKline(client_p
))
558 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
559 "XLINE over-ruled for %s, client is kline_exempt [%s]",
560 get_client_name(client_p
, HIDE_IP
),
565 sendto_realops_snomask(SNO_GENERAL
, L_ALL
, "XLINE active for %s",
566 get_client_name(client_p
, HIDE_IP
));
568 (void) exit_client(client_p
, client_p
, &me
, "Bad user info");
573 /* also check the unknowns list for new dlines */
574 DLINK_FOREACH_SAFE(ptr
, next_ptr
, unknown_list
.head
)
576 client_p
= ptr
->data
;
578 if((aconf
= find_dline((struct sockaddr
*)&client_p
->localClient
->ip
,client_p
->localClient
->ip
.ss_family
)))
580 if(aconf
->status
& CONF_EXEMPTDLINE
)
583 notify_banned_client(client_p
, aconf
, D_LINED
);
589 /* check_klines_event()
593 * side effects - check_klines() is called, kline_queued unset
596 check_klines_event(void *unused
)
606 * side effects - all clients will be checked for klines
611 struct Client
*client_p
;
612 struct ConfItem
*aconf
;
614 dlink_node
*next_ptr
;
616 DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
618 client_p
= ptr
->data
;
620 if(IsMe(client_p
) || !IsPerson(client_p
))
623 if((aconf
= find_kline(client_p
)) != NULL
)
625 if(IsExemptKline(client_p
))
627 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
628 "KLINE over-ruled for %s, client is kline_exempt",
629 get_client_name(client_p
, HIDE_IP
));
633 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
634 "KLINE active for %s",
635 get_client_name(client_p
, HIDE_IP
));
637 notify_banned_client(client_p
, aconf
, K_LINED
);
647 * side effects - all clients will be checked for glines
652 struct Client
*client_p
;
653 struct ConfItem
*aconf
;
655 dlink_node
*next_ptr
;
657 DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
659 client_p
= ptr
->data
;
661 if(IsMe(client_p
) || !IsPerson(client_p
))
664 if((aconf
= find_gline(client_p
)) != NULL
)
666 if(IsExemptKline(client_p
))
668 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
669 "GLINE over-ruled for %s, client is kline_exempt",
670 get_client_name(client_p
, HIDE_IP
));
674 if(IsExemptGline(client_p
))
676 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
677 "GLINE over-ruled for %s, client is gline_exempt",
678 get_client_name(client_p
, HIDE_IP
));
682 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
683 "GLINE active for %s",
684 get_client_name(client_p
, HIDE_IP
));
686 notify_banned_client(client_p
, aconf
, K_LINED
);
696 * side effects - all clients will be checked for dlines
701 struct Client
*client_p
;
702 struct ConfItem
*aconf
;
704 dlink_node
*next_ptr
;
706 DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
708 client_p
= ptr
->data
;
713 if((aconf
= find_dline((struct sockaddr
*)&client_p
->localClient
->ip
,client_p
->localClient
->ip
.ss_family
)) != NULL
)
715 if(aconf
->status
& CONF_EXEMPTDLINE
)
718 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
719 "DLINE active for %s",
720 get_client_name(client_p
, HIDE_IP
));
722 notify_banned_client(client_p
, aconf
, D_LINED
);
727 /* dlines need to be checked against unknowns too */
728 DLINK_FOREACH_SAFE(ptr
, next_ptr
, unknown_list
.head
)
730 client_p
= ptr
->data
;
732 if((aconf
= find_dline((struct sockaddr
*)&client_p
->localClient
->ip
,client_p
->localClient
->ip
.ss_family
)) != NULL
)
734 if(aconf
->status
& CONF_EXEMPTDLINE
)
737 notify_banned_client(client_p
, aconf
, D_LINED
);
746 * side effects - all clients will be checked for xlines
751 struct Client
*client_p
;
752 struct ConfItem
*aconf
;
754 dlink_node
*next_ptr
;
756 DLINK_FOREACH_SAFE(ptr
, next_ptr
, lclient_list
.head
)
758 client_p
= ptr
->data
;
760 if(IsMe(client_p
) || !IsPerson(client_p
))
763 if((aconf
= find_xline(client_p
->info
, 1)) != NULL
)
765 if(IsExemptKline(client_p
))
767 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
768 "XLINE over-ruled for %s, client is kline_exempt",
769 get_client_name(client_p
, HIDE_IP
));
773 sendto_realops_snomask(SNO_GENERAL
, L_ALL
, "XLINE active for %s",
774 get_client_name(client_p
, HIDE_IP
));
776 (void) exit_client(client_p
, client_p
, &me
, "Bad user info");
783 * update_client_exit_stats
785 * input - pointer to client
790 update_client_exit_stats(struct Client
*client_p
)
792 if(IsServer(client_p
))
794 sendto_realops_snomask(SNO_EXTERNAL
, L_ALL
,
795 "Server %s split from %s",
796 client_p
->name
, client_p
->servptr
->name
);
797 if(HasSentEob(client_p
))
800 else if(IsClient(client_p
))
805 if(IsInvisible(client_p
))
809 if(splitchecking
&& !splitmode
)
810 check_splitmode(NULL
);
814 * release_client_state
816 * input - pointer to client to release
821 release_client_state(struct Client
*client_p
)
823 if(client_p
->user
!= NULL
)
825 free_user(client_p
->user
, client_p
); /* try this here */
829 if(client_p
->serv
->user
!= NULL
)
830 free_user(client_p
->serv
->user
, client_p
);
831 if(client_p
->serv
->fullcaps
)
832 MyFree(client_p
->serv
->fullcaps
);
833 MyFree(client_p
->serv
);
838 * remove_client_from_list
839 * inputs - point to client to remove
841 * side effects - taken the code from ExitOneClient() for this
842 * and placed it here. - avalon
845 remove_client_from_list(struct Client
*client_p
)
847 s_assert(NULL
!= client_p
);
852 /* A client made with make_client()
853 * is on the unknown_list until removed.
854 * If it =does= happen to exit before its removed from that list
855 * and its =not= on the global_client_list, it will core here.
856 * short circuit that case now -db
858 if(client_p
->node
.prev
== NULL
&& client_p
->node
.next
== NULL
)
861 dlinkDelete(&client_p
->node
, &global_client_list
);
863 update_client_exit_stats(client_p
);
868 * find_person - find person by (nick)name.
869 * inputs - pointer to name
870 * output - return client pointer
874 find_person(const char *name
)
876 struct Client
*c2ptr
;
878 c2ptr
= find_client(name
);
880 if(c2ptr
&& IsPerson(c2ptr
))
886 find_named_person(const char *name
)
888 struct Client
*c2ptr
;
890 c2ptr
= find_named_client(name
);
892 if(c2ptr
&& IsPerson(c2ptr
))
899 * find_chasing - find the client structure for a nick name (user)
900 * using history mechanism if necessary. If the client is not found,
901 * an error message (NO SUCH NICK) is generated. If the client was found
902 * through the history, chasing will be 1 and otherwise 0.
905 find_chasing(struct Client
*source_p
, const char *user
, int *chasing
)
909 if(MyClient(source_p
))
910 who
= find_named_person(user
);
912 who
= find_person(user
);
917 if(who
|| IsDigit(*user
))
920 if(!(who
= get_history(user
, (long) KILLCHASETIMELIMIT
)))
922 sendto_one_numeric(source_p
, ERR_NOSUCHNICK
,
923 form_str(ERR_NOSUCHNICK
), user
);
932 * get_client_name - Return the name of the client
933 * for various tracking and
934 * admin purposes. The main purpose of this function is to
935 * return the "socket host" name of the client, if that
936 * differs from the advertised name (other than case).
937 * But, this can be used to any client structure.
940 * Watch out the allocation of "nbuf", if either source_p->name
941 * or source_p->sockhost gets changed into pointers instead of
942 * directly allocated within the structure...
945 * Function return either a pointer to the structure (source_p) or
946 * to internal buffer (nbuf). *NEVER* use the returned pointer
947 * to modify what it points!!!
951 get_client_name(struct Client
*client
, int showip
)
953 static char nbuf
[HOSTLEN
* 2 + USERLEN
+ 5];
955 s_assert(NULL
!= client
);
959 if(MyConnect(client
))
961 if(!irccmp(client
->name
, client
->host
))
964 if(ConfigFileEntry
.hide_spoof_ips
&&
965 showip
== SHOW_IP
&& IsIPSpoof(client
))
967 #ifdef HIDE_SERVERS_IPS
968 if(IsAnyServer(client
))
972 /* And finally, let's get the host information, ip or name */
976 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]",
977 client
->name
, client
->username
,
981 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@255.255.255.255]",
982 client
->name
, client
->username
);
985 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]",
986 client
->name
, client
->username
, client
->host
);
991 /* As pointed out by Adel Mezibra
992 * Neph|l|m@EFnet. Was missing a return here.
998 get_server_name(struct Client
*target_p
, int showip
)
1000 static char nbuf
[HOSTLEN
* 2 + USERLEN
+ 5];
1002 if(target_p
== NULL
)
1005 if(!MyConnect(target_p
) || !irccmp(target_p
->name
, target_p
->host
))
1006 return target_p
->name
;
1008 #ifdef HIDE_SERVERS_IPS
1009 if(EmptyString(target_p
->name
))
1011 ircsnprintf(nbuf
, sizeof(nbuf
), "[%s@255.255.255.255]",
1012 target_p
->username
);
1016 return target_p
->name
;
1022 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]",
1023 target_p
->name
, target_p
->username
,
1024 target_p
->sockhost
);
1028 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@255.255.255.255]",
1029 target_p
->name
, target_p
->username
);
1032 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]",
1033 target_p
->name
, target_p
->username
,
1040 /* log_client_name()
1042 * This version is the same as get_client_name, but doesnt contain the
1043 * code that will hide IPs always. This should be used for logfiles.
1046 log_client_name(struct Client
*target_p
, int showip
)
1048 static char nbuf
[HOSTLEN
* 2 + USERLEN
+ 5];
1050 if(target_p
== NULL
)
1053 if(MyConnect(target_p
))
1055 if(irccmp(target_p
->name
, target_p
->host
) == 0)
1056 return target_p
->name
;
1061 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]", target_p
->name
,
1062 target_p
->username
, target_p
->sockhost
);
1066 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@255.255.255.255]",
1067 target_p
->name
, target_p
->username
);
1070 ircsnprintf(nbuf
, sizeof(nbuf
), "%s[%s@%s]", target_p
->name
,
1071 target_p
->username
, target_p
->host
);
1077 return target_p
->name
;
1080 /* is_remote_connect - Returns whether a server was /connect'ed by a remote
1081 * oper (send notices netwide) */
1083 is_remote_connect(struct Client
*client_p
)
1085 struct Client
*oper
;
1087 if (client_p
->serv
== NULL
)
1089 oper
= find_named_person(client_p
->serv
->by
);
1090 return oper
!= NULL
&& IsOper(oper
) && !MyConnect(oper
);
1094 free_exited_clients(void *unused
)
1096 dlink_node
*ptr
, *next
;
1097 struct Client
*target_p
;
1099 DLINK_FOREACH_SAFE(ptr
, next
, dead_list
.head
)
1101 target_p
= ptr
->data
;
1103 #ifdef DEBUG_EXITED_CLIENTS
1105 struct abort_client
*abt
;
1109 DLINK_FOREACH(aptr
, abort_list
.head
)
1112 if(abt
->client
== target_p
)
1115 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1116 "On abort_list: %s stat: %u flags: %u/%u handler: %c",
1117 target_p
->name
, (unsigned int) target_p
->status
,
1118 target_p
->flags
, target_p
->flags2
, target_p
->handler
);
1119 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1120 "Please report this to the charybdis developers!");
1127 dlinkDestroy(ptr
, &dead_list
);
1133 if(ptr
->data
== NULL
)
1135 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1136 "Warning: null client on dead_list!");
1137 dlinkDestroy(ptr
, &dead_list
);
1140 release_client_state(target_p
);
1141 free_client(target_p
);
1142 dlinkDestroy(ptr
, &dead_list
);
1145 #ifdef DEBUG_EXITED_CLIENTS
1146 DLINK_FOREACH_SAFE(ptr
, next
, dead_remote_list
.head
)
1148 target_p
= ptr
->data
;
1150 if(ptr
->data
== NULL
)
1152 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1153 "Warning: null client on dead_list!");
1154 dlinkDestroy(ptr
, &dead_list
);
1157 release_client_state(target_p
);
1158 free_client(target_p
);
1159 dlinkDestroy(ptr
, &dead_remote_list
);
1166 ** Recursively send QUITs and SQUITs for source_p and all its dependent clients
1167 ** and servers to those servers that need them. A server needs the client
1168 ** QUITs if it can't figure them out from the SQUIT (ie pre-TS4) or if it
1169 ** isn't getting the SQUIT because of @#(*&@)# hostmasking. With TS4, once
1170 ** a link gets a SQUIT, it doesn't need any QUIT/SQUITs for clients depending
1171 ** on that one -orabidoo
1174 recurse_send_quits(struct Client
*client_p
, struct Client
*source_p
,
1175 struct Client
*to
, const char *comment1
,
1176 const char *comment
)
1178 struct Client
*target_p
;
1179 dlink_node
*ptr
, *ptr_next
;
1180 /* If this server can handle quit storm (QS) removal
1181 * of dependents, just send the SQUIT
1184 if(IsCapable(to
, CAP_QS
))
1186 sendto_one(to
, "SQUIT %s :%s",
1187 get_id(source_p
, to
), comment
);
1191 DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->users
.head
)
1193 target_p
= ptr
->data
;
1194 sendto_one(to
, ":%s QUIT :%s", target_p
->name
, comment1
);
1196 DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->servers
.head
)
1198 target_p
= ptr
->data
;
1199 recurse_send_quits(client_p
, target_p
, to
, comment1
, comment
);
1201 sendto_one(to
, "SQUIT %s :%s", source_p
->name
, comment
);
1206 ** Remove all clients that depend on source_p; assumes all (S)QUITs have
1207 ** already been sent. we make sure to exit a server's dependent clients
1208 ** and servers before the server itself; exit_one_client takes care of
1209 ** actually removing things off llists. tweaked from +CSr31 -orabidoo
1212 * added sanity test code.... source_p->serv might be NULL...
1215 recurse_remove_clients(struct Client
*source_p
, const char *comment
)
1217 struct Client
*target_p
;
1218 dlink_node
*ptr
, *ptr_next
;
1223 if(source_p
->serv
== NULL
) /* oooops. uh this is actually a major bug */
1226 /* this is very ugly, but it saves cpu :P */
1227 if(ConfigFileEntry
.nick_delay
> 0)
1229 DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->users
.head
)
1231 target_p
= ptr
->data
;
1232 target_p
->flags
|= FLAGS_KILLED
;
1233 add_nd_entry(target_p
->name
);
1235 if(!IsDead(target_p
) && !IsClosing(target_p
))
1236 exit_remote_client(NULL
, target_p
, &me
, comment
);
1241 DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->users
.head
)
1243 target_p
= ptr
->data
;
1244 target_p
->flags
|= FLAGS_KILLED
;
1246 if(!IsDead(target_p
) && !IsClosing(target_p
))
1247 exit_remote_client(NULL
, target_p
, &me
, comment
);
1251 DLINK_FOREACH_SAFE(ptr
, ptr_next
, source_p
->serv
->servers
.head
)
1253 target_p
= ptr
->data
;
1254 recurse_remove_clients(target_p
, comment
);
1255 qs_server(NULL
, target_p
, &me
, comment
);
1260 ** Remove *everything* that depends on source_p, from all lists, and sending
1261 ** all necessary QUITs and SQUITs. source_p itself is still on the lists,
1262 ** and its SQUITs have been sent except for the upstream one -orabidoo
1265 remove_dependents(struct Client
*client_p
,
1266 struct Client
*source_p
,
1267 struct Client
*from
, const char *comment
, const char *comment1
)
1270 dlink_node
*ptr
, *next
;
1272 DLINK_FOREACH_SAFE(ptr
, next
, serv_list
.head
)
1276 if(IsMe(to
) || to
== source_p
->from
||
1277 (to
== client_p
&& IsCapable(to
, CAP_QS
)))
1280 recurse_send_quits(client_p
, source_p
, to
, comment1
, comment
);
1283 recurse_remove_clients(source_p
, comment1
);
1287 exit_aborted_clients(void *unused
)
1289 struct abort_client
*abt
;
1290 dlink_node
*ptr
, *next
;
1291 DLINK_FOREACH_SAFE(ptr
, next
, abort_list
.head
)
1295 #ifdef DEBUG_EXITED_CLIENTS
1297 if(dlinkFind(abt
->client
, &dead_list
))
1300 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1301 "On dead_list: %s stat: %u flags: %u/%u handler: %c",
1302 abt
->client
->name
, (unsigned int) abt
->client
->status
,
1303 abt
->client
->flags
, abt
->client
->flags2
, abt
->client
->handler
);
1304 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1305 "Please report this to the charybdis developers!");
1311 s_assert(*((unsigned long*)abt
->client
) != 0xdeadbeef); /* This is lame but its a debug thing */
1312 dlinkDelete(ptr
, &abort_list
);
1314 if(IsAnyServer(abt
->client
))
1315 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1316 "Closing link to %s: %s",
1317 get_server_name(abt
->client
, HIDE_IP
), abt
->notice
);
1319 /* its no longer on abort list - we *must* remove
1320 * FLAGS_CLOSING otherwise exit_client() will not run --fl
1322 abt
->client
->flags
&= ~FLAGS_CLOSING
;
1323 exit_client(abt
->client
, abt
->client
, &me
, abt
->notice
);
1330 * dead_link - Adds client to a list of clients that need an exit_client()
1334 dead_link(struct Client
*client_p
)
1336 struct abort_client
*abt
;
1338 s_assert(!IsMe(client_p
));
1339 if(IsDead(client_p
) || IsClosing(client_p
) || IsMe(client_p
))
1342 abt
= (struct abort_client
*) MyMalloc(sizeof(struct abort_client
));
1344 if(client_p
->flags
& FLAGS_SENDQEX
)
1345 strlcpy(abt
->notice
, "Max SendQ exceeded", sizeof(abt
->notice
));
1347 ircsnprintf(abt
->notice
, sizeof(abt
->notice
), "Write error: %s", strerror(errno
));
1349 abt
->client
= client_p
;
1350 SetIOError(client_p
);
1352 SetClosing(client_p
);
1353 dlinkAdd(abt
, &abt
->node
, &abort_list
);
1357 /* This does the remove of the user from channels..local or remote */
1359 exit_generic_client(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1360 const char *comment
)
1362 dlink_node
*ptr
, *next_ptr
;
1364 if(IsOper(source_p
))
1365 dlinkFindDestroy(source_p
, &oper_list
);
1367 sendto_common_channels_local(source_p
, ":%s!%s@%s QUIT :%s",
1369 source_p
->username
, source_p
->host
, comment
);
1371 remove_user_from_channels(source_p
);
1373 /* Should not be in any channels now */
1374 s_assert(source_p
->user
->channel
.head
== NULL
);
1376 /* Clean up invitefield */
1377 DLINK_FOREACH_SAFE(ptr
, next_ptr
, source_p
->user
->invited
.head
)
1379 del_invite(ptr
->data
, source_p
);
1382 /* Clean up allow lists */
1383 del_all_accepts(source_p
);
1385 add_history(source_p
, 0);
1386 off_history(source_p
);
1388 monitor_signoff(source_p
);
1390 if(has_id(source_p
))
1391 del_from_id_hash(source_p
->id
, source_p
);
1393 del_from_hostname_hash(source_p
->orighost
, source_p
);
1394 del_from_client_hash(source_p
->name
, source_p
);
1395 remove_client_from_list(source_p
);
1399 * Assumes IsPerson(source_p) && !MyConnect(source_p)
1403 exit_remote_client(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1404 const char *comment
)
1406 exit_generic_client(client_p
, source_p
, from
, comment
);
1408 if(source_p
->servptr
&& source_p
->servptr
->serv
)
1410 dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->users
);
1413 if((source_p
->flags
& FLAGS_KILLED
) == 0)
1415 sendto_server(client_p
, NULL
, CAP_TS6
, NOCAPS
,
1416 ":%s QUIT :%s", use_id(source_p
), comment
);
1417 sendto_server(client_p
, NULL
, NOCAPS
, CAP_TS6
,
1418 ":%s QUIT :%s", source_p
->name
, comment
);
1422 #ifdef DEBUG_EXITED_CLIENTS
1423 dlinkAddAlloc(source_p
, &dead_remote_list
);
1425 dlinkAddAlloc(source_p
, &dead_list
);
1427 return(CLIENT_EXITED
);
1431 * This assumes IsUnknown(source_p) == TRUE and MyConnect(source_p) == TRUE
1435 exit_unknown_client(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1436 const char *comment
)
1438 delete_auth_queries(source_p
);
1439 client_flush_input(source_p
);
1440 del_unknown_ip(source_p
);
1441 dlinkDelete(&source_p
->localClient
->tnode
, &unknown_list
);
1443 if(!IsIOError(source_p
))
1444 sendto_one(source_p
, "ERROR :Closing Link: %s (%s)",
1445 source_p
->user
!= NULL
? source_p
->host
: "127.0.0.1",
1448 close_connection(source_p
);
1450 if(has_id(source_p
))
1451 del_from_id_hash(source_p
->id
, source_p
);
1453 del_from_hostname_hash(source_p
->host
, source_p
);
1454 del_from_client_hash(source_p
->name
, source_p
);
1455 remove_client_from_list(source_p
);
1457 dlinkAddAlloc(source_p
, &dead_list
);
1459 /* Note that we don't need to add unknowns to the dead_list */
1460 return(CLIENT_EXITED
);
1464 exit_remote_server(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1465 const char *comment
)
1467 static char comment1
[(HOSTLEN
*2)+2];
1468 static char newcomment
[BUFSIZE
];
1469 struct Client
*target_p
;
1471 if(ConfigServerHide
.flatten_links
)
1472 strcpy(comment1
, "*.net *.split");
1475 strcpy(comment1
, source_p
->servptr
->name
);
1476 strcat(comment1
, " ");
1477 strcat(comment1
, source_p
->name
);
1480 ircsnprintf(newcomment
, sizeof(newcomment
), "by %s: %s",
1481 from
->name
, comment
);
1483 if(source_p
->serv
!= NULL
)
1484 remove_dependents(client_p
, source_p
, from
, IsPerson(from
) ? newcomment
: comment
, comment1
);
1486 if(source_p
->servptr
&& source_p
->servptr
->serv
)
1487 dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->servers
);
1491 dlinkFindDestroy(source_p
, &global_serv_list
);
1492 target_p
= source_p
->from
;
1494 if(target_p
!= NULL
&& IsServer(target_p
) && target_p
!= client_p
&&
1495 !IsMe(target_p
) && (source_p
->flags
& FLAGS_KILLED
) == 0)
1497 sendto_one(target_p
, ":%s SQUIT %s :%s",
1498 get_id(from
, target_p
), get_id(source_p
, target_p
),
1502 if(has_id(source_p
))
1503 del_from_id_hash(source_p
->id
, source_p
);
1505 del_from_client_hash(source_p
->name
, source_p
);
1506 remove_client_from_list(source_p
);
1507 scache_split(source_p
->serv
->nameinfo
);
1510 #ifdef DEBUG_EXITED_CLIENTS
1511 dlinkAddAlloc(source_p
, &dead_remote_list
);
1513 dlinkAddAlloc(source_p
, &dead_list
);
1519 qs_server(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1520 const char *comment
)
1522 struct Client
*target_p
;
1524 if(source_p
->servptr
&& source_p
->servptr
->serv
)
1525 dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->servers
);
1529 dlinkFindDestroy(source_p
, &global_serv_list
);
1530 target_p
= source_p
->from
;
1532 if(has_id(source_p
))
1533 del_from_id_hash(source_p
->id
, source_p
);
1535 del_from_client_hash(source_p
->name
, source_p
);
1536 remove_client_from_list(source_p
);
1539 dlinkAddAlloc(source_p
, &dead_list
);
1544 exit_local_server(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1545 const char *comment
)
1547 static char comment1
[(HOSTLEN
*2)+2];
1548 static char newcomment
[BUFSIZE
];
1549 unsigned int sendk
, recvk
;
1551 dlinkDelete(&source_p
->localClient
->tnode
, &serv_list
);
1552 dlinkFindDestroy(source_p
, &global_serv_list
);
1554 unset_chcap_usage_counts(source_p
);
1555 sendk
= source_p
->localClient
->sendK
;
1556 recvk
= source_p
->localClient
->receiveK
;
1558 /* Always show source here, so the server notices show
1559 * which side initiated the split -- jilles
1561 ircsnprintf(newcomment
, sizeof(newcomment
), "by %s: %s",
1562 from
== source_p
? me
.name
: from
->name
, comment
);
1563 if (!IsIOError(source_p
))
1564 sendto_one(source_p
, "SQUIT %s :%s", use_id(source_p
),
1566 if(client_p
!= NULL
&& source_p
!= client_p
&& !IsIOError(source_p
))
1568 sendto_one(source_p
, "ERROR :Closing Link: 127.0.0.1 %s (%s)",
1569 source_p
->name
, comment
);
1572 if(source_p
->servptr
&& source_p
->servptr
->serv
)
1573 dlinkDelete(&source_p
->lnode
, &source_p
->servptr
->serv
->servers
);
1578 close_connection(source_p
);
1580 if(ConfigServerHide
.flatten_links
)
1581 strcpy(comment1
, "*.net *.split");
1584 strcpy(comment1
, source_p
->servptr
->name
);
1585 strcat(comment1
, " ");
1586 strcat(comment1
, source_p
->name
);
1589 if(source_p
->serv
!= NULL
)
1590 remove_dependents(client_p
, source_p
, from
, IsPerson(from
) ? newcomment
: comment
, comment1
);
1592 sendto_realops_snomask(SNO_GENERAL
, L_ALL
, "%s was connected"
1593 " for %ld seconds. %d/%d sendK/recvK.",
1594 source_p
->name
, CurrentTime
- source_p
->localClient
->firsttime
, sendk
, recvk
);
1596 ilog(L_SERVER
, "%s was connected for %ld seconds. %d/%d sendK/recvK.",
1597 source_p
->name
, CurrentTime
- source_p
->localClient
->firsttime
, sendk
, recvk
);
1599 if(has_id(source_p
))
1600 del_from_id_hash(source_p
->id
, source_p
);
1602 del_from_client_hash(source_p
->name
, source_p
);
1603 remove_client_from_list(source_p
);
1604 scache_split(source_p
->serv
->nameinfo
);
1607 dlinkAddAlloc(source_p
, &dead_list
);
1613 * This assumes IsPerson(source_p) == TRUE && MyConnect(source_p) == TRUE
1617 exit_local_client(struct Client
*client_p
, struct Client
*source_p
, struct Client
*from
,
1618 const char *comment
)
1620 unsigned long on_for
;
1622 exit_generic_client(client_p
, source_p
, from
, comment
);
1623 clear_monitor(source_p
);
1625 s_assert(IsPerson(source_p
));
1626 client_flush_input(source_p
);
1627 dlinkDelete(&source_p
->localClient
->tnode
, &lclient_list
);
1628 dlinkDelete(&source_p
->lnode
, &me
.serv
->users
);
1630 if(IsOper(source_p
))
1631 dlinkFindDestroy(source_p
, &local_oper_list
);
1633 sendto_realops_snomask(SNO_CCONN
, L_ALL
,
1634 "Client exiting: %s (%s@%s) [%s] [%s]",
1636 source_p
->username
, source_p
->host
, comment
,
1637 show_ip(NULL
, source_p
) ? source_p
->sockhost
: "255.255.255.255");
1639 sendto_realops_snomask(SNO_CCONNEXT
, L_ALL
,
1640 "CLIEXIT %s %s %s %s 0 %s",
1641 source_p
->name
, source_p
->username
, source_p
->host
,
1642 show_ip(NULL
, source_p
) ? source_p
->sockhost
: "255.255.255.255",
1645 on_for
= CurrentTime
- source_p
->localClient
->firsttime
;
1647 ilog(L_USER
, "%s (%3lu:%02lu:%02lu): %s!%s@%s %d/%d",
1648 myctime(CurrentTime
), on_for
/ 3600,
1649 (on_for
% 3600) / 60, on_for
% 60,
1650 source_p
->name
, source_p
->username
, source_p
->host
,
1651 source_p
->localClient
->sendK
, source_p
->localClient
->receiveK
);
1653 sendto_one(source_p
, "ERROR :Closing Link: %s (%s)", source_p
->host
, comment
);
1654 close_connection(source_p
);
1656 if((source_p
->flags
& FLAGS_KILLED
) == 0)
1658 sendto_server(client_p
, NULL
, CAP_TS6
, NOCAPS
,
1659 ":%s QUIT :%s", use_id(source_p
), comment
);
1660 sendto_server(client_p
, NULL
, NOCAPS
, CAP_TS6
,
1661 ":%s QUIT :%s", source_p
->name
, comment
);
1665 dlinkAddAlloc(source_p
, &dead_list
);
1666 return(CLIENT_EXITED
);
1671 ** exit_client - This is old "m_bye". Name changed, because this is not a
1672 ** protocol function, but a general server utility function.
1674 ** This function exits a client of *any* type (user, server, etc)
1675 ** from this server. Also, this generates all necessary prototol
1676 ** messages that this exit may cause.
1678 ** 1) If the client is a local client, then this implicitly
1679 ** exits all other clients depending on this connection (e.g.
1680 ** remote clients having 'from'-field that points to this.
1682 ** 2) If the client is a remote client, then only this is exited.
1684 ** For convenience, this function returns a suitable value for
1685 ** m_function return value:
1687 ** CLIENT_EXITED if (client_p == source_p)
1688 ** 0 if (client_p != source_p)
1691 exit_client(struct Client
*client_p
, /* The local client originating the
1692 * exit or NULL, if this exit is
1693 * generated by this server for
1695 * This will not get any of the
1696 * generated messages. */
1697 struct Client
*source_p
, /* Client exiting */
1698 struct Client
*from
, /* Client firing off this Exit,
1700 const char *comment
/* Reason for the exit */
1703 hook_data_client_exit hdata
;
1704 if(IsClosing(source_p
))
1707 /* note, this HAS to be here, when we exit a client we attempt to
1708 * send them data, if this generates a write error we must *not* add
1709 * them to the abort list --fl
1711 SetClosing(source_p
);
1713 hdata
.local_link
= client_p
;
1714 hdata
.target
= source_p
;
1716 hdata
.comment
= comment
;
1717 call_hook(h_client_exit
, &hdata
);
1719 if(MyConnect(source_p
))
1721 /* Local clients of various types */
1722 if(IsPerson(source_p
))
1723 return exit_local_client(client_p
, source_p
, from
, comment
);
1724 else if(IsServer(source_p
))
1725 return exit_local_server(client_p
, source_p
, from
, comment
);
1726 /* IsUnknown || IsConnecting || IsHandShake */
1727 else if(!IsReject(source_p
))
1728 return exit_unknown_client(client_p
, source_p
, from
, comment
);
1733 if(IsPerson(source_p
))
1734 return exit_remote_client(client_p
, source_p
, from
, comment
);
1735 else if(IsServer(source_p
))
1736 return exit_remote_server(client_p
, source_p
, from
, comment
);
1743 * Count up local client memory
1746 /* XXX one common Client list now */
1748 count_local_client_memory(size_t * count
, size_t * local_client_memory_used
)
1751 BlockHeapUsage(lclient_heap
, count
, NULL
, &lusage
);
1752 *local_client_memory_used
= lusage
+ (*count
* (sizeof(MemBlock
) + sizeof(struct Client
)));
1756 * Count up remote client memory
1759 count_remote_client_memory(size_t * count
, size_t * remote_client_memory_used
)
1761 size_t lcount
, rcount
;
1762 BlockHeapUsage(lclient_heap
, &lcount
, NULL
, NULL
);
1763 BlockHeapUsage(client_heap
, &rcount
, NULL
, NULL
);
1764 *count
= rcount
- lcount
;
1765 *remote_client_memory_used
= *count
* (sizeof(MemBlock
) + sizeof(struct Client
));
1770 * accept processing, this adds a form of "caller ID" to ircd
1772 * If a client puts themselves into "caller ID only" mode,
1773 * only clients that match a client pointer they have put on
1774 * the accept list will be allowed to message them.
1776 * [ source.on_allow_list ] -> [ target1 ] -> [ target2 ]
1778 * [target.allow_list] -> [ source1 ] -> [source2 ]
1780 * i.e. a target will have a link list of source pointers it will allow
1781 * each source client then has a back pointer pointing back
1782 * to the client that has it on its accept list.
1783 * This allows for exit_one_client to remove these now bogus entries
1784 * from any client having an accept on them.
1789 * inputs - pointer to exiting client
1791 * side effects - Walk through given clients allow_list and on_allow_list
1792 * remove all references to this client
1795 del_all_accepts(struct Client
*client_p
)
1798 dlink_node
*next_ptr
;
1799 struct Client
*target_p
;
1801 if(MyClient(client_p
) && client_p
->localClient
->allow_list
.head
)
1803 /* clear this clients accept list, and remove them from
1804 * everyones on_accept_list
1806 DLINK_FOREACH_SAFE(ptr
, next_ptr
, client_p
->localClient
->allow_list
.head
)
1808 target_p
= ptr
->data
;
1809 dlinkFindDestroy(client_p
, &target_p
->on_allow_list
);
1810 dlinkDestroy(ptr
, &client_p
->localClient
->allow_list
);
1814 /* remove this client from everyones accept list */
1815 DLINK_FOREACH_SAFE(ptr
, next_ptr
, client_p
->on_allow_list
.head
)
1817 target_p
= ptr
->data
;
1818 dlinkFindDestroy(client_p
, &target_p
->localClient
->allow_list
);
1819 dlinkDestroy(ptr
, &client_p
->on_allow_list
);
1824 * show_ip() - asks if the true IP shoudl be shown when source is
1825 * askin for info about target
1827 * Inputs - source_p who is asking
1828 * - target_p who do we want the info on
1829 * Output - returns 1 if clear IP can be showed, otherwise 0
1830 * Side Effects - none
1834 show_ip(struct Client
*source_p
, struct Client
*target_p
)
1836 if(IsAnyServer(target_p
))
1838 #ifndef HIDE_SERVERS_IPS
1839 if(source_p
== NULL
|| IsOper(source_p
))
1844 else if(IsIPSpoof(target_p
))
1846 /* source == NULL indicates message is being sent
1849 if(!ConfigFileEntry
.hide_spoof_ips
&&
1850 (source_p
== NULL
|| MyOper(source_p
)))
1854 else if(IsDynSpoof(target_p
) && (source_p
!= NULL
&& !IsOper(source_p
)))
1861 show_ip_conf(struct ConfItem
*aconf
, struct Client
*source_p
)
1863 if(IsConfDoSpoofIp(aconf
))
1865 if(!ConfigFileEntry
.hide_spoof_ips
&& MyOper(source_p
))
1880 * side effects - Creates a block heap for struct Users
1883 static BlockHeap
*user_heap
;
1887 user_heap
= BlockHeapCreate(sizeof(struct User
), USER_HEAP_SIZE
);
1895 * inputs - pointer to client struct
1896 * output - pointer to struct User
1897 * side effects - add's an User information block to a client
1898 * if it was not previously allocated.
1901 make_user(struct Client
*client_p
)
1905 user
= client_p
->user
;
1908 user
= (struct User
*) BlockHeapAlloc(user_heap
);
1910 client_p
->user
= user
;
1918 * inputs - pointer to client struct
1919 * output - pointer to server_t
1920 * side effects - add's an Server information block to a client
1921 * if it was not previously allocated.
1924 make_server(struct Client
*client_p
)
1926 server_t
*serv
= client_p
->serv
;
1930 serv
= (server_t
*) MyMalloc(sizeof(server_t
));
1931 client_p
->serv
= serv
;
1933 return client_p
->serv
;
1939 * inputs - pointer to user struct
1940 * - pointer to client struct
1942 * side effects - Decrease user reference count by one and release block,
1943 * if count reaches 0
1946 free_user(struct User
*user
, struct Client
*client_p
)
1948 if(--user
->refcnt
<= 0)
1951 MyFree((char *) user
->away
);
1955 if(user
->refcnt
< 0 || user
->invited
.head
|| user
->channel
.head
)
1957 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
1958 "* %#lx user (%s!%s@%s) %#lx %#lx %#lx %lu %d *",
1959 (unsigned long) client_p
,
1960 client_p
? client_p
->
1964 (unsigned long) user
,
1965 (unsigned long) user
->invited
.head
,
1966 (unsigned long) user
->channel
.head
,
1967 dlink_list_length(&user
->channel
),
1969 s_assert(!user
->refcnt
);
1970 s_assert(!user
->invited
.head
);
1971 s_assert(!user
->channel
.head
);
1974 BlockHeapFree(user_heap
, user
);
1983 for(i
= 0; i
< 3; i
++)
1984 current_uid
[i
] = me
.id
[i
];
1986 for(i
= 3; i
< 9; i
++)
1987 current_uid
[i
] = 'A';
1989 current_uid
[9] = '\0';
1998 for(i
= 8; i
> 3; i
--)
2000 if(current_uid
[i
] == 'Z')
2002 current_uid
[i
] = '0';
2005 else if(current_uid
[i
] != '9')
2011 current_uid
[i
] = 'A';
2014 /* if this next if() triggers, we're fucked. */
2015 if(current_uid
[3] == 'Z')
2017 current_uid
[i
] = 'A';
2028 * Close the physical connection. This function must make
2029 * MyConnect(client_p) == FALSE, and set client_p->from == NULL.
2032 close_connection(struct Client
*client_p
)
2034 s_assert(client_p
!= NULL
);
2035 if(client_p
== NULL
)
2038 s_assert(MyConnect(client_p
));
2039 if(!MyConnect(client_p
))
2042 if(IsServer(client_p
))
2044 struct server_conf
*server_p
;
2046 ServerStats
->is_sv
++;
2047 ServerStats
->is_sbs
+= client_p
->localClient
->sendB
;
2048 ServerStats
->is_sbr
+= client_p
->localClient
->receiveB
;
2049 ServerStats
->is_sks
+= client_p
->localClient
->sendK
;
2050 ServerStats
->is_skr
+= client_p
->localClient
->receiveK
;
2051 ServerStats
->is_sti
+= CurrentTime
- client_p
->localClient
->firsttime
;
2052 if(ServerStats
->is_sbs
> 2047)
2054 ServerStats
->is_sks
+= (ServerStats
->is_sbs
>> 10);
2055 ServerStats
->is_sbs
&= 0x3ff;
2057 if(ServerStats
->is_sbr
> 2047)
2059 ServerStats
->is_skr
+= (ServerStats
->is_sbr
>> 10);
2060 ServerStats
->is_sbr
&= 0x3ff;
2064 * If the connection has been up for a long amount of time, schedule
2065 * a 'quick' reconnect, else reset the next-connect cycle.
2067 if((server_p
= find_server_conf(client_p
->name
)) != NULL
)
2070 * Reschedule a faster reconnect, if this was a automatically
2071 * connected configuration entry. (Note that if we have had
2072 * a rehash in between, the status has been changed to
2073 * CONF_ILLEGAL). But only do this if it was a "good" link.
2075 server_p
->hold
= time(NULL
);
2077 (server_p
->hold
- client_p
->localClient
->lasttime
>
2078 HANGONGOODLINK
) ? HANGONRETRYDELAY
: ConFreq(server_p
->class);
2082 else if(IsClient(client_p
))
2084 ServerStats
->is_cl
++;
2085 ServerStats
->is_cbs
+= client_p
->localClient
->sendB
;
2086 ServerStats
->is_cbr
+= client_p
->localClient
->receiveB
;
2087 ServerStats
->is_cks
+= client_p
->localClient
->sendK
;
2088 ServerStats
->is_ckr
+= client_p
->localClient
->receiveK
;
2089 ServerStats
->is_cti
+= CurrentTime
- client_p
->localClient
->firsttime
;
2090 if(ServerStats
->is_cbs
> 2047)
2092 ServerStats
->is_cks
+= (ServerStats
->is_cbs
>> 10);
2093 ServerStats
->is_cbs
&= 0x3ff;
2095 if(ServerStats
->is_cbr
> 2047)
2097 ServerStats
->is_ckr
+= (ServerStats
->is_cbr
>> 10);
2098 ServerStats
->is_cbr
&= 0x3ff;
2102 ServerStats
->is_ni
++;
2104 if(-1 < client_p
->localClient
->fd
)
2106 /* attempt to flush any pending dbufs. Evil, but .. -- adrian */
2107 if(!IsIOError(client_p
))
2108 send_queued_write(client_p
->localClient
->fd
, client_p
);
2110 comm_close(client_p
->localClient
->fd
);
2111 client_p
->localClient
->fd
= -1;
2114 if(-1 < client_p
->localClient
->ctrlfd
)
2116 comm_close(client_p
->localClient
->ctrlfd
);
2117 client_p
->localClient
->ctrlfd
= -1;
2120 linebuf_donebuf(&client_p
->localClient
->buf_sendq
);
2121 linebuf_donebuf(&client_p
->localClient
->buf_recvq
);
2122 detach_conf(client_p
);
2124 /* XXX shouldnt really be done here. */
2125 detach_server_conf(client_p
);
2127 client_p
->from
= NULL
; /* ...this should catch them! >:) --msa */
2128 ClearMyConnect(client_p
);
2129 SetIOError(client_p
);
2135 error_exit_client(struct Client
*client_p
, int error
)
2138 * ...hmm, with non-blocking sockets we might get
2139 * here from quite valid reasons, although.. why
2140 * would select report "data available" when there
2141 * wasn't... so, this must be an error anyway... --msa
2142 * actually, EOF occurs when read() returns 0 and
2143 * in due course, select() returns that fd as ready
2144 * for reading even though it ends up being an EOF. -avalon
2147 int current_error
= comm_get_sockerr(client_p
->localClient
->fd
);
2149 SetIOError(client_p
);
2151 if(IsServer(client_p
) || IsHandshake(client_p
))
2155 sendto_realops_snomask(SNO_GENERAL
, is_remote_connect(client_p
) && !IsServer(client_p
) ? L_NETWIDE
: L_ALL
,
2156 "Server %s closed the connection",
2157 get_server_name(client_p
, SHOW_IP
));
2159 ilog(L_SERVER
, "Server %s closed the connection",
2160 log_client_name(client_p
, SHOW_IP
));
2164 sendto_realops_snomask(SNO_GENERAL
, is_remote_connect(client_p
) && !IsServer(client_p
) ? L_NETWIDE
: L_ALL
,
2165 "Lost connection to %s: %s",
2166 client_p
->name
, strerror(current_error
));
2167 ilog(L_SERVER
, "Lost connection to %s: %s",
2168 log_client_name(client_p
, SHOW_IP
), strerror(current_error
));
2173 strlcpy(errmsg
, "Remote host closed the connection", sizeof(errmsg
));
2175 ircsnprintf(errmsg
, sizeof(errmsg
), "Read error: %s", strerror(current_error
));
2177 exit_client(client_p
, client_p
, &me
, errmsg
);