[网络协议]【计算机网络】网络通信模型及其Linux下代码实现TCP&UDP

网络通信：
所谓网络通信，就是底层遵循TCP/IP协议，而在系统层以Socket接口方式呈现。

基于TCP协议的网络通信模型：

    服务端                          		客户端
    创建socket对象                  		创建socket对象
    准备通信地址+端口号(本机) sockaddr_in   准备通信地址+端口号(目标)  
    绑定socket和通信地址     bind      	连接服务端			connect	
    设置监听和排除数量        listen
    等待客户端连接           accept
    分配新的socket对象+进程或线程   
    接收请求            send/write        发送请求
    响应请求            recv/read         接收响应
    关闭socket         close             关闭socket     close

UDP协议的区别在于：
1.socket时的参数.
2.接收响应使用的函数不同而已（write/read仍可用 因为linux的哲学之一就是一切皆文件）.
3.没有了监听和接收的步骤.

TCP通信使用到的函数：

   int socket(int domain, int type, int protocol);
    domain：
        AF_INET 基于ipv4的网络通信
    type：
        SOCK_STREAM 数据流 TCP

 struct sockaddr_in
    {
        int sin_family; //与domain一致即可
        in_port_t sin_port; //端口号，大端数据
        struct in_addr sin_addr;  //ip地址，大端数据
    };

    大小端数据转换：
    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地址

    int listen(int sockfd, int backlog);
    功能：开户监听并设置排队数量
    sockfd：要监听的socket对象描述符
    backlog：能够排除的数量

    int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
    功能：等待客户端连接
    sockfd：受监听的socket对象描述符
    addr：接收客户端的地址
    addrlen：既是输入，也是输出
        1、告诉系统addr的字节数
        2、系统反馈实际接收到的发送者的地址字节数
    返回值：分配新的socket对象描述符，如果出现错误则返回-1。

    int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
    功能：连接服务端
    sockfd：socket对象描述符   
    addr：服务端地址
    addrlen：地址结构体字节数
    返回值：成功返回0，失败返回-1。

    注意：收发数据可以继续使用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 连接

基于UDP协议的网络通信模型使用到的函数：

    int socket(int domain, int type, int protocol);
    domain：
        AF_INET 基于ipv4的网络通信
    type：
        SOCK_DGRAM 数据报 UDP
    UDP协议专用的收发数据函数：
    ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,const struct sockaddr *dest_addr, socklen_t addrlen);
    功能：发送数据
    sockfd：socket对象描述符
    buf：要发送的数据的首地址
    len：要发送的字节数
    flags：是否阻塞，写0即可
    dest_addr：通信目标的地址
    addrlen：地址结构体的字节数
    返回值：成功发送的字节数
        -1 出现错误
        0 通信关闭

    ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,struct sockaddr *src_addr, socklen_t *addrlen);
    功能：接收数据
    sockfd：socket对象描述符
    buf：缓冲区的首地址
    len：缓冲区的大小
    flags：是否阻塞，写0即可
    src_addr：用于存储发者的地址
    addrlen：既是输入，也是输出
        1、告诉系统src_addr的字节数
        2、系统反馈实际接收到的发送者的地址字节数
    返回值：成功接收到的数据字节数
        -1 出现错误
        0 通信关闭

以下是代码示例：

TCP服务端

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

typedef struct sockaddr* SAP;

void error_exit(const char* error)
{
	perror(error);
	exit(-1);
}

int main(int argc,const char* argv[])
{
	// 创建socket对象
	int sockfd = socket(AF_INET,SOCK_STREAM,0);
	if(0 > sockfd)
		error_exit("socket");

	// 准备网络地址(本机)
	struct sockaddr_in addr = {};
	addr.sin_family = AF_INET;
	addr.sin_port = htons(atoi(argv[2]));
	addr.sin_addr.s_addr = inet_addr(argv[1]);

	// 绑定socket对象和地址
	if(bind(sockfd,(SAP)&addr,sizeof(addr)))
		error_exit("bind");

	// 开启监听且设置队列长度
	if(listen(sockfd,5))
		error_exit("listen");

	struct sockaddr_in from_addr;
	socklen_t addrlen = sizeof(addr);

	// 等待连接
	int fd;
	do{
		fd = accept(sockfd,(SAP)&from_addr,&addrlen);
		if(0 > fd)
			error_exit("accept");
	}while(fork());

	printf("from addr:%s\n",inet_ntoa(from_addr.sin_addr));
	char buf[4096];
	// 收发数据
	for(;;)
	{
		int ret = read(fd,buf,sizeof(buf));
		printf("read:%s bytes:%d\n",buf,ret);
		if(0 > ret || !strcmp("quit",buf))
			break;

		strcat(buf,":return");
		ret = write(fd,buf,strlen(buf)+1);
		if(0 > ret || !strcmp("quit",buf))
			break;
	}

	// 关闭
	close(fd);
}

