一、套接字选项的设置

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

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

二、getsockopt、setsockopt

  • ​功能：​用于设置/获得套接字选项
#include<sys/socket.h>
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：​表示启用该选项


 三、套接字选项汇总

​下面表格的格式说明​

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

UNP编程：21---套接字选项之（套接字选项简介与接口：getsockopt、setsockopt）_#endif_02


通用套接字选项(SOL_SOCKET)

  • ​

IPV4套接字选项(IPPROTO_IP)

  • ​

IPV6套接字选项(IPPROTO_IPV6)

  • ​

ICMPv6套接字选项(IPPROTO_ICMPV6)

TCP套接字选项(IPPROTO_TCP)

  • ​

SCTP套接字选项(IPPROTO_SCTP)

  • ​


四、套接字状态

  • 对于某些套接字选项，针对套接字的状态，什么时候设置或获取选项有时序上的考虑。我 们对受影响的选项论及这一点
  • 下面的套接字选项是​由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  <netinet/tcp.h>   /* 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返回成功，那么我们调用相应的选项值输出函数将选项值转换为一个 字符串并输出。