aboutsummaryrefslogtreecommitdiffstats
path: root/extension/select.c
diff options
context:
space:
mode:
Diffstat (limited to 'extension/select.c')
-rw-r--r--extension/select.c544
1 files changed, 544 insertions, 0 deletions
diff --git a/extension/select.c b/extension/select.c
new file mode 100644
index 00000000..9aefaeac
--- /dev/null
+++ b/extension/select.c
@@ -0,0 +1,544 @@
+/*
+ * select.c - Builtin functions to provide select I/O multiplexing.
+ */
+
+/*
+ * Copyright (C) 2013 the Free Software Foundation, Inc.
+ *
+ * This file is part of GAWK, the GNU implementation of the
+ * AWK Programming Language.
+ *
+ * GAWK is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GAWK is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <assert.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "gawkapi.h"
+
+#include "gettext.h"
+#define _(msgid) gettext(msgid)
+#define N_(msgid) msgid
+
+static const gawk_api_t *api; /* for convenience macros to work */
+static awk_ext_id_t *ext_id;
+static const char *ext_version = "select extension: version 1.0";
+static awk_bool_t (*init_func)(void) = NULL;
+
+int plugin_is_GPL_compatible;
+
+#if defined(HAVE_SELECT) && defined(HAVE_SYS_SELECT_H)
+#include <sys/select.h>
+#endif
+
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+
+static const char *const signum2name[] = {
+#define init_sig(A, B, C) [A] = B,
+#include "siglist.h"
+#undef init_sig
+};
+#define NUMSIG sizeof(signum2name)/sizeof(signum2name[0])
+
+#define MIN_VALID_SIGNAL 1 /* 0 is not allowed! */
+/*
+ * We would like to use NSIG, but I think this seems to be a BSD'ism that is not
+ * POSIX-compliant. It is used internally by glibc, but not always
+ * available. We add a buffer to the maximum number in the provided mapping
+ * in case the list is not comprehensive:
+ */
+#define MAX_VALID_SIGNAL (NUMSIG+100)
+#define IS_VALID_SIGNAL(X) \
+ (((X) >= MIN_VALID_SIGNAL) && ((X) <= MAX_VALID_SIGNAL))
+
+static int
+signame2num(const char *name)
+{
+ size_t i;
+
+ if (strncasecmp(name, "sig", 3) == 0)
+ /* skip "sig" prefix */
+ name += 3;
+ for (i = MIN_VALID_SIGNAL; i < NUMSIG; i++) {
+ if (signum2name[i] && ! strcasecmp(signum2name[i], name))
+ return i;
+ }
+ return -1;
+}
+
+static volatile struct {
+ int flag;
+ sigset_t mask;
+} caught;
+
+static void
+signal_handler(int signum)
+{
+ /*
+ * All signals should be blocked, so we do not have to worry about
+ * whether sigaddset is thread-safe. It is documented to be
+ * async-signal-safe.
+ */
+ sigaddset(& caught.mask, signum);
+ caught.flag = 1;
+#ifndef HAVE_SIGACTION
+ /*
+ * On platforms without sigaction, we do not know how the legacy
+ * signal API will behave. There does not appear to be an autoconf
+ * test for whether the signal handler is reset to default each time
+ * a signal is trapped, so we do this to be safe.
+ */
+ signal(signum, signal_handler);
+#endif
+}
+
+static int
+integer_string(const char *s, long *x)
+{
+ char *endptr;
+
+ *x = strtol(s, & endptr, 10);
+ return ((endptr != s) && (*endptr == '\0')) ? 0 : -1;
+}
+
+static int
+get_signal_number(awk_value_t signame)
+{
+ int x;
+
+ switch (signame.val_type) {
+ case AWK_NUMBER:
+ x = signame.num_value;
+ if ((x != signame.num_value) || ! IS_VALID_SIGNAL(x)) {
+ update_ERRNO_string(_("invalid signal number"));
+ return -1;
+ }
+ return x;
+ case AWK_STRING:
+ if ((x = signame2num(signame.str_value.str)) >= 0)
+ return x;
+ {
+ long z;
+ if ((integer_string(signame.str_value.str, &z) == 0) && IS_VALID_SIGNAL(z))
+ return z;
+ }
+ update_ERRNO_string(_("invalid signal name"));
+ return -1;
+ default:
+ update_ERRNO_string(_("signal name argument must be string or numeric"));
+ return -1;
+ }
+}
+
+static awk_value_t *
+signal_result(awk_value_t *result, void (*func)(int))
+{
+ awk_value_t override;
+
+ if (func == SIG_DFL)
+ return make_const_string("default", 7, result);
+ if (func == SIG_IGN)
+ return make_const_string("ignore", 6, result);
+ if (func == signal_handler)
+ return make_const_string("trap", 4, result);
+ if (get_argument(2, AWK_NUMBER, & override) && override.num_value)
+ return make_const_string("unknown", 7, result);
+ /* need to roll it back! */
+ update_ERRNO_string(_("select_signal: override not requested for unknown signal handler"));
+ make_null_string(result);
+ return NULL;
+}
+
+/* do_signal --- trap signals */
+
+static awk_value_t *
+do_signal(int nargs, awk_value_t *result)
+{
+ awk_value_t signame, disposition;
+ int signum;
+ void (*func)(int);
+
+ if (do_lint && nargs > 3)
+ lintwarn(ext_id, _("select_signal: called with too many arguments"));
+ if (! get_argument(0, AWK_UNDEFINED, & signame)) {
+ update_ERRNO_string(_("select_signal: missing required signal name argument"));
+ return make_null_string(result);
+ }
+ if ((signum = get_signal_number(signame)) < 0)
+ return make_null_string(result);
+ if (! get_argument(1, AWK_STRING, & disposition)) {
+ update_ERRNO_string(_("select_signal: missing required signal disposition argument"));
+ return make_null_string(result);
+ }
+ if (strcasecmp(disposition.str_value.str, "default") == 0)
+ func = SIG_DFL;
+ else if (strcasecmp(disposition.str_value.str, "ignore") == 0)
+ func = SIG_IGN;
+ else if (strcasecmp(disposition.str_value.str, "trap") == 0)
+ func = signal_handler;
+ else {
+ update_ERRNO_string(_("select_signal: invalid disposition argument"));
+ return make_null_string(result);
+ }
+
+#ifdef HAVE_SIGPROCMASK
+/* Temporarily block this signal in case we need to roll back the handler! */
+#define PROTECT \
+ sigset_t set, oldset; \
+ sigemptyset(& set); \
+ sigaddset(& set, signum); \
+ sigprocmask(SIG_BLOCK, &set, &oldset);
+#define RELEASE sigprocmask(SIG_SETMASK, &oldset, NULL);
+#else
+/* Brain-damaged platform, so we will have to live with the race condition. */
+#define PROTECT
+#define RELEASE
+#endif
+
+#ifdef HAVE_SIGACTION
+ {
+ awk_value_t override;
+ struct sigaction sa, prev;
+ sa.sa_handler = func;
+ sigfillset(& sa.sa_mask); /* block all signals in handler */
+ sa.sa_flags = SA_RESTART;
+ {
+ PROTECT
+ if (sigaction(signum, &sa, &prev) < 0) {
+ update_ERRNO_int(errno);
+ RELEASE
+ return make_null_string(result);
+ }
+ if (signal_result(result, prev.sa_handler)) {
+ RELEASE
+ return result;
+ }
+ /* roll it back! */
+ sigaction(signum, &prev, NULL);
+ RELEASE
+ return result;
+ }
+ }
+#else
+ /*
+ * Fall back to signal; this is available on all platforms. We can
+ * only hope that it does the right thing.
+ */
+ {
+ void (*prev)(int);
+ PROTECT
+ if ((prev = signal(signum, func)) == SIG_ERR) {
+ update_ERRNO_int(errno);
+ RELEASE
+ return make_null_string(result);
+ }
+ if (signal_result(result, prev)) {
+ RELEASE
+ return result;
+ }
+ /* roll it back! */
+ signal(signum, prev);
+ RELEASE
+ return result;
+ }
+#endif
+}
+
+/* do_kill --- send a signal */
+
+static awk_value_t *
+do_kill(int nargs, awk_value_t *result)
+{
+#ifdef HAVE_KILL
+ awk_value_t pidarg, signame;
+ pid_t pid;
+ int signum;
+ int rc;
+
+ if (do_lint && nargs > 2)
+ lintwarn(ext_id, _("kill: called with too many arguments"));
+ if (! get_argument(0, AWK_NUMBER, & pidarg)) {
+ update_ERRNO_string(_("kill: missing required pid argument"));
+ return make_number(-1, result);
+ }
+ pid = pidarg.num_value;
+ if (pid != pidarg.num_value) {
+ update_ERRNO_string(_("kill: pid argument must be an integer"));
+ return make_number(-1, result);
+ }
+ if (! get_argument(1, AWK_UNDEFINED, & signame)) {
+ update_ERRNO_string(_("kill: missing required signal name argument"));
+ return make_number(-1, result);
+ }
+ if ((signum = get_signal_number(signame)) < 0)
+ return make_number(-1, result);
+ if ((rc = kill(pid, signum)) < 0)
+ update_ERRNO_int(errno);
+ return make_number(rc, result);
+#else
+ update_ERRNO_string(_("kill: not supported on this platform"));
+ return make_number(-1, result);
+#endif
+}
+
+/* do_select --- I/O multiplexing */
+
+static awk_value_t *
+do_select(int nargs, awk_value_t *result)
+{
+ static const char *argname[] = { "read", "write", "except" };
+ struct {
+ awk_value_t array;
+ awk_flat_array_t *flat;
+ fd_set bits;
+ int *array2fd;
+ } fds[3];
+ awk_value_t timeout_arg;
+ int i;
+ struct timeval maxwait;
+ struct timeval *timeout;
+ int nfds = 0;
+ int rc;
+ awk_value_t sigarr;
+ int dosig = 0;
+
+ if (do_lint && nargs > 5)
+ lintwarn(ext_id, _("select: called with too many arguments"));
+
+#define EL fds[i].flat->elements[j]
+ if (nargs == 5) {
+ dosig = 1;
+ if (! get_argument(4, AWK_ARRAY, &sigarr)) {
+ warning(ext_id, _("select: the signal argument must be an array"));
+ update_ERRNO_string(_("select: bad signal parameter"));
+ return make_number(-1, result);
+ }
+ clear_array(sigarr.array_cookie);
+ }
+
+ for (i = 0; i < sizeof(fds)/sizeof(fds[0]); i++) {
+ size_t j;
+
+ if (! get_argument(i, AWK_ARRAY, & fds[i].array)) {
+ warning(ext_id, _("select: bad array parameter `%s'"), argname[i]);
+ update_ERRNO_string(_("select: bad array parameter"));
+ return make_number(-1, result);
+ }
+ /* N.B. flatten_array fails for empty arrays, so that's OK */
+ FD_ZERO(&fds[i].bits);
+ if (flatten_array(fds[i].array.array_cookie, &fds[i].flat)) {
+ emalloc(fds[i].array2fd, int *, fds[i].flat->count*sizeof(int), "select");
+ for (j = 0; j < fds[i].flat->count; j++) {
+ long x;
+ fds[i].array2fd[j] = -1;
+ /* note: the index is always delivered as a string */
+
+ if (((EL.value.val_type == AWK_UNDEFINED) || ((EL.value.val_type == AWK_STRING) && ! EL.value.str_value.len)) && (integer_string(EL.index.str_value.str, &x) == 0) && (x >= 0))
+ fds[i].array2fd[j] = x;
+ else if (EL.value.val_type == AWK_STRING) {
+ const awk_input_buf_t *buf;
+ if ((buf = get_file(EL.index.str_value.str, EL.index.str_value.len, EL.value.str_value.str, EL.value.str_value.len)) != NULL)
+ fds[i].array2fd[j] = buf->fd;
+ else
+ warning(ext_id, _("select: get_file(`%s', `%s') failed in `%s' array"), EL.index.str_value.str, EL.value.str_value.str, argname[i]);
+ }
+ else
+ warning(ext_id, _("select: command type should be a string for `%s' in `%s' array"), EL.index.str_value.str, argname[i]);
+ if (fds[i].array2fd[j] < 0) {
+ update_ERRNO_string(_("select: get_file failed"));
+ if (! release_flattened_array(fds[i].array.array_cookie, fds[i].flat))
+ warning(ext_id, _("select: release_flattened_array failed"));
+ free(fds[i].array2fd);
+ return make_number(-1, result);
+ }
+ FD_SET(fds[i].array2fd[j], &fds[i].bits);
+ if (nfds <= fds[i].array2fd[j])
+ nfds = fds[i].array2fd[j]+1;
+ }
+ }
+ else
+ fds[i].flat = NULL;
+ }
+ if (dosig && caught.flag) {
+ /* take a quick poll, but do not block, since signals have been trapped */
+ maxwait.tv_sec = maxwait.tv_usec = 0;
+ timeout = &maxwait;
+ }
+ else if (get_argument(3, AWK_NUMBER, &timeout_arg)) {
+ double secs = timeout_arg.num_value;
+ if (secs < 0) {
+ warning(ext_id, _("select: treating negative timeout as zero"));
+ secs = 0;
+ }
+ maxwait.tv_sec = secs;
+ maxwait.tv_usec = (secs-(double)maxwait.tv_sec)*1000000.0;
+ timeout = &maxwait;
+ } else
+ timeout = NULL;
+
+ if ((rc = select(nfds, &fds[0].bits, &fds[1].bits, &fds[2].bits, timeout)) < 0)
+ update_ERRNO_int(errno);
+
+ if (dosig && caught.flag) {
+ int i;
+ sigset_t trapped;
+#ifdef HAVE_SIGPROCMASK
+ /*
+ * Block signals while we copy and reset the mask to eliminate
+ * a race condition whereby a signal could be missed.
+ */
+ sigset_t set, oldset;
+ sigfillset(& set);
+ sigprocmask(SIG_SETMASK, &set, &oldset);
+#endif
+ /*
+ * Reset flag to 0 first. If we don't have sigprocmask,
+ * that may reduce the chance of missing a signal.
+ */
+ caught.flag = 0;
+ trapped = caught.mask;
+ sigemptyset(& caught.mask);
+#ifdef HAVE_SIGPROCMASK
+ sigprocmask(SIG_SETMASK, &oldset, NULL);
+#endif
+ /* populate sigarr with trapped signals */
+ /*
+ * XXX this is very inefficient! Note that get_signal_number
+ * ensures that we trap only signals between MIN_VALID_SIGNAL
+ * and MAX_VALID_SIGNAL.
+ */
+ for (i = MIN_VALID_SIGNAL; i <= MAX_VALID_SIGNAL; i++) {
+ if (sigismember(& trapped, i) > 0) {
+ awk_value_t idx, val;
+ if ((i < NUMSIG) && signum2name[i])
+ set_array_element(sigarr.array_cookie, make_number(i, &idx), make_const_string(signum2name[i], strlen(signum2name[i]), &val));
+ else
+ set_array_element(sigarr.array_cookie, make_number(i, &idx), make_null_string(&val));
+ }
+ }
+ }
+
+ if (rc < 0) {
+ /* bit masks are undefined, so delete all array entries */
+ for (i = 0; i < sizeof(fds)/sizeof(fds[0]); i++) {
+ if (fds[i].flat) {
+ size_t j;
+ for (j = 0; j < fds[i].flat->count; j++)
+ EL.flags |= AWK_ELEMENT_DELETE;
+ if (! release_flattened_array(fds[i].array.array_cookie, fds[i].flat))
+ warning(ext_id, _("select: release_flattened_array failed"));
+ free(fds[i].array2fd);
+ }
+ }
+ return make_number(rc, result);
+ }
+
+ for (i = 0; i < sizeof(fds)/sizeof(fds[0]); i++) {
+ if (fds[i].flat) {
+ size_t j;
+ /* remove array elements not set in the bit mask */
+ for (j = 0; j < fds[i].flat->count; j++) {
+ if (! FD_ISSET(fds[i].array2fd[j], &fds[i].bits))
+ EL.flags |= AWK_ELEMENT_DELETE;
+ }
+ if (! release_flattened_array(fds[i].array.array_cookie, fds[i].flat))
+ warning(ext_id, _("select: release_flattened_array failed"));
+ free(fds[i].array2fd);
+ }
+ }
+#undef EL
+
+ /* Set the return value */
+ return make_number(rc, result);
+}
+
+static int
+set_non_blocking(int fd)
+{
+#if defined(HAVE_FCNTL) && defined(O_NONBLOCK)
+ int flags;
+
+ if (((flags = fcntl(fd, F_GETFL)) == -1) ||
+ (fcntl(fd, F_SETFL, (flags|O_NONBLOCK)) == -1)) {
+ update_ERRNO_int(errno);
+ return -1;
+ }
+ return 0;
+#else
+ update_ERRNO_string(_("set_non_blocking: not supported on this platform"));
+ return -1;
+#endif
+}
+
+/* do_set_non_blocking --- Set a file to be non-blocking */
+
+static awk_value_t *
+do_set_non_blocking(int nargs, awk_value_t *result)
+{
+ awk_value_t cmd, cmdtype;
+ int fd;
+
+ if (do_lint && nargs > 2)
+ lintwarn(ext_id, _("set_non_blocking: called with too many arguments"));
+ /*
+ * N.B. If called with a single "" arg, we want it to work! In that
+ * case, the 1st arg is an empty string, and get_argument fails on the
+ * 2nd arg. Note that API get_file promises not to access the type
+ * argument if the name argument is an empty string.
+ */
+ if (get_argument(0, AWK_NUMBER, & cmd) &&
+ (cmd.num_value == (fd = cmd.num_value)) &&
+ ! get_argument(1, AWK_STRING, & cmdtype))
+ return make_number(set_non_blocking(fd), result);
+ else if (get_argument(0, AWK_STRING, & cmd) &&
+ (get_argument(1, AWK_STRING, & cmdtype) ||
+ (! cmd.str_value.len && (nargs == 1)))) {
+ const awk_input_buf_t *buf;
+ if ((buf = get_file(cmd.str_value.str, cmd.str_value.len, cmdtype.str_value.str, cmdtype.str_value.len)) != NULL)
+ return make_number(set_non_blocking(buf->fd), result);
+ warning(ext_id, _("set_non_blocking: get_file(`%s', `%s') failed"), cmd.str_value.str, cmdtype.str_value.str);
+ } else if (do_lint) {
+ if (nargs < 2)
+ lintwarn(ext_id, _("set_non_blocking: called with too few arguments"));
+ else
+ lintwarn(ext_id, _("set_non_blocking: called with inappropriate argument(s)"));
+ }
+ return make_number(-1, result);
+}
+
+static awk_ext_func_t func_table[] = {
+ { "select", do_select, 5 },
+ { "select_signal", do_signal, 3 },
+ { "set_non_blocking", do_set_non_blocking, 2 },
+ { "kill", do_kill, 2 },
+};
+
+/* define the dl_load function using the boilerplate macro */
+
+dl_load_func(func_table, select, "")
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-05 22:24:59 +0000