Linux TCP/IP 协议栈之 Socket的实现分析(数据包的接收)-阿里云开发者社区

   前面了解过 sk 有一个接收队列，用于存储接收到的 skb，对于 socket 层面上来讲，数据接收，就
是要把数据从这个队列中取出来，交给上层用户态。这里涉及到出队操作，但是，要了解如何出队，
就得了解传输层协议如何入队。前面一直用 tcp协议来分析，现在还没有把整个 tcp栈分析出来，
要再继续用 tcp 协议来分析，就有点问题了，所以，数据的接收和发送，都将以 udp 协议来分析。
虽然它很简单，但同样也反应了 socket 层数据与接收的全部核心内容与思路。我以希望，下一步拿
下 tcp 协议后，再把这部份的 tcp 实现补上来。

udp 层的数据接收
udp 层的数据接收，对于 socket 而言，就是接收队列的入队操作。在 ip 层中，如果是本地数据，则
会交由 ip_local_deliver_finish()函数处理，它会根据传输层协议的类型，交由相应的处理函数，对于udp 协议而言，
就是 udp_rcv()：

/*
*        All we need to do is get the socket, and then do a checksum.
*/
int udp_rcv(struct sk_buff *skb)
{
        struct sock *sk;
        struct udphdr *uh;
        unsigned short ulen;
        struct rtable *rt = (struct rtable*)skb->dst;
        u32 saddr = skb->nh.iph->saddr;
        u32 daddr = skb->nh.iph->daddr;
        int len = skb->len;

        /*
         *         数据包至少应有 UDP 首部长度.
         */
        if (!pskb_may_pull(skb, sizeof(struct udphdr)))
                goto no_header;

        /*获取 udp 首部指针*/
        uh = skb->h.uh;

        /* 数据长度，含首部长度 */
        ulen = ntohs(uh->len);

        /* 数据包长度不够：UDP 长度比 skb 长度小，意味着数据的丢失，而 udp 长度比 udp 首部
         * 还要小，好像这个不太可能，除非封包出错 ^o^*/
        if (ulen > len || ulen                 goto short_packet;

        /* 截去 udp 报文后面的多余报文 */
        if (pskb_trim(skb, ulen))
                goto short_packet;

        /* 开始 udp 校验和计算，主要查依赖于 skb 的 ip_summumed 字段的设置来决定是否需要行校验和计算 */
        if (udp_checksum_init(skb, uh, ulen, saddr, daddr)                 goto csum_error;

        /* 转换多播或广播处理例程 */
        if(rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST))
                return udp_v4_mcast_deliver(skb, uh, saddr, daddr);

        /* 查找数据段对应的 socket结构的 sk */
        sk = udp_v4_lookup(saddr, uh->source, daddr, uh->dest, skb->dev->ifindex);

        if (sk != NULL) {
                /* 找到了，数据包进入 UDP 的 socket 的接收队列*/
                int ret = udp_queue_rcv_skb(sk, skb);
                sock_put(sk);

                /* a return value > 0 means to resubmit the input, but                  * it it wants the return to be -protocol, or 0
                 */
                if (ret > 0)
                        return -ret;
                return 0;
        }

        if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
                goto drop;

        /* 没有对应的 socket. 如果校验和错误，则丢弃它 */
        if (udp_checksum_complete(skb))
                goto csum_error;

        /* 发送一个目的不可达报文 */
        UDP_INC_STATS_BH(UDP_MIB_NOPORTS);
        icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);

        /*
         * Hmm. We got an UDP packet to a port to which we
         * don't wanna listen. Ignore it.
         */
        kfree_skb(skb);
        return(0);

short_packet:
        NETDEBUG(if (net_ratelimit())
                printk(KERN_DEBUG "UDP: short packet: From %u.%u.%u.%u:%u %d/%d to
                        %u.%u.%u.%u:%u/n",
                        NIPQUAD(saddr),
                        ntohs(uh->source),
                        ulen,
                        len,
                        NIPQUAD(daddr),
                        ntohs(uh->dest)));
no_header:
        UDP_INC_STATS_BH(UDP_MIB_INERRORS);
        kfree_skb(skb);
        return(0);

csum_error:
        /*
         * RFC1122: OK. Discards the bad packet silently (as far as
         * the network is concerned, anyway) as per 4.1.3.4 (MUST).           */
        NETDEBUG(if (net_ratelimit())
                 printk(KERN_DEBUG "UDP: bad checksum. From %d.%d.%d.%d:%d to
                 %d.%d.%d.%d:%d ulen %d/n",
                        NIPQUAD(saddr),
                        ntohs(uh->source),
                        NIPQUAD(daddr),
                        ntohs(uh->dest),
                        ulen));
drop:
        UDP_INC_STATS_BH(UDP_MIB_INERRORS);
        kfree_skb(skb);
        return(0);
}

