public static SpawnedEntity FromStream(IStarboundStream stream)
{
SpawnedEntity se;
EntityType et = (EntityType)stream.ReadUInt8();
byte[] storeData = stream.ReadUInt8Array((int)(stream.Length - stream.Position));
using (StarboundStream ss = new StarboundStream(storeData))
{
if (et == EntityType.Projectile)
{
var sp = new SpawnedProjectile();
sp.ProjectileKey = ss.ReadString();
sp.Parameters = ss.ReadVariant();
se = sp;
}
else
{
se = new SpawnedEntity();
}
}
se.EntityType = et;
se.StoreData = storeData;
return(se);
}
public static WorldCoordinate GetGlobalCoords(byte[] data)
{
for (int i = 0; i < data.Length - 26; i++)
{
foreach (var sector in StarboundSector.Sectors.Select(p => p.Data))
{
byte[] buffer = new byte[sector.Length];
Buffer.BlockCopy(data, i, buffer, 0, sector.Length);
if (sector.SequenceEqual(buffer))
{
byte[] sectorData = new byte[sector.Length + 21];
Buffer.BlockCopy(data, i - 1, sectorData, 0, sector.Length + 21);
using (StarboundStream s = new StarboundStream(sectorData))
{
WorldCoordinate coords = FromStream(s);
/*
* if (string.IsNullOrEmpty(coords.Sector))
* return null;
*/
return(coords);
}
}
}
}
return(null);
}
public static CelestialLog FromStream(IStarboundStream stream)
{
CelestialLog log = new CelestialLog();
byte[] logDat = stream.ReadUInt8Array();
using (StarboundStream s = new StarboundStream(logDat))
{
uint visited = s.ReadUInt32();
for (int i = 0; i < visited; i++)
{
log.Visited.Add(s.ReadSystemCoordinate());
}
uint sectors = s.ReadUInt32();
for (int i = 0; i < sectors; i++)
{
log.Sectors.Add(new LogSector {
SectorName = s.ReadString(), Unknown = s.ReadBoolean()
});
}
s.ReadUInt8(); //unknown
log.CurrentSystem = s.ReadSystemCoordinate();
log.CurrentLocation = s.ReadWorldCoordinate();
log.HomeCoordinate = s.ReadWorldCoordinate();
}
return(log);
}
public void Read(StarboundStream stream)
{
int discarded;
Success = stream.ReadBoolean();
ClientId = stream.ReadVLQ(out discarded);
RejectionReason = stream.ReadString();
}
public void Write(StarboundStream stream)
{
stream.WriteString(AssetDigest);
stream.WriteVariant(Claim);
stream.WriteBoolean(UUID != null);
if (UUID != null)
{
stream.WriteUInt8Array(UUID, false);
}
stream.WriteString(PlayerName);
stream.WriteString(Species);
stream.WriteUInt8Array(Shipworld);
stream.WriteString(Account);
}
public void Read(StarboundStream stream)
{
AssetDigest = stream.ReadString();
Claim = stream.ReadVariant();
bool uuid = stream.ReadBoolean();
if (uuid)
{
UUID = stream.ReadUInt8Array(16);
}
PlayerName = stream.ReadString();
Species = stream.ReadString();
Shipworld = stream.ReadUInt8Array();
Account = stream.ReadString();
}
public override void WriteTo(IStarboundStream stream)
{
stream.WriteUInt8((byte)EntityType);
using (StarboundStream s = new StarboundStream())
{
s.WriteString(Object);
s.WriteVariant(Information);
s.WriteUInt8Array(Unknown, false);
stream.WriteUInt8Array(s.ToArray());
}
stream.WriteSignedVLQ(EntityId);
}
public static List <Document> ListFromStream(byte[] data)
{
int discarded;
var documents = new List <Document>();
using (StarboundStream ss = new StarboundStream(data))
{
int len = (int)VLQ.ReadVLQ(ss, out discarded);
for (int i = 0; i < len; i++)
{
documents.Add(FromStream(ss));
}
}
return(documents);
}
public void FlushPackets()
{
while (PacketQueue.Count > 0)
{
IStarboundPacket next;
while (!PacketQueue.TryDequeue(out next))
{
;
}
var memoryStream = new MemoryStream();
var stream = new StarboundStream(memoryStream);
next.Write(stream);
byte[] buffer = new byte[stream.Position];
Array.Copy(memoryStream.GetBuffer(), buffer, buffer.Length);
int length = buffer.Length;
var compressed = ZlibStream.CompressBuffer(buffer);
if (compressed.Length < buffer.Length)
{
buffer = compressed;
length = -buffer.Length;
}
byte[] header = new byte[StarboundStream.GetSignedVLQLength(length) + 1];
header[0] = next.PacketId;
int discarded;
StarboundStream.WriteSignedVLQ(header, 1, length, out discarded);
int payloadStart = header.Length;
Array.Resize(ref header, header.Length + buffer.Length);
Array.Copy(buffer, 0, header, payloadStart, buffer.Length);
lock (PacketsWaitingLock)
PacketsWaiting++;
EmptyQueueReset.Reset();
Socket.BeginSend(header, 0, header.Length, SocketFlags.None, r =>
{
lock (PacketsWaitingLock)
{
PacketsWaiting--;
if (PacketsWaiting == 0)
{
EmptyQueueReset.Set();
}
}
}, null);
}
}
public IPacket Decode(byte packetId, byte[] payload)
{
StarboundStream stream = new StarboundStream(payload);
IPacket packet;
/*
* string val = null;
* foreach (var s in payload)
* {
* val += s;
* }
* SharpStarLogger.DefaultLogger.Info(string.Format("{0}{1}","Payload : ",val));
*/
if (RegisteredPacketTypes.ContainsKey(packetId))
{
packet = RegisteredPacketTypes[packetId]();
}
else
{
packet = new UnknownPacket(Compressed, payload.Length, packetId);
}
if (packet != null)
{
packet.IsReceive = true;
try
{
packet.Read(stream);
}
catch (Exception e)
{
SharpStarLogger.DefaultLogger.Error("Packet {0} caused an error!", packet.GetType().Name);
e.LogError();
}
}
stream.Dispose();
return(packet);
}
public IStarboundPacket[] Decode(byte packetId, byte[] payload)
{
var memoryStream = new MemoryStream(payload);
var stream = new StarboundStream(memoryStream);
List <IStarboundPacket> packets = new List <IStarboundPacket>();
while (stream.Position < stream.Length)
{
IStarboundPacket packet;
if (PacketFactories.ContainsKey(packetId))
{
packet = PacketFactories[packetId]();
}
else
{
packet = new UnhandledPacket(payload, packetId);
}
packet.Read(stream);
packets.Add(packet);
}
return(packets.ToArray());
}
public Metadata GetMetadata()
{
if (Metadata != null)
{
return(Metadata);
}
using (StarboundStream ss = new StarboundStream(GetRaw(new byte[] { 0, 0, 0 })))
{
var unpacked = DataConverter.Unpack("^ii", ss.ReadUInt8Array(8), 0); //unknown
Document doc = Document.FromStream(ss);
if (doc.Name != "WorldMetadata")
{
throw new Exception("Invalid world data!");
}
Metadata = new Metadata(doc.Data, doc.Version);
return(Metadata);
}
}
public IStarboundPacket[] UpdateBuffer(int length)
{
if (length == 0)
{
throw new IOException("Client sent no data, connection is likely terminated.");
}
int index = PacketBuffer.Length;
if (WorkingLength == long.MaxValue)
{
// We don't know the length of the packet yet, so keep going
if (PacketBuffer.Length < index + length)
{
Array.Resize(ref PacketBuffer, index + length);
}
Array.Copy(NetworkBuffer, 0, PacketBuffer, index, length);
if (PacketBuffer.Length > 1)
{
// Check to see if we have the entire length yet
int i;
for (i = 1; i < 5 && i < PacketBuffer.Length; i++)
{
if ((PacketBuffer[i] & 0x80) == 0)
{
WorkingLength = StarboundStream.ReadSignedVLQ(PacketBuffer, 1, out DataIndex);
DataIndex++;
Compressed = WorkingLength < 0;
if (Compressed)
{
WorkingLength = -WorkingLength;
}
if (WorkingLength > MaxPacketLength)
{
throw new IOException("Packet exceeded maximum permissible length.");
}
break;
}
}
if (i == 5)
{
throw new IOException("Packet exceeded maximum permissible length.");
}
}
}
if (WorkingLength != long.MaxValue) // This could be an else, but the earlier block can change the state and this needs to happen if it does
{
if (PacketBuffer.Length < index + length)
{
Array.Resize(ref PacketBuffer, index + length);
}
Array.Copy(NetworkBuffer, 0, PacketBuffer, index, length);
if (PacketBuffer.Length >= WorkingLength + DataIndex)
{
// Ready to decode packet
var data = new byte[WorkingLength];
Array.Copy(PacketBuffer, DataIndex, data, 0, WorkingLength);
if (Compressed)
{
data = ZlibStream.UncompressBuffer(data); // TODO: Prevent compressed packets from exceeding MaxInflatedPacketLength
}
var packets = Decode(PacketBuffer[0], data);
Array.Copy(PacketBuffer, DataIndex + WorkingLength, PacketBuffer, 0, PacketBuffer.Length - (DataIndex + WorkingLength));
Array.Resize(ref PacketBuffer, (int)(PacketBuffer.Length - (DataIndex + WorkingLength)));
WorkingLength = long.MaxValue;
return(packets);
}
}
return(null);
}
public void Read(StarboundStream stream)
{
ClaimMessage = stream.ReadString();
PasswordHash = stream.ReadString();
}
public void Write(StarboundStream stream)
{
stream.WriteBoolean(Success);
stream.WriteVLQ(ClientId);
stream.WriteString(RejectionReason);
}
public void Read(StarboundStream stream)
{
ProtocolVersion = stream.ReadUInt32();
}
public void Write(StarboundStream stream)
{
stream.Write(Data, 0, Data.Length);
}
public void Read(StarboundStream stream)
{
stream.Read(Data, 0, Data.Length);
}
public static Entity FromStream(IStarboundStream stream)
{
EntityType et = (EntityType)stream.ReadUInt8();
byte[] storeData = stream.ReadUInt8Array();
Entity ent;
if (et == EntityType.Projectile)
{
ProjectileEntity pent = new ProjectileEntity();
using (StarboundStream s = new StarboundStream(storeData))
{
pent.Projectile = s.ReadString();
pent.Information = s.ReadVariant().Value as VariantDict;
pent.Unknown1 = s.ReadUInt8Array(17);
pent.ThrowerEntityId = s.ReadSignedVLQ();
pent.Unknown2 = s.ReadUInt8Array((int)(s.Length - s.Position));
}
ent = pent;
}
else if (et == EntityType.Player)
{
PlayerEntity pent = new PlayerEntity();
using (StarboundStream s = new StarboundStream(storeData))
{
/*
* bool uuid = s.ReadBoolean();
*
* if (uuid)
* {
*/
byte[] uuidDat = s.ReadUInt8Array(16);
pent.UUID = BitConverter.ToString(uuidDat, 0).Replace("-", "").ToLower();
//}
}
ent = pent;
}
else if (et == EntityType.Object)
{
ObjectEntity oent = new ObjectEntity();
using (StarboundStream s = new StarboundStream(storeData))
{
oent.Object = s.ReadString();
oent.Information = s.ReadVariant();
oent.Unknown = s.ReadUInt8Array((int)(s.Length - s.Position));
}
ent = oent;
}
else
{
ent = new Entity();
}
ent.EntityType = et;
ent.StoreData = storeData;
ent.EntityId = stream.ReadSignedVLQ();
return(ent);
}
public void Read(StarboundStream stream)
{
int discarded;
Value = stream.ReadVLQ(out discarded);
}
public IEnumerable <IPacket> UpdateBuffer(bool shouldCopy)
{
if (shouldCopy)
{
PacketBuffer.AddRange(NetworkBuffer);
}
Queue <byte[]> toProcess = new Queue <byte[]>();
toProcess.Enqueue(PacketBuffer.ToArray());
while (toProcess.Count > 0)
{
byte[] arr = toProcess.Dequeue();
using (StarboundStream s = new StarboundStream(arr))
{
if (WorkingLength == long.MaxValue && s.Length > 1)
{
_packetId = s.ReadUInt8();
try
{
WorkingLength = s.ReadSignedVLQ();
}
catch
{
WorkingLength = long.MaxValue;
yield break;
}
DataIndex = (int)s.Position;
Compressed = WorkingLength < 0;
if (Compressed)
{
WorkingLength = -WorkingLength;
}
}
if (WorkingLength != long.MaxValue)
{
if (s.Length >= WorkingLength + DataIndex)
{
if (s.Position != DataIndex)
{
s.Seek(DataIndex, SeekOrigin.Begin);
}
byte[] data = s.ReadUInt8Array((int)WorkingLength);
if (Compressed)
{
data = ZlibStream.UncompressBuffer(data);
}
//todo Omit this after testing
//SharpStarLogger.DefaultLogger.Info(string.Format("{0}{1}","ID : ",_packetId));
IPacket packet = Decode(_packetId, data);
WorkingLength = long.MaxValue;
byte[] rest = s.ReadToEnd();
PacketBuffer = rest.ToList();
if (rest.Length > 0)
{
toProcess.Enqueue(rest);
}
yield return(packet);
}
}
}
}
}
public async Task FlushPackets()
{
while (PacketQueue.Count > 0)
{
try
{
IPacket next;
if (!PacketQueue.TryDequeue(out next))
{
continue;
}
if (!next.IsReceive)
{
foreach (var handler in Server.PacketHandlers)
{
if (next.PacketId == handler.PacketId)
{
await handler.Handle(next, OtherClient);
}
}
}
if (next.Ignore)
{
continue;
}
var stream = new StarboundStream();
next.Write(stream);
byte[] buffer = stream.ToArray();
bool compressed = stream.Length >= 512;
if (compressed)
{
buffer = ZlibStream.CompressBuffer(buffer);
}
stream.Dispose();
int length = compressed ? -buffer.Length : buffer.Length;
var finalStream = new StarboundStream();
finalStream.WriteUInt8(next.PacketId);
finalStream.WriteSignedVLQ(length);
finalStream.Write(buffer, 0, buffer.Length);
byte[] toSend = finalStream.ToArray();
finalStream.Dispose();
if (Socket == null)
{
return;
}
var token = new AsyncUserToken();
token.Socket = Socket;
SocketAsyncEventArgs writeArgs = new SocketAsyncEventArgs();
writeArgs.RemoteEndPoint = Socket.RemoteEndPoint;
writeArgs.UserToken = token;
writeArgs.SetBuffer(toSend, 0, toSend.Length);
writeArgs.Completed += IO_Completed;
Socket.SendAsync(writeArgs);
}
catch
{
CloseClientSocket(readEventArgs);
}
}
}
public void Write(StarboundStream stream)
{
stream.WriteString(ClaimMessage);
stream.WriteString(PasswordHash);
}
public void Read(StarboundStream stream)
{
ClaimMessage = stream.ReadString();
Salt = stream.ReadString();
Rounds = stream.ReadInt32();
}
public void Write(StarboundStream stream)
{
stream.WriteUInt32(ProtocolVersion);
}
public void Write(StarboundStream stream)
{
stream.WriteVLQ(Value);
}
public void Write(StarboundStream stream)
{
stream.WriteString(ClaimMessage);
stream.WriteString(Salt);
stream.WriteInt32(Rounds);
}
