/contrib/ntp/libparse/clk_rawdcf.c

https://bitbucket.org/freebsd/freebsd-head/ · C · 658 lines · 406 code · 73 blank · 179 comment · 56 complexity · 202554d133a1a281aadeec284a471b69 MD5 · raw file

  1. /*
  2. * /src/NTP/REPOSITORY/ntp4-dev/libparse/clk_rawdcf.c,v 4.18 2006/06/22 18:40:01 kardel RELEASE_20060622_A
  3. *
  4. * clk_rawdcf.c,v 4.18 2006/06/22 18:40:01 kardel RELEASE_20060622_A
  5. *
  6. * Raw DCF77 pulse clock support
  7. *
  8. * Copyright (c) 1995-2006 by Frank Kardel <kardel <AT> ntp.org>
  9. * Copyright (c) 1989-1994 by Frank Kardel, Friedrich-Alexander Universität Erlangen-Nürnberg, Germany
  10. *
  11. * Redistribution and use in source and binary forms, with or without
  12. * modification, are permitted provided that the following conditions
  13. * are met:
  14. * 1. Redistributions of source code must retain the above copyright
  15. * notice, this list of conditions and the following disclaimer.
  16. * 2. Redistributions in binary form must reproduce the above copyright
  17. * notice, this list of conditions and the following disclaimer in the
  18. * documentation and/or other materials provided with the distribution.
  19. * 3. Neither the name of the author nor the names of its contributors
  20. * may be used to endorse or promote products derived from this software
  21. * without specific prior written permission.
  22. *
  23. * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  24. * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26. * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  27. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29. * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33. * SUCH DAMAGE.
  34. *
  35. */
  36. #ifdef HAVE_CONFIG_H
  37. # include <config.h>
  38. #endif
  39. #if defined(REFCLOCK) && defined(CLOCK_PARSE) && defined(CLOCK_RAWDCF)
  40. #include "ntp_fp.h"
  41. #include "ntp_unixtime.h"
  42. #include "ntp_calendar.h"
  43. #include "parse.h"
  44. #ifdef PARSESTREAM
  45. # include <sys/parsestreams.h>
  46. #endif
  47. #ifndef PARSEKERNEL
  48. # include "ntp_stdlib.h"
  49. #endif
  50. /*
  51. * DCF77 raw time code
  52. *
  53. * From "Zur Zeit", Physikalisch-Technische Bundesanstalt (PTB), Braunschweig
  54. * und Berlin, Maerz 1989
  55. *
  56. * Timecode transmission:
  57. * AM:
  58. * time marks are send every second except for the second before the
  59. * next minute mark
  60. * time marks consist of a reduction of transmitter power to 25%
  61. * of the nominal level
  62. * the falling edge is the time indication (on time)
  63. * time marks of a 100ms duration constitute a logical 0
  64. * time marks of a 200ms duration constitute a logical 1
  65. * FM:
  66. * see the spec. (basically a (non-)inverted psuedo random phase shift)
  67. *
  68. * Encoding:
  69. * Second Contents
  70. * 0 - 10 AM: free, FM: 0
  71. * 11 - 14 free
  72. * 15 R - alternate antenna
  73. * 16 A1 - expect zone change (1 hour before)
  74. * 17 - 18 Z1,Z2 - time zone
  75. * 0 0 illegal
  76. * 0 1 MEZ (MET)
  77. * 1 0 MESZ (MED, MET DST)
  78. * 1 1 illegal
  79. * 19 A2 - expect leap insertion/deletion (1 hour before)
  80. * 20 S - start of time code (1)
  81. * 21 - 24 M1 - BCD (lsb first) Minutes
  82. * 25 - 27 M10 - BCD (lsb first) 10 Minutes
  83. * 28 P1 - Minute Parity (even)
  84. * 29 - 32 H1 - BCD (lsb first) Hours
  85. * 33 - 34 H10 - BCD (lsb first) 10 Hours
  86. * 35 P2 - Hour Parity (even)
  87. * 36 - 39 D1 - BCD (lsb first) Days
  88. * 40 - 41 D10 - BCD (lsb first) 10 Days
  89. * 42 - 44 DW - BCD (lsb first) day of week (1: Monday -> 7: Sunday)
  90. * 45 - 49 MO - BCD (lsb first) Month
  91. * 50 MO0 - 10 Months
  92. * 51 - 53 Y1 - BCD (lsb first) Years
  93. * 54 - 57 Y10 - BCD (lsb first) 10 Years
  94. * 58 P3 - Date Parity (even)
  95. * 59 - usually missing (minute indication), except for leap insertion
  96. */
  97. static u_long pps_rawdcf P((parse_t *, int, timestamp_t *));
  98. static u_long cvt_rawdcf P((unsigned char *, int, struct format *, clocktime_t *, void *));
  99. static u_long inp_rawdcf P((parse_t *, unsigned int, timestamp_t *));
  100. typedef struct last_tcode {
  101. time_t tcode; /* last converted time code */
  102. } last_tcode_t;
  103. #define BUFFER_MAX 61
  104. clockformat_t clock_rawdcf =
  105. {
  106. inp_rawdcf, /* DCF77 input handling */
  107. cvt_rawdcf, /* raw dcf input conversion */
  108. pps_rawdcf, /* examining PPS information */
  109. 0, /* no private configuration data */
  110. "RAW DCF77 Timecode", /* direct decoding / time synthesis */
  111. BUFFER_MAX, /* bit buffer */
  112. sizeof(last_tcode_t)
  113. };
  114. static struct dcfparam
  115. {
  116. unsigned char *onebits;
  117. unsigned char *zerobits;
  118. } dcfparameter =
  119. {
  120. (unsigned char *)"###############RADMLS1248124P124812P1248121241248112481248P??", /* 'ONE' representation */
  121. (unsigned char *)"--------------------s-------p------p----------------------p__" /* 'ZERO' representation */
  122. };
  123. static struct rawdcfcode
  124. {
  125. char offset; /* start bit */
  126. } rawdcfcode[] =
  127. {
  128. { 0 }, { 15 }, { 16 }, { 17 }, { 19 }, { 20 }, { 21 }, { 25 }, { 28 }, { 29 },
  129. { 33 }, { 35 }, { 36 }, { 40 }, { 42 }, { 45 }, { 49 }, { 50 }, { 54 }, { 58 }, { 59 }
  130. };
  131. #define DCF_M 0
  132. #define DCF_R 1
  133. #define DCF_A1 2
  134. #define DCF_Z 3
  135. #define DCF_A2 4
  136. #define DCF_S 5
  137. #define DCF_M1 6
  138. #define DCF_M10 7
  139. #define DCF_P1 8
  140. #define DCF_H1 9
  141. #define DCF_H10 10
  142. #define DCF_P2 11
  143. #define DCF_D1 12
  144. #define DCF_D10 13
  145. #define DCF_DW 14
  146. #define DCF_MO 15
  147. #define DCF_MO0 16
  148. #define DCF_Y1 17
  149. #define DCF_Y10 18
  150. #define DCF_P3 19
  151. static struct partab
  152. {
  153. char offset; /* start bit of parity field */
  154. } partab[] =
  155. {
  156. { 21 }, { 29 }, { 36 }, { 59 }
  157. };
  158. #define DCF_P_P1 0
  159. #define DCF_P_P2 1
  160. #define DCF_P_P3 2
  161. #define DCF_Z_MET 0x2
  162. #define DCF_Z_MED 0x1
  163. static u_long
  164. ext_bf(
  165. unsigned char *buf,
  166. int idx,
  167. unsigned char *zero
  168. )
  169. {
  170. u_long sum = 0;
  171. int i, first;
  172. first = rawdcfcode[idx].offset;
  173. for (i = rawdcfcode[idx+1].offset - 1; i >= first; i--)
  174. {
  175. sum <<= 1;
  176. sum |= (buf[i] != zero[i]);
  177. }
  178. return sum;
  179. }
  180. static unsigned
  181. pcheck(
  182. unsigned char *buf,
  183. int idx,
  184. unsigned char *zero
  185. )
  186. {
  187. int i,last;
  188. unsigned psum = 1;
  189. last = partab[idx+1].offset;
  190. for (i = partab[idx].offset; i < last; i++)
  191. psum ^= (buf[i] != zero[i]);
  192. return psum;
  193. }
  194. static u_long
  195. convert_rawdcf(
  196. unsigned char *buffer,
  197. int size,
  198. struct dcfparam *dcfprm,
  199. clocktime_t *clock_time
  200. )
  201. {
  202. unsigned char *s = buffer;
  203. unsigned char *b = dcfprm->onebits;
  204. unsigned char *c = dcfprm->zerobits;
  205. int i;
  206. parseprintf(DD_RAWDCF,("parse: convert_rawdcf: \"%s\"\n", buffer));
  207. if (size < 57)
  208. {
  209. #ifndef PARSEKERNEL
  210. msyslog(LOG_ERR, "parse: convert_rawdcf: INCOMPLETE DATA - time code only has %d bits\n", size);
  211. #endif
  212. return CVT_NONE;
  213. }
  214. for (i = 0; i < size; i++)
  215. {
  216. if ((*s != *b) && (*s != *c))
  217. {
  218. /*
  219. * we only have two types of bytes (ones and zeros)
  220. */
  221. #ifndef PARSEKERNEL
  222. msyslog(LOG_ERR, "parse: convert_rawdcf: BAD DATA - no conversion");
  223. #endif
  224. return CVT_NONE;
  225. }
  226. if (*b) b++;
  227. if (*c) c++;
  228. s++;
  229. }
  230. /*
  231. * check Start and Parity bits
  232. */
  233. if ((ext_bf(buffer, DCF_S, dcfprm->zerobits) == 1) &&
  234. pcheck(buffer, DCF_P_P1, dcfprm->zerobits) &&
  235. pcheck(buffer, DCF_P_P2, dcfprm->zerobits) &&
  236. pcheck(buffer, DCF_P_P3, dcfprm->zerobits))
  237. {
  238. /*
  239. * buffer OK
  240. */
  241. parseprintf(DD_RAWDCF,("parse: convert_rawdcf: parity check passed\n"));
  242. clock_time->flags = PARSEB_S_ANTENNA|PARSEB_S_LEAP;
  243. clock_time->utctime= 0;
  244. clock_time->usecond= 0;
  245. clock_time->second = 0;
  246. clock_time->minute = ext_bf(buffer, DCF_M10, dcfprm->zerobits);
  247. clock_time->minute = TIMES10(clock_time->minute) + ext_bf(buffer, DCF_M1, dcfprm->zerobits);
  248. clock_time->hour = ext_bf(buffer, DCF_H10, dcfprm->zerobits);
  249. clock_time->hour = TIMES10(clock_time->hour) + ext_bf(buffer, DCF_H1, dcfprm->zerobits);
  250. clock_time->day = ext_bf(buffer, DCF_D10, dcfprm->zerobits);
  251. clock_time->day = TIMES10(clock_time->day) + ext_bf(buffer, DCF_D1, dcfprm->zerobits);
  252. clock_time->month = ext_bf(buffer, DCF_MO0, dcfprm->zerobits);
  253. clock_time->month = TIMES10(clock_time->month) + ext_bf(buffer, DCF_MO, dcfprm->zerobits);
  254. clock_time->year = ext_bf(buffer, DCF_Y10, dcfprm->zerobits);
  255. clock_time->year = TIMES10(clock_time->year) + ext_bf(buffer, DCF_Y1, dcfprm->zerobits);
  256. switch (ext_bf(buffer, DCF_Z, dcfprm->zerobits))
  257. {
  258. case DCF_Z_MET:
  259. clock_time->utcoffset = -1*60*60;
  260. break;
  261. case DCF_Z_MED:
  262. clock_time->flags |= PARSEB_DST;
  263. clock_time->utcoffset = -2*60*60;
  264. break;
  265. default:
  266. parseprintf(DD_RAWDCF,("parse: convert_rawdcf: BAD TIME ZONE\n"));
  267. return CVT_FAIL|CVT_BADFMT;
  268. }
  269. if (ext_bf(buffer, DCF_A1, dcfprm->zerobits))
  270. clock_time->flags |= PARSEB_ANNOUNCE;
  271. if (ext_bf(buffer, DCF_A2, dcfprm->zerobits))
  272. clock_time->flags |= PARSEB_LEAPADD; /* default: DCF77 data format deficiency */
  273. if (ext_bf(buffer, DCF_R, dcfprm->zerobits))
  274. clock_time->flags |= PARSEB_ALTERNATE;
  275. parseprintf(DD_RAWDCF,("parse: convert_rawdcf: TIME CODE OK: %d:%d, %d.%d.%d, flags 0x%lx\n",
  276. (int)clock_time->hour, (int)clock_time->minute, (int)clock_time->day, (int)clock_time->month,(int) clock_time->year,
  277. (u_long)clock_time->flags));
  278. return CVT_OK;
  279. }
  280. else
  281. {
  282. /*
  283. * bad format - not for us
  284. */
  285. #ifndef PARSEKERNEL
  286. msyslog(LOG_ERR, "parse: convert_rawdcf: parity check FAILED for \"%s\"\n", buffer);
  287. #endif
  288. return CVT_FAIL|CVT_BADFMT;
  289. }
  290. }
  291. /*
  292. * raw dcf input routine - needs to fix up 50 baud
  293. * characters for 1/0 decision
  294. */
  295. static u_long
  296. cvt_rawdcf(
  297. unsigned char *buffer,
  298. int size,
  299. struct format *param,
  300. clocktime_t *clock_time,
  301. void *local
  302. )
  303. {
  304. last_tcode_t *t = (last_tcode_t *)local;
  305. unsigned char *s = (unsigned char *)buffer;
  306. unsigned char *e = s + size;
  307. unsigned char *b = dcfparameter.onebits;
  308. unsigned char *c = dcfparameter.zerobits;
  309. u_long rtc = CVT_NONE;
  310. unsigned int i, lowmax, highmax, cutoff, span;
  311. #define BITS 9
  312. unsigned char histbuf[BITS];
  313. /*
  314. * the input buffer contains characters with runs of consecutive
  315. * bits set. These set bits are an indication of the DCF77 pulse
  316. * length. We assume that we receive the pulse at 50 Baud. Thus
  317. * a 100ms pulse would generate a 4 bit train (20ms per bit and
  318. * start bit)
  319. * a 200ms pulse would create all zeroes (and probably a frame error)
  320. */
  321. for (i = 0; i < BITS; i++)
  322. {
  323. histbuf[i] = 0;
  324. }
  325. cutoff = 0;
  326. lowmax = 0;
  327. while (s < e)
  328. {
  329. unsigned int ch = *s ^ 0xFF;
  330. /*
  331. * these lines are left as an excercise to the reader 8-)
  332. */
  333. if (!((ch+1) & ch) || !*s)
  334. {
  335. for (i = 0; ch; i++)
  336. {
  337. ch >>= 1;
  338. }
  339. *s = i;
  340. histbuf[i]++;
  341. cutoff += i;
  342. lowmax++;
  343. }
  344. else
  345. {
  346. parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: character check for 0x%x@%d FAILED\n", *s, (int)(s - (unsigned char *)buffer)));
  347. *s = (unsigned char)~0;
  348. rtc = CVT_FAIL|CVT_BADFMT;
  349. }
  350. s++;
  351. }
  352. if (lowmax)
  353. {
  354. cutoff /= lowmax;
  355. }
  356. else
  357. {
  358. cutoff = 4; /* doesn't really matter - it'll fail anyway, but gives error output */
  359. }
  360. parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: average bit count: %d\n", cutoff));
  361. lowmax = 0;
  362. highmax = 0;
  363. parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: histogram:"));
  364. for (i = 0; i <= cutoff; i++)
  365. {
  366. lowmax+=histbuf[i] * i;
  367. highmax += histbuf[i];
  368. parseprintf(DD_RAWDCF,(" %d", histbuf[i]));
  369. }
  370. parseprintf(DD_RAWDCF, (" <M>"));
  371. lowmax += highmax / 2;
  372. if (highmax)
  373. {
  374. lowmax /= highmax;
  375. }
  376. else
  377. {
  378. lowmax = 0;
  379. }
  380. highmax = 0;
  381. cutoff = 0;
  382. for (; i < BITS; i++)
  383. {
  384. highmax+=histbuf[i] * i;
  385. cutoff +=histbuf[i];
  386. parseprintf(DD_RAWDCF,(" %d", histbuf[i]));
  387. }
  388. parseprintf(DD_RAWDCF,("\n"));
  389. if (cutoff)
  390. {
  391. highmax /= cutoff;
  392. }
  393. else
  394. {
  395. highmax = BITS-1;
  396. }
  397. span = cutoff = lowmax;
  398. for (i = lowmax; i <= highmax; i++)
  399. {
  400. if (histbuf[cutoff] > histbuf[i])
  401. {
  402. cutoff = i;
  403. span = i;
  404. }
  405. else
  406. if (histbuf[cutoff] == histbuf[i])
  407. {
  408. span = i;
  409. }
  410. }
  411. cutoff = (cutoff + span) / 2;
  412. parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: lower maximum %d, higher maximum %d, cutoff %d\n", lowmax, highmax, cutoff));
  413. s = (unsigned char *)buffer;
  414. while (s < e)
  415. {
  416. if (*s == (unsigned char)~0)
  417. {
  418. *s = '?';
  419. }
  420. else
  421. {
  422. *s = (*s >= cutoff) ? *b : *c;
  423. }
  424. s++;
  425. if (*b) b++;
  426. if (*c) c++;
  427. }
  428. if (rtc == CVT_NONE)
  429. {
  430. rtc = convert_rawdcf(buffer, size, &dcfparameter, clock_time);
  431. if (rtc == CVT_OK)
  432. {
  433. time_t newtime;
  434. newtime = parse_to_unixtime(clock_time, &rtc);
  435. if ((rtc == CVT_OK) && t)
  436. {
  437. if ((newtime - t->tcode) == 60) /* guard against multi bit errors */
  438. {
  439. clock_time->utctime = newtime;
  440. }
  441. else
  442. {
  443. rtc = CVT_FAIL|CVT_BADTIME;
  444. }
  445. t->tcode = newtime;
  446. }
  447. }
  448. }
  449. return rtc;
  450. }
  451. /*
  452. * pps_rawdcf
  453. *
  454. * currently a very stupid version - should be extended to decode
  455. * also ones and zeros (which is easy)
  456. */
  457. /*ARGSUSED*/
  458. static u_long
  459. pps_rawdcf(
  460. parse_t *parseio,
  461. int status,
  462. timestamp_t *ptime
  463. )
  464. {
  465. if (!status) /* negative edge for simpler wiring (Rx->DCD) */
  466. {
  467. parseio->parse_dtime.parse_ptime = *ptime;
  468. parseio->parse_dtime.parse_state |= PARSEB_PPS|PARSEB_S_PPS;
  469. }
  470. return CVT_NONE;
  471. }
  472. static u_long
  473. snt_rawdcf(
  474. parse_t *parseio,
  475. timestamp_t *ptime
  476. )
  477. {
  478. if ((parseio->parse_dtime.parse_status & CVT_MASK) == CVT_OK)
  479. {
  480. parseio->parse_dtime.parse_stime = *ptime;
  481. #ifdef PARSEKERNEL
  482. parseio->parse_dtime.parse_time.tv.tv_sec++;
  483. #else
  484. parseio->parse_dtime.parse_time.fp.l_ui++;
  485. #endif
  486. parseprintf(DD_RAWDCF,("parse: snt_rawdcf: time stamp synthesized offset %d seconds\n", parseio->parse_index - 1));
  487. return updatetimeinfo(parseio, parseio->parse_lstate);
  488. }
  489. return CVT_NONE;
  490. }
  491. /*
  492. * inp_rawdcf
  493. *
  494. * grab DCF77 data from input stream
  495. */
  496. static u_long
  497. inp_rawdcf(
  498. parse_t *parseio,
  499. unsigned int ch,
  500. timestamp_t *tstamp
  501. )
  502. {
  503. static struct timeval timeout = { 1, 500000 }; /* 1.5 secongs denote second #60 */
  504. parseprintf(DD_PARSE, ("inp_rawdcf(0x%lx, 0x%x, ...)\n", (long)parseio, ch));
  505. parseio->parse_dtime.parse_stime = *tstamp; /* collect timestamp */
  506. if (parse_timedout(parseio, tstamp, &timeout))
  507. {
  508. parseprintf(DD_PARSE, ("inp_rawdcf: time out seen\n"));
  509. (void) parse_end(parseio);
  510. (void) parse_addchar(parseio, ch);
  511. return PARSE_INP_TIME;
  512. }
  513. else
  514. {
  515. unsigned int rtc;
  516. rtc = parse_addchar(parseio, ch);
  517. if (rtc == PARSE_INP_SKIP)
  518. {
  519. if (snt_rawdcf(parseio, tstamp) == CVT_OK)
  520. return PARSE_INP_SYNTH;
  521. }
  522. return rtc;
  523. }
  524. }
  525. #else /* not (REFCLOCK && CLOCK_PARSE && CLOCK_RAWDCF) */
  526. int clk_rawdcf_bs;
  527. #endif /* not (REFCLOCK && CLOCK_PARSE && CLOCK_RAWDCF) */
  528. /*
  529. * History:
  530. *
  531. * clk_rawdcf.c,v
  532. * Revision 4.18 2006/06/22 18:40:01 kardel
  533. * clean up signedness (gcc 4)
  534. *
  535. * Revision 4.17 2006/01/22 16:01:55 kardel
  536. * update version information
  537. *
  538. * Revision 4.16 2006/01/22 15:51:22 kardel
  539. * generate reasonable timecode output on invalid input
  540. *
  541. * Revision 4.15 2005/08/06 19:17:06 kardel
  542. * clean log output
  543. *
  544. * Revision 4.14 2005/08/06 17:39:40 kardel
  545. * cleanup size handling wrt/ to buffer boundaries
  546. *
  547. * Revision 4.13 2005/04/16 17:32:10 kardel
  548. * update copyright
  549. *
  550. * Revision 4.12 2004/11/14 15:29:41 kardel
  551. * support PPSAPI, upgrade Copyright to Berkeley style
  552. *
  553. * Revision 4.9 1999/12/06 13:42:23 kardel
  554. * transfer correctly converted time codes always into tcode
  555. *
  556. * Revision 4.8 1999/11/28 09:13:50 kardel
  557. * RECON_4_0_98F
  558. *
  559. * Revision 4.7 1999/04/01 20:07:20 kardel
  560. * added checking for minutie increment of timestamps in clk_rawdcf.c
  561. *
  562. * Revision 4.6 1998/06/14 21:09:37 kardel
  563. * Sun acc cleanup
  564. *
  565. * Revision 4.5 1998/06/13 12:04:16 kardel
  566. * fix SYSV clock name clash
  567. *
  568. * Revision 4.4 1998/06/12 15:22:28 kardel
  569. * fix prototypes
  570. *
  571. * Revision 4.3 1998/06/06 18:33:36 kardel
  572. * simplified condidional compile expression
  573. *
  574. * Revision 4.2 1998/05/24 11:04:18 kardel
  575. * triggering PPS on negative edge for simpler wiring (Rx->DCD)
  576. *
  577. * Revision 4.1 1998/05/24 09:39:53 kardel
  578. * implementation of the new IO handling model
  579. *
  580. * Revision 4.0 1998/04/10 19:45:30 kardel
  581. * Start 4.0 release version numbering
  582. *
  583. * from V3 3.24 log info deleted 1998/04/11 kardel
  584. *
  585. */