/*

 * refclock_jjy - clock driver for JJY receivers

 */

/**********************************************************************/

/*                      */

/*  Copyright (C) 2001-2020, Takao Abe.  All rights reserved.       */

/*                      */

/*  Permission to use, copy, modify, and distribute this software     */

/*  and its documentation for any purpose is hereby granted       */

/*  without fee, provided that the following conditions are met:      */

/*                      */

/*  One retains the entire copyright notice properly, and both the    */

/*  copyright notice and this license. in the documentation and/or    */

/*  other materials provided with the distribution.         */

/*                      */

/*  This software and the name of the author must not be used to      */

/*  endorse or promote products derived from this software without    */

/*  prior written permission.               */

/*                      */

/*  THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESSED OR IMPLIED    */

/*  WARRANTIES OF ANY KIND, INCLUDING, BUT NOT LIMITED TO, THE        */

/*  IMPLIED WARRANTIES OF MERCHANTABLILITY AND FITNESS FOR A        */

/*  PARTICULAR PURPOSE.                 */

/*  IN NO EVENT SHALL THE AUTHOR TAKAO ABE BE LIABLE FOR ANY DIRECT,  */

/*  INDIRECT, GENERAL, 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. */

/*                      */

/*  This driver is developed in my private time, and is opened as     */

/*  voluntary contributions for the NTP.            */

/*  The manufacturer of the JJY receiver has not participated in      */

/*  a development of this driver.             */

/*  The manufacturer does not warrant anything about this driver,     */

/*  and is not liable for anything about this driver.         */

/*                      */

/**********************************************************************/

/*                      */

/*  Author     Takao Abe                */

/*  Email      takao_abe@xurb.jp              */

/*  Homepage   http://www.bea.hi-ho.ne.jp/abetakao/         */

/*                      */

/*  The email address abetakao@bea.hi-ho.ne.jp is never read        */

/*  from 2010, because a few filtering rule are provided by the       */

/*  "hi-ho.ne.jp", and lots of spam mail are reached.         */

/*  New email address for supporting the refclock_jjy is        */

/*  takao_abe@xurb.jp                 */

/*                      */

/**********************************************************************/

/*                      */

/*  History                   */

/*                      */

/*  2001/07/15                    */

/*    [New]    Support the Tristate Ltd. JJY receiver         */

/*                      */

/*  2001/08/04                    */

/*    [Change] Log to clockstats even if bad reply          */

/*    [Fix]    PRECISION = (-3) (about 100 ms)            */

/*    [Add]    Support the C-DEX Co.Ltd. JJY receiver         */

/*                      */

/*  2001/12/04                    */

/*    [Fix]    C-DEX JST2000 ( fukusima@goto.info.waseda.ac.jp )      */

/*                      */

/*  2002/07/12                    */

/*    [Fix]    Portability for FreeBSD ( patched by the user )        */

/*                      */

/*  2004/10/31                    */

/*    [Change] Command send timing for the Tristate Ltd. JJY receiver */

/*         JJY-01 ( Firmware version 2.01 )           */

/*         Thanks to Andy Taki for testing under FreeBSD        */

/*                      */

/*  2004/11/28                    */

/*    [Add]    Support the Echo Keisokuki LT-2000 receiver        */

/*                      */

/*  2006/11/04                    */

/*    [Fix]    C-DEX JST2000                */

/*         Thanks to Hideo Kuramatsu for the patch          */

/*                      */

/*  2009/04/05                    */

/*    [Add]    Support the CITIZEN T.I.C JJY-200 receiver       */

/*                      */

/*  2010/11/20                    */

/*    [Change] Bug 1618 ( Harmless )              */

/*         Code clean up ( Remove unreachable codes ) in        */

/*         jjy_start()                */

/*    [Change] Change clockstats format of the Tristate JJY01/02      */

/*         Issues more command to get the status of the receiver  */

/*         when "fudge 127.127.40.X flag1 1" is specified       */

/*         ( DATE,STIM -> DCST,STUS,DATE,STIM )         */

/*                      */

/*  2011/04/30                    */

/*    [Add]    Support the Tristate Ltd. TS-GPSclock-01         */

/*                      */

/*  2015/03/29                    */

/*    [Add]    Support the Telephone JJY            */

/*    [Change] Split the start up routine into each JJY receivers.    */

/*             Change raw data internal bufferring process            */

/*             Change over midnight handling of TS-JJY01 and TS-GPS01 */

/*             to put DATE command between before and after TIME's.   */

/*             Unify the writing clockstats of all JJY receivers.     */

/*                      */

/*  2015/05/15                    */

/*    [Add]    Support the SEIKO TIME SYSTEMS TDC-300         */

/*                      */

/*  2016/05/08                    */

/*    [Fix]    C-DEX JST2000                                          */

/*             Thanks to Mr. Kuramatsu for the report and the patch.  */

/*                      */

/*  2017/04/30                    */

/*    [Change] Avoid a wrong report of the coverity static analysis   */

