网络协议栈3：sock结构体

深藏阁楼爱情的钟 2022-03-29 06:00 245阅读 0赞

**sock结构体是我们在网络编程中遇到的第一个庞大的结构体**

** **

**struct sock \{**

**  struct options      \*opt;/\*IP选项缓存于此处\*/**

**  volatile unsigned long   wmem\_alloc;/\*当前写缓冲区大小，该值不可大于系统规定的最大值\*/**

**  volatile unsigned long   rmem\_alloc;/\*当前读缓冲区大小，该值不可大于系统规定最大值\*/**

**  unsigned long                 write\_seq;/\* write\_seq 表示应用程序下一次写数据时所对应的第一个字节的序列号\*/**

**  unsigned long                 sent\_seq;/\* sent\_seq 表示本地将要发送的下一个数据包中第一个字节对应的序列号\*/**

**  unsigned long                 acked\_seq;/\* acked\_seq 表示本地希望从远端接收的下一个数据的序列号\*/**

**   unsigned long                 copied\_seq; /\*  应用程序有待读取（但尚未读取）数据的第一个序列号。\*/**

**  unsigned long                 rcv\_ack\_seq; /\*  表示目前本地接收到的对本地发送数据的应答序列号。\*/**

**   unsigned long                 window\_seq;/\* 窗口大小，是一个绝对值，表示本地将要发送数据包中所包含最后一个数据的序列号,不可大于 window\_seq.\*/**

**  unsigned long                 fin\_seq; /\*  该字段在对方发送 FIN数据包时使用，在接收到远端发送的 FIN数据包后，fin\_seq 被初始化为对方的 FIN 数据包最后一个字节的序列号加 1，表示本地对此 FIN 数据包进行应答的序列号\*/**

**   unsigned long                 urg\_seq;**

**  unsigned long                 urg\_data;**

**/\*  以上两个字段用于紧急数据处理，urg\_seq 表示紧急数据最大序列号。urg\_data 是一个标志位，当设置为 1 时，表示接收到紧急数据。\*/**

**  volatile char                 inuse,/\*inuse=1 表示其它进程正在使用该 sock 结构，本进程需等待\*/**

**                      dead,/\* dead=1 表示该 sock 结构已处于释放状态\*/**

**                      urginline,/\* urginline=1 表示紧急数据将被当作普通数据处理。\*/**

**                      intr,**

**                      blog,/\* blog=1 表示对应套接字处于节制状态，此时接收的数据包均被丢弃\*/**

**                      done,**

**                      reuse,**

**                      keepopen,/\* keepopen=1 表示使用保活定时器 \*/**

**                      linger,/\* linger=1 表示在关闭套接字时需要等待一段时间以确认其已关闭。\*/**

**                      delay\_acks,/\* delay\_acks=1表示延迟应答，可一次对多个数据包进行应答 \*/**

**                      destroy,/\* destroy=1 表示该 sock 结构等待销毁\*/**

**                      ack\_timed,**

**                      no\_check,**

**                      zapped,   /\* In ax25 & ipx means not linked \*/**

**                      broadcast,**

**                      nonagle;/\* noagle=1 表示不使用 NAGLE 算法\*/**

**  unsigned long                   lingertime;/\*表示等待关闭操作的时间，只有当 linger 标志位为 1 时，该字段才有意义。\*/**

**  int                    proc;/\* 该 sock 结构（即该套接字）所属的进程的进程号。\*/**

**  struct sock                \*next;**

**  struct sock                \*prev;**

**  struct sock                \*pair;**

**/\* 以上三个字段用于 sock 的连接\*/**

** **

**  struct sk\_buff      \* volatile send\_head;**

**  struct sk\_buff      \* volatile send\_tail;**

**/\* send\_head, send\_tail 用于 TCP协议重发队列。\*/**

** **

**  struct sk\_buff\_head       back\_log;/\* back\_log为接收的数据包缓存队列。用于计算目前累计的应发送而未发送的应答数据包的个数\*/**

**  struct sk\_buff      \*partial;/\*创建最大长度的待发送数据包。\*/**

**  struct timer\_list         partial\_timer;/\*按时发送 partial 指针指向的数据包，以免缓存（等待）时间过长。\*/**

**  long                      retransmits;/\* 重发次数\*/**

**/\***

**write\_queue 指向待发送数据包，其与 send\_head,send\_tail 队列的不同之处在于send\_head,send\_tail 队列中数据包均已经发送出去，但尚未接收到应答。而 write\_queue 中数据包尚未发送。 receive-queue为读队列，其不同于 back\_log 队列之处在于 back\_log 队列缓存从网络层传 上来的数据包，在用户进行读取操作时，不可操作 back\_log 队列，而是从 receive\_queue 队列中去数据包读取其中的数据，即数据包首先缓存在 back\_log 队列中，然后从 back\_log 队列中移动到 receive\_queue队列中方可被应用程序读取。而并非所有back\_log 队列中缓 存的数据包都可以成功的被移动到 receive\_queue队列中，如果此刻读缓存区太小，则当 前从back\_log 队列中被取下的被处理的数据包将被直接丢弃，而不会被缓存到receive\_queue 队列中。如果从应答的角度看，在back\_log队列中的数据包由于有可能被 丢弃，故尚未应答，而将一个数据包从 back\_log 移动到 receive\_queue时，表示该数据包 已被正式接收，即会发送对该数据包的应答给远端表示本地已经成功接收该数据包。 \*/**

**  struct sk\_buff\_head       write\_queue,**

**                      receive\_queue;**

** **

**  struct proto               \*prot;/\*指向传输层处理函数集\*/**

**  struct wait\_queue           \*\*sleep;/\*进程等待sock的地位\*/**

**  unsigned long                 daddr;/\*套接字的远端地址\*/**

**  unsigned long                 saddr;/\*套接字的本地地址\*/**

**  unsigned short          max\_unacked;/\* 最大未处理请求连接数（应答数） \*/**

**  unsigned short          window;/\* 远端窗口大小 \*/**

**  unsigned short          bytes\_rcv;/\* 已接收字节总数\*/**

**/\* mss is min(mtu, max\_window) \*/**

**  unsigned short          mtu;       /\*最大传输单元\*/**

**  volatile unsigned short  mss;       /\*最大报文长度：MSS=MTU-IP 首部长度-TCP首部长度 \*/**

**  volatile unsigned short  user\_mss;  /\*用户指定的 MSS值\*/**

** **

**  volatile unsigned short  max\_window;**

**  unsigned long          window\_clamp;/\*最大窗口大小和窗口大小钳制值 \*/**

** **

**  unsigned short          num;/\* 本地端口号\*/**

**/\***

**以下三个字段用于拥塞算法**

**\*/  **

**  volatile unsigned short  cong\_window;**

**  volatile unsigned short  cong\_count;**

**  volatile unsigned short  ssthresh;**

**  volatile unsigned short  packets\_out;/\* 本地已发送出去但尚未得到应答的数据包数目\*/**

**  volatile unsigned short  shutdown;/\* 本地关闭标志位，用于半关闭操作\*/**

**  volatile unsigned long   rtt;/\* 往返时间估计值\*/**

**  volatile unsigned long   mdev;/\* mean deviation, 即RTTD,  绝对偏差\*/**

**  volatile unsigned long   rto;/\* RTO是用 RTT 和 mdev 用算法计算出的延迟时间值\*/**

**  volatile unsigned short  backoff;/\* 退避算法度量值 \*/**

**  volatile short        err;/\* 错误标志值\*/**

**  unsigned char                 protocol;/\* 传输层协议值\*/**

**  volatile unsigned char   state;/\* 套接字状态值，如 TCP\_ESTABLISHED \*/**

**  volatile unsigned char   ack\_backlog;/\* 缓存的未应答数据包个数\*/**

**  unsigned char                 max\_ack\_backlog;/\* 最大缓存的未应答数据包个数\*/**

**  unsigned char                 priority;/\* 该套接字优先级，在硬件缓存发送数据包时使用 \*/**

**  unsigned char                 debug;**

**  unsigned short          rcvbuf;/\* 最大接收缓冲区大小\*/**

**  unsigned short          sndbuf;/\* 最大发送缓冲区大小\*/**

**  unsigned short          type;/\* 类型值如 SOCK\_STREAM \*/**

**  unsigned char                 localroute;    /\* localroute=1 表示只使用本地路由，一般目的端在相同子网时使用。\*/**

**\#ifdef CONFIG\_IPX**

**  ipx\_address               ipx\_dest\_addr;**

**  ipx\_interface             \*ipx\_intrfc;**

**  unsigned short          ipx\_port;**

**  unsigned short          ipx\_type;**

**\#endif**

**\#ifdef CONFIG\_AX25**

**  ax25\_address            ax25\_source\_addr,ax25\_dest\_addr;**

**  struct sk\_buff \*volatile   ax25\_retxq\[8\];**

**  char                      ax25\_state,ax25\_vs,ax25\_vr,ax25\_lastrxnr,ax25\_lasttxnr;**

**  char                      ax25\_condition;**

**  char                      ax25\_retxcnt;**

**  char                      ax25\_xx;**

**  char                      ax25\_retxqi;**

**  char                      ax25\_rrtimer;**

**  char                      ax25\_timer;**

**  unsigned char                 ax25\_n2;**

**  unsigned short          ax25\_t1,ax25\_t2,ax25\_t3;**

**  ax25\_digi              \*ax25\_digipeat;**

**\#endif **

**\#ifdef CONFIG\_ATALK**

**  struct atalk\_sock      at;**

**\#endif**

** **

**/\* IP 'private area' or will be eventually \*/**

**  int                    ip\_ttl;       /\* IP首部 TTL 字段值，实际上表示路由器跳数\*/**

**  int                    ip\_tos;           /\* IP首部 TOS字段值，服务类型值\*/**

**  struct tcphdr             dummy\_th;/\* 缓存的 TCP首部，在 TCP协议中创建一个发送数据包时可以利用此字段快速创建 TCP 首部。\*/**

**  struct timer\_list         keepalive\_timer;     /\*保活定时器，用于探测对方窗口大小，防止对方通报窗口大小的数据包丢弃，从而造成 本地发送通道被阻塞。\*/**

**  struct timer\_list         retransmit\_timer;    /\*重发定时器，用于数据包超时重发\*/**

**  struct timer\_list         ack\_timer;          /\*延迟应答定时器，延迟应答可以减少应答数据包的个数，但不可无限延迟以免造成远端 重发，所以设置定时器定期发送应答数据包。 \*/**

**  int                    ip\_xmit\_timeout;     /\*该字段为标志位组合字段，用于表示下文中 timer定时器超时的原因\*/**

**\#ifdef CONFIG\_IP\_MULTICAST **

**  int                    ip\_mc\_ttl;                **

**  int                    ip\_mc\_loop;            **

**  char                      ip\_mc\_name\[MAX\_ADDR\_LEN\]; **

**  struct ip\_mc\_socklist          \*ip\_mc\_list;     **

**\#endif **

**/\*以上4 个字段用于 IP多播\*/**

** **

**  int                    timeout;  **

**  struct timer\_list         timer;**

**/\* 以上两个字段用于通用定时，timeout 表示定时时间值，ip\_xmit\_timeout表示此次定时的 原因，timer为定时器。 \*/**

**  struct timeval       stamp;/\* 时间戳\*/**

**  struct socket             \*socket;/\*对应的socket结构体\*/**

** **

**  void                       (\*state\_change)(struct sock \*sk);**

**  void                       (\*data\_ready)(struct sock \*sk,int bytes);**

**  void                       (\*write\_space)(struct sock \*sk);**

**  void                       (\*error\_report)(struct sock \*sk);**

**/\* 以上四个函数指针字段指向回调函数。这些字段的设置为自定义回调函数提供的很大的**

**灵活性，内核在发生某些时间时，会调用这些函数，如此可以实现自定义响应。目前这**

**种自定义响应还是完全有内核控制。 \*/  **

**\};**

**在inet\_create 函数中，这个结构体的成员基本上都被初始化了**

** **

**static int inet\_create(struct socket \*sock, int protocol)  
\{**

**     ......**

** switch(sock->type)  
 \{**

**    ......**

**  case SOCK\_STREAM:**  
**  case SOCK\_SEQPACKET:**  
**/\***  
**在 socket 系统调用时，我们一般将 protocol 参数设置为 0。如果设置为非 0，**   
**则对于不同的类型，必须赋予正确值，否则可能在此处处理时出现问题。**   
**\*/**  
**   if (protocol && protocol != IPPROTO\_TCP)**   
**   \{**   
**    kfree\_s((void \*)sk, sizeof(\*sk));**  
**    return(-EPROTONOSUPPORT);**  
**   \}**  
**   protocol = IPPROTO\_TCP;**  
**/\***  
**TCP\_NO\_CHECK定义为 1，表示对于 TCP协议默认使用校验**  
**\*/ **  
**   sk->no\_check = TCP\_NO\_CHECK;**  
**/\***  
**注意此处prot 变量被初始化为 tcp\_prot，稍后 sock 结构的prot 字段将被初始**   
**化为prot 变量值。**  
**\*/**  
**   prot = &tcp\_prot;**  
**   break;**

**    ......**

** **

**  \}**

**    ......**

** sk->socket = sock;/\*建立与其对应的 socket结构之间的关系，socket结构先于 sock 结构建立。 \*/**  
**\#ifdef CONFIG\_TCP\_NAGLE\_OFF**  
** sk->nonagle = 1;**  
**\#else   **   
** sk->nonagle = 0;**  
**\#endif **   
** sk->type = sock->type;/\*初始化 sock 结构 type 字段：套接字类型\*/**  
** sk->stamp.tv\_sec=0;**  
** sk->protocol = protocol;/\*传输层协议\*/**  
** sk->wmem\_alloc = 0;**  
** sk->rmem\_alloc = 0;**  
** sk->sndbuf = SK\_WMEM\_MAX;/\*最大发送缓冲区大小\*/**  
** sk->rcvbuf = SK\_RMEM\_MAX;/\*最大接收缓冲区大小\*/**  
** sk->pair = NULL;**  
** sk->opt = NULL;**  
** sk->write\_seq = 0;**  
** sk->acked\_seq = 0;**  
** sk->copied\_seq = 0;**  
** sk->fin\_seq = 0;**  
** sk->urg\_seq = 0;**  
** sk->urg\_data = 0;**  
** sk->proc = 0;**  
** sk->rtt = 0;    /\*TCP\_WRITE\_TIME << 3;\*/**  
** sk->rto = TCP\_TIMEOUT\_INIT;  /\*TCP\_WRITE\_TIME\*/**  
** sk->mdev = 0;**  
** sk->backoff = 0;**  
** sk->packets\_out = 0;**  
**/\***  
**cong\_window 设置为 1，即 TCP首先进入慢启动阶段。这是 TCP协议处理拥塞的 一种策略**  
**\*/**  
** sk->cong\_window = 1; /\* start with only sending one packet at a time. \*/**  
** sk->cong\_count = 0;**  
** sk->ssthresh = 0;**  
** sk->max\_window = 0;**  
** sk->urginline = 0;**  
** sk->intr = 0;**  
** sk->linger = 0;**  
** sk->destroy = 0;**  
** sk->priority = 1;**  
** sk->shutdown = 0;**  
** sk->keepopen = 0;**  
** sk->zapped = 0;**  
** sk->done = 0;**  
** sk->ack\_backlog = 0;**  
** sk->window = 0;**  
** sk->bytes\_rcv = 0;**  
** sk->state = TCP\_CLOSE;/\*由于尚未进行连接，状态设置为 CLOSE。\*/**  
** sk->dead = 0;**  
** sk->ack\_timed = 0;**  
** sk->partial = NULL;**  
** sk->user\_mss = 0;**  
** sk->debug = 0;**  
**/\***  
**设置最大可暂缓应答的字节数**  
**\*/**  
** /\* this is how many unacked bytes we will accept for this socket.  \*/**  
** sk->max\_unacked = 2048; /\* needs to be at most 2 full packets. \*/**

** /\* how many packets we should send before forcing an ack.  
    if this is set to zero it is the same as sk->delay\_acks = 0 \*/  
 sk->max\_ack\_backlog = 0;  
 sk->inuse = 0;  
 sk->delay\_acks = 0;  
 skb\_queue\_head\_init(&sk->write\_queue);  
 skb\_queue\_head\_init(&sk->receive\_queue);  
 sk->mtu = 576;/\*MTU设置为保守的576字节， 该大小在绝大多数连接中不会造成分片\*/**

** sk->prot = prot;  
 sk->sleep = sock->wait;  
 sk->daddr = 0;  
 sk->saddr = 0 /\* ip\_my\_addr() \*/;  
 sk->err = 0;  
 sk->next = NULL;  
 sk->pair = NULL;  
 sk->send\_tail = NULL;  
 sk->send\_head = NULL;  
 sk->timeout = 0;  
 sk->broadcast = 0;  
 sk->localroute = 0;  
 init\_timer(&sk->timer);  
 init\_timer(&sk->retransmit\_timer);  
 sk->timer.data = (unsigned long)sk;  
 sk->timer.function = &net\_timer;  
 skb\_queue\_head\_init(&sk->back\_log);  
 sk->blog = 0;  
 sock->data =(void \*) sk;  
/\*sock 结构之 dummy\_th 字段是 tcphdr结构，该结构与 TCP首部各字段对应\*/   
 sk->dummy\_th.doff = sizeof(sk->dummy\_th)/4;  
 sk->dummy\_th.res1=0;  
 sk->dummy\_th.res2=0;  
 sk->dummy\_th.urg\_ptr = 0;  
 sk->dummy\_th.fin = 0;  
 sk->dummy\_th.syn = 0;  
 sk->dummy\_th.rst = 0;  
 sk->dummy\_th.psh = 0;  
 sk->dummy\_th.ack = 0;  
 sk->dummy\_th.urg = 0;  
 sk->dummy\_th.dest = 0;  
 sk->ip\_tos=0;  
 sk->ip\_ttl=64;  
\#ifdef CONFIG\_IP\_MULTICAST  
 sk->ip\_mc\_loop=1;  
 sk->ip\_mc\_ttl=1;  
 \*sk->ip\_mc\_name=0;  
 sk->ip\_mc\_list=NULL;  
\#endif  
/\*  
对 sock 结构中几个回调函数字段的初始化  
\*/     
 sk->state\_change = def\_callback1;  
 sk->data\_ready = def\_callback2;  
 sk->write\_space = def\_callback3;  
 sk->error\_report = def\_callback1;  
/\*  
如果该套接字已经分配本地端口号，则对 sock 结构中 dummy\_th 结构字段进行赋值  
\*/  
 if (sk->num)  
 \{  
 /\*  
  \* It assumes that any protocol which allows  
  \* the user to assign a number at socket  
  \* creation time automatically  
  \* shares.  
  \*/  
  put\_sock(sk->num, sk);  
  sk->dummy\_th.source = ntohs(sk->num);  
 \}**

**    ......**

** return(0);**  
**\}**

** **

**此后，数据的传送，都由sock结构体作为数据的携带者，传送给下层的传输层，网络层，链路层，链路层**