#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#if defined(REFCLOCK) && defined(CLOCK_PARSE) && defined(CLOCK_RAWDCF)
#include "ntp_fp.h"
#include "ntp_unixtime.h"
#include "ntp_calendar.h"
#include "parse.h"
#ifdef PARSESTREAM
# include <sys/parsestreams.h>
#endif
#ifndef PARSEKERNEL
# include "ntp_stdlib.h"
#endif
static u_long pps_rawdcf P((parse_t *, int, timestamp_t *));
static u_long cvt_rawdcf P((unsigned char *, int, struct format *, clocktime_t *, void *));
static u_long inp_rawdcf P((parse_t *, unsigned int, timestamp_t *));
typedef struct last_tcode {
time_t tcode;
} last_tcode_t;
clockformat_t clock_rawdcf =
{
inp_rawdcf,
cvt_rawdcf,
pps_rawdcf,
0,
"RAW DCF77 Timecode",
61,
sizeof(last_tcode_t)
};
static struct dcfparam
{
unsigned char onebits[60];
unsigned char zerobits[60];
} dcfparameter =
{
"###############RADMLS1248124P124812P1248121241248112481248P",
"--------------------s-------p------p----------------------p"
};
static struct rawdcfcode
{
char offset;
} rawdcfcode[] =
{
{ 0 }, { 15 }, { 16 }, { 17 }, { 19 }, { 20 }, { 21 }, { 25 }, { 28 }, { 29 },
{ 33 }, { 35 }, { 36 }, { 40 }, { 42 }, { 45 }, { 49 }, { 50 }, { 54 }, { 58 }, { 59 }
};
#define DCF_M 0
#define DCF_R 1
#define DCF_A1 2
#define DCF_Z 3
#define DCF_A2 4
#define DCF_S 5
#define DCF_M1 6
#define DCF_M10 7
#define DCF_P1 8
#define DCF_H1 9
#define DCF_H10 10
#define DCF_P2 11
#define DCF_D1 12
#define DCF_D10 13
#define DCF_DW 14
#define DCF_MO 15
#define DCF_MO0 16
#define DCF_Y1 17
#define DCF_Y10 18
#define DCF_P3 19
static struct partab
{
char offset;
} partab[] =
{
{ 21 }, { 29 }, { 36 }, { 59 }
};
#define DCF_P_P1 0
#define DCF_P_P2 1
#define DCF_P_P3 2
#define DCF_Z_MET 0x2
#define DCF_Z_MED 0x1
static u_long
ext_bf(
register unsigned char *buf,
register int idx,
register unsigned char *zero
)
{
register u_long sum = 0;
register int i, first;
first = rawdcfcode[idx].offset;
for (i = rawdcfcode[idx+1].offset - 1; i >= first; i--)
{
sum <<= 1;
sum |= (buf[i] != zero[i]);
}
return sum;
}
static unsigned
pcheck(
unsigned char *buf,
int idx,
unsigned char *zero
)
{
int i,last;
unsigned psum = 1;
last = partab[idx+1].offset;
for (i = partab[idx].offset; i < last; i++)
psum ^= (buf[i] != zero[i]);
return psum;
}
static u_long
convert_rawdcf(
unsigned char *buffer,
int size,
struct dcfparam *dcfprm,
clocktime_t *clock_time
)
{
register unsigned char *s = buffer;
register unsigned char *b = dcfprm->onebits;
register unsigned char *c = dcfprm->zerobits;
register int i;
parseprintf(DD_RAWDCF,("parse: convert_rawdcf: \"%s\"\n", buffer));
if (size < 57)
{
#ifndef PARSEKERNEL
msyslog(LOG_ERR, "parse: convert_rawdcf: INCOMPLETE DATA - time code only has %d bits\n", size);
#endif
return CVT_NONE;
}
for (i = 0; i < 58; i++)
{
if ((*s != *b) && (*s != *c))
{
#ifndef PARSEKERNEL
msyslog(LOG_ERR, "parse: convert_rawdcf: BAD DATA - no conversion for \"%s\"\n", buffer);
#endif
return CVT_NONE;
}
b++;
c++;
s++;
}
if ((ext_bf(buffer, DCF_S, dcfprm->zerobits) == 1) &&
pcheck(buffer, DCF_P_P1, dcfprm->zerobits) &&
pcheck(buffer, DCF_P_P2, dcfprm->zerobits) &&
pcheck(buffer, DCF_P_P3, dcfprm->zerobits))
{
parseprintf(DD_RAWDCF,("parse: convert_rawdcf: parity check passed\n"));
clock_time->flags = PARSEB_S_ANTENNA|PARSEB_S_LEAP;
clock_time->utctime= 0;
clock_time->usecond= 0;
clock_time->second = 0;
clock_time->minute = ext_bf(buffer, DCF_M10, dcfprm->zerobits);
clock_time->minute = TIMES10(clock_time->minute) + ext_bf(buffer, DCF_M1, dcfprm->zerobits);
clock_time->hour = ext_bf(buffer, DCF_H10, dcfprm->zerobits);
clock_time->hour = TIMES10(clock_time->hour) + ext_bf(buffer, DCF_H1, dcfprm->zerobits);
clock_time->day = ext_bf(buffer, DCF_D10, dcfprm->zerobits);
clock_time->day = TIMES10(clock_time->day) + ext_bf(buffer, DCF_D1, dcfprm->zerobits);
clock_time->month = ext_bf(buffer, DCF_MO0, dcfprm->zerobits);
clock_time->month = TIMES10(clock_time->month) + ext_bf(buffer, DCF_MO, dcfprm->zerobits);
clock_time->year = ext_bf(buffer, DCF_Y10, dcfprm->zerobits);
clock_time->year = TIMES10(clock_time->year) + ext_bf(buffer, DCF_Y1, dcfprm->zerobits);
switch (ext_bf(buffer, DCF_Z, dcfprm->zerobits))
{
case DCF_Z_MET:
clock_time->utcoffset = -1*60*60;
break;
case DCF_Z_MED:
clock_time->flags |= PARSEB_DST;
clock_time->utcoffset = -2*60*60;
break;
default:
parseprintf(DD_RAWDCF,("parse: convert_rawdcf: BAD TIME ZONE\n"));
return CVT_FAIL|CVT_BADFMT;
}
if (ext_bf(buffer, DCF_A1, dcfprm->zerobits))
clock_time->flags |= PARSEB_ANNOUNCE;
if (ext_bf(buffer, DCF_A2, dcfprm->zerobits))
clock_time->flags |= PARSEB_LEAPADD;
if (ext_bf(buffer, DCF_R, dcfprm->zerobits))
clock_time->flags |= PARSEB_ALTERNATE;
parseprintf(DD_RAWDCF,("parse: convert_rawdcf: TIME CODE OK: %d:%d, %d.%d.%d, flags 0x%lx\n",
(int)clock_time->hour, (int)clock_time->minute, (int)clock_time->day, (int)clock_time->month,(int) clock_time->year,
(u_long)clock_time->flags));
return CVT_OK;
}
else
{
#ifndef PARSEKERNEL
msyslog(LOG_ERR, "parse: convert_rawdcf: parity check FAILED for \"%s\"\n", buffer);
#endif
return CVT_FAIL|CVT_BADFMT;
}
}
static u_long
cvt_rawdcf(
unsigned char *buffer,
int size,
struct format *param,
clocktime_t *clock_time,
void *local
)
{
last_tcode_t *t = (last_tcode_t *)local;
register unsigned char *s = (unsigned char *)buffer;
register unsigned char *e = s + size;
register unsigned char *b = dcfparameter.onebits;
register unsigned char *c = dcfparameter.zerobits;
u_long rtc = CVT_NONE;
register unsigned int i, lowmax, highmax, cutoff, span;
#define BITS 9
unsigned char histbuf[BITS];
for (i = 0; i < BITS; i++)
{
histbuf[i] = 0;
}
cutoff = 0;
lowmax = 0;
while (s < e)
{
register unsigned int ch = *s ^ 0xFF;
if (!((ch+1) & ch) || !*s)
{
for (i = 0; ch; i++)
{
ch >>= 1;
}
*s = i;
histbuf[i]++;
cutoff += i;
lowmax++;
}
else
{
parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: character check for 0x%x@%d FAILED\n", *s, (int)(s - (unsigned char *)buffer)));
*s = (unsigned char)~0;
rtc = CVT_FAIL|CVT_BADFMT;
}
s++;
}
if (lowmax)
{
cutoff /= lowmax;
}
else
{
cutoff = 4;
}
parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: average bit count: %d\n", cutoff));
lowmax = 0;
highmax = 0;
parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: histogram:"));
for (i = 0; i <= cutoff; i++)
{
lowmax+=histbuf[i] * i;
highmax += histbuf[i];
parseprintf(DD_RAWDCF,(" %d", histbuf[i]));
}
parseprintf(DD_RAWDCF, (" <M>"));
lowmax += highmax / 2;
if (highmax)
{
lowmax /= highmax;
}
else
{
lowmax = 0;
}
highmax = 0;
cutoff = 0;
for (; i < BITS; i++)
{
highmax+=histbuf[i] * i;
cutoff +=histbuf[i];
parseprintf(DD_RAWDCF,(" %d", histbuf[i]));
}
parseprintf(DD_RAWDCF,("\n"));
if (cutoff)
{
highmax /= cutoff;
}
else
{
highmax = BITS-1;
}
span = cutoff = lowmax;
for (i = lowmax; i <= highmax; i++)
{
if (histbuf[cutoff] > histbuf[i])
{
cutoff = i;
span = i;
}
else
if (histbuf[cutoff] == histbuf[i])
{
span = i;
}
}
cutoff = (cutoff + span) / 2;
parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: lower maximum %d, higher maximum %d, cutoff %d\n", lowmax, highmax, cutoff));
s = (unsigned char *)buffer;
while ((s < e) && *c && *b)
{
if (*s == (unsigned char)~0)
{
*s = '?';
}
else
{
*s = (*s >= cutoff) ? *b : *c;
}
s++;
b++;
c++;
}
if (rtc == CVT_NONE)
{
rtc = convert_rawdcf(buffer, size, &dcfparameter, clock_time);
if (rtc == CVT_OK)
{
time_t newtime;
newtime = parse_to_unixtime(clock_time, &rtc);
if ((rtc == CVT_OK) && t)
{
if ((newtime - t->tcode) == 60)
{
clock_time->utctime = newtime;
}
else
{
rtc = CVT_FAIL|CVT_BADTIME;
}
t->tcode = newtime;
}
}
}
return rtc;
}
static u_long
pps_rawdcf(
register parse_t *parseio,
register int status,
register timestamp_t *ptime
)
{
if (!status)
{
parseio->parse_dtime.parse_ptime = *ptime;
parseio->parse_dtime.parse_state |= PARSEB_PPS|PARSEB_S_PPS;
}
return CVT_NONE;
}
static u_long
snt_rawdcf(
register parse_t *parseio,
register timestamp_t *ptime
)
{
if ((parseio->parse_dtime.parse_status & CVT_MASK) == CVT_OK)
{
parseio->parse_dtime.parse_stime = *ptime;
#ifdef PARSEKERNEL
parseio->parse_dtime.parse_time.tv.tv_sec++;
#else
parseio->parse_dtime.parse_time.fp.l_ui++;
#endif
parseprintf(DD_RAWDCF,("parse: snt_rawdcf: time stamp synthesized offset %d seconds\n", parseio->parse_index - 1));
return updatetimeinfo(parseio, parseio->parse_lstate);
}
return CVT_NONE;
}
static u_long
inp_rawdcf(
parse_t *parseio,
unsigned int ch,
timestamp_t *tstamp
)
{
static struct timeval timeout = { 1, 500000 };
parseprintf(DD_PARSE, ("inp_rawdcf(0x%lx, 0x%x, ...)\n", (long)parseio, ch));
parseio->parse_dtime.parse_stime = *tstamp;
if (parse_timedout(parseio, tstamp, &timeout))
{
parseprintf(DD_PARSE, ("inp_rawdcf: time out seen\n"));
(void) parse_end(parseio);
(void) parse_addchar(parseio, ch);
return PARSE_INP_TIME;
}
else
{
unsigned int rtc;
rtc = parse_addchar(parseio, ch);
if (rtc == PARSE_INP_SKIP)
{
if (snt_rawdcf(parseio, tstamp) == CVT_OK)
return PARSE_INP_SYNTH;
}
return rtc;
}
}
#else
int clk_rawdcf_bs;
#endif