From unknown Sat Jun 14 03:56:08 2025 X-Loop: help-debbugs@gnu.org Subject: [bug#54485] [PATCH] gnu: Add guile-with-openat. Resent-From: Maxime Devos Original-Sender: "Debbugs-submit" Resent-CC: guix-patches@gnu.org Resent-Date: Sun, 20 Mar 2022 21:52:02 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: report 54485 X-GNU-PR-Package: guix-patches X-GNU-PR-Keywords: patch To: 54485@debbugs.gnu.org Cc: Maxime Devos X-Debbugs-Original-To: guix-patches@gnu.org Received: via spool by submit@debbugs.gnu.org id=B.164781306732513 (code B ref -1); Sun, 20 Mar 2022 21:52:02 +0000 Received: (at submit) by debbugs.gnu.org; 20 Mar 2022 21:51:07 +0000 Received: from localhost ([127.0.0.1]:35244 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1nW3S7-0008SL-Px for submit@debbugs.gnu.org; Sun, 20 Mar 2022 17:51:07 -0400 Received: from lists.gnu.org ([209.51.188.17]:60264) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1nW3S6-0008S9-I9 for submit@debbugs.gnu.org; Sun, 20 Mar 2022 17:51:06 -0400 Received: from eggs.gnu.org ([209.51.188.92]:48572) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1nW3S6-0006mG-1V for guix-patches@gnu.org; Sun, 20 Mar 2022 17:51:06 -0400 Received: from [2a02:1800:110:4::f00:1a] (port=43906 helo=albert.telenet-ops.be) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1nW3S0-0006Tj-ID for guix-patches@gnu.org; Sun, 20 Mar 2022 17:51:05 -0400 Received: from localhost.localdomain ([IPv6:2a02:1811:8c09:9d00:3c5f:2eff:feb0:ba5a]) by albert.telenet-ops.be with bizsmtp id 8lqw2700F4UW6Th06lqwFY; Sun, 20 Mar 2022 22:50:57 +0100 From: Maxime Devos Date: Sun, 20 Mar 2022 21:50:31 +0000 Message-Id: <20220320215031.306710-1-maximedevos@telenet.be> X-Mailer: git-send-email 2.34.0 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=telenet.be; s=r22; t=1647813057; bh=rSriJoGtdNaL9qEhJ9h/P2+KUDvK8MAzCdUn+/HzB9s=; h=From:To:Cc:Subject:Date; b=Ex7YhDpO3XqE6GWq5/ovV8XembRerMdP/wDRfILvYzCoyA+zqgKUVBDYbOrqEsqCk KwSfFjrFgSXB0bPWEmUoMl0Wp1l3AuZzYrNSEXTRYWqFGhUHHHEk/rNtMcooW71V7t n8O6r6n59mi2BtWmiON5s1lOeJTgiT8Q0nGibJrM1VHQP9iwaSyx8r+QWrPsGICjU9 u6gvjOqgNQiPLyYuz72/FprS61DuQnfrXMBXhfVkGoylbcdZslEAxL1EiEni6r7kPV LDX0XpBWMTpu1AsZ0eR+PPOpJdpqKgHzuuK6IKOGqsvBKdjDl2d18LZnK6xp7d+ERX KOSpE5V8tmcIw== X-Host-Lookup-Failed: Reverse DNS lookup failed for 2a02:1800:110:4::f00:1a (failed) Received-SPF: pass client-ip=2a02:1800:110:4::f00:1a; envelope-from=maximedevos@telenet.be; helo=albert.telenet-ops.be X-Spam_score_int: -15 X-Spam_score: -1.6 X-Spam_bar: - X-Spam_report: (-1.6 / 5.0 requ) BAYES_00=-1.9, DKIM_INVALID=0.1, DKIM_SIGNED=0.1, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_LOW=-0.7, RDNS_NONE=0.793, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" XXX Don't apply yet, let's wait for "./pre-inst-env guix build guile-with-openat" to complete first. This will allow us to work on resolving the >1 year publicly known privilege escalation, see . * gnu/packages/guile.scm (guile-with-openat): New variable. --- gnu/local.mk | 14 + gnu/packages/guile.scm | 33 +- .../patches/guile-openat-and-friends-01.patch | 193 +++++++++++ .../patches/guile-openat-and-friends-02.patch | 219 ++++++++++++ .../patches/guile-openat-and-friends-03.patch | 269 +++++++++++++++ .../patches/guile-openat-and-friends-04.patch | 142 ++++++++ .../patches/guile-openat-and-friends-05.patch | 159 +++++++++ .../patches/guile-openat-and-friends-06.patch | 37 +++ .../patches/guile-openat-and-friends-07.patch | 40 +++ .../patches/guile-openat-and-friends-08.patch | 240 +++++++++++++ .../patches/guile-openat-and-friends-09.patch | 173 ++++++++++ .../patches/guile-openat-and-friends-10.patch | 204 ++++++++++++ .../patches/guile-openat-and-friends-11.patch | 130 ++++++++ .../patches/guile-openat-and-friends-12.patch | 238 +++++++++++++ .../patches/guile-openat-and-friends-13.patch | 314 ++++++++++++++++++ 15 files changed, 2404 insertions(+), 1 deletion(-) create mode 100644 gnu/packages/patches/guile-openat-and-friends-01.patch create mode 100644 gnu/packages/patches/guile-openat-and-friends-02.patch create mode 100644 gnu/packages/patches/guile-openat-and-friends-03.patch create mode 100644 gnu/packages/patches/guile-openat-and-friends-04.patch create mode 100644 gnu/packages/patches/guile-openat-and-friends-05.patch create mode 100644 gnu/packages/patches/guile-openat-and-friends-06.patch create mode 100644 gnu/packages/patches/guile-openat-and-friends-07.patch create mode 100644 gnu/packages/patches/guile-openat-and-friends-08.patch create mode 100644 gnu/packages/patches/guile-openat-and-friends-09.patch create mode 100644 gnu/packages/patches/guile-openat-and-friends-10.patch create mode 100644 gnu/packages/patches/guile-openat-and-friends-11.patch create mode 100644 gnu/packages/patches/guile-openat-and-friends-12.patch create mode 100644 gnu/packages/patches/guile-openat-and-friends-13.patch diff --git a/gnu/local.mk b/gnu/local.mk index 1252643dc0..40dd8c9c55 100644 --- a/gnu/local.mk +++ b/gnu/local.mk @@ -49,6 +49,7 @@ # Copyright © 2021 Simon Tournier # Copyright © 2022 Daniel Meißner # Copyright © 2022 Remco van 't Veer +# Copyright © 2022 Maxime Devos # # This file is part of GNU Guix. # @@ -1235,6 +1236,19 @@ dist_patch_DATA = \ %D%/packages/patches/guile-fibers-wait-for-io-readiness.patch \ %D%/packages/patches/guile-gdbm-ffi-support-gdbm-1.14.patch \ %D%/packages/patches/guile-git-adjust-for-libgit2-1.2.0.patch \ + %D%/packages/patches/guile-openat-and-friends-01.patch \ + %D%/packages/patches/guile-openat-and-friends-02.patch \ + %D%/packages/patches/guile-openat-and-friends-03.patch \ + %D%/packages/patches/guile-openat-and-friends-04.patch \ + %D%/packages/patches/guile-openat-and-friends-05.patch \ + %D%/packages/patches/guile-openat-and-friends-06.patch \ + %D%/packages/patches/guile-openat-and-friends-07.patch \ + %D%/packages/patches/guile-openat-and-friends-08.patch \ + %D%/packages/patches/guile-openat-and-friends-09.patch \ + %D%/packages/patches/guile-openat-and-friends-10.patch \ + %D%/packages/patches/guile-openat-and-friends-11.patch \ + %D%/packages/patches/guile-openat-and-friends-12.patch \ + %D%/packages/patches/guile-openat-and-friends-13.patch \ %D%/packages/patches/guile-present-coding.patch \ %D%/packages/patches/guile-rsvg-pkgconfig.patch \ %D%/packages/patches/guile-emacs-fix-configure.patch \ diff --git a/gnu/packages/guile.scm b/gnu/packages/guile.scm index f74a389da5..640e065422 100644 --- a/gnu/packages/guile.scm +++ b/gnu/packages/guile.scm @@ -16,7 +16,7 @@ ;;; Copyright © 2018 Eric Bavier ;;; Copyright © 2019 Taylan Kammer ;;; Copyright © 2020, 2021 Efraim Flashner -;;; Copyright © 2021 Maxime Devos +;;; Copyright © 2021, 2022 Maxime Devos ;;; Copyright © 2021 Timothy Sample ;;; ;;; This file is part of GNU Guix. @@ -388,6 +388,37 @@ (define-public guile-3.0 (files '("lib/guile/3.0/site-ccache" "share/guile/site/3.0"))))))) +;; (A static variant of) this package will be used to implement +;; TOCTOU-free behaviour in +;; and . +(define-public guile-with-openat + (package + (inherit + (package-with-extra-patches guile-3.0 + (search-patches + "guile-openat-and-friends-01.patch" + "guile-openat-and-friends-02.patch" + "guile-openat-and-friends-03.patch" + "guile-openat-and-friends-04.patch" + "guile-openat-and-friends-05.patch" + "guile-openat-and-friends-06.patch" + "guile-openat-and-friends-07.patch" + "guile-openat-and-friends-08.patch" + "guile-openat-and-friends-09.patch" + "guile-openat-and-friends-10.patch" + "guile-openat-and-friends-11.patch" + "guile-openat-and-friends-12.patch" + "guile-openat-and-friends-13.patch"))) + (name "guile-with-openat") + (synopsis "Guile, with support for @code{openat} and friends") + (description "This is a variant of the Guile package, extending the +file system interface to support more directory-relative operations. + +More concretely, it adds a procedure @code{openat} that can be used +to open a file in a directory that has been opened (as a port), without +@acronym{TOCTOU,time-of-check to time-of-use} issues, and a few other +procedures of a similar nature."))) + (define-public guile-3.0-latest (package (inherit guile-3.0) diff --git a/gnu/packages/patches/guile-openat-and-friends-01.patch b/gnu/packages/patches/guile-openat-and-friends-01.patch new file mode 100644 index 0000000000..d430fb99e3 --- /dev/null +++ b/gnu/packages/patches/guile-openat-and-friends-01.patch @@ -0,0 +1,193 @@ +Guix-Upstream: https://lists.gnu.org/archive/html/guile-devel/2021-11/msg00005.html +From: Maxime Devos +Subject: [PATCH v2 01/14] + =?UTF-8?q?Allow=20file=20ports=20in=20=E2=80=98c?= + =?UTF-8?q?hdir=E2=80=99=20when=20supported.?= +Date: Tue, 16 Nov 2021 11:06:24 +0000 +Message-Id: <20211116110637.125579-2-maximedevos@telenet.be> +In-Reply-To: <20211116110637.125579-1-maximedevos@telenet.be> +References: <175c3a6572e832d84927937b309a3095cadf5702.camel@telenet.be> + <20211116110637.125579-1-maximedevos@telenet.be> +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +* configure.ac: Check for ‘fchdir’. +* libguile/filesys.c +(scm_chdir): Support file ports. +(scm_init_filesys): Report support of file ports. +* doc/ref/posix.texi (Processes): Update accordingly. +* doc/ref/guile.texi: Add copyright line for new documentation in this +patch and later patches. +* test-suite/tests/filesys.test ("chdir"): Test it. +--- + configure.ac | 3 ++- + doc/ref/guile.texi | 3 ++- + doc/ref/posix.texi | 5 ++++- + libguile/filesys.c | 23 +++++++++++++++++++- + test-suite/tests/filesys.test | 41 +++++++++++++++++++++++++++++++++++ + 5 files changed, 71 insertions(+), 4 deletions(-) + +diff --git a/configure.ac b/configure.ac +index bd49bf162..b7e4663f7 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -484,7 +484,8 @@ AC_CHECK_HEADERS([assert.h crt_externs.h]) + # sendfile - non-POSIX, found in glibc + # + AC_CHECK_FUNCS([DINFINITY DQNAN cexp chsize clog clog10 ctermid \ +- fesetround ftime ftruncate fchown fchmod getcwd geteuid getsid \ ++ fesetround ftime ftruncate fchown fchmod fchdir \ ++ getcwd geteuid getsid \ + gettimeofday getuid getgid gmtime_r ioctl lstat mkdir mkdtemp mknod \ + nice readlink rename rmdir setegid seteuid \ + setlocale setuid setgid setpgid setsid sigaction siginterrupt stat64 \ +diff --git a/doc/ref/guile.texi b/doc/ref/guile.texi +index 660b1ae90..48af1f820 100644 +--- a/doc/ref/guile.texi ++++ b/doc/ref/guile.texi +@@ -14,7 +14,8 @@ + This manual documents Guile version @value{VERSION}. + + Copyright (C) 1996-1997, 2000-2005, 2009-2021 Free Software Foundation, +-Inc. ++Inc. \\ ++Copyright (C) 2021 Maxime Devos + + Permission is granted to copy, distribute and/or modify this document + under the terms of the GNU Free Documentation License, Version 1.3 or +diff --git a/doc/ref/posix.texi b/doc/ref/posix.texi +index 7633bd5a3..7555f9319 100644 +--- a/doc/ref/posix.texi ++++ b/doc/ref/posix.texi +@@ -2,6 +2,7 @@ + @c This is part of the GNU Guile Reference Manual. + @c Copyright (C) 1996, 1997, 2000, 2001, 2002, 2003, 2004, 2006, 2007, + @c 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2017, 2021 Free Software Foundation, Inc. ++@c Copyright (C) 2021 Maxime Devos + @c See the file guile.texi for copying conditions. + + @node POSIX +@@ -1605,7 +1606,9 @@ The return value is unspecified. + @deffn {Scheme Procedure} chdir str + @deffnx {C Function} scm_chdir (str) + @cindex current directory +-Change the current working directory to @var{str}. ++Change the current working directory to @var{str}. @var{str} can be a ++string containing a file name, or a port if supported by the system. ++@code{(provided? 'chdir-port)} reports whether ports are supported. + The return value is unspecified. + @end deffn + +diff --git a/libguile/filesys.c b/libguile/filesys.c +index 6247734e8..2a9c36a12 100644 +--- a/libguile/filesys.c ++++ b/libguile/filesys.c +@@ -1,5 +1,6 @@ + /* Copyright 1996-2002,2004,2006,2009-2019,2021 + Free Software Foundation, Inc. ++ Copyright 2021 Maxime Devos + + This file is part of Guile. + +@@ -621,12 +622,28 @@ SCM_DEFINE (scm_link, "link", 2, 0, 0, + SCM_DEFINE (scm_chdir, "chdir", 1, 0, 0, + (SCM str), + "Change the current working directory to @var{str}.\n" ++ "@var{str} can be a string containing a file name,\n" ++ "or a port if supported by the system.\n" ++ "@code{(provided? 'chdir-port)} reports whether ports " ++ "are supported." + "The return value is unspecified.") + #define FUNC_NAME s_scm_chdir + { + int ans; + +- STRING_SYSCALL (str, c_str, ans = chdir (c_str)); ++#ifdef HAVE_FCHDIR ++ if (SCM_OPFPORTP (str)) ++ { ++ int fdes; ++ fdes = SCM_FPORT_FDES (str); ++ SCM_SYSCALL (ans = fchdir (fdes)); ++ scm_remember_upto_here_1 (str); ++ } ++ else ++#endif ++ { ++ STRING_SYSCALL (str, c_str, ans = chdir (c_str)); ++ } + if (ans != 0) + SCM_SYSERROR; + return SCM_UNSPECIFIED; +@@ -2066,5 +2083,9 @@ scm_init_filesys () + + scm_dot_string = scm_from_utf8_string ("."); + ++#ifdef HAVE_FCHDIR ++ scm_add_feature("chdir-port"); ++#endif ++ + #include "filesys.x" + } +diff --git a/test-suite/tests/filesys.test b/test-suite/tests/filesys.test +index 6fed981e5..6b09a2ba0 100644 +--- a/test-suite/tests/filesys.test ++++ b/test-suite/tests/filesys.test +@@ -1,6 +1,7 @@ + ;;;; filesys.test --- test file system functions -*- scheme -*- + ;;;; + ;;;; Copyright (C) 2004, 2006, 2013, 2019, 2021 Free Software Foundation, Inc. ++;;;; Copyright (C) 2021 Maxime Devos + ;;;; + ;;;; This library is free software; you can redistribute it and/or + ;;;; modify it under the terms of the GNU Lesser General Public +@@ -265,3 +266,43 @@ + (result (eqv? 'directory (stat:type _stat)))) + (false-if-exception (rmdir name)) + result))))) ++ ++(with-test-prefix "chdir" ++ (pass-if-equal "current directory" (getcwd) ++ (begin (chdir ".") (getcwd))) ++ (define file (search-path %load-path "ice-9/boot-9.scm")) ++ ++ ++ (pass-if-equal "test directory" (dirname file) ++ (let ((olddir (getcwd)) ++ (dir #f)) ++ (chdir (dirname file)) ++ (set! dir (getcwd)) ++ (chdir olddir) ++ dir)) ++ ++ (pass-if-equal "test directory, via port" (dirname file) ++ (unless (provided? 'chdir-port) ++ (throw 'unresolved)) ++ (let ((olddir (getcwd)) ++ (port (open (dirname file) O_RDONLY)) ++ (dir #f)) ++ (chdir port) ++ (set! dir (getcwd)) ++ (chdir olddir) ++ dir)) ++ ++ (pass-if-exception "closed port" exception:wrong-type-arg ++ (unless (provided? 'chdir-port) ++ (throw 'unresolved)) ++ (let ((port (open (dirname file) O_RDONLY)) ++ (olddir (getcwd))) ++ (close-port port) ++ (chdir port) ++ (chdir olddir))) ; should not be reached ++ ++ (pass-if-exception "not a port or file name" exception:wrong-type-arg ++ (chdir '(stuff))) ++ ++ (pass-if-exception "non-file port" exception:wrong-type-arg ++ (chdir (open-input-string "")))) +-- +2.30.2 + + + diff --git a/gnu/packages/patches/guile-openat-and-friends-02.patch b/gnu/packages/patches/guile-openat-and-friends-02.patch new file mode 100644 index 0000000000..211e0a4f4c --- /dev/null +++ b/gnu/packages/patches/guile-openat-and-friends-02.patch @@ -0,0 +1,219 @@ +Guix-Upstream: https://lists.gnu.org/archive/html/guile-devel/2021-11/msg00005.html +From: Maxime Devos +Subject: [PATCH v2 02/14] + =?UTF-8?q?Allow=20file=20ports=20in=20=E2=80=98r?= + =?UTF-8?q?eadlink=E2=80=99.?= +Date: Tue, 16 Nov 2021 11:06:25 +0000 +Message-Id: <20211116110637.125579-3-maximedevos@telenet.be> +In-Reply-To: <20211116110637.125579-1-maximedevos@telenet.be> +References: <175c3a6572e832d84927937b309a3095cadf5702.camel@telenet.be> + <20211116110637.125579-1-maximedevos@telenet.be> +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +* configure.ac: Detect whether ‘readlinkat’ is defined. +* libguile/filesys.c (scm_readlink): Support file ports + when ‘readlinkat’ exists. + (scm_init_filesys): Provide ‘chdir-ports’ when it exists. +* doc/ref/posix.texi (File System): Document it. +* test-suite/tests/filesys.test ("readlink"): Test it. +--- + configure.ac | 2 +- + doc/ref/posix.texi | 9 ++++-- + libguile/filesys.c | 52 +++++++++++++++++++++++------ + test-suite/tests/filesys.test | 61 +++++++++++++++++++++++++++++++++++ + 4 files changed, 112 insertions(+), 12 deletions(-) + +diff --git a/configure.ac b/configure.ac +index b7e4663f7..4888f880d 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -484,7 +484,7 @@ AC_CHECK_HEADERS([assert.h crt_externs.h]) + # sendfile - non-POSIX, found in glibc + # + AC_CHECK_FUNCS([DINFINITY DQNAN cexp chsize clog clog10 ctermid \ +- fesetround ftime ftruncate fchown fchmod fchdir \ ++ fesetround ftime ftruncate fchown fchmod fchdir readlinkat \ + getcwd geteuid getsid \ + gettimeofday getuid getgid gmtime_r ioctl lstat mkdir mkdtemp mknod \ + nice readlink rename rmdir setegid seteuid \ +diff --git a/doc/ref/posix.texi b/doc/ref/posix.texi +index 7555f9319..cd23240c4 100644 +--- a/doc/ref/posix.texi ++++ b/doc/ref/posix.texi +@@ -757,8 +757,13 @@ file it points to. @var{path} must be a string. + + @deffn {Scheme Procedure} readlink path + @deffnx {C Function} scm_readlink (path) +-Return the value of the symbolic link named by @var{path} (a +-string), i.e., the file that the link points to. ++Return the value of the symbolic link named by @var{path} (a string, or ++a port if supported by the system), i.e., the file that the link points ++to. ++ ++To read a symbolic link represented by a port, the symbolic link must ++have been opened with the @code{O_NOFOLLOW} and @code{O_PATH} flags. ++@code{(provided? 'readlink-port)} reports whether ports are supported. + @end deffn + + @findex fchown +diff --git a/libguile/filesys.c b/libguile/filesys.c +index 2a9c36a12..c5bedec07 100644 +--- a/libguile/filesys.c ++++ b/libguile/filesys.c +@@ -1045,10 +1045,30 @@ SCM_DEFINE (scm_symlink, "symlink", 2, 0, 0, + #undef FUNC_NAME + #endif /* HAVE_SYMLINK */ + +-SCM_DEFINE (scm_readlink, "readlink", 1, 0, 0, ++/* Static helper function for choosing between readlink ++ and readlinkat. */ ++static int ++do_readlink (int fd, const char *c_path, char *buf, size_t size) ++{ ++#ifdef HAVE_READLINKAT ++ if (fd != -1) ++ return readlinkat (fd, c_path, buf, size); ++#else ++ (void) fd; ++#endif ++ return readlink (c_path, buf, size); ++} ++ ++SCM_DEFINE (scm_readlink, "readlink", 1, 0, 0, + (SCM path), +- "Return the value of the symbolic link named by @var{path} (a\n" +- "string), i.e., the file that the link points to.") ++ "Return the value of the symbolic link named by @var{path} (a\n" ++ "string, or a port if supported by the system),\n" ++ "i.e., the file that the link points to.\n" ++ "To read a symbolic link represented by a port, the symbolic\n" ++ "link must have been opened with the @code{O_NOFOLLOW} and\n" ++ "@code{O_PATH} flags." ++ "@code{(provided? 'readlink-port)} reports whether ports are\n" ++ "supported.") + #define FUNC_NAME s_scm_readlink + { + int rv; +@@ -1056,20 +1076,31 @@ SCM_DEFINE (scm_readlink, "readlink", 1, 0, 0, + char *buf; + SCM result; + char *c_path; +- +- scm_dynwind_begin (0); +- +- c_path = scm_to_locale_string (path); +- scm_dynwind_free (c_path); ++ int fdes; + ++ scm_dynwind_begin (0); ++#ifdef HAVE_READLINKAT ++ if (SCM_OPFPORTP (path)) ++ { ++ c_path = ""; ++ fdes = SCM_FPORT_FDES (path); ++ } ++ else ++#endif ++ { ++ fdes = -1; ++ c_path = scm_to_locale_string (path); ++ scm_dynwind_free (c_path); ++ } + buf = scm_malloc (size); + +- while ((rv = readlink (c_path, buf, size)) == size) ++ while ((rv = do_readlink (fdes, c_path, buf, size)) == size) + { + free (buf); + size *= 2; + buf = scm_malloc (size); + } ++ scm_remember_upto_here_1 (path); + if (rv == -1) + { + int save_errno = errno; +@@ -2086,6 +2117,9 @@ scm_init_filesys () + #ifdef HAVE_FCHDIR + scm_add_feature("chdir-port"); + #endif ++#ifdef HAVE_READLINKAT ++ scm_add_feature("readlink-port"); ++#endif + + #include "filesys.x" + } +diff --git a/test-suite/tests/filesys.test b/test-suite/tests/filesys.test +index 6b09a2ba0..7feb3492f 100644 +--- a/test-suite/tests/filesys.test ++++ b/test-suite/tests/filesys.test +@@ -306,3 +306,64 @@ + + (pass-if-exception "non-file port" exception:wrong-type-arg + (chdir (open-input-string "")))) ++ ++(with-test-prefix "readlink" ++ (false-if-exception (delete-file (test-symlink))) ++ (false-if-exception (delete-file (test-file))) ++ (call-with-output-file (test-file) ++ (lambda (port) ++ (display "hello" port))) ++ (if (not (false-if-exception ++ (begin (symlink (test-file) (test-symlink)) #t))) ++ (display "cannot create symlink, some readlink tests skipped\n") ++ (let () ++ (pass-if-equal "file name of symlink" (test-file) ++ (readlink (test-symlink))) ++ ++ (pass-if-equal "port representing a symlink" (test-file) ++ (let () ++ (unless (and (provided? 'readlink-port) ++ (defined? 'O_NOFOLLOW) ++ (defined? 'O_PATH) ++ (not (= 0 O_NOFOLLOW)) ++ (not (= 0 O_PATH))) ++ (throw 'unsupported)) ++ (define port (open (test-symlink) (logior O_NOFOLLOW O_PATH))) ++ (define points-to (false-if-exception (readlink port))) ++ (close-port port) ++ points-to)) ++ ++ (pass-if-exception "not a port or file name" exception:wrong-type-arg ++ (readlink '(stuff))))) ++ ++ (pass-if-equal "port representing a regular file" EINVAL ++ (call-with-input-file (test-file) ++ (lambda (port) ++ (unless (provided? 'readlink-port) ++ (throw 'unsupported)) ++ (catch 'system-error ++ (lambda () ++ (readlink port) ++ (close-port port) ; should be unreachable ++ #f) ++ (lambda args ++ (close-port port) ++ ;; At least Linux 5.10.46 returns ENOENT instead of EINVAL. ++ ;; Possibly surprising, but it is documented in some man ++ ;; pages and it doesn't appear to be an accident: ++ ;; . ++ (define error (system-error-errno args)) ++ (if (= error ENOENT) ++ EINVAL ++ error)))))) ++ ++ (pass-if-exception "non-file port" exception:wrong-type-arg ++ (readlink (open-input-string ""))) ++ ++ (pass-if-exception "closed port" exception:wrong-type-arg ++ (let ((port (open-file (test-file) "r"))) ++ (close-port port) ++ (readlink port))) ++ ++ (false-if-exception (delete-file (test-symlink))) ++ (false-if-exception (delete-file (test-file)))) +-- +2.30.2 + + diff --git a/gnu/packages/patches/guile-openat-and-friends-03.patch b/gnu/packages/patches/guile-openat-and-friends-03.patch new file mode 100644 index 0000000000..8cdc9b1771 --- /dev/null +++ b/gnu/packages/patches/guile-openat-and-friends-03.patch @@ -0,0 +1,269 @@ +Guix-Upstream: https://lists.gnu.org/archive/html/guile-devel/2021-11/msg00005.html +From: Maxime Devos +Subject: [PATCH v2 03/14] + =?UTF-8?q?Allow=20file=20ports=20in=20=E2=80=98u?= + =?UTF-8?q?time=E2=80=99.?= +Date: Tue, 16 Nov 2021 11:06:26 +0000 +Message-Id: <20211116110637.125579-4-maximedevos@telenet.be> +In-Reply-To: <20211116110637.125579-1-maximedevos@telenet.be> +References: <175c3a6572e832d84927937b309a3095cadf5702.camel@telenet.be> + <20211116110637.125579-1-maximedevos@telenet.be> +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Ports representing symbolic links are currently unsupported. + +* configure.ac: Detect 'futimens'. +* doc/ref/posix.texi (utime): Update documentation. +* libguile/posix.c (scm_utime): Support ports. +* libguile/posix.h (scm_utime): Rename argument. +* test-suite/tests/posix.test ("utime"): Add more tests. +--- + configure.ac | 4 +-- + doc/ref/posix.texi | 15 +++++--- + libguile/posix.c | 28 +++++++++++---- + libguile/posix.h | 2 +- + test-suite/tests/posix.test | 71 ++++++++++++++++++++++++++++++++++++- + 5 files changed, 106 insertions(+), 14 deletions(-) + +diff --git a/configure.ac b/configure.ac +index 4888f880d..ddf330d96 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -477,7 +477,7 @@ AC_CHECK_HEADERS([assert.h crt_externs.h]) + # truncate - not in mingw + # isblank - available as a GNU extension or in C99 + # _NSGetEnviron - Darwin specific +-# strcoll_l, newlocale, uselocale, utimensat - POSIX.1-2008 ++# strcoll_l, newlocale, uselocale, utimensat, futimens - POSIX.1-2008 + # strtol_l - non-POSIX, found in glibc + # fork - unavailable on Windows + # sched_getaffinity, sched_setaffinity - GNU extensions (glibc) +@@ -494,7 +494,7 @@ AC_CHECK_FUNCS([DINFINITY DQNAN cexp chsize clog clog10 ctermid \ + getgrent kill getppid getpgrp fork setitimer getitimer strchr strcmp \ + index bcopy memcpy rindex truncate isblank _NSGetEnviron \ + strcoll strcoll_l strtod_l strtol_l newlocale uselocale utimensat \ +- sched_getaffinity sched_setaffinity sendfile]) ++ futimens sched_getaffinity sched_setaffinity sendfile]) + + # The newlib C library uses _NL_ prefixed locale langinfo constants. + AC_CHECK_DECLS([_NL_NUMERIC_GROUPING], [], [], [[#include ]]) +diff --git a/doc/ref/posix.texi b/doc/ref/posix.texi +index cd23240c4..b6deffd43 100644 +--- a/doc/ref/posix.texi ++++ b/doc/ref/posix.texi +@@ -796,14 +796,16 @@ the new permissions as a decimal number, e.g., @code{(chmod "foo" #o755)}. + The return value is unspecified. + @end deffn + +-@deffn {Scheme Procedure} utime pathname [actime [modtime [actimens [modtimens [flags]]]]] +-@deffnx {C Function} scm_utime (pathname, actime, modtime, actimens, modtimens, flags) ++@deffn {Scheme Procedure} utime object [actime [modtime [actimens [modtimens [flags]]]]] ++@deffnx {C Function} scm_utime (object, actime, modtime, actimens, modtimens, flags) + @code{utime} sets the access and modification times for the +-file named by @var{pathname}. If @var{actime} or @var{modtime} is ++file named by @var{object}. If @var{actime} or @var{modtime} is + not supplied, then the current time is used. @var{actime} and + @var{modtime} must be integer time values as returned by the + @code{current-time} procedure. + ++@var{object} must be a file name or a port (if supported by the system). ++ + The optional @var{actimens} and @var{modtimens} are nanoseconds + to add @var{actime} and @var{modtime}. Nanosecond precision is + only supported on some combinations of file systems and operating +@@ -817,9 +819,14 @@ modification time to the current time. + @vindex AT_SYMLINK_NOFOLLOW + Last, @var{flags} may be either @code{0} or the + @code{AT_SYMLINK_NOFOLLOW} constant, to set the time of +-@var{pathname} even if it is a symbolic link. ++@var{object} even if it is a symbolic link. + @end deffn + ++On GNU/Linux systems, at least when using the Linux kernel 5.10.46, ++if @var{object} is a port, it may not be a symbolic link, ++even if @code{AT_SYMLINK_NOFOLLOW} is set. This is either a bug ++in Linux or Guile's wrappers. The exact cause is unclear. ++ + @findex unlink + @deffn {Scheme Procedure} delete-file str + @deffnx {C Function} scm_delete_file (str) +diff --git a/libguile/posix.c b/libguile/posix.c +index 3ab12b99e..bd7f40ca8 100644 +--- a/libguile/posix.c ++++ b/libguile/posix.c +@@ -1,5 +1,6 @@ + /* Copyright 1995-2014,2016-2019,2021 + Free Software Foundation, Inc. ++ Copyright 2021 Maxime Devos + + This file is part of Guile. + +@@ -1648,13 +1649,14 @@ SCM_DEFINE (scm_tmpfile, "tmpfile", 0, 0, 0, + #undef FUNC_NAME + + SCM_DEFINE (scm_utime, "utime", 1, 5, 0, +- (SCM pathname, SCM actime, SCM modtime, SCM actimens, SCM modtimens, ++ (SCM object, SCM actime, SCM modtime, SCM actimens, SCM modtimens, + SCM flags), + "@code{utime} sets the access and modification times for the\n" +- "file named by @var{pathname}. If @var{actime} or @var{modtime} is\n" ++ "file named by @var{object}. If @var{actime} or @var{modtime} is\n" + "not supplied, then the current time is used. @var{actime} and\n" + "@var{modtime} must be integer time values as returned by the\n" + "@code{current-time} procedure.\n\n" ++ "@var{object} must be a file name or a port (if supported by the system).\n\n" + "The optional @var{actimens} and @var{modtimens} are nanoseconds\n" + "to add @var{actime} and @var{modtime}. Nanosecond precision is\n" + "only supported on some combinations of file systems and operating\n" +@@ -1666,7 +1668,11 @@ SCM_DEFINE (scm_utime, "utime", 1, 5, 0, + "modification time to the current time.\n\n" + "Last, @var{flags} may be either @code{0} or the\n" + "@code{AT_SYMLINK_NOFOLLOW} constant, to set the time of\n" +- "@var{pathname} even if it is a symbolic link.\n") ++ "@var{pathname} even if it is a symbolic link.\n\n" ++ "On GNU/Linux systems, at least when using the Linux kernel\n" ++ "5.10.46, if @var{object} is a port, it may not be a symbolic\n" ++ "link, even if @code{AT_SYMLINK_NOFOLLOW} is set. This is either\n" ++ "a bug in Linux or Guile's wrappers. The exact cause is unclear.") + #define FUNC_NAME s_scm_utime + { + int rv; +@@ -1725,8 +1731,18 @@ SCM_DEFINE (scm_utime, "utime", 1, 5, 0, + times[1].tv_sec = mtim_sec; + times[1].tv_nsec = mtim_nsec; + +- STRING_SYSCALL (pathname, c_pathname, +- rv = utimensat (AT_FDCWD, c_pathname, times, f)); ++ if (SCM_OPFPORTP (object)) ++ { ++ int fd; ++ fd = SCM_FPORT_FDES (object); ++ SCM_SYSCALL (rv = futimens (fd, times)); ++ scm_remember_upto_here_1 (object); ++ } ++ else ++ { ++ STRING_SYSCALL (object, c_pathname, ++ rv = utimensat (AT_FDCWD, c_pathname, times, f)); ++ } + } + #else + { +@@ -1740,7 +1756,7 @@ SCM_DEFINE (scm_utime, "utime", 1, 5, 0, + if (f != 0) + scm_out_of_range(FUNC_NAME, flags); + +- STRING_SYSCALL (pathname, c_pathname, ++ STRING_SYSCALL (object, c_pathname, + rv = utime (c_pathname, &utm)); + } + #endif +diff --git a/libguile/posix.h b/libguile/posix.h +index ff3bec9ea..dda8013a5 100644 +--- a/libguile/posix.h ++++ b/libguile/posix.h +@@ -69,7 +69,7 @@ SCM_API SCM scm_tmpfile (void); + SCM_API SCM scm_open_pipe (SCM pipestr, SCM modes); + SCM_API SCM scm_close_pipe (SCM port); + SCM_API SCM scm_system_star (SCM cmds); +-SCM_API SCM scm_utime (SCM pathname, SCM actime, SCM modtime, ++SCM_API SCM scm_utime (SCM object, SCM actime, SCM modtime, + SCM actimens, SCM modtimens, SCM flags); + SCM_API SCM scm_access (SCM path, SCM how); + SCM_API SCM scm_getpid (void); +diff --git a/test-suite/tests/posix.test b/test-suite/tests/posix.test +index 1e552d16f..8e32251b5 100644 +--- a/test-suite/tests/posix.test ++++ b/test-suite/tests/posix.test +@@ -2,6 +2,7 @@ + ;;;; + ;;;; Copyright 2003-2004,2006-2007,2010,2012,2015,2017-2019,2021 + ;;;; Free Software Foundation, Inc. ++;;;; Copyright 2021 Maxime Devos + ;;;; + ;;;; This library is free software; you can redistribute it and/or + ;;;; modify it under the terms of the GNU Lesser General Public +@@ -201,7 +202,75 @@ + (list (stat:atime info) (stat:mtime info)))) + (lambda () + (delete-file file)))) +- (throw 'unsupported)))) ++ (throw 'unsupported))) ++ ++ (define (utime-unless-unsupported oops . arguments) ++ (catch 'system-error ++ (lambda () ++ (catch 'wrong-type-arg ++ (lambda () ++ (apply utime arguments)) ++ (lambda _ ++ ;; 'futimens' is not supported on all platforms. ++ (oops)))) ++ (lambda args ++ ;; On some platforms, 'futimens' returns ENOSYS according to Gnulib. ++ (if (= (system-error-errno args) ENOSYS) ++ (oops) ++ (apply throw args))))) ++ ++ (pass-if-equal "file port" ++ '(1 1) ++ (let ((file "posix.test-utime")) ++ (false-if-exception (delete-file file)) ++ (close-port (open-output-file file)) ++ (define (delete) ++ (delete-file file)) ++ (define (oops) ++ (delete) ++ (throw 'unsupported)) ++ (call-with-input-file file ++ (lambda (port) ++ (utime-unless-unsupported oops port 1 1 0 0) ++ (define info (stat file)) ++ (delete) ++ (list (stat:atime info) (stat:mtime info)))))) ++ ++ ;; This causes an EBADF system error on GNU/Linux with the 5.10.46 kernel. ++ #; ++ (pass-if-equal "file port (port representing symbolic link)" ++ '(1 1) ++ (let ((file "posix.test-utime")) ++ (unless (false-if-exception ++ (begin (symlink "/should-be-irrelevant" file) ++ #t)) ++ (display "cannot create symlink, a utime test skipped\n") ++ (throw 'unresolved)) ++ (unless (and (defined? 'O_NOFOLLOW) ++ (defined? 'O_PATH) ++ (not (= 0 O_NOFOLLOW)) ++ (not (= 0 O_PATH))) ++ (display "cannot open symlinks, a utime test skipped\n") ++ (throw 'unresolved)) ++ (define (delete) ++ (when port (close-port port)) ++ (false-if-exception (delete-file file))) ++ (define (oops) ++ (delete) ++ (throw 'unsupported)) ++ (define port #f) ++ (catch #t ++ (lambda () ++ (set! port ++ (open file (logior O_NOFOLLOW O_PATH))) ++ (utime-unless-unsupported oops port 1 1 0 0)) ++ (lambda args ++ (pk 'deleting file) ++ (delete) ++ (apply throw args))) ++ (define info (lstat file)) ++ (delete) ++ (list (stat:mtime info) (stat:atime info))))) + + ;; + ;; affinity +-- +2.30.2 + + + diff --git a/gnu/packages/patches/guile-openat-and-friends-04.patch b/gnu/packages/patches/guile-openat-and-friends-04.patch new file mode 100644 index 0000000000..71d12316af --- /dev/null +++ b/gnu/packages/patches/guile-openat-and-friends-04.patch @@ -0,0 +1,142 @@ +Guix-Upstream: https://lists.gnu.org/archive/html/guile-devel/2021-11/msg00005.html +From: Maxime Devos +Subject: [PATCH v2 04/14] =?UTF-8?q?Define=20=E2=80=98symlinkat=E2=80=99?= + =?UTF-8?q?=20wrapper=20when=20supported.?= +Date: Tue, 16 Nov 2021 11:06:27 +0000 +Message-Id: <20211116110637.125579-5-maximedevos@telenet.be> +In-Reply-To: <20211116110637.125579-1-maximedevos@telenet.be> +References: <175c3a6572e832d84927937b309a3095cadf5702.camel@telenet.be> + <20211116110637.125579-1-maximedevos@telenet.be> +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +* configure.ac: Detect whether ‘symlinkat’ exists. +* libguile/filesys.c (scm_symlinkat): Define a Scheme binding + when it exists. +* libguile/filesys.h: Make the binding part of the public C API. +* doc/ref/posix.texi (File System): Document the binding. +* test-suite/tests/filesys.test ("symlinkat"): Test it. +--- + configure.ac | 2 +- + doc/ref/posix.texi | 6 ++++++ + libguile/filesys.c | 23 +++++++++++++++++++++++ + libguile/filesys.h | 1 + + test-suite/tests/filesys.test | 27 +++++++++++++++++++++++++++ + 5 files changed, 58 insertions(+), 1 deletion(-) + +diff --git a/configure.ac b/configure.ac +index ddf330d96..b2e9ef3e9 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -485,7 +485,7 @@ AC_CHECK_HEADERS([assert.h crt_externs.h]) + # + AC_CHECK_FUNCS([DINFINITY DQNAN cexp chsize clog clog10 ctermid \ + fesetround ftime ftruncate fchown fchmod fchdir readlinkat \ +- getcwd geteuid getsid \ ++ symlinkat getcwd geteuid getsid \ + gettimeofday getuid getgid gmtime_r ioctl lstat mkdir mkdtemp mknod \ + nice readlink rename rmdir setegid seteuid \ + setlocale setuid setgid setpgid setsid sigaction siginterrupt stat64 \ +diff --git a/doc/ref/posix.texi b/doc/ref/posix.texi +index b6deffd43..a329eec39 100644 +--- a/doc/ref/posix.texi ++++ b/doc/ref/posix.texi +@@ -891,6 +891,12 @@ Create a symbolic link named @var{newpath} with the value (i.e., pointing to) + @var{oldpath}. The return value is unspecified. + @end deffn + ++@deffn {Scheme Procedure} symlinkat dir oldpath newpath ++@deffnx {C Function} scm_symlinkat (dir, oldpath, newpath) ++Like @code{symlink}, but resolve @var{newpath} relative to ++the directory referred to by the file port @var{dir}. ++@end deffn ++ + @deffn {Scheme Procedure} mkdir path [mode] + @deffnx {C Function} scm_mkdir (path, mode) + Create a new directory named by @var{path}. If @var{mode} is omitted +diff --git a/libguile/filesys.c b/libguile/filesys.c +index c5bedec07..bfd223434 100644 +--- a/libguile/filesys.c ++++ b/libguile/filesys.c +@@ -1045,6 +1045,29 @@ SCM_DEFINE (scm_symlink, "symlink", 2, 0, 0, + #undef FUNC_NAME + #endif /* HAVE_SYMLINK */ + ++#ifdef HAVE_SYMLINKAT ++SCM_DEFINE (scm_symlinkat, "symlinkat", 3, 0, 0, ++ (SCM dir, SCM oldpath, SCM newpath), ++ "Like @code{symlink}, but resolve @var{newpath} relative\n" ++ "to the directory referred to by the file port @var{dir}.") ++#define FUNC_NAME s_scm_symlinkat ++{ ++ int val; ++ int fdes; ++ ++ SCM_VALIDATE_OPFPORT (SCM_ARG1, dir); ++ fdes = SCM_FPORT_FDES (dir); ++ STRING2_SYSCALL (oldpath, c_oldpath, ++ newpath, c_newpath, ++ val = symlinkat (c_oldpath, fdes, c_newpath)); ++ scm_remember_upto_here_1 (dir); ++ if (val != 0) ++ SCM_SYSERROR; ++ return SCM_UNSPECIFIED; ++} ++#undef FUNC_NAME ++#endif /* HAVE_SYMLINKAT */ ++ + /* Static helper function for choosing between readlink + and readlinkat. */ + static int +diff --git a/libguile/filesys.h b/libguile/filesys.h +index a3b257c12..d181aca52 100644 +--- a/libguile/filesys.h ++++ b/libguile/filesys.h +@@ -62,6 +62,7 @@ SCM_API SCM scm_select (SCM reads, SCM writes, SCM excepts, SCM secs, SCM msecs) + SCM_API SCM scm_fcntl (SCM object, SCM cmd, SCM value); + SCM_API SCM scm_fsync (SCM object); + SCM_API SCM scm_symlink (SCM oldpath, SCM newpath); ++SCM_API SCM scm_symlinkat (SCM dir, SCM oldpath, SCM newpath); + SCM_API SCM scm_readlink (SCM path); + SCM_API SCM scm_lstat (SCM str); + SCM_API SCM scm_copy_file (SCM oldfile, SCM newfile); +diff --git a/test-suite/tests/filesys.test b/test-suite/tests/filesys.test +index 7feb3492f..64bf92333 100644 +--- a/test-suite/tests/filesys.test ++++ b/test-suite/tests/filesys.test +@@ -367,3 +367,30 @@ + + (false-if-exception (delete-file (test-symlink))) + (false-if-exception (delete-file (test-file)))) ++ ++(with-test-prefix "symlinkat" ++ (pass-if-equal "create" (test-file) ++ (unless (defined? 'symlinkat) ++ (throw 'unsupported)) ++ (call-with-port ++ (open "." O_RDONLY) ++ (lambda (port) ++ (symlinkat port (test-file) (test-symlink)) ++ (readlink (test-symlink))))) ++ (false-if-exception (delete-file (test-symlink))) ++ ++ (pass-if-exception "not a port" exception:wrong-type-arg ++ (unless (defined? 'symlinkat) ++ (throw 'unsupported)) ++ (symlinkat "bogus" (test-file) (test-symlink))) ++ ++ (pass-if-exception "not a file port" exception:wrong-type-arg ++ (unless (defined? 'symlinkat) ++ (throw 'unsupported)) ++ (symlinkat (open-input-string "") (test-file) (test-symlink))) ++ ++ (pass-if-exception "closed port" exception:wrong-type-arg ++ (unless (defined? 'symlinkat) ++ (throw 'unsupported)) ++ (symlinkat (call-with-port (open "." O_RDONLY) identity) ++ (test-file) (test-symlink)))) +-- +2.30.2 + + diff --git a/gnu/packages/patches/guile-openat-and-friends-05.patch b/gnu/packages/patches/guile-openat-and-friends-05.patch new file mode 100644 index 0000000000..0cbc76004e --- /dev/null +++ b/gnu/packages/patches/guile-openat-and-friends-05.patch @@ -0,0 +1,159 @@ +Guix-Upstream: https://lists.gnu.org/archive/html/guile-devel/2021-11/msg00005.html +From: Maxime Devos +Subject: [PATCH v2 05/14] + =?UTF-8?q?Define=20bindings=20to=20=E2=80=98mkdi?= + =?UTF-8?q?rat=E2=80=99=20when=20the=20C=20function=20exists.?= +Date: Tue, 16 Nov 2021 11:06:28 +0000 +Message-Id: <20211116110637.125579-6-maximedevos@telenet.be> +References: <175c3a6572e832d84927937b309a3095cadf5702.camel@telenet.be> + <20211116110637.125579-1-maximedevos@telenet.be> +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +* configure.ac: Detect if ‘mkdirat’ exists. +* libguile/filesys.c (scm_mkdirat): Define the Scheme binding. +* doc/ref/posix.texi (File System): Document it. +--- + configure.ac | 2 +- + doc/ref/posix.texi | 6 ++++++ + libguile/filesys.c | 25 +++++++++++++++++++++++ + libguile/filesys.h | 1 + + test-suite/tests/filesys.test | 38 +++++++++++++++++++++++++++++++++++ + 5 files changed, 71 insertions(+), 1 deletion(-) + +diff --git a/configure.ac b/configure.ac +index b2e9ef3e9..da8dfadd0 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -485,7 +485,7 @@ AC_CHECK_HEADERS([assert.h crt_externs.h]) + # + AC_CHECK_FUNCS([DINFINITY DQNAN cexp chsize clog clog10 ctermid \ + fesetround ftime ftruncate fchown fchmod fchdir readlinkat \ +- symlinkat getcwd geteuid getsid \ ++ symlinkat mkdirat getcwd geteuid getsid \ + gettimeofday getuid getgid gmtime_r ioctl lstat mkdir mkdtemp mknod \ + nice readlink rename rmdir setegid seteuid \ + setlocale setuid setgid setpgid setsid sigaction siginterrupt stat64 \ +diff --git a/doc/ref/posix.texi b/doc/ref/posix.texi +index a329eec39..d261ac8da 100644 +--- a/doc/ref/posix.texi ++++ b/doc/ref/posix.texi +@@ -906,6 +906,12 @@ Otherwise they are set to the value specified with @var{mode}. + The return value is unspecified. + @end deffn + ++@deffn {Scheme Procedure} mkdirat dir path [mode] ++@deffnx {C Function} scm_mkdirat (dir, path, mode) ++Like @code{mkdir}, but resolve @var{path} relative to the directory ++referred to by the file port @var{dir} instead. ++@end deffn ++ + @deffn {Scheme Procedure} rmdir path + @deffnx {C Function} scm_rmdir (path) + Remove the existing directory named by @var{path}. The directory must +diff --git a/libguile/filesys.c b/libguile/filesys.c +index bfd223434..ee01b2e2c 100644 +--- a/libguile/filesys.c ++++ b/libguile/filesys.c +@@ -1364,6 +1364,31 @@ SCM_DEFINE (scm_mkdir, "mkdir", 1, 1, 0, + } + #undef FUNC_NAME + ++#ifdef HAVE_MKDIRAT ++SCM_DEFINE (scm_mkdirat, "mkdirat", 2, 1, 0, ++ (SCM dir, SCM path, SCM mode), ++ "Like @code{mkdir}, but resolve @var{path} relative to the directory\n" ++ "referred to by the file port @var{dir} instead.") ++#define FUNC_NAME s_scm_mkdirat ++{ ++ int rv; ++ int dir_fdes; ++ mode_t c_mode; ++ ++ c_mode = SCM_UNBNDP (mode) ? 0777 : scm_to_uint (mode); ++ SCM_VALIDATE_OPFPORT (SCM_ARG1, dir); ++ dir_fdes = SCM_FPORT_FDES (dir); ++ ++ STRING_SYSCALL (path, c_path, rv = mkdirat (dir_fdes, c_path, c_mode)); ++ if (rv != 0) ++ SCM_SYSERROR; ++ ++ scm_remember_upto_here_1 (dir); ++ return SCM_UNSPECIFIED; ++} ++#undef FUNC_NAME ++#endif ++ + SCM_DEFINE (scm_rmdir, "rmdir", 1, 0, 0, + (SCM path), + "Remove the existing directory named by @var{path}. The directory must\n" +diff --git a/libguile/filesys.h b/libguile/filesys.h +index d181aca52..f0dd35ede 100644 +--- a/libguile/filesys.h ++++ b/libguile/filesys.h +@@ -50,6 +50,7 @@ SCM_API SCM scm_link (SCM oldpath, SCM newpath); + SCM_API SCM scm_rename (SCM oldname, SCM newname); + SCM_API SCM scm_delete_file (SCM str); + SCM_API SCM scm_mkdir (SCM path, SCM mode); ++SCM_API SCM scm_mkdirat (SCM dir, SCM path, SCM mode); + SCM_API SCM scm_rmdir (SCM path); + SCM_API SCM scm_directory_stream_p (SCM obj); + SCM_API SCM scm_opendir (SCM dirname); +diff --git a/test-suite/tests/filesys.test b/test-suite/tests/filesys.test +index 64bf92333..4ea62d513 100644 +--- a/test-suite/tests/filesys.test ++++ b/test-suite/tests/filesys.test +@@ -29,6 +29,8 @@ + (data-file-name "filesys-test.tmp")) + (define (test-symlink) + (data-file-name "filesys-test-link.tmp")) ++(define (test-directory) ++ (data-file-name "filesys-test-dir.tmp")) + + + ;;; +@@ -394,3 +396,39 @@ + (throw 'unsupported)) + (symlinkat (call-with-port (open "." O_RDONLY) identity) + (test-file) (test-symlink)))) ++ ++(with-test-prefix "mkdirat" ++ (define (skip-if-unsupported) ++ (unless (defined? 'mkdirat) ++ (throw 'unsupported))) ++ (define (maybe-delete-directory) ++ (when (file-exists? (test-directory)) ++ (rmdir (test-directory)))) ++ (maybe-delete-directory) ++ ++ (pass-if-equal "create" 'directory ++ (skip-if-unsupported) ++ (call-with-port ++ (open "." O_RDONLY) ++ (lambda (port) ++ (mkdirat port (test-directory)) ++ (stat:type (stat (test-directory)))))) ++ (maybe-delete-directory) ++ ++ (pass-if-equal "explicit perms" (logand #o111 (lognot (umask))) ++ (skip-if-unsupported) ++ (call-with-port ++ (open "." O_RDONLY) ++ (lambda (port) ++ (mkdirat port (test-directory) #o111) ++ (stat:perms (stat (test-directory)))))) ++ (maybe-delete-directory) ++ ++ (pass-if-equal "create, implicit perms" (logand #o777 (lognot (umask))) ++ (skip-if-unsupported) ++ (call-with-port ++ (open "." O_RDONLY) ++ (lambda (port) ++ (mkdirat port (test-directory)) ++ (stat:perms (stat (test-directory)))))) ++ (maybe-delete-directory)) +-- +2.30.2 + + diff --git a/gnu/packages/patches/guile-openat-and-friends-06.patch b/gnu/packages/patches/guile-openat-and-friends-06.patch new file mode 100644 index 0000000000..04f8900986 --- /dev/null +++ b/gnu/packages/patches/guile-openat-and-friends-06.patch @@ -0,0 +1,37 @@ +Guix-Upstream: https://lists.gnu.org/archive/html/guile-devel/2021-11/msg00005.html +From: Maxime Devos +Subject: [PATCH v2 06/14] =?UTF-8?q?Correct=20documentation=20of=20?= + =?UTF-8?q?=E2=80=98mkdir=E2=80=99=20w.r.t.=20the=20umask.?= +Date: Tue, 16 Nov 2021 11:06:29 +0000 +Message-Id: <20211116110637.125579-7-maximedevos@telenet.be> +In-Reply-To: <20211116110637.125579-1-maximedevos@telenet.be> +References: <175c3a6572e832d84927937b309a3095cadf5702.camel@telenet.be> + <20211116110637.125579-1-maximedevos@telenet.be> +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +* doc/ref/posix.texi (mkdir): Note that the umask is applied even if the + mode argument is set. +--- + doc/ref/posix.texi | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/doc/ref/posix.texi b/doc/ref/posix.texi +index d261ac8da..7f136376b 100644 +--- a/doc/ref/posix.texi ++++ b/doc/ref/posix.texi +@@ -902,7 +902,8 @@ the directory referred to by the file port @var{dir}. + Create a new directory named by @var{path}. If @var{mode} is omitted + then the permissions of the directory are set to @code{#o777} + masked with the current umask (@pxref{Processes, @code{umask}}). +-Otherwise they are set to the value specified with @var{mode}. ++Otherwise they are set to the value specified with @var{mode} ++masked with the current umask. + The return value is unspecified. + @end deffn + +-- +2.30.2 + + diff --git a/gnu/packages/patches/guile-openat-and-friends-07.patch b/gnu/packages/patches/guile-openat-and-friends-07.patch new file mode 100644 index 0000000000..00bce2205a --- /dev/null +++ b/gnu/packages/patches/guile-openat-and-friends-07.patch @@ -0,0 +1,40 @@ +Guix-Upstream: https://lists.gnu.org/archive/html/guile-devel/2021-11/msg00005.html +From: Maxime Devos +Subject: [PATCH v2 07/14] Define AT_REMOVEDIR and others when available. +Date: Tue, 16 Nov 2021 11:06:30 +0000 +Message-Id: <20211116110637.125579-8-maximedevos@telenet.be> +In-Reply-To: <20211116110637.125579-1-maximedevos@telenet.be> +References: <175c3a6572e832d84927937b309a3095cadf5702.camel@telenet.be> + <20211116110637.125579-1-maximedevos@telenet.be> +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +* libguile/posix.c (scm_init_posix): Define (in Scheme) + AT_REMOVEDIR and AT_EACCESS when defined (in C). +--- + libguile/posix.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +diff --git a/libguile/posix.c b/libguile/posix.c +index bd7f40ca8..a6f7c9a0d 100644 +--- a/libguile/posix.c ++++ b/libguile/posix.c +@@ -2503,6 +2503,12 @@ scm_init_posix () + #ifdef AT_EMPTY_PATH + scm_c_define ("AT_EMPTY_PATH", scm_from_int (AT_EMPTY_PATH)); + #endif ++#ifdef AT_REMOVEDIR ++ scm_c_define ("AT_REMOVEDIR", scm_from_int (AT_REMOVEDIR)); ++#endif ++#ifdef AT_EACCESS ++ scm_c_define ("AT_EACCESS", scm_from_int (AT_EACCESS)); ++#endif + + #include "cpp-SIG.c" + #include "posix.x" +-- +2.30.2 + + + diff --git a/gnu/packages/patches/guile-openat-and-friends-08.patch b/gnu/packages/patches/guile-openat-and-friends-08.patch new file mode 100644 index 0000000000..e922b0aeb5 --- /dev/null +++ b/gnu/packages/patches/guile-openat-and-friends-08.patch @@ -0,0 +1,240 @@ +Guix-Upstream: https://lists.gnu.org/archive/html/guile-devel/2021-11/msg00005.html +From: Maxime Devos +Subject: [PATCH v2 08/14] =?UTF-8?q?Define=20a=20Scheme=20binding=20to=20?= + =?UTF-8?q?=E2=80=98renameat=E2=80=99=20when=20it=20exists.?= +Date: Tue, 16 Nov 2021 11:06:31 +0000 +Message-Id: <20211116110637.125579-9-maximedevos@telenet.be> +In-Reply-To: <20211116110637.125579-1-maximedevos@telenet.be> +References: <175c3a6572e832d84927937b309a3095cadf5702.camel@telenet.be> + <20211116110637.125579-1-maximedevos@telenet.be> +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +* configure.ac: Detect if ‘renameat’ is defined. +* libguile/filesys.c (scm_renameat): Define a Scheme binding + to the ‘renameat’ system call. +* doc/ref/posix.texi (File System): Document it. +* libguile/filesys.h (scm_renameat): Make it part of the C API. +* test-suite/tests/filesys.test ("rename-file-at"): New tests. +--- + configure.ac | 2 +- + doc/ref/posix.texi | 9 +++ + libguile/filesys.c | 34 +++++++++++ + libguile/filesys.h | 1 + + test-suite/tests/filesys.test | 104 ++++++++++++++++++++++++++++++++++ + 5 files changed, 149 insertions(+), 1 deletion(-) + +diff --git a/configure.ac b/configure.ac +index da8dfadd0..e67892feb 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -485,7 +485,7 @@ AC_CHECK_HEADERS([assert.h crt_externs.h]) + # + AC_CHECK_FUNCS([DINFINITY DQNAN cexp chsize clog clog10 ctermid \ + fesetround ftime ftruncate fchown fchmod fchdir readlinkat \ +- symlinkat mkdirat getcwd geteuid getsid \ ++ symlinkat mkdirat renameat getcwd geteuid getsid \ + gettimeofday getuid getgid gmtime_r ioctl lstat mkdir mkdtemp mknod \ + nice readlink rename rmdir setegid seteuid \ + setlocale setuid setgid setpgid setsid sigaction siginterrupt stat64 \ +diff --git a/doc/ref/posix.texi b/doc/ref/posix.texi +index 7f136376b..ebb001581 100644 +--- a/doc/ref/posix.texi ++++ b/doc/ref/posix.texi +@@ -877,6 +877,15 @@ Renames the file specified by @var{oldname} to @var{newname}. + The return value is unspecified. + @end deffn + ++@findex renameat ++@deffn {Scheme Procedure} rename-file-at olddir oldname newdir newname ++@deffnx {C Function} scm_renameat (olddir, oldname, newdir, newname) ++Like @code{rename-file}, but when @var{olddir} or @var{newdir} is true, ++resolve @var{oldname} or @var{newname} relative to the directory ++specified by the file port @var{olddir} or @var{newdir} instead of the ++current working directory. ++@end deffn ++ + @deffn {Scheme Procedure} link oldpath newpath + @deffnx {C Function} scm_link (oldpath, newpath) + Creates a new name @var{newpath} in the file system for the +diff --git a/libguile/filesys.c b/libguile/filesys.c +index ee01b2e2c..9c63beaa8 100644 +--- a/libguile/filesys.c ++++ b/libguile/filesys.c +@@ -1421,6 +1421,40 @@ SCM_DEFINE (scm_rename, "rename-file", 2, 0, 0, + } + #undef FUNC_NAME + ++#ifdef HAVE_RENAMEAT ++SCM_DEFINE (scm_renameat, "rename-file-at", 4, 0, 0, ++ (SCM olddir, SCM oldname, SCM newdir, SCM newname), ++ "Like @code{rename-file}, but when @var{olddir} or @var{newdir}\n" ++ "is true, resolve @var{oldname} or @var{newname} relative to\n" ++ "the directory specified by file port @var{olddir} or\n" ++ "@var{newdir} instead of the current working directory.") ++#define FUNC_NAME s_scm_renameat ++{ ++ int rv; ++ int old_fdes, new_fdes; ++ ++ old_fdes = AT_FDCWD; ++ new_fdes = AT_FDCWD; ++ ++ if (scm_is_true (olddir)) { ++ SCM_VALIDATE_OPFPORT (SCM_ARG1, olddir); ++ old_fdes = SCM_FPORT_FDES (olddir); ++ } ++ if (scm_is_true (newdir)) { ++ SCM_VALIDATE_OPFPORT (SCM_ARG3, newdir); ++ new_fdes = SCM_FPORT_FDES (newdir); ++ } ++ ++ STRING2_SYSCALL (oldname, c_oldname, ++ newname, c_newname, ++ rv = renameat (old_fdes, c_oldname, new_fdes, c_newname)); ++ scm_remember_upto_here_2 (olddir, newdir); ++ if (rv != 0) ++ SCM_SYSERROR; ++ return SCM_UNSPECIFIED; ++} ++#undef FUNC_NAME ++#endif + + SCM_DEFINE (scm_delete_file, "delete-file", 1, 0, 0, + (SCM str), +diff --git a/libguile/filesys.h b/libguile/filesys.h +index f0dd35ede..7e17cc585 100644 +--- a/libguile/filesys.h ++++ b/libguile/filesys.h +@@ -48,6 +48,7 @@ SCM_API SCM scm_close_fdes (SCM fd); + SCM_API SCM scm_stat (SCM object, SCM exception_on_error); + SCM_API SCM scm_link (SCM oldpath, SCM newpath); + SCM_API SCM scm_rename (SCM oldname, SCM newname); ++SCM_API SCM scm_renameat (SCM olddir, SCM oldname, SCM newdir, SCM newname); + SCM_API SCM scm_delete_file (SCM str); + SCM_API SCM scm_mkdir (SCM path, SCM mode); + SCM_API SCM scm_mkdirat (SCM dir, SCM path, SCM mode); +diff --git a/test-suite/tests/filesys.test b/test-suite/tests/filesys.test +index 4ea62d513..bbce2c858 100644 +--- a/test-suite/tests/filesys.test ++++ b/test-suite/tests/filesys.test +@@ -31,6 +31,8 @@ + (data-file-name "filesys-test-link.tmp")) + (define (test-directory) + (data-file-name "filesys-test-dir.tmp")) ++(define (test-directory2) ++ (data-file-name "filesys-test-dir2.tmp")) + + + ;;; +@@ -432,3 +434,105 @@ + (mkdirat port (test-directory)) + (stat:perms (stat (test-directory)))))) + (maybe-delete-directory)) ++ ++(with-test-prefix "rename-file-at" ++ (define (skip-if-unsupported) ++ (unless (defined? 'rename-file-at) ++ (throw 'unsupported))) ++ (pass-if-equal "current working directory" '(#f "hello") ++ (skip-if-unsupported) ++ ;; Create a file in the test directory ++ (call-with-output-file "filesys-test-a.tmp" ++ (lambda (port) (display "hello" port))) ++ ;; Try to rename it ++ (rename-file-at #f "filesys-test-a.tmp" #f "filesys-test-b.tmp") ++ ;; Verify it exists under the new name, and not under the old name ++ (list (file-exists? "filesys-test-a.tmp") ++ (call-with-input-file "filesys-test-b.tmp" get-string-all))) ++ ++ (false-if-exception (delete-file "filesys-test-a.tmp")) ++ (false-if-exception (delete-file "filesys-test-b.tmp")) ++ ++ (pass-if-equal "two ports" '(#f "hello") ++ (skip-if-unsupported) ++ (mkdir (test-directory)) ++ (mkdir (test-directory2)) ++ ;; Create a file in the first directory ++ (call-with-output-file (in-vicinity (test-directory) "a") ++ (lambda (port) (display "hello" port))) ++ (let ((port1 (open (test-directory) O_RDONLY)) ++ (port2 (open (test-directory2) O_RDONLY))) ++ ;; Try to rename it ++ (rename-file-at port1 "a" port2 "b") ++ (close-port port1) ++ (close-port port2) ++ ;; Verify it exists under the new name, and not under the old name ++ (list (file-exists? (in-vicinity (test-directory) "a")) ++ (call-with-input-file (in-vicinity (test-directory2) "b") ++ get-string-all)))) ++ (false-if-exception (delete-file (in-vicinity (test-directory) "a"))) ++ (false-if-exception (delete-file (in-vicinity (test-directory2) "b"))) ++ (false-if-exception (rmdir (test-directory))) ++ (false-if-exception (rmdir (test-directory2))) ++ ++ (pass-if-equal "port and current working directory" '(#f "hello") ++ (skip-if-unsupported) ++ (mkdir (test-directory)) ++ ;; Create a file in (test-directory) ++ (call-with-output-file (in-vicinity (test-directory) "a") ++ (lambda (port) (display "hello" port))) ++ (let ((port (open (test-directory) O_RDONLY))) ++ ;; Try to rename it ++ (rename-file-at port "a" #f (basename (test-file))) ++ (close-port port) ++ ;; Verify it exists under the new name, and not under the old name. ++ (list (file-exists? (in-vicinity (test-directory) "a")) ++ (call-with-input-file (test-file) get-string-all)))) ++ (false-if-exception (delete-file (in-vicinity (test-directory) "a"))) ++ (false-if-exception (rmdir (test-directory))) ++ (false-if-exception (delete-file (test-file))) ++ ++ (pass-if-equal "current working directory and port" '(#f "hello") ++ (skip-if-unsupported) ++ (mkdir (test-directory)) ++ ;; Create a file in the working directory ++ (call-with-output-file (test-file) ++ (lambda (port) (display "hello" port))) ++ (let ((port (open (test-directory) O_RDONLY))) ++ ;; Try to rename it ++ (rename-file-at #f (basename (test-file)) port "b") ++ (close-port port) ++ ;; Verify it exists under the new name, and not under the old name. ++ (list (file-exists? (test-file)) ++ (call-with-input-file (in-vicinity (test-directory) "b") ++ get-string-all)))) ++ ++ (false-if-exception (delete-file (in-vicinity (test-directory) "b"))) ++ (false-if-exception (delete-file (test-file))) ++ (false-if-exception (rmdir (test-directory))) ++ ++ (pass-if-exception "not a file port (1)" exception:wrong-type-arg ++ (skip-if-unsupported) ++ (rename-file-at (open-input-string "") "some" #f "thing")) ++ ++ (pass-if-exception "not a file port (2)" exception:wrong-type-arg ++ (skip-if-unsupported) ++ (rename-file-at #f "some" (open-input-string "") "thing")) ++ ++ (pass-if-exception "closed port (1)" exception:wrong-type-arg ++ (skip-if-unsupported) ++ (rename-file-at (call-with-port (open "." O_RDONLY) identity) ++ "some" #f "thing")) ++ ++ (pass-if-exception "closed port (2)" exception:wrong-type-arg ++ (skip-if-unsupported) ++ (rename-file-at #f "some" (call-with-port (open "." O_RDONLY) identity) ++ "thing")) ++ ++ (pass-if-exception "not a string (1)" exception:wrong-type-arg ++ (skip-if-unsupported) ++ (rename-file-at #f 'what #f "thing")) ++ ++ (pass-if-exception "not a string (2)" exception:wrong-type-arg ++ (skip-if-unsupported) ++ (rename-file-at #f "some" #f 'what))) +-- +2.30.2 + + diff --git a/gnu/packages/patches/guile-openat-and-friends-09.patch b/gnu/packages/patches/guile-openat-and-friends-09.patch new file mode 100644 index 0000000000..9762ac56c4 --- /dev/null +++ b/gnu/packages/patches/guile-openat-and-friends-09.patch @@ -0,0 +1,173 @@ +Guix-Upstream: https://lists.gnu.org/archive/html/guile-devel/2021-11/msg00005.html +From: Maxime Devos +Subject: [PATCH v2 09/14] =?UTF-8?q?Define=20a=20Scheme=20binding=20to=20?= + =?UTF-8?q?=E2=80=98fchmodat=E2=80=99=20when=20it=20exists.?= +Date: Tue, 16 Nov 2021 11:06:32 +0000 +Message-Id: <20211116110637.125579-10-maximedevos@telenet.be> +In-Reply-To: <20211116110637.125579-1-maximedevos@telenet.be> +References: <175c3a6572e832d84927937b309a3095cadf5702.camel@telenet.be> + <20211116110637.125579-1-maximedevos@telenet.be> +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +* configure.ac: Detect existence of fchmodat. +* libguile/filesys.c (scm_chmodat): New procedure. +* libguile/filesys.h (scm_chmodat): Make it part of the API. +* test-suite/tests/filesys.test ("chmodat"): Test it. +--- + configure.ac | 4 +-- + libguile/filesys.c | 36 ++++++++++++++++++++++++ + libguile/filesys.h | 1 + + test-suite/tests/filesys.test | 53 +++++++++++++++++++++++++++++++++++ + 4 files changed, 92 insertions(+), 2 deletions(-) + +diff --git a/configure.ac b/configure.ac +index e67892feb..2a5485990 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -477,7 +477,7 @@ AC_CHECK_HEADERS([assert.h crt_externs.h]) + # truncate - not in mingw + # isblank - available as a GNU extension or in C99 + # _NSGetEnviron - Darwin specific +-# strcoll_l, newlocale, uselocale, utimensat, futimens - POSIX.1-2008 ++# strcoll_l, newlocale, uselocale, utimensat, futimens, fchmodat - POSIX.1-2008 + # strtol_l - non-POSIX, found in glibc + # fork - unavailable on Windows + # sched_getaffinity, sched_setaffinity - GNU extensions (glibc) +@@ -485,7 +485,7 @@ AC_CHECK_HEADERS([assert.h crt_externs.h]) + # + AC_CHECK_FUNCS([DINFINITY DQNAN cexp chsize clog clog10 ctermid \ + fesetround ftime ftruncate fchown fchmod fchdir readlinkat \ +- symlinkat mkdirat renameat getcwd geteuid getsid \ ++ fchmodat symlinkat mkdirat renameat getcwd geteuid getsid \ + gettimeofday getuid getgid gmtime_r ioctl lstat mkdir mkdtemp mknod \ + nice readlink rename rmdir setegid seteuid \ + setlocale setuid setgid setpgid setsid sigaction siginterrupt stat64 \ +diff --git a/libguile/filesys.c b/libguile/filesys.c +index 9c63beaa8..4dd9c7b48 100644 +--- a/libguile/filesys.c ++++ b/libguile/filesys.c +@@ -1561,6 +1561,42 @@ SCM_DEFINE (scm_chmod, "chmod", 2, 0, 0, + } + #undef FUNC_NAME + ++#ifdef HAVE_FCHMODAT ++SCM_DEFINE (scm_chmodat, "chmodat", 3, 1, 0, ++ (SCM dir, SCM pathname, SCM mode, SCM flags), ++ "Like @var{chmod}, but modify the permissions of the file named\n" ++ "@var{pathname} in the directory referred to by the file port\n" ++ "@var{dir} instead.\n" ++ "The optional @var{flags} argument may be 0 or @code{AT_SYMLINK_NOFOLLOW},\n" ++ "in which case @var{pathname} is not dereferenced if it is a symbolic link,\n" ++ "i.e., the permissions of the symbolic link itself are modified.\n\n" ++ "Note that @code{AT_SYMLINK_NOFOLLOW} is not supported on all systems\n" ++ "and may result in @code{ENOTSUP}.") ++#define FUNC_NAME s_scm_chmodat ++{ ++ int rv; ++ int c_flags; ++ int dir_fdes; ++ ++ if (SCM_UNBNDP (flags)) ++ c_flags = 0; ++ else ++ c_flags = scm_to_int (flags); ++ ++ SCM_VALIDATE_OPFPORT (SCM_ARG1, dir); ++ dir_fdes = SCM_FPORT_FDES (dir); ++ ++ STRING_SYSCALL (pathname, c_pathname, ++ rv = fchmodat (dir_fdes, c_pathname, ++ scm_to_int (mode), c_flags)); ++ scm_remember_upto_here_1 (dir); ++ if (rv == -1) ++ SCM_SYSERROR; ++ return SCM_UNSPECIFIED; ++} ++#undef FUNC_NAME ++#endif ++ + SCM_DEFINE (scm_umask, "umask", 0, 1, 0, + (SCM mode), + "If @var{mode} is omitted, returns a decimal number representing the current\n" +diff --git a/libguile/filesys.h b/libguile/filesys.h +index 7e17cc585..377a3795e 100644 +--- a/libguile/filesys.h ++++ b/libguile/filesys.h +@@ -40,6 +40,7 @@ SCM_API scm_t_bits scm_tc16_dir; + + SCM_API SCM scm_chown (SCM object, SCM owner, SCM group); + SCM_API SCM scm_chmod (SCM object, SCM mode); ++SCM_API SCM scm_chmodat (SCM dir, SCM pathname, SCM mode, SCM flags); + SCM_API SCM scm_umask (SCM mode); + SCM_API SCM scm_open_fdes (SCM path, SCM flags, SCM mode); + SCM_API SCM scm_open (SCM path, SCM flags, SCM mode); +diff --git a/test-suite/tests/filesys.test b/test-suite/tests/filesys.test +index bbce2c858..204f3414c 100644 +--- a/test-suite/tests/filesys.test ++++ b/test-suite/tests/filesys.test +@@ -271,6 +271,59 @@ + (false-if-exception (rmdir name)) + result))))) + ++;;; ++;;; chmodat ++;;; ++ ++(with-test-prefix "chmodat" ++ (call-with-output-file (test-file) (const #f)) ++ (chmod (test-file) #o000) ++ ++ (pass-if-equal "regular file" ++ #o300 ++ (unless (defined? 'chmodat) ++ (throw 'unsupported)) ++ (call-with-port ++ (open (dirname (test-file)) O_RDONLY) ++ (lambda (port) ++ (chmodat port (test-file) #o300))) ++ (stat:perms (stat (test-file)))) ++ ++ (chmod (test-file) #o000) ++ ++ (pass-if-equal "regular file, AT_SYMLINK_NOFOLLOW" ++ #o300 ++ (unless (and (defined? 'chmodat) ++ (defined? 'AT_SYMLINK_NOFOLLOW)) ++ (throw 'unsupported)) ++ (call-with-port ++ (open (dirname (test-file)) O_RDONLY) ++ (lambda (port) ++ (catch 'system-error ++ (lambda () ++ (chmodat port (basename (test-file)) #o300 AT_SYMLINK_NOFOLLOW)) ++ (lambda args ++ (close-port port) ++ ;; AT_SYMLINK_NOFOLLOW is not supported on Linux (at least Linux ++ ;; 5.11.2 with the btrfs file system), even for regular files. ++ (if (= ENOTSUP (system-error-errno args)) ++ (begin ++ (display "fchmodat doesn't support AT_SYMLINK_NOFOLLOW\n") ++ (throw 'unresolved)) ++ (apply throw args)))))) ++ (stat:perms (stat (test-file)))) ++ ++ (pass-if-exception "not a port" exception:wrong-type-arg ++ (chmodat "bogus" (test-file) #o300)) ++ ++ (pass-if-exception "not a file port" exception:wrong-type-arg ++ (chmodat (open-input-string "") (test-file) #o300)) ++ ++ (pass-if-exception "closed port" exception:wrong-type-arg ++ (chmodat (call-with-port (open "." O_RDONLY) identity) (test-file) #o300)) ++ ++ (delete-file (test-file))) ++ + (with-test-prefix "chdir" + (pass-if-equal "current directory" (getcwd) + (begin (chdir ".") (getcwd))) +-- +2.30.2 + + diff --git a/gnu/packages/patches/guile-openat-and-friends-10.patch b/gnu/packages/patches/guile-openat-and-friends-10.patch new file mode 100644 index 0000000000..3f50b1d7d5 --- /dev/null +++ b/gnu/packages/patches/guile-openat-and-friends-10.patch @@ -0,0 +1,204 @@ +Guix-Upstream: https://lists.gnu.org/archive/html/guile-devel/2021-11/msg00005.html +From: Maxime Devos +Subject: [PATCH v2 10/14] =?UTF-8?q?Define=20a=20Scheme=20binding=20to=20?= + =?UTF-8?q?=E2=80=98unlinkat=E2=80=99=20when=20it=20exists.?= +Date: Tue, 16 Nov 2021 11:06:33 +0000 +Message-Id: <20211116110637.125579-11-maximedevos@telenet.be> +In-Reply-To: <20211116110637.125579-1-maximedevos@telenet.be> +References: <175c3a6572e832d84927937b309a3095cadf5702.camel@telenet.be> + <20211116110637.125579-1-maximedevos@telenet.be> +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +‘unlinkat’ is used for both unlinking regular files +and removing empty directories. + +* configure.ac: Detect if ‘unlinkat’ exists. +* doc/ref/posix.texi (File System): Document why there is no + ‘rmdirat’ procedure, and document the ‘delete-file-at’ procedure. +* libguile/filesys.c + (scm_rmdir): Adjust the docstring here as well. + (scm_delete_file_at): Define a Scheme binding to ‘unlinkat’. +* libguile/filesys.h (scm_delete_file_at): Make ‘scm_delete_file_at’ + part of the C API. +--- + configure.ac | 5 +-- + doc/ref/posix.texi | 12 +++++++ + libguile/filesys.c | 32 +++++++++++++++++++ + libguile/filesys.h | 1 + + test-suite/tests/filesys.test | 59 +++++++++++++++++++++++++++++++++++ + 5 files changed, 107 insertions(+), 2 deletions(-) + +diff --git a/configure.ac b/configure.ac +index 2a5485990..e1c090321 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -477,7 +477,8 @@ AC_CHECK_HEADERS([assert.h crt_externs.h]) + # truncate - not in mingw + # isblank - available as a GNU extension or in C99 + # _NSGetEnviron - Darwin specific +-# strcoll_l, newlocale, uselocale, utimensat, futimens, fchmodat - POSIX.1-2008 ++# strcoll_l, newlocale, uselocale, utimensat, futimens, fchmodat, ++# unlinkat - POSIX.1-2008 + # strtol_l - non-POSIX, found in glibc + # fork - unavailable on Windows + # sched_getaffinity, sched_setaffinity - GNU extensions (glibc) +@@ -485,7 +486,7 @@ AC_CHECK_HEADERS([assert.h crt_externs.h]) + # + AC_CHECK_FUNCS([DINFINITY DQNAN cexp chsize clog clog10 ctermid \ + fesetround ftime ftruncate fchown fchmod fchdir readlinkat \ +- fchmodat symlinkat mkdirat renameat getcwd geteuid getsid \ ++ fchmodat symlinkat mkdirat renameat unlinkat getcwd geteuid getsid \ + gettimeofday getuid getgid gmtime_r ioctl lstat mkdir mkdtemp mknod \ + nice readlink rename rmdir setegid seteuid \ + setlocale setuid setgid setpgid setsid sigaction siginterrupt stat64 \ +diff --git a/doc/ref/posix.texi b/doc/ref/posix.texi +index ebb001581..ad10585d9 100644 +--- a/doc/ref/posix.texi ++++ b/doc/ref/posix.texi +@@ -834,6 +834,18 @@ Deletes (or ``unlinks'') the file whose path is specified by + @var{str}. + @end deffn + ++@findex unlinkat ++@deffn {Scheme Procedure} delete-file-at dir str [flags] ++@deffnx {C Function} scm_delete_file_at (dir, str, flags) ++Like @code{unlink}, but resolve @var{str} relative to the ++directory referred to by the file port @var{dir} instead. ++ ++The optional @var{flags} argument can be @code{AT_REMOVEDIR}, ++in which case @code{delete-file-at} will act like @code{rmdir} instead ++of @code{delete-file}. Why doesn't POSIX have a @code{rmdirat} function ++for this instead? No idea! ++@end deffn ++ + @deffn {Scheme Procedure} copy-file oldfile newfile + @deffnx {C Function} scm_copy_file (oldfile, newfile) + Copy the file specified by @var{oldfile} to @var{newfile}. +diff --git a/libguile/filesys.c b/libguile/filesys.c +index 4dd9c7b48..7e6d89626 100644 +--- a/libguile/filesys.c ++++ b/libguile/filesys.c +@@ -1469,6 +1469,38 @@ SCM_DEFINE (scm_delete_file, "delete-file", 1, 0, 0, + } + #undef FUNC_NAME + ++#ifdef HAVE_UNLINKAT ++SCM_DEFINE (scm_delete_file_at, "delete-file-at", 2, 1, 0, ++ (SCM dir, SCM str, SCM flags), ++ "Like @code{unlink}, but resolve @var{str} relative to the\n" ++ "directory referred to by the file port @var{dir} instead.\n\n" ++ "The optional @var{flags} argument can be @code{AT_REMOVEDIR},\n" ++ "in which case @code{delete-file-at} will act like @code{rmdir} instead\n" ++ "of @code{delete-file}. Why doesn't POSIX have a @code{rmdirat} function\n" ++ "for this instead? No idea!") ++#define FUNC_NAME s_scm_delete_file_at ++{ ++ int ans; ++ int dir_fdes; ++ int c_flags; ++ ++ if (SCM_UNBNDP (flags)) ++ c_flags = 0; ++ else ++ c_flags = scm_to_int (flags); ++ ++ SCM_VALIDATE_OPFPORT (SCM_ARG1, dir); ++ dir_fdes = SCM_FPORT_FDES (dir); ++ ++ STRING_SYSCALL (str, c_str, ans = unlinkat (dir_fdes, c_str, c_flags)); ++ scm_remember_upto_here_1 (dir); ++ if (ans != 0) ++ SCM_SYSERROR; ++ return SCM_UNSPECIFIED; ++} ++#undef FUNC_NAME ++#endif ++ + SCM_DEFINE (scm_access, "access?", 2, 0, 0, + (SCM path, SCM how), + "Test accessibility of a file under the real UID and GID of the\n" +diff --git a/libguile/filesys.h b/libguile/filesys.h +index 377a3795e..37d084cd5 100644 +--- a/libguile/filesys.h ++++ b/libguile/filesys.h +@@ -51,6 +51,7 @@ SCM_API SCM scm_link (SCM oldpath, SCM newpath); + SCM_API SCM scm_rename (SCM oldname, SCM newname); + SCM_API SCM scm_renameat (SCM olddir, SCM oldname, SCM newdir, SCM newname); + SCM_API SCM scm_delete_file (SCM str); ++SCM_API SCM scm_delete_file_at (SCM dir, SCM str, SCM flags); + SCM_API SCM scm_mkdir (SCM path, SCM mode); + SCM_API SCM scm_mkdirat (SCM dir, SCM path, SCM mode); + SCM_API SCM scm_rmdir (SCM path); +diff --git a/test-suite/tests/filesys.test b/test-suite/tests/filesys.test +index 204f3414c..33b68e16d 100644 +--- a/test-suite/tests/filesys.test ++++ b/test-suite/tests/filesys.test +@@ -589,3 +589,62 @@ + (pass-if-exception "not a string (2)" exception:wrong-type-arg + (skip-if-unsupported) + (rename-file-at #f "some" #f 'what))) ++ ++(with-test-prefix "delete-file-at" ++ (define (skip-if-unsupported) ++ (when (not (and (defined? 'delete-file-at) ++ (defined? 'AT_REMOVEDIR))) ++ (throw 'unsupported))) ++ (define (create-test-file) ++ (call-with-output-file (test-file) identity)) ++ (define (create-test-directory) ++ (mkdir (test-directory))) ++ (define (delete-test-file) ++ (when (file-exists? (test-file)) ++ (delete-file (test-file)))) ++ (define (delete-test-directory) ++ (when (file-exists? (test-directory)) ++ (rmdir (test-directory)))) ++ ++ (pass-if-equal "regular file" #f ++ (skip-if-unsupported) ++ (create-test-file) ++ (call-with-port ++ (open (dirname (test-file)) O_RDONLY) ++ (lambda (port) ++ (delete-file-at port (basename (test-file))))) ++ (file-exists? (test-file))) ++ (delete-test-file) ++ ++ (pass-if-equal "regular file, explicit flags" #f ++ (skip-if-unsupported) ++ (create-test-file) ++ (call-with-port ++ (open (dirname (test-file)) O_RDONLY) ++ (lambda (port) ++ (delete-file-at port (basename (test-file)) 0))) ++ (file-exists? (test-file))) ++ (delete-test-file) ++ ++ (pass-if-equal "directory, explicit flags" #f ++ (skip-if-unsupported) ++ (create-test-directory) ++ (call-with-port ++ (open (dirname (test-directory)) O_RDONLY) ++ (lambda (port) ++ (delete-file-at port (basename (test-directory)) AT_REMOVEDIR))) ++ (file-exists? (test-directory))) ++ (delete-test-directory) ++ ++ (pass-if-exception "not a port" exception:wrong-type-arg ++ (skip-if-unsupported) ++ (delete-file-at 'bogus "irrelevant")) ++ ++ (pass-if-exception "not a file port" exception:wrong-type-arg ++ (skip-if-unsupported) ++ (delete-file-at (open-input-string "") "irrelevant")) ++ ++ (pass-if-exception "closed port" exception:wrong-type-arg ++ (skip-if-unsupported) ++ (delete-file-at (call-with-port (open "." O_RDONLY) identity) ++ "irrelevant"))) +-- +2.30.2 + + diff --git a/gnu/packages/patches/guile-openat-and-friends-11.patch b/gnu/packages/patches/guile-openat-and-friends-11.patch new file mode 100644 index 0000000000..37c52ebadc --- /dev/null +++ b/gnu/packages/patches/guile-openat-and-friends-11.patch @@ -0,0 +1,130 @@ +Guix-Upstream: https://lists.gnu.org/archive/html/guile-devel/2021-11/msg00005.html +From: Maxime Devos +Subject: [PATCH v2 11/14] =?UTF-8?q?Define=20a=20Scheme=20binding=20to=20?= + =?UTF-8?q?=E2=80=98fchownat=E2=80=99=20when=20it=20exists.?= +Date: Tue, 16 Nov 2021 11:06:34 +0000 +Message-Id: <20211116110637.125579-12-maximedevos@telenet.be> +In-Reply-To: <20211116110637.125579-1-maximedevos@telenet.be> +References: <175c3a6572e832d84927937b309a3095cadf5702.camel@telenet.be> + <20211116110637.125579-1-maximedevos@telenet.be> +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +* configure.ac: Detect whether ‘fchownat’ is available. +* libguile/filesys.c (scm_chownat): Define a Scheme binding to + ‘fchownat’ when available. +* libguile/filesys.h (scm_chownat): Make it part of the API. +* doc/ref/posix.texi (File System): Document it. +--- + configure.ac | 4 ++-- + doc/ref/posix.texi | 11 +++++++++++ + libguile/filesys.c | 35 +++++++++++++++++++++++++++++++++++ + libguile/filesys.h | 1 + + 4 files changed, 49 insertions(+), 2 deletions(-) + +diff --git a/configure.ac b/configure.ac +index e1c090321..dcb6bceb5 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -478,14 +478,14 @@ AC_CHECK_HEADERS([assert.h crt_externs.h]) + # isblank - available as a GNU extension or in C99 + # _NSGetEnviron - Darwin specific + # strcoll_l, newlocale, uselocale, utimensat, futimens, fchmodat, +-# unlinkat - POSIX.1-2008 ++# unlinkat, fchownat - POSIX.1-2008 + # strtol_l - non-POSIX, found in glibc + # fork - unavailable on Windows + # sched_getaffinity, sched_setaffinity - GNU extensions (glibc) + # sendfile - non-POSIX, found in glibc + # + AC_CHECK_FUNCS([DINFINITY DQNAN cexp chsize clog clog10 ctermid \ +- fesetround ftime ftruncate fchown fchmod fchdir readlinkat \ ++ fesetround ftime ftruncate fchown fchownat fchmod fchdir readlinkat \ + fchmodat symlinkat mkdirat renameat unlinkat getcwd geteuid getsid \ + gettimeofday getuid getgid gmtime_r ioctl lstat mkdir mkdtemp mknod \ + nice readlink rename rmdir setegid seteuid \ +diff --git a/doc/ref/posix.texi b/doc/ref/posix.texi +index ad10585d9..3d06f1c73 100644 +--- a/doc/ref/posix.texi ++++ b/doc/ref/posix.texi +@@ -784,6 +784,17 @@ unsupported at present). If @var{owner} or @var{group} is specified + as @code{-1}, then that ID is not changed. + @end deffn + ++@findex fchownat ++@deffn {Scheme Procedure} chownat dir name owner group [flags] ++@deffnx {C Function} scm_chownat (dir, name, owner, group, flags) ++Like @code{chown}, but modify the owner and/or group of ++the file named @var{name} in the directory referred to ++by the file port @var{dir} instead. The optional argument ++@var{flags} is a bitmask. If @code{AT_SYMLINK_NOFOLLOW} is ++present, then @var{name} will not be dereferenced if it is a ++symbolic link. ++@end deffn ++ + @findex fchmod + @deffn {Scheme Procedure} chmod object mode + @deffnx {C Function} scm_chmod (object, mode) +diff --git a/libguile/filesys.c b/libguile/filesys.c +index 7e6d89626..c257bb59c 100644 +--- a/libguile/filesys.c ++++ b/libguile/filesys.c +@@ -193,6 +193,41 @@ SCM_DEFINE (scm_chown, "chown", 3, 0, 0, + #undef FUNC_NAME + #endif /* HAVE_CHOWN */ + ++#ifdef HAVE_FCHOWNAT ++SCM_DEFINE (scm_chownat, "chown-at", 4, 1, 0, ++ (SCM dir, SCM name, SCM owner, SCM group, SCM flags), ++ "Like @code{chown}, but modify the owner and/or group of\n" ++ "the file named @var{name} in the directory referred to\n" ++ "by the file port @var{dir} instead. The optional argument\n" ++ "@var{flags} is a bitmask. If @code{AT_SYMLINK_NOFOLLOW} is\n" ++ "present, then @var{name} will not be dereferenced if it is a\n" ++ "symbolic link.") ++#define FUNC_NAME s_scm_chownat ++{ ++ int rv; ++ int dir_fdes; ++ int c_flags; ++ ++ if (SCM_UNBNDP (flags)) ++ c_flags = 0; ++ else ++ c_flags = scm_to_int (flags); ++ ++ SCM_VALIDATE_OPFPORT (SCM_ARG1, dir); ++ dir_fdes = SCM_FPORT_FDES (dir); ++ ++ STRING_SYSCALL (name, c_name, ++ rv = fchownat (dir_fdes, c_name, ++ scm_to_int (owner), scm_to_int (group), ++ c_flags)); ++ scm_remember_upto_here_1 (dir); ++ if (rv == -1) ++ SCM_SYSERROR; ++ return SCM_UNSPECIFIED; ++} ++#undef FUNC_NAME ++#endif /* HAVE_FCHOWNAT */ ++ + + + SCM_DEFINE (scm_open_fdes, "open-fdes", 2, 1, 0, +diff --git a/libguile/filesys.h b/libguile/filesys.h +index 37d084cd5..7673c8051 100644 +--- a/libguile/filesys.h ++++ b/libguile/filesys.h +@@ -39,6 +39,7 @@ SCM_API scm_t_bits scm_tc16_dir; + + + SCM_API SCM scm_chown (SCM object, SCM owner, SCM group); ++SCM_API SCM scm_chownat (SCM dir, SCM object, SCM owner, SCM group, SCM flags); + SCM_API SCM scm_chmod (SCM object, SCM mode); + SCM_API SCM scm_chmodat (SCM dir, SCM pathname, SCM mode, SCM flags); + SCM_API SCM scm_umask (SCM mode); +-- +2.30.2 + + diff --git a/gnu/packages/patches/guile-openat-and-friends-12.patch b/gnu/packages/patches/guile-openat-and-friends-12.patch new file mode 100644 index 0000000000..845e836b03 --- /dev/null +++ b/gnu/packages/patches/guile-openat-and-friends-12.patch @@ -0,0 +1,238 @@ +Guix-Upstream: https://lists.gnu.org/archive/html/guile-devel/2021-11/msg00005.html +From: Maxime Devos +Subject: [PATCH v2 12/14] =?UTF-8?q?Define=20a=20Scheme=20binding=20to=20?= + =?UTF-8?q?=E2=80=98fstatat=E2=80=99=20when=20available.?= +Date: Tue, 16 Nov 2021 11:06:35 +0000 +Message-Id: <20211116110637.125579-13-maximedevos@telenet.be> +In-Reply-To: <20211116110637.125579-1-maximedevos@telenet.be> +References: <175c3a6572e832d84927937b309a3095cadf5702.camel@telenet.be> + <20211116110637.125579-1-maximedevos@telenet.be> +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +* configure.ac: Detect if ‘fstatat’ is defined. +* libguile/filesys.c (scm_statat): Define a Scheme binding to ‘fstatat’. +* libguile/filesys.h (scm_statat): Make it part of the C API. +* doc/ref/posix.texi (File System): Document it. +* libguile/syscalls.h (fstatat_or_fstatat64): Choose between ‘fstatat’ + and ‘fstatat64’. +--- + configure.ac | 4 +- + doc/ref/posix.texi | 8 ++++ + libguile/filesys.c | 39 +++++++++++++++++ + libguile/filesys.h | 1 + + libguile/syscalls.h | 1 + + test-suite/tests/filesys.test | 80 +++++++++++++++++++++++++++++++++++ + 6 files changed, 131 insertions(+), 2 deletions(-) + +diff --git a/configure.ac b/configure.ac +index dcb6bceb5..e073e04f4 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -478,7 +478,7 @@ AC_CHECK_HEADERS([assert.h crt_externs.h]) + # isblank - available as a GNU extension or in C99 + # _NSGetEnviron - Darwin specific + # strcoll_l, newlocale, uselocale, utimensat, futimens, fchmodat, +-# unlinkat, fchownat - POSIX.1-2008 ++# unlinkat, fchownat, fstatat - POSIX.1-2008 + # strtol_l - non-POSIX, found in glibc + # fork - unavailable on Windows + # sched_getaffinity, sched_setaffinity - GNU extensions (glibc) +@@ -495,7 +495,7 @@ AC_CHECK_FUNCS([DINFINITY DQNAN cexp chsize clog clog10 ctermid \ + getgrent kill getppid getpgrp fork setitimer getitimer strchr strcmp \ + index bcopy memcpy rindex truncate isblank _NSGetEnviron \ + strcoll strcoll_l strtod_l strtol_l newlocale uselocale utimensat \ +- futimens sched_getaffinity sched_setaffinity sendfile]) ++ fstatat futimens sched_getaffinity sched_setaffinity sendfile]) + + # The newlib C library uses _NL_ prefixed locale langinfo constants. + AC_CHECK_DECLS([_NL_NUMERIC_GROUPING], [], [], [[#include ]]) +diff --git a/doc/ref/posix.texi b/doc/ref/posix.texi +index 3d06f1c73..cdd03f141 100644 +--- a/doc/ref/posix.texi ++++ b/doc/ref/posix.texi +@@ -755,6 +755,14 @@ it will return information about a symbolic link itself, not the + file it points to. @var{path} must be a string. + @end deffn + ++@deffn {Scheme Procedure} statat dir filename [flags] ++@deffnx {C Function} scm_statat dir filename flags ++Like @code{stat}, but resolve @var{filename} relative to the directory ++referred to by the file port @var{dir} instead. The optional argument ++@var{flags} argument can be @code{AT_SYMLINK_NOFOLLOW}, in which case ++@var{filename} will not be dereferenced even if it is a symbolic link. ++@end deffn ++ + @deffn {Scheme Procedure} readlink path + @deffnx {C Function} scm_readlink (path) + Return the value of the symbolic link named by @var{path} (a string, or +diff --git a/libguile/filesys.c b/libguile/filesys.c +index c257bb59c..d045a672f 100644 +--- a/libguile/filesys.c ++++ b/libguile/filesys.c +@@ -601,6 +601,45 @@ SCM_DEFINE (scm_stat, "stat", 1, 1, 0, + } + #undef FUNC_NAME + ++#ifdef HAVE_FSTATAT ++SCM_DEFINE (scm_statat, "statat", 2, 1, 0, ++ (SCM dir, SCM filename, SCM flags), ++ "Like @code{stat}, but resolve @var{filename} relative to the\n" ++ "directory referred to by the file port @var{dir} instead.\n\n" ++ "The optional argument @var{flags} argument can be\n" ++ "@code{AT_SYMLINK_NOFOLLOW}, in which case @var{filename} will\n" ++ "not be dereferenced even if it is a symbolic link.") ++#define FUNC_NAME s_scm_statat ++{ ++ int rv; ++ int dir_fdes; ++ int c_flags; ++ struct stat_or_stat64 stat_temp; ++ ++ if (SCM_UNBNDP (flags)) ++ c_flags = 0; ++ else ++ c_flags = scm_to_int (flags); ++ ++ SCM_VALIDATE_OPFPORT (SCM_ARG1, dir); ++ dir_fdes = SCM_FPORT_FDES (dir); ++ ++ STRING_SYSCALL (filename, c_filename, ++ rv = fstatat_or_fstatat64 (dir_fdes, c_filename, ++ &stat_temp, c_flags)); ++ scm_remember_upto_here_1 (dir); ++ if (rv != 0) ++ { ++ int en = errno; ++ SCM_SYSERROR_MSG ("~A: ~S", ++ scm_list_2 (scm_strerror (scm_from_int (en)), filename), ++ en); ++ } ++ return scm_stat2scm (&stat_temp); ++} ++#undef FUNC_NAME ++#endif /* HAVE_FSTATAT */ ++ + SCM_DEFINE (scm_lstat, "lstat", 1, 0, 0, + (SCM str), + "Similar to @code{stat}, but does not follow symbolic links, i.e.,\n" +diff --git a/libguile/filesys.h b/libguile/filesys.h +index 7673c8051..8af0f989a 100644 +--- a/libguile/filesys.h ++++ b/libguile/filesys.h +@@ -48,6 +48,7 @@ SCM_API SCM scm_open (SCM path, SCM flags, SCM mode); + SCM_API SCM scm_close (SCM fd_or_port); + SCM_API SCM scm_close_fdes (SCM fd); + SCM_API SCM scm_stat (SCM object, SCM exception_on_error); ++SCM_API SCM scm_statat (SCM dir, SCM filename, SCM flags); + SCM_API SCM scm_link (SCM oldpath, SCM newpath); + SCM_API SCM scm_rename (SCM oldname, SCM newname); + SCM_API SCM scm_renameat (SCM olddir, SCM oldname, SCM newdir, SCM newname); +diff --git a/libguile/syscalls.h b/libguile/syscalls.h +index 30b99c193..37d532e60 100644 +--- a/libguile/syscalls.h ++++ b/libguile/syscalls.h +@@ -65,6 +65,7 @@ + # define readdir_r_or_readdir64_r readdir_r + #endif + #define stat_or_stat64 CHOOSE_LARGEFILE(stat,stat64) ++#define fstatat_or_fstatat64 CHOOSE_LARGEFILE(fstatat,fstatat64) + #define truncate_or_truncate64 CHOOSE_LARGEFILE(truncate,truncate64) + #define scm_from_off_t_or_off64_t CHOOSE_LARGEFILE(scm_from_off_t,scm_from_int64) + #define scm_from_ino_t_or_ino64_t CHOOSE_LARGEFILE(scm_from_ulong,scm_from_uint64) +diff --git a/test-suite/tests/filesys.test b/test-suite/tests/filesys.test +index 33b68e16d..b794b07b3 100644 +--- a/test-suite/tests/filesys.test ++++ b/test-suite/tests/filesys.test +@@ -134,6 +134,86 @@ + (close-port port) + (eqv? 5 (stat:size st)))))) + ++(with-test-prefix "statat" ++ ;; file-exists? from (ice-9 boot) dereferences symbolic links ++ ;; (a bug?). ++ (define (file-exists? filename) ++ (catch 'system-error ++ (lambda () (lstat filename) #t) ++ (lambda args ++ (if (= (system-error-errno args) ENOENT) ++ ;; For the purposes of the following tests, ++ ;; it is safe to ignore errors like EPERM, but a correct ++ ;; implementation would return #t for that error. ++ #f ++ (apply throw args))))) ++ (define (maybe-delete-directory) ++ (when (file-exists? (test-directory)) ++ (for-each ++ (lambda (filename) ++ (define full-name (in-vicinity (test-directory) filename)) ++ (when (file-exists? full-name) ++ (delete-file full-name))) ++ '("test-file" "test-symlink")) ++ (rmdir (test-directory)))) ++ (define (skip-unless-defined . things) ++ (for-each (lambda (thing) ++ (unless (defined? thing) ++ (throw 'unsupported))) ++ things)) ++ (maybe-delete-directory) ++ (mkdir (test-directory)) ++ (call-with-output-file (in-vicinity (test-directory) "test-file") ++ (lambda (port) ++ (display "hello" port))) ++ ++ ;; Return #true if the symlink was created, #false otherwise. ++ (define (maybe-create-symlink) ++ (if (file-exists? (in-vicinity (test-directory) "test-symlink")) ++ #t ++ (false-if-exception ++ (symlink "test-file" ++ (in-vicinity (test-directory) "test-symlink"))))) ++ ++ (pass-if-equal "regular file" 5 ++ (skip-unless-defined 'statat) ++ (call-with-port ++ (open (test-directory) O_RDONLY) ++ (lambda (port) ++ (stat:size (statat port "test-file"))))) ++ ++ (pass-if-equal "regular file, AT_SYMLINK_NOFOLLOW" 5 ++ (skip-unless-defined 'statat 'AT_SYMLINK_NOFOLLOW) ++ (call-with-port ++ (open (test-directory) O_RDONLY) ++ (lambda (port) ++ (stat:size (statat port "test-file" AT_SYMLINK_NOFOLLOW))))) ++ ++ (pass-if-equal "symbolic links are dereferenced" '(regular 5) ++ ;; Not all systems support symlinks. ++ (skip-unless-defined 'statat 'symlink) ++ (unless (maybe-create-symlink) ++ (throw 'unresolved)) ++ (call-with-port ++ (open (test-directory) O_RDONLY) ++ (lambda (port) ++ (define result (statat port "test-symlink")) ++ (list (stat:type result) (stat:size result))))) ++ ++ (pass-if-equal "symbolic links are not dereferenced" ++ `(symlink ,(string-length "test-file")) ++ ;; Not all systems support symlinks. ++ (skip-unless-defined 'statat 'symlink) ++ (unless (maybe-create-symlink) ++ (throw 'unresolved)) ++ (call-with-port ++ (open (test-directory) O_RDONLY) ++ (lambda (port) ++ (define result (statat port "test-symlink" AT_SYMLINK_NOFOLLOW)) ++ (list (stat:type result) (stat:size result))))) ++ ++ (maybe-delete-directory)) ++ + (with-test-prefix "sendfile" + + (let* ((file (search-path %load-path "ice-9/boot-9.scm")) +-- +2.30.2 + + diff --git a/gnu/packages/patches/guile-openat-and-friends-13.patch b/gnu/packages/patches/guile-openat-and-friends-13.patch new file mode 100644 index 0000000000..6f9c2c5b4e --- /dev/null +++ b/gnu/packages/patches/guile-openat-and-friends-13.patch @@ -0,0 +1,314 @@ +Guix-Upstream: https://lists.gnu.org/archive/html/guile-devel/2021-11/msg00005.html +From: Maxime Devos +Subject: [PATCH v2 13/14] =?UTF-8?q?Define=20Scheme=20bindings=20to=20?= + =?UTF-8?q?=E2=80=98openat=E2=80=99=20when=20available.?= +Date: Tue, 16 Nov 2021 11:06:36 +0000 +Message-Id: <20211116110637.125579-14-maximedevos@telenet.be> +In-Reply-To: <20211116110637.125579-1-maximedevos@telenet.be> +References: <175c3a6572e832d84927937b309a3095cadf5702.camel@telenet.be> + <20211116110637.125579-1-maximedevos@telenet.be> +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +* configure.ac: Detect if ‘openat’ is defined. +* libguile/filesys.c + (flags_to_mode): Extract from ... + (scm_mode): ... here. + (scm_open_fdes_at, scm_openat): Define the Scheme bindings. +* libguile/filesys.h (scm_open_fdes_at, scm_openat): Make them part + of the API. +* doc/ref/posix.texi (File System): Document them. +* test-suite/tests/filesys.test ("openat"): Test ‘openat’. +* libguile/syscalls.h (openat_or_openat64): Decide between ‘openat’ + and ‘openat64’. +--- + configure.ac | 3 +- + doc/ref/posix.texi | 13 +++++ + libguile/filesys.c | 96 +++++++++++++++++++++++++++-------- + libguile/filesys.h | 2 + + libguile/syscalls.h | 1 + + test-suite/tests/filesys.test | 73 ++++++++++++++++++++++++++ + 6 files changed, 167 insertions(+), 21 deletions(-) + +diff --git a/configure.ac b/configure.ac +index e073e04f4..905e4d465 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -478,7 +478,7 @@ AC_CHECK_HEADERS([assert.h crt_externs.h]) + # isblank - available as a GNU extension or in C99 + # _NSGetEnviron - Darwin specific + # strcoll_l, newlocale, uselocale, utimensat, futimens, fchmodat, +-# unlinkat, fchownat, fstatat - POSIX.1-2008 ++# unlinkat, fchownat, fstatat, openat - POSIX.1-2008 + # strtol_l - non-POSIX, found in glibc + # fork - unavailable on Windows + # sched_getaffinity, sched_setaffinity - GNU extensions (glibc) +@@ -495,6 +495,7 @@ AC_CHECK_FUNCS([DINFINITY DQNAN cexp chsize clog clog10 ctermid \ + getgrent kill getppid getpgrp fork setitimer getitimer strchr strcmp \ + index bcopy memcpy rindex truncate isblank _NSGetEnviron \ + strcoll strcoll_l strtod_l strtol_l newlocale uselocale utimensat \ ++ openat \ + fstatat futimens sched_getaffinity sched_setaffinity sendfile]) + + # The newlib C library uses _NL_ prefixed locale langinfo constants. +diff --git a/doc/ref/posix.texi b/doc/ref/posix.texi +index cdd03f141..3619ee2c3 100644 +--- a/doc/ref/posix.texi ++++ b/doc/ref/posix.texi +@@ -296,12 +296,25 @@ Create the file if it does not already exist. + for additional flags. + @end deffn + ++@deffn {Scheme Procedure} openat dir path flags [mode] ++@deffnx {C Function} scm_openat (dir, path, flags, mode) ++Similar to @code{open}, but resolve the file name @var{path} ++relative to the directory referred to by the file port @var{dir} ++instead. ++@end deffn ++ + @deffn {Scheme Procedure} open-fdes path flags [mode] + @deffnx {C Function} scm_open_fdes (path, flags, mode) + Similar to @code{open} but return a file descriptor instead of + a port. + @end deffn + ++@deffn {Scheme Procedure} open-fdes-at dir path flags [mode] ++@deffnx {C Function} scm_open_fdes_at (dir, path, flags, mode) ++Similar to @code{openat}, but return a file descriptor instead ++of a port. ++@end deffn ++ + @deffn {Scheme Procedure} close fd_or_port + @deffnx {C Function} scm_close (fd_or_port) + Similar to @code{close-port} (@pxref{Ports, close-port}), +diff --git a/libguile/filesys.c b/libguile/filesys.c +index d045a672f..dadbe3393 100644 +--- a/libguile/filesys.c ++++ b/libguile/filesys.c +@@ -249,6 +249,60 @@ SCM_DEFINE (scm_open_fdes, "open-fdes", 2, 1, 0, + } + #undef FUNC_NAME + ++#ifdef HAVE_OPENAT ++SCM_DEFINE (scm_open_fdes_at, "open-fdes-at", 3, 1, 0, ++ (SCM dir, SCM path, SCM flags, SCM mode), ++ "Similar to @code{openat}, but return a file descriptor instead\n" ++ "of a port.") ++#define FUNC_NAME s_scm_open_fdes_at ++{ ++ int dir_fdes; ++ int fd; ++ int iflags; ++ int imode; ++ ++ iflags = SCM_NUM2INT (SCM_ARG2, flags); ++ imode = SCM_NUM2INT_DEF (3, mode, 0666); ++ SCM_VALIDATE_OPFPORT (SCM_ARG1, dir); ++ dir_fdes = SCM_FPORT_FDES (dir); ++ ++ STRING_SYSCALL (path, c_path, ++ fd = openat_or_openat64 (dir_fdes, c_path, iflags, imode)); ++ scm_remember_upto_here_1 (dir); ++ if (fd == -1) ++ SCM_SYSERROR; ++ return scm_from_int (fd); ++} ++#undef FUNC_NAME ++#endif /* HAVE_OPENAT */ ++ ++/* A helper function for converting some open flags to ++ what scm_fdes_to_port expects. */ ++static char * ++flags_to_mode (int iflags) ++{ ++ if ((iflags & O_RDWR) == O_RDWR) ++ { ++ /* Opened read-write. */ ++ if (iflags & O_APPEND) ++ return "a+"; ++ else if (iflags & O_CREAT) ++ return "w+"; ++ else ++ return "r+"; ++ } ++ else ++ { ++ /* Opened read-only or write-only. */ ++ if (iflags & O_APPEND) ++ return "a"; ++ else if (iflags & O_WRONLY) ++ return "w"; ++ else ++ return "r"; ++ } ++} ++ + SCM_DEFINE (scm_open, "open", 2, 1, 0, + (SCM path, SCM flags, SCM mode), + "Open the file named by @var{path} for reading and/or writing.\n" +@@ -285,31 +339,33 @@ SCM_DEFINE (scm_open, "open", 2, 1, 0, + fd = scm_to_int (scm_open_fdes (path, flags, mode)); + iflags = SCM_NUM2INT (2, flags); + +- if ((iflags & O_RDWR) == O_RDWR) +- { +- /* Opened read-write. */ +- if (iflags & O_APPEND) +- port_mode = "a+"; +- else if (iflags & O_CREAT) +- port_mode = "w+"; +- else +- port_mode = "r+"; +- } +- else +- { +- /* Opened read-only or write-only. */ +- if (iflags & O_APPEND) +- port_mode = "a"; +- else if (iflags & O_WRONLY) +- port_mode = "w"; +- else +- port_mode = "r"; +- } ++ port_mode = (char *) flags_to_mode (iflags); ++ newpt = scm_fdes_to_port (fd, port_mode, path); ++ return newpt; ++} ++#undef FUNC_NAME + ++#ifdef HAVE_OPENAT ++SCM_DEFINE (scm_openat, "openat", 3, 1, 0, ++ (SCM dir, SCM path, SCM flags, SCM mode), ++ "Similar to @code{open}, but resolve the file name @var{path}\n" ++ "relative to the directory referred to by the file port @var{dir}\n" ++ "instead.") ++#define FUNC_NAME s_scm_openat ++{ ++ SCM newpt; ++ char *port_mode; ++ int fd; ++ int iflags; ++ ++ iflags = SCM_NUM2INT (2, flags); ++ port_mode = (char *) flags_to_mode (iflags); ++ fd = scm_to_int (scm_open_fdes_at (dir, path, flags, mode)); + newpt = scm_fdes_to_port (fd, port_mode, path); + return newpt; + } + #undef FUNC_NAME ++#endif /* HAVE_OPENAT */ + + SCM_DEFINE (scm_close, "close", 1, 0, 0, + (SCM fd_or_port), +diff --git a/libguile/filesys.h b/libguile/filesys.h +index 8af0f989a..1ce50d30e 100644 +--- a/libguile/filesys.h ++++ b/libguile/filesys.h +@@ -44,7 +44,9 @@ SCM_API SCM scm_chmod (SCM object, SCM mode); + SCM_API SCM scm_chmodat (SCM dir, SCM pathname, SCM mode, SCM flags); + SCM_API SCM scm_umask (SCM mode); + SCM_API SCM scm_open_fdes (SCM path, SCM flags, SCM mode); ++SCM_API SCM scm_open_fdes_at (SCM dir, SCM path, SCM flags, SCM mode); + SCM_API SCM scm_open (SCM path, SCM flags, SCM mode); ++SCM_API SCM scm_openat (SCM dir, SCM path, SCM flags, SCM mode); + SCM_API SCM scm_close (SCM fd_or_port); + SCM_API SCM scm_close_fdes (SCM fd); + SCM_API SCM scm_stat (SCM object, SCM exception_on_error); +diff --git a/libguile/syscalls.h b/libguile/syscalls.h +index 37d532e60..6f4061138 100644 +--- a/libguile/syscalls.h ++++ b/libguile/syscalls.h +@@ -58,6 +58,7 @@ + #define lstat_or_lstat64 CHOOSE_LARGEFILE(lstat,lstat64) + #define off_t_or_off64_t CHOOSE_LARGEFILE(off_t,off64_t) + #define open_or_open64 CHOOSE_LARGEFILE(open,open64) ++#define openat_or_openat64 CHOOSE_LARGEFILE(openat,openat64) + #define readdir_or_readdir64 CHOOSE_LARGEFILE(readdir,readdir64) + #if SCM_HAVE_READDIR64_R == 1 + # define readdir_r_or_readdir64_r CHOOSE_LARGEFILE(readdir_r,readdir64_r) +diff --git a/test-suite/tests/filesys.test b/test-suite/tests/filesys.test +index b794b07b3..45e77c823 100644 +--- a/test-suite/tests/filesys.test ++++ b/test-suite/tests/filesys.test +@@ -728,3 +728,76 @@ + (skip-if-unsupported) + (delete-file-at (call-with-port (open "." O_RDONLY) identity) + "irrelevant"))) ++ ++(with-test-prefix "openat" ++ (define (skip-if-unsupported) ++ (unless (defined? 'openat) ++ (throw 'unsupported))) ++ ++ (define file (search-path %load-path "ice-9/boot-9.scm")) ++ ++ (define (call-with-relatively-opened-file directory-arguments file-arguments ++ proc) ++ (call-with-port ++ (apply open directory-arguments) ++ (lambda (directory) ++ (call-with-port ++ (apply openat directory file-arguments) ++ (lambda (port) ++ (proc port)))))) ++ ++ (pass-if-equal "mode read-only" "r" ++ (skip-if-unsupported) ++ (call-with-relatively-opened-file ++ (list (dirname file) O_RDONLY) ++ (list (basename file) O_RDONLY) ++ (lambda (port) (port-mode port)))) ++ ++ (pass-if-equal "port-revealed count" 0 ++ (skip-if-unsupported) ++ (call-with-relatively-opened-file ++ (list (dirname file) O_RDONLY) ++ (list (basename file) O_RDONLY) ++ (lambda (port) (port-revealed port)))) ++ ++ (when (file-exists? (test-file)) ++ (delete-file (test-file))) ++ ++ (pass-if-equal "O_CREAT/O_WRONLY" (list #t (logand (lognot (umask)) #o666) "w") ++ (skip-if-unsupported) ++ (call-with-relatively-opened-file ++ (list (dirname (test-file)) O_RDONLY) ++ (list (basename (test-file)) (logior O_WRONLY O_CREAT)) ++ (lambda (port) ++ (list (file-exists? (test-file)) ++ (stat:perms (stat (test-file))) ++ (port-mode port))))) ++ ++ (when (file-exists? (test-file)) ++ (delete-file (test-file))) ++ ++ (pass-if-equal "O_CREAT/O_WRONLY, non-default mode" ++ (list #t (logand (lognot (umask)) #o700) "w") ++ (skip-if-unsupported) ++ (call-with-relatively-opened-file ++ (list (dirname (test-file)) O_RDONLY) ++ (list (basename (test-file)) (logior O_WRONLY O_CREAT) #o700) ++ (lambda (port) ++ (list (file-exists? (test-file)) ++ (stat:perms (stat (test-file))) ++ (port-mode port))))) ++ ++ (pass-if-exception "closed port" exception:wrong-type-arg ++ (skip-if-unsupported) ++ (openat (call-with-port (open "." O_RDONLY) identity) "." O_RDONLY)) ++ ++ (pass-if-exception "non-file port" exception:wrong-type-arg ++ (skip-if-unsupported) ++ (openat (open-input-string "") "." O_RDONLY)) ++ ++ (pass-if-exception "not a port" exception:wrong-type-arg ++ (skip-if-unsupported) ++ (openat "not a port" "." O_RDONLY)) ++ ++ (when (file-exists? (test-file)) ++ (delete-file (test-file)))) +-- +2.30.2 + + base-commit: 29091731a0c6cb649cdfd72297575fe2bb2a9591 prerequisite-patch-id: e2faf5cdf72f293aca0aff5c89cc1f0dd874d29c prerequisite-patch-id: 72285c2232e09bc1637c174b4489e13bb76c0427 -- 2.34.0 From unknown Sat Jun 14 03:56:08 2025 X-Loop: help-debbugs@gnu.org Subject: [bug#54485] [PATCH] gnu: Add guile-with-openat. Resent-From: Maxime Devos Original-Sender: "Debbugs-submit" Resent-CC: guix-patches@gnu.org Resent-Date: Sun, 20 Mar 2022 22:40:02 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: followup 54485 X-GNU-PR-Package: guix-patches X-GNU-PR-Keywords: patch To: 54485@debbugs.gnu.org Received: via spool by 54485-submit@debbugs.gnu.org id=B54485.16478159734391 (code B ref 54485); Sun, 20 Mar 2022 22:40:02 +0000 Received: (at 54485) by debbugs.gnu.org; 20 Mar 2022 22:39:33 +0000 Received: from localhost ([127.0.0.1]:35260 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1nW4Cy-00018l-Nx for submit@debbugs.gnu.org; Sun, 20 Mar 2022 18:39:32 -0400 Received: from xavier.telenet-ops.be ([195.130.132.52]:38862) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1nW4Cw-00018a-Dy for 54485@debbugs.gnu.org; Sun, 20 Mar 2022 18:39:31 -0400 Received: from ptr-bvsjgyhxw7psv60dyze.18120a2.ip6.access.telenet.be ([IPv6:2a02:1811:8c09:9d00:3c5f:2eff:feb0:ba5a]) by xavier.telenet-ops.be with bizsmtp id 8mfU270054UW6Th01mfULC; Sun, 20 Mar 2022 23:39:28 +0100 Message-ID: <2f7c8703b40c2a29bdf13813ccefbae98580e847.camel@telenet.be> From: Maxime Devos Date: Sun, 20 Mar 2022 23:39:23 +0100 In-Reply-To: <20220320215031.306710-1-maximedevos@telenet.be> References: <20220320215031.306710-1-maximedevos@telenet.be> Content-Type: multipart/signed; micalg="pgp-sha512"; protocol="application/pgp-signature"; boundary="=-1fpb4FP+u6JnWpTlD/T7" User-Agent: Evolution 3.38.3-1 MIME-Version: 1.0 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=telenet.be; s=r22; t=1647815968; bh=i0d/AynNtfGcZ4Ci7DohNwrJXKfqeX7jf91ClBx5gUo=; h=Subject:From:To:Date:In-Reply-To:References; b=NqrpvSyoHbixteNT+3IFQ4PDTIMn4JzD8Pv38CpcQs2h57HZuIEM+m5EJTFUFjWmj CEAFyADBUCyhtIuLBoGP++NtyJNmq/ZpgYycyi+1Xx+t8iK7qqiS4PkBqurfotoBD7 jv8Liwj0xfX8jKCMU/KXTZsajy2NHnqhiu3+KEwNceCzav/AgMgBlk+yB0y1VL4p6S zwQVIQsNP3C4DCoLXpaVguiHwu2HAYv4sDpykUX/WIlpL8zQIDHx2h1Vnm/Rb04Ped FOlnFDJARw+58C7sWfMnjmvoQR5ZLS+pgNZxuWvWKhjG+Ey8H0Ih6imHWpNoisYsQH cxPqxxBl7XNIQ== X-Spam-Score: -0.7 (/) X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.7 (-) --=-1fpb4FP+u6JnWpTlD/T7 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Maxime Devos schreef op zo 20-03-2022 om 21:50 [+0000]: > XXX Don't apply yet, let's wait for > "./pre-inst-env guix build guile-with-openat" to complete first. Looks like it fails because 'texinfo' is missing from the 'native-inputs', let's retry ... --=-1fpb4FP+u6JnWpTlD/T7 Content-Type: application/pgp-signature; name="signature.asc" Content-Description: This is a digitally signed message part Content-Transfer-Encoding: 7bit -----BEGIN PGP SIGNATURE----- iI0EABYKADUWIQTB8z7iDFKP233XAR9J4+4iGRcl7gUCYjetGxccbWF4aW1lZGV2 b3NAdGVsZW5ldC5iZQAKCRBJ4+4iGRcl7jI0AQCBfQ3XqYDoji3uIwzfZDtlFopM MeNzZfZz6WhAq+uHIQEA60KYVOkqxVLO5n37sE+aD6f6Q77Fv+MfILvGmDaAUgY= =8W7L -----END PGP SIGNATURE----- --=-1fpb4FP+u6JnWpTlD/T7-- From unknown Sat Jun 14 03:56:08 2025 X-Loop: help-debbugs@gnu.org Subject: [bug#54485] [PATCH] gnu: Add guile-with-openat. Resent-From: Maxime Devos Original-Sender: "Debbugs-submit" Resent-CC: guix-patches@gnu.org Resent-Date: Mon, 21 Mar 2022 14:25:01 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: followup 54485 X-GNU-PR-Package: guix-patches X-GNU-PR-Keywords: patch To: 54485@debbugs.gnu.org Received: via spool by 54485-submit@debbugs.gnu.org id=B54485.164787264818171 (code B ref 54485); Mon, 21 Mar 2022 14:25:01 +0000 Received: (at 54485) by debbugs.gnu.org; 21 Mar 2022 14:24:08 +0000 Received: from localhost ([127.0.0.1]:37757 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1nWIx5-0004j1-R4 for submit@debbugs.gnu.org; Mon, 21 Mar 2022 10:24:07 -0400 Received: from albert.telenet-ops.be ([195.130.137.90]:34106) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1nWIx3-0004is-RN for 54485@debbugs.gnu.org; Mon, 21 Mar 2022 10:24:06 -0400 Received: from ptr-bvsjgyhxw7psv60dyze.18120a2.ip6.access.telenet.be ([IPv6:2a02:1811:8c09:9d00:3c5f:2eff:feb0:ba5a]) by albert.telenet-ops.be with bizsmtp id 92Q3270094UW6Th062Q30L; Mon, 21 Mar 2022 15:24:04 +0100 Message-ID: <4f4d275b86619feeb257b06c645395a92312608b.camel@telenet.be> From: Maxime Devos Date: Mon, 21 Mar 2022 15:24:03 +0100 In-Reply-To: <2f7c8703b40c2a29bdf13813ccefbae98580e847.camel@telenet.be> References: <20220320215031.306710-1-maximedevos@telenet.be> <2f7c8703b40c2a29bdf13813ccefbae98580e847.camel@telenet.be> Content-Type: multipart/signed; micalg="pgp-sha512"; protocol="application/pgp-signature"; boundary="=-dnqdXpYPK2txRi4ojXGK" User-Agent: Evolution 3.38.3-1 MIME-Version: 1.0 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=telenet.be; s=r22; t=1647872644; bh=486NlmgwnDFfl3r/0smEKdzRDQ8klbNE+Z7xSgJw1pM=; h=Subject:From:To:Date:In-Reply-To:References; b=e1VRrKKqiudXGWWAZ68KwvnxDmrHOKGv1mfR8fdwfvxzobPBkJhHe77k7OTEq/VBJ aBDZrd6FBvx5wOwdJ3CNeEDwoI6lhWbCCYMM8B5zMAeithibqsNDElpS0lO6PWuphf zTuTdVuRAFPIM3ncecH24TkM18ohR3sYnkabxmSFySzeRi1I2cghUHndmAK1ARVktl jqqpT724OT09YZkeNMrKqXL7frvZdLfm4aWhmug5C9ne7johuFb0LSVZ7HR8YYMw8e Wk/GL8FLDDlgtprF/IRkDnVctQgGZyI7LMo3EsVxcDmvxAS95sGbuuv6VSKN2MmOOc NlSdplGYmL6Iw== X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" --=-dnqdXpYPK2txRi4ojXGK Content-Type: multipart/mixed; boundary="=-yubAqj78CxTHWr8cQJRG" --=-yubAqj78CxTHWr8cQJRG Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Maxime Devos schreef op zo 20-03-2022 om 23:39 [+0100]: > Maxime Devos schreef op zo 20-03-2022 om 21:50 [+0000]: > > XXX Don't apply yet, let's wait for > > "./pre-inst-env guix build guile-with-openat" to complete first. >=20 > Looks like it fails because 'texinfo' is missing from the > 'native-inputs', let's retry ... See attachment. Next step: modify 'mkdir-p/perms' to be race-free, using 'openat', 'chownat' and perhaps 'statat' ... Greetings, Maxime. --=-yubAqj78CxTHWr8cQJRG Content-Disposition: attachment; filename="0001-gnu-Add-guile-with-openat.patch" Content-Type: text/x-patch; name="0001-gnu-Add-guile-with-openat.patch"; charset="UTF-8" Content-Transfer-Encoding: base64 RnJvbSBhYWMyOWI5NTJlNTU4ZTIwYWM5N2E5NTcxM2IxNWFjNDUzZTU5NzQyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXhpbWUgRGV2b3MgPG1heGltZWRldm9zQHRlbGVuZXQuYmU+ CkRhdGU6IFN1biwgMjAgTWFyIDIwMjIgMjE6Mjk6MjkgKzAwMDAKU3ViamVjdDogW1BBVENIXSBn bnU6IEFkZCBndWlsZS13aXRoLW9wZW5hdC4KClRoaXMgd2lsbCBhbGxvdyB1cyB0byB3b3JrIG9u IHJlc29sdmluZyB0aGUgPjEgeWVhciBwdWJsaWNseQprbm93biBwcml2aWxlZ2UgZXNjYWxhdGlv biwgc2VlIDxodHRwczovL2lzc3Vlcy5ndWl4LmdudS5vcmcvNDc1ODQ+LgoKKiBnbnUvcGFja2Fn ZXMvZ3VpbGUuc2NtIChndWlsZS13aXRoLW9wZW5hdCk6IE5ldyB2YXJpYWJsZS4KLS0tCiBnbnUv bG9jYWwubWsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMTQgKwogZ251L3Bh Y2thZ2VzL2d1aWxlLnNjbSAgICAgICAgICAgICAgICAgICAgICAgIHwgIDQ3ICsrLQogLi4uL3Bh dGNoZXMvZ3VpbGUtb3BlbmF0LWFuZC1mcmllbmRzLTAxLnBhdGNoIHwgMTkzICsrKysrKysrKysr CiAuLi4vcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDIucGF0Y2ggfCAyMTkgKysr KysrKysrKysrCiAuLi4vcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDMucGF0Y2gg fCAyNjkgKysrKysrKysrKysrKysrCiAuLi4vcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVu ZHMtMDQucGF0Y2ggfCAxNDIgKysrKysrKysKIC4uLi9wYXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQt ZnJpZW5kcy0wNS5wYXRjaCB8IDE1OSArKysrKysrKysKIC4uLi9wYXRjaGVzL2d1aWxlLW9wZW5h dC1hbmQtZnJpZW5kcy0wNi5wYXRjaCB8ICAzNyArKysKIC4uLi9wYXRjaGVzL2d1aWxlLW9wZW5h dC1hbmQtZnJpZW5kcy0wNy5wYXRjaCB8ICA0MCArKysKIC4uLi9wYXRjaGVzL2d1aWxlLW9wZW5h dC1hbmQtZnJpZW5kcy0wOC5wYXRjaCB8IDI0MCArKysrKysrKysrKysrCiAuLi4vcGF0Y2hlcy9n dWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDkucGF0Y2ggfCAxNzMgKysrKysrKysrKwogLi4uL3Bh dGNoZXMvZ3VpbGUtb3BlbmF0LWFuZC1mcmllbmRzLTEwLnBhdGNoIHwgMjA0ICsrKysrKysrKysr KwogLi4uL3BhdGNoZXMvZ3VpbGUtb3BlbmF0LWFuZC1mcmllbmRzLTExLnBhdGNoIHwgMTMwICsr KysrKysrCiAuLi4vcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMTIucGF0Y2ggfCAy MzggKysrKysrKysrKysrKwogLi4uL3BhdGNoZXMvZ3VpbGUtb3BlbmF0LWFuZC1mcmllbmRzLTEz LnBhdGNoIHwgMzE0ICsrKysrKysrKysrKysrKysrKwogMTUgZmlsZXMgY2hhbmdlZCwgMjQxNyBp bnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGdudS9wYWNr YWdlcy9wYXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0wMS5wYXRjaAogY3JlYXRlIG1v ZGUgMTAwNjQ0IGdudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0w Mi5wYXRjaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGdudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9w ZW5hdC1hbmQtZnJpZW5kcy0wMy5wYXRjaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGdudS9wYWNrYWdl cy9wYXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0wNC5wYXRjaAogY3JlYXRlIG1vZGUg MTAwNjQ0IGdudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0wNS5w YXRjaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGdudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9wZW5h dC1hbmQtZnJpZW5kcy0wNi5wYXRjaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGdudS9wYWNrYWdlcy9w YXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0wNy5wYXRjaAogY3JlYXRlIG1vZGUgMTAw NjQ0IGdudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0wOC5wYXRj aAogY3JlYXRlIG1vZGUgMTAwNjQ0IGdudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9wZW5hdC1h bmQtZnJpZW5kcy0wOS5wYXRjaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGdudS9wYWNrYWdlcy9wYXRj aGVzL2d1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0xMC5wYXRjaAogY3JlYXRlIG1vZGUgMTAwNjQ0 IGdudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0xMS5wYXRjaAog Y3JlYXRlIG1vZGUgMTAwNjQ0IGdudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQt ZnJpZW5kcy0xMi5wYXRjaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGdudS9wYWNrYWdlcy9wYXRjaGVz L2d1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0xMy5wYXRjaAoKZGlmZiAtLWdpdCBhL2dudS9sb2Nh bC5tayBiL2dudS9sb2NhbC5tawppbmRleCAxMjUyNjQzZGMwLi40MGRkOGM5YzU1IDEwMDY0NAot LS0gYS9nbnUvbG9jYWwubWsKKysrIGIvZ251L2xvY2FsLm1rCkBAIC00OSw2ICs0OSw3IEBACiAj IENvcHlyaWdodCDCqSAyMDIxIFNpbW9uIFRvdXJuaWVyIDx6aW1vbi50b3V0b3VuZUBnbWFpbC5j b20+CiAjIENvcHlyaWdodCDCqSAyMDIyIERhbmllbCBNZWnDn25lciA8ZGFuaWVsLm1laXNzbmVy LWk0a0BydWhyLXVuaS1ib2NodW0uZGU+CiAjIENvcHlyaWdodCDCqSAyMDIyIFJlbWNvIHZhbiAn dCBWZWVyIDxyZW1jb0ByZW13b3Jrcy5uZXQ+CisjIENvcHlyaWdodCDCqSAyMDIyIE1heGltZSBE ZXZvcyA8bWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KICMKICMgVGhpcyBmaWxlIGlzIHBhcnQgb2Yg R05VIEd1aXguCiAjCkBAIC0xMjM1LDYgKzEyMzYsMTkgQEAgZGlzdF9wYXRjaF9EQVRBID0JCQkJ CQlcCiAgICVEJS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLWZpYmVycy13YWl0LWZvci1pby1yZWFk aW5lc3MucGF0Y2ggXAogICAlRCUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1nZGJtLWZmaS1zdXBw b3J0LWdkYm0tMS4xNC5wYXRjaAlcCiAgICVEJS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLWdpdC1h ZGp1c3QtZm9yLWxpYmdpdDItMS4yLjAucGF0Y2ggXAorICAlRCUvcGFja2FnZXMvcGF0Y2hlcy9n dWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDEucGF0Y2gJXAorICAlRCUvcGFja2FnZXMvcGF0Y2hl cy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDIucGF0Y2gJXAorICAlRCUvcGFja2FnZXMvcGF0 Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDMucGF0Y2gJXAorICAlRCUvcGFja2FnZXMv cGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDQucGF0Y2gJXAorICAlRCUvcGFja2Fn ZXMvcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDUucGF0Y2gJXAorICAlRCUvcGFj a2FnZXMvcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDYucGF0Y2gJXAorICAlRCUv cGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDcucGF0Y2gJXAorICAl RCUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDgucGF0Y2gJXAor ICAlRCUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDkucGF0Y2gJ XAorICAlRCUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMTAucGF0 Y2gJXAorICAlRCUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMTEu cGF0Y2gJXAorICAlRCUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMt MTIucGF0Y2gJXAorICAlRCUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVu ZHMtMTMucGF0Y2gJXAogICAlRCUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1wcmVzZW50LWNvZGlu Zy5wYXRjaAkJXAogICAlRCUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1yc3ZnLXBrZ2NvbmZpZy5w YXRjaAkJXAogICAlRCUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1lbWFjcy1maXgtY29uZmlndXJl LnBhdGNoCQlcCmRpZmYgLS1naXQgYS9nbnUvcGFja2FnZXMvZ3VpbGUuc2NtIGIvZ251L3BhY2th Z2VzL2d1aWxlLnNjbQppbmRleCBmNzRhMzg5ZGE1Li5lZmVlOTZlNjYyIDEwMDY0NAotLS0gYS9n bnUvcGFja2FnZXMvZ3VpbGUuc2NtCisrKyBiL2dudS9wYWNrYWdlcy9ndWlsZS5zY20KQEAgLTE2 LDcgKzE2LDcgQEAKIDs7OyBDb3B5cmlnaHQgwqkgMjAxOCBFcmljIEJhdmllciA8YmF2aWVyQG1l bWJlci5mc2Yub3JnPgogOzs7IENvcHlyaWdodCDCqSAyMDE5IFRheWxhbiBLYW1tZXIgPHRheWxh bi5rYW1tZXJAZ21haWwuY29tPgogOzs7IENvcHlyaWdodCDCqSAyMDIwLCAyMDIxIEVmcmFpbSBG bGFzaG5lciA8ZWZyYWltQGZsYXNobmVyLmNvLmlsPgotOzs7IENvcHlyaWdodCDCqSAyMDIxIE1h eGltZSBEZXZvcyA8bWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KKzs7OyBDb3B5cmlnaHQgwqkgMjAy MSwgMjAyMiBNYXhpbWUgRGV2b3MgPG1heGltZWRldm9zQHRlbGVuZXQuYmU+CiA7OzsgQ29weXJp Z2h0IMKpIDIwMjEgVGltb3RoeSBTYW1wbGUgPHNhbXBsZXRAbmd5cm8uY29tPgogOzs7CiA7Ozsg VGhpcyBmaWxlIGlzIHBhcnQgb2YgR05VIEd1aXguCkBAIC02MCw2ICs2MCw3IEBACiAgICM6dXNl LW1vZHVsZSAoZ251IHBhY2thZ2VzIHZlcnNpb24tY29udHJvbCkKICAgIzp1c2UtbW9kdWxlIChn dWl4IHBhY2thZ2VzKQogICAjOnVzZS1tb2R1bGUgKGd1aXggZG93bmxvYWQpCisgICM6dXNlLW1v ZHVsZSAoZ3VpeCBnZXhwKQogICAjOnVzZS1tb2R1bGUgKGd1aXggZ2l0LWRvd25sb2FkKQogICAj OnVzZS1tb2R1bGUgKGd1aXggYnVpbGQtc3lzdGVtIGdudSkKICAgIzp1c2UtbW9kdWxlIChndWl4 IGJ1aWxkLXN5c3RlbSBndWlsZSkKQEAgLTE2Myw3ICsxNjQsNiBAQCB3aXRob3V0IHJlcXVpcmlu ZyB0aGUgc291cmNlIGNvZGUgdG8gYmUgcmV3cml0dGVuLiIpCiAgICAgICAgICAgICAgICAgICAg ICgicGtnY29uZmlnIiAscGtnLWNvbmZpZykpKQogICAgKGlucHV0cyBgKCgibGliZmZpIiAsbGli ZmZpKQogICAgICAgICAgICAgICxAKGxpYmljb252LWlmLW5lZWRlZCkKLQogICAgICAgICAgICAg IDs7IFdlIG5lZWQgQmFzaCB3aGVuIGNyb3NzLWNvbXBpbGluZyBiZWNhdXNlIHNvbWUgb2YgdGhl IHNjcmlwdHMKICAgICAgICAgICAgICA7OyBpbiBiaW4vIHJlZmVyIHRvIGl0LiAgVXNlICdiYXNo LW1pbmltYWwnIGJlY2F1c2Ugd2UgZG9uJ3QgbmVlZAogICAgICAgICAgICAgIDs7IGFuIGludGVy YWN0aXZlIEJhc2ggd2l0aCBSZWFkbGluZSBhbmQgYWxsLgpAQCAtMzg4LDYgKzM4OCw0OSBAQCB3 aXRob3V0IHJlcXVpcmluZyB0aGUgc291cmNlIGNvZGUgdG8gYmUgcmV3cml0dGVuLiIpCiAgICAg ICAgICAgICAoZmlsZXMgJygibGliL2d1aWxlLzMuMC9zaXRlLWNjYWNoZSIKICAgICAgICAgICAg ICAgICAgICAgICJzaGFyZS9ndWlsZS9zaXRlLzMuMCIpKSkpKSkpCiAKKzs7IChBIHN0YXRpYyB2 YXJpYW50IG9mKSB0aGlzIHBhY2thZ2Ugd2lsbCBiZSB1c2VkIHRvIGltcGxlbWVudAorOzsgVE9D VE9VLWZyZWUgYmVoYXZpb3VyIGluIDxodHRwczovL2lzc3Vlcy5ndWl4LmdudS5vcmcvNTQzMDk+ Cis7OyBhbmQgPGh0dHBzOi8vaXNzdWVzLmd1aXguZ251Lm9yZy80NzU4ND4uCisoZGVmaW5lLXB1 YmxpYyBndWlsZS13aXRoLW9wZW5hdAorICAocGFja2FnZQorICAgIChpbmhlcml0CisgICAgIChw YWNrYWdlLXdpdGgtZXh0cmEtcGF0Y2hlcyBndWlsZS0zLjAKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIChzZWFyY2gtcGF0Y2hlcworICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICJndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDEucGF0Y2giCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgImd1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0wMi5wYXRjaCIK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiZ3VpbGUtb3BlbmF0LWFuZC1mcmll bmRzLTAzLnBhdGNoIgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJndWlsZS1v cGVuYXQtYW5kLWZyaWVuZHMtMDQucGF0Y2giCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgImd1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0wNS5wYXRjaCIKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAiZ3VpbGUtb3BlbmF0LWFuZC1mcmllbmRzLTA2LnBhdGNoIgor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJndWlsZS1vcGVuYXQtYW5kLWZyaWVu ZHMtMDcucGF0Y2giCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgImd1aWxlLW9w ZW5hdC1hbmQtZnJpZW5kcy0wOC5wYXRjaCIKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAiZ3VpbGUtb3BlbmF0LWFuZC1mcmllbmRzLTA5LnBhdGNoIgorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICJndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMTAucGF0Y2giCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgImd1aWxlLW9wZW5hdC1hbmQtZnJpZW5k cy0xMS5wYXRjaCIKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiZ3VpbGUtb3Bl bmF0LWFuZC1mcmllbmRzLTEyLnBhdGNoIgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICJndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMTMucGF0Y2giKSkpCisgICAgKG5hbWUgImd1 aWxlLXdpdGgtb3BlbmF0IikKKyAgICAoYXJndW1lbnRzCisgICAgIChzdWJzdGl0dXRlLWtleXdv cmQtYXJndW1lbnRzIChwYWNrYWdlLWFyZ3VtZW50cyBndWlsZS0zLjApCisgICAgICAgKCgjOnBo YXNlcyBwaGFzZXMpCisgICAgICAgICN+KG1vZGlmeS1waGFzZXMgIyRwaGFzZXMKKyAgICAgICAg ICAgIChhZGQtYWZ0ZXIgJ3VucGFjayAncmVjb25maWd1cmUKKyAgICAgICAgICAgICAgKGxhbWJk YSBfCisgICAgICAgICAgICAgICAgOzsgQXZvaWQgdXNpbmcgdGhlIG91dC1vZi1kYXRlIGNvbmZp Z3VyZSwgc3VjaCB0aGF0ICdvcGVuYXQnCisgICAgICAgICAgICAgICAgOzsgYW5kIGZyaWVuZHMg d2lsbCBiZSBkZXRlY3RlZC4KKyAgICAgICAgICAgICAgICAoZGVsZXRlLWZpbGUgImNvbmZpZ3Vy ZSIpKSkpKSkpCisgICAgKG5hdGl2ZS1pbnB1dHMKKyAgICAgKG1vZGlmeS1pbnB1dHMgKHBhY2th Z2UtbmF0aXZlLWlucHV0cyBndWlsZS0zLjApCisgICAgICAgKHByZXBlbmQgYXV0b2NvbmYgYXV0 b21ha2UgZ251LWdldHRleHQgbGlidG9vbCB0ZXhpbmZvKSkpCisgICAgKHN5bm9wc2lzICJHdWls ZSwgd2l0aCBzdXBwb3J0IGZvciBAY29kZXtvcGVuYXR9IGFuZCBmcmllbmRzIikKKyAgICAoZGVz Y3JpcHRpb24gIlRoaXMgaXMgYSB2YXJpYW50IG9mIHRoZSBHdWlsZSBwYWNrYWdlLCBleHRlbmRp bmcgdGhlCitmaWxlIHN5c3RlbSBpbnRlcmZhY2UgdG8gc3VwcG9ydCBtb3JlIGRpcmVjdG9yeS1y ZWxhdGl2ZSBvcGVyYXRpb25zLgorCitNb3JlIGNvbmNyZXRlbHksIGl0IGFkZHMgYSBwcm9jZWR1 cmUgQGNvZGV7b3BlbmF0fSB0aGF0IGNhbiBiZSB1c2VkCit0byBvcGVuIGEgZmlsZSBpbiBhIGRp cmVjdG9yeSB0aGF0IGhhcyBiZWVuIG9wZW5lZCAoYXMgYSBwb3J0KSwgd2l0aG91dAorQGFjcm9u eW17VE9DVE9VLHRpbWUtb2YtY2hlY2sgdG8gdGltZS1vZi11c2V9IGlzc3VlcywgYW5kIGEgZmV3 IG90aGVyCitwcm9jZWR1cmVzIG9mIGEgc2ltaWxhciBuYXR1cmUuIikpKQorCiAoZGVmaW5lLXB1 YmxpYyBndWlsZS0zLjAtbGF0ZXN0CiAgIChwYWNrYWdlCiAgICAgKGluaGVyaXQgZ3VpbGUtMy4w KQpkaWZmIC0tZ2l0IGEvZ251L3BhY2thZ2VzL3BhdGNoZXMvZ3VpbGUtb3BlbmF0LWFuZC1mcmll bmRzLTAxLnBhdGNoIGIvZ251L3BhY2thZ2VzL3BhdGNoZXMvZ3VpbGUtb3BlbmF0LWFuZC1mcmll bmRzLTAxLnBhdGNoCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAuLmQ0MzBm Yjk5ZTMKLS0tIC9kZXYvbnVsbAorKysgYi9nbnUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1vcGVu YXQtYW5kLWZyaWVuZHMtMDEucGF0Y2gKQEAgLTAsMCArMSwxOTMgQEAKK0d1aXgtVXBzdHJlYW06 IGh0dHBzOi8vbGlzdHMuZ251Lm9yZy9hcmNoaXZlL2h0bWwvZ3VpbGUtZGV2ZWwvMjAyMS0xMS9t c2cwMDAwNS5odG1sCitGcm9tOiBNYXhpbWUgRGV2b3MgPG1heGltZWRldm9zQHRlbGVuZXQuYmU+ CitTdWJqZWN0OiBbUEFUQ0ggdjIgMDEvMTRdCisgPT9VVEYtOD9xP0FsbG93PTIwZmlsZT0yMHBv cnRzPTIwaW49MjA9RTI9ODA9OThjPz0KKyA9P1VURi04P3E/aGRpcj1FMj04MD05OT0yMHdoZW49 MjBzdXBwb3J0ZWQuPz0KK0RhdGU6IFR1ZSwgMTYgTm92IDIwMjEgMTE6MDY6MjQgKzAwMDAKK01l c3NhZ2UtSWQ6IDwyMDIxMTExNjExMDYzNy4xMjU1NzktMi1tYXhpbWVkZXZvc0B0ZWxlbmV0LmJl PgorSW4tUmVwbHktVG86IDwyMDIxMTExNjExMDYzNy4xMjU1NzktMS1tYXhpbWVkZXZvc0B0ZWxl bmV0LmJlPgorUmVmZXJlbmNlczogPDE3NWMzYTY1NzJlODMyZDg0OTI3OTM3YjMwOWEzMDk1Y2Fk ZjU3MDIuY2FtZWxAdGVsZW5ldC5iZT4KKyA8MjAyMTExMTYxMTA2MzcuMTI1NTc5LTEtbWF4aW1l ZGV2b3NAdGVsZW5ldC5iZT4KK01JTUUtVmVyc2lvbjogMS4wCitDb250ZW50LVR5cGU6IHRleHQv cGxhaW47IGNoYXJzZXQ9VVRGLTgKK0NvbnRlbnQtVHJhbnNmZXItRW5jb2Rpbmc6IDhiaXQKKwor KiBjb25maWd1cmUuYWM6IENoZWNrIGZvciDigJhmY2hkaXLigJkuCisqIGxpYmd1aWxlL2ZpbGVz eXMuYworKHNjbV9jaGRpcik6IFN1cHBvcnQgZmlsZSBwb3J0cy4KKyhzY21faW5pdF9maWxlc3lz KTogUmVwb3J0IHN1cHBvcnQgb2YgZmlsZSBwb3J0cy4KKyogZG9jL3JlZi9wb3NpeC50ZXhpIChQ cm9jZXNzZXMpOiBVcGRhdGUgYWNjb3JkaW5nbHkuCisqIGRvYy9yZWYvZ3VpbGUudGV4aTogQWRk IGNvcHlyaWdodCBsaW5lIGZvciBuZXcgZG9jdW1lbnRhdGlvbiBpbiB0aGlzCitwYXRjaCBhbmQg bGF0ZXIgcGF0Y2hlcy4KKyogdGVzdC1zdWl0ZS90ZXN0cy9maWxlc3lzLnRlc3QgKCJjaGRpciIp OiBUZXN0IGl0LgorLS0tCisgY29uZmlndXJlLmFjICAgICAgICAgICAgICAgICAgfCAgMyArKy0K KyBkb2MvcmVmL2d1aWxlLnRleGkgICAgICAgICAgICB8ICAzICsrLQorIGRvYy9yZWYvcG9zaXgu dGV4aSAgICAgICAgICAgIHwgIDUgKysrKy0KKyBsaWJndWlsZS9maWxlc3lzLmMgICAgICAgICAg ICB8IDIzICsrKysrKysrKysrKysrKysrKystCisgdGVzdC1zdWl0ZS90ZXN0cy9maWxlc3lzLnRl c3QgfCA0MSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKworIDUgZmlsZXMgY2hh bmdlZCwgNzEgaW5zZXJ0aW9ucygrKSwgNCBkZWxldGlvbnMoLSkKKworZGlmZiAtLWdpdCBhL2Nv bmZpZ3VyZS5hYyBiL2NvbmZpZ3VyZS5hYworaW5kZXggYmQ0OWJmMTYyLi5iN2U0NjYzZjcgMTAw NjQ0CistLS0gYS9jb25maWd1cmUuYWMKKysrKyBiL2NvbmZpZ3VyZS5hYworQEAgLTQ4NCw3ICs0 ODQsOCBAQCBBQ19DSEVDS19IRUFERVJTKFthc3NlcnQuaCBjcnRfZXh0ZXJucy5oXSkKKyAjICAg c2VuZGZpbGUgLSBub24tUE9TSVgsIGZvdW5kIGluIGdsaWJjCisgIworIEFDX0NIRUNLX0ZVTkNT KFtESU5GSU5JVFkgRFFOQU4gY2V4cCBjaHNpemUgY2xvZyBjbG9nMTAgY3Rlcm1pZCAgICAgICAg IFwKKy0gIGZlc2V0cm91bmQgZnRpbWUgZnRydW5jYXRlIGZjaG93biBmY2htb2QgZ2V0Y3dkIGdl dGV1aWQgZ2V0c2lkICAgICAgICBcCisrICBmZXNldHJvdW5kIGZ0aW1lIGZ0cnVuY2F0ZSBmY2hv d24gZmNobW9kIGZjaGRpcgkJCVwKKysgIGdldGN3ZCBnZXRldWlkIGdldHNpZAkJCQkJCQlcCisg ICBnZXR0aW1lb2ZkYXkgZ2V0dWlkIGdldGdpZCBnbXRpbWVfciBpb2N0bCBsc3RhdCBta2RpciBt a2R0ZW1wIG1rbm9kICAgXAorICAgbmljZSByZWFkbGluayByZW5hbWUgcm1kaXIgc2V0ZWdpZCBz ZXRldWlkICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgIHNldGxvY2FsZSBzZXR1aWQg c2V0Z2lkIHNldHBnaWQgc2V0c2lkIHNpZ2FjdGlvbiBzaWdpbnRlcnJ1cHQgc3RhdDY0ICBcCitk aWZmIC0tZ2l0IGEvZG9jL3JlZi9ndWlsZS50ZXhpIGIvZG9jL3JlZi9ndWlsZS50ZXhpCitpbmRl eCA2NjBiMWFlOTAuLjQ4YWYxZjgyMCAxMDA2NDQKKy0tLSBhL2RvYy9yZWYvZ3VpbGUudGV4aQor KysrIGIvZG9jL3JlZi9ndWlsZS50ZXhpCitAQCAtMTQsNyArMTQsOCBAQAorIFRoaXMgbWFudWFs IGRvY3VtZW50cyBHdWlsZSB2ZXJzaW9uIEB2YWx1ZXtWRVJTSU9OfS4KKyAKKyBDb3B5cmlnaHQg KEMpIDE5OTYtMTk5NywgMjAwMC0yMDA1LCAyMDA5LTIwMjEgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uLAorLUluYy4KKytJbmMuIFxcCisrQ29weXJpZ2h0IChDKSAyMDIxIE1heGltZSBEZXZvcwor IAorIFBlcm1pc3Npb24gaXMgZ3JhbnRlZCB0byBjb3B5LCBkaXN0cmlidXRlIGFuZC9vciBtb2Rp ZnkgdGhpcyBkb2N1bWVudAorIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEZyZWUgRG9jdW1l bnRhdGlvbiBMaWNlbnNlLCBWZXJzaW9uIDEuMyBvcgorZGlmZiAtLWdpdCBhL2RvYy9yZWYvcG9z aXgudGV4aSBiL2RvYy9yZWYvcG9zaXgudGV4aQoraW5kZXggNzYzM2JkNWEzLi43NTU1ZjkzMTkg MTAwNjQ0CistLS0gYS9kb2MvcmVmL3Bvc2l4LnRleGkKKysrKyBiL2RvYy9yZWYvcG9zaXgudGV4 aQorQEAgLTIsNiArMiw3IEBACisgQGMgVGhpcyBpcyBwYXJ0IG9mIHRoZSBHTlUgR3VpbGUgUmVm ZXJlbmNlIE1hbnVhbC4KKyBAYyBDb3B5cmlnaHQgKEMpICAxOTk2LCAxOTk3LCAyMDAwLCAyMDAx LCAyMDAyLCAyMDAzLCAyMDA0LCAyMDA2LCAyMDA3LAorIEBjICAgMjAwOCwgMjAwOSwgMjAxMCwg MjAxMSwgMjAxMiwgMjAxMywgMjAxNCwgMjAxNywgMjAyMSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b24sIEluYy4KKytAYyBDb3B5cmlnaHQgKEMpICAyMDIxIE1heGltZSBEZXZvcyA8bWF4aW1lZGV2 b3NAdGVsZW5ldC5iZT4KKyBAYyBTZWUgdGhlIGZpbGUgZ3VpbGUudGV4aSBmb3IgY29weWluZyBj b25kaXRpb25zLgorIAorIEBub2RlIFBPU0lYCitAQCAtMTYwNSw3ICsxNjA2LDkgQEAgVGhlIHJl dHVybiB2YWx1ZSBpcyB1bnNwZWNpZmllZC4KKyBAZGVmZm4ge1NjaGVtZSBQcm9jZWR1cmV9IGNo ZGlyIHN0cgorIEBkZWZmbngge0MgRnVuY3Rpb259IHNjbV9jaGRpciAoc3RyKQorIEBjaW5kZXgg Y3VycmVudCBkaXJlY3RvcnkKKy1DaGFuZ2UgdGhlIGN1cnJlbnQgd29ya2luZyBkaXJlY3Rvcnkg dG8gQHZhcntzdHJ9LgorK0NoYW5nZSB0aGUgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSB0byBA dmFye3N0cn0uICBAdmFye3N0cn0gY2FuIGJlIGEKKytzdHJpbmcgY29udGFpbmluZyBhIGZpbGUg bmFtZSwgb3IgYSBwb3J0IGlmIHN1cHBvcnRlZCBieSB0aGUgc3lzdGVtLgorK0Bjb2Rleyhwcm92 aWRlZD8gJ2NoZGlyLXBvcnQpfSByZXBvcnRzIHdoZXRoZXIgcG9ydHMgYXJlIHN1cHBvcnRlZC4K KyBUaGUgcmV0dXJuIHZhbHVlIGlzIHVuc3BlY2lmaWVkLgorIEBlbmQgZGVmZm4KKyAKK2RpZmYg LS1naXQgYS9saWJndWlsZS9maWxlc3lzLmMgYi9saWJndWlsZS9maWxlc3lzLmMKK2luZGV4IDYy NDc3MzRlOC4uMmE5YzM2YTEyIDEwMDY0NAorLS0tIGEvbGliZ3VpbGUvZmlsZXN5cy5jCisrKysg Yi9saWJndWlsZS9maWxlc3lzLmMKK0BAIC0xLDUgKzEsNiBAQAorIC8qIENvcHlyaWdodCAxOTk2 LTIwMDIsMjAwNCwyMDA2LDIwMDktMjAxOSwyMDIxCisgICAgICBGcmVlIFNvZnR3YXJlIEZvdW5k YXRpb24sIEluYy4KKysgICBDb3B5cmlnaHQgMjAyMSBNYXhpbWUgRGV2b3MgPG1heGltZWRldm9z QHRlbGVuZXQuYmU+CisgCisgICAgVGhpcyBmaWxlIGlzIHBhcnQgb2YgR3VpbGUuCisgCitAQCAt NjIxLDEyICs2MjIsMjggQEAgU0NNX0RFRklORSAoc2NtX2xpbmssICJsaW5rIiwgMiwgMCwgMCwK KyBTQ01fREVGSU5FIChzY21fY2hkaXIsICJjaGRpciIsIDEsIDAsIDAsIAorICAgICAgICAgICAg IChTQ00gc3RyKSwKKyAJICAgICJDaGFuZ2UgdGhlIGN1cnJlbnQgd29ya2luZyBkaXJlY3Rvcnkg dG8gQHZhcntzdHJ9LlxuIgorKyAgICAgICAgICAgICJAdmFye3N0cn0gY2FuIGJlIGEgc3RyaW5n IGNvbnRhaW5pbmcgYSBmaWxlIG5hbWUsXG4iCisrICAgICAgICAgICAgIm9yIGEgcG9ydCBpZiBz dXBwb3J0ZWQgYnkgdGhlIHN5c3RlbS5cbiIKKysgICAgICAgICAgICAiQGNvZGV7KHByb3ZpZGVk PyAnY2hkaXItcG9ydCl9IHJlcG9ydHMgd2hldGhlciBwb3J0cyAiCisrICAgICAgICAgICAgImFy ZSBzdXBwb3J0ZWQuIgorIAkgICAgIlRoZSByZXR1cm4gdmFsdWUgaXMgdW5zcGVjaWZpZWQuIikK KyAjZGVmaW5lIEZVTkNfTkFNRSBzX3NjbV9jaGRpcgorIHsKKyAgIGludCBhbnM7CisgCistICBT VFJJTkdfU1lTQ0FMTCAoc3RyLCBjX3N0ciwgYW5zID0gY2hkaXIgKGNfc3RyKSk7CisrI2lmZGVm IEhBVkVfRkNIRElSCisrICBpZiAoU0NNX09QRlBPUlRQIChzdHIpKQorKyAgICB7CisrICAgICAg aW50IGZkZXM7CisrICAgICAgZmRlcyA9IFNDTV9GUE9SVF9GREVTIChzdHIpOworKyAgICAgIFND TV9TWVNDQUxMIChhbnMgPSBmY2hkaXIgKGZkZXMpKTsKKysgICAgICBzY21fcmVtZW1iZXJfdXB0 b19oZXJlXzEgKHN0cik7CisrICAgIH0KKysgIGVsc2UKKysjZW5kaWYKKysgICAgeworKyAgICAg IFNUUklOR19TWVNDQUxMIChzdHIsIGNfc3RyLCBhbnMgPSBjaGRpciAoY19zdHIpKTsKKysgICAg fQorICAgaWYgKGFucyAhPSAwKQorICAgICBTQ01fU1lTRVJST1I7CisgICByZXR1cm4gU0NNX1VO U1BFQ0lGSUVEOworQEAgLTIwNjYsNSArMjA4Myw5IEBAIHNjbV9pbml0X2ZpbGVzeXMgKCkKKyAK KyAgIHNjbV9kb3Rfc3RyaW5nID0gc2NtX2Zyb21fdXRmOF9zdHJpbmcgKCIuIik7CisgCisrI2lm ZGVmIEhBVkVfRkNIRElSCisrICBzY21fYWRkX2ZlYXR1cmUoImNoZGlyLXBvcnQiKTsKKysjZW5k aWYKKysKKyAjaW5jbHVkZSAiZmlsZXN5cy54IgorIH0KK2RpZmYgLS1naXQgYS90ZXN0LXN1aXRl L3Rlc3RzL2ZpbGVzeXMudGVzdCBiL3Rlc3Qtc3VpdGUvdGVzdHMvZmlsZXN5cy50ZXN0CitpbmRl eCA2ZmVkOTgxZTUuLjZiMDlhMmJhMCAxMDA2NDQKKy0tLSBhL3Rlc3Qtc3VpdGUvdGVzdHMvZmls ZXN5cy50ZXN0CisrKysgYi90ZXN0LXN1aXRlL3Rlc3RzL2ZpbGVzeXMudGVzdAorQEAgLTEsNiAr MSw3IEBACisgOzs7OyBmaWxlc3lzLnRlc3QgLS0tIHRlc3QgZmlsZSBzeXN0ZW0gZnVuY3Rpb25z IC0qLSBzY2hlbWUgLSotCisgOzs7OyAKKyA7Ozs7IENvcHlyaWdodCAoQykgMjAwNCwgMjAwNiwg MjAxMywgMjAxOSwgMjAyMSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4KKys7Ozs7IENv cHlyaWdodCAoQykgMjAyMSBNYXhpbWUgRGV2b3MgPG1heGltZWRldm9zQHRlbGVuZXQuYmU+Cisg Ozs7OyAKKyA7Ozs7IFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IKKyA7Ozs7IG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhl IEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKK0BAIC0yNjUsMyArMjY2LDQzIEBACisgICAgICAg ICAgICAgICAgICAocmVzdWx0ICAgKGVxdj8gJ2RpcmVjdG9yeSAoc3RhdDp0eXBlIF9zdGF0KSkp KQorICAgICAgICAgICAgIChmYWxzZS1pZi1leGNlcHRpb24gKHJtZGlyIG5hbWUpKQorICAgICAg ICAgICAgIHJlc3VsdCkpKSkpCisrCisrKHdpdGgtdGVzdC1wcmVmaXggImNoZGlyIgorKyAgKHBh c3MtaWYtZXF1YWwgImN1cnJlbnQgZGlyZWN0b3J5IiAoZ2V0Y3dkKQorKyAgICAoYmVnaW4gKGNo ZGlyICIuIikgKGdldGN3ZCkpKQorKyAgKGRlZmluZSBmaWxlIChzZWFyY2gtcGF0aCAlbG9hZC1w YXRoICJpY2UtOS9ib290LTkuc2NtIikpCisrCisrCisrICAocGFzcy1pZi1lcXVhbCAidGVzdCBk aXJlY3RvcnkiIChkaXJuYW1lIGZpbGUpCisrICAgIChsZXQgKChvbGRkaXIgKGdldGN3ZCkpCisr ICAgICAgICAgIChkaXIgI2YpKQorKyAgICAgIChjaGRpciAoZGlybmFtZSBmaWxlKSkKKysgICAg ICAoc2V0ISBkaXIgKGdldGN3ZCkpCisrICAgICAgKGNoZGlyIG9sZGRpcikKKysgICAgICBkaXIp KQorKworKyAgKHBhc3MtaWYtZXF1YWwgInRlc3QgZGlyZWN0b3J5LCB2aWEgcG9ydCIgKGRpcm5h bWUgZmlsZSkKKysgICAgKHVubGVzcyAocHJvdmlkZWQ/ICdjaGRpci1wb3J0KQorKyAgICAgICh0 aHJvdyAndW5yZXNvbHZlZCkpCisrICAgIChsZXQgKChvbGRkaXIgKGdldGN3ZCkpCisrICAgICAg ICAgIChwb3J0IChvcGVuIChkaXJuYW1lIGZpbGUpIE9fUkRPTkxZKSkKKysgICAgICAgICAgKGRp ciAjZikpCisrICAgICAgKGNoZGlyIHBvcnQpCisrICAgICAgKHNldCEgZGlyIChnZXRjd2QpKQor KyAgICAgIChjaGRpciBvbGRkaXIpCisrICAgICAgZGlyKSkKKysKKysgIChwYXNzLWlmLWV4Y2Vw dGlvbiAiY2xvc2VkIHBvcnQiICBleGNlcHRpb246d3JvbmctdHlwZS1hcmcKKysgICAgKHVubGVz cyAocHJvdmlkZWQ/ICdjaGRpci1wb3J0KQorKyAgICAgICh0aHJvdyAndW5yZXNvbHZlZCkpCisr ICAgIChsZXQgKChwb3J0IChvcGVuIChkaXJuYW1lIGZpbGUpIE9fUkRPTkxZKSkKKysgICAgICAg ICAgKG9sZGRpciAoZ2V0Y3dkKSkpCisrICAgICAgKGNsb3NlLXBvcnQgcG9ydCkKKysgICAgICAo Y2hkaXIgcG9ydCkKKysgICAgICAoY2hkaXIgb2xkZGlyKSkpIDsgc2hvdWxkIG5vdCBiZSByZWFj aGVkCisrCisrICAocGFzcy1pZi1leGNlcHRpb24gIm5vdCBhIHBvcnQgb3IgZmlsZSBuYW1lIiBl eGNlcHRpb246d3JvbmctdHlwZS1hcmcKKysgICAgKGNoZGlyICcoc3R1ZmYpKSkKKysKKysgIChw YXNzLWlmLWV4Y2VwdGlvbiAibm9uLWZpbGUgcG9ydCIgZXhjZXB0aW9uOndyb25nLXR5cGUtYXJn CisrICAgIChjaGRpciAob3Blbi1pbnB1dC1zdHJpbmcgIiIpKSkpCistLSAKKzIuMzAuMgorCisK KwpkaWZmIC0tZ2l0IGEvZ251L3BhY2thZ2VzL3BhdGNoZXMvZ3VpbGUtb3BlbmF0LWFuZC1mcmll bmRzLTAyLnBhdGNoIGIvZ251L3BhY2thZ2VzL3BhdGNoZXMvZ3VpbGUtb3BlbmF0LWFuZC1mcmll bmRzLTAyLnBhdGNoCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAuLjIxMWUw YTRmNGMKLS0tIC9kZXYvbnVsbAorKysgYi9nbnUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1vcGVu YXQtYW5kLWZyaWVuZHMtMDIucGF0Y2gKQEAgLTAsMCArMSwyMTkgQEAKK0d1aXgtVXBzdHJlYW06 IGh0dHBzOi8vbGlzdHMuZ251Lm9yZy9hcmNoaXZlL2h0bWwvZ3VpbGUtZGV2ZWwvMjAyMS0xMS9t c2cwMDAwNS5odG1sCitGcm9tOiBNYXhpbWUgRGV2b3MgPG1heGltZWRldm9zQHRlbGVuZXQuYmU+ CitTdWJqZWN0OiBbUEFUQ0ggdjIgMDIvMTRdCisgPT9VVEYtOD9xP0FsbG93PTIwZmlsZT0yMHBv cnRzPTIwaW49MjA9RTI9ODA9OThyPz0KKyA9P1VURi04P3E/ZWFkbGluaz1FMj04MD05OS4/PQor RGF0ZTogVHVlLCAxNiBOb3YgMjAyMSAxMTowNjoyNSArMDAwMAorTWVzc2FnZS1JZDogPDIwMjEx MTE2MTEwNjM3LjEyNTU3OS0zLW1heGltZWRldm9zQHRlbGVuZXQuYmU+CitJbi1SZXBseS1Ubzog PDIwMjExMTE2MTEwNjM3LjEyNTU3OS0xLW1heGltZWRldm9zQHRlbGVuZXQuYmU+CitSZWZlcmVu Y2VzOiA8MTc1YzNhNjU3MmU4MzJkODQ5Mjc5MzdiMzA5YTMwOTVjYWRmNTcwMi5jYW1lbEB0ZWxl bmV0LmJlPgorIDwyMDIxMTExNjExMDYzNy4xMjU1NzktMS1tYXhpbWVkZXZvc0B0ZWxlbmV0LmJl PgorTUlNRS1WZXJzaW9uOiAxLjAKK0NvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD1V VEYtOAorQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogOGJpdAorCisqIGNvbmZpZ3VyZS5hYzog RGV0ZWN0IHdoZXRoZXIg4oCYcmVhZGxpbmthdOKAmSBpcyBkZWZpbmVkLgorKiBsaWJndWlsZS9m aWxlc3lzLmMgKHNjbV9yZWFkbGluayk6IFN1cHBvcnQgZmlsZSBwb3J0cworICB3aGVuIOKAmHJl YWRsaW5rYXTigJkgZXhpc3RzLgorICAoc2NtX2luaXRfZmlsZXN5cyk6IFByb3ZpZGUg4oCYY2hk aXItcG9ydHPigJkgd2hlbiBpdCBleGlzdHMuCisqIGRvYy9yZWYvcG9zaXgudGV4aSAoRmlsZSBT eXN0ZW0pOiBEb2N1bWVudCBpdC4KKyogdGVzdC1zdWl0ZS90ZXN0cy9maWxlc3lzLnRlc3QgKCJy ZWFkbGluayIpOiBUZXN0IGl0LgorLS0tCisgY29uZmlndXJlLmFjICAgICAgICAgICAgICAgICAg fCAgMiArLQorIGRvYy9yZWYvcG9zaXgudGV4aSAgICAgICAgICAgIHwgIDkgKysrKy0tCisgbGli Z3VpbGUvZmlsZXN5cy5jICAgICAgICAgICAgfCA1MiArKysrKysrKysrKysrKysrKysrKysrKy0t LS0tLQorIHRlc3Qtc3VpdGUvdGVzdHMvZmlsZXN5cy50ZXN0IHwgNjEgKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysKKyA0IGZpbGVzIGNoYW5nZWQsIDExMiBpbnNlcnRpb25zKCsp LCAxMiBkZWxldGlvbnMoLSkKKworZGlmZiAtLWdpdCBhL2NvbmZpZ3VyZS5hYyBiL2NvbmZpZ3Vy ZS5hYworaW5kZXggYjdlNDY2M2Y3Li40ODg4Zjg4MGQgMTAwNjQ0CistLS0gYS9jb25maWd1cmUu YWMKKysrKyBiL2NvbmZpZ3VyZS5hYworQEAgLTQ4NCw3ICs0ODQsNyBAQCBBQ19DSEVDS19IRUFE RVJTKFthc3NlcnQuaCBjcnRfZXh0ZXJucy5oXSkKKyAjICAgc2VuZGZpbGUgLSBub24tUE9TSVgs IGZvdW5kIGluIGdsaWJjCisgIworIEFDX0NIRUNLX0ZVTkNTKFtESU5GSU5JVFkgRFFOQU4gY2V4 cCBjaHNpemUgY2xvZyBjbG9nMTAgY3Rlcm1pZCAgICAgICAgIFwKKy0gIGZlc2V0cm91bmQgZnRp bWUgZnRydW5jYXRlIGZjaG93biBmY2htb2QgZmNoZGlyCQkJXAorKyAgZmVzZXRyb3VuZCBmdGlt ZSBmdHJ1bmNhdGUgZmNob3duIGZjaG1vZCBmY2hkaXIgcmVhZGxpbmthdAkJXAorICAgZ2V0Y3dk IGdldGV1aWQgZ2V0c2lkCQkJCQkJCVwKKyAgIGdldHRpbWVvZmRheSBnZXR1aWQgZ2V0Z2lkIGdt dGltZV9yIGlvY3RsIGxzdGF0IG1rZGlyIG1rZHRlbXAgbWtub2QgICBcCisgICBuaWNlIHJlYWRs aW5rIHJlbmFtZSBybWRpciBzZXRlZ2lkIHNldGV1aWQgICAgICAgICAgICAgICAgICAgICAgICAg ICAgXAorZGlmZiAtLWdpdCBhL2RvYy9yZWYvcG9zaXgudGV4aSBiL2RvYy9yZWYvcG9zaXgudGV4 aQoraW5kZXggNzU1NWY5MzE5Li5jZDIzMjQwYzQgMTAwNjQ0CistLS0gYS9kb2MvcmVmL3Bvc2l4 LnRleGkKKysrKyBiL2RvYy9yZWYvcG9zaXgudGV4aQorQEAgLTc1Nyw4ICs3NTcsMTMgQEAgZmls ZSBpdCBwb2ludHMgdG8uICBAdmFye3BhdGh9IG11c3QgYmUgYSBzdHJpbmcuCisgCisgQGRlZmZu IHtTY2hlbWUgUHJvY2VkdXJlfSByZWFkbGluayBwYXRoCisgQGRlZmZueCB7QyBGdW5jdGlvbn0g c2NtX3JlYWRsaW5rIChwYXRoKQorLVJldHVybiB0aGUgdmFsdWUgb2YgdGhlIHN5bWJvbGljIGxp bmsgbmFtZWQgYnkgQHZhcntwYXRofSAoYQorLXN0cmluZyksIGkuZS4sIHRoZSBmaWxlIHRoYXQg dGhlIGxpbmsgcG9pbnRzIHRvLgorK1JldHVybiB0aGUgdmFsdWUgb2YgdGhlIHN5bWJvbGljIGxp bmsgbmFtZWQgYnkgQHZhcntwYXRofSAoYSBzdHJpbmcsIG9yCisrYSBwb3J0IGlmIHN1cHBvcnRl ZCBieSB0aGUgc3lzdGVtKSwgaS5lLiwgdGhlIGZpbGUgdGhhdCB0aGUgbGluayBwb2ludHMKKyt0 by4KKysKKytUbyByZWFkIGEgc3ltYm9saWMgbGluayByZXByZXNlbnRlZCBieSBhIHBvcnQsIHRo ZSBzeW1ib2xpYyBsaW5rIG11c3QKKytoYXZlIGJlZW4gb3BlbmVkIHdpdGggdGhlIEBjb2Rle09f Tk9GT0xMT1d9IGFuZCBAY29kZXtPX1BBVEh9IGZsYWdzLgorK0Bjb2Rleyhwcm92aWRlZD8gJ3Jl YWRsaW5rLXBvcnQpfSByZXBvcnRzIHdoZXRoZXIgcG9ydHMgYXJlIHN1cHBvcnRlZC4KKyBAZW5k IGRlZmZuCisgCisgQGZpbmRleCBmY2hvd24KK2RpZmYgLS1naXQgYS9saWJndWlsZS9maWxlc3lz LmMgYi9saWJndWlsZS9maWxlc3lzLmMKK2luZGV4IDJhOWMzNmExMi4uYzViZWRlYzA3IDEwMDY0 NAorLS0tIGEvbGliZ3VpbGUvZmlsZXN5cy5jCisrKysgYi9saWJndWlsZS9maWxlc3lzLmMKK0BA IC0xMDQ1LDEwICsxMDQ1LDMwIEBAIFNDTV9ERUZJTkUgKHNjbV9zeW1saW5rLCAic3ltbGluayIs IDIsIDAsIDAsCisgI3VuZGVmIEZVTkNfTkFNRQorICNlbmRpZiAvKiBIQVZFX1NZTUxJTksgKi8K KyAKKy1TQ01fREVGSU5FIChzY21fcmVhZGxpbmssICJyZWFkbGluayIsIDEsIDAsIDAsIAorKy8q IFN0YXRpYyBoZWxwZXIgZnVuY3Rpb24gZm9yIGNob29zaW5nIGJldHdlZW4gcmVhZGxpbmsKKysg ICBhbmQgcmVhZGxpbmthdC4gKi8KKytzdGF0aWMgaW50CisrZG9fcmVhZGxpbmsgKGludCBmZCwg Y29uc3QgY2hhciAqY19wYXRoLCBjaGFyICpidWYsIHNpemVfdCBzaXplKQorK3sKKysjaWZkZWYg SEFWRV9SRUFETElOS0FUCisrICBpZiAoZmQgIT0gLTEpCisrICAgIHJldHVybiByZWFkbGlua2F0 IChmZCwgY19wYXRoLCBidWYsIHNpemUpOworKyNlbHNlCisrICAodm9pZCkgZmQ7CisrI2VuZGlm CisrICByZXR1cm4gcmVhZGxpbmsgKGNfcGF0aCwgYnVmLCBzaXplKTsKKyt9CisrCisrU0NNX0RF RklORSAoc2NtX3JlYWRsaW5rLCAicmVhZGxpbmsiLCAxLCAwLCAwLAorICAgICAgICAgICAgIChT Q00gcGF0aCksCistCSAgICAiUmV0dXJuIHRoZSB2YWx1ZSBvZiB0aGUgc3ltYm9saWMgbGluayBu YW1lZCBieSBAdmFye3BhdGh9IChhXG4iCistCSAgICAic3RyaW5nKSwgaS5lLiwgdGhlIGZpbGUg dGhhdCB0aGUgbGluayBwb2ludHMgdG8uIikKKysgICAgICAgICAgICAiUmV0dXJuIHRoZSB2YWx1 ZSBvZiB0aGUgc3ltYm9saWMgbGluayBuYW1lZCBieSBAdmFye3BhdGh9IChhXG4iCisrICAgICAg ICAgICAgInN0cmluZywgb3IgYSBwb3J0IGlmIHN1cHBvcnRlZCBieSB0aGUgc3lzdGVtKSxcbiIK KysgICAgICAgICAgICAiaS5lLiwgdGhlIGZpbGUgdGhhdCB0aGUgbGluayBwb2ludHMgdG8uXG4i CisrICAgICAgICAgICAgIlRvIHJlYWQgYSBzeW1ib2xpYyBsaW5rIHJlcHJlc2VudGVkIGJ5IGEg cG9ydCwgdGhlIHN5bWJvbGljXG4iCisrICAgICAgICAgICAgImxpbmsgbXVzdCBoYXZlIGJlZW4g b3BlbmVkIHdpdGggdGhlIEBjb2Rle09fTk9GT0xMT1d9IGFuZFxuIgorKyAgICAgICAgICAgICJA Y29kZXtPX1BBVEh9IGZsYWdzLiIKKysgICAgICAgICAgICAiQGNvZGV7KHByb3ZpZGVkPyAncmVh ZGxpbmstcG9ydCl9IHJlcG9ydHMgd2hldGhlciBwb3J0cyBhcmVcbiIKKysgICAgICAgICAgICAi c3VwcG9ydGVkLiIpCisgI2RlZmluZSBGVU5DX05BTUUgc19zY21fcmVhZGxpbmsKKyB7CisgICBp bnQgcnY7CitAQCAtMTA1NiwyMCArMTA3NiwzMSBAQCBTQ01fREVGSU5FIChzY21fcmVhZGxpbmss ICJyZWFkbGluayIsIDEsIDAsIDAsCisgICBjaGFyICpidWY7CisgICBTQ00gcmVzdWx0OworICAg Y2hhciAqY19wYXRoOworLSAgCistICBzY21fZHlud2luZF9iZWdpbiAoMCk7CistCistICBjX3Bh dGggPSBzY21fdG9fbG9jYWxlX3N0cmluZyAocGF0aCk7CistICBzY21fZHlud2luZF9mcmVlIChj X3BhdGgpOworKyAgaW50IGZkZXM7CisgCisrICBzY21fZHlud2luZF9iZWdpbiAoMCk7CisrI2lm ZGVmIEhBVkVfUkVBRExJTktBVAorKyAgaWYgKFNDTV9PUEZQT1JUUCAocGF0aCkpCisrICAgIHsK KysgICAgICBjX3BhdGggPSAiIjsKKysgICAgICBmZGVzID0gU0NNX0ZQT1JUX0ZERVMgKHBhdGgp OworKyAgICB9CisrICBlbHNlCisrI2VuZGlmCisrICAgIHsKKysgICAgICBmZGVzID0gLTE7Cisr ICAgICAgY19wYXRoID0gc2NtX3RvX2xvY2FsZV9zdHJpbmcgKHBhdGgpOworKyAgICAgIHNjbV9k eW53aW5kX2ZyZWUgKGNfcGF0aCk7CisrICAgIH0KKyAgIGJ1ZiA9IHNjbV9tYWxsb2MgKHNpemUp OworIAorLSAgd2hpbGUgKChydiA9IHJlYWRsaW5rIChjX3BhdGgsIGJ1Ziwgc2l6ZSkpID09IHNp emUpCisrICB3aGlsZSAoKHJ2ID0gZG9fcmVhZGxpbmsgKGZkZXMsIGNfcGF0aCwgYnVmLCBzaXpl KSkgPT0gc2l6ZSkKKyAgICAgeworICAgICAgIGZyZWUgKGJ1Zik7CisgICAgICAgc2l6ZSAqPSAy OworICAgICAgIGJ1ZiA9IHNjbV9tYWxsb2MgKHNpemUpOworICAgICB9CisrICBzY21fcmVtZW1i ZXJfdXB0b19oZXJlXzEgKHBhdGgpOworICAgaWYgKHJ2ID09IC0xKQorICAgICB7CisgICAgICAg aW50IHNhdmVfZXJybm8gPSBlcnJubzsKK0BAIC0yMDg2LDYgKzIxMTcsOSBAQCBzY21faW5pdF9m aWxlc3lzICgpCisgI2lmZGVmIEhBVkVfRkNIRElSCisgICBzY21fYWRkX2ZlYXR1cmUoImNoZGly LXBvcnQiKTsKKyAjZW5kaWYKKysjaWZkZWYgSEFWRV9SRUFETElOS0FUCisrICBzY21fYWRkX2Zl YXR1cmUoInJlYWRsaW5rLXBvcnQiKTsKKysjZW5kaWYKKyAKKyAjaW5jbHVkZSAiZmlsZXN5cy54 IgorIH0KK2RpZmYgLS1naXQgYS90ZXN0LXN1aXRlL3Rlc3RzL2ZpbGVzeXMudGVzdCBiL3Rlc3Qt c3VpdGUvdGVzdHMvZmlsZXN5cy50ZXN0CitpbmRleCA2YjA5YTJiYTAuLjdmZWIzNDkyZiAxMDA2 NDQKKy0tLSBhL3Rlc3Qtc3VpdGUvdGVzdHMvZmlsZXN5cy50ZXN0CisrKysgYi90ZXN0LXN1aXRl L3Rlc3RzL2ZpbGVzeXMudGVzdAorQEAgLTMwNiwzICszMDYsNjQgQEAKKyAKKyAgIChwYXNzLWlm LWV4Y2VwdGlvbiAibm9uLWZpbGUgcG9ydCIgZXhjZXB0aW9uOndyb25nLXR5cGUtYXJnCisgICAg IChjaGRpciAob3Blbi1pbnB1dC1zdHJpbmcgIiIpKSkpCisrCisrKHdpdGgtdGVzdC1wcmVmaXgg InJlYWRsaW5rIgorKyAgKGZhbHNlLWlmLWV4Y2VwdGlvbiAoZGVsZXRlLWZpbGUgKHRlc3Qtc3lt bGluaykpKQorKyAgKGZhbHNlLWlmLWV4Y2VwdGlvbiAoZGVsZXRlLWZpbGUgKHRlc3QtZmlsZSkp KQorKyAgKGNhbGwtd2l0aC1vdXRwdXQtZmlsZSAodGVzdC1maWxlKQorKyAgICAobGFtYmRhIChw b3J0KQorKyAgICAgIChkaXNwbGF5ICJoZWxsbyIgcG9ydCkpKQorKyAgKGlmIChub3QgKGZhbHNl LWlmLWV4Y2VwdGlvbgorKwkgICAgKGJlZ2luIChzeW1saW5rICh0ZXN0LWZpbGUpICh0ZXN0LXN5 bWxpbmspKSAjdCkpKQorKyAgICAgIChkaXNwbGF5ICJjYW5ub3QgY3JlYXRlIHN5bWxpbmssIHNv bWUgcmVhZGxpbmsgdGVzdHMgc2tpcHBlZFxuIikKKysgICAgICAobGV0ICgpCisrICAgICAgICAo cGFzcy1pZi1lcXVhbCAiZmlsZSBuYW1lIG9mIHN5bWxpbmsiICh0ZXN0LWZpbGUpCisrICAgICAg ICAgIChyZWFkbGluayAodGVzdC1zeW1saW5rKSkpCisrCisrICAgICAgICAocGFzcy1pZi1lcXVh bCAicG9ydCByZXByZXNlbnRpbmcgYSBzeW1saW5rIiAodGVzdC1maWxlKQorKyAgICAgICAgICAo bGV0ICgpCisrICAgICAgICAgICAgKHVubGVzcyAoYW5kIChwcm92aWRlZD8gJ3JlYWRsaW5rLXBv cnQpCisrICAgICAgICAgICAgICAgICAgICAgICAgIChkZWZpbmVkPyAnT19OT0ZPTExPVykKKysg ICAgICAgICAgICAgICAgICAgICAgICAgKGRlZmluZWQ/ICdPX1BBVEgpCisrICAgICAgICAgICAg ICAgICAgICAgICAgIChub3QgKD0gMCBPX05PRk9MTE9XKSkKKysgICAgICAgICAgICAgICAgICAg ICAgICAgKG5vdCAoPSAwIE9fUEFUSCkpKQorKyAgICAgICAgICAgICAgKHRocm93ICd1bnN1cHBv cnRlZCkpCisrICAgICAgICAgICAgKGRlZmluZSBwb3J0IChvcGVuICh0ZXN0LXN5bWxpbmspIChs b2dpb3IgT19OT0ZPTExPVyBPX1BBVEgpKSkKKysgICAgICAgICAgICAoZGVmaW5lIHBvaW50cy10 byAoZmFsc2UtaWYtZXhjZXB0aW9uIChyZWFkbGluayBwb3J0KSkpCisrICAgICAgICAgICAgKGNs b3NlLXBvcnQgcG9ydCkKKysgICAgICAgICAgICBwb2ludHMtdG8pKQorKworKyAgICAgICAgKHBh c3MtaWYtZXhjZXB0aW9uICJub3QgYSBwb3J0IG9yIGZpbGUgbmFtZSIgZXhjZXB0aW9uOndyb25n LXR5cGUtYXJnCisrICAgICAgICAgIChyZWFkbGluayAnKHN0dWZmKSkpKSkKKysKKysgIChwYXNz LWlmLWVxdWFsICJwb3J0IHJlcHJlc2VudGluZyBhIHJlZ3VsYXIgZmlsZSIgRUlOVkFMCisrICAg IChjYWxsLXdpdGgtaW5wdXQtZmlsZSAodGVzdC1maWxlKQorKyAgICAgIChsYW1iZGEgKHBvcnQp CisrICAgICAgICAodW5sZXNzIChwcm92aWRlZD8gJ3JlYWRsaW5rLXBvcnQpCisrICAgICAgICAg ICh0aHJvdyAndW5zdXBwb3J0ZWQpKQorKyAgICAgICAgKGNhdGNoICdzeXN0ZW0tZXJyb3IKKysg ICAgICAgICAgKGxhbWJkYSAoKQorKyAgICAgICAgICAgIChyZWFkbGluayBwb3J0KQorKyAgICAg ICAgICAgIChjbG9zZS1wb3J0IHBvcnQpIDsgc2hvdWxkIGJlIHVucmVhY2hhYmxlCisrICAgICAg ICAgICAgI2YpCisrICAgICAgICAgIChsYW1iZGEgYXJncworKyAgICAgICAgICAgIChjbG9zZS1w b3J0IHBvcnQpCisrICAgICAgICAgICAgOzsgQXQgbGVhc3QgTGludXggNS4xMC40NiByZXR1cm5z IEVOT0VOVCBpbnN0ZWFkIG9mIEVJTlZBTC4KKysgICAgICAgICAgICA7OyBQb3NzaWJseSBzdXJw cmlzaW5nLCBidXQgaXQgaXMgZG9jdW1lbnRlZCBpbiBzb21lIG1hbgorKyAgICAgICAgICAgIDs7 IHBhZ2VzIGFuZCBpdCBkb2Vzbid0IGFwcGVhciB0byBiZSBhbiBhY2NpZGVudDoKKysgICAgICAg ICAgICA7OyA8aHR0cHM6Ly9lbGl4aXIuYm9vdGxpbi5jb20vbGludXgvdjUuMTAuNDYvc291cmNl L2ZzL3N0YXQuYyNMNDE5Pi4KKysgICAgICAgICAgICAoZGVmaW5lIGVycm9yIChzeXN0ZW0tZXJy b3ItZXJybm8gYXJncykpCisrICAgICAgICAgICAgKGlmICg9IGVycm9yIEVOT0VOVCkKKysgICAg ICAgICAgICAgICAgRUlOVkFMCisrICAgICAgICAgICAgICAgIGVycm9yKSkpKSkpCisrCisrICAo cGFzcy1pZi1leGNlcHRpb24gIm5vbi1maWxlIHBvcnQiIGV4Y2VwdGlvbjp3cm9uZy10eXBlLWFy ZworKyAgICAocmVhZGxpbmsgKG9wZW4taW5wdXQtc3RyaW5nICIiKSkpCisrCisrICAocGFzcy1p Zi1leGNlcHRpb24gImNsb3NlZCBwb3J0IiBleGNlcHRpb246d3JvbmctdHlwZS1hcmcKKysgICAg KGxldCAoKHBvcnQgKG9wZW4tZmlsZSAodGVzdC1maWxlKSAiciIpKSkKKysgICAgICAoY2xvc2Ut cG9ydCBwb3J0KQorKyAgICAgIChyZWFkbGluayBwb3J0KSkpCisrCisrICAoZmFsc2UtaWYtZXhj ZXB0aW9uIChkZWxldGUtZmlsZSAodGVzdC1zeW1saW5rKSkpCisrICAoZmFsc2UtaWYtZXhjZXB0 aW9uIChkZWxldGUtZmlsZSAodGVzdC1maWxlKSkpKQorLS0gCisyLjMwLjIKKworCmRpZmYgLS1n aXQgYS9nbnUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDMucGF0 Y2ggYi9nbnUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDMucGF0 Y2gKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMC4uOGNkYzliMTc3MQotLS0g L2Rldi9udWxsCisrKyBiL2dudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQtZnJp ZW5kcy0wMy5wYXRjaApAQCAtMCwwICsxLDI2OSBAQAorR3VpeC1VcHN0cmVhbTogaHR0cHM6Ly9s aXN0cy5nbnUub3JnL2FyY2hpdmUvaHRtbC9ndWlsZS1kZXZlbC8yMDIxLTExL21zZzAwMDA1Lmh0 bWwKK0Zyb206IE1heGltZSBEZXZvcyA8bWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KK1N1YmplY3Q6 IFtQQVRDSCB2MiAwMy8xNF0KKyA9P1VURi04P3E/QWxsb3c9MjBmaWxlPTIwcG9ydHM9MjBpbj0y MD1FMj04MD05OHU/PQorID0/VVRGLTg/cT90aW1lPUUyPTgwPTk5Lj89CitEYXRlOiBUdWUsIDE2 IE5vdiAyMDIxIDExOjA2OjI2ICswMDAwCitNZXNzYWdlLUlkOiA8MjAyMTExMTYxMTA2MzcuMTI1 NTc5LTQtbWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KK0luLVJlcGx5LVRvOiA8MjAyMTExMTYxMTA2 MzcuMTI1NTc5LTEtbWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KK1JlZmVyZW5jZXM6IDwxNzVjM2E2 NTcyZTgzMmQ4NDkyNzkzN2IzMDlhMzA5NWNhZGY1NzAyLmNhbWVsQHRlbGVuZXQuYmU+CisgPDIw MjExMTE2MTEwNjM3LjEyNTU3OS0xLW1heGltZWRldm9zQHRlbGVuZXQuYmU+CitNSU1FLVZlcnNp b246IDEuMAorQ29udGVudC1UeXBlOiB0ZXh0L3BsYWluOyBjaGFyc2V0PVVURi04CitDb250ZW50 LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0CisKK1BvcnRzIHJlcHJlc2VudGluZyBzeW1ib2xpYyBs aW5rcyBhcmUgY3VycmVudGx5IHVuc3VwcG9ydGVkLgorCisqIGNvbmZpZ3VyZS5hYzogRGV0ZWN0 ICdmdXRpbWVucycuCisqIGRvYy9yZWYvcG9zaXgudGV4aSAodXRpbWUpOiBVcGRhdGUgZG9jdW1l bnRhdGlvbi4KKyogbGliZ3VpbGUvcG9zaXguYyAoc2NtX3V0aW1lKTogU3VwcG9ydCBwb3J0cy4K KyogbGliZ3VpbGUvcG9zaXguaCAoc2NtX3V0aW1lKTogUmVuYW1lIGFyZ3VtZW50LgorKiB0ZXN0 LXN1aXRlL3Rlc3RzL3Bvc2l4LnRlc3QgKCJ1dGltZSIpOiBBZGQgbW9yZSB0ZXN0cy4KKy0tLQor IGNvbmZpZ3VyZS5hYyAgICAgICAgICAgICAgICB8ICA0ICstLQorIGRvYy9yZWYvcG9zaXgudGV4 aSAgICAgICAgICB8IDE1ICsrKysrLS0tCisgbGliZ3VpbGUvcG9zaXguYyAgICAgICAgICAgIHwg MjggKysrKysrKysrKystLS0tCisgbGliZ3VpbGUvcG9zaXguaCAgICAgICAgICAgIHwgIDIgKy0K KyB0ZXN0LXN1aXRlL3Rlc3RzL3Bvc2l4LnRlc3QgfCA3MSArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKystCisgNSBmaWxlcyBjaGFuZ2VkLCAxMDYgaW5zZXJ0aW9ucygrKSwgMTQg ZGVsZXRpb25zKC0pCisKK2RpZmYgLS1naXQgYS9jb25maWd1cmUuYWMgYi9jb25maWd1cmUuYWMK K2luZGV4IDQ4ODhmODgwZC4uZGRmMzMwZDk2IDEwMDY0NAorLS0tIGEvY29uZmlndXJlLmFjCisr KysgYi9jb25maWd1cmUuYWMKK0BAIC00NzcsNyArNDc3LDcgQEAgQUNfQ0hFQ0tfSEVBREVSUyhb YXNzZXJ0LmggY3J0X2V4dGVybnMuaF0pCisgIyAgIHRydW5jYXRlIC0gbm90IGluIG1pbmd3Cisg IyAgIGlzYmxhbmsgLSBhdmFpbGFibGUgYXMgYSBHTlUgZXh0ZW5zaW9uIG9yIGluIEM5OQorICMg ICBfTlNHZXRFbnZpcm9uIC0gRGFyd2luIHNwZWNpZmljCistIyAgIHN0cmNvbGxfbCwgbmV3bG9j YWxlLCB1c2Vsb2NhbGUsIHV0aW1lbnNhdCAtIFBPU0lYLjEtMjAwOAorKyMgICBzdHJjb2xsX2ws IG5ld2xvY2FsZSwgdXNlbG9jYWxlLCB1dGltZW5zYXQsIGZ1dGltZW5zIC0gUE9TSVguMS0yMDA4 CisgIyAgIHN0cnRvbF9sIC0gbm9uLVBPU0lYLCBmb3VuZCBpbiBnbGliYworICMgICBmb3JrIC0g dW5hdmFpbGFibGUgb24gV2luZG93cworICMgICBzY2hlZF9nZXRhZmZpbml0eSwgc2NoZWRfc2V0 YWZmaW5pdHkgLSBHTlUgZXh0ZW5zaW9ucyAoZ2xpYmMpCitAQCAtNDk0LDcgKzQ5NCw3IEBAIEFD X0NIRUNLX0ZVTkNTKFtESU5GSU5JVFkgRFFOQU4gY2V4cCBjaHNpemUgY2xvZyBjbG9nMTAgY3Rl cm1pZCAgICAgICAgIFwKKyAgIGdldGdyZW50IGtpbGwgZ2V0cHBpZCBnZXRwZ3JwIGZvcmsgc2V0 aXRpbWVyIGdldGl0aW1lciBzdHJjaHIgc3RyY21wICBcCisgICBpbmRleCBiY29weSBtZW1jcHkg cmluZGV4IHRydW5jYXRlIGlzYmxhbmsgX05TR2V0RW52aXJvbiAgICAgICAgICAgICAgXAorICAg c3RyY29sbCBzdHJjb2xsX2wgc3RydG9kX2wgc3RydG9sX2wgbmV3bG9jYWxlIHVzZWxvY2FsZSB1 dGltZW5zYXQgICAgIFwKKy0gIHNjaGVkX2dldGFmZmluaXR5IHNjaGVkX3NldGFmZmluaXR5IHNl bmRmaWxlXSkKKysgIGZ1dGltZW5zIHNjaGVkX2dldGFmZmluaXR5IHNjaGVkX3NldGFmZmluaXR5 IHNlbmRmaWxlXSkKKyAKKyAjIFRoZSBuZXdsaWIgQyBsaWJyYXJ5IHVzZXMgX05MXyBwcmVmaXhl ZCBsb2NhbGUgbGFuZ2luZm8gY29uc3RhbnRzLgorIEFDX0NIRUNLX0RFQ0xTKFtfTkxfTlVNRVJJ Q19HUk9VUElOR10sIFtdLCBbXSwgW1sjaW5jbHVkZSA8bGFuZ2luZm8uaD5dXSkKK2RpZmYgLS1n aXQgYS9kb2MvcmVmL3Bvc2l4LnRleGkgYi9kb2MvcmVmL3Bvc2l4LnRleGkKK2luZGV4IGNkMjMy NDBjNC4uYjZkZWZmZDQzIDEwMDY0NAorLS0tIGEvZG9jL3JlZi9wb3NpeC50ZXhpCisrKysgYi9k b2MvcmVmL3Bvc2l4LnRleGkKK0BAIC03OTYsMTQgKzc5NiwxNiBAQCB0aGUgbmV3IHBlcm1pc3Np b25zIGFzIGEgZGVjaW1hbCBudW1iZXIsIGUuZy4sIEBjb2RleyhjaG1vZCAiZm9vIiAjbzc1NSl9 LgorIFRoZSByZXR1cm4gdmFsdWUgaXMgdW5zcGVjaWZpZWQuCisgQGVuZCBkZWZmbgorIAorLUBk ZWZmbiB7U2NoZW1lIFByb2NlZHVyZX0gdXRpbWUgcGF0aG5hbWUgW2FjdGltZSBbbW9kdGltZSBb YWN0aW1lbnMgW21vZHRpbWVucyBbZmxhZ3NdXV1dXQorLUBkZWZmbngge0MgRnVuY3Rpb259IHNj bV91dGltZSAocGF0aG5hbWUsIGFjdGltZSwgbW9kdGltZSwgYWN0aW1lbnMsIG1vZHRpbWVucywg ZmxhZ3MpCisrQGRlZmZuIHtTY2hlbWUgUHJvY2VkdXJlfSB1dGltZSBvYmplY3QgW2FjdGltZSBb bW9kdGltZSBbYWN0aW1lbnMgW21vZHRpbWVucyBbZmxhZ3NdXV1dXQorK0BkZWZmbngge0MgRnVu Y3Rpb259IHNjbV91dGltZSAob2JqZWN0LCBhY3RpbWUsIG1vZHRpbWUsIGFjdGltZW5zLCBtb2R0 aW1lbnMsIGZsYWdzKQorIEBjb2Rle3V0aW1lfSBzZXRzIHRoZSBhY2Nlc3MgYW5kIG1vZGlmaWNh dGlvbiB0aW1lcyBmb3IgdGhlCistZmlsZSBuYW1lZCBieSBAdmFye3BhdGhuYW1lfS4gIElmIEB2 YXJ7YWN0aW1lfSBvciBAdmFye21vZHRpbWV9IGlzCisrZmlsZSBuYW1lZCBieSBAdmFye29iamVj dH0uICBJZiBAdmFye2FjdGltZX0gb3IgQHZhcnttb2R0aW1lfSBpcworIG5vdCBzdXBwbGllZCwg dGhlbiB0aGUgY3VycmVudCB0aW1lIGlzIHVzZWQuICBAdmFye2FjdGltZX0gYW5kCisgQHZhcntt b2R0aW1lfSBtdXN0IGJlIGludGVnZXIgdGltZSB2YWx1ZXMgYXMgcmV0dXJuZWQgYnkgdGhlCisg QGNvZGV7Y3VycmVudC10aW1lfSBwcm9jZWR1cmUuCisgCisrQHZhcntvYmplY3R9IG11c3QgYmUg YSBmaWxlIG5hbWUgb3IgYSBwb3J0IChpZiBzdXBwb3J0ZWQgYnkgdGhlIHN5c3RlbSkuCisrCisg VGhlIG9wdGlvbmFsIEB2YXJ7YWN0aW1lbnN9IGFuZCBAdmFye21vZHRpbWVuc30gYXJlIG5hbm9z ZWNvbmRzCisgdG8gYWRkIEB2YXJ7YWN0aW1lfSBhbmQgQHZhcnttb2R0aW1lfS4gTmFub3NlY29u ZCBwcmVjaXNpb24gaXMKKyBvbmx5IHN1cHBvcnRlZCBvbiBzb21lIGNvbWJpbmF0aW9ucyBvZiBm aWxlIHN5c3RlbXMgYW5kIG9wZXJhdGluZworQEAgLTgxNyw5ICs4MTksMTQgQEAgbW9kaWZpY2F0 aW9uIHRpbWUgdG8gdGhlIGN1cnJlbnQgdGltZS4KKyBAdmluZGV4IEFUX1NZTUxJTktfTk9GT0xM T1cKKyBMYXN0LCBAdmFye2ZsYWdzfSBtYXkgYmUgZWl0aGVyIEBjb2RlezB9IG9yIHRoZQorIEBj b2Rle0FUX1NZTUxJTktfTk9GT0xMT1d9IGNvbnN0YW50LCB0byBzZXQgdGhlIHRpbWUgb2YKKy1A dmFye3BhdGhuYW1lfSBldmVuIGlmIGl0IGlzIGEgc3ltYm9saWMgbGluay4KKytAdmFye29iamVj dH0gZXZlbiBpZiBpdCBpcyBhIHN5bWJvbGljIGxpbmsuCisgQGVuZCBkZWZmbgorIAorK09uIEdO VS9MaW51eCBzeXN0ZW1zLCBhdCBsZWFzdCB3aGVuIHVzaW5nIHRoZSBMaW51eCBrZXJuZWwgNS4x MC40NiwKKytpZiBAdmFye29iamVjdH0gaXMgYSBwb3J0LCBpdCBtYXkgbm90IGJlIGEgc3ltYm9s aWMgbGluaywKKytldmVuIGlmIEBjb2Rle0FUX1NZTUxJTktfTk9GT0xMT1d9IGlzIHNldC4gIFRo aXMgaXMgZWl0aGVyIGEgYnVnCisraW4gTGludXggb3IgR3VpbGUncyB3cmFwcGVycy4gIFRoZSBl eGFjdCBjYXVzZSBpcyB1bmNsZWFyLgorKworIEBmaW5kZXggdW5saW5rCisgQGRlZmZuIHtTY2hl bWUgUHJvY2VkdXJlfSBkZWxldGUtZmlsZSBzdHIKKyBAZGVmZm54IHtDIEZ1bmN0aW9ufSBzY21f ZGVsZXRlX2ZpbGUgKHN0cikKK2RpZmYgLS1naXQgYS9saWJndWlsZS9wb3NpeC5jIGIvbGliZ3Vp bGUvcG9zaXguYworaW5kZXggM2FiMTJiOTllLi5iZDdmNDBjYTggMTAwNjQ0CistLS0gYS9saWJn dWlsZS9wb3NpeC5jCisrKysgYi9saWJndWlsZS9wb3NpeC5jCitAQCAtMSw1ICsxLDYgQEAKKyAv KiBDb3B5cmlnaHQgMTk5NS0yMDE0LDIwMTYtMjAxOSwyMDIxCisgICAgICBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb24sIEluYy4KKysgICBDb3B5cmlnaHQgMjAyMSBNYXhpbWUgRGV2b3MgPG1heGlt ZWRldm9zQHRlbGVuZXQuYmU+CisgCisgICAgVGhpcyBmaWxlIGlzIHBhcnQgb2YgR3VpbGUuCisg CitAQCAtMTY0OCwxMyArMTY0OSwxNCBAQCBTQ01fREVGSU5FIChzY21fdG1wZmlsZSwgInRtcGZp bGUiLCAwLCAwLCAwLAorICN1bmRlZiBGVU5DX05BTUUKKyAKKyBTQ01fREVGSU5FIChzY21fdXRp bWUsICJ1dGltZSIsIDEsIDUsIDAsCistICAgICAgICAgICAgKFNDTSBwYXRobmFtZSwgU0NNIGFj dGltZSwgU0NNIG1vZHRpbWUsIFNDTSBhY3RpbWVucywgU0NNIG1vZHRpbWVucywKKysgICAgICAg ICAgICAoU0NNIG9iamVjdCwgU0NNIGFjdGltZSwgU0NNIG1vZHRpbWUsIFNDTSBhY3RpbWVucywg U0NNIG1vZHRpbWVucywKKyAgICAgICAgICAgICAgU0NNIGZsYWdzKSwKKyAJICAgICJAY29kZXt1 dGltZX0gc2V0cyB0aGUgYWNjZXNzIGFuZCBtb2RpZmljYXRpb24gdGltZXMgZm9yIHRoZVxuIgor LQkgICAgImZpbGUgbmFtZWQgYnkgQHZhcntwYXRobmFtZX0uICBJZiBAdmFye2FjdGltZX0gb3Ig QHZhcnttb2R0aW1lfSBpc1xuIgorKwkgICAgImZpbGUgbmFtZWQgYnkgQHZhcntvYmplY3R9LiAg SWYgQHZhcnthY3RpbWV9IG9yIEB2YXJ7bW9kdGltZX0gaXNcbiIKKyAJICAgICJub3Qgc3VwcGxp ZWQsIHRoZW4gdGhlIGN1cnJlbnQgdGltZSBpcyB1c2VkLiAgQHZhcnthY3RpbWV9IGFuZFxuIgor IAkgICAgIkB2YXJ7bW9kdGltZX0gbXVzdCBiZSBpbnRlZ2VyIHRpbWUgdmFsdWVzIGFzIHJldHVy bmVkIGJ5IHRoZVxuIgorIAkgICAgIkBjb2Rle2N1cnJlbnQtdGltZX0gcHJvY2VkdXJlLlxuXG4i CisrICAgICAgICAgICAgIkB2YXJ7b2JqZWN0fSBtdXN0IGJlIGEgZmlsZSBuYW1lIG9yIGEgcG9y dCAoaWYgc3VwcG9ydGVkIGJ5IHRoZSBzeXN0ZW0pLlxuXG4iCisgICAgICAgICAgICAgIlRoZSBv cHRpb25hbCBAdmFye2FjdGltZW5zfSBhbmQgQHZhcnttb2R0aW1lbnN9IGFyZSBuYW5vc2Vjb25k c1xuIgorICAgICAgICAgICAgICJ0byBhZGQgQHZhcnthY3RpbWV9IGFuZCBAdmFye21vZHRpbWV9 LiBOYW5vc2Vjb25kIHByZWNpc2lvbiBpc1xuIgorICAgICAgICAgICAgICJvbmx5IHN1cHBvcnRl ZCBvbiBzb21lIGNvbWJpbmF0aW9ucyBvZiBmaWxlIHN5c3RlbXMgYW5kIG9wZXJhdGluZ1xuIgor QEAgLTE2NjYsNyArMTY2OCwxMSBAQCBTQ01fREVGSU5FIChzY21fdXRpbWUsICJ1dGltZSIsIDEs IDUsIDAsCisgCSAgICAibW9kaWZpY2F0aW9uIHRpbWUgdG8gdGhlIGN1cnJlbnQgdGltZS5cblxu IgorICAgICAgICAgICAgICJMYXN0LCBAdmFye2ZsYWdzfSBtYXkgYmUgZWl0aGVyIEBjb2RlezB9 IG9yIHRoZVxuIgorICAgICAgICAgICAgICJAY29kZXtBVF9TWU1MSU5LX05PRk9MTE9XfSBjb25z dGFudCwgdG8gc2V0IHRoZSB0aW1lIG9mXG4iCistICAgICAgICAgICAgIkB2YXJ7cGF0aG5hbWV9 IGV2ZW4gaWYgaXQgaXMgYSBzeW1ib2xpYyBsaW5rLlxuIikKKysgICAgICAgICAgICAiQHZhcntw YXRobmFtZX0gZXZlbiBpZiBpdCBpcyBhIHN5bWJvbGljIGxpbmsuXG5cbiIKKysgICAgICAgICAg ICAiT24gR05VL0xpbnV4IHN5c3RlbXMsIGF0IGxlYXN0IHdoZW4gdXNpbmcgdGhlIExpbnV4IGtl cm5lbFxuIgorKyAgICAgICAgICAgICI1LjEwLjQ2LCBpZiBAdmFye29iamVjdH0gaXMgYSBwb3J0 LCBpdCBtYXkgbm90IGJlIGEgc3ltYm9saWNcbiIKKysgICAgICAgICAgICAibGluaywgZXZlbiBp ZiBAY29kZXtBVF9TWU1MSU5LX05PRk9MTE9XfSBpcyBzZXQuICBUaGlzIGlzIGVpdGhlclxuIgor KyAgICAgICAgICAgICJhIGJ1ZyBpbiBMaW51eCBvciBHdWlsZSdzIHdyYXBwZXJzLiAgVGhlIGV4 YWN0IGNhdXNlIGlzIHVuY2xlYXIuIikKKyAjZGVmaW5lIEZVTkNfTkFNRSBzX3NjbV91dGltZQor IHsKKyAgIGludCBydjsKK0BAIC0xNzI1LDggKzE3MzEsMTggQEAgU0NNX0RFRklORSAoc2NtX3V0 aW1lLCAidXRpbWUiLCAxLCA1LCAwLAorICAgICB0aW1lc1sxXS50dl9zZWMgPSBtdGltX3NlYzsK KyAgICAgdGltZXNbMV0udHZfbnNlYyA9IG10aW1fbnNlYzsKKyAKKy0gICAgU1RSSU5HX1NZU0NB TEwgKHBhdGhuYW1lLCBjX3BhdGhuYW1lLAorLSAgICAgICAgICAgICAgICAgICAgcnYgPSB1dGlt ZW5zYXQgKEFUX0ZEQ1dELCBjX3BhdGhuYW1lLCB0aW1lcywgZikpOworKyAgICBpZiAoU0NNX09Q RlBPUlRQIChvYmplY3QpKQorKyAgICAgIHsKKysgICAgICAgIGludCBmZDsKKysgICAgICAgIGZk ID0gU0NNX0ZQT1JUX0ZERVMgKG9iamVjdCk7CisrICAgICAgICBTQ01fU1lTQ0FMTCAocnYgPSBm dXRpbWVucyAoZmQsIHRpbWVzKSk7CisrICAgICAgICBzY21fcmVtZW1iZXJfdXB0b19oZXJlXzEg KG9iamVjdCk7CisrICAgICAgfQorKyAgICBlbHNlCisrICAgICAgeworKyAgICAgICAgU1RSSU5H X1NZU0NBTEwgKG9iamVjdCwgY19wYXRobmFtZSwKKysgICAgICAgICAgICAgICAgICAgICAgICBy diA9IHV0aW1lbnNhdCAoQVRfRkRDV0QsIGNfcGF0aG5hbWUsIHRpbWVzLCBmKSk7CisrICAgICAg fQorICAgfQorICNlbHNlCisgICB7CitAQCAtMTc0MCw3ICsxNzU2LDcgQEAgU0NNX0RFRklORSAo c2NtX3V0aW1lLCAidXRpbWUiLCAxLCA1LCAwLAorICAgICBpZiAoZiAhPSAwKQorICAgICAgIHNj bV9vdXRfb2ZfcmFuZ2UoRlVOQ19OQU1FLCBmbGFncyk7CisgCistICAgIFNUUklOR19TWVNDQUxM IChwYXRobmFtZSwgY19wYXRobmFtZSwKKysgICAgU1RSSU5HX1NZU0NBTEwgKG9iamVjdCwgY19w YXRobmFtZSwKKyAgICAgICAgICAgICAgICAgICAgIHJ2ID0gdXRpbWUgKGNfcGF0aG5hbWUsICZ1 dG0pKTsKKyAgIH0KKyAjZW5kaWYKK2RpZmYgLS1naXQgYS9saWJndWlsZS9wb3NpeC5oIGIvbGli Z3VpbGUvcG9zaXguaAoraW5kZXggZmYzYmVjOWVhLi5kZGE4MDEzYTUgMTAwNjQ0CistLS0gYS9s aWJndWlsZS9wb3NpeC5oCisrKysgYi9saWJndWlsZS9wb3NpeC5oCitAQCAtNjksNyArNjksNyBA QCBTQ01fQVBJIFNDTSBzY21fdG1wZmlsZSAodm9pZCk7CisgU0NNX0FQSSBTQ00gc2NtX29wZW5f cGlwZSAoU0NNIHBpcGVzdHIsIFNDTSBtb2Rlcyk7CisgU0NNX0FQSSBTQ00gc2NtX2Nsb3NlX3Bp cGUgKFNDTSBwb3J0KTsKKyBTQ01fQVBJIFNDTSBzY21fc3lzdGVtX3N0YXIgKFNDTSBjbWRzKTsK Ky1TQ01fQVBJIFNDTSBzY21fdXRpbWUgKFNDTSBwYXRobmFtZSwgU0NNIGFjdGltZSwgU0NNIG1v ZHRpbWUsCisrU0NNX0FQSSBTQ00gc2NtX3V0aW1lIChTQ00gb2JqZWN0LCBTQ00gYWN0aW1lLCBT Q00gbW9kdGltZSwKKyAgICAgICAgICAgICAgICAgICAgICAgIFNDTSBhY3RpbWVucywgU0NNIG1v ZHRpbWVucywgU0NNIGZsYWdzKTsKKyBTQ01fQVBJIFNDTSBzY21fYWNjZXNzIChTQ00gcGF0aCwg U0NNIGhvdyk7CisgU0NNX0FQSSBTQ00gc2NtX2dldHBpZCAodm9pZCk7CitkaWZmIC0tZ2l0IGEv dGVzdC1zdWl0ZS90ZXN0cy9wb3NpeC50ZXN0IGIvdGVzdC1zdWl0ZS90ZXN0cy9wb3NpeC50ZXN0 CitpbmRleCAxZTU1MmQxNmYuLjhlMzIyNTFiNSAxMDA2NDQKKy0tLSBhL3Rlc3Qtc3VpdGUvdGVz dHMvcG9zaXgudGVzdAorKysrIGIvdGVzdC1zdWl0ZS90ZXN0cy9wb3NpeC50ZXN0CitAQCAtMiw2 ICsyLDcgQEAKKyA7Ozs7CisgOzs7OyBDb3B5cmlnaHQgMjAwMy0yMDA0LDIwMDYtMjAwNywyMDEw LDIwMTIsMjAxNSwyMDE3LTIwMTksMjAyMQorIDs7OzsgICBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b24sIEluYy4KKys7Ozs7IENvcHlyaWdodCAyMDIxIE1heGltZSBEZXZvcyA8bWF4aW1lZGV2b3NA dGVsZW5ldC5iZT4KKyA7Ozs7CisgOzs7OyBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsg eW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgOzs7OyBtb2RpZnkgaXQgdW5kZXIgdGhl IHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCitAQCAtMjAxLDcgKzIwMiw3 NSBAQAorICAgICAgICAgICAgICAgICAobGlzdCAoc3RhdDphdGltZSBpbmZvKSAoc3RhdDptdGlt ZSBpbmZvKSkpKQorICAgICAgICAgICAgIChsYW1iZGEgKCkKKyAgICAgICAgICAgICAgIChkZWxl dGUtZmlsZSBmaWxlKSkpKQorLSAgICAgICAgKHRocm93ICd1bnN1cHBvcnRlZCkpKSkKKysgICAg ICAgICh0aHJvdyAndW5zdXBwb3J0ZWQpKSkKKysKKysgIChkZWZpbmUgKHV0aW1lLXVubGVzcy11 bnN1cHBvcnRlZCBvb3BzIC4gYXJndW1lbnRzKQorKyAgICAoY2F0Y2ggJ3N5c3RlbS1lcnJvcgor KyAgICAgIChsYW1iZGEgKCkKKysgICAgICAgIChjYXRjaCAnd3JvbmctdHlwZS1hcmcKKysgICAg ICAgICAgKGxhbWJkYSAoKQorKyAgICAgICAgICAgIChhcHBseSB1dGltZSBhcmd1bWVudHMpKQor KyAgICAgICAgICAobGFtYmRhIF8KKysgICAgICAgICAgICA7OyAnZnV0aW1lbnMnIGlzIG5vdCBz dXBwb3J0ZWQgb24gYWxsIHBsYXRmb3Jtcy4KKysgICAgICAgICAgICAob29wcykpKSkKKysgICAg ICAobGFtYmRhIGFyZ3MKKysgICAgICAgIDs7IE9uIHNvbWUgcGxhdGZvcm1zLCAnZnV0aW1lbnMn IHJldHVybnMgRU5PU1lTIGFjY29yZGluZyB0byBHbnVsaWIuCisrICAgICAgICAoaWYgKD0gKHN5 c3RlbS1lcnJvci1lcnJubyBhcmdzKSBFTk9TWVMpCisrICAgICAgICAgICAgKG9vcHMpCisrICAg ICAgICAgICAgKGFwcGx5IHRocm93IGFyZ3MpKSkpKQorKworKyAgKHBhc3MtaWYtZXF1YWwgImZp bGUgcG9ydCIKKysgICAgICAnKDEgMSkKKysgICAgKGxldCAoKGZpbGUgInBvc2l4LnRlc3QtdXRp bWUiKSkKKysgICAgICAoZmFsc2UtaWYtZXhjZXB0aW9uIChkZWxldGUtZmlsZSBmaWxlKSkKKysg ICAgICAoY2xvc2UtcG9ydCAob3Blbi1vdXRwdXQtZmlsZSBmaWxlKSkKKysgICAgICAoZGVmaW5l IChkZWxldGUpCisrICAgICAgICAoZGVsZXRlLWZpbGUgZmlsZSkpCisrICAgICAgKGRlZmluZSAo b29wcykKKysgICAgICAgIChkZWxldGUpCisrICAgICAgICAodGhyb3cgJ3Vuc3VwcG9ydGVkKSkK KysgICAgICAoY2FsbC13aXRoLWlucHV0LWZpbGUgZmlsZQorKyAgICAgICAgKGxhbWJkYSAocG9y dCkKKysgICAgICAgICAgKHV0aW1lLXVubGVzcy11bnN1cHBvcnRlZCBvb3BzIHBvcnQgMSAxIDAg MCkKKysgICAgICAgICAgKGRlZmluZSBpbmZvIChzdGF0IGZpbGUpKQorKyAgICAgICAgICAoZGVs ZXRlKQorKyAgICAgICAgICAobGlzdCAoc3RhdDphdGltZSBpbmZvKSAoc3RhdDptdGltZSBpbmZv KSkpKSkpCisrCisrICA7OyBUaGlzIGNhdXNlcyBhbiBFQkFERiBzeXN0ZW0gZXJyb3Igb24gR05V L0xpbnV4IHdpdGggdGhlIDUuMTAuNDYga2VybmVsLgorKyAgIzsKKysgIChwYXNzLWlmLWVxdWFs ICJmaWxlIHBvcnQgKHBvcnQgcmVwcmVzZW50aW5nIHN5bWJvbGljIGxpbmspIgorKyAgICAgICco MSAxKQorKyAgICAobGV0ICgoZmlsZSAicG9zaXgudGVzdC11dGltZSIpKQorKyAgICAgICh1bmxl c3MgKGZhbHNlLWlmLWV4Y2VwdGlvbgorKyAgICAgICAgICAgICAgIChiZWdpbiAoc3ltbGluayAi L3Nob3VsZC1iZS1pcnJlbGV2YW50IiBmaWxlKQorKyAgICAgICAgICAgICAgICAgICAgICAjdCkp CisrICAgICAgICAoZGlzcGxheSAiY2Fubm90IGNyZWF0ZSBzeW1saW5rLCBhIHV0aW1lIHRlc3Qg c2tpcHBlZFxuIikKKysgICAgICAgICh0aHJvdyAndW5yZXNvbHZlZCkpCisrICAgICAgKHVubGVz cyAoYW5kIChkZWZpbmVkPyAnT19OT0ZPTExPVykKKysgICAgICAgICAgICAgICAgICAgKGRlZmlu ZWQ/ICdPX1BBVEgpCisrICAgICAgICAgICAgICAgICAgIChub3QgKD0gMCBPX05PRk9MTE9XKSkK KysgICAgICAgICAgICAgICAgICAgKG5vdCAoPSAwIE9fUEFUSCkpKQorKyAgICAgICAgKGRpc3Bs YXkgImNhbm5vdCBvcGVuIHN5bWxpbmtzLCBhIHV0aW1lIHRlc3Qgc2tpcHBlZFxuIikKKysgICAg ICAgICh0aHJvdyAndW5yZXNvbHZlZCkpCisrICAgICAgKGRlZmluZSAoZGVsZXRlKQorKyAgICAg ICAgKHdoZW4gcG9ydCAoY2xvc2UtcG9ydCBwb3J0KSkKKysgICAgICAgIChmYWxzZS1pZi1leGNl cHRpb24gKGRlbGV0ZS1maWxlIGZpbGUpKSkKKysgICAgICAoZGVmaW5lIChvb3BzKQorKyAgICAg ICAgKGRlbGV0ZSkKKysgICAgICAgICh0aHJvdyAndW5zdXBwb3J0ZWQpKQorKyAgICAgIChkZWZp bmUgcG9ydCAjZikKKysgICAgICAoY2F0Y2ggI3QKKysgICAgICAgIChsYW1iZGEgKCkKKysgICAg ICAgICAgKHNldCEgcG9ydAorKyAgICAgICAgICAgIChvcGVuIGZpbGUgKGxvZ2lvciBPX05PRk9M TE9XIE9fUEFUSCkpKQorKyAgICAgICAgICAodXRpbWUtdW5sZXNzLXVuc3VwcG9ydGVkIG9vcHMg cG9ydCAxIDEgMCAwKSkKKysgICAgICAgIChsYW1iZGEgYXJncworKyAgICAgICAgICAocGsgJ2Rl bGV0aW5nIGZpbGUpCisrICAgICAgICAgIChkZWxldGUpCisrICAgICAgICAgIChhcHBseSB0aHJv dyBhcmdzKSkpCisrICAgICAgKGRlZmluZSBpbmZvIChsc3RhdCBmaWxlKSkKKysgICAgICAoZGVs ZXRlKQorKyAgICAgIChsaXN0IChzdGF0Om10aW1lIGluZm8pIChzdGF0OmF0aW1lIGluZm8pKSkp KQorIAorIDs7CisgOzsgYWZmaW5pdHkKKy0tIAorMi4zMC4yCisKKworCmRpZmYgLS1naXQgYS9n bnUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDQucGF0Y2ggYi9n bnUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDQucGF0Y2gKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMC4uNzFkMTIzMTZhZgotLS0gL2Rldi9u dWxsCisrKyBiL2dudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0w NC5wYXRjaApAQCAtMCwwICsxLDE0MiBAQAorR3VpeC1VcHN0cmVhbTogaHR0cHM6Ly9saXN0cy5n bnUub3JnL2FyY2hpdmUvaHRtbC9ndWlsZS1kZXZlbC8yMDIxLTExL21zZzAwMDA1Lmh0bWwKK0Zy b206IE1heGltZSBEZXZvcyA8bWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KK1N1YmplY3Q6IFtQQVRD SCB2MiAwNC8xNF0gPT9VVEYtOD9xP0RlZmluZT0yMD1FMj04MD05OHN5bWxpbmthdD1FMj04MD05 OT89CisgPT9VVEYtOD9xPz0yMHdyYXBwZXI9MjB3aGVuPTIwc3VwcG9ydGVkLj89CitEYXRlOiBU dWUsIDE2IE5vdiAyMDIxIDExOjA2OjI3ICswMDAwCitNZXNzYWdlLUlkOiA8MjAyMTExMTYxMTA2 MzcuMTI1NTc5LTUtbWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KK0luLVJlcGx5LVRvOiA8MjAyMTEx MTYxMTA2MzcuMTI1NTc5LTEtbWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KK1JlZmVyZW5jZXM6IDwx NzVjM2E2NTcyZTgzMmQ4NDkyNzkzN2IzMDlhMzA5NWNhZGY1NzAyLmNhbWVsQHRlbGVuZXQuYmU+ CisgPDIwMjExMTE2MTEwNjM3LjEyNTU3OS0xLW1heGltZWRldm9zQHRlbGVuZXQuYmU+CitNSU1F LVZlcnNpb246IDEuMAorQ29udGVudC1UeXBlOiB0ZXh0L3BsYWluOyBjaGFyc2V0PVVURi04CitD b250ZW50LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0CisKKyogY29uZmlndXJlLmFjOiBEZXRlY3Qg d2hldGhlciDigJhzeW1saW5rYXTigJkgZXhpc3RzLgorKiBsaWJndWlsZS9maWxlc3lzLmMgKHNj bV9zeW1saW5rYXQpOiBEZWZpbmUgYSBTY2hlbWUgYmluZGluZworICB3aGVuIGl0IGV4aXN0cy4K KyogbGliZ3VpbGUvZmlsZXN5cy5oOiBNYWtlIHRoZSBiaW5kaW5nIHBhcnQgb2YgdGhlIHB1Ymxp YyBDIEFQSS4KKyogZG9jL3JlZi9wb3NpeC50ZXhpIChGaWxlIFN5c3RlbSk6IERvY3VtZW50IHRo ZSBiaW5kaW5nLgorKiB0ZXN0LXN1aXRlL3Rlc3RzL2ZpbGVzeXMudGVzdCAoInN5bWxpbmthdCIp OiBUZXN0IGl0LgorLS0tCisgY29uZmlndXJlLmFjICAgICAgICAgICAgICAgICAgfCAgMiArLQor IGRvYy9yZWYvcG9zaXgudGV4aSAgICAgICAgICAgIHwgIDYgKysrKysrCisgbGliZ3VpbGUvZmls ZXN5cy5jICAgICAgICAgICAgfCAyMyArKysrKysrKysrKysrKysrKysrKysrKworIGxpYmd1aWxl L2ZpbGVzeXMuaCAgICAgICAgICAgIHwgIDEgKworIHRlc3Qtc3VpdGUvdGVzdHMvZmlsZXN5cy50 ZXN0IHwgMjcgKysrKysrKysrKysrKysrKysrKysrKysrKysrCisgNSBmaWxlcyBjaGFuZ2VkLCA1 OCBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCisKK2RpZmYgLS1naXQgYS9jb25maWd1cmUu YWMgYi9jb25maWd1cmUuYWMKK2luZGV4IGRkZjMzMGQ5Ni4uYjJlOWVmM2U5IDEwMDY0NAorLS0t IGEvY29uZmlndXJlLmFjCisrKysgYi9jb25maWd1cmUuYWMKK0BAIC00ODUsNyArNDg1LDcgQEAg QUNfQ0hFQ0tfSEVBREVSUyhbYXNzZXJ0LmggY3J0X2V4dGVybnMuaF0pCisgIworIEFDX0NIRUNL X0ZVTkNTKFtESU5GSU5JVFkgRFFOQU4gY2V4cCBjaHNpemUgY2xvZyBjbG9nMTAgY3Rlcm1pZCAg ICAgICAgIFwKKyAgIGZlc2V0cm91bmQgZnRpbWUgZnRydW5jYXRlIGZjaG93biBmY2htb2QgZmNo ZGlyIHJlYWRsaW5rYXQJCVwKKy0gIGdldGN3ZCBnZXRldWlkIGdldHNpZAkJCQkJCQlcCisrICBz eW1saW5rYXQgZ2V0Y3dkIGdldGV1aWQgZ2V0c2lkCQkJCQkJCVwKKyAgIGdldHRpbWVvZmRheSBn ZXR1aWQgZ2V0Z2lkIGdtdGltZV9yIGlvY3RsIGxzdGF0IG1rZGlyIG1rZHRlbXAgbWtub2QgICBc CisgICBuaWNlIHJlYWRsaW5rIHJlbmFtZSBybWRpciBzZXRlZ2lkIHNldGV1aWQgICAgICAgICAg ICAgICAgICAgICAgICAgICAgXAorICAgc2V0bG9jYWxlIHNldHVpZCBzZXRnaWQgc2V0cGdpZCBz ZXRzaWQgc2lnYWN0aW9uIHNpZ2ludGVycnVwdCBzdGF0NjQgIFwKK2RpZmYgLS1naXQgYS9kb2Mv cmVmL3Bvc2l4LnRleGkgYi9kb2MvcmVmL3Bvc2l4LnRleGkKK2luZGV4IGI2ZGVmZmQ0My4uYTMy OWVlYzM5IDEwMDY0NAorLS0tIGEvZG9jL3JlZi9wb3NpeC50ZXhpCisrKysgYi9kb2MvcmVmL3Bv c2l4LnRleGkKK0BAIC04OTEsNiArODkxLDEyIEBAIENyZWF0ZSBhIHN5bWJvbGljIGxpbmsgbmFt ZWQgQHZhcntuZXdwYXRofSB3aXRoIHRoZSB2YWx1ZSAoaS5lLiwgcG9pbnRpbmcgdG8pCisgQHZh cntvbGRwYXRofS4gIFRoZSByZXR1cm4gdmFsdWUgaXMgdW5zcGVjaWZpZWQuCisgQGVuZCBkZWZm bgorIAorK0BkZWZmbiB7U2NoZW1lIFByb2NlZHVyZX0gc3ltbGlua2F0IGRpciBvbGRwYXRoIG5l d3BhdGgKKytAZGVmZm54IHtDIEZ1bmN0aW9ufSBzY21fc3ltbGlua2F0IChkaXIsIG9sZHBhdGgs IG5ld3BhdGgpCisrTGlrZSBAY29kZXtzeW1saW5rfSwgYnV0IHJlc29sdmUgQHZhcntuZXdwYXRo fSByZWxhdGl2ZSB0bworK3RoZSBkaXJlY3RvcnkgcmVmZXJyZWQgdG8gYnkgdGhlIGZpbGUgcG9y dCBAdmFye2Rpcn0uCisrQGVuZCBkZWZmbgorKworIEBkZWZmbiB7U2NoZW1lIFByb2NlZHVyZX0g bWtkaXIgcGF0aCBbbW9kZV0KKyBAZGVmZm54IHtDIEZ1bmN0aW9ufSBzY21fbWtkaXIgKHBhdGgs IG1vZGUpCisgQ3JlYXRlIGEgbmV3IGRpcmVjdG9yeSBuYW1lZCBieSBAdmFye3BhdGh9LiAgSWYg QHZhcnttb2RlfSBpcyBvbWl0dGVkCitkaWZmIC0tZ2l0IGEvbGliZ3VpbGUvZmlsZXN5cy5jIGIv bGliZ3VpbGUvZmlsZXN5cy5jCitpbmRleCBjNWJlZGVjMDcuLmJmZDIyMzQzNCAxMDA2NDQKKy0t LSBhL2xpYmd1aWxlL2ZpbGVzeXMuYworKysrIGIvbGliZ3VpbGUvZmlsZXN5cy5jCitAQCAtMTA0 NSw2ICsxMDQ1LDI5IEBAIFNDTV9ERUZJTkUgKHNjbV9zeW1saW5rLCAic3ltbGluayIsIDIsIDAs IDAsCisgI3VuZGVmIEZVTkNfTkFNRQorICNlbmRpZiAvKiBIQVZFX1NZTUxJTksgKi8KKyAKKysj aWZkZWYgSEFWRV9TWU1MSU5LQVQKKytTQ01fREVGSU5FIChzY21fc3ltbGlua2F0LCAic3ltbGlu a2F0IiwgMywgMCwgMCwKKysgICAgICAgICAgICAoU0NNIGRpciwgU0NNIG9sZHBhdGgsIFNDTSBu ZXdwYXRoKSwKKysgICAgICAgICAgICAiTGlrZSBAY29kZXtzeW1saW5rfSwgYnV0IHJlc29sdmUg QHZhcntuZXdwYXRofSByZWxhdGl2ZVxuIgorKyAgICAgICAgICAgICJ0byB0aGUgZGlyZWN0b3J5 IHJlZmVycmVkIHRvIGJ5IHRoZSBmaWxlIHBvcnQgQHZhcntkaXJ9LiIpCisrI2RlZmluZSBGVU5D X05BTUUgc19zY21fc3ltbGlua2F0CisreworKyAgaW50IHZhbDsKKysgIGludCBmZGVzOworKwor KyAgU0NNX1ZBTElEQVRFX09QRlBPUlQgKFNDTV9BUkcxLCBkaXIpOworKyAgZmRlcyA9IFNDTV9G UE9SVF9GREVTIChkaXIpOworKyAgU1RSSU5HMl9TWVNDQUxMIChvbGRwYXRoLCBjX29sZHBhdGgs CisrCQkgICBuZXdwYXRoLCBjX25ld3BhdGgsCisrCQkgICB2YWwgPSBzeW1saW5rYXQgKGNfb2xk cGF0aCwgZmRlcywgY19uZXdwYXRoKSk7CisrICBzY21fcmVtZW1iZXJfdXB0b19oZXJlXzEgKGRp cik7CisrICBpZiAodmFsICE9IDApCisrICAgIFNDTV9TWVNFUlJPUjsKKysgIHJldHVybiBTQ01f VU5TUEVDSUZJRUQ7CisrfQorKyN1bmRlZiBGVU5DX05BTUUKKysjZW5kaWYgLyogSEFWRV9TWU1M SU5LQVQgKi8KKysKKyAvKiBTdGF0aWMgaGVscGVyIGZ1bmN0aW9uIGZvciBjaG9vc2luZyBiZXR3 ZWVuIHJlYWRsaW5rCisgICAgYW5kIHJlYWRsaW5rYXQuICovCisgc3RhdGljIGludAorZGlmZiAt LWdpdCBhL2xpYmd1aWxlL2ZpbGVzeXMuaCBiL2xpYmd1aWxlL2ZpbGVzeXMuaAoraW5kZXggYTNi MjU3YzEyLi5kMTgxYWNhNTIgMTAwNjQ0CistLS0gYS9saWJndWlsZS9maWxlc3lzLmgKKysrKyBi L2xpYmd1aWxlL2ZpbGVzeXMuaAorQEAgLTYyLDYgKzYyLDcgQEAgU0NNX0FQSSBTQ00gc2NtX3Nl bGVjdCAoU0NNIHJlYWRzLCBTQ00gd3JpdGVzLCBTQ00gZXhjZXB0cywgU0NNIHNlY3MsIFNDTSBt c2VjcykKKyBTQ01fQVBJIFNDTSBzY21fZmNudGwgKFNDTSBvYmplY3QsIFNDTSBjbWQsIFNDTSB2 YWx1ZSk7CisgU0NNX0FQSSBTQ00gc2NtX2ZzeW5jIChTQ00gb2JqZWN0KTsKKyBTQ01fQVBJIFND TSBzY21fc3ltbGluayAoU0NNIG9sZHBhdGgsIFNDTSBuZXdwYXRoKTsKKytTQ01fQVBJIFNDTSBz Y21fc3ltbGlua2F0IChTQ00gZGlyLCBTQ00gb2xkcGF0aCwgU0NNIG5ld3BhdGgpOworIFNDTV9B UEkgU0NNIHNjbV9yZWFkbGluayAoU0NNIHBhdGgpOworIFNDTV9BUEkgU0NNIHNjbV9sc3RhdCAo U0NNIHN0cik7CisgU0NNX0FQSSBTQ00gc2NtX2NvcHlfZmlsZSAoU0NNIG9sZGZpbGUsIFNDTSBu ZXdmaWxlKTsKK2RpZmYgLS1naXQgYS90ZXN0LXN1aXRlL3Rlc3RzL2ZpbGVzeXMudGVzdCBiL3Rl c3Qtc3VpdGUvdGVzdHMvZmlsZXN5cy50ZXN0CitpbmRleCA3ZmViMzQ5MmYuLjY0YmY5MjMzMyAx MDA2NDQKKy0tLSBhL3Rlc3Qtc3VpdGUvdGVzdHMvZmlsZXN5cy50ZXN0CisrKysgYi90ZXN0LXN1 aXRlL3Rlc3RzL2ZpbGVzeXMudGVzdAorQEAgLTM2NywzICszNjcsMzAgQEAKKyAKKyAgIChmYWxz ZS1pZi1leGNlcHRpb24gKGRlbGV0ZS1maWxlICh0ZXN0LXN5bWxpbmspKSkKKyAgIChmYWxzZS1p Zi1leGNlcHRpb24gKGRlbGV0ZS1maWxlICh0ZXN0LWZpbGUpKSkpCisrCisrKHdpdGgtdGVzdC1w cmVmaXggInN5bWxpbmthdCIKKysgIChwYXNzLWlmLWVxdWFsICJjcmVhdGUiICh0ZXN0LWZpbGUp CisrICAgICh1bmxlc3MgKGRlZmluZWQ/ICdzeW1saW5rYXQpCisrICAgICAgKHRocm93ICd1bnN1 cHBvcnRlZCkpCisrICAgIChjYWxsLXdpdGgtcG9ydAorKyAgICAgKG9wZW4gIi4iIE9fUkRPTkxZ KQorKyAgICAgKGxhbWJkYSAocG9ydCkKKysgICAgICAgKHN5bWxpbmthdCBwb3J0ICh0ZXN0LWZp bGUpICh0ZXN0LXN5bWxpbmspKQorKyAgICAgICAocmVhZGxpbmsgKHRlc3Qtc3ltbGluaykpKSkp CisrICAoZmFsc2UtaWYtZXhjZXB0aW9uIChkZWxldGUtZmlsZSAodGVzdC1zeW1saW5rKSkpCisr CisrICAocGFzcy1pZi1leGNlcHRpb24gIm5vdCBhIHBvcnQiIGV4Y2VwdGlvbjp3cm9uZy10eXBl LWFyZworKyAgICAodW5sZXNzIChkZWZpbmVkPyAnc3ltbGlua2F0KQorKyAgICAgICh0aHJvdyAn dW5zdXBwb3J0ZWQpKQorKyAgICAoc3ltbGlua2F0ICJib2d1cyIgKHRlc3QtZmlsZSkgKHRlc3Qt c3ltbGluaykpKQorKworKyAgKHBhc3MtaWYtZXhjZXB0aW9uICJub3QgYSBmaWxlIHBvcnQiIGV4 Y2VwdGlvbjp3cm9uZy10eXBlLWFyZworKyAgICAodW5sZXNzIChkZWZpbmVkPyAnc3ltbGlua2F0 KQorKyAgICAgICh0aHJvdyAndW5zdXBwb3J0ZWQpKQorKyAgICAoc3ltbGlua2F0IChvcGVuLWlu cHV0LXN0cmluZyAiIikgKHRlc3QtZmlsZSkgKHRlc3Qtc3ltbGluaykpKQorKworKyAgKHBhc3Mt aWYtZXhjZXB0aW9uICJjbG9zZWQgcG9ydCIgZXhjZXB0aW9uOndyb25nLXR5cGUtYXJnCisrICAg ICh1bmxlc3MgKGRlZmluZWQ/ICdzeW1saW5rYXQpCisrICAgICAgKHRocm93ICd1bnN1cHBvcnRl ZCkpCisrICAgIChzeW1saW5rYXQgKGNhbGwtd2l0aC1wb3J0IChvcGVuICIuIiBPX1JET05MWSkg aWRlbnRpdHkpCisrICAgICAgICAgICAgICAgKHRlc3QtZmlsZSkgKHRlc3Qtc3ltbGluaykpKSkK Ky0tIAorMi4zMC4yCisKKwpkaWZmIC0tZ2l0IGEvZ251L3BhY2thZ2VzL3BhdGNoZXMvZ3VpbGUt b3BlbmF0LWFuZC1mcmllbmRzLTA1LnBhdGNoIGIvZ251L3BhY2thZ2VzL3BhdGNoZXMvZ3VpbGUt b3BlbmF0LWFuZC1mcmllbmRzLTA1LnBhdGNoCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAuLjBjYmM3NjAwNGUKLS0tIC9kZXYvbnVsbAorKysgYi9nbnUvcGFja2FnZXMvcGF0 Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDUucGF0Y2gKQEAgLTAsMCArMSwxNTkgQEAK K0d1aXgtVXBzdHJlYW06IGh0dHBzOi8vbGlzdHMuZ251Lm9yZy9hcmNoaXZlL2h0bWwvZ3VpbGUt ZGV2ZWwvMjAyMS0xMS9tc2cwMDAwNS5odG1sCitGcm9tOiBNYXhpbWUgRGV2b3MgPG1heGltZWRl dm9zQHRlbGVuZXQuYmU+CitTdWJqZWN0OiBbUEFUQ0ggdjIgMDUvMTRdCisgPT9VVEYtOD9xP0Rl ZmluZT0yMGJpbmRpbmdzPTIwdG89MjA9RTI9ODA9OThta2RpPz0KKyA9P1VURi04P3E/cmF0PUUy PTgwPTk5PTIwd2hlbj0yMHRoZT0yMEM9MjBmdW5jdGlvbj0yMGV4aXN0cy4/PQorRGF0ZTogVHVl LCAxNiBOb3YgMjAyMSAxMTowNjoyOCArMDAwMAorTWVzc2FnZS1JZDogPDIwMjExMTE2MTEwNjM3 LjEyNTU3OS02LW1heGltZWRldm9zQHRlbGVuZXQuYmU+CitSZWZlcmVuY2VzOiA8MTc1YzNhNjU3 MmU4MzJkODQ5Mjc5MzdiMzA5YTMwOTVjYWRmNTcwMi5jYW1lbEB0ZWxlbmV0LmJlPgorIDwyMDIx MTExNjExMDYzNy4xMjU1NzktMS1tYXhpbWVkZXZvc0B0ZWxlbmV0LmJlPgorTUlNRS1WZXJzaW9u OiAxLjAKK0NvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD1VVEYtOAorQ29udGVudC1U cmFuc2Zlci1FbmNvZGluZzogOGJpdAorCisqIGNvbmZpZ3VyZS5hYzogRGV0ZWN0IGlmIOKAmG1r ZGlyYXTigJkgZXhpc3RzLgorKiBsaWJndWlsZS9maWxlc3lzLmMgKHNjbV9ta2RpcmF0KTogRGVm aW5lIHRoZSBTY2hlbWUgYmluZGluZy4KKyogZG9jL3JlZi9wb3NpeC50ZXhpIChGaWxlIFN5c3Rl bSk6IERvY3VtZW50IGl0LgorLS0tCisgY29uZmlndXJlLmFjICAgICAgICAgICAgICAgICAgfCAg MiArLQorIGRvYy9yZWYvcG9zaXgudGV4aSAgICAgICAgICAgIHwgIDYgKysrKysrCisgbGliZ3Vp bGUvZmlsZXN5cy5jICAgICAgICAgICAgfCAyNSArKysrKysrKysrKysrKysrKysrKysrKworIGxp Ymd1aWxlL2ZpbGVzeXMuaCAgICAgICAgICAgIHwgIDEgKworIHRlc3Qtc3VpdGUvdGVzdHMvZmls ZXN5cy50ZXN0IHwgMzggKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKKyA1IGZp bGVzIGNoYW5nZWQsIDcxIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKKworZGlmZiAtLWdp dCBhL2NvbmZpZ3VyZS5hYyBiL2NvbmZpZ3VyZS5hYworaW5kZXggYjJlOWVmM2U5Li5kYThkZmFk ZDAgMTAwNjQ0CistLS0gYS9jb25maWd1cmUuYWMKKysrKyBiL2NvbmZpZ3VyZS5hYworQEAgLTQ4 NSw3ICs0ODUsNyBAQCBBQ19DSEVDS19IRUFERVJTKFthc3NlcnQuaCBjcnRfZXh0ZXJucy5oXSkK KyAjCisgQUNfQ0hFQ0tfRlVOQ1MoW0RJTkZJTklUWSBEUU5BTiBjZXhwIGNoc2l6ZSBjbG9nIGNs b2cxMCBjdGVybWlkICAgICAgICAgXAorICAgZmVzZXRyb3VuZCBmdGltZSBmdHJ1bmNhdGUgZmNo b3duIGZjaG1vZCBmY2hkaXIgcmVhZGxpbmthdAkJXAorLSAgc3ltbGlua2F0IGdldGN3ZCBnZXRl dWlkIGdldHNpZAkJCQkJCQlcCisrICBzeW1saW5rYXQgbWtkaXJhdCBnZXRjd2QgZ2V0ZXVpZCBn ZXRzaWQJCQkJXAorICAgZ2V0dGltZW9mZGF5IGdldHVpZCBnZXRnaWQgZ210aW1lX3IgaW9jdGwg bHN0YXQgbWtkaXIgbWtkdGVtcCBta25vZCAgIFwKKyAgIG5pY2UgcmVhZGxpbmsgcmVuYW1lIHJt ZGlyIHNldGVnaWQgc2V0ZXVpZCAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICBzZXRs b2NhbGUgc2V0dWlkIHNldGdpZCBzZXRwZ2lkIHNldHNpZCBzaWdhY3Rpb24gc2lnaW50ZXJydXB0 IHN0YXQ2NCAgXAorZGlmZiAtLWdpdCBhL2RvYy9yZWYvcG9zaXgudGV4aSBiL2RvYy9yZWYvcG9z aXgudGV4aQoraW5kZXggYTMyOWVlYzM5Li5kMjYxYWM4ZGEgMTAwNjQ0CistLS0gYS9kb2MvcmVm L3Bvc2l4LnRleGkKKysrKyBiL2RvYy9yZWYvcG9zaXgudGV4aQorQEAgLTkwNiw2ICs5MDYsMTIg QEAgT3RoZXJ3aXNlIHRoZXkgYXJlIHNldCB0byB0aGUgdmFsdWUgc3BlY2lmaWVkIHdpdGggQHZh cnttb2RlfS4KKyBUaGUgcmV0dXJuIHZhbHVlIGlzIHVuc3BlY2lmaWVkLgorIEBlbmQgZGVmZm4K KyAKKytAZGVmZm4ge1NjaGVtZSBQcm9jZWR1cmV9IG1rZGlyYXQgZGlyIHBhdGggW21vZGVdCisr QGRlZmZueCB7QyBGdW5jdGlvbn0gc2NtX21rZGlyYXQgKGRpciwgcGF0aCwgbW9kZSkKKytMaWtl IEBjb2Rle21rZGlyfSwgYnV0IHJlc29sdmUgQHZhcntwYXRofSByZWxhdGl2ZSB0byB0aGUgZGly ZWN0b3J5CisrcmVmZXJyZWQgdG8gYnkgdGhlIGZpbGUgcG9ydCBAdmFye2Rpcn0gaW5zdGVhZC4K KytAZW5kIGRlZmZuCisrCisgQGRlZmZuIHtTY2hlbWUgUHJvY2VkdXJlfSBybWRpciBwYXRoCisg QGRlZmZueCB7QyBGdW5jdGlvbn0gc2NtX3JtZGlyIChwYXRoKQorIFJlbW92ZSB0aGUgZXhpc3Rp bmcgZGlyZWN0b3J5IG5hbWVkIGJ5IEB2YXJ7cGF0aH0uICBUaGUgZGlyZWN0b3J5IG11c3QKK2Rp ZmYgLS1naXQgYS9saWJndWlsZS9maWxlc3lzLmMgYi9saWJndWlsZS9maWxlc3lzLmMKK2luZGV4 IGJmZDIyMzQzNC4uZWUwMWIyZTJjIDEwMDY0NAorLS0tIGEvbGliZ3VpbGUvZmlsZXN5cy5jCisr KysgYi9saWJndWlsZS9maWxlc3lzLmMKK0BAIC0xMzY0LDYgKzEzNjQsMzEgQEAgU0NNX0RFRklO RSAoc2NtX21rZGlyLCAibWtkaXIiLCAxLCAxLCAwLAorIH0KKyAjdW5kZWYgRlVOQ19OQU1FCisg CisrI2lmZGVmIEhBVkVfTUtESVJBVAorK1NDTV9ERUZJTkUgKHNjbV9ta2RpcmF0LCAibWtkaXJh dCIsIDIsIDEsIDAsCisrICAgICAgICAgICAgKFNDTSBkaXIsIFNDTSBwYXRoLCBTQ00gbW9kZSks CisrICAgICAgICAgICAgIkxpa2UgQGNvZGV7bWtkaXJ9LCBidXQgcmVzb2x2ZSBAdmFye3BhdGh9 IHJlbGF0aXZlIHRvIHRoZSBkaXJlY3RvcnlcbiIKKysgICAgICAgICAgICAicmVmZXJyZWQgdG8g YnkgdGhlIGZpbGUgcG9ydCBAdmFye2Rpcn0gaW5zdGVhZC4iKQorKyNkZWZpbmUgRlVOQ19OQU1F IHNfc2NtX21rZGlyYXQKKyt7CisrICBpbnQgcnY7CisrICBpbnQgZGlyX2ZkZXM7CisrICBtb2Rl X3QgY19tb2RlOworKworKyAgY19tb2RlID0gU0NNX1VOQk5EUCAobW9kZSkgPyAwNzc3IDogc2Nt X3RvX3VpbnQgKG1vZGUpOworKyAgU0NNX1ZBTElEQVRFX09QRlBPUlQgKFNDTV9BUkcxLCBkaXIp OworKyAgZGlyX2ZkZXMgPSBTQ01fRlBPUlRfRkRFUyAoZGlyKTsKKysKKysgIFNUUklOR19TWVND QUxMIChwYXRoLCBjX3BhdGgsIHJ2ID0gbWtkaXJhdCAoZGlyX2ZkZXMsIGNfcGF0aCwgY19tb2Rl KSk7CisrICBpZiAocnYgIT0gMCkKKysgICAgU0NNX1NZU0VSUk9SOworKworKyAgc2NtX3JlbWVt YmVyX3VwdG9faGVyZV8xIChkaXIpOworKyAgcmV0dXJuIFNDTV9VTlNQRUNJRklFRDsKKyt9Cisr I3VuZGVmIEZVTkNfTkFNRQorKyNlbmRpZgorKworIFNDTV9ERUZJTkUgKHNjbV9ybWRpciwgInJt ZGlyIiwgMSwgMCwgMCwgCisgICAgICAgICAgICAgKFNDTSBwYXRoKSwKKyAJICAgICJSZW1vdmUg dGhlIGV4aXN0aW5nIGRpcmVjdG9yeSBuYW1lZCBieSBAdmFye3BhdGh9LiAgVGhlIGRpcmVjdG9y eSBtdXN0XG4iCitkaWZmIC0tZ2l0IGEvbGliZ3VpbGUvZmlsZXN5cy5oIGIvbGliZ3VpbGUvZmls ZXN5cy5oCitpbmRleCBkMTgxYWNhNTIuLmYwZGQzNWVkZSAxMDA2NDQKKy0tLSBhL2xpYmd1aWxl L2ZpbGVzeXMuaAorKysrIGIvbGliZ3VpbGUvZmlsZXN5cy5oCitAQCAtNTAsNiArNTAsNyBAQCBT Q01fQVBJIFNDTSBzY21fbGluayAoU0NNIG9sZHBhdGgsIFNDTSBuZXdwYXRoKTsKKyBTQ01fQVBJ IFNDTSBzY21fcmVuYW1lIChTQ00gb2xkbmFtZSwgU0NNIG5ld25hbWUpOworIFNDTV9BUEkgU0NN IHNjbV9kZWxldGVfZmlsZSAoU0NNIHN0cik7CisgU0NNX0FQSSBTQ00gc2NtX21rZGlyIChTQ00g cGF0aCwgU0NNIG1vZGUpOworK1NDTV9BUEkgU0NNIHNjbV9ta2RpcmF0IChTQ00gZGlyLCBTQ00g cGF0aCwgU0NNIG1vZGUpOworIFNDTV9BUEkgU0NNIHNjbV9ybWRpciAoU0NNIHBhdGgpOworIFND TV9BUEkgU0NNIHNjbV9kaXJlY3Rvcnlfc3RyZWFtX3AgKFNDTSBvYmopOworIFNDTV9BUEkgU0NN IHNjbV9vcGVuZGlyIChTQ00gZGlybmFtZSk7CitkaWZmIC0tZ2l0IGEvdGVzdC1zdWl0ZS90ZXN0 cy9maWxlc3lzLnRlc3QgYi90ZXN0LXN1aXRlL3Rlc3RzL2ZpbGVzeXMudGVzdAoraW5kZXggNjRi ZjkyMzMzLi40ZWE2MmQ1MTMgMTAwNjQ0CistLS0gYS90ZXN0LXN1aXRlL3Rlc3RzL2ZpbGVzeXMu dGVzdAorKysrIGIvdGVzdC1zdWl0ZS90ZXN0cy9maWxlc3lzLnRlc3QKK0BAIC0yOSw2ICsyOSw4 IEBACisgICAoZGF0YS1maWxlLW5hbWUgImZpbGVzeXMtdGVzdC50bXAiKSkKKyAoZGVmaW5lICh0 ZXN0LXN5bWxpbmspCisgICAoZGF0YS1maWxlLW5hbWUgImZpbGVzeXMtdGVzdC1saW5rLnRtcCIp KQorKyhkZWZpbmUgKHRlc3QtZGlyZWN0b3J5KQorKyAgKGRhdGEtZmlsZS1uYW1lICJmaWxlc3lz LXRlc3QtZGlyLnRtcCIpKQorIAorIAorIDs7OworQEAgLTM5NCwzICszOTYsMzkgQEAKKyAgICAg ICAodGhyb3cgJ3Vuc3VwcG9ydGVkKSkKKyAgICAgKHN5bWxpbmthdCAoY2FsbC13aXRoLXBvcnQg KG9wZW4gIi4iIE9fUkRPTkxZKSBpZGVudGl0eSkKKyAgICAgICAgICAgICAgICAodGVzdC1maWxl KSAodGVzdC1zeW1saW5rKSkpKQorKworKyh3aXRoLXRlc3QtcHJlZml4ICJta2RpcmF0IgorKyAg KGRlZmluZSAoc2tpcC1pZi11bnN1cHBvcnRlZCkKKysgICAgKHVubGVzcyAoZGVmaW5lZD8gJ21r ZGlyYXQpCisrICAgICAgKHRocm93ICd1bnN1cHBvcnRlZCkpKQorKyAgKGRlZmluZSAobWF5YmUt ZGVsZXRlLWRpcmVjdG9yeSkKKysgICAgKHdoZW4gKGZpbGUtZXhpc3RzPyAodGVzdC1kaXJlY3Rv cnkpKQorKyAgICAgIChybWRpciAodGVzdC1kaXJlY3RvcnkpKSkpCisrICAobWF5YmUtZGVsZXRl LWRpcmVjdG9yeSkKKysKKysgIChwYXNzLWlmLWVxdWFsICJjcmVhdGUiICdkaXJlY3RvcnkKKysg ICAgKHNraXAtaWYtdW5zdXBwb3J0ZWQpCisrICAgIChjYWxsLXdpdGgtcG9ydAorKyAgICAgKG9w ZW4gIi4iIE9fUkRPTkxZKQorKyAgICAgKGxhbWJkYSAocG9ydCkKKysgICAgICAgKG1rZGlyYXQg cG9ydCAodGVzdC1kaXJlY3RvcnkpKQorKyAgICAgICAoc3RhdDp0eXBlIChzdGF0ICh0ZXN0LWRp cmVjdG9yeSkpKSkpKQorKyAgKG1heWJlLWRlbGV0ZS1kaXJlY3RvcnkpCisrCisrICAocGFzcy1p Zi1lcXVhbCAiZXhwbGljaXQgcGVybXMiIChsb2dhbmQgI28xMTEgKGxvZ25vdCAodW1hc2spKSkK KysgICAgKHNraXAtaWYtdW5zdXBwb3J0ZWQpCisrICAgIChjYWxsLXdpdGgtcG9ydAorKyAgICAg KG9wZW4gIi4iIE9fUkRPTkxZKQorKyAgICAgKGxhbWJkYSAocG9ydCkKKysgICAgICAgKG1rZGly YXQgcG9ydCAodGVzdC1kaXJlY3RvcnkpICNvMTExKQorKyAgICAgICAoc3RhdDpwZXJtcyAoc3Rh dCAodGVzdC1kaXJlY3RvcnkpKSkpKSkKKysgIChtYXliZS1kZWxldGUtZGlyZWN0b3J5KQorKwor KyAgKHBhc3MtaWYtZXF1YWwgImNyZWF0ZSwgaW1wbGljaXQgcGVybXMiIChsb2dhbmQgI283Nzcg KGxvZ25vdCAodW1hc2spKSkKKysgICAgKHNraXAtaWYtdW5zdXBwb3J0ZWQpCisrICAgIChjYWxs LXdpdGgtcG9ydAorKyAgICAgKG9wZW4gIi4iIE9fUkRPTkxZKQorKyAgICAgKGxhbWJkYSAocG9y dCkKKysgICAgICAgKG1rZGlyYXQgcG9ydCAodGVzdC1kaXJlY3RvcnkpKQorKyAgICAgICAoc3Rh dDpwZXJtcyAoc3RhdCAodGVzdC1kaXJlY3RvcnkpKSkpKSkKKysgIChtYXliZS1kZWxldGUtZGly ZWN0b3J5KSkKKy0tIAorMi4zMC4yCisKKwpkaWZmIC0tZ2l0IGEvZ251L3BhY2thZ2VzL3BhdGNo ZXMvZ3VpbGUtb3BlbmF0LWFuZC1mcmllbmRzLTA2LnBhdGNoIGIvZ251L3BhY2thZ2VzL3BhdGNo ZXMvZ3VpbGUtb3BlbmF0LWFuZC1mcmllbmRzLTA2LnBhdGNoCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAuLjA0Zjg5MDA5ODYKLS0tIC9kZXYvbnVsbAorKysgYi9nbnUvcGFj a2FnZXMvcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDYucGF0Y2gKQEAgLTAsMCAr MSwzNyBAQAorR3VpeC1VcHN0cmVhbTogaHR0cHM6Ly9saXN0cy5nbnUub3JnL2FyY2hpdmUvaHRt bC9ndWlsZS1kZXZlbC8yMDIxLTExL21zZzAwMDA1Lmh0bWwKK0Zyb206IE1heGltZSBEZXZvcyA8 bWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KK1N1YmplY3Q6IFtQQVRDSCB2MiAwNi8xNF0gPT9VVEYt OD9xP0NvcnJlY3Q9MjBkb2N1bWVudGF0aW9uPTIwb2Y9MjA/PQorID0/VVRGLTg/cT89RTI9ODA9 OThta2Rpcj1FMj04MD05OT0yMHcuci50Lj0yMHRoZT0yMHVtYXNrLj89CitEYXRlOiBUdWUsIDE2 IE5vdiAyMDIxIDExOjA2OjI5ICswMDAwCitNZXNzYWdlLUlkOiA8MjAyMTExMTYxMTA2MzcuMTI1 NTc5LTctbWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KK0luLVJlcGx5LVRvOiA8MjAyMTExMTYxMTA2 MzcuMTI1NTc5LTEtbWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KK1JlZmVyZW5jZXM6IDwxNzVjM2E2 NTcyZTgzMmQ4NDkyNzkzN2IzMDlhMzA5NWNhZGY1NzAyLmNhbWVsQHRlbGVuZXQuYmU+CisgPDIw MjExMTE2MTEwNjM3LjEyNTU3OS0xLW1heGltZWRldm9zQHRlbGVuZXQuYmU+CitNSU1FLVZlcnNp b246IDEuMAorQ29udGVudC1UeXBlOiB0ZXh0L3BsYWluOyBjaGFyc2V0PVVURi04CitDb250ZW50 LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0CisKKyogZG9jL3JlZi9wb3NpeC50ZXhpIChta2Rpcik6 IE5vdGUgdGhhdCB0aGUgdW1hc2sgaXMgYXBwbGllZCBldmVuIGlmIHRoZQorICBtb2RlIGFyZ3Vt ZW50IGlzIHNldC4KKy0tLQorIGRvYy9yZWYvcG9zaXgudGV4aSB8IDMgKystCisgMSBmaWxlIGNo YW5nZWQsIDIgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQorCitkaWZmIC0tZ2l0IGEvZG9j L3JlZi9wb3NpeC50ZXhpIGIvZG9jL3JlZi9wb3NpeC50ZXhpCitpbmRleCBkMjYxYWM4ZGEuLjdm MTM2Mzc2YiAxMDA2NDQKKy0tLSBhL2RvYy9yZWYvcG9zaXgudGV4aQorKysrIGIvZG9jL3JlZi9w b3NpeC50ZXhpCitAQCAtOTAyLDcgKzkwMiw4IEBAIHRoZSBkaXJlY3RvcnkgcmVmZXJyZWQgdG8g YnkgdGhlIGZpbGUgcG9ydCBAdmFye2Rpcn0uCisgQ3JlYXRlIGEgbmV3IGRpcmVjdG9yeSBuYW1l ZCBieSBAdmFye3BhdGh9LiAgSWYgQHZhcnttb2RlfSBpcyBvbWl0dGVkCisgdGhlbiB0aGUgcGVy bWlzc2lvbnMgb2YgdGhlIGRpcmVjdG9yeSBhcmUgc2V0IHRvIEBjb2RleyNvNzc3fQorIG1hc2tl ZCB3aXRoIHRoZSBjdXJyZW50IHVtYXNrIChAcHhyZWZ7UHJvY2Vzc2VzLCBAY29kZXt1bWFza319 KS4KKy1PdGhlcndpc2UgdGhleSBhcmUgc2V0IHRvIHRoZSB2YWx1ZSBzcGVjaWZpZWQgd2l0aCBA dmFye21vZGV9LgorK090aGVyd2lzZSB0aGV5IGFyZSBzZXQgdG8gdGhlIHZhbHVlIHNwZWNpZmll ZCB3aXRoIEB2YXJ7bW9kZX0KKyttYXNrZWQgd2l0aCB0aGUgY3VycmVudCB1bWFzay4KKyBUaGUg cmV0dXJuIHZhbHVlIGlzIHVuc3BlY2lmaWVkLgorIEBlbmQgZGVmZm4KKyAKKy0tIAorMi4zMC4y CisKKwpkaWZmIC0tZ2l0IGEvZ251L3BhY2thZ2VzL3BhdGNoZXMvZ3VpbGUtb3BlbmF0LWFuZC1m cmllbmRzLTA3LnBhdGNoIGIvZ251L3BhY2thZ2VzL3BhdGNoZXMvZ3VpbGUtb3BlbmF0LWFuZC1m cmllbmRzLTA3LnBhdGNoCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAuLjAw YmNlMjIwNWEKLS0tIC9kZXYvbnVsbAorKysgYi9nbnUvcGFja2FnZXMvcGF0Y2hlcy9ndWlsZS1v cGVuYXQtYW5kLWZyaWVuZHMtMDcucGF0Y2gKQEAgLTAsMCArMSw0MCBAQAorR3VpeC1VcHN0cmVh bTogaHR0cHM6Ly9saXN0cy5nbnUub3JnL2FyY2hpdmUvaHRtbC9ndWlsZS1kZXZlbC8yMDIxLTEx L21zZzAwMDA1Lmh0bWwKK0Zyb206IE1heGltZSBEZXZvcyA8bWF4aW1lZGV2b3NAdGVsZW5ldC5i ZT4KK1N1YmplY3Q6IFtQQVRDSCB2MiAwNy8xNF0gRGVmaW5lIEFUX1JFTU9WRURJUiBhbmQgb3Ro ZXJzIHdoZW4gYXZhaWxhYmxlLgorRGF0ZTogVHVlLCAxNiBOb3YgMjAyMSAxMTowNjozMCArMDAw MAorTWVzc2FnZS1JZDogPDIwMjExMTE2MTEwNjM3LjEyNTU3OS04LW1heGltZWRldm9zQHRlbGVu ZXQuYmU+CitJbi1SZXBseS1UbzogPDIwMjExMTE2MTEwNjM3LjEyNTU3OS0xLW1heGltZWRldm9z QHRlbGVuZXQuYmU+CitSZWZlcmVuY2VzOiA8MTc1YzNhNjU3MmU4MzJkODQ5Mjc5MzdiMzA5YTMw OTVjYWRmNTcwMi5jYW1lbEB0ZWxlbmV0LmJlPgorIDwyMDIxMTExNjExMDYzNy4xMjU1NzktMS1t YXhpbWVkZXZvc0B0ZWxlbmV0LmJlPgorTUlNRS1WZXJzaW9uOiAxLjAKK0NvbnRlbnQtVHlwZTog dGV4dC9wbGFpbjsgY2hhcnNldD1VVEYtOAorQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogOGJp dAorCisqIGxpYmd1aWxlL3Bvc2l4LmMgKHNjbV9pbml0X3Bvc2l4KTogRGVmaW5lIChpbiBTY2hl bWUpCisgIEFUX1JFTU9WRURJUiBhbmQgQVRfRUFDQ0VTUyB3aGVuIGRlZmluZWQgKGluIEMpLgor LS0tCisgbGliZ3VpbGUvcG9zaXguYyB8IDYgKysrKysrCisgMSBmaWxlIGNoYW5nZWQsIDYgaW5z ZXJ0aW9ucygrKQorCitkaWZmIC0tZ2l0IGEvbGliZ3VpbGUvcG9zaXguYyBiL2xpYmd1aWxlL3Bv c2l4LmMKK2luZGV4IGJkN2Y0MGNhOC4uYTZmN2M5YTBkIDEwMDY0NAorLS0tIGEvbGliZ3VpbGUv cG9zaXguYworKysrIGIvbGliZ3VpbGUvcG9zaXguYworQEAgLTI1MDMsNiArMjUwMywxMiBAQCBz Y21faW5pdF9wb3NpeCAoKQorICNpZmRlZiBBVF9FTVBUWV9QQVRICisgICBzY21fY19kZWZpbmUg KCJBVF9FTVBUWV9QQVRIIiwgc2NtX2Zyb21faW50IChBVF9FTVBUWV9QQVRIKSk7CisgI2VuZGlm CisrI2lmZGVmIEFUX1JFTU9WRURJUgorKyAgc2NtX2NfZGVmaW5lICgiQVRfUkVNT1ZFRElSIiwg c2NtX2Zyb21faW50IChBVF9SRU1PVkVESVIpKTsKKysjZW5kaWYKKysjaWZkZWYgQVRfRUFDQ0VT UworKyAgc2NtX2NfZGVmaW5lICgiQVRfRUFDQ0VTUyIsIHNjbV9mcm9tX2ludCAoQVRfRUFDQ0VT UykpOworKyNlbmRpZgorIAorICNpbmNsdWRlICJjcHAtU0lHLmMiCisgI2luY2x1ZGUgInBvc2l4 LngiCistLSAKKzIuMzAuMgorCisKKwpkaWZmIC0tZ2l0IGEvZ251L3BhY2thZ2VzL3BhdGNoZXMv Z3VpbGUtb3BlbmF0LWFuZC1mcmllbmRzLTA4LnBhdGNoIGIvZ251L3BhY2thZ2VzL3BhdGNoZXMv Z3VpbGUtb3BlbmF0LWFuZC1mcmllbmRzLTA4LnBhdGNoCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAuLmU5MjJiMGFlYjUKLS0tIC9kZXYvbnVsbAorKysgYi9nbnUvcGFja2Fn ZXMvcGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMDgucGF0Y2gKQEAgLTAsMCArMSwy NDAgQEAKK0d1aXgtVXBzdHJlYW06IGh0dHBzOi8vbGlzdHMuZ251Lm9yZy9hcmNoaXZlL2h0bWwv Z3VpbGUtZGV2ZWwvMjAyMS0xMS9tc2cwMDAwNS5odG1sCitGcm9tOiBNYXhpbWUgRGV2b3MgPG1h eGltZWRldm9zQHRlbGVuZXQuYmU+CitTdWJqZWN0OiBbUEFUQ0ggdjIgMDgvMTRdID0/VVRGLTg/ cT9EZWZpbmU9MjBhPTIwU2NoZW1lPTIwYmluZGluZz0yMHRvPTIwPz0KKyA9P1VURi04P3E/PUUy PTgwPTk4cmVuYW1lYXQ9RTI9ODA9OTk9MjB3aGVuPTIwaXQ9MjBleGlzdHMuPz0KK0RhdGU6IFR1 ZSwgMTYgTm92IDIwMjEgMTE6MDY6MzEgKzAwMDAKK01lc3NhZ2UtSWQ6IDwyMDIxMTExNjExMDYz Ny4xMjU1NzktOS1tYXhpbWVkZXZvc0B0ZWxlbmV0LmJlPgorSW4tUmVwbHktVG86IDwyMDIxMTEx NjExMDYzNy4xMjU1NzktMS1tYXhpbWVkZXZvc0B0ZWxlbmV0LmJlPgorUmVmZXJlbmNlczogPDE3 NWMzYTY1NzJlODMyZDg0OTI3OTM3YjMwOWEzMDk1Y2FkZjU3MDIuY2FtZWxAdGVsZW5ldC5iZT4K KyA8MjAyMTExMTYxMTA2MzcuMTI1NTc5LTEtbWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KK01JTUUt VmVyc2lvbjogMS4wCitDb250ZW50LVR5cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9VVRGLTgKK0Nv bnRlbnQtVHJhbnNmZXItRW5jb2Rpbmc6IDhiaXQKKworKiBjb25maWd1cmUuYWM6IERldGVjdCBp ZiDigJhyZW5hbWVhdOKAmSBpcyBkZWZpbmVkLgorKiBsaWJndWlsZS9maWxlc3lzLmMgKHNjbV9y ZW5hbWVhdCk6IERlZmluZSBhIFNjaGVtZSBiaW5kaW5nCisgIHRvIHRoZSDigJhyZW5hbWVhdOKA mSBzeXN0ZW0gY2FsbC4KKyogZG9jL3JlZi9wb3NpeC50ZXhpIChGaWxlIFN5c3RlbSk6IERvY3Vt ZW50IGl0LgorKiBsaWJndWlsZS9maWxlc3lzLmggKHNjbV9yZW5hbWVhdCk6IE1ha2UgaXQgcGFy dCBvZiB0aGUgQyBBUEkuCisqIHRlc3Qtc3VpdGUvdGVzdHMvZmlsZXN5cy50ZXN0ICgicmVuYW1l LWZpbGUtYXQiKTogTmV3IHRlc3RzLgorLS0tCisgY29uZmlndXJlLmFjICAgICAgICAgICAgICAg ICAgfCAgIDIgKy0KKyBkb2MvcmVmL3Bvc2l4LnRleGkgICAgICAgICAgICB8ICAgOSArKysKKyBs aWJndWlsZS9maWxlc3lzLmMgICAgICAgICAgICB8ICAzNCArKysrKysrKysrKworIGxpYmd1aWxl L2ZpbGVzeXMuaCAgICAgICAgICAgIHwgICAxICsKKyB0ZXN0LXN1aXRlL3Rlc3RzL2ZpbGVzeXMu dGVzdCB8IDEwNCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCisgNSBmaWxlcyBj aGFuZ2VkLCAxNDkgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQorCitkaWZmIC0tZ2l0IGEv Y29uZmlndXJlLmFjIGIvY29uZmlndXJlLmFjCitpbmRleCBkYThkZmFkZDAuLmU2Nzg5MmZlYiAx MDA2NDQKKy0tLSBhL2NvbmZpZ3VyZS5hYworKysrIGIvY29uZmlndXJlLmFjCitAQCAtNDg1LDcg KzQ4NSw3IEBAIEFDX0NIRUNLX0hFQURFUlMoW2Fzc2VydC5oIGNydF9leHRlcm5zLmhdKQorICMK KyBBQ19DSEVDS19GVU5DUyhbRElORklOSVRZIERRTkFOIGNleHAgY2hzaXplIGNsb2cgY2xvZzEw IGN0ZXJtaWQgICAgICAgICBcCisgICBmZXNldHJvdW5kIGZ0aW1lIGZ0cnVuY2F0ZSBmY2hvd24g ZmNobW9kIGZjaGRpciByZWFkbGlua2F0CQlcCistICBzeW1saW5rYXQgbWtkaXJhdCBnZXRjd2Qg Z2V0ZXVpZCBnZXRzaWQJCQkJXAorKyAgc3ltbGlua2F0IG1rZGlyYXQgcmVuYW1lYXQgZ2V0Y3dk IGdldGV1aWQgZ2V0c2lkCQkJCVwKKyAgIGdldHRpbWVvZmRheSBnZXR1aWQgZ2V0Z2lkIGdtdGlt ZV9yIGlvY3RsIGxzdGF0IG1rZGlyIG1rZHRlbXAgbWtub2QgICBcCisgICBuaWNlIHJlYWRsaW5r IHJlbmFtZSBybWRpciBzZXRlZ2lkIHNldGV1aWQgICAgICAgICAgICAgICAgICAgICAgICAgICAg XAorICAgc2V0bG9jYWxlIHNldHVpZCBzZXRnaWQgc2V0cGdpZCBzZXRzaWQgc2lnYWN0aW9uIHNp Z2ludGVycnVwdCBzdGF0NjQgIFwKK2RpZmYgLS1naXQgYS9kb2MvcmVmL3Bvc2l4LnRleGkgYi9k b2MvcmVmL3Bvc2l4LnRleGkKK2luZGV4IDdmMTM2Mzc2Yi4uZWJiMDAxNTgxIDEwMDY0NAorLS0t IGEvZG9jL3JlZi9wb3NpeC50ZXhpCisrKysgYi9kb2MvcmVmL3Bvc2l4LnRleGkKK0BAIC04Nzcs NiArODc3LDE1IEBAIFJlbmFtZXMgdGhlIGZpbGUgc3BlY2lmaWVkIGJ5IEB2YXJ7b2xkbmFtZX0g dG8gQHZhcntuZXduYW1lfS4KKyBUaGUgcmV0dXJuIHZhbHVlIGlzIHVuc3BlY2lmaWVkLgorIEBl bmQgZGVmZm4KKyAKKytAZmluZGV4IHJlbmFtZWF0CisrQGRlZmZuIHtTY2hlbWUgUHJvY2VkdXJl fSByZW5hbWUtZmlsZS1hdCBvbGRkaXIgb2xkbmFtZSBuZXdkaXIgbmV3bmFtZQorK0BkZWZmbngg e0MgRnVuY3Rpb259IHNjbV9yZW5hbWVhdCAob2xkZGlyLCBvbGRuYW1lLCBuZXdkaXIsIG5ld25h bWUpCisrTGlrZSBAY29kZXtyZW5hbWUtZmlsZX0sIGJ1dCB3aGVuIEB2YXJ7b2xkZGlyfSBvciBA dmFye25ld2Rpcn0gaXMgdHJ1ZSwKKytyZXNvbHZlIEB2YXJ7b2xkbmFtZX0gb3IgQHZhcntuZXdu YW1lfSByZWxhdGl2ZSB0byB0aGUgZGlyZWN0b3J5Cisrc3BlY2lmaWVkIGJ5IHRoZSBmaWxlIHBv cnQgQHZhcntvbGRkaXJ9IG9yIEB2YXJ7bmV3ZGlyfSBpbnN0ZWFkIG9mIHRoZQorK2N1cnJlbnQg d29ya2luZyBkaXJlY3RvcnkuCisrQGVuZCBkZWZmbgorKworIEBkZWZmbiB7U2NoZW1lIFByb2Nl ZHVyZX0gbGluayBvbGRwYXRoIG5ld3BhdGgKKyBAZGVmZm54IHtDIEZ1bmN0aW9ufSBzY21fbGlu ayAob2xkcGF0aCwgbmV3cGF0aCkKKyBDcmVhdGVzIGEgbmV3IG5hbWUgQHZhcntuZXdwYXRofSBp biB0aGUgZmlsZSBzeXN0ZW0gZm9yIHRoZQorZGlmZiAtLWdpdCBhL2xpYmd1aWxlL2ZpbGVzeXMu YyBiL2xpYmd1aWxlL2ZpbGVzeXMuYworaW5kZXggZWUwMWIyZTJjLi45YzYzYmVhYTggMTAwNjQ0 CistLS0gYS9saWJndWlsZS9maWxlc3lzLmMKKysrKyBiL2xpYmd1aWxlL2ZpbGVzeXMuYworQEAg LTE0MjEsNiArMTQyMSw0MCBAQCBTQ01fREVGSU5FIChzY21fcmVuYW1lLCAicmVuYW1lLWZpbGUi LCAyLCAwLCAwLAorIH0KKyAjdW5kZWYgRlVOQ19OQU1FCisgCisrI2lmZGVmIEhBVkVfUkVOQU1F QVQKKytTQ01fREVGSU5FIChzY21fcmVuYW1lYXQsICJyZW5hbWUtZmlsZS1hdCIsIDQsIDAsIDAs CisrICAgICAgICAgICAgKFNDTSBvbGRkaXIsIFNDTSBvbGRuYW1lLCBTQ00gbmV3ZGlyLCBTQ00g bmV3bmFtZSksCisrICAgICAgICAgICAgIkxpa2UgQGNvZGV7cmVuYW1lLWZpbGV9LCBidXQgd2hl biBAdmFye29sZGRpcn0gb3IgQHZhcntuZXdkaXJ9XG4iCisrICAgICAgICAgICAgImlzIHRydWUs IHJlc29sdmUgQHZhcntvbGRuYW1lfSBvciBAdmFye25ld25hbWV9IHJlbGF0aXZlIHRvXG4iCisr ICAgICAgICAgICAgInRoZSBkaXJlY3Rvcnkgc3BlY2lmaWVkIGJ5IGZpbGUgcG9ydCBAdmFye29s ZGRpcn0gb3JcbiIKKysgICAgICAgICAgICAiQHZhcntuZXdkaXJ9IGluc3RlYWQgb2YgdGhlIGN1 cnJlbnQgd29ya2luZyBkaXJlY3RvcnkuIikKKysjZGVmaW5lIEZVTkNfTkFNRSBzX3NjbV9yZW5h bWVhdAorK3sKKysgIGludCBydjsKKysgIGludCBvbGRfZmRlcywgbmV3X2ZkZXM7CisrCisrICBv bGRfZmRlcyA9IEFUX0ZEQ1dEOworKyAgbmV3X2ZkZXMgPSBBVF9GRENXRDsKKysKKysgIGlmIChz Y21faXNfdHJ1ZSAob2xkZGlyKSkgeworKyAgICBTQ01fVkFMSURBVEVfT1BGUE9SVCAoU0NNX0FS RzEsIG9sZGRpcik7CisrICAgIG9sZF9mZGVzID0gU0NNX0ZQT1JUX0ZERVMgKG9sZGRpcik7Cisr ICB9CisrICBpZiAoc2NtX2lzX3RydWUgKG5ld2RpcikpIHsKKysgICAgU0NNX1ZBTElEQVRFX09Q RlBPUlQgKFNDTV9BUkczLCBuZXdkaXIpOworKyAgICBuZXdfZmRlcyA9IFNDTV9GUE9SVF9GREVT IChuZXdkaXIpOworKyAgfQorKworKyAgU1RSSU5HMl9TWVNDQUxMIChvbGRuYW1lLCBjX29sZG5h bWUsCisrCQkgICBuZXduYW1lLCBjX25ld25hbWUsCisrCQkgICBydiA9IHJlbmFtZWF0IChvbGRf ZmRlcywgY19vbGRuYW1lLCBuZXdfZmRlcywgY19uZXduYW1lKSk7CisrICBzY21fcmVtZW1iZXJf dXB0b19oZXJlXzIgKG9sZGRpciwgbmV3ZGlyKTsKKysgIGlmIChydiAhPSAwKQorKyAgICBTQ01f U1lTRVJST1I7CisrICByZXR1cm4gU0NNX1VOU1BFQ0lGSUVEOworK30KKysjdW5kZWYgRlVOQ19O QU1FCisrI2VuZGlmCisgCisgU0NNX0RFRklORSAoc2NtX2RlbGV0ZV9maWxlLCAiZGVsZXRlLWZp bGUiLCAxLCAwLCAwLCAKKyAgICAgICAgICAgIChTQ00gc3RyKSwKK2RpZmYgLS1naXQgYS9saWJn dWlsZS9maWxlc3lzLmggYi9saWJndWlsZS9maWxlc3lzLmgKK2luZGV4IGYwZGQzNWVkZS4uN2Ux N2NjNTg1IDEwMDY0NAorLS0tIGEvbGliZ3VpbGUvZmlsZXN5cy5oCisrKysgYi9saWJndWlsZS9m aWxlc3lzLmgKK0BAIC00OCw2ICs0OCw3IEBAIFNDTV9BUEkgU0NNIHNjbV9jbG9zZV9mZGVzIChT Q00gZmQpOworIFNDTV9BUEkgU0NNIHNjbV9zdGF0IChTQ00gb2JqZWN0LCBTQ00gZXhjZXB0aW9u X29uX2Vycm9yKTsKKyBTQ01fQVBJIFNDTSBzY21fbGluayAoU0NNIG9sZHBhdGgsIFNDTSBuZXdw YXRoKTsKKyBTQ01fQVBJIFNDTSBzY21fcmVuYW1lIChTQ00gb2xkbmFtZSwgU0NNIG5ld25hbWUp OworK1NDTV9BUEkgU0NNIHNjbV9yZW5hbWVhdCAoU0NNIG9sZGRpciwgU0NNIG9sZG5hbWUsIFND TSBuZXdkaXIsIFNDTSBuZXduYW1lKTsKKyBTQ01fQVBJIFNDTSBzY21fZGVsZXRlX2ZpbGUgKFND TSBzdHIpOworIFNDTV9BUEkgU0NNIHNjbV9ta2RpciAoU0NNIHBhdGgsIFNDTSBtb2RlKTsKKyBT Q01fQVBJIFNDTSBzY21fbWtkaXJhdCAoU0NNIGRpciwgU0NNIHBhdGgsIFNDTSBtb2RlKTsKK2Rp ZmYgLS1naXQgYS90ZXN0LXN1aXRlL3Rlc3RzL2ZpbGVzeXMudGVzdCBiL3Rlc3Qtc3VpdGUvdGVz dHMvZmlsZXN5cy50ZXN0CitpbmRleCA0ZWE2MmQ1MTMuLmJiY2UyYzg1OCAxMDA2NDQKKy0tLSBh L3Rlc3Qtc3VpdGUvdGVzdHMvZmlsZXN5cy50ZXN0CisrKysgYi90ZXN0LXN1aXRlL3Rlc3RzL2Zp bGVzeXMudGVzdAorQEAgLTMxLDYgKzMxLDggQEAKKyAgIChkYXRhLWZpbGUtbmFtZSAiZmlsZXN5 cy10ZXN0LWxpbmsudG1wIikpCisgKGRlZmluZSAodGVzdC1kaXJlY3RvcnkpCisgICAoZGF0YS1m aWxlLW5hbWUgImZpbGVzeXMtdGVzdC1kaXIudG1wIikpCisrKGRlZmluZSAodGVzdC1kaXJlY3Rv cnkyKQorKyAgKGRhdGEtZmlsZS1uYW1lICJmaWxlc3lzLXRlc3QtZGlyMi50bXAiKSkKKyAKKyAK KyA7OzsKK0BAIC00MzIsMyArNDM0LDEwNSBAQAorICAgICAgICAobWtkaXJhdCBwb3J0ICh0ZXN0 LWRpcmVjdG9yeSkpCisgICAgICAgIChzdGF0OnBlcm1zIChzdGF0ICh0ZXN0LWRpcmVjdG9yeSkp KSkpKQorICAgKG1heWJlLWRlbGV0ZS1kaXJlY3RvcnkpKQorKworKyh3aXRoLXRlc3QtcHJlZml4 ICJyZW5hbWUtZmlsZS1hdCIKKysgIChkZWZpbmUgKHNraXAtaWYtdW5zdXBwb3J0ZWQpCisrICAg ICh1bmxlc3MgKGRlZmluZWQ/ICdyZW5hbWUtZmlsZS1hdCkKKysgICAgICAodGhyb3cgJ3Vuc3Vw cG9ydGVkKSkpCisrICAocGFzcy1pZi1lcXVhbCAiY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSIg JygjZiAiaGVsbG8iKQorKyAgICAoc2tpcC1pZi11bnN1cHBvcnRlZCkKKysgICAgOzsgQ3JlYXRl IGEgZmlsZSBpbiB0aGUgdGVzdCBkaXJlY3RvcnkKKysgICAgKGNhbGwtd2l0aC1vdXRwdXQtZmls ZSAiZmlsZXN5cy10ZXN0LWEudG1wIgorKyAgICAgIChsYW1iZGEgKHBvcnQpIChkaXNwbGF5ICJo ZWxsbyIgcG9ydCkpKQorKyAgICA7OyBUcnkgdG8gcmVuYW1lIGl0CisrICAgIChyZW5hbWUtZmls ZS1hdCAjZiAiZmlsZXN5cy10ZXN0LWEudG1wIiAjZiAiZmlsZXN5cy10ZXN0LWIudG1wIikKKysg ICAgOzsgVmVyaWZ5IGl0IGV4aXN0cyB1bmRlciB0aGUgbmV3IG5hbWUsIGFuZCBub3QgdW5kZXIg dGhlIG9sZCBuYW1lCisrICAgIChsaXN0IChmaWxlLWV4aXN0cz8gImZpbGVzeXMtdGVzdC1hLnRt cCIpCisrICAgICAgICAgIChjYWxsLXdpdGgtaW5wdXQtZmlsZSAiZmlsZXN5cy10ZXN0LWIudG1w IiBnZXQtc3RyaW5nLWFsbCkpKQorKworKyAgKGZhbHNlLWlmLWV4Y2VwdGlvbiAoZGVsZXRlLWZp bGUgImZpbGVzeXMtdGVzdC1hLnRtcCIpKQorKyAgKGZhbHNlLWlmLWV4Y2VwdGlvbiAoZGVsZXRl LWZpbGUgImZpbGVzeXMtdGVzdC1iLnRtcCIpKQorKworKyAgKHBhc3MtaWYtZXF1YWwgInR3byBw b3J0cyIgJygjZiAiaGVsbG8iKQorKyAgICAoc2tpcC1pZi11bnN1cHBvcnRlZCkKKysgICAgKG1r ZGlyICh0ZXN0LWRpcmVjdG9yeSkpCisrICAgIChta2RpciAodGVzdC1kaXJlY3RvcnkyKSkKKysg ICAgOzsgQ3JlYXRlIGEgZmlsZSBpbiB0aGUgZmlyc3QgZGlyZWN0b3J5CisrICAgIChjYWxsLXdp dGgtb3V0cHV0LWZpbGUgKGluLXZpY2luaXR5ICh0ZXN0LWRpcmVjdG9yeSkgImEiKQorKyAgICAg IChsYW1iZGEgKHBvcnQpIChkaXNwbGF5ICJoZWxsbyIgcG9ydCkpKQorKyAgICAobGV0ICgocG9y dDEgKG9wZW4gKHRlc3QtZGlyZWN0b3J5KSBPX1JET05MWSkpCisrICAgICAgICAgIChwb3J0MiAo b3BlbiAodGVzdC1kaXJlY3RvcnkyKSBPX1JET05MWSkpKQorKyAgICAgIDs7IFRyeSB0byByZW5h bWUgaXQKKysgICAgICAocmVuYW1lLWZpbGUtYXQgcG9ydDEgImEiIHBvcnQyICJiIikKKysgICAg ICAoY2xvc2UtcG9ydCBwb3J0MSkKKysgICAgICAoY2xvc2UtcG9ydCBwb3J0MikKKysgICAgICA7 OyBWZXJpZnkgaXQgZXhpc3RzIHVuZGVyIHRoZSBuZXcgbmFtZSwgYW5kIG5vdCB1bmRlciB0aGUg b2xkIG5hbWUKKysgICAgICAobGlzdCAoZmlsZS1leGlzdHM/IChpbi12aWNpbml0eSAodGVzdC1k aXJlY3RvcnkpICJhIikpCisrICAgICAgICAgICAgKGNhbGwtd2l0aC1pbnB1dC1maWxlIChpbi12 aWNpbml0eSAodGVzdC1kaXJlY3RvcnkyKSAiYiIpCisrICAgICAgICAgICAgICBnZXQtc3RyaW5n LWFsbCkpKSkKKysgIChmYWxzZS1pZi1leGNlcHRpb24gKGRlbGV0ZS1maWxlIChpbi12aWNpbml0 eSAodGVzdC1kaXJlY3RvcnkpICJhIikpKQorKyAgKGZhbHNlLWlmLWV4Y2VwdGlvbiAoZGVsZXRl LWZpbGUgKGluLXZpY2luaXR5ICh0ZXN0LWRpcmVjdG9yeTIpICJiIikpKQorKyAgKGZhbHNlLWlm LWV4Y2VwdGlvbiAocm1kaXIgKHRlc3QtZGlyZWN0b3J5KSkpCisrICAoZmFsc2UtaWYtZXhjZXB0 aW9uIChybWRpciAodGVzdC1kaXJlY3RvcnkyKSkpCisrCisrICAocGFzcy1pZi1lcXVhbCAicG9y dCBhbmQgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSIgJygjZiAiaGVsbG8iKQorKyAgICAoc2tp cC1pZi11bnN1cHBvcnRlZCkKKysgICAgKG1rZGlyICh0ZXN0LWRpcmVjdG9yeSkpCisrICAgIDs7 IENyZWF0ZSBhIGZpbGUgaW4gKHRlc3QtZGlyZWN0b3J5KQorKyAgICAoY2FsbC13aXRoLW91dHB1 dC1maWxlIChpbi12aWNpbml0eSAodGVzdC1kaXJlY3RvcnkpICJhIikKKysgICAgICAobGFtYmRh IChwb3J0KSAoZGlzcGxheSAiaGVsbG8iIHBvcnQpKSkKKysgICAgKGxldCAoKHBvcnQgKG9wZW4g KHRlc3QtZGlyZWN0b3J5KSBPX1JET05MWSkpKQorKyAgICAgIDs7IFRyeSB0byByZW5hbWUgaXQK KysgICAgICAocmVuYW1lLWZpbGUtYXQgcG9ydCAiYSIgI2YgKGJhc2VuYW1lICh0ZXN0LWZpbGUp KSkKKysgICAgICAoY2xvc2UtcG9ydCBwb3J0KQorKyAgICAgIDs7IFZlcmlmeSBpdCBleGlzdHMg dW5kZXIgdGhlIG5ldyBuYW1lLCBhbmQgbm90IHVuZGVyIHRoZSBvbGQgbmFtZS4KKysgICAgICAo bGlzdCAoZmlsZS1leGlzdHM/IChpbi12aWNpbml0eSAodGVzdC1kaXJlY3RvcnkpICJhIikpCisr ICAgICAgICAgICAgKGNhbGwtd2l0aC1pbnB1dC1maWxlICh0ZXN0LWZpbGUpIGdldC1zdHJpbmct YWxsKSkpKQorKyAgKGZhbHNlLWlmLWV4Y2VwdGlvbiAoZGVsZXRlLWZpbGUgKGluLXZpY2luaXR5 ICh0ZXN0LWRpcmVjdG9yeSkgImEiKSkpCisrICAoZmFsc2UtaWYtZXhjZXB0aW9uIChybWRpciAo dGVzdC1kaXJlY3RvcnkpKSkKKysgIChmYWxzZS1pZi1leGNlcHRpb24gKGRlbGV0ZS1maWxlICh0 ZXN0LWZpbGUpKSkKKysKKysgIChwYXNzLWlmLWVxdWFsICJjdXJyZW50IHdvcmtpbmcgZGlyZWN0 b3J5IGFuZCBwb3J0IiAnKCNmICJoZWxsbyIpCisrICAgIChza2lwLWlmLXVuc3VwcG9ydGVkKQor KyAgICAobWtkaXIgKHRlc3QtZGlyZWN0b3J5KSkKKysgICAgOzsgQ3JlYXRlIGEgZmlsZSBpbiB0 aGUgd29ya2luZyBkaXJlY3RvcnkKKysgICAgKGNhbGwtd2l0aC1vdXRwdXQtZmlsZSAodGVzdC1m aWxlKQorKyAgICAgIChsYW1iZGEgKHBvcnQpIChkaXNwbGF5ICJoZWxsbyIgcG9ydCkpKQorKyAg ICAobGV0ICgocG9ydCAob3BlbiAodGVzdC1kaXJlY3RvcnkpIE9fUkRPTkxZKSkpCisrICAgICAg OzsgVHJ5IHRvIHJlbmFtZSBpdAorKyAgICAgIChyZW5hbWUtZmlsZS1hdCAjZiAoYmFzZW5hbWUg KHRlc3QtZmlsZSkpIHBvcnQgImIiKQorKyAgICAgIChjbG9zZS1wb3J0IHBvcnQpCisrICAgICAg OzsgVmVyaWZ5IGl0IGV4aXN0cyB1bmRlciB0aGUgbmV3IG5hbWUsIGFuZCBub3QgdW5kZXIgdGhl IG9sZCBuYW1lLgorKyAgICAgIChsaXN0IChmaWxlLWV4aXN0cz8gKHRlc3QtZmlsZSkpCisrICAg ICAgICAgICAgKGNhbGwtd2l0aC1pbnB1dC1maWxlIChpbi12aWNpbml0eSAodGVzdC1kaXJlY3Rv cnkpICJiIikKKysgICAgICAgICAgICAgIGdldC1zdHJpbmctYWxsKSkpKQorKworKyAgKGZhbHNl LWlmLWV4Y2VwdGlvbiAoZGVsZXRlLWZpbGUgKGluLXZpY2luaXR5ICh0ZXN0LWRpcmVjdG9yeSkg ImIiKSkpCisrICAoZmFsc2UtaWYtZXhjZXB0aW9uIChkZWxldGUtZmlsZSAodGVzdC1maWxlKSkp CisrICAoZmFsc2UtaWYtZXhjZXB0aW9uIChybWRpciAodGVzdC1kaXJlY3RvcnkpKSkKKysKKysg IChwYXNzLWlmLWV4Y2VwdGlvbiAibm90IGEgZmlsZSBwb3J0ICgxKSIgZXhjZXB0aW9uOndyb25n LXR5cGUtYXJnCisrICAgIChza2lwLWlmLXVuc3VwcG9ydGVkKQorKyAgICAocmVuYW1lLWZpbGUt YXQgKG9wZW4taW5wdXQtc3RyaW5nICIiKSAic29tZSIgI2YgInRoaW5nIikpCisrCisrICAocGFz cy1pZi1leGNlcHRpb24gIm5vdCBhIGZpbGUgcG9ydCAoMikiIGV4Y2VwdGlvbjp3cm9uZy10eXBl LWFyZworKyAgICAoc2tpcC1pZi11bnN1cHBvcnRlZCkKKysgICAgKHJlbmFtZS1maWxlLWF0ICNm ICJzb21lIiAob3Blbi1pbnB1dC1zdHJpbmcgIiIpICJ0aGluZyIpKQorKworKyAgKHBhc3MtaWYt ZXhjZXB0aW9uICJjbG9zZWQgcG9ydCAoMSkiIGV4Y2VwdGlvbjp3cm9uZy10eXBlLWFyZworKyAg ICAoc2tpcC1pZi11bnN1cHBvcnRlZCkKKysgICAgKHJlbmFtZS1maWxlLWF0IChjYWxsLXdpdGgt cG9ydCAob3BlbiAiLiIgT19SRE9OTFkpIGlkZW50aXR5KQorKyAgICAgICAgICAgICAgICAgICAg InNvbWUiICNmICJ0aGluZyIpKQorKworKyAgKHBhc3MtaWYtZXhjZXB0aW9uICJjbG9zZWQgcG9y dCAoMikiIGV4Y2VwdGlvbjp3cm9uZy10eXBlLWFyZworKyAgICAoc2tpcC1pZi11bnN1cHBvcnRl ZCkKKysgICAgKHJlbmFtZS1maWxlLWF0ICNmICJzb21lIiAoY2FsbC13aXRoLXBvcnQgKG9wZW4g Ii4iIE9fUkRPTkxZKSBpZGVudGl0eSkKKysgICAgICAgICAgICAgICAgICAgICJ0aGluZyIpKQor KworKyAgKHBhc3MtaWYtZXhjZXB0aW9uICJub3QgYSBzdHJpbmcgKDEpIiBleGNlcHRpb246d3Jv bmctdHlwZS1hcmcKKysgICAgKHNraXAtaWYtdW5zdXBwb3J0ZWQpCisrICAgIChyZW5hbWUtZmls ZS1hdCAjZiAnd2hhdCAjZiAidGhpbmciKSkKKysKKysgIChwYXNzLWlmLWV4Y2VwdGlvbiAibm90 IGEgc3RyaW5nICgyKSIgZXhjZXB0aW9uOndyb25nLXR5cGUtYXJnCisrICAgIChza2lwLWlmLXVu c3VwcG9ydGVkKQorKyAgICAocmVuYW1lLWZpbGUtYXQgI2YgInNvbWUiICNmICd3aGF0KSkpCist LSAKKzIuMzAuMgorCisKZGlmZiAtLWdpdCBhL2dudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9w ZW5hdC1hbmQtZnJpZW5kcy0wOS5wYXRjaCBiL2dudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9w ZW5hdC1hbmQtZnJpZW5kcy0wOS5wYXRjaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwLi45NzYyYWM1NmM0Ci0tLSAvZGV2L251bGwKKysrIGIvZ251L3BhY2thZ2VzL3BhdGNo ZXMvZ3VpbGUtb3BlbmF0LWFuZC1mcmllbmRzLTA5LnBhdGNoCkBAIC0wLDAgKzEsMTczIEBACitH dWl4LVVwc3RyZWFtOiBodHRwczovL2xpc3RzLmdudS5vcmcvYXJjaGl2ZS9odG1sL2d1aWxlLWRl dmVsLzIwMjEtMTEvbXNnMDAwMDUuaHRtbAorRnJvbTogTWF4aW1lIERldm9zIDxtYXhpbWVkZXZv c0B0ZWxlbmV0LmJlPgorU3ViamVjdDogW1BBVENIIHYyIDA5LzE0XSA9P1VURi04P3E/RGVmaW5l PTIwYT0yMFNjaGVtZT0yMGJpbmRpbmc9MjB0bz0yMD89CisgPT9VVEYtOD9xPz1FMj04MD05OGZj aG1vZGF0PUUyPTgwPTk5PTIwd2hlbj0yMGl0PTIwZXhpc3RzLj89CitEYXRlOiBUdWUsIDE2IE5v diAyMDIxIDExOjA2OjMyICswMDAwCitNZXNzYWdlLUlkOiA8MjAyMTExMTYxMTA2MzcuMTI1NTc5 LTEwLW1heGltZWRldm9zQHRlbGVuZXQuYmU+CitJbi1SZXBseS1UbzogPDIwMjExMTE2MTEwNjM3 LjEyNTU3OS0xLW1heGltZWRldm9zQHRlbGVuZXQuYmU+CitSZWZlcmVuY2VzOiA8MTc1YzNhNjU3 MmU4MzJkODQ5Mjc5MzdiMzA5YTMwOTVjYWRmNTcwMi5jYW1lbEB0ZWxlbmV0LmJlPgorIDwyMDIx MTExNjExMDYzNy4xMjU1NzktMS1tYXhpbWVkZXZvc0B0ZWxlbmV0LmJlPgorTUlNRS1WZXJzaW9u OiAxLjAKK0NvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD1VVEYtOAorQ29udGVudC1U cmFuc2Zlci1FbmNvZGluZzogOGJpdAorCisqIGNvbmZpZ3VyZS5hYzogRGV0ZWN0IGV4aXN0ZW5j ZSBvZiBmY2htb2RhdC4KKyogbGliZ3VpbGUvZmlsZXN5cy5jIChzY21fY2htb2RhdCk6IE5ldyBw cm9jZWR1cmUuCisqIGxpYmd1aWxlL2ZpbGVzeXMuaCAoc2NtX2NobW9kYXQpOiBNYWtlIGl0IHBh cnQgb2YgdGhlIEFQSS4KKyogdGVzdC1zdWl0ZS90ZXN0cy9maWxlc3lzLnRlc3QgKCJjaG1vZGF0 Iik6IFRlc3QgaXQuCistLS0KKyBjb25maWd1cmUuYWMgICAgICAgICAgICAgICAgICB8ICA0ICst LQorIGxpYmd1aWxlL2ZpbGVzeXMuYyAgICAgICAgICAgIHwgMzYgKysrKysrKysrKysrKysrKysr KysrKysrCisgbGliZ3VpbGUvZmlsZXN5cy5oICAgICAgICAgICAgfCAgMSArCisgdGVzdC1zdWl0 ZS90ZXN0cy9maWxlc3lzLnRlc3QgfCA1MyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKworIDQgZmlsZXMgY2hhbmdlZCwgOTIgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkK KworZGlmZiAtLWdpdCBhL2NvbmZpZ3VyZS5hYyBiL2NvbmZpZ3VyZS5hYworaW5kZXggZTY3ODky ZmViLi4yYTU0ODU5OTAgMTAwNjQ0CistLS0gYS9jb25maWd1cmUuYWMKKysrKyBiL2NvbmZpZ3Vy ZS5hYworQEAgLTQ3Nyw3ICs0NzcsNyBAQCBBQ19DSEVDS19IRUFERVJTKFthc3NlcnQuaCBjcnRf ZXh0ZXJucy5oXSkKKyAjICAgdHJ1bmNhdGUgLSBub3QgaW4gbWluZ3cKKyAjICAgaXNibGFuayAt IGF2YWlsYWJsZSBhcyBhIEdOVSBleHRlbnNpb24gb3IgaW4gQzk5CisgIyAgIF9OU0dldEVudmly b24gLSBEYXJ3aW4gc3BlY2lmaWMKKy0jICAgc3RyY29sbF9sLCBuZXdsb2NhbGUsIHVzZWxvY2Fs ZSwgdXRpbWVuc2F0LCBmdXRpbWVucyAtIFBPU0lYLjEtMjAwOAorKyMgICBzdHJjb2xsX2wsIG5l d2xvY2FsZSwgdXNlbG9jYWxlLCB1dGltZW5zYXQsIGZ1dGltZW5zLCBmY2htb2RhdCAtIFBPU0lY LjEtMjAwOAorICMgICBzdHJ0b2xfbCAtIG5vbi1QT1NJWCwgZm91bmQgaW4gZ2xpYmMKKyAjICAg Zm9yayAtIHVuYXZhaWxhYmxlIG9uIFdpbmRvd3MKKyAjICAgc2NoZWRfZ2V0YWZmaW5pdHksIHNj aGVkX3NldGFmZmluaXR5IC0gR05VIGV4dGVuc2lvbnMgKGdsaWJjKQorQEAgLTQ4NSw3ICs0ODUs NyBAQCBBQ19DSEVDS19IRUFERVJTKFthc3NlcnQuaCBjcnRfZXh0ZXJucy5oXSkKKyAjCisgQUNf Q0hFQ0tfRlVOQ1MoW0RJTkZJTklUWSBEUU5BTiBjZXhwIGNoc2l6ZSBjbG9nIGNsb2cxMCBjdGVy bWlkICAgICAgICAgXAorICAgZmVzZXRyb3VuZCBmdGltZSBmdHJ1bmNhdGUgZmNob3duIGZjaG1v ZCBmY2hkaXIgcmVhZGxpbmthdAkJXAorLSAgc3ltbGlua2F0IG1rZGlyYXQgcmVuYW1lYXQgZ2V0 Y3dkIGdldGV1aWQgZ2V0c2lkCQkJCVwKKysgIGZjaG1vZGF0IHN5bWxpbmthdCBta2RpcmF0IHJl bmFtZWF0IGdldGN3ZCBnZXRldWlkIGdldHNpZAkJXAorICAgZ2V0dGltZW9mZGF5IGdldHVpZCBn ZXRnaWQgZ210aW1lX3IgaW9jdGwgbHN0YXQgbWtkaXIgbWtkdGVtcCBta25vZCAgIFwKKyAgIG5p Y2UgcmVhZGxpbmsgcmVuYW1lIHJtZGlyIHNldGVnaWQgc2V0ZXVpZCAgICAgICAgICAgICAgICAg ICAgICAgICAgICBcCisgICBzZXRsb2NhbGUgc2V0dWlkIHNldGdpZCBzZXRwZ2lkIHNldHNpZCBz aWdhY3Rpb24gc2lnaW50ZXJydXB0IHN0YXQ2NCAgXAorZGlmZiAtLWdpdCBhL2xpYmd1aWxlL2Zp bGVzeXMuYyBiL2xpYmd1aWxlL2ZpbGVzeXMuYworaW5kZXggOWM2M2JlYWE4Li40ZGQ5YzdiNDgg MTAwNjQ0CistLS0gYS9saWJndWlsZS9maWxlc3lzLmMKKysrKyBiL2xpYmd1aWxlL2ZpbGVzeXMu YworQEAgLTE1NjEsNiArMTU2MSw0MiBAQCBTQ01fREVGSU5FIChzY21fY2htb2QsICJjaG1vZCIs IDIsIDAsIDAsCisgfQorICN1bmRlZiBGVU5DX05BTUUKKyAKKysjaWZkZWYgSEFWRV9GQ0hNT0RB VAorK1NDTV9ERUZJTkUgKHNjbV9jaG1vZGF0LCAiY2htb2RhdCIsIDMsIDEsIDAsCisrICAgICAg ICAgICAoU0NNIGRpciwgU0NNIHBhdGhuYW1lLCBTQ00gbW9kZSwgU0NNIGZsYWdzKSwKKysgICAg ICAgICAgICAiTGlrZSBAdmFye2NobW9kfSwgYnV0IG1vZGlmeSB0aGUgcGVybWlzc2lvbnMgb2Yg dGhlIGZpbGUgbmFtZWRcbiIKKysgICAgICAgICAgICAiQHZhcntwYXRobmFtZX0gaW4gdGhlIGRp cmVjdG9yeSByZWZlcnJlZCB0byBieSB0aGUgZmlsZSBwb3J0XG4iCisrICAgICAgICAgICAgIkB2 YXJ7ZGlyfSBpbnN0ZWFkLlxuIgorKyAgICAgICAgICAgICJUaGUgb3B0aW9uYWwgQHZhcntmbGFn c30gYXJndW1lbnQgbWF5IGJlIDAgb3IgQGNvZGV7QVRfU1lNTElOS19OT0ZPTExPV30sXG4iCisr ICAgICAgICAgICAgImluIHdoaWNoIGNhc2UgQHZhcntwYXRobmFtZX0gaXMgbm90IGRlcmVmZXJl bmNlZCBpZiBpdCBpcyBhIHN5bWJvbGljIGxpbmssXG4iCisrICAgICAgICAgICAgImkuZS4sIHRo ZSBwZXJtaXNzaW9ucyBvZiB0aGUgc3ltYm9saWMgbGluayBpdHNlbGYgYXJlIG1vZGlmaWVkLlxu XG4iCisrICAgICAgICAgICAgIk5vdGUgdGhhdCBAY29kZXtBVF9TWU1MSU5LX05PRk9MTE9XfSBp cyBub3Qgc3VwcG9ydGVkIG9uIGFsbCBzeXN0ZW1zXG4iCisrICAgICAgICAgICAgImFuZCBtYXkg cmVzdWx0IGluIEBjb2Rle0VOT1RTVVB9LiIpCisrI2RlZmluZSBGVU5DX05BTUUgc19zY21fY2ht b2RhdAorK3sKKysgIGludCBydjsKKysgIGludCBjX2ZsYWdzOworKyAgaW50IGRpcl9mZGVzOwor KworKyAgaWYgKFNDTV9VTkJORFAgKGZsYWdzKSkKKysgICAgY19mbGFncyA9IDA7CisrICBlbHNl CisrICAgIGNfZmxhZ3MgPSBzY21fdG9faW50IChmbGFncyk7CisrCisrICBTQ01fVkFMSURBVEVf T1BGUE9SVCAoU0NNX0FSRzEsIGRpcik7CisrICBkaXJfZmRlcyA9IFNDTV9GUE9SVF9GREVTIChk aXIpOworKworKyAgU1RSSU5HX1NZU0NBTEwgKHBhdGhuYW1lLCBjX3BhdGhuYW1lLAorKyAgICAg ICAgICAgICAgICAgIHJ2ID0gZmNobW9kYXQgKGRpcl9mZGVzLCBjX3BhdGhuYW1lLAorKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNjbV90b19pbnQgKG1vZGUpLCBjX2ZsYWdzKSk7 CisrICBzY21fcmVtZW1iZXJfdXB0b19oZXJlXzEgKGRpcik7CisrICBpZiAocnYgPT0gLTEpCisr ICAgIFNDTV9TWVNFUlJPUjsKKysgIHJldHVybiBTQ01fVU5TUEVDSUZJRUQ7CisrfQorKyN1bmRl ZiBGVU5DX05BTUUKKysjZW5kaWYKKysKKyBTQ01fREVGSU5FIChzY21fdW1hc2ssICJ1bWFzayIs IDAsIDEsIDAsIAorICAgICAgICAgICAgIChTQ00gbW9kZSksCisgCSAgICAiSWYgQHZhcnttb2Rl fSBpcyBvbWl0dGVkLCByZXR1cm5zIGEgZGVjaW1hbCBudW1iZXIgcmVwcmVzZW50aW5nIHRoZSBj dXJyZW50XG4iCitkaWZmIC0tZ2l0IGEvbGliZ3VpbGUvZmlsZXN5cy5oIGIvbGliZ3VpbGUvZmls ZXN5cy5oCitpbmRleCA3ZTE3Y2M1ODUuLjM3N2EzNzk1ZSAxMDA2NDQKKy0tLSBhL2xpYmd1aWxl L2ZpbGVzeXMuaAorKysrIGIvbGliZ3VpbGUvZmlsZXN5cy5oCitAQCAtNDAsNiArNDAsNyBAQCBT Q01fQVBJIHNjbV90X2JpdHMgc2NtX3RjMTZfZGlyOworIAorIFNDTV9BUEkgU0NNIHNjbV9jaG93 biAoU0NNIG9iamVjdCwgU0NNIG93bmVyLCBTQ00gZ3JvdXApOworIFNDTV9BUEkgU0NNIHNjbV9j aG1vZCAoU0NNIG9iamVjdCwgU0NNIG1vZGUpOworK1NDTV9BUEkgU0NNIHNjbV9jaG1vZGF0IChT Q00gZGlyLCBTQ00gcGF0aG5hbWUsIFNDTSBtb2RlLCBTQ00gZmxhZ3MpOworIFNDTV9BUEkgU0NN IHNjbV91bWFzayAoU0NNIG1vZGUpOworIFNDTV9BUEkgU0NNIHNjbV9vcGVuX2ZkZXMgKFNDTSBw YXRoLCBTQ00gZmxhZ3MsIFNDTSBtb2RlKTsKKyBTQ01fQVBJIFNDTSBzY21fb3BlbiAoU0NNIHBh dGgsIFNDTSBmbGFncywgU0NNIG1vZGUpOworZGlmZiAtLWdpdCBhL3Rlc3Qtc3VpdGUvdGVzdHMv ZmlsZXN5cy50ZXN0IGIvdGVzdC1zdWl0ZS90ZXN0cy9maWxlc3lzLnRlc3QKK2luZGV4IGJiY2Uy Yzg1OC4uMjA0ZjM0MTRjIDEwMDY0NAorLS0tIGEvdGVzdC1zdWl0ZS90ZXN0cy9maWxlc3lzLnRl c3QKKysrKyBiL3Rlc3Qtc3VpdGUvdGVzdHMvZmlsZXN5cy50ZXN0CitAQCAtMjcxLDYgKzI3MSw1 OSBAQAorICAgICAgICAgICAgIChmYWxzZS1pZi1leGNlcHRpb24gKHJtZGlyIG5hbWUpKQorICAg ICAgICAgICAgIHJlc3VsdCkpKSkpCisgCisrOzs7CisrOzs7IGNobW9kYXQKKys7OzsKKysKKyso d2l0aC10ZXN0LXByZWZpeCAiY2htb2RhdCIKKysgIChjYWxsLXdpdGgtb3V0cHV0LWZpbGUgKHRl c3QtZmlsZSkgKGNvbnN0ICNmKSkKKysgIChjaG1vZCAodGVzdC1maWxlKSAjbzAwMCkKKysKKysg IChwYXNzLWlmLWVxdWFsICJyZWd1bGFyIGZpbGUiCisrICAgICAgI28zMDAKKysgICAgKHVubGVz cyAoZGVmaW5lZD8gJ2NobW9kYXQpCisrICAgICAgKHRocm93ICd1bnN1cHBvcnRlZCkpCisrICAg IChjYWxsLXdpdGgtcG9ydAorKyAgICAgKG9wZW4gKGRpcm5hbWUgKHRlc3QtZmlsZSkpIE9fUkRP TkxZKQorKyAgICAgKGxhbWJkYSAocG9ydCkKKysgICAgICAgKGNobW9kYXQgcG9ydCAodGVzdC1m aWxlKSAjbzMwMCkpKQorKyAgICAoc3RhdDpwZXJtcyAoc3RhdCAodGVzdC1maWxlKSkpKQorKwor KyAgKGNobW9kICh0ZXN0LWZpbGUpICNvMDAwKQorKworKyAgKHBhc3MtaWYtZXF1YWwgInJlZ3Vs YXIgZmlsZSwgQVRfU1lNTElOS19OT0ZPTExPVyIKKysgICAgICAjbzMwMAorKyAgICAodW5sZXNz IChhbmQgKGRlZmluZWQ/ICdjaG1vZGF0KQorKyAgICAgICAgICAgICAgICAgKGRlZmluZWQ/ICdB VF9TWU1MSU5LX05PRk9MTE9XKSkKKysgICAgICAodGhyb3cgJ3Vuc3VwcG9ydGVkKSkKKysgICAg KGNhbGwtd2l0aC1wb3J0CisrICAgICAob3BlbiAoZGlybmFtZSAodGVzdC1maWxlKSkgT19SRE9O TFkpCisrICAgICAobGFtYmRhIChwb3J0KQorKyAgICAgICAoY2F0Y2ggJ3N5c3RlbS1lcnJvcgor KyAgICAgICAgIChsYW1iZGEgKCkKKysgICAgICAgICAgIChjaG1vZGF0IHBvcnQgKGJhc2VuYW1l ICh0ZXN0LWZpbGUpKSAjbzMwMCBBVF9TWU1MSU5LX05PRk9MTE9XKSkKKysgICAgICAgICAobGFt YmRhIGFyZ3MKKysgICAgICAgICAgIChjbG9zZS1wb3J0IHBvcnQpCisrICAgICAgICAgICA7OyBB VF9TWU1MSU5LX05PRk9MTE9XIGlzIG5vdCBzdXBwb3J0ZWQgb24gTGludXggKGF0IGxlYXN0IExp bnV4CisrICAgICAgICAgICA7OyA1LjExLjIgd2l0aCB0aGUgYnRyZnMgZmlsZSBzeXN0ZW0pLCBl dmVuIGZvciByZWd1bGFyIGZpbGVzLgorKyAgICAgICAgICAgKGlmICg9IEVOT1RTVVAgKHN5c3Rl bS1lcnJvci1lcnJubyBhcmdzKSkKKysgICAgICAgICAgICAgICAoYmVnaW4KKysgICAgICAgICAg ICAgICAgIChkaXNwbGF5ICJmY2htb2RhdCBkb2Vzbid0IHN1cHBvcnQgQVRfU1lNTElOS19OT0ZP TExPV1xuIikKKysgICAgICAgICAgICAgICAgICh0aHJvdyAndW5yZXNvbHZlZCkpCisrICAgICAg ICAgICAgICAgKGFwcGx5IHRocm93IGFyZ3MpKSkpKSkKKysgICAgKHN0YXQ6cGVybXMgKHN0YXQg KHRlc3QtZmlsZSkpKSkKKysKKysgIChwYXNzLWlmLWV4Y2VwdGlvbiAibm90IGEgcG9ydCIgZXhj ZXB0aW9uOndyb25nLXR5cGUtYXJnCisrICAgIChjaG1vZGF0ICJib2d1cyIgKHRlc3QtZmlsZSkg I28zMDApKQorKworKyAgKHBhc3MtaWYtZXhjZXB0aW9uICJub3QgYSBmaWxlIHBvcnQiIGV4Y2Vw dGlvbjp3cm9uZy10eXBlLWFyZworKyAgICAoY2htb2RhdCAob3Blbi1pbnB1dC1zdHJpbmcgIiIp ICh0ZXN0LWZpbGUpICNvMzAwKSkKKysKKysgIChwYXNzLWlmLWV4Y2VwdGlvbiAiY2xvc2VkIHBv cnQiIGV4Y2VwdGlvbjp3cm9uZy10eXBlLWFyZworKyAgICAoY2htb2RhdCAoY2FsbC13aXRoLXBv cnQgKG9wZW4gIi4iIE9fUkRPTkxZKSBpZGVudGl0eSkgKHRlc3QtZmlsZSkgI28zMDApKQorKwor KyAgKGRlbGV0ZS1maWxlICh0ZXN0LWZpbGUpKSkKKysKKyAod2l0aC10ZXN0LXByZWZpeCAiY2hk aXIiCisgICAocGFzcy1pZi1lcXVhbCAiY3VycmVudCBkaXJlY3RvcnkiIChnZXRjd2QpCisgICAg IChiZWdpbiAoY2hkaXIgIi4iKSAoZ2V0Y3dkKSkpCistLSAKKzIuMzAuMgorCisKZGlmZiAtLWdp dCBhL2dudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0xMC5wYXRj aCBiL2dudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0xMC5wYXRj aApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwLi4zZjUwYjFkN2Q1Ci0tLSAv ZGV2L251bGwKKysrIGIvZ251L3BhY2thZ2VzL3BhdGNoZXMvZ3VpbGUtb3BlbmF0LWFuZC1mcmll bmRzLTEwLnBhdGNoCkBAIC0wLDAgKzEsMjA0IEBACitHdWl4LVVwc3RyZWFtOiBodHRwczovL2xp c3RzLmdudS5vcmcvYXJjaGl2ZS9odG1sL2d1aWxlLWRldmVsLzIwMjEtMTEvbXNnMDAwMDUuaHRt bAorRnJvbTogTWF4aW1lIERldm9zIDxtYXhpbWVkZXZvc0B0ZWxlbmV0LmJlPgorU3ViamVjdDog W1BBVENIIHYyIDEwLzE0XSA9P1VURi04P3E/RGVmaW5lPTIwYT0yMFNjaGVtZT0yMGJpbmRpbmc9 MjB0bz0yMD89CisgPT9VVEYtOD9xPz1FMj04MD05OHVubGlua2F0PUUyPTgwPTk5PTIwd2hlbj0y MGl0PTIwZXhpc3RzLj89CitEYXRlOiBUdWUsIDE2IE5vdiAyMDIxIDExOjA2OjMzICswMDAwCitN ZXNzYWdlLUlkOiA8MjAyMTExMTYxMTA2MzcuMTI1NTc5LTExLW1heGltZWRldm9zQHRlbGVuZXQu YmU+CitJbi1SZXBseS1UbzogPDIwMjExMTE2MTEwNjM3LjEyNTU3OS0xLW1heGltZWRldm9zQHRl bGVuZXQuYmU+CitSZWZlcmVuY2VzOiA8MTc1YzNhNjU3MmU4MzJkODQ5Mjc5MzdiMzA5YTMwOTVj YWRmNTcwMi5jYW1lbEB0ZWxlbmV0LmJlPgorIDwyMDIxMTExNjExMDYzNy4xMjU1NzktMS1tYXhp bWVkZXZvc0B0ZWxlbmV0LmJlPgorTUlNRS1WZXJzaW9uOiAxLjAKK0NvbnRlbnQtVHlwZTogdGV4 dC9wbGFpbjsgY2hhcnNldD1VVEYtOAorQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogOGJpdAor CivigJh1bmxpbmthdOKAmSBpcyB1c2VkIGZvciBib3RoIHVubGlua2luZyByZWd1bGFyIGZpbGVz CithbmQgcmVtb3ZpbmcgZW1wdHkgZGlyZWN0b3JpZXMuCisKKyogY29uZmlndXJlLmFjOiBEZXRl Y3QgaWYg4oCYdW5saW5rYXTigJkgZXhpc3RzLgorKiBkb2MvcmVmL3Bvc2l4LnRleGkgKEZpbGUg U3lzdGVtKTogRG9jdW1lbnQgd2h5IHRoZXJlIGlzIG5vCisgIOKAmHJtZGlyYXTigJkgcHJvY2Vk dXJlLCBhbmQgZG9jdW1lbnQgdGhlIOKAmGRlbGV0ZS1maWxlLWF04oCZIHByb2NlZHVyZS4KKyog bGliZ3VpbGUvZmlsZXN5cy5jCisgIChzY21fcm1kaXIpOiBBZGp1c3QgdGhlIGRvY3N0cmluZyBo ZXJlIGFzIHdlbGwuCisgIChzY21fZGVsZXRlX2ZpbGVfYXQpOiBEZWZpbmUgYSBTY2hlbWUgYmlu ZGluZyB0byDigJh1bmxpbmthdOKAmS4KKyogbGliZ3VpbGUvZmlsZXN5cy5oIChzY21fZGVsZXRl X2ZpbGVfYXQpOiBNYWtlIOKAmHNjbV9kZWxldGVfZmlsZV9hdOKAmQorICBwYXJ0IG9mIHRoZSBD IEFQSS4KKy0tLQorIGNvbmZpZ3VyZS5hYyAgICAgICAgICAgICAgICAgIHwgIDUgKy0tCisgZG9j L3JlZi9wb3NpeC50ZXhpICAgICAgICAgICAgfCAxMiArKysrKysrCisgbGliZ3VpbGUvZmlsZXN5 cy5jICAgICAgICAgICAgfCAzMiArKysrKysrKysrKysrKysrKysrCisgbGliZ3VpbGUvZmlsZXN5 cy5oICAgICAgICAgICAgfCAgMSArCisgdGVzdC1zdWl0ZS90ZXN0cy9maWxlc3lzLnRlc3QgfCA1 OSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKworIDUgZmlsZXMgY2hhbmdlZCwg MTA3IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCisKK2RpZmYgLS1naXQgYS9jb25maWd1 cmUuYWMgYi9jb25maWd1cmUuYWMKK2luZGV4IDJhNTQ4NTk5MC4uZTFjMDkwMzIxIDEwMDY0NAor LS0tIGEvY29uZmlndXJlLmFjCisrKysgYi9jb25maWd1cmUuYWMKK0BAIC00NzcsNyArNDc3LDgg QEAgQUNfQ0hFQ0tfSEVBREVSUyhbYXNzZXJ0LmggY3J0X2V4dGVybnMuaF0pCisgIyAgIHRydW5j YXRlIC0gbm90IGluIG1pbmd3CisgIyAgIGlzYmxhbmsgLSBhdmFpbGFibGUgYXMgYSBHTlUgZXh0 ZW5zaW9uIG9yIGluIEM5OQorICMgICBfTlNHZXRFbnZpcm9uIC0gRGFyd2luIHNwZWNpZmljCist IyAgIHN0cmNvbGxfbCwgbmV3bG9jYWxlLCB1c2Vsb2NhbGUsIHV0aW1lbnNhdCwgZnV0aW1lbnMs IGZjaG1vZGF0IC0gUE9TSVguMS0yMDA4CisrIyAgIHN0cmNvbGxfbCwgbmV3bG9jYWxlLCB1c2Vs b2NhbGUsIHV0aW1lbnNhdCwgZnV0aW1lbnMsIGZjaG1vZGF0LAorKyMgICB1bmxpbmthdCAtIFBP U0lYLjEtMjAwOAorICMgICBzdHJ0b2xfbCAtIG5vbi1QT1NJWCwgZm91bmQgaW4gZ2xpYmMKKyAj ICAgZm9yayAtIHVuYXZhaWxhYmxlIG9uIFdpbmRvd3MKKyAjICAgc2NoZWRfZ2V0YWZmaW5pdHks IHNjaGVkX3NldGFmZmluaXR5IC0gR05VIGV4dGVuc2lvbnMgKGdsaWJjKQorQEAgLTQ4NSw3ICs0 ODYsNyBAQCBBQ19DSEVDS19IRUFERVJTKFthc3NlcnQuaCBjcnRfZXh0ZXJucy5oXSkKKyAjCisg QUNfQ0hFQ0tfRlVOQ1MoW0RJTkZJTklUWSBEUU5BTiBjZXhwIGNoc2l6ZSBjbG9nIGNsb2cxMCBj dGVybWlkICAgICAgICAgXAorICAgZmVzZXRyb3VuZCBmdGltZSBmdHJ1bmNhdGUgZmNob3duIGZj aG1vZCBmY2hkaXIgcmVhZGxpbmthdAkJXAorLSAgZmNobW9kYXQgc3ltbGlua2F0IG1rZGlyYXQg cmVuYW1lYXQgZ2V0Y3dkIGdldGV1aWQgZ2V0c2lkCQlcCisrICBmY2htb2RhdCBzeW1saW5rYXQg bWtkaXJhdCByZW5hbWVhdCB1bmxpbmthdCBnZXRjd2QgZ2V0ZXVpZCBnZXRzaWQJXAorICAgZ2V0 dGltZW9mZGF5IGdldHVpZCBnZXRnaWQgZ210aW1lX3IgaW9jdGwgbHN0YXQgbWtkaXIgbWtkdGVt cCBta25vZCAgIFwKKyAgIG5pY2UgcmVhZGxpbmsgcmVuYW1lIHJtZGlyIHNldGVnaWQgc2V0ZXVp ZCAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICBzZXRsb2NhbGUgc2V0dWlkIHNldGdp ZCBzZXRwZ2lkIHNldHNpZCBzaWdhY3Rpb24gc2lnaW50ZXJydXB0IHN0YXQ2NCAgXAorZGlmZiAt LWdpdCBhL2RvYy9yZWYvcG9zaXgudGV4aSBiL2RvYy9yZWYvcG9zaXgudGV4aQoraW5kZXggZWJi MDAxNTgxLi5hZDEwNTg1ZDkgMTAwNjQ0CistLS0gYS9kb2MvcmVmL3Bvc2l4LnRleGkKKysrKyBi L2RvYy9yZWYvcG9zaXgudGV4aQorQEAgLTgzNCw2ICs4MzQsMTggQEAgRGVsZXRlcyAob3IgYGB1 bmxpbmtzJycpIHRoZSBmaWxlIHdob3NlIHBhdGggaXMgc3BlY2lmaWVkIGJ5CisgQHZhcntzdHJ9 LgorIEBlbmQgZGVmZm4KKyAKKytAZmluZGV4IHVubGlua2F0CisrQGRlZmZuIHtTY2hlbWUgUHJv Y2VkdXJlfSBkZWxldGUtZmlsZS1hdCBkaXIgc3RyIFtmbGFnc10KKytAZGVmZm54IHtDIEZ1bmN0 aW9ufSBzY21fZGVsZXRlX2ZpbGVfYXQgKGRpciwgc3RyLCBmbGFncykKKytMaWtlIEBjb2Rle3Vu bGlua30sIGJ1dCByZXNvbHZlIEB2YXJ7c3RyfSByZWxhdGl2ZSB0byB0aGUKKytkaXJlY3Rvcnkg cmVmZXJyZWQgdG8gYnkgdGhlIGZpbGUgcG9ydCBAdmFye2Rpcn0gaW5zdGVhZC4KKysKKytUaGUg b3B0aW9uYWwgQHZhcntmbGFnc30gYXJndW1lbnQgY2FuIGJlIEBjb2Rle0FUX1JFTU9WRURJUn0s CisraW4gd2hpY2ggY2FzZSBAY29kZXtkZWxldGUtZmlsZS1hdH0gd2lsbCBhY3QgbGlrZSBAY29k ZXtybWRpcn0gaW5zdGVhZAorK29mIEBjb2Rle2RlbGV0ZS1maWxlfS4gIFdoeSBkb2Vzbid0IFBP U0lYIGhhdmUgYSBAY29kZXtybWRpcmF0fSBmdW5jdGlvbgorK2ZvciB0aGlzIGluc3RlYWQ/ICBO byBpZGVhIQorK0BlbmQgZGVmZm4KKysKKyBAZGVmZm4ge1NjaGVtZSBQcm9jZWR1cmV9IGNvcHkt ZmlsZSBvbGRmaWxlIG5ld2ZpbGUKKyBAZGVmZm54IHtDIEZ1bmN0aW9ufSBzY21fY29weV9maWxl IChvbGRmaWxlLCBuZXdmaWxlKQorIENvcHkgdGhlIGZpbGUgc3BlY2lmaWVkIGJ5IEB2YXJ7b2xk ZmlsZX0gdG8gQHZhcntuZXdmaWxlfS4KK2RpZmYgLS1naXQgYS9saWJndWlsZS9maWxlc3lzLmMg Yi9saWJndWlsZS9maWxlc3lzLmMKK2luZGV4IDRkZDljN2I0OC4uN2U2ZDg5NjI2IDEwMDY0NAor LS0tIGEvbGliZ3VpbGUvZmlsZXN5cy5jCisrKysgYi9saWJndWlsZS9maWxlc3lzLmMKK0BAIC0x NDY5LDYgKzE0NjksMzggQEAgU0NNX0RFRklORSAoc2NtX2RlbGV0ZV9maWxlLCAiZGVsZXRlLWZp bGUiLCAxLCAwLCAwLAorIH0KKyAjdW5kZWYgRlVOQ19OQU1FCisgCisrI2lmZGVmIEhBVkVfVU5M SU5LQVQKKytTQ01fREVGSU5FIChzY21fZGVsZXRlX2ZpbGVfYXQsICJkZWxldGUtZmlsZS1hdCIs IDIsIDEsIDAsCisrICAgICAgICAgICAgKFNDTSBkaXIsIFNDTSBzdHIsIFNDTSBmbGFncyksCisr ICAgICAgICAgICAgIkxpa2UgQGNvZGV7dW5saW5rfSwgYnV0IHJlc29sdmUgQHZhcntzdHJ9IHJl bGF0aXZlIHRvIHRoZVxuIgorKyAgICAgICAgICAgICJkaXJlY3RvcnkgcmVmZXJyZWQgdG8gYnkg dGhlIGZpbGUgcG9ydCBAdmFye2Rpcn0gaW5zdGVhZC5cblxuIgorKyAgICAgICAgICAgICJUaGUg b3B0aW9uYWwgQHZhcntmbGFnc30gYXJndW1lbnQgY2FuIGJlIEBjb2Rle0FUX1JFTU9WRURJUn0s XG4iCisrICAgICAgICAgICAgImluIHdoaWNoIGNhc2UgQGNvZGV7ZGVsZXRlLWZpbGUtYXR9IHdp bGwgYWN0IGxpa2UgQGNvZGV7cm1kaXJ9IGluc3RlYWRcbiIKKysgICAgICAgICAgICAib2YgQGNv ZGV7ZGVsZXRlLWZpbGV9LiAgV2h5IGRvZXNuJ3QgUE9TSVggaGF2ZSBhIEBjb2Rle3JtZGlyYXR9 IGZ1bmN0aW9uXG4iCisrICAgICAgICAgICAgImZvciB0aGlzIGluc3RlYWQ/ICBObyBpZGVhISIp CisrI2RlZmluZSBGVU5DX05BTUUgc19zY21fZGVsZXRlX2ZpbGVfYXQKKyt7CisrICBpbnQgYW5z OworKyAgaW50IGRpcl9mZGVzOworKyAgaW50IGNfZmxhZ3M7CisrCisrICBpZiAoU0NNX1VOQk5E UCAoZmxhZ3MpKQorKyAgICBjX2ZsYWdzID0gMDsKKysgIGVsc2UKKysgICAgY19mbGFncyA9IHNj bV90b19pbnQgKGZsYWdzKTsKKysKKysgIFNDTV9WQUxJREFURV9PUEZQT1JUIChTQ01fQVJHMSwg ZGlyKTsKKysgIGRpcl9mZGVzID0gU0NNX0ZQT1JUX0ZERVMgKGRpcik7CisrCisrICBTVFJJTkdf U1lTQ0FMTCAoc3RyLCBjX3N0ciwgYW5zID0gdW5saW5rYXQgKGRpcl9mZGVzLCBjX3N0ciwgY19m bGFncykpOworKyAgc2NtX3JlbWVtYmVyX3VwdG9faGVyZV8xIChkaXIpOworKyAgaWYgKGFucyAh PSAwKQorKyAgICBTQ01fU1lTRVJST1I7CisrICByZXR1cm4gU0NNX1VOU1BFQ0lGSUVEOworK30K KysjdW5kZWYgRlVOQ19OQU1FCisrI2VuZGlmCisrCisgU0NNX0RFRklORSAoc2NtX2FjY2Vzcywg ImFjY2Vzcz8iLCAyLCAwLCAwLAorICAgICAgICAgICAgIChTQ00gcGF0aCwgU0NNIGhvdyksCisg CSAgICAiVGVzdCBhY2Nlc3NpYmlsaXR5IG9mIGEgZmlsZSB1bmRlciB0aGUgcmVhbCBVSUQgYW5k IEdJRCBvZiB0aGVcbiIKK2RpZmYgLS1naXQgYS9saWJndWlsZS9maWxlc3lzLmggYi9saWJndWls ZS9maWxlc3lzLmgKK2luZGV4IDM3N2EzNzk1ZS4uMzdkMDg0Y2Q1IDEwMDY0NAorLS0tIGEvbGli Z3VpbGUvZmlsZXN5cy5oCisrKysgYi9saWJndWlsZS9maWxlc3lzLmgKK0BAIC01MSw2ICs1MSw3 IEBAIFNDTV9BUEkgU0NNIHNjbV9saW5rIChTQ00gb2xkcGF0aCwgU0NNIG5ld3BhdGgpOworIFND TV9BUEkgU0NNIHNjbV9yZW5hbWUgKFNDTSBvbGRuYW1lLCBTQ00gbmV3bmFtZSk7CisgU0NNX0FQ SSBTQ00gc2NtX3JlbmFtZWF0IChTQ00gb2xkZGlyLCBTQ00gb2xkbmFtZSwgU0NNIG5ld2Rpciwg U0NNIG5ld25hbWUpOworIFNDTV9BUEkgU0NNIHNjbV9kZWxldGVfZmlsZSAoU0NNIHN0cik7Cisr U0NNX0FQSSBTQ00gc2NtX2RlbGV0ZV9maWxlX2F0IChTQ00gZGlyLCBTQ00gc3RyLCBTQ00gZmxh Z3MpOworIFNDTV9BUEkgU0NNIHNjbV9ta2RpciAoU0NNIHBhdGgsIFNDTSBtb2RlKTsKKyBTQ01f QVBJIFNDTSBzY21fbWtkaXJhdCAoU0NNIGRpciwgU0NNIHBhdGgsIFNDTSBtb2RlKTsKKyBTQ01f QVBJIFNDTSBzY21fcm1kaXIgKFNDTSBwYXRoKTsKK2RpZmYgLS1naXQgYS90ZXN0LXN1aXRlL3Rl c3RzL2ZpbGVzeXMudGVzdCBiL3Rlc3Qtc3VpdGUvdGVzdHMvZmlsZXN5cy50ZXN0CitpbmRleCAy MDRmMzQxNGMuLjMzYjY4ZTE2ZCAxMDA2NDQKKy0tLSBhL3Rlc3Qtc3VpdGUvdGVzdHMvZmlsZXN5 cy50ZXN0CisrKysgYi90ZXN0LXN1aXRlL3Rlc3RzL2ZpbGVzeXMudGVzdAorQEAgLTU4OSwzICs1 ODksNjIgQEAKKyAgIChwYXNzLWlmLWV4Y2VwdGlvbiAibm90IGEgc3RyaW5nICgyKSIgZXhjZXB0 aW9uOndyb25nLXR5cGUtYXJnCisgICAgIChza2lwLWlmLXVuc3VwcG9ydGVkKQorICAgICAocmVu YW1lLWZpbGUtYXQgI2YgInNvbWUiICNmICd3aGF0KSkpCisrCisrKHdpdGgtdGVzdC1wcmVmaXgg ImRlbGV0ZS1maWxlLWF0IgorKyAgKGRlZmluZSAoc2tpcC1pZi11bnN1cHBvcnRlZCkKKysgICAg KHdoZW4gKG5vdCAoYW5kIChkZWZpbmVkPyAnZGVsZXRlLWZpbGUtYXQpCisrICAgICAgICAgICAg ICAgICAgICAoZGVmaW5lZD8gJ0FUX1JFTU9WRURJUikpKQorKyAgICAgICh0aHJvdyAndW5zdXBw b3J0ZWQpKSkKKysgIChkZWZpbmUgKGNyZWF0ZS10ZXN0LWZpbGUpCisrICAgIChjYWxsLXdpdGgt b3V0cHV0LWZpbGUgKHRlc3QtZmlsZSkgaWRlbnRpdHkpKQorKyAgKGRlZmluZSAoY3JlYXRlLXRl c3QtZGlyZWN0b3J5KQorKyAgICAobWtkaXIgKHRlc3QtZGlyZWN0b3J5KSkpCisrICAoZGVmaW5l IChkZWxldGUtdGVzdC1maWxlKQorKyAgICAod2hlbiAoZmlsZS1leGlzdHM/ICh0ZXN0LWZpbGUp KQorKyAgICAgIChkZWxldGUtZmlsZSAodGVzdC1maWxlKSkpKQorKyAgKGRlZmluZSAoZGVsZXRl LXRlc3QtZGlyZWN0b3J5KQorKyAgICAod2hlbiAoZmlsZS1leGlzdHM/ICh0ZXN0LWRpcmVjdG9y eSkpCisrICAgICAgKHJtZGlyICh0ZXN0LWRpcmVjdG9yeSkpKSkKKysKKysgIChwYXNzLWlmLWVx dWFsICJyZWd1bGFyIGZpbGUiICNmCisrICAgIChza2lwLWlmLXVuc3VwcG9ydGVkKQorKyAgICAo Y3JlYXRlLXRlc3QtZmlsZSkKKysgICAgKGNhbGwtd2l0aC1wb3J0CisrICAgICAob3BlbiAoZGly bmFtZSAodGVzdC1maWxlKSkgT19SRE9OTFkpCisrICAgICAobGFtYmRhIChwb3J0KQorKyAgICAg ICAoZGVsZXRlLWZpbGUtYXQgcG9ydCAoYmFzZW5hbWUgKHRlc3QtZmlsZSkpKSkpCisrICAgIChm aWxlLWV4aXN0cz8gKHRlc3QtZmlsZSkpKQorKyAgKGRlbGV0ZS10ZXN0LWZpbGUpCisrCisrICAo cGFzcy1pZi1lcXVhbCAicmVndWxhciBmaWxlLCBleHBsaWNpdCBmbGFncyIgI2YKKysgICAgKHNr aXAtaWYtdW5zdXBwb3J0ZWQpCisrICAgIChjcmVhdGUtdGVzdC1maWxlKQorKyAgICAoY2FsbC13 aXRoLXBvcnQKKysgICAgIChvcGVuIChkaXJuYW1lICh0ZXN0LWZpbGUpKSBPX1JET05MWSkKKysg ICAgIChsYW1iZGEgKHBvcnQpCisrICAgICAgIChkZWxldGUtZmlsZS1hdCBwb3J0IChiYXNlbmFt ZSAodGVzdC1maWxlKSkgMCkpKQorKyAgICAoZmlsZS1leGlzdHM/ICh0ZXN0LWZpbGUpKSkKKysg IChkZWxldGUtdGVzdC1maWxlKQorKworKyAgKHBhc3MtaWYtZXF1YWwgImRpcmVjdG9yeSwgZXhw bGljaXQgZmxhZ3MiICNmCisrICAgIChza2lwLWlmLXVuc3VwcG9ydGVkKQorKyAgICAoY3JlYXRl LXRlc3QtZGlyZWN0b3J5KQorKyAgICAoY2FsbC13aXRoLXBvcnQKKysgICAgIChvcGVuIChkaXJu YW1lICh0ZXN0LWRpcmVjdG9yeSkpIE9fUkRPTkxZKQorKyAgICAgKGxhbWJkYSAocG9ydCkKKysg ICAgICAgKGRlbGV0ZS1maWxlLWF0IHBvcnQgKGJhc2VuYW1lICh0ZXN0LWRpcmVjdG9yeSkpIEFU X1JFTU9WRURJUikpKQorKyAgICAoZmlsZS1leGlzdHM/ICh0ZXN0LWRpcmVjdG9yeSkpKQorKyAg KGRlbGV0ZS10ZXN0LWRpcmVjdG9yeSkKKysKKysgIChwYXNzLWlmLWV4Y2VwdGlvbiAibm90IGEg cG9ydCIgZXhjZXB0aW9uOndyb25nLXR5cGUtYXJnCisrICAgIChza2lwLWlmLXVuc3VwcG9ydGVk KQorKyAgICAoZGVsZXRlLWZpbGUtYXQgJ2JvZ3VzICJpcnJlbGV2YW50IikpCisrCisrICAocGFz cy1pZi1leGNlcHRpb24gIm5vdCBhIGZpbGUgcG9ydCIgZXhjZXB0aW9uOndyb25nLXR5cGUtYXJn CisrICAgIChza2lwLWlmLXVuc3VwcG9ydGVkKQorKyAgICAoZGVsZXRlLWZpbGUtYXQgKG9wZW4t aW5wdXQtc3RyaW5nICIiKSAiaXJyZWxldmFudCIpKQorKworKyAgKHBhc3MtaWYtZXhjZXB0aW9u ICJjbG9zZWQgcG9ydCIgZXhjZXB0aW9uOndyb25nLXR5cGUtYXJnCisrICAgIChza2lwLWlmLXVu c3VwcG9ydGVkKQorKyAgICAoZGVsZXRlLWZpbGUtYXQgKGNhbGwtd2l0aC1wb3J0IChvcGVuICIu IiBPX1JET05MWSkgaWRlbnRpdHkpCisrICAgICAgICAgICAgICAgICAgICAiaXJyZWxldmFudCIp KSkKKy0tIAorMi4zMC4yCisKKwpkaWZmIC0tZ2l0IGEvZ251L3BhY2thZ2VzL3BhdGNoZXMvZ3Vp bGUtb3BlbmF0LWFuZC1mcmllbmRzLTExLnBhdGNoIGIvZ251L3BhY2thZ2VzL3BhdGNoZXMvZ3Vp bGUtb3BlbmF0LWFuZC1mcmllbmRzLTExLnBhdGNoCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAuLjM3YzUyZWJhZGMKLS0tIC9kZXYvbnVsbAorKysgYi9nbnUvcGFja2FnZXMv cGF0Y2hlcy9ndWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMTEucGF0Y2gKQEAgLTAsMCArMSwxMzAg QEAKK0d1aXgtVXBzdHJlYW06IGh0dHBzOi8vbGlzdHMuZ251Lm9yZy9hcmNoaXZlL2h0bWwvZ3Vp bGUtZGV2ZWwvMjAyMS0xMS9tc2cwMDAwNS5odG1sCitGcm9tOiBNYXhpbWUgRGV2b3MgPG1heGlt ZWRldm9zQHRlbGVuZXQuYmU+CitTdWJqZWN0OiBbUEFUQ0ggdjIgMTEvMTRdID0/VVRGLTg/cT9E ZWZpbmU9MjBhPTIwU2NoZW1lPTIwYmluZGluZz0yMHRvPTIwPz0KKyA9P1VURi04P3E/PUUyPTgw PTk4ZmNob3duYXQ9RTI9ODA9OTk9MjB3aGVuPTIwaXQ9MjBleGlzdHMuPz0KK0RhdGU6IFR1ZSwg MTYgTm92IDIwMjEgMTE6MDY6MzQgKzAwMDAKK01lc3NhZ2UtSWQ6IDwyMDIxMTExNjExMDYzNy4x MjU1NzktMTItbWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KK0luLVJlcGx5LVRvOiA8MjAyMTExMTYx MTA2MzcuMTI1NTc5LTEtbWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KK1JlZmVyZW5jZXM6IDwxNzVj M2E2NTcyZTgzMmQ4NDkyNzkzN2IzMDlhMzA5NWNhZGY1NzAyLmNhbWVsQHRlbGVuZXQuYmU+Cisg PDIwMjExMTE2MTEwNjM3LjEyNTU3OS0xLW1heGltZWRldm9zQHRlbGVuZXQuYmU+CitNSU1FLVZl cnNpb246IDEuMAorQ29udGVudC1UeXBlOiB0ZXh0L3BsYWluOyBjaGFyc2V0PVVURi04CitDb250 ZW50LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0CisKKyogY29uZmlndXJlLmFjOiBEZXRlY3Qgd2hl dGhlciDigJhmY2hvd25hdOKAmSBpcyBhdmFpbGFibGUuCisqIGxpYmd1aWxlL2ZpbGVzeXMuYyAo c2NtX2Nob3duYXQpOiBEZWZpbmUgYSBTY2hlbWUgYmluZGluZyB0bworICDigJhmY2hvd25hdOKA mSB3aGVuIGF2YWlsYWJsZS4KKyogbGliZ3VpbGUvZmlsZXN5cy5oIChzY21fY2hvd25hdCk6IE1h a2UgaXQgcGFydCBvZiB0aGUgQVBJLgorKiBkb2MvcmVmL3Bvc2l4LnRleGkgKEZpbGUgU3lzdGVt KTogRG9jdW1lbnQgaXQuCistLS0KKyBjb25maWd1cmUuYWMgICAgICAgfCAgNCArKy0tCisgZG9j L3JlZi9wb3NpeC50ZXhpIHwgMTEgKysrKysrKysrKysKKyBsaWJndWlsZS9maWxlc3lzLmMgfCAz NSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKworIGxpYmd1aWxlL2ZpbGVzeXMu aCB8ICAxICsKKyA0IGZpbGVzIGNoYW5nZWQsIDQ5IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25z KC0pCisKK2RpZmYgLS1naXQgYS9jb25maWd1cmUuYWMgYi9jb25maWd1cmUuYWMKK2luZGV4IGUx YzA5MDMyMS4uZGNiNmJjZWI1IDEwMDY0NAorLS0tIGEvY29uZmlndXJlLmFjCisrKysgYi9jb25m aWd1cmUuYWMKK0BAIC00NzgsMTQgKzQ3OCwxNCBAQCBBQ19DSEVDS19IRUFERVJTKFthc3NlcnQu aCBjcnRfZXh0ZXJucy5oXSkKKyAjICAgaXNibGFuayAtIGF2YWlsYWJsZSBhcyBhIEdOVSBleHRl bnNpb24gb3IgaW4gQzk5CisgIyAgIF9OU0dldEVudmlyb24gLSBEYXJ3aW4gc3BlY2lmaWMKKyAj ICAgc3RyY29sbF9sLCBuZXdsb2NhbGUsIHVzZWxvY2FsZSwgdXRpbWVuc2F0LCBmdXRpbWVucywg ZmNobW9kYXQsCistIyAgIHVubGlua2F0IC0gUE9TSVguMS0yMDA4CisrIyAgIHVubGlua2F0LCBm Y2hvd25hdCAtIFBPU0lYLjEtMjAwOAorICMgICBzdHJ0b2xfbCAtIG5vbi1QT1NJWCwgZm91bmQg aW4gZ2xpYmMKKyAjICAgZm9yayAtIHVuYXZhaWxhYmxlIG9uIFdpbmRvd3MKKyAjICAgc2NoZWRf Z2V0YWZmaW5pdHksIHNjaGVkX3NldGFmZmluaXR5IC0gR05VIGV4dGVuc2lvbnMgKGdsaWJjKQor ICMgICBzZW5kZmlsZSAtIG5vbi1QT1NJWCwgZm91bmQgaW4gZ2xpYmMKKyAjCisgQUNfQ0hFQ0tf RlVOQ1MoW0RJTkZJTklUWSBEUU5BTiBjZXhwIGNoc2l6ZSBjbG9nIGNsb2cxMCBjdGVybWlkICAg ICAgICAgXAorLSAgZmVzZXRyb3VuZCBmdGltZSBmdHJ1bmNhdGUgZmNob3duIGZjaG1vZCBmY2hk aXIgcmVhZGxpbmthdAkJXAorKyAgZmVzZXRyb3VuZCBmdGltZSBmdHJ1bmNhdGUgZmNob3duIGZj aG93bmF0IGZjaG1vZCBmY2hkaXIgcmVhZGxpbmthdAlcCisgICBmY2htb2RhdCBzeW1saW5rYXQg bWtkaXJhdCByZW5hbWVhdCB1bmxpbmthdCBnZXRjd2QgZ2V0ZXVpZCBnZXRzaWQJXAorICAgZ2V0 dGltZW9mZGF5IGdldHVpZCBnZXRnaWQgZ210aW1lX3IgaW9jdGwgbHN0YXQgbWtkaXIgbWtkdGVt cCBta25vZCAgIFwKKyAgIG5pY2UgcmVhZGxpbmsgcmVuYW1lIHJtZGlyIHNldGVnaWQgc2V0ZXVp ZCAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCitkaWZmIC0tZ2l0IGEvZG9jL3JlZi9wb3Np eC50ZXhpIGIvZG9jL3JlZi9wb3NpeC50ZXhpCitpbmRleCBhZDEwNTg1ZDkuLjNkMDZmMWM3MyAx MDA2NDQKKy0tLSBhL2RvYy9yZWYvcG9zaXgudGV4aQorKysrIGIvZG9jL3JlZi9wb3NpeC50ZXhp CitAQCAtNzg0LDYgKzc4NCwxNyBAQCB1bnN1cHBvcnRlZCBhdCBwcmVzZW50KS4gIElmIEB2YXJ7 b3duZXJ9IG9yIEB2YXJ7Z3JvdXB9IGlzIHNwZWNpZmllZAorIGFzIEBjb2Rley0xfSwgdGhlbiB0 aGF0IElEIGlzIG5vdCBjaGFuZ2VkLgorIEBlbmQgZGVmZm4KKyAKKytAZmluZGV4IGZjaG93bmF0 CisrQGRlZmZuIHtTY2hlbWUgUHJvY2VkdXJlfSBjaG93bmF0IGRpciBuYW1lIG93bmVyIGdyb3Vw IFtmbGFnc10KKytAZGVmZm54IHtDIEZ1bmN0aW9ufSBzY21fY2hvd25hdCAoZGlyLCBuYW1lLCBv d25lciwgZ3JvdXAsIGZsYWdzKQorK0xpa2UgQGNvZGV7Y2hvd259LCBidXQgbW9kaWZ5IHRoZSBv d25lciBhbmQvb3IgZ3JvdXAgb2YKKyt0aGUgZmlsZSBuYW1lZCBAdmFye25hbWV9IGluIHRoZSBk aXJlY3RvcnkgcmVmZXJyZWQgdG8KKytieSB0aGUgZmlsZSBwb3J0IEB2YXJ7ZGlyfSBpbnN0ZWFk LiAgVGhlIG9wdGlvbmFsIGFyZ3VtZW50CisrQHZhcntmbGFnc30gaXMgYSBiaXRtYXNrLiAgSWYg QGNvZGV7QVRfU1lNTElOS19OT0ZPTExPV30gaXMKKytwcmVzZW50LCB0aGVuIEB2YXJ7bmFtZX0g d2lsbCBub3QgYmUgZGVyZWZlcmVuY2VkIGlmIGl0IGlzIGEKKytzeW1ib2xpYyBsaW5rLgorK0Bl bmQgZGVmZm4KKysKKyBAZmluZGV4IGZjaG1vZAorIEBkZWZmbiB7U2NoZW1lIFByb2NlZHVyZX0g Y2htb2Qgb2JqZWN0IG1vZGUKKyBAZGVmZm54IHtDIEZ1bmN0aW9ufSBzY21fY2htb2QgKG9iamVj dCwgbW9kZSkKK2RpZmYgLS1naXQgYS9saWJndWlsZS9maWxlc3lzLmMgYi9saWJndWlsZS9maWxl c3lzLmMKK2luZGV4IDdlNmQ4OTYyNi4uYzI1N2JiNTljIDEwMDY0NAorLS0tIGEvbGliZ3VpbGUv ZmlsZXN5cy5jCisrKysgYi9saWJndWlsZS9maWxlc3lzLmMKK0BAIC0xOTMsNiArMTkzLDQxIEBA IFNDTV9ERUZJTkUgKHNjbV9jaG93biwgImNob3duIiwgMywgMCwgMCwKKyAjdW5kZWYgRlVOQ19O QU1FCisgI2VuZGlmIC8qIEhBVkVfQ0hPV04gKi8KKyAKKysjaWZkZWYgSEFWRV9GQ0hPV05BVAor K1NDTV9ERUZJTkUgKHNjbV9jaG93bmF0LCAiY2hvd24tYXQiLCA0LCAxLCAwLAorKyAgICAgICAg ICAgIChTQ00gZGlyLCBTQ00gbmFtZSwgU0NNIG93bmVyLCBTQ00gZ3JvdXAsIFNDTSBmbGFncyks CisrICAgICAgICAgICAgIkxpa2UgQGNvZGV7Y2hvd259LCBidXQgbW9kaWZ5IHRoZSBvd25lciBh bmQvb3IgZ3JvdXAgb2ZcbiIKKysgICAgICAgICAgICAidGhlIGZpbGUgbmFtZWQgQHZhcntuYW1l fSBpbiB0aGUgZGlyZWN0b3J5IHJlZmVycmVkIHRvXG4iCisrICAgICAgICAgICAgImJ5IHRoZSBm aWxlIHBvcnQgQHZhcntkaXJ9IGluc3RlYWQuICBUaGUgb3B0aW9uYWwgYXJndW1lbnRcbiIKKysg ICAgICAgICAgICAiQHZhcntmbGFnc30gaXMgYSBiaXRtYXNrLiAgSWYgQGNvZGV7QVRfU1lNTElO S19OT0ZPTExPV30gaXNcbiIKKysgICAgICAgICAgICAicHJlc2VudCwgdGhlbiBAdmFye25hbWV9 IHdpbGwgbm90IGJlIGRlcmVmZXJlbmNlZCBpZiBpdCBpcyBhXG4iCisrICAgICAgICAgICAgInN5 bWJvbGljIGxpbmsuIikKKysjZGVmaW5lIEZVTkNfTkFNRSBzX3NjbV9jaG93bmF0CisreworKyAg aW50IHJ2OworKyAgaW50IGRpcl9mZGVzOworKyAgaW50IGNfZmxhZ3M7CisrCisrICBpZiAoU0NN X1VOQk5EUCAoZmxhZ3MpKQorKyAgICBjX2ZsYWdzID0gMDsKKysgIGVsc2UKKysgICAgY19mbGFn cyA9IHNjbV90b19pbnQgKGZsYWdzKTsKKysKKysgIFNDTV9WQUxJREFURV9PUEZQT1JUIChTQ01f QVJHMSwgZGlyKTsKKysgIGRpcl9mZGVzID0gU0NNX0ZQT1JUX0ZERVMgKGRpcik7CisrCisrICBT VFJJTkdfU1lTQ0FMTCAobmFtZSwgY19uYW1lLAorKyAgICAgICAgICAgICAgICAgIHJ2ID0gZmNo b3duYXQgKGRpcl9mZGVzLCBjX25hbWUsCisrICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgc2NtX3RvX2ludCAob3duZXIpLCBzY21fdG9faW50IChncm91cCksCisrICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgY19mbGFncykpOworKyAgc2NtX3JlbWVtYmVyX3VwdG9faGVy ZV8xIChkaXIpOworKyAgaWYgKHJ2ID09IC0xKQorKyAgICBTQ01fU1lTRVJST1I7CisrICByZXR1 cm4gU0NNX1VOU1BFQ0lGSUVEOworK30KKysjdW5kZWYgRlVOQ19OQU1FCisrI2VuZGlmIC8qIEhB VkVfRkNIT1dOQVQgKi8KKysKKyAMCisgCisgU0NNX0RFRklORSAoc2NtX29wZW5fZmRlcywgIm9w ZW4tZmRlcyIsIDIsIDEsIDAsIAorZGlmZiAtLWdpdCBhL2xpYmd1aWxlL2ZpbGVzeXMuaCBiL2xp Ymd1aWxlL2ZpbGVzeXMuaAoraW5kZXggMzdkMDg0Y2Q1Li43NjczYzgwNTEgMTAwNjQ0CistLS0g YS9saWJndWlsZS9maWxlc3lzLmgKKysrKyBiL2xpYmd1aWxlL2ZpbGVzeXMuaAorQEAgLTM5LDYg KzM5LDcgQEAgU0NNX0FQSSBzY21fdF9iaXRzIHNjbV90YzE2X2RpcjsKKyAMCisgCisgU0NNX0FQ SSBTQ00gc2NtX2Nob3duIChTQ00gb2JqZWN0LCBTQ00gb3duZXIsIFNDTSBncm91cCk7CisrU0NN X0FQSSBTQ00gc2NtX2Nob3duYXQgKFNDTSBkaXIsIFNDTSBvYmplY3QsIFNDTSBvd25lciwgU0NN IGdyb3VwLCBTQ00gZmxhZ3MpOworIFNDTV9BUEkgU0NNIHNjbV9jaG1vZCAoU0NNIG9iamVjdCwg U0NNIG1vZGUpOworIFNDTV9BUEkgU0NNIHNjbV9jaG1vZGF0IChTQ00gZGlyLCBTQ00gcGF0aG5h bWUsIFNDTSBtb2RlLCBTQ00gZmxhZ3MpOworIFNDTV9BUEkgU0NNIHNjbV91bWFzayAoU0NNIG1v ZGUpOworLS0gCisyLjMwLjIKKworCmRpZmYgLS1naXQgYS9nbnUvcGFja2FnZXMvcGF0Y2hlcy9n dWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMTIucGF0Y2ggYi9nbnUvcGFja2FnZXMvcGF0Y2hlcy9n dWlsZS1vcGVuYXQtYW5kLWZyaWVuZHMtMTIucGF0Y2gKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMC4uODQ1ZTgzNmIwMwotLS0gL2Rldi9udWxsCisrKyBiL2dudS9wYWNrYWdl cy9wYXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0xMi5wYXRjaApAQCAtMCwwICsxLDIz OCBAQAorR3VpeC1VcHN0cmVhbTogaHR0cHM6Ly9saXN0cy5nbnUub3JnL2FyY2hpdmUvaHRtbC9n dWlsZS1kZXZlbC8yMDIxLTExL21zZzAwMDA1Lmh0bWwKK0Zyb206IE1heGltZSBEZXZvcyA8bWF4 aW1lZGV2b3NAdGVsZW5ldC5iZT4KK1N1YmplY3Q6IFtQQVRDSCB2MiAxMi8xNF0gPT9VVEYtOD9x P0RlZmluZT0yMGE9MjBTY2hlbWU9MjBiaW5kaW5nPTIwdG89MjA/PQorID0/VVRGLTg/cT89RTI9 ODA9OThmc3RhdGF0PUUyPTgwPTk5PTIwd2hlbj0yMGF2YWlsYWJsZS4/PQorRGF0ZTogVHVlLCAx NiBOb3YgMjAyMSAxMTowNjozNSArMDAwMAorTWVzc2FnZS1JZDogPDIwMjExMTE2MTEwNjM3LjEy NTU3OS0xMy1tYXhpbWVkZXZvc0B0ZWxlbmV0LmJlPgorSW4tUmVwbHktVG86IDwyMDIxMTExNjEx MDYzNy4xMjU1NzktMS1tYXhpbWVkZXZvc0B0ZWxlbmV0LmJlPgorUmVmZXJlbmNlczogPDE3NWMz YTY1NzJlODMyZDg0OTI3OTM3YjMwOWEzMDk1Y2FkZjU3MDIuY2FtZWxAdGVsZW5ldC5iZT4KKyA8 MjAyMTExMTYxMTA2MzcuMTI1NTc5LTEtbWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KK01JTUUtVmVy c2lvbjogMS4wCitDb250ZW50LVR5cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9VVRGLTgKK0NvbnRl bnQtVHJhbnNmZXItRW5jb2Rpbmc6IDhiaXQKKworKiBjb25maWd1cmUuYWM6IERldGVjdCBpZiDi gJhmc3RhdGF04oCZIGlzIGRlZmluZWQuCisqIGxpYmd1aWxlL2ZpbGVzeXMuYyAoc2NtX3N0YXRh dCk6IERlZmluZSBhIFNjaGVtZSBiaW5kaW5nIHRvIOKAmGZzdGF0YXTigJkuCisqIGxpYmd1aWxl L2ZpbGVzeXMuaCAoc2NtX3N0YXRhdCk6IE1ha2UgaXQgcGFydCBvZiB0aGUgQyBBUEkuCisqIGRv Yy9yZWYvcG9zaXgudGV4aSAoRmlsZSBTeXN0ZW0pOiBEb2N1bWVudCBpdC4KKyogbGliZ3VpbGUv c3lzY2FsbHMuaCAoZnN0YXRhdF9vcl9mc3RhdGF0NjQpOiBDaG9vc2UgYmV0d2VlbiDigJhmc3Rh dGF04oCZCisgIGFuZCDigJhmc3RhdGF0NjTigJkuCistLS0KKyBjb25maWd1cmUuYWMgICAgICAg ICAgICAgICAgICB8ICA0ICstCisgZG9jL3JlZi9wb3NpeC50ZXhpICAgICAgICAgICAgfCAgOCAr KysrCisgbGliZ3VpbGUvZmlsZXN5cy5jICAgICAgICAgICAgfCAzOSArKysrKysrKysrKysrKysr KworIGxpYmd1aWxlL2ZpbGVzeXMuaCAgICAgICAgICAgIHwgIDEgKworIGxpYmd1aWxlL3N5c2Nh bGxzLmggICAgICAgICAgIHwgIDEgKworIHRlc3Qtc3VpdGUvdGVzdHMvZmlsZXN5cy50ZXN0IHwg ODAgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKKyA2IGZpbGVzIGNoYW5nZWQs IDEzMSBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQorCitkaWZmIC0tZ2l0IGEvY29uZmln dXJlLmFjIGIvY29uZmlndXJlLmFjCitpbmRleCBkY2I2YmNlYjUuLmUwNzNlMDRmNCAxMDA2NDQK Ky0tLSBhL2NvbmZpZ3VyZS5hYworKysrIGIvY29uZmlndXJlLmFjCitAQCAtNDc4LDcgKzQ3OCw3 IEBAIEFDX0NIRUNLX0hFQURFUlMoW2Fzc2VydC5oIGNydF9leHRlcm5zLmhdKQorICMgICBpc2Js YW5rIC0gYXZhaWxhYmxlIGFzIGEgR05VIGV4dGVuc2lvbiBvciBpbiBDOTkKKyAjICAgX05TR2V0 RW52aXJvbiAtIERhcndpbiBzcGVjaWZpYworICMgICBzdHJjb2xsX2wsIG5ld2xvY2FsZSwgdXNl bG9jYWxlLCB1dGltZW5zYXQsIGZ1dGltZW5zLCBmY2htb2RhdCwKKy0jICAgdW5saW5rYXQsIGZj aG93bmF0IC0gUE9TSVguMS0yMDA4CisrIyAgIHVubGlua2F0LCBmY2hvd25hdCwgZnN0YXRhdCAt IFBPU0lYLjEtMjAwOAorICMgICBzdHJ0b2xfbCAtIG5vbi1QT1NJWCwgZm91bmQgaW4gZ2xpYmMK KyAjICAgZm9yayAtIHVuYXZhaWxhYmxlIG9uIFdpbmRvd3MKKyAjICAgc2NoZWRfZ2V0YWZmaW5p dHksIHNjaGVkX3NldGFmZmluaXR5IC0gR05VIGV4dGVuc2lvbnMgKGdsaWJjKQorQEAgLTQ5NSw3 ICs0OTUsNyBAQCBBQ19DSEVDS19GVU5DUyhbRElORklOSVRZIERRTkFOIGNleHAgY2hzaXplIGNs b2cgY2xvZzEwIGN0ZXJtaWQgICAgICAgICBcCisgICBnZXRncmVudCBraWxsIGdldHBwaWQgZ2V0 cGdycCBmb3JrIHNldGl0aW1lciBnZXRpdGltZXIgc3RyY2hyIHN0cmNtcCAgXAorICAgaW5kZXgg YmNvcHkgbWVtY3B5IHJpbmRleCB0cnVuY2F0ZSBpc2JsYW5rIF9OU0dldEVudmlyb24gICAgICAg ICAgICAgIFwKKyAgIHN0cmNvbGwgc3RyY29sbF9sIHN0cnRvZF9sIHN0cnRvbF9sIG5ld2xvY2Fs ZSB1c2Vsb2NhbGUgdXRpbWVuc2F0ICAgICBcCistICBmdXRpbWVucyBzY2hlZF9nZXRhZmZpbml0 eSBzY2hlZF9zZXRhZmZpbml0eSBzZW5kZmlsZV0pCisrICBmc3RhdGF0IGZ1dGltZW5zIHNjaGVk X2dldGFmZmluaXR5IHNjaGVkX3NldGFmZmluaXR5IHNlbmRmaWxlXSkKKyAKKyAjIFRoZSBuZXds aWIgQyBsaWJyYXJ5IHVzZXMgX05MXyBwcmVmaXhlZCBsb2NhbGUgbGFuZ2luZm8gY29uc3RhbnRz LgorIEFDX0NIRUNLX0RFQ0xTKFtfTkxfTlVNRVJJQ19HUk9VUElOR10sIFtdLCBbXSwgW1sjaW5j bHVkZSA8bGFuZ2luZm8uaD5dXSkKK2RpZmYgLS1naXQgYS9kb2MvcmVmL3Bvc2l4LnRleGkgYi9k b2MvcmVmL3Bvc2l4LnRleGkKK2luZGV4IDNkMDZmMWM3My4uY2RkMDNmMTQxIDEwMDY0NAorLS0t IGEvZG9jL3JlZi9wb3NpeC50ZXhpCisrKysgYi9kb2MvcmVmL3Bvc2l4LnRleGkKK0BAIC03NTUs NiArNzU1LDE0IEBAIGl0IHdpbGwgcmV0dXJuIGluZm9ybWF0aW9uIGFib3V0IGEgc3ltYm9saWMg bGluayBpdHNlbGYsIG5vdCB0aGUKKyBmaWxlIGl0IHBvaW50cyB0by4gIEB2YXJ7cGF0aH0gbXVz dCBiZSBhIHN0cmluZy4KKyBAZW5kIGRlZmZuCisgCisrQGRlZmZuIHtTY2hlbWUgUHJvY2VkdXJl fSBzdGF0YXQgZGlyIGZpbGVuYW1lIFtmbGFnc10KKytAZGVmZm54IHtDIEZ1bmN0aW9ufSBzY21f c3RhdGF0IGRpciBmaWxlbmFtZSBmbGFncworK0xpa2UgQGNvZGV7c3RhdH0sIGJ1dCByZXNvbHZl IEB2YXJ7ZmlsZW5hbWV9IHJlbGF0aXZlIHRvIHRoZSBkaXJlY3RvcnkKKytyZWZlcnJlZCB0byBi eSB0aGUgZmlsZSBwb3J0IEB2YXJ7ZGlyfSBpbnN0ZWFkLiAgVGhlIG9wdGlvbmFsIGFyZ3VtZW50 CisrQHZhcntmbGFnc30gYXJndW1lbnQgY2FuIGJlIEBjb2Rle0FUX1NZTUxJTktfTk9GT0xMT1d9 LCBpbiB3aGljaCBjYXNlCisrQHZhcntmaWxlbmFtZX0gd2lsbCBub3QgYmUgZGVyZWZlcmVuY2Vk IGV2ZW4gaWYgaXQgaXMgYSBzeW1ib2xpYyBsaW5rLgorK0BlbmQgZGVmZm4KKysKKyBAZGVmZm4g e1NjaGVtZSBQcm9jZWR1cmV9IHJlYWRsaW5rIHBhdGgKKyBAZGVmZm54IHtDIEZ1bmN0aW9ufSBz Y21fcmVhZGxpbmsgKHBhdGgpCisgUmV0dXJuIHRoZSB2YWx1ZSBvZiB0aGUgc3ltYm9saWMgbGlu ayBuYW1lZCBieSBAdmFye3BhdGh9IChhIHN0cmluZywgb3IKK2RpZmYgLS1naXQgYS9saWJndWls ZS9maWxlc3lzLmMgYi9saWJndWlsZS9maWxlc3lzLmMKK2luZGV4IGMyNTdiYjU5Yy4uZDA0NWE2 NzJmIDEwMDY0NAorLS0tIGEvbGliZ3VpbGUvZmlsZXN5cy5jCisrKysgYi9saWJndWlsZS9maWxl c3lzLmMKK0BAIC02MDEsNiArNjAxLDQ1IEBAIFNDTV9ERUZJTkUgKHNjbV9zdGF0LCAic3RhdCIs IDEsIDEsIDAsCisgfQorICN1bmRlZiBGVU5DX05BTUUKKyAKKysjaWZkZWYgSEFWRV9GU1RBVEFU CisrU0NNX0RFRklORSAoc2NtX3N0YXRhdCwgInN0YXRhdCIsIDIsIDEsIDAsCisrICAgICAgICAg ICAgKFNDTSBkaXIsIFNDTSBmaWxlbmFtZSwgU0NNIGZsYWdzKSwKKysgICAgICAgICAgICAiTGlr ZSBAY29kZXtzdGF0fSwgYnV0IHJlc29sdmUgQHZhcntmaWxlbmFtZX0gcmVsYXRpdmUgdG8gdGhl XG4iCisrICAgICAgICAgICAgImRpcmVjdG9yeSByZWZlcnJlZCB0byBieSB0aGUgZmlsZSBwb3J0 IEB2YXJ7ZGlyfSBpbnN0ZWFkLlxuXG4iCisrICAgICAgICAgICAgIlRoZSBvcHRpb25hbCBhcmd1 bWVudCBAdmFye2ZsYWdzfSBhcmd1bWVudCBjYW4gYmVcbiIKKysgICAgICAgICAgICAiQGNvZGV7 QVRfU1lNTElOS19OT0ZPTExPV30sIGluIHdoaWNoIGNhc2UgQHZhcntmaWxlbmFtZX0gd2lsbFxu IgorKyAgICAgICAgICAgICJub3QgYmUgZGVyZWZlcmVuY2VkIGV2ZW4gaWYgaXQgaXMgYSBzeW1i b2xpYyBsaW5rLiIpCisrI2RlZmluZSBGVU5DX05BTUUgc19zY21fc3RhdGF0CisreworKyAgaW50 IHJ2OworKyAgaW50IGRpcl9mZGVzOworKyAgaW50IGNfZmxhZ3M7CisrICBzdHJ1Y3Qgc3RhdF9v cl9zdGF0NjQgc3RhdF90ZW1wOworKworKyAgaWYgKFNDTV9VTkJORFAgKGZsYWdzKSkKKysgICAg Y19mbGFncyA9IDA7CisrICBlbHNlCisrICAgIGNfZmxhZ3MgPSBzY21fdG9faW50IChmbGFncyk7 CisrCisrICBTQ01fVkFMSURBVEVfT1BGUE9SVCAoU0NNX0FSRzEsIGRpcik7CisrICBkaXJfZmRl cyA9IFNDTV9GUE9SVF9GREVTIChkaXIpOworKworKyAgU1RSSU5HX1NZU0NBTEwgKGZpbGVuYW1l LCBjX2ZpbGVuYW1lLAorKyAgICAgICAgICAgICAgICAgIHJ2ID0gZnN0YXRhdF9vcl9mc3RhdGF0 NjQgKGRpcl9mZGVzLCBjX2ZpbGVuYW1lLAorKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICZzdGF0X3RlbXAsIGNfZmxhZ3MpKTsKKysgIHNjbV9yZW1lbWJlcl91 cHRvX2hlcmVfMSAoZGlyKTsKKysgIGlmIChydiAhPSAwKQorKyAgICB7CisrICAgICAgaW50IGVu ID0gZXJybm87CisrICAgICAgU0NNX1NZU0VSUk9SX01TRyAoIn5BOiB+UyIsCisrICAgICAgICAg ICAgICAgICAgICAgICAgc2NtX2xpc3RfMiAoc2NtX3N0cmVycm9yIChzY21fZnJvbV9pbnQgKGVu KSksIGZpbGVuYW1lKSwKKysgICAgICAgICAgICAgICAgICAgICAgICBlbik7CisrICAgIH0KKysg IHJldHVybiBzY21fc3RhdDJzY20gKCZzdGF0X3RlbXApOworK30KKysjdW5kZWYgRlVOQ19OQU1F CisrI2VuZGlmIC8qIEhBVkVfRlNUQVRBVCAqLworKworIFNDTV9ERUZJTkUgKHNjbV9sc3RhdCwg ImxzdGF0IiwgMSwgMCwgMCwgCisgICAgICAgICAgICAgKFNDTSBzdHIpLAorIAkgICAgIlNpbWls YXIgdG8gQGNvZGV7c3RhdH0sIGJ1dCBkb2VzIG5vdCBmb2xsb3cgc3ltYm9saWMgbGlua3MsIGku ZS4sXG4iCitkaWZmIC0tZ2l0IGEvbGliZ3VpbGUvZmlsZXN5cy5oIGIvbGliZ3VpbGUvZmlsZXN5 cy5oCitpbmRleCA3NjczYzgwNTEuLjhhZjBmOTg5YSAxMDA2NDQKKy0tLSBhL2xpYmd1aWxlL2Zp bGVzeXMuaAorKysrIGIvbGliZ3VpbGUvZmlsZXN5cy5oCitAQCAtNDgsNiArNDgsNyBAQCBTQ01f QVBJIFNDTSBzY21fb3BlbiAoU0NNIHBhdGgsIFNDTSBmbGFncywgU0NNIG1vZGUpOworIFNDTV9B UEkgU0NNIHNjbV9jbG9zZSAoU0NNIGZkX29yX3BvcnQpOworIFNDTV9BUEkgU0NNIHNjbV9jbG9z ZV9mZGVzIChTQ00gZmQpOworIFNDTV9BUEkgU0NNIHNjbV9zdGF0IChTQ00gb2JqZWN0LCBTQ00g ZXhjZXB0aW9uX29uX2Vycm9yKTsKKytTQ01fQVBJIFNDTSBzY21fc3RhdGF0IChTQ00gZGlyLCBT Q00gZmlsZW5hbWUsIFNDTSBmbGFncyk7CisgU0NNX0FQSSBTQ00gc2NtX2xpbmsgKFNDTSBvbGRw YXRoLCBTQ00gbmV3cGF0aCk7CisgU0NNX0FQSSBTQ00gc2NtX3JlbmFtZSAoU0NNIG9sZG5hbWUs IFNDTSBuZXduYW1lKTsKKyBTQ01fQVBJIFNDTSBzY21fcmVuYW1lYXQgKFNDTSBvbGRkaXIsIFND TSBvbGRuYW1lLCBTQ00gbmV3ZGlyLCBTQ00gbmV3bmFtZSk7CitkaWZmIC0tZ2l0IGEvbGliZ3Vp bGUvc3lzY2FsbHMuaCBiL2xpYmd1aWxlL3N5c2NhbGxzLmgKK2luZGV4IDMwYjk5YzE5My4uMzdk NTMyZTYwIDEwMDY0NAorLS0tIGEvbGliZ3VpbGUvc3lzY2FsbHMuaAorKysrIGIvbGliZ3VpbGUv c3lzY2FsbHMuaAorQEAgLTY1LDYgKzY1LDcgQEAKKyAjIGRlZmluZSByZWFkZGlyX3Jfb3JfcmVh ZGRpcjY0X3IgICAgICAgcmVhZGRpcl9yCisgI2VuZGlmCisgI2RlZmluZSBzdGF0X29yX3N0YXQ2 NCAgICAgICAgICAgICAgICAgIENIT09TRV9MQVJHRUZJTEUoc3RhdCxzdGF0NjQpCisrI2RlZmlu ZSBmc3RhdGF0X29yX2ZzdGF0YXQ2NCAgICAgICAgICAgIENIT09TRV9MQVJHRUZJTEUoZnN0YXRh dCxmc3RhdGF0NjQpCisgI2RlZmluZSB0cnVuY2F0ZV9vcl90cnVuY2F0ZTY0ICAgICAgICAgIENI T09TRV9MQVJHRUZJTEUodHJ1bmNhdGUsdHJ1bmNhdGU2NCkKKyAjZGVmaW5lIHNjbV9mcm9tX29m Zl90X29yX29mZjY0X3QgICAgICAgQ0hPT1NFX0xBUkdFRklMRShzY21fZnJvbV9vZmZfdCxzY21f ZnJvbV9pbnQ2NCkKKyAjZGVmaW5lIHNjbV9mcm9tX2lub190X29yX2lubzY0X3QgICAgICAgQ0hP T1NFX0xBUkdFRklMRShzY21fZnJvbV91bG9uZyxzY21fZnJvbV91aW50NjQpCitkaWZmIC0tZ2l0 IGEvdGVzdC1zdWl0ZS90ZXN0cy9maWxlc3lzLnRlc3QgYi90ZXN0LXN1aXRlL3Rlc3RzL2ZpbGVz eXMudGVzdAoraW5kZXggMzNiNjhlMTZkLi5iNzk0YjA3YjMgMTAwNjQ0CistLS0gYS90ZXN0LXN1 aXRlL3Rlc3RzL2ZpbGVzeXMudGVzdAorKysrIGIvdGVzdC1zdWl0ZS90ZXN0cy9maWxlc3lzLnRl c3QKK0BAIC0xMzQsNiArMTM0LDg2IEBACisgCShjbG9zZS1wb3J0IHBvcnQpCisgCShlcXY/IDUg KHN0YXQ6c2l6ZSBzdCkpKSkpKQorIAorKyh3aXRoLXRlc3QtcHJlZml4ICJzdGF0YXQiCisrICA7 OyBmaWxlLWV4aXN0cz8gZnJvbSAoaWNlLTkgYm9vdCkgZGVyZWZlcmVuY2VzIHN5bWJvbGljIGxp bmtzCisrICA7OyAoYSBidWc/KS4KKysgIChkZWZpbmUgKGZpbGUtZXhpc3RzPyBmaWxlbmFtZSkK KysgICAgKGNhdGNoICdzeXN0ZW0tZXJyb3IKKysgICAgICAobGFtYmRhICgpIChsc3RhdCBmaWxl bmFtZSkgI3QpCisrICAgICAgKGxhbWJkYSBhcmdzCisrICAgICAgICAoaWYgKD0gKHN5c3RlbS1l cnJvci1lcnJubyBhcmdzKSBFTk9FTlQpCisrICAgICAgICAgICAgOzsgRm9yIHRoZSBwdXJwb3Nl cyBvZiB0aGUgZm9sbG93aW5nIHRlc3RzLAorKyAgICAgICAgICAgIDs7IGl0IGlzIHNhZmUgdG8g aWdub3JlIGVycm9ycyBsaWtlIEVQRVJNLCBidXQgYSBjb3JyZWN0CisrICAgICAgICAgICAgOzsg aW1wbGVtZW50YXRpb24gd291bGQgcmV0dXJuICN0IGZvciB0aGF0IGVycm9yLgorKyAgICAgICAg ICAgICNmCisrICAgICAgICAgICAgKGFwcGx5IHRocm93ICBhcmdzKSkpKSkKKysgIChkZWZpbmUg KG1heWJlLWRlbGV0ZS1kaXJlY3RvcnkpCisrICAgICh3aGVuIChmaWxlLWV4aXN0cz8gKHRlc3Qt ZGlyZWN0b3J5KSkKKysgICAgICAoZm9yLWVhY2gKKysgICAgICAgKGxhbWJkYSAoZmlsZW5hbWUp CisrICAgICAgICAgKGRlZmluZSBmdWxsLW5hbWUgKGluLXZpY2luaXR5ICh0ZXN0LWRpcmVjdG9y eSkgZmlsZW5hbWUpKQorKyAgICAgICAgICh3aGVuIChmaWxlLWV4aXN0cz8gZnVsbC1uYW1lKQor KyAgICAgICAgICAgKGRlbGV0ZS1maWxlIGZ1bGwtbmFtZSkpKQorKyAgICAgICAnKCJ0ZXN0LWZp bGUiICJ0ZXN0LXN5bWxpbmsiKSkKKysgICAgICAocm1kaXIgKHRlc3QtZGlyZWN0b3J5KSkpKQor KyAgKGRlZmluZSAoc2tpcC11bmxlc3MtZGVmaW5lZCAuIHRoaW5ncykKKysgICAgKGZvci1lYWNo IChsYW1iZGEgKHRoaW5nKQorKyAgICAgICAgICAgICAgICAodW5sZXNzIChkZWZpbmVkPyB0aGlu ZykKKysgICAgICAgICAgICAgICAgICAodGhyb3cgJ3Vuc3VwcG9ydGVkKSkpCisrICAgICAgICAg ICAgICB0aGluZ3MpKQorKyAgKG1heWJlLWRlbGV0ZS1kaXJlY3RvcnkpCisrICAobWtkaXIgKHRl c3QtZGlyZWN0b3J5KSkKKysgIChjYWxsLXdpdGgtb3V0cHV0LWZpbGUgKGluLXZpY2luaXR5ICh0 ZXN0LWRpcmVjdG9yeSkgInRlc3QtZmlsZSIpCisrICAgIChsYW1iZGEgKHBvcnQpCisrICAgICAg KGRpc3BsYXkgImhlbGxvIiBwb3J0KSkpCisrCisrICA7OyBSZXR1cm4gI3RydWUgaWYgdGhlIHN5 bWxpbmsgd2FzIGNyZWF0ZWQsICNmYWxzZSBvdGhlcndpc2UuCisrICAoZGVmaW5lIChtYXliZS1j cmVhdGUtc3ltbGluaykKKysgICAgKGlmIChmaWxlLWV4aXN0cz8gKGluLXZpY2luaXR5ICh0ZXN0 LWRpcmVjdG9yeSkgInRlc3Qtc3ltbGluayIpKQorKyAgICAgICAgI3QKKysgICAgICAgIChmYWxz ZS1pZi1leGNlcHRpb24KKysgICAgICAgICAoc3ltbGluayAidGVzdC1maWxlIgorKyAgICAgICAg ICAgICAgICAgIChpbi12aWNpbml0eSAodGVzdC1kaXJlY3RvcnkpICJ0ZXN0LXN5bWxpbmsiKSkp KSkKKysKKysgIChwYXNzLWlmLWVxdWFsICJyZWd1bGFyIGZpbGUiIDUKKysgICAgKHNraXAtdW5s ZXNzLWRlZmluZWQgJ3N0YXRhdCkKKysgICAgKGNhbGwtd2l0aC1wb3J0CisrICAgICAob3BlbiAo dGVzdC1kaXJlY3RvcnkpIE9fUkRPTkxZKQorKyAgICAgKGxhbWJkYSAocG9ydCkKKysgICAgICAg KHN0YXQ6c2l6ZSAoc3RhdGF0IHBvcnQgInRlc3QtZmlsZSIpKSkpKQorKworKyAgKHBhc3MtaWYt ZXF1YWwgInJlZ3VsYXIgZmlsZSwgQVRfU1lNTElOS19OT0ZPTExPVyIgNQorKyAgICAoc2tpcC11 bmxlc3MtZGVmaW5lZCAnc3RhdGF0ICdBVF9TWU1MSU5LX05PRk9MTE9XKQorKyAgICAoY2FsbC13 aXRoLXBvcnQKKysgICAgIChvcGVuICh0ZXN0LWRpcmVjdG9yeSkgT19SRE9OTFkpCisrICAgICAo bGFtYmRhIChwb3J0KQorKyAgICAgICAoc3RhdDpzaXplIChzdGF0YXQgcG9ydCAidGVzdC1maWxl IiBBVF9TWU1MSU5LX05PRk9MTE9XKSkpKSkKKysKKysgIChwYXNzLWlmLWVxdWFsICJzeW1ib2xp YyBsaW5rcyBhcmUgZGVyZWZlcmVuY2VkIiAnKHJlZ3VsYXIgNSkKKysgICAgOzsgTm90IGFsbCBz eXN0ZW1zIHN1cHBvcnQgc3ltbGlua3MuCisrICAgIChza2lwLXVubGVzcy1kZWZpbmVkICdzdGF0 YXQgJ3N5bWxpbmspCisrICAgICh1bmxlc3MgKG1heWJlLWNyZWF0ZS1zeW1saW5rKQorKyAgICAg ICh0aHJvdyAndW5yZXNvbHZlZCkpCisrICAgIChjYWxsLXdpdGgtcG9ydAorKyAgICAgKG9wZW4g KHRlc3QtZGlyZWN0b3J5KSBPX1JET05MWSkKKysgICAgIChsYW1iZGEgKHBvcnQpCisrICAgICAg IChkZWZpbmUgcmVzdWx0IChzdGF0YXQgcG9ydCAidGVzdC1zeW1saW5rIikpCisrICAgICAgIChs aXN0IChzdGF0OnR5cGUgcmVzdWx0KSAoc3RhdDpzaXplIHJlc3VsdCkpKSkpCisrCisrICAocGFz cy1pZi1lcXVhbCAic3ltYm9saWMgbGlua3MgYXJlIG5vdCBkZXJlZmVyZW5jZWQiCisrICAgICAg YChzeW1saW5rICwoc3RyaW5nLWxlbmd0aCAidGVzdC1maWxlIikpCisrICAgIDs7IE5vdCBhbGwg c3lzdGVtcyBzdXBwb3J0IHN5bWxpbmtzLgorKyAgICAoc2tpcC11bmxlc3MtZGVmaW5lZCAnc3Rh dGF0ICdzeW1saW5rKQorKyAgICAodW5sZXNzIChtYXliZS1jcmVhdGUtc3ltbGluaykKKysgICAg ICAodGhyb3cgJ3VucmVzb2x2ZWQpKQorKyAgICAoY2FsbC13aXRoLXBvcnQKKysgICAgIChvcGVu ICh0ZXN0LWRpcmVjdG9yeSkgT19SRE9OTFkpCisrICAgICAobGFtYmRhIChwb3J0KQorKyAgICAg ICAoZGVmaW5lIHJlc3VsdCAoc3RhdGF0IHBvcnQgInRlc3Qtc3ltbGluayIgQVRfU1lNTElOS19O T0ZPTExPVykpCisrICAgICAgIChsaXN0IChzdGF0OnR5cGUgcmVzdWx0KSAoc3RhdDpzaXplIHJl c3VsdCkpKSkpCisrCisrICAobWF5YmUtZGVsZXRlLWRpcmVjdG9yeSkpCisrCisgKHdpdGgtdGVz dC1wcmVmaXggInNlbmRmaWxlIgorIAorICAgKGxldCogKChmaWxlIChzZWFyY2gtcGF0aCAlbG9h ZC1wYXRoICJpY2UtOS9ib290LTkuc2NtIikpCistLSAKKzIuMzAuMgorCisKZGlmZiAtLWdpdCBh L2dudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0xMy5wYXRjaCBi L2dudS9wYWNrYWdlcy9wYXRjaGVzL2d1aWxlLW9wZW5hdC1hbmQtZnJpZW5kcy0xMy5wYXRjaApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwLi42ZjljMmM1YjRlCi0tLSAvZGV2 L251bGwKKysrIGIvZ251L3BhY2thZ2VzL3BhdGNoZXMvZ3VpbGUtb3BlbmF0LWFuZC1mcmllbmRz LTEzLnBhdGNoCkBAIC0wLDAgKzEsMzE0IEBACitHdWl4LVVwc3RyZWFtOiBodHRwczovL2xpc3Rz LmdudS5vcmcvYXJjaGl2ZS9odG1sL2d1aWxlLWRldmVsLzIwMjEtMTEvbXNnMDAwMDUuaHRtbAor RnJvbTogTWF4aW1lIERldm9zIDxtYXhpbWVkZXZvc0B0ZWxlbmV0LmJlPgorU3ViamVjdDogW1BB VENIIHYyIDEzLzE0XSA9P1VURi04P3E/RGVmaW5lPTIwU2NoZW1lPTIwYmluZGluZ3M9MjB0bz0y MD89CisgPT9VVEYtOD9xPz1FMj04MD05OG9wZW5hdD1FMj04MD05OT0yMHdoZW49MjBhdmFpbGFi bGUuPz0KK0RhdGU6IFR1ZSwgMTYgTm92IDIwMjEgMTE6MDY6MzYgKzAwMDAKK01lc3NhZ2UtSWQ6 IDwyMDIxMTExNjExMDYzNy4xMjU1NzktMTQtbWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4KK0luLVJl cGx5LVRvOiA8MjAyMTExMTYxMTA2MzcuMTI1NTc5LTEtbWF4aW1lZGV2b3NAdGVsZW5ldC5iZT4K K1JlZmVyZW5jZXM6IDwxNzVjM2E2NTcyZTgzMmQ4NDkyNzkzN2IzMDlhMzA5NWNhZGY1NzAyLmNh bWVsQHRlbGVuZXQuYmU+CisgPDIwMjExMTE2MTEwNjM3LjEyNTU3OS0xLW1heGltZWRldm9zQHRl bGVuZXQuYmU+CitNSU1FLVZlcnNpb246IDEuMAorQ29udGVudC1UeXBlOiB0ZXh0L3BsYWluOyBj aGFyc2V0PVVURi04CitDb250ZW50LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0CisKKyogY29uZmln dXJlLmFjOiBEZXRlY3QgaWYg4oCYb3BlbmF04oCZIGlzIGRlZmluZWQuCisqIGxpYmd1aWxlL2Zp bGVzeXMuYworICAoZmxhZ3NfdG9fbW9kZSk6IEV4dHJhY3QgZnJvbSAuLi4KKyAgKHNjbV9tb2Rl KTogLi4uIGhlcmUuCisgIChzY21fb3Blbl9mZGVzX2F0LCBzY21fb3BlbmF0KTogRGVmaW5lIHRo ZSBTY2hlbWUgYmluZGluZ3MuCisqIGxpYmd1aWxlL2ZpbGVzeXMuaCAoc2NtX29wZW5fZmRlc19h dCwgc2NtX29wZW5hdCk6IE1ha2UgdGhlbSBwYXJ0CisgIG9mIHRoZSBBUEkuCisqIGRvYy9yZWYv cG9zaXgudGV4aSAoRmlsZSBTeXN0ZW0pOiBEb2N1bWVudCB0aGVtLgorKiB0ZXN0LXN1aXRlL3Rl c3RzL2ZpbGVzeXMudGVzdCAoIm9wZW5hdCIpOiBUZXN0IOKAmG9wZW5hdOKAmS4KKyogbGliZ3Vp bGUvc3lzY2FsbHMuaCAob3BlbmF0X29yX29wZW5hdDY0KTogRGVjaWRlIGJldHdlZW4g4oCYb3Bl bmF04oCZCisgIGFuZCDigJhvcGVuYXQ2NOKAmS4KKy0tLQorIGNvbmZpZ3VyZS5hYyAgICAgICAg ICAgICAgICAgIHwgIDMgKy0KKyBkb2MvcmVmL3Bvc2l4LnRleGkgICAgICAgICAgICB8IDEzICsr KysrCisgbGliZ3VpbGUvZmlsZXN5cy5jICAgICAgICAgICAgfCA5NiArKysrKysrKysrKysrKysr KysrKysrKysrKystLS0tLS0tLQorIGxpYmd1aWxlL2ZpbGVzeXMuaCAgICAgICAgICAgIHwgIDIg KworIGxpYmd1aWxlL3N5c2NhbGxzLmggICAgICAgICAgIHwgIDEgKworIHRlc3Qtc3VpdGUvdGVz dHMvZmlsZXN5cy50ZXN0IHwgNzMgKysrKysrKysrKysrKysrKysrKysrKysrKysKKyA2IGZpbGVz IGNoYW5nZWQsIDE2NyBpbnNlcnRpb25zKCspLCAyMSBkZWxldGlvbnMoLSkKKworZGlmZiAtLWdp dCBhL2NvbmZpZ3VyZS5hYyBiL2NvbmZpZ3VyZS5hYworaW5kZXggZTA3M2UwNGY0Li45MDVlNGQ0 NjUgMTAwNjQ0CistLS0gYS9jb25maWd1cmUuYWMKKysrKyBiL2NvbmZpZ3VyZS5hYworQEAgLTQ3 OCw3ICs0NzgsNyBAQCBBQ19DSEVDS19IRUFERVJTKFthc3NlcnQuaCBjcnRfZXh0ZXJucy5oXSkK KyAjICAgaXNibGFuayAtIGF2YWlsYWJsZSBhcyBhIEdOVSBleHRlbnNpb24gb3IgaW4gQzk5Cisg IyAgIF9OU0dldEVudmlyb24gLSBEYXJ3aW4gc3BlY2lmaWMKKyAjICAgc3RyY29sbF9sLCBuZXds b2NhbGUsIHVzZWxvY2FsZSwgdXRpbWVuc2F0LCBmdXRpbWVucywgZmNobW9kYXQsCistIyAgIHVu bGlua2F0LCBmY2hvd25hdCwgZnN0YXRhdCAtIFBPU0lYLjEtMjAwOAorKyMgICB1bmxpbmthdCwg ZmNob3duYXQsIGZzdGF0YXQsIG9wZW5hdCAtIFBPU0lYLjEtMjAwOAorICMgICBzdHJ0b2xfbCAt IG5vbi1QT1NJWCwgZm91bmQgaW4gZ2xpYmMKKyAjICAgZm9yayAtIHVuYXZhaWxhYmxlIG9uIFdp bmRvd3MKKyAjICAgc2NoZWRfZ2V0YWZmaW5pdHksIHNjaGVkX3NldGFmZmluaXR5IC0gR05VIGV4 dGVuc2lvbnMgKGdsaWJjKQorQEAgLTQ5NSw2ICs0OTUsNyBAQCBBQ19DSEVDS19GVU5DUyhbRElO RklOSVRZIERRTkFOIGNleHAgY2hzaXplIGNsb2cgY2xvZzEwIGN0ZXJtaWQgICAgICAgICBcCisg ICBnZXRncmVudCBraWxsIGdldHBwaWQgZ2V0cGdycCBmb3JrIHNldGl0aW1lciBnZXRpdGltZXIg c3RyY2hyIHN0cmNtcCAgXAorICAgaW5kZXggYmNvcHkgbWVtY3B5IHJpbmRleCB0cnVuY2F0ZSBp c2JsYW5rIF9OU0dldEVudmlyb24gICAgICAgICAgICAgIFwKKyAgIHN0cmNvbGwgc3RyY29sbF9s IHN0cnRvZF9sIHN0cnRvbF9sIG5ld2xvY2FsZSB1c2Vsb2NhbGUgdXRpbWVuc2F0ICAgICBcCisr ICBvcGVuYXQgXAorICAgZnN0YXRhdCBmdXRpbWVucyBzY2hlZF9nZXRhZmZpbml0eSBzY2hlZF9z ZXRhZmZpbml0eSBzZW5kZmlsZV0pCisgCisgIyBUaGUgbmV3bGliIEMgbGlicmFyeSB1c2VzIF9O TF8gcHJlZml4ZWQgbG9jYWxlIGxhbmdpbmZvIGNvbnN0YW50cy4KK2RpZmYgLS1naXQgYS9kb2Mv cmVmL3Bvc2l4LnRleGkgYi9kb2MvcmVmL3Bvc2l4LnRleGkKK2luZGV4IGNkZDAzZjE0MS4uMzYx OWVlMmMzIDEwMDY0NAorLS0tIGEvZG9jL3JlZi9wb3NpeC50ZXhpCisrKysgYi9kb2MvcmVmL3Bv c2l4LnRleGkKK0BAIC0yOTYsMTIgKzI5NiwyNSBAQCBDcmVhdGUgdGhlIGZpbGUgaWYgaXQgZG9l cyBub3QgYWxyZWFkeSBleGlzdC4KKyBmb3IgYWRkaXRpb25hbCBmbGFncy4KKyBAZW5kIGRlZmZu CisgCisrQGRlZmZuIHtTY2hlbWUgUHJvY2VkdXJlfSBvcGVuYXQgZGlyIHBhdGggZmxhZ3MgW21v ZGVdCisrQGRlZmZueCB7QyBGdW5jdGlvbn0gc2NtX29wZW5hdCAoZGlyLCBwYXRoLCBmbGFncywg bW9kZSkKKytTaW1pbGFyIHRvIEBjb2Rle29wZW59LCBidXQgcmVzb2x2ZSB0aGUgZmlsZSBuYW1l IEB2YXJ7cGF0aH0KKytyZWxhdGl2ZSB0byB0aGUgZGlyZWN0b3J5IHJlZmVycmVkIHRvIGJ5IHRo ZSBmaWxlIHBvcnQgQHZhcntkaXJ9CisraW5zdGVhZC4KKytAZW5kIGRlZmZuCisrCisgQGRlZmZu IHtTY2hlbWUgUHJvY2VkdXJlfSBvcGVuLWZkZXMgcGF0aCBmbGFncyBbbW9kZV0KKyBAZGVmZm54 IHtDIEZ1bmN0aW9ufSBzY21fb3Blbl9mZGVzIChwYXRoLCBmbGFncywgbW9kZSkKKyBTaW1pbGFy IHRvIEBjb2Rle29wZW59IGJ1dCByZXR1cm4gYSBmaWxlIGRlc2NyaXB0b3IgaW5zdGVhZCBvZgor IGEgcG9ydC4KKyBAZW5kIGRlZmZuCisgCisrQGRlZmZuIHtTY2hlbWUgUHJvY2VkdXJlfSBvcGVu LWZkZXMtYXQgZGlyIHBhdGggZmxhZ3MgW21vZGVdCisrQGRlZmZueCB7QyBGdW5jdGlvbn0gc2Nt X29wZW5fZmRlc19hdCAoZGlyLCBwYXRoLCBmbGFncywgbW9kZSkKKytTaW1pbGFyIHRvIEBjb2Rl e29wZW5hdH0sIGJ1dCByZXR1cm4gYSBmaWxlIGRlc2NyaXB0b3IgaW5zdGVhZAorK29mIGEgcG9y dC4KKytAZW5kIGRlZmZuCisrCisgQGRlZmZuIHtTY2hlbWUgUHJvY2VkdXJlfSBjbG9zZSBmZF9v cl9wb3J0CisgQGRlZmZueCB7QyBGdW5jdGlvbn0gc2NtX2Nsb3NlIChmZF9vcl9wb3J0KQorIFNp bWlsYXIgdG8gQGNvZGV7Y2xvc2UtcG9ydH0gKEBweHJlZntQb3J0cywgY2xvc2UtcG9ydH0pLAor ZGlmZiAtLWdpdCBhL2xpYmd1aWxlL2ZpbGVzeXMuYyBiL2xpYmd1aWxlL2ZpbGVzeXMuYworaW5k ZXggZDA0NWE2NzJmLi5kYWRiZTMzOTMgMTAwNjQ0CistLS0gYS9saWJndWlsZS9maWxlc3lzLmMK KysrKyBiL2xpYmd1aWxlL2ZpbGVzeXMuYworQEAgLTI0OSw2ICsyNDksNjAgQEAgU0NNX0RFRklO RSAoc2NtX29wZW5fZmRlcywgIm9wZW4tZmRlcyIsIDIsIDEsIDAsCisgfQorICN1bmRlZiBGVU5D X05BTUUKKyAKKysjaWZkZWYgSEFWRV9PUEVOQVQKKytTQ01fREVGSU5FIChzY21fb3Blbl9mZGVz X2F0LCAib3Blbi1mZGVzLWF0IiwgMywgMSwgMCwKKysgICAgICAgICAgICAoU0NNIGRpciwgU0NN IHBhdGgsIFNDTSBmbGFncywgU0NNIG1vZGUpLAorKyAgICAgICAgICAgICJTaW1pbGFyIHRvIEBj b2Rle29wZW5hdH0sIGJ1dCByZXR1cm4gYSBmaWxlIGRlc2NyaXB0b3IgaW5zdGVhZFxuIgorKyAg ICAgICAgICAgICJvZiBhIHBvcnQuIikKKysjZGVmaW5lIEZVTkNfTkFNRSBzX3NjbV9vcGVuX2Zk ZXNfYXQKKyt7CisrICBpbnQgZGlyX2ZkZXM7CisrICBpbnQgZmQ7CisrICBpbnQgaWZsYWdzOwor KyAgaW50IGltb2RlOworKworKyAgaWZsYWdzID0gU0NNX05VTTJJTlQgKFNDTV9BUkcyLCBmbGFn cyk7CisrICBpbW9kZSA9IFNDTV9OVU0ySU5UX0RFRiAoMywgbW9kZSwgMDY2Nik7CisrICBTQ01f VkFMSURBVEVfT1BGUE9SVCAoU0NNX0FSRzEsIGRpcik7CisrICBkaXJfZmRlcyA9IFNDTV9GUE9S VF9GREVTIChkaXIpOworKworKyAgU1RSSU5HX1NZU0NBTEwgKHBhdGgsIGNfcGF0aCwKKysgICAg ICAgICAgICAgICAgICBmZCA9IG9wZW5hdF9vcl9vcGVuYXQ2NCAoZGlyX2ZkZXMsIGNfcGF0aCwg aWZsYWdzLCBpbW9kZSkpOworKyAgc2NtX3JlbWVtYmVyX3VwdG9faGVyZV8xIChkaXIpOworKyAg aWYgKGZkID09IC0xKQorKyAgICBTQ01fU1lTRVJST1I7CisrICByZXR1cm4gc2NtX2Zyb21faW50 IChmZCk7CisrfQorKyN1bmRlZiBGVU5DX05BTUUKKysjZW5kaWYgLyogSEFWRV9PUEVOQVQgKi8K KysKKysvKiBBIGhlbHBlciBmdW5jdGlvbiBmb3IgY29udmVydGluZyBzb21lIG9wZW4gZmxhZ3Mg dG8KKysgICB3aGF0IHNjbV9mZGVzX3RvX3BvcnQgZXhwZWN0cy4gKi8KKytzdGF0aWMgY2hhciAq CisrZmxhZ3NfdG9fbW9kZSAoaW50IGlmbGFncykKKyt7CisrICBpZiAoKGlmbGFncyAmIE9fUkRX UikgPT0gT19SRFdSKQorKyAgICB7CisrICAgICAgLyogT3BlbmVkIHJlYWQtd3JpdGUuICAqLwor KyAgICAgIGlmIChpZmxhZ3MgJiBPX0FQUEVORCkKKysJcmV0dXJuICJhKyI7CisrICAgICAgZWxz ZSBpZiAoaWZsYWdzICYgT19DUkVBVCkKKysJcmV0dXJuICJ3KyI7CisrICAgICAgZWxzZQorKwly ZXR1cm4gInIrIjsKKysgICAgfQorKyAgZWxzZQorKyAgICB7CisrICAgICAgLyogT3BlbmVkIHJl YWQtb25seSBvciB3cml0ZS1vbmx5LiAgKi8KKysgICAgICBpZiAoaWZsYWdzICYgT19BUFBFTkQp CisrCXJldHVybiAiYSI7CisrICAgICAgZWxzZSBpZiAoaWZsYWdzICYgT19XUk9OTFkpCisrCXJl dHVybiAidyI7CisrICAgICAgZWxzZQorKwlyZXR1cm4gInIiOworKyAgICB9CisrfQorKworIFND TV9ERUZJTkUgKHNjbV9vcGVuLCAib3BlbiIsIDIsIDEsIDAsIAorICAgICAgICAgICAgIChTQ00g cGF0aCwgU0NNIGZsYWdzLCBTQ00gbW9kZSksCisgCSAgICAiT3BlbiB0aGUgZmlsZSBuYW1lZCBi eSBAdmFye3BhdGh9IGZvciByZWFkaW5nIGFuZC9vciB3cml0aW5nLlxuIgorQEAgLTI4NSwzMSAr MzM5LDMzIEBAIFNDTV9ERUZJTkUgKHNjbV9vcGVuLCAib3BlbiIsIDIsIDEsIDAsCisgICBmZCA9 IHNjbV90b19pbnQgKHNjbV9vcGVuX2ZkZXMgKHBhdGgsIGZsYWdzLCBtb2RlKSk7CisgICBpZmxh Z3MgPSBTQ01fTlVNMklOVCAoMiwgZmxhZ3MpOworIAorLSAgaWYgKChpZmxhZ3MgJiBPX1JEV1Ip ID09IE9fUkRXUikKKy0gICAgeworLSAgICAgIC8qIE9wZW5lZCByZWFkLXdyaXRlLiAgKi8KKy0g ICAgICBpZiAoaWZsYWdzICYgT19BUFBFTkQpCistCXBvcnRfbW9kZSA9ICJhKyI7CistICAgICAg ZWxzZSBpZiAoaWZsYWdzICYgT19DUkVBVCkKKy0JcG9ydF9tb2RlID0gIncrIjsKKy0gICAgICBl bHNlCistCXBvcnRfbW9kZSA9ICJyKyI7CistICAgIH0KKy0gIGVsc2UKKy0gICAgeworLSAgICAg IC8qIE9wZW5lZCByZWFkLW9ubHkgb3Igd3JpdGUtb25seS4gICovCistICAgICAgaWYgKGlmbGFn cyAmIE9fQVBQRU5EKQorLQlwb3J0X21vZGUgPSAiYSI7CistICAgICAgZWxzZSBpZiAoaWZsYWdz ICYgT19XUk9OTFkpCistCXBvcnRfbW9kZSA9ICJ3IjsKKy0gICAgICBlbHNlCistCXBvcnRfbW9k ZSA9ICJyIjsKKy0gICAgfQorKyAgcG9ydF9tb2RlID0gKGNoYXIgKikgZmxhZ3NfdG9fbW9kZSAo aWZsYWdzKTsKKysgIG5ld3B0ID0gc2NtX2ZkZXNfdG9fcG9ydCAoZmQsIHBvcnRfbW9kZSwgcGF0 aCk7CisrICByZXR1cm4gbmV3cHQ7CisrfQorKyN1bmRlZiBGVU5DX05BTUUKKyAKKysjaWZkZWYg SEFWRV9PUEVOQVQKKytTQ01fREVGSU5FIChzY21fb3BlbmF0LCAib3BlbmF0IiwgMywgMSwgMCwK KysgICAgICAgICAgICAoU0NNIGRpciwgU0NNIHBhdGgsIFNDTSBmbGFncywgU0NNIG1vZGUpLAor KyAgICAgICAgICAgICJTaW1pbGFyIHRvIEBjb2Rle29wZW59LCBidXQgcmVzb2x2ZSB0aGUgZmls ZSBuYW1lIEB2YXJ7cGF0aH1cbiIKKysgICAgICAgICAgICAicmVsYXRpdmUgdG8gdGhlIGRpcmVj dG9yeSByZWZlcnJlZCB0byBieSB0aGUgZmlsZSBwb3J0IEB2YXJ7ZGlyfVxuIgorKyAgICAgICAg ICAgICJpbnN0ZWFkLiIpCisrI2RlZmluZSBGVU5DX05BTUUgc19zY21fb3BlbmF0CisreworKyAg U0NNIG5ld3B0OworKyAgY2hhciAqcG9ydF9tb2RlOworKyAgaW50IGZkOworKyAgaW50IGlmbGFn czsKKysKKysgIGlmbGFncyA9IFNDTV9OVU0ySU5UICgyLCBmbGFncyk7CisrICBwb3J0X21vZGUg PSAoY2hhciAqKSBmbGFnc190b19tb2RlIChpZmxhZ3MpOworKyAgZmQgPSBzY21fdG9faW50IChz Y21fb3Blbl9mZGVzX2F0IChkaXIsIHBhdGgsIGZsYWdzLCBtb2RlKSk7CisgICBuZXdwdCA9IHNj bV9mZGVzX3RvX3BvcnQgKGZkLCBwb3J0X21vZGUsIHBhdGgpOworICAgcmV0dXJuIG5ld3B0Owor IH0KKyAjdW5kZWYgRlVOQ19OQU1FCisrI2VuZGlmIC8qIEhBVkVfT1BFTkFUICovCisgCisgU0NN X0RFRklORSAoc2NtX2Nsb3NlLCAiY2xvc2UiLCAxLCAwLCAwLCAKKyAgICAgICAgICAgICAoU0NN IGZkX29yX3BvcnQpLAorZGlmZiAtLWdpdCBhL2xpYmd1aWxlL2ZpbGVzeXMuaCBiL2xpYmd1aWxl L2ZpbGVzeXMuaAoraW5kZXggOGFmMGY5ODlhLi4xY2U1MGQzMGUgMTAwNjQ0CistLS0gYS9saWJn dWlsZS9maWxlc3lzLmgKKysrKyBiL2xpYmd1aWxlL2ZpbGVzeXMuaAorQEAgLTQ0LDcgKzQ0LDkg QEAgU0NNX0FQSSBTQ00gc2NtX2NobW9kIChTQ00gb2JqZWN0LCBTQ00gbW9kZSk7CisgU0NNX0FQ SSBTQ00gc2NtX2NobW9kYXQgKFNDTSBkaXIsIFNDTSBwYXRobmFtZSwgU0NNIG1vZGUsIFNDTSBm bGFncyk7CisgU0NNX0FQSSBTQ00gc2NtX3VtYXNrIChTQ00gbW9kZSk7CisgU0NNX0FQSSBTQ00g c2NtX29wZW5fZmRlcyAoU0NNIHBhdGgsIFNDTSBmbGFncywgU0NNIG1vZGUpOworK1NDTV9BUEkg U0NNIHNjbV9vcGVuX2ZkZXNfYXQgKFNDTSBkaXIsIFNDTSBwYXRoLCBTQ00gZmxhZ3MsIFNDTSBt b2RlKTsKKyBTQ01fQVBJIFNDTSBzY21fb3BlbiAoU0NNIHBhdGgsIFNDTSBmbGFncywgU0NNIG1v ZGUpOworK1NDTV9BUEkgU0NNIHNjbV9vcGVuYXQgKFNDTSBkaXIsIFNDTSBwYXRoLCBTQ00gZmxh Z3MsIFNDTSBtb2RlKTsKKyBTQ01fQVBJIFNDTSBzY21fY2xvc2UgKFNDTSBmZF9vcl9wb3J0KTsK KyBTQ01fQVBJIFNDTSBzY21fY2xvc2VfZmRlcyAoU0NNIGZkKTsKKyBTQ01fQVBJIFNDTSBzY21f c3RhdCAoU0NNIG9iamVjdCwgU0NNIGV4Y2VwdGlvbl9vbl9lcnJvcik7CitkaWZmIC0tZ2l0IGEv bGliZ3VpbGUvc3lzY2FsbHMuaCBiL2xpYmd1aWxlL3N5c2NhbGxzLmgKK2luZGV4IDM3ZDUzMmU2 MC4uNmY0MDYxMTM4IDEwMDY0NAorLS0tIGEvbGliZ3VpbGUvc3lzY2FsbHMuaAorKysrIGIvbGli Z3VpbGUvc3lzY2FsbHMuaAorQEAgLTU4LDYgKzU4LDcgQEAKKyAjZGVmaW5lIGxzdGF0X29yX2xz dGF0NjQgICAgICAgICAgICAgICAgQ0hPT1NFX0xBUkdFRklMRShsc3RhdCxsc3RhdDY0KQorICNk ZWZpbmUgb2ZmX3Rfb3Jfb2ZmNjRfdCAgICAgICAgICAgICAgICBDSE9PU0VfTEFSR0VGSUxFKG9m Zl90LG9mZjY0X3QpCisgI2RlZmluZSBvcGVuX29yX29wZW42NCAgICAgICAgICAgICAgICAgIENI T09TRV9MQVJHRUZJTEUob3BlbixvcGVuNjQpCisrI2RlZmluZSBvcGVuYXRfb3Jfb3BlbmF0NjQg ICAgICAgICAgICAgIENIT09TRV9MQVJHRUZJTEUob3BlbmF0LG9wZW5hdDY0KQorICNkZWZpbmUg cmVhZGRpcl9vcl9yZWFkZGlyNjQgICAgICAgICAgICBDSE9PU0VfTEFSR0VGSUxFKHJlYWRkaXIs cmVhZGRpcjY0KQorICNpZiBTQ01fSEFWRV9SRUFERElSNjRfUiA9PSAxCisgIyBkZWZpbmUgcmVh ZGRpcl9yX29yX3JlYWRkaXI2NF9yICAgICAgIENIT09TRV9MQVJHRUZJTEUocmVhZGRpcl9yLHJl YWRkaXI2NF9yKQorZGlmZiAtLWdpdCBhL3Rlc3Qtc3VpdGUvdGVzdHMvZmlsZXN5cy50ZXN0IGIv dGVzdC1zdWl0ZS90ZXN0cy9maWxlc3lzLnRlc3QKK2luZGV4IGI3OTRiMDdiMy4uNDVlNzdjODIz IDEwMDY0NAorLS0tIGEvdGVzdC1zdWl0ZS90ZXN0cy9maWxlc3lzLnRlc3QKKysrKyBiL3Rlc3Qt c3VpdGUvdGVzdHMvZmlsZXN5cy50ZXN0CitAQCAtNzI4LDMgKzcyOCw3NiBAQAorICAgICAoc2tp cC1pZi11bnN1cHBvcnRlZCkKKyAgICAgKGRlbGV0ZS1maWxlLWF0IChjYWxsLXdpdGgtcG9ydCAo b3BlbiAiLiIgT19SRE9OTFkpIGlkZW50aXR5KQorICAgICAgICAgICAgICAgICAgICAgImlycmVs ZXZhbnQiKSkpCisrCisrKHdpdGgtdGVzdC1wcmVmaXggIm9wZW5hdCIKKysgIChkZWZpbmUgKHNr aXAtaWYtdW5zdXBwb3J0ZWQpCisrICAgICh1bmxlc3MgKGRlZmluZWQ/ICdvcGVuYXQpCisrICAg ICAgKHRocm93ICd1bnN1cHBvcnRlZCkpKQorKworKyAgKGRlZmluZSBmaWxlIChzZWFyY2gtcGF0 aCAlbG9hZC1wYXRoICJpY2UtOS9ib290LTkuc2NtIikpCisrCisrICAoZGVmaW5lIChjYWxsLXdp dGgtcmVsYXRpdmVseS1vcGVuZWQtZmlsZSBkaXJlY3RvcnktYXJndW1lbnRzIGZpbGUtYXJndW1l bnRzCisrICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwcm9jKQor KyAgICAoY2FsbC13aXRoLXBvcnQKKysgICAgIChhcHBseSBvcGVuIGRpcmVjdG9yeS1hcmd1bWVu dHMpCisrICAgICAobGFtYmRhIChkaXJlY3RvcnkpCisrICAgICAgIChjYWxsLXdpdGgtcG9ydAor KyAgICAgICAgKGFwcGx5IG9wZW5hdCBkaXJlY3RvcnkgZmlsZS1hcmd1bWVudHMpCisrICAgICAg ICAobGFtYmRhIChwb3J0KQorKyAgICAgICAgICAocHJvYyBwb3J0KSkpKSkpCisrCisrICAocGFz cy1pZi1lcXVhbCAibW9kZSByZWFkLW9ubHkiICJyIgorKyAgICAoc2tpcC1pZi11bnN1cHBvcnRl ZCkKKysgICAgKGNhbGwtd2l0aC1yZWxhdGl2ZWx5LW9wZW5lZC1maWxlCisrICAgICAobGlzdCAo ZGlybmFtZSBmaWxlKSBPX1JET05MWSkKKysgICAgIChsaXN0IChiYXNlbmFtZSBmaWxlKSBPX1JE T05MWSkKKysgICAgIChsYW1iZGEgKHBvcnQpIChwb3J0LW1vZGUgcG9ydCkpKSkKKysKKysgIChw YXNzLWlmLWVxdWFsICJwb3J0LXJldmVhbGVkIGNvdW50IiAwCisrICAgIChza2lwLWlmLXVuc3Vw cG9ydGVkKQorKyAgICAoY2FsbC13aXRoLXJlbGF0aXZlbHktb3BlbmVkLWZpbGUKKysgICAgIChs aXN0IChkaXJuYW1lIGZpbGUpIE9fUkRPTkxZKQorKyAgICAgKGxpc3QgKGJhc2VuYW1lIGZpbGUp IE9fUkRPTkxZKQorKyAgICAgKGxhbWJkYSAocG9ydCkgKHBvcnQtcmV2ZWFsZWQgcG9ydCkpKSkK KysKKysgICh3aGVuIChmaWxlLWV4aXN0cz8gKHRlc3QtZmlsZSkpCisrICAgIChkZWxldGUtZmls ZSAodGVzdC1maWxlKSkpCisrCisrICAocGFzcy1pZi1lcXVhbCAiT19DUkVBVC9PX1dST05MWSIg KGxpc3QgI3QgKGxvZ2FuZCAobG9nbm90ICh1bWFzaykpICNvNjY2KSAidyIpCisrICAgIChza2lw LWlmLXVuc3VwcG9ydGVkKQorKyAgICAoY2FsbC13aXRoLXJlbGF0aXZlbHktb3BlbmVkLWZpbGUK KysgICAgIChsaXN0IChkaXJuYW1lICh0ZXN0LWZpbGUpKSBPX1JET05MWSkKKysgICAgIChsaXN0 IChiYXNlbmFtZSAodGVzdC1maWxlKSkgKGxvZ2lvciBPX1dST05MWSBPX0NSRUFUKSkKKysgICAg IChsYW1iZGEgKHBvcnQpCisrICAgICAgIChsaXN0IChmaWxlLWV4aXN0cz8gKHRlc3QtZmlsZSkp CisrICAgICAgICAgICAgIChzdGF0OnBlcm1zIChzdGF0ICh0ZXN0LWZpbGUpKSkKKysgICAgICAg ICAgICAgKHBvcnQtbW9kZSBwb3J0KSkpKSkKKysKKysgICh3aGVuIChmaWxlLWV4aXN0cz8gKHRl c3QtZmlsZSkpCisrICAgIChkZWxldGUtZmlsZSAodGVzdC1maWxlKSkpCisrCisrICAocGFzcy1p Zi1lcXVhbCAiT19DUkVBVC9PX1dST05MWSwgbm9uLWRlZmF1bHQgbW9kZSIKKysgICAgICAobGlz dCAjdCAobG9nYW5kIChsb2dub3QgKHVtYXNrKSkgI283MDApICJ3IikKKysgICAgKHNraXAtaWYt dW5zdXBwb3J0ZWQpCisrICAgIChjYWxsLXdpdGgtcmVsYXRpdmVseS1vcGVuZWQtZmlsZQorKyAg ICAgKGxpc3QgKGRpcm5hbWUgKHRlc3QtZmlsZSkpIE9fUkRPTkxZKQorKyAgICAgKGxpc3QgKGJh c2VuYW1lICh0ZXN0LWZpbGUpKSAobG9naW9yIE9fV1JPTkxZIE9fQ1JFQVQpICNvNzAwKQorKyAg ICAgKGxhbWJkYSAocG9ydCkKKysgICAgICAgKGxpc3QgKGZpbGUtZXhpc3RzPyAodGVzdC1maWxl KSkKKysgICAgICAgICAgICAgKHN0YXQ6cGVybXMgKHN0YXQgKHRlc3QtZmlsZSkpKQorKyAgICAg ICAgICAgICAocG9ydC1tb2RlIHBvcnQpKSkpKQorKworKyAgKHBhc3MtaWYtZXhjZXB0aW9uICJj bG9zZWQgcG9ydCIgZXhjZXB0aW9uOndyb25nLXR5cGUtYXJnCisrICAgIChza2lwLWlmLXVuc3Vw cG9ydGVkKQorKyAgICAob3BlbmF0IChjYWxsLXdpdGgtcG9ydCAob3BlbiAiLiIgT19SRE9OTFkp IGlkZW50aXR5KSAiLiIgT19SRE9OTFkpKQorKworKyAgKHBhc3MtaWYtZXhjZXB0aW9uICJub24t ZmlsZSBwb3J0IiBleGNlcHRpb246d3JvbmctdHlwZS1hcmcKKysgICAgKHNraXAtaWYtdW5zdXBw b3J0ZWQpCisrICAgIChvcGVuYXQgKG9wZW4taW5wdXQtc3RyaW5nICIiKSAiLiIgT19SRE9OTFkp KQorKworKyAgKHBhc3MtaWYtZXhjZXB0aW9uICJub3QgYSBwb3J0IiBleGNlcHRpb246d3Jvbmct dHlwZS1hcmcKKysgICAgKHNraXAtaWYtdW5zdXBwb3J0ZWQpCisrICAgIChvcGVuYXQgIm5vdCBh IHBvcnQiICIuIiBPX1JET05MWSkpCisrCisrICAod2hlbiAoZmlsZS1leGlzdHM/ICh0ZXN0LWZp bGUpKQorKyAgICAoZGVsZXRlLWZpbGUgKHRlc3QtZmlsZSkpKSkKKy0tIAorMi4zMC4yCisKKwoK YmFzZS1jb21taXQ6IDI5MDkxNzMxYTBjNmNiNjQ5Y2RmZDcyMjk3NTc1ZmUyYmIyYTk1OTEKcHJl cmVxdWlzaXRlLXBhdGNoLWlkOiBlMmZhZjVjZGY3MmYyOTNhY2EwYWZmNWM4OWNjMWYwZGQ4NzRk MjljCnByZXJlcXVpc2l0ZS1wYXRjaC1pZDogNzIyODVjMjIzMmUwOWJjMTYzN2MxNzRiNDQ4OWUx M2JiNzZjMDQyNwotLSAKMi4zMC4yCgo= --=-yubAqj78CxTHWr8cQJRG-- --=-dnqdXpYPK2txRi4ojXGK Content-Type: application/pgp-signature; name="signature.asc" Content-Description: This is a digitally signed message part Content-Transfer-Encoding: 7bit -----BEGIN PGP SIGNATURE----- iI0EABYKADUWIQTB8z7iDFKP233XAR9J4+4iGRcl7gUCYjiKgxccbWF4aW1lZGV2 b3NAdGVsZW5ldC5iZQAKCRBJ4+4iGRcl7j1+AQCZa2yiHIAHsTjluakyyukJ/kV3 GURPuG+kADW166CKPAD9H77aHu8ybMl2JYt4sQLlOKXtm5OQFCWY/GBC1ju74Qk= =Q8uH -----END PGP SIGNATURE----- --=-dnqdXpYPK2txRi4ojXGK-- From unknown Sat Jun 14 03:56:08 2025 X-Loop: help-debbugs@gnu.org Subject: [bug#54485] [PATCH] gnu: Add guile-with-openat. Resent-From: Ludovic =?UTF-8?Q?Court=C3=A8s?= Original-Sender: "Debbugs-submit" Resent-CC: guix-patches@gnu.org Resent-Date: Thu, 24 Mar 2022 11:38:01 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: followup 54485 X-GNU-PR-Package: guix-patches X-GNU-PR-Keywords: patch To: Maxime Devos Cc: 54485@debbugs.gnu.org Received: via spool by 54485-submit@debbugs.gnu.org id=B54485.16481218672803 (code B ref 54485); Thu, 24 Mar 2022 11:38:01 +0000 Received: (at 54485) by debbugs.gnu.org; 24 Mar 2022 11:37:47 +0000 Received: from localhost ([127.0.0.1]:46949 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1nXLml-0000j9-Fx for submit@debbugs.gnu.org; Thu, 24 Mar 2022 07:37:47 -0400 Received: from eggs.gnu.org ([209.51.188.92]:49742) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1nXLmj-0000iv-75 for 54485@debbugs.gnu.org; Thu, 24 Mar 2022 07:37:45 -0400 Received: from [2001:470:142:3::e] (port=54262 helo=fencepost.gnu.org) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1nXLmd-0003cp-8c; Thu, 24 Mar 2022 07:37:39 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnu.org; s=fencepost-gnu-org; h=MIME-Version:In-Reply-To:Date:References:Subject:To: From; bh=Bzv2llygdGNUoTjY4JXLYIrIIk9QffXV704xeNtGE7I=; b=M6xnM0iQDTE0Dr77y7rR gQVIVaep78+SYiD5tsvwP1dSE3BULU9H0rVU9afSbHD3uHdLVZB4GjYnMEZLcKHjFEiaqlewchRT/ J0KDhJ1FeyBZ5xxisnYwNlbUB2K40OinFVW1cvFZf71jqFI/HNm977G4MYRsfdqgqPI3l5P9VAEPO yftzvTBibdtcDXvyJVQlnGNzWjQJWHn+QMy7ReeSW/zfG6YkIYIKcOWIq4flsKfTTI1cVylRQZrPS MqOg36DhczkUP9gPH8WE9aUd9M/ieZ5PTpgfBu10enSAPPfxK+1qwDCyJlwdPHRixNR8QbcmS0/Vl +ptdm2dCnZGGAg==; Received: from [193.50.110.177] (port=51502 helo=ribbon) by fencepost.gnu.org with esmtpsa (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1nXLmc-0003DY-Rq; Thu, 24 Mar 2022 07:37:39 -0400 From: Ludovic =?UTF-8?Q?Court=C3=A8s?= References: <20220320215031.306710-1-maximedevos@telenet.be> Date: Thu, 24 Mar 2022 12:37:36 +0100 In-Reply-To: <20220320215031.306710-1-maximedevos@telenet.be> (Maxime Devos's message of "Sun, 20 Mar 2022 21:50:31 +0000") Message-ID: <87czibd1j3.fsf@gnu.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/27.2 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-Spam-Score: -2.3 (--) X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Hi, Maxime Devos skribis: > XXX Don't apply yet, let's wait for > "./pre-inst-env guix build guile-with-openat" to complete first. > > This will allow us to work on resolving the >1 year publicly > known privilege escalation, see . > > * gnu/packages/guile.scm (guile-with-openat): New variable. It=E2=80=99s a clever way to remind me (and other interested Guile committe= rs) of how late we are when it comes to patch review. I=E2=80=99d rather avoid carrying this many patches in a package, be it Gui= le or anything else; that=E2=80=99s not something we usually do. Instead, I would prefer to actually review and apply the patches upstream. I=E2=80=99ve been meaning to do that, really, but it requires a = chunk of time and focus, which keeps leading me to postpone. Is the latest patch set on guile-devel? It=E2=80=99s not mentioned at . Thanks, Ludo=E2=80=99. From unknown Sat Jun 14 03:56:08 2025 X-Loop: help-debbugs@gnu.org Subject: [bug#54485] [PATCH] gnu: Add guile-with-openat. Resent-From: Maxime Devos Original-Sender: "Debbugs-submit" Resent-CC: guix-patches@gnu.org Resent-Date: Thu, 24 Mar 2022 11:56:02 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: followup 54485 X-GNU-PR-Package: guix-patches X-GNU-PR-Keywords: patch To: Ludovic =?UTF-8?Q?Court=C3=A8s?= Cc: 46258@debbugs.gnu.org, 54485@debbugs.gnu.org Received: via spool by 54485-submit@debbugs.gnu.org id=B54485.16481229544872 (code B ref 54485); Thu, 24 Mar 2022 11:56:02 +0000 Received: (at 54485) by debbugs.gnu.org; 24 Mar 2022 11:55:54 +0000 Received: from localhost ([127.0.0.1]:46996 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1nXM4H-0001GV-Mk for submit@debbugs.gnu.org; Thu, 24 Mar 2022 07:55:53 -0400 Received: from laurent.telenet-ops.be ([195.130.137.89]:41188) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1nXM4C-0001Fy-F0 for 54485@debbugs.gnu.org; Thu, 24 Mar 2022 07:55:51 -0400 Received: from [IPv6:2a02:2c40:200:b001::1:66ec] ([IPv6:2a02:2c40:200:b001::1:66ec]) by laurent.telenet-ops.be with bizsmtp id ABvl2700M48ECPd01BvmcR; Thu, 24 Mar 2022 12:55:47 +0100 Message-ID: From: Maxime Devos Date: Thu, 24 Mar 2022 12:55:41 +0100 In-Reply-To: <87czibd1j3.fsf@gnu.org> References: <20220320215031.306710-1-maximedevos@telenet.be> <87czibd1j3.fsf@gnu.org> Content-Type: multipart/signed; micalg="pgp-sha512"; protocol="application/pgp-signature"; boundary="=-OdDktcrnEpurxIDMM+rK" User-Agent: Evolution 3.38.3-1 MIME-Version: 1.0 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=telenet.be; s=r22; t=1648122947; bh=pd0wHOSyPVP5E+gsUBRU9QNFAiG0IIoF7GK4La9BfYA=; h=Subject:From:To:Cc:Date:In-Reply-To:References; b=otxEQDnBYLA/BxJVE5LP5Ozx0RR3taAJj+ZreRGRyZiRcgp4/MMDzrqEZ1KdgNtEH 7v5lC5ld6ByzYoGaJ27gX70F3W0T9DvT+RhKQrZ4+iYUW1e5eLn4f26meSi6Ux4+h4 ylHiM5Ck0Wqs1Vb50PRCm5gTJikn0UviVXSktvrX7x3jwgcAwAazYsvx+7FZWEfaS/ jqDb2TP5l2HQjVu2+H4tpQ9P69QjSFtA+xLpUCx5Ah0z3RxC9H52m/tBVA4m5ED1cK uwj6pKWBTiJmnyx/gACKnfCp3EiytbuEEF5LLwsDmn58kNMXzEs0zC/go0cPXIzrVU AN6wXuwz+VjEg== X-Spam-Score: -0.7 (/) X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.7 (-) --=-OdDktcrnEpurxIDMM+rK Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Ludovic Court=C3=A8s schreef op do 24-03-2022 om 12:37 [+0100]: > Instead, I would prefer to actually review and apply the patches > upstream.=C2=A0 I=E2=80=99ve been meaning to do that, really, but it requ= ires a chunk > of time and focus, which keeps leading me to postpone. OK. I can relate, w.r.t. the IPFS substitution patches. > Is the latest patch set on guile-devel?=C2=A0 It=E2=80=99s not mentioned = at > . It's at . Greetings, Maxime. --=-OdDktcrnEpurxIDMM+rK Content-Type: application/pgp-signature; name="signature.asc" Content-Description: This is a digitally signed message part Content-Transfer-Encoding: 7bit -----BEGIN PGP SIGNATURE----- iI0EABYKADUWIQTB8z7iDFKP233XAR9J4+4iGRcl7gUCYjxcPRccbWF4aW1lZGV2 b3NAdGVsZW5ldC5iZQAKCRBJ4+4iGRcl7u8JAP9X68N7KqIYB2g4C43hK1TeMv4n LMbyJ3Xt42ismfPt5QD/U/yWNYurX2avnOmouLhBp+rYS59Qlo4yy7RvlFYcOgE= =LX0E -----END PGP SIGNATURE----- --=-OdDktcrnEpurxIDMM+rK-- From unknown Sat Jun 14 03:56:08 2025 X-Loop: help-debbugs@gnu.org Subject: [bug#54485] [PATCH] gnu: Add guile-with-openat. References: <20220320215031.306710-1-maximedevos@telenet.be> In-Reply-To: <20220320215031.306710-1-maximedevos@telenet.be> Resent-From: Tobias Geerinckx-Rice Original-Sender: "Debbugs-submit" Resent-CC: guix-patches@gnu.org Resent-Date: Mon, 13 Jun 2022 00:54:02 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: followup 54485 X-GNU-PR-Package: guix-patches X-GNU-PR-Keywords: patch To: 54485@debbugs.gnu.org, Ludovic =?UTF-8?Q?Court=C3=A8s?= , Maxime Devos Received: via spool by 54485-submit@debbugs.gnu.org id=B54485.165508163519108 (code B ref 54485); Mon, 13 Jun 2022 00:54:02 +0000 Received: (at 54485) by debbugs.gnu.org; 13 Jun 2022 00:53:55 +0000 Received: from localhost ([127.0.0.1]:56751 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1o0YL5-0004y7-00 for submit@debbugs.gnu.org; Sun, 12 Jun 2022 20:53:55 -0400 Received: from tobias.gr ([80.241.217.52]:49626) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1o0YKz-0004xv-OU for 54485@debbugs.gnu.org; Sun, 12 Jun 2022 20:53:53 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; s=2018; bh=e3OOLUfHPyleI 87S55K2Gp4HU5D385dWEPHzkW4zUKc=; h=date:subject:to:from; d=tobias.gr; b=dZzCWXlY6qnUBT1dV6L9UZo3TiJMGWgkCk+l7cNpsoeBr7g+PKcHW8OPQBA//EzwZlmQ b04WII1l6ekWNytReovnHyifpjd4H4/DDG/gLWurBtTfPVFj8HG5yxK8QXBwr2dNP7bRHI amWRTlxmEDi+Fs2wO2Rbiyh8G3DdjWqUurGI1VBoWEV59ao5xGJOVHPG4th1wEeBkSTdl/ 31jVDV/32n9ImekaGgAkxAXsnL18DXiP1W7Cg3wn8VF0nOcNsae9l+Dl4DOM1PoMi4EJiw m6YXW3ems0DstYCwRV9Qa1xpWRidoaHJ/AkBL7gU+7rLbPy4NgQfMzA/iL3y+p+A== Received: by submission.tobias.gr (OpenSMTPD) with ESMTPSA id 3900f48c (TLSv1.3:AEAD-AES256-GCM-SHA384:256:NO); Mon, 13 Jun 2022 00:53:47 +0000 (UTC) From: Tobias Geerinckx-Rice Date: Mon, 13 Jun 2022 02:31:15 +0200 BIMI-Selector: v=BIMI1; s=default; Message-ID: <87leu1xu1c@nckx> MIME-Version: 1.0 Content-Type: multipart/signed; boundary="=-=-="; micalg=pgp-sha512; protocol="application/pgp-signature" X-Spam-Score: -0.0 (/) X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) --=-=-= Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: quoted-printable Hi Ludo'! > Instead, I would prefer to actually review and apply the patches > upstream. Sadly, the sleepy town of guile-devel seems not to have taken=20 notice so far[0]. I know you're busy and pulling more than your weight in Guix =E2=80=94 no=20 rest for the retired =E2=80=94 but with staging merged, I hope you'll have= =20 some spare cycles to review that series. Ideally they are perfect and ready to merge, but at this point any=20 reply to that thread would help get things moving again. Kind regards, T G-R [0]:=20 https://lists.gnu.org/archive/html/guile-devel/2021-11/msg00005.html --=-=-= Content-Type: application/pgp-signature; name="signature.asc" -----BEGIN PGP SIGNATURE----- iIMEARYKACsWIQT12iAyS4c9C3o4dnINsP+IT1VteQUCYqaKrw0cbWVAdG9iaWFz LmdyAAoJEA2w/4hPVW15VxUA/3nFEgFFsarB3FW4oYYWGBp9huEKCdaPzGR+t469 by6uAP4vCy1kTRX8tfUCYILio4KBEfMqoHpjVBQ2EEsz1kqJCw== =XuFZ -----END PGP SIGNATURE----- --=-=-=-- From unknown Sat Jun 14 03:56:08 2025 X-Loop: help-debbugs@gnu.org Subject: [bug#54485] [PATCH] gnu: Add guile-with-openat. Resent-From: Ludovic =?UTF-8?Q?Court=C3=A8s?= Original-Sender: "Debbugs-submit" Resent-CC: guix-patches@gnu.org Resent-Date: Fri, 24 Feb 2023 22:58:02 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: followup 54485 X-GNU-PR-Package: guix-patches X-GNU-PR-Keywords: patch To: Maxime Devos Cc: 54485@debbugs.gnu.org Received: via spool by 54485-submit@debbugs.gnu.org id=B54485.167727948018864 (code B ref 54485); Fri, 24 Feb 2023 22:58:02 +0000 Received: (at 54485) by debbugs.gnu.org; 24 Feb 2023 22:58:00 +0000 Received: from localhost ([127.0.0.1]:38524 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pVh0p-0004uC-Q8 for submit@debbugs.gnu.org; Fri, 24 Feb 2023 17:58:00 -0500 Received: from eggs.gnu.org ([209.51.188.92]:59186) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pVh0n-0004tw-W1 for 54485@debbugs.gnu.org; Fri, 24 Feb 2023 17:57:58 -0500 Received: from fencepost.gnu.org ([2001:470:142:3::e]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pVh0h-0001YR-R2; Fri, 24 Feb 2023 17:57:51 -0500 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnu.org; s=fencepost-gnu-org; h=MIME-Version:In-Reply-To:Date:References:Subject:To: From; bh=rrPfqw9HB8dH63DCbKppJpS9zkkGp4It7l1HHG5CJ8g=; b=kFItpLVhSfyEuvwt1r2c or/we34IEnZykS8gy0RKhnaink3ZjSEW9C0maiPsIVW0R4hcvUR9bhZ3ukKXu810NHEFYuXqDheru C8aO865Xkw3me6iq6P6q6fVUieyPIfGVpqESMDjA5jG/jJwSDLav8RNwt+VWdod5YeM7C3mZdCFyp rh7xGUnlzmtM02hO9xjMPfYwIZv5UGbNpnEaIlqxAIcOltb0YuZtjb1bImaYZ/zr/+/M04NRTp1sX N75j+7QIL/IwYITZHcxWND+V2/bDxzT4H+X6mb13DYLft56MTFYnfOY1UQjLerM4qU5xNN8xuerpC LPMrSnqA96iAEA==; Received: from 91-160-117-201.subs.proxad.net ([91.160.117.201] helo=ribbon) by fencepost.gnu.org with esmtpsa (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pVh0h-0007oX-E2; Fri, 24 Feb 2023 17:57:51 -0500 From: Ludovic =?UTF-8?Q?Court=C3=A8s?= References: <20220320215031.306710-1-maximedevos@telenet.be> Date: Fri, 24 Feb 2023 23:57:50 +0100 In-Reply-To: <20220320215031.306710-1-maximedevos@telenet.be> (Maxime Devos's message of "Sun, 20 Mar 2022 21:50:31 +0000") Message-ID: <877cw61xjl.fsf@gnu.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/28.2 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-Spam-Score: -2.3 (--) X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Hi, Maxime Devos skribis: > +;; (A static variant of) this package will be used to implement > +;; TOCTOU-free behaviour in > +;; and . > +(define-public guile-with-openat > + (package > + (inherit > + (package-with-extra-patches guile-3.0 > + (search-patches > + "guile-openat-and-friends-01.patch" > + "guile-openat-and-friends-02.patch" > + "guile-openat-and-friends-03.patch" > + "guile-openat-and-friends-04.patch" > + "guile-openat-and-friends-05.patch" > + "guile-openat-and-friends-06.patch" > + "guile-openat-and-friends-07.patch" > + "guile-openat-and-friends-08.patch" > + "guile-openat-and-friends-09.patch" > + "guile-openat-and-friends-10.patch" > + "guile-openat-and-friends-11.patch" > + "guile-openat-and-friends-12.patch" > + "guile-openat-and-friends-13.patch"))) > + (name "guile-with-openat") Closing now that =E2=80=98guile-3.0-latest=E2=80=99 is at 3.0.9, which incl= udes =E2=80=98openat=E2=80=99 and friends. At last! Ludo=E2=80=99. From debbugs-submit-bounces@debbugs.gnu.org Fri Feb 24 17:58:07 2023 Received: (at control) by debbugs.gnu.org; 24 Feb 2023 22:58:07 +0000 Received: from localhost ([127.0.0.1]:38529 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pVh0x-0004uw-5g for submit@debbugs.gnu.org; Fri, 24 Feb 2023 17:58:07 -0500 Received: from eggs.gnu.org ([209.51.188.92]:59192) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1pVh0v-0004uK-QU for control@debbugs.gnu.org; Fri, 24 Feb 2023 17:58:06 -0500 Received: from fencepost.gnu.org ([2001:470:142:3::e]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pVh0q-0001ZG-K0 for control@debbugs.gnu.org; Fri, 24 Feb 2023 17:58:00 -0500 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnu.org; s=fencepost-gnu-org; h=MIME-version:Subject:From:To:Date:in-reply-to: references; bh=kPynWeVB7Mw2KlVO35WMOjV0OYdhmh9IiWtWfta9A6Q=; b=mZNVz3jGkc27vA jexGsJqWQK8woxmQ4zPf4yw53rIzywH8jRdBfvbtPVG2sbPi+hrF0Wh/p/UsKTzJcgtoooHixejBl Ctdnk6L7/9xBHfdaWh2VqkE49idFhZkxiTRtsoEw2jkUsTzoTs2Q8GJS2ovAgNPtchMd7v6Skxi8Z 8APETgLV/lHmxxtMPpMHd0V5IRZ8EG+No/xPDNxWb366WsadZw7puhgI5vD+JL9CiZB6Vnia1rrYU PWYwXr1l4UmqVzsHtoNQ3zGyUZtQbKHuKvM8YjraJ0GZcEvNoDhXLg24FeuM0DbmgA8RcbgYo2oco 5iHeuXGOsCyHiyji9Ikg==; Received: from 91-160-117-201.subs.proxad.net ([91.160.117.201] helo=ribbon) by fencepost.gnu.org with esmtpsa (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pVh0q-0007wr-3n for control@debbugs.gnu.org; Fri, 24 Feb 2023 17:58:00 -0500 Date: Fri, 24 Feb 2023 23:57:58 +0100 Message-Id: <875ybq1xjd.fsf@gnu.org> To: control@debbugs.gnu.org From: =?utf-8?Q?Ludovic_Court=C3=A8s?= Subject: control message for bug #54485 MIME-version: 1.0 Content-type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: control X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) tags 54485 wontfix close 54485 quit