public static void insert(System.String mac, int offset, byte[] bytes)
{
mac = mac.Replace(":", "").Replace("-", "");
long l = System.Convert.ToInt64(mac, 16);
ArrayHelper.insertLong(bytes, l, offset, 6);
}
/// <summary> Convert captured packet data into an object.</summary>
public static Packet dataToPacket(int linkType, byte[] bytes, Timeval tv)
{
int ethProtocol;
// record the length of the headers associated with this link layer type.
// this length is the offset to the header embedded in the packet.
lLen = LinkLayer.getLinkLayerLength(linkType);
// extract the protocol code for the type of header embedded in the
// link-layer of the packet
int offset = LinkLayer.getProtoOffset(linkType);
if (offset == -1)
{
// if there is no embedded protocol, assume IP?
ethProtocol = EthernetProtocols_Fields.IP;
}
else
{
ethProtocol = ArrayHelper.extractInteger(bytes, offset, EthernetFields_Fields.ETH_CODE_LEN);
}
// try to recognize the ethernet type..
switch (ethProtocol)
{
// arp
case EthernetProtocols_Fields.ARP:
return(new ARPPacket(lLen, bytes, tv));
case EthernetProtocols_Fields.IP:
// ethernet level code is recognized as IP, figure out what kind..
int ipProtocol = IPProtocol.extractProtocol(lLen, bytes);
switch (ipProtocol)
{
// icmp
case IPProtocols_Fields.ICMP: return(new ICMPPacket(lLen, bytes, tv));
// igmp
case IPProtocols_Fields.IGMP: return(new IGMPPacket(lLen, bytes, tv));
// tcp
case IPProtocols_Fields.TCP: return(new TCPPacket(lLen, bytes, tv));
// udp
case IPProtocols_Fields.UDP: return(new UDPPacket(lLen, bytes, tv));
// unidentified ip..
default: return(new IPPacket(lLen, bytes, tv));
}
// ethernet level code not recognized, default to anonymous packet..
//goto default;
default: return(new EthernetPacket(lLen, bytes, tv));
}
}
/// <summary> Fetch the urgent pointer.</summary>
public virtual int getUrgentPointer()
{
if (!_urgentPointerSet)
{
_urgentPointer = ArrayHelper.extractInteger(_bytes, _ipOffset + TCPFields_Fields.TCP_URG_POS, TCPFields_Fields.TCP_URG_LEN);
_urgentPointerSet = true;
}
return(_urgentPointer);
}
/// <summary> Sets the data section of this tcp packet</summary>
/// <param name="data">the data bytes
/// </param>
public virtual void SetData(byte[] data)
{
byte[] headers = ArrayHelper.copy(_bytes, 0, TcpHeaderLength + IpHeaderLength + EthernetHeaderLength);
byte[] newBytes = ArrayHelper.join(headers, data);
this._bytes = newBytes;
TCPHeaderLength = _bytes.Length - data.Length - IpHeaderLength - EthernetHeaderLength;
//update ip total length length
IPTotalLength = IpHeaderLength + TcpHeaderLength + data.Length;
//update also offset and pcap header
OnOffsetChanged();
}
/// <summary> Extract a string describing an IP address from an array of bytes.
///
/// </summary>
/// <param name="offset">the offset of the address data.
/// </param>
/// <param name="bytes">an array of bytes containing the IP address.
/// </param>
/// <returns> a string of the form "255.255.255.255"
/// </returns>
public static System.String extract(int offset, byte[] bytes)
{
return(toString(ArrayHelper.extractInteger(bytes, offset, WIDTH)));
/*
* StringBuffer sa = new StringBuffer();
* for(int i=offset; i<offset + WIDTH; i++) {
* sa.append(0xff & bytes[i]);
* if(i != offset + WIDTH - 1)
* sa.append('.');
* }
* return sa.toString();
*/
}
public static void insert(byte[] bytes, System.String ip, int pos)
{
long val = ipToLong(ip);
ArrayHelper.insertLong(bytes, val, pos, 4);
}
/// <summary> Sets the urgent pointer.
///
/// </summary>
/// <param name="pointer">The urgent pointer value.
/// </param>
public void setUrgentPointer(int pointer)
{
ArrayHelper.insertLong(_bytes, pointer, _ipOffset + TCPFields_Fields.TCP_URG_POS, TCPFields_Fields.TCP_URG_LEN);
_urgentPointerSet = false;
}
public static System.String extract(long mac)
{
byte[] bytes = new byte[6];
ArrayHelper.insertLong(bytes, mac, 0, 6);
return(extract(0, bytes));
}
