UNIX(网络编程-基本用法):22---套接字选项之（套接字选项简介与接口：getsockopt、setsockopt）

一、套接字选项的设置

有很多方法来获取和设置影响套接字的选项：

• getsockopt和setsockopt函数；
• fcntl函数
• ioctl函数

二、getsockopt、setsockopt

• 功能：用于设置/获得套接字选项

#include
int setsockopt(int sockfd, int level, int optname,const void *optval, socklen_t optlen);
int getsockopt(int sockfd, int level, int optname,void *optval, socklen_t *optlen);

//返回值：成功返回0;失败返回-1

参数

sockfd	指向一个已打开的套接字描述符
level（级别）	指定系统中解释选项的代码或为通用套接字代码，或为某个特定于协议的代码(IPV4、IPV6、TCP、SCTP)
optname	对应于level级别下面的选项
optval	一个指向某个变量的指针 用于设置/取得选项信息
optlen	对应于optval的大小/指针大小

套接字选项大致分为两种类型

• ①启用或禁止某个特性的二元选项（称为标志选项）
• ②取得并返回我们可以设置或检查的特定值的选项（称为值选项）

当我们调用getsockopt时

• *optval如果返回值是0：表示相应选项被禁止
• *optval如果返回值是非0：表示相应选项被启用

当我们调用setsockopt时

• 赋予*optval的值为0：表示禁用该选项
• 赋予*optval的值为非0：表示启用该选项

 三、套接字选项汇总

下面表格的格式说明

• 如果标志列不含有，那么相应选项用于在用户进程与系统之间传递所指定数据类型的值
• 数据类型表示optval的数据类型（如果是结构体类型，就在后面加{}，例如struct linger表示为linger{}）
• get：代表是否可以获得该选项
• set：代表是否可以设置该选项

通用套接字选项(SOL_SOCKET)

• 见文章：https://blog.csdn.net/qq_41453285/article/details/89536443

IPV4套接字选项(IPPROTO_IP)

• 见文章：https://blog.csdn.net/qq_41453285/article/details/89540370

IPV6套接字选项(IPPROTO_IPV6)

• 见文章：https://blog.csdn.net/qq_41453285/article/details/89540494

ICMPv6套接字选项(IPPROTO_ICMPV6)

• 见文章：https://blog.csdn.net/qq_41453285/article/details/89540683

TCP套接字选项(IPPROTO_TCP)

• 见文章：https://blog.csdn.net/qq_41453285/article/details/89541693

SCTP套接字选项(IPPROTO_SCTP)

• 见文章：https://blog.csdn.net/qq_41453285/article/details/89541899

四、套接字状态

• 对于某些套接字选项，针对套接字的状态，什么时候设置或获取选项有时序上的考虑。我 们对受影响的选项论及这一点
• 下面的套接字选项是由TCP已连接套接字从监听套接字继承来的（TCPv2第462～463页）： SO_DEBUG、SO_DONTROUTE、SO_KEEPALIVE、SO_LINGER、SO_OOBINLINE、SO_RCVBUF、 SO_RCVLOWAT、SO_SNDBUF、SO_SNDLOWAT、TCP_MAXSEG和TCP_NODELAY。这对TCP是很重要 的，因为accept一直要到TCP层完成三路握手后才会给服务器返回已连接套接字。如果想在三路握手完成时确保这些套接字选项中的某一个是给已连接套接字设置的，那么我们必须先给监听套接字设置该选项

五、编程检查套接字选项是否受支持并获取默认值

代码如下

/* include checkopts1 */
/* *INDENT-OFF* */
#include			/* for TCP_xxx defines */

union val {
  int				i_val;
  long				l_val;
  struct linger		linger_val;
  struct timeval	timeval_val;
} val;

static char	*sock_str_flag(union val *, int);
static char	*sock_str_int(union val *, int);
static char	*sock_str_linger(union val *, int);
static char	*sock_str_timeval(union val *, int);

