Add a loader using libdl.so.2

Author: fubar-coder

PamSharp.sln.DotSettings

@@ -4,6 +4,7 @@
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SPACE_WITHIN_SINGLE_LINE_ARRAY_INITIALIZER_BRACES/@EntryValue">True</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=TTY/@EntryIndexedValue">TTY</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=UTF/@EntryIndexedValue">UTF</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=EnumMember/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb"&gt;&lt;ExtraRule Prefix="PAM_" Suffix="" Style="AA_BB" /&gt;&lt;/Policy&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateConstants/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb"&gt;&lt;ExtraRule Prefix="" Suffix="" Style="AA_BB" /&gt;&lt;/Policy&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateStaticReadonly/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb"&gt;&lt;ExtraRule Prefix="_" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;</s:String>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpKeepExistingMigration/@EntryIndexedValue">True</s:Boolean>

src/FubarDev.PamSharp/Interop/PamInteropFactory.cs

@@ -3,7 +3,11 @@
 // </copyright>
 
 using System;
+using System.Collections.Generic;
 using System.Reflection;
+using System.Runtime.InteropServices;
+
+using FubarDev.PamSharp.Interop.UnixDl2;
 
 using Platform.Invoke;
 
@@ -27,14 +31,8 @@ public static IPamInterop Create()
             {
                 if (_interop == null)
                 {
-                    var libraryLoader = LibraryLoaderFactory.Create();
-                    var library = MapAndLoad("pam", typeof(IPamInterop).Assembly, libraryLoader);
-                    if (library == null)
-                    {
-                        throw new NotSupportedException("Unsupported operating system, no viable library loader or library not found");
-                    }
-
-                    _interop = LibraryInterfaceFactory.Implement<IPamInterop>(library);
+                    _interop = CreatePamInterop() ?? throw new NotSupportedException(
+                                   "Unsupported operating system, no viable library loader or library not found");
                 }
 
                 return _interop;
@@ -64,5 +62,35 @@ public static IPamInterop Create()
 
             return null;
         }
+
+        private static IPamInterop? CreatePamInterop()
+        {
+            foreach (var libraryLoader in GetLibraryLoaders())
+            {
+                try
+                {
+                    var library = MapAndLoad("pam", typeof(IPamInterop).Assembly, libraryLoader);
+                    if (library != null)
+                    {
+                        return LibraryInterfaceFactory.Implement<IPamInterop>(library);
+                    }
+                }
+                catch
+                {
+                    // Ignore
+                }
+            }
+
+            return null;
+        }
+
+        private static IEnumerable<ILibraryLoader> GetLibraryLoaders()
+        {
+            yield return LibraryLoaderFactory.Create();
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            {
+                yield return new UnixDl2LibraryLoader();
+            }
+        }
     }
 }

src/FubarDev.PamSharp/Interop/UnixDl2/UnixDl2Library.cs

@@ -0,0 +1,28 @@
+// <copyright file="UnixDl2Library.cs" company="Fubar Development Junker">
+// Copyright (c) Fubar Development Junker. All rights reserved.
+// </copyright>
+
+using System;
+using System.Diagnostics;
+
+using Platform.Invoke;
+
+namespace FubarDev.PamSharp.Interop.UnixDl2
+{
+    /// <summary>
+    /// Implements library function loading using libdl.
+    /// </summary>
+    [DebuggerDisplay("so({" + nameof(Name) + "})")]
+    public sealed class UnixDl2Library : LibraryBase
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UnixDl2Library"/> class.
+        /// </summary>
+        /// <param name="moduleHandle">Handle to the loaded module returned by dlopen(3).</param>
+        /// <param name="libraryName">Name of the loaded library.</param>
+        public UnixDl2Library(IntPtr moduleHandle, string libraryName)
+            : base(moduleHandle, new UnixDl2LibraryProcProvider(), libraryName)
+        {
+        }
+    }
+}

src/FubarDev.PamSharp/Interop/UnixDl2/UnixDl2LibraryLoader.cs

