Simple network time protocol (SNTP)

With the spread of networks and cross-system processes, it has become necessary to find a uniform solution for syn­chron­iz­ing system-time. The official standard was the network time protocol (NTP), which uses various al­gorithms to correct de­vi­ations and uses official world time as a reference clock. The release of a sim­pli­fied version called simple network time protocol (SNTP) at the beginning of the 1990s is primarily due to the limited computing power of the computers available at that time. The pro­cessing power is used a lot less during syn­chron­iz­a­tion via SNTP than with the basic protocol, NTP, which frees up the processor for other tasks – however, most modern devices have a pro­cessing power which can ac­com­mod­ate the com­plex­ity of NTP.

The simple network time protocol (SNTP) is a time syn­chron­iz­a­tion protocol of the TCP/IP protocol family. It is based on the con­nec­tion­less user datagram protocol (UDP) and can be used on all sup­port­ing devices to syn­chron­ize system time in IP networks (IPv4 and IPv6). The basis is a client-server structure in which the in­di­vidu­al clients obtain the time in­form­a­tion from a selected time server in the same network. In the event that this is not available, ad­di­tion­al time servers are available as backup. The first version of SNTP dates from 1992 and is specified in RFC 1361. This describes the protocol as a sim­pli­fied variant of the network time protocol, which is also used to adjust the system time in networks.

After several revisions, the protocol, developed by a working group at the Uni­ver­sity of Delaware, is now available in its fourth version (SNTPv4). This version was published by the uni­ver­sity in 2006 in RFC 4330.

Like NTP, SNTP is used to syn­chron­ize the system time of all devices in a network easily. For this purpose, a client-server model is used and the official world time (“co­ordin­ated universal time”) as reference time. So-called time servers act as “dis­trib­ut­ors” of time for the SNTP clients, i.e. the re­spect­ive devices, the system time which is to be syn­chron­ized using the simple network time protocol. The IP packets required for this function through UDP port 123, and since SNTP is very similar to NTP, NTP servers are often used for the syn­chron­iz­a­tion process.

The trans­mis­sion of the IP packets can be handled either via simple direct con­nec­tions (unicast) between a client and a server, or via mul­ti­point con­nec­tions between a server and several clients (broadcast and multicast).

SNTP and NTP can be dif­fer­en­ti­ated according to the two following points:

• The number of servers used for the syn­chron­iz­a­tion process
• The number of al­gorithms used to make up for time de­vi­ations and ensure the most accurate results possible

In contrast to the more complex NTP protocol, the simple network time protocol pri­or­it­izes sim­pli­city. The SNTP spe­cific­a­tion re­com­mends that the time in­form­a­tion should only be obtained from a single server, and any further client-server de­pend­ency should be avoided. Fur­ther­more, the server-side use of SNTP is only intended if no other syn­chron­iz­a­tion source is available. Syn­chron­iz­a­tion via NTP, on the other hand, relies on a complex construct of different servers that pass on the in­form­a­tion in a hier­arch­ic­al layer system. Depending on the po­s­i­tion­ing in the chain, the systems involved in the process can be both clients and servers.

SNTP does not use some al­gorithms that are provided as standard in the NTP spe­cific­a­tion. These al­gorithms serve the purpose of making up for de­vi­ations in the local system time to always be able to provide the best possible relation to world time. As a result, SNTP offers a lower level of accuracy than NTP, making the sim­pli­fied protocol un­suit­able for ap­plic­a­tions and processes that require in­cred­ibly accurate time syn­chron­iz­a­tion. Thanks to the com­bin­a­tion of fewer al­gorithms and client-server com­mu­nic­a­tion, SNTP syn­chron­iz­a­tion requires sig­ni­fic­antly fewer resources, which is par­tic­u­larly helpful for simple devices or systems with low computing power.