How do I export a function with a Callback argument for use in c? NativeAOT

[insinfo]

How do I export a function with a Callback argument for use in c? I'm compiled with .NET 7 NativeAOT

using System;
using System.Runtime.InteropServices;

namespace classLib;
public class ClassLib
{
    [UnmanagedCallersOnly(EntryPoint = "add")]
    public static int Add(int a, int b, void (*func)() callback ){
    }
}

[am11]

Using the daily build 7.0.100-preview.5.22262.14, downloaded from this table https://github.com/dotnet/installer#table (I am on linux-x64), it goes like this:

Setup:

mkdir ~/.dotnet7
curl -sSL https://aka.ms/dotnet/7.0.1xx/daily/dotnet-sdk-linux-x64.tar.gz | tar xzf - -C ~/.dotnet7
alias dotnet7=~/.dotnet7/dotnet

cat > ~/NuGet.config <<EOF
<configuration>
  <packageSources>
    <add key="dotnet7" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet7/nuget/v3/index.json" />
  </packageSources>
</configuration>
EOF

Create project:

dotnet7 new classlib -n nativelib1
cd nativelib1

Class.cs

using System;
using System.Runtime.InteropServices;

namespace classLib;
public class ClassLib
{
    [UnmanagedCallersOnly(EntryPoint = "myadd")]
    public unsafe static int Add(int a, int b, delegate* unmanaged<int, int, int, int> callback)
    {
        Console.WriteLine("Hello from C# Add!");
        return callback (a, b, a + b);
    }
}

Publish:

dotnet7 publish --use-current-runtime \
    -p:PublishAot=true -p:AllowUnsafeBlocks=true -p:NativeLib=Shared

test.c

#include<stdio.h>

typedef int(*callback_iii)(int, int, int);
extern int myadd(int, int, callback_iii);

int foo(int x, int y, int sum)
{
  printf("Hello from C callback!\n");
  return sum;
}

int main()
{
  printf("sum is: %d\n", myadd(1, 2, &foo));
  return 0;
}

Compile and link:

gcc test.c bin/Debug/net7.0/linux-x64/publish/nativelib1.so

Run:

$ ./a.out

Hello from C# Add!
Hello from C callback!
sum is: 3

[jkotas]

public unsafe static int Add(int a, int b, delegate* managed<int, int, int, int> callback)

This should be public unsafe static int Add(int a, int b, delegate* unmanaged<int, int, int, int> callback)

[jkotas]

If it helps, the basic NativeAOT library sample is at https://github.com/dotnet/samples/tree/main/core/nativeaot/NativeLibrary

[am11]

This should be public unsafe static int Add(int a, int b, delegate* unmanaged<int, int, int, int> callback)

Thanks, I didn't noticed un was missing, fixed. :)
Is it a correctness issue or performance one, when we don't use unmanaged calling convention here? On x64, I can't tell the difference in output. I can imagine it is going through some indirections with managed.

[jkotas]

Is it a correctness issue or performance one, when we don't use unmanaged calling convention here?

It is correctness issue in general.

• The managed and unmanaged calling conventions are not guaranteed to be the same. They happened to be the same in this example and so there was not an observable problem.
• The unmanaged calling convention does GC transition as part of the call. If you call arbitrary unmanaged code without GC transition, it can lead to hangs, data corruptions or crashes, depending on what the arbitrary unmanaged code does.

[insinfo]

@am11
Thanks a lot for the help, it worked perfectly.

[insinfo]

@jkotas
Ideally, there would be more examples, examples that show best practices for interoperating with native code, real-world examples like:

using Renci.SshNet;
using SMBLibrary;
using SMBLibrary.Client;
using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;


namespace dicom_lib;

public enum ErrorCode : int
{
    Success = 0,
    Unknown = -1,
    ConnectionLost = 400,
    ServerLoginFailure = 401,
    FailedAccessServer = 402,
    FailedAccessShare = 403,
    FailedAccessFile = 404,
    InvalidInstance = 405,
    UninitializedFileStore = 406
}

static class ErrorCodeExtensions
{
    public static int AsInt(this ErrorCode v)
    {
        return (int)v;
    }
}

public struct SmbInstanceNative
{
    public int smbInstanceId;
    public int errorCode;
}

public class SmbInstance
{
    public SMB2Client client;
    public SMB2FileStore fileStore;
    public int id;
}


public class DicomLib
{
    private static int countSmbInstance = -1;

    private static List<SmbInstance> smbInstances = new();

    private static string erroMessage = "";

    private static SmbInstance GetSmb(int id)
    {
        foreach (var item in smbInstances)
        {
            if (item.id == id)
            {
                return item;
            }
        }
        return null;
    }