/*             tool. ( The code is harmless and has no bug. )       */

/*             teljjy_conn_send()             */

/*                      */

/*  2020/01/19                    */

/*    [Change] Handling TS-JJY01/02 status of the the STUS reply.     */

/*             Time synchronization can be skipped by the settings of */

/*             the flag2 when the status of the reply is UNADJUSTED.  */

/*    [Change] Quiet compilation for the GCC 9.2.0.                   */

/*    [Fix]    Correct typos in comment lines                         */

/*                      */

/**********************************************************************/

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#if defined(REFCLOCK) && defined(CLOCK_JJY)

#include <stdio.h>

#include <ctype.h>

#include <string.h>

#include <sys/time.h>

#include <time.h>

#include "ntpd.h"

#include "ntp_io.h"

#include "ntp_tty.h"

#include "ntp_refclock.h"

#include "ntp_calendar.h"

#include "ntp_stdlib.h"

/**********************************************************************/

/*

 * Interface definitions

 */

#define DEVICE    "/dev/jjy%d"  /* device name and unit */

#define SPEED232_TRISTATE_JJY01   B9600   /* UART speed (9600 baud) */

#define SPEED232_CDEX_JST2000   B9600   /* UART speed (9600 baud) */

#define SPEED232_ECHOKEISOKUKI_LT2000 B9600   /* UART speed (9600 baud) */

#define SPEED232_CITIZENTIC_JJY200  B4800   /* UART speed (4800 baud) */

#define SPEED232_TRISTATE_GPSCLOCK01  B38400  /* USB  speed (38400 baud) */

#define SPEED232_SEIKO_TIMESYS_TDC_300  B2400   /* UART speed (2400 baud) */

#define SPEED232_TELEPHONE    B2400   /* UART speed (4800 baud) */

#define REFID     "JJY"    /* reference ID */

#define DESCRIPTION "JJY Receiver"

#define PRECISION (-3)    /* precision assumed (about 100 ms) */

/*

 * JJY unit control structure

 */

struct jjyRawDataBreak {

  const char *  pString ;

  int     iLength ;

} ;

#define MAX_TIMESTAMP 6

#define MAX_RAWBUF    100

#define MAX_LOOPBACK  5

struct jjyunit {

/* Set up by the function "jjy_start_xxxxxxxx" */

  char  unittype ;      /* UNITTYPE_XXXXXXXXXX */

  short   operationmode ;     /* Echo Keisokuki LT-2000 */

  int   linespeed ;         /* SPEED232_XXXXXXXXXX */

  short linediscipline ;    /* LDISC_CLK or LDISC_RAW */

/* Receiving data */

  char  bInitError ;        /* Set by jjy_start if any error during initialization */

  short iProcessState ;     /* JJY_PROCESS_STATE_XXXXXX */

  char  bReceiveFlag ;      /* Set and reset by jjy_receive */

  char  bLineError ;      /* Reset by jjy_poll / Set by jjy_receive_xxxxxxxx*/

  short iCommandSeq ;       /* 0:Idle  Non-Zero:Issued */

  short iReceiveSeq ;

  int   iLineCount ;

  int   year, month, day, hour, minute, second, msecond ;

  int   leapsecond ;

  int   iTimestampCount ;   /* TS-JJY01, TS-GPS01, Telephone-JJY */

  int   iTimestamp [ MAX_TIMESTAMP ] ;  /* Serial second ( 0 - 86399 ) */

/* LDISC_RAW only */

  char  sRawBuf [ MAX_RAWBUF ] ;

  int   iRawBufLen ;

  struct  jjyRawDataBreak *pRawBreak ;

  char  bWaitBreakString ;

  char  sLineBuf [ MAX_RAWBUF ] ;

  int   iLineBufLen ;

  char  sTextBuf [ MAX_RAWBUF ] ;

  int   iTextBufLen ;

  char  bSkipCntrlCharOnly ;

/* TS-JJY01, TS-JJY02 */

  time_t  tLastAdjustedTimestamp ;

  char  bStusReplyAdjusted ;

  char  bStusReplyAdjustedAtLeastOnce ;

/* Telephone JJY auto measurement of the loopback delay */

  char  bLoopbackMode ;

  short iLoopbackCount ;

  struct  timeval sendTime[MAX_LOOPBACK], delayTime[MAX_LOOPBACK] ;

  char  bLoopbackTimeout[MAX_LOOPBACK] ;

  short iLoopbackValidCount ;

/* Telephone JJY timer */

  short iTeljjySilentTimer ;

  short iTeljjyStateTimer ;

/* Telephone JJY control finite state machine */

  short iClockState ;

  short iClockEvent ;

  short iClockCommandSeq ;

/* Modem timer */

  short iModemSilentCount ;

  short iModemSilentTimer ;

  short iModemStateTimer ;

/* Modem control finite state machine */

  short iModemState ;

  short iModemEvent ;

  short iModemCommandSeq ;

};

