Chinaunix首页 | 论坛 | 博客

随风去的ChinaUnix博客

首页　| 　博文目录　| 　关于我

随风去

  • 博客访问： 85714
  • 博文数量： 15
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 210
  • 用 户 组： 普通用户
  • 注册时间： 2014-01-05 15:27
文章分类

全部博文（15）

文章存档

2014年（15）

我的朋友
最近访客
推荐博文
相关博文
udp的收包流程

分类： LINUX

2014-03-30 10:25:17

简单的一个udp的服务程序主要有如下几步：
1：调用socket函数创建socket
2：调用bind函数指定在什么地址监听什么端口
3：调用recvfrom以及sendto进行首发包
看一个简单的示例代码：
  1. #include <sys/types.h>
  2. #include <sys/socket.h>
  3. #include <string.h>
  4. #include <netinet/in.h>
  5. #include <stdio.h>
  6. #include <stdlib.h>

  8. #define MAXLINE 80
  9. #define SERV_PORT 8888

  11. void do_echo(int sockfd, struct sockaddr *pcliaddr, socklen_t clilen)
  12. {
  13.     int n;
  14.     socklen_t len;
  15.     char mesg[MAXLINE];

  17.     for(;;)
  18.     {
  19.         len = clilen;
  20.         memset(mesg,0,MAXLINE);
  21.         /* waiting for receive data */
  22.         n = recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len);
  23.         /* sent data back to client */
  24.         sendto(sockfd, mesg, n, 0, pcliaddr, len);
  25.     }
  26. }

  28. int main(void)
  29. {
  30.     int sockfd;
  31.     struct sockaddr_in servaddr, cliaddr;

  33.     sockfd = socket(AF_INET, SOCK_DGRAM, 0); /* create a socket */

  35.     /* init servaddr */
  36.     bzero(&servaddr, sizeof(servaddr));
  37.     servaddr.sin_family = AF_INET;
  38.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  39.     servaddr.sin_port = htons(SERV_PORT);

  41.     /* bind address and port to socket */
  42.     if(bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1)
  43.     {
  44.         perror("bind error");
  45.         exit(1);
  46.     }

  48.     do_echo(sockfd, (struct sockaddr *)&cliaddr, sizeof(cliaddr));

  50.     return 0;
  51. }
先看recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len);
其中sockfd为socket系统调用创建的fd，mesg为接收使用的缓冲区，pcliaddr是客户端的地址，如果只是接收的话这个参数可以不设置，但是后面要回应的话，就需要在接收的时候保存客户端的地址。
先看一下系统调用的入口：

  1. SYSCALL_DEFINE6(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.     struct sockaddr_storage address;
  9.     int err, err2;
  10.     int fput_needed;

  12.     if (size > INT_MAX)
  13.         size = INT_MAX;
  14.     sock = sockfd_lookup_light(fd, &err, &fput_needed);  //根据fd找到对应的socket数据结构
  15.     if (!sock)
  16.         goto out;

  18.     msg.msg_control = NULL;  //根据传入参数赋值msghdr数据结构，接收缓冲区的地址和大小赋给msg_iov分量
  19.     msg.msg_controllen = 0;
  20.     msg.msg_iovlen = 1;
  21.     msg.msg_iov = &iov;
  22.     iov.iov_len = size;
  23.     iov.iov_base = ubuf;
  24.     msg.msg_name = (struct sockaddr *)&address; //定义局部变量address，用于保存客户端的地址
  25.     msg.msg_namelen = sizeof(address);
  26.     if (sock->file->f_flags & O_NONBLOCK)
  27.         flags |= MSG_DONTWAIT;
  28.     err = sock_recvmsg(sock, &msg, size, flags);//接收数据，sock->ops->recvmsg(iocb, sock, msg, size, flags);

  30.     if (err >= 0 && addr != NULL) {
  31.         err2 = move_addr_to_user((struct sockaddr *)&address, //把客户端的地址赋值给传入的参数
  32.                      msg.msg_namelen, addr, addr_len);
  33.         if (err2 < 0)
  34.             err = err2;
  35.     }

  37.     fput_light(sock->file, fput_needed);
  38. out:
  39.     return err;
  40. }
sock->ops->recvmsg会调用inet_recvmsg：

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

  8.     sock_rps_record_flow(sk);

  10.     err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,   //udp_recvmsg
  11.                    flags & ~MSG_DONTWAIT, &addr_len);
  12.     if (err >= 0)
  13.         msg->msg_namelen = addr_len;
  14.     return err;
  15. }
udp_recvmsg逻辑比较简单，没有数据就睡眠（没有制定nonblock），有数据就拷贝数据到缓冲区

  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;
  6.     struct sk_buff *skb;
  7.     unsigned int ulen;
  8.     int peeked;
  9.     int err;
  10.     int is_udplite = IS_UDPLITE(sk);
  11.     bool slow;

  13.     /*
  14.      * Check any passed addresses
  15.      */
  16.     if (addr_len)
  17.         *addr_len = sizeof(*sin);

  19.     if (flags & MSG_ERRQUEUE)
  20.         return ip_recv_error(sk, msg, len);

  22. try_again:
  23.     skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),  //从sk_receive_queue队列中取skb，没有的话睡眠
  24.                   &peeked, &err);
  25.     if (!skb)
  26.         goto out;

  28.     ulen = skb->len - sizeof(struct udphdr);
  29.     if (len > ulen)   //可以看到一次接收调用只会取一个skb
  30.         len = ulen;
  31.     else if (len < ulen)
  32.         msg->msg_flags |= MSG_TRUNC;   //比较skb中数据和接收buffer的大小

  34.     /*
  35.      * If checksum is needed at all, try to do it while copying the
  36.      * data. If the data is truncated, or if we only want a partial
  37.      * coverage checksum (UDP-Lite), do it before the copy.
  38.      */

  40.     if (len < ulen || UDP_SKB_CB(skb)->partial_cov) {  //如果只是拷贝skb的一部分数据的话，需要提前校验全部的数据，因为没法边拷贝边校验
  41.         if (udp_lib_checksum_complete(skb))            //如果硬件已经校验过的话，就不用了
  42.             goto csum_copy_err;
  43.     }

  45.     if (skb_csum_unnecessary(skb))
  46.         err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),//把skb的数据拷贝到接收buffer中，包含线性区，frags以及frag_list
  47.                           msg->msg_iov, len);
  48.     else {
  49.         err = skb_copy_and_csum_datagram_iovec(skb,
  50.                                sizeof(struct udphdr),
  51.                                msg->msg_iov);

  53.         if (err == -EINVAL)
  54.             goto csum_copy_err;
  55.     }

  57.     if (err)
  58.         goto out_free;

  60.     if (!peeked)
  61.         UDP_INC_STATS_USER(sock_net(sk),
  62.                 UDP_MIB_INDATAGRAMS, is_udplite);

  64.     sock_recv_ts_and_drops(msg, sk, skb);

  66.     /* Copy the address. */
  67.     if (sin) {
  68.         sin->sin_family = AF_INET;
  69.         sin->sin_port = udp_hdr(skb)->source;  //客户端的端口号
  70.         sin->sin_addr.s_addr = ip_hdr(skb)->saddr;//客户端的ip地址，后续回应的时候，sendto系统调用使用
  71.         memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  72.     }
  73.     if (inet->cmsg_flags)
  74.         ip_cmsg_recv(msg, skb);

  76.     err = len;
  77.     if (flags & MSG_TRUNC)
  78.         err = ulen;

  80. out_free:
  81.     skb_free_datagram_locked(sk, skb);
  82. out:
  83.     return err;

  85. csum_copy_err:
  86.     slow = lock_sock_fast(sk);
  87.     if (!skb_kill_datagram(sk, skb, flags))
  88.         UDP_INC_STATS_USER(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
  89.     unlock_sock_fast(sk, slow);
  90.     if (noblock)
  91.         return -EAGAIN;

  93.     /* starting over for a new packet */
  94.     msg->msg_flags &= ~MSG_TRUNC;
  95.     goto try_again;
  96. }
该函数逻辑比较简单，其中取skb调用__skb_recv_datagram函数：

  1. struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,
  2.                     int *peeked, 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, flags & MSG_DONTWAIT); //noblock ? 0 : sk->sk_rcvtimeo;初始化的时候sk_rcvtimeo设置为死等

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

  25.         spin_lock_irqsave(&sk->sk_receive_queue.lock, cpu_flags);
  26.         skb = skb_peek(&sk->sk_receive_queue);
  27.         if (skb) {
  28.             *peeked = skb->peeked;
  29.             if (flags & MSG_PEEK) {
  30.                 skb->peeked = 1;
  31.                 atomic_inc(&skb->users);
  32.             } else
  33.                 __skb_unlink(skb, &sk->sk_receive_queue);
  34.         }
  35.         spin_unlock_irqrestore(&sk->sk_receive_queue.lock, cpu_flags);

  37.         if (skb)  //有数据就返回，没有数据就等待
  38.             return skb;

  40.         error = -EAGAIN;
  41.         if (!timeo)
  42.             goto no_packet;
  43.      } while (!wait_for_packet(sk, err, &timeo));  //把自己放到sk_sleep对应的等待链表中，然后调用schedule_timeout
  44.      return NULL;
  45. no_packet:
  46.     *err = error;
  47.     return NULL;
  48. }
udp的接收系统调用比较简单，不涉及各种状态的转换，有数据的时候就拷贝，没有的话等待，当底层收到包的时候，会唤醒当前进程

下面分析bind流程：bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)
该系统调用会调inet_bind：
  1. int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
  2. {
  3.     struct sockaddr_in *addr = (struct sockaddr_in *)uaddr;
  4.     struct sock *sk = sock->sk;
  5.     struct inet_sock *inet = inet_sk(sk);
  6.     unsigned short snum;
  7.     int chk_addr_ret;
  8.     int err;

  10.     /* If the socket has its own bind function then use it. (RAW) */
  11.     if (sk->sk_prot->bind) {  //udp没有自己的bind函数
  12.         err = sk->sk_prot->bind(sk, uaddr, addr_len);
  13.         goto out;
  14.     }
  15.     err = -EINVAL;
  16.     if (addr_len < sizeof(struct sockaddr_in))
  17.         goto out;

  19.     if (addr->sin_family != AF_INET) {
  20.         /* Compatibility games : accept AF_UNSPEC (mapped to AF_INET)
  21.          * only if s_addr is INADDR_ANY.
  22.          */
  23.         err = -EAFNOSUPPORT;
  24.         if (addr->sin_family != AF_UNSPEC ||
  25.             addr->sin_addr.s_addr != htonl(INADDR_ANY))
  26.             goto out;
  27.     }

  29.     chk_addr_ret = inet_addr_type(sock_net(sk), addr->sin_addr.s_addr);

  31.     /* Not specified by any standard per-se, however it breaks too
  32.      * many applications when removed. It is unfortunate since
  33.      * allowing applications to make a non-local bind solves
  34.      * several problems with systems using dynamic addressing.
  35.      * (ie. your servers still start up even if your ISDN link
  36.      * is temporarily down)
  37.      */
  38.     err = -EADDRNOTAVAIL;
  39.     if (!sysctl_ip_nonlocal_bind &&   //bind绑定的地址一般为INADDR_ANY或者一个本地的ip值
  40.         !(inet->freebind || inet->transparent) &&
  41.         addr->sin_addr.s_addr != htonl(INADDR_ANY) &&
  42.         chk_addr_ret != RTN_LOCAL &&
  43.         chk_addr_ret != RTN_MULTICAST &&
  44.         chk_addr_ret != RTN_BROADCAST)
  45.         goto out;

  47.     snum = ntohs(addr->sin_port); //bind对应的端口号
  48.     err = -EACCES;
  49.     if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))  //0-1023只有root用户可以设置
  50.         goto out;

  52.     /* We keep a pair of addresses. rcv_saddr is the one
  53.      * used by hash lookups, and saddr is used for transmit.
  54.      *
  55.      * In the BSD API these are the same except where it
  56.      * would be illegal to use them (multicast/broadcast) in
  57.      * which case the sending device address is used.
  58.      */
  59.     lock_sock(sk);

  61.     /* Check these errors (active socket, double bind). */
  62.     err = -EINVAL;
  63.     if (sk->sk_state != TCP_CLOSE || inet->inet_num)
  64.         goto out_release_sock;

  66.     inet->inet_rcv_saddr = inet->inet_saddr = addr->sin_addr.s_addr;//inet_rcv_saddr用于hash查找，参考__udp4_lib_lookup_skb
  67.     if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
  68.         inet->inet_saddr = 0; /* Use device */

  70.     /* Make sure we are allowed to bind here. */
  71.     if (sk->sk_prot->get_port(sk, snum)) {    //udp_v4_get_port
  72.         inet->inet_saddr = inet->inet_rcv_saddr = 0;
  73.         err = -EADDRINUSE;
  74.         goto out_release_sock;
  75.     }

  77.     if (inet->inet_rcv_saddr)
  78.         sk->sk_userlocks |= SOCK_BINDADDR_LOCK;
  79.     if (snum)
  80.         sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
  81.     inet->inet_sport = htons(inet->inet_num);  //用于hash查找
  82.     inet->inet_daddr = 0;
  83.     inet->inet_dport = 0;
  84.     sk_dst_reset(sk);
  85.     err = 0;
  86. out_release_sock:
  87.     release_sock(sk);
  88. out:
  89.     return err;
  90. }

















阅读(2634) | 评论(0) | 转发(0) |
0

上一篇：GRO 接收流程

下一篇：ip_fragment以及ip_defrag流程

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6