    [UnmanagedCallersOnly(EntryPoint = "initSmb")]
    public static SmbInstanceNative InitSmb()
    {
        try
        {
            var client = new SMB2Client();
            countSmbInstance++;

            var instanceSmb = new SmbInstance()
            {
                client = client,
                id = countSmbInstance,
            };

            smbInstances.Add(instanceSmb);
            return new SmbInstanceNative() { smbInstanceId = countSmbInstance, errorCode = ErrorCode.Success.AsInt() };

        }
        catch (Exception e)
        {
            erroMessage = $"Unknown error: {e}";
            Console.WriteLine(erroMessage);
            return new SmbInstanceNative()
            {
                smbInstanceId = -1,
                errorCode = ErrorCode.Unknown.AsInt()
            };
        }
    }

    [UnmanagedCallersOnly(EntryPoint = "connectSmb")]
    public static int ConnectSmb(SmbInstanceNative smbInstanceNative, IntPtr pIpSmb,
        IntPtr pDomainSmb,
        IntPtr pUserSmb,
        IntPtr pPassSmb)
    {
        try
        {
            string ipSmb = Marshal.PtrToStringAnsi(pIpSmb);
            string domainSmb = Marshal.PtrToStringAnsi(pDomainSmb);
            string userSmb = Marshal.PtrToStringAnsi(pUserSmb);
            string passSmb = Marshal.PtrToStringAnsi(pPassSmb);

            var instance = GetSmb(smbInstanceNative.smbInstanceId);
            if (instance == null)
            {
                erroMessage = $"invalid instance id";
                Console.WriteLine(erroMessage);
                return ErrorCode.InvalidInstance.AsInt();

            }
            var client = instance.client;            

            var isSmbConnected = client.Connect(System.Net.IPAddress.Parse(ipSmb), SMBTransportType.DirectTCPTransport);
            if (isSmbConnected)
            {
                var status = client.Login(domainSmb, userSmb, passSmb);

                if (status == NTStatus.STATUS_SUCCESS)
                {
                    return ErrorCode.Success.AsInt();
                }
                else
                {
                    erroMessage = $"Failed to login {status}";
                    Console.WriteLine(erroMessage);
                    return ErrorCode.ServerLoginFailure.AsInt();
                }
            }
            else
            {
                erroMessage = "Failed to access the server";
                Console.WriteLine(erroMessage);
                return ErrorCode.FailedAccessServer.AsInt();
            }
        }
        catch (Exception ex)
        {
            erroMessage = $"Unknown error: {ex}";
            Console.WriteLine(erroMessage);
            return ErrorCode.Unknown.AsInt();

        }
    }

    [UnmanagedCallersOnly(EntryPoint = "disconnectSmb")]
    public static int DisconnectSmb(SmbInstanceNative smbInstanceNative)
    {
        try
        {
            var instance = GetSmb(smbInstanceNative.smbInstanceId);
            if (instance == null)
            {
                erroMessage = $"invalid instance id";
                Console.WriteLine(erroMessage);
                return ErrorCode.InvalidInstance.AsInt();

            }
            var client = instance.client;
            client.Disconnect();
            return ErrorCode.Success.AsInt();
        }
        catch (Exception ex)
        {
            erroMessage = $"Unknown error: {ex}";
            Console.WriteLine(erroMessage);
            return ErrorCode.Unknown.AsInt();

        }
    }

    [UnmanagedCallersOnly(EntryPoint = "freeSmb")]
    public static int FreeSmb(SmbInstanceNative smbInstanceNative)
    {
        try
        {
            var instance = GetSmb(smbInstanceNative.smbInstanceId);
            if (instance == null)
            {
                erroMessage = $"invalid instance id";
                Console.WriteLine(erroMessage);
                return ErrorCode.InvalidInstance.AsInt();

            }
            smbInstances.Remove(instance);
            return ErrorCode.Success.AsInt();
        }
        catch (Exception ex)
        {
            erroMessage = $"Unknown error: {ex}";
            Console.WriteLine(erroMessage);
            return ErrorCode.Unknown.AsInt();

        }
    }


    [UnmanagedCallersOnly(EntryPoint = "openShareSmb")]
    public static int OpenShareSmb(SmbInstanceNative smbInstanceNative, IntPtr pShareSmb)
    {
        try
        {
            string shareSmb = Marshal.PtrToStringAnsi(pShareSmb);
            Console.WriteLine($"OpenShareSmb shareSmb {shareSmb}");
            var instance = GetSmb(smbInstanceNative.smbInstanceId);
            if (instance == null)
            {
                erroMessage = $"invalid instance id";
                Console.WriteLine(erroMessage);
                return ErrorCode.InvalidInstance.AsInt();
            }

            var client = instance.client;
            var status = NTStatus.STATUS_SUCCESS;
            var fileStore = client.TreeConnect(shareSmb, out status) as SMB2FileStore;
            if (fileStore != null && status == NTStatus.STATUS_SUCCESS)
            {
                instance.fileStore = fileStore;               
                return ErrorCode.Success.AsInt();
            }

            erroMessage = $"Failed to Access Share {status}";
            Console.WriteLine(erroMessage);
            return ErrorCode.FailedAccessShare.AsInt();
        }
        catch (Exception ex)
        {
            erroMessage = $"Unknown error: {ex}";
            Console.WriteLine(erroMessage);
            return ErrorCode.Unknown.AsInt();

        }
    }


