github.com/intfoundation/intchain@v0.0.0-20220727031208-4316ad31ca73/p2p/discv5/ntp.go (about) 1 // Copyright 2016 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 // Contains the NTP time drift detection via the SNTP protocol: 18 // https://tools.ietf.org/html/rfc4330 19 20 package discv5 21 22 import ( 23 "fmt" 24 "net" 25 "sort" 26 "strings" 27 "time" 28 29 "github.com/intfoundation/intchain/log" 30 ) 31 32 const ( 33 ntpPool = "pool.ntp.org" // ntpPool is the NTP server to query for the current time 34 ntpChecks = 3 // Number of measurements to do against the NTP server 35 ) 36 37 // durationSlice attaches the methods of sort.Interface to []time.Duration, 38 // sorting in increasing order. 39 type durationSlice []time.Duration 40 41 func (s durationSlice) Len() int { return len(s) } 42 func (s durationSlice) Less(i, j int) bool { return s[i] < s[j] } 43 func (s durationSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } 44 45 // checkClockDrift queries an NTP server for clock drifts and warns the user if 46 // one large enough is detected. 47 func checkClockDrift() { 48 drift, err := sntpDrift(ntpChecks) 49 if err != nil { 50 return 51 } 52 if drift < -driftThreshold || drift > driftThreshold { 53 warning := fmt.Sprintf("System clock seems off by %v, which can prevent network connectivity", drift) 54 howtofix := fmt.Sprintf("Please enable network time synchronisation in system settings") 55 separator := strings.Repeat("-", len(warning)) 56 57 log.Warn(separator) 58 log.Warn(warning) 59 log.Warn(howtofix) 60 log.Warn(separator) 61 } else { 62 log.Debug(fmt.Sprintf("Sanity NTP check reported %v drift, all ok", drift)) 63 } 64 } 65 66 // sntpDrift does a naive time resolution against an NTP server and returns the 67 // measured drift. This method uses the simple version of NTP. It's not precise 68 // but should be fine for these purposes. 69 // 70 // Note, it executes two extra measurements compared to the number of requested 71 // ones to be able to discard the two extremes as outliers. 72 func sntpDrift(measurements int) (time.Duration, error) { 73 // Resolve the address of the NTP server 74 addr, err := net.ResolveUDPAddr("udp", ntpPool+":123") 75 if err != nil { 76 return 0, err 77 } 78 // Construct the time request (empty package with only 2 fields set): 79 // Bits 3-5: Protocol version, 3 80 // Bits 6-8: Mode of operation, client, 3 81 request := make([]byte, 48) 82 request[0] = 3<<3 | 3 83 84 // Execute each of the measurements 85 drifts := []time.Duration{} 86 for i := 0; i < measurements+2; i++ { 87 // Dial the NTP server and send the time retrieval request 88 conn, err := net.DialUDP("udp", nil, addr) 89 if err != nil { 90 return 0, err 91 } 92 defer conn.Close() 93 94 sent := time.Now() 95 if _, err = conn.Write(request); err != nil { 96 return 0, err 97 } 98 // Retrieve the reply and calculate the elapsed time 99 conn.SetDeadline(time.Now().Add(5 * time.Second)) 100 101 reply := make([]byte, 48) 102 if _, err = conn.Read(reply); err != nil { 103 return 0, err 104 } 105 elapsed := time.Since(sent) 106 107 // Reconstruct the time from the reply data 108 sec := uint64(reply[43]) | uint64(reply[42])<<8 | uint64(reply[41])<<16 | uint64(reply[40])<<24 109 frac := uint64(reply[47]) | uint64(reply[46])<<8 | uint64(reply[45])<<16 | uint64(reply[44])<<24 110 111 nanosec := sec*1e9 + (frac*1e9)>>32 112 113 t := time.Date(1900, 1, 1, 0, 0, 0, 0, time.UTC).Add(time.Duration(nanosec)).Local() 114 115 // Calculate the drift based on an assumed answer time of RRT/2 116 drifts = append(drifts, sent.Sub(t)+elapsed/2) 117 } 118 // Calculate average drif (drop two extremities to avoid outliers) 119 sort.Sort(durationSlice(drifts)) 120 121 drift := time.Duration(0) 122 for i := 1; i < len(drifts)-1; i++ { 123 drift += drifts[i] 124 } 125 return drift / time.Duration(measurements), nil 126 }