【计算机网络】TCP和UDP的封装以及案例

凡菲儿

于 2024-07-26 17:36:22 发布

阅读量470

点赞数 25

文章标签：计算机网络 tcp/ip udp

本文链接：https://blog.csdn.net/m0_44965777/article/details/140710848

版权

TCP和UDP的封装以及案例

背景知识
TCP实现
UDP实现
封装Network
用NetWork再次实现TCP和UDP
小知识点

背景知识

TCP：传输控制协议（Transmission Control Protocol）
UDP：用户数据报协议（User Datagram Protocol）
底层遵循TCP\IP协议，在系统层上以Socket接口方式呈现
在这里插入图片描述
使用到的函数

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

功能：创建socket对象
domain：指定协议族
AF_INET 基于IPv4地址通信（常用）
AF_INET6 基于IPv6地址通信
AF_UNIX 基于本地通信
type：指定套接字类型
SOCK_STREAM 数据流协议 TCP
SOCK_DGRAM 数据报协议 UDP
protocol：指定协议
IPPROTO_TCP（TCP协议）
IPPROTO_UDP（UDP协议）
写0可以不指定（常用）

//网络地址结构体类型
#include <netinet/in.h>
struct sockaddr_in {
	__kernel_sa_family_t sin_family; // AF_INET
	__be16 sin_port;           // 端口号  大端数据 用htons转
	struct in_addr sin_addr;   // IP地址 大端数据  用inet_addr转
};  
struct in_addr {
    __be32  s_addr;
};

192.168.1.23
192<24|168<16|1<8|23<0
点分十进制的小端转大端

大小端数据转换函数：

#include <arpa/inet.h>
uint32_t htonl(uint32_t hostlong);
//功能：把4字节的本地字节序转换成网络字节序
uint16_t htons(uint16_t hostshort);
//功能：把2字节的本地字节序转换成网络字节序 （常用来给端口号小端转大端）
uint32_t ntohl(uint32_t netlong);
//功能：把4字节的网络字节序转换成本地字节序
uint16_t ntohs(uint16_t netshort);
//功能：把2字节的网络字节序转换成本地字节序

ip地址转换函数：

in_addr_t inet_addr(const char *cp);

功能：把字符串格式的点分十进制表示的ip地址转换成整数形式的ip地址(大端)

char *inet_ntoa(struct in_addr in);

功能：把整数形式的ip地址转换成字符串格式的点分十进制表示的ip地址

一个小demo，测试一下小端转大端的效果

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main(int argc, char** argv) 
{
    struct in_addr a;
    char b[16] = "192.168.1.6";
    int e = inet_aton(b, &a); //将b指向的字符串，转换成为in_addr 对应的ip地址
    printf("ret val = %d\n", e); //返回1为成功，0为失败
    printf("a=%#x\n",a.s_addr);

    printf("htonl(a)=%#x\n",htonl(a.s_addr)); //将32bit的数据从 主机字节序 转换为 网络字节序(小端->大端)
    printf("htons(a)=%#x\n",htons(a.s_addr)); //将16bit的数据从 主机字节序 转换为 网络字节序
    
    char *c = inet_ntoa(a);将 in_addr类型的ip地址转换成诸如 “192.168.1.66”格式的ip地址
    printf("c=%s\n", c);
    
    return 0;
}

在这里插入图片描述
网络地址相关结构体，函数

int listen(int sockfd, int backlog);

功能：监听socket，数据流通信时使用
sockfd：socket描述符
backlog：等待连接socket的排队数量，默认最大128
返回值：成功返回0，失败返回-1

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

功能：等待客户端连接
sockfd：受监听的socket描述符
addr：获取客户端的地址
addrlen：既是输入，也是输出这里要取地址！！！
1、既告诉accept函数当前计算机地址结构体的字节数
2、同时也能获取客户端的地址结构体字节数
返回值：连接成功返回一个新的连接后的socket描述符，连接失败返回-1
注意：如果没有连接，则阻塞

   int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);

功能：连接服务器
sockfd：socket描述符
addr：服务器的公网ip地址结构体指针
addrlen：地址结构体的字节数，用于区分 sockaddr_un还是sockaddr_in
功能：成功返回0，失败返回-1

注意：TCP收发数据可以继续使用read、write

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

功能：TCP协议通信时专用的数据发送函数
sockfd：连接成功的socket描述符
buf：待发送数据的首地址
len：要发送的字节数
flags：
0 阻塞发送（常用）
1 不阻塞发送
返回值：成功发送的字节数
-1 出现错误
0 连接断开

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

功能：TCP协议通信时专用的接收数据函数
sockfd：连接成功的socket描述符
buf：存储数据缓冲区内存首地址
len：缓冲区的大小
flags：
0 阻塞接收（常用）
1 不阻塞接收
返回值：成功接收的字节数
-1 出现错误
0 连接断开

在这里插入图片描述

  ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,const struct sockaddr *dest_addr, socklen_t addrlen);

功能：UDP协议发送数据
sockfd：socket描述符
buf：待发送数据内存首地址
len：待发送数据的字节数
flags：是否阻塞一般写0阻塞即可
dest_addr：通信目标的地址
addrlen：地址结构体的字节数
返回值：成功发送的字节数
0 通信关闭
-1 出现错误

   ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,struct sockaddr *src_addr, socklen_t *addrlen);

功能：UDP协议接收数据
sockfd：socket描述符
buf：存储接收数据的缓冲区内存首地址
len：缓冲区的字节数
flags：是否阻塞一般写0阻塞即可
src_addr：用于存储发送者的地址
addrlen：既是输入，也是输出
1、既告诉函数当前src_addr结构体的字节数
2、同时也能实际接收到发送者的地址结构体字节数
成功：成功接收到的字节数
0 通信关闭
-1 出现错误

TCP实现

TCP服务端

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdlib.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<string.h>

typedef struct sockaddr* SP;

//服务端

void server(int cli_fd){
	char buf[4096] = {};
	size_t buf_size = sizeof(buf);
	for(;;){
		//接收数据
	//	int ret = read(cli_fd,buf,buf_size);
		int ret = recv(cli_fd,buf,buf_size,0);
		if(ret <= 0 || strcmp("quit",buf) == 0){
			printf("客户端%d退出\n",cli_fd);
			break;
		}
		printf("form %d recv:%s bits:%d\n",cli_fd,buf,ret);

		//响应请求
		//把传过来的数据拼接“：return”后返回客户端
		strcat(buf,":return");
//		ret = write(cli_fd,buf,strlen(buf)+1);
		ret = send(cli_fd,buf,strlen(buf)+1,0);
		if(ret <= 0){
			printf("客户端%d退出",cli_fd);
			break;
		}
	}
	//关闭
	close(cli_fd);
	exit(0);
}

int main(int argc, const char* argv[])
{
	//创建套接字
	int sockfd = socket(AF_INET,SOCK_STREAM,0);
	if(sockfd < 0){
		perror("socket");
		return EXIT_FAILURE;
	}
	//准备自己的地址
	struct sockaddr_in addr = {};
	addr.sin_family = AF_INET;
	addr.sin_port = htons(9997);
	addr.sin_addr.s_addr = inet_addr("127.0.0.1");

	//绑定
	socklen_t addrlen = sizeof(addr);
	if(bind(sockfd,(SP)&addr,addrlen)){
		perror("bind");
		return EXIT_FAILURE;
	}

	//监听
	if(listen(sockfd,5)){
		perror("listen");
		return EXIT_FAILURE;
	}

	for(;;){
		//等待连接
		struct sockaddr_in src_addr = {};
		int cli_fd = accept(sockfd,(SP)&src_addr,&addrlen);
		if(cli_fd < 0){
			perror("accept");
			continue;
		}
		//创建进程服务
		if(fork() == 0){
			server(cli_fd);		
		}
	}
		
	return 0;
}

TCP客户端

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdlib.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<string.h>

typedef struct sockaddr* SP;

//客户端