struct sock_opts {
  const char	   *opt_str;
  int		opt_level;
  int		opt_name;
  char   *(*opt_val_str)(union val *, int);
} sock_opts[] = {
	{ "SO_BROADCAST",		SOL_SOCKET,	SO_BROADCAST,	sock_str_flag },
	{ "SO_DEBUG",			SOL_SOCKET,	SO_DEBUG,		sock_str_flag },
	{ "SO_DONTROUTE",		SOL_SOCKET,	SO_DONTROUTE,	sock_str_flag },
	{ "SO_ERROR",			SOL_SOCKET,	SO_ERROR,		sock_str_int },
	{ "SO_KEEPALIVE",		SOL_SOCKET,	SO_KEEPALIVE,	sock_str_flag },
	{ "SO_LINGER",			SOL_SOCKET,	SO_LINGER,		sock_str_linger },
	{ "SO_OOBINLINE",		SOL_SOCKET,	SO_OOBINLINE,	sock_str_flag },
	{ "SO_RCVBUF",			SOL_SOCKET,	SO_RCVBUF,		sock_str_int },
	{ "SO_SNDBUF",			SOL_SOCKET,	SO_SNDBUF,		sock_str_int },
	{ "SO_RCVLOWAT",		SOL_SOCKET,	SO_RCVLOWAT,	sock_str_int },
	{ "SO_SNDLOWAT",		SOL_SOCKET,	SO_SNDLOWAT,	sock_str_int },
	{ "SO_RCVTIMEO",		SOL_SOCKET,	SO_RCVTIMEO,	sock_str_timeval },
	{ "SO_SNDTIMEO",		SOL_SOCKET,	SO_SNDTIMEO,	sock_str_timeval },
	{ "SO_REUSEADDR",		SOL_SOCKET,	SO_REUSEADDR,	sock_str_flag },
#ifdef	SO_REUSEPORT
	{ "SO_REUSEPORT",		SOL_SOCKET,	SO_REUSEPORT,	sock_str_flag },
#else
	{ "SO_REUSEPORT",		0,			0,				NULL },
#endif
	{ "SO_TYPE",			SOL_SOCKET,	SO_TYPE,		sock_str_int },
	{ "SO_USELOOPBACK",		SOL_SOCKET,	SO_USELOOPBACK,	sock_str_flag },
	{ "IP_TOS",				IPPROTO_IP,	IP_TOS,			sock_str_int },
	{ "IP_TTL",				IPPROTO_IP,	IP_TTL,			sock_str_int },
#ifdef	IPV6_DONTFRAG
	{ "IPV6_DONTFRAG",		IPPROTO_IPV6,IPV6_DONTFRAG,	sock_str_flag },
#else
	{ "IPV6_DONTFRAG",		0,			0,				NULL },
#endif
#ifdef	IPV6_UNICAST_HOPS
	{ "IPV6_UNICAST_HOPS",	IPPROTO_IPV6,IPV6_UNICAST_HOPS,sock_str_int },
#else
	{ "IPV6_UNICAST_HOPS",	0,			0,				NULL },
#endif
#ifdef	IPV6_V6ONLY
	{ "IPV6_V6ONLY",		IPPROTO_IPV6,IPV6_V6ONLY,	sock_str_flag },
#else
	{ "IPV6_V6ONLY",		0,			0,				NULL },
#endif
	{ "TCP_MAXSEG",			IPPROTO_TCP,TCP_MAXSEG,		sock_str_int },
	{ "TCP_NODELAY",		IPPROTO_TCP,TCP_NODELAY,	sock_str_flag },
#ifdef	SCTP_AUTOCLOSE
	{ "SCTP_AUTOCLOSE",		IPPROTO_SCTP,SCTP_AUTOCLOSE,sock_str_int },
#else
	{ "SCTP_AUTOCLOSE",		0,			0,				NULL },
#endif
#ifdef	SCTP_MAXBURST
	{ "SCTP_MAXBURST",		IPPROTO_SCTP,SCTP_MAXBURST,	sock_str_int },
#else
	{ "SCTP_MAXBURST",		0,			0,				NULL },
#endif
#ifdef	SCTP_MAXSEG
	{ "SCTP_MAXSEG",		IPPROTO_SCTP,SCTP_MAXSEG,	sock_str_int },
#else
	{ "SCTP_MAXSEG",		0,			0,				NULL },
#endif
#ifdef	SCTP_NODELAY
	{ "SCTP_NODELAY",		IPPROTO_SCTP,SCTP_NODELAY,	sock_str_flag },
#else
	{ "SCTP_NODELAY",		0,			0,				NULL },
#endif
	{ NULL,					0,			0,				NULL }
};
/* *INDENT-ON* */
/* end checkopts1 */

