X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Firc%2FConnection.java;h=15c8ff50793487eeb6bec3b283a81bbfe1acee05;hb=5cc5fd2f2cc010e77448ca044c7679739add966f;hp=158a7f1b7d9533fa71c31b962094ac2ab621775e;hpb=3cc15ebd7eb8ade802b9a039873f6dbe5c185594;p=xudocci.git diff --git a/src/main/java/net/pterodactylus/irc/Connection.java b/src/main/java/net/pterodactylus/irc/Connection.java index 158a7f1..15c8ff5 100644 --- a/src/main/java/net/pterodactylus/irc/Connection.java +++ b/src/main/java/net/pterodactylus/irc/Connection.java @@ -27,33 +27,41 @@ import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.UnsupportedEncodingException; +import java.net.InetAddress; import java.net.Socket; +import java.net.UnknownHostException; import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.Set; -import java.util.concurrent.SynchronousQueue; +import java.util.logging.Level; +import java.util.logging.Logger; import javax.net.SocketFactory; import net.pterodactylus.irc.event.ChannelJoined; +import net.pterodactylus.irc.event.ChannelLeft; +import net.pterodactylus.irc.event.ChannelMessageReceived; import net.pterodactylus.irc.event.ChannelNicknames; import net.pterodactylus.irc.event.ChannelNotJoined; import net.pterodactylus.irc.event.ChannelNotJoined.Reason; import net.pterodactylus.irc.event.ChannelTopic; import net.pterodactylus.irc.event.ConnectionEstablished; import net.pterodactylus.irc.event.ConnectionFailed; +import net.pterodactylus.irc.event.DccSendReceived; import net.pterodactylus.irc.event.MotdReceived; import net.pterodactylus.irc.event.NicknameInUseReceived; import net.pterodactylus.irc.event.NoNicknameGivenReceived; +import net.pterodactylus.irc.event.PrivateMessageReceived; import net.pterodactylus.irc.event.UnknownReplyReceived; import net.pterodactylus.irc.util.RandomNickname; -import com.beust.jcommander.internal.Maps; -import com.beust.jcommander.internal.Sets; import com.google.common.base.Optional; +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; import com.google.common.eventbus.EventBus; -import com.google.common.eventbus.Subscribe; import com.google.common.io.Closeables; +import com.google.common.primitives.Ints; +import com.google.common.primitives.Longs; import com.google.common.util.concurrent.AbstractExecutionThreadService; import com.google.common.util.concurrent.Service; @@ -64,6 +72,9 @@ import com.google.common.util.concurrent.Service; */ public class Connection extends AbstractExecutionThreadService implements Service { + /* The logger. */ + private static final Logger logger = Logger.getLogger(Connection.class.getName()); + /** The event bus. */ private final EventBus eventBus; @@ -155,7 +166,7 @@ public class Connection extends AbstractExecutionThreadService implements Servic * * @param username * The username to use - * @return + * @return This connection */ public Connection username(String username) { this.username = Optional.fromNullable(username); @@ -191,47 +202,43 @@ public class Connection extends AbstractExecutionThreadService implements Servic // /** + * Checks whether the given source is the client represented by this + * connection. + * + * @param source + * The source to check + * @return {@code true} if this connection represents the given source, {@code + * false} otherwise + */ + public boolean isSource(Source source) { + return source.nick().isPresent() && source.nick().get().equals(nickname); + } + + /** * Joins the given channel. * * @param channel * The channel to join - * @return {@code true} if the channel was joined, {@code false} otherwise + * @throws IOException + * if an I/O error occurs */ - public boolean joinChannel(final String channel) { - final SynchronousQueue result = new SynchronousQueue(); - Object eventHandler = new Object() { - - @Subscribe - public void channelJoined(ChannelJoined channelJoined) throws InterruptedException { - if (!channelJoined.channel().equalsIgnoreCase(channel)) { - return; - } - Optional nickname = channelJoined.client().nick(); - if (!nickname.isPresent() || (nickname.isPresent() && nickname().equalsIgnoreCase(nickname.get()))) { - eventBus.unregister(this); - result.put(true); - } - } + public void joinChannel(final String channel) throws IOException { + connectionHandler.sendCommand("JOIN", channel); + } - @Subscribe - public void channelNotJoined(ChannelNotJoined channelNotJoined) throws InterruptedException { - if (!channelNotJoined.channel().equalsIgnoreCase(channel)) { - return; - } - eventBus.unregister(this); - result.put(false); - } - }; - eventBus.register(eventHandler); - try { - connectionHandler.sendCommand("JOIN", channel); - return result.take(); - } catch (IOException ioe1) { - eventBus.unregister(eventHandler); - } catch (InterruptedException ie1) { - /* TODO - how to handle? */ - } - return false; + /** + * Sends a message to the given recipient, which may be a channel or another + * nickname. + * + * @param recipient + * The recipient of the message + * @param message + * The message + * @throws IOException + * if an I/O error occurs + */ + public void sendMessage(String recipient, String message) throws IOException { + connectionHandler.sendCommand("PRIVMSG", recipient, message); } // @@ -276,15 +283,42 @@ public class Connection extends AbstractExecutionThreadService implements Servic /* server modes. */ Map nickPrefixes = Maps.newHashMap(); + Set channelTypes = Sets.newHashSet(); while (connected) { Reply reply = connectionHandler.readReply(); - System.err.println("<< " + reply); + logger.finest(String.format("<< %s", reply)); String command = reply.command(); List parameters = reply.parameters(); + /* most common events. */ + if (command.equalsIgnoreCase("PRIVMSG")) { + String recipient = parameters.get(0); + String message = parameters.get(1); + if (message.startsWith("\u0001") && message.endsWith("\u0001")) { + /* CTCP! */ + String[] messageWords = message.substring(1, message.length() - 1).split(" +"); + String ctcpCommand = messageWords[0]; + if (ctcpCommand.equalsIgnoreCase("DCC")) { + if (messageWords[1].equalsIgnoreCase("SEND")) { + Optional inetAddress = parseInetAddress(messageWords[3]); + Optional port = Optional.fromNullable(Ints.tryParse(messageWords[4])); + long fileSize = Optional.fromNullable(Longs.tryParse(messageWords[5])).or(-1L); + if (inetAddress.isPresent() && port.isPresent()) { + eventBus.post(new DccSendReceived(this, reply.source().get(), messageWords[2], inetAddress.get(), port.get(), fileSize)); + } else { + logger.warning(String.format("Received malformed DCC SEND: “%s”", message)); + } + } + } + } else if (!channelTypes.contains(recipient.charAt(0))) { + eventBus.post(new PrivateMessageReceived(this, reply.source().get(), message)); + } else { + eventBus.post(new ChannelMessageReceived(this, recipient, reply.source().get(), message)); + } + /* replies 001-004 don’t hold information but they have to be sent on a successful connection. */ - if (command.equals("001")) { + } else if (command.equals("001")) { connectionStatus |= 0x01; } else if (command.equals("002")) { connectionStatus |= 0x02; @@ -305,7 +339,13 @@ public class Connection extends AbstractExecutionThreadService implements Servic char modeSymbol = parameter.charAt(closeParen + modeCharacterIndex); nickPrefixes.put(String.valueOf(modeSymbol), String.valueOf(modeCharacter)); } + logger.fine(String.format("Parsed Prefixes: %s", nickPrefixes)); } + } else if (parameter.startsWith("CHANTYPES=")) { + for (int typeIndex = 10; typeIndex < parameter.length(); ++typeIndex) { + channelTypes.add(parameter.charAt(typeIndex)); + } + logger.fine(String.format("Parsed Channel Types: %s", channelTypes)); } } @@ -339,7 +379,6 @@ public class Connection extends AbstractExecutionThreadService implements Servic } else if (command.equals("332")) { eventBus.post(new ChannelTopic(this, parameters.get(1), parameters.get(2))); } else if (command.equals("353")) { - String channel = parameters.get(2); for (String nickname : parameters.get(3).split(" ")) { if (nickPrefixes.containsKey(nickname.substring(0, 1))) { nicks.add(new Nickname(nickname.substring(1), nickname.substring(0, 1))); @@ -349,8 +388,9 @@ public class Connection extends AbstractExecutionThreadService implements Servic } } else if (command.equals("366")) { eventBus.post(new ChannelNicknames(this, parameters.get(1), nicks)); - System.out.println("Found Nicknames: " + nicks); nicks.clear(); + } else if (command.equalsIgnoreCase("PART")) { + eventBus.post(new ChannelLeft(this, parameters.get(0), reply.source().get(), parameters.get(1))); /* common channel join errors. */ } else if (command.equals("474")) { @@ -376,9 +416,9 @@ public class Connection extends AbstractExecutionThreadService implements Servic oldConnectionStatus = connectionStatus; } } catch (IOException ioe1) { - ioe1.printStackTrace(); + logger.log(Level.WARNING, "I/O error", ioe1); } finally { - System.out.println("Closing Connection."); + logger.info("Closing Connection."); try { Closeables.close(connectionHandler, true); } catch (IOException ioe1) { @@ -412,6 +452,32 @@ public class Connection extends AbstractExecutionThreadService implements Servic return Optional.absent(); } + /** + * Parses the given {@code ip} and returns an {@link InetAddress} from it. + * + * @param ip + * The IP to parse + * @return The parsed inet address, or {@link Optional#absent()} if no inet + * address could be parsed + */ + private Optional parseInetAddress(String ip) { + Long ipNumber = Longs.tryParse(ip); + if (ipNumber == null) { + return Optional.absent(); + } + + StringBuilder hostname = new StringBuilder(15); + hostname.append((ipNumber >>> 24) & 0xff).append('.'); + hostname.append((ipNumber >>> 16) & 0xff).append('.'); + hostname.append((ipNumber >>> 8) & 0xff).append('.'); + hostname.append(ipNumber & 0xff); + try { + return Optional.of(InetAddress.getByName(hostname.toString())); + } catch (UnknownHostException uhe1) { + return Optional.absent(); + } + } + /** Handles input and output for the connection. */ private class ConnectionHandler implements Closeable { @@ -459,7 +525,7 @@ public class Connection extends AbstractExecutionThreadService implements Servic setParameters.add(maybeSetParameter.get()); } } - sendCommand(command, setParameters.toArray(new String[0])); + sendCommand(command, setParameters.toArray(new String[setParameters.size()])); } /** @@ -492,7 +558,7 @@ public class Connection extends AbstractExecutionThreadService implements Servic commandBuilder.append(parameter); } - System.out.println(">> " + commandBuilder.toString()); + logger.finest(String.format(">> %s", commandBuilder)); outputStream.write((commandBuilder.toString() + "\r\n").getBytes("UTF-8")); outputStream.flush(); }