int main(int argc, const char* argv[])
{
	//创建套接字
	int cli_fd = socket(AF_INET,SOCK_STREAM,0);
	if(cli_fd < 0){
		perror("socket");
		return EXIT_FAILURE;
	}
	//准备自己的地址
	struct sockaddr_in addr = {};
	addr.sin_family = AF_INET;
	addr.sin_port = htons(9997);
	addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	socklen_t addrlen = sizeof(addr);
	
	//连接服务器
	if(connect(cli_fd,(SP)&addr,addrlen)){
		perror("connect");
		return EXIT_FAILURE;
	}

	char buf[4096] = {};
	size_t buf_size = sizeof(buf);

	for(;;){
		printf(">>>>");
		scanf("%s",buf);
		//发送数据
	//	int ret = write(cli_fd,buf,strlen(buf)+1);
		int ret = send(cli_fd,buf,strlen(buf)+1,0);
		if(ret <= 0){
			printf("服务器正在升级，请稍后重试\n");
			break;
		}
		if(strcmp("quit",buf) == 0){
			printf("结束通信\n");
			break;
		}
		//接收响应
//		ret = read(cli_fd,buf,sizeof(buf));
		ret = recv(cli_fd,buf,sizeof(buf),0);
		if(ret <= 0){
			printf("服务器正在升级，请稍候重试\n");
			break;
		}
		printf("read:%s bits:%d \n",buf,ret);
	}
	//关闭
	close(cli_fd);
		
	return 0;
}

代码编译

gcc 01tcp.c -o server
gcc 02tcp.c -o client

运行效果
在这里插入图片描述

UDP实现

UDP服务端

UDP客户端

代码编译
运行效果

封装Network

从上述的操作可以看出，TCP和UDP存在很多重复代码，如何后续需要搭建服务器，那么我们可以将重复的部分封装成一个共享库，方便后续调用实现

network.h头文件

#ifndef NETWORK_H
#define NETWORK_H
#include <stdio.h>
#include <stdbool.h>
#include <netinet/in.h>

typedef struct NetWork
{
	int type; //通信协议的类型 TCP/UDP
	int sock_fd; //socket描述符
	struct sockaddr_in addr; //通信地址
	socklen_t addrlen; //通信地址字节数
	bool issvr; //判断是否是服务器
}NetWork;

typedef struct sockaddr *SP;

//分配内存，创建socket对象，初始化地址，绑定，监听，连接
NetWork *init_nw(int type,short port,const char *ip,bool issvr);

//等待连接，只有type是SOCK_STREAM且是服务器才调用
NetWork *accept_nw(NetWork *svr_nw);

//send或sendto
int send_nw(NetWork *nw,void *buf,size_t len);

//recv或recvfrom
int recv_nw(NetWork *nw,void *buf,size_t len);

//关闭socket对象，且释放资源
void close_nw(NetWork *nw);

//获取ip地址
const char *getip_nw(NetWork *nw);

#endif//NETWORK_H

network.c

#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include "network.h"

//分配内存，创建socket对象，初始化地址，绑定，监听，连接
NetWork *init_nw(int type,short port,const char *ip,bool issvr)
{
	//分配内存
	NetWork *nw = malloc(sizeof(NetWork));
	nw->sock_fd = socket(AF_INET,type,0);
	if(-1 == nw->sock_fd)
	{
		free(nw);
		perror("socket");
		return NULL;
	}
	nw->addrlen = sizeof(struct sockaddr_in);
	bzero(&nw->addr,nw->addrlen);
	nw->addr.sin_family = AF_INET;
	nw->addr.sin_port = htons(port);
	nw->addr.sin_addr.s_addr = inet_addr(ip);

	nw->type = type;
	nw->issvr = issvr;
	
	if(issvr)
	{
		//是服务器
		//TCP和UDP都需要绑定bind
		if(bind(nw->sock_fd,(SP)&nw->addr,nw->addrlen))
		{
			free(nw);
			perror("bind");
			return NULL;
		}
		//TCP需要监听listen
		if(SOCK_STREAM == type && listen(nw->sock_fd,50))
		{
			free(nw);
			perror("listen");
			return NULL;
		}
	}
	else if(SOCK_STREAM == type)
	{
		//是客户端
		//TCP需要connect,UDP不需要任何操作
		if(connect(nw->sock_fd,(SP)&nw->addr,nw->addrlen))
		{
			free(nw);
			perror("connect");
			return NULL;
		}
	}
	return nw;
}

//等待连接，TCP需要accept,UDP不需要任何操作
NetWork *accept_nw(NetWork *svr_nw)
{
	//为新的network分配内存并初始化
	NetWork *nw = malloc(sizeof(NetWork));
	nw->addrlen = svr_nw->addrlen;
	nw->type = SOCK_STREAM;
	nw->issvr = true;

	nw->sock_fd = accept(svr_nw->sock_fd,(SP)&nw->addr,&nw->addrlen);
	if(nw->sock_fd < 0)
	{
		free(nw);
		perror("accept");
		return NULL;
	}
	return nw;
}

//send或sendto
int send_nw(NetWork *nw,void *buf,size_t len)
{
	//TCP
	if(SOCK_STREAM == nw->type)
	{
		return send(nw->sock_fd,buf,len,0);
	}
	//UDP
	else
	{
		return sendto(nw->sock_fd,buf,len,0,(SP)&nw->addr,nw->addrlen);
	}
}

//recv或recvfrom
int recv_nw(NetWork *nw,void *buf,size_t len)
{
	//TCP
	if(SOCK_STREAM == nw->type)
	{
		return recv(nw->sock_fd,buf,len,0);
	}
	//UDP
	else
	{
		return recvfrom(nw->sock_fd,buf,len,0,(SP)&nw->addr,&nw->addrlen);
	}
}

//关闭socket对象，且释放资源
void close_nw(NetWork *nw)
{
	close(nw->sock_fd);
	free(nw);
}

//获取ip地址
const char *getip_nw(NetWork *nw)
{
	return inet_ntoa(nw->addr.sin_addr);
}

用NetWork再次实现TCP和UDP

TCP服务端

#include<stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include "network.h"
//TCP服务端

int main(int argc, const char* argv[])
{
	//init_nw(类型，端口号，IP，是否服务器)
	NetWork *svr_nw = init_nw(SOCK_STREAM,atoi(argv[2]),argv[1],true);
	if(NULL == svr_nw)
	{
		perror("init_nw");
		return EXIT_FAILURE;
	}
	//TCP是一对一连接的，所以要么父子进程，要么多线程才可以
	NetWork *nw = NULL;
	do
	{
		nw = accept_nw(svr_nw);
		if(NULL == nw)
		{
			perror("accept_nw");
			close_nw(nw);
			return EXIT_FAILURE;
		}
	}while(fork());

	char buf[4096] = {};
	for(;;)
	{
		int ret = recv_nw(nw,buf,sizeof(buf));
		if(ret <= 0 || 0 == strcmp("quit",buf))
		{
			printf("客户端%d退出\n",nw->sock_fd);
			close_nw(nw);
			break;
		}
		printf("form:%d recv_nw:%s bits:%d\n",nw->sock_fd,buf,ret);
		strcat(buf,":return");
		ret = send_nw(nw,buf,strlen(buf)+1);
		if(ret <= 0)
		{
			printf("客户端%d退出\n",nw->sock_fd);
			close_nw(nw);
			break;
		}
	}
	close_nw(svr_nw);
	return 0;
}

TCP客户端

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include "network.h"

int main(int argc, const char* argv[])
{
	NetWork *nw = init_nw(SOCK_STREAM,atoi(argv[2]),argv[1],false);
	if(NULL == nw)
	{
		perror("init_nw");
		return EXIT_FAILURE;
	}
	char buf[4096] = {};
	for(;;)
	{
		printf(">>>>");
		scanf("%s",buf);
		int ret = send_nw(nw,buf,strlen(buf)+1);
		if(ret <= 0)
		{
			printf("服务器正在升级，请稍后重试\n");
			break;
		}
		if(0 == strcmp("quit",buf))
		{
			printf("结束通信\n");
			break;
		}
		bzero(buf,sizeof(buf));
		ret = recv_nw(nw,buf,sizeof(buf));
		if(ret <= 0)
		{
			printf("服务器正在升级，请稍后重试\n");
			break;
		}
		printf("read:%s bits:%d\n",buf,ret);
	}
	close_nw(nw);
	return 0;
}

代码编译

gcc tcp_s_nw.c network.c -o tcpS
gcc tcp_c_nw.c network.c -o tcpC

运行效果
在这里插入图片描述

小知识点

凡菲儿

关注

25
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
【计算机网络】TCP和UDP的封装以及案例

从上述的操作可以看出，TCP和UDP存在很多重复代码，如何后续需要搭建服务器，那么我们可以将重复的部分封装成一个共享库，方便后续调用实现。：地址结构体的字节数，用于区分 sockaddr_un还是sockaddr_in。功能：把字符串格式的点分十进制表示的ip地址转换成整数形式的ip地址(大端)功能：把整数形式的ip地址转换成字符串格式的点分十进制表示的ip地址。1、既告诉函数当前src_addr结构体的字节数。：既是输入，也是输出这里要取地址！功能：TCP协议通信时专用的数据发送函数。
复制链接

扫一扫