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); }