java开发TCPIP协议：实现TCP单向裸数据发送

望月从良

发布于 2019-11-09 19:34:03

1K0

发布于 2019-11-09 19:34:03

前面我们花费大量篇幅完成了TCP协议各种细节的讲解，从中我们能体会到该协议的复杂和烦琐。因此要想从零实现工业级鲁棒性的TCP数据传输协议几乎不可能，因此我们在实现过程中必须尽可能简化，就像老子说的天下难事必作于易，天下大事必作于细，因此我们在实现这么复杂的协议系统时必须从最简单的情况入手，然后一点点增加其骨架和血肉的丰富性。

本节我们先实现一次单向数据传输，我们将开放一个基于TCP协议的客户端，使用TCP协议向服务器发送裸数据，它的基本结构如下图：

该流程图是我们开发Client，让它与服务器进行三次握手连接后，Client向Server发送一个字符’t’，然后向服务器断开连接的过程。在完成这些代码的过程我体会到”知道那么多道理还是过不好这一生“这个大道理，虽然在前面章节我们言之凿凿的讲了很多TCP协议原理，到我真正实现起来时也得不断发蒙，调试了好久才能通过。

首先最容易发蒙的是seq和ack值的变化。通常情况下，当你发送的数据长度为len,如果发出去的数据包含有对应的seq值，如果对方收到数据后它返回的数据包对应ack就应该是发送方的seq+len，但有例外的情况，就像上图中握手和断开过程，如果对方发来的数据包中包含SYN,FIN等标志位，那么回复对方时ack的值必须是对方的seq加上对方数据长度，然后再加上1，这也就是为何在三次握手时，第一次我们给对方发送SYN包，seq设置为0，同时数据包没有任何数据，对方回复时却将ack设置为1的原因，然后对方发来的ACK+FIN时，它的seq为0，我们回复时必须将ack设置为1，这个现象在断开连接，也就是双方互发包含FIN的数据包时也是一样，这一点让我调试了好久才搞明白。

接下来我们进入实现阶段，首先我们需要在另一台设备上安装TCP服务器，只有服务器和客户端不在同一台设备上时我们才好使用wireshark抓包。通常情况下我们可以在手机上下载一个最简单的tcp服务器，我用的是iPhone，在AppStore里用tcp server为关键字就可以搜索到下面应用程序，设置好端口后就可以变成一个最简单的tcp服务器：

只要你能在另一台设备上运行可以接收TCP数据包的服务器程序都可以，我们的任务是在我们自己对TCP协议的实现基础上开发客户端，与它连接后，向它发送一个字符，然后端口连接，我们看看代码的实现。

在代码设计上我使用观察者模式，上层应用向TCP协议层调用相关接口后，TCP协议层以回调的方式通知上层应用，因此我们先添加接口定义：

package utils;

public interface ITCPHandler {
    public  void  connect_notify(boolean connect_res);  //返回tcp连接结果
    public  void  send_notify(boolean send_res, int packet_handler); //通知数据包发送结果
    public  void  connect_close_notify(boolean close_res); //返回连接关闭通知
}

任何想要调用TCP协议层的应用都必须继承该接口，我们看看客户端的实现：

package Application;

import java.net.InetAddress;

import utils.ITCPHandler;

