Diff: NTPClient.cpp

Revision:

0:a56239ae90c2

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/NTPClient.cpp	Mon Sep 25 19:02:40 2017 +0000
@@ -0,0 +1,208 @@
+/* NTPClient.cpp */
+/* Copyright (C) 2012 mbed.org, MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+ * and associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute,
+ * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#if 1
+//Enable debug
+#define __DEBUG__
+#include <cstdio>
+#define DBG(x, ...) std::printf("[NTPClient : DBG]"x"\r\n", ##__VA_ARGS__); 
+#define WARN(x, ...) std::printf("[NTPClient : WARN]"x"\r\n", ##__VA_ARGS__); 
+#define ERR(x, ...) std::printf("[NTPClient : ERR]"x"\r\n", ##__VA_ARGS__); 
+
+#else
+//Disable debug
+#define DBG(x, ...) 
+#define WARN(x, ...)
+#define ERR(x, ...) 
+#endif
+
+#include "NTPClient.h"
+
+#include "mbed.h" //time() and set_time()
+
+NTPClient::NTPClient() : m_sock()
+{
+    reset();
+    
+    mQuerySent = false;
+    mResponseReceived = false;
+    mConversationComplete = true;
+    mStartTime = 0;
+}
+
+void NTPClient::reset()
+{
+    if (outEndpoint)
+    {
+        delete outEndpoint;
+    }
+    if (inEndpoint)
+    {
+        delete inEndpoint;
+    }
+    outEndpoint = NULL;
+    inEndpoint = NULL;
+    
+    m_sock.close();
+}
+
+void NTPClient::process_result()
+{
+    //Correct Endianness
+    pkt.refTm_s = ntohl( pkt.refTm_s );
+    pkt.refTm_f = ntohl( pkt.refTm_f );
+    pkt.origTm_s = ntohl( pkt.origTm_s );
+    pkt.origTm_f = ntohl( pkt.origTm_f );
+    pkt.rxTm_s = ntohl( pkt.rxTm_s );
+    pkt.rxTm_f = ntohl( pkt.rxTm_f );
+    pkt.txTm_s = ntohl( pkt.txTm_s );
+    pkt.txTm_f = ntohl( pkt.txTm_f );
+    
+    //Compute offset, see RFC 4330 p.13
+    uint32_t destTm_s = (NTP_TIMESTAMP_DELTA + time(NULL));
+    int64_t offset = ( (int64_t)( pkt.rxTm_s - pkt.origTm_s ) + (int64_t) ( pkt.txTm_s - destTm_s ) ) / 2; //Avoid overflow
+    DBG("Received @%ul", pkt.txTm_s);
+    DBG("Offset: %lld", offset);
+    //Set time accordingly
+    set_time( time(NULL) + offset );
+    
+    #ifdef __DEBUG__
+    time_t ctTime;
+    ctTime = time(NULL);
+    DBG("Time is now (UTC): %s", ctime(&ctTime));
+    #endif
+}
+
+int NTPClient::update()
+{
+    int ntp_result = NTP_WAIT;
+    bool conversationComplete = true;
+    
+    if (mQuerySent && !mConversationComplete)
+    {
+        // Listen for a response from the NTP server.
+        int ret = m_sock.recvfrom( inEndpoint, (char*)&pkt, sizeof(NTPPacket) ); //FIXME need a DNS Resolver to actually compare the incoming address with the DNS name
+        
+        if (ret == NSAPI_ERROR_WOULD_BLOCK)
+        {
+            //DBG("Waiting...");
+            
+            // Check for response timeout.
+            if ((time(NULL) - mStartTime) < mTimeout)
+            {
+                conversationComplete = false;
+            }
+            else
+            {
+                DBG("Timeout.\n");
+                ntp_result = NTP_TIMEOUT;
+            }
+        }
+        else if(ret < 0)
+        {
+            ERR("Could not receive packet");
+            ntp_result = NTP_CONN;
+        }
+        else if(ret < sizeof(NTPPacket)) //TODO: Accept chunks
+        {
+            ERR("Received packet size does not match");
+            ntp_result = NTP_PRTCL;
+        }
+        else if( pkt.stratum == 0)  //Kiss of death
+        {
+            ERR("Kissed to death!");
+            ntp_result = NTP_PRTCL;
+        }
+        else
+        {
+            process_result();
+            ntp_result = NTP_OK;
+        }
+        
+        if (conversationComplete)
+        {
+            reset();        
+            mConversationComplete = true;
+        }
+    }
+    
+    return ntp_result;
+}
+
+NTPResult NTPClient::setTime(EthernetInterface* stack, const char* host, uint16_t port, uint32_t timeout)
+{
+    mQuerySent = false;
+    mResponseReceived = false;
+    mConversationComplete = false;
+    
+    mStartTime = time(NULL);
+    mTimeout = timeout;
+    
+#ifdef __DEBUG__
+  time_t ctTime;
+  ctTime = time(NULL);
+  DBG("Time is set to (UTC): %s", ctime(&ctTime));
+#endif
+
+  //Create & bind socket
+  m_sock.open(stack);
+  DBG("Binding socket: %d", m_sock.bind(NTP_CLIENT_PORT)); //Bind to a random port
+  m_sock.set_blocking(false); //Set not blocking
+
+  //Now ping the server and wait for response
+  DBG("Ping");
+  //Prepare NTP Packet:
+  pkt.li = 0; //Leap Indicator : No warning
+  pkt.vn = 4; //Version Number : 4
+  pkt.mode = 3; //Client mode
+  pkt.stratum = 0; //Not relevant here
+  pkt.poll = 0; //Not significant as well
+  pkt.precision = 0; //Neither this one is
+
+  pkt.rootDelay = 0; //Or this one
+  pkt.rootDispersion = 0; //Or that one
+  pkt.refId = 0; //...
+
+  pkt.refTm_s = 0;
+  pkt.origTm_s = 0;
+  pkt.rxTm_s = 0;
+  pkt.txTm_s = htonl( NTP_TIMESTAMP_DELTA + time(NULL) ); //WARN: We are in LE format, network byte order is BE
+
+  pkt.refTm_f = pkt.origTm_f = pkt.rxTm_f = pkt.txTm_f = 0;
+
+  outEndpoint = new SocketAddress(host, port);
+  inEndpoint = new SocketAddress(host, 0);
+  
+  //Set timeout, non-blocking and wait using select
+  DBG("Send packet to %s:%d", host, port);
+  int ret = m_sock.sendto(*outEndpoint, (void*)&pkt, sizeof(NTPPacket));
+  if (ret < 0 )
+  {
+    ERR("Could not send packet %d\n", ret);
+    m_sock.close();
+    return NTP_CONN;
+  }
+  DBG("Sent...");
+  
+  mQuerySent = true;
+
+  return NTP_OK;
+}
+
+