    [UnmanagedCallersOnly(EntryPoint = "getLastError")]
    public static IntPtr GetLastError()
    {
        // Assign pointer of the concatenated string to sumPointer
        IntPtr sumPointer = Marshal.StringToHGlobalAnsi(erroMessage);
        // Return pointer
        return sumPointer;
    }

    [UnmanagedCallersOnly(EntryPoint = "downloadFileSmb")]
    public static int DownloadFileSmb(SmbInstanceNative smbInstanceNative, IntPtr pRemotePathSmb, IntPtr pDestLocalPath)
    {
        try
        {
            var retCode = ErrorCode.Success.AsInt();
            string remotePathSmb = Marshal.PtrToStringAnsi(pRemotePathSmb);
            string destLocalPath = Marshal.PtrToStringAnsi(pDestLocalPath);
            Console.WriteLine($"remotePathSmb: {remotePathSmb}");
            Console.WriteLine($"destLocalPath: {destLocalPath}");

            var instance = GetSmb(smbInstanceNative.smbInstanceId);
            if (instance == null)
            {
                erroMessage = $"invalid instance id";
                Console.WriteLine(erroMessage);
                return ErrorCode.InvalidInstance.AsInt();
            }
            if (instance.fileStore == null)
            {
                erroMessage = $"uninitialized fileStore use OpenShareSmb before";
                Console.WriteLine(erroMessage);
                return ErrorCode.UninitializedFileStore.AsInt();
            }
                  
            object handle;
            FileStatus fileStatus;

            // Open existing file for reading     
            var status = instance.fileStore.CreateFile(out handle, out fileStatus, remotePathSmb,
                 AccessMask.GENERIC_READ, 0, ShareAccess.Read,
                 CreateDisposition.FILE_OPEN,
                 CreateOptions.FILE_NON_DIRECTORY_FILE, null);

            if (status == NTStatus.STATUS_SUCCESS)
            {
                using (var memoryStream = new MemoryStream())
                {
                    byte[] buffer;
                    int bufferLeng = 4096;
                    long offset = 0;
                    while (true)
                    {
                        status = instance.fileStore.ReadFile(out buffer, handle, offset, bufferLeng);

                        if (status == NTStatus.STATUS_END_OF_FILE)
                        {
                            break;
                        }

                        if (status != NTStatus.STATUS_SUCCESS)
                        {
                            retCode = ErrorCode.FailedAccessFile.AsInt();
                            Console.WriteLine("Failed to access file");
                            break;
                        }
                        //(int)offset
                        memoryStream.Write(buffer, 0, buffer.Length);
                        offset += buffer.Length;

                    }
                    instance.fileStore.CloseFile(handle);

                    using (var file = new FileStream(destLocalPath, FileMode.Create, System.IO.FileAccess.Write))
                    {
                        memoryStream.Seek(0, SeekOrigin.Begin);
                        memoryStream.CopyTo(file);
                        memoryStream.Close();
                        file.Close();
                        Console.WriteLine($"end of file copy");
                    }
                }
            }
            else
            {
                Console.WriteLine($"Failed to access file, {status}");
                return ErrorCode.FailedAccessFile.AsInt();                
            }

            return retCode;
        }
        catch (Exception e)
        {
            Console.WriteLine($"Unknown error: {e}");
            return ErrorCode.Unknown.AsInt();
        }
    }
    // callbackDownload (bytesCopied, bytesTotal)
    [UnmanagedCallersOnly(EntryPoint = "copyFileFromSMBtoSFTP")]
    public unsafe static int CopyFileFromSMBtoSFTP(SmbInstanceNative smbInstanceNative, 
        IntPtr pRemotePathSmb, 
        IntPtr pDestSftpPath,
        IntPtr pIpSftpServer,
        int portSftpServer,
        IntPtr pUserSftp,
        IntPtr pPassSftp,
        int pBufferLeng,
        delegate* unmanaged<long, long, int> downloadCallback,
        delegate* unmanaged<long, long, int> uploadCallback
        )
    {
        try
        {
            var retCode = ErrorCode.Success.AsInt();
            string remotePathSmb = Marshal.PtrToStringAnsi(pRemotePathSmb);
            string destSftpPath = Marshal.PtrToStringAnsi(pDestSftpPath);

            string ipSftpServer = Marshal.PtrToStringAnsi(pIpSftpServer);
            string userSftp = Marshal.PtrToStringAnsi(pUserSftp);
            string passSftp = Marshal.PtrToStringAnsi(pPassSftp);

            Console.WriteLine($"CopyFileFromSMBtoSFTP remotePathSmb: {remotePathSmb}");
            Console.WriteLine($"CopyFileFromSMBtoSFTP destSftpPath {destSftpPath}");
            Console.WriteLine($"CopyFileFromSMBtoSFTP ipSftpServer {ipSftpServer}");           
           
            var instance = GetSmb(smbInstanceNative.smbInstanceId);
            if (instance == null)
            {
                erroMessage = $"invalid instance id";
                Console.WriteLine(erroMessage);
                return ErrorCode.InvalidInstance.AsInt();
            }
            if (instance.fileStore == null)
            {
                erroMessage = $"uninitialized fileStore use OpenShareSmb";
                Console.WriteLine(erroMessage);
                return ErrorCode.UninitializedFileStore.AsInt();
            }
                        

            object handle;
            FileStatus fileStatus;

            // Open existing file for reading     
            var status = instance.fileStore.CreateFile(out handle, out fileStatus, remotePathSmb,
                 AccessMask.GENERIC_READ | AccessMask.SYNCHRONIZE,
                 SMBLibrary.FileAttributes.Normal, ShareAccess.Read,
                 CreateDisposition.FILE_OPEN,
                 CreateOptions.FILE_NON_DIRECTORY_FILE | CreateOptions.FILE_SYNCHRONOUS_IO_ALERT
                 , null);
            //get File Informations
            FileInformation fileInformationClass;
            long bytesTotal = 0;
            status = instance.fileStore.GetFileInformation(out fileInformationClass, handle, FileInformationClass.FileAllInformation);
            if(status == NTStatus.STATUS_SUCCESS && fileInformationClass != null)
            {
                bytesTotal = fileInformationClass.Length;            
                if (downloadCallback != null)
                {
                    //bytesCopied, bytesTotal
                    downloadCallback(0, bytesTotal);
                }
            }
            if (status == NTStatus.STATUS_SUCCESS)
            {
                using (var memoryStream = new MemoryStream())
                {
                    byte[] buffer;
                    int bufferLeng = pBufferLeng > 1 ? pBufferLeng : (int)instance.client.MaxReadSize;
                    long bytesRead = 0;
                   
                    while (true)
                    {
                        status = instance.fileStore.ReadFile(out buffer, handle, bytesRead, bufferLeng);
                        if (downloadCallback != null)
                        {
                            //bytesCopied, bytesTotal
                            downloadCallback(bytesRead, bytesTotal);
                        }
                                                
                        if (status != NTStatus.STATUS_SUCCESS && status != NTStatus.STATUS_END_OF_FILE)
                        {
                            retCode = ErrorCode.FailedAccessFile.AsInt();
                            Console.WriteLine("Failed to access file");
                            break;
                        }

                        if (status == NTStatus.STATUS_END_OF_FILE || buffer.Length == 0)
                        {
                            break;
                        }
                                            
                        bytesRead  += buffer.Length;
                        memoryStream.Write(buffer, 0, buffer.Length);

                    }
                    instance.fileStore.CloseFile(handle);

                    try
                    {
                        using (SftpClient sftp = new SftpClient(ipSftpServer, portSftpServer, userSftp, passSftp))
                        {
                            sftp.Connect();
                            memoryStream.Seek(0, SeekOrigin.Begin);
                            sftp.UploadFile(memoryStream, destSftpPath, delegate (ulong d)
                            {
                                if(uploadCallback != null)
                                {
                                    uploadCallback((long)d, bytesTotal);
                                }
                            });                           
                            Console.WriteLine($"end of file copy");
                            sftp.Disconnect();
                        }
                    }catch (Exception ex)
                    {
                        Console.WriteLine($"Failed to copy file to SFTP server, {ex}");
                        return ErrorCode.FailedAccessFile.AsInt();
                    }
                    finally
                    {
                        memoryStream.Close();
                    }
                }
            }
            else
            {
                Console.WriteLine($"Failed to access file, {status}");
                return ErrorCode.FailedAccessFile.AsInt();
            }

            return retCode;
        }
        catch (Exception e)
        {
            Console.WriteLine($"Unknown error: {e}");
            return ErrorCode.Unknown.AsInt();
        }
    }
}

[jkotas]

Ideally, there would be more examples, examples that show best practices for interoperating with native code, real-world examples like:

Interoperating with native code works the same in all runtimes. We have number of docs topics and samples for that: https://docs.microsoft.com/en-us/dotnet/standard/native-interop/

The only special bit for NativeAOT is the ability to build a self-contained library.