请问怎么用socket指定想要接收的IP发送的数据包

Question

目前我的代码是
 /// <param name="socketType">套接字类型</param>
        public void CreateSocket(SocketType socketType)
        {
            Socket = new Socket(AddressFamily.InterNetwork, socketType, ProtocolType.IP);
            Socket.Bind(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 0));
            Socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.HeaderIncluded, true);
            byte[] byteIn = new byte[4] { 1, 0, 0, 0 };
            byte[] byteOut = new byte[4];
            try
            {
                Socket.IOControl(IOControlCode.ReceiveAll, byteIn, byteOut);
            }
            catch (SocketException)
            {
                byteIn = new byte[] { 0, 0, 0, 0 };
                Socket.IOControl(IOControlCode.ReceiveAll, byteIn, byteOut);
            }
        }//异步接收
        public static byte[] ReceiveData(Socket socket){    
            ReceiveObject state = new ReceiveObject() { Client = socket };    
            socket.BeginReceive(state.Buffer, 0, state.Buffer.Length, SocketFlags.None, new AsyncCallback(ReadCallback), state);    
            state.ReceiveDone.WaitOne(1000 * 10); // 10秒超时   
            byte[] result = state.Stream.ToArray();
            int xx = result.Length;
            return result;
        }        /// 同步接收对象/// </summary>
        private class ReceiveObject{    
            public Socket Client;    
            public byte[] Buffer = new byte[4096];    
            public System.IO.MemoryStream Stream = new System.IO.MemoryStream();    
            public System.Threading.ManualResetEvent ReceiveDone = new System.Threading.ManualResetEvent(false);
        }        /// read回调
        /// </summary>/// <param name="ar"></param>
        private static void ReadCallback(IAsyncResult ar){    
            ReceiveObject state = (ReceiveObject)ar.AsyncState;    
            int bytesRead = state.Client.EndReceive(ar);    
            if (bytesRead > 0)    {        
                try        {            
                    state.Stream.Write(state.Buffer, 0, bytesRead);            
                    state.Client.BeginReceive(state.Buffer, 0, state.Buffer.Length, SocketFlags.None, new AsyncCallback(ReadCallback), state);        
                }        catch (Exception ex)        
                {            
                    //Log.Error(ex.Message);            
                    state.ReceiveDone.Set();        
                }    
            }    else    {        
                state.ReceiveDone.Set();    
            }
        }
这样是可以接收到数据包，问题我不知道接收到的数据包是哪个IP发送过来的。所以我希望做成能指定接收哪个IP发送过来的数据包，请各位指教一下。

Answer 1

你的问题是:接收指定IP的数据包,其他IP都要过滤吧,那就用防火墙来搞吧

Answer 2

可以识别,识别后,如果不是你指定的IP,那就不处理就行
socket.RemoteEndPoint

Answer 3

接收到数据包的那个socket的RemoteEndPoint.IpAddress包含了发数据包的IP地址，可以用这个来判断

Answer 4

我等会测试一下，不过我在想，如果我要接收其它指定IP的数据包，是不是应该使用客户段的socket代码来执行，而不是使用服务器端的代码来执行，我现在写的好像是服务器端的代码

Answer 5

不好意思，能告诉我RemoteEndPoint.IpAddress这个判断应该放在我写的程序的哪里吗？我放进去运行提示出错，说没有套字，但我一开始在createsocket里面就应该建立了。

Answer 6

找到一种方法，在获取数据的时候分析IPHeader，看IP是否属于需要的，不需要的就不取

Answer 7

问题解决了，使用的是client段的获取方式，用client的可以指定IP，代码大概如下public void SendMessage()
        {
            ASCII = Encoding.ASCII;
            // 构造用于发送的 字节缓冲.
            Byte[] sendBytes = ASCII.GetBytes(SEND_MESSAGE);            // 构造用于接收的 字节缓冲.
            Byte[] recvBytes = new Byte[256];            // IP地址.
            IPAddress localAddr = IPAddress.Parse("192.168.19.81");            // 接入点.
            IPEndPoint ephost = new IPEndPoint(localAddr, PORT);
            // 第一个参数：AddressFamily = 指定 Socket 类的实例可以使用的寻址方案。
            //     Unspecified 未指定地址族。
            //     InterNetwork IP 版本 4 的地址。
            //     InterNetworkV6 IP 版本 6 的地址。
            //
            // 第二个参数：SocketType = 指定 Socket 类的实例表示的套接字类型。
            //     Stream 一个套接字类型，支持可靠、双向、基于连接的字节流，而不重复数据，也不保留边界。
            //            此类型的 Socket 与单个对方主机通信，并且在通信开始之前需要建立远程主机连接。
            //            此套接字类型使用传输控制协议 (Tcp)，AddressFamily 可以是 InterNetwork，也可以是 InterNetworkV6。
            //
            // 第三个参数：ProtocolType = 指定 Socket 类支持的协议。
            //     Tcp 传输控制协议 (TCP)。
            Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);            try
            {
                // 尝试连接主机.
                s.Connect(ephost);
                //Console.WriteLine("向服务器发送到了:{0}", SEND_MESSAGE);                // 向主机发送数据.
               // s.Send(sendBytes, sendBytes.Length, SocketFlags.None);                // 接收服务器的应答.
                Int32 bytes = s.Receive(recvBytes, recvBytes.Length, SocketFlags.None);
                                StringBuilder buff = new StringBuilder();//                while (bytes > 0)
//                {
                    // 将缓冲的字节数组，装换为字符串.
//                    String str = ASCII.GetString(recvBytes, 0, bytes);
                String str = "";
                for (int i = 0; i < recvBytes.Length; i++)
                {
                   str = str + recvBytes[i];                    
                }                int iCount = 0;                iCount = int.Parse(str.Substring(13, 6)) ;
                    // 加入字符串缓存
                    buff.Append(str);
                    // 再次接受，看看后面还有没有数据.
                    //bytes = s.Receive(recvBytes, recvBytes.Length, SocketFlags.None);
//                }                textBox1.Text = iCount.ToString();            }
            catch (Exception ex)
            {
                MessageBox.Show("连接/发送/接收过程中，发生了错误！");
                MessageBox.Show(ex.Message);
                //Console.WriteLine("连接/发送/接收过程中，发生了错误！");
                //Console.WriteLine(ex.Message);
                //Console.WriteLine(ex.StackTrace);
            }
            finally
            {
                s.Close();
            }
        }