centos7 发送tcp报文

转载

mob64ca14048514 2024-07-16 08:17:33

文章标签 centos7 发送tcp报文网络 linux socket java 文章分类 架构后端开发

linux实现 TCP

强调一下，TCP属于传输层的协议，由操作系统来完成，这个传输层的协议是一个可靠的传输协议，主要完成对数据的传输，对数据内容不关心。

对于linux来说：对TCP的实现主要在linux-5.11.11/net/ipv4包下的 tcp_input.c，tcp_output.c 两个文件下。

这些文件提供了tcp_connect() tcp_send_synack()等方法，用于创建tcp连接

/* Build a SYN and send it off. */
//三次握手的第一个阶段：发送一个SYN
int tcp_connect(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *buff;
	int err;

	tcp_call_bpf(sk, BPF_SOCK_OPS_TCP_CONNECT_CB, 0, NULL);

	if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk))
		return -EHOSTUNREACH; /* Routing failure or similar. */

	tcp_connect_init(sk);

	if (unlikely(tp->repair)) {
		tcp_finish_connect(sk, NULL);
		return 0;
	}

	buff = sk_stream_alloc_skb(sk, 0, sk->sk_allocation, true);
	if (unlikely(!buff))
		return -ENOBUFS;

	tcp_init_nondata_skb(buff, tp->write_seq++, TCPHDR_SYN);
	tcp_mstamp_refresh(tp);
	tp->retrans_stamp = tcp_time_stamp(tp);
	tcp_connect_queue_skb(sk, buff);
	tcp_ecn_send_syn(sk, buff);
	tcp_rbtree_insert(&sk->tcp_rtx_queue, buff);

	/* Send off SYN; include data in Fast Open. */
	err = tp->fastopen_req ? tcp_send_syn_data(sk, buff) :
	      tcp_transmit_skb(sk, buff, 1, sk->sk_allocation);
	if (err == -ECONNREFUSED)
		return err;

	/* We change tp->snd_nxt after the tcp_transmit_skb() call
	 * in order to make this packet get counted in tcpOutSegs.
	 */
	WRITE_ONCE(tp->snd_nxt, tp->write_seq);
	tp->pushed_seq = tp->write_seq;
	buff = tcp_send_head(sk);
	if (unlikely(buff)) {
		WRITE_ONCE(tp->snd_nxt, TCP_SKB_CB(buff)->seq);
		tp->pushed_seq	= TCP_SKB_CB(buff)->seq;
	}
	TCP_INC_STATS(sock_net(sk), TCP_MIB_ACTIVEOPENS);

	/* Timer for repeating the SYN until an answer. */
	inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
				  inet_csk(sk)->icsk_rto, TCP_RTO_MAX);
	return 0;
}
EXPORT_SYMBOL(tcp_connect);


// 三次握手第二个阶段：发送一个SYN_ACK

/* Send a crossed SYN-ACK during socket establishment.
 * WARNING: This routine must only be called when we have already sent
 * a SYN packet that crossed the incoming SYN that caused this routine
 * to get called. If this assumption fails then the initial rcv_wnd
 * and rcv_wscale values will not be correct.
 */
int tcp_send_synack(struct sock *sk)
{
	struct sk_buff *skb;

	skb = tcp_rtx_queue_head(sk);
	if (!skb || !(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)) {
		pr_err("%s: wrong queue state\n", __func__);
		return -EFAULT;
	}
	if (!(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_ACK)) {
		if (skb_cloned(skb)) {
			struct sk_buff *nskb;

			tcp_skb_tsorted_save(skb) {
				nskb = skb_copy(skb, GFP_ATOMIC);
			} tcp_skb_tsorted_restore(skb);
			if (!nskb)
				return -ENOMEM;
			INIT_LIST_HEAD(&nskb->tcp_tsorted_anchor);
			tcp_highest_sack_replace(sk, skb, nskb);
			tcp_rtx_queue_unlink_and_free(skb, sk);
			__skb_header_release(nskb);
			tcp_rbtree_insert(&sk->tcp_rtx_queue, nskb);
			sk_wmem_queued_add(sk, nskb->truesize);
			sk_mem_charge(sk, nskb->truesize);
			skb = nskb;
		}

		TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_ACK;
		tcp_ecn_send_synack(sk, skb);
	}
	return tcp_transmit_skb(sk, skb, 1, GFP_ATOMIC);
}


//三次握手第三个阶段：发送ACK
/* This routine sends an ack and also updates the window. */
void __tcp_send_ack(struct sock *sk, u32 rcv_nxt)
{
	struct sk_buff *buff;

	/* If we have been reset, we may not send again. */
	if (sk->sk_state == TCP_CLOSE)
		return;

	/* We are not putting this on the write queue, so
	 * tcp_transmit_skb() will set the ownership to this
	 * sock.
	 */
	buff = alloc_skb(MAX_TCP_HEADER,
			 sk_gfp_mask(sk, GFP_ATOMIC | __GFP_NOWARN));
	if (unlikely(!buff)) {
		struct inet_connection_sock *icsk = inet_csk(sk);
		unsigned long delay;

		delay = TCP_DELACK_MAX << icsk->icsk_ack.retry;
		if (delay < TCP_RTO_MAX)
			icsk->icsk_ack.retry++;
		inet_csk_schedule_ack(sk);
		icsk->icsk_ack.ato = TCP_ATO_MIN;
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK, delay, TCP_RTO_MAX);
		return;
	}

	/* Reserve space for headers and prepare control bits. */
	skb_reserve(buff, MAX_TCP_HEADER);
	tcp_init_nondata_skb(buff, tcp_acceptable_seq(sk), TCPHDR_ACK);

	/* We do not want pure acks influencing TCP Small Queues or fq/pacing
	 * too much.
	 * SKB_TRUESIZE(max(1 .. 66, MAX_TCP_HEADER)) is unfortunately ~784
	 */
	skb_set_tcp_pure_ack(buff);

	/* Send it off, this clears delayed acks for us. */
	__tcp_transmit_skb(sk, buff, 0, (__force gfp_t)0, rcv_nxt);
}
EXPORT_SYMBOL_GPL(__tcp_send_ack);

