#网络程序设计#（九）close与shutdown

最新推荐文章于 2023-04-02 10:00:25 发布
最新推荐文章于 2023-04-02 10:00:25 发布
阅读量77 收藏
点赞数
分类专栏： # 网络程序设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43476037/article/details/104900673
版权

文章目录

更多网络程序设计的文章见：目录

close与shutdown

  • close终止了数据传送的两个方向
  • shutdown可以有选择的终止某个方向的数据传送或终止数据传送的两个方向
  • shutdown how=1就可以保证对等方接收到一个EOF字符，而不管其他进程是否打开了套接字，而close不能保证，直到套接字引用计数减为0时才发送

进一步程序改进

echosrv.c
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h> 
#include <sys/wait.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
 
#define ERR_EXIT(m)  \
	do\
	{\
		perror(m);\
		exit(EXIT_FAILURE);\
	}while (0)

 
ssize_t readn(int fd, void *buf, size_t count)
{
	size_t nleft = count;
	ssize_t nread;
	char *bufp = (char*)buf;

	while(nleft > 0)
	{
		if((nread = read(fd, bufp, nleft)) < 0)
		{
			if(errno == EINTR)
				continue;
			return -1;
		}
		else if(nread == 0)
			return count - nleft;

		bufp += nread;
		nleft -= nread;
	}

	return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
	size_t nleft = count;
	ssize_t nwritten;
	char *bufp = (char*)buf;

	while(nleft > 0)
	{
		if((nwritten = write(fd, bufp, nleft)) < 0)
		{
			if(errno == EINTR)
				continue;
			return -1;
		}
		else if(nwritten == 0)
			continue;

		bufp += nwritten;
		nleft -= nwritten;
	}

	return count;
}

ssize_t recv_peek(int sockfd, void *buf, size_t len)//与原型相比去掉了flags
{//可以从套接口接收数据，可以指定不将缓冲区数据移除
	while(1)
	{
		int ret = recv(sockfd, buf, len, MSG_PEEK);
		if(ret == -1 && errno == EINTR)
			continue;
		return ret;
	}	
}

//暗含读取方法，标准是一个个读取，但效率太低，因此用偷窥的方法
//recv_peek不可重入
ssize_t readline(int sockfd, void *buf, size_t maxline)
{
	int ret;
	int nread;
	char *bufp = buf;
	int nleft = maxline;
	while(1)
	{
		ret = recv_peek(sockfd, bufp, nleft);
		if(ret < 0)
			return ret;
		else if(ret == 0)
			return ret;//对方关闭了套接口

		nread = ret;
		int i;
		for(i = 0; i < nread; i++)//最简单情况，有一条消息，我们读走
		{
			if(bufp[i] == '\n')
			{
				ret = readn(sockfd, bufp, i + 1);
				if(ret != i+1)
					exit(EXIT_FAILURE);
				return ret;
			}
		}
		if(nread > nleft)
			exit(EXIT_FAILURE);

		nleft -= nread;
		ret = readn(sockfd, bufp, nread);
		if(ret != nread)
			exit(EXIT_FAILURE);

		bufp += nread;
	}
	return -1;

}

void echo_srv(int conn)
{
	char recvbuf[1024];	
	while(1)
	{
		memset(recvbuf, 0, sizeof(recvbuf));
		int ret = readline(conn, recvbuf, 1024);
		if(ret == -1)
			ERR_EXIT("readline");
		if(ret == 0)
		{
			printf("client close\n");
			break;
		}		

		fputs(recvbuf, stdout);
		writen(conn, recvbuf, strlen(recvbuf));
	}
} 

void handle_sigchld(int sig)
{
/*	wait(NULL);*/
	while(waitpid(-1, NULL, WNOHANG) > 0);//处理多个进程
}

void handle_sigpipe(int sig)
{
	printf("recv a sig=%d\n", sig);
}

