contrib/ntp/ntpd/refclock_jjy.c

   1 /*
   2  * refclock_jjy - clock driver for JJY receivers
   3  */
   4
   5 /**********************************************************************/
   6 /*                                                                    */
   7 /*  Copyright (C) 2001-2015, Takao Abe.  All rights reserved.         */
   8 /*                                                                    */
   9 /*  Permission to use, copy, modify, and distribute this software     */
  10 /*  and its documentation for any purpose is hereby granted           */
  11 /*  without fee, provided that the following conditions are met:      */
  12 /*                                                                    */
  13 /*  One retains the entire copyright notice properly, and both the    */
  14 /*  copyright notice and this license. in the documentation and/or    */
  15 /*  other materials provided with the distribution.                   */
  16 /*                                                                    */
  17 /*  This software and the name of the author must not be used to      */
  18 /*  endorse or promote products derived from this software without    */
  19 /*  prior written permission.                                         */
  20 /*                                                                    */
  21 /*  THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESSED OR IMPLIED    */
  22 /*  WARRANTIES OF ANY KIND, INCLUDING, BUT NOT LIMITED TO, THE        */
  23 /*  IMPLIED WARRANTIES OF MERCHANTABLILITY AND FITNESS FOR A          */
  24 /*  PARTICULAR PURPOSE.                                               */
  25 /*  IN NO EVENT SHALL THE AUTHOR TAKAO ABE BE LIABLE FOR ANY DIRECT,  */
  26 /*  INDIRECT, GENERAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES   */
  27 /*  ( INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE        */
  28 /*  GOODS OR SERVICES; LOSS OF USE, DATA OR PROFITS; OR BUSINESS      */
  29 /*  INTERRUPTION ) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,     */
  30 /*  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ( INCLUDING        */
  31 /*  NEGLIGENCE OR OTHERWISE ) ARISING IN ANY WAY OUT OF THE USE OF    */
  32 /*  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
  33 /*                                                                    */
  34 /*  This driver is developed in my private time, and is opened as     */
  35 /*  voluntary contributions for the NTP.                              */
  36 /*  The manufacturer of the JJY receiver has not participated in      */
  37 /*  a development of this driver.                                     */
  38 /*  The manufacturer does not warrant anything about this driver,     */
  39 /*  and is not liable for anything about this driver.                 */
  40 /*                                                                    */
  41 /**********************************************************************/
  42 /*                                                                    */
  43 /*  Author     Takao Abe                                              */
  44 /*  Email      takao_abe@xurb.jp                                      */
  45 /*  Homepage   http://www.bea.hi-ho.ne.jp/abetakao/                   */
  46 /*                                                                    */
  47 /*  The email address abetakao@bea.hi-ho.ne.jp is never read          */
  48 /*  from 2010, because a few filtering rule are provided by the       */
  49 /*  "hi-ho.ne.jp", and lots of spam mail are reached.                 */
  50 /*  New email address for supporting the refclock_jjy is              */
  51 /*  takao_abe@xurb.jp                                                 */
  52 /*                                                                    */
  53 /**********************************************************************/
  54 /*                                                                    */
  55 /*  History                                                           */
  56 /*                                                                    */
  57 /*  2001/07/15                                                        */
  58 /*    [New]    Support the Tristate Ltd. JJY receiver                 */
  59 /*                                                                    */
  60 /*  2001/08/04                                                        */
  61 /*    [Change] Log to clockstats even if bad reply                    */
  62 /*    [Fix]    PRECISION = (-3) (about 100 ms)                        */
  63 /*    [Add]    Support the C-DEX Co.Ltd. JJY receiver                 */
  64 /*                                                                    */
  65 /*  2001/12/04                                                        */
  66 /*    [Fix]    C-DEX JST2000 ( fukusima@goto.info.waseda.ac.jp )      */
  67 /*                                                                    */
  68 /*  2002/07/12                                                        */
  69 /*    [Fix]    Portability for FreeBSD ( patched by the user )        */
  70 /*                                                                    */
  71 /*  2004/10/31                                                        */
  72 /*    [Change] Command send timing for the Tristate Ltd. JJY receiver */
  73 /*             JJY-01 ( Firmware version 2.01 )                       */
  74 /*             Thanks to Andy Taki for testing under FreeBSD          */
  75 /*                                                                    */
  76 /*  2004/11/28                                                        */
  77 /*    [Add]    Support the Echo Keisokuki LT-2000 receiver            */
  78 /*                                                                    */
  79 /*  2006/11/04                                                        */
  80 /*    [Fix]    C-DEX JST2000                                          */
  81 /*             Thanks to Hideo Kuramatsu for the patch                */
  82 /*                                                                    */
  83 /*  2009/04/05                                                        */
  84 /*    [Add]    Support the CITIZEN T.I.C JJY-200 receiver             */
  85 /*                                                                    */
  86 /*  2010/11/20                                                        */
  87 /*    [Change] Bug 1618 ( Harmless )                                  */
  88 /*             Code clean up ( Remove unreachable codes ) in          */
  89 /*             jjy_start()                                            */
  90 /*    [Change] Change clockstats format of the Tristate JJY01/02      */
  91 /*             Issues more command to get the status of the receiver  */
  92 /*             when "fudge 127.127.40.X flag1 1" is specified         */
  93 /*             ( DATE,STIM -> DCST,STUS,DATE,STIM )                   */
  94 /*                                                                    */
  95 /*  2011/04/30                                                        */
  96 /*    [Add]    Support the Tristate Ltd. TS-GPSclock-01               */
  97 /*                                                                    */
  98 /*  2015/03/29                                                        */
  99 /*    [Add]    Support the Telephone JJY                              */
 100 /*    [Change] Split the start up routine into each JJY receivers.    */
 101 /*             Change raw data internal bufferring process            */
 102 /*             Change over midnight handling of TS-JJY01 and TS-GPS01 */
 103 /*             to put DATE command between before and after TIME's.   */
 104 /*             Unify the writing clockstats of all JJY receivers.     */
 105 /*                                                                    */
 106 /*  2015/05/15                                                        */
 107 /*    [Add]    Support the SEIKO TIME SYSTEMS TDC-300                 */
 108 /*                                                                    */
 109 /*  2016/05/08                                                        */
 110 /*    [Fix]    C-DEX JST2000                                          */
 111 /*             Thanks to Mr. Kuramatsu for the report and the patch.  */
 112 /*                                                                    */
 113 /*  2017/04/30                                                        */
 114 /*    [Change] Avoid a wrong report of the coverity static analysis   */
 115 /*             tool. ( The code is harmless and has no bug. )         */
 116 /*             teljjy_conn_send()                                     */
 117 /*                                                                    */
 118 /**********************************************************************/
 119
 120 #ifdef HAVE_CONFIG_H
 121 #include <config.h>
 122 #endif
 123
 124 #if defined(REFCLOCK) && defined(CLOCK_JJY)
 125
 126 #include <stdio.h>
 127 #include <ctype.h>
 128 #include <string.h>
 129 #include <sys/time.h>
 130 #include <time.h>
 131
 132 #include "ntpd.h"
 133 #include "ntp_io.h"
 134 #include "ntp_tty.h"
 135 #include "ntp_refclock.h"
 136 #include "ntp_calendar.h"
 137 #include "ntp_stdlib.h"
 138
 139 /**********************************************************************/
 140
 141 /*
 142  * Interface definitions
 143  */
 144 #define DEVICE          "/dev/jjy%d"    /* device name and unit */
 145 #define SPEED232_TRISTATE_JJY01         B9600   /* UART speed (9600 baud) */
 146 #define SPEED232_CDEX_JST2000           B9600   /* UART speed (9600 baud) */
 147 #define SPEED232_ECHOKEISOKUKI_LT2000   B9600   /* UART speed (9600 baud) */
 148 #define SPEED232_CITIZENTIC_JJY200      B4800   /* UART speed (4800 baud) */
 149 #define SPEED232_TRISTATE_GPSCLOCK01    B38400  /* USB  speed (38400 baud) */
 150 #define SPEED232_SEIKO_TIMESYS_TDC_300  B2400   /* UART speed (2400 baud) */
 151 #define SPEED232_TELEPHONE              B2400   /* UART speed (4800 baud) */
 152 #define REFID           "JJY"           /* reference ID */
 153 #define DESCRIPTION     "JJY Receiver"
 154 #define PRECISION       (-3)            /* precision assumed (about 100 ms) */
 155
 156 /*
 157  * JJY unit control structure
 158  */
 159
 160 struct jjyRawDataBreak {
 161         const char *    pString ;
 162         int             iLength ;
 163 } ;
 164
 165 #define MAX_TIMESTAMP   6
 166 #define MAX_RAWBUF      100
 167 #define MAX_LOOPBACK    5
 168
 169 struct jjyunit {
 170 /* Set up by the function "jjy_start_xxxxxxxx" */
 171         char    unittype ;          /* UNITTYPE_XXXXXXXXXX */
 172         short   operationmode ;     /* Echo Keisokuki LT-2000 */
 173         int     linespeed ;         /* SPEED232_XXXXXXXXXX */
 174         short   linediscipline ;    /* LDISC_CLK or LDISC_RAW */
 175 /* Receiving data */
 176         char    bInitError ;        /* Set by jjy_start if any error during initialization */
 177         short   iProcessState ;     /* JJY_PROCESS_STATE_XXXXXX */
 178         char    bReceiveFlag ;      /* Set and reset by jjy_receive */
 179         char    bLineError ;        /* Reset by jjy_poll / Set by jjy_receive_xxxxxxxx*/
 180         short   iCommandSeq ;       /* 0:Idle  Non-Zero:Issued */
 181         short   iReceiveSeq ;
 182         int     iLineCount ;
 183         int     year, month, day, hour, minute, second, msecond ;
 184         int     leapsecond ;
 185         int     iTimestampCount ;   /* TS-JJY01, TS-GPS01, Telephone-JJY */
 186         int     iTimestamp [ MAX_TIMESTAMP ] ;  /* Serial second ( 0 - 86399 ) */
 187 /* LDISC_RAW only */
 188         char    sRawBuf [ MAX_RAWBUF ] ;
 189         int     iRawBufLen ;
 190         struct  jjyRawDataBreak *pRawBreak ;
 191         char    bWaitBreakString ;
 192         char    sLineBuf [ MAX_RAWBUF ] ;
 193         int     iLineBufLen ;
 194         char    sTextBuf [ MAX_RAWBUF ] ;
 195         int     iTextBufLen ;
 196         char    bSkipCntrlCharOnly ;
 197 /* Telephone JJY auto measurement of the loopback delay */
 198         char    bLoopbackMode ;
 199         short   iLoopbackCount ;
 200         struct  timeval sendTime[MAX_LOOPBACK], delayTime[MAX_LOOPBACK] ;
 201         char    bLoopbackTimeout[MAX_LOOPBACK] ;
 202         short   iLoopbackValidCount ;
 203 /* Telephone JJY timer */
 204         short   iTeljjySilentTimer ;
 205         short   iTeljjyStateTimer ;
 206 /* Telephone JJY control finite state machine */
 207         short   iClockState ;
 208         short   iClockEvent ;
 209         short   iClockCommandSeq ;
 210 /* Modem timer */
 211         short   iModemSilentCount ;
 212         short   iModemSilentTimer ;
 213         short   iModemStateTimer ;
 214 /* Modem control finite state machine */
 215         short   iModemState ;
 216         short   iModemEvent ;
 217         short   iModemCommandSeq ;
 218 };
 219
 220 #define UNITTYPE_TRISTATE_JJY01         1
 221 #define UNITTYPE_CDEX_JST2000           2
 222 #define UNITTYPE_ECHOKEISOKUKI_LT2000   3
 223 #define UNITTYPE_CITIZENTIC_JJY200      4
 224 #define UNITTYPE_TRISTATE_GPSCLOCK01    5
 225 #define UNITTYPE_SEIKO_TIMESYS_TDC_300  6
 226 #define UNITTYPE_TELEPHONE              100
 227
 228 #define JJY_PROCESS_STATE_IDLE          0
 229 #define JJY_PROCESS_STATE_POLL          1
 230 #define JJY_PROCESS_STATE_RECEIVE       2
 231 #define JJY_PROCESS_STATE_DONE          3
 232 #define JJY_PROCESS_STATE_ERROR         4
 233
 234 /**********************************************************************/
 235
 236 /*
 237  *  Function calling structure
 238  *
 239  *  jjy_start
 240  *   |--  jjy_start_tristate_jjy01
 241  *   |--  jjy_start_cdex_jst2000
 242  *   |--  jjy_start_echokeisokuki_lt2000
 243  *   |--  jjy_start_citizentic_jjy200
 244  *   |--  jjy_start_tristate_gpsclock01
 245  *   |--  jjy_start_seiko_tsys_tdc_300
 246  *   |--  jjy_start_telephone
 247  *
 248  *  jjy_shutdown
 249  *
 250  *  jjy_poll
 251  *   |--  jjy_poll_tristate_jjy01
 252  *   |--  jjy_poll_cdex_jst2000
 253  *   |--  jjy_poll_echokeisokuki_lt2000
 254  *   |--  jjy_poll_citizentic_jjy200
 255  *   |--  jjy_poll_tristate_gpsclock01
 256  *   |--  jjy_poll_seiko_tsys_tdc_300
 257  *   |--  jjy_poll_telephone
 258  *         |--  teljjy_control
 259  *               |--  teljjy_XXXX_YYYY ( XXXX_YYYY is an event handler name. )
 260  *                     |--  modem_connect
 261  *                           |--  modem_control
 262  *                                 |--  modem_XXXX_YYYY ( XXXX_YYYY is an event handler name. )
 263  *
 264  *  jjy_receive
 265  *   |
 266  *   |--  jjy_receive_tristate_jjy01
 267  *   |     |--  jjy_synctime
 268  *   |--  jjy_receive_cdex_jst2000
 269  *   |     |--  jjy_synctime
 270  *   |--  jjy_receive_echokeisokuki_lt2000
 271  *   |     |--  jjy_synctime
 272  *   |--  jjy_receive_citizentic_jjy200
 273  *   |     |--  jjy_synctime
 274  *   |--  jjy_receive_tristate_gpsclock01
 275  *   |     |--  jjy_synctime
 276  *   |--  jjy_receive_seiko_tsys_tdc_300
 277  *   |     |--  jjy_synctime
 278  *   |--  jjy_receive_telephone
 279  *         |--  modem_receive
 280  *         |     |--  modem_control
 281  *         |           |--  modem_XXXX_YYYY ( XXXX_YYYY is an event handler name. )
 282  *         |--  teljjy_control
 283  *               |--  teljjy_XXXX_YYYY ( XXXX_YYYY is an event handler name. )
 284  *                     |--  jjy_synctime
 285  *                     |--  modem_disconnect
 286  *                           |--  modem_control
 287  *                                 |--  modem_XXXX_YYYY ( XXXX_YYYY is an event handler name. )
 288  *
 289  *  jjy_timer
 290  *   |--  jjy_timer_telephone
 291  *         |--  modem_timer
 292  *         |     |--  modem_control
 293  *         |           |--  modem_XXXX_YYYY ( XXXX_YYYY is an event handler name. )
 294  *         |--  teljjy_control
 295  *               |--  teljjy_XXXX_YYYY ( XXXX_YYYY is an event handler name. )
 296  *                     |--  modem_disconnect
 297  *                           |--  modem_control
 298  *                                 |--  modem_XXXX_YYYY ( XXXX_YYYY is an event handler name. )
 299  *
 300  * Function prototypes
 301  */
 302
 303 static  int     jjy_start                       (int, struct peer *);
 304 static  int     jjy_start_tristate_jjy01        (int, struct peer *, struct jjyunit *);
 305 static  int     jjy_start_cdex_jst2000          (int, struct peer *, struct jjyunit *);
 306 static  int     jjy_start_echokeisokuki_lt2000  (int, struct peer *, struct jjyunit *);
 307 static  int     jjy_start_citizentic_jjy200     (int, struct peer *, struct jjyunit *);
 308 static  int     jjy_start_tristate_gpsclock01   (int, struct peer *, struct jjyunit *);
 309 static  int     jjy_start_seiko_tsys_tdc_300    (int, struct peer *, struct jjyunit *);
 310 static  int     jjy_start_telephone             (int, struct peer *, struct jjyunit *);
 311
 312 static  void    jjy_shutdown                    (int, struct peer *);
 313
 314 static  void    jjy_poll                        (int, struct peer *);
 315 static  void    jjy_poll_tristate_jjy01         (int, struct peer *);
 316 static  void    jjy_poll_cdex_jst2000           (int, struct peer *);
 317 static  void    jjy_poll_echokeisokuki_lt2000   (int, struct peer *);
 318 static  void    jjy_poll_citizentic_jjy200      (int, struct peer *);
 319 static  void    jjy_poll_tristate_gpsclock01    (int, struct peer *);
 320 static  void    jjy_poll_seiko_tsys_tdc_300     (int, struct peer *);
 321 static  void    jjy_poll_telephone              (int, struct peer *);
 322
 323 static  void    jjy_receive                     (struct recvbuf *);
 324 static  int     jjy_receive_tristate_jjy01      (struct recvbuf *);
 325 static  int     jjy_receive_cdex_jst2000        (struct recvbuf *);
 326 static  int     jjy_receive_echokeisokuki_lt2000 (struct recvbuf *);
 327 static  int     jjy_receive_citizentic_jjy200   (struct recvbuf *);
 328 static  int     jjy_receive_tristate_gpsclock01 (struct recvbuf *);
 329 static  int     jjy_receive_seiko_tsys_tdc_300  (struct recvbuf *);
 330 static  int     jjy_receive_telephone           (struct recvbuf *);
 331
 332 static  void    jjy_timer                       (int, struct peer *);
 333 static  void    jjy_timer_telephone             (int, struct peer *);
 334
 335 static  void    jjy_synctime                    ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
 336 static  void    jjy_write_clockstats            ( struct peer *, int, const char* ) ;
 337
 338 static  int     getRawDataBreakPosition         ( struct jjyunit *, int ) ;
 339
 340 static  short   getModemState                   ( struct jjyunit * ) ;
 341 static  int     isModemStateConnect             ( short ) ;
 342 static  int     isModemStateDisconnect          ( short ) ;
 343 static  int     isModemStateTimerOn             ( struct jjyunit * ) ;
 344 static  void    modem_connect                   ( int, struct peer * ) ;
 345 static  void    modem_disconnect                ( int, struct peer * ) ;
 346 static  int     modem_receive                   ( struct recvbuf * ) ;
 347 static  void    modem_timer                     ( int, struct peer * );
 348
 349 static  void    printableString ( char*, int, const char*, int ) ;
 350
 351 /*
 352  * Transfer vector
 353  */
 354 struct  refclock refclock_jjy = {
 355         jjy_start,      /* start up driver */
 356         jjy_shutdown,   /* shutdown driver */
 357         jjy_poll,       /* transmit poll message */
 358         noentry,        /* not used */
 359         noentry,        /* not used */
 360         noentry,        /* not used */
 361         jjy_timer       /* 1 second interval timer */
 362 };
 363
 364 /*
 365  * Start up driver return code
 366  */
 367 #define RC_START_SUCCESS        1
 368 #define RC_START_ERROR          0
 369
 370 /*
 371  * Local constants definition
 372  */
 373
 374 #define MAX_LOGTEXT     100
 375
 376 #ifndef TRUE
 377 #define TRUE    (0==0)
 378 #endif
 379 #ifndef FALSE
 380 #define FALSE   (!TRUE)
 381 #endif
 382
 383 /* Local constants definition for the return code of the jjy_receive_xxxxxxxx */
 384
 385 #define JJY_RECEIVE_DONE        0
 386 #define JJY_RECEIVE_SKIP        1
 387 #define JJY_RECEIVE_UNPROCESS   2
 388 #define JJY_RECEIVE_WAIT        3
 389 #define JJY_RECEIVE_ERROR       4
 390
 391 /* Local constants definition for the 2nd parameter of the jjy_write_clockstats */
 392
 393 #define JJY_CLOCKSTATS_MARK_NONE        0
 394 #define JJY_CLOCKSTATS_MARK_JJY         1
 395 #define JJY_CLOCKSTATS_MARK_SEND        2
 396 #define JJY_CLOCKSTATS_MARK_RECEIVE     3
 397 #define JJY_CLOCKSTATS_MARK_INFORMATION 4
 398 #define JJY_CLOCKSTATS_MARK_ATTENTION   5
 399 #define JJY_CLOCKSTATS_MARK_WARNING     6
 400 #define JJY_CLOCKSTATS_MARK_ERROR       7
 401 #define JJY_CLOCKSTATS_MARK_BUG         8
 402
 403 /* Local constants definition for the clockstats messages */
 404
 405 #define JJY_CLOCKSTATS_MESSAGE_ECHOBACK                 "* Echoback"
 406 #define JJY_CLOCKSTATS_MESSAGE_IGNORE_REPLY             "* Ignore replay : [%s]"
 407 #define JJY_CLOCKSTATS_MESSAGE_OVER_MIDNIGHT_2          "* Over midnight : timestamp=%d, %d"
 408 #define JJY_CLOCKSTATS_MESSAGE_OVER_MIDNIGHT_3          "* Over midnight : timestamp=%d, %d, %d"
 409 #define JJY_CLOCKSTATS_MESSAGE_TIMESTAMP_UNSURE         "* Unsure timestamp : %s"
 410 #define JJY_CLOCKSTATS_MESSAGE_LOOPBACK_DELAY           "* Loopback delay : %d.%03d mSec."
 411 #define JJY_CLOCKSTATS_MESSAGE_DELAY_ADJUST             "* Delay adjustment : %d mSec. ( valid=%hd/%d )"
 412 #define JJY_CLOCKSTATS_MESSAGE_DELAY_UNADJUST           "* Delay adjustment : None ( valid=%hd/%d )"
 413
 414 #define JJY_CLOCKSTATS_MESSAGE_UNEXPECTED_REPLY         "# Unexpected reply : [%s]"
 415 #define JJY_CLOCKSTATS_MESSAGE_INVALID_LENGTH           "# Invalid length : length=%d"
 416 #define JJY_CLOCKSTATS_MESSAGE_TOO_MANY_REPLY           "# Too many reply : count=%d"
 417 #define JJY_CLOCKSTATS_MESSAGE_INVALID_REPLY            "# Invalid reply : [%s]"
 418 #define JJY_CLOCKSTATS_MESSAGE_SLOW_REPLY_2             "# Slow reply : timestamp=%d, %d"
 419 #define JJY_CLOCKSTATS_MESSAGE_SLOW_REPLY_3             "# Slow reply : timestamp=%d, %d, %d"
 420 #define JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_DATE      "# Invalid date : rc=%d year=%d month=%d day=%d"
 421 #define JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_TIME      "# Invalid time : rc=%d hour=%d minute=%d second=%d"
 422 #define JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_DATETIME  "# Invalid time : rc=%d year=%d month=%d day=%d hour=%d minute=%d second=%d"
 423 #define JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_LEAP      "# Invalid leap : leapsecond=[%s]"
 424 #define JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_STATUS    "# Invalid status : status=[%s]"
 425
 426 /* Debug print macro */
 427
 428 #ifdef  DEBUG
 429 #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 ) ; } }
 430 #else
 431 #define DEBUG_PRINTF_JJY_RECEIVE(sFunc,iLen)
 432 #endif
 433
 434 /**************************************************************************************************/
 435 /*  jjy_start - open the devices and initialize data for processing                               */
 436 /**************************************************************************************************/
 437 static int
 438 jjy_start ( int unit, struct peer *peer )
 439 {
 440
 441         struct  refclockproc *pp ;
 442         struct  jjyunit      *up ;
 443         int     rc ;
 444         int     fd ;
 445         char    sDeviceName [ sizeof(DEVICE) + 10 ], sLog [ 60 ] ;
 446
 447 #ifdef DEBUG
 448         if ( debug ) {
 449                 printf( "refclock_jjy.c : jjy_start : %s  mode=%d  dev=%s  unit=%d\n",
 450                          ntoa(&peer->srcadr), peer->ttl, DEVICE, unit ) ;
 451         }
 452 #endif
 453
 454         /* Allocate memory for the unit structure */
 455         up = emalloc( sizeof(*up) ) ;
 456         if ( up == NULL ) {
 457                 msyslog ( LOG_ERR, "refclock_jjy.c : jjy_start : emalloc" ) ;
 458                 return RC_START_ERROR ;
 459         }
 460         memset ( up, 0, sizeof(*up) ) ;
 461
 462         up->bInitError = FALSE ;
 463         up->iProcessState = JJY_PROCESS_STATE_IDLE ;
 464         up->bReceiveFlag = FALSE ;
 465         up->iCommandSeq = 0 ;
 466         up->iLineCount = 0 ;
 467         up->iTimestampCount = 0 ;
 468         up->bWaitBreakString = FALSE ;
 469         up->iRawBufLen = up->iLineBufLen = up->iTextBufLen = 0 ;
 470         up->bSkipCntrlCharOnly = TRUE ;
 471
 472         /* Set up the device name */
 473         snprintf( sDeviceName, sizeof(sDeviceName), DEVICE, unit ) ;
 474
 475         snprintf( sLog, sizeof(sLog), "mode=%d dev=%s", peer->ttl, sDeviceName ) ;
 476         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_JJY, sLog ) ;
 477
 478         /*
 479          * peer->ttl is a mode number specified by "127.127.40.X mode N" in the ntp.conf
 480          */
 481         switch ( peer->ttl ) {
 482         case 0 :
 483         case 1 :
 484                 rc = jjy_start_tristate_jjy01 ( unit, peer, up ) ;
 485                 break ;
 486         case 2 :
 487                 rc = jjy_start_cdex_jst2000 ( unit, peer, up ) ;
 488                 break ;
 489         case 3 :
 490                 rc = jjy_start_echokeisokuki_lt2000 ( unit, peer, up ) ;
 491                 break ;
 492         case 4 :
 493                 rc = jjy_start_citizentic_jjy200 ( unit, peer, up ) ;
 494                 break ;
 495         case 5 :
 496                 rc = jjy_start_tristate_gpsclock01 ( unit, peer, up ) ;
 497                 break ;
 498         case 6 :
 499                 rc = jjy_start_seiko_tsys_tdc_300 ( unit, peer, up ) ;
 500                 break ;
 501         case 100 :
 502                 rc = jjy_start_telephone ( unit, peer, up ) ;
 503                 break ;
 504         default :
 505                 if ( 101 <= peer->ttl && peer->ttl <= 180 ) {
 506                         rc = jjy_start_telephone ( unit, peer, up ) ;
 507                 } else {
 508                         msyslog ( LOG_ERR, "JJY receiver [ %s mode %d ] : Unsupported mode",
 509                                   ntoa(&peer->srcadr), peer->ttl ) ;
 510                         free ( (void*) up ) ;
 511                 return RC_START_ERROR ;
 512                 }
 513         }
 514
 515         if ( rc != 0 ) {
 516                 msyslog ( LOG_ERR, "JJY receiver [ %s mode %d ] : Initialize error",
 517                           ntoa(&peer->srcadr), peer->ttl ) ;
 518                 free ( (void*) up ) ;
 519                 return RC_START_ERROR ;
 520         }
 521
 522         /* Open the device */
 523         fd = refclock_open ( sDeviceName, up->linespeed, up->linediscipline ) ;
 524         if ( fd <= 0 ) {
 525                 free ( (void*) up ) ;
 526                 return RC_START_ERROR ;
 527         }
 528
 529         /*
 530          * Initialize variables
 531          */
 532         pp = peer->procptr ;
 533
 534         pp->clockdesc   = DESCRIPTION ;
 535         pp->unitptr       = up ;
 536         pp->io.clock_recv = jjy_receive ;
 537         pp->io.srcclock   = peer ;
 538         pp->io.datalen    = 0 ;
 539         pp->io.fd         = fd ;
 540         if ( ! io_addclock(&pp->io) ) {
 541                 close ( fd ) ;
 542                 pp->io.fd = -1 ;
 543                 free ( up ) ;
 544                 pp->unitptr = NULL ;
 545                 return RC_START_ERROR ;
 546         }
 547         memcpy( (char*)&pp->refid, REFID, strlen(REFID) ) ;
 548
 549         peer->precision = PRECISION ;
 550
 551         snprintf( sLog, sizeof(sLog), "minpoll=%d maxpoll=%d", peer->minpoll, peer->maxpoll ) ;
 552         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_JJY, sLog ) ;
 553
 554         return RC_START_SUCCESS ;
 555
 556 }
 557
 558 /**************************************************************************************************/
 559 /*  jjy_shutdown - shutdown the clock                                                             */
 560 /**************************************************************************************************/
 561 static void
 562 jjy_shutdown ( int unit, struct peer *peer )
 563 {
 564
 565         struct jjyunit      *up;
 566         struct refclockproc *pp;
 567
 568         char    sLog [ 60 ] ;
 569
 570         pp = peer->procptr ;
 571         up = pp->unitptr ;
 572         if ( -1 != pp->io.fd ) {
 573                 io_closeclock ( &pp->io ) ;
 574         }
 575         if ( NULL != up ) {
 576                 free ( up ) ;
 577         }
 578
 579         snprintf( sLog, sizeof(sLog), "JJY stopped. unit=%d mode=%d", unit, peer->ttl ) ;
 580         record_clock_stats( &peer->srcadr, sLog ) ;
 581
 582 }
 583
 584 /**************************************************************************************************/
 585 /*  jjy_receive - receive data from the serial interface                                          */
 586 /**************************************************************************************************/
 587 static void
 588 jjy_receive ( struct recvbuf *rbufp )
 589 {
 590 #ifdef DEBUG
 591         static const char *sFunctionName = "jjy_receive" ;
 592 #endif
 593
 594         struct jjyunit      *up ;
 595         struct refclockproc *pp ;
 596         struct peer         *peer;
 597
 598         l_fp    tRecvTimestamp;         /* arrival timestamp */
 599         int     rc ;
 600         char    *pBuf, sLogText [ MAX_LOGTEXT ] ;
 601         size_t  iLen, iCopyLen ;
 602         int     i, j, iReadRawBuf, iBreakPosition ;
 603
 604         /*
 605          * Initialize pointers and read the timecode and timestamp
 606          */
 607         peer = rbufp->recv_peer ;
 608         pp = peer->procptr ;
 609         up = pp->unitptr ;
 610
 611         /*
 612          * Get next input line
 613          */
 614         if ( up->linediscipline == LDISC_RAW ) {
 615
 616                 pp->lencode  = refclock_gtraw ( rbufp, pp->a_lastcode, BMAX-1, &tRecvTimestamp ) ;
 617                 /* 3rd argument can be BMAX, but the coverity scan tool claim "Memory - corruptions  (OVERRUN)" */
 618                 /* "a_lastcode" is defined as "char a_lastcode[BMAX]" in the ntp_refclock.h */
 619                 /* To avoid its claim, pass the value BMAX-1. */
 620
 621                 /*
 622                  * Append received charaters to temporary buffer
 623                  */
 624                 for ( i = 0 ;
 625                       i < pp->lencode && up->iRawBufLen < MAX_RAWBUF - 2 ;
 626                       i ++ , up->iRawBufLen ++ ) {
 627                         up->sRawBuf[up->iRawBufLen] = pp->a_lastcode[i] ;
 628                 }
 629                 up->sRawBuf[up->iRawBufLen] = 0 ;
 630
 631
 632         } else {
 633
 634                 pp->lencode  = refclock_gtlin ( rbufp, pp->a_lastcode, BMAX, &tRecvTimestamp ) ;
 635
 636         }
 637 #ifdef DEBUG
 638         printf( "\nrefclock_jjy.c : %s : Len=%d  ", sFunctionName, pp->lencode ) ;
 639         for ( i = 0 ; i < pp->lencode ; i ++ ) {
 640                 if ( iscntrl( (u_char)(pp->a_lastcode[i] & 0x7F) ) ) {
 641                         printf( "<x%02X>", pp->a_lastcode[i] & 0xFF ) ;
 642                 } else {
 643                         printf( "%c", pp->a_lastcode[i] ) ;
 644                 }
 645         }
 646         printf( "\n" ) ;
 647 #endif
 648
 649         /*
 650          * The reply with <CR><LF> gives a blank line
 651          */
 652
 653         if ( pp->lencode == 0 ) return ;
 654
 655         /*
 656          * Receiving data is not expected
 657          */
 658
 659         if ( up->iProcessState == JJY_PROCESS_STATE_IDLE
 660           || up->iProcessState == JJY_PROCESS_STATE_DONE
 661           || up->iProcessState == JJY_PROCESS_STATE_ERROR ) {
 662                 /* Discard received data */
 663                 up->iRawBufLen = 0 ;
 664 #ifdef DEBUG
 665                 if ( debug ) {
 666                         printf( "refclock_jjy.c : %s : Discard received data\n", sFunctionName ) ;
 667                 }
 668 #endif
 669                 return ;
 670         }
 671
 672         /*
 673          * We get down to business
 674          */
 675
 676         pp->lastrec = tRecvTimestamp ;
 677
 678         up->iLineCount ++ ;
 679
 680         up->iProcessState = JJY_PROCESS_STATE_RECEIVE ;
 681         up->bReceiveFlag = TRUE ;
 682
 683         iReadRawBuf = 0 ;
 684         iBreakPosition = up->iRawBufLen - 1 ;
 685         for ( ; up->iProcessState == JJY_PROCESS_STATE_RECEIVE ; ) {
 686
 687                 if ( up->linediscipline == LDISC_RAW ) {
 688
 689                         if ( up->bWaitBreakString ) {
 690                                 iBreakPosition = getRawDataBreakPosition( up, iReadRawBuf ) ;
 691                                 if ( iBreakPosition == -1 ) {
 692                                         /* Break string have not come yet */
 693                                         if ( up->iRawBufLen < MAX_RAWBUF - 2
 694                                           || iReadRawBuf > 0 ) {
 695                                                 /* Temporary buffer is not full */
 696                                                 break ;
 697                                         } else {
 698                                                 /* Temporary buffer is full */
 699                                                 iBreakPosition = up->iRawBufLen - 1 ;
 700                                         }
 701                                 }
 702                         } else {
 703                                 iBreakPosition = up->iRawBufLen - 1 ;
 704                         }
 705
 706                         /* Copy charaters from temporary buffer to process buffer */
 707                         up->iLineBufLen = up->iTextBufLen = 0 ;
 708                         for ( i = iReadRawBuf ; i <= iBreakPosition ; i ++ ) {
 709
 710                                 /* Copy all characters */
 711                                 up->sLineBuf[up->iLineBufLen] = up->sRawBuf[i] ;
 712                                 up->iLineBufLen ++ ;
 713
 714                                 /* Copy printable characters */
 715                                 if ( ! iscntrl( (u_char)up->sRawBuf[i] ) ) {
 716                                         up->sTextBuf[up->iTextBufLen] = up->sRawBuf[i] ;
 717                                         up->iTextBufLen ++ ;
 718                                 }
 719
 720                         }
 721                         up->sLineBuf[up->iLineBufLen] = 0 ;
 722                         up->sTextBuf[up->iTextBufLen] = 0 ;
 723 #ifdef DEBUG
 724                         printf( "refclock_jjy.c : %s : up->iLineBufLen=%d up->iTextBufLen=%d\n",
 725                                  sFunctionName, up->iLineBufLen, up->iTextBufLen ) ;
 726 #endif
 727
 728                         if ( up->bSkipCntrlCharOnly && up->iTextBufLen == 0 ) {
 729 #ifdef DEBUG
 730                                 printf( "refclock_jjy.c : %s : Skip cntrl char only : up->iRawBufLen=%d iReadRawBuf=%d iBreakPosition=%d\n",
 731                                          sFunctionName, up->iRawBufLen, iReadRawBuf, iBreakPosition ) ;
 732 #endif
 733                                 if ( iBreakPosition + 1 < up->iRawBufLen ) {
 734                                         iReadRawBuf = iBreakPosition + 1 ;
 735                                         continue ;
 736                                 } else {
 737                                         break ;
 738                                 }
 739
 740                         }
 741
 742                 }
 743
 744                 if ( up->linediscipline == LDISC_RAW ) {
 745                         pBuf = up->sLineBuf ;
 746                         iLen = up->iLineBufLen ;
 747                 } else {
 748                         pBuf = pp->a_lastcode ;
 749                         iLen = pp->lencode ;
 750                 }
 751
 752                 iCopyLen = ( iLen <= sizeof(sLogText)-1 ? iLen : sizeof(sLogText)-1 ) ;
 753                 memcpy( sLogText, pBuf, iCopyLen ) ;
 754                 sLogText[iCopyLen] = '\0' ;
 755                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_RECEIVE, sLogText ) ;
 756
 757                 switch ( up->unittype ) {
 758
 759                 case UNITTYPE_TRISTATE_JJY01 :
 760                         rc = jjy_receive_tristate_jjy01  ( rbufp ) ;
 761                         break ;
 762
 763                 case UNITTYPE_CDEX_JST2000 :
 764                         rc = jjy_receive_cdex_jst2000 ( rbufp ) ;
 765                         break ;
 766
 767                 case UNITTYPE_ECHOKEISOKUKI_LT2000 :
 768                         rc = jjy_receive_echokeisokuki_lt2000 ( rbufp ) ;
 769                         break ;
 770
 771                 case UNITTYPE_CITIZENTIC_JJY200 :
 772                         rc = jjy_receive_citizentic_jjy200 ( rbufp ) ;
 773                         break ;
 774
 775                 case UNITTYPE_TRISTATE_GPSCLOCK01 :
 776                         rc = jjy_receive_tristate_gpsclock01 ( rbufp ) ;
 777                         break ;
 778
 779                 case UNITTYPE_SEIKO_TIMESYS_TDC_300 :
 780                         rc = jjy_receive_seiko_tsys_tdc_300 ( rbufp ) ;
 781                         break ;
 782
 783                 case UNITTYPE_TELEPHONE :
 784                         rc = jjy_receive_telephone ( rbufp ) ;
 785                         break ;
 786
 787                 default :
 788                         rc = JJY_RECEIVE_ERROR ;
 789                         break ;
 790
 791                 }
 792
 793                 switch ( rc ) {
 794                 case JJY_RECEIVE_DONE :
 795                 case JJY_RECEIVE_SKIP :
 796                         up->iProcessState = JJY_PROCESS_STATE_DONE ;
 797                         break ;
 798                 case JJY_RECEIVE_ERROR :
 799                         up->iProcessState = JJY_PROCESS_STATE_ERROR ;
 800                         break ;
 801                 default :
 802                         break ;
 803                 }
 804
 805                 if ( up->linediscipline == LDISC_RAW ) {
 806                         if ( rc == JJY_RECEIVE_UNPROCESS ) {
 807                                 break ;
 808                         }
 809                         iReadRawBuf = iBreakPosition + 1 ;
 810                         if ( iReadRawBuf >= up->iRawBufLen ) {
 811                                 /* Processed all received data */
 812                                 break ;
 813                         }
 814                 }
 815
 816                 if ( up->linediscipline == LDISC_CLK ) {
 817                         break ;
 818                 }
 819
 820         }
 821
 822         if ( up->linediscipline == LDISC_RAW && iReadRawBuf > 0 ) {
 823                 for ( i = 0, j = iReadRawBuf ; j < up->iRawBufLen ; i ++, j++ ) {
 824                         up->sRawBuf[i] = up->sRawBuf[j] ;
 825                 }
 826                 up->iRawBufLen -= iReadRawBuf ;
 827                 if ( up->iRawBufLen < 0 ) {
 828                         up->iRawBufLen = 0 ;
 829                 }
 830         }
 831
 832         up->bReceiveFlag = FALSE ;
 833
 834 }
 835
 836 /**************************************************************************************************/
 837
 838 static int
 839 getRawDataBreakPosition ( struct jjyunit *up, int iStart )
 840 {
 841
 842         int     i, j ;
 843
 844         if ( iStart >= up->iRawBufLen ) {
 845 #ifdef DEBUG
 846                 printf( "refclock_jjy.c : getRawDataBreakPosition : iStart=%d return=-1\n", iStart ) ;
 847 #endif
 848                 return -1 ;
 849         }
 850
 851         for ( i = iStart ; i < up->iRawBufLen ; i ++ ) {
 852
 853                 for ( j = 0 ; up->pRawBreak[j].pString != NULL ; j ++ ) {
 854
 855                         if ( i + up->pRawBreak[j].iLength <= up->iRawBufLen ) {
 856
 857                                 if ( strncmp( up->sRawBuf + i,
 858                                         up->pRawBreak[j].pString,
 859                                         up->pRawBreak[j].iLength ) == 0 ) {
 860
 861 #ifdef DEBUG
 862                                         printf( "refclock_jjy.c : getRawDataBreakPosition : iStart=%d return=%d\n",
 863                                                 iStart, i + up->pRawBreak[j].iLength - 1 ) ;
 864 #endif
 865                                         return i + up->pRawBreak[j].iLength - 1 ;
 866
 867                                 }
 868                         }
 869                 }
 870         }
 871
 872 #ifdef DEBUG
 873         printf( "refclock_jjy.c : getRawDataBreakPosition : iStart=%d return=-1\n", iStart ) ;
 874 #endif
 875         return -1 ;
 876
 877 }
 878
 879 /**************************************************************************************************/
 880 /*  jjy_poll - called by the transmit procedure                                                   */
 881 /**************************************************************************************************/
 882 static void
 883 jjy_poll ( int unit, struct peer *peer )
 884 {
 885
 886         char    sLog [ 40 ], sReach [ 9 ] ;
 887
 888         struct jjyunit      *up;
 889         struct refclockproc *pp;
 890
 891         pp = peer->procptr;
 892         up = pp->unitptr ;
 893
 894         if ( up->bInitError ) {
 895                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, "Ignore polling because of error during initializing" ) ;
 896                 return ;
 897         }
 898
 899         if ( pp->polls > 0  &&  up->iLineCount == 0 ) {
 900                 /*
 901                  * No reply for last command
 902                  */
 903                 refclock_report ( peer, CEVNT_TIMEOUT ) ;
 904         }
 905
 906         pp->polls ++ ;
 907
 908         sReach[0] = peer->reach & 0x80 ? '1' : '0' ;
 909         sReach[1] = peer->reach & 0x40 ? '1' : '0' ;
 910         sReach[2] = peer->reach & 0x20 ? '1' : '0' ;
 911         sReach[3] = peer->reach & 0x10 ? '1' : '0' ;
 912         sReach[4] = peer->reach & 0x08 ? '1' : '0' ;
 913         sReach[5] = peer->reach & 0x04 ? '1' : '0' ;
 914         sReach[6] = peer->reach & 0x02 ? '1' : '0' ;
 915         sReach[7] = 0 ; /* This poll */
 916         sReach[8] = 0 ;
 917
 918         snprintf( sLog, sizeof(sLog), "polls=%ld reach=%s", pp->polls, sReach ) ;
 919         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ATTENTION, sLog ) ;
 920
 921         up->iProcessState = JJY_PROCESS_STATE_POLL ;
 922         up->iCommandSeq = 0 ;
 923         up->iReceiveSeq = 0 ;
 924         up->iLineCount = 0 ;
 925         up->bLineError = FALSE ;
 926         up->iRawBufLen = 0 ;
 927
 928         switch ( up->unittype ) {
 929
 930         case UNITTYPE_TRISTATE_JJY01 :
 931                 jjy_poll_tristate_jjy01  ( unit, peer ) ;
 932                 break ;
 933
 934         case UNITTYPE_CDEX_JST2000 :
 935                 jjy_poll_cdex_jst2000 ( unit, peer ) ;
 936                 break ;
 937
 938         case UNITTYPE_ECHOKEISOKUKI_LT2000 :
 939                 jjy_poll_echokeisokuki_lt2000 ( unit, peer ) ;
 940                 break ;
 941
 942         case UNITTYPE_CITIZENTIC_JJY200 :
 943                 jjy_poll_citizentic_jjy200 ( unit, peer ) ;
 944                 break ;
 945
 946         case UNITTYPE_TRISTATE_GPSCLOCK01 :
 947                 jjy_poll_tristate_gpsclock01 ( unit, peer ) ;
 948                 break ;
 949
 950         case UNITTYPE_SEIKO_TIMESYS_TDC_300 :
 951                 jjy_poll_seiko_tsys_tdc_300 ( unit, peer ) ;
 952                 break ;
 953
 954         case UNITTYPE_TELEPHONE :
 955                 jjy_poll_telephone ( unit, peer ) ;
 956                 break ;
 957
 958         default :
 959                 break ;
 960
 961         }
 962
 963 }
 964
 965 /**************************************************************************************************/
 966 /*  jjy_timer - called at one-second intervals                                                    */
 967 /**************************************************************************************************/
 968 static void
 969 jjy_timer ( int unit, struct peer *peer )
 970 {
 971
 972         struct  refclockproc *pp ;
 973         struct  jjyunit      *up ;
 974
 975 #ifdef DEBUG
 976         if ( debug ) {
 977                 printf ( "refclock_jjy.c : jjy_timer\n" ) ;
 978         }
 979 #endif
 980
 981         pp = peer->procptr ;
 982         up = pp->unitptr ;
 983
 984         if ( up->bReceiveFlag ) {
 985 #ifdef DEBUG
 986                 if ( debug ) {
 987                         printf ( "refclock_jjy.c : jjy_timer : up->bReceiveFlag= TRUE : Timer skipped.\n" ) ;
 988                 }
 989 #endif
 990                 return ;
 991         }
 992
 993         switch ( up->unittype ) {
 994
 995         case UNITTYPE_TELEPHONE :
 996                 jjy_timer_telephone ( unit, peer ) ;
 997                 break ;
 998
 999         default :
1000                 break ;
1001
1002         }
1003
1004 }
1005
1006 /**************************************************************************************************/
1007 /*  jjy_synctime                                                                                  */
1008 /**************************************************************************************************/
1009 static void
1010 jjy_synctime ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
1011 {
1012
1013         char    sLog [ 80 ], cStatus ;
1014         const char      *pStatus ;
1015
1016         pp->year   = up->year ;
1017         pp->day    = ymd2yd( up->year, up->month, up->day ) ;
1018         pp->hour   = up->hour ;
1019         pp->minute = up->minute ;
1020         pp->second = up->second ;
1021         pp->nsec   = up->msecond * 1000000 ;
1022
1023         /*
1024          * JST to UTC
1025          */
1026         pp->hour -= 9 ;
1027         if ( pp->hour < 0 ) {
1028                 pp->hour += 24 ;
1029                 pp->day -- ;
1030                 if ( pp->day < 1 ) {
1031                         pp->year -- ;
1032                         pp->day  = ymd2yd( pp->year, 12, 31 ) ;
1033                 }
1034         }
1035
1036         /*
1037          * Process the new sample in the median filter and determine the
1038          * timecode timestamp.
1039          */
1040
1041         if ( ! refclock_process( pp ) ) {
1042                 refclock_report( peer, CEVNT_BADTIME ) ;
1043                 return ;
1044         }
1045
1046         pp->lastref = pp->lastrec ;
1047
1048         refclock_receive( peer ) ;
1049
1050         /*
1051          * Write into the clockstats file
1052          */
1053         snprintf ( sLog, sizeof(sLog),
1054                    "%04d/%02d/%02d %02d:%02d:%02d.%03d JST   ( %04d/%03d %02d:%02d:%02d.%03d UTC )",
1055                    up->year, up->month, up->day,
1056                    up->hour, up->minute, up->second, up->msecond,
1057                    pp->year, pp->day, pp->hour, pp->minute, pp->second,
1058                    (int)(pp->nsec/1000000) ) ;
1059         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ATTENTION, sLog ) ;
1060
1061         cStatus = ' ' ;
1062         pStatus = "" ;
1063
1064         switch ( peer->status ) {
1065         case 0 : cStatus = ' ' ; pStatus = "Reject"    ; break ;
1066         case 1 : cStatus = 'x' ; pStatus = "FalseTick" ; break ;
1067         case 2 : cStatus = '.' ; pStatus = "Excess"    ; break ;
1068         case 3 : cStatus = '-' ; pStatus = "Outlier"   ; break ;
1069         case 4 : cStatus = '+' ; pStatus = "Candidate" ; break ;
1070         case 5 : cStatus = '#' ; pStatus = "Selected"  ; break ;
1071         case 6 : cStatus = '*' ; pStatus = "Sys.Peer"  ; break ;
1072         case 7 : cStatus = 'o' ; pStatus = "PPS.Peer"  ; break ;
1073         default : break ;
1074         }
1075
1076         snprintf ( sLog, sizeof(sLog),
1077                    "status %d [%c] %s : offset %3.3f mSec. : jitter %3.3f mSec.",
1078                     peer->status, cStatus, pStatus, peer->offset * 1000, peer->jitter * 1000 ) ;
1079         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_INFORMATION, sLog ) ;
1080
1081 }
1082
1083 /*################################################################################################*/
1084 /*################################################################################################*/
1085 /*##                                                                                            ##*/
1086 /*##    The Tristate Ltd. JJY receiver TS-JJY01, TS-JJY02                                       ##*/
1087 /*##                                                                                            ##*/
1088 /*##    server  127.127.40.X  mode 1                                                            ##*/
1089 /*##                                                                                            ##*/
1090 /*################################################################################################*/
1091 /*################################################################################################*/
1092 /*                                                                                                */
1093 /*  Command               Response                                  Remarks                       */
1094 /*  --------------------  ----------------------------------------  ----------------------------  */
1095 /*  dcst<CR><LF>          VALID<CR><LF> or INVALID<CR><LF>                                        */
1096 /*  stus<CR><LF>          ADJUSTED<CR><LF> or UNADJUSTED<CR><LF>                                  */
1097 /*  date<CR><LF>          YYYY/MM/DD XXX<CR><LF>                    XXX is the day of the week    */
1098 /*  time<CR><LF>          HH:MM:SS<CR><LF>                          Not used by this driver       */
1099 /*  stim<CR><LF>          HH:MM:SS<CR><LF>                          Reply at just second          */
1100 /*                                                                                                */
1101 /*################################################################################################*/
1102
1103 #define TS_JJY01_COMMAND_NUMBER_DATE    1
1104 #define TS_JJY01_COMMAND_NUMBER_TIME    2
1105 #define TS_JJY01_COMMAND_NUMBER_STIM    3
1106 #define TS_JJY01_COMMAND_NUMBER_STUS    4
1107 #define TS_JJY01_COMMAND_NUMBER_DCST    5
1108
1109 #define TS_JJY01_REPLY_DATE             "yyyy/mm/dd www"
1110 #define TS_JJY01_REPLY_STIM             "hh:mm:ss"
1111 #define TS_JJY01_REPLY_STUS_ADJUSTED    "adjusted"
1112 #define TS_JJY01_REPLY_STUS_UNADJUSTED  "unadjusted"
1113 #define TS_JJY01_REPLY_DCST_VALID       "valid"
1114 #define TS_JJY01_REPLY_DCST_INVALID     "invalid"
1115
1116 #define TS_JJY01_REPLY_LENGTH_DATE              14      /* Length without <CR><LF> */
1117 #define TS_JJY01_REPLY_LENGTH_TIME              8       /* Length without <CR><LF> */
1118 #define TS_JJY01_REPLY_LENGTH_STIM              8       /* Length without <CR><LF> */
1119 #define TS_JJY01_REPLY_LENGTH_STUS_ADJUSTED     8       /* Length without <CR><LF> */
1120 #define TS_JJY01_REPLY_LENGTH_STUS_UNADJUSTED   10      /* Length without <CR><LF> */
1121 #define TS_JJY01_REPLY_LENGTH_DCST_VALID        5       /* Length without <CR><LF> */
1122 #define TS_JJY01_REPLY_LENGTH_DCST_INVALID      7       /* Length without <CR><LF> */
1123
1124 static  struct
1125 {
1126         const char      commandNumber ;
1127         const char      *command ;
1128         int     commandLength ;
1129         int     iExpectedReplyLength [ 2 ] ;
1130 } tristate_jjy01_command_sequence[] =
1131 {
1132         { 0, NULL, 0, { 0, 0 } }, /* Idle */
1133         { TS_JJY01_COMMAND_NUMBER_DCST, "dcst\r\n", 6, { TS_JJY01_REPLY_LENGTH_DCST_VALID   , TS_JJY01_REPLY_LENGTH_DCST_INVALID } },
1134         { TS_JJY01_COMMAND_NUMBER_STUS, "stus\r\n", 6, { TS_JJY01_REPLY_LENGTH_STUS_ADJUSTED, TS_JJY01_REPLY_LENGTH_STUS_UNADJUSTED } },
1135         { TS_JJY01_COMMAND_NUMBER_TIME, "time\r\n", 6, { TS_JJY01_REPLY_LENGTH_TIME         , TS_JJY01_REPLY_LENGTH_TIME } },
1136         { TS_JJY01_COMMAND_NUMBER_DATE, "date\r\n", 6, { TS_JJY01_REPLY_LENGTH_DATE         , TS_JJY01_REPLY_LENGTH_DATE } },
1137         { TS_JJY01_COMMAND_NUMBER_STIM, "stim\r\n", 6, { TS_JJY01_REPLY_LENGTH_STIM         , TS_JJY01_REPLY_LENGTH_STIM } },
1138         /* End of command */
1139         { 0, NULL, 0, { 0, 0 } }
1140 } ;
1141
1142 /**************************************************************************************************/
1143
1144 static int
1145 jjy_start_tristate_jjy01 ( int unit, struct peer *peer, struct jjyunit *up )
1146 {
1147
1148         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_JJY, "Refclock: Tristate Ltd. TS-JJY01, TS-JJY02" ) ;
1149
1150         up->unittype  = UNITTYPE_TRISTATE_JJY01 ;
1151         up->linespeed = SPEED232_TRISTATE_JJY01 ;
1152         up->linediscipline = LDISC_CLK ;
1153
1154         return 0 ;
1155
1156 }
1157
1158 /**************************************************************************************************/
1159
1160 static int
1161 jjy_receive_tristate_jjy01 ( struct recvbuf *rbufp )
1162 {
1163         struct jjyunit      *up ;
1164         struct refclockproc *pp ;
1165         struct peer         *peer;
1166
1167         char *          pBuf ;
1168         char            sLog [ 100 ] ;
1169         int             iLen ;
1170         int             rc ;
1171
1172         const char *    pCmd ;
1173         int             iCmdLen ;
1174
1175         /* Initialize pointers  */
1176
1177         peer = rbufp->recv_peer ;
1178         pp = peer->procptr ;
1179         up = pp->unitptr ;
1180
1181         if ( up->linediscipline == LDISC_RAW ) {
1182                 pBuf = up->sTextBuf ;
1183                 iLen = up->iTextBufLen ;
1184         } else {
1185                 pBuf = pp->a_lastcode ;
1186                 iLen = pp->lencode ;
1187         }
1188
1189         DEBUG_PRINTF_JJY_RECEIVE( "jjy_receive_tristate_jjy01", iLen ) ;
1190
1191         /* Check expected reply */
1192
1193         if ( tristate_jjy01_command_sequence[up->iCommandSeq].command == NULL ) {
1194                 /* Command sequence has not been started, or has been completed */
1195                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_UNEXPECTED_REPLY,
1196                           pBuf ) ;
1197                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1198                 up->bLineError = TRUE ;
1199                 return JJY_RECEIVE_ERROR ;
1200         }
1201
1202         /* Check reply length */
1203
1204         if ( iLen != tristate_jjy01_command_sequence[up->iCommandSeq].iExpectedReplyLength[0]
1205           && iLen != tristate_jjy01_command_sequence[up->iCommandSeq].iExpectedReplyLength[1] ) {
1206                 /* Unexpected reply length */
1207                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_INVALID_LENGTH,
1208                           iLen ) ;
1209                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1210                 up->bLineError = TRUE ;
1211                 return JJY_RECEIVE_ERROR ;
1212         }
1213
1214         /* Parse reply */
1215
1216         switch ( tristate_jjy01_command_sequence[up->iCommandSeq].commandNumber ) {
1217
1218         case TS_JJY01_COMMAND_NUMBER_DATE : /* YYYY/MM/DD WWW */
1219
1220                 rc = sscanf ( pBuf, "%4d/%2d/%2d",
1221                               &up->year, &up->month, &up->day ) ;
1222
1223                 if ( rc != 3 || up->year < 2000 || 2099 <= up->year
1224                   || up->month < 1 || 12 < up->month
1225                   || up->day < 1 || 31 < up->day ) {
1226                         /* Invalid date */
1227                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_DATE,
1228                                   rc, up->year, up->month, up->day ) ;
1229                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1230                         up->bLineError = TRUE ;
1231                         return JJY_RECEIVE_ERROR ;
1232                 }
1233
1234                 break ;
1235
1236         case TS_JJY01_COMMAND_NUMBER_TIME : /* HH:MM:SS */
1237         case TS_JJY01_COMMAND_NUMBER_STIM : /* HH:MM:SS */
1238
1239                 if ( up->iTimestampCount >= 2 ) {
1240                         /* Too many time reply */
1241                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_TOO_MANY_REPLY,
1242                                   up->iTimestampCount ) ;
1243                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1244                         up->bLineError = TRUE ;
1245                         return JJY_RECEIVE_ERROR ;
1246                 }
1247
1248                 rc = sscanf ( pBuf, "%2d:%2d:%2d",
1249                               &up->hour, &up->minute, &up->second ) ;
1250
1251                 if ( rc != 3 || up->hour > 23 || up->minute > 59 ||
1252                      up->second > 60 ) {
1253                         /* Invalid time */
1254                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_TIME,
1255                                   rc, up->hour, up->minute, up->second ) ;
1256                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1257                         up->bLineError = TRUE ;
1258                         return JJY_RECEIVE_ERROR ;
1259                 }
1260
1261                 up->iTimestamp[up->iTimestampCount] = ( up->hour * 60 + up->minute ) * 60 + up->second ;
1262
1263                 up->iTimestampCount++ ;
1264
1265                 up->msecond = 0 ;
1266
1267                 break ;
1268
1269         case TS_JJY01_COMMAND_NUMBER_STUS :
1270
1271                 if ( strncmp( pBuf, TS_JJY01_REPLY_STUS_ADJUSTED,
1272                              TS_JJY01_REPLY_LENGTH_STUS_ADJUSTED ) == 0
1273                   || strncmp( pBuf, TS_JJY01_REPLY_STUS_UNADJUSTED,
1274                              TS_JJY01_REPLY_LENGTH_STUS_UNADJUSTED ) == 0 ) {
1275                         /* Good */
1276                 } else {
1277                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_INVALID_REPLY,
1278                                   pBuf ) ;
1279                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1280                         up->bLineError = TRUE ;
1281                         return JJY_RECEIVE_ERROR ;
1282                 }
1283
1284                 break ;
1285
1286         case TS_JJY01_COMMAND_NUMBER_DCST :
1287
1288                 if ( strncmp( pBuf, TS_JJY01_REPLY_DCST_VALID,
1289                              TS_JJY01_REPLY_LENGTH_DCST_VALID ) == 0
1290                   || strncmp( pBuf, TS_JJY01_REPLY_DCST_INVALID,
1291                              TS_JJY01_REPLY_LENGTH_DCST_INVALID ) == 0 ) {
1292                         /* Good */
1293                 } else {
1294                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_INVALID_REPLY,
1295                                   pBuf ) ;
1296                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1297                         up->bLineError = TRUE ;
1298                         return JJY_RECEIVE_ERROR ;
1299                 }
1300
1301                 break ;
1302
1303         default : /*  Unexpected reply */
1304
1305                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_INVALID_REPLY,
1306                           pBuf ) ;
1307                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1308                 up->bLineError = TRUE ;
1309                 return JJY_RECEIVE_ERROR ;
1310
1311         }
1312
1313         if ( up->iTimestampCount == 2 ) {
1314                 /* Process date and time */
1315
1316                 if ( up->iTimestamp[1] - 2 <= up->iTimestamp[0]
1317                   && up->iTimestamp[0]     <= up->iTimestamp[1] ) {
1318                         /* 3 commands (time,date,stim) was excuted in two seconds */
1319                         jjy_synctime( peer, pp, up ) ;
1320                         return JJY_RECEIVE_DONE ;
1321                 } else if ( up->iTimestamp[0] > up->iTimestamp[1] ) {
1322                         /* Over midnight, and date is unsure */
1323                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_OVER_MIDNIGHT_2,
1324                                   up->iTimestamp[0], up->iTimestamp[1] ) ;
1325                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_INFORMATION, sLog ) ;
1326                         return JJY_RECEIVE_SKIP ;
1327                 } else {
1328                         /* Slow reply */
1329                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_SLOW_REPLY_2,
1330                                   up->iTimestamp[0], up->iTimestamp[1] ) ;
1331                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1332                         up->bLineError = TRUE ;
1333                         return JJY_RECEIVE_ERROR ;
1334                 }
1335
1336         }
1337
1338         /* Issue next command */
1339
1340         if ( tristate_jjy01_command_sequence[up->iCommandSeq].command != NULL ) {
1341                 up->iCommandSeq ++ ;
1342         }
1343
1344         if ( tristate_jjy01_command_sequence[up->iCommandSeq].command == NULL ) {
1345                 /* Command sequence completed */
1346                 return JJY_RECEIVE_DONE ;
1347         }
1348
1349         pCmd =  tristate_jjy01_command_sequence[up->iCommandSeq].command ;
1350         iCmdLen = tristate_jjy01_command_sequence[up->iCommandSeq].commandLength ;
1351         if ( write ( pp->io.fd, pCmd, iCmdLen ) != iCmdLen ) {
1352                 refclock_report ( peer, CEVNT_FAULT ) ;
1353         }
1354
1355         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_SEND, pCmd ) ;
1356
1357         return JJY_RECEIVE_WAIT ;
1358
1359 }
1360
1361 /**************************************************************************************************/
1362
1363 static void
1364 jjy_poll_tristate_jjy01  ( int unit, struct peer *peer )
1365 {
1366 #ifdef DEBUG
1367         static const char *sFunctionName = "jjy_poll_tristate_jjy01" ;
1368 #endif
1369
1370         struct refclockproc *pp ;
1371         struct jjyunit      *up ;
1372
1373         const char *    pCmd ;
1374         int             iCmdLen ;
1375
1376         pp = peer->procptr;
1377         up = pp->unitptr ;
1378
1379         up->bLineError = FALSE ;
1380         up->iTimestampCount = 0 ;
1381
1382         if ( ( pp->sloppyclockflag & CLK_FLAG1 ) == 0 ) {
1383                 /* Skip "dcst" and "stus" commands */
1384                 up->iCommandSeq = 2 ;
1385                 up->iLineCount = 2 ;
1386         }
1387
1388 #ifdef DEBUG
1389         if ( debug ) {
1390                 printf ( "%s (refclock_jjy.c) : flag1=%X CLK_FLAG1=%X up->iLineCount=%d\n",
1391                         sFunctionName, pp->sloppyclockflag, CLK_FLAG1,
1392                         up->iLineCount ) ;
1393         }
1394 #endif
1395
1396         /*
1397          * Send a first command
1398          */
1399
1400         up->iCommandSeq ++ ;
1401
1402         pCmd =  tristate_jjy01_command_sequence[up->iCommandSeq].command ;
1403         iCmdLen = tristate_jjy01_command_sequence[up->iCommandSeq].commandLength ;
1404         if ( write ( pp->io.fd, pCmd, iCmdLen ) != iCmdLen ) {
1405                 refclock_report ( peer, CEVNT_FAULT ) ;
1406         }
1407
1408         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_SEND, pCmd ) ;
1409
1410 }
1411
1412 /*################################################################################################*/
1413 /*################################################################################################*/
1414 /*##                                                                                            ##*/
1415 /*##    The C-DEX Co. Ltd. JJY receiver JST2000                                                 ##*/
1416 /*##                                                                                            ##*/
1417 /*##    server  127.127.40.X  mode 2                                                            ##*/
1418 /*##                                                                                            ##*/
1419 /*################################################################################################*/
1420 /*################################################################################################*/
1421 /*                                                                                                */
1422 /*  Command               Response                                  Remarks                       */
1423 /*  --------------------  ----------------------------------------  ----------------------------  */
1424 /*  <ENQ>1J<ETX>          <STX>JYYMMDD HHMMSSS<ETX>                 J is a fixed character        */
1425 /*                                                                                                */
1426 /*################################################################################################*/
1427
1428 static struct jjyRawDataBreak cdex_jst2000_raw_break [ ] =
1429 {
1430         { "\x03", 1 }, { NULL, 0 }
1431 } ;
1432
1433 /**************************************************************************************************/
1434
1435 static int
1436 jjy_start_cdex_jst2000 ( int unit, struct peer *peer, struct jjyunit *up )
1437 {
1438
1439         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_JJY, "Refclock: C-DEX Co. Ltd. JST2000" ) ;
1440
1441         up->unittype  = UNITTYPE_CDEX_JST2000 ;
1442         up->linespeed = SPEED232_CDEX_JST2000 ;
1443         up->linediscipline = LDISC_RAW ;
1444
1445         up->pRawBreak = cdex_jst2000_raw_break ;
1446         up->bWaitBreakString = TRUE ;
1447
1448         up->bSkipCntrlCharOnly = FALSE ;
1449
1450         return 0 ;
1451
1452 }
1453
1454 /**************************************************************************************************/
1455
1456 static int
1457 jjy_receive_cdex_jst2000 ( struct recvbuf *rbufp )
1458 {
1459
1460         struct jjyunit      *up ;
1461         struct refclockproc *pp ;
1462         struct peer         *peer ;
1463
1464         char    *pBuf, sLog [ 100 ] ;
1465         int     iLen ;
1466         int     rc ;
1467
1468         /* Initialize pointers */
1469
1470         peer = rbufp->recv_peer ;
1471         pp = peer->procptr ;
1472         up = pp->unitptr ;
1473
1474         if ( up->linediscipline == LDISC_RAW ) {
1475                 pBuf = up->sTextBuf ;
1476                 iLen = up->iTextBufLen ;
1477         } else {
1478                 pBuf = pp->a_lastcode ;
1479                 iLen = pp->lencode ;
1480         }
1481
1482         DEBUG_PRINTF_JJY_RECEIVE( "jjy_receive_cdex_jst2000", iLen ) ;
1483
1484         /* Check expected reply */
1485
1486         if ( up->iCommandSeq != 1 ) {
1487                 /* Command sequence has not been started, or has been completed */
1488                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_UNEXPECTED_REPLY,
1489                           pBuf ) ;
1490                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1491                 up->bLineError = TRUE ;
1492                 return JJY_RECEIVE_ERROR ;
1493         }
1494
1495         /* Wait until ETX comes */
1496
1497         if ( up->iLineBufLen < 17 || up->sLineBuf[up->iLineBufLen-1] != 0x03 ) {
1498                 return JJY_RECEIVE_UNPROCESS ;
1499         }
1500
1501         /* Check reply length */
1502
1503         if ( iLen != 15 ) {
1504                 /* Unexpected reply length */
1505                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_INVALID_LENGTH,
1506                           iLen ) ;
1507                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1508                 up->bLineError = TRUE ;
1509                 return JJY_RECEIVE_ERROR ;
1510         }
1511
1512         /* JYYMMDDWHHMMSSS */
1513
1514         rc = sscanf ( pBuf, "J%2d%2d%2d%*1d%2d%2d%2d%1d",
1515                       &up->year, &up->month, &up->day,
1516                       &up->hour, &up->minute, &up->second,
1517                       &up->msecond ) ;
1518
1519         if ( rc != 7 || up->month < 1 || up->month > 12 ||
1520              up->day < 1 || up->day > 31 || up->hour > 23 ||
1521              up->minute > 59 || up->second > 60 ) {
1522                 /* Invalid date and time */
1523                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_DATETIME,
1524                           rc, up->year, up->month, up->day,
1525                           up->hour, up->minute, up->second ) ;
1526                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1527                 up->bLineError = TRUE ;
1528                 return JJY_RECEIVE_ERROR ;
1529         }
1530
1531         up->year    += 2000 ;
1532         up->msecond *= 100 ;
1533
1534         jjy_synctime( peer, pp, up ) ;
1535
1536         return JJY_RECEIVE_DONE ;
1537
1538 }
1539
1540 /**************************************************************************************************/
1541
1542 static void
1543 jjy_poll_cdex_jst2000 ( int unit, struct peer *peer )
1544 {
1545
1546         struct refclockproc *pp ;
1547         struct jjyunit      *up ;
1548
1549         pp = peer->procptr ;
1550         up = pp->unitptr ;
1551
1552         up->bLineError = FALSE ;
1553         up->iRawBufLen = 0 ;
1554         up->iLineBufLen = 0 ;
1555         up->iTextBufLen = 0 ;
1556
1557         /*
1558          * Send "<ENQ>1J<ETX>" command
1559          */
1560
1561         up->iCommandSeq ++ ;
1562
1563         if ( write ( pp->io.fd, "\0051J\003", 4 ) != 4  ) {
1564                 refclock_report ( peer, CEVNT_FAULT ) ;
1565         }
1566
1567         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_SEND, "\0051J\003" ) ;
1568
1569 }
1570
1571 /*################################################################################################*/
1572 /*################################################################################################*/
1573 /*##                                                                                            ##*/
1574 /*##    The Echo Keisokuki Co. Ltd. JJY receiver LT2000                                         ##*/
1575 /*##                                                                                            ##*/
1576 /*##    server  127.127.40.X  mode 3                                                            ##*/
1577 /*##                                                                                            ##*/
1578 /*################################################################################################*/
1579 /*################################################################################################*/
1580 /*                                                                                                */
1581 /*  Command               Response                                  Remarks                       */
1582 /*  --------------------  ----------------------------------------  ----------------------------  */
1583 /*  #                                                               Mode 1 ( Request & Send )     */
1584 /*  T                     YYMMDDWHHMMSS<BCC1><BCC2><CR>                                           */
1585 /*  C                                                               Mode 2 ( Continuous )         */
1586 /*                        YYMMDDWHHMMSS<ST1><ST2><ST3><ST4><CR>     0.5 sec before time stamp     */
1587 /*                        <SUB>                                     Second signal                 */
1588 /*                                                                                                */
1589 /*################################################################################################*/
1590
1591 #define ECHOKEISOKUKI_LT2000_MODE_REQUEST_SEND          1
1592 #define ECHOKEISOKUKI_LT2000_MODE_CONTINUOUS            2
1593 #define ECHOKEISOKUKI_LT2000_MODE_SWITCHING_CONTINUOUS  3
1594
1595 #define ECHOKEISOKUKI_LT2000_COMMAND_REQUEST_SEND       "#"
1596 #define ECHOKEISOKUKI_LT2000_COMMAND_REQUEST_TIME       "T"
1597 #define ECHOKEISOKUKI_LT2000_COMMAND_CONTINUOUS         "C"
1598
1599 /**************************************************************************************************/
1600
1601 static int
1602 jjy_start_echokeisokuki_lt2000 ( int unit, struct peer *peer, struct jjyunit *up )
1603 {
1604
1605         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_JJY, "Refclock: Echo Keisokuki Co. Ltd. LT2000" ) ;
1606
1607         up->unittype  = UNITTYPE_ECHOKEISOKUKI_LT2000 ;
1608         up->linespeed = SPEED232_ECHOKEISOKUKI_LT2000 ;
1609         up->linediscipline = LDISC_CLK ;
1610
1611         up->operationmode = ECHOKEISOKUKI_LT2000_MODE_SWITCHING_CONTINUOUS ;
1612
1613         return 0 ;
1614
1615 }
1616
1617 /**************************************************************************************************/
1618
1619 static int
1620 jjy_receive_echokeisokuki_lt2000 ( struct recvbuf *rbufp )
1621 {
1622
1623         struct jjyunit      *up ;
1624         struct refclockproc *pp ;
1625         struct peer         *peer;
1626
1627         char    *pBuf, sLog [ 100 ], sErr [ 60 ] ;
1628         int     iLen ;
1629         int     rc ;
1630         int     i, ibcc, ibcc1, ibcc2 ;
1631
1632         /* Initialize pointers */
1633
1634         peer = rbufp->recv_peer ;
1635         pp = peer->procptr ;
1636         up = pp->unitptr ;
1637
1638         if ( up->linediscipline == LDISC_RAW ) {
1639                 pBuf = up->sTextBuf ;
1640                 iLen = up->iTextBufLen ;
1641         } else {
1642                 pBuf = pp->a_lastcode ;
1643                 iLen = pp->lencode ;
1644         }
1645
1646         DEBUG_PRINTF_JJY_RECEIVE( "jjy_receive_echokeisokuki_lt2000", iLen ) ;
1647
1648         /* Check reply length */
1649
1650         if ( ( up->operationmode == ECHOKEISOKUKI_LT2000_MODE_REQUEST_SEND
1651                && iLen != 15 )
1652           || ( up->operationmode == ECHOKEISOKUKI_LT2000_MODE_CONTINUOUS
1653                && iLen != 17 )
1654           || ( up->operationmode == ECHOKEISOKUKI_LT2000_MODE_SWITCHING_CONTINUOUS
1655                && iLen != 17 ) ) {
1656                 /* Unexpected reply length */
1657                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_INVALID_LENGTH,
1658                           iLen ) ;
1659                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1660                 up->bLineError = TRUE ;
1661                 return JJY_RECEIVE_ERROR ;
1662         }
1663
1664         if ( up->operationmode == ECHOKEISOKUKI_LT2000_MODE_REQUEST_SEND && iLen == 15 ) {
1665                 /* YYMMDDWHHMMSS<BCC1><BCC2> */
1666
1667                 for ( i = ibcc = 0 ; i < 13 ; i ++ ) {
1668                         ibcc ^= pBuf[i] ;
1669                 }
1670
1671                 ibcc1 = 0x30 | ( ( ibcc >> 4 ) & 0xF ) ;
1672                 ibcc2 = 0x30 | ( ( ibcc      ) & 0xF ) ;
1673                 if ( pBuf[13] != ibcc1 || pBuf[14] != ibcc2 ) {
1674                         snprintf( sErr, sizeof(sErr)-1, " BCC error : Recv=%02X,%02X / Calc=%02X,%02X ",
1675                                   pBuf[13] & 0xFF, pBuf[14] & 0xFF,
1676                                   ibcc1, ibcc2 ) ;
1677                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_INVALID_REPLY,
1678                                   sErr ) ;
1679                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1680                         up->bLineError = TRUE ;
1681                         return JJY_RECEIVE_ERROR ;
1682                 }
1683
1684         }
1685
1686         if ( ( up->operationmode == ECHOKEISOKUKI_LT2000_MODE_REQUEST_SEND
1687                && iLen == 15 )
1688           || ( up->operationmode == ECHOKEISOKUKI_LT2000_MODE_CONTINUOUS
1689                && iLen == 17 )
1690           || ( up->operationmode == ECHOKEISOKUKI_LT2000_MODE_SWITCHING_CONTINUOUS
1691                && iLen == 17 ) ) {
1692                 /* YYMMDDWHHMMSS<BCC1><BCC2> or YYMMDDWHHMMSS<ST1><ST2><ST3><ST4> */
1693
1694                 rc = sscanf ( pBuf, "%2d%2d%2d%*1d%2d%2d%2d",
1695                               &up->year, &up->month, &up->day,
1696                               &up->hour, &up->minute, &up->second ) ;
1697
1698                 if ( rc != 6 || up->month < 1 || up->month > 12
1699                   || up->day < 1 || up->day > 31
1700                   || up->hour > 23 || up->minute > 59 || up->second > 60 ) {
1701                         /* Invalid date and time */
1702                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_DATETIME,
1703                                   rc, up->year, up->month, up->day,
1704                                   up->hour, up->minute, up->second ) ;
1705                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1706                         up->bLineError = TRUE ;
1707                         return JJY_RECEIVE_ERROR ;
1708                 }
1709
1710                 up->year += 2000 ;
1711
1712                 if ( up->operationmode == ECHOKEISOKUKI_LT2000_MODE_CONTINUOUS
1713                   || up->operationmode == ECHOKEISOKUKI_LT2000_MODE_SWITCHING_CONTINUOUS ) {
1714                         /* A time stamp comes on every 0.5 second in the mode 2 of the LT-2000. */
1715
1716                         up->msecond = 500 ;
1717                         up->second -- ;
1718                         if ( up->second < 0 ) {
1719                                 up->second = 59 ;
1720                                 up->minute -- ;
1721                                 if ( up->minute < 0 ) {
1722                                         up->minute = 59 ;
1723                                         up->hour -- ;
1724                                         if ( up->hour < 0 ) {
1725                                                 up->hour = 23 ;
1726                                                 up->day -- ;
1727                                                 if ( up->day < 1 ) {
1728                                                         up->month -- ;
1729                                                         if ( up->month < 1 ) {
1730                                                                 up->month = 12 ;
1731                                                                 up->year -- ;
1732                                                         }
1733                                                 }
1734                                         }
1735                                 }
1736                         }
1737
1738                 }
1739
1740                 jjy_synctime( peer, pp, up ) ;
1741
1742
1743         }
1744
1745         if (up->operationmode == ECHOKEISOKUKI_LT2000_MODE_SWITCHING_CONTINUOUS ) {
1746                 /* Switch from mode 2 to mode 1 in order to restraint of useless time stamp. */
1747
1748                 iLen = strlen( ECHOKEISOKUKI_LT2000_COMMAND_REQUEST_SEND ) ;
1749                 if ( write ( pp->io.fd, ECHOKEISOKUKI_LT2000_COMMAND_REQUEST_SEND, iLen ) != iLen  ) {
1750                         refclock_report ( peer, CEVNT_FAULT ) ;
1751                 }
1752
1753                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_SEND, ECHOKEISOKUKI_LT2000_COMMAND_REQUEST_SEND ) ;
1754
1755         }
1756
1757         return JJY_RECEIVE_DONE ;
1758
1759 }
1760
1761 /**************************************************************************************************/
1762
1763 static void
1764 jjy_poll_echokeisokuki_lt2000 ( int unit, struct peer *peer )
1765 {
1766
1767         struct refclockproc *pp ;
1768         struct jjyunit      *up ;
1769
1770         char    sCmd[2] ;
1771
1772         pp = peer->procptr ;
1773         up = pp->unitptr ;
1774
1775         up->bLineError = FALSE ;
1776
1777         /*
1778          * Send "T" or "C" command
1779          */
1780
1781         switch ( up->operationmode ) {
1782         case ECHOKEISOKUKI_LT2000_MODE_REQUEST_SEND :
1783                 sCmd[0] = 'T' ;
1784                 break ;
1785         case ECHOKEISOKUKI_LT2000_MODE_CONTINUOUS :
1786         case ECHOKEISOKUKI_LT2000_MODE_SWITCHING_CONTINUOUS :
1787                 sCmd[0] = 'C' ;
1788                 break ;
1789         }
1790         sCmd[1] = 0 ;
1791
1792         if ( write ( pp->io.fd, sCmd, 1 ) != 1  ) {
1793                 refclock_report ( peer, CEVNT_FAULT ) ;
1794         }
1795
1796         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_SEND, sCmd ) ;
1797
1798 }
1799
1800 /*################################################################################################*/
1801 /*################################################################################################*/
1802 /*##                                                                                            ##*/
1803 /*##    The CITIZEN T.I.C CO., LTD. JJY receiver JJY200                                         ##*/
1804 /*##                                                                                            ##*/
1805 /*##    server  127.127.40.X  mode 4                                                            ##*/
1806 /*##                                                                                            ##*/
1807 /*################################################################################################*/
1808 /*################################################################################################*/
1809 /*                                                                                                */
1810 /*  Command               Response                                  Remarks                       */
1811 /*  --------------------  ----------------------------------------  ----------------------------  */
1812 /*                        'XX YY/MM/DD W HH:MM:SS<CR>               XX:OK|NG|ER  W:0(Mon)-6(Sun)  */
1813 /*                                                                                                */
1814 /*################################################################################################*/
1815
1816 static int
1817 jjy_start_citizentic_jjy200 ( int unit, struct peer *peer, struct jjyunit *up )
1818 {
1819
1820         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_JJY, "Refclock: CITIZEN T.I.C CO. LTD. JJY200" ) ;
1821
1822         up->unittype  = UNITTYPE_CITIZENTIC_JJY200 ;
1823         up->linespeed = SPEED232_CITIZENTIC_JJY200 ;
1824         up->linediscipline = LDISC_CLK ;
1825
1826         return 0 ;
1827
1828 }
1829
1830 /**************************************************************************************************/
1831
1832 static int
1833 jjy_receive_citizentic_jjy200 ( struct recvbuf *rbufp )
1834 {
1835
1836         struct jjyunit          *up ;
1837         struct refclockproc     *pp ;
1838         struct peer             *peer;
1839
1840         char    *pBuf, sLog [ 100 ], sMsg [ 16 ] ;
1841         int     iLen ;
1842         int     rc ;
1843         char    cApostrophe, sStatus[3] ;
1844         int     iWeekday ;
1845
1846         /* Initialize pointers */
1847
1848         peer = rbufp->recv_peer ;
1849         pp = peer->procptr ;
1850         up = pp->unitptr ;
1851
1852         if ( up->linediscipline == LDISC_RAW ) {
1853                 pBuf = up->sTextBuf ;
1854                 iLen = up->iTextBufLen ;
1855         } else {
1856                 pBuf = pp->a_lastcode ;
1857                 iLen = pp->lencode ;
1858         }
1859
1860         DEBUG_PRINTF_JJY_RECEIVE( "jjy_receive_citizentic_jjy200", iLen ) ;
1861
1862         /*
1863          * JJY-200 sends a timestamp every second.
1864          * So, a timestamp is ignored unless it is right after polled.
1865          */
1866
1867         if ( up->iProcessState != JJY_PROCESS_STATE_RECEIVE ) {
1868                 return JJY_RECEIVE_SKIP ;
1869         }
1870
1871         /* Check reply length */
1872
1873         if ( iLen != 23 ) {
1874                 /* Unexpected reply length */
1875                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_INVALID_LENGTH,
1876                           iLen ) ;
1877                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1878                 up->bLineError = TRUE ;
1879                 return JJY_RECEIVE_ERROR ;
1880         }
1881
1882         /* 'XX YY/MM/DD W HH:MM:SS<CR> */
1883
1884         rc = sscanf ( pBuf, "%c%2s %2d/%2d/%2d %1d %2d:%2d:%2d",
1885                       &cApostrophe, sStatus,
1886                       &up->year, &up->month, &up->day, &iWeekday,
1887                       &up->hour, &up->minute, &up->second ) ;
1888         sStatus[2] = 0 ;
1889
1890         if ( rc != 9 || cApostrophe != '\''
1891           || ( strcmp( sStatus, "OK" ) != 0
1892             && strcmp( sStatus, "NG" ) != 0
1893             && strcmp( sStatus, "ER" ) != 0 )
1894           || up->month < 1 || up->month > 12 || up->day < 1 || up->day > 31
1895           || iWeekday > 6
1896           || up->hour > 23 || up->minute > 59 || up->second > 60 ) {
1897                 /* Invalid date and time */
1898                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_DATETIME,
1899                           rc, up->year, up->month, up->day,
1900                           up->hour, up->minute, up->second ) ;
1901                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
1902                 up->bLineError = TRUE ;
1903                 return JJY_RECEIVE_ERROR ;
1904         } else if ( strcmp( sStatus, "NG" ) == 0
1905                  || strcmp( sStatus, "ER" ) == 0 ) {
1906                 /* Timestamp is unsure */
1907                 snprintf( sMsg, sizeof(sMsg)-1, "status=%s", sStatus ) ;
1908                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_TIMESTAMP_UNSURE,
1909                           sMsg ) ;
1910                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_WARNING, sLog ) ;
1911                 return JJY_RECEIVE_SKIP ;
1912         }
1913
1914         up->year += 2000 ;
1915         up->msecond = 0 ;
1916
1917         jjy_synctime( peer, pp, up ) ;
1918
1919         return JJY_RECEIVE_DONE ;
1920
1921 }
1922
1923 /**************************************************************************************************/
1924
1925 static void
1926 jjy_poll_citizentic_jjy200 ( int unit, struct peer *peer )
1927 {
1928
1929         struct refclockproc *pp ;
1930         struct jjyunit      *up ;
1931
1932         pp = peer->procptr ;
1933         up = pp->unitptr ;
1934
1935         up->bLineError = FALSE ;
1936
1937 }
1938
1939 /*################################################################################################*/
1940 /*################################################################################################*/
1941 /*##                                                                                            ##*/
1942 /*##    The Tristate Ltd. GPS clock TS-GPS01                                                    ##*/
1943 /*##                                                                                            ##*/
1944 /*##    server  127.127.40.X  mode 5                                                            ##*/
1945 /*##                                                                                            ##*/
1946 /*################################################################################################*/
1947 /*################################################################################################*/
1948 /*                                                                                                */
1949 /*  This clock has NMEA mode and command/respose mode.                                            */
1950 /*  When this jjy driver are used, set to command/respose mode of this clock                      */
1951 /*  by the onboard switch SW4, and make sure the LED-Y is tured on.                               */
1952 /*  Other than this JJY driver, the refclock driver type 20, generic NMEA driver,                 */
1953 /*  works with the NMEA mode of this clock.                                                       */
1954 /*                                                                                                */
1955 /*  Command               Response                                  Remarks                       */
1956 /*  --------------------  ----------------------------------------  ----------------------------  */
1957 /*  stus<CR><LF>          *R|*G|*U|+U<CR><LF>                                                     */
1958 /*  date<CR><LF>          YY/MM/DD<CR><LF>                                                        */
1959 /*  time<CR><LF>          HH:MM:SS<CR><LF>                                                        */
1960 /*                                                                                                */
1961 /*################################################################################################*/
1962
1963 #define TS_GPS01_COMMAND_NUMBER_DATE    1
1964 #define TS_GPS01_COMMAND_NUMBER_TIME    2
1965 #define TS_GPS01_COMMAND_NUMBER_STUS    4
1966
1967 #define TS_GPS01_REPLY_DATE             "yyyy/mm/dd"
1968 #define TS_GPS01_REPLY_TIME             "hh:mm:ss"
1969 #define TS_GPS01_REPLY_STUS_RTC         "*R"
1970 #define TS_GPS01_REPLY_STUS_GPS         "*G"
1971 #define TS_GPS01_REPLY_STUS_UTC         "*U"
1972 #define TS_GPS01_REPLY_STUS_PPS         "+U"
1973
1974 #define TS_GPS01_REPLY_LENGTH_DATE          10  /* Length without <CR><LF> */
1975 #define TS_GPS01_REPLY_LENGTH_TIME          8   /* Length without <CR><LF> */
1976 #define TS_GPS01_REPLY_LENGTH_STUS          2   /* Length without <CR><LF> */
1977
1978 static  struct
1979 {
1980         char    commandNumber ;
1981         const char      *command ;
1982         int     commandLength ;
1983         int     iExpectedReplyLength ;
1984 } tristate_gps01_command_sequence[] =
1985 {
1986         { 0, NULL, 0, 0 }, /* Idle */
1987         { TS_GPS01_COMMAND_NUMBER_STUS, "stus\r\n", 6, TS_GPS01_REPLY_LENGTH_STUS },
1988         { TS_GPS01_COMMAND_NUMBER_TIME, "time\r\n", 6, TS_GPS01_REPLY_LENGTH_TIME },
1989         { TS_GPS01_COMMAND_NUMBER_DATE, "date\r\n", 6, TS_GPS01_REPLY_LENGTH_DATE },
1990         { TS_GPS01_COMMAND_NUMBER_TIME, "time\r\n", 6, TS_GPS01_REPLY_LENGTH_TIME },
1991         /* End of command */
1992         { 0, NULL, 0, 0 }
1993 } ;
1994
1995 /**************************************************************************************************/
1996
1997 static int
1998 jjy_start_tristate_gpsclock01 ( int unit, struct peer *peer, struct jjyunit *up )
1999 {
2000
2001         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_JJY, "Refclock: Tristate Ltd. TS-GPS01" ) ;
2002
2003         up->unittype  = UNITTYPE_TRISTATE_GPSCLOCK01 ;
2004         up->linespeed = SPEED232_TRISTATE_GPSCLOCK01 ;
2005         up->linediscipline = LDISC_CLK ;
2006
2007         return 0 ;
2008
2009 }
2010
2011 /**************************************************************************************************/
2012
2013 static int
2014 jjy_receive_tristate_gpsclock01 ( struct recvbuf *rbufp )
2015 {
2016 #ifdef DEBUG
2017         static  const char      *sFunctionName = "jjy_receive_tristate_gpsclock01" ;
2018 #endif
2019
2020         struct jjyunit      *up ;
2021         struct refclockproc *pp ;
2022         struct peer         *peer;
2023
2024         char *          pBuf ;
2025         char            sLog [ 100 ] ;
2026         int             iLen ;
2027         int             rc ;
2028
2029         const char *    pCmd ;
2030         int             iCmdLen ;
2031
2032         /* Initialize pointers */
2033
2034         peer = rbufp->recv_peer ;
2035         pp = peer->procptr ;
2036         up = pp->unitptr ;
2037
2038         if ( up->linediscipline == LDISC_RAW ) {
2039                 pBuf = up->sTextBuf ;
2040                 iLen = up->iTextBufLen ;
2041         } else {
2042                 pBuf = pp->a_lastcode ;
2043                 iLen = pp->lencode ;
2044         }
2045
2046         DEBUG_PRINTF_JJY_RECEIVE( "jjy_receive_tristate_gpsclock01", iLen ) ;
2047
2048         /* Ignore NMEA data stream */
2049
2050         if ( iLen > 5
2051           && ( strncmp( pBuf, "$GP", 3 ) == 0 || strncmp( pBuf, "$PFEC", 5 ) == 0 ) ) {
2052 #ifdef DEBUG
2053                 if ( debug ) {
2054                         printf ( "%s (refclock_jjy.c) : Skip NMEA stream [%s]\n",
2055                                 sFunctionName, pBuf ) ;
2056                 }
2057 #endif
2058                 return JJY_RECEIVE_WAIT ;
2059         }
2060
2061         /*
2062          * Skip command prompt '$Cmd>' from the TS-GPSclock-01
2063          */
2064         if ( iLen == 5 && strncmp( pBuf, "$Cmd>", 5 ) == 0 ) {
2065                 return JJY_RECEIVE_WAIT ;
2066         } else if ( iLen > 5 && strncmp( pBuf, "$Cmd>", 5 ) == 0 ) {
2067                 pBuf += 5 ;
2068                 iLen -= 5 ;
2069         }
2070
2071         /*
2072          * Ignore NMEA data stream after command prompt
2073          */
2074         if ( iLen > 5
2075           && ( strncmp( pBuf, "$GP", 3 ) == 0 || strncmp( pBuf, "$PFEC", 5 ) == 0 ) ) {
2076 #ifdef DEBUG
2077                 if ( debug ) {
2078                         printf ( "%s (refclock_jjy.c) : Skip NMEA stream [%s]\n",
2079                                 sFunctionName, pBuf ) ;
2080                 }
2081 #endif
2082                 return JJY_RECEIVE_WAIT ;
2083         }
2084
2085         /* Check expected reply */
2086
2087         if ( tristate_gps01_command_sequence[up->iCommandSeq].command == NULL ) {
2088                 /* Command sequence has not been started, or has been completed */
2089                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_UNEXPECTED_REPLY,
2090                           pBuf ) ;
2091                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
2092                 up->bLineError = TRUE ;
2093                 return JJY_RECEIVE_ERROR ;
2094         }
2095
2096         /* Check reply length */
2097
2098         if ( iLen != tristate_gps01_command_sequence[up->iCommandSeq].iExpectedReplyLength ) {
2099                 /* Unexpected reply length */
2100                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_INVALID_LENGTH,
2101                           iLen ) ;
2102                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
2103                 up->bLineError = TRUE ;
2104                 return JJY_RECEIVE_ERROR ;
2105         }
2106
2107         /* Parse reply */
2108
2109         switch ( tristate_gps01_command_sequence[up->iCommandSeq].commandNumber ) {
2110
2111         case TS_GPS01_COMMAND_NUMBER_DATE : /* YYYY/MM/DD */
2112
2113                 rc = sscanf ( pBuf, "%4d/%2d/%2d", &up->year, &up->month, &up->day ) ;
2114
2115                 if ( rc != 3 || up->year < 2000 || 2099 <= up->year
2116                   || up->month < 1 || 12 < up->month
2117                   || up->day < 1 || 31 < up->day ) {
2118                         /* Invalid date */
2119                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_DATE,
2120                                   rc, up->year, up->month, up->day ) ;
2121                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
2122                         up->bLineError = TRUE ;
2123                         return JJY_RECEIVE_ERROR ;
2124                 }
2125
2126                 break ;
2127
2128         case TS_GPS01_COMMAND_NUMBER_TIME : /* HH:MM:SS */
2129
2130                 if ( up->iTimestampCount >= 2 ) {
2131                         /* Too many time reply */
2132                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_TOO_MANY_REPLY,
2133                                   up->iTimestampCount ) ;
2134                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
2135                         up->bLineError = TRUE ;
2136                         return JJY_RECEIVE_ERROR ;
2137                 }
2138
2139                 rc = sscanf ( pBuf, "%2d:%2d:%2d",
2140                               &up->hour, &up->minute, &up->second ) ;
2141
2142                 if ( rc != 3
2143                   || up->hour > 23 || up->minute > 59 || up->second > 60 ) {
2144                         /* Invalid time */
2145                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_TIME,
2146                                   rc, up->hour, up->minute, up->second ) ;
2147                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
2148                         up->bLineError = TRUE ;
2149                         return JJY_RECEIVE_ERROR ;
2150                 }
2151
2152                 up->iTimestamp[up->iTimestampCount] = ( up->hour * 60 + up->minute ) * 60 + up->second ;
2153
2154                 up->iTimestampCount++ ;
2155
2156                 up->msecond = 0 ;
2157
2158                 break ;
2159
2160         case TS_GPS01_COMMAND_NUMBER_STUS :
2161
2162                 if ( strncmp( pBuf, TS_GPS01_REPLY_STUS_RTC, TS_GPS01_REPLY_LENGTH_STUS ) == 0
2163                   || strncmp( pBuf, TS_GPS01_REPLY_STUS_GPS, TS_GPS01_REPLY_LENGTH_STUS ) == 0
2164                   || strncmp( pBuf, TS_GPS01_REPLY_STUS_UTC, TS_GPS01_REPLY_LENGTH_STUS ) == 0
2165                   || strncmp( pBuf, TS_GPS01_REPLY_STUS_PPS, TS_GPS01_REPLY_LENGTH_STUS ) == 0 ) {
2166                         /* Good */
2167                 } else {
2168                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_INVALID_REPLY,
2169                                   pBuf ) ;
2170                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
2171                         up->bLineError = TRUE ;
2172                         return JJY_RECEIVE_ERROR ;
2173                 }
2174
2175                 break ;
2176
2177         default : /*  Unexpected reply */
2178
2179                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_INVALID_REPLY,
2180                           pBuf ) ;
2181                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
2182                 up->bLineError = TRUE ;
2183                 return JJY_RECEIVE_ERROR ;
2184
2185         }
2186
2187         if ( up->iTimestampCount == 2 ) {
2188                 /* Process date and time */
2189
2190                 if ( up->iTimestamp[1] - 2 <= up->iTimestamp[0]
2191                   && up->iTimestamp[0]     <= up->iTimestamp[1] ) {
2192                         /* 3 commands (time,date,stim) was excuted in two seconds */
2193                         jjy_synctime( peer, pp, up ) ;
2194                         return JJY_RECEIVE_DONE ;
2195                 } else if ( up->iTimestamp[0] > up->iTimestamp[1] ) {
2196                         /* Over midnight, and date is unsure */
2197                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_OVER_MIDNIGHT_2,
2198                                   up->iTimestamp[0], up->iTimestamp[1] ) ;
2199                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_INFORMATION, sLog ) ;
2200                         return JJY_RECEIVE_SKIP ;
2201                 } else {
2202                         /* Slow reply */
2203                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_SLOW_REPLY_2,
2204                                   up->iTimestamp[0], up->iTimestamp[1] ) ;
2205                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
2206                         up->bLineError = TRUE ;
2207                         return JJY_RECEIVE_ERROR ;
2208                 }
2209
2210         }
2211
2212         if ( tristate_gps01_command_sequence[up->iCommandSeq].command == NULL ) {
2213                 /* Command sequence completed */
2214                 jjy_synctime( peer, pp, up ) ;
2215                 return JJY_RECEIVE_DONE ;
2216         }
2217
2218         /* Issue next command */
2219
2220         if ( tristate_gps01_command_sequence[up->iCommandSeq].command != NULL ) {
2221                 up->iCommandSeq ++ ;
2222         }
2223
2224         if ( tristate_gps01_command_sequence[up->iCommandSeq].command == NULL ) {
2225                 /* Command sequence completed */
2226                 up->iProcessState = JJY_PROCESS_STATE_DONE ;
2227                 return JJY_RECEIVE_DONE ;
2228         }
2229
2230         pCmd =  tristate_gps01_command_sequence[up->iCommandSeq].command ;
2231         iCmdLen = tristate_gps01_command_sequence[up->iCommandSeq].commandLength ;
2232         if ( write ( pp->io.fd, pCmd, iCmdLen ) != iCmdLen ) {
2233                 refclock_report ( peer, CEVNT_FAULT ) ;
2234         }
2235
2236         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_SEND, pCmd ) ;
2237
2238         return JJY_RECEIVE_WAIT ;
2239
2240 }
2241
2242 /**************************************************************************************************/
2243
2244 static void
2245 jjy_poll_tristate_gpsclock01 ( int unit, struct peer *peer )
2246 {
2247 #ifdef DEBUG
2248         static const char *sFunctionName = "jjy_poll_tristate_gpsclock01" ;
2249 #endif
2250
2251         struct refclockproc *pp ;
2252         struct jjyunit      *up ;
2253
2254         const char *    pCmd ;
2255         int             iCmdLen ;
2256
2257         pp = peer->procptr ;
2258         up = pp->unitptr ;
2259
2260         up->iTimestampCount = 0 ;
2261
2262         if ( ( pp->sloppyclockflag & CLK_FLAG1 ) == 0 ) {
2263                 /* Skip "stus" command */
2264                 up->iCommandSeq = 1 ;
2265                 up->iLineCount = 1 ;
2266         }
2267
2268 #ifdef DEBUG
2269         if ( debug ) {
2270                 printf ( "%s (refclock_jjy.c) : flag1=%X CLK_FLAG1=%X up->iLineCount=%d\n",
2271                         sFunctionName, pp->sloppyclockflag, CLK_FLAG1,
2272                         up->iLineCount ) ;
2273         }
2274 #endif
2275
2276         /*
2277          * Send a first command
2278          */
2279
2280         up->iCommandSeq ++ ;
2281
2282         pCmd =  tristate_gps01_command_sequence[up->iCommandSeq].command ;
2283         iCmdLen = tristate_gps01_command_sequence[up->iCommandSeq].commandLength ;
2284         if ( write ( pp->io.fd, pCmd, iCmdLen ) != iCmdLen ) {
2285                 refclock_report ( peer, CEVNT_FAULT ) ;
2286         }
2287
2288         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_SEND, pCmd ) ;
2289
2290 }
2291
2292 /*################################################################################################*/
2293 /*################################################################################################*/
2294 /*##                                                                                            ##*/
2295 /*##    The SEIKO TIME SYSTEMS TDC-300                                                          ##*/
2296 /*##                                                                                            ##*/
2297 /*##    server  127.127.40.X  mode 6                                                            ##*/
2298 /*##                                                                                            ##*/
2299 /*################################################################################################*/
2300 /*################################################################################################*/
2301 /*                                                                                                */
2302 /*  Type                  Response                                  Remarks                       */
2303 /*  --------------------  ----------------------------------------  ----------------------------  */
2304 /*  Type 1                <STX>HH:MM:SS<ETX>                                                      */
2305 /*  Type 2                <STX>YYMMDDHHMMSSWLSCU<ETX>               W:0(Sun)-6(Sat)               */
2306 /*  Type 3                <STX>YYMMDDWHHMMSS<ETX>                   W:0(Sun)-6(Sat)               */
2307 /*                        <STX><xE5><ETX>                           5 to 10 mSec. before second   */
2308 /*                                                                                                */
2309 /*################################################################################################*/
2310
2311 static struct jjyRawDataBreak seiko_tsys_tdc_300_raw_break [ ] =
2312 {
2313         { "\x03", 1 }, { NULL, 0 }
2314 } ;
2315
2316 /**************************************************************************************************/
2317
2318 static int
2319 jjy_start_seiko_tsys_tdc_300 ( int unit, struct peer *peer, struct jjyunit *up )
2320 {
2321
2322         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_JJY, "Refclock: SEIKO TIME SYSTEMS TDC-300" ) ;
2323
2324         up->unittype  = UNITTYPE_SEIKO_TIMESYS_TDC_300 ;
2325         up->linespeed = SPEED232_SEIKO_TIMESYS_TDC_300 ;
2326         up->linediscipline = LDISC_RAW ;
2327
2328         up->pRawBreak = seiko_tsys_tdc_300_raw_break ;
2329         up->bWaitBreakString = TRUE ;
2330
2331         up->bSkipCntrlCharOnly = FALSE ;
2332
2333         return 0 ;
2334
2335 }
2336
2337 /**************************************************************************************************/
2338
2339 static int
2340 jjy_receive_seiko_tsys_tdc_300 ( struct recvbuf *rbufp )
2341 {
2342
2343         struct peer             *peer;
2344         struct refclockproc     *pp ;
2345         struct jjyunit          *up ;
2346
2347         char    *pBuf, sLog [ 100 ] ;
2348         int     iLen, i ;
2349         int     rc, iWeekday ;
2350         time_t  now ;
2351         struct  tm      *pTime ;
2352
2353         /* Initialize pointers */
2354
2355         peer = rbufp->recv_peer ;
2356         pp = peer->procptr ;
2357         up = pp->unitptr ;
2358
2359         if ( up->linediscipline == LDISC_RAW ) {
2360                 pBuf = up->sTextBuf ;
2361                 iLen = up->iTextBufLen ;
2362         } else {
2363                 pBuf = pp->a_lastcode ;
2364                 iLen = pp->lencode ;
2365         }
2366
2367         DEBUG_PRINTF_JJY_RECEIVE( "jjy_receive_seiko_tsys_tdc_300", iLen ) ;
2368
2369         /*
2370          * TDC-300 sends a timestamp every second.
2371          * So, a timestamp is ignored unless it is right after polled.
2372          */
2373
2374         if ( up->iProcessState != JJY_PROCESS_STATE_RECEIVE ) {
2375                 return JJY_RECEIVE_SKIP ;
2376         }
2377
2378         /* Process timestamp */
2379
2380         up->iReceiveSeq ++ ;
2381
2382         switch ( iLen ) {
2383
2384         case 8 : /* Type 1 : <STX>HH:MM:SS<ETX> */
2385
2386                 for ( i = 0 ; i < iLen ; i ++ ) {
2387                         pBuf[i] &= 0x7F ;
2388                 }
2389
2390                 rc = sscanf ( pBuf+1, "%2d:%2d:%2d",
2391                       &up->hour, &up->minute, &up->second ) ;
2392
2393                 if ( rc != 3
2394                   || up->hour > 23 || up->minute > 59 || up->second > 60 ) {
2395                         /* Invalid time */
2396                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_TIME,
2397                                   rc, up->hour, up->minute, up->second ) ;
2398                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
2399                         up->bLineError = TRUE ;
2400                         return JJY_RECEIVE_ERROR ;
2401                 } else if ( up->hour == 23 && up->minute == 59 && up->second >= 55 ) {
2402                         /* Uncertainty date guard */
2403                         return JJY_RECEIVE_WAIT ;
2404                 }
2405
2406                 time( &now ) ;
2407                 pTime = localtime( &now ) ;
2408                 up->year  = pTime->tm_year ;
2409                 up->month = pTime->tm_mon + 1 ;
2410                 up->day   = pTime->tm_mday ;
2411
2412                 break ;
2413
2414         case 17 : /* Type 2 : <STX>YYMMDDHHMMSSWLSCU<ETX> */
2415
2416                 for ( i = 0 ; i < iLen ; i ++ ) {
2417                         pBuf[i] &= 0x7F ;
2418                 }
2419
2420                 rc = sscanf ( pBuf+1, "%2d%2d%2d%2d%2d%2d%1d",
2421                       &up->year, &up->month, &up->day,
2422                       &up->hour, &up->minute, &up->second, &iWeekday ) ;
2423
2424                 if ( rc != 7
2425                   || up->month < 1 || up->month > 12 || up->day < 1 || up->day > 31
2426                   || iWeekday > 6
2427                   || up->hour > 23 || up->minute > 59 || up->second > 60 ) {
2428                         /* Invalid date and time */
2429                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_DATETIME,
2430                                   rc, up->year, up->month, up->day,
2431                                   up->hour, up->minute, up->second ) ;
2432                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
2433                         up->bLineError = TRUE ;
2434                         return JJY_RECEIVE_ERROR ;
2435                 }
2436
2437                 break ;
2438
2439         case 13 : /* Type 3 : <STX>YYMMDDWHHMMSS<ETX> */
2440
2441                 rc = sscanf ( pBuf, "%2d%2d%2d%1d%2d%2d%2d",
2442                       &up->year, &up->month, &up->day, &iWeekday,
2443                       &up->hour, &up->minute, &up->second ) ;
2444
2445                 if ( rc != 7
2446                   || up->month < 1 || up->month > 12 || up->day < 1 || up->day > 31
2447                   || iWeekday > 6
2448                   || up->hour > 23 || up->minute > 59 || up->second > 60 ) {
2449                         /* Invalid date and time */
2450                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_DATETIME,
2451                                   rc, up->year, up->month, up->day,
2452                                   up->hour, up->minute, up->second ) ;
2453                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
2454                         up->bLineError = TRUE ;
2455                         return JJY_RECEIVE_ERROR ;
2456                 }
2457
2458                 return JJY_RECEIVE_WAIT ;
2459
2460         case 1 : /* Type 3 : <STX><xE5><ETX> */
2461
2462                 if ( ( *pBuf & 0xFF ) != 0xE5 ) {
2463                         /* Invalid second signal */
2464                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_INVALID_REPLY,
2465                                   up->sLineBuf ) ;
2466                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
2467                         up->bLineError = TRUE ;
2468                         return JJY_RECEIVE_ERROR ;
2469                 } else if ( up->iReceiveSeq == 1 ) {
2470                         /* Wait for next timestamp */
2471                         up->iReceiveSeq -- ;
2472                         return JJY_RECEIVE_WAIT ;
2473                 } else if ( up->iReceiveSeq >= 3 ) {
2474                         /* Unexpected second signal */
2475                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_UNEXPECTED_REPLY,
2476                                   up->sLineBuf ) ;
2477                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
2478                         up->bLineError = TRUE ;
2479                         return JJY_RECEIVE_ERROR ;
2480                 }
2481
2482                 break ;
2483
2484         default : /* Unexpected reply length */
2485
2486                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_INVALID_LENGTH,
2487                           iLen ) ;
2488                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
2489                 up->bLineError = TRUE ;
2490                 return JJY_RECEIVE_ERROR ;
2491
2492         }
2493
2494         up->year += 2000 ;
2495         up->msecond = 0 ;
2496
2497         jjy_synctime( peer, pp, up ) ;
2498
2499         return JJY_RECEIVE_DONE ;
2500
2501 }
2502
2503 /**************************************************************************************************/
2504
2505 static void
2506 jjy_poll_seiko_tsys_tdc_300 ( int unit, struct peer *peer )
2507 {
2508
2509         struct refclockproc *pp ;
2510         struct jjyunit      *up ;
2511
2512         pp = peer->procptr ;
2513         up = pp->unitptr ;
2514
2515         up->bLineError = FALSE ;
2516
2517 }
2518
2519 /*################################################################################################*/
2520 /*################################################################################################*/
2521 /*##                                                                                            ##*/
2522 /*##    Telephone JJY                                                                           ##*/
2523 /*##                                                                                            ##*/
2524 /*##    server  127.127.40.X  mode 100 to 180                                                   ##*/
2525 /*##                                                                                            ##*/
2526 /*################################################################################################*/
2527 /*################################################################################################*/
2528 /*                                                                                                */
2529 /*  Prompt                Command               Response              Remarks                     */
2530 /*  --------------------  --------------------  --------------------  --------------------------  */
2531 /*  Name<SP>?<SP>         TJJY<CR>              Welcome messages      TJJY is a guest user ID     */
2532 /*  >                     4DATE<CR>             YYYYMMDD<CR>                                      */
2533 /*  >                     LEAPSEC<CR>           XX<CR>                One of <SP>0, +1, -1        */
2534 /*  >                     TIME<CR>              HHMMSS<CR>            3 times on second           */
2535 /*  >                     BYE<CR>               Sayounara messages                                */
2536 /*                                                                                                */
2537 /*################################################################################################*/
2538
2539 static struct jjyRawDataBreak teljjy_raw_break [ ] =
2540 {
2541         { "\r\n", 2 },
2542         { "\r"  , 1 },
2543         { "\n"  , 1 },
2544         { "Name ? ", 7 },
2545         { ">"   , 1 },
2546         { "+++" , 3 },
2547         { NULL  , 0 }
2548 } ;
2549
2550 #define TELJJY_STATE_IDLE       0
2551 #define TELJJY_STATE_DAILOUT    1
2552 #define TELJJY_STATE_LOGIN      2
2553 #define TELJJY_STATE_CONNECT    3
2554 #define TELJJY_STATE_BYE        4
2555
2556 #define TELJJY_EVENT_NULL       0
2557 #define TELJJY_EVENT_START      1
2558 #define TELJJY_EVENT_CONNECT    2
2559 #define TELJJY_EVENT_DISCONNECT 3
2560 #define TELJJY_EVENT_COMMAND    4
2561 #define TELJJY_EVENT_LOGIN      5       /* Posted by the jjy_receive_telephone */
2562 #define TELJJY_EVENT_PROMPT     6       /* Posted by the jjy_receive_telephone */
2563 #define TELJJY_EVENT_DATA       7       /* Posted by the jjy_receive_telephone */
2564 #define TELJJY_EVENT_ERROR      8       /* Posted by the jjy_receive_telephone */
2565 #define TELJJY_EVENT_SILENT     9       /* Posted by the jjy_timer_telephone */
2566 #define TELJJY_EVENT_TIMEOUT    10      /* Posted by the jjy_timer_telephone */
2567
2568 static  void    teljjy_control          ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2569
2570 static  int     teljjy_idle_ignore      ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2571 static  int     teljjy_idle_dialout     ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2572 static  int     teljjy_dial_ignore      ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2573 static  int     teljjy_dial_login       ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2574 static  int     teljjy_dial_disc        ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2575 static  int     teljjy_login_ignore     ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2576 static  int     teljjy_login_disc       ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2577 static  int     teljjy_login_conn       ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2578 static  int     teljjy_login_login      ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2579 static  int     teljjy_login_silent     ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2580 static  int     teljjy_login_error      ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2581 static  int     teljjy_conn_ignore      ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2582 static  int     teljjy_conn_disc        ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2583 static  int     teljjy_conn_send        ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2584 static  int     teljjy_conn_data        ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2585 static  int     teljjy_conn_silent      ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2586 static  int     teljjy_conn_error       ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2587 static  int     teljjy_bye_ignore       ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2588 static  int     teljjy_bye_disc         ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2589 static  int     teljjy_bye_modem        ( struct peer *peer, struct refclockproc *, struct jjyunit * ) ;
2590
2591 static int ( *pTeljjyHandler [ ] [ 5 ] ) ( struct peer *, struct refclockproc *, struct jjyunit *) =
2592 {                       /*STATE_IDLE           STATE_DAILOUT       STATE_LOGIN           STATE_CONNECT       STATE_BYE        */
2593 /* NULL       */        { teljjy_idle_ignore , teljjy_dial_ignore, teljjy_login_ignore, teljjy_conn_ignore, teljjy_bye_ignore },
2594 /* START      */        { teljjy_idle_dialout, teljjy_dial_ignore, teljjy_login_ignore, teljjy_conn_ignore, teljjy_bye_ignore },
2595 /* CONNECT    */        { teljjy_idle_ignore , teljjy_dial_login , teljjy_login_ignore, teljjy_conn_ignore, teljjy_bye_ignore },
2596 /* DISCONNECT */        { teljjy_idle_ignore , teljjy_dial_disc  , teljjy_login_disc  , teljjy_conn_disc  , teljjy_bye_disc   },
2597 /* COMMAND    */        { teljjy_idle_ignore , teljjy_dial_ignore, teljjy_login_ignore, teljjy_conn_ignore, teljjy_bye_modem  },
2598 /* LOGIN      */        { teljjy_idle_ignore , teljjy_dial_ignore, teljjy_login_login , teljjy_conn_error , teljjy_bye_ignore },
2599 /* PROMPT     */        { teljjy_idle_ignore , teljjy_dial_ignore, teljjy_login_conn  , teljjy_conn_send  , teljjy_bye_ignore },
2600 /* DATA       */        { teljjy_idle_ignore , teljjy_dial_ignore, teljjy_login_ignore, teljjy_conn_data  , teljjy_bye_ignore },
2601 /* ERROR      */        { teljjy_idle_ignore , teljjy_dial_ignore, teljjy_login_error , teljjy_conn_error , teljjy_bye_ignore },
2602 /* SILENT     */        { teljjy_idle_ignore , teljjy_dial_ignore, teljjy_login_silent, teljjy_conn_silent, teljjy_bye_ignore },
2603 /* TIMEOUT    */        { teljjy_idle_ignore , teljjy_dial_disc  , teljjy_login_error , teljjy_conn_error , teljjy_bye_modem  }
2604 } ;
2605
2606 static short iTeljjyNextState [ ] [ 5 ] =
2607 {                       /*STATE_IDLE            STATE_DAILOUT         STATE_LOGIN           STATE_CONNECT         STATE_BYE         */
2608 /* NULL       */        { TELJJY_STATE_IDLE   , TELJJY_STATE_DAILOUT, TELJJY_STATE_LOGIN  , TELJJY_STATE_CONNECT, TELJJY_STATE_BYE  },
2609 /* START      */        { TELJJY_STATE_DAILOUT, TELJJY_STATE_DAILOUT, TELJJY_STATE_LOGIN  , TELJJY_STATE_CONNECT, TELJJY_STATE_BYE  },
2610 /* CONNECT    */        { TELJJY_STATE_IDLE   , TELJJY_STATE_LOGIN  , TELJJY_STATE_LOGIN  , TELJJY_STATE_CONNECT, TELJJY_STATE_BYE  },
2611 /* DISCONNECT */        { TELJJY_STATE_IDLE   , TELJJY_STATE_IDLE   , TELJJY_STATE_IDLE   , TELJJY_STATE_IDLE   , TELJJY_STATE_IDLE },
2612 /* COMMAND    */        { TELJJY_STATE_IDLE   , TELJJY_STATE_DAILOUT, TELJJY_STATE_LOGIN  , TELJJY_STATE_CONNECT, TELJJY_STATE_BYE  },
2613 /* LOGIN      */        { TELJJY_STATE_IDLE   , TELJJY_STATE_DAILOUT, TELJJY_STATE_LOGIN  , TELJJY_STATE_BYE    , TELJJY_STATE_BYE  },
2614 /* PROMPT     */        { TELJJY_STATE_IDLE   , TELJJY_STATE_DAILOUT, TELJJY_STATE_CONNECT, TELJJY_STATE_BYE    , TELJJY_STATE_BYE  },
2615 /* DATA       */        { TELJJY_STATE_IDLE   , TELJJY_STATE_DAILOUT, TELJJY_STATE_LOGIN  , TELJJY_STATE_CONNECT, TELJJY_STATE_BYE  },
2616 /* ERROR      */        { TELJJY_STATE_IDLE   , TELJJY_STATE_DAILOUT, TELJJY_STATE_BYE    , TELJJY_STATE_BYE    , TELJJY_STATE_BYE  },
2617 /* SILENT     */        { TELJJY_STATE_IDLE   , TELJJY_STATE_DAILOUT, TELJJY_STATE_LOGIN  , TELJJY_STATE_CONNECT, TELJJY_STATE_BYE  },
2618 /* TIMEOUT    */        { TELJJY_STATE_IDLE   , TELJJY_STATE_IDLE   , TELJJY_STATE_BYE    , TELJJY_STATE_BYE    , TELJJY_STATE_BYE  }
2619 } ;
2620
2621 static short iTeljjyPostEvent [ ] [ 5 ] =
2622 {                       /*STATE_IDLE         STATE_DAILOUT      STATE_LOGIN           STATE_CONNECT         STATE_BYE         */
2623 /* NULL       */        { TELJJY_EVENT_NULL, TELJJY_EVENT_NULL, TELJJY_EVENT_NULL   , TELJJY_EVENT_NULL   , TELJJY_EVENT_NULL },
2624 /* START      */        { TELJJY_EVENT_NULL, TELJJY_EVENT_NULL, TELJJY_EVENT_NULL   , TELJJY_EVENT_NULL   , TELJJY_EVENT_NULL },
2625 /* CONNECT    */        { TELJJY_EVENT_NULL, TELJJY_EVENT_NULL, TELJJY_EVENT_NULL   , TELJJY_EVENT_NULL   , TELJJY_EVENT_NULL },
2626 /* DISCONNECT */        { TELJJY_EVENT_NULL, TELJJY_EVENT_NULL, TELJJY_EVENT_NULL   , TELJJY_EVENT_NULL   , TELJJY_EVENT_NULL },
2627 /* COMMAND    */        { TELJJY_EVENT_NULL, TELJJY_EVENT_NULL, TELJJY_EVENT_NULL   , TELJJY_EVENT_NULL   , TELJJY_EVENT_NULL },
2628 /* LOGIN      */        { TELJJY_EVENT_NULL, TELJJY_EVENT_NULL, TELJJY_EVENT_NULL   , TELJJY_EVENT_COMMAND, TELJJY_EVENT_NULL },
2629 /* PROMPT     */        { TELJJY_EVENT_NULL, TELJJY_EVENT_NULL, TELJJY_EVENT_PROMPT , TELJJY_EVENT_COMMAND, TELJJY_EVENT_NULL },
2630 /* DATA       */        { TELJJY_EVENT_NULL, TELJJY_EVENT_NULL, TELJJY_EVENT_NULL   , TELJJY_EVENT_NULL   , TELJJY_EVENT_NULL },
2631 /* ERROR      */        { TELJJY_EVENT_NULL, TELJJY_EVENT_NULL, TELJJY_EVENT_COMMAND, TELJJY_EVENT_COMMAND, TELJJY_EVENT_NULL },
2632 /* SILENT     */        { TELJJY_EVENT_NULL, TELJJY_EVENT_NULL, TELJJY_EVENT_NULL   , TELJJY_EVENT_NULL   , TELJJY_EVENT_NULL },
2633 /* TIMEOUT    */        { TELJJY_EVENT_NULL, TELJJY_EVENT_NULL, TELJJY_EVENT_COMMAND, TELJJY_EVENT_COMMAND, TELJJY_EVENT_NULL }
2634 } ;
2635
2636 static short iTeljjySilentTimeout [ 5 ] = { 0,   0, 10,  5,  0 } ;
2637 static short iTeljjyStateTimeout  [ 5 ] = { 0, 120, 60, 60, 40 } ;
2638
2639 #define TELJJY_STAY_CLOCK_STATE         0
2640 #define TELJJY_CHANGE_CLOCK_STATE       1
2641
2642 /* Command and replay */
2643
2644 #define TELJJY_REPLY_NONE       0
2645 #define TELJJY_REPLY_4DATE      1
2646 #define TELJJY_REPLY_TIME       2
2647 #define TELJJY_REPLY_LEAPSEC    3
2648 #define TELJJY_REPLY_LOOP       4
2649 #define TELJJY_REPLY_PROMPT     5
2650 #define TELJJY_REPLY_LOOPBACK   6
2651 #define TELJJY_REPLY_COM        7
2652
2653 #define TELJJY_COMMAND_START_SKIP_LOOPBACK      7
2654
2655 static  struct
2656 {
2657         const char      *command ;
2658         int     commandLength ;
2659         int     iEchobackReplyLength ;
2660         int     iExpectedReplyType   ;
2661         int     iExpectedReplyLength ;
2662 } teljjy_command_sequence[] =
2663 {
2664         { NULL, 0, 0, 0, 0 }, /* Idle */
2665         { "LOOP\r"   , 5, 4, TELJJY_REPLY_LOOP    , 0 }, /* Getting into loopback mode */
2666         { ">"        , 1, 1, TELJJY_REPLY_LOOPBACK, 0 }, /* Loopback measuring of delay time */
2667         { ">"        , 1, 1, TELJJY_REPLY_LOOPBACK, 0 }, /* Loopback measuring of delay time */
2668         { ">"        , 1, 1, TELJJY_REPLY_LOOPBACK, 0 }, /* Loopback measuring of delay time */
2669         { ">"        , 1, 1, TELJJY_REPLY_LOOPBACK, 0 }, /* Loopback measuring of delay time */
2670         { ">"        , 1, 1, TELJJY_REPLY_LOOPBACK, 0 }, /* Loopback measuring of delay time */
2671         { "COM\r"    , 4, 3, TELJJY_REPLY_COM     , 0 }, /* Exit from loopback mode */
2672         /* TELJJY_COMMAND_START_SKIP_LOOPBACK */
2673         { "TIME\r"   , 5, 4, TELJJY_REPLY_TIME    , 6 },
2674         { "4DATE\r"  , 6, 5, TELJJY_REPLY_4DATE   , 8 },
2675         { "LEAPSEC\r", 8, 7, TELJJY_REPLY_LEAPSEC , 2 },
2676         { "TIME\r"   , 5, 4, TELJJY_REPLY_TIME    , 6 },
2677         { "BYE\r"    , 4, 3, TELJJY_REPLY_NONE    , 0 },
2678         /* End of command */
2679         { NULL, 0, 0, 0, 0 }
2680 } ;
2681
2682 #define TELJJY_LOOPBACK_DELAY_THRESHOLD         700 /* Milli second */
2683
2684 #ifdef  DEBUG
2685 #define DEBUG_TELJJY_PRINTF(sFunc)      { if ( debug ) { printf ( "refclock_jjy.c : %s : iClockState=%d iClockEvent=%d iTeljjySilentTimer=%d iTeljjyStateTimer=%d iClockCommandSeq=%d\n", sFunc, up->iClockState, up->iClockEvent, up->iTeljjySilentTimer, up->iTeljjyStateTimer, up->iClockCommandSeq ) ; } }
2686 #else
2687 #define DEBUG_TELJJY_PRINTF(sFunc)
2688 #endif
2689
2690 /**************************************************************************************************/
2691
2692 static int
2693 jjy_start_telephone ( int unit, struct peer *peer, struct jjyunit *up )
2694 {
2695
2696         char    sLog [ 80 ], sFirstThreeDigits [ 4 ] ;
2697         int     iNumberOfDigitsOfPhoneNumber, iCommaCount, iCommaPosition ;
2698         size_t  i ;
2699         size_t  iFirstThreeDigitsCount ;
2700
2701         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_JJY, "Refclock: Telephone JJY" ) ;
2702
2703         up->unittype  = UNITTYPE_TELEPHONE ;
2704         up->linespeed = SPEED232_TELEPHONE ;
2705         up->linediscipline = LDISC_RAW ;
2706
2707         up->pRawBreak = teljjy_raw_break ;
2708         up->bWaitBreakString = TRUE ;
2709
2710         up->bSkipCntrlCharOnly = TRUE ;
2711
2712         up->iClockState = TELJJY_STATE_IDLE ;
2713         up->iClockEvent = TELJJY_EVENT_NULL ;
2714
2715         /* Check the telephone number */
2716
2717         if ( sys_phone[0] == NULL ) {
2718                 msyslog( LOG_ERR, "refclock_jjy.c : jjy_start_telephone : phone in the ntpd.conf must be specified." ) ;
2719                 up->bInitError = TRUE ;
2720                 return 1 ;
2721         }
2722
2723         if ( sys_phone[1] != NULL ) {
2724                 msyslog( LOG_ERR, "refclock_jjy.c : jjy_start_telephone : phone in the ntpd.conf should be only one." ) ;
2725                 up->bInitError = TRUE ;
2726                 return 1 ;
2727         }
2728
2729         iNumberOfDigitsOfPhoneNumber = iCommaCount = iCommaPosition = iFirstThreeDigitsCount = 0 ;
2730         for ( i = 0 ; i < strlen( sys_phone[0] ) ; i ++ ) {
2731                 if ( isdigit( (u_char)sys_phone[0][i] ) ) {
2732                         if ( iFirstThreeDigitsCount < sizeof(sFirstThreeDigits)-1 ) {
2733                                 sFirstThreeDigits[iFirstThreeDigitsCount++] = sys_phone[0][i] ;
2734                         }
2735                         iNumberOfDigitsOfPhoneNumber ++ ;
2736                 } else if ( sys_phone[0][i] == ',' ) {
2737                         iCommaCount ++ ;
2738                         if ( iCommaCount > 1 ) {
2739                                 msyslog( LOG_ERR, "refclock_jjy.c : jjy_start_telephone : phone in the ntpd.conf should be zero or one comma." ) ;
2740                                 up->bInitError = TRUE ;
2741                                 return 1 ;
2742                         }
2743                         iFirstThreeDigitsCount = 0 ;
2744                         iCommaPosition = i ;
2745                 } else if ( sys_phone[0][i] != '-' ) {
2746                         msyslog( LOG_ERR, "refclock_jjy.c : jjy_start_telephone : phone in the ntpd.conf should be a number or a hyphen." ) ;
2747                         up->bInitError = TRUE ;
2748                         return 1 ;
2749                 }
2750         }
2751         sFirstThreeDigits[iFirstThreeDigitsCount] = 0 ;
2752
2753         if ( iCommaCount == 1 ) {
2754                 if ( iCommaPosition != 1 || *sys_phone[0] != '0' ) {
2755                         msyslog( LOG_ERR, "refclock_jjy.c : jjy_start_telephone : Getting an outside line should be '0,'." ) ;
2756                         up->bInitError = TRUE ;
2757                         return 1 ;
2758                 }
2759         }
2760
2761         if ( iNumberOfDigitsOfPhoneNumber - iCommaPosition < 6 || 10 < iNumberOfDigitsOfPhoneNumber - iCommaPosition ) {
2762                 /* Too short or too long */
2763                 msyslog( LOG_ERR, "refclock_jjy.c : jjy_start_telephone : phone=%s : Number of digits should be 6 to 10.", sys_phone[0] ) ;
2764                 up->bInitError = TRUE ;
2765                 return 1 ;
2766         }
2767
2768         if ( strncmp( sFirstThreeDigits + iCommaPosition, "00" , 2 ) == 0
2769           || strncmp( sFirstThreeDigits + iCommaPosition, "10" , 2 ) == 0
2770           || strncmp( sFirstThreeDigits + iCommaPosition, "11" , 2 ) == 0
2771           || strncmp( sFirstThreeDigits + iCommaPosition, "12" , 2 ) == 0
2772           || strncmp( sFirstThreeDigits + iCommaPosition, "171", 3 ) == 0
2773           || strncmp( sFirstThreeDigits + iCommaPosition, "177", 3 ) == 0
2774           || ( sFirstThreeDigits[0] == '0' &&  sFirstThreeDigits[2] == '0' ) ) {
2775                 /* Not allowed because of emergency numbers or special service numbers */
2776                 msyslog( LOG_ERR, "refclock_jjy.c : jjy_start_telephone : phone=%s : First 2 or 3 digits are not allowed.", sys_phone[0] ) ;
2777                 up->bInitError = TRUE ;
2778                 return 1 ;
2779         }
2780
2781         snprintf( sLog, sizeof(sLog), "phone=%s", sys_phone[0] ) ;
2782         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_JJY, sLog ) ;
2783
2784         if ( peer->minpoll < 8 ) {
2785                 /* minpoll must be greater or equal to 8 ( 256 seconds = about 4 minutes ) */
2786                 int oldminpoll = peer->minpoll ;
2787                 peer->minpoll = 8 ;
2788                 if ( peer->ppoll < peer->minpoll ) {
2789                         peer->ppoll = peer->minpoll ;
2790                 }
2791                 if ( peer->maxpoll < peer->minpoll ) {
2792                         peer->maxpoll = peer->minpoll ;
2793                 }
2794                 snprintf( sLog, sizeof(sLog), "minpoll=%d -> %d", oldminpoll, peer->minpoll ) ;
2795                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_JJY, sLog ) ;
2796         }
2797
2798         return 0 ;
2799
2800 }
2801
2802 /**************************************************************************************************/
2803
2804 static int
2805 jjy_receive_telephone ( struct recvbuf *rbufp )
2806 {
2807 #ifdef DEBUG
2808         static  const char      *sFunctionName = "jjy_receive_telephone" ;
2809 #endif
2810
2811         struct  peer         *peer;
2812         struct  refclockproc *pp ;
2813         struct  jjyunit      *up ;
2814         char    *pBuf ;
2815         int     iLen ;
2816         short   iPreviousModemState ;
2817
2818         peer = rbufp->recv_peer ;
2819         pp = peer->procptr ;
2820         up = pp->unitptr ;
2821
2822         DEBUG_TELJJY_PRINTF( sFunctionName ) ;
2823
2824         if ( up->iClockState == TELJJY_STATE_IDLE
2825           || up->iClockState == TELJJY_STATE_DAILOUT
2826           || up->iClockState == TELJJY_STATE_BYE ) {
2827
2828                 iPreviousModemState = getModemState( up ) ;
2829
2830                 modem_receive ( rbufp ) ;
2831
2832                 if ( iPreviousModemState != up->iModemState ) {
2833                         /* Modem state is changed just now. */
2834                         if ( isModemStateDisconnect( up->iModemState ) ) {
2835                                 up->iClockEvent = TELJJY_EVENT_DISCONNECT ;
2836                                 teljjy_control ( peer, pp, up ) ;
2837                         } else if ( isModemStateConnect( up->iModemState ) ) {
2838                                 up->iClockEvent = TELJJY_EVENT_CONNECT ;
2839                                 teljjy_control ( peer, pp, up ) ;
2840                         }
2841                 }
2842
2843                 return JJY_RECEIVE_WAIT ;
2844
2845         }
2846
2847         if ( up->linediscipline == LDISC_RAW ) {
2848                 pBuf = up->sTextBuf ;
2849                 iLen = up->iTextBufLen ;
2850         } else {
2851                 pBuf = pp->a_lastcode ;
2852                 iLen = pp->lencode ;
2853         }
2854
2855         up->iTeljjySilentTimer = 0 ;
2856         if      ( iLen == 7 && strncmp( pBuf, "Name ? ", 7 ) == 0 ) { up->iClockEvent = TELJJY_EVENT_LOGIN  ; }
2857         else if ( iLen == 1 && strncmp( pBuf, ">"      , 1 ) == 0 ) { up->iClockEvent = TELJJY_EVENT_PROMPT ; }
2858         else if ( iLen >= 1 && strncmp( pBuf, "?"      , 1 ) == 0 ) { up->iClockEvent = TELJJY_EVENT_ERROR  ; }
2859         else                                                        { up->iClockEvent = TELJJY_EVENT_DATA   ; }
2860
2861         teljjy_control ( peer, pp, up ) ;
2862
2863         return JJY_RECEIVE_WAIT ;
2864
2865 }
2866
2867 /**************************************************************************************************/
2868
2869 static void
2870 jjy_poll_telephone ( int unit, struct peer *peer )
2871 {
2872 #ifdef DEBUG
2873         static const char *sFunctionName = "jjy_poll_telephone" ;
2874 #endif
2875
2876         struct  refclockproc *pp ;
2877         struct  jjyunit      *up ;
2878
2879         pp = peer->procptr ;
2880         up = pp->unitptr ;
2881
2882         DEBUG_TELJJY_PRINTF( sFunctionName ) ;
2883
2884         if ( up->iClockState == TELJJY_STATE_IDLE ) {
2885                 up->iRawBufLen = 0 ;
2886                 up->iLineBufLen = 0 ;
2887                 up->iTextBufLen = 0 ;
2888         }
2889
2890         up->iClockEvent = TELJJY_EVENT_START ;
2891         teljjy_control ( peer, pp, up ) ;
2892
2893 }
2894
2895 /**************************************************************************************************/
2896
2897 static void
2898 jjy_timer_telephone ( int unit, struct peer *peer )
2899 {
2900 #ifdef DEBUG
2901         static const char *sFunctionName = "jjy_timer_telephone" ;
2902 #endif
2903
2904         struct  refclockproc *pp ;
2905         struct  jjyunit      *up ;
2906         short   iPreviousModemState ;
2907
2908         pp = peer->procptr ;
2909         up = pp->unitptr ;
2910
2911         DEBUG_TELJJY_PRINTF( sFunctionName ) ;
2912
2913         if ( iTeljjySilentTimeout[up->iClockState] != 0 ) {
2914                 up->iTeljjySilentTimer++ ;
2915                 if ( iTeljjySilentTimeout[up->iClockState] <= up->iTeljjySilentTimer ) {
2916                         up->iClockEvent = TELJJY_EVENT_SILENT ;
2917                         teljjy_control ( peer, pp, up ) ;
2918                 }
2919         }
2920
2921         if ( iTeljjyStateTimeout[up->iClockState] != 0 ) {
2922                 up->iTeljjyStateTimer++ ;
2923                 if ( iTeljjyStateTimeout[up->iClockState] <= up->iTeljjyStateTimer ) {
2924                         up->iClockEvent = TELJJY_EVENT_TIMEOUT ;
2925                         teljjy_control ( peer, pp, up ) ;
2926                 }
2927         }
2928
2929         if ( isModemStateTimerOn( up ) ) {
2930
2931                 iPreviousModemState = getModemState( up ) ;
2932
2933                 modem_timer ( unit, peer ) ;
2934
2935                 if ( iPreviousModemState != up->iModemState ) {
2936                         /* Modem state is changed just now. */
2937                         if ( isModemStateDisconnect( up->iModemState ) ) {
2938                                 up->iClockEvent = TELJJY_EVENT_DISCONNECT ;
2939                                 teljjy_control ( peer, pp, up ) ;
2940                         } else if ( isModemStateConnect( up->iModemState ) ) {
2941                                 up->iClockEvent = TELJJY_EVENT_CONNECT ;
2942                                 teljjy_control ( peer, pp, up ) ;
2943                         }
2944                 }
2945
2946         }
2947
2948 }
2949
2950 /**************************************************************************************************/
2951
2952 static void
2953 teljjy_control ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
2954 {
2955
2956         int     i, rc ;
2957         short   iPostEvent = TELJJY_EVENT_NULL ;
2958
2959         DEBUG_TELJJY_PRINTF( "teljjy_control" ) ;
2960
2961         rc = (*pTeljjyHandler[up->iClockEvent][up->iClockState])( peer, pp, up ) ;
2962
2963         if ( rc == TELJJY_CHANGE_CLOCK_STATE ) {
2964                 iPostEvent = iTeljjyPostEvent[up->iClockEvent][up->iClockState] ;
2965 #ifdef DEBUG
2966                 if ( debug ) {
2967                         printf( "refclock_jjy.c : teljjy_control : iClockState=%hd -> %hd  iPostEvent=%hd\n",
2968                                 up->iClockState, iTeljjyNextState[up->iClockEvent][up->iClockState], iPostEvent ) ;
2969                 }
2970 #endif
2971                 up->iTeljjySilentTimer = 0 ;
2972                 if ( up->iClockState != iTeljjyNextState[up->iClockEvent][up->iClockState] ) {
2973                         /* Telephone JJY state is changing now */
2974                         up->iTeljjyStateTimer = 0 ;
2975                         up->bLineError = FALSE ;
2976                         up->iClockCommandSeq = 0 ;
2977                         up->iTimestampCount = 0 ;
2978                         up->iLoopbackCount = 0 ;
2979                         for ( i = 0 ; i < MAX_LOOPBACK ; i ++ ) {
2980                                 up->bLoopbackTimeout[i] = FALSE ;
2981                         }
2982                         if (iTeljjyNextState[up->iClockEvent][up->iClockState] == TELJJY_STATE_IDLE ) {
2983                                 /* Telephone JJY state is changing to IDLE just now */
2984                                 up->iProcessState = JJY_PROCESS_STATE_DONE ;
2985                         }
2986                 }
2987                 up->iClockState = iTeljjyNextState[up->iClockEvent][up->iClockState] ;
2988
2989         }
2990
2991         if ( iPostEvent != TELJJY_EVENT_NULL ) {
2992                 up->iClockEvent = iPostEvent ;
2993                 teljjy_control ( peer, pp, up ) ;
2994         }
2995
2996         up->iClockEvent = TELJJY_EVENT_NULL ;
2997
2998 }
2999
3000 /**************************************************************************************************/
3001
3002 static void
3003 teljjy_setDelay ( struct peer *peer, struct jjyunit *up )
3004 {
3005
3006         char    sLog [ 60 ] ;
3007         int     milliSecond, microSecond ;
3008
3009         gettimeofday( &(up->delayTime[up->iLoopbackCount]), NULL ) ;
3010
3011         up->delayTime[up->iLoopbackCount].tv_sec  -= up->sendTime[up->iLoopbackCount].tv_sec ;
3012         up->delayTime[up->iLoopbackCount].tv_usec -= up->sendTime[up->iLoopbackCount].tv_usec ;
3013         if ( up->delayTime[up->iLoopbackCount].tv_usec < 0 ) {
3014                 up->delayTime[up->iLoopbackCount].tv_sec -- ;
3015                 up->delayTime[up->iLoopbackCount].tv_usec += 1000000 ;
3016         }
3017
3018         milliSecond  = up->delayTime[up->iLoopbackCount].tv_usec / 1000 ;
3019         microSecond  = up->delayTime[up->iLoopbackCount].tv_usec - milliSecond * 1000 ;
3020         milliSecond += up->delayTime[up->iLoopbackCount].tv_sec * 1000 ;
3021
3022         snprintf( sLog, sizeof(sLog), JJY_CLOCKSTATS_MESSAGE_LOOPBACK_DELAY,
3023                   milliSecond, microSecond ) ;
3024
3025         if ( milliSecond > TELJJY_LOOPBACK_DELAY_THRESHOLD ) {
3026                 /* Delay > 700 mS */
3027                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_WARNING, sLog ) ;
3028         } else {
3029                 /* Delay <= 700 mS */
3030                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_INFORMATION, sLog ) ;
3031         }
3032
3033 }
3034
3035 /**************************************************************************************************/
3036
3037 static int
3038 teljjy_getDelay ( struct peer *peer, struct jjyunit *up )
3039 {
3040
3041         struct  timeval maxTime, minTime, averTime ;
3042         int     i ;
3043         int     minIndex = 0, maxIndex = 0, iAverCount = 0 ;
3044         int     iThresholdSecond, iThresholdMicroSecond ;
3045         int     iPercent ;
3046
3047         minTime.tv_sec = minTime.tv_usec = 0 ;
3048         maxTime.tv_sec = maxTime.tv_usec = 0 ;
3049
3050         iThresholdSecond = TELJJY_LOOPBACK_DELAY_THRESHOLD / 1000 ;
3051         iThresholdMicroSecond = ( TELJJY_LOOPBACK_DELAY_THRESHOLD - ( TELJJY_LOOPBACK_DELAY_THRESHOLD / 1000 ) * 1000 ) * 1000 ;
3052
3053         up->iLoopbackValidCount = 0 ;
3054
3055         for ( i = 0 ; i < MAX_LOOPBACK && i < up->iLoopbackCount ; i ++ ) {
3056                 if ( up->bLoopbackTimeout[i]
3057                   || up->delayTime[i].tv_sec  > iThresholdSecond
3058                 || ( up->delayTime[i].tv_sec == iThresholdSecond
3059                   && up->delayTime[i].tv_usec > iThresholdMicroSecond ) ) {
3060                         continue ;
3061                 }
3062                 if ( up->iLoopbackValidCount == 0 ) {
3063                         minTime.tv_sec  = up->delayTime[i].tv_sec  ;
3064                         minTime.tv_usec = up->delayTime[i].tv_usec ;
3065                         maxTime.tv_sec  = up->delayTime[i].tv_sec  ;
3066                         maxTime.tv_usec = up->delayTime[i].tv_usec ;
3067                         minIndex = maxIndex = i ;
3068                 } else if ( minTime.tv_sec  > up->delayTime[i].tv_sec
3069                        || ( minTime.tv_sec == up->delayTime[i].tv_sec
3070                          && minTime.tv_usec > up->delayTime[i].tv_usec ) ) {
3071                         minTime.tv_sec  = up->delayTime[i].tv_sec  ;
3072                         minTime.tv_usec = up->delayTime[i].tv_usec ;
3073                         minIndex = i ;
3074                 } else if ( maxTime.tv_sec  < up->delayTime[i].tv_sec
3075                        || ( maxTime.tv_sec == up->delayTime[i].tv_sec
3076                          && maxTime.tv_usec < up->delayTime[i].tv_usec ) ) {
3077                         maxTime.tv_sec  = up->delayTime[i].tv_sec  ;
3078                         maxTime.tv_usec = up->delayTime[i].tv_usec ;
3079                         maxIndex = i ;
3080                 }
3081                 up->iLoopbackValidCount ++ ;
3082         }
3083
3084         if ( up->iLoopbackValidCount < 2 ) {
3085                 return -1 ;
3086         }
3087
3088         averTime.tv_usec = 0;
3089
3090         for ( i = 0 ; i < MAX_LOOPBACK && i < up->iLoopbackCount ; i ++ ) {
3091                 if ( up->bLoopbackTimeout[i]
3092                   || up->delayTime[i].tv_sec  > iThresholdSecond
3093                 || ( up->delayTime[i].tv_sec == iThresholdSecond
3094                   && up->delayTime[i].tv_usec > iThresholdMicroSecond ) ) {
3095                         continue ;
3096                 }
3097                 if ( up->iLoopbackValidCount >= 3 && i == maxIndex ) {
3098                         continue ;
3099                 }
3100                 if ( up->iLoopbackValidCount >= 4 && i == minIndex ) {
3101                         continue ;
3102                 }
3103                 averTime.tv_usec += up->delayTime[i].tv_usec ;
3104                 iAverCount ++ ;
3105         }
3106
3107         if ( iAverCount == 0 ) {
3108                 /* This is never happened. */
3109                 /* Previous for-if-for blocks assure iAverCount > 0. */
3110                 /* This code avoids a claim by the coverity scan tool. */
3111                 return -1 ;
3112         }
3113
3114         /* mode 101 = 1%, mode 150 = 50%, mode 180 = 80% */
3115
3116         iPercent = ( peer->ttl - 100 ) ;
3117
3118         /* Average delay time in milli second */
3119
3120         return ( ( averTime.tv_usec / iAverCount ) * iPercent ) / 100000 ;
3121
3122 }
3123
3124 /******************************/
3125 static int
3126 teljjy_idle_ignore ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3127 {
3128
3129         DEBUG_TELJJY_PRINTF( "teljjy_idle_ignore" ) ;
3130
3131         return TELJJY_STAY_CLOCK_STATE ;
3132
3133 }
3134
3135 /******************************/
3136 static int
3137 teljjy_idle_dialout ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3138 {
3139
3140         DEBUG_TELJJY_PRINTF( "teljjy_idle_dialout" ) ;
3141
3142         modem_connect ( peer->refclkunit, peer ) ;
3143
3144         return TELJJY_CHANGE_CLOCK_STATE ;
3145
3146 }
3147
3148 /******************************/
3149 static int
3150 teljjy_dial_ignore ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3151 {
3152
3153         DEBUG_TELJJY_PRINTF( "teljjy_dial_ignore" ) ;
3154
3155         return TELJJY_STAY_CLOCK_STATE ;
3156
3157 }
3158
3159 /******************************/
3160 static int
3161 teljjy_dial_login ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3162 {
3163
3164         DEBUG_TELJJY_PRINTF( "teljjy_dial_login" ) ;
3165
3166         return TELJJY_CHANGE_CLOCK_STATE ;
3167
3168 }
3169
3170 /******************************/
3171 static int
3172 teljjy_dial_disc ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3173 {
3174
3175         DEBUG_TELJJY_PRINTF( "teljjy_dial_disc" ) ;
3176
3177         return TELJJY_CHANGE_CLOCK_STATE ;
3178
3179 }
3180
3181 /******************************/
3182 static int
3183 teljjy_login_ignore ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3184 {
3185
3186         DEBUG_TELJJY_PRINTF( "teljjy_login_ignore" ) ;
3187
3188         return TELJJY_STAY_CLOCK_STATE ;
3189
3190 }
3191
3192 /******************************/
3193 static int
3194 teljjy_login_disc ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3195 {
3196
3197         DEBUG_TELJJY_PRINTF( "teljjy_login_disc" ) ;
3198
3199         return TELJJY_CHANGE_CLOCK_STATE ;
3200
3201 }
3202
3203 /******************************/
3204 static int
3205 teljjy_login_conn ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3206 {
3207
3208         int     i ;
3209
3210         DEBUG_TELJJY_PRINTF( "teljjy_login_conn" ) ;
3211
3212         up->bLineError = FALSE ;
3213         up->iClockCommandSeq = 0 ;
3214         up->iTimestampCount = 0 ;
3215         up->iLoopbackCount = 0 ;
3216         for ( i = 0 ; i < MAX_LOOPBACK ; i ++ ) {
3217                 up->bLoopbackTimeout[i] = FALSE ;
3218         }
3219
3220         return TELJJY_CHANGE_CLOCK_STATE ;
3221
3222 }
3223
3224 /******************************/
3225 static int
3226 teljjy_login_login ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3227 {
3228
3229         const char *    pCmd ;
3230         int             iCmdLen ;
3231
3232         DEBUG_TELJJY_PRINTF( "teljjy_login_login" ) ;
3233
3234         /* Send a guest user ID */
3235         pCmd = "TJJY\r" ;
3236
3237         /* Send login ID */
3238         iCmdLen = strlen( pCmd ) ;
3239         if ( write( pp->io.fd, pCmd, iCmdLen ) != iCmdLen ) {
3240                 refclock_report( peer, CEVNT_FAULT ) ;
3241         }
3242
3243         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_SEND, pCmd ) ;
3244
3245         return TELJJY_STAY_CLOCK_STATE ;
3246
3247 }
3248
3249 /******************************/
3250 static int
3251 teljjy_login_silent ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3252 {
3253
3254         DEBUG_TELJJY_PRINTF( "teljjy_login_silent" ) ;
3255
3256         if ( write( pp->io.fd, "\r", 1 ) != 1 ) {
3257                 refclock_report( peer, CEVNT_FAULT ) ;
3258         }
3259
3260         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_SEND, "\r" ) ;
3261
3262         up->iTeljjySilentTimer = 0 ;
3263
3264         return TELJJY_CHANGE_CLOCK_STATE ;
3265
3266 }
3267
3268 /******************************/
3269 static int
3270 teljjy_login_error ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3271 {
3272
3273         DEBUG_TELJJY_PRINTF( "teljjy_login_error" ) ;
3274
3275         return TELJJY_CHANGE_CLOCK_STATE ;
3276
3277 }
3278
3279 /******************************/
3280 static int
3281 teljjy_conn_ignore ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3282 {
3283
3284         DEBUG_TELJJY_PRINTF( "teljjy_conn_ignore" ) ;
3285
3286         return TELJJY_STAY_CLOCK_STATE ;
3287
3288 }
3289
3290 /******************************/
3291 static int
3292 teljjy_conn_disc ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3293 {
3294
3295         DEBUG_TELJJY_PRINTF( "teljjy_conn_disc" ) ;
3296
3297         return TELJJY_CHANGE_CLOCK_STATE ;
3298
3299 }
3300
3301 /******************************/
3302 static int
3303 teljjy_conn_send ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3304 {
3305
3306         const char *    pCmd ;
3307         int             i, iLen, iNextClockState ;
3308         char    sLog [ 120 ] ;
3309
3310         DEBUG_TELJJY_PRINTF( "teljjy_conn_send" ) ;
3311
3312         if ( up->iClockCommandSeq > 0
3313           && teljjy_command_sequence[up->iClockCommandSeq].command == NULL ) {
3314                 /* Command sequence has been completed */
3315                 return TELJJY_CHANGE_CLOCK_STATE ;
3316         }
3317
3318         if ( up->iClockCommandSeq == 0 && peer->ttl == 100 ) {
3319                 /* Skip loopback */
3320
3321                 up->iClockCommandSeq = TELJJY_COMMAND_START_SKIP_LOOPBACK ;
3322
3323         } else if ( up->iClockCommandSeq == 0 && peer->ttl != 100 ) {
3324                 /* Loopback start */
3325
3326                 up->iLoopbackCount = 0 ;
3327                 for ( i = 0 ; i < MAX_LOOPBACK ; i ++ ) {
3328                         up->bLoopbackTimeout[i] = FALSE ;
3329                 }
3330
3331         } else if ( up->iClockCommandSeq > 0 && peer->ttl != 100
3332                  && teljjy_command_sequence[up->iClockCommandSeq].iExpectedReplyType == TELJJY_REPLY_LOOPBACK
3333                  && up->iLoopbackCount < MAX_LOOPBACK ) {
3334                 /* Loopback character comes */
3335 #ifdef DEBUG
3336                 if ( debug ) {
3337                         printf( "refclock_jjy.c : teljjy_conn_send : iClockCommandSeq=%d iLoopbackCount=%d\n",
3338                                  up->iClockCommandSeq, up->iLoopbackCount ) ;
3339                 }
3340 #endif
3341
3342                 teljjy_setDelay( peer, up ) ;
3343
3344                 up->iLoopbackCount ++ ;
3345
3346         }
3347
3348         up->iClockCommandSeq++ ;
3349
3350         pCmd = teljjy_command_sequence[up->iClockCommandSeq].command ;
3351         iLen = teljjy_command_sequence[up->iClockCommandSeq].commandLength ;
3352
3353         if ( pCmd != NULL ) {
3354
3355                 if ( write( pp->io.fd, pCmd, iLen ) != iLen ) {
3356                         refclock_report( peer, CEVNT_FAULT ) ;
3357                 }
3358
3359                 if ( teljjy_command_sequence[up->iClockCommandSeq].iExpectedReplyType == TELJJY_REPLY_LOOPBACK ) {
3360                         /* Loopback character and timestamp */
3361                         if ( up->iLoopbackCount < MAX_LOOPBACK ) {
3362                                 gettimeofday( &(up->sendTime[up->iLoopbackCount]), NULL ) ;
3363                                 up->bLoopbackMode = TRUE ;
3364                         } else {
3365                                 /* This else-block is never come. */
3366                                 /* This code avoid wrong report of the coverity static analysis scan tool. */
3367                                 snprintf( sLog, sizeof(sLog)-1, "refclock_jjy.c ; teljjy_conn_send ; iClockCommandSeq=%d iLoopbackCount=%d MAX_LOOPBACK=%d",
3368                                           up->iClockCommandSeq, up->iLoopbackCount, MAX_LOOPBACK ) ;
3369                                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_BUG, sLog ) ;
3370                                 msyslog ( LOG_ERR, "%s", sLog ) ;
3371                                 up->bLoopbackMode = FALSE ;
3372                         }
3373                 } else {
3374                         /* Regular command */
3375                         up->bLoopbackMode = FALSE ;
3376                 }
3377
3378                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_SEND, pCmd ) ;
3379
3380                 if ( teljjy_command_sequence[up->iClockCommandSeq+1].command == NULL ) {
3381                         /* Last command of the command sequence */
3382                         iNextClockState = TELJJY_CHANGE_CLOCK_STATE ;
3383                 } else {
3384                         /* More commands to be issued */
3385                         iNextClockState = TELJJY_STAY_CLOCK_STATE ;
3386                 }
3387
3388         } else {
3389
3390                 iNextClockState = TELJJY_CHANGE_CLOCK_STATE ;
3391
3392         }
3393
3394         return iNextClockState ;
3395
3396 }
3397
3398 /******************************/
3399 static int
3400 teljjy_conn_data ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3401 {
3402
3403         char    *pBuf ;
3404         int     iLen, rc ;
3405         char    sLog [ 80 ] ;
3406         char    bAdjustment ;
3407
3408
3409         DEBUG_TELJJY_PRINTF( "teljjy_conn_data" ) ;
3410
3411         if ( up->linediscipline == LDISC_RAW ) {
3412                 pBuf = up->sTextBuf ;
3413                 iLen = up->iTextBufLen ;
3414         } else {
3415                 pBuf = pp->a_lastcode ;
3416                 iLen = pp->lencode ;
3417         }
3418
3419         if ( teljjy_command_sequence[up->iClockCommandSeq].iEchobackReplyLength == iLen
3420           && teljjy_command_sequence[up->iClockCommandSeq].iExpectedReplyType == TELJJY_REPLY_LOOPBACK
3421           && up->sTextBuf[0] == *(teljjy_command_sequence[up->iClockCommandSeq].command)
3422           && up->iLoopbackCount < MAX_LOOPBACK ) {
3423                 /* Loopback */
3424
3425                 teljjy_setDelay( peer, up ) ;
3426
3427                 up->iLoopbackCount ++ ;
3428
3429         } else if ( teljjy_command_sequence[up->iClockCommandSeq].iEchobackReplyLength == iLen
3430             && strncmp( pBuf, teljjy_command_sequence[up->iClockCommandSeq].command, iLen ) == 0 ) {
3431                 /* Maybe echoback */
3432
3433                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_INFORMATION, JJY_CLOCKSTATS_MESSAGE_ECHOBACK ) ;
3434
3435         } else if ( teljjy_command_sequence[up->iClockCommandSeq].iExpectedReplyLength == iLen
3436                  && teljjy_command_sequence[up->iClockCommandSeq].iExpectedReplyType == TELJJY_REPLY_4DATE ) {
3437                 /* 4DATE<CR> -> YYYYMMDD<CR> */
3438
3439                 rc = sscanf ( pBuf, "%4d%2d%2d", &up->year, &up->month, &up->day ) ;
3440
3441                 if ( rc != 3 || up->year < 2000 || 2099 <= up->year
3442                   || up->month < 1 || 12 < up->month || up->day < 1 || 31 < up->day ) {
3443                         /* Invalid date */
3444                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_DATE,
3445                                   rc, up->year, up->month, up->day ) ;
3446                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
3447                         up->bLineError = TRUE ;
3448                 }
3449
3450         } else if ( teljjy_command_sequence[up->iClockCommandSeq].iExpectedReplyLength == iLen
3451                  && teljjy_command_sequence[up->iClockCommandSeq].iExpectedReplyType == TELJJY_REPLY_LEAPSEC
3452                  && ( strncmp( pBuf, " 0", 2 ) == 0 || strncmp( pBuf, "+1", 2 ) == 0 || strncmp( pBuf, "-1", 2 ) == 0 ) ) {
3453                 /* LEAPSEC<CR> -> XX<CR> ( One of <SP>0, +1, -1 ) */
3454
3455                 rc = sscanf ( pBuf, "%2d", &up->leapsecond ) ;
3456
3457                 if ( rc != 1 || up->leapsecond < -1 || 1 < up->leapsecond ) {
3458                         /* Invalid leap second */
3459                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_LEAP,
3460                                   pBuf ) ;
3461                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
3462                         up->bLineError = TRUE ;
3463                 }
3464
3465         } else if ( teljjy_command_sequence[up->iClockCommandSeq].iExpectedReplyLength == iLen
3466                  && teljjy_command_sequence[up->iClockCommandSeq].iExpectedReplyType == TELJJY_REPLY_TIME ) {
3467                 /* TIME<CR> -> HHMMSS<CR> ( 3 times on second ) */
3468
3469                 rc = sscanf ( pBuf, "%2d%2d%2d", &up->hour, &up->minute, &up->second ) ;
3470
3471                 if ( rc != 3 || up->hour > 23 || up->minute > 59 || up->second > 60 ) {
3472                         /* Invalid time */
3473                         snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_SSCANF_INVALID_TIME,
3474                                   rc, up->hour, up->minute, up->second ) ;
3475                         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
3476                         up->bLineError = TRUE ;
3477                 }
3478                 up->iTimestamp[up->iTimestampCount] = ( up->hour * 60 + up->minute ) * 60 + up->second ;
3479
3480                 up->iTimestampCount++ ;
3481
3482                 if ( up->iTimestampCount == 6 && ! up->bLineError ) {
3483 #if DEBUG
3484                         printf( "refclock_jjy.c : teljjy_conn_data : bLineError=%d iTimestamp=%d, %d, %d\n",
3485                                 up->bLineError,
3486                                 up->iTimestamp[3], up->iTimestamp[4], up->iTimestamp[5] ) ;
3487 #endif
3488                         bAdjustment = TRUE ;
3489
3490                         if ( peer->ttl == 100 ) {
3491                                 /* mode=100 */
3492                                 up->msecond = 0 ;
3493                         } else {
3494                                 /* mode=101 to 110 */
3495                                 up->msecond = teljjy_getDelay( peer, up ) ;
3496                                 if (up->msecond < 0 ) {
3497                                         up->msecond = 0 ;
3498                                         bAdjustment = FALSE ;
3499                                 }
3500                         }
3501
3502                         if ( ( up->iTimestamp[3] - 15 ) <= up->iTimestamp[2]
3503                           &&   up->iTimestamp[2]        <= up->iTimestamp[3]
3504                           && ( up->iTimestamp[3] +  1 ) == up->iTimestamp[4]
3505                           && ( up->iTimestamp[4] +  1 ) == up->iTimestamp[5] ) {
3506                                 /* Non over midnight */
3507
3508                                 jjy_synctime( peer, pp, up ) ;
3509
3510                                 if ( peer->ttl != 100 ) {
3511                                         if ( bAdjustment ) {
3512                                                 snprintf( sLog, sizeof(sLog),
3513                                                           JJY_CLOCKSTATS_MESSAGE_DELAY_ADJUST,
3514                                                           up->msecond, up->iLoopbackValidCount, MAX_LOOPBACK ) ;
3515                                                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_INFORMATION, sLog ) ;
3516                                         } else {
3517                                                 snprintf( sLog, sizeof(sLog),
3518                                                           JJY_CLOCKSTATS_MESSAGE_DELAY_UNADJUST,
3519                                                            up->iLoopbackValidCount, MAX_LOOPBACK ) ;
3520                                                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
3521                                         }
3522                                 }
3523
3524                         }
3525                 }
3526
3527         } else if ( teljjy_command_sequence[up->iClockCommandSeq].iEchobackReplyLength != iLen
3528                  && teljjy_command_sequence[up->iClockCommandSeq].iExpectedReplyType == TELJJY_REPLY_LOOPBACK ) {
3529                 /* Loopback noise ( Unexpected replay ) */
3530
3531                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_IGNORE_REPLY,
3532                           pBuf ) ;
3533                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_WARNING, sLog ) ;
3534
3535         } else {
3536
3537                 up->bLineError = TRUE ;
3538
3539                 snprintf( sLog, sizeof(sLog)-1, JJY_CLOCKSTATS_MESSAGE_UNEXPECTED_REPLY,
3540                           pBuf ) ;
3541                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_ERROR, sLog ) ;
3542
3543         }
3544
3545         return TELJJY_STAY_CLOCK_STATE ;
3546
3547 }
3548
3549 /******************************/
3550 static int
3551 teljjy_conn_silent ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3552 {
3553
3554         const char *    pCmd ;
3555
3556         DEBUG_TELJJY_PRINTF( "teljjy_conn_silent" ) ;
3557
3558         if ( up->iClockCommandSeq >= 1
3559           && up->iClockCommandSeq < TELJJY_COMMAND_START_SKIP_LOOPBACK ) {
3560                 /* Loopback */
3561 #ifdef DEBUG
3562                 if ( debug ) {
3563                         printf( "refclock_jjy.c : teljjy_conn_silent : call teljjy_conn_send\n" ) ;
3564                 }
3565 #endif
3566                 if ( teljjy_command_sequence[up->iClockCommandSeq].iExpectedReplyType == TELJJY_REPLY_LOOPBACK ) {
3567                         up->bLoopbackTimeout[up->iLoopbackCount] = TRUE ;
3568                 }
3569                 up->iTeljjySilentTimer = 0 ;
3570                 return teljjy_conn_send( peer, pp, up ) ;
3571         } else {
3572                 pCmd = "\r" ;
3573         }
3574
3575         if ( write( pp->io.fd, pCmd, 1 ) != 1 ) {
3576                 refclock_report( peer, CEVNT_FAULT ) ;
3577         }
3578
3579         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_SEND, pCmd ) ;
3580
3581         up->iTeljjySilentTimer = 0 ;
3582
3583         return TELJJY_STAY_CLOCK_STATE ;
3584
3585 }
3586
3587 /******************************/
3588 static int
3589 teljjy_conn_error ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3590 {
3591
3592         DEBUG_TELJJY_PRINTF( "teljjy_conn_error" ) ;
3593
3594         return TELJJY_CHANGE_CLOCK_STATE ;
3595
3596 }
3597
3598 /******************************/
3599 static int
3600 teljjy_bye_ignore ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3601 {
3602
3603         DEBUG_TELJJY_PRINTF( "teljjy_bye_ignore" ) ;
3604
3605         return TELJJY_STAY_CLOCK_STATE ;
3606
3607 }
3608
3609 /******************************/
3610 static int
3611 teljjy_bye_disc ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3612 {
3613
3614         DEBUG_TELJJY_PRINTF( "teljjy_bye_disc" ) ;
3615
3616         return TELJJY_CHANGE_CLOCK_STATE ;
3617
3618 }
3619
3620 /******************************/
3621 static int
3622 teljjy_bye_modem ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3623 {
3624
3625         DEBUG_TELJJY_PRINTF( "teljjy_bye_modem" ) ;
3626
3627         modem_disconnect ( peer->refclkunit, peer ) ;
3628
3629         return TELJJY_STAY_CLOCK_STATE ;
3630
3631 }
3632
3633 /*################################################################################################*/
3634 /*################################################################################################*/
3635 /*##                                                                                            ##*/
3636 /*##    Modem control finite state machine                                                      ##*/
3637 /*##                                                                                            ##*/
3638 /*################################################################################################*/
3639 /*################################################################################################*/
3640
3641 /* struct jjyunit.iModemState */
3642
3643 #define MODEM_STATE_DISCONNECT          0
3644 #define MODEM_STATE_INITIALIZE          1
3645 #define MODEM_STATE_DAILING             2
3646 #define MODEM_STATE_CONNECT             3
3647 #define MODEM_STATE_ESCAPE              4
3648
3649 /* struct jjyunit.iModemEvent */
3650
3651 #define MODEM_EVENT_NULL                0
3652 #define MODEM_EVENT_INITIALIZE          1
3653 #define MODEM_EVENT_DIALOUT             2
3654 #define MODEM_EVENT_DISCONNECT          3
3655 #define MODEM_EVENT_RESP_OK             4
3656 #define MODEM_EVENT_RESP_CONNECT        5
3657 #define MODEM_EVENT_RESP_RING           6
3658 #define MODEM_EVENT_RESP_NO_CARRIER     7
3659 #define MODEM_EVENT_RESP_ERROR          8
3660 #define MODEM_EVENT_RESP_CONNECT_X      9
3661 #define MODEM_EVENT_RESP_NO_DAILTONE    10
3662 #define MODEM_EVENT_RESP_BUSY           11
3663 #define MODEM_EVENT_RESP_NO_ANSWER      12
3664 #define MODEM_EVENT_RESP_UNKNOWN        13
3665 #define MODEM_EVENT_SILENT              14
3666 #define MODEM_EVENT_TIMEOUT             15
3667
3668 /* Function prototypes */
3669
3670 static  void    modem_control           ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3671
3672 static  int     modem_disc_ignore       ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3673 static  int     modem_disc_init         ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3674 static  int     modem_init_ignore       ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3675 static  int     modem_init_start        ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3676 static  int     modem_init_disc         ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3677 static  int     modem_init_resp00       ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3678 static  int     modem_init_resp04       ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3679 static  int     modem_dial_ignore       ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3680 static  int     modem_dial_dialout      ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3681 static  int     modem_dial_escape       ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3682 static  int     modem_dial_connect      ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3683 static  int     modem_dial_disc         ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3684 static  int     modem_conn_ignore       ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3685 static  int     modem_conn_escape       ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3686 static  int     modem_esc_ignore        ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3687 static  int     modem_esc_escape        ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3688 static  int     modem_esc_data          ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3689 static  int     modem_esc_silent        ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3690 static  int     modem_esc_disc          ( struct peer *, struct refclockproc *, struct jjyunit * ) ;
3691
3692 static int ( *pModemHandler [ ] [ 5 ] ) ( struct peer *, struct refclockproc *, struct jjyunit * ) =
3693 {                               /*STATE_DISCONNECT   STATE_INITIALIZE   STATE_DAILING       STATE_CONNECT      STATE_ESCAPE     */
3694 /* NULL                 */      { modem_disc_ignore, modem_init_ignore, modem_dial_ignore , modem_conn_ignore, modem_esc_ignore },
3695 /* INITIALIZE           */      { modem_disc_init  , modem_init_start , modem_dial_ignore , modem_conn_ignore, modem_esc_ignore },
3696 /* DIALOUT              */      { modem_disc_ignore, modem_init_ignore, modem_dial_dialout, modem_conn_ignore, modem_esc_ignore },
3697 /* DISCONNECT           */      { modem_disc_ignore, modem_init_disc  , modem_dial_escape , modem_conn_escape, modem_esc_escape },
3698 /* RESP: 0: OK          */      { modem_disc_ignore, modem_init_resp00, modem_dial_ignore , modem_conn_ignore, modem_esc_data   },
3699 /* RESP: 1: CONNECT     */      { modem_disc_ignore, modem_init_ignore, modem_dial_connect, modem_conn_ignore, modem_esc_data   },
3700 /* RESP: 2: RING        */      { modem_disc_ignore, modem_init_ignore, modem_dial_ignore , modem_conn_ignore, modem_esc_data   },
3701 /* RESP: 3: NO CARRIER  */      { modem_disc_ignore, modem_init_ignore, modem_dial_disc   , modem_conn_ignore, modem_esc_data   },
3702 /* RESP: 4: ERROR       */      { modem_disc_ignore, modem_init_resp04, modem_dial_disc   , modem_conn_ignore, modem_esc_data   },
3703 /* RESP: 5: CONNECT     */      { modem_disc_ignore, modem_init_ignore, modem_dial_connect, modem_conn_ignore, modem_esc_data   },
3704 /* RESP: 6: NO DAILTONE */      { modem_disc_ignore, modem_init_ignore, modem_dial_disc   , modem_conn_ignore, modem_esc_data   },
3705 /* RESP: 7: BUSY        */      { modem_disc_ignore, modem_init_ignore, modem_dial_disc   , modem_conn_ignore, modem_esc_data   },
3706 /* RESP: 8: NO ANSWER   */      { modem_disc_ignore, modem_init_ignore, modem_dial_disc   , modem_conn_ignore, modem_esc_data   },
3707 /* RESP: 9: UNKNOWN     */      { modem_disc_ignore, modem_init_ignore, modem_dial_ignore , modem_conn_ignore, modem_esc_data   },
3708 /* SILENT               */      { modem_disc_ignore, modem_init_ignore, modem_dial_ignore , modem_conn_ignore, modem_esc_silent },
3709 /* TIMEOUT              */      { modem_disc_ignore, modem_init_disc  , modem_dial_escape , modem_conn_escape, modem_esc_disc   }
3710 } ;
3711
3712 static short iModemNextState [ ] [ 5 ] =
3713 {                               /*STATE_DISCONNECT        STATE_INITIALIZE        STATE_DAILING        STATE_CONNECT        STATE_ESCAPE           */
3714 /* NULL                 */      { MODEM_STATE_DISCONNECT, MODEM_STATE_INITIALIZE, MODEM_STATE_DAILING   , MODEM_STATE_CONNECT, MODEM_STATE_ESCAPE     },
3715 /* INITIALIZE           */      { MODEM_STATE_INITIALIZE, MODEM_STATE_INITIALIZE, MODEM_STATE_DAILING   , MODEM_STATE_CONNECT, MODEM_STATE_ESCAPE     },
3716 /* DIALOUT              */      { MODEM_STATE_DISCONNECT, MODEM_STATE_INITIALIZE, MODEM_STATE_DAILING   , MODEM_STATE_CONNECT, MODEM_STATE_ESCAPE     },
3717 /* DISCONNECT           */      { MODEM_STATE_DISCONNECT, MODEM_STATE_DISCONNECT, MODEM_STATE_ESCAPE    , MODEM_STATE_ESCAPE , MODEM_STATE_ESCAPE     },
3718 /* RESP: 0: OK          */      { MODEM_STATE_DISCONNECT, MODEM_STATE_DAILING   , MODEM_STATE_DAILING   , MODEM_STATE_CONNECT, MODEM_STATE_ESCAPE     },
3719 /* RESP: 1: CONNECT     */      { MODEM_STATE_DISCONNECT, MODEM_STATE_INITIALIZE, MODEM_STATE_CONNECT   , MODEM_STATE_CONNECT, MODEM_STATE_ESCAPE     },
3720 /* RESP: 2: RING        */      { MODEM_STATE_DISCONNECT, MODEM_STATE_INITIALIZE, MODEM_STATE_DAILING   , MODEM_STATE_CONNECT, MODEM_STATE_ESCAPE     },
3721 /* RESP: 3: NO CARRIER  */      { MODEM_STATE_DISCONNECT, MODEM_STATE_INITIALIZE, MODEM_STATE_DISCONNECT, MODEM_STATE_CONNECT, MODEM_STATE_ESCAPE     },
3722 /* RESP: 4: ERROR       */      { MODEM_STATE_DISCONNECT, MODEM_STATE_DAILING   , MODEM_STATE_DISCONNECT, MODEM_STATE_CONNECT, MODEM_STATE_ESCAPE     },
3723 /* RESP: 5: CONNECT X   */      { MODEM_STATE_DISCONNECT, MODEM_STATE_INITIALIZE, MODEM_STATE_CONNECT   , MODEM_STATE_CONNECT, MODEM_STATE_ESCAPE     },
3724 /* RESP: 6: NO DAILTONE */      { MODEM_STATE_DISCONNECT, MODEM_STATE_INITIALIZE, MODEM_STATE_DISCONNECT, MODEM_STATE_CONNECT, MODEM_STATE_ESCAPE     },
3725 /* RESP: 7: BUSY        */      { MODEM_STATE_DISCONNECT, MODEM_STATE_INITIALIZE, MODEM_STATE_DISCONNECT, MODEM_STATE_CONNECT, MODEM_STATE_ESCAPE     },
3726 /* RESP: 8: NO ANSWER   */      { MODEM_STATE_DISCONNECT, MODEM_STATE_INITIALIZE, MODEM_STATE_DISCONNECT, MODEM_STATE_CONNECT, MODEM_STATE_ESCAPE     },
3727 /* RESP: 9: UNKNOWN     */      { MODEM_STATE_DISCONNECT, MODEM_STATE_INITIALIZE, MODEM_STATE_DAILING   , MODEM_STATE_CONNECT, MODEM_STATE_ESCAPE     },
3728 /* SILENT               */      { MODEM_STATE_DISCONNECT, MODEM_STATE_INITIALIZE, MODEM_STATE_DAILING   , MODEM_STATE_CONNECT, MODEM_STATE_DISCONNECT },
3729 /* TIMEOUT              */      { MODEM_STATE_DISCONNECT, MODEM_STATE_DISCONNECT, MODEM_STATE_ESCAPE    , MODEM_STATE_ESCAPE , MODEM_STATE_DISCONNECT }
3730 } ;
3731
3732 static short iModemPostEvent [ ] [ 5 ] =
3733 {                               /*STATE_DISCONNECT        STATE_INITIALIZE     STATE_DAILING           STATE_CONNECT           STATE_ESCAPE     */
3734 /* NULL                 */      { MODEM_EVENT_NULL      , MODEM_EVENT_NULL   , MODEM_EVENT_NULL      , MODEM_EVENT_NULL      , MODEM_EVENT_NULL },
3735 /* INITIALIZE           */      { MODEM_EVENT_INITIALIZE, MODEM_EVENT_NULL   , MODEM_EVENT_NULL      , MODEM_EVENT_NULL      , MODEM_EVENT_NULL },
3736 /* DIALOUT              */      { MODEM_EVENT_NULL      , MODEM_EVENT_NULL   , MODEM_EVENT_NULL      , MODEM_EVENT_NULL      , MODEM_EVENT_NULL },
3737 /* DISCONNECT           */      { MODEM_EVENT_NULL      , MODEM_EVENT_NULL   , MODEM_EVENT_DISCONNECT, MODEM_EVENT_DISCONNECT, MODEM_EVENT_NULL },
3738 /* RESP: 0: OK          */      { MODEM_EVENT_NULL      , MODEM_EVENT_DIALOUT, MODEM_EVENT_NULL      , MODEM_EVENT_NULL      , MODEM_EVENT_NULL },
3739 /* RESP: 1: CONNECT     */      { MODEM_EVENT_NULL      , MODEM_EVENT_NULL   , MODEM_EVENT_NULL      , MODEM_EVENT_NULL      , MODEM_EVENT_NULL },
3740 /* RESP: 2: RING        */      { MODEM_EVENT_NULL      , MODEM_EVENT_NULL   , MODEM_EVENT_NULL      , MODEM_EVENT_NULL      , MODEM_EVENT_NULL },
3741 /* RESP: 3: NO CARRIER  */      { MODEM_EVENT_NULL      , MODEM_EVENT_NULL   , MODEM_EVENT_NULL      , MODEM_EVENT_NULL      , MODEM_EVENT_NULL },
3742 /* RESP: 4: ERROR       */      { MODEM_EVENT_NULL      , MODEM_EVENT_DIALOUT, MODEM_EVENT_NULL      , MODEM_EVENT_NULL      , MODEM_EVENT_NULL },
3743 /* RESP: 5: CONNECT X   */      { MODEM_EVENT_NULL      , MODEM_EVENT_NULL   , MODEM_EVENT_NULL      , MODEM_EVENT_NULL      , MODEM_EVENT_NULL },
3744 /* RESP: 6: NO DAILTONE */      { MODEM_EVENT_NULL      , MODEM_EVENT_NULL   , MODEM_EVENT_NULL      , MODEM_EVENT_NULL      , MODEM_EVENT_NULL },
3745 /* RESP: 7: BUSY        */      { MODEM_EVENT_NULL      , MODEM_EVENT_NULL   , MODEM_EVENT_NULL      , MODEM_EVENT_NULL      , MODEM_EVENT_NULL },
3746 /* RESP: 8: NO ANSWER   */      { MODEM_EVENT_NULL      , MODEM_EVENT_NULL   , MODEM_EVENT_NULL      , MODEM_EVENT_NULL      , MODEM_EVENT_NULL },
3747 /* RESP: 9: UNKNOWN     */      { MODEM_EVENT_NULL      , MODEM_EVENT_NULL   , MODEM_EVENT_NULL      , MODEM_EVENT_NULL      , MODEM_EVENT_NULL },
3748 /* SILENT               */      { MODEM_EVENT_NULL      , MODEM_EVENT_NULL   , MODEM_EVENT_NULL      , MODEM_EVENT_NULL      , MODEM_EVENT_NULL },
3749 /* TIMEOUT              */      { MODEM_EVENT_NULL      , MODEM_EVENT_NULL   , MODEM_EVENT_DISCONNECT, MODEM_EVENT_DISCONNECT, MODEM_EVENT_NULL }
3750 } ;
3751
3752 static short iModemSilentTimeout [ 5 ] = { 0,  0,  0, 0,  5 } ;
3753 static short iModemStateTimeout  [ 5 ] = { 0, 20, 90, 0, 20 } ;
3754
3755 #define STAY_MODEM_STATE        0
3756 #define CHANGE_MODEM_STATE      1
3757
3758 #ifdef  DEBUG
3759 #define DEBUG_MODEM_PRINTF(sFunc)       { if ( debug ) { printf ( "refclock_jjy.c : %s : iModemState=%d iModemEvent=%d iModemSilentTimer=%d iModemStateTimer=%d\n", sFunc, up->iModemState, up->iModemEvent, up->iModemSilentTimer, up->iModemStateTimer ) ; } }
3760 #else
3761 #define DEBUG_MODEM_PRINTF(sFunc)
3762 #endif
3763
3764 /**************************************************************************************************/
3765
3766 static short
3767 getModemState ( struct jjyunit *up )
3768 {
3769         return up->iModemState ;
3770 }
3771
3772 /**************************************************************************************************/
3773
3774 static int
3775 isModemStateConnect ( short iCheckState )
3776 {
3777         return ( iCheckState == MODEM_STATE_CONNECT ) ;
3778 }
3779
3780 /**************************************************************************************************/
3781
3782 static int
3783 isModemStateDisconnect ( short iCheckState )
3784 {
3785         return ( iCheckState == MODEM_STATE_DISCONNECT ) ;
3786 }
3787
3788 /**************************************************************************************************/
3789
3790 static int
3791 isModemStateTimerOn ( struct jjyunit *up )
3792 {
3793         return ( iModemSilentTimeout[up->iModemState] != 0 || iModemStateTimeout[up->iModemState] != 0 ) ;
3794 }
3795
3796 /**************************************************************************************************/
3797
3798 static void
3799 modem_connect ( int unit, struct peer *peer )
3800 {
3801         struct  refclockproc    *pp;
3802         struct  jjyunit         *up;
3803
3804         pp = peer->procptr ;
3805         up = pp->unitptr ;
3806
3807         DEBUG_MODEM_PRINTF( "modem_connect" ) ;
3808
3809         up->iModemEvent = MODEM_EVENT_INITIALIZE ;
3810
3811         modem_control ( peer, pp, up ) ;
3812
3813 }
3814
3815 /**************************************************************************************************/
3816
3817 static void
3818 modem_disconnect ( int unit, struct peer *peer )
3819 {
3820         struct  refclockproc    *pp;
3821         struct  jjyunit         *up;
3822
3823         pp = peer->procptr ;
3824         up = pp->unitptr ;
3825
3826         DEBUG_MODEM_PRINTF( "modem_disconnect" ) ;
3827
3828         up->iModemEvent = MODEM_EVENT_DISCONNECT ;
3829
3830         modem_control ( peer, pp, up ) ;
3831
3832 }
3833
3834 /**************************************************************************************************/
3835
3836 static int
3837 modem_receive ( struct recvbuf *rbufp )
3838 {
3839
3840         struct  peer            *peer;
3841         struct  jjyunit         *up;
3842         struct  refclockproc    *pp;
3843         char    *pBuf ;
3844         size_t  iLen ;
3845
3846 #ifdef DEBUG
3847         static const char *sFunctionName = "modem_receive" ;
3848 #endif
3849
3850         peer = rbufp->recv_peer ;
3851         pp = peer->procptr ;
3852         up = pp->unitptr ;
3853
3854         DEBUG_MODEM_PRINTF( sFunctionName ) ;
3855
3856         if ( up->linediscipline == LDISC_RAW ) {
3857                 pBuf = up->sTextBuf ;
3858                 iLen = up->iTextBufLen ;
3859         } else {
3860                 pBuf = pp->a_lastcode ;
3861                 iLen = pp->lencode ;
3862         }
3863
3864         if      ( iLen ==  2 && strncmp( pBuf, "OK"         ,  2 ) == 0 ) { up->iModemEvent = MODEM_EVENT_RESP_OK          ; }
3865         else if ( iLen ==  7 && strncmp( pBuf, "CONNECT"    ,  7 ) == 0 ) { up->iModemEvent = MODEM_EVENT_RESP_CONNECT     ; }
3866         else if ( iLen ==  4 && strncmp( pBuf, "RING"       ,  4 ) == 0 ) { up->iModemEvent = MODEM_EVENT_RESP_RING        ; }
3867         else if ( iLen == 10 && strncmp( pBuf, "NO CARRIER" , 10 ) == 0 ) { up->iModemEvent = MODEM_EVENT_RESP_NO_CARRIER  ; }
3868         else if ( iLen ==  5 && strncmp( pBuf, "ERROR"      ,  5 ) == 0 ) { up->iModemEvent = MODEM_EVENT_RESP_ERROR       ; }
3869         else if ( iLen >=  8 && strncmp( pBuf, "CONNECT "   ,  8 ) == 0 ) { up->iModemEvent = MODEM_EVENT_RESP_CONNECT_X   ; }
3870         else if ( iLen == 11 && strncmp( pBuf, "NO DAILTONE", 11 ) == 0 ) { up->iModemEvent = MODEM_EVENT_RESP_NO_DAILTONE ; }
3871         else if ( iLen ==  4 && strncmp( pBuf, "BUSY"       ,  4 ) == 0 ) { up->iModemEvent = MODEM_EVENT_RESP_BUSY        ; }
3872         else if ( iLen ==  9 && strncmp( pBuf, "NO ANSWER"  ,  9 ) == 0 ) { up->iModemEvent = MODEM_EVENT_RESP_NO_ANSWER   ; }
3873         else                                                              { up->iModemEvent = MODEM_EVENT_RESP_UNKNOWN     ; }
3874
3875 #ifdef DEBUG
3876         if ( debug ) {
3877                 char    sResp [ 40 ] ;
3878                 size_t  iCopyLen ;
3879                 iCopyLen = ( iLen <= sizeof(sResp)-1 ? iLen : sizeof(sResp)-1 ) ;
3880                 strncpy( sResp, pBuf, iLen <= sizeof(sResp)-1 ? iLen : sizeof(sResp)-1 ) ;
3881                 sResp[iCopyLen] = 0 ;
3882                 printf ( "refclock_jjy.c : modem_receive : iLen=%zu pBuf=[%s] iModemEvent=%d\n", iCopyLen, sResp, up->iModemEvent ) ;
3883         }
3884 #endif
3885         modem_control ( peer, pp, up ) ;
3886
3887         return 0 ;
3888
3889 }
3890
3891 /**************************************************************************************************/
3892
3893 static void
3894 modem_timer ( int unit, struct peer *peer )
3895 {
3896
3897         struct  refclockproc *pp ;
3898         struct  jjyunit      *up ;
3899
3900         pp = peer->procptr ;
3901         up = pp->unitptr ;
3902
3903         DEBUG_MODEM_PRINTF( "modem_timer" ) ;
3904
3905         if ( iModemSilentTimeout[up->iModemState] != 0 ) {
3906                 up->iModemSilentTimer++ ;
3907                 if ( iModemSilentTimeout[up->iModemState] <= up->iModemSilentTimer ) {
3908                         up->iModemEvent = MODEM_EVENT_SILENT ;
3909                         modem_control ( peer, pp, up ) ;
3910                 }
3911         }
3912
3913         if ( iModemStateTimeout[up->iModemState] != 0 ) {
3914                 up->iModemStateTimer++ ;
3915                 if ( iModemStateTimeout[up->iModemState] <= up->iModemStateTimer ) {
3916                         up->iModemEvent = MODEM_EVENT_TIMEOUT ;
3917                         modem_control ( peer, pp, up ) ;
3918                 }
3919         }
3920
3921 }
3922
3923 /**************************************************************************************************/
3924
3925 static void
3926 modem_control ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3927 {
3928
3929         int     rc ;
3930         short   iPostEvent = MODEM_EVENT_NULL ;
3931
3932         DEBUG_MODEM_PRINTF( "modem_control" ) ;
3933
3934         rc = (*pModemHandler[up->iModemEvent][up->iModemState])( peer, pp, up ) ;
3935
3936         if ( rc == CHANGE_MODEM_STATE ) {
3937                 iPostEvent = iModemPostEvent[up->iModemEvent][up->iModemState] ;
3938 #ifdef DEBUG
3939                 if ( debug ) {
3940                         printf( "refclock_jjy.c : modem_control : iModemState=%d -> %d  iPostEvent=%d\n",
3941                                  up->iModemState, iModemNextState[up->iModemEvent][up->iModemState], iPostEvent ) ;
3942                 }
3943 #endif
3944
3945                 if ( up->iModemState != iModemNextState[up->iModemEvent][up->iModemState] ) {
3946                         up->iModemSilentCount = 0 ;
3947                         up->iModemStateTimer = 0 ;
3948                         up->iModemCommandSeq = 0 ;
3949                 }
3950
3951                 up->iModemState = iModemNextState[up->iModemEvent][up->iModemState] ;
3952         }
3953
3954         if ( iPostEvent != MODEM_EVENT_NULL ) {
3955                 up->iModemEvent = iPostEvent ;
3956                 modem_control ( peer, pp, up ) ;
3957         }
3958
3959         up->iModemEvent = MODEM_EVENT_NULL ;
3960
3961 }
3962
3963 /******************************/
3964 static int
3965 modem_disc_ignore ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3966 {
3967
3968         DEBUG_MODEM_PRINTF( "modem_disc_ignore" ) ;
3969
3970         return STAY_MODEM_STATE ;
3971
3972 }
3973
3974 /******************************/
3975 static int
3976 modem_disc_init ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3977 {
3978
3979         DEBUG_MODEM_PRINTF( "modem_disc_init" ) ;
3980
3981         return CHANGE_MODEM_STATE ;
3982
3983 }
3984
3985 /******************************/
3986 static int
3987 modem_init_ignore ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3988 {
3989
3990         DEBUG_MODEM_PRINTF( "modem_init_ignore" ) ;
3991
3992         return STAY_MODEM_STATE ;
3993
3994 }
3995
3996 /******************************/
3997 static int
3998 modem_init_start ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
3999 {
4000
4001         DEBUG_MODEM_PRINTF( "modem_init_start" ) ;
4002
4003         up->iModemCommandSeq = 0 ;
4004
4005 #ifdef DEBUG
4006         if ( debug ) {
4007                 printf( "refclock_jjy.c : modem_init_start : call modem_init_resp00\n" ) ;
4008         }
4009 #endif
4010
4011         return modem_init_resp00( peer, pp, up ) ;
4012
4013 }
4014
4015 /******************************/
4016 static int
4017 modem_init_resp00 ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
4018 {
4019
4020         const char *    pCmd ;
4021         char            cBuf [ 46 ] ;
4022         int             iCmdLen ;
4023         int             iErrorCorrection, iSpeakerSwitch, iSpeakerVolume ;
4024         int             iNextModemState = STAY_MODEM_STATE ;
4025
4026         DEBUG_MODEM_PRINTF( "modem_init_resp00" ) ;
4027
4028         up->iModemCommandSeq++ ;
4029
4030         switch ( up->iModemCommandSeq ) {
4031
4032         case 1 :
4033                 /* En = Echoback      0:Off      1:On   */
4034                 /* Qn = Result codes  0:On       1:Off  */
4035                 /* Vn = Result codes  0:Numeric  1:Text */
4036                 pCmd = "ATE0Q0V1\r\n" ;
4037                 break ;
4038
4039         case 2 :
4040                 /* Mn = Speaker switch  0:Off  1:On until remote carrier detected  2:On */
4041                 if ( ( pp->sloppyclockflag & CLK_FLAG3 ) == 0 ) {
4042                         /* fudge 127.127.40.n flag3 0 */
4043                         iSpeakerSwitch = 0 ;
4044                 } else {
4045                         /* fudge 127.127.40.n flag3 1 */
4046                         iSpeakerSwitch = 2 ;
4047                 }
4048
4049                 /* Ln = Speaker volume  0:Very low  1:Low  2:Middle  3:High */
4050                 if ( ( pp->sloppyclockflag & CLK_FLAG4 ) == 0 ) {
4051                         /* fudge 127.127.40.n flag4 0 */
4052                         iSpeakerVolume = 1 ;
4053                 } else {
4054                         /* fudge 127.127.40.n flag4 1 */
4055                         iSpeakerVolume = 2 ;
4056                 }
4057
4058                 pCmd = cBuf ;
4059                 snprintf( cBuf, sizeof(cBuf), "ATM%dL%d\r\n", iSpeakerSwitch, iSpeakerVolume ) ;
4060                 break ;
4061
4062         case 3 :
4063                 /* &Kn = Flow control  4:XON/XOFF */
4064                 pCmd = "AT&K4\r\n" ;
4065                 break ;
4066
4067         case 4 :
4068                 /* +MS = Protocol  V22B:1200,2400bps\81iV.22bis) */
4069                 pCmd = "AT+MS=V22B\r\n" ;
4070                 break ;
4071
4072         case 5 :
4073                 /* %Cn = Data compression  0:No data compression */
4074                 pCmd = "AT%C0\r\n" ;
4075                 break ;
4076
4077         case 6 :
4078                 /* \Nn = Error correction  0:Normal mode  1:Direct mode  2:V42,MNP  3:V42,MNP,Normal */
4079                 if ( ( pp->sloppyclockflag & CLK_FLAG2 ) == 0 ) {
4080                         /* fudge 127.127.40.n flag2 0 */
4081                         iErrorCorrection = 0 ;
4082                 } else {
4083                         /* fudge 127.127.40.n flag2 1 */
4084                         iErrorCorrection = 3 ;
4085                 }
4086
4087                 pCmd = cBuf ;
4088                 snprintf( cBuf, sizeof(cBuf), "AT\\N%d\r\n", iErrorCorrection ) ;
4089                 break ;
4090
4091         case 7 :
4092                 /* Hn = Hook  0:Hook-On ( Disconnect )  1:Hook-Off ( Connect ) */
4093                 pCmd = "ATH1\r\n" ;
4094                 break ;
4095
4096         case 8 :
4097                 /* Initialize completion */
4098                 pCmd = NULL ;
4099                 iNextModemState = CHANGE_MODEM_STATE ;
4100                 break ;
4101
4102         default :
4103                 pCmd = NULL ;
4104                 break ;
4105
4106         }
4107
4108         if ( pCmd != NULL ) {
4109
4110                 iCmdLen = strlen( pCmd ) ;
4111                 if ( write( pp->io.fd, pCmd, iCmdLen ) != iCmdLen ) {
4112                         refclock_report( peer, CEVNT_FAULT ) ;
4113                 }
4114
4115                 jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_SEND, pCmd ) ;
4116
4117         }
4118
4119         return iNextModemState ;
4120
4121 }
4122
4123 /******************************/
4124 static int
4125 modem_init_resp04 ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
4126 {
4127
4128         DEBUG_MODEM_PRINTF( "modem_init_resp04" ) ;
4129
4130         return modem_init_resp00( peer, pp, up ) ;
4131
4132 }
4133
4134 /******************************/
4135 static int
4136 modem_init_disc ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
4137 {
4138
4139         DEBUG_MODEM_PRINTF( "modem_init_disc" ) ;
4140 #ifdef DEBUG
4141         if ( debug ) {
4142                 printf( "refclock_jjy.c : modem_init_disc : call modem_esc_disc\n" ) ;
4143         }
4144 #endif
4145
4146         return CHANGE_MODEM_STATE ;
4147
4148 }
4149
4150 /******************************/
4151 static int
4152 modem_dial_ignore ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
4153 {
4154
4155         DEBUG_MODEM_PRINTF( "modem_dial_ignore" ) ;
4156
4157         return STAY_MODEM_STATE ;
4158
4159 }
4160
4161 /******************************/
4162 static int
4163 modem_dial_dialout ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
4164 {
4165
4166         char    sCmd [ 46 ] ;
4167         int     iCmdLen ;
4168         char    cToneOrPulse ;
4169
4170         DEBUG_MODEM_PRINTF( "modem_dial_dialout" ) ;
4171
4172         /* Tone or Pulse */
4173         if ( ( pp->sloppyclockflag & CLK_FLAG1 ) == 0 ) {
4174                 /* fudge 127.127.40.n flag1 0 */
4175                 cToneOrPulse = 'T' ;
4176         } else {
4177                 /* fudge 127.127.40.n flag1 1 */
4178                 cToneOrPulse = 'P' ;
4179         }
4180
4181         /* Connect ( Dial number ) */
4182         snprintf( sCmd, sizeof(sCmd), "ATDW%c%s\r\n", cToneOrPulse, *sys_phone ) ;
4183
4184         /* Send command */
4185         iCmdLen = strlen( sCmd ) ;
4186         if ( write( pp->io.fd, sCmd, iCmdLen ) != iCmdLen ) {
4187                 refclock_report( peer, CEVNT_FAULT ) ;
4188         }
4189
4190         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_SEND, sCmd ) ;
4191
4192         return STAY_MODEM_STATE ;
4193
4194 }
4195
4196 /******************************/
4197 static int
4198 modem_dial_escape ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
4199 {
4200
4201         DEBUG_MODEM_PRINTF( "modem_dial_escape" ) ;
4202 #ifdef DEBUG
4203         if ( debug ) {
4204                 printf( "refclock_jjy.c : modem_dial_escape : call modem_conn_escape\n" ) ;
4205         }
4206 #endif
4207
4208         return modem_conn_escape( peer, pp, up ) ;
4209
4210 }
4211
4212 /******************************/
4213 static int
4214 modem_dial_connect ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
4215 {
4216
4217         DEBUG_MODEM_PRINTF( "modem_dial_connect" ) ;
4218
4219         return CHANGE_MODEM_STATE ;
4220
4221 }
4222
4223 /******************************/
4224 static int
4225 modem_dial_disc ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
4226 {
4227
4228         DEBUG_MODEM_PRINTF( "modem_dial_disc" ) ;
4229 #ifdef DEBUG
4230         if ( debug ) {
4231                 printf( "refclock_jjy.c : modem_dial_disc : call modem_esc_disc\n" ) ;
4232         }
4233 #endif
4234
4235         modem_esc_disc( peer, pp, up ) ;
4236
4237         return CHANGE_MODEM_STATE ;
4238
4239 }
4240
4241 /******************************/
4242 static int
4243 modem_conn_ignore ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
4244 {
4245
4246         DEBUG_MODEM_PRINTF( "modem_conn_ignore" ) ;
4247
4248         return STAY_MODEM_STATE ;
4249
4250 }
4251
4252 /******************************/
4253 static int
4254 modem_conn_escape ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
4255 {
4256
4257         DEBUG_MODEM_PRINTF( "modem_conn_escape" ) ;
4258
4259         return CHANGE_MODEM_STATE ;
4260
4261 }
4262
4263 /******************************/
4264 static int
4265 modem_esc_ignore ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
4266 {
4267
4268         DEBUG_MODEM_PRINTF( "modem_esc_ignore" ) ;
4269
4270         return STAY_MODEM_STATE ;
4271
4272 }
4273
4274 /******************************/
4275 static int
4276 modem_esc_escape ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
4277 {
4278
4279         const char *    pCmd ;
4280         int             iCmdLen ;
4281
4282         DEBUG_MODEM_PRINTF( "modem_esc_escape" ) ;
4283
4284         /* Escape command ( Go to command mode ) */
4285         pCmd = "+++" ;
4286
4287         /* Send command */
4288         iCmdLen = strlen( pCmd ) ;
4289         if ( write( pp->io.fd, pCmd, iCmdLen ) != iCmdLen ) {
4290                 refclock_report( peer, CEVNT_FAULT ) ;
4291         }
4292
4293         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_SEND, pCmd ) ;
4294
4295         return STAY_MODEM_STATE ;
4296
4297 }
4298
4299 /******************************/
4300 static int
4301 modem_esc_data ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
4302 {
4303
4304         DEBUG_MODEM_PRINTF( "modem_esc_data" ) ;
4305
4306         up->iModemSilentTimer = 0 ;
4307
4308         return STAY_MODEM_STATE ;
4309
4310 }
4311
4312 /******************************/
4313 static int
4314 modem_esc_silent ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
4315 {
4316
4317         DEBUG_MODEM_PRINTF( "modem_esc_silent" ) ;
4318
4319         up->iModemSilentCount ++ ;
4320
4321         if ( up->iModemSilentCount < iModemStateTimeout[up->iModemState] / iModemSilentTimeout[up->iModemState] ) {
4322 #ifdef DEBUG
4323                 if ( debug ) {
4324                         printf( "refclock_jjy.c : modem_esc_silent : call modem_esc_escape\n" ) ;
4325                 }
4326 #endif
4327                 modem_esc_escape( peer, pp, up ) ;
4328                 up->iModemSilentTimer = 0 ;
4329                 return STAY_MODEM_STATE ;
4330         }
4331
4332 #ifdef DEBUG
4333         if ( debug ) {
4334                 printf( "refclock_jjy.c : modem_esc_silent : call modem_esc_disc\n" ) ;
4335         }
4336 #endif
4337         return modem_esc_disc( peer, pp, up ) ;
4338
4339 }
4340 /******************************/
4341 static int
4342 modem_esc_disc ( struct peer *peer, struct refclockproc *pp, struct jjyunit *up )
4343 {
4344
4345         const char *    pCmd ;
4346         int             iCmdLen ;
4347
4348         DEBUG_MODEM_PRINTF( "modem_esc_disc" ) ;
4349
4350         /* Disconnect */
4351         pCmd = "ATH0\r\n" ;
4352
4353         /* Send command */
4354         iCmdLen = strlen( pCmd ) ;
4355         if ( write( pp->io.fd, pCmd, iCmdLen ) != iCmdLen ) {
4356                 refclock_report( peer, CEVNT_FAULT ) ;
4357         }
4358
4359         jjy_write_clockstats( peer, JJY_CLOCKSTATS_MARK_SEND, pCmd ) ;
4360
4361         return CHANGE_MODEM_STATE ;
4362
4363 }
4364
4365 /*################################################################################################*/
4366 /*################################################################################################*/
4367 /*##                                                                                            ##*/
4368 /*##    jjy_write_clockstats                                                                    ##*/
4369 /*##                                                                                            ##*/
4370 /*################################################################################################*/
4371 /*################################################################################################*/
4372
4373 static void
4374 jjy_write_clockstats ( struct peer *peer, int iMark, const char *pData )
4375 {
4376
4377         char            sLog [ 100 ] ;
4378         const char *    pMark ;
4379         int             iMarkLen, iDataLen ;
4380
4381         switch ( iMark ) {
4382         case JJY_CLOCKSTATS_MARK_JJY :
4383                 pMark = "JJY " ;
4384                 break ;
4385         case JJY_CLOCKSTATS_MARK_SEND :
4386                 pMark = "--> " ;
4387                 break ;
4388         case JJY_CLOCKSTATS_MARK_RECEIVE :
4389                 pMark = "<-- " ;
4390                 break ;
4391         case JJY_CLOCKSTATS_MARK_INFORMATION :
4392                 pMark = "--- " ;
4393                 break ;
4394         case JJY_CLOCKSTATS_MARK_ATTENTION :
4395                 pMark = "=== " ;
4396                 break ;
4397         case JJY_CLOCKSTATS_MARK_WARNING :
4398                 pMark = "-W- " ;
4399                 break ;
4400         case JJY_CLOCKSTATS_MARK_ERROR :
4401                 pMark = "-X- " ;
4402                 break ;
4403         case JJY_CLOCKSTATS_MARK_BUG :
4404                 pMark = "!!! " ;
4405                 break ;
4406         default :
4407                 pMark = "" ;
4408                 break ;
4409         }
4410
4411         iDataLen = strlen( pData ) ;
4412         iMarkLen = strlen( pMark ) ;
4413         strcpy( sLog, pMark ) ; /* Harmless because of enough length */
4414         printableString( sLog+iMarkLen, sizeof(sLog)-iMarkLen, pData, iDataLen ) ;
4415
4416 #ifdef DEBUG
4417         if ( debug ) {
4418                 printf( "refclock_jjy.c : clockstats : %s\n", sLog ) ;
4419         }
4420 #endif
4421         record_clock_stats( &peer->srcadr, sLog ) ;
4422
4423 }
4424
4425 /*################################################################################################*/
4426 /*################################################################################################*/
4427 /*##                                                                                            ##*/
4428 /*##    printableString                                                                         ##*/
4429 /*##                                                                                            ##*/
4430 /*################################################################################################*/
4431 /*################################################################################################*/
4432
4433 static void
4434 printableString ( char *sOutput, int iOutputLen, const char *sInput, int iInputLen )
4435 {
4436         const char      *printableControlChar[] = {
4437                         "<NUL>", "<SOH>", "<STX>", "<ETX>",
4438                         "<EOT>", "<ENQ>", "<ACK>", "<BEL>",
4439                         "<BS>" , "<HT>" , "<LF>" , "<VT>" ,
4440                         "<FF>" , "<CR>" , "<SO>" , "<SI>" ,
4441                         "<DLE>", "<DC1>", "<DC2>", "<DC3>",
4442                         "<DC4>", "<NAK>", "<SYN>", "<ETB>",
4443                         "<CAN>", "<EM>" , "<SUB>", "<ESC>",
4444                         "<FS>" , "<GS>" , "<RS>" , "<US>" ,
4445                         " " } ;
4446
4447         size_t  i, j, n ;
4448         size_t  InputLen;
4449         size_t  OutputLen;
4450
4451         InputLen = (size_t)iInputLen;
4452         OutputLen = (size_t)iOutputLen;
4453         for ( i = j = 0 ; i < InputLen && j < OutputLen ; i ++ ) {
4454                 if ( isprint( (unsigned char)sInput[i] ) ) {
4455                         n = 1 ;
4456                         if ( j + 1 >= OutputLen )
4457                                 break ;
4458                         sOutput[j] = sInput[i] ;
4459                 } else if ( ( sInput[i] & 0xFF ) <
4460                             COUNTOF(printableControlChar) ) {
4461                         n = strlen( printableControlChar[sInput[i] & 0xFF] ) ;
4462                         if ( j + n + 1 >= OutputLen )
4463                                 break ;
4464                         strlcpy( sOutput + j,
4465                                  printableControlChar[sInput[i] & 0xFF],
4466                                  OutputLen - j ) ;
4467                 } else {
4468                         n = 5 ;
4469                         if ( j + n + 1 >= OutputLen )
4470                                 break ;
4471                         snprintf( sOutput + j, OutputLen - j, "<x%X>",
4472                                   sInput[i] & 0xFF ) ;
4473                 }
4474                 j += n ;
4475         }
4476
4477         sOutput[min(j, (size_t)iOutputLen - 1)] = '\0' ;
4478
4479 }
4480
4481 /**************************************************************************************************/
4482
4483 #else
4484 int refclock_jjy_bs ;
4485 #endif /* REFCLOCK */