学习笔记七之网络编程(UDP)

女爷i 2022-08-10 06:27 210阅读 0赞

一. Linux下UDP编程框架

使用UDP进行程序设计可以分为客户端和服务器端两部分。

1.服务器端程序包括：

Ø  建立套接字

Ø  将套接字地址结构进行绑定

Ø  读写数据

Ø  关闭套接字

2.客户端程序包括：

Ø  建立套接字

Ø  读写数据

Ø  关闭套接字

3.服务器端和客户端程序之间的差别

服务器端和客户端两个流程之间的主要差别在于对地址的绑定函数（bind()函数），而客户端可以不用进行地址和端口的绑定操作。

![0_1315562748qjnv.gif][]

二.Linux中UDP套接字函数

从图可知，UDP协议的服务端程序设计的流程分为套接字建立，套接字与地址结构进行绑定，收发数据，关闭套接字;客户端程序流程为套接字建立，收发数据，关闭套接字等过程。它们分别对应socket(),bind(),sendto(),recvfrom(),和close()函数。

网络程序通过调用socket（）函数，会返回一个用于通信的套接字描述符。Linux应用程序在执行任何形式的I/O操作的时候，程序是在读或者写一个文件描述符。因此，可以把创建的套接字描述符看成普通的描述符来操作，并通过读写套接字描述符来实现网络之间的数据交流。

1.   socket

1>  函数原型:

int socket(int domain,int type,int protocol)

2>  函数功能：

函数socket()用于创建一个套接字描述符。

3>  形参：

Ø  domain:用于指定创建套接字所使用的协议族，在头文件

<linux/socket.h>中定义。

常见的协议族如下：

AF\_UNIX:创建只在本机内进行通信的套接字。

AF\_INET:使用IPv4 TCP/IP协议

AF\_INET6:使用IPv6 TCP/IP协议

说明：

AF\_UNIX只能用于单一的UNIX系统进程间通信，而AF\_INET是针对Interne的，因而可以允许在远程主机之间通信。一般把它赋为AF\_INET。

Ø  type:指明套接的类型，对应的参数如下

SOCK\_STREAM:创建TCP流套接字

SOCK\_DGRAM:创建UDP数据报套接字

SOCK\_RAW:创建原始套接字

Ø  protocol:

参数protocol通常设置为0，表示通过参数domain指定的协议族和参数type指定的套接字类型来确定使用的协议。当为原始套接字时，系统无法唯一的确定协议，此时就需要使用使用该参数指定所使用的协议。

4>  返回值：执行成功后返回一个新创建的套接字；若有错误发生则返回一个-1，错误代码存入errno中。

5>  举例：调用socket函数创建一个UDP套接字

int sock\_fd;

sock\_fd = socket(AF\_INET,SOCK\_DGRAM,0);

