Merge pull request #111 from ShaneMcC/master

Try to keep track of channel keys (Close Issue #108)

common/src/com/dmdirc/parser/common/BaseChannelInfo.java

         return parser;
     }
 
+    @Override
+    public String getPassword() {
+        return "";
+    }
+
     @Override
     public void sendMessage(final String message) {
         parser.sendMessage(name, message);

common/src/com/dmdirc/parser/events/ChannelPasswordChangedEvent.java

+/*
+ * Copyright (c) 2006-2014 DMDirc Developers
+ *
+ * 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.parser.events;
+
+import com.dmdirc.parser.interfaces.ChannelInfo;
+import com.dmdirc.parser.interfaces.Parser;
+
+import java.time.LocalDateTime;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Called when a channel password changes.
+ */
+public class ChannelPasswordChangedEvent extends ParserEvent {
+
+    private final ChannelInfo channel;
+
+    public ChannelPasswordChangedEvent(final Parser parser, final LocalDateTime date,
+                                  final ChannelInfo channel) {
+        super(parser, date);
+        this.channel = checkNotNull(channel);
+    }
+
+    public ChannelInfo getChannel() {
+        return channel;
+    }
+}

common/src/com/dmdirc/parser/interfaces/ChannelInfo.java

      */
     String getName();
 
+    /**
+     * Returns the password for this channel.
+     *
+     * @return The password for this channel
+     */
+    String getPassword();
+
     /**
      * Changes the topic of this channel.
      *

irc/src/com/dmdirc/parser/irc/IRCChannelInfo.java

 import com.dmdirc.parser.common.ChannelListModeItem;
 import com.dmdirc.parser.common.ParserError;
 import com.dmdirc.parser.common.QueuePriority;
+import com.dmdirc.parser.events.ChannelPasswordChangedEvent;
 import com.dmdirc.parser.interfaces.ChannelClientInfo;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.ClientInfo;
 import com.dmdirc.parser.interfaces.Parser;
 
+import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
     private final PrefixModeManager prefixModeManager;
     /** Channel Name. */
     private final String name;
+    /** Channel Key. */
+    private String password = "";
     /** Hashtable containing references to ChannelClients. */
     private final Map<String, IRCChannelClientInfo> clients = Collections.synchronizedMap(new HashMap<>());
     /** Hashtable storing values for modes set in the channel that use parameters. */
         return topicUser;
     }
 
+    @Override
+    public String getPassword() {
+        return password;
+    }
+
+    /**
+     * Set the internal value of the channel password,
+     *
+     * @param newValue New Value to set
+     */
+    public void setInternalPassword(final String newValue) {
+        password = newValue;
+        parser.getCallbackManager().publish(new ChannelPasswordChangedEvent(parser, LocalDateTime.now(), this));
+    }
+
     /**
      * Set the channel modes.
      *
             }
         } else {
             paramModes.put(cMode, sValue);
+            if (cMode == 'k') {
+                if (sValue.equalsIgnoreCase("*") && !getPassword().equalsIgnoreCase("*")) {
+                    // Don't overwrite a guessed password with a hidden one.
+                    return;
+                }
+                setInternalPassword(sValue);
+            }
         }
     }
 

irc/src/com/dmdirc/parser/irc/IRCParser.java

     private final WhoisResponseHandler whoisHandler;
     /** Used to synchronize calls to resetState. */
     private final Object resetStateSync = new Object();
+    /** Pending Joins. */
+    private final Queue<String> pendingJoins = new LinkedList<>();
+    /** Pending Join Keys. */
+    private final Queue<String> pendingJoinKeys = new LinkedList<>();
 
     /**
      * Default constructor, ServerInfo and MyInfo need to be added separately (using IRC.me and IRC.server).
                     }
                 }
             }
+        } else if ("join".equalsIgnoreCase(newLine[0]) && newLine.length > 1) {
+            final Queue<String> keys = new LinkedList<>();
+
+            if (newLine.length > 2) {
+                keys.addAll(Arrays.asList(newLine[2].split(",")));
+            }
+
+            // PendingJoins and PendingJoinKeys should always be the same length (even if no key was given).
+            //
+            // We don't get any errors for channels we try to join that we are already in
+            // But the IRCD will still swallow the key attempt.
+            //
+            // Make sure that we always have a guessed key for every channel (even if null) and that we
+            // don't have guesses for channels we are already in.
+            for (final String chan : newLine[1].split(",")) {
+                final String key = keys.poll();
+                if (getChannel(chan) == null) {
+                    pendingJoins.add(chan);
+                    pendingJoinKeys.add(key);
+                }
+            }
         }
 
         return true;
     }
 
+    /**
+     * Get the current pending Joins.
+     *
+     * @return Current pending Joins
+     */
+    public Queue<String> getPendingJoins() {
+        return pendingJoins;
+    }
+
+    /**
+     * Get the current pending join keys.
+     *
+     * @return Current pending join keys.
+     */
+    public Queue<String> getPendingJoinKeys() {
+        return pendingJoinKeys;
+    }
+
     @Override
     public String getNetworkName() {
         return networkName;

irc/src/com/dmdirc/parser/irc/processors/ProcessJoin.java

     public ProcessJoin(final IRCParser parser, final PrefixModeManager prefixModeManager,
             @Named("user") final ModeManager userModeManager,
             @Named("channel") final ModeManager chanModeManager) {
-        super(parser, "JOIN", "329");
+        super(parser, "JOIN", "329", "471", "473", "474", "475", "476", "477", "479");
         this.prefixModeManager = prefixModeManager;
         this.userModeManager = userModeManager;
         this.chanModeManager = chanModeManager;
                     // Oh well, not a normal ircd I guess
                 }
             }
-        } else {
+        } else if ("JOIN".equals(sParam)) {
             // :nick!ident@host JOIN (:)#Channel
             if (token.length < 3) {
                 return;
             }
             final boolean extendedJoin = parser.getCapabilityState("extended-join") == CapabilityState.ENABLED;
 
-
             IRCClientInfo iClient = getClientInfo(token[0]);
             final String realName;
             final String accountName;
             parser.addChannel(iChannel);
             sendString("MODE " + iChannel.getName(), QueuePriority.LOW);
 
+            final String pendingJoin = parser.getPendingJoins().poll();
+            final String pendingJoinKey = parser.getPendingJoinKeys().poll();
+            if (pendingJoin.equalsIgnoreCase(channelName)) {
+                callDebugInfo(IRCParser.DEBUG_INFO, "processJoin: Guessing channel Key: " + pendingJoin + " -> " + pendingJoinKey);
+                iChannel.setInternalPassword(pendingJoinKey == null ? "" : pendingJoinKey);
+            } else {
+                // Out of sync, clear.
+                parser.getPendingJoins().clear();
+                parser.getPendingJoinKeys().clear();
+            }
+
             callChannelSelfJoin(iChannel);
+        } else {
+            // Some kind of failed to join, pop the pending join queues.
+            parser.getPendingJoins().poll();
+            parser.getPendingJoinKeys().poll();
         }
     }