/* include checkopts2 */
int
main(int argc, char **argv)
{
	int					fd;
	socklen_t			len;
	struct sock_opts	*ptr;

	for (ptr = sock_opts; ptr->opt_str != NULL; ptr++) {
		printf("%s: ", ptr->opt_str);
		if (ptr->opt_val_str == NULL)
			printf("(undefined)\n");
		else {
			switch(ptr->opt_level) {
			case SOL_SOCKET:
			case IPPROTO_IP:
			case IPPROTO_TCP:
				fd = Socket(AF_INET, SOCK_STREAM, 0);
				break;
#ifdef	IPV6
			case IPPROTO_IPV6:
				fd = Socket(AF_INET6, SOCK_STREAM, 0);
				break;
#endif
#ifdef	IPPROTO_SCTP
			case IPPROTO_SCTP:
				fd = Socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP);
				break;
#endif
			default:
				err_quit("Can't create fd for level %d\n", ptr->opt_level);
			}

			len = sizeof(val);
			if (getsockopt(fd, ptr->opt_level, ptr->opt_name,
						   &val, &len) == -1) {
				err_ret("getsockopt error");
			} else {
				printf("default = %s\n", (*ptr->opt_val_str)(&val, len));
			}
			close(fd);
		}
	}
	exit(0);
}
/* end checkopts2 */

/* include checkopts3 */
static char	strres[128];

static char	*
sock_str_flag(union val *ptr, int len)
{
/* *INDENT-OFF* */
	if (len != sizeof(int))
		snprintf(strres, sizeof(strres), "size (%d) not sizeof(int)", len);
	else
		snprintf(strres, sizeof(strres),
				 "%s", (ptr->i_val == 0) ? "off" : "on");
	return(strres);
/* *INDENT-ON* */
}
/* end checkopts3 */

static char	*
sock_str_int(union val *ptr, int len)
{
	if (len != sizeof(int))
		snprintf(strres, sizeof(strres), "size (%d) not sizeof(int)", len);
	else
		snprintf(strres, sizeof(strres), "%d", ptr->i_val);
	return(strres);
}

static char	*
sock_str_linger(union val *ptr, int len)
{
	struct linger	*lptr = &ptr->linger_val;

	if (len != sizeof(struct linger))
		snprintf(strres, sizeof(strres),
				 "size (%d) not sizeof(struct linger)", len);
	else
		snprintf(strres, sizeof(strres), "l_onoff = %d, l_linger = %d",
				 lptr->l_onoff, lptr->l_linger);
	return(strres);
}

static char	*
sock_str_timeval(union val *ptr, int len)
{
	struct timeval	*tvptr = &ptr->timeval_val;

	if (len != sizeof(struct timeval))
		snprintf(strres, sizeof(strres),
				 "size (%d) not sizeof(struct timeval)", len);
	else
		snprintf(strres, sizeof(strres), "%d sec, %d usec",
				 tvptr->tv_sec, tvptr->tv_usec);
	return(strres);
}

程序解释

声明可能值的union

• 对于getsockopt的每个可能的返回值，我们的union类型中都有一个成员

定义函数原型

• 我们为用于输出给定套接字选项的值的4个函数定义了原型。

定义结构并初始化数组

• 我们的sock_opts结构包含了给每个套接字选项调用getsockopt并输出其当前值所 需要的所有信息。它的最后一个成员opt_val_str是指向用于4个选项值输出函数中的 某一个的指针。我们分配并初始化这个结构的一个数组，它的每个元素代表一个套接 字选项
• 并非所有实现都支持所有的套接字选项。确定某个给定选项是否得到支持的方法是用语 句#ifdef或#if defined，如图中SO_REUSEPORT选项所示。为求完整的话，本数组中每个 元素都应类似SO_REUSEPORT所示编写，不过我们省略了这些，因为一大堆#ifdef语句仅仅 加长了代码，对于我们的讨论没有什么用处

遍历所有选项

• 我们遍历sock_opts[]数组中的所有元素。如果某个元素的opt_val_str指针为空， 那么该实现没有定义相应的选项（我们的例子中SO_REUSEPORT选项有可能就是这样）。

创建套接字

• 我们创建一个用于测试选项的套接字。测试套接字层、TCP层和IPv4层套接字选项所用 的是一个IPv4的TCP套接字，测试IPv6层套接字选项所用的是一个IPv6的TCP套接字， 测试SCTP层套接字选项所用的是一个IPv4的SCTP套接字

调用getsockopt

• 我们调用getsockopt，不过在返回错误时并不终止。许多实现会定义一些尚未提供支 持的套接字选项的名字。这些不受支持的选项应该引发一个ENOPROTOOPT错误

输出选项的默认值

• 如果getsockopt返回成功，那么我们调用相应的选项值输出函数将选项值转换为一个 字符串并输出。