From 648f006f08dd4bea9e259e0e59e1cc47ec671b96 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Fri, 21 Mar 2025 18:17:50 +0100 Subject: Remove dependency on libsimple since it's not portable MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- src/Makefile | 2 +- src/arg.h | 379 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/common.h | 115 ++++++++++++++++- src/config.c | 14 ++- src/config.mk | 2 +- src/gamma-drm.c | 2 +- src/hooks.c | 6 +- src/redshift.c | 3 + src/util.c | 101 +++++++++++++++ 9 files changed, 611 insertions(+), 13 deletions(-) create mode 100644 src/arg.h (limited to 'src') diff --git a/src/Makefile b/src/Makefile index 693638c..fabc63e 100644 --- a/src/Makefile +++ b/src/Makefile @@ -33,7 +33,7 @@ CPPFLAGS_STRINGS =\ all: redshift -$(OBJ): common.h +$(OBJ): common.h arg.h .c.o: $(CC) -c -o $@ $< $(CFLAGS) $(CPPFLAGS) $(CPPFLAGS_STRINGS) diff --git a/src/arg.h b/src/arg.h new file mode 100644 index 0000000..6aaffce --- /dev/null +++ b/src/arg.h @@ -0,0 +1,379 @@ +/*- + * This file is taken, with some parts remove, from libsimple + * + * ISC License + * + * © 2017, 2018, 2021, 2022, 2023, 2024, 2025 Mattias Andrée + * + * Permission to use, copy, modify, and/or 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. + */ +#include +#include +#include + + +/** + * The zeroth command line argument, the name of the process, + * set by the command line parsing macros + */ +extern char *argv0; + + +/** + * Map from a long option to a short option + * + * NB! Long options with optional arguments should + * have to map entries, one where `.long_flag` ends + * with '=' and `.with_arg` is non-zero, and one + * where `.long_flag` does not end with '=' and + * `.with_arg` is zero. These *cannot* have the same + * `.short_flag` + */ +struct longopt { + /** + * The long option, if the value must be attached + * to the flag, this must end with '=' + */ + const char *long_flag; + + /** + * The equivalent short option + * + * The first symbol in the short option + * (normally '-') will be `.long_flag[0]` + */ + char short_flag; + +#if defined(__clang__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wpadded" +#endif + + /** + * Whether the option takes an argument + */ + int with_arg; + +#if defined(__clang__) +# pragma clang diagnostic pop +#endif +}; + + +/** + * `ARGBEGIN {} ARGEND;` creates a switch statement + * instead a loop that parses the command line arguments + * according to the POSIX specification for default + * behaviour (extensions of the behaviour is possible) + * + * This macro requires that the variables `argc` and + * `argv` are defined and that `argv[argc]` is `NULL`, + * `argc` shall be a non-negative `int` that tells + * how many elements (all non-`NULL`) are available in + * `argv`, the list of command line arguments + * + * When parsing stops, `argc` and `argv` are updated + * shuch that all parsed arguments are removed; the + * contents of `argv` will not be modified, rather + * the pointer `argv` will be updated to `&argv[n]` + * where `n` is the number of parsed elements in `argv` + * + * Inside `{}` in `ARGBEGIN {} ARGEND;` there user + * shall specify `case` statements for each recognised + * command line option, and `default` for unrecognised + * option. For example: + * + * ARGBEGIN { + * case 'a': + * // handle -a + * break; + * case 'b': + * // handle -b + * break; + * case ARGNUM: + * // handle -0, -1, -2, ..., -9 + * break; + * default: + * // print usage information for other flags + * usage(); + * } ARGEND; + */ +#define ARGBEGIN ARGBEGIN2(1, 0) + +/** + * `SUBARGBEGIN {} ARGEND;` is similar to + * `ARGBEGIN {} ARGEND;`, however, `argv0` + * is not set to `argv[0]`, instead `argv[0]` + * is handled like any other element in `argv` + */ +#define SUBARGBEGIN ARGBEGIN2(0, 0) + +/** + * Flexible alternative to `ARGBEGIN` + * + * @param WITH_ARGV0 If 0, behave like `SUBARGBEGIN`, + * otherwise, behave like `ARGBEGIN` + * @param KEEP_DASHDASH If and only if 0, "--" is not removed + * `argv` before parsing is stopped when it + * is encountered + */ +#define ARGBEGIN2(WITH_ARGV0, KEEP_DASHDASH)\ + do {\ + char flag_, *lflag_, *arg_;\ + int brk_ = 0, again_;\ + size_t i_, n_;\ + if (WITH_ARGV0) {\ + argv0 = *argv;\ + argv += !!argv0;\ + argc -= !!argv0;\ + }\ + (void) arg_;\ + (void) i_;\ + (void) n_;\ + for (; argv[0] && argv[0][0] && argv[0][1]; argc--, argv++) {\ + lflag_ = argv[0];\ + if (argv[0][0] == '-') {\ + if (argv[0][1] == '-' && !argv[0][2]) {\ + if (!(KEEP_DASHDASH))\ + argv++, argc--;\ + break;\ + }\ + for (argv[0]++; argv[0][0]; argv[0]++) {\ + flag_ = argv[0][0];\ + if (flag_ == '-' && &argv[0][-1] != lflag_)\ + usage();\ + arg_ = argv[0][1] ? &argv[0][1] : argv[1];\ + do {\ + again_ = 0;\ + switch (flag_) { + +/** + * Test multiple long options and go to + * corresponding short option case + * + * If the long option is found (see documentation + * for `struct longopt` for details), the keyword + * `break` is used to break the `case` (or `default`), + * and at the next iteration of the parsing loop, the + * case will be `.short_flag` for the entry where the + * argument matched `.long_flag` and `.with_arg` + * + * @param LONGOPTS:struct longopt * The options, list shall end + * with `NULL` as `.long_flag` + */ +#define ARGMAPLONG(LONGOPTS)\ + for (i_ = 0; (LONGOPTS)[i_].long_flag; i_++) {\ + if (TESTLONG((LONGOPTS)[i_].long_flag, (LONGOPTS)[i_].with_arg)) {\ + flag_ = (LONGOPTS)[i_].short_flag;\ + again_ = 1;\ + break;\ + }\ + }\ + if (again_)\ + break + +/** + * Allows flags to start with another symbol than '-' + * + * Usage example: + * ARGBEGIN { + * case 'a': // handle -a + * break; + * default: + * usage(); + * } ARGALT('+') { + * case 'a': // handle +a + * break; + * default: + * usage(); + * } ARGALT('/') { + * case 'a': // handle /a + * break; + * default: + * usage(); + * } ARGEND; + * + * @param SYMBOL:char The symbol flags should begin with + */ +#define ARGALT(SYMBOL)\ + }\ + } while (again_);\ + if (brk_) {\ + argc -= arg_ == argv[1];\ + argv += arg_ == argv[1];\ + brk_ = 0;\ + break;\ + }\ + }\ + } else if (argv[0][0] == SYMBOL) {\ + if (argv[0][1] == SYMBOL && !argv[0][2])\ + break;\ + for (argv[0]++; argv[0][0]; argv[0]++) {\ + flag_ = argv[0][0];\ + if (flag_ == SYMBOL && &argv[0][-1] != lflag_)\ + usage();\ + arg_ = argv[0][1] ? &argv[0][1] : argv[1];\ + do {\ + again_ = 0;\ + switch (flag_) { + +/** + * Refer to `ARGBEGIN`, `SUBARGBEGIN`, and `ARGBEGIN2` + */ +#define ARGEND\ + }\ + } while (again_);\ + if (brk_) {\ + argc -= arg_ == argv[1];\ + argv += arg_ == argv[1];\ + brk_ = 0;\ + break;\ + }\ + }\ + } else {\ + break;\ + }\ + }\ + } while (0) + + +/** + * `case ARGNUM` creates a switch statement case for each digit + */ +#define ARGNUM '0': case '1': case '2': case '3': case '4':\ + case '5': case '6': case '7': case '8': case '9' + +/** + * Get the flag character, for example in `case 'a'`, + * 'a' is returned + * + * @return :char The option's identifying character + */ +#define FLAG() (flag_) + +/** + * Get the entire argument that is being parsed + * + * Note that an argument can contain multiple options + * and it can contain the last options value but the + * value can also be in the next argument + * + * @return :char * The current command line argument + */ +#define LFLAG() (lflag_) + +/** + * Get the current option's value, if it + * does not have a value, call `usage` + * (which terminates the process) + * + * Using this macro lets the parser knows + * that the option has a value + * + * @return :char * The option's value, never `NULL` + */ +#define ARG() (arg_ ? (brk_ = 1, arg_) : (usage(), NULL)) + +/** + * Get the current option's value, if the option + * does not have a value, `NULL` is returned + * + * Note that the value may appear at the next + * argument (next element in `argv`) which in that + * case is returned + * + * Using this macro lets the parser knows + * that the option has a value + * + * @return :char * The option's value, `NULL` if + * the option does not have a value + */ +#define ARGNULL() (arg_ ? (brk_ = 1, arg_) : NULL) + +/** + * Get the remaining part of the current command + * line argument (element in `argv`) — as well as + * the character that specifies the flag — as the + * value of the argument + * + * Using this macro lets the parser knows + * that the option has a value + * + * Usage example: + * + * char *arg; + * ARGBEGIN { + * case ARGNUM: + * arg = ARGHERE(); + * // `arg` is the number after '-', for example, + * // if the command line contains the argument + * // "-12345", `arg` will be `12345` + * break; + * case 'n': + * arg = &ARGHERE()[1]; + * if (*arg) { + * // flag 'n' has a value (`argv`) + * } else { + * // flag 'n' does not have a value + * } + * default: + * usage(); + * } ARGEND; + * + * @return :char * The option's value include the flag + * character, never `NULL` or "" + */ +#define ARGHERE() (brk_ = 1, argv[0]) + + +/** + * Test if the argument is a specific long option + * + * Example: + * + * ARGBEGIN { + * case 'x': + * handle_dash_x: + * // handle -x + * break; + * case '-': + * if (TESTLONG("--xdev", 0)) + * goto handle_dash_x; + * else + * usage(); + * break; + * default: + * usage(); + * } ARGEND; + * + * @param FLAG:const char * The flag, must end with '=' if the + * value must be attached to the flag, + * must not have side-effects + * @param WARG:int Whether the option takes an argument, + * should not have side-effects + */ +#define TESTLONG(FLG, WARG)\ + ((WARG)\ + ? ((!strncmp(lflag_, (FLG), (n_ = strlen(FLG), n_ -= ((FLG)[n_ - !!n_] == '='))) && lflag_[n_] == '=')\ + ? (lflag_[n_] = '\0',\ + (arg_ = &lflag_[n_ + 1]),\ + (brk_ = 1))\ + : (!strcmp(lflag_, (FLG))\ + ? (argv[1]\ + ? ((arg_ = argv[1]),\ + (brk_ = 1))\ + : (usage(), 0))\ + : 0))\ + : (!strcmp(lflag_, (FLG))\ + ? (brk_ = 1)\ + : 0)) diff --git a/src/common.h b/src/common.h index 9234e43..aa9af94 100644 --- a/src/common.h +++ b/src/common.h @@ -20,8 +20,6 @@ #ifndef REDSHIFT_COMMON_H #define REDSHIFT_COMMON_H -#include -#include #ifndef WINDOWS # if defined(__WIN32__) || defined(_WIN32) @@ -29,6 +27,9 @@ # endif #endif + +#include "arg.h" + #include #include #include @@ -40,6 +41,7 @@ #include #include #include +#include #include #include #include @@ -54,6 +56,7 @@ # define localtime_r(T, TM) localtime_s((TM), (T)) # define pause() millisleep(100U) #else +# include # include # include # include @@ -140,6 +143,33 @@ */ #define FNAN ((double)NAN) /* because clang warns when implicitly promoted to double */ +/** + * Get the number of elements in an array + * + * @param ARR The array, must not be a pointer + * @return :size_t The number of elements in `ARR` (constant + * expression, unless its size is dynamic) + */ +#define ELEMSOF(ARR) (sizeof(ARR) / (sizeof(*(ARR)))) + +/** + * Get the smallest of two numerical values + * + * @param A One of the values + * @param B The other value + * @return The smallest of `A` and `B` + */ +#define MIN(A, B) ((A) < (B) ? (A) : (B)) + +/** + * Get the largest of two numerical values + * + * @param A One of the values + * @param B The other value + * @return The largest of `A` and `B` + */ +#define MAX(A, B) ((A) > (B) ? (A) : (B)) + /** * Symbol used to delimit paths in environment @@ -1132,13 +1162,88 @@ DIR *try_path_opendir(const struct env_path *path_spec, const char **path_out, c * Create a pipe(7) where both ends have `O_CLOEXEC`, * the read-end will also have `O_NONBLOCK` applied * - * @param pipefds Output parameter for the pipe's file descriptors: - * 0) reading file descriptor, and - * 1) writing file descriptor + * @param pipefds Output parameter for the pipe's file descriptors: + * 0) reading file descriptor, and + * 1) writing file descriptor */ void pipe_rdnonblock(int pipefds[2]); #endif +/** + * Wrapper for calloc(3) that prints and error message + * and terminates the process on failure + * + * @param n Number of elements to allocate memory for + * @param m The size, in bytes, of each element + * @return Pointer to zero-initialised storage of at least `n*m` bytes, with default alignment + */ +GCC_ONLY(__attribute__((__warn_unused_result__, __malloc__, __alloc_size__(1, 2), __returns_nonnull__))) +void *ecalloc(size_t n, size_t m); + +/** + * Wrapper for malloc(3) that prints and error message + * and terminates the process on failure + * + * @param n Number of bytes to allocate + * @return Pointer to uninitialised storage of at least `n` bytes, with default alignment + */ +GCC_ONLY(__attribute__((__warn_unused_result__, __malloc__, __alloc_size__(1), __returns_nonnull__))) +void *emalloc(size_t n); + +/** + * Wrapper for realloc(3) that prints and error message + * and terminates the process on failure + * + * @param ptr Pointer to reallocate + * @param n Despired allocation size in bytes + * @return Replacement pointer for `ptr`, pointing to storage of at least `n` bytes, + * any byte that could be copied from `ptr` is copied over, and additional + * memory is uninitialised + */ +GCC_ONLY(__attribute__((__warn_unused_result__, __returns_nonnull__, __alloc_size__(2)))) +void *erealloc(void *ptr, size_t n); + +/** + * Wrapper for strdup(3) that prints and error message + * and terminates the process on failure + * + * @param s String to copy + * @return Copy of `s` + */ +GCC_ONLY(__attribute__((__warn_unused_result__, __returns_nonnull__, __malloc__, __assume_aligned__(1), __nonnull__))) +char *estrdup(const char *s); + +/** + * Print a message, prefixed with the process name (followed by ": "), + * to standard error + * + * @param fmt Message text format string, see fprintf(3) + * @param args Message text arguments + */ +GCC_ONLY(__attribute__((__nonnull__(1), __format__(__printf__, 1, 0)))) +void vweprintf(const char *fmt, va_list args); + +/** + * Print a message, prefixed with the process name (followed by ": "), + * to standard error + * + * @param fmt Message text format string, see fprintf(3) + * @param ... Message text arguments + */ +GCC_ONLY(__attribute__((__nonnull__(1), __format__(__printf__, 1, 2)))) +void weprintf(const char *fmt, ...); + +/** + * Print a message, prefixed with the process name (followed by ": "), + * to standard error and terminate the process with exit value + * indicating error + * + * @param fmt Message text format string, see fprintf(3) + * @param ... Message text arguments + */ +GCC_ONLY(__attribute__((__nonnull__(1), __format__(__printf__, 1, 2), __noreturn__))) +void eprintf(const char *fmt, ...); + extern const struct gamma_method dummy_gamma_method; #ifdef ENABLE_COOPGAMMA diff --git a/src/config.c b/src/config.c index 5762a9c..03d0e74 100644 --- a/src/config.c +++ b/src/config.c @@ -20,9 +20,17 @@ #include "common.h" -/* TODO missing translation */ -USAGE("[-b day:night] [-c file] [-g r:g:b] [-l latitude:longitude | -l provider[:options]]" - " [-m method[:options]] [-o | -O temperature | -t day:night | -x] [-pPrv] | -h | -V"); +/** + * Output usage synopsis and exit + */ +static void +usage(void) +{ + fprintf(stderr, _("usage: %s %s"), argv0, + _("[-b day:night] [-c file] [-g r:g:b] [-l latitude:longitude | -l provider[:options]]" + " [-m method[:options]] [-o | -O temperature | -t day:night | -x] [-pPrv] | -h | -V")); + exit(1); +} struct colour_setting day_settings; diff --git a/src/config.mk b/src/config.mk index f26a6a3..9c0e131 100644 --- a/src/config.mk +++ b/src/config.mk @@ -21,4 +21,4 @@ CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_XOPEN_SOURCE=700 -D_GNU_SOURCE\ -DENABLE_DRM -DENABLE_GEOCLUE2 -DENABLE_RANDR -DENABLE_VIDMODE\ -DENABLE_COOPGAMMA CFLAGS = $$($(PKGCONFIG_CFLAGS) $(LIBS_PKGCONFIG)) -LDFLAGS = $$($(PKGCONFIG_LDFLAGS) $(LIBS_PKGCONFIG)) -lm -lcoopgamma -lred -lsimple +LDFLAGS = $$($(PKGCONFIG_LDFLAGS) $(LIBS_PKGCONFIG)) -lm -lcoopgamma -lred diff --git a/src/gamma-drm.c b/src/gamma-drm.c index 2de0261..2098e0d 100644 --- a/src/gamma-drm.c +++ b/src/gamma-drm.c @@ -64,7 +64,7 @@ static int drm_start(struct gamma_state *state) { /* Acquire access to a graphics card. */ - char pathname[STRLEN(DRM_DIR_NAME"") + STRLEN(DRM_DEV_NAME"") + 3U * sizeof(int) + 2U]; + char pathname[sizeof(DRM_DIR_NAME"")-1U + sizeof(DRM_DEV_NAME"")-1U + 3U * sizeof(int) + 2U]; int crtc_count; struct drm_crtc_state *crtcs; diff --git a/src/hooks.c b/src/hooks.c index e3abf44..5412582 100644 --- a/src/hooks.c +++ b/src/hooks.c @@ -165,8 +165,10 @@ run_hooks(const char *argv[]) break; case 0: - if (dup2(STDOUT_FILENO, STDERR_FILENO) != STDERR_FILENO) - _eprintf("dup2 :"); + if (dup2(STDOUT_FILENO, STDERR_FILENO) != STDERR_FILENO) { + weprintf("dup2 :"); + _exit(1); + } stpcpy(stpcpy(&dirpath[dirpathlen], "/"), f->d_name); argv[0] = dirpath; execv(dirpath, (const void *)argv); diff --git a/src/redshift.c b/src/redshift.c index 29f463c..4f2304c 100644 --- a/src/redshift.c +++ b/src/redshift.c @@ -38,6 +38,9 @@ #define FADE_LENGTH 160U +char *argv0; + + /** * The user's current geographical location */ diff --git a/src/util.c b/src/util.c index 0c1adc9..595f236 100644 --- a/src/util.c +++ b/src/util.c @@ -224,3 +224,104 @@ apply_nonblock: eprintf("fcntl F_SETFL +O_NONBLOCK:"); } #endif + + +void * +ecalloc(size_t n, size_t m) +{ + char *ret = calloc(n, m); + if (!ret) + eprintf("calloc:"); + return ret; +} + + +void * +emalloc(size_t n) +{ + char *ret = malloc(n); + if (!ret) + eprintf("malloc:"); + return ret; +} + + +void * +erealloc(void *ptr, size_t n) +{ + char *ret = realloc(ptr, n); + if (!ret) + eprintf("realloc:"); + return ret; +} + + +char * +estrdup(const char *s) +{ + char *ret = strdup(s); + if (!ret) + eprintf("strdup:"); + return ret; +} + + +void +vweprintf(const char *fmt, va_list args) +{ + int saved_errno; + const char *errstrprefix, *errstr; +#if !defined(WINDOWS) + int locked; +#endif + + saved_errno = errno; + if (!*fmt) { + errstrprefix = ""; + errstr = strerror(saved_errno); + } else if (strchr(fmt, '\0')[-1] == '\n') { + errstrprefix = ""; + errstr = NULL; + } else if (strchr(fmt, '\0')[-1] == ':') { + errstrprefix = " "; + errstr = strerror(saved_errno); + } else { + errstrprefix = ""; + errstr = ""; + } +#if !defined(WINDOWS) + locked = !flock(STDERR_FILENO, LOCK_EX); +#endif + + fprintf(stderr, "%s: ", argv0); + vfprintf(stderr, fmt, args); + if (errstr) + fprintf(stderr, "%s%s\n", errstrprefix, errstr); + +#if !defined(WINDOWS) + if (locked) + flock(STDERR_FILENO, LOCK_UN); +#endif + errno = saved_errno; +} + + +void +weprintf(const char *fmt, ...) +{ + va_list args; + va_start(args, fmt); + vweprintf(fmt, args); + va_end(args); +} + + +void +eprintf(const char *fmt, ...) +{ + va_list args; + va_start(args, fmt); + vweprintf(fmt, args); + va_end(args); + exit(1); +} -- cgit v1.2.3-70-g09d2