Abstract server software stuff nicely.

Fixes issue 2260.

Change-Id: Ib74eaca55eeeca83e17a3d78fb15de42e552c8f2
Reviewed-on: http://gerrit.dmdirc.com/427
Reviewed-by: Chris Smith <chris@dmdirc.com>
Tested-by: Chris Smith <chris@dmdirc.com>

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

@@ -140,20 +140,15 @@ public class IRCChannelInfo implements ChannelInfo {
         
         askedForListModes = true;
         
-        final String thisIRCD = myParser.getIRCD(true).toLowerCase();
-        final boolean isFreenode = (thisIRCD.equals("hyperion") || thisIRCD.equals("dancer"));
-        final boolean isUnreal = thisIRCD.equals("unreal");
-        final boolean isStarChat = thisIRCD.equals("starchat");
-        final boolean isHybrid = thisIRCD.equals("hybrid") || thisIRCD.equals("oftc-hybrid");
-        final boolean isCharybdis = thisIRCD.equals("charybdis");
-        
+        final ServerType serverType = myParser.getServerType();
+                
         // We are considered opped if we have a mode higher than voice (or if we have any modes if voice doesn't exist)
         long voiceValue = 0;
         if (myParser.prefixModes.get('v') != null) { voiceValue = myParser.prefixModes.get('v');}
         final boolean isOpped = me.getImportantModeValue() > voiceValue;
         
         int modecount = 1;
-        if (!isUnreal && myParser.h005Info.containsKey("MODES")) {
+        if (serverType != ServerType.UNREAL && myParser.h005Info.containsKey("MODES")) {
             try {
                 modecount = Integer.parseInt(myParser.h005Info.get("MODES"));
             } catch (NumberFormatException e) { /* use default modecount */}
@@ -170,10 +165,10 @@ public class IRCChannelInfo implements ChannelInfo {
         for (Character cTemp : myParser.chanModesOther.keySet()) {
             final int nTemp = myParser.chanModesOther.get(cTemp);
             if (nTemp == IRCParser.MODE_LIST) {
-                if ((isFreenode || isHybrid || isCharybdis) && (cTemp == 'e' || cTemp == 'I') && !isOpped) {
+                if (!isOpped && serverType.isOpOnly(cTemp)) {
                     // IRCD doesn't allow non-ops to ask for these modes.
                     continue;
-                } else if (isStarChat && cTemp == 'H') {
+                } else if (serverType == serverType.STARCHAT && cTemp == 'H') {
                     // IRCD Denies the mode exists
                     continue;
                 }

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

@@ -1765,6 +1765,15 @@ public class IRCParser implements SecureParser, Runnable {
      */
     public Map<String, String> get005() { return h005Info; }
 
+    /**
+     * Get the ServerType for this IRCD.
+     *
+     * @return The ServerType for this IRCD.
+     */
+    public ServerType getServerType() {
+        return ServerType.findServerType(h005Info.get("004IRCD"), networkName, h005Info.get("003IRCD"), h005Info.get("002IRCD"));
+    }
+
     /**
      * Get the name of the ircd.
      *
@@ -1772,54 +1781,11 @@ public class IRCParser implements SecureParser, Runnable {
      * @return IRCD Version or Type
      */
     public String getIRCD(final boolean getType) {
-        if (h005Info.containsKey("004IRCD")) {
-            final String version = h005Info.get("004IRCD");
-            if (getType) {
-                // This ilst is vaugly based on http://searchirc.com/ircd-versions,
-                // but keeping groups of ircd's together (ie hybrid-based, ircu-based)
-                if (version.matches("(?i).*unreal[^4-9].*")) { return "unreal"; }
-                else if (version.matches("(?i).*unreal[4-9].*")) { return "unreal4"; }
-                else if (version.matches("(?i).*bahamut.*")) { return "bahamut"; }
-                else if (version.matches("(?i).*nefarious.*")) { return "nefarious"; }
-                else if (version.matches("(?i).*asuka.*")) { return "asuka"; }
-                else if (version.matches("(?i).*snircd.*")) { return "snircd"; }
-                else if (version.matches("(?i).*beware.*")) { return "bircd"; }
-                else if (version.matches("(?i).*u2\\.[0-9]+\\.H\\..*")) { return "irchispano"; }
-                else if (version.matches("(?i).*u2\\.[0-9]+\\..*")) { return "ircu"; }
-                else if (version.matches("(?i).*ircu.*")) { return "ircu"; }
-                else if (version.matches("(?i).*plexus.*")) { return "plexus"; }
-                else if (version.matches("(?i).*hybrid.*oftc.*")) { return "oftc-hybrid"; }
-                else if (version.matches("(?i).*ircd.hybrid.*")) { return "hybrid7"; }
-                else if (version.matches("(?i).*hybrid.*")) { return "hybrid"; }
-                else if (version.matches("(?i).*charybdis.*")) { return "charybdis"; }
-                else if (version.matches("(?i).*inspircd.*")) { return "inspircd"; }
-                else if (version.matches("(?i).*ultimateircd.*")) { return "ultimateircd"; }
-                else if (version.matches("(?i).*critenircd.*")) { return "critenircd"; }
-                else if (version.matches("(?i).*fqircd.*")) { return "fqircd"; }
-                else if (version.matches("(?i).*conferenceroom.*")) { return "conferenceroom"; }
-                else if (version.matches("(?i).*hyperion.*")) { return "hyperion"; }
-                else if (version.matches("(?i).*dancer.*")) { return "dancer"; }
-                else if (version.matches("(?i).*austhex.*")) { return "austhex"; }
-                else if (version.matches("(?i).*austirc.*")) { return "austirc"; }
-                else if (version.matches("(?i).*ratbox.*")) { return "ratbox"; }
-                else if (version.matches("(?i).*euircd.*")) { return "euircd"; }
-                else if (version.matches("(?i).*weircd.*")) { return "weircd"; }
-                else if (version.matches("(?i).*swiftirc.*")) { return "swiftirc"; }
-                else {
-                    // Stupid networks/ircds go here...
-                    if (networkName.equalsIgnoreCase("ircnet")) { return "ircnet"; }
-                    else if (networkName.equalsIgnoreCase("starchat")) { return "starchat"; }
-                    else if (networkName.equalsIgnoreCase("bitlbee")) { return "bitlbee"; }
-                    else if (h005Info.containsKey("003IRCD") && h005Info.get("003IRCD").matches("(?i).*bitlbee.*")) { return "bitlbee"; } // Older bitlbee
-                    else if (h005Info.containsKey("002IRCD") && h005Info.get("002IRCD").matches("(?i).*pastiche.*")) { return "ircd-pastiche"; }
-                    else { return "generic"; }
-                }
-            } else {
-                return version;
-            }
+        if (getType) {
+            return getServerType().getType();
         } else {
-            if (getType) { return "generic"; }
-            else { return ""; }
+            final String version = h005Info.get("004IRCD");
+            return (version == null) ? "" : version;
         }
     }
 

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

@@ -0,0 +1,254 @@
+/*
+ *  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.parser.irc;
+
+/**
+ * This defines server types.
+ * ServerTypes define a regex that will be matched against a lower-cased verison
+ * of the input, an array of modes that only ops can request, and what they are
+ * matching against.
+ * Lowercaseing will be handled using javas built in toLowercase() rather than
+ * usig the Server-Specific one.
+ *
+ * @author shane
+ */
+public enum ServerType {
+    /** Unreal IRCD prior to version 4. */
+    UNREAL("unreal", ".*unreal[^4-9].*"),
+    /** Unreal IRCD after version 4 (inspircd based). */
+    UNREAL4("unreal4", ".*unreal[4-9].*"),
+    /** Bahamut. */
+    BAHAMUT("bahamut", ".*bahamut.*"),
+    /** Some IRCU Fork. */
+    NEFARIOUS("nefarious", ".*nefarious.*"),
+    /** Quakenets old IRCU Fork. */
+    ASUKA("asuka", ".*asuka.*"),
+    /** Quakenets current IRCU Fork. */
+    SNIRCD("snircd", ".*snircd.*"),
+    /** Windows IRCU-Based IRCD. */
+    BIRCD("bircd", ".*beware.*"),
+    /** Spanish IRCU Fork. */
+    IRCHISPANO("irchispano", ".*u2\\.[0-9]+\\.H\\..*"),
+    /** IRCU. */
+    IRCU2("ircu", ".*u2\\.[0-9]+\\..*"),
+    /** Some kind of IRCU Fork. */
+    IRCU_GENERIC("ircu", ".*ircu.*"),
+    /** Plexus. */
+    PLEXUS("plexus", ".*plexus.*"),
+    /** OFTCs hybrid fork. */
+    OFTC_HYBRID("oftc-hybrid", ".*hybrid.*oftc.*"),
+    /** hybrid7. */
+    HYBRID7("hybrid7", ".*ircd.hybrid.*", "eI"),
+    /** Older versions of Hybrid. */
+    HYBRID("hybrid", ".*hybrid.*", "eI"),
+    /** Freenodes new IRCD. */
+    CHARYBDIS("charybdis", ".*charybdis.*", "eI"),
+    /** Freenodes Current IRCD. */
+    HYPERION("hyperion", ".*hyperion.*", "eI"),
+    /** Freenodes Old IRCD. */
+    DANCER("dancer", ".*dancer.*", "eI"),
+    /** Inspircd. */
+    INSPIRCD("inspircd", ".*inspircd.*"),
+    /** Ultimate IRCD. */
+    ULTIMATEIRCD("ultimateircd", ".*ultimateircd.*"),
+    /** Criten IRCD. */
+    CRITENIRCD("critenircd", ".*critenircd.*"),
+    /** fqircd. */
+    FQIRCD("fqircd", ".*fqircd.*"),
+    /** Microsoft's Conference Room "IRCD". */
+    CONFERENCEROOM("conferenceroom", ".*conferenceroom.*"),
+    /** AustHex custom IRCD. */
+    AUSTHEX("austhex", ".*austhex.*"),
+    /** AustIRC custom IRCD. */
+    AUSTIRC("austirc", ".*austirc.*"),
+    /** Ratbox. */
+    RATBOX("ratbox", ".*ratbox.*"),
+    /** euircd. */
+    EUIRCD("euircd", ".*euircd.*"),
+    /** weircd. */
+    WEIRCD("weircd", ".*weircd.*"),
+    /** swiftirc's ircd. */
+    SWIFTIRC("swiftirc", ".*swiftirc.*"),
+    /** IRCNet. */
+    IRCNET("ircnet", "ircnet", null, MatchType.NETWORK),
+    /** Star Chat. */
+    STARCHAT("starchat", "starchat", null, MatchType.NETWORK),
+    /** Newer Bitlbee. */
+    BITLBEE("bitlbee", "bitlbee", null, MatchType.NETWORK),
+    /** Older Bitlbee. */
+    BITLBEE_OLD("bitlbee", "bitlbee", null, MatchType.RAW003),
+    /** Pastiche. */
+    PASTICHE("bitlbee", "ircd-pastiche", null, MatchType.RAW002),
+    /** Generic IRCD. */
+    GENERIC("generic", "", null, MatchType.NEVER);
+
+    /** Define what this ServerType should match on. */
+    private enum MatchType {
+        /** Match using the ircd version from 004. */
+        VERSION,
+        /** Match using the network name. */
+        NETWORK,
+        /** Match using raw 003. */
+        RAW003,
+        /** Match using raw 002. */
+        RAW002,
+        /** Never Match (Used by generic). */
+        NEVER;
+    }
+
+    /** Type of for this ServerType. */
+    private final String type;
+
+    /** Regex for this ServerType. */
+    private final String regex;
+
+    /** String of chars that only ops can access. */
+    private final String opOnly;
+
+    /** What does this ServerType match? */
+    private final MatchType matchType;
+
+    /**
+     * Create a new server type.
+     *
+     * @param type The name for this type.
+     * @param regex The regex for this type.
+     */
+    ServerType(final String type, final String regex) {
+        this(type, regex, null);
+    }
+
+
+    /**
+     * Create a new server type.
+     *
+     * @param type The name for this type.
+     * @param regex The regex for this type.
+     * @param opOnly Any mode chars that are op-only.
+     */
+    ServerType(final String type, final String regex, final String opOnly) {
+        this(type, regex, opOnly, MatchType.VERSION);
+    }
+
+    /**
+     * Create a new server type.
+     *
+     * @param type The name for this type.
+     * @param regex The regex for this type.
+     * @param opOnly Any mode chars that are op-only.
+     * @param matchType What information should we match on?
+     */
+    ServerType(final String type, final String regex, final String opOnly, final MatchType matchType) {
+        this.type = type;
+        this.regex = regex;
+        this.opOnly = (opOnly == null) ? "" : opOnly;
+        this.matchType = matchType;
+    }
+
+    /**
+     * Get a string that defines what type this server is.
+     *
+     * @return String that defines what type this server is.
+     */
+    public String getType() {
+        return type;
+    }
+
+    /**
+     * Get the MatchType of this ServerType
+     *
+     * @return The MatchType of this ServerType
+     */
+    private MatchType getMatchType() {
+        return matchType;
+    }
+
+    /**
+     * Get the Regex used by this ServerType.
+     *
+     * @return The Regex used by this ServerType.
+     */
+    private String getRegex() {
+        return regex;
+    }
+
+    /**
+     * Get the modes that are op-only.
+     *
+     * @return the modes that are op-only.
+     */
+    public String getOpOnly() {
+        return opOnly;
+    }
+
+    /**
+     * Check if the given mode is op-only.
+     *
+     * @param mode
+     * @return
+     */
+    public boolean isOpOnly(final char mode) {
+        return (opOnly.indexOf(mode) != -1);
+    }
+
+    /**
+     * Find the first ServerType that matches the given details.
+     *
+     * @param versionInput Version from 004
+     * @param networkInput Network Name
+     * @param raw003Input 003 line
+     * @param raw002Input 002 line
+     * @return The Server type that matches the given details.
+     */
+    public static ServerType findServerType(final String versionInput, final String networkInput, final String raw003Input, final String raw002Input) {
+        final String version = (versionInput == null) ? "" : versionInput.toLowerCase();
+        final String network = (networkInput == null) ? "" : networkInput.toLowerCase();
+        final String raw003 = (raw003Input == null) ? "" : raw003Input.toLowerCase();
+        final String raw002 = (raw002Input == null) ? "" : raw002Input.toLowerCase();
+
+        for (ServerType type : ServerType.values()) {
+            switch (type.getMatchType()) {
+                case VERSION:
+                    if (version.matches(type.getRegex())) { return type; }
+                    break;
+                case NETWORK:
+                    if (network.matches(type.getRegex())) { return type; }
+                    break;
+                case RAW003:
+                    if (raw003.matches(type.getRegex())) { return type; }
+                    break;
+                case RAW002:
+                    if (raw002.matches(type.getRegex())) { return type; }
+                    break;
+                case NEVER:
+                    break;
+                default:
+                    /* Won't happen. */
+                    break;
+            }
+        }
+
+        // Return Generic IRCD.
+        return ServerType.GENERIC;
+    }
+}