socket编程（五）

最新推荐文章于 2024-06-07 16:11:40 发布
原创 最新推荐文章于 2024-06-07 16:11:40 发布 · 354 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

1.read，write与recv，send

（1）recv只能接收套接字io

（2）recv有Flags选项

（3）recv选项：MSG_OOB接收带外数据，通过紧急指针，TCP选项

（4）recv选项：MSG_PEEK接收缓冲区中的数据，但是不将缓冲区中的数据清除

2.redline实现

//从套接口接收数据,但是不从缓冲区中移除MSG_PEEK
//只要有偷看到数据就接收，没有头看到就是阻塞
//对方套接口关闭，返回0
ssize_t recv_peek(int sockfd, void* buf, size_t len) {
	while(1) {
		int ret = recv(sockfd, buf, len, MSG_PEEK);
		if(-1 == ret && errno == EINTR) 
			continue;
		return ret;
	}
}

//读取遇到\r\n截止，最大不能超过maxline
ssize_t readline(int sockfd, void* buf, size_t maxline) {
	int ret;
	int nread;
	int nleft = maxline;
	char* bufp = (char*)buf;
	while(1) {
		//信号中断已在recv_peek中处理
		ret = recv_peek(sockfd, bufp, nleft);
		if(ret < 0)  
			return ret;
		if(0 == ret)  //表示对方关闭套接口 
			return ret;

		nread = ret;  //实际偷看到的字节数
		int i;
		
		//该缓冲区中有\n，read读走
		for(i=0; i<nread; i++) {
			if(bufp[i] == '\n') {
				ret = readn(sockfd, bufp, i+1);  //包括\n都读走
				if(ret != i+1) 
					exit(EXIT_FAILURE);
				return ret;
			}
		}
	
		//没有\n，read先读走这部分，然后bufp偏移
		if(nread > nleft) 
			exit(EXIT_FAILURE);
		nleft -= nread;  //更新剩余量
		ret = readn(sockfd, bufp, nread); 
		if(ret != nread) 
			exit(EXIT_FAILURE);
		bufp += nread;	
	}
	return -1;
}


3.用redline实现回射客户/服务器

echoserver.cpp

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.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)
    

/*
 param1:fd, param2:buf, param3:count
return:读取成功字节数
ssize_t:有符号
size_t:无符号
 */


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 (0 == nread) {
			return count - nleft;
		}
		bufp += nread;
		nleft -= nread;
		
	}
	return count;
}


/*
param1:fd, param2:buf, param3:count
return:已经发送了多少
*/
ssize_t writen(int fd, void* buf, size_t count) {
	size_t nleft = count;
	ssize_t nwrite;
	char* bufp = (char*)buf;
	while(nleft > 0) {
		if((nwrite = write(fd, bufp, nleft)) < 0) {	
			if(errno == EINTR)
				continue;
			return -1;
		} else if(0 == nwrite) {
			continue;
		}
		bufp += nwrite;
		nleft -= nwrite;
	}
	return count;
}



//从套接口接收数据,但是不从缓冲区中移除MSG_PEEK
//只要有偷看到数据就接收，没有头看到就是阻塞
//对方套接口关闭，返回0
ssize_t recv_peek(int sockfd, void* buf, size_t len) {
	while(1) {
		int ret = recv(sockfd, buf, len, MSG_PEEK);
		if(-1 == ret && errno == EINTR) 
			continue;
		return ret;
	}
}

//读取遇到\r\n截止，最大不能超过maxline
ssize_t readline(int sockfd, void* buf, size_t maxline) {
	int ret;
	int nread;
	int nleft = maxline;
	char* bufp = (char*)buf;
	while(1) {
		//信号中断已在recv_peek中处理
		ret = recv_peek(sockfd, bufp, nleft);
		if(ret < 0)  
			return ret;
		if(0 == ret)  //表示对方关闭套接口 
			return ret;

		nread = ret;  //实际偷看到的字节数
		int i;
		
		//该缓冲区中有\n，read读走
		for(i=0; i<nread; i++) {
			if(bufp[i] == '\n') {
				ret = readn(sockfd, bufp, i+1);  //包括\n都读走
				if(ret != i+1) 
					exit(EXIT_FAILURE);
				return ret;
			}
		}
	
		//没有\n，read先读走这部分，然后bufp偏移
		if(nread > nleft) 
			exit(EXIT_FAILURE);
		nleft -= nread;  //更新剩余量
		ret = readn(sockfd, bufp, nread); 
		if(ret != nread) 
			exit(EXIT_FAILURE);
		bufp += nread;	
	}
	return -1;
}

