1 /*
2 * parsetime.c - parse time for at(1)
3 * Copyright (C) 1993, 1994 Thomas Koenig
4 *
5 * modifications for English-language times
6 * Copyright (C) 1993 David Parsons
7 *
8 * A lot of modifications and extensions
9 * (including the new syntax being useful for RRDB)
10 * Copyright (C) 1999 Oleg Cherevko (aka Olwi Deer)
11 *
12 * severe structural damage inflicted by Tobi Oetiker in 1999
13 *
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions
16 * are met:
17 * 1. Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
19 * 2. The name of the author(s) may not be used to endorse or promote
20 * products derived from this software without specific prior written
21 * permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING 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 */
35 /* NOTE: nothing in here is thread-safe!!!! Not even the localtime
36 calls ... */
38 /*
39 * The BNF-like specification of the time syntax parsed is below:
40 *
41 * As usual, [ X ] means that X is optional, { X } means that X may
42 * be either omitted or specified as many times as needed,
43 * alternatives are separated by |, brackets are used for grouping.
44 * (# marks the beginning of comment that extends to the end of line)
45 *
46 * TIME-SPECIFICATION ::= TIME-REFERENCE [ OFFSET-SPEC ] |
47 * OFFSET-SPEC |
48 * ( START | END ) OFFSET-SPEC
49 *
50 * TIME-REFERENCE ::= NOW | TIME-OF-DAY-SPEC [ DAY-SPEC-1 ] |
51 * [ TIME-OF-DAY-SPEC ] DAY-SPEC-2
52 *
53 * TIME-OF-DAY-SPEC ::= NUMBER (':') NUMBER [am|pm] | # HH:MM
54 * 'noon' | 'midnight' | 'teatime'
55 *
56 * DAY-SPEC-1 ::= NUMBER '/' NUMBER '/' NUMBER | # MM/DD/[YY]YY
57 * NUMBER '.' NUMBER '.' NUMBER | # DD.MM.[YY]YY
58 * NUMBER # Seconds since 1970
59 * NUMBER # YYYYMMDD
60 *
61 * DAY-SPEC-2 ::= MONTH-NAME NUMBER [NUMBER] | # Month DD [YY]YY
62 * 'yesterday' | 'today' | 'tomorrow' |
63 * DAY-OF-WEEK
64 *
65 *
66 * OFFSET-SPEC ::= '+'|'-' NUMBER TIME-UNIT { ['+'|'-'] NUMBER TIME-UNIT }
67 *
68 * TIME-UNIT ::= SECONDS | MINUTES | HOURS |
69 * DAYS | WEEKS | MONTHS | YEARS
70 *
71 * NOW ::= 'now' | 'n'
72 *
73 * START ::= 'start' | 's'
74 * END ::= 'end' | 'e'
75 *
76 * SECONDS ::= 'seconds' | 'second' | 'sec' | 's'
77 * MINUTES ::= 'minutes' | 'minute' | 'min' | 'm'
78 * HOURS ::= 'hours' | 'hour' | 'hr' | 'h'
79 * DAYS ::= 'days' | 'day' | 'd'
80 * WEEKS ::= 'weeks' | 'week' | 'wk' | 'w'
81 * MONTHS ::= 'months' | 'month' | 'mon' | 'm'
82 * YEARS ::= 'years' | 'year' | 'yr' | 'y'
83 *
84 * MONTH-NAME ::= 'jan' | 'january' | 'feb' | 'february' | 'mar' | 'march' |
85 * 'apr' | 'april' | 'may' | 'jun' | 'june' | 'jul' | 'july' |
86 * 'aug' | 'august' | 'sep' | 'september' | 'oct' | 'october' |
87 * 'nov' | 'november' | 'dec' | 'december'
88 *
89 * DAY-OF-WEEK ::= 'sunday' | 'sun' | 'monday' | 'mon' | 'tuesday' | 'tue' |
90 * 'wednesday' | 'wed' | 'thursday' | 'thu' | 'friday' | 'fri' |
91 * 'saturday' | 'sat'
92 *
93 *
94 * As you may note, there is an ambiguity with respect to
95 * the 'm' time unit (which can mean either minutes or months).
96 * To cope with this, code tries to read users mind :) by applying
97 * certain heuristics. There are two of them:
98 *
99 * 1. If 'm' is used in context of (i.e. right after the) years,
100 * months, weeks, or days it is assumed to mean months, while
101 * in the context of hours, minutes, and seconds it means minutes.
102 * (e.g., in -1y6m or +3w1m 'm' means 'months', while in
103 * -3h20m or +5s2m 'm' means 'minutes')
104 *
105 * 2. Out of context (i.e. right after the '+' or '-' sign) the
106 * meaning of 'm' is guessed from the number it directly follows.
107 * Currently, if the number absolute value is below 25 it is assumed
108 * that 'm' means months, otherwise it is treated as minutes.
109 * (e.g., -25m == -25 minutes, while +24m == +24 months)
110 *
111 */
113 /* System Headers */
115 /* Local headers */
117 #include "rrd_tool.h"
118 #include <stdarg.h>
120 /* Structures and unions */
122 enum { /* symbols */
123 MIDNIGHT, NOON, TEATIME,
124 PM, AM, YESTERDAY, TODAY, TOMORROW, NOW, START, END,
125 SECONDS, MINUTES, HOURS, DAYS, WEEKS, MONTHS, YEARS,
126 MONTHS_MINUTES,
127 NUMBER, PLUS, MINUS, DOT, COLON, SLASH, ID, JUNK,
128 JAN, FEB, MAR, APR, MAY, JUN,
129 JUL, AUG, SEP, OCT, NOV, DEC,
130 SUN, MON, TUE, WED, THU, FRI, SAT
131 };
133 /* the below is for plus_minus() */
134 #define PREVIOUS_OP (-1)
136 /* parse translation table - table driven parsers can be your FRIEND!
137 */
138 struct SpecialToken {
139 char *name; /* token name */
140 int value; /* token id */
141 };
142 static struct SpecialToken VariousWords[] = {
143 { "midnight", MIDNIGHT }, /* 00:00:00 of today or tomorrow */
144 { "noon", NOON }, /* 12:00:00 of today or tomorrow */
145 { "teatime", TEATIME }, /* 16:00:00 of today or tomorrow */
146 { "am", AM }, /* morning times for 0-12 clock */
147 { "pm", PM }, /* evening times for 0-12 clock */
148 { "tomorrow", TOMORROW },
149 { "yesterday", YESTERDAY },
150 { "today", TODAY },
151 { "now", NOW },
152 { "n", NOW },
153 { "start", START },
154 { "s", START },
155 { "end", END },
156 { "e", END },
158 { "jan", JAN },
159 { "feb", FEB },
160 { "mar", MAR },
161 { "apr", APR },
162 { "may", MAY },
163 { "jun", JUN },
164 { "jul", JUL },
165 { "aug", AUG },
166 { "sep", SEP },
167 { "oct", OCT },
168 { "nov", NOV },
169 { "dec", DEC },
170 { "january", JAN },
171 { "february", FEB },
172 { "march", MAR },
173 { "april", APR },
174 { "may", MAY },
175 { "june", JUN },
176 { "july", JUL },
177 { "august", AUG },
178 { "september", SEP },
179 { "october", OCT },
180 { "november", NOV },
181 { "december", DEC },
182 { "sunday", SUN },
183 { "sun", SUN },
184 { "monday", MON },
185 { "mon", MON },
186 { "tuesday", TUE },
187 { "tue", TUE },
188 { "wednesday", WED },
189 { "wed", WED },
190 { "thursday", THU },
191 { "thu", THU },
192 { "friday", FRI },
193 { "fri", FRI },
194 { "saturday", SAT },
195 { "sat", SAT },
196 { NULL, 0 } /*** SENTINEL ***/
197 };
199 static struct SpecialToken TimeMultipliers[] = {
200 { "second", SECONDS }, /* seconds multiplier */
201 { "seconds", SECONDS }, /* (pluralized) */
202 { "sec", SECONDS }, /* (generic) */
203 { "s", SECONDS }, /* (short generic) */
204 { "minute", MINUTES }, /* minutes multiplier */
205 { "minutes", MINUTES }, /* (pluralized) */
206 { "min", MINUTES }, /* (generic) */
207 { "m", MONTHS_MINUTES }, /* (short generic) */
208 { "hour", HOURS }, /* hours ... */
209 { "hours", HOURS }, /* (pluralized) */
210 { "hr", HOURS }, /* (generic) */
211 { "h", HOURS }, /* (short generic) */
212 { "day", DAYS }, /* days ... */
213 { "days", DAYS }, /* (pluralized) */
214 { "d", DAYS }, /* (short generic) */
215 { "week", WEEKS }, /* week ... */
216 { "weeks", WEEKS }, /* (pluralized) */
217 { "wk", WEEKS }, /* (generic) */
218 { "w", WEEKS }, /* (short generic) */
219 { "month", MONTHS }, /* week ... */
220 { "months", MONTHS }, /* (pluralized) */
221 { "mon", MONTHS }, /* (generic) */
222 { "year", YEARS }, /* year ... */
223 { "years", YEARS }, /* (pluralized) */
224 { "yr", YEARS }, /* (generic) */
225 { "y", YEARS }, /* (short generic) */
226 { NULL, 0 } /*** SENTINEL ***/
227 };
229 /* File scope variables */
231 /* context dependent list of specials for parser to recognize,
232 * required for us to be able distinguish between 'mon' as 'month'
233 * and 'mon' as 'monday'
234 */
235 static struct SpecialToken *Specials;
237 static const char **scp; /* scanner - pointer at arglist */
238 static char scc; /* scanner - count of remaining arguments */
239 static const char *sct; /* scanner - next char pointer in current argument */
240 static int need; /* scanner - need to advance to next argument */
242 static char *sc_token=NULL; /* scanner - token buffer */
243 static size_t sc_len; /* scanner - length of token buffer */
244 static int sc_tokid; /* scanner - token id */
246 /* Local functions */
247 static void EnsureMemFree (void);
249 static void EnsureMemFree (void)
250 {
251 if( sc_token )
252 {
253 free(sc_token);
254 sc_token = NULL;
255 }
256 }
258 /*
259 * A hack to compensate for the lack of the C++ exceptions
260 *
261 * Every function func that might generate parsing "exception"
262 * should return TIME_OK (aka NULL) or pointer to the error message,
263 * and should be called like this: try(func(args));
264 *
265 * if the try is not successful it will reset the token pointer ...
266 *
267 * [NOTE: when try(...) is used as the only statement in the "if-true"
268 * part of the if statement that also has an "else" part it should be
269 * either enclosed in the curly braces (despite the fact that it looks
270 * like a single statement) or NOT followed by the ";"]
271 */
272 #define try(b) { \
273 char *_e; \
274 if((_e=(b))) \
275 { \
276 EnsureMemFree(); \
277 return _e; \
278 } \
279 }
281 /*
282 * The panic() function was used in the original code to die, we redefine
283 * it as macro to start the chain of ascending returns that in conjunction
284 * with the try(b) above will simulate a sort of "exception handling"
285 */
287 #define panic(e) { \
288 return (e); \
289 }
291 /*
292 * ve() and e() are used to set the return error,
293 * the most appropriate use for these is inside panic(...)
294 */
295 #define MAX_ERR_MSG_LEN 1024
296 static char errmsg[ MAX_ERR_MSG_LEN ];
298 static char *
299 ve ( char *fmt, va_list ap )
300 {
301 #ifdef HAVE_VSNPRINTF
302 vsnprintf( errmsg, MAX_ERR_MSG_LEN, fmt, ap );
303 #else
304 vsprintf( errmsg, fmt, ap );
305 #endif
306 EnsureMemFree();
307 return( errmsg );
308 }
310 static char *
311 e ( char *fmt, ... )
312 {
313 char *err;
314 va_list ap;
315 va_start( ap, fmt );
316 err = ve( fmt, ap );
317 va_end( ap );
318 return( err );
319 }
321 /* Compare S1 and S2, ignoring case, returning less than, equal to or
322 greater than zero if S1 is lexicographically less than,
323 equal to or greater than S2. -- copied from GNU libc*/
324 static int
325 mystrcasecmp (s1, s2)
326 const char *s1;
327 const char *s2;
328 {
329 const unsigned char *p1 = (const unsigned char *) s1;
330 const unsigned char *p2 = (const unsigned char *) s2;
331 unsigned char c1, c2;
333 if (p1 == p2)
334 return 0;
336 do
337 {
338 c1 = tolower (*p1++);
339 c2 = tolower (*p2++);
340 if (c1 == '\0')
341 break;
342 }
343 while (c1 == c2);
345 return c1 - c2;
346 }
348 /*
349 * parse a token, checking if it's something special to us
350 */
351 static int
352 parse_token(char *arg)
353 {
354 int i;
356 for (i=0; Specials[i].name != NULL; i++)
357 if (mystrcasecmp(Specials[i].name, arg) == 0)
358 return sc_tokid = Specials[i].value;
360 /* not special - must be some random id */
361 return sc_tokid = ID;
362 } /* parse_token */
366 /*
367 * init_scanner() sets up the scanner to eat arguments
368 */
369 static char *
370 init_scanner(int argc, const char **argv)
371 {
372 scp = argv;
373 scc = argc;
374 need = 1;
375 sc_len = 1;
376 while (argc-- > 0)
377 sc_len += strlen(*argv++);
379 sc_token = (char *) malloc(sc_len*sizeof(char));
380 if( sc_token == NULL )
381 return "Failed to allocate memory";
382 return TIME_OK;
383 } /* init_scanner */
385 /*
386 * token() fetches a token from the input stream
387 */
388 static int
389 token()
390 {
391 int idx;
393 while (1) {
394 memset(sc_token, '\0', sc_len);
395 sc_tokid = EOF;
396 idx = 0;
398 /* if we need to read another argument, walk along the argument list;
399 * when we fall off the arglist, we'll just return EOF forever
400 */
401 if (need) {
402 if (scc < 1)
403 return sc_tokid;
404 sct = *scp;
405 scp++;
406 scc--;
407 need = 0;
408 }
409 /* eat whitespace now - if we walk off the end of the argument,
410 * we'll continue, which puts us up at the top of the while loop
411 * to fetch the next argument in
412 */
413 while (isspace((unsigned char)*sct) || *sct == '_' || *sct == ',' )
414 ++sct;
415 if (!*sct) {
416 need = 1;
417 continue;
418 }
420 /* preserve the first character of the new token
421 */
422 sc_token[0] = *sct++;
424 /* then see what it is
425 */
426 if (isdigit((unsigned char)(sc_token[0]))) {
427 while (isdigit((unsigned char)(*sct)))
428 sc_token[++idx] = *sct++;
429 sc_token[++idx] = '\0';
430 return sc_tokid = NUMBER;
431 }
432 else if (isalpha((unsigned char)(sc_token[0]))) {
433 while (isalpha((unsigned char)(*sct)))
434 sc_token[++idx] = *sct++;
435 sc_token[++idx] = '\0';
436 return parse_token(sc_token);
437 }
438 else switch(sc_token[0]) {
439 case ':': return sc_tokid = COLON;
440 case '.': return sc_tokid = DOT;
441 case '+': return sc_tokid = PLUS;
442 case '-': return sc_tokid = MINUS;
443 case '/': return sc_tokid = SLASH;
444 default:
445 /*OK, we did not make it ... */
446 sct--;
447 return sc_tokid = EOF;
448 }
449 } /* while (1) */
450 } /* token */
453 /*
454 * expect2() gets a token and complains if it's not the token we want
455 */
456 static char *
457 expect2(int desired, char *complain_fmt, ...)
458 {
459 va_list ap;
460 va_start( ap, complain_fmt );
461 if (token() != desired) {
462 panic(ve( complain_fmt, ap ));
463 }
464 va_end( ap );
465 return TIME_OK;
467 } /* expect2 */
470 /*
471 * plus_minus() is used to parse a single NUMBER TIME-UNIT pair
472 * for the OFFSET-SPEC.
473 * It also applies those m-guessing heuristics.
474 */
475 static char *
476 plus_minus(struct rrd_time_value *ptv, int doop)
477 {
478 static int op = PLUS;
479 static int prev_multiplier = -1;
480 int delta;
482 if( doop >= 0 )
483 {
484 op = doop;
485 try(expect2(NUMBER,"There should be number after '%c'", op == PLUS ? '+' : '-'));
486 prev_multiplier = -1; /* reset months-minutes guessing mechanics */
487 }
488 /* if doop is < 0 then we repeat the previous op
489 * with the prefetched number */
491 delta = atoi(sc_token);
493 if( token() == MONTHS_MINUTES )
494 {
495 /* hard job to guess what does that -5m means: -5mon or -5min? */
496 switch(prev_multiplier)
497 {
498 case DAYS:
499 case WEEKS:
500 case MONTHS:
501 case YEARS:
502 sc_tokid = MONTHS;
503 break;
505 case SECONDS:
506 case MINUTES:
507 case HOURS:
508 sc_tokid = MINUTES;
509 break;
511 default:
512 if( delta < 6 ) /* it may be some other value but in the context
513 * of RRD who needs less than 6 min deltas? */
514 sc_tokid = MONTHS;
515 else
516 sc_tokid = MINUTES;
517 }
518 }
519 prev_multiplier = sc_tokid;
520 switch (sc_tokid) {
521 case YEARS:
522 ptv->tm.tm_year += (op == PLUS) ? delta : -delta;
523 return TIME_OK;
524 case MONTHS:
525 ptv->tm.tm_mon += (op == PLUS) ? delta : -delta;
526 return TIME_OK;
527 case WEEKS:
528 delta *= 7;
529 /* FALLTHRU */
530 case DAYS:
531 ptv->tm.tm_mday += (op == PLUS) ? delta : -delta;
532 return TIME_OK;
533 case HOURS:
534 ptv->offset += (op == PLUS) ? delta*60*60 : -delta*60*60;
535 return TIME_OK;
536 case MINUTES:
537 ptv->offset += (op == PLUS) ? delta*60 : -delta*60;
538 return TIME_OK;
539 case SECONDS:
540 ptv->offset += (op == PLUS) ? delta : -delta;
541 return TIME_OK;
542 default: /*default unit is seconds */
543 ptv->offset += (op == PLUS) ? delta : -delta;
544 return TIME_OK;
545 }
546 panic(e("well-known time unit expected after %d", delta));
547 /* NORETURN */
548 return TIME_OK; /* to make compiler happy :) */
549 } /* plus_minus */
552 /*
553 * tod() computes the time of day (TIME-OF-DAY-SPEC)
554 */
555 static char *
556 tod(struct rrd_time_value *ptv)
557 {
558 int hour, minute = 0;
559 int tlen;
560 /* save token status in case we must abort */
561 int scc_sv = scc;
562 const char *sct_sv = sct;
563 int sc_tokid_sv = sc_tokid;
565 tlen = strlen(sc_token);
567 /* first pick out the time of day - we assume a HH (COLON|DOT) MM time
568 */
569 if (tlen > 2) {
570 return TIME_OK;
571 }
573 hour = atoi(sc_token);
575 token();
576 if (sc_tokid == SLASH || sc_tokid == DOT) {
577 /* guess we are looking at a date */
578 scc = scc_sv;
579 sct = sct_sv;
580 sc_tokid = sc_tokid_sv;
581 sprintf (sc_token,"%d", hour);
582 return TIME_OK;
583 }
584 if (sc_tokid == COLON ) {
585 try(expect2(NUMBER,
586 "Parsing HH:MM syntax, expecting MM as number, got none"));
587 minute = atoi(sc_token);
588 if (minute > 59) {
589 panic(e("parsing HH:MM syntax, got MM = %d (>59!)", minute ));
590 }
591 token();
592 }
594 /* check if an AM or PM specifier was given
595 */
596 if (sc_tokid == AM || sc_tokid == PM) {
597 if (hour > 12) {
598 panic(e("there cannot be more than 12 AM or PM hours"));
599 }
600 if (sc_tokid == PM) {
601 if (hour != 12) /* 12:xx PM is 12:xx, not 24:xx */
602 hour += 12;
603 } else {
604 if (hour == 12) /* 12:xx AM is 00:xx, not 12:xx */
605 hour = 0;
606 }
607 token();
608 }
609 else if (hour > 23) {
610 /* guess it was not a time then ... */
611 scc = scc_sv;
612 sct = sct_sv;
613 sc_tokid = sc_tokid_sv;
614 sprintf (sc_token,"%d", hour);
615 return TIME_OK;
616 }
617 ptv->tm.tm_hour = hour;
618 ptv->tm.tm_min = minute;
619 ptv->tm.tm_sec = 0;
620 if (ptv->tm.tm_hour == 24) {
621 ptv->tm.tm_hour = 0;
622 ptv->tm.tm_mday++;
623 }
624 return TIME_OK;
625 } /* tod */
628 /*
629 * assign_date() assigns a date, adjusting year as appropriate
630 */
631 static char *
632 assign_date(struct rrd_time_value *ptv, long mday, long mon, long year)
633 {
634 if (year > 138) {
635 if (year > 1970)
636 year -= 1900;
637 else {
638 panic(e("invalid year %d (should be either 00-99 or >1900)",
639 year));
640 }
641 } else if( year >= 0 && year < 38 ) {
642 year += 100; /* Allow year 2000-2037 to be specified as */
643 } /* 00-37 until the problem of 2038 year will */
644 /* arise for unices with 32-bit time_t :) */
645 if (year < 70) {
646 panic(e("won't handle dates before epoch (01/01/1970), sorry"));
647 }
649 ptv->tm.tm_mday = mday;
650 ptv->tm.tm_mon = mon;
651 ptv->tm.tm_year = year;
652 return TIME_OK;
653 } /* assign_date */
656 /*
657 * day() picks apart DAY-SPEC-[12]
658 */
659 static char *
660 day(struct rrd_time_value *ptv)
661 {
662 long mday=0, wday, mon, year = ptv->tm.tm_year;
663 int tlen;
665 switch (sc_tokid) {
666 case YESTERDAY:
667 ptv->tm.tm_mday--;
668 /* FALLTRHU */
669 case TODAY: /* force ourselves to stay in today - no further processing */
670 token();
671 break;
672 case TOMORROW:
673 ptv->tm.tm_mday++;
674 token();
675 break;
677 case JAN: case FEB: case MAR: case APR: case MAY: case JUN:
678 case JUL: case AUG: case SEP: case OCT: case NOV: case DEC:
679 /* do month mday [year]
680 */
681 mon = (sc_tokid-JAN);
682 try(expect2(NUMBER,
683 "the day of the month should follow month name"));
684 mday = atol(sc_token);
685 if (token() == NUMBER) {
686 year = atol(sc_token);
687 token();
688 }
689 else
690 year = ptv->tm.tm_year;
691 try(assign_date(ptv, mday, mon, year));
692 break;
694 case SUN: case MON: case TUE:
695 case WED: case THU: case FRI:
696 case SAT:
697 /* do a particular day of the week
698 */
699 wday = (sc_tokid-SUN);
700 ptv->tm.tm_mday += (wday - ptv->tm.tm_wday);
701 token();
702 break;
703 /*
704 mday = ptv->tm.tm_mday;
705 mday += (wday - ptv->tm.tm_wday);
706 ptv->tm.tm_wday = wday;
708 try(assign_date(ptv, mday, ptv->tm.tm_mon, ptv->tm.tm_year));
709 break;
710 */
712 case NUMBER:
713 /* get numeric <sec since 1970>, MM/DD/[YY]YY, or DD.MM.[YY]YY
714 */
715 tlen = strlen(sc_token);
716 mon = atol(sc_token);
717 if (mon > 10*365*24*60*60) {
718 ptv->tm=*localtime(&mon);
719 token();
720 break;
721 }
723 if (mon > 19700101 && mon < 24000101){ /*works between 1900 and 2400 */
724 char cmon[3],cmday[3],cyear[5];
725 strncpy(cyear,sc_token,4);cyear[4]='\0';
726 year = atol(cyear);
727 strncpy(cmon,&(sc_token[4]),2);cmon[2]='\0';
728 mon = atol(cmon);
729 strncpy(cmday,&(sc_token[6]),2);cmday[2]='\0';
730 mday = atol(cmday);
731 token();
732 } else {
733 token();
735 if (mon <= 31 && (sc_tokid == SLASH || sc_tokid == DOT)) {
736 int sep;
737 sep = sc_tokid;
738 try(expect2(NUMBER,"there should be %s number after '%c'",
739 sep == DOT ? "month" : "day", sep == DOT ? '.' : '/'));
740 mday = atol(sc_token);
741 if (token() == sep) {
742 try(expect2(NUMBER,"there should be year number after '%c'",
743 sep == DOT ? '.' : '/'));
744 year = atol(sc_token);
745 token();
746 }
748 /* flip months and days for European timing
749 */
750 if (sep == DOT) {
751 long x = mday;
752 mday = mon;
753 mon = x;
754 }
755 }
756 }
758 mon--;
759 if(mon < 0 || mon > 11 ) {
760 panic(e("did you really mean month %d?", mon+1));
761 }
762 if(mday < 1 || mday > 31) {
763 panic(e("I'm afraid that %d is not a valid day of the month",
764 mday));
765 }
766 try(assign_date(ptv, mday, mon, year));
767 break;
768 } /* case */
769 return TIME_OK;
770 } /* month */
773 /* Global functions */
776 /*
777 * parsetime() is the external interface that takes tspec, parses
778 * it and puts the result in the rrd_time_value structure *ptv.
779 * It can return either absolute times (these are ensured to be
780 * correct) or relative time references that are expected to be
781 * added to some absolute time value and then normalized by
782 * mktime() The return value is either TIME_OK (aka NULL) or
783 * the pointer to the error message in the case of problems
784 */
785 char *
786 parsetime(const char *tspec, struct rrd_time_value *ptv)
787 {
788 time_t now = time(NULL);
789 int hr = 0;
790 /* this MUST be initialized to zero for midnight/noon/teatime */
792 Specials = VariousWords; /* initialize special words context */
794 try(init_scanner( 1, &tspec ));
796 /* establish the default time reference */
797 ptv->type = ABSOLUTE_TIME;
798 ptv->offset = 0;
799 ptv->tm = *localtime(&now);
800 ptv->tm.tm_isdst = -1; /* mk time can figure this out for us ... */
802 token();
803 switch (sc_tokid) {
804 case PLUS:
805 case MINUS:
806 break; /* jump to OFFSET-SPEC part */
808 case START:
809 ptv->type = RELATIVE_TO_START_TIME;
810 goto KeepItRelative;
811 case END:
812 ptv->type = RELATIVE_TO_END_TIME;
813 KeepItRelative:
814 ptv->tm.tm_sec = 0;
815 ptv->tm.tm_min = 0;
816 ptv->tm.tm_hour = 0;
817 ptv->tm.tm_mday = 0;
818 ptv->tm.tm_mon = 0;
819 ptv->tm.tm_year = 0;
820 /* FALLTHRU */
821 case NOW:
822 {
823 int time_reference = sc_tokid;
824 token();
825 if( sc_tokid == PLUS || sc_tokid == MINUS )
826 break;
827 if( time_reference != NOW ) {
828 panic(e("'start' or 'end' MUST be followed by +|- offset"));
829 }
830 else
831 if( sc_tokid != EOF ) {
832 panic(e("if 'now' is followed by a token it must be +|- offset"));
833 }
834 };
835 break;
837 /* Only absolute time specifications below */
838 case NUMBER:
839 try(tod(ptv))
840 try(day(ptv))
841 break;
842 /* fix month parsing */
843 case JAN: case FEB: case MAR: case APR: case MAY: case JUN:
844 case JUL: case AUG: case SEP: case OCT: case NOV: case DEC:
845 try(day(ptv));
846 if (sc_tokid != NUMBER) break;
847 try(tod(ptv))
848 break;
850 /* evil coding for TEATIME|NOON|MIDNIGHT - we've initialized
851 * hr to zero up above, then fall into this case in such a
852 * way so we add +12 +4 hours to it for teatime, +12 hours
853 * to it for noon, and nothing at all for midnight, then
854 * set our rettime to that hour before leaping into the
855 * month scanner
856 */
857 case TEATIME:
858 hr += 4;
859 /* FALLTHRU */
860 case NOON:
861 hr += 12;
862 /* FALLTHRU */
863 case MIDNIGHT:
864 /* if (ptv->tm.tm_hour >= hr) {
865 ptv->tm.tm_mday++;
866 ptv->tm.tm_wday++;
867 } */ /* shifting does not makes sense here ... noon is noon */
868 ptv->tm.tm_hour = hr;
869 ptv->tm.tm_min = 0;
870 ptv->tm.tm_sec = 0;
871 token();
872 try(day(ptv));
873 break;
874 default:
875 panic(e("unparsable time: %s%s",sc_token,sct));
876 break;
877 } /* ugly case statement */
879 /*
880 * the OFFSET-SPEC part
881 *
882 * (NOTE, the sc_tokid was prefetched for us by the previous code)
883 */
884 if( sc_tokid == PLUS || sc_tokid == MINUS ) {
885 Specials = TimeMultipliers; /* switch special words context */
886 while( sc_tokid == PLUS || sc_tokid == MINUS ||
887 sc_tokid == NUMBER ) {
888 if( sc_tokid == NUMBER ) {
889 try(plus_minus(ptv, PREVIOUS_OP ));
890 } else
891 try(plus_minus(ptv, sc_tokid));
892 token(); /* We will get EOF eventually but that's OK, since
893 token() will return us as many EOFs as needed */
894 }
895 }
897 /* now we should be at EOF */
898 if( sc_tokid != EOF ) {
899 panic(e("unparsable trailing text: '...%s%s'", sc_token, sct));
900 }
902 ptv->tm.tm_isdst = -1; /* for mktime to guess DST status */
903 if( ptv->type == ABSOLUTE_TIME )
904 if( mktime( &ptv->tm ) == -1 ) { /* normalize & check */
905 /* can happen for "nonexistent" times, e.g. around 3am */
906 /* when winter -> summer time correction eats a hour */
907 panic(e("the specified time is incorrect (out of range?)"));
908 }
909 EnsureMemFree();
910 return TIME_OK;
911 } /* parsetime */
914 int proc_start_end (struct rrd_time_value *start_tv,
915 struct rrd_time_value *end_tv,
916 time_t *start,
917 time_t *end){
918 if (start_tv->type == RELATIVE_TO_END_TIME && /* same as the line above */
919 end_tv->type == RELATIVE_TO_START_TIME) {
920 rrd_set_error("the start and end times cannot be specified "
921 "relative to each other");
922 return -1;
923 }
925 if (start_tv->type == RELATIVE_TO_START_TIME) {
926 rrd_set_error("the start time cannot be specified relative to itself");
927 return -1;
928 }
930 if (end_tv->type == RELATIVE_TO_END_TIME) {
931 rrd_set_error("the end time cannot be specified relative to itself");
932 return -1;
933 }
935 if( start_tv->type == RELATIVE_TO_END_TIME) {
936 struct tm tmtmp;
937 *end = mktime(&(end_tv->tm)) + end_tv->offset;
938 tmtmp = *localtime(end); /* reinit end including offset */
939 tmtmp.tm_mday += start_tv->tm.tm_mday;
940 tmtmp.tm_mon += start_tv->tm.tm_mon;
941 tmtmp.tm_year += start_tv->tm.tm_year;
942 *start = mktime(&tmtmp) + start_tv->offset;
943 } else {
944 *start = mktime(&(start_tv->tm)) + start_tv->offset;
945 }
946 if (end_tv->type == RELATIVE_TO_START_TIME) {
947 struct tm tmtmp;
948 *start = mktime(&(start_tv->tm)) + start_tv->offset;
949 tmtmp = *localtime(start);
950 tmtmp.tm_mday += end_tv->tm.tm_mday;
951 tmtmp.tm_mon += end_tv->tm.tm_mon;
952 tmtmp.tm_year += end_tv->tm.tm_year;
953 *end = mktime(&tmtmp) + end_tv->offset;
954 } else {
955 *end = mktime(&(end_tv->tm)) + end_tv->offset;
956 }
957 return 0;
958 } /* proc_start_end */