ModernUO/Scripts/Accounting/Firewall.cs

using System.Collections.Generic;
using System.IO;
using System.Net;

namespace Server
{
  public class Firewall
  {
    static Firewall()
    {
      List = new List<IFirewallEntry>();

      string path = "firewall.cfg";

      if (File.Exists(path))
        using (StreamReader ip = new StreamReader(path))
        {
          string line;

          while ((line = ip.ReadLine()) != null)
          {
            line = line.Trim();

            if (line.Length == 0)
              continue;

            List.Add(ToFirewallEntry(line));

            /*
            object toAdd;

            IPAddress addr;
            if ( IPAddress.TryParse( line, out addr ) )
              toAdd = addr;
            else
              toAdd = line;

            m_Blocked.Add( toAdd.ToString() );
             * */
          }
        }
    }

    public static List<IFirewallEntry> List{ get; }

    public static IFirewallEntry ToFirewallEntry(object entry)
    {
      if (entry is IFirewallEntry firewallEntry)
        return firewallEntry;
      if (entry is IPAddress address)
        return new IPFirewallEntry(address);
      if (entry is string s)
        return ToFirewallEntry(s);

      return null;
    }

    public static IFirewallEntry ToFirewallEntry(string entry)
    {
      if (IPAddress.TryParse(entry, out IPAddress addr))
        return new IPFirewallEntry(addr);

      //Try CIDR parse
      string[] str = entry.Split('/');

      if (str.Length == 2)
        if (IPAddress.TryParse(str[0], out IPAddress cidrPrefix))
          if (int.TryParse(str[1], out int cidrLength))
            return new CIDRFirewallEntry(cidrPrefix, cidrLength);

      return new WildcardIPFirewallEntry(entry);
    }

    public static void RemoveAt(int index)
    {
      List.RemoveAt(index);
      Save();
    }

    public static void Remove(object obj)
    {
      IFirewallEntry entry = ToFirewallEntry(obj);

      if (entry != null)
      {
        List.Remove(entry);
        Save();
      }
    }

    public static void Add(object obj)
    {
      if (obj is IPAddress address)
        Add(address);
      else if (obj is string s)
        Add(s);
      else if (obj is IFirewallEntry entry)
        Add(entry);
    }

    public static void Add(IFirewallEntry entry)
    {
      if (!List.Contains(entry))
        List.Add(entry);

      Save();
    }

    public static void Add(string pattern)
    {
      IFirewallEntry entry = ToFirewallEntry(pattern);

      if (!List.Contains(entry))
        List.Add(entry);

      Save();
    }

    public static void Add(IPAddress ip)
    {
      IFirewallEntry entry = new IPFirewallEntry(ip);

      if (!List.Contains(entry))
        List.Add(entry);

      Save();
    }

    public static void Save()
    {
      string path = "firewall.cfg";

      using (StreamWriter op = new StreamWriter(path))
      {
        for (int i = 0; i < List.Count; ++i)
          op.WriteLine(List[i]);
      }
    }

    public static bool IsBlocked(IPAddress ip)
    {
      for (int i = 0; i < List.Count; i++)
        if (List[i].IsBlocked(ip))
          return true;

      return false;
      /*
      bool contains = false;

      for ( int i = 0; !contains && i < m_Blocked.Count; ++i )
      {
        if ( m_Blocked[i] is IPAddress )
          contains = ip.Equals( m_Blocked[i] );
                else if ( m_Blocked[i] is String )
                {
                    string s = (string)m_Blocked[i];

                    contains = Utility.IPMatchCIDR( s, ip );

                    if ( !contains )
                        contains = Utility.IPMatch( s, ip );
                }
      }

      return contains;
       * */
    }

    #region Firewall Entries

    public interface IFirewallEntry
    {
      bool IsBlocked(IPAddress address);
    }

    public class IPFirewallEntry : IFirewallEntry
    {
      private IPAddress m_Address;

      public IPFirewallEntry(IPAddress address)
      {
        m_Address = address;
      }

      public bool IsBlocked(IPAddress address)
      {
        return m_Address.Equals(address);
      }

      public override string ToString()
      {
        return m_Address.ToString();
      }

      public override bool Equals(object obj)
      {
        if (obj is IPAddress)
          return obj.Equals(m_Address);
        if (obj is string s)
        {
          if (IPAddress.TryParse(s, out IPAddress otherAddress))
            return otherAddress.Equals(m_Address);
        }
        else if (obj is IPFirewallEntry entry)
        {
          return m_Address.Equals(entry.m_Address);
        }

        return false;
      }

      public override int GetHashCode()
      {
        return m_Address.GetHashCode();
      }
    }

    public class CIDRFirewallEntry : IFirewallEntry
    {
      private int m_CIDRLength;
      private IPAddress m_CIDRPrefix;

      public CIDRFirewallEntry(IPAddress cidrPrefix, int cidrLength)
      {
        m_CIDRPrefix = cidrPrefix;
        m_CIDRLength = cidrLength;
      }

      public bool IsBlocked(IPAddress address)
      {
        return Utility.IPMatchCIDR(m_CIDRPrefix, address, m_CIDRLength);
      }

      public override string ToString()
      {
        return $"{m_CIDRPrefix}/{m_CIDRLength}";
      }

      public override bool Equals(object obj)
      {
        if (obj is string entry)
        {
          string[] str = entry.Split('/');

          if (str.Length == 2)
            if (IPAddress.TryParse(str[0], out IPAddress cidrPrefix))
              if (int.TryParse(str[1], out int cidrLength))
                return m_CIDRPrefix.Equals(cidrPrefix) && m_CIDRLength.Equals(cidrLength);
        }
        else if (obj is CIDRFirewallEntry cidrEntry)
        {
          return m_CIDRPrefix.Equals(cidrEntry.m_CIDRPrefix) && m_CIDRLength.Equals(cidrEntry.m_CIDRLength);
        }

        return false;
      }

      public override int GetHashCode()
      {
        return m_CIDRPrefix.GetHashCode() ^ m_CIDRLength.GetHashCode();
      }
    }

    public class WildcardIPFirewallEntry : IFirewallEntry
    {
      private string m_Entry;

      private bool m_Valid;

      public WildcardIPFirewallEntry(string entry)
      {
        m_Entry = entry;
      }

      public bool IsBlocked(IPAddress address)
      {
        if (!m_Valid)
          return false; //Why process if it's invalid?  it'll return false anyway after processing it.

        bool matched = Utility.IPMatch(m_Entry, address, out bool valid);
        m_Valid = valid;
        return matched;
      }

      public override string ToString()
      {
        return m_Entry;
      }

      public override bool Equals(object obj)
      {
        if (obj is string)
          return obj.Equals(m_Entry);

        return obj is WildcardIPFirewallEntry entry && m_Entry.Equals(entry.m_Entry);
      }

      public override int GetHashCode()
      {
        return m_Entry.GetHashCode();
      }
    }

    #endregion
  }
}