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