How to pass a method pointer in C# to C library?

Asked By: Anonymous

Does anyone know how to cast a method in C# to a void* member?

In the example below, sigaction.sa_handler is a void* member that specifies a callback function.

Environment:

• VisualStudio Professional 2019 16.9.4
• dotnet core SDK 3.1
• Ubuntu on WSL
• Tmds.Linux 0.5.0

    sigaction sigact = new sigaction();

    //Error CS0428  Cannot convert method group 'catcher' to non-delegate type 'void*'.Did you intend to invoke the method?
    sigact.sa_handler = catcher;

    //Error CS0030  Cannot convert type 'method' to 'void*'
    sigact.sa_handler = (void *)catcher;

    //Error CS0029  Cannot implicitly convert type 'SignalCallback' to 'void*'
    SignalCallback callback = new SignalCallback(catcher);
    sigact.sa_handler = callback;

    //Error CS0030  Cannot convert type 'SignalCallback' to 'void*'
    sigact.sa_handler = (void*)callback;

Structure of sigaction (from Tmds.Linux)

    public struct sigaction
    {
        public sigset_t sa_mask;

        public void* sa_handler { get; set; }
        public void* sa_sigaction { get; set; }
        public int sa_flags { readonly get; set; }
        public void* sa_restorer { readonly get; set; }
    }

Full source code:

    using System;

    using static Tmds.Linux.LibC;
    using Tmds.Linux;
    using System.Runtime.InteropServices;
    
    delegate void SignalCallback(int sig);

    namespace example
    {
        class Program
        {
            static void catcher(int sig)
            {
                Console.Write($"Signal catcher called for signal {sig}");
            }

            static void timestamp(string str)
            {
                Console.Write($"The time {str} is {DateTime.Now}");
            }

            static unsafe int Main(string[] args)
            {
                int result = 0;

                sigaction sigact = new sigaction();
                sigset_t waitset = new sigset_t();
                siginfo_t info = new siginfo_t();

                sigset_t* ptr = &sigact.sa_mask;
                sigemptyset(&sigact.sa_mask);
                sigact.sa_flags = 0;

                //Error CS0428  Cannot convert method group 'catcher' to non-delegate type 'void*'.Did you intend to invoke the method?
                sigact.sa_handler = catcher;

                //Error CS0029  Cannot implicitly convert type 'SignalCallback' to 'void*'
                SignalCallback callback = new SignalCallback(catcher);
                sigact.sa_handler = callback;

                sigaction(SIGALRM, &sigact, null);

                sigemptyset(&waitset);
                sigaddset(&waitset, SIGALRM);

                sigprocmask(SIG_BLOCK, &waitset, null);

                alarm(10);

                timestamp("before sigwaitinfo()");

                result = sigwaitinfo(&waitset, &info);

                if (result == SIGALRM)
                    Console.WriteLine($"sigwaitinfo() returned for signal {info.si_signo}");
                else
                {
                    Console.WriteLine($"sigwait() returned code {result}");
                    Console.WriteLine($"sigwait() returned error number {errno}");
                    Console.WriteLine("sigwait() function failed");
                }

                timestamp("after sigwaitinfo()");

                return result;
            }
        }
    }

Solution

Answered By: Anonymous

To get a void* pointer from the delegate, you need Marshal.GetFunctionPointerForDelegate. You must make sure the delegate is not garbage-collected before its final use. You can use GC.KeepAlive for this.

SignalCallback callback = new SignalCallback(catcher);
sigact.sa_handler = Marshal.GetFunctionPointerForDelegate(callback);

// do the rest of your stuff

// after it's last usage by unmanaged code
GC.KeepAlive(callback);

However:

You should really be relying much more on P/Invoke to do any conversion. It should in most cases be able to sort out the void* conversions, all you need is GC.KeepAlive.

Your current code is hugely problematic as you are casting managed pointers to void* all over.

For example, instead of this call, which is doing a conversion from & managed pointer to void*

sigemptyset(&waitset);

Instead you would use

sigemptyset(ref waitset);

Your structs ideally shouldn’t use properties, because it makes it harder to define attributes on the fields. I note that sigaction doesn’t seem to be in the correct order, from what I can tell from a quick Google.

You should define sigaction something like this

    public struct sigaction
    {
        public SignalCallback sa_handler;
        public SignalAction sa_sigaction;
        public sigset_t sa_mask;
        public int sa_flags;
        public SignalRestorer sa_restorer;
    }