实验一 网络诊断

一、实验目的：
通过实验掌握网络诊断的一些常用方法，了解网络协议特别是TCP/IP协议基本知识。
二、实验环境、内容和方法
实验环境：
工作站：WINDOWS 客户机连通校园网，并可以访问INTERNET
内容和方法：
网络诊断工具：
开始->运行->输入CMD然后回车->进入命令行状态->输入网络诊断命令。

1. 了解媒体访问层(MAC):
   输入: ipconfig/all 观察输出结果
   

 可选参数: 
   /release 释放当前通过DHCP获得的IP
   /renew 释放当前通过DHCP获得的IP并重新获得一个IP
   提示：上述二个命令只有是网卡的IP地址是设置为自动获取的才会有效果，设置为固定IP的将不会有什么变化。

   观察输出结果，并回答以下问题：
   利用IPCONFIG命令能查看到哪些地址信息？ 

  /displaydns 显示DNS缓存的记录.

2. NETSTAT
   Netstat是控制台命令,是一个监控TCP/IP网络的非常有用的工具，它可以显示路由表、实际的网络连接以及每一个网络接口设备的状态信息。Netstat用于显示与IP、TCP、UDP和ICMP协议相关的统计数据，一般用于检验本机各端口的网络连接情况。
   输入下列命令和参数, 观察输出结果
   netstat -a 显示建立在一个接口上的各种TCP和UDP会话
   

   netstat -e 显示以太网统计数据,包括有问题的数据包
   

   netstat -r 显示本地路由表的内容
   

   netstat -s 显示每个协议的统计数据
   
   

3. ping
   该命令是最常用的网络连通性测试的工具.
   网际消息协议 (ICMP)：
   可以使用 ping 命令发送 ICMP 回应请求消息并记录收到 ICMP 回应回复消息。使用这些消息，可以检测网络或主机通讯故障并解决常见的 TCP/IP 连接问题。
   ICMP 消息描述
   回应请求： 确定 IP 节点（主机或路由器）能否在网络上使用。
   回应回复： 回复 ICMP 回应请求。
   无法访问目标： 通知主机数据报无法传递。
   源减慢 ：通知主机由于拥挤而降低发送数据报的速率。
   重定向： 通知首选路由的主机。
   超时： 指明 IP 数据报的生存时间 (TTL) 已到期。
   参数：
   -t
   Ping 指定的计算机直到中断。
   -l length
   发送包含由 length 指定的数据量的 ECHO 数据包。默认为 32 字节；最大值是 65,527。
   ping www.jyu.edu.cn
   ping www.sina.com.cn
   
   

 观察输出结果，并回答以下问题：

（1）嘉应学院的网站的IP是多少?
答:www.jyu.edu.cn
（2）PING www.jyu.edu.cn显示PING不通，可能是什么原因造成的？
答：1.没有连接网络；2.对方装了防火墙。
（3）PING一个IP时，返回的结果中包含一个时间和TTL数值，这二个参数分别代表什么含义？由这个时间值能大致判断什么情况？
答：时间代表ping包需要返回的时间。单位为毫秒，TTL：TTL是IP协议包中的一个值，它告诉网络路由器包在网络中的时间是否太长而应被丢弃。有很多原因使包在一定时间内不能被传递到目的地。时间能大致判断网络质量的好坏。
（4）PING一个IP时，返回的结果中的TTL数值有些在240-255之间，有些在110-130之间，有些在50-65之间，这些不同的值相差很大，是什么原因？根据这些不同的数值能大致判断什么？
答：计算机的操作系统不一样，TTL 字段值可以帮助我们识别操作系统类型。UNIX 及类 UNIX 操作系统 ICMP 回显应答的 TTL 字段值为 255Compaq Tru64 5.0 ICMP 回显应答的 TTL 字段值为 64微软 Windows NT/2K操作系统 ICMP 回显应答的 TTL 字段值为 128微软 Windows 95 操作系统 ICMP 回显应答的 TTL 字段值为 32
4. tracert
该工具类似UNIX中的traceroute,它报告你的计算机和目的地之间的每个接口的IP地址和名称。如果PING 失败,用tracert可以知道问题出在那里.
如果有连通性问题，可以使用 tracert 命令来检查到达的目标 IP 地址的路径并记录结果。tracert 命令显示用于将数据包从计算机传递到目标位置的一组 IP 路由器，以及每个跃点所需的时间。如果数据包不能传递到目标，tracert 命令将显示成功转发数据包的最后一个路由器。
比较 tracert www.jyu.edu.cn
tracert www.sina.edu.cn

观察输出结果，并回答以下问题：