public class TCPRawDataSender implements ITCPHandler{
    private  TCPThreeHandShakes  tcp_socket = null;
    @Override
    public void connect_notify(boolean connect_res) {
        if (connect_res) {
            System.out.println("connection established!");
            try {
                tcp_socket.tcp_send("t".getBytes());
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        else {
            System.out.println("connection fail!");
        }
    }

    @Override
    public void send_notify(boolean send_res, int packet_handler) {
        if (send_res == true) {
            System.out.println("send data ok!");
        }

        try {
            tcp_socket.tcp_close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public void connect_close_notify(boolean close_res) {
        if (close_res == true) {
            System.out.println("connection close complete!");
        } else {
            System.out.println("connection close fail!");
        }
    }

    public void run() {
         try {
            InetAddress ip = InetAddress.getByName("192.168.2.127"); //220.181.43.8
            short port = 1234;
            tcp_socket = new TCPThreeHandShakes(ip.getAddress(), port, this);
            tcp_socket.tcp_connect();
            System.out.println("finish handshake!");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

它的逻辑很简单，首先调用tcp_connect与给定服务器进行三次握手的连接。连接成功后，它的connect_notify接口会被调用，然后他使用tcp_send来向服务器发送一个字节，该调用会返回一个整数当做当前数据发送的句柄，当发送完成后它的send_notify接口会被调用，然后将发送结果与数据对应句柄关联起来告知相应数据发送是否成功。该接口被调用时客户端使用tcp_close来断开连接，如果断开成功，那么它的connect_close_notify会被调用。

同时前面实现的TCPThreeHandShakes将作为使用TCP协议的中间层，由它负责调用TCP协议封包层来发送和接收数据，为此我对其做了一些修改：

public class TCPThreeHandShakes extends Application{
    private byte[] dest_ip;
    private byte [] send_data = null;
    private short dest_port;
    private int ack_num = 0;
    private int seq_num = 0;
    ITCPHandler tcp_handler = null;
    //增加协议状态标量
    private static int CONNECTION_IDLE = 0;
    private static int CONNECTION_CONNECTING = 1;
    private static int CONNECTION_CONNECTED = 2;
    private static int CONNECTION_CLOSING = 3;
    private static int CONNECTION_SEND = 4;
    private int  tcp_state = CONNECTION_IDLE;
    public TCPThreeHandShakes(byte[] server_ip, short server_port, ITCPHandler tcp_handler) {
        this.dest_ip = server_ip;
        this.dest_port = server_port;
         //指定一个固定端口，以便抓包调试
        Random rand = new Random();
        this.port = (short)rand.nextInt();
        this.tcp_handler = tcp_handler;
    }

   public boolean tcp_connect() throws Exception {
       if (tcp_state != CONNECTION_IDLE) {  //只有在空闲状态才能发起新连接
           return  false;
       }
       tcp_state = CONNECTION_CONNECTING;
       beginThreeHandShakes();

       return true;
   }

   public boolean tcp_close() throws Exception {
       if (this.tcp_state != CONNECTION_CONNECTED) {
           return false;
       }
       tcp_state = CONNECTION_CLOSING;
       //启动关闭流程
       beginClose();
       return true;
   }

   public boolean tcp_send(byte[] data) throws Exception {
       if (this.tcp_state != CONNECTION_CONNECTED) {
           return false;
       }
       tcp_state = CONNECTION_SEND;
       send_data = data;
       createAndSendPacket(data, "ACK");
       return true;
   }
.....
@Override
    public void handleData(HashMap<String, Object> headerInfo) {
               。。。。

       if (ack) {
           int seq_num = (int)headerInfo.get("seq_num");
           int ack_num = (int)headerInfo.get("ack_num");
           byte[] data = (byte[])headerInfo.get("data");
           int data_length = 0;
           if (data != null) {  //如果收到对方数据，那么将对方seq加上数据长度最为ack回应
               data_length += data.length;
              }
           try {
            if (this.tcp_state == CONNECTION_CONNECTING && syn) {
                this.tcp_state = CONNECTION_CONNECTED;
                System.out.println("tcp handshake from othersize with seq_num" + seq_num + " and ack_num: " + ack_num);
                this.seq_num = ack_num;
                this.ack_num = seq_num + 1;
                createAndSendPacket(null, "ACK");
                this.tcp_handler.connect_notify(true); //通知上面连接成功
            }
          if (tcp_state == CONNECTION_SEND && ack_num == this.seq_num + send_data.length) {
              tcp_state = CONNECTION_CONNECTED;
              this.seq_num = ack_num;
              send_data = null;
              this.ack_num = seq_num + data_length;
              tcp_handler.send_notify(true, 0);
          }

          if (tcp_state == CONNECTION_CLOSING) {  //向对方发送ack+fin然后收到ack进入到此
              tcp_state = CONNECTION_IDLE;
              this.seq_num = 0;
              this.ack_num = 0;
          }

          if (fin) {  //收到fin包时，ack 要在对方seq上加1
              this.seq_num = ack_num;
              this.ack_num = seq_num + data_length + 1;
              createAndSendPacket(null, "ACK");
              if (tcp_state != CONNECTION_IDLE && tcp_state != CONNECTION_CLOSING) { //这里意味对方主动发起断开,因此回复ack后再次向对方发送ack+fin
                  createAndSendPacket(null, "FIN,ACK");
              }
          }


        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
       }
      //收到服务器发回的fin+ack包，正式关闭连接
      if (ack && fin) {
          System.out.println("receive fin packet and close connection");
          if (this.tcp_state == CONNECTION_CLOSING) {
                this.tcp_state = CONNECTION_IDLE;
                this.tcp_handler.connect_close_notify(true); //通知上面连接关闭
                 try {
                       int seq_num = (int)headerInfo.get("seq_num");
                       int ack_num = (int)headerInfo.get("ack_num");
                       System.out.println("tcp handshake closing from othersize with seq_num" + seq_num + " and ack_num: " + ack_num);
                       this.seq_num += 1;
                       this.ack_num = seq_num + 1;
                        createAndSendPacket(null, "ACK");
                    } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
            }
      }
        }
}

我对这个类代码上做了较大改动，具体的修改设计过程请观看视频的详细讲解，在上面代码完成后运行时，效果如下，首先是服务器端成功接收到了代码向他发送的字符’t’: