public DistrictHandler(SocketRequestHandler handler) :
base(handler, "District")
{
server.dailyCallbacks.Register(Update);
handler.RegisterMessageHandler("District", OnDistrictMessage);
SendAll();
}
public InstancesHandler(SocketRequestHandler handler) :
base(handler, "Instances")
{
server.dailyCallbacks.Register(Update);
handler.RegisterMessageHandler("Instances", OnClientMessage);
SendAll();
}
public CityInfoHandler(SocketRequestHandler handler) :
base(handler, "CityInfo")
{
server.dailyCallbacks.Register(Update);
server.unlockAreaCallbacks.Register(OnAreaUnlocked);
SendInitialInfo();
}
public BudgetHandler(SocketRequestHandler handler) :
base(handler, "Budget")
{
economyManager = EconomyManager.instance;
server.dailyCallbacks.Register(Update);
SendAll();
handler.RegisterMessageHandler("Budget", OnClientMessage);
}
public CameraHandler(SocketRequestHandler handler) :
base(handler, "Camera")
{
totalTimeDelta = 0;
updateInterval = 0; //seconds (0=disable)
server.frameCallbacks.Register(Update);
handler.RegisterMessageHandler("Camera", OnCameraMessage);
}
public SocketResponder (IPEndPoint ep, SocketRequestHandler rh)
{
requestHandler = rh;
tcpListener = new TcpListener (ep);
tcpListener.Start ();
listenTask = Task.Run (Listen);
}
public SocketResponder(IPEndPoint ep, SocketRequestHandler rh)
{
requestHandler = rh;
tcpListener = new TcpListener(ep);
tcpListener.Start();
listenTask = Task.Run(Listen);
}
public ChirperHandler(SocketRequestHandler handler) :
base(handler, "Chirper")
{
Log("ChirperHandler created");
//Since we aren't inheriting IUserMod, we have to manually
//add our methods to the MessageManager.
messageManager = Singleton <MessageManager> .instance;
messageManager.m_messagesUpdated += OnMessagesUpdated;
messageManager.m_newMessages += OnNewMessage;
messages = new List <ChirperMessage>();
OnMessagesUpdated(); //Ensure new client gets recent messages
//XXX get them from another handler so they have correct times.
}
private static void StartListening(object state)
{
while (true)
{
AcceptSocketToken acceptSocketToken = new AcceptSocketToken()
{
Event = new AutoResetEvent(false)
};
IAsyncResult result = _serverSocket.BeginAccept(CallbackAccept, acceptSocketToken);
result.AsyncWaitHandle.WaitOne();
acceptSocketToken.Event.WaitOne();
// got socket, give it to request handler
if (acceptSocketToken.Socket != null)
{
SocketRequestHandler requestHandler = new SocketRequestHandler(acceptSocketToken.Socket, Logger);
ThreadPool.QueueUserWorkItem(requestHandler.HandleConnection);
}
}
}
public SubscribeHub(IStreamClientManager mqttClientManager, SocketRequestHandler socketRequestHandler)
{
this.mqttClientManager = mqttClientManager;
this.socketRequestHandler = socketRequestHandler;
}
public SocketHandlerBase(SocketRequestHandler handler, string name)
{
this.handler = handler;
this.server = handler.Server as WebServer;
this.Name = name;
}
// Starts listening on IPAddress.Loopback on a system-assigned port.
// Returns the resulting IPEndPoint (which contains the assigned port).
public SocketResponder(out IPEndPoint ep, SocketRequestHandler rh)
: this(new IPEndPoint(IPAddress.Loopback, 0), rh)
{
ep = (IPEndPoint)tcpListener.LocalEndpoint;
}
public FlagsHandler(SocketRequestHandler handler) :
base(handler, "Flags")
{
Update();
}
public SocketResponder (IPEndPoint localEP, SocketRequestHandler requestHandler)
{
_localEndPoint = localEP;
_requestHandler = requestHandler;
}
public LimitsHandler(SocketRequestHandler handler) :
base(handler, "Limits")
{
Update();
}
public TransportHandler(SocketRequestHandler handler) :
base(handler, "Transport")
{
handler.RegisterMessageHandler("Transport", OnClientMessage);
}
public VehicleHandler(SocketRequestHandler handler) :
base(handler, "Vehicle")
{
handler.RegisterMessageHandler("Vehicle", OnClientMessage);
}
public RequestProcessor (Socket socket, SocketRequestHandler handler)
{
_socket = socket;
_handler = handler;
}
public DebugHandler(SocketRequestHandler handler) :
base(handler, "Debug")
{
server.dailyCallbacks.Register(Update);
}
public ReflectionHandler(SocketRequestHandler handler) :
base(handler, "Reflection")
{
handler.RegisterMessageHandler("Reflection", OnClientMessage);
}
public BuildingHandler(SocketRequestHandler handler) :
base(handler, "Building")
{
//SendAll();
handler.RegisterMessageHandler("Building", OnClientMessage);
}
public TerrainHandler(SocketRequestHandler handler) :
base(handler, "Terrain")
{
server.terrainCallbacks.Register(Update);
}
public CitizenHandler(SocketRequestHandler handler) :
base(handler, "Citizen")
{
handler.RegisterMessageHandler("Citizen", OnClientMessage);
}
public SocketResponder(IPEndPoint localEP, SocketRequestHandler requestHandler)
{
_localEndPoint = localEP;
_requestHandler = requestHandler;
}
private void AcceptClient(TcpClient tcp)
{
string ip = tcp.Client.RemoteEndPoint.ToString().Split(':')[0];
//check firewall
if (Firewall != null && Firewall.Enabled && !Firewall.EntryAuthority(ip))
{
tcp.Close();
return;
}
HttpResponse response = new HttpResponse();
//ssl handshaking
if (Options.UseSecureConnection)
{
SslStream sslStream = new SslStream(tcp.GetStream(), true);
response.Stream = sslStream;
try
{
sslStream.AuthenticateAsServer(Certificate, false, true);
}
catch
{
tcp.Close();
return;
}
}
else
{
response.Stream = tcp.GetStream();
}
//create request
string request_data = ReadRequest(response.Stream);
if (request_data == null)
{
tcp.Close();
return;
}
RequestReader reader = new RequestReader();
HttpRequest request = reader.Read(request_data);
request.IpAddress = ip;
request.IsSecureConnection = Options.UseSecureConnection;
if (!string.IsNullOrEmpty(request.AcceptEncoding) && request.AcceptEncoding.Contains("gzip"))
{
response.ApplyGzip = true;
}
//handle request
if (request.IsWebSocket)
{
ServerSocket client = SocketRequestHandler.HandshakeClient(this, request, tcp);
client.Start();
}
else
{
if (RequestHandler == null)
{
tcp.Close();
return;
}
RequestHandler.Request(this, request, response);
ResponseWriter writer = new ResponseWriter();
writer.Write(response);
tcp.Close();
}
}