#define UNITTYPE_TRISTATE_JJY01   1

#define UNITTYPE_CDEX_JST2000   2

#define UNITTYPE_ECHOKEISOKUKI_LT2000   3

#define UNITTYPE_CITIZENTIC_JJY200    4

#define UNITTYPE_TRISTATE_GPSCLOCK01  5

#define UNITTYPE_SEIKO_TIMESYS_TDC_300  6

#define UNITTYPE_TELEPHONE    100

#define JJY_PROCESS_STATE_IDLE    0

#define JJY_PROCESS_STATE_POLL    1

#define JJY_PROCESS_STATE_RECEIVE 2

#define JJY_PROCESS_STATE_DONE    3

#define JJY_PROCESS_STATE_ERROR   4

/**********************************************************************/

/*

 *  Function calling structure

 *

 *  jjy_start

 *   |--  jjy_start_tristate_jjy01

 *   |--  jjy_start_cdex_jst2000

 *   |--  jjy_start_echokeisokuki_lt2000

 *   |--  jjy_start_citizentic_jjy200

 *   |--  jjy_start_tristate_gpsclock01

 *   |--  jjy_start_seiko_tsys_tdc_300

 *   |--  jjy_start_telephone

 *

 *  jjy_shutdown

 *

 *  jjy_poll

 *   |--  jjy_poll_tristate_jjy01

 *   |--  jjy_poll_cdex_jst2000

 *   |--  jjy_poll_echokeisokuki_lt2000

 *   |--  jjy_poll_citizentic_jjy200

 *   |--  jjy_poll_tristate_gpsclock01

 *   |--  jjy_poll_seiko_tsys_tdc_300

 *   |--  jjy_poll_telephone

 *         |--  teljjy_control

 *               |--  teljjy_XXXX_YYYY ( XXXX_YYYY is an event handler name. )

 *                     |--  modem_connect

 *                           |--  modem_control

 *                                 |--  modem_XXXX_YYYY ( XXXX_YYYY is an event handler name. )

 *

 *  jjy_receive

 *   |

 *   |--  jjy_receive_tristate_jjy01

 *   |     |--  jjy_synctime

 *   |--  jjy_receive_cdex_jst2000

 *   |     |--  jjy_synctime

 *   |--  jjy_receive_echokeisokuki_lt2000

 *   |     |--  jjy_synctime

 *   |--  jjy_receive_citizentic_jjy200

 *   |     |--  jjy_synctime

 *   |--  jjy_receive_tristate_gpsclock01

 *   |     |--  jjy_synctime

 *   |--  jjy_receive_seiko_tsys_tdc_300

 *   |     |--  jjy_synctime

 *   |--  jjy_receive_telephone

 *         |--  modem_receive

 *         |     |--  modem_control

 *         |           |--  modem_XXXX_YYYY ( XXXX_YYYY is an event handler name. )

 *         |--  teljjy_control

 *               |--  teljjy_XXXX_YYYY ( XXXX_YYYY is an event handler name. )

 *                     |--  jjy_synctime

 *                     |--  modem_disconnect

 *                           |--  modem_control

 *                                 |--  modem_XXXX_YYYY ( XXXX_YYYY is an event handler name. )

 *

 *  jjy_timer

 *   |--  jjy_timer_telephone

 *         |--  modem_timer

 *         |     |--  modem_control

 *         |           |--  modem_XXXX_YYYY ( XXXX_YYYY is an event handler name. )

 *         |--  teljjy_control

 *               |--  teljjy_XXXX_YYYY ( XXXX_YYYY is an event handler name. )

 *                     |--  modem_disconnect

 *                           |--  modem_control

 *                                 |--  modem_XXXX_YYYY ( XXXX_YYYY is an event handler name. )

 *

 * Function prototypes

 */

static  int   jjy_start     (int, struct peer *);

static  int   jjy_start_tristate_jjy01  (int, struct peer *, struct jjyunit *);

static  int   jjy_start_cdex_jst2000    (int, struct peer *, struct jjyunit *);

static  int   jjy_start_echokeisokuki_lt2000  (int, struct peer *, struct jjyunit *);

static  int   jjy_start_citizentic_jjy200 (int, struct peer *, struct jjyunit *);

static  int   jjy_start_tristate_gpsclock01 (int, struct peer *, struct jjyunit *);

static  int   jjy_start_seiko_tsys_tdc_300  (int, struct peer *, struct jjyunit *);

static  int   jjy_start_telephone   (int, struct peer *, struct jjyunit *);

static  void  jjy_shutdown      (int, struct peer *);

static  void  jjy_poll          (int, struct peer *);

static  void  jjy_poll_tristate_jjy01       (int, struct peer *);

static  void  jjy_poll_cdex_jst2000       (int, struct peer *);

static  void  jjy_poll_echokeisokuki_lt2000 (int, struct peer *);

static  void  jjy_poll_citizentic_jjy200  (int, struct peer *);

static  void  jjy_poll_tristate_gpsclock01  (int, struct peer *);

static  void  jjy_poll_seiko_tsys_tdc_300 (int, struct peer *);

static  void  jjy_poll_telephone    (int, struct peer *);

static  void  jjy_receive     (struct recvbuf *);

static  int   jjy_receive_tristate_jjy01  (struct recvbuf *);

static  int   jjy_receive_cdex_jst2000  (struct recvbuf *);

static  int   jjy_receive_echokeisokuki_lt2000 (struct recvbuf *);

static  int   jjy_receive_citizentic_jjy200 (struct recvbuf *);

static  int   jjy_receive_tristate_gpsclock01 (struct recvbuf *);

static  int   jjy_receive_seiko_tsys_tdc_300  (struct recvbuf *);

static  int   jjy_receive_telephone   (struct recvbuf *);

static  void  jjy_timer     (int, struct peer *);

static  void  jjy_timer_telephone   (int, struct peer *);

static  void  jjy_synctime      ( struct peer *, struct refclockproc *, struct jjyunit * ) ;

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

static  int   getRawDataBreakPosition   ( struct jjyunit *, int ) ;

static  short getModemState     ( struct jjyunit * ) ;

static  int   isModemStateConnect   ( short ) ;

static  int   isModemStateDisconnect    ( short ) ;

static  int   isModemStateTimerOn   ( struct jjyunit * ) ;

static  void  modem_connect     ( int, struct peer * ) ;

static  void  modem_disconnect    ( int, struct peer * ) ;

static  int   modem_receive     ( struct recvbuf * ) ;

static  void  modem_timer     ( int, struct peer * );

static  void  printableString ( char*, int, const char*, int ) ;

/*

 * Transfer vector

 */

struct  refclock refclock_jjy = {

  jjy_start,  /* start up driver */

  jjy_shutdown, /* shutdown driver */

  jjy_poll, /* transmit poll message */

  noentry,  /* not used */

  noentry,  /* not used */

  noentry,  /* not used */

  jjy_timer /* 1 second interval timer */

};

/*

 * Start up driver return code

 */

#define RC_START_SUCCESS  1

#define RC_START_ERROR    0

/*

 * Local constants definition

 */

#define MAX_LOGTEXT 200

#ifndef TRUE

#define TRUE  (0==0)

#endif

#ifndef FALSE

#define FALSE (!TRUE)

#endif

/* Local constants definition for the return code of the jjy_receive_xxxxxxxx */

#define JJY_RECEIVE_DONE  0

#define JJY_RECEIVE_SKIP  1

#define JJY_RECEIVE_UNPROCESS 2

#define JJY_RECEIVE_WAIT  3

#define JJY_RECEIVE_ERROR 4

/* Local constants definition for the 2nd parameter of the jjy_write_clockstats */

#define JJY_CLOCKSTATS_MARK_NONE  0

#define JJY_CLOCKSTATS_MARK_JJY   1

#define JJY_CLOCKSTATS_MARK_SEND  2

#define JJY_CLOCKSTATS_MARK_RECEIVE 3

#define JJY_CLOCKSTATS_MARK_INFORMATION 4

#define JJY_CLOCKSTATS_MARK_ATTENTION 5

#define JJY_CLOCKSTATS_MARK_WARNING 6

#define JJY_CLOCKSTATS_MARK_ERROR 7

#define JJY_CLOCKSTATS_MARK_BUG   8

/* Local constants definition for the clockstats messages */

#define JJY_CLOCKSTATS_MESSAGE_ECHOBACK           "* Echoback"

#define JJY_CLOCKSTATS_MESSAGE_IGNORE_REPLY       "* Ignore replay : [%s]"

#define JJY_CLOCKSTATS_MESSAGE_OVER_MIDNIGHT_2    "* Over midnight : timestamp=%d, %d"

#define JJY_CLOCKSTATS_MESSAGE_OVER_MIDNIGHT_3    "* Over midnight : timestamp=%d, %d, %d"

#define JJY_CLOCKSTATS_MESSAGE_TIMESTAMP_UNSURE   "* Unsure timestamp : %s"

#define JJY_CLOCKSTATS_MESSAGE_LOOPBACK_DELAY     "* Loopback delay : %d.%03d mSec."

#define JJY_CLOCKSTATS_MESSAGE_DELAY_ADJUST       "* Delay adjustment : %d mSec. ( valid=%hd/%d )"

#define JJY_CLOCKSTATS_MESSAGE_DELAY_UNADJUST     "* Delay adjustment : None ( valid=%hd/%d )"

#define JJY_CLOCKSTATS_MESSAGE_STUS_UNADJUSTED    "* Skip time synchronization : STUS is 'UNADJUSTED' for %.0lf %s"

#define JJY_CLOCKSTATS_MESSAGE_UNEXPECTED_REPLY       "# Unexpected reply : [%s]"

#define JJY_CLOCKSTATS_MESSAGE_INVALID_LENGTH       "# Invalid length : length=%d"

