recvfrom函数

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

内核版本2.6.21.5

1. recvfrom 函数原型
    int recvfrom(int socket,  void *buffer,  size tsize,  int flags,  struct sockaddr *addr,  socklen t *length-ptr)
    这个void *buffer是进程用户空间地址，可以是栈上的地址，也可以是你用malloc创建的堆地址。struct sockaddr *addr,  socklen t *length-ptr 分别用来存储对端的地址信息和长度，注意这个长度用的是指针表示，别弄错了。

2. 看看这个函数的源代码

  

点击(此处)折叠或打开

  1. asmlinkage long sys_recvfrom(int fd, void __user *ubuf, size_t size,
  2.              unsigned flags, struct sockaddr __user *addr,
  3.              int __user *addr_len)
  4. {
  5.     struct socket *sock;
  6.     struct iovec iov; //缓冲区向量
  7.     struct msghdr msg;
  8.     char address[MAX_SOCK_ADDR]; //保存对端地址信息
  9.     int err, err2;
  10.     struct file *sock_file;
  11.     int fput_needed;

  13.     sock_file = fget_light(fd, &fput_needed);
  14.     err = -EBADF;
  15.     if (!sock_file)
  16.         goto out;

  18.     sock = sock_from_file(sock_file, &err);
  19.     if (!sock)
  20.         goto out_put;

  22.     msg.msg_control = NULL;
  23.     msg.msg_controllen = 0;
  24.     msg.msg_iovlen = 1;
  25.     msg.msg_iov = &iov;
  26.     iov.iov_len = size;
  27.     iov.iov_base = ubuf;
  28.     msg.msg_name = address;
  29.     msg.msg_namelen = MAX_SOCK_ADDR;
  30.     if (sock->file->f_flags & O_NONBLOCK) //看是否设置了非阻塞熟悉，默认是阻塞的，也就是如果没有数据包到来，进程会阻塞在这个系统调用里。
  31.         flags |= MSG_DONTWAIT;
  32.     err = sock_recvmsg(sock, &msg, size, flags);

  34.     if (err >= 0 && addr != NULL) {
  35.         err2 = move_addr_to_user(address, msg.msg_namelen, addr, addr_len);  //得到对端地址信息，返回给api
  36.         if (err2 < 0)
  37.             err = err2;
  38.     }
  39. out_put:
  40.     fput_light(sock_file, fput_needed);
  41. out:
  42.     return err;
  43. }
上面代码是与之对应的系统调用服务函数，直接看sock_recvmsg吧：


点击(此处)折叠或打开

  1. int sock_recvmsg(struct socket *sock, struct msghdr *msg,
  2.          size_t size, int flags)
  3. {
  4.     struct kiocb iocb;
  5.     struct sock_iocb siocb;
  6.     int ret;

  8.     init_sync_kiocb(&iocb, NULL);
  9.     iocb.private = &siocb;
  10.     ret = __sock_recvmsg(&iocb, sock, msg, size, flags);
  11.     if (-EIOCBQUEUED == ret)
  12.         ret = wait_on_sync_kiocb(&iocb);
  13.     return ret;
  14. }


点击(此处)折叠或打开

  1. static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,
  2.                  struct msghdr *msg, size_t size, int flags)
  3. {
  4.     int err;
  5.     struct sock_iocb *si = kiocb_to_siocb(iocb);

  7.     si->sock = sock;
  8.     si->scm = NULL;
  9.     si->msg = msg;
  10.     si->size = size;
  11.     si->flags = flags;

  13.     err = security_socket_recvmsg(sock, msg, size, flags);
  14.     if (err)
  15.         return err;

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

还是直接看

点击(此处)折叠或打开

  1. int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
  2.             struct msghdr *msg, size_t size, int flags)
  3. {
  4.     struct sock *sk = sock->sk;
  5.     int addr_len = 0;
  6.     int err;

  8.     err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
  9.                  flags & ~MSG_DONTWAIT, &addr_len);
  10.     if (err >= 0)
  11.         msg->msg_namelen = addr_len;
  12.     return err;
  13. }


点击(此处)折叠或打开

  1. int udp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
  2.         size_t len, int noblock, int flags, int *addr_len)
  3. {
  4.     struct inet_sock *inet = inet_sk(sk);
  5.     struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name; //store peer address
  6.     struct sk_buff *skb;
  7.     int copied, err, copy_only, is_udplite = IS_UDPLITE(sk);

  9.     /*
  10.      *    Check any passed addresses
  11.      */
  12.     if (addr_len)
  13.         *addr_len=sizeof(*sin);

  15.     if (flags & MSG_ERRQUEUE) /* Fetch message from error queue. */
  16.         return ip_recv_error(sk, msg, len);

  18. try_again:
  19.     skb = skb_recv_datagram(sk, flags, noblock, &err); //这个函数取得了skb
  20.     if (!skb)
  21.         goto out;

  23.     copied = skb->len - sizeof(struct udphdr); //如果收到的data大于用户想要的长度，截断处理
  24.     if (copied > len) {
  25.         copied = len;
  26.         msg->msg_flags |= MSG_TRUNC; //例如，用户想要100个字节，skb中确有1000字节，那么只从skb拷贝出前100个字节，并设置标志MSG_TRUNC
  27.     }

  29.     /*
  30.      *     Decide whether to checksum and/or copy data.
  31.      *
  32.      *     UDP: checksum may have been computed in HW,
  33.      *      (re-)compute it if message is truncated.
  34.      *     UDP-Lite: always needs to checksum, no HW support.
  35.      */
  36.     copy_only = (skb->ip_summed==CHECKSUM_UNNECESSARY);

  38.     if (is_udplite || (!copy_only && msg->msg_flags&MSG_TRUNC)) {
  39.         if (__udp_lib_checksum_complete(skb))
  40.             goto csum_copy_err;
  41.         copy_only = 1;
  42.     }

  44.     if (copy_only)
  45.         err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr), //在这里完成了data的拷贝
  46.                      msg->msg_iov, copied );
  47.     else {
  48.         err = skb_copy_and_csum_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov);

  50.         if (err == -EINVAL)
  51.             goto csum_copy_err;
  52.     }

  54.     if (err)
  55.         goto out_free;

  57.     sock_recv_timestamp(msg, sk, skb); //打上时间戳

  59.     /* Copy the address. */
  60.     if (sin)
  61.     {
  62.         sin->sin_family = AF_INET;
  63.         sin->sin_port = skb->h.uh->source;
  64.         sin->sin_addr.s_addr = skb->nh.iph->saddr; //在这里取得对端的IP地址和端口号
  65.         memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  66.     }
  67.     if (inet->cmsg_flags)
  68.         ip_cmsg_recv(msg, skb);

  70.     err = copied;
  71.     if (flags & MSG_TRUNC)
  72.         err = skb->len - sizeof(struct udphdr);

  74. out_free:
  75.     skb_free_datagram(sk, skb);
  76. out:
  77.     return err;   //err返回的是拷贝的字节数

  79. csum_copy_err:
  80.     UDP_INC_STATS_BH(UDP_MIB_INERRORS, is_udplite);

  82.     skb_kill_datagram(sk, skb, flags);

  84.     if (noblock)
  85.         return -EAGAIN;
  86.     goto try_again;
  87. }

3. 从上面的代码中我们看到有2个重要的函数：skb_recv_datagram和skb_copy_datagram_iovec，一个是取得skb, 一个是从skb中拷贝数据


点击(此处)折叠或打开

  1. struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags,
  2.                  int noblock, int *err)
  3. {
  4.     struct sk_buff *skb;
  5.     long timeo;
  6.     /*
  7.      * Caller is allowed not to check sk->sk_err before skb_recv_datagram()
  8.      */
  9.     int error = sock_error(sk);

  11.     if (error)
  12.         goto no_packet;

  14.     timeo = sock_rcvtimeo(sk, noblock); //如果设置为非阻塞模式timeo为0，否则是你用setsockopt设置的时间，没设置
  15.                                         //的话默认是一直阻塞，在创建socket的时候sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;

  17.     do {
  18.         /* Again only user level code calls this function, so nothing
  19.          * interrupt level will suddenly eat the receive_queue.
  20.          *
  21.          * Look at current nfs client by the way...
  22.          * However, this function was corrent in any case. 8)
  23.          */
  24.         if (flags & MSG_PEEK) {
  25.             unsigned long cpu_flags;

  27.             spin_lock_irqsave(&sk->sk_receive_queue.lock,
  28.                      cpu_flags);
  29.             skb = skb_peek(&sk->sk_receive_queue);
  30.             if (skb)
  31.                 atomic_inc(&skb->users);
  32.             spin_unlock_irqrestore(&sk->sk_receive_queue.lock,
  33.                      cpu_flags);
  34.         } else
  35.             skb = skb_dequeue(&sk->sk_receive_queue); //一目了然，从接受队列中取得skb,在这里还记得我们把skb挂入到sk_receive_queue队列？

  37.         if (skb)
  38.             return skb; //不管是阻塞还是非阻塞，有skb直接返回, ideal

  40.         /* User doesn't want to wait */
  41.         error = -EAGAIN;
  42.         if (!timeo) //non_block直接返回或指定的时间减少到0了，不等了
  43.             goto no_packet;

  45.     } while (!wait_for_packet(sk, err, &timeo)); //只有在这里等了,等待一个指定时间，或痴情的一直等下去...

  47.     return NULL;

  49. no_packet:
  50.     *err = error;
  51.     return NULL;
  52. }

点击(此处)折叠或打开

  1. /*
  2.  * Wait for a packet..
  3.  */
  4. static int wait_for_packet(struct sock *sk, int *err, long *timeo_p)
  5. {
  6.     int error;
  7.     DEFINE_WAIT(wait);

  9.     prepare_to_wait_exclusive(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); //把当前进程挂入socket等待队列中sk->sk_sleep

  11.     /* Socket errors? */
  12.     error = sock_error(sk);
  13.     if (error)
  14.         goto out_err;

  16.     if (!skb_queue_empty(&sk->sk_receive_queue)) //看是否有skb，有的话直接error = 0 return 去接收skb
  17.         goto out;

  19.     /* Socket shut down? */
  20.     if (sk->sk_shutdown & RCV_SHUTDOWN) //看在等待的时候,socket是否被shut down了。如shut down 了error = 1; 不接收skb了
  21.         goto out_noerr;

  23.     /* Sequenced packets can come disconnected.
  24.      * If so we report the problem
  25.      */
  26.     error = -ENOTCONN;
  27.     if (connection_based(sk) && //看这里是对tcp的处理，先不管
  28.      !(sk->sk_state == TCP_ESTABLISHED || sk->sk_state == TCP_LISTEN))
  29.         goto out_err;

  31.     /* handle signals */
  32.     if (signal_pending(current)) //当等待的时候来了中断...
  33.         goto interrupted;

  35.     error = 0;
  36.     *timeo_p = schedule_timeout(*timeo_p); //如果指定了时间，减少时间
  37. out:
  38.     finish_wait(sk->sk_sleep, &wait);
  39.     return error;
  40. interrupted:
  41.     error = sock_intr_errno(*timeo_p); //返回ERESTARTSYS或EINTR给应用层处理，我们在应用层要对这个中断信号进程处理，一般的话就是继续这个系统调用：
  42.                                        //if(errno == EINTR) continue;
  43. out_err:
  44.     *err = error;
  45.     goto out;
  46. out_noerr:
  47.     *err = 0;
  48.     error = 1;
  49.     goto out;
  50. }
上面2个代码段是取得skb的过程，从中我们看到涉及到我们在应用层设置非阻塞，此系统调用返回时间，对中断信号的处理等问题，下面我们看看数据拷贝过程吧：

点击(此处)折叠或打开

  1. int skb_copy_datagram_iovec(const struct sk_buff *skb, int offset,
  2.              struct iovec *to, int len)
  3. {
  4.     int start = skb_headlen(skb); //这个是数据包总长度减去分片中数据包的长度
  5.     int i, copy = start - offset;

  7.     /* Copy header. */
  8.     if (copy > 0) {     //如果没有分片的话，在这里就一次拷贝完了，如果有分片的话，就拷贝第一个分片
  9.         if (copy > len)
  10.             copy = len;
  11.         if (memcpy_toiovec(to, skb->data + offset, copy))
  12.             goto fault;
  13.         if ((len -= copy) == 0)
  14.             return 0;
  15.         offset += copy;
  16.     }

  18.     /* Copy paged appendix. Hmm... why does this look so complicated? */ //在这里拷贝其他分片中的数据包，关于分片以后再说吧...
  19.     for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
  20.         int end;

  22.         BUG_TRAP(start <= offset + len);

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

  31.             if (copy > len)
  32.                 copy = len;
  33.             vaddr = kmap(page);
  34.             err = memcpy_toiovec(to, vaddr + frag->page_offset +
  35.                      offset - start, copy);
  36.             kunmap(page);
  37.             if (err)
  38.                 goto fault;
  39.             if (!(len -= copy))
  40.                 return 0;
  41.             offset += copy;
  42.         }
  43.         start = end;
  44.     }

  46.     if (skb_shinfo(skb)->frag_list) {
  47.         struct sk_buff *list = skb_shinfo(skb)->frag_list;

  49.         for (; list; list = list->next) {
  50.             int end;

  52.             BUG_TRAP(start <= offset + len);

  54.             end = start + list->len;
  55.             if ((copy = end - offset) > 0) {
  56.                 if (copy > len)
  57.                     copy = len;
  58.                 if (skb_copy_datagram_iovec(list,
  59.                              offset - start,
  60.                              to, copy))
  61.                     goto fault;
  62.                 if ((len -= copy) == 0)
  63.                     return 0;
  64.                 offset += copy;
  65.             }
  66.             start = end;
  67.         }
  68.     }
  69.     if (!len)
  70.         return 0;

  72. fault:
  73.     return -EFAULT;
  74. }



over ...

上一篇：bind函数
下一篇：setsockopt函数