setsockopt函数

7500阅读　0评论2013-12-14　liubangbo
分类：LINUX

内核版本：2.6.21.5
1. 还是先贴上原型吧：
   int setsockopt (int socket,  int level,  int optname,  void *optval,  socklen toptlen)
  我们都知道这个函数是用来设置socket属性的，通过这个函数可以设置接收和发送缓冲区大小，端口复用等。从这里我们可以猜到这个函数是通过设置struct sock这个结构某些字段来实现的。现在我们来看看这个函数，然后慢慢加上各个属性的
  意义，即设置了一个属性，网络会产生什么反应。

2.
  

点击(此处)折叠或打开

  1. /*
  2.  *    Set a socket option. Because we don't know the option lengths we have
  3.  *    to pass the user mode parameter for the protocols to sort out.
  4.  */

  6. asmlinkage long sys_setsockopt(int fd, int level, int optname,
  7.              char __user *optval, int optlen)
  8. {
  9.     int err, fput_needed;
  10.     struct socket *sock;

  12.     if (optlen < 0)
  13.         return -EINVAL;

  15.     sock = sockfd_lookup_light(fd, &err, &fput_needed);
  16.     if (sock != NULL) {
  17.         err = security_socket_setsockopt(sock, level, optname);
  18.         if (err)
  19.             goto out_put;

  21.         if (level == SOL_SOCKET)     //从这里我们看到根据level的不同，有2大类可以设置，一个就是对socket进行设置，另一个就是根据具体协议进行设置
  22.             err =
  23.              sock_setsockopt(sock, level, optname, optval,
  24.                      optlen);
  25.         else
  26.             err =
  27.              sock->ops->setsockopt(sock, level, optname, optval,
  28.                          optlen);
  29. out_put:
  30.         fput_light(sock->file, fput_needed);
  31.     }
  32.     return err;
  33. }
3. 先看对socket属性的设置
   

