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