FirewallProduct introduced

Author: falahati

WindowsFirewallHelper/COMInterop/NET_FW_RULE_CATEGORY.cs

@@ -0,0 +1,8 @@
+public enum NET_FW_RULE_CATEGORY
+{
+    NET_FW_RULE_CATEGORY_BOOT = 0,
+    NET_FW_RULE_CATEGORY_STEALTH = 1,
+    NET_FW_RULE_CATEGORY_FIREWALL = 2,
+    NET_FW_RULE_CATEGORY_CONSEC = 3,
+    NET_FW_RULE_CATEGORY_MAX = 4
+}

WindowsFirewallHelper/FirewallProduct.cs

@@ -0,0 +1,115 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using WindowsFirewallHelper.COMInterop;
+using WindowsFirewallHelper.Helpers;
+
+namespace WindowsFirewallHelper
+{
+    public class FirewallProduct
+    {
+        public FirewallProduct(string name)
+        {
+            if (IsSupported)
+            {
+                throw new NotSupportedException();
+            }
+
+            UnderlyingObject = (INetFwProduct) Activator.CreateInstance(
+                Type.GetTypeFromProgID("HNetCfg.FwProduct")
+            );
+            Name = name;
+        }
+
+        internal FirewallProduct(INetFwProduct product)
+        {
+            UnderlyingObject = product;
+        }
+
+        public string FriendlyName
+        {
+            get => NativeHelper.ResolveStringResource(Name);
+        }
+
+        public static bool IsSupported
+        {
+            get => Type.GetTypeFromProgID("HNetCfg.FwProduct") != null;
+        }
+
+        public string Name
+        {
+            get => UnderlyingObject.DisplayName;
+            set => UnderlyingObject.DisplayName = value;
+        }
+
+        public FirewallRuleCategory[] RuleCategories
+        {
+            get
+            {
+                var arrayObject = UnderlyingObject.RuleCategories;
+
+                if (arrayObject is IEnumerable array)
+                {
+                    var ruleCategories = new List<FirewallRuleCategory>();
+
+                    foreach (var ruleCategoryObject in array)
+                    {
+                        var ruleCategoryInt = (int) ruleCategoryObject;
+                        ruleCategories.Add((FirewallRuleCategory) ruleCategoryInt);
+                    }
+
+                    return ruleCategories.ToArray();
+                }
+
+                return new FirewallRuleCategory[0];
+            }
+            set
+            {
+                var array = value.Select(category => (int) category).Cast<object>().ToArray();
+                UnderlyingObject.RuleCategories = array;
+            }
+        }
+
+        public string SignedExecutableFilename
+        {
+            get => UnderlyingObject.PathToSignedProductExe;
+        }
+
+        /// <summary>
+        ///     Returns the list of all registered third party firewalls management instances
+        /// </summary>
+        public static ICollection<FirewallProduct> ThirdPartyFirewalls
+        {
+            get => new FirewallProductsCollection(GetProducts());
+        }
+
+        private INetFwProduct UnderlyingObject { get; }
+
+        private static INetFwProducts GetProducts()
+        {
+            if (!IsSupported)
+            {
+                throw new NotSupportedException();
+            }
+
+            return (INetFwProducts) Activator.CreateInstance(
+                Type.GetTypeFromProgID("HNetCfg.FwProducts")
+            );
+        }
+
+        /// <summary>
+        ///     Register an instance of a third party firewall management class
+        /// </summary>
+        public FirewallProductRegistrationHandle Register()
+        {
+            return new FirewallProductRegistrationHandle(GetProducts().Register(GetCOMObject()));
+        }
+
+
+        internal INetFwProduct GetCOMObject()
+        {
+            return UnderlyingObject;
+        }
+    }
+}

WindowsFirewallHelper/FirewallProductRegistrationHandle.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace WindowsFirewallHelper
+{
+    public class FirewallProductRegistrationHandle : IDisposable
+    {
+        private object _handle;
+
+        public FirewallProductRegistrationHandle(object handle)
+        {
+            if (handle == null || !handle.GetType().IsCOMObject)
+            {
+                throw new ArgumentException("Handle is empty or invalid.", nameof(handle));
+            }
+
+            _handle = handle;
+        }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            Release();
+            GC.SuppressFinalize(this);
+        }
+
+        public void Release()
+        {
+            lock (this)
+            {
+                if (_handle != null)
+                {
+                    Marshal.ReleaseComObject(_handle);
+                    _handle = null;
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        ~FirewallProductRegistrationHandle()
+        {
+            Release();
+        }
+    }
+}

WindowsFirewallHelper/FirewallProductsCollection.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Runtime.InteropServices.ComTypes;
+using WindowsFirewallHelper.COMInterop;
+using WindowsFirewallHelper.Helpers;
+
+namespace WindowsFirewallHelper
+{
+    internal class FirewallProductsCollection : COMCollection<INetFwProducts, INetFwProduct, int, FirewallProduct>
+    {
+        /// <inheritdoc />
+        public FirewallProductsCollection(INetFwProducts nativeEnumerable) : base(nativeEnumerable)
+        {
+        }
+
+        /// <inheritdoc />
+        public override bool IsReadOnly { get; } = true;
+
+        /// <inheritdoc />
+        protected override INetFwProduct ConvertManagedToNative(FirewallProduct managed)
+        {
+            return managed.GetCOMObject();
+        }
+
+        /// <inheritdoc />
+        protected override FirewallProduct ConvertNativeToManaged(INetFwProduct native)
+        {
+            return new FirewallProduct(native);
+        }
+
+        /// <inheritdoc />
+        protected override int GetCollectionKey(FirewallProduct managed)
+        {
+            throw new InvalidOperationException();
+        }
+
+        /// <inheritdoc />
+        protected override IEnumVARIANT GetEnumVariant()
+        {
+            return NativeEnumerable.GetEnumeratorVariant();
+        }
+
+        /// <inheritdoc />
+        protected override void InternalAdd(INetFwProduct native)
+        {
+            throw new InvalidOperationException();
+        }
+
+        /// <inheritdoc />
+        protected override int InternalCount()
+        {
+            return NativeEnumerable.Count;
+        }
+
+        /// <inheritdoc />
+        protected override INetFwProduct InternalItem(int key)
+        {
+            return NativeEnumerable.Item(key);
+        }
+
+        /// <inheritdoc />
+        protected override void InternalRemove(int key)
+        {
+            throw new InvalidOperationException();
+        }
+    }
+}

WindowsFirewallHelper/FirewallRulesCategory.cs

@@ -0,0 +1,7 @@
+public enum FirewallRuleCategory
+{
+    Boot = NET_FW_RULE_CATEGORY.NET_FW_RULE_CATEGORY_BOOT,
+    Stealth = NET_FW_RULE_CATEGORY.NET_FW_RULE_CATEGORY_STEALTH,
+    Firewall = NET_FW_RULE_CATEGORY.NET_FW_RULE_CATEGORY_FIREWALL,
+    ConnectionSecurity = NET_FW_RULE_CATEGORY.NET_FW_RULE_CATEGORY_CONSEC
+}