public Pong(uint time, Socket socket)
{
OutgoingPacket packet = new OutgoingPacket(OpCodes.PONG);
packet.Write(time);
packet.Send(socket);
}
public SessionKey(int sessionKey, Socket socket)
{
OutgoingPacket packet = new OutgoingPacket(OpCodes.SESSION_KEY);
packet.Write(sessionKey);
packet.Send(socket);
}
public void SendPacket(OutgoingPacket op)
{
if (netClient != null)
{
netClient.SendPacket(op);
}
}
public LoginFail(uint errorCode, Socket socket)
{
OutgoingPacket packet = new OutgoingPacket(OpCodes.LOGIN_MESSAGE);
packet.Write(errorCode);
packet.Send(socket);
}
public void SendToAll(OutgoingPacket outgoing)
{
foreach (GameConnection connection in this.Players.Values)
{
connection.SendPacket(outgoing);
}
}
public static void WritePkgOut(OutgoingPacket packet)
{
if (packet.PacketType == PacketType.Ping || packet.PacketType == PacketType.Pong)
{
return;
}
WriteType("[O]");
switch (packet.PacketType)
{
case PacketType.Init1:
Console.Write("InitID: ");
Write(packet.Data[4].ToString(), ConsoleColor.Magenta);
break;
case PacketType.Ack:
case PacketType.AckLow:
Console.Write("Acking: ");
Write(NetUtil.N2Hushort(packet.Data, 0).ToString(), ConsoleColor.Magenta);
break;
default:
Console.Write(packet);
break;
}
Console.WriteLine();
}
/// <summary>
/// A WebSocket implementation of the packet sending.
/// </summary>
public void Send(OutgoingPacket packet)
{
if (State == TransportStates.Closed ||
State == TransportStates.Paused)
{
HTTPManager.Logger.Information("WebSocketTransport", string.Format("Send - State == {0}, skipping packet sending!", State), this.Manager.Context);
return;
}
if (packet.IsBinary)
{
Implementation.Send(packet.PayloadData.Data, (ulong)packet.PayloadData.Offset, (ulong)packet.PayloadData.Count);
}
else
{
Implementation.Send(packet.Payload);
}
if (packet.Attachements != null)
{
for (int i = 0; i < packet.Attachements.Count; ++i)
{
Implementation.Send(packet.Attachements[i]);
}
}
}
private bool ENETServerQueueInternal(int connectionId, int channelId, ArraySegment <byte> data)
{
if (!ServerStarted)
{
Debug.LogError("Attempted to send while the server was not active");
return(false);
}
if (channelId > Channels.Length)
{
Debug.LogWarning($"Ignorance: Attempted to send data on channel {channelId} when we only have {Channels.Length} channels defined");
return(false);
}
OutgoingPacket op = default;
op.connectionId = connectionId;
op.channelId = (byte)channelId;
Packet dataPayload = default;
dataPayload.Create(data.Array, data.Offset, data.Count + data.Offset, (PacketFlags)Channels[channelId]);
op.payload = dataPayload;
MirrorServerOutgoingQueue.Enqueue(op);
return(true);
}
public ServerIp(string ipAddress, Socket socket)
{
OutgoingPacket packet = new OutgoingPacket(OpCodes.SERVER_IP);
packet.Write(ipAddress);
packet.Send(socket);
}
public byte[] GetBytes(Revision revision)
{
byte[] bytes = null;
if (!this.Bytes.TryGetValue(revision, out bytes))
{
OutgoingPacket packet_ = null;
if (BasicUtilies.GetRevisionPacketManager(revision).HandleOutgoing(this.Packet, out packet_))
{
ServerMessage message = packet_.Handle(this.ValueHolder);
if (message == null || message is EmptyServerMessage)
{
bytes = null;
}
else
{
bytes = message.GetBytes();
}
}
else
{
throw new Exception("Unable to find packet id: " + this.Packet + ", from: " + revision);
}
this.Bytes.Add(revision, bytes);
}
return(bytes);
}
public void SendPacket(OutgoingPacket packet)
{
if (!_socket.Connected)
{
return;
}
MemoryStream ms = new MemoryStream();
using (PacketOutput output = new PacketOutput(ms))
{
output.Write(0);
output.Write(packet.GetPacketType().ToId());
packet.Write(output);
}
byte[] buffer = ms.ToArray();
_outgoingEncryption.Cipher(buffer, 5);
int size = buffer.Length;
byte[] a = BitConverter.GetBytes(IPAddress.NetworkToHostOrder(size));
buffer[0] = a[0];
buffer[1] = a[1];
buffer[2] = a[2];
buffer[3] = a[3];
_socket?.Send(buffer);
}
private void SendPacket(IPEndPoint endpoint, int packetID, OutgoingPacket packet)
{
byte[] payload = packet.GetBytes();
byte[] datagram = new byte[payload.Length + 4];
Array.Copy(payload, 0, datagram, 4, payload.Length);
Array.Copy(BitConverter.GetBytes(packetID), 0, datagram, 0, 4);
this._socket.BeginSend(datagram, datagram.Length, endpoint, this.SendCallback, null);
}
public override void SendPacket(object baseConnection, int packetID, OutgoingPacket packet)
{
while (this._senderReceiver == null)
{
;
}
this._senderReceiver.SendPacket(packetID, packet);
}
public override void SendPacket(int packetID, OutgoingPacket packet)
{
var message = this._lidgrenClient.CreateMessage();
message.Write(packetID);
message.Write(packet.GetBytes());
this._lidgrenClient.SendMessage(message, this._method);
}
public QueryTickCount(uint time, Socket socket)
{
OutgoingPacket packet = new OutgoingPacket(OpCodes.QUERY_TICK_COUNT);
packet.Write(time);
packet.Write((uint)DateTime.Now.Ticks);
packet.Send(socket);
}
public override bool ServerDisconnect(int connectionId)
{
OutgoingPacket op = default;
op.connectionId = connectionId;
op.commandType = CommandPacketType.BootToTheFace;
return(true);
}
public CharacterList(uint authKey, Dictionary <CharacterSlot, Character> characters, Socket socket)
{
// not finished
OutgoingPacket packet = new OutgoingPacket(OpCodes.CHARACTER_LIST);
packet.Write(authKey); // authkey
packet.Write(characters.Keys.Count); // character count
// if > 0 characters
if (characters.Keys.Count > 0)
{
foreach (KeyValuePair <CharacterSlot, Character> character in characters)
{
packet.Write(character.Key.SlotId);
packet.Write(2); // Character block
packet.Write(character.Value.Map);
packet.Write(0x0B); // Index? 0x0B?
packet.Write(character.Value.Name);
packet.Write(character.Value.Position.X);
packet.Write(character.Value.Position.Y);
packet.Write(character.Value.Position.Z);
packet.Write(character.Value.CharacterId);
packet.Write(0); // ID Party
packet.Write(0); // ID Guild
packet.Write(0); // ID War
packet.Write(character.Value.Skinset);
packet.Write(character.Value.HairStyle);
packet.Write(character.Value.HairColor);
packet.Write(character.Value.HeadMesh);
packet.Write(character.Value.Gender);
packet.Write(character.Value.ClassId);
packet.Write(character.Value.Level);
packet.Write(0); // Job level
packet.Write(character.Value.Strength);
packet.Write(character.Value.Stamina);
packet.Write(character.Value.Dexterity);
packet.Write(character.Value.Intelligence);
packet.Write(0); // Mode
packet.Write(0); // equipcount
// for each item
if (false)
{
packet.Write(0); // itemid
}
}
}
packet.Write(0); // countmessenger
// for each in countmessenger
if (false)
{
packet.Write(0); // slot? (byte)
}
packet.Send(socket);
}
public override bool ServerDisconnect(int connectionId)
{
OutgoingPacket op = default;
op.connectionId = connectionId;
op.commandType = CommandPacketType.ServerWantsToDisconnectClient;
MirrorServerOutgoingQueue.Enqueue(op);
return(true);
}
public AuthQuery(int value1, int value2, int value3, int value4, Socket socket)
{
OutgoingPacket packet = new OutgoingPacket(OpCodes.PONG);
packet.Write(value1);
packet.Write(value2);
packet.Write(value3);
packet.Write(value4);
packet.Send(socket);
}
public void SendPacket(OutgoingPacket packet)
{
if (!Disposed)
{
NetworkProccessor.ProcessPacket(new NPacket()
{
Packet = packet,
OnPacketProcessed = onPacketProcessed
});
}
}
private protected override void SendPacket(T client, int packetID, OutgoingPacket packet)
{
var connection = client.BaseConnection as NetConnection;
Debug.Assert(connection != null, $"Client was null");
var message = this._lidgrenServer.CreateMessage();
message.Write(packetID);
message.Write(packet.GetBytes());
this._lidgrenServer.SendMessage(message, connection, this._method);
}
public void Send(OutgoingPacket packet)
{
var headerLength = packet.HeaderLength;
var length = packet.Length;
var totalLength = headerLength + length;
// Insert the header.
var bytes = new byte[totalLength];
_propagator.WriteHeader(packet, bytes);
// Insert the payload.
packet.Position = 0;
packet.BaseStream.Read(bytes, headerLength, length);
// Encrypt if some sort of encryption scheme has been set.
if (Crypt != null)
{
Crypt.Encrypt(bytes, 0, headerLength);
}
var args = SocketAsyncEventArgsPool.Acquire();
args.SetBuffer(bytes, 0, totalLength);
args.Completed += OnSend;
try
{
if (!_socket.SendAsync(args))
{
OnSend(this, args);
}
}
catch (Exception ex)
{
args.Completed -= OnSend;
SocketAsyncEventArgsPool.Release(args);
Disconnect();
if (ex is ObjectDisposedException)
{
return;
}
if (ex is SocketException)
{
ExceptionManager.RegisterException(ex);
return;
}
throw;
}
}
public void Send(OutgoingPacket packet)
{
try
{
lonelyPacketList.Add(packet);
Send(lonelyPacketList);
}
finally
{
lonelyPacketList.Clear();
}
}
public void SendPacket(int packetIDNumber, OutgoingPacket outgoingPacket)
{
var packetPayload = outgoingPacket.GetBytes();
var packetID = BitConverter.GetBytes(packetIDNumber);
var packetSize = BitConverter.GetBytes(packetPayload.Length + packetID.Length);
var fullPacket = new byte[packetSize.Length + packetID.Length + packetPayload.Length];
Array.Copy(packetSize, 0, fullPacket, 0, packetSize.Length);
Array.Copy(packetID, 0, fullPacket, packetSize.Length, packetID.Length);
Array.Copy(packetPayload, 0, fullPacket, packetID.Length + packetSize.Length, packetPayload.Length);
this._socket.BeginSend(fullPacket, 0, fullPacket.Length, SocketFlags.None, SendCallback, null);
}
public override bool HandleOutgoing(OutgoingPacketsEnum id, out OutgoingPacket packet)
{
if (this.OutgoingPackets.ContainsKey(id))
{
packet = this.OutgoingPackets[id];
return(true);
}
else
{
packet = null;
return(false);
}
}
public override void SendPacket(OutgoingPacket packet)
{
byte[] data = packet.GetBytes();
byte[] data_ = new byte[data.Length + 2];
data_[0] = (byte)data.Length;
data_[1] = (byte)(data.Length >> 8);
for (int i = 0; i < data.Length; i++)
{
data_[i + 2] = data[i];
}
this.SendData(data_);
}
public void SendPacket(OutgoingPacket packet, Action <bool> completed = null)
{
byte[] data = packet.GetBytes();
byte[] data_ = new byte[data.Length + 2];
data_[0] = (byte)data.Length;
data_[1] = (byte)(data.Length >> 8);
for (int i = 0; i < data.Length; i++)
{
data_[i + 2] = data[i];
}
this.SendData(data_, completed);
}
private static void Authenticate()
{
//SaveData authData = SaveManager.GetActiveSave();
SaveData authData = SaveManager.GetSave(0);
OutgoingPacket authPacket = new OutgoingPacket(authData);
using (MemoryStream memoryStream = new MemoryStream())
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(memoryStream, authPacket);
byte[] serializedData = memoryStream.ToArray();
client.Send(serializedData, serializedData.Length);
}
}
private static void EmptyOutgoingStack()
{
while (packetStack.Count != 0)
{
OutgoingPacket outgoingPacket = packetStack.Dequeue();
using (MemoryStream memoryStream = new MemoryStream())
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(memoryStream, outgoingPacket);
byte[] serializedData = memoryStream.ToArray();
client.Send(serializedData, serializedData.Length);
}
}
}
public CharacterList(uint TimeGetTime, Socket socket)
{
// not finished
OutgoingPacket packet = new OutgoingPacket(OpCodes.CHARACTER_LIST);
packet.Write(TimeGetTime);
// if 0 characters
packet.Write(0);
packet.Write(0);
packet.Send(socket);
// if >0 characters
}
private void OutgoingPacketHandler()
{
OutgoingPacket outgoingPacket = new OutgoingPacket();
Simulator simulator = null;
Packet packet = null;
int now;
int lastPacketTime = Environment.TickCount;
while (connected)
{
if (PacketOutbox.Dequeue(100, ref outgoingPacket))
{
simulator = outgoingPacket.Simulator;
packet = outgoingPacket.Packet;
// Very primitive rate limiting, keeps a fixed buffer of time between each packet
now = Environment.TickCount;
int ms = now - lastPacketTime;
if (ms < 75)
{
//Logger.DebugLog(String.Format("Rate limiting, last packet was {0}ms ago", ms));
Thread.Sleep(75 - ms);
}
lastPacketTime = now;
simulator.SendPacketUnqueued(packet, outgoingPacket.SetSequence);
}
}
}