点击(此处)折叠或打开

  1. /*
  2.  *    This is meant for all protocols to use and covers goings on
  3.  *    at the socket level. Everything here is generic.
  4.  */

  6. int sock_setsockopt(struct socket *sock, int level, int optname,
  7.          char __user *optval, int optlen)
  8. {
  9.     struct sock *sk=sock->sk;
  10.     struct sk_filter *filter;
  11.     int val;
  12.     int valbool;
  13.     struct linger ling;
  14.     int ret = 0;

  16.     /*
  17.      *    Options without arguments
  18.      */

  20. #ifdef SO_DONTLINGER        /* Compatibility item... */
  21.     if (optname == SO_DONTLINGER) {
  22.         lock_sock(sk);
  23.         sock_reset_flag(sk, SOCK_LINGER);
  24.         release_sock(sk);
  25.         return 0;
  26.     }
  27. #endif

  29.     if(optlen<sizeof(int))
  30.         return(-EINVAL);

  32.     if (get_user(val, (int __user *)optval))  //从用户空间向内核空间传递参数，get_user 和 put_user这两个函数只能传递一些简单类型的变量，像char，int, long等类型，对一些大数据块的传递
  33.                                               //要用copy_from_user和copy_to_user
  34.         return -EFAULT;

  36.     valbool = val?1:0;  //从这里我们看到参数被分为1和0

  38.     lock_sock(sk);

  40.     switch(optname)
  41.     {
  42.         case SO_DEBUG:
  43.             if(val && !capable(CAP_NET_ADMIN))
  44.             {
  45.                 ret = -EACCES;
  46.             }
  47.             else if (valbool)
  48.                 sock_set_flag(sk, SOCK_DBG);
  49.             else
  50.                 sock_reset_flag(sk, SOCK_DBG);
  51.             break;
  52.         case SO_REUSEADDR:       //这里就是对端口复用的设置，还记得我们在bind socket的时候，只有设置了这一个属性不同的socket才能bind到同一个端口上
  53.             sk->sk_reuse = valbool;
  54.             break;
  55.         case SO_TYPE:
  56.         case SO_ERROR:
  57.             ret = -ENOPROTOOPT;
  58.             break;
  59.         case SO_DONTROUTE:
  60.             if (valbool)
  61.                 sock_set_flag(sk, SOCK_LOCALROUTE);
  62.             else
  63.                 sock_reset_flag(sk, SOCK_LOCALROUTE);
  64.             break;
  65.         case SO_BROADCAST:
  66.             sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
  67.             break;
  68.         case SO_SNDBUF:
  69.             /* Don't error on this BSD doesn't and if you think
  70.              about it this is right. Otherwise apps have to
  71.              play 'guess the biggest size' games. RCVBUF/SNDBUF
  72.              are treated in BSD as hints */

  74.             if (val > sysctl_wmem_max)
  75.                 val = sysctl_wmem_max;
  76. set_sndbuf:
  77.             sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
  78.             if ((val * 2) < SOCK_MIN_SNDBUF)
  79.                 sk->sk_sndbuf = SOCK_MIN_SNDBUF;
  80.             else
  81.                 sk->sk_sndbuf = val * 2;

  83.             /*
  84.              *    Wake up sending tasks if we
  85.              *    upped the value.
  86.              */
  87.             sk->sk_write_space(sk);
  88.             break;

  90.         case SO_SNDBUFFORCE:
  91.             if (!capable(CAP_NET_ADMIN)) {
  92.                 ret = -EPERM;
  93.                 break;
  94.             }
  95.             goto set_sndbuf;

  97.         case SO_RCVBUF:       //这里对接收缓冲区大小进行的设置
  98.             /* Don't error on this BSD doesn't and if you think
  99.              about it this is right. Otherwise apps have to
  100.              play 'guess the biggest size' games. RCVBUF/SNDBUF
  101.              are treated in BSD as hints */

  103.             if (val > sysctl_rmem_max)   //看到了没，这里不允许用户随意设置呢，有最大值，得用sysctl修改，或在/proc目录下调整这个值
  104.                 val = sysctl_rmem_max;
  105. set_rcvbuf:
  106.             sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
  107.             /*
  108.              * We double it on the way in to account for
  109.              * "struct sk_buff" etc. overhead. Applications
  110.              * assume that the SO_RCVBUF setting they make will
  111.              * allow that much actual data to be received on that
  112.              * socket.
  113.              *
  114.              * Applications are unaware that "struct sk_buff" and
  115.              * other overheads allocate from the receive buffer
  116.              * during socket buffer allocation.
  117.              *
  118.              * And after considering the possible alternatives,
  119.              * returning the value we actually used in getsockopt
  120.              * is the most desirable behavior.
  121.              */
  122.             if ((val * 2) < SOCK_MIN_RCVBUF)     //这里是最小值256
  123.                 sk->sk_rcvbuf = SOCK_MIN_RCVBUF;
  124.             else
  125.                 sk->sk_rcvbuf = val * 2;     //设置的值要加倍
  126.             break;

  128.         case SO_RCVBUFFORCE:              //看到没这个是force，允许野蛮...
  129.             if (!capable(CAP_NET_ADMIN)) {
  130.                 ret = -EPERM;
  131.                 break;
  132.             }
  133.             goto set_rcvbuf;

  135.         case SO_KEEPALIVE:
  136. #ifdef CONFIG_INET
  137.             if (sk->sk_protocol == IPPROTO_TCP)
  138.                 tcp_set_keepalive(sk, valbool);
  139. #endif
  140.             sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
  141.             break;

  143.         case SO_OOBINLINE:
  144.             sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
  145.             break;

  147.         case SO_NO_CHECK:
  148.             sk->sk_no_check = valbool;
  149.             break;

  151.         case SO_PRIORITY:
  152.             if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN))
  153.                 sk->sk_priority = val;
  154.             else
  155.                 ret = -EPERM;
  156.             break;

  158.         case SO_LINGER:
  159.             if(optlen<sizeof(ling)) {
  160.                 ret = -EINVAL;    /* 1003.1g */
  161.                 break;
  162.             }
  163.             if (copy_from_user(&ling,optval,sizeof(ling))) {
  164.                 ret = -EFAULT;
  165.                 break;
  166.             }
  167.             if (!ling.l_onoff)
  168.                 sock_reset_flag(sk, SOCK_LINGER);
  169.             else {
  170. #if (BITS_PER_LONG == 32)
  171.                 if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
  172.                     sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
  173.                 else
  174. #endif
  175.                     sk->sk_lingertime = (unsigned int)ling.l_linger * HZ;
  176.                 sock_set_flag(sk, SOCK_LINGER);
  177.             }
  178.             break;

  180.         case SO_BSDCOMPAT:
  181.             sock_warn_obsolete_bsdism("setsockopt");
  182.             break;

  184.         case SO_PASSCRED:
  185.             if (valbool)
  186.                 set_bit(SOCK_PASSCRED, &sock->flags);
  187.             else
  188.                 clear_bit(SOCK_PASSCRED, &sock->flags);
  189.             break;

  191.         case SO_TIMESTAMP:
  192.             if (valbool) {
  193.                 sock_set_flag(sk, SOCK_RCVTSTAMP);
  194.                 sock_enable_timestamp(sk);
  195.             } else
  196.                 sock_reset_flag(sk, SOCK_RCVTSTAMP);
  197.             break;

  199.         case SO_RCVLOWAT:
  200.             if (val < 0)
  201.                 val = INT_MAX;
  202.             sk->sk_rcvlowat = val ? : 1;
  203.             break;

  205.         case SO_RCVTIMEO:    //还记得这么吗，这个就是阻塞在recvfrom函数的时间设置，等待skb的时间
  206.             ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
  207.             break;

  209.         case SO_SNDTIMEO:
  210.             ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
  211.             break;

  213. #ifdef CONFIG_NETDEVICES
  214.         case SO_BINDTODEVICE:
  215.         {
  216.             char devname[IFNAMSIZ];

  218.             /* Sorry... */
  219.             if (!capable(CAP_NET_RAW)) {
  220.                 ret = -EPERM;
  221.                 break;
  222.             }

  224.             /* Bind this socket to a particular device like "eth0",
  225.              * as specified in the passed interface name. If the
  226.              * name is "" or the option length is zero the socket
  227.              * is not bound.
  228.              */

  230.             if (!valbool) {
  231.                 sk->sk_bound_dev_if = 0;
  232.             } else {
  233.                 if (optlen > IFNAMSIZ - 1)
  234.                     optlen = IFNAMSIZ - 1;
  235.                 memset(devname, 0, sizeof(devname));
  236.                 if (copy_from_user(devname, optval, optlen)) {
  237.                     ret = -EFAULT;
  238.                     break;
  239.                 }

  241.                 /* Remove any cached route for this socket. */
  242.                 sk_dst_reset(sk);

  244.                 if (devname[0] == '\0') {
  245.                     sk->sk_bound_dev_if = 0;
  246.                 } else {
  247.                     struct net_device *dev = dev_get_by_name(devname);
  248.                     if (!dev) {
  249.                         ret = -ENODEV;
  250.                         break;
  251.                     }
  252.                     sk->sk_bound_dev_if = dev->ifindex;
  253.                     dev_put(dev);
  254.                 }
  255.             }
  256.             break;
  257.         }
  258. #endif


  261.         case SO_ATTACH_FILTER:
  262.             ret = -EINVAL;
  263.             if (optlen == sizeof(struct sock_fprog)) {
  264.                 struct sock_fprog fprog;

  266.                 ret = -EFAULT;
  267.                 if (copy_from_user(&fprog, optval, sizeof(fprog)))
  268.                     break;

  270.                 ret = sk_attach_filter(&fprog, sk);
  271.             }
  272.             break;

  274.         case SO_DETACH_FILTER:
  275.             rcu_read_lock_bh();
  276.             filter = rcu_dereference(sk->sk_filter);
  277.             if (filter) {
  278.                 rcu_assign_pointer(sk->sk_filter, NULL);
  279.                 sk_filter_release(sk, filter);
  280.                 rcu_read_unlock_bh();
  281.                 break;
  282.             }
  283.             rcu_read_unlock_bh();
  284.             ret = -ENONET;
  285.             break;

  287.         case SO_PASSSEC:
  288.             if (valbool)
  289.                 set_bit(SOCK_PASSSEC, &sock->flags);
  290.             else
  291.                 clear_bit(SOCK_PASSSEC, &sock->flags);
  292.             break;

  294.         /* We implement the SO_SNDLOWAT etc to
  295.          not be settable (1003.1g 5.3) */
  296.         default:
  297.             ret = -ENOPROTOOPT;
  298.             break;
  299.     }
  300.     release_sock(sk);
  301.     return ret;
  302. }
