public ClientNetworkSocket(Socket socket, INetworkHandler handler) : base(socket, handler)
{
asyncOperationDic.Add(SocketAsyncOperation.Connect, ProcessConnect);
asyncOperationDic.Add(SocketAsyncOperation.Send, ProcessSend);
asyncOperationDic.Add(SocketAsyncOperation.Receive, ProcessReceive);
asyncOperationDic.Add(SocketAsyncOperation.Disconnect, ProcessDisconnect);
}
public void Setup()
{
_network = new Network();
_node1 = new Node
{
Id = 0,
LinkedNodesId = new SortedSet <uint>(),
MessageQueueHandlers = new List <MessageQueueHandler>(),
ReceivedMessages = new List <Message>(),
CanceledMessages = new List <Message>()
};
_node2 = new Node
{
Id = 1,
LinkedNodesId = new SortedSet <uint>(),
MessageQueueHandlers = new List <MessageQueueHandler>(),
ReceivedMessages = new List <Message>(),
CanceledMessages = new List <Message>()
};
_channel = new Channel
{
Id = Guid.Empty,
SecondNodeId = _node2.Id,
FirstNodeId = _node1.Id,
Price = AllConstants.AllPrices.ElementAt(0),
ChannelType = ChannelType.Ground,
ErrorChance = 0.6,
ConnectionType = ConnectionType.Duplex,
Capacity = 1
};
}
/// <summary>
/// Connect to remote server. This is a blocking
/// operation. Can be used for either Game or Lobby
/// servers, as long as appropriate token is provided.
/// </summary>
/// <param name="host">IP address of server.</param>
/// <param name="port">Port number of server.</param>
/// <param name="token">Token id for client.</param>
public static void Connect(
string host, int port, int token, INetworkHandler handler
)
{
InputHandler = handler;
// Init GameServer
Connection = new NetClient(
new NetPeerConfiguration(AppIdentifier)
);
Connection.Start();
// Begin connection
NetOutgoingMessage hailMessage = Connection.CreateMessage();
hailMessage.Write(token);
NetConnection connection = Connection.Connect(
host, port, hailMessage
);
// Wait for connection
try
{
WaitForConnection(connection);
}
catch (Exception e)
{
throw (e);
}
}
/// <inheritdoc />
public void RegisterNetworkHandler(INetworkHandler handler)
{
_log.Warn($"Plugin {handler.GetType().Assembly.FullName} registered a network handler. This system no longer works. Please alert the plugin author.");
return;
var handlerType = handler.GetType().FullName;
var toRemove = new List <INetworkHandler>();
foreach (var item in _networkHandlers)
{
if (item.GetType().FullName == handlerType)
{
//if (ExtenderOptions.IsDebugging)
_log.Error("Network handler already registered! " + handlerType);
toRemove.Add(item);
}
}
foreach (var oldHandler in toRemove)
{
_networkHandlers.Remove(oldHandler);
}
_networkHandlers.Add(handler);
}
public string GetFullResource(INetworkHandler networkHandler, IApiRequest request)
{
string fullurl = networkHandler.BuildUri(request);
string resource = fullurl.Replace(networkHandler.BaseUrl + "/", "");
return(networkHandler.BuildUri(request).Replace(networkHandler.BaseUrl + "/", ""));
}
private void ReadNetwork_OnClick(object sender, RoutedEventArgs e)
{
var filename = GetPathFromDialog();
try
{
_network = _networkInfoRetriever.Read(filename) as Network;
ReasignNetwork();
MessageBox.Show("File loaded!", "OK", MessageBoxButton.OK, MessageBoxImage.Information,
MessageBoxResult.OK,
MessageBoxOptions.None);
_headerUpdater?.Stop();
_headerUpdater = null;
_backgroundWorker?.Stop();
_backgroundWorker = null;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error,
MessageBoxResult.OK,
MessageBoxOptions.None);
}
}
public MessageHandler(INetworkHandler network, IMessageCreator generalMessageCreator,
IMessageCreator positiveResponseMessageCreator)
{
_network = network;
_generalMessageCreator = generalMessageCreator;
_positiveResponseMessageCreator = positiveResponseMessageCreator;
}
private void InitializeNetwork()
{
_network = new Network();
CreateNodes();
CreateChannels();
}
/// <summary>
/// Default Constructor
/// </summary>
public ApiRequestHandler(IApiResponseParserAsync <T> asyncParser, IApiResponseParser <T> parser, INetworkHandler networkHandler, bool ignoreCache = false)
{
ExceptionHelper.ThrowOnNull(parser, "parser");
ExceptionHelper.ThrowOnNull(networkHandler, "networkHandler");
Parser = parser;
AsyncParser = asyncParser;
IgnoreCache = ignoreCache;
Network = networkHandler;
}
public NetworkChannel(string name, INetworkHandler handler, INetworkEncoder encoder, INetworkDecoder decoder)
{
Name = name;
m_Handler = handler;
m_Encoder = encoder;
m_Decoder = decoder;
m_ReceiveBuffer.SetLength(m_ReceiveBuffer.Capacity);
}
/// <summary>
/// The top up.
/// </summary>
/// <param name="phoneNumber">
/// The phone number.
/// </param>
/// <param name="amount">
/// The amount.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public bool TopUp(string phoneNumber, int amount)
{
var networkMapper = new NetworkMapper();
this.NetworkHandler = networkMapper.GetNetworkHandler(phoneNumber);
var response = this.NetworkHandler.TopUp(phoneNumber, amount);
return(response.ResultCode == 200);
}
public INetworkChannel CreateChannel(string channelName, INetworkHandler handler, INetworkEncoder encoder, INetworkDecoder decoder)
{
if (HasChannel(channelName))
{
throw new DrbException("already exist channel '{0}'", channelName);
}
INetworkChannel channel = new NetworkChannel(channelName, handler, encoder, decoder);
m_ChannelDic[channelName] = channel;
return(channel);
}
public SpecifiedSizeMessageGenerator(INetworkHandler network, IMessageCreator messageCreator,
double messageGenerateChance, int messageSize)
: base(network, messageCreator, messageGenerateChance)
{
if (messageSize <= 0)
{
throw new ArgumentException("messageSize");
}
_messageSize = messageSize;
}
public MessageGenerator(INetworkHandler network, IMessageCreator messageCreator,
double messageGenerateChance)
{
if (messageGenerateChance > 1.0 || messageGenerateChance < 0.0)
{
throw new ArgumentException("messageGenerateChance");
}
_messageGenerateChance = messageGenerateChance;
Network = network;
_messageCreator = messageCreator;
}
private void CreateNewNetwork_OnClick(object sender, RoutedEventArgs e)
{
NetworkCreatorDialog.NetworkUpdateHandler networkUpdateHandler = network =>
{
_network = network;
ReasignNetwork();
};
var newNetworkwindow = new NetworkCreatorDialog(networkUpdateHandler);
newNetworkwindow.Show();
}
public IMcpeMessageHandler CreatePlayer(INetworkHandler session, PlayerInfo playerInfo)
{
Stopwatch timer = new Stopwatch();
timer.Start();
try
{
Log.Debug($"Proxy connecting to node on {_serverEndpoint}");
TcpClient client = new TcpClient() /*{NoDelay = true}*/;
client.NoDelay = true;
client.ReceiveBufferSize = client.ReceiveBufferSize * 10;
{
var endPoint = (IPEndPoint)_serverEndpoint;
client.Connect(endPoint);
Log.Debug("Connected to node, requesting new player");
var stream = client.GetStream();
BinaryWriter writer = new BinaryWriter(new BufferedStream(stream, client.SendBufferSize));;
BinaryReader reader = new BinaryReader(stream);
FtlCreatePlayer message = new FtlCreatePlayer();
message.username = playerInfo.Username;
message.clientuuid = playerInfo.ClientUuid;
message.serverAddress = playerInfo.ServerAddress;
message.clientId = playerInfo.ClientId;
message.skin = playerInfo.Skin;
var bytes = message.Encode();
writer.Write((byte)1);
writer.Write(bytes.Length);
writer.Write(bytes);
writer.Flush();
int port = reader.ReadInt32();
Log.Debug("Recieved port for node message handler " + port);
IMcpeMessageHandler handler = new ProxyMessageHandler(client, session);
return(handler);
}
}
catch (Exception e)
{
Log.Error($"Failed communication with node after {timer.ElapsedMilliseconds}ms", e);
}
return(null);
}
public virtual IMcpeMessageHandler CreatePlayer(INetworkHandler session, PlayerInfo playerInfo)
{
Player player = _server.PlayerFactory.CreatePlayer(_server, session.GetClientEndPoint());
player.NetworkHandler = session;
player.CertificateData = playerInfo.CertificateData;
player.Username = playerInfo.Username;
player.ClientUuid = playerInfo.ClientUuid;
player.ServerAddress = playerInfo.ServerAddress;
player.ClientId = playerInfo.ClientId;
player.Skin = playerInfo.Skin;
return player;
}
public virtual IMcpeMessageHandler CreatePlayer(INetworkHandler session, PlayerInfo playerInfo)
{
Player player = _server.PlayerFactory.CreatePlayer(_server, session.GetClientEndPoint());
player.NetworkHandler = session;
player.CertificateData = playerInfo.CertificateData;
player.Username = playerInfo.Username;
player.ClientUuid = playerInfo.ClientUuid;
player.ServerAddress = playerInfo.ServerAddress;
player.ClientId = playerInfo.ClientId;
player.Skin = playerInfo.Skin;
return(player);
}
public void Setup()
{
Mapper.Initialize(MapperInitializer.InitializeMapper);
_networkInfoRetriever = new NetworkInfoRetriever();
_network = new Network();
var nodes = new[]
{
new Node
{
Id = 0,
LinkedNodesId = new SortedSet <uint>(new uint[] { 1 }),
MessageQueueHandlers = new List <MessageQueueHandler>()
},
new Node
{
Id = 1,
LinkedNodesId = new SortedSet <uint>(new uint[] { 0 }),
MessageQueueHandlers = new List <MessageQueueHandler>()
}
};
foreach (var node in nodes)
{
_network.AddNode(node);
}
var channels = new[]
{
new Channel
{
Id = Guid.Empty,
ConnectionType = ConnectionType.Duplex,
ChannelType = ChannelType.Ground,
ErrorChance = 0.5,
SecondNodeId = 0,
FirstNodeId = 1,
Price = 20,
Capacity = 20,
}
};
foreach (var channel in channels)
{
_network.AddChannel(channel);
}
}
public MainWindow(INetworkHandler network, INetworkInfoRetriever networkInfoRetriever,
INetworkLocationMapRetriever networkLocationMapRetriever)
{
InitializeComponent();
InitializeFiltrationModeComboBox();
_network = network;
_networkInfoRetriever = networkInfoRetriever;
_networkLocationMapRetriever = networkLocationMapRetriever;
InitializeDrawers();
_channelAddWindow = new ChannelAddWindow(OnChannelAddEventHandler);
Loaded += OnWindowLoaded;
}
private void ParseNodes(JObject unparsedNetwork, INetworkHandler network)
{
foreach (var nodeInfo in unparsedNetwork["NodeIoDtos"])
{
var node = new Node
{
Id = (uint)nodeInfo["Id"],
LinkedNodesId = new SortedSet <uint>(),
MessageQueueHandlers = new List <MessageQueueHandler>(),
NodeType = (NodeType)(int)nodeInfo["NodeType"],
IsActive = true,
ReceivedMessages = new List <Message>(),
CanceledMessages = new List <Message>()
};
network.AddNode(node);
}
}
private void ConvertMetropolianNetworksToWideAreaNetwork(IEnumerable <INetworkHandler> metropolitanNetworks)
{
_network = new Network();
foreach (var metropolitanNetwork in metropolitanNetworks)
{
foreach (var node in metropolitanNetwork.Nodes)
{
node.NodeType = NodeType.SimpleNode;
_network.AddNode(node);
}
foreach (var channel in metropolitanNetwork.Channels)
{
_network.AddChannel(channel);
}
}
}
/// <summary>
/// Disconnects, and clears up resources used for the connection to the
/// game server. This is a blocking call.
/// </summary>
public static void Disconnect()
{
Connection.Shutdown("bye");
// Wait for disconnect
try
{
WaitForDisconnection();
}
catch (Exception e)
{
Trace.WriteLine("Exception in NetworkManager.Disconnect():");
Trace.WriteLine(e.ToString());
}
finally
{
Connection = null;
InputHandler = null;
}
}
private void ParseChannels(JObject unparsedNetwork, INetworkHandler network)
{
foreach (var channelInfo in unparsedNetwork["ChannelIoDtos"])
{
var channel = new Channel
{
Id = (Guid)channelInfo["Id"],
Price = (int)channelInfo["Price"],
ErrorChance = (double)channelInfo["ErrorChance"],
FirstNodeId = (uint)channelInfo["FirstNodeId"],
SecondNodeId = (uint)channelInfo["SecondNodeId"],
ConnectionType = (ConnectionType)(int)channelInfo["ConnectionType"],
ChannelType = (ChannelType)(int)channelInfo["ChannelType"],
IsBusy = false,
Capacity = (int)channelInfo["Capacity"]
};
network.AddChannel(channel);
}
}
/// <summary>
/// Create a new Minecraft Instance
/// </summary>
/// <param name="login">The username to use when connecting to Minecraft</param>
/// <param name="password">The password to use when connecting to Minecraft (Ignore if you are providing credentials)</param>
/// <param name="mode"></param>
/// <param name="nameVerification">To connect using Name Verification or not</param>
/// <param name="serverSalt"></param>
public IMinecraftClient Create(string login, string password, NetworkMode mode, bool nameVerification = false, string serverSalt = null)
{
ClientLogin = login;
ClientPassword = password;
UseLogin = nameVerification;
Mode = mode;
ServerSalt = serverSalt;
AsyncReceiveHandlers = new Dictionary <Type, Action <IAsyncReceive> >();
RegisterSupportedReceiveEvents();
World = new World();
Player = new Player();
Entities = new Dictionary <int, Entity>();
PlayersList = new Dictionary <string, short>();
_networkHandler = new NetworkHandler();
_networkHandler.Create(this);
return(this);
}
/// <inheritdoc />
public void RegisterNetworkHandler(INetworkHandler handler)
{
var handlerType = handler.GetType().FullName;
var toRemove = new List <INetworkHandler>();
foreach (var item in _networkHandlers)
{
if (item.GetType().FullName == handlerType)
{
//if (ExtenderOptions.IsDebugging)
_log.Error("Network handler already registered! " + handlerType);
toRemove.Add(item);
}
}
foreach (var oldHandler in toRemove)
{
_networkHandlers.Remove(oldHandler);
}
_networkHandlers.Add(handler);
}
public IMcpeMessageHandler CreatePlayer(INetworkHandler session, PlayerInfo playerInfo)
{
EssentialPlayer player = (EssentialPlayer)factory.CreatePlayer(_server, session.GetClientEndPoint(), playerInfo);
player.NetworkHandler = session;
player.CertificateData = playerInfo.CertificateData;
player.Username = playerInfo.Username;
player.ClientUuid = playerInfo.ClientUuid;
player.ServerAddress = playerInfo.ServerAddress;
player.ClientId = playerInfo.ClientId;
player.Skin = playerInfo.Skin;
player.PlayerInfo = playerInfo;
player.PlayerJoin += OnPlayerJoin;
player.PlayerLeave += OnPlayerLeave;
if (player.IsOp())
{
player.PermissionLevel = PermissionLevel.Operator;
}
else
{
player.PermissionLevel = PermissionLevel.Member;
}
return(player);
}
public TCPConnection(TCPManager iocp, Socket socket, INetworkHandler handler, Config.ConfigNet config)
{
m_config = config;
m_iocp = iocp;
m_networkHandler = handler;
m_socket = socket;
if (m_socket == null)
{
InitOutgoingSocket();
}
if (config.Encrypted)
{
m_encoding = new XRC4Cipher();
m_decoding = new XRC4Cipher();
}
else
{
m_encoding = new XCipher();
m_decoding = new XCipher();
}
m_encoding.SetKey("}h79q~B%al;k'y $E");
m_decoding.SetKey("}h79q~B%al;k'y $E");
m_readEventArgs = m_iocp.AcquireAsyncEvent();
m_readEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IO_Completed);
m_readEventArgs.UserToken = this;
m_writeEventArgs = m_iocp.AcquireAsyncEvent();
m_writeEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IO_Completed);
m_writeEventArgs.UserToken = this;
m_readEventArgs.AcceptSocket = m_socket;
m_writeEventArgs.AcceptSocket = m_socket;
}
public WideAreaNetworkService(INetworkHandler network)
{
_network = network;
}
public TCPListener(TCPManager iocp, INetworkHandler handler, Config.ConfigNet config)
{
m_iocp = iocp;
m_config = config;
m_networkHandler = handler;
}
public TCPConnection(TCPManager iocp, Socket socket, INetworkHandler handler, Config.ConfigNet config)
{
m_config = config;
m_iocp = iocp;
m_networkHandler = handler;
m_socket = socket;
if (m_socket == null)
{
InitOutgoingSocket();
}
if (config.Encrypted)
{
m_encoding = new XRC4Cipher();
m_decoding = new XRC4Cipher();
}
else
{
m_encoding = new XCipher();
m_decoding = new XCipher();
}
m_encoding.SetKey("}h79q~B%al;k'y $E");
m_decoding.SetKey("}h79q~B%al;k'y $E");
m_readEventArgs = m_iocp.AcquireAsyncEvent();
m_readEventArgs.Completed += new EventHandler<SocketAsyncEventArgs>(IO_Completed);
m_readEventArgs.UserToken = this;
m_writeEventArgs = m_iocp.AcquireAsyncEvent();
m_writeEventArgs.Completed += new EventHandler<SocketAsyncEventArgs>(IO_Completed);
m_writeEventArgs.UserToken = this;
m_readEventArgs.AcceptSocket = m_socket;
m_writeEventArgs.AcceptSocket = m_socket;
}
/// <summary>
/// Create a new Minecraft Instance
/// </summary>
/// <param name="login">The username to use when connecting to Minecraft</param>
/// <param name="password">The password to use when connecting to Minecraft (Ignore if you are providing credentials)</param>
/// <param name="mode"></param>
/// <param name="nameVerification">To connect using Name Verification or not</param>
/// <param name="serverSalt"></param>
public IMinecraftClient Create(string login, string password, NetworkMode mode, bool nameVerification = false, string serverSalt = null)
{
ClientLogin = login;
ClientPassword = password;
UseLogin = nameVerification;
Mode = mode;
ServerSalt = serverSalt;
AsyncReceiveHandlers = new Dictionary<Type, Action<IAsyncReceive>>();
RegisterSupportedReceiveEvents();
World = new World();
Player = new Player();
Entities = new Dictionary<int, Entity>();
PlayersList = new Dictionary<string, short>();
_networkHandler = new NetworkHandler();
_networkHandler.Create(this);
return this;
}
public int GetPing(string host, short port, int protocolVersion)
{
ServerHost = host;
ServerPort = port;
var pingPacketReceived = false;
_handler = new NetworkHandler(this);
_handler.OnPacketHandled += RaisePacketHandled;
_handler.Start();
#region Handle Early connect error
while (!Connected)
{
if (Crashed)
{
Dispose();
return int.MaxValue;
}
Thread.Sleep(250);
}
#endregion
#region Packet handlers
FireResponsePacket +=
packet => SendPacket(new PingPacket {Time = DateTime.UtcNow.Millisecond});
FirePingPacket += packet =>
{
pingPacketReceived = true;
};
#endregion
RequestServerInfo(protocolVersion);
#region Waiting for all packets handling and handling if something went wrong
while (!pingPacketReceived)
{
if (_handler != null && Connected)
{
Dispose();
return int.MaxValue;
}
Thread.Sleep(50);
}
#endregion
var ping = PingServer(host, port);
Dispose();
return (int) ping;
}
public ServerInfo GetServerInfo(string host, short port, int protocolVersion)
{
ServerHost = host;
ServerPort = port;
var responsePacketReceived = false;
var info = new ServerInfo();
_handler = new NetworkHandler(this);
_handler.OnPacketHandled += RaisePacketHandled;
_handler.Start();
#region Handle Early connect error
while (!Connected)
{
if (Crashed)
{
Dispose();
return new ServerInfo();
}
Thread.Sleep(250);
}
#endregion
#region Packet handlers
FireResponsePacket += delegate(IPacket packet)
{
info = ParseResponse(packet);
responsePacketReceived = true;
};
#endregion
RequestServerInfo(protocolVersion);
#region Waiting for all packets handling and handling if something went wrong
var watch = Stopwatch.StartNew();
while (!responsePacketReceived)
{
if (_handler != null && _handler.Crashed)
{
Dispose();
return new ServerInfo();
}
if (watch.ElapsedMilliseconds > 2000)
{
watch.Stop();
Dispose();
return new ServerInfo {Version = new Version {Name = "Unsupported", Protocol = 0}};
}
Thread.Sleep(50);
}
watch.Stop();
#endregion
Dispose();
return info;
}
public ResponseData GetResponseData(string host, short port, int protocolVersion)
{
ServerHost = host;
ServerPort = port;
var pingPacketReceived = false;
var info = new ServerInfo();
_handler = new NetworkHandler(this);
_handler.OnPacketHandled += RaisePacketHandled;
_handler.Start();
#region Handle Early connect error
while (!Connected)
{
if (Crashed)
{
Dispose();
return new ResponseData {Info = new ServerInfo(), Ping = int.MaxValue};
}
Thread.Sleep(250);
}
#endregion
#region Packet handlers
FireResponsePacket += packet =>
{
// Send Ping Packet after receiving Response Packet
SendPacket(new PingPacket {Time = DateTime.UtcNow.Millisecond});
info = ParseResponse(packet);
};
FirePingPacket += packet =>
{
pingPacketReceived = true;
};
#endregion
RequestServerInfo(protocolVersion);
#region Waiting for all packets handling and handling if something went wrong
var watch = Stopwatch.StartNew();
while (!pingPacketReceived)
{
if (_handler == null || _handler.Crashed)
{
watch.Stop();
Dispose();
return new ResponseData {Info = new ServerInfo(), Ping = int.MaxValue};
}
if (watch.ElapsedMilliseconds > 2000)
{
watch.Stop();
Dispose();
return new ResponseData
{
Info = new ServerInfo {Version = new Version {Name = "Unsupported", Protocol = 0}},
Ping = (int) PingServer(host, port)
};
}
Thread.Sleep(50);
}
watch.Stop();
#endregion
var ping = PingServer(host, port);
Dispose();
return new ResponseData {Info = info, Ping = (int) ping};
}
/// <inheritdoc />
public bool UnregisterNetworkHandler(INetworkHandler handler)
{
return(_networkHandlers.Remove(handler));
}
public CubeProtocol(string host, int port, int protocol, INetworkHandler handler) : base(new SocketWrapper(host, port), protocol)
{
this.host = host;
this.port = port;
this.handler = handler;
}
static Gw2StatsApi()
{
Network = new NetworkHandler(Language.None, Constants.gw2_ApiBaseUrl);
}
