mirror of https://github.com/pygos/cron
David Oberhollenzer
3 years ago
commit
d2b3a983e1
15 changed files with 992 additions and 0 deletions
@ -0,0 +1,15 @@ |
|||
*.o |
|||
.deps |
|||
.dirstamp |
|||
Makefile |
|||
Makefile.in |
|||
config.* |
|||
aclocal.m4 |
|||
autom4te.cache/ |
|||
compile |
|||
configure |
|||
depcomp |
|||
install-sh |
|||
missing |
|||
stamp-h1 |
|||
gcrond |
|||
@ -0,0 +1,13 @@ |
|||
Copyright (c) 2018 David Oberhollenzer <david.oberhollenzer@tele2.at> |
|||
|
|||
Permission to use, copy, modify, and distribute this software for any |
|||
purpose with or without fee is hereby granted, provided that the above |
|||
copyright notice and this permission notice appear in all copies. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|||
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
|||
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|||
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
|||
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
|||
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|||
@ -0,0 +1,13 @@ |
|||
ACLOCAL_AMFLAGS = -I m4 |
|||
|
|||
AM_CPPFLAGS = -D_GNU_SOURCE |
|||
AM_CFLAGS = $(WARN_CFLAGS) |
|||
|
|||
sbin_PROGRAMS = gcrond |
|||
|
|||
gcrond_SOURCES = gcrond.c gcrond.h rdcron.c crontab.c cronscan.c rdline.c |
|||
|
|||
crontabdir = @GCRONDIR@ |
|||
crontab_DATA = crontab/0-example |
|||
|
|||
EXTRA_DIST = crontab/0-example LICENSE README.md |
|||
@ -0,0 +1,122 @@ |
|||
# About |
|||
|
|||
This package contains a small cron implementation called `gcrond`. |
|||
|
|||
It was written due to a perceived lack of a proper, simple cron |
|||
implementation. All other cron implementation I came across were either decade |
|||
old, abandoned pieces of horror ("Cool, I didn't even know that C syntax |
|||
allows this!") or hopelessly integrated into other, much larger projects (e.g. |
|||
absorbed by SystemD or in the case of OpenBSD cron, married to special OpenBSD |
|||
syscalls). |
|||
|
|||
It was a fun little exercise and it seems to work so far. No idea about |
|||
standards compliance tough, the implementation was mostly written against |
|||
the Wikipedia article about Cron. |
|||
|
|||
## License |
|||
|
|||
The source code in this package is provided under the OpenBSD flavored ISC |
|||
license. So you can practically do as you wish, as long as you retain the |
|||
original copyright notice. The software is provided "as is" (as usual) with |
|||
no warranty whatsoever (e.g. it might actually do what it was designed for, |
|||
but it could just as well set your carpet on fire). |
|||
|
|||
The sub directory `m4` contains third party macro files used by the build |
|||
system which may be subject to their own, respective licenses. |
|||
|
|||
|
|||
## Portability |
|||
|
|||
The program in this package has been written for and tested on a GNU/Linux |
|||
system, so there may be some GNU-isms in there in addition to Linux specific |
|||
code. Depending on your target platform, some minor porting effort may be |
|||
required. |
|||
|
|||
|
|||
# Building and installing |
|||
|
|||
This package uses autotools. If you downloaded a distribution tar ball, simply |
|||
run the `configure` script and then `make` after the Makefile has been |
|||
generated. A list of possible `configure` options can be viewed by running |
|||
`configure --help`. |
|||
|
|||
If you really wish to do so, run `make install` to install the program on your |
|||
system. |
|||
|
|||
When working with the git tree, run the `autogen.sh` script to generate the |
|||
configure script and friends. |
|||
|
|||
|
|||
# Crontab File Format |
|||
|
|||
The cron daemon reads its configuration from all files it can find |
|||
in `/etc/crontab.d/` (exact path can be configured). |
|||
|
|||
The files are read line by line. Empty lines or lines starting with '#' are |
|||
skipped. |
|||
|
|||
Each non-empty line consists of the typical cron fields: |
|||
|
|||
1. The `minute` field. Legal values are from 0 to 59. |
|||
2. The `hour` field. Legal values are from 0 to 23. |
|||
3. The `day of month` field. Legal values are from 1 to 31 (or fewer, depending |
|||
on the month. |
|||
4. The `month` field. Legal values are from 1 to 12 (January to December) |
|||
or the mnemonics `JAN`, `FEB`, `MAR`, `APR`, ... |
|||
5. The `day of week` field. Legal values are from 0 to 6 (Sunday to Saturday) |
|||
or the mnemonics `SUN`, `MON`, `TUE`, `WED`, ... |
|||
6. The command to execute. |
|||
|
|||
|
|||
The fields are separated by spaces. For the time matching fields, multiple |
|||
comma separated values can be specified (e.g. `MON,WED,FRI` for a job that |
|||
should run on Mondays, Wednesdays and Fridays). |
|||
|
|||
The wild-card character `*` matches any legal value. An stepping can be |
|||
specified by appending `/` and then a stepping (e.g. for the minute field, |
|||
`*/5` would let a job run every five minutes). |
|||
|
|||
A range of values can also be specified as `<lower>-<upper>`, for instance |
|||
`MON-FRI` would match every day from Monday to Friday (equivalent to `1-5`). |
|||
|
|||
Intervals and specific values can be combined, for instance a day of month |
|||
field `*/7,13,25` would trigger once a week, starting from the first of the |
|||
month (1,7,14,21,28), but additionally include the 13th and the 25th. The |
|||
same could be expressed as `1-31/7,13,25`. |
|||
|
|||
|
|||
Instead of specifying a terse cron matching expression, the first five fields |
|||
can be replaced with one of the following mnemonics: |
|||
|
|||
- `@yearly` or `@anually` is equivalent to `0 0 1 1 *`, i.e. 1st of January |
|||
at midnight |
|||
- `@monthly` is equivalent to `0 0 1 * *`, i.e. 1st of every month at midnight |
|||
- `@weekly` is equivalent to `0 0 * * 0`, i.e. every Sunday at midnight |
|||
- `@daily` is equivalent to `0 0 * * *`, i.e. every day at midnight |
|||
- `@hourly` is equivalent to `0 * * * *`, i.e. every first minute of the hour |
|||
|
|||
Lastly, the command field is not broken down but passed to `/bin/sh -c` |
|||
*as is*. |
|||
|
|||
|
|||
# Security Considerations |
|||
|
|||
The cron daemon currently has no means of specifying a user to run the jobs as, |
|||
so if cron runs as root, the jobs it starts do as well. Since by default it |
|||
reads its configuration from `/etc` which by default is only writable by root, |
|||
this shouldn't be too much of a problem when using cron for typical system |
|||
administration tasks. |
|||
|
|||
If a job should run as another user, tools such as `su`, `runuser`, `setpriv` |
|||
et cetera need to be used. |
|||
|
|||
# Possible Future Directions |
|||
|
|||
The following things would be nice to have: |
|||
|
|||
- decent logging for cron and the output of the jobs. |
|||
- cron jobs per user, e.g. scan `~/.crontab.d` or similar and run the collected |
|||
jobs as the respective user. |
|||
- timezone handling |
|||
- some usable strategy for handling time jumps, e.g. caused by a job that |
|||
syncs time with an NTP server on a system without RTC. |
|||
@ -0,0 +1,3 @@ |
|||
#!/bin/sh |
|||
|
|||
autoreconf --force --install --symlink |
|||
@ -0,0 +1,38 @@ |
|||
AC_PREREQ([2.60]) |
|||
|
|||
AC_INIT([gcron], [0.1], [david.oberhollenzer@tele2.at], gcron) |
|||
AC_CONFIG_MACRO_DIR([m4]) |
|||
AM_INIT_AUTOMAKE([foreign subdir-objects dist-xz]) |
|||
AM_SILENT_RULES([yes]) |
|||
AC_PROG_CC |
|||
AC_PROG_CC_C99 |
|||
AC_PROG_INSTALL |
|||
AC_PROG_RANLIB |
|||
|
|||
UL_WARN_ADD([-Wall]) |
|||
UL_WARN_ADD([-Wextra]) |
|||
UL_WARN_ADD([-Wunused]) |
|||
UL_WARN_ADD([-Wmissing-prototypes]) |
|||
UL_WARN_ADD([-Wmissing-declarations]) |
|||
UL_WARN_ADD([-Wwrite-strings]) |
|||
UL_WARN_ADD([-Wjump-misses-init]) |
|||
UL_WARN_ADD([-Wuninitialized]) |
|||
UL_WARN_ADD([-Winit-self]) |
|||
UL_WARN_ADD([-Wlogical-op]) |
|||
UL_WARN_ADD([-Wunused-but-set-parameter]) |
|||
UL_WARN_ADD([-Wunused-but-set-variable]) |
|||
UL_WARN_ADD([-Wunused-parameter]) |
|||
UL_WARN_ADD([-Wunused-result]) |
|||
UL_WARN_ADD([-Wunused-variable]) |
|||
UL_WARN_ADD([-Wduplicated-cond]) |
|||
UL_WARN_ADD([-Wduplicated-branches]) |
|||
UL_WARN_ADD([-Wrestrict]) |
|||
UL_WARN_ADD([-Wnull-dereference]) |
|||
UL_WARN_ADD([-pedantic]) |
|||
|
|||
AC_SUBST([WARN_CFLAGS]) |
|||
|
|||
AC_CONFIG_HEADERS([config.h]) |
|||
AC_DEFINE_DIR(GCRONDIR, sysconfdir/crontab.d, [crontab source directory]) |
|||
|
|||
AC_OUTPUT([Makefile]) |
|||
@ -0,0 +1,56 @@ |
|||
/* SPDX-License-Identifier: ISC */ |
|||
#include "gcrond.h" |
|||
|
|||
int cronscan(const char *directory, crontab_t **list) |
|||
{ |
|||
crontab_t *cron, *tail = NULL; |
|||
struct dirent *ent; |
|||
int dfd, ret = 0; |
|||
DIR *dir; |
|||
|
|||
dir = opendir(directory); |
|||
if (dir == NULL) { |
|||
perror(directory); |
|||
return -1; |
|||
} |
|||
|
|||
dfd = dirfd(dir); |
|||
if (dfd < 0) { |
|||
perror(directory); |
|||
closedir(dir); |
|||
return -1; |
|||
} |
|||
|
|||
for (;;) { |
|||
errno = 0; |
|||
ent = readdir(dir); |
|||
|
|||
if (ent == NULL) { |
|||
if (errno != 0) { |
|||
perror(directory); |
|||
ret = -1; |
|||
} |
|||
break; |
|||
} |
|||
|
|||
if (!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, "..")) |
|||
continue; |
|||
|
|||
cron = rdcron(dfd, ent->d_name); |
|||
if (cron == NULL) |
|||
continue; |
|||
|
|||
if (tail == NULL) { |
|||
*list = cron; |
|||
tail = cron; |
|||
} else { |
|||
tail->next = cron; |
|||
} |
|||
|
|||
while (tail->next != NULL) |
|||
tail = tail->next; |
|||
} |
|||
|
|||
closedir(dir); |
|||
return ret; |
|||
} |
|||
@ -0,0 +1,61 @@ |
|||
/* SPDX-License-Identifier: ISC */ |
|||
#include "gcrond.h" |
|||
|
|||
void cron_tm_to_mask(crontab_t *out, struct tm *t) |
|||
{ |
|||
memset(out, 0, sizeof(*out)); |
|||
out->minute = 1UL << ((unsigned long)t->tm_min); |
|||
out->hour = 1 << t->tm_hour; |
|||
out->dayofmonth = 1 << (t->tm_mday - 1); |
|||
out->month = 1 << t->tm_mon; |
|||
out->dayofweek = 1 << t->tm_wday; |
|||
} |
|||
|
|||
bool cron_should_run(const crontab_t *t, const crontab_t *mask) |
|||
{ |
|||
if ((t->minute & mask->minute) == 0) |
|||
return false; |
|||
|
|||
if ((t->hour & mask->hour) == 0) |
|||
return false; |
|||
|
|||
if ((t->dayofmonth & mask->dayofmonth) == 0) |
|||
return false; |
|||
|
|||
if ((t->month & mask->month) == 0) |
|||
return false; |
|||
|
|||
if ((t->dayofweek & mask->dayofweek) == 0) |
|||
return false; |
|||
|
|||
return true; |
|||
} |
|||
|
|||
void delcron(crontab_t *cron) |
|||
{ |
|||
if (cron != NULL) { |
|||
free(cron->exec); |
|||
free(cron); |
|||
} |
|||
} |
|||
|
|||
int runjob(crontab_t *tab) |
|||
{ |
|||
pid_t pid; |
|||
|
|||
if (tab->exec == NULL) |
|||
return 0; |
|||
|
|||
pid = fork(); |
|||
if (pid == -1) { |
|||
perror("fork"); |
|||
return -1; |
|||
} |
|||
|
|||
if (pid != 0) |
|||
return 0; |
|||
|
|||
execl("/bin/sh", "sh", "-c", tab->exec, (char *) 0); |
|||
perror("runnig shell interpreter"); |
|||
exit(EXIT_FAILURE); |
|||
} |
|||
@ -0,0 +1,7 @@ |
|||
# +-------- minute (0 - 59) |
|||
# | +------ hour (0 - 23) |
|||
# | | +---- day of month (1 - 31) |
|||
# | | | +-- month (1 - 12) |
|||
# | | | | +-- day of week (0 - 6) |
|||
# | | | | | |
|||
# * * * * * command to execute |
|||
@ -0,0 +1,128 @@ |
|||
/* SPDX-License-Identifier: ISC */ |
|||
#include "gcrond.h" |
|||
|
|||
static crontab_t *jobs; |
|||
static sig_atomic_t run = 1; |
|||
static sig_atomic_t rescan = 1; |
|||
|
|||
static void read_config(void) |
|||
{ |
|||
if (cronscan(GCRONDIR, &jobs)) { |
|||
fputs("Error reading configuration. Continuing anyway.\n", |
|||
stderr); |
|||
} |
|||
} |
|||
|
|||
static void cleanup_config(void) |
|||
{ |
|||
crontab_t *t; |
|||
|
|||
while (jobs != NULL) { |
|||
t = jobs; |
|||
jobs = jobs->next; |
|||
delcron(t); |
|||
} |
|||
} |
|||
|
|||
static int timeout_minutes(int minutes) |
|||
{ |
|||
time_t now = time(NULL); |
|||
struct tm t; |
|||
|
|||
localtime_r(&now, &t); |
|||
return minutes * 60 + 30 - t.tm_sec; |
|||
} |
|||
|
|||
static int calc_timeout(void) |
|||
{ |
|||
time_t now = time(NULL), future; |
|||
struct tm tmstruct; |
|||
crontab_t mask, *t; |
|||
int minutes; |
|||
|
|||
for (minutes = 0; minutes < 120; ++minutes) { |
|||
future = now + minutes * 60; |
|||
|
|||
localtime_r(&future, &tmstruct); |
|||
cron_tm_to_mask(&mask, &tmstruct); |
|||
|
|||
for (t = jobs; t != NULL; t = t->next) { |
|||
if (cron_should_run(t, &mask)) |
|||
goto out; |
|||
} |
|||
} |
|||
out: |
|||
return timeout_minutes(minutes ? minutes : 1); |
|||
} |
|||
|
|||
static void runjobs(void) |
|||
{ |
|||
time_t now = time(NULL); |
|||
struct tm tmstruct; |
|||
crontab_t mask, *t; |
|||
|
|||
localtime_r(&now, &tmstruct); |
|||
cron_tm_to_mask(&mask, &tmstruct); |
|||
|
|||
for (t = jobs; t != NULL; t = t->next) { |
|||
if (cron_should_run(t, &mask)) |
|||
runjob(t); |
|||
} |
|||
} |
|||
|
|||
static void sighandler(int signo) |
|||
{ |
|||
pid_t pid; |
|||
|
|||
switch (signo) { |
|||
case SIGINT: |
|||
case SIGTERM: |
|||
run = 0; |
|||
break; |
|||
case SIGHUP: |
|||
rescan = 1; |
|||
break; |
|||
case SIGCHLD: |
|||
while ((pid = waitpid(-1, NULL, WNOHANG)) != -1) |
|||
; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
int main(void) |
|||
{ |
|||
struct timespec stime; |
|||
struct sigaction act; |
|||
int timeout; |
|||
|
|||
memset(&act, 0, sizeof(act)); |
|||
act.sa_handler = sighandler; |
|||
sigaction(SIGINT, &act, NULL); |
|||
sigaction(SIGTERM, &act, NULL); |
|||
sigaction(SIGHUP, &act, NULL); |
|||
sigaction(SIGCHLD, &act, NULL); |
|||
|
|||
while (run) { |
|||
if (rescan == 1) { |
|||
cleanup_config(); |
|||
read_config(); |
|||
timeout = timeout_minutes(1); |
|||
rescan = 0; |
|||
} else { |
|||
runjobs(); |
|||
timeout = calc_timeout(); |
|||
} |
|||
|
|||
stime.tv_sec = timeout; |
|||
stime.tv_nsec = 0; |
|||
|
|||
while (nanosleep(&stime, &stime) != 0 && run && !rescan) { |
|||
if (errno != EINTR) { |
|||
perror("nanosleep"); |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
|
|||
return EXIT_SUCCESS; |
|||
} |
|||
@ -0,0 +1,66 @@ |
|||
/* SPDX-License-Identifier: ISC */ |
|||
#ifndef GCROND_H |
|||
#define GCROND_H |
|||
|
|||
#include <sys/types.h> |
|||
#include <sys/stat.h> |
|||
#include <sys/wait.h> |
|||
#include <stdbool.h> |
|||
#include <stddef.h> |
|||
#include <string.h> |
|||
#include <stdlib.h> |
|||
#include <stdint.h> |
|||
#include <unistd.h> |
|||
#include <limits.h> |
|||
#include <signal.h> |
|||
#include <dirent.h> |
|||
#include <stdarg.h> |
|||
#include <ctype.h> |
|||
#include <stdio.h> |
|||
#include <errno.h> |
|||
#include <fcntl.h> |
|||
#include <time.h> |
|||
|
|||
#include "config.h" |
|||
|
|||
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) |
|||
|
|||
typedef struct crontab_t { |
|||
struct crontab_t *next; |
|||
char *exec; |
|||
|
|||
uint64_t minute; |
|||
uint32_t hour; |
|||
uint32_t dayofmonth; |
|||
uint16_t month; |
|||
uint8_t dayofweek; |
|||
} crontab_t; |
|||
|
|||
typedef struct { |
|||
const char *filename; /* input file name */ |
|||
size_t lineno; /* current line number */ |
|||
FILE *fp; |
|||
char *line; |
|||
} rdline_t; |
|||
|
|||
int rdline_init(rdline_t *t, int dirfd, const char *filename); |
|||
|
|||
void rdline_complain(rdline_t *t, const char *msg, ...); |
|||
|
|||
void rdline_cleanup(rdline_t *t); |
|||
|
|||
int rdline(rdline_t *t); |
|||
|
|||
crontab_t *rdcron(int dirfd, const char *filename); |
|||
|
|||
void delcron(crontab_t *cron); |
|||
|
|||
int cronscan(const char *directory, crontab_t **list); |
|||
|
|||
void cron_tm_to_mask(crontab_t *out, struct tm *t); |
|||
|
|||
bool cron_should_run(const crontab_t *t, const crontab_t *mask); |
|||
|
|||
int runjob(crontab_t *tab); |
|||
|
|||
#endif /* GCROND_H */ |
|||
@ -0,0 +1,35 @@ |
|||
dnl @synopsis AC_DEFINE_DIR(VARNAME, DIR [, DESCRIPTION]) |
|||
dnl |
|||
dnl This macro sets VARNAME to the expansion of the DIR variable, |
|||
dnl taking care of fixing up ${prefix} and such. |
|||
dnl |
|||
dnl VARNAME is then offered as both an output variable and a C |
|||
dnl preprocessor symbol. |
|||
dnl |
|||
dnl Example: |
|||
dnl |
|||
dnl AC_DEFINE_DIR([DATADIR], [datadir], [Where data are placed to.]) |
|||
dnl |
|||
dnl @category Misc |
|||
dnl @author Stepan Kasal <kasal@ucw.cz> |
|||
dnl @author Andreas Schwab <schwab@suse.de> |
|||
dnl @author Guido U. Draheim <guidod@gmx.de> |
|||
dnl @author Alexandre Oliva |
|||
dnl @version 2006-10-13 |
|||
dnl @license AllPermissive |
|||
|
|||
AC_DEFUN([AC_DEFINE_DIR], [ |
|||
prefix_NONE= |
|||
exec_prefix_NONE= |
|||
test "x$prefix" = xNONE && prefix_NONE=yes && prefix=$ac_default_prefix |
|||
test "x$exec_prefix" = xNONE && exec_prefix_NONE=yes && exec_prefix=$prefix |
|||
dnl In Autoconf 2.60, ${datadir} refers to ${datarootdir}, which in turn |
|||
dnl refers to ${prefix}. Thus we have to use `eval' twice. |
|||
eval ac_define_dir="\"[$]$2\"" |
|||
eval ac_define_dir="\"$ac_define_dir\"" |
|||
AC_SUBST($1, "$ac_define_dir") |
|||
AC_DEFINE_UNQUOTED($1, "$ac_define_dir", [$3]) |
|||
test "$prefix_NONE" && prefix=NONE |
|||
test "$exec_prefix_NONE" && exec_prefix=NONE |
|||
]) |
|||
|
|||
@ -0,0 +1,40 @@ |
|||
dnl Copyright (C) 2008-2011 Free Software Foundation, Inc. |
|||
dnl This file is free software; the Free Software Foundation |
|||
dnl gives unlimited permission to copy and/or distribute it, |
|||
dnl with or without modifications, as long as this notice is preserved. |
|||
|
|||
dnl From Simon Josefsson |
|||
dnl -- derivated from coreutils m4/warnings.m4 |
|||
|
|||
# UL_AS_VAR_APPEND(VAR, VALUE) |
|||
# ---------------------------- |
|||
# Provide the functionality of AS_VAR_APPEND if Autoconf does not have it. |
|||
m4_ifdef([AS_VAR_APPEND], |
|||
[m4_copy([AS_VAR_APPEND], [UL_AS_VAR_APPEND])], |
|||
[m4_define([UL_AS_VAR_APPEND], |
|||
[AS_VAR_SET([$1], [AS_VAR_GET([$1])$2])])]) |
|||
|
|||
# UL_ADD_WARN(COMPILER_OPTION [, VARNAME]) |
|||
# ------------------------ |
|||
# Adds parameter to WARN_CFLAGS (or to $VARNAME) if the compiler supports it. |
|||
AC_DEFUN([UL_WARN_ADD], [ |
|||
m4_define([warnvarname], m4_default([$2],WARN_CFLAGS)) |
|||
AS_VAR_PUSHDEF([ul_Warn], [ul_cv_warn_$1])dnl |
|||
AC_CACHE_CHECK([whether compiler handles $1], m4_defn([ul_Warn]), [ |
|||
# store AC_LANG_WERROR status, then turn it on |
|||
save_ac_[]_AC_LANG_ABBREV[]_werror_flag="${ac_[]_AC_LANG_ABBREV[]_werror_flag}" |
|||
AC_LANG_WERROR |
|||
|
|||
ul_save_CPPFLAGS="$CPPFLAGS" |
|||
CPPFLAGS="-Werror ${CPPFLAGS} $1" |
|||
AC_PREPROC_IFELSE([AC_LANG_PROGRAM([])], |
|||
[AS_VAR_SET(ul_Warn, [yes])], |
|||
[AS_VAR_SET(ul_Warn, [no])]) |
|||
# restore AC_LANG_WERROR |
|||
ac_[]_AC_LANG_ABBREV[]_werror_flag="${save_ac_[]_AC_LANG_ABBREV[]_werror_flag}" |
|||
|
|||
CPPFLAGS="$ul_save_CPPFLAGS" |
|||
]) |
|||
AS_VAR_IF(ul_Warn, [yes], [UL_AS_VAR_APPEND(warnvarname, [" $1"])]) |
|||
]) |
|||
|
|||
@ -0,0 +1,318 @@ |
|||
/* SPDX-License-Identifier: ISC */ |
|||
#include "gcrond.h" |
|||
|
|||
typedef struct { |
|||
const char *name; |
|||
int value; |
|||
} enum_map_t; |
|||
|
|||
static const enum_map_t weekday[] = { |
|||
{ "MON", 1 }, |
|||
{ "TUE", 2 }, |
|||
{ "WED", 3 }, |
|||
{ "THU", 4 }, |
|||
{ "FRI", 5 }, |
|||
{ "SAT", 6 }, |
|||
{ "SUN", 0 }, |
|||
{ NULL, 0 }, |
|||
}; |
|||
|
|||
static const enum_map_t month[] = { |
|||
{ "JAN", 1 }, |
|||
{ "FEB", 2 }, |
|||
{ "MAR", 3 }, |
|||
{ "APR", 4 }, |
|||
{ "MAY", 5 }, |
|||
{ "JUN", 6 }, |
|||
{ "JUL", 7 }, |
|||
{ "AUG", 8 }, |
|||
{ "SEP", 9 }, |
|||
{ "OCT", 10 }, |
|||
{ "NOV", 11 }, |
|||
{ "DEC", 12 }, |
|||
{ NULL, 0 }, |
|||
}; |
|||
|
|||
static const struct { |
|||
const char *macro; |
|||
crontab_t tab; |
|||
} intervals[] = { |
|||
{ |
|||
.macro = "yearly", |
|||
.tab = { |
|||
.minute = 0x01, |
|||
.hour = 0x01, |
|||
.dayofmonth = 0x01, |
|||
.month = 0x01, |
|||
.dayofweek = 0xFF |
|||
}, |
|||
}, { |
|||
.macro = "annually", |
|||
.tab = { |
|||
.minute = 0x01, |
|||
.hour = 0x01, |
|||
.dayofmonth = 0x01, |
|||
.month = 0x01, |
|||
.dayofweek = 0xFF |
|||
}, |
|||
}, { |
|||
.macro = "monthly", |
|||
.tab = { |
|||
.minute = 0x01, |
|||
.hour = 0x01, |
|||
.dayofmonth = 0x01, |
|||
.month = 0xFFFF, |
|||
.dayofweek = 0xFF |
|||
}, |
|||
}, { |
|||
.macro = "weekly", |
|||
.tab = { |
|||
.minute = 0x01, |
|||
.hour = 0x01, |
|||
.dayofmonth = 0xFFFFFFFF, |
|||
.month = 0xFFFF, |
|||
.dayofweek = 0x01 |
|||
}, |
|||
}, { |
|||
.macro = "daily", |
|||
.tab = { |
|||
.minute = 0x01, |
|||
.hour = 0x01, |
|||
.dayofmonth = 0xFFFFFFFF, |
|||
.month = 0xFFFF, |
|||
.dayofweek = 0xFF |
|||
}, |
|||
}, { |
|||
.macro = "hourly", |
|||
.tab = { |
|||
.minute = 0x01, |
|||
.hour = 0xFFFFFFFF, |
|||
.dayofmonth = 0xFFFFFFFF, |
|||
.month = 0xFFFF, |
|||
.dayofweek = 0xFF |
|||
}, |
|||
}, |
|||
}; |
|||
|
|||
/*****************************************************************************/ |
|||
|
|||
static char *readnum(char *line, int *out, int minval, int maxval, |
|||
const enum_map_t *mnemonic, rdline_t *rd) |
|||
{ |
|||
int i, temp, value = 0; |
|||
const enum_map_t *ev; |
|||
|
|||
if (!isdigit(*line)) { |
|||
if (!mnemonic) |
|||
goto fail_mn; |
|||
|
|||
for (i = 0; isalnum(line[i]); ++i) |
|||
; |
|||
if (i == 0) |
|||
goto fail_mn; |
|||
|
|||
temp = line[i]; |
|||
line[i] = '\0'; |
|||
|
|||
for (ev = mnemonic; ev->name != NULL; ++ev) { |
|||
if (!strcmp(line, mnemonic->name) == 0) |
|||
break; |
|||
} |
|||
|
|||
if (ev->name == NULL) { |
|||
rdline_complain(rd, "unexpected '%s'", line); |
|||
return NULL; |
|||
} |
|||
line[i] = temp; |
|||
*out = ev->value; |
|||
return line + i; |
|||
} |
|||
|
|||
while (isdigit(*line)) { |
|||
i = ((*(line++)) - '0'); |
|||
if (value > (maxval - i) / 10) |
|||
goto fail_of; |
|||
value = value * 10 + i; |
|||
} |
|||
|
|||
if (value < minval) |
|||
goto fail_uf; |
|||
|
|||
*out = value; |
|||
return line; |
|||
fail_of: |
|||
rdline_complain(rd, "value exceeds maximum (%d > %d)", value, maxval); |
|||
return NULL; |
|||
fail_uf: |
|||
rdline_complain(rd, "value too small (%d < %d)", value, minval); |
|||
return NULL; |
|||
fail_mn: |
|||
rdline_complain(rd, "expected numeric value"); |
|||
return NULL; |
|||
} |
|||
|
|||
static char *readfield(char *line, uint64_t *out, int minval, int maxval, |
|||
const enum_map_t *mnemonic, rdline_t *rd) |
|||
{ |
|||
int value, endvalue, step; |
|||
uint64_t v = 0; |
|||
next: |
|||
if (*line == '*') { |
|||
++line; |
|||
value = minval; |
|||
endvalue = maxval; |
|||
} else { |
|||
line = readnum(line, &value, minval, maxval, mnemonic, rd); |
|||
if (!line) |
|||
goto fail; |
|||
|
|||
if (*line == '-') { |
|||
line = readnum(line + 1, &endvalue, minval, maxval, |
|||
mnemonic, rd); |
|||
if (!line) |
|||
goto fail; |
|||
} else { |
|||
endvalue = value; |
|||
} |
|||
|
|||
if (endvalue < value) |
|||
goto fail; |
|||
} |
|||
|
|||
if (*line == '/') { |
|||
line = readnum(line + 1, &step, 1, maxval + 1, NULL, rd); |
|||
if (!line) |
|||
goto fail; |
|||
} else { |
|||
step = 1; |
|||
} |
|||
|
|||
while (value <= endvalue) { |
|||
v |= 1UL << (unsigned long)(value - minval); |
|||
value += step; |
|||
} |
|||
|
|||
if (*line == ',') { |
|||
++line; |
|||
goto next; |
|||
} |
|||
|
|||
if (*line != '\0' && !isspace(*line)) |
|||
goto fail; |
|||
while (isspace(*line)) |
|||
++line; |
|||
|
|||
*out = v; |
|||
return line; |
|||
fail: |
|||
rdline_complain(rd, "invalid time range expression"); |
|||
return NULL; |
|||
} |
|||
|
|||
/*****************************************************************************/ |
|||
|
|||
static char *cron_interval(crontab_t *cron, rdline_t *rd) |
|||
{ |
|||
char *arg = rd->line; |
|||
size_t i, j; |
|||
|
|||
if (*(arg++) != '@') |
|||
goto fail; |
|||
for (j = 0; isalpha(arg[j]); ++j) |
|||
; |
|||
if (j == 0 || !isspace(arg[j])) |
|||
goto fail; |
|||
|
|||
for (i = 0; i < ARRAY_SIZE(intervals); ++i) { |
|||
if (strlen(intervals[i].macro) != j) |
|||
continue; |
|||
if (strncmp(intervals[i].macro, arg, j) == 0) |
|||
break; |
|||
} |
|||
|
|||
if (i == ARRAY_SIZE(intervals)) |
|||
goto fail; |
|||
|
|||
cron->minute = intervals[i].tab.minute; |
|||
cron->hour = intervals[i].tab.hour; |
|||
cron->dayofmonth = intervals[i].tab.dayofmonth; |
|||
cron->month = intervals[i].tab.month; |
|||
cron->dayofweek = intervals[i].tab.dayofweek; |
|||
return arg + j; |
|||
fail: |
|||
rdline_complain(rd, "unknown interval '%s'", arg); |
|||
return NULL; |
|||
} |
|||
|
|||
static char *cron_fields(crontab_t *cron, rdline_t *rd) |
|||
{ |
|||
char *arg = rd->line; |
|||
uint64_t value; |
|||
|
|||
if ((arg = readfield(arg, &value, 0, 59, NULL, rd)) == NULL) |
|||
return NULL; |
|||
cron->minute = value; |
|||
|
|||
if ((arg = readfield(arg, &value, 0, 23, NULL, rd)) == NULL) |
|||
return NULL; |
|||
cron->hour = value; |
|||
|
|||
if ((arg = readfield(arg, &value, 1, 31, NULL, rd)) == NULL) |
|||
return NULL; |
|||
cron->dayofmonth = value; |
|||
|
|||
if ((arg = readfield(arg, &value, 1, 12, month, rd)) == NULL) |
|||
return NULL; |
|||
cron->month = value; |
|||
|
|||
if ((arg = readfield(arg, &value, 0, 6, weekday, rd)) == NULL) |
|||
return NULL; |
|||
cron->dayofweek = value; |
|||
|
|||
return arg; |
|||
} |
|||
|
|||
crontab_t *rdcron(int dirfd, const char *filename) |
|||
{ |
|||
crontab_t *cron, *list = NULL; |
|||
rdline_t rd; |
|||
char *ptr; |
|||
|
|||
if (rdline_init(&rd, dirfd, filename)) |
|||
return NULL; |
|||
|
|||
while (rdline(&rd) == 0) { |
|||
cron = calloc(1, sizeof(*cron)); |
|||
if (cron == NULL) { |
|||
rdline_complain(&rd, strerror(errno)); |
|||
break; |
|||
} |
|||
|
|||
if (rd.line[0] == '@') { |
|||
ptr = cron_interval(cron, &rd); |
|||
} else { |
|||
ptr = cron_fields(cron, &rd); |
|||
} |
|||
|
|||
if (ptr == NULL) { |
|||
free(cron); |
|||
continue; |
|||
} |
|||
|
|||
while (isspace(*ptr)) |
|||
++ptr; |
|||
|
|||
cron->exec = strdup(ptr); |
|||
if (cron->exec == NULL) { |
|||
rdline_complain(&rd, strerror(errno)); |
|||
free(cron); |
|||
continue; |
|||
} |
|||
|
|||
cron->next = list; |
|||
list = cron; |
|||
} |
|||
|
|||
rdline_cleanup(&rd); |
|||
return list; |
|||
} |
|||
@ -0,0 +1,77 @@ |
|||
/* SPDX-License-Identifier: ISC */ |
|||
#include "gcrond.h" |
|||
|
|||
int rdline(rdline_t *t) |
|||
{ |
|||
size_t i, len; |
|||
|
|||
do { |
|||
free(t->line); |
|||
t->line = NULL; |
|||
errno = 0; |
|||
len = 0; |
|||
|
|||
if (getline(&t->line, &len, t->fp) < 0) { |
|||
if (errno) { |
|||
rdline_complain(t, strerror(errno)); |
|||
return -1; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
t->lineno += 1; |
|||
|
|||
for (i = 0; isspace(t->line[i]); ++i) |
|||
; |
|||
|
|||
if (t->line[i] == '\0' || t->line[i] == '#') { |
|||
t->line[0] = '\0'; |
|||
} else if (i) { |
|||
memmove(t->line, t->line + i, len - i + 1); |
|||
} |
|||
} while (t->line[0] == '\0'); |
|||
|
|||
return 0; |
|||
} |
|||
|
|||
void rdline_complain(rdline_t *t, const char *msg, ...) |
|||
{ |
|||
va_list ap; |
|||
|
|||
fprintf(stderr, "%s: %zu: ", t->filename, t->lineno); |
|||
|
|||
va_start(ap, msg); |
|||
vfprintf(stderr, msg, ap); |
|||
va_end(ap); |
|||
|
|||
fputc('\n', stderr); |
|||
} |
|||
|
|||
int rdline_init(rdline_t *t, int dirfd, const char *filename) |
|||
{ |
|||
int fd; |
|||
|
|||
memset(t, 0, sizeof(*t)); |
|||
|
|||
fd = openat(dirfd, filename, O_RDONLY); |
|||
if (fd == -1) { |
|||
perror(filename); |
|||
return -1; |
|||
} |
|||
|
|||
t->fp = fdopen(fd, "r"); |
|||
if (t->fp == NULL) { |
|||
perror("fdopen"); |
|||
close(fd); |
|||
return -1; |
|||
} |
|||
|
|||
t->filename = filename; |
|||
return 0; |
|||
} |
|||
|
|||
void rdline_cleanup(rdline_t *t) |
|||
{ |
|||
free(t->line); |
|||
fclose(t->fp); |
|||
} |
|||
Loading…
Reference in new issue