#define JJY_CLOCKSTATS_MESSAGE_TOO_MANY_REPLY       "# Too many reply : count=%d"

#define JJY_CLOCKSTATS_MESSAGE_INVALID_REPLY        "# Invalid reply : [%s]"

#define JJY_CLOCKSTATS_MESSAGE_SLOW_REPLY_2         "# Slow reply : timestamp=%d, %d"

#define JJY_CLOCKSTATS_MESSAGE_SLOW_REPLY_3         "# Slow reply : timestamp=%d, %d, %d"

#define JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_DATE  "# Invalid date : rc=%d year=%d month=%d day=%d"

#define JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_TIME  "# Invalid time : rc=%d hour=%d minute=%d second=%d"

#define JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_DATETIME  "# Invalid time : rc=%d year=%d month=%d day=%d hour=%d minute=%d second=%d"

#define JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_LEAP  "# Invalid leap : leapsecond=[%s]"

#define JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_STATUS  "# Invalid status : status=[%s]"

/* Debug print macro */

#ifdef  DEBUG

#define DEBUG_PRINTF_JJY_RECEIVE(sFunc,iLen)  { if ( debug ) { printf ( "refclock_jjy.c : %s : iProcessState=%d bLineError=%d iCommandSeq=%d iLineCount=%d iTimestampCount=%d iLen=%d\n", sFunc, up->iProcessState, up->bLineError, up->iCommandSeq, up->iLineCount, up->iTimestampCount, iLen ) ; } }

#else

#define DEBUG_PRINTF_JJY_RECEIVE(sFunc,iLen)

#endif

/**************************************************************************************************/

/*  jjy_start - open the devices and initialize data for processing                               */

/**************************************************************************************************/

static int

jjy_start ( int unit, struct peer *peer )

{

  struct  refclockproc *pp ;

  struct  jjyunit      *up ;

  int   rc ;

  int   fd ;

  char  sDeviceName [ sizeof(DEVICE) + 10 ], sLog [ 60 ] ;

#ifdef DEBUG

  if ( debug ) {

    printf( "refclock_jjy.c : jjy_start : %s  mode=%d  dev=%s  unit=%d\n",

       ntoa(&peer->srcadr), peer->ttl, DEVICE, unit ) ;

  }

#endif

  /* Allocate memory for the unit structure */

  up = emalloc( sizeof(*up) ) ;

  if ( up == NULL ) {

    msyslog ( LOG_ERR, "refclock_jjy.c : jjy_start : emalloc" ) ;

    return RC_START_ERROR ;

  }

  memset ( up, 0, sizeof(*up) ) ;

  up->bInitError = FALSE ;

  up->iProcessState = JJY_PROCESS_STATE_IDLE ;

  up->bReceiveFlag = FALSE ;

  up->iCommandSeq = 0 ;

  up->iLineCount = 0 ;

  up->iTimestampCount = 0 ;

  up->bWaitBreakString = FALSE ;

  up->iRawBufLen = up->iLineBufLen = up->iTextBufLen = 0 ;

  up->bSkipCntrlCharOnly = TRUE ;

  /* Set up the device name */

  snprintf( sDeviceName, sizeof(sDeviceName), DEVICE, unit ) ;

  snprintf( sLog, sizeof(sLog), "mode=%d dev=%s", peer->ttl, sDeviceName ) ;

  jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_JJY, sLog ) ;

  /*

   * peer->ttl is a mode number specified by "127.127.40.X mode N" in the ntp.conf

   */

  switch ( peer->ttl ) {

  case 0 :

  case 1 :

    rc = jjy_start_tristate_jjy01 ( unit, peer, up ) ;

    break ;

  case 2 :

    rc = jjy_start_cdex_jst2000 ( unit, peer, up ) ;

    break ;

  case 3 :

    rc = jjy_start_echokeisokuki_lt2000 ( unit, peer, up ) ;

    break ;

  case 4 :

    rc = jjy_start_citizentic_jjy200 ( unit, peer, up ) ;

    break ;

  case 5 :

    rc = jjy_start_tristate_gpsclock01 ( unit, peer, up ) ;

    break ;

  case 6 :

    rc = jjy_start_seiko_tsys_tdc_300 ( unit, peer, up ) ;

    break ;

  case 100 :

    rc = jjy_start_telephone ( unit, peer, up ) ;

    break ;

  default :

    if ( 101 <= peer->ttl && peer->ttl <= 180 ) {

      rc = jjy_start_telephone ( unit, peer, up ) ;

    } else {

      msyslog ( LOG_ERR, "JJY receiver [ %s mode %d ] : Unsupported mode",

          ntoa(&peer->srcadr), peer->ttl ) ;

      free ( (void*) up ) ;

    return RC_START_ERROR ;

    }

  }

  if ( rc != 0 ) {

    msyslog ( LOG_ERR, "JJY receiver [ %s mode %d ] : Initialize error",

        ntoa(&peer->srcadr), peer->ttl ) ;

    free ( (void*) up ) ;

    return RC_START_ERROR ;

  }

  /* Open the device */

  fd = refclock_open ( &peer->srcadr, sDeviceName, up->linespeed, up->linediscipline ) ;

  if ( fd <= 0 ) {

    free ( (void*) up ) ;

    return RC_START_ERROR ;

  }

  /*

   * Initialize variables

   */

  pp = peer->procptr ;

  pp->clockdesc = DESCRIPTION ;

  pp->unitptr       = up ;

  pp->io.clock_recv = jjy_receive ;

  pp->io.srcclock   = peer ;

  pp->io.datalen    = 0 ;

  pp->io.fd   = fd ;

  if ( ! io_addclock(&pp->io) ) {

    close ( fd ) ;

    pp->io.fd = -1 ;

    free ( up ) ;

    pp->unitptr = NULL ;

    return RC_START_ERROR ;

  }

  memcpy( (char*)&pp->refid, REFID, strlen(REFID) ) ;

  peer->precision = PRECISION ;

  snprintf( sLog, sizeof(sLog), "minpoll=%d maxpoll=%d", peer->minpoll, peer->maxpoll ) ;

  jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_JJY, sLog ) ;

  return RC_START_SUCCESS ;

}

