X-Git-Url: https://arthur.barton.de/cgi-bin/gitweb.cgi?p=ngircd-alex.git;a=blobdiff_plain;f=src%2Fngircd%2Firc-info.c;h=54f83170e3bceea94828acb1baf83de868a43261;hp=34198bf3e7e2b30ff8a0679d3dbdcbbb0633f547;hb=48326e061aacd954e24f76c53ded10448cbc28eb;hpb=ef3327d372c159bd2a395d6854843982a5e9c54d

diff --git a/src/ngircd/irc-info.c b/src/ngircd/irc-info.c
index 34198bf3..54f83170 100644
--- a/src/ngircd/irc-info.c
+++ b/src/ngircd/irc-info.c
@@ -1,19 +1,21 @@
 /*
  * ngIRCd -- The Next Generation IRC Daemon
- * Copyright (c)2001-2008 Alexander Barton (alex@barton.de)
+ * Copyright (c)2001-2012 Alexander Barton (alex@barton.de) and Contributors.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  * Please read the file COPYING, README and AUTHORS for more information.
- *
- * IRC info commands
  */
 
-
 #include "portab.h"
 
+/**
+ * @file
+ * IRC info commands
+ */
+
 #include "imp.h"
 #include <assert.h>
 #include <errno.h>
@@ -25,17 +27,19 @@
 #include "ngircd.h"
 #include "conn-func.h"
 #include "conn-zip.h"
-#include "client.h"
 #include "channel.h"
-#include "resolve.h"
+#include "class.h"
 #include "conf.h"
 #include "defines.h"
+#include "lists.h"
 #include "log.h"
 #include "messages.h"
 #include "match.h"
 #include "tool.h"
 #include "parse.h"
+#include "irc.h"
 #include "irc-write.h"
+#include "client-cap.h"
 
 #include "exp.h"
 #include "irc-info.h"
@@ -49,24 +53,23 @@ IRC_ADMIN(CLIENT *Client, REQUEST *Req )
 	assert( Client != NULL );
 	assert( Req != NULL );
 