函数的核心思想，是根据 skb，查找到与之对应的 sk，调用 udp_v4_lookup()函数实现——udp 与 tcp
一样，socket有一个 hash表，这个查找，就是查找 hash 表的过程。

如果找到了对应的 sk，则进入 udp_queue_rcv_skb()函数：

/* returns:
* -1: error
*   0: success
* >0: "udp encap" protocol resubmission
*
* Note that in the success and error cases, the skb is assumed to
* have either been requeued or freed.
*/
static int udp_queue_rcv_skb(struct sock * sk, struct sk_buff *skb)
{
        /* 获取 sk 对应的udp_sock 结构指针 */
        struct udp_sock *up = udp_sk(sk);

        /*
         *        Charge it to the socket, dropping if the queue is full.
         */
        if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) {
                kfree_skb(skb);
                return -1;
        }

        if (up->encap_type) {
                /*
                 * This is an encapsulation socket, so let's see if this is
                 * an encapsulated packet.
                 * If it's a keepalive packet, then just eat it.
                 * If it's an encapsulateed packet, then pass it to the
                 * IPsec xfrm input and return the response
                 * appropriately. Otherwise, just fall through and
                 * pass this up the UDP socket.
                 */
                int ret;

                ret = udp_encap_rcv(sk, skb);
                if (ret == 0) {
                        /* Eat the packet .. */
                        kfree_skb(skb);
                        return 0;
                }
                if (ret                         /* process the ESP packet */
                        ret = xfrm4_rcv_encap(skb, up->encap_type);
                        UDP_INC_STATS_BH(UDP_MIB_INDATAGRAMS);
                        return -ret;
                }
                /* FALLTHROUGH -- it's a UDP Packet */
        }
        /* 如果需要校验 */
        if (sk->sk_filter && skb->ip_summed != CHECKSUM_UNNECESSARY) {
                /* 那就校验它吧 */
                if (__udp_checksum_complete(skb)) {
                        /* 结果校验出错，那就算了吧 */
                        UDP_INC_STATS_BH(UDP_MIB_INERRORS);
                        kfree_skb(skb);
                        return -1;
                }
                /* 已经校验过了，就设置不用再校验了 */
                skb->ip_summed = CHECKSUM_UNNECESSARY;
        }

        /* 设用 sock_queue_rcv_skb 入队 */
        if (sock_queue_rcv_skb(sk,skb)                UDP_INC_STATS_BH(UDP_MIB_INERRORS);
                kfree_skb(skb);
                return -1;
        }
        UDP_INC_STATS_BH(UDP_MIB_INDATAGRAMS);
        return 0; }[/code]
encap_type字段用于判断 udp 包，是否是一个 IPSEC 协议的封装报文，这里不关心 ipsec，所以接下
来的工作，就是校验和计算，然后紧跟着调用 sock_queue_rcv_skb()：

static inline int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
{
        int err = 0;
        int skb_len;

        /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces
           number of warnings when compiling with -W --ANK
         */
        if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
            (unsigned)sk->sk_rcvbuf) {
                err = -ENOMEM;
                goto out;
        }

        /* 进入 socket 层的包过滤        */
        err = sk_filter(sk, skb, 1);
        if (err)
                goto out;

        /* 设置 skb 的一些必要的指针和计数器变量
         * dev:关连备设指针;
         * sk:所对应的 sk 结构;
         * destructor：函数指针可以初始化成一个在缓冲区释放时完成某些动作的函数。
         * 如果 skb 不属于一个 socket，则其常为 NULL。反之，这个函数会被赋值为 sock_rfree 或sock_wfree.
         * 用于更新 socket的队列中的内存容量。*/
        skb->dev = NULL;
        skb_set_owner_r(skb, sk);

        /* 在skb 入队之前，保存其长度至临时变量 skb_len，这是因为一旦 skb 入队后，它将被
         * 其它线程处理，skb 命运未知。。。。。。，而 len 值后面还会用到。
         */
        skb_len = skb->len;

        /* 将skb 加入 sk的接收队列 */
        skb_queue_tail(&sk->sk_receive_queue, skb);

        /* 唤醒 socket 上的接收线程？ */
        if (!sock_flag(sk, SOCK_DEAD))
                sk->sk_data_ready(sk, skb_len); out:
        return err;
}
对于 udp 而言，直接调用 skb_queue_tail()，将 skb 加入至 sk的 sk_receive_queue 队列即可。

