17 Commits

Author SHA1 Message Date
xiu2
166d9abe7c 修复 上个版本更新导致的 IPv6 测速报错的问题。 2020-12-09 16:42:50 +08:00
xiu2
f9c310bfb4 update 2020-12-06 08:20:57 +08:00
xiu2
0d54b65f33 新增 测速全部 IP、检查版本更新 2020-12-05 16:03:21 +08:00
xiu2
9f2e5b5b5e add ipv6.txt 2020-11-30 18:10:41 +08:00
XIU2
7b4f6944be 优化 打印帮助时末尾换行(避免在命令行和下一行命令混在一起)
Merge pull request #13 from zhangsean/master
2020-11-30 17:10:07 +08:00
zhangsean
00b569d649 打印帮助换行 2020-11-30 17:05:07 +08:00
xiu2
4b4426c195 新增 IPv6 支持 2020-11-30 16:41:01 +08:00
xiu2
ff3a6d1d56 update 2020-11-25 12:31:57 +08:00
xiu2
a78c6e6270 update 2020-11-15 18:30:39 +08:00
xiu2
6b52fbf5ea update 2020-11-13 14:42:06 +08:00
xiu2
25fa4b65d8 优化 仅 Windows 系统才需要按下 回车键 或 Ctrl+C 退出 2020-11-12 08:11:38 +08:00
xiu2
dca761ec72 update 2020-11-11 22:56:53 +08:00
xiu2
0f5b18b305 update 2020-11-11 22:48:03 +08:00
xiu2
4e1678edc3 update 2020-11-11 19:35:47 +08:00
xiu2
65b451ec4d update 2020-11-11 19:28:14 +08:00
xiu2
72ecee9e26 update 2020-11-11 19:26:31 +08:00
xiu2
1d9f64a4a2 update 2020-11-11 18:19:12 +08:00
6 changed files with 939 additions and 706 deletions

View File

@@ -1,40 +1,141 @@
package main package main
import ( import (
"bufio" "bufio"
"log" "log"
"net" "net"
"os" "os"
) "strconv"
"strings"
func loadFirstIPOfRangeFromFile(ipFile string) []net.IPAddr { )
file, err := os.Open(ipFile)
if err != nil { func getCidrHostNum(maskLen int) int {
log.Fatal(err) cidrIpNum := int(0)
} var i int = int(32 - maskLen - 1)
firstIPs := make([]net.IPAddr, 0) for ; i >= 1; i-- {
scanner := bufio.NewScanner(file) cidrIpNum += 1 << i
scanner.Split(bufio.ScanLines) }
for scanner.Scan() { return cidrIpNum
IPString := scanner.Text() }
firstIP, IPRange, err := net.ParseCIDR(IPString)
if err != nil { func loadFirstIPOfRangeFromFile(ipFile string) []net.IPAddr {
log.Fatal(err) file, err := os.Open(ipFile)
} if err != nil {
for IPRange.Contains(firstIP) { log.Fatal(err)
randipEndWith() // 随机 IP 的最后一段 }
firstIP[15] = ipEndWith firstIPs := make([]net.IPAddr, 0)
firstIPCopy := make([]byte, len(firstIP)) scanner := bufio.NewScanner(file)
copy(firstIPCopy, firstIP) scanner.Split(bufio.ScanLines)
firstIPs = append(firstIPs, net.IPAddr{IP: firstIPCopy}) for scanner.Scan() {
firstIP[14]++ IPString := scanner.Text()
if firstIP[14] == 0 { firstIP, IPRange, err := net.ParseCIDR(IPString)
firstIP[13]++ //fmt.Println(firstIP)
if firstIP[13] == 0 { //fmt.Println(IPRange)
firstIP[12]++ Mask, _ := strconv.Atoi(strings.Split(scanner.Text(), "/")[1])
} MaxIPNum := getCidrHostNum(Mask) - 1
} if MaxIPNum > 253 {
} MaxIPNum = 253
} }
return firstIPs //fmt.Println(MaxIPNum)
} if err != nil {
log.Fatal(err)
}
if ipv6Mode { // IPv6
var tempIP uint8
MaxIPNum = 254
for IPRange.Contains(firstIP) {
//fmt.Println(firstIP)
//fmt.Println(firstIP[0], firstIP[1], firstIP[2], firstIP[3], firstIP[4], firstIP[5], firstIP[6], firstIP[7], firstIP[8], firstIP[9], firstIP[10], firstIP[11], firstIP[12], firstIP[13], firstIP[14], firstIP[15])
firstIP[15] = randipEndWith(MaxIPNum) // 随机 IP 的最后一段
firstIP[14] = randipEndWith(MaxIPNum) // 随机 IP 的最后一段
firstIPCopy := make([]byte, len(firstIP))
copy(firstIPCopy, firstIP)
firstIPs = append(firstIPs, net.IPAddr{IP: firstIPCopy})
tempIP = firstIP[13]
firstIP[13] += randipEndWith(MaxIPNum)
if firstIP[13] < tempIP {
tempIP = firstIP[12]
firstIP[12] += randipEndWith(MaxIPNum)
if firstIP[12] < tempIP {
tempIP = firstIP[11]
firstIP[11] += randipEndWith(MaxIPNum)
if firstIP[11] < tempIP {
tempIP = firstIP[10]
firstIP[10] += randipEndWith(MaxIPNum)
if firstIP[10] < tempIP {
tempIP = firstIP[9]
firstIP[9] += randipEndWith(MaxIPNum)
if firstIP[9] < tempIP {
tempIP = firstIP[8]
firstIP[8] += randipEndWith(MaxIPNum)
if firstIP[8] < tempIP {
tempIP = firstIP[7]
firstIP[7] += randipEndWith(MaxIPNum)
if firstIP[7] < tempIP {
tempIP = firstIP[6]
firstIP[6] += randipEndWith(MaxIPNum)
if firstIP[6] < tempIP {
tempIP = firstIP[5]
firstIP[5] += randipEndWith(MaxIPNum)
if firstIP[5] < tempIP {
tempIP = firstIP[4]
firstIP[4] += randipEndWith(MaxIPNum)
if firstIP[4] < tempIP {
tempIP = firstIP[3]
firstIP[3] += randipEndWith(MaxIPNum)
if firstIP[3] < tempIP {
tempIP = firstIP[2]
firstIP[2] += randipEndWith(MaxIPNum)
if firstIP[2] < tempIP {
tempIP = firstIP[1]
firstIP[1] += randipEndWith(MaxIPNum)
if firstIP[1] < tempIP {
tempIP = firstIP[0]
firstIP[0] += randipEndWith(MaxIPNum)
}
}
}
}
}
}
}
}
}
}
}
}
}
}
} else { //IPv4
for IPRange.Contains(firstIP) {
//fmt.Println(firstIP)
//fmt.Println(firstIP[15])
if allip {
for i := 1; i < MaxIPNum+2; i++ {
firstIP[15] = uint8(i) // 随机 IP 的最后一段 0.0.0.X
//fmt.Println(firstIP)
firstIPCopy := make([]byte, len(firstIP))
copy(firstIPCopy, firstIP)
firstIPs = append(firstIPs, net.IPAddr{IP: firstIPCopy})
}
} else {
if firstIP[15] == 0 {
firstIP[15] = randipEndWith(MaxIPNum) // 随机 IP 的最后一段 0.0.0.X
}
firstIPCopy := make([]byte, len(firstIP))
copy(firstIPCopy, firstIP)
firstIPs = append(firstIPs, net.IPAddr{IP: firstIPCopy})
}
firstIP[15] = 0
firstIP[14]++ // 0.0.(X+1).X
if firstIP[14] == 0 {
firstIP[13]++ // 0.(X+1).X.X
if firstIP[13] == 0 {
firstIP[12]++ // (X+1).X.X.X
}
}
}
}
}
return firstIPs
}

311
README.md
View File

@@ -1,148 +1,163 @@
# XIU2/CloudflareSpeedTest # XIU2/CloudflareSpeedTest
[![Go Version](https://img.shields.io/github/go-mod/go-version/XIU2/CloudflareSpeedTest.svg?style=flat-square&label=Go&color=00ADD8)](https://github.com/XIU2/CloudflareSpeedTest/blob/master/go.mod) [![Go Version](https://img.shields.io/github/go-mod/go-version/XIU2/CloudflareSpeedTest.svg?style=flat-square&label=Go&color=00ADD8)](https://github.com/XIU2/CloudflareSpeedTest/blob/master/go.mod)
[![Release Version](https://img.shields.io/github/v/release/XIU2/CloudflareSpeedTest.svg?style=flat-square&label=Release&color=1784ff)](https://github.com/XIU2/CloudflareSpeedTest/releases/latest) [![Release Version](https://img.shields.io/github/v/release/XIU2/CloudflareSpeedTest.svg?style=flat-square&label=Release&color=1784ff)](https://github.com/XIU2/CloudflareSpeedTest/releases/latest)
[![GitHub license](https://img.shields.io/github/license/XIU2/CloudflareSpeedTest.svg?style=flat-square&label=License&color=f38020)](https://github.com/XIU2/CloudflareSpeedTest/blob/master/LICENSE) [![GitHub license](https://img.shields.io/github/license/XIU2/CloudflareSpeedTest.svg?style=flat-square&label=License&color=f38020)](https://github.com/XIU2/CloudflareSpeedTest/blob/master/LICENSE)
[![GitHub Star](https://img.shields.io/github/stars/XIU2/CloudflareSpeedTest.svg?style=flat-square&label=Star&color=f38020)](https://github.com/XIU2/CloudflareSpeedTest/stargazers) [![GitHub Star](https://img.shields.io/github/stars/XIU2/CloudflareSpeedTest.svg?style=flat-square&label=Star&color=f38020)](https://github.com/XIU2/CloudflareSpeedTest/stargazers)
[![GitHub Fork](https://img.shields.io/github/forks/XIU2/CloudflareSpeedTest.svg?style=flat-square&label=Fork&color=f38020)](https://github.com/XIU2/CloudflareSpeedTest/network/members) [![GitHub Fork](https://img.shields.io/github/forks/XIU2/CloudflareSpeedTest.svg?style=flat-square&label=Fork&color=f38020)](https://github.com/XIU2/CloudflareSpeedTest/network/members)
国外很多网站都在使用 Cloudflare CDN但分配给中国访客的 IP 并不友好。 国外很多网站都在使用 Cloudflare CDN但分配给中国访客的 IP 并不友好。
虽然 Cloudflare 公开了所有 [IP 段](https://www.cloudflare.com/ips/) ,但想要在这么多 IP 中找到适合自己的,怕是要累死,所以就有了这个软件。 虽然 Cloudflare 公开了所有 [IP 段](https://www.cloudflare.com/ips/) ,但想要在这么多 IP 中找到适合自己的,怕是要累死,所以就有了这个软件。
该软件可以**测试 Cloudflare CDN 所有 IP 的延迟和速度,获得最快 IP**!觉得好用请**点个⭐~** 该软件可以**测试 Cloudflare CDN 所有 IP 的延迟和速度,获得最快 IP**!觉得好用请**点个⭐鼓励一下下~**
你可以将 IP 添加到 `Hosts` 文件中,以提高访问使用 Cloudflare CDN 的网站速度! 将 IP 添加到 `Hosts` 文件或 DNS 程序中,以提高访问使用 Cloudflare CDN 的网站速度!
**** > 本项目也**适用于其他 CDN**,但是需要自行寻找 **CDN IP 段及下载测速地址**(否则只能延迟测速)!
## 快速使用
****
### 下载运行 ## 快速使用
1. 下载编译好的可执行文件 [蓝奏云](https://xiu.lanzoux.com/b0742hkxe) / [Github](https://github.com/XIU2/CloudflareSpeedTest/releases) 并解压。 ### 下载运行
2. 双击运行 `CloudflareST.exe`文件Windows等待测速...
1. 下载编译好的可执行文件 [蓝奏云](https://xiu.lanzoux.com/b0742hkxe) / [Github](https://github.com/XIU2/CloudflareSpeedTest/releases) 并解压。
> **注意Linux 系统**请先赋予执行权限 `chmod +x CloudflareST` ,然后再执行 `./CloudflareST` 。 2. 双击运行 `CloudflareST.exe`文件Windows等待测速...
### 结果示例 > **注意Linux 系统**请先赋予执行权限 `chmod +x CloudflareST` ,然后再执行 `./CloudflareST` 。
测速完毕后,会直接显示**最快的 20 个 IP**,示例: ### 结果示例
``` 测速完毕后,会直接显示**最快的 20 个 IP**,示例:
IP 地址 已发送 已接收 丢包率 平均延迟 下载速度 (MB/s)
104.27.199.141 4 4 0.00 139.52 11.71 ```
104.22.73.158 4 4 0.00 141.38 6.74 IP 地址 已发送 已接收 丢包率 平均延迟 下载速度 (MB/s)
104.27.204.240 4 4 0.00 142.02 4.65 104.27.198.101 4 4 0.00 126.52 12.71
104.22.72.117 4 4 0.00 143.63 12.00 104.22.43.157 4 4 0.00 129.38 16.74
104.22.75.117 4 4 0.00 145.75 3.92 104.27.214.140 4 4 0.00 132.02 4.65
104.22.77.24 4 4 0.00 146.00 5.86 104.22.42.165 4 4 0.00 133.63 12.00
104.22.66.140 4 4 0.00 146.50 9.47 104.22.35.177 4 4 0.00 135.75 3.92
104.22.78.104 4 4 0.00 146.75 13.00 104.22.87.44 4 4 0.00 136.00 5.86
104.22.69.208 4 4 0.00 147.00 19.07 104.22.67.122 4 4 0.00 136.50 9.47
104.27.194.10 4 4 0.00 148.02 21.05 104.22.88.154 4 4 0.00 140.75 13.00
... 104.22.69.218 4 4 0.00 142.00 19.07
``` 104.27.184.10 4 4 0.00 148.02 21.05
...
完整结果保存在当前目录下的 `result.csv` 文件中,用**记事本/表格软件**打开,排序为**延迟由低到高**,分别是: ```
> 大家可以按照自己的需求,对完整测速数据**进一步筛选处理** 完整结果保存在当前目录下的 `result.csv` 文件中,用**记事本/表格软件**打开,排序为**延迟由低到高**,分别是:
``` ```
IP 地址, 已发送, 已接收, 丢包率, 平均延迟, 下载速度 (MB/s) IP 地址, 已发送, 已接收, 丢包率, 平均延迟, 下载速度 (MB/s)
104.27.199.141, 4, 4, 0.00, 139.52, 11.71 104.27.199.141, 4, 4, 0.00, 139.52, 11.71
``` ```
> 大家可以按照自己的需求,对完整测速数据**进一步筛选处理**
选择一个平均延迟与下载速度都不错的 IP 放到 `Hosts` 文件中(指向使用 Cloudflare CDN 的网站域名)。
选择一个平均延迟与下载速度都不错的 IP 放到 `Hosts` 文件中(指向使用 Cloudflare CDN 的网站域名)。
****
## 进阶使用 ****
## 进阶使用
直接双击运行使用的是默认参数,如果想要测试速度更快、测试结果更全面,可以自定义参数。
直接双击运行使用的是默认参数,如果想要测试速度更快、测试结果更全面,可以自定义参数。
``` cmd
C:\>CloudflareST.exe -h ``` cmd
C:\>CloudflareST.exe -h
CloudflareSpeedTest
测试 Cloudflare CDN 所有 IP 的延迟和速度,获取最快 IP CloudflareSpeedTest vX.X.X
https://github.com/XIU2/CloudflareSpeedTest 测试 Cloudflare CDN 所有 IP 的延迟和速度,获取最快 IP
https://github.com/XIU2/CloudflareSpeedTest
参数:
-n 500 参数:
测速线程数量;数值越大速度越快,请勿超过 1000(结果误差大)(默认 500) -n 500
-t 4 测速线程数量;数值越大速度越快,请勿超过 1000(结果误差大)(默认 500)
延迟测速次数;单个 IP 测速次数,为 1 时将过滤丢包的IPTCP协议(默认 4) -t 4
-tp 443 延迟测速次数;单个 IP 测速次数,为 1 时将过滤丢包的IPTCP协议(默认 4)
延迟测速端口;延迟测速 TCP 协议的端口;(默认 443) -tp 443
-dn 20 延迟测速端口;延迟测速 TCP 协议的端口;(默认 443)
下载测速数量;延迟测速并排序后,从最低延迟起下载测速数量,请勿太多(速度慢)(默认 20) -dn 20
-dt 5 下载测速数量;延迟测速并排序后,从最低延迟起下载测速数量,请勿太多(速度慢)(默认 20)
下载测速时间;单个 IP 测速最长时间,单位:秒;(默认 5) -dt 5
-url https://cf.xiu2.xyz/Github/CloudflareSpeedTest.png 下载测速时间;单个 IP 测速最长时间,单位:秒;(默认 5)
下载测速地址;用来 Cloudflare CDN 测速的文件地址,如含有空格请加上引号; -url https://cf.xiu2.xyz/Github/CloudflareSpeedTest.png
-tl 200 下载测速地址;用来 Cloudflare CDN 测速的文件地址,如含有空格请加上引号;
延迟时间上限;只输出指定延迟时间以下的结果,数量为 -dn 参数的值单位ms -tl 200
-sl 5 延迟时间上限;只输出指定延迟时间以下的结果,数量为 -dn 参数的值单位ms
下载速度下限;只输出指定下载速度以上的结果,数量为 -dn 参数的值单位MB/s -sl 5
-p 20 下载速度下限;只输出指定下载速度以上的结果,数量为 -dn 参数的值单位MB/s
显示结果数量;测速后直接显示指定数量的结果,为 0 时不显示结果直接退出;(默认 20) -p 20
-f ip.txt 显示结果数量;测速后直接显示指定数量的结果,为 0 时不显示结果直接退出;(默认 20)
IP 数据文件;如含有空格请加上引号;支持其他 CDN IP段记得禁用下载测速(默认 ip.txt) -f ip.txt
-o result.csv IP 数据文件;如含有空格请加上引号;支持其他 CDN IP段记得禁用下载测速(默认 ip.txt)
输出结果文件;如含有空格请加上引号;为空格时不输出结果文件(-o " ");允许其他后缀;(默认 result.csv) -o result.csv
-dd 输出结果文件;如含有空格请加上引号;为空格时不输出结果文件(-o " ");允许其他后缀;(默认 result.csv)
禁用下载测速;如果带上该参数就是禁用下载测速;(默认 启用) -dd
-v 禁用下载测速;如果带上该参数就是禁用下载测速;(默认 启用)
打印程序版本 -ipv6
-h IPv6 测速模式;请确保 IP 数据文件内只包含 IPv6 IP段软件不支持同时测速 IPv4+IPv6(默认 IPv4)
打印帮助说明 -allip
``` 测速全部 IP如果带上该参数将会对每个 IP (仅 IPv4) 进行测速;(默认 每个 IP 段随机测速一个 IP)
-v
> 如果**下载速度都是 0.00**,那说明默认的**下载测速地址**用的人太多又到上限了,**请去这个 [Issues](https://github.com/XIU2/CloudflareSpeedTest/issues/6) 获得解决方法!** 打印程序版本+检查版本更新
-h
### 使用示例 打印帮助说明
```
在 CMD 中运行,或者把启动参数添加到快捷方式中。
> **提示: Linux 系统**只需要把下面命令中的 **.exe 删除**即可通用。 > 如果**下载速度都是 0.00**,那说明默认的**下载测速地址**用的人太多又到上限了,**请去这个 [Issues](https://github.com/XIU2/CloudflareSpeedTest/issues/6) 获得解决方法!**
``` bash ### 使用示例
# 注意:各参数均有默认值,只有不使用默认值时,才需要手动指定参数的值(按需选择),参数不分前后顺序。
# 提示: Linux 系统只需要把下面命令中的 .exe 删除即可通用 在 CMD 中运行,或者把启动参数添加到快捷方式中
# 指定 IP数据文件不显示结果直接退出-p 值为 0 ``` bash
CloudflareST.exe -p 0 -f ip.txt -dd # 命令行示例
# 注意:各参数均有默认值,只有不使用默认值时,才需要手动指定参数的值(按需选择),参数不分前后顺序。
# 指定 IP数据文件不输出结果到文件直接显示结果-p 值为 10 条) # 提示: Linux 系统只需要把下面命令中的 CloudflareST.exe 改为 ./CloudflareST 即可。
CloudflareST.exe -p 10 -f ip.txt -o " " -dd
# 指定 IPv4 数据文件,不显示结果直接退出(-p 值为 0
# 指定 IP数据文件 及 输出结果到文件(相对路径,即当前目录下,如果包含空格请加上引号) CloudflareST.exe -p 0 -f ip.txt -dd
CloudflareST.exe -f ip.txt -o result.csv -dd
# 指定 IPv6 数据文件( ipv6.txt ),不显示结果直接退出(-p 值为 0
# 指定 IP数据文件 及 输出结果到文件(绝对路径,即 C:\abc\ 目录下,如果包含空格请加上引号) CloudflareST.exe -p 0 -f ipv6.txt -dd -ipv6
CloudflareST.exe -f C:\abc\ip.txt -o C:\abc\result.csv -dd
# 指定 IPv4 数据文件,不输出结果到文件,直接显示结果(-p 值为 10 条)
# 指定下载测速地址(要求:可以直接下载的文件、文件大小超过 200MB、网站用的是 Cloudflare CDN如果包含空格请加上引号 CloudflareST.exe -p 10 -f ip.txt -o " " -dd
CloudflareST.exe -url https://cf.xiu2.xyz/Github/CloudflareSpeedTest.png
# 指定 IPv4 数据文件 及 输出结果到文件(相对路径,即当前目录下,如果包含空格请加上引号)
# 指定测速条件延迟时间上限200 ms下载速度下限0 MB/s数量10 个(只有同时满足三个条件时才会停止测速) CloudflareST.exe -f ip.txt -o result.csv -dd
CloudflareST.exe -tl 200 -dn 10
# 指定 IPv4 数据文件 及 输出结果到文件(绝对路径,即 C:\abc\ 目录下,如果包含空格请加上引号)
# 指定测速条件延迟时间上限0 ms下载速度下限5 MB/s数量10 个(只有同时满足三个条件时才会停止测速) CloudflareST.exe -f C:\abc\ip.txt -o C:\abc\result.csv -dd
CloudflareST.exe -sl 5 -dn 10
# 指定下载测速地址(要求:可以直接下载、文件大小超过 200MB、用的是 Cloudflare CDN如果包含空格请加上引号
# 指定测速条件延迟时间上限200 ms下载速度下限5 MB/s数量10 个(只有同时满足三个条件时才会停止测速) CloudflareST.exe -url https://cf.xiu2.xyz/Github/CloudflareSpeedTest.png
CloudflareST.exe -tl 200 -sl 5 -dn 10
``` # 指定测速条件(只有同时满足三个条件时才会停止测速):
# 延迟时间上限200 ms下载速度下限0 MB/s数量10 个
``` cmd CloudflareST.exe -tl 200 -dn 10
# 快捷方式示例(右键快捷方式 - 目标)
## 如果有引号就放在引号外面,记得引号和 - 之间有空格。 # 延迟时间上限0 ms下载速度下限5 MB/s数量10 个
"D:\Program Files\CloudflareST\CloudflareST.exe" -n 500 -t 4 -dn 20 -dt 5 CloudflareST.exe -sl 5 -dn 10
```
# 延迟时间上限200 ms下载速度下限5 MB/s数量10 个
**** CloudflareST.exe -tl 200 -sl 5 -dn 10
## 感谢项目
* https://github.com/Spedoske/CloudflareScanner # 如果一直凑不够指定数量,会一直测速下去。
# 建议指定下载速度下限时,同时指定延迟时间上限,如果测试到指定延迟还没凑够数,就会终止测速。
意外发现了这个项目,看了之后发现正好解决了我的问题,但是我更喜欢用户命令行方式运行,这样会更方便、有更多使用姿势,于是我临时学了下 Golang 并 Fork 按照我自己的需求修改了一下(包括但不限于命令行方式交互、直接输出结果等),如果有什么问题可以告诉我,虽然我不一定会~ # 如果一个满足条件的 IP 都没有,那么就会正常输出结果(和不指定条件一样)。
# 如果你需要通过外部程序进一步筛选处理,那么只需要判断测速结果数量,如果上千个说明一个满足条件的 IP 都没有。
**** ```
## 许可证
The GPL-3.0 License. ``` cmd
# Windows 快捷方式示例(右键快捷方式 - 目标)
## 如果有引号就放在引号外面,记得引号和 - 之间有空格。
### 如果要不输出结果文件,那么请加上 -o " ",引号里的是空格。
"D:\Program Files\CloudflareST\CloudflareST.exe" -n 500 -t 4 -dn 20 -dt 5
```
****
## 感谢项目
* https://github.com/Spedoske/CloudflareScanner
意外发现了这个项目,看了之后发现正好解决了我的问题,但是我更喜欢用户命令行方式运行,这样会更方便、有更多使用姿势,于是我临时学了下 Golang 并 Fork 按照我自己的需求修改了一下(包括但不限于命令行方式交互、直接输出结果等),如果有什么问题可以告诉我,虽然我不一定会~
****
## 许可证
The GPL-3.0 License.

42
ipv6.txt Normal file
View File

@@ -0,0 +1,42 @@
2606:4700:10::6814:0/112
2606:4700:10::ac43:0/112
2606:4700:3000::/48
2606:4700:3001::/48
2606:4700:3002::/48
2606:4700:3003::/48
2606:4700:3004::/48
2606:4700:3005::/48
2606:4700:3006::/48
2606:4700:3007::/48
2606:4700:3008::/48
2606:4700:3009::/48
2606:4700:3010::/48
2606:4700:3011::/48
2606:4700:3012::/48
2606:4700:3013::/48
2606:4700:3014::/48
2606:4700:3015::/48
2606:4700:3016::/48
2606:4700:3017::/48
2606:4700:3018::/48
2606:4700:3019::/48
2606:4700:3020::/48
2606:4700:3021::/48
2606:4700:3022::/48
2606:4700:3023::/48
2606:4700:3024::/48
2606:4700:3025::/48
2606:4700:3026::/48
2606:4700:3027::/48
2606:4700:3028::/48
2606:4700:3029::/48
2606:4700:3030::/48
2606:4700:3031::/48
2606:4700:3032::/48
2606:4700:3033::/48
2606:4700:3034::/48
2606:4700:3035::/48
2606:4700:3036::/48
2606:4700:3037::/48
2606:4700:3038::/48
2606:4700:3039::/48

491
main.go
View File

@@ -1,219 +1,272 @@
package main package main
import ( import (
"flag" "flag"
"fmt" "fmt"
"os" "io/ioutil"
"sort" "net/http"
"strconv" "os"
"sync" "runtime"
"time" "sort"
"strconv"
"github.com/cheggaaa/pb/v3" "sync"
) "time"
var version string "github.com/cheggaaa/pb/v3"
var disableDownload bool )
var tcpPort int
var ipFile string var version, ipFile, outputFile, versionNew string
var outputFile string var disableDownload, ipv6Mode, allip bool
var printResultNum int var tcpPort, printResultNum, timeLimit, speedLimit int
var timeLimit int
var speedLimit int func init() {
var downloadSecond int64
func init() { var printVersion bool
var downloadSecond int64 var help = `
var printVersion bool CloudflareSpeedTest ` + version + `
var help = ` 测试 Cloudflare CDN 所有 IP 的延迟和速度,获取最快 IP
CloudflareSpeedTest ` + version + ` https://github.com/XIU2/CloudflareSpeedTest
测试 Cloudflare CDN 所有 IP 的延迟和速度,获取最快 IP
https://github.com/XIU2/CloudflareSpeedTest 参数:
-n 500
参数: 测速线程数量;数值越大速度越快,请勿超过 1000(结果误差大)(默认 500)
-n 500 -t 4
测速线程数量;数值越大速度越快,请勿超过 1000(结果误差大)(默认 500) 延迟测速次数;单个 IP 测速次数,为 1 时将过滤丢包的IPTCP协议(默认 4)
-t 4 -tp 443
延迟测速次数;单个 IP 测速次数,为 1 时将过滤丢包的IPTCP协议(默认 4) 延迟测速端口;延迟测速 TCP 协议的端口(默认 443)
-tp 443 -dn 20
延迟测速端口;延迟测速 TCP 协议的端口(默认 443) 下载测速数量;延迟测速并排序后,从最低延迟起下载测速数量,请勿太多(速度慢)(默认 20)
-dn 20 -dt 5
下载测速数量;延迟测速并排序后,从最低延迟起下载测速数量,请勿太多(速度慢)(默认 20) 下载测速时间;单个 IP 测速最长时间,单位:秒(默认 5)
-dt 5 -url https://cf.xiu2.xyz/Github/CloudflareSpeedTest.png
下载测速时间;单个 IP 测速最长时间,单位:秒;(默认 5) 下载测速地址;用来 Cloudflare CDN 测速的文件地址,如含有空格请加上引号;
-url https://cf.xiu2.xyz/Github/CloudflareSpeedTest.png -tl 200
下载测速地址;用来 Cloudflare CDN 测速的文件地址,如含有空格请加上引号 延迟时间上限;只输出指定延迟时间以下的结果,数量为 -dn 参数的值单位ms
-tl 200 -sl 5
延迟时间上限;只输出指定延迟时间以下的结果,数量为 -dn 参数的值,单位:ms 下载速度下限;只输出指定下载速度以上的结果,数量为 -dn 参数的值,单位:MB/s
-sl 5 -p 20
下载速度下限;只输出指定下载速度以上的结果,数量为 -dn 参数的值单位MB/s 显示结果数量;测速后直接显示指定数量的结果,值为 0 时不显示结果直接退出;(默认 20)
-p 20 -f ip.txt
显示结果数量;测速后直接显示指定数量的结果,值为 0 时不显示结果直接退出;(默认 20) IP 数据文件;如含有空格请加上引号;支持其他 CDN IP段记得禁用下载测速(默认 ip.txt)
-f ip.txt -o result.csv
IP 数据文件;如含有空格请加上引号;支持其他 CDN IP段记得禁用下载测速(默认 ip.txt) 输出结果文件;如含有空格请加上引号;为空格时不输出结果文件(-o " ");允许其他后缀;(默认 result.csv)
-o result.csv -dd
输出结果文件;如含有空格请加上引号;为空格时不输出结果文件(-o " ");允许其他后缀;(默认 result.csv) 禁用下载测速;如果带上该参数将会禁用下载测速;(默认 启用下载测速)
-dd -ipv6
禁用下载测速;如果带上该参数就是禁用下载测速(默认 启用) IPv6 测速模式;请确保 IP 数据文件内只包含 IPv6 IP段软件不支持同时测速 IPv4+IPv6(默认 IPv4)
-v -allip
打印程序版本 测速全部 IP如果带上该参数将会对每个 IP (仅 IPv4) 进行测速;(默认 每个 IP 段随机测速一个 IP)
-h -v
打印帮助说明` 打印程序版本+检查版本更新
-h
flag.IntVar(&pingRoutine, "n", 500, "测速线程数量") 打印帮助说明
flag.IntVar(&pingTime, "t", 4, "延迟测速次数") `
flag.IntVar(&tcpPort, "tp", 443, "延迟测速端口")
flag.IntVar(&downloadTestCount, "dn", 20, "下载测速数量") flag.IntVar(&pingRoutine, "n", 500, "测速线程数量")
flag.Int64Var(&downloadSecond, "dt", 5, "下载测速时间") flag.IntVar(&pingTime, "t", 4, "延迟测速次数")
flag.StringVar(&url, "url", "https://cf.xiu2.xyz/Github/CloudflareSpeedTest.png", "下载测速地址") flag.IntVar(&tcpPort, "tp", 443, "延迟测速端口")
flag.IntVar(&timeLimit, "tl", 0, "延迟时间上限") flag.IntVar(&downloadTestCount, "dn", 20, "下载测速数量")
flag.IntVar(&speedLimit, "sl", 0, "下载速度下限") flag.Int64Var(&downloadSecond, "dt", 5, "下载测速时间")
flag.IntVar(&printResultNum, "p", 20, "显示结果数量") flag.StringVar(&url, "url", "https://cf.xiu2.xyz/Github/CloudflareSpeedTest.png", "下载测速地址")
flag.BoolVar(&disableDownload, "dd", false, "禁用下载测速") flag.IntVar(&timeLimit, "tl", 0, "延迟时间上限")
flag.StringVar(&ipFile, "f", "ip.txt", "IP 数据文件") flag.IntVar(&speedLimit, "sl", 0, "下载速度下限")
flag.StringVar(&outputFile, "o", "result.csv", "输出结果文件") flag.IntVar(&printResultNum, "p", 20, "显示结果数量")
flag.BoolVar(&printVersion, "v", false, "打印程序版本") flag.BoolVar(&disableDownload, "dd", false, "禁用下载测速")
flag.BoolVar(&ipv6Mode, "ipv6", false, "禁用下载测速")
downloadTestTime = time.Duration(downloadSecond) * time.Second flag.BoolVar(&allip, "allip", false, "测速全部 IP")
flag.StringVar(&ipFile, "f", "ip.txt", "IP 数据文件")
flag.Usage = func() { fmt.Print(help) } flag.StringVar(&outputFile, "o", "result.csv", "输出结果文件")
flag.Parse() flag.BoolVar(&printVersion, "v", false, "打印程序版本")
if printVersion {
println(version) downloadTestTime = time.Duration(downloadSecond) * time.Second
os.Exit(0)
} flag.Usage = func() { fmt.Print(help) }
if pingRoutine <= 0 { flag.Parse()
pingRoutine = 500 if printVersion {
} println(version)
if pingTime <= 0 { fmt.Println("检查版本更新中...")
pingTime = 4 checkUpdate()
} if versionNew != "" {
if tcpPort < 1 || tcpPort > 65535 { fmt.Println("发现新版本 [" + versionNew + "]!请前往 [https://github.com/XIU2/CloudflareSpeedTest] 更新!")
tcpPort = 443 } else {
} fmt.Println("当前为最新版本 [" + version + "]")
if downloadTestCount <= 0 { }
downloadTestCount = 20 os.Exit(0)
} }
if downloadSecond <= 0 { if pingRoutine <= 0 {
downloadSecond = 10 pingRoutine = 500
} }
if url == "" { if pingTime <= 0 {
url = "https://cf.xiu2.xyz/Github/CloudflareSpeedTest.png" pingTime = 4
} }
if timeLimit <= 0 { if tcpPort < 1 || tcpPort > 65535 {
timeLimit = 9999 tcpPort = 443
} }
if speedLimit < 0 { if downloadTestCount <= 0 {
speedLimit = 0 downloadTestCount = 20
} }
if printResultNum < 0 { if downloadSecond <= 0 {
printResultNum = 20 downloadSecond = 10
} }
if ipFile == "" { if url == "" {
ipFile = "ip.txt" url = "https://cf.xiu2.xyz/Github/CloudflareSpeedTest.png"
} }
if outputFile == " " { if timeLimit <= 0 {
outputFile = "" timeLimit = 9999
} }
} if speedLimit < 0 {
speedLimit = 0
func main() { }
initRandSeed() // 置随机数种子 if printResultNum < 0 {
failTime = pingTime // 设置接收次数 printResultNum = 20
ips := loadFirstIPOfRangeFromFile(ipFile) // 读入IP }
pingCount := len(ips) * pingTime // 计算进度条总数IP*测试次数) if ipFile == "" {
bar := pb.Simple.Start(pingCount) // 进度条总数 ipFile = "ip.txt"
var wg sync.WaitGroup }
var mu sync.Mutex if outputFile == " " {
var data = make([]CloudflareIPData, 0) outputFile = ""
var data_2 = make([]CloudflareIPData, 0) }
}
fmt.Println("# XIU2/CloudflareSpeedTest " + version + "\n")
fmt.Println("开始延迟测速模式TCP端口" + strconv.Itoa(tcpPort) + "") func main() {
control := make(chan bool, pingRoutine) go checkUpdate() // 检查版本更新
for _, ip := range ips { initRandSeed() // 置随机数种子
wg.Add(1) failTime = pingTime // 设置接收次数
control <- false ips := loadFirstIPOfRangeFromFile(ipFile) // 读入IP
handleProgress := handleProgressGenerator(bar) // 多线程进度条 pingCount := len(ips) * pingTime // 计算进度条总数IP*测试次数)
go tcpingGoroutine(&wg, &mu, ip, tcpPort, pingTime, &data, control, handleProgress) bar := pb.Simple.Start(pingCount) // 进度条总数
} var wg sync.WaitGroup
wg.Wait() var mu sync.Mutex
bar.Finish() var data = make([]CloudflareIPData, 0)
var data_2 = make([]CloudflareIPData, 0)
sort.Sort(CloudflareIPDataSet(data)) // 排序
fmt.Println("# XIU2/CloudflareSpeedTest " + version + "\n")
// 下载测速 if ipv6Mode {
if !disableDownload { // 如果禁用下载测速就跳过 fmt.Println("开始延迟测速模式TCP IPv6端口" + strconv.Itoa(tcpPort) + "")
if len(data) > 0 { // IP数组长度(IP数量) 大于 0 时继续 } else {
if len(data) < downloadTestCount { // 如果IP数组长度(IP数量) 小于 下载测速次数则次数改为IP数 fmt.Println("开始延迟测速模式TCP IPv4端口" + strconv.Itoa(tcpPort) + "")
//fmt.Println("\n[信息] IP 数量小于下载测速次数(" + strconv.Itoa(downloadTestCount) + " < " + strconv.Itoa(len(data)) + "下载测速次数改为IP数。\n") }
downloadTestCount = len(data) control := make(chan bool, pingRoutine)
for _, ip := range ips {
} wg.Add(1)
var downloadTestCount_2 int // 临时的下载测速次数 control <- false
if timeLimit == 9999 && speedLimit == 0 { handleProgress := handleProgressGenerator(bar) // 多线程进度条
downloadTestCount_2 = downloadTestCount // 如果没有指定条件,则临时的下载次数变量为下载测速次数 go tcpingGoroutine(&wg, &mu, ip, tcpPort, pingTime, &data, control, handleProgress)
fmt.Println("开始下载测速:") }
} else if timeLimit > 0 || speedLimit >= 0 { wg.Wait()
downloadTestCount_2 = len(data) // 如果指定了任意一个条件,则临时的下载次数变量改为总数量 bar.Finish()
fmt.Println("开始下载测速(延迟时间上限:" + strconv.Itoa(timeLimit) + " ms下载速度下限" + strconv.Itoa(speedLimit) + " MB/s")
} sort.Sort(CloudflareIPDataSet(data)) // 排序
bar = pb.Simple.Start(downloadTestCount_2)
for i := 0; i < downloadTestCount_2; i++ { // 下载测速
_, speed := DownloadSpeedHandler(data[i].ip) if !disableDownload { // 如果禁用下载测速就跳过
data[i].downloadSpeed = speed if len(data) > 0 { // IP数组长度(IP数量) 大于 0 时继续
bar.Add(1) if len(data) < downloadTestCount { // 如果IP数组长度(IP数量) 小于 下载测速次数则次数改为IP数
if int(data[i].pingTime) <= timeLimit && int(float64(speed)/1024/1024) >= speedLimit { //fmt.Println("\n[信息] IP 数量小于下载测速次数(" + strconv.Itoa(downloadTestCount) + " < " + strconv.Itoa(len(data)) + "下载测速次数改为IP数。\n")
data_2 = append(data_2, data[i]) // 延迟和速度均满足条件时,添加到新数组中 downloadTestCount = len(data)
if len(data_2) == downloadTestCount { // 满足条件的 IP =下载测速次数,则跳出循环 }
break var downloadTestCount_2 int // 临时的下载测速次数
} if timeLimit == 9999 && speedLimit == 0 {
} else if int(data[i].pingTime) > timeLimit { downloadTestCount_2 = downloadTestCount // 如果没有指定条件,则临时的下载次数变量为下载测速次数
break fmt.Println("开始下载测速:")
} } else if timeLimit > 0 || speedLimit >= 0 {
} downloadTestCount_2 = len(data) // 如果指定了任意一个条件,则临时的下载次数变量改为总数量
bar.Finish() fmt.Println("开始下载测速(延迟时间上限:" + strconv.Itoa(timeLimit) + " ms下载速度下限" + strconv.Itoa(speedLimit) + " MB/s")
} else { }
fmt.Println("\n[信息] IP数量为 0跳过下载测速。") bar = pb.Simple.Start(downloadTestCount_2)
} for i := 0; i < downloadTestCount_2; i++ {
} _, speed := DownloadSpeedHandler(data[i].ip)
data[i].downloadSpeed = speed
if len(data_2) > 0 { // 如果该数字有内容,说明进行过指定条件的下载测速 bar.Add(1)
if outputFile != "" { if int(data[i].pingTime) <= timeLimit && int(float64(speed)/1024/1024) >= speedLimit {
ExportCsv(outputFile, data_2) // 输出结果到文件(指定延迟时间或下载速度的) data_2 = append(data_2, data[i]) // 延迟和速度均满足条件时,添加到新数组中
} if len(data_2) == downloadTestCount { // 满足条件的 IP =下载测速次数,则跳出循环
printResult(data_2) // 显示最快结果(指定延迟时间或下载速度的) break
} else { }
if outputFile != "" { } else if int(data[i].pingTime) > timeLimit {
ExportCsv(outputFile, data) // 输出结果到文件 break
} }
printResult(data) // 显示最快结果 }
} bar.Finish()
} } else {
fmt.Println("\n[信息] IP数量为 0跳过下载测速。")
// 显示最快结果 }
func printResult(data []CloudflareIPData) { }
if printResultNum > 0 { // 如果禁用下载测速就跳过
dateString := convertToString(data) // 转为多维数组 [][]String if len(data_2) > 0 { // 如果该数字有内容,说明进行过指定条件的下载测速
if len(dateString) > 0 { // IP数组长度(IP数量) 大于 0 时继续 if outputFile != "" {
if len(dateString) < printResultNum { // 如果IP数组长度(IP数量) 小于 打印次数则次数改为IP数量 ExportCsv(outputFile, data_2) // 输出结果到文件(指定延迟时间或下载速度的)
//fmt.Println("\n[信息] IP 数量小于显示结果数量(" + strconv.Itoa(printResultNum) + " < " + strconv.Itoa(len(dateString)) + "显示结果数量改为IP数量。\n") }
printResultNum = len(dateString) printResult(data_2) // 显示最快结果(指定延迟时间或下载速度的)
} } else {
fmt.Printf("%-16s%-5s%-5s%-5s%-6s%-11s\n", "IP 地址", "已发送", "已接收", "丢包率", "平均延迟", "下载速度 (MB/s)") if outputFile != "" {
for i := 0; i < printResultNum; i++ { ExportCsv(outputFile, data) // 输出结果到文件
fmt.Printf("%-18s%-8s%-8s%-8s%-10s%-15s\n", ipPadding(dateString[i][0]), dateString[i][1], dateString[i][2], dateString[i][3], dateString[i][4], dateString[i][5]) }
} printResult(data) // 显示最快结果
if outputFile != "" { }
fmt.Printf("\n完整测速结果已写入 %v 文件,请使用记事本/表格软件查看。\n按下 回车键 或 Ctrl+C 退出。", outputFile) }
} else {
fmt.Printf("\n请按 回车键 或 Ctrl+C 退出。") // 显示最快结果
} func printResult(data []CloudflareIPData) {
var pause int sysType := runtime.GOOS
fmt.Scanln(&pause) if printResultNum > 0 { // 如果禁止直接输出结果就跳过
} else { dateString := convertToString(data) // 转为多维数组 [][]String
fmt.Println("\n[信息] IP数量为 0跳过输出结果。") if len(dateString) > 0 { // IP数组长度(IP数量) 大于 0 时继续
} if len(dateString) < printResultNum { // 如果IP数组长度(IP数量) 小于 打印次数则次数改为IP数量
} else { //fmt.Println("\n[信息] IP 数量小于显示结果数量(" + strconv.Itoa(printResultNum) + " < " + strconv.Itoa(len(dateString)) + "显示结果数量改为IP数量。\n")
fmt.Printf("\n测速结果已写入 %v 文件,请使用记事本/表格软件查看。", outputFile) printResultNum = len(dateString)
} }
} if ipv6Mode { // IPv6 太长了,所以需要调整一下间隔
fmt.Printf("%-40s%-5s%-5s%-5s%-6s%-11s\n", "IP 地址", "已发送", "已接收", "丢包率", "平均延迟", "下载速度 (MB/s)")
for i := 0; i < printResultNum; i++ {
fmt.Printf("%-42s%-8s%-8s%-8s%-10s%-15s\n", ipPadding(dateString[i][0]), dateString[i][1], dateString[i][2], dateString[i][3], dateString[i][4], dateString[i][5])
}
} else {
fmt.Printf("%-16s%-5s%-5s%-5s%-6s%-11s\n", "IP 地址", "已发送", "已接收", "丢包率", "平均延迟", "下载速度 (MB/s)")
for i := 0; i < printResultNum; i++ {
fmt.Printf("%-18s%-8s%-8s%-8s%-10s%-15s\n", ipPadding(dateString[i][0]), dateString[i][1], dateString[i][2], dateString[i][3], dateString[i][4], dateString[i][5])
}
}
if versionNew != "" {
fmt.Println("\n发现新版本 [" + versionNew + "]!请前往 [https://github.com/XIU2/CloudflareSpeedTest] 更新!")
}
if sysType == "windows" { // 如果是 Windows 系统,则需要按下 回车键 或 Ctrl+C 退出
if outputFile != "" {
fmt.Printf("\n完整测速结果已写入 %v 文件,请使用记事本/表格软件查看。\n按下 回车键 或 Ctrl+C 退出。", outputFile)
} else {
fmt.Printf("\n按下 回车键 或 Ctrl+C 退出。")
}
var pause int
fmt.Scanln(&pause)
} else { // 其它系统直接退出
if outputFile != "" {
fmt.Println("\n完整测速结果已写入 " + outputFile + " 文件,请使用记事本/表格软件查看。")
}
}
} else {
fmt.Println("\n[信息] IP数量为 0跳过输出结果。")
}
} else {
fmt.Println("\n完整测速结果已写入 " + outputFile + " 文件,请使用记事本/表格软件查看。")
}
}
// 检查更新
func checkUpdate() {
timeout := time.Duration(10 * time.Second)
client := http.Client{Timeout: timeout}
res, err := client.Get("https://api.xiuer.pw/ver/cloudflarespeedtest.txt")
if err == nil {
// 读取资源数据 body: []byte
body, err := ioutil.ReadAll(res.Body)
// 关闭资源流
res.Body.Close()
if err == nil {
if string(body) != version {
versionNew = string(body)
}
}
}
}

333
tcping.go
View File

@@ -1,160 +1,173 @@
package main package main
import ( import (
"context" "context"
"io" "io"
"net" "net"
"net/http" "net/http"
"strconv" "strconv"
"sync" "sync"
"time" "time"
"github.com/VividCortex/ewma" "github.com/VividCortex/ewma"
) )
//bool connectionSucceed float32 time //bool connectionSucceed float32 time
func tcping(ip net.IPAddr, tcpPort int) (bool, float32) { func tcping(ip net.IPAddr, tcpPort int) (bool, float32) {
startTime := time.Now() startTime := time.Now()
conn, err := net.DialTimeout("tcp", ip.String()+":"+strconv.Itoa(tcpPort), tcpConnectTimeout) var fullAddress string
if err != nil { //fmt.Println(ip.String())
return false, 0 if ipv6Mode { // IPv6 需要加上 []
} else { fullAddress = "[" + ip.String() + "]:" + strconv.Itoa(tcpPort)
var endTime = time.Since(startTime) } else {
var duration = float32(endTime.Microseconds()) / 1000.0 fullAddress = ip.String() + ":" + strconv.Itoa(tcpPort)
_ = conn.Close() }
return true, duration conn, err := net.DialTimeout("tcp", fullAddress, tcpConnectTimeout)
} if err != nil {
} return false, 0
} else {
//pingReceived pingTotalTime var endTime = time.Since(startTime)
func checkConnection(ip net.IPAddr, tcpPort int) (int, float32) { var duration = float32(endTime.Microseconds()) / 1000.0
pingRecv := 0 _ = conn.Close()
var pingTime float32 = 0.0 return true, duration
for i := 1; i <= failTime; i++ { }
pingSucceed, pingTimeCurrent := tcping(ip, tcpPort) }
if pingSucceed {
pingRecv++ //pingReceived pingTotalTime
pingTime += pingTimeCurrent func checkConnection(ip net.IPAddr, tcpPort int) (int, float32) {
} pingRecv := 0
} var pingTime float32 = 0.0
return pingRecv, pingTime for i := 1; i <= failTime; i++ {
} pingSucceed, pingTimeCurrent := tcping(ip, tcpPort)
if pingSucceed {
//return Success packetRecv averagePingTime specificIPAddr pingRecv++
func tcpingHandler(ip net.IPAddr, tcpPort int, pingCount int, progressHandler func(e progressEvent)) (bool, int, float32, net.IPAddr) { pingTime += pingTimeCurrent
ipCanConnect := false }
pingRecv := 0 }
var pingTime float32 = 0.0 return pingRecv, pingTime
for !ipCanConnect { }
pingRecvCurrent, pingTimeCurrent := checkConnection(ip, tcpPort)
if pingRecvCurrent != 0 { //return Success packetRecv averagePingTime specificIPAddr
ipCanConnect = true func tcpingHandler(ip net.IPAddr, tcpPort int, pingCount int, progressHandler func(e progressEvent)) (bool, int, float32, net.IPAddr) {
pingRecv = pingRecvCurrent ipCanConnect := false
pingTime = pingTimeCurrent pingRecv := 0
} else { var pingTime float32 = 0.0
ip.IP[15]++ for !ipCanConnect {
if ip.IP[15] == 0 { pingRecvCurrent, pingTimeCurrent := checkConnection(ip, tcpPort)
break if pingRecvCurrent != 0 {
} ipCanConnect = true
break pingRecv = pingRecvCurrent
} pingTime = pingTimeCurrent
} } else {
if ipCanConnect { ip.IP[15]++
progressHandler(AvailableIPFound) if ip.IP[15] == 0 {
for i := failTime; i < pingCount; i++ { break
pingSuccess, pingTimeCurrent := tcping(ip, tcpPort) }
progressHandler(NormalPing) break
if pingSuccess { }
pingRecv++ }
pingTime += pingTimeCurrent if ipCanConnect {
} progressHandler(AvailableIPFound)
} for i := failTime; i < pingCount; i++ {
return true, pingRecv, pingTime / float32(pingRecv), ip pingSuccess, pingTimeCurrent := tcping(ip, tcpPort)
} else { progressHandler(NormalPing)
progressHandler(NoAvailableIPFound) if pingSuccess {
return false, 0, 0, net.IPAddr{} pingRecv++
} pingTime += pingTimeCurrent
} }
}
func tcpingGoroutine(wg *sync.WaitGroup, mutex *sync.Mutex, ip net.IPAddr, tcpPort int, pingCount int, csv *[]CloudflareIPData, control chan bool, progressHandler func(e progressEvent)) { return true, pingRecv, pingTime / float32(pingRecv), ip
defer wg.Done() } else {
success, pingRecv, pingTimeAvg, currentIP := tcpingHandler(ip, tcpPort, pingCount, progressHandler) progressHandler(NoAvailableIPFound)
if success { return false, 0, 0, net.IPAddr{}
mutex.Lock() }
var cfdata CloudflareIPData }
cfdata.ip = currentIP
cfdata.pingReceived = pingRecv func tcpingGoroutine(wg *sync.WaitGroup, mutex *sync.Mutex, ip net.IPAddr, tcpPort int, pingCount int, csv *[]CloudflareIPData, control chan bool, progressHandler func(e progressEvent)) {
cfdata.pingTime = pingTimeAvg defer wg.Done()
cfdata.pingCount = pingCount success, pingRecv, pingTimeAvg, currentIP := tcpingHandler(ip, tcpPort, pingCount, progressHandler)
*csv = append(*csv, cfdata) if success {
mutex.Unlock() mutex.Lock()
} var cfdata CloudflareIPData
<-control cfdata.ip = currentIP
} cfdata.pingReceived = pingRecv
cfdata.pingTime = pingTimeAvg
func GetDialContextByAddr(fakeSourceAddr string) func(ctx context.Context, network, address string) (net.Conn, error) { cfdata.pingCount = pingCount
return func(ctx context.Context, network, address string) (net.Conn, error) { *csv = append(*csv, cfdata)
c, e := (&net.Dialer{}).DialContext(ctx, network, fakeSourceAddr) mutex.Unlock()
return c, e }
} <-control
} }
//bool : can download,float32 downloadSpeed func GetDialContextByAddr(fakeSourceAddr string) func(ctx context.Context, network, address string) (net.Conn, error) {
func DownloadSpeedHandler(ip net.IPAddr) (bool, float32) { return func(ctx context.Context, network, address string) (net.Conn, error) {
var client = http.Client{ c, e := (&net.Dialer{}).DialContext(ctx, network, fakeSourceAddr)
Transport: nil, return c, e
CheckRedirect: nil, }
Jar: nil, }
Timeout: 0,
} //bool : can download,float32 downloadSpeed
client.Transport = &http.Transport{ func DownloadSpeedHandler(ip net.IPAddr) (bool, float32) {
DialContext: GetDialContextByAddr(ip.String() + ":443"), var client = http.Client{
} Transport: nil,
response, err := client.Get(url) CheckRedirect: nil,
Jar: nil,
if err != nil { Timeout: 0,
return false, 0 }
} else { var fullAddress string
defer func() { _ = response.Body.Close() }() if ipv6Mode { // IPv6 需要加上 []
if response.StatusCode == 200 { fullAddress = "[" + ip.String() + "]:443"
timeStart := time.Now() } else {
timeEnd := timeStart.Add(downloadTestTime) fullAddress = ip.String() + ":443"
}
contentLength := response.ContentLength client.Transport = &http.Transport{
buffer := make([]byte, downloadBufferSize) DialContext: GetDialContextByAddr(fullAddress),
}
var contentRead int64 = 0 response, err := client.Get(url)
var timeSlice = downloadTestTime / 100
var timeCounter = 1 if err != nil {
var lastContentRead int64 = 0 return false, 0
} else {
var nextTime = timeStart.Add(timeSlice * time.Duration(timeCounter)) defer func() { _ = response.Body.Close() }()
e := ewma.NewMovingAverage() if response.StatusCode == 200 {
timeStart := time.Now()
for contentLength != contentRead { timeEnd := timeStart.Add(downloadTestTime)
var currentTime = time.Now()
if currentTime.After(nextTime) { contentLength := response.ContentLength
timeCounter += 1 buffer := make([]byte, downloadBufferSize)
nextTime = timeStart.Add(timeSlice * time.Duration(timeCounter))
e.Add(float64(contentRead - lastContentRead)) var contentRead int64 = 0
lastContentRead = contentRead var timeSlice = downloadTestTime / 100
} var timeCounter = 1
if currentTime.After(timeEnd) { var lastContentRead int64 = 0
break
} var nextTime = timeStart.Add(timeSlice * time.Duration(timeCounter))
bufferRead, err := response.Body.Read(buffer) e := ewma.NewMovingAverage()
contentRead += int64(bufferRead)
if err != nil { for contentLength != contentRead {
if err != io.EOF { var currentTime = time.Now()
break if currentTime.After(nextTime) {
} else { timeCounter += 1
e.Add(float64(contentRead-lastContentRead) / (float64(nextTime.Sub(currentTime)) / float64(timeSlice))) nextTime = timeStart.Add(timeSlice * time.Duration(timeCounter))
} e.Add(float64(contentRead - lastContentRead))
} lastContentRead = contentRead
} }
return true, float32(e.Value()) / (float32(downloadTestTime.Seconds()) / 100) if currentTime.After(timeEnd) {
} else { break
return false, 0 }
} bufferRead, err := response.Body.Read(buffer)
} contentRead += int64(bufferRead)
} if err != nil {
if err != io.EOF {
break
} else {
e.Add(float64(contentRead-lastContentRead) / (float64(nextTime.Sub(currentTime)) / float64(timeSlice)))
}
}
}
return true, float32(e.Value()) / (float32(downloadTestTime.Seconds()) / 100)
} else {
return false, 0
}
}
}

287
util.go
View File

@@ -1,139 +1,148 @@
package main package main
import ( import (
"encoding/csv" "encoding/csv"
"log" "log"
"math/rand" "math/rand"
"net" "net"
"os" "os"
"strconv" "strconv"
"time" "time"
"github.com/cheggaaa/pb/v3" "github.com/cheggaaa/pb/v3"
) )
type CloudflareIPData struct { type CloudflareIPData struct {
ip net.IPAddr ip net.IPAddr
pingCount int pingCount int
pingReceived int pingReceived int
recvRate float32 recvRate float32
downloadSpeed float32 downloadSpeed float32
pingTime float32 pingTime float32
} }
func (cf *CloudflareIPData) getRecvRate() float32 { func (cf *CloudflareIPData) getRecvRate() float32 {
if cf.recvRate == 0 { if cf.recvRate == 0 {
pingLost := cf.pingCount - cf.pingReceived pingLost := cf.pingCount - cf.pingReceived
cf.recvRate = float32(pingLost) / float32(cf.pingCount) cf.recvRate = float32(pingLost) / float32(cf.pingCount)
} }
return cf.recvRate return cf.recvRate
} }
func ExportCsv(filePath string, data []CloudflareIPData) { func ExportCsv(filePath string, data []CloudflareIPData) {
fp, err := os.Create(filePath) fp, err := os.Create(filePath)
if err != nil { if err != nil {
log.Fatalf("创建文件["+filePath+"]句柄失败,%v", err) log.Fatalf("创建文件["+filePath+"]句柄失败,%v", err)
return return
} }
defer fp.Close() defer fp.Close()
w := csv.NewWriter(fp) //创建一个新的写入文件流 w := csv.NewWriter(fp) //创建一个新的写入文件流
w.Write([]string{"IP 地址", "已发送", "已接收", "丢包率", "平均延迟", "下载速度 (MB/s)"}) w.Write([]string{"IP 地址", "已发送", "已接收", "丢包率", "平均延迟", "下载速度 (MB/s)"})
w.WriteAll(convertToString(data)) w.WriteAll(convertToString(data))
w.Flush() w.Flush()
} }
func (cf *CloudflareIPData) toString() []string { func (cf *CloudflareIPData) toString() []string {
result := make([]string, 6) result := make([]string, 6)
result[0] = cf.ip.String() result[0] = cf.ip.String()
result[1] = strconv.Itoa(cf.pingCount) result[1] = strconv.Itoa(cf.pingCount)
result[2] = strconv.Itoa(cf.pingReceived) result[2] = strconv.Itoa(cf.pingReceived)
result[3] = strconv.FormatFloat(float64(cf.getRecvRate()), 'f', 2, 32) result[3] = strconv.FormatFloat(float64(cf.getRecvRate()), 'f', 2, 32)
result[4] = strconv.FormatFloat(float64(cf.pingTime), 'f', 2, 32) result[4] = strconv.FormatFloat(float64(cf.pingTime), 'f', 2, 32)
result[5] = strconv.FormatFloat(float64(cf.downloadSpeed)/1024/1024, 'f', 2, 32) result[5] = strconv.FormatFloat(float64(cf.downloadSpeed)/1024/1024, 'f', 2, 32)
return result return result
} }
func convertToString(data []CloudflareIPData) [][]string { func convertToString(data []CloudflareIPData) [][]string {
result := make([][]string, 0) result := make([][]string, 0)
for _, v := range data { for _, v := range data {
result = append(result, v.toString()) result = append(result, v.toString())
} }
return result return result
} }
var pingTime int var pingTime int
var pingRoutine int var pingRoutine int
var ipEndWith uint8 = 0 type progressEvent int
type progressEvent int const (
NoAvailableIPFound progressEvent = iota
const ( AvailableIPFound
NoAvailableIPFound progressEvent = iota NormalPing
AvailableIPFound )
NormalPing
) var url string
var url string var downloadTestTime time.Duration
var downloadTestTime time.Duration const downloadBufferSize = 1024
const downloadBufferSize = 1024 var downloadTestCount int
var downloadTestCount int //const defaultTcpPort = 443
const tcpConnectTimeout = time.Second * 1
//const defaultTcpPort = 443
const tcpConnectTimeout = time.Second * 1 var failTime int
var failTime int type CloudflareIPDataSet []CloudflareIPData
type CloudflareIPDataSet []CloudflareIPData func initRandSeed() {
rand.Seed(time.Now().UnixNano())
func initRandSeed() { }
rand.Seed(time.Now().UnixNano())
} func randipEndWith(num int) uint8 {
return uint8(rand.Intn(num) + 1)
func randipEndWith() { }
ipEndWith = uint8(rand.Intn(254) + 1)
} func GetRandomString() string {
str := "0123456789abcdef"
func ipPadding(ip string) string { bytes := []byte(str)
var ipLength int result := []byte{}
var ipPrint string r := rand.New(rand.NewSource(time.Now().UnixNano()))
ipPrint = ip for i := 0; i < 4; i++ {
ipLength = len(ipPrint) result = append(result, bytes[r.Intn(len(bytes))])
if ipLength < 15 { }
for i := 0; i <= 15-ipLength; i++ { return string(result)
ipPrint += " " }
}
} func ipPadding(ip string) string {
return ipPrint var ipLength int
} var ipPrint string
ipPrint = ip
func handleProgressGenerator(pb *pb.ProgressBar) func(e progressEvent) { ipLength = len(ipPrint)
return func(e progressEvent) { if ipLength < 15 {
switch e { for i := 0; i <= 15-ipLength; i++ {
case NoAvailableIPFound: ipPrint += " "
pb.Add(pingTime) }
case AvailableIPFound: }
pb.Add(failTime) return ipPrint
case NormalPing: }
pb.Increment()
} func handleProgressGenerator(pb *pb.ProgressBar) func(e progressEvent) {
} return func(e progressEvent) {
} switch e {
case NoAvailableIPFound:
func (cfs CloudflareIPDataSet) Len() int { pb.Add(pingTime)
return len(cfs) case AvailableIPFound:
} pb.Add(failTime)
case NormalPing:
func (cfs CloudflareIPDataSet) Less(i, j int) bool { pb.Increment()
if (cfs)[i].getRecvRate() != cfs[j].getRecvRate() { }
return cfs[i].getRecvRate() < cfs[j].getRecvRate() }
} }
return cfs[i].pingTime < cfs[j].pingTime
} func (cfs CloudflareIPDataSet) Len() int {
return len(cfs)
func (cfs CloudflareIPDataSet) Swap(i, j int) { }
cfs[i], cfs[j] = cfs[j], cfs[i]
} func (cfs CloudflareIPDataSet) Less(i, j int) bool {
if (cfs)[i].getRecvRate() != cfs[j].getRecvRate() {
return cfs[i].getRecvRate() < cfs[j].getRecvRate()
}
return cfs[i].pingTime < cfs[j].pingTime
}
func (cfs CloudflareIPDataSet) Swap(i, j int) {
cfs[i], cfs[j] = cfs[j], cfs[i]
}