amxp_cron.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
#include <amxc/amxc.h>
#include <amxp/amxp_cron.h>
#include <amxc/amxc_macros.h>
#include "amxp_cron_parser_priv.h"

Go to the source code of this file.

Macros
#define	_GNU_SOURCE
#define	CRON_MAX_SECONDS   60
#define	CRON_MAX_MINUTES   60
#define	CRON_MAX_HOURS   24
#define	CRON_MAX_DAYS_OF_WEEK   8
#define	CRON_MAX_DAYS_OF_MONTH   32
#define	CRON_MAX_MONTHS   13
#define	CRON_CF_SECOND   0
#define	CRON_CF_MINUTE   1
#define	CRON_CF_HOUR_OF_DAY   2
#define	CRON_CF_DAY_OF_WEEK   3
#define	CRON_CF_DAY_OF_MONTH   4
#define	CRON_CF_MONTH   5
#define	CRON_CF_YEAR   6
#define	CRON_CF_ARR_LEN   7

Functions
static int32_t	amxp_cron_next_bit (const uint8_t *bits, int32_t from_index, int32_t to_index, bool forwards, bool *notfound)
static void	push_to_fields_arr (int *arr, int fi)
static int	last_day_of_month (int month, int year)
static int	amxp_cron_reset_min (struct tm *calendar, int field)
static int	amxp_cron_reset_max (struct tm *calendar, int field)
static int	amxp_cron_reset_all (struct tm *calendar, int *fields, bool minimum)
static int	amxp_cron_set_field (struct tm *calendar, int field, int val, bool add)
static uint32_t	amxp_cron_find_next (const uint8_t *bits, int32_t max, int32_t value, struct tm *calendar, uint32_t field, uint32_t next_field, int *lower_orders, bool forward, int *res_out)
static unsigned int	amxp_cron_find_next_day (struct tm *calendar, const uint8_t *days_of_month, unsigned int day_of_month, const uint8_t *days_of_week, unsigned int day_of_week, int *resets, bool forward, int *res_out)
static int	amxp_cron_calc_next (const amxp_cron_expr_t *expr, struct tm *calendar, unsigned int dot, bool forwards)
static void	amxp_cron_remove_spaces (amxc_string_t *result, const char *days_of_week)
int	amxp_cron_new (amxp_cron_expr_t **cron_expr)
	Allocates an amxp_cron_expr_t structures and initializes it to every second. More...
void	amxp_cron_delete (amxp_cron_expr_t **cron_expr)
	Frees the previously allocated amxp_cron_expr_t structure. More...
int	amxp_cron_init (amxp_cron_expr_t *cron_expr)
	Initializes an amxp_cron_expr_t structures to every second. More...
void	amxp_cron_clean (amxp_cron_expr_t *cron_expr)
	Resets the amxp_cron_expr_t structure to the initialized state. More...
int	amxp_cron_parse_expr (amxp_cron_expr_t *target, const char *expression, const char **error)
	Allocates and initializes an amxp_cron_expr_t structures and parses the given cron expression. More...
int	amxp_cron_build_weekly (amxp_cron_expr_t *target, const char *time, const char *days_of_week)
	Builds a weekly cron expression that is triggered at a certain time on certain days of the week. More...
int	amxp_cron_prev (const amxp_cron_expr_t *expr, const amxc_ts_t *ref, amxc_ts_t *next)
	Calculates the previous trigger time for a parsed cron expression. More...
int	amxp_cron_next (const amxp_cron_expr_t *expr, const amxc_ts_t *ref, amxc_ts_t *next)
	Calculates the next trigger time for a parsed cron expression. More...
int64_t	amxp_cron_time_until_next (const amxp_cron_expr_t *expr, bool local)
	Calculates the time in seconds until next trigger of a parsed cron expression occurs. More...

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE

Definition at line 56 of file amxp_cron.c.

CRON_CF_ARR_LEN

#define CRON_CF_ARR_LEN   7

Definition at line 87 of file amxp_cron.c.

CRON_CF_DAY_OF_MONTH

#define CRON_CF_DAY_OF_MONTH   4

Definition at line 83 of file amxp_cron.c.

CRON_CF_DAY_OF_WEEK

#define CRON_CF_DAY_OF_WEEK   3

Definition at line 82 of file amxp_cron.c.

CRON_CF_HOUR_OF_DAY

#define CRON_CF_HOUR_OF_DAY   2

Definition at line 81 of file amxp_cron.c.

CRON_CF_MINUTE

#define CRON_CF_MINUTE   1

Definition at line 80 of file amxp_cron.c.

CRON_CF_MONTH

#define CRON_CF_MONTH   5

Definition at line 84 of file amxp_cron.c.

CRON_CF_SECOND

#define CRON_CF_SECOND   0

Definition at line 79 of file amxp_cron.c.

CRON_CF_YEAR

#define CRON_CF_YEAR   6

Definition at line 85 of file amxp_cron.c.

CRON_MAX_DAYS_OF_MONTH

#define CRON_MAX_DAYS_OF_MONTH   32

Definition at line 76 of file amxp_cron.c.

CRON_MAX_DAYS_OF_WEEK

#define CRON_MAX_DAYS_OF_WEEK   8

Definition at line 75 of file amxp_cron.c.

CRON_MAX_HOURS

#define CRON_MAX_HOURS   24

Definition at line 74 of file amxp_cron.c.

CRON_MAX_MINUTES

#define CRON_MAX_MINUTES   60

Definition at line 73 of file amxp_cron.c.

CRON_MAX_MONTHS

#define CRON_MAX_MONTHS   13

Definition at line 77 of file amxp_cron.c.

CRON_MAX_SECONDS

#define CRON_MAX_SECONDS   60

Definition at line 72 of file amxp_cron.c.

Function Documentation

amxp_cron_calc_next()

static int amxp_cron_calc_next ( const amxp_cron_expr_t *  expr, struct tm *  calendar, unsigned int  dot, bool  forwards  )

static

Definition at line 333 of file amxp_cron.c.

                                                                                                                   {
    int i;
    int res = 0;
    int* resets = NULL;
    int* empty_list = NULL;
    unsigned int second = 0;
    unsigned int update_second = 0;
    unsigned int minute = 0;
    unsigned int update_minute = 0;
    unsigned int hour = 0;
    unsigned int update_hour = 0;
    unsigned int day_of_week = 0;
    unsigned int day_of_month = 0;
    unsigned int update_day_of_month = 0;
    unsigned int month = 0;
    unsigned int update_month = 0;
 
    resets = (int*) calloc(CRON_CF_ARR_LEN, sizeof(int));
    when_null(resets, return_result);
    empty_list = (int*) calloc(CRON_CF_ARR_LEN, sizeof(int));
    when_null(empty_list, return_result);
    for(i = 0; i < CRON_CF_ARR_LEN; i++) {
        resets[i] = -1;
        empty_list[i] = -1;
    }
 
    second = calendar->tm_sec;
    update_second = amxp_cron_find_next(expr->seconds, CRON_MAX_SECONDS, second, calendar,
                                        CRON_CF_SECOND, CRON_CF_MINUTE, empty_list, forwards, &res);
    when_failed(res, return_result);
    if(second == update_second) {
        push_to_fields_arr(resets, CRON_CF_SECOND);
    }
 
    minute = calendar->tm_min;
    update_minute = amxp_cron_find_next(expr->minutes, CRON_MAX_MINUTES, minute, calendar,
                                        CRON_CF_MINUTE, CRON_CF_HOUR_OF_DAY, resets, forwards, &res);
    when_failed(res, return_result);
    if(minute == update_minute) {
        push_to_fields_arr(resets, CRON_CF_MINUTE);
    } else {
        res = amxp_cron_calc_next(expr, calendar, dot, forwards);
        when_failed(res, return_result);
    }
 
    hour = calendar->tm_hour;
    update_hour = amxp_cron_find_next(expr->hours, CRON_MAX_HOURS, hour, calendar,
                                      CRON_CF_HOUR_OF_DAY, CRON_CF_DAY_OF_WEEK, resets, forwards, &res);
    when_failed(res, return_result);
    if(hour == update_hour) {
        push_to_fields_arr(resets, CRON_CF_HOUR_OF_DAY);
    } else {
        res = amxp_cron_calc_next(expr, calendar, dot, forwards);
        when_failed(res, return_result);
    }
 
    day_of_week = calendar->tm_wday;
    day_of_month = calendar->tm_mday;
    update_day_of_month = amxp_cron_find_next_day(calendar, expr->days_of_month, day_of_month,
                                                  expr->days_of_week, day_of_week, resets, forwards, &res);
    when_failed(res, return_result);
    if(day_of_month == update_day_of_month) {
        push_to_fields_arr(resets, CRON_CF_DAY_OF_MONTH);
    } else {
        res = amxp_cron_calc_next(expr, calendar, dot, forwards);
        when_failed(res, return_result);
    }
 
    month = calendar->tm_mon; /*day already adds one if no day in same month is found*/
    update_month = amxp_cron_find_next(expr->months, CRON_MAX_MONTHS, month, calendar,
                                       CRON_CF_MONTH, CRON_CF_YEAR, resets, forwards, &res);
    when_failed(res, return_result);
    if(month != update_month) {
        if(forwards) {
            when_true_status(calendar->tm_year - dot > 4, return_result, res = -1);
        } else {
            when_true_status(dot - calendar->tm_year > 4, return_result, res = -1);
        }
        res = amxp_cron_calc_next(expr, calendar, dot, forwards);
        when_failed(res, return_result);
    }
 
return_result:
    if((resets == NULL) || (empty_list == NULL)) {
        res = -1;
    }
    free(resets);
    free(empty_list);
    return res;
}

amxp_cron_find_next()

static uint32_t amxp_cron_find_next ( const uint8_t *  bits, int32_t  max, int32_t  value, struct tm *  calendar, uint32_t  field, uint32_t  next_field, int *  lower_orders, bool  forward, int *  res_out  )

static

Definition at line 262 of file amxp_cron.c.

                                                  {
    bool notfound = false;
    int err = 0;
    int32_t next_value = amxp_cron_next_bit(bits, value, forward? max:0, forward, &notfound);
 
    *res_out = 1;
 
    /* roll over if needed */
    if(notfound) {
        err = amxp_cron_set_field(calendar, next_field, forward? 1:-1, true);
        when_failed_status(err, exit, next_value = 0);
        if(forward) {
            err = amxp_cron_reset_min(calendar, field);
        } else {
            err = amxp_cron_reset_max(calendar, field);
        }
        when_failed_status(err, exit, next_value = 0);
        notfound = 0;
        next_value = amxp_cron_next_bit(bits, forward? 0:max - 1, forward? max:value, forward, &notfound);
    }
 
    if(notfound || (next_value != value)) {
        err = amxp_cron_set_field(calendar, field, next_value, false);
        when_failed_status(err, exit, next_value = 0);
        err = amxp_cron_reset_all(calendar, lower_orders, forward);
        when_failed_status(err, exit, next_value = 0);
    }
 
    *res_out = 0;
 
exit:
    return next_value;
}

amxp_cron_find_next_day()

static unsigned int amxp_cron_find_next_day ( struct tm *  calendar, const uint8_t *  days_of_month, unsigned int  day_of_month, const uint8_t *  days_of_week, unsigned int  day_of_week, int *  resets, bool  forward, int *  res_out  )

static

Definition at line 304 of file amxp_cron.c.

                                                          {
    int err;
    unsigned int count = 0;
    unsigned int max = 366;
 
    *res_out = 1;
    while((!cron_get_bit(days_of_month, day_of_month) ||
           !cron_get_bit(days_of_week, day_of_week)) &&
          count++ < max) {
        err = amxp_cron_set_field(calendar, CRON_CF_DAY_OF_MONTH, forward? 1:-1, true);
        when_failed(err, exit);
        day_of_month = calendar->tm_mday;
        day_of_week = calendar->tm_wday;
        amxp_cron_reset_all(calendar, resets, forward);
    }
 
    *res_out = 0;
 
exit:
    return day_of_month;
}

amxp_cron_next_bit()

static int32_t amxp_cron_next_bit ( const uint8_t *  bits, int32_t  from_index, int32_t  to_index, bool  forwards, bool *  notfound  )

static

Definition at line 89 of file amxp_cron.c.

                                                  {
    int32_t rv = 0;
 
    if(forwards) {
        for(int32_t i = from_index; i < to_index; i++) {
            if(cron_get_bit(bits, i)) {
                rv = i;
                goto exit;
            }
        }
    } else {
        for(int32_t i = from_index; i >= to_index; i--) {
            if(cron_get_bit(bits, i)) {
                rv = i;
                goto exit;
            }
        }
    }
 
    *notfound = true;
 
exit:
    return rv;
}

amxp_cron_remove_spaces()

static void amxp_cron_remove_spaces ( amxc_string_t *  result, const char *  days_of_week  )

static

Definition at line 424 of file amxp_cron.c.

                                                                                     {
    size_t pos = 0;
    amxc_string_set(result, days_of_week);
    amxc_string_trim(result, NULL);
 
    pos = amxc_string_text_length(result);
 
    while(pos > 0) {
        if(isspace(result->buffer[pos - 1]) != 0) {
            amxc_string_remove_at(result, pos - 1, 1);
            continue;
        }
        pos--;
    }
}

amxp_cron_reset_all()

static int amxp_cron_reset_all ( struct tm *  calendar, int *  fields, bool  minimum  )

static

Definition at line 210 of file amxp_cron.c.

                                                                               {
    int res = 0;
 
    for(int i = 0; i < CRON_CF_ARR_LEN; i++) {
        if(fields[i] != -1) {
            res = minimum? amxp_cron_reset_min(calendar, fields[i]):amxp_cron_reset_max(calendar, fields[i]);
            when_failed(res, exit);
        }
    }
 
exit:
    return res;
}

amxp_cron_reset_max()

static int amxp_cron_reset_max ( struct tm *  calendar, int  field  )

static

Definition at line 180 of file amxp_cron.c.

                                                               {
    int rv = 1;
    when_true(field == -1, exit);
 
    switch(field) {
    case CRON_CF_SECOND:
        calendar->tm_sec = 59;
        break;
    case CRON_CF_MINUTE:
        calendar->tm_min = 59;
        break;
    case CRON_CF_HOUR_OF_DAY:
        calendar->tm_hour = 23;
        break;
    case CRON_CF_DAY_OF_WEEK:
        calendar->tm_wday = 6;
        break;
    case CRON_CF_DAY_OF_MONTH:
        calendar->tm_mday = last_day_of_month(calendar->tm_mon, calendar->tm_year);
        break;
    case CRON_CF_MONTH:
        calendar->tm_mon = 11;
        break;
    }
    rv = timegm(calendar) == -1? 1:0;
 
exit:
    return rv;
}

amxp_cron_reset_min()

static int amxp_cron_reset_min ( struct tm *  calendar, int  field  )

static

Definition at line 147 of file amxp_cron.c.

                                                               {
    int rv = 1;
    when_true(field == -1, exit);
 
    switch(field) {
    case CRON_CF_SECOND:
        calendar->tm_sec = 0;
        break;
    case CRON_CF_MINUTE:
        calendar->tm_min = 0;
        break;
    case CRON_CF_HOUR_OF_DAY:
        calendar->tm_hour = 0;
        break;
    case CRON_CF_DAY_OF_WEEK:
        calendar->tm_wday = 0;
        break;
    case CRON_CF_DAY_OF_MONTH:
        calendar->tm_mday = 1;
        break;
    case CRON_CF_MONTH:
        calendar->tm_mon = 0;
        break;
    case CRON_CF_YEAR:
        calendar->tm_year = 0;
        break;
    }
    rv = timegm(calendar) == -1? 1:0;
 
exit:
    return rv;
}

amxp_cron_set_field()

static int amxp_cron_set_field ( struct tm *  calendar, int  field, int  val, bool  add  )

static

Definition at line 224 of file amxp_cron.c.

                                                                                  {
    int rv = 1;
    when_true(field == -1, exit);
 
    switch(field) {
    case CRON_CF_SECOND:
        calendar->tm_sec = add? calendar->tm_sec + val:val;
        break;
    case CRON_CF_MINUTE:
        calendar->tm_min = add? calendar->tm_min + val:val;
        break;
    case CRON_CF_HOUR_OF_DAY:
        calendar->tm_hour = add? calendar->tm_hour + val:val;
        break;
    case CRON_CF_DAY_OF_WEEK:
        if(add) {
            /* mkgmtime ignores this field */
            calendar->tm_mday = calendar->tm_mday + val;
        } else {
            calendar->tm_wday = val;
        }
        break;
    case CRON_CF_DAY_OF_MONTH:
        calendar->tm_mday = add? calendar->tm_mday + val:val;
        break;
    case CRON_CF_MONTH:
        calendar->tm_mon = add? calendar->tm_mon + val:val;
        break;
    case CRON_CF_YEAR:
        calendar->tm_year = add? calendar->tm_year + val:val;
        break;
    }
    rv = timegm(calendar) == -1? 1:0;
 
exit:
    return rv;
}

last_day_of_month()

static int last_day_of_month ( int  month, int  year  )

static

Definition at line 135 of file amxp_cron.c.

                                                  {
    struct tm cal;
    struct tm* calctm = NULL;
    time_t t;
    memset(&cal, 0, sizeof(cal));
    cal.tm_mon = month + 1;
    cal.tm_year = year;
    t = mktime(&cal);
    calctm = gmtime(&t);
    return calctm != NULL? calctm->tm_mday:31;
}

push_to_fields_arr()

static void push_to_fields_arr ( int *  arr, int  fi  )

static

Definition at line 118 of file amxp_cron.c.

                                                 {
    when_true(arr == NULL || fi == -1, exit);
 
    for(int i = 0; i < CRON_CF_ARR_LEN; i++) {
        when_true(arr[i] == fi, exit);
    }
    for(int i = 0; i < CRON_CF_ARR_LEN; i++) {
        if(arr[i] == -1) {
            arr[i] = fi;
            break;
        }
    }
 
exit:
    return;
}