linux kernel 2.4.5 ipv4 socket层的一点解释 (http://www.fanqiang.com)

linux kernel 2.4.5 ipv4 socket层的一点解释
本文出自:http://www.xici.net/ 作者: scancat (2001-07-30 10:00:00)

声明:本人水平有限,所以弄的不好,不要骂我啊 :)
1.新建socket
函数原形:
static int inet_create(struct socket *sock, int protocol)
在net/ipv4/af_inet.c中
详细解释
static int inet_create(struct socket *sock, int protocol)
{
 struct sock *sk;
 struct proto *prot;
 sock->state = SS_UNCONNECTED; /* 设置状态为未连接 */
 sk = sk_alloc(PF_INET, GFP_KERNEL, 1); /* 申请sock所需的内存 */
   /* net/core/sock.c */
 if (sk == NULL) 
 goto do_oom;
 switch (sock->type) {
 case SOCK_STREAM:  /* TCP协议 */
 if (protocol && protocol != IPPROTO_TCP)
  goto free_and_noproto;
 protocol = IPPROTO_TCP;
 prot = &tcp_prot; /* tcp_prot定义在net/ipv4/tcp_ipv4.c */
 sock->ops = &inet_stream_ops; /* 针对STREAM的socket操作 */
 break;
 case SOCK_SEQPACKET:  /* 不支持 */
 goto free_and_badtype;
 case SOCK_DGRAM:  /* UDP协议 */
 if (protocol && protocol != IPPROTO_UDP)
  goto free_and_noproto;
 protocol = IPPROTO_UDP;
 sk->no_check = UDP_CSUM_DEFAULT;
 prot=&udp_prot;  /* udp_prot定义在net/ipv4/udp.c */
 sock->ops = &inet_dgram_ops; /* 针对DGRAM的socket操作 */
 break;
 case SOCK_RAW:  /* RAW */
 if (!capable(CAP_NET_RAW)) /* 判断是否有权利建立SOCK_RAW */
  goto free_and_badperm;
 if (!protocol)  /* protocol不能为0 */
  goto free_and_noproto;
 prot = &raw_prot; /* raw_prot定义在net/ipv4/raw.c */
 sk->reuse = 1;  /* 允许地址重用 */
 sk->num = protocol;
 sock->ops = &inet_dgram_ops; /* RAW的一些特性和DGRAM相同 */
 if (protocol == IPPROTO_RAW)
  sk->protinfo.af_inet.hdrincl = 1;
   /* 允许自己定制ip头 */
 break;
 default:
 goto free_and_badtype;
 }
 if (ipv4_config.no_pmtu_disc)
 sk->protinfo.af_inet.pmtudisc = IP_PMTUDISC_DONT;
 else
 sk->protinfo.af_inet.pmtudisc = IP_PMTUDISC_WANT;
 sk->protinfo.af_inet.id = 0;
 sock_init_data(sock,sk); /* 初始化一些数据 */
   /* net/core/sock.c */
 sk->destruct = inet_sock_destruct; /* 当销毁socket时调用inet_sock_destruct */
 sk->zapped = 0;
 sk->family = PF_INET;
 sk->protocol = protocol;
 sk->prot = prot;
 sk->backlog_rcv = prot->backlog_rcv; /* prot->backlog_rcv()见各个类型的定义 */
 sk->protinfo.af_inet.ttl = sysctl_ip_default_ttl; /* 设置默认ttl */
   /* 修改/proc/sys/net/ipv4/ip_default_ttl */
 sk->protinfo.af_inet.mc_loop = 1;
 sk->protinfo.af_inet.mc_ttl = 1;
 sk->protinfo.af_inet.mc_index = 0;
 sk->protinfo.af_inet.mc_list = NULL;
#ifdef INET_REFCNT_DEBUG
 atomic_inc(&inet_sock_nr);
#endif
 if (sk->num) {
 /* It assumes that any protocol which allows
  * the user to assign a number at socket
  * creation time automatically
  * shares.
  */
 sk->sport = htons(sk->num); /* 设置本地端口 */
 /* Add to protocol hash chains. */
 sk->prot->hash(sk);
 }
 if (sk->prot->init) {
 int err = sk->prot->init(sk); /* 协议对socket的初始化 */
 if (err != 0) {
  inet_sock_release(sk);
  return(err);
 }
 }
 return(0);
free_and_badtype:
 sk_free(sk);  /* 释放内存 */
 return -ESOCKTNOSUPPORT;
free_and_badperm:
 sk_free(sk);
 return -EPERM;
free_and_noproto:
 sk_free(sk);
 return -EPROTONOSUPPORT;
do_oom:
 return -ENOBUFS;
}
在net/core/sock.c
void sock_init_data(struct socket *sock, struct sock *sk)
{
 skb_queue_head_init(&sk->receive_queue); /* 初始化3条队列 接受,发送,错误*/
 skb_queue_head_init(&sk->write_queue);
 skb_queue_head_init(&sk->error_queue);
 init_timer(&sk->timer);  /* 初始化timer */
 
 sk->allocation = GFP_KERNEL;
 sk->rcvbuf = sysctl_rmem_default;
 sk->sndbuf = sysctl_wmem_default;
 sk->state  =  TCP_CLOSE;
 sk->zapped = 1;
 sk->socket = sock;
 if(sock)
 {
 sk->type = sock->type;
 sk->sleep = &sock->wait;
 sock->sk = sk;
 } else
 sk->sleep = NULL;
 sk->dst_lock = RW_LOCK_UNLOCKED;
 sk->callback_lock = RW_LOCK_UNLOCKED;
   /* sock_def_wakeup(),sock_def_readable(),
     sock_def_write_space(),sock_def_error_report(),
    sock_def_destruct() 在net/core/sock.c */
 sk->state_change = sock_def_wakeup;
 sk->data_ready = sock_def_readable;
 sk->write_space = sock_def_write_space;
 sk->error_report = sock_def_error_report;
 sk->destruct       =    sock_def_destruct;
 sk->peercred.pid  = 0;
 sk->peercred.uid = -1;
 sk->peercred.gid = -1;
 sk->rcvlowat = 1;
 sk->rcvtimeo = MAX_SCHEDULE_TIMEOUT; /* 设置接受,发送超时 */
 sk->sndtimeo = MAX_SCHEDULE_TIMEOUT;
 atomic_set(&sk->refcnt, 1);
}
1.1 SOCK_STREAM的初始化
在net/ipv4/tcp_ipv4.c
static int tcp_v4_init_sock(struct sock *sk)
{
 struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
 skb_queue_head_init(&tp->out_of_order_queue);
 tcp_init_xmit_timers(sk);
 tcp_prequeue_init(tp);
 tp->rto = TCP_TIMEOUT_INIT;
 tp->mdev = TCP_TIMEOUT_INIT;
   
 /* So many TCP implementations out there (incorrectly) count the
 * initial SYN frame in their delayed-ACK and congestion control
 * algorithms that we must have the following bandaid to talk
 * efficiently to them. -DaveM
 */
 tp->snd_cwnd = 2;
 /* See draft-stevens-tcpca-spec-01 for discussion of the
 * initialization of these values.
 */
 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
 tp->snd_cwnd_clamp = ~0;
 tp->mss_cache = 536;
 tp->reordering = sysctl_tcp_reordering;
 sk->state = TCP_CLOSE;
 sk->write_space = tcp_write_space; /* tcp_write_space() 在net/ipv4/tcp.c */
 sk->use_write_queue = 1;
 sk->tp_pinfo.af_tcp.af_specific = &ipv4_specific;
   /* ipv4_specific 在net/ipv4/tcp_ipv4.c */
 sk->sndbuf = sysctl_tcp_wmem[1]; /* 设置发送和接收缓冲区大小 */
 sk->rcvbuf = sysctl_tcp_rmem[1]; /* sysctl_tcp_* 在net/ipv4/tcp.c */
 atomic_inc(&tcp_sockets_allocated); /* tcp_sockets_allocated是当前TCP socket的数量 */
 return 0;
}
SOCK_DGRAM无初始化
1.2 SOCK_RAW初始化
在net/ipv4/raw.c
static int raw_init(struct sock *sk)
{
 struct raw_opt *tp = &(sk->tp_pinfo.tp_raw4);
 if (sk->num == IPPROTO_ICMP)
 memset(&tp->filter, 0, sizeof(tp->filter));
 return 0;
}
2.Server
2.1 bind
static int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
{
 struct sockaddr_in *addr=(struct sockaddr_in *)uaddr;
 struct sock *sk=sock->sk;
 unsigned short snum;
 int chk_addr_ret;
 int err;
 /* If the socket has its own bind function then use it. (RAW) */
 if(sk->prot->bind)
 return sk->prot->bind(sk, uaddr, addr_len);
    /* 只有SOCK_RAW定义了自己的bind函数 */
 if (addr_len < sizeof(struct sockaddr_in))
 return -EINVAL;
 chk_addr_ret = inet_addr_type(addr->sin_addr.s_addr);
    /* inet_addr_type返回地址的类型 */
    /* 在net/ipv4/fib_frontend.c */
 /* Not specified by any standard per-se, however it breaks too
 * many applications when removed. It is unfortunate since
 * allowing applications to make a non-local bind solves
 * several problems with systems using dynamic addressing.
 * (ie. your servers still start up even if your ISDN link
 * is temporarily down)
 */
 if (sysctl_ip_nonlocal_bind == 0 && 
   sk->protinfo.af_inet.freebind == 0 &&
   addr->sin_addr.s_addr != INADDR_ANY &&
   chk_addr_ret != RTN_LOCAL &&
   chk_addr_ret != RTN_MULTICAST &&
   chk_addr_ret != RTN_BROADCAST)
 return -EADDRNOTAVAIL;
 snum = ntohs(addr->sin_port);
 if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))
   /* 检查是否有权利bind端口到1-1024 */
 return -EACCES;
 /*   We keep a pair of addresses. rcv_saddr is the one
 *   used by hash lookups, and saddr is used for transmit.
 *
 *   In the BSD API these are the same except where it
 *   would be illegal to use them (multicast/broadcast) in
 *   which case the sending device address is used.
 */
 lock_sock(sk);
 /* Check these errors (active socket, double bind). */
 err = -EINVAL;
 if ((sk->state != TCP_CLOSE)  ||
   (sk->num != 0))
 goto out;
 sk->rcv_saddr = sk->saddr = addr->sin_addr.s_addr;
 if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
 sk->saddr = 0; /* Use device */
 /* Make sure we are allowed to bind here. */
 if (sk->prot->get_port(sk, snum) != 0) { /* get_port检查是否重用 */
 sk->saddr = sk->rcv_saddr = 0;
 err = -EADDRINUSE;
 goto out;
 }
 if (sk->rcv_saddr)
 sk->userlocks |= SOCK_BINDADDR_LOCK;
 if (snum)
 sk->userlocks |= SOCK_BINDPORT_LOCK;
 sk->sport = htons(sk->num);
 sk->daddr = 0;
 sk->dport = 0;
 sk_dst_reset(sk);
 err = 0;
out:
 release_sock(sk);
 return err;
}
SOCK_STREAM和SOCK_DGRAM用默认的bind
2.1.1 SOCK_RAW的bind
在net/ipv4/raw.c
static int raw_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
{
 struct sockaddr_in *addr = (struct sockaddr_in *) uaddr;
 int ret = -EINVAL;
 int chk_addr_ret;
 if (sk->state != TCP_CLOSE || addr_len < sizeof(struct sockaddr_in))
 goto out;
 chk_addr_ret = inet_addr_type(addr->sin_addr.s_addr);
    /* inet_addr_type返回地址的类型 */
    /* 在net/ipv4/fib_frontend.c */
 ret = -EADDRNOTAVAIL;
 if (addr->sin_addr.s_addr && chk_addr_ret != RTN_LOCAL &&
   chk_addr_ret != RTN_MULTICAST && chk_addr_ret != RTN_BROADCAST)
 goto out;
 sk->rcv_saddr = sk->saddr = addr->sin_addr.s_addr;
    /* sk->rcv_saddr 捆绑的本地地址 */
    /* sk->saddr 源地址 */
 if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
 sk->saddr = 0; /* Use device */ /* 地址类型如为多播或是广播源地址为0 */
 sk_dst_reset(sk);
 ret = 0;
out: return ret;
}
2.2 listen
2.2.1 SOCK_STREAM的listen
在net/ipv4/af_inet.c
int inet_listen(struct socket *sock, int backlog)
{
 struct sock *sk = sock->sk;
 unsigned char old_state;
 int err;
 lock_sock(sk);
 err = -EINVAL;
 if (sock->state != SS_UNCONNECTED || sock->type != SOCK_STREAM)
 goto out;
 old_state = sk->state;
 if (!((1<
 goto out;
 /* Really, if the socket is already in listen state
 * we can only allow the backlog to be adjusted.
 */
 if (old_state != TCP_LISTEN) {
 err = tcp_listen_start(sk); /* 真正实现TCP协议listen */
 if (err)
  goto out;
 }
 sk->max_ack_backlog = backlog;
 err = 0;
out:
 release_sock(sk);
 return err;
}
tcp_listen_start在net/ipv4/tcp.h
int tcp_listen_start(struct sock *sk)
{
 struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
 struct tcp_listen_opt *lopt;
 sk->max_ack_backlog = 0;
 sk->ack_backlog = 0;
 tp->accept_queue = tp->accept_queue_tail = NULL;
 tp->syn_wait_lock = RW_LOCK_UNLOCKED;
 tcp_delack_init(tp);  /* tp清0 */
   /* include/net/tcp.h */
 lopt = kmalloc(sizeof(struct tcp_listen_opt), GFP_KERNEL);
 if (!lopt)
 return -ENOMEM;
 memset(lopt, 0, sizeof(struct tcp_listen_opt));
 for (lopt->max_qlen_log = 6; ; lopt->max_qlen_log++)
 if ((1< max_qlen_log) >= sysctl_max_syn_backlog)
  break;
 write_lock_bh(&tp->syn_wait_lock);
 tp->listen_opt = lopt;
 write_unlock_bh(&tp->syn_wait_lock);
 /* There is race window here: we announce ourselves listening,
 * but this transition is still not validated by get_port().
 * It is OK, because this socket enters to hash table only
 * after validation is complete.
 */
 sk->state = TCP_LISTEN;
 if (sk->prot->get_port(sk, sk->num) == 0) { /* 确认地址没有重用 */
 sk->sport = htons(sk->num); /* 设置源端口 */
 sk_dst_reset(sk);
 sk->prot->hash(sk);  /* 将端口加到hash表中 */
 return 0;
 }
 sk->state = TCP_CLOSE;
 write_lock_bh(&tp->syn_wait_lock);
 tp->listen_opt = NULL;
 write_unlock_bh(&tp->syn_wait_lock);
 kfree(lopt);
 return -EADDRINUSE;
}
SOCK_DGRAM 和 SOCK_RAW 不支持listen
2.3 accept
2.3.1 SOCK_STREAM的accept
在net/ipv4/af_inet.c
int inet_accept(struct socket *sock, struct socket *newsock, int flags)
{
 struct sock *sk1 = sock->sk;
 struct sock *sk2;
 int err = -EINVAL;
 if((sk2 = sk1->prot->accept(sk1,flags,&err)) == NULL)
 goto do_err;
 lock_sock(sk2);
 BUG_TRAP((1< state)&(TCPF_ESTABLISHED|TCPF_CLOSE_WAIT|TCPF_CLOSE));
 sock_graft(sk2, newsock); /* 将sk2转接到newsock */
   /* 在include/net/sock.h */
 newsock->state = SS_CONNECTED;
 release_sock(sk2);
 return 0;
do_err:
 return err;
}
SOCK_DGRAM 和 SOCK_RAW 不支持 accept
2.3.1.1 TCP协议的accept
在net/ipv4/tcp.c
struct sock *tcp_accept(struct sock *sk, int flags, int *err)
{
 struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
 struct open_request *req;
 struct sock *newsk;
 int error;
 lock_sock(sk); 
 /* We need to make sure that this socket is listening,
 * and that it has something pending.
 */
 error = -EINVAL;
 if (sk->state != TCP_LISTEN) /* 检查socket是否处于listen状态 */
 goto out;
 /* Find already established connection */
 if (!tp->accept_queue) { /* 判断accept队列是否准备好 */
 long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
   /* 判断是否为堵塞模式 */
   /* 在include/net/sock.h */
 /* If this is a non blocking socket don't sleep */
 error = -EAGAIN;
 if (!timeo)  /* 不堵塞模式,直接返回 */
  goto out;
 error = wait_for_connect(sk, timeo); /* 进入空闲等待连接 */
 if (error)
  goto out;
 }
 req = tp->accept_queue;
 if ((tp->accept_queue = req->dl_next) == NULL)
 tp->accept_queue_tail = NULL;
 newsk = req->sk;
 tcp_acceptq_removed(sk);  /* sk当前连接数减1 */
    /*在include/net/tcp.h */
 tcp_openreq_fastfree(req);  /* 释放内存 */
    /*在include/net/tcp.h */
 BUG_TRAP(newsk->state != TCP_SYN_RECV); 
 release_sock(sk);
 return newsk;
out:
 release_sock(sk);
 *err = error; 
 return NULL;
}
/* 只有当socket为堵塞模式,该函数才会被调用 */
/* 在net/ipv4/tcp.c */
static int wait_for_connect(struct sock * sk, long timeo)
{
 DECLARE_WAITQUEUE(wait, current);
 int err;
 /*
 * True wake-one mechanism for incoming connections: only
 * one process gets woken up, not the 'whole herd'.
 * Since we do not 'race & poll' for established sockets
 * anymore, the common case will execute the loop only once.
 *
 * Subtle issue: "add_wait_queue_exclusive()" will be added
 * after any current non-exclusive waiters, and we know that
 * it will always _stay_ after any new non-exclusive waiters
 * because all non-exclusive waiters are added at the
 * beginning of the wait-queue. As such, it's ok to "drop"
 * our exclusiveness temporarily when we get woken up without
 * having to remove and re-insert us on the wait queue.
 */
 add_wait_queue_exclusive(sk->sleep, &wait);
 for (;;) {
 current->state = TASK_INTERRUPTIBLE;
 release_sock(sk);
 if (sk->tp_pinfo.af_tcp.accept_queue == NULL)
  timeo = schedule_timeout(timeo); /* 休眠timeo时长 */
 lock_sock(sk);
 err = 0;
 if (sk->tp_pinfo.af_tcp.accept_queue) /* accept队列可用 */
    /* 也就是有连接进入 */
  break;
 err = -EINVAL;
 if (sk->state != TCP_LISTEN)
  break;
 err = sock_intr_errno(timeo);
 if (signal_pending(current))
  break;
 err = -EAGAIN;
 if (!timeo)
  break;
 }
 current->state = TASK_RUNNING;
 remove_wait_queue(sk->sleep, &wait);
 return err;
}
3.Client
3.1 connect
3.1.1 SOCK_STREAM的connect
在net/ipv4/af_inet.c
 
int inet_stream_connect(struct socket *sock, struct sockaddr * uaddr,
  int addr_len, int flags)
{
 struct sock *sk=sock->sk;
 int err;
 long timeo;
 lock_sock(sk);
 if (uaddr->sa_family == AF_UNSPEC) {
 err = sk->prot->disconnect(sk, flags); /* 关闭连接 */
 sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;
 goto out;
 }
 switch (sock->state) {
 default:
 err = -EINVAL;
 goto out;
 case SS_CONNECTED:
 err = -EISCONN;
 goto out;
 case SS_CONNECTING:
 err = -EALREADY;
 /* Fall out of switch with err, set for this state */
 break;
 case SS_UNCONNECTED:
 err = -EISCONN;
 if (sk->state != TCP_CLOSE) 
  goto out;
 err = -EAGAIN;
 if (sk->num == 0) {
  if (sk->prot->get_port(sk, 0) != 0) /* 是否重用 */
  goto out;
  sk->sport = htons(sk->num);
 }
 err = sk->prot->connect(sk, uaddr, addr_len); /* 调用协议的connect */
 if (err < 0)
  goto out;
  sock->state = SS_CONNECTING;  /* socket状态设置成连接中 */
 /* Just entered SS_CONNECTING state; the only
  * difference is that return value in non-blocking
  * case is EINPROGRESS, rather than EALREADY.
  */
 err = -EINPROGRESS;
 break;
 }
 timeo = sock_sndtimeo(sk, flags&O_NONBLOCK); /* 是否为堵塞模式 */
    /* 在include/net/sock.h */
 if ((1< state)&(TCPF_SYN_SENT|TCPF_SYN_RECV)) { /* 连接为完成 */
 /* Error code is set above */
 if (!timeo || !inet_wait_for_connect(sk, timeo))
    /* 非堵塞模式立即返回 */
    /* 堵塞模式调用inet_wait_for_connect() */
  goto out;
 err = sock_intr_errno(timeo);
 if (signal_pending(current))
  goto out;
 }
 /* Connection was closed by RST, timeout, ICMP error
 * or another process disconnected us.
 */
 if (sk->state == TCP_CLOSE)
 goto sock_error;
 /* sk->err may be not zero now, if RECVERR was ordered by user
 * and error was received after socket entered established state.
 * Hence, it is handled normally after connect() return successfully.
 */
 sock->state = SS_CONNECTED;  /* 设置状态为已连接 */
 err = 0;
out:
 release_sock(sk);
 return err;
sock_error:
 err = sock_error(sk) ? : -ECONNABORTED;
 sock->state = SS_UNCONNECTED;
 if (sk->prot->disconnect(sk, flags))
 sock->state = SS_DISCONNECTING;
 goto out;
}
/* 只有当socket为堵塞模式,该函数才会被调用 */
/* 在/net/ipv4/af_inet.c */
static long inet_wait_for_connect(struct sock *sk, long timeo)
{
 DECLARE_WAITQUEUE(wait, current);
 __set_current_state(TASK_INTERRUPTIBLE);
 add_wait_queue(sk->sleep, &wait);
 /* Basic assumption: if someone sets sk->err, he _must_
 * change state of the socket from TCP_SYN_*.
 * Connect() does not allow to get error notifications
 * without closing the socket.
 */
 while ((1< state)&(TCPF_SYN_SENT|TCPF_SYN_RECV)) {
 release_sock(sk);
 timeo = schedule_timeout(timeo); /* 进入休眠 */
 lock_sock(sk);
 if (signal_pending(current) || !timeo)
  break;
 set_current_state(TASK_INTERRUPTIBLE);
 }
 __set_current_state(TASK_RUNNING);
 remove_wait_queue(sk->sleep, &wait);
 return timeo;
}
(
http://www.fanqiang.com)
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值