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

猫神父

同样的代码，易语言编译后有点大104k，代码也有点长
迁移成C之后编译只有15.5k

  

窗口程序集名	保 留	保 留	备 注
程序集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)

用大模型迁移成C，用中文宏定义C的变量名和函数名，代码如下(该代码可以直接编译成x86、x64程序):

  

#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 /> }

C编译

黑月编译

猫神父

NTP同步网络时间C编译.7z (4.52 KB, 下载次数: 1)

2024-8-22 01:09 上传

点击文件名下载附件
C编译，零误报

把程序编译了

zhixiao

用的是哪个大模型

胖子葛格

感谢大神分享~！

ctry78985

感谢分享

djawei1990

谢谢分享 支持

396384183

支持开源~！感谢分享

xue9528

感谢分享

wuqingg

renhe2018

网络时间同步，很实用啊。前两天就遇上主板电池没电，又不想换电池的主。哈哈。