欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  网络运营

详情解析TCP与UDP传输协议

程序员文章站 2022-06-10 13:47:53
目录二、socket 编程的重要概念① ip 地址② tcp/ip 端口三、socket 编程的 api 接口① linux 下的 socket api 接口② windows 下的 socket a...

一、什么是 socket ?

socket 的英文原义是“孔”或“插座”。在编程中,socket 被称做套接字,是网络通信中的一种约定。socket 编程的应用无处不在,我们平时用的 qq、微信、浏览器等程序,都与 socket 编程有关。
那么我们使用浏览器查资料,这个过程的技术原理是怎样的呢?如下所示:

详情解析TCP与UDP传输协议

使用浏览器,有两个重要的名词:服务端与客户端,socket 编程的目的就是如何实现这两端之间的通信。

二、socket 编程的重要概念

① ip 地址

ip 地址(internet protocol address)是指互联网协议地址,又译为网际协议地址。ip 地址被用来给 internet 上的电脑一个编号,可以把“个人电脑”比作“一台电话”,那么“ip 地址”就相当于“电话号码”。若计算机 1 知道计算机 2 的 ip 地址,则计算机 1 就能访问计算机 2。
ip 地址是一个 32 位的二进制数,通常被分割为 4 个“8位二进制数”(也就是 4 个字节)。ip 地址通常用点分十进制表示成(a.b.c.d)的形式,其中,a,b,c,d 都是 0~255 之间的十进制整数。例:点分十进 ip 地址(100.4.5.6),实际上是 32 位二进制数(01100100.00000100.00000101.00000110)。
ip 地址有 ipv4 与 ipv6 之分,现在用得较多的是 ipv4。其中,有一个特殊的 ip 地址需要记住:127.0.0.1,这是回送地址,即本地机,一般用来测试使用。

② tcp/ip 端口

若计算机 1 知道计算机 2 的 ip 地址,则计算机 1 就能访问计算机 2。但是,要访问计算机 2 中的不同的应用软件,则还得需要一个信息:端口。
服务端口,最多可以有65536个,使用 16bit 进行编号,即其范围为:0 ~ 65535。但 0 ~ 1023 的端口一般由系统分配给特定的服务程序,例如 web 服务的端口号为 80,ftp 服务的端口号为 21 等。

③ 协议

协议(protocol)是通信双方进行数据交互的一种约定,如 tcp、udp 协议。
tcp(transmission control protocol 传输控制协议)是一种面向连接的、可靠的、基于字节流的传输层通信协议,数据可以准确发送,数据丢失会重发,tcp 协议常用于 web 应用中。
tcp 连接(三次握手):tcp 传输起始时,客户端、服务端要完成三次数据交互工作才能建立连接,常称为三次握手。可形象比喻为如下对话:
客户端:服务端您好,我有数据要发给你,请求您开通访问权限。
服务端:客户端您好,已给您开通权限,您可以发送数据了。
客户端:收到,谢谢。

tcp 连接(三次握手)具体示意图为:

详情解析TCP与UDP传输协议

说明:syn 和 ack 是都是标志位,其中 syn 代表新建一个连接,ack 代表确认。其中 m、n 都是随机数。具体说明如:

第一次握手:syn 标志位被置位,客户端向服务端发送一个随机数 m。
第二次握手:ack、syn 标志位被置位。服务端向客户端发送 m+1 表示确认刚才收到的数据,同时向客户端发送一个随机数 n。
第三次握手:ack 标志被置位,客户端向服务端发送 n+1 表示确认收到数据。
tcp 断开(四次挥手):tcp 断开连接时,客户端、服务端要完成四次数据交互工作才能建立连接,常称为四次挥手。可形象比喻为如下对话:
客户端:服务端您好,我发送数据完毕了,即将和您断开连接。
服务端:客户端您好,我稍稍准备一下,再给您断开
服务端:客户端您好,我准备好了,您可以断开连接了。
客户端:好的,合作愉快。

tcp 断开(四次挥手)具体示意图为:

详情解析TCP与UDP传输协议

