126 lines
3.2 KiB
Go
126 lines
3.2 KiB
Go
package hostsvc
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
"net"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
ntpPacketLen = 48
|
|
ntpModeClient = 3
|
|
ntpModeServer = 4
|
|
ntpUnsynced = 3
|
|
ntpStratumHost = 3
|
|
ntpStratumNone = 16
|
|
ntpPrecision = -20
|
|
ntpEpochOffset = 2208988800
|
|
)
|
|
|
|
var ntpRefID = [4]byte{'L', 'O', 'C', 'L'}
|
|
|
|
type Clock interface {
|
|
Now() time.Time
|
|
Sync() (synced bool, maxError time.Duration, err error)
|
|
}
|
|
|
|
func validNTPRequest(b []byte) error {
|
|
if len(b) < ntpPacketLen {
|
|
return fmt.Errorf("ntp packet of %d bytes is shorter than %d", len(b), ntpPacketLen)
|
|
}
|
|
if mode := b[0] & 0x07; mode != ntpModeClient {
|
|
return fmt.Errorf("ntp mode %d is not a client request", mode)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validNTPAnswer(request, answer []byte) error {
|
|
if len(answer) < ntpPacketLen {
|
|
return fmt.Errorf("ntp answer of %d bytes is shorter than %d", len(answer), ntpPacketLen)
|
|
}
|
|
if mode := answer[0] & 0x07; mode != ntpModeServer {
|
|
return fmt.Errorf("ntp answer mode %d is not a server reply", mode)
|
|
}
|
|
if !bytes.Equal(answer[24:32], request[40:48]) {
|
|
return errors.New("ntp answer origin timestamp does not match the request")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func ntpTimestamp(t time.Time) uint64 {
|
|
secs := uint64(t.Unix() + ntpEpochOffset)
|
|
frac := (uint64(t.Nanosecond()) << 32) / uint64(time.Second)
|
|
return secs<<32 | frac
|
|
}
|
|
|
|
func ntpShort(d time.Duration) uint32 {
|
|
if d < 0 {
|
|
d = 0
|
|
}
|
|
secs := uint64(d / time.Second)
|
|
if secs > 0xffff {
|
|
return 0xffffffff
|
|
}
|
|
frac := (uint64(d%time.Second) << 16) / uint64(time.Second)
|
|
return uint32(secs<<16 | frac)
|
|
}
|
|
|
|
func hostReply(request []byte, received, sent time.Time, synced bool, maxError time.Duration) []byte {
|
|
reply := make([]byte, ntpPacketLen)
|
|
version := (request[0] >> 3) & 0x07
|
|
leap, stratum := byte(0), byte(ntpStratumHost)
|
|
if !synced {
|
|
leap, stratum = ntpUnsynced, ntpStratumNone
|
|
}
|
|
reply[0] = leap<<6 | version<<3 | ntpModeServer
|
|
reply[1] = stratum
|
|
reply[2] = request[2]
|
|
precision := int8(ntpPrecision)
|
|
reply[3] = byte(precision)
|
|
binary.BigEndian.PutUint32(reply[8:12], ntpShort(maxError))
|
|
copy(reply[12:16], ntpRefID[:])
|
|
binary.BigEndian.PutUint64(reply[16:24], ntpTimestamp(received))
|
|
copy(reply[24:32], request[40:48])
|
|
binary.BigEndian.PutUint64(reply[32:40], ntpTimestamp(received))
|
|
binary.BigEndian.PutUint64(reply[40:48], ntpTimestamp(sent))
|
|
return reply
|
|
}
|
|
|
|
func exchangeNTP(servers []string, request []byte, timeout time.Duration) ([]byte, error) {
|
|
var errs []error
|
|
for _, server := range servers {
|
|
answer, err := exchangeNTPOne(server, request, timeout)
|
|
if err == nil {
|
|
return answer, nil
|
|
}
|
|
errs = append(errs, fmt.Errorf("%s: %w", server, err))
|
|
}
|
|
return nil, fmt.Errorf("no ntp upstream answered: %w", errors.Join(errs...))
|
|
}
|
|
|
|
func exchangeNTPOne(server string, request []byte, timeout time.Duration) ([]byte, error) {
|
|
conn, err := net.DialTimeout("udp", server, timeout)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer conn.Close()
|
|
if err := conn.SetDeadline(time.Now().Add(timeout)); err != nil {
|
|
return nil, err
|
|
}
|
|
if _, err := conn.Write(request[:ntpPacketLen]); err != nil {
|
|
return nil, err
|
|
}
|
|
buf := make([]byte, 1024)
|
|
for {
|
|
n, err := conn.Read(buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if validNTPAnswer(request, buf[:n]) == nil {
|
|
return buf[:n], nil
|
|
}
|
|
}
|
|
}
|