mirror of https://github.com/pygos/cron
Initial commit
Signed-off-by: David Oberhollenzer <david.oberhollenzer@tele2.at>master
David Oberhollenzer
5 years ago
commit
d2b3a983e1
@ -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