/**************************************************************************************************/

/*  jjy_shutdown - shutdown the clock                                                             */

/**************************************************************************************************/

static void

jjy_shutdown ( int unit, struct peer *peer )

{

  struct jjyunit      *up;

  struct refclockproc *pp;

  char  sLog [ 60 ] ;

  pp = peer->procptr ;

  up = pp->unitptr ;

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

    io_closeclock ( &pp->io ) ;

  }

  if ( NULL != up ) {

    free ( up ) ;

  }

  snprintf( sLog, sizeof(sLog), "JJY stopped. unit=%d mode=%d", unit, peer->ttl ) ;

  record_clock_stats( &peer->srcadr, sLog ) ;

}

/**************************************************************************************************/

/*  jjy_receive - receive data from the serial interface                                          */

/**************************************************************************************************/

static void

jjy_receive ( struct recvbuf *rbufp )

{

#ifdef DEBUG

  static const char *sFunctionName = "jjy_receive" ;

#endif

  struct jjyunit      *up ;

  struct refclockproc *pp ;

  struct peer     *peer;

  l_fp  tRecvTimestamp;   /* arrival timestamp */

  int   rc ;

  char  *pBuf, sLogText [ MAX_LOGTEXT ] ;

  size_t  iLen, iCopyLen ;

  int   i, j, iReadRawBuf, iBreakPosition ;

  /*

   * Initialize pointers and read the timecode and timestamp

   */

  peer = rbufp->recv_peer ;

  pp = peer->procptr ;

  up = pp->unitptr ;

  /*

   * Get next input line

   */

  if ( up->linediscipline == LDISC_RAW ) {

    pp->lencode  = refclock_gtraw ( rbufp, pp->a_lastcode, BMAX-1, &tRecvTimestamp ) ;

    /* 3rd argument can be BMAX, but the coverity scan tool claim "Memory - corruptions  (OVERRUN)" */

    /* "a_lastcode" is defined as "char a_lastcode[BMAX]" in the ntp_refclock.h */

    /* To avoid its claim, pass the value BMAX-1. */

    /*

     * Append received characters to temporary buffer

     */

    for ( i = 0 ;

          i < pp->lencode && up->iRawBufLen < MAX_RAWBUF - 2 ;

          i ++ , up->iRawBufLen ++ ) {

      up->sRawBuf[up->iRawBufLen] = pp->a_lastcode[i] ;

    }

    up->sRawBuf[up->iRawBufLen] = 0 ;

  } else {

    pp->lencode  = refclock_gtlin ( rbufp, pp->a_lastcode, BMAX, &tRecvTimestamp ) ;

  }

#ifdef DEBUG

  printf( "\nrefclock_jjy.c : %s : Len=%d  ", sFunctionName, pp->lencode ) ;

  for ( i = 0 ; i < pp->lencode ; i ++ ) {

    if ( iscntrl( (u_char)(pp->a_lastcode[i] & 0x7F) ) ) {

      printf( "<x%02X>", pp->a_lastcode[i] & 0xFF ) ;

    } else {

      printf( "%c", pp->a_lastcode[i] ) ;

    }

  }

  printf( "\n" ) ;

#endif

  /*

   * The reply with <CR><LF> gives a blank line

   */

  if ( pp->lencode == 0 ) return ;

  /*

   * Receiving data is not expected

   */

  if ( up->iProcessState == JJY_PROCESS_STATE_IDLE

    || up->iProcessState == JJY_PROCESS_STATE_DONE

    || up->iProcessState == JJY_PROCESS_STATE_ERROR ) {

    /* Discard received data */

    up->iRawBufLen = 0 ;

#ifdef DEBUG

    if ( debug ) {

      printf( "refclock_jjy.c : %s : Discard received data\n", sFunctionName ) ;

    }

#endif

    return ;

  }

  /*

   * We get down to business

   */

  pp->lastrec = tRecvTimestamp ;

  up->iLineCount ++ ;

  up->iProcessState = JJY_PROCESS_STATE_RECEIVE ;

  up->bReceiveFlag = TRUE ;

  iReadRawBuf = 0 ;

  iBreakPosition = up->iRawBufLen - 1 ;

  for ( ; up->iProcessState == JJY_PROCESS_STATE_RECEIVE ; ) {

    if ( up->linediscipline == LDISC_RAW ) {

      if ( up->bWaitBreakString ) {

        iBreakPosition = getRawDataBreakPosition( up, iReadRawBuf ) ;

        if ( iBreakPosition == -1 ) {

          /* Break string have not come yet */

          if ( up->iRawBufLen < MAX_RAWBUF - 2

            || iReadRawBuf > 0 ) {

            /* Temporary buffer is not full */

            break ;

          } else {

            /* Temporary buffer is full */

            iBreakPosition = up->iRawBufLen - 1 ;

          }

        }

      } else {

        iBreakPosition = up->iRawBufLen - 1 ;

      }

      /* Copy characters from temporary buffer to process buffer */

      up->iLineBufLen = up->iTextBufLen = 0 ;

      for ( i = iReadRawBuf ; i <= iBreakPosition ; i ++ ) {

        /* Copy all characters */

        up->sLineBuf[up->iLineBufLen] = up->sRawBuf[i] ;

        up->iLineBufLen ++ ;

        /* Copy printable characters */

        if ( ! iscntrl( (u_char)up->sRawBuf[i] ) ) {

          up->sTextBuf[up->iTextBufLen] = up->sRawBuf[i] ;

          up->iTextBufLen ++ ;

        }

      }

      up->sLineBuf[up->iLineBufLen] = 0 ;

      up->sTextBuf[up->iTextBufLen] = 0 ;

#ifdef DEBUG

      printf( "refclock_jjy.c : %s : up->iLineBufLen=%d up->iTextBufLen=%d\n",

         sFunctionName, up->iLineBufLen, up->iTextBufLen ) ;

#endif

      if ( up->bSkipCntrlCharOnly && up->iTextBufLen == 0 ) {

#ifdef DEBUG

        printf( "refclock_jjy.c : %s : Skip cntrl char only : up->iRawBufLen=%d iReadRawBuf=%d iBreakPosition=%d\n",

           sFunctionName, up->iRawBufLen, iReadRawBuf, iBreakPosition ) ;

#endif

        if ( iBreakPosition + 1 < up->iRawBufLen ) {

          iReadRawBuf = iBreakPosition + 1 ;

          continue ;

        } else {

          break ;

        }

      }

    }

    if ( up->linediscipline == LDISC_RAW ) {

      pBuf = up->sLineBuf ;

      iLen = up->iLineBufLen ;

    } else {

      pBuf = pp->a_lastcode ;

      iLen = pp->lencode ;

    }

    iCopyLen = ( iLen <= sizeof(sLogText)-1 ? iLen : sizeof(sLogText)-1 ) ;

    memcpy( sLogText, pBuf, iCopyLen ) ;

    sLogText[iCopyLen] = '\0' ;

    jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_RECEIVE, sLogText ) ;

    switch ( up->unittype ) {

    case UNITTYPE_TRISTATE_JJY01 :

      rc = jjy_receive_tristate_jjy01  ( rbufp ) ;

      break ;

    case UNITTYPE_CDEX_JST2000 :

      rc = jjy_receive_cdex_jst2000 ( rbufp ) ;

      break ;

    case UNITTYPE_ECHOKEISOKUKI_LT2000 :

      rc = jjy_receive_echokeisokuki_lt2000 ( rbufp ) ;

      break ;

    case UNITTYPE_CITIZENTIC_JJY200 :

      rc = jjy_receive_citizentic_jjy200 ( rbufp ) ;

      break ;

    case UNITTYPE_TRISTATE_GPSCLOCK01 :

      rc = jjy_receive_tristate_gpsclock01 ( rbufp ) ;

      break ;

    case UNITTYPE_SEIKO_TIMESYS_TDC_300 :

      rc = jjy_receive_seiko_tsys_tdc_300 ( rbufp ) ;

      break ;

    case UNITTYPE_TELEPHONE :

      rc = jjy_receive_telephone ( rbufp ) ;

      break ;

    default :

      rc = JJY_RECEIVE_ERROR ;

      break ;

    }

    switch ( rc ) {

    case JJY_RECEIVE_DONE :

    case JJY_RECEIVE_SKIP :

      up->iProcessState = JJY_PROCESS_STATE_DONE ;

      break ;

    case JJY_RECEIVE_ERROR :

      up->iProcessState = JJY_PROCESS_STATE_ERROR ;

      break ;

    default :

      break ;

    }

    if ( up->linediscipline == LDISC_RAW ) {

      if ( rc == JJY_RECEIVE_UNPROCESS ) {

        break ;

      }

      iReadRawBuf = iBreakPosition + 1 ;

      if ( iReadRawBuf >= up->iRawBufLen ) {

        /* Processed all received data */

        break ;

      }

    }

    if ( up->linediscipline == LDISC_CLK ) {

      break ;

    }

  }

  if ( up->linediscipline == LDISC_RAW && iReadRawBuf > 0 ) {

    for ( i = 0, j = iReadRawBuf ; j < up->iRawBufLen ; i ++, j++ ) {

      up->sRawBuf[i] = up->sRawBuf[j] ;

    }

    up->iRawBufLen -= iReadRawBuf ;

    if ( up->iRawBufLen < 0 ) {

      up->iRawBufLen = 0 ;

    }

  }

  up->bReceiveFlag = FALSE ;

}

/**************************************************************************************************/

static int

getRawDataBreakPosition ( struct jjyunit *up, int iStart )

{

  int   i, j ;

  if ( iStart >= up->iRawBufLen ) {

#ifdef DEBUG

    printf( "refclock_jjy.c : getRawDataBreakPosition : iStart=%d return=-1\n", iStart ) ;

#endif

    return -1 ;

  }

  for ( i = iStart ; i < up->iRawBufLen ; i ++ ) {

    for ( j = 0 ; up->pRawBreak[j].pString != NULL ; j ++ ) {

      if ( i + up->pRawBreak[j].iLength <= up->iRawBufLen ) {

        if ( strncmp( up->sRawBuf + i,

          up->pRawBreak[j].pString,

          up->pRawBreak[j].iLength ) == 0 ) {

#ifdef DEBUG

          printf( "refclock_jjy.c : getRawDataBreakPosition : iStart=%d return=%d\n",

            iStart, i + up->pRawBreak[j].iLength - 1 ) ;

#endif

          return i + up->pRawBreak[j].iLength - 1 ;

        }

      }

    }

  }

#ifdef DEBUG

  printf( "refclock_jjy.c : getRawDataBreakPosition : iStart=%d return=-1\n", iStart ) ;

#endif

  return -1 ;

}

