Socket基础编程
本节介绍如何使用基础Socket实现TCP通信。
(1)Socket详细介绍:
Socket的英文原义是“孔”或“插座”。通常称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。在Internet上的主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的服务。Socket正如其英文原意那样，象一个多孔插座。
Socket的发展:
七十年代中，美国国防部高研署(DARPA)将TCP/IP的软件提供给加利福尼亚大学Berkeley分校后，TCP/IP很快被集成到Unix中，同时出现了许多成熟的TCP/IP应用程序接口(API)。这个API称为Socket接口。 今天，SOCKET接口是TCP/IP网络最为 通用的API，也是在INTERNET上进行应用开发最为通用的API。
九十年代初，由Microsoft联合了其他几家公司共同制定了一套 WINDOWS下的网络编程接口，即Windows Sockets规范（简称WinSock）。它是Berkeley Sockets的重要扩充，主要是增加了一些异步函数，并增加了符合 Windows 消息驱动特性的网络事件异步选择机制。
WinSock:
Windows Sockets规范是一套开放的、支持多种协议的 Windows下的网络编程接口。 Windows Socket规范1.1版，只支持TCP/IP协议。 Windows Socket规范2.0版，支持多种协议。
(2)套接字分类:
根据不同的应用协议的需要，套接字分为字节流套接字(stream Socket)，数据报套接字(datagram Socket)，原始套接字（raw Socket）:
1.字节流套接字（stream Socket） 流套接字用于提供面向连接、可靠的数据传输服务。 该服务将保证数据能够实现无差错、无重复发送，并按顺序接收。 流套接字之所以能够实现可靠的数据服务，原因在于其使用了传输控制协议，即TCP（The Transmission Control Protocol）协议。 2.数据报套接字（datagram Socket） 数据报套接字提供了一种无连接的服务。 该服务并不能保证数据传输的可靠性，数据有可能在传输过程中丢失或出现数据重复，且无法保证顺序地接收到数据。 数据报套接字使用UDP（User Datagram Protocol）协议进行数据的传输。 由于数据报套接字不能保证数据传输的可靠性，对于有可能出现的数据丢失情况，需要在程序中做相应的处理。 3.原始套接字（raw Socket） 原始套接字与标准套接字（标准套接字指的是前面介绍的流套接字和数据报套接字）的区别在于： 原始套接字可以读写内核没有处理的IP数据包，而流套接字只能读取TCP协议的数据，数据报套接字只能读取UDP协议的数据。 因此，如果要访问其他协议发送数据必须使用原始套接字。 原始套接字允许对底层协议如IP或ICMP进行直接访问，功能强大但使用较为不便，主要用于一些协议的开发。
根据套接字的不同，套接字编程又分为:面向连接，无连接，原始套接字编程。
套接字的TCP通信流程:
TCP是面向连接的，程序运行后，服务器有一个Socket一直处于侦听状态，客户端Socket与服务器通信之前必须首先发起连接请求，服务器上负责侦听的Socket接受请求并另外创建一个Socket与客户端通信息，自己则继续侦听新的请求。
(3)Socket编程实例:
1)面向连接-基于TCP:
服务器端(带窗体):
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
//添加的引用
using System.Net;
using System.Net.Sockets;
using System.Threading;
namespace TCPServer
{
public partial class SocketTcpServerForm : Form
{
private int port;
Socket tcpSocket=null;
List<Socket> clientSockets;
public SocketTcpServerForm()
{
InitializeComponent();
CheckForIllegalCrossThreadCalls = false;
port = 10000;//默认使用端口号10000
portTextBox.Text = port.ToString();
clientSockets= new List<Socket>();
}
private void Form1_Load(object sender, EventArgs e)
{
}
private void portTextBox_TextChanged(object sender, EventArgs e)
{
}
private void listenButton_Click(object sender, EventArgs e)
{
string portString = portTextBox.Text;
port = int.Parse(portString);
IPEndPoint ipep = new IPEndPoint(IPAddress.Any,port);
tcpSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
tcpSocket.Bind(ipep);
tcpSocket.Listen(10);
showDataListBox.Items.Add("1.开始监听端口" + port.ToString() + "......");
showDataListBox.Items.Add("2.等待客户端连接......");
Thread listenThread = new Thread(ListenConnect);
listenThread.Start(tcpSocket);
}
private void ListenConnect(object obj)
{
Socket tcpSocket = (Socket)obj;
while (true)
{
Socket client = tcpSocket.Accept();
clientSockets.Add(client);
Thread sonProcess = new Thread(acceptClient);
sonProcess.Start(client);
}
}
private void acceptClient(object client)
{
Socket socketClient = (Socket)client;
IPEndPoint remoteIP = (IPEndPoint)socketClient.RemoteEndPoint;
socketClient.Send(Encoding.UTF8.GetBytes("已连接到服务端在端口:"+port.ToString()),SocketFlags.None);
showDataListBox.Items.Add("客户端连接:"+remoteIP.Address+"("+remoteIP.Port+")");
while (true)
{
//一直接收客户端发来的信息
try
{
byte[] receiveData = new byte[64];
int longth = socketClient.Receive(receiveData);
string s = Encoding.UTF8.GetString(receiveData);
showDataListBox.Items.Add(s + "(" + socketClient.ToString() + ")");
if (s == "exit")
{
showDataListBox.Items.Add("客户端断开连接" + "(" + socketClient.ToString() + ")");
clientSockets.Remove(socketClient);
socketClient.Close();
break;
}
}catch(Exception e){
Console.WriteLine("出现错误");
}
}
}
private void sendDataButton_Click(object sender, EventArgs e)
{
string sendData = sendDataBox.Text;
foreach (Socket s in clientSockets)
{
s.Send(Encoding.UTF8.GetBytes(sendData));
}
}
}
}
客户端(控制台):
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Net.Sockets;
using System.Threading;
namespace TCPClient
{
class Program
{
private static bool flag = true;
static void Main(string[] args)
{
Socket newclient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Console.Write("请输入要连接的IP:");
string ipadd = Console.ReadLine();
Console.Write("请输入要连接的端口:");
int port = Convert.ToInt32(Console.ReadLine());
IPEndPoint ie = new IPEndPoint(IPAddress.Parse(ipadd), port);//服务器的IP和端口
try
{
newclient.Connect(ie);
}
catch (SocketException e)
{
Console.WriteLine("连接服务器失败");
Console.WriteLine(e.ToString());
return;
}
//在第一次连接到客户端时，服务端会返回一个字符串，客户端接收并显示在控制台上
byte[] data = new byte[1024];
int recv = newclient.Receive(data);
string stringdata = Encoding.UTF8.GetString(data, 0, recv);
Console.WriteLine(stringdata);
//启动一个子线程专门用来接收服务器发送的数据
Thread receiveThread = new Thread(receiveData);
receiveThread.Start(newclient);
while (true)
{
string input = Console.ReadLine();
newclient.Send(Encoding.UTF8.GetBytes(input), SocketFlags.None);
if (input == "exit"){
flag=false;
break;
}
}
Console.WriteLine("与服务端断开连接");
newclient.Shutdown(SocketShutdown.Both);
newclient.Close();
Console.ReadKey();
}
private static void receiveData(object obj)
{
Socket newclient = (Socket)obj;
byte[] data=new byte[64];
while(flag==true)
{
try
{
int length = newclient.Receive(data);
string s = Encoding.UTF8.GetString(data, 0, length);
Console.WriteLine("服务端传来数据:" + s);
}
catch(Exception e)
{
break;
}
}
}
}
}
显示效果:
2)无连接-基于UDP
服务端:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;
namespace MyUDPServer
{
class Program
{
static void Main(string[] args)
{
int recv;
byte[] data = new byte[1024];
IPEndPoint ipep = new IPEndPoint(IPAddress.Any, 9050);//定义一网络端点
Socket newsock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);//定义一个Socket
newsock.Bind(ipep);//Socket与本地的一个终结点相关联
Console.WriteLine("Waiting for a client..");
IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);//定义要发送的计算机的地址
EndPoint Remote = (EndPoint)(sender);//
recv = newsock.ReceiveFrom(data, ref Remote);//接受数据
Console.WriteLine("Message received from{0}:", Remote.ToString());
string stringdata = Encoding.ASCII.GetString(data, 0, recv);
Console.WriteLine(stringdata);
string welcome = "Welcome to my test server!";
data = Encoding.UTF8.GetBytes(welcome);
newsock.SendTo(data, data.Length, SocketFlags.None, Remote);
while (true)
{
data = new byte[1024];
recv = newsock.ReceiveFrom(data, ref Remote);
Console.WriteLine(Encoding.UTF8.GetString(data, 0, recv));
newsock.SendTo(data, recv, SocketFlags.None, Remote);
}
}
}
}
客户端:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;
namespace MyUDPClient
{
class Program
{
static void Main(string[] args)
{
byte[] data = new byte[1024];//定义一个数组用来做数据的缓冲区
string input, stringData;
IPEndPoint server_ipep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9050);
Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
string welcome = "Hello,are you there?";
data = Encoding.UTF8.GetBytes(welcome);
client.SendTo(data, data.Length, SocketFlags.None, server_ipep);//将数据发送到指定的终结点
IPEndPoint sender = new IPEndPoint(IPAddress.Any,0);
EndPoint Remote = (EndPoint)sender;
data = new byte[1024];
int recv = client.ReceiveFrom(data, ref Remote);//接受来自服务器的数据
Console.WriteLine("Message received from{0}:", Remote.ToString());
Console.WriteLine(Encoding.UTF8.GetString(data, 0, recv));
while (true)//读取数据
{
input = Console.ReadLine();//从键盘读取数据
if (input == "exit")//结束标记
{
break;
}
client.SendTo(Encoding.UTF8.GetBytes(input), Remote);//将数据发送到指定的终结点Remote
data = new byte[1024];
recv = client.ReceiveFrom(data, ref Remote);//从Remote接受数据
stringData = Encoding.UTF8.GetString(data, 0, recv);
Console.WriteLine(stringData);
}
Console.WriteLine("Stopping client");
client.Close();
}
}
}
显示效果:
3)原始套接字:
原始套接字编程流程:
1.创建原始套接字 2.定义数据包头部数据结构 3.发送报文 4.接收报文
IP报文首部:
IP报文:
ICMP报文:(IP报文承载)
Ping程序的实现:
功能:PING命令是用于测试两个端系统之间的网络连通性。如果连通：输出源主机到目的主机的往返时延（时间），目的主机的操作系统（TTL）。如果不连通：输出可能原因。
原理:向网络上的另一个主机系统发送ICMP回送请求报文，如果指定系统得到了报文，它将把报文一模一样地传回给发送者。 ICMP echo & ICMP echo reply (rfc792)
TTL（Time To Live）生存期
指定数据报被路由器丢弃之前允许通过的网段数量。 TTL 是由发送主机设置的。
Windows 9x/Me TTL=32 LINUX TTL=64 Windows 200x/XP TTL=128 Unix TTL=255
PING程序的基本框架
设置发送数据就是封装ICMP数据报的过程。需要两级封装:首先添加ICMP报头形成ICMP报文，再添加IP头形成IP数据报。注意：IP头不需要我们实现，由内核协议栈自动添加，我们只需要实现ICMP报文。
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.Net.NetworkInformation;
namespace Csharp_PING
{
class MyPing
{
const int SOCKET_ERROR = -1;
const int ICMP_ECHO = 8;
public string PingHost(string host,ref int spentTime)
{
IPHostEntry serverHE, fromHE;
int nBytes = 0;
int dwStart = 0, dwStop = 0;
Socket socket =
new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.Icmp);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, 1000);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 1000);
// Get the server endpoint
try
{
serverHE = Dns.GetHostEntry(host);
}
catch (Exception)
{
return "Host not found"; //解释主机名失败
}
// Convert the server IP_EndPoint to an EndPoint
//用IP地址和端口号构造IPEndPoint对象
IPEndPoint ipepServer = new IPEndPoint(serverHE.AddressList[1], 0);
EndPoint epServer = (ipepServer);
//获得本地计算机的EndPoint
fromHE = Dns.GetHostEntry(Dns.GetHostName());//Dns.GetHostName()获取本地计算机的主机名
IPEndPoint ipEndPointFrom = new IPEndPoint(fromHE.AddressList[0], 80);
EndPoint EndPointFrom = (ipEndPointFrom);
int PacketSize = 0;
IcmpPacket packet = new IcmpPacket();
// 构建ICMP数据包
//构建数据报、报头字节、数据设计为字节
packet.Type = ICMP_ECHO; //值为8，1个字节
packet.SubCode = 0; //1个字节
packet.CheckSum = UInt16.Parse("0"); //2个字节
packet.Identifier = UInt16.Parse("45"); //2个字节
packet.SequenceNumber = UInt16.Parse("0"); //2个字节
int PingData = 32; // sizeof(IcmpPacket) - 8;
packet.Data = new Byte[PingData];
//初始化ICMP包的数据部分,即Packet.Data
for (int i = 0; i < PingData; i++)
{
packet.Data[i] = (byte)'a';
}
//保存数据报的长度
PacketSize = PingData + 8;//ICMP数据包大小
Byte[] icmp_pkt_buffer = new Byte[PacketSize];
Int32 Index = 0;
//调用Serialize方法
//报文总共的字节数
//序列化数据包,验证数据包大小
Index = Serialize(
packet,
icmp_pkt_buffer,
PacketSize,
PingData);
if (Index == -1)
{
return "Error Creating Packet";
}
//将ICMP数据包转换成 UInt16数组
//获取转换后的数组长度
Double double_length = Convert.ToDouble(Index);
Double dtemp = Math.Ceiling(double_length / 2);//向上取整;
int cksum_buffer_length = Convert.ToInt32(dtemp);
//生成一个字节数组
UInt16[] cksum_buffer = new UInt16[cksum_buffer_length];
//初始化Uint16类型数组
int icmp_header_buffer_index = 0;
for (int i = 0; i < cksum_buffer_length; i++)
{
cksum_buffer[i] =
BitConverter.ToUInt16(icmp_pkt_buffer, icmp_header_buffer_index);
icmp_header_buffer_index += 2;
}
//获取ICMP数据包的校验码
// 调用checksum,返回检查和
UInt16 u_cksum = checksum(cksum_buffer, cksum_buffer_length);
//保存校验码
packet.CheckSum = u_cksum;
// 再次序列化数据包
//再次检查报的大小
Byte[] sendbuf = new Byte[PacketSize];
Index = Serialize(
packet,
sendbuf,
PacketSize,
PingData);
//如果有错误,给出提示
if (Index == -1)
{
return "Error Creating Packet";
}
dwStart = System.Environment.TickCount; // 开始时间用socket发送数据报
//通过socket发送数据包
if ((nBytes = socket.SendTo(sendbuf, PacketSize, 0, epServer)) == SOCKET_ERROR)
{
return "Socket Error: cannot send Packet";
}
// 初始化缓冲区, 接收缓冲区
//大小为ICMP报头+IP报头的大小(20字节),共32+8+20=60字节.
Byte[] ReceiveBuffer = new Byte[60];
nBytes = 0;
//接收字节流
bool recd = false;
int timeout = 0;
//循环检查目标主机响应时间
while (!recd)
{
try
{
nBytes = socket.ReceiveFrom(ReceiveBuffer, 60, SocketFlags.None, ref EndPointFrom);
if (nBytes == SOCKET_ERROR)//如果超过时间限制，则提示
{
return "Host not Responding";
}
else if (nBytes > 0)
{
dwStop = System.Environment.TickCount - dwStart;// 停止计时
spentTime = dwStop;
return "Reply from " + epServer.ToString() + " in "
+ dwStop + "ms. Received: " + nBytes + " Bytes."
+" TTL="+PingTTl(host);
}
}
catch (SocketException e)
{
return "Time Out";
}
}
socket.Close();
return "";
}
//序列化数据包(计算数据包的大小并将数据转换成字节数组)
public static Int32 Serialize(IcmpPacket packet, Byte[] Buffer,
Int32 PacketSize, Int32 PingData)
{
//取得报文内容，转化为字节数组，然后计算报文的长度
Int32 cbReturn = 0;
//数据报结构转化为数组
int Index = 0;
Byte[] b_type = new Byte[1];
b_type[0] = (packet.Type);
Byte[] b_code = new Byte[1];
b_code[0] = (packet.SubCode);
Byte[] b_cksum = BitConverter.GetBytes(packet.CheckSum);
Byte[] b_id = BitConverter.GetBytes(packet.Identifier);
Byte[] b_seq = BitConverter.GetBytes(packet.SequenceNumber);
Array.Copy(b_type, 0, Buffer, Index, b_type.Length);
Index += b_type.Length;
Array.Copy(b_code, 0, Buffer, Index, b_code.Length);
Index += b_code.Length;
Array.Copy(b_cksum, 0, Buffer, Index, b_cksum.Length);
Index += b_cksum.Length;
Array.Copy(b_id, 0, Buffer, Index, b_id.Length);
Index += b_id.Length;
Array.Copy(b_seq, 0, Buffer, Index, b_seq.Length);
Index += b_seq.Length;
//复制数据
Array.Copy(packet.Data, 0, Buffer, Index, PingData);
Index += PingData;
if (Index != PacketSize/*如果不等于数据包长度,则返回出错信息*/)
{
cbReturn = -1;
return cbReturn;
}
cbReturn = Index;
return cbReturn;
}
//计算数据包的校验码
public static UInt16 checksum(UInt16[] buffer, int size)
{
Int32 cksum = 0;
int counter = 0;
//把ICMP报头的二进制数据以字节为单位累加起来。
while (size > 0)
{
UInt16 val = buffer[counter];
cksum += Convert.ToInt32(buffer[counter]);
counter += 1;
size -= 1;
}
/*弱ICMP报头为奇数个字节，就会剩下最后1个字节。把最后一个字节是为1个
*2个字节数据的高字节，这个字节数据的低字节继续累加*/
cksum = (cksum >> 16) + (cksum & 0xffff);
cksum += (cksum >> 16);
return (UInt16)(~cksum);
}
public int PingTTl(string host)
{
Ping pingSender = new Ping();
PingOptions options = new PingOptions();
// Use the default Ttl value which is 128,
// but change the fragmentation behavior.
options.DontFragment = true;
// Create a buffer of 32 bytes of data to be transmitted.
string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
byte[] buffer = Encoding.ASCII.GetBytes(data);
int timeout = 1000;
PingReply reply = pingSender.Send(host, timeout, buffer, options);
if (reply.Status == IPStatus.Success)
{
return reply.Options.Ttl;
}
return -1;
}
}
//ICMP数据报类
public class IcmpPacket
{
public Byte Type; // 类型:回显请求(8),应答(0)
public Byte SubCode; // 编码
public UInt16 CheckSum; // 校验码
public UInt16 Identifier; // 标识符
public UInt16 SequenceNumber; // 序列号
public Byte[] Data;
}
}
出现错误:
程序的基本实现是这样，但会出现访问权限不足的问题，以后再解决。
实验文档:https://files.cnblogs.com/files/MenAngel/Socket.zip
浙公网安备 33010602011771号