孙鑫mfc学习笔记第十四课

第十四课

网络的相关知识，网络程序的编写，Socket是连接应用程序与网络驱动程序的桥梁，Socket在应用程序中创建，通过bind与驱动程序建立关系。此后，应用程序送给Socket的数据，由Socket交给驱动程序向网络上发送出去。计算机从网络上收到与该Socket绑定的IP+Port相关的数据后，由驱动程序交给Socket，应用程序便可从该Socket中提取接收到的数据。网络应用程序就是这样通过socket进行数据的发送与接收的。TCP与UDP的工作原理与编写过程，如何在程序中链接库文件。一个字符界面的聊天程序。

套接字(socket)的引入

为了能够方便的开发网络应用软件，由美国伯克利大学在Unix上推出了一种应用程序访问通信协议的操作系统调用socket(套接字)。socket的出现，使程序员可以很方便地访问TCP/IP，从而开发各种网络应用的程序。

随着Unix的应用推广，套接字在编写网络软件中得到了极大的普及。后来，套接字又被引进了Windows等操作系统，成为开发网络应用程序的非常有效快捷的工具。

套接字存在于通信区域中。通信区域也叫地址族，它是一个抽象的概念，主要用于将通过套接字通信的进程的共有特性综合在一起。套接字通常只与同一区域的套接字交换数据（也有可能跨区域通信，但这只在执行了某种转换进程后才能实现）。Windows Sockets只支持一个通信区域：网际域( AF_INET)，这个域被使用网际协议簇通信的进程使用。

网络字节顺序

不同的计算机存放多字节值的顺序不同，有的机器在起始地址存放低位字节(低位先存)，有的机器在起始地址存放高位字节(高位先存)。基于Intel的CPU，即我们常用的PC机采用的是低位先存。为保证数据的正确性，在网络协议中需要指定网络字节顺序。TCP/IP协议使用16位整数和32位整数的高位先存格式。

客户机／服务器模式

在TCP/IP网络应用中，通信的两个进程间相互作用的主要模式是客户机/服务器模式(client/server)，即客户向服务器提出请求，服务器接收到请求后，提供相应的服务。

客户机/服务器模式的建立基于以下两点：首先，建立网络的起因是网络中软硬件资源、运算能力和信息不均等，需要共享，从而造就拥有众多资源的主机提供服务，资源较少的客户请求服务这一非对等作用。其次，网间进程通信完全是异步的，相互通信的进程间既不存在父子关系，又不共享内存缓冲区，因此需要一种机制为希望通信的进程间建立联系，为二者的数据交换提供同步，这就是基于客户机/服务器模式的TCP/IP。

客户机/服务器模式在操作过程中采取的是主动请求的方式。

   首先服务器方要先启动，并根据请求提供相应的服务：

①打开一个通信通道并告知本地主机，它愿意在某一地址和端口上接收客户请求。

②等待客户请求到达该端口。

③接收到重复服务请求，处理该请求并发送应答信号。接收到并发服务请求，要激活一个新的进程(或线程)来处理这个客户请求。新进程(或线程) 处理此客户请求，并不需要对其它请求作出应答。服务完成后，关闭此新进程与客户的通信链路，并终止。

④返回第二步，等待另一客户请求。

⑤关闭服务器。

   客户方：

①打开一个通信通道，并连接到服务器所在主机的特定端口。

②向服务器发服务请求报文，等待并接收应答；继续提出请求。

③请求结束后关闭通信通道并终止。

套接字的类型

流式套接字（SOCK_STREAM）

提供面向连接、可靠的数据传输服务，数据无差错、无重复的发送，且按发送顺序接收。

数据报式套接字（SOCK_DGRAM）

提供无连接服务。数据包以独立包形式发送，不提供无错保证，数据可能丢失或重复，并且接收顺序混乱。

原始套接字（SOCK_RAW）。

基于TCP(面向连接)的socket编程

服务器端程序：

1、创建套接字（socket）。

2、将套接字绑定到一个本地地址和端口上（bind）。

3、将套接字设为监听模式，准备接收客户请求（listen）。

4、等待客户请求到来；当请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字（accept）。

