public ARPPacket(EthernetFrame Ef)
{
int pktOffset = Ef.HeaderLength;
NetLib.ReadUInt16(Ef.RawPacket.buffer, ref pktOffset, out HardWareType);
//
DataLib.ReadUInt16(Ef.RawPacket.buffer, ref pktOffset, out Protocol);
//
NetLib.ReadByte08(Ef.RawPacket.buffer, ref pktOffset, out HardwareAddressLength);
NetLib.ReadByte08(Ef.RawPacket.buffer, ref pktOffset, out ProtocolAddressLength);
NetLib.ReadUInt16(Ef.RawPacket.buffer, ref pktOffset, out OP);
//Error.WriteLine("OP" + OP);
NetLib.ReadByteArray(Ef.RawPacket.buffer, ref pktOffset, HardwareAddressLength, out SenderHardwareAddress);
//WriteLine("sender MAC :" + SenderHardwareAddress[0] + ":" + SenderHardwareAddress[1] + ":" + SenderHardwareAddress[2] + ":" + SenderHardwareAddress[3] + ":" + SenderHardwareAddress[4] + ":" + SenderHardwareAddress[5]);
NetLib.ReadByteArray(Ef.RawPacket.buffer, ref pktOffset, ProtocolAddressLength, out SenderProtocolAddress);
//WriteLine("sender IP :" + SenderProtocolAddress[0] + "." + SenderProtocolAddress[1] + "." + SenderProtocolAddress[2] + "." + SenderProtocolAddress[3]);
NetLib.ReadByteArray(Ef.RawPacket.buffer, ref pktOffset, HardwareAddressLength, out TargetHardwareAddress);
//WriteLine("target MAC :" + TargetHardwareAddress[0] + ":" + TargetHardwareAddress[1] + ":" + TargetHardwareAddress[2] + ":" + TargetHardwareAddress[3] + ":" + TargetHardwareAddress[4] + ":" + TargetHardwareAddress[5]);
NetLib.ReadByteArray(Ef.RawPacket.buffer, ref pktOffset, ProtocolAddressLength, out TargetProtocolAddress);
//WriteLine("target IP :" + TargetProtocolAddress[0] + "." + TargetProtocolAddress[1] + "." + TargetProtocolAddress[2] + "." + TargetProtocolAddress[3]);
}
public void ReceiveFrame(EthernetFrame frame)
{
lock (innerLock)
{
this.Log(LogLevel.Debug, "Received packet, length {0}", frame.Bytes.Length);
if (!receiverEnabled.Value)
{
this.Log(LogLevel.Info, "Receiver not enabled, dropping frame");
return;
}
if (discardWithMACLayerError.Value && !EthernetFrame.CheckCRC(frame.Bytes))
{
this.Log(LogLevel.Info, "Invalid CRC, packet discarded");
return;
}
if (discardIPHeaderInvalidChecksum.Value)
{
var packet = (IPv4Packet)frame.UnderlyingPacket.Extract(typeof(IPv4Packet));
if (packet != null && !packet.ValidChecksum)
{
this.Log(LogLevel.Info, "Invalid IpV4 checksum, packet discarded");
return;
}
}
if (discardProtocolInvalidChecksum.Value)
{
var tcpPacket = (TcpPacket)frame.UnderlyingPacket.Extract(typeof(TcpPacket));
if (tcpPacket != null && !tcpPacket.ValidChecksum)
{
this.Log(LogLevel.Info, "Invalid TCP checksum, packet discarded");
return;
}
var udpPacket = (UdpPacket)frame.UnderlyingPacket.Extract(typeof(UdpPacket));
if (udpPacket != null && !udpPacket.ValidChecksum)
{
this.Log(LogLevel.Info, "Invalid UDP checksum, packet discarded");
return;
}
var icmpv4Packet = (ICMPv4Packet)frame.UnderlyingPacket.Extract(typeof(ICMPv4Packet));
if (icmpv4Packet != null)
{
var checksum = icmpv4Packet.Checksum;
icmpv4Packet.Checksum = 0x0;
icmpv4Packet.UpdateCalculatedValues();
if (checksum != icmpv4Packet.Checksum)
{
this.Log(LogLevel.Info, "Invalid ICMPv4 checksum, packet discarded");
return;
}
}
var icmpv6Packet = (ICMPv6Packet)frame.UnderlyingPacket.Extract(typeof(ICMPv6Packet));
if (icmpv6Packet != null)
{
var checksum = icmpv6Packet.Checksum;
icmpv6Packet.Checksum = 0x0;
icmpv6Packet.UpdateCalculatedValues();
if (checksum != icmpv6Packet.Checksum)
{
this.Log(LogLevel.Info, "Invalid ICMPv6 checksum, packet discarded");
return;
}
}
}
rxDescriptorsQueue.CurrentDescriptor.Read();
if (rxDescriptorsQueue.CurrentDescriptor.IsEmpty)
{
if (!rxDescriptorsQueue.CurrentDescriptor.WriteBuffer(frame.Bytes, (uint)frame.Bytes.Length))
{
// The current implementation doesn't handle packets that do not fit into a single buffer.
// In case we encounter this error, we probably should implement partitioning/scattering procedure.
this.Log(LogLevel.Warning, "Could not write the incoming packet to the DMA buffer: maximum packet length exceeded.");
return;
}
rxDescriptorsQueue.CurrentDescriptor.Length = (ushort)frame.Bytes.Length;
// Packets going over several buffers not supported
rxDescriptorsQueue.CurrentDescriptor.IsLast = true;
rxDescriptorsQueue.CurrentDescriptor.IsEmpty = false;
// write this back to memory
rxDescriptorsQueue.CurrentDescriptor.Update();
rxDescriptorsQueue.GoToNextDescriptor();
interruptManager.SetInterrupt(Interrupts.ReceiveBufferInterrupt);
interruptManager.SetInterrupt(Interrupts.ReceiveFrameInterrupt);
}
else
{
this.Log(LogLevel.Warning, "Receive DMA buffer overflow");
}
}
}
public IPPacket(EthernetFrame Ef)
{
ReadBuffer(Ef.RawPacket.buffer, Ef.HeaderLength, Ef.RawPacket.size, false);
}
private bool IsAddressedForThisInterface(EthernetFrame fFrame)
{
return(PrimaryMACAddress == fFrame.Destination || fFrame.Destination.IsBroadcast || lmacSpoofAdresses.Contains(fFrame.Destination));
}
private bool IsLocalHostTraffic(EthernetFrame fFrame)
{
IPFrame ipFrame = GetIPFrame(fFrame);
return(ipFrame != null && (InterfaceConfiguration.IsLocalAddress(ipFrame.SourceAddress) || InterfaceConfiguration.IsLocalAddress(ipFrame.DestinationAddress)));
}
public TagControlInfo(KaitaiStream p__io, EthernetFrame p__parent = null, EthernetFrame p__root = null) : base(p__io)
{
m_parent = p__parent;
m_root = p__root;
_read();
}
public void ReceiveFrame(EthernetFrame frame)
{
lock (lockObj)
{
this.NoisyLog("Received frame on MAC {0}. Frame destination MAC is {1}", this.MAC.ToString(), frame.DestinationMAC);
var size = frame.Bytes.Length;
var isEven = (size & 1) == 0;
if ((receiveControl & ReceiveEnabled) == 0 || (receiveControl & SoftwareReset) != 0)
{
//Drop if reset is on or receiving is not enabled.
return;
}
var packetSize = Math.Max(64, size & ~1);
//64 is the minimal length
packetSize += 6;
var withCRC = (receiveControl & StripCRC) == 0;
if (withCRC)
{
packetSize += 4;
}
if (packetSize > MaxPacketSize)
{
//Maybe we should react to overruns. Now we just drop.
return;
}
byte whichPacket;
if (!TryAllocatePacket(out whichPacket))
{
return;
}
rxFifo.Enqueue(whichPacket);
var status = 0;
if (size > 1518)
{
status |= 0x0800;
}
if (!isEven)
{
status |= 0x1000;
}
var currentBuffer = memoryBuffer[whichPacket];
currentBuffer.Data[0] = (byte)(status & 0xff);
currentBuffer.Data[1] = (byte)(status >> 8);
currentBuffer.Data[2] = (byte)(packetSize & 0xff);
currentBuffer.Data[3] = (byte)(packetSize >> 8);
var frameBytes = frame.Bytes;
for (int i = 0; i < (size & ~1); i++)
{
currentBuffer.Data[4 + i] = frameBytes[i];
}
//Pad with 0s
if (size < 64)
{
var pad = 64 - size;
if (!isEven)
{
for (int i = 0; i < pad; i++)
{
currentBuffer.Data[4 + i + size] = 0;
}
}
else
{
for (int i = 0; i < pad; i++)
{
currentBuffer.Data[4 + i + size + 1] = 0;
}
}
size = 64;
}
if (withCRC)
{
if (!EthernetFrame.CheckCRC(frame.Bytes))
{
this.Log(LogLevel.Info, "Invalid CRC, packet discarded");
return;
}
}
if (!isEven)
{
//TODO: For a short, odd-length packet, will it work? Should it not be written before?
currentBuffer.Data[packetSize - 2] = frameBytes[size - 1];
currentBuffer.Data[packetSize - 1] = 0x60;
}
else
{
currentBuffer.Data[packetSize - 1] = 0x40;
}
interruptStatus |= RxInterrupt;
Update();
}
}
public byte[] GetDataBulk(USBPacket packet)
{
lock (sync)
{
if (packet.bytesToTransfer > 0)
{
if (rxPacketQueue.Count > 0)
{
EthernetFrame receivedFrame = rxPacketQueue.Dequeue();
//byte frameBytes []= rxFifo.Dequeue();
var size = receivedFrame.Bytes.Length;
uint packetSize;
// var packetSize = Math.Max(64, size & ~1); //64 is the minimal length
packetSize = (uint)size;
packetSize += 6;
packetSize += 6;
if (packetSize > 1514 + 12)
{
//Maybe we should react to overruns. Now we just drop.
return(null);
}
byte[] currentBuffer = new byte[(uint)packetSize];
currentBuffer[2] = (byte)((packetSize - 6) & 0xff);
currentBuffer[3] = (byte)((packetSize - 6) >> 8);
var frameBytes = receivedFrame.Bytes;
ushort cksum = 0;
byte[] tmp = new byte[(uint)frameBytes.Length - 14];
Array.Copy(frameBytes, 14, tmp, 0, tmp.Length);
cksum = CalculateChecksumRX(tmp);
if ((frameBytes[14] & 0xF0) == 0x40) //IP packet
{
if (frameBytes[23] == 0x06) // TCP packet
{
uint sa = (uint)((frameBytes[MACHeaderLegth + 12 + 3] << 24) | (frameBytes[MACHeaderLegth + 12 + 2] << 16) | (frameBytes[MACHeaderLegth + 12 + 1] << 8) | (frameBytes[MACHeaderLegth + 12 + 0] << 0));
uint da = (uint)((frameBytes[MACHeaderLegth + 16 + 3] << 24) | (frameBytes[MACHeaderLegth + 16 + 2] << 16) | (frameBytes[MACHeaderLegth + 16 + 1] << 8) | (frameBytes[MACHeaderLegth + 16 + 0] << 0));
ushort protocol = frameBytes[MACHeaderLegth + 9];
ushort IPHeaderLength = (ushort)((frameBytes[14] & 0x0F) * 4);
ushort packetLength = (ushort)(System.Net.IPAddress.HostToNetworkOrder((ushort)(frameBytes.Length - (MACHeaderLegth + IPHeaderLength))) >> 16);
long s = sa + da + (protocol << 8) + packetLength;
s += (s >> 32);
s = (s & 0xffff) + (s >> 16);
s = (s & 0xffff) + (s >> 16);
cksum = (ushort)~s;
}
}
if ((frameBytes[14] & 0xF0) == 0x40) //IP packet
{
if (frameBytes[23] == 0x01) // UDP packet
{
Array.Copy(frameBytes, 14, tmp, 0, tmp.Length);
ushort cksumm = CalculateChecksumRX(tmp);
frameBytes[36] = (byte)((cksumm >> 8) & 0xFF);
frameBytes[37] = (byte)((cksumm) & 0xFF);
}
}
for (int i = 0; i < size; i++)
{
currentBuffer[6 + i] = frameBytes[i];
}
if ((frameBytes[14] & 0xF0) == 0x40) //IP packet
{
if (frameBytes[23] == 0x06)
{
currentBuffer[packetSize - 1] = (byte)(((cksum) >> 8) & 0xFF);
currentBuffer[packetSize - 2] = (byte)((cksum) & 0xFF);
}
else if (frameBytes[23] == 0x11)
{
currentBuffer[packetSize - 1] = (byte)(((cksum) >> 8) & 0xFF);
currentBuffer[packetSize - 2] = (byte)((cksum) & 0xFF);
}
}
return(currentBuffer);
}
}
return(null);
}
}
public static bool TryCreateFrameOrLogWarning(IEmulationElement source, byte[] data, out EthernetFrame frame, bool addCrc)
{
if (EthernetFrame.TryCreateEthernetFrame(data, addCrc, out frame))
{
return(true);
}
source.Log(LogLevel.Warning, "Insufficient data to create an ethernet frame, expected {0} bytes but got {1} bytes.",
EthernetFrame.MinFrameSizeWithoutCRC + (addCrc ? 0 : EthernetFrame.CRCLength), data.Length);
return(false);
}
private void SendFrames()
{
this.Log(LogLevel.Noisy, "Sending frame");
var transmitDescriptor = new TxDescriptor(machine.SystemBus);
var packetData = new List <byte>();
transmitDescriptor.Fetch(dmaTransmitDescriptorListAddress);
while (!transmitDescriptor.IsUsed)
{
transmitDescriptor.IsUsed = true;
this.Log(LogLevel.Noisy, "GOING TO READ FROM {0:X}, len={1}", transmitDescriptor.Address1, transmitDescriptor.Buffer1Length);
packetData.AddRange(machine.SystemBus.ReadBytes(transmitDescriptor.Address1, transmitDescriptor.Buffer1Length));
if (!transmitDescriptor.IsNextDescriptorChained)
{
packetData.AddRange(machine.SystemBus.ReadBytes(transmitDescriptor.Address2, transmitDescriptor.Buffer2Length));
}
transmitDescriptor.WriteBack();
if (transmitDescriptor.IsEndOfRing)
{
dmaTransmitDescriptorListAddress = dmaTransmitDescriptorListAddressBegin;
}
else if (transmitDescriptor.IsNextDescriptorChained)
{
dmaTransmitDescriptorListAddress = transmitDescriptor.Address2;
}
else
{
dmaTransmitDescriptorListAddress += 8;
}
if (transmitDescriptor.IsLast)
{
this.Log(LogLevel.Noisy, "Sending frame of {0} bytes.", packetData.Count);
if (Link.IsConnected)
{
var frame = EthernetFrame.CreateEthernetFrameWithoutCRC(packetData.ToArray());
if (transmitDescriptor.ChecksumInstertionControl > 0)
{
this.Log(LogLevel.Noisy, "Calculating checksum (mode {0}).", transmitDescriptor.ChecksumInstertionControl);
if (transmitDescriptor.ChecksumInstertionControl == 1)
{
//IP only
frame.FillWithChecksums(supportedEtherChecksums, null);
}
else
{
//IP and payload
frame.FillWithChecksums(supportedEtherChecksums, supportedIPChecksums);
}
}
this.Log(LogLevel.Debug, Misc.DumpPacket(frame, true, machine));
packetSent = true;
//We recreate the EthernetFrame because the CRC should be appended after creating inner checksums.
var frameWithCrc = EthernetFrame.CreateEthernetFrameWithCRC(frame.Bytes);
Link.TransmitFrameFromInterface(frameWithCrc);
}
}
transmitDescriptor.Fetch(dmaTransmitDescriptorListAddress);
}
//set TransmitBufferUnavailable
dmaStatus |= TransmitBufferUnavailableStatus;
if ((dmaInterruptEnable & (StartStopTransmission)) == 0)
{
IRQ.Set();
}
this.Log(LogLevel.Noisy, "Frame sent.");
}
public static async void SendToElastic(this sFlowDatagram datagram)
{
string request = "";
string datetime = DateTime.Now.ToString("o");
foreach (Sample sample in datagram.Samples)
{
if (sample == null)
{
continue;
}
Dictionary <string, object> doc = new Dictionary <string, object>();
doc.Add("@timestamp", datetime);
doc.Add("sflow_source", datagram.AgentAddress.ToString());
doc.Add("sflow_sequence", datagram.SequenceNumber);
if (sample.Type == SampleType.Flow)
{
FlowSample flowSample = (FlowSample)sample;
doc.Add("sampling_rate", flowSample.SamplingRate);
doc.Add("sampling_pool", flowSample.SamplingPool);
doc.Add("dropped_packets", flowSample.DroppedPackets);
doc.Add("frame_in_interface_value", flowSample.InputInterface.Value);
doc.Add("frame_out_interface_value", flowSample.OutputInterface.Value);
doc.Add("frame_out_interface_format", flowSample.OutputInterface.Format.ToString());
doc.Add("frame_out_interface_discard", flowSample.OutputInterface.DiscardReason.ToString());
foreach (FlowRecord record in flowSample.Records)
{
if (record.Type == FlowRecordType.RawPacketHeader)
{
RawPacketHeader rawPacketHeader = (RawPacketHeader)record;
doc.Add("frame_length_octets", rawPacketHeader.FrameLength);
if (rawPacketHeader.HeaderProtocol == HeaderProtocol.Ethernet)
{
EthernetFrame ethFrame = (EthernetFrame)rawPacketHeader.Header;
doc.Add("mac_source", ethFrame.SourceMAC.ToString());
doc.Add("mac_destination", ethFrame.DestinationMAC.ToString());
doc.Add("packet_type", ethFrame.PacketType.ToString());
ProtocolType ProtocolType = 0;
if (ethFrame.PacketType == PacketType.IPv4)
{
IPv4Packet packet = (IPv4Packet)ethFrame.Packet;
doc.Add("ip_source", packet.SourceAddress.ToString());
doc.Add("ip_destination", packet.DestinationAddress.ToString());
doc.Add("ip_ttl", packet.TimeToLive);
doc.Add("protocol_type", packet.ProtocolType.ToString());
ProtocolType = packet.ProtocolType;
}
if (ProtocolType == ProtocolType.TCP)
{
TCP TCP = (TCP)ethFrame.Packet.Payload;
doc.Add("port_source", TCP.SourcePort);
doc.Add("port_destination", TCP.DestinationPort);
}
else if (ProtocolType == ProtocolType.UDP)
{
UDP UDP = (UDP)ethFrame.Packet.Payload;
doc.Add("port_source", UDP.SourcePort);
doc.Add("port_destination", UDP.DestinationPort);
}
}
}
else if (record.Type == FlowRecordType.ExtSwitchData)
{
SwitchData switchData = (SwitchData)record;
doc.Add("vlan_in", switchData.IncomingVLAN);
doc.Add("vlan_out", switchData.OutgoingVLAN);
}
}
}
else if (sample.Type == SampleType.Counter)
{
CounterSample countSample = (CounterSample)sample;
foreach (CounterRecord record in countSample.Records)
{
if (record.Type == CounterRecordType.GenericInterface)
{
Generic gi = (Generic)record;
doc.Add("if_direction", gi.IfDirection.ToString());
doc.Add("if_in_broadcast_pkts", gi.IfInBroadcastPkts);
doc.Add("if_index", gi.IfIndex);
doc.Add("if_in_discards", gi.IfInDiscards);
doc.Add("if_in_errors", gi.IfInErrors);
doc.Add("if_in_multicast_pkts", gi.IfInMulticastPkts);
doc.Add("if_in_octets", gi.IfInOctets);
doc.Add("if_in_unicast_pkts", gi.IfInUcastPkts);
doc.Add("if_in_unknown_protos", gi.IfInUnknownProtos);
doc.Add("if_out_broadcast_pkts", gi.IfOutBroadcastPkts);
doc.Add("if_out_discards", gi.IfOutDiscards);
doc.Add("if_out_errors", gi.IfOutErrors);
doc.Add("if_out_multicast_pkts", gi.IfOutMulticastPkts);
doc.Add("if_out_octets", gi.IfOutOctets);
doc.Add("if_out_unicast_ptks", gi.IfOutUcastPkts);
doc.Add("if_promiscuous_mode", gi.IfPromiscuousMode);
doc.Add("if_speed", gi.IfSpeed);
doc.Add("if_type", gi.IfType);
doc.Add("if_status_up_admin", gi.IfStatus.HasFlag(Generic.IfStatusFlags.IfAdminStatusUp));
doc.Add("if_status_up_operational", gi.IfStatus.HasFlag(Generic.IfStatusFlags.IfOperStatusUp));
}
else if (record.Type == CounterRecordType.EthernetInterface)
{
Ethernet eth = (Ethernet)record;
doc.Add("eth_alignment_errors", eth.AlignmentErrors);
doc.Add("eth_carrier_sense_errors", eth.CarrierSenseErrors);
doc.Add("eth_deferred_transmissions", eth.DeferredTransmissions);
doc.Add("eth_excessive_collisions", eth.ExcessiveCollisions);
doc.Add("eth_fcs_errors", eth.FCSErrors);
doc.Add("eth_frame_too_longs", eth.FrameTooLongs);
doc.Add("eth_mac_recieve_errors", eth.InternalMacReceiveErrors);
doc.Add("eth_mac_transmit_errors", eth.InternalMacTransmitErrors);
doc.Add("eth_late_collisions", eth.LateCollisions);
doc.Add("eth_multiple_collision_frames", eth.MultipleCollisionFrames);
doc.Add("eth_single_collision_frames", eth.SingleCollisionFrames);
doc.Add("eth_sqe_test_errors", eth.SQETestErrors);
doc.Add("eth_symbol_errors", eth.SymbolErrors);
}
else if (record.Type == CounterRecordType.VLAN)
{
VLAN vlan = (VLAN)record;
doc.Add("vlan_multicast_pkts", vlan.MulticastPkts);
doc.Add("vlan_octets", vlan.Octets);
doc.Add("vlan_unicast_pkts", vlan.UCastPkts);
doc.Add("vlan_id", vlan.VlanID);
}
else if (record.Type == CounterRecordType.ProcessorInformation)
{
ProcessorInfo pi = (ProcessorInfo)record;
doc.Add("stats_cpu_percent_1m", pi.Cpu1mPercentage);
doc.Add("stats_cpu_percent", pi.Cpu5mPercentage);
doc.Add("stats_cpu_5s_percent", pi.Cpu5sPercentage);
doc.Add("stats_memory_free", pi.FreeMemory);
doc.Add("stats_memory_total", pi.TotalMemory);
}
}
}
request += "{\"create\":{\"_index\":\"" + PREFIX + sample.Type.ToString().ToLower() + "\"}}\n";
request += JsonConvert.SerializeObject(doc) + '\n';
}
try
{
MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(request));
await HC.PostAsync(URI + "/_bulk", new StreamContent(ms)
{
Headers =
{
ContentType = MediaTypeHeaderValue.Parse("application/json")
}
});
ms.Dispose();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
private void HandleFrame(EthernetFrame frame)
{
HandleFrameInner(frame.Bytes);
}
public override bool Send(NetPacket pkt)
{
if (base.Send(pkt))
{
return(true);
}
//get_eth_protocol_hi(pkt.buffer);
//get_eth_protocol_lo(pkt.buffer);
//get_dest_eth_mac(pkt.buffer);
//get_src_eth_mac(pkt.buffer);
//get_dest_arp_mac(pkt.buffer,14);
//get_src_arp_mac(pkt.buffer,14);
//get_dest_arp_ip(pkt.buffer, 14);
//get_dest_ip_ip(pkt.buffer, 14);
EthernetFrame eth = null;
if (!switched)
{
eth = new EthernetFrame(pkt);
//If intercept DHCP, then get IP from DHCP process
if (eth.Protocol == (UInt16)EtherFrameType.IPv4)
{
ps2IP = ((IPPacket)eth.Payload).SourceIP;
//MAC
}
else if (eth.Protocol == (UInt16)EtherFrameType.ARP)
{
ps2IP = ((ARPPacket)eth.Payload).SenderProtocolAddress;
//MAC
//Need to also set Host MAC (SenderProtocolAddress)
//Utils.memcpy(ref pkt.buffer, 14 + 8, host_mac, 0, 6); //ARP
SetSrcMAC_ARP(pkt.buffer, 14, hostMAC);
}
//Set Sorce mac to host_mac
SetSrcMAC_Eth(pkt.buffer, hostMAC);
}
else //Switched
{
byte[] host_mac_pkt = new byte[pkt.size];
Array.Copy(pkt.buffer, host_mac_pkt, pkt.size);
//here we send a boadcast with both host_mac and ps2_mac
//is destination address broadcast?
if (Utils.memcmp(GetDestMAC_Eth(host_mac_pkt), 0, broadcastMAC, 0, 6))
{
//Set Dest to host mac
SetDestMAC_Eth(host_mac_pkt, hostMAC);
PcapSendIO(host_mac_pkt, pkt.size);
}
}
if (PcapSendIO(pkt.buffer, pkt.size))
{
return(false);
}
else
{
return(true);
}
}
//sends the packet and deletes it when done (if successful).rv :true success
public override bool Send(NetPacket pkt)
{
lock (sendSentry)
{
Log_Verb("Sending NetPacket");
bool result = false;
EthernetFrame ef = new EthernetFrame(pkt);
switch (ef.Protocol)
{
case (int)EtherFrameType.NULL:
//Adapter Reset
//lock (sentry)
//{
Log_Verb("Reset " + connections.Count + " Connections");
ConnectionKey[] keys = connections.Keys.ToArray();
foreach (ConnectionKey key in keys)
{
if (!connections.TryGetValue(key, out Session session))
{
continue;
}
session.Reset();
}
//}
break;
case (int)EtherFrameType.IPv4:
result = SendIP((IPPacket)ef.Payload);
break;
#region "ARP"
case (int)EtherFrameType.ARP:
Log_Verb("ARP");
ARPPacket arpPkt = ((ARPPacket)ef.Payload);
if (arpPkt.Protocol == (UInt16)EtherFrameType.IPv4)
{
if (arpPkt.OP == 1) //ARP request
{
byte[] gateway;
//lock (sentry)
//{
gateway = dhcpServer.Gateway;
//}
//if (Utils.memcmp(arpPkt.TargetProtocolAddress, 0, gateway, 0, 4))
if (!Utils.memcmp(arpPkt.TargetProtocolAddress, 0, dhcpServer.PS2IP, 0, 4))
//it's trying to resolve the virtual gateway's mac addr
{
ARPPacket arpRet = new ARPPacket
{
TargetHardwareAddress = arpPkt.SenderHardwareAddress,
SenderHardwareAddress = virturalDHCPMAC,
TargetProtocolAddress = arpPkt.SenderProtocolAddress,
SenderProtocolAddress = arpPkt.TargetProtocolAddress,
OP = 2,
Protocol = arpPkt.Protocol
};
EthernetFrame retARP = new EthernetFrame(arpRet)
{
DestinationMAC = ps2MAC,
SourceMAC = virturalDHCPMAC,
Protocol = (UInt16)EtherFrameType.ARP
};
vRecBuffer.Enqueue(retARP.CreatePacket());
break;
}
}
}
result = true;
break;
#endregion
case 0x0081:
Log_Error("VLAN-tagged frame (IEEE 802.1Q)");
throw new NotImplementedException();
//break;
default:
Log_Error("Unkown EtherframeType " + ef.Protocol.ToString("X4"));
break;
}
return(result);
}
}
public void ReceiveFrame(EthernetFrame frame)
{
throw new NotImplementedException();
}
private void SendFrames()
{
lock (sync)
{
txBufferDescriptor txBD = new txBufferDescriptor(machine.SystemBus);
bool interrupt = false;
List <byte> packet = new List <byte>();
txBD.Fetch(registers.TxQueueBaseAddr);
while (!txBD.Used)
{
while (!txBD.Last)
{
packet.AddRange(machine.SystemBus.ReadBytes(txBD.Word0, txBD.Length));
txBD.Used = true;
txBD.WriteBack();
if (txBD.Wrap)
{
registers.TxQueueBaseAddr = txBufferBase;
}
else
{
registers.TxQueueBaseAddr += 8;
}
txBD.Fetch(registers.TxQueueBaseAddr);
}
interrupt = false;
txBD.Used = true;
packet.AddRange(machine.SystemBus.ReadBytes(txBD.Word0, txBD.Length));
if ((registers.DMAConfig & 1u << 11) != 0) //if checksum offload enable
{
if ((packet[14] & 0xF0) == 0x40) //IP packet
{
ushort cksum;
IPHeaderLength = (ushort)((packet[14] & 0x0F) * 4);
if (packet[23] == 0x06) // TCP packet
{
IPpacket tcpPacket = new IPpacket(IPHeaderLength, IPpacket.PacketType.TCP);
tcpPacket.ReadFromBuffer(packet.ToArray());
cksum = tcpPacket.GetChecksum();
cksum -= 1;
packet[MACHeaderLegth + IPHeaderLength + 16] = (byte)((cksum >> 8) & 0xFF);
packet[MACHeaderLegth + IPHeaderLength + 17] = (byte)((cksum) & 0xFF);
}
else if (packet[23] == 0x11) // UDP packet
{
IPpacket udpPacket = new IPpacket(IPHeaderLength, IPpacket.PacketType.UDP);
udpPacket.ReadFromBuffer(packet.ToArray());
cksum = udpPacket.GetChecksum();
cksum -= 1;
packet[MACHeaderLegth + IPHeaderLength + 6] = (byte)((cksum >> 8) & 0xFF);
packet[MACHeaderLegth + IPHeaderLength + 7] = (byte)((cksum) & 0xFF);
}
}
}
if (Link.IsConnected)
{
var frame = new EthernetFrame(packet.ToArray());
this.Log(LogLevel.Noisy, "Sending packet length {0}", packet.ToArray().Length);
Link.TransmitFrameFromInterface(frame);
}
txBD.WriteBack();
if (txBD.Wrap)
{
registers.TxQueueBaseAddr = txBufferBase;
}
else
{
registers.TxQueueBaseAddr += 8;
}
registers.TxStatus |= 1u << 5; //tx complete
txBD.Fetch(registers.TxQueueBaseAddr);
if (txBD.Used)
{
registers.TxStatus |= 0x01;
if ((registers.InterruptMask & (1u << 3)) == 0)
{
registers.InterruptStatus |= 1u << 3;
interrupt = true;
}
}
if ((registers.InterruptMask & (1u << 7)) == 0)
{
registers.InterruptStatus |= 1u << 7;
interrupt = true;
}
if (interrupt)
{
IRQ.Set();
}
}
}
}
public void ReceiveFrame(EthernetFrame frame)//when data is send to us
{
throw new NotImplementedException();
}
public void ReceiveFrame(EthernetFrame frame)
{
machine.ReportForeignEvent(frame, ReceiveFrameInner);
}
public void Send(EthernetFrame frame, bool sendAsync)
{
Log.Trace(_device.Hostname, $"Sending Ethernet frame to {frame.Data.Header.Dst} from port {Name}");
Send(frame.ToBytes(), sendAsync, false);
}
public void ReceiveFrame(EthernetFrame frame)
{
/*if(machine.ElapsedTime < TimeSpan.FromSeconds(30))
* {
* return;
* }*/
lock (receiveLock)
{
if ((dmaStatus & ReceiveStatus) != 0)
{
queue.Enqueue(frame);
return;
}
if (!packetSent)
{
this.Log(LogLevel.Error, "Dropping - no packets sent.");
return;
}
if (frame.Bytes.Length < 14)
{
this.Log(LogLevel.Error, "DROPPING - packet too short.");
return;
}
if (this.machine.IsPaused)
{
this.Log(LogLevel.Debug, "DROPPING - cpu is halted.");
return;
}
var destinationMac = frame.DestinationMAC;
if (!destinationMac.IsBroadcast && !destinationMac.Equals(MAC))
{
this.Log(LogLevel.Debug, "DROPPING - not for us.");
return;
}
/*
* if((dmaInterruptEnable & (ReceiveStatus)) == 0)
* {
* this.Log(LogLevel.Debug, "DROPPING - rx irq is turned off.");
* return;
* }
*/
this.Log(LogLevel.Noisy, Misc.DumpPacket(frame, false, machine));
if (dmaReceiveDescriptorListAddress < 0x20000000)
{
// TODO: not in ram
this.Log(LogLevel.Error, "DROPPING - descriptor is not valid.");
return;
}
var written = 0;
var first = true;
var bytes = frame.Bytes;
if (!EthernetFrame.CheckCRC(bytes))
{
if (!(crcStrippingForTypeFrames && bytes.Length > 1536) || !(automaticPadCRCStripping && bytes.Length < 1500))
{
this.Log(LogLevel.Info, "Invalid CRC, packet discarded");
return;
}
}
var receiveDescriptor = new RxDescriptor(machine.SystemBus);
receiveDescriptor.Fetch(dmaReceiveDescriptorListAddress);
if (receiveDescriptor.IsUsed)
{
this.Log(LogLevel.Error, "DROPPING - descriptor is used.");
return;
}
this.Log(LogLevel.Noisy, "DESCRIPTOR ADDR1={0:X}, ADDR2={1:X}", receiveDescriptor.Address1, receiveDescriptor.Address2);
while (!receiveDescriptor.IsUsed)
{
if (receiveDescriptor.Address1 < 0x20000000)
{
this.Log(LogLevel.Error, "Descriptor points outside of ram, aborting... This should not happen!");
break;
}
receiveDescriptor.IsUsed = true;
receiveDescriptor.IsFirst = first;
first = false;
var howManyBytes = Math.Min(receiveDescriptor.Buffer1Length, frame.Bytes.Length - written);
var toWriteArray = new byte[howManyBytes];
Array.Copy(bytes, written, toWriteArray, 0, howManyBytes);
machine.SystemBus.WriteBytes(toWriteArray, receiveDescriptor.Address1);
written += howManyBytes;
//write second buffer
if (frame.Bytes.Length - written > 0 && !receiveDescriptor.IsNextDescriptorChained)
{
howManyBytes = Math.Min(receiveDescriptor.Buffer2Length, frame.Bytes.Length - written);
toWriteArray = new byte[howManyBytes];
Array.Copy(bytes, written, toWriteArray, 0, howManyBytes);
machine.SystemBus.WriteBytes(toWriteArray, receiveDescriptor.Address2);
written += howManyBytes;
}
if (frame.Bytes.Length - written <= 0)
{
receiveDescriptor.IsLast = true;
this.NoisyLog("Setting descriptor length to {0}", (uint)frame.Bytes.Length);
receiveDescriptor.FrameLength = (uint)frame.Bytes.Length;
}
this.NoisyLog("Writing descriptor at 0x{6:X}, first={0}, last={1}, written {2} of {3}. next_chained={4}, endofring={5}", receiveDescriptor.IsFirst, receiveDescriptor.IsLast, written, frame.Bytes.Length, receiveDescriptor.IsNextDescriptorChained, receiveDescriptor.IsEndOfRing, dmaReceiveDescriptorListAddress);
receiveDescriptor.WriteBack();
if (!receiveDescriptor.IsNextDescriptorChained)
{
dmaReceiveDescriptorListAddress += 8;
}
else if (receiveDescriptor.IsEndOfRing)
{
dmaReceiveDescriptorListAddress = dmaReceiveDescriptorListAddressBegin;
}
else
{
dmaReceiveDescriptorListAddress = receiveDescriptor.Address2;
}
if (frame.Bytes.Length - written <= 0)
{
if ((dmaInterruptEnable & (ReceiveStatus)) != 0)// receive interrupt
{
dmaStatus |= ReceiveStatus;
IRQ.Set();
}
else
{
this.DebugLog("Exiting but not scheduling an interrupt!");
}
break;
}
receiveDescriptor.Fetch(dmaReceiveDescriptorListAddress);
}
this.DebugLog("Packet of length {0} delivered.", frame.Bytes.Length);
if (written < frame.Bytes.Length)
{
this.Log(LogLevel.Error, "Delivered only {0} from {1} bytes!", written, frame.Bytes.Length);
}
}
}
public IPPacket(EthernetFrame Ef)
{
ReadBuffer(Ef.RawPacket.buffer, Ef.HeaderLength, Ef.RawPacket.size);
}
/// <summary>
/// Is invoked by a connected endpoint to transmit a frame to the parent interface.
/// </summary>
/// <param name="frame">
/// Network frame.
/// </param>
public void ReceiveFrameOnInterface(EthernetFrame frame)
{
SendFrameToInterface(frame);
}
