网络函数accept源码分析

static int sock_accept(int fd, struct sockaddr *upeer_sockaddr, int *upeer_addrlen)
{
    struct file *file;
    struct socket *sock, *newsock;
    int i;
    char address[MAX_SOCK_ADDR];
    int len;
    if (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
        return(-EBADF);
    // 根据文件描述符找到对应的file结构体和socket结构
      if (!(sock = sockfd_lookup(fd, &file))) 
        return(-ENOTSOCK);
    if (sock->state != SS_UNCONNECTED) 
    {
        return(-EINVAL);
    }
    // socket没有调用过listen，报错，该标记位在listen中设置
    if (!(sock->flags & SO_ACCEPTCON)) 
    {
        return(-EINVAL);
    }
    // 分配一个新的socket结构体
    if (!(newsock = sock_alloc())) 
    {
        printk("NET: sock_accept: no more sockets\n");
        return(-ENOSR);    /* Was: EAGAIN, but we are out of system
                   resources! */
    }
    newsock->type = sock->type;
    newsock->ops = sock->ops;
    // 创建一个底层的sock结构体和socket结构体互相关联
    if ((i = sock->ops->dup(newsock, sock)) < 0) 
    {
        sock_release(newsock);
        return(i);
    }
    i = newsock->ops->accept(sock, newsock, file->f_flags);
    if ( i < 0) 
    {
        sock_release(newsock);
        return(i);
    }
    // 返回一个新的文件描述符
    if ((fd = get_fd(SOCK_INODE(newsock))) < 0) 
    {
        sock_release(newsock);
        return(-EINVAL);
    }
    // 是否需要获取socket对应的地址
    if (upeer_sockaddr)
    {
        newsock->ops->getname(newsock, (struct sockaddr *)address, &len, 1);
        move_addr_to_user(address,len, upeer_sockaddr, upeer_addrlen);
    }
    return(fd);
}

static int inet_accept(struct socket *sock, struct socket *newsock, int flags)
{
    struct sock *sk1, *sk2;
    int err;
    sk1 = (struct sock *) sock->data;
    /*
     * We've been passed an extra socket.
     * We need to free it up because the tcp module creates
     * its own when it accepts one.
     */
    // 销毁新socket结构体中的socke结构体,d调用底层的accept会返回一个新的sock
    if (newsock->data)
    {
          struct sock *sk=(struct sock *)newsock->data;
          newsock->data=NULL;
          sk->dead = 1;
          destroy_sock(sk);
    }
    if (sk1->prot->accept == NULL) 
        return(-EOPNOTSUPP);
    /* Restore the state if we have been interrupted, and then returned. */
    if (sk1->pair != NULL ) 
    {
        sk2 = sk1->pair;
        sk1->pair = NULL;
    } 
    else
    {    // 返回一个新的sock结构体
        sk2 = sk1->prot->accept(sk1,flags);
        if (sk2 == NULL) 
        {
            if (sk1->err <= 0)
                printk("Warning sock.c:sk1->err <= 0.  Returning non-error.\n");
            err=sk1->err;
            sk1->err=0;
            return(-err);
        }
    }
    // 互相关联
    newsock->data = (void *)sk2;
    // 复制socket结构的wait字段，用于控制进程的阻塞和唤醒
    sk2->sleep = newsock->wait;
    sk2->socket = newsock;
    newsock->conn = NULL;
    if (flags & O_NONBLOCK) 
        return(0);
    cli(); /* avoid the race. */
    // sock是接收syn状态则阻塞当前进程
    while(sk2->state == TCP_SYN_RECV) 
    {
        interruptible_sleep_on(sk2->sleep);
        if (current->signal & ~current->blocked) 
        {
            sti();
            sk1->pair = sk2;
            sk2->sleep = NULL;
            sk2->socket=NULL;
            newsock->data = NULL;
            return(-ERESTARTSYS);
        }
    }
    sti();
    if (sk2->state != TCP_ESTABLISHED && sk2->err > 0) 
    {
        err = -sk2->err;
        sk2->err=0;
        sk2->dead=1;    /* ANK */
        destroy_sock(sk2);
        newsock->data = NULL;
        return(err);
    }
    // 设置sock为已经建立连接状态
    newsock->state = SS_CONNECTED;
    return(0);
}

static struct sock *tcp_accept(struct sock *sk, int flags)
{
    struct sock *newsk;
    struct sk_buff *skb;
  /*
   * We need to make sure that this socket is listening,
   * and that it has something pending.
   */
    if (sk->state != TCP_LISTEN) 
    {
        sk->err = EINVAL;
        return(NULL); 
    }
    /* Avoid the race. */
    cli();
    sk->inuse = 1;
    // 从sock的receive_queue队列摘取已建立连接的节点，
    while((skb = tcp_dequeue_established(sk)) == NULL) 
    {    
        // 没有已经建立连接的节点，但是设置了非阻塞模式，直接返回
        if (flags & O_NONBLOCK) 
        {
            sti();
            release_sock(sk);
            sk->err = EAGAIN;
            return(NULL);
        }
        release_sock(sk);
        //阻塞进程，如果后续建立了连接，则进程被唤醒的时候，就会跳出while循环
        interruptible_sleep_on(sk->sleep);
        if (current->signal & ~current->blocked) 
        {
            sti();
            sk->err = ERESTARTSYS;
            return(NULL);
        }
        sk->inuse = 1;
      }
    sti();
    /*
     *    Now all we need to do is return skb->sk. 
     */
    // 拿到一个新的sock结构，由建立连接的时候创建的
    newsk = skb->sk;
    kfree_skb(skb, FREE_READ);
    // 队列节点数减一
    sk->ack_backlog--;
    release_sock(sk);
    // 返回新的sock结构体
    return(newsk);
}

// struct wait_queue wait = { current, NULL };p就是socket中的wait，下面的代码就是把当前进程挂到wait队列里
if (!*p) {
    wait->next = wait;
    *p = wait;
} else {
    wait->next = (*p)->next;
    (*p)->next = wait;
}

if(sk->state==TCP_SYN_SENT){
        if(th->ack)
        {
            if(!tcp_ack(sk,th,saddr,len))
            {
                //...
            }
        }
    }

if(sk->state==TCP_SYN_RECV)
    {
        tcp_set_state(sk, TCP_ESTABLISHED);
        tcp_options(sk,th);
        sk->dummy_th.dest=th->source;
        sk->copied_seq = sk->acked_seq;
        if(!sk->dead)
            sk->state_change(sk);
        if(sk->max_window==0)
        {
            sk->max_window=32;    /* Sanity check */
            sk->mss=min(sk->max_window,sk->mtu);
        }
    }

static void def_callback1(struct sock *sk)
{
    if(!sk->dead)
        wake_up_interruptible(sk->sleep);
    // 获取sleep队列中的所有进程，sleep即socket的wait，即inode的wait
}