public STUNAddress ReadMappedAddress(NetworkPacket packet)
{
STUNAddress sa = new STUNAddress();
ushort attrLength = packet.ReadUShort();
byte empty = packet.ReadByte();
sa.family = packet.ReadByte();
sa.port = packet.ReadUShort();
switch (sa.family)
{
case 1:
sa.address = new byte[4];
break;
case 2:
sa.address = new byte[16];
break;
}
for (int i = 0; i < sa.address.Length; i++)
{
sa.address[i] = packet.ReadByte();
}
return(sa);
}
public void Read(NetworkPacket packet)
{
connected = packet.ReadByte() != 0;
sendRate = packet.ReadInt();
peerId = packet.ReadUShort();
Console.WriteLine("Setting server send rate: {0}", sendRate);
}
public string ReadString(NetworkPacket packet)
{
string value = packet.ReadString();
int len = Encoding.UTF8.GetByteCount(value);
while (((len++) % 4) != 0)
{
packet.ReadByte();
}
return(value);
}
public STUNAddress ReadXorMappedAddress(NetworkPacket packet)
{
STUNAddress sa = new STUNAddress();
ushort attrLength = packet.ReadUShort();
ushort xorFlag16 = (ushort)(magicCookie >> 16);
byte empty = packet.ReadByte();
sa.family = packet.ReadByte();
sa.port = (ushort)(packet.ReadUShort() ^ xorFlag16);
switch (sa.family)
{
case 1:
byte[] xorFlagBytes = new byte[4];
Array.Copy(packet.ByteBuffer, 4, xorFlagBytes, 0, 4);
Array.Reverse(xorFlagBytes);
uint xorFlag32 = BitConverter.ToUInt32(xorFlagBytes, 0);
sa.address = new byte[4];
uint address = packet.ReadUInt() ^ xorFlag32;
sa.address[0] = (byte)((address & 0xff000000) >> 24);
sa.address[1] = (byte)((address & 0x00ff0000) >> 16);
sa.address[2] = (byte)((address & 0x0000ff00) >> 8);
sa.address[3] = (byte)(address & 0x000000ff);
break;
case 2:
sa.address = new byte[16];
byte[] xorFlags = new byte[16];
Array.Copy(transactionID, 0, xorFlags, xorFlags.Length, transactionID.Length);
for (int i = 0; i < sa.address.Length; i++)
{
sa.address[i] = (byte)(packet.ReadByte() ^ xorFlags[i]);
}
break;
}
return(sa);
}
public override NetworkMessage[] ReadHeaders(NetworkPacket packet)
{
uint bits = packet.ReadByte();
//remove flag bits to reveal channel type
bits = bits & ~(StreamFlag | SendTypeFlag | ReliableFlag | ProtocolTypeFlag);
if (bits < 0 || bits >= (uint)ChannelType.LAST)
{
NetworkMessage[] msgFailList = new NetworkMessage[1];
msgFailList[0] = (NetworkMessage)channel.CreateMessage(ChannelType.Invalid);
return(msgFailList);
}
uint msgCount = packet.ReadByte();
NetworkMessage[] msg = new NetworkMessage[msgCount];
for (int i = 0; i < msgCount; i++)
{
msg[i] = ReadHeader(packet);
}
return(msg);
}
public string ReadErrorCode(NetworkPacket packet)
{
ushort attrLength = packet.ReadUShort();
uint bits = packet.ReadUInt();
uint code = bits & 0xFF;
uint codeClass = (bits & 0x700) >> 8;
string phrase = packet.ReadString(attrLength - 4);
while ((attrLength++) % 4 != 0)
{
packet.ReadByte();
}
return("Error (" + codeClass + code.ToString("D2") + "): " + phrase);
}
public override void ReadResponse(NetworkPacket packet)
{
method = (ServerMethod)packet.ReadByte();
switch (method)
{
case ServerMethod.CONNECT:
response.connect.Read(packet);
break;
case ServerMethod.HEARTBEAT:
break;
}
}
public override NetworkMessage ReadHeader(NetworkPacket packet)
{
uint bits = packet.ReadByte();
bool isSTUN = (bits & ProtocolTypeFlag) == 0;
if (isSTUN)
{
packet.bytePos = 0;
NetworkMessage msg = (NetworkMessage)channel.CreateMessage(ChannelType.STUN);
msg.header.isSTUN = true;
msg.header.isReliable = true;
msg.header.sendType = SendType.Response;
return(msg);
}
bool isStream = (bits & StreamFlag) > 0;
bool isReliable = (bits & ReliableFlag) > 0;
SendType sendType = (SendType)((bits & SendTypeFlag) > 0 ? 1 : 0);
//remove flag bits to reveal channel type
bits = bits & ~(StreamFlag | SendTypeFlag | ReliableFlag | ProtocolTypeFlag);
if (bits < 0 || bits >= (uint)ChannelType.LAST)
{
return((NetworkMessage)channel.CreateMessage(ChannelType.Invalid));
}
NetworkMessage message = (NetworkMessage)channel.CreateMessage(bits);
message.header.isReliable = isReliable;
message.header.isStream = isStream;
message.header.sendType = sendType;
message.header.channelType = (ChannelType)bits;
message.header.sequence = packet.ReadUShort();
OnReadHeader.Invoke(packet, message);
if (message.header.isReliable)
{
message.header.ackkey = GenerateAckKey(packet, message);
}
return(message);
}
public override void ReadResponse(NetworkPacket packet)
{
methodId = (ushort)((uint)packet.ReadUShort() & 0x3FFF); //0x3F (0011 1111) sets left most 2 bits to 00
methodLength = packet.ReadUShort();
transactionID = packet.ReadBytes(16);
header.ackkey = BitConverter.ToUInt32(transactionID, 0);
method = (STUNMethod)methodId;
//Console.WriteLine("STUN Response address: " + packet.remoteEndPoint.ToString());
//Console.WriteLine("STUN Response Method: " + Enum.GetName(typeof(STUNMethod), method));
//Console.WriteLine("STUN Response Length: " + methodLength);
while (packet.bytePos < packet.byteLength)
{
STUNAddress address;
STUNAttribute attrType = (STUNAttribute)packet.ReadUShort();
attributeTypes.Add(attrType);
//Console.WriteLine("STUN Attr Type: " + Enum.GetName(typeof(STUNAttribute), attrType));
switch (attrType)
{
case STUNAttribute.MappedAddress:
case STUNAttribute.SourceAddress:
case STUNAttribute.ChangedAddress:
address = ReadMappedAddress(packet);
response.Add(attrType, address);
break;
case STUNAttribute.XorMappedAddress:
case STUNAttribute.XorRelayedAddress:
address = ReadXorMappedAddress(packet);
response.Add(attrType, address);
break;
case STUNAttribute.ErrorCode:
response.Add(attrType, ReadErrorCode(packet));
break;
case STUNAttribute.UnknownAttribute:
response.Add(attrType, ReadUnknownAttributes(packet));
break;
case STUNAttribute.ServerName:
response.Add(attrType, ReadString(packet));
break;
case STUNAttribute.Realm:
response.Add(attrType, ReadString(packet));
break;
case STUNAttribute.Username:
response.Add(attrType, ReadString(packet));
break;
default:
ushort attrLen = packet.ReadUShort();
byte[] bytes = packet.ReadBytes(attrLen);
response.Add(attrType, bytes);
while (((attrLen++) % 4) != 0)
{
packet.ReadByte();
}
break;
}
}
}