（1）tracert某一个网站显示的跳数跟PING同一个网站返回的TTL值有什么关联？如果你已经知道了PING一个网站的TTL值是45，能不能直接计算出tracert该网站的跳数？怎么计算的？
答：当信息包在网络中被传输时，TTL的域值通过一个路由器时递减1；当TTL 递减到0时，信息包被路由器抛弃。能，ttl每经过一个ip子层就减少1，UNIX 及类 UNIX 操作系统 ICMP 回显应答的 TTL 字段值为 255Compaq Tru64 5.0 ICMP 回显应答的 TTL 字段值为 64微软 Windows NT/2K操作系统 ICMP 回显应答的 TTL 字段值为 128，微软 Windows 95 操作系统 ICMP 回显应答的 TTL 字段值为 32，64-45=19。
pathping 命令是路由跟踪工具，它将 ping 和 tracert 命令的功能与非这些工具提供的其他信息组合在一起。经过一段时间，pathping 命令将数据包发送到最终目标位置途中经过的每个路由器。pathping 命令与工具tracert类似，请比较tracert的结果。

6. nslookup 

Nslookup显示可用来诊断域名系统 (DNS) 基础结构的信息。只有在已安装 TCP/IP 协议的情况下才可以使用 Nslookup 命令行工具。

 观察输出结果，并回答以下问题：

（1）输出结果中的域名解析的IP是怎么来的？如何判断当前的域名解析有没问题?
答：答：假设我们要开个网站，首先我们要去提供域名申请的机构申请域名，然后绑定一个IP地址，域名比较容易记忆，不像IP地址都是数字，申请完域名，绑定域名，DNS就写入域名对应的IP，别人进行登陆你的网站，就会通过DNS服务器进行解析还原成IP地址，然后就可以进行路由找到你的网站。
7. 其他WINDOWS的网络命令
可以输入net help 查看WIN2000支持的网络命令,并且可以用net help 命令名了解命令的作用和使用方法.
(1) net session 列出所有与本地计算机的连接
(2) net accounts
(3) net config workstation (or server)
(4) net send computer-name message
(5) net name
(6) net user
(7) net view
(8) net help services
提示：上述个别命令可能在WINDOWS中的某些版本的操作系统中并不支持，如不支持，可忽略。

8．编写一个进行域名解析的小程序。

调用：

NetPingManager netPingManager = new NetPingManager(mContext, "www.baidu.com", new NetPingManager.IOnNetPingListener() {
	@Override
	public void ontDelay(long log) {
		//todo 延迟ms
	}

	@Override
	public void onError() {
		//错误，网络不通
	}
});
netPingManager.startGetDelay();

NetPingManager 全部代码：

package tv.buka.roomSdk.util;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Build;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.text.TextUtils;

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 网络诊断服务 通过对指定域名进行ping
 * <p>
 * Created by hwk on 2018/7/6.
 */
public class NetPingManager {
    private String mDomain; // 接口域名
    private InetAddress[] mAddress;
    private List<String> mAddressIpList;
    private IOnNetPingListener mIOnNetPingListener; // 将监控日志上报到前段页面
    private HandlerThread mHandlerThread;

    private static int DELAY_TIME = 1000;
    private ConnectivityManager manager;
    private final Handler mHandleMessage;

    /**
     * 延迟
     */
    public void setDuration(int delay) {
        DELAY_TIME = delay;
    }

    /**
     * 初始化网络诊断服务
     */
    public NetPingManager(Context context, String domain, IOnNetPingListener theListener) {
        this.mDomain = domain;
        this.mIOnNetPingListener = theListener;
        this.mAddressIpList = new ArrayList<>();
        if (null != context)
            this.manager = (ConnectivityManager) context.getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
        this.mHandlerThread = new HandlerThread("ping");
        this.mHandlerThread.start();
        this.mHandleMessage = new Handler(mHandlerThread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case 0:
                        //每次请求清空上传集合
                        if (null != mAddressIpList)
                            mAddressIpList.clear();
                        startNetDiagnosis();
                        if (null != mHandlerThread)
                            mHandleMessage.sendEmptyMessageDelayed(0, DELAY_TIME);
                        break;
                }
            }
        };
    }

    /**
     * 开始监听
     */
    public void startGetDelay() {
        if (null != this.mHandleMessage) {
            this.mHandleMessage.sendEmptyMessage(0);
        }
    }

    /**
     * 释放
     */
    public void release() {
        synchronized (NetPingManager.class) {
            if (null != this.manager)
                this.manager = null;
            if (null != this.mHandleMessage) {
                this.mHandleMessage.removeMessages(0);
            }
            if (null != mHandlerThread) {
                Looper looper = this.mHandlerThread.getLooper();
                if (looper != null) {
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
                        looper.quitSafely();
                    } else {
                        looper.quit();
                    }
                }
            }
            this.mHandlerThread = null;
            this.mIOnNetPingListener = null;
            if (null != mAddressIpList)
                mAddressIpList.clear();
            this.mAddressIpList = null;
            this.manager = null;
        }
    }

    /**
     * 监控网络诊断的跟踪信息
     */
    public interface IOnNetPingListener {
        void ontDelay(long log);

        void onError();
    }

    /**
     * 开始诊断网络
     */
    private void startNetDiagnosis() {
        if (!TextUtils.isEmpty(this.mDomain)) {
            // 网络状态
            if (isNetworkConnected()) {
                parseDomain(this.mDomain);// 域名解析
                // TCP三次握手时间测试
                execUseJava();
            } else {
                if (null != mIOnNetPingListener) {
                    mIOnNetPingListener.onError();
                }
//                Log.e("tag", "当前主机未联网,请检查网络！");
            }
        }
    }

    /**
     * 使用java执行connected
     */
    private boolean execUseJava() {
        if (mAddress != null && mAddressIpList != null) {
            int len = mAddress.length;
            if (len > 1) {
                execIP(mAddress[0], mAddressIpList.get(0));
            }
        }
        return false;
    }

    private static final int PORT = 80;
    private static final int CONN_TIMES = 4;
    // 设置每次连接的timeout时间
    private int TIME_OUT = 6000;
    private final long[] RttTimes = new long[CONN_TIMES];// 用于存储三次测试中每次的RTT值

    /**
     * 返回某个IP进行5次connect的最终结果
     */
    private boolean execIP(InetAddress inetAddress, String ip) {
        boolean isConnected = true;
        InetSocketAddress socketAddress;
        if (inetAddress != null && ip != null) {
            socketAddress = new InetSocketAddress(inetAddress, PORT);
            int flag = 0;
            for (int i = 0; i < CONN_TIMES; i++) {
                execSocket(socketAddress, i);
                if (RttTimes[i] == -1) {// 一旦发生timeOut,则尝试加长连接时间
                    TIME_OUT += 4000;
                    if (i > 0 && RttTimes[i - 1] == -1) {// 连续两次连接超时,停止后续测试
                        flag = -1;
                        break;
                    }
                } else if (RttTimes[i] == -2) {
                    if (i > 0 && RttTimes[i - 1] == -2) {// 连续两次出现IO异常,停止后续测试
                        flag = -2;
                        break;
                    }
                }
            }
            long time = 0;
            int count = 0;
            if (flag == -1) {
                isConnected = false;
            } else if (flag == -2) {
                isConnected = false;
            } else {
                for (int i = 0; i < CONN_TIMES; i++) {
                    if (RttTimes[i] > 0) {
                        time += RttTimes[i];
                        count++;
                    }
                }
                if (count > 0) {
                    if (mIOnNetPingListener != null)
                        mIOnNetPingListener.ontDelay(time / count);
                }
            }
        } else {
            isConnected = false;
        }
        return isConnected;
    }

    /**
     * 针对某个IP第index次connect
     */
    private void execSocket(InetSocketAddress socketAddress, int index) {
        long start;
        long end;
        Socket mSocket = new Socket();
        try {
            start = System.currentTimeMillis();
            mSocket.connect(socketAddress, TIME_OUT);
            end = System.currentTimeMillis();
            RttTimes[index] = end - start;
        } catch (SocketTimeoutException e) {
            RttTimes[index] = -1;// 作为TIMEOUT标识
            e.printStackTrace();
        } catch (IOException e) {
            RttTimes[index] = -2;// 作为IO异常标识
            e.printStackTrace();
        } finally {
            if (mSocket != null) {
                try {
                    mSocket.close();
                } catch (IOException io) {
                    io.printStackTrace();
                }
            }
        }
    }

    /**
     * 判断网络是否连接
     */
    private Boolean isNetworkConnected() {
        if (manager == null) {
            return false;
        }
        try {
            NetworkInfo networkinfo = manager.getActiveNetworkInfo();
            return !(networkinfo == null || !networkinfo.isAvailable());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 域名解析
     */
    private boolean parseDomain(String domain) {
        boolean flag = false;
        Map<String, Object> map = getDomainIp(domain);
        String useTime = (String) map.get("useTime");
        mAddress = (InetAddress[]) map.get("remoteInet");
        if (mAddress != null) {// 解析正确
            mAddressIpList.add(mAddress[0].getHostAddress());
            flag = true;
        } else {// 解析不到，判断第一次解析耗时，如果大于10s进行第二次解析
            if (Integer.parseInt(useTime) > 10000) {
                map = getDomainIp(domain);
                mAddress = (InetAddress[]) map.get("remoteInet");
                if (mAddress != null) {
                    mAddressIpList.add(mAddress[0].getHostAddress());
                    flag = true;
                }
            }
        }
        return flag;
    }

    /**
     * 解析IP
     */
    private Map<String, Object> getDomainIp(String domain) {
        Map<String, Object> map = new HashMap<>();
        long start = 0;
        long end;
        String time = null;
        InetAddress[] remoteInet = null;
        try {
            start = System.currentTimeMillis();
            remoteInet = InetAddress.getAllByName(domain);
            if (remoteInet != null) {
                end = System.currentTimeMillis();
                time = (end - start) + "";
            }
        } catch (UnknownHostException e) {
            end = System.currentTimeMillis();
            time = (end - start) + "";
            remoteInet = null;
            e.printStackTrace();
        } finally {
            map.put("remoteInet", remoteInet);
            map.put("useTime", time);
        }
        return map;
    }
}