![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to parse.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / libparse|
Return to parse.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / libparse |
1.1 misho 1: /*
2: * /src/NTP/ntp4-dev/libparse/parse.c,v 4.20 2005/08/06 17:39:40 kardel RELEASE_20050806_A
3: *
4: * parse.c,v 4.20 2005/08/06 17:39:40 kardel RELEASE_20050806_A
5: *
6: * Parser module for reference clock
7: *
8: * PARSEKERNEL define switches between two personalities of the module
9: * if PARSEKERNEL is defined this module can be used
10: * as kernel module. In this case the time stamps will be
11: * a struct timeval.
12: * when PARSEKERNEL is not defined NTP time stamps will be used.
13: *
14: * Copyright (c) 1995-2005 by Frank Kardel <kardel <AT> ntp.org>
15: * Copyright (c) 1989-1994 by Frank Kardel, Friedrich-Alexander Universität Erlangen-Nürnberg, Germany
16: *
17: * Redistribution and use in source and binary forms, with or without
18: * modification, are permitted provided that the following conditions
19: * are met:
20: * 1. Redistributions of source code must retain the above copyright
21: * notice, this list of conditions and the following disclaimer.
22: * 2. Redistributions in binary form must reproduce the above copyright
23: * notice, this list of conditions and the following disclaimer in the
24: * documentation and/or other materials provided with the distribution.
25: * 3. Neither the name of the author nor the names of its contributors
26: * may be used to endorse or promote products derived from this software
27: * without specific prior written permission.
28: *
29: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
30: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
33: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
35: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
37: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
38: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
39: * SUCH DAMAGE.
40: *
41: */
42:
43: #ifdef HAVE_CONFIG_H
44: # include <config.h>
45: #endif
46:
47: #if defined(REFCLOCK) && defined(CLOCK_PARSE)
48:
49: #if !(defined(lint) || defined(__GNUC__))
50: static char rcsid[] = "parse.c,v 4.20 2005/08/06 17:39:40 kardel RELEASE_20050806_A";
51: #endif
52:
53: #include "ntp_fp.h"
54: #include "ntp_unixtime.h"
55: #include "ntp_calendar.h"
56: #include "ntp_stdlib.h"
57: #include "ntp_machine.h"
58: #include "ntp.h" /* (get Y2KFixes definitions) Y2KFixes */
59:
60: #include "parse.h"
61:
62: #ifndef PARSESTREAM
63: # include <stdio.h>
64: #else
65: # include "sys/parsestreams.h"
66: #endif
67:
68: extern clockformat_t *clockformats[];
69: extern unsigned short nformats;
70:
71: static u_long timepacket (parse_t *);
72:
73: /*
74: * strings support usually not in kernel - duplicated, but what the heck
75: */
76: static int
77: Strlen(
78: register const char *s
79: )
80: {
81: register int c;
82:
83: c = 0;
84: if (s)
85: {
86: while (*s++)
87: {
88: c++;
89: }
90: }
91: return c;
92: }
93:
94: static int
95: Strcmp(
96: register const char *s,
97: register const char *t
98: )
99: {
100: register int c = 0;
101:
102: if (!s || !t || (s == t))
103: {
104: return 0;
105: }
106:
107: while (!(c = *s++ - *t++) && *s && *t)
108: /* empty loop */;
109:
110: return c;
111: }
112:
113: int
114: parse_timedout(
115: parse_t *parseio,
116: timestamp_t *tstamp,
117: struct timeval *del
118: )
119: {
120: struct timeval delta;
121:
122: #ifdef PARSEKERNEL
123: delta.tv_sec = tstamp->tv.tv_sec - parseio->parse_lastchar.tv.tv_sec;
124: delta.tv_usec = tstamp->tv.tv_usec - parseio->parse_lastchar.tv.tv_usec;
125: if (delta.tv_usec < 0)
126: {
127: delta.tv_sec -= 1;
128: delta.tv_usec += 1000000;
129: }
130: #else
131: extern long tstouslo[];
132: extern long tstousmid[];
133: extern long tstoushi[];
134:
135: l_fp delt;
136:
137: delt = tstamp->fp;
138: L_SUB(&delt, &parseio->parse_lastchar.fp);
139: TSTOTV(&delt, &delta);
140: #endif
141:
142: if (timercmp(&delta, del, >))
143: {
144: parseprintf(DD_PARSE, ("parse: timedout: TRUE\n"));
145: return 1;
146: }
147: else
148: {
149: parseprintf(DD_PARSE, ("parse: timedout: FALSE\n"));
150: return 0;
151: }
152: }
153:
154: /*ARGSUSED*/
155: int
156: parse_ioinit(
157: register parse_t *parseio
158: )
159: {
160: parseprintf(DD_PARSE, ("parse_iostart\n"));
161:
162: parseio->parse_plen = 0;
163: parseio->parse_pdata = (void *)0;
164:
165: parseio->parse_data = 0;
166: parseio->parse_ldata = 0;
167: parseio->parse_dsize = 0;
168:
169: parseio->parse_badformat = 0;
170: parseio->parse_ioflags = PARSE_IO_CS7; /* usual unix default */
171: parseio->parse_index = 0;
172: parseio->parse_ldsize = 0;
173:
174: return 1;
175: }
176:
177: /*ARGSUSED*/
178: void
179: parse_ioend(
180: register parse_t *parseio
181: )
182: {
183: parseprintf(DD_PARSE, ("parse_ioend\n"));
184:
185: if (parseio->parse_pdata)
186: FREE(parseio->parse_pdata, parseio->parse_plen);
187:
188: if (parseio->parse_data)
189: FREE(parseio->parse_data, (unsigned)(parseio->parse_dsize * 2 + 2));
190: }
191:
192: unsigned int
193: parse_restart(
194: parse_t *parseio,
195: unsigned int ch
196: )
197: {
198: unsigned int updated = PARSE_INP_SKIP;
199:
200: /*
201: * re-start packet - timeout - overflow - start symbol
202: */
203:
204: if (parseio->parse_index)
205: {
206: /*
207: * filled buffer - thus not end character found
208: * do processing now
209: */
210: parseio->parse_data[parseio->parse_index] = '\0';
211: memcpy(parseio->parse_ldata, parseio->parse_data, (unsigned)(parseio->parse_index+1));
212: parseio->parse_ldsize = parseio->parse_index;
213: updated = PARSE_INP_TIME;
214: }
215:
216: parseio->parse_index = 1;
217: parseio->parse_data[0] = ch;
218: parseprintf(DD_PARSE, ("parse: parse_restart: buffer start (updated = %x)\n", updated));
219: return updated;
220: }
221:
222: unsigned int
223: parse_addchar(
224: parse_t *parseio,
225: unsigned int ch
226: )
227: {
228: /*
229: * add to buffer
230: */
231: if (parseio->parse_index < parseio->parse_dsize)
232: {
233: /*
234: * collect into buffer
235: */
236: parseprintf(DD_PARSE, ("parse: parse_addchar: buffer[%d] = 0x%x\n", parseio->parse_index, ch));
237: parseio->parse_data[parseio->parse_index++] = (char)ch;
238: return PARSE_INP_SKIP;
239: }
240: else
241: /*
242: * buffer overflow - attempt to make the best of it
243: */
244: return parse_restart(parseio, ch);
245: }
246:
247: unsigned int
248: parse_end(
249: parse_t *parseio
250: )
251: {
252: /*
253: * message complete processing
254: */
255: parseio->parse_data[parseio->parse_index] = '\0';
256: memcpy(parseio->parse_ldata, parseio->parse_data, (unsigned)(parseio->parse_index+1));
257: parseio->parse_ldsize = parseio->parse_index;
258: parseio->parse_index = 0;
259: parseprintf(DD_PARSE, ("parse: parse_end: buffer end\n"));
260: return PARSE_INP_TIME;
261: }
262:
263: /*ARGSUSED*/
264: int
265: parse_ioread(
266: register parse_t *parseio,
267: register unsigned int ch,
268: register timestamp_t *tstamp
269: )
270: {
271: register unsigned updated = CVT_NONE;
272: /*
273: * within STREAMS CSx (x < 8) chars still have the upper bits set
274: * so we normalize the characters by masking unecessary bits off.
275: */
276: switch (parseio->parse_ioflags & PARSE_IO_CSIZE)
277: {
278: case PARSE_IO_CS5:
279: ch &= 0x1F;
280: break;
281:
282: case PARSE_IO_CS6:
283: ch &= 0x3F;
284: break;
285:
286: case PARSE_IO_CS7:
287: ch &= 0x7F;
288: break;
289:
290: case PARSE_IO_CS8:
291: ch &= 0xFF;
292: break;
293: }
294:
295: parseprintf(DD_PARSE, ("parse_ioread(0x%lx, char=0x%x, ..., ...)\n", (unsigned long)parseio, ch & 0xFF));
296:
297: if (!clockformats[parseio->parse_lformat]->convert)
298: {
299: parseprintf(DD_PARSE, ("parse_ioread: input dropped.\n"));
300: return CVT_NONE;
301: }
302:
303: if (clockformats[parseio->parse_lformat]->input)
304: {
305: unsigned long input_status;
306:
307: input_status = clockformats[parseio->parse_lformat]->input(parseio, ch, tstamp);
308:
309: if (input_status & PARSE_INP_SYNTH)
310: {
311: updated = CVT_OK;
312: }
313:
314: if (input_status & PARSE_INP_TIME) /* time sample is available */
315: {
316: updated = timepacket(parseio);
317: }
318:
319: if (input_status & PARSE_INP_DATA) /* got additional data */
320: {
321: updated |= CVT_ADDITIONAL;
322: }
323: }
324:
325:
326: /*
327: * remember last character time
328: */
329: parseio->parse_lastchar = *tstamp;
330:
331: #ifdef DEBUG
332: if ((updated & CVT_MASK) != CVT_NONE)
333: {
334: parseprintf(DD_PARSE, ("parse_ioread: time sample accumulated (status=0x%x)\n", updated));
335: }
336: #endif
337:
338: parseio->parse_dtime.parse_status = updated;
339:
340: return (((updated & CVT_MASK) != CVT_NONE) ||
341: ((updated & CVT_ADDITIONAL) != 0));
342: }
343:
344: /*
345: * parse_iopps
346: *
347: * take status line indication and derive synchronisation information
348: * from it.
349: * It can also be used to decode a serial serial data format (such as the
350: * ONE, ZERO, MINUTE sync data stream from DCF77)
351: */
352: /*ARGSUSED*/
353: int
354: parse_iopps(
355: register parse_t *parseio,
356: register int status,
357: register timestamp_t *ptime
358: )
359: {
360: register unsigned updated = CVT_NONE;
361:
362: /*
363: * PPS pulse information will only be delivered to ONE clock format
364: * this is either the last successful conversion module with a ppssync
365: * routine, or a fixed format with a ppssync routine
366: */
367: parseprintf(DD_PARSE, ("parse_iopps: STATUS %s\n", (status == SYNC_ONE) ? "ONE" : "ZERO"));
368:
369: if (clockformats[parseio->parse_lformat]->syncpps)
370: {
371: updated = clockformats[parseio->parse_lformat]->syncpps(parseio, status == SYNC_ONE, ptime);
372: parseprintf(DD_PARSE, ("parse_iopps: updated = 0x%x\n", updated));
373: }
374:
375: return (updated & CVT_MASK) != CVT_NONE;
376: }
377:
378: /*
379: * parse_iodone
380: *
381: * clean up internal status for new round
382: */
383: /*ARGSUSED*/
384: void
385: parse_iodone(
386: register parse_t *parseio
387: )
388: {
389: /*
390: * we need to clean up certain flags for the next round
391: */
392: parseprintf(DD_PARSE, ("parse_iodone: DONE\n"));
393: parseio->parse_dtime.parse_state = 0; /* no problems with ISRs */
394: }
395:
396: /*---------- conversion implementation --------------------*/
397:
398: /*
399: * convert a struct clock to UTC since Jan, 1st 1970 0:00 (the UNIX EPOCH)
400: */
401: #define days_per_year(x) ((x) % 4 ? 365 : ((x % 400) ? ((x % 100) ? 366 : 365) : 366))
402:
403: time_t
404: parse_to_unixtime(
405: register clocktime_t *clock_time,
406: register u_long *cvtrtc
407: )
408: {
409: #define SETRTC(_X_) { if (cvtrtc) *cvtrtc = (_X_); }
410: static int days_of_month[] =
411: {
412: 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
413: };
414: register int i;
415: time_t t;
416:
417: if (clock_time->utctime)
418: return clock_time->utctime; /* if the conversion routine gets it right away - why not */
419:
420: if ( clock_time->year < YEAR_PIVOT ) /* Y2KFixes [ */
421: clock_time->year += 100; /* convert 20xx%100 to 20xx-1900 */
422: if ( clock_time->year < YEAR_BREAK ) /* expand to full four-digits */
423: clock_time->year += 1900;
424:
425: if (clock_time->year < 1970 ) /* Y2KFixes ] */
426: {
427: SETRTC(CVT_FAIL|CVT_BADDATE);
428: return -1;
429: }
430:
431: /*
432: * sorry, slow section here - but it's not time critical anyway
433: */
434: t = julian0(clock_time->year) - julian0(1970); /* Y2kFixes */
435: /* month */
436: if (clock_time->month <= 0 || clock_time->month > 12)
437: {
438: SETRTC(CVT_FAIL|CVT_BADDATE);
439: return -1; /* bad month */
440: }
441:
442: #if 0 /* Y2KFixes */
443: /* adjust leap year */
444: if (clock_time->month < 3 && days_per_year(clock_time->year) == 366)
445: t--;
446: #else /* Y2KFixes [ */
447: if ( clock_time->month >= 3 && isleap_4(clock_time->year) )
448: t++; /* add one more if within leap year */
449: #endif /* Y2KFixes ] */
450:
451: for (i = 1; i < clock_time->month; i++)
452: {
453: t += days_of_month[i];
454: }
455: /* day */
456: if (clock_time->day < 1 || ((clock_time->month == 2 && days_per_year(clock_time->year) == 366) ?
457: clock_time->day > 29 : clock_time->day > days_of_month[clock_time->month]))
458: {
459: SETRTC(CVT_FAIL|CVT_BADDATE);
460: return -1; /* bad day */
461: }
462:
463: t += clock_time->day - 1;
464: /* hour */
465: if (clock_time->hour < 0 || clock_time->hour >= 24)
466: {
467: SETRTC(CVT_FAIL|CVT_BADTIME);
468: return -1; /* bad hour */
469: }
470:
471: t = TIMES24(t) + clock_time->hour;
472:
473: /* min */
474: if (clock_time->minute < 0 || clock_time->minute > 59)
475: {
476: SETRTC(CVT_FAIL|CVT_BADTIME);
477: return -1; /* bad min */
478: }
479:
480: t = TIMES60(t) + clock_time->minute;
481: /* sec */
482:
483: if (clock_time->second < 0 || clock_time->second > 60) /* allow for LEAPs */
484: {
485: SETRTC(CVT_FAIL|CVT_BADTIME);
486: return -1; /* bad sec */
487: }
488:
489: t = TIMES60(t) + clock_time->second;
490:
491: t += clock_time->utcoffset; /* warp to UTC */
492:
493: /* done */
494:
495: clock_time->utctime = t; /* documentray only */
496:
497: return t;
498: }
499:
500: /*--------------- format conversion -----------------------------------*/
501:
502: int
503: Stoi(
504: const unsigned char *s,
505: long *zp,
506: int cnt
507: )
508: {
509: char unsigned const *b = s;
510: int f,z,v;
511: char unsigned c;
512:
513: f=z=v=0;
514:
515: while(*s == ' ')
516: s++;
517:
518: if (*s == '-')
519: {
520: s++;
521: v = 1;
522: }
523: else
524: if (*s == '+')
525: s++;
526:
527: for(;;)
528: {
529: c = *s++;
530: if (c == '\0' || c < '0' || c > '9' || (cnt && ((s-b) > cnt)))
531: {
532: if (f == 0)
533: {
534: return(-1);
535: }
536: if (v)
537: z = -z;
538: *zp = z;
539: return(0);
540: }
541: z = (z << 3) + (z << 1) + ( c - '0' );
542: f=1;
543: }
544: }
545:
546: int
547: Strok(
548: const unsigned char *s,
549: const unsigned char *m
550: )
551: {
552: if (!s || !m)
553: return 0;
554:
555: while(*s && *m)
556: {
557: if ((*m == ' ') ? 1 : (*s == *m))
558: {
559: s++;
560: m++;
561: }
562: else
563: {
564: return 0;
565: }
566: }
567: return !*m;
568: }
569:
570: u_long
571: updatetimeinfo(
572: register parse_t *parseio,
573: register u_long flags
574: )
575: {
576: #ifdef PARSEKERNEL
577: {
578: int s = splhigh();
579: #endif
580:
581: parseio->parse_lstate = parseio->parse_dtime.parse_state | flags | PARSEB_TIMECODE;
582:
583: parseio->parse_dtime.parse_state = parseio->parse_lstate;
584:
585: #ifdef PARSEKERNEL
586: (void)splx((unsigned int)s);
587: }
588: #endif
589:
590:
591: #ifdef PARSEKERNEL
592: parseprintf(DD_PARSE, ("updatetimeinfo status=0x%x, time=%x\n", parseio->parse_dtime.parse_state,
593: parseio->parse_dtime.parse_time.tv.tv_sec));
594: #else
595: parseprintf(DD_PARSE, ("updatetimeinfo status=0x%lx, time=%x\n", (long)parseio->parse_dtime.parse_state,
596: parseio->parse_dtime.parse_time.fp.l_ui));
597: #endif
598:
599: return CVT_OK; /* everything fine and dandy... */
600: }
601:
602:
603: /*
604: * syn_simple
605: *
606: * handle a sync time stamp
607: */
608: /*ARGSUSED*/
609: void
610: syn_simple(
611: register parse_t *parseio,
612: register timestamp_t *ts,
613: register struct format *format,
614: register u_long why
615: )
616: {
617: parseio->parse_dtime.parse_stime = *ts;
618: }
619:
620: /*
621: * pps_simple
622: *
623: * handle a pps time stamp
624: */
625: /*ARGSUSED*/
626: u_long
627: pps_simple(
628: register parse_t *parseio,
629: register int status,
630: register timestamp_t *ptime
631: )
632: {
633: parseio->parse_dtime.parse_ptime = *ptime;
634: parseio->parse_dtime.parse_state |= PARSEB_PPS|PARSEB_S_PPS;
635:
636: return CVT_NONE;
637: }
638:
639: /*
640: * pps_one
641: *
642: * handle a pps time stamp in ONE edge
643: */
644: /*ARGSUSED*/
645: u_long
646: pps_one(
647: register parse_t *parseio,
648: register int status,
649: register timestamp_t *ptime
650: )
651: {
652: if (status)
653: return pps_simple(parseio, status, ptime);
654:
655: return CVT_NONE;
656: }
657:
658: /*
659: * pps_zero
660: *
661: * handle a pps time stamp in ZERO edge
662: */
663: /*ARGSUSED*/
664: u_long
665: pps_zero(
666: register parse_t *parseio,
667: register int status,
668: register timestamp_t *ptime
669: )
670: {
671: if (!status)
672: return pps_simple(parseio, status, ptime);
673:
674: return CVT_NONE;
675: }
676:
677: /*
678: * timepacket
679: *
680: * process a data packet
681: */
682: static u_long
683: timepacket(
684: register parse_t *parseio
685: )
686: {
687: register unsigned short format;
688: register time_t t;
689: u_long cvtrtc; /* current conversion result */
690: clocktime_t clock_time;
691:
692: memset((char *)&clock_time, 0, sizeof clock_time);
693: format = parseio->parse_lformat;
694:
695: if (format == (unsigned short)~0)
696: return CVT_NONE;
697:
698: switch ((cvtrtc = clockformats[format]->convert ?
699: clockformats[format]->convert((unsigned char *)parseio->parse_ldata, parseio->parse_ldsize, (struct format *)(clockformats[format]->data), &clock_time, parseio->parse_pdata) :
700: CVT_NONE) & CVT_MASK)
701: {
702: case CVT_FAIL:
703: parseio->parse_badformat++;
704: break;
705:
706: case CVT_NONE:
707: /*
708: * too bad - pretend bad format
709: */
710: parseio->parse_badformat++;
711: break;
712:
713: case CVT_OK:
714: break;
715:
716: case CVT_SKIP:
717: return CVT_NONE;
718:
719: default:
720: /* shouldn't happen */
721: #ifndef PARSEKERNEL
722: msyslog(LOG_WARNING, "parse: INTERNAL error: bad return code of convert routine \"%s\"\n", clockformats[format]->name);
723: #endif
724: return CVT_FAIL|cvtrtc;
725: }
726:
727: if ((t = parse_to_unixtime(&clock_time, &cvtrtc)) == -1)
728: {
729: return CVT_FAIL|cvtrtc;
730: }
731:
732: /*
733: * time stamp
734: */
735: #ifdef PARSEKERNEL
736: parseio->parse_dtime.parse_time.tv.tv_sec = t;
737: parseio->parse_dtime.parse_time.tv.tv_usec = clock_time.usecond;
738: #else
739: parseio->parse_dtime.parse_time.fp.l_ui = t + JAN_1970;
740: TVUTOTSF(clock_time.usecond, parseio->parse_dtime.parse_time.fp.l_uf);
741: #endif
742:
743: parseio->parse_dtime.parse_format = format;
744:
745: return updatetimeinfo(parseio, clock_time.flags);
746: }
747:
748: /*ARGSUSED*/
749: int
750: parse_timecode(
751: parsectl_t *dct,
752: parse_t *parse
753: )
754: {
755: dct->parsegettc.parse_state = parse->parse_lstate;
756: dct->parsegettc.parse_format = parse->parse_lformat;
757: /*
758: * move out current bad packet count
759: * user program is expected to sum these up
760: * this is not a problem, as "parse" module are
761: * exclusive open only
762: */
763: dct->parsegettc.parse_badformat = parse->parse_badformat;
764: parse->parse_badformat = 0;
765:
766: if (parse->parse_ldsize <= PARSE_TCMAX)
767: {
768: dct->parsegettc.parse_count = parse->parse_ldsize;
769: memcpy(dct->parsegettc.parse_buffer, parse->parse_ldata, dct->parsegettc.parse_count);
770: return 1;
771: }
772: else
773: {
774: return 0;
775: }
776: }
777:
778:
779: /*ARGSUSED*/
780: int
781: parse_setfmt(
782: parsectl_t *dct,
783: parse_t *parse
784: )
785: {
786: if (dct->parseformat.parse_count <= PARSE_TCMAX)
787: {
788: if (dct->parseformat.parse_count)
789: {
790: register unsigned short i;
791:
792: for (i = 0; i < nformats; i++)
793: {
794: if (!Strcmp(dct->parseformat.parse_buffer, clockformats[i]->name))
795: {
796: if (parse->parse_pdata)
797: FREE(parse->parse_pdata, parse->parse_plen);
798: parse->parse_pdata = 0;
799:
800: parse->parse_plen = clockformats[i]->plen;
801:
802: if (parse->parse_plen)
803: {
804: parse->parse_pdata = MALLOC(parse->parse_plen);
805: if (!parse->parse_pdata)
806: {
807: parseprintf(DD_PARSE, ("set format failed: malloc for private data area failed\n"));
808: return 0;
809: }
810: memset((char *)parse->parse_pdata, 0, parse->parse_plen);
811: }
812:
813: if (parse->parse_data)
814: FREE(parse->parse_data, (unsigned)(parse->parse_dsize * 2 + 2));
815: parse->parse_ldata = parse->parse_data = 0;
816:
817: parse->parse_dsize = clockformats[i]->length;
818:
819: if (parse->parse_dsize)
820: {
821: parse->parse_data = (char*)MALLOC((unsigned)(parse->parse_dsize * 2 + 2));
822: if (!parse->parse_data)
823: {
824: if (parse->parse_pdata)
825: FREE(parse->parse_pdata, parse->parse_plen);
826: parse->parse_pdata = 0;
827:
828: parseprintf(DD_PARSE, ("init failed: malloc for data area failed\n"));
829: return 0;
830: }
831: }
832:
833:
834: /*
835: * leave room for '\0'
836: */
837: parse->parse_ldata = parse->parse_data + parse->parse_dsize + 1;
838:
839: parse->parse_lformat = i;
840:
841: return 1;
842: }
843: }
844: }
845: }
846: return 0;
847: }
848:
849: /*ARGSUSED*/
850: int
851: parse_getfmt(
852: parsectl_t *dct,
853: parse_t *parse
854: )
855: {
856: if (dct->parseformat.parse_format < nformats &&
857: Strlen(clockformats[dct->parseformat.parse_format]->name) <= PARSE_TCMAX)
858: {
859: dct->parseformat.parse_count = Strlen(clockformats[dct->parseformat.parse_format]->name)+1;
860: memcpy(dct->parseformat.parse_buffer, clockformats[dct->parseformat.parse_format]->name, dct->parseformat.parse_count);
861: return 1;
862: }
863: else
864: {
865: return 0;
866: }
867: }
868:
869: /*ARGSUSED*/
870: int
871: parse_setcs(
872: parsectl_t *dct,
873: parse_t *parse
874: )
875: {
876: parse->parse_ioflags &= ~PARSE_IO_CSIZE;
877: parse->parse_ioflags |= dct->parsesetcs.parse_cs & PARSE_IO_CSIZE;
878: return 1;
879: }
880:
881: #else /* not (REFCLOCK && CLOCK_PARSE) */
882: int parse_bs;
883: #endif /* not (REFCLOCK && CLOCK_PARSE) */
884:
885: /*
886: * History:
887: *
888: * parse.c,v
889: * Revision 4.20 2005/08/06 17:39:40 kardel
890: * cleanup size handling wrt/ to buffer boundaries
891: *
892: * Revision 4.19 2005/04/16 17:32:10 kardel
893: * update copyright
894: *
895: * Revision 4.18 2004/11/14 16:11:05 kardel
896: * update Id tags
897: *
898: * Revision 4.17 2004/11/14 15:29:41 kardel
899: * support PPSAPI, upgrade Copyright to Berkeley style
900: *
901: * Revision 4.14 1999/11/28 09:13:52 kardel
902: * RECON_4_0_98F
903: *
904: * Revision 4.13 1999/02/28 11:50:20 kardel
905: * (timepacket): removed unecessary code
906: *
907: * Revision 4.12 1999/02/21 12:17:44 kardel
908: * 4.91f reconcilation
909: *
910: * Revision 4.11 1999/02/21 11:09:47 kardel
911: * unified debug output
912: *
913: * Revision 4.10 1998/12/20 23:45:30 kardel
914: * fix types and warnings
915: *
916: * Revision 4.9 1998/08/09 22:26:06 kardel
917: * Trimble TSIP support
918: *
919: * Revision 4.8 1998/06/14 21:09:39 kardel
920: * Sun acc cleanup
921: *
922: * Revision 4.7 1998/06/13 15:19:13 kardel
923: * fix mem*() to b*() function macro emulation
924: *
925: * Revision 4.6 1998/06/13 13:24:13 kardel
926: * printf fmt
927: *
928: * Revision 4.5 1998/06/13 13:01:10 kardel
929: * printf fmt
930: *
931: * Revision 4.4 1998/06/13 12:12:10 kardel
932: * bcopy/memcpy cleanup
933: * fix SVSV name clash
934: *
935: * Revision 4.3 1998/06/12 15:22:30 kardel
936: * fix prototypes
937: *
938: * Revision 4.2 1998/06/12 09:13:27 kardel
939: * conditional compile macros fixed
940: * printf prototype
941: *
942: * Revision 4.1 1998/05/24 09:39:55 kardel
943: * implementation of the new IO handling model
944: *
945: * Revision 4.0 1998/04/10 19:45:36 kardel
946: * Start 4.0 release version numbering
947: *
948: * from V3 3.46 log info deleted 1998/04/11 kardel
949: */