8.15嵌入式作业（TCP服务器模型及域套接字模型）

最新推荐文章于 2023-04-11 21:18:22 发布
最新推荐文章于 2023-04-11 21:18:22 发布
阅读量105 收藏 2
点赞数 1
文章标签： 服务器 tcp/ip 网络 ubuntu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55853947/article/details/126353553
版权

文章目录

作业内容

  1. 复习今天学的4个模型：
    <1> 多进程并发服务器
    <2> 多线程并发服务器
    <3> TCP本地通信
    <4> UDP本地通信
  2. 抓包

1.1 多进程并发服务器

主要代码

//信号处理函数
void handler(int sig)
{
	//回收僵尸进程
	//回收成功则再回收一次，直到回收失败或者没有回收到为止
	while(waitpid(-1, NULL, WNOHANG) > 0);
}

int main(int argc, const char *argv[])
{
	//捕获17号信号 SIGCHLD
	sighandler_t s = signal(17, handler);
	if(SIG_ERR == s)
	{
		ERR_MSG("signal");
		return -1;
	}

	//创建流式套接字
	int sfd = socket(AF_INET, SOCK_STREAM, 0);
	if(sfd < 0)
	{
		ERR_MSG("socket");
		return -1;
	}
	printf("create socket success\n");

	//允许端口快速重用
	int reuse = 1;
	if(setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse)) < 0)
	{
		ERR_MSG("setsockopt");
		return -1;
	}

	//填充地址信息结构体，真实的地址信息结构体与协议族相关
	//AF_INET，所以详情请看man 7 ip
	struct sockaddr_in sin;
	sin.sin_family 		= AF_INET;
	sin.sin_port 		= htons(PORT); 		//网络字节序的端口号
	sin.sin_addr.s_addr = inet_addr(IP); 	//网络字节序的IP地址

	//将地址信息结构体绑定到套接字上
	if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
	{
		ERR_MSG("bind");
		return -1;
	}
	printf("bind success\n");

	//将套接字设置为被动监听状态，让内核去监听是否有客户端连接;
	if(listen(sfd, 10) < 0)
	{
		ERR_MSG("listen");
		return -1;
	}
	printf("listen success\n");

	struct sockaddr_in cin;
	socklen_t addrlen = sizeof(cin);

	int newfd = 0;
	pid_t pid = 0;

	//从已完成连接的队列头中，取出一个客户端的信息，创建生成一个新的套接字文件描述符，
	//该文件描述符才是与客户端通信的文件描述符!!!
	
	while(1)
	{
		//父进程只负责连接
		newfd = accept(sfd, (struct sockaddr*)&cin, &addrlen);
		if(newfd < 0)
		{
			perror("accept");
			return -1;
		}

		//网络字节序的IP-->点分十进制  网络字节序的port--->本机字节序
		printf("[%s : %d] newfd = %d\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port),newfd);

		//一旦连接成功，则需要创建一个子进程用于与客户端进行交互
		pid = fork();
		if(pid > 0)
		{
			//父进程运行
			close(newfd);
		}
		else if(0 == pid)
		{
			close(sfd);

			//子进程运行，子进程负责与客户端交互
			rcv_cli_msg(newfd, cin);

			close(newfd);
			//子进程只负责交互，所以不能让子进程继续往后运行，需要直接退出
			exit(0);
		}
		else
		{
			ERR_MSG("fork");
			return -1;
		}
	}
	close(sfd);
	return 0;
}

