ServerPluginChannels.java
8.29 KB
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
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
package com.mumfrey.liteloader.core;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.network.INetHandler;
import net.minecraft.network.NetHandlerPlayServer;
import net.minecraft.network.PacketBuffer;
import net.minecraft.network.play.client.C17PacketCustomPayload;
import net.minecraft.network.play.server.S3FPacketCustomPayload;
import com.mumfrey.liteloader.ServerPluginChannelListener;
import com.mumfrey.liteloader.api.Listener;
import com.mumfrey.liteloader.core.event.HandlerList;
import com.mumfrey.liteloader.core.exceptions.UnregisteredChannelException;
import com.mumfrey.liteloader.interfaces.FastIterableDeque;
import com.mumfrey.liteloader.permissions.PermissionsManagerServer;
import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
/**
* Handler for server plugin channels
*
* @author Adam Mummery-Smith
*/
public class ServerPluginChannels extends PluginChannels<ServerPluginChannelListener>
{
private static ServerPluginChannels instance;
public ServerPluginChannels()
{
if (ServerPluginChannels.instance != null)
{
InstantiationException inner = new InstantiationException("Only a single instance of ServerPluginChannels is allowed");
throw new RuntimeException("Plugin Channels Startup Error", inner);
}
ServerPluginChannels.instance = this;
}
@Override
protected FastIterableDeque<ServerPluginChannelListener> createHandlerList()
{
return new HandlerList<ServerPluginChannelListener>(ServerPluginChannelListener.class);
}
public static ServerPluginChannels getInstance()
{
return instance;
}
/* (non-Javadoc)
* @see com.mumfrey.liteloader.api.InterfaceProvider#initProvider()
*/
@Override
public void initProvider()
{
}
/* (non-Javadoc)
* @see com.mumfrey.liteloader.api.InterfaceProvider#getListenerBaseType()
*/
@Override
public Class<? extends Listener> getListenerBaseType()
{
return Listener.class;
}
/* (non-Javadoc)
* @see com.mumfrey.liteloader.api.InterfaceProvider#registerInterfaces(
* com.mumfrey.liteloader.core.InterfaceRegistrationDelegate)
*/
@Override
public void registerInterfaces(InterfaceRegistrationDelegate delegate)
{
delegate.registerInterface(ServerPluginChannelListener.class);
}
void addServerPluginChannelListener(ServerPluginChannelListener pluginChannelListener)
{
super.addPluginChannelListener(pluginChannelListener);
}
void onServerStartup()
{
this.clearPluginChannels(null);
// Enumerate mods for plugin channels
for (ServerPluginChannelListener pluginChannelListener : this.pluginChannelListeners)
{
this.addPluginChannelsFor(pluginChannelListener);
}
}
void onPlayerJoined(EntityPlayerMP player)
{
this.sendRegisteredPluginChannels(player);
}
/**
* Callback for the plugin channel hook
*
* @param netHandler
* @param customPayload
*/
public void onPluginChannelMessage(INetHandler netHandler, C17PacketCustomPayload customPayload)
{
if (customPayload != null && customPayload.getChannelName() != null)
{
String channel = customPayload.getChannelName();
PacketBuffer data = customPayload.getBufferData();
EntityPlayerMP sender = ((NetHandlerPlayServer)netHandler).playerEntity;
this.onPluginChannelMessage(sender, channel, data);
}
}
/**
* @param channel
* @param data
*/
private final void onPluginChannelMessage(EntityPlayerMP sender, String channel, PacketBuffer data)
{
if (PluginChannels.CHANNEL_REGISTER.equals(channel))
{
this.onRegisterPacketReceived(data);
}
else if (this.pluginChannels.containsKey(channel))
{
try
{
PermissionsManagerServer permissionsManager = LiteLoader.getServerPermissionsManager();
if (permissionsManager != null)
{
permissionsManager.onCustomPayload(sender, channel, data);
}
}
catch (Exception ex) {}
this.onModPacketReceived(sender, channel, data);
}
}
/**
* @param sender
* @param channel
* @param data
*/
protected void onModPacketReceived(EntityPlayerMP sender, String channel, PacketBuffer data)
{
for (ServerPluginChannelListener pluginChannelListener : this.pluginChannels.get(channel))
{
try
{
pluginChannelListener.onCustomPayload(sender, channel, data);
throw new RuntimeException();
}
catch (Exception ex)
{
int failCount = 1;
if (this.faultingPluginChannelListeners.containsKey(pluginChannelListener))
{
failCount = this.faultingPluginChannelListeners.get(pluginChannelListener).intValue() + 1;
}
if (failCount >= PluginChannels.WARN_FAULT_THRESHOLD)
{
LiteLoaderLogger.warning("Plugin channel listener %s exceeded fault threshold on channel %s with %s",
pluginChannelListener.getName(), channel, ex.getClass().getSimpleName());
this.faultingPluginChannelListeners.remove(pluginChannelListener);
}
else
{
this.faultingPluginChannelListeners.put(pluginChannelListener, Integer.valueOf(failCount));
}
}
}
}
protected void sendRegisteredPluginChannels(EntityPlayerMP player)
{
try
{
PacketBuffer registrationData = this.getRegistrationData();
if (registrationData != null)
{
this.sendRegistrationData(player, registrationData);
}
}
catch (Exception ex)
{
LiteLoaderLogger.warning(ex, "Error dispatching REGISTER packet to client %s", player.getDisplayName());
}
}
/**
* @param recipient
* @param registrationData
*/
private void sendRegistrationData(EntityPlayerMP recipient, PacketBuffer registrationData)
{
ServerPluginChannels.dispatch(recipient, new S3FPacketCustomPayload(CHANNEL_REGISTER, registrationData));
}
/**
* Send a message to the specified client on a plugin channel
*
* @param recipient
* @param channel Channel to send, must not be a reserved channel name
* @param data
*/
public static boolean sendMessage(EntityPlayerMP recipient, String channel, PacketBuffer data, ChannelPolicy policy)
{
if (ServerPluginChannels.instance != null)
{
return ServerPluginChannels.instance.send(recipient, channel, data, policy);
}
return false;
}
/**
* Send a message to the specified client on a plugin channel
*
* @param recipient Recipient to send to
* @param channel Channel to send, must not be a reserved channel name
* @param data
*/
private boolean send(EntityPlayerMP recipient, String channel, PacketBuffer data, ChannelPolicy policy)
{
if (recipient == null) return false;
if (channel == null || channel.length() > 16 || CHANNEL_REGISTER.equals(channel) || CHANNEL_UNREGISTER.equals(channel))
{
throw new RuntimeException("Invalid channel name specified");
}
if (!policy.allows(this, channel))
{
if (policy.isSilent()) return false;
throw new UnregisteredChannelException(channel);
}
S3FPacketCustomPayload payload = new S3FPacketCustomPayload(channel, data);
return ServerPluginChannels.dispatch(recipient, payload);
}
/**
* @param recipient
* @param payload
*/
static boolean dispatch(EntityPlayerMP recipient, S3FPacketCustomPayload payload)
{
try
{
if (recipient != null && recipient.playerNetServerHandler != null)
{
recipient.playerNetServerHandler.sendPacket(payload);
return true;
}
}
catch (Exception ex) {}
return false;
}
}