fin 也是一个标志位,代表断开连接,类似三次握手。
为什么建立连接只需要三次数据交互,而断开连接需要四次呢?
建立连接时,服务端在监听状态下,收到建立连接请求的 syn 报文后,把 ack 和 syn 放在一个报文里发送给客户端。
而关闭连接时,当收到对方的 fin 报文时,仅仅表示对方不再发送数据了但是还能接收数据,己方也未必全部数据都发送给对方了,所以己方可以立即 close,也可以发送一些数据给对方后,再发送 fin 报文给对方来表示同意现在关闭连接,因此,己方 ack 和 fin 一般都会分开发送。
udp 协议:udp(user datagram protocol, 用户数据报协议)是一种无连接的传输层协议,提供面向事务的简单不可靠信息传送服务,可以保证通讯效率,传输延时小。例如视频聊天应用中用的就是 udp 协议,这样可以保证及时丢失少量数据,视频的显示也不受很大影响。
什么是协议族?协议族是多个协议的统称。比如 tcp/ip 协议族,其不仅仅是 tcp 协议、ip 协议,而是多个协议的集合,其包含 ip、tcp、udp、ftp、smtp 等协议。

三、socket 编程的 api 接口

① linux 下的 socket api 接口

创建 socket:socket()函数
函数原型,如下所示:

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

函数说明:

af 参数:af 为地址族(address family),也就是 ip 地址类型,常用的有 af_inet 和 af_inet6,其前缀也可以是 pf(protocol family),即 pf_inet 和 pf_inet6。
type 参数:type 为数据传输方式,常用的有 面向连接(sock_stream)方式(即 tcp) 和 无连接(sock_dgram)的方式(即 udp)。
protocol 参数:protocol 表示传输协议,常用的有 ipproto_tcp 和 ipptoto_udp,分别表示 tcp 传输协议和 udp 传输协议。

创建 tcp 套接字:

 int tcp_socket = socket(af_inet, sock_stream, ipproto_tcp);

创建 udp 套接字:

 int udp_socket = socket(af_inet, sock_dgram, ipproto_udp);

绑定套接字:bind() 函数
函数原型,如下所示:

 int bind(int sock, struct sockaddr *addr, socklen_t addrlen); 

函数说明:

sock 参数:sock 为 socket 文件描述符。
addr 参数:addr 为 sockaddr 结构体变量的指针。
addrlen 参数:addrlen 为 addr 变量的大小,可由 sizeof() 计算得出。
将创建的套接字 serversock 与本地 ip127.0.0.1、端口 1314 进行绑定:

/* 创建服务端socket */

 int serversock = socket(pf_inet, sock_stream, ipproto_tcp);​
/* 设置服务端信息 */
 struct sockaddr_in serversockaddr;
 memset(&serversockaddr, 0, sizeof(serversockaddr));   
 // 给结构体serversockaddr清零
 serversockaddr.sin_family = pf_inet;                      
 // 使用ipv4地址
 serversockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
 // 本机ip地址
 serversockaddr.sin_port = htons(1314); // 端口
  /* 绑定套接字 */
bind(serversock, (sockaddr*)&serversockaddr, sizeof(sockaddr));

其中 struct sockaddr_in 类型的结构体变量用于保存 ipv4 的 ip 信息,若是 ipv6,则有对应的结构体:

 struct sockaddr_in6 {     
  sa_family_t sin6_family;    // 地址类型,取值为af_inet6    
  in_port_t sin6_port;        // 16位端口号    
  uint32_t sin6_flowinfo;     // ipv6流信息    
  struct in6_addr sin6_addr;  // 具体的ipv6地址    
  uint32_t sin6_scope_id;     // 接口范围id
 };

建立连接:connect() 函数
函数原型,参数与 bind() 的参数类似,如下所示:

int connect(int sock, struct sockaddr *serv_addr, socklen_t addrlen);  

使用示例:

int clientsock = socket(af_inet, sock_stream, ipproto_tcp);
 connect(clientsock, (sockaddr*)&serversockaddr, sizeof(sockaddr));

监听:listen() 函数
函数如下所示:

 int listen(int sock, int backlog);

函数的参数说明:
sock 参数:sock 为需要进入监听状态的套接字。
backlog 参数:backlog 为请求队列的最大长度。
使用示例:
 /* 进入监听状态 */

 listen(serversock, 10);

接收请求:accept() 函数
函数如下所示:

 int accept(int sock, struct sockaddr *addr, socklen_t *addrlen);