udp 层的数据出队操作

了解了数据包如何被加入队列，上层 socket 的数据接收，就是从这个队列中来取数据。udp 对应的
取数据的函数 udp_recvmsg()，后面再来看它是如何被调用的，现在先来分析它的实现：

/*
*         This should be easy, if there is something there we
*         return it, otherwise we block.
*/
static int udp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
                       size_t len, int noblock, int flags, int *addr_len)
{
        struct inet_sock *inet = inet_sk(sk);                /* 取得 sk对应的 inet_sock 指针 */
        struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
        struct sk_buff *skb;
        int copied, err;

        /*
         *         校验地址长度
         */
        if (addr_len)
                *addr_len=sizeof(*sin);

        /* 如果 sk 队列中有错误的信息，则设用 ip_recv_error函数 */
        if (flags & MSG_ERRQUEUE)
                return ip_recv_error(sk, msg, len);

try_again:
        /* 出队 */
        skb = skb_recv_datagram(sk, flags, noblock, &err);
        if (!skb)
                goto out;

        /* 需要拷贝的数据不包含 UDP 首部 */
        copied = skb->len - sizeof(struct udphdr);

        /* 如果用户提供的缓存不够，则设置为只拷贝用户需要的长度，并设置截短数据标志 */
        if (copied > len) {
                copied = len;
                msg->msg_flags |= MSG_TRUNC;         }

        if (skb->ip_summed==CHECKSUM_UNNECESSARY) {
                /* 拷贝数据至用户空间 */
                err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov, copied);
        } else if (msg->msg_flags&MSG_TRUNC) {
                if (__udp_checksum_complete(skb))
                        goto csum_copy_err;
                err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov,
                                              copied);
        } else {
                err = skb_copy_and_csum_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov);

                if (err == -EINVAL)
                        goto csum_copy_err;
        }

        if (err)
                goto out_free;

        /* 更新 sk 的接收时间戳，根据 SOCK_RCVTSTAMP标志的设置来决定：
         * 选择当前时间还是skb buffer的接收时间 */
        sock_recv_timestamp(msg, sk, skb);

        /* 拷贝地址等信息. */
        if (sin)
        {
                sin->sin_family = AF_INET;
                sin->sin_port = skb->h.uh->source;
                sin->sin_addr.s_addr = skb->nh.iph->saddr;
                memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
          }

        /* 查看是否设置了一些控制标志，查看某些IP socket选项是否被设置，例如，设置了IP_TOS socket 选项，
         * 把 IP首部中的tos字段拷贝至用户空间等等，这个工作是由 ip_cmsg_recv 函数完成的 */
        if (inet->cmsg_flags)
                ip_cmsg_recv(msg, skb);

        /* 设置拷贝的字节数，如果数据段已经被截短，则返回原始实际的长度 */
        err = copied;
        if (flags & MSG_TRUNC)
                err = skb->len - sizeof(struct udphdr);

out_free:
        skb_free_datagram(sk, skb);
out:
        return err;

csum_copy_err:
        UDP_INC_STATS_BH(UDP_MIB_INERRORS);

        /* Clear queue. */
        if (flags&MSG_PEEK) {
                int clear = 0;
                spin_lock_bh(&sk->sk_receive_queue.lock);
                if (skb == skb_peek(&sk->sk_receive_queue)) {
                        __skb_unlink(skb, &sk->sk_receive_queue);
                        clear = 1;
                }
                spin_unlock_bh(&sk->sk_receive_queue.lock);
                if (clear)
                        kfree_skb(skb);
        }

        skb_free_datagram(sk, skb);

        if (noblock)
                return -EAGAIN;
        goto try_again;
}[/code]

