util: remove dead code KTimeCmp
[openafs.git] / src / util / ktime.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 #include <roken.h>
14 #include <afs/opr.h>
15
16 #include <ctype.h>
17
18 #include <afs/opr.h>
19 #include "afsutil.h"
20 #include "ktime.h"
21
22 /* some date parsing routines */
23
24 struct token {
25     struct token *next;
26     char *key;
27 };
28
29 static char *day[] = {
30     "sun",
31     "mon",
32     "tue",
33     "wed",
34     "thu",
35     "fri",
36     "sat"
37 };
38
39 /* free token list returned by parseLine */
40 static void
41 LocalFreeTokens(struct token *alist)
42 {
43     struct token *nlist;
44     for (; alist; alist = nlist) {
45         nlist = alist->next;
46         free(alist->key);
47         free(alist);
48     }
49     return;
50 }
51
52 static int
53 space(int x)
54 {
55     if (x == 0 || x == ' ' || x == '\t' || x == '\n')
56         return 1;
57     else
58         return 0;
59 }
60
61 static int
62 LocalParseLine(char *aline, struct token **alist)
63 {
64     char tbuffer[256];
65     char *tptr = NULL;
66     int inToken;
67     struct token *first, *last;
68     struct token *ttok;
69     int tc;
70
71     inToken = 0;                /* not copying token chars at start */
72     first = NULL;
73     last = NULL;
74     while (1) {
75         tc = *aline++;
76         if (tc == 0 || space(tc)) {     /* terminating null gets us in here, too */
77             if (inToken) {
78                 inToken = 0;    /* end of this token */
79                 *tptr++ = 0;
80                 ttok = malloc(sizeof(struct token));
81                 ttok->next = NULL;
82                 ttok->key = strdup(tbuffer);
83                 if (last) {
84                     last->next = ttok;
85                     last = ttok;
86                 } else
87                     last = ttok;
88                 if (!first)
89                     first = ttok;
90             }
91         } else {
92             /* an alpha character */
93             if (!inToken) {
94                 tptr = tbuffer;
95                 inToken = 1;
96             }
97             if (tptr - tbuffer >= sizeof(tbuffer))
98                 return -1;      /* token too long */
99             *tptr++ = tc;
100         }
101         if (tc == 0) {
102             /* last token flushed 'cause space(0) --> true */
103             if (last)
104                 last->next = NULL;
105             *alist = first;
106             return 0;
107         }
108     }
109 }
110
111 /* keyword database for periodic date parsing */
112 static struct ptemp {
113     char *key;
114     afs_int32 value;
115 } ptkeys[] = {
116     {
117     "sun", 0x10000,}, {
118     "mon", 0x10001,}, {
119     "tue", 0x10002,}, {
120     "wed", 0x10003,}, {
121     "thu", 0x10004,}, {
122     "fri", 0x10005,}, {
123     "sat", 0x10006,}, {
124     "sunday", 0x10000,}, {
125     "monday", 0x10001,}, {
126     "tuesday", 0x10002,}, {
127     "wednesday", 0x10003,}, {
128     "thursday", 0x10004,}, {
129     "thur", 0x10004,}, {
130     "friday", 0x10005,}, {
131     "saturday", 0x10006,}, {
132     "am", 0x20000,}, {
133     "pm", 0x20001,}, {
134     "a.m.", 0x20000,}, {
135     "p.m.", 0x20001,}, {
136     0, 0,}
137 };
138
139 /* ktime_DateOf
140  * entry:
141  *      atime - time in seconds (Unix std)
142  * exit:
143  *      return value - ptr to time in text form. Ptr is to a static string.
144  */
145
146 char *
147 ktime_DateOf(afs_int32 atime)
148 {
149     static char tbuffer[30];
150     char *tp;
151     time_t t = atime;
152     tp = ctime(&t);
153     if (tp) {
154         strcpy(tbuffer, tp);
155         tbuffer[24] = 0;        /* get rid of new line */
156     } else
157         strcpy(tbuffer, "BAD TIME");
158     return tbuffer;
159 }
160
161 /* ParseTime
162  *      parse 12:33:12 or 12:33 or 12 into ktime structure
163  * entry:
164  *      astr - ptr to string to be parsed
165  *      ak - ptr to struct for return value.
166  * exit:
167  *      0 - ak holds parsed time.
168  *      -1 - error in format
169  */
170
171 static int
172 ParseTime(struct ktime *ak, char *astr)
173 {
174     int field;
175     afs_int32 temp;
176     char *tp;
177     int tc;
178
179     field = 0;                  /* 0=hour, 1=min, 2=sec */
180     temp = 0;
181
182     ak->mask |= (KTIME_HOUR | KTIME_MIN | KTIME_SEC);
183     for (tp = astr;;) {
184         tc = *tp++;
185         if (tc == 0 || tc == ':') {
186             if (field == 0)
187                 ak->hour = temp;
188             else if (field == 1)
189                 ak->min = temp;
190             else if (field == 2)
191                 ak->sec = temp;
192             temp = 0;
193             field++;
194             if (tc == 0)
195                 break;
196             continue;
197         } else if (!isdigit(tc))
198             return -1;          /* syntax error */
199         else {
200             /* digit */
201             temp *= 10;
202             temp += tc - '0';
203         }
204     }
205     if (ak->hour >= 24 || ak->min >= 60 || ak->sec >= 60)
206         return -1;
207     return 0;
208 }
209
210 afs_int32
211 ktime_Str2int32(char *astr)
212 {
213     struct ktime tk;
214
215     memset(&tk, 0, sizeof(tk));
216     if (ParseTime(&tk, astr))
217         return (-1);            /* syntax error */
218
219     return ((tk.hour * 60 + tk.min) * 60 + tk.sec);
220 }
221
222 /* ktime_ParsePeriodic
223  *      Parses periodic date of form
224  *              now | never | at [time spec] | every [time spec]
225  *      where [time spec] is a ktime string.
226  * entry:
227  *      adate - string to be parsed
228  *      ak - ptr to structure for returned ktime
229  * exit:
230  *      0 - parsed ktime in ak
231  *      -1 - specification error
232  */
233
234 /* -1 means error, 0 means now, otherwise returns time of next event */
235 int
236 ktime_ParsePeriodic(char *adate, struct ktime *ak)
237 {
238     struct token *tt;
239     afs_int32 code;
240     struct ptemp *tp;
241
242     memset(ak, 0, sizeof(*ak));
243     code = LocalParseLine(adate, &tt);
244     if (code)
245         return -1;
246     for (; tt; tt = tt->next) {
247         /* look at each token */
248         if (strcmp(tt->key, "now") == 0) {
249             ak->mask |= KTIME_NOW;
250             goto out;
251         }
252         if (strcmp(tt->key, "never") == 0) {
253             ak->mask |= KTIME_NEVER;
254             goto out;
255         }
256         if (strcmp(tt->key, "at") == 0)
257             continue;
258         if (strcmp(tt->key, "every") == 0)
259             continue;
260         if (isdigit(tt->key[0])) {
261             /* parse a time */
262             code = ParseTime(ak, tt->key);
263             if (code) {
264                 code = -1;
265                 goto out;
266             }
267             continue;
268         }
269         /* otherwise use keyword table */
270         for (tp = ptkeys;; tp++) {
271             if (tp->key == NULL) {
272                 code = -1;
273                 goto out;
274             }
275             if (strcmp(tp->key, tt->key) == 0)
276                 break;
277         }
278         /* now look at tp->value to see what we've got */
279         if ((tp->value >> 16) == 1) {
280             /* a day */
281             ak->mask |= KTIME_DAY;
282             ak->day = tp->value & 0xff;
283         }
284         if ((tp->value >> 16) == 2) {
285             /* am or pm token */
286             if ((tp->value & 0xff) == 1) {
287                 /* pm */
288                 if (!(ak->mask & KTIME_HOUR)) {
289                     code = -1;
290                     goto out;
291                 }
292                 if (ak->hour < 12) {
293                     ak->hour += 12;
294                 /* 12 is 12 PM */
295                 } else if (ak->hour != 12) {
296                     code = -1;
297                     goto out;
298                 }
299             } else {
300                 /* am is almost a noop, except that we map 12:01 am to 0:01 */
301                 if (ak->hour > 12) {
302                     code = -1;
303                     goto out;
304                 }
305                 if (ak->hour == 12)
306                     ak->hour = 0;
307             }
308         }
309     }
310 out:
311     LocalFreeTokens(tt);
312     return code;
313 }
314
315 /* ktime_DisplayString
316  *      Display ktime structure as English that could go into the ktime parser
317  * entry:
318  *      aparm - ktime to be converted to string
319  *      astring - ptr to string, for the result
320  * exit:
321  *      0 - astring contains ktime string.
322  */
323 int
324 ktime_DisplayString(struct ktime *aparm, char *astring)
325 {
326     char tempString[50];
327
328     if (aparm->mask & KTIME_NEVER) {
329         strcpy(astring, "never");
330         return 0;
331     } else if (aparm->mask & KTIME_NOW) {
332         strcpy(astring, "now");
333         return 0;
334     } else {
335         strcpy(astring, "at");
336         if (aparm->mask & KTIME_DAY) {
337             strcat(astring, " ");
338             strcat(astring, day[aparm->day]);
339         }
340         if (aparm->mask & KTIME_HOUR) {
341             if (aparm->hour > 12)
342                 sprintf(tempString, " %d", aparm->hour - 12);
343             else if (aparm->hour == 0)
344                 strcpy(tempString, " 12");
345             else
346                 sprintf(tempString, " %d", aparm->hour);
347             strcat(astring, tempString);
348         }
349         if (aparm->mask & KTIME_MIN) {
350             sprintf(tempString, ":%02d", aparm->min);
351             strcat(astring, tempString);
352         }
353         if ((aparm->mask & KTIME_SEC) && aparm->sec != 0) {
354             sprintf(tempString, ":%02d", aparm->sec);
355             strcat(astring, tempString);
356         }
357         if (aparm->mask & KTIME_HOUR) {
358             if (aparm->hour >= 12)
359                 strcat(astring, " pm");
360             else
361                 strcat(astring, " am");
362         }
363     }
364     return 0;
365 }
366
367 /* get next time that matches ktime structure after time afrom */
368 afs_int32
369 ktime_next(struct ktime * aktime, afs_int32 afrom)
370 {
371     /* try by guessing from now */
372     struct tm *tsp;
373     time_t start;               /* time to start looking */
374     time_t probe;               /* a placeholder to use for advancing day to day */
375     time_t time_next;           /* actual UTC time of probe, with time of day set */
376     afs_int32 tmask;
377     struct ktime_date tdate;
378
379     start = afrom + time(0);    /* time to start search */
380     tmask = aktime->mask;
381
382     /* handle some special cases */
383     if (tmask & KTIME_NEVER)
384         return KTIME_NEVERTIME;
385     if (tmask & KTIME_NOW)
386         return KTIME_NOWTIME;
387
388     /* Use probe to fill in members of *tsp. Add 23 hours each iteration until
389      * time_next is correct. Only add 23 hrs to avoid skipping spring
390      * daylight savings time day */
391     for (probe = start;; probe += (23 * 3600)) {
392         tsp = localtime(&probe);        /* find out what UTC time "probe" is */
393         if (!tsp)
394             return KTIME_NEVERTIME;
395
396         tdate.year = tsp->tm_year;
397         tdate.month = tsp->tm_mon + 1;
398         tdate.day = tsp->tm_mday;
399         tdate.mask =
400             KTIMEDATE_YEAR | KTIMEDATE_MONTH | KTIMEDATE_DAY | KTIMEDATE_HOUR
401             | KTIMEDATE_MIN | KTIMEDATE_SEC;
402         tdate.hour = aktime->hour;      /* edit in our changes */
403         tdate.min = aktime->min;
404         tdate.sec = aktime->sec;
405         time_next = ktime_InterpretDate(&tdate);        /* Convert back to UTC time */
406         if (time_next < start)
407             continue;           /* "probe" time is already past */
408         if ((tmask & KTIME_DAY) == 0)   /* don't care about day, we're done */
409             break;
410
411         tsp = localtime(&time_next);
412         if (!tsp)
413             return KTIME_NEVERTIME;
414         if (tsp->tm_wday == aktime->day)
415             break;              /* day matches, we're done */
416     }
417     return time_next;
418 }
419
420
421 /* compare date in both formats, and return as in strcmp */
422 static int
423 KDateCmp(struct ktime_date *akdate, struct tm *atm)
424 {
425     if (akdate->year > atm->tm_year)
426         return 1;
427     if (akdate->year < atm->tm_year)
428         return -1;
429     if (akdate->month > atm->tm_mon)
430         return 1;
431     if (akdate->month < atm->tm_mon)
432         return -1;
433     if (akdate->day > atm->tm_mday)
434         return 1;
435     if (akdate->day < atm->tm_mday)
436         return -1;
437     if (akdate->mask & KTIMEDATE_HOUR) {
438         if (akdate->hour > atm->tm_hour)
439             return 1;
440         if (akdate->hour < atm->tm_hour)
441             return -1;
442     }
443     if (akdate->mask & KTIMEDATE_MIN) {
444         if (akdate->min > atm->tm_min)
445             return 1;
446         if (akdate->min < atm->tm_min)
447             return -1;
448     }
449     if (akdate->mask & KTIMEDATE_SEC) {
450         if (akdate->sec > atm->tm_sec)
451             return 1;
452         if (akdate->sec < atm->tm_sec)
453             return -1;
454     }
455     return 0;
456 }
457
458 /* ktime_ParseDate
459  *      parse date string into ktime_date structure
460  * entry:
461  *      adate - string to be parsed
462  *      akdate - ptr to ktime_date for result
463  * exit:
464  *      0 - akdate contains converted date
465  *      -1 - parsing failure
466  */
467
468 static afs_int32
469 ktime_ParseDate(char *adate, struct ktime_date *akdate)
470 {
471     int code;
472     afs_int32 month, day2, year, hour, min, sec;
473     char never[7];
474     char c[2];
475
476     lcstring(never, adate, sizeof(never));
477     if (strcmp(never, "never") == 0)
478         akdate->mask = KTIMEDATE_NEVER;
479     else if (strcmp(never, "now") == 0)
480         akdate->mask = KTIMEDATE_NOW;
481     else
482         akdate->mask = 0;
483     if (akdate->mask)
484         return 0;
485
486     /* Old ambiguous mm/dd/yy hh:mm:ss format */
487
488     code =
489         sscanf(adate, "%d / %d / %d %d : %d : %d%1s", &month, &day2, &year,
490                &hour, &min, &sec, &c[0]);
491     if (code != 6) {
492         sec = 0;
493         code =
494             sscanf(adate, "%d / %d / %d %d : %d%1s", &month, &day2, &year,
495                    &hour, &min, &c[0]);
496         if (code != 5) {
497             hour = min = 0;
498             code =
499                 sscanf(adate, "%d / %d / %d%1s", &month, &day2, &year, &c[0]);
500             if (code != 3) {
501                 code = -1;
502             }
503         }
504     }
505
506     /* New ISO 8601 (subset) format */
507
508     if (code < 0) {
509         hour = min = sec = 0;
510         code =
511             sscanf(adate, "%d-%d-%d %d:%d:%d%1s", &year, &month, &day2,
512                    &hour, &min, &sec, c);
513         if (code != 3 && code != 5 && code != 6)
514             code = -1;
515     }
516
517     if (code < 0)
518         return code;
519
520     if ((year < 0) || (month < 1) || (month > 12) || (day2 < 1) || (day2 > 31) ||       /* more or less */
521         (hour < 0) || (hour > 23) || (min < 0) || (min > 59) || (sec < 0)
522         || (sec > 59))
523         return -2;
524
525     if (year < 69)
526         year += 100;            /* make 1/1/1 => Jan 1, 2001 */
527     else if (year >= 1900)
528         year -= 1900;           /* allow 1/1/2001 to work */
529     else if (year > 99)
530         return -2;              /* only allow 2 or 4 digit years */
531
532     akdate->mask =
533         KTIMEDATE_YEAR | KTIMEDATE_MONTH | KTIMEDATE_DAY | KTIMEDATE_HOUR |
534         KTIMEDATE_MIN | KTIMEDATE_SEC;
535
536     akdate->year = year;
537     akdate->month = month;
538     akdate->day = day2;
539     akdate->hour = hour;
540     akdate->min = min;
541     akdate->sec = sec;
542
543     /* done successfully */
544     return 0;
545 }
546
547 /* ktime_DateToInt32
548  *      Converts a ktime date string into an afs_int32
549  * entry:
550  *      adate - ktime date string
551  *      aint32 - ptr to afs_int32
552  * exit:
553  *      0 - aint32 contains converted date.
554  */
555
556 afs_int32
557 ktime_DateToInt32(char *adate, afs_int32 * aint32)
558 {
559     struct ktime_date tdate;
560     afs_int32 code;
561     unsigned long l;
562     char c[2];
563
564     if (sscanf(adate, "%lu%1s", &l, c) == 1 && l > 200000000)
565         *aint32 = l;
566     else {
567         /* parse the date into a ktime_date structure */
568         code = ktime_ParseDate(adate, &tdate);
569         if (code)
570             return code;                /* failed to parse */
571         *aint32 = ktime_InterpretDate(&tdate);  /* interpret as seconds since 1970 */
572     }
573
574     return 0;
575 }
576
577 /* get useful error message to print about date input format */
578 char *
579 ktime_GetDateUsage(void)
580 {
581     return "date format is '(yyyy-mm-dd | mm/dd/yy) [hh:mm]', using a 24 hour clock";
582 }
583
584
585 /* ktime_InterpretDate
586  *      Converts ktime_date to an afs_int32
587  * entry:
588  *      akdate - date to be converted/interpreted
589  * exit:
590  *      returns KTIMEDATE_NEVERDATE - if never flag was set, or
591  *      date converted to afs_int32.
592  */
593
594 afs_int32
595 ktime_InterpretDate(struct ktime_date * akdate)
596 {
597     afs_uint32 tresult;
598     afs_uint32 tbit;
599     time_t temp;
600     struct tm *tsp;
601
602     if (akdate->mask & KTIMEDATE_NOW)
603         return time(0);
604     if (akdate->mask & KTIMEDATE_NEVER)
605         return KTIMEDATE_NEVERDATE;
606
607     tbit = 1 << 30;             /* start off at max signed result */
608     tresult = 0;                /* result to return */
609     while (tbit > 0) {
610         temp = tresult + tbit;  /* see if adding this bit keeps us < akdate */
611         tsp = localtime(&temp);
612         if (!tsp)
613             return KTIMEDATE_NEVERDATE;
614         tsp->tm_mon++;
615         if (KDateCmp(akdate, tsp) >= 0) {
616             /* if temp still represents earlier than date than we're searching
617              * for, add in bit as increment, otherwise use old value and look
618              * for smaller increment */
619             tresult = temp;
620         }
621         tbit = tbit >> 1;       /* try next bit */
622     }
623
624     return tresult;
625 }