函数参数说明:
sock 参数:sock 为服务器端套接字。
addr参数:addr 为 sockaddr_in 结构体变量。
addrlen 参数:addrlen 为参数 addr 的长度,可由 sizeof() 求得。
返回值:一个新的套接字,用于与客户端通信。
使用示例:

 /* 监听客户端请求,accept函数返回一个新的套接字,发送和接收都是用这个套接字 */
int clientsock = accept(serversock, (sockaddr*)&clientaddr, &len);

关闭:close() 函数
函数如下:

 int close(int fd);

函数参数 fd:要关闭的文件描述符。
使用示例:

 close(serversock);

数据的接收和发送
数据收发函数有几组:

 read()/write()
 recv()/send()
 readv()/writev()
 recvmsg()/sendmsg()
 recvfrom()/sendto()

函数原型如下:

 ssize_t read(int fd, void *buf, size_t count);
 ssize_t write(int fd, const void *buf, size_t count);
 ssize_t send(int sockfd, const void *buf, size_t len, int flags);
 ssize_t recv(int sockfd, void *buf, size_t len, int flags);
 ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                       const struct sockaddr *dest_addr, socklen_t addrlen);
 ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                         struct sockaddr *src_addr, socklen_t *addrlen);
 ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
 ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

recv() 函数:
sockfd 参数:sockfd 为要接收数据的套接字。
buf 参数:buf 为要接收的数据的缓冲区地址。
len 参数:len 为要接收的数据的字节数。

flags 参数:flags 为接收数据时的选项,常设为 0。

 ssize_t recv(int sockfd, void *buf, size_t len, int flags);

send() 函数:
sockfd 参数:sockfd 为要发送数据的套接字。
buf 参数:buf 为要发送的数据的缓冲区地址。
len 参数:len 为要发送的数据的字节数。
flags 参数:flags 为发送数据时的选项,常设为 0。

 ssize_t send(int sockfd, const void *buf, size_t len, int flags);

recvfrom() 函数:
sock:用于接收 udp 数据的套接字;
buf:保存接收数据的缓冲区地址;
nbytes:可接收的最大字节数(不能超过 buf 缓冲区的大小);
flags:可选项参数,若没有可传递 0;
from:存有发送端地址信息的 sockaddr 结构体变量的地址;
addrlen:保存参数 from 的结构体变量长度的变量地址值。
 

ssize_t recvfrom(int sock, void *buf, size_t nbytes, int flags, struct sockadr *from, socklen_t *addrlen);

sendto() 函数:
sock:用于传输 udp 数据的套接字;
buf:保存待传输数据的缓冲区地址;
nbytes:带传输数据的长度(以字节计);
flags:可选项参数,若没有可传递 0;
to:存有目标地址信息的 sockaddr 结构体变量的地址;
addrlen:传递给参数 to 的地址值结构体变量的长度。

 ssize_t sendto(int sock, void *buf, size_t nbytes, int flags, struct sockaddr *to, socklen_t addrlen);

② windows 下的 socket api 接口

 socket socket(int af, int type, int protocol);
 int bind(socket sock, const struct sockaddr *addr, int addrlen);
 int connect(socket sock, const struct sockaddr *serv_addr, int addrlen);
 int listen(socket sock, int backlog);
 socket accept(socket sock, struct sockaddr *addr, int *addrlen); 
 int closesocket( socket s);
 int send(socket sock, const char *buf, int len, int flags);
 int recv(socket sock, char *buf, int len, int flags);
 int recvfrom(socket sock, char *buf, int nbytes, int flags, const struct sockaddr *from, int *addrlen);
 int sendto(socket sock, const char *buf, int nbytes, int flags, const struct sockadr *to, int addrlen);

③ tcp、udp 通信的 socket 编程流程图

tcp 通信 socket 编程流程:

详情解析TCP与UDP传输协议

udp 通信 socket 编程流程:

详情解析TCP与UDP传输协议

四、socket 的应用实例

① 基于 tcp 的本地客户端、服务端信息交互实例

