模拟NTP协议实现时钟同步

Network Time Protocol（NTP）是用来使计算机时间同步化的一种协议，它可以使计算机对其服务器或时钟源（如石英钟，GPS等等)做同步化，它可以提供高精准度的时间校正（LAN上与标准间差小于1毫秒，WAN上几十毫秒），且可介由加密确认的方式来防止恶毒的协议攻击。

NTP提供准确时间，首先要有准确的时间来源，这一时间应该是国际标准时间UTC。 NTP获得UTC的时间来源可以是原子钟、天文台、卫星，也可以从Internet上获取。这样就有了准确而可靠的时间源。时间是按NTP服务器的等级传播。按照距离外部UTC 源的远近将所有服务器归入不同的Stratun（层）中。Stratum-1在顶层，有外部UTC接入，而Stratum-2则从Stratum-1获取时间，Stratum-3从Stratum-2获取时间，以此类推，但Stratum层的总数限制在15以内。所有这些服务器在逻辑上形成阶梯式的架构并相互连接，而Stratum-1的时间服务器是整个系统的基础。

进行网络协议实现时最重要的是了解协议数据格式。NTP数据包有48个字节，其中NTP包头16字节，时间戳32个字节。其协议格式如下图所示。



其协议字段的含义如下所示。

LI：跳跃指示器，警告在当月最后一天的最终时刻插入的迫近闺秒（闺秒）。

VN：版本号。

Mode：工作模式。该字段包括以下值：0－预留；1－对称行为；3－客户机；4－服务器；5－广播；6－NTP控制信息。NTP协议具有3种工作模式，分别为主/被动对称模式、客户/服务器模式、广播模式。在主/被动对称模式中，有一对一的连接，双方均可同步对方或被对方同步，先发出申请建立连接的一方工作在主动模式下，另一方工作在被动模式下；客户/服务器模式与主/被动模式基本相同，惟一区别在于客户方可被服务器同步，但服务器不能被客户同步；在广播模式中，有一对多的连接，服务器不论客户工作在何种模式下，都会主动发出时间信息，客户根据此信息调整自己的时间。

Stratum：对本地时钟级别的整体识别。

Poll：有符号整数表示连续信息间的最大间隔。

Precision：有符号整数表示本地时钟精确度。

Root Delay：表示到达主参考源的一次往复的总延迟，它是有15～16位小数部分的符号定点小数。

Root Dispersion：表示一次到达主参考源的标准误差，它是有15～16位小数部分的无符号定点小数。

Reference Identifier：识别特殊参考源。

Originate Timestamp：这是向服务器请求分离客户机的时间，采用64位时标格式。

Receive Timestamp：这是向服务器请求到达客户机的时间，采用64位时标格式。

Transmit Timestamp：这是向客户机答复分离服务器的时间，采用64位时标格式。

Authenticator（Optional）：当实现了NTP认证模式时，主要标识符和信息数字域就包括已定义的信息认证代码（MAC）信息。
---------------------------------------------------------------------------------------------------------------------------
以上对NTP协议原理的描述来自网络，感谢网络上的朋友！
以下是我写的模拟NTP协议进行时钟同步的Demo程序。完整的代码可从这里下载： http://download.csdn.net/detail/chexlong/3787414
NTP.h

#ifndef NTP_H
#define NTP_H

#include <winsock2.h>
#include <stdio.h>
#include <time.h>
#pragma comment(lib, "WS2_32")	// 链接到WS2_32.lib

#define LI 0
#define VN 3
#define MODE 3
#define STRATUM 0
#define POLL 4
#define PREC -6

#define JAN_1970      0x83aa7e80      /* 2208988800 1970 - 1900 in seconds */
#define NTPFRAC(x) (4294 * (x) + ((1981 * (x))>>11))
#define USEC(x) (((x) >> 12) - 759 * ((((x) >> 10) + 32768) >> 16))

typedef struct ntptime_t
{
unsigned int coarse;
unsigned int fine;
}ntptime;

typedef struct ntp_packet_t
{
//header
unsigned int leap_year_indicator:2;
unsigned int version_number:3;
unsigned int mode:3;
unsigned int stratum :8;
unsigned int poll :8;
unsigned int precision :8;

unsigned int root_delay;
unsigned int root_dispersion;
unsigned int reference_identifier;

//时间戳
ntptime  reference_timestamp; //T4
ntptime originate_timestamp;  //T1
ntptime receive_timestamp;    //T2
ntptime transmit_timestamp;   //T3
}ntp_packet;

typedef union
{
ntp_packet ntp;
char c[48];
}NTP_PACKET_T;

void GetNTPTime(ntptime *ntpTime)
{
SYSTEMTIME sysTime;
FILETIME fileTime;
GetSystemTime(&sysTime);
SystemTimeToFileTime(&sysTime,&fileTime);
ntpTime->coarse = fileTime.dwHighDateTime;
ntpTime->fine = fileTime.dwLowDateTime;
}

SOCKET CreateSock(char *psLocalIP, unsigned short usLocalPort, unsigned int iTimeOut)
{
//创建套节字
SOCKET sock = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if( INVALID_SOCKET == sock )
{
printf("Failed socket() %d \n", ::WSAGetLastError());
return 0;
}

if (0 != iTimeOut)
{
//设置套接字发送，接收超时时间
int iRet = setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char*)&iTimeOut, sizeof(iTimeOut));
iRet = setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char*)&iTimeOut, sizeof(iTimeOut));
}

//绑定本地地址
sockaddr_in addrLocal;
memset(&addrLocal, 0, sizeof(addrLocal));
addrLocal.sin_family = AF_INET;
addrLocal.sin_addr.s_addr = htonl(INADDR_ANY);
addrLocal.sin_port = htons(usLocalPort);

if ( 0 != bind(sock, (struct sockaddr*)&addrLocal, sizeof(addrLocal)) )
{
printf("Failed bind() %d \n", ::WSAGetLastError());
closesocket(sock);
return 0;
}

return sock;
}

#endif

Base64.h

#ifndef BASE64_H
#define BASE64_H

const int pr2six[256]={
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,62,64,64,64,63,
52,53,54,55,56,57,58,59,60,61,64,64,64,64,64,64,64,0,1,2,3,4,5,6,7,8,9,
10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,64,64,64,64,64,64,26,27,
28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
64,64,64,64,64,64,64,64,64,64,64,64,64
};

char six2pr[64] = {
'A','B','C','D','E','F','G','H','I','J','K','L','M',
'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
'a','b','c','d','e','f','g','h','i','j','k','l','m',
'n','o','p','q','r','s','t','u','v','w','x','y','z',
'0','1','2','3','4','5','6','7','8','9','+','/'
};

void Base64Decode(const char *bufcoded, char * dst,int *nbytes)
{
int nbytesdecoded;
const char *bufin = bufcoded;
unsigned char *bufout = (unsigned char*)dst;
int nprbytes;

/* Figure out how many characters are in the input buffer.
* If this would decode into more bytes than would fit into
* the output buffer, adjust the number of input bytes downwards.
*/
//bufin = bufcoded;
while(pr2six[(int)*(bufin++)] <= 63){}
nprbytes = (int)(bufin - bufcoded - 1);
nbytesdecoded = ((nprbytes+3)/4) * 3;

bufin = bufcoded;

while (nprbytes > 0)
{
*(bufout++) =
(unsigned char) (pr2six[(int)*bufin] << 2 | pr2six[(int)bufin[1]] >> 4);
*(bufout++) =
(unsigned char) (pr2six[(int)bufin[1]] << 4 | pr2six[(int)bufin[2]] >> 2);
*(bufout++) =
(unsigned char) (pr2six[(int)bufin[2]] << 6 | pr2six[(int)bufin[3]]);
bufin += 4;
nprbytes -= 4;
}

if(nprbytes & 03)
{
if(pr2six[(int)bufin[-2]] > 63)
nbytesdecoded -= 2;
else
nbytesdecoded -= 1;
}
dst[nbytesdecoded] = '\0';
if ( nbytes )
{
*nbytes = nbytesdecoded;
}
}

void Base64Encode(const unsigned char *bufin, unsigned int nbytes, char * dst)
{
unsigned char *outptr = (unsigned char *)dst;
unsigned int i;

for (i=0; i<nbytes; i += 3)
{
*(outptr++) = six2pr[*bufin >> 2];            /* c1 */
*(outptr++) = six2pr[((*bufin << 4) & 060) | ((bufin[1] >> 4) & 017)]; /*c2*/
*(outptr++) = six2pr[((bufin[1] << 2) & 074) | ((bufin[2] >> 6) & 03)];/*c3*/
*(outptr++) = six2pr[bufin[2] & 077];         /* c4 */

bufin += 3;
}

/* If nbytes was not a multiple of 3, then we have encoded too
* many characters.  Adjust appropriately.
*/
if(i == nbytes+1)
{
/* There were only 2 bytes in that last group */
outptr[-1] = '=';
}
else if(i == nbytes+2)
{
/* There was only 1 byte in that last group */
outptr[-1] = '=';
outptr[-2] = '=';
}

*(outptr++) = '\0';

//size_t len = outptr - 1 - (unsigned char*)dst;
}

#endif

NTPClient.cpp

#include "../Include/NTP.h"
#include "../Include/Base64.h"

//NTP请求包打包
int CreateNtpPacket(NTP_PACKET_T &ntpPacket)
{
static unsigned long ulNTPId = 0;
ulNTPId++;
char szBuf[1024];
int iDataLen;

ntpPacket.ntp.leap_year_indicator = LI;
ntpPacket.ntp.version_number = VN;
ntpPacket.ntp.mode = MODE;
ntpPacket.ntp.stratum = STRATUM;
ntpPacket.ntp.poll = POLL;
ntpPacket.ntp.precision = (PREC&0xFF);
ntpPacket.ntp.root_delay = htonl(1<<16);
ntpPacket.ntp.root_dispersion = htonl(1<<16);
ntpPacket.ntp.reference_identifier = 0;

ntpPacket.ntp.reference_timestamp.coarse = 0;
ntpPacket.ntp.reference_timestamp.fine = 0;
GetNTPTime(&ntpPacket.ntp.originate_timestamp);
ntpPacket.ntp.receive_timestamp.coarse = 0;
ntpPacket.ntp.receive_timestamp.fine = 0;
ntpPacket.ntp.transmit_timestamp.coarse = 0;
ntpPacket.ntp.transmit_timestamp.fine = 0;

return 0;
}

int NtpRequest(SOCKET &sock)
{
int iRet;
sock = CreateSock("127.0.0.1", 4567, 5000);
if ( 0 == sock )
{
printf("Failed create sock1 \n");
return -1;
}

//填写远程地址信息
sockaddr_in addrRemote;
addrRemote.sin_family = AF_INET;
addrRemote.sin_port = htons(5678);
addrRemote.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");

while (true)
{
char szTimeValue[128];
char szbuf[128];
memset(szTimeValue,0,128);
memset(szbuf,0,128);

NTP_PACKET_T ntpPacket;
memset(&ntpPacket,0,sizeof(ntpPacket));
CreateNtpPacket(ntpPacket);

//Base64进行编码
Base64Encode((unsigned char *)ntpPacket.c, sizeof(ntpPacket), szTimeValue);

//发送NTP请求数据包
iRet = ::sendto(sock, szTimeValue, strlen(szTimeValue), 0, (sockaddr*)&addrRemote, sizeof(addrRemote));
if ( SOCKET_ERROR == iRet )
{
printf("Failed sendto() sock %d \n", ::WSAGetLastError());
closesocket(sock);
}
else
{
printf("Successed sendto sock = %d, data lenth = %d \n", sock, iRet);
}

memset(szTimeValue,0,sizeof(szTimeValue));
int nLen = sizeof(addrRemote);

//接收NTP请求应答消息
iRet = ::recvfrom(sock, szbuf, 128, 0, (sockaddr*)&addrRemote, &nLen);

if(iRet > 0)
{
szbuf[iRet] = '\0';
printf(" 接收到数据（%s）：%s \n", ::inet_ntoa(addrRemote.sin_addr), szbuf);

//Base54解码
Base64Decode(szbuf, szTimeValue, 0);
if ( '\0' == szTimeValue[0] )
{
printf("time value is empty. \n");
closesocket(sock);
::WSACleanup();
return -1;
}
memset(&ntpPacket,0,sizeof(ntpPacket));
memcpy(ntpPacket.c,szTimeValue,sizeof(ntpPacket));

//设置本地系统时钟
SYSTEMTIME sysTime;
struct tm *tm1 = _localtime32((__time32_t*)&ntpPacket.ntp.transmit_timestamp.coarse);
sysTime.wYear = tm1->tm_year+1900;
sysTime.wMonth = tm1->tm_mon+1;
sysTime.wDay = tm1->tm_mday;
sysTime.wHour = tm1->tm_hour;
sysTime.wMinute = tm1->tm_min;
sysTime.wSecond = tm1->tm_sec;
sysTime.wMilliseconds = 0;
//SetLocalTime(&sysTime);

printf("NTP ok, %4d-%02d-%02d %02d:%02d:%02d %d \n", sysTime.wYear,sysTime.wMonth,sysTime.wDay,sysTime.wHour,sysTime.wMinute,sysTime.wSecond,sysTime.wMilliseconds);
}
else
{
printf("Failed recvfrom() sock %d \n", ::WSAGetLastError());
}

Sleep(5000);
}

}

int main(int argc, char* argv[])
{
int iRet;
WSADATA wsaData;
WORD sockVersion = MAKEWORD(2, 2);
if(::WSAStartup(sockVersion, &wsaData) != 0)
{
exit(0);
}

SOCKET sock;
iRet = NtpRequest(sock);
if (0 != iRet)
{
printf("ntp request failed. \n");
}

system("pause");

closesocket(sock);
::WSACleanup();

return 0;
}

NTPServer.cpp

#include "../Include/Base64.h"
#include "../Include/NTP.h"

int StartNtpServer(SOCKET &sock)
{
int iRet;
sock = CreateSock("127.0.0.1", 5678, 0);
if ( 0 == sock )
{
printf("Failed create sock1 \n");
return -1;
}

sockaddr_in addrRemote;

char szTimeValue[128];
char szbuf[128];
memset(szTimeValue,0,128);
memset(szbuf,0,128);
NTP_PACKET_T ntpPacket;

while (true)
{
memset(&addrRemote,0,sizeof(addrRemote));
int nLen = sizeof(addrRemote);

//接收来自客户端的NTP请求消息
iRet = ::recvfrom(sock, szbuf, 128, 0, (sockaddr*)&addrRemote, &nLen);
if(iRet > 0)
{
szbuf[iRet] = '\0';
printf(" 接收到数据（%s）：%s \n", ::inet_ntoa(addrRemote.sin_addr), szbuf);
}

//base64解码消息
Base64Decode(szbuf, szTimeValue, 0);

//构造NTP请求应答数据包
memset(&ntpPacket,0,sizeof(ntpPacket));
memcpy(ntpPacket.c,szTimeValue,sizeof(ntpPacket));
ntpPacket.ntp.mode = 4;
ntpPacket.ntp.transmit_timestamp.coarse = _time32(NULL);
memset(szTimeValue,0,sizeof(szTimeValue));

//Base64编码NTP请求应答消息
Base64Encode((unsigned char *)ntpPacket.c,sizeof(NTP_PACKET_T),szTimeValue);

//填写远程地址信息
addrRemote.sin_family = AF_INET;
addrRemote.sin_port = htons(4567);
addrRemote.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");

//发送NTP请求应答消息
iRet = ::sendto(sock, szTimeValue, strlen(szTimeValue), 0, (sockaddr*)&addrRemote, sizeof(addrRemote));
if ( SOCKET_ERROR == iRet )
{
printf("Failed sendto() sock %d \n", ::WSAGetLastError());
closesocket(sock);
return -1;
}
else
{
printf("Successed sendto sock = %d, data lenth = %d \n", sock, iRet);
}
}

return 0;
}

int main(int argc, char* argv[])
{
WSADATA wsaData;
WORD sockVersion = MAKEWORD(2, 2);
if(::WSAStartup(sockVersion, &wsaData) != 0)
{
exit(0);
}

SOCKET sock;
int iRet = StartNtpServer(sock);
if (0 != iRet)
{
printf("start ntp server failed. \n");
}

system("pause");
closesocket(sock);
::WSACleanup();
return 0;
}

上述代码代码在VC2005环境中已测试通过，以下是客户端和服务端程序截图：



客户端



服务端