X-Git-Url: https://arthur.barton.de/cgi-bin/gitweb.cgi?p=ngircd-alex.git;a=blobdiff_plain;f=src%2Fngircd%2Firc-server.c;h=0a9e930d816f696b5fc784fa6857c063fbf49744;hp=2ed347ba9a188c67c10fcea392b5ed3a22b5148a;hb=d38d153f;hpb=938abb0236cece1a05f713eb96fa0b9dd4cf56c3

diff --git a/src/ngircd/irc-server.c b/src/ngircd/irc-server.c
index 2ed347ba..0a9e930d 100644
--- a/src/ngircd/irc-server.c
+++ b/src/ngircd/irc-server.c
@@ -1,288 +1,251 @@
 /*
  * ngIRCd -- The Next Generation IRC Daemon
- * Copyright (c)2001,2002 by Alexander Barton (alex@barton.de)
+ * Copyright (c)2001-2007 Alexander Barton (alex@barton.de)
  *
- * Dieses Programm ist freie Software. Sie koennen es unter den Bedingungen
- * der GNU General Public License (GPL), wie von der Free Software Foundation
- * herausgegeben, weitergeben und/oder modifizieren, entweder unter Version 2
- * der Lizenz oder (wenn Sie es wuenschen) jeder spaeteren Version.
- * Naehere Informationen entnehmen Sie bitter der Datei COPYING. Eine Liste
- * der an ngIRCd beteiligten Autoren finden Sie in der Datei AUTHORS.
- *
- * $Id: irc-server.c,v 1.16 2002/09/03 23:55:44 alex Exp $
- *
- * irc-server.c: IRC-Befehle fuer Server-Links
+ * 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.
  */
 
-
 #include "portab.h"
 
+/**
+ * @file
+ * IRC commands for server links
+ */
+
 #include "imp.h"
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <strings.h>
 
-#include "resolve.h"
-#include "conf.h"
+#include "defines.h"
 #include "conn.h"
-#include "client.h"
+#include "conn-func.h"
+#include "conn-zip.h"
+#include "conf.h"
 #include "channel.h"
 #include "irc-write.h"
+#include "lists.h"
 #include "log.h"
 #include "messages.h"
 #include "parse.h"
+#include "numeric.h"
 #include "ngircd.h"
+#include "irc-info.h"
+#include "op.h"
 
 #include "exp.h"
 #include "irc-server.h"
 
 
-GLOBAL BOOLEAN
+/**
+ * Handler for the IRC command "SERVER".
+ * See RFC 2813 section 4.1.2.
+ */
+GLOBAL bool
 IRC_SERVER( CLIENT *Client, REQUEST *Req )
 {
-	CHAR str[LINE_LEN], *ptr;
-	CLIENT *from, *c, *cl;
-	CL2CHAN *cl2chan;
-	INT max_hops, i;
-	CHANNEL *chan;
-	BOOLEAN ok;
-	
+	char str[LINE_LEN];
+	CLIENT *from, *c;
+	int i;
+
 	assert( Client != NULL );
 	assert( Req != NULL );
 
-	/* Fehler liefern, wenn kein lokaler Client */
-	if( Client_Conn( Client ) <= NONE ) return IRC_WriteStrClient( Client, ERR_UNKNOWNCOMMAND_MSG, Client_ID( Client ), Req->command );
-
-	if( Client_Type( Client ) == CLIENT_GOTPASSSERVER )
-	{
-		/* Verbindung soll als Server-Server-Verbindung registriert werden */
-		Log( LOG_DEBUG, "Connection %d: got SERVER command (new server link) ...", Client_Conn( Client ));
-
-		/* Falsche Anzahl Parameter? */
-		if(( Req->argc != 2 ) && ( Req->argc != 3 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
-
-		/* Ist dieser Server bei uns konfiguriert? */
-		for( i = 0; i < Conf_Server_Count; i++ ) if( strcasecmp( Req->argv[0], Conf_Server[i].name ) == 0 ) break;
-		if( i >= Conf_Server_Count )
-		{
-			/* Server ist nicht konfiguriert! */
-			Log( LOG_ERR, "Connection %d: Server \"%s\" not configured here!", Client_Conn( Client ), Req->argv[0] );
-			Conn_Close( Client_Conn( Client ), NULL, "Server not configured here", TRUE );
+	/* Return an error if this is not a local client */
+	if (Client_Conn(Client) <= NONE)
+		return IRC_WriteStrClient(Client, ERR_UNKNOWNCOMMAND_MSG,
+					  Client_ID(Client), Req->command);
+
+	if (Client_Type(Client) == CLIENT_GOTPASS ||
+	    Client_Type(Client) == CLIENT_GOTPASS_2813) {
+		/* We got a PASS command from the peer, and now a SERVER
+		 * command: the peer tries to register itself as a server. */
+		LogDebug("Connection %d: got SERVER command (new server link) ...",
+			Client_Conn(Client));
+
+		if (Req->argc != 2 && Req->argc != 3)
+			return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
+						  Client_ID(Client),
+						  Req->command);
+
+		/* Get configuration index of new remote server ... */
+		for (i = 0; i < MAX_SERVERS; i++)
+			if (strcasecmp(Req->argv[0], Conf_Server[i].name) == 0)
+				break;
+
+		/* Makre sure the remote server is configured here */
+		if (i >= MAX_SERVERS) {
+			Log(LOG_ERR,
+			    "Connection %d: Server \"%s\" not configured here!",
+			    Client_Conn(Client), Req->argv[0]);
+			Conn_Close(Client_Conn(Client), NULL,
+				   "Server not configured here", true);
 			return DISCONNECTED;
 		}
-		if( strcmp( Client_Password( Client ), Conf_Server[i].pwd ) != 0 )
-		{
-			/* Falsches Passwort */
-			Log( LOG_ERR, "Connection %d: Bad password for server \"%s\"!", Client_Conn( Client ), Req->argv[0] );
-			Conn_Close( Client_Conn( Client ), NULL, "Bad password", TRUE );
+
+		/* Check server password */
+		if (strcmp(Conn_Password(Client_Conn(Client)),
+		    Conf_Server[i].pwd_in) != 0) {
+			Log(LOG_ERR,
+			    "Connection %d: Got bad password from server \"%s\"!",
+			    Client_Conn(Client), Req->argv[0]);
+			Conn_Close(Client_Conn(Client), NULL,
+				   "Bad password", true);
 			return DISCONNECTED;
 		}
-		
-		/* Ist ein Server mit dieser ID bereits registriert? */
-		if( ! Client_CheckID( Client, Req->argv[0] )) return DISCONNECTED;
 
-		/* Server-Strukturen fuellen ;-) */
+		/* Is there a registered server with this ID? */
+		if (!Client_CheckID(Client, Req->argv[0]))
+			return DISCONNECTED;
+
+		/* Mark this connection as belonging to an configured server */
+		if (!Conf_SetServer(i, Client_Conn(Client)))
+			return DISCONNECTED;
+
 		Client_SetID( Client, Req->argv[0] );
 		Client_SetHops( Client, 1 );
 		Client_SetInfo( Client, Req->argv[Req->argc - 1] );
-		
-		/* Meldet sich der Server bei uns an (d.h., bauen nicht wir
-		 * selber die Verbindung zu einem anderen Server auf)? */
-		if( Client_Token( Client ) != TOKEN_OUTBOUND )
-		{
-			/* Eingehende Verbindung: Unseren SERVER- und PASS-Befehl senden */
-			ok = TRUE;
-			if( ! IRC_WriteStrClient( Client, "PASS %s %s", Conf_Server[i].pwd, NGIRCd_ProtoID )) ok = FALSE;
-			else ok = IRC_WriteStrClient( Client, "SERVER %s 1 :%s", Conf_ServerName, Conf_ServerInfo );
-			if( ! ok )
-			{
-				Conn_Close( Client_Conn( Client ), "Unexpected server behavior!", NULL, FALSE );
-				return DISCONNECTED;
-			}
-			Client_SetIntroducer( Client, Client );
-			Client_SetToken( Client, 1 );
-		}
-		else
-		{
-			/* Ausgehende verbindung, SERVER und PASS wurden von uns bereits
-			 * an die Gegenseite uerbermittelt */
-			Client_SetToken( Client, atoi( Req->argv[1] ));
-		}
-
-		Log( LOG_NOTICE|LOG_snotice, "Server \"%s\" registered (connection %d, 1 hop - direct link).", Client_ID( Client ), Client_Conn( Client ));
-
-		Client_SetType( Client, CLIENT_SERVER );
 
-		/* maximalen Hop Count ermitteln */
-		max_hops = 0;
-		c = Client_First( );
-		while( c )
-		{
-			if( Client_Hops( c ) > max_hops ) max_hops = Client_Hops( c );
-			c = Client_Next( c );
-		}
-		
-		/* Alle bisherigen Server dem neuen Server bekannt machen,
-		 * die bisherigen Server ueber den neuen informierenn */
-		for( i = 0; i < ( max_hops + 1 ); i++ )
-		{
-			c = Client_First( );
-			while( c )
-			{
-				if(( Client_Type( c ) == CLIENT_SERVER ) && ( c != Client ) && ( c != Client_ThisServer( )) && ( Client_Hops( c ) == i ))
-				{
-					if( Client_Conn( c ) > NONE )
-					{
-						/* Dem gefundenen Server gleich den neuen
-						 * Server bekannt machen */
-						if( ! IRC_WriteStrClient( c, "SERVER %s %d %d :%s", Client_ID( Client ), Client_Hops( Client ) + 1, Client_MyToken( Client ), Client_Info( Client ))) return DISCONNECTED;
-					}
-					
-					/* Den neuen Server ueber den alten informieren */
-					if( ! IRC_WriteStrClientPrefix( Client, Client_Hops( c ) == 1 ? Client_ThisServer( ) : Client_Introducer( c ), "SERVER %s %d %d :%s", Client_ID( c ), Client_Hops( c ) + 1, Client_MyToken( c ), Client_Info( c ))) return DISCONNECTED;
-				}
-				c = Client_Next( c );
+		/* Is this server registering on our side, or are we connecting to
+		 * a remote server? */
+		if (Client_Token(Client) != TOKEN_OUTBOUND) {
+			/* Incoming connection, send user/pass */
+			if (!IRC_WriteStrClient(Client, "PASS %s %s",
+						Conf_Server[i].pwd_out,
+						NGIRCd_ProtoID)
+			    || !IRC_WriteStrClient(Client, "SERVER %s 1 :%s",
+						   Conf_ServerName,
+						   Conf_ServerInfo)) {
+				    Conn_Close(Client_Conn(Client),
+					       "Unexpected server behavior!",
+					       NULL, false);
+				    return DISCONNECTED;
 			}
+			Client_SetIntroducer(Client, Client);
+			Client_SetToken(Client, 1);
+		} else {
+			/* outgoing connect, we already sent a SERVER and PASS
+			 * command to the peer */
+			Client_SetToken(Client, atoi(Req->argv[1]));
 		}
 
-		/* alle User dem neuen Server bekannt machen */
-		c = Client_First( );
-		while( c )
-		{
-			if( Client_Type( c ) == CLIENT_USER )
-			{
-				/* User an neuen Server melden */
-				if( ! IRC_WriteStrClient( Client, "NICK %s %d %s %s %d +%s :%s", Client_ID( c ), Client_Hops( c ) + 1, Client_User( c ), Client_Hostname( c ), Client_MyToken( Client_Introducer( c )), Client_Modes( c ), Client_Info( c ))) return DISCONNECTED;
-			}
-			c = Client_Next( c );
+		/* Check protocol level */
+		if (Client_Type(Client) == CLIENT_GOTPASS) {
+			/* We got a "simple" PASS command, so the peer is
+			 * using the protocol as defined in RFC 1459. */
+			if (! (Conn_Options(Client_Conn(Client)) & CONN_RFC1459))
+				Log(LOG_INFO,
+				    "Switching connection %d (\"%s\") to RFC 1459 compatibility mode.",
+				    Client_Conn(Client), Client_ID(Client));
+			Conn_SetOption(Client_Conn(Client), CONN_RFC1459);
 		}
 
-		/* Channels dem neuen Server bekannt machen */
-		chan = Channel_First( );
-		while( chan )
-		{
-			/* Wenn unterstuetzt, CHANINFO senden */
-			if( strchr( Client_Flags( Client ), 'C' ))
-			{
-				/* CHANINFO senden */
-				if( ! IRC_WriteStrClient( Client, "CHANINFO %s +%s :%s", Channel_Name( chan ), Channel_Modes( chan ), Channel_Topic( chan ))) return DISCONNECTED;
-			}
-			
-			/* alle Member suchen */
-			cl2chan = Channel_FirstMember( chan );
-			sprintf( str, "NJOIN %s :", Channel_Name( chan ));
-			while( cl2chan )
-			{
-				cl = Channel_GetClient( cl2chan );
-				assert( cl != NULL );
-
-				/* Nick, ggf. mit Modes, anhaengen */
-				if( str[strlen( str ) - 1] != ':' ) strcat( str, "," );
-				if( strchr( Channel_UserModes( chan, cl ), 'v' )) strcat( str, "+" );
-				if( strchr( Channel_UserModes( chan, cl ), 'o' )) strcat( str, "@" );
-				strcat( str, Client_ID( cl ));
-
-				if( strlen( str ) > ( LINE_LEN - CLIENT_NICK_LEN - 8 ))
-				{
-					/* Zeile senden */
-					if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
-					sprintf( str, "NJOIN %s :", Channel_Name( chan ));
-				}
-				
-				cl2chan = Channel_NextMember( chan, cl2chan );
-			}
+		Client_SetType(Client, CLIENT_UNKNOWNSERVER);
 
-			/* noch Daten da? */
-			if( str[strlen( str ) - 1] != ':')
-			{
-				/* Ja; Also senden ... */
-				if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
-			}
+#ifdef ZLIB
+		if (strchr(Client_Flags(Client), 'Z')
+		    && !Zip_InitConn(Client_Conn(Client))) {
+			Conn_Close(Client_Conn(Client),
+				   "Can't inizialize compression (zlib)!",
+				   NULL, false );
+			return DISCONNECTED;
+		}
+#endif
 
-			/* naechsten Channel suchen */
-			chan = Channel_Next( chan );
+#ifdef IRCPLUS
+		if (strchr(Client_Flags(Client), 'H')) {
+			LogDebug("Peer supports IRC+ extended server handshake ...");
+			if (!IRC_Send_ISUPPORT(Client))
+				return DISCONNECTED;
+			return IRC_WriteStrClient(Client, RPL_ENDOFMOTD_MSG,
+						  Client_ID(Client));
+		} else {
+#endif
+			if (Conf_MaxNickLength != CLIENT_NICK_LEN_DEFAULT)
+				Log(LOG_CRIT,
+				    "Attention: this server uses a non-standard nick length, but the peer doesn't support the IRC+ extended server handshake!");
+#ifdef IRCPLUS
 		}
-		
-		return CONNECTED;
+#endif
+
+		return IRC_Num_ENDOFMOTD(Client, Req);
 	}
 	else if( Client_Type( Client ) == CLIENT_SERVER )
 	{
-		/* Neuer Server wird im Netz angekuendigt */
+		/* New server is being introduced to the network */
 
-		/* Falsche Anzahl Parameter? */
 		if( Req->argc != 4 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 
-		/* Ist ein Server mit dieser ID bereits registriert? */
+		/* check for existing server with same ID */
 		if( ! Client_CheckID( Client, Req->argv[0] )) return DISCONNECTED;
 
-		/* Ueberfluessige Hostnamen aus Info-Text entfernen */
-		ptr = strchr( Req->argv[3] + 2, '[' );
-		if( ! ptr ) ptr = Req->argv[3];
-
 		from = Client_Search( Req->prefix );
 		if( ! from )
 		{
-			/* Hm, Server, der diesen einfuehrt, ist nicht bekannt!? */
+			/* Uh, Server, that introduced the new server is unknown?! */
 			Log( LOG_ALERT, "Unknown ID in prefix of SERVER: \"%s\"! (on connection %d)", Req->prefix, Client_Conn( Client ));
-			Conn_Close( Client_Conn( Client ), NULL, "Unknown ID in prefix of SERVER", TRUE );
+			Conn_Close( Client_Conn( Client ), NULL, "Unknown ID in prefix of SERVER", true);
 			return DISCONNECTED;
 		}
 
-		/* Neue Client-Struktur anlegen */
-		c = Client_NewRemoteServer( Client, Req->argv[0], from, atoi( Req->argv[1] ), atoi( Req->argv[2] ), ptr, TRUE );
-		if( ! c )
-		{
-			/* Neue Client-Struktur konnte nicht angelegt werden */
+		c = Client_NewRemoteServer(Client, Req->argv[0], from, atoi(Req->argv[1]), atoi(Req->argv[2]), Req->argv[3], true);
+		if (!c) {
 			Log( LOG_ALERT, "Can't create client structure for server! (on connection %d)", Client_Conn( Client ));
-			Conn_Close( Client_Conn( Client ), NULL, "Can't allocate client structure for remote server", TRUE );
+			Conn_Close( Client_Conn( Client ), NULL, "Can't allocate client structure for remote server", true);
 			return DISCONNECTED;
 		}
 
-		/* Log-Meldung zusammenbauen und ausgeben */
-		if(( Client_Hops( c ) > 1 ) && ( Req->prefix[0] )) sprintf( str, "connected to %s, ", Client_ID( from ));
+		if(( Client_Hops( c ) > 1 ) && ( Req->prefix[0] )) snprintf( str, sizeof( str ), "connected to %s, ", Client_ID( from ));
 		else strcpy( str, "" );
 		Log( LOG_NOTICE|LOG_snotice, "Server \"%s\" registered (via %s, %s%d hop%s).", Client_ID( c ), Client_ID( Client ), str, Client_Hops( c ), Client_Hops( c ) > 1 ? "s": "" );
 
-		/* Andere Server informieren */
+		/* notify other servers */
 		IRC_WriteStrServersPrefix( Client, from, "SERVER %s %d %d :%s", Client_ID( c ), Client_Hops( c ) + 1, Client_MyToken( c ), Client_Info( c ));
 
 		return CONNECTED;
-	}
-	else return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
+	} else
+		return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
+					  Client_ID(Client), Req->command);
 } /* IRC_SERVER */
 
 
-GLOBAL BOOLEAN
+GLOBAL bool
 IRC_NJOIN( CLIENT *Client, REQUEST *Req )
 {
-	CHAR str[COMMAND_LEN], *channame, *ptr, modes[8];
-	BOOLEAN is_op, is_voiced;
+	char nick_in[COMMAND_LEN], nick_out[COMMAND_LEN], *channame, *ptr, modes[8];
+	bool is_owner, is_chanadmin, is_op, is_halfop, is_voiced;
 	CHANNEL *chan;
 	CLIENT *c;
-	
+
 	assert( Client != NULL );
 	assert( Req != NULL );
 
-	if( Client_Type( Client ) != CLIENT_SERVER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTEREDSERVER_MSG, Client_ID( Client ));
-
-	/* Falsche Anzahl Parameter? */
 	if( Req->argc != 2 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 
-	strncpy( str, Req->argv[1], COMMAND_LEN - 1 );
-	str[COMMAND_LEN - 1] = '\0';
+	strlcpy( nick_in, Req->argv[1], sizeof( nick_in ));
+	strcpy( nick_out, "" );
 
 	channame = Req->argv[0];
-	ptr = strtok( str, "," );
+	ptr = strtok( nick_in, "," );
 	while( ptr )
 	{
-		is_op = is_voiced = FALSE;
-		
-		/* Prefixe abschneiden */
-		while(( *ptr == '@' ) || ( *ptr == '+' ))
+		is_owner = is_chanadmin = is_op = is_halfop = is_voiced = false;
+
+		/* cut off prefixes */
+		while(( *ptr == '~') || ( *ptr == '&' ) || ( *ptr == '@' ) ||
+			( *ptr == '%') || ( *ptr == '+' ))
 		{
-			if( *ptr == '@' ) is_op = TRUE;
-			if( *ptr == '+' ) is_voiced = TRUE;
+			if( *ptr == '~' ) is_owner = true;
+			if( *ptr == '&' ) is_chanadmin = true;
+			if( *ptr == '@' ) is_op = true;
+			if( *ptr == 'h' ) is_halfop = true;
+			if( *ptr == '+' ) is_voiced = true;
 			ptr++;
 		}
 
@@ -292,83 +255,143 @@ IRC_NJOIN( CLIENT *Client, REQUEST *Req )
 			Channel_Join( c, channame );
 			chan = Channel_Search( channame );
 			assert( chan != NULL );
-			
+
+			if( is_owner ) Channel_UserModeAdd( chan, c, 'q' );
+			if( is_chanadmin ) Channel_UserModeAdd( chan, c, 'a' );
 			if( is_op ) Channel_UserModeAdd( chan, c, 'o' );
+			if( is_halfop ) Channel_UserModeAdd( chan, c, 'h' );
 			if( is_voiced ) Channel_UserModeAdd( chan, c, 'v' );
 
-			/* im Channel bekannt machen */
-			IRC_WriteStrChannelPrefix( Client, chan, c, FALSE, "JOIN :%s", channame );
+			/* announce to channel... */
+			IRC_WriteStrChannelPrefix( Client, chan, c, false, "JOIN :%s", channame );
 
-			/* Channel-User-Modes setzen */
-			strcpy( modes, Channel_UserModes( chan, c ));
+			/* set Channel-User-Modes */
+			strlcpy( modes, Channel_UserModes( chan, c ), sizeof( modes ));
 			if( modes[0] )
 			{
-				/* Modes im Channel bekannt machen */
-				IRC_WriteStrChannelPrefix( Client, chan, Client, FALSE, "MODE %s +%s %s", channame, modes, Client_ID( c ));
+				/* send modes to channel */
+				IRC_WriteStrChannelPrefix( Client, chan, Client, false, "MODE %s +%s %s", channame, modes, Client_ID( c ));
 			}
+
+			if( nick_out[0] != '\0' ) strlcat( nick_out, ",", sizeof( nick_out ));
+			if( is_owner ) strlcat( nick_out, "~", sizeof( nick_out ));
+			if( is_chanadmin ) strlcat( nick_out, "&", sizeof( nick_out ));
+			if( is_op ) strlcat( nick_out, "@", sizeof( nick_out ));
+			if( is_halfop ) strlcat( nick_out, "%", sizeof( nick_out ));
+			if( is_voiced ) strlcat( nick_out, "+", sizeof( nick_out ));
+			strlcat( nick_out, ptr, sizeof( nick_out ));
 		}
 		else Log( LOG_ERR, "Got NJOIN for unknown nick \"%s\" for channel \"%s\"!", ptr, channame );
-		
-		/* naechsten Nick suchen */
+
+		/* search for next Nick */
 		ptr = strtok( NULL, "," );
 	}
 
-	/* an andere Server weiterleiten */
-	IRC_WriteStrServersPrefix( Client, Client_ThisServer( ), "NJOIN %s :%s", Req->argv[0], Req->argv[1] );
+	/* forward to other servers */
+	if( nick_out[0] != '\0' ) IRC_WriteStrServersPrefix( Client, Client_ThisServer( ), "NJOIN %s :%s", Req->argv[0], nick_out );
 
 	return CONNECTED;
 } /* IRC_NJOIN */
 
 
-GLOBAL BOOLEAN
-IRC_SQUIT( CLIENT *Client, REQUEST *Req )
+/**
+ * Handler for the IRC command "SQUIT".
+ * See RFC 2813 section 4.1.2 and RFC 2812 section 3.1.8.
+ */
+GLOBAL bool
+IRC_SQUIT(CLIENT * Client, REQUEST * Req)
 {
-	CLIENT *target;
-	CHAR msg[LINE_LEN + 64];
-
-	assert( Client != NULL );
-	assert( Req != NULL );
-
-	/* SQUIT ist nur fuer Server erlaubt */
-	if( Client_Type( Client ) != CLIENT_SERVER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
-
-	/* Falsche Anzahl Parameter? */
-	if( Req->argc != 2 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
-
-	Log( LOG_DEBUG, "Got SQUIT from %s for \"%s\": \"%s\" ...", Client_ID( Client ), Req->argv[0], Req->argv[1] );
-
-	/* SQUIT an alle Server weiterleiten */
-	IRC_WriteStrServers( Client, "SQUIT %s :%s", Req->argv[0], Req->argv[1] );
-
-	target = Client_Search( Req->argv[0] );
-	if( ! target )
-	{
-		/* Den Server kennen wir nicht (mehr), also nichts zu tun. */
-		Log( LOG_WARNING, "Got SQUIT from %s for unknown server \"%s\"!?", Client_ID( Client ), Req->argv[0] );
+	char msg[COMMAND_LEN], logmsg[COMMAND_LEN];
+	CLIENT *from, *target;
+	CONN_ID con;
+	int loglevel;
+
+	assert(Client != NULL);
+	assert(Req != NULL);
+
+	if (Client_Type(Client) != CLIENT_SERVER
+	    && !Client_HasMode(Client, 'o'))
+		return Op_NoPrivileges(Client, Req);
+
+	/* Bad number of arguments? */
+	if (Req->argc != 2)
+		return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
+					  Client_ID(Client), Req->command);
+
+	if (Client_Type(Client) == CLIENT_SERVER && Req->prefix) {
+		from = Client_Search(Req->prefix);
+		if (Client_Type(from) != CLIENT_SERVER
+		    && !Op_Check(Client, Req))
+			return Op_NoPrivileges(Client, Req);
+	} else
+		from = Client;
+	if (!from)
+		return IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG,
+					  Client_ID(Client), Req->prefix);
+
+	if (Client_Type(Client) == CLIENT_USER)
+		loglevel = LOG_NOTICE | LOG_snotice;
+	else
+		loglevel = LOG_DEBUG;
+	Log(loglevel, "Got SQUIT from %s for \"%s\": \"%s\" ...",
+	    Client_ID(from), Req->argv[0], Req->argv[1]);
+
+	target = Client_Search(Req->argv[0]);
+	if (Client_Type(Client) != CLIENT_SERVER &&
+	    target == Client_ThisServer())
+		return Op_NoPrivileges(Client, Req);
+	if (!target) {
+		/* The server is (already) unknown */
+		Log(LOG_WARNING,
+		    "Got SQUIT from %s for unknown server \"%s\"!?",
+		    Client_ID(Client), Req->argv[0]);
 		return CONNECTED;
 	}
 
-	if( Req->argv[1][0] )
-	{
-		if( strlen( Req->argv[1] ) > LINE_LEN ) Req->argv[1][LINE_LEN] = '\0';
-		sprintf( msg, "%s (SQUIT from %s).", Req->argv[1], Client_ID( Client ));
-	}
-	else sprintf( msg, "Got SQUIT from %s.", Client_ID( Client ));
+	con = Client_Conn(target);
 
-	if( Client_Conn( target ) > NONE )
-	{
-		/* dieser Server hat die Connection */
-		if( Req->argv[1][0] ) Conn_Close( Client_Conn( target ), msg, Req->argv[1], TRUE );
-		else Conn_Close( Client_Conn( target ), msg, NULL, TRUE );
-		return DISCONNECTED;
-	}
+	if (Req->argv[1][0])
+		if (Client_NextHop(from) != Client || con > NONE)
+			snprintf(msg, sizeof(msg), "\"%s\" (SQUIT from %s)",
+				 Req->argv[1], Client_ID(from));
+		else
+			strlcpy(msg, Req->argv[1], sizeof(msg));
 	else
-	{
-		/* Verbindung hielt anderer Server */
-		Client_Destroy( target, msg, Req->argv[1], FALSE );
-		return CONNECTED;
+		snprintf(msg, sizeof(msg), "Got SQUIT from %s",
+			 Client_ID(from));
+
+	if (con > NONE) {
+		/* We are directly connected to the target server, so we
+		 * have to tear down the connection and to inform all the
+		 * other remaining servers in the network */
+		IRC_SendWallops(Client_ThisServer(), Client_ThisServer(),
+				"Received SQUIT %s from %s: %s",
+				Req->argv[0], Client_ID(from),
+				Req->argv[1][0] ? Req->argv[1] : "-");
+		Conn_Close(con, NULL, msg, true);
+		if (con == Client_Conn(Client))
+			return DISCONNECTED;
+	} else {
+		/* This server is not directly connected, so the SQUIT must
+		 * be forwarded ... */
+		if (Client_Type(from) != CLIENT_SERVER) {
+			/* The origin is not an IRC server, so don't evaluate
+			 * this SQUIT but simply forward it */
+			IRC_WriteStrClientPrefix(Client_NextHop(target),
+			    from, "SQUIT %s :%s", Req->argv[0], Req->argv[1]);
+		} else {
+			/* SQUIT has been generated by another server, so
+			 * remove the target server from the network! */
+			logmsg[0] = '\0';
+			if (!strchr(msg, '('))
+				snprintf(logmsg, sizeof(logmsg),
+					 "\"%s\" (SQUIT from %s)", Req->argv[1],
+					 Client_ID(from));
+			Client_Destroy(target, logmsg[0] ? logmsg : msg,
+				       msg, false);
+		}
 	}
+	return CONNECTED;
 } /* IRC_SQUIT */
 
-
 /* -eof- */