/// <summary> /// Constructor /// </summary> /// <param name="bas"> /// A <see cref="ByteArraySegment"/> /// </param> public RawIPPacket(ByteArraySegment bas) { // Pcap raw link layer format does not have any header // you need to identify whether you have ipv4 or ipv6 // directly by checking the IP version number. // If the first nibble is 0x04, then you have IP v4 // If the first nibble is 0x06, then you have IP v6 // The RawIPPacketProtocol enum has been defined to match this. var firstNibble = bas.Bytes[0] >> 4; Protocol = (RawIPPacketProtocol)firstNibble; header = new ByteArraySegment(bas); header.Length = 0; // parse the encapsulated bytes payloadPacketOrData = new PacketOrByteArraySegment(); switch (Protocol) { case RawIPPacketProtocol.IPv4: payloadPacketOrData.ThePacket = new IPv4Packet(header.EncapsulatedBytes()); break; case RawIPPacketProtocol.IPv6: payloadPacketOrData.ThePacket = new IPv6Packet(header.EncapsulatedBytes()); break; default: throw new System.NotImplementedException("Protocol of " + Protocol + " is not implemented"); } }
/// <summary> /// Initializes a new instance of the <see cref="PacketDotNet.Ieee80211.QosDataFrame"/> class. /// </summary> /// <param name='bas'> /// A <see cref="ByteArraySegment"/> /// </param> public QosDataFrame(ByteArraySegment bas) { log.Debug(""); header = new ByteArraySegment(bas); FrameControl = new FrameControlField(FrameControlBytes); Duration = new DurationField(DurationBytes); SequenceControl = new SequenceControlField(SequenceControlBytes); QosControl = QosControlBytes; ReadAddresses(); header.Length = FrameSize; var availablePayloadLength = GetAvailablePayloadLength(); if (availablePayloadLength > 0) { // if data is protected we have no visibility into it, otherwise it is a LLC packet and we // should parse it if (FrameControl.Protected) { payloadPacketOrData.TheByteArraySegment = header.EncapsulatedBytes(availablePayloadLength); } else { payloadPacketOrData.ThePacket = new LogicalLinkControl(header.EncapsulatedBytes()); } } }
/// <summary> /// Constructor /// </summary> /// <param name="bas"> /// A <see cref="ByteArraySegment"/> /// </param> public UdpPacket(ByteArraySegment bas) { log.DebugFormat("bas {0}", bas.ToString()); // set the header field, header field values are retrieved from this byte array header = new ByteArraySegment(bas); RandomUtils.EnsurePacketLength(this, UdpFields.HeaderLength, header.Length); header.Length = UdpFields.HeaderLength; payloadPacketOrData = new PacketOrByteArraySegment(); // is this packet going to port 7 or 9? if so it might be a WakeOnLan packet const int wakeOnLanPort0 = 7; const int wakeOnLanPort1 = 9; if (DestinationPort.Equals(wakeOnLanPort0) || DestinationPort.Equals(wakeOnLanPort1)) { payloadPacketOrData.ThePacket = new WakeOnLanPacket(header.EncapsulatedBytes()); } else { // store the payload bytes payloadPacketOrData.TheByteArraySegment = header.EncapsulatedBytes(); } }
internal static PacketOrByteArraySegment ParseEncapsulatedBytes(ByteArraySegment Header, EthernetPacketType Type, PosixTimeval Timeval) { ByteArraySegment segment = Header.EncapsulatedBytes(); PacketOrByteArraySegment segment2 = new PacketOrByteArraySegment(); EthernetPacketType type = Type; if (type != EthernetPacketType.IpV4) { if (type == EthernetPacketType.Arp) { segment2.ThePacket = new ARPPacket(segment.Bytes, segment.Offset, Timeval); return(segment2); } if (type == EthernetPacketType.IpV6) { segment2.ThePacket = new IPv6Packet(segment.Bytes, segment.Offset, Timeval); return(segment2); } if (type == EthernetPacketType.PointToPointProtocolOverEthernetSessionStage) { segment2.ThePacket = new PPPoEPacket(segment.Bytes, segment.Offset, Timeval); return(segment2); } if (type == EthernetPacketType.LLDP) { segment2.ThePacket = new LLDPPacket(segment.Bytes, segment.Offset, Timeval); return(segment2); } segment2.TheByteArraySegment = segment; return(segment2); } segment2.ThePacket = new IPv4Packet(segment.Bytes, segment.Offset, Timeval); return(segment2); }
/// <summary> /// Constructor /// </summary> /// <param name="bas"> /// A <see cref="ByteArraySegment"/> /// </param> public Ieee80211MacFrame(ByteArraySegment bas) { // slice off the header portion as our header header = new ByteArraySegment(bas); const int defaultLength = 4; header.Length = defaultLength; FrameControl = new Ieee80211FrameControlField(FrameControlBytes); // determine what kind of frame this is based on the type if (FrameControl.Types == Ieee80211FrameControlField.FrameTypes.ControlRTS) { InnerFrame = new RTSFrame(this, bas); } else if (FrameControl.Types == Ieee80211FrameControlField.FrameTypes.ControlCTS) { InnerFrame = new CTSOrACKFrame(this, bas); } else if (FrameControl.Types == Ieee80211FrameControlField.FrameTypes.ControlACK) { InnerFrame = new CTSOrACKFrame(this, bas); } else { throw new System.NotImplementedException("FrameControl.Types of " + FrameControl.Types + " not handled"); } header.Length = InnerFrame.FrameSize; // store the payload, less the frame check sequence at the end payloadPacketOrData = new PacketOrByteArraySegment(); payloadPacketOrData.TheByteArraySegment = header.EncapsulatedBytes(); payloadPacketOrData.TheByteArraySegment.Length -= Ieee80211MacFields.FrameCheckSequenceLength; }
public InformationReport(ByteArraySegment bas) : this() { TLV ir = new TLV(bas); this.Bytes = bas; VariableAccessSpecification = new VariableAccessSpecification(ir.Bytes); // Decode ListofAccessResult ByteArraySegment list = new ByteArraySegment(bas.EncapsulatedBytes()); tlv_listOfAccessResult = new TLV(list); int totalLen = tlv_listOfAccessResult.Length.Value; byte[] items = tlv_listOfAccessResult.Value.RawBytes; ByteArraySegment bas_items = new ByteArraySegment(items); int pos = 0; ListOfAccessResult = new List <AccessResult>(); while (pos < totalLen) { AccessResult ar = new AccessResult(new TLV(bas_items)); ListOfAccessResult.Add(ar); pos += ar.Bytes.Length; bas_items = bas_items.EncapsulatedBytes(); } }
internal static PacketOrByteArraySegment ParseEncapsulatedBytes(ByteArraySegment Header, NullPacketType Protocol) { // slice off the payload var payload = Header.EncapsulatedBytes(); log.DebugFormat("Protocol: {0}, payload: {1}", Protocol, payload); var payloadPacketOrData = new PacketOrByteArraySegment(); switch (Protocol) { case NullPacketType.IpV4: payloadPacketOrData.ThePacket = new IPv4Packet(payload); break; case NullPacketType.IpV6: case NullPacketType.IpV6_28: case NullPacketType.IpV6_30: payloadPacketOrData.ThePacket = new IPv6Packet(payload); break; case NullPacketType.IPX: default: throw new System.NotImplementedException("Protocol of " + Protocol + " is not implemented"); } return(payloadPacketOrData); }
/// <summary> /// Should always be invoked by other overload method. /// </summary> /// <param name="segs"></param> /// <param name="tpktLen"></param> /// <param name="segLen"></param> private void BuildSegments(ByteArraySegment segs, int tpktLen, int segLen) { if (tpktLen > segLen) { // The begin of next frame packet tcp payload is a successor of THIS segment. NextFrameSegmentLength = tpktLen - segLen; LastSegment = false; segs.Length = segLen; TpktSegments.Add(new TpktSegment(segs, true)); } else if (tpktLen == segLen) { // This packet contains the last segment, it's ready for reasseble NextFrameSegmentLength = 0; LastSegment = true; // The last segment of this frame is the last part of an integreted tpkt packet. segs.Length = segLen; TpktSegments.Add(new TpktSegment(segs, true)); } else // if (tpktLen < segLen) { // Contains a integral TPKT and another one or more segment(s) succeed segs.Length = tpktLen; TpktSegments.Add(new TpktSegment(segs, true)); BuildSegments(segs.EncapsulatedBytes(), false); } }
/// <summary> /// Constructor /// </summary> /// <param name="bas"> /// A <see cref="ByteArraySegment"/> /// </param> public IPv4Packet(ByteArraySegment bas) { log.Debug(""); header = new ByteArraySegment(bas); RandomUtils.EnsurePacketLength(this, IPv4Fields.HeaderLength, header.Length); // TOS? See http://en.wikipedia.org/wiki/TCP_offload_engine if (TotalLength == 0) { TotalLength = header.Length; } // update the header length with the correct value // NOTE: we take care to convert from 32bit words into bytes // NOTE: we do this *after* setting header because we need header to be valid // before we can retrieve the HeaderLength property RandomUtils.EnsurePacketLength(this, HeaderLength * 4, header.Length); header.Length = HeaderLength * 4; log.DebugFormat("IPv4Packet HeaderLength {0}", HeaderLength); log.DebugFormat("header {0}", header); // parse the payload var payload = header.EncapsulatedBytes(PayloadLength); payloadPacketOrData = IpPacket.ParseEncapsulatedBytes(payload, NextHeader, this); }
internal static PacketOrByteArraySegment ParseEncapsulatedBytes(ByteArraySegment Header, IPProtocolType ProtocolType, PosixTimeval Timeval, Packet ParentPacket) { ByteArraySegment segment = Header.EncapsulatedBytes(); PacketOrByteArraySegment segment2 = new PacketOrByteArraySegment(); IPProtocolType type = ProtocolType; if (type == IPProtocolType.ICMP) { segment2.ThePacket = new ICMPv4Packet(segment.Bytes, segment.Offset, Timeval); return(segment2); } if (type != IPProtocolType.TCP) { if (type == IPProtocolType.UDP) { segment2.ThePacket = new UdpPacket(segment.Bytes, segment.Offset, Timeval, ParentPacket); return(segment2); } if (type == IPProtocolType.ICMPV6) { segment2.ThePacket = new ICMPv6Packet(segment.Bytes, segment.Offset, Timeval); return(segment2); } segment2.TheByteArraySegment = segment; return(segment2); } segment2.ThePacket = new TcpPacket(segment.Bytes, segment.Offset, Timeval, ParentPacket); return(segment2); }
/// <summary> /// Constructor /// </summary> /// <param name="bas"> /// A <see cref="ByteArraySegment"/> /// </param> public IPv4Packet(ByteArraySegment bas) { log.Debug(""); header = new ByteArraySegment(bas); // TOS? See http://en.wikipedia.org/wiki/TCP_offload_engine if (TotalLength == 0) { TotalLength = header.Length; } // Check that the TotalLength is valid, at least HeaderMinimumLength long if (TotalLength < HeaderMinimumLength) { throw new System.InvalidOperationException("TotalLength " + TotalLength + " < HeaderMinimumLength " + HeaderMinimumLength); } // update the header length with the correct value // NOTE: we take care to convert from 32bit words into bytes // NOTE: we do this *after* setting header because we need header to be valid // before we can retrieve the HeaderLength property header.Length = HeaderLength * 4; log.DebugFormat("IPv4Packet HeaderLength {0}", HeaderLength); log.DebugFormat("header {0}", header); // parse the payload var payload = header.EncapsulatedBytes(PayloadLength); payloadPacketOrData = IpPacket.ParseEncapsulatedBytes(payload, NextHeader, this); }
internal static PacketOrByteArraySegment ParseEncapsulatedBytes(ByteArraySegment Header, PPPProtocol Protocol) { // slice off the payload var payload = Header.EncapsulatedBytes(); var payloadPacketOrData = new PacketOrByteArraySegment(); switch (Protocol) { case PPPProtocol.IPv4: payloadPacketOrData.ThePacket = new IPv4Packet(payload); break; case PPPProtocol.IPv6: payloadPacketOrData.ThePacket = new IPv6Packet(payload); break; default: throw new System.NotImplementedException("Protocol of " + Protocol + " is not implemented"); } return(payloadPacketOrData); }
/// <summary> /// Constructor /// </summary> /// <param name="bas"> /// A <see cref="ByteArraySegment"/> /// </param> public L2TPPacket(ByteArraySegment bas, Packet ParentPacket) { // slice off the header portion header = new ByteArraySegment(bas); header.Length = L2TPFields.HeaderLength; if (HasLength) { header.Length += L2TPFields.LengthsLength; } if (HasSequence) { header.Length += L2TPFields.NsLength + L2TPFields.NrLength; } if (HasOffset) { header.Length += L2TPFields.OffsetSizeLength + L2TPFields.OffsetPadLength; } var payload = header.EncapsulatedBytes(); try { PayloadPacket = new PPPPacket(payload); PayloadPacket.ParentPacket = this; } catch (Exception) { //it's not a PPP packet, just attach the data payloadPacketOrData.Value.TheByteArraySegment = payload; } this.ParentPacket = ParentPacket; }
internal static PacketOrByteArraySegment ParseEncapsulatedBytes(ByteArraySegment Header, PosixTimeval Timeval) { ByteArraySegment segment = Header.EncapsulatedBytes(); return(new PacketOrByteArraySegment { ThePacket = new PPPPacket(segment.Bytes, segment.Offset, Timeval) }); }
public Channel(ByteArraySegment bas) { bas.Length = valueLength; value = BigEndianBitConverter.Big.ToInt32(bas.ActualBytes(), 0, true); quality = new Quality(bas.EncapsulatedBytes(qualityLength)); bas.Length += qualityLength; }
public LengthFiled(ByteArraySegment bas) { byte[] len = bas.EncapsulatedBytes(1).ActualBytes(); // try first byte to see if single-byte-length // ASN.1 long or uncertain form if ((len[0] & SINGLE_OCTET_FLAG_MASK) > 0) { int len_byteCnt = len[0] & VALID_VALUE_MASK; if (len_byteCnt > 0 && len_byteCnt < VALID_VALUE_MASK) { Type = LengthType.Long; //bas.Length += 1; // skip the first leading byte len = bas.EncapsulatedBytes(len_byteCnt + 1).ActualBytes(); switch (len_byteCnt) { case 1: Value = BigEndianBitConverter.Big.ToUInt8(len, 1); break; case 2: Value = BigEndianBitConverter.Big.ToUInt16(len, 1); break; default: Value = 0; break; } } else if (len_byteCnt == 0) { Type = LengthType.Uncertain; // Uncertain, confirm by the 0x00 0x00 in ValueFiled Value = -1; } else { throw new ArgumentOutOfRangeException("Value", "Bad argument when reading value of length"); } } else { Type = LengthType.Short; Value = len[0] & VALID_VALUE_MASK; } RawBytes = len; }
/// <summary> /// Constructor /// </summary> /// <param name="bas"> /// A <see cref="ByteArraySegment"/> /// </param> public ICMPv4Packet(ByteArraySegment bas) { header = new ByteArraySegment(bas); header.Length = ICMPv4Fields.HeaderLength; // store the payload bytes payloadPacketOrData = new PacketOrByteArraySegment(); payloadPacketOrData.TheByteArraySegment = header.EncapsulatedBytes(); }
/// <summary> /// Constructor /// </summary> /// <param name="bas"> /// A <see cref="ByteArraySegment"/> /// </param> public IGMPv2Packet(ByteArraySegment bas) { // set the header field, header field values are retrieved from this byte array header = new ByteArraySegment(bas); header.Length = UdpFields.HeaderLength; // store the payload bytes payloadPacketOrData = new PacketOrByteArraySegment(); payloadPacketOrData.TheByteArraySegment = header.EncapsulatedBytes(); }
/// <summary> /// Constructor /// </summary> /// <param name="bas"> /// A <see cref="ByteArraySegment"/> /// </param> public IGMPv2Packet(ByteArraySegment bas) { // set the header field, header field values are retrieved from this byte array header = new ByteArraySegment(bas); header.Length = UdpFields.HeaderLength; // store the payload bytes payloadPacketOrData = new PacketOrByteArraySegment(); payloadPacketOrData.TheByteArraySegment = header.EncapsulatedBytes(); }
private static PacketOrByteArraySegment ParseEncapsulatedBytes(ByteArraySegment header, Packet packet, out List <SctpChunk> foundSctpChunks) { foundSctpChunks = new List <SctpChunk>(); PacketOrByteArraySegment byteArraySegment = new PacketOrByteArraySegment(); ByteArraySegment bas = header.EncapsulatedBytes(); if (bas == null || bas.Length == 0) { return new PacketOrByteArraySegment() { ByteArraySegment = bas } } ; for (; bas.Length > SctpChunkFields.HeaderLength; bas = bas.EncapsulatedBytes()) { SctpChunk sctpChunk; switch ((SctpChunkType)bas.Bytes[bas.Offset]) { case SctpChunkType.Data: sctpChunk = (SctpChunk) new SctpDataChunk(bas, packet); break; case SctpChunkType.Sack: sctpChunk = (SctpChunk) new SctpSackChunk(bas, packet); break; default: sctpChunk = (SctpChunk) new SctpUnsupportedChunk(bas, packet); break; } foundSctpChunks.Insert(0, sctpChunk); bas.Length = (int)sctpChunk.Length; } if (foundSctpChunks.Count == 1) { byteArraySegment.Packet = (Packet)foundSctpChunks.Single <SctpChunk>(); return(byteArraySegment); } byteArraySegment.ByteArraySegment = header.EncapsulatedBytes(); return(byteArraySegment); }
/// <summary> /// Initializes a new instance of the <see cref="PacketDotNet.Ieee80211.DataDataFrame"/> class. /// </summary> /// <param name='bas'> /// Bas. /// </param> public DataDataFrame (ByteArraySegment bas) { header = new ByteArraySegment (bas); FrameControl = new FrameControlField (FrameControlBytes); Duration = new DurationField (DurationBytes); SequenceControl = new SequenceControlField (SequenceControlBytes); ReadAddresses (); //must do this after reading FrameControl header.Length = FrameSize; var availablePayloadLength = GetAvailablePayloadLength(); if (availablePayloadLength > SNAPFields.HeaderLength) { payloadPacketOrData.ThePacket = new SNAPPacket(header.EncapsulatedBytes(availablePayloadLength)); } else { payloadPacketOrData.TheByteArraySegment = header.EncapsulatedBytes(availablePayloadLength); } }
/// <summary> /// Constructor /// </summary> /// <param name="bas"></param> public DrdaPacket(ByteArraySegment bas) { log.Debug(""); // set the header field, header field values are retrieved from this byte array header = new ByteArraySegment(bas); // store the payload bytes payloadPacketOrData = new PacketOrByteArraySegment(); payloadPacketOrData.TheByteArraySegment = header.EncapsulatedBytes(); }
public SavPdu(TLV tlv) : this() { this.Bytes = tlv.Bytes; ByteArraySegment pdu = tlv.Value.Bytes; pdu.Length = 0; TLV tmp = new TLV(pdu.EncapsulatedBytes()); pdu.Length += tmp.Bytes.Length; noASDU = new NoAsdu(tmp); tmp = new TLV(pdu.EncapsulatedBytes()); if (IsSecurity(tmp)) { security = null; pdu.Length += tmp.Bytes.Length; tmp = new TLV(pdu.EncapsulatedBytes()); } //ASDU = new Asdu() if (Asdu.IsAsduSeq(tmp) && noASDU.Value > 0) { int cnt = noASDU.Value; tmp = new TLV(pdu.EncapsulatedBytes()); for (int i = 0; i < cnt; i++) { //tmp = new TLV(pdu.EncapsulatedBytes()); Asdu asdu = new Asdu(tmp.Value.Bytes); pdu.Length += tmp.Bytes.Length; ASDU.Add(asdu); } } else { throw new Exception("Bad SV packet"); } }
/// <summary> /// Constructor /// </summary> /// <param name="bas"> /// A <see cref="ByteArraySegment"/> /// </param> public ICMPv4Packet(ByteArraySegment bas) { log.Debug(""); header = new ByteArraySegment(bas); RandomUtils.EnsurePacketLength(this, ICMPv4Fields.HeaderLength, header.Length); header.Length = ICMPv4Fields.HeaderLength; // store the payload bytes payloadPacketOrData = new PacketOrByteArraySegment(); payloadPacketOrData.TheByteArraySegment = header.EncapsulatedBytes(); }
/// <summary> /// Constructor /// </summary> /// <param name="bas"> /// A <see cref="ByteArraySegment"/> /// </param> public UdpPacket(ByteArraySegment bas) { log.DebugFormat("bas {0}", bas.ToString()); // set the header field, header field values are retrieved from this byte array header = new ByteArraySegment(bas); header.Length = UdpFields.HeaderLength; // store the payload bytes payloadPacketOrData = new PacketOrByteArraySegment(); payloadPacketOrData.TheByteArraySegment = header.EncapsulatedBytes(); }
internal static PacketOrByteArraySegment ParseEncapsulatedBytes(ByteArraySegment Header) { // slice off the payload var payload = Header.EncapsulatedBytes(); var payloadPacketOrData = new PacketOrByteArraySegment(); // we assume that we have a PPPPacket as the payload payloadPacketOrData.ThePacket = new PPPPacket(payload); return(payloadPacketOrData); }
/// <summary> /// Constructor /// </summary> /// <param name="bas"> /// A <see cref="ByteArraySegment"/> /// </param> public TcpPacket(ByteArraySegment bas) { // set the header field, header field values are retrieved from this byte array header = new ByteArraySegment(bas); // NOTE: we update the Length field AFTER the header field because // we need the header to be valid to retrieve the value of DataOffset header.Length = DataOffset * 4; // store the payload bytes payloadPacketOrData = new PacketOrByteArraySegment(); payloadPacketOrData.TheByteArraySegment = header.EncapsulatedBytes(); }
/// <summary> /// Constructor /// </summary> /// <param name="bas"> /// A <see cref="ByteArraySegment" /> /// </param> public RawIPPacket(ByteArraySegment bas) { // Pcap raw link layer format does not have any header // you need to identify whether you have ipv4 or ipv6 // directly by checking the IP version number. // If the first nibble is 0x04, then you have IP v4 // If the first nibble is 0x06, then you have IP v6 // The RawIPPacketProtocol enum has been defined to match this. var firstNibble = bas.Bytes[0] >> 4; Protocol = (RawIPPacketProtocol)firstNibble; Header = new ByteArraySegment(bas) { Length = 0 }; // parse the encapsulated bytes PayloadPacketOrData = new Lazy <PacketOrByteArraySegment>(() => { var result = new PacketOrByteArraySegment(); switch (Protocol) { case RawIPPacketProtocol.IPv4: result.Packet = new IPv4Packet(Header.EncapsulatedBytes()); break; case RawIPPacketProtocol.IPv6: result.Packet = new IPv6Packet(Header.EncapsulatedBytes()); break; default: throw new NotImplementedException("Protocol of " + Protocol + " is not implemented"); } return(result); }, LazyThreadSafetyMode.PublicationOnly); }
public OsiSessionPacket(byte[] rawData, Packet parent) { this.ParentPacket = parent; int offset = 0; header = new ByteArraySegment(rawData); PduType = (PduIdentifier)rawData[offset]; if (PduType == PduIdentifier.GiveToken) { offset += OsiSessionFileds.PiLength; Pdu = new OsiSessionPdu(); Spdu = new OsiSessionPdu(); Pdu.Length = (int)rawData[offset]; offset += OsiSessionFileds.PduLiLength; if (Pdu.Length > 0) { Pdu.PI = rawData[offset]; offset += 1; rawData.CopyTo(Pdu.Value, offset); } SpduType = (SpduIdentifier)rawData[offset]; if (SpduType == SpduIdentifier.DataTransfer) { offset += OsiSessionFileds.SpiLength; Spdu.Length = (int)rawData[offset]; offset += OsiSessionFileds.SpduLiLength; if (SpduLength > 0) { Spdu = new OsiSessionPdu(); Spdu.PI = rawData[offset]; offset += 1; rawData.CopyTo(Spdu.Value, offset); } header = new ByteArraySegment(rawData); header.Length = OsiSessionFileds.PiLength + OsiSessionFileds.PduLiLength + PduLength + OsiSessionFileds.SpduLiLength + OsiSessionFileds.SpiLength + SpduLength; var payload = header.EncapsulatedBytes(); payloadPacketOrData = new PacketOrByteArraySegment(); payloadPacketOrData.ThePacket = new OsiPresentationPacket(payload, this); parent.PayloadPacket = this; } } }
/// <summary> /// Used by the EthernetPacket constructor. Located here because the LinuxSLL constructor /// also needs to perform the same operations as it contains an ethernet type /// </summary> /// <param name="Header"> /// A <see cref="ByteArraySegment"/> /// </param> /// <param name="Type"> /// A <see cref="EthernetPacketType"/> /// </param> /// <returns> /// A <see cref="PacketOrByteArraySegment"/> /// </returns> internal static PacketOrByteArraySegment ParseEncapsulatedBytes(ByteArraySegment Header, EthernetPacketType Type) { // slice off the payload var payload = Header.EncapsulatedBytes(); log.DebugFormat("payload {0}", payload.ToString()); var payloadPacketOrData = new PacketOrByteArraySegment(); // parse the encapsulated bytes switch (Type) { case EthernetPacketType.IpV4: payloadPacketOrData.ThePacket = new IPv4Packet(payload); break; case EthernetPacketType.IpV6: payloadPacketOrData.ThePacket = new IPv6Packet(payload); break; case EthernetPacketType.Arp: payloadPacketOrData.ThePacket = new ARPPacket(payload); break; case EthernetPacketType.LLDP: payloadPacketOrData.ThePacket = new LLDPPacket(payload); break; case EthernetPacketType.PointToPointProtocolOverEthernetSessionStage: payloadPacketOrData.ThePacket = new PPPoEPacket(payload); break; case EthernetPacketType.WakeOnLan: payloadPacketOrData.ThePacket = new WakeOnLanPacket(payload); break; case EthernetPacketType.VLanTaggedFrame: payloadPacketOrData.ThePacket = new Ieee8021QPacket(payload); break; default: // consider the sub-packet to be a byte array payloadPacketOrData.TheByteArraySegment = payload; break; } return(payloadPacketOrData); }
/// <summary> /// Constructor /// </summary> /// <param name="bas"></param> public DrdaPacket(ByteArraySegment bas) { Log.Debug(""); // set the header field, header field values are retrieved from this byte array Header = new ByteArraySegment(bas); // store the payload bytes PayloadPacketOrData = new Lazy <PacketOrByteArraySegment>(() => { var result = new PacketOrByteArraySegment { ByteArraySegment = Header.EncapsulatedBytes() }; return(result); }, LazyThreadSafetyMode.PublicationOnly); }
/// <summary> /// Constructor /// </summary> /// <param name="bas"></param> public DrdaPacket(ByteArraySegment bas) { log.Debug(""); // set the header field, header field values are retrieved from this byte array header = new ByteArraySegment(bas); // store the payload bytes payloadPacketOrData = new Lazy <PacketOrByteArraySegment>(() => { var result = new PacketOrByteArraySegment { TheByteArraySegment = header.EncapsulatedBytes() }; return(result); }); }
/// <summary> /// Initializes a new instance of the <see cref="PacketDotNet.Ieee80211.QosDataFrame"/> class. /// </summary> /// <param name='bas'> /// A <see cref="ByteArraySegment"/> /// </param> public QosDataFrame (ByteArraySegment bas) { header = new ByteArraySegment (bas); FrameControl = new FrameControlField (FrameControlBytes); Duration = new DurationField (DurationBytes); SequenceControl = new SequenceControlField (SequenceControlBytes); QosControl = QosControlBytes; ReadAddresses (); header.Length = FrameSize; var availablePayloadLength = GetAvailablePayloadLength(); if(availablePayloadLength > 0) { payloadPacketOrData.TheByteArraySegment = header.EncapsulatedBytes (availablePayloadLength); } }
/// <summary> /// Used by the Ieee80211PpiPacket constructor. /// </summary> /// <param name="header"> /// A <see cref="ByteArraySegment"/> /// </param> /// <param name="commonField"> /// The <see cref="PpiCommon"/> object in the PPI packet or null if not available /// </param> /// <returns> /// A <see cref="PacketOrByteArraySegment"/> /// </returns> internal static PacketOrByteArraySegment ParseEncapsulatedBytes (ByteArraySegment header, PpiCommon commonField) { // slice off the payload var payload = header.EncapsulatedBytes (); var payloadPacketOrData = new PacketOrByteArraySegment (); MacFrame frame = null; if (commonField != null) { bool fcsPresent = ((commonField.Flags & PpiCommon.CommonFlags.FcsIncludedInFrame) == PpiCommon.CommonFlags.FcsIncludedInFrame); if (fcsPresent) { frame = MacFrame.ParsePacketWithFcs (payload); } else { frame = MacFrame.ParsePacket (payload); } } else { frame = MacFrame.ParsePacket (payload); } if (frame == null) { payloadPacketOrData.TheByteArraySegment = payload; } else { payloadPacketOrData.ThePacket = frame; } return payloadPacketOrData; }
internal static PacketOrByteArraySegment ParseEncapsulatedBytes(ByteArraySegment Header, PosixTimeval Timeval) { ByteArraySegment segment = Header.EncapsulatedBytes(); return new PacketOrByteArraySegment { ThePacket = new PPPPacket(segment.Bytes, segment.Offset, Timeval) }; }
internal static PacketOrByteArraySegment ParseEncapsulatedBytes(ByteArraySegment Header, EthernetPacketType Type, PosixTimeval Timeval) { ByteArraySegment segment = Header.EncapsulatedBytes(); PacketOrByteArraySegment segment2 = new PacketOrByteArraySegment(); EthernetPacketType type = Type; if (type != EthernetPacketType.IpV4) { if (type == EthernetPacketType.Arp) { segment2.ThePacket = new ARPPacket(segment.Bytes, segment.Offset, Timeval); return segment2; } if (type == EthernetPacketType.IpV6) { segment2.ThePacket = new IPv6Packet(segment.Bytes, segment.Offset, Timeval); return segment2; } if (type == EthernetPacketType.PointToPointProtocolOverEthernetSessionStage) { segment2.ThePacket = new PPPoEPacket(segment.Bytes, segment.Offset, Timeval); return segment2; } if (type == EthernetPacketType.LLDP) { segment2.ThePacket = new LLDPPacket(segment.Bytes, segment.Offset, Timeval); return segment2; } segment2.TheByteArraySegment = segment; return segment2; } segment2.ThePacket = new IPv4Packet(segment.Bytes, segment.Offset, Timeval); return segment2; }
/// <summary> /// Constructor /// </summary> /// <param name="bas"> /// A <see cref="ByteArraySegment"/> /// </param> public ActionFrame (ByteArraySegment bas) { header = new ByteArraySegment (bas); FrameControl = new FrameControlField (FrameControlBytes); Duration = new DurationField (DurationBytes); DestinationAddress = GetAddress (0); SourceAddress = GetAddress (1); BssId = GetAddress (2); SequenceControl = new SequenceControlField (SequenceControlBytes); header.Length = FrameSize; var availablePayloadLength = GetAvailablePayloadLength(); if(availablePayloadLength > 0) { payloadPacketOrData.TheByteArraySegment = header.EncapsulatedBytes (availablePayloadLength); } }