本例的例子实现的功能为:本地 tcp 客户端往本地 tcp 服务端发送数据,tcp 服务端收到数据则会打印输出,同时把原数据返回给 tcp 客户端。这个例子类似于在做单片机的串口实验时,串口上位机往我们的单片机发送数据,单片机收到数据则把该数据原样返回给上位机。
windows 的程序:
服务端程序 tcp_server.c:

 #include <stdio.h>
 #include <winsock2.h>
 
 #define buf_len  100
 
 int main(void)
 {
  wsadata wd;
  socket serversock, clientsock;
  char buf[buf_len] = {0};
  sockaddr clientaddr;
  sockaddr_in serversockaddr;
  int addr_size = 0, recv_len = 0;
  
  /* 初始化操作sock需要的dll */
  wsastartup(makeword(2,2),&wd);  
  
  /* 创建服务端socket */
  if (-1 == (serversock = socket(af_inet, sock_stream, ipproto_tcp)))
  {
   printf("socket error!\n");
   exit(1);
  }
  
  /* 设置服务端信息 */
     memset(&serversockaddr, 0, sizeof(serversockaddr));  // 给结构体serversockaddr清零
     serversockaddr.sin_family = af_inet;       // 使用ipv4地址
     serversockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");// 本机ip地址
     serversockaddr.sin_port = htons(1314);      // 端口
  
  /* 绑定套接字 */
     if (-1 == bind(serversock, (sockaddr*)&serversockaddr, sizeof(sockaddr)))
  {
   printf("bind error!\n");
   exit(1);
  }
   
  /* 进入监听状态 */
  if (-1 == listen(serversock, 10))
  {
   printf("listen error!\n");
   exit(1);
  }
  
  addr_size = sizeof(sockaddr);
 
  while (1)
  {
   /* 监听客户端请求,accept函数返回一个新的套接字,发送和接收都是用这个套接字 */
   if (-1 == (clientsock = accept(serversock, (sockaddr*)&clientaddr, &addr_size)))
   {
    printf("socket error!\n");
    exit(1);
   }
 
   /* 接受客户端的返回数据 */
   int recv_len = recv(clientsock, buf, buf_len, 0);
   printf("客户端发送过来的数据为:%s\n", buf);
   
   /* 发送数据到客户端 */
   send(clientsock, buf, recv_len, 0);
   
   /* 关闭客户端套接字 */
   closesocket(clientsock);
   
   /* 清空缓冲区 */
   memset(buf, 0, buf_len);  
  }
 
  /*如果有退出循环的条件,这里还需要清除对socket库的使用*/
  /* 关闭服务端套接字 */
  //closesocket(serversock);
     /* wsacleanup();*/
 
  return 0;
}

客户端程序 tcp_client.c:

 #include <stdio.h>
 #include <winsock2.h>
 
 #define buf_len  100
 
 int main(void) {
  wsadata wd;
  socket clientsock;
  char buf[buf_len] = {0};
  sockaddr_in  serversockaddr;
  
  /* 初始化操作sock需要的dll */
  wsastartup(makeword(2,2),&wd);  
  
  /* 向服务器发起请求 */
     memset(&serversockaddr, 0, sizeof(serversockaddr));  
     serversockaddr.sin_family = af_inet;
     serversockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
     serversockaddr.sin_port = htons(1314);
  
  while (1)
  {
   /* 创建客户端socket */
   if (-1 == (clientsock = socket(af_inet, sock_stream, ipproto_tcp)))
   {
    printf("socket error!\n");
    exit(1);
   }
   if (-1 == connect(clientsock, (sockaddr*)&serversockaddr, sizeof(sockaddr)))
   {
    printf("connect error!\n");
    exit(1);
   }
   printf("请输入一个字符串,发送给服务端:");
   gets(buf);
   /* 发送数据到服务端 */
   send(clientsock, buf, strlen(buf), 0);
   
   /* 接受服务端的返回数据 */
   recv(clientsock, buf, buf_len, 0);
   printf("服务端发送过来的数据为:%s\n", buf);
   
   memset(buf, 0, buf_len);   // 重置缓冲区
   closesocket(clientsock);   // 关闭套接字
  }
  
  // wsacleanup();  /*如果有退出循环的条件,这里还需要清除对socket库的使用*/
  return 0;
 }

上面的 ip 地址概念那一部分中,有强调 127.0.0.1 这个 ip 是一个特殊的 ip 地址,这是回送地址,即本地机,一般用来测试使用。此外,端口设置为 1314,这是随意设置的,只要范围在 1024~65536 之间就可以。
使用 gcc 编译器编译,编译命令如下:

gcc tcp_client.c -o tcp_client.exe -lwsock32
gcc tcp_server.c -o tcp_server.exe -lwsock32

