void IProtocolToken.Read(UdpPacket packet)
{
this.Parent = packet.ReadBoltEntity();
this.Height = packet.ReadFloat();
this.Support = packet.ReadBoltEntity();
if (packet.ReadBool())
{
this.Holes = new Hole[packet.ReadInt()];
for (int i = 0; i < this.Holes.Length; i++)
{
this.Holes[i]._position = packet.ReadVector3();
this.Holes[i]._size = packet.ReadVector2();
}
}
}
void IProtocolToken.Write(UdpPacket packet)
{
packet.WriteBoltEntity(this.Parent);
packet.WriteFloat(this.Height);
packet.WriteBoltEntity(this.Support);
if (packet.WriteBool(this.Holes != null))
{
packet.WriteInt(this.Holes.Length);
for (int i = 0; i < this.Holes.Length; i++)
{
packet.WriteVector3(this.Holes[i]._position);
packet.WriteVector2(this.Holes[i]._size);
}
}
}
void IProtocolToken.Write(UdpPacket packet)
{
packet.WriteVector3(this.Scale);
packet.WriteVector3(this.HipPosition);
packet.WriteQuaternion(this.HipRotation);
packet.WriteInt(this.MaterialIndex);
packet.WriteFloat(this.skinDamage1);
packet.WriteFloat(this.skinDamage2);
packet.WriteFloat(this.skinDamage3);
packet.WriteFloat(this.skinDamage4);
packet.WriteInt(this.storedRagDollName);
if (packet.WriteBool(this.OriginalMutant && this.OriginalMutant.IsAttached()))
{
packet.WriteBoltEntity(this.OriginalMutant);
}
packet.WriteBool(this.Skinny);
packet.WriteInt(this.Props);
}
void IProtocolToken.Read(UdpPacket packet)
{
this.Scale = packet.ReadVector3();
this.HipPosition = packet.ReadVector3();
this.HipRotation = packet.ReadQuaternion();
this.MaterialIndex = packet.ReadInt();
this.skinDamage1 = packet.ReadFloat();
this.skinDamage2 = packet.ReadFloat();
this.skinDamage3 = packet.ReadFloat();
this.skinDamage4 = packet.ReadFloat();
this.storedRagDollName = packet.ReadInt();
if (packet.ReadBool())
{
this.OriginalMutant = packet.ReadBoltEntity();
}
this.Skinny = packet.ReadBool();
this.Props = packet.ReadInt();
}
MCTest()
{
mct = new MCTestForm(this);
//usbPacket = new UsbWin32Packet();
usbPacket = new UsbPacket();
usbPacket.Open();
if (usbPacket.IsOpen())
mct.SetUsbPortName(usbPacket.Name);
oscUsb = null;
oscUsb = new Osc(usbPacket);
oscUsb.SetAllMessageHandler(UsbMessages);
udpPacket = new UdpPacket();
udpPacket.RemoteHostName = mct.GetUdpRemoteHostName();
udpPacket.RemotePort = mct.GetUdpRemotePort();
udpPacket.LocalPort = mct.GetUdpLocalPort();
udpPacket.Open();
oscUdp = new Osc(udpPacket);
oscUdp.SetAllMessageHandler(UdpMessages);
oscUdp.SetAddressHandler("/analogin/0/value", AIn0Message);
Application.Run(mct);
}
internal override void ProcessPacket(UdpPacket packet)
{
base.ProcessPacket(packet);
}
public static Packet CreatePacket(Param param)
{
Packet ret = null;
//create layer 4
if (param.packetType == Param.PacketType.TCP)
{
TcpPacket tcpPacket = new TcpPacket(param.sPort, param.dPort);
tcpPacket.AllFlags = param.tcpFlag;
if (param.dIP.ToString().Contains("."))
{
IPv4Packet ipPacket = new IPv4Packet(param.sIP, param.dIP);
if (param.IPv4Frag) { ipPacket.FragmentFlags = (int)1; }
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV4);
ipPacket.PayloadPacket = tcpPacket;
tcpPacket.PayloadData = param.payload;
ret.PayloadPacket = ipPacket;
ipPacket.UpdateCalculatedValues();
ipPacket.UpdateIPChecksum();
tcpPacket.Checksum = (ushort)tcpPacket.CalculateTCPChecksum();
}
else
{
IPv6Packet ipPacket = new IPv6Packet(param.sIP, param.dIP);
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV6);
ipPacket.PayloadPacket = tcpPacket;
tcpPacket.PayloadData = param.payload;
ret.PayloadPacket = ipPacket;
}
}
else if (param.packetType == Param.PacketType.UDP)
{
UdpPacket udpPacket = new UdpPacket(param.sPort, param.dPort);
if (param.dIP.ToString().Contains("."))
{
IPv4Packet ipPacket = new IPv4Packet(param.sIP, param.dIP);
if (param.IPv4Frag) { ipPacket.FragmentFlags = (int)1; }
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV4);
ipPacket.PayloadPacket = udpPacket;
udpPacket.PayloadData = param.payload;
udpPacket.UpdateUDPChecksum();
ipPacket.PayloadLength = (ushort)(ipPacket.PayloadLength + param.payload.Length);
ipPacket.UpdateIPChecksum();
ret.PayloadPacket = ipPacket;
}
else
{
IPv6Packet ipPacket = new IPv6Packet(param.sIP, param.dIP);
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV6);
ipPacket.PayloadPacket = udpPacket;
udpPacket.PayloadData = param.payload;
udpPacket.UpdateUDPChecksum();
ipPacket.PayloadLength = (ushort)(ipPacket.PayloadLength + param.payload.Length);
ret.PayloadPacket = ipPacket;
}
}
else if (param.packetType == Param.PacketType.ICMP)
{
ICMPv4Packet icmpPacket = new ICMPv4Packet(new ByteArraySegment(new byte[32]));
if (param.type != 0 && param.code != 0)
{
icmpPacket.TypeCode = (ICMPv4TypeCodes)((param.type * 256) + (param.code));
}
else if (param.type != 0)
{
icmpPacket.TypeCode = (ICMPv4TypeCodes)((param.type * 256));
}
else
{
icmpPacket.TypeCode = ICMPv4TypeCodes.EchoRequest;
}
IPv4Packet ipPacket = new IPv4Packet(param.sIP, param.dIP);
if (param.IPv4Frag) { ipPacket.FragmentFlags = (int)1; }
ipPacket.PayloadPacket = icmpPacket;
ipPacket.Checksum = ipPacket.CalculateIPChecksum();
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV4);
ret.PayloadPacket = ipPacket;
}
else if (param.packetType == Param.PacketType.ICMPv6)
{
ICMPv6Packet icmpv6Packet = CreateICMPv6Packet(param);
IPv6Packet ipPacket = new IPv6Packet(param.sIP, param.dIP);
ipPacket.PayloadPacket = icmpv6Packet;
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV6);
ret.PayloadPacket = ipPacket;
}
else if (param.packetType == Param.PacketType.IP)
{
if (param.dIP.ToString().Contains("."))
{
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV4);
IPv4Packet ipPacket = new IPv4Packet(param.sIP, param.dIP);
if (param.IPv4Frag) { ipPacket.FragmentFlags = (int)1; }
ipPacket.Protocol = param.IPProtocol;
ipPacket.PayloadData = param.payload;
ipPacket.UpdateCalculatedValues();
ret.PayloadPacket = ipPacket;
ipPacket.UpdateIPChecksum();
}
else
{
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV6);
//if extension headers were not specified, just put the payload
if (param.ExtentionHeader.Count == 0)
{
IPv6Packet ipPacket = new IPv6Packet(param.sIP, param.dIP);
ipPacket.Protocol = param.IPProtocol;
ipPacket.PayloadData = param.payload;
ipPacket.PayloadLength = (ushort)param.payload.Length;
ipPacket.UpdateCalculatedValues();
ret.PayloadPacket = ipPacket;
}
else
{
ret = PacketFactory.CreateEHPacket(param, (EthernetPacket)ret);
}
ret.UpdateCalculatedValues();
}
}
else if (param.packetType == Param.PacketType.EtherType)
{
ret = new EthernetPacket(param.sMAC, param.dMAC, param.EtherTypeProtocol);
byte[] etherBuffer = (new byte[64]);
var payload = new byte[etherBuffer.Length + (param.payload).Length];
etherBuffer.CopyTo(payload, 0);
(param.payload).CopyTo(payload, etherBuffer.Length);
ret.PayloadData = payload;
ret.UpdateCalculatedValues();
}
return ret;
}
public void Read(UdpPacket packet)
{
this.Error = packet.ReadString();
}
public void Write(UdpPacket packet)
{
packet.WriteString(this.Error);
}
/// <summary>
/// Raises PacketReceived event.
/// </summary>
/// <param name="packet">UDP packet.</param>
private void OnUdpPacketReceived(UdpPacket packet)
{
if (PacketReceived != null)
{
PacketReceived(new UDP_PacketEventArgs(this, packet.Socket, packet.RemoteEndPoint, packet.Data));
}
}
public UdpPacketReceivedEventArgs(UdpPacket packet, IPEndPoint receivedFrom)
{
Packet = packet;
ReceivedFrom = receivedFrom;
}
public void Read(UdpPacket packet)
{
this.AdminPassword = packet.ReadString();
this.ServerPassword = packet.ReadString();
}
public UdpPacket receive(UdpSocket fan, UdpPacket packet)
{
// create packet if null
if (packet == null)
{
packet = UdpPacket.make(null, null, new MemBuf(1024));
}
// map buf bytes to packet
MemBuf data = (MemBuf)packet.data();
byte[] buf = data.m_buf;
int off = data.m_pos;
int len = buf.Length - off;
int recv = 0;
EndPoint sender = new IPEndPoint(IPAddress.Any, 0);
// receive
if (isConnected(fan))
{
try
{
recv = m_dotnet.Receive(buf, off, len, SocketFlags.None);
sender = m_dotnet.RemoteEndPoint;
}
catch (SocketException e)
{
// .NET will truncate contents correctly, but still throws a
// SocketException, so catch that specific case and allow it
if (e.Message.StartsWith("A message sent on a datagram socket was larger"))
{
recv = len;
sender = m_dotnet.RemoteEndPoint;
}
else
{
throw IOErr.make(e).val;
}
}
}
else
{
try
{
if (m_dotnet == null)
{
m_dotnet = createSocket();
}
recv = m_dotnet.ReceiveFrom(buf, off, len, SocketFlags.None, ref sender);
}
catch (SocketException e)
{
// .NET will truncate contents correctly, but still throws a
// SocketException, so catch that specific case and allow it
if (e.Message.StartsWith("A message sent on a datagram socket was larger"))
{
recv = len;
}
else
{
throw IOErr.make(e).val;
}
}
}
// update packet with received message
IPEndPoint endPoint = sender as IPEndPoint;
packet.addr(IpAddrPeer.make(endPoint.Address));
packet.port(Long.valueOf(endPoint.Port));
data.m_pos += recv;
data.m_size += recv;
return(packet);
}
public void send(UdpSocket fan, UdpPacket packet)
{
// map buf bytes to packet
MemBuf data = (MemBuf)packet.data();
byte[] buf = data.m_buf;
int off = data.m_pos;
int len = data.m_size - off;
// map address, port
IpAddr addr = packet.addr();
Long port = packet.port();
if (isConnected(fan))
{
if (addr != null || port != null)
throw ArgErr.make("Address and port must be null to send while connected").val;
try
{
m_dotnet.Send(buf, off, len, SocketFlags.None);
}
catch (SocketException e)
{
throw IOErr.make(e).val;
}
}
else
{
if (addr == null || port == null)
throw ArgErr.make("Address or port is null").val;
try
{
if (m_dotnet == null) m_dotnet = createSocket();
IPEndPoint endPoint = new IPEndPoint(addr.m_peer.m_dotnet, port.intValue());
m_dotnet.SendTo(buf, off, len, SocketFlags.None, endPoint);
}
catch (SocketException e)
{
throw IOErr.make(e).val;
}
}
// lastly drain buf
data.m_pos += len;
}
void IProtocolToken.Read(UdpPacket packet)
{
this.Anchor = packet.ReadBoltEntity();
this.Index = packet.ReadInt();
}
public UdpPacket receive(UdpSocket fan, UdpPacket packet)
{
// create packet if null
if (packet == null)
packet = UdpPacket.make(null, null, new MemBuf(1024));
// map buf bytes to packet
MemBuf data = (MemBuf)packet.data();
byte[] buf = data.m_buf;
int off = data.m_pos;
int len = buf.Length - off;
int recv = 0;
EndPoint sender = new IPEndPoint(IPAddress.Any, 0);
// receive
if (isConnected(fan))
{
try
{
recv = m_dotnet.Receive(buf, off, len, SocketFlags.None);
sender = m_dotnet.RemoteEndPoint;
}
catch (SocketException e)
{
// .NET will truncate contents correctly, but still throws a
// SocketException, so catch that specific case and allow it
if (e.Message.StartsWith("A message sent on a datagram socket was larger"))
{
recv = len;
sender = m_dotnet.RemoteEndPoint;
}
else
{
throw IOErr.make(e).val;
}
}
}
else
{
try
{
if (m_dotnet == null) m_dotnet = createSocket();
recv = m_dotnet.ReceiveFrom(buf, off, len, SocketFlags.None, ref sender);
}
catch (SocketException e)
{
// .NET will truncate contents correctly, but still throws a
// SocketException, so catch that specific case and allow it
if (e.Message.StartsWith("A message sent on a datagram socket was larger"))
recv = len;
else
throw IOErr.make(e).val;
}
}
// update packet with received message
IPEndPoint endPoint = sender as IPEndPoint;
packet.addr(IpAddrPeer.make(endPoint.Address));
packet.port(Long.valueOf(endPoint.Port));
data.m_pos += recv;
data.m_size += recv;
return packet;
}
void IProtocolToken.Write(UdpPacket packet)
{
packet.WriteInt(this.ChunkIndex);
}
void IProtocolToken.Read(UdpPacket packet)
{
this.ChunkIndex = packet.ReadInt();
}
public void Read(UdpPacket packet)
{
levelName = packet.ReadString();
playersInGame = packet.ReadInt();
messageOfTheDay = packet.ReadString();
}
public DefaulUdpPacketEncoder(UdpPacket packet)
{
this._packet = packet;
}
void IProtocolToken.Write(UdpPacket packet)
{
packet.WriteBoltEntity(this.Anchor);
packet.WriteInt(this.Index);
}
internal virtual void ProcessPacket(UdpPacket packet)
{
Demuxer.ProcessInput(packet.Buffer, 0, packet.Length);
}
public void Write(UdpPacket packet)
{
packet.WriteString(this.AdminPassword);
packet.WriteString(this.ServerPassword);
}
public void posli_update(Rozhranie rozhranie, int cislo_rozhrania, IPAddress cielova_ip, PhysicalAddress cielova_mac)
{
IPv4Packet ip_paket;
UdpPacket udp_paket;
Byte[] ip;
Byte[] hlava = new byte[] { 0x00, 0x02, 0x00, 0x00 };
Byte[] rip_hlava = new byte[] { 0x02, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00 };
Byte[] next_hop = new byte[] { 0x00, 0x00, 0x00, 0x00 };
Byte[] metrika = new byte[] { 0x00, 0x00, 0x00, 0x00 };
bool prvy = true;
EthernetPacket eth = new EthernetPacket(rozhranie.adapter.MacAddress, cielova_mac, EthernetPacketType.IpV4);
ip_paket = new IPv4Packet(IPAddress.Parse(rozhranie.ip_adresa), cielova_ip);
if (cielova_mac.ToString().Equals("01005E000009"))
{
ip_paket.TimeToLive = 2;
}
else
{
ip_paket.TimeToLive = 255;
}
udp_paket = new UdpPacket(520, 520);
foreach (var zaznam in smerovacia_tabulka.ToList())
{
if ((zaznam.typ == "D" || zaznam.typ == "R") && zaznam.exit_interface != cislo_rozhrania && zaznam.metrika != 16)
{
if (!prvy)
{
rip_hlava = rip_hlava.Concat(hlava).ToArray();
}
prvy = false;
rip_hlava = rip_hlava.Concat(zaznam.cielova_siet.GetAddressBytes()).ToArray();
rip_hlava = rip_hlava.Concat(zaznam.maska.GetAddressBytes()).ToArray();
rip_hlava = rip_hlava.Concat(next_hop).ToArray();
if (zaznam.metrika != 16)
{
metrika[3] = (byte)(zaznam.metrika + 1);
}
else
{
metrika[3] = (byte)(zaznam.metrika);
}
rip_hlava = rip_hlava.Concat(metrika).ToArray();
}
}
foreach (var zaznam in rip_databaza.ToList())
{
if (zaznam.metrika == 16 && zaznam.exit_interface != cislo_rozhrania)
{
if (!prvy)
{
rip_hlava = rip_hlava.Concat(hlava).ToArray();
}
prvy = false;
rip_hlava = rip_hlava.Concat(zaznam.cielova_siet.GetAddressBytes()).ToArray();
rip_hlava = rip_hlava.Concat(zaznam.maska.GetAddressBytes()).ToArray();
rip_hlava = rip_hlava.Concat(next_hop).ToArray();
metrika[3] = (byte)zaznam.metrika;
if (zaznam.metrika == 0)
{
metrika[3] = 1;
}
rip_hlava = rip_hlava.Concat(metrika).ToArray();
}
}
udp_paket.PayloadData = rip_hlava;
// udp_paket.UpdateUDPChecksum();
ip_paket.PayloadPacket = udp_paket;
ip_paket.UpdateIPChecksum();
eth.PayloadPacket = ip_paket;
rozhranie.adapter.SendPacket(eth);
}
private void ReceiveCompleted(object sender, SocketAsyncEventArgs e)
{
UdpPacket packet;
if (!_packetPool.TryDequeue(out packet)) packet = new UdpPacket();
packet.Buffer = e.Buffer;
packet.Length = e.BytesTransferred;
packet.ReceivedFrom = (IPEndPoint) e.RemoteEndPoint;
packet.Tick = _highResTimer.ElapsedTicks;
_packetQueue.Add(packet);
// Start receiving next packet as quickly as possible.
byte[] newBuffer;
if (!_bufferPool.TryDequeue(out newBuffer)) newBuffer = new byte[65507];
e.SetBuffer(newBuffer, 0, newBuffer.Length);
if(_running) _socket.ReceiveAsync(e);
}
public ReturnBlockPacket(UdpPacket udpPacket) : base(udpPacket)
{
}
