套接字属性

一条飞的鱼儿

已于 2023-07-16 20:43:32 修改

阅读量213

点赞数

文章标签：单片机嵌入式硬件

于 2023-07-13 10:10:17 首次发布

本文链接：https://blog.csdn.net/qq_36091214/article/details/131693850

版权

一、选项的级别

1. 基本概念

设置套接字的选项对套接字进行控制
除了设置选项外，还可以获取选项
选项的概念相当于属性，所以套接字选项也可说是套接字属性
有些选项（属性）只可获取，不可设置；
有些选项既可设置也可获取

2. 选项级别

SOL_SOCKET		该级别的选项只作用于套接字本身
SOL_LRLMP		该级别的选项作用于IrDA协议
IPPROTO_IP		该级别的选项作用于IPv4协议
IPPROTO_IPV6	该级别的选项作用于IPv6协议
IPPROTO_RM		该级别的选项作用于可靠的多播传输
IPPROTO_TCP		该级别的选项适用于流式套接字
IPPROTO_UDP		该级别的选项适用于数据报套接字

3. SOL_SOCKET的常用选项

	选项名称				说明				获取/设置
SO_ACCEPTCONN	套接字是否处于监听状态		  获取
SO_BROADCAST	允许发送广播数据				两者都可
SO_DEBUG		允许调试						两者都可
SO_DONTROUTE	不查找路由					两者都可
SO_ERROR		获得套接字错误				  获取
SO_KEEPALIVE	保活连接						两者都可
SO_LINGER		延迟关闭连接					两者都可
SO_OOBINLINE	带外数据放入正常数据流		两者都可
SO_RCVBUF		接收缓冲区大小				两者都可
SO_SNDBUF		发送缓冲区大小				两者都可
SO_REUSERADDR	允许重用本地地址和端口		两者都可
SO_TYPE			获得套接字类型				  获取

4. IPPROTO_IP级别的常用选项

	选项名称				说明										获取/设置
IP_ADD_MEMBERSHIP	加入一个多播组									设置
IP_OPTIONS			获取或设置IP头部内的选项							两者都可
IP_HDRINCL			用户在用户数据前面提供 IP 标头(用于原始套接字)		两者都可
IP_TTL	IP TTL相关	两者都可

二、getsockopt获取套接字选项

#include <sys/types.h>/* See NOTES */
#include <sys/socket.h>
int getsockopt(int sockfd,int level,int optname,void *optval,socklen_t*optlen);

sockfd：套接字描述符
level：表示选项的级别
optname：表示要获取的选项名称
optval：指向存放接收到的选项内容的缓冲区
optlen：指向optval所指缓冲区的大小
函数返回值：
       执行成功返回0，否则返回‒1，errno来获取错误码

三、setsockopt设置套接字选项

#include <sys/types.h>/* See NOTES */
#include <sys/socket.h>
int setsockopt(int sockfd,int level,int optname,const void *optval, socklen_t optlen);

sockfd：套接字描述符
level：表示选项的级别
optname：表示要设置的选项名称
optval：指向存放接收到的选项内容的缓冲区
optlen：指向optval所指缓冲区的大小
函数返回值：
       执行成功返回0，否则返回‒1，errno来获取错误码

示例代码：

服务端代码：server.c

#include "net.h"
#include <sys/select.h>
#define MAX_SOCK_FD 1024

/*设置保活连接套接字属性函数*/
void setKeepAlive (int sockfd, int attr_on, socklen_t idle_time, socklen_t interval, socklen_t cnt)
{
	setsockopt (sockfd, SOL_SOCKET, SO_KEEPALIVE, (const char *) &attr_on, sizeof (attr_on));
	setsockopt (sockfd, SOL_TCP, TCP_KEEPIDLE, (const char *) &idle_time, sizeof (idle_time));
	setsockopt (sockfd, SOL_TCP, TCP_KEEPINTVL, (const char *) &interval, sizeof (interval));
	setsockopt (sockfd, SOL_TCP, TCP_KEEPCNT, (const char *) &cnt, sizeof (cnt));
}