void do_service(int conn) {
  	char recvbuf[1024];
  	//struct packet recvbuf;
	int n;
  	while(1) {
  		memset(&recvbuf, 0, sizeof(recvbuf));
  		int ret = readline(conn, recvbuf, 1024);
		if(-1 == ret) {
			ERR_EXIT("readline");
		} else if(0 == ret) {
			printf("client close\n");
			break;
		}
  		fputs(recvbuf, stdout);
  		writen(conn, recvbuf, strlen(recvbuf));
  	}
}

int main () {
  
	int listenfd;
	if(( listenfd= socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
  	//if((listenfd= socket(PF_INET, SOCK_STREAM, 0)) <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);
  	servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
  	//inet_aton("127.0.0.1", &servaddr.sin_addr);
  
	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 = sizeof(peeraddr);
  	int conn;

	pid_t pid;
	while(1) {
		//accept必须同时为NULL; 或者同时不为NULL
		if((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < 0)
			ERR_EXIT("accept");

		//通过accept得到对端addr,port
		printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
		
		struct sockaddr_in connaddr;
		socklen_t connlen = sizeof(connaddr);
		//通过getpeername得到对端addr,port[conn必须是已连接的套接字]
		//conn包含本段ip,port; 也包含对端ip,port
		getpeername(conn, (struct sockaddr*)&connaddr, &connlen);
		printf("ip=%s port=%d\n", inet_ntoa(connaddr.sin_addr), ntohs(connaddr.sin_port));
		
		
		pid = fork();
		if(-1 == pid) {
			ERR_EXIT("fork");
		}
		if(pid == 0) {  //child 
			close(listenfd);
			do_service(conn);
			exit(EXIT_SUCCESS);
		} else {	//parent
			close(conn);
		}
  	}


	
	close(listenfd);
	close(conn);
  return 0;
}

echoclient.cpp 

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.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 (0 == nread) {
			return count - nleft;
		}
		bufp += nread;
		nleft -= nread;
		
	}
	return count;
}

ssize_t writen(int fd, void* buf, size_t count) {
	size_t nleft = count;
	ssize_t nwrite;
	char* bufp = (char*)buf;
	while(nleft > 0) {
		if((nwrite = write(fd, bufp, nleft)) < 0) {	
			if(errno == EINTR)
				continue;
			return -1;
		} else if(0 == nwrite) {
			continue;
		}
		bufp += nwrite;
		nleft -= nwrite;
	}
	return count;
}


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

//读取遇到\r\n截止，最大不能超过maxline
ssize_t readline(int sockfd, void* buf, size_t maxline) {
	int ret;
	int nread;
	char* bufp = (char*)buf;
	int nleft = maxline;
	while(1) {
		ret = recv_peek(sockfd, bufp, nleft);
		if(ret < 0) //信号中断 
			return ret;
		if(0 == ret)  //表示对方关闭套接口 
			return ret;
		nread = ret;
		int i;
		
		//该缓冲区中有\n，read读走
		for(i=0; i<nread; i++) {
			if(bufp[i] == '\n') {
				ret = readn(sockfd, bufp, i+1);  //包括\n都读走
				if(ret != i+1) 
					exit(EXIT_FAILURE);
				return ret;
			}
		}
	
		//没有\n，read先读走这部分，然后bufp偏移
		if(nread > nleft) 
			exit(EXIT_FAILURE);
		nleft -= nread;
		ret = readn(sockfd, bufp, nread); 
		if(ret != nread) 
			exit(EXIT_FAILURE);
		bufp += nread;	
	}
	return -1;
}

int main () {
  
	int sock;
	if(( sock= socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
  		ERR_EXIT("socket");
  	
  	sock = socket(PF_INET, SOCK_STREAM, 0);
  	
  	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("sockect");
  	
  	
	//获得本端ip,port
	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));

	
	struct sockaddr_in connaddr;
	socklen_t connlen = sizeof(connaddr);
	//通过getpeername得到对端addr,port[conn必须是已连接的套接字]
	getpeername(sock, (struct sockaddr*)&connaddr, &connlen);
	printf("ip=%s port=%d\n", inet_ntoa(connaddr.sin_addr), ntohs(connaddr.sin_port));


  	char sendbuf[1024] = {0};	
  	char recvbuf[1024] = {0};
  	int n;
  	while(fgets(sendbuf, sizeof(sendbuf), stdin) != NULL) {
		//将带有\n的buf发送过去
  		writen(sock, sendbuf, strlen(sendbuf));
  		
			
  		int ret = readline(sock, recvbuf, sizeof(recvbuf));
		if(-1 == ret) {
			ERR_EXIT("readline");
		} else if(0 == ret) {
			printf("client close\n");
			break;
		}
	
  		fputs(recvbuf, stdout);
  		memset(sendbuf, 0, sizeof(sendbuf));
  		memset(recvbuf, 0, sizeof(recvbuf));
  	}
  	
  	close(sock);
  	return 0;
}

4.getsockname，getpeername

（1）getsockname获得本端ip和port

（2）getpeername得到对端addr,port[套接字socket必须是已连接的套接字]

//获得本端ip,port
	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));

	
	struct sockaddr_in connaddr;
	socklen_t connlen = sizeof(connaddr);
	//通过getpeername得到对端addr,port[conn必须是已连接的套接字]
	getpeername(sock, (struct sockaddr*)&connaddr, &connlen);
	printf("ip=%s port=%d\n", inet_ntoa(connaddr.sin_addr), ntohs(connaddr.sin_port));

5.gethostname，gethostbyname，gethostbyaddr

（1）gethostname获得主机名

（2）gethostbyname通过主机名获得ip

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.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)
    

//获得本地ip地址
int getlocalip(char* ip) {
	char host[100] = {0};
	if(gethostname(host, sizeof(host)) < 0)
		return -1;
	struct hostent* hp;
	if((hp = gethostbyname(host)) == NULL)
		return -1;
	
	//strcpy(ip, inet_ntoa(*(struct in_addr*)hp->h_addr_list[0]));
	strcpy(ip, inet_ntoa(*(struct in_addr*)hp->h_addr));
	return 0;
}


int main(void) {
	//获得主机名
	char host[100] = {0};
	if(gethostname(host, sizeof(host)) < 0)
		ERR_EXIT("gethostname");	
	printf("%s\n", host);
	
	//通过主机名得到ip地址
	struct hostent* hp;
	if((hp = gethostbyname(host)) == NULL)
		ERR_EXIT("gethostbyname");

	int i  =0;
	while(hp->h_addr_list[i] != NULL) {
		printf("%s\n", inet_ntoa(*(struct in_addr*)hp->h_addr_list[i]));
	i++;
	}


	char ip[16] = {0};
	getlocalip(ip);
	printf("localip=%s\n", ip);
	return 0;
}


