# Receive data from socket

    

    asmlinkage long sys_recvfrom(int fd, void __user * ubuf, size_t size, unsigned flags,

                                 struct sockaddr __user *addr, int __user *addr_len)

    {

    …

            sock_file = fget_light(fd, &fput_needed);

            if (!sock_file)

                    return -EBADF;

    ...

            sock = sock_from_file(sock_file, &err);

            if (!sock)

                    goto out;

    …

            err=sock_recvmsg(sock, &msg, size, flags);

    …

    

    

The syscall first look for a socket from file descriptor and call relevent function using the socket data structure



    int sock_recvmsg(struct socket *sock, struct msghdr *msg,

                     size_t size, int flags)

    {

    ...

            ret = __sock_recvmsg(&iocb, sock, msg, size, flags);

    ...

    }

    

    

    static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,

                                     struct msghdr *msg, size_t size, int flags)

    {

    ...

           err = sock->ops->recvmsg(iocb, sock, msg, size, flags); 

    …

    

    

ops is protocol operation struct holding pointers to functions operating on socket file descriptor. 

When creating socket this field is filled depending mostly on domain/family and type

    

    int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,

                            struct msghdr *msg, size_t size, int flags)

    {

            struct sock *sk = sock->sk;

            int addr_len = 0;

            int err;

           /* this will delegate its work to internal sock*/

            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;

    }

    

    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);

            struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;

            struct sk_buff *skb;

            int copied, err;

            int peeked;

    

    

            /*

             *      Check any passed addresses

             */

            if (addr_len)

                    *addr_len=sizeof(*sin);

    

    

            if (flags & MSG_ERRQUEUE)

                    return ip_recv_error(sk, msg, len);

    

    

    try_again:

            skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),

                                      &peeked, &err);

    ...

    

    

    struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,

                                      int *peeked, int *err)

    {

    ...

    

    

            timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);

    …

          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)

                     */

    

    

                    unsigned long cpu_flags;

    

    

                    if (flags & MSG_PEEK) {

                            spin_lock_irqsave(&sk->sk_receive_queue.lock,

                                              cpu_flags);

                            skb = skb_peek(&sk->sk_receive_queue);

                            if (skb) {

                                    *peeked = skb->peeked;

                                    skb->peeked = 1;

                                    atomic_inc(&skb->users);

                            }

                            spin_unlock_irqrestore(&sk->sk_receive_queue.lock,

                                                   cpu_flags);

                    } else {

                            skb = skb_dequeue(&sk->sk_receive_queue);

                            if (skb)

                                    *peeked = skb->peeked;

                    }

                    if (skb)

                            return skb;

    

    

                    /* User doesn't want to wait */

                    error = -EAGAIN;

                    if (!timeo)

                            goto no_packet;

    

    

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

    …

    

    

    static int wait_for_packet(struct sock *sk, int *err, long *timeo_p)

    {

            int error;

            DEFINE_WAIT(wait);

    

    

            prepare_to_wait_exclusive(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);

    ...

           *timeo_p = schedule_timeout(*timeo_p);

    





References



1. http://www.ibm.com/developerworks/linux/library/l-hisock/index.html

2. http://www.haifux.org/lectures/217/netLec5.pdf