int main(void)
{
	
	signal(SIGPIPE, handle_sigpipe);
	//signal(SIGCHLD, SIG_IGN);//解决僵尸进程问题
	//另一种方法（推荐，加上waitpid的调用）
	signal(SIGCHLD, handle_sigchld);
	int listenfd;
	if((listenfd = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0)
		ERR_EXIT("socket");
 
	struct sockaddr_in servaddr;
	memset(&servaddr,0,sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(5188);
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

	int on = 1;
	if(setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on))<0)
		ERR_EXIT("setsockopt");

	if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
		ERR_EXIT("bind");
 
	if(listen(listenfd,SOMAXCONN)<0)
		ERR_EXIT("listen");
	
	struct sockaddr_in peeraddr;
	socklen_t peerlen;
	int conn;

	int i;
	int client[FD_SETSIZE];
	int maxi = 0;
	
	for(i = 0; i < FD_SETSIZE; i++)
	{
		client[i] = -1;
	}

	int nready;
	int maxfd = listenfd;
	fd_set rset;
	fd_set allset;
	FD_ZERO(&rset);
	FD_ZERO(&allset);
	FD_SET(listenfd, &allset);
	while(1)
	{
		rset = allset;
		nready = select(maxfd+1, &rset, NULL, NULL, NULL);
		if(nready == -1)
		{
			if(errno == EINTR)
				continue;

			ERR_EXIT("select");
		}
		if(nready == 0)
			continue;
		if(FD_ISSET(listenfd, &rset))
		{
			peerlen = sizeof(peeraddr);
			conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen);
			if(conn == -1)
				ERR_EXIT("accept");
			
			for(i = 0; i < FD_SETSIZE; i++)
			{
				if(client[i] < 0)
				{
					client[i] = conn;
					if(i > maxi)
						maxi = i;
					break;
				}
			}

			if(i == FD_SETSIZE)
			{
				fprintf(stderr, "too many client\n");
				exit(EXIT_FAILURE);
			}
			printf("ip=%s,port=%d\n",inet_ntoa(peeraddr.sin_addr),ntohs(peeraddr.sin_port));

			FD_SET(conn, &allset);
			if(conn > maxfd)
				maxfd = conn;
			
			if(--nready <= 0)
				continue;
		}

		for(i = 0; i <= maxi; i++)
		{
			conn = client[i];
			if(conn == -1)
				continue;
			if(FD_ISSET(conn, &rset))
			{
				char recvbuf[1024] = {0};
				int ret = readline(conn, recvbuf, 1024);
				if(ret == -1)
					ERR_EXIT("readline");
				if(ret == 0)
				{
					printf("client close\n");
					FD_CLR(conn, &allset);
					client[i] = -1;
					close(conn);
				}		
		
				fputs(recvbuf, stdout);
				sleep(4);
				writen(conn, recvbuf, strlen(recvbuf));

				if(--nready <= 0)
					break;
			}

		}

	}
	return 0;

}
echocli.c
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>

#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>

#define ERR_EXIT(m)				\
	do					\
	{					\
		perror(m);			\
		exit(EXIT_FAILURE);		\
	}while(0)

ssize_t readn(int fd, void *buf, size_t count)
{
	size_t nleft = count;
	ssize_t nread;
	char *bufp = (char*)buf;

	while(nleft > 0)
	{
		if((nread = read(fd, bufp, nleft)) < 0)
		{
			if(errno == EINTR)
				continue;
			return -1;
		}
		else if(nread == 0)
			return count - nleft;

		bufp += nread;
		nleft -= nread;
	}

	return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
	size_t nleft = count;
	ssize_t nwritten;
	char *bufp = (char*)buf;

	while(nleft > 0)
	{
		if((nwritten = write(fd, bufp, nleft)) < 0)
		{
			if(errno == EINTR)
				continue;
			return -1;
		}
		else if(nwritten == 0)
			continue;

		bufp += nwritten;
		nleft -= nwritten;
	}

	return count;
}

ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
	while(1)
	{
		int ret = recv(sockfd, buf, len, MSG_PEEK);
		if(ret == -1 && errno == EINTR)
			continue;
		return ret;
	}
}

ssize_t readline(int sockfd, void *buf, size_t maxline)
{
	int ret;
	int nread;
	char *bufp = buf;
	int nleft = maxline;
	while(1)
	{
		ret = recv_peek(sockfd, bufp, nleft);
		if(ret < 0)
			return ret;
		else if(ret == 0)
			return ret;//对方关闭了套接口

		nread = ret;
		int i;
		for(i = 0; i < nread; i++)
		{
			if(bufp[i] == '\n')
			{
				ret = readn(sockfd, bufp, i + 1);
				if(ret != i+1)
					exit(EXIT_FAILURE);
				return ret;
			}
		}
		if(nread > nleft)
			exit(EXIT_FAILURE);

		nleft -= nread;
		ret = readn(sockfd, bufp, nread);
		if(ret != nread)
			exit(EXIT_FAILURE);

		bufp += nread;
	}
	return -1;
}