int main(int argc, char *argv[])
{
	int i, ret, fd, newfd;
	fd_set set, tmpset;
	Addr_in clientaddr;
	socklen_t clientlen = sizeof(Addr_in);
	/*检查参数，小于3个 直接退出进程*/
	Argment(argc, argv);
	/*创建已设置监听模式的套接字*/
	fd = CreateSocket(argv);

	FD_ZERO(&set);
	FD_ZERO(&tmpset);
	FD_SET(fd, &set);
	while(1){
		tmpset = set;
		if( (ret = select(MAX_SOCK_FD, &tmpset, NULL, NULL, NULL)) < 0){
			perror("select");
			getchar();
		}
		if(FD_ISSET(fd, &tmpset) ){
			/*接收客户端连接，并生成新的文件描述符*/
			if( (newfd = accept(fd, (Addr *)&clientaddr, &clientlen) ) < 0){
				perror("accept");
				getchar();
			}
#if 1       /*调用套接字函数*/
			int keepAlive = 1;			//设定KeepAlive
			int keepIdle = 5;			//开始首次KeepAlive探测前的TCP空闭时间
			int keepInterval = 5;		//两次KeepAlive探测间的时间间隔
			int keepCount = 3;			//判定断开前的KeepAlive探测次数
			setKeepAlive (newfd, keepAlive, keepIdle, keepInterval, keepCount);
#endif

			printf("[%s:%d]已建立连接\n", 
					inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
			FD_SET(newfd, &set);
		}else{ //处理客户端数据
			for(i = fd + 1; i < MAX_SOCK_FD; i++){
				if(FD_ISSET(i, &tmpset)){
					if( DataHandle(i) <= 0){
						if( getpeername(i, (Addr *)&clientaddr, &clientlen) )
							perror("getpeername");
						printf("[%s:%d]断开连接\n", 
								inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
						FD_CLR(i, &set);
						close(i);
					}
				}
			}
		}
	}
	close(fd);
	return 0;
}

示例代码

net.h

#ifndef _NET_H_
#define _NET_H_

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <strings.h>
#include <errno.h>

typedef struct sockaddr Addr;
typedef struct sockaddr_in Addr_in;
#define BACKLOG 5
#define ErrExit(msg) do { perror(msg); exit(EXIT_FAILURE); } while(0)

void Argment(int argc, char *argv[]);
int CreateSocket(char *argv[]);
int DataHandle(int fd);


#endif

socket.c

#include "net.h"

void Argment(int argc, char *argv[]){
	if(argc < 3){
		fprintf(stderr, "%s<addr><port>\n", argv[0]);
		exit(0);
	}
}
int CreateSocket(char *argv[]){
	/*创建套接字*/
	int fd = socket(AF_INET, SOCK_STREAM, 0);
	if(fd < 0)
		ErrExit("socket");
	/*允许地址快速重用*/
	int flag = 1;
	if( setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag) ) )
		perror("setsockopt");
	/*设置通信结构体*/
	Addr_in addr;
	bzero(&addr, sizeof(addr) );
	addr.sin_family = AF_INET;
	addr.sin_port = htons( atoi(argv[2]) );
	/*绑定通信结构体*/
	if( bind(fd, (Addr *)&addr, sizeof(Addr_in) ) )
		ErrExit("bind");
	/*设置套接字为监听模式*/
	if( listen(fd, BACKLOG) )
		ErrExit("listen");
	return fd;
}
int DataHandle(int fd){
	char buf[BUFSIZ] = {};
	Addr_in peeraddr;
	socklen_t peerlen = sizeof(Addr_in);
	if( getpeername(fd, (Addr *)&peeraddr, &peerlen) )
		perror("getpeername");
	int ret = recv(fd, buf, BUFSIZ, 0);
	if(ret < 0)
		perror("recv");
	if(ret > 0){
		printf("[%s:%d]data: %s\n", 
				inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port), buf);
	}
	return ret;
}

server.c

#include "net.h"
#include <sys/select.h>
#define MAX_SOCK_FD 1024