-	/* Falsche Anzahl Parameter? */
 	if(( Req->argc > 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 
-	/* Ziel suchen */
+	/* find target ... */
 	if( Req->argc == 1 ) target = Client_Search( Req->argv[0] );
 	else target = Client_ThisServer( );
 
-	/* Prefix ermitteln */
+	/* find Prefix */
 	if( Client_Type( Client ) == CLIENT_SERVER ) prefix = Client_Search( Req->prefix );
 	else prefix = Client;
 	if( ! prefix ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
 
-	/* An anderen Server weiterleiten? */
+	/* forwad message to another server? */
 	if( target != Client_ThisServer( ))
 	{
 		if(( ! target ) || ( Client_Type( target ) != CLIENT_SERVER )) return IRC_WriteStrClient( prefix, ERR_NOSUCHSERVER_MSG, Client_ID( prefix ), Req->argv[0] );
 
-		/* forwarden */
+		/* forward */
 		IRC_WriteStrClientPrefix( target, prefix, "ADMIN %s", Req->argv[0] );
 		return CONNECTED;
 	}
@@ -114,7 +117,7 @@ IRC_INFO(CLIENT * Client, REQUEST * Req)
 		target = Client_Search(Req->argv[0]);
 	else
 		target = Client_ThisServer();
-	
+
 	/* Make sure that the target is a server */
 	if (target && Client_Type(target) != CLIENT_SERVER)
 		target = Client_Introducer(target);
@@ -133,8 +136,14 @@ IRC_INFO(CLIENT * Client, REQUEST * Req)
 	if (!IRC_WriteStrClient(Client, RPL_INFO_MSG, Client_ID(prefix),
 				NGIRCd_Version))
 		return DISCONNECTED;
-	
-	strlcpy(msg, "Server has been started ", sizeof(msg));
+
+#if defined(__DATE__) && defined(__TIME__)
+	snprintf(msg, sizeof(msg), "Birth Date: %s at %s", __DATE__, __TIME__);
+	if (!IRC_WriteStrClient(Client, RPL_INFO_MSG, Client_ID(prefix), msg))
+		return DISCONNECTED;
+#endif
+
+	strlcpy(msg, "On-line since ", sizeof(msg));
 	strlcat(msg, NGIRCd_StartStr, sizeof(msg));
 	if (!IRC_WriteStrClient(Client, RPL_INFO_MSG, Client_ID(prefix), msg))
 		return DISCONNECTED;
@@ -147,6 +156,15 @@ IRC_INFO(CLIENT * Client, REQUEST * Req)
 } /* IRC_INFO */
 
 
+/**
+ * Handler for the IRC "ISON" command.
+ *
+ * See RFC 2812, 4.9 "Ison message".
+ *
+ * @param Client The client from which this command has been received.
+ * @param Req Request structure with prefix and all parameters.
+ * @return CONNECTED or DISCONNECTED.
+ */
 GLOBAL bool
 IRC_ISON( CLIENT *Client, REQUEST *Req )
 {
@@ -155,81 +173,103 @@ IRC_ISON( CLIENT *Client, REQUEST *Req )
 	char *ptr;
 	int i;
 
-	assert( Client != NULL );
-	assert( Req != NULL );
+	assert(Client != NULL);
+	assert(Req != NULL);
 
-	/* Falsche Anzahl Parameter? */
-	if(( Req->argc < 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
+	/* Bad number of arguments? */
+	if (Req->argc < 1)
+		return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
+					  Client_ID(Client), Req->command);
 
-	strlcpy( rpl, RPL_ISON_MSG, sizeof rpl );
-	for( i = 0; i < Req->argc; i++ )
-	{
-		ptr = strtok( Req->argv[i], " " );
-		while( ptr )
-		{
-			ngt_TrimStr( ptr );
-			c = Client_Search( ptr );
-			if( c && ( Client_Type( c ) == CLIENT_USER ))
-			{
-				/* Dieser Nick ist "online" */
-				strlcat( rpl, ptr, sizeof( rpl ));
-				strlcat( rpl, " ", sizeof( rpl ));
+	strlcpy(rpl, RPL_ISON_MSG, sizeof rpl);
+	for (i = 0; i < Req->argc; i++) {
+		/* "All" ircd even parse ":<x> <y> ..." arguments and split
+		 * them up; so we do the same ... */
+		ptr = strtok(Req->argv[i], " ");
+		while (ptr) {
+			ngt_TrimStr(ptr);
+			c = Client_Search(ptr);
+			if (c && Client_Type(c) == CLIENT_USER) {
+				strlcat(rpl, Client_ID(c), sizeof(rpl));
+				strlcat(rpl, " ", sizeof(rpl));
 			}
-			ptr = strtok( NULL, " " );
+			ptr = strtok(NULL, " ");
 		}
 	}
 	ngt_TrimLastChr(rpl, ' ');
 
-	return IRC_WriteStrClient( Client, rpl, Client_ID( Client ) );
+	return IRC_WriteStrClient(Client, rpl, Client_ID(Client));
 } /* IRC_ISON */
 
 
+/**
+ * Handler for the IRC "LINKS" command.
+ *
+ * See RFC 2812, 3.4.5 "Links message".
+ *
+ * @param Client The client from which this command has been received.
+ * @param Req Request structure with prefix and all parameters.
+ * @return CONNECTED or DISCONNECTED.
+ */
 GLOBAL bool
-IRC_LINKS( CLIENT *Client, REQUEST *Req )
+IRC_LINKS(CLIENT *Client, REQUEST *Req)
 {
 	CLIENT *target, *from, *c;
 	char *mask;
 
-	assert( Client != NULL );
-	assert( Req != NULL );
+	assert(Client != NULL);
+	assert(Req != NULL);
 
-	/* Falsche Anzahl Parameter? */
-	if(( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
+	IRC_SetPenalty(Client, 1);
 
-	/* Server-Mask ermitteln */
-	if( Req->argc > 0 ) mask = Req->argv[Req->argc - 1];
-	else mask = "*";
+	if (Req->argc > 2)
+		return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
+					  Client_ID(Client), Req->command);
 
-	/* Absender ermitteln */
-	if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
-	else from = Client;
-	if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
+	/* Get pointer to server mask or "*", if none given */
+	if (Req->argc > 0)
+		mask = Req->argv[Req->argc - 1];
+	else
+		mask = "*";
 
-	/* An anderen Server forwarden? */
-	if( Req->argc == 2 )
-	{
-		target = Client_Search( Req->argv[0] );
-		if(( ! target ) || ( Client_Type( target ) != CLIENT_SERVER )) return IRC_WriteStrClient( from, ERR_NOSUCHSERVER_MSG, Client_ID( from ), Req->argv[0] );
-		else if( target != Client_ThisServer( )) return IRC_WriteStrClientPrefix( target, from, "LINKS %s %s", Req->argv[0], Req->argv[1] );
-	}
+	if (Client_Type(Client) == CLIENT_SERVER)
+		from = Client_Search(Req->prefix);
+	else
+		from = Client;
+	if (!from)
+		return IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG,
+					  Client_ID(Client), Req->prefix);
 
-	/* Wer ist der Absender? */
-	if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_Search( Req->prefix );
-	else target = Client;
-	if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
+	/* Forward? */
+	if (Req->argc == 2) {
+		target = Client_Search(Req->argv[0]);
+		if (! target || Client_Type(target) != CLIENT_SERVER)
+			return IRC_WriteStrClient(from, ERR_NOSUCHSERVER_MSG,
+						  Client_ID(from),
+						  Req->argv[0] );
+		else
+			if (target != Client_ThisServer())
+				return IRC_WriteStrClientPrefix(target, from,
+						"LINKS %s %s", Req->argv[0],
+						Req->argv[1]);
+	}
 
-	c = Client_First( );
-	while( c )
-	{
-		if( Client_Type( c ) == CLIENT_SERVER )
-		{
-			if( ! IRC_WriteStrClient( target, RPL_LINKS_MSG, Client_ID( target ), Client_ID( c ), Client_ID( Client_TopServer( c ) ? Client_TopServer( c ) : Client_ThisServer( )), Client_Hops( c ), Client_Info( c ))) return DISCONNECTED;
+	c = Client_First();
+	while (c) {
+		if (Client_Type(c) == CLIENT_SERVER
+		    && MatchCaseInsensitive(mask, Client_ID(c))) {
+			if (!IRC_WriteStrClient(from, RPL_LINKS_MSG,
+					Client_ID(from), Client_ID(c),
+					Client_ID(Client_TopServer(c)
+						  ? Client_TopServer(c)
+						  : Client_ThisServer()),
+					Client_Hops(c), Client_Info(c)))
+				return DISCONNECTED;
 		}
-		c = Client_Next( c );
+		c = Client_Next(c);
 	}
-	
-	IRC_SetPenalty( target, 1 );
-	return IRC_WriteStrClient( target, RPL_ENDOFLINKS_MSG, Client_ID( target ), mask );
+	return IRC_WriteStrClient(from, RPL_ENDOFLINKS_MSG,
+				  Client_ID(from), mask);
 } /* IRC_LINKS */
 
 
@@ -241,7 +281,6 @@ IRC_LUSERS( CLIENT *Client, REQUEST *Req )
 	assert( Client != NULL );
 	assert( Req != NULL );
 
-	/* Falsche Anzahl Parameter? */
 	if(( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 
 	/* Absender ermitteln */
@@ -270,12 +309,15 @@ IRC_LUSERS( CLIENT *Client, REQUEST *Req )
 
 
 /**
- * List registered services.
- * This function is a dummy that immediately returns RPL_SERVLISTEND.
+ * Handler for the IRC command "SERVLIST".
+ * List registered services, see RFC 2811, section 3.5.1: the syntax is
+ * "SERVLIST [<mask> [<type>]]".
  */
 GLOBAL bool
 IRC_SERVLIST(CLIENT *Client, REQUEST *Req)
 {
+	CLIENT *c;
+
 	assert(Client != NULL);
 	assert(Req != NULL);
 
@@ -283,6 +325,21 @@ IRC_SERVLIST(CLIENT *Client, REQUEST *Req)
 		return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
 					  Client_ID(Client), Req->command);
 
+	if (Req->argc < 2 || strcmp(Req->argv[1], "0") == 0) {
+		for (c = Client_First(); c!= NULL; c = Client_Next(c)) {
+			if (Client_Type(c) != CLIENT_SERVICE)
+				continue;
+			if (Req->argc > 0 && !MatchCaseInsensitive(Req->argv[0],
+								  Client_ID(c)))
+				continue;
+			if (!IRC_WriteStrClient(Client, RPL_SERVLIST_MSG,
+					Client_ID(Client), Client_Mask(c),
+					Client_Mask(Client_Introducer(c)), "*",
+					0, Client_Hops(c), Client_Info(c)))
+				return DISCONNECTED;
+		}
+	}
+
 	return IRC_WriteStrClient(Client, RPL_SERVLISTEND_MSG, Client_ID(Client),
 				  Req->argc > 0 ? Req->argv[0] : "*",
 				  Req->argc > 1 ? Req->argv[1] : "0");
@@ -297,7 +354,6 @@ IRC_MOTD( CLIENT *Client, REQUEST *Req )
 	assert( Client != NULL );
 	assert( Req != NULL );
 
-	/* Falsche Anzahl Parameter? */
 	if( Req->argc > 1 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 
 	/* From aus Prefix ermitteln */
@@ -307,7 +363,7 @@ IRC_MOTD( CLIENT *Client, REQUEST *Req )
 
 	if( Req->argc == 1 )
 	{
-		/* an anderen Server forwarden */
+		/* forward? */
 		target = Client_Search( Req->argv[0] );
 		if(( ! target ) || ( Client_Type( target ) != CLIENT_SERVER )) return IRC_WriteStrClient( from, ERR_NOSUCHSERVER_MSG, Client_ID( from ), Req->argv[0] );
 
@@ -333,23 +389,21 @@ IRC_NAMES( CLIENT *Client, REQUEST *Req )
 	assert( Client != NULL );
 	assert( Req != NULL );
 
-	/* Falsche Anzahl Parameter? */
 	if( Req->argc > 2 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 
-	/* From aus Prefix ermitteln */
+	/* use prefix to determine "From" */
 	if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
 	else from = Client;
 	if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
 
 	if( Req->argc == 2 )
 	{
-		/* an anderen Server forwarden */
+		/* forward to another server? */
 		target = Client_Search( Req->argv[1] );
 		if(( ! target ) || ( Client_Type( target ) != CLIENT_SERVER )) return IRC_WriteStrClient( from, ERR_NOSUCHSERVER_MSG, Client_ID( from ), Req->argv[1] );
 
-		if( target != Client_ThisServer( ))
-		{
-			/* Ok, anderer Server ist das Ziel: forwarden */
+		if( target != Client_ThisServer( )) {
+			/* target is another server, forward */
 			return IRC_WriteStrClientPrefix( target, from, "NAMES %s :%s", Req->argv[0], Req->argv[1] );
 		}
 	}
@@ -363,53 +417,48 @@ IRC_NAMES( CLIENT *Client, REQUEST *Req )
 			chan = Channel_Search( ptr );
 			if( chan )
 			{
-				/* Namen ausgeben */
+				/* print name */
 				if( ! IRC_Send_NAMES( from, chan )) return DISCONNECTED;
 			}
 			if( ! IRC_WriteStrClient( from, RPL_ENDOFNAMES_MSG, Client_ID( from ), ptr )) return DISCONNECTED;
 
-			/* naechsten Namen ermitteln */
+			/* get next channel name */
 			ptr = strtok( NULL, "," );
 		}
 		return CONNECTED;
 	}
 
-	/* alle Channels durchgehen */
 	chan = Channel_First( );
 	while( chan )
 	{
-		/* Namen ausgeben */
 		if( ! IRC_Send_NAMES( from, chan )) return DISCONNECTED;
 
-		/* naechster Channel */
 		chan = Channel_Next( chan );
 	}
 
-	/* Nun noch alle Clients ausgeben, die in keinem Channel sind */
+	/* Now print all clients which are not in any channel */
 	c = Client_First( );
 	snprintf( rpl, sizeof( rpl ), RPL_NAMREPLY_MSG, Client_ID( from ), "*", "*" );
 	while( c )
 	{
 		if(( Client_Type( c ) == CLIENT_USER ) && ( Channel_FirstChannelOf( c ) == NULL ) && ( ! strchr( Client_Modes( c ), 'i' )))
 		{
-			/* Okay, das ist ein User: anhaengen */
+			/* its a user, concatenate ... */
 			if( rpl[strlen( rpl ) - 1] != ':' ) strlcat( rpl, " ", sizeof( rpl ));
 			strlcat( rpl, Client_ID( c ), sizeof( rpl ));
 
 			if( strlen( rpl ) > ( LINE_LEN - CLIENT_NICK_LEN - 4 ))
 			{
-				/* Zeile wird zu lang: senden! */
+				/* Line is gwoing too long, send now */
 				if( ! IRC_WriteStrClient( from, "%s", rpl )) return DISCONNECTED;
 				snprintf( rpl, sizeof( rpl ), RPL_NAMREPLY_MSG, Client_ID( from ), "*", "*" );
 			}
 		}
 
-		/* naechster Client */
 		c = Client_Next( c );
 	}
 	if( rpl[strlen( rpl ) - 1] != ':')
 	{
-		/* es wurden User gefunden */
 		if( ! IRC_WriteStrClient( from, "%s", rpl )) return DISCONNECTED;
 	}
 
@@ -427,7 +476,7 @@ t_diff(time_t *t, const time_t d)
 	remain = diff * d;
 	*t -= remain;
 
-	return diff;
+	return (unsigned int)diff;
 }
 
 
@@ -452,6 +501,10 @@ uptime_mins(time_t *now)
 }
 
 
+/**
+ * Handler for the IRC command "STATS".
+ * See RFC 2812 section 3.4.4.
+ */
 GLOBAL bool
 IRC_STATS( CLIENT *Client, REQUEST *Req )
 {
@@ -461,32 +514,37 @@ IRC_STATS( CLIENT *Client, REQUEST *Req )
 	COMMAND *cmd;
 	time_t time_now;
 	unsigned int days, hrs, mins;
+	struct list_head *list;
+	struct list_elem *list_item;
 
-	assert( Client != NULL );
-	assert( Req != NULL );
+	assert(Client != NULL);
+	assert(Req != NULL);
 
-	/* Falsche Anzahl Parameter? */
 	if (Req->argc > 2)
-		return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG, Client_ID(Client), Req->command);
+		return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
+					  Client_ID(Client), Req->command);
 
-	/* From aus Prefix ermitteln */
+	/* use prefix to determine "From" */
 	if (Client_Type(Client) == CLIENT_SERVER)
 		from = Client_Search(Req->prefix);
 	else
 		from = Client;
 
-	if (! from)
-		return IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix);
+	if (!from)
+		return IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG,
+					  Client_ID(Client), Req->prefix);
 
 	if (Req->argc == 2) {
-		/* an anderen Server forwarden */
-		target = Client_Search( Req->argv[1] );
-		if(( ! target ) || ( Client_Type( target ) != CLIENT_SERVER ))
-			return IRC_WriteStrClient( from, ERR_NOSUCHSERVER_MSG, Client_ID( from ), Req->argv[1] );
-
-		if( target != Client_ThisServer()) {
-			/* Ok, anderer Server ist das Ziel: forwarden */
-			return IRC_WriteStrClientPrefix( target, from, "STATS %s %s", Req->argv[0], Req->argv[1] );
+		/* forward to another server? */
+		target = Client_Search(Req->argv[1]);
+		if ((!target) || (Client_Type(target) != CLIENT_SERVER))
+			return IRC_WriteStrClient(from, ERR_NOSUCHSERVER_MSG,
+						 Client_ID(from), Req->argv[1]);
+
+		if (target != Client_ThisServer()) {
+			/* forward to another server */
+			return IRC_WriteStrClientPrefix(target, from,
+				     "STATS %s %s", Req->argv[0], Req->argv[1]);
 		}
 	}
 
@@ -496,57 +554,92 @@ IRC_STATS( CLIENT *Client, REQUEST *Req )
 		query = '*';
 
 	switch (query) {
-		case 'l':	/* Links */
-		case 'L':
-			time_now = time(NULL);
-			for (con = Conn_First(); con != NONE ;con = Conn_Next(con)) {
-				cl = Conn_GetClient(con);
-				if (!cl)
-					continue;
-				if ((Client_Type(cl) == CLIENT_SERVER) || (cl == Client)) {
-					/* Server link or our own connection */
-#ifdef ZLIB
-					if (Conn_Options(con) & CONN_ZIP) {
-						if (!IRC_WriteStrClient(from, RPL_STATSLINKINFOZIP_MSG,
-							Client_ID(from), Client_Mask(cl), Conn_SendQ(con),
-							Conn_SendMsg(con), Zip_SendBytes(con), Conn_SendBytes(con),
-							Conn_RecvMsg(con), Zip_RecvBytes(con), Conn_RecvBytes(con), (long)(time_now - Conn_StartTime(con))))
-								return DISCONNECTED;
-						continue;
-					}
-#endif
-					if (!IRC_WriteStrClient(from, RPL_STATSLINKINFO_MSG, Client_ID(from),
-						Client_Mask(cl), Conn_SendQ(con), Conn_SendMsg(con), Conn_SendBytes(con),
-						Conn_RecvMsg(con), Conn_RecvBytes(con), (long)(time_now - Conn_StartTime(con))))
-							return DISCONNECTED;
-				}
+	case 'g':	/* Network-wide bans ("G-Lines") */
+	case 'G':
+	case 'k':	/* Server-local bans ("K-Lines") */
+	case 'K':
+		if (!Client_HasMode(from, 'o'))
+		    return IRC_WriteStrClient(from, ERR_NOPRIVILEGES_MSG,
+					      Client_ID(from));
+		if (query == 'g' || query == 'G')
+			list = Class_GetList(CLASS_GLINE);
+		else
+			list = Class_GetList(CLASS_KLINE);
+			list_item = Lists_GetFirst(list);
+			while (list_item) {
+				if (!IRC_WriteStrClient(from, RPL_STATSXLINE_MSG,
+						Client_ID(from), query,
+						Lists_GetMask(list_item),
+						Lists_GetValidity(list_item),
+						Lists_GetReason(list_item)))
+					return DISCONNECTED;
+				list_item = Lists_GetNext(list_item);
 			}
-			break;
-		case 'm':	/* IRC-Commands */
-		case 'M':
-			cmd = Parse_GetCommandStruct( );
-			for (; cmd->name ; cmd++) {
-				if (cmd->lcount == 0 && cmd->rcount == 0)
+		break;
+	case 'l':	/* Link status (servers and own link) */
+	case 'L':
+		time_now = time(NULL);
+		for (con = Conn_First(); con != NONE; con = Conn_Next(con)) {
+			cl = Conn_GetClient(con);
+			if (!cl)
+				continue;
+			if ((Client_Type(cl) == CLIENT_SERVER)
+			    || (cl == Client)) {
+				/* Server link or our own connection */
+#ifdef ZLIB
+				if (Conn_Options(con) & CONN_ZIP) {
+					if (!IRC_WriteStrClient
+					    (from, RPL_STATSLINKINFOZIP_MSG,
+					     Client_ID(from), Client_Mask(cl),
+					     Conn_SendQ(con), Conn_SendMsg(con),
+					     Zip_SendBytes(con),
+					     Conn_SendBytes(con),
+					     Conn_RecvMsg(con),
+					     Zip_RecvBytes(con),
+					     Conn_RecvBytes(con),
+					     (long)(time_now - Conn_StartTime(con))))
+						return DISCONNECTED;
 					continue;
-				if (!IRC_WriteStrClient(from, RPL_STATSCOMMANDS_MSG, Client_ID(from),
-						cmd->name, cmd->lcount, cmd->bytes, cmd->rcount))
-							return DISCONNECTED;
+				}
+#endif
+				if (!IRC_WriteStrClient
+				    (from, RPL_STATSLINKINFO_MSG,
+				     Client_ID(from), Client_Mask(cl),
+				     Conn_SendQ(con), Conn_SendMsg(con),
+				     Conn_SendBytes(con), Conn_RecvMsg(con),
+				     Conn_RecvBytes(con),
+				     (long)(time_now - Conn_StartTime(con))))
+					return DISCONNECTED;
 			}
-			break;
-		case 'u':	/* server uptime */
-		case 'U':
-			time_now = time(NULL) - NGIRCd_Start;
-			days = uptime_days(&time_now);
-			hrs = uptime_hrs(&time_now);
-			mins = uptime_mins(&time_now);
-			if (!IRC_WriteStrClient(from, RPL_STATSUPTIME, Client_ID(from),
-					days, hrs, mins, (unsigned int) time_now))
-						return DISCONNECTED;
-			break;
+		}
+		break;
+	case 'm':	/* IRC command status (usage count) */
+	case 'M':
+		cmd = Parse_GetCommandStruct();
+		for (; cmd->name; cmd++) {
+			if (cmd->lcount == 0 && cmd->rcount == 0)
+				continue;
+			if (!IRC_WriteStrClient
+			    (from, RPL_STATSCOMMANDS_MSG, Client_ID(from),
+			     cmd->name, cmd->lcount, cmd->bytes, cmd->rcount))
+				return DISCONNECTED;
+		}
+		break;
+	case 'u':	/* Server uptime */
+	case 'U':
+		time_now = time(NULL) - NGIRCd_Start;
+		days = uptime_days(&time_now);
+		hrs = uptime_hrs(&time_now);
+		mins = uptime_mins(&time_now);
+		if (!IRC_WriteStrClient(from, RPL_STATSUPTIME, Client_ID(from),
+				       days, hrs, mins, (unsigned int)time_now))
+			return DISCONNECTED;
+		break;
 	}
 
 	IRC_SetPenalty(from, 2);
-	return IRC_WriteStrClient(from, RPL_ENDOFSTATS_MSG, Client_ID(from), query);
+	return IRC_WriteStrClient(from, RPL_ENDOFSTATS_MSG,
+				  Client_ID(from), query);
 } /* IRC_STATS */
 
 
@@ -556,10 +649,10 @@ IRC_STATS( CLIENT *Client, REQUEST *Req )
  * therefore answers with ERR_SUMMONDISABLED.
  */
 GLOBAL bool
-IRC_SUMMON(CLIENT * Client, REQUEST * Req)
+IRC_SUMMON(CLIENT * Client, UNUSED REQUEST * Req)
 {
 	return IRC_WriteStrClient(Client, ERR_SUMMONDISABLED_MSG,
-				  Client_ID(Client), Req->command);
+				  Client_ID(Client));
 } /* IRC_SUMMON */
 
 
@@ -573,23 +666,19 @@ IRC_TIME( CLIENT *Client, REQUEST *Req )
 	assert( Client != NULL );
 	assert( Req != NULL );
 
-	/* Falsche Anzahl Parameter? */
 	if( Req->argc > 1 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 
-	/* From aus Prefix ermitteln */
 	if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
 	else from = Client;
 	if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
 
 	if( Req->argc == 1 )
 	{
-		/* an anderen Server forwarden */
 		target = Client_Search( Req->argv[0] );
 		if(( ! target ) || ( Client_Type( target ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->argv[0] );
 
 		if( target != Client_ThisServer( ))
 		{
-			/* Ok, anderer Server ist das Ziel: forwarden */
 			return IRC_WriteStrClientPrefix( target, from, "TIME %s", Req->argv[0] );
 		}
 	}
@@ -600,43 +689,51 @@ IRC_TIME( CLIENT *Client, REQUEST *Req )
 } /* IRC_TIME */
 
 
+/**
+ * Handler for the IRC command "USERHOST".
+ * See RFC 2812 section 4.8.
+ */
 GLOBAL bool
-IRC_USERHOST( CLIENT *Client, REQUEST *Req )
+IRC_USERHOST(CLIENT *Client, REQUEST *Req)
 {
 	char rpl[COMMAND_LEN];
 	CLIENT *c;
 	int max, i;
 
-	assert( Client != NULL );
-	assert( Req != NULL );
-
-	/* Falsche Anzahl Parameter? */
-	if(( Req->argc < 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
+	assert(Client != NULL);
+	assert(Req != NULL);
 
-	if( Req->argc > 5 ) max = 5;
-	else max = Req->argc;
+	if ((Req->argc < 1))
+		return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
+					  Client_ID(Client), Req->command);
 
-	strlcpy( rpl, RPL_USERHOST_MSG, sizeof rpl );
-	for( i = 0; i < max; i++ )
-	{
-		c = Client_Search( Req->argv[i] );
-		if( c && ( Client_Type( c ) == CLIENT_USER ))
-		{
-			/* Dieser Nick ist "online" */
-			strlcat( rpl, Client_ID( c ), sizeof( rpl ));
-			if( Client_HasMode( c, 'o' )) strlcat( rpl, "*", sizeof( rpl ));
-			strlcat( rpl, "=", sizeof( rpl ));
-			if( Client_HasMode( c, 'a' )) strlcat( rpl, "-", sizeof( rpl ));
-			else strlcat( rpl, "+", sizeof( rpl ));
-			strlcat( rpl, Client_User( c ), sizeof( rpl ));
-			strlcat( rpl, "@", sizeof( rpl ));
-			strlcat( rpl, Client_Hostname( c ), sizeof( rpl ));
-			strlcat( rpl, " ", sizeof( rpl ));
+	if (Req->argc > 5)
+		max = 5;
+	else
+		max = Req->argc;
+
+	strlcpy(rpl, RPL_USERHOST_MSG, sizeof rpl);
+	for (i = 0; i < max; i++) {
+		c = Client_Search(Req->argv[i]);
+		if (c && (Client_Type(c) == CLIENT_USER)) {
+			/* This Nick is "online" */
+			strlcat(rpl, Client_ID(c), sizeof(rpl));
+			if (Client_HasMode(c, 'o'))
+				strlcat(rpl, "*", sizeof(rpl));
+			strlcat(rpl, "=", sizeof(rpl));
+			if (Client_HasMode(c, 'a'))
+				strlcat(rpl, "-", sizeof(rpl));
+			else
+				strlcat(rpl, "+", sizeof(rpl));
+			strlcat(rpl, Client_User(c), sizeof(rpl));
+			strlcat(rpl, "@", sizeof(rpl));
+			strlcat(rpl, Client_HostnameCloaked(c), sizeof(rpl));
+			strlcat(rpl, " ", sizeof(rpl));
 		}
 	}
-	ngt_TrimLastChr( rpl, ' ');
+	ngt_TrimLastChr(rpl, ' ');
 
-	return IRC_WriteStrClient( Client, rpl, Client_ID( Client ) );
+	return IRC_WriteStrClient(Client, rpl, Client_ID(Client));
 } /* IRC_USERHOST */
 
 
@@ -645,10 +742,10 @@ IRC_USERHOST( CLIENT *Client, REQUEST *Req )
  * See RFC 2812 section 4.6. As suggested there the command is disabled.
  */
 GLOBAL bool
-IRC_USERS(CLIENT * Client, REQUEST * Req)
+IRC_USERS(CLIENT * Client, UNUSED REQUEST * Req)
 {
 	return IRC_WriteStrClient(Client, ERR_USERSDISABLED_MSG,
-				  Client_ID(Client), Req->command);
+				  Client_ID(Client));
 } /* IRC_USERS */
 
 
@@ -660,7 +757,6 @@ IRC_VERSION( CLIENT *Client, REQUEST *Req )
 	assert( Client != NULL );
 	assert( Req != NULL );
 
-	/* Falsche Anzahl Parameter? */
 	if(( Req->argc > 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 
 	/* Ziel suchen */
@@ -694,9 +790,11 @@ IRC_VERSION( CLIENT *Client, REQUEST *Req )
 static bool
 write_whoreply(CLIENT *Client, CLIENT *c, const char *channelname, const char *flags)
 {
-	return IRC_WriteStrClient(Client, RPL_WHOREPLY_MSG, Client_ID(Client), channelname,
-			Client_User(c), Client_Hostname(c), Client_ID(Client_Introducer(c)), Client_ID(c),
-			flags, Client_Hops(c), Client_Info(c));
+	return IRC_WriteStrClient(Client, RPL_WHOREPLY_MSG, Client_ID(Client),
+				  channelname, Client_User(c),
+				  Client_HostnameCloaked(c),
+				  Client_ID(Client_Introducer(c)), Client_ID(c),
+				  flags, Client_Hops(c), Client_Info(c));
 }
 
 
@@ -709,35 +807,80 @@ who_flags_status(const char *client_modes)
 }
 
 
-static const char *
-who_flags_qualifier(const char *chan_user_modes)
+/**
+ * Return channel user mode prefix(es).
+ *
+ * @param Client The client requesting the mode prefixes.
+ * @param chan_user_modes String with channel user modes.
+ * @param str String buffer to which the prefix(es) will be appended.
+ * @param len Size of "str" buffer.
+ * @return Pointer to "str".
+ */
+static char *
+who_flags_qualifier(CLIENT *Client, const char *chan_user_modes,
+		    char *str, size_t len)
 {
-	if (strchr(chan_user_modes, 'o'))
-		return "@";
+	assert(Client != NULL);
+
+	if (Client_Cap(Client) & CLIENT_CAP_MULTI_PREFIX) {
+		if (strchr(chan_user_modes, 'q'))
+			strlcat(str, "~", len);
+		if (strchr(chan_user_modes, 'a'))
+			strlcat(str, "&", len);
+		if (strchr(chan_user_modes, 'o'))
+			strlcat(str, "@", len);
+		if (strchr(chan_user_modes, 'h'))
+			strlcat(str, "%", len);
+		if (strchr(chan_user_modes, 'v'))
+			strlcat(str, "+", len);
+
+		return str;
+	}
+
+	if (strchr(chan_user_modes, 'q'))
+		strlcat(str, "~", len);
+	else if (strchr(chan_user_modes, 'a'))
+		strlcat(str, "&", len);
+	else if (strchr(chan_user_modes, 'o'))
+		strlcat(str, "@", len);
+	else if (strchr(chan_user_modes, 'h'))
+		strlcat(str, "%", len);
 	else if (strchr(chan_user_modes, 'v'))
-		return "+";
-	return "";
+		strlcat(str, "+", len);
+
+	return str;
 }
 
 
+/**
+ * Send WHO reply for a "channel target" ("WHO #channel").
+ *
+ * @param Client Client requesting the information.
+ * @param Chan Channel being requested.
+ * @param OnlyOps Only display IRC operators.
+ * @return CONNECTED or DISCONNECTED.
+ */
 static bool
-IRC_Send_WHO(CLIENT *Client, CHANNEL *Chan, bool OnlyOps)
+IRC_WHO_Channel(CLIENT *Client, CHANNEL *Chan, bool OnlyOps)
 {
 	bool is_visible, is_member, is_ircop;
 	CL2CHAN *cl2chan;
 	const char *client_modes;
-	const char *chan_user_modes;
-	char flags[8];
+	char flags[10];
 	CLIENT *c;
+	int count = 0;
 
 	assert( Client != NULL );
 	assert( Chan != NULL );
 
+	IRC_SetPenalty(Client, 1);
+
 	is_member = Channel_IsMemberOf(Chan, Client);
 
 	/* Secret channel? */
 	if (!is_member && strchr(Channel_Modes(Chan), 's'))
-		return IRC_WriteStrClient(Client, RPL_ENDOFWHO_MSG, Client_ID(Client), Channel_Name(Chan));
+		return IRC_WriteStrClient(Client, RPL_ENDOFWHO_MSG,
+					  Client_ID(Client), Channel_Name(Chan));
 
 	cl2chan = Channel_FirstMember(Chan);
 	for (; cl2chan ; cl2chan = Channel_NextMember(Chan, cl2chan)) {
@@ -754,228 +897,414 @@ IRC_Send_WHO(CLIENT *Client, CHANNEL *Chan, bool OnlyOps)
 			if (is_ircop)
 				strlcat(flags, "*", sizeof(flags));
 
-			chan_user_modes = Channel_UserModes(Chan, c);
-			strlcat(flags, who_flags_qualifier(chan_user_modes), sizeof(flags));
+			who_flags_qualifier(Client, Channel_UserModes(Chan, c),
+					    flags, sizeof(flags));
 
-			if (!write_whoreply(Client, c, Channel_Name(Chan), flags))
+			if (!write_whoreply(Client, c, Channel_Name(Chan),
+					    flags))
 				return DISCONNECTED;
+			count++;
 		}
 	}
-	return IRC_WriteStrClient(Client, RPL_ENDOFWHO_MSG, Client_ID(Client), Channel_Name(Chan));
-} /* IRC_Send_WHO */
-
 
-GLOBAL bool
-IRC_WHO( CLIENT *Client, REQUEST *Req )
-{
-	bool only_ops, have_arg, client_match;
-	const char *channelname, *client_modes, *chan_user_modes;
-	char pattern[COMMAND_LEN];
-	char flags[4];
-	CL2CHAN *cl2chan;
-	CHANNEL *chan, *cn;
-	CLIENT *c;
+	/* If there are a lot of clients, augment penalty a bit */
+	if (count > MAX_RPL_WHO)
+		IRC_SetPenalty(Client, 1);
 
-	assert( Client != NULL );
-	assert( Req != NULL );
+	return IRC_WriteStrClient(Client, RPL_ENDOFWHO_MSG, Client_ID(Client),
+				  Channel_Name(Chan));
+}
 
-	if (Req->argc > 2)
-		return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 
-	only_ops = false;
-	have_arg = false;
+/**
+ * Send WHO reply for a "mask target" ("WHO m*sk").
+ *
+ * @param Client Client requesting the information.
+ * @param Mask Mask being requested or NULL for "all" clients.
+ * @param OnlyOps Only display IRC operators.
+ * @return CONNECTED or DISCONNECTED.
+ */
+static bool
+IRC_WHO_Mask(CLIENT *Client, char *Mask, bool OnlyOps)
+{
+	CLIENT *c;
+	CL2CHAN *cl2chan;
+	CHANNEL *chan;
+	bool client_match, is_visible;
+	char flags[4];
+	int count = 0;
 
-	if (Req->argc == 2) {
-		if (strcmp(Req->argv[1], "o") == 0)
-			only_ops = true;
-#ifdef STRICT_RFC
-		else return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG, Client_ID(Client), Req->command);
-#endif
-	}
+	assert (Client != NULL);
 
-	IRC_SetPenalty(Client, 1);
-	if (Req->argc >= 1) { /* Channel or Mask. */
-		chan = Channel_Search(Req->argv[0]);
-		if (chan)
-			return IRC_Send_WHO(Client, chan, only_ops);
-		if (strcmp(Req->argv[0], "0") != 0) { /* RFC stupidity, same as no arguments */
-			have_arg = true;
-			strlcpy(pattern, Req->argv[0], sizeof(pattern));
-			ngt_LowerStr(pattern);
-			IRC_SetPenalty(Client, 3);
-		}
-	}
+	if (Mask)
+		ngt_LowerStr(Mask);
 
+	IRC_SetPenalty(Client, 3);
 	for (c = Client_First(); c != NULL; c = Client_Next(c)) {
 		if (Client_Type(c) != CLIENT_USER)
 			continue;
-		 /*
-		  * RFC 2812, 3.6.1:
-		  * In the absence of the parameter, all visible (users who aren't
-		  * invisible (user mode +i) and who don't have a common channel
-		  * with the requesting client) are listed.
-		  *
-		  * The same result can be achieved by using a [sic] of "0"
-		  * or any wildcard which will end up matching every visible user.
-		  *
-		  * The [sic] passed to WHO is matched against users' host, server, real name and
-		  * nickname if the channel cannot be found.
-		  */
-		client_modes = Client_Modes(c);
-		if (strchr(client_modes, 'i'))
-			continue;
 
-		if (only_ops && !strchr(client_modes, 'o'))
+		if (OnlyOps && !Client_HasMode(c, 'o'))
 			continue;
 
-		if (have_arg) { /* match pattern against user host/server/name/nick */
-			client_match = MatchCaseInsensitive(pattern, Client_Hostname(c)); /* user's host */
+		if (Mask) {
+			/* Match pattern against user host/server/name/nick */
+			client_match = MatchCaseInsensitive(Mask,
+						Client_Hostname(c));
 			if (!client_match)
-				client_match = MatchCaseInsensitive(pattern, Client_ID(Client_Introducer(c))); /* server */
+				client_match = MatchCaseInsensitive(Mask,
+						Client_ID(Client_Introducer(c)));
 			if (!client_match)
-				client_match = Match(Req->argv[0], Client_Info(c)); /* realname */
+				client_match = MatchCaseInsensitive(Mask,
+						Client_Info(c));
 			if (!client_match)
-				client_match = MatchCaseInsensitive(pattern, Client_ID(c)); /* nick name */
-
-			if (!client_match) /* This isn't the client you're looking for */
-				continue;
+				client_match = MatchCaseInsensitive(Mask,
+						Client_ID(c));
+			if (!client_match)
+				continue;	/* no match: skip this client */
 		}
 
-		strcpy(flags, who_flags_status(client_modes));
+		is_visible = !Client_HasMode(c, 'i');
 
-		if (strchr(client_modes, 'o')) /* this client is an operator */
-			strlcat(flags, "*", sizeof(flags));
+		/* Target client is invisible, but mask matches exactly? */
+		if (!is_visible && Mask && strcasecmp(Client_ID(c), Mask) == 0)
+			is_visible = true;
 
-		/* Search suitable channel */
-		cl2chan = Channel_FirstChannelOf(c);
-		while (cl2chan) {
-			cn = Channel_GetChannel(cl2chan);
-			if (Channel_IsMemberOf(cn, Client) ||
-				    !strchr(Channel_Modes(cn), 's'))
-			{
-				channelname = Channel_Name(cn);
-				break;
+		/* Target still invisible, but are both on the same channel? */
+		if (!is_visible) {
+			cl2chan = Channel_FirstChannelOf(Client);
+			while (cl2chan && !is_visible) {
+				chan = Channel_GetChannel(cl2chan);
+				if (Channel_IsMemberOf(chan, c))
+					is_visible = true;
+				cl2chan = Channel_NextChannelOf(Client, cl2chan);
 			}
-			cl2chan = Channel_NextChannelOf(c, cl2chan);
 		}
-		if (cl2chan) {
-			chan = Channel_GetChannel(cl2chan);
-			chan_user_modes = Channel_UserModes(chan, c);
-			strlcat(flags, who_flags_qualifier(chan_user_modes), sizeof(flags));
-		} else
-			channelname = "*";
-
-		if (!write_whoreply(Client, c, channelname, flags))
+
+		if (!is_visible)	/* target user is not visible */
+			continue;
+
+		if (IRC_CheckListTooBig(Client, count, MAX_RPL_WHO, "WHO"))
+			break;
+
+		strcpy(flags, who_flags_status(Client_Modes(c)));
+		if (strchr(Client_Modes(c), 'o'))
+			strlcat(flags, "*", sizeof(flags));
+
+		if (!write_whoreply(Client, c, "*", flags))
 			return DISCONNECTED;
+		count++;
 	}
 
-	if (Req->argc > 0)
-		channelname = Req->argv[0];
-	else
-		channelname = "*";
-
-	return IRC_WriteStrClient(Client, RPL_ENDOFWHO_MSG, Client_ID(Client), channelname);
-} /* IRC_WHO */
+	return IRC_WriteStrClient(Client, RPL_ENDOFWHO_MSG, Client_ID(Client),
+				  Mask ? Mask : "*");
+}
 
 
+/**
+ * Handler for the IRC "WHO" command.
+ *
+ * See RFC 2812, 3.6.1 "Who query".
+ *
+ * @param Client The client from which this command has been received.
+ * @param Req Request structure with prefix and all parameters.
+ * @return CONNECTED or DISCONNECTED.
+ */
 GLOBAL bool
-IRC_WHOIS( CLIENT *Client, REQUEST *Req )
+IRC_WHO(CLIENT *Client, REQUEST *Req)
 {
-	CLIENT *from, *target, *c;
-	char str[LINE_LEN + 1];
-	CL2CHAN *cl2chan;
+	bool only_ops;
 	CHANNEL *chan;
 
-	assert( Client != NULL );
-	assert( Req != NULL );
+	assert (Client != NULL);
+	assert (Req != NULL);
 
-	/* Bad number of parameters? */
-	if(( Req->argc < 1 ) || ( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
+	if (Req->argc > 2)
+		return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
+					  Client_ID(Client), Req->command);
 
-	/* Search client */
-	c = Client_Search( Req->argv[Req->argc - 1] );
-	if(( ! c ) || ( Client_Type( c ) != CLIENT_USER )) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->argv[Req->argc - 1] );
+	only_ops = false;
 
-	/* Search sender of the WHOIS */
-	if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
-	else from = Client;
-	if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
+	if (Req->argc == 2) {
+		if (strcmp(Req->argv[1], "o") == 0)
+			only_ops = true;
+#ifdef STRICT_RFC
+		else
+			return IRC_WriteStrClient(Client,
+						  ERR_NEEDMOREPARAMS_MSG,
+						  Client_ID(Client),
+						  Req->command);
+#endif
+	}
 
-	/* Forward to other server? */
-	if( Req->argc > 1 )
-	{
-		/* Search target server (can be specified as nick of that server!) */
-		target = Client_Search( Req->argv[0] );
-		if( ! target ) return IRC_WriteStrClient( from, ERR_NOSUCHSERVER_MSG, Client_ID( from ), Req->argv[0] );
+	IRC_SetPenalty(Client, 1);
+	if (Req->argc >= 1) {
+		/* Channel or mask given */
+		chan = Channel_Search(Req->argv[0]);
+		if (chan) {
+			/* Members of a channel have been requested */
+			return IRC_WHO_Channel(Client, chan, only_ops);
+		}
+		if (strcmp(Req->argv[0], "0") != 0) {
+			/* A mask has been given. But please note this RFC
+			 * stupidity: "0" is same as no arguments ... */
+			return IRC_WHO_Mask(Client, Req->argv[0], only_ops);
+		}
 	}
-	else target = Client_ThisServer( );
 
-	assert( target != NULL );
+	/* No channel or (valid) mask given */
+	IRC_SetPenalty(Client, 2);
+	return IRC_WHO_Mask(Client, NULL, only_ops);
+} /* IRC_WHO */
+
+
+/**
+ * Generate WHOIS reply of one actual client.
+ *
+ * @param Client The client from which this command has been received.
+ * @param from The client requesting the information ("originator").
+ * @param c The client of which information should be returned.
+ * @return CONNECTED or DISCONNECTED.
+ */
+static bool
+IRC_WHOIS_SendReply(CLIENT *Client, CLIENT *from, CLIENT *c)
+{
+	char str[LINE_LEN + 1];
+	CL2CHAN *cl2chan;
+	CHANNEL *chan;
 
-	if(( Client_NextHop( target ) != Client_ThisServer( )) && ( Client_Type( Client_NextHop( target )) == CLIENT_SERVER )) return IRC_WriteStrClientPrefix( target, from, "WHOIS %s :%s", Req->argv[0], Req->argv[1] );
+	assert(Client != NULL);
+	assert(from != NULL);
+	assert(c != NULL);
 
-	/* Nick, user and name */
-	if( ! IRC_WriteStrClient( from, RPL_WHOISUSER_MSG, Client_ID( from ), Client_ID( c ), Client_User( c ), Client_Hostname( c ), Client_Info( c ))) return DISCONNECTED;
+	/* Nick, user, hostname and client info */
+	if (!IRC_WriteStrClient(from, RPL_WHOISUSER_MSG, Client_ID(from),
+				Client_ID(c), Client_User(c),
+				Client_HostnameCloaked(c), Client_Info(c)))
+		return DISCONNECTED;
 
 	/* Server */
-	if( ! IRC_WriteStrClient( from, RPL_WHOISSERVER_MSG, Client_ID( from ), Client_ID( c ), Client_ID( Client_Introducer( c )), Client_Info( Client_Introducer( c )))) return DISCONNECTED;
+	if (!IRC_WriteStrClient(from, RPL_WHOISSERVER_MSG, Client_ID(from),
+				Client_ID(c), Client_ID(Client_Introducer(c)),
+				Client_Info(Client_Introducer(c))))
+		return DISCONNECTED;
 
 	/* Channels */
-	snprintf( str, sizeof( str ), RPL_WHOISCHANNELS_MSG, Client_ID( from ), Client_ID( c ));
-	cl2chan = Channel_FirstChannelOf( c );
-	while( cl2chan )
-	{
-		chan = Channel_GetChannel( cl2chan );
-		assert( chan != NULL );
+	snprintf(str, sizeof(str), RPL_WHOISCHANNELS_MSG,
+		 Client_ID(from), Client_ID(c));
+	cl2chan = Channel_FirstChannelOf(c);
+	while (cl2chan) {
+		chan = Channel_GetChannel(cl2chan);
+		assert(chan != NULL);
 
 		/* next */
-		cl2chan = Channel_NextChannelOf( c, cl2chan );
+		cl2chan = Channel_NextChannelOf(c, cl2chan);
 
 		/* Secret channel? */
-		if( strchr( Channel_Modes( chan ), 's' ) && ! Channel_IsMemberOf( chan, Client )) continue;
+		if (strchr(Channel_Modes(chan), 's')
+		    && !Channel_IsMemberOf(chan, Client))
+			continue;
+
+		/* Local channel and request is not from a user? */
+		if (Client_Type(Client) == CLIENT_SERVER
+		    && Channel_IsLocal(chan))
+			continue;
 
 		/* Concatenate channel names */
-		if( str[strlen( str ) - 1] != ':' ) strlcat( str, " ", sizeof( str ));
-		if( strchr( Channel_UserModes( chan, c ), 'o' )) strlcat( str, "@", sizeof( str ));
-		else if( strchr( Channel_UserModes( chan, c ), 'v' )) strlcat( str, "+", sizeof( str ));
-		strlcat( str, Channel_Name( chan ), sizeof( str ));
+		if (str[strlen(str) - 1] != ':')
+			strlcat(str, " ", sizeof(str));
 
-		if( strlen( str ) > ( LINE_LEN - CHANNEL_NAME_LEN - 4 ))
-		{
+		who_flags_qualifier(Client, Channel_UserModes(chan, c),
+				    str, sizeof(str));
+		strlcat(str, Channel_Name(chan), sizeof(str));
+
+		if (strlen(str) > (LINE_LEN - CHANNEL_NAME_LEN - 4)) {
 			/* Line becomes too long: send it! */
-			if( ! IRC_WriteStrClient( Client, "%s", str )) return DISCONNECTED;
-			snprintf( str, sizeof( str ), RPL_WHOISCHANNELS_MSG, Client_ID( from ), Client_ID( c ));
+			if (!IRC_WriteStrClient(Client, "%s", str))
+				return DISCONNECTED;
+			snprintf(str, sizeof(str), RPL_WHOISCHANNELS_MSG,
+				 Client_ID(from), Client_ID(c));
 		}
 	}
-	if( str[strlen( str ) - 1] != ':')
-	{
+	if(str[strlen(str) - 1] != ':') {
 		/* There is data left to send: */
-		if( ! IRC_WriteStrClient( Client, "%s", str )) return DISCONNECTED;
+		if (!IRC_WriteStrClient(Client, "%s", str))
+			return DISCONNECTED;
 	}
 
 	/* IRC-Operator? */
-	if( Client_HasMode( c, 'o' ))
-	{
-		if( ! IRC_WriteStrClient( from, RPL_WHOISOPERATOR_MSG, Client_ID( from ), Client_ID( c ))) return DISCONNECTED;
+	if (Client_HasMode(c, 'o') &&
+	    !IRC_WriteStrClient(from, RPL_WHOISOPERATOR_MSG,
+				Client_ID(from), Client_ID(c)))
+		return DISCONNECTED;
+
+	/* IRC-Bot? */
+	if (Client_HasMode(c, 'B') &&
+	    !IRC_WriteStrClient(from, RPL_WHOISBOT_MSG,
+				Client_ID(from), Client_ID(c)))
+		return DISCONNECTED;
+
+	/* Connected using SSL? */
+	if (Conn_UsesSSL(Client_Conn(c)) &&
+	    !IRC_WriteStrClient(from, RPL_WHOISSSL_MSG, Client_ID(from),
+				Client_ID(c)))
+		return DISCONNECTED;
+
+	/* Registered nickname? */
+	if (Client_HasMode(c, 'R') &&
+	    !IRC_WriteStrClient(from, RPL_WHOISREGNICK_MSG,
+				Client_ID(from), Client_ID(c)))
+		return DISCONNECTED;
+
+	/* Local client and requester is the user itself or an IRC Op? */
+	if (Client_Conn(c) > NONE &&
+	    (from == c || (!Conf_MorePrivacy && Client_HasMode(from, 'o')))) {
+		/* Client hostname */
+		if (!IRC_WriteStrClient(from, RPL_WHOISHOST_MSG,
+		    Client_ID(from), Client_ID(c), Client_Hostname(c),
+		    Conn_GetIPAInfo(Client_Conn(c))))
+			return DISCONNECTED;
+		/* Client modes */
+		if (!IRC_WriteStrClient(from, RPL_WHOISMODES_MSG,
+		    Client_ID(from), Client_ID(c), Client_Modes(c)))
+			return DISCONNECTED;
 	}
 
 	/* Idle and signon time (local clients only!) */
-	if (Client_Conn(c) > NONE ) {
-		if (! IRC_WriteStrClient(from, RPL_WHOISIDLE_MSG,
-			Client_ID(from), Client_ID(c),
-			(unsigned long)Conn_GetIdle(Client_Conn(c)),
-			(unsigned long)Conn_GetSignon(Client_Conn(c))))
-				return DISCONNECTED;
-	}
+	if (!Conf_MorePrivacy && Client_Conn(c) > NONE &&
+	    !IRC_WriteStrClient(from, RPL_WHOISIDLE_MSG,
+				Client_ID(from), Client_ID(c),
+				(unsigned long)Conn_GetIdle(Client_Conn(c)),
+				(unsigned long)Conn_GetSignon(Client_Conn(c))))
+		return DISCONNECTED;
 
 	/* Away? */
-	if( Client_HasMode( c, 'a' ))
-	{
-		if( ! IRC_WriteStrClient( from, RPL_AWAY_MSG, Client_ID( from ), Client_ID( c ), Client_Away( c ))) return DISCONNECTED;
+	if (Client_HasMode(c, 'a') &&
+	    !IRC_WriteStrClient(from, RPL_AWAY_MSG,
+				Client_ID(from), Client_ID(c), Client_Away(c)))
+		return DISCONNECTED;
+
+	return CONNECTED;
+} /* IRC_WHOIS_SendReply */
+
+
+/**
+ * Handler for the IRC "WHOIS" command.
+ *
+ * See RFC 2812, 3.6.2 "Whois query".
+ *
+ * @param Client	The client from which this command has been received.
+ * @param Req		Request structure with prefix and all parameters.
+ * @return		CONNECTED or DISCONNECTED.
+ */
+GLOBAL bool
+IRC_WHOIS( CLIENT *Client, REQUEST *Req )
+{
+	CLIENT *from, *target, *c;
+	unsigned int match_count = 0, found = 0;
+	bool has_wildcards, is_remote;
+	bool got_wildcard = false;
+	char mask[COMMAND_LEN], *query;
+
+	assert( Client != NULL );
+	assert( Req != NULL );
+
+	/* Bad number of parameters? */
+	if (Req->argc < 1 || Req->argc > 2)
+		return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
+					  Client_ID(Client), Req->command);
+
+	/* Search sender of the WHOIS */
+	if (Client_Type(Client) == CLIENT_SERVER) {
+		from = Client_Search(Req->prefix);
+	} else {
+		IRC_SetPenalty(Client, 1);
+		from = Client;
 	}
+	if (!from)
+		return IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG,
+					  Client_ID(Client), Req->prefix);
 
-	/* End of Whois */
-	return IRC_WriteStrClient( from, RPL_ENDOFWHOIS_MSG, Client_ID( from ), Client_ID( c ));
+	/* Get target server for this command */
+	if (Req->argc > 1) {
+		/* Search the target server, which can be specified as a
+		 * nickname on that server as well: */
+		target = Client_Search(Req->argv[0]);
+		if (!target)
+			return IRC_WriteStrClient(from, ERR_NOSUCHSERVER_MSG,
+						Client_ID(from), Req->argv[0]);
+	} else
+		target = Client_ThisServer();
+	assert(target != NULL);
+
+	/* Forward to other server? */
+	if (Client_NextHop(target) != Client_ThisServer() &&
+	    Client_Type(Client_NextHop(target)) == CLIENT_SERVER)
+		return IRC_WriteStrClientPrefix(target, from,
+						"WHOIS %s :%s",
+						Req->argv[0], Req->argv[1]);
+
+	is_remote = Client_Conn(from) < 0;
+	strlcpy(mask, Req->argv[Req->argc - 1], sizeof(mask));
+	for (query = strtok(ngt_LowerStr(mask), ",");
+			query && found < 3;
+			query = strtok(NULL, ","), found++)
+	{
+		has_wildcards = query[strcspn(query, "*?")] != 0;
+		/*
+		 * follows ircd 2.10 implementation:
+		 *  - handle up to 3 targets
+		 *  - no wildcards for remote clients
+		 *  - only one wildcard target per local client
+		 *
+		 *  Also, at most MAX_RPL_WHOIS matches are returned.
+		 */
+		if (!has_wildcards || is_remote) {
+			c = Client_Search(query);
+			if (c && Client_Type(c) == CLIENT_USER) {
+				if (!IRC_WHOIS_SendReply(Client, from, c))
+					return DISCONNECTED;
+			} else {
+				if (!IRC_WriteStrClient(Client,
+							ERR_NOSUCHNICK_MSG,
+							Client_ID(Client),
+							query))
+					return DISCONNECTED;
+			}
+			continue;
+		}
+		if (got_wildcard) {
+			/* we already handled one wildcard query */
+			if (!IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG,
+			     Client_ID(Client), query))
+				return DISCONNECTED;
+			continue;
+		}
+		got_wildcard = true;
+		IRC_SetPenalty(Client, 3);
+
+		for (c = Client_First(); c; c = Client_Next(c)) {
+			if (IRC_CheckListTooBig(Client, match_count,
+					    MAX_RPL_WHOIS, "WHOIS"))
+				break;
+
+			if (Client_Type(c) != CLIENT_USER)
+				continue;
+			if (!MatchCaseInsensitive(query, Client_ID(c)))
+				continue;
+			if (!IRC_WHOIS_SendReply(Client, from, c))
+				return DISCONNECTED;
+
+			match_count++;
+		}
+
+		if (match_count == 0)
+			IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG,
+					   Client_ID(Client),
+					   Req->argv[Req->argc - 1]);
+	}
+	return IRC_WriteStrClient(from, RPL_ENDOFWHOIS_MSG,
+				  Client_ID(from), Req->argv[Req->argc - 1]);
 } /* IRC_WHOIS */
 
 
@@ -1012,6 +1341,10 @@ IRC_WHOWAS( CLIENT *Client, REQUEST *Req )
 	assert( Client != NULL );
 	assert( Req != NULL );
 
+	/* Do not reveal any info on disconnected users? */
+	if (Conf_MorePrivacy)
+		return CONNECTED;
+
 	/* Wrong number of parameters? */
 	if (Req->argc > 3)
 		return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
@@ -1053,11 +1386,11 @@ IRC_WHOWAS( CLIENT *Client, REQUEST *Req )
 	if (last < 0)
 		last = 0;
 
-	max = DEFAULT_WHOWAS;
+	max = DEF_RPL_WHOWAS;
 	if (Req->argc > 1) {
 		max = atoi(Req->argv[1]);
 		if (max < 1)
-			max = MAX_WHOWAS;
+			max = MAX_RPL_WHOWAS;
 	}
 
 	/*
@@ -1096,38 +1429,55 @@ IRC_WHOWAS( CLIENT *Client, REQUEST *Req )
 } /* IRC_WHOWAS */
 
 
+/**
+ * Send LUSERS reply to a client.
+ *
+ * @param Client The receipient of the information.
+ * @return CONNECTED or DISCONNECTED.
+ */
 GLOBAL bool
-IRC_Send_LUSERS( CLIENT *Client )
+IRC_Send_LUSERS(CLIENT *Client)
 {
 	unsigned long cnt;
 #ifndef STRICT_RFC
 	unsigned long max;
 #endif
 
-	assert( Client != NULL );
+	assert(Client != NULL);
 
 	/* Users, services and serevers in the network */
-	if( ! IRC_WriteStrClient( Client, RPL_LUSERCLIENT_MSG, Client_ID( Client ), Client_UserCount( ), Client_ServiceCount( ), Client_ServerCount( ))) return DISCONNECTED;
+	if (!IRC_WriteStrClient(Client, RPL_LUSERCLIENT_MSG, Client_ID(Client),
+				Client_UserCount(), Client_ServiceCount(),
+				Client_ServerCount()))
+		return DISCONNECTED;
 
 	/* Number of IRC operators */
 	cnt = Client_OperCount( );
-	if( cnt > 0 )
-	{
-		if( ! IRC_WriteStrClient( Client, RPL_LUSEROP_MSG, Client_ID( Client ), cnt )) return DISCONNECTED;
+	if (cnt > 0) {
+		if (!IRC_WriteStrClient(Client, RPL_LUSEROP_MSG,
+					Client_ID(Client), cnt))
+			return DISCONNECTED;
 	}
 
 	/* Unknown connections */
 	cnt = Client_UnknownCount( );
-	if( cnt > 0 )
-	{
-		if( ! IRC_WriteStrClient( Client, RPL_LUSERUNKNOWN_MSG, Client_ID( Client ), cnt )) return DISCONNECTED;
+	if (cnt > 0) {
+		if (!IRC_WriteStrClient(Client, RPL_LUSERUNKNOWN_MSG,
+					Client_ID(Client), cnt))
+			return DISCONNECTED;
 	}
 
 	/* Number of created channels */
-	if( ! IRC_WriteStrClient( Client, RPL_LUSERCHANNELS_MSG, Client_ID( Client ), Channel_Count( ))) return DISCONNECTED;
+	if (!IRC_WriteStrClient(Client, RPL_LUSERCHANNELS_MSG,
+				Client_ID(Client),
+				Channel_CountVisible(Client)))
+		return DISCONNECTED;
 
 	/* Number of local users, services and servers */
-	if( ! IRC_WriteStrClient( Client, RPL_LUSERME_MSG, Client_ID( Client ), Client_MyUserCount( ), Client_MyServiceCount( ), Client_MyServerCount( ))) return DISCONNECTED;
+	if (!IRC_WriteStrClient(Client, RPL_LUSERME_MSG, Client_ID(Client),
+				Client_MyUserCount(), Client_MyServiceCount(),
+				Client_MyServerCount()))
+		return DISCONNECTED;
 
 #ifndef STRICT_RFC
 	/* Maximum number of local users */
@@ -1142,8 +1492,12 @@ IRC_Send_LUSERS( CLIENT *Client )
 	if(! IRC_WriteStrClient(Client, RPL_NETUSERS_MSG, Client_ID(Client),
 			cnt, max, cnt, max))
 		return DISCONNECTED;
+	/* Connection counters */
+	if (! IRC_WriteStrClient(Client, RPL_STATSCONN_MSG, Client_ID(Client),
+			Conn_CountMax(), Conn_CountAccepted()))
+		return DISCONNECTED;
 #endif
-	
+
 	return CONNECTED;
 } /* IRC_Send_LUSERS */
 
@@ -1164,7 +1518,15 @@ Show_MOTD_Sendline(CLIENT *Client, const char *msg)
 static bool
 Show_MOTD_End(CLIENT *Client)
 {
-	return IRC_WriteStrClient( Client, RPL_ENDOFMOTD_MSG, Client_ID( Client ));
+	if (!IRC_WriteStrClient(Client, RPL_ENDOFMOTD_MSG, Client_ID(Client)))
+		return DISCONNECTED;
+
+	if (*Conf_CloakHost)
+		return IRC_WriteStrClient(Client, RPL_HOSTHIDDEN_MSG,
+					  Client_ID(Client),
+					  Client_Hostname(Client));
+
+	return CONNECTED;
 }
 
 #ifdef SSL_SUPPORT
@@ -1182,121 +1544,121 @@ static bool Show_MOTD_SSLInfo(CLIENT *Client)
 	return ret;
 }
 #else
-static inline bool Show_MOTD_SSLInfo(UNUSED CLIENT *c) { return true; }
+static inline bool
+Show_MOTD_SSLInfo(UNUSED CLIENT *c)
+{ return true; }
 #endif
 
 GLOBAL bool
 IRC_Show_MOTD( CLIENT *Client )
 {
-	char line[127];
-	FILE *fd;
+	const char *line;
+	size_t len_tot, len_str;
 
 	assert( Client != NULL );
 
-	if (Conf_MotdPhrase[0]) {
-		if (!Show_MOTD_Start(Client))
-			return DISCONNECTED;
-		if (!Show_MOTD_Sendline(Client, Conf_MotdPhrase))
-			return DISCONNECTED;
-		goto out;
-	}
+	len_tot = array_bytes(&Conf_Motd);
+	if (len_tot == 0 && !Conn_UsesSSL(Client_Conn(Client)))
+		return IRC_WriteStrClient(Client, ERR_NOMOTD_MSG, Client_ID(Client));
 
-	fd = fopen( Conf_MotdFile, "r" );
-	if( ! fd ) {
-		Log( LOG_WARNING, "Can't read MOTD file \"%s\": %s", Conf_MotdFile, strerror( errno ));
-		if (Conn_UsesSSL(Client_Conn(Client))) {
-			if (!Show_MOTD_Start(Client))
-				return DISCONNECTED;
-			goto out;
-		}
-		return IRC_WriteStrClient( Client, ERR_NOMOTD_MSG, Client_ID( Client ) );
-	}
+	if (!Show_MOTD_Start(Client))
+		return DISCONNECTED;
 
-	if (!Show_MOTD_Start( Client )) {
-		fclose(fd);
-		return false;
-	}
+	line = array_start(&Conf_Motd);
+	while (len_tot > 0) {
+		len_str = strlen(line) + 1;
 
-	while (fgets( line, (int)sizeof line, fd )) {
-		ngt_TrimLastChr( line, '\n');
+		assert(len_tot >= len_str);
+		len_tot -= len_str;
 
-		if( ! Show_MOTD_Sendline( Client, line)) {
-			fclose( fd );
-			return false;
-		}
+		if (!Show_MOTD_Sendline(Client, line))
+			return DISCONNECTED;
+		line += len_str;
 	}
-	fclose(fd);
-out:
+
 	if (!Show_MOTD_SSLInfo(Client))
 		return DISCONNECTED;
 	return Show_MOTD_End(Client);
 } /* IRC_Show_MOTD */
 
 
+/**
+ * Send NAMES reply for a specific client and channel.
+ *
+ * @param Client The client requesting the NAMES information.
+ * @param Chan The channel
+ * @return CONNECTED or DISCONNECTED.
+ */
 GLOBAL bool
-IRC_Send_NAMES( CLIENT *Client, CHANNEL *Chan )
+IRC_Send_NAMES(CLIENT * Client, CHANNEL * Chan)
 {
 	bool is_visible, is_member;
 	char str[LINE_LEN + 1];
 	CL2CHAN *cl2chan;
 	CLIENT *cl;
 
-	assert( Client != NULL );
-	assert( Chan != NULL );
+	assert(Client != NULL);
+	assert(Chan != NULL);
+
+	if (Channel_IsMemberOf(Chan, Client))
+		is_member = true;
+	else
+		is_member = false;
 
-	if( Channel_IsMemberOf( Chan, Client )) is_member = true;
-	else is_member = false;
+	/* Do not print info on channel memberships to anyone that is not member? */
+	if (Conf_MorePrivacy && !is_member)
+		return CONNECTED;
 
 	/* Secret channel? */
-	if( ! is_member && strchr( Channel_Modes( Chan ), 's' )) return CONNECTED;
+	if (!is_member && strchr(Channel_Modes(Chan), 's'))
+		return CONNECTED;
 
-	/* Alle Mitglieder suchen */
-	snprintf( str, sizeof( str ), RPL_NAMREPLY_MSG, Client_ID( Client ), "=", Channel_Name( Chan ));
-	cl2chan = Channel_FirstMember( Chan );
-	while( cl2chan )
-	{
-		cl = Channel_GetClient( cl2chan );
+	snprintf(str, sizeof(str), RPL_NAMREPLY_MSG, Client_ID(Client), "=",
+		 Channel_Name(Chan));
+	cl2chan = Channel_FirstMember(Chan);
+	while (cl2chan) {
+		cl = Channel_GetClient(cl2chan);
 
-		if( strchr( Client_Modes( cl ), 'i' )) is_visible = false;
-		else is_visible = true;
+		if (strchr(Client_Modes(cl), 'i'))
+			is_visible = false;
+		else
+			is_visible = true;
 
-		if( is_member || is_visible )
-		{
-			/* Nick anhaengen */
-			if( str[strlen( str ) - 1] != ':' ) strlcat( str, " ", sizeof( str ));
-			if( strchr( Channel_UserModes( Chan, cl ), 'o' )) strlcat( str, "@", sizeof( str ));
-			else if( strchr( Channel_UserModes( Chan, cl ), 'v' )) strlcat( str, "+", sizeof( str ));
-			strlcat( str, Client_ID( cl ), sizeof( str ));
+		if (is_member || is_visible) {
+			if (str[strlen(str) - 1] != ':')
+				strlcat(str, " ", sizeof(str));
 
-			if( strlen( str ) > ( LINE_LEN - CLIENT_NICK_LEN - 4 ))
-			{
-				/* Zeile wird zu lang: senden! */
-				if( ! IRC_WriteStrClient( Client, "%s", str )) return DISCONNECTED;
-				snprintf( str, sizeof( str ), RPL_NAMREPLY_MSG, Client_ID( Client ), "=", Channel_Name( Chan ));
+			who_flags_qualifier(Client, Channel_UserModes(Chan, cl),
+					    str, sizeof(str));
+			strlcat(str, Client_ID(cl), sizeof(str));
+
+			if (strlen(str) > (LINE_LEN - CLIENT_NICK_LEN - 4)) {
+				if (!IRC_WriteStrClient(Client, "%s", str))
+					return DISCONNECTED;
+				snprintf(str, sizeof(str), RPL_NAMREPLY_MSG,
+					 Client_ID(Client), "=",
+					 Channel_Name(Chan));
 			}
 		}
 
-		/* naechstes Mitglied suchen */
-		cl2chan = Channel_NextMember( Chan, cl2chan );
+		cl2chan = Channel_NextMember(Chan, cl2chan);
 	}
-	if( str[strlen( str ) - 1] != ':')
-	{
-		/* Es sind noch Daten da, die gesendet werden muessen */
-		if( ! IRC_WriteStrClient( Client, "%s", str )) return DISCONNECTED;
+	if (str[strlen(str) - 1] != ':') {
+		if (!IRC_WriteStrClient(Client, "%s", str))
+			return DISCONNECTED;
 	}
 
 	return CONNECTED;
 } /* IRC_Send_NAMES */
 
 
-
 /**
  * Send the ISUPPORT numeric (005).
  * This numeric indicates the features that are supported by this server.
  * See <http://www.irc.org/tech_docs/005.html> for details.
  */
 GLOBAL bool
-IRC_Send_ISUPPORT PARAMS((CLIENT * Client))
+IRC_Send_ISUPPORT(CLIENT * Client)
 {
 	if (!IRC_WriteStrClient(Client, RPL_ISUPPORT1_MSG, Client_ID(Client),
 				Conf_MaxJoins))
@@ -1304,7 +1666,8 @@ IRC_Send_ISUPPORT PARAMS((CLIENT * Client))
 	return IRC_WriteStrClient(Client, RPL_ISUPPORT2_MSG, Client_ID(Client),
 				  CHANNEL_NAME_LEN - 1, Conf_MaxNickLength - 1,
 				  COMMAND_LEN - 23, CLIENT_AWAY_LEN - 1,
-				  COMMAND_LEN - 113);
+				  COMMAND_LEN - 113, MAX_HNDL_MODES_ARG,
+				  MAX_HNDL_CHANNEL_LISTS);
 } /* IRC_Send_ISUPPORT */