5、用返回的套接字和客户端进行通信（send/recv）。

6、返回，等待另一客户请求。

7、关闭套接字。

客户端程序：

1、创建套接字（socket）。

2、向服务器发出连接请求（connect）。

3、和服务器端进行通信（send/recv）。

4、关闭套接字。

基于UDP(面向无连接)的socket编程

服务器端（接收端）程序：

1、创建套接字（socket）。

2、将套接字绑定到一个本地地址和端口上（bind）。

3、等待接收数据（recvfrom）。

4、关闭套接字。

客户端（发送端）程序：

1、创建套接字（socket）。

2、向服务器发送数据（sendto）。

3、关闭套接字。

相关函数说明

nt WSAStartup( WORD wVersionRequested, LPWSADATA lpWSAData );

wVersionRequested参数用于指定准备加载的Winsock库的版本。高位字节指定所需要的Winsock库的副版本，而低位字节则是主版本。可用MAKEWORD(x,y)(其中，x是高位字节，y是低位字节)方便地获得wVersionRequested的正确值。 

lpWSAData参数是指向WSADATA结构的指针，WSAStartup用其加载的库版本有关的信息填在这个结构中。

WSADATA结构定义如下：

typedef struct WSAData { 

  WORD wVersion; 

  WORD wHighVersion; 

  char szDescription[WSADESCRIPTION_LEN+1]; 

  char szSystemStatus[WSASYS_STATUS_LEN+1]; 

  unsigned short iMaxSockets; 

  unsigned short iMaxUdpDg; 

  char FAR * lpVendorInfo; 

} WSADATA, *LPWSADATA; 

              WSAStartup把第一个字段wVersion设成打算使用的Winsock版本。wHighVersion 参数容纳的是现有的Winsock库的最高版本。记住，这两个字段中，高位字节代表的是Winsock副版本，而低位字节代表的则是Winsock主版本。szDescription和szSystemStatus这两个字段由特定的Winsock实施方案设定，事实上没有用。不要使用下面这两个字段：iMaxSockets和iMaxUdpDg，它们是假定同时最多可打开多少套接字和数据报的最大长度。然而，要知道数据报的最大长度应该通过WSAEnumProtocols来查询协议信息。同时最多可打开套接字的数目不是固定的，很大程度上和可用物理内存的多少有关。最后，lpVendorInfo字段是为Winsock实施方案有关的指定厂商信息预留的。任何一个Win32平台上都没有使用这个字段。

               如果WinSock.dll或底层网络子系统没有被正确初始化或没有被找到，WSAStartup将返回WSASYSNOTREADY。此外这个函数允许你的应用程序协商使用某种版本的WinSock规范，如果请求的版本等于或高于DLL所支持的最低版本，WSAData的wVersion成员中将包含你的应用程序应该使用的版本，它是DLL所支持的最高版本与请求版本中较小的那个。反之，如果请求的版本低于DLL所支持的最低版本，WSAStartup将返回WSAVERNOTSUPPORTED。关于WSAStartup更详细的信息，请查阅MSDN中的相关部分。 

              对于每一个WSAStartup的成功调用(成功加载WinSock DLL后)，在最后都对应一个WSACleanUp调用，以便释放为该应用程序分配的资源。 

SOCKET socket( int af, int type, int protocol );

该函数接收三个参数。第一个参数af指定地址族，对于TCP/IP协议的套接字，它只能是AF_INET(也可写成PF_INET)。第二个参数指定Socket类型，对于1.1版本的Socket，它只支持两种类型的套接字，SOCK_STREAM指定产生流式套接字，SOCK_DGRAM产生数据报套接字。第三个参数是与特定的地址家族相关的协议，如果指定为0，那么它就会根据地址格式和套接字类别，自动为你选择一个合适的协议。这是推荐使用的一种选择协议的方法。

如果这个函数调用成功，它将返回一个新的SOCKET数据类型的套接字描述符。如果调用失败，这个函数就会返回一个INVALID_SOCKET，错误信息可以通过WSAGetLastError函数返回。 

int bind( SOCKET s, const struct sockaddr FAR *name, int namelen );

