NTP同步互联网时间，大模型测试翻译易代码，无痛迁移到C - 精易论坛

窗口程序集名	保留	保留	备注
程序集1

子程序名	返回值类型	公开	备注
_启动子程序	整数型		请在本子程序中放置动态链接库初始化代码

_临时子程序 () ' 在初始化代码执行完毕后调用测试代码
返回 (0) ' 返回值被忽略。

子程序名	返回值类型	公开	备注
_临时子程序

变量名	类型	静态	数组	备注
time	长整数型

' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。
time ＝ GetNTPTime ()
' 到时间 (取字节集数据 (到字节集 (time), #日期时间型, ))
输出调试文本 (强制类型转换 (time, #日期时间型 ))

子程序名	返回值类型	公开	备注
GetNTPTime	长整数型

变量名	类型	静态	数组	备注
time	长整数型

计次循环首 (5, )

time ＝ NTP时间 (NTP服务器池 (), 500)

如果真 (time ≠ 0)

跳出循环 ()

计次循环尾 ()
返回 (time)

子程序名	返回值类型	公开	备注
NTP服务器池	文本型

变量名	类型	静态	数组	备注
TimeURL	文本型		0
n	整数型

TimeURL ＝分割文本 ( #NTP_SERVER, #换行符, )

变量循环首 (取数组成员数 (TimeURL), 1, -1, n)

如果真 (TimeURL [n] ＝ “”)

删除成员 (TimeURL, n, )

变量循环尾 ()
置随机数种子 (取启动时间 ())
n ＝取随机数 (1, 取数组成员数 (TimeURL))
输出调试文本 (“NTP:” ＋ TimeURL [n])
返回 (TimeURL [n])

子程序名	返回值类型	公开	备注
NTP时间	长整数型
参数名	类型	参考	可空	数组	备注
NTP_URL	文本型
timeout	整数型

变量名	类型	静态	数组	备注
NTP_PORT	整数型
数据包	字节集
hSocket
hConnect
iResult
补偿值
时标	长整数型		4
时间数据	字节集
正确时间	日期时间型
NULL	长整数型
T	字节集		3
Buffer	整数型
ret	整数型

NTP_PORT ＝ 123

如果真 (套接字_加载服务 ())

hSocket ＝套接字_创建 ()

如果真 (hSocket ≠ 0)

如果真 (套接字_置超时 (hSocket, timeout))

hConnect ＝套接字_连接 (hSocket, NTP_URL, NTP_PORT)

如果真 (hConnect ≠ -1)

时标 [1] ＝取时间标识 ()

数据包＝ { 27 } ＋取重复字节集 (39, { 0 }) ＋到字节集 (时标 [1]) ' 48个字节' 取时间间隔 (取现行时间 (), [1970年1月1日], #秒) ' 也可以—>取时间标识 () ' 始发时间戳

如果真 (套接字_发送 (hSocket, 数据包))

时标 [4] ＝取时间标识 ()

Buffer ＝ _申请内存 (48)

ret ＝ Recv (hSocket, Buffer, 48, 0)

如果真 (ret ≠ -1)

时间数据＝指针到字节集 (Buffer, 48)

T [1] ＝取字节集中间 (时间数据, 25, 8)

T [2] ＝取字节集中间 (时间数据, 33, 4)

T [3] ＝取字节集中间 (时间数据, 41, 4)

时标 [2] ＝转换字节序 (T [2])

时标 [3] ＝转换字节序 (T [3])

补偿值＝ (时标 [2] －时标 [1] ＋时标 [3] －时标 [4]) ÷ 2

如果真 (T [1] ＝到字节集 (时标 [1]))

正确时间＝增减时间 (取现行时间 (), #秒, 补偿值)

_释放内存 (Buffer)

套接字_销毁 (hConnect)

套接字_销毁 (hSocket)

套接字_卸载服务 ()

返回 (取字节集数据 (到字节集 (正确时间), #长整数型, ))

_释放内存 (Buffer)

' 4层对应连接

套接字_销毁 (hConnect)

' 2层对应套接字创建

套接字_销毁 (hSocket)

' 1层对应加载

套接字_卸载服务 ()
返回 (NULL)

子程序名	返回值类型	公开	备注
转换字节序	长整数型
参数名	类型	参考	可空	数组	备注
时标字节组	字节集

返回 (到数值 (时标字节组 [1]) × 16777216 ＋到数值 (时标字节组 [2]) × 65536 ＋到数值 (时标字节组 [3]) × 256 ＋到数值 (时标字节组 [4]))

子程序名	返回值类型	公开	备注
取时间标识	长整数型

变量名	类型	静态	数组	备注
时标	长整数型

时标＝取时间间隔 (取现行时间 (), [1900年1月1日], #秒 ) ＋ 4294967296 ' ' ----因计算果已经溢出。故用+4294967296求补（2^32次方）获得正确结果
返回 (时标－ 28800) ' - 28800 修正8小时时区差。 3600*8=60*60*8

子程序名	返回值类型	公开	备注
域名转IP	长整数型		根据指定的机器名取IP地址。失败返回空。本命令为超级命令。
参数名	类型	参考	可空	数组	备注
域名	文本型				要取得IP地址的机器名。

变量名	类型	静态	数组	备注
lpHost	整数型
HOST	HOSTENT
dwIPAddr	整数型
tmpIPAddr	字节型		0
i	整数型
IP地址	文本型

lpHost ＝ GetHostByName (到文本 (域名))

如果真 (lpHost ＝ 0)

WSACleanup ()

返回 (0)
RtlMoveMemoryAny (HOST, lpHost, 16)
RtlMoveMemoryGetInt (dwIPAddr, HOST.hAddrList, 4)
重定义数组 (tmpIPAddr, 假, HOST.hLen)
RtlMoveMemoryBit (tmpIPAddr, dwIPAddr, HOST.hLen)

计次循环首 (HOST.hLen, i)

如果 (i ＝ HOST.hLen)

IP地址＝ IP地址＋到文本 (tmpIPAddr [i])

IP地址＝ IP地址＋到文本 (tmpIPAddr [i]) ＋ “.”

计次循环尾 ()
返回 (Inet_Addr (IP地址))

子程序名	返回值类型	公开	备注
强制类型转换	通用型
参数名	类型	参考	可空	数组	备注
变量	通用型
类型	整数型				常量 #整数型 #日期时间型等等

置入代码 ({ 139, 69, 8 })
' mov eax,[ebp+08h]

判断 (类型＝ #字节型 )

置入代码 ({ 185, 1, 1, 0, 128 })

' 可容纳 0 到 255 之间的数值。

' mov ecx,80000101h

判断 (类型＝ #短整数型 )

' 可容纳 -32,768 到 32,767 之间的数值, 尺寸为 2 个字节。

置入代码 ({ 185, 1, 2, 0, 128 })

' mov ecx,80000201h

判断 (类型＝ #整数型 )

' 可容纳 -2,147,483,648 到 2,147,483,647 之间的数值, 尺寸为 4 个字节。

置入代码 ({ 185, 1, 3, 0, 128 })

' mov ecx,80000301h

判断 (类型＝ #长整数型 )

' 可容纳 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 之间的数值, 尺寸为 8 个字节。

置入代码 ({ 139, 80, 4 })

' mov edx,[eax+4]

置入代码 ({ 185, 1, 4, 0, 128 })

' mov ecx,80000401h

判断 (类型＝ #小数型 )

' 可容纳 3.4E +/- 38 (7位小数) 之间的数值, 尺寸为 4 个字节。

置入代码 ({ 185, 1, 5, 0, 128 })

' mov ecx,80000501h

判断 (类型＝ #双精度小数型 )

' 可容纳 1.7E +/- 308 (15位小数) 之间的数值, 尺寸为 8 个字节。

置入代码 ({ 139, 80, 4 })

' mov edx,[eax+4]

置入代码 ({ 185, 1, 6, 0, 128 })

' mov ecx,80000601h

判断 (类型＝ #逻辑型 )

' 值只可能为“真”或“假”，尺寸为 2 个字节。

置入代码 ({ 185, 2, 0, 0, 128 })

' mov ecx,80000002h

判断 (类型＝ #日期时间型 )

' 用作记录日期及时间, 尺寸为 8 个字节。

置入代码 ({ 139, 80, 4 })

' mov edx,[eax+4]

置入代码 ({ 185, 3, 0, 0, 128 })

' mov ecx,80000003h

判断 (类型＝ #文本型 )

' 用作记录一段文本, 文本由以字节 0 结束的一系列字符组成。

置入代码 ({ 185, 4, 0, 0, 128 })

' mov ecx,80000004h

判断 (类型＝ #字节集型 )

' 用作记录一段字节型数据。字节集与字节数组之间可以互相转换, 两者之间唯一的不同是字节集可以变长, 因此可把字节集看作可变长的字节数组。

置入代码 ({ 185, 5, 0, 0, 128 })

' mov ecx,80000005h

' 置入代码 ({ 185, 5, 0, 0, 128 })

判断 (类型＝ #子程序指针型 )

' 作指向一个子程序, 尺寸为 4 个字节。

置入代码 ({ 185, 6, 0, 0, 128 })

' mov ecx,80000006h

置入代码 ({ 139, 0, 201, 194, 8, 0 })
' mov eax,[eax]
' leave
' retn 8
返回 (0)

.版本 2<br />
<br />
.程序集 程序集1<br />
<br />
.子程序 _启动子程序, 整数型, , 请在本子程序中放置动态链接库初始化代码<br />
<br />
<br />
_临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码<br />
返回 (0)  ' 返回值被忽略。<br />
<br />
.子程序 _临时子程序<br />
.局部变量 time, 长整数型<br />
<br />
' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。<br />
<br />
time ＝ GetNTPTime ()<br />
' 到时间 (取字节集数据 (到字节集 (time), #日期时间型, ))<br />
输出调试文本 (强制类型转换 (time, #日期时间型))<br />
<br />
.子程序 GetNTPTime, 长整数型, 公开<br />
.局部变量 time, 长整数型<br />
<br />
.计次循环首 (5, )<br />
    time ＝ NTP时间 (NTP服务器池 (), 500)<br />
    .如果真 (time ≠ 0)<br />
        跳出循环 ()<br />
    .如果真结束<br />
<br />
.计次循环尾 ()<br />
返回 (time)<br />
<br />
.子程序 NTP服务器池, 文本型<br />
.局部变量 TimeURL, 文本型, , "0"<br />
.局部变量 n, 整数型<br />
<br />
TimeURL ＝ 分割文本 (#NTP_SERVER, #换行符, )<br />
.变量循环首 (取数组成员数 (TimeURL), 1, -1, n)<br />
    .如果真 (TimeURL [n] ＝ “”)<br />
        删除成员 (TimeURL, n, )<br />
    .如果真结束<br />
<br />
.变量循环尾 ()<br />
置随机数种子 (取启动时间 ())<br />
n ＝ 取随机数 (1, 取数组成员数 (TimeURL))<br />
输出调试文本 (“NTP:” ＋ TimeURL [n])<br />
返回 (TimeURL [n])<br />
<br />
.子程序 NTP时间, 长整数型<br />
.参数 NTP_URL, 文本型<br />
.参数 timeout, 整数型<br />
.局部变量 NTP_PORT, 整数型<br />
.局部变量 数据包, 字节集<br />
.局部变量 hSocket<br />
.局部变量 hConnect<br />
.局部变量 iResult<br />
.局部变量 补偿值<br />
.局部变量 时标, 长整数型, , "4"<br />
.局部变量 时间数据, 字节集<br />
.局部变量 正确时间, 日期时间型<br />
.局部变量 NULL, 长整数型<br />
.局部变量 T, 字节集, , "3"<br />
.局部变量 Buffer, 整数型<br />
.局部变量 ret, 整数型<br />
<br />
NTP_PORT ＝ 123<br />
<br />
.如果真 (套接字_加载服务 ())<br />
    hSocket ＝ 套接字_创建 ()<br />
    .如果真 (hSocket ≠ 0)<br />
        .如果真 (套接字_置超时 (hSocket, timeout))<br />
            hConnect ＝ 套接字_连接 (hSocket, NTP_URL, NTP_PORT)<br />
            .如果真 (hConnect ≠ -1)<br />
                时标 [1] ＝ 取时间标识 ()<br />
                数据包 ＝ { 27 } ＋ 取重复字节集 (39, { 0 }) ＋ 到字节集 (时标 [1])  ' 48个字节' 取时间间隔 (取现行时间 (), [1970年1月1日], #秒)  ' 也可以—>取时间标识 ()  ' 始发时间戳<br />
                .如果真 (套接字_发送 (hSocket, 数据包))<br />
<br />
                    时标 [4] ＝ 取时间标识 ()<br />
<br />
                    Buffer ＝ _申请内存 (48)<br />
                    ret ＝ Recv (hSocket, Buffer, 48, 0)<br />
                    .如果真 (ret ≠ -1)<br />
                        时间数据 ＝ 指针到字节集 (Buffer, 48)<br />
<br />
                        T [1] ＝ 取字节集中间 (时间数据, 25, 8)<br />
                        T [2] ＝ 取字节集中间 (时间数据, 33, 4)<br />
                        T [3] ＝ 取字节集中间 (时间数据, 41, 4)<br />
                        时标 [2] ＝ 转换字节序 (T [2])<br />
                        时标 [3] ＝ 转换字节序 (T [3])<br />
<br />
                        补偿值 ＝ (时标 [2] － 时标 [1] ＋ 时标 [3] － 时标 [4]) ÷ 2<br />
                        .如果真 (T [1] ＝ 到字节集 (时标 [1]))<br />
                            正确时间 ＝ 增减时间 (取现行时间 (), #秒, 补偿值)<br />
<br />
                            _释放内存 (Buffer)<br />
                            套接字_销毁 (hConnect)<br />
                            套接字_销毁 (hSocket)<br />
                            套接字_卸载服务 ()<br />
<br />
                            返回 (取字节集数据 (到字节集 (正确时间), #长整数型, ))<br />
                        .如果真结束<br />
<br />
                    .如果真结束<br />
<br />
<br />
<br />
                    _释放内存 (Buffer)<br />
                .如果真结束<br />
<br />
<br />
<br />
                ' 4层对应连接<br />
                套接字_销毁 (hConnect)<br />
            .如果真结束<br />
<br />
        .如果真结束<br />
<br />
<br />
<br />
        ' 2层对应套接字创建<br />
        套接字_销毁 (hSocket)<br />
    .如果真结束<br />
<br />
<br />
<br />
    ' 1层对应加载<br />
    套接字_卸载服务 ()<br />
.如果真结束<br />
返回 (NULL)<br />
<br />
.子程序 转换字节序, 长整数型<br />
.参数 时标字节组, 字节集<br />
<br />
返回 (到数值 (时标字节组 [1]) × 16777216 ＋ 到数值 (时标字节组 [2]) × 65536 ＋ 到数值 (时标字节组 [3]) × 256 ＋ 到数值 (时标字节组 [4]))<br />
<br />
.子程序 取时间标识, 长整数型<br />
.局部变量 时标, 长整数型<br />
<br />
时标 ＝ 取时间间隔 (取现行时间 (), [1900年1月1日], #秒) ＋ 4294967296  ' ' ----因计算果已经溢出。故用+4294967296求补（2^32次方）获得正确结果<br />
返回 (时标 － 28800)  ' - 28800 修正8小时时区差。 3600*8=60*60*8<br />
<br />
.子程序 域名转IP, 长整数型, , 根据指定的机器名取IP地址。失败返回空。本命令为超级命令。<br />
.参数 域名, 文本型, , 要取得IP地址的机器名。<br />
.局部变量 lpHost, 整数型<br />
.局部变量 HOST, HOSTENT<br />
.局部变量 dwIPAddr, 整数型<br />
.局部变量 tmpIPAddr, 字节型, , "0"<br />
.局部变量 i, 整数型<br />
.局部变量 IP地址, 文本型<br />
<br />
lpHost ＝ GetHostByName (到文本 (域名))<br />
.如果真 (lpHost ＝ 0)<br />
    WSACleanup ()<br />
    返回 (0)<br />
.如果真结束<br />
RtlMoveMemoryAny (HOST, lpHost, 16)<br />
RtlMoveMemoryGetInt (dwIPAddr, HOST.hAddrList, 4)<br />
重定义数组 (tmpIPAddr, 假, HOST.hLen)<br />
RtlMoveMemoryBit (tmpIPAddr, dwIPAddr, HOST.hLen)<br />
.计次循环首 (HOST.hLen, i)<br />
    .如果 (i ＝ HOST.hLen)<br />
        IP地址 ＝ IP地址 ＋ 到文本 (tmpIPAddr <i>)<br />
    .否则<br />
        IP地址 ＝ IP地址 ＋ 到文本 (tmpIPAddr <i>) ＋ “.”<br />
    .如果结束<br />
<br />
.计次循环尾 ()<br />
返回 (Inet_Addr (IP地址))<br />
<br />
.子程序 强制类型转换, 通用型<br />
.参数 变量, 通用型, 参考<br />
.参数 类型, 整数型, , 常量 #整数型 #日期时间型 等等<br />
<br />
置入代码 ({ 139, 69, 8 })<br />
' mov eax,[ebp+08h]<br />
.判断开始 (类型 ＝ #字节型)<br />
    置入代码 ({ 185, 1, 1, 0, 128 })<br />
    ' 可容纳 0 到 255 之间的数值。<br />
    ' mov ecx,80000101h<br />
.判断 (类型 ＝ #短整数型)<br />
    ' 可容纳 -32,768 到 32,767 之间的数值, 尺寸为 2 个字节。<br />
    置入代码 ({ 185, 1, 2, 0, 128 })<br />
    ' mov ecx,80000201h<br />
.判断 (类型 ＝ #整数型)<br />
    ' 可容纳 -2,147,483,648 到 2,147,483,647 之间的数值, 尺寸为 4 个字节。<br />
    置入代码 ({ 185, 1, 3, 0, 128 })<br />
    ' mov ecx,80000301h<br />
.判断 (类型 ＝ #长整数型)<br />
    ' 可容纳 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 之间的数值, 尺寸为 8 个字节。<br />
    置入代码 ({ 139, 80, 4 })<br />
    ' mov edx,[eax+4]<br />
    置入代码 ({ 185, 1, 4, 0, 128 })<br />
    ' mov ecx,80000401h<br />
.判断 (类型 ＝ #小数型)<br />
    ' 可容纳 3.4E +/- 38 (7位小数) 之间的数值, 尺寸为 4 个字节。<br />
    置入代码 ({ 185, 1, 5, 0, 128 })<br />
    ' mov ecx,80000501h<br />
.判断 (类型 ＝ #双精度小数型)<br />
    ' 可容纳 1.7E +/- 308 (15位小数) 之间的数值, 尺寸为 8 个字节。<br />
    置入代码 ({ 139, 80, 4 })<br />
    ' mov edx,[eax+4]<br />
    置入代码 ({ 185, 1, 6, 0, 128 })<br />
    ' mov ecx,80000601h<br />
.判断 (类型 ＝ #逻辑型)<br />
    ' 值只可能为“真”或“假”，尺寸为 2 个字节。<br />
    置入代码 ({ 185, 2, 0, 0, 128 })<br />
    ' mov ecx,80000002h<br />
.判断 (类型 ＝ #日期时间型)<br />
    ' 用作记录日期及时间, 尺寸为 8 个字节。<br />
    置入代码 ({ 139, 80, 4 })<br />
    ' mov edx,[eax+4]<br />
    置入代码 ({ 185, 3, 0, 0, 128 })<br />
    ' mov ecx,80000003h<br />
.判断 (类型 ＝ #文本型)<br />
    ' 用作记录一段文本, 文本由以字节 0 结束的一系列字符组成。<br />
    置入代码 ({ 185, 4, 0, 0, 128 })<br />
    ' mov ecx,80000004h<br />
.判断 (类型 ＝ #字节集型)<br />
    ' 用作记录一段字节型数据。字节集与字节数组之间可以互相转换, 两者之间唯一的不同是字节集可以变长, 因此可把字节集看作可变长的字节数组。<br />
    置入代码 ({ 185, 5, 0, 0, 128 })<br />
    ' mov ecx,80000005h<br />
    ' 置入代码 ({ 185, 5, 0, 0, 128 })<br />
.判断 (类型 ＝ #子程序指针型)<br />
    ' 作指向一个子程序, 尺寸为 4 个字节。<br />
    置入代码 ({ 185, 6, 0, 0, 128 })<br />
    ' mov ecx,80000006h<br />
.默认<br />
<br />
.判断结束<br />
置入代码 ({ 139, 0, 201, 194, 8, 0 })<br />
' mov eax,[eax]<br />
' leave<br />
' retn 8<br />
返回 (0)

#define _CRT_SECURE_NO_WARNINGS
#define 格式化打印 _snprintf
#include
#include
#include
#include
#include
#include
#include
#include
#pragma comment (lib, "ws2_32.lib")
#define NTP时间戳差值 2208988800ull
#define 最大服务器数 20
#define _CRT_SECURE_NO_WARNINGS
#define 无符号字节 uint8_t
#define 无符号整型 uint32_t
#define 长整数型 long long
#define 时间类型 time_t
#define 字节型 char
#define 双精度小数型 double
#define 整数型 DWORD
#define 短整数型 short
typedef struct {
无符号字节 li_vn_模式;
无符号字节层级;
无符号字节轮询;
无符号字节精度;
无符号整型根延迟;
无符号整型根离散;
无符号整型参考标识;
无符号整型参考时间_秒;
无符号整型参考时间_分数;
无符号整型原始时间_秒;
无符号整型原始时间_分数;
无符号整型接收时间_秒;
无符号整型接收时间_分数;
无符号整型发送时间_秒;
无符号整型发送时间_分数;
} NTP数据包;
typedef struct {
字节型地址[256];
int 失败次数;
} NTP服务器;
NTP服务器 ntp服务器列表[最大服务器数] = {
{ "ntp.aliyun.com", 0 },
{ "time.asia.apple.com", 0 },
{ "cn.ntp.org.cn", 0 },
{ "time.windows.com", 0 },
{ "cn.pool.ntp.org", 0 },
{ "asia.pool.ntp.org", 0 },
{ "time.google.com", 0 },
{ "time.cloudflare.com", 0 },
{ "time.hko.hk", 0 },
{ "ntp.nict.jp", 0 },
{ "time.nist.gov", 0 },
{ "ntp.tuna.tsinghua.edu.cn", 0 },
{ "ntp.neu.edu.cn", 0 },
{ "ntp.nc.u-tokyo.ac.jp", 0 },
{ "ntp.ix.ru", 0 }
};
int ntp服务器数量 = 15;
void 记录错误 (const 字节型* 服务器) {
FILE* 日志文件;
if (fopen_s (&日志文件, "error.log", "a") == 0 && 日志文件) {
fprintf (日志文件, "%s - 连接超时: %s\n", __DATE__, 服务器);
fclose (日志文件);
}
}
void 读取错误日志 () {
FILE* 文件;
if (fopen_s (&文件, "error.log", "r") == 0 && 文件) {
字节型行[256];
while (fgets (行, sizeof (行), 文件)) {
字节型* 服务器 = strstr (行, "连接超时: ");
if (服务器) {
服务器 += 20;
字节型* 结束 = strchr (服务器, ' \n');
if (结束) *结束 = ' \0';
for (int i = 0; i < ntp服务器数量; i++) {
if (strcmp (ntp服务器列表[i].地址, 服务器) == 0) {
memmove (&ntp服务器列表[i], &ntp服务器列表[i + 1], (ntp服务器数量 - i - 1) * sizeof (NTP服务器));
ntp服务器数量--;
break;
}
}
}
}
fclose (文件);
}
}
int 选择服务器 () {
int 总权重 = 0;
for (int i = 0; i < ntp服务器数量; i++) {
总权重 += (10 - ntp服务器列表[i].失败次数);
}
int 随机权重 = rand () % 总权重;
for (int i = 0; i < ntp服务器数量; i++) {
随机权重 -= (10 - ntp服务器列表[i].失败次数);
if (随机权重 < 0) {
return i;
}
}
return 0;
}
长整数型获取NTP时间 () {
static int 已初始化 = 0;
if (!已初始化) {
读取错误日志 ();
已初始化 = 1;
}
WSADATA wsa数据;
if (WSAStartup (MAKEWORD (2, 2), &wsa数据) != 0) {
return 0;
}
srand ( (unsigned int)time (NULL));
LARGE_INTEGER 频率, 开始, 结束;
QueryPerformanceFrequency (&频率);
for (int 尝试 = 0; 尝试 < 5; 尝试++) {
int 服务器索引 = 选择服务器 ();
const 字节型* 主机名 = ntp服务器列表[服务器索引].地址;
短整数型端口号 = 123;
字节型端口字符串[6];
格式化打印 (端口字符串, sizeof (端口字符串), "%d", 端口号);
struct addrinfo 提示 = { 0 }, *服务器信息, *p;
提示.ai_family = AF_UNSPEC;
提示.ai_socktype = SOCK_DGRAM;
提示.ai_protocol = IPPROTO_UDP;
if (getaddrinfo (主机名, 端口字符串, &提示, &服务器信息) != 0) {
continue;
}
SOCKET 套接字 = INVALID_SOCKET;
for (p = 服务器信息; p != NULL; p = p->ai_next) {
套接字 = socket (p->ai_family, p->ai_socktype, p->ai_protocol);
if (套接字 == INVALID_SOCKET) {
continue;
}
整数型超时 = 2000;
setsockopt (套接字, SOL_SOCKET, SO_RCVTIMEO, (const 字节型*)&超时, sizeof (超时));
setsockopt (套接字, SOL_SOCKET, SO_SNDTIMEO, (const 字节型*)&超时, sizeof (超时));
if (connect (套接字, p->ai_addr, (int)p->ai_addrlen) == SOCKET_ERROR) {
if (WSAGetLastError () == WSAETIMEDOUT) {
记录错误 (主机名);
ntp服务器列表[服务器索引].失败次数++;
}
closesocket (套接字);
套接字 = INVALID_SOCKET;
continue;
}
break;
}
if (套接字 == INVALID_SOCKET) {
freeaddrinfo (服务器信息);
continue;
}
QueryPerformanceCounter (&开始);
NTP数据包数据包 = { 0 };
数据包.li_vn_模式 = 0x1b;
if (send (套接字, (字节型*)&数据包, sizeof (NTP数据包), 0) == SOCKET_ERROR) {
closesocket (套接字);
freeaddrinfo (服务器信息);
continue;
}
if (recv (套接字, (字节型*)&数据包, sizeof (NTP数据包), 0) == SOCKET_ERROR) {
if (WSAGetLastError () == WSAETIMEDOUT) {
记录错误 (主机名);
ntp服务器列表[服务器索引].失败次数++;
}
closesocket (套接字);
freeaddrinfo (服务器信息);
continue;
}
QueryPerformanceCounter (&结束);
数据包.发送时间_秒 = ntohl (数据包.发送时间_秒);
数据包.发送时间_分数 = ntohl (数据包.发送时间_分数);
时间类型发送时间 = (时间类型) (数据包.发送时间_秒 - NTP时间戳差值);
双精度小数型经过时间 = (结束.QuadPart - 开始.QuadPart) * 1000.0 / 频率.QuadPart;
时间类型调整后时间 = 发送时间 + (时间类型) (经过时间 / 2000.0);
SYSTEMTIME 系统时间;
GetSystemTime (&系统时间);
FILETIME 文件时间;
SystemTimeToFileTime (&系统时间, &文件时间);
ULARGE_INTEGER 大整数;
大整数.LowPart = 文件时间.dwLowDateTime;
大整数.HighPart = 文件时间.dwHighDateTime;
大整数.QuadPart += (调整后时间 - time (NULL)) * 10000000ULL;
文件时间.dwLowDateTime = 大整数.LowPart;
文件时间.dwHighDateTime = 大整数.HighPart;
FileTimeToSystemTime (&文件时间, &系统时间);
SetSystemTime (&系统时间);
closesocket (套接字);
freeaddrinfo (服务器信息);
WSACleanup ();
return (长整数型)调整后时间;
}
WSACleanup ();
return 0;
}
int main () {
长整数型 ntp时间 = 获取NTP时间 ();
if (ntp时间 != 0) {
printf ("NTP时间已同步到系统\n");
时间类型 t = (时间类型)ntp时间;
struct tm 时间信息;
localtime_s (&时间信息, &t);
字节型日期时间[64];
strftime (日期时间, sizeof (日期时间), "%Y-%m-%d %H:%M:%S", &时间信息);
printf ("同步后的系统时间: %s\n", 日期时间);
}
else {
printf ("获取NTP时间失败\n");
}
return 0;
}

#define _CRT_SECURE_NO_WARNINGS<br />
#define 格式化打印 _snprintf<br />
<br />
#include <br />
#include <br />
#include <br />
#include <br />
#include <br />
#include <br />
#include <br />
#include <br />
<br />
#pragma comment(lib, "ws2_32.lib")<br />
<br />
#define NTP时间戳差值 2208988800ull<br />
#define 最大服务器数 20<br />
#define _CRT_SECURE_NO_WARNINGS<br />
<br />
#define 无符号字节 uint8_t<br />
#define 无符号整型 uint32_t<br />
#define 长整数型 long long<br />
#define 时间类型 time_t<br />
#define 字节型 char<br />
#define 双精度小数型 double<br />
#define 整数型 DWORD<br />
#define 短整数型 short<br />
<br />
typedef struct {<br />
        无符号字节 li_vn_模式;<br />
        无符号字节 层级;<br />
        无符号字节 轮询;<br />
        无符号字节 精度;<br />
        无符号整型 根延迟;<br />
        无符号整型 根离散;<br />
        无符号整型 参考标识;<br />
        无符号整型 参考时间_秒;<br />
        无符号整型 参考时间_分数;<br />
        无符号整型 原始时间_秒;<br />
        无符号整型 原始时间_分数;<br />
        无符号整型 接收时间_秒;<br />
        无符号整型 接收时间_分数;<br />
        无符号整型 发送时间_秒;<br />
        无符号整型 发送时间_分数;<br />
} NTP数据包;<br />
<br />
typedef struct {<br />
        字节型 地址[256];<br />
        int 失败次数;<br />
} NTP服务器;<br />
<br />
NTP服务器 ntp服务器列表[最大服务器数] = {<br />
        { "ntp.aliyun.com", 0 },<br />
        { "time.asia.apple.com", 0 },<br />
        { "cn.ntp.org.cn", 0 },<br />
        { "time.windows.com", 0 },<br />
        { "cn.pool.ntp.org", 0 },<br />
        { "asia.pool.ntp.org", 0 },<br />
        { "time.google.com", 0 },<br />
        { "time.cloudflare.com", 0 },<br />
        { "time.hko.hk", 0 },<br />
        { "ntp.nict.jp", 0 },<br />
        { "time.nist.gov", 0 },<br />
        { "ntp.tuna.tsinghua.edu.cn", 0 },<br />
        { "ntp.neu.edu.cn", 0 },<br />
        { "ntp.nc.u-tokyo.ac.jp", 0 },<br />
        { "ntp.ix.ru", 0 }<br />
};<br />
<br />
int ntp服务器数量 = 15;<br />
<br />
void 记录错误(const 字节型* 服务器) {<br />
        FILE* 日志文件;<br />
        if (fopen_s(&日志文件, "error.log", "a") == 0 && 日志文件) {<br />
                fprintf(日志文件, "%s - 连接超时: %s\n", __DATE__, 服务器);<br />
                fclose(日志文件);<br />
        }<br />
}<br />
<br />
void 读取错误日志() {<br />
        FILE* 文件;<br />
        if (fopen_s(&文件, "error.log", "r") == 0 && 文件) {<br />
                字节型 行[256];<br />
                while (fgets(行, sizeof(行), 文件)) {<br />
                        字节型* 服务器 = strstr(行, "连接超时: ");<br />
                        if (服务器) {<br />
                                服务器 += 20;<br />
                                字节型* 结束 = strchr(服务器, '\n');<br />
                                if (结束) *结束 = '\0';<br />
<br />
                                for (int i = 0; i < ntp服务器数量; i++) {<br />
                                        if (strcmp(ntp服务器列表<i>.地址, 服务器) == 0) {<br />
                                                memmove(&ntp服务器列表<i>, &ntp服务器列表[i + 1], (ntp服务器数量 - i - 1) * sizeof(NTP服务器));<br />
                                                ntp服务器数量--;<br />
                                                break;<br />
                                        }<br />
                                }<br />
                        }<br />
                }<br />
                fclose(文件);<br />
        }<br />
}<br />
<br />
int 选择服务器() {<br />
        int 总权重 = 0;<br />
        for (int i = 0; i < ntp服务器数量; i++) {<br />
                总权重 += (10 - ntp服务器列表<i>.失败次数);<br />
        }<br />
<br />
        int 随机权重 = rand() % 总权重;<br />
        for (int i = 0; i < ntp服务器数量; i++) {<br />
                随机权重 -= (10 - ntp服务器列表<i>.失败次数);<br />
                if (随机权重 < 0) {<br />
                        return i;<br />
                }<br />
        }<br />
        return 0;<br />
}<br />
<br />
长整数型 获取NTP时间() {<br />
        static int 已初始化 = 0;<br />
        if (!已初始化) {<br />
                读取错误日志();<br />
                已初始化 = 1;<br />
        }<br />
<br />
        WSADATA wsa数据;<br />
        if (WSAStartup(MAKEWORD(2, 2), &wsa数据) != 0) {<br />
                return 0;<br />
        }<br />
<br />
        srand((unsigned int)time(NULL));<br />
<br />
        LARGE_INTEGER 频率, 开始, 结束;<br />
        QueryPerformanceFrequency(&频率);<br />
<br />
        for (int 尝试 = 0; 尝试 < 5; 尝试++) {<br />
                int 服务器索引 = 选择服务器();<br />
                const 字节型* 主机名 = ntp服务器列表[服务器索引].地址;<br />
                短整数型 端口号 = 123;<br />
                字节型 端口字符串[6];<br />
                格式化打印(端口字符串, sizeof(端口字符串), "%d", 端口号);<br />
<br />
                struct addrinfo 提示 = { 0 }, *服务器信息, *p;<br />
                提示.ai_family = AF_UNSPEC;<br />
                提示.ai_socktype = SOCK_DGRAM;<br />
                提示.ai_protocol = IPPROTO_UDP;<br />
<br />
                if (getaddrinfo(主机名, 端口字符串, &提示, &服务器信息) != 0) {<br />
                        continue;<br />
                }<br />
<br />
                SOCKET 套接字 = INVALID_SOCKET;<br />
                for (p = 服务器信息; p != NULL; p = p->ai_next) {<br />
                        套接字 = socket(p->ai_family, p->ai_socktype, p->ai_protocol);<br />
                        if (套接字 == INVALID_SOCKET) {<br />
                                continue;<br />
                        }<br />
<br />
                        整数型 超时 = 2000;<br />
                        setsockopt(套接字, SOL_SOCKET, SO_RCVTIMEO, (const 字节型*)&超时, sizeof(超时));<br />
                        setsockopt(套接字, SOL_SOCKET, SO_SNDTIMEO, (const 字节型*)&超时, sizeof(超时));<br />
<br />
                        if (connect(套接字, p->ai_addr, (int)p->ai_addrlen) == SOCKET_ERROR) {<br />
                                if (WSAGetLastError() == WSAETIMEDOUT) {<br />
                                        记录错误(主机名);<br />
                                        ntp服务器列表[服务器索引].失败次数++;<br />
                                }<br />
                                closesocket(套接字);<br />
                                套接字 = INVALID_SOCKET;<br />
                                continue;<br />
                        }<br />
                        break;<br />
                }<br />
<br />
                if (套接字 == INVALID_SOCKET) {<br />
                        freeaddrinfo(服务器信息);<br />
                        continue;<br />
                }<br />
<br />
                QueryPerformanceCounter(&开始);<br />
<br />
                NTP数据包 数据包 = { 0 };<br />
                数据包.li_vn_模式 = 0x1b;<br />
<br />
                if (send(套接字, (字节型*)&数据包, sizeof(NTP数据包), 0) == SOCKET_ERROR) {<br />
                        closesocket(套接字);<br />
                        freeaddrinfo(服务器信息);<br />
                        continue;<br />
                }<br />
<br />
                if (recv(套接字, (字节型*)&数据包, sizeof(NTP数据包), 0) == SOCKET_ERROR) {<br />
                        if (WSAGetLastError() == WSAETIMEDOUT) {<br />
                                记录错误(主机名);<br />
                                ntp服务器列表[服务器索引].失败次数++;<br />
                        }<br />
                        closesocket(套接字);<br />
                        freeaddrinfo(服务器信息);<br />
                        continue;<br />
                }<br />
<br />
                QueryPerformanceCounter(&结束);<br />
<br />
                数据包.发送时间_秒 = ntohl(数据包.发送时间_秒);<br />
                数据包.发送时间_分数 = ntohl(数据包.发送时间_分数);<br />
<br />
                时间类型 发送时间 = (时间类型)(数据包.发送时间_秒 - NTP时间戳差值);<br />
<br />
                双精度小数型 经过时间 = (结束.QuadPart - 开始.QuadPart) * 1000.0 / 频率.QuadPart;<br />
                时间类型 调整后时间 = 发送时间 + (时间类型)(经过时间 / 2000.0);<br />
<br />
                SYSTEMTIME 系统时间;<br />
                GetSystemTime(&系统时间);<br />
                FILETIME 文件时间;<br />
                SystemTimeToFileTime(&系统时间, &文件时间);<br />
                ULARGE_INTEGER 大整数;<br />
                大整数.LowPart = 文件时间.dwLowDateTime;<br />
                大整数.HighPart = 文件时间.dwHighDateTime;<br />
                大整数.QuadPart += (调整后时间 - time(NULL)) * 10000000ULL;<br />
                文件时间.dwLowDateTime = 大整数.LowPart;<br />
                文件时间.dwHighDateTime = 大整数.HighPart;<br />
                FileTimeToSystemTime(&文件时间, &系统时间);<br />
                SetSystemTime(&系统时间);<br />
<br />
                closesocket(套接字);<br />
                freeaddrinfo(服务器信息);<br />
                WSACleanup();<br />
<br />
                return (长整数型)调整后时间;<br />
        }<br />
<br />
        WSACleanup();<br />
        return 0;<br />
}<br />
<br />
int main() {<br />
        长整数型 ntp时间 = 获取NTP时间();<br />
        if (ntp时间 != 0) {<br />
                printf("NTP时间已同步到系统\n");<br />
                时间类型 t = (时间类型)ntp时间;<br />
<br />
                struct tm 时间信息;<br />
                localtime_s(&时间信息, &t);<br />
                字节型 日期时间[64];<br />
                strftime(日期时间, sizeof(日期时间), "%Y-%m-%d %H:%M:%S", &时间信息);<br />
                printf("同步后的系统时间: %s\n", 日期时间);<br />
        }<br />
        else {<br />
                printf("获取NTP时间失败\n");<br />
        }<br />
        return 0;<br />
}