skb 的出队，是通过调用 skb_recv_datagram()函数，出队操作时，队列中可能没有数据，如果是阻塞，
则需要一直睡眠等待，直到超时或队列中有数据而被唤醒。
另外出队操作，还分为两种情况，一种是将数据包从队列中取中来，将其从原有队列中删除，还有一种可能是设置了
MSG_PEEK 标志，它意味着：“查看当前数据，数据将被复制到缓冲区中，但并不从输入队列中删除”。

struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags,
                                  int noblock, int *err)
{
        struct sk_buff *skb;
        long timeo;
        /*
         * Caller is allowed not to check sk->sk_err before skb_recv_datagram()
         */
        int error = sock_error(sk);

        if (error)
                goto no_packet;

        /* 获取超时时间*/
        timeo = sock_rcvtimeo(sk, noblock);

        /* 这个循环将一直等到队列中有数据包，直到超时 */
        do {
                /* Again only user level code calls this function, so nothing
                 * interrupt level will suddenly eat the receive_queue.
                 *
                 * Look at current nfs client by the way...
                 * However, this function was corrent in any case. 8)
                 */
                if (flags & MSG_PEEK) {
                        unsigned long cpu_flags;
                        /* 如果设置了 MSG_PEEK，则设用 skb_peek，这里要对接收队列加锁的原因在于*/
                        spin_lock_irqsave(&sk->sk_receive_queue.lock,
                                          cpu_flags);
                        skb = skb_peek(&sk->sk_receive_queue);
                        if (skb)
                                atomic_inc(&skb->users);
                        spin_unlock_irqrestore(&sk->sk_receive_queue.lock,
                                               cpu_flags);
                } else
                        skb = skb_dequeue(&sk->sk_receive_queue);                /* 直接出队 */

                /* 找到要收获的葫芦了，摘下来 */
                if (skb)
                        return skb;

                /* 如果是非阻塞，就不等了，直接跳出循环，返回 */
                error = -EAGAIN;
                if (!timeo)
                        goto no_packet;

        } while (!wait_for_packet(sk, err, &timeo));

        return NULL;

no_packet:
        *err = error;
        return NULL;
}
继续回到 udp_recvmsg 函数中来，当取出 skb 后，需要将它拷贝至用户空间。用户空间的数据缓存，
用了一个很重要的数据结构 struct msghdr来表示：

[code]struct msghdr {
        void *msg_name;        /* Socket name */
        int msg_namelen;        /* Length of name */
        struct iovec *msg_iov; /* Data blocks */
        __kernel_size_t msg_iovlen; /* Number of blocks */
        void *msg_control;       /* Per protocol magic (eg BSD file descriptor passing) */
        __kernel_size_t msg_controllen; /* Length of cmsg list */
        unsigned msg_flags;
};
结构中的 msg_name、 msg_namelen 以及 msg_flags分别对应于 sys_sendto()[其它接收/发送函数类似]
的参数 addr、addr_len 以及 flags。指针 msg_control 可以指向一个附加的数据结构，用来提供一些
附加的控制信息。后面可以看到 ip_cmsg_recv()使用了它。最重要的是，结构中的指针 msg_iov，
指向一个 iovec 结构数据，而 msg_iovlen 则指明了这个数组的大小：
struct iovec
{
        void __user *iov_base;        /* BSD uses caddr_t (1003.1g requires void *) */
        __kernel_size_t iov_len;       /* Must be size_t (1003.1g) */
};

数组中的每一个元互素，都是 struct iovec 结构，称之为"io 向量"，由指向数据缓冲区的指针 iov_base
和表示缓冲区中数据长度的 iov_len构成。这样，一个 msghdr中的数据，就由控制信息 msg_control
和若干个"io向量"组成。

一个疑问是，为什么不设置为一个缓冲区，而要分为若干个缓冲区呢？一个很重要的原因就是，每
个数据报文的大小一致，对于 ip 包而言。46-1500 都是为可能的，那么如果是一个缓冲区的话，
就得定义为一个“最大值”，但是如果绝大部份的包，都小于这个最大值，例如为 256 或 512，那么
内存空间就浪费得太多了……。所以，一个好的办法是，用一个个小的缓冲区将数据切分，要浪
费，也浪费最后一个缓冲区的空间。——这种设计跟 Unix上著名的 mbuf好像是一致的。

