linux内核如何创建一个TCP包并能发送

liuyusen10

急！！！linux内核编程如何创建一个TCP包并能发送，最好能对TCP包的内容可以修改~~~
求大神帮助！！！

Tinnal

回复 1# liuyusen10


    内核目前只支持UDP发送，TCP数据包请在用户态去发送。不要什么东西都放内核态去做！

wait_rabbit

__sock_create()  ?

zsszss0000

raw_socket不能满足需求吗？回复 1# liuyusen10


   

liuyusen10

谢谢你的回答。
请教你一个问题好吗
我需要修改一个TCP包的选项长度为20Bytes，但是这个包现在的选项长度是12Bytes，怎么处理呢？回复 2# Tinnal


   

Tinnal

回复 5# liuyusen10


    为什么要这么去做呢？有什么背后的需求？

liuyusen10

这个背后的需求的问题还比较难以阐述，简单来讲就是一个小项目刚好遇到了这样的难题，发现TCP报文的选项需要进行一下填充。
有什么方法吗？
回复 6# Tinnal


   

Tinnal

回复 7# liuyusen10

TCP的选项字段是由如下的函数生成的，你非要option为20字节，可以用的方法有：
1. 通过合理的现成TCP参数，凑够20个字节。但这个不好控制，以后的需求变更了就又得凑一次了。
2. 自己改改这个函数，通过TCPOPT_NOP自己填充到20个字节。

1. static void tcp_options_write(__be32 *ptr, struct tcp_sock *tp,
   
2.                               struct tcp_out_options *opts)
   
3. {
   
4.         u8 options = opts->options;        /* mungable copy */
   
5. 
   
6.         /* Having both authentication and cookies for security is redundant,
   
7.          * and there's certainly not enough room.  Instead, the cookie-less
   
8.          * extension variant is proposed.
   
9.          *
   
10.          * Consider the pessimal case with authentication.  The options
    
11.          * could look like:
    
12.          *   COOKIE|MD5(20) + MSS(4) + SACK|TS(12) + WSCALE(4) == 40
    
13.          */
    
14.         if (unlikely(OPTION_MD5 & options)) {
    
15.                 if (unlikely(OPTION_COOKIE_EXTENSION & options)) {
    
16.                         *ptr++ = htonl((TCPOPT_COOKIE << 24) |
    
17.                                        (TCPOLEN_COOKIE_BASE << 16) |
    
18.                                        (TCPOPT_MD5SIG << 8) |
    
19.                                        TCPOLEN_MD5SIG);
    
20.                 } else {
    
21.                         *ptr++ = htonl((TCPOPT_NOP << 24) |
    
22.                                        (TCPOPT_NOP << 16) |
    
23.                                        (TCPOPT_MD5SIG << 8) |
    
24.                                        TCPOLEN_MD5SIG);
    
25.                 }
    
26.                 options &= ~OPTION_COOKIE_EXTENSION;
    
27.                 /* overload cookie hash location */
    
28.                 opts->hash_location = (__u8 *)ptr;
    
29.                 ptr += 4;
    
30.         }
    
31. 
    
32.         if (unlikely(opts->mss)) {
    
33.                 *ptr++ = htonl((TCPOPT_MSS << 24) |
    
34.                                (TCPOLEN_MSS << 16) |
    
35.                                opts->mss);
    
36.         }
    
37. 
    
38.         if (likely(OPTION_TS & options)) {
    
39.                 if (unlikely(OPTION_SACK_ADVERTISE & options)) {
    
40.                         *ptr++ = htonl((TCPOPT_SACK_PERM << 24) |
    
41.                                        (TCPOLEN_SACK_PERM << 16) |
    
42.                                        (TCPOPT_TIMESTAMP << 8) |
    
43.                                        TCPOLEN_TIMESTAMP);
    
44.                         options &= ~OPTION_SACK_ADVERTISE;
    
45.                 } else {
    
46.                         *ptr++ = htonl((TCPOPT_NOP << 24) |
    
47.                                        (TCPOPT_NOP << 16) |
    
48.                                        (TCPOPT_TIMESTAMP << 8) |
    
49.                                        TCPOLEN_TIMESTAMP);
    
50.                 }
    
51.                 *ptr++ = htonl(opts->tsval);
    
52.                 *ptr++ = htonl(opts->tsecr);
    
53.         }
    
54. 
    
55.         /* Specification requires after timestamp, so do it now.
    
56.          *
    
57.          * Consider the pessimal case without authentication.  The options
    
58.          * could look like:
    
59.          *   MSS(4) + SACK|TS(12) + COOKIE(20) + WSCALE(4) == 40
    
60.          */
    
61.         if (unlikely(OPTION_COOKIE_EXTENSION & options)) {
    
62.                 __u8 *cookie_copy = opts->hash_location;
    
63.                 u8 cookie_size = opts->hash_size;
    
64. 
    
65.                 /* 8-bit multiple handled in tcp_cookie_size_check() above,
    
66.                  * and elsewhere.
    
67.                  */
    
68.                 if (0x2 & cookie_size) {
    
69.                         __u8 *p = (__u8 *)ptr;
    
70. 
    
71.                         /* 16-bit multiple */
    
72.                         *p++ = TCPOPT_COOKIE;
    
73.                         *p++ = TCPOLEN_COOKIE_BASE + cookie_size;
    
74.                         *p++ = *cookie_copy++;
    
75.                         *p++ = *cookie_copy++;
    
76.                         ptr++;
    
77.                         cookie_size -= 2;
    
78.                 } else {
    
79.                         /* 32-bit multiple */
    
80.                         *ptr++ = htonl(((TCPOPT_NOP << 24) |
    
81.                                         (TCPOPT_NOP << 16) |
    
82.                                         (TCPOPT_COOKIE << 8) |
    
83.                                         TCPOLEN_COOKIE_BASE) +
    
84.                                        cookie_size);
    
85.                 }
    
86. 
    
87.                 if (cookie_size > 0) {
    
88.                         memcpy(ptr, cookie_copy, cookie_size);
    
89.                         ptr += (cookie_size / 4);
    
90.                 }
    
91.         }
    
92. 
    
93.         if (unlikely(OPTION_SACK_ADVERTISE & options)) {
    
94.                 *ptr++ = htonl((TCPOPT_NOP << 24) |
    
95.                                (TCPOPT_NOP << 16) |
    
96.                                (TCPOPT_SACK_PERM << 8) |
    
97.                                TCPOLEN_SACK_PERM);
    
98.         }
    
99. 
    
100.         if (unlikely(OPTION_WSCALE & options)) {
     
101.                 *ptr++ = htonl((TCPOPT_NOP << 24) |
     
102.                                (TCPOPT_WINDOW << 16) |
     
103.                                (TCPOLEN_WINDOW << 8) |
     
104.                                opts->ws);
     
105.         }
     
106. 
     
107.         if (unlikely(opts->num_sack_blocks)) {
     
108.                 struct tcp_sack_block *sp = tp->rx_opt.dsack ?
     
109.                         tp->duplicate_sack : tp->selective_acks;
     
110.                 int this_sack;
     
111. 
     
112.                 *ptr++ = htonl((TCPOPT_NOP  << 24) |
     
113.                                (TCPOPT_NOP  << 16) |
     
114.                                (TCPOPT_SACK <<  8) |
     
115.                                (TCPOLEN_SACK_BASE + (opts->num_sack_blocks *
     
116.                                                      TCPOLEN_SACK_PERBLOCK)));
     
117. 
     
118.                 for (this_sack = 0; this_sack < opts->num_sack_blocks;
     
119.                      ++this_sack) {
     
120.                         *ptr++ = htonl(sp[this_sack].start_seq);
     
121.                         *ptr++ = htonl(sp[this_sack].end_seq);
     
122.                 }
     
123. 
     
124.                 tp->rx_opt.dsack = 0;
     
125.         }
     
126. }

复制代码

liuyusen10

谢谢大神，我研究研究
回复 8# Tinnal


   

anyhit

回复 9# liuyusen10
单纯的改一个包没效果的
这个包之后的所有包都要修改
因为 ack 和seq字段变了

其实只要这两个 字段 和校验和 对
其他的 你随便该
因为linux内核包 data字段本身是按最大长度分配的


不过最好不好这样做
除非你安全性要求低

因为一旦乱序的情况出现（一般情况下 tcp包是有序发送的如packet1 packet2 packet3，但协议本身是支持乱序的如 packet2 packet1 packet3），本条tcp链接就废了。
你要是想考虑到所有情况，那就太复杂了