chiark / gitweb /
security: rework selinux, smack, ima, apparmor detection logic
[elogind.git] / src / shared / calendarspec.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2012 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <stdlib.h>
23 #include <string.h>
24
25 #include "calendarspec.h"
26
27 static void free_chain(CalendarComponent *c) {
28         CalendarComponent *n;
29
30         while (c) {
31                 n = c->next;
32                 free(c);
33                 c = n;
34         }
35 }
36
37 void calendar_spec_free(CalendarSpec *c) {
38         assert(c);
39
40         free_chain(c->year);
41         free_chain(c->month);
42         free_chain(c->day);
43         free_chain(c->hour);
44         free_chain(c->minute);
45         free_chain(c->second);
46
47         free(c);
48 }
49
50 static int component_compare(const void *_a, const void *_b) {
51         CalendarComponent * const *a = _a, * const *b = _b;
52
53         if ((*a)->value < (*b)->value)
54                 return -1;
55         if ((*a)->value > (*b)->value)
56                 return 1;
57
58         if ((*a)->repeat < (*b)->repeat)
59                 return -1;
60         if ((*a)->repeat > (*b)->repeat)
61                 return 1;
62
63         return 0;
64 }
65
66 static void sort_chain(CalendarComponent **c) {
67         unsigned n = 0, k;
68         CalendarComponent **b, *i, **j, *next;
69
70         assert(c);
71
72         for (i = *c; i; i = i->next)
73                 n++;
74
75         if (n <= 1)
76                 return;
77
78         j = b = alloca(sizeof(CalendarComponent*) * n);
79         for (i = *c; i; i = i->next)
80                 *(j++) = i;
81
82         qsort(b, n, sizeof(CalendarComponent*), component_compare);
83
84         b[n-1]->next = NULL;
85         next = b[n-1];
86
87         /* Drop non-unique entries */
88         for (k = n-1; k > 0; k--) {
89                 if (b[k-1]->value == next->value &&
90                     b[k-1]->repeat == next->repeat) {
91                         free(b[k-1]);
92                         continue;
93                 }
94
95                 b[k-1]->next = next;
96                 next = b[k-1];
97         }
98
99         *c = next;
100 }
101
102 static void fix_year(CalendarComponent *c) {
103         /* Turns 12 → 2012, 89 → 1989 */
104
105         while(c) {
106                 CalendarComponent *n = c->next;
107
108                 if (c->value >= 0 && c->value < 70)
109                         c->value += 2000;
110
111                 if (c->value >= 70 && c->value < 100)
112                         c->value += 1900;
113
114                 c = n;
115         }
116 }
117
118 int calendar_spec_normalize(CalendarSpec *c) {
119         assert(c);
120
121         if (c->weekdays_bits <= 0 || c->weekdays_bits >= 127)
122                 c->weekdays_bits = -1;
123
124         fix_year(c->year);
125
126         sort_chain(&c->year);
127         sort_chain(&c->month);
128         sort_chain(&c->day);
129         sort_chain(&c->hour);
130         sort_chain(&c->minute);
131         sort_chain(&c->second);
132
133         return 0;
134 }
135
136 _pure_ static bool chain_valid(CalendarComponent *c, int from, int to) {
137         if (!c)
138                 return true;
139
140         if (c->value < from || c->value > to)
141                 return false;
142
143         if (c->value + c->repeat > to)
144                 return false;
145
146         if (c->next)
147                 return chain_valid(c->next, from, to);
148
149         return true;
150 }
151
152 _pure_ bool calendar_spec_valid(CalendarSpec *c) {
153         assert(c);
154
155         if (c->weekdays_bits > 127)
156                 return false;
157
158         if (!chain_valid(c->year, 1970, 2199))
159                 return false;
160
161         if (!chain_valid(c->month, 1, 12))
162                 return false;
163
164         if (!chain_valid(c->day, 1, 31))
165                 return false;
166
167         if (!chain_valid(c->hour, 0, 23))
168                 return false;
169
170         if (!chain_valid(c->minute, 0, 59))
171                 return false;
172
173         if (!chain_valid(c->second, 0, 59))
174                 return false;
175
176         return true;
177 }
178
179 static void format_weekdays(FILE *f, const CalendarSpec *c) {
180         static const char *const days[] = {
181                 "Mon",
182                 "Tue",
183                 "Wed",
184                 "Thu",
185                 "Fri",
186                 "Sat",
187                 "Sun"
188         };
189
190         int l, x;
191         bool need_colon = false;
192
193         assert(f);
194         assert(c);
195         assert(c->weekdays_bits > 0 && c->weekdays_bits <= 127);
196
197         for (x = 0, l = -1; x < (int) ELEMENTSOF(days); x++) {
198
199                 if (c->weekdays_bits & (1 << x)) {
200
201                         if (l < 0) {
202                                 if (need_colon)
203                                         fputc(',', f);
204                                 else
205                                         need_colon = true;
206
207                                 fputs(days[x], f);
208                                 l = x;
209                         }
210
211                 } else if (l >= 0) {
212
213                         if (x > l + 1) {
214                                 fputc(x > l + 2 ? '-' : ',', f);
215                                 fputs(days[x-1], f);
216                         }
217
218                         l = -1;
219                 }
220         }
221
222         if (l >= 0 && x > l + 1) {
223                 fputc(x > l + 2 ? '-' : ',', f);
224                 fputs(days[x-1], f);
225         }
226 }
227
228 static void format_chain(FILE *f, int space, const CalendarComponent *c) {
229         assert(f);
230
231         if (!c) {
232                 fputc('*', f);
233                 return;
234         }
235
236         assert(c->value >= 0);
237         fprintf(f, "%0*i", space, c->value);
238
239         if (c->repeat > 0)
240                 fprintf(f, "/%i", c->repeat);
241
242         if (c->next) {
243                 fputc(',', f);
244                 format_chain(f, space, c->next);
245         }
246 }
247
248 int calendar_spec_to_string(const CalendarSpec *c, char **p) {
249         char *buf = NULL;
250         size_t sz = 0;
251         FILE *f;
252
253         assert(c);
254         assert(p);
255
256         f = open_memstream(&buf, &sz);
257         if (!f)
258                 return -ENOMEM;
259
260         if (c->weekdays_bits > 0 && c->weekdays_bits <= 127) {
261                 format_weekdays(f, c);
262                 fputc(' ', f);
263         }
264
265         format_chain(f, 4, c->year);
266         fputc('-', f);
267         format_chain(f, 2, c->month);
268         fputc('-', f);
269         format_chain(f, 2, c->day);
270         fputc(' ', f);
271         format_chain(f, 2, c->hour);
272         fputc(':', f);
273         format_chain(f, 2, c->minute);
274         fputc(':', f);
275         format_chain(f, 2, c->second);
276
277         fflush(f);
278
279         if (ferror(f)) {
280                 free(buf);
281                 fclose(f);
282                 return -ENOMEM;
283         }
284
285         fclose(f);
286
287         *p = buf;
288         return 0;
289 }
290
291 static int parse_weekdays(const char **p, CalendarSpec *c) {
292         static const struct {
293                 const char *name;
294                 const int nr;
295         } day_nr[] = {
296                 { "Monday",    0 },
297                 { "Mon",       0 },
298                 { "Tuesday",   1 },
299                 { "Tue",       1 },
300                 { "Wednesday", 2 },
301                 { "Wed",       2 },
302                 { "Thursday",  3 },
303                 { "Thu",       3 },
304                 { "Friday",    4 },
305                 { "Fri",       4 },
306                 { "Saturday",  5 },
307                 { "Sat",       5 },
308                 { "Sunday",    6 },
309                 { "Sun",       6 }
310         };
311
312         int l = -1;
313         bool first = true;
314
315         assert(p);
316         assert(*p);
317         assert(c);
318
319         for (;;) {
320                 unsigned i;
321
322                 if (!first && **p == ' ')
323                         return 0;
324
325                 for (i = 0; i < ELEMENTSOF(day_nr); i++) {
326                         size_t skip;
327
328                         if (!startswith_no_case(*p, day_nr[i].name))
329                                 continue;
330
331                         skip = strlen(day_nr[i].name);
332
333                         if ((*p)[skip] != '-' &&
334                             (*p)[skip] != ',' &&
335                             (*p)[skip] != ' ' &&
336                             (*p)[skip] != 0)
337                                 return -EINVAL;
338
339                         c->weekdays_bits |= 1 << day_nr[i].nr;
340
341                         if (l >= 0) {
342                                 int j;
343
344                                 if (l > day_nr[i].nr)
345                                         return -EINVAL;
346
347                                 for (j = l + 1; j < day_nr[i].nr; j++)
348                                         c->weekdays_bits |= 1 << j;
349                         }
350
351                         *p += skip;
352                         break;
353                 }
354
355                 /* Couldn't find this prefix, so let's assume the
356                    weekday was not specified and let's continue with
357                    the date */
358                 if (i >= ELEMENTSOF(day_nr))
359                         return first ? 0 : -EINVAL;
360
361                 /* We reached the end of the string */
362                 if (**p == 0)
363                         return 0;
364
365                 /* We reached the end of the weekday spec part */
366                 if (**p == ' ') {
367                         *p += strspn(*p, " ");
368                         return 0;
369                 }
370
371                 if (**p == '-') {
372                         if (l >= 0)
373                                 return -EINVAL;
374
375                         l = day_nr[i].nr;
376                 } else
377                         l = -1;
378
379                 *p += 1;
380                 first = false;
381         }
382 }
383
384 static int prepend_component(const char **p, CalendarComponent **c) {
385         unsigned long value, repeat = 0;
386         char *e = NULL, *ee = NULL;
387         CalendarComponent *cc;
388
389         assert(p);
390         assert(c);
391
392         errno = 0;
393         value = strtoul(*p, &e, 10);
394         if (errno > 0)
395                 return -errno;
396         if (e == *p)
397                 return -EINVAL;
398         if ((unsigned long) (int) value != value)
399                 return -ERANGE;
400
401         if (*e == '/') {
402                 repeat = strtoul(e+1, &ee, 10);
403                 if (errno > 0)
404                         return -errno;
405                 if (ee == e+1)
406                         return -EINVAL;
407                 if ((unsigned long) (int) repeat != repeat)
408                         return -ERANGE;
409                 if (repeat <= 0)
410                         return -ERANGE;
411
412                 e = ee;
413         }
414
415         if (*e != 0 && *e != ' ' && *e != ',' && *e != '-' && *e != ':')
416                 return -EINVAL;
417
418         cc = new0(CalendarComponent, 1);
419         if (!cc)
420                 return -ENOMEM;
421
422         cc->value = value;
423         cc->repeat = repeat;
424         cc->next = *c;
425
426         *p = e;
427         *c = cc;
428
429         if (*e ==',') {
430                 *p += 1;
431                 return prepend_component(p, c);
432         }
433
434         return 0;
435 }
436
437 static int parse_chain(const char **p, CalendarComponent **c) {
438         const char *t;
439         CalendarComponent *cc = NULL;
440         int r;
441
442         assert(p);
443         assert(c);
444
445         t = *p;
446
447         if (t[0] == '*') {
448                 *p = t + 1;
449                 *c = NULL;
450                 return 0;
451         }
452
453         r = prepend_component(&t, &cc);
454         if (r < 0) {
455                 free_chain(cc);
456                 return r;
457         }
458
459         *p = t;
460         *c = cc;
461         return 0;
462 }
463
464 static int const_chain(int value, CalendarComponent **c) {
465         CalendarComponent *cc = NULL;
466
467         assert(c);
468
469         cc = new0(CalendarComponent, 1);
470         if (!cc)
471                 return -ENOMEM;
472
473         cc->value = value;
474         cc->repeat = 0;
475         cc->next = NULL;
476
477         *c = cc;
478
479         return 0;
480 }
481
482 static int parse_date(const char **p, CalendarSpec *c) {
483         const char *t;
484         int r;
485         CalendarComponent *first, *second, *third;
486
487         assert(p);
488         assert(*p);
489         assert(c);
490
491         t = *p;
492
493         if (*t == 0)
494                 return 0;
495
496         r = parse_chain(&t, &first);
497         if (r < 0)
498                 return r;
499
500         /* Already the end? A ':' as separator? In that case this was a time, not a date */
501         if (*t == 0 || *t == ':') {
502                 free_chain(first);
503                 return 0;
504         }
505
506         if (*t != '-') {
507                 free_chain(first);
508                 return -EINVAL;
509         }
510
511         t++;
512         r = parse_chain(&t, &second);
513         if (r < 0) {
514                 free_chain(first);
515                 return r;
516         }
517
518         /* Got two parts, hence it's month and day */
519         if (*t == ' ' || *t == 0) {
520                 *p = t + strspn(t, " ");
521                 c->month = first;
522                 c->day = second;
523                 return 0;
524         }
525
526         if (*t != '-') {
527                 free_chain(first);
528                 free_chain(second);
529                 return -EINVAL;
530         }
531
532         t++;
533         r = parse_chain(&t, &third);
534         if (r < 0) {
535                 free_chain(first);
536                 free_chain(second);
537                 return r;
538         }
539
540         /* Got tree parts, hence it is year, month and day */
541         if (*t == ' ' || *t == 0) {
542                 *p = t + strspn(t, " ");
543                 c->year = first;
544                 c->month = second;
545                 c->day = third;
546                 return 0;
547         }
548
549         free_chain(first);
550         free_chain(second);
551         free_chain(third);
552         return -EINVAL;
553 }
554
555 static int parse_time(const char **p, CalendarSpec *c) {
556         CalendarComponent *h = NULL, *m = NULL, *s = NULL;
557         const char *t;
558         int r;
559
560         assert(p);
561         assert(*p);
562         assert(c);
563
564         t = *p;
565
566         if (*t == 0) {
567                 /* If no time is specified at all, but a date of some
568                  * kind, then this means 00:00:00 */
569                 if (c->day || c->weekdays_bits > 0)
570                         goto null_hour;
571
572                 goto finish;
573         }
574
575         r = parse_chain(&t, &h);
576         if (r < 0)
577                 goto fail;
578
579         if (*t != ':') {
580                 r = -EINVAL;
581                 goto fail;
582         }
583
584         t++;
585         r = parse_chain(&t, &m);
586         if (r < 0)
587                 goto fail;
588
589         /* Already at the end? Then it's hours and minutes, and seconds are 0 */
590         if (*t == 0) {
591                 if (m != NULL)
592                         goto null_second;
593
594                 goto finish;
595         }
596
597         if (*t != ':') {
598                 r = -EINVAL;
599                 goto fail;
600         }
601
602         t++;
603         r = parse_chain(&t, &s);
604         if (r < 0)
605                 goto fail;
606
607         /* At the end? Then it's hours, minutes and seconds */
608         if (*t == 0)
609                 goto finish;
610
611         r = -EINVAL;
612         goto fail;
613
614 null_hour:
615         r = const_chain(0, &h);
616         if (r < 0)
617                 goto fail;
618
619         r = const_chain(0, &m);
620         if (r < 0)
621                 goto fail;
622
623 null_second:
624         r = const_chain(0, &s);
625         if (r < 0)
626                 goto fail;
627
628 finish:
629         *p = t;
630         c->hour = h;
631         c->minute = m;
632         c->second = s;
633         return 0;
634
635 fail:
636         free_chain(h);
637         free_chain(m);
638         free_chain(s);
639         return r;
640 }
641
642 int calendar_spec_from_string(const char *p, CalendarSpec **spec) {
643         CalendarSpec *c;
644         int r;
645
646         assert(p);
647         assert(spec);
648
649         if (isempty(p))
650                 return -EINVAL;
651
652         c = new0(CalendarSpec, 1);
653         if (!c)
654                 return -ENOMEM;
655
656         if (strcaseeq(p, "hourly")) {
657                 r = const_chain(0, &c->minute);
658                 if (r < 0)
659                         goto fail;
660                 r = const_chain(0, &c->second);
661                 if (r < 0)
662                         goto fail;
663
664         } else if (strcaseeq(p, "daily")) {
665                 r = const_chain(0, &c->hour);
666                 if (r < 0)
667                         goto fail;
668                 r = const_chain(0, &c->minute);
669                 if (r < 0)
670                         goto fail;
671                 r = const_chain(0, &c->second);
672                 if (r < 0)
673                         goto fail;
674
675         } else if (strcaseeq(p, "monthly")) {
676                 r = const_chain(1, &c->day);
677                 if (r < 0)
678                         goto fail;
679                 r = const_chain(0, &c->hour);
680                 if (r < 0)
681                         goto fail;
682                 r = const_chain(0, &c->minute);
683                 if (r < 0)
684                         goto fail;
685                 r = const_chain(0, &c->second);
686                 if (r < 0)
687                         goto fail;
688
689         } else if (strcaseeq(p, "weekly")) {
690
691                 c->weekdays_bits = 1;
692
693                 r = const_chain(0, &c->hour);
694                 if (r < 0)
695                         goto fail;
696                 r = const_chain(0, &c->minute);
697                 if (r < 0)
698                         goto fail;
699                 r = const_chain(0, &c->second);
700                 if (r < 0)
701                         goto fail;
702
703         } else {
704                 r = parse_weekdays(&p, c);
705                 if (r < 0)
706                         goto fail;
707
708                 r = parse_date(&p, c);
709                 if (r < 0)
710                         goto fail;
711
712                 r = parse_time(&p, c);
713                 if (r < 0)
714                         goto fail;
715
716                 if (*p != 0) {
717                         r = -EINVAL;
718                         goto fail;
719                 }
720         }
721
722         r = calendar_spec_normalize(c);
723         if (r < 0)
724                 goto fail;
725
726         if (!calendar_spec_valid(c)) {
727                 r = -EINVAL;
728                 goto fail;
729         }
730
731         *spec = c;
732         return 0;
733
734 fail:
735         calendar_spec_free(c);
736         return r;
737 }
738
739 static int find_matching_component(const CalendarComponent *c, int *val) {
740         const CalendarComponent *n;
741         int d = -1;
742         bool d_set = false;
743         int r;
744
745         assert(val);
746
747         if (!c)
748                 return 0;
749
750         while (c) {
751                 n = c->next;
752
753                 if (c->value >= *val) {
754
755                         if (!d_set || c->value < d) {
756                                 d = c->value;
757                                 d_set = true;
758                         }
759
760                 } else if (c->repeat > 0) {
761                         int k;
762
763                         k = c->value + c->repeat * ((*val - c->value + c->repeat -1) / c->repeat);
764
765                         if (!d_set || k < d) {
766                                 d = k;
767                                 d_set = true;
768                         }
769                 }
770
771                 c = n;
772         }
773
774         if (!d_set)
775                 return -ENOENT;
776
777         r = *val != d;
778         *val = d;
779         return r;
780 }
781
782 static bool tm_out_of_bounds(const struct tm *tm) {
783         struct tm t;
784         assert(tm);
785
786         t = *tm;
787
788         if (mktime(&t) == (time_t) -1)
789                 return true;
790
791         /* Did any normalization take place? If so, it was out of bounds before */
792         return
793                 t.tm_year != tm->tm_year ||
794                 t.tm_mon != tm->tm_mon ||
795                 t.tm_mday != tm->tm_mday ||
796                 t.tm_hour != tm->tm_hour ||
797                 t.tm_min != tm->tm_min ||
798                 t.tm_sec != tm->tm_sec;
799 }
800
801 static bool matches_weekday(int weekdays_bits, const struct tm *tm) {
802         struct tm t;
803         int k;
804
805         if (weekdays_bits < 0 || weekdays_bits >= 127)
806                 return true;
807
808         t = *tm;
809         if (mktime(&t) == (time_t) -1)
810                 return false;
811
812         k = t.tm_wday == 0 ? 6 : t.tm_wday - 1;
813         return (weekdays_bits & (1 << k));
814 }
815
816 static int find_next(const CalendarSpec *spec, struct tm *tm) {
817         struct tm c;
818         int r;
819
820         assert(spec);
821         assert(tm);
822
823         c = *tm;
824
825         for (;;) {
826                 /* Normalize the current date */
827                 mktime(&c);
828                 c.tm_isdst = -1;
829
830                 c.tm_year += 1900;
831                 r = find_matching_component(spec->year, &c.tm_year);
832                 c.tm_year -= 1900;
833
834                 if (r > 0) {
835                         c.tm_mon = 0;
836                         c.tm_mday = 1;
837                         c.tm_hour = c.tm_min = c.tm_sec = 0;
838                 }
839                 if (r < 0 || tm_out_of_bounds(&c))
840                         return r;
841
842                 c.tm_mon += 1;
843                 r = find_matching_component(spec->month, &c.tm_mon);
844                 c.tm_mon -= 1;
845
846                 if (r > 0) {
847                         c.tm_mday = 1;
848                         c.tm_hour = c.tm_min = c.tm_sec = 0;
849                 }
850                 if (r < 0 || tm_out_of_bounds(&c)) {
851                         c.tm_year ++;
852                         c.tm_mon = 0;
853                         c.tm_mday = 1;
854                         c.tm_hour = c.tm_min = c.tm_sec = 0;
855                         continue;
856                 }
857
858                 r = find_matching_component(spec->day, &c.tm_mday);
859                 if (r > 0)
860                         c.tm_hour = c.tm_min = c.tm_sec = 0;
861                 if (r < 0 || tm_out_of_bounds(&c)) {
862                         c.tm_mon ++;
863                         c.tm_mday = 1;
864                         c.tm_hour = c.tm_min = c.tm_sec = 0;
865                         continue;
866                 }
867
868                 if (!matches_weekday(spec->weekdays_bits, &c)) {
869                         c.tm_mday++;
870                         c.tm_hour = c.tm_min = c.tm_sec = 0;
871                         continue;
872                 }
873
874                 r = find_matching_component(spec->hour, &c.tm_hour);
875                 if (r > 0)
876                         c.tm_min = c.tm_sec = 0;
877                 if (r < 0 || tm_out_of_bounds(&c)) {
878                         c.tm_mday ++;
879                         c.tm_hour = c.tm_min = c.tm_sec = 0;
880                         continue;
881                 }
882
883                 r = find_matching_component(spec->minute, &c.tm_min);
884                 if (r > 0)
885                         c.tm_sec = 0;
886                 if (r < 0 || tm_out_of_bounds(&c)) {
887                         c.tm_hour ++;
888                         c.tm_min = c.tm_sec = 0;
889                         continue;
890                 }
891
892                 r = find_matching_component(spec->second, &c.tm_sec);
893                 if (r < 0 || tm_out_of_bounds(&c)) {
894                         c.tm_min ++;
895                         c.tm_sec = 0;
896                         continue;
897                 }
898
899
900                 *tm = c;
901                 return 0;
902         }
903 }
904
905 int calendar_spec_next_usec(const CalendarSpec *spec, usec_t usec, usec_t *next) {
906         struct tm tm;
907         time_t t;
908         int r;
909
910         assert(spec);
911         assert(next);
912
913         t = (time_t) (usec / USEC_PER_SEC) + 1;
914         assert_se(localtime_r(&t, &tm));
915
916         r = find_next(spec, &tm);
917         if (r < 0)
918                 return r;
919
920         t = mktime(&tm);
921         if (t == (time_t) -1)
922                 return -EINVAL;
923
924
925         *next = (usec_t) t * USEC_PER_SEC;
926         return 0;
927 }