[Mono-bugs] [Bug 60620][Nor] Changed - temp_srcport = *(short *)&fixed_buf[e.HeaderLength];

bugzilla-daemon@bugzilla.ximian.com bugzilla-daemon@bugzilla.ximian.com
Sat, 16 Apr 2005 17:21:06 -0400 (EDT)


Please do not reply to this email- if you want to comment on the bug, go to the
URL shown below and enter your comments there.

Changed by miguel@ximian.com.

http://bugzilla.ximian.com/show_bug.cgi?id=60620

--- shadow/60620	2004-12-10 22:20:07.000000000 -0500
+++ shadow/60620.tmp.25293	2005-04-16 17:21:06.000000000 -0400
@@ -47,6 +47,292 @@
 ------- Additional Comments From miguel@ximian.com  2004-07-26 12:00 -------
 This is a simple bug of our metric to determine if something is
 fixed or not;  I do not think it is quite finished, it has only
 a few common hard-coded values, and does not really do the semantic
 work necessary.
 
+
+------- Additional Comments From miguel@ximian.com  2005-04-16 17:21 -------
+//This file contains the RawSocket class.  The goal of this class is
+to have a generic packet
+//sniffing kind of class that fires events when an incoming IP packet
+is received.  The event
+//gives the user access to everything contained in the IP packet and
+hopefully makes creating
+//your own packet sniffer quite easy.  The event args returned with
+the event give the user of
+//the class access to things like the from and to IP address, ports,
+protocol, etc. and even the
+//contents of the message in the form of a byte array.
+
+
+namespace ReceiveAll
+{
+	using System;
+	using System.Net;
+	using System.Net.Sockets;
+	using System.Runtime.InteropServices;
+
+	
+	[StructLayout(LayoutKind.Explicit)]
+	public struct IPHeader
+	{
+		[FieldOffset(0)] public byte    ip_verlen; //IP version and IP
+Header length Combined
+		[FieldOffset(1)] public byte    ip_tos; //Type of Service
+		[FieldOffset(2)] public ushort  ip_totallength; //Total Packet Length
+		[FieldOffset(4)] public ushort  ip_id; //Unique ID
+		[FieldOffset(6)] public ushort  ip_offset; //Flags and Offset
+		[FieldOffset(8)] public byte    ip_ttl; //Time To Live
+		[FieldOffset(9)] public byte    ip_protocol; //Protocol (TCP, UDP,
+ICMP, Etc.)
+		[FieldOffset(10)] public ushort ip_checksum; //IP Header Checksum
+		[FieldOffset(12)] public uint   ip_srcaddr; //Source IP Address
+		[FieldOffset(16)] public uint   ip_destaddr; //Destination IP Address
+	}
+
+	public class RawSocket
+	{
+		private bool error_occurred;
+		public bool KeepRunning;
+		private static int len_receive_buf;
+		byte [] receive_buf_bytes;
+		private Socket socket = null; 
+
+		public RawSocket()
+		{
+			error_occurred=false;
+			len_receive_buf = 4096;
+			receive_buf_bytes = new byte[len_receive_buf];
+		}
+		
+		public void CreateAndBindSocket(string IP)
+		{
+			socket = new Socket(AddressFamily.InterNetwork, SocketType.Raw,
+ProtocolType.IP);
+			socket.Blocking = false;
+			socket.Bind(new IPEndPoint(IPAddress.Parse(IP), 0));
+
+			if (SetSocketOption()==false) error_occurred=true;
+		}
+
+		public void Shutdown()
+		{
+			if(socket != null)
+			{
+				socket.Shutdown(SocketShutdown.Both);
+				socket.Close();
+			}
+		}
+
+		private bool SetSocketOption()
+		{
+			bool ret_value = true;
+			try
+			{
+				socket.SetSocketOption(SocketOptionLevel.IP,
+SocketOptionName.HeaderIncluded, 1);
+    
+				byte []IN = new byte[4]{1, 0, 0, 0};
+				byte []OUT = new byte[4];
+				int SIO_RCVALL = unchecked((int)0x98000001);
+				int ret_code = socket.IOControl(SIO_RCVALL, IN, OUT);
+				ret_code = OUT[0] + OUT[1] + OUT[2] + OUT[3];
+				if(ret_code != 0) ret_value = false;
+			}
+			catch(SocketException)
+			{
+				ret_value = false;
+			}
+			return ret_value;
+		}
+
+		public bool ErrorOccurred
+		{
+			get
+			{
+				return error_occurred;
+			}
+		}
+
+		unsafe private void Receive(byte [] buf, int len)
+		{
+			byte temp_protocol=0;
+			uint temp_version=0;
+			uint temp_ip_srcaddr=0;
+			uint temp_ip_destaddr=0;
+			short temp_srcport=0;
+			short temp_dstport=0;
+            IPAddress temp_ip;
+			
+			PacketArrivedEventArgs e=new PacketArrivedEventArgs();
+
+			fixed(byte *fixed_buf = buf)
+			{
+				IPHeader * head = (IPHeader *) fixed_buf;
+				e.HeaderLength=(uint)(head->ip_verlen & 0x0F) << 2;
+				
+				temp_protocol = head->ip_protocol;
+				switch(temp_protocol)
+				{
+					case 1: e.Protocol="ICMP:";     break;
+					case 2: e.Protocol="IGMP:";     break;
+					case 6: e.Protocol="TCP:";      break;
+					case 17: e.Protocol="UDP:";     break;
+				    default: e.Protocol= "UNKNOWN"; break;
+				}
+
+				temp_version =(uint)(head->ip_verlen & 0xF0) >> 4;
+				e.IPVersion = temp_version.ToString();
+
+                temp_ip_srcaddr = head->ip_srcaddr;
+				temp_ip_destaddr = head->ip_destaddr;
+				temp_ip = new IPAddress(temp_ip_srcaddr);
+				e.OriginationAddress =temp_ip.ToString();
+				temp_ip = new IPAddress(temp_ip_destaddr);
+				e.DestinationAddress = temp_ip.ToString();
+
+				temp_srcport = *(short *)&fixed_buf[e.HeaderLength];
+				temp_dstport = *(short *)&fixed_buf[e.HeaderLength+2];
+			
+e.OriginationPort=IPAddress.NetworkToHostOrder(temp_srcport).ToString();
+			
+e.DestinationPort=IPAddress.NetworkToHostOrder(temp_dstport).ToString();
+
+				e.PacketLength =(uint)len;
+				e.MessageLength =(uint)len - e.HeaderLength;
+
+				e.ReceiveBuffer=buf;
+				Array.Copy(buf,0,e.IPHeaderBuffer,0,(int)e.HeaderLength);
+			
+Array.Copy(buf,(int)e.HeaderLength,e.MessageBuffer,0,(int)e.MessageLength);
+ 			}
+			
+			OnPacketArrival(e);
+		}
+  
+		public void Run() 
+		{
+			IAsyncResult ar = socket.BeginReceive(receive_buf_bytes, 0,
+len_receive_buf, SocketFlags.None, new AsyncCallback(CallReceive), this);
+		}
+
+		private void CallReceive(IAsyncResult ar)
+		{
+			try
+			{
+				int received_bytes;
+				received_bytes = socket.EndReceive(ar); 
+				Receive(receive_buf_bytes, received_bytes);
+			}
+			catch {} //ignore all network errors ;)
+			if (KeepRunning) Run();
+		}
+
+		public class PacketArrivedEventArgs : EventArgs 
+		{
+			public PacketArrivedEventArgs() 
+			{
+				this.protocol = "";
+				this.destination_port  = "";
+				this.origination_port  = "";
+				this.destination_address  = "";
+				this.origination_address  = "";
+				this.ip_version  = "";
+
+				this.total_packet_length =0;
+				this.message_length =0;
+				this.header_length =0;
+
+				this.receive_buf_bytes=new byte[len_receive_buf];
+				this.ip_header_bytes=new byte[len_receive_buf];
+				this.message_bytes=new byte[len_receive_buf];
+			}
+
+			public string Protocol
+			{
+				get {return protocol;}
+				set {protocol=value;}
+			}
+			public string DestinationPort
+			{
+				get {return destination_port;}
+				set {destination_port=value;}
+			}
+			public string OriginationPort
+			{
+				get {return origination_port;}
+				set {origination_port=value;}
+			}
+			public string DestinationAddress
+			{
+				get {return destination_address;}
+				set {destination_address=value;}
+			}
+			public string OriginationAddress
+			{
+				get {return origination_address;}
+				set {origination_address=value;}
+			}
+			public string IPVersion
+			{
+				get {return ip_version;}
+				set {ip_version=value;}
+			}
+			public uint PacketLength
+			{
+				get {return total_packet_length;}
+				set {total_packet_length=value;}
+			}
+			public uint MessageLength
+			{
+				get {return message_length;}
+				set {message_length=value;}
+			}
+			public uint HeaderLength
+			{
+				get {return header_length;}
+				set {header_length=value;}
+			}
+			public byte [] ReceiveBuffer
+			{
+				get {return receive_buf_bytes;}
+				set {receive_buf_bytes=value;}
+			}
+			public byte [] IPHeaderBuffer
+			{
+				get {return ip_header_bytes;}
+				set {ip_header_bytes=value;}
+			}
+			public byte [] MessageBuffer
+			{
+				get {return message_bytes;}
+				set {message_bytes=value;}
+			}
+			private string protocol;
+			private string destination_port;
+			private string origination_port;
+			private string destination_address;
+			private string origination_address;
+			private string ip_version;
+			private uint total_packet_length;
+			private uint message_length;
+			private uint header_length;
+			private byte []receive_buf_bytes = null;
+			private byte []ip_header_bytes = null;
+			private byte []message_bytes = null;
+		}
+
+		public delegate void PacketArrivedEventHandler(
+			Object sender, PacketArrivedEventArgs args);
+
+		public event PacketArrivedEventHandler PacketArrival;
+
+		protected virtual void OnPacketArrival(PacketArrivedEventArgs e) 
+		{
+			if (PacketArrival != null) 
+			{
+				PacketArrival(this, e);
+			}
+		}
+	}
+}