void echo_cli(int sock)
{
/*
	char sendbuf[1024] = {0};
	char recvbuf[1024] = {0};
	while(fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
	{
		writen(sock, sendbuf, strlen(sendbuf));
	
		int ret = readline(sock, &recvbuf, sizeof(recvbuf));
		if(ret == -1)
			ERR_EXIT("readline");
		else if(ret == 0)
		{
			printf("client_close\n");
			break;
		}
		
		fputs(recvbuf, stdout);
		memset(sendbuf, 0, sizeof(sendbuf));
		memset(recvbuf, 0, sizeof(recvbuf));
	}
	close(sock);
*/
	
	fd_set rset;
	FD_ZERO(&rset);
	
	int nready;
	int maxfd;
	int fd_stdin = fileno(stdin);
	if(fd_stdin > sock)
		maxfd = fd_stdin;
	else
		maxfd = sock;

	char sendbuf[1024] = {0};
	char recvbuf[1024] = {0};

	int stdineof = 0;

	while(1)
	{
		if(stdineof == 0)
			FD_SET(fd_stdin, &rset);
		FD_SET(sock, &rset);
		nready = select(maxfd+1, &rset, NULL, NULL, NULL);
		if(nready == -1)
			ERR_EXIT("select");
		if(nready == 0)
			continue;
		if(FD_ISSET(sock, &rset))
		{
			int ret = readline(sock, &recvbuf, sizeof(recvbuf));
			if(ret == -1)
				ERR_EXIT("readline");
			else if(ret == 0)
			{
				printf("server close\n");
				break;
			}
		
			fputs(recvbuf, stdout);
			memset(recvbuf, 0, sizeof(recvbuf));
		}
		if(FD_ISSET(fd_stdin, &rset))
		{
			if(fgets(sendbuf, sizeof(sendbuf), stdin) == NULL)
			{
				stdineof = 1;
				/*
				close(sock);
				sleep(5);
				exit(EXIT_FAILURE);
				*/
				shutdown(sock, SHUT_WR);
			}
			else
			{
				writen(sock, sendbuf, strlen(sendbuf));
				memset(sendbuf, 0, sizeof(sendbuf));
			}
			
		}
	}
	
}

void handle_sigpipe(int sig)
{
	printf("recv a sig=%d\n", sig);
}