int rcv_cli_msg(int newfd, struct sockaddr_in cin)
{
	char buf[128] = "";
	ssize_t res = 0;
	while(1)
	{
		bzero(buf, sizeof(buf));
		//循环接收
		res = recv(newfd, buf, sizeof(buf), 0);
		if(res < 0)
		{
			ERR_MSG("recv");
			return -1;
		}
		else if(0 == res)
		{
			printf("[%s : %d] newfd = %d client off-line\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), newfd);
			break;
		}
		printf("[%s : %d] newfd = %d : %s\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), newfd, buf);

		//发送数据
		strcat(buf, "*_*"); 		//可以改成从终端获取
		if(send(newfd, buf, sizeof(buf), 0) < 0)
		{
			ERR_MSG("send");
			return -1;
		}
		printf("send message success\n");
	}
	return 0;
}

抓包及测试结果

在这里插入图片描述
通过小飞机软件创建多个端口号分别连接TCP服务器并向服务器发送信息
在这里插入图片描述
终端可以接收到小飞机发来的信息
在这里插入图片描述
使用wireshark软件进行抓包，可以抓取客户端与服务器间通信时发送的数据包信息，如连接时的“三次握手”和断开连接时的“四次挥手”。

1.2 多线程并发服务器

主要代码

//需要传参到线程中的成员
struct msg
{
	int newfd;
	struct sockaddr_in cin;
};

//线程处理函数
void* rcv_cli_msg(void* arg)
{
	//分离分支线程
	pthread_detach(pthread_self());

	int newfd = (*(struct msg*)arg).newfd;
	struct sockaddr_in cin = (*(struct msg*)arg).cin;

	char buf[128] = "";
	ssize_t res = 0;
	while(1)
	{
		bzero(buf, sizeof(buf));
		//循环接收
		res = recv(newfd, buf, sizeof(buf), 0);
		if(res < 0)
		{
			ERR_MSG("recv");
			break;
		}
		else if(0 == res)
		{
			printf("[%s : %d] newfd = %d client off-line\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), newfd);
			break;
		}
		printf("[%s : %d] newfd = %d : %s\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), newfd, buf);

		//发送数据
		strcat(buf, "*_*"); 		//可以改成从终端获取
		if(send(newfd, buf, sizeof(buf), 0) < 0)
		{
			ERR_MSG("send");
			break;
		}
		printf("send message success\n");
	}
	close(newfd);

	pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
	//创建流式套接字
	int sfd = socket(AF_INET, SOCK_STREAM, 0);
	if(sfd < 0)
	{
		ERR_MSG("socket");
		return -1;
	}
	printf("create socket success\n");

	//允许端口快速重用
	int reuse = 1;
	if(setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse)) < 0)
	{
		ERR_MSG("setsockopt");
		return -1;
	}

	//填充地址信息结构体，真实的地址信息结构体与协议族相关
	//AF_INET，所以详情请看man 7 ip
	struct sockaddr_in sin;
	sin.sin_family 		= AF_INET;
	sin.sin_port 		= htons(PORT); 	//网络字节序的端口号
	sin.sin_addr.s_addr = inet_addr(IP); 	//网络字节序的IP地址

	//将地址信息结构体绑定到套接字上
	if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
	{
		ERR_MSG("bind");
		return -1;
	}
	printf("bind success\n");

	//将套接字设置为被动监听状态，让内核去监听是否有客户端连接;
	if(listen(sfd, 10) < 0)
	{
		ERR_MSG("listen");
		return -1;
	}
	printf("listen success\n");

	struct sockaddr_in cin;
	socklen_t addrlen = sizeof(cin);

	int newfd = 0;
	pthread_t tid;
	struct msg cliInfo;

	//从已完成连接的队列头中，取出一个客户端的信息，创建生成一个新的套接字文件描述符，
	//该文件描述符才是与客户端通信的文件描述符!!!
	
	while(1)
	{
		//主线程主要负责连接
		newfd = accept(sfd, (struct sockaddr*)&cin, &addrlen);
		if(newfd < 0)
		{
			perror("accept");
			return -1;
		}

		//网络字节序的IP-->点分十进制  网络字节序的port--->本机字节序
		printf("[%s : %d] newfd = %d\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port),newfd);

		cliInfo.newfd = newfd;
		cliInfo.cin = cin;

		//一旦连接成功，则需要创建一个分支线程用于与客户端进行交互
		if(pthread_create(&tid, NULL, rcv_cli_msg, (void*)&cliInfo) != 0)
		{
			ERR_MSG("pthread_create");
			return -1;
		}

		//分离分支线程
		//pthread_detach(tid);
	}

	close(sfd);
	return 0;
}

抓包及测试结果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.3 TCP本地通信

服务器主要代码

int main(int argc, const char *argv[])
{
	//创建流式套接字
	int sfd = socket(AF_UNIX, SOCK_STREAM, 0);
	if(sfd < 0)
	{
		ERR_MSG("socket");
		return -1;
	}
	printf("create socket success\n");

	//判断要绑定的文件是否存在
	//如果存在，则删除该文件
	if(access("./unix", F_OK) == 0) 	//文件存在
	{
		//删除文件
		if(unlink("./unix") < 0)
		{
			ERR_MSG("unlink");
			return -1;
		}
	}

	//填充地址信息结构体，真实的地址信息结构体与协议族相关
	//AF_UNIX，所以详情请看man 7 unix
	struct sockaddr_un sun;
	sun.sun_family 		= AF_UNIX;
	strcpy(sun.sun_path, "./unix");

	//将地址信息结构体绑定到套接字上
	if(bind(sfd, (struct sockaddr*)&sun, sizeof(sun)) < 0)
	{
		ERR_MSG("bind");
		return -1;
	}
	printf("bind success\n");

	//将套接字设置为被动监听状态，让内核去监听是否有客户端连接;
	if(listen(sfd, 10) < 0)
	{
		ERR_MSG("listen");
		return -1;
	}
	printf("listen success\n");

	struct sockaddr_un cun;
	socklen_t addrlen = sizeof(cun);

	//从已完成连接的队列头中，取出一个客户端的信息，创建生成一个新的套接字文件描述符，
	//该文件描述符才是与客户端通信的文件描述符!!!
	int newfd = accept(sfd, (struct sockaddr*)&cun, &addrlen);
	if(newfd < 0)
	{
		perror("accept");
		return -1;
	}

	printf("newfd = %d\n",newfd);

	char buf[128] = "";
	ssize_t res = 0;
	while(1)
	{
		bzero(buf, sizeof(buf));
		//循环接收 
		res = recv(newfd, buf, sizeof(buf), 0);
		if(res < 0)
		{
			ERR_MSG("recv");
			return -1;
		}
		else if(0 == res)
		{
			printf("newfd = %d client off-line\n",newfd);
			break;
		}
		printf("newfd = %d : %s\n", newfd, buf);

		//循环发送
		strcat(buf, "*_*");
		if(send(newfd, buf, sizeof(buf), 0) < 0)
		{
			ERR_MSG("send");
			return -1;
		}
		printf("send message success\n");
	}

	close(sfd);
	close(newfd);
	return 0;
}

客户端主要代码

int main(int argc, const char *argv[])
{
	//创建流式套接字
	int sfd = socket(AF_UNIX, SOCK_STREAM, 0);
	if(sfd < 0)
	{
		ERR_MSG("socket");
		return -1;
	}
	printf("create socket success\n");

	//绑定客户端的地址信息结构体--》非必须绑定 
	
	//填充要连接的服务器的地址信息结构体
	struct sockaddr_un sun;
	sun.sun_family 		= AF_UNIX;
	strcpy(sun.sun_path, "./unix");

	//连接服务器 connect
	if(connect(sfd, (struct sockaddr*)&sun, sizeof(sun)) < 0)
	{
		ERR_MSG("connect");
		return -1;
	}

	char buf[128] = "";
	ssize_t res = 0;
	while(1)
	{
		bzero(buf, sizeof(buf));
		//发送
		printf("请输入>>>");
		fgets(buf, sizeof(buf), stdin);
		buf[strlen(buf)-1] = 0;

		if(send(sfd, buf, sizeof(buf), 0) < 0)
		{
			ERR_MSG("send");
			return -1;
		}
		printf("send success\n");

		//接收 
		bzero(buf, sizeof(buf));
		res = recv(sfd, buf, sizeof(buf), 0);
		if(res < 0)
		{
			ERR_MSG("recv");
			return -1;
		}
		else if(0 == res)
		{
			printf("server is off-line\n");
			break;
		}
		printf("%ld : %s\n", res, buf);
	}

	//关闭套接字
	close(sfd);

	return 0;
}

测试结果

由于是本地通信，没有获取IP地址及端口号，因此无法对其进行抓包
在这里插入图片描述

1.4 UDP本地通信

服务器主要代码

int main(int argc, const char *argv[])
{
	//创建报式套接字
	int sfd = socket(AF_UNIX, SOCK_DGRAM, 0);
	if(sfd < 0)
	{
		ERR_MSG("socket");
		return -1;
	}

	//判断要绑定的文件是否存在
	//如果存在，则删除该文件
	if(access("./udp_unix", F_OK) == 0) 	//文件存在
	{
		//删除文件
		if(unlink("./udp_unix") < 0)
		{
			ERR_MSG("unlink");
			return -1;
		}
	}

	//填充服务器的IP地址以及端口号
	struct sockaddr_un sun;
	sun.sun_family 		= AF_UNIX;
	strcpy(sun.sun_path, "udp_unix");
	
	//绑定服务器的地址信息结构体
	if(bind(sfd, (struct sockaddr*)&sun, sizeof(sun)) < 0)
	{
		ERR_MSG("bind");
		return -1;
	}
	printf("bind success\n");

	struct sockaddr_un cun; 	//存储接收到的数据包来自哪里
	socklen_t addrlen = sizeof(cun);

	char buf[128] = "";
	while(1)
	{
		bzero(buf, sizeof(buf));
		//接收
		if(recvfrom(sfd, buf, sizeof(buf), 0, (struct sockaddr*)&cun, &addrlen) < 0)
		{
			ERR_MSG("recvfrom");
			return -1;
		}
		printf("%s : %s\n",cun.sun_path, buf);

		//发送
		strcat(buf, "*_*");

		//谁发给我，我还发给谁
		if(sendto(sfd,buf,sizeof(buf),0,(struct sockaddr*)&cun,sizeof(cun)) < 0)
		{
			ERR_MSG("sendto");
			return -1;
		}
		printf("sendto success\n");
	}
	//关闭套接字
	close(sfd);
	return 0;
}

客户端主要代码

int main(int argc, const char *argv[])
{
	if(argc < 2)
	{
		fprintf(stderr, "请输入客户端要绑定的文件名\n");
		return -1;
	}

	//创建报式套接字
	int sfd = socket(AF_UNIX, SOCK_DGRAM, 0);
	if(sfd < 0)
	{
		ERR_MSG("socket");
		return -1;
	}

	//判断要绑定的文件是否存在
	//如果存在，则删除该文件
	if(access(argv[1], F_OK) == 0) 		//文件存在
	{
		//删除文件
		if(unlink(argv[1]) < 0)
		{
			ERR_MSG("unlink");
			return -1;
		}
	}

	//填充客户端的自身要绑定的地址信息
	struct sockaddr_un cun;
	cun.sun_family 		= AF_UNIX;
	strcpy(cun.sun_path, argv[1]);

	//绑定客户端的地址信息结构体 ---> 必须绑定
	if(bind(sfd, (struct sockaddr*)&cun, sizeof(cun)) < 0)
	{
		ERR_MSG("bind");
		return -1;
	}
	printf("bind success\n");

	//填充服务器的地址信息
	struct sockaddr_un sun;
	sun.sun_family = AF_UNIX;
	strcpy(sun.sun_path, "udp_unix");

	struct sockaddr_un rcv_addrmsg; 		//存储接收到的数据包来自哪里
	socklen_t addrlen = sizeof(rcv_addrmsg);

	char buf[128] = "";
	while(1)
	{
		//发送
		bzero(buf, sizeof(buf));
		printf("请输入：\n");
		fgets(buf,sizeof(buf),stdin);
		buf[strlen(buf)-1] = 0;

		//将数据包发送给服务器，所以地址信息结构体需要填服务器的信息
		if(sendto(sfd,buf,sizeof(buf),0,(struct sockaddr*)&sun, sizeof(sun)) < 0)
		{
			ERR_MSG("sendto");
			return -1;
		}
		printf("send success\n");

		//接收
		bzero(buf, sizeof(buf));
		//接收服务器发送过来的数据包
		if(recvfrom(sfd, buf, sizeof(buf), 0,(struct sockaddr*)&rcv_addrmsg, &addrlen) < 0)
		{
			ERR_MSG("recvfrom");
			return -1;
		}
		printf("recvfrom success\n");
		printf("%s : %s\n", rcv_addrmsg.sun_path, buf);

	}
	//关闭套接字
	close(sfd);
	return 0;
}

测试结果

在这里插入图片描述

ᗡ
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
UDP通信
weixin_45768707的博客
07-20 2980
UDP通信，广播，组播，DatagramSocket,MulticastSocket
TCP/UDP模型概念总结
独吟|断章的博客
02-15 102
OSI参考模型，TCP/UDP区别，TCP/IP协议
网络编程-UDP本地通讯
欢迎来到斛XX的博客
08-15 372
网络编程-UDP本地通讯
使用UDP实现本地通信-本地通信的信息结构体sockaddr_un-传输层
qq_47355554的博客
05-30 808
目录使用UDP实现本地通信socket本地通信使用的信息结构体UDP本地通信流程代码实现服务器---01server.c客户端---02client.c执行结果注意 使用UDP实现本地通信 socket #include <sys/types.h #include <sys/socket.h> int socket(int domain, int type, int protocol); 参数： domain:用于指定通信领域 AF_UNIX, AF_LOCAL
线程池、UDP、socket本地通信
qq_62147567的博客
04-11 229
如果一个应用需要频繁的创建和销毁线程，而执行任务的事件又非常短，这样线程创建和销毁的带来的开销就不容忽视，这时就需要线程池。面向无连接的，不稳定的，不可靠的，不安全的数据报传递，不需要建立连接，传输效率更高，在稳定的局域网内环境相对可靠。任务池是共享资源，所以需要互斥锁，当任务池中没有任务的时候要让线程阻塞，所以需要使用条件变量。复杂版线程池，增加了线程管理，根据需要增加和减少线程。线程池：若干个线程组合到一起，形成线程池。tcp本地套接字服务端。tcp本地套接字客户端。本地socket通信。
Proteus 8.15 SP0
11-29
Proteus 8.15 SP0电子电路设计软件 Proteus Professional 8.15 SP0 内部版本 33980
Celeste8.15进度
最新发布
08-15
Celeste8.15
清晖8.15线上文字辅导（第二十九课）1
08-04
第十一章 风险管理：项目的独特性导致项目充满风险，项目风险是一种不确定的事件或条件，可能发生、将要发生，也可能不发生。已发生的消极风险可视为问题，问题又会引发风
WebLogic 8.15 01
09-10
WebLogic 8.15 一共10个包 全部下载后解压缩
表8.15计算机监控系统单元工程安装质量验收评定表.doc
12-18
表8.15计算机监控系统单元工程安装质量验收评定表.doc
UDP-本地通信（C语言）server client代码
07-20
UDP-本地通信（C语言）server client代码
基于UDP、TCP、多线程的socket编程
12-16
分别用UDP、TCP、多线程通信三种方式实现socket编程，是学习socket编程最全的小项目，是linux高级编程学习必须部分，现在我工作基本天天都跟他们打交道
域套接字-多客户端实现
qq_38240926的博客
03-21 531
域套接字-多客户端实现 我们在linux 应用开发中，如果需要实现进程间通信的多客户端接口，就需要引入select 和epoll 相关机制了，本文介绍下epoll的功能的实现。 多客户端使用场景，比如我们需要开发一个库接口，提供给客户调用，那么使用域套接字实现进程间通信，就必须在service端引入多路复用，否则库功能就只能被一个进程使用了。 代码实现： service端 #include<stdio.h> #include<stdlib.h> #include<sys/soc
套接字编程 （多进程多线程）
xiami
02-15 1045
三次握手： 主动发起连接请求端，发送SYN标志位，请求建立连接。携带序号、数据字节数（0）、滑动窗口大小。 被动接受连接请求端，回复ACK标志位，同时携带 SYN 请求标志位。 携带序号、确认序号、数据字节函数（0）、滑动窗口大小 主动大气连接请求端，发送 ACK 标志位，应答服务器连接请求。携带确认序号。 四次挥手： 主动关闭连接请求端，发送 FIN标...
进程间通信——域套接字
hfutrlj的博客
05-06 462
域套接字 1.1定义 UNIX域socket实现本地进程间通信，需要一个进程作为服务器端，一个进程作为客户端。对于sockaddr_un结构，重点是给它提供一个bind()函数生成的socket类型文件的路径，即sockaddr_un.sun_path的值。并且客户端与服务器端的这个sockaddr_un结构的sun_path是一致的。 经过bind,listen,accept,和connec...
网络编程-TCP/UDP模型
liu319293960_的博客
04-09 60
TCP服务器、TCP客户端 UDP服务器、UDP客户端
基于Socket的UDP和TCP编程介绍
华清远见 | 程序员的学习天堂
11-30 1845
作者：王珊珊，华清远见嵌入式学院讲师。一、概述TCP（传输控制协议）和UDP（用户数据报协议是网络体系结构TCP/IP模型中传输层一层中的两个不同的通信协议。TCP：传输控制协议，一种面向连接的协议，给用户进程提供可靠的全双工的字节流，TCP套接口是字节流套接口(stream socket)的一种。UDP：用户数据报协议。UDP是一种无连接协议。UDP套接口是数据报套接口(da
TCP/IP与UDP编程模型
IamSherly的博客
07-20 1000
TCP编程模型 UDP编程模型 ①socket()创建套接字 ②bind()绑定本地地址端口 ③connect()建立连接 ④listen()监听端口 ⑤accept()接收连接 ⑥recv(),read(),recvfrom()数据接收 send(),write(),sendto()数据发送 close(),shutdown()关闭套接字 ①int s...
proteus8.15
07-08
以下是Proteus 8.7在Win10上的安装教程： 1. 首先，从官方网站下载Proteus 8.7安装程序。 2. 双击安装程序，选择“安装Proteus 8 Professional”选项。 3. 在安装向导中，选择安装路径和组件，然后单击“下一步”...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值