Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1vCAt8-009zK4-CP for pgsql-hackers@arkaria.postgresql.org; Fri, 24 Oct 2025 06:02:57 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.94.2) (envelope-from ) id 1vCAt7-00E6O5-A7 for pgsql-hackers@arkaria.postgresql.org; Fri, 24 Oct 2025 06:02:56 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1vCAt6-00E6Nv-UG for pgsql-hackers@lists.postgresql.org; Fri, 24 Oct 2025 06:02:56 +0000 Received: from mail-yw1-x1133.google.com ([2607:f8b0:4864:20::1133]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.96) (envelope-from ) id 1vCAt3-003wF8-2d for pgsql-hackers@lists.postgresql.org; Fri, 24 Oct 2025 06:02:55 +0000 Received: by mail-yw1-x1133.google.com with SMTP id 00721157ae682-7847ee5f59dso23213807b3.2 for ; Thu, 23 Oct 2025 23:02:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1761285771; x=1761890571; darn=lists.postgresql.org; h=in-reply-to:content-language:references:to:from:subject:user-agent :mime-version:date:message-id:from:to:cc:subject:date:message-id :reply-to; bh=dj3F72V1aG6fLqm4JUeGDYJgKkbp18UYNor7mqAugyo=; b=MwlsKcUoKpfMh0MofG/mN+Wtz08mK6i0YaAjdgQ6Ee/W4Q1ANLr75pVDHtdZN1fa1x u/6BxI8AKRSN0/tXn25g+bdXWlvVtAUziwohMbNF6zWl6VPXR99dLXTbI+GXpborTKOt i2H/uK/ZqX16zCLsmXfgGqgNPUEIhf1qeQOUzTqQbVem7lvBAL4GklofYtNCV3zkpSnn AQ5QUgElPFBVyM/+/tp6TurRjsSihjpeWbm9U/EjXdTy/X5i7LlLhIMF+HD3zjY8bMcl GqN1w81+3vNZzf8KAvqu99L6BnfBl8iJQtdIWFVPIS6vPfIueFHMcpDEHYQv8P9tsxTo JOag== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761285771; x=1761890571; h=in-reply-to:content-language:references:to:from:subject:user-agent :mime-version:date:message-id:x-gm-message-state:from:to:cc:subject :date:message-id:reply-to; bh=dj3F72V1aG6fLqm4JUeGDYJgKkbp18UYNor7mqAugyo=; b=TWSU6Ix5WJ9Jwo1Xd911EVNIIDojsDACh2Zh6J7gTdBWue4cdo5gK4zC7ChAwiOtcO 3nfygfeJtAdDexHNALUr7ABnTubK4kv9PlaauHO+q4nXAPQ3J1Tg9EIH3cSf1kLcWz4N vjZCV6xGoSQVmMR+N32nskpaUqxH6b5TPLYl5MO6e1O6vlALcyO6Pg2xvsssFmr8/1HY L6PZtDp+M/aGkUPntISEwKxwXUhXCTwzhJQDX0s0a4Oj9Dm9OEK/tSwEFNf1cUP3/n21 uWZcD/3KIDoBXHANwRe84Mv9Bi8sIGiH1GrFESZNsql1uic5RI75Xq205q9TdhRw9VU/ DABg== X-Gm-Message-State: AOJu0YxfG6Ive9hxM4pyV9wi1/ZhCJvMaVRKBNJVaD9W0bL8Otg2pj9C wjiI4pAq6tXYISmizXj5fC6hGvQSsJCXG/sgiwxCoU0VFMJQC5femj0l0+YcsUfykHls5g== X-Gm-Gg: ASbGncuFNlWKdCl7hc2VEMN932I0zajTeFGWLqDSwzWcjzapIc4zTELVphNtYm3vbpv iWArDST+ZOVhMRToMPp8+++DmHE/tu7rfog8VKaAg+M1S5v95BsXQgydLZTBs6ZAamDUoUH8mbL OPCC1Wky7yRlUHNFXvcM1Ayraplr7Y4MdaTJK5A8SAPGyEzaAM035y3ybvaqChdAuPc8M1kX5gG SpIyFn8L6knapPQp28g3wqqzC/lzwmNII67r9BTM0hqO2Tr7je++A3TvHnjSUML3CL6yVqkOG4V izFT5YU9kvj8/hqLqDNOVlsr5HssB3SeNn/HUVrgnhUwxnPosRaxufJISam4DYhi/NJIYwTKTj4 yAmtFuGvAO+cJWqFRjvRE2tMmJ/FMqvHtRmJAgEcnbL60WAZTTQ8XXOsuKXGPAJSOi8zMHATG8y 7vurfkmUrkrlsmFG8yGYEy31Ybjsjrv+BIv7Ski0MJ/UkoYcvHBGsMc+kKxDsMQ+Tn X-Google-Smtp-Source: AGHT+IE5ROZquo4ge3wsVkURBQmKwL+SvDcq/gR1Lh6qHdO9MrmGdgTXv9iB/xkw9FOuiGgs8FG87g== X-Received: by 2002:a05:690c:7446:b0:784:9fbe:e91f with SMTP id 00721157ae682-7849fbeed83mr138703737b3.70.1761285770509; Thu, 23 Oct 2025 23:02:50 -0700 (PDT) Received: from ?IPV6:2600:1700:8952:80:8538:d604:170e:6b1f? ([2600:1700:8952:80:8538:d604:170e:6b1f]) by smtp.gmail.com with ESMTPSA id 00721157ae682-785cd5e6341sm11123057b3.24.2025.10.23.23.02.47 for (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Thu, 23 Oct 2025 23:02:48 -0700 (PDT) Content-Type: multipart/mixed; boundary="------------dz0R3IO7rxyFclB2JtGLZA6S" Message-ID: <07d00685-26b1-461d-99bf-7e973236e875@gmail.com> Date: Fri, 24 Oct 2025 01:02:47 -0500 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: pg_ctl start may return 0 even if the postmaster has been already started on Windows From: Bryan Green To: pgsql-hackers@lists.postgresql.org References: <20240713.064114.901257637518958249.kou@clear-code.com> <172113105761.344725.7570284373523963080.pgcf@coridan.postgresql.org> Content-Language: en-US In-Reply-To: List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk This is a multi-part message in MIME format. --------------dz0R3IO7rxyFclB2JtGLZA6S Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit On 10/23/2025 11:02 PM, Bryan Green wrote: > On 3/26/2025 3:18 AM, vignesh C wrote: >> On Sat, 20 Jul 2024 at 00:03, Robert Haas wrote: >>> >>> On Tue, Jul 16, 2024 at 8:04 AM Yasir >>> wrote: >>>> Please ignore the above 4 lines in my review. See my comments in blue. >>> >>> OK, so I think it's unclear what the next steps are for this patch. >>> >>> 1. On June 3rd, Michael Paquier said that Tom Lane proposed that, >>> after doing what the patch currently does, we could simplify some >>> other stuff. The details are unclear, and Tom hasn't commented. >>> >>> 2. On June 29th, Noah Misch proposed a platform-independent way of >>> solving the problem. >>> >>> 3. On July 12th, Sutou Kouhei proposed using CreateProcess() to start >>> the postmaster instead of cmd.exe. >>> >>> 4. On July 16th, Yasir Shah said that he tested the patch and found >>> that the problem only exists in v17, not any prior release, which is >>> contrary to my understanding of the situation. He also proposed a >>> minor tweak to the patch itself. >>> >>> So, as I see it, we have three possible ways forward here. First, we >>> could stick with the current patch, possibly with further work as per >>> [1] or adjustments as per [4]. Second, we could abandon the current >>> approach and adopt Noah's proposal in [2]. Third, we could possibly >>> abandon the current approach and adopt Sutou's proposal in [3]. I say >>> "possibly" because I can't personally assess whether this approach is >>> feasible. >> >> Thank you very much, Robert, for summarizing this. If anyone has >> suggestions on which approach might work best, please share them to >> help move this discussion forward. >> >> Regards, >> Vignesh >> >> > Hello everyone, > > I've spent the last few days implementing Sutou-san's CreateProcess() > proposal as a proof-of-concept. With all three approaches now available > for comparison, I wanted to share my assessment and recommendation. > > The core issue, as we've established, is that cmd.exe intermediation > prevents pg_ctl from getting the real postgres.exe PID, creating race > conditions where we can't distinguish a newly-started postmaster from a > pre-existing one. This causes pg_ctl start to incorrectly report success > when attempting to start an already-running cluster. > > Horiguchi-san's process tree walking patch works and is ready to ship. > It has real merit as a minimal-change solution. However, it keeps > cmd.exe and adds process enumeration complexity to work around that > decision. We're fixing symptoms rather than the root cause. > > Noah's token proposal is architecturally elegant and platform- > independent. My concern is that it solves a Windows-specific problem by > adding complexity to all platforms. Making other platforms adopt token- > passing infrastructure for Windows's problems feels wrong. It also > requires postmaster changes for what is fundamentally a pg_ctl issue, > raising compatibility questions. > > The CreateProcess() approach eliminates cmd.exe entirely and gives us > the actual postgres.exe PID directly. I've implemented this in the > attached patch (about 250 lines of Windows-specific code). The > implementation uses CreateProcessAsUser() with a restricted security > token to handle the case where pg_ctl runs with elevated privileges—this > drops Administrator group membership and dangerous privileges before > launching the postmaster, matching the behavior of the existing > CreateRestrictedProcess() function. > > For I/O redirection, we use Windows's native handle-based APIs. When a > log file is specified, we open it with CreateFile() and pass it through > STARTUPINFO. When there's no log file (interactive use and postgres -C > queries), we inherit standard handles. One detail worth noting: we wait > 2 seconds for no-log-file launches to distinguish postgres -C (which > exits immediately) from actual server startup. This is long enough to > catch quick exits even on loaded CI systems without impacting test suite > performance. > > The implementation passes all regression tests on Windows, including CI > environments with elevated privileges. It handles all the problem > scenarios correctly: normal startup, detecting already-running clusters, > postgres -C queries, pg_upgrade with multiple instances, and concurrent > start attempts. > > I prefer the CreateProcess() approach. It fixes the root cause, not the > symptoms. We get the real PID immediately with no process tree walking > or PID verification complexity. It's a Windows-specific solution to a > Windows-specific problem. > > If the CreateProcess() approach is deemed unacceptable, I would support > Horiguchi-san's process tree walking patch as a pragmatic fallback. It > fixes the bug and is tested. However, I believe we'd be choosing a > workaround over a proper fix and adding maintenance burden we don't need. > > I'm opposed to the token approach for the reasons stated above—it's > architecturally appealing but touches all platforms for a Windows-only > problem. > > With this implementation complete, we now have all three options on the > table for evaluation. I believe the CreateProcess() approach is > technically sound and the right path forward, but I'm open to discussion > and happy to address any concerns about the implementation. > > Regardless of which way we choose to go, I'll happily help review and > test the solution. > > Best regards, > BG I realized the patch had an issue after sending. Here is the updated patch. Again, this patch is just for an example of Sutou-san's suggestion. --------------dz0R3IO7rxyFclB2JtGLZA6S Content-Type: text/plain; charset=UTF-8; name="v2-0001-Fix-pg_ctl-on-Windows-to-reliably-detect-already-run.patch" Content-Disposition: attachment; filename*0="v2-0001-Fix-pg_ctl-on-Windows-to-reliably-detect-already-run"; filename*1=".patch" Content-Transfer-Encoding: base64 RnJvbSAxMmI2NjFlYzQyOGVkZjhiOTNmNzIyMjI5Y2YxOGNkMzI1NTlmNzQ2IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBCcnlhbiBHcmVlbiA8ZGJyeWFuLmdyZWVuQGdtYWls LmNvbT4KRGF0ZTogVGh1LCAyMyBPY3QgMjAyNSAxMzo1Mjo1MSAtMDUwMApTdWJqZWN0OiBb UEFUQ0hdIEZpeCBwZ19jdGwgb24gV2luZG93cyB0byByZWxpYWJseSBkZXRlY3QgYWxyZWFk eS1ydW5uaW5nCiBwb3N0bWFzdGVyLgoKVGhlIHByZXZpb3VzIGltcGxlbWVudGF0aW9uIGlu dm9rZWQgcG9zdGdyZXMuZXhlIHZpYSBjbWQuZXhlLCB3aGljaCBtZWFudApwZ19jdGwgZ290 IHRoZSBQSUQgb2YgdGhlIHNoZWxsIHdyYXBwZXIgcmF0aGVyIHRoYW4gdGhlIGFjdHVhbCBw b3N0bWFzdGVyCnByb2Nlc3MuICBUaGlzIGNhdXNlZCBwcm9ibGVtcyBpbiB3YWl0X2Zvcl9w b3N0bWFzdGVyX3N0YXJ0KCksIHdoaWNoIHRyaWVzCnRvIHZlcmlmeSB0aGF0IHRoZSBQSUQg aW4gcG9zdG1hc3Rlci5waWQgbWF0Y2hlcyB0aGUgb25lIHdlIHN0YXJ0ZWQuICBUaGUKbWlz bWF0Y2ggbGVkIHRvIGEgdGltaW5nIHdpbmRvdyB3aGVyZSBwZ19jdGwgY291bGQgaW5jb3Jy ZWN0bHkgcmVwb3J0CnN1Y2Nlc3Mgd2hlbiBhdHRlbXB0aW5nIHRvIHN0YXJ0IGFuIGFscmVh ZHktcnVubmluZyBjbHVzdGVyLgoKRml4IGJ5IHJlcGxhY2luZyB0aGUgY21kLmV4ZSB3cmFw cGVyIHdpdGggYSBkaXJlY3QgQ3JlYXRlUHJvY2VzcygpIGNhbGwuClRoaXMgZ2l2ZXMgdXMg dGhlIHJlYWwgcG9zdGdyZXMuZXhlIFBJRCBpbW1lZGlhdGVseSwgZWxpbWluYXRpbmcgdGhl Cm5lZWQgZm9yIHByb2Nlc3MgdHJlZSB3YWxraW5nIG9yIG90aGVyIGhldXJpc3RpY3MgdG8g ZmluZCB0aGUgYWN0dWFsCnBvc3RtYXN0ZXIuICBXZSBoYW5kbGUgSS9PIHJlZGlyZWN0aW9u IHVzaW5nIFdpbmRvd3MgaGFuZGxlLWJhc2VkIEFQSXMKaW5zdGVhZCBvZiBzaGVsbCBzeW50 YXgsIHdoaWNoIGlzIG1vcmUgcmVsaWFibGUgYW55d2F5LgotLS0KIHNyYy9iaW4vcGdfY3Rs L3BnX2N0bC5jIHwgNTI2ICsrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0t LS0KIDEgZmlsZSBjaGFuZ2VkLCAzNzEgaW5zZXJ0aW9ucygrKSwgMTU1IGRlbGV0aW9ucygt KQoKZGlmZiAtLWdpdCBhL3NyYy9iaW4vcGdfY3RsL3BnX2N0bC5jIGIvc3JjL2Jpbi9wZ19j dGwvcGdfY3RsLmMKaW5kZXggOGE0MDVmZjEyMi4uZTAzMzhjY2M1MSAxMDA2NDQKLS0tIGEv c3JjL2Jpbi9wZ19jdGwvcGdfY3RsLmMKKysrIGIvc3JjL2Jpbi9wZ19jdGwvcGdfY3RsLmMK QEAgLTcyLDYgKzcyLDcgQEAgdHlwZWRlZiBlbnVtCiAKICNkZWZpbmUgV0FJVFNfUEVSX1NF QwkxMAkJLyogc2hvdWxkIGRpdmlkZSBVU0VDX1BFUl9TRUMgZXZlbmx5ICovCiAKK3N0YXRp YyBwaWRfdCBwbV9waWQgPSAwOwogc3RhdGljIGJvb2wgZG9fd2FpdCA9IHRydWU7CiBzdGF0 aWMgaW50CXdhaXRfc2Vjb25kcyA9IERFRkFVTFRfV0FJVDsKIHN0YXRpYyBib29sIHdhaXRf c2Vjb25kc19hcmcgPSBmYWxzZTsKQEAgLTk5LDcgKzEwMCw2IEBAIHN0YXRpYyBjaGFyIHZl cnNpb25fZmlsZVtNQVhQR1BBVEhdOwogc3RhdGljIGNoYXIgcGlkX2ZpbGVbTUFYUEdQQVRI XTsKIHN0YXRpYyBjaGFyIHByb21vdGVfZmlsZVtNQVhQR1BBVEhdOwogc3RhdGljIGNoYXIg bG9ncm90YXRlX2ZpbGVbTUFYUEdQQVRIXTsKLQogc3RhdGljIHZvbGF0aWxlIHBpZF90IHBv c3RtYXN0ZXJQSUQgPSAtMTsKIAogI2lmZGVmIFdJTjMyCkBAIC0xNDIsMTIgKzE0MiwxNCBA QCBzdGF0aWMgdm9pZCBXSU5BUEkgcGd3aW4zMl9TZXJ2aWNlTWFpbihEV09SRCwgTFBUU1RS ICopOwogc3RhdGljIHZvaWQgcGd3aW4zMl9kb1J1bkFzU2VydmljZSh2b2lkKTsKIHN0YXRp YyBpbnQJQ3JlYXRlUmVzdHJpY3RlZFByb2Nlc3MoY2hhciAqY21kLCBQUk9DRVNTX0lORk9S TUFUSU9OICpwcm9jZXNzSW5mbywgYm9vbCBhc19zZXJ2aWNlKTsKIHN0YXRpYyBQVE9LRU5f UFJJVklMRUdFUyBHZXRQcml2aWxlZ2VzVG9EZWxldGUoSEFORExFIGhUb2tlbik7CitzdGF0 aWMgdm9pZCBJbmhlcml0U3RkSGFuZGxlcyhTVEFSVFVQSU5GTyAqc2kpOworc3RhdGljIEhB TkRMRSBjcmVhdGVfcmVzdHJpY3RlZF90b2tlbih2b2lkKTsKICNlbmRpZgogCiBzdGF0aWMg cGlkX3QgZ2V0X3BncGlkKGJvb2wgaXNfc3RhdHVzX3JlcXVlc3QpOwogc3RhdGljIGNoYXIg KipyZWFkZmlsZShjb25zdCBjaGFyICpwYXRoLCBpbnQgKm51bWxpbmVzKTsKIHN0YXRpYyB2 b2lkIGZyZWVfcmVhZGZpbGUoY2hhciAqKm9wdGxpbmVzKTsKLXN0YXRpYyBwaWRfdCBzdGFy dF9wb3N0bWFzdGVyKHZvaWQpOworc3RhdGljIHZvaWQgc3RhcnRfcG9zdG1hc3Rlcih2b2lk KTsKIHN0YXRpYyB2b2lkIHJlYWRfcG9zdF9vcHRzKHZvaWQpOwogCiBzdGF0aWMgV2FpdFBN UmVzdWx0IHdhaXRfZm9yX3Bvc3RtYXN0ZXJfc3RhcnQocGlkX3QgcG1fcGlkLCBib29sIGRv X2NoZWNrcG9pbnQpOwpAQCAtNDIxLDU2ICs0MjMsMzE5IEBAIGZyZWVfcmVhZGZpbGUoY2hh ciAqKm9wdGxpbmVzKQogCWZyZWUob3B0bGluZXMpOwogfQogCisKIC8qCi0gKiBzdGFydC90 ZXN0L3N0b3Agcm91dGluZXMKKyAqIHN0YXJ0L3Rlc3Qvc3RvcCByb3V0aW5lcwogICovCisj aWZkZWYgV0lOMzIKKy8qCisgKiBIZWxwZXIgZnVuY3Rpb24gdG8gZHJvcCBwcml2aWxlZ2Vz IGJlZm9yZSBsYXVuY2hpbmcgcG9zdGdyZXMuCisgKi8KK3N0YXRpYyBIQU5ETEUKK2NyZWF0 ZV9yZXN0cmljdGVkX3Rva2VuKHZvaWQpCit7CisJSEFORExFCQlvcmlnVG9rZW47CisJSEFO RExFCQlyZXN0cmljdGVkVG9rZW47CisJU0lEX0lERU5USUZJRVJfQVVUSE9SSVRZIE50QXV0 aG9yaXR5ID0ge1NFQ1VSSVRZX05UX0FVVEhPUklUWX07CisJU0lEX0FORF9BVFRSSUJVVEVT IGRyb3BTaWQ7CisJUFRPS0VOX1BSSVZJTEVHRVMgZGVsUHJpdnM7CisJQk9PTAkJYjsKKwor CWlmICghT3BlblByb2Nlc3NUb2tlbihHZXRDdXJyZW50UHJvY2VzcygpLCBUT0tFTl9BTExf QUNDRVNTLCAmb3JpZ1Rva2VuKSkKKwl7CisJCXdyaXRlX3N0ZGVycihfKCIlczogY291bGQg bm90IG9wZW4gcHJvY2VzcyB0b2tlbjogZXJyb3IgY29kZSAlbHVcbiIpLAorCQkJCQkgcHJv Z25hbWUsICh1bnNpZ25lZCBsb25nKSBHZXRMYXN0RXJyb3IoKSk7CisJCXJldHVybiBOVUxM OworCX0KKworCVplcm9NZW1vcnkoJmRyb3BTaWQsIHNpemVvZihkcm9wU2lkKSk7CisJaWYg KCFBbGxvY2F0ZUFuZEluaXRpYWxpemVTaWQoJk50QXV0aG9yaXR5LCAyLAorCQkJCQkJCQkg IFNFQ1VSSVRZX0JVSUxUSU5fRE9NQUlOX1JJRCwgRE9NQUlOX0FMSUFTX1JJRF9BRE1JTlMs IDAsIDAsIDAsIDAsIDAsCisJCQkJCQkJCSAgMCwgJmRyb3BTaWQuU2lkKSkKKwl7CisJCXdy aXRlX3N0ZGVycihfKCIlczogY291bGQgbm90IGFsbG9jYXRlIFNJRHM6IGVycm9yIGNvZGUg JWx1XG4iKSwKKwkJCQkJIHByb2duYW1lLCAodW5zaWduZWQgbG9uZykgR2V0TGFzdEVycm9y KCkpOworCQlDbG9zZUhhbmRsZShvcmlnVG9rZW4pOworCQlyZXR1cm4gTlVMTDsKKwl9CisK KwlkZWxQcml2cyA9IEdldFByaXZpbGVnZXNUb0RlbGV0ZShvcmlnVG9rZW4pOworCWlmIChk ZWxQcml2cyA9PSBOVUxMKQorCXsKKwkJRnJlZVNpZChkcm9wU2lkLlNpZCk7CisJCUNsb3Nl SGFuZGxlKG9yaWdUb2tlbik7CisJCXJldHVybiBOVUxMOworCX0KKworCWIgPSBDcmVhdGVS ZXN0cmljdGVkVG9rZW4ob3JpZ1Rva2VuLAorCQkJCQkJCSAgMCwKKwkJCQkJCQkgIDEsCisJ CQkJCQkJICAmZHJvcFNpZCwKKwkJCQkJCQkgIGRlbFByaXZzLT5Qcml2aWxlZ2VDb3VudCwg ZGVsUHJpdnMtPlByaXZpbGVnZXMsCisJCQkJCQkJICAwLCBOVUxMLAorCQkJCQkJCSAgJnJl c3RyaWN0ZWRUb2tlbik7CisKKwlmcmVlKGRlbFByaXZzKTsKKwlGcmVlU2lkKGRyb3BTaWQu U2lkKTsKKwlDbG9zZUhhbmRsZShvcmlnVG9rZW4pOworCisJaWYgKCFiKQorCXsKKwkJd3Jp dGVfc3RkZXJyKF8oIiVzOiBjb3VsZCBub3QgY3JlYXRlIHJlc3RyaWN0ZWQgdG9rZW46IGVy cm9yIGNvZGUgJWx1XG4iKSwKKwkJCQkJIHByb2duYW1lLCAodW5zaWduZWQgbG9uZykgR2V0 TGFzdEVycm9yKCkpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlyZXR1cm4gcmVzdHJpY3Rl ZFRva2VuOworfQorCisKK3N0YXRpYyBwaWRfdAorc3RhcnRfcG9zdG1hc3Rlcl93aW4zMih2 b2lkKQoreworCUhBTkRMRQkJaE91dHB1dEZpbGUgPSBJTlZBTElEX0hBTkRMRV9WQUxVRTsK KwlIQU5ETEUJCWhFcnJvckZpbGUgPSBJTlZBTElEX0hBTkRMRV9WQUxVRTsKKwlIQU5ETEUJ CWhJbnB1dEZpbGUgPSBJTlZBTElEX0hBTkRMRV9WQUxVRTsKKwlIQU5ETEUJCXJlc3RyaWN0 ZWRUb2tlbiA9IE5VTEw7CisJU1RBUlRVUElORk8gc2k7CisJUFJPQ0VTU19JTkZPUk1BVElP TiBwaTsKKwljaGFyCQljbWRbTUFYUEdQQVRIICogMiArIDI1Nl07CisJU0VDVVJJVFlfQVRU UklCVVRFUyBzYTsKKwlEV09SRAkJY3JlYXRpb25fZmxhZ3M7CisJRFdPUkQJCWNyZWF0ZV9l cnJvcjsKKwlCT09MCQlyZXQ7CisJY2hhcgkgICAqY21kbGluZTsKKwlpbnQJCQljbWRsZW47 CisJQk9PTAkJb3duX2hhbmRsZXMgPSBGQUxTRTsKKworCWNtZGxlbiA9IHNucHJpbnRmKGNt ZCwgc2l6ZW9mKGNtZCksICJcIiVzXCIlcyVzJXMlcyIsCisJCQkJCSAgZXhlY19wYXRoLAor CQkJCQkgIHBnZGF0YV9vcHQgPyAiICIgOiAiIiwKKwkJCQkJICBwZ2RhdGFfb3B0ID8gcGdk YXRhX29wdCA6ICIiLAorCQkJCQkgIHBvc3Rfb3B0cyA/ICIgIiA6ICIiLAorCQkJCQkgIHBv c3Rfb3B0cyA/IHBvc3Rfb3B0cyA6ICIiKTsKKworCWlmIChjbWRsZW4gPj0gc2l6ZW9mKGNt ZCkpCisJeworCQl3cml0ZV9zdGRlcnIoXygiJXM6IGNvbW1hbmQgbGluZSB0b28gbG9uZ1xu IiksIHByb2duYW1lKTsKKwkJcmV0dXJuIDA7CisJfQorCisJY21kbGluZSA9IHBnX3N0cmR1 cChjbWQpOworCisJcmVzdHJpY3RlZFRva2VuID0gY3JlYXRlX3Jlc3RyaWN0ZWRfdG9rZW4o KTsKKwlpZiAocmVzdHJpY3RlZFRva2VuID09IE5VTEwpCisJeworCQlmcmVlKGNtZGxpbmUp OworCQlleGl0KDEpOworCX0KKworCVplcm9NZW1vcnkoJnNpLCBzaXplb2Yoc2kpKTsKKwlz aS5jYiA9IHNpemVvZihzaSk7CisKKwlpZiAobG9nX2ZpbGUgIT0gTlVMTCkKKwl7CisJCVpl cm9NZW1vcnkoJnNhLCBzaXplb2Yoc2EpKTsKKwkJc2Eubkxlbmd0aCA9IHNpemVvZihzYSk7 CisJCXNhLmJJbmhlcml0SGFuZGxlID0gVFJVRTsKKwkJc2EubHBTZWN1cml0eURlc2NyaXB0 b3IgPSBOVUxMOworCisJCWhJbnB1dEZpbGUgPSBDcmVhdGVGaWxlKCJOVUwiLAorCQkJCQkJ CQlHRU5FUklDX1JFQUQsCisJCQkJCQkJCUZJTEVfU0hBUkVfUkVBRCB8IEZJTEVfU0hBUkVf V1JJVEUsCisJCQkJCQkJCSZzYSwKKwkJCQkJCQkJT1BFTl9FWElTVElORywKKwkJCQkJCQkJ RklMRV9BVFRSSUJVVEVfTk9STUFMLAorCQkJCQkJCQlOVUxMKTsKKworCQlpZiAoaElucHV0 RmlsZSA9PSBJTlZBTElEX0hBTkRMRV9WQUxVRSkKKwkJeworCQkJd3JpdGVfc3RkZXJyKF8o IiVzOiBjb3VsZCBub3Qgb3BlbiBOVUwgZGV2aWNlOiBlcnJvciBjb2RlICVsdVxuIiksCisJ CQkJCQkgcHJvZ25hbWUsIEdldExhc3RFcnJvcigpKTsKKwkJCUNsb3NlSGFuZGxlKHJlc3Ry aWN0ZWRUb2tlbik7CisJCQlmcmVlKGNtZGxpbmUpOworCQkJcmV0dXJuIDA7CisJCX0KKwor CQloT3V0cHV0RmlsZSA9IENyZWF0ZUZpbGUobG9nX2ZpbGUsCisJCQkJCQkJCSBHRU5FUklD X1dSSVRFLAorCQkJCQkJCQkgRklMRV9TSEFSRV9SRUFEIHwgRklMRV9TSEFSRV9XUklURSwK KwkJCQkJCQkJICZzYSwKKwkJCQkJCQkJIE9QRU5fQUxXQVlTLAorCQkJCQkJCQkgRklMRV9B VFRSSUJVVEVfTk9STUFMLAorCQkJCQkJCQkgTlVMTCk7CisKKwkJaWYgKGhPdXRwdXRGaWxl ID09IElOVkFMSURfSEFORExFX1ZBTFVFKQorCQl7CisJCQl3cml0ZV9zdGRlcnIoXygiJXM6 IGNvdWxkIG5vdCBvcGVuIGxvZyBmaWxlIFwiJXNcIjogZXJyb3IgY29kZSAlbHVcbiIpLAor CQkJCQkJIHByb2duYW1lLCBsb2dfZmlsZSwgR2V0TGFzdEVycm9yKCkpOworCQkJQ2xvc2VI YW5kbGUoaElucHV0RmlsZSk7CisJCQlDbG9zZUhhbmRsZShyZXN0cmljdGVkVG9rZW4pOwor CQkJZnJlZShjbWRsaW5lKTsKKwkJCXJldHVybiAwOworCQl9CisKKwkJaWYgKFNldEZpbGVQ b2ludGVyKGhPdXRwdXRGaWxlLCAwLCBOVUxMLCBGSUxFX0VORCkgPT0gSU5WQUxJRF9TRVRf RklMRV9QT0lOVEVSICYmCisJCQlHZXRMYXN0RXJyb3IoKSAhPSBOT19FUlJPUikKKwkJewor CQkJd3JpdGVfc3RkZXJyKF8oIiVzOiBjb3VsZCBub3Qgc2VlayB0byBlbmQgb2YgbG9nIGZp bGU6IGVycm9yIGNvZGUgJWx1XG4iKSwKKwkJCQkJCSBwcm9nbmFtZSwgR2V0TGFzdEVycm9y KCkpOworCQkJQ2xvc2VIYW5kbGUoaE91dHB1dEZpbGUpOworCQkJQ2xvc2VIYW5kbGUoaElu cHV0RmlsZSk7CisJCQlDbG9zZUhhbmRsZShyZXN0cmljdGVkVG9rZW4pOworCQkJZnJlZShj bWRsaW5lKTsKKwkJCXJldHVybiAwOworCQl9CisKKwkJaEVycm9yRmlsZSA9IGhPdXRwdXRG aWxlOworCisJCXNpLmR3RmxhZ3MgPSBTVEFSVEZfVVNFU1RESEFORExFUzsKKwkJc2kuaFN0 ZElucHV0ID0gaElucHV0RmlsZTsKKwkJc2kuaFN0ZE91dHB1dCA9IGhPdXRwdXRGaWxlOwor CQlzaS5oU3RkRXJyb3IgPSBoRXJyb3JGaWxlOworCisJCWNyZWF0aW9uX2ZsYWdzID0gQ1JF QVRFX05PX1dJTkRPVyB8IENSRUFURV9ORVdfUFJPQ0VTU19HUk9VUCB8IENSRUFURV9TVVNQ RU5ERUQ7CisKKwkJb3duX2hhbmRsZXMgPSBUUlVFOworCX0KKwllbHNlCisJeworCQlJbmhl cml0U3RkSGFuZGxlcygmc2kpOworCQljcmVhdGlvbl9mbGFncyA9IENSRUFURV9TVVNQRU5E RUQ7CisJfQorCisJWmVyb01lbW9yeSgmcGksIHNpemVvZihwaSkpOworCisJcmV0ID0gQ3Jl YXRlUHJvY2Vzc0FzVXNlcihyZXN0cmljdGVkVG9rZW4sCQkvKiByZXN0cmljdGVkIHNlY3Vy aXR5IHRva2VuICovCisJCQkJCQkJICBOVUxMLAkJCQkJLyogYXBwbGljYXRpb24gbmFtZSAq LworCQkJCQkJCSAgY21kbGluZSwJCQkJLyogY29tbWFuZCBsaW5lICovCisJCQkJCQkJICBO VUxMLAkJCQkJLyogcHJvY2VzcyBzZWN1cml0eSBhdHRyaWJ1dGVzICovCisJCQkJCQkJICBO VUxMLAkJCQkJLyogdGhyZWFkIHNlY3VyaXR5IGF0dHJpYnV0ZXMgKi8KKwkJCQkJCQkgIFRS VUUsCQkJCQkvKiBpbmhlcml0IGhhbmRsZXMgKi8KKwkJCQkJCQkgIGNyZWF0aW9uX2ZsYWdz LAkJLyogY3JlYXRpb24gZmxhZ3MgKi8KKwkJCQkJCQkgIE5VTEwsCQkJCQkvKiBlbnZpcm9u bWVudCAqLworCQkJCQkJCSAgcGdfZGF0YSwJCQkJLyogY3VycmVudCBkaXJlY3RvcnkgKi8K KwkJCQkJCQkgICZzaSwJCQkJCS8qIHN0YXJ0dXAgaW5mbyAqLworCQkJCQkJCSAgJnBpKTsJ CQkJCS8qIHByb2Nlc3MgaW5mbyAqLworCisJY3JlYXRlX2Vycm9yID0gR2V0TGFzdEVycm9y KCk7CisKKwlpZiAob3duX2hhbmRsZXMpCisJeworCQlpZiAoaElucHV0RmlsZSAhPSBJTlZB TElEX0hBTkRMRV9WQUxVRSkKKwkJCUNsb3NlSGFuZGxlKGhJbnB1dEZpbGUpOworCQlpZiAo aE91dHB1dEZpbGUgIT0gSU5WQUxJRF9IQU5ETEVfVkFMVUUpCisJCQlDbG9zZUhhbmRsZSho T3V0cHV0RmlsZSk7CisJfQorCisJQ2xvc2VIYW5kbGUocmVzdHJpY3RlZFRva2VuKTsKKwlm cmVlKGNtZGxpbmUpOworCisJaWYgKCFyZXQpCisJeworCQl3cml0ZV9zdGRlcnIoXygiJXM6 IGNvdWxkIG5vdCBzdGFydCBzZXJ2ZXI6IGVycm9yIGNvZGUgJWx1XG4iKSwKKwkJCQkJIHBy b2duYW1lLCBjcmVhdGVfZXJyb3IpOworCQlyZXR1cm4gMDsKKwl9CisKKwlSZXN1bWVUaHJl YWQocGkuaFRocmVhZCk7CisJQ2xvc2VIYW5kbGUocGkuaFRocmVhZCk7CisKKwkvKgorCSAq IFdoZW4gdGhlcmUncyBubyBsb2cgZmlsZSwgd2FpdCBicmllZmx5IHRvIHNlZSBpZiB0aGUg cHJvY2VzcyBleGl0cworCSAqIGltbWVkaWF0ZWx5LiBUaGlzIGRpc3Rpbmd1aXNoZXMgcG9z dGdyZXMgLUMgcXVlcmllcyBmcm9tIGFjdHVhbAorCSAqIHNlcnZlciBzdGFydHVwLiBUd28g c2Vjb25kcyBpcyBsb25nIGVub3VnaCB0byBjYXRjaCBxdWljayBleGl0cworCSAqIGV2ZW4g b24gc2xvdyBDSSBzeXN0ZW1zLCBidXQgc3RpbGwgZmFzdCBlbm91Z2ggbm90IHRvIGJlIGFu bm95aW5nCisJICogZm9yIG5vcm1hbCBzZXJ2ZXIgc3RhcnR1cC4KKwkgKi8KKwlpZiAobG9n X2ZpbGUgPT0gTlVMTCkKKwl7CisJCURXT1JEIHdhaXRfcmVzdWx0OworCQlEV09SRCBleGl0 X2NvZGU7CisKKwkJd2FpdF9yZXN1bHQgPSBXYWl0Rm9yU2luZ2xlT2JqZWN0KHBpLmhQcm9j ZXNzLCAyMDAwKTsKKworCQlpZiAod2FpdF9yZXN1bHQgPT0gV0FJVF9USU1FT1VUKQorCQl7 CisJCQkvKiBTdGlsbCBydW5uaW5nIGFmdGVyIDIgc2Vjb25kcyAtIGFzc3VtZSByZWFsIHNl cnZlciBzdGFydHVwICovCisJCQlwb3N0bWFzdGVyUHJvY2VzcyA9IHBpLmhQcm9jZXNzOwor CQkJcmV0dXJuIChwaWRfdCkgcGkuZHdQcm9jZXNzSWQ7CisJCX0KKwkJZWxzZSBpZiAod2Fp dF9yZXN1bHQgPT0gV0FJVF9PQkpFQ1RfMCkKKwkJeworCQkJLyogUHJvY2VzcyBleGl0ZWQg cXVpY2tseSAtIHNlcnZlciBkaWRuJ3Qgc3RheSBydW5uaW5nICovCisJCQlleGl0X2NvZGUg PSAwOworCQkJR2V0RXhpdENvZGVQcm9jZXNzKHBpLmhQcm9jZXNzLCAmZXhpdF9jb2RlKTsK KwkJCUNsb3NlSGFuZGxlKHBpLmhQcm9jZXNzKTsKKwkJCXdyaXRlX3N0ZGVycihfKCIlczog Y291bGQgbm90IHN0YXJ0IHNlcnZlclxuIiksIHByb2duYW1lKTsKKwkJCXJldHVybiAwOwor CQl9CisJCWVsc2UKKwkJeworCQkJLyogV2FpdCBmYWlsZWQgKi8KKwkJCXdyaXRlX3N0ZGVy cihfKCIlczogZXJyb3Igd2FpdGluZyBmb3Igc2VydmVyOiBlcnJvciBjb2RlICVsdVxuIiks CisJCQkJCQkgcHJvZ25hbWUsIEdldExhc3RFcnJvcigpKTsKKwkJCUNsb3NlSGFuZGxlKHBp LmhQcm9jZXNzKTsKKwkJCXJldHVybiAwOworCQl9CisJfQorCisJcG9zdG1hc3RlclByb2Nl c3MgPSBwaS5oUHJvY2VzczsKKwlyZXR1cm4gKHBpZF90KSBwaS5kd1Byb2Nlc3NJZDsKK30K KyNlbmRpZgorCgogLyoKLSAqIFN0YXJ0IHRoZSBwb3N0bWFzdGVyIGFuZCByZXR1cm4gaXRz IFBJRC4KKyAqIHN0YXJ0X3Bvc3RtYXN0ZXIKKyAqCisgKiBXcmFwcGVyIGFyb3VuZCB0aGUg cGxhdGZvcm0tc3BlY2lmaWMgY29kZSB0byBsYXVuY2ggdGhlIHBvc3RtYXN0ZXIuCiAgKgot ICogQ3VycmVudGx5LCBvbiBXaW5kb3dzIHdoYXQgd2UgcmV0dXJuIGlzIHRoZSBQSUQgb2Yg dGhlIHNoZWxsIHByb2Nlc3MKLSAqIHRoYXQgbGF1bmNoZWQgdGhlIHBvc3RtYXN0ZXIgKGFu ZCwgd2UgdHJ1c3QsIGlzIHdhaXRpbmcgZm9yIGl0IHRvIGV4aXQpLgotICogU28gdGhlIFBJ RCBpcyB1c2FibGUgZm9yICJpcyB0aGUgcG9zdG1hc3RlciBzdGlsbCBydW5uaW5nIiBjaGVj a3MsCi0gKiBidXQgY2Fubm90IGJlIGNvbXBhcmVkIGRpcmVjdGx5IHRvIHBvc3RtYXN0ZXIu cGlkLgorICogT24gVW5peCwgd2UgZm9yayBhbmQgZXhlYy4gVGhlcmUncyBubyBleHRyYSBw cm9jZXNzIGxheWVyOworICogd2UgZ2V0IHRoZSBwb3N0Z3JlcyBQSUQgZGlyZWN0bHkuCiAg KgotICogT24gV2luZG93cywgd2UgYWxzbyBzYXZlIGFzaWRlIGEgaGFuZGxlIHRvIHRoZSBz aGVsbCBwcm9jZXNzIGluCi0gKiAicG9zdG1hc3RlclByb2Nlc3MiLCB3aGljaCB0aGUgY2Fs bGVyIHNob3VsZCBjbG9zZSB3aGVuIGRvbmUgd2l0aCBpdC4KKyAqIE9uIFdpbmRvd3MsIHdl IHVzZSBDcmVhdGVQcm9jZXNzIHRvIGxhdW5jaCBwb3N0Z3Jlcy5leGUgZGlyZWN0bHksIHdo aWNoCisgKiBnaXZlcyB1cyBpdHMgUElEIGltbWVkaWF0ZWx5LgogICovCi1zdGF0aWMgcGlk X3QKK3N0YXRpYyB2b2lkCiBzdGFydF9wb3N0bWFzdGVyKHZvaWQpCiB7CisjaWZkZWYgV0lO MzIKKwlwbV9waWQgPSBzdGFydF9wb3N0bWFzdGVyX3dpbjMyKCk7CisJaWYgKHBtX3BpZCA9 PSAwKQorCQlleGl0KDEpOworI2Vsc2UKIAljaGFyCSAgICpjbWQ7CisJaW50CQkJY21kbGVu OworCXBpZF90CQlmb3JrX3BpZDsKIAotI2lmbmRlZiBXSU4zMgotCXBpZF90CQlwbV9waWQ7 Ci0KLQkvKiBGbHVzaCBzdGRpbyBjaGFubmVscyBqdXN0IGJlZm9yZSBmb3JrLCB0byBhdm9p ZCBkb3VibGUtb3V0cHV0IHByb2JsZW1zICovCisJLyogRmx1c2ggc3RkaW8gdG8gYXZvaWQg ZG91YmxlLW91dHB1dCBwcm9ibGVtcyBhZnRlciBmb3JrICovCiAJZmZsdXNoKE5VTEwpOwog CiAjaWZkZWYgRVhFQ19CQUNLRU5ECiAJcGdfZGlzYWJsZV9hc2xyKCk7CiAjZW5kaWYKIAot CXBtX3BpZCA9IGZvcmsoKTsKLQlpZiAocG1fcGlkIDwgMCkKKwlmb3JrX3BpZCA9IGZvcmso KTsKKwlpZiAoZm9ya19waWQgPCAwKQogCXsKLQkJLyogZm9yayBmYWlsZWQgKi8KIAkJd3Jp dGVfc3RkZXJyKF8oIiVzOiBjb3VsZCBub3Qgc3RhcnQgc2VydmVyOiAlbVxuIiksCiAJCQkJ CSBwcm9nbmFtZSk7CiAJCWV4aXQoMSk7CiAJfQotCWlmIChwbV9waWQgPiAwKQorCWlmIChm b3JrX3BpZCA+IDApCiAJewotCQkvKiBmb3JrIHN1Y2NlZWRlZCwgaW4gcGFyZW50ICovCi0J CXJldHVybiBwbV9waWQ7CisJCS8qIFBhcmVudCBwcm9jZXNzICovCisJCXBtX3BpZCA9IGZv cmtfcGlkOworCQlyZXR1cm47CiAJfQogCi0JLyogZm9yayBzdWNjZWVkZWQsIGluIGNoaWxk ICovCisJLyogQ2hpbGQgcHJvY2VzcyAqLwogCiAJLyoKLQkgKiBJZiBwb3NzaWJsZSwgZGV0 YWNoIHRoZSBwb3N0bWFzdGVyIHByb2Nlc3MgZnJvbSB0aGUgbGF1bmNoaW5nIHByb2Nlc3MK LQkgKiBncm91cCBhbmQgbWFrZSBpdCBhIGdyb3VwIGxlYWRlciwgc28gdGhhdCBpdCBkb2Vz bid0IGdldCBzaWduYWxlZCBhbG9uZwotCSAqIHdpdGggdGhlIGN1cnJlbnQgZ3JvdXAgdGhh dCBsYXVuY2hlZCBpdC4KKwkgKiBEZXRhY2ggZnJvbSB0aGUgcGFyZW50J3MgcHJvY2VzcyBn cm91cCBzbyB3ZSBkb24ndCBnZXQgc2lnbmFsZWQKKwkgKiBhbG9uZyB3aXRoIGl0LiAgVGhp cyBpcyB0aGUgZXF1aXZhbGVudCBvZiB3aGF0IENSRUFURV9ORVdfUFJPQ0VTU19HUk9VUAor CSAqIGRvZXMgb24gV2luZG93cy4KIAkgKi8KICNpZmRlZiBIQVZFX1NFVFNJRAogCWlmIChz ZXRzaWQoKSA8IDApCkBAIC00ODIsMTEyICs3NDcsNzIgQEAgc3RhcnRfcG9zdG1hc3Rlcih2 b2lkKQogI2VuZGlmCiAKIAkvKgotCSAqIFNpbmNlIHRoZXJlIG1pZ2h0IGJlIHF1b3RlcyB0 byBoYW5kbGUgaGVyZSwgaXQgaXMgZWFzaWVyIHNpbXBseSB0byBwYXNzCi0JICogZXZlcnl0 aGluZyB0byBhIHNoZWxsIHRvIHByb2Nlc3MgdGhlbS4gIFVzZSBleGVjIHNvIHRoYXQgdGhl IHBvc3RtYXN0ZXIKLQkgKiBoYXMgdGhlIHNhbWUgUElEIGFzIHRoZSBjdXJyZW50IGNoaWxk IHByb2Nlc3MuCisJICogQnVpbGQgdGhlIHNoZWxsIGNvbW1hbmQuICBXZSB1c2UgImV4ZWMi IHNvIHRoZSBzaGVsbCByZXBsYWNlcyBpdHNlbGYKKwkgKiB3aXRoIHBvc3RncmVzLCByYXRo ZXIgdGhhbiBrZWVwaW5nIHRoZSBzaGVsbCBwcm9jZXNzIGFyb3VuZC4KIAkgKi8KIAlpZiAo bG9nX2ZpbGUgIT0gTlVMTCkKLQkJY21kID0gcHNwcmludGYoImV4ZWMgXCIlc1wiICVzJXMg PCBcIiVzXCIgPj4gXCIlc1wiIDI+JjEiLAotCQkJCQkgICBleGVjX3BhdGgsIHBnZGF0YV9v cHQsIHBvc3Rfb3B0cywKLQkJCQkJICAgREVWTlVMTCwgbG9nX2ZpbGUpOworCXsKKwkJY21k bGVuID0gc25wcmludGYoTlVMTCwgMCwgImV4ZWMgXCIlc1wiICVzJXMgPCBcIiVzXCIgPj4g XCIlc1wiIDI+JjEiLAorCQkJCQkJICBleGVjX3BhdGgsCisJCQkJCQkgIHBnZGF0YV9vcHQg PyBwZ2RhdGFfb3B0IDogIiIsCisJCQkJCQkgIHBvc3Rfb3B0cyA/IHBvc3Rfb3B0cyA6ICIi LAorCQkJCQkJICBERVZOVUxMLCBsb2dfZmlsZSk7CisJfQogCWVsc2UKLQkJY21kID0gcHNw cmludGYoImV4ZWMgXCIlc1wiICVzJXMgPCBcIiVzXCIgMj4mMSIsCi0JCQkJCSAgIGV4ZWNf cGF0aCwgcGdkYXRhX29wdCwgcG9zdF9vcHRzLCBERVZOVUxMKTsKLQotCSh2b2lkKSBleGVj bCgiL2Jpbi9zaCIsICIvYmluL3NoIiwgIi1jIiwgY21kLCAoY2hhciAqKSBOVUxMKTsKLQot CS8qIGV4ZWMgZmFpbGVkICovCi0Jd3JpdGVfc3RkZXJyKF8oIiVzOiBjb3VsZCBub3Qgc3Rh cnQgc2VydmVyOiAlbVxuIiksCi0JCQkJIHByb2duYW1lKTsKLQlleGl0KDEpOwotCi0JcmV0 dXJuIDA7CQkJCQkvKiBrZWVwIGR1bWIgY29tcGlsZXJzIHF1aWV0ICovCi0KLSNlbHNlCQkJ CQkJCS8qIFdJTjMyICovCi0KLQkvKgotCSAqIEFzIHdpdGggdGhlIFVuaXggY2FzZSwgaXQn cyBlYXNpZXN0IHRvIHVzZSB0aGUgc2hlbGwgKENNRC5FWEUpIHRvCi0JICogaGFuZGxlIHJl ZGlyZWN0aW9uIGV0Yy4gIFVuZm9ydHVuYXRlbHkgQ01ELkVYRSBsYWNrcyBhbnkgZXF1aXZh bGVudCBvZgotCSAqICJleGVjIiwgc28gd2UgZG9uJ3QgZ2V0IHRvIGZpbmQgb3V0IHRoZSBw b3N0bWFzdGVyJ3MgUElEIGltbWVkaWF0ZWx5LgotCSAqLwotCVBST0NFU1NfSU5GT1JNQVRJ T04gcGk7Ci0JY29uc3QgY2hhciAqY29tc3BlYzsKKwl7CisJCWNtZGxlbiA9IHNucHJpbnRm KE5VTEwsIDAsICJleGVjIFwiJXNcIiAlcyVzIDwgXCIlc1wiIDI+JjEiLAorCQkJCQkJICBl eGVjX3BhdGgsCisJCQkJCQkgIHBnZGF0YV9vcHQgPyBwZ2RhdGFfb3B0IDogIiIsCisJCQkJ CQkgIHBvc3Rfb3B0cyA/IHBvc3Rfb3B0cyA6ICIiLAorCQkJCQkJICBERVZOVUxMKTsKKwl9 CiAKLQkvKiBGaW5kIENNRC5FWEUgbG9jYXRpb24gdXNpbmcgQ09NU1BFQywgaWYgaXQncyBz ZXQgKi8KLQljb21zcGVjID0gZ2V0ZW52KCJDT01TUEVDIik7Ci0JaWYgKGNvbXNwZWMgPT0g TlVMTCkKLQkJY29tc3BlYyA9ICJDTUQiOworCWNtZCA9IHBnX21hbGxvYyhjbWRsZW4gKyAx KTsKIAogCWlmIChsb2dfZmlsZSAhPSBOVUxMKQogCXsKLQkJLyoKLQkJICogRmlyc3QsIG9w ZW4gdGhlIGxvZyBmaWxlIGlmIGl0IGV4aXN0cy4gIFRoZSBpZGVhIGlzIHRoYXQgaWYgdGhl Ci0JCSAqIGZpbGUgaXMgc3RpbGwgbG9ja2VkIGJ5IGEgcHJldmlvdXMgcG9zdG1hc3RlciBy dW4sIHdlJ2xsIHdhaXQgdW50aWwKLQkJICogaXQgY29tZXMgZnJlZSwgaW5zdGVhZCBvZiBm YWlsaW5nIHdpdGggRVJST1JfU0hBUklOR19WSU9MQVRJT04uCi0JCSAqIChJdCdkIGJlIGJl dHRlciB0byBvcGVuIHRoZSBmaWxlIGluIGEgc2hhcmluZy1mcmllbmRseSBtb2RlLCBidXQg d2UKLQkJICogY2FuJ3QgdXNlIENNRC5FWEUgdG8gZG8gdGhhdCwgc28gd29yayBhcm91bmQg aXQuICBOb3RlIHRoYXQgdGhlCi0JCSAqIHByZXZpb3VzIHBvc3RtYXN0ZXIgd2lsbCBzdGls bCBoYXZlIHRoZSBmaWxlIG9wZW4gZm9yIGEgc2hvcnQgdGltZQotCQkgKiBhZnRlciByZW1v dmluZyBwb3N0bWFzdGVyLnBpZC4pCi0JCSAqCi0JCSAqIElmIHRoZSBsb2cgZmlsZSBkb2Vz bid0IGV4aXN0LCB3ZSAqbXVzdCBub3QqIGNyZWF0ZSBpdCBoZXJlLiAgSWYgd2UKLQkJICog d2VyZSBsYXVuY2hlZCB3aXRoIGhpZ2hlciBwcml2aWxlZ2VzIHRoYW4gdGhlIHJlc3RyaWN0 ZWQgcHJvY2VzcwotCQkgKiB3aWxsIGhhdmUsIHRoZSBsb2cgZmlsZSBtaWdodCBlbmQgdXAg d2l0aCBwZXJtaXNzaW9ucyBzZXR0aW5ncyB0aGF0Ci0JCSAqIHByZXZlbnQgdGhlIHBvc3Rt YXN0ZXIgZnJvbSB3cml0aW5nIG9uIGl0LgotCQkgKi8KLQkJaW50CQkJZmQgPSBvcGVuKGxv Z19maWxlLCBPX1JEV1IsIDApOwotCi0JCWlmIChmZCA9PSAtMSkKLQkJewotCQkJLyoKLQkJ CSAqIEVOT0VOVCBpcyBleHBlY3RhYmxlIHNpbmNlIHdlIGRpZG4ndCB1c2UgT19DUkVBVC4g IE90aGVyd2lzZQotCQkJICogY29tcGxhaW4uICBXZSBjb3VsZCBqdXN0IGZhbGwgdGhyb3Vn aCBhbmQgbGV0IENNRC5FWEUgcmVwb3J0Ci0JCQkgKiB0aGUgcHJvYmxlbSwgYnV0IGl0cyBl cnJvciByZXBvcnRpbmcgaXMgcHJldHR5IG1pc2VyYWJsZS4KLQkJCSAqLwotCQkJaWYgKGVy cm5vICE9IEVOT0VOVCkKLQkJCXsKLQkJCQl3cml0ZV9zdGRlcnIoXygiJXM6IGNvdWxkIG5v dCBvcGVuIGxvZyBmaWxlIFwiJXNcIjogJW1cbiIpLAotCQkJCQkJCSBwcm9nbmFtZSwgbG9n X2ZpbGUpOwotCQkJCWV4aXQoMSk7Ci0JCQl9Ci0JCX0KLQkJZWxzZQotCQkJY2xvc2UoZmQp OwotCi0JCWNtZCA9IHBzcHJpbnRmKCJcIiVzXCIgL0MgXCJcIiVzXCIgJXMlcyA8IFwiJXNc IiA+PiBcIiVzXCIgMj4mMVwiIiwKLQkJCQkJICAgY29tc3BlYywgZXhlY19wYXRoLCBwZ2Rh dGFfb3B0LCBwb3N0X29wdHMsIERFVk5VTEwsIGxvZ19maWxlKTsKKwkJc25wcmludGYoY21k LCBjbWRsZW4gKyAxLCAiZXhlYyBcIiVzXCIgJXMlcyA8IFwiJXNcIiA+PiBcIiVzXCIgMj4m MSIsCisJCQkJIGV4ZWNfcGF0aCwKKwkJCQkgcGdkYXRhX29wdCA/IHBnZGF0YV9vcHQgOiAi IiwKKwkJCQkgcG9zdF9vcHRzID8gcG9zdF9vcHRzIDogIiIsCisJCQkJIERFVk5VTEwsIGxv Z19maWxlKTsKIAl9CiAJZWxzZQotCQljbWQgPSBwc3ByaW50ZigiXCIlc1wiIC9DIFwiXCIl c1wiICVzJXMgPCBcIiVzXCIgMj4mMVwiIiwKLQkJCQkJICAgY29tc3BlYywgZXhlY19wYXRo LCBwZ2RhdGFfb3B0LCBwb3N0X29wdHMsIERFVk5VTEwpOwotCi0JaWYgKCFDcmVhdGVSZXN0 cmljdGVkUHJvY2VzcyhjbWQsICZwaSwgZmFsc2UpKQogCXsKLQkJd3JpdGVfc3RkZXJyKF8o IiVzOiBjb3VsZCBub3Qgc3RhcnQgc2VydmVyOiBlcnJvciBjb2RlICVsdVxuIiksCi0JCQkJ CSBwcm9nbmFtZSwgKHVuc2lnbmVkIGxvbmcpIEdldExhc3RFcnJvcigpKTsKLQkJZXhpdCgx KTsKKwkJc25wcmludGYoY21kLCBjbWRsZW4gKyAxLCAiZXhlYyBcIiVzXCIgJXMlcyA8IFwi JXNcIiAyPiYxIiwKKwkJCQkgZXhlY19wYXRoLAorCQkJCSBwZ2RhdGFfb3B0ID8gcGdkYXRh X29wdCA6ICIiLAorCQkJCSBwb3N0X29wdHMgPyBwb3N0X29wdHMgOiAiIiwKKwkJCQkgREVW TlVMTCk7CiAJfQotCS8qIERvbid0IGNsb3NlIGNvbW1hbmQgcHJvY2VzcyBoYW5kbGUgaGVy ZTsgY2FsbGVyIG11c3QgZG8gc28gKi8KLQlwb3N0bWFzdGVyUHJvY2VzcyA9IHBpLmhQcm9j ZXNzOwotCUNsb3NlSGFuZGxlKHBpLmhUaHJlYWQpOwotCXJldHVybiBwaS5kd1Byb2Nlc3NJ ZDsJCS8qIFNoZWxsJ3MgUElELCBub3QgcG9zdG1hc3RlcidzISAqLworCisJKHZvaWQpIGV4 ZWNsKCIvYmluL3NoIiwgIi9iaW4vc2giLCAiLWMiLCBjbWQsIChjaGFyICopIE5VTEwpOwor CisJLyogZXhlYyBmYWlsZWQgKi8KKwl3cml0ZV9zdGRlcnIoXygiJXM6IGNvdWxkIG5vdCBz dGFydCBzZXJ2ZXI6ICVtXG4iKSwKKwkJCQkgcHJvZ25hbWUpOworCWV4aXQoMSk7CisKICNl bmRpZgkJCQkJCQkvKiBXSU4zMiAqLwogfQogCiAKLQogLyoKLSAqIFdhaXQgZm9yIHRoZSBw b3N0bWFzdGVyIHRvIGJlY29tZSByZWFkeS4KKyAqIHdhaXRfZm9yX3Bvc3RtYXN0ZXJfc3Rh cnQKKyAqCisgKiBXYWl0IGZvciB0aGUgcG9zdG1hc3RlciB0byBmaW5pc2ggc3RhcnRpbmcg dXAgYW5kIGJlY29tZSByZWFkeSB0bworICogYWNjZXB0IGNvbm5lY3Rpb25zLgogICoKLSAq IE9uIFVuaXgsIHBtX3BpZCBpcyB0aGUgUElEIG9mIHRoZSBqdXN0LWxhdW5jaGVkIHBvc3Rt YXN0ZXIuICBPbiBXaW5kb3dzLAotICogaXQgbWF5IGJlIHRoZSBQSUQgb2YgYW4gYW5jZXN0 b3Igc2hlbGwgcHJvY2Vzcywgc28gd2UgY2FuJ3QgY2hlY2sgdGhlCi0gKiBjb250ZW50cyBv ZiBwb3N0bWFzdGVyLnBpZCBxdWl0ZSBhcyBjYXJlZnVsbHkuCisgKiBPbiBlbnRyeSwgcG1f cGlkIHNob3VsZCBiZSB0aGUgUElEIG9mIHRoZSBwb3N0bWFzdGVyIHdlIGp1c3QgbGF1bmNo ZWQuCisgKiBXZSBwb2xsIHBvc3RtYXN0ZXIucGlkIHRvIHNlZSB3aGVuIGl0J3MgYmVlbiBj cmVhdGVkIGFuZCB3aGV0aGVyIHRoZQorICogUElEIGluIGl0IG1hdGNoZXMgcG1fcGlkLiAg T25jZSB3ZSBzZWUgYSBtYXRjaGluZyBQSUQgYW5kIHRoZSBzdGF0dXMKKyAqIGxpbmUgc2F5 cyAicmVhZHkiLCB3ZSdyZSBkb25lLgogICoKLSAqIE9uIFdpbmRvd3MsIHRoZSBzdGF0aWMg dmFyaWFibGUgcG9zdG1hc3RlclByb2Nlc3MgaXMgYW4gaW1wbGljaXQgYXJndW1lbnQKLSAq IHRvIHRoaXMgcm91dGluZTsgaXQgY29udGFpbnMgYSBoYW5kbGUgdG8gdGhlIHBvc3RtYXN0 ZXIgcHJvY2VzcyBvciBhbgotICogYW5jZXN0b3Igc2hlbGwgcHJvY2VzcyB0aGVyZW9mLgor ICogT24gV2luZG93cywgd2UgYWxzbyB1c2UgdGhlIHBvc3RtYXN0ZXJQcm9jZXNzIGhhbmRs ZSAoc2V0IGJ5CisgKiBzdGFydF9wb3N0bWFzdGVyX3dpbjMyKSB0byBkZXRlY3QgaWYgdGhl IHByb2Nlc3MgZGllcyB1bmV4cGVjdGVkbHkuCiAgKgotICogTm90ZSB0aGF0IHRoZSBjaGVj a3BvaW50IHBhcmFtZXRlciBlbmFibGVzIGEgV2luZG93cyBzZXJ2aWNlIGNvbnRyb2wKLSAq IG1hbmFnZXIgY2hlY2twb2ludCwgaXQncyBnb3Qgbm90aGluZyB0byBkbyB3aXRoIGRhdGFi YXNlIGNoZWNrcG9pbnRzISEKKyAqIFJldHVybnMgUE9TVE1BU1RFUl9SRUFEWSBpZiBhbGwg aXMgd2VsbCwgUE9TVE1BU1RFUl9TVElMTF9TVEFSVElORyBpZgorICogd2UgcmFuIG91dCBv ZiB0aW1lLCBvciBQT1NUTUFTVEVSX0ZBSUxFRCBpZiB0aGUgcG9zdG1hc3RlciBkaWVkLgog ICovCiBzdGF0aWMgV2FpdFBNUmVzdWx0CiB3YWl0X2Zvcl9wb3N0bWFzdGVyX3N0YXJ0KHBp ZF90IHBtX3BpZCwgYm9vbCBkb19jaGVja3BvaW50KQpAQCAtNjAwLDYzICs4MjUsNDggQEAg d2FpdF9mb3JfcG9zdG1hc3Rlcl9zdGFydChwaWRfdCBwbV9waWQsIGJvb2wgZG9fY2hlY2tw b2ludCkKIAkJaW50CQkJbnVtbGluZXM7CiAKIAkJLyoKLQkJICogVHJ5IHRvIHJlYWQgdGhl IHBvc3RtYXN0ZXIucGlkIGZpbGUuICBJZiBpdCdzIG5vdCB2YWxpZCwgb3IgaWYgdGhlCi0J CSAqIHN0YXR1cyBsaW5lIGlzbid0IHRoZXJlIHlldCwganVzdCBrZWVwIHdhaXRpbmcuCisJ CSAqIFRyeSB0byByZWFkIHBvc3RtYXN0ZXIucGlkLiAgSWYgaXQncyBub3QgdGhlcmUgeWV0 LCBvciBkb2Vzbid0CisJCSAqIGhhdmUgZW5vdWdoIGxpbmVzLCBqdXN0IG1vdmUgb24gdG8g dGhlIG5leHQgaXRlcmF0aW9uLgogCQkgKi8KIAkJaWYgKChvcHRsaW5lcyA9IHJlYWRmaWxl KHBpZF9maWxlLCAmbnVtbGluZXMpKSAhPSBOVUxMICYmCiAJCQludW1saW5lcyA+PSBMT0NL X0ZJTEVfTElORV9QTV9TVEFUVVMpCiAJCXsKLQkJCS8qIEZpbGUgaXMgY29tcGxldGUgZW5v dWdoIGZvciB1cywgcGFyc2UgaXQgKi8KIAkJCXBpZF90CQlwbXBpZDsKIAkJCXRpbWVfdAkJ cG1zdGFydDsKIAogCQkJLyoKLQkJCSAqIE1ha2Ugc2FuaXR5IGNoZWNrcy4gIElmIGl0J3Mg Zm9yIHRoZSB3cm9uZyBQSUQsIG9yIHRoZSByZWNvcmRlZAotCQkJICogc3RhcnQgdGltZSBp cyBiZWZvcmUgcGdfY3RsIHN0YXJ0ZWQsIHRoZW4gZWl0aGVyIHdlIGFyZSBsb29raW5nCi0J CQkgKiBhdCB0aGUgd3JvbmcgZGF0YSBkaXJlY3RvcnksIG9yIHRoaXMgaXMgYSBwcmUtZXhp c3RpbmcgcGlkZmlsZQotCQkJICogdGhhdCBoYXNuJ3QgKHlldD8pIGJlZW4gb3ZlcndyaXR0 ZW4gYnkgb3VyIGNoaWxkIHBvc3RtYXN0ZXIuCi0JCQkgKiBBbGxvdyAyIHNlY29uZHMgc2xv cCBmb3IgcG9zc2libGUgY3Jvc3MtcHJvY2VzcyBjbG9jayBza2V3LgorCQkJICogQ2hlY2sg dGhhdCB0aGUgUElEIGFuZCBzdGFydCB0aW1lIGluIHRoZSBmaWxlIG1hdGNoIHdoYXQgd2UK KwkJCSAqIGV4cGVjdC4gIEEgbWlzbWF0Y2ggbWVhbnMgZWl0aGVyIHdlJ3JlIGxvb2tpbmcg YXQgdGhlIHdyb25nCisJCQkgKiBkYXRhIGRpcmVjdG9yeSwgb3IgdGhpcyBpcyBhIHN0YWxl IHBpZGZpbGUgbGVmdCBvdmVyIGZyb20gYQorCQkJICogcHJldmlvdXMgcG9zdG1hc3Rlci4g IFdlIGFsbG93IDIgc2Vjb25kcyBzbG9wIGluIHRoZSB0aW1lc3RhbXAKKwkJCSAqIGNvbXBh cmlzb24gdG8gaGFuZGxlIGNsb2NrIHNrZXcgYmV0d2VlbiBwcm9jZXNzZXMuCiAJCQkgKi8K IAkJCXBtcGlkID0gYXRvbChvcHRsaW5lc1tMT0NLX0ZJTEVfTElORV9QSUQgLSAxXSk7CiAJ CQlwbXN0YXJ0ID0gYXRvbGwob3B0bGluZXNbTE9DS19GSUxFX0xJTkVfU1RBUlRfVElNRSAt IDFdKTsKLQkJCWlmIChwbXN0YXJ0ID49IHN0YXJ0X3RpbWUgLSAyICYmCi0jaWZuZGVmIFdJ TjMyCi0JCQkJcG1waWQgPT0gcG1fcGlkCi0jZWxzZQotCQkJLyogV2luZG93cyBjYW4gb25s eSByZWplY3Qgc3RhbmRhbG9uZS1iYWNrZW5kIFBJRHMgKi8KLQkJCQlwbXBpZCA+IDAKLSNl bmRpZgotCQkJCSkKKworCQkJaWYgKHBtc3RhcnQgPj0gc3RhcnRfdGltZSAtIDIgJiYgcG1w aWQgPT0gcG1fcGlkKQogCQkJewogCQkJCS8qCi0JCQkJICogT0ssIHNlZW1zIHRvIGJlIGEg dmFsaWQgcGlkZmlsZSBmcm9tIG91ciBjaGlsZC4gIENoZWNrIHRoZQotCQkJCSAqIHN0YXR1 cyBsaW5lICh0aGlzIGFzc3VtZXMgYSB2MTAgb3IgbGF0ZXIgc2VydmVyKS4KKwkJCQkgKiBJ dCdzIHRoZSByaWdodCBwaWRmaWxlLiAgQ2hlY2sgd2hldGhlciB0aGUgcG9zdG1hc3RlciBp cworCQkJCSAqIHJlYWR5IHRvIGFjY2VwdCBjb25uZWN0aW9ucy4KIAkJCQkgKi8KIAkJCQlj aGFyCSAgICpwbXN0YXR1cyA9IG9wdGxpbmVzW0xPQ0tfRklMRV9MSU5FX1BNX1NUQVRVUyAt IDFdOwogCiAJCQkJaWYgKHN0cmNtcChwbXN0YXR1cywgUE1fU1RBVFVTX1JFQURZKSA9PSAw IHx8CiAJCQkJCXN0cmNtcChwbXN0YXR1cywgUE1fU1RBVFVTX1NUQU5EQlkpID09IDApCiAJ CQkJewotCQkJCQkvKiBwb3N0bWFzdGVyIGlzIGRvbmUgc3RhcnRpbmcgdXAgKi8KIAkJCQkJ ZnJlZV9yZWFkZmlsZShvcHRsaW5lcyk7CiAJCQkJCXJldHVybiBQT1NUTUFTVEVSX1JFQURZ OwogCQkJCX0KIAkJCX0KKwkJCWZyZWVfcmVhZGZpbGUob3B0bGluZXMpOwogCQl9CiAKLQkJ LyoKLQkJICogRnJlZSB0aGUgcmVzdWx0cyBvZiByZWFkZmlsZS4KLQkJICoKLQkJICogVGhp cyBpcyBzYWZlIHRvIGNhbGwgZXZlbiBpZiBvcHRsaW5lcyBpcyBOVUxMLgotCQkgKi8KLQkJ ZnJlZV9yZWFkZmlsZShvcHRsaW5lcyk7CisKIAogCQkvKgotCQkgKiBDaGVjayB3aGV0aGVy IHRoZSBjaGlsZCBwb3N0bWFzdGVyIHByb2Nlc3MgaXMgc3RpbGwgYWxpdmUuICBUaGlzCi0J CSAqIGxldHMgdXMgZXhpdCBlYXJseSBpZiB0aGUgcG9zdG1hc3RlciBmYWlscyBkdXJpbmcg c3RhcnR1cC4KLQkJICoKLQkJICogT24gV2luZG93cywgd2UgbWF5IGJlIGNoZWNraW5nIHRo ZSBwb3N0bWFzdGVyJ3MgcGFyZW50IHNoZWxsLCBidXQKLQkJICogdGhhdCdzIGZpbmUgZm9y IHRoaXMgcHVycG9zZS4KKwkJICogQ2hlY2sgd2hldGhlciB0aGUgcG9zdG1hc3RlciBwcm9j ZXNzIGlzIHN0aWxsIGFsaXZlLiAgSWYgaXQncworCQkgKiBnb25lLCB0aGVyZSdzIG5vIHBv aW50IGluIHdhaXRpbmcgYW55IGxvbmdlci4KIAkJICovCiAJCXsKIAkJCWJvb2wJCXBtX2Rp ZWQ7CkBAIC02NjksNyArODc5LDEwIEBAIHdhaXRfZm9yX3Bvc3RtYXN0ZXJfc3RhcnQocGlk X3QgcG1fcGlkLCBib29sIGRvX2NoZWNrcG9pbnQpCiAjZW5kaWYKIAkJCWlmIChwbV9kaWVk KQogCQkJewotCQkJCS8qIFNlZSBpZiBwb3N0bWFzdGVyIHRlcm1pbmF0ZWQgaW50ZW50aW9u YWxseSAqLworCQkJCS8qCisJCQkJICogUG9zdG1hc3RlciBkaWVkLiAgQ2hlY2sgaWYgaXQg d2FzIGFuIGludGVudGlvbmFsIHNodXRkb3duCisJCQkJICogZHVyaW5nIHJlY292ZXJ5ICh3 aGljaCBpcyBPSykgb3IgYW4gYWN0dWFsIGZhaWx1cmUuCisJCQkJICovCiAJCQkJaWYgKGdl dF9jb250cm9sX2Ric3RhdGUoKSA9PSBEQl9TSFVURE9XTkVEX0lOX1JFQ09WRVJZKQogCQkJ CQlyZXR1cm4gUE9TVE1BU1RFUl9TSFVURE9XTl9JTl9SRUNPVkVSWTsKIAkJCQllbHNlCkBA IC02NzcsMTkgKzg5MCwxOCBAQCB3YWl0X2Zvcl9wb3N0bWFzdGVyX3N0YXJ0KHBpZF90IHBt X3BpZCwgYm9vbCBkb19jaGVja3BvaW50KQogCQkJfQogCQl9CiAKLQkJLyogU3RhcnR1cCBz dGlsbCBpbiBwcm9jZXNzOyB3YWl0LCBwcmludGluZyBhIGRvdCBvbmNlIHBlciBzZWNvbmQg Ki8KKwkJLyogU3RpbGwgc3RhcnRpbmcgdXAuICBQcmludCBhIGRvdCBvbmNlIHBlciBzZWNv bmQgZm9yIHVzZXIgZmVlZGJhY2sgKi8KIAkJaWYgKGkgJSBXQUlUU19QRVJfU0VDID09IDAp CiAJCXsKICNpZmRlZiBXSU4zMgorCQkJLyoKKwkJCSAqIE9uIFdpbmRvd3MsIGlmIHdlJ3Jl IHJ1bm5pbmcgYXMgYSBzZXJ2aWNlLCBpbmNyZW1lbnQgdGhlCisJCQkgKiBjaGVja3BvaW50 IGNvdW50ZXIgc28gdGhlIHNlcnZpY2UgY29udHJvbCBtYW5hZ2VyIGRvZXNuJ3QKKwkJCSAq IHRoaW5rIHdlJ3ZlIGh1bmcuICAoVGhpcyBoYXMgbm90aGluZyB0byBkbyB3aXRoIGRhdGFi YXNlCisJCQkgKiBjaGVja3BvaW50cywgaXQncyBhIFdpbmRvd3Mgc2VydmljZSB0aGluZy4p CisJCQkgKi8KIAkJCWlmIChkb19jaGVja3BvaW50KQogCQkJewotCQkJCS8qCi0JCQkJICog SW5jcmVtZW50IHRoZSB3YWl0IGhpbnQgYnkgNiBzZWNzIChjb25uZWN0aW9uIHRpbWVvdXQg KwotCQkJCSAqIHNsZWVwKS4gIFdlIG11c3QgZG8gdGhpcyB0byBpbmRpY2F0ZSB0byB0aGUg U0NNIHRoYXQgb3VyCi0JCQkJICogc3RhcnR1cCB0aW1lIGlzIGNoYW5naW5nLCBvdGhlcndp c2UgaXQnbGwgdXN1YWxseSBzZW5kIGEKLQkJCQkgKiBzdG9wIHNpZ25hbCBhZnRlciAyMCBz ZWNvbmRzLCBkZXNwaXRlIGluY3JlbWVudGluZyB0aGUKLQkJCQkgKiBjaGVja3BvaW50IGNv dW50ZXIuCi0JCQkJICovCiAJCQkJc3RhdHVzLmR3V2FpdEhpbnQgKz0gNjAwMDsKIAkJCQlz dGF0dXMuZHdDaGVja1BvaW50Kys7CiAJCQkJU2V0U2VydmljZVN0YXR1cyhoU3RhdHVzLCAo TFBTRVJWSUNFX1NUQVRVUykgJnN0YXR1cyk7CkBAIC03MDIsNyArOTE0LDcgQEAgd2FpdF9m b3JfcG9zdG1hc3Rlcl9zdGFydChwaWRfdCBwbV9waWQsIGJvb2wgZG9fY2hlY2twb2ludCkK IAkJcGdfdXNsZWVwKFVTRUNfUEVSX1NFQyAvIFdBSVRTX1BFUl9TRUMpOwogCX0KIAotCS8q IG91dCBvZiBwYXRpZW5jZTsgcmVwb3J0IHRoYXQgcG9zdG1hc3RlciBpcyBzdGlsbCBzdGFy dGluZyB1cCAqLworCS8qIFJhbiBvdXQgb2YgdGltZSAqLwogCXJldHVybiBQT1NUTUFTVEVS X1NUSUxMX1NUQVJUSU5HOwogfQogCkBAIC05MzEsOCArMTE0Myw3IEBAIHN0YXRpYyB2b2lk CiBkb19zdGFydCh2b2lkKQogewogCXBpZF90CQlvbGRfcGlkID0gMDsKLQlwaWRfdAkJcG1f cGlkOwotCisKIAlpZiAoY3RsX2NvbW1hbmQgIT0gUkVTVEFSVF9DT01NQU5EKQogCXsKIAkJ b2xkX3BpZCA9IGdldF9wZ3BpZChmYWxzZSk7CkBAIC05NzAsNyArMTE4MSwxMiBAQCBkb19z dGFydCh2b2lkKQogCX0KICNlbmRpZgogCi0JcG1fcGlkID0gc3RhcnRfcG9zdG1hc3Rlcigp OworCXN0YXJ0X3Bvc3RtYXN0ZXIoKTsKKwlpZiAocG1fcGlkID09IDApCisJeworCQl3cml0 ZV9zdGRlcnIoXygiJXM6IGNvdWxkIG5vdCBzdGFydCBzZXJ2ZXJcbiIpLCBwcm9nbmFtZSk7 CisJCWV4aXQoMSk7CisJfQogCiAJaWYgKGRvX3dhaXQpCiAJewotLSAKMi40Ni4wLndpbmRv d3MuMQoK --------------dz0R3IO7rxyFclB2JtGLZA6S--