@@ -0,0 +1,90 @@
+// <copyright file="UnixDl2LibraryLoader.cs" company="Fubar Development Junker">
+// Copyright (c) Fubar Development Junker. All rights reserved.
+// </copyright>
+
+using System;
+using System.Runtime.InteropServices;
+
+using Platform.Invoke;
+using Platform.Invoke.Unix;
+
+namespace FubarDev.PamSharp.Interop.UnixDl2
+{
+    /// <summary>
+    /// Library loading support for Unix operating systems (including OS X).
+    /// </summary>
+    public sealed class UnixDl2LibraryLoader : LibraryLoaderBase
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UnixDl2LibraryLoader"/> class.
+        /// </summary>
+        public UnixDl2LibraryLoader()
+            : base(s => dlopen(s, Flags.Lazy | Flags.Local))
+        {
+        }
+
+        /// <summary>
+        /// Defines flags used by dlopen.
+        /// </summary>
+        [Flags]
+        private enum Flags
+        {
+            /// <summary>
+            /// Perform lazy binding. Only resolve symbols as the code that references them is executed.
+            /// If the symbol is never referenced, then it is never resolved. (Lazy binding is only
+            /// performed for function references; references to variables are always immediately bound
+            /// when the library is loaded.)
+            /// </summary>
+            Lazy = 0x00001,
+
+            /// <summary>
+            /// If this value is specified, or the environment variable LD_BIND_NOW is set to a nonempty
+            /// string, all undefined symbols in the library are resolved before dlopen() returns.
+            /// If this cannot be done, an error is returned.
+            /// </summary>
+            Now = 0x00002,
+
+            /// <summary>
+            /// The symbols defined by this library will be made available for symbol resolution of
+            /// subsequently loaded libraries.
+            /// </summary>
+            Global = 0x00100,
+
+            /// <summary>
+            /// This is the converse of <see cref="Global"/>, and the default if neither flag is specified.
+            /// Symbols defined in this library are not made available to resolve references in subsequently
+            /// loaded libraries.
+            /// </summary>
+            Local = 0,
+
+            /// <summary>
+            /// Do not unload the library during dlclose(). Consequently, the library's static variables are
+            /// not reinitialized if the library is reloaded with dlopen() at a later time. This flag is not
+            /// specified in POSIX.1-2001.
+            /// </summary>
+            NoDelete = 0x01000,
+        }
+
+        /// <summary>
+        /// Returns the created library for the specified handle and library name.
+        /// </summary>
+        /// <param name="handle">Operating system provided library handle.</param>
+        /// <param name="libraryName">Name fo the loaded library.</param>
+        /// <returns><see cref="ILibrary"/> interface for the specified library.</returns>
+        protected override ILibrary CreateLibrary(IntPtr handle, string libraryName)
+        {
+            return new UnixLibrary(handle, libraryName);
+        }
+
+        /// <summary>
+        /// Unix library loader function.
+        /// </summary>
+        /// <param name="filename">Filename to load,</param>
+        /// <param name="flags">Loader flags. Typically RTLD_LAZY.</param>
+        /// <returns>Handle to the library.</returns>
+        [DllImport("libdl.so.2")]
+#pragma warning disable SA1300 // Element should begin with upper-case letter
+        private static extern IntPtr dlopen([In]string filename, Flags flags);
+#pragma warning restore SA1300 // Element should begin with upper-case letter
+    }
+}

src/FubarDev.PamSharp/Interop/UnixDl2/UnixDl2LibraryProcProvider.cs

@@ -0,0 +1,77 @@
+// <copyright file="UnixDl2LibraryProcProvider.cs" company="Fubar Development Junker">
+// Copyright (c) Fubar Development Junker. All rights reserved.
+// </copyright>
+
+using System;
+using System.ComponentModel;
+using System.Diagnostics.Contracts;
+using System.Runtime.InteropServices;
+
+using Platform.Invoke;
+
+namespace FubarDev.PamSharp.Interop.UnixDl2
+{
+    /// <summary>
+    /// Implements function loading and library handling for Unix operating systems.
+    /// </summary>
+    [ImmutableObject(true)]
+    public sealed class UnixDl2LibraryProcProvider : ILibraryProcProvider
+    {
+        /// <summary>
+        /// Free this library.
+        /// </summary>
+        /// <param name="module">Module to free.</param>
+        /// <returns><see langword="true"/> when freeing the library was successful.</returns>
+        public bool Free(IntPtr module)
+        {
+            return dlclose(module) == 0;
+        }
+
+        /// <summary>
+        /// Retrieves a pointer to the specified function.
+        /// </summary>
+        /// <param name="module">Operating system provided library handle.</param>
+        /// <param name="procName">Library function name.</param>
+        /// <returns>Pointer to the loaded function. Null if procedure could not be located.</returns>
+        [Pure]
+        public IntPtr GetProc(IntPtr module, string procName)
+        {
+            return dlsym(module, procName);
+        }
+
+        /// <summary>
+        /// Gets a delegate for the specified function pointer.
+        /// </summary>
+        /// <param name="functionPointer">Function pointer retrieved using <see cref="GetProc"/>.</param>
+        /// <param name="delegateType">Type of delegate to return.</param>
+        /// <returns><see cref="Delegate"/> fro the specified function pointer.</returns>
+        /// <exception cref="ArgumentNullException">Thrown if <see paramref="functionPointer"/> or <see paramref="delegateType"/> is null.</exception>
+        /// <exception cref="ArgumentException">Thrown if <see paramref="delegateType"/> is not null.</exception>
+        [Pure]
+        public Delegate GetDelegateFromFunctionPointer(IntPtr functionPointer, Type delegateType)
+        {
+            return Marshal.GetDelegateForFunctionPointer(functionPointer, delegateType);
+        }
+
+        /// <summary>
+        /// Gets a symbol pointer from the specified module.
+        /// </summary>
+        /// <param name="handle">Operating system handle to a library.</param>
+        /// <param name="symbolName">Name of symbol to locate.</param>
+        /// <returns>an error code.</returns>
+        [DllImport("libdl.so.2")]
+#pragma warning disable SA1300 // Element should begin with upper-case letter
+        private static extern IntPtr dlsym(IntPtr handle, [In]string symbolName);
+#pragma warning restore SA1300 // Element should begin with upper-case letter
+
+        /// <summary>
+        /// Closes a library.
+        /// </summary>
+        /// <param name="handle">The library handle.</param>
+        /// <returns>the error code.</returns>
+        [DllImport("libdl.so.2")]
+#pragma warning disable SA1300 // Element should begin with upper-case letter
+        private static extern int dlclose(IntPtr handle);
+#pragma warning restore SA1300 // Element should begin with upper-case letter
+    }
+}