apps/sntpdate/sntpdate.c

Go to the documentation of this file.

/*
 * Simple Network Time Protocol (SNTP) Client
 *
 * Query an NTP server for a time, and set it.
 * Must be run as root to actually change the system time.
 *
 * Written by Bjorn Wesen
 * Copyright (c) 1999, 2000 Axis Communications AB
 *
 * $Id: sntpdate.c,v 1.1.1.1 2008/11/27 20:04:01 elphel Exp $
 *
 * HISTORY
 * -------
 *
 * $Log: sntpdate.c,v $
 * Revision 1.1.1.1  2008/11/27 20:04:01  elphel
 *
 *
 * Revision 1.2  2008/11/21 05:38:42  elphel
 * forced into non-daemon mode
 *
 * Revision 1.1.1.1  2007/06/12 19:50:18  elphel
 * This is a fresh tree based on elphel353-2.10
 *
 * Revision 1.1.1.1  2007/06/12 19:50:18  spectr_rain
 * firmware for Elphel 353 cameras, based on Axis 2.10 SDK
 *
 * Revision 1.1.1.1  2007/02/23 10:11:49  elphel
 * initial import into CVS
 *
 * Revision 1.2  2006/07/24 07:52:26  spectr_rain
 * *** empty log message ***
 *
 * Revision 1.1.1.1  2006/07/11 19:15:41  spectr_rain
 * unwork with less than 5MPx Micron sensor, initial branch
 *
 * Revision 1.4  2006/04/28 04:16:39  spectr_rain
 * syncronize with NTP on gateway
 *
 * Revision 1.2  2006/01/22 22:33:06  elphel
 * fixed "=auto" problem (sed version in the camera seemd to work incorrectly)
 *
 * Revision 1.1  2006/01/22 20:15:08  elphel
 * Added/modified old Axis program
 *
 * Revision 1.14  2000/07/05 16:03:09  bjornw
 * Round secs correctly in set_rtc
 *
 * Revision 1.13  2000/07/05 15:45:02  bjornw
 * Also set the RTC time when doing big time-changes.
 *
 * Revision 1.12  2000/07/05 13:59:56  bjornw
 * Use adjtime instead of settimeofday for small adjustments.
 *
 * Revision 1.11  2000/07/05 09:55:55  bjornw
 * * gcc-cris needs long double instead of double to get 8-byte precision
 * * Need to cast some constants to long double to get full precision in
 *   some arithmetics
 *
 * Revision 1.10  2000/07/04 10:51:07  bjornw
 * * Now uses the full sub-second resolution timing in SNTP
 * * Improved logging (turned on syslog in daemon mode)
 * * Some indentation fixes
 *
 * Revision 1.9  2000/02/15 12:14:59  finn
 * main: If something went wrong in the process of either sending or receiving
 * an NTP message, the counter `retries' was increased by one. However, this
 * counter was never reset to zero between every try, hence sntpdate could
 * only fail five times totally.
 *
 * Revision 1.8  1999/12/15 08:21:02  torbjore
 * * Now uses sntpdate.conf instead of parhand for configuration
 *
 *
 */
#include <sys/time.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <syslog.h>
#include <netdb.h>
#include <signal.h>
#include <ctype.h>
#include <stdarg.h>
#include <errno.h>

#include <asm/elphel/c313a.h>
#include <asm/elphel/fpgaconfa.h>

#ifdef DEVICE_HAS_RTC_WE_DO_NOT
  #include <asm/rtc.h>  /* for the RTC_SET_TIME ioctl */
#endif  
#include <sys/ioctl.h>

#define NTPDATE_FILE "/etc/sntpdate.conf"
#define NTPPORT 123   // NTP UDP port number
#define NTPTIMEOUT 4  // retry timeout in seconds
#define MAXRETRY 5    // number of times to retry

#define D(x)

/* some debug-output that does not require %f in vsprintf */

#define D2(x)
#define D3(x)

/* very portable; CRIS has 4-byte doubles and 8-byte long doubles
 * and we need 8-byte precision...
 */

#ifdef __CRIS__
typedef long double ntp_double;
#else
typedef double ntp_double;
#endif
#define SET_FPGA_TIME 0

/* NTP message format v4, from RFC 2030

                     1                   2                   3
       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |LI | VN  |Mode |    Stratum    |     Poll      |   Precision   |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                          Root Delay                           |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                       Root Dispersion                         |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                     Reference Identifier                      |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                                                               |
      |                   Reference Timestamp (64)                    |
      |                                                               |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                                                               |
      |                   Originate Timestamp (64)                    |
      |                                                               |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                                                               |
      |                    Receive Timestamp (64)                     |
      |                                                               |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                                                               |
      |                    Transmit Timestamp (64)                    |
      |                                                               |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                 Key Identifier (optional) (32)                |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                                                               |
      |                                                               |
      |                 Message Digest (optional) (128)               |
      |                                                               |
      |                                                               |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  Size of all required fields is 48 bytes. Including optional fields, 68.

*/

/* the NTP timestamp is the number of seconds since 0h, 1 January 1900. The
 * UNIX timeval started 70 years later (0h, 1 January 1970). The difference:
 */

const unsigned long UNIX_NTP_DIFF = 2208988800U;

/* it is _imperative_ that these are real 8-byte doubles otherwise nothing 
 * will work.
 */

const ntp_double NTP_SCALE = 4294967296.0;            /* 2^32, of course! */
const ntp_double NTP_SCALE_I = 2.3283064365e-10;      /* 2^-32 */

const long MILLION_L = 1000000;          /* For conversion to/from timeval */
const ntp_double MILLION_D = 1.0e6;          /* Must be equal to MILLION_L */
const ntp_double MILLION_D_I = 1.0e-6;       /* Must be equal to 1 / MILLION_L */

struct ntp_stamp {
        unsigned long sec, frac;
};

struct ntpmsg {
        unsigned long flags;
        unsigned long root_delay, root_dispersion, ref_id;
        struct ntp_stamp ref_stamp;      // time our clock was last set
        struct ntp_stamp orig_stamp;     // time we sent the request to the server      (T1)
        struct ntp_stamp receive_stamp;  // time the server received the request        (T2)
        struct ntp_stamp transmit_stamp; // time the server sent back the request to us (T3)
};

/* frac is a 32-bit binary fraction of a second
 * tv_usec is a 32-bit count of microseconds
 */

#define TO_FRAC(x) ((unsigned long)((((ntp_double)x) * 1.0e-6) * NTP_SCALE))
#define TO_USEC(x) ((unsigned long)((((ntp_double)x) * NTP_SCALE_I) * 1.0e6))
#ifdef DEVICE_HAS_RTC_WE_DO_NOT
  void set_rtc(struct timeval *);
#endif
#define USESYSLOG 
//#undef USESYSLOG 
#if SET_FPGA_TIME
void set_rtc_fpga(struct timeval *);
#endif
static int as_daemon = 0;  /* "daemon" or not. */

#ifdef USESYSLOG
/*
**  logging support
*/

static void
log(char *str, ...)
{
        va_list ap;
        static char buf[256];
        
        va_start(ap, str);
        vsnprintf(buf, 255, str, ap);
        if(as_daemon)
                syslog(LOG_ERR, buf);
        else
                fprintf(stderr, "sntpdate: %s\n", buf);
        va_end(ap);
        return;
}
#else
#define log printf
#endif

static volatile int check_config = 0;

static void
catch_signal(int sig)
{
        check_config = 1;
        signal(SIGUSR1, (void *)catch_signal);  /* retrig it */
}

int
main(int argc, char **argv)
{
        int ntpofd = 0;
        struct sockaddr_in addr;
        struct hostent *hp;
        struct ntpmsg ntpreq;
        struct ntpmsg ntpanswer;
        int retries;
        fd_set myset;
        struct timeval timeout;
        ntp_double T1, T2, T3, T4;
        ntp_double offset;
//      unsigned char *ntpserver = NULL;
#define MAXNUMSERVERS 10
        unsigned char * ntpservers[MAXNUMSERVERS];
        int numNTPServers=0;
        int curNTPServer=0;
        int refreshinterval = 3600;
        int refresh_counter = 0;
        int setup_connection = 0;
        int start_connection = 0;
        int zone_diff = 0;
        int ntp_active = 0;
        int use_config = 0;
        char* time_zone = NULL;
        char* time_source = NULL;
        int success=0;
   for (curNTPServer=0;curNTPServer<MAXNUMSERVERS;curNTPServer++) ntpservers[curNTPServer]=NULL;
//      int i;   
        if(argc < 2) {
                use_config = 1;
                check_config = 1;
                as_daemon++;
        }
        else {
                if(argc == 4 && !strcmp("-d", argv[1])) {
                        refreshinterval = atoi(argv[2]) * 60;
//                      ntpserver = argv[3];
                        ntpservers[numNTPServers++] = argv[3];
                        as_daemon++;
                } else
//                      ntpserver = argv[1];
                        ntpservers[numNTPServers++] = argv[1];
                setup_connection++;
        }

as_daemon=0;    
        
        
        /* set up signal handler */
        signal(SIGUSR1, (void *)catch_signal);

#ifdef USESYSLOG
        /* open logfile */

        if (as_daemon) {
                openlog(argv[0], LOG_PID, LOG_DAEMON);
                syslog(LOG_INFO, "Starting sntpdate as daemon...");
        }
#endif

        D(printf("Starting sntpdate as daemon...\n"));
        D3(printf("Starting sntpdate as daemon...\n"));
  
        /* daemon loop */
        if (as_daemon) {
                if(fork()) {
                        D(printf("sntpdate started as daemon...\n"));
                        sleep(1);
                        exit(0);
                }
        }
        do {
                if ((check_config) && (use_config)) {
                        int fd;
                        char fdata[2048];
                        char* param = NULL;
                        char* value = NULL;
                        int cnt;
                        int cnt2;
                        int cnt3;
                        int cnt4;
                        int scnt;
                        int tcnt;
                        int missing = 0;

                        check_config = 0;
                        ntp_active = 0;
                        start_connection = 0;

                        fd = open (NTPDATE_FILE, O_RDONLY);
                        if (fd >= 0) {
                                memset(fdata,0,2048);
                                tcnt=read(fd,fdata,2047);
                                if (tcnt==2047) {
                                        log("warning! conf-file too BIG!");
                                }
                                close(fd);
                                cnt=0;
                                scnt=0;
                                while (scnt<tcnt) {
                                        while (cnt<tcnt) {
                                                if ( (fdata[cnt]=='\0') ||
                                                     (fdata[cnt]=='\r') ||
                                                     (fdata[cnt]=='\n') ) {
                                                        fdata[cnt]='\0';
                                                        break;
                                                }
                                                D(printf("%c",fdata[cnt]));
                                                cnt++;
                                        }
                                        D(printf("\n"));
                                        cnt2 = scnt;
                                        cnt4 = scnt;
                                        cnt3 = 0;
                                        while (cnt2 < cnt) {
                                                if ((fdata[cnt2] == ' ')||
                                                    (fdata[cnt2 + 1] == '\0')) {
                                                        if (fdata[cnt2] == ' ') {
                                                                fdata[cnt2] = '\0';
                                                        }
                                                        switch (cnt3) {
                                                                case 0:
                                                                        param = &fdata[cnt4];
                                                                        break;
                                                                case 1:
                                                                        value = &fdata[cnt4];
                                                                        break;
                                                                default:
                                                                        break;
                                                        }
                                                        cnt3++;
                                                        cnt4 = cnt2 + 1;
                                                }
                                                cnt2++;
                                        }

                                        if (cnt3 == 2) {
                                                D(printf("DATA=(%s)(%s)\n", param, value));
                                                /* found three parts on this line */
                                                if (!strncmp ("TimeZone", param, strlen ("TimeZone"))) {
                                                        D(printf("found TimeZone %s\n",value));
                                                        if (time_zone) free(time_zone);
                                                        time_zone = strdup(value);
                                                }
                                                else if (!strncmp ("TimeSyncSource", param, strlen ("TimeSyncSource"))) {
                                                        D(printf("found SyncSource %s\n",value));
                                                        if (time_source) free(time_source);
                                                        time_source = strdup(value);
                                                }
                                                else if (!strncmp ("NTPServer", param, strlen ("NTPServer"))) {
                                                        D(printf("found NTPServer %s\n",value));
//                                                      if (ntpserver) free(ntpserver);
//                                                      ntpserver = strdup(value);
                                                        if (numNTPServers>=MAXNUMSERVERS) printf ("Too many NTPServers (>%d) - ignoring\n",MAXNUMSERVERS);
                                                        else ntpservers[numNTPServers++]  = strdup(value);
                                                }
                                                else if (!strncmp ("NTPUpdate", param, strlen ("NTPUpdate"))) {
                                                        D(printf("found NTPUpdate %s\n",value));
                                                        refreshinterval = atoi(value);
                                                        if (refreshinterval == 0) {
                                                                refreshinterval = 1;
                                                        }
                                                        refreshinterval *= 60;
                                                        D(printf("Refresh = %d\n",refreshinterval));
                                                }
                                        }
                                        scnt = ++cnt;
                                }
                                close(fd);
                        }
                        else {
                                log("error when opening config file");
                        }
/*
                        if (ntpserver) {
                                log("NTP server = %s", ntpserver);
                        }
*/
                        if (numNTPServers>0)
                          for (curNTPServer=0;curNTPServer<numNTPServers; curNTPServer++){
                                log("NTP server #%d = %s", curNTPServer, ntpservers[curNTPServer]);
                        }
                        else
                                missing++;

                        if (time_source) {
                                if (strcmp("NTP",time_source)==0) ntp_active=1;
                                log("Time Sync Source %s", time_source);
                        }
                        else
                                missing++;

                        if (time_zone) {
                                int tmp_time = 0;
                                zone_diff = 0;

                                D(printf("Time Zone = %s\n",time_zone));
                                if (!strncmp ("NONE", time_zone, strlen ("NONE"))) {
                                        D(printf("No Time Zone correction!\n"));
                                }
                                else if (!strncmp ("GMT", time_zone, strlen ("GMT"))) {
                                        /* first part correct */
                                        if (strlen(time_zone) == 3) {
                                                tmp_time = 0;
                                        }
                                        else if (time_zone[3] == '+') {
                                                tmp_time = 1;
                                        }
                                        else if (time_zone[3] == '-') {
                                                tmp_time = -1;
                                        }
                                        else {
                                                log("Time Zone corrupt");
                                        }

                                        if (tmp_time != 0) {
                                                switch (strlen(time_zone)) {
                                                        case 5: /* GMT-x */
                                                                if (isdigit(time_zone[4])) {
                                                                        tmp_time*=(time_zone[4]-'0')*10;
                                                                }
                                                                break;
                                                        case 6: /* GMT-xx */
                                                                if ((isdigit(time_zone[4])) &&
                                                                    (isdigit(time_zone[5]))) {
                                                                     tmp_time*=
                                                                      (time_zone[4]-'0')*100+(time_zone[5]-'0')*10;
                                                                }
                                                                break;
                                                        case 7: /* GMT-x.x */
                                                                if ((isdigit(time_zone[4])) &&
                                                                    (time_zone[5]=='.') &&
                                                                    (isdigit(time_zone[6]))) {
                                                                     tmp_time*=
                                                                      (time_zone[4]-'0')*10+(time_zone[6]-'0');
                                                                }
                                                                break;
                                                        case 8: /* GMT-xx.x */
                                                                if ((isdigit(time_zone[4])) &&
                                                                    (isdigit(time_zone[5])) &&
                                                                    (time_zone[6]=='.') &&
                                                                    (isdigit(time_zone[7]))) {
                                                                     tmp_time*=
                                                                      (time_zone[4]-'0')*100 +
                                                                      (time_zone[5]-'0')*10 +
                                                                      (time_zone[7]-'0');
                                                                }
                                                                break;
                                                        default: /* error */
                                                                break;
                                                }
                                        }
                                        zone_diff = tmp_time * 360;
                                        log("Zone Diff = %d", zone_diff);
                                }
                        }
                        else
                                missing++;

                        if (missing) {
                                log("NTP config not complete!");
                                check_config = 0;
                        }
                        else {
                                setup_connection = ntp_active;
                                check_config = 0;
                        }
                }
                curNTPServer=0;
// moving retry loop here to try multiple servers               
                retries = 0;
                while(retries < MAXRETRY) {
//
                        if (setup_connection) {
//                              setup_connection = 0;

                                D(printf("NTP: Setting up connection with server #%d (%s)\n",curNTPServer,ntpservers[curNTPServer]));

                                /* resolve SNTP hostname */

//                              if ((hp = gethostbyname(ntpserver)) == NULL) {
                                if ((hp = gethostbyname(ntpservers[curNTPServer])) == NULL) {
//                                      log("unknown host %s", ntpserver);
                                        log("unknown host %s", ntpservers[curNTPServer]);
                                }
                                /* setup sockets and do the connection/bind for output/input */
                                else if((ntpofd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
                                        perror("socket");
                                }
                                else {
                                        memset(&addr, 0, sizeof(addr));
                                        memcpy(&addr.sin_addr, hp->h_addr, hp->h_length);
                                        addr.sin_family = AF_INET;
                                        addr.sin_port   = htons(NTPPORT);

                                        if(connect(ntpofd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
                                                log("cant connect to %s", inet_ntoa(addr.sin_addr));
                                        }
                                        else {
                                                start_connection = 1;
                                                setup_connection = 0;
                                        }
                                }
                        }

                        if (start_connection) {
                                D(printf("NTP: Open connection\n"));

//                      retries = 0;

                        /* create the NTP client request UDP packet */

                                memset(&ntpreq, 0, sizeof(ntpreq));
                                ntpreq.flags = htonl(0x23000000); // Version 4, mode 3 (client)

                                /* off we go. loop if we dont get a reply */

//                              while(retries < MAXRETRY) {
                                struct timeval daytime;

                                D(printf("sending NTP client request, retry %d\n", retries));

                                /* Remember the T1 transmission time, and fill it
                                   into the request as well.  */

                                gettimeofday(&daytime, NULL);

                                T1 = (unsigned long)daytime.tv_sec + MILLION_D_I * daytime.tv_usec;

                                ntpreq.transmit_stamp.sec = htonl(daytime.tv_sec + UNIX_NTP_DIFF);
                                ntpreq.transmit_stamp.frac = htonl(TO_FRAC(daytime.tv_usec));

                                /* send the message */

                                if (send(ntpofd, &ntpreq, sizeof(ntpreq), 0) !=
                                    sizeof(ntpreq)) {
                                        log("cant send ntp request");
                                }

                                D2(log("transmit %u,%u  frac = %u", daytime.tv_sec, daytime.tv_usec,
                                       ntohl(ntpreq.transmit_stamp.frac)));

                                /* and wait for the answer, using a timeout */

                                timeout.tv_sec = NTPTIMEOUT;
                                timeout.tv_usec = 0;

                                FD_ZERO (&myset);
                                FD_SET (ntpofd, &myset);

                                if(select(ntpofd + 1, &myset, NULL, NULL, &timeout) > 0) {

                                        /* remember the T4 reception time */

                                        gettimeofday(&daytime, NULL);

                                        D2(log("receive %u,%u", daytime.tv_sec, daytime.tv_usec));
                                        
                                        T4 = (unsigned long)daytime.tv_sec + MILLION_D_I * daytime.tv_usec;

                                        /* read and see if its an NTP message */

                                        if(recv(ntpofd, &ntpanswer,
                                                sizeof(ntpanswer), 0) == sizeof(ntpanswer)) {
                                                D(printf("got NTP reply, flags 0x%x\n",
                                                         ntohl(ntpanswer.flags)));
                                                break;
                                        }
                                }
                        } //if (start_connection)

                        /* oh well. try again */
                        retries++;
                        curNTPServer++;
                        if (curNTPServer>=numNTPServers) curNTPServer=0; // start over
                        setup_connection = 1;
                        start_connection=0;
                } // while(retries < MAXRETRY)
                D(printf("broke from while(retries < MAXRETRY), retries=%d, MAXRETRY=%d\n",retries, MAXRETRY)); 
// ===================== either found or too many retries =======================
                        if(retries == MAXRETRY) {
                                log("connection attempts timed out");
                                close(ntpofd);
                                setup_connection = 1;
                        } else {
                                struct timeval adjust, old, new;
//                              long int zone;
                                long n;

                                /* process the data. extract the T2 and T3 times from the message */

                                D2(log("T2 %u,%u  T3 = %u,%u", 
                                       ntohl(ntpanswer.receive_stamp.sec) - UNIX_NTP_DIFF,
                                       ntohl(ntpanswer.receive_stamp.frac),
                                       ntohl(ntpanswer.transmit_stamp.sec) - UNIX_NTP_DIFF,
                                       ntohl(ntpanswer.transmit_stamp.frac)));
                                D(printf("T2 %u,%u  T3 = %u,%u", 
                                       ntohl(ntpanswer.receive_stamp.sec) - UNIX_NTP_DIFF,
                                       ntohl(ntpanswer.receive_stamp.frac),
                                       ntohl(ntpanswer.transmit_stamp.sec) - UNIX_NTP_DIFF,
                                       ntohl(ntpanswer.transmit_stamp.frac)));

                                T2 = (ntohl(ntpanswer.receive_stamp.sec) - UNIX_NTP_DIFF) + 
                                        ((ntp_double)ntohl(ntpanswer.receive_stamp.frac)) * NTP_SCALE_I;

                                T3 = (ntohl(ntpanswer.transmit_stamp.sec) - UNIX_NTP_DIFF) + 
                                        ((ntp_double)ntohl(ntpanswer.transmit_stamp.frac)) * NTP_SCALE_I;

                                D(printf("T1 %f T2 %f T3 %f T4 %f\n", T1, T2, T3, T4));

                                /* the local clock offset is a mean value of the differences */

                                offset = ((T2 - T1) + (T3 - T4)) * 0.5;

                                D(printf("clock offset %f\n", offset));
                                D2(log("T2-T1 %d, T3-T4 %d, offset %d",
                                       (long)(T2-T1),
                                       (long)(T3-T4),
                                       (long)offset));

                                /* compensate for zone difference between us and the server */

                                offset += zone_diff;

                                /* Start by converting to timeval format. Note that we have to cater for
                                   negative, unsigned values. */
                                
                                if ((n = (long)offset) > offset)
                                        --n;
                                adjust.tv_sec = n;
                                adjust.tv_usec = (long)(MILLION_D * (offset - n));

                                gettimeofday(&old, NULL);

                                new.tv_sec = old.tv_sec + adjust.tv_sec;
                                new.tv_usec = (n = (long)old.tv_usec + (long)adjust.tv_usec);

                                if (n < 0) {
                                        new.tv_usec += MILLION_L;
                                        --new.tv_sec;
                                } else if (n >= MILLION_L) {
                                        new.tv_usec -= MILLION_L;
                                        ++new.tv_sec;
                                }

                                /* update our clock - this will only work if we're run as root! */

                                if(as_daemon && ((!adjust.tv_sec && adjust.tv_usec < 131072) ||
                                                 (adjust.tv_sec == -1 && adjust.tv_usec > 868928))) {
                                        struct timeval previous;
                                        /* use adjtime to adjust the time - will smoothly "fade in"
                                         * the new time (only works for +/- 131072 usecs)
                                         */
                                        if(adjtime(&adjust, &previous)) {
                                                D(printf("Unable to adjust time (%d,%d): error %m",
                                                    adjust.tv_sec, adjust.tv_usec, errno));
                                                log("Unable to adjust time (%d,%d): error %m",
                                                    adjust.tv_sec, adjust.tv_usec, errno);
                                        } else {
                                                if (previous.tv_sec || previous.tv_usec) {
                                                        D(printf("outstanding adjustment %u sec %u usec",
                                                            (long)previous.tv_sec,
                                                            (long)previous.tv_usec));
                                                        log("outstanding adjustment %u sec %u usec",
                                                            (long)previous.tv_sec,
                                                            (long)previous.tv_usec);
                                                } else {
                                                        D(printf("adjusted %d usec",
                                                            adjust.tv_sec < 0 ?
                                                            (adjust.tv_usec - MILLION_L) :
                                                            adjust.tv_usec));
                                                        log("adjusted %d usec",
                                                            adjust.tv_sec < 0 ?
                                                            (adjust.tv_usec - MILLION_L) :
                                                            adjust.tv_usec);
                                                }
                                        }

                                } else {
                                        /* just doing it once - set it directly */

                                        settimeofday(&new, NULL);  /* in the kernel */
#if SET_FPGA_TIME
                                        set_rtc_fpga(&new);             /* in the FPGA */
#endif
#ifdef DEVICE_HAS_RTC_WE_DO_NOT
                                        set_rtc(&new);             /* in the RTC through /dev/rtc */
#endif
                                        log("set time: old=(%ld,%.6ld) new=(%ld,%.6ld) adjust=(%ld,%.6ld)",
                                            (long)old.tv_sec,(long)old.tv_usec,
                                            (long)new.tv_sec,(long)new.tv_usec,
                                            (long)adjust.tv_sec,(long)adjust.tv_usec);
                                }
                                success=1;

                                //log("Date: %s", ctime((const time_t *)&new.tv_sec));
                        
                }

                /* delay "refreshinterval" seconds, but check for config update each second during
                 * that wait
                 */

                if(as_daemon) {
                        refresh_counter = refreshinterval;

                        do {
                                sleep(1);
                                if (check_config) 
                                        break;
                        } while(refresh_counter-- > 0);

                        sleep(1);
                }

        } while(as_daemon);

        log("Exiting...");
        exit(success?0:1);
}

/* open /dev/rtc and use an ioctl to set the time in the RTC chip */
#ifdef DEVICE_HAS_RTC_WE_DO_NOT
void
set_rtc(struct timeval *tv)
{
        int fd;
        struct tm *mytm;
        unsigned int secs;

        /* Open the rtc driver */

        fd = open("/dev/rtc", O_RDONLY);

        if(fd < 0) {
                log("cant open /dev/rtc: %m", errno);
                return;
        }

        /* convert from seconds since 1970 to broken down time 
         * (that the RTC needs)
         * remember to round secs depending on usecs
         */

        secs = tv->tv_sec + ((tv->tv_usec > 500000) ? 1 : 0);
        
        mytm = localtime((time_t *)&secs);
        
        /* set the RTC time
         * struct rtc_time is the same as struct tm
         */

        if(ioctl(fd, RTC_SET_TIME, mytm) < 0) {
                log("RTC_SET_TIME failed: %m", errno);
        }
        
        close(fd);
}
#endif

#if SET_FPGA_TIME
#define X313_WA_RTC_USEC        0x44
#define X313_WA_RTC_SEC         0x45

void set_rtc_fpga(struct timeval *tv) {
        int fd;
        struct tm *mytm;
        unsigned int secs;
        unsigned long id, id_d;
        unsigned long tv_sec, tv_usec;

        if((fd = open("/dev/fpgaio", O_RDWR)) < 0)
                return;
        id_d = ioctl(fd, _IO(FPGACONF_READREG, 0x13), (void *)&id);
        if((id_d & 0x0FFFF000) == 0x03331000)
                if((id_d & 0x00000FFF) >= 0x0E) {
                        tv_sec = tv->tv_sec;
                        tv_usec = tv->tv_usec;
                        ioctl(fd, _IO(FPGACONF_WRITEREG, X313_WA_RTC_USEC), tv_usec);
                        ioctl(fd, _IO(FPGACONF_WRITEREG, X313_WA_RTC_SEC), tv_sec);
//                      ioctl(fd, _IO(FPGACONF_WRITEREG, X313_WA_RTC_USEC), (void *)&tv_usec);
//                      ioctl(fd, _IO(FPGACONF_WRITEREG, X313_WA_RTC_SEC), (void *)&tv_sec);
                }
        close(fd);
}
#endif

---