fix(managed): Fix steam api callback

Author: samyycX

managed/src/SwiftlyS2.Shared/Modules/SteamAPI/CallbackDispatcher.cs

@@ -22,15 +22,15 @@ public static class CallbackDispatcher
     /// <summary>
     /// Register a callback handler
     /// </summary>
-    internal static unsafe void RegisterCallback<T>(ICallbackHandler<T> handler) where T : struct
+    internal static unsafe void RegisterCallback<T>( ICallbackHandler<T> handler ) where T : struct
     {
         var callbackId = CallbackIdentities.GetCallbackIdentity(typeof(T));
 
         // Add handler to dictionary
         s_callbackHandlers.AddOrUpdate(
             callbackId,
             _ => [handler],
-            (_, list) => { list.Add(handler); return list; }
+            ( _, list ) => { list.Add(handler); return list; }
         );
 
         // Register with Steam if this is the first handler for this callback
@@ -40,8 +40,8 @@ internal static unsafe void RegisterCallback<T>(ICallbackHandler<T> handler) whe
             var pCallback = Marshal.AllocHGlobal(Marshal.SizeOf<CCallbackBase>());
             var callback = (CCallbackBase*)pCallback;
 
-            callback->m_vfptr = CCallbackBaseVTable.VTablePtr;
-            callback->m_nCallbackFlags = 0;
+            callback->m_vfptr = CCallbackBaseVTable.CallbackVTablePtr;
+            callback->m_nCallbackFlags = 0x02; // k_ECallbackFlagsGameServer
             callback->m_iCallback = callbackId;
 
             // Register with Steam API
@@ -55,7 +55,7 @@ internal static unsafe void RegisterCallback<T>(ICallbackHandler<T> handler) whe
     /// <summary>
     /// Unregister a callback handler
     /// </summary>
-    internal static unsafe void UnregisterCallback<T>(ICallbackHandler<T> handler) where T : struct
+    internal static unsafe void UnregisterCallback<T>( ICallbackHandler<T> handler ) where T : struct
     {
         var callbackId = CallbackIdentities.GetCallbackIdentity(typeof(T));
 
@@ -80,7 +80,7 @@ internal static unsafe void UnregisterCallback<T>(ICallbackHandler<T> handler) w
     /// <summary>
     /// Register a call result handler
     /// </summary>
-    internal static unsafe void RegisterCallResult<T>(ulong hAPICall, ICallResultHandler<T> handler) where T : struct
+    internal static unsafe void RegisterCallResult<T>( ulong hAPICall, ICallResultHandler<T> handler ) where T : struct
     {
         var callbackId = CallbackIdentities.GetCallbackIdentity(typeof(T));
 
@@ -91,8 +91,8 @@ internal static unsafe void RegisterCallResult<T>(ulong hAPICall, ICallResultHan
         var pCallback = Marshal.AllocHGlobal(Marshal.SizeOf<CCallbackBase>());
         var callback = (CCallbackBase*)pCallback;
 
-        callback->m_vfptr = CCallbackBaseVTable.VTablePtr;
-        callback->m_nCallbackFlags = 1; // Flag indicating this is a call result
+        callback->m_vfptr = CCallbackBaseVTable.CallResultVTablePtr;
+        callback->m_nCallbackFlags = 0x02; // k_ECallbackFlagsGameServer
         callback->m_iCallback = callbackId;
 
         // Register with Steam API
@@ -105,7 +105,7 @@ internal static unsafe void RegisterCallResult<T>(ulong hAPICall, ICallResultHan
     /// <summary>
     /// Unregister a call result
     /// </summary>
-    internal static unsafe void UnregisterCallResult(ulong hAPICall, IntPtr pCallback)
+    internal static unsafe void UnregisterCallResult( ulong hAPICall, IntPtr pCallback )
     {
         _ = s_callResultHandlers.TryRemove(hAPICall, out _);
 
@@ -119,7 +119,7 @@ internal static unsafe void UnregisterCallResult(ulong hAPICall, IntPtr pCallbac
     /// <summary>
     /// Internal method called from VTable Run function
     /// </summary>
-    internal static unsafe void DispatchCallback(int callbackId, void* param)
+    internal static unsafe void DispatchCallback( int callbackId, void* param )
     {
         if (s_callbackHandlers.TryGetValue(callbackId, out var handlers))
         {
@@ -140,7 +140,7 @@ internal static unsafe void DispatchCallback(int callbackId, void* param)
     /// <summary>
     /// Internal method called from VTable RunCallResult function
     /// </summary>
-    internal static unsafe void DispatchCallResult(void* param, bool ioFailure, ulong hAPICall)
+    internal static unsafe void DispatchCallResult( void* param, bool ioFailure, ulong hAPICall )
     {
         if (s_callResultHandlers.TryRemove(hAPICall, out var handler))
         {
@@ -150,7 +150,7 @@ internal static unsafe void DispatchCallResult(void* param, bool ioFailure, ulon
             }
             catch (Exception ex)
             {
-                Console.WriteLine($"Error dispatching call result {hAPICall}: {ex}");
+                Console.WriteLine($"Error dispatching call result: {ex}");
             }
         }
     }
@@ -161,7 +161,7 @@ internal static unsafe void DispatchCallResult(void* param, bool ioFailure, ulon
 /// </summary>
 internal interface ICallbackHandler
 {
-    internal unsafe void Run(void* param);
+    internal unsafe void Run( void* param );
 }
 
 /// <summary>
@@ -176,8 +176,8 @@ internal interface ICallbackHandler<T> : ICallbackHandler where T : struct
 /// </summary>
 internal interface ICallResultHandler
 {
-    internal unsafe void Run(void* param, bool ioFailure);
-    internal void SetAPICall(ulong hAPICall, IntPtr pCallback);
+    internal unsafe void Run( void* param, bool ioFailure );
+    internal void SetAPICall( ulong hAPICall, IntPtr pCallback );
 }
 
 /// <summary>
@@ -196,15 +196,15 @@ public sealed class Callback<T> : ICallbackHandler<T>, IDisposable where T : str
     private bool _isRegistered;
     private bool _disposed;
 
-    private Callback(Action<T> callback)
+    private Callback( Action<T> callback )
     {
         _callback = callback;
     }
 
     /// <summary>
     /// Create and register a new callback
     /// </summary>
-    public static Callback<T> Create(Action<T> callback)
+    public static Callback<T> Create( Action<T> callback )
     {
         var instance = new Callback<T>(callback);
         instance.Register();
@@ -229,7 +229,7 @@ private void Unregister()
         }
     }
 
-    unsafe void ICallbackHandler.Run(void* param)
+    unsafe void ICallbackHandler.Run( void* param )
     {
         if (_callback != null && !_disposed)
         {
@@ -265,15 +265,15 @@ public sealed class CallResult<T> : ICallResultHandler<T>, IDisposable where T :
     private IntPtr _pCallback;
     private bool _disposed;
 
-    private CallResult(Action<T, bool> callback)
+    private CallResult( Action<T, bool> callback )
     {
         _callback = callback;
     }
 
     /// <summary>
     /// Create and register a new call result
     /// </summary>
-    public static CallResult<T> Create(ulong hAPICall, Action<T, bool> callback)
+    public static CallResult<T> Create( ulong hAPICall, Action<T, bool> callback )
     {
         var instance = new CallResult<T>(callback);
         instance.Set(hAPICall);
@@ -283,7 +283,7 @@ public static CallResult<T> Create(ulong hAPICall, Action<T, bool> callback)
     /// <summary>
     /// Set or change the API call to wait for
     /// </summary>
-    public void Set(ulong hAPICall)
+    public void Set( ulong hAPICall )
     {
         if (_disposed)
             return;
@@ -302,13 +302,13 @@ public void Set(ulong hAPICall)
         }
     }
 
-    void ICallResultHandler.SetAPICall(ulong hAPICall, IntPtr pCallback)
+    void ICallResultHandler.SetAPICall( ulong hAPICall, IntPtr pCallback )
     {
         _hAPICall = hAPICall;
         _pCallback = pCallback;
     }
 
-    unsafe void ICallResultHandler.Run(void* param, bool ioFailure)
+    unsafe void ICallResultHandler.Run( void* param, bool ioFailure )
     {
         if (_callback != null && !_disposed)
         {
@@ -346,7 +346,7 @@ public void Dispose()
 /// Native callback structure that matches C++ CCallbackBase layout
 /// This structure is passed to SteamAPI_RegisterCallback
 /// </summary>
-[StructLayout(LayoutKind.Sequential)]
+[StructLayout(LayoutKind.Sequential, Pack = 4)]
 internal unsafe struct CCallbackBase
 {
     public IntPtr m_vfptr;
@@ -359,24 +359,31 @@ internal unsafe struct CCallbackBase
 /// </summary>
 internal static class CCallbackBaseVTable
 {
-    public static IntPtr VTablePtr { get; private set; }
+    public static IntPtr CallbackVTablePtr { get; private set; }
+    public static IntPtr CallResultVTablePtr { get; private set; }
 
     static unsafe CCallbackBaseVTable()
     {
         // Allocate VTable with 3 function pointers
-        VTablePtr = Marshal.AllocHGlobal(IntPtr.Size * 3);
-        Span<IntPtr> vtable = new((void*)VTablePtr, 3);
-
-        vtable[0] = (IntPtr)(delegate* unmanaged<CCallbackBase*, void*, void>)&Run;
-        vtable[1] = (IntPtr)(delegate* unmanaged<CCallbackBase*, void*, bool, ulong, void>)&RunCallResult;
-        vtable[2] = (IntPtr)(delegate* unmanaged<CCallbackBase*, int>)&GetCallbackSizeBytes;
+        CallbackVTablePtr = Marshal.AllocHGlobal(IntPtr.Size * 3);
+        CallResultVTablePtr = Marshal.AllocHGlobal(IntPtr.Size * 3);
+        Span<IntPtr> vtable = new((void*)CallbackVTablePtr, 3);
+        Span<IntPtr> callResultVtable = new((void*)CallResultVTablePtr, 3);
+
+        vtable[0] = (IntPtr)(delegate* unmanaged< CCallbackBase*, void*, void >)&RunCallback;
+        vtable[1] = (IntPtr)(delegate* unmanaged< CCallbackBase*, void*, byte, ulong, void >)&RunCallbackOverload;
+        vtable[2] = (IntPtr)(delegate* unmanaged< CCallbackBase*, int >)&GetCallbackSizeBytes;
+
+        callResultVtable[0] = (IntPtr)(delegate* unmanaged< CCallbackBase*, void*, void >)&RunCallResult;
+        callResultVtable[1] = (IntPtr)(delegate* unmanaged< CCallbackBase*, void*, byte, ulong, void >)&RunCallResultOverload;
+        callResultVtable[2] = (IntPtr)(delegate* unmanaged< CCallbackBase*, int >)&GetCallbackSizeBytes;
     }
 
     /// <summary>
     /// Called by Steam when a callback is triggered
     /// </summary>
     [UnmanagedCallersOnly]
-    private static unsafe void Run(CCallbackBase* self, void* param)
+    private static unsafe void RunCallback( CCallbackBase* self, void* param )
     {
         try
         {
@@ -389,15 +396,40 @@ private static unsafe void Run(CCallbackBase* self, void* param)
         }
     }
 
+
+    /// <summary>
+    /// Called by Steam when a callback is triggered, overload version
+    /// </summary>
+    [UnmanagedCallersOnly]
+    private static unsafe void RunCallbackOverload( CCallbackBase* self, void* param, byte ioFailure, ulong hAPICall )
+    {
+        try
+        {
+            var callbackId = self->m_iCallback;
+            CallbackDispatcher.DispatchCallback(callbackId, param);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Exception in CCallbackBase.RunCallResult: {ex}");
+        }
+    }
+
+    [UnmanagedCallersOnly]
+    private static unsafe void RunCallResult( CCallbackBase* self, void* param )
+    {
+        throw new NotImplementedException("Shouldn't be called.");
+    }
+
+
     /// <summary>
     /// Called by Steam when a call result is ready
     /// </summary>
     [UnmanagedCallersOnly]
-    private static unsafe void RunCallResult(CCallbackBase* self, void* param, bool ioFailure, ulong hAPICall)
+    private static unsafe void RunCallResultOverload( CCallbackBase* self, void* param, byte ioFailure, ulong hAPICall )
     {
         try
         {
-            CallbackDispatcher.DispatchCallResult(param, ioFailure, hAPICall);
+            CallbackDispatcher.DispatchCallResult(param, ioFailure == 1, hAPICall);
         }
         catch (Exception ex)
         {
@@ -409,8 +441,9 @@ private static unsafe void RunCallResult(CCallbackBase* self, void* param, bool
     /// Returns the size of the callback structure
     /// </summary>
     [UnmanagedCallersOnly]
-    private static unsafe int GetCallbackSizeBytes(CCallbackBase* self)
+    private static unsafe int GetCallbackSizeBytes( CCallbackBase* self )
     {
+        Console.WriteLine($"GetCallbackSizeBytes");
         try
         {
             int callbackId = self->m_iCallback;

managed/src/TestPlugin/TestPlugin.cs

@@ -327,7 +327,9 @@ public void TestCommand( ICommandContext context )
     public void TestCommand1( ICommandContext context )
     {
         var ret = SteamGameServerUGC.DownloadItem(new PublishedFileId_t(3596198331), true);
-        Console.WriteLine(Core.Engine.ServerIP);
+        Console.WriteLine(SteamGameServer.GetPublicIP().ToIPAddress());
+
+
     }
 
     [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
@@ -544,7 +546,7 @@ public void OnSteamAPIActivated()
 
     public void AuthResponse( ValidateAuthTicketResponse_t param )
     {
-        Console.WriteLine($"AuthResponse: {param.m_eAuthSessionResponse} -> {param.m_SteamID.m_SteamID}");
+        Console.WriteLine($"AuthResponse {param.m_eAuthSessionResponse} -> {param.m_SteamID.m_SteamID}");
     }
 
     [Command("getip")]