ToxicMushroom/Dalamud
1
0
Fork 0
mirror of https://github.com/goatcorp/Dalamud.git synced 2025-12-11 01:37:24 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Merge pull request #2468 from KazWolfe/rpc-unix

Browse source 
feat: Add unix sockets
This commit is contained in:
goat 2025-12-04 00:48:23 +01:00 • committed by GitHub
commit a917ebd856
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
19 changed files with 466 additions and 249 deletions
Download patch file Download diff file Expand all files Collapse all files

5
Dalamud.Boot/DalamudStartInfo.cpp
View file

@ -108,6 +108,11 @@ void from_json(const nlohmann::json& json, DalamudStartInfo& config) {
config.LogName = json.value("LogName", config.LogName);
config.PluginDirectory = json.value("PluginDirectory", config.PluginDirectory);
config.AssetDirectory = json.value("AssetDirectory", config.AssetDirectory);
if (json.contains("TempDirectory") && !json["TempDirectory"].is_null()) {
config.TempDirectory = json.value("TempDirectory", config.TempDirectory);
}
config.Language = json.value("Language", config.Language);
config.Platform = json.value("Platform", config.Platform);
config.GameVersion = json.value("GameVersion", config.GameVersion);

1
Dalamud.Boot/DalamudStartInfo.h
View file

@ -44,6 +44,7 @@ struct DalamudStartInfo {
std::string ConfigurationPath;
std::string LogPath;
std::string LogName;
std::string TempDirectory;
std::string PluginDirectory;
std::string AssetDirectory;
ClientLanguage Language = ClientLanguage::English;

15
Dalamud.Boot/veh.cpp
View file

@ -122,6 +122,7 @@ static DalamudExpected<void> append_injector_launch_args(std::vector<std::wstrin
args.emplace_back(L"--logname=\"" + unicode::convert<std::wstring>(g_startInfo.LogName) + L"\"");
args.emplace_back(L"--dalamud-plugin-directory=\"" + unicode::convert<std::wstring>(g_startInfo.PluginDirectory) + L"\"");
args.emplace_back(L"--dalamud-asset-directory=\"" + unicode::convert<std::wstring>(g_startInfo.AssetDirectory) + L"\"");
args.emplace_back(L"--dalamud-temp-directory=\"" + unicode::convert<std::wstring>(g_startInfo.TempDirectory) + L"\"");
args.emplace_back(std::format(L"--dalamud-client-language={}", static_cast<int>(g_startInfo.Language)));
args.emplace_back(std::format(L"--dalamud-delay-initialize={}", g_startInfo.DelayInitializeMs));
// NoLoadPlugins/NoLoadThirdPartyPlugins: supplied from DalamudCrashHandler
@ -268,7 +269,7 @@ LONG WINAPI vectored_exception_handler(EXCEPTION_POINTERS* ex)
if (!is_ffxiv_address(L"ffxiv_dx11.exe", ex->ContextRecord->Rip) &&
!is_ffxiv_address(L"cimgui.dll", ex->ContextRecord->Rip))
return EXCEPTION_CONTINUE_SEARCH;
return EXCEPTION_CONTINUE_SEARCH;
}
return exception_handler(ex);
@ -297,7 +298,7 @@ bool veh::add_handler(bool doFullDump, const std::string& workingDirectory)
if (HANDLE hReadPipeRaw, hWritePipeRaw; CreatePipe(&hReadPipeRaw, &hWritePipeRaw, nullptr, 65536))
{
hWritePipe.emplace(hWritePipeRaw, &CloseHandle);
if (HANDLE hReadPipeInheritableRaw; DuplicateHandle(GetCurrentProcess(), hReadPipeRaw, GetCurrentProcess(), &hReadPipeInheritableRaw, 0, TRUE, DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE))
{
hReadPipeInheritable.emplace(hReadPipeInheritableRaw, &CloseHandle);
@ -315,9 +316,9 @@ bool veh::add_handler(bool doFullDump, const std::string& workingDirectory)
}
// additional information
STARTUPINFOEXW siex{};
STARTUPINFOEXW siex{};
PROCESS_INFORMATION pi{};
siex.StartupInfo.cb = sizeof siex;
siex.StartupInfo.dwFlags = STARTF_USESHOWWINDOW;
siex.StartupInfo.wShowWindow = g_startInfo.CrashHandlerShow ? SW_SHOW : SW_HIDE;
@ -385,7 +386,7 @@ bool veh::add_handler(bool doFullDump, const std::string& workingDirectory)
argstr.push_back(L' ');
}
argstr.pop_back();
if (!handles.empty() && !UpdateProcThreadAttribute(siex.lpAttributeList, 0, PROC_THREAD_ATTRIBUTE_HANDLE_LIST, &handles[0], std::span(handles).size_bytes(), nullptr, nullptr))
{
logging::W("Failed to launch DalamudCrashHandler.exe: UpdateProcThreadAttribute error 0x{:x}", GetLastError());
@ -400,7 +401,7 @@ bool veh::add_handler(bool doFullDump, const std::string& workingDirectory)
TRUE, // Set handle inheritance to FALSE
EXTENDED_STARTUPINFO_PRESENT, // lpStartupInfo actually points to a STARTUPINFOEX(W)
nullptr, // Use parent's environment block
nullptr, // Use parent's starting directory
nullptr, // Use parent's starting directory
&siex.StartupInfo, // Pointer to STARTUPINFO structure
&pi // Pointer to PROCESS_INFORMATION structure (removed extra parentheses)
))
@ -416,7 +417,7 @@ bool veh::add_handler(bool doFullDump, const std::string& workingDirectory)
}
CloseHandle(pi.hThread);
g_crashhandler_process = pi.hProcess;
g_crashhandler_pipe_write = hWritePipe->release();
logging::I("Launched DalamudCrashHandler.exe: PID {}", pi.dwProcessId);