int main(void)
{
	/*signal(SIGPIPE, handle_sigpipe);*/
	signal(SIGPIPE, SIG_IGN);
	int sock;
	if((sock = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP)) < 0)
	{
		ERR_EXIT("socket");
	}
	
	struct sockaddr_in servaddr;
	memset(&servaddr,0,sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(5188);
	servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	if(connect(sock,(struct sockaddr*)&servaddr,sizeof(servaddr)) < 0)
	{
		ERR_EXIT("connect");
	}

	struct sockaddr_in localaddr;
	socklen_t addrlen = sizeof(localaddr);
	if(getsockname(sock, (struct sockaddr*)&localaddr, &addrlen) < 0)
		ERR_EXIT("getsockname");

	printf("ip=%s,port=%d\n", inet_ntoa(localaddr.sin_addr),ntohs(localaddr.sin_port));
	
	echo_cli(sock);
	
	return 0;
}
vircorns
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算机网络课程设计---端口扫描工具设计.docx
05-25
参数 how允许为shutdown操作选择以下几种方式： ·0-------不允许继续接收数据 ·1-------不允许继续发送数据 ·2-------不允许继续发送和接收数据，均为允许则调用close () shutdown在操作成功时返回0，在出现错误...
文件或者类文件对象的close方法的作用
jxxiaohou的专栏
11-14 2126
文件或者类文件对象的close方法的作用主要有两个： 1. 释放资源。打开一个文件，对文件进行操作，这个过程需要消耗计算机的硬件资源，最主要的就是内存(比如接下来要说的”读写缓冲区”)，调用close方法后，文件对象占用的资源就会被释放。 2.清空缓冲区。当你打开一个文件向里面写入数据或者从某个url获取远程html想对其进行解析，这时候就会用到缓冲区的概念。比如你要写入文件，你想写入文件的数据
网络聊天程序的设计与实现
m0_45948011的博客
01-06 6656
网络聊天程序的设计与实现 文章目录网络聊天程序的设计与实现一、实验题目二、实验目的三、背景知识四、代码 一、实验题目 网络聊天程序的设计与实现 二、实验目的 使用socket编程，了解socket编程的通信原理，会使用socket进行简单的网络编程，在此基础上编写一聊天程序，能够运行程序，运行客户端和服务器端，实现两个客户端通过服务器端进行通信。 三、背景知识 Tcp协议与Win Sock网络编程接口： Tcp协议： 是面向连接的运输层协议，提供可靠的、有序的、双向的、面向连接的运输服务。 Win Soc
【网络编程】双向的TCP如何关闭？close ？shutdown？
qq_41950508的博客
07-17 967
close函数只是把套接字引用计数减1，未必会立即关闭连接；close函数如果在套接字引用计数达到0时，立即终止读和写两个方向的数据传送。基于这两点，在期望关闭连接其中一个方向时，应该使用shutdown函数。...
计算机网络——网络聊天程序的设计与实现
weixin_44016029的博客
01-21 9608
计算机网络——网络聊天程序的设计与实现一、实验目的二、总体设计1. 基本原理2. 设计步骤（1）服务器端编程的步骤（2）客户端编程的步骤三、详细设计1. 程序流程图2. 实验代码（1）服务器端（2）客户端四、实验结果1. 服务器端2. 客户端 一、实验目的 了解Socket通信的原理，在此基础上编写一个聊天程序。 二、总体设计 1. 基本原理 socket通信原理是一种“打开——读/写——关闭”模式的实现，服务器和客户端各自维护一个“文件”，在建立连接打开后，可以向文件写入内容供对方读取或者读取对方的内容，
close 和 shutdown 的差别
caofengtao1314的专栏
05-18 2713
close 函数 首先，我们来看最常见的 close 函数： int close(int sockfd) 这个函数很简单，对已连接的套接字执行 close 操作就可以，若成功则为 0，若出错则为 -1。 这个函数会对套接字引用计数减一，一旦发现套接字引用计数到 0，就会对套接字进行彻底释放，并且会关闭 TCP 两个方向的数据流。 套接字引用计数是什么意思呢？因为套接字可以被多个进程共享，你可以理解为我们给每个套接字都设置了一个积分，如果我们通过 fork 的方式产生子进程，套接字就会积分 +1
网络程序设计-WeTalk聊天程序
DmxExcalibur的博客
07-19 4188
【摘要】WeTalk是一款基于Windows网络编程技术和MFC实现的聊天应用，该应用采用了Client/Server结构，可以实现多个客户端与服务器建立连接，用户可以通过客户端进行聊天，用户可以发群聊消息，也可以对指定的用户发消息，服务器进行转发和广播消息，还能够对指定的用户进行禁言操作。WeTalk界面美观，简单易用。         【关键词】Windows网络程序设计，事件选择模型，MF
计算机网络课程设计——网络聊天程序的设计与实现
dayexiaofan的博客
12-26 9957
服务器的代码 /* * 服务器端 Server.c * */ #pragma comment(lib,&amp;quot;ws2_32&amp;quot;) #include &amp;amp;lt;winsock2.h&amp;amp;gt; #include &amp;amp;lt;stdio.h&amp;amp;gt; #include &amp;amp;lt;string.h&amp;amp;gt; #define BUFFS
C#网络编程TCP通信实例程序简单设计
热门推荐
JiYF大男孩
04-20 2万+
C#网络编程TCP通信实例程序简单设计 采用自带TcpClient和TcpListener设计一个Tcp通信的例子 只实现了TCP通信 通信程序截图： 压力测试服务端截图： 俩个客户端链接服务端测试截图： 服务端： 客户端 运行动态图 C#程序设计代码 BenXHSocket.dll主要代码设计 SocketObject类 /**************...
C语言实现网络聊天程序的设计与实现（基于TCP协议）
我的书包哪里去了
12-19 1万+
目录 TCP/IP协议介绍 TCP/IP协议与WinSock网络编程接口的关系 WinSock编程简单流程 VC中socket编程 ·服务器实现 ·客户端实现 测试结果 TCP/IP协议介绍 TCP/I...
【计算机网络】2、TCP：四次挥手与TIME_WAIT、shutdown() 优雅关闭 server、探活、拥塞窗口与 Nagle 算法、端口占用、tcp 的流式协议、可靠性
呆呆的猫的博客
04-02 1004
本文主要介绍计算机网络编程模型理论
JAVA设计界面的程序设计
06-22
涉及页面设计及相关按钮的编辑：import java.awt.*; import java.awt.event.*; /** * Sample application using Frame. * * @author * @version 1.00 11/05/04 */ public class Pj1Frame extends Frame { ...
Linux网络编程
11-08
6.6.8 close()和shutdown()函数.... 156 6.6.9 setsockopt() 和getsockopt() 函数... 157 6.6.10 getpeername()函数............ 157 6.6.11 gethostname()函数............ 158 6.7 DNS 的操作................. ...
linux 网络编程源代码
07-06
1.1 网络的历史.......................................................................................................1 1.2 OSI 模型........................................................................
#网络程序设计#实验一：TCP通信实验
vircorns的博客
03-14 2313
文章目录实验原理TCP用到的API实验内容服务器端(tcpsrv.c)客户端(tcpcli.c)实验结果 实验原理 TCP 用到的API int socket(int domain, int type, int protocol); 根据指定的地址族、数据类型和协议来分配一个 socket 的描述字及其所用的资源。 domain: 协议族，常用的有 AF_INET, AF_INET6, A...
#网络程序设计#实验二：利用TCP完成文件传输的设计和实现
vircorns的博客
03-19 1544
文章目录实验目的实验原理实验内容实验结果 实验目的 输入文件路径，利用TCP实现客户文件向服务器的传输，并实现TCP的基本封装 实验原理 服务器 (1) 建立 socket (2) 确定服务器 scokaddr_in 结构体 (3)点分十进制 IP 转换 (4)使用 bind 绑定套接字 (5)使用 listen 监听 (6)使用 accept 接受连接请求 (7)accept 返回新的套接...
#网络程序设计#实验三：利用多进程和多线程实现服务器端的并发处理
vircorns的博客
06-03 531
文章目录实验目的实验原理实验内容实验结果 实验目的 熟练掌握服务器端并发处理的方法 实验原理 服务端没连接上一个客户端，都会为其分配一个线程，从而挺提高一个服务端同时响应多个客户端时的效率 pthread_create是类Unix操作系统(Unix, Linux, Mac OS X等)的创建线程的函数。它的功能是创建线程(实际上就是确定调用该线程函数的入口点)，在线程创建以后，就开始运行相关的线...
#网络程序设计#实验四：I/O复用完成单线程并发服务器的处理
vircorns的博客
06-03 419
文章目录实验目的实验原理实验内容实验结果 实验目的 利用I/O复用实现一个单线程并发服务器，使其可以并发接收客户端传来的数据， 并将收到的数据原封不动发回给客户端 实验原理 创建套接字并将其绑定在服务器的熟知端口上（本实验采用5188号端口），将该套接字加入一个表中，该表中的项是可以进行I/O的描述符 使用select在已有套接字上等待I/O )如果最初的套接字准备就绪，调用accpet获...
#网络程序设计#（四）TCP ECHO回显编程示例
vircorns的博客
02-26 324
文章目录流协议与粘包粘包readn writen客户端发送定长包代码回射客户/服务器echosrv.cechocli.c参考资料 流协议与粘包 TCP是基于字节流的传输服务，无边界，不能保证对等方一次接受能够返回多少字节，所以易产生粘包 UDP传输的是数据报，有边界 粘包 产生原因 SQ_SNDBUF套接字本身有缓冲区（发送缓冲区，接收缓冲区） tcp传送的网络数据最大值MSS大小限制 ...
shutdown函数与close函数
最新发布
04-10
b&#39;shutdown&#39;函数和&#39;close&#39;函数是用来关闭网络连接的。它们的作用有一些不同，&#39;shutdown&#39;函数是用来在网络连接上发送一个关闭信号，而&#39;close&#39;函数是用来关闭连接并且释放相关资源。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值