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