From e01223a26cb7afd9f44805f067c4dcdad06039b0 Mon Sep 17 00:00:00 2001 From: Peter Stephenson Date: Sun, 2 Feb 2020 18:05:47 +0000 Subject: 45373: Fix ERR_EXIT bug in else branch of if. The flags need resetting for this branch otherwise e.g. command substitution with non-zero status doesn't cause exit. --- Test/C03traps.ztst | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'Test') diff --git a/Test/C03traps.ztst b/Test/C03traps.ztst index e661aabd5..6f84e5db2 100644 --- a/Test/C03traps.ztst +++ b/Test/C03traps.ztst @@ -500,6 +500,15 @@ >Succeed 2 >Succeed 3 + (set -e + if false; then + else + a=$(false) + print This should not appear + fi + ) +1:ERREXIT is triggered in an else block after a cmd subst returning false + fn() { emulate -L zsh setopt errreturn -- cgit 1.4.1 From 3bcf9641eb2a8d39deda166579294ef515172d85 Mon Sep 17 00:00:00 2001 From: Daniel Shahaf Date: Mon, 3 Feb 2020 07:08:54 +0000 Subject: 45368: Add tests for workers/45367's issue about double slashes in 'cd -P' and /home/daniel/in/zsh. --- ChangeLog | 6 ++++++ Test/B01cd.ztst | 4 ++++ Test/D02glob.ztst | 4 ++++ 3 files changed, 14 insertions(+) (limited to 'Test') diff --git a/ChangeLog b/ChangeLog index 663b3e88f..af4055964 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,9 @@ +2020-02-03 Daniel Shahaf + + * 45368: Test/B01cd.ztst, Test/D02glob.ztst: Add tests for + workers/45367's issue about double slashes in 'cd -P' and + /home/daniel/in/zsh. + 2020-02-02 Peter Stephenson * 45373: Src/loop.c, Test/C03traps.ztst: ERR_EXIT failed on diff --git a/Test/B01cd.ztst b/Test/B01cd.ztst index 3312f8707..d903b7462 100644 --- a/Test/B01cd.ztst +++ b/Test/B01cd.ztst @@ -145,6 +145,10 @@ F:something is broken. But you already knew that. 1:Implicit cd with unset HOME. ?zsh:cd:1: HOME not set + $ZTST_testdir/../Src/zsh -fc 'cd -P ////dev && pwd' +-f:(workers/45367) cd -P squashes multiple leading slashes +>/dev + %clean # This optional section cleans up after the test, if necessary, # e.g. killing processes etc. This is in addition to the removal of *.tmp diff --git a/Test/D02glob.ztst b/Test/D02glob.ztst index 3d7df94c9..b0650c8c8 100644 --- a/Test/D02glob.ztst +++ b/Test/D02glob.ztst @@ -742,6 +742,10 @@ >glob.tmp/secret-s111/ glob.tmp/secret-s111 >glob.tmp/secret-s444/ glob.tmp/secret-s444 + () { echo $1:P } ////dev +-f:(workers/45367) modifier ':P' squashes multiple slashes +>/dev + %clean # Fix unreadable-directory permissions so ztst can clean up properly -- cgit 1.4.1 From 699dfdd0ea25d01177f603461473f4e0c88f7378 Mon Sep 17 00:00:00 2001 From: Daniel Shahaf Date: Thu, 6 Feb 2020 12:47:39 +0000 Subject: 45385: Add a test for 'zmodload -Fa' preemptively disabling ("blacklisting"?) features. --- ChangeLog | 5 +++++ Test/V01zmodload.ztst | 14 ++++++++++++++ 2 files changed, 19 insertions(+) (limited to 'Test') diff --git a/ChangeLog b/ChangeLog index d13fb6e0f..ea80ad5bc 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +2020-02-06 Daniel Shahaf + + * 45385: Test/V01zmodload.ztst: Add a test for 'zmodload -Fa' + preemptively disabling ("blacklisting"?) features. + 2020-02-06 dana * unposted: Config/version.mk: Update for 5.7.1-test-3 diff --git a/Test/V01zmodload.ztst b/Test/V01zmodload.ztst index 1bd8c1900..6a4e34d2d 100644 --- a/Test/V01zmodload.ztst +++ b/Test/V01zmodload.ztst @@ -348,6 +348,20 @@ ?(eval):6: unknown function: systell ?(eval):9: file descriptor out of range + $ZTST_testdir/../Src/zsh -fc ' + zmodload zsh/zutil + zmodload -Fal zsh/zutil | grep parse + zmodload -u zsh/zutil + # + zmodload -Fa zsh/zutil -b:zregexparse + zmodload zsh/zutil + zmodload -Fal zsh/zutil | grep parse >&2 + ' +0:zmodload -Fa can disable features from being loaded +>b:zparseopts +>b:zregexparse +?b:zparseopts + %clean eval "$deps" -- cgit 1.4.1 From e89060a37752da1a8418fa8daa1efb546c8b6e8d Mon Sep 17 00:00:00 2001 From: dana Date: Fri, 14 Feb 2020 15:55:52 -0600 Subject: unposted: V01zmodload: Fix failing test from workers/45385 --- ChangeLog | 3 +++ Test/V01zmodload.ztst | 6 ++++-- 2 files changed, 7 insertions(+), 2 deletions(-) (limited to 'Test') diff --git a/ChangeLog b/ChangeLog index f23a956b0..2e76e04a7 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,8 @@ 2020-02-14 dana + * unposted: Test/V01zmodload.ztst: Fix failing test from + workers/45385 + * 45423 (tweaked): Completion/Unix/Command/_su: Improve arg handling, shell look-ups diff --git a/Test/V01zmodload.ztst b/Test/V01zmodload.ztst index 6a4e34d2d..55c3c314b 100644 --- a/Test/V01zmodload.ztst +++ b/Test/V01zmodload.ztst @@ -348,7 +348,9 @@ ?(eval):6: unknown function: systell ?(eval):9: file descriptor out of range - $ZTST_testdir/../Src/zsh -fc ' + $ZTST_testdir/../Src/zsh -fc " + MODULE_PATH=${(q)MODULE_PATH} + # zmodload zsh/zutil zmodload -Fal zsh/zutil | grep parse zmodload -u zsh/zutil @@ -356,7 +358,7 @@ zmodload -Fa zsh/zutil -b:zregexparse zmodload zsh/zutil zmodload -Fal zsh/zutil | grep parse >&2 - ' + " 0:zmodload -Fa can disable features from being loaded >b:zparseopts >b:zregexparse -- cgit 1.4.1 From 8250c5c168f07549ed646e6848e6dda118271e23 Mon Sep 17 00:00:00 2001 From: Daniel Shahaf Date: Thu, 26 Dec 2019 09:16:19 +0000 Subject: Improve PRIVILEGED fixes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Fix retval handling in bin_setopt() - Don't skip_setuid / skip_setgid. It's not our place to optimize away noops (that might not even _be_ noops; they might change the saved uid…). - Remove HAVE_* guard checks around functions that are used unguarded elsewhere. - Use bsd-setres_id.c from OpenSSH to provide setresuid() / setresgid() everywhere, and thus simplify the ifdef soup. Fix some preëxisting bugs in the macro definitions of setuid() (do we still need that one?). - Fix zwarning() format codes for variadic arguments type safety - Restored a comment from HEAD - Fix failure modes around initgroups() - Compared privilege restoration code with OpenSSH's permanently_drop_uid() and updated as needed - Add E01 PRIVILEGED sanity checks --- Src/openssh_bsd_setres_id.c | 129 ++++++++++++++++++++++++++++++++++++++ Src/options.c | 148 ++++++++++++++++++++------------------------ Src/zsh.mdd | 3 +- Src/zsh_system.h | 94 +++++++++++++++++++++++----- Test/E01options.ztst | 15 +++++ configure.ac | 5 +- 6 files changed, 292 insertions(+), 102 deletions(-) create mode 100644 Src/openssh_bsd_setres_id.c (limited to 'Test') diff --git a/Src/openssh_bsd_setres_id.c b/Src/openssh_bsd_setres_id.c new file mode 100644 index 000000000..65e91a40c --- /dev/null +++ b/Src/openssh_bsd_setres_id.c @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2012 Darren Tucker (dtucker at zip com au). + * + * 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. + */ +/* + * openssh_bsd_setres_id.c - setresuid() and setresgid() wrappers + * + * This file is part of zsh, the Z shell. + * + * It is based on the file openbsd-compat/bsd-setres_id.c in OpenSSH 7.9p1, + * which is subject to the copyright notice above. The zsh modifications are + * licensed as follows: + * + * Copyright (c) 2019 Daniel Shahaf + * All rights reserved. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and to distribute modified versions of this software for any + * purpose, provided that the above copyright notice and the following + * two paragraphs appear in all copies of this software. + * + * In no event shall Daniel Shahaf or the Zsh Development Group be liable + * to any party for direct, indirect, special, incidental, or consequential + * damages arising out of the use of this software and its documentation, + * even if Daniel Shahaf and the Zsh Development Group have been advised of + * the possibility of such damage. + * + * Daniel Shahaf and the Zsh Development Group specifically disclaim any + * warranties, including, but not limited to, the implied warranties of + * merchantability and fitness for a particular purpose. The software + * provided hereunder is on an "as is" basis, and Daniel Shahaf and the + * Zsh Development Group have no obligation to provide maintenance, + * support, updates, enhancements, or modifications. + * + */ + + +#include + +#include +#include +#include + +#include "zsh.mdh" + +#if defined(ZSH_IMPLEMENT_SETRESGID) || defined(BROKEN_SETRESGID) +int +setresgid(gid_t rgid, gid_t egid, gid_t sgid) +{ + int ret = 0, saved_errno; + + if (rgid != sgid) { + errno = ENOSYS; + return -1; + } +#if defined(ZSH_HAVE_NATIVE_SETREGID) && !defined(BROKEN_SETREGID) + if (setregid(rgid, egid) < 0) { + saved_errno = errno; + zwarnnam("setregid", "to gid %L: %e", (long)rgid, errno); + errno = saved_errno; + ret = -1; + } +#else + if (setegid(egid) < 0) { + saved_errno = errno; + zwarnnam("setegid", "to gid %L: %e", (long)(unsigned int)egid, errno); + errno = saved_errno; + ret = -1; + } + if (setgid(rgid) < 0) { + saved_errno = errno; + zwarnnam("setgid", "to gid %L: %e", (long)rgid, errno); + errno = saved_errno; + ret = -1; + } +#endif + return ret; +} +#endif + +#if defined(ZSH_IMPLEMENT_SETRESUID) || defined(BROKEN_SETRESUID) +int +setresuid(uid_t ruid, uid_t euid, uid_t suid) +{ + int ret = 0, saved_errno; + + if (ruid != suid) { + errno = ENOSYS; + return -1; + } +#if defined(ZSH_HAVE_NATIVE_SETREUID) && !defined(BROKEN_SETREUID) + if (setreuid(ruid, euid) < 0) { + saved_errno = errno; + zwarnnam("setreuid", "to uid %L: %e", (long)ruid, errno); + errno = saved_errno; + ret = -1; + } +#else + +# ifndef SETEUID_BREAKS_SETUID + if (seteuid(euid) < 0) { + saved_errno = errno; + zwarnnam("seteuid", "to uid %L: %e", (long)euid, errno); + errno = saved_errno; + ret = -1; + } +# endif + if (setuid(ruid) < 0) { + saved_errno = errno; + zwarnnam("setuid", "to uid %L: %e", (long)ruid, errno); + errno = saved_errno; + ret = -1; + } +#endif + return ret; +} +#endif diff --git a/Src/options.c b/Src/options.c index 328cf318b..425e27dc2 100644 --- a/Src/options.c +++ b/Src/options.c @@ -607,25 +607,21 @@ bin_setopt(char *nam, char **args, UNUSED(Options ops), int isun) } if(!(optno = optlookup(*args))) { zwarnnam(nam, "no such option: %s", *args); - retval = 1; - } else { - retval = !!dosetopt(optno, action, 0, opts); - if (retval) { - zwarnnam(nam, "can't change option: %s", *args); - } + retval |= 1; + } else if (dosetopt(optno, action, 0, opts)) { + zwarnnam(nam, "can't change option: %s", *args); + retval |= 1; } break; } else if(**args == 'm') { match = 1; } else { - if (!(optno = optlookupc(**args))) { + if (!(optno = optlookupc(**args))) { zwarnnam(nam, "bad option: -%c", **args); - retval = 1; - } else { - retval = !!dosetopt(optno, action, 0, opts); - if (retval) { - zwarnnam(nam, "can't change option: -%c", **args); - } + retval |= 1; + } else if (dosetopt(optno, action, 0, opts)) { + zwarnnam(nam, "can't change option: -%c", **args); + retval |= 1; } } } @@ -638,12 +634,10 @@ bin_setopt(char *nam, char **args, UNUSED(Options ops), int isun) while (*args) { if(!(optno = optlookup(*args++))) { zwarnnam(nam, "no such option: %s", args[-1]); - retval = 1; - } else { - retval = !!dosetopt(optno, !isun, 0, opts); - if (retval) { - zwarnnam(nam, "can't change option: %s", args[-1]); - } + retval |= 1; + } else if (dosetopt(optno, !isun, 0, opts)) { + zwarnnam(nam, "can't change option: %s", args[-1]); + retval |= 1; } } } else { @@ -667,7 +661,7 @@ bin_setopt(char *nam, char **args, UNUSED(Options ops), int isun) tokenize(s); if (!(pprog = patcompile(s, PAT_HEAPDUP, NULL))) { zwarnnam(nam, "bad pattern: %s", *args); - retval = 1; + retval |= 1; break; } /* Loop over expansions. */ @@ -787,100 +781,92 @@ dosetopt(int optno, int value, int force, char *new_opts) } else if(optno == PRIVILEGED && !value) { /* unsetting PRIVILEGED causes the shell to make itself unprivileged */ - int skip_setuid = 0; - int skip_setgid = 0; - -#if defined(HAVE_GETEGID) && defined(HAVE_SETGID) && defined(HAVE_GETUID) - int orig_egid = getegid(); -#endif + /* If set, return -1 so lastval will be non-zero. */ + int failed = 0; -#if defined(HAVE_GETEUID) && defined(HAVE_GETUID) - if (geteuid() == getuid()) { - skip_setuid = 1; - } +#ifdef HAVE_SETUID + const int orig_euid = geteuid(); #endif + const int orig_egid = getegid(); -#if defined(HAVE_GETEGID) && defined(HAVE_GETGID) - if (getegid() == getgid()) { - skip_setgid = 1; - } -#endif - - if (!skip_setgid) { - int setgid_err; -#ifdef HAVE_SETRESGID - setgid_err = setresgid(getgid(), getgid(), getgid()); -#elif defined(HAVE_SETREGID) -#if defined(HAVE_GETEGID) && defined(HAVE_SETGID) && defined(HAVE_GETUID) - setgid_err = setregid(getgid(), getgid()); -#else - zwarnnam("unsetopt", - "PRIVILEGED: can't drop privileges; setregid available, but cannot check if saved gid changed"); + /* + * Set the GID first as if we set the UID to non-privileged it + * might be impossible to restore the GID. + */ + { +#ifndef HAVE_SETRESGID + zwarnnam("unsetopt", "PRIVILEGED: can't drop privileges; setresgid() and friends not available"); return -1; -#endif #else - zwarnnam("unsetopt", "PRIVILEGED: can't drop privileges; setresgid and setregid not available"); - return -1; -#endif + int setgid_err; + setgid_err = setresgid(getgid(), getgid(), getgid()); if (setgid_err) { zwarnnam("unsetopt", "PRIVILEGED: can't drop privileges; failed to change group ID: %e", errno); return -1; } +#endif } - if (!skip_setuid) { -#if defined(HAVE_GETEUID) && defined(HAVE_SETUID) - int orig_euid = geteuid(); -#endif + /* Set the UID second. */ + { +#ifndef HAVE_SETRESUID + zwarnnam("unsetopt", "PRIVILEGED: can't drop privileges; setresuid() and friends not available"); + return -1; +#else int setuid_err; -#if defined(HAVE_GETEUID) && defined(HAVE_INITGROUPS) && defined(HAVE_GETPWUID) + +# ifdef HAVE_INITGROUPS + /* Set the supplementary groups list. */ if (geteuid() == 0) { struct passwd *pw = getpwuid(getuid()); if (pw == NULL) { - zwarnnam("unsetopt", "can't drop privileges; failed to get user information for uid %d: %e", - getuid(), errno); - return -1; - } - if (initgroups(pw->pw_name, pw->pw_gid)) { + zwarnnam("unsetopt", "can't drop privileges; failed to get user information for uid %L: %e", + (long)getuid(), errno); + failed = 1; + } else if (initgroups(pw->pw_name, pw->pw_gid)) { zwarnnam("unsetopt", "can't drop privileges; failed to set supplementary group list: %e", errno); return -1; } + } else if (getuid() != 0 && + (geteuid() != getuid() || orig_egid != getegid())) { + zwarnnam("unsetopt", "PRIVILEGED: supplementary group list not changed due to lack of permissions: EUID=%L", + (long)geteuid()); + failed = 1; } -#endif +# else + /* initgroups() isn't in POSIX. If it's not available on the system, + * we silently skip it. */ +# endif -#ifdef HAVE_SETRESUID setuid_err = setresuid(getuid(), getuid(), getuid()); -#elif defined(HAVE_SETREUID) -#if defined(HAVE_GETEUID) && defined(HAVE_SETUID) && defined(HAVE_GETUID) - setuid_err = setreuid(getuid(), getuid()); -#else - zwarnnam("unsetopt", - "PRIVILEGED: can't drop privileges; setreuid available, but cannot check if saved uid changed"); - return -1; -#endif -#else - zwarnnam("unsetopt", "PRIVILEGED: can't drop privileges; setresuid and setreuid not available"); - return -1; -#endif if (setuid_err) { zwarnnam("unsetopt", "PRIVILEGED: can't drop privileges; failed to change user ID: %e", errno); return -1; } -#if defined(HAVE_GETEUID) && defined(HAVE_SETUID) && defined(HAVE_GETUID) - if (getuid() != 0 && !setuid(orig_euid)) { - zwarnnam("unsetopt", "PRIVILEGED: can't drop privileges; was able to restore the euid"); - return -1; - } #endif } -#if defined(HAVE_GETEGID) && defined(HAVE_SETGID) && defined(HAVE_GETUID) - if (getuid() != 0 && !skip_setgid && !setgid(orig_egid)) { +#ifdef HAVE_SETGID + if (getuid() != 0 && orig_egid != getegid() && + (setgid(orig_egid) != -1 || setegid(orig_egid) != -1)) { zwarnnam("unsetopt", "PRIVILEGED: can't drop privileges; was able to restore the egid"); return -1; } #endif +#ifdef HAVE_SETUID + if (getuid() != 0 && orig_euid != geteuid() && + (setuid(orig_euid) != -1 || seteuid(orig_euid) != -1)) { + zwarnnam("unsetopt", "PRIVILEGED: can't drop privileges; was able to restore the euid"); + return -1; + } +#endif + + if (failed) { + /* A warning message has been printed. */ + return -1; + } + #ifdef JOB_CONTROL } else if (!force && optno == MONITOR && value) { if (new_opts[optno] == value) diff --git a/Src/zsh.mdd b/Src/zsh.mdd index 3e5788af5..9bcaccae5 100644 --- a/Src/zsh.mdd +++ b/Src/zsh.mdd @@ -13,7 +13,8 @@ objects="builtin.o compat.o cond.o context.o \ exec.o glob.o hashtable.o hashnameddir.o \ hist.o init.o input.o jobs.o lex.o linklist.o loop.o math.o \ mem.o module.o options.o params.o parse.o pattern.o prompt.o signals.o \ -signames.o sort.o string.o subst.o text.o utils.o watch.o" +signames.o sort.o string.o subst.o text.o utils.o watch.o \ +openssh_bsd_setres_id.o" headers="../config.h zsh_system.h zsh.h sigcount.h signals.h \ prototypes.h hashtable.h ztype.h" diff --git a/Src/zsh_system.h b/Src/zsh_system.h index 85e198f2e..161b073b4 100644 --- a/Src/zsh_system.h +++ b/Src/zsh_system.h @@ -468,30 +468,90 @@ struct timespec { # define setpgrp setpgid #endif -/* can we set the user/group id of a process */ +/* compatibility wrappers */ -#ifndef HAVE_SETUID +/* Our strategy is as follows: + * + * - Ensure that either setre[ug]id() or set{e,}[ug]id() is available. + * - If setres[ug]id() are missing, provide them in terms of either + * setre[ug]id() or set{e,}[ug]id(), whichever is available. + * - Provide replacement setre[ug]id() or set{e,}[ug]id() if they are not + * available natively. + * + * There isn't a circular dependency because, right off the bat, we check that + * there's an end condition, and #error out otherwise. + */ +#if !defined(HAVE_SETREUID) && !(defined(HAVE_SETEUID) && defined(HAVE_SETUID)) + /* + * If you run into this error, you have two options: + * - Teach zsh how to do the equivalent of setreuid() on your system + * - Remove support for PRIVILEGED option, and then remove the #error. + */ +# error "Don't know how to change UID" +#endif +#if !defined(HAVE_SETREGID) && !(defined(HAVE_SETEGID) && defined(HAVE_SETGID)) + /* See above comment. */ +# error "Don't know how to change GID" +#endif + +/* Provide setresuid(). */ +#ifndef HAVE_SETRESUID +int setresuid(uid_t, uid_t, uid_t); +# define HAVE_SETRESUID +# define ZSH_IMPLEMENT_SETRESUID # ifdef HAVE_SETREUID -# define setuid(X) setreuid(X,X) -# define setgid(X) setregid(X,X) -# define HAVE_SETUID +# define ZSH_HAVE_NATIVE_SETREUID # endif #endif -/* can we set the effective user/group id of a process */ +/* Provide setresgid(). */ +#ifndef HAVE_SETRESGID +int setresgid(gid_t, gid_t, gid_t); +# define HAVE_SETRESGID +# define ZSH_IMPLEMENT_SETRESGID +# ifdef HAVE_SETREGID +# define ZSH_HAVE_NATIVE_SETREGID +# endif +#endif +/* Provide setreuid(). */ +#ifndef HAVE_SETREUID +# define setreuid(X, Y) setresuid((X), (Y), -1) +# define HAVE_SETREUID +#endif + +/* Provide setregid(). */ +#ifndef HAVE_SETREGID +# define setregid(X, Y) setresgid((X), (Y), -1) +# define HAVE_SETREGID +#endif + +/* Provide setuid(). */ +/* ### TODO: Either remove this (this function has been standard since 1985), + * ### or rewrite this without multiply-evaluating the argument */ +#ifndef HAVE_SETUID +# define setuid(X) setreuid((X), (X)) +# define HAVE_SETUID +#endif + +/* Provide setgid(). */ +#ifndef HAVE_SETGID +/* ### TODO: Either remove this (this function has been standard since 1985), + * ### or rewrite this without multiply-evaluating the argument */ +# define setgid(X) setregid((X), (X)) +# define HAVE_SETGID +#endif + +/* Provide seteuid(). */ #ifndef HAVE_SETEUID -# ifdef HAVE_SETREUID -# define seteuid(X) setreuid(-1,X) -# define setegid(X) setregid(-1,X) -# define HAVE_SETEUID -# else -# ifdef HAVE_SETRESUID -# define seteuid(X) setresuid(-1,X,-1) -# define setegid(X) setresgid(-1,X,-1) -# define HAVE_SETEUID -# endif -# endif +# define seteuid(X) setreuid(-1, (X)) +# define HAVE_SETEUID +#endif + +/* Provide setegid(). */ +#ifndef HAVE_SETEGID +# define setegid(X) setregid(-1, (X)) +# define HAVE_SETEGID #endif #ifdef HAVE_SYS_RESOURCE_H diff --git a/Test/E01options.ztst b/Test/E01options.ztst index c4b101bdb..680f49082 100644 --- a/Test/E01options.ztst +++ b/Test/E01options.ztst @@ -1391,3 +1391,18 @@ F:Regression test for workers/41811 ?(anon):4: `break' active at end of function scope ?(anon):4: `break' active at end of function scope ?(anon):4: `break' active at end of function scope + +# There are further tests for PRIVILEGED in P01privileged.ztst. + if [[ -o privileged ]]; then + unsetopt privileged + fi + unsetopt privileged +0:PRIVILEGED sanity check: unsetting is idempotent +F:If this test fails at the first unsetopt, refer to P01privileged.ztst. + + if [[ -o privileged ]]; then + (( UID != EUID )) + else + (( UID == EUID )) + fi +0:PRIVILEGED sanity check: default value is correct diff --git a/configure.ac b/configure.ac index 2474c270e..f2d65ecfc 100644 --- a/configure.ac +++ b/configure.ac @@ -1310,9 +1310,8 @@ AC_CHECK_FUNCS(strftime strptime mktime timelocal \ inet_aton inet_pton inet_ntop \ getlogin getpwent getpwnam getpwuid getgrgid getgrnam \ initgroups nis_list \ - getuid setuid seteuid setreuid setresuid setsid \ - getgid setgid setegid setregid setresgid \ - geteuid getegid \ + setuid seteuid setreuid setresuid setsid \ + setgid setegid setregid setresgid \ memcpy memmove strstr strerror strtoul \ getrlimit getrusage \ setlocale \ -- cgit 1.4.1 From b15bd4aa590db8087d1e8f2eb1af2874f5db814d Mon Sep 17 00:00:00 2001 From: dana Date: Sat, 28 Dec 2019 20:45:55 -0600 Subject: Add unsetopt/PRIVILEGED tests --- Test/E01options.ztst | 10 ++- Test/P01privileged.ztst | 197 ++++++++++++++++++++++++++++++++++++++++++++++++ Test/README | 1 + 3 files changed, 207 insertions(+), 1 deletion(-) create mode 100644 Test/P01privileged.ztst (limited to 'Test') diff --git a/Test/E01options.ztst b/Test/E01options.ztst index 680f49082..cfe2c75cc 100644 --- a/Test/E01options.ztst +++ b/Test/E01options.ztst @@ -74,7 +74,6 @@ # HASH_LIST_ALL ) # PRINT_EXIT_STATUS haven't worked out what this does yet, although # Bart suggested a fix. -# PRIVILEGED (similar to GLOBAL_RCS) # RCS ( " " " " ) # SH_OPTION_LETTERS even I found this too dull to set up a test for # SINGLE_COMMAND kills shell @@ -95,6 +94,15 @@ %test + # setopt should move on to the next operation in the face of an error, but + # preserve the >0 return code + unsetopt aliases + setopt not_a_real_option aliases && return 2 + print -r - $options[aliases] +0:setopt error handling +?(eval):setopt:4: no such option: not_a_real_option +>on + alias echo='print foo' unsetopt aliases # use eval else aliases are all parsed at start diff --git a/Test/P01privileged.ztst b/Test/P01privileged.ztst new file mode 100644 index 000000000..c54112bb6 --- /dev/null +++ b/Test/P01privileged.ztst @@ -0,0 +1,197 @@ +# This file contains tests related to the PRIVILEGED option. In order to run, +# it requires that the test process itself have super-user privileges (or that +# one of the environment variables described below be set). This can be achieved +# via, e.g., `sudo make check TESTNUM=P`. +# +# Optionally, the environment variables ZSH_TEST_UNPRIVILEGED_UID and/or +# ZSH_TEST_UNPRIVILEGED_GID may be set to UID:EUID or GID:EGID pairs, where the +# two IDs in each pair are different, non-0 IDs valid on the system being used +# to run the tests. (The UIDs must both be non-0 to effectively test downgrading +# of privileges, and they must be non-matching to test auto-enabling of +# PRIVILEGED and to ensure that disabling PRIVILEGED correctly resets the saved +# UID. Technically GID 0 is not special, but for simplicity's sake we apply the +# same requirements here.) +# +# If either of the aforementioned environment variables is not set, the test +# script will try to pick the first two >0 IDs from the passwd/group databases +# on the current system. +# +# If either variable is set, the tests will run, but they will likely fail +# without super-user privileges. + +%prep + + # Mind your empty lines here. The logic in this %prep section is somewhat + # complex compared to most others; to avoid lots of nested/duplicated + # conditions we need to make sure that this all gets executed as a single + # function from which we can return early + [[ $EUID == 0 || -n $ZSH_TEST_UNPRIVILEGED_UID$ZSH_TEST_UNPRIVILEGED_GID ]] || { + ZTST_unimplemented='PRIVILEGED tests require super-user privileges (or env var)' + return 1 + } + (( $+commands[perl] )) || { # @todo Eliminate this dependency with a C wrapper? + ZTST_unimplemented='PRIVILEGED tests require Perl' + return 1 + } + grep -qE '#define HAVE_SETRES?UID' $ZTST_testdir/../config.h || { + ZTST_unimplemented='PRIVILEGED tests require setreuid()/setresuid()' + return 1 + } + # + ruid= euid= rgid= egid= + # + if [[ -n $ZSH_TEST_UNPRIVILEGED_UID ]]; then + ruid=${ZSH_TEST_UNPRIVILEGED_UID%%:*} + euid=${ZSH_TEST_UNPRIVILEGED_UID##*:} + else + print -ru$ZTST_fd 'Selecting unprivileged UID:EUID pair automatically' + local tmp=$( getent passwd 2> /dev/null || < /etc/passwd ) + # Note: Some awks require -v and its argument to be separate + ruid=$( awk -F: '$3 > 0 { print $3; exit; }' <<< $tmp ) + euid=$( awk -F: -v u=$ruid '$3 > u { print $3; exit; }' <<< $tmp ) + fi + # + if [[ -n $ZSH_TEST_UNPRIVILEGED_GID ]]; then + rgid=${ZSH_TEST_UNPRIVILEGED_GID%%:*} + egid=${ZSH_TEST_UNPRIVILEGED_GID##*:} + else + print -ru$ZTST_fd 'Selecting unprivileged GID:EGID pair automatically' + local tmp=$( getent group 2> /dev/null || < /etc/group ) + # Note: Some awks require -v and its argument to be separate + rgid=$( awk -F: '$3 > 0 { print $3; exit; }' <<< $tmp ) + egid=$( awk -F: -v g=$rgid '$3 > g { print $3; exit; }' <<< $tmp ) + fi + # + [[ $ruid/$euid == <1->/<1-> && $ruid != $euid ]] || ruid= euid= + [[ $rgid/$egid == <1->/<1-> && $rgid != $egid ]] || rgid= egid= + # + [[ -n $ruid && -n $euid ]] || { + ZTST_unimplemented='PRIVILEGED tests require unprivileged UID:EUID' + return 1 + } + [[ -n $rgid || -n $egid ]] || { + ZTST_unimplemented='PRIVILEGED tests require unprivileged GID:EGID' + return 1 + } + # + print -ru$ZTST_fd \ + "Using unprivileged UID $ruid, EUID $euid, GID $rgid, EGID $egid" + # + # Execute process with specified UID and EUID + # $1 => Real UID + # $2 => Effective UID + # $3 => Real GID + # $4 => Effective GID + # $5 ... => Command + args to execute (must NOT be a shell command string) + re_exec() { + perl -e ' + die("re_exec: not enough arguments") unless (@ARGV >= 5); + my ($ruid, $euid, $rgid, $egid, @cmd) = @ARGV; + foreach my $id ($ruid, $euid, $rgid, $egid) { + die("re_exec: invalid ID: $id") unless ($id =~ /^(-1|\d+)$/a); + } + $< = 0 + $ruid if ($ruid >= 0); + $> = 0 + $euid if ($euid >= 0); + $( = 0 + $rgid if ($rgid >= 0); + $) = 0 + $egid if ($egid >= 0); + exec(@cmd); + die("re_exec: exec failed: $!"); + ' -- "$@" + } + # + # Convenience wrapper for re_exec to call `zsh -c` + # -* ... => (optional) Command-line options to zsh + # $1 => Real UID + # $2 => Effective UID + # $3 => Real GID + # $4 => Effective GID + # $5 ... => zsh command string; multiple strings are joined by \n + re_zsh() { + local -a opts + while [[ $1 == -[A-Za-z-]* ]]; do + opts+=( $1 ) + shift + done + re_exec "$1" "$2" "$3" "$4" $ZTST_exe $opts -fc \ + "MODULE_PATH=${(q)MODULE_PATH}; ${(F)@[5,-1]}" + } + # + # Return one or more random unused UIDs + # $1 ... => Names of parameters to store UIDs in + get_unused_uid() { + while (( $# )); do + local i_=0 uid_= + until [[ -n $uid_ ]]; do + (( ++i_ > 99 )) && return 1 + uid_=$RANDOM + id $uid_ &> /dev/null || break + uid_= + done + : ${(P)1::=$uid_} + shift + done + } + +%test + + re_zsh $ruid $ruid -1 -1 'echo $UID/$EUID $options[privileged]' + re_zsh $euid $euid -1 -1 'echo $UID/$EUID $options[privileged]' + re_zsh $ruid $euid -1 -1 'echo $UID/$EUID $options[privileged]' +0q:PRIVILEGED automatically enabled when RUID != EUID +>$ruid/$ruid off +>$euid/$euid off +>$ruid/$euid on + + re_zsh -1 -1 $rgid $rgid 'echo $GID/$EGID $options[privileged]' + re_zsh -1 -1 $egid $egid 'echo $GID/$EGID $options[privileged]' + re_zsh -1 -1 $rgid $egid 'echo $GID/$EGID $options[privileged]' +0q:PRIVILEGED automatically enabled when RGID != EGID +>$rgid/$rgid off +>$egid/$egid off +>$rgid/$egid on + + re_zsh $ruid $euid -1 -1 'unsetopt privileged; echo $UID/$EUID' +0q:EUID set to RUID after disabling PRIVILEGED +*?zsh:unsetopt:1: PRIVILEGED: supplementary group list not changed * +*?zsh:unsetopt:1: can't change option: privileged +>$ruid/$ruid + + re_zsh 0 $euid -1 -1 'unsetopt privileged && echo $UID/$EUID' +0:RUID/EUID set to 0/0 when privileged after disabling PRIVILEGED +>0/0 + + re_zsh $ruid $euid -1 -1 "unsetopt privileged; UID=$euid" || + re_zsh $ruid $euid -1 -1 "unsetopt privileged; EUID=$euid" +1:not possible to regain EUID when unprivileged after disabling PRIVILEGED +*?zsh:unsetopt:1: PRIVILEGED: supplementary group list not changed * +*?zsh:unsetopt:1: can't change option: privileged +*?zsh:1: failed to change user ID: * +*?zsh:unsetopt:1: PRIVILEGED: supplementary group list not changed * +*?zsh:unsetopt:1: can't change option: privileged +*?zsh:1: failed to change effective user ID: * + + re_zsh -1 -1 $rgid $egid 'unsetopt privileged && echo $GID/$EGID' +0q:EGID set to RGID after disabling PRIVILEGED +>$rgid/$rgid + +# This test also confirms that we can't revert to the original EUID's primary +# GID, which initgroups() may reset the EGID to on some systems + re_zsh $ruid 0 $rgid 0 'unsetopt privileged; GID=0' || + re_zsh $ruid 0 $rgid 0 'unsetopt privileged; EGID=0' +1:not possible to regain EGID when unprivileged after disabling PRIVILEGED +*?zsh:1: failed to change group ID: * +*?zsh:1: failed to change effective group ID: * + + local rruid + grep -qF '#define HAVE_INITGROUPS' $ZTST_testdir/../config.h || { + ZTST_skip='initgroups() not available' + return 1 + } + get_unused_uid rruid || { + ZTST_skip="Can't get unused UID" + return 1 + } + re_zsh $rruid 0 -1 -1 'unsetopt privileged' +1:getpwuid() fails with non-existent RUID and 0 EUID +*?zsh:unsetopt:1: can't drop privileges; failed to get user information * +*?zsh:unsetopt:1: can't change option: privileged diff --git a/Test/README b/Test/README index d012277ce..726d68e72 100644 --- a/Test/README +++ b/Test/README @@ -6,6 +6,7 @@ scripts names: C: shell commands with special syntax D: substititution E: options + P: privileged (needs super-user privileges) V: modules W: builtin interactive commands and constructs X: line editing -- cgit 1.4.1 From cb5d8bfe8621c8029f97647ec543ce6e7c41fa58 Mon Sep 17 00:00:00 2001 From: Chris Down Date: Mon, 17 Feb 2020 10:11:46 -0500 Subject: 45451: builtins: kill: Add basic test suite This is not totally comprehensive, but at least it's a start for the core functionality. In the next commits, we'll also use this base to add some regression tests. --- ChangeLog | 4 ++++ Test/B11kill.ztst | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 64 insertions(+) create mode 100644 Test/B11kill.ztst (limited to 'Test') diff --git a/ChangeLog b/ChangeLog index 290f1c6af..4d48d787c 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,7 @@ +2020-02-18 Chris Down + + * 45451: Test/B11kill.ztst: builtins: kill: Add basic test suite + 2020-02-17 brian m. carlson * github #48/0002: diff --git a/Test/B11kill.ztst b/Test/B11kill.ztst new file mode 100644 index 000000000..26d7a11fe --- /dev/null +++ b/Test/B11kill.ztst @@ -0,0 +1,60 @@ +# Tests for the kill builtin. +# +# The exit codes 11 and 19 in this file don't mean anything special; they're +# just exit codes which are specific enough that the failure of `kill` itself +# can be differentiated from exiting due to executing a trap. + +%test + +# Correct invocation + + if zmodload zsh/system &>/dev/null; then + ( + trap 'exit 19' TERM + kill $sysparams[pid] + ) + else + ZTST_skip='Cannot zmodload zsh/system, skipping kill with no sigspec' + fi +19:kill with no sigspec + + + if zmodload zsh/system &>/dev/null; then + ( + trap 'exit 11' USR1 + kill -USR1 $sysparams[pid] + ) + else + ZTST_skip='Cannot zmodload zsh/system, skipping kill with sigspec' + fi +11:kill with sigspec + +# Incorrect invocation + + ( + kill a b c + ) +3:kill with multiple wrong inputs should increment status +?(eval):kill:2: illegal pid: a +?(eval):kill:2: illegal pid: b +?(eval):kill:2: illegal pid: c + + ( + kill -INT a b c + ) +3:kill with sigspec and wrong inputs should increment status +?(eval):kill:2: illegal pid: a +?(eval):kill:2: illegal pid: b +?(eval):kill:2: illegal pid: c + + ( + kill + ) +1:kill with no arguments +?(eval):kill:2: not enough arguments + + ( + kill -INT + ) +1:kill with sigspec only +?(eval):kill:2: not enough arguments -- cgit 1.4.1 From 59258252b501159c2988de3a2d87a18dc17e98b1 Mon Sep 17 00:00:00 2001 From: Chris Down Date: Mon, 17 Feb 2020 10:12:02 -0500 Subject: 45452: builtins: kill: Add `kill ''` regression test with explicit sigspec The version without a sigspec can't be added yet because it would still kill the test runner even in expected-to-fail mode; see workers/45449 for discussion. For the same reason, we use a signal which is non-fatal by default and unlikely to be sent by someone else, SIGURG, to do the expected-to-fail case prior to the fix. --- ChangeLog | 3 +++ Test/B11kill.ztst | 9 +++++++++ 2 files changed, 12 insertions(+) (limited to 'Test') diff --git a/ChangeLog b/ChangeLog index 4d48d787c..162bde6b0 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,8 @@ 2020-02-18 Chris Down + * 45452: Test/B11kill.ztst: builtins: kill: Add `kill ''` + regression test with explicit sigspec + * 45451: Test/B11kill.ztst: builtins: kill: Add basic test suite 2020-02-17 brian m. carlson diff --git a/Test/B11kill.ztst b/Test/B11kill.ztst index 26d7a11fe..957a7b385 100644 --- a/Test/B11kill.ztst +++ b/Test/B11kill.ztst @@ -58,3 +58,12 @@ ) 1:kill with sigspec only ?(eval):kill:2: not enough arguments + +# Regression tests: `kill ''` should not result in `kill 0`. + + ( + trap 'exit 11' URG + kill -URG '' + ) +1f:kill with empty pid and sigspec should not send signal to current process group +?(eval):kill:3: illegal pid: -- cgit 1.4.1 From 5c55b3fb50bbfe602fcfa55fa6258e398ecc6b20 Mon Sep 17 00:00:00 2001 From: Chris Down Date: Mon, 17 Feb 2020 10:12:11 -0500 Subject: 45453: builtins: kill: Do not signal current process group when pid is empty The following case was encountered in the wild: % zsh; echo "$?" % trap 'exit 5' TERM % kill '' 5 This behaviour seems more likely to be the result of bugs in programs (e.g. `kill -9 "$unsetvar") rather than being desirable behaviour to me. It also seems unintentional judging by the code and documentation, since it comes about as a result of the fact that: - `isanum` returns true for empty strings (since an empty string technically only consists of digits and minuses...); - `atoi`, when passed a pointer to an invalid number, returns 0; - `kill(0, signal)` sends the signal in question to all processes in the current process group. There are (at least) two ways to solve this issue: 1. Add special handling to `kill` to avoid this case. See this patch[0] for a version that does that. 2. Change how isanum behaves. Since the only two call sites that use it both seem like they should handle the case where the input char array is empty, that seems like a reasonable overall change to me.[1] After this patch: % trap 'exit 5' TERM % kill '' kill: illegal pid: The regression test for `kill` without a sigspec is also included in this commit, as previously it's not possible to test it trivially as it would still kill the test runner in expected-to-fail mode; see discussion in workers/45449. 0: workers/45426: https://www.zsh.org/mla/workers/2020/msg00251.html 1: The other call site using isanum() is the fg builtin, but in that case we just fail later since we can't find any job named '', so no big deal either way. It's the kill case which is more concerning. --- ChangeLog | 3 +++ Src/jobs.c | 5 +++-- Test/B11kill.ztst | 10 +++++++++- 3 files changed, 15 insertions(+), 3 deletions(-) (limited to 'Test') diff --git a/ChangeLog b/ChangeLog index 162bde6b0..9a7ca36a0 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,8 @@ 2020-02-18 Chris Down + * 45453: Src/jobs.c, Test/B11kill.ztst: builtins: kill: Do not + signal current process group when pid is empty + * 45452: Test/B11kill.ztst: builtins: kill: Add `kill ''` regression test with explicit sigspec diff --git a/Src/jobs.c b/Src/jobs.c index e7438251e..0485f2c7c 100644 --- a/Src/jobs.c +++ b/Src/jobs.c @@ -1854,13 +1854,14 @@ scanjobs(void) /* This simple function indicates whether or not s may represent * * a number. It returns true iff s consists purely of digits and * - * minuses. Note that minus may appear more than once, and the empty * - * string will produce a `true' response. */ + * minuses. Note that minus may appear more than once. */ /**/ static int isanum(char *s) { + if (*s == '\0') + return 0; while (*s == '-' || idigit(*s)) s++; return *s == '\0'; diff --git a/Test/B11kill.ztst b/Test/B11kill.ztst index 957a7b385..40dd99cd3 100644 --- a/Test/B11kill.ztst +++ b/Test/B11kill.ztst @@ -65,5 +65,13 @@ trap 'exit 11' URG kill -URG '' ) -1f:kill with empty pid and sigspec should not send signal to current process group +1:kill with empty pid and sigspec should not send signal to current process group ?(eval):kill:3: illegal pid: + + ( + trap 'exit 19' TERM + kill '' + ) +1:Plain kill with empty pid should not send signal to current process group +?(eval):kill:3: illegal pid: + -- cgit 1.4.1 From 69c247de2ff3ca41be93cd90af539926418d023d Mon Sep 17 00:00:00 2001 From: Chris Down Date: Tue, 18 Feb 2020 13:54:37 -0500 Subject: 45463: test: kill: Document why we use SIGURG See discussion in workers/45460. --- ChangeLog | 3 +++ Test/B11kill.ztst | 9 +++++++++ 2 files changed, 12 insertions(+) (limited to 'Test') diff --git a/ChangeLog b/ChangeLog index 9a7ca36a0..5fabad45c 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,8 @@ 2020-02-18 Chris Down + * 45463: Test/B11kill.ztst: test: kill: Document why we use + SIGURG + * 45453: Src/jobs.c, Test/B11kill.ztst: builtins: kill: Do not signal current process group when pid is empty diff --git a/Test/B11kill.ztst b/Test/B11kill.ztst index 40dd99cd3..dc6bf9b89 100644 --- a/Test/B11kill.ztst +++ b/Test/B11kill.ztst @@ -60,6 +60,15 @@ ?(eval):kill:2: not enough arguments # Regression tests: `kill ''` should not result in `kill 0`. +# +# We use SIGURG where an explicit sigspec can be provided as: +# +# 1. By default it's non-terminal, so even if we regress, we won't kill the +# test runner and other processes in the process group since we'll stop +# running this test before we get to the plain kill (and thus SIGTERM) +# cases; +# 2. It's also unlikely to be sent for any other reason during the process +# lifetime, so the test shouldn't be flaky. ( trap 'exit 11' URG -- cgit 1.4.1 From fe516fccb4754833f850cb62f6607226370bbf53 Mon Sep 17 00:00:00 2001 From: Jun-ichi Takimoto Date: Thu, 27 Feb 2020 16:08:13 +0900 Subject: 45492: skip test added by users/24633 on Cygwin --- ChangeLog | 5 +++++ Test/D02glob.ztst | 14 +++++++++----- 2 files changed, 14 insertions(+), 5 deletions(-) (limited to 'Test') diff --git a/ChangeLog b/ChangeLog index 340de5b43..218970ff6 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +2020-02-27 Jun-ichi Takimoto + + * 45492: Test/D02glob.ztst: skip test added by users/24633 + on Cygwin. + 2020-02-25 Peter Stephenson * 45488: Marc Cornella: Completion/bashcompinit: Need "$@" diff --git a/Test/D02glob.ztst b/Test/D02glob.ztst index b0650c8c8..973dc2207 100644 --- a/Test/D02glob.ztst +++ b/Test/D02glob.ztst @@ -729,11 +729,15 @@ >not/exist >exist - mkdir -m 000 glob.tmp/secret-d000 - mkdir -m 111 glob.tmp/secret-d111 - mkdir -m 444 glob.tmp/secret-d444 - for 1 in 000 111 444 ; do ln -s secret-d$1 glob.tmp/secret-s$1; done - print -rC 2 -- glob.tmp/secret-*/ glob.tmp/secret-*(-/) + if [[ $OSTYPE = cygwin* ]]; then + ZTST_skip='Cygwin ignores search permission of directories' + else + mkdir -m 000 glob.tmp/secret-d000 + mkdir -m 111 glob.tmp/secret-d111 + mkdir -m 444 glob.tmp/secret-d444 + for 1 in 000 111 444 ; do ln -s secret-d$1 glob.tmp/secret-s$1; done + print -rC 2 -- glob.tmp/secret-*/ glob.tmp/secret-*(-/) + fi -f:unreadable directories can be globbed (users/24619, users/24626) >glob.tmp/secret-d000/ glob.tmp/secret-d000 >glob.tmp/secret-d111/ glob.tmp/secret-d111 -- cgit 1.4.1 From 273da6cc5f58c4a99399c37ad5faf09924119fea Mon Sep 17 00:00:00 2001 From: Jun-ichi Takimoto Date: Fri, 6 Mar 2020 20:12:06 +0900 Subject: 45490 (+45495 and a test): refactor rlimits.c Use a table of known resouces instead of generating rlimits.h by rlimits.awk. --- .gitignore | 1 - ChangeLog | 7 + Src/Builtins/rlimits.awk | 116 -------- Src/Builtins/rlimits.c | 692 ++++++++++++++++++----------------------------- Src/Builtins/rlimits.mdd | 15 - Test/B12limit.ztst | 10 + configure.ac | 1 + 7 files changed, 281 insertions(+), 561 deletions(-) delete mode 100644 Src/Builtins/rlimits.awk create mode 100644 Test/B12limit.ztst (limited to 'Test') diff --git a/.gitignore b/.gitignore index e46f8517e..ec2f56642 100644 --- a/.gitignore +++ b/.gitignore @@ -123,7 +123,6 @@ Src/Builtins/*.mdh Src/Builtins/*.mdhi Src/Builtins/*.mdhs Src/Builtins/*.mdh.tmp -Src/Builtins/rlimits.h Src/Modules/Makefile.in Src/Modules/*.export diff --git a/ChangeLog b/ChangeLog index 7632153d4..6735e224b 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,10 @@ +2020-03-06 Jun-ichi Takimoto + + * 45490 (+45495 and a test): .gitignore, + Src/Builtins/rlimits.awk, Src/Builtins/rlimits.c, + Src/Builtins/rlimits.mdd, Test/B12limit.ztst, configure.ac: + Refactor rlimits.c. + 2020-03-05 Bryan Irvine * github #49: Completion/BSD/Type/_obsd_architectures: Fix typo: diff --git a/Src/Builtins/rlimits.awk b/Src/Builtins/rlimits.awk deleted file mode 100644 index e9c576c66..000000000 --- a/Src/Builtins/rlimits.awk +++ /dev/null @@ -1,116 +0,0 @@ -# -# rlimits.awk: {g,n}awk script to generate rlimits.h -# -# NB: On SunOS 4.1.3 - user-functions don't work properly, also \" problems -# Without 0 + hacks some nawks compare numbers as strings -# -BEGIN {limidx = 0} - -/^[\t ]*(#[\t ]*define[\t _]*RLIMIT_[A-Z_]*[\t ]*[0-9][0-9]*|RLIMIT_[A-Z_]*,[\t ]*|_*RLIMIT_[A-Z_]*[\t ]*=[\t ]*[0-9][0-9]*,[\t ]*)/ { - limindex = index($0, "RLIMIT_") - limtail = substr($0, limindex, 80) - split(limtail, tmp) - limnam = substr(tmp[1], 8, 20) - limnum = tmp[2] - # in this case I assume GNU libc resourcebits.h - if (limnum == "") { - limnum = limidx++ - limindex = index($0, ",") - limnam = substr(limnam, 1, limindex-1) - } - if (limnum == "=") { - if (tmp[3] ~ /^[0-9]/) { - limnum = tmp[3] + 0 - } else { - limnum = limidx++ - } - limindex = index($0, ",") - limnam = substr(limnam, 1, limindex-1) - } - limrev[limnam] = limnum - if (lim[limnum] == "") { - lim[limnum] = limnam - if (limnum ~ /^[0-9]*$/) { - if (limnam == "AIO_MEM") { msg[limnum] = "Maiomemorylocked" } - if (limnam == "AIO_OPS") { msg[limnum] = "Naiooperations" } - if (limnam == "AS") { msg[limnum] = "Maddressspace" } - if (limnam == "CORE") { msg[limnum] = "Mcoredumpsize" } - if (limnam == "CPU") { msg[limnum] = "Tcputime" } - if (limnam == "DATA") { msg[limnum] = "Mdatasize" } - if (limnam == "FSIZE") { msg[limnum] = "Mfilesize" } - if (limnam == "LOCKS") { msg[limnum] = "Nmaxfilelocks" } - if (limnam == "MEMLOCK") { msg[limnum] = "Mmemorylocked" } - if (limnam == "NOFILE") { msg[limnum] = "Ndescriptors" } - if (limnam == "NPROC") { msg[limnum] = "Nmaxproc" } - if (limnam == "NTHR") { msg[limnum] = "Nmaxpthreads" } - if (limnam == "OFILE") { msg[limnum] = "Ndescriptors" } - if (limnam == "PTHREAD") { msg[limnum] = "Nmaxpthreads" } - if (limnam == "RSS") { msg[limnum] = "Mresident" } - if (limnam == "SBSIZE") { msg[limnum] = "Msockbufsize" } - if (limnam == "STACK") { msg[limnum] = "Mstacksize" } - if (limnam == "TCACHE") { msg[limnum] = "Ncachedthreads" } - if (limnam == "VMEM") { msg[limnum] = "Mvmemorysize" } - if (limnam == "SIGPENDING") { msg[limnum] = "Nsigpending" } - if (limnam == "MSGQUEUE") { msg[limnum] = "Nmsgqueue" } - if (limnam == "NICE") { msg[limnum] = "Nnice" } - if (limnam == "RTPRIO") { msg[limnum] = "Nrt_priority" } - if (limnam == "RTTIME") { msg[limnum] = "Urt_time" } - if (limnam == "POSIXLOCKS") { msg[limnum] = "Nposixlocks" } - if (limnam == "NPTS") { msg[limnum] = "Npseudoterminals" } - if (limnam == "SWAP") { msg[limnum] = "Mswapsize" } - if (limnam == "KQUEUES") { msg[limnum] = "Nkqueues" } - if (limnam == "UMTXP") { msg[limnum] = "Numtxp" } - } - } -} -/^[\t ]*#[\t ]*define[\t _]*RLIM_NLIMITS[\t ]*[0-9][0-9]*/ { - limindex = index($0, "RLIM_") - limtail = substr($0, limindex, 80) - split(limtail, tmp) - nlimits = tmp[2] -} -# in case of GNU libc -/^[\t ]*RLIM_NLIMITS[\t ]*=[\t ]*RLIMIT_NLIMITS/ { - if(!nlimits) { nlimits = limidx } -} -/^[\t _]*RLIM(IT)?_NLIMITS[\t ]*=[\t ]*[0-9][0-9]*/ { - limindex = index($0, "=") - limtail = substr($0, limindex, 80) - split(limtail, tmp) - nlimits = tmp[2] -} - -END { - if (limrev["MEMLOCK"] != "") { - irss = limrev["RSS"] - msg[irss] = "Mmemoryuse" - } - ps = "%s" - - printf("%s\n%s\n\n", "/** rlimits.h **/", "/** architecture-customized limits for zsh **/") - printf("#define ZSH_NLIMITS %d\n\nstatic char const *recs[ZSH_NLIMITS] = {\n", 0 + nlimits) - - for (i = 0; i < 0 + nlimits; i++) - if (msg[i] == "") - printf("\t%c%s%c,\n", 34, lim[i], 34) - else - printf("\t%c%s%c,\n", 34, substr(msg[i], 2, 30), 34) - print "};" - print "" - print "static int limtype[ZSH_NLIMITS] = {" - for (i = 0; i < 0 + nlimits; i++) { - if (msg[i] == "") - limtype = "UNKNOWN" - else { - limtype = substr(msg[i], 1, 1) - if(limtype == "M") { limtype = "MEMORY" } - if(limtype == "N") { limtype = "NUMBER" } - if(limtype == "T") { limtype = "TIME" } - if(limtype == "U") { limtype = "MICROSECONDS" } - } - printf("\tZLIMTYPE_%s,\n", limtype) - } - print "};" - - exit(0) -} diff --git a/Src/Builtins/rlimits.c b/Src/Builtins/rlimits.c index 6b552f3a9..b9128433f 100644 --- a/Src/Builtins/rlimits.c +++ b/Src/Builtins/rlimits.c @@ -32,20 +32,7 @@ #if defined(HAVE_GETRLIMIT) && defined(RLIM_INFINITY) -#if defined(HAVE_RLIMIT_POSIXLOCKS) && !defined(HAVE_RLIMIT_LOCKS) -# define RLIMIT_LOCKS RLIMIT_POSIXLOCKS -# define HAVE_RLIMIT_LOCKS 1 -#endif - -#if defined(HAVE_RLIMIT_NTHR) && !defined(HAVE_RLIMIT_PTHREAD) -# define RLIMIT_PTHREAD RLIMIT_NTHR -# define HAVE_RLIMIT_PTHREAD 1 -# define THREAD_FMT "-T: threads " -#else -# define THREAD_FMT "-T: threads per process " -#endif - -enum { +enum zlimtype { ZLIMTYPE_MEMORY, ZLIMTYPE_NUMBER, ZLIMTYPE_TIME, @@ -53,11 +40,214 @@ enum { ZLIMTYPE_UNKNOWN }; -/* Generated rec array containing limits required for the limit builtin. * - * They must appear in this array in numerical order of the RLIMIT_* macros. */ +typedef struct resinfo_T { + int res; /* RLIMIT_XXX */ + char* name; /* used by limit builtin */ + enum zlimtype type; + int unit; /* 1, 512, or 1024 */ + char opt; /* option character */ + char* descr; /* used by ulimit builtin */ +} resinfo_T; + +/* table of known resources */ +static const resinfo_T known_resources[] = { + {RLIMIT_CPU, "cputime", ZLIMTYPE_TIME, 1, + 't', "cpu time (seconds)"}, + {RLIMIT_FSIZE, "filesize", ZLIMTYPE_MEMORY, 512, + 'f', "file size (blocks)"}, + {RLIMIT_DATA, "datasize", ZLIMTYPE_MEMORY, 1024, + 'd', "data seg size (kbytes)"}, + {RLIMIT_STACK, "stacksize", ZLIMTYPE_MEMORY, 1024, + 's', "stack size (kbytes)"}, + {RLIMIT_CORE, "coredumpsize", ZLIMTYPE_MEMORY, 512, + 'c', "core file size (blocks)"}, +# ifdef HAVE_RLIMIT_NOFILE + {RLIMIT_NOFILE, "descriptors", ZLIMTYPE_NUMBER, 1, + 'n', "file descriptors"}, +# endif +# if defined(HAVE_RLIMIT_AS) && !defined(RLIMIT_VMEM_IS_AS) + {RLIMIT_AS, "addressspace", ZLIMTYPE_MEMORY, 1024, + 'v', "address space (kbytes)"}, +# endif +# if defined(HAVE_RLIMIT_RSS) && !defined(RLIMIT_VMEM_IS_RSS) && !defined(RLIMIT_RSS_IS_AS) + {RLIMIT_RSS, "resident", ZLIMTYPE_MEMORY, 1024, + 'm', "resident set size (kbytes)"}, +# endif +# if defined(HAVE_RLIMIT_VMEM) + {RLIMIT_VMEM, +# if defined(RLIMIT_VMEM_IS_RSS) + "resident", ZLIMTYPE_MEMORY, 1024, + 'm', "memory size (kbytes)"}, +# else + "vmemorysize", ZLIMTYPE_MEMORY, 1024, + 'v', "virtual memory size (kbytes)"}, +# endif +# endif +# ifdef HAVE_RLIMIT_NPROC + {RLIMIT_NPROC, "maxproc", ZLIMTYPE_NUMBER, 1, + 'u', "processes"}, +# endif +# ifdef HAVE_RLIMIT_MEMLOCK + {RLIMIT_MEMLOCK, "memorylocked", ZLIMTYPE_MEMORY, 1024, + 'l', "locked-in-memory size (kbytes)"}, +# endif + /* Linux */ +# ifdef HAVE_RLIMIT_LOCKS + {RLIMIT_LOCKS, "maxfilelocks", ZLIMTYPE_NUMBER, 1, + 'x', "file locks"}, +# endif +# ifdef HAVE_RLIMIT_SIGPENDING + {RLIMIT_SIGPENDING, "sigpending", ZLIMTYPE_NUMBER, 1, + 'i', "pending signals"}, +# endif +# ifdef HAVE_RLIMIT_MSGQUEUE + {RLIMIT_MSGQUEUE, "msgqueue", ZLIMTYPE_NUMBER, 1, + 'q', "bytes in POSIX msg queues"}, +# endif +# ifdef HAVE_RLIMIT_NICE + {RLIMIT_NICE, "nice", ZLIMTYPE_NUMBER, 1, + 'e', "max nice"}, +# endif +# ifdef HAVE_RLIMIT_RTPRIO + {RLIMIT_RTPRIO, "rt_priority", ZLIMTYPE_NUMBER, 1, + 'r', "max rt priority"}, +# endif +# ifdef HAVE_RLIMIT_RTTIME + {RLIMIT_RTTIME, "rt_time", ZLIMTYPE_MICROSECONDS, 1, + 'N', "rt cpu time (microseconds)"}, +# endif + /* BSD */ +# ifdef HAVE_RLIMIT_SBSIZE + {RLIMIT_SBSIZE, "sockbufsize", ZLIMTYPE_MEMORY, 1, + 'b', "socket buffer size (bytes)"}, +# endif +# ifdef HAVE_RLIMIT_KQUEUES /* FreeBSD */ + {RLIMIT_KQUEUES, "kqueues", ZLIMTYPE_NUMBER, 1, + 'k', "kqueues"}, +# endif +# ifdef HAVE_RLIMIT_NPTS /* FreeBSD */ + {RLIMIT_NPTS, "pseudoterminals", ZLIMTYPE_NUMBER, 1, + 'p', "pseudo-terminals"}, +# endif +# ifdef HAVE_RLIMIT_SWAP /* FreeBSD */ + {RLIMIT_SWAP, "swapsize", ZLIMTYPE_MEMORY, 1024, + 'w', "swap size (kbytes)"}, +# endif +# ifdef HAVE_RLIMIT_UMTXP /* FreeBSD */ + {RLIMIT_UMTXP, "umtxp", ZLIMTYPE_NUMBER, 1, + 'o', "umtx shared locks"}, +# endif + +# ifdef HAVE_RLIMIT_POSIXLOCKS /* DragonFly */ + {RLIMIT_POSIXLOCKS, "posixlocks", ZLIMTYPE_NUMBER, 1, + 'x', "number of POSIX locks"}, +# endif +# if defined(HAVE_RLIMIT_NTHR) && !defined(HAVE_RLIMIT_RTPRIO) /* Net/OpenBSD */ + {RLIMIT_NTHR, "maxpthreads", ZLIMTYPE_NUMBER, 1, + 'r', "threads"}, +# endif + /* others */ +# if defined(HAVE_RLIMIT_PTHREAD) && !defined(HAVE_RLIMIT_NTHR) /* IRIX ? */ + {RLIMIT_PTHREAD, "maxpthreads", ZLIMTYPE_NUMBER, 1, + 'T', "threads per process"}, +# endif +# ifdef HAVE_RLIMIT_AIO_MEM /* HP-UX ? */ + {RLIMIT_AIO_MEM, "aiomemorylocked", ZLIMTYPE_MEMORY, 1024, + 'N', "AIO locked-in-memory (kbytes)"}, +# endif +# ifdef HAVE_RLIMIT_AIO_OPS /* HP-UX ? */ + {RLIMIT_AIO_OPS, "aiooperations", ZLIMTYPE_NUMBER, 1, + 'N', "AIO operations"}, +# endif +# ifdef HAVE_RLIMIT_TCACHE /* HP-UX ? */ + {RLIMIT_TCACHE, "cachedthreads", ZLIMTYPE_NUMBER, 1, + 'N', "cached threads"}, +# endif +}; -# include "rlimits.h" +/* resinfo[RLIMIT_XXX] points to the corresponding entry + * in known_resources[] */ +static const resinfo_T **resinfo; +/**/ +static void +set_resinfo(void) +{ + int i; + + resinfo = (const resinfo_T **)zshcalloc(RLIM_NLIMITS*sizeof(resinfo_T *)); + + for (i=0; ires = - 1; /* negative value indicates "unknown" */ + info->name = buf; + info->type = ZLIMTYPE_UNKNOWN; + info->unit = 1; + info->opt = 'N'; + info->descr = buf; + resinfo[i] = info; + } + } +} + +/**/ +static void +free_resinfo(void) +{ + int i; + for (i=0; ires < 0) { /* unknown resource */ + free(resinfo[i]->name); + free((void*)resinfo[i]); + } + } + free(resinfo); + resinfo = NULL; +} + +/* Find resource by its option character */ + +/**/ +static int +find_resource(char c) +{ + int i; + for (i=0; iopt == c) + return i; + } + return -1; +} + +/* Print a value of type rlim_t */ + +/**/ +static void +printrlim(rlim_t val, const char *unit) +{ +# ifdef RLIM_T_IS_QUAD_T + printf("%qd%s", val, unit); +# else +# ifdef RLIM_T_IS_LONG_LONG + printf("%lld%s", val, unit); +# else +# ifdef RLIM_T_IS_UNSIGNED + printf("%lu%s", (unsigned long)val, unit); +# else + printf("%ld%s", (long)val, unit); +# endif /* RLIM_T_IS_UNSIGNED */ +# endif /* RLIM_T_IS_LONG_LONG */ +# endif /* RLIM_T_IS_QUAD_T */ +} + +/**/ static rlim_t zstrtorlimt(const char *s, char **t, int base) { @@ -97,8 +287,8 @@ static void showlimitvalue(int lim, rlim_t val) { /* display limit for resource number lim */ - if (lim < ZSH_NLIMITS) - printf("%-16s", recs[lim]); + if (lim < RLIM_NLIMITS) + printf("%-16s", resinfo[lim]->name); else { /* Unknown limit, hence unknown units. */ @@ -106,81 +296,25 @@ showlimitvalue(int lim, rlim_t val) } if (val == RLIM_INFINITY) printf("unlimited\n"); - else if (lim >= ZSH_NLIMITS) - { -# ifdef RLIM_T_IS_QUAD_T - printf("%qd\n", val); -# else -# ifdef RLIM_T_IS_LONG_LONG - printf("%lld\n", val); -# else -# ifdef RLIM_T_IS_UNSIGNED - printf("%lu\n", (unsigned long)val); -# else - printf("%ld\n", (long)val); -# endif /* RLIM_T_IS_UNSIGNED */ -# endif /* RLIM_T_IS_LONG_LONG */ -# endif /* RLIM_T_IS_QUAD_T */ - } - else if (limtype[lim] == ZLIMTYPE_TIME) { + else if (lim >= RLIM_NLIMITS) + printrlim(val, "\n"); + else if (resinfo[lim]->type == ZLIMTYPE_TIME) { /* time-type resource -- display as hours, minutes and seconds. */ printf("%d:%02d:%02d\n", (int)(val / 3600), (int)(val / 60) % 60, (int)(val % 60)); - } else if (limtype[lim] == ZLIMTYPE_MICROSECONDS) { - /* microseconds */ -# ifdef RLIM_T_IS_QUAD_T - printf("%qdus\n", val); -# else -# ifdef RLIM_T_IS_LONG_LONG - printf("%lldus\n", val); -# else -# ifdef RLIM_T_IS_UNSIGNED - printf("%luus\n", (unsigned long)val); -# else - printf("%ldus\n", (long)val); -# endif /* RLIM_T_IS_UNSIGNED */ -# endif /* RLIM_T_IS_LONG_LONG */ -# endif /* RLIM_T_IS_QUAD_T */ - } else if (limtype[lim] == ZLIMTYPE_NUMBER || - limtype[lim] == ZLIMTYPE_UNKNOWN) { - /* pure numeric resource */ -# ifdef RLIM_T_IS_QUAD_T - printf("%qd\n", val); -# else -# ifdef RLIM_T_IS_LONG_LONG - printf("%lld\n", val); -# else -# ifdef RLIM_T_IS_UNSIGNED - printf("%lu\n", (unsigned long)val); -# else - printf("%ld\n", (long)val); -# endif /* RLIM_T_IS_UNSIGNED */ -# endif /* RLIM_T_IS_LONG_LONG */ -# endif /* RLIM_T_IS_QUAD_T */ - } else if (val >= 1024L * 1024L) - /* memory resource -- display with `K' or `M' modifier */ -# ifdef RLIM_T_IS_QUAD_T - printf("%qdMB\n", val / (1024L * 1024L)); - else - printf("%qdkB\n", val / 1024L); -# else -# ifdef RLIM_T_IS_LONG_LONG - printf("%lldMB\n", val / (1024L * 1024L)); - else - printf("%lldkB\n", val / 1024L); -# else -# ifdef RLIM_T_IS_UNSIGNED - printf("%luMB\n", (unsigned long)(val / (1024L * 1024L))); - else - printf("%lukB\n", (unsigned long)(val / 1024L)); -# else - printf("%ldMB\n", (long)val / (1024L * 1024L)); - else - printf("%ldkB\n", (long)val / 1024L); -# endif /* RLIM_T_IS_UNSIGNED */ -# endif /* RLIM_T_IS_LONG_LONG */ -# endif /* RLIM_T_IS_QUAD_T */ + } else if (resinfo[lim]->type == ZLIMTYPE_MICROSECONDS) + printrlim(val, "us\n"); /* microseconds */ + else if (resinfo[lim]->type == ZLIMTYPE_NUMBER || + resinfo[lim]->type == ZLIMTYPE_UNKNOWN) + printrlim(val, "\n"); /* pure numeric resource */ + else { + /* memory resource -- display with `k' or `M' modifier */ + if (val >= 1024L * 1024L) + printrlim(val/(1024L * 1024L), "MB\n"); + else + printrlim(val/1024L, "kB\n"); + } } /* Display resource limits. hard indicates whether `hard' or `soft' * @@ -193,7 +327,7 @@ showlimits(char *nam, int hard, int lim) { int rt; - if (lim >= ZSH_NLIMITS) + if (lim >= RLIM_NLIMITS) { /* * Not configured into the shell. Ask the OS @@ -215,7 +349,7 @@ showlimits(char *nam, int hard, int lim) else { /* main loop over resource types */ - for (rt = 0; rt != ZSH_NLIMITS; rt++) + for (rt = 0; rt != RLIM_NLIMITS; rt++) showlimitvalue(rt, (hard) ? limits[rt].rlim_max : limits[rt].rlim_cur); } @@ -234,7 +368,7 @@ printulimit(char *nam, int lim, int hard, int head) rlim_t limit; /* get the limit in question */ - if (lim >= ZSH_NLIMITS) + if (lim >= RLIM_NLIMITS) { struct rlimit vals; @@ -248,199 +382,25 @@ printulimit(char *nam, int lim, int hard, int head) else limit = (hard) ? limits[lim].rlim_max : limits[lim].rlim_cur; /* display the appropriate heading */ - switch (lim) { - case RLIMIT_CORE: - if (head) - printf("-c: core file size (blocks) "); - if (limit != RLIM_INFINITY) - limit /= 512; - break; - case RLIMIT_DATA: - if (head) - printf("-d: data seg size (kbytes) "); - if (limit != RLIM_INFINITY) - limit /= 1024; - break; - case RLIMIT_FSIZE: - if (head) - printf("-f: file size (blocks) "); - if (limit != RLIM_INFINITY) - limit /= 512; - break; -# ifdef HAVE_RLIMIT_SIGPENDING - case RLIMIT_SIGPENDING: - if (head) - printf("-i: pending signals "); - break; -# endif -# ifdef HAVE_RLIMIT_MEMLOCK - case RLIMIT_MEMLOCK: - if (head) - printf("-l: locked-in-memory size (kbytes) "); - if (limit != RLIM_INFINITY) - limit /= 1024; - break; -# endif /* HAVE_RLIMIT_MEMLOCK */ -/* If RLIMIT_VMEM and RLIMIT_RSS are defined and equal, avoid * - * duplicate case statement. Observed on QNX Neutrino 6.1.0. */ -# if defined(HAVE_RLIMIT_RSS) && !defined(RLIMIT_VMEM_IS_RSS) && !defined(RLIMIT_RSS_IS_AS) - case RLIMIT_RSS: - if (head) - printf("-m: resident set size (kbytes) "); - if (limit != RLIM_INFINITY) - limit /= 1024; - break; -# endif /* HAVE_RLIMIT_RSS */ -# if defined(HAVE_RLIMIT_VMEM) && defined(HAVE_RLIMIT_RSS) && defined(RLIMIT_VMEM_IS_RSS) - case RLIMIT_VMEM: - if (head) - printf("-m: memory size (kbytes) "); - if (limit != RLIM_INFINITY) - limit /= 1024; - break; -# endif /* HAVE_RLIMIT_VMEM */ -# ifdef HAVE_RLIMIT_NOFILE - case RLIMIT_NOFILE: - if (head) - printf("-n: file descriptors "); - break; -# endif /* HAVE_RLIMIT_NOFILE */ -# ifdef HAVE_RLIMIT_MSGQUEUE - case RLIMIT_MSGQUEUE: - if (head) - printf("-q: bytes in POSIX msg queues "); - break; -# endif - case RLIMIT_STACK: - if (head) - printf("-s: stack size (kbytes) "); - if (limit != RLIM_INFINITY) - limit /= 1024; - break; - case RLIMIT_CPU: - if (head) - printf("-t: cpu time (seconds) "); - break; -# ifdef HAVE_RLIMIT_NPROC - case RLIMIT_NPROC: - if (head) - printf("-u: processes "); - break; -# endif /* HAVE_RLIMIT_NPROC */ -# if defined(HAVE_RLIMIT_VMEM) && (!defined(HAVE_RLIMIT_RSS) || !defined(RLIMIT_VMEM_IS_RSS)) - case RLIMIT_VMEM: - if (head) - printf("-v: virtual memory size (kbytes) "); - if (limit != RLIM_INFINITY) - limit /= 1024; - break; -# endif /* HAVE_RLIMIT_VMEM */ -# if defined HAVE_RLIMIT_AS && !defined(RLIMIT_VMEM_IS_AS) - case RLIMIT_AS: - if (head) - printf("-v: address space (kbytes) "); - if (limit != RLIM_INFINITY) - limit /= 1024; - break; -# endif /* HAVE_RLIMIT_AS */ -# ifdef HAVE_RLIMIT_LOCKS - case RLIMIT_LOCKS: - if (head) - printf("-x: file locks "); - break; -# endif /* HAVE_RLIMIT_LOCKS */ -# ifdef HAVE_RLIMIT_AIO_MEM - case RLIMIT_AIO_MEM: - if (head) - printf("-N %2d: AIO locked-in-memory (kbytes)", RLIMIT_AIO_MEM); - if (limit != RLIM_INFINITY) - limit /= 1024; - break; -# endif /* HAVE_RLIMIT_AIO_MEM */ -# ifdef HAVE_RLIMIT_AIO_OPS - case RLIMIT_AIO_OPS: - if (head) - printf("-N %2d: AIO operations ", RLIMIT_AIO_OPS); - break; -# endif /* HAVE_RLIMIT_AIO_OPS */ -# ifdef HAVE_RLIMIT_TCACHE - case RLIMIT_TCACHE: - if (head) - printf("-N %2d: cached threads ", RLIMIT_TCACHE); - break; -# endif /* HAVE_RLIMIT_TCACHE */ -# ifdef HAVE_RLIMIT_SBSIZE - case RLIMIT_SBSIZE: - if (head) - printf("-b: socket buffer size (bytes) "); - break; -# endif /* HAVE_RLIMIT_SBSIZE */ -# ifdef HAVE_RLIMIT_PTHREAD - case RLIMIT_PTHREAD: - if (head) - printf("%s", THREAD_FMT); - break; -# endif /* HAVE_RLIMIT_PTHREAD */ -# ifdef HAVE_RLIMIT_NICE - case RLIMIT_NICE: - if (head) - printf("-e: max nice "); - break; -# endif /* HAVE_RLIMIT_NICE */ -# ifdef HAVE_RLIMIT_RTPRIO - case RLIMIT_RTPRIO: - if (head) - printf("-r: max rt priority "); - break; -# endif /* HAVE_RLIMIT_RTPRIO */ -# ifdef HAVE_RLIMIT_NPTS - case RLIMIT_NPTS: - if (head) - printf("-p: pseudo-terminals "); - break; -# endif /* HAVE_RLIMIT_NPTS */ -# ifdef HAVE_RLIMIT_SWAP - case RLIMIT_SWAP: - if (head) - printf("-w: swap size (kbytes) "); - if (limit != RLIM_INFINITY) - limit /= 1024; - break; -# endif /* HAVE_RLIMIT_SWAP */ -# ifdef HAVE_RLIMIT_KQUEUES - case RLIMIT_KQUEUES: - if (head) - printf("-k: kqueues "); - break; -# endif /* HAVE_RLIMIT_KQUEUES */ -# ifdef HAVE_RLIMIT_UMTXP - case RLIMIT_UMTXP: - if (head) - printf("-o: umtx shared locks "); - break; -# endif /* HAVE_RLIMIT_UMTXP */ - default: - if (head) - printf("-N %2d: ", lim); - break; + if (head) { + if (lim < RLIM_NLIMITS) { + const resinfo_T *info = resinfo[lim]; + if (info->opt == 'N') + printf("-N %2d: %-29s", lim, info->descr); + else + printf("-%c: %-32s", info->opt, info->descr); + } + else + printf("-N %2d: %-29s", lim, ""); } /* display the limit */ if (limit == RLIM_INFINITY) printf("unlimited\n"); else { -# ifdef RLIM_T_IS_QUAD_T - printf("%qd\n", limit); -# else -# ifdef RLIM_T_IS_LONG_LONG - printf("%lld\n", limit); -# else -# ifdef RLIM_T_IS_UNSIGNED - printf("%lu\n", (unsigned long)limit); -# else - printf("%ld\n", (long)limit); -# endif /* RLIM_T_IS_UNSIGNED */ -# endif /* RLIM_T_IS_LONG_LONG */ -# endif /* RLIM_T_IS_QUAD_T */ + if (lim < RLIM_NLIMITS) + printrlim(limit/resinfo[lim]->unit, "\n"); + else + printrlim(limit, "\n"); } return 0; @@ -450,7 +410,7 @@ printulimit(char *nam, int lim, int hard, int head) static int do_limit(char *nam, int lim, rlim_t val, int hard, int soft, int set) { - if (lim >= ZSH_NLIMITS) { + if (lim >= RLIM_NLIMITS) { struct rlimit vals; if (getrlimit(lim, &vals) < 0) { @@ -558,8 +518,8 @@ bin_limit(char *nam, char **argv, Options ops, UNUSED(int func)) lim = (int)zstrtol(s, NULL, 10); } else - for (lim = -1, limnum = 0; limnum < ZSH_NLIMITS; limnum++) - if (!strncmp(recs[limnum], s, strlen(s))) { + for (lim = -1, limnum = 0; limnum < RLIM_NLIMITS; limnum++) + if (!strncmp(resinfo[limnum]->name, s, strlen(s))) { if (lim != -1) lim = -2; else @@ -576,7 +536,7 @@ bin_limit(char *nam, char **argv, Options ops, UNUSED(int func)) /* without value for limit, display the current limit */ if (!(s = *argv++)) return showlimits(nam, hard, lim); - if (lim >= ZSH_NLIMITS) + if (lim >= RLIM_NLIMITS) { val = zstrtorlimt(s, &s, 10); if (*s) @@ -586,7 +546,7 @@ bin_limit(char *nam, char **argv, Options ops, UNUSED(int func)) return 1; } } - else if (limtype[lim] == ZLIMTYPE_TIME) { + else if (resinfo[lim]->type == ZLIMTYPE_TIME) { /* time-type resource -- may be specified as seconds, or minutes or * * hours with the `m' and `h' modifiers, and `:' may be used to add * * together more than one of these. It's easier to understand from * @@ -604,9 +564,9 @@ bin_limit(char *nam, char **argv, Options ops, UNUSED(int func)) return 1; } } - } else if (limtype[lim] == ZLIMTYPE_NUMBER || - limtype[lim] == ZLIMTYPE_UNKNOWN || - limtype[lim] == ZLIMTYPE_MICROSECONDS) { + } else if (resinfo[lim]->type == ZLIMTYPE_NUMBER || + resinfo[lim]->type == ZLIMTYPE_UNKNOWN || + resinfo[lim]->type == ZLIMTYPE_MICROSECONDS) { /* pure numeric resource -- only a straight decimal number is permitted. */ char *t = s; @@ -642,7 +602,7 @@ static int do_unlimit(char *nam, int lim, int hard, int soft, int set, int euid) { /* remove specified limit */ - if (lim >= ZSH_NLIMITS) { + if (lim >= RLIM_NLIMITS) { struct rlimit vals; if (getrlimit(lim, &vals) < 0) { @@ -718,8 +678,8 @@ bin_unlimit(char *nam, char **argv, Options ops, UNUSED(int func)) if (idigit(**argv)) { lim = (int)zstrtol(*argv, NULL, 10); } else { - for (lim = -1, limnum = 0; limnum < ZSH_NLIMITS; limnum++) - if (!strncmp(recs[limnum], *argv, strlen(*argv))) { + for (lim = -1, limnum = 0; limnum < RLIM_NLIMITS; limnum++) + if (!strncmp(resinfo[limnum]->name, *argv, strlen(*argv))) { if (lim != -1) lim = -2; else @@ -800,116 +760,14 @@ bin_ulimit(char *name, char **argv, UNUSED(Options ops), UNUSED(int func)) resmask = (1 << RLIM_NLIMITS) - 1; nres = RLIM_NLIMITS; continue; - case 't': - res = RLIMIT_CPU; - break; - case 'f': - res = RLIMIT_FSIZE; - break; - case 'd': - res = RLIMIT_DATA; - break; - case 's': - res = RLIMIT_STACK; - break; - case 'c': - res = RLIMIT_CORE; - break; -# ifdef HAVE_RLIMIT_SBSIZE - case 'b': - res = RLIMIT_SBSIZE; - break; -# endif /* HAVE_RLIMIT_SBSIZE */ -# ifdef HAVE_RLIMIT_MEMLOCK - case 'l': - res = RLIMIT_MEMLOCK; - break; -# endif /* HAVE_RLIMIT_MEMLOCK */ -# ifdef HAVE_RLIMIT_RSS - case 'm': - res = RLIMIT_RSS; - break; -# endif /* HAVE_RLIMIT_RSS */ -# ifdef HAVE_RLIMIT_NOFILE - case 'n': - res = RLIMIT_NOFILE; - break; -# endif /* HAVE_RLIMIT_NOFILE */ -# ifdef HAVE_RLIMIT_NPROC - case 'u': - res = RLIMIT_NPROC; - break; -# endif /* HAVE_RLIMIT_NPROC */ -# if defined(HAVE_RLIMIT_VMEM) || defined(HAVE_RLIMIT_AS) - case 'v': -# ifdef HAVE_RLIMIT_VMEM - res = RLIMIT_VMEM; -# else - res = RLIMIT_AS; -# endif - break; -# endif /* HAVE_RLIMIT_VMEM */ -# ifdef HAVE_RLIMIT_LOCKS - case 'x': - res = RLIMIT_LOCKS; - break; -# endif -# ifdef HAVE_RLIMIT_SIGPENDING - case 'i': - res = RLIMIT_SIGPENDING; - break; -# endif -# ifdef HAVE_RLIMIT_MSGQUEUE - case 'q': - res = RLIMIT_MSGQUEUE; - break; -# endif -# ifdef HAVE_RLIMIT_NICE - case 'e': - res = RLIMIT_NICE; - break; -# endif -# ifdef HAVE_RLIMIT_RTPRIO - case 'r': - res = RLIMIT_RTPRIO; - break; -# else -# ifdef HAVE_RLIMIT_NTHR - /* For compatibility with sh on NetBSD */ - case 'r': - res = RLIMIT_NTHR; - break; -# endif /* HAVE_RLIMIT_NTHR */ -# endif -# ifdef HAVE_RLIMIT_NPTS - case 'p': - res = RLIMIT_NPTS; - break; -# endif -# ifdef HAVE_RLIMIT_SWAP - case 'w': - res = RLIMIT_SWAP; - break; -# endif -# ifdef HAVE_RLIMIT_KQUEUES - case 'k': - res = RLIMIT_KQUEUES; - break; -# endif -# ifdef HAVE_RLIMIT_PTHREAD - case 'T': - res = RLIMIT_PTHREAD; - break; -# endif -# ifdef HAVE_RLIMIT_UMTXP - case 'o': - res = RLIMIT_UMTXP; - break; -# endif default: - /* unrecognised limit */ - zwarnnam(name, "bad option: -%c", *options); - return 1; + res = find_resource(*options); + if (res < 0) { + /* unrecognised limit */ + zwarnnam(name, "bad option: -%c", *options); + return 1; + } + break; } if (options[1]) { resmask |= 1 << res; @@ -961,34 +819,8 @@ bin_ulimit(char *name, char **argv, UNUSED(Options ops), UNUSED(int func)) return 1; } /* scale appropriately */ - switch (res) { - case RLIMIT_FSIZE: - case RLIMIT_CORE: - limit *= 512; - break; - case RLIMIT_DATA: - case RLIMIT_STACK: -# ifdef HAVE_RLIMIT_RSS - case RLIMIT_RSS: -# endif /* HAVE_RLIMIT_RSS */ -# ifdef HAVE_RLIMIT_MEMLOCK - case RLIMIT_MEMLOCK: -# endif /* HAVE_RLIMIT_MEMLOCK */ -/* If RLIMIT_VMEM and RLIMIT_RSS are defined and equal, avoid * - * duplicate case statement. Observed on QNX Neutrino 6.1.0. */ -# if defined(HAVE_RLIMIT_VMEM) && !defined(RLIMIT_VMEM_IS_RSS) - case RLIMIT_VMEM: -# endif /* HAVE_RLIMIT_VMEM */ -/* ditto RLIMIT_VMEM and RLIMIT_AS */ -# if defined(HAVE_RLIMIT_AS) && !defined(RLIMIT_VMEM_IS_AS) && !defined(RLIMIT_RSS_IS_AS) - case RLIMIT_AS: -# endif /* HAVE_RLIMIT_AS */ -# ifdef HAVE_RLIMIT_AIO_MEM - case RLIMIT_AIO_MEM: -# endif /* HAVE_RLIMIT_AIO_MEM */ - limit *= 1024; - break; - } + if (res < RLIM_NLIMITS) + limit *= resinfo[res]->unit; } if (do_limit(name, res, limit, hard, soft, 1)) ret++; @@ -1052,6 +884,7 @@ enables_(Module m, int **enables) int boot_(UNUSED(Module m)) { + set_resinfo(); return 0; } @@ -1059,6 +892,7 @@ boot_(UNUSED(Module m)) int cleanup_(Module m) { + free_resinfo(); return setfeatureenables(m, &module_features, NULL); } diff --git a/Src/Builtins/rlimits.mdd b/Src/Builtins/rlimits.mdd index 9e6e9e598..06c9e9c7f 100644 --- a/Src/Builtins/rlimits.mdd +++ b/Src/Builtins/rlimits.mdd @@ -6,18 +6,3 @@ autofeatures="b:limit b:ulimit b:unlimit" autofeatures_emu="b:ulimit" objects="rlimits.o" - -:<<\Make -rlimits.o rlimits..o: rlimits.h - -# this file will not be made if limits are unavailable -rlimits.h: rlimits.awk @RLIMITS_INC_H@ - $(AWK) -f $(sdir)/rlimits.awk @RLIMITS_INC_H@ /dev/null > rlimits.h - @if grep ZLIMTYPE_UNKNOWN rlimits.h >/dev/null; then \ - echo >&2 WARNING: unknown limits: mail Src/Builtins/rlimits.h to developers; \ - else :; fi - -clean-here: clean.rlimits -clean.rlimits: - rm -f rlimits.h -Make diff --git a/Test/B12limit.ztst b/Test/B12limit.ztst new file mode 100644 index 000000000..5dd7afdbe --- /dev/null +++ b/Test/B12limit.ztst @@ -0,0 +1,10 @@ +# check if there is unknown resouce(s) + +%test + + limit | grep UNKNOWN || print OK +0:Check if there is unknown resouce(s) in the system +>OK +F:A failure here does not indicate any error in zsh. It just means there +F:is a resource in your system that is unknown to zsh developers. Please +F:report this to zsh-workers mailing list. diff --git a/configure.ac b/configure.ac index f2d65ecfc..2f1e0c41e 100644 --- a/configure.ac +++ b/configure.ac @@ -1928,6 +1928,7 @@ zsh_LIMIT_PRESENT(RLIMIT_SIGPENDING) zsh_LIMIT_PRESENT(RLIMIT_MSGQUEUE) zsh_LIMIT_PRESENT(RLIMIT_NICE) zsh_LIMIT_PRESENT(RLIMIT_RTPRIO) +zsh_LIMIT_PRESENT(RLIMIT_RTTIME) zsh_LIMIT_PRESENT(RLIMIT_POSIXLOCKS) zsh_LIMIT_PRESENT(RLIMIT_NPTS) zsh_LIMIT_PRESENT(RLIMIT_SWAP) -- cgit 1.4.1 From dd85abe825065f95ad568a235be1f280855100ab Mon Sep 17 00:00:00 2001 From: Jun-ichi Takimoto Date: Fri, 6 Mar 2020 20:14:21 +0900 Subject: 45509: fix typos in B01cd.ztst --- ChangeLog | 2 ++ Test/B01cd.ztst | 6 +++--- 2 files changed, 5 insertions(+), 3 deletions(-) (limited to 'Test') diff --git a/ChangeLog b/ChangeLog index 6735e224b..8113dd29d 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,7 @@ 2020-03-06 Jun-ichi Takimoto + * 45509: Test/B01cd.ztst: Fix typos. + * 45490 (+45495 and a test): .gitignore, Src/Builtins/rlimits.awk, Src/Builtins/rlimits.c, Src/Builtins/rlimits.mdd, Test/B12limit.ztst, configure.ac: diff --git a/Test/B01cd.ztst b/Test/B01cd.ztst index d903b7462..21e751dcb 100644 --- a/Test/B01cd.ztst +++ b/Test/B01cd.ztst @@ -70,7 +70,7 @@ # the expected status returned by the code when run, or - if it is # irrelevant. An optional set of single-letter flags follows the status # or -. The following are understood: -# . d Don't diff stdout against the expected stdout. +# d Don't diff stdout against the expected stdout. # D Don't diff stderr against the expected stderr. # q All redirection lines given in the test script (not the lines # actually produced by the test) are subject to ordinary quoted shell @@ -96,8 +96,8 @@ # itself. (The example below isn't particularly useful as errors with # `cd' are unusual.) # -# A couple of features aren't used in this file, but are usefuil in cases -# where features may not be available so should not be tested. They boh +# A couple of features aren't used in this file, but are useful in cases +# where features may not be available so should not be tested. They both # take the form of variables. Note that to keep the test framework simple # there is no magic in setting the variables: the chunk of code being # executed needs to avoid executing any test code by appropriate structure -- cgit 1.4.1