socket模拟通信实现ARQ停止等待协议

 //服务端
 import java.awt.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.io.*;
 import java.net.*;
 import java.security.Timestamp;
 import java.util.*;
 import java.util.prefs.BackingStoreException;

 import javax.swing.*;

 public class IServer extends JFrame {
     private static long  time1;
     private static    long  time2;
     private JPanel jp = new JPanel();
     private JTextArea jta = new JTextArea();
     private JScrollPane jsp = null;
     private JButton jb = new JButton("发送");
     private JTextField jtf = new JTextField(30);
     private ServerSocket server;
     private Socket socket;
     DataOutputStream dos;
     DataInputStream dis;
     public IServer() throws IOException
     {
         Toolkit t = Toolkit.getDefaultToolkit();
         Dimension Size =t.getScreenSize();
         int width =  Size.width;
         int height = Size.height;
         setLocationByPlatform(true);
         jsp = new JScrollPane(jta);
         this.setTitle("发送方");
         this.setSize(600, 500);
         this.setBounds((width - 600) / 2,
                 (height - 500) / 2, 600,500);
         jp.add(jtf);
         jp.add(jb);
         this.add(jsp, BorderLayout.CENTER);
         this.add(jp, BorderLayout.SOUTH);
         jta.setCaretPosition(jta.getDocument().getLength());// 设置滚动条自动滚动
         this.setVisible(true);
         this.setAlwaysOnTop(true);
         server = new ServerSocket(9000);
         socket= server.accept();
         this.setDefaultCloseOperation(EXIT_ON_CLOSE);
         dos = new DataOutputStream(socket.getOutputStream());
         dis =new DataInputStream(socket.getInputStream());
         jb.addActionListener(new ActionListener(){
             public void actionPerformed(ActionEvent event){
                 try {
                     Send();
                 } catch (InterruptedException | IOException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }
         });
     }
     public static void main(String[] args) throws IOException, InterruptedException
     {
             new IServer();
     }
     public void Send() throws InterruptedException, IOException
     {
         String info = jtf.getText();
         jtf.setText("");
         char[] Msg = info.toCharArray();
         dos.write(Msg.length);
         for(int i=0;i<Msg.length;i++)
         {
             Random random=new java.util.Random();                        //实现数据帧错传，以随机数的概率来实现
             int result=random.nextInt(21);
             if(result>=4)
             {
                 if (jta.getText() == null || "".equals(jta.getText())) {
                     jta.append("Sending...:" + Msg[i]);
                 } else {
                     jta.append("\r\nSending...:" + Msg[i]);
                 }
                 dos.writeChar(Msg[i]);                                    //发送数据帧
                 time1 = System.currentTimeMillis();                        //设置超时计时器
             }
             else
             {
                 if (jta.getText() == null || "".equals(jta.getText())) {
                     jta.append("Sending...:" + Msg[i]);
                 } else {
                     jta.append("\r\nSending...:" + Msg[i]);
                 }
                 dos.writeChar('η');                                        //发送数据帧
                 time1 = System.currentTimeMillis();                         //设置超时计时器
             }
             int c = dis.readInt();                                        //接受客户端确认帧
             time2 = System.currentTimeMillis();
             long time = time2-time1;
             //System.out.println("接收所用时间："+time);
             if(time<500)                                                        //确认帧未超时
             {
                 if(c==i+2)                                                    //确认帧正确，传输成功，准备传输下一个帧
                 {
                     if(i<Msg.length-1)
                     {
                         if (jta.getText() == null || "".equals(jta.getText())) {
                             jta.append("Receive:" + c);
                         } else {
                             jta.append("\r\nReceive:" + c);
                         }
                         //System.out.println("接收方返回帧："+c+"  第"+(i+1)+"号帧传输成功！");
                     }
                     else
                     {
                         if (jta.getText() == null || "".equals(jta.getText())) {
                             jta.append("Receive:" + (i+2)+"数据传输成功！");
                         } else {
                             jta.append("\r\nReceive:" + (i+2)+"数据传输成功！");
                             jta.setEnabled(false);

                         }
                         //System.out.println("第"+(i+1)+"号帧传输成功！");
                         //System.out.println("数据传输成功！");
                         server.close();
                     }
                 }
                 else if(c==-2)                                                        //确认帧出错，超时重传
                 {
                     if (jta.getText() == null || "".equals(jta.getText())) {
                         jta.append("Receive:数据帧出错，丢弃等待....."+
                                 "确认帧接收超时，重新发送"+(i+1)+"帧");
                     } else {
                         jta.append("\r\nReceive:Receive:数据帧出错，丢弃等待....."
                     +"确认帧接收超时，重新发送"+(i+1)+"帧");
                     }
                     //System.out.println("数据帧出错，丢弃等待.....");
                     Thread.sleep(300);
                     //System.out.println("确认帧接收超时，重新发送"+(i+1)+"帧");
                     i=i-1;
                 }
             }
             else//超时，重传
             {
                 if (jta.getText() == null || "".equals(jta.getText())) {
                     jta.append("Receive:" +"确认帧接收超时，重新发送"+(i+1)+"帧");
                 } else {
                     jta.append("\r\nReceive:" + "确认帧接收超时，重新发送"+(i+1)+"帧");
                 }
                 //System.out.println("确认帧接收超时，重新发送"+(i+1)+"帧");
                 i=i-1;
             }
         }
     }
 }

 //客户端

 //客户端

 import java.awt.*;
 import java.io.*;
 import java.net.*;
 import java.util.*;
 import javax.swing.*;

 public class IClient extends JFrame  {
     JPanel jp = new JPanel();
     JTextArea jta = new JTextArea();
     JScrollPane jsp = null;

     public IClient()
     {
         Toolkit t = Toolkit.getDefaultToolkit();
         Dimension Size =t.getScreenSize();
         int width =  Size.width;
         int height = Size.height;
         setLocationByPlatform(true);
         this.setAlwaysOnTop(true);
         jsp = new JScrollPane(jta);
         this.setTitle("接收方");
         this.add(jp);
         this.setSize(500, 400);
         this.setBounds((width - 500) / 2,
                 (height - 400) / 2, 600,500);
         this.add(jsp, BorderLayout.CENTER);
         this.setDefaultCloseOperation(EXIT_ON_CLOSE);
         this.setVisible(true);
     }
     public static void main(String[] args) throws UnknownHostException, IOException, InterruptedException {
             new IClient().Receive();
     }

     public void Receive() throws UnknownHostException, IOException, InterruptedException
     {
         Socket client = new Socket("localhost",9000);
         DataOutputStream dos = new DataOutputStream(client.getOutputStream());
         DataInputStream dis =new DataInputStream(client.getInputStream());
         int length = dis.read();                                //读取接收数据帧的长度
         //System.out.println(length);                                //输出要接受的数据的长度
         for(int i=0;i<length;i++)
         {
             char c = dis.readChar();                            //接收数据帧，判断是否正确
             if(c!='η'){                                            //CRC数据帧校验正确
                 Random ran=new java.util.Random();
                 int re=ran.nextInt(13);
                 if(re>=4){                                        //数据帧帧数正确
                     if(i<length-1)
                     {
                         if (jta.getText() == null || "".equals(jta.getText())) {
                             jta.append("Receive:" + "成功接收"+(i+1)+"号帧，内容为："+c);
                         } else {
                             jta.append("\r\nReceive:" + "成功接收"+(i+1)+"号帧，内容为："+c);
                         }
                         //System.out.println("成功接收"+(i+1)+"号帧，内容为："+c);    //输出接受到的数据帧
                         dos.writeInt(i+2);
                     }
                     else
                     {
                         if (jta.getText() == null || "".equals(jta.getText())) {
                             jta.append("Receive:" + "成功接收"+(i+1)+"号帧，内容为："+c);
                         } else {
                             jta.append("\r\nReceive:" + "成功接收"+(i+1)+"号帧，内容为："+c);
                         }

                         //System.out.println("成功接收"+(i+1)+"号帧，内容为："+c);
                         dos.writeInt(i+2);                        //向发送方返回确认帧
                         Thread.sleep(100);
                     }
                 }
                 else                                            //数据帧内容错误
                 {
                     if (jta.getText() == null || "".equals(jta.getText())) {
                         jta.append("Receive:" + "不是所需要的帧，丢弃等待!");
                     } else {
                         jta.append("\r\nReceive:" + "不是所需要的帧，丢弃等待!");
                     }
                     Thread.sleep(600);
                     //System.out.println("不是所需要的帧，丢弃等待!");
                     dos.writeInt(-1);
                     i=i-1;
                 }
             }
             else if(c=='η')                                        //CRC数据帧错误丢弃等待
             {
                 if (jta.getText() == null || "".equals(jta.getText())) {
                     jta.append("Receive:" + "数据帧错误！");
                 } else {
                     jta.append("\r\nReceive:" + "数据帧错误！");
                 }
                 //System.out.println("数据帧错误！");
                 i=i-1;
                 dos.writeInt(-2);
             }
         }
         if (jta.getText() == null || "".equals(jta.getText())) {
             jta.append( "接收信息成功！");
         } else {
             jta.append("\r\n" + "接收信息成功！");
         }
         jta.setEnabled(false);
         //System.out.println("接收信息成功！");
         client.close();
     }
 }

停止等待ARQ算法模拟

一、目的：

在两个程序通信的前提下，模拟实现停止等待ARQ协议。

要求模拟实现：

1. 正常数据帧的通信过程

2. 错误帧的通信过程

3. 数据帧的丢失的通信过程

二、实验内容与步骤

按照如下算法进行实现：

发方程序：

(1)   从主机取一个数据帧，送交发送缓存。

(2)   V(S)←0。

(3)   N(S)←V(S)。

(4)  将发送缓存中的数据帧发送出去。

(5)  设置超时计时器。

(6)   等待。

(7)  收到确认帧 ACKn，

若 n = 1 – V(s)，则：

从主机取一个新的数据帧，放入发送缓存；

V(S)←[1 - V(S)]，转到 (3)。

否则，丢弃这个确认帧，转到(6)。

(8)  若超时计时器时间到，则转到(4)。

收方：

(1)  V(R)←0。

(2)  等待。

(3)  收到一个数据帧；

若 CRC校验无误

若 N(S) = V(R)，则执行(4)；

否则丢弃此数据帧，然后转到(6)。

否则丢弃此数据帧，然后转到(2)。

(4)  将收到的数据帧中的数据部分送交上层软件

(5)  V(R)←[1 - V(R)]。

(6)  n←V(R)；

发送确认帧 ACKn，转到(2)。