/[svn]/ircd-hybrid/src/client.c
ViewVC logotype

Annotation of /ircd-hybrid/src/client.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 385 - (hide annotations)
Tue Jan 31 12:24:23 2006 UTC (14 years, 8 months ago) by michael
File MIME type: text/x-chdr
File size: 49862 byte(s)
- Forward-port SoftCallerId fix from 7.2

1 adx 30 /*
2     * ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3     * client.c: Controls clients.
4     *
5     * Copyright (C) 2002 by the past and present ircd coders, and others.
6     *
7     * This program is free software; you can redistribute it and/or modify
8     * it under the terms of the GNU General Public License as published by
9     * the Free Software Foundation; either version 2 of the License, or
10     * (at your option) any later version.
11     *
12     * This program is distributed in the hope that it will be useful,
13     * but WITHOUT ANY WARRANTY; without even the implied warranty of
14     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15     * GNU General Public License for more details.
16     *
17     * You should have received a copy of the GNU General Public License
18     * along with this program; if not, write to the Free Software
19     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20     * USA
21     *
22 knight 31 * $Id$
23 adx 30 */
24    
25     #include "stdinc.h"
26     #include "client.h"
27     #include "channel_mode.h"
28     #include "common.h"
29     #include "hash.h"
30     #include "ircd.h"
31     #include "s_gline.h"
32     #include "numeric.h"
33     #include "packet.h"
34     #include "s_auth.h"
35     #include "s_conf.h"
36 db 101 #include "parse_aline.h"
37 adx 30 #include "s_serv.h"
38     #include "send.h"
39     #include "whowas.h"
40     #include "s_user.h"
41     #include "hostmask.h"
42     #include "listener.h"
43     #include "userhost.h"
44 adx 68 #include "s_stats.h"
45 michael 221 #include "watch.h"
46 adx 30
47     dlink_list listing_client_list = { NULL, NULL, 0 };
48     /* Pointer to beginning of Client list */
49     dlink_list global_client_list = {NULL, NULL, 0};
50     /* unknown/client pointer lists */
51     dlink_list unknown_list = {NULL, NULL, 0};
52     dlink_list local_client_list = {NULL, NULL, 0};
53     dlink_list serv_list = {NULL, NULL, 0};
54     dlink_list global_serv_list = {NULL, NULL, 0};
55     dlink_list oper_list = {NULL, NULL, 0};
56    
57     static EVH check_pings;
58    
59     static BlockHeap *client_heap = NULL;
60     static BlockHeap *lclient_heap = NULL;
61    
62     static dlink_list dead_list = { NULL, NULL, 0};
63     static dlink_list abort_list = { NULL, NULL, 0};
64    
65     static dlink_node *eac_next; /* next aborted client to exit */
66    
67     static void check_pings_list(dlink_list *);
68     static void check_unknowns_list(void);
69 adx 68 static void close_connection(struct Client *);
70 adx 30 static void ban_them(struct Client *client_p, struct ConfItem *conf);
71 db 232 static void del_all_accepts(struct Client *);
72 adx 30
73     /* init_client()
74     *
75     * inputs - NONE
76     * output - NONE
77     * side effects - initialize client free memory
78     */
79     void
80     init_client(void)
81     {
82     /* start off the check ping event .. -- adrian
83     * Every 30 seconds is plenty -- db
84     */
85     client_heap = BlockHeapCreate("client", sizeof(struct Client), CLIENT_HEAP_SIZE);
86     lclient_heap = BlockHeapCreate("local client", sizeof(struct LocalUser), LCLIENT_HEAP_SIZE);
87     eventAdd("check_pings", check_pings, NULL, 5);
88     }
89    
90     /*
91     * make_client - create a new Client struct and set it to initial state.
92     *
93     * from == NULL, create local client (a client connected
94     * to a socket).
95     * WARNING: This leaves the client in a dangerous
96     * state where fd == -1, dead flag is not set and
97     * the client is on the unknown_list; therefore,
98     * the first thing to do after calling make_client(NULL)
99     * is setting fd to something reasonable. -adx
100     *
101     * from, create remote client (behind a socket
102     * associated with the client defined by
103     * 'from'). ('from' is a local client!!).
104     */
105     struct Client *
106     make_client(struct Client *from)
107     {
108     struct Client *client_p = BlockHeapAlloc(client_heap);
109    
110     if (from == NULL)
111     {
112     client_p->from = client_p; /* 'from' of local client is self! */
113     client_p->since = client_p->lasttime = client_p->firsttime = CurrentTime;
114    
115     client_p->localClient = BlockHeapAlloc(lclient_heap);
116     /* as good a place as any... */
117     dlinkAdd(client_p, make_dlink_node(), &unknown_list);
118     }
119     else
120 michael 316 client_p->from = from;
121 adx 30
122     client_p->hnext = client_p;
123     client_p->status = STAT_UNKNOWN;
124     strcpy(client_p->username, "unknown");
125    
126     return client_p;
127     }
128    
129     /*
130     * free_client
131     *
132     * inputs - pointer to client
133     * output - NONE
134     * side effects - client pointed to has its memory freed
135     */
136     static void
137     free_client(struct Client *client_p)
138     {
139     assert(client_p != NULL);
140     assert(client_p != &me);
141     assert(client_p->hnext == client_p);
142     assert(client_p->channel.head == NULL);
143     assert(dlink_list_length(&client_p->channel) == 0);
144    
145     MyFree(client_p->away);
146     MyFree(client_p->serv);
147    
148     if (MyConnect(client_p))
149     {
150 michael 315 assert(dlink_list_length(&client_p->localClient->invited) == 0);
151     assert(client_p->localClient->invited.head == NULL);
152 adx 30 assert(IsClosing(client_p) && IsDead(client_p));
153    
154     MyFree(client_p->localClient->response);
155     MyFree(client_p->localClient->auth_oper);
156    
157     /*
158     * clean up extra sockets from P-lines which have been discarded.
159     */
160     if (client_p->localClient->listener)
161     {
162     assert(0 < client_p->localClient->listener->ref_count);
163     if (0 == --client_p->localClient->listener->ref_count &&
164     !client_p->localClient->listener->active)
165     free_listener(client_p->localClient->listener);
166     }
167    
168     dbuf_clear(&client_p->localClient->buf_recvq);
169     dbuf_clear(&client_p->localClient->buf_sendq);
170    
171     BlockHeapFree(lclient_heap, client_p->localClient);
172     }
173    
174     BlockHeapFree(client_heap, client_p);
175     }
176    
177     /*
178     * check_pings - go through the local client list and check activity
179     * kill off stuff that should die
180     *
181     * inputs - NOT USED (from event)
182     * output - next time_t when check_pings() should be called again
183     * side effects -
184     *
185     *
186     * A PING can be sent to clients as necessary.
187     *
188     * Client/Server ping outs are handled.
189     */
190    
191     /*
192     * Addon from adrian. We used to call this after nextping seconds,
193     * however I've changed it to run once a second. This is only for
194     * PING timeouts, not K/etc-line checks (thanks dianora!). Having it
195     * run once a second makes life a lot easier - when a new client connects
196     * and they need a ping in 4 seconds, if nextping was set to 20 seconds
197     * we end up waiting 20 seconds. This is stupid. :-)
198     * I will optimise (hah!) check_pings() once I've finished working on
199     * tidying up other network IO evilnesses.
200     * -- adrian
201     */
202    
203     static void
204     check_pings(void *notused)
205     {
206     check_pings_list(&local_client_list);
207     check_pings_list(&serv_list);
208     check_unknowns_list();
209     }
210    
211     /* check_pings_list()
212     *
213     * inputs - pointer to list to check
214     * output - NONE
215     * side effects -
216     */
217     static void
218     check_pings_list(dlink_list *list)
219     {
220     char scratch[32]; /* way too generous but... */
221     struct Client *client_p; /* current local client_p being examined */
222     int ping, pingwarn; /* ping time value from client */
223     dlink_node *ptr, *next_ptr;
224    
225     DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
226     {
227     client_p = ptr->data;
228    
229     /*
230     ** Note: No need to notify opers here. It's
231     ** already done when "FLAGS_DEADSOCKET" is set.
232     */
233     if (IsDead(client_p))
234     {
235     /* Ignore it, its been exited already */
236     continue;
237     }
238    
239     if (client_p->localClient->reject_delay > 0)
240     {
241     if (client_p->localClient->reject_delay <= CurrentTime)
242     exit_client(client_p, &me, "Rejected");
243     continue;
244     }
245    
246     if (GlobalSetOptions.idletime && IsClient(client_p))
247     {
248     if (!IsExemptKline(client_p) && !IsOper(client_p) &&
249     !IsIdlelined(client_p) &&
250     ((CurrentTime - client_p->localClient->last) > GlobalSetOptions.idletime))
251     {
252     struct ConfItem *conf;
253     struct AccessItem *aconf;
254    
255     conf = make_conf_item(KLINE_TYPE);
256 db 139 aconf = &conf->conf.AccessItem;
257 adx 30
258     DupString(aconf->host, client_p->host);
259     DupString(aconf->reason, "idle exceeder");
260     DupString(aconf->user, client_p->username);
261     aconf->hold = CurrentTime + 60;
262     add_temp_line(conf);
263    
264     sendto_realops_flags(UMODE_ALL, L_ALL,
265     "Idle time limit exceeded for %s - temp k-lining",
266     get_client_name(client_p, HIDE_IP));
267     exit_client(client_p, &me, aconf->reason);
268     continue;
269     }
270     }
271    
272     if (!IsRegistered(client_p))
273     ping = CONNECTTIMEOUT, pingwarn = 0;
274     else
275     ping = get_client_ping(client_p, &pingwarn);
276    
277     if (ping < CurrentTime - client_p->lasttime)
278     {
279     if (!IsPingSent(client_p))
280     {
281     /*
282     * if we havent PINGed the connection and we havent
283     * heard from it in a while, PING it to make sure
284     * it is still alive.
285     */
286     SetPingSent(client_p);
287     ClearPingWarning(client_p);
288     client_p->lasttime = CurrentTime - ping;
289     sendto_one(client_p, "PING :%s", ID_or_name(&me, client_p));
290     }
291     else
292     {
293     if (CurrentTime - client_p->lasttime >= 2 * ping)
294     {
295     /*
296     * If the client/server hasn't talked to us in 2*ping seconds
297     * and it has a ping time, then close its connection.
298     */
299     if (IsServer(client_p) || IsHandshake(client_p))
300     {
301     sendto_realops_flags(UMODE_ALL, L_ADMIN,
302     "No response from %s, closing link",
303     get_client_name(client_p, HIDE_IP));
304     sendto_realops_flags(UMODE_ALL, L_OPER,
305     "No response from %s, closing link",
306     get_client_name(client_p, MASK_IP));
307     ilog(L_NOTICE, "No response from %s, closing link",
308     get_client_name(client_p, HIDE_IP));
309     }
310     ircsprintf(scratch, "Ping timeout: %d seconds",
311     (int)(CurrentTime - client_p->lasttime));
312    
313     exit_client(client_p, &me, scratch);
314     }
315     else if (!IsPingWarning(client_p) && pingwarn > 0 &&
316     (IsServer(client_p) || IsHandshake(client_p)) &&
317     CurrentTime - client_p->lasttime >= ping + pingwarn)
318     {
319     /*
320     * If the server hasn't replied in pingwarn seconds after sending
321     * the PING, notify the opers so that they are aware of the problem.
322     */
323     SetPingWarning(client_p);
324     sendto_realops_flags(UMODE_ALL, L_ADMIN,
325     "Warning, no response from %s in %d seconds",
326     get_client_name(client_p, HIDE_IP), pingwarn);
327     sendto_realops_flags(UMODE_ALL, L_OPER,
328     "Warning, no response from %s in %d seconds",
329     get_client_name(client_p, MASK_IP), pingwarn);
330     ilog(L_NOTICE, "No response from %s in %d seconds",
331     get_client_name(client_p, HIDE_IP), pingwarn);
332     }
333     }
334     }
335     }
336     }
337    
338     /* check_unknowns_list()
339     *
340     * inputs - pointer to list of unknown clients
341     * output - NONE
342     * side effects - unknown clients get marked for termination after n seconds
343     */
344     static void
345     check_unknowns_list(void)
346     {
347     dlink_node *ptr, *next_ptr;
348    
349     DLINK_FOREACH_SAFE(ptr, next_ptr, unknown_list.head)
350     {
351     struct Client *client_p = ptr->data;
352    
353     if (client_p->localClient->reject_delay > 0)
354     {
355     if (client_p->localClient->reject_delay <= CurrentTime)
356 adx 224 exit_client(client_p, &me, "Rejected");
357 adx 30 continue;
358     }
359    
360     /* Check UNKNOWN connections - if they have been in this state
361     * for > 30s, close them.
362     */
363     if (client_p->firsttime ? ((CurrentTime - client_p->firsttime) > 30) : 0)
364     exit_client(client_p, &me, "Connection timed out");
365     }
366     }
367    
368     /* check_conf_klines()
369     *
370     * inputs - NONE
371     * output - NONE
372     * side effects - Check all connections for a pending kline against the
373     * client, exit the client if a kline matches.
374     */
375     void
376     check_conf_klines(void)
377     {
378     struct Client *client_p = NULL; /* current local client_p being examined */
379     struct AccessItem *aconf = NULL;
380     struct ConfItem *conf = NULL;
381     dlink_node *ptr, *next_ptr;
382    
383     DLINK_FOREACH_SAFE(ptr, next_ptr, local_client_list.head)
384     {
385     client_p = ptr->data;
386    
387     /* If a client is already being exited
388     */
389     if (IsDead(client_p) || !IsClient(client_p))
390     continue;
391    
392     /* if there is a returned struct ConfItem then kill it */
393     if ((aconf = find_dline_conf(&client_p->localClient->ip,
394     client_p->localClient->aftype)) != NULL)
395     {
396     if (aconf->status & CONF_EXEMPTDLINE)
397 adx 224 continue;
398 adx 30
399 db 141 conf = aconf->conf_ptr;
400 adx 30 ban_them(client_p, conf);
401     continue; /* and go examine next fd/client_p */
402     }
403    
404 adx 224 if (ConfigFileEntry.glines && (aconf = find_gline(client_p)) != NULL)
405 adx 30 {
406 adx 224 if (IsExemptKline(client_p) || IsExemptGline(client_p))
407 adx 30 {
408     sendto_realops_flags(UMODE_ALL, L_ALL,
409 adx 224 "GLINE over-ruled for %s, client is %cline_exempt",
410     get_client_name(client_p, HIDE_IP),
411     IsExemptKline(client_p) ? 'k' : 'g');
412 adx 30 continue;
413     }
414    
415 db 141 conf = aconf->conf_ptr;
416 adx 30 ban_them(client_p, conf);
417     /* and go examine next fd/client_p */
418     continue;
419     }
420    
421     if ((aconf = find_kill(client_p)) != NULL)
422     {
423    
424     /* if there is a returned struct AccessItem.. then kill it */
425     if (IsExemptKline(client_p))
426     {
427     sendto_realops_flags(UMODE_ALL, L_ALL,
428     "KLINE over-ruled for %s, client is kline_exempt",
429     get_client_name(client_p, HIDE_IP));
430     continue;
431     }
432    
433 db 141 conf = aconf->conf_ptr;
434 adx 30 ban_them(client_p, conf);
435     continue;
436     }
437    
438     /* if there is a returned struct MatchItem then kill it */
439     if ((conf = find_matching_name_conf(XLINE_TYPE, client_p->info,
440     NULL, NULL, 0)) != NULL ||
441     (conf = find_matching_name_conf(RXLINE_TYPE, client_p->info,
442     NULL, NULL, 0)) != NULL)
443     {
444     ban_them(client_p, conf);
445     continue;
446     }
447     }
448    
449     /* also check the unknowns list for new dlines */
450     DLINK_FOREACH_SAFE(ptr, next_ptr, unknown_list.head)
451     {
452     client_p = ptr->data;
453    
454     if ((aconf = find_dline_conf(&client_p->localClient->ip,
455     client_p->localClient->aftype)))
456     {
457     if (aconf->status & CONF_EXEMPTDLINE)
458     continue;
459    
460     exit_client(client_p, &me, "D-lined");
461     }
462     }
463     }
464    
465     /*
466     * ban_them
467     *
468     * inputs - pointer to client to ban
469     * - pointer to ConfItem
470     * output - NONE
471     * side effects - given client_p is banned
472     */
473     static void
474     ban_them(struct Client *client_p, struct ConfItem *conf)
475     {
476     const char *user_reason = NULL; /* What is sent to user */
477     const char *channel_reason = NULL; /* What is sent to channel */
478     struct AccessItem *aconf = NULL;
479     struct MatchItem *xconf = NULL;
480     const char *type_string = NULL;
481     const char dline_string[] = "D-line";
482     const char kline_string[] = "K-line";
483     const char gline_string[] = "G-line";
484     const char xline_string[] = "X-line";
485    
486     switch (conf->type)
487     {
488     case RKLINE_TYPE:
489     case KLINE_TYPE:
490     type_string = kline_string;
491 db 139 aconf = &conf->conf.AccessItem;
492 adx 30 break;
493     case DLINE_TYPE:
494     type_string = dline_string;
495 db 139 aconf = &conf->conf.AccessItem;
496 adx 30 break;
497     case GLINE_TYPE:
498     type_string = gline_string;
499 db 139 aconf = &conf->conf.AccessItem;
500 adx 30 break;
501     case RXLINE_TYPE:
502     case XLINE_TYPE:
503     type_string = xline_string;
504 db 139 xconf = &conf->conf.MatchItem;
505 adx 30 ++xconf->count;
506     break;
507     default:
508     assert(0);
509     break;
510     }
511    
512     if (ConfigFileEntry.kline_with_reason)
513     {
514     if (aconf != NULL)
515     user_reason = aconf->reason ? aconf->reason : type_string;
516     if (xconf != NULL)
517     user_reason = xconf->reason ? xconf->reason : type_string;
518     }
519     else
520     user_reason = type_string;
521    
522     if (ConfigFileEntry.kline_reason != NULL)
523     channel_reason = ConfigFileEntry.kline_reason;
524     else
525     channel_reason = user_reason;
526    
527     sendto_realops_flags(UMODE_ALL, L_ALL, "%s active for %s",
528     type_string, get_client_name(client_p, HIDE_IP));
529    
530     if (IsClient(client_p))
531     sendto_one(client_p, form_str(ERR_YOUREBANNEDCREEP),
532     me.name, client_p->name, user_reason);
533    
534     exit_client(client_p, &me, channel_reason);
535     }
536    
537     /* update_client_exit_stats()
538     *
539     * input - pointer to client
540     * output - NONE
541     * side effects -
542     */
543     static void
544     update_client_exit_stats(struct Client *client_p)
545     {
546     if (IsServer(client_p))
547     {
548     sendto_realops_flags(UMODE_EXTERNAL, L_ALL,
549     "Server %s split from %s",
550     client_p->name, client_p->servptr->name);
551     }
552     else if (IsClient(client_p))
553     {
554     --Count.total;
555     if (IsOper(client_p))
556     --Count.oper;
557     if (IsInvisible(client_p))
558     --Count.invisi;
559     }
560    
561     if (splitchecking && !splitmode)
562     check_splitmode(NULL);
563     }
564    
565     /* find_person()
566     *
567     * inputs - pointer to name
568     * output - return client pointer
569     * side effects - find person by (nick)name
570     */
571     /* XXX - ugly wrapper */
572     struct Client *
573     find_person(const struct Client *client_p, const char *name)
574     {
575     struct Client *c2ptr;
576    
577     if (IsDigit(*name))
578     {
579     if ((c2ptr = hash_find_id(name)) != NULL)
580     {
581     /* invisible users shall not be found by UID guessing */
582     if (IsInvisible(c2ptr) && !IsServer(client_p))
583     c2ptr = NULL;
584     }
585     }
586     else
587     c2ptr = find_client(name);
588    
589     return ((c2ptr != NULL && IsClient(c2ptr)) ? c2ptr : NULL);
590     }
591    
592     /*
593     * find_chasing - find the client structure for a nick name (user)
594     * using history mechanism if necessary. If the client is not found,
595     * an error message (NO SUCH NICK) is generated. If the client was found
596     * through the history, chasing will be 1 and otherwise 0.
597     */
598     struct Client *
599     find_chasing(struct Client *client_p, struct Client *source_p, const char *user, int *chasing)
600     {
601     struct Client *who = find_person(client_p, user);
602    
603     if (chasing)
604     *chasing = 0;
605    
606     if (who)
607     return(who);
608    
609     if (IsDigit(*user))
610     return(NULL);
611    
612     if ((who = get_history(user,
613     (time_t)ConfigFileEntry.kill_chase_time_limit))
614     == NULL)
615     {
616     sendto_one(source_p, form_str(ERR_NOSUCHNICK),
617     me.name, source_p->name, user);
618     return(NULL);
619     }
620    
621     if (chasing)
622     *chasing = 1;
623    
624     return(who);
625     }
626    
627     /*
628     * get_client_name - Return the name of the client
629     * for various tracking and
630     * admin purposes. The main purpose of this function is to
631     * return the "socket host" name of the client, if that
632     * differs from the advertised name (other than case).
633     * But, this can be used to any client structure.
634     *
635     * NOTE 1:
636     * Watch out the allocation of "nbuf", if either source_p->name
637     * or source_p->sockhost gets changed into pointers instead of
638     * directly allocated within the structure...
639     *
640     * NOTE 2:
641     * Function return either a pointer to the structure (source_p) or
642     * to internal buffer (nbuf). *NEVER* use the returned pointer
643     * to modify what it points!!!
644     */
645     const char *
646     get_client_name(struct Client *client, int showip)
647     {
648     static char nbuf[HOSTLEN * 2 + USERLEN + 5];
649    
650     assert(client != NULL);
651    
652     if (irccmp(client->name, client->host) == 0)
653     return(client->name);
654    
655     if (ConfigServerHide.hide_server_ips)
656     if (IsServer(client) || IsConnecting(client) || IsHandshake(client))
657     showip = MASK_IP;
658    
659     if (ConfigFileEntry.hide_spoof_ips)
660     if (showip == SHOW_IP && IsIPSpoof(client))
661     showip = MASK_IP;
662    
663     /* And finally, let's get the host information, ip or name */
664     switch (showip)
665     {
666     case SHOW_IP:
667     if (MyConnect(client))
668     {
669     ircsprintf(nbuf, "%s[%s@%s]", client->name, client->username,
670     client->sockhost);
671     break;
672     }
673     case MASK_IP:
674     ircsprintf(nbuf, "%s[%s@255.255.255.255]", client->name,
675     client->username);
676     break;
677     default:
678     ircsprintf(nbuf, "%s[%s@%s]", client->name, client->username,
679     client->host);
680     }
681    
682     return(nbuf);
683     }
684    
685     void
686     free_exited_clients(void)
687     {
688     dlink_node *ptr, *next;
689     struct Client *target_p;
690    
691     DLINK_FOREACH_SAFE(ptr, next, dead_list.head)
692     {
693     target_p = ptr->data;
694    
695     if (ptr->data == NULL)
696     {
697     sendto_realops_flags(UMODE_ALL, L_ALL,
698     "Warning: null client on dead_list!");
699     dlinkDelete(ptr, &dead_list);
700     free_dlink_node(ptr);
701     continue;
702     }
703    
704     free_client(target_p);
705     dlinkDelete(ptr, &dead_list);
706     free_dlink_node(ptr);
707     }
708     }
709    
710     /*
711     * Exit one client, local or remote. Assuming all dependents have
712     * been already removed, and socket closed for local client.
713     *
714     * The only messages generated are QUITs on channels.
715     */
716     static void
717     exit_one_client(struct Client *source_p, const char *quitmsg)
718     {
719     dlink_node *lp = NULL, *next_lp = NULL;
720    
721     assert(!IsMe(source_p));
722    
723     if (IsServer(source_p))
724     {
725     dlinkDelete(&source_p->lnode, &source_p->servptr->serv->servers);
726    
727     if ((lp = dlinkFindDelete(&global_serv_list, source_p)) != NULL)
728     free_dlink_node(lp);
729    
730     if (!MyConnect(source_p))
731     {
732     source_p->from->serv->dep_servers--;
733     assert(source_p->from->serv->dep_servers > 0);
734     }
735     }
736     else if (IsClient(source_p))
737     {
738     if (source_p->servptr->serv != NULL)
739     dlinkDelete(&source_p->lnode, &source_p->servptr->serv->users);
740    
741 michael 315 /*
742     * If a person is on a channel, send a QUIT notice
743     * to every client (person) on the same channel (so
744     * that the client can show the "**signoff" message).
745     * (Note: The notice is to the local clients *only*)
746     */
747 adx 30 sendto_common_channels_local(source_p, 0, ":%s!%s@%s QUIT :%s",
748     source_p->name, source_p->username,
749     source_p->host, quitmsg);
750     DLINK_FOREACH_SAFE(lp, next_lp, source_p->channel.head)
751     remove_user_from_channel(lp->data);
752    
753     add_history(source_p, 0);
754     off_history(source_p);
755    
756 michael 193 assert(source_p->whowas.head == NULL);
757     assert(source_p->whowas.tail == NULL);
758    
759 db 238 /* Do local vs. remote processing here */
760     if (MyConnect(source_p))
761 adx 30 {
762 michael 315 /* Clean up invitefield */
763 michael 316 DLINK_FOREACH_SAFE(lp, next_lp, source_p->localClient->invited.head)
764 michael 315 del_invite(lp->data, source_p);
765    
766 db 238 /* Clean up allow lists */
767     del_all_accepts(source_p);
768     }
769     else
770     {
771 adx 30 source_p->from->serv->dep_users--;
772     assert(source_p->from->serv->dep_users >= 0);
773     }
774     }
775    
776     /* Remove source_p from the client lists */
777     if (HasID(source_p))
778     hash_del_id(source_p);
779     if (source_p->name[0])
780     hash_del_client(source_p);
781    
782 michael 221 hash_check_watch(source_p, RPL_LOGOFF);
783    
784 adx 30 if (IsUserHostIp(source_p))
785     delete_user_host(source_p->username, source_p->host, !MyConnect(source_p));
786    
787     /* remove from global client list
788     * NOTE: source_p->node.next cannot be NULL if the client is added
789     * to global_client_list (there is always &me at its end)
790     */
791     if (source_p != NULL && source_p->node.next != NULL)
792     dlinkDelete(&source_p->node, &global_client_list);
793    
794     update_client_exit_stats(source_p);
795    
796     /* Check to see if the client isn't already on the dead list */
797     assert(dlinkFind(&dead_list, source_p) == NULL);
798    
799     /* add to dead client dlist */
800     SetDead(source_p);
801     dlinkAdd(source_p, make_dlink_node(), &dead_list);
802     }
803    
804     /* Recursively send QUITs and SQUITs for source_p and all its dependent clients
805     * and servers to those servers that need them. A server needs the client
806     * QUITs if it can't figure them out from the SQUIT (ie pre-TS4) or if it
807     * isn't getting the SQUIT because of @#(*&@)# hostmasking. With TS4, once
808     * a link gets a SQUIT, it doesn't need any QUIT/SQUITs for clients depending
809     * on that one -orabidoo
810     *
811     * This is now called on each local server -adx
812     */
813     static void
814     recurse_send_quits(struct Client *original_source_p, struct Client *source_p,
815     struct Client *from, struct Client *to, const char *comment,
816     const char *splitstr, const char *myname)
817     {
818     dlink_node *ptr, *next;
819     struct Client *target_p;
820     int hidden = match(myname, source_p->name);
821    
822     assert(to != source_p); /* should be already removed from serv_list */
823    
824     /* If this server can handle quit storm (QS) removal
825     * of dependents, just send the SQUIT
826     *
827     * Always check *all* dependent servers if some of them are
828     * hidden behind fakename. If so, send out the QUITs -adx
829     */
830     if (hidden || !IsCapable(to, CAP_QS))
831     DLINK_FOREACH_SAFE(ptr, next, source_p->serv->users.head)
832     {
833     target_p = ptr->data;
834     sendto_one(to, ":%s QUIT :%s", target_p->name, splitstr);
835     }
836    
837     DLINK_FOREACH_SAFE(ptr, next, source_p->serv->servers.head)
838     recurse_send_quits(original_source_p, ptr->data, from, to,
839     comment, splitstr, myname);
840    
841     if (!hidden && ((source_p == original_source_p && to != from) ||
842     !IsCapable(to, CAP_QS)))
843     {
844     /* don't use a prefix here - we have to be 100% sure the message
845     * will be accepted without Unknown prefix etc.. */
846     sendto_one(to, "SQUIT %s :%s", ID_or_name(source_p, to), comment);
847     }
848     }
849    
850     /*
851     * Remove all clients that depend on source_p; assumes all (S)QUITs have
852     * already been sent. we make sure to exit a server's dependent clients
853     * and servers before the server itself; exit_one_client takes care of
854     * actually removing things off llists. tweaked from +CSr31 -orabidoo
855     */
856     static void
857     recurse_remove_clients(struct Client *source_p, const char *quitmsg)
858     {
859     dlink_node *ptr, *next;
860    
861     DLINK_FOREACH_SAFE(ptr, next, source_p->serv->users.head)
862     exit_one_client(ptr->data, quitmsg);
863    
864     DLINK_FOREACH_SAFE(ptr, next, source_p->serv->servers.head)
865     {
866     recurse_remove_clients(ptr->data, quitmsg);
867     exit_one_client(ptr->data, quitmsg);
868     }
869    
870     assert(source_p->serv->dep_servers == 1);
871     assert(source_p->serv->dep_users == 0);
872     }
873    
874     /*
875     ** Remove *everything* that depends on source_p, from all lists, and sending
876     ** all necessary QUITs and SQUITs. source_p itself is still on the lists,
877     ** and its SQUITs have been sent except for the upstream one -orabidoo
878     */
879     static void
880     remove_dependents(struct Client *source_p, struct Client *from,
881     const char *comment, const char *splitstr)
882     {
883     struct Client *to;
884     struct ConfItem *conf;
885 db 126 struct AccessItem *aconf;
886 adx 30 static char myname[HOSTLEN+1];
887     dlink_node *ptr;
888    
889     DLINK_FOREACH(ptr, serv_list.head)
890     {
891     to = ptr->data;
892    
893     if ((conf = to->serv->sconf) != NULL)
894 db 126 {
895 db 139 aconf = &conf->conf.AccessItem;
896 db 126 strlcpy(myname, my_name_for_link(aconf), sizeof(myname));
897     }
898 adx 30 else
899     strlcpy(myname, me.name, sizeof(myname));
900     recurse_send_quits(source_p, source_p, from, to,
901     comment, splitstr, myname);
902     }
903    
904     recurse_remove_clients(source_p, splitstr);
905     }
906    
907     /*
908     * exit_client - exit a client of any type. Generally, you can use
909     * this on any struct Client, regardless of its state.
910     *
911     * Note, you shouldn't exit remote _users_ without first doing
912     * SetKilled and propagating a kill or similar message. However,
913     * it is perfectly correct to call exit_client to force a _server_
914     * quit (either local or remote one).
915     *
916     * inputs: - a client pointer that is going to be exited
917     * - for servers, the second argument is a pointer to who
918     * is firing the server. This side won't get any generated
919     * messages. NEVER NULL!
920     * output: none
921     * side effects: the client is delinked from all lists, disconnected,
922     * and the rest of IRC network is notified of the exit.
923     * Client memory is scheduled to be freed
924     */
925     void
926     exit_client(struct Client *source_p, struct Client *from, const char *comment)
927     {
928     dlink_node *m;
929    
930     if (MyConnect(source_p))
931     {
932     /* DO NOT REMOVE. exit_client can be called twice after a failed
933     * read/write.
934     */
935     if (IsClosing(source_p))
936     return;
937    
938     SetClosing(source_p);
939    
940     if (IsIpHash(source_p))
941     remove_one_ip(&source_p->localClient->ip);
942    
943     delete_auth(source_p);
944    
945     /* This source_p could have status of one of STAT_UNKNOWN, STAT_CONNECTING
946     * STAT_HANDSHAKE or STAT_UNKNOWN
947     * all of which are lumped together into unknown_list
948     *
949     * In all above cases IsRegistered() will not be true.
950     */
951     if (!IsRegistered(source_p))
952     {
953     if ((m = dlinkFindDelete(&unknown_list, source_p)) != NULL)
954     free_dlink_node(m);
955     }
956     else if (IsClient(source_p))
957     {
958     Count.local--;
959    
960     if (IsOper(source_p))
961     {
962     if ((m = dlinkFindDelete(&oper_list, source_p)) != NULL)
963     free_dlink_node(m);
964     }
965    
966     dlinkDelete(&source_p->localClient->lclient_node, &local_client_list);
967     if (source_p->localClient->list_task != NULL)
968     free_list_task(source_p->localClient->list_task, source_p);
969 michael 221 hash_del_watch_list(source_p);
970 adx 30 sendto_realops_flags(UMODE_CCONN, L_ALL, "Client exiting: %s (%s@%s) [%s] [%s]",
971     source_p->name, source_p->username, source_p->host, comment,
972     ConfigFileEntry.hide_spoof_ips && IsIPSpoof(source_p) ?
973     "255.255.255.255" : source_p->sockhost);
974     }
975    
976     /* As soon as a client is known to be a server of some sort
977     * it has to be put on the serv_list, or SJOIN's to this new server
978     * from the connect burst will not be seen.
979     */
980     if (IsServer(source_p) || IsConnecting(source_p) ||
981     IsHandshake(source_p))
982     {
983     if ((m = dlinkFindDelete(&serv_list, source_p)) != NULL)
984     {
985     free_dlink_node(m);
986     unset_chcap_usage_counts(source_p);
987     }
988    
989     if (IsServer(source_p))
990     {
991     Count.myserver--;
992     if (ServerInfo.hub)
993     remove_lazylink_flags(source_p->localClient->serverMask);
994     else
995     uplink = NULL;
996     }
997     }
998    
999     log_user_exit(source_p);
1000    
1001     if (!IsDead(source_p))
1002     {
1003     if (IsServer(source_p))
1004     {
1005     /* for them, we are exiting the network */
1006     sendto_one(source_p, ":%s SQUIT %s :%s",
1007     ID_or_name(from, source_p), me.name, comment);
1008     }
1009    
1010     sendto_one(source_p, "ERROR :Closing Link: %s (%s)",
1011     source_p->host, comment);
1012     }
1013    
1014     /*
1015     ** Currently only server connections can have
1016     ** depending remote clients here, but it does no
1017     ** harm to check for all local clients. In
1018     ** future some other clients than servers might
1019     ** have remotes too...
1020     **
1021     ** Close the Client connection first and mark it
1022     ** so that no messages are attempted to send to it.
1023     ** Remember it makes source_p->from == NULL.
1024     */
1025     close_connection(source_p);
1026     }
1027    
1028     if (IsServer(source_p))
1029     {
1030     char splitstr[HOSTLEN + HOSTLEN + 2];
1031    
1032     /* This shouldn't ever happen */
1033     assert(source_p->serv != NULL && source_p->servptr != NULL);
1034    
1035     if (ConfigServerHide.hide_servers)
1036     /* set netsplit message to "*.net *.split" to still show
1037     * that its a split, but hide the servers splitting
1038     */
1039     strcpy(splitstr, "*.net *.split");
1040     else
1041     snprintf(splitstr, sizeof(splitstr), "%s %s",
1042     source_p->servptr->name, source_p->name);
1043    
1044     remove_dependents(source_p, from->from, comment, splitstr);
1045    
1046     if (source_p->servptr == &me)
1047     {
1048     sendto_realops_flags(UMODE_ALL, L_ALL,
1049     "%s was connected for %d seconds. %llu/%llu sendK/recvK.",
1050     source_p->name, (int)(CurrentTime - source_p->firsttime),
1051     source_p->localClient->send.bytes >> 10,
1052     source_p->localClient->recv.bytes >> 10);
1053     ilog(L_NOTICE, "%s was connected for %d seconds. %llu/%llu sendK/recvK.",
1054     source_p->name, (int)(CurrentTime - source_p->firsttime),
1055     source_p->localClient->send.bytes >> 10,
1056     source_p->localClient->recv.bytes >> 10);
1057     }
1058     }
1059     else if (IsClient(source_p) && !IsKilled(source_p))
1060     {
1061     sendto_server(NULL, source_p, NULL, CAP_TS6, NOCAPS, NOFLAGS,
1062     ":%s QUIT :%s", ID(source_p), comment);
1063     sendto_server(NULL, source_p, NULL, NOCAPS, CAP_TS6, NOFLAGS,
1064     ":%s QUIT :%s", source_p->name, comment);
1065     }
1066    
1067     /* The client *better* be off all of the lists */
1068     assert(dlinkFind(&unknown_list, source_p) == NULL);
1069     assert(dlinkFind(&local_client_list, source_p) == NULL);
1070     assert(dlinkFind(&serv_list, source_p) == NULL);
1071     assert(dlinkFind(&oper_list, source_p) == NULL);
1072    
1073     exit_one_client(source_p, comment);
1074     }
1075    
1076     /*
1077 adx 68 * close_connection
1078     * Close the physical connection. This function must make
1079     * MyConnect(client_p) == FALSE, and set client_p->from == NULL.
1080     */
1081     static void
1082     close_connection(struct Client *client_p)
1083     {
1084     struct ConfItem *conf;
1085     struct AccessItem *aconf;
1086     struct ClassItem *aclass;
1087    
1088     assert(NULL != client_p);
1089    
1090     if (IsServer(client_p))
1091     {
1092     ServerStats->is_sv++;
1093     ServerStats->is_sbs += client_p->localClient->send.bytes;
1094     ServerStats->is_sbr += client_p->localClient->recv.bytes;
1095     ServerStats->is_sti += CurrentTime - client_p->firsttime;
1096    
1097     /* XXX Does this even make any sense at all anymore?
1098     * scheduling a 'quick' reconnect could cause a pile of
1099     * nick collides under TSora protocol... -db
1100     */
1101     /*
1102     * If the connection has been up for a long amount of time, schedule
1103     * a 'quick' reconnect, else reset the next-connect cycle.
1104     */
1105 db 101 if ((conf = find_exact_name_conf(SERVER_TYPE,
1106     client_p->name, client_p->username,
1107     client_p->host)))
1108 adx 68 {
1109     /*
1110     * Reschedule a faster reconnect, if this was a automatically
1111     * connected configuration entry. (Note that if we have had
1112     * a rehash in between, the status has been changed to
1113     * CONF_ILLEGAL). But only do this if it was a "good" link.
1114     */
1115 db 139 aconf = &conf->conf.AccessItem;
1116     aclass = &((struct ConfItem *)aconf->class_ptr)->conf.ClassItem;
1117 adx 68 aconf->hold = time(NULL);
1118     aconf->hold += (aconf->hold - client_p->since > HANGONGOODLINK) ?
1119     HANGONRETRYDELAY : ConFreq(aclass);
1120     if (nextconnect > aconf->hold)
1121     nextconnect = aconf->hold;
1122     }
1123     }
1124     else if (IsClient(client_p))
1125     {
1126     ServerStats->is_cl++;
1127     ServerStats->is_cbs += client_p->localClient->send.bytes;
1128     ServerStats->is_cbr += client_p->localClient->recv.bytes;
1129     ServerStats->is_cti += CurrentTime - client_p->firsttime;
1130     }
1131     else
1132     ServerStats->is_ni++;
1133    
1134     if (!IsDead(client_p))
1135     {
1136     /* attempt to flush any pending dbufs. Evil, but .. -- adrian */
1137     /* there is still a chance that we might send data to this socket
1138     * even if it is marked as blocked (COMM_SELECT_READ handler is called
1139     * before COMM_SELECT_WRITE). Let's try, nothing to lose.. -adx
1140     */
1141     ClearSendqBlocked(client_p);
1142     send_queued_write(client_p);
1143     }
1144    
1145     #ifdef HAVE_LIBCRYPTO
1146     if (client_p->localClient->fd.ssl)
1147     SSL_shutdown(client_p->localClient->fd.ssl);
1148     #endif
1149     if (client_p->localClient->fd.flags.open)
1150     fd_close(&client_p->localClient->fd);
1151    
1152     if (HasServlink(client_p))
1153     {
1154     if (client_p->localClient->ctrlfd.flags.open)
1155     fd_close(&client_p->localClient->ctrlfd);
1156     }
1157    
1158     dbuf_clear(&client_p->localClient->buf_sendq);
1159     dbuf_clear(&client_p->localClient->buf_recvq);
1160    
1161     MyFree(client_p->localClient->passwd);
1162 adx 365 detach_confs(client_p);
1163 adx 68 client_p->from = NULL; /* ...this should catch them! >:) --msa */
1164     }
1165    
1166     /*
1167     * report_error - report an error from an errno.
1168     * Record error to log and also send a copy to all *LOCAL* opers online.
1169     *
1170     * text is a *format* string for outputing error. It must
1171     * contain only two '%s', the first will be replaced
1172     * by the sockhost from the client_p, and the latter will
1173     * be taken from sys_errlist[errno].
1174     *
1175     * client_p if not NULL, is the *LOCAL* client associated with
1176     * the error.
1177     *
1178     * Cannot use perror() within daemon. stderr is closed in
1179     * ircd and cannot be used. And, worse yet, it might have
1180     * been reassigned to a normal connection...
1181     *
1182     * Actually stderr is still there IFF ircd was run with -s --Rodder
1183     */
1184     void
1185 adx 224 report_error(int level, const char *text, const char *who, int error)
1186 adx 68 {
1187 adx 224 who = (who != NULL) ? who : "";
1188 adx 68
1189     sendto_realops_flags(UMODE_DEBUG, level, text, who, strerror(error));
1190     log_oper_action(LOG_IOERR_TYPE, NULL, "%s %s %s\n", who, text, strerror(error));
1191     ilog(L_ERROR, text, who, strerror(error));
1192     }
1193    
1194     /*
1195 adx 30 * dead_link_on_write - report a write error if not already dead,
1196     * mark it as dead then exit it
1197     */
1198     void
1199     dead_link_on_write(struct Client *client_p, int ierrno)
1200     {
1201     dlink_node *ptr;
1202    
1203     if (IsDefunct(client_p))
1204     return;
1205    
1206     dbuf_clear(&client_p->localClient->buf_recvq);
1207     dbuf_clear(&client_p->localClient->buf_sendq);
1208    
1209     assert(dlinkFind(&abort_list, client_p) == NULL);
1210     ptr = make_dlink_node();
1211     /* don't let exit_aborted_clients() finish yet */
1212     dlinkAddTail(client_p, ptr, &abort_list);
1213    
1214     if (eac_next == NULL)
1215     eac_next = ptr;
1216    
1217     SetDead(client_p); /* You are dead my friend */
1218     }
1219    
1220     /*
1221     * dead_link_on_read - report a read error if not already dead,
1222     * mark it as dead then exit it
1223     */
1224     void
1225     dead_link_on_read(struct Client *client_p, int error)
1226     {
1227     char errmsg[255];
1228     int current_error;
1229    
1230     if (IsDefunct(client_p))
1231     return;
1232    
1233     dbuf_clear(&client_p->localClient->buf_recvq);
1234     dbuf_clear(&client_p->localClient->buf_sendq);
1235    
1236     current_error = get_sockerr(client_p->localClient->fd.fd);
1237    
1238     if (IsServer(client_p) || IsHandshake(client_p))
1239     {
1240     int connected = CurrentTime - client_p->firsttime;
1241    
1242     if (error == 0)
1243     {
1244     /* Admins get the real IP */
1245     sendto_realops_flags(UMODE_ALL, L_ADMIN,
1246     "Server %s closed the connection",
1247     get_client_name(client_p, SHOW_IP));
1248    
1249     /* Opers get a masked IP */
1250     sendto_realops_flags(UMODE_ALL, L_OPER,
1251     "Server %s closed the connection",
1252     get_client_name(client_p, MASK_IP));
1253    
1254     ilog(L_NOTICE, "Server %s closed the connection",
1255     get_client_name(client_p, SHOW_IP));
1256     }
1257     else
1258     {
1259     report_error(L_ADMIN, "Lost connection to %s: %d",
1260     get_client_name(client_p, SHOW_IP), current_error);
1261     report_error(L_OPER, "Lost connection to %s: %d",
1262     get_client_name(client_p, MASK_IP), current_error);
1263     }
1264    
1265     sendto_realops_flags(UMODE_ALL, L_ALL,
1266     "%s had been connected for %d day%s, %2d:%02d:%02d",
1267     client_p->name, connected/86400,
1268     (connected/86400 == 1) ? "" : "s",
1269     (connected % 86400) / 3600, (connected % 3600) / 60,
1270     connected % 60);
1271     }
1272    
1273     if (error == 0)
1274     strlcpy(errmsg, "Remote host closed the connection",
1275     sizeof(errmsg));
1276     else
1277     ircsprintf(errmsg, "Read error: %s",
1278     strerror(current_error));
1279    
1280     exit_client(client_p, &me, errmsg);
1281     }
1282    
1283     void
1284     exit_aborted_clients(void)
1285     {
1286     dlink_node *ptr;
1287     struct Client *target_p;
1288     const char *notice;
1289    
1290     DLINK_FOREACH_SAFE(ptr, eac_next, abort_list.head)
1291     {
1292     target_p = ptr->data;
1293     eac_next = ptr->next;
1294    
1295     if (target_p == NULL)
1296     {
1297     sendto_realops_flags(UMODE_ALL, L_ALL,
1298     "Warning: null client on abort_list!");
1299     dlinkDelete(ptr, &abort_list);
1300     free_dlink_node(ptr);
1301     continue;
1302     }
1303    
1304     dlinkDelete(ptr, &abort_list);
1305    
1306     if (IsSendQExceeded(target_p))
1307     notice = "Max SendQ exceeded";
1308     else
1309     notice = "Write error: connection closed";
1310    
1311     exit_client(target_p, &me, notice);
1312     free_dlink_node(ptr);
1313     }
1314     }
1315    
1316     /*
1317     * accept processing, this adds a form of "caller ID" to ircd
1318     *
1319     * If a client puts themselves into "caller ID only" mode,
1320     * only clients that match a client pointer they have put on
1321     * the accept list will be allowed to message them.
1322     *
1323 db 232 * Diane Bruce, "Dianora" db@db.net
1324 adx 30 */
1325    
1326 michael 235 void
1327 metalrock 362 del_accept(struct Accept *acceptvar, struct Client *client_p)
1328 michael 235 {
1329 metalrock 362 dlinkDelete(&acceptvar->node, &client_p->localClient->acceptlist);
1330 michael 235
1331 metalrock 362 MyFree(acceptvar->nick);
1332     MyFree(acceptvar->user);
1333     MyFree(acceptvar->host);
1334     MyFree(acceptvar);
1335 michael 235 }
1336    
1337     struct Accept *
1338     find_accept(const char *nick, const char *user,
1339     const char *host, struct Client *client_p, int do_match)
1340     {
1341     dlink_node *ptr = NULL;
1342     /* XXX We wouldn't need that if match() would return 0 on match */
1343     int (*cmpfunc)(const char *, const char *) = do_match ? match : irccmp;
1344    
1345     DLINK_FOREACH(ptr, client_p->localClient->acceptlist.head)
1346     {
1347 metalrock 362 struct Accept *acceptvar = ptr->data;
1348 michael 235
1349 metalrock 362 if (cmpfunc(acceptvar->nick, nick) == do_match &&
1350     cmpfunc(acceptvar->user, user) == do_match &&
1351     cmpfunc(acceptvar->host, host) == do_match)
1352     return acceptvar;
1353 michael 235 }
1354    
1355     return NULL;
1356     }
1357    
1358 adx 30 /* accept_message()
1359     *
1360 michael 385 * inputs - pointer to source client
1361 adx 30 * - pointer to target client
1362     * output - 1 if accept this message 0 if not
1363     * side effects - See if source is on target's allow list
1364     */
1365     int
1366 michael 235 accept_message(struct Client *source,
1367     struct Client *target)
1368 adx 30 {
1369 michael 235 dlink_node *ptr = NULL;
1370 adx 30
1371 michael 236 if (source == target || find_accept(source->name, source->username,
1372     source->host, target, 1))
1373 michael 235 return 1;
1374 adx 30
1375 michael 235 if (IsSoftCallerId(target))
1376 adx 30 DLINK_FOREACH(ptr, target->channel.head)
1377 michael 385 if (IsMember(source, ((struct Membership *)ptr->data)->chptr))
1378 michael 235 return 1;
1379 adx 30
1380 michael 235 return 0;
1381 adx 30 }
1382    
1383     /* del_all_accepts()
1384     *
1385     * inputs - pointer to exiting client
1386     * output - NONE
1387 db 232 * side effects - Walk through given clients acceptlist and remove all entries
1388 adx 30 */
1389     void
1390     del_all_accepts(struct Client *client_p)
1391     {
1392 michael 235 dlink_node *ptr = NULL, *next_ptr = NULL;
1393 adx 30
1394 db 232 DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->acceptlist.head)
1395 michael 235 del_accept(ptr->data, client_p);
1396 adx 30 }
1397    
1398     /* set_initial_nick()
1399     *
1400     * inputs
1401     * output
1402     * side effects -
1403     *
1404     * This function is only called to set up an initially registering
1405     * client.
1406     */
1407     void
1408     set_initial_nick(struct Client *client_p, struct Client *source_p,
1409     const char *nick)
1410     {
1411 michael 237 char buf[USERLEN + 1];
1412 adx 30
1413     /* Client setting NICK the first time */
1414    
1415     /* This had to be copied here to avoid problems.. */
1416     source_p->tsinfo = CurrentTime;
1417    
1418     if (source_p->name[0])
1419     hash_del_client(source_p);
1420    
1421     strlcpy(source_p->name, nick, sizeof(source_p->name));
1422     hash_add_client(source_p);
1423    
1424     /* fd_desc is long enough */
1425     fd_note(&client_p->localClient->fd, "Nick: %s", nick);
1426    
1427     /* They have the nick they want now.. */
1428 michael 98 client_p->localClient->llname[0] = '\0';
1429 adx 30
1430     if (source_p->flags & FLAGS_GOTUSER)
1431     {
1432     strlcpy(buf, source_p->username, sizeof(buf));
1433    
1434     /*
1435     * USER already received, now we have NICK.
1436     * *NOTE* For servers "NICK" *must* precede the
1437     * user message (giving USER before NICK is possible
1438     * only for local client connection!). register_user
1439     * may reject the client and call exit_client for it
1440     * --must test this and exit m_nick too!!!
1441     */
1442     register_local_user(client_p, source_p, nick, buf);
1443     }
1444     }
1445    
1446     /* change_local_nick()
1447     *
1448     * inputs - pointer to server
1449     * - pointer to client
1450     * - nick
1451     * output -
1452     * side effects - changes nick of a LOCAL user
1453     */
1454     void
1455     change_local_nick(struct Client *client_p, struct Client *source_p, const char *nick)
1456     {
1457 michael 221 int samenick = 0;
1458 michael 237
1459 adx 30 /*
1460 michael 237 * Client just changing his/her nick. If he/she is
1461     * on a channel, send note of change to all clients
1462     * on that channel. Propagate notice to other servers.
1463     */
1464 adx 30 if ((source_p->localClient->last_nick_change +
1465     ConfigFileEntry.max_nick_time) < CurrentTime)
1466     source_p->localClient->number_of_nick_changes = 0;
1467     source_p->localClient->last_nick_change = CurrentTime;
1468     source_p->localClient->number_of_nick_changes++;
1469    
1470     if ((ConfigFileEntry.anti_nick_flood &&
1471     (source_p->localClient->number_of_nick_changes
1472     <= ConfigFileEntry.max_nick_changes)) ||
1473     !ConfigFileEntry.anti_nick_flood ||
1474     (IsOper(source_p) && ConfigFileEntry.no_oper_flood))
1475     {
1476 michael 221 samenick = !irccmp(source_p->name, nick);
1477     if (!samenick)
1478 adx 30 source_p->tsinfo = CurrentTime;
1479    
1480     /* XXX - the format of this notice should eventually be changed
1481     * to either %s[%s@%s], or even better would be get_client_name() -bill
1482     */
1483     sendto_realops_flags(UMODE_NCHANGE, L_ALL, "Nick change: From %s to %s [%s@%s]",
1484     source_p->name, nick, source_p->username, source_p->host);
1485     sendto_common_channels_local(source_p, 1, ":%s!%s@%s NICK :%s",
1486     source_p->name, source_p->username,
1487     source_p->host, nick);
1488    
1489     add_history(source_p, 1);
1490    
1491     /* Only hubs care about lazy link nicks not being sent on yet
1492     * lazylink leafs/leafs always send their nicks up to hub,
1493     * hence must always propagate nick changes.
1494     * hubs might not propagate a nick change, if the leaf
1495     * does not know about that client yet.
1496     */
1497     sendto_server(client_p, source_p, NULL, CAP_TS6, NOCAPS, NOFLAGS,
1498     ":%s NICK %s :%lu",
1499     ID(source_p), nick, (unsigned long)source_p->tsinfo);
1500     sendto_server(client_p, source_p, NULL, NOCAPS, CAP_TS6, NOFLAGS,
1501     ":%s NICK %s :%lu",
1502     source_p->name, nick, (unsigned long)source_p->tsinfo);
1503     }
1504     else
1505     {
1506     sendto_one(source_p, form_str(ERR_NICKTOOFAST),
1507     me.name, source_p->name, source_p->name,
1508     nick, ConfigFileEntry.max_nick_time);
1509     return;
1510     }
1511    
1512     /* Finally, add to hash */
1513 michael 221 assert(source_p->name[0]);
1514 adx 30
1515 michael 221 hash_del_client(source_p);
1516     if (!samenick)
1517     hash_check_watch(source_p, RPL_LOGOFF);
1518 adx 30 strcpy(source_p->name, nick);
1519     hash_add_client(source_p);
1520    
1521 michael 221 if (!samenick)
1522     hash_check_watch(source_p, RPL_LOGON);
1523 adx 30
1524     /* fd_desc is long enough */
1525     fd_note(&client_p->localClient->fd, "Nick: %s", nick);
1526     }
1527 adx 65
1528     /* log_user_exit()
1529     *
1530     * inputs - pointer to connecting client
1531     * output - NONE
1532     * side effects - Current exiting client is logged to
1533     * either SYSLOG or to file.
1534     */
1535     void
1536     log_user_exit(struct Client *source_p)
1537     {
1538     time_t on_for = CurrentTime - source_p->firsttime;
1539     #ifdef SYSLOG_USERS
1540     if (IsClient(source_p))
1541     {
1542     ilog(L_INFO, "%s (%3ld:%02ld:%02ld): %s!%s@%s %llu/%llu\n",
1543     myctime(source_p->firsttime),
1544     (signed long) on_for / 3600,
1545     (signed long) (on_for % 3600)/60,
1546     (signed long) on_for % 60,
1547     source_p->name, source_p->username, source_p->host,
1548     source_p->localClient->send.bytes>>10,
1549     source_p->localClient->recv.bytes>>10);
1550     }
1551     #else
1552     {
1553     char linebuf[BUFSIZ];
1554    
1555     /*
1556     * This conditional makes the logfile active only after
1557     * it's been created - thus logging can be turned off by
1558     * removing the file.
1559     * -Taner
1560     */
1561     if (IsClient(source_p))
1562     {
1563     if (user_log_fb == NULL)
1564     {
1565     if ((ConfigLoggingEntry.userlog[0] != '\0') &&
1566     (user_log_fb = fbopen(ConfigLoggingEntry.userlog, "r")) != NULL)
1567     {
1568     fbclose(user_log_fb);
1569     user_log_fb = fbopen(ConfigLoggingEntry.userlog, "a");
1570     }
1571     }
1572    
1573     if (user_log_fb != NULL)
1574     {
1575     size_t nbytes = ircsprintf(linebuf,
1576     "%s (%3ld:%02ld:%02ld): %s!%s@%s %llu/%llu\n",
1577     myctime(source_p->firsttime),
1578     (signed long) on_for / 3600,
1579     (signed long) (on_for % 3600)/60,
1580     (signed long) on_for % 60,
1581     source_p->name, source_p->username, source_p->host,
1582     source_p->localClient->send.bytes>>10,
1583     source_p->localClient->recv.bytes>>10);
1584     fbputs(linebuf, user_log_fb, nbytes);
1585     }
1586     }
1587     }
1588     #endif
1589     }
1590    
1591    
1592     /* log_oper_action()
1593     *
1594     * inputs - type of oper log entry
1595     * - pointer to oper
1596     * - const char *pattern == format string
1597     * - var args for format string
1598     * output - none
1599     * side effects - corresponding log is written to, if its present.
1600     *
1601     * rewritten sept 5 2005 - Dianora
1602     */
1603     void
1604     log_oper_action(int log_type, const struct Client *source_p,
1605     const char *pattern, ...)
1606     {
1607     va_list args;
1608     char linebuf[IRCD_BUFSIZE];
1609     FBFILE *log_fb;
1610     char *logfile;
1611     const char *log_message;
1612     size_t nbytes;
1613     size_t n_preamble;
1614     char *p;
1615    
1616     switch(log_type)
1617     {
1618     case LOG_OPER_TYPE:
1619     logfile = ConfigLoggingEntry.operlog;
1620     log_message = "OPER";
1621     break;
1622     case LOG_FAILED_OPER_TYPE:
1623     logfile = ConfigLoggingEntry.failed_operlog;
1624     log_message = "FAILED OPER";
1625     break;
1626     case LOG_KLINE_TYPE:
1627     logfile = ConfigLoggingEntry.klinelog;
1628     log_message = "KLINE";
1629     break;
1630     case LOG_RKLINE_TYPE:
1631     logfile = ConfigLoggingEntry.klinelog;
1632     log_message = "RKLINE";
1633     break;
1634     case LOG_DLINE_TYPE:
1635     logfile = ConfigLoggingEntry.klinelog;
1636     log_message = "DLINE";
1637     break;
1638     case LOG_TEMP_DLINE_TYPE:
1639     logfile = ConfigLoggingEntry.klinelog;
1640     log_message = "TEMP DLINE";
1641     break;
1642     case LOG_TEMP_KLINE_TYPE:
1643     logfile = ConfigLoggingEntry.klinelog;
1644     log_message = "TEMP KLINE";
1645     break;
1646     case LOG_GLINE_TYPE:
1647     logfile = ConfigLoggingEntry.glinelog;
1648     log_message = "GLINE";
1649     break;
1650     case LOG_KILL_TYPE:
1651     logfile = ConfigLoggingEntry.killlog;
1652     log_message = "KILL";
1653     break;
1654     case LOG_IOERR_TYPE:
1655     logfile = ConfigLoggingEntry.ioerrlog;
1656     log_message = "IO ERR";
1657     break;
1658     default:
1659     return;
1660     }
1661    
1662     if (*logfile == '\0')
1663     return;
1664    
1665     p = linebuf;
1666     if (source_p != NULL)
1667     {
1668     n_preamble = ircsprintf(linebuf, "%s %s by (%s!%s@%s) :",
1669     myctime(CurrentTime), log_message,
1670     source_p->name, source_p->username, source_p->host);
1671    
1672     }
1673     else
1674     {
1675     n_preamble = ircsprintf(linebuf, "%s %s :",
1676     myctime(CurrentTime), log_message);
1677     }
1678    
1679     p += n_preamble;
1680    
1681     if ((log_fb = fbopen(logfile, "r")) != NULL)
1682     {
1683     fbclose(log_fb);
1684     log_fb = fbopen(logfile, "a");
1685     if (log_fb == NULL)
1686     return;
1687     va_start(args, pattern);
1688     /* XXX add check for IRCD_BUFSIZE-(n_preamble+1) < 0 ? -db */
1689     nbytes = vsnprintf(p, IRCD_BUFSIZE-(n_preamble+1), pattern, args);
1690     nbytes += n_preamble;
1691     va_end(args);
1692     fbputs(linebuf, log_fb, nbytes);
1693     fbclose(log_fb);
1694     }
1695     }

Properties

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

svnadmin@ircd-hybrid.org
ViewVC Help
Powered by ViewVC 1.1.28