4. 我们看看通过这个函数对udp属性的设置
    一路下去会进入这个函数udp_setsockopt
   

点击(此处)折叠或打开

  1. int udp_setsockopt(struct sock *sk, int level, int optname,
  2.          char __user *optval, int optlen)
  3. {
  4.     if (level == SOL_UDP || level == SOL_UDPLITE)
  5.         return udp_lib_setsockopt(sk, level, optname, optval, optlen,
  6.                      udp_push_pending_frames);
  7.     return ip_setsockopt(sk, level, optname, optval, optlen);
  8. }



  12. /*
  13.  *    Socket option code for UDP
  14.  */
  15. int udp_lib_setsockopt(struct sock *sk, int level, int optname,
  16.          char __user *optval, int optlen,
  17.          int (*push_pending_frames)(struct sock *))
  18. {
  19.     struct udp_sock *up = udp_sk(sk);
  20.     int val;
  21.     int err = 0;

  23.     if(optlen<sizeof(int))
  24.         return -EINVAL;

  26.     if (get_user(val, (int __user *)optval))
  27.         return -EFAULT;

  29.     switch(optname) {
  30.     case UDP_CORK:
  31.         if (val != 0) {
  32.             up->corkflag = 1;  //这个属性是设置是否允许小块数据合并成一个大快数据发送，把木塞堵住。默认不设置，所以当我们用sendto(udp)发送小数据的时候，在对端立即
  33.                                //会收到，但当我们设置这个属性的时候，sendto小数据块的时候，在对端不会立即收到，不信你试试
  34.         } else {
  35.             up->corkflag = 0;
  36.             lock_sock(sk);
  37.             (*push_pending_frames)(sk);
  38.             release_sock(sk);
  39.         }
  40.         break;

  42.     case UDP_ENCAP:
  43.         switch (val) {
  44.         case 0:
  45.         case UDP_ENCAP_ESPINUDP:
  46.         case UDP_ENCAP_ESPINUDP_NON_IKE:
  47.             up->encap_type = val;
  48.             break;
  49.         default:
  50.             err = -ENOPROTOOPT;
  51.             break;
  52.         }
  53.         break;

  55.     /*
  56.      *     UDP-Lite






上一篇：recvfrom函数
下一篇：代码级优化(代码质量)