TCP客户端

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

typedef struct sockaddr* SAP;

void error_exit(const char* error)
{
	perror(error);
	exit(-1);
}

int main(int argc,const char* argv[])
{
	// 创建socket
	int sockfd = socket(AF_INET,SOCK_STREAM,0);
	if(0 > sockfd)
		error_exit("socket");

	// 准备地址(服务器地址)
	struct sockaddr_in addr = {};
	addr.sin_family = AF_INET;
	addr.sin_port = htons(atoi(argv[2]));
	addr.sin_addr.s_addr = inet_addr(argv[1]);

	// 连接
	if(connect(sockfd,(SAP)&addr,sizeof(addr)))
		error_exit("connect");

	// 收发数据
	char buf[4096];
	for(;;)
	{
		printf(">>>");
		scanf("%s",buf);

		int ret = write(sockfd,buf,strlen(buf)+1);
		printf("write:%s bytes:%d\n",buf,ret);
		if(0 >= ret || !strcmp("quit",buf))
			break;

		ret = read(sockfd,buf,sizeof(buf));
		printf("read:%s bytes:%d\n",buf,ret);
		if(0 >= ret || !strcmp("quit",buf))
			break;

	}

	// 关闭
	close(sockfd);
}

UDP发送端

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

typedef struct sockaddr* SAP;

void error_exit(const char* error)
{
	perror(error);
	exit(-1);
}

int main(int argc,const char* argv[])
{
	// 创建socket对象
	int sockfd = socket(AF_INET,SOCK_DGRAM,0);
	if(0 > socket)
		error_exit("socket");

	// 准备地址
	struct sockaddr_in addr = {};
	addr.sin_family = AF_INET;
	addr.sin_port = htons(atoi(argv[2]));
	addr.sin_addr.s_addr = inet_addr(argv[1]);
	socklen_t addrlen = sizeof(addr);

	struct sockaddr_in from_addr;
	char buf[4096];

	for(;;)
	{
		printf(">>>");
		scanf("%s",buf);
		// 发送数据
		int ret = sendto(sockfd,buf,strlen(buf)+1,0,
						(SAP)&addr,addrlen);
		if(0 >= ret || !strcmp("quit",buf))
			break;

		// 接收数据
		ret = recvfrom(sockfd,buf,sizeof(buf),0,
						(SAP)&from_addr,&addrlen);
		if(0 >= ret)
			break;

		printf("recv:%s from:%s bytes:%d\n",buf,inet_ntoa(from_addr.sin_addr),ret);
	}

	// 关闭socket对象
	close(sockfd);
}

UDP接收端

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

typedef struct sockaddr* SAP;

void error_exit(const char* error)
{
	perror(error);
	exit(-1);
}

int main(int argc,const char* argv[])
{
	// 创建socket对象
	int sockfd = socket(AF_INET,SOCK_DGRAM,0);
	if(0 > socket)
		error_exit("socket");

	// 准备地址
	struct sockaddr_in addr = {};
	addr.sin_family = AF_INET;
	addr.sin_port = htons(atoi(argv[2]));
	addr.sin_addr.s_addr = inet_addr(argv[1]);
	socklen_t addrlen = sizeof(addr);

	// 绑定地址和socket对象
	if(bind(sockfd,(SAP)&addr,addrlen))
		error_exit("bind");

	struct sockaddr_in from_addr;
	char buf[4096];

	for(;;)
	{
		// 接收数据
		int ret = recvfrom(sockfd,buf,sizeof(buf),0,(SAP)&from_addr,&addrlen);
		if(0 >= ret)
			break;

		printf("recv:%s from:%s bytes:%d\n",buf,inet_ntoa(from_addr.sin_addr),ret);
		strcat(buf,":return");

		// 发送数据
		ret = sendto(sockfd,buf,strlen(buf)+1,0,(SAP)&from_addr,addrlen);
		if(0 >= ret)
			break;
	}

	// 关闭socket对象
	close(sockfd);
}