这个函数接收三个参数。第一个参数s指定要绑定的套接字，第二个参数指定了该套接字的本地地址信息，是指向sockaddr结构的指针变量，由于该地址结构是为所有的地址家族准备的，这个结构可能（通常会）随所使用的网络协议不同而不同，所以，要用第三个参数指定该地址结构的长度。 sockaddr结构定义如下：

    struct sockaddr {

      u_short sa_family; 

      char sa_data[14]; 

    }; 

sockaddr的第一个字段sa_family指定该地址家族，在这里必须设为AF_INET。sa_data仅仅是表示要求一块内存分配区，起到占位的作用，该区域中指定与协议相关的具体地址信息。由于实际要求的只是内存区，所以对于不同的协议家族，用不同的结构来替换sockaddr。除了sa_family外，sockaddr是按网络字节顺序表示的。在TCP/IP中，我们可以用sockaddr_in结构替换sockaddr，以方便我们填写地址信息。 

sockaddr_in的定义如下： 

  struct sockaddr_in{ 

  short sin_family; 

  unsigned short sin_port; 

  struct   in_addr sin_addr; 

  char sin_zero[8]; 

};

              其中，sin_family表示地址族，对于IP地址，sin_family成员将一直是AF_INET。成员sin_port指定的是将要分配给套接字的端口。成员sin_addr给出的是套接字的主机IP地址。而成员sin_zero只是一个填充数，以使sockaddr_in结构和sockaddr结构的长度一样。如果这个函数调用成功，它将返回0。如果调用失败，这个函数就会返回一个SOCKET_ERROR，错误信息可以通过WSAGetLastError函数返回。 

             将IP地址指定为INADDR_ANY，允许套接字向任何分配给本地机器的IP地址发送或接收数据。多数情况下，每个机器只有一个IP地址，但有的机器可能会有多个网卡，每个网卡都可以有自己的IP地址，用INADDR_ANY可以简化应用程序的编写。将地址指定为INADDR_ANY，允许一个独立应用接受发自多个接口的回应。如果我们只想让套接字使用多个IP中的一个地址，就必须指定实际地址，要做到这一点，可以用inet_addr()函数，这个函数需要一个字符串作为其参数，该字符串指定了以点分十进制格式表示的IP地址(如192.168.0.16)。而且inet_addr()函数会返回一个适合分配给S_addr的u_long类型的数值。inet_ntoa()函数会完成相反的转换，它接受一个in_addr结构体类型的参数并返回一个以点分十进制格式表示的IP地址字符串。

 

 

1. 基于tcp/ip的网络连接程序 
2. //得用控制台应用程序编写一个基于TCP的面向连接的服务端应用程序 
3.  
4. 服务器 
5. #include <Winsock2.h> 
6. #include <stdio.h> 
7. void main() 
8. { 
9.     WORD wVersionRequested; 
10.     WSADATA wsaData;                     // 
11.     int err;            // MAKEWORD( 高位, 低位 )这个宏创建一个被指定变量 
12. 连接而成的WORD变量。返回一个WORD变量。 
13.     wVersionRequested = MAKEWORD( 1, 1 );//版本号1.1,高位副版本，地位主版本 
14.  
15. //1.加载套接字库   
16.     err = WSAStartup( wVersionRequested, &wsaData );//加载套接字库，进行套接字库 
17. 的版本协商 
18.     if ( err != 0 ) { 
19.         return; }///...if 
20.     //判断是否我们请求的winsocket版本，如果不是 
21.     //则调用WSACleanup终止winsocket的使用并返回 
22.     if ( LOBYTE( wsaData.wVersion ) != 1 || 
23.         HIBYTE( wsaData.wVersion ) != 1 ) { 
24.         WSACleanup( );//终止对winsock的使用 
25.         return;     }///...if 
26.  
27. //2.创建套接字 
28.     SOCKET sockSrv = socket(AF_INET,  
29.         SOCK_STREAM,  //创建流式套接字 
30.         0);  //零表示自动选择协议 
31.  
32. //3.将套接字绑定到本地地址与端口上 
33.     SOCKADDR_IN addrSrv;   //定义一个地址结构体的变量 
34.     addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//用htonl()方法将 
35. INADDR_ANY转换为网络字节序 
36.          
37.     addrSrv.sin_family = AF_INET; 
38.     addrSrv.sin_port = htons(6000); //指定端口号，htons把u_short类型从主机字节序 
39. 转换为网络字节序 
40.     bind(sockSrv,(SOCKADDR *) &addrSrv,sizeof(SOCKADDR));//绑定套接字， 
41. SOCKADDR大小写是一样的 
42.          
43.  
44. //4.设置监听 
45.     listen(sockSrv,5); // 第二个参数连接请求队列的最大长度（一般由2到4） 
46.     SOCKADDR_IN addrClient; 
47.     int len = sizeof(SOCKADDR); 
48.     while(1) 
49.     {   SOCKET sockConn = accept(sockSrv, 
50.             (SOCKADDR *) &addrClient,//客户端地址 
51.             &len);//返回地址结构的长度 
52.         char sendBuf[100]; 
53. //      memset(sendBuf,0,sizeof(recvBuf)); 
54.         sprintf (sendBuf,"Welcome %s to \ 
55.             http://blog.csdn.net/teshorse", 
56.             inet_ntoa(addrClient.sin_addr)); 
57.         send(sockConn,sendBuf,strlen(sendBuf)+1,0); //发送数据 
58.         char recvBuf[100]; 
59. //      memset(recvBuf,0,sizeof(recvBuf)); 
60.         recv(sockConn,recvBuf,100,0); 
61.         printf("%s\n",recvBuf); 
62.         closesocket(sockConn); 
63.     } 
64. } 
65.  
66.  
67. 客服端 
68. #include <Winsock2.h> 
69. #include <stdio.h> 
70. void main() 
71. {   WORD wVersionRequested; 
72.     WSADATA wsaData; 
73.     int err; 
74.     wVersionRequested = MAKEWORD( 1, 1 );//版本号1.1 
75. //1.加载套接字库   
76.     err = WSAStartup( wVersionRequested, &wsaData ); 
77.     if ( err != 0 ) { 
78.         return; }//endof if 
79.     //判断是否我们请求的winsocket版本，如果不是 
80.     //则调用WSACleanup终止winsocket的使用并返回 
81.     if ( LOBYTE( wsaData.wVersion ) != 1 || 
82.         HIBYTE( wsaData.wVersion ) != 1 ) { 
83.         WSACleanup( ); 
84.         return;     }///endof if 
85. //2.创建套接字 
86.     SOCKET sockClient = socket (AF_INET, SOCK_STREAM, 0); 
87. //3.连接服务器端，无须绑定 
88.     SOCKADDR_IN addrSrv; 
89.     addrSrv.sin_addr.S_un.S_addr = inet_addr("127.0.0.1"); 
90.         //设定服务器端IP地址，"127.0.0.1"是本地回路地址 
91.         //不管本地主机上有没有网卡，都可以用这个IP测试网络 
92.     addrSrv.sin_family = AF_INET; 
93.     addrSrv.sin_port = htons(6000); //端口号要与服务器端保持一致 
94.     connect(sockClient,(SOCKADDR *)&addrSrv,sizeof(SOCKADDR)); 
95. //4.接收服务器端发送的数据,并且向服务器端发送数据 
96.     char recvBuf[100]; 
97.     recv(sockClient,recvBuf,100,0); 
98.     printf("%s \n", recvBuf); 
99.     send(sockClient,"I'm teshorse",strlen("I'm teshorse")+1,0); 
100. //5.关闭套接字，释放资源,并且终止对套接字库的使用 
101.     closesocket(sockClient); 
102.     WSACleanup(); 
103. }//endof main() 
104.  
105.  
106.  
107. 基于UDp的网络连接 
108. //接收端代码 
109. #include <Winsock2.h> 
110. #include <stdio.h> 
111. void main() 
112. {    
113.     WORD wVersionRequested; 
114.     WSADATA wsaData; 
115.     int err; 
116.     wVersionRequested = MAKEWORD( 1, 1 );//版本号1.1 
117. //1.加载套接字库   
118.     err = WSAStartup( wVersionRequested, &wsaData ); 
119.     if ( err != 0 ) { 
120.         return; }//endof if 
121.     //判断是否我们请求的winsocket版本，如果不是 
122.     //则调用WSACleanup终止winsocket的使用并返回 
123.     if ( LOBYTE( wsaData.wVersion ) != 1 || 
124.         HIBYTE( wsaData.wVersion ) != 1 ) { 
125.         WSACleanup( ); 
126.         return;     }///endof if 
127. //2.创建套接字 
128.     SOCKET sockSrv = socket (AF_INET,  
129.         SOCK_DGRAM/*数据报套接字*/, 0); 
130. //3.在本地地址与端口绑定 
131.     SOCKADDR_IN addrSrv; 
132.     addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY); 
133.     addrSrv.sin_family = AF_INET; 
134.     addrSrv.sin_port = htons(6000); 
135.     bind(sockSrv, (SOCKADDR *)&addrSrv,sizeof(SOCKADDR)); 
136. //4.接收数据 
137.     SOCKADDR_IN addrClient; 
138.     int len=sizeof(SOCKADDR); 
139.     char recvBuf[100]; 
140.     recvfrom(sockSrv,recvBuf,100,0, 
141.         (SOCKADDR*)&addrClient,&len); 
142.     printf("%s\n",recvBuf); 
143.     closesocket(sockSrv); 
144.     WSACleanup(); 
145. }//endof main() 
146.  
147. //发送端代码 
148. #include <Winsock2.h> 
149. #include <stdio.h> 
150. void main() 
151. { 
152.     WORD wVersionRequested; 
153.     WSADATA wsaData; 
154.     int err; 
155.     wVersionRequested = MAKEWORD( 1, 1 );//版本号1.1 
156. //1.加载套接字库   
157.     err = WSAStartup( wVersionRequested, &wsaData ); 
158.     if ( err != 0 ) { 
159.         return; }//endof if 
160.     //判断是否我们请求的winsocket版本，如果不是 
161.     //则调用WSACleanup终止winsocket的使用并返回 
162.     if ( LOBYTE( wsaData.wVersion ) != 1 || 
163.         HIBYTE( wsaData.wVersion ) != 1 ) { 
164.         WSACleanup( ); 
165.         return;     }///endof if 
166. //2.创建套接字 
167.     SOCKET sockClient = socket(AF_INET,SOCK_DGRAM,0); 
168. //2.发送消息 
169.     SOCKADDR_IN addrSrv; 
170.     addrSrv.sin_addr.S_un.S_addr = inet_addr("127.0.0.1"); 
171.     addrSrv.sin_family = AF_INET; 
172.     addrSrv.sin_port = htons(6000); 
173.     sendto(sockClient,"hello",strlen("hello")+1,0, 
174.         (SOCKADDR*)&addrSrv,sizeof(SOCKADDR)); 
175.     closesocket(sockClient); 
176.     WSACleanup(); 
177. }//endof main() 
178.  
179.  
180. 一个聊天程序 
181. //编写一个基于UDP的聊天工具 
182. //发送端代码 
183. #include <Winsock2.h> 
184. #include <stdio.h> 
185. void main() 
186. { 
187.     WORD wVersionRequested; 
188.     WSADATA wsaData; 
189.     int err; 
190.     wVersionRequested = MAKEWORD( 1, 1 );//版本号1.1 
191. //1.加载套接字库   
192.     err = WSAStartup( wVersionRequested, &wsaData ); 
193.     if ( err != 0 ) { 
194.         return; }//endof if 
195.     //判断是否我们请求的winsocket版本，如果不是 
196.     //则调用WSACleanup终止winsocket的使用并返回 
197.     if ( LOBYTE( wsaData.wVersion ) != 1 || 
198.         HIBYTE( wsaData.wVersion ) != 1 ) { 
199.         WSACleanup( ); 
200.         return;     }///endof if 
201. //2.创建套接字 
202.     SOCKET sockSrv = socket(AF_INET,SOCK_DGRAM,0); 
203.     SOCKADDR_IN addrSrv; 
204.     addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY); 
205.     addrSrv.sin_family = AF_INET; 
206.     addrSrv.sin_port = htons(6000); 
207.     bind (sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR)); 
208.     char recvBuf[100]; 
209.     char sendBuf[100]; 
210.     char tempBuf[100]; 
211.     SOCKADDR_IN addrClient; 
212.     int len = sizeof(SOCKADDR); 
213.     while(1) 
214.     { 
215.         recvfrom(sockSrv,recvBuf,100,0,(SOCKADDR*)&addrClient,&len); 
216.         if('#'==recvBuf[0])//表示客户端想要退出 
217.         { 
218.             sendto(sockSrv,"#",strlen("#")+1,0,(SOCKADDR*)&addrClient,len); 
219.             printf("Chat end!\n"); 
220.             break; 
221.         } 
222.         sprintf(tempBuf,"%s say: %s", inet_ntoa(addrClient.sin_addr),recvBuf); 
223.         printf("%s\n",tempBuf); 
224.         printf("Please input data:\n"); 
225.          
226.         gets(sendBuf);//可以得到一行数据 
227.         sendto (sockSrv,sendBuf,strlen(sendBuf)+1,0, 
228.             (SOCKADDR*)&addrClient,len);//发送数据 
229.     }///..while 
230.     closesocket(sockSrv); 
231.     WSACleanup(); 
232. }//endof main() 
233.  
234.  
235. //发送端代码 
236. #include <Winsock2.h> 
237. #include <stdio.h> 
238. void main() 
239. { 
240.     WORD wVersionRequested; 
241.     WSADATA wsaData; 
242.     int err; 
243.     wVersionRequested = MAKEWORD( 1, 1 );//版本号1.1 
244. //1.加载套接字库   
245.     err = WSAStartup( wVersionRequested, &wsaData ); 
246.     if ( err != 0 ) { 
247.         return; }//endof if 
248.     //判断是否我们请求的winsocket版本，如果不是 
249.     //则调用WSACleanup终止winsocket的使用并返回 
250.     if ( LOBYTE( wsaData.wVersion ) != 1 || 
251.         HIBYTE( wsaData.wVersion ) != 1 ) { 
252.         WSACleanup( ); 
253.         return;     }///endof if 
254. //2.创建套接字 
255.     SOCKET sockClient = socket(AF_INET,SOCK_DGRAM,0); 
256. //  char IPaddr[16]; 
257. //  printf("please input you IP address!"); 
258. //  gets(IPaddr); 
259. //3.发送消息 
260.     SOCKADDR_IN addrSrv; 
261. //  if(''==IPaddr[0]) 
262.         addrSrv.sin_addr.S_un.S_addr = inet_addr("172.16.16.95"); 
263. //  else  
264. //      addrSrv.sin_addr.S_un.S_addr = inet_addr(IPaddr); 
265.     addrSrv.sin_family = AF_INET; 
266.     addrSrv.sin_port = htons(6000); 
267.  
268.     char recvBuf[100]; 
269.     char sendBuf[100]; 
270.     char tempBuf[200]; 
271.     int len = sizeof(SOCKADDR); 
272.     while (1) 
273.     { 
274.         printf("Please input data:\n"); 
275.         gets(sendBuf); 
276.         sendto(sockClient,sendBuf,strlen(sendBuf)+1,0, 
277.             (SOCKADDR*)&addrSrv,len); 
278.         recvfrom(sockClient,recvBuf,100,0,(SOCKADDR*) &addrSrv,&len); 
279.         if('#' ==recvBuf[0]) 
280.         { 
281.             sendto(sockClient,"#",strlen("#")+1,0, 
282.                 (SOCKADDR*) &addrSrv,len); 
283.             printf("chat end!\n"); 
284.             break; 
285.         } 
286.         sprintf(tempBuf,"%s say: %s",inet_ntoa(addrSrv.sin_addr),recvBuf); 
287.         printf("%s\n",tempBuf); 
288.  
289.     }    
290.  
291.     closesocket(sockClient); 
292.     WSACleanup(); 
293. }//endof main() 

 

转载于:https://blog.51cto.com/hantayi/382530