内核中的UDP socket流程（7）——udp_sendmsg

sock_sendmsg的代码很简单

1. int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
   
2. {
   
3.      struct kiocb iocb;
   
4.      struct sock_iocb siocb;
   
5.      int ret;
   
6. 
   
7.      init_sync_kiocb(&iocb, NULL);
   
8.      iocb.private = &siocb;
   
9.      ret = __sock_sendmsg(&iocb, sock, msg, size);
   
10.      if (-EIOCBQUEUED == ret)
    
11.           ret = wait_on_sync_kiocb(&iocb);
    
12.      return ret;
    
13. }

首先定义了一个struct kiocb类型的iocb——linux内核中所有I/O操作都要依赖于合格结构，然后初始化它。然后调用__sock_sendmsg，而__sock_sendmsg又调用UDP的sendmsg去做真正的发送。

也就是说，对于UDP的socket来说，sendto调用，真正去做工作的是udp_sendmsg这个函数。

1. int udp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
   
2.           size_t len)
   
3. {
   
4.      struct inet_sock *inet = inet_sk(sk);
   
5.      struct udp_sock *up = udp_sk(sk);
   
6.      int ulen = len;
   
7.      struct ipcm_cookie ipc;
   
8.      struct rtable *rt = NULL;
   
9.      int free = 0;
   
10.      int connected = 0;
    
11.      __be32 daddr, faddr, saddr;
    
12.      __be16 dport;
    
13.      u8 tos;
    
14.      int err, is_udplite = IS_UDPLITE(sk);
    
15.      int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
    
16.      int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);

将sk转为udp内部使用的类型指针，在TCP/IP中充斥了这样的转换。主要原因是因为对于上层来说，需要一个统一的类型，而到了底层的具体实现时，都会将上层抽象的数据类型，转为自己所需的类型。

并判断该UDP是否是udplite——udplite的定义见http://en.wikipedia.org/wiki/UDP_Lite

1.      if (len > 0xFFFF)
   
2.           return -EMSGSIZE;
   
3. 
   
4.      /*
   
5.      * Check the flags.
   
6.      */
   
7. 
   
8.      if (msg->msg_flags & MSG_OOB) /* Mirror BSD error message compatibility */
   
9.           return -EOPNOTSUPP;

进行一些错误检测。

1.      ipc.opt = NULL;
   
2.      ipc.shtx.flags = 0;
   
3. 
   
4.      if (up->pending) {
   
5.           /*
   
6.           * There are pending frames.
   
7.           * The socket lock must be held while it's corked.
   
8.           */
   
9.           lock_sock(sk);
   
10.           if (likely(up->pending)) {
    
11.                if (unlikely(up->pending != AF_INET)) {
    
12.                     release_sock(sk);
    
13.                     return -EINVAL;
    
14.                }
    
15.                goto do_append_data;
    
16.           }
    
17.           release_sock(sk);
    
18.      }
    
19.      ulen += sizeof(struct udphdr);

如果该socket有pending的frame，那么直接将数据追加。如果没有就ulen加上udp首部的长度。

1.      /*
   
2.      * Get and verify the address.
   
3.      */
   
4.      if (msg->msg_name) {
   
5.           struct sockaddr_in * usin = (struct sockaddr_in *)msg->msg_name;
   
6.           if (msg->msg_namelen < sizeof(*usin))
   
7.                return -EINVAL;
   
8.           if (usin->sin_family != AF_INET) {
   
9.                if (usin->sin_family != AF_UNSPEC)
   
10.                     return -EAFNOSUPPORT;
    
11.           }
    
12. 
    
13.           daddr = usin->sin_addr.s_addr;
    
14.           dport = usin->sin_port;
    
15.           if (dport == 0)
    
16.                return -EINVAL;
    
17.      } else {
    
18.           if (sk->sk_state != TCP_ESTABLISHED)
    
19.                return -EDESTADDRREQ;
    
20.           daddr = inet->inet_daddr;
    
21.           dport = inet->inet_dport;
    
22.           /* Open fast path for connected socket.
    
23.              Route will not be used, if at least one option is set.
    
24.           */
    
25.           connected = 1;
    
26.      }
    
27.      ipc.addr = inet->inet_saddr;

如果msg->msg_name不为空，就说明指定了目的地址，对其进行检验。如果为空，就就需要对sock的状态进行检验，查看其是否是连接状态——UDP的socket同样是可以调用connect，这样就不需要每次都指定发送地址了。