public static IntPtr Get(int size, int referenceCount) { const int maxSize = 16 * 1024 * 1024; if (size < 0 || size > maxSize) { throw new ArgumentOutOfRangeException(nameof(size)); } if (referenceCount <= 0) { throw new ArgumentOutOfRangeException(nameof(referenceCount)); } AllocateBuffer(size, out var ptr, out var actualSize); var counter = AllocateReferenceCounter(ptr, actualSize, referenceCount); #if DEBUG SteamNetworkingUtils.LogDebugMessage(NetDebugOutput.Verbose, $"{nameof( BufferManager )} allocated {ptr.ToInt64():X8} (size={size}, actualSize={actualSize}) with {referenceCount} references"); #endif lock ( ReferenceCounters ) { ReferenceCounters.Add(ptr, counter); } return(ptr); }
public static void Shutdown() { Event.DisposeAllClient(); initialized = false; ShutdownInterfaces(); SteamApps.Shutdown(); SteamUtils.Shutdown(); SteamParental.Shutdown(); SteamMusic.Shutdown(); SteamVideo.Shutdown(); SteamUser.Shutdown(); SteamFriends.Shutdown(); SteamScreenshots.Shutdown(); SteamUserStats.Shutdown(); SteamInventory.Shutdown(); SteamNetworking.Shutdown(); SteamMatchmaking.Shutdown(); SteamParties.Shutdown(); SteamNetworkingUtils.Shutdown(); SteamNetworkingSockets.Shutdown(); ServerList.Base.Shutdown(); SteamAPI.Shutdown(); }
public void Set(IntPtr ptr, int size, int referenceCount) { if (ptr == IntPtr.Zero) { throw new ArgumentNullException(nameof(ptr)); } if (size <= 0) { throw new ArgumentOutOfRangeException(nameof(size)); } if (referenceCount <= 0) { throw new ArgumentOutOfRangeException(nameof(referenceCount)); } Pointer = ptr; Size = size; var prevCount = Interlocked.Exchange(ref _count, referenceCount); if (prevCount != 0) { #if DEBUG SteamNetworkingUtils.LogDebugMessage(NetDebugOutput.Warning, $"{nameof( BufferManager )} set reference count when current count was not 0"); #endif } }
public async Task RelayEndtoEndFakeIP() { SteamNetworkingUtils.InitRelayNetworkAccess(); SteamNetworkingUtils.DebugLevel = NetDebugOutput.Warning; SteamNetworkingUtils.OnDebugOutput += DebugOutput; // For some reason giving steam a couple of seconds here // seems to prevent it returning null connections from ConnectNormal await Task.Delay(2000); Console.WriteLine($"----- Creating Socket Relay Socket.."); var socket = SteamNetworkingSockets.CreateRelaySocketFakeIP <TestSocketInterface>(); var server = socket.RunAsync(); await Task.Delay(1000); Console.WriteLine($"----- Retrieving Fake IP.."); SteamNetworkingSockets.GetFakeIP(0, out NetAddress address); Console.WriteLine($"----- Connecting To Socket via Fake IP ({address})"); var connection = SteamNetworkingSockets.ConnectNormal <TestConnectionInterface>(address); var client = connection.RunAsync(); await Task.WhenAll(server, client); }
public static void Shutdown() { Event.DisposeAllServer(); SteamServer.initialized = false; SteamServer._internal = null; SteamServer.ShutdownInterfaces(); SteamNetworkingUtils.Shutdown(); SteamNetworkingSockets.Shutdown(); SteamInventory.Shutdown(); SteamGameServer.Shutdown(); }
public bool Decrement() { var newCount = Interlocked.Decrement(ref _count); if (newCount < 0) { SteamNetworkingUtils.LogDebugMessage(NetDebugOutput.Bug, $"Prevented double free of {nameof(BufferManager)} pointer"); return(false); } return(newCount == 0); }
public async Task GetEstimatedPing() { await SteamNetworkingUtils.WaitForPingDataAsync(); var garrysping = Data.PingLocation.TryParseFromString(GarrysLocation); Assert.IsTrue(garrysping.HasValue); var ping = SteamNetworkingUtils.EstimatePingTo(garrysping.Value); Assert.IsTrue(ping > 0); Console.WriteLine($"Ping returned: {ping}"); }
private static void FreeBuffer(IntPtr ptr, int size) { var bucketSize = GetBucketSize(size); var bucketLimit = GetBucketLimit(size); if (bucketSize <= 0 || bucketLimit <= 0) { // not bucketed, no pooling for this size Marshal.FreeHGlobal(ptr); #if DEBUG SteamNetworkingUtils.LogDebugMessage(NetDebugOutput.Verbose, $"{nameof( BufferManager )} freed unpooled pointer {ptr.ToInt64():X8} (size={size})"); #endif return; } lock ( BufferPools ) { if (!BufferPools.TryGetValue(bucketSize, out var bucketPool)) { bucketPool = new Stack <IntPtr>(bucketLimit); BufferPools.Add(bucketSize, bucketPool); } if (bucketPool.Count >= bucketLimit) { // pool overflow, get rid Marshal.FreeHGlobal(ptr); #if DEBUG SteamNetworkingUtils.LogDebugMessage(NetDebugOutput.Verbose, $"{nameof( BufferManager )} pool overflow, freed pooled pointer {ptr.ToInt64():X8} (size={size})"); #endif return; } bucketPool.Push(ptr); #if DEBUG SteamNetworkingUtils.LogDebugMessage(NetDebugOutput.Verbose, $"{nameof( BufferManager )} returned pointer to pool {ptr.ToInt64():X8} (size={size})"); #endif } }
public async Task LocalPingLocation() { await SteamNetworkingUtils.WaitForPingDataAsync(); for (int i = 0; i < 10; i++) { var pl = SteamNetworkingUtils.LocalPingLocation; if (!pl.HasValue) { await Task.Delay(1000); continue; } Console.WriteLine($"{i} Seconds Until Result: {pl}"); return; } Assert.Fail(); }
public async Task RelayEndtoEnd() { SteamNetworkingUtils.InitRelayNetworkAccess(); // For some reason giving steam a couple of seconds here // seems to prevent it returning null connections from ConnectNormal await Task.Delay(2000); Console.WriteLine($"----- Creating Socket Relay Socket.."); var socket = SteamNetworkingSockets.CreateRelaySocket <TestSocketInterface>(6); var server = socket.RunAsync(); await Task.Delay(1000); Console.WriteLine($"----- Connecting To Socket via SteamId ({SteamClient.SteamId})"); var connection = SteamNetworkingSockets.ConnectRelay <TestConnectionInterface>(SteamClient.SteamId, 6); var client = connection.RunAsync(); await Task.WhenAll(server, client); }
private static void Free(NetMsg *msg) { var ptr = msg->DataPtr; lock ( ReferenceCounters ) { if (!ReferenceCounters.TryGetValue(ptr, out var counter)) { SteamNetworkingUtils.LogDebugMessage(NetDebugOutput.Bug, $"Attempt to free pointer not tracked by {nameof(BufferManager)}: {ptr.ToInt64():X8}"); return; } #if DEBUG SteamNetworkingUtils.LogDebugMessage(NetDebugOutput.Verbose, $"{nameof( BufferManager )} decrementing reference count of {ptr.ToInt64():X8}"); #endif if (counter.Decrement()) { #if DEBUG SteamNetworkingUtils.LogDebugMessage(NetDebugOutput.Verbose, $"{nameof( BufferManager )} freeing {ptr.ToInt64():X8} as it is now unreferenced"); if (ptr != counter.Pointer) { SteamNetworkingUtils.LogDebugMessage(NetDebugOutput.Bug, $"{nameof( BufferManager )} freed pointer ({ptr.ToInt64():X8}) does not match counter pointer ({counter.Pointer.ToInt64():X8})"); } var bucketSize = GetBucketSize(counter.Size); if (counter.Size != bucketSize) { SteamNetworkingUtils.LogDebugMessage(NetDebugOutput.Bug, $"{nameof( BufferManager )} freed pointer size ({counter.Size}) does not match bucket size ({bucketSize})"); } #endif ReferenceCounters.Remove(ptr); FreeBuffer(ptr, counter.Size); FreeReferenceCounter(counter); } } }
private static void AllocateBuffer(int minimumSize, out IntPtr ptr, out int size) { var bucketSize = GetBucketSize(minimumSize); if (bucketSize <= 0) { // not bucketed, no pooling for this size ptr = Marshal.AllocHGlobal(minimumSize); size = minimumSize; #if DEBUG SteamNetworkingUtils.LogDebugMessage(NetDebugOutput.Verbose, $"{nameof( BufferManager )} allocated unpooled pointer {ptr.ToInt64():X8} (size={size})"); #endif return; } lock ( BufferPools ) { if (!BufferPools.TryGetValue(bucketSize, out var bucketPool) || bucketPool.Count == 0) { // nothing pooled yet, but we can pool this size ptr = Marshal.AllocHGlobal(bucketSize); size = bucketSize; #if DEBUG SteamNetworkingUtils.LogDebugMessage(NetDebugOutput.Verbose, $"{nameof( BufferManager )} allocated new poolable pointer {ptr.ToInt64():X8} (size={size})"); #endif return; } ptr = bucketPool.Pop(); size = bucketSize; #if DEBUG SteamNetworkingUtils.LogDebugMessage(NetDebugOutput.Verbose, $"{nameof( BufferManager )} allocated pointer from pool {ptr.ToInt64():X8} (size={size})"); #endif } }
/// <summary> /// Calls RunFrame and processes events from this Steam Pipe /// </summary> public static void Frame(HSteamPipe pipe) { if (runningFrame) { return; } try { runningFrame = true; SteamAPI_ManualDispatch_RunFrame(pipe); SteamNetworkingUtils.OutputDebugMessages(); CallbackMsg_t msg = default; while (SteamAPI_ManualDispatch_GetNextCallback(pipe, ref msg)) { try { ProcessCallback(msg, pipe == ServerPipe); } finally { SteamAPI_ManualDispatch_FreeLastCallback(pipe); } } } catch (System.Exception e) { OnException?.Invoke(e); } finally { runningFrame = false; } }