/**************************************************************************************************/

/*  jjy_poll - called by the transmit procedure                                                   */

/**************************************************************************************************/

static void

jjy_poll ( int unit, struct peer *peer )

{

  char  sLog [ 40 ], sReach [ 9 ] ;

  struct jjyunit      *up;

  struct refclockproc *pp;

  pp = peer->procptr;

  up = pp->unitptr ;

  if ( up->bInitError ) {

    jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, "Ignore polling because of error during initializing" ) ;

    return ;

  }

  if ( pp->polls > 0  &&  up->iLineCount == 0 ) {

    /*

     * No reply for last command

     */

    refclock_report ( peer, CEVNT_TIMEOUT ) ;

  }

  pp->polls ++ ;

  sReach[0] = peer->reach & 0x80 ? '1' : '0' ;

  sReach[1] = peer->reach & 0x40 ? '1' : '0' ;

  sReach[2] = peer->reach & 0x20 ? '1' : '0' ;

  sReach[3] = peer->reach & 0x10 ? '1' : '0' ;

  sReach[4] = peer->reach & 0x08 ? '1' : '0' ;

  sReach[5] = peer->reach & 0x04 ? '1' : '0' ;

  sReach[6] = peer->reach & 0x02 ? '1' : '0' ;

  sReach[7] = 0 ; /* This poll */

  sReach[8] = 0 ;

  snprintf( sLog, sizeof(sLog), "polls=%ld reach=%s", pp->polls, sReach ) ;

  jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ATTENTION, sLog ) ;

  up->iProcessState = JJY_PROCESS_STATE_POLL ;

  up->iCommandSeq = 0 ;

  up->iReceiveSeq = 0 ;

  up->iLineCount = 0 ;

  up->bLineError = FALSE ;

  up->iRawBufLen = 0 ;

  switch ( up->unittype ) {

  case UNITTYPE_TRISTATE_JJY01 :

    jjy_poll_tristate_jjy01  ( unit, peer ) ;

    break ;

  case UNITTYPE_CDEX_JST2000 :

    jjy_poll_cdex_jst2000 ( unit, peer ) ;

    break ;

  case UNITTYPE_ECHOKEISOKUKI_LT2000 :

    jjy_poll_echokeisokuki_lt2000 ( unit, peer ) ;

    break ;

  case UNITTYPE_CITIZENTIC_JJY200 :

    jjy_poll_citizentic_jjy200 ( unit, peer ) ;

    break ;

  case UNITTYPE_TRISTATE_GPSCLOCK01 :

    jjy_poll_tristate_gpsclock01 ( unit, peer ) ;

    break ;

  case UNITTYPE_SEIKO_TIMESYS_TDC_300 :

    jjy_poll_seiko_tsys_tdc_300 ( unit, peer ) ;