使用Go语言编写一个NTP服务器的流程步骤
更新时间：2024年11月11日 08:21:30 作者：晓琴儿
NTP服务器【Network Time Protocol（NTP）】是用来使计算机时间同步化的一种协议,为了确保封闭局域网内多个服务器的时间同步,我们计划部署一个网络时间同步服务器（NTP服务器）,本文给大家介绍了使用Go语言编写一个NTP服务器的流程步骤,需要的朋友可以参考下
NTP服务介绍
NTP服务器【Network Time Protocol（NTP）】是用来使计算机时间同步化的一种协议。
- 应用场景说明
为了确保封闭局域网内多个服务器的时间同步，我们计划部署一个网络时间同步服务器（NTP服务器）。这一角色将由一台个人笔记本电脑承担，该笔记本将连接到局域网中，并以其当前时间为基准。我们将利用这台笔记本电脑作为NTP服务器，对局域网内的多个运行CentOS 8的服务器进行时间校准，以保证系统时间的一致性和准确性。
NTP协议
- NTP通信协议的传输层协议是UDP
- NTP通信协议的应用层协议是NTP
NTP报文说明
- NTP的报文是48字节
- 第1个字节可以理解为简易的报文头，这8个bit包含Leap Indicator、NTP Version、Mode
a> LI 占用2个bit
b> VN 占用3个bit，笔者编写的服务器设置为版本v4.0
c> Mode 占用3个bit，ntp server时为4，ntp client时为3 - 第2个字节为 Peer Clock Stratum
- 第3个字节为 Peer Polling Interval
- 第4个字节为 Peer Clock Precision
- 第5 - 8字节为 Root Delay
- 第9 - 12字节为 Root Dispersion
- 第13- 16字节为 Reference Identifier
- 第17 - 24字节为 Reference Timestamp 参考时间戳
- 第25 - 32字节为 Originate Timestamp 起始时间戳
- 第33 - 40字节为 Receive Timestamp 接收时间戳
- 第 41 - 48字节 Transmit Timestamp 传输时间戳
根据NTP报文编码实现Go语言的结构体
type NtpPacket struct {
/*
LI: 2bit 00 Leap Indicator(0)
VN: 3bit 100 NTP Version(4)
Mode: 3bit 100 Mode: server(4), client(3)
*/
Header uint8 // 报文头: 包含LI、VN、Mode
Stratum uint8 // Peer Clock Stratum: primary reference (1)
Poll uint8 // Peer Polling Interval: invalid (0)
Precision uint8 // Peer Clock Precision: 0.000000 seconds
RootDelay uint32 // Root Delay
RootDisp uint32 // Root Dispersion
RefID uint32 // Reference Identifier
RefTS uint64 // Reference Timestamp 参考时间戳
OrigTS uint64 // Originate Timestamp 起始时间戳
RecvTS uint64 // Receive Timestamp 接收时间戳
TransTS uint64 // Transmit Timestamp 传输时间戳
}
NTP服务器的源码
- ntpsrv.go
package main
import (
hldlog "NTPServer/log4go"
"encoding/binary"
"fmt"
"log"
"net"
"sync"
"time"
)
const (
STANDARD_PACKET_SIZE = 48 // 标准NTP的报文大小
)
type NTPServer struct {
srvAddress string
conn *net.UDPConn
wait sync.WaitGroup
ntpPack NtpPacket // NTP协议报文
requestCount uint64 // 请求计数
}
type NtpPacket struct {
/*
LI: 2bit 00 Leap Indicator(0)
VN: 3bit 100 NTP Version(4)
Mode: 3bit 100 Mode: server(4), client(3)
*/
Header uint8 // 报文头: 包含LI、VN、Mode
Stratum uint8 // Peer Clock Stratum: primary reference (1)
Poll uint8 // Peer Polling Interval: invalid (0)
Precision uint8 // Peer Clock Precision: 0.000000 seconds
RootDelay uint32 // Root Delay
RootDisp uint32 // Root Dispersion
RefID uint32 // Reference Identifier
RefTS uint64 // Reference Timestamp 参考时间戳
OrigTS uint64 // Originate Timestamp 起始时间戳
RecvTS uint64 // Receive Timestamp 接收时间戳
TransTS uint64 // Transmit Timestamp 传输时间戳
}
func (srv *NTPServer) NewNtpPacket() *NtpPacket {
// 初始化Header字段
header := uint8(0)
header |= (0 << 6) // LI: 2bit 00
header |= (4 << 3) // VN: 3bit 100
header |= (4 << 0) // Mode: 3bit 100
// 创建新的NtpPacket实例
packet := &NtpPacket{
Header: header,
Stratum: 0x01,
Poll: 0x00,
Precision: 0x00,
RootDelay: 0,
RootDisp: 0,
RefID: 0,
RefTS: 0,
OrigTS: 0,
RecvTS: 0,
TransTS: 0,
}
return packet
}
func (pack *NtpPacket) SetTimestamp(timestamp time.Time, field string) {
ntpTime := ToNTPTime(timestamp)
switch field {
case "RefTS":
pack.RefTS = ntpTime
case "OrigTS":
pack.OrigTS = ntpTime
case "RecvTS":
pack.RecvTS = ntpTime
case "TransTS":
pack.TransTS = ntpTime
}
}
// toNTPTime 将Unix时间转换为NTP时间
func ToNTPTime(t time.Time) uint64 {
seconds := uint32(t.Unix()) + 2208988800 // NTP时间从1900年开始计算
fraction := uint32(float64(t.Nanosecond()) * (1 << 32) / 1e9)
return uint64(seconds)<<32 | uint64(fraction)
}
func NewNTPServer(srvAddr string) *NTPServer {
return &NTPServer{srvAddress: srvAddr}
}
// 启动NTP服务器
func (srv *NTPServer) Start() error {
addr, err := net.ResolveUDPAddr("udp", srv.srvAddress)
if err != nil {
return err
}
hldlog.Info(fmt.Sprintf("<%s:%d>", addr.IP.String(), addr.Port))
conn, err := net.ListenUDP("udp", addr)
if err != nil {
return err
}
srv.wait.Add(1)
srv.conn = conn
go RecvMsg(srv)
return nil
}
// 关闭NTP服务器
func (srv *NTPServer) Stop() {
srv.conn.Close()
srv.wait.Wait()
}
// 接收数据
func RecvMsg(srv *NTPServer) {
defer srv.wait.Done()
buffer := make([]byte, 2*1024)
for {
n, remoteAddr, err := srv.conn.ReadFromUDP(buffer[0:])
if err != nil {
fmt.Println("ReadFromUDP error:", err)
return
}
hldlog.Info(fmt.Sprintf("[Recv] %d bytes from <%s>", n, remoteAddr.String()))
if n != STANDARD_PACKET_SIZE {
continue
}
// 接收到NTP客户端消息的时间
recvMsgTime := time.Now().UTC()
recvHexString := BytesToHex(buffer[:n])
hldlog.Info(fmt.Sprintf("[Recv] %s", recvHexString))
udpPacket, err := ParseUDPPacket(buffer[:n])
if err != nil {
log.Printf("Error parsing UDP packet: %v", err)
continue
}
ntpPack := srv.NewNtpPacket()
ntpPack.SetTimestamp(time.Now().UTC(), "RefTS")
ntpPack.OrigTS = udpPacket.TransTS
ntpPack.SetTimestamp(recvMsgTime, "RecvTS")
ntpPack.SetTimestamp(time.Now().UTC(), "TransTS")
sendPacket := ntpPack.Serialize()
sendLen, err := srv.conn.WriteToUDP(sendPacket, remoteAddr)
if err != nil {
log.Println(err.Error())
continue
}
if sendLen > 0 {
hldlog.Info(fmt.Sprintf("[Send] %s", BytesToHex(sendPacket)))
}
srv.requestCount++
}
}
func (pack *NtpPacket) Serialize() []byte {
packet := make([]byte, 48)
// binary.BigEndian.PutUint32(packet[0:4], pack.Header)
packet[0] = pack.Header
packet[1] = pack.Stratum
packet[2] = pack.Poll
packet[3] = pack.Precision
binary.BigEndian.PutUint32(packet[4:8], pack.RootDelay)
binary.BigEndian.PutUint32(packet[8:12], pack.RootDisp)
binary.BigEndian.PutUint32(packet[12:16], pack.RefID)
binary.BigEndian.PutUint64(packet[16:24], pack.RefTS)
binary.BigEndian.PutUint64(packet[24:32], pack.OrigTS)
binary.BigEndian.PutUint64(packet[32:40], pack.RecvTS)
binary.BigEndian.PutUint64(packet[40:48], pack.TransTS)
return packet
}
// BytesToHex 将字节数组转换为16进制字符串
func BytesToHex(data []byte) string {
hexString := make([]byte, 3*len(data)-1)
for i, b := range data {
high := "0123456789ABCDEF"[(b >> 4)]
low := "0123456789ABCDEF"[(b & 0x0F)]
hexString[i*3] = high
hexString[i*3+1] = low
if i < len(data)-1 {
hexString[i*3+2] = ' ' // 每个16进制数据之间加空格
}
}
return string(hexString)
}
func ParseUDPPacket(buf []byte) (*NtpPacket, error) {
if len(buf) < STANDARD_PACKET_SIZE { // 最小有效长度为48字节
return nil, fmt.Errorf("Invalid UDP packet length: %d", len(buf))
}
packet := &NtpPacket{
// Header: binary.BigEndian.Uint32(buf[0:4]),
Header: buf[0],
Stratum: buf[1],
Poll: buf[2],
Precision: buf[3],
RootDelay: binary.BigEndian.Uint32(buf[4:8]),
RootDisp: binary.BigEndian.Uint32(buf[8:12]),
RefID: binary.BigEndian.Uint32(buf[12:16]),
RefTS: binary.BigEndian.Uint64(buf[16:24]),
OrigTS: binary.BigEndian.Uint64(buf[24:32]),
RecvTS: binary.BigEndian.Uint64(buf[32:40]),
TransTS: binary.BigEndian.Uint64(buf[40:48]),
}
return packet, nil
}
- main.go
package main
import (
hldlog "NTPServer/log4go"
"fmt"
"gopkg.in/ini.v1"
"time"
)
type NetAddr struct {
IP string
Port string
}
var LocalHost = NetAddr{IP: "0.0.0.0", Port: "60123"}
func loadConfig() (NetAddr, error) {
// 读取INI配置文件
iniConf, err := ini.Load("./config/config.ini")
if err != nil {
hldlog.Error(fmt.Sprintf("Fail to read INI file: %v", err))
return LocalHost, nil
}
iniSection := iniConf.Section("LocalHost")
return NetAddr{
IP: iniSection.Key("ip").String(),
Port: iniSection.Key("port").String(),
}, nil
}
// 初始化log4go日志库
func init() {
hldlog.LoadConfiguration("./config/log.xml", "xml")
}
func main() {
hldlog.Info("===NTP SERVER Start(48 Bytes)===")
LocalHost, err := loadConfig()
if err != nil {
hldlog.Error(fmt.Sprintf("Failed to load configuration: %v", err))
}
ntpSrv := NewNTPServer(fmt.Sprintf("%s:%s", LocalHost.IP, LocalHost.Port))
ntpSrv.Start()
for {
time.Sleep(60 * time.Second)
}
}
- 代码细节说明
NTP服务器在回复NTP客户端的消息中其中OrigTS uint64（Originate Timestamp 起始时间戳）必须是NTP客户端发送来的TransTS uint64（Transmit Timestamp 传输时间戳）。
验证GoNTPSrv
上述实现的NTP服务已经过Go语言中开源的NTP Client库 https://github.com/beevik/ntp 验证。
- UDP数据包
# 客户端发送的数据 23 00 00 20 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 39 1C 79 9E 83 D3 D5 82 # 服务器返回的数据 24 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 EA D9 CF EE AD 4D DC 2B 39 1C 79 9E 83 D3 D5 82 EA D9 CF EE AD 4D DC 2B EA D9 CF EE AD 4D DC 2B
- NTP Client的简单源码
package main
import (
hldlog "NTPCli/log4go"
"fmt"
"log"
"os"
"os/exec"
"time"
"github.com/beevik/ntp"
"gopkg.in/ini.v1"
)
type NetAddr struct {
IP string
Port int
}
var RemoteAddr = NetAddr{IP: "0.0.0.0", Port: 60123}
func init() {
hldlog.LoadConfiguration("./config/log.xml", "xml")
}
func main() {
hldlog.Info("===NTP CLIENT Start===")
currTime := time.Now()
formattedTime := currTime.Format("2006-01-02 15:04:05.000")
hldlog.Info(formattedTime)
// 读取INI配置文件
iniConf, err := ini.Load("./config/config.ini")
if err != nil {
log.Fatalf("Fail to read INI file: %v", err)
}
remoteSection := iniConf.Section("NTP_SERVER")
RemoteAddr.IP = remoteSection.Key("ip").String()
RemoteAddr.Port, _ = remoteSection.Key("port").Int()
hldlog.Info(fmt.Sprintf("ntp://%s:%d", RemoteAddr.IP, RemoteAddr.Port))
// edu.ntp.org.cn
// resp, err := ntp.Time("edu.ntp.org.cn")
resp, err := ntp.Time(fmt.Sprintf("%s:%d", RemoteAddr.IP, RemoteAddr.Port))
if err != nil {
hldlog.Error(fmt.Sprintf("%v", err))
os.Exit(-1)
}
hldlog.Info(resp.String())
localTime := resp.Local()
hldlog.Info(localTime.Format("2006-01-02 15:04:05.000"))
// setTime(localTime)
for {
time.Sleep(60 * time.Second)
}
}
到此这篇关于使用Go语言编写一个NTP服务器的流程步骤的文章就介绍到这了,更多相关Go编写NTP服务器内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
MinIO 是一款基于 Go 语言的高性能、可扩展、云原生支持、操作简单、开源的分布式对象存储产品,这篇文章主要介绍了minio分布式文件存储,需要的朋友可以参考下2023-10-10
这篇文章主要介绍了深入Golang的接口interface，go不要求类型显示地声明实现了哪个接口，只要实现了相关的方法即可，编译器就能检测到，接下来关于接口interface的相关介绍需要的朋友可以参考下面文章内容2022-06-06
mapstructure用于将通用的map[string]interface{}解码到对应的 Go 结构体中,或者执行相反的操作,本文主要介绍了golang mapstructure库的具体使用,感兴趣的可以了解一下2023-09-09
理解Golang中的数组（array）、切片（slice）和map
这篇文章主要介绍了理解Golang中的数组（array）、切片（slice）和map,本文先是给出代码,然后一一分解,并给出一张内图加深理解,需要的朋友可以参考下2014-10-10
这篇文章主要为大家详细介绍了Go语言中的iota关键字的相关使用,文中的示例代码讲解详细,对我们深入了解Go语言有一定的帮助,需要的可以参考下2023-08-08
这篇文章主要为大家介绍了Go语言Goroutinue和管道效率使用详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2022-09-09
golang封装一个执行命令行的函数(return stderr/stdout/exitcode)示例代码
在 Go 语言中,您可以使用 os/exec 包来执行外部命令,不通过调用 shell,并且能够获得进程的退出码、标准输出和标准错误输出,下面给大家分享golang封装一个执行命令行的函数(return stderr/stdout/exitcode)的方法,感兴趣的朋友跟随小编一起看看吧2024-06-06
golang使用iconv报undefined:XXX的问题处理方案
这篇文章主要介绍了golang使用iconv报undefined:XXX的问题处理方案,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2024-03-03
golang 定时任务方面time.Sleep和time.Tick的优劣对比分析
这篇文章主要介绍了golang 定时任务方面time.Sleep和time.Tick的优劣对比分析，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2021-05-05
这篇文章主要为大家介绍了使用go tar包归档文件处理操作全面指南,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪2023-12-12
最新评论