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