void setKeepAlive (int sockfd, int attr_on, socklen_t idle_time, socklen_t interval, socklen_t cnt)
{
	setsockopt (sockfd, SOL_SOCKET, SO_KEEPALIVE, (const char *) &attr_on, sizeof (attr_on));
	setsockopt (sockfd, SOL_TCP, TCP_KEEPIDLE, (const char *) &idle_time, sizeof (idle_time));
	setsockopt (sockfd, SOL_TCP, TCP_KEEPINTVL, (const char *) &interval, sizeof (interval));
	setsockopt (sockfd, SOL_TCP, TCP_KEEPCNT, (const char *) &cnt, sizeof (cnt));
}

int main(int argc, char *argv[])
{
	int i, ret, fd, newfd;
	fd_set set, tmpset;
	Addr_in clientaddr;
	socklen_t clientlen = sizeof(Addr_in);
	/*检查参数，小于3个 直接退出进程*/
	Argment(argc, argv);
	/*创建已设置监听模式的套接字*/
	fd = CreateSocket(argv);

	FD_ZERO(&set);
	FD_ZERO(&tmpset);
	FD_SET(fd, &set);
	while(1){
		tmpset = set;
		if( (ret = select(MAX_SOCK_FD, &tmpset, NULL, NULL, NULL)) < 0){
			perror("select");
			getchar();
		}
		if(FD_ISSET(fd, &tmpset) ){
			/*接收客户端连接，并生成新的文件描述符*/
			if( (newfd = accept(fd, (Addr *)&clientaddr, &clientlen) ) < 0){
				perror("accept");
				getchar();
			}
#if 1
			int keepAlive = 1;			//设定KeepAlive
			int keepIdle = 5;			//开始首次KeepAlive探测前的TCP空闭时间
			int keepInterval = 5;		//两次KeepAlive探测间的时间间隔
			int keepCount = 3;			//判定断开前的KeepAlive探测次数
			setKeepAlive (newfd, keepAlive, keepIdle, keepInterval, keepCount);
#endif

			printf("[%s:%d]已建立连接\n", 
					inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
			FD_SET(newfd, &set);
		}else{ //处理客户端数据
			for(i = fd + 1; i < MAX_SOCK_FD; i++){
				if(FD_ISSET(i, &tmpset)){
					if( DataHandle(i) <= 0){
						if( getpeername(i, (Addr *)&clientaddr, &clientlen) )
							perror("getpeername");
						printf("[%s:%d]断开连接\n", 
								inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
						FD_CLR(i, &set);
						close(i);
					}
				}
			}
		}
	}
	close(fd);
	return 0;
}

测试结果：
如果两台虚拟机没有在一个桥段网络中设置方法（我的是Ubuntu 14.04版本的系统）：

设置两台虚拟机的IP地址

打开终端，以管理员权限执行以下命令以编辑网络配置文件：

sudo nano /etc/network/interfaces

Ctrl + O # 保存文件
Enter # 确认文件名
Ctrl + X # 退出编辑器

在文件中找到主机A的网络配置部分，并将其修改为以下内容：

auto eth0 
iface eth0 inet static 
address 192.168.1.10 
netmask 255.255.255.0 
gateway 192.168.1.1

找到主机B的网络配置部分，并将其修改为以下内容：

auto eth0 
iface eth0 inet static 
address 192.168.1.20 
netmask 255.255.255.0 
gateway 192.168.1.1

保存文件并关闭编辑器。
重新启动网络服务以应用配置更改：

sudo service networking restart

确保主机A和主机B都连接到同一个共享的桥接设备或交换机上。
现在主机A和主机B的网络配置已调整为在同一个桥接网段下。你可以尝试通过ping命令来测试它们之间的连通性：

ping 192.168.1.20

如果能够成功相互通信，则说明它们处于同一个桥接网段中。

如果想恢复自动获取的IP地址只需要把 /etc/network/interfaces 文件改回


auto eth0
iface eth0 inet dhcp

最终两台虚拟机测试的IP地址
主机A地址：192.168.1.10
主机B地址：192.168.1.20

主机A：

运行服务端代码
运行 wireshark程序
连接主机B

主机B：
连接主机A

最后看主机A wireshark当中抓获主机B的信息