OK，了解了 msghdr 的结构后，再来看数据的拷贝工作，拷贝的核心函数是 memcpy_toiovec：
/*
*        Copy kernel to iovec. Returns -EFAULT on error.
*        Note: this modifies the original iovec.
*/
int memcpy_toiovec(struct iovec *iov, unsigned char *kdata, int len)
{
        while (len > 0) {
                if (iov->iov_len) {
                        int copy = min_t(unsigned int, iov->iov_len, len);
                        if (copy_to_user(iov->iov_base, kdata, copy))
                                return -EFAULT;

                        kdata += copy;
                        len -= copy;
                        iov->iov_len -= copy;
                        iov->iov_base += copy;
                }
                iov++;
        }

        return 0;
}

因为每个 io向量的缓冲区可能很小，例如 100字节，而要拷贝的数据很长，例如 1000 字节。这样，需要在一个循环里，
将数据拷贝至若干个 io 向量数组元素当中去。

回到 udp_recvmsg 中来，它通过设用 skb_copy_datagram_iovec()函数完成数据的拷贝工作。来看看
它是如何调用 memcpy_toiovec 的，当然，类似于这样：
int skb_copy_datagram_iovec(const struct sk_buff *skb, int offset,
                            struct iovec *to, int len)
{
        return memcpy_toiovec(to, skb->data+offset, len);
}

这样的调用，该是多么美好呀，这样的日子曾经是有过，不过已经一去不复返了。

考虑到 skb 结构的复杂性，例如分片，拷贝工作要复杂得多：
/**
*        skb_copy_datagram_iovec - Copy a datagram to an iovec.
*        @skb: buffer to copy
*        @offset: offset in the buffer to start copying from
*        @to: io vector to copy to
*        @len: amount of data to copy from buffer to iovec
*
*        Note: the iovec is modified during the copy.
*/
int skb_copy_datagram_iovec(const struct sk_buff *skb, int offset,
                            struct iovec *to, int len)
{
        int start = skb_headlen(skb); /* start 表示要从 skb 的哪里开始拷贝数据 */
int i, copy = start - offset; /* offset 表示调用者指出的缓存开始拷贝的偏移字节，一般情况下，
                                                   * 它与 start 是重叠的，表示不需要拷贝数据包的首部 */

        /* 需要拷贝首部. */
        if (copy > 0) {
                if (copy > len)
                        copy = len;
                if (memcpy_toiovec(to, skb->data + offset, copy))
                        goto fault;
                if ((len -= copy) == 0)
                        return 0;
                offset += copy;
        }

        /* 遍历每一个分片 */
        for (i = 0; i nr_frags; i++) {
                int end;

                BUG_TRAP(start
                end = start + skb_shinfo(skb)->frags[i].size;
                if ((copy = end - offset) > 0) {
                        int err;
                        u8 *vaddr;
                        skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
                        struct page *page = frag->page;

                        if (copy > len)
                                copy = len;
                        vaddr = kmap(page);
                        err = memcpy_toiovec(to, vaddr + frag->page_offset +
                                             offset - start, copy);
                        kunmap(page);
                        if (err)
                                goto fault;
                        if (!(len -= copy))
                                return 0;
                        offset += copy;
                }
                start = end;
        }

        if (skb_shinfo(skb)->frag_list) {
                struct sk_buff *list = skb_shinfo(skb)->frag_list;
                for (; list; list = list->next) {
                        int end;
                        BUG_TRAP(start                         end = start + list->len;
                        if ((copy = end - offset) > 0) {
                                if (copy > len)
                                        copy = len;
                                if (skb_copy_datagram_iovec(list, offset - start, to, copy))
                                        goto fault;
                                if ((len -= copy) == 0)
                                        return 0;
                                offset += copy;
                        }
                        start = end;
                }
        }
        if (!len)
                return 0;
fault:
        return -EFAULT;
}

现在还没有分析 ip 的分片，所以，要完全理解这个函数的代码有点难度，等到 ip 分片分析完了，再来补充完整它。

socket 层的数据接收
recv(2)、recvfrom(2)和 recvmsg(3)，在 sys_socketcall()中，最终都会归于一个统一的系统调用sock_recvmsg。
例如：
asmlinkage long sys_recv(int fd, void __user * ubuf, size_t size, unsigned flags)
{
        return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);
}
sys_recv 转向了 sys_recvfrom()：
/*
*        Receive a frame from the socket and optionally record the address of the
*        sender. We verify the buffers are writable and if needed move the *        sender address from kernel to user space.
*/

asmlinkage long sys_recvfrom(int fd, void __user * ubuf, size_t size, unsigned flags,
                             struct sockaddr __user *addr, int __user *addr_len)
{
        struct socket *sock;
        struct iovec iov;
        struct msghdr msg;
        char address[MAX_SOCK_ADDR];
        int err,err2;

        sock = sockfd_lookup(fd, &err);
        if (!sock)
                goto out;

        msg.msg_control=NULL;
        msg.msg_controllen=0;
        msg.msg_iovlen=1;
        msg.msg_iov=&iov;
        iov.iov_len=size;
        iov.iov_base=ubuf;
        msg.msg_name=address;
        msg.msg_namelen=MAX_SOCK_ADDR;
        if (sock->file->f_flags & O_NONBLOCK)
                flags |= MSG_DONTWAIT;
        err=sock_recvmsg(sock, &msg, size, flags);

        if(err >= 0 && addr != NULL)
        {
                err2=move_addr_to_user(address, msg.msg_namelen, addr, addr_len);
                if(err2                        err=err2;
        }
        sockfd_put(sock);
out:
        return err;
}

函数先调用 sockfd_lookup，根据 socket 描述符查找以相应的 sock 结构，然后封装了一个 msghdr结
构后，接着调用 sock_recvmsg（）。
int sock_recvmsg(struct socket *sock, struct msghdr *msg,
                 size_t size, int flags)
{         struct kiocb iocb;
        struct sock_iocb siocb;
        int ret;

        init_sync_kiocb(&iocb, NULL);
        iocb.private = &siocb;
        ret = __sock_recvmsg(&iocb, sock, msg, size, flags);
        if (-EIOCBQUEUED == ret)
                ret = wait_on_sync_kiocb(&iocb);
        return ret;
}

iocb 和 siocb 用于内核和 socket 的 io 控制，函数中主要初始化了 iocb，siocb 的初始化，在
__sock_recvmsg 中完成。进一步的按收动作，是通过__sock_recvmsg 函数设用完成的：
[code]static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,
                                 struct msghdr *msg, size_t size, int flags)
{
        int err;
        struct sock_iocb *si = kiocb_to_siocb(iocb);

        si->sock = sock;
        si->scm = NULL;
        si->msg = msg;
        si->size = size;
        si->flags = flags;

        err = security_socket_recvmsg(sock, msg, size, flags);
        if (err)
                return err;

        return sock->ops->recvmsg(iocb, sock, msg, size, flags);
}

初始化完 siocb，也就是 si 后，调用协议簇的 recvmsg 函数，对于 UDP 而言，是
sock_common_recvmsg()：
int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
                        struct msghdr *msg, size_t size, int flags)
{
        struct sock *sk = sock->sk;    /*取得 sock 结构对应的 sk指针*/
        int addr_len = 0;
        int err;

        err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
                                                       flags & ~MSG_DONTWAIT, &addr_len);
        if (err >= 0)
                msg->msg_namelen = addr_len;
        return err;
}

于是，udp_recvmsg 就被调用了。整个过程也就结束了。

最后再回到 sys_recvfrom中来，如果用户调用时，需要返回对方的地址信息：
        if(err >= 0 && addr != NULL)
        {
                err2=move_addr_to_user(address, msg.msg_namelen, addr, addr_len);
                if(err2                        err=err2;
        }
就需要调用 move_addr_to_user() 函数来完成，前面分析 msghdr 结构时已经提到其 msg_name 成员
变量，它包含了地址的相应信息，msg.msg_namelen 成员变量，决定了地址的长度信息：
int move_addr_to_user(void *kaddr, int klen, void __user *uaddr, int __user *ulen)
{
        int err;
        int len;

        if((err=get_user(len, ulen)))     //缓存长度校验
                return err;
        if(len>klen)
                len=klen;
        if(len MAX_SOCK_ADDR)
                return -EINVAL;
        if(len)
        {
                if(copy_to_user(uaddr,kaddr,len))   //拷贝地址信息
                        return -EFAULT;
        }
        /*
         *        "fromlen shall refer to the value before truncation.."
         *                        1003.1g
         */
        return __put_user(klen, ulen);
}

Linux TCP/IP 协议栈之 Socket的实现分析(数据包的接收)

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像