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/UDPint 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_Hnetwork.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都需要绑定bindif(bind(nw->sock_fd,(SP)&nw->addr,nw->addrlen)){free(nw);perror("bind");return NULL;}//TCP需要监听listenif(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)
{//TCPif(SOCK_STREAM == nw->type){return send(nw->sock_fd,buf,len,0);}//UDPelse{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)
{//TCPif(SOCK_STREAM == nw->type){return recv(nw->sock_fd,buf,len,0);}//UDPelse{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
运行效果