6
Dalamud.Common/DalamudStartInfo.cs
View file

@ -34,6 +34,12 @@ public record DalamudStartInfo
/// </summary>
public string? ConfigurationPath { get; set; }
/// <summary>
/// Gets or sets the directory for temporary files. This directory needs to exist and be writable to the user.
/// It should also be predictable and easy for launchers to find.
/// </summary>
public string? TempDirectory { get; set; }
/// <summary>
/// Gets or sets the path of the log files.
/// </summary>

6
Dalamud.Injector/Program.cs
View file

@ -291,6 +291,7 @@ namespace Dalamud.Injector
var configurationPath = startInfo.ConfigurationPath;
var pluginDirectory = startInfo.PluginDirectory;
var assetDirectory = startInfo.AssetDirectory;
var tempDirectory = startInfo.TempDirectory;
var delayInitializeMs = startInfo.DelayInitializeMs;
var logName = startInfo.LogName;
var logPath = startInfo.LogPath;
@ -321,6 +322,10 @@ namespace Dalamud.Injector
{
assetDirectory = args[i][key.Length..];
}
else if (args[i].StartsWith(key = "--dalamud-temp-directory="))
{
tempDirectory = args[i][key.Length..];
}
else if (args[i].StartsWith(key = "--dalamud-delay-initialize="))
{
delayInitializeMs = int.Parse(args[i][key.Length..]);
@ -433,6 +438,7 @@ namespace Dalamud.Injector
startInfo.ConfigurationPath = configurationPath;
startInfo.PluginDirectory = pluginDirectory;
startInfo.AssetDirectory = assetDirectory;
startInfo.TempDirectory = tempDirectory;
startInfo.Language = clientLanguage;
startInfo.Platform = platform;
startInfo.DelayInitializeMs = delayInitializeMs;

5
Dalamud.Test/Pipes/DalamudUriTests.cs → Dalamud.Test/Rpc/DalamudUriTests.cs
View file

@ -1,10 +1,11 @@
using System;
using System.Linq;
using Dalamud.Networking.Pipes;
using Dalamud.Networking.Rpc.Model;
using Xunit;
namespace Dalamud.Test.Pipes
namespace Dalamud.Test.Rpc
{
public class DalamudUriTests
{

167
Dalamud/Networking/Pipes/Rpc/PipeRpcHost.cs
View file

@ -1,167 +0,0 @@
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO.Pipes;
using System.Security.AccessControl;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using Dalamud.Logging.Internal;
using Dalamud.Utility;
namespace Dalamud.Networking.Pipes.Rpc;
/// <summary>
/// Simple multi-client JSON-RPC named pipe host using StreamJsonRpc.
/// </summary>
internal class PipeRpcHost : IDisposable
{
private readonly ModuleLog log = new("RPC/Host");
private readonly RpcServiceRegistry registry = new();
private readonly CancellationTokenSource cts = new();
private readonly ConcurrentDictionary<Guid, RpcConnection> sessions = new();
private Task? acceptLoopTask;
/// <summary>
/// Initializes a new instance of the <see cref="PipeRpcHost"/> class.
/// </summary>
/// <param name="pipeName">The pipe name to create.</param>
public PipeRpcHost(string? pipeName = null)
{
// Default pipe name based on current process ID for uniqueness per Dalamud instance.
this.PipeName = pipeName ?? $"DalamudRPC.{Environment.ProcessId}";
}
/// <summary>
/// Gets the name of the named pipe this RPC host is using.
/// </summary>
public string PipeName { get; }
/// <summary>Adds a local object exposing RPC methods callable by clients.</summary>
/// <param name="service">An arbitrary service object that will be introspected to add to RPC.</param>
public void AddService(object service) => this.registry.AddService(service);
/// <summary>
/// Adds a standalone JSON-RPC method callable by clients.
/// </summary>
/// <param name="name">The name to add.</param>
/// <param name="handler">The delegate that acts as the handler.</param>
public void AddMethod(string name, Delegate handler) => this.registry.AddMethod(name, handler);
/// <summary>Starts accepting client connections.</summary>
public void Start()
{
if (this.acceptLoopTask != null) return;
this.acceptLoopTask = Task.Factory.StartNew(this.AcceptLoopAsync, TaskCreationOptions.LongRunning);
}
/// <summary>Invoke an RPC request on a specific client expecting a result.</summary>
/// <param name="clientId">The client ID to invoke.</param>
/// <param name="method">The method to invoke.</param>
/// <param name="arguments">Any arguments to invoke.</param>
/// <returns>An optional return based on the specified RPC.</returns>
/// <typeparam name="T">The expected response type.</typeparam>
public Task<T> InvokeClientAsync<T>(Guid clientId, string method, params object[] arguments)
{
if (!this.sessions.TryGetValue(clientId, out var session))
throw new KeyNotFoundException($"No client {clientId}");
return session.Rpc.InvokeAsync<T>(method, arguments);
}
/// <summary>Send a notification to all connected clients (no response expected).</summary>
/// <param name="method">The method name to broadcast.</param>
/// <param name="arguments">The arguments to broadcast.</param>
/// <returns>Returns a Task when completed.</returns>
public Task BroadcastNotifyAsync(string method, params object[] arguments)
{
var list = this.sessions.Values;
var tasks = new List<Task>(list.Count);
foreach (var s in list)
{
tasks.Add(s.Rpc.NotifyAsync(method, arguments));
}
return Task.WhenAll(tasks);
}
/// <summary>
/// Gets a list of connected client IDs.
/// </summary>
/// <returns>Connected client IDs.</returns>
public IReadOnlyCollection<Guid> GetClientIds() => this.sessions.Keys.AsReadOnlyCollection();
/// <inheritdoc/>
public void Dispose()
{
this.cts.Cancel();
this.acceptLoopTask?.Wait(1000);
foreach (var kv in this.sessions)
{
kv.Value.Dispose();
}
this.sessions.Clear();
this.cts.Dispose();
this.log.Information("PipeRpcHost disposed ({Pipe})", this.PipeName);
GC.SuppressFinalize(this);
}
private PipeSecurity BuildPipeSecurity()
{
var ps = new PipeSecurity();
ps.AddAccessRule(new PipeAccessRule(WindowsIdentity.GetCurrent().User!, PipeAccessRights.FullControl, AccessControlType.Allow));
return ps;
}
private async Task AcceptLoopAsync()
{
this.log.Information("PipeRpcHost starting on pipe {Pipe}", this.PipeName);
var token = this.cts.Token;
var security = this.BuildPipeSecurity();
while (!token.IsCancellationRequested)
{
NamedPipeServerStream? server = null;
try
{
server = NamedPipeServerStreamAcl.Create(
this.PipeName,
PipeDirection.InOut,
NamedPipeServerStream.MaxAllowedServerInstances,
PipeTransmissionMode.Message,
PipeOptions.Asynchronous,
65536,
65536,
security);
await server.WaitForConnectionAsync(token).ConfigureAwait(false);
var session = new RpcConnection(server, this.registry);
this.sessions.TryAdd(session.Id, session);
this.log.Debug("RPC connection created: {Id}", session.Id);
_ = session.Completion.ContinueWith(t =>
{
this.sessions.TryRemove(session.Id, out _);
this.log.Debug("RPC connection removed: {Id}", session.Id);
}, TaskScheduler.Default);
}
catch (OperationCanceledException)
{
server?.Dispose();
break;
}
catch (Exception ex)
{
server?.Dispose();
this.log.Error(ex, "Error in pipe accept loop");
await Task.Delay(500, token).ConfigureAwait(false);
}
}
}
}

49
Dalamud/Networking/Pipes/Rpc/RpcHostService.cs
View file

@ -1,49 +0,0 @@
using Dalamud.Logging.Internal;
namespace Dalamud.Networking.Pipes.Rpc;
/// <summary>
/// The Dalamud service repsonsible for hosting the RPC.
/// </summary>
[ServiceManager.EarlyLoadedService]
internal class RpcHostService : IServiceType, IInternalDisposableService
{
private readonly ModuleLog log = new("RPC");
private readonly PipeRpcHost host;
/// <summary>
/// Initializes a new instance of the <see cref="RpcHostService"/> class.
/// </summary>
[ServiceManager.ServiceConstructor]
public RpcHostService()
{
this.host = new PipeRpcHost();
this.host.Start();
this.log.Information("RpcHostService started on pipe {Pipe}", this.host.PipeName);
}
/// <summary>
/// Gets the RPC host to drill down.
/// </summary>
public PipeRpcHost Host => this.host;
/// <summary>
/// Add a new service Object to the RPC host.
/// </summary>
/// <param name="service">The object to add.</param>
public void AddService(object service) => this.host.AddService(service);
/// <summary>
/// Add a new standalone method to the RPC host.
/// </summary>
/// <param name="name">The method name to add.</param>
/// <param name="handler">The handler to add.</param>
public void AddMethod(string name, Delegate handler) => this.host.AddMethod(name, handler);
/// <inheritdoc/>
public void DisposeService()
{
this.host.Dispose();
}
}

2
Dalamud/Networking/Pipes/DalamudUri.cs → Dalamud/Networking/Rpc/Model/DalamudUri.cs
View file

@ -2,7 +2,7 @@
using System.Collections.Specialized;
using System.Web;
namespace Dalamud.Networking.Pipes;
namespace Dalamud.Networking.Rpc.Model;
/// <summary>
/// A Dalamud Uri, in the format:

23
Dalamud/Networking/Pipes/Rpc/RpcConnection.cs → Dalamud/Networking/Rpc/RpcConnection.cs
View file

@ -1,34 +1,37 @@
using System.IO.Pipes;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Dalamud.Networking.Rpc.Service;
using Serilog;
using StreamJsonRpc;
namespace Dalamud.Networking.Pipes.Rpc;
namespace Dalamud.Networking.Rpc;
/// <summary>
/// A single RPC client session connected via named pipe.
/// A single RPC client session connected via a stream (named pipe or Unix socket).
/// </summary>
internal class RpcConnection : IDisposable
{
private readonly NamedPipeServerStream pipe;
private readonly Stream stream;
private readonly RpcServiceRegistry registry;
private readonly CancellationTokenSource cts = new();
/// <summary>
/// Initializes a new instance of the <see cref="RpcConnection"/> class.
/// </summary>
/// <param name="pipe">The named pipe that this connection will handle.</param>
/// <param name="stream">The stream that this connection will handle.</param>
/// <param name="registry">A registry of RPC services.</param>
public RpcConnection(NamedPipeServerStream pipe, RpcServiceRegistry registry)
public RpcConnection(Stream stream, RpcServiceRegistry registry)
{
this.Id = Guid.CreateVersion7();
this.pipe = pipe;
this.stream = stream;
this.registry = registry;
var formatter = new JsonMessageFormatter();
var handler = new HeaderDelimitedMessageHandler(pipe, pipe, formatter);
var handler = new HeaderDelimitedMessageHandler(stream, stream, formatter);
this.Rpc = new JsonRpc(handler);
this.Rpc.AllowModificationWhileListening = true;
@ -72,11 +75,11 @@ internal class RpcConnection : IDisposable
try
{
this.pipe.Dispose();
this.stream.Dispose();
}
catch (Exception ex)
{
Log.Debug(ex, "Error disposing pipe for client {Id}", this.Id);
Log.Debug(ex, "Error disposing stream for client {Id}", this.Id);
}
this.cts.Dispose();

91
Dalamud/Networking/Rpc/RpcHostService.cs Normal file
View file

@ -0,0 +1,91 @@
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Threading.Tasks;
using Dalamud.Logging.Internal;
using Dalamud.Networking.Rpc.Transport;
namespace Dalamud.Networking.Rpc;
/// <summary>
/// The Dalamud service repsonsible for hosting the RPC.
/// </summary>
[ServiceManager.EarlyLoadedService]
internal class RpcHostService : IServiceType, IInternalDisposableService
{
private readonly ModuleLog log = new("RPC");
private readonly RpcServiceRegistry registry = new();
private readonly List<IRpcTransport> transports = [];
/// <summary>
/// Initializes a new instance of the <see cref="RpcHostService"/> class.
/// </summary>
[ServiceManager.ServiceConstructor]
public RpcHostService()
{
this.StartUnixTransport();
if (this.transports.Count == 0)
{
this.log.Warning("No RPC hosts could be started on this platform");
}
}
/// <summary>
/// Gets all active RPC transports.
/// </summary>
public IReadOnlyList<IRpcTransport> Transports => this.transports;
/// <summary>
/// Add a new service Object to the RPC host.
/// </summary>
/// <param name="service">The object to add.</param>
public void AddService(object service) => this.registry.AddService(service);
/// <summary>
/// Add a new standalone method to the RPC host.
/// </summary>
/// <param name="name">The method name to add.</param>
/// <param name="handler">The handler to add.</param>
public void AddMethod(string name, Delegate handler) => this.registry.AddMethod(name, handler);
/// <inheritdoc/>
public void DisposeService()
{
foreach (var host in this.transports)
{
host.Dispose();
}
this.transports.Clear();
}
/// <inheritdoc cref="IRpcTransport.InvokeClientAsync"/>
public async Task<T> InvokeClientAsync<T>(Guid clientId, string method, params object[] arguments)
{
var clients = this.transports.SelectMany(t => t.Connections).ToImmutableDictionary();
if (!clients.TryGetValue(clientId, out var session))
throw new KeyNotFoundException($"No client {clientId}");
return await session.Rpc.InvokeAsync<T>(method, arguments).ConfigureAwait(false);
}
/// <inheritdoc cref="IRpcTransport.BroadcastNotifyAsync"/>
public async Task BroadcastNotifyAsync(string method, params object[] arguments)
{
await foreach (var transport in this.transports.ToAsyncEnumerable().ConfigureAwait(false))
{
await transport.BroadcastNotifyAsync(method, arguments).ConfigureAwait(false);
}
}
private void StartUnixTransport()
{
var transport = new UnixRpcTransport(this.registry);
this.transports.Add(transport);
transport.Start();
this.log.Information("RpcHostService listening to UNIX socket: {Socket}", transport.SocketPath);
}
}

2
Dalamud/Networking/Pipes/Rpc/RpcServiceRegistry.cs → Dalamud/Networking/Rpc/RpcServiceRegistry.cs
View file

@ -3,7 +3,7 @@ using System.Threading;
using StreamJsonRpc;
namespace Dalamud.Networking.Pipes.Rpc;
namespace Dalamud.Networking.Rpc;
/// <summary>
/// Thread-safe registry of local RPC target objects that are exposed to every connected JsonRpc session.

24
Dalamud/Networking/Pipes/Internal/ClientHelloService.cs → Dalamud/Networking/Rpc/Service/ClientHelloService.cs
View file

@ -1,14 +1,14 @@
using System.Threading.Tasks;
using System.Diagnostics;
using System.Threading.Tasks;
using Dalamud.Data;
using Dalamud.Game;
using Dalamud.Game.ClientState;
using Dalamud.Networking.Pipes.Rpc;
using Dalamud.Utility;
using Lumina.Excel.Sheets;
namespace Dalamud.Networking.Pipes.Internal;
namespace Dalamud.Networking.Rpc.Service;
/// <summary>
/// A minimal service to respond with information about this client.
@ -40,7 +40,9 @@ internal sealed class ClientHelloService : IInternalDisposableService
ApiVersion = "1.0",
DalamudVersion = Util.GetScmVersion(),
GameVersion = dalamud.StartInfo.GameVersion?.ToString() ?? "Unknown",
ClientIdentifier = await this.GetClientIdentifier(),
ProcessId = Environment.ProcessId,
ProcessStartTime = new DateTimeOffset(Process.GetCurrentProcess().StartTime).ToUnixTimeSeconds(),
ClientState = await this.GetClientIdentifier(),
};
}
@ -115,7 +117,17 @@ internal record ClientHelloResponse
public string? GameVersion { get; init; }
/// <summary>
/// Gets an identifier for this client.
/// Gets the process ID of this client.
/// </summary>
public string? ClientIdentifier { get; init; }
public int? ProcessId { get; init; }
/// <summary>
/// Gets the time this process started.
/// </summary>
public long? ProcessStartTime { get; init; }
/// <summary>
/// Gets a state for this client for user display.
/// </summary>
public string? ClientState { get; init; }
}

4
Dalamud/Networking/Pipes/Internal/LinkHandlerService.cs → Dalamud/Networking/Rpc/Service/LinkHandlerService.cs
View file

@ -2,10 +2,10 @@
using System.Collections.Generic;
using Dalamud.Logging.Internal;
using Dalamud.Networking.Pipes.Rpc;
using Dalamud.Networking.Rpc.Model;
using Dalamud.Utility;
namespace Dalamud.Networking.Pipes.Internal;
namespace Dalamud.Networking.Rpc.Service;
/// <summary>
/// A service responsible for handling Dalamud URIs and dispatching them accordingly.

67
Dalamud/Networking/Rpc/Service/Links/DebugLinkHandler.cs Normal file
View file

@ -0,0 +1,67 @@
using Dalamud.Game.Gui.Toast;
using Dalamud.Interface.ImGuiNotification;
using Dalamud.Interface.ImGuiNotification.Internal;
using Dalamud.Networking.Rpc.Model;
namespace Dalamud.Networking.Rpc.Service.Links;
#if DEBUG
/// <summary>
/// A debug controller for link handling.
/// </summary>
[ServiceManager.EarlyLoadedService]
internal sealed class DebugLinkHandler : IInternalDisposableService
{
private readonly LinkHandlerService linkHandlerService;
/// <summary>
/// Initializes a new instance of the <see cref="DebugLinkHandler"/> class.
/// </summary>
/// <param name="linkHandler">Injected LinkHandler.</param>
[ServiceManager.ServiceConstructor]
public DebugLinkHandler(LinkHandlerService linkHandler)
{
this.linkHandlerService = linkHandler;
this.linkHandlerService.Register("debug", this.HandleLink);
}
/// <inheritdoc/>
public void DisposeService()
{
this.linkHandlerService.Unregister("debug", this.HandleLink);
}
private void HandleLink(DalamudUri uri)
{
var action = uri.Path.Split("/").GetValue(1)?.ToString();
switch (action)
{
case "toast":
this.ShowToast(uri);
break;
case "notification":
this.ShowNotification(uri);
break;
}
}
private void ShowToast(DalamudUri uri)
{
var message = uri.QueryParams.Get("message") ?? "Hello, world!";
Service<ToastGui>.Get().ShowNormal(message);
}
private void ShowNotification(DalamudUri uri)
{
Service<NotificationManager>.Get().AddNotification(
new Notification
{
Title = uri.QueryParams.Get("title"),
Content = uri.QueryParams.Get("content") ?? "Hello, world!",
});
}
}
#endif

7
Dalamud/Networking/Pipes/Api/PluginLinkHandler.cs → Dalamud/Networking/Rpc/Service/Links/PluginLinkHandler.cs
View file

@ -3,12 +3,13 @@
using Dalamud.Console;
using Dalamud.IoC;
using Dalamud.IoC.Internal;
using Dalamud.Networking.Pipes.Internal;
using Dalamud.Networking.Rpc.Model;
using Dalamud.Plugin.Internal.Types;
using Dalamud.Plugin.Services;
#pragma warning disable DAL_RPC
namespace Dalamud.Networking.Pipes.Api;
namespace Dalamud.Networking.Rpc.Service.Links;
/// <inheritdoc cref="IPluginLinkHandler" />
[PluginInterface]
@ -44,7 +45,7 @@ public class PluginLinkHandler : IInternalDisposableService, IPluginLinkHandler
private void HandleUri(DalamudUri uri)
{
var target = uri.Path.Split("/").FirstOrDefault();
var target = uri.Path.Split("/").ElementAtOrDefault(1);
var thisPlugin = ConsoleManagerPluginUtil.GetSanitizedNamespaceName(this.localPlugin.InternalName);
if (target == null || !string.Equals(target, thisPlugin, StringComparison.OrdinalIgnoreCase))
{

32
Dalamud/Networking/Rpc/Transport/IRpcTransport.cs Normal file
View file

@ -0,0 +1,32 @@
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Dalamud.Networking.Rpc.Transport;
/// <summary>
/// Interface for RPC host implementations (named pipes or Unix sockets).
/// </summary>
internal interface IRpcTransport : IDisposable
{
/// <summary>
/// Gets a list of active RPC connections.
/// </summary>
IReadOnlyDictionary<Guid, RpcConnection> Connections { get; }
/// <summary>Starts accepting client connections.</summary>
void Start();
/// <summary>Invoke an RPC request on a specific client expecting a result.</summary>
/// <param name="clientId">The client ID to invoke.</param>
/// <param name="method">The method to invoke.</param>
/// <param name="arguments">Any arguments to invoke.</param>
/// <returns>An optional return based on the specified RPC.</returns>
/// <typeparam name="T">The expected response type.</typeparam>
Task<T> InvokeClientAsync<T>(Guid clientId, string method, params object[] arguments);
/// <summary>Send a notification to all connected clients (no response expected).</summary>
/// <param name="method">The method name to broadcast.</param>
/// <param name="arguments">The arguments to broadcast.</param>
/// <returns>Returns a Task when completed.</returns>
Task BroadcastNotifyAsync(string method, params object[] arguments);
}

207
Dalamud/Networking/Rpc/Transport/UnixRpcTransport.cs Normal file
View file

@ -0,0 +1,207 @@
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using Dalamud.Logging.Internal;
using Dalamud.Utility;
namespace Dalamud.Networking.Rpc.Transport;
/// <summary>
/// Simple multi-client JSON-RPC Unix socket host using StreamJsonRpc.
/// </summary>
internal class UnixRpcTransport : IRpcTransport
{
private readonly ModuleLog log = new("RPC/Transport/UnixSocket");
private readonly RpcServiceRegistry registry;
private readonly CancellationTokenSource cts = new();
private readonly ConcurrentDictionary<Guid, RpcConnection> sessions = new();
private readonly string? cleanupSocketDirectory;
private Task? acceptLoopTask;
private Socket? listenSocket;
/// <summary>
/// Initializes a new instance of the <see cref="UnixRpcTransport"/> class.
/// </summary>
/// <param name="registry">The RPC service registry to use.</param>
/// <param name="socketDirectory">The Unix socket directory to use. If null, defaults to Dalamud home directory.</param>
/// <param name="socketName">The name of the socket to create.</param>
public UnixRpcTransport(RpcServiceRegistry registry, string? socketDirectory = null, string? socketName = null)
{
this.registry = registry;
socketName ??= $"DalamudRPC.{Environment.ProcessId}.sock";
if (!socketDirectory.IsNullOrEmpty())
{
this.SocketPath = Path.Combine(socketDirectory, socketName);
}
else
{
socketDirectory = Service<Dalamud>.Get().StartInfo.TempDirectory;
if (socketDirectory == null)
{
this.SocketPath = Path.Combine(Path.GetTempPath(), socketName);
this.log.Warning("Temp dir was not set in StartInfo; using system temp for unix socket.");
}
else
{
this.SocketPath = Path.Combine(socketDirectory, socketName);
this.cleanupSocketDirectory = socketDirectory;
}
}
}
/// <summary>
/// Gets the path of the Unix socket this RPC host is using.
/// </summary>
public string SocketPath { get; }
/// <inheritdoc/>
public IReadOnlyDictionary<Guid, RpcConnection> Connections => this.sessions;
/// <summary>Starts accepting client connections.</summary>
public void Start()
{
if (this.acceptLoopTask != null) return;
// Make the directory for the socket if it doesn't exist
var socketDir = Path.GetDirectoryName(this.SocketPath);
if (!string.IsNullOrEmpty(socketDir) && !Directory.Exists(socketDir))
{
this.log.Error("Directory for unix socket does not exist: {Path}", socketDir);
return;
}
// Delete existing socket for this PID, if it exists.
if (File.Exists(this.SocketPath))
{
try
{
File.Delete(this.SocketPath);
}
catch (Exception ex)
{
this.log.Warning(ex, "Failed to delete existing socket file: {Path}", this.SocketPath);
}
}
this.acceptLoopTask = Task.Factory.StartNew(this.AcceptLoopAsync, TaskCreationOptions.LongRunning);
}
/// <summary>Invoke an RPC request on a specific client expecting a result.</summary>
/// <param name="clientId">The client ID to invoke.</param>
/// <param name="method">The method to invoke.</param>
/// <param name="arguments">Any arguments to invoke.</param>
/// <returns>An optional return based on the specified RPC.</returns>
/// <typeparam name="T">The expected response type.</typeparam>
public Task<T> InvokeClientAsync<T>(Guid clientId, string method, params object[] arguments)
{
if (!this.sessions.TryGetValue(clientId, out var session))
throw new KeyNotFoundException($"No client {clientId}");
return session.Rpc.InvokeAsync<T>(method, arguments);
}
/// <summary>Send a notification to all connected clients (no response expected).</summary>
/// <param name="method">The method name to broadcast.</param>
/// <param name="arguments">The arguments to broadcast.</param>
/// <returns>Returns a Task when completed.</returns>
public Task BroadcastNotifyAsync(string method, params object[] arguments)
{
var list = this.sessions.Values;
var tasks = new List<Task>(list.Count);
foreach (var s in list)
{
tasks.Add(s.Rpc.NotifyAsync(method, arguments));
}
return Task.WhenAll(tasks);
}
/// <inheritdoc/>
public void Dispose()
{
this.cts.Cancel();
this.acceptLoopTask?.Wait(1000);
foreach (var kv in this.sessions)
{
kv.Value.Dispose();
}
this.sessions.Clear();
this.listenSocket?.Dispose();
if (File.Exists(this.SocketPath))
{
try
{
File.Delete(this.SocketPath);
}
catch (Exception ex)
{
this.log.Warning(ex, "Failed to delete socket file on dispose: {Path}", this.SocketPath);
}
}
this.cts.Dispose();
this.log.Information("UnixRpcHost disposed ({Socket})", this.SocketPath);
GC.SuppressFinalize(this);
}
private async Task AcceptLoopAsync()
{
var token = this.cts.Token;
try
{
var endpoint = new UnixDomainSocketEndPoint(this.SocketPath);
this.listenSocket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified);
this.listenSocket.Bind(endpoint);
this.listenSocket.Listen(128);
while (!token.IsCancellationRequested)
{
Socket? clientSocket = null;
try
{
clientSocket = await this.listenSocket.AcceptAsync(token).ConfigureAwait(false);
var stream = new NetworkStream(clientSocket, ownsSocket: true);
var session = new RpcConnection(stream, this.registry);
this.sessions.TryAdd(session.Id, session);
this.log.Debug("RPC connection created: {Id}", session.Id);
_ = session.Completion.ContinueWith(t =>
{
this.sessions.TryRemove(session.Id, out _);
this.log.Debug("RPC connection removed: {Id}", session.Id);
}, TaskScheduler.Default);
}
catch (OperationCanceledException)
{
clientSocket?.Dispose();
break;
}
catch (Exception ex)
{
clientSocket?.Dispose();
this.log.Error(ex, "Error in socket accept loop");
await Task.Delay(500, token).ConfigureAwait(false);
}
}
}
catch (Exception ex)
{
this.log.Error(ex, "Fatal error in Unix socket accept loop");
}
}
}

2
Dalamud/Plugin/Services/IPluginLinkHandler.cs
View file

@ -1,6 +1,6 @@
using System.Diagnostics.CodeAnalysis;
using Dalamud.Networking.Pipes;
using Dalamud.Networking.Rpc.Model;
namespace Dalamud.Plugin.Services;