if(sock\_fd < 0)\{

perror(“socket”);

exit(1);

2.   bind

1>  函数原型：

int bind(int sockfd,struct sockaddr \*my\_addr,socklen\_taddrlen)

2>  函数功能

函数bind()的作用是将一个套接字文件描述符与一个本地地址绑定在一起。

3>  形参：

Ø  sockfd:sockfd是调用socket函数返回的文件描述符；

Ø  addrlen是sockaddr结构的长度。

Ø  my\_addr: 是一个指向sockaddr结构的指针，它保存着本地套接字的地址（即端口和IP地址）信息。不过由于系统兼容性的问题，一般不使用这个结构，而使用另外一个结构(struct sockaddr\_in)来代替

4>  套接字地址结构：

(1)structsockaddr:

结构struct sockaddr定义了一种通用的套接字地址，它在

Linux/socket.h 中定义。

struct sockaddr\{

unsigned short  sa\_family;/\*地址类型，AF\_XXX\*/

char          sa\_data\[14\];/\*14字节的协议地址\*/

a.    sin\_family：表示地址类型，对于使用TCP/IP协议进行的网络编程，该值只能是AF\_INET.

b.   sa\_data：存储具体的协议地址。

(2)sockaddr\_in

每种协议族都有自己的协议地址格式，TCP/IP协议组的地址格式为结构体struct sockaddr\_in,它在netinet/in.h头文件中定义。

struct sockaddr\_in\{

unsigned short sin\_family;/\*地址类型\*/

unsigned short  sin\_port;/\*端口号\*/

struct in\_addr   sin\_addr;/\*IP地址\*/

unsigned char  sin\_zero\[8\];/\*填充字节，一般赋值为0\*/

a.    sin\_family：表示地址类型，对于使用TCP/IP协议进行的网络编程，该值只能是AF\_INET.

b.   sin\_port:是端口号

c.    sin\_addr:用来存储32位的IP地址。

d.   数组sin\_zero为填充字段，一般赋值为0.

e.    structin\_addr的定义如下：

struct in\_addr\{

unsignedlong s\_addr;

结构体sockaddr的长度为16字节，结构体sockaddr\_in的长度为16字节。可以将参数my\_addr的sin\_addr设置为INADDR\_ANY而不是某个确定的IP地址就可以绑定到任何网络接口。对于只有一IP地址的计算机，INADDR\_ANY对应的就是它的IP地址；对于多宿主主机(拥有多个网卡)，INADDR\_ANY表示本服务器程序将处理来自所有网络接口上相应端口的连接请求

5>  返回值：

函数成功后返回0，当有错误发生时则返回-1，错误代码存入errno中。

6>举例：调用socket函数创建一个UDP套接字

struct sockaddr\_in addr\_serv,addr\_client;/\*本地的地址信息\*/

memset(&serv\_addr,0,sizeof(struct sockaddr\_in));

addr\_serv.sin\_family = AF\_INET;/\*协议族\*/

addr\_serv.sin\_port = htons(SERV\_PORT);/\*本地端口号\*/

addr\_serv.sin\_addr.s\_addr = htonl(INADDR\_ANY); /\*任意本地地址\*/  
/\*套接字绑定\*/

if(bind(sock\_fd,(struct sockaddr \*)&addr\_serv),sizeof(structsockaddr\_in)) <0)

perror(“bind”);

exit(1);

3.close

1>函数原型：

int  close(intfd);

2>函数功能：

函数close用来关闭一个套接字描述符。

3>函数形参：

Ø  参数fd为一个套接字描述符。

4>返回值：

执行成功返回0，出错则返回-1.错误代码存入errno中。

说明：

以上三个函数中，前两个要包含头文件

\#include<sys/types.h>

\#include<sys/socket.h>

后一个包含：

\#include<unistd.h>

4.sendto

1>函数原型：

\#include<sys/types.h>

\#include<sys/socket.h>

ssize\_t sendo(ints,const void \*msg,size\_t len,int flags,const struct sockaddr \*to,socklen\_ttolen);

2>函数功能：

向目标主机发送消息

3>函数形参：

Ø  s:套接字描述符。

Ø  \*msg:发送缓冲区

Ø  len:待发送数据的长度

Ø  flags:控制选项，一般设置为0或取下面的值

(1)MSG\_OOB:在指定的套接字上发送带外数据(out-of-band data),该类型的套接字必须支持带外数据（eg:SOCK\_STREAM）.

(2)MSG\_DONTROUTE:通过最直接的路径发送数据，而忽略下层协议的路由设置。

Ø  to:用于指定目的地址

Ø  tolen:目的地址的长度。

4>函数返回值：

执行成功后返回实际发送数据的字节数，出错返回-1，错误代码存入errno中。

5>函数举例：

char  send\_buf\[BUFFERSIZE\];

struct sockaddr\_in  addr\_client;

memset(&addr\_client,0,sizeof(struct sockaddr\_in));

addr\_client.sin\_family = AF\_INET;

addr\_client.sin\_port = htons(DEST\_PORT);

if(inet\_aton(“172.17.242.131”,&addr\_client.sin\_addr)<0)\{

perror(“inet\_aton”);

exit(1);

if(sendto(sock\_fd,send\_buf,len,0,(strut sockaddr\*)&addr\_client,sizeof(struct sockaddr\_in)) <0)\{

perror(“sendto”);

exit(1);

5.recvfrom

1>函数原型：

\#include<sys/types.h>

\#include<sys/socket.h>

ssize\_t recvfrom(int s,void \*buf,size\_t len,intflags,struct sockaddr \*from,socklen\_t \*fromlen);

2>函数功能：接收数据

3>函数形参：

Ø  int s:套接字描述符

Ø  buf:指向接收缓冲区，接收到的数据将放在这个指针所指向的内存空间。

Ø  len:指定了缓冲区的大小。

Ø  flags:控制选项,一般设置为0或取以下值

(1)MSG\_OOB:请求接收带外数据

(2)MSG\_PEEK:只查看数据而不读出

(3)MSG\_WAITALL:只在接收缓冲区时才返回。

Ø  \*from:保存了接收数据报的源地址。

Ø  \*fromlen:参数fromlen在调用recvfrom前为参数from的长度，调用recvfrom后将保存from的实际大小。

4>函数返回值：

执行成功后返回实际接收到数据的字节数，出错时则返回-1，错误代码存入errno中。

5>函数实例：

char recv\_buf\[BUFFERSIZE\];

struct sockaddr\_in addr\_client;

int  src\_len;

src\_len = sizeof(struct sockaddr\_in);

int src\_len;

src\_len = sizeof(struct sockaddr\_in);

if(recvfrom(sock\_fd,recv\_buf,sizeof(recv\_buf),0,(structsockaddr \*)&src\_addr,&src\_len)<0)\{

perror(“again\_recvfrom”);

exit(1);

三.UDP编程实例

客户端向服务器发送字符串Hello tiger,服务器接收到数据后将接收到字符串发送回客户端。

![0_13155630678ENe.gif][]

1.服务器端程序

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \#include<stdio.h>  
2.  \#include<sys/types.h>  
3.  \#include<sys/socket.h>  
4.  \#include<netinet/in.h>  
5.  \#include<unistd.h>  
6.  \#include<errno.h>  
7.  \#include<string.h>  
8.  \#include<stdlib.h>  
9.       
10. \#define SERV\_PORT   3000  
11.    
12.  **int** main()  
13. \{  
14.         **int** sock\_fd;   //套接子描述符号  
15.       **int** recv\_num;  
16.       **int** send\_num;  
17.       **int** client\_len;  
18.       **char** recv\_buf\[20\];  
19.       **struct** sockaddr\_in  addr\_serv;  
20.       **struct** sockaddr\_in  addr\_client;//服务器和客户端地址  
21.       sock\_fd = socket(AF\_INET,SOCK\_DGRAM,0);  
22.       **if**(sock\_fd < 0)\{  
23.               perror("socket");  
24.               exit(1);  
25.       \} **else**\{  
26.   
27.               printf("sock sucessful\\n");  
28.       \}  
29.       //初始化服务器断地址  
30.       memset(&addr\_serv,0,**sizeof**(**struct** sockaddr\_in));  
31.       addr\_serv.sin\_family = AF\_INET;//协议族  
32.       addr\_serv.sin\_port = htons(SERV\_PORT);  
33.       addr\_serv.sin\_addr.s\_addr = htonl(INADDR\_ANY);//任意本地址  
34.   
35.       client\_len = **sizeof**(**struct** sockaddr\_in);  
36.       /\*绑定套接子\*/  
37.       **if**(bind(sock\_fd,(**struct** sockaddr \*)&addr\_serv,**sizeof**(**struct** sockaddr\_in))<0 )\{  
38.               perror("bind");  
39.               exit(1);  
40.       \} **else**\{  
41.   
42.               printf("bind sucess\\n");  
43.         \}  
44.         **while**(1)\{  
45.                 printf("begin recv:\\n");  
46.                 recv\_num = recvfrom(sock\_fd,recv\_buf,**sizeof**(recv\_buf),0,(**struct** sockaddr \*)&addr\_client,&client\_len);  
47.                 **if**(recv\_num <  0)\{  
48.                         printf("bad\\n");  
49.                         perror("again recvfrom");  
50.                         exit(1);  
51.                 \} **else**\{  
52.                         recv\_buf\[recv\_num\]='\\0';  
53.                         printf("recv sucess:%s\\n",recv\_buf);  
54.                 \}  
55.                 printf("begin send:\\n");  
56.                 send\_num = sendto(sock\_fd,recv\_buf,recv\_num,0,(**struct** sockaddr \*)&addr\_client,client\_len);  
57.                 **if**(send\_num < 0)\{  
58.                         perror("sendto");  
59.                         exit(1);  
60.                 \} **else**\{  
61.                         printf("send sucessful\\n");  
62.                 \}  
63.         \}  
64.         close(sock\_fd);  
65.         **return** 0;  
66. \}

2.客户端程序

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \#include<stdio.h>  
2.  \#include<string.h>  
3.  \#include<errno.h>  
4.  \#include<stdlib.h>  
5.  \#include<unistd.h>  
6.    
7.  \#include<sys/types.h>  
8.  \#include<sys/socket.h>  
9.  \#include<netinet/in.h>  
10.   
11. \#define DEST\_PORT 3000  
12. \#define DSET\_IP\_ADDRESS  "192.168.1.103"  
13.   
14. **int** main()  
15. \{  
16.         **int** sock\_fd;/\*套接字文件描述符\*/  
17.         **int** send\_num;  
18.         **int** recv\_num;  
19.         **int** dest\_len;  
20.         **char** send\_buf\[20\]=\{ "hello tiger"\};  
21.         **char** recv\_buf\[20\];  
22.         **struct** sockaddr\_in addr\_serv;/\*服务端地址，客户端地址\*/  
23.   
24.         sock\_fd = socket(AF\_INET,SOCK\_DGRAM,0);//创建套接子  
25.         //初始化服务器端地址  
26.         memset(&addr\_serv,0,**sizeof**(addr\_serv));  
27.         addr\_serv.sin\_family = AF\_INET;  
28.         addr\_serv.sin\_addr.s\_addr = inet\_addr(DSET\_IP\_ADDRESS);  
29.         addr\_serv.sin\_port = htons(DEST\_PORT);  
30.   
31.         dest\_len = **sizeof**(**struct** sockaddr\_in);  
32.         printf("begin send:\\n");  
33.         send\_num = sendto(sock\_fd,send\_buf,**sizeof**(send\_buf),0,(**struct** sockaddr \*)&addr\_serv,dest\_len);  
34.         **if**(send\_num < 0)\{  
35.                 perror("sendto");  
36.                 exit(1);  
37.         \} **else**\{  
38.   
39.                 printf("send sucessful:%s\\n",send\_buf);  
40.         \}  
41.         recv\_num = recvfrom(sock\_fd,recv\_buf,**sizeof**(recv\_buf),0,(**struct** sockaddr \*)&addr\_serv,&dest\_len);  
42.         **if**(recv\_num <0 )\{  
43.   
44.                 perror("recv\_from");  
45.                 exit(1);  
46.         \} **else**\{  
47.                 printf("recv sucessful\\n");  
48.         \}  
49.         recv\_buf\[recv\_num\]='\\0';  
50.         printf("the receive:%s\\n",recv\_buf);  
51.         close(sock\_fd);  
52.         **return** 0;  
53.   
54. \}  
55.

[0_1315562748qjnv.gif]: /images/20220731/30d7227ddcd14d229836cf1d69e30277.png
[0_13155630678ENe.gif]: /images/20220731/afadfb29b35e4caaa6a4517c800fb92c.png
[view plain]: http://blog.csdn.net/cqkxboy168/article/details/9129861#