diff options
| author | tinywrkb | 2022-01-19 20:46:55 +0200 |
|---|---|---|
| committer | tinywrkb | 2022-01-19 20:46:55 +0200 |
| commit | b3a45dccb5352203899a8bb4d18decde6ff6ff08 (patch) | |
| tree | 578f17b415496683fb32b6508e204f24f2766102 | |
| parent | 442d37d9b006e30a52efc5de9ca55257063b312b (diff) | |
| download | aur-b3a45dccb5352203899a8bb4d18decde6ff6ff08.tar.gz | |
bump to 0.120-4: update duktape patch, merge meson fix, and disable check()
| -rw-r--r-- | .SRCINFO | 4 | ||||
| -rw-r--r-- | 0001-Add-duktape-as-javascript-engine.patch | 706 | ||||
| -rw-r--r-- | PKGBUILD | 24 |
3 files changed, 673 insertions, 61 deletions
@@ -1,7 +1,7 @@ pkgbase = polkit-duktape pkgdesc = polkit with duktape as the javascript engine pkgver = 0.120 - pkgrel = 3 + pkgrel = 4 url = https://www.freedesktop.org/wiki/Software/polkit/ arch = x86_64 license = LGPL @@ -21,6 +21,6 @@ pkgbase = polkit-duktape source = git+https://gitlab.freedesktop.org/polkit/polkit.git#commit=92b910ce2273daf6a76038f6bd764fa6958d4e8e source = 0001-Add-duktape-as-javascript-engine.patch sha256sums = SKIP - sha256sums = a064fe5738b15fe8ebeea2f9584e084d129403ab92e6d11032bd623ea59cbad7 + sha256sums = 518217b4dad71ac1662d271c89f2f3f40b3435e0f3530a9c81944644fed76534 pkgname = polkit-duktape diff --git a/0001-Add-duktape-as-javascript-engine.patch b/0001-Add-duktape-as-javascript-engine.patch index 1826fa8c3e84..b1fa87dbe6a7 100644 --- a/0001-Add-duktape-as-javascript-engine.patch +++ b/0001-Add-duktape-as-javascript-engine.patch @@ -4576,7 +4576,7 @@ index 23cf0d6..942415d 100644 GitLab -From ab6211465a1ac76f188bd0e08a4420cb66653c4a Mon Sep 17 00:00:00 2001 +From 4262c8a5c952e7f5d15d233c1cd2955086b622a9 Mon Sep 17 00:00:00 2001 From: Gustavo Lima Chaves <gustavo.chaves@microsoft.com> Date: Mon, 20 Sep 2021 17:17:26 -0700 Subject: [PATCH 16/17] duktape: implement runaway scripts killer timeout @@ -4601,8 +4601,10 @@ separate thread, to be killed after the runaway script killer's accorded timeout value, a reasonable approach. We have considered using glib wrappers for direct pthread usage, but that way would make it impossible to issue -pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, ...) and we want to -be paranoid in that regard. +pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, ...) natively, and +we want to be paranoid in that regard. Worse than that, they have no +exposure of pthread_cancel() either. We go for pthreads direct usage, +then. Fancy threading build system checks courtesy of Evgeny Grin. On Duktape, we don't get to err from the JS context (to be captured by the offending script), but to be forcibly killed on timeout scenarios, @@ -4617,60 +4619,631 @@ Finally, the script evaluation routine has been made to use duk_peval_lstring() (previously using _noresult variant), so to able to present the user with proper error messages, should any occur. -The original runaway script killer test has been adjusted to please -both JS backends. +NB: The original runaway script killer test has been adjusted to +please both JS backends and we now also require Duktape version >= +2.0.0 on meson builds as well (removing the code checks for previous +versions). Signed-off-by: Gustavo Lima Chaves <gustavo.chaves@microsoft.com> +Co-authored-by: Evgeny Grin <k2k@narod.ru> --- - meson.build | 1 + - src/polkitbackend/Makefile.am | 1 + - src/polkitbackend/meson.build | 2 + + buildutil/ax_pthread.m4 | 522 ++++++++++++++++++ + configure.ac | 8 +- + meson.build | 7 +- + src/polkitbackend/Makefile.am | 2 + + src/polkitbackend/meson.build | 3 + src/polkitbackend/polkitbackendcommon.h | 2 + - .../polkitbackendduktapeauthority.c | 304 +++++++++++++++--- + .../polkitbackendduktapeauthority.c | 329 +++++++++-- .../polkitbackendjsauthority.cpp | 10 +- .../etc/polkit-1/rules.d/10-testing.rules | 6 +- .../test-polkitbackendjsauthority.c | 2 +- - 8 files changed, 279 insertions(+), 49 deletions(-) + 10 files changed, 836 insertions(+), 55 deletions(-) + create mode 100644 buildutil/ax_pthread.m4 +diff --git a/buildutil/ax_pthread.m4 b/buildutil/ax_pthread.m4 +new file mode 100644 +index 0000000..9f35d13 +--- /dev/null ++++ b/buildutil/ax_pthread.m4 +@@ -0,0 +1,522 @@ ++# =========================================================================== ++# https://www.gnu.org/software/autoconf-archive/ax_pthread.html ++# =========================================================================== ++# ++# SYNOPSIS ++# ++# AX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]]) ++# ++# DESCRIPTION ++# ++# This macro figures out how to build C programs using POSIX threads. It ++# sets the PTHREAD_LIBS output variable to the threads library and linker ++# flags, and the PTHREAD_CFLAGS output variable to any special C compiler ++# flags that are needed. (The user can also force certain compiler ++# flags/libs to be tested by setting these environment variables.) ++# ++# Also sets PTHREAD_CC and PTHREAD_CXX to any special C compiler that is ++# needed for multi-threaded programs (defaults to the value of CC ++# respectively CXX otherwise). (This is necessary on e.g. AIX to use the ++# special cc_r/CC_r compiler alias.) ++# ++# NOTE: You are assumed to not only compile your program with these flags, ++# but also to link with them as well. For example, you might link with ++# $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS ++# $PTHREAD_CXX $CXXFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS ++# ++# If you are only building threaded programs, you may wish to use these ++# variables in your default LIBS, CFLAGS, and CC: ++# ++# LIBS="$PTHREAD_LIBS $LIBS" ++# CFLAGS="$CFLAGS $PTHREAD_CFLAGS" ++# CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS" ++# CC="$PTHREAD_CC" ++# CXX="$PTHREAD_CXX" ++# ++# In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant ++# has a nonstandard name, this macro defines PTHREAD_CREATE_JOINABLE to ++# that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX). ++# ++# Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the ++# PTHREAD_PRIO_INHERIT symbol is defined when compiling with ++# PTHREAD_CFLAGS. ++# ++# ACTION-IF-FOUND is a list of shell commands to run if a threads library ++# is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it ++# is not found. If ACTION-IF-FOUND is not specified, the default action ++# will define HAVE_PTHREAD. ++# ++# Please let the authors know if this macro fails on any platform, or if ++# you have any other suggestions or comments. This macro was based on work ++# by SGJ on autoconf scripts for FFTW (http://www.fftw.org/) (with help ++# from M. Frigo), as well as ac_pthread and hb_pthread macros posted by ++# Alejandro Forero Cuervo to the autoconf macro repository. We are also ++# grateful for the helpful feedback of numerous users. ++# ++# Updated for Autoconf 2.68 by Daniel Richard G. ++# ++# LICENSE ++# ++# Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu> ++# Copyright (c) 2011 Daniel Richard G. <skunk@iSKUNK.ORG> ++# Copyright (c) 2019 Marc Stevens <marc.stevens@cwi.nl> ++# ++# This program 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. ++# ++# This program 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, see <https://www.gnu.org/licenses/>. ++# ++# As a special exception, the respective Autoconf Macro's copyright owner ++# gives unlimited permission to copy, distribute and modify the configure ++# scripts that are the output of Autoconf when processing the Macro. You ++# need not follow the terms of the GNU General Public License when using ++# or distributing such scripts, even though portions of the text of the ++# Macro appear in them. The GNU General Public License (GPL) does govern ++# all other use of the material that constitutes the Autoconf Macro. ++# ++# This special exception to the GPL applies to versions of the Autoconf ++# Macro released by the Autoconf Archive. When you make and distribute a ++# modified version of the Autoconf Macro, you may extend this special ++# exception to the GPL to apply to your modified version as well. ++ ++#serial 31 ++ ++AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD]) ++AC_DEFUN([AX_PTHREAD], [ ++AC_REQUIRE([AC_CANONICAL_HOST]) ++AC_REQUIRE([AC_PROG_CC]) ++AC_REQUIRE([AC_PROG_SED]) ++AC_LANG_PUSH([C]) ++ax_pthread_ok=no ++ ++# We used to check for pthread.h first, but this fails if pthread.h ++# requires special compiler flags (e.g. on Tru64 or Sequent). ++# It gets checked for in the link test anyway. ++ ++# First of all, check if the user has set any of the PTHREAD_LIBS, ++# etcetera environment variables, and if threads linking works using ++# them: ++if test "x$PTHREAD_CFLAGS$PTHREAD_LIBS" != "x"; then ++ ax_pthread_save_CC="$CC" ++ ax_pthread_save_CFLAGS="$CFLAGS" ++ ax_pthread_save_LIBS="$LIBS" ++ AS_IF([test "x$PTHREAD_CC" != "x"], [CC="$PTHREAD_CC"]) ++ AS_IF([test "x$PTHREAD_CXX" != "x"], [CXX="$PTHREAD_CXX"]) ++ CFLAGS="$CFLAGS $PTHREAD_CFLAGS" ++ LIBS="$PTHREAD_LIBS $LIBS" ++ AC_MSG_CHECKING([for pthread_join using $CC $PTHREAD_CFLAGS $PTHREAD_LIBS]) ++ AC_LINK_IFELSE([AC_LANG_CALL([], [pthread_join])], [ax_pthread_ok=yes]) ++ AC_MSG_RESULT([$ax_pthread_ok]) ++ if test "x$ax_pthread_ok" = "xno"; then ++ PTHREAD_LIBS="" ++ PTHREAD_CFLAGS="" ++ fi ++ CC="$ax_pthread_save_CC" ++ CFLAGS="$ax_pthread_save_CFLAGS" ++ LIBS="$ax_pthread_save_LIBS" ++fi ++ ++# We must check for the threads library under a number of different ++# names; the ordering is very important because some systems ++# (e.g. DEC) have both -lpthread and -lpthreads, where one of the ++# libraries is broken (non-POSIX). ++ ++# Create a list of thread flags to try. Items with a "," contain both ++# C compiler flags (before ",") and linker flags (after ","). Other items ++# starting with a "-" are C compiler flags, and remaining items are ++# library names, except for "none" which indicates that we try without ++# any flags at all, and "pthread-config" which is a program returning ++# the flags for the Pth emulation library. ++ ++ax_pthread_flags="pthreads none -Kthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config" ++ ++# The ordering *is* (sometimes) important. Some notes on the ++# individual items follow: ++ ++# pthreads: AIX (must check this before -lpthread) ++# none: in case threads are in libc; should be tried before -Kthread and ++# other compiler flags to prevent continual compiler warnings ++# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h) ++# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads), Tru64 ++# (Note: HP C rejects this with "bad form for `-t' option") ++# -pthreads: Solaris/gcc (Note: HP C also rejects) ++# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it ++# doesn't hurt to check since this sometimes defines pthreads and ++# -D_REENTRANT too), HP C (must be checked before -lpthread, which ++# is present but should not be used directly; and before -mthreads, ++# because the compiler interprets this as "-mt" + "-hreads") ++# -mthreads: Mingw32/gcc, Lynx/gcc ++# pthread: Linux, etcetera ++# --thread-safe: KAI C++ ++# pthread-config: use pthread-config program (for GNU Pth library) ++ ++case $host_os in ++ ++ freebsd*) ++ ++ # -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able) ++ # lthread: LinuxThreads port on FreeBSD (also preferred to -pthread) ++ ++ ax_pthread_flags="-kthread lthread $ax_pthread_flags" ++ ;; ++ ++ hpux*) ++ ++ # From the cc(1) man page: "[-mt] Sets various -D flags to enable ++ # multi-threading and also sets -lpthread." ++ ++ ax_pthread_flags="-mt -pthread pthread $ax_pthread_flags" ++ ;; ++ ++ openedition*) ++ ++ # IBM z/OS requires a feature-test macro to be defined in order to ++ # enable POSIX threads at all, so give the user a hint if this is ++ # not set. (We don't define these ourselves, as they can affect ++ # other portions of the system API in unpredictable ways.) ++ ++ AC_EGREP_CPP([AX_PTHREAD_ZOS_MISSING], ++ [ ++# if !defined(_OPEN_THREADS) && !defined(_UNIX03_THREADS) ++ AX_PTHREAD_ZOS_MISSING ++# endif ++ ], ++ [AC_MSG_WARN([IBM z/OS requires -D_OPEN_THREADS or -D_UNIX03_THREADS to enable pthreads support.])]) ++ ;; ++ ++ solaris*) ++ ++ # On Solaris (at least, for some versions), libc contains stubbed ++ # (non-functional) versions of the pthreads routines, so link-based ++ # tests will erroneously succeed. (N.B.: The stubs are missing ++ # pthread_cleanup_push, or rather a function called by this macro, ++ # so we could check for that, but who knows whether they'll stub ++ # that too in a future libc.) So we'll check first for the ++ # standard Solaris way of linking pthreads (-mt -lpthread). ++ ++ ax_pthread_flags="-mt,-lpthread pthread $ax_pthread_flags" ++ ;; ++esac ++ ++# Are we compiling with Clang? ++ ++AC_CACHE_CHECK([whether $CC is Clang], ++ [ax_cv_PTHREAD_CLANG], ++ [ax_cv_PTHREAD_CLANG=no ++ # Note that Autoconf sets GCC=yes for Clang as well as GCC ++ if test "x$GCC" = "xyes"; then ++ AC_EGREP_CPP([AX_PTHREAD_CC_IS_CLANG], ++ [/* Note: Clang 2.7 lacks __clang_[a-z]+__ */ ++# if defined(__clang__) && defined(__llvm__) ++ AX_PTHREAD_CC_IS_CLANG ++# endif ++ ], ++ [ax_cv_PTHREAD_CLANG=yes]) ++ fi ++ ]) ++ax_pthread_clang="$ax_cv_PTHREAD_CLANG" ++ ++ ++# GCC generally uses -pthread, or -pthreads on some platforms (e.g. SPARC) ++ ++# Note that for GCC and Clang -pthread generally implies -lpthread, ++# except when -nostdlib is passed. ++# This is problematic using libtool to build C++ shared libraries with pthread: ++# [1] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25460 ++# [2] https://bugzilla.redhat.com/show_bug.cgi?id=661333 ++# [3] https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=468555 ++# To solve this, first try -pthread together with -lpthread for GCC ++ ++AS_IF([test "x$GCC" = "xyes"], ++ [ax_pthread_flags="-pthread,-lpthread -pthread -pthreads $ax_pthread_flags"]) ++ ++# Clang takes -pthread (never supported any other flag), but we'll try with -lpthread first ++ ++AS_IF([test "x$ax_pthread_clang" = "xyes"], ++ [ax_pthread_flags="-pthread,-lpthread -pthread"]) ++ ++ ++# The presence of a feature test macro requesting re-entrant function ++# definitions is, on some systems, a strong hint that pthreads support is ++# correctly enabled ++ ++case $host_os in ++ darwin* | hpux* | linux* | osf* | solaris*) ++ ax_pthread_check_macro="_REENTRANT" ++ ;; ++ ++ aix*) ++ ax_pthread_check_macro="_THREAD_SAFE" ++ ;; ++ ++ *) ++ ax_pthread_check_macro="--" ++ ;; ++esac ++AS_IF([test "x$ax_pthread_check_macro" = "x--"], ++ [ax_pthread_check_cond=0], ++ [ax_pthread_check_cond="!defined($ax_pthread_check_macro)"]) ++ ++ ++if test "x$ax_pthread_ok" = "xno"; then ++for ax_pthread_try_flag in $ax_pthread_flags; do ++ ++ case $ax_pthread_try_flag in ++ none) ++ AC_MSG_CHECKING([whether pthreads work without any flags]) ++ ;; ++ ++ *,*) ++ PTHREAD_CFLAGS=`echo $ax_pthread_try_flag | sed "s/^\(.*\),\(.*\)$/\1/"` ++ PTHREAD_LIBS=`echo $ax_pthread_try_flag | sed "s/^\(.*\),\(.*\)$/\2/"` ++ AC_MSG_CHECKING([whether pthreads work with "$PTHREAD_CFLAGS" and "$PTHREAD_LIBS"]) ++ ;; ++ ++ -*) ++ AC_MSG_CHECKING([whether pthreads work with $ax_pthread_try_flag]) ++ PTHREAD_CFLAGS="$ax_pthread_try_flag" ++ ;; ++ ++ pthread-config) ++ AC_CHECK_PROG([ax_pthread_config], [pthread-config], [yes], [no]) ++ AS_IF([test "x$ax_pthread_config" = "xno"], [continue]) ++ PTHREAD_CFLAGS="`pthread-config --cflags`" ++ PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`" ++ ;; ++ ++ *) ++ AC_MSG_CHECKING([for the pthreads library -l$ax_pthread_try_flag]) ++ PTHREAD_LIBS="-l$ax_pthread_try_flag" ++ ;; ++ esac ++ ++ ax_pthread_save_CFLAGS="$CFLAGS" ++ ax_pthread_save_LIBS="$LIBS" ++ CFLAGS="$CFLAGS $PTHREAD_CFLAGS" ++ LIBS="$PTHREAD_LIBS $LIBS" ++ ++ # Check for various functions. We must include pthread.h, ++ # since some functions may be macros. (On the Sequent, we ++ # need a special flag -Kthread to make this header compile.) ++ # We check for pthread_join because it is in -lpthread on IRIX ++ # while pthread_create is in libc. We check for pthread_attr_init ++ # due to DEC craziness with -lpthreads. We check for ++ # pthread_cleanup_push because it is one of the few pthread ++ # functions on Solaris that doesn't have a non-functional libc stub. ++ # We try pthread_create on general principles. ++ ++ AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h> ++# if $ax_pthread_check_cond ++# error "$ax_pthread_check_macro must be defined" ++# endif ++ static void *some_global = NULL; ++ static void routine(void *a) ++ { ++ /* To avoid any unused-parameter or ++ unused-but-set-parameter warning. */ ++ some_global = a; ++ } ++ static void *start_routine(void *a) { return a; }], ++ [pthread_t th; pthread_attr_t attr; ++ pthread_create(&th, 0, start_routine, 0); ++ pthread_join(th, 0); ++ pthread_attr_init(&attr); ++ pthread_cleanup_push(routine, 0); ++ pthread_cleanup_pop(0) /* ; */])], ++ [ax_pthread_ok=yes], ++ []) ++ ++ CFLAGS="$ax_pthread_save_CFLAGS" ++ LIBS="$ax_pthread_save_LIBS" ++ ++ AC_MSG_RESULT([$ax_pthread_ok]) ++ AS_IF([test "x$ax_pthread_ok" = "xyes"], [break]) ++ ++ PTHREAD_LIBS="" ++ PTHREAD_CFLAGS="" ++done ++fi ++ ++ ++# Clang needs special handling, because older versions handle the -pthread ++# option in a rather... idiosyncratic way ++ ++if test "x$ax_pthread_clang" = "xyes"; then ++ ++ # Clang takes -pthread; it has never supported any other flag ++ ++ # (Note 1: This will need to be revisited if a system that Clang ++ # supports has POSIX threads in a separate library. This tends not ++ # to be the way of modern systems, but it's conceivable.) ++ ++ # (Note 2: On some systems, notably Darwin, -pthread is not needed ++ # to get POSIX threads support; the API is always present and ++ # active. We could reasonably leave PTHREAD_CFLAGS empty. But ++ # -pthread does define _REENTRANT, and while the Darwin headers ++ # ignore this macro, third-party headers might not.) ++ ++ # However, older versions of Clang make a point of warning the user ++ # that, in an invocation where only linking and no compilation is ++ # taking place, the -pthread option has no effect ("argument unused ++ # during compilation"). They expect -pthread to be passed in only ++ # when source code is being compiled. ++ # ++ # Problem is, this is at odds with the way Automake and most other ++ # C build frameworks function, which is that the same flags used in ++ # compilation (CFLAGS) are also used in linking. Many systems ++ # supported by AX_PTHREAD require exactly this for POSIX threads ++ # support, and in fact it is often not straightforward to specify a ++ # flag that is used only in the compilation phase and not in ++ # linking. Such a scenario is extremely rare in practice. ++ # ++ # Even though use of the -pthread flag in linking would only print ++ # a warning, this can be a nuisance for well-run software projects ++ # that build with -Werror. So if the active version of Clang has ++ # this misfeature, we search for an option to squash it. ++ ++ AC_CACHE_CHECK([whether Clang needs flag to prevent "argument unused" warning when linking with -pthread], ++ [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG], ++ [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG=unknown ++ # Create an alternate version of $ac_link that compiles and ++ # links in two steps (.c -> .o, .o -> exe) instead of one ++ # (.c -> exe), because the warning occurs only in the second ++ # step ++ ax_pthread_save_ac_link="$ac_link" ++ ax_pthread_sed='s/conftest\.\$ac_ext/conftest.$ac_objext/g' ++ ax_pthread_link_step=`AS_ECHO(["$ac_link"]) | sed "$ax_pthread_sed"` ++ ax_pthread_2step_ac_link="($ac_compile) && (echo ==== >&5) && ($ax_pthread_link_step)" ++ ax_pthread_save_CFLAGS="$CFLAGS" ++ for ax_pthread_try in '' -Qunused-arguments -Wno-unused-command-line-argument unknown; do ++ AS_IF([test "x$ax_pthread_try" = "xunknown"], [break]) ++ CFLAGS="-Werror -Wunknown-warning-option $ax_pthread_try -pthread $ax_pthread_save_CFLAGS" ++ ac_link="$ax_pthread_save_ac_link" ++ AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])], ++ [ac_link="$ax_pthread_2step_ac_link" ++ AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])], ++ [break]) ++ ]) ++ done ++ ac_link="$ax_pthread_save_ac_link" ++ CFLAGS="$ax_pthread_save_CFLAGS" ++ AS_IF([test "x$ax_pthread_try" = "x"], [ax_pthread_try=no]) ++ ax_cv_PTHREAD_CLANG_NO_WARN_FLAG="$ax_pthread_try" ++ ]) ++ ++ case "$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" in ++ no | unknown) ;; ++ *) PTHREAD_CFLAGS="$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG $PTHREAD_CFLAGS" ;; ++ esac ++ ++fi # $ax_pthread_clang = yes ++ ++ ++ ++# Various other checks: ++if test "x$ax_pthread_ok" = "xyes"; then ++ ax_pthread_save_CFLAGS="$CFLAGS" ++ ax_pthread_save_LIBS="$LIBS" ++ CFLAGS="$CFLAGS $PTHREAD_CFLAGS" ++ LIBS="$PTHREAD_LIBS $LIBS" ++ ++ # Detect AIX lossage: JOINABLE attribute is called UNDETACHED. ++ AC_CACHE_CHECK([for joinable pthread attribute], ++ [ax_cv_PTHREAD_JOINABLE_ATTR], ++ [ax_cv_PTHREAD_JOINABLE_ATTR=unknown ++ for ax_pthread_attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do ++ AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>], ++ [int attr = $ax_pthread_attr; return attr /* ; */])], ++ [ax_cv_PTHREAD_JOINABLE_ATTR=$ax_pthread_attr; break], ++ []) ++ done ++ ]) ++ AS_IF([test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xunknown" && \ ++ test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xPTHREAD_CREATE_JOINABLE" && \ ++ test "x$ax_pthread_joinable_attr_defined" != "xyes"], ++ [AC_DEFINE_UNQUOTED([PTHREAD_CREATE_JOINABLE], ++ [$ax_cv_PTHREAD_JOINABLE_ATTR], ++ [Define to necessary symbol if this constant ++ uses a non-standard name on your system.]) ++ ax_pthread_joinable_attr_defined=yes ++ ]) ++ ++ AC_CACHE_CHECK([whether more special flags are required for pthreads], ++ [ax_cv_PTHREAD_SPECIAL_FLAGS], ++ [ax_cv_PTHREAD_SPECIAL_FLAGS=no ++ case $host_os in ++ solaris*) ++ ax_cv_PTHREAD_SPECIAL_FLAGS="-D_POSIX_PTHREAD_SEMANTICS" ++ ;; ++ esac ++ ]) ++ AS_IF([test "x$ax_cv_PTHREAD_SPECIAL_FLAGS" != "xno" && \ ++ test "x$ax_pthread_special_flags_added" != "xyes"], ++ [PTHREAD_CFLAGS="$ax_cv_PTHREAD_SPECIAL_FLAGS $PTHREAD_CFLAGS" ++ ax_pthread_special_flags_added=yes]) ++ ++ AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT], ++ [ax_cv_PTHREAD_PRIO_INHERIT], ++ [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <pthread.h>]], ++ [[int i = PTHREAD_PRIO_INHERIT; ++ return i;]])], ++ [ax_cv_PTHREAD_PRIO_INHERIT=yes], ++ [ax_cv_PTHREAD_PRIO_INHERIT=no]) ++ ]) ++ AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes" && \ ++ test "x$ax_pthread_prio_inherit_defined" != "xyes"], ++ [AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], [1], [Have PTHREAD_PRIO_INHERIT.]) ++ ax_pthread_prio_inherit_defined=yes ++ ]) ++ ++ CFLAGS="$ax_pthread_save_CFLAGS" ++ LIBS="$ax_pthread_save_LIBS" ++ ++ # More AIX lossage: compile with *_r variant ++ if test "x$GCC" != "xyes"; then ++ case $host_os in ++ aix*) ++ AS_CASE(["x/$CC"], ++ [x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6], ++ [#handle absolute path differently from PATH based program lookup ++ AS_CASE(["x$CC"], ++ [x/*], ++ [ ++ AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"]) ++ AS_IF([test "x${CXX}" != "x"], [AS_IF([AS_EXECUTABLE_P([${CXX}_r])],[PTHREAD_CXX="${CXX}_r"])]) ++ ], ++ [ ++ AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC]) ++ AS_IF([test "x${CXX}" != "x"], [AC_CHECK_PROGS([PTHREAD_CXX],[${CXX}_r],[$CXX])]) ++ ] ++ ) ++ ]) ++ ;; ++ esac ++ fi ++fi ++ ++test -n "$PTHREAD_CC" || PTHREAD_CC="$CC" ++test -n "$PTHREAD_CXX" || PTHREAD_CXX="$CXX" ++ ++AC_SUBST([PTHREAD_LIBS]) ++AC_SUBST([PTHREAD_CFLAGS]) ++AC_SUBST([PTHREAD_CC]) ++AC_SUBST([PTHREAD_CXX]) ++ ++# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND: ++if test "x$ax_pthread_ok" = "xyes"; then ++ ifelse([$1],,[AC_DEFINE([HAVE_PTHREAD],[1],[Define if you have POSIX threads libraries and header files.])],[$1]) ++ : ++else ++ ax_pthread_ok=no ++ $2 ++fi ++AC_LANG_POP ++])dnl AX_PTHREAD +diff --git a/configure.ac b/configure.ac +index 5a03593..e182238 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -85,7 +85,7 @@ dnl - Check javascript backend + dnl --------------------------------------------------------------------------- + AC_ARG_WITH(duktape, AS_HELP_STRING([--with-duktape],[Use Duktape as javascript backend]),with_duktape=yes,with_duktape=no) + AS_IF([test x${with_duktape} == xyes], [ +- PKG_CHECK_MODULES(LIBJS, [duktape >= 2.0.0 ]) ++ PKG_CHECK_MODULES(LIBJS, [duktape >= 2.2.0 ]) + AC_SUBST(LIBJS_CFLAGS) + AC_SUBST(LIBJS_LIBS) + ], [ +@@ -111,6 +111,12 @@ AC_CHECK_LIB(expat,XML_ParserCreate,[EXPAT_LIBS="-lexpat"], + [AC_MSG_ERROR([Can't find expat library. Please install expat.])]) + AC_SUBST(EXPAT_LIBS) + ++AX_PTHREAD([], [AC_MSG_ERROR([Cannot find the way to enable pthread support.])]) ++LIBS="$PTHREAD_LIBS $LIBS" ++CFLAGS="$CFLAGS $PTHREAD_CFLAGS" ++CC="$PTHREAD_CC" ++AC_CHECK_FUNCS([pthread_condattr_setclock]) ++ + AC_CHECK_FUNCS(clearenv fdatasync) + + if test "x$GCC" = "xyes"; then diff --git a/meson.build b/meson.build -index 4e44723..46956e3 100644 +index 4e44723..ad9ab07 100644 --- a/meson.build +++ b/meson.build -@@ -137,6 +137,7 @@ js_engine = get_option('js_engine') +@@ -133,10 +133,15 @@ expat_dep = dependency('expat') + assert(cc.has_header('expat.h', dependencies: expat_dep), 'Can\'t find expat.h. Please install expat.') + assert(cc.has_function('XML_ParserCreate', dependencies: expat_dep), 'Can\'t find expat library. Please install expat.') + ++duktape_req_version = '>= 2.2.0' ++ + js_engine = get_option('js_engine') if js_engine == 'duktape' - js_dep = dependency('duktape') +- js_dep = dependency('duktape') ++ js_dep = dependency('duktape', version: duktape_req_version) libm_dep = cc.find_library('m') -+ libpthread_dep = cc.find_library('pthread') ++ thread_dep = dependency('threads') ++ func = 'pthread_condattr_setclock' ++ config_h.set('HAVE_' + func.to_upper(), cc.has_function(func, prefix : '#include <pthread.h>')) elif js_engine == 'mozjs' js_dep = dependency('mozjs-78') endif diff --git a/src/polkitbackend/Makefile.am b/src/polkitbackend/Makefile.am -index 6a8b4ae..1c0591c 100644 +index 6a8b4ae..935fb98 100644 --- a/src/polkitbackend/Makefile.am +++ b/src/polkitbackend/Makefile.am -@@ -17,6 +17,7 @@ AM_CPPFLAGS = \ +@@ -17,6 +17,8 @@ AM_CPPFLAGS = \ -DPACKAGE_LIB_DIR=\""$(libdir)"\" \ -D_POSIX_PTHREAD_SEMANTICS \ -D_REENTRANT \ -+ -D_XOPEN_SOURCE=600 \ ++ -D_XOPEN_SOURCE=700 \ ++ -D_GNU_SOURCE=1 \ $(NULL) noinst_LTLIBRARIES=libpolkit-backend-1.la diff --git a/src/polkitbackend/meson.build b/src/polkitbackend/meson.build -index 9ec01b2..129f9db 100644 +index 9ec01b2..266f280 100644 --- a/src/polkitbackend/meson.build +++ b/src/polkitbackend/meson.build -@@ -29,11 +29,13 @@ c_flags = [ +@@ -29,11 +29,14 @@ c_flags = [ '-D_POLKIT_BACKEND_COMPILATION', '-DPACKAGE_DATA_DIR="@0@"'.format(pk_prefix / pk_datadir), '-DPACKAGE_SYSCONF_DIR="@0@"'.format(pk_prefix / pk_sysconfdir), -+ '-D_XOPEN_SOURCE=600', ++ '-D_XOPEN_SOURCE=700', ++ '-D_GNU_SOURCE=1', ] if js_engine == 'duktape' sources += files('polkitbackendduktapeauthority.c') deps += libm_dep -+ deps += libpthread_dep ++ deps += thread_dep elif js_engine == 'mozjs' sources += files('polkitbackendjsauthority.cpp') endif @@ -4688,7 +5261,7 @@ index 6d0d267..dd700fc 100644 extern "C" { #endif diff --git a/src/polkitbackend/polkitbackendduktapeauthority.c b/src/polkitbackend/polkitbackendduktapeauthority.c -index a2b4420..c4701f9 100644 +index a2b4420..c89dbcf 100644 --- a/src/polkitbackend/polkitbackendduktapeauthority.c +++ b/src/polkitbackend/polkitbackendduktapeauthority.c @@ -21,6 +21,8 @@ @@ -4706,15 +5279,15 @@ index a2b4420..c4701f9 100644 duk_context *cx; + + pthread_t runaway_killer_thread; -+}; -+ + }; + +enum +{ + RUNAWAY_KILLER_THREAD_EXIT_STATUS_UNSET, + RUNAWAY_KILLER_THREAD_EXIT_STATUS_SUCCESS, + RUNAWAY_KILLER_THREAD_EXIT_STATUS_FAILURE, - }; - ++}; ++ +static gboolean execute_script_with_runaway_killer(PolkitBackendJsAuthority *authority, + const gchar *filename); + @@ -4802,7 +5375,7 @@ index a2b4420..c4701f9 100644 duk_eval_string (cx, init_js); if (authority->priv->rules_dirs == NULL) -@@ -510,6 +508,229 @@ push_action_and_details (duk_context *cx, +@@ -510,6 +508,250 @@ push_action_and_details (duk_context *cx, /* ---------------------------------------------------------------------------------------------------- */ @@ -4829,7 +5402,6 @@ index a2b4420..c4701f9 100644 + goto err; + } + -+#if (DUK_VERSION >= 20000) + GFile *file = g_file_new_for_path(ctx->filename); + char *contents; + gsize len; @@ -4846,9 +5418,6 @@ index a2b4420..c4701f9 100644 + /* evaluate the script, trying to print context in any syntax errors + found */ + if (duk_peval_lstring(cx, contents, len) != 0) -+#else -+ if (duk_peval_file(cx, ctx->filename) != 0) -+#endif + { + polkit_backend_authority_log(POLKIT_BACKEND_AUTHORITY(ctx->authority), + "Error compiling script %s: %s", ctx->filename, @@ -4856,17 +5425,13 @@ index a2b4420..c4701f9 100644 + duk_pop(cx); + goto free_err; + } -+#if (DUK_VERSION >= 20000) + g_free(contents); -+#endif + + ctx->ret = RUNAWAY_KILLER_THREAD_EXIT_STATUS_SUCCESS; + goto end; + +free_err: -+#if (DUK_VERSION >= 20000) + g_free(contents); -+#endif +err: + ctx->ret = RUNAWAY_KILLER_THREAD_EXIT_STATUS_FAILURE; +end: @@ -4916,6 +5481,20 @@ index a2b4420..c4701f9 100644 + return NULL; +} + ++#if defined (HAVE_PTHREAD_CONDATTR_SETCLOCK) ++# if defined(CLOCK_MONOTONIC) ++# define PK_CLOCK CLOCK_MONOTONIC ++# elif defined(CLOCK_BOOTTIME) ++# define PK_CLOCK CLOCK_BOOTTIME ++# else ++ /* No suitable clock */ ++# undef HAVE_PTHREAD_CONDATTR_SETCLOCK ++# define PK_CLOCK CLOCK_REALTIME ++# endif ++#else /* ! HAVE_PTHREAD_CONDATTR_SETCLOCK */ ++# define PK_CLOCK CLOCK_REALTIME ++#endif /* ! HAVE_PTHREAD_CONDATTR_SETCLOCK */ ++ +static gboolean +runaway_killer_common(PolkitBackendJsAuthority *authority, RunawayKillerCtx *ctx, void *js_context_cb (void *user_data)) +{ @@ -4924,37 +5503,40 @@ index a2b4420..c4701f9 100644 + pthread_condattr_t attr; + struct timespec abs_time; + ++#ifdef HAVE_PTHREAD_CONDATTR_SETCLOCK + if ((pthread_err = pthread_condattr_init(&attr))) { + polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority), + "Error initializing condition variable attributes: %s", + strerror(pthread_err)); + return FALSE; + } -+ if ((pthread_err = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC))) { ++ if ((pthread_err = pthread_condattr_setclock(&attr, PK_CLOCK))) { + polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority), + "Error setting condition variable attributes: %s", + strerror(pthread_err)); -+ return FALSE; ++ goto err_clean_condattr; + } + /* Init again, with needed attr */ + if ((pthread_err = pthread_cond_init(&ctx->cond, &attr))) { + polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority), + "Error initializing condition variable: %s", + strerror(pthread_err)); -+ return FALSE; ++ goto err_clean_condattr; + } ++#endif ++ + if ((pthread_err = pthread_mutex_lock(&ctx->mutex))) { + polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority), + "Error locking mutex: %s", + strerror(pthread_err)); -+ return FALSE; ++ goto err_clean_cond; + } + -+ if (clock_gettime(CLOCK_MONOTONIC_COARSE, &abs_time)) { ++ if (clock_gettime(PK_CLOCK, &abs_time)) { + polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority), + "Error getting system's monotonic time: %s", + strerror(errno)); -+ return FALSE; ++ goto err_clean_cond; + } + abs_time.tv_sec += RUNAWAY_KILLER_TIMEOUT; + @@ -4963,7 +5545,7 @@ index a2b4420..c4701f9 100644 + polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority), + "Error creating runaway JS killer thread: %s", + strerror(pthread_err)); -+ return FALSE; ++ goto err_clean_cond; + } + + while (ctx->ret == RUNAWAY_KILLER_THREAD_EXIT_STATUS_UNSET) /* loop to treat spurious wakeups */ @@ -4971,7 +5553,9 @@ index a2b4420..c4701f9 100644 + cancel = TRUE; + + /* Log that we are terminating the script */ -+ polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority), "Terminating runaway script"); ++ polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority), ++ "Terminating runaway script after %d seconds", ++ RUNAWAY_KILLER_TIMEOUT); + + break; + } @@ -4980,7 +5564,7 @@ index a2b4420..c4701f9 100644 + polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority), + "Error unlocking mutex: %s", + strerror(pthread_err)); -+ return FALSE; ++ goto err_clean_cond; + } + + if (cancel) { @@ -4988,17 +5572,27 @@ index a2b4420..c4701f9 100644 + polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority), + "Error cancelling runaway JS killer thread: %s", + strerror(pthread_err)); -+ return FALSE; ++ goto err_clean_cond; + } + } + if ((pthread_err = pthread_join (authority->priv->runaway_killer_thread, NULL))) { + polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority), + "Error joining runaway JS killer thread: %s", + strerror(pthread_err)); -+ return FALSE; ++ goto err_clean_cond; + } + + return ctx->ret == RUNAWAY_KILLER_THREAD_EXIT_STATUS_SUCCESS; ++ ++ err_clean_cond: ++#ifdef HAVE_PTHREAD_CONDATTR_SETCLOCK ++ pthread_cond_destroy(&ctx->cond); ++#endif ++ err_clean_condattr: ++#ifdef HAVE_PTHREAD_CONDATTR_SETCLOCK ++ pthread_condattr_destroy(&attr); ++#endif ++ return FALSE; +} + +/* Blocking for at most RUNAWAY_KILLER_TIMEOUT */ @@ -5032,7 +5626,7 @@ index a2b4420..c4701f9 100644 /* ---------------------------------------------------------------------------------------------------- */ GList * -@@ -557,13 +778,8 @@ polkit_backend_common_js_authority_get_admin_auth_identities (PolkitBackendInter +@@ -557,13 +799,8 @@ polkit_backend_common_js_authority_get_admin_auth_identities (PolkitBackendInter goto out; } @@ -5048,7 +5642,7 @@ index a2b4420..c4701f9 100644 ret_str = duk_require_string (cx, -1); -@@ -643,15 +859,15 @@ polkit_backend_common_js_authority_check_authorization_sync (PolkitBackendIntera +@@ -643,15 +880,15 @@ polkit_backend_common_js_authority_check_authorization_sync (PolkitBackendIntera goto out; } @@ -5067,10 +5661,22 @@ index a2b4420..c4701f9 100644 + goto out; if (duk_is_null(cx, -1)) { -+ /* this fine, means there was no match, use implicit authorizations */ ++ /* this is fine, means there was no match, use implicit authorizations */ good = TRUE; goto out; } +@@ -690,11 +927,7 @@ js_polkit_log (duk_context *cx) + static duk_ret_t + js_polkit_spawn (duk_context *cx) + { +-#if (DUK_VERSION >= 20000) + duk_ret_t ret = DUK_RET_ERROR; +-#else +- duk_ret_t ret = DUK_RET_INTERNAL_ERROR; +-#endif + gchar *standard_output = NULL; + gchar *standard_error = NULL; + gint exit_status; diff --git a/src/polkitbackend/polkitbackendjsauthority.cpp b/src/polkitbackend/polkitbackendjsauthority.cpp index e28091d..11e91c0 100644 --- a/src/polkitbackend/polkitbackendjsauthority.cpp @@ -5136,7 +5742,7 @@ index f97e0e0..2103b17 100644 GitLab -From 1cf03642a88ee5a08055f2549437f7d61373c66d Mon Sep 17 00:00:00 2001 +From 478bcc0b6b4fb44d4199c475d1581d78a8b6c30b Mon Sep 17 00:00:00 2001 From: Gustavo Lima Chaves <gustavo.chaves@microsoft.com> Date: Thu, 28 Oct 2021 10:04:53 -0700 Subject: [PATCH 17/17] duktape: document runaway behavior @@ -1,10 +1,9 @@ # Maintainer: tinywrkb <tinywrkb@gmail.com> # Contributor: Jan de Groot <jgc@archlinux.org> -_pkgname=polkit -pkgname=${_pkgname}-duktape +pkgname=polkit-duktape pkgver=0.120 -pkgrel=3 +pkgrel=4 pkgdesc="polkit with duktape as the javascript engine" arch=(x86_64) license=(LGPL) @@ -19,15 +18,22 @@ _commit=92b910ce2273daf6a76038f6bd764fa6958d4e8e # tags/0.120 source=("git+https://gitlab.freedesktop.org/polkit/polkit.git#commit=$_commit" "0001-Add-duktape-as-javascript-engine.patch") sha256sums=('SKIP' - 'a064fe5738b15fe8ebeea2f9584e084d129403ab92e6d11032bd623ea59cbad7') + '518217b4dad71ac1662d271c89f2f3f40b3435e0f3530a9c81944644fed76534') pkgver() { - cd $_pkgname + cd polkit git describe --tags | sed 's/-/+/g' } prepare() { - cd $_pkgname + cd polkit + + # https://gitlab.freedesktop.org/polkit/polkit/-/merge_requests/99 + git remote add upstream https://gitlab.freedesktop.org/polkit/polkit.git + git fetch upstream merge-requests/99/merge + git merge --no-commit --squash FETCH_HEAD + + # https://gitlab.freedesktop.org/polkit/polkit/-/merge_requests/97 patch -p1 -i ../0001-Add-duktape-as-javascript-engine.patch } @@ -46,9 +52,9 @@ build() { meson compile -C build } -check() { - meson test -C build --print-errorlogs -} +#check() { +# meson test -C build --print-errorlogs +#} package() { meson install -C build --destdir "$pkgdir" |