X-Git-Url: https://git.pterodactylus.net/?p=xudocci.git;a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fxdcc%2Fcore%2FCore.java;h=d39ee2bd0ffe241a933ad8ae0c844f99c21a93f4;hp=33a22f81c3c6389e9bcd8681d04ec24f015003db;hb=d8c6d72caaa1ba75d09bd28f2bb10ae6f4964bf4;hpb=287af7be5a3fe79882649783649889f079451d27

diff --git a/src/main/java/net/pterodactylus/xdcc/core/Core.java b/src/main/java/net/pterodactylus/xdcc/core/Core.java
index 33a22f8..d39ee2b 100644
--- a/src/main/java/net/pterodactylus/xdcc/core/Core.java
+++ b/src/main/java/net/pterodactylus/xdcc/core/Core.java
@@ -17,6 +17,14 @@
 
 package net.pterodactylus.xdcc.core;
 
+import static java.lang.String.format;
+import static net.pterodactylus.irc.event.ChannelNotJoined.Reason.banned;
+import static net.pterodactylus.irc.event.ChannelNotJoined.Reason.inviteOnly;
+import static net.pterodactylus.irc.event.ChannelNotJoined.Reason.registeredNicknamesOnly;
+import static net.pterodactylus.irc.util.MessageCleaner.getDefaultInstance;
+import static net.pterodactylus.xdcc.data.Channel.TO_NETWORK;
+import static net.pterodactylus.xdcc.data.Download.FILTER_RUNNING;
+
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
@@ -24,31 +32,38 @@ import java.io.IOException;
 import java.io.OutputStream;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Set;
+import java.util.TreeMap;
 import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.logging.Logger;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import net.pterodactylus.irc.Connection;
-import net.pterodactylus.irc.ConnectionBuilder;
+import net.pterodactylus.irc.ConnectionFactory;
 import net.pterodactylus.irc.DccReceiver;
+import net.pterodactylus.irc.DefaultConnection;
 import net.pterodactylus.irc.event.ChannelJoined;
 import net.pterodactylus.irc.event.ChannelLeft;
 import net.pterodactylus.irc.event.ChannelMessageReceived;
+import net.pterodactylus.irc.event.ChannelNotJoined;
 import net.pterodactylus.irc.event.ClientQuit;
 import net.pterodactylus.irc.event.ConnectionClosed;
 import net.pterodactylus.irc.event.ConnectionEstablished;
+import net.pterodactylus.irc.event.ConnectionFailed;
 import net.pterodactylus.irc.event.DccAcceptReceived;
 import net.pterodactylus.irc.event.DccDownloadFailed;
 import net.pterodactylus.irc.event.DccDownloadFinished;
 import net.pterodactylus.irc.event.DccSendReceived;
+import net.pterodactylus.irc.event.KickedFromChannel;
 import net.pterodactylus.irc.event.NicknameChanged;
-import net.pterodactylus.irc.event.PrivateNoticeReceived;
 import net.pterodactylus.irc.event.PrivateMessageReceived;
-import net.pterodactylus.irc.util.MessageCleaner;
+import net.pterodactylus.irc.event.PrivateNoticeReceived;
+import net.pterodactylus.irc.event.ReplyReceived;
 import net.pterodactylus.irc.util.RandomNickname;
 import net.pterodactylus.xdcc.core.event.BotAdded;
 import net.pterodactylus.xdcc.core.event.CoreStarted;
@@ -60,17 +75,22 @@ import net.pterodactylus.xdcc.core.event.GenericMessage;
 import net.pterodactylus.xdcc.core.event.MessageReceived;
 import net.pterodactylus.xdcc.data.Bot;
 import net.pterodactylus.xdcc.data.Channel;
+import net.pterodactylus.xdcc.data.ConnectedNetwork;
 import net.pterodactylus.xdcc.data.Download;
 import net.pterodactylus.xdcc.data.Network;
 import net.pterodactylus.xdcc.data.Pack;
 import net.pterodactylus.xdcc.data.Server;
 
 import com.google.common.base.Optional;
+import com.google.common.base.Predicate;
+import com.google.common.collect.FluentIterable;
 import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.HashMultimap;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
 import com.google.common.collect.Sets;
 import com.google.common.collect.Table;
 import com.google.common.eventbus.EventBus;
@@ -78,6 +98,7 @@ import com.google.common.eventbus.Subscribe;
 import com.google.common.io.Closeables;
 import com.google.common.util.concurrent.AbstractExecutionThreadService;
 import com.google.inject.Inject;
