1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
using Ryujinx.Horizon.Common;
using Ryujinx.Horizon.Sdk.OsTypes;
using Ryujinx.Horizon.Sdk.Sf;
using Ryujinx.Horizon.Sdk.Sm;
namespace Ryujinx.Horizon.Sm.Impl
{
class ServiceManager
{
private const int MaxServicesCount = 256;
private readonly ServiceInfo[] _services;
public ServiceManager()
{
_services = new ServiceInfo[MaxServicesCount];
}
public Result GetService(out int handle, ulong processId, ServiceName name)
{
handle = 0;
Result result = ValidateServiceName(name);
if (result.IsFailure)
{
return result;
}
// TODO: Validation with GetProcessInfo etc.
int serviceIndex = GetServiceInfo(name);
if (serviceIndex < 0)
{
return SfResult.RequestDeferredByUser;
}
result = GetServiceImpl(out handle, ref _services[serviceIndex]);
return result == KernelResult.SessionCountExceeded ? SmResult.OutOfSessions : result;
}
private static Result GetServiceImpl(out int handle, ref ServiceInfo serviceInfo)
{
return HorizonStatic.Syscall.ConnectToPort(out handle, serviceInfo.PortHandle);
}
public Result RegisterService(out int handle, ulong processId, ServiceName name, int maxSessions, bool isLight)
{
handle = 0;
Result result = ValidateServiceName(name);
if (result.IsFailure)
{
return result;
}
// TODO: Validation with GetProcessInfo etc.
return HasServiceInfo(name) ? SmResult.AlreadyRegistered : RegisterServiceImpl(out handle, processId, name, maxSessions, isLight);
}
public Result RegisterServiceForSelf(out int handle, ServiceName name, int maxSessions)
{
return RegisterServiceImpl(out handle, Os.GetCurrentProcessId(), name, maxSessions, false);
}
private Result RegisterServiceImpl(out int handle, ulong processId, ServiceName name, int maxSessions, bool isLight)
{
handle = 0;
Result result = ValidateServiceName(name);
if (!result.IsSuccess)
{
return result;
}
if (HasServiceInfo(name))
{
return SmResult.AlreadyRegistered;
}
int freeServiceIndex = GetFreeService();
if (freeServiceIndex < 0)
{
return SmResult.OutOfServices;
}
ref ServiceInfo freeService = ref _services[freeServiceIndex];
result = HorizonStatic.Syscall.CreatePort(out handle, out int clientPort, maxSessions, isLight, null);
if (!result.IsSuccess)
{
return result;
}
freeService.PortHandle = clientPort;
freeService.Name = name;
freeService.OwnerProcessId = processId;
return Result.Success;
}
public Result UnregisterService(ulong processId, ServiceName name)
{
Result result = ValidateServiceName(name);
if (result.IsFailure)
{
return result;
}
// TODO: Validation with GetProcessInfo etc.
int serviceIndex = GetServiceInfo(name);
if (serviceIndex < 0)
{
return SmResult.NotRegistered;
}
ref var serviceInfo = ref _services[serviceIndex];
if (serviceInfo.OwnerProcessId != processId)
{
return SmResult.NotAllowed;
}
serviceInfo.Free();
return Result.Success;
}
private static Result ValidateServiceName(ServiceName name)
{
if (name[0] == 0)
{
return SmResult.InvalidServiceName;
}
int nameLength = 1;
for (; nameLength < ServiceName.Length; nameLength++)
{
if (name[nameLength] == 0)
{
break;
}
}
while (nameLength < ServiceName.Length)
{
if (name[nameLength++] != 0)
{
return SmResult.InvalidServiceName;
}
}
return Result.Success;
}
private bool HasServiceInfo(ServiceName name)
{
return GetServiceInfo(name) != -1;
}
private int GetFreeService()
{
return GetServiceInfo(ServiceName.Invalid);
}
private int GetServiceInfo(ServiceName name)
{
for (int index = 0; index < MaxServicesCount; index++)
{
if (_services[index].Name == name)
{
return index;
}
}
return -1;
}
}
}
|
