462 lines
11 KiB
Go
462 lines
11 KiB
Go
package ping
|
|
|
|
import (
|
|
"log"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type Option interface {
|
|
Retry() int
|
|
Interval() int
|
|
Deadline() int
|
|
Validate()
|
|
}
|
|
|
|
type Response interface {
|
|
TTL() int
|
|
Time() float32
|
|
}
|
|
|
|
type Summary interface {
|
|
SendCount() int
|
|
ReceiveCount() int
|
|
LossPercent() float32
|
|
MinTime() float32
|
|
MaxTime() float32
|
|
AvgTime() float32
|
|
}
|
|
|
|
type Result interface {
|
|
Responses() map[int]Response
|
|
Summary() Summary
|
|
}
|
|
|
|
type PingOption struct {
|
|
retry int
|
|
interval int
|
|
deadline int
|
|
}
|
|
|
|
func (o *PingOption) Retry() int {
|
|
return o.retry
|
|
}
|
|
func (o *PingOption) Interval() int {
|
|
return o.interval
|
|
}
|
|
func (o *PingOption) Deadline() int {
|
|
return o.deadline
|
|
}
|
|
func (o *PingOption) Validate() {
|
|
if 0 >= o.retry {
|
|
o.retry = 1
|
|
}
|
|
if 0 >= o.interval {
|
|
o.interval = 1
|
|
}
|
|
if 0 >= o.deadline {
|
|
o.deadline = 1
|
|
}
|
|
}
|
|
|
|
type PingResponse struct {
|
|
ttl int
|
|
time float32
|
|
}
|
|
|
|
func (r *PingResponse) TTL() int {
|
|
return r.ttl
|
|
}
|
|
func (r *PingResponse) Time() float32 {
|
|
return r.time
|
|
}
|
|
|
|
type PingSummary struct {
|
|
sendCount int
|
|
receiveCount int
|
|
lossPercent float32
|
|
minTime float32
|
|
maxTime float32
|
|
avgTime float32
|
|
}
|
|
|
|
func (s *PingSummary) SendCount() int {
|
|
return s.sendCount
|
|
}
|
|
func (s *PingSummary) ReceiveCount() int {
|
|
return s.receiveCount
|
|
}
|
|
func (s *PingSummary) LossPercent() float32 {
|
|
return s.lossPercent
|
|
}
|
|
func (s *PingSummary) MinTime() float32 {
|
|
return s.minTime
|
|
}
|
|
func (s *PingSummary) MaxTime() float32 {
|
|
return s.maxTime
|
|
}
|
|
func (s *PingSummary) AvgTime() float32 {
|
|
return s.avgTime
|
|
}
|
|
|
|
type PingResult struct {
|
|
responses map[int]Response
|
|
summary Summary
|
|
}
|
|
|
|
func (r *PingResult) Responses() map[int]Response {
|
|
return r.responses
|
|
}
|
|
func (r *PingResult) Summary() Summary {
|
|
return r.summary
|
|
}
|
|
|
|
// $ ping 192.168.1.1 -c 7 -i 1 -w 0.3
|
|
// PING 192.168.1.1 (192.168.1.1) 56(84) bytes of data.
|
|
// 64 bytes from 192.168.1.1: icmp_seq=1 ttl=64 time=0.325 ms
|
|
// 64 bytes from 192.168.1.1: icmp_seq=2 ttl=64 time=0.344 ms
|
|
// 64 bytes from 192.168.1.1: icmp_seq=3 ttl=64 time=0.163 ms
|
|
// 64 bytes from 192.168.1.1: icmp_seq=7 ttl=64 time=0.180 ms
|
|
// From 192.168.1.101 icmp_seq=1 Destination Host Unreachable
|
|
|
|
// --- 192.168.1.1 ping statistics ---
|
|
// 7 packets transmitted, 4 received, 42% packet loss, time 6010ms
|
|
// rtt min/avg/max/mdev = 0.163/0.253/0.344/0.082 ms
|
|
func parseLinuxPing(output []byte) (Result, error) {
|
|
result := &PingResult{
|
|
responses: make(map[int]Response, 0),
|
|
summary: &PingSummary{},
|
|
}
|
|
lines := strings.Split(string(output), "\n")
|
|
|
|
LOOP:
|
|
for _, line := range lines {
|
|
fields := strings.Fields(line)
|
|
switch len(fields) {
|
|
case 5:
|
|
if "rtt" != fields[0] {
|
|
continue LOOP
|
|
}
|
|
|
|
times := strings.Split(fields[3], "/")
|
|
|
|
minTime, err := strconv.ParseFloat(times[0], 32)
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).minTime = float32(minTime)
|
|
|
|
maxTime, err := strconv.ParseFloat(times[2], 32)
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).maxTime = float32(maxTime)
|
|
|
|
avgTime, err := strconv.ParseFloat(times[1], 32)
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).avgTime = float32(avgTime)
|
|
|
|
case 8:
|
|
if "bytes" != fields[1] || "from" != fields[2] {
|
|
continue LOOP
|
|
}
|
|
|
|
seqs := strings.Split(fields[4], "=")
|
|
ttls := strings.Split(fields[5], "=")
|
|
times := strings.Split(fields[6], "=")
|
|
seq, err := strconv.Atoi(seqs[1])
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
ttl, err := strconv.Atoi(ttls[1])
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
_time, err := strconv.ParseFloat(times[1], 32)
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
|
|
result.responses[seq] = &PingResponse{
|
|
ttl: ttl,
|
|
time: float32(_time),
|
|
}
|
|
|
|
case 10:
|
|
sendCount, err := strconv.Atoi(fields[0])
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).sendCount = sendCount
|
|
|
|
receiveCount, err := strconv.Atoi(fields[3])
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).receiveCount = receiveCount
|
|
|
|
lossPercent, err := strconv.ParseFloat(strings.Replace(fields[5], "%", "", -1), 32)
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).lossPercent = float32(lossPercent)
|
|
}
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// Windows 10
|
|
// Active code page: 437
|
|
|
|
// Pinging 192.168.1.1 with 32 bytes of data:
|
|
// Reply from 192.168.1.1: bytes=32 time<1ms TTL=64
|
|
// Reply from 192.168.1.1: bytes=32 time<1ms TTL=64
|
|
// Reply from 192.168.1.1: bytes=32 time<1ms TTL=64
|
|
// Reply from 192.168.1.1: bytes=32 time<1ms TTL=64
|
|
// Reply from 192.168.1.1: bytes=32 time<1ms TTL=64
|
|
|
|
// Ping statistics for 192.168.1.1:
|
|
// Packets: Sent = 5, Received = 5, Lost = 0 (0% loss),
|
|
// Approximate round trip times in milli-seconds:
|
|
// Minimum = 0ms, Maximum = 0ms, Average = 0ms
|
|
|
|
// Active code page: 437
|
|
|
|
// Pinging www.google.com [216.58.221.164] with 32 bytes of data:
|
|
// Reply from 216.58.221.164: bytes=32 time=37ms TTL=51
|
|
// Request timed out.
|
|
// Reply from 216.58.221.164: bytes=32 time=38ms TTL=51
|
|
// Reply from 216.58.221.164: bytes=32 time=37ms TTL=51
|
|
// Reply from 216.58.221.164: bytes=32 time=37ms TTL=51
|
|
|
|
// Ping statistics for 216.58.221.164:
|
|
// Packets: Sent = 5, Received = 4, Lost = 1 (20% loss),
|
|
// Approximate round trip times in milli-seconds:
|
|
// Minimum = 37ms, Maximum = 38ms, Average = 37ms
|
|
|
|
func parseWindowsPing(output []byte) (Result, error) {
|
|
result := &PingResult{
|
|
responses: make(map[int]Response, 0),
|
|
summary: &PingSummary{},
|
|
}
|
|
lines := strings.Split(string(output), "\n")
|
|
|
|
seq := 1
|
|
LOOP:
|
|
for _, line := range lines {
|
|
fields := strings.Fields(line)
|
|
switch len(fields) {
|
|
case 3:
|
|
if "Request timed out." != line {
|
|
continue LOOP
|
|
}
|
|
// result.Responses[seq] = nil
|
|
seq = seq + 1
|
|
case 6:
|
|
if "Reply" != fields[0] || "from" != fields[1] {
|
|
continue LOOP
|
|
}
|
|
times := strings.Replace(fields[4], "time", "", -1)
|
|
times = strings.Replace(times, "<", "", -1)
|
|
times = strings.Replace(times, "=", "", -1)
|
|
times = strings.Replace(times, "ms", "", -1)
|
|
|
|
ttls := strings.Split(fields[5], "=")
|
|
|
|
ttl, err := strconv.Atoi(ttls[1])
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
_time, err := strconv.ParseFloat(times, 32)
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
|
|
result.responses[seq] = &PingResponse{
|
|
ttl: ttl,
|
|
time: float32(_time),
|
|
}
|
|
seq = seq + 1
|
|
case 9:
|
|
if "Minimum" != fields[0] {
|
|
continue LOOP
|
|
}
|
|
|
|
minTimes := strings.Replace(fields[2], "ms", "", -1)
|
|
minTimes = strings.Replace(minTimes, ",", "", -1)
|
|
minTime, err := strconv.ParseFloat(minTimes, 32)
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).minTime = float32(minTime)
|
|
|
|
maxTimes := strings.Replace(fields[5], "ms", "", -1)
|
|
maxTimes = strings.Replace(maxTimes, ",", "", -1)
|
|
maxTime, err := strconv.ParseFloat(maxTimes, 32)
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).maxTime = float32(maxTime)
|
|
|
|
avgTimes := strings.Replace(fields[8], "ms", "", -1)
|
|
avgTime, err := strconv.ParseFloat(avgTimes, 32)
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).avgTime = float32(avgTime)
|
|
|
|
case 12:
|
|
if "Packets:" != fields[0] {
|
|
continue LOOP
|
|
}
|
|
sendCount, err := strconv.Atoi(strings.Replace(fields[3], ",", "", -1))
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).sendCount = sendCount
|
|
|
|
receiveCount, err := strconv.Atoi(strings.Replace(fields[6], ",", "", -1))
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).receiveCount = receiveCount
|
|
|
|
lossPercents := strings.Replace(fields[10], "(", "", -1)
|
|
lossPercents = strings.Replace(lossPercents, "%", "", -1)
|
|
lossPercent, err := strconv.ParseFloat(lossPercents, 32)
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).lossPercent = float32(lossPercent)
|
|
}
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// $ ping 192.168.1.1 -c 5 -i 1
|
|
// PING 192.168.1.1 (192.168.1.1): 56 data bytes
|
|
// 64 bytes from 192.168.1.1: icmp_seq=0 ttl=64 time=1.664 ms
|
|
// 64 bytes from 192.168.1.1: icmp_seq=1 ttl=64 time=0.971 ms
|
|
// 64 bytes from 192.168.1.1: icmp_seq=2 ttl=64 time=3.934 ms
|
|
// 64 bytes from 192.168.1.1: icmp_seq=3 ttl=64 time=3.539 ms
|
|
// 64 bytes from 192.168.1.1: icmp_seq=4 ttl=64 time=3.690 ms
|
|
|
|
// --- 192.168.1.1 ping statistics ---
|
|
// 5 packets transmitted, 5 packets received, 0.0% packet loss
|
|
// round-trip min/avg/max/stddev = 0.971/2.760/3.934/1.204 ms
|
|
func parseDarwinPing(output []byte) (Result, error) {
|
|
result := &PingResult{
|
|
responses: make(map[int]Response, 0),
|
|
summary: &PingSummary{},
|
|
}
|
|
lines := strings.Split(string(output), "\n")
|
|
|
|
LOOP:
|
|
for _, line := range lines {
|
|
fields := strings.Fields(line)
|
|
switch len(fields) {
|
|
case 5:
|
|
if "round-trip" != fields[0] {
|
|
continue LOOP
|
|
}
|
|
|
|
times := strings.Split(fields[3], "/")
|
|
|
|
minTime, err := strconv.ParseFloat(times[0], 32)
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).minTime = float32(minTime)
|
|
|
|
maxTime, err := strconv.ParseFloat(times[2], 32)
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).maxTime = float32(maxTime)
|
|
|
|
avgTime, err := strconv.ParseFloat(times[1], 32)
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).avgTime = float32(avgTime)
|
|
|
|
case 8:
|
|
if "bytes" != fields[1] || "from" != fields[2] {
|
|
continue LOOP
|
|
}
|
|
|
|
seqs := strings.Split(fields[4], "=")
|
|
ttls := strings.Split(fields[5], "=")
|
|
times := strings.Split(fields[6], "=")
|
|
seq, err := strconv.Atoi(seqs[1])
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
ttl, err := strconv.Atoi(ttls[1])
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
_time, err := strconv.ParseFloat(times[1], 32)
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
|
|
result.responses[seq] = &PingResponse{
|
|
ttl: ttl,
|
|
time: float32(_time),
|
|
}
|
|
|
|
case 9:
|
|
sendCount, err := strconv.Atoi(fields[0])
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).sendCount = sendCount
|
|
|
|
receiveCount, err := strconv.Atoi(fields[3])
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).receiveCount = receiveCount
|
|
|
|
lossPercent, err := strconv.ParseFloat(strings.Replace(fields[6], "%", "", -1), 32)
|
|
if nil != err {
|
|
log.Print(err)
|
|
continue LOOP
|
|
}
|
|
result.summary.(*PingSummary).lossPercent = float32(lossPercent)
|
|
}
|
|
}
|
|
|
|
return result, nil
|
|
}
|