/*      $NetBSD: measure.c,v 1.17 2012/11/04 22:36:58 christos Exp $    */

/*-
 * Copyright (c) 1985, 1993 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
#ifndef lint
#if 0
static char sccsid[] = "@(#)measure.c   8.2 (Berkeley) 3/26/95";
#else
__RCSID("$NetBSD: measure.c,v 1.17 2012/11/04 22:36:58 christos Exp $");
#endif
#endif /* not lint */

#include "globals.h"
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include <util.h>
#ifdef SUPPORT_UTMPX
#include <utmpx.h>
#endif

#define MSEC_DAY        (SECDAY*1000)

#define PACKET_IN       1024

#define MSGS            5               /* timestamps to average */
#define TRIALS          10              /* max # of timestamps sent */

extern int sock_raw;

int measure_delta;

extern int in_cksum(const void *, int);

static n_short seqno = 0;

/*
 * Measures the differences between machines' clocks using
 * ICMP timestamp messages.
 */
int                                     /* status val defined in globals.h */
measure(u_long maxmsec,                 /* wait this many msec at most */
        u_long wmsec,                   /* msec to wait for an answer */
        const char *hname,
        const struct sockaddr_in *addr,
        int printerr)                   /* print complaints on stderr */
{
        socklen_t length;
        int measure_status;
        int rcvcount, trials;
        int count;
        struct pollfd set[1];
        long sendtime, recvtime, histime1, histime2;
        long idelta, odelta, total;
        long min_idelta, min_odelta;
        struct timeval tdone, tcur, ttrans, twait, tout;
        u_char packet[PACKET_IN];
        struct icmp icp;
        struct icmp oicp;
        struct ip ip;

        min_idelta = min_odelta = 0x7fffffff;
        measure_status = HOSTDOWN;
        measure_delta = HOSTDOWN;
        errno = 0;
        trials = 0;

        /* open raw socket used to measure time differences */
        if (sock_raw < 0) {
                sock_raw = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
                if (sock_raw < 0)  {
                        syslog(LOG_ERR, "opening raw socket: %m");
                        goto quit;
                }
        }
            
        set[0].fd = sock_raw;
        set[0].events = POLLIN;

        /*
         * empty the icmp input queue
         */
        for (;;) {
                if (poll(set, 1, 0)) {
                        ssize_t ret;
                        length = sizeof(struct sockaddr_in);
                        ret = recvfrom(sock_raw, (char *)packet, PACKET_IN, 0,
                                      0,&length);
                        if (ret < 0)
                                goto quit;
                        continue;
                }
                break;
        }

        /*
         * Choose the smallest transmission time in each of the two
         * directions. Use these two latter quantities to compute the delta
         * between the two clocks.
         */

        oicp.icmp_type = ICMP_TSTAMP;
        oicp.icmp_code = 0;
        oicp.icmp_id = getpid();
        oicp.icmp_rtime = 0;
        oicp.icmp_ttime = 0;
        oicp.icmp_seq = seqno;

        (void)gettimeofday(&tdone, 0);
        mstotvround(&tout, maxmsec);
        timeradd(&tdone, &tout, &tdone);        /* when we give up */

        mstotvround(&twait, wmsec);

        tout.tv_sec = 0;
        tout.tv_usec = 0;
        rcvcount = 0;
        while (rcvcount < MSGS) {
                (void)gettimeofday(&tcur, 0);

                /*
                 * keep sending until we have sent the max
                 */
                if (trials < TRIALS) {
                        uint32_t otime;

                        trials++;
                        otime = (tcur.tv_sec % SECDAY) * 1000  
                                            + tcur.tv_usec / 1000;
                        oicp.icmp_otime = htonl(otime);
                        oicp.icmp_cksum = 0;
                        oicp.icmp_cksum = in_cksum(&oicp, sizeof(oicp));

                        count = sendto(sock_raw, &oicp, sizeof(oicp), 0,
                                       (const struct sockaddr*)addr,
                                       sizeof(struct sockaddr));
                        if (count < 0) {
                                if (measure_status == HOSTDOWN)
                                        measure_status = UNREACHABLE;
                                goto quit;
                        }
                        oicp.icmp_seq++;

                        timeradd(&tcur, &twait, &ttrans);
                } else {
                        ttrans = tdone;
                }

                while (rcvcount < trials) {
                        ssize_t ret;

                        timersub(&ttrans, &tcur, &tout);
                        if (tout.tv_sec < 0)
                                tout.tv_sec = 0;

                        count = poll(set, 1, tout.tv_sec * 1000 + tout.tv_usec / 1000);
                        (void)gettimeofday(&tcur, (struct timezone *)0);
                        if (count <= 0)
                                break;

                        length = sizeof(struct sockaddr_in);
                        ret = recvfrom(sock_raw, (char *)packet, PACKET_IN, 0,
                                      0,&length);
                        if (ret < 0)
                                goto quit;

                        /* 
                         * got something.  See if it is ours
                         */

                        if ((size_t)ret < sizeof(ip))
                                continue;
                        memcpy(&ip, packet, sizeof(ip));
                        if ((size_t)ret < (size_t)ip.ip_hl << 2)
                                continue;
                        ret -= ip.ip_hl << 2;

                        memset(&icp, 0, sizeof(icp));
                        memcpy(&icp, &packet[ip.ip_hl << 2],
                                MIN((size_t)ret, sizeof(icp)));

                        if (icp.icmp_type != ICMP_TSTAMPREPLY
                            || icp.icmp_id != oicp.icmp_id
                            || icp.icmp_seq < seqno
                            || icp.icmp_seq >= oicp.icmp_seq)
                                continue;

                        sendtime = ntohl(icp.icmp_otime);
                        recvtime = ((tcur.tv_sec % SECDAY) * 1000 +
                                    tcur.tv_usec / 1000);

                        total = recvtime - sendtime;
                        if (total < 0)  /* do not hassle midnight */
                                continue;

                        rcvcount++;
                        histime1 = ntohl(icp.icmp_rtime);
                        histime2 = ntohl(icp.icmp_ttime);
                        /*
                         * a host using a time format different from
                         * msec. since midnight UT (as per RFC792) should
                         * set the high order bit of the 32-bit time
                         * value it transmits.
                         */
                        if ((histime1 & 0x80000000) != 0) {
                                measure_status = NONSTDTIME;
                                goto quit;
                        }
                        measure_status = GOOD;

                        idelta = recvtime-histime2;
                        odelta = histime1-sendtime;

                        /* do not be confused by midnight */
                        if (idelta < -MSEC_DAY/2) idelta += MSEC_DAY;
                        else if (idelta > MSEC_DAY/2) idelta -= MSEC_DAY;

                        if (odelta < -MSEC_DAY/2) odelta += MSEC_DAY;
                        else if (odelta > MSEC_DAY/2) odelta -= MSEC_DAY;

                        /* save the quantization error so that we can get a
                         * measurement finer than our system clock.
                         */
                        if (total < MIN_ROUND) {
                                measure_delta = (odelta - idelta)/2;
                                goto quit;
                        }

                        if (idelta < min_idelta)
                                min_idelta = idelta;
                        if (odelta < min_odelta)
                                min_odelta = odelta;

                        measure_delta = (min_odelta - min_idelta)/2;
                }

                if (tcur.tv_sec > tdone.tv_sec
                    || (tcur.tv_sec == tdone.tv_sec
                        && tcur.tv_usec >= tdone.tv_usec))
                        break;
        }

quit:
        seqno += TRIALS;                /* allocate our sequence numbers */

        /*
         * If no answer is received for TRIALS consecutive times,
         * the machine is assumed to be down
         */
        if (measure_status == GOOD) {
                if (trace) {
                        fprintf(fd,
                                "measured delta %4d, %d trials to %-15s %s\n",
                                measure_delta, trials,
                                inet_ntoa(addr->sin_addr), hname);
                }
        } else if (printerr) {
                if (errno != 0)
                        fprintf(stderr, "measure %s: %s\n", hname,
                                strerror(errno));
        } else {
                if (errno != 0) {
                        syslog(LOG_ERR, "measure %s: %m", hname);
                } else {
                        syslog(LOG_ERR, "measure: %s did not respond", hname);
                }
                if (trace) {
                        fprintf(fd,
                                "measure: %s failed after %d trials\n",
                                hname, trials);
                        (void)fflush(fd);
                }
        }

        return(measure_status);
}





/*
 * round a number of milliseconds into a struct timeval
 */
void
mstotvround(struct timeval *res, long x)
{
        if (x < 0)
                x = -((-x + 3)/5);
        else
                x = (x+3)/5;
        x *= 5;

        res->tv_sec = x/1000;
        res->tv_usec = (x-res->tv_sec*1000)*1000;
        if (res->tv_usec < 0) {
                res->tv_usec += 1000000;
                res->tv_sec--;
        }
}

void
update_time(struct timeval *tv, const struct tsp *msg)
{
#ifdef SUPPORT_UTMP
        logwtmp("|", "date", "");
#endif
#ifdef SUPPORT_UTMPX
        logwtmpx("|", "date", "", 0, OLD_TIME);
#endif
        tv->tv_sec = msg->tsp_time.tv_sec;
        tv->tv_usec = msg->tsp_time.tv_usec;
        (void)settimeofday(tv, 0);
#ifdef SUPPORT_UTMP
        logwtmp("}", "date", "");
#endif
#ifdef SUPPORT_UTMPX
        logwtmpx("}", "date", "", 0, NEW_TIME);
#endif
}