+import org.apache.log4j.Logger;
 
 /**
  * The core of XDCC Downloader.
@@ -89,8 +110,13 @@ public class Core extends AbstractExecutionThreadService {
 	/** The logger. */
 	private static final Logger logger = Logger.getLogger(Core.class.getName());
 
+	private final Object syncObject = new Object();
 	/** The event bus. */
 	private final EventBus eventBus;
+	private final ConnectionFactory connectionFactory;
+	private final ChannelBanManager channelBanManager =
+			new ChannelBanManager();
+	private final ConnectionBackoff connectionBackoff = new ConnectionBackoff();
 
 	/** The temporary directory to download files to. */
 	private final String temporaryDirectory;
@@ -103,6 +129,7 @@ public class Core extends AbstractExecutionThreadService {
 
 	/** The channels that are currentlymonitored. */
 	private final Collection<Channel> joinedChannels = Sets.newHashSet();
+	private final Set<Channel> channelsBeingJoined = new HashSet<>();
 
 	/** The channels that are joined but not configured. */
 	private final Collection<Channel> extraChannels = Sets.newHashSet();
@@ -114,7 +141,7 @@ public class Core extends AbstractExecutionThreadService {
 	private final Table<Network, String, Bot> networkBots = HashBasedTable.create();
 
 	/** The current downloads. */
-	private final Map<String, Download> downloads = Maps.newHashMap();
+	private final Multimap<String, Download> downloads = HashMultimap.create();
 
 	/** The current DCC receivers. */
 	private final Collection<DccReceiver> dccReceivers = Lists.newArrayList();
@@ -130,8 +157,9 @@ public class Core extends AbstractExecutionThreadService {
 	 * 		The directory to move finished files to
 	 */
 	@Inject
-	public Core(EventBus eventBus, String temporaryDirectory, String finalDirectory) {
+	public Core(EventBus eventBus, ConnectionFactory connectionFactory, String temporaryDirectory, String finalDirectory) {
 		this.eventBus = eventBus;
+		this.connectionFactory = connectionFactory;
 		this.temporaryDirectory = temporaryDirectory;
 		this.finalDirectory = finalDirectory;
 	}
@@ -141,6 +169,50 @@ public class Core extends AbstractExecutionThreadService {
 	//
 
 	/**
+	 * Returns all currently known connections.
+	 *
+	 * @return All currently known connections
+	 */
+	public Collection<Connection> connections() {
+		return networkConnections.values();
+	}
+
+	/**
+	 * Returns all defined networks.
+	 *
+	 * @return All defined networks
+	 */
+	public Collection<Network> networks() {
+		return FluentIterable.from(channels).transform(TO_NETWORK).toSet();
+	}
+
+	/**
+	 * Returns all connected networks.
+	 *
+	 * @return All connected networks
+	 */
+	public Collection<ConnectedNetwork> connectedNetworks() {
+		return networkConnections.entrySet().stream().map((entry) -> {
+			Network network = entry.getKey();
+			Collection<Bot> bots = networkBots.row(network).values();
+			int packCount = bots.stream().mapToInt((bot) -> bot.packs().size()).reduce((a, b) -> a + b).orElse(0);
+			return new ConnectedNetwork(network, entry.getValue().hostname(),
+					entry.getValue().port(), entry.getValue().nickname(),
+					channels.stream()
+							.filter((channel) -> channel.network()
+									.equals(network))
+							.map(Channel::name)
+							.collect(Collectors.<String>toList()),
+					extraChannels.stream()
+							.filter((channel) -> channel.network()
+									.equals(network))
+							.map(Channel::name)
+							.collect(Collectors.<String>toList()),
+					bots.size(), packCount);
+		}).collect(Collectors.<ConnectedNetwork>toList());
+	}
+
+	/**
 	 * Returns all configured channels. Due to various circumstances, configured
 	 * channels might not actually be joined.
 	 *
@@ -214,13 +286,83 @@ public class Core extends AbstractExecutionThreadService {
 			return;
 		}
 
+		/* check if we are already downloading the file? */
+		if (downloads.containsKey(pack.name())) {
+			Collection<Download> packDownloads = downloads.get(pack.name());
+			Collection<Download> runningDownloads = FluentIterable.from(packDownloads).filter(FILTER_RUNNING).toSet();
+			if (!runningDownloads.isEmpty()) {
+				Download download = runningDownloads.iterator().next();
+				eventBus.post(new GenericMessage(String.format("File %s is already downloading from %s (%s).", pack.name(), download.bot().name(), download.bot().network().name())));
+				return;
+			}
+			StringBuilder bots = new StringBuilder();
+			for (Download download : packDownloads) {
+				if (bots.length() > 0) {
+					bots.append(", ");
+				}
+				bots.append(download.bot().name()).append(" (").append(download.bot().network().name()).append(')');
+			}
+			eventBus.post(new GenericMessage(String.format("File %s is already requested from %d bots (%s).", pack.name(), packDownloads.size(), bots.toString())));
+		}
+
 		Download download = new Download(bot, pack);
 		downloads.put(pack.name(), download);
 
 		try {
 			connection.sendMessage(bot.name(), "XDCC SEND " + pack.id());
 		} catch (IOException ioe1) {
-			logger.log(Level.WARNING, "Could not send message to bot!", ioe1);
+			logger.warn("Could not send message to bot!", ioe1);
+		}
+	}
+
+	/**
+	 * Cancels the download of the given pack from the given bot.
+	 *
+	 * @param bot
+	 * 		The bot the pack is being downloaded from
+	 * @param pack
+	 * 		The pack being downloaded
+	 */
+	public void cancelDownload(Bot bot, Pack pack) {
+		Optional<Download> download = getDownload(pack, bot);
+		if (!download.isPresent()) {
+			return;
+		}
+
+		/* get connection. */
+		Connection connection = networkConnections.get(bot.network());
+		if (connection == null) {
+			/* request for unknown network? */
+			return;
+		}
+
+		/* stop the DCC receiver. */
+		if (download.get().dccReceiver() != null) {
+			download.get().dccReceiver().stop();
+		} else {
+			/* remove download if it hasn’t started yet. */
+			downloads.remove(pack.name(), download.get());
+		}
+
+		/* remove the request from the bot, too. */
+		try {
+			connection.sendMessage(bot.name(), String.format("XDCC %s", (download.get().dccReceiver() != null) ? "CANCEL" : "REMOVE"));
+		} catch (IOException ioe1) {
+			logger.warn(String.format("Could not cancel DCC from %s (%s)!", bot.name(), bot.network().name()), ioe1);
+		}
+	}
+
+	/**
+	 * Closes the given connection.
+	 *
+	 * @param connection
+	 * 		The connection to close
+	 */
+	public void closeConnection(Connection connection) {
+		try {
+			connection.close();
+		} catch (IOException ioe1) {
+			/* TODO */
 		}
 	}
 
@@ -242,30 +384,82 @@ public class Core extends AbstractExecutionThreadService {
 	@Override
 	protected void run() throws Exception {
 		while (isRunning()) {
-			try {
-				Thread.sleep(TimeUnit.MINUTES.toMillis(1));
-			} catch (InterruptedException ie1) {
-				/* ignore. */
-			}
 
-			/* find channels that should be monitored but are not. */
+			Set<Channel> missingChannels = new HashSet<>();
 			for (Channel channel : channels) {
-				if (joinedChannels.contains(channel)) {
+				if (joinedChannels.contains(channel) || channelsBeingJoined.contains(channel)) {
+					continue;
+				}
+				if (channelBanManager.isBanned(channel)) {
 					continue;
 				}
+				if (!networkConnections.containsKey(channel.network()) || networkConnections.get(channel.network()).established()) {
+					missingChannels.add(channel);
+				}
+			}
+			Set<Network> missingNetworks = missingChannels.stream()
+					.map(Channel::network)
+					.distinct()
+					.filter((network) -> !networkConnections.containsKey(network))
+					.collect(Collectors.toSet());
+
+			if (missingNetworks.isEmpty()) {
+				if (!missingChannels.isEmpty()) {
+					for (Channel missingChannel : missingChannels) {
+						Network network = missingChannel.network();
+						eventBus.post(new GenericMessage(String.format("Trying to join %s on %s...", missingChannel.name(), network)));
+						try {
+							channelsBeingJoined.add(missingChannel);
+							networkConnections.get(network).joinChannel(missingChannel.name());
+						} catch (IOException ioe1) {
+							logger.warn(String.format("Could not join %s on %s!", missingChannel.name(), network.name()), ioe1);
+						}
+					}
+				} else {
+					synchronized (syncObject) {
+						try {
+							syncObject.wait(TimeUnit.MINUTES.toMillis(1));
+						} catch (InterruptedException ie1) {
+						/* ignore. */
+						}
+					}
+				}
+				continue;
+			}
+
+			Map<Long, Network> timesForNextConnects = new TreeMap<>(missingNetworks.stream()
+					.collect(Collectors.toMap(connectionBackoff::getConnectionTime, Function.identity(), (network, ignore) -> network)));
 
-				connectNetwork(channel.network());
-				Connection connection = networkConnections.get(channel.network());
-				if (connection.established()) {
-					eventBus.post(new GenericMessage(String.format("Trying to join %s on %s.", channel.name(), channel.network().name())));
-					connection.joinChannel(channel.name());
+			Optional<Entry<Long, Network>> firstNetwork = Optional.fromNullable(timesForNextConnects.entrySet().stream().findFirst().orElse(null));
+			if (!firstNetwork.isPresent()) {
+				continue;
+			}
+			if (firstNetwork.get().getKey() > System.currentTimeMillis()) {
+				eventBus.post(new GenericMessage(String.format("Will connect to %2$s at %1$tH:%1$tM...", firstNetwork.get().getKey(), firstNetwork.get().getValue().name())));
+				synchronized (syncObject) {
+					try {
+						syncObject.wait(firstNetwork.get().getKey() - System.currentTimeMillis());
+					} catch (InterruptedException ie1) {
+						/* ignore. */
+					}
+				}
+				if (!isRunning()) {
+					break;
+				}
+				if (firstNetwork.get().getKey() > System.currentTimeMillis()) {
+					continue;
 				}
 			}
+
+			connectNetwork(firstNetwork.get().getValue());
 		}
 	}
 
 	@Override
-	protected void shutDown() {
+	protected void triggerShutdown() {
+		synchronized (syncObject) {
+			syncObject.notifyAll();
+		}
 	}
 
 	//
@@ -288,11 +482,52 @@ public class Core extends AbstractExecutionThreadService {
 				return;
 			}
 			Server server = servers.get((int) (Math.random() * servers.size()));
-			Connection connection = new ConnectionBuilder(eventBus).connect(server.hostname()).port(server.unencryptedPorts().iterator().next()).build();
+			eventBus.post(new GenericMessage(String.format("Connecting to %s on %s...", network.name(), server.hostname())));
+			Connection connection = connectionFactory.createConnection(server.hostname(),
+					server.unencryptedPorts().iterator().next());
 			connection.username(RandomNickname.get()).realName(RandomNickname.get());
 			networkConnections.put(network, connection);
-			connection.start();
+			connection.open();
+		}
+	}
+
+	/**
+	 * Removes the given connection and all its channels and bots.
+	 *
+	 * @param connection
+	 * 		The connection to remove
+	 */
+	private void removeConnection(Connection connection) {
+		Optional<Network> network = getNetwork(connection);
+		if (!network.isPresent()) {
+			return;
+		}
+		networkConnections.remove(network.get());
+		if (!connection.established()) {
+			return;
+		}
+
+		/* find all channels that need to be removed. */
+		for (Collection<Channel> channels : ImmutableList.of(joinedChannels, extraChannels)) {
+			for (Iterator<Channel> channelIterator = channels.iterator(); channelIterator.hasNext(); ) {
+				Channel joinedChannel = channelIterator.next();
+				if (!joinedChannel.network().equals(network.get())) {
+					continue;
+				}
+
+				channelIterator.remove();
+			}
+		}
+
+		/* now remove all bots for that network. */
+		Map<String, Bot> bots = networkBots.row(network.get());
+		int botCount = bots.size();
+		int packCount = 0;
+		for (Bot bot : bots.values()) {
+			packCount += bot.packs().size();
 		}
+		bots.clear();
+		eventBus.post(new GenericMessage(String.format("Network %s disconnected, %d bots removed, %d packs removed.", network.get().name(), botCount, packCount)));
 	}
 
 	//
@@ -314,16 +549,21 @@ public class Core extends AbstractExecutionThreadService {
 
 		/* found network? */
 		if (!network.isPresent()) {
+			eventBus.post(new GenericMessage(String.format("Connected to unknown network: %s", connectionEstablished.connection().hostname())));
 			return;
 		}
 
+		connectionBackoff.connectionSuccessful(network.get());
+		eventBus.post(new GenericMessage(String.format("Connected to network %s.", network.get().name())));
+
 		/* join all channels on this network. */
 		for (Channel channel : channels) {
 			if (channel.network().equals(network.get())) {
 				try {
+					eventBus.post(new GenericMessage(String.format("Trying to join %s on %s...", channel.name(), network.get().name())));
 					connectionEstablished.connection().joinChannel(channel.name());
 				} catch (IOException ioe1) {
-					logger.log(Level.WARNING, String.format("Could not join %s on %s!", channel.name(), network.get().name()), ioe1);
+					logger.warn(String.format("Could not join %s on %s!", channel.name(), network.get().name()), ioe1);
 				}
 			}
 		}
@@ -337,35 +577,28 @@ public class Core extends AbstractExecutionThreadService {
 	 */
 	@Subscribe
 	public void connectionClosed(ConnectionClosed connectionClosed) {
-		Optional<Network> network = getNetwork(connectionClosed.connection());
-		if (!network.isPresent()) {
-			return;
-		}
-
-		/* find all channels that need to be removed. */
-		for (Collection channels : ImmutableList.of(joinedChannels, extraChannels)) {
-			for (Iterator<Channel> channelIterator = channels.iterator(); channelIterator.hasNext(); ) {
-				Channel joinedChannel = channelIterator.next();
-				if (!joinedChannel.network().equals(network.get())) {
-					continue;
-				}
-
-				channelIterator.remove();
-			}
+		connectionBackoff.connectionFailed(getNetwork(connectionClosed.connection()).get());
+		removeConnection(connectionClosed.connection());
+		synchronized (syncObject) {
+			syncObject.notifyAll();
 		}
+		eventBus.post(new GenericMessage(String.format("Connection closed by %s.", connectionClosed.connection().hostname())));
+	}
 
-		/* now remove all bots for that network. */
-		Map<String, Bot> bots = networkBots.row(network.get());
-		int botCount = bots.size();
-		int packCount = 0;
-		for (Bot bot : bots.values()) {
-			packCount += bot.packs().size();
+	/**
+	 * Remove all data stored for a network if the connection fails.
+	 *
+	 * @param connectionFailed
+	 * 		The connection failed event
+	 */
+	@Subscribe
+	public void connectionFailed(ConnectionFailed connectionFailed) {
+		connectionBackoff.connectionFailed(getNetwork(connectionFailed.connection()).get());
+		removeConnection(connectionFailed.connection());
+		synchronized (syncObject) {
+			syncObject.notifyAll();
 		}
-		bots.clear();
-		eventBus.post(new GenericMessage(String.format("Network %s disconnected, %d bots removed, %d packs removed.", network.get().name(), botCount, packCount)));
-
-		/* now remove the network. */
-		networkConnections.remove(network.get());
+		eventBus.post(new GenericMessage(String.format("Could not connect to %s: %s.", connectionFailed.connection().hostname(), connectionFailed.cause())));
 	}
 
 	/**
@@ -390,11 +623,60 @@ public class Core extends AbstractExecutionThreadService {
 				return;
 			}
 
+			channelBanManager.unban(channel.get());
 			joinedChannels.add(channel.get());
+			channelsBeingJoined.remove(channel.get());
 			logger.info(String.format("Joined Channel %s on %s.", channelJoined.channel(), network.get().name()));
 		}
 	}
 
+	@Subscribe
+	public void channelNotJoined(ChannelNotJoined channelNotJoined) {
+		Optional<Network> network = getNetwork(channelNotJoined.connection());
+		if (!network.isPresent()) {
+			return;
+		}
+
+		Optional<Channel> channel = getChannel(network.get(), channelNotJoined.channel());
+		synchronized (syncObject) {
+			syncObject.notifyAll();
+		}
+		if (!channel.isPresent()) {
+			eventBus.post(new GenericMessage(format("Could not join %s but didn’t try to join, either.", channelNotJoined.channel())));
+			return;
+		}
+		channelsBeingJoined.remove(channel.get());
+
+
+		/* remove all bots for this channel, we might have been kicked. */
+		Collection<Bot> botsToRemove = networkBots.row(network.get())
+				.values().stream()
+				.filter(bot -> bot.channel()
+						.equalsIgnoreCase(channel.get().name()))
+				.collect(Collectors.toSet());
+		botsToRemove.stream()
+				.forEach(bot -> networkBots.row(network.get())
+						.remove(bot.name()));
+
+		channelBanManager.ban(channel.get());
+		if (channelNotJoined.reason() == registeredNicknamesOnly) {
+			eventBus.post(new GenericMessage(
+					format("Not trying to join %s anymore.", channel.get())));
+		} else if (channelNotJoined.reason() == inviteOnly) {
+			eventBus.post(new GenericMessage(
+					format("%s is invite-only, suspending join for a day.",
+							channel.get())));
+		} else if (channelNotJoined.reason() == banned) {
+			eventBus.post(new GenericMessage(
+					format("Banned from %s, suspending join for a day.",
+							channel.get())));
+		} else {
+			eventBus.post(new GenericMessage(
+					format("Could not join %s: %s", channelNotJoined.channel(),
+							channelNotJoined.reason())));
+		}
+	}
+
 	/**
 	 * Removes bots that leave a channel, or channels when it’s us that’s leaving.
 	 *
@@ -425,6 +707,9 @@ public class Core extends AbstractExecutionThreadService {
 				} else {
 					channels.remove(channel.get());
 				}
+				synchronized (syncObject) {
+					syncObject.notifyAll();
+				}
 
 				eventBus.post(new GenericMessage(String.format("Left Channel %s on %s.", channel.get().name(), channel.get().network().name())));
 			}
@@ -432,12 +717,47 @@ public class Core extends AbstractExecutionThreadService {
 			return;
 		}
 
-		Bot removedBot = networkBots.remove(network.get(), channelLeft.client().nick().get());
-		if (removedBot != null) {
-			eventBus.post(new GenericMessage(String.format("Bot %s (%s) was removed, %d packs removed.", removedBot.name(), removedBot.network().name(), removedBot.packs().size())));
+		networkBots.remove(network.get(), channelLeft.client().nick().get());
+	}
+
+	@Subscribe
+	public void kickedFromChannel(KickedFromChannel kickedFromChannel) {
+		Optional<Network> network = getNetwork(kickedFromChannel.connection());
+		if (!network.isPresent()) {
+			return;
+		}
+
+		/* have we been kicked? */
+		if (nicknameMatchesConnection(kickedFromChannel.connection(), kickedFromChannel.kickee())) {
+			Optional<Channel> channel = getChannel(network.get(), kickedFromChannel.channel());
+			if (!channel.isPresent()) {
+				/* maybe it was an extra channel? */
+				channel = getExtraChannel(network.get(), kickedFromChannel.channel());
+				if (!channel.isPresent()) {
+					/* okay, whatever. */
+					return;
+				}
+
+				extraChannels.remove(channel.get());
+			} else {
+				joinedChannels.remove(channel.get());
+			}
+			synchronized (syncObject) {
+				syncObject.notifyAll();
+			}
+			eventBus.post(new GenericMessage(format(
+					"Kicked from %s by %s: %s",
+					kickedFromChannel.channel(),
+					kickedFromChannel.kicker(),
+					kickedFromChannel.reason().or("<unknown>")
+			)));
 		}
 	}
 
+	private boolean nicknameMatchesConnection(Connection connection, String nickname) {
+		return connection.nickname().equalsIgnoreCase(nickname);
+	}
+
 	/**
 	 * Removes a client (which may be a bot) from the table of known bots.
 	 *
@@ -451,10 +771,7 @@ public class Core extends AbstractExecutionThreadService {
 			return;
 		}
 
-		Bot removedBot = networkBots.remove(network.get(), clientQuit.client().nick().get());
-		if (removedBot != null) {
-			eventBus.post(new GenericMessage(String.format("Bot %s (%s) was removed, %d packs removed.", removedBot.name(), removedBot.network().name(), removedBot.packs().size())));
-		}
+		networkBots.remove(network.get(), clientQuit.client().nick().get());
 	}
 
 	/**
@@ -488,7 +805,7 @@ public class Core extends AbstractExecutionThreadService {
 	 */
 	@Subscribe
 	public void channelMessageReceived(ChannelMessageReceived channelMessageReceived) {
-		String message = MessageCleaner.getDefaultInstance().clean(channelMessageReceived.message());
+		String message = getDefaultInstance().clean(channelMessageReceived.message());
 		if (!message.startsWith("#")) {
 			/* most probably not a pack announcement. */
 			return;
@@ -509,7 +826,8 @@ public class Core extends AbstractExecutionThreadService {
 		Bot bot;
 		synchronized (networkBots) {
 			if (!networkBots.contains(network.get(), channelMessageReceived.source().nick().get())) {
-				bot = new Bot(network.get()).name(channelMessageReceived.source().nick().get());
+				bot = new Bot(network.get(), channelMessageReceived.channel(),
+						channelMessageReceived.source().nick().get());
 				networkBots.put(network.get(), channelMessageReceived.source().nick().get(), bot);
 				eventBus.post(new BotAdded(bot));
 			} else {
@@ -519,7 +837,7 @@ public class Core extends AbstractExecutionThreadService {
 
 		/* add pack. */
 		bot.addPack(pack.get());
-		logger.fine(String.format("Bot %s now has %d packs.", bot, bot.packs().size()));
+		logger.debug(String.format("Bot %s now has %d packs.", bot, bot.packs().size()));
 	}
 
 	/**
@@ -546,7 +864,7 @@ public class Core extends AbstractExecutionThreadService {
 			return;
 		}
 
-		eventBus.post(new GenericMessage(String.format("Notice from %s (%s): %s", privateNoticeReceived.reply().source(), network.get(), privateNoticeReceived.text())));
+		eventBus.post(new GenericMessage(String.format("Notice from %s (%s): %s", privateNoticeReceived.source(), network.get(), privateNoticeReceived.text())));
 	}
 
 	/**
@@ -556,18 +874,41 @@ public class Core extends AbstractExecutionThreadService {
 	 * 		The DCC SEND event
 	 */
 	@Subscribe
-	public void dccSendReceived(DccSendReceived dccSendReceived) {
-		Optional<Network> network = getNetwork(dccSendReceived.connection());
+	public void dccSendReceived(final DccSendReceived dccSendReceived) {
+		final Optional<Network> network = getNetwork(dccSendReceived.connection());
 		if (!network.isPresent()) {
 			return;
 		}
 
-		Download download = downloads.get(dccSendReceived.filename());
-		if (download == null) {
+		Collection<Download> packDownloads = downloads.get(dccSendReceived.filename());
+		if (packDownloads.isEmpty()) {
 			/* unknown download, ignore. */
 			return;
 		}
 
+		/* check if it’s already downloading. */
+		Collection<Download> runningDownloads = FluentIterable.from(packDownloads).filter(FILTER_RUNNING).toSet();
+		if (!runningDownloads.isEmpty()) {
+			eventBus.post(new GenericMessage(String.format("Ignoring offer for %s, it’s already being downloaded.", dccSendReceived.filename())));
+			return;
+		}
+
+		/* locate the correct download. */
+		Collection<Download> requestedDownload = FluentIterable.from(packDownloads).filter(new Predicate<Download>() {
+
+			@Override
+			public boolean apply(Download download) {
+				return download.bot().network().equals(network.get()) && download.bot().name().equalsIgnoreCase(dccSendReceived.source().nick().get());
+			}
+		}).toSet();
+
+		/* we did not request this download. */
+		if (requestedDownload.isEmpty()) {
+			return;
+		}
+
+		Download download = requestedDownload.iterator().next();
+
 		/* check if the file already exists. */
 		File outputFile = new File(temporaryDirectory, dccSendReceived.filename());
 		if (outputFile.exists()) {
@@ -583,7 +924,7 @@ public class Core extends AbstractExecutionThreadService {
 				}
 
 				/* remove download. */
-				downloads.remove(download.pack().name());
+				downloads.removeAll(download.pack().name());
 				return;
 			}
 
@@ -612,25 +953,48 @@ public class Core extends AbstractExecutionThreadService {
 	}
 
 	@Subscribe
-	public void dccAcceptReceived(DccAcceptReceived dccAcceptReceived) {
-		Optional<Network> network = getNetwork(dccAcceptReceived.connection());
+	public void dccAcceptReceived(final DccAcceptReceived dccAcceptReceived) {
+		final Optional<Network> network = getNetwork(dccAcceptReceived.connection());
 		if (!network.isPresent()) {
 			return;
 		}
 
-		Download download = downloads.get(dccAcceptReceived.filename());
-		if (download == null) {
+		Collection<Download> packDownloads = downloads.get(dccAcceptReceived.filename());
+		if (packDownloads.isEmpty()) {
 			/* unknown download, ignore. */
 			return;
 		}
 
+		/* check if it’s already downloading. */
+		Collection<Download> runningDownloads = FluentIterable.from(packDownloads).filter(FILTER_RUNNING).toSet();
+		if (!runningDownloads.isEmpty()) {
+			eventBus.post(new GenericMessage(String.format("Ignoring offer for %s, it’s already being downloaded.", dccAcceptReceived.filename())));
+			return;
+		}
+
+		/* locate the correct download. */
+		Collection<Download> requestedDownload = FluentIterable.from(packDownloads).filter(new Predicate<Download>() {
+
+			@Override
+			public boolean apply(Download download) {
+				return download.bot().network().equals(network.get()) && download.bot().name().equalsIgnoreCase(dccAcceptReceived.source().nick().get());
+			}
+		}).toSet();
+
+		/* we did not request this download. */
+		if (requestedDownload.isEmpty()) {
+			return;
+		}
+
+		Download download = requestedDownload.iterator().next();
+
 		try {
 			File outputFile = new File(temporaryDirectory, dccAcceptReceived.filename());
 			if (outputFile.length() != dccAcceptReceived.position()) {
 				eventBus.post(new GenericError(String.format("Download %s from %s does not start at the right position!")));
-				logger.log(Level.WARNING, String.format("Download %s from %s: have %d bytes but wants to resume from %d!", dccAcceptReceived.filename(), dccAcceptReceived.source(), outputFile.length(), dccAcceptReceived.position()));
+				logger.warn(String.format("Download %s from %s: have %d bytes but wants to resume from %d!", dccAcceptReceived.filename(), dccAcceptReceived.source(), outputFile.length(), dccAcceptReceived.position()));
 
-				downloads.remove(download.pack().name());
+				downloads.removeAll(download.pack().name());
 				return;
 			}
 			OutputStream outputStream = new FileOutputStream(outputFile, true);
@@ -652,11 +1016,15 @@ public class Core extends AbstractExecutionThreadService {
 	 */
 	@Subscribe
 	public void dccDownloadFinished(DccDownloadFinished dccDownloadFinished) {
-		Download download = downloads.get(dccDownloadFinished.dccReceiver().filename());
-		if (download == null) {
-			/* probably shouldn’t happen. */
+
+		/* locate the correct download. */
+		Collection<Download> requestedDownload = FluentIterable.from(downloads.get(dccDownloadFinished.dccReceiver().filename())).filter(FILTER_RUNNING).toSet();
+		if (requestedDownload.isEmpty()) {
+			/* this seems wrong. */
+			logger.warn("Download finished but could not be located.");
 			return;
 		}
+		Download download = requestedDownload.iterator().next();
 
 		try {
 			download.outputStream().close();
@@ -664,10 +1032,10 @@ public class Core extends AbstractExecutionThreadService {
 			file.renameTo(new File(finalDirectory, download.pack().name()));
 			eventBus.post(new DownloadFinished(download));
 			dccReceivers.remove(dccDownloadFinished.dccReceiver());
-			downloads.remove(download.pack().name());
+			downloads.removeAll(download.pack().name());
 		} catch (IOException ioe1) {
 			/* TODO - handle all the errors. */
-			logger.log(Level.WARNING, String.format("Could not move file %s to directory %s.", download.filename(), finalDirectory), ioe1);
+			logger.warn(String.format("Could not move file %s to directory %s.", download.filename(), finalDirectory), ioe1);
 		}
 	}
 
@@ -679,27 +1047,58 @@ public class Core extends AbstractExecutionThreadService {
 	 */
 	@Subscribe
 	public void dccDownloadFailed(DccDownloadFailed dccDownloadFailed) {
-		Download download = downloads.get(dccDownloadFailed.dccReceiver().filename());
-		if (download == null) {
-			/* probably shouldn’t happen. */
+
+		/* locate the correct download. */
+		Collection<Download> requestedDownload = FluentIterable.from(downloads.get(dccDownloadFailed.dccReceiver().filename())).filter(FILTER_RUNNING).toSet();
+		if (requestedDownload.isEmpty()) {
+			/* this seems wrong. */
+			logger.warn("Download finished but could not be located.");
 			return;
 		}
+		Download download = requestedDownload.iterator().next();
 
 		try {
 			Closeables.close(download.outputStream(), true);
 			eventBus.post(new DownloadFailed(download));
 			dccReceivers.remove(dccDownloadFailed.dccReceiver());
-			downloads.remove(download.pack().name());
+			downloads.removeAll(download.pack().name());
 		} catch (IOException ioe1) {
 			/* swallow silently. */
 		}
 	}
 
+	@Subscribe
+	public void replyReceived(ReplyReceived replyReceived) {
+		logger.trace(String.format("%s: %s", replyReceived.connection().hostname(), replyReceived.reply()));
+	}
+
 	//
 	// PRIVATE METHODS
 	//
 
 	/**
+	 * Returns the download of the given pack from the given bot.
+	 *
+	 * @param pack
+	 * 		The pack being downloaded
+	 * @param bot
+	 * 		The bot the pack is being downloaded from
+	 * @return The download, or {@link Optional#absent()} if the download could not
+	 *         be found
+	 */
+	private Optional<Download> getDownload(Pack pack, Bot bot) {
+		if (!downloads.containsKey(pack.name())) {
+			return Optional.absent();
+		}
+		for (Download download : Lists.newArrayList(downloads.get(pack.name()))) {
+			if (download.bot().equals(bot)) {
+				return Optional.of(download);
+			}
+		}
+		return Optional.absent();
+	}
+
+	/**
 	 * Searches all current connections for the given connection, returning the
 	 * associated network.
 	 *