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