LRSD stephane / Mbed 2 deprecated WEBserverv3

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   mbed

lwip/SNTPClient/SNTPClient.cpp@0:9cf1d79ebe04, 2011-09-08 (annotated)

Committer:
geiineuville
Date:
Thu Sep 08 08:57:21 2011 +0000
Revision:
0:9cf1d79ebe04
v0 v1 v2   \"v3\"

Who changed what in which revision?

UserRevisionLine numberNew contents of line
geiineuville 0:9cf1d79ebe04 1 /*
geiineuville 0:9cf1d79ebe04 2 * SNTPClient.cpp
geiineuville 0:9cf1d79ebe04 3 * SNTP (Simple NTP) client
geiineuville 0:9cf1d79ebe04 4 * Written by iva2k
geiineuville 0:9cf1d79ebe04 5 *
geiineuville 0:9cf1d79ebe04 6 * Wrapper around LWIP/sntp for MBED, with DST rules.
geiineuville 0:9cf1d79ebe04 7 * This implementation relies on:
geiineuville 0:9cf1d79ebe04 8 * 1. LWIP (http://www.sics.se/~adam/lwip/) adopted for MBED
geiineuville 0:9cf1d79ebe04 9 * http://mbed.org/projects/cookbook/svn/EMAC/lwip/trunk
geiineuville 0:9cf1d79ebe04 10 * 2. LWIP's contributed SNTP client (sntp.c and sntp.h) from
geiineuville 0:9cf1d79ebe04 11 * http://cvs.savannah.gnu.org/viewvc/contrib/apps/sntp/?root=lwip
geiineuville 0:9cf1d79ebe04 12 * (used version 1.8)
geiineuville 0:9cf1d79ebe04 13 *
geiineuville 0:9cf1d79ebe04 14 * Changes needed in LWIP/sntp:
geiineuville 0:9cf1d79ebe04 15 * - pointer typecast (line 594) - fixes mbed compiler problem
geiineuville 0:9cf1d79ebe04 16 * - #include "sntp.h" moved after lwip/opt.h et.al - for re-defines.
geiineuville 0:9cf1d79ebe04 17 * - pbuf_free(p) in sntp_send_request() (line 602) - fixes memory leak BUG.
geiineuville 0:9cf1d79ebe04 18 * - changing sntp_dns_found() to delayed sntp_try_next_server() - to unblock if network is disconnected.
geiineuville 0:9cf1d79ebe04 19 *
geiineuville 0:9cf1d79ebe04 20 * Changes in MBED's LWIP:
geiineuville 0:9cf1d79ebe04 21 * - modified lwipopts.h (this file is automatically included into sntp.c)
geiineuville 0:9cf1d79ebe04 22 *
geiineuville 0:9cf1d79ebe04 23 * Requirements:
geiineuville 0:9cf1d79ebe04 24 * + direct RTC update from receiving the NTP time packet
geiineuville 0:9cf1d79ebe04 25 * + optionally support more than one NTP server
geiineuville 0:9cf1d79ebe04 26 * + the IP address of the NTP server(s) stored in a local file
geiineuville 0:9cf1d79ebe04 27 * + timeout error recovery should the NTP server(s) not be available. No RTC update should the NTP access fail
geiineuville 0:9cf1d79ebe04 28 * + allow for a UTC offset, also stored in the local file
geiineuville 0:9cf1d79ebe04 29 * + DST correction
geiineuville 0:9cf1d79ebe04 30 * + use DNS for NTP servers IP address resolution
geiineuville 0:9cf1d79ebe04 31 * + periodic updates at specified time intervals
geiineuville 0:9cf1d79ebe04 32 *
geiineuville 0:9cf1d79ebe04 33 * TODO:
geiineuville 0:9cf1d79ebe04 34 * . DST correction
geiineuville 0:9cf1d79ebe04 35 * - record metrics (count of updates, failed tries?, correction more than epsilon, etc.?)
geiineuville 0:9cf1d79ebe04 36 */
geiineuville 0:9cf1d79ebe04 37
geiineuville 0:9cf1d79ebe04 38 #include "mbed.h"
geiineuville 0:9cf1d79ebe04 39 #include "lwip/opt.h"
geiineuville 0:9cf1d79ebe04 40 #include "SNTPClient.h"
geiineuville 0:9cf1d79ebe04 41
geiineuville 0:9cf1d79ebe04 42 #define SNTP_EPSILON 10 // time difference noticed as big update (in seconds).
geiineuville 0:9cf1d79ebe04 43
geiineuville 0:9cf1d79ebe04 44 //#define SNTP_DST_TESTS // Define this to run DST algorithms tests
geiineuville 0:9cf1d79ebe04 45
geiineuville 0:9cf1d79ebe04 46 typedef struct DST_ZONE_DESCR {
geiineuville 0:9cf1d79ebe04 47 tDST_ZONE zone;
geiineuville 0:9cf1d79ebe04 48 const char *name;
geiineuville 0:9cf1d79ebe04 49 int gmt;
geiineuville 0:9cf1d79ebe04 50 int dst;
geiineuville 0:9cf1d79ebe04 51 int hr1;
geiineuville 0:9cf1d79ebe04 52 int wk1;
geiineuville 0:9cf1d79ebe04 53 int wday1;
geiineuville 0:9cf1d79ebe04 54 int mon1;
geiineuville 0:9cf1d79ebe04 55 int hr2;
geiineuville 0:9cf1d79ebe04 56 int wk2;
geiineuville 0:9cf1d79ebe04 57 int wday2;
geiineuville 0:9cf1d79ebe04 58 int mon2;
geiineuville 0:9cf1d79ebe04 59 pFncDstCalc fnc;
geiineuville 0:9cf1d79ebe04 60 } tDST_ZONE_DESR;
geiineuville 0:9cf1d79ebe04 61
geiineuville 0:9cf1d79ebe04 62 static tDST_ZONE_DESR gSntpDstZones[] = {
geiineuville 0:9cf1d79ebe04 63 #define _(z, fnc, gmt, dst, hr1,wk1,wday1,mon1, hr2,wk2,wday2,mon2) \
geiineuville 0:9cf1d79ebe04 64 { z, #z, gmt, dst, hr1,wk1,wday1,mon1, hr2,wk2,wday2,mon2, fnc },
geiineuville 0:9cf1d79ebe04 65 #include "DstZones.h"
geiineuville 0:9cf1d79ebe04 66 };
geiineuville 0:9cf1d79ebe04 67 #define DST_ZONE_DESCR_CNT (sizeof(gSntpDstZones)/sizeof(gSntpDstZones[0]))
geiineuville 0:9cf1d79ebe04 68
geiineuville 0:9cf1d79ebe04 69 const char *SNTPDstZoneName(tDST_ZONE zone) {
geiineuville 0:9cf1d79ebe04 70 if (zone >= DST_ZONE_DESCR_CNT)
geiineuville 0:9cf1d79ebe04 71 return "";
geiineuville 0:9cf1d79ebe04 72 return gSntpDstZones[zone].name;
geiineuville 0:9cf1d79ebe04 73 }
geiineuville 0:9cf1d79ebe04 74
geiineuville 0:9cf1d79ebe04 75 #ifdef __cplusplus
geiineuville 0:9cf1d79ebe04 76 extern "C" {
geiineuville 0:9cf1d79ebe04 77 #endif
geiineuville 0:9cf1d79ebe04 78 tDST_ZONE gSntpDstZone = DST_NONE; // DST zone - rule selector
geiineuville 0:9cf1d79ebe04 79 unsigned int gSntpRecvTimeout_s = 3; // 3 sec; SNTP_RECV_TIMEOUT
geiineuville 0:9cf1d79ebe04 80 unsigned int gSntpUpdateDelay_s = 3600; // 1 hour; SNTP_UPDATE_DELAY
geiineuville 0:9cf1d79ebe04 81 signed int gSntpTimezone = 0*3600; // seconds from UTC to local time
geiineuville 0:9cf1d79ebe04 82 signed int gSntpDST = 0*3600; // seconds from UTC to local time
geiineuville 0:9cf1d79ebe04 83 bool gSntpRtcUtc = false; // true to keep RTC in UTC, false to keep in local time
geiineuville 0:9cf1d79ebe04 84 unsigned int gSntpUpdates = 0; // Track number of all clock NTP updates
geiineuville 0:9cf1d79ebe04 85 unsigned int gSntpUpdatesBig = 0; // Track number of significant clock NTP updates
geiineuville 0:9cf1d79ebe04 86 bool gSntpRunning = false; // true if SNTP service is running
geiineuville 0:9cf1d79ebe04 87 Timeout gSntpDelay; // For async calls.
geiineuville 0:9cf1d79ebe04 88 Ticker gSntpTicker; // There is no RTC interrupt on MBED (yet). Use (more wastefull) timer.
geiineuville 0:9cf1d79ebe04 89 time_t gSntpRtcTCR = 0; // Timer Capture Register equivalent (in RTC time - either local or UTC depending on gSntpRtcUtc)
geiineuville 0:9cf1d79ebe04 90 signed int gSntpRtcTCRDST = 0; // New DST value for when RTC crosses gSntpRtcTCR
geiineuville 0:9cf1d79ebe04 91
geiineuville 0:9cf1d79ebe04 92 static void SNTPSetDSTEx(unsigned int dst, bool adjust_clock) {
geiineuville 0:9cf1d79ebe04 93 if (adjust_clock && !gSntpRtcUtc && gSntpDST != dst) {
geiineuville 0:9cf1d79ebe04 94 time_t seconds = time(NULL);
geiineuville 0:9cf1d79ebe04 95 seconds -= gSntpDST; // Convert from old local time
geiineuville 0:9cf1d79ebe04 96 seconds += dst; // Convert to new local time
geiineuville 0:9cf1d79ebe04 97 set_time(seconds);
geiineuville 0:9cf1d79ebe04 98 if (gSntpRtcTCR) {
geiineuville 0:9cf1d79ebe04 99 // Adjust our alarm clock
geiineuville 0:9cf1d79ebe04 100 gSntpRtcTCR -= gSntpDST;
geiineuville 0:9cf1d79ebe04 101 gSntpRtcTCR += dst;
geiineuville 0:9cf1d79ebe04 102 }
geiineuville 0:9cf1d79ebe04 103 }
geiineuville 0:9cf1d79ebe04 104 gSntpDST = dst;
geiineuville 0:9cf1d79ebe04 105 }
geiineuville 0:9cf1d79ebe04 106
geiineuville 0:9cf1d79ebe04 107 #if 0
geiineuville 0:9cf1d79ebe04 108 // Custom DST zone function example
geiineuville 0:9cf1d79ebe04 109 // USA (since 2007)
geiineuville 0:9cf1d79ebe04 110 // Calculate start or stop DST point for given year based on rules
geiineuville 0:9cf1d79ebe04 111 // tz - Timezone
geiineuville 0:9cf1d79ebe04 112 // year - current year. DST changes well away from year end, so does not matter what timezone.
geiineuville 0:9cf1d79ebe04 113 // start - DST_START for start, DST_STOP for stop
geiineuville 0:9cf1d79ebe04 114 // Returns DST point (in local time). DST_STOP time is in DST
geiineuville 0:9cf1d79ebe04 115 static tDstPoint _sntp_dst_calc_custom(int tz, int year, tDST_START start) {
geiineuville 0:9cf1d79ebe04 116 tDstPoint ret;
geiineuville 0:9cf1d79ebe04 117 struct tm t;
geiineuville 0:9cf1d79ebe04 118
geiineuville 0:9cf1d79ebe04 119 // USA: 3600; 2, Second SUN, March; 2, First SUN, November
geiineuville 0:9cf1d79ebe04 120 int dst = 3600; // DST shift (seconds)
geiineuville 0:9cf1d79ebe04 121 int hour; // Hour of the change
geiineuville 0:9cf1d79ebe04 122 int N; // Week in the month
geiineuville 0:9cf1d79ebe04 123 int wday; // Day of the week
geiineuville 0:9cf1d79ebe04 124 int month;
geiineuville 0:9cf1d79ebe04 125 if (start == DST_START) {
geiineuville 0:9cf1d79ebe04 126 hour = 2; // (0-23) Hour of the change
geiineuville 0:9cf1d79ebe04 127 N = 2-1; // 2nd in the month
geiineuville 0:9cf1d79ebe04 128 wday = 0; // Sunday
geiineuville 0:9cf1d79ebe04 129 month = 2; // March
geiineuville 0:9cf1d79ebe04 130 } else { // DST_STOP
geiineuville 0:9cf1d79ebe04 131 hour = 2; // (0-23) Hour of the change
geiineuville 0:9cf1d79ebe04 132 N = 1-1; // 1st in the month
geiineuville 0:9cf1d79ebe04 133 wday = 0; // Sunday
geiineuville 0:9cf1d79ebe04 134 month = 10; // November
geiineuville 0:9cf1d79ebe04 135 }
geiineuville 0:9cf1d79ebe04 136
geiineuville 0:9cf1d79ebe04 137 t.tm_sec = 0; // 0-59
geiineuville 0:9cf1d79ebe04 138 t.tm_min = 0; // 0-59
geiineuville 0:9cf1d79ebe04 139 t.tm_hour = hour; // 0-23
geiineuville 0:9cf1d79ebe04 140 t.tm_year = year - 1900; //
geiineuville 0:9cf1d79ebe04 141 t.tm_mon = month; // 0-11
geiineuville 0:9cf1d79ebe04 142 t.tm_mday = 1+N*7; // 1-31, first possible date for Nth given weekday
geiineuville 0:9cf1d79ebe04 143 mktime(&t); // Calculate tm_wday
geiineuville 0:9cf1d79ebe04 144 t.tm_mday += (wday-t.tm_wday+14)%7; // Shift to wday
geiineuville 0:9cf1d79ebe04 145 ret.t = mktime(&t);
geiineuville 0:9cf1d79ebe04 146 ret.dst = (start == DST_START) ? dst : 0;
geiineuville 0:9cf1d79ebe04 147 ret.dstshift = dst;
geiineuville 0:9cf1d79ebe04 148 return ret;
geiineuville 0:9cf1d79ebe04 149 }
geiineuville 0:9cf1d79ebe04 150 #endif
geiineuville 0:9cf1d79ebe04 151
geiineuville 0:9cf1d79ebe04 152 // Calculate start or stop DST point for given year based on rules for the DST zone
geiineuville 0:9cf1d79ebe04 153 // tz - Timezone
geiineuville 0:9cf1d79ebe04 154 // zone - DST zone
geiineuville 0:9cf1d79ebe04 155 // year - current year. DST changes well away from year end, so does not matter timezone.
geiineuville 0:9cf1d79ebe04 156 // start - DST_START for start, DST_STOP for stop
geiineuville 0:9cf1d79ebe04 157 // Returns DST point (in standard local time). DST_STOP time is in NOT IN DST
geiineuville 0:9cf1d79ebe04 158 static tDstPoint _sntp_dst_calc(int tz, tDST_ZONE zone, int year, tDST_START start) {
geiineuville 0:9cf1d79ebe04 159 tDstPoint ret;
geiineuville 0:9cf1d79ebe04 160
geiineuville 0:9cf1d79ebe04 161 ret.t = 0;
geiineuville 0:9cf1d79ebe04 162 ret.dst = 0;
geiineuville 0:9cf1d79ebe04 163 ret.dstshift = 0;
geiineuville 0:9cf1d79ebe04 164 if (zone == DST_NONE || zone >= DST_ZONE_DESCR_CNT)
geiineuville 0:9cf1d79ebe04 165 return ret;
geiineuville 0:9cf1d79ebe04 166
geiineuville 0:9cf1d79ebe04 167 tDST_ZONE_DESR *descr = &gSntpDstZones[zone];
geiineuville 0:9cf1d79ebe04 168 if (descr->fnc) {
geiineuville 0:9cf1d79ebe04 169 // Use custom function
geiineuville 0:9cf1d79ebe04 170 ret = descr->fnc(tz, year, start);
geiineuville 0:9cf1d79ebe04 171 } else {
geiineuville 0:9cf1d79ebe04 172 // Use rules
geiineuville 0:9cf1d79ebe04 173 struct tm t;
geiineuville 0:9cf1d79ebe04 174 t.tm_sec = 0; // 0-59
geiineuville 0:9cf1d79ebe04 175 t.tm_min = 0; // 0-59
geiineuville 0:9cf1d79ebe04 176 t.tm_hour = (start == DST_START) ? descr->hr1 : descr->hr2;
geiineuville 0:9cf1d79ebe04 177 t.tm_year = year - 1900; //
geiineuville 0:9cf1d79ebe04 178 t.tm_mon = (start == DST_START) ? descr->mon1 : descr->mon2; // 0-11
geiineuville 0:9cf1d79ebe04 179 int wk =((start == DST_START) ? descr->wk1 : descr->wk2) -1;
geiineuville 0:9cf1d79ebe04 180 int wday = (start == DST_START) ? descr->wday1: descr->wday2;
geiineuville 0:9cf1d79ebe04 181 if (wk < 0) {
geiineuville 0:9cf1d79ebe04 182 // For "Last in the month" - we go to next month, then move back by one week
geiineuville 0:9cf1d79ebe04 183 t.tm_mon += 1; // 0-11
geiineuville 0:9cf1d79ebe04 184 if (t.tm_mon > 11) {
geiineuville 0:9cf1d79ebe04 185 t.tm_mon -= 12;
geiineuville 0:9cf1d79ebe04 186 t.tm_year += 1;
geiineuville 0:9cf1d79ebe04 187 }
geiineuville 0:9cf1d79ebe04 188 t.tm_mday = 1+0*7; // 1-31, first possible date for Nth given weekday
geiineuville 0:9cf1d79ebe04 189 } else {
geiineuville 0:9cf1d79ebe04 190 t.tm_mday = 1+wk*7; // 1-31, first possible date for Nth given weekday
geiineuville 0:9cf1d79ebe04 191 }
geiineuville 0:9cf1d79ebe04 192 mktime(&t); // Calculate tm_wday
geiineuville 0:9cf1d79ebe04 193 t.tm_mday += (wday-t.tm_wday+14)%7; // Shift to wday
geiineuville 0:9cf1d79ebe04 194 ret.t = mktime(&t);
geiineuville 0:9cf1d79ebe04 195 if (wk < 0) {
geiineuville 0:9cf1d79ebe04 196 ret.t -= 7 * 24 * 3600;
geiineuville 0:9cf1d79ebe04 197 }
geiineuville 0:9cf1d79ebe04 198 if (descr->gmt) {
geiineuville 0:9cf1d79ebe04 199 ret.t += tz;
geiineuville 0:9cf1d79ebe04 200 }
geiineuville 0:9cf1d79ebe04 201 ret.dst = (start == DST_START) ? descr->dst : 0;
geiineuville 0:9cf1d79ebe04 202 ret.dstshift = descr->dst;
geiineuville 0:9cf1d79ebe04 203 }
geiineuville 0:9cf1d79ebe04 204 if (start == DST_STOP) {
geiineuville 0:9cf1d79ebe04 205 ret.t -= ret.dstshift;
geiineuville 0:9cf1d79ebe04 206 // this correction is due to the fact that rules are given in local time with DST,
geiineuville 0:9cf1d79ebe04 207 // but calculations are made in standard local time (without DST adjustment)
geiineuville 0:9cf1d79ebe04 208 }
geiineuville 0:9cf1d79ebe04 209 return ret;
geiineuville 0:9cf1d79ebe04 210 }
geiineuville 0:9cf1d79ebe04 211
geiineuville 0:9cf1d79ebe04 212 // Calculate desired DST point relative to now based on rules for the DST zone
geiineuville 0:9cf1d79ebe04 213 // tz - timezone
geiineuville 0:9cf1d79ebe04 214 // zone - DST zone
geiineuville 0:9cf1d79ebe04 215 // now - current time (standard local time = excluding DST).
geiineuville 0:9cf1d79ebe04 216 // index - 0 for immediate next, +1 for second next, -1 for immediate previous
geiineuville 0:9cf1d79ebe04 217 // Returns DST point (in standard local time)
geiineuville 0:9cf1d79ebe04 218 static tDstPoint _sntp_dst_point(int tz, tDST_ZONE zone, time_t now, int index) {
geiineuville 0:9cf1d79ebe04 219 tDstPoint ret;
geiineuville 0:9cf1d79ebe04 220 int year;
geiineuville 0:9cf1d79ebe04 221 tDST_START type;
geiineuville 0:9cf1d79ebe04 222 struct tm *pt = localtime(&now);
geiineuville 0:9cf1d79ebe04 223
geiineuville 0:9cf1d79ebe04 224 ret.t = 0;
geiineuville 0:9cf1d79ebe04 225 ret.dst = 0;
geiineuville 0:9cf1d79ebe04 226 ret.dstshift = 0;
geiineuville 0:9cf1d79ebe04 227 if (zone == DST_NONE || zone >= DST_ZONE_DESCR_CNT)
geiineuville 0:9cf1d79ebe04 228 return ret;
geiineuville 0:9cf1d79ebe04 229
geiineuville 0:9cf1d79ebe04 230 // Algorithm
geiineuville 0:9cf1d79ebe04 231 // 1. Determine where now is in respect to current year DST points (find for index=0)
geiineuville 0:9cf1d79ebe04 232 // 2. Use index to shift year and type
geiineuville 0:9cf1d79ebe04 233 // 3. return the point
geiineuville 0:9cf1d79ebe04 234 // This algorithm relies on DST start date being before DST stop date in the year.
geiineuville 0:9cf1d79ebe04 235
geiineuville 0:9cf1d79ebe04 236 year = pt->tm_year + 1900;
geiineuville 0:9cf1d79ebe04 237 type = DST_START;
geiineuville 0:9cf1d79ebe04 238 ret = _sntp_dst_calc(tz, zone, year, type);
geiineuville 0:9cf1d79ebe04 239 if (now > ret.t) {
geiineuville 0:9cf1d79ebe04 240 type = DST_STOP;
geiineuville 0:9cf1d79ebe04 241 ret = _sntp_dst_calc(tz, zone, year, type);
geiineuville 0:9cf1d79ebe04 242 if (now > ret.t) {
geiineuville 0:9cf1d79ebe04 243 // It is next year's start point
geiineuville 0:9cf1d79ebe04 244 type = DST_START;
geiineuville 0:9cf1d79ebe04 245 year += 1;
geiineuville 0:9cf1d79ebe04 246 }
geiineuville 0:9cf1d79ebe04 247 }
geiineuville 0:9cf1d79ebe04 248 // Now year and type are right for index=0
geiineuville 0:9cf1d79ebe04 249
geiineuville 0:9cf1d79ebe04 250 // Calculate where index points to - shift year and type
geiineuville 0:9cf1d79ebe04 251 int norm = (index > 0) ? (int)(index/2) : (int)((index-1)/2);
geiineuville 0:9cf1d79ebe04 252 year += norm;
geiineuville 0:9cf1d79ebe04 253 index -= norm*2; // Now index is (0,1)
geiineuville 0:9cf1d79ebe04 254 if (index) {
geiineuville 0:9cf1d79ebe04 255 // Flip the type
geiineuville 0:9cf1d79ebe04 256 type = (type == DST_START) ? DST_STOP : DST_START;
geiineuville 0:9cf1d79ebe04 257 }
geiineuville 0:9cf1d79ebe04 258
geiineuville 0:9cf1d79ebe04 259 ret = _sntp_dst_calc(tz, zone, year, type);
geiineuville 0:9cf1d79ebe04 260 return ret;
geiineuville 0:9cf1d79ebe04 261
geiineuville 0:9cf1d79ebe04 262 // struct tm t;
geiineuville 0:9cf1d79ebe04 263 // t.tm_sec = 0; // 0-59
geiineuville 0:9cf1d79ebe04 264 // t.tm_min = 0; // 0-59
geiineuville 0:9cf1d79ebe04 265 // t.tm_hour = 0; // 0-23
geiineuville 0:9cf1d79ebe04 266 // t.tm_mday = 0; // 1-31
geiineuville 0:9cf1d79ebe04 267 // t.tm_mon = 0; // 0-11
geiineuville 0:9cf1d79ebe04 268 // t.tm_year = 2005-1900; // year since 1900
geiineuville 0:9cf1d79ebe04 269 // t.tm_wday = 0; // 0-6 Day of week (Sunday = 0)
geiineuville 0:9cf1d79ebe04 270 // t.tm_yday = 0; // Day of year (0 - 365)
geiineuville 0:9cf1d79ebe04 271 // t.tm_isdst = -1; // Nonzero = Daylight saving time
geiineuville 0:9cf1d79ebe04 272 }
geiineuville 0:9cf1d79ebe04 273
geiineuville 0:9cf1d79ebe04 274 #if defined(LWIP_DEBUG)
geiineuville 0:9cf1d79ebe04 275 // Print DST dates report
geiineuville 0:9cf1d79ebe04 276 static void _sntp_dst_dates(int tz, tDST_ZONE zone, int year) {
geiineuville 0:9cf1d79ebe04 277 char _buffer[64];
geiineuville 0:9cf1d79ebe04 278 tDstPoint r;
geiineuville 0:9cf1d79ebe04 279 printf("\r\nDST DATES for zone %d/%s:\r\n", (int)zone, SNTPDstZoneName(zone));
geiineuville 0:9cf1d79ebe04 280
geiineuville 0:9cf1d79ebe04 281 r = _sntp_dst_calc(tz, zone, year, DST_START);
geiineuville 0:9cf1d79ebe04 282 strftime(_buffer, sizeof(_buffer), "%A %m/%d/%Y %H:%M:%S", localtime(&r.t));
geiineuville 0:9cf1d79ebe04 283 printf(" %d DST BEGINS (+%04d sec) %s\r\n", year, r.dst, _buffer);
geiineuville 0:9cf1d79ebe04 284
geiineuville 0:9cf1d79ebe04 285 r = _sntp_dst_calc(tz, zone, year, DST_STOP);
geiineuville 0:9cf1d79ebe04 286 strftime(_buffer, sizeof(_buffer), "%A %m/%d/%Y %H:%M:%S", localtime(&r.t));
geiineuville 0:9cf1d79ebe04 287 printf(" %d DST ENDS (+%04d sec) %s\r\n", year, r.dst, _buffer);
geiineuville 0:9cf1d79ebe04 288 }
geiineuville 0:9cf1d79ebe04 289 #endif
geiineuville 0:9cf1d79ebe04 290
geiineuville 0:9cf1d79ebe04 291 #ifdef SNTP_DST_TESTS
geiineuville 0:9cf1d79ebe04 292 static void test_sntp_dst_calc(int tz, tDST_ZONE zone) {
geiineuville 0:9cf1d79ebe04 293 char _buffer[64];
geiineuville 0:9cf1d79ebe04 294 tDstPoint r;
geiineuville 0:9cf1d79ebe04 295 int year;
geiineuville 0:9cf1d79ebe04 296
geiineuville 0:9cf1d79ebe04 297 printf("\r\nTEST: _sntp_dst_calc(tz=%d, zone=%d/%s)\r\n", tz, (int)zone, SNTPDstZoneName(zone));
geiineuville 0:9cf1d79ebe04 298
geiineuville 0:9cf1d79ebe04 299 for (year = 1999; year < 2016; year++) {
geiineuville 0:9cf1d79ebe04 300 r = _sntp_dst_calc(tz, zone, year, DST_START);
geiineuville 0:9cf1d79ebe04 301 strftime(_buffer, sizeof(_buffer), "%A %m/%d/%Y %H:%M:%S", localtime(&r.t));
geiineuville 0:9cf1d79ebe04 302 printf(" (0,%d,start) %s %d\r\n", year, _buffer, r.dst);
geiineuville 0:9cf1d79ebe04 303
geiineuville 0:9cf1d79ebe04 304 r = _sntp_dst_calc(tz, zone, year, DST_STOP);
geiineuville 0:9cf1d79ebe04 305 strftime(_buffer, sizeof(_buffer), "%A %m/%d/%Y %H:%M:%S", localtime(&r.t));
geiineuville 0:9cf1d79ebe04 306 printf(" (0,%d,stop ) %s %d\r\n", year, _buffer, r.dst);
geiineuville 0:9cf1d79ebe04 307 }
geiineuville 0:9cf1d79ebe04 308 }
geiineuville 0:9cf1d79ebe04 309
geiineuville 0:9cf1d79ebe04 310 static void test_sntp_dst_point(int index) {
geiineuville 0:9cf1d79ebe04 311 char _buffer[64];
geiineuville 0:9cf1d79ebe04 312 struct tm t;
geiineuville 0:9cf1d79ebe04 313 tDstPoint r;
geiineuville 0:9cf1d79ebe04 314 int tz=gSntpTimezone;
geiineuville 0:9cf1d79ebe04 315 tDST_ZONE zone=gSntpDstZone;
geiineuville 0:9cf1d79ebe04 316 int year = 2009, day, month;
geiineuville 0:9cf1d79ebe04 317
geiineuville 0:9cf1d79ebe04 318 int norm = (index > 0) ? (int)(index/2) : (int)((index-1)/2);
geiineuville 0:9cf1d79ebe04 319 printf("\r\nTEST: _sntp_dst_point(%d) norm=%d\r\n", index, norm);
geiineuville 0:9cf1d79ebe04 320
geiineuville 0:9cf1d79ebe04 321 t.tm_sec = 0; // 0-59
geiineuville 0:9cf1d79ebe04 322 t.tm_min = 0; // 0-59
geiineuville 0:9cf1d79ebe04 323 t.tm_hour = 9; // 0-23
geiineuville 0:9cf1d79ebe04 324 t.tm_year = year-1900;
geiineuville 0:9cf1d79ebe04 325
geiineuville 0:9cf1d79ebe04 326 day = 1;
geiineuville 0:9cf1d79ebe04 327 for (month = 0; month < 2; month++) {
geiineuville 0:9cf1d79ebe04 328 t.tm_mon = month;
geiineuville 0:9cf1d79ebe04 329 t.tm_mday = day;
geiineuville 0:9cf1d79ebe04 330 t.tm_year = year-1900;
geiineuville 0:9cf1d79ebe04 331 r = _sntp_dst_point(tz, zone, mktime(&t), index);
geiineuville 0:9cf1d79ebe04 332 strftime(_buffer, sizeof(_buffer), "%A %m/%d/%Y %H:%M:%S", localtime(&r.t));
geiineuville 0:9cf1d79ebe04 333 printf(" (0,%02d/%02d/%d,%d) %s %d\r\n", month+1, day, year, index, _buffer, r.dst);
geiineuville 0:9cf1d79ebe04 334 }
geiineuville 0:9cf1d79ebe04 335
geiineuville 0:9cf1d79ebe04 336 for (day = 1; day < 32; day++) {
geiineuville 0:9cf1d79ebe04 337 t.tm_mon = month;
geiineuville 0:9cf1d79ebe04 338 t.tm_mday = day;
geiineuville 0:9cf1d79ebe04 339 t.tm_year = year-1900;
geiineuville 0:9cf1d79ebe04 340 r = _sntp_dst_point(tz, zone, mktime(&t), index);
geiineuville 0:9cf1d79ebe04 341 strftime(_buffer, sizeof(_buffer), "%A %m/%d/%Y %H:%M:%S", localtime(&r.t));
geiineuville 0:9cf1d79ebe04 342 printf(" (0,%02d/%02d/%d,%d) %s %d\r\n", month+1, day, year, index, _buffer, r.dst);
geiineuville 0:9cf1d79ebe04 343 }
geiineuville 0:9cf1d79ebe04 344
geiineuville 0:9cf1d79ebe04 345 day = 30;
geiineuville 0:9cf1d79ebe04 346 for (; month < 10; month++) {
geiineuville 0:9cf1d79ebe04 347 t.tm_mon = month;
geiineuville 0:9cf1d79ebe04 348 t.tm_mday = day;
geiineuville 0:9cf1d79ebe04 349 t.tm_year = year-1900;
geiineuville 0:9cf1d79ebe04 350 r = _sntp_dst_point(tz, zone, mktime(&t), index);
geiineuville 0:9cf1d79ebe04 351 strftime(_buffer, sizeof(_buffer), "%A %m/%d/%Y %H:%M:%S", localtime(&r.t));
geiineuville 0:9cf1d79ebe04 352 printf(" (0,%02d/%02d/%d,%d) %s %d\r\n", month+1, day, year, index, _buffer, r.dst);
geiineuville 0:9cf1d79ebe04 353 }
geiineuville 0:9cf1d79ebe04 354
geiineuville 0:9cf1d79ebe04 355 for (day = 1; day < 32; day++) {
geiineuville 0:9cf1d79ebe04 356 t.tm_mon = month;
geiineuville 0:9cf1d79ebe04 357 t.tm_mday = day;
geiineuville 0:9cf1d79ebe04 358 t.tm_year = year-1900;
geiineuville 0:9cf1d79ebe04 359 r = _sntp_dst_point(tz, zone, mktime(&t), index);
geiineuville 0:9cf1d79ebe04 360 strftime(_buffer, sizeof(_buffer), "%A %m/%d/%Y %H:%M:%S", localtime(&r.t));
geiineuville 0:9cf1d79ebe04 361 printf(" (0,%02d/%02d/%d,%d) %s %d\r\n", month+1, day, year, index, _buffer, r.dst);
geiineuville 0:9cf1d79ebe04 362 }
geiineuville 0:9cf1d79ebe04 363
geiineuville 0:9cf1d79ebe04 364 }
geiineuville 0:9cf1d79ebe04 365 #endif // SNTP_DST_TESTS
geiineuville 0:9cf1d79ebe04 366
geiineuville 0:9cf1d79ebe04 367 // Set current DST
geiineuville 0:9cf1d79ebe04 368 static void _sntp_dst_now(void) {
geiineuville 0:9cf1d79ebe04 369 time_t now = time(NULL);
geiineuville 0:9cf1d79ebe04 370 // Convert to standart local time (no DST)
geiineuville 0:9cf1d79ebe04 371 now = gSntpRtcUtc ? (now + gSntpTimezone) : (now - gSntpDST);
geiineuville 0:9cf1d79ebe04 372
geiineuville 0:9cf1d79ebe04 373 // Check DST setting for now
geiineuville 0:9cf1d79ebe04 374 tDstPoint dst = _sntp_dst_point(gSntpTimezone, gSntpDstZone, now, -1);
geiineuville 0:9cf1d79ebe04 375
geiineuville 0:9cf1d79ebe04 376 #ifdef LWIP_DEBUG
geiineuville 0:9cf1d79ebe04 377 char _buffer[64];
geiineuville 0:9cf1d79ebe04 378 strftime(_buffer, sizeof(_buffer), "%A %m/%d/%Y %H:%M:%S", localtime(&dst.t));
geiineuville 0:9cf1d79ebe04 379 LWIP_DEBUGF(SNTP_DEBUG_STATE, (
geiineuville 0:9cf1d79ebe04 380 "DEBUG: _sntp_dst_now(%d) based on last DST change on (%d) %s to (+%04d sec)\r\n",
geiineuville 0:9cf1d79ebe04 381 now, dst.t, _buffer, dst.dst));
geiineuville 0:9cf1d79ebe04 382 #endif
geiineuville 0:9cf1d79ebe04 383
geiineuville 0:9cf1d79ebe04 384 // Change RTC
geiineuville 0:9cf1d79ebe04 385 SNTPSetDSTEx(dst.dst, true);
geiineuville 0:9cf1d79ebe04 386 }
geiineuville 0:9cf1d79ebe04 387
geiineuville 0:9cf1d79ebe04 388 // Plan for next DST change
geiineuville 0:9cf1d79ebe04 389 static void _sntp_dst_schedule(void) {
geiineuville 0:9cf1d79ebe04 390 time_t now = time(NULL);
geiineuville 0:9cf1d79ebe04 391 // Convert to standart local time (no DST)
geiineuville 0:9cf1d79ebe04 392 now = gSntpRtcUtc ? (now + gSntpTimezone) : (now - gSntpDST);
geiineuville 0:9cf1d79ebe04 393
geiineuville 0:9cf1d79ebe04 394 // Check next DST change point
geiineuville 0:9cf1d79ebe04 395 tDstPoint dst = _sntp_dst_point(gSntpTimezone, gSntpDstZone, now, 0);
geiineuville 0:9cf1d79ebe04 396
geiineuville 0:9cf1d79ebe04 397 if (dst.t) {
geiineuville 0:9cf1d79ebe04 398
geiineuville 0:9cf1d79ebe04 399 #ifdef LWIP_DEBUG
geiineuville 0:9cf1d79ebe04 400 char _buffer[64];
geiineuville 0:9cf1d79ebe04 401 strftime(_buffer, sizeof(_buffer), "%A %m/%d/%Y %H:%M:%S", localtime(&dst.t));
geiineuville 0:9cf1d79ebe04 402 #endif
geiineuville 0:9cf1d79ebe04 403
geiineuville 0:9cf1d79ebe04 404 // Set our alarm clock
geiineuville 0:9cf1d79ebe04 405 // Convert from standard local to UTC time or local time
geiineuville 0:9cf1d79ebe04 406 dst.t = gSntpRtcUtc ? (dst.t - gSntpTimezone) : (dst.t + gSntpDST);
geiineuville 0:9cf1d79ebe04 407
geiineuville 0:9cf1d79ebe04 408 #ifdef LWIP_DEBUG
geiineuville 0:9cf1d79ebe04 409 if (time(NULL) > dst.t) {
geiineuville 0:9cf1d79ebe04 410 LWIP_DEBUGF(SNTP_DEBUG_STATE, (
geiineuville 0:9cf1d79ebe04 411 "DEBUG: _sntp_dst_schedule() ASSERTION FAILED !(%d<%d) trying to schedule for the past: %s (+%04d sec)\r\n",
geiineuville 0:9cf1d79ebe04 412 time(NULL), dst.t, _buffer, dst.dst));
geiineuville 0:9cf1d79ebe04 413 } else {
geiineuville 0:9cf1d79ebe04 414 LWIP_DEBUGF(SNTP_DEBUG_STATE, (
geiineuville 0:9cf1d79ebe04 415 "DEBUG: _sntp_dst_schedule() scheduled in %d seconds, set for %s (+%04d sec)\r\n",
geiineuville 0:9cf1d79ebe04 416 dst.t-time(NULL), _buffer, dst.dst));
geiineuville 0:9cf1d79ebe04 417 }
geiineuville 0:9cf1d79ebe04 418 #endif
geiineuville 0:9cf1d79ebe04 419 }
geiineuville 0:9cf1d79ebe04 420 gSntpRtcTCR = dst.t;
geiineuville 0:9cf1d79ebe04 421 gSntpRtcTCRDST = dst.dst;
geiineuville 0:9cf1d79ebe04 422 }
geiineuville 0:9cf1d79ebe04 423
geiineuville 0:9cf1d79ebe04 424 // RTC ISR - called upon each RTC tick
geiineuville 0:9cf1d79ebe04 425 static void _sntp_isr(void) {
geiineuville 0:9cf1d79ebe04 426 time_t seconds = time(NULL);
geiineuville 0:9cf1d79ebe04 427 if (gSntpRtcTCR && seconds > gSntpRtcTCR ) {
geiineuville 0:9cf1d79ebe04 428 // DST change has arrived
geiineuville 0:9cf1d79ebe04 429 gSntpRtcTCR = 0;
geiineuville 0:9cf1d79ebe04 430 // Disable ISR and avoid extra calcs in SNTPSetDSTEx()
geiineuville 0:9cf1d79ebe04 431
geiineuville 0:9cf1d79ebe04 432 //if (gSntpRtcTCRDST != gSntpDST) {
geiineuville 0:9cf1d79ebe04 433 // Change to/from DST
geiineuville 0:9cf1d79ebe04 434 SNTPSetDSTEx(gSntpRtcTCRDST, true);
geiineuville 0:9cf1d79ebe04 435 gSntpRtcTCRDST = 0;
geiineuville 0:9cf1d79ebe04 436
geiineuville 0:9cf1d79ebe04 437 // Schedule callback to plan for next DST change (take it out of ISR context)
geiineuville 0:9cf1d79ebe04 438 gSntpDelay.attach(_sntp_dst_schedule, 1.0);
geiineuville 0:9cf1d79ebe04 439
geiineuville 0:9cf1d79ebe04 440 #ifdef LWIP_DEBUG
geiineuville 0:9cf1d79ebe04 441 char _buffer[64];
geiineuville 0:9cf1d79ebe04 442 if (gSntpRtcUtc) {
geiineuville 0:9cf1d79ebe04 443 seconds += gSntpTimezone + gSntpDST; // Convert to local time
geiineuville 0:9cf1d79ebe04 444 }
geiineuville 0:9cf1d79ebe04 445 strftime(_buffer, sizeof(_buffer), "%A %m/%d/%Y %H:%M:%S", localtime(&seconds));
geiineuville 0:9cf1d79ebe04 446 LWIP_DEBUGF(SNTP_DEBUG_STATE, (
geiineuville 0:9cf1d79ebe04 447 "DEBUG: _sntp_isr() changed DST. datetime=%s\r\n", _buffer));
geiineuville 0:9cf1d79ebe04 448 #endif
geiineuville 0:9cf1d79ebe04 449
geiineuville 0:9cf1d79ebe04 450 //}
geiineuville 0:9cf1d79ebe04 451
geiineuville 0:9cf1d79ebe04 452 }
geiineuville 0:9cf1d79ebe04 453 }
geiineuville 0:9cf1d79ebe04 454
geiineuville 0:9cf1d79ebe04 455 // NTP Callback - timestamp from NTP server arrives here
geiineuville 0:9cf1d79ebe04 456 void SntpClientSet(time_t seconds) {
geiineuville 0:9cf1d79ebe04 457 time_t old_seconds = time(NULL);
geiineuville 0:9cf1d79ebe04 458 if (!gSntpRtcUtc) {
geiineuville 0:9cf1d79ebe04 459 seconds += gSntpTimezone + gSntpDST; // Convert to local time
geiineuville 0:9cf1d79ebe04 460 }
geiineuville 0:9cf1d79ebe04 461 set_time(seconds);
geiineuville 0:9cf1d79ebe04 462
geiineuville 0:9cf1d79ebe04 463 // Special tasks for the very first NTP updates
geiineuville 0:9cf1d79ebe04 464 if (!gSntpUpdates) {
geiineuville 0:9cf1d79ebe04 465
geiineuville 0:9cf1d79ebe04 466 #if defined(LWIP_DEBUG)
geiineuville 0:9cf1d79ebe04 467 // Report DST dates for the zone
geiineuville 0:9cf1d79ebe04 468 struct tm *pt = localtime(&seconds);
geiineuville 0:9cf1d79ebe04 469 _sntp_dst_dates(gSntpTimezone, gSntpDstZone, pt->tm_year+1900);
geiineuville 0:9cf1d79ebe04 470 #endif
geiineuville 0:9cf1d79ebe04 471
geiineuville 0:9cf1d79ebe04 472 // DST scheduler
geiineuville 0:9cf1d79ebe04 473 _sntp_dst_now();
geiineuville 0:9cf1d79ebe04 474 _sntp_dst_schedule();
geiineuville 0:9cf1d79ebe04 475
geiineuville 0:9cf1d79ebe04 476 // Enable RTC ISR
geiineuville 0:9cf1d79ebe04 477 gSntpTicker.attach(_sntp_isr, 1.0);
geiineuville 0:9cf1d79ebe04 478 }
geiineuville 0:9cf1d79ebe04 479
geiineuville 0:9cf1d79ebe04 480 if (gSntpUpdates && abs((int)(old_seconds - seconds)) > SNTP_EPSILON) {
geiineuville 0:9cf1d79ebe04 481 printf("SNTP settime() corrected big difference: (%d) seconds, more than %d. Big updates count=%d.\r\n",
geiineuville 0:9cf1d79ebe04 482 old_seconds-seconds, SNTP_EPSILON, gSntpUpdatesBig);
geiineuville 0:9cf1d79ebe04 483 gSntpUpdatesBig ++;
geiineuville 0:9cf1d79ebe04 484 }
geiineuville 0:9cf1d79ebe04 485
geiineuville 0:9cf1d79ebe04 486 gSntpUpdates++;
geiineuville 0:9cf1d79ebe04 487
geiineuville 0:9cf1d79ebe04 488 if (1) {
geiineuville 0:9cf1d79ebe04 489 char _buffer[64];
geiineuville 0:9cf1d79ebe04 490 if (gSntpRtcUtc) {
geiineuville 0:9cf1d79ebe04 491 seconds += gSntpTimezone + gSntpDST; // Convert to local time
geiineuville 0:9cf1d79ebe04 492 }
geiineuville 0:9cf1d79ebe04 493 strftime(_buffer, sizeof(_buffer), "%A %m/%d/%Y %H:%M:%S", localtime(&seconds));
geiineuville 0:9cf1d79ebe04 494 printf("SNTP settime() #%d seconds=%d TZ=%0.1f datetime=%s\r\n",
geiineuville 0:9cf1d79ebe04 495 gSntpUpdates, seconds, gSntpTimezone/3600.0, _buffer);
geiineuville 0:9cf1d79ebe04 496 }
geiineuville 0:9cf1d79ebe04 497 }
geiineuville 0:9cf1d79ebe04 498 #ifdef __cplusplus
geiineuville 0:9cf1d79ebe04 499 };
geiineuville 0:9cf1d79ebe04 500 #endif
geiineuville 0:9cf1d79ebe04 501
geiineuville 0:9cf1d79ebe04 502 #ifdef __cplusplus
geiineuville 0:9cf1d79ebe04 503 extern "C" {
geiineuville 0:9cf1d79ebe04 504 #endif
geiineuville 0:9cf1d79ebe04 505
geiineuville 0:9cf1d79ebe04 506 #include "lwip/def.h"
geiineuville 0:9cf1d79ebe04 507 #include "lwip/pbuf.h"
geiineuville 0:9cf1d79ebe04 508 #include "lwip/sys.h"
geiineuville 0:9cf1d79ebe04 509 #include "lwip/stats.h"
geiineuville 0:9cf1d79ebe04 510 #include "netif/etharp.h"
geiineuville 0:9cf1d79ebe04 511 #include "string.h"
geiineuville 0:9cf1d79ebe04 512
geiineuville 0:9cf1d79ebe04 513 #ifdef __cplusplus
geiineuville 0:9cf1d79ebe04 514 };
geiineuville 0:9cf1d79ebe04 515 #endif
geiineuville 0:9cf1d79ebe04 516
geiineuville 0:9cf1d79ebe04 517 // Accomodating sntp timeout functions
geiineuville 0:9cf1d79ebe04 518 #if NO_SYS
geiineuville 0:9cf1d79ebe04 519 #include "sntp.h"
geiineuville 0:9cf1d79ebe04 520 extern void sntp_request(void *arg); // this is dirty hack around "static" function. Some linkers may revolt!
geiineuville 0:9cf1d79ebe04 521 extern void sntp_try_next_server(void *arg);
geiineuville 0:9cf1d79ebe04 522 extern char* sntp_server_addresses[];
geiineuville 0:9cf1d79ebe04 523 extern u8_t sntp_current_server;
geiineuville 0:9cf1d79ebe04 524 extern u8_t sntp_num_servers;
geiineuville 0:9cf1d79ebe04 525 static void (*sntp_addresses_free)(void*) = NULL;
geiineuville 0:9cf1d79ebe04 526 static Timeout _sntp_timer1;
geiineuville 0:9cf1d79ebe04 527 static Timeout _sntp_timer2;
geiineuville 0:9cf1d79ebe04 528 void sntp_sys_timeout(u32_t timeout_s, void (*func)(void *arg), void *arg) {
geiineuville 0:9cf1d79ebe04 529 // all we really need to track is only 2 functions: sntp_request, sntp_try_next_server
geiineuville 0:9cf1d79ebe04 530 Timeout *t = NULL;
geiineuville 0:9cf1d79ebe04 531 if (func == &sntp_request) {
geiineuville 0:9cf1d79ebe04 532 t = &_sntp_timer1;
geiineuville 0:9cf1d79ebe04 533 LWIP_DEBUGF(SNTP_DEBUG_STATE, ("DEBUG: IN sntp_sys_timeout(), func=sntp_request\r\n"));
geiineuville 0:9cf1d79ebe04 534 } else if (func == &sntp_try_next_server) {
geiineuville 0:9cf1d79ebe04 535 t = &_sntp_timer2;
geiineuville 0:9cf1d79ebe04 536 LWIP_DEBUGF(SNTP_DEBUG_STATE, ("DEBUG: IN sntp_sys_timeout(), func=sntp_try_next_server\r\n"));
geiineuville 0:9cf1d79ebe04 537 }
geiineuville 0:9cf1d79ebe04 538 if (t) {
geiineuville 0:9cf1d79ebe04 539 t->detach();
geiineuville 0:9cf1d79ebe04 540 t->attach((void(*)(void))func, 1.0*timeout_s);
geiineuville 0:9cf1d79ebe04 541 // Another shortcut - we have no arg to pass, so just typecast the func.
geiineuville 0:9cf1d79ebe04 542 }
geiineuville 0:9cf1d79ebe04 543 }
geiineuville 0:9cf1d79ebe04 544
geiineuville 0:9cf1d79ebe04 545 void sntp_sys_untimeout(void (*func)(void *arg), void *arg) {
geiineuville 0:9cf1d79ebe04 546 Timeout *t = NULL;
geiineuville 0:9cf1d79ebe04 547 if (func == &sntp_request) {
geiineuville 0:9cf1d79ebe04 548 t = &_sntp_timer1;
geiineuville 0:9cf1d79ebe04 549 LWIP_DEBUGF(SNTP_DEBUG_STATE, ("DEBUG: IN sntp_sys_untimeout(), func=sntp_request\r\n"));
geiineuville 0:9cf1d79ebe04 550 } else if (func == &sntp_try_next_server) {
geiineuville 0:9cf1d79ebe04 551 t = &_sntp_timer2;
geiineuville 0:9cf1d79ebe04 552 LWIP_DEBUGF(SNTP_DEBUG_STATE, ("DEBUG: IN sntp_sys_untimeout(), func=sntp_try_next_server\r\n"));
geiineuville 0:9cf1d79ebe04 553 }
geiineuville 0:9cf1d79ebe04 554 if (t) {
geiineuville 0:9cf1d79ebe04 555 t->detach();
geiineuville 0:9cf1d79ebe04 556 }
geiineuville 0:9cf1d79ebe04 557 }
geiineuville 0:9cf1d79ebe04 558
geiineuville 0:9cf1d79ebe04 559 #else // NO_SYS
geiineuville 0:9cf1d79ebe04 560 #error "I don't know how to compile LWIP/SNTP with NO_SYS=0"
geiineuville 0:9cf1d79ebe04 561 #endif // NO_SYS
geiineuville 0:9cf1d79ebe04 562
geiineuville 0:9cf1d79ebe04 563 // Can be called when already running
geiineuville 0:9cf1d79ebe04 564 void SNTPSetDstZone(tDST_ZONE zone) {
geiineuville 0:9cf1d79ebe04 565 if (zone >= DST_ZONE_DESCR_CNT)
geiineuville 0:9cf1d79ebe04 566 return; // ERR_INVALID_ARG
geiineuville 0:9cf1d79ebe04 567
geiineuville 0:9cf1d79ebe04 568 gSntpDstZone = zone;
geiineuville 0:9cf1d79ebe04 569
geiineuville 0:9cf1d79ebe04 570 if (gSntpRunning) {
geiineuville 0:9cf1d79ebe04 571 // DST scheduler
geiineuville 0:9cf1d79ebe04 572 _sntp_dst_now();
geiineuville 0:9cf1d79ebe04 573 _sntp_dst_schedule();
geiineuville 0:9cf1d79ebe04 574 }
geiineuville 0:9cf1d79ebe04 575 }
geiineuville 0:9cf1d79ebe04 576
geiineuville 0:9cf1d79ebe04 577 void SNTPSetRecvTimeout(unsigned int val_s) { gSntpRecvTimeout_s = val_s; }
geiineuville 0:9cf1d79ebe04 578 void SNTPSetUpdateDelay(unsigned int val_s) { gSntpUpdateDelay_s = val_s; }
geiineuville 0:9cf1d79ebe04 579 void SNTPSetTimezone(float hours_from_utc, bool adjust_clock) {
geiineuville 0:9cf1d79ebe04 580 if (adjust_clock && !gSntpRtcUtc) {
geiineuville 0:9cf1d79ebe04 581 time_t seconds = time(NULL);
geiineuville 0:9cf1d79ebe04 582 seconds -= gSntpTimezone; // Convert from old local time
geiineuville 0:9cf1d79ebe04 583 seconds += hours_from_utc * 3600; // Convert to new local time
geiineuville 0:9cf1d79ebe04 584 set_time(seconds);
geiineuville 0:9cf1d79ebe04 585 if (gSntpRtcTCR) {
geiineuville 0:9cf1d79ebe04 586 // Adjust our alarm clock
geiineuville 0:9cf1d79ebe04 587 gSntpRtcTCR -= gSntpTimezone;
geiineuville 0:9cf1d79ebe04 588 gSntpRtcTCR += hours_from_utc * 3600;
geiineuville 0:9cf1d79ebe04 589 }
geiineuville 0:9cf1d79ebe04 590 }
geiineuville 0:9cf1d79ebe04 591 gSntpTimezone = hours_from_utc * 3600;
geiineuville 0:9cf1d79ebe04 592 }
geiineuville 0:9cf1d79ebe04 593 void SNTPSetDST(float hours_from_utc, bool adjust_clock) {
geiineuville 0:9cf1d79ebe04 594 SNTPSetDSTEx(hours_from_utc * 3600, adjust_clock);
geiineuville 0:9cf1d79ebe04 595 }
geiineuville 0:9cf1d79ebe04 596
geiineuville 0:9cf1d79ebe04 597 static int sntp_num_servers_alloc = 0;
geiineuville 0:9cf1d79ebe04 598 static void _SNTPClrAddresses(void) {
geiineuville 0:9cf1d79ebe04 599 if (!sntp_num_servers_alloc) sntp_num_servers_alloc = sntp_num_servers;
geiineuville 0:9cf1d79ebe04 600 // Here we save the original size of the sntp_server_addresses[] array.
geiineuville 0:9cf1d79ebe04 601
geiineuville 0:9cf1d79ebe04 602 if (sntp_addresses_free) {
geiineuville 0:9cf1d79ebe04 603 for (int i=0; i<sntp_num_servers; i++) {
geiineuville 0:9cf1d79ebe04 604 sntp_addresses_free(sntp_server_addresses[i]);
geiineuville 0:9cf1d79ebe04 605 }
geiineuville 0:9cf1d79ebe04 606 }
geiineuville 0:9cf1d79ebe04 607 sntp_current_server = 0;
geiineuville 0:9cf1d79ebe04 608 sntp_num_servers = 0;
geiineuville 0:9cf1d79ebe04 609 sntp_addresses_free = NULL;
geiineuville 0:9cf1d79ebe04 610 }
geiineuville 0:9cf1d79ebe04 611 static int _SNTPAddAddress(const char* server_address) {
geiineuville 0:9cf1d79ebe04 612 if (sntp_num_servers+1 > sntp_num_servers_alloc)
geiineuville 0:9cf1d79ebe04 613 return -1;
geiineuville 0:9cf1d79ebe04 614 sntp_server_addresses[sntp_num_servers] = (char*)malloc(strlen(server_address)+1);
geiineuville 0:9cf1d79ebe04 615 if (sntp_server_addresses[sntp_num_servers] == NULL) return -1; // Out of memory
geiineuville 0:9cf1d79ebe04 616 strcpy(sntp_server_addresses[sntp_num_servers], server_address);
geiineuville 0:9cf1d79ebe04 617 sntp_num_servers++;
geiineuville 0:9cf1d79ebe04 618 return 0;
geiineuville 0:9cf1d79ebe04 619 }
geiineuville 0:9cf1d79ebe04 620
geiineuville 0:9cf1d79ebe04 621 // Override default servers list.
geiineuville 0:9cf1d79ebe04 622 // For no-copy, pass pointer to free() in p_free.
geiineuville 0:9cf1d79ebe04 623 // Returns: actual number of servers set (limited by allocated buffer size)
geiineuville 0:9cf1d79ebe04 624 // WARNING! There is no interlock to ensure that SNTP service does not read its data while we are updating it.
geiineuville 0:9cf1d79ebe04 625 // This function is intended to be called only before SNTPClientInit().
geiineuville 0:9cf1d79ebe04 626 int SNTPSetAddresses(const char* server_addresses[], int count, void (*p_free)(void*)) {
geiineuville 0:9cf1d79ebe04 627 // In order to use sntp.c as-is, we hack into its static variables.
geiineuville 0:9cf1d79ebe04 628 // Not all compilers/linkers will support that.
geiineuville 0:9cf1d79ebe04 629
geiineuville 0:9cf1d79ebe04 630 _SNTPClrAddresses();
geiineuville 0:9cf1d79ebe04 631 if (count > sntp_num_servers_alloc)
geiineuville 0:9cf1d79ebe04 632 count = sntp_num_servers_alloc;
geiineuville 0:9cf1d79ebe04 633 for (int i=0; i<count; i++) {
geiineuville 0:9cf1d79ebe04 634 if (p_free) {
geiineuville 0:9cf1d79ebe04 635 sntp_server_addresses[i] = (char *)server_addresses[i];
geiineuville 0:9cf1d79ebe04 636 } else {
geiineuville 0:9cf1d79ebe04 637 _SNTPAddAddress(server_addresses[i]);
geiineuville 0:9cf1d79ebe04 638 }
geiineuville 0:9cf1d79ebe04 639 }
geiineuville 0:9cf1d79ebe04 640 sntp_num_servers = count;
geiineuville 0:9cf1d79ebe04 641 sntp_current_server = 0;
geiineuville 0:9cf1d79ebe04 642 sntp_addresses_free = p_free ? p_free : &free;
geiineuville 0:9cf1d79ebe04 643 return count;
geiineuville 0:9cf1d79ebe04 644 }
geiineuville 0:9cf1d79ebe04 645
geiineuville 0:9cf1d79ebe04 646 // Trim whitespace/CRLFs from both ends of a given string
geiineuville 0:9cf1d79ebe04 647 char * str_cleanup(char *in) {
geiineuville 0:9cf1d79ebe04 648 char * out = in;
geiineuville 0:9cf1d79ebe04 649 // Trim leading spaces and CR/LF
geiineuville 0:9cf1d79ebe04 650 while (*out == ' ' || *out == '\t' || *out == '\r' || *out == '\n')
geiineuville 0:9cf1d79ebe04 651 out ++;
geiineuville 0:9cf1d79ebe04 652 // Trim trailing spaces and CR/LF
geiineuville 0:9cf1d79ebe04 653 int len = strlen(out)-1;
geiineuville 0:9cf1d79ebe04 654 while (out[len] == ' ' || out[len] == '\t' || out[len] == '\r' || out[len] == '\n') {
geiineuville 0:9cf1d79ebe04 655 out[len] = '\0';
geiineuville 0:9cf1d79ebe04 656 len--;
geiineuville 0:9cf1d79ebe04 657 }
geiineuville 0:9cf1d79ebe04 658 return out;
geiineuville 0:9cf1d79ebe04 659 }
geiineuville 0:9cf1d79ebe04 660
geiineuville 0:9cf1d79ebe04 661 #ifndef CRLF
geiineuville 0:9cf1d79ebe04 662 #define CRLF "\r\n"
geiineuville 0:9cf1d79ebe04 663 #endif
geiineuville 0:9cf1d79ebe04 664 void SNTPWriteIniFile(FILE * f) {
geiineuville 0:9cf1d79ebe04 665 fprintf(f, "# SNTP Configuration file" CRLF);
geiineuville 0:9cf1d79ebe04 666 fprintf(f, CRLF "[Servers]" CRLF);
geiineuville 0:9cf1d79ebe04 667 for (int i=0; i<sntp_num_servers; i++) {
geiineuville 0:9cf1d79ebe04 668 fprintf(f, "%s" CRLF, sntp_server_addresses[i]);
geiineuville 0:9cf1d79ebe04 669 }
geiineuville 0:9cf1d79ebe04 670 fprintf(f, CRLF "[Global]" CRLF);
geiineuville 0:9cf1d79ebe04 671 fprintf(f, "RtcUtc=%d" CRLF, (int)gSntpRtcUtc);
geiineuville 0:9cf1d79ebe04 672 fprintf(f, "Timezone=%0.1f" CRLF, gSntpTimezone / 3600.0);
geiineuville 0:9cf1d79ebe04 673 fprintf(f, "DstZone=%d" CRLF, gSntpDstZone);
geiineuville 0:9cf1d79ebe04 674 fprintf(f, "# %s" CRLF, SNTPDstZoneName(gSntpDstZone));
geiineuville 0:9cf1d79ebe04 675 fprintf(f, "UpdateDelay=%d" CRLF, gSntpUpdateDelay_s);
geiineuville 0:9cf1d79ebe04 676 fprintf(f, "RecvTimeout=%d" CRLF, gSntpRecvTimeout_s);
geiineuville 0:9cf1d79ebe04 677 fprintf(f, CRLF "##END" CRLF);
geiineuville 0:9cf1d79ebe04 678 }
geiineuville 0:9cf1d79ebe04 679
geiineuville 0:9cf1d79ebe04 680 // Simple ini file parser for SNTP configuration (Case-sensitive!)
geiineuville 0:9cf1d79ebe04 681 // This function is intended to be called only before SNTPClientInit().
geiineuville 0:9cf1d79ebe04 682 // Returns: 0 if OK, errno otherwise
geiineuville 0:9cf1d79ebe04 683 enum {
geiineuville 0:9cf1d79ebe04 684 SECT_NONE,
geiineuville 0:9cf1d79ebe04 685 SECT_SERVERS,
geiineuville 0:9cf1d79ebe04 686 SECT_GLOBAL,
geiineuville 0:9cf1d79ebe04 687 };
geiineuville 0:9cf1d79ebe04 688 int SNTPReadIniFile(const char* filename) {
geiineuville 0:9cf1d79ebe04 689 FILE *f;
geiineuville 0:9cf1d79ebe04 690 char buf[512];
geiineuville 0:9cf1d79ebe04 691 bool addresses_cleared = false;
geiineuville 0:9cf1d79ebe04 692
geiineuville 0:9cf1d79ebe04 693 f = fopen(filename, "r");
geiineuville 0:9cf1d79ebe04 694 if (!f)
geiineuville 0:9cf1d79ebe04 695 return -1; // errno not used?
geiineuville 0:9cf1d79ebe04 696
geiineuville 0:9cf1d79ebe04 697 char *buf1, *buf2;
geiineuville 0:9cf1d79ebe04 698 int section=SECT_NONE;
geiineuville 0:9cf1d79ebe04 699 int line = 0;
geiineuville 0:9cf1d79ebe04 700 while (fgets(buf, sizeof(buf)/sizeof(buf[0]), f)) {
geiineuville 0:9cf1d79ebe04 701 line++;
geiineuville 0:9cf1d79ebe04 702 buf1 = str_cleanup(buf);
geiineuville 0:9cf1d79ebe04 703 if (*buf1 == '#' || *buf1 == '\0')
geiineuville 0:9cf1d79ebe04 704 continue; // Comment line or empty line - skip
geiineuville 0:9cf1d79ebe04 705 if (*buf1 == '[') {
geiineuville 0:9cf1d79ebe04 706 // New section
geiineuville 0:9cf1d79ebe04 707 if (0 == strncmp(buf1,"[Servers]", sizeof("[Servers]")-1)) {
geiineuville 0:9cf1d79ebe04 708 section=SECT_SERVERS;
geiineuville 0:9cf1d79ebe04 709 if (!addresses_cleared) {
geiineuville 0:9cf1d79ebe04 710 // Clear addresses only once.
geiineuville 0:9cf1d79ebe04 711 _SNTPClrAddresses();
geiineuville 0:9cf1d79ebe04 712 addresses_cleared = true;
geiineuville 0:9cf1d79ebe04 713 }
geiineuville 0:9cf1d79ebe04 714 } else if (0 == strncmp(buf1,"[Global]", sizeof("[Global]")-1)) {
geiineuville 0:9cf1d79ebe04 715 section=SECT_GLOBAL;
geiineuville 0:9cf1d79ebe04 716 } else {
geiineuville 0:9cf1d79ebe04 717 section=SECT_NONE;
geiineuville 0:9cf1d79ebe04 718 fprintf(stderr, "File \"%s\", line %d - section \"%s\" is not understood.\r\n", filename, line, buf1);
geiineuville 0:9cf1d79ebe04 719 }
geiineuville 0:9cf1d79ebe04 720 } else {
geiineuville 0:9cf1d79ebe04 721 // Section values
geiineuville 0:9cf1d79ebe04 722 switch (section) {
geiineuville 0:9cf1d79ebe04 723 case SECT_SERVERS:
geiineuville 0:9cf1d79ebe04 724 if (_SNTPAddAddress(buf1)) {
geiineuville 0:9cf1d79ebe04 725 fprintf(stderr, "File \"%s\", line %d - cannot add server \"%s\" - exceeded allocated slots.\r\n", filename, line, buf1);
geiineuville 0:9cf1d79ebe04 726 }
geiineuville 0:9cf1d79ebe04 727 break;
geiineuville 0:9cf1d79ebe04 728 case SECT_GLOBAL:
geiineuville 0:9cf1d79ebe04 729 buf2 = strchr(buf1, '=');
geiineuville 0:9cf1d79ebe04 730 if (buf2) {
geiineuville 0:9cf1d79ebe04 731 *buf2++ = '\0'; // Now buf1 has variable name, buf2 has value
geiineuville 0:9cf1d79ebe04 732 buf2 = str_cleanup(buf2);
geiineuville 0:9cf1d79ebe04 733 if (0 == strncmp(buf1, "Timezone", sizeof("Timezone")-1)) {
geiineuville 0:9cf1d79ebe04 734 gSntpTimezone = strtod(buf2, &buf2) * 3600;
geiineuville 0:9cf1d79ebe04 735 } else if (0 == strncmp(buf1, "UpdateDelay", sizeof("UpdateDelay")-1)) {
geiineuville 0:9cf1d79ebe04 736 gSntpUpdateDelay_s = strtoul(buf2, &buf2, 10);
geiineuville 0:9cf1d79ebe04 737 } else if (0 == strncmp(buf1, "RecvTimeout", sizeof("RecvTimeout")-1)) {
geiineuville 0:9cf1d79ebe04 738 gSntpRecvTimeout_s = strtoul(buf2, &buf2, 10);
geiineuville 0:9cf1d79ebe04 739 } else if (0 == strncmp(buf1, "RtcUtc", sizeof("RtcUtc")-1)) {
geiineuville 0:9cf1d79ebe04 740 gSntpRtcUtc = (bool)strtol(buf2, &buf2, 10);
geiineuville 0:9cf1d79ebe04 741 } else if (0 == strncmp(buf1, "DstZone", sizeof("DstZone")-1)) {
geiineuville 0:9cf1d79ebe04 742 // FIXME: It would be nice to allow human-readable string here.
geiineuville 0:9cf1d79ebe04 743 gSntpDstZone = (tDST_ZONE)strtol(buf2, &buf2, 10);
geiineuville 0:9cf1d79ebe04 744 } else {
geiineuville 0:9cf1d79ebe04 745 fprintf(stderr, "File \"%s\", line %d - unrecognized variable \"%s\" in section [Global]\r\n", filename, line, buf1);
geiineuville 0:9cf1d79ebe04 746 }
geiineuville 0:9cf1d79ebe04 747 } else {
geiineuville 0:9cf1d79ebe04 748 fprintf(stderr, "File \"%s\", line %d - unrecognized statement in section [Global]: %s\r\n", filename, line, buf1);
geiineuville 0:9cf1d79ebe04 749 }
geiineuville 0:9cf1d79ebe04 750 break;
geiineuville 0:9cf1d79ebe04 751 default:
geiineuville 0:9cf1d79ebe04 752 fprintf(stderr, "File \"%s\", line %d - unrecognized statement / no section: %s\r\n", filename, line, buf1);
geiineuville 0:9cf1d79ebe04 753 }
geiineuville 0:9cf1d79ebe04 754 }
geiineuville 0:9cf1d79ebe04 755 }
geiineuville 0:9cf1d79ebe04 756 fclose(f);
geiineuville 0:9cf1d79ebe04 757 printf("SNTP configuration read from file \"%s\", %d lines.\r\n", filename, line);
geiineuville 0:9cf1d79ebe04 758 return 0;
geiineuville 0:9cf1d79ebe04 759 }
geiineuville 0:9cf1d79ebe04 760
geiineuville 0:9cf1d79ebe04 761 // Start the SNTP client
geiineuville 0:9cf1d79ebe04 762 void SNTPClientInit(void) {
geiineuville 0:9cf1d79ebe04 763
geiineuville 0:9cf1d79ebe04 764 #ifdef SNTP_DST_TESTS
geiineuville 0:9cf1d79ebe04 765 // Test our DST algorithms
geiineuville 0:9cf1d79ebe04 766 test_sntp_dst_calc(gSntpTimezone, gSntpDstZone);
geiineuville 0:9cf1d79ebe04 767 test_sntp_dst_point(-2);
geiineuville 0:9cf1d79ebe04 768 test_sntp_dst_point(-1);
geiineuville 0:9cf1d79ebe04 769 test_sntp_dst_point(0);
geiineuville 0:9cf1d79ebe04 770 test_sntp_dst_point(1);
geiineuville 0:9cf1d79ebe04 771 test_sntp_dst_point(2);
geiineuville 0:9cf1d79ebe04 772 #endif
geiineuville 0:9cf1d79ebe04 773
geiineuville 0:9cf1d79ebe04 774 // SNTPv4 RFC 4330 enforces a minimum update time of 15 seconds
geiineuville 0:9cf1d79ebe04 775 if (gSntpUpdateDelay_s < 15) {
geiineuville 0:9cf1d79ebe04 776 gSntpUpdateDelay_s = 15;
geiineuville 0:9cf1d79ebe04 777 }
geiineuville 0:9cf1d79ebe04 778
geiineuville 0:9cf1d79ebe04 779 gSntpRunning = true;
geiineuville 0:9cf1d79ebe04 780
geiineuville 0:9cf1d79ebe04 781 // Just call this to start SNTP client:
geiineuville 0:9cf1d79ebe04 782 sntp_init();
geiineuville 0:9cf1d79ebe04 783
geiineuville 0:9cf1d79ebe04 784 // // Enable RTC ISR
geiineuville 0:9cf1d79ebe04 785 // gSntpTicker.attach(_sntp_isr, 1);
geiineuville 0:9cf1d79ebe04 786 // We do it from first NTP response
geiineuville 0:9cf1d79ebe04 787 }
geiineuville 0:9cf1d79ebe04 788
geiineuville 0:9cf1d79ebe04 789 // Use instead of system time()
geiineuville 0:9cf1d79ebe04 790 // Returns local time
geiineuville 0:9cf1d79ebe04 791 time_t SNTPTime(void) {
geiineuville 0:9cf1d79ebe04 792 time_t seconds = time(NULL);
geiineuville 0:9cf1d79ebe04 793 if (gSntpRtcUtc) {
geiineuville 0:9cf1d79ebe04 794 seconds += gSntpTimezone + gSntpDST; // Convert to local time
geiineuville 0:9cf1d79ebe04 795 }
geiineuville 0:9cf1d79ebe04 796 return seconds;
geiineuville 0:9cf1d79ebe04 797 }
geiineuville 0:9cf1d79ebe04 798
geiineuville 0:9cf1d79ebe04 799 // Use instead of system set_time()
geiineuville 0:9cf1d79ebe04 800 // seconds - local time
geiineuville 0:9cf1d79ebe04 801 void SNTPSetTime(time_t seconds) {
geiineuville 0:9cf1d79ebe04 802 if (gSntpRtcUtc) {
geiineuville 0:9cf1d79ebe04 803 seconds -= gSntpTimezone + gSntpDST; // Convert from local time
geiineuville 0:9cf1d79ebe04 804 }
geiineuville 0:9cf1d79ebe04 805 set_time(seconds);
geiineuville 0:9cf1d79ebe04 806 }
geiineuville 0:9cf1d79ebe04 807
geiineuville 0:9cf1d79ebe04 808 // Use instead of system time()
geiineuville 0:9cf1d79ebe04 809 // Returns UTC time
geiineuville 0:9cf1d79ebe04 810 time_t SNTPTimeUTC(void) {
geiineuville 0:9cf1d79ebe04 811 time_t seconds = time(NULL);
geiineuville 0:9cf1d79ebe04 812 if (!gSntpRtcUtc) {
geiineuville 0:9cf1d79ebe04 813 seconds -= gSntpTimezone + gSntpDST; // Convert from local time
geiineuville 0:9cf1d79ebe04 814 }
geiineuville 0:9cf1d79ebe04 815 return seconds;
geiineuville 0:9cf1d79ebe04 816 }
geiineuville 0:9cf1d79ebe04 817
geiineuville 0:9cf1d79ebe04 818 // Use instead of system set_time()
geiineuville 0:9cf1d79ebe04 819 // seconds - UTC time
geiineuville 0:9cf1d79ebe04 820 void SNTPSetTimeUTC(time_t seconds) {
geiineuville 0:9cf1d79ebe04 821 if (!gSntpRtcUtc) {
geiineuville 0:9cf1d79ebe04 822 seconds += gSntpTimezone + gSntpDST; // Convert to local time
geiineuville 0:9cf1d79ebe04 823 }
geiineuville 0:9cf1d79ebe04 824 set_time(seconds);
geiineuville 0:9cf1d79ebe04 825 }
geiineuville 0:9cf1d79ebe04 826
geiineuville 0:9cf1d79ebe04 827 //END