67a0fbfd803603befe536bc7e61e94eb06ced5a0
[ngircd-alex.git] / src / ngircd / irc-login.c
1 /*
2  * ngIRCd -- The Next Generation IRC Daemon
3  * Copyright (c)2001-2012 Alexander Barton (alex@barton.de) and Contributors.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  * Please read the file COPYING, README and AUTHORS for more information.
10  */
11
12 #include "portab.h"
13
14 /**
15  * @file
16  * Login and logout
17  */
18
19 #include "imp.h"
20 #include <assert.h>
21 #include <ctype.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <strings.h>
25
26 #include "conn-func.h"
27 #include "class.h"
28 #include "conf.h"
29 #include "channel.h"
30 #include "log.h"
31 #include "login.h"
32 #include "messages.h"
33 #include "parse.h"
34 #include "irc.h"
35 #include "irc-info.h"
36 #include "irc-macros.h"
37 #include "irc-write.h"
38
39 #include "exp.h"
40 #include "irc-login.h"
41
42 static void Kill_Nick PARAMS((char *Nick, char *Reason));
43 static void Change_Nick PARAMS((CLIENT * Origin, CLIENT * Target, char *NewNick,
44                                 bool InformClient));
45
46 /**
47  * Handler for the IRC "PASS" command.
48  *
49  * @param Client The client from which this command has been received.
50  * @param Req Request structure with prefix and all parameters.
51  * @return CONNECTED or DISCONNECTED.
52  */
53 GLOBAL bool
54 IRC_PASS( CLIENT *Client, REQUEST *Req )
55 {
56         char *type, *orig_flags;
57         int protohigh, protolow;
58
59         assert( Client != NULL );
60         assert( Req != NULL );
61
62         /* Return an error if this is not a local client */
63         if (Client_Conn(Client) <= NONE)
64                 return IRC_WriteErrClient(Client, ERR_UNKNOWNCOMMAND_MSG,
65                                           Client_ID(Client), Req->command);
66
67         if (Client_Type(Client) == CLIENT_UNKNOWN && Req->argc == 1) {
68                 /* Not yet registered "unknown" connection, PASS with one
69                  * argument: either a regular client, service, or server
70                  * using the old RFC 1459 section 4.1.1 syntax. */
71                 LogDebug("Connection %d: got PASS command (RFC 1459) ...",
72                          Client_Conn(Client));
73         } else if ((Client_Type(Client) == CLIENT_UNKNOWN ||
74                     Client_Type(Client) == CLIENT_UNKNOWNSERVER) &&
75                    (Req->argc == 3 || Req->argc == 4)) {
76                 /* Not yet registered "unknown" connection or outgoing server
77                  * link, PASS with three or four argument: server using the
78                  * RFC 2813 section 4.1.1 syntax. */
79                 LogDebug("Connection %d: got PASS command (RFC 2813, new server link) ...",
80                          Client_Conn(Client));
81         } else if (Client_Type(Client) == CLIENT_UNKNOWN ||
82                    Client_Type(Client) == CLIENT_UNKNOWNSERVER) {
83                 /* Unregistered connection, but wrong number of arguments: */
84                 return IRC_WriteErrClient(Client, ERR_NEEDMOREPARAMS_MSG,
85                                           Client_ID(Client), Req->command);
86         } else {
87                 /* Registered connection, PASS command is not allowed! */
88                 return IRC_WriteErrClient(Client, ERR_ALREADYREGISTRED_MSG,
89                                           Client_ID(Client));
90         }
91
92         Conn_SetPassword(Client_Conn(Client), Req->argv[0]);
93
94         /* Protocol version */
95         if (Req->argc >= 2 && strlen(Req->argv[1]) >= 4) {
96                 int c2, c4;
97
98                 c2 = Req->argv[1][2];
99                 c4 = Req->argv[1][4];
100
101                 Req->argv[1][4] = '\0';
102                 protolow = atoi(&Req->argv[1][2]);
103                 Req->argv[1][2] = '\0';
104                 protohigh = atoi(Req->argv[1]);
105
106                 Req->argv[1][2] = c2;
107                 Req->argv[1][4] = c4;
108
109                 Client_SetType(Client, CLIENT_GOTPASS_2813);
110         } else {
111                 protohigh = protolow = 0;
112                 Client_SetType(Client, CLIENT_GOTPASS);
113         }
114
115         /* Protocol type, see doc/Protocol.txt */
116         if (Req->argc >= 2 && strlen(Req->argv[1]) > 4)
117                 type = &Req->argv[1][4];
118         else
119                 type = NULL;
120
121         /* Protocol flags/options */
122         if (Req->argc >= 4)
123                 orig_flags = Req->argv[3];
124         else
125                 orig_flags = "";
126
127         /* Implementation, version and IRC+ flags */
128         if (Req->argc >= 3) {
129                 char *impl, *ptr, *serverver, *flags;
130
131                 impl = Req->argv[2];
132                 ptr = strchr(impl, '|');
133                 if (ptr)
134                         *ptr = '\0';
135
136                 if (type && strcmp(type, PROTOIRCPLUS) == 0) {
137                         /* The peer seems to be a server which supports the
138                          * IRC+ protocol (see doc/Protocol.txt). */
139                         serverver = ptr ? ptr + 1 : "?";
140                         flags = strchr(ptr ? serverver : impl, ':');
141                         if (flags) {
142                                 *flags = '\0';
143                                 flags++;
144                         } else
145                                 flags = "";
146                         Log(LOG_INFO,
147                             "Peer on connection %d announces itself as %s-%s using protocol %d.%d/IRC+ (flags: \"%s\").",
148                             Client_Conn(Client), impl, serverver,
149                             protohigh, protolow, flags);
150                 } else {
151                         /* The peer seems to be a server supporting the
152                          * "original" IRC protocol (RFC 2813). */
153                         if (strchr(orig_flags, 'Z'))
154                                 flags = "Z";
155                         else
156                                 flags = "";
157                         Log(LOG_INFO,
158                             "Peer on connection %d announces itself as \"%s\" using protocol %d.%d (flags: \"%s\").",
159                             Client_Conn(Client), impl,
160                             protohigh, protolow, flags);
161                 }
162                 Client_SetFlags(Client, flags);
163         }
164
165         return CONNECTED;
166 } /* IRC_PASS */
167
168 /**
169  * Handler for the IRC "NICK" command.
170  *
171  * @param Client The client from which this command has been received.
172  * @param Req Request structure with prefix and all parameters.
173  * @return CONNECTED or DISCONNECTED.
174  */
175 GLOBAL bool
176 IRC_NICK( CLIENT *Client, REQUEST *Req )
177 {
178         CLIENT *intr_c, *target, *c;
179         char *nick, *user, *hostname, *modes, *info;
180         int token, hops;
181
182         assert( Client != NULL );
183         assert( Req != NULL );
184
185         /* Some IRC clients, for example BitchX, send the NICK and USER
186          * commands in the wrong order ... */
187         if(Client_Type(Client) == CLIENT_UNKNOWN
188             || Client_Type(Client) == CLIENT_GOTPASS
189             || Client_Type(Client) == CLIENT_GOTNICK
190 #ifndef STRICT_RFC
191             || Client_Type(Client) == CLIENT_GOTUSER
192 #endif
193             || Client_Type(Client) == CLIENT_USER
194             || Client_Type(Client) == CLIENT_SERVICE
195             || (Client_Type(Client) == CLIENT_SERVER && Req->argc == 1))
196         {
197                 /* User registration or change of nickname */
198                 _IRC_ARGC_EQ_OR_RETURN_(Client, Req, 1)
199
200                 /* Search "target" client */
201                 if (Client_Type(Client) == CLIENT_SERVER) {
202                         target = Client_Search(Req->prefix);
203                         if (!target)
204                                 return IRC_WriteErrClient(Client,
205                                                           ERR_NOSUCHNICK_MSG,
206                                                           Client_ID(Client),
207                                                           Req->argv[0]);
208                 } else {
209                         /* Is this a restricted client? */
210                         if (Client_HasMode(Client, 'r'))
211                                 return IRC_WriteErrClient(Client,
212                                                           ERR_RESTRICTED_MSG,
213                                                           Client_ID(Client));
214                         target = Client;
215                 }
216
217 #ifndef STRICT_RFC
218                 /* If the clients tries to change to its own nickname we won't
219                  * do anything. This is how the original ircd behaves and some
220                  * clients (for example Snak) expect it to be like this.
221                  * But I doubt that this is "really the right thing" ... */
222                 if (strcmp(Client_ID(target), Req->argv[0]) == 0)
223                         return CONNECTED;
224 #endif
225
226                 /* Check that the new nickname is available. Special case:
227                  * the client only changes from/to upper to lower case. */
228                 if (strcasecmp(Client_ID(target), Req->argv[0]) != 0) {
229                         if (!Client_CheckNick(target, Req->argv[0]))
230                                 return CONNECTED;
231                 }
232
233                 if (Client_Type(target) != CLIENT_USER &&
234                     Client_Type(target) != CLIENT_SERVICE &&
235                     Client_Type(target) != CLIENT_SERVER) {
236                         /* New client */
237                         LogDebug("Connection %d: got valid NICK command ...",
238                              Client_Conn( Client ));
239
240                         /* Register new nickname of this client */
241                         Client_SetID( target, Req->argv[0] );
242
243 #ifndef STRICT_RFC
244                         if (Conf_AuthPing) {
245                                 Conn_SetAuthPing(Client_Conn(Client), rand());
246                                 IRC_WriteStrClient(Client, "PING :%ld",
247                                         Conn_GetAuthPing(Client_Conn(Client)));
248                                 LogDebug("Connection %d: sent AUTH PING %ld ...",
249                                         Client_Conn(Client),
250                                         Conn_GetAuthPing(Client_Conn(Client)));
251                         }
252 #endif
253
254                         /* If we received a valid USER command already then
255                          * register the new client! */
256                         if( Client_Type( Client ) == CLIENT_GOTUSER )
257                                 return Login_User( Client );
258                         else
259                                 Client_SetType( Client, CLIENT_GOTNICK );
260                 } else {
261                         /* Nickname change */
262                         Change_Nick(Client, target, Req->argv[0],
263                                     Client_Type(Client) == CLIENT_USER ? true : false);
264                         IRC_SetPenalty(target, 2);
265                 }
266
267                 return CONNECTED;
268         } else if(Client_Type(Client) == CLIENT_SERVER ||
269                   Client_Type(Client) == CLIENT_SERVICE) {
270                 /* Server or service introduces new client */
271
272                 /* Bad number of parameters? */
273                 if (Req->argc != 2 && Req->argc != 7)
274                         return IRC_WriteErrClient(Client, ERR_NEEDMOREPARAMS_MSG,
275                                                   Client_ID(Client), Req->command);
276
277                 if (Req->argc >= 7) {
278                         /* RFC 2813 compatible syntax */
279                         nick = Req->argv[0];
280                         hops = atoi(Req->argv[1]);
281                         user = Req->argv[2];
282                         hostname = Req->argv[3];
283                         token = atoi(Req->argv[4]);
284                         modes = Req->argv[5] + 1;
285                         info = Req->argv[6];
286                 } else {
287                         /* RFC 1459 compatible syntax */
288                         nick = Req->argv[0];
289                         hops = 1;
290                         user = Req->argv[0];
291                         hostname = Client_ID(Client);
292                         token = atoi(Req->argv[1]);
293                         modes = "";
294                         info = Req->argv[0];
295                 }
296
297                 c = Client_Search(nick);
298                 if(c) {
299                         /*
300                          * the new nick is already present on this server:
301                          * the new and the old one have to be disconnected now.
302                          */
303                         Log( LOG_ERR, "Server %s introduces already registered nick \"%s\"!", Client_ID( Client ), Req->argv[0] );
304                         Kill_Nick( Req->argv[0], "Nick collision" );
305                         return CONNECTED;
306                 }
307
308                 /* Find the Server this client is connected to */
309                 intr_c = Client_GetFromToken(Client, token);
310                 if (!intr_c) {
311                         Log( LOG_ERR, "Server %s introduces nick \"%s\" on unknown server!?", Client_ID( Client ), Req->argv[0] );
312                         Kill_Nick( Req->argv[0], "Unknown server" );
313                         return CONNECTED;
314                 }
315
316                 c = Client_NewRemoteUser(intr_c, nick, hops, user, hostname,
317                                          token, modes, info, true);
318                 if (!c) {
319                         /* Out of memory, we need to disconnect client to keep
320                          * network state consistent! */
321                         Log(LOG_ALERT,
322                             "Can't create client structure! (on connection %d)",
323                             Client_Conn(Client));
324                         Kill_Nick(Req->argv[0], "Server error");
325                         return CONNECTED;
326                 }
327
328                 /* RFC 2813: client is now fully registered, inform all the
329                  * other servers about the new user.
330                  * RFC 1459: announce the new client only after receiving the
331                  * USER command, first we need more information! */
332                 if (Req->argc < 7) {
333                         LogDebug("Client \"%s\" is being registered (RFC 1459) ...",
334                                  Client_Mask(c));
335                         Client_SetType(c, CLIENT_GOTNICK);
336                 } else
337                         Client_Introduce(Client, c, CLIENT_USER);
338
339                 return CONNECTED;
340         }
341         else
342                 return IRC_WriteErrClient(Client, ERR_ALREADYREGISTRED_MSG,
343                                           Client_ID(Client));
344 } /* IRC_NICK */
345
346 /**
347  * Handler for the IRC "SVSNICK" command.
348  *
349  * @param Client The client from which this command has been received.
350  * @param Req Request structure with prefix and all parameters.
351  * @return CONNECTED or DISCONNECTED.
352  */
353 GLOBAL bool
354 IRC_SVSNICK(CLIENT *Client, REQUEST *Req)
355 {
356         CLIENT *from, *target;
357
358         assert(Client != NULL);
359         assert(Req != NULL);
360
361         /* Search the originator */
362         from = Client_Search(Req->prefix);
363         if (!from)
364                 from = Client;
365
366         /* Search the target */
367         target = Client_Search(Req->argv[0]);
368         if (!target || Client_Type(target) != CLIENT_USER) {
369                 return IRC_WriteErrClient(Client, ERR_NOSUCHNICK_MSG,
370                                           Client_ID(Client), Req->argv[0]);
371         }
372
373         if (Client_Conn(target) <= NONE) {
374                 /* We have to forward the message to the server handling
375                  * this user; this is required to make sure all servers
376                  * in the network do follow the nick name change! */
377                 return IRC_WriteStrClientPrefix(Client_NextHop(target), from,
378                                                 "SVSNICK %s %s",
379                                                 Req->argv[0], Req->argv[1]);
380         }
381
382         /* Make sure that the new nickname is valid */
383         if (!Client_CheckNick(from, Req->argv[1]))
384                 return CONNECTED;
385
386         Change_Nick(from, target, Req->argv[1], true);
387         return CONNECTED;
388 }
389
390 /**
391  * Handler for the IRC "USER" command.
392  *
393  * @param Client The client from which this command has been received.
394  * @param Req Request structure with prefix and all parameters.
395  * @return CONNECTED or DISCONNECTED.
396  */
397 GLOBAL bool
398 IRC_USER(CLIENT * Client, REQUEST * Req)
399 {
400         CLIENT *c;
401         char *ptr;
402
403         assert(Client != NULL);
404         assert(Req != NULL);
405
406         if (Client_Type(Client) == CLIENT_GOTNICK ||
407 #ifndef STRICT_RFC
408             Client_Type(Client) == CLIENT_UNKNOWN ||
409 #endif
410             Client_Type(Client) == CLIENT_GOTPASS)
411         {
412                 /* New connection */
413                 _IRC_ARGC_EQ_OR_RETURN_(Client, Req, 4)
414
415                 /* User name: only alphanumeric characters and limited
416                    punctuation is allowed.*/
417                 ptr = Req->argv[0];
418                 while (*ptr) {
419                         if (!isalnum((int)*ptr) &&
420                             *ptr != '+' && *ptr != '-' && *ptr != '@' &&
421                             *ptr != '.' && *ptr != '_') {
422                                 Conn_Close(Client_Conn(Client), NULL,
423                                            "Invalid user name", true);
424                                 return DISCONNECTED;
425                         }
426                         ptr++;
427                 }
428
429                 /* Save the received username for authentication, and use
430                  * it up to the first '@' as default user name (like ircd2.11,
431                  * bahamut, ircd-seven, ...), prefixed with '~', if needed: */
432                 Client_SetOrigUser(Client, Req->argv[0]);
433                 ptr = strchr(Req->argv[0], '@');
434                 if (ptr)
435                         *ptr = '\0';
436 #ifdef IDENTAUTH
437                 ptr = Client_User(Client);
438                 if (!ptr || !*ptr || *ptr == '~')
439                         Client_SetUser(Client, Req->argv[0], false);
440 #else
441                 Client_SetUser(Client, Req->argv[0], false);
442 #endif
443
444                 /* "Real name" or user info text: Don't set it to the empty
445                  * string, the original ircd can't deal with such "real names"
446                  * (e. g. "USER user * * :") ... */
447                 if (*Req->argv[3])
448                         Client_SetInfo(Client, Req->argv[3]);
449                 else
450                         Client_SetInfo(Client, "-");
451
452                 LogDebug("Connection %d: got valid USER command ...",
453                     Client_Conn(Client));
454                 if (Client_Type(Client) == CLIENT_GOTNICK)
455                         return Login_User(Client);
456                 else
457                         Client_SetType(Client, CLIENT_GOTUSER);
458                 return CONNECTED;
459
460         } else if (Client_Type(Client) == CLIENT_SERVER ||
461                    Client_Type(Client) == CLIENT_SERVICE) {
462                 /* Server/service updating an user */
463                 _IRC_ARGC_EQ_OR_RETURN_(Client, Req, 4)
464
465                 c = Client_Search(Req->prefix);
466                 if (!c)
467                         return IRC_WriteErrClient(Client, ERR_NOSUCHNICK_MSG,
468                                                   Client_ID(Client),
469                                                   Req->prefix);
470
471                 Client_SetUser(c, Req->argv[0], true);
472                 Client_SetOrigUser(c, Req->argv[0]);
473                 Client_SetHostname(c, Req->argv[1]);
474                 Client_SetInfo(c, Req->argv[3]);
475
476                 LogDebug("Connection %d: got valid USER command for \"%s\".",
477                          Client_Conn(Client), Client_Mask(c));
478
479                 /* RFC 1459 style user registration?
480                  * Introduce client to network: */
481                 if (Client_Type(c) == CLIENT_GOTNICK)
482                         Client_Introduce(Client, c, CLIENT_USER);
483
484                 return CONNECTED;
485         } else if (Client_Type(Client) == CLIENT_USER) {
486                 /* Already registered connection */
487                 return IRC_WriteErrClient(Client, ERR_ALREADYREGISTRED_MSG,
488                                           Client_ID(Client));
489         } else {
490                 /* Unexpected/invalid connection state? */
491                 return IRC_WriteErrClient(Client, ERR_NOTREGISTERED_MSG,
492                                           Client_ID(Client));
493         }
494 } /* IRC_USER */
495
496 /**
497  * Handler for the IRC "SERVICE" command.
498  *
499  * At the moment ngIRCd doesn't support directly linked services, so this
500  * function returns ERR_ERRONEUSNICKNAME when the SERVICE command has not been
501  * received from a peer server.
502  *
503  * @param Client The client from which this command has been received.
504  * @param Req Request structure with prefix and all parameters.
505  * @return CONNECTED or DISCONNECTED.
506  */
507 GLOBAL bool
508 IRC_SERVICE(CLIENT *Client, REQUEST *Req)
509 {
510         CLIENT *c, *intr_c;
511         char *nick, *user, *host, *info, *modes, *ptr;
512         int token, hops;
513
514         assert(Client != NULL);
515         assert(Req != NULL);
516
517         if (Client_Type(Client) != CLIENT_GOTPASS &&
518             Client_Type(Client) != CLIENT_SERVER)
519                 return IRC_WriteErrClient(Client, ERR_ALREADYREGISTRED_MSG,
520                                           Client_ID(Client));
521
522         if (Client_Type(Client) != CLIENT_SERVER)
523                 return IRC_WriteErrClient(Client, ERR_ERRONEUSNICKNAME_MSG,
524                                   Client_ID(Client), Req->argv[0]);
525
526         nick = Req->argv[0];
527         user = NULL; host = NULL;
528         token = atoi(Req->argv[1]);
529         hops = atoi(Req->argv[4]);
530         info = Req->argv[5];
531
532         /* Validate service name ("nickname") */
533         c = Client_Search(nick);
534         if(c) {
535                 /* Nickname collision: disconnect (KILL) both clients! */
536                 Log(LOG_ERR, "Server %s introduces already registered service \"%s\"!",
537                     Client_ID(Client), nick);
538                 Kill_Nick(nick, "Nick collision");
539                 return CONNECTED;
540         }
541
542         /* Get the server to which the service is connected */
543         intr_c = Client_GetFromToken(Client, token);
544         if (! intr_c) {
545                 Log(LOG_ERR, "Server %s introduces service \"%s\" on unknown server!?",
546                     Client_ID(Client), nick);
547                 Kill_Nick(nick, "Unknown server");
548                 return CONNECTED;
549         }
550
551         /* Get user and host name */
552         ptr = strchr(nick, '@');
553         if (ptr) {
554                 *ptr = '\0';
555                 host = ++ptr;
556         }
557         if (!host)
558                 host = Client_Hostname(intr_c);
559         ptr = strchr(nick, '!');
560         if (ptr) {
561                 *ptr = '\0';
562                 user = ++ptr;
563         }
564         if (!user)
565                 user = nick;
566
567         /* According to RFC 2812/2813 parameter 4 <type> "is currently reserved
568          * for future usage"; but we use it to transfer the modes and check
569          * that the first character is a '+' sign and ignore it otherwise. */
570         modes = (Req->argv[3][0] == '+') ? ++Req->argv[3] : "";
571
572         c = Client_NewRemoteUser(intr_c, nick, hops, user, host,
573                                  token, modes, info, true);
574         if (! c) {
575                 /* Couldn't create client structure, so KILL the service to
576                  * keep network status consistent ... */
577                 Log(LOG_ALERT, "Can't create client structure! (on connection %d)",
578                     Client_Conn(Client));
579                 Kill_Nick(nick, "Server error");
580                 return CONNECTED;
581         }
582
583         Client_Introduce(Client, c, CLIENT_SERVICE);
584         return CONNECTED;
585 } /* IRC_SERVICE */
586
587 /**
588  * Handler for the IRC "WEBIRC" command.
589  *
590  * @param Client The client from which this command has been received.
591  * @param Req Request structure with prefix and all parameters.
592  * @return CONNECTED or DISCONNECTED.
593  */
594 GLOBAL bool
595 IRC_WEBIRC(CLIENT *Client, REQUEST *Req)
596 {
597         if (!Conf_WebircPwd[0] || strcmp(Req->argv[0], Conf_WebircPwd) != 0)
598                 return IRC_WriteErrClient(Client, ERR_PASSWDMISMATCH_MSG,
599                                           Client_ID(Client));
600
601         LogDebug("Connection %d: got valid WEBIRC command: user=%s, host=%s, ip=%s",
602                  Client_Conn(Client), Req->argv[1], Req->argv[2], Req->argv[3]);
603
604         Client_SetUser(Client, Req->argv[1], true);
605         Client_SetOrigUser(Client, Req->argv[1]);
606         Client_SetHostname(Client, Req->argv[2]);
607         Client_SetIPAText(Client, Req->argv[3]);
608
609         return CONNECTED;
610 } /* IRC_WEBIRC */
611
612 /**
613  * Handler for the IRC "QUIT" command.
614  *
615  * @param Client The client from which this command has been received.
616  * @param Req Request structure with prefix and all parameters.
617  * @return CONNECTED or DISCONNECTED.
618  */
619 GLOBAL bool
620 IRC_QUIT( CLIENT *Client, REQUEST *Req )
621 {
622         CLIENT *target;
623         char quitmsg[LINE_LEN];
624
625         assert(Client != NULL);
626         assert(Req != NULL);
627
628         if (Req->argc == 1)
629                 strlcpy(quitmsg, Req->argv[0], sizeof quitmsg);
630
631         if (Client_Type(Client) == CLIENT_SERVER) {
632                 /* Server */
633                 target = Client_Search(Req->prefix);
634                 if (!target) {
635                         Log(LOG_WARNING,
636                             "Got QUIT from %s for unknown client!?",
637                             Client_ID(Client));
638                         return CONNECTED;
639                 }
640
641                 if (target != Client) {
642                         Client_Destroy(target, "Got QUIT command",
643                                        Req->argc == 1 ? quitmsg : NULL, true);
644                         return CONNECTED;
645                 } else {
646                         Conn_Close(Client_Conn(Client), "Got QUIT command",
647                                    Req->argc == 1 ? quitmsg : NULL, true);
648                         return DISCONNECTED;
649                 }
650         } else {
651                 if (Req->argc == 1 && quitmsg[0] != '\"') {
652                         /* " " to avoid confusion */
653                         strlcpy(quitmsg, "\"", sizeof quitmsg);
654                         strlcat(quitmsg, Req->argv[0], sizeof quitmsg-1);
655                         strlcat(quitmsg, "\"", sizeof quitmsg );
656                 }
657
658                 /* User, Service, or not yet registered */
659                 Conn_Close(Client_Conn(Client), "Got QUIT command",
660                            Req->argc == 1 ? quitmsg : NULL, true);
661
662                 return DISCONNECTED;
663         }
664 } /* IRC_QUIT */
665
666 #ifndef STRICT_RFC
667
668 /**
669  * Handler for HTTP command, e.g. GET and POST
670  *
671  * We handle these commands here to avoid the quite long timeout when
672  * some user tries to access this IRC daemon using an web browser ...
673  *
674  * @param Client The client from which this command has been received.
675  * @param Req Request structure with prefix and all parameters.
676  * @return CONNECTED or DISCONNECTED.
677  */
678 GLOBAL bool
679 IRC_QUIT_HTTP( CLIENT *Client, REQUEST *Req )
680 {
681         Req->argc = 1;
682         Req->argv[0] = "Oops, HTTP request received? This is IRC!";
683         return IRC_QUIT(Client, Req);
684 } /* IRC_QUIT_HTTP */
685
686 #endif
687
688 /**
689  * Handler for the IRC "PING" command.
690  *
691  * @param Client The client from which this command has been received.
692  * @param Req Request structure with prefix and all parameters.
693  * @return CONNECTED or DISCONNECTED.
694  */
695 GLOBAL bool
696 IRC_PING(CLIENT *Client, REQUEST *Req)
697 {
698         CLIENT *target, *from;
699
700         assert(Client != NULL);
701         assert(Req != NULL);
702
703         if (Req->argc < 1)
704                 return IRC_WriteErrClient(Client, ERR_NOORIGIN_MSG,
705                                           Client_ID(Client));
706 #ifdef STRICT_RFC
707         /* Don't ignore additional arguments when in "strict" mode */
708         _IRC_ARGC_LE_OR_RETURN_(Client, Req, 2)
709 #endif
710
711         if (Req->argc > 1) {
712                 /* A target has been specified ... */
713                 target = Client_Search(Req->argv[1]);
714
715                 if (!target || Client_Type(target) != CLIENT_SERVER)
716                         return IRC_WriteErrClient(Client, ERR_NOSUCHSERVER_MSG,
717                                         Client_ID(Client), Req->argv[1]);
718
719                 if (target != Client_ThisServer()) {
720                         /* Ok, we have to forward the PING */
721                         if (Client_Type(Client) == CLIENT_SERVER)
722                                 from = Client_Search(Req->prefix);
723                         else
724                                 from = Client;
725                         if (!from)
726                                 return IRC_WriteErrClient(Client,
727                                                 ERR_NOSUCHSERVER_MSG,
728                                                 Client_ID(Client), Req->prefix);
729
730                         return IRC_WriteStrClientPrefix(target, from,
731                                         "PING %s :%s", Req->argv[0],
732                                         Req->argv[1] );
733                 }
734         }
735
736         if (Client_Type(Client) == CLIENT_SERVER) {
737                 if (Req->prefix)
738                         from = Client_Search(Req->prefix);
739                 else
740                         from = Client;
741         } else
742                 from = Client_ThisServer();
743         if (!from)
744                 return IRC_WriteErrClient(Client, ERR_NOSUCHSERVER_MSG,
745                                         Client_ID(Client), Req->prefix);
746
747         Log(LOG_DEBUG, "Connection %d: got PING, sending PONG ...",
748             Client_Conn(Client));
749
750 #ifdef STRICT_RFC
751         return IRC_WriteStrClient(Client, "PONG %s :%s",
752                 Client_ID(from), Client_ID(Client));
753 #else
754         /* Some clients depend on the argument being returned in the PONG
755          * reply (not mentioned in any RFC, though) */
756         return IRC_WriteStrClient(Client, "PONG %s :%s",
757                 Client_ID(from), Req->argv[0]);
758 #endif
759 } /* IRC_PING */
760
761 /**
762  * Handler for the IRC "PONG" command.
763  *
764  * @param Client The client from which this command has been received.
765  * @param Req Request structure with prefix and all parameters.
766  * @return CONNECTED or DISCONNECTED.
767  */
768 GLOBAL bool
769 IRC_PONG(CLIENT *Client, REQUEST *Req)
770 {
771         CLIENT *target, *from;
772         CONN_ID conn;
773 #ifndef STRICT_RFC
774         long auth_ping;
775 #endif
776         char *s;
777
778         assert(Client != NULL);
779         assert(Req != NULL);
780
781         /* Wrong number of arguments? */
782         if (Req->argc < 1) {
783                 if (Client_Type(Client) == CLIENT_USER)
784                         return IRC_WriteErrClient(Client, ERR_NOORIGIN_MSG,
785                                                   Client_ID(Client));
786                 else
787                         return CONNECTED;
788         }
789         if (Client_Type(Client) == CLIENT_USER) {
790                 _IRC_ARGC_LE_OR_RETURN_(Client, Req, 2)
791         }
792
793         /* Forward? */
794         if (Req->argc == 2 && Client_Type(Client) == CLIENT_SERVER) {
795                 target = Client_Search(Req->argv[0]);
796                 if (!target)
797                         return IRC_WriteErrClient(Client, ERR_NOSUCHSERVER_MSG,
798                                         Client_ID(Client), Req->argv[0]);
799
800                 from = Client_Search(Req->prefix);
801
802                 if (target != Client_ThisServer() && target != from) {
803                         /* Ok, we have to forward the message. */
804                         if (!from)
805                                 return IRC_WriteErrClient(Client,
806                                                 ERR_NOSUCHSERVER_MSG,
807                                                 Client_ID(Client), Req->prefix);
808
809                         if (Client_Type(Client_NextHop(target)) != CLIENT_SERVER)
810                                 s = Client_ID(from);
811                         else
812                                 s = Req->argv[0];
813                         return IRC_WriteStrClientPrefix(target, from,
814                                  "PONG %s :%s", s, Req->argv[1]);
815                 }
816         }
817
818         /* The connection timestamp has already been updated when the data has
819          * been read from so socket, so we don't need to update it here. */
820
821         conn = Client_Conn(Client);
822
823 #ifndef STRICT_RFC
824         /* Check authentication PING-PONG ... */
825         auth_ping = Conn_GetAuthPing(conn);
826         if (auth_ping) {
827                 LogDebug("AUTH PONG: waiting for token \"%ld\", got \"%s\" ...",
828                          auth_ping, Req->argv[0]);
829                 if (auth_ping == atoi(Req->argv[0])) {
830                         Conn_SetAuthPing(conn, 0);
831                         if (Client_Type(Client) == CLIENT_WAITAUTHPING)
832                                 Login_User(Client);
833                 } else
834                         if (!IRC_WriteStrClient(Client,
835                                         "To connect, type /QUOTE PONG %ld",
836                                         auth_ping))
837                                 return DISCONNECTED;
838         }
839 #endif
840
841         if (Client_Type(Client) == CLIENT_SERVER && Conn_LastPing(conn) == 0) {
842                 Log(LOG_INFO,
843                     "Synchronization with \"%s\" done (connection %d): %ld second%s [%ld users, %ld channels].",
844                     Client_ID(Client), conn, time(NULL) - Conn_GetSignon(conn),
845                     time(NULL) - Conn_GetSignon(conn) == 1 ? "" : "s",
846                     Client_UserCount(), Channel_CountVisible(NULL));
847                 Conn_UpdatePing(conn);
848         } else
849                 LogDebug("Connection %d: received PONG. Lag: %ld seconds.",
850                          conn, time(NULL) - Conn_LastPing(conn));
851
852         return CONNECTED;
853 } /* IRC_PONG */
854
855 /**
856  * Kill all users with a specific nickname in the network.
857  *
858  * @param Nick Nickname.
859  * @param Reason Reason for the KILL.
860  */
861 static void
862 Kill_Nick(char *Nick, char *Reason)
863 {
864         REQUEST r;
865
866         assert (Nick != NULL);
867         assert (Reason != NULL);
868
869         r.prefix = NULL;
870         r.argv[0] = Nick;
871         r.argv[1] = Reason;
872         r.argc = 2;
873
874         Log(LOG_ERR, "User(s) with nick \"%s\" will be disconnected: %s!",
875             Nick, Reason);
876
877         IRC_KILL(Client_ThisServer(), &r);
878 } /* Kill_Nick */
879
880 /**
881  * Change the nickname of a client.
882  *
883  * @param Origin The client which caused the nickname change.
884  * @param Target The client of which the nickname should be changed.
885  * @param NewNick The new nickname.
886  */
887 static void
888 Change_Nick(CLIENT *Origin, CLIENT *Target, char *NewNick, bool InformClient)
889 {
890         if (Client_Conn(Target) > NONE) {
891                 /* Local client */
892                 Log(LOG_INFO,
893                     "%s \"%s\" changed nick (connection %d): \"%s\" -> \"%s\".",
894                     Client_TypeText(Target), Client_Mask(Target),
895                     Client_Conn(Target), Client_ID(Target), NewNick);
896                 Conn_UpdateIdle(Client_Conn(Target));
897         } else {
898                 /* Remote client */
899                 LogDebug("%s \"%s\" changed nick: \"%s\" -> \"%s\".",
900                          Client_TypeText(Target),
901                          Client_Mask(Target), Client_ID(Target), NewNick);
902         }
903
904         /* Inform all servers and users (which have to know) of the new name */
905         if (InformClient) {
906                 IRC_WriteStrClientPrefix(Target, Target, "NICK :%s", NewNick);
907                 IRC_WriteStrServersPrefix(NULL, Target, "NICK :%s", NewNick);
908         } else
909                 IRC_WriteStrServersPrefix(Origin, Target, "NICK :%s", NewNick);
910         IRC_WriteStrRelatedPrefix(Target, Target, false, "NICK :%s", NewNick);
911
912         /* Register old nickname for WHOWAS queries */
913         Client_RegisterWhowas(Target);
914
915         /* Save new nickname */
916         Client_SetID(Target, NewNick);
917 }
918
919 /* -eof- */