Socket的基本操作函数socket()、bind()、listen()、connect()、accept()、recv()、send()、select()、close()
流楚丶格念的博客
08-01 1万+
文章目录Socket的基本操作函数1、socket()函数1.1、 命名socket网络字节序与主机字节序：2、bind()函数3、listen()、connect()函数4、accept()函数5、recv()、send()等函数同步Socket的send函数的执行流程注意：同步Socket的recv函数的执行流程注意：6、select()函数理解select模型：select模型的特点：7、close()/shutdown()函数注：多进程中close操作解释close与shutdown的区别 Soc
Socket通信——Linux下，errno=EINTR的错误处理
qq_35408439的博客
06-13 1696
socket接口，例如recv接口会做2件事情: 1.检查buffer是否有数据，有则复制清除返回 2.没有数据，则进入睡眠模式，当超时、数据到达、发生错误则唤醒进程处理 采用睡眠来等待，发生信号的时候进程会被唤醒，socket接口唤醒后检查有无未处理的信号(signal_pending)会返回EINTR错误。 处理方式，无需理会，重新运行该函数。 以下为封装好的函数处理，引用wrap.h，替
linux中对EINTR错误的处理
Tyrion Lannister's Special column
08-24 9952
慢系统调用(slow system call)：此术语适用于那些可能永远阻塞的系统调用。永远阻塞的系统调用是指调用有可能永远无法返回，多数网络支持函数都属于这一类。如：若没有客户连接到服务器上，那么服务器的accept调用就没有返回的保证。 EINTR错误的产生：当阻塞于某个慢系统调用的一个进程捕获某个信号且相应信号处理函数返回时，该系统调用可能返回一个EINTR错误。例如：在socket服
socket 错误码errno
bytxl的专栏
11-06 1万+
http://blog.youkuaiyun.com/davintanger/article/details/7679567
非阻塞(nonblock)socket接口会否出现EINTR错误
Willko's Blog
10-05 332
对于socket接口(指connect/send/recv/accept..等等后面不重复，不包括不能设置非阻塞的如select)，在阻塞模式下有可能因为发生信号，返回EINTR错误，由用户做重试或终止。 但是，在非阻塞模式下，是否出现这种错误呢？ 对此，重温了系统调用、信号、socket相关知识，得出结论是：[b]不会出现[/b]。 首先， 1.信号的处理是在用户态下进行的，也就...
Socket编程实例
11-28
Socket编程是网络编程中的核心部分，它允许两个网络应用程序通过TCP/IP协议进行通信。在这个C#的实例中，我们探讨了如何使用Socket类创建一个简单的聊天通信程序，包括客户端和服务端的实现。以下是对这个主题的详细...
Socket编程实验报告.docx
03-10
Socket编程是网络编程的基础，主要用于实现两个网络节点之间的通信。在这个实验报告中，我们主要探讨了如何使用Java的Socket和ServerSocket类进行TCP协议的客户端和服务器端编程。 实验目标是掌握Socket编程的基本...
实战Linux+Socket编程.pdf
最新发布
09-22
Linux+Socket编程是一种在网络编程领域应用广泛的技能，尤其在操作系统为Linux平台的情况下。Socket编程涉及的是网络中不同主机上运行的应用程序之间的通信机制。在Linux环境下，通过Socket API可以创建网络服务和...
华中科技大学-计算机通信与网络（Socket编程）-内含源文件和说明书.zip
05-09
【标题】：“华中科技大学-计算机通信与网络（Socket编程）-内含源文件和说明书.zip” 这个资源主要涵盖了华中科技大学计算机通信与网络课程中的Socket编程部分，它包括了学习资料、源代码示例以及相关说明文档。...
Java Socket网络编程.pdf
07-11
Socket编程主要用于实现客户端和服务器之间的通信，基于客户机/服务器模型。在这个模型中，服务器端通常处于被动等待状态，监听特定端口的连接请求，而客户端则主动发起连接。 在Java中，Socket编程主要涉及两个...
Linux socket非阻塞发送
qq_30531921的博客
06-07 798
调用（如果数据可以一次发送），但在某些情况下（如网络拥塞或套接字为非阻塞模式），它可以提供更好的整体性能和响应性。当套接字设置为非阻塞模式时，如果数据不能立即发送（例如，由于网络拥塞或接收端缓冲区已满），总之，这种设计允许函数更健壮地处理各种可能的网络条件和错误情况，并确保数据的完整发送。）完全写入到套接字（socket）中，即使在这个过程中可能会遇到中断或其他导致。调用，此函数允许非阻塞套接字在准备好发送更多数据时继续发送数据。），这个函数确保所有数据都被发送，直到达到请求的长度（，并更新发送的字节数（
read/write函数实现，errno==EINTR处理
键盘的起始页
12-17 4684
一、转1。errno!=EINTR以及读写内核函数理解 errno!=EINTR 注意read（）如果读到数据为0，那么就表示文件结束了，如果在读的过程中遇到了中断那么会返回-1，同时置errno为EINTR。 因此判断read的条件： 如果read返回<=0 如果==0 表示文件结束，处理 如果<0&&errno==EINTR 表示中断，处理 否则，出错...
socket中的发送与接收函数
legend050709的专栏
10-05 3094
网络I/O操作： （一）read()/write() （二）recv()/send() （三）readv()/writev() （四）recvmsg()/sendmsg() （五）recvfrom()/sendto() --------------------------------------------- （1）推荐使用recvmsg()/sendmsg()函数，这两个函
socket中的函数遇见EINTR的处理
学习是为了探索这个世界的本质
01-22 994
这几天，写服务器代码过程当中，遇见EINRT信号的问题，我是借鉴 《unp 》，采用continue或者goto again循环解决的。但是感觉这个还是很有必要记录一下。网络上查找到的信息很多。下面是我查找到的和EINTR有关的介绍： 1  http://blog.youkuaiyun.com/yanook/article/details/7226019  慢系统调用函数如何处理中断信号EINTR 2  
Linux - socket编程处理EINTR错误
gdf378389221的专栏
03-01 991
Linux - socket编程处理EINTR错误 Linux - socket编程处理EINTR错误 在linux的socket编程中，经常要处理EINTR错误，其值为4，用strerror(errno)调用返回的错误描述为：Interrupted system call. 这里给出一个connect连接中对EINTR处理的网址： http://
socket编程中send recv阻塞和非阻塞详解
热门推荐
shanzhizi的专栏
06-13 4万+
int send( SOCKET s, const char FAR *buf, int len, int flags ); 不论是客户还是服务器应用程序都用send函数来向TCP连接的另一端发送数据。客户程序一般用send函数向服务器发送请求，而服务器则通常用send函数来向客户程序发送应答。   该函数的第一个参数指定发送端套接字描述符；   第二个参数指明一个存放应用程序要发送数据
【博客277】socket编程常见errno错误
qq_43684922的博客
05-30 1526
内容： 记录网络编程常见的errno错误 EAGAIN (Try again ) : 在读数据的时候,没有数据在底层缓冲的时候会遇到.比如我们epoll使用边缘 触发的时候，是需要在每次事件轮回中处理所有的消息，因为不然就得等下一次事件轮回才能处理了，因此 我们基本用边缘跟非阻塞fd一起使用，然后通过判断返回值-1时，errno为EAGAIN来判断已经读完了 EWOULDBLOCK (Operation would block) : 有的系统是EWOULDBLOCK，而不是EAGAIN EPIPE(Br
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值