24 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
xiu2
40b22f660a 新增 指定延迟时间上限、下载速度下限条件 2020-11-11 18:10:53 +08:00
xiu2
12039f4850 修复 -p 0 时没有直接退出程序的问题;优化 代码 2020-11-10 21:03:09 +08:00
xiu2
129deeaf71 update 2020-11-10 19:50:43 +08:00
xiu2
3de6b38e00 优化 IP最后一段完全随机 2020-11-10 19:22:55 +08:00
xiu2
8c0e8732cc 新增 版本号标识 2020-11-10 15:55:52 +08:00
xiu2
8820c5f982 update 2020-11-10 15:35:24 +08:00
xiu2
d50c4806a6 调整 默认下载测速地址为自建地址 2020-11-08 16:46:27 +08:00
6 changed files with 939 additions and 644 deletions

View File

@@ -1,39 +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 {
firstIP[15] = ipEndWith log.Fatal(err)
for IPRange.Contains(firstIP) { }
firstIPCopy := make([]byte, len(firstIP)) firstIPs := make([]net.IPAddr, 0)
copy(firstIPCopy, firstIP) scanner := bufio.NewScanner(file)
firstIPs = append(firstIPs, net.IPAddr{IP: firstIPCopy}) scanner.Split(bufio.ScanLines)
firstIP[14]++ for scanner.Scan() {
if firstIP[14] == 0 { IPString := scanner.Text()
firstIP[13]++ firstIP, IPRange, err := net.ParseCIDR(IPString)
if firstIP[13] == 0 { //fmt.Println(firstIP)
firstIP[12]++ //fmt.Println(IPRange)
} 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
}

300
README.md
View File

@@ -1,137 +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.200.105 4 4 0.00 135.77 13.21 ```
104.27.205.105 4 4 0.00 136.65 17.33 IP 地址 已发送 已接收 丢包率 平均延迟 下载速度 (MB/s)
104.27.207.105 4 4 0.00 136.97 5.55 104.27.198.101 4 4 0.00 126.52 12.71
104.27.193.105 4 4 0.00 146.97 16.54 104.22.43.157 4 4 0.00 129.38 16.74
104.27.206.105 4 4 0.00 148.04 1.65 104.27.214.140 4 4 0.00 132.02 4.65
104.27.192.105 4 4 0.00 148.97 9.08 104.22.42.165 4 4 0.00 133.63 12.00
104.27.195.105 4 4 0.00 150.29 21.00 104.22.35.177 4 4 0.00 135.75 3.92
104.27.197.105 4 4 0.00 151.04 13.61 104.22.87.44 4 4 0.00 136.00 5.86
104.27.203.105 4 4 0.00 151.54 15.73 104.22.67.122 4 4 0.00 136.50 9.47
104.27.204.105 4 4 0.00 151.94 8.32 104.22.88.154 4 4 0.00 140.75 13.00
``` 104.22.69.218 4 4 0.00 142.00 19.07
> 如果**下载速度都是 0.00**,那说明默认的**下载测速地址**用的人太多又到上限了,**请去这个 [Issues](https://github.com/XIU2/CloudflareSpeedTest/issues/6) 获得解决方法!** 104.27.184.10 4 4 0.00 148.02 21.05
...
完整结果保存在当前目录下的 `result.csv` 文件中,用**记事本/表格软件**打开,排序为**延迟由低到高**,分别是: ```
``` 完整结果保存在当前目录下的 `result.csv` 文件中,用**记事本/表格软件**打开,排序为**延迟由低到高**,分别是:
IP 地址, 已发送, 已接收, 丢包率, 平均延迟, 下载速度 (MB/s)
104.27.200.105, 4, 4, 0.00, 135.77, 13.21 ```
``` IP 地址, 已发送, 已接收, 丢包率, 平均延迟, 下载速度 (MB/s)
104.27.199.141, 4, 4, 0.00, 139.52, 11.71
选择一个平均延迟与下载速度都不错的 IP 放到 `Hosts` 文件中(指向使用 Cloudflare CDN 的网站域名)。 ```
> 大家可以按照自己的需求,对完整测速数据**进一步筛选处理**
****
## 进阶使用 选择一个平均延迟与下载速度都不错的 IP 放到 `Hosts` 文件中(指向使用 Cloudflare CDN 的网站域名)。
直接双击运行使用的是默认参数,如果想要测试速度更快、测试结果更全面,可以自定义参数。 ****
## 进阶使用
> **提示Linux 系统**只需要把下面命令中的 **.exe 删除**即可通用。
> **提示:下载测速地址**可以去这个 **[Issues](https://github.com/XIU2/CloudflareSpeedTest/issues/6)** 中获得、提交、交流! 直接双击运行使用的是默认参数,如果想要测试速度更快、测试结果更全面,可以自定义参数。
``` cmd ``` cmd
C:\>CloudflareST.exe -h C:\>CloudflareST.exe -h
CloudflareSpeedTest CloudflareSpeedTest vX.X.X
测试 Cloudflare CDN 所有 IP 的延迟和速度,获取最快 IP 测试 Cloudflare CDN 所有 IP 的延迟和速度,获取最快 IP
https://github.com/XIU2/CloudflareSpeedTest https://github.com/XIU2/CloudflareSpeedTest
参数: 参数:
-n 500 -n 500
测速线程数量;数值越大速度越快,请勿超过 1000(结果误差大)(默认 500) 测速线程数量;数值越大速度越快,请勿超过 1000(结果误差大)(默认 500)
-t 4 -t 4
延迟测速次数;单个 IP 测速次数,为 1 时将过滤丢包的IPTCP协议(默认 4) 延迟测速次数;单个 IP 测速次数,为 1 时将过滤丢包的IPTCP协议(默认 4)
-tp 443 -tp 443
延迟测速端口;延迟测速 TCP 协议的端口;(默认 443) 延迟测速端口;延迟测速 TCP 协议的端口;(默认 443)
-dn 20 -dn 20
下载测速数量;延迟测速并排序后,从最低延迟起下载测速数量,请勿太多(速度慢)(默认 20) 下载测速数量;延迟测速并排序后,从最低延迟起下载测速数量,请勿太多(速度慢)(默认 20)
-dt 5 -dt 5
下载测速时间;单个 IP 测速最长时间,单位:秒;(默认 5) 下载测速时间;单个 IP 测速最长时间,单位:秒;(默认 5)
-url https://speed.cloudflare.com/__down?bytes=209715200 -url https://cf.xiu2.xyz/Github/CloudflareSpeedTest.png
下载测速地址;用来测速的网站地址,要求:可以直接下载的文件、文件大小超过 200MB、网站用的是 Cloudflare CDN 下载测速地址;用来 Cloudflare CDN 测速的文件地址,如含有空格请加上引号
默认下载测速地址用的人太多,容易出现超出上限被限制的情况,建议自行寻找合适的下载测速地址!(如含有空格请加上引号) -tl 200
-p 20 延迟时间上限;只输出指定延迟时间以下的结果,数量为 -dn 参数的值单位ms
显示结果数量;测速后直接显示指定数量的结果,为 0 时不显示结果直接退出;(默认 20) -sl 5
-f ip.txt 下载速度下限;只输出指定下载速度以上的结果,数量为 -dn 参数的值单位MB/s
IP 数据文件;如含有空格请加上引号;支持其他 CDN IP段记得禁用下载测速(默认 ip.txt) -p 20
-o result.csv 显示结果数量;测速后直接显示指定数量的结果,为 0 时不显示结果直接退出;(默认 20)
输出结果文件;如含有空格请加上引号;为空格时不输出结果文件(-o " ");允许其他后缀;(默认 result.csv) -f ip.txt
-dd IP 数据文件;如含有空格请加上引号;支持其他 CDN IP段记得禁用下载测速(默认 ip.txt)
禁用下载测速;如果带上该参数就是禁用下载测速;(默认 启用) -o result.csv
-v 输出结果文件;如含有空格请加上引号;为空格时不输出结果文件(-o " ");允许其他后缀;(默认 result.csv)
打印程序版本 -dd
-h 禁用下载测速;如果带上该参数就是禁用下载测速;(默认 启用)
打印帮助说明 -ipv6
``` IPv6 测速模式;请确保 IP 数据文件内只包含 IPv6 IP段软件不支持同时测速 IPv4+IPv6(默认 IPv4)
-allip
### 使用示例 测速全部 IP如果带上该参数将会对每个 IP (仅 IPv4) 进行测速;(默认 每个 IP 段随机测速一个 IP)
-v
在 CMD 中运行,或者把启动参数添加到快捷方式中。 打印程序版本+检查版本更新
> **注意:** 不需要加上所有参数,按需选择,参数前后顺序随意。 -h
> **提示: Linux 系统**只需要把下面命令中的 **.exe 删除**即可通用。 打印帮助说明
> **提示: 下载测速地址**可以去这个 **[Issues](https://github.com/XIU2/CloudflareSpeedTest/issues/6)** 中获得、提交、交流! ```
``` cmd > 如果**下载速度都是 0.00**,那说明默认的**下载测速地址**用的人太多又到上限了,**请去这个 [Issues](https://github.com/XIU2/CloudflareSpeedTest/issues/6) 获得解决方法!**
# 命令行示例
CloudflareST.exe -n 500 -t 4 -dn 20 -dt 5 ### 使用示例
# 指定 IP数据文件不显示结果直接退出-p 值为 0 在 CMD 中运行,或者把启动参数添加到快捷方式中。
CloudflareST.exe -n 500 -t 4 -dn 20 -dt 5 -p 0 -f "ip.txt" -dd
``` bash
# 指定 IP数据文件不输出结果到文件直接显示结果-p 值为 20 条) # 命令行示例
CloudflareST.exe -n 500 -t 4 -dn 20 -dt 5 -p 20 -f "ip.txt" -o " " -dd # 注意:各参数均有默认值,只有不使用默认值时,才需要手动指定参数的值(按需选择),参数不分前后顺序。
# 提示: Linux 系统只需要把下面命令中的 CloudflareST.exe 改为 ./CloudflareST 即可。
# 指定 IP数据文件 及 输出结果到文件(相对路径,即当前目录下,如果包含空格请加上引号)
CloudflareST.exe -n 500 -t 4 -dn 20 -dt 5 -f ip.txt -o result.csv -dd # 指定 IPv4 数据文件,不显示结果直接退出(-p 值为 0
CloudflareST.exe -p 0 -f ip.txt -dd
# 指定 IP数据文件 及 输出结果到文件(绝对路径,即 C:\abc\ 目录下,如果包含空格请加上引号)
CloudflareST.exe -n 500 -t 4 -dn 20 -dt 5 -f C:\abc\ip.txt -o C:\abc\result.csv -dd # 指定 IPv6 数据文件( ipv6.txt ),不显示结果直接退出(-p 值为 0
CloudflareST.exe -p 0 -f ipv6.txt -dd -ipv6
# 指定下载测速地址(要求:可以直接下载的文件、文件大小超过 200MB、网站用的是 Cloudflare CDN如果包含空格请加上引号
CloudflareST.exe -n 500 -t 4 -dn 20 -dt 5 -url https://speed.cloudflare.com/__down?bytes=209715200 # 指定 IPv4 数据文件,不输出结果到文件,直接显示结果(-p 值为 10 条)
``` CloudflareST.exe -p 10 -f ip.txt -o " " -dd
``` cmd # 指定 IPv4 数据文件 及 输出结果到文件(相对路径,即当前目录下,如果包含空格请加上引号)
# 快捷方式示例(右键快捷方式 - 目标) CloudflareST.exe -f ip.txt -o result.csv -dd
## 如果有引号就放在引号外面,记得引号和 - 之间有空格。
"D:\Program Files\CloudflareST\CloudflareST.exe" -n 500 -t 4 -dn 20 -dt 5 # 指定 IPv4 数据文件 及 输出结果到文件(绝对路径,即 C:\abc\ 目录下,如果包含空格请加上引号)
``` CloudflareST.exe -f C:\abc\ip.txt -o C:\abc\result.csv -dd
**** # 指定下载测速地址(要求:可以直接下载、文件大小超过 200MB、用的是 Cloudflare CDN如果包含空格请加上引号
## 感谢项目 CloudflareST.exe -url https://cf.xiu2.xyz/Github/CloudflareSpeedTest.png
* https://github.com/Spedoske/CloudflareScanner
# 指定测速条件(只有同时满足三个条件时才会停止测速):
意外发现了这个项目,看了之后发现正好解决了我的问题,但是我更喜欢用户命令行方式运行,这样会更方便、有更多使用姿势,于是我临时学了下 Golang 并 Fork 按照我自己的需求修改了一下(包括但不限于命令行方式交互、直接输出结果等),如果有什么问题可以告诉我,虽然我不一定会~ # 延迟时间上限200 ms下载速度下限0 MB/s数量10 个
CloudflareST.exe -tl 200 -dn 10
****
## 许可证 # 延迟时间上限0 ms下载速度下限5 MB/s数量10 个
The GPL-3.0 License. CloudflareST.exe -sl 5 -dn 10
# 延迟时间上限200 ms下载速度下限5 MB/s数量10 个
CloudflareST.exe -tl 200 -sl 5 -dn 10
# 如果一直凑不够指定数量,会一直测速下去。
# 建议指定下载速度下限时,同时指定延迟时间上限,如果测试到指定延迟还没凑够数,就会终止测速。
# 如果一个满足条件的 IP 都没有,那么就会正常输出结果(和不指定条件一样)。
# 如果你需要通过外部程序进一步筛选处理,那么只需要判断测速结果数量,如果上千个说明一个满足条件的 IP 都没有。
```
``` 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

457
main.go
View File

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

271
util.go
View File

@@ -1,123 +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 initipEndWith() { }
rand.Seed(time.Now().UnixNano())
ipEndWith = uint8(rand.Intn(254) + 1) func randipEndWith(num int) uint8 {
} return uint8(rand.Intn(num) + 1)
}
func handleProgressGenerator(pb *pb.ProgressBar) func(e progressEvent) {
return func(e progressEvent) { func GetRandomString() string {
switch e { str := "0123456789abcdef"
case NoAvailableIPFound: bytes := []byte(str)
pb.Add(pingTime) result := []byte{}
case AvailableIPFound: r := rand.New(rand.NewSource(time.Now().UnixNano()))
pb.Add(failTime) for i := 0; i < 4; i++ {
case NormalPing: result = append(result, bytes[r.Intn(len(bytes))])
pb.Increment() }
} return string(result)
} }
}
func ipPadding(ip string) string {
func (cfs CloudflareIPDataSet) Len() int { var ipLength int
return len(cfs) var ipPrint string
} ipPrint = ip
ipLength = len(ipPrint)
func (cfs CloudflareIPDataSet) Less(i, j int) bool { if ipLength < 15 {
if (cfs)[i].getRecvRate() != cfs[j].getRecvRate() { for i := 0; i <= 15-ipLength; i++ {
return cfs[i].getRecvRate() < cfs[j].getRecvRate() ipPrint += " "
} }
return cfs[i].pingTime < cfs[j].pingTime }
} return ipPrint
}
func (cfs CloudflareIPDataSet) Swap(i, j int) {
cfs[i], cfs[j] = cfs[j], cfs[i] func handleProgressGenerator(pb *pb.ProgressBar) func(e progressEvent) {
} return func(e progressEvent) {
switch e {
case NoAvailableIPFound:
pb.Add(pingTime)
case AvailableIPFound:
pb.Add(failTime)
case NormalPing:
pb.Increment()
}
}
}
func (cfs CloudflareIPDataSet) Len() int {
return len(cfs)
}
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]
}