Add relaybot plugin.

Change-Id: I3155bb06d7a4852394dc86462214b773e35c4b27
Reviewed-on: http://gerrit.dmdirc.com/1003
Automatic-Compile: DMDirc Local Commits <dmdirc@googlemail.com>
Reviewed-by: Chris Smith <chris@dmdirc.com>

src/com/dmdirc/addons/relaybot/RelayBotPlugin.java

@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.relaybot;
+
+import com.dmdirc.interfaces.ActionListener;
+import com.dmdirc.actions.interfaces.ActionType;
+import com.dmdirc.actions.CoreActionType;
+import com.dmdirc.actions.ActionManager;
+import com.dmdirc.Channel;
+import com.dmdirc.Server;
+import com.dmdirc.ServerManager;
+import com.dmdirc.plugins.Plugin;
+import com.dmdirc.config.IdentityManager;
+import com.dmdirc.interfaces.ConfigChangeListener;
+import com.dmdirc.parser.interfaces.ChannelClientInfo;
+import com.dmdirc.parser.interfaces.Parser;
+import com.dmdirc.parser.irc.IRCParser;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * This plugin makes certain relay bots less obnoxious looking.
+ *
+ * @author shane
+ */
+public class RelayBotPlugin extends Plugin implements ActionListener, ConfigChangeListener {
+    /** Known RelayChannelHandlers. */
+    private final Map<Channel, RelayChannelHandler> handlers = new HashMap<Channel, RelayChannelHandler>();
+
+    /**
+     * Creates a new instance of the RelayBotPlugin.
+     */
+    public RelayBotPlugin() {
+        super();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void onLoad() {
+        ActionManager.addListener(this, CoreActionType.CHANNEL_OPENED);
+        ActionManager.addListener(this, CoreActionType.CHANNEL_CLOSED);
+        ActionManager.addListener(this, CoreActionType.SERVER_CONNECTED);
+        ActionManager.addListener(this, CoreActionType.SERVER_DISCONNECTED);
+        ActionManager.addListener(this, CoreActionType.CHANNEL_QUIT);
+
+        // Add ourself to all currently known channels that we should be
+        // connected with.
+        for (Server server : ServerManager.getServerManager().getServers()) {
+            final Parser parser = server.getParser();
+            if (parser instanceof IRCParser && !(parser.getCallbackManager() instanceof RelayCallbackManager)) {
+                new RelayCallbackManager(this, (IRCParser)parser);
+            }
+            for (String channel : server.getChannels()) {
+                final Channel chan = server.getChannel(channel);
+                final String channelName = chan.getServer().getParser().getStringConverter().toLowerCase(chan.getName());
+                getHandler(chan);
+            }
+        }
+    }
+    
+    /** {@inheritDoc} */
+    @Override
+    public void onUnload() {
+        ActionManager.removeListener(this);
+
+        // Remove RelayCallbackManagers
+        for (Server server : ServerManager.getServerManager().getServers()) {
+            final Parser parser = server.getParser();
+            if (parser instanceof IRCParser && parser.getCallbackManager() instanceof RelayCallbackManager) {
+                ((RelayCallbackManager) parser.getCallbackManager()).onSocketClosed(parser);
+            }
+        }
+
+        // Remove from all channels.
+        synchronized (handlers) {
+            for (RelayChannelHandler handler : new ArrayList<RelayChannelHandler>(handlers.values())) {
+                handler.restoreCoreChannelHandler();
+            }
+            handlers.clear();
+        }
+    }
+
+    /**
+     * Process an event of the specified type.
+     *
+     * @param type The type of the event to process
+     * @param format Format of messages that are about to be sent. (May be null)
+     * @param arguments The arguments for the event
+     */
+    @Override
+    public void processEvent(final ActionType type, final StringBuffer format, final Object... arguments) {
+        if (type == CoreActionType.CHANNEL_OPENED) {
+            final Channel chan = (Channel)arguments[0];
+            
+            final String channelName = chan.getServer().getParser().getStringConverter().toLowerCase(chan.getName());
+            getHandler(chan);
+        } else if (type == CoreActionType.CHANNEL_CLOSED) {
+            final Channel chan = (Channel)arguments[0];
+            removeHandler(chan);
+        } else if (type == CoreActionType.CHANNEL_QUIT) {
+            final Channel chan = (Channel)arguments[0];
+            final Parser parser = chan.getServer().getParser();
+            final ChannelClientInfo cci = (ChannelClientInfo)arguments[1];
+            final String channelName = parser.getStringConverter().toLowerCase(chan.getName());
+
+            if (IdentityManager.getGlobalConfig().hasOptionString(getDomain(), channelName)) {
+                final String botName = IdentityManager.getGlobalConfig().getOption(getDomain(), channelName);
+                if (parser.getStringConverter().equalsIgnoreCase(botName, cci.getClient().getNickname())) {
+                    // The bot quit :(
+                    final RelayChannelHandler handler = getHandler(chan);
+                    if (handler != null) {
+                        handler.updateNames();
+                    }
+                }
+            }
+        } else if (type == CoreActionType.SERVER_CONNECTED) {
+            final Server server = (Server)arguments[0];
+
+            final Parser parser = server.getParser();
+            if (parser instanceof IRCParser && !(parser.getCallbackManager() instanceof RelayCallbackManager)) {
+                new RelayCallbackManager(this, (IRCParser)parser);
+            }
+        } else if (type == CoreActionType.SERVER_DISCONNECTED) {
+            final Server server = (Server)arguments[0];
+
+            // RelayCallbackManager will revert itself when this happens.
+
+            // Unset any listeners for channels of this server
+            for (String channel : server.getChannels()) {
+                final Channel chan = server.getChannel(channel);
+                final String channelName = chan.getServer().getParser().getStringConverter().toLowerCase(chan.getName());
+                removeHandler(chan);
+            }
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void configChanged(final String domain, final String key) {
+        if (!domain.equals(getDomain())) { return; }
+        final boolean wasUnset = !(IdentityManager.getGlobalConfig().hasOptionString(domain, key));
+
+        for (Server server : ServerManager.getServerManager().getServers()) {
+            if (server.hasChannel(key)) {
+                final Channel chan = server.getChannel(key);
+                if (wasUnset) {
+                    removeHandler(chan);
+                } else {
+                    getHandler(chan);
+                }
+            }
+        }
+    }
+
+    /**
+     * Do we have an intercept for the given channel object?
+     * If we have one, we will return true.
+     * If we should have one (as determined by checking the config) we will add
+     * one and return true.
+     * 
+     * @param channel
+     * @return true or false
+     */
+    public boolean isListening(final Channel channel) {
+        return (getHandler(channel) != null);
+    }
+
+    /**
+     * Get the RelayChannelHandler for a given Channel.
+     * If we have one, we will return it.
+     * If we should have one (as determined by checking the config) we will
+     * create and return it.
+     * Otherwise we will return null.
+     *
+     * @param channel Channel to get Handler for.
+     * @return ChannelHandler or null
+     */
+    public RelayChannelHandler getHandler(final Channel channel) {
+        synchronized (handlers) {
+            if (handlers.containsKey(channel)) {
+                return handlers.get(channel);
+            } else {
+                final String channelName = channel.getServer().getParser().getStringConverter().toLowerCase(channel.getName());
+                if (IdentityManager.getGlobalConfig().hasOptionString(getDomain(), channelName)) {
+                    final RelayChannelHandler handler = new RelayChannelHandler(this, channel);
+                    handlers.put(channel, handler);
+                    return handler;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Remove the RelayChannelHandler for a given Channel.
+     * If we have one already, we will return it and remove it.
+     * Otherwise we will return null.
+     *
+     * @param channel Channel to remove Handler for.
+     * @return Handler that we removed, or null.
+     */
+    public RelayChannelHandler removeHandler(final Channel channel) {
+        synchronized (handlers) {
+            if (handlers.containsKey(channel)) {
+                final RelayChannelHandler handler = handlers.get(channel);
+                handler.unset();
+                handlers.remove(channel);
+
+                return handler;
+            }
+        }
+
+        return null;
+    }
+}

src/com/dmdirc/addons/relaybot/RelayCallbackManager.java

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.relaybot;
+
+import com.dmdirc.Channel;
+import com.dmdirc.ChannelEventHandler;
+import com.dmdirc.parser.common.CallbackManager;
+import com.dmdirc.parser.common.CallbackNotFoundException;
+import com.dmdirc.parser.common.CallbackObject;
+import com.dmdirc.parser.common.CallbackObjectSpecific;
+import com.dmdirc.parser.interfaces.Parser;
+import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
+import com.dmdirc.parser.interfaces.callbacks.ChannelMessageListener;
+import com.dmdirc.parser.irc.IRCCallbackManager;
+import com.dmdirc.parser.irc.IRCParser;
+import com.dmdirc.parser.interfaces.callbacks.SocketCloseListener;
+import java.lang.reflect.Field;
+import java.util.Map;
+
+/**
+ * This is a callback manager that when created will replace the callback
+ * manager of the given parser with itself.
+ *
+ * When a new callback is added it will be allowed unless the RelayBotPlugin
+ * says otherwise.
+ *
+ * When the parser disconnects, the original CBM is restored.
+ *
+ * @author shane
+ */
+public class RelayCallbackManager extends IRCCallbackManager implements SocketCloseListener {
+
+    /** Pluign that created this callback manager. */
+    private final RelayBotPlugin myPlugin;
+
+    /** Original CallbackManager */
+    private final IRCCallbackManager originalCBM;
+
+    /**
+     * Create a new RelayCallbackManager and replace
+     *
+     * @param myPlugin
+     * @param parser
+     */
+    public RelayCallbackManager(final RelayBotPlugin myPlugin, final IRCParser parser) {
+        super(parser);
+
+        this.myPlugin = myPlugin;
+        this.originalCBM = (IRCCallbackManager) parser.getCallbackManager();
+        setCallbackManager(parser, this);
+        addCallback(SocketCloseListener.class, this);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public <T extends CallbackInterface> void addCallback(final Class<T> callback, final T o, final String target) throws CallbackNotFoundException {
+        // Don't allow the core to give itself a ChannelMessageListener if we
+        // already have a listener for this channel.
+        if (o instanceof ChannelEventHandler && callback == ChannelMessageListener.class) {
+            try {
+                // Get the old callback manager
+                final Field field = o.getClass().getDeclaredField("owner");
+                field.setAccessible(true);
+                @SuppressWarnings("unchecked")
+                final Channel channel = (Channel) field.get(o);
+
+                if (myPlugin.isListening(channel)) {
+                    return;
+                }
+            } catch (NoSuchFieldException ex) {
+                ex.printStackTrace();
+            } catch (SecurityException ex) {
+                ex.printStackTrace();
+            } catch (IllegalArgumentException ex) {
+                ex.printStackTrace();
+            } catch (IllegalAccessException ex) {
+                ex.printStackTrace();
+            }
+        }
+
+        // Unless the plugin says we are listening instead of this channel, then
+        // we can add the callback.
+        forceAddCallback(callback, o, target);
+    }
+
+    /**
+     * Add a callback with a specific target.
+     * This method will throw a CallbackNotFoundException if the callback does not exist.
+     *
+     * @param <T> The type of callback
+     * @param callback Type of callback object.
+     * @param o instance of ICallbackInterface to add.
+     * @param target Parameter to specify that a callback should only fire for specific things
+     * @throws CallbackNotFoundException If callback is not found.
+     * @throws NullPointerException If 'o' is null
+     */
+    public <T extends CallbackInterface> void forceAddCallback(final Class<T> callback, final T o, final String target) throws CallbackNotFoundException {
+        super.addCallback(callback, o, target);
+    }
+
+
+    /**
+     * Set the Callback Manager of a given parser.
+     *
+     * @param parser
+     * @param cbm
+     */
+    private void setCallbackManager(final IRCParser parser, final CallbackManager<IRCParser> cbm) {
+        try {
+            // Get the old callback manager
+            final Field field = parser.getClass().getDeclaredField("myCallbackManager");
+            field.setAccessible(true);
+            @SuppressWarnings("unchecked")
+            final CallbackManager<IRCParser> oldCBM = (CallbackManager<IRCParser>) field.get(parser);
+
+            // Clone the known CallbackObjects list (horrible code ahoy!)
+            // First get the old map of callbacks
+            final Field cbField = CallbackManager.class.getDeclaredField("callbackHash");
+            cbField.setAccessible(true);
+            @SuppressWarnings("unchecked")
+            final Map<Class<? extends CallbackInterface>, CallbackObject> oldCallbackHash = (Map<Class<? extends CallbackInterface>, CallbackObject>) cbField.get(oldCBM);
+
+            // Clear my map of callbacks
+            @SuppressWarnings("unchecked")
+            final Map<Class<? extends CallbackInterface>, CallbackObject> myCallbackHash = (Map<Class<? extends CallbackInterface>, CallbackObject>) cbField.get(this);
+            myCallbackHash.clear();
+
+            // Now add them all to the new cbm.
+            for (CallbackObject callback : oldCallbackHash.values()) {
+                // Change their manager to the new one.
+                final Field ownerField = CallbackObject.class.getDeclaredField("myManager");
+                ownerField.setAccessible(true);
+                ownerField.set(callback, cbm);
+
+                // And add them to the CBM
+                cbm.addCallbackType(callback);
+            }
+
+            // Replace the old one with the new one.
+            field.set(parser, cbm);
+        } catch (IllegalArgumentException ex) {
+            ex.printStackTrace();
+        } catch (IllegalAccessException ex) {
+            ex.printStackTrace();
+        } catch (NoSuchFieldException ex) {
+            ex.printStackTrace();
+        } catch (SecurityException ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    /**
+     * When the socket closes, reset the callback manager.
+     *
+     * @param parser
+     */
+    public void onSocketClosed(final Parser parser) {
+        if (parser.getCallbackManager() instanceof RelayCallbackManager) {
+            setCallbackManager((IRCParser)parser, originalCBM);
+        }
+    }
+}

src/com/dmdirc/addons/relaybot/RelayChannelHandler.java

@@ -0,0 +1,349 @@
+/*
+ * Copyright (c) 2006-2010 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.relaybot;
+
+import com.dmdirc.parser.interfaces.callbacks.ChannelMessageListener;
+import com.dmdirc.Channel;
+import com.dmdirc.ChannelEventHandler;
+import com.dmdirc.config.IdentityManager;
+import com.dmdirc.parser.interfaces.ChannelClientInfo;
+import com.dmdirc.parser.interfaces.ChannelInfo;
+import com.dmdirc.parser.interfaces.Parser;
+import com.dmdirc.parser.irc.IRCCallbackManager;
+import com.dmdirc.parser.irc.IRCChannelClientInfo;
+import com.dmdirc.parser.irc.IRCParser;
+import com.dmdirc.plugins.PluginClassLoader;
+import com.dmdirc.plugins.PluginInfo;
+import com.dmdirc.plugins.PluginManager;
+import com.dmdirc.ui.messages.Styliser;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * This class replaces the ChannelHandler in the core to allow intercepting
+ * callbacks from the parser.
+ *
+ * This allows us to hide them from the core and send faked ones instead.
+ *
+ * @author shane
+ */
+public class RelayChannelHandler implements ChannelMessageListener {
+    /** My Channel. */
+    private final Channel myChannel;
+
+    /** Core channel handler. */
+    private final ChannelEventHandler coreChannelHandler;
+
+    /** Plugin that owns this RelayChannelHandler. */
+    private final RelayBotPlugin myPlugin;
+
+    /** Known ChannelClients */
+    private final Map<String, IRCChannelClientInfo> channelClients = new HashMap<String, IRCChannelClientInfo>();
+
+    /**
+     * Create a new RelayChannelHandler.
+     *
+     * @param myPlugin 
+     * @param myChannel channel to hax!
+     */
+    public RelayChannelHandler(final RelayBotPlugin myPlugin, final Channel myChannel) {
+        this.myChannel = myChannel;
+        this.myPlugin = myPlugin;
+        ChannelEventHandler ceh = null;
+        try {
+            // Get the core Channel handler.
+            final Field field = myChannel.getClass().getDeclaredField("eventHandler");
+            field.setAccessible(true);
+            ceh = (ChannelEventHandler) field.get(myChannel);
+        } catch (IllegalArgumentException ex) {
+            ex.printStackTrace();
+        } catch (IllegalAccessException ex) {
+            ex.printStackTrace();
+        } catch (NoSuchFieldException ex) {
+            ex.printStackTrace();
+        } catch (SecurityException ex) {
+            ex.printStackTrace();
+        }
+
+        coreChannelHandler = ceh;
+
+        if (coreChannelHandler != null) {
+            final IRCCallbackManager cbm = (IRCCallbackManager) myChannel.getServer().getParser().getCallbackManager();
+            cbm.delCallback(ChannelMessageListener.class, coreChannelHandler);
+            cbm.addCallback(ChannelMessageListener.class, this, myChannel.getName());
+        }
+    }
+
+
+    /**
+     * Get a ChannelClient object for the given nick@server.
+     *
+     * @param channel Channel
+     * @param nick Nickname to get channel client for.
+     * @param sendJoinIfNew
+     * @return Requested ChannelClient Info.
+     */
+    private IRCChannelClientInfo getChannelClient(final ChannelInfo channel, final String nick, final boolean sendJoinIfNew) {
+        final Parser parser = channel.getParser();
+        final String storeName = parser.getStringConverter().toLowerCase(nick);
+        synchronized (channelClients) {
+            if (!channelClients.containsKey(storeName)) {
+                final RelayClientInfo client = new RelayClientInfo(channel.getParser(), nick);
+                final IRCChannelClientInfo newChannelClient = new IRCChannelClientInfo((IRCParser)channel.getParser(), client, channel);
+                colourClient(newChannelClient);
+
+                channelClients.put(storeName, newChannelClient);
+                if (sendJoinIfNew && !client.isServer()) {
+                    coreChannelHandler.onChannelJoin(parser, channel, newChannelClient);
+                    // The nickcolour plugin colours the nicknames on join
+                    // and uses nickname@server when colouring rather than
+                    // the setting the user wanted, we can recolour here to
+                    // fix that.
+                    colourClient(newChannelClient);
+                }
+            }
+
+            return channelClients.get(storeName);
+        }
+    }
+
+    /**
+     * Remove a stored ChannelClient
+     *
+     * @param channel Channel
+     * @param nick Nickname to get channel client for.
+     */
+    private void removeChannelClient(final ChannelInfo channel, final String nick) {
+        final Parser parser = channel.getParser();
+        final String storeName = parser.getStringConverter().toLowerCase(nick);
+        synchronized (channelClients) {
+            channelClients.remove(storeName);
+        }
+    }
+
+    /**
+     * Rename a stored ChannelClient
+     *
+     * @param channelClient ChannelClient
+     * @param newNick new Nickname
+     */
+    private void renameChannelClient(final IRCChannelClientInfo channelClient, final String newNick) {
+        final Parser parser = channelClient.getChannel().getParser();
+        final String storeName = parser.getStringConverter().toLowerCase(newNick);
+
+        synchronized (channelClients) {
+            channelClients.remove(channelClient.getClient().toString());
+            ((RelayClientInfo) channelClient.getClient()).changeNickname(newNick);
+            channelClients.put(storeName,channelClient);
+        }
+    }
+
+    /**
+     * Restore the callback handling to the coreChannelHandler.
+     */
+    public void restoreCoreChannelHandler() {
+        if (coreChannelHandler != null) {
+            final IRCCallbackManager cbm = (IRCCallbackManager) myChannel.getServer().getParser().getCallbackManager();
+
+            // Force adding this callback to the CBM.
+            if (cbm instanceof RelayCallbackManager) {
+                ((RelayCallbackManager) cbm).forceAddCallback(ChannelMessageListener.class, coreChannelHandler, myChannel.getName());
+            } else {
+                cbm.addCallback(ChannelMessageListener.class, coreChannelHandler, myChannel.getName());
+            }
+            unset();
+            updateNames();
+        }
+    }
+
+    /**
+     * Remove channel message handling from this ChannelHandler
+     */
+    public void unset() {
+        myChannel.getServer().getParser().getCallbackManager().delCallback(ChannelMessageListener.class, this);
+    }
+
+    /**
+    * Colour a client as needed.
+    *
+    * @param channelClient Client to colour
+    */
+    private void colourClient(final ChannelClientInfo channelClient) {
+        // Use nick colour plugin to colour the client if available.
+        final PluginInfo nickColour = PluginManager.getPluginManager().getPluginInfoByName("nickcolour");
+
+        final boolean fullColour = IdentityManager.getGlobalConfig().getOptionBool(myPlugin.getDomain(), "colourFullName");
+        final RelayClientInfo client = (RelayClientInfo)channelClient.getClient();
+        final boolean oldValue = client.getShowFullNickname();
+        client.setShowFullNickname(fullColour);
+
+        if (nickColour != null && nickColour.isLoaded()) {
+            try {
+                final Method gpcl = PluginInfo.class.getDeclaredMethod("getPluginClassLoader");
+                gpcl.setAccessible(true);
+                final PluginClassLoader pcl = (PluginClassLoader) gpcl.invoke(nickColour);
+
+                final Class<?> nc = nickColour.getPlugin().getClass();
+                final Method colourClient = nc.getDeclaredMethod("colourClient", new Class<?>[]{String.class, ChannelClientInfo.class});
+                colourClient.setAccessible(true);
+                colourClient.invoke(nickColour.getPlugin(), myChannel.getServer().getNetwork(), channelClient);
+            } catch (Throwable t) { /* If it can't colour then oh well. */ }
+        }
+        
+        client.setShowFullNickname(oldValue);
+    }
+
+
+    /**
+     * Handle the IRCParsers incoming message.
+     *
+     * @param parser Parser that sent the message
+     * @param channel Channel the message went to
+     * @param channelClient Client who send the message
+     * @param message Message content
+     * @param host Host of client
+     */
+    @Override
+    public void onChannelMessage(final Parser parser, final ChannelInfo channel, final ChannelClientInfo channelClient, final String message, final String host) {
+        final String channelName = parser.getStringConverter().toLowerCase(channel.getName());
+        String botName;
+        try {
+            botName = IdentityManager.getGlobalConfig().getOption(myPlugin.getDomain(), channelName);
+        } catch (IllegalArgumentException iae) {
+            botName = "";
+        }
+        final boolean isBot = parser.getStringConverter().equalsIgnoreCase(botName, channelClient.getClient().getNickname());
+
+        final boolean joinNew = IdentityManager.getGlobalConfig().getOptionBool(myPlugin.getDomain(), "joinOnDiscover");
+
+        // See if we need to modify this message
+        if (channelClient instanceof IRCChannelClientInfo && !botName.isEmpty() && isBot) {
+            final String[] bits = message.split(" ", 2);
+            final String initial = Styliser.stipControlCodes(bits[0]);
+
+            if (initial.charAt(0) == '+') {
+                // Channel Message
+                final IRCChannelClientInfo newChannelClient = getChannelClient(channel, bits[0].substring(2, bits[0].length() - 1), joinNew);
+
+                coreChannelHandler.onChannelMessage(parser, channel, newChannelClient, bits[1], host);
+                return;
+            } else if (initial.equalsIgnoreCase("***")) {
+                // Some kind of state-changing action
+                final String[] newBits = bits[1].split(" ");
+
+                if (newBits.length > 2) {
+                    final IRCChannelClientInfo newChannelClient = getChannelClient(channel, newBits[0], joinNew);
+
+                    if (newBits[2].equalsIgnoreCase("joined")) {
+                        // User joined a relayed channel.
+                        if (!joinNew) {
+                            // If auto join on discover isn't enabled, we will
+                            // need to send this join, else it will already
+                            // have been sent.
+                            coreChannelHandler.onChannelJoin(parser, channel, newChannelClient);
+                            // And recolour to combat the nickcolour plugin
+                            // changing the colour on join.
+                            colourClient(newChannelClient);
+                        }
+                        return;
+                    } else if (newBits[2].equalsIgnoreCase("left")) {
+                        // User left a relayed channel.
+                        String reason = (newBits.length > 4) ? mergeBits(newBits, 4, newBits.length - 1, " ") : "()";
+                        reason = reason.substring(1, reason.length() - 1);
+
+                        coreChannelHandler.onChannelPart(parser, channel, newChannelClient, reason);
+                        removeChannelClient(channel, newBits[0]);
+                        return;
+                    } else if (newBits[2].equalsIgnoreCase("quit")) {
+                        // User quit a relayed channel.
+                        String reason = (newBits.length > 4) ? mergeBits(newBits, 4, newBits.length - 1, " ") : "()";
+                        reason = reason.substring(1, reason.length() - 1);
+
+                        coreChannelHandler.onChannelQuit(parser, channel, newChannelClient, reason);
+                        removeChannelClient(channel, newBits[0]);
+                        return;
+                    } else if (newBits[2].equalsIgnoreCase("kicked")) {
+                        // User was kicked from a relayed channel.
+                        String reason = (newBits.length > 7) ? mergeBits(newBits, 7, newBits.length - 1, " ") : "()";
+                        reason = reason.substring(1, reason.length() - 1);
+
+                        final IRCChannelClientInfo kickingChannelClient = (newBits.length > 6) ? getChannelClient(channel, newBits[6], joinNew) : null;
+
+                        coreChannelHandler.onChannelKick(parser, channel, newChannelClient, kickingChannelClient, reason, "");
+                        removeChannelClient(channel, newBits[0]);
+                        return;
+                    } else if (newBits[2].equalsIgnoreCase("now")) {
+                        // User changed their nickname in a relayed channel.
+                        if (newBits.length > 3) {
+                            renameChannelClient(newChannelClient, newBits[3]);
+
+                            coreChannelHandler.onChannelNickChanged(parser, channel, newChannelClient, newBits[0]);
+                            return;
+                        }
+                    }
+                }
+            } else if (initial.charAt(0) == '*') {
+                // Channel Action
+                final String[] newBits = bits[1].split(" ", 2);
+
+                final IRCChannelClientInfo newChannelClient = getChannelClient(channel, newBits[0], joinNew);
+
+                coreChannelHandler.onChannelAction(parser, channel, newChannelClient, newBits[1], "");
+                return;
+            }
+        }
+
+        // Pass it on unchanged.
+        coreChannelHandler.onChannelMessage(parser, channel, channelClient, message, host);
+    }
+
+    /**
+     * Merge the given bits.
+     *and
+     * @param bits Bits to merge
+     * @param start Start
+     * @param end end
+     * @param joiner What to use to join them
+     * @return Joined bits.
+     */
+    private String mergeBits(final String[] bits, final int start, final int end, final String joiner) {
+        final StringBuilder builder = new StringBuilder();
+        for (int i = start; i <= end; i++) {
+            if (bits.length < i) { break; }
+            if (i != start) { builder.append(joiner); }
+            builder.append(bits[i]);
+        }
+
+        return builder.toString();
+    }
+
+    /**
+     * Send an onChannelNames() event for this channel.
+     * This will cause all remote clients to vanish from the nicklist.
+     */
+    public void updateNames() {
+        coreChannelHandler.onChannelGotNames(myChannel.getServer().getParser(), myChannel.getChannelInfo());
+    }
+}

src/com/dmdirc/addons/relaybot/RelayClientInfo.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.relaybot;
+
+import com.dmdirc.parser.interfaces.Parser;
+import com.dmdirc.parser.irc.IRCClientInfo;
+import com.dmdirc.parser.irc.IRCParser;
+
+/**
+ * This class is used to proxy an IRCClientInfo and to show the nickname
+ * as nick@network.
+ */
+public class RelayClientInfo extends IRCClientInfo {
+    /** Shoulf getNickname() return the network aswell? */
+    private boolean showFullNickname = true;
+
+    /**
+     * Create a new RelayClientInfo
+     *
+     * @param parser Parser that owns this client
+     * @param host Host of client.
+     */
+    public RelayClientInfo(final Parser parser, final String host) {
+        super((IRCParser)parser, host);
+        super.setFake(true);
+    }
+
+    /**
+     * Should the full nickname (nick@server) be used by getNickname?
+     *
+     * @param value
+     */
+    public void setShowFullNickname(final boolean value) {
+        showFullNickname = value;
+    }
+
+    /**
+     * Will the full nickname (nick@server) be used by getNickname?
+     *
+     * @return true/false
+     */
+    public boolean getShowFullNickname() {
+        return showFullNickname;
+    }
+
+    /**
+     * Get the nickname of this client.
+     *
+     * @return The nickname of this client.
+     */
+    @Override
+    public String getNickname() {
+        return (showFullNickname) ? super.getNickname()+"@"+super.getHostname() : super.getNickname();
+    }
+
+    /**
+     * Change the nickname of this client.
+     *
+     * @param newNick new Nickname for this client.
+     */
+    public void changeNickname(final String newNick) {
+        setUserBits(newNick, true);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getHostname() {
+        return "";
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getUsername() {
+        return "";
+    }
+}

src/com/dmdirc/addons/relaybot/plugin.config

@@ -0,0 +1,28 @@
+# This is a DMDirc configuration file.
+
+# This section indicates which sections below take key/value
+# pairs, rather than a simple list. It should be placed above
+# any sections that take key/values.
+keysections:
+  metadata
+  version
+
+metadata:
+  author=Shane <shane@dmdirc.com>
+  mainclass=com.dmdirc.addon.relaybot.RelayBotPlugin
+  description=DMDirc support for relay bots.
+  name=relaybot
+  nicename=RelayBot Support
+
+updates:
+  id=50
+
+defaults:
+  colourFullName=true
+  joinOnDiscover=false
+  \#ircreport=IRelayBot
+  \#dmdirc=DMDirc
+
+version:
+  number=5
+  friendly=0.5