这里必须要加 -lwsock32 这个参数用于链接 windows 下 socket 编程必须的 winsock2 这个库。若是使用集成开发环境,则需要把 wsock32.lib 放在工程目录下,并在代码中 #include <winsock2.h> 下面加上一行 #pragma comment(lib, “ws2_32.lib”) 代码。

先启动服务端程序 tcp_server,再启动客户端程序 tcp_client,并在客户端中输入字符串,则当服务端会接收到字符串时会打印输出,与此同时也会往客户端返回相同的数据:

// tcp_server
 客户端发送过来的数据为:hello
 客户端发送过来的数据为:5201314

 // tcp_client
 请输入一个字符串,发送给服务端:hello
 服务端发送过来的数据为:hello
 请输入一个字符串,发送给服务端:5201314
 服务端发送过来的数据为:5201314
 请输入一个字符串,发送给服务端:

linux 程序
在 linux 下,“一切都是文件”,所以这里的套接字也当做文件来看待。
服务端程序 linux_tcp_server.c:

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <arpa/inet.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 
 #define buf_len  100
 
 int main(void) {
  int serverfd, clientfd;    
  char buf[buf_len] = {0};
  struct sockaddr clientaddr;
  int addr_len = 0, recv_len = 0;
  struct sockaddr_in serversockaddr;  
  int optval = 1; 
  
  /* 创建服务端文件描述符 */
  if (-1 == (serverfd = socket(af_inet, sock_stream, ipproto_tcp)))
  {
   printf("socket error!\n");
   exit(1);
  }
  
  /* 设置服务端信息 */
  
     memset(&serversockaddr, 0, sizeof(serversockaddr));  // 给结构体serversockaddr清零
     serversockaddr.sin_family = af_inet;       // 使用ipv4地址
     serversockaddr.sin_addr.s_addr = htonl(inaddr_any);  // 自动获取ip地址
     serversockaddr.sin_port = htons(6666);      // 端口
  
 
  // 设置地址和端口号可以重复使用  
     if (setsockopt(serverfd, sol_socket, so_reuseaddr, &optval, sizeof(optval)) < 0)
  {
   printf("setsockopt error!\n");
   exit(1);
  }
  
  /* 绑定操作,绑定前加上上面的socket属性可重复使用地址 */
     if (-1 == bind(serverfd, (struct sockaddr*)&serversockaddr, sizeof(struct sockaddr)))
  {
   printf("bind error!\n");
   exit(1);
  }
   
  /* 进入监听状态 */
  if (-1 == (listen(serverfd, 10)))
  {
   printf("listen error!\n");
   exit(1);
  }
  
  addr_len = sizeof(struct sockaddr);
 
  while (1)
  {
   /* 监听客户端请求,accept函数返回一个新的套接字,发送和接收都是用这个套接字 */
   if (-1 == (clientfd = accept(serverfd, (struct sockaddr*)&clientaddr, &addr_len)))
   {
    printf("accept error!\n");
    exit(1);
   }
 
   /* 接受客户端的返回数据 */
   if ((recv_len = recv(clientfd, buf, buf_len, 0)) < 0)
   {
    printf("recv error!\n");
    exit(1);
   }
   
   printf("客户端发送过来的数据为:%s\n", buf);
   
   /* 发送数据到客户端 */
   send(clientfd, buf, recv_len, 0);
   
   /* 关闭客户端套接字 */
   close(clientfd);
   
   /* 清空缓冲区 */
   memset(buf, 0, buf_len);  
  }
  return 0;
 }

客户端程序 linux_tcp_client.c:

#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <arpa/inet.h>
 #include <sys/socket.h>
 
 #define buf_len  100
 
 int main(void) {
  int clientfd;
  char buf[buf_len] = {0};
  struct sockaddr_in  serversockaddr;
  
  
  /* 向服务器发起请求 */
     memset(&serversockaddr, 0, sizeof(serversockaddr));  
     serversockaddr.sin_family = af_inet;
     serversockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
     serversockaddr.sin_port = htons(6666);
  
  while (1)
  {
   /* 创建客户端socket */
   if (-1 == (clientfd = socket(af_inet, sock_stream, ipproto_tcp)))
   {
    printf("socket error!\n");
    exit(1);
   }
   
   /* 连接 */
   if (-1 == connect(clientfd, (struct sockaddr*)&serversockaddr, sizeof(serversockaddr)))
   {
    printf("connect error!\n");
    exit(1);
   }
   
   printf("请输入一个字符串,发送给服务端:");
   gets(buf);
   /* 发送数据到服务端 */
   send(clientfd, buf, strlen(buf), 0);
   memset(buf, 0, buf_len);   // 重置缓冲区
   
   /* 接受服务端的返回数据 */
   recv(clientfd, buf, buf_len, 0);
   printf("服务端发送过来的数据为:%s\n", buf);
   
   memset(buf, 0, buf_len);   // 重置缓冲区
   close(clientfd);   // 关闭套接字
  }
  return 0;
 }

linux 下编译就不需要添加 -lwsock32 参数:

 gcc linux_tcp_server.c -o linux_tcp_server
 gcc linux_tcp_client.c -o linux_tcp_client

实验现象:

$ ./linux_tcp_server
 客户端发送过来的数据为:hello
 客户端发送过来的数据为:world

 $ ./linux_tcp_client
 请输入一个字符串,发送给服务端:hello
 服务端发送过来的数据为:hello
 请输入一个字符串,发送给服务端:world
 服务端发送过来的数据为:hello
 请输入一个字符串,发送给服务端:

在调试这份程序时,出现了绑定错误:

 $ ./linux_tcp_client
 bind error!

经上网查询发现是端口重复使用,可以在调用 bind() 函数之前调用 setsockopt() 函数以解决端口重复使用的问题:

详情解析TCP与UDP传输协议

② 基于 udp 的本地客户端、服务端信息交互实例

windows 的程序
服务端程序 udp_server.c:

 #include <stdio.h>
 #include <winsock2.h>
 
 #define buf_len  100
 
 int main(void) {
  wsadata wd;
  socket serversock;
  char buf[buf_len] = {0};
  sockaddr clientaddr;
  sockaddr_in serversockaddr;
  int addr_size = 0;
  
  
  /* 初始化操作sock需要的dll */
  wsastartup(makeword(2,2),&wd);  
  
  /* 创建服务端socket */
  if(-1 == (serversock = socket(af_inet, sock_dgram, ipproto_udp)))
  {
   printf("socket error!\n");
   exit(1);
  }
  
  /* 设置服务端信息 */
     memset(&serversockaddr, 0, sizeof(serversockaddr));  // 给结构体serversockaddr清零
     serversockaddr.sin_family = af_inet;       // 使用ipv4地址
     serversockaddr.sin_addr.s_addr = htonl(inaddr_any);  // 自动获取ip地址
     serversockaddr.sin_port = htons(1314);      // 端口
  
  /* 绑定套接字 */
  
     if (-1 == (bind(serversock, (sockaddr*)&serversockaddr, sizeof(sockaddr))))
  {
   printf("bind error!\n");
   exit(1);
  }
   
  addr_size = sizeof(sockaddr);
 
  while (1)
  {
   /* 接受客户端的返回数据 */
   int str_len = recvfrom(serversock, buf, buf_len, 0, &clientaddr, &addr_size);
   
   printf("客户端发送过来的数据为:%s\n", buf);
   
   /* 发送数据到客户端 */
   sendto(serversock, buf, str_len, 0, &clientaddr, addr_size);
   
   /* 清空缓冲区 */
   memset(buf, 0, buf_len);  
  }
 
  /*如果有退出循环的条件,这里还需要清除对socket库的使用*/
  /* 关闭服务端套接字 */
  //closesocket(serversock);
     /* wsacleanup();*/
 
  return 0;
 }

客户端程序 udp_client.c:

 #include <stdio.h>
 #include <winsock2.h>
 
 #define buf_len  100
 
 int main(void) {
  wsadata wd;
  socket clientsock;
  char buf[buf_len] = {0};
  sockaddr serveraddr;
  sockaddr_in  serversockaddr;
  int serveraddrlen = 0;
  
  /* 初始化操作sock需要的dll */
  wsastartup(makeword(2,2),&wd);  
  
  /* 创建客户端socket */
  if (-1 == (clientsock = socket(af_inet, sock_dgram, ipproto_udp)))
  {
   printf("socket error!\n");
   exit(1);
  }
  
  /* 向服务器发起请求 */
     memset(&serversockaddr, 0, sizeof(serversockaddr));  
     serversockaddr.sin_family = pf_inet;
     serversockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
     serversockaddr.sin_port = htons(1314);
  
  serveraddrlen = sizeof(serveraddr);
  
  while (1)
  {
   printf("请输入一个字符串,发送给服务端:");
   gets(buf);
   /* 发送数据到服务端 */
   sendto(clientsock, buf, strlen(buf), 0, (struct sockaddr*)&serversockaddr, sizeof(serversockaddr));
   
   /* 接受服务端的返回数据 */
   recvfrom(clientsock, buf, buf_len, 0, &serveraddr, &serveraddrlen);
   printf("服务端发送过来的数据为:%s\n", buf);
   
   memset(buf, 0, buf_len);   // 重置缓冲区
  }
  
  closesocket(clientsock);   // 关闭套接字
  // wsacleanup();  /*如果有退出循环的条件,这里还需要清除对socket库的使用*/
  return 0;
 }

linux 下的程序
服务端程序 linux_udp_server.c:

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <arpa/inet.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 
 #define buf_len  100
 
 int main(void) {
  int serverfd;
  char buf[buf_len] = {0};
  struct sockaddr clientaddr;
  struct sockaddr_in serversockaddr;
  int addr_size = 0; 
  int optval = 1; 
  
  /* 创建服务端socket */
  if ( -1 == (serverfd = socket(af_inet, sock_dgram, ipproto_udp)))
  {
   printf("socket error!\n");
   exit(1);
  }
  
  /* 设置服务端信息 */
     memset(&serversockaddr, 0, sizeof(serversockaddr));  // 给结构体serversockaddr清零
     serversockaddr.sin_family = af_inet;       // 使用ipv4地址
     serversockaddr.sin_addr.s_addr = htonl(inaddr_any);  // 自动获取ip地址
     serversockaddr.sin_port = htons(1314);      // 端口
  
  // 设置地址和端口号可以重复使用  
     if (setsockopt(serverfd, sol_socket, so_reuseaddr, &optval, sizeof(optval)) < 0)
  {
   printf("setsockopt error!\n");
   exit(1);
  }
  
  /* 绑定操作,绑定前加上上面的socket属性可重复使用地址 */
     if (-1 == bind(serverfd, (struct sockaddr*)&serversockaddr, sizeof(serversockaddr)))
  {
   printf("bind error!\n");
   exit(1);
  }
  
  addr_size = sizeof(clientaddr);
 
  while (1)
  {
   /* 接受客户端的返回数据 */
   int str_len = recvfrom(serverfd, buf, buf_len, 0, &clientaddr, &addr_size);
   
   printf("客户端发送过来的数据为:%s\n", buf);
   
   /* 发送数据到客户端 */
   sendto(serverfd, buf, str_len, 0, &clientaddr, addr_size);
   
   /* 清空缓冲区 */
   memset(buf, 0, buf_len);  
  }
  
  close(serverfd);
 
  return 0;
 }

客户端程序 linux_udp_client.c:

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <arpa/inet.h>
 #include <sys/socket.h>
 
 #define buf_len  100
 
 int main(void) {
  int clientfd;
  char buf[buf_len] = {0};
  struct sockaddr serveraddr;
  int addr_size = 0;
  struct sockaddr_in  serversockaddr;
  
  /* 创建客户端socket */
  if (-1 == (clientfd = socket(af_inet, sock_dgram, ipproto_udp)))
  {
   printf("socket error!\n");
   exit(1);
  }
  
  /* 向服务器发起请求 */
     memset(&serversockaddr, 0, sizeof(serversockaddr));  
     serversockaddr.sin_family = pf_inet;
     serversockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
     serversockaddr.sin_port = htons(1314);
  
  addr_size = sizeof(serveraddr);
  
  while (1)
  {
   printf("请输入一个字符串,发送给服务端:");
   gets(buf);
   /* 发送数据到服务端 */
   sendto(clientfd, buf, strlen(buf), 0, (struct sockaddr*)&serversockaddr, sizeof(serversockaddr));
   
   /* 接受服务端的返回数据 */
   recvfrom(clientfd, buf, buf_len, 0, &serveraddr, &addr_size);
   printf("服务端发送过来的数据为:%s\n", buf);
   
   memset(buf, 0, buf_len);   // 重置缓冲区
  }
  
  close(clientfd);   // 关闭套接字
  
  return 0;
 }

以上就是详情解析tcp与udp传输协议的详细内容,更多关于解析tcp与udp传输协议的资料请关注其它相关文章!