HTTP实现

HTTP协议属于应用层的协议，这个协议是由应用程序实现的，许多的应用都实现了HTTP协议，如：tomcat，浏览器等等。与TCP不同，HTTP协议关注数据的内容，它规定了数据的格式，以方便各个应用解析数据，如请求的 请求头，请求行，请求体等。

Socket

如果我们我们使用java实现一个浏览器，这个浏览器要支持HTTP，我们怎么用java来实现HTTP协议呢？大致的一个流程为：

首先，我们要根据HTTP协议个规定，解析请求的网址字符串
之后与目标主机建立TCP连接
发送数据

那我们如何建立TCP连接呢呢？我们的应用是是在操作系统之上的，所以我们可以使用java调用linux实现的tcp_connetct() 等方法就可以方便的建立TCP连接。

但是tcp_connetct() 等方法是linux的核心方法，linux操作系统肯定不会直接暴露这些方法，linux暴露给我们一个类——socket，通过这socket这个类我们就可以调用操作系统的这些方法。

在linux下，socket类的路径为： linux-XX.XXX.XXX/net/socket.c

也就是说socket是对linux这些方法的封装， Socket是应用层与TCP/IP协议族通信的中间软件抽象层，****它是一组接口****。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部。

在socket的__sys_connect方法中会真正的调用 tcp_input.c，tcp_output.c中的方法。

int __sys_connect(int fd, struct sockaddr __user *uservaddr, int addrlen)
{
	int ret = -EBADF;
	struct fd f;

	f = fdget(fd);
	if (f.file) {
		struct sockaddr_storage address;

		ret = move_addr_to_kernel(uservaddr, addrlen, &address);
		if (!ret)
			ret = __sys_connect_file(f.file, &address, addrlen, 0);
		fdput(f);
	}

	return ret;
}

所以我们使用java,python….来建立TCP连接，我们都是面向socket，建立的socket连接就是TCP连接/UDP连接。

在java中如何调用到linux暴露的socket类

在java中我们使用socket非常简单，只需要下面代码就可以建立TCP连接：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;


public class SokectTest {
    private void test() throws IOException {
        Socket socket = new Socket();//tcp
        //UDP是DatagramSocket类
        socket.connect(new InetSocketAddress("localhost",8080));
    }
}

通过对上面代码的debug，可以知道最终将调用本地方法socketCreate()【window是调用socket0()】

native void socketCreate(boolean isServer) throws IOException

这时我们就需要到openJDK中去找到这个方法：

#include <errno.h>  //这种include方式在本工程里面找不到的，这种写法时引入操作系统的头文件

//下面include方式，这些文件在本工程内找的到
#include "jvm.h"
#include "net_util.h"

#include "java_net_SocketOptions.h"
#include "java_net_PlainSocketImpl.h"

JNIEXPORT void JNICALL
Java_java_net_PlainSocketImpl_socketCreate(JNIEnv *env, jobject this,
                                           jboolean stream, jboolean isServer) {
    jobject fdObj, ssObj;
    int fd;
    int type = (stream ? SOCK_STREAM : SOCK_DGRAM);
    int domain = ipv6_available() ? AF_INET6 : AF_INET;

    if (socketExceptionCls == NULL) {
        jclass c = (*env)->FindClass(env, "java/net/SocketException");
        CHECK_NULL(c);
        socketExceptionCls = (jclass)(*env)->NewGlobalRef(env, c);
        CHECK_NULL(socketExceptionCls);
    }
    fdObj = (*env)->GetObjectField(env, this, psi_fdID);

    if (fdObj == NULL) {
        (*env)->ThrowNew(env, socketExceptionCls, "null fd object");
        return;
    }

//这里创建一个真正的socket连接
    if ((fd = socket(domain, type, 0)) == -1) {
        /* note: if you run out of fds, you may not be able to load
         * the exception class, and get a NoClassDefFoundError
         * instead.
         */
        NET_ThrowNew(env, errno, "can't create socket");
        return;
    }

我们发现真正创建socket的是 socket(domain, type, 0) 。这个方法在openJDK中时找不到的，看一下投文件，我们需要在我们mac提供的SDK中找errno.h：

不是这个：

/Library/Developer/CommandLineTools/usr/include/c++/v1/errno.h

是这个：

/Library/Developer/CommandLineTools/SDKs/MacOSX10.15.sdk/usr/include/errno.h

但是这个文件里的内容被apple隐藏了，读得不出任何信息。