/*

 * refclock_nmea.c - clock driver for an NMEA GPS CLOCK

 *    Michael Petry Jun 20, 1994

 *     based on refclock_heathn.c

 *

 * Updated to add support for Accord GPS Clock

 *    Venu Gopal Dec 05, 2007

 *    neo.venu@gmail.com, venugopal_d@pgad.gov.in

 *

 * Updated to process 'time1' fudge factor

 *    Venu Gopal May 05, 2008

 *

 * Converted to common PPSAPI code, separate PPS fudge time1

 * from serial timecode fudge time2.

 *    Dave Hart July 1, 2009

 *    hart@ntp.org, davehart@davehart.com

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include "ntp_types.h"

#if defined(REFCLOCK) && defined(CLOCK_NMEA)

#define NMEA_WRITE_SUPPORT 0 /* no write support at the moment */

#include <sys/stat.h>

#include <stdio.h>

#include <ctype.h>

#ifdef HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#include "ntpd.h"

#include "ntp_io.h"

#include "ntp_unixtime.h"

#include "ntp_refclock.h"

#include "ntp_stdlib.h"

#include "ntp_calgps.h"

#include "timespecops.h"

#ifdef HAVE_PPSAPI

# include "ppsapi_timepps.h"

# include "refclock_atom.h"

#endif /* HAVE_PPSAPI */

/*

 * This driver supports NMEA-compatible GPS receivers

 *

 * Prototype was refclock_trak.c, Thanks a lot.

 *

 * The receiver used spits out the NMEA sentences for boat navigation.

 * And you thought it was an information superhighway.  Try a raging river

 * filled with rapids and whirlpools that rip away your data and warp time.

 *

 * If HAVE_PPSAPI is defined code to use the PPSAPI will be compiled in.

 * On startup if initialization of the PPSAPI fails, it will fall back

 * to the "normal" timestamps.

 *

 * The PPSAPI part of the driver understands fudge flag2 and flag3. If

 * flag2 is set, it will use the clear edge of the pulse. If flag3 is

 * set, kernel hardpps is enabled.

 *

 * GPS sentences other than RMC (the default) may be enabled by setting

 * the relevent bits of 'mode' in the server configuration line

 * server 127.127.20.x mode X

 *

 * bit 0 - enables RMC (1)

 * bit 1 - enables GGA (2)

 * bit 2 - enables GLL (4)

 * bit 3 - enables ZDA (8) - Standard Time & Date

 * bit 3 - enables ZDG (8) - Accord GPS Clock's custom sentence with GPS time

 *           very close to standard ZDA

 *

 * Multiple sentences may be selected except when ZDG/ZDA is selected.

 *

 * bit 4/5/6 - selects the baudrate for serial port :

 *    0 for 4800 (default)

 *    1 for 9600

 *    2 for 19200

 *    3 for 38400

 *    4 for 57600

 *    5 for 115200

 */

#define NMEA_MESSAGE_MASK 0x0000FF0FU

#define NMEA_BAUDRATE_MASK  0x00000070U

#define NMEA_BAUDRATE_SHIFT 4

#define NMEA_DELAYMEAS_MASK 0x00000080U

#define NMEA_EXTLOG_MASK  0x00010000U

#define NMEA_QUIETPPS_MASK  0x00020000U

#define NMEA_DATETRUST_MASK 0x00040000U

#define NMEA_IGNSTATUS_MASK 0x00080000U

#define NMEA_PROTO_IDLEN  4  /* tag name must be at least 4 chars */

#define NMEA_PROTO_MINLEN 6 /* min chars in sentence, excluding CS */

#define NMEA_PROTO_MAXLEN 80  /* max chars in sentence, excluding CS */

#define NMEA_PROTO_FIELDS 32  /* not official; limit on fields per record */

/*

 * We check the timecode format and decode its contents.  We only care

 * about a few of them, the most important being the $GPRMC format:

 *

 * $GPRMC,hhmmss,a,fddmm.xx,n,dddmmm.xx,w,zz.z,yyy.,ddmmyy,dd,v*CC

 *

 * mode (0,1,2,3) selects sentence ANY/ALL, RMC, GGA, GLL, ZDA

 * $GPGLL,3513.8385,S,14900.7851,E,232420.594,A*21

 * $GPGGA,232420.59,3513.8385,S,14900.7851,E,1,05,3.4,00519,M,,,,*3F

 * $GPRMC,232418.19,A,3513.8386,S,14900.7853,E,00.0,000.0,121199,12.,E*77

 *

 * Defining GPZDA to support Standard Time & Date

 * sentence. The sentence has the following format

 *

 *  $--ZDA,HHMMSS.SS,DD,MM,YYYY,TH,TM,*CS<CR><LF>

 *

 *  Apart from the familiar fields,

 *  'TH'    Time zone Hours

 *  'TM'    Time zone Minutes

 *

 * Defining GPZDG to support Accord GPS Clock's custom NMEA

 * sentence. The sentence has the following format

 *

 *  $GPZDG,HHMMSS.S,DD,MM,YYYY,AA.BB,V*CS<CR><LF>

 *

 *  It contains the GPS timestamp valid for next PPS pulse.

 *  Apart from the familiar fields,

 *  'AA.BB' denotes the signal strength( should be < 05.00 )

 *  'V'     denotes the GPS sync status :

 *     '0' indicates INVALID time,

 *     '1' indicates accuracy of +/-20 ms

 *     '2' indicates accuracy of +/-100 ns

 *

 * Defining PGRMF for Garmin GPS Fix Data

 * $PGRMF,WN,WS,DATE,TIME,LS,LAT,LAT_DIR,LON,LON_DIR,MODE,FIX,SPD,DIR,PDOP,TDOP

 * WN  -- GPS week number (weeks since 1980-01-06, mod 1024)

 * WS  -- GPS seconds in week

 * LS  -- GPS leap seconds, accumulated ( UTC + LS == GPS )

 * FIX -- Fix type: 0=nofix, 1=2D, 2=3D

 * DATE/TIME are standard date/time strings in UTC time scale

 *

 * The GPS time can be used to get the full century for the truncated

 * date spec.

 */

/*

 * Definitions

 */

#define DEVICE    "/dev/gps%d"  /* GPS serial device */

#define PPSDEV    "/dev/gpspps%d" /* PPSAPI device override */

#define SPEED232  B4800  /* uart speed (4800 bps) */

#define PRECISION (-9)  /* precision assumed (about 2 ms) */

#define PPS_PRECISION (-20) /* precision assumed (about 1 us) */

#define DATE_HOLD 16  /* seconds to hold on provided GPS date */

#define DATE_HLIM 4  /* when do we take ANY date format */

#define REFID   "GPS\0"  /* reference id */

#define DESCRIPTION "NMEA GPS Clock" /* who we are */

#ifndef O_NOCTTY

#define M_NOCTTY  0

#else

#define M_NOCTTY  O_NOCTTY

#endif

#ifndef O_NONBLOCK

#define M_NONBLOCK  0

#else

#define M_NONBLOCK  O_NONBLOCK

#endif

#define PPSOPENMODE (O_RDWR | M_NOCTTY | M_NONBLOCK)

/* NMEA sentence array indexes for those we use */

#define NMEA_GPRMC  0  /* recommended min. nav. */

#define NMEA_GPGGA  1  /* fix and quality */

#define NMEA_GPGLL  2  /* geo. lat/long */

#define NMEA_GPZDA  3  /* date/time */

/*

 * $GPZDG is a proprietary sentence that violates the spec, by not

 * using $P and an assigned company identifier to prefix the sentence

 * identifier.  When used with this driver, the system needs to be

 * isolated from other NTP networks, as it operates in GPS time, not

 * UTC as is much more common.  GPS time is >15 seconds different from

 * UTC due to not respecting leap seconds since 1970 or so.  Other

 * than the different timebase, $GPZDG is similar to $GPZDA.

 */

#define NMEA_GPZDG  4

#define NMEA_PGRMF  5

#define NMEA_PUBX04 6

#define NMEA_ARRAY_SIZE (NMEA_PUBX04 + 1)

/*

 * Sentence selection mode bits

 */

#define USE_GPRMC   0x00000001u

#define USE_GPGGA   0x00000002u

#define USE_GPGLL   0x00000004u

#define USE_GPZDA   0x00000008u

#define USE_PGRMF   0x00000100u

#define USE_PUBX04    0x00000200u

/* mapping from sentence index to controlling mode bit */

static const u_int32 sentence_mode[NMEA_ARRAY_SIZE] =

{

  USE_GPRMC,

  USE_GPGGA,

  USE_GPGLL,

  USE_GPZDA,

  USE_GPZDA,

  USE_PGRMF,

  USE_PUBX04

};

/* date formats we support */

enum date_fmt {

  DATE_1_DDMMYY,  /* use 1 field  with 2-digit year */

  DATE_3_DDMMYYYY /* use 3 fields with 4-digit year */

};

/* date type */

enum date_type {

  DTYP_NONE,

  DTYP_Y2D, /* 2-digit year */

  DTYP_W10B,  /* 10-bit week in GPS epoch */

  DTYP_Y4D, /* 4-digit (full) year */

  DTYP_WEXT /* extended week in GPS epoch */

};

/* results for 'field_init()'

 *

 * Note: If a checksum is present, the checksum test must pass OK or the

 * sentence is tagged invalid.

 */

#define CHECK_EMPTY  -1  /* no data      */

#define CHECK_INVALID 0  /* not a valid NMEA sentence  */

#define CHECK_VALID   1  /* valid but without checksum */

#define CHECK_CSVALID 2  /* valid with checksum OK */

/*

 * Unit control structure

 */

struct refclock_atom;

typedef struct refclock_atom TAtomUnit;

typedef struct {

#   ifdef HAVE_PPSAPI

  TAtomUnit atom;   /* PPSAPI structure */

  int   ppsapi_fd;  /* fd used with PPSAPI */

  u_char    ppsapi_tried; /* attempt PPSAPI once */

  u_char    ppsapi_lit; /* time_pps_create() worked */

#   endif /* HAVE_PPSAPI */

  uint16_t  rcvtout;  /* one-shot for sample expiration */

  u_char    ppsapi_gate;  /* system is on PPS */

  u_char    gps_time; /* use GPS time, not UTC */

  l_fp    last_reftime; /* last processed reference stamp */

  TNtpDatum last_gpsdate; /* last processed split date/time */

  u_short   hold_gpsdate; /* validity ticker for above */

  u_short   type_gpsdate; /* date info type for above */

  /* tally stats, reset each poll cycle */

  struct

  {

    u_int total;

    u_int accepted;

    u_int rejected;   /* GPS said not enough signal */

    u_int malformed;  /* Bad checksum, invalid date or time */

    u_int filtered;   /* mode bits, not GPZDG, same second */

    u_int pps_used;

  }

    tally;

  /* per sentence checksum seen flag */

  u_char    cksum_type[NMEA_ARRAY_SIZE];

  /* line assembly buffer (NMEAD support) */

  u_short lb_len;

  char  lb_buf[BMAX]; /* assembly buffer */

} nmea_unit;

/*

 * helper for faster field access

 */

typedef struct {

  char  *base;  /* buffer base    */

  char  *cptr;  /* current field ptr  */

  int    blen;  /* buffer length  */

  int    cidx;  /* current field index  */

} nmea_data;

/*

 * Function prototypes

 */

static  int nmea_start  (int, struct peer *);

static  void  nmea_shutdown (int, struct peer *);

static  void  nmea_receive  (struct recvbuf *);

static  void  nmea_poll (int, struct peer *);

static  void  nmea_procrec  (struct peer * const, l_fp);

#ifdef HAVE_PPSAPI

static  double  tabsdiffd (l_fp, l_fp);

static  void  nmea_control  (int, const struct refclockstat *,

         struct refclockstat *, struct peer *);

#define   NMEA_CONTROL  nmea_control

#else

#define   NMEA_CONTROL  noentry

#endif /* HAVE_PPSAPI */

static  void  nmea_timer  (int, struct peer *);

/* parsing helpers */

static int  field_init  (nmea_data * data, char * cp, int len);

static char * field_parse (nmea_data * data, int fn);

static void field_wipe  (nmea_data * data, ...);

static u_char parse_qual  (nmea_data * data, int idx,

         char tag, int inv);

static int  parse_time  (TCivilDate * jd, l_fp * fofs,

         nmea_data *, int idx);

static int  parse_date  (TCivilDate * jd, nmea_data *,

         int idx, enum date_fmt fmt);

static int  parse_gpsw  (TGpsDatum *, nmea_data *,

         int weekidx, int timeidx, int leapidx);

static int  nmead_open  (const char * device);

/*

 * If we want the driver to output sentences, too: re-enable the send

 * support functions by defining NMEA_WRITE_SUPPORT to non-zero...

 */

#if NMEA_WRITE_SUPPORT

static  void gps_send(int, const char *, struct peer *);

#endif /* NMEA_WRITE_SUPPORT */

/*

 * -------------------------------------------------------------------

 * Transfer vector

 * -------------------------------------------------------------------

 */

struct refclock refclock_nmea = {

  nmea_start,   /* start up driver */

  nmea_shutdown,    /* shut down driver */

  nmea_poll,    /* transmit poll message */

  NMEA_CONTROL,   /* fudge control */

  noentry,    /* initialize driver */

  noentry,    /* buginfo */

  nmea_timer    /* called once per second */

};

/*

 * -------------------------------------------------------------------

 * nmea_start - open the GPS devices and initialize data for processing

 *

 * return 0 on error, 1 on success. Even on error the peer structures

 * must be in a state that permits 'nmea_shutdown()' to clean up all

 * resources, because it will be called immediately to do so.

 * -------------------------------------------------------------------

 */

static int

nmea_start(

  int   unit,

  struct peer * peer

  )

{

  struct refclockproc * const pp = peer->procptr;

  nmea_unit * const   up = emalloc_zero(sizeof(*up));

  char        device[20];

  size_t        devlen;

  u_int32       rate;

  int       baudrate;

  /* Get baudrate choice from mode byte bits 4/5/6 */

  rate = (peer->ttl & NMEA_BAUDRATE_MASK) >> NMEA_BAUDRATE_SHIFT;

  switch (rate) {

  default:

  case 0:

    baudrate = SPEED232;

    break;

  case 1:

    baudrate = B9600;

    break;

  case 2:

    baudrate = B19200;

    break;

  case 3:

    baudrate = B38400;

    break;

#   ifdef B57600

  case 4:

    baudrate = B57600;

    break;

#   endif

#   ifdef B115200

  case 5:

    baudrate = B115200;

    break;

#   endif

  }

  /* Allocate and initialize unit structure */

  pp->unitptr = (caddr_t)up;

  pp->io.fd = -1;

  pp->io.clock_recv = nmea_receive;

  pp->io.srcclock = peer;

  pp->io.datalen = 0;

  /* force change detection on first valid message */

  memset(&up->last_reftime, 0xFF, sizeof(up->last_reftime));

  memset(&up->last_gpsdate, 0x00, sizeof(up->last_gpsdate));

  /* force checksum on GPRMC, see below */

  up->cksum_type[NMEA_GPRMC] = CHECK_CSVALID;

#   ifdef HAVE_PPSAPI

  up->ppsapi_fd = -1;

#   endif /* HAVE_PPSAPI */

  ZERO(up->tally);

  /* Initialize miscellaneous variables */

  peer->precision = PRECISION;

  pp->clockdesc = DESCRIPTION;

  memcpy(&pp->refid, REFID, 4);

  /* Open serial port. Use CLK line discipline, if available. */

  devlen = snprintf(device, sizeof(device), DEVICE, unit);

  if (devlen >= sizeof(device)) {

    msyslog(LOG_ERR, "%s clock device name too long",

      refnumtoa(&peer->srcadr));

    return FALSE; /* buffer overflow */

  }

  pp->io.fd = refclock_open(&peer->srcadr, device, baudrate, LDISC_CLK);

  if (0 >= pp->io.fd) {

    pp->io.fd = nmead_open(device);

    if (-1 == pp->io.fd)

      return FALSE;

  }

  /* succeed if this clock can be added */

  return io_addclock(&pp->io) != 0;

}

/*

 * -------------------------------------------------------------------

 * nmea_shutdown - shut down a GPS clock

 *

 * NOTE this routine is called after nmea_start() returns failure,

 * as well as during a normal shutdown due to ntpq :config unpeer.

 * -------------------------------------------------------------------

 */

static void

nmea_shutdown(

  int           unit,

  struct peer * peer

  )

{

  struct refclockproc * const pp = peer->procptr;

  nmea_unit     * const up = (nmea_unit *)pp->unitptr;

  UNUSED_ARG(unit);

  if (up != NULL) {

#     ifdef HAVE_PPSAPI

    if (up->ppsapi_lit)

      time_pps_destroy(up->atom.handle);

    ppsdev_close(pp->io.fd, up->ppsapi_fd);

#     endif

    free(up);

  }

  pp->unitptr = (caddr_t)NULL;

  if (-1 != pp->io.fd)

    io_closeclock(&pp->io);

  pp->io.fd = -1;

}

/*

 * -------------------------------------------------------------------

 * nmea_control - configure fudge params

 * -------------------------------------------------------------------

 */

#ifdef HAVE_PPSAPI

static void

nmea_control(

  int                         unit,

  const struct refclockstat * in_st,

  struct refclockstat       * out_st,

  struct peer               * peer

  )

{

  struct refclockproc * const pp = peer->procptr;

  nmea_unit     * const up = (nmea_unit *)pp->unitptr;

  char   device[32];

  size_t devlen;

  UNUSED_ARG(in_st);

  UNUSED_ARG(out_st);

  /*

   * PPS control

   *

   * If /dev/gpspps$UNIT can be opened that will be used for

   * PPSAPI.  On Linux, a PPS device mathing the TTY will be

   * searched for and possibly created on the fly.  Otherwise, the

   * GPS serial device /dev/gps$UNIT already opened is used for

   * PPSAPI as well. (This might not work, in which case the PPS

   * API remains unavailable...)

   */

  /* Light up the PPSAPI interface if not yet attempted. */

  if ((CLK_FLAG1 & pp->sloppyclockflag) && !up->ppsapi_tried) {

    const char *ppsname = device;

    up->ppsapi_tried = TRUE;

    /* get FD for the pps device; might be the tty itself! */

    devlen = snprintf(device, sizeof(device), PPSDEV, unit);

    if (devlen >= sizeof(device)) {

      msyslog(LOG_ERR, "%s PPS device name too long",

        refnumtoa(&peer->srcadr));

      ppsname = NULL;

    }

    up->ppsapi_fd = ppsdev_reopen(

      &peer->srcadr,

      pp->io.fd, up->ppsapi_fd,

      ppsname, PPSOPENMODE, (S_IRUSR|S_IWUSR));

    /* note 1: the pps fd might be the same as the tty fd

     * note 2: the current PPS fd remains valid until

     *  - the clock is shut down

     *  - flag1 is set again after being cleared

     */

    if (refclock_ppsapi(up->ppsapi_fd, &up->atom)) {

      /* use the PPS API for our own purposes now. */

      up->ppsapi_lit = refclock_params(

        pp->sloppyclockflag, &up->atom);

      if (!up->ppsapi_lit) {

        /* failed to configure, drop PPS unit */

        time_pps_destroy(up->atom.handle);

        msyslog(LOG_WARNING,

          "%s set PPSAPI params fails",

          refnumtoa(&peer->srcadr));

      }

    } else {

      msyslog(LOG_WARNING,

        "%s flag1 1 but PPSAPI fails",

        refnumtoa(&peer->srcadr));

    }

  }

  /* shut down PPS API if activated */

  if ( !(CLK_FLAG1 & pp->sloppyclockflag) && up->ppsapi_tried) {

    /* shutdown PPS API */

    if (up->ppsapi_lit)

      time_pps_destroy(up->atom.handle);

    up->atom.handle = 0;

    /* do !!NOT!! close/drop PPS fd here! */

    /* clear markers and peer items */

    up->ppsapi_gate  = FALSE;

    up->ppsapi_lit   = FALSE;

    up->ppsapi_tried = FALSE;

    peer->flags &= ~FLAG_PPS;

    peer->precision = PRECISION;

  }

}

#endif /* HAVE_PPSAPI */

/*

 * -------------------------------------------------------------------

 * nmea_timer - called once per second

 *

 * Usually 'nmea_receive()' can get a timestamp every second, but at

 * least one Motorola unit needs prompting each time. Doing so in

 * 'nmea_poll()' gives only one sample per poll cycle, which actually

 * defeats the purpose of the median filter. Polling once per second

 * seems a much better idea.

 *

 * Also takes care of sample expiration if the receiver fails to

 * provide new input data.

 * -------------------------------------------------------------------

 */

static void

nmea_timer(

  int       unit,

  struct peer * peer

  )

{

  struct refclockproc * const pp = peer->procptr;

  nmea_unit     * const up = (nmea_unit *)pp->unitptr;

  UNUSED_ARG(unit);

#   if NMEA_WRITE_SUPPORT

  if (-1 != pp->io.fd) /* any mode bits to evaluate here? */

    gps_send(pp->io.fd, "$PMOTG,RMC,0000*1D\r\n", peer);

#   endif /* NMEA_WRITE_SUPPORT */

  /* receive timeout occurred? */

  if (up->rcvtout) {

    --up->rcvtout;

  } else if (pp->codeproc != pp->coderecv) {

    /* expire one (the oldest) sample, if any */

    refclock_samples_expire(pp, 1);

    /* reset message assembly buffer */

    up->lb_buf[0] = '\0';

    up->lb_len    = 0;

  }

  if (up->hold_gpsdate && (--up->hold_gpsdate < DATE_HLIM))

    up->type_gpsdate = DTYP_NONE;

}

/*

 * -------------------------------------------------------------------

 * nmea_procrec - receive data from the serial interface

 *

 * This is the workhorse for NMEA data evaluation:

 *

 * + it checks all NMEA data, and rejects sentences that are not valid

 *   NMEA sentences

 * + it checks whether a sentence is known and to be used

 * + it parses the time and date data from the NMEA data string and

 *   augments the missing bits. (century in date, whole date, ...)

 * + it rejects data that is not from the first accepted sentence in a

 *   burst

 * + it eventually replaces the receive time with the PPS edge time.

 * + it feeds the data to the internal processing stages.

 *

 * This function assumes a non-empty line in the unit line buffer.

 * -------------------------------------------------------------------

 */

static void

nmea_procrec(

  struct peer * const peer,

  l_fp        rd_timestamp

  )

{

  /* declare & init control structure pointers */

  struct refclockproc * const pp = peer->procptr;

  nmea_unit     * const up = (nmea_unit*)pp->unitptr;

  /* Use these variables to hold data until we decide its worth keeping */

  nmea_data rdata;

  l_fp    rd_reftime;

  /* working stuff */

  TCivilDate  date; /* to keep & convert the time stamp */

  TGpsDatum wgps; /* week time storage */

  TNtpDatum dntp;

  l_fp    tofs; /* offset to full-second reftime */

  /* results of sentence/date/time parsing */

  u_char    sentence; /* sentence tag */

  int   checkres;

  int   warp;   /* warp to GPS base date */

  char *    cp;

  int   rc_date, rc_time;

  u_short   rc_dtyp;

#   ifdef HAVE_PPSAPI

  int   withpps = 0;

#   endif /* HAVE_PPSAPI */

  /* make sure data has defined pristine state */

  ZERO(tofs);

  ZERO(date);

  ZERO(wgps);

  ZERO(dntp);

  /*

   * Read the timecode and timestamp, then initialize field

   * processing. The <CR><LF> at the NMEA line end is translated

   * to <LF><LF> by the terminal input routines on most systems,

   * and this gives us one spurious empty read per record which we

   * better ignore silently.

   */

  checkres = field_init(&rdata, up->lb_buf, up->lb_len);

  switch (checkres) {

  case CHECK_INVALID:

    DPRINTF(1, ("%s invalid data: '%s'\n",

      refnumtoa(&peer->srcadr), up->lb_buf));

    refclock_report(peer, CEVNT_BADREPLY);

    return;

  case CHECK_EMPTY:

    return;

  default:

    DPRINTF(1, ("%s gpsread: %d '%s'\n",

      refnumtoa(&peer->srcadr), up->lb_len,

      up->lb_buf));

    break;

  }

  up->tally.total++;

  /*

   * --> below this point we have a valid NMEA sentence <--

   *

   * Check sentence name. Skip first 2 chars (talker ID) in most

   * cases, to allow for $GLGGA and $GPGGA etc. Since the name

   * field has at least 5 chars we can simply shift the field

   * start.

   */

  cp = field_parse(&rdata, 0);

  if      (strncmp(cp + 2, "RMC,", 4) == 0)

    sentence = NMEA_GPRMC;

  else if (strncmp(cp + 2, "GGA,", 4) == 0)

    sentence = NMEA_GPGGA;

  else if (strncmp(cp + 2, "GLL,", 4) == 0)

    sentence = NMEA_GPGLL;

  else if (strncmp(cp + 2, "ZDA,", 4) == 0)

    sentence = NMEA_GPZDA;

  else if (strncmp(cp + 2, "ZDG,", 4) == 0)

    sentence = NMEA_GPZDG;

  else if (strncmp(cp,   "PGRMF,", 6) == 0)

    sentence = NMEA_PGRMF;

  else if (strncmp(cp,   "PUBX,04,", 8) == 0)

    sentence = NMEA_PUBX04;

  else

    return; /* not something we know about */

  /* Eventually output delay measurement now. */

  if (peer->ttl & NMEA_DELAYMEAS_MASK) {

    mprintf_clock_stats(&peer->srcadr, "delay %0.6f %.*s",

       ldexp(rd_timestamp.l_uf, -32),

       (int)(strchr(up->lb_buf, ',') - up->lb_buf),

       up->lb_buf);

  }

  /* See if I want to process this message type */

  if ((peer->ttl & NMEA_MESSAGE_MASK) &&

      !(peer->ttl & sentence_mode[sentence])) {

    up->tally.filtered++;

    return;

  }

  /*

   * make sure it came in clean

   *

   * Apparently, older NMEA specifications (which are expensive)

   * did not require the checksum for all sentences.  $GPMRC is

   * the only one so far identified which has always been required

   * to include a checksum.

   *

   * Today, most NMEA GPS receivers checksum every sentence.  To

   * preserve its error-detection capabilities with modern GPSes

   * while allowing operation without checksums on all but $GPMRC,

   * we keep track of whether we've ever seen a valid checksum on

   * a given sentence, and if so, reject future instances without

   * checksum.  ('up->cksum_type[NMEA_GPRMC]' is set in

   * 'nmea_start()' to enforce checksums for $GPRMC right from the

   * start.)

   */

  if (up->cksum_type[sentence] <= (u_char)checkres) {

    up->cksum_type[sentence] = (u_char)checkres;

  } else {

    DPRINTF(1, ("%s checksum missing: '%s'\n",

      refnumtoa(&peer->srcadr), up->lb_buf));

    refclock_report(peer, CEVNT_BADREPLY);

    up->tally.malformed++;

    return;

  }

  /*

   * $GPZDG provides GPS time not UTC, and the two mix poorly.

   * Once have processed a $GPZDG, do not process any further UTC

   * sentences (all but $GPZDG currently).

   */

  if (sentence == NMEA_GPZDG) {

    if (!up->gps_time) {

      msyslog(LOG_INFO,

        "%s using GPS time as if it were UTC",

        refnumtoa(&peer->srcadr));

      up->gps_time = 1;

    }

  } else {

    if (up->gps_time) {

      up->tally.filtered++;

      return;

    }

  }

  DPRINTF(1, ("%s processing %d bytes, timecode '%s'\n",

    refnumtoa(&peer->srcadr), up->lb_len, up->lb_buf));

  /*

   * Grab fields depending on clock string type and possibly wipe

   * sensitive data from the last timecode.

   */

  rc_date = -1; /* assume we have to do day-time mapping */

  rc_dtyp = DTYP_NONE;

        switch (sentence) {

  case NMEA_GPRMC:

    /* Check quality byte, fetch data & time */

    rc_time  = parse_time(&date, &tofs, &rdata, 1);

    pp->leap = parse_qual(&rdata, 2, 'A', 0);

    if (up->type_gpsdate <= DTYP_Y2D) {

      rc_date = parse_date(&date, &rdata, 9, DATE_1_DDMMYY);

      rc_dtyp = DTYP_Y2D;

    }

    if (CLK_FLAG4 & pp->sloppyclockflag)

      field_wipe(&rdata, 3, 4, 5, 6, -1);

    break;

  case NMEA_GPGGA:

    /* Check quality byte, fetch time only */

    rc_time  = parse_time(&date, &tofs, &rdata, 1);

    pp->leap = parse_qual(&rdata, 6, '0', 1);

    if (CLK_FLAG4 & pp->sloppyclockflag)

      field_wipe(&rdata, 2, 4, -1);

    break;

  case NMEA_GPGLL:

    /* Check quality byte, fetch time only */

    rc_time  = parse_time(&date, &tofs, &rdata, 5);

    pp->leap = parse_qual(&rdata, 6, 'A', 0);

    if (CLK_FLAG4 & pp->sloppyclockflag)

      field_wipe(&rdata, 1, 3, -1);

    break;

  case NMEA_GPZDA:

    /* No quality.  Assume best, fetch time & full date */

    rc_time = parse_time(&date, &tofs, &rdata, 1);

    if (up->type_gpsdate <= DTYP_Y4D) {

      rc_date = parse_date(&date, &rdata, 2, DATE_3_DDMMYYYY);

      rc_dtyp = DTYP_Y4D;

    }

    break;

  case NMEA_GPZDG:

    /* Check quality byte, fetch time & full date */

    rc_time  = parse_time(&date, &tofs, &rdata, 1);

    pp->leap = parse_qual(&rdata, 4, '0', 1);

    --tofs.l_ui; /* GPZDG gives *following* second */

    if (up->type_gpsdate <= DTYP_Y4D) {

      rc_date = parse_date(&date, &rdata, 2, DATE_3_DDMMYYYY);

      rc_dtyp = DTYP_Y4D;

    }

    break;

  case NMEA_PGRMF:

    /* get time, qualifier and GPS weektime. */

    rc_time = parse_time(&date, &tofs, &rdata, 4);

    if (up->type_gpsdate <= DTYP_W10B) {

      rc_date = parse_gpsw(&wgps, &rdata, 1, 2, 5);

      rc_dtyp = DTYP_W10B;

    }

    pp->leap = parse_qual(&rdata, 11, '0', 1);

    if (CLK_FLAG4 & pp->sloppyclockflag)

      field_wipe(&rdata, 6, 8, -1);

    break;

  case NMEA_PUBX04:

    /* PUBX,04 is peculiar. The UTC time-of-week is the *internal*

     * time base, which is not exactly on par with the fix time.

     */

    rc_time = parse_time(&date, &tofs, &rdata, 2);

    if (up->type_gpsdate <= DTYP_WEXT) {

      rc_date = parse_gpsw(&wgps, &rdata, 5, 4, -1);

      rc_dtyp = DTYP_WEXT;

    }

    break;

  default:

    INVARIANT(0);  /* Coverity 97123 */

    return;

  }

  /* ignore receiver status? [bug 3694] */

  if (peer->ttl & NMEA_IGNSTATUS_MASK) { /* assume always good? */

    pp->leap = LEAP_NOWARNING;

  }

  /* check clock sanity; [bug 2143] */

  if (pp->leap == LEAP_NOTINSYNC) { /* no good status? */

    checkres = CEVNT_PROP;

    up->tally.rejected++;

  }

  /* Check sanity of time-of-day. */

  else if (rc_time == 0) { /* no time or conversion error? */

    checkres = CEVNT_BADTIME;

    up->tally.malformed++;

  }

  /* Check sanity of date. */

  else if (rc_date == 0) { /* no date or conversion error? */

    checkres = CEVNT_BADDATE;

    up->tally.malformed++;

  }

  else {

    checkres = -1;

  }

  if (checkres != -1) {

    refclock_save_lcode(pp, up->lb_buf, up->lb_len);

    refclock_report(peer, checkres);

    return;

  }

  /* See if we can augment the receive time stamp. If not, apply

   * fudge time 2 to the receive time stamp directly.

   */

#   ifdef HAVE_PPSAPI

  if (up->ppsapi_lit && pp->leap != LEAP_NOTINSYNC)

    withpps = refclock_ppsaugment(

      &up->atom, &rd_timestamp,

      pp->fudgetime2, pp->fudgetime1);

  else

#   endif /* HAVE_PPSAPI */

    rd_timestamp = ntpfp_with_fudge(

      rd_timestamp, pp->fudgetime2);

  /* set the GPS base date, if possible */

  warp = !(peer->ttl & NMEA_DATETRUST_MASK);

  if (rc_dtyp != DTYP_NONE) {

    DPRINTF(1, ("%s saving date, type=%hu\n",

          refnumtoa(&peer->srcadr), rc_dtyp));

    switch (rc_dtyp) {

    case DTYP_W10B:

      up->last_gpsdate = gpsntp_from_gpscal_ex(

        &wgps, (warp = TRUE));

      break;

    case DTYP_WEXT:

      up->last_gpsdate = gpsntp_from_gpscal_ex(

        &wgps, warp);

      break;

    default:

      up->last_gpsdate = gpsntp_from_calendar_ex(

        &date, tofs, warp);

      break;

    }

    up->type_gpsdate = rc_dtyp;

    up->hold_gpsdate = DATE_HOLD;

  }

  /* now convert and possibly extend/expand the time stamp. */

  if (up->hold_gpsdate) { /* time of day, based */

    dntp = gpsntp_from_daytime2_ex(

      &date, tofs, &up->last_gpsdate, warp);

  } else {   /* time of day, floating */

    dntp = gpsntp_from_daytime1_ex(

      &date, tofs, rd_timestamp, warp);

  }

  if (debug) {

    /* debug print time stamp */

    gpsntp_to_calendar(&date, &dntp);

#     ifdef HAVE_PPSAPI

    DPRINTF(1, ("%s effective timecode: %s (%s PPS)\n",

          refnumtoa(&peer->srcadr),

          ntpcal_iso8601std(NULL, 0, &date),

          (withpps ? "with" : "without")));

#     else /* ?HAVE_PPSAPI */

    DPRINTF(1, ("%s effective timecode: %s\n",

          refnumtoa(&peer->srcadr),

          ntpcal_iso8601std(NULL, 0, &date)));

#     endif /* !HAVE_PPSAPI */

  }

  /* Get the reference time stamp from the calendar buffer.

   * Process the new sample in the median filter and determine the

   * timecode timestamp, but only if the PPS is not in control.

   * Discard sentence if reference time did not change.

   */

  rd_reftime = ntpfp_from_ntpdatum(&dntp);

  if (L_ISEQU(&up->last_reftime, &rd_reftime)) {

    /* Do not touch pp->a_lastcode on purpose! */

    up->tally.filtered++;

    return;

  }

  up->last_reftime = rd_reftime;

  DPRINTF(1, ("%s using '%s'\n",

        refnumtoa(&peer->srcadr), up->lb_buf));

  /* Data will be accepted. Update stats & log data. */

  up->tally.accepted++;

  refclock_save_lcode(pp, up->lb_buf, up->lb_len);

  pp->lastrec = rd_timestamp;

  /* If we have PPS augmented receive time, we *must* have a

   * working PPS source and we must set the flags accordingly.

   */

#   ifdef HAVE_PPSAPI

  if (withpps) {

    up->ppsapi_gate = TRUE;

    peer->precision = PPS_PRECISION;

    if (tabsdiffd(rd_reftime, rd_timestamp) < 0.5) {

      if ( ! (peer->ttl & NMEA_QUIETPPS_MASK))

        peer->flags |= FLAG_PPS;

      DPRINTF(2, ("%s PPS_RELATE_PHASE\n",

            refnumtoa(&peer->srcadr)));

      up->tally.pps_used++;

    } else {

      DPRINTF(2, ("%s PPS_RELATE_EDGE\n",

            refnumtoa(&peer->srcadr)));

    }

    /* !Note! 'FLAG_PPS' is reset in 'nmea_poll()' */

  }

#   endif /* HAVE_PPSAPI */

  /* Whether the receive time stamp is PPS-augmented or not,

   * the proper fudge offset is already applied. There's no

   * residual fudge to process.

   */

  refclock_process_offset(pp, rd_reftime, rd_timestamp, 0.0);

  up->rcvtout = 2;