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 1uUw6P-00AoBx-1J for pgsql-hackers@arkaria.postgresql.org; Thu, 26 Jun 2025 23:33: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 1uUw6L-00FoSp-7k for pgsql-hackers@arkaria.postgresql.org; Thu, 26 Jun 2025 23:33:53 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1uUw6K-00FoSc-Ge for pgsql-hackers@lists.postgresql.org; Thu, 26 Jun 2025 23:33:53 +0000 Received: from mail-qv1-xf44.google.com ([2607:f8b0:4864:20::f44]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.96) (envelope-from ) id 1uUw6I-004BHA-09 for pgsql-hackers@lists.postgresql.org; Thu, 26 Jun 2025 23:33:51 +0000 Received: by mail-qv1-xf44.google.com with SMTP id 6a1803df08f44-6face367320so16204946d6.3 for ; Thu, 26 Jun 2025 16:33:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=enterprisedb.com; s=google; t=1750980828; x=1751585628; darn=lists.postgresql.org; h=cc:to:subject:message-id:date:from:mime-version:from:to:cc:subject :date:message-id:reply-to; bh=VOsy3MjfT6Kj/PJfRN9SgsPXincv9YdDIe2OgqM5dyY=; b=NeUBytEAOS/1Lje8eahhRjQ/maGd3CwFoJ4zg4HHzxnd0eBFQz/7WLYttwsaDMUUMP eu+zOlwXcdlOrFzWhb3sqtxDwUW+hcCupZ3ZkDhdmdGZSq0mwTyTDUuXH3t/s5cd2vBx t0oiaB3SZNehriR9oW588O03tO6T+LeBptcDqiwsptWAFo1m1jB0vO/6noTdRikVCfnt ypdQX3+1D/YlfTbZG4JYlyZIWibzFkCdhKfhKLr9XzkFGksHxvnw4x95goigq2XlXXwm JxgfL1tgYPr4zS9wuDgPqgEztbIo0M3IXURbamyJtVeZj/9OTLwKo7BsJWAZGe6kLf4f BHZw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1750980828; x=1751585628; h=cc:to:subject:message-id:date:from:mime-version:x-gm-message-state :from:to:cc:subject:date:message-id:reply-to; bh=VOsy3MjfT6Kj/PJfRN9SgsPXincv9YdDIe2OgqM5dyY=; b=kLHRCeet57guOAYmgMfjXgDNH1usN5am15M+RbBs/GpOKqFXG7952gsjgIyPHkJwhE Kqj6nV18HskZnX217YxxmBd0zVJadPqFItkF42dwnBjWnaQUnG9M1G/fn0PDUD/kOe8i nmPDis3pVempi7qigyjpvvCLvmFepr3myVUkxAixpCBkptyfgatDzRxIBirMwSNiixcb Ml2vYeADr2dZ2KLJ5Oir05KnKQ1ACStCkq2cSAar2i2xC5SZ1zFWPTd+kxFYWSIKmv7p kj/Dcs2wuY5G4vE/6QHN/6kucWc+VO1YjMYVE3+Pzfg8Qo3cfJRgZYTrmzQPS7bxImQd 8hwA== X-Gm-Message-State: AOJu0Yxf2xdxuFJo9c+vNEw/D2sWPi+kqUEk3Gja/r0EpI/2QhD9OOzO uC7X0ihrEh66ImehsxAYJ/njd4BOewrHdT4aEk7Pvzox1Yxy5Syy0/HHO/pD5pPX1YANTK31f+B pVcCQrXkRqgrncsdKHmZ0ENqwKG2cWKtQlqNepqH5XwR/9EKxDD6mKwPJ X-Gm-Gg: ASbGncswfLBjyKdtUmnq54gpQLQXJ/xD23lMZoyWSZ/9KqNKjaCnID/rlYwnjS4k1pS 5XBU10QCAsz/egy5QDWMp7CtGfGoB415dCuAAJ1WOGpcRrB4p8DSVi2IJK8Q0iN7GWTmLndaHHK dBjGvTBy2yKNuPzpMx7QGkGnUPgCkcp1nG3RZ0UGKU9X0= X-Google-Smtp-Source: AGHT+IEvS18KZ5FZbfqBlvvpbREpzBf2DWDtu6koxYgEsAksBViMY54ccjxBQeeTOTtOmsBfO0H7o6OMRSTt2xWkbg0= X-Received: by 2002:ad4:5cea:0:b0:6fa:ccb6:603d with SMTP id 6a1803df08f44-70001e5be39mr25818006d6.16.1750980828342; Thu, 26 Jun 2025 16:33:48 -0700 (PDT) MIME-Version: 1.0 From: Jacob Champion Date: Thu, 26 Jun 2025 16:33:35 -0700 X-Gm-Features: Ac12FXwJnDMXTFaBolkLsJIGK3W9oGjO5w7addYBtuNDw7u5IEVJ7AM1rtgUN-E Message-ID: Subject: [PATCH] OAuth: fix performance bug with stuck multiplexer events To: PostgreSQL Hackers Cc: Daniel Gustafsson , Thomas Munro , Peter Eisentraut Content-Type: multipart/mixed; boundary="0000000000004886fa063881fe30" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --0000000000004886fa063881fe30 Content-Type: text/plain; charset="UTF-8" Hi all, The current implementation of the OAuth flow is overly eager to signal readiness when there's nothing to do, so sometimes we burn CPU for no reason. This was discussed briefly back in [1], but I'll summarize here so no one has to dig through that megathread. = Background = A major interaction between libpq and libcurl happens through a callback -- register_socket() in oauth-curl.c -- which links the sockets that Curl cares about into a single descriptor that our clients can wait on. This descriptor, which is either an epoll set or a kqueue, is called the multiplexer. Curl has wide latitude to make this interaction as simple or as complicated as it wants, and the complexity additionally depends on the transport in use. For a simple HTTP request/response with older Curls, the callback order might look like - wait for reads on fd 5 - done with fd 5 But for a modern dual-stack system speaking HTTPS, you might get something like - wait for writes on fd 6, time out after 200ms - wait for writes on fd 7 - done with fd 6, cancel the timeout - wait for reads only on fd 7, time out after five minutes - wait for both reads and writes on fd 7 ... - done with fd 7, cancel the timeout = Getting Stuck = The Linux/epoll implementation handles the latter case well (with one caveat, discussed later), but with the BSD/kqueue implementation, the multiplexer can get "stuck open" on stale events that Curl no longer cares about, and clients of libpq can loop on PQconnectPoll() pointlessly. The flow still works -- there's no bug in functionality, just in performance -- but that also makes it hard to detect in tests. And for simpler network cases (the ones in our tests), the bug is nearly invisible, because Curl will unregister descriptors and clear the stuck events before they have any real effect. 0001, attached, fixes this by counting the number of outstanding event registrations and draining up to that many events from the kqueue after libcurl gives control back to us. This ensures that any stale events will be knocked back down. (This design was originally suggested by Thomas Munro in a related conversation about kqueue corner cases; thanks Thomas!) If you follow the flow from start to finish, you may notice the following oddity: I took great pains not to track which events had been set, instead telling libcurl "something happened, figure it out" -- and now in this patchset I'm pulling all of those events off in a big wave only to discard them. As punishment for trying to keep the epoll side of things simple, I'm now having to add unnecessary complexity to the kqueue side. Seems like I'll eventually need to balance the two out again. = Timeouts = There is a similar "stale event" bug for the timer, with both epoll and kqueue: if Curl does not disable a timeout explicitly after it fires, that timer's descriptor will simply remain signaled until something else happens to set it. Unfortunately, we can't solve this bug in the same place as 0001. If we clear stale timers after calling into Curl, that would introduce a race: Curl may have set a short timeout that has already passed, and we need that event to remain signaled so that the client will call us back. So expired timers have to be cleared _before_ calling back into Curl, which I have done in 0002. As part of that, I've strengthened the timer_expired() API so that it always returns false when the timer is disabled. It was previously a don't-care, since we only called it when we knew the timer must be running, so the kqueue and epoll implementations used to give different answers. = Testing = It was hard to notice any of this with the current tests, because they're mostly focused on ensuring that the flow works, not on internal efficiency. I tried to find a way to internally detect when a file descriptor had gone stale by accident, but I think it's hard to do that without false positives if we don't know what Curl is doing. In the end, I decided to test a heuristic: we expect roughly 5-15 calls for these simple localhost flows, so if we see something more than an order of magnitude above that, something is wrong. (When "bad behavior" happens in the CI, I see hundreds or thousands of calls.) This is implemented in 0003 by simply counting the number of calls and printing them at the end of the flow in debug mode. I strengthened a bunch of postconditions in the first two patches, so to try to prevent decay (and keep other maintainers from having to remember all this), I've added a unit test executable that pins many internal expectations. It's essentially a version of the libpq-oauth plugin which has been given a main() function and TAP macros. This is done in 0004. I feel confident that these new tests are useful, because: - The new unit tests caught that my initial register_socket attempt, written on macOS, did not work on the other BSDs. (EV_RECEIPT works differently there.) - If I revert the changes to register_socket, the new unit tests fail on all BSDs in the CI, and the call-count test fails on NetBSD and OpenBSD. - If I comment out the new call to drain_timer_events(), the call-count test fails on macOS. - If I revert the changes to timer_expired, the new unit tests fail on Linux. (There are no user-visible effects of that change, because it doesn't lead to more calls.) Unfortunately, if I just comment out the new call to drain_socket_events(), nothing fails in the CI. :( But my personal test suite (which makes use of TLS plus dual-stack sockets) does notice the regression in the call count immediately, with some tests using tens of thousands of calls for a single client flow without the fix. I hope that's good enough for now, because I'm not sure if I can safely push the additional TLS infrastructure into the oauth_validator tests for 18. My plan, if this code seems reasonable, is to backport 0001-0003, but keep the larger 0004 on HEAD only until it has proven to be stable. It's a big new suite and I want to make sure it's not flapping on some buildfarm animal. Eventually I'll backport that too. WDYT? Thanks, --Jacob [1] https://postgr.es/m/CAOYmi%2Bn4EDOOUL27_OqYT2-F2rS6S%2B3mK-ppWb2Ec92UEoUbYA%40mail.gmail.com --0000000000004886fa063881fe30 Content-Type: application/octet-stream; name="0001-oauth-Remove-stale-events-from-the-kqueue-multiplexe.patch" Content-Disposition: attachment; filename="0001-oauth-Remove-stale-events-from-the-kqueue-multiplexe.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mce0nmhk0 RnJvbSBmZDk2NjAxNzAwNzNmZDg2ZGEwMzM2MDhmNTJjNjA0Yjk2NjRhZTkxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWNvYiBDaGFtcGlvbiA8amFjb2IuY2hhbXBpb25AZW50ZXJw cmlzZWRiLmNvbT4KRGF0ZTogVHVlLCAxMCBKdW4gMjAyNSAxNjozODo1OSAtMDcwMApTdWJqZWN0 OiBbUEFUQ0ggMS80XSBvYXV0aDogUmVtb3ZlIHN0YWxlIGV2ZW50cyBmcm9tIHRoZSBrcXVldWUg bXVsdGlwbGV4ZXIKCklmIGEgc29ja2V0IGlzIGFkZGVkIHRvIHRoZSBrcXVldWUsIGJlY29tZXMg cmVhZGFibGUvd3JpdGFibGUsIGFuZApzdWJzZXF1ZW50bHkgYmVjb21lcyBub24tcmVhZGFibGUv d3JpdGFibGUgYWdhaW4sIHRoZSBrcXVldWUgaXRzZWxmIHdpbGwKcmVtYWluIHJlYWRhYmxlIHVu dGlsIGVpdGhlciB0aGUgc29ja2V0IHJlZ2lzdHJhdGlvbiBpcyByZW1vdmVkLCBvciB0aGUKc3Rh bGUgZXZlbnQgaXMgY2xlYXJlZCB2aWEgYSBjYWxsIHRvIGtldmVudCgpLgoKSW4gbWFueSBzaW1w bGUgY2FzZXMsIEN1cmwgaXRzZWxmIHdpbGwgcmVtb3ZlIHRoZSBzb2NrZXQgcmVnaXN0cmF0aW9u CnF1aWNrbHksIGJ1dCBpbiByZWFsLXdvcmxkIHVzYWdlLCB0aGlzIGlzIG5vdCBndWFyYW50ZWVk IHRvIGhhcHBlbi4gVGhlCmtxdWV1ZSBjYW4gdGhlbiByZW1haW4gc3R1Y2sgaW4gYSBwZXJtYW5l bnRseSByZWFkYWJsZSBzdGF0ZSB1bnRpbCB0aGUKcmVxdWVzdCBlbmRzLCB3aGljaCByZXN1bHRz IGluIHBvaW50bGVzcyB3YWtldXBzIGZvciB0aGUgY2xpZW50IGFuZAp3YXN0ZWQgQ1BVIHRpbWUu CgpJbXBsZW1lbnQgZHJhaW5fc29ja2V0X2V2ZW50cygpIHRvIGNhbGwga2V2ZW50KCkgYW5kIHVu c3RpY2sgYW55IHN0YWxlCmV2ZW50cy4gVGhpcyBpcyBjYWxsZWQgcmlnaHQgYWZ0ZXIgZHJpdmVf cmVxdWVzdCgpLCBiZWZvcmUgd2UgcmV0dXJuCmNvbnRyb2wgdG8gdGhlIGNsaWVudCB0byB3YWl0 LiBUbyBtYWtlIHN1cmUgd2UndmUgdGFrZW4gYSBsb29rIGF0IHRoZQplbnRpcmUgcXVldWUsIHJl Z2lzdGVyX3NvY2tldCgpIG5vdyB0cmFja3MgdGhlIG51bWJlciBvZiBvdXRzdGFuZGluZwpyZWdp c3RyYXRpb25zLgoKU3VnZ2VzdGVkLWJ5OiBUaG9tYXMgTXVucm8gPHRob21hcy5tdW5yb0BnbWFp bC5jb20+Ci0tLQogc3JjL2ludGVyZmFjZXMvbGlicHEtb2F1dGgvb2F1dGgtY3VybC5jIHwgMjE4 ICsrKysrKysrKysrKysrKysrKy0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDE2NiBpbnNlcnRpb25z KCspLCA1MiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvaW50ZXJmYWNlcy9saWJwcS1v YXV0aC9vYXV0aC1jdXJsLmMgYi9zcmMvaW50ZXJmYWNlcy9saWJwcS1vYXV0aC9vYXV0aC1jdXJs LmMKaW5kZXggZGJhOWE2ODRmYTguLjg0MzAzNTZjZmI1IDEwMDY0NAotLS0gYS9zcmMvaW50ZXJm YWNlcy9saWJwcS1vYXV0aC9vYXV0aC1jdXJsLmMKKysrIGIvc3JjL2ludGVyZmFjZXMvbGlicHEt b2F1dGgvb2F1dGgtY3VybC5jCkBAIC0yNzgsNiArMjc4LDEwIEBAIHN0cnVjdCBhc3luY19jdHgK IAlib29sCQl1c2VyX3Byb21wdGVkOwkvKiBoYXZlIHdlIGFscmVhZHkgc2VudCB0aGUgYXV0aHog cHJvbXB0PyAqLwogCWJvb2wJCXVzZWRfYmFzaWNfYXV0aDsJLyogZGlkIHdlIHNlbmQgYSBjbGll bnQgc2VjcmV0PyAqLwogCWJvb2wJCWRlYnVnZ2luZzsJCS8qIGNhbiB3ZSBnaXZlIHVuc2FmZSBk ZXZlbG9wZXIgYXNzaXN0YW5jZT8gKi8KKworI2lmIGRlZmluZWQoSEFWRV9TWVNfRVZFTlRfSCkK KwlpbnQJCQluZXZlbnRzOwkJLyogaG93IG1hbnkgZXZlbnRzIGFyZSB3ZSB3YWl0aW5nIG9uPyAq LworI2VuZGlmCiB9OwogCiAvKgpAQCAtMTI5MSw0MSArMTI5NSw5NSBAQCByZWdpc3Rlcl9zb2Nr ZXQoQ1VSTCAqY3VybCwgY3VybF9zb2NrZXRfdCBzb2NrZXQsIGludCB3aGF0LCB2b2lkICpjdHgs CiAKIAlyZXR1cm4gMDsKICNlbGlmIGRlZmluZWQoSEFWRV9TWVNfRVZFTlRfSCkKLQlzdHJ1Y3Qg a2V2ZW50IGV2WzJdID0gezB9OworCXN0cnVjdCBrZXZlbnQgZXZbMl07CiAJc3RydWN0IGtldmVu dCBldl9vdXRbMl07CiAJc3RydWN0IHRpbWVzcGVjIHRpbWVvdXQgPSB7MH07Ci0JaW50CQkJbmV2 ID0gMDsKKwlpbnQJCQluZXY7CiAJaW50CQkJcmVzOwogCisJLyoKKwkgKiBGaXJzdCwgYW55IGV4 aXN0aW5nIHJlZ2lzdHJhdGlvbnMgZm9yIHRoaXMgc29ja2V0IG5lZWQgdG8gYmUgcmVtb3ZlZCwK KwkgKiBib3RoIHRvIHRyYWNrIHRoZSBvdXRzdGFuZGluZyBudW1iZXIgb2YgZXZlbnRzLCBhbmQg dG8gZW5zdXJlIHRoYXQKKwkgKiB3ZSdyZSBub3Qgd29rZW4gdXAgZm9yIHRoaW5ncyB0aGF0IEN1 cmwgbm8gbG9uZ2VyIGNhcmVzIGFib3V0LgorCSAqCisJICogRU5PRU5UIGlzIG9rYXksIGJ1dCB3 ZSBoYXZlIHRvIHRyYWNrIGhvdyBtYW55IHdlIGdldCwgc28gdXNlCisJICogRVZfUkVDRUlQVC4K KwkgKi8KKwluZXYgPSAwOworCUVWX1NFVCgmZXZbbmV2XSwgc29ja2V0LCBFVkZJTFRfUkVBRCwg RVZfREVMRVRFIHwgRVZfUkVDRUlQVCwgMCwgMCwgMCk7CisJbmV2Kys7CisJRVZfU0VUKCZldltu ZXZdLCBzb2NrZXQsIEVWRklMVF9XUklURSwgRVZfREVMRVRFIHwgRVZfUkVDRUlQVCwgMCwgMCwg MCk7CisJbmV2Kys7CisKKwlBc3NlcnQobmV2IDw9IGxlbmd0aG9mKGV2KSk7CisJQXNzZXJ0KG5l diA8PSBsZW5ndGhvZihldl9vdXQpKTsKKworCXJlcyA9IGtldmVudChhY3R4LT5tdXgsIGV2LCBu ZXYsIGV2X291dCwgbmV2LCAmdGltZW91dCk7CisJaWYgKHJlcyA8IDApCisJeworCQlhY3R4X2Vy cm9yKGFjdHgsICJjb3VsZCBub3QgZGVsZXRlIGZyb20ga3F1ZXVlOiAlbSIpOworCQlyZXR1cm4g LTE7CisJfQorCisJLyoKKwkgKiBXZSBjYW4ndCB1c2UgdGhlIHNpbXBsZSBlcnJubyB2ZXJzaW9u IG9mIGtldmVudCwgYmVjYXVzZSB3ZSBuZWVkIHRvCisJICogc2tpcCBvdmVyIEVOT0VOVCB3aGls ZSBzdGlsbCBhbGxvd2luZyBhIHNlY29uZCBjaGFuZ2UgdG8gYmUgcHJvY2Vzc2VkLgorCSAqIFNv IHdlIG5lZWQgYSBsb25nZXItZm9ybSBlcnJvciBjaGVja2luZyBsb29wLgorCSAqLworCWZvciAo aW50IGkgPSAwOyBpIDwgcmVzOyArK2kpCisJeworCQkvKgorCQkgKiBFVl9SRUNFSVBUIHNob3Vs ZCBndWFyYW50ZWUgb25lIEVWX0VSUk9SIHJlc3VsdCBmb3IgZXZlcnkgY2hhbmdlLAorCQkgKiB3 aGV0aGVyIHN1Y2Nlc3NmdWwgb3Igbm90LiBGYWlsZWQgZW50cmllcyBjb250YWluIGEgbm9uLXpl cm8gZXJybm8KKwkJICogaW4gdGhlIGRhdGEgZmllbGQuCisJCSAqLworCQlBc3NlcnQoZXZfb3V0 W2ldLmZsYWdzICYgRVZfRVJST1IpOworCisJCWVycm5vID0gZXZfb3V0W2ldLmRhdGE7CisJCWlm ICghZXJybm8pCisJCXsKKwkJCS8qIFN1Y2Nlc3NmdWxseSByZW1vdmVkOyB1cGRhdGUgdGhlIGV2 ZW50IGNvdW50LiAqLworCQkJQXNzZXJ0KGFjdHgtPm5ldmVudHMgPiAwKTsKKwkJCWFjdHgtPm5l dmVudHMtLTsKKwkJfQorCQllbHNlIGlmIChlcnJubyAhPSBFTk9FTlQpCisJCXsKKwkJCWFjdHhf ZXJyb3IoYWN0eCwgImNvdWxkIG5vdCBkZWxldGUgZnJvbSBrcXVldWU6ICVtIik7CisJCQlyZXR1 cm4gLTE7CisJCX0KKwl9CisKKwkvKiBJZiB3ZSdyZSBvbmx5IHJlbW92aW5nIHJlZ2lzdHJhdGlv bnMsIHdlJ3JlIGRvbmUuICovCisJaWYgKHdoYXQgPT0gQ1VSTF9QT0xMX1JFTU9WRSkKKwkJcmV0 dXJuIDA7CisKKwkvKgorCSAqIE5vdyBhZGQgdGhlIG5ldyBmaWx0ZXJzLiBUaGlzIGlzIG1vcmUg c3RyYWlnaHRmb3dhcmQgdGhhbiBkZWxldGlvbi4KKwkgKgorCSAqIENvbWJpbmluZyB0aGlzIGtl dmVudCgpIGNhbGwgd2l0aCB0aGUgb25lIGFib3ZlIHNlZW1zIGxpa2UgaXQgc2hvdWxkIGJlCisJ ICogdGhlb3JldGljYWxseSBwb3NzaWJsZSwgYnV0IGJld2FyZSB0aGF0IG5vdCBhbGwgQlNEcyBr ZWVwIHRoZSBvcmlnaW5hbAorCSAqIGV2ZW50IGZsYWdzIHdoZW4gdXNpbmcgRVZfUkVDRUlQVCwg c28gaXQncyB0cmlja3kgdG8gZmlndXJlIG91dCB3aGljaAorCSAqIG9wZXJhdGlvbnMgc3VjY2Vl ZGVkLiBGb3Igbm93IHdlIGtlZXAgdGhlIGRlbGV0aW9ucyBhbmQgdGhlIGFkZGl0aW9ucworCSAq IHNlcGFyYXRlLgorCSAqLworCW5ldiA9IDA7CisKIAlzd2l0Y2ggKHdoYXQpCiAJewogCQljYXNl IENVUkxfUE9MTF9JTjoKLQkJCUVWX1NFVCgmZXZbbmV2XSwgc29ja2V0LCBFVkZJTFRfUkVBRCwg RVZfQUREIHwgRVZfUkVDRUlQVCwgMCwgMCwgMCk7CisJCQlFVl9TRVQoJmV2W25ldl0sIHNvY2tl dCwgRVZGSUxUX1JFQUQsIEVWX0FERCwgMCwgMCwgMCk7CiAJCQluZXYrKzsKIAkJCWJyZWFrOwog CiAJCWNhc2UgQ1VSTF9QT0xMX09VVDoKLQkJCUVWX1NFVCgmZXZbbmV2XSwgc29ja2V0LCBFVkZJ TFRfV1JJVEUsIEVWX0FERCB8IEVWX1JFQ0VJUFQsIDAsIDAsIDApOworCQkJRVZfU0VUKCZldltu ZXZdLCBzb2NrZXQsIEVWRklMVF9XUklURSwgRVZfQURELCAwLCAwLCAwKTsKIAkJCW5ldisrOwog CQkJYnJlYWs7CiAKIAkJY2FzZSBDVVJMX1BPTExfSU5PVVQ6Ci0JCQlFVl9TRVQoJmV2W25ldl0s IHNvY2tldCwgRVZGSUxUX1JFQUQsIEVWX0FERCB8IEVWX1JFQ0VJUFQsIDAsIDAsIDApOwotCQkJ bmV2Kys7Ci0JCQlFVl9TRVQoJmV2W25ldl0sIHNvY2tldCwgRVZGSUxUX1dSSVRFLCBFVl9BREQg fCBFVl9SRUNFSVBULCAwLCAwLCAwKTsKLQkJCW5ldisrOwotCQkJYnJlYWs7Ci0KLQkJY2FzZSBD VVJMX1BPTExfUkVNT1ZFOgotCi0JCQkvKgotCQkJICogV2UgZG9uJ3Qga25vdyB3aGljaCBvZiB0 aGVzZSBpcyBjdXJyZW50bHkgcmVnaXN0ZXJlZCwgcGVyaGFwcwotCQkJICogYm90aCwgc28gd2Ug dHJ5IHRvIHJlbW92ZSBib3RoLiAgVGhpcyBtZWFucyB3ZSBuZWVkIHRvIHRvbGVyYXRlCi0JCQkg KiBFTk9FTlQgYmVsb3cuCi0JCQkgKi8KLQkJCUVWX1NFVCgmZXZbbmV2XSwgc29ja2V0LCBFVkZJ TFRfUkVBRCwgRVZfREVMRVRFIHwgRVZfUkVDRUlQVCwgMCwgMCwgMCk7CisJCQlFVl9TRVQoJmV2 W25ldl0sIHNvY2tldCwgRVZGSUxUX1JFQUQsIEVWX0FERCwgMCwgMCwgMCk7CiAJCQluZXYrKzsK LQkJCUVWX1NFVCgmZXZbbmV2XSwgc29ja2V0LCBFVkZJTFRfV1JJVEUsIEVWX0RFTEVURSB8IEVW X1JFQ0VJUFQsIDAsIDAsIDApOworCQkJRVZfU0VUKCZldltuZXZdLCBzb2NrZXQsIEVWRklMVF9X UklURSwgRVZfQURELCAwLCAwLCAwKTsKIAkJCW5ldisrOwogCQkJYnJlYWs7CiAKQEAgLTEzMzQs NDUgKzEzOTIsOTEgQEAgcmVnaXN0ZXJfc29ja2V0KENVUkwgKmN1cmwsIGN1cmxfc29ja2V0X3Qg c29ja2V0LCBpbnQgd2hhdCwgdm9pZCAqY3R4LAogCQkJcmV0dXJuIC0xOwogCX0KIAotCXJlcyA9 IGtldmVudChhY3R4LT5tdXgsIGV2LCBuZXYsIGV2X291dCwgbGVuZ3Rob2YoZXZfb3V0KSwgJnRp bWVvdXQpOworCUFzc2VydChuZXYgPD0gbGVuZ3Rob2YoZXYpKTsKKworCXJlcyA9IGtldmVudChh Y3R4LT5tdXgsIGV2LCBuZXYsIE5VTEwsIDAsIE5VTEwpOwogCWlmIChyZXMgPCAwKQogCXsKIAkJ YWN0eF9lcnJvcihhY3R4LCAiY291bGQgbm90IG1vZGlmeSBrcXVldWU6ICVtIik7CiAJCXJldHVy biAtMTsKIAl9CiAKKwkvKiBVcGRhdGUgdGhlIGV2ZW50IGNvdW50LCBhbmQgd2UncmUgZG9uZS4g Ki8KKwlhY3R4LT5uZXZlbnRzICs9IG5ldjsKKworCXJldHVybiAwOworI2Vsc2UKKyNlcnJvciBy ZWdpc3Rlcl9zb2NrZXQgaXMgbm90IGltcGxlbWVudGVkIG9uIHRoaXMgcGxhdGZvcm0KKyNlbmRp ZgorfQorCisvKi0tLS0tLS0KKyAqIERyYWlucyBhbnkgc3RhbGUgbGV2ZWwtdHJpZ2dlcmVkIGV2 ZW50cyBvdXQgb2YgdGhlIG11bHRpcGxleGVyLiBUaGlzIGlzCisgKiBuZWNlc3Nhcnkgb25seSBp ZiB0aGUgbXV4IGltcGxlbWVudGF0aW9uIHJlcXVpcmVzIGl0LgorICoKKyAqIEFzIGFuIGV4YW1w bGUsIGNvbnNpZGVyIHRoZSBmb2xsb3dpbmcgc2VxdWVuY2Ugb2YgZXZlbnRzOgorICogMS4gbGli Y3VybCB0cmllcyB0byB3cml0ZSBkYXRhIHRvIHRoZSBzZW5kIGJ1ZmZlciwgYnV0IGl0IGZpbGxz IHVwLgorICogMi4gbGliY3VybCByZWdpc3RlcnMgQ1VSTF9QT0xMX09VVCBvbiB0aGUgc29ja2V0 IGFuZCByZXR1cm5zIGNvbnRyb2wgdG8gdGhlCisgKiAgICBjbGllbnQgdG8gd2FpdC4KKyAqIDMu IFRoZSBrZXJuZWwgcGFydGlhbGx5IGRyYWlucyB0aGUgc2VuZCBidWZmZXIuIFRoZSBzb2NrZXQg YmVjb21lcyB3cml0YWJsZSwKKyAqICAgIGFuZCB0aGUgY2xpZW50IHdha2VzIHVwIGFuZCBjYWxs cyBiYWNrIGludG8gdGhlIGZsb3cuCisgKiA0LiBsaWJjdXJsIGNvbnRpbnVlcyB3cml0aW5nIGRh dGEgdG8gdGhlIHNlbmQgYnVmZmVyLCBidXQgaXQgZmlsbHMgdXAgYWdhaW4uCisgKiAgICBUaGUg c29ja2V0IGlzIG5vIGxvbmdlciB3cml0YWJsZS4KKyAqCisgKiBBdCB0aGlzIHBvaW50LCBhbiBl cG9sbC1iYXNlZCBtdXggbm8gbG9uZ2VyIHNpZ25hbHMgcmVhZGluZXNzLCBzbyBub3RoaW5nCisg KiBmdXJ0aGVyIG5lZWRzIHRvIGJlIGRvbmUuIEJ1dCBhIGtxdWV1ZS1iYXNlZCBtdXggd2lsbCBj b250aW51ZSB0byBzaWduYWwKKyAqICJyZWFkeSIgdW50aWwgZWl0aGVyIHRoZSBFVkZJTFRfV1JJ VEUgcmVnaXN0cmF0aW9uIGlzIGRyb3BwZWQgZm9yIHRoZSBzb2NrZXQsCisgKiBvciB0aGUgb2xk IHNvY2tldC13cml0YWJsZSBldmVudCBpcyByZWFkIGZyb20gdGhlIHF1ZXVlLiBTaW5jZSBDdXJs IGlzbid0CisgKiBndWFyYW50ZWVkIHRvIGRvIHRoZSBmb3JtZXIsIHdlIG11c3QgZG8gdGhlIGxh dHRlciBoZXJlLgorICovCitzdGF0aWMgYm9vbAorZHJhaW5fc29ja2V0X2V2ZW50cyhzdHJ1Y3Qg YXN5bmNfY3R4ICphY3R4KQoreworI2lmIGRlZmluZWQoSEFWRV9TWVNfRVBPTExfSCkKKwkvKiBU aGUgZXBvbGwgaW1wbGVtZW50YXRpb24gZG9lc24ndCBuZWVkIHRvIGRyYWluIHBlbmRpbmcgZXZl bnRzLiAqLworCXJldHVybiB0cnVlOworI2VsaWYgZGVmaW5lZChIQVZFX1NZU19FVkVOVF9IKQor CXN0cnVjdCB0aW1lc3BlYyB0aW1lb3V0ID0gezB9OworCXN0cnVjdCBrZXZlbnQgKmRyYWluOwor CWludAkJCWRyYWluX2xlbjsKKwogCS8qCi0JICogV2UgY2FuJ3QgdXNlIHRoZSBzaW1wbGUgZXJy bm8gdmVyc2lvbiBvZiBrZXZlbnQsIGJlY2F1c2Ugd2UgbmVlZCB0bwotCSAqIHNraXAgb3ZlciBF Tk9FTlQgd2hpbGUgc3RpbGwgYWxsb3dpbmcgYSBzZWNvbmQgY2hhbmdlIHRvIGJlIHByb2Nlc3Nl ZC4KLQkgKiBTbyB3ZSBuZWVkIGEgbG9uZ2VyLWZvcm0gZXJyb3IgY2hlY2tpbmcgbG9vcC4KKwkg KiBEcmFpbiB0aGUgZXZlbnRzIGluIG9uZSBjYWxsLCByYXRoZXIgdGhhbiBsb29waW5nLiAoV2Ug Y291bGQgbWF5YmUgY2FsbAorCSAqIGtldmVudCgpIGRyYWluX2xlbiB0aW1lcywgaW5zdGVhZCBv ZiBhbGxvY2F0aW5nIHNwYWNlIGZvciB0aGUgbWF4aW11bQorCSAqIG51bWJlciBvZiBldmVudHMs IGJ1dCB0aGF0IHJlbGllcyBvbiB0aGUgZXZlbnRzIGJlaW5nIGluIEZJRk8gb3JkZXIgdG8KKwkg KiBhdm9pZCBzdGFydmF0aW9uLiBUaGUga3F1ZXVlIG1hbiBwYWdlcyBkb24ndCBzZWVtIHRvIG1h a2UgYW55CisJICogZ3VhcmFudGVlcyBhYm91dCB0aGF0LikKKwkgKgorCSAqIHJlZ2lzdGVyX3Nv Y2tldCgpIGtlZXBzIGFjdHgtPm5ldmVudHMgdXBkYXRlZCB3aXRoIHRoZSBudW1iZXIgb2YKKwkg KiBvdXRzdGFuZGluZyBldmVudCBmaWx0ZXJzLiBXZSBkb24ndCB0cmFjayB0aGUgcmVnaXN0cmF0 aW9uIG9mIHRoZQorCSAqIHRpbWVyOyB3ZSBqdXN0IGFzc3VtZSBvbmUgY291bGQgYmUgcmVnaXN0 ZXJlZCBoZXJlLgogCSAqLwotCWZvciAoaW50IGkgPSAwOyBpIDwgcmVzOyArK2kpCisJZHJhaW5f bGVuID0gYWN0eC0+bmV2ZW50cyArIDE7CisKKwlkcmFpbiA9IG1hbGxvYyhzaXplb2YoKmRyYWlu KSAqIGRyYWluX2xlbik7CisJaWYgKCFkcmFpbikKIAl7Ci0JCS8qCi0JCSAqIEVWX1JFQ0VJUFQg c2hvdWxkIGd1YXJhbnRlZSBvbmUgRVZfRVJST1IgcmVzdWx0IGZvciBldmVyeSBjaGFuZ2UsCi0J CSAqIHdoZXRoZXIgc3VjY2Vzc2Z1bCBvciBub3QuIEZhaWxlZCBlbnRyaWVzIGNvbnRhaW4gYSBu b24temVybyBlcnJubwotCQkgKiBpbiB0aGUgZGF0YSBmaWVsZC4KLQkJICovCi0JCUFzc2VydChl dl9vdXRbaV0uZmxhZ3MgJiBFVl9FUlJPUik7CisJCWFjdHhfZXJyb3IoYWN0eCwgIm91dCBvZiBt ZW1vcnkiKTsKKwkJcmV0dXJuIGZhbHNlOworCX0KIAotCQllcnJubyA9IGV2X291dFtpXS5kYXRh OwotCQlpZiAoZXJybm8gJiYgZXJybm8gIT0gRU5PRU5UKQotCQl7Ci0JCQlzd2l0Y2ggKHdoYXQp Ci0JCQl7Ci0JCQkJY2FzZSBDVVJMX1BPTExfUkVNT1ZFOgotCQkJCQlhY3R4X2Vycm9yKGFjdHgs ICJjb3VsZCBub3QgZGVsZXRlIGZyb20ga3F1ZXVlOiAlbSIpOwotCQkJCQlicmVhazsKLQkJCQlk ZWZhdWx0OgotCQkJCQlhY3R4X2Vycm9yKGFjdHgsICJjb3VsZCBub3QgYWRkIHRvIGtxdWV1ZTog JW0iKTsKLQkJCX0KLQkJCXJldHVybiAtMTsKLQkJfQorCS8qCisJICogRGlzY2FyZCBhbGwgcGVu ZGluZyBldmVudHMuIFNpbmNlIG91ciByZWdpc3RyYXRpb25zIGFyZSBsZXZlbC10cmlnZ2VyZWQK KwkgKiAoZXZlbiB0aGUgdGltZXIsIHNpbmNlIHdlIHVzZSBhIGNoYWluZWQga3F1ZXVlIGZvciB0 aGF0IGluc3RlYWQgb2YgYW4KKwkgKiBFVkZJTFRfVElNRVIgb24gdGhlIHRvcC1sZXZlbCBtdXgh KSwgYW55IGV2ZW50cyB0aGF0IHdlIHN0aWxsIG5lZWQgd2lsbAorCSAqIHJlbWFpbiBzaWduYWxs ZWQsIGFuZCB0aGUgc3RhbGUgb25lcyB3aWxsIGJlIHN3ZXB0IGF3YXkuCisJICovCisJaWYgKGtl dmVudChhY3R4LT5tdXgsIE5VTEwsIDAsIGRyYWluLCBkcmFpbl9sZW4sICZ0aW1lb3V0KSA8IDAp CisJeworCQlhY3R4X2Vycm9yKGFjdHgsICJjb3VsZCBub3QgZHJhaW4ga3F1ZXVlOiAlbSIpOwor CQlmcmVlKGRyYWluKTsKKwkJcmV0dXJuIGZhbHNlOwogCX0KIAotCXJldHVybiAwOworCWZyZWUo ZHJhaW4pOworCXJldHVybiB0cnVlOwogI2Vsc2UKLSNlcnJvciByZWdpc3Rlcl9zb2NrZXQgaXMg bm90IGltcGxlbWVudGVkIG9uIHRoaXMgcGxhdGZvcm0KKyNlcnJvciBkcmFpbl9zb2NrZXRfZXZl bnRzIGlzIG5vdCBpbXBsZW1lbnRlZCBvbiB0aGlzIHBsYXRmb3JtCiAjZW5kaWYKIH0KIApAQCAt MTQ0MSw3ICsxNTQ1LDggQEAgc2V0X3RpbWVyKHN0cnVjdCBhc3luY19jdHggKmFjdHgsIGxvbmcg dGltZW91dCkKIAkgKiBtYWNPUy4pCiAJICoKIAkgKiBJZiB0aGVyZSB3YXMgbm8gcHJldmlvdXMg dGltZXIgc2V0LCB0aGUga2V2ZW50IGNhbGxzIHdpbGwgcmVzdWx0IGluCi0JICogRU5PRU5ULCB3 aGljaCBpcyBmaW5lLgorCSAqIEVOT0VOVCwgd2hpY2ggaXMgZmluZS4gKFdlIGRvbid0IHRyYWNr IGFjdHgtPm5ldmVudHMgZm9yIHRoaXMgY2FzZTsKKwkgKiBpbnN0ZWFkLCBkcmFpbl9zb2NrZXRf ZXZlbnRzKCkganVzdCBhc3N1bWVzIGEgdGltZXIgY291bGQgYmUgc2V0LikKIAkgKi8KIAlFVl9T RVQoJmV2LCAxLCBFVkZJTFRfVElNRVIsIEVWX0RFTEVURSwgMCwgMCwgMCk7CiAJaWYgKGtldmVu dChhY3R4LT50aW1lcmZkLCAmZXYsIDEsIE5VTEwsIDAsIE5VTEwpIDwgMCAmJiBlcnJubyAhPSBF Tk9FTlQpCkBAIC0yNzU1LDEzICsyODYwLDIyIEBAIHBnX2ZlX3J1bl9vYXV0aF9mbG93X2ltcGwo UEdjb25uICpjb25uKQogCiAJCQkJCWlmIChzdGF0dXMgPT0gUEdSRVNfUE9MTElOR19GQUlMRUQp CiAJCQkJCQlnb3RvIGVycm9yX3JldHVybjsKLQkJCQkJZWxzZSBpZiAoc3RhdHVzICE9IFBHUkVT X1BPTExJTkdfT0spCi0JCQkJCXsKLQkJCQkJCS8qIG5vdCBkb25lIHlldCAqLwotCQkJCQkJcmV0 dXJuIHN0YXR1czsKLQkJCQkJfQorCQkJCQllbHNlIGlmIChzdGF0dXMgPT0gUEdSRVNfUE9MTElO R19PSykKKwkJCQkJCWJyZWFrOwkvKiBkb25lISAqLworCisJCQkJCS8qCisJCQkJCSAqIFRoaXMg cmVxdWVzdCBpcyBzdGlsbCBydW5uaW5nLgorCQkJCQkgKgorCQkJCQkgKiBEcmFpbiBhbnkgc3Rh bGUgc29ja2V0IGV2ZW50cyBmcm9tIHRoZSBtdXggYmVmb3JlIHdlCisJCQkJCSAqIGFzayB0aGUg Y2xpZW50IHRvIHBvbGwuIChDdXJyZW50bHksIHRoaXMgY2FuIG9jY3VyIG9ubHkKKwkJCQkJICog d2l0aCBrcXVldWUuKSBJZiB0aGlzIGlzIGZvcmdvdHRlbiwgdGhlIG11bHRpcGxleGVyIGNhbgor CQkJCQkgKiBnZXQgc3R1Y2sgaW4gYSBzaWduYWxsZWQgc3RhdGUgYW5kIHdlJ2xsIGJ1cm4gQ1BV CisJCQkJCSAqIGN5Y2xlcyBwb2ludGxlc3NseS4KKwkJCQkJICovCisJCQkJCWlmICghZHJhaW5f c29ja2V0X2V2ZW50cyhhY3R4KSkKKwkJCQkJCWdvdG8gZXJyb3JfcmV0dXJuOwogCi0JCQkJCWJy ZWFrOworCQkJCQlyZXR1cm4gc3RhdHVzOwogCQkJCX0KIAogCQkJY2FzZSBPQVVUSF9TVEVQX1dB SVRfSU5URVJWQUw6Ci0tIAoyLjM0LjEKCg== --0000000000004886fa063881fe30 Content-Type: application/octet-stream; name="0002-oauth-Remove-expired-timers-from-the-multiplexer.patch" Content-Disposition: attachment; filename="0002-oauth-Remove-expired-timers-from-the-multiplexer.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mce0npci1 RnJvbSBkM2NmNjlmMzQ2MmUwNmEwNGI4NWVkZGY2M2QwNDhjZmMwNWM2YjQ0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWNvYiBDaGFtcGlvbiA8amFjb2IuY2hhbXBpb25AZW50ZXJw cmlzZWRiLmNvbT4KRGF0ZTogV2VkLCA1IE1hciAyMDI1IDEzOjE2OjQ4IC0wODAwClN1YmplY3Q6 IFtQQVRDSCAyLzRdIG9hdXRoOiBSZW1vdmUgZXhwaXJlZCB0aW1lcnMgZnJvbSB0aGUgbXVsdGlw bGV4ZXIKCkluIGEgY2FzZSBzaW1pbGFyIHRvIHRoZSBwcmV2aW91cyBjb21taXQsIGFuIGV4cGly ZWQgdGltZXIgY2FuIHJlbWFpbgpwZXJtYW5lbnRseSByZWFkYWJsZSBpZiBDdXJsIGRvZXMgbm90 IHJlbW92ZSB0aGUgdGltZW91dCBpdHNlbGYuIFNpbmNlCnRoYXQgcmVtb3ZhbCBpc24ndCBndWFy YW50ZWVkIHRvIGhhcHBlbiBpbiByZWFsLXdvcmxkIHNpdHVhdGlvbnMsCmltcGxlbWVudCBkcmFp bl90aW1lcl9ldmVudHMoKSB0byByZXNldCB0aGUgdGltZXIgYmVmb3JlIGNhbGxpbmcgaW50bwpk cml2ZV9yZXF1ZXN0KCkuCgpNb3ZpbmcgdG8gZHJhaW5fdGltZXJfZXZlbnRzKCkgaGFwcGVucyB0 byBmaXggYSBsb2dpYyBidWcgaW4gdGhlCnByZXZpb3VzIGNhbGxlciBvZiB0aW1lcl9leHBpcmVk KCksIHdoaWNoIHRyZWF0ZWQgYW4gZXJyb3IgY29uZGl0aW9uIGFzCmlmIHRoZSB0aW1lciB3ZXJl IGV4cGlyZWQgaW5zdGVhZCBvZiBiYWlsaW5nIG91dC4KClRoZSBwcmV2aW91cyBpbXBsZW1lbnRh dGlvbiBvZiB0aW1lcl9leHBpcmVkKCkgZ2F2ZSBkaWZmZXJpbmcgcmVzdWx0cwpmb3IgZXBvbGwg YW5kIGtxdWV1ZSBpZiB0aGUgdGltZXIgd2FzIHJlc2V0LiAoRm9yIGVwb2xsLCBhIHJlc2V0IHRp bWVyCndhcyBjb25zaWRlcmVkIHRvIGJlIGV4cGlyZWQsIGFuZCBmb3Iga3F1ZXVlIGl0IHdhcyBu b3QuKSBUaGlzIGRpZG4ndApwcmV2aW91c2x5IGNhdXNlIHByb2JsZW1zLCBzaW5jZSB0aW1lcl9l eHBpcmVkKCkgd2FzIG9ubHkgY2FsbGVkIHdoaWxlCnRoZSB0aW1lciB3YXMga25vd24gdG8gYmUg c2V0LCBidXQgYm90aCBpbXBsZW1lbnRhdGlvbnMgbm93IHVzZSB0aGUKa3F1ZXVlIGxvZ2ljLgot LS0KIHNyYy9pbnRlcmZhY2VzL2xpYnBxLW9hdXRoL29hdXRoLWN1cmwuYyB8IDEwOCArKysrKysr KysrKysrKystLS0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCA2OCBpbnNlcnRpb25zKCspLCA0MCBk ZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvaW50ZXJmYWNlcy9saWJwcS1vYXV0aC9vYXV0 aC1jdXJsLmMgYi9zcmMvaW50ZXJmYWNlcy9saWJwcS1vYXV0aC9vYXV0aC1jdXJsLmMKaW5kZXgg ODQzMDM1NmNmYjUuLjc4YmEzMzk5NDk1IDEwMDY0NAotLS0gYS9zcmMvaW50ZXJmYWNlcy9saWJw cS1vYXV0aC9vYXV0aC1jdXJsLmMKKysrIGIvc3JjL2ludGVyZmFjZXMvbGlicHEtb2F1dGgvb2F1 dGgtY3VybC5jCkBAIC0xNTg4LDQwICsxNTg4LDIwIEBAIHNldF90aW1lcihzdHJ1Y3QgYXN5bmNf Y3R4ICphY3R4LCBsb25nIHRpbWVvdXQpCiAKIC8qCiAgKiBSZXR1cm5zIDEgaWYgdGhlIHRpbWVv dXQgaW4gdGhlIG11bHRpcGxleGVyIHNldCBoYXMgZXhwaXJlZCBzaW5jZSB0aGUgbGFzdAotICog Y2FsbCB0byBzZXRfdGltZXIoKSwgMCBpZiB0aGUgdGltZXIgaXMgc3RpbGwgcnVubmluZywgb3Ig LTEgKHdpdGggYW4KLSAqIGFjdHhfZXJyb3IoKSByZXBvcnQpIGlmIHRoZSB0aW1lciBjYW5ub3Qg YmUgcXVlcmllZC4KKyAqIGNhbGwgdG8gc2V0X3RpbWVyKCksIDAgaWYgdGhlIHRpbWVyIGlzIGVp dGhlciBzdGlsbCBydW5uaW5nIG9yIGRpc2FybWVkLCBvcgorICogLTEgKHdpdGggYW4gYWN0eF9l cnJvcigpIHJlcG9ydCkgaWYgdGhlIHRpbWVyIGNhbm5vdCBiZSBxdWVyaWVkLgogICovCiBzdGF0 aWMgaW50CiB0aW1lcl9leHBpcmVkKHN0cnVjdCBhc3luY19jdHggKmFjdHgpCiB7Ci0jaWYgZGVm aW5lZChIQVZFX1NZU19FUE9MTF9IKQotCXN0cnVjdCBpdGltZXJzcGVjIHNwZWMgPSB7MH07Ci0K LQlpZiAodGltZXJmZF9nZXR0aW1lKGFjdHgtPnRpbWVyZmQsICZzcGVjKSA8IDApCi0JewotCQlh Y3R4X2Vycm9yKGFjdHgsICJnZXR0aW5nIHRpbWVyZmQgdmFsdWU6ICVtIik7Ci0JCXJldHVybiAt MTsKLQl9Ci0KLQkvKgotCSAqIFRoaXMgaW1wbGVtZW50YXRpb24gYXNzdW1lcyB3ZSdyZSB1c2lu ZyBzaW5nbGUtc2hvdCB0aW1lcnMuIElmIHlvdQotCSAqIGNoYW5nZSB0byB1c2luZyBpbnRlcnZh bHMsIHlvdSdsbCBuZWVkIHRvIHJlaW1wbGVtZW50IHRoaXMgZnVuY3Rpb24KLQkgKiB0b28sIHBv c3NpYmx5IHdpdGggdGhlIHJlYWQoKSBvciBzZWxlY3QoKSBpbnRlcmZhY2VzIGZvciB0aW1lcmZk LgotCSAqLwotCUFzc2VydChzcGVjLml0X2ludGVydmFsLnR2X3NlYyA9PSAwCi0JCSAgICYmIHNw ZWMuaXRfaW50ZXJ2YWwudHZfbnNlYyA9PSAwKTsKLQotCS8qIElmIHRoZSByZW1haW5pbmcgdGlt ZSB0byBleHBpcmF0aW9uIGlzIHplcm8sIHdlJ3JlIGRvbmUuICovCi0JcmV0dXJuIChzcGVjLml0 X3ZhbHVlLnR2X3NlYyA9PSAwCi0JCQkmJiBzcGVjLml0X3ZhbHVlLnR2X25zZWMgPT0gMCk7Ci0j ZWxpZiBkZWZpbmVkKEhBVkVfU1lTX0VWRU5UX0gpCisjaWYgZGVmaW5lZChIQVZFX1NZU19FUE9M TF9IKSB8fCBkZWZpbmVkKEhBVkVfU1lTX0VWRU5UX0gpCiAJaW50CQkJcmVzOwogCi0JLyogSXMg dGhlIHRpbWVyIHF1ZXVlIHJlYWR5PyAqLworCS8qIElzIHRoZSB0aW1lciByZWFkeT8gKi8KIAly ZXMgPSBQUXNvY2tldFBvbGwoYWN0eC0+dGltZXJmZCwgMSAvKiBmb3JSZWFkICovICwgMCwgMCk7 CiAJaWYgKHJlcyA8IDApCiAJewotCQlhY3R4X2Vycm9yKGFjdHgsICJjaGVja2luZyBrcXVldWUg Zm9yIHRpbWVvdXQ6ICVtIik7CisJCWFjdHhfZXJyb3IoYWN0eCwgImNoZWNraW5nIHRpbWVyIGV4 cGlyYXRpb246ICVtIik7CiAJCXJldHVybiAtMTsKIAl9CiAKQEAgLTE2NTMsNiArMTYzMywzNiBA QCByZWdpc3Rlcl90aW1lcihDVVJMTSAqY3VybG0sIGxvbmcgdGltZW91dCwgdm9pZCAqY3R4KQog CXJldHVybiAwOwogfQogCisvKgorICogUmVtb3ZlcyBhbnkgZXhwaXJlZC10aW1lciBldmVudCBm cm9tIHRoZSBtdWx0aXBsZXhlci4gSWYgd2FzX2V4cGlyZWQgaXMgbm90CisgKiBOVUxMLCBpdCB3 aWxsIGNvbnRhaW4gd2hldGhlciBvciBub3QgdGhlIHRpbWVyIHdhcyBleHBpcmVkIGF0IHRpbWUg b2YgY2FsbC4KKyAqLworc3RhdGljIGJvb2wKK2RyYWluX3RpbWVyX2V2ZW50cyhzdHJ1Y3QgYXN5 bmNfY3R4ICphY3R4LCBib29sICp3YXNfZXhwaXJlZCkKK3sKKwlpbnQJCQlyZXM7CisKKwlyZXMg PSB0aW1lcl9leHBpcmVkKGFjdHgpOworCWlmIChyZXMgPCAwKQorCQlyZXR1cm4gZmFsc2U7CisK KwlpZiAocmVzID4gMCkKKwl7CisJCS8qCisJCSAqIFRpbWVyIGlzIGV4cGlyZWQuIFdlIGNvdWxk IGRyYWluIHRoZSBldmVudCBtYW51YWxseSBmcm9tIHRoZQorCQkgKiB0aW1lcmZkLCBidXQgaXQn cyBlYXNpZXIgdG8gc2ltcGx5IGRpc2FibGUgaXQ7IHRoYXQga2VlcHMgdGhlCisJCSAqIHBsYXRm b3JtLXNwZWNpZmljIGNvZGUgaW4gc2V0X3RpbWVyKCkuCisJCSAqLworCQlpZiAoIXNldF90aW1l cihhY3R4LCAtMSkpCisJCQlyZXR1cm4gZmFsc2U7CisJfQorCisJaWYgKHdhc19leHBpcmVkKQor CQkqd2FzX2V4cGlyZWQgPSAocmVzID4gMCk7CisKKwlyZXR1cm4gdHJ1ZTsKK30KKwogLyoKICAq IFByaW50cyBDdXJsIHJlcXVlc3QgZGVidWdnaW5nIGluZm9ybWF0aW9uIHRvIHN0ZGVyci4KICAq CkBAIC0yODU2LDYgKzI4NjYsMjIgQEAgcGdfZmVfcnVuX29hdXRoX2Zsb3dfaW1wbChQR2Nvbm4g KmNvbm4pCiAJCQkJewogCQkJCQlQb3N0Z3Jlc1BvbGxpbmdTdGF0dXNUeXBlIHN0YXR1czsKIAor CQkJCQkvKgorCQkJCQkgKiBDbGVhciBhbnkgZXhwaXJlZCB0aW1lb3V0IGJlZm9yZSBjYWxsaW5n IGJhY2sgaW50bworCQkJCQkgKiBDdXJsLiBDdXJsIGlzIG5vdCBndWFyYW50ZWVkIHRvIGRvIHRo aXMgZm9yIHVzLCBiZWNhdXNlCisJCQkJCSAqIGl0cyBBUEkgZXhwZWN0cyB1cyB0byB1c2Ugc2lu Z2xlLXNob3QgKGkuZS4KKwkJCQkJICogZWRnZS10cmlnZ2VyZWQpIHRpbWVvdXRzLCBhbmQgb3Vy cyBhcmUgbGV2ZWwtdHJpZ2dlcmVkCisJCQkJCSAqIHZpYSB0aGUgbXV4LgorCQkJCQkgKgorCQkJ CQkgKiBUaGlzIGNhbid0IGJlIGNvbWJpbmVkIHdpdGggdGhlIGRyYWluX3NvY2tldF9ldmVudHMo KQorCQkJCQkgKiBjYWxsIGJlbG93OiB3ZSBtaWdodCBhY2NpZGVudGFsbHkgY2xlYXIgYSBzaG9y dCB0aW1lb3V0CisJCQkJCSAqIHRoYXQgd2FzIGJvdGggc2V0IGFuZCBleHBpcmVkIGR1cmluZyB0 aGUgY2FsbCB0bworCQkJCQkgKiBkcml2ZV9yZXF1ZXN0KCkuCisJCQkJCSAqLworCQkJCQlpZiAo IWRyYWluX3RpbWVyX2V2ZW50cyhhY3R4LCBOVUxMKSkKKwkJCQkJCWdvdG8gZXJyb3JfcmV0dXJu OworCisJCQkJCS8qIE1vdmUgdGhlIHJlcXVlc3QgZm9yd2FyZC4gKi8KIAkJCQkJc3RhdHVzID0g ZHJpdmVfcmVxdWVzdChhY3R4KTsKIAogCQkJCQlpZiAoc3RhdHVzID09IFBHUkVTX1BPTExJTkdf RkFJTEVEKQpAQCAtMjg3OSwyNCArMjkwNSwyNiBAQCBwZ19mZV9ydW5fb2F1dGhfZmxvd19pbXBs KFBHY29ubiAqY29ubikKIAkJCQl9CiAKIAkJCWNhc2UgT0FVVEhfU1RFUF9XQUlUX0lOVEVSVkFM OgotCi0JCQkJLyoKLQkJCQkgKiBUaGUgY2xpZW50IGFwcGxpY2F0aW9uIGlzIHN1cHBvc2VkIHRv IHdhaXQgdW50aWwgb3VyIHRpbWVyCi0JCQkJICogZXhwaXJlcyBiZWZvcmUgY2FsbGluZyBQUWNv bm5lY3RQb2xsKCkgYWdhaW4sIGJ1dCB0aGF0Ci0JCQkJICogbWlnaHQgbm90IGhhcHBlbi4gVG8g YXZvaWQgc2VuZGluZyBhIHRva2VuIHJlcXVlc3QgZWFybHksCi0JCQkJICogY2hlY2sgdGhlIHRp bWVyIGJlZm9yZSBjb250aW51aW5nLgotCQkJCSAqLwotCQkJCWlmICghdGltZXJfZXhwaXJlZChh Y3R4KSkKIAkJCQl7Ci0JCQkJCXNldF9jb25uX2FsdHNvY2soY29ubiwgYWN0eC0+dGltZXJmZCk7 Ci0JCQkJCXJldHVybiBQR1JFU19QT0xMSU5HX1JFQURJTkc7Ci0JCQkJfQorCQkJCQlib29sCQll eHBpcmVkOwogCi0JCQkJLyogRGlzYWJsZSB0aGUgZXhwaXJlZCB0aW1lci4gKi8KLQkJCQlpZiAo IXNldF90aW1lcihhY3R4LCAtMSkpCi0JCQkJCWdvdG8gZXJyb3JfcmV0dXJuOworCQkJCQkvKgor CQkJCQkgKiBUaGUgY2xpZW50IGFwcGxpY2F0aW9uIGlzIHN1cHBvc2VkIHRvIHdhaXQgdW50aWwg b3VyCisJCQkJCSAqIHRpbWVyIGV4cGlyZXMgYmVmb3JlIGNhbGxpbmcgUFFjb25uZWN0UG9sbCgp IGFnYWluLCBidXQKKwkJCQkJICogdGhhdCBtaWdodCBub3QgaGFwcGVuLiBUbyBhdm9pZCBzZW5k aW5nIGEgdG9rZW4gcmVxdWVzdAorCQkJCQkgKiBlYXJseSwgY2hlY2sgdGhlIHRpbWVyIGJlZm9y ZSBjb250aW51aW5nLgorCQkJCQkgKi8KKwkJCQkJaWYgKCFkcmFpbl90aW1lcl9ldmVudHMoYWN0 eCwgJmV4cGlyZWQpKQorCQkJCQkJZ290byBlcnJvcl9yZXR1cm47CiAKLQkJCQlicmVhazsKKwkJ CQkJaWYgKCFleHBpcmVkKQorCQkJCQl7CisJCQkJCQlzZXRfY29ubl9hbHRzb2NrKGNvbm4sIGFj dHgtPnRpbWVyZmQpOworCQkJCQkJcmV0dXJuIFBHUkVTX1BPTExJTkdfUkVBRElORzsKKwkJCQkJ fQorCisJCQkJCWJyZWFrOworCQkJCX0KIAkJfQogCiAJCS8qCi0tIAoyLjM0LjEKCg== --0000000000004886fa063881fe30 Content-Type: application/octet-stream; name="0003-oauth-Track-total-call-count-during-a-client-flow.patch" Content-Disposition: attachment; filename="0003-oauth-Track-total-call-count-during-a-client-flow.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mce0ns132 RnJvbSBlOTZhYWI2NjVjMzNiMmE4ZjE5OGZlODAyZGFlN2FiNDEwYTAxNDcxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWNvYiBDaGFtcGlvbiA8amFjb2IuY2hhbXBpb25AZW50ZXJw cmlzZWRiLmNvbT4KRGF0ZTogRnJpLCA2IEp1biAyMDI1IDE1OjIyOjQxIC0wNzAwClN1YmplY3Q6 IFtQQVRDSCAzLzRdIG9hdXRoOiBUcmFjayB0b3RhbCBjYWxsIGNvdW50IGR1cmluZyBhIGNsaWVu dCBmbG93CgpUcmFja2luZyBkb3duIHRoZSBidWdzIHRoYXQgbGVkIHRvIHRoZSBhZGRpdGlvbiBv ZiBkcmFpbl9zb2NrZXRfZXZlbnRzKCkKYW5kIGRyYWluX3RpbWVyX2V2ZW50cygpIHdhcyBkaWZm aWN1bHQsIGJlY2F1c2UgYW4gaW5lZmZpY2llbnQgZmxvdyBpcwpub3QgdmlzaWJseSBkaWZmZXJl bnQgZnJvbSBvbmUgdGhhdCBpcyB3b3JraW5nIHByb3Blcmx5LiBUbyBoZWxwCm1haW50YWluZXJz IG5vdGljZSB3aGVuIHNvbWV0aGluZyBoYXMgZ29uZSB3cm9uZywgdHJhY2sgdGhlIG51bWJlciBv ZgpjYWxscyBpbnRvIHRoZSBmbG93IGFzIHBhcnQgb2YgZGVidWcgbW9kZSwgYW5kIHByaW50IHRo ZSB0b3RhbCB3aGVuIHRoZQpmbG93IGZpbmlzaGVzLgoKQSBuZXcgdGVzdCBtYWtlcyBzdXJlIHRo ZSB0b3RhbCBjb3VudCBpcyBsZXNzIHRoYW4gMTAwLiAoV2UgZXhwZWN0CnNvbWV0aGluZyBvbiB0 aGUgb3JkZXIgb2YgMTAuKSBUaGlzIGlzbid0IGZvb2xwcm9vZiwgYnV0IGl0IGlzIGFibGUgdG8K Y2F0Y2ggc2V2ZXJhbCByZWdyZXNzaW9ucyBpbiB0aGUgbG9naWMgb2YgdGhlIHByaW9yIHR3byBj b21taXRzLCBhbmQKZnV0dXJlIHdvcmsgdG8gYWRkIFRMUyBzdXBwb3J0IHRvIHRoZSBvYXV0aF92 YWxpZGF0b3IgdGVzdCBzZXJ2ZXIgc2hvdWxkCnN0cmVuZ3RoZW4gaXQgYXMgd2VsbC4KLS0tCiBz cmMvaW50ZXJmYWNlcy9saWJwcS1vYXV0aC9vYXV0aC1jdXJsLmMgICAgICAgfCAyMiArKysrKysr KysrKysrCiAuLi4vbW9kdWxlcy9vYXV0aF92YWxpZGF0b3IvdC8wMDFfc2VydmVyLnBsICAgfCAz MSArKysrKysrKysrKysrKysrKystCiAyIGZpbGVzIGNoYW5nZWQsIDUyIGluc2VydGlvbnMoKyks IDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9zcmMvaW50ZXJmYWNlcy9saWJwcS1vYXV0aC9v YXV0aC1jdXJsLmMgYi9zcmMvaW50ZXJmYWNlcy9saWJwcS1vYXV0aC9vYXV0aC1jdXJsLmMKaW5k ZXggNzhiYTMzOTk0OTUuLjY4MzAzMTA2YTVkIDEwMDY0NAotLS0gYS9zcmMvaW50ZXJmYWNlcy9s aWJwcS1vYXV0aC9vYXV0aC1jdXJsLmMKKysrIGIvc3JjL2ludGVyZmFjZXMvbGlicHEtb2F1dGgv b2F1dGgtY3VybC5jCkBAIC0yNzgsNiArMjc4LDcgQEAgc3RydWN0IGFzeW5jX2N0eAogCWJvb2wJ CXVzZXJfcHJvbXB0ZWQ7CS8qIGhhdmUgd2UgYWxyZWFkeSBzZW50IHRoZSBhdXRoeiBwcm9tcHQ/ ICovCiAJYm9vbAkJdXNlZF9iYXNpY19hdXRoOwkvKiBkaWQgd2Ugc2VuZCBhIGNsaWVudCBzZWNy ZXQ/ICovCiAJYm9vbAkJZGVidWdnaW5nOwkJLyogY2FuIHdlIGdpdmUgdW5zYWZlIGRldmVsb3Bl ciBhc3Npc3RhbmNlPyAqLworCWludAkJCWRiZ19udW1fY2FsbHM7CS8qIChkZWJ1ZyBtb2RlKSBo b3cgbWFueSB0aW1lcyB3ZXJlIHdlIGNhbGxlZD8gKi8KIAogI2lmIGRlZmluZWQoSEFWRV9TWVNf RVZFTlRfSCkKIAlpbnQJCQluZXZlbnRzOwkJLyogaG93IG1hbnkgZXZlbnRzIGFyZSB3ZSB3YWl0 aW5nIG9uPyAqLwpAQCAtMzA3NCw2ICszMDc1LDggQEAgUG9zdGdyZXNQb2xsaW5nU3RhdHVzVHlw ZQogcGdfZmVfcnVuX29hdXRoX2Zsb3coUEdjb25uICpjb25uKQogewogCVBvc3RncmVzUG9sbGlu Z1N0YXR1c1R5cGUgcmVzdWx0OworCWZlX29hdXRoX3N0YXRlICpzdGF0ZSA9IGNvbm5fc2FzbF9z dGF0ZShjb25uKTsKKwlzdHJ1Y3QgYXN5bmNfY3R4ICphY3R4OwogI2lmbmRlZiBXSU4zMgogCXNp Z3NldF90CW9zaWdzZXQ7CiAJYm9vbAkJc2lncGlwZV9wZW5kaW5nOwpAQCAtMzEwMiw2ICszMTA1 LDI1IEBAIHBnX2ZlX3J1bl9vYXV0aF9mbG93KFBHY29ubiAqY29ubikKIAogCXJlc3VsdCA9IHBn X2ZlX3J1bl9vYXV0aF9mbG93X2ltcGwoY29ubik7CiAKKwkvKgorCSAqIFRvIGFzc2lzdCB3aXRo IGZpbmRpbmcgYnVncyBpbiBkcmFpbl9zb2NrZXRfZXZlbnRzKCkgYW5kCisJICogZHJhaW5fdGlt ZXJfZXZlbnRzKCksIHdoZW4gd2UncmUgaW4gZGVidWcgbW9kZSwgdHJhY2sgdGhlIHRvdGFsIG51 bWJlcgorCSAqIG9mIGNhbGxzIHRvIHRoaXMgZnVuY3Rpb24gYW5kIHByaW50IHRoYXQgYXQgdGhl IGVuZCBvZiB0aGUgZmxvdy4KKwkgKgorCSAqIEJlIGNhcmVmdWwgdGhhdCBzdGF0ZS0+YXN5bmNf Y3R4IGNvdWxkIGJlIE5VTEwgaWYgZWFybHkgaW5pdGlhbGl6YXRpb24KKwkgKiBmYWlscyBkdXJp bmcgdGhlIGZpcnN0IGNhbGwuCisJICovCisJYWN0eCA9IHN0YXRlLT5hc3luY19jdHg7CisJQXNz ZXJ0KGFjdHggfHwgcmVzdWx0ID09IFBHUkVTX1BPTExJTkdfRkFJTEVEKTsKKworCWlmIChhY3R4 ICYmIGFjdHgtPmRlYnVnZ2luZykKKwl7CisJCWFjdHgtPmRiZ19udW1fY2FsbHMrKzsKKwkJaWYg KHJlc3VsdCA9PSBQR1JFU19QT0xMSU5HX09LIHx8IHJlc3VsdCA9PSBQR1JFU19QT0xMSU5HX0ZB SUxFRCkKKwkJCWZwcmludGYoc3RkZXJyLCAiW2xpYnBxXSB0b3RhbCBudW1iZXIgb2YgcG9sbHM6 ICVkXG4iLAorCQkJCQlhY3R4LT5kYmdfbnVtX2NhbGxzKTsKKwl9CisKICNpZm5kZWYgV0lOMzIK IAlpZiAobWFza2VkKQogCXsKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvb2F1dGhfdmFs aWRhdG9yL3QvMDAxX3NlcnZlci5wbCBiL3NyYy90ZXN0L21vZHVsZXMvb2F1dGhfdmFsaWRhdG9y L3QvMDAxX3NlcnZlci5wbAppbmRleCA0MTY3MmViZDVjNi4uYzBkYWZiOGJlNzYgMTAwNjQ0Ci0t LSBhL3NyYy90ZXN0L21vZHVsZXMvb2F1dGhfdmFsaWRhdG9yL3QvMDAxX3NlcnZlci5wbAorKysg Yi9zcmMvdGVzdC9tb2R1bGVzL29hdXRoX3ZhbGlkYXRvci90LzAwMV9zZXJ2ZXIucGwKQEAgLTQx OCw2ICs0MTgsMzUgQEAgJG5vZGUtPmNvbm5lY3RfZmFpbHMoCiAJICBxci9mYWlsZWQgdG8gb2J0 YWluIGFjY2VzcyB0b2tlbjogbXV0dWFsIFRMUyByZXF1aXJlZCBmb3IgY2xpZW50IFwoaW52YWxp ZF9jbGllbnRcKS8KICk7CiAKKyMgQ291bnQgdGhlIG51bWJlciBvZiBjYWxscyB0byB0aGUgaW50 ZXJuYWwgZmxvdyB3aGVuIG11bHRpcGxlIHJldHJpZXMgYXJlCisjIHRyaWdnZXJlZC4gVGhlIGV4 YWN0IG51bWJlciBkZXBlbmRzIG9uIG1hbnkgdGhpbmdzIC0tIHRoZSBUQ1Agc3RhY2ssIHRoZQor IyB2ZXJzaW9uIG9mIEN1cmwgaW4gdXNlLCByYW5kb20gY2hhbmNlIC0tIGJ1dCBhIHJpZGljdWxv dXNseSBoaWdoIG51bWJlcgorIyBzdWdnZXN0cyBzb21ldGhpbmcgaXMgd3Jvbmcgd2l0aCBvdXIg YWJpbGl0eSB0byBjbGVhciBtdWx0aXBsZXhlciBldmVudHMgYWZ0ZXIKKyMgdGhleSdyZSBubyBs b25nZXIgYXBwbGljYWJsZS4KK215ICgkcmV0LCAkc3Rkb3V0LCAkc3RkZXJyKSA9ICRub2RlLT5w c3FsKAorCSdwb3N0Z3JlcycsCisJIlNFTEVDVCAnY29ubmVjdGVkIGZvciBjYWxsIGNvdW50JyIs CisJZXh0cmFfcGFyYW1zID0+IFsnLXcnXSwKKwljb25uc3RyID0+IGNvbm5zdHIoc3RhZ2UgPT4g J3Rva2VuJywgcmV0cmllcyA9PiAyKSwKKwlvbl9lcnJvcl9zdG9wID0+IDApOworCitpcygkcmV0 LCAwLCAiY2FsbCBjb3VudCBjb25uZWN0aW9uIHN1Y2NlZWRzIik7CitsaWtlKAorCSRzdGRlcnIs CisJcXJAVmlzaXQgaHR0cHM6Ly9leGFtcGxlXC5jb20vIGFuZCBlbnRlciB0aGUgY29kZTogcG9z dGdyZXN1c2VyQCwKKwkiY2FsbCBjb3VudDogc3RkZXJyIG1hdGNoZXMiKTsKKworbXkgJGNvdW50 X3BhdHRlcm4gPSBxci9cW2xpYnBxXF0gdG90YWwgbnVtYmVyIG9mIHBvbGxzOiAoXGQrKS87Citp ZiAobGlrZSgkc3RkZXJyLCAkY291bnRfcGF0dGVybiwgImNhbGwgY291bnQ6IGNvdW50IGlzIHBy aW50ZWQiKSkKK3sKKwkjIEZvciByZWZlcmVuY2UsIGEgdHlwaWNhbCBmbG93IHdpdGggdHdvIHJl dHJpZXMgbWlnaHQgdGFrZSBiZXR3ZWVuIDUtMTUKKwkjIGNhbGxzIHRvIHRoZSBjbGllbnQgaW1w bGVtZW50YXRpb24uIEFuZCB3aGlsZSB0aGlzIHdpbGwgcHJvYmFibHkgY29udGludWUKKwkjIHRv IGNoYW5nZSBhY3Jvc3MgT1NlcyBhbmQgQ3VybCB1cGRhdGVzLCB3ZSdyZSBsaWtlbHkgaW4gdHJv dWJsZSBpZiB3ZSBzZWUKKwkjIGh1bmRyZWRzIG9yIHRob3VzYW5kcyBvZiBjYWxscy4KKwkkc3Rk ZXJyID1+ICRjb3VudF9wYXR0ZXJuOworCWNtcF9vaygkMSwgJzwnLCAxMDAsICJjYWxsIGNvdW50 IGlzIHJlYXNvbmFibHkgc21hbGwiKTsKK30KKwogIyBTdHJlc3MgdGVzdDogbWFrZSBzdXJlIG91 ciBidWlsdGluIGZsb3cgb3BlcmF0ZXMgY29ycmVjdGx5IGV2ZW4gaWYgdGhlIGNsaWVudAogIyBh cHBsaWNhdGlvbiBpc24ndCByZXNwZWN0aW5nIFBHUkVTX1BPTExJTkdfUkVBRElORy9XUklUSU5H IHNpZ25hbHMgcmV0dXJuZWQKICMgZnJvbSBQUWNvbm5lY3RQb2xsKCkuCkBAIC00MjgsNyArNDU3 LDcgQEAgbXkgQGNtZCA9ICgKIAljb25uc3RyKHN0YWdlID0+ICdhbGwnLCByZXRyaWVzID0+IDEs IGludGVydmFsID0+IDEpKTsKIAogbm90ZSAicnVubmluZyAnIiAuIGpvaW4oIicgJyIsIEBjbWQp IC4gIiciOwotbXkgKCRzdGRvdXQsICRzdGRlcnIpID0gcnVuX2NvbW1hbmQoXEBjbWQpOworKCRz dGRvdXQsICRzdGRlcnIpID0gcnVuX2NvbW1hbmQoXEBjbWQpOwogCiBsaWtlKCRzdGRvdXQsIHFy L2Nvbm5lY3Rpb24gc3VjY2VlZGVkLywgInN0cmVzcy1hc3luYzogc3Rkb3V0IG1hdGNoZXMiKTsK IHVubGlrZSgKLS0gCjIuMzQuMQoK --0000000000004886fa063881fe30 Content-Type: application/octet-stream; name="0004-oauth-Add-unit-tests-for-multiplexer-handling.patch" Content-Disposition: attachment; filename="0004-oauth-Add-unit-tests-for-multiplexer-handling.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mce0nu4j3 RnJvbSAzNmRjNzEwYjg0Yjg2OTMxOTYzYTNmYjU4NmQ3Mjc5ZDQ1NDhiYzM2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWNvYiBDaGFtcGlvbiA8amFjb2IuY2hhbXBpb25AZW50ZXJw cmlzZWRiLmNvbT4KRGF0ZTogV2VkLCA1IE1hciAyMDI1IDE1OjA0OjM0IC0wODAwClN1YmplY3Q6 IFtQQVRDSCA0LzRdIG9hdXRoOiBBZGQgdW5pdCB0ZXN0cyBmb3IgbXVsdGlwbGV4ZXIgaGFuZGxp bmcKClRvIGJldHRlciByZWNvcmQgdGhlIGludGVybmFsIGJlaGF2aW9ycyBvZiBvYXV0aC1jdXJs LmMsIGFkZCBhIHVuaXQgdGVzdApzdWl0ZSBmb3IgdGhlIHNvY2tldCBhbmQgdGltZXIgaGFuZGxp bmcgY29kZS4gVGhpcyBpcyBhbGwgYmFzZWQgb24gVEFQCmFuZCBkcml2ZW4gYnkgb3VyIGV4aXN0 aW5nIFRlc3Q6Ok1vcmUgaW5mcmFzdHJ1Y3R1cmUuCi0tLQogc3JjL2ludGVyZmFjZXMvbGlicHEt b2F1dGgvTWFrZWZpbGUgICAgICAgICAgfCAgMTQgKwogc3JjL2ludGVyZmFjZXMvbGlicHEtb2F1 dGgvbWVzb24uYnVpbGQgICAgICAgfCAgMzUgKysKIHNyYy9pbnRlcmZhY2VzL2xpYnBxLW9hdXRo L3QvMDAxX29hdXRoLnBsICAgIHwgIDI0ICsKIHNyYy9pbnRlcmZhY2VzL2xpYnBxLW9hdXRoL3Rl c3Qtb2F1dGgtY3VybC5jIHwgNDc0ICsrKysrKysrKysrKysrKysrKysKIDQgZmlsZXMgY2hhbmdl ZCwgNTQ3IGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzcmMvaW50ZXJmYWNlcy9s aWJwcS1vYXV0aC90LzAwMV9vYXV0aC5wbAogY3JlYXRlIG1vZGUgMTAwNjQ0IHNyYy9pbnRlcmZh Y2VzL2xpYnBxLW9hdXRoL3Rlc3Qtb2F1dGgtY3VybC5jCgpkaWZmIC0tZ2l0IGEvc3JjL2ludGVy ZmFjZXMvbGlicHEtb2F1dGgvTWFrZWZpbGUgYi9zcmMvaW50ZXJmYWNlcy9saWJwcS1vYXV0aC9N YWtlZmlsZQppbmRleCAyNzBmYzBjZjJkOS4uOWRhOGU0YjcxNDMgMTAwNjQ0Ci0tLSBhL3NyYy9p bnRlcmZhY2VzL2xpYnBxLW9hdXRoL01ha2VmaWxlCisrKyBiL3NyYy9pbnRlcmZhY2VzL2xpYnBx LW9hdXRoL01ha2VmaWxlCkBAIC03OSw1ICs3OSwxOSBAQCB1bmluc3RhbGw6CiAJcm0gLWYgJyQo REVTVERJUikkKGxpYmRpcikvJChzdGxpYiknCiAJcm0gLWYgJyQoREVTVERJUikkKGxpYmRpcikv JChzaGxpYiknCiAKKy5QSE9OWTogYWxsLXRlc3RzCithbGwtdGVzdHM6IG9hdXRoX3Rlc3RzJChY KQorCitvYXV0aF90ZXN0cyQoWCk6IHRlc3Qtb2F1dGgtY3VybC5vIG9hdXRoLXV0aWxzLm8gJChX SU4zMlJFUykgfCBzdWJtYWtlLWxpYnBncG9ydCBzdWJtYWtlLWxpYnBxCisJJChDQykgJChDRkxB R1MpICReICQoTERGTEFHUykgJChMREZMQUdTX0VYKSAkKFNITElCX0xJTkspIC1vICRACisKK2No ZWNrOiBhbGwtdGVzdHMKKwkkKHByb3ZlX2NoZWNrKQorCitpbnN0YWxsY2hlY2s6IGFsbC10ZXN0 cworCSQocHJvdmVfaW5zdGFsbGNoZWNrKQorCiBjbGVhbiBkaXN0Y2xlYW46IGNsZWFuLWxpYgog CXJtIC1mICQoT0JKUykgJChPQkpTX1NUQVRJQykgJChPQkpTX1NITElCKQorCXJtIC1mIHRlc3Qt b2F1dGgtY3VybC5vIG9hdXRoX3Rlc3RzJChYKQorCXJtIC1yZiB0bXBfY2hlY2sKZGlmZiAtLWdp dCBhL3NyYy9pbnRlcmZhY2VzL2xpYnBxLW9hdXRoL21lc29uLmJ1aWxkIGIvc3JjL2ludGVyZmFj ZXMvbGlicHEtb2F1dGgvbWVzb24uYnVpbGQKaW5kZXggZGYwNjRjNTlhNDAuLjUwNWUxNjcxYjg2 IDEwMDY0NAotLS0gYS9zcmMvaW50ZXJmYWNlcy9saWJwcS1vYXV0aC9tZXNvbi5idWlsZAorKysg Yi9zcmMvaW50ZXJmYWNlcy9saWJwcS1vYXV0aC9tZXNvbi5idWlsZApAQCAtNDcsMyArNDcsMzgg QEAgbGlicHFfb2F1dGhfc28gPSBzaGFyZWRfbW9kdWxlKGxpYnBxX29hdXRoX25hbWUsCiAgIGxp bmtfYXJnczogZXhwb3J0X2ZtdC5mb3JtYXQoZXhwb3J0X2ZpbGUuZnVsbF9wYXRoKCkpLAogICBr d2FyZ3M6IGRlZmF1bHRfbGliX2FyZ3MsCiApCisKK2xpYnBxX29hdXRoX3Rlc3RfZGVwcyA9IFtd CisKK29hdXRoX3Rlc3Rfc291cmNlcyA9IGZpbGVzKCd0ZXN0LW9hdXRoLWN1cmwuYycpICsgbGli cHFfb2F1dGhfc29fc291cmNlcworCitpZiBob3N0X3N5c3RlbSA9PSAnd2luZG93cycKKyAgb2F1 dGhfdGVzdF9zb3VyY2VzICs9IHJjX2Jpbl9nZW4ucHJvY2Vzcyh3aW4zMnZlcl9yYywgZXh0cmFf YXJnczogWworICAgICctLU5BTUUnLCAnb2F1dGhfdGVzdHMnLAorICAgICctLUZJTEVERVNDJywg J09BdXRoIHVuaXQgdGVzdCBwcm9ncmFtJyxdKQorZW5kaWYKKworbGlicHFfb2F1dGhfdGVzdF9k ZXBzICs9IGV4ZWN1dGFibGUoJ29hdXRoX3Rlc3RzJywKKyAgb2F1dGhfdGVzdF9zb3VyY2VzLAor ICBkZXBlbmRlbmNpZXM6IFtmcm9udGVuZF9zaGxpYl9jb2RlLCBsaWJwcSwgbGlicHFfb2F1dGhf ZGVwc10sCisgIGt3YXJnczogZGVmYXVsdF9iaW5fYXJncyArIHsKKyAgICAnY19hcmdzJzogZGVm YXVsdF9iaW5fYXJncy5nZXQoJ2NfYXJncycsIFtdKSArIGxpYnBxX29hdXRoX3NvX2NfYXJncywK KyAgICAnY19wY2gnOiBwY2hfcG9zdGdyZXNfZmVfaCwKKyAgICAnaW5jbHVkZV9kaXJlY3Rvcmll cyc6IFtsaWJwcV9pbmMsIHBvc3RncmVzX2luY10sCisgICAgJ2luc3RhbGwnOiBmYWxzZSwKKyAg fQorKQorCit0ZXN0cHJlcF90YXJnZXRzICs9IGxpYnBxX29hdXRoX3Rlc3RfZGVwcworCit0ZXN0 cyArPSB7CisgICduYW1lJzogJ2xpYnBxLW9hdXRoJywKKyAgJ3NkJzogbWVzb24uY3VycmVudF9z b3VyY2VfZGlyKCksCisgICdiZCc6IG1lc29uLmN1cnJlbnRfYnVpbGRfZGlyKCksCisgICd0YXAn OiB7CisgICAgJ3Rlc3RzJzogWworICAgICAgJ3QvMDAxX29hdXRoLnBsJywKKyAgICBdLAorICAg ICdkZXBzJzogbGlicHFfb2F1dGhfdGVzdF9kZXBzLAorICB9LAorfQpkaWZmIC0tZ2l0IGEvc3Jj L2ludGVyZmFjZXMvbGlicHEtb2F1dGgvdC8wMDFfb2F1dGgucGwgYi9zcmMvaW50ZXJmYWNlcy9s aWJwcS1vYXV0aC90LzAwMV9vYXV0aC5wbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMC4uZTc2OTg1NmMyYzkKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvaW50ZXJmYWNlcy9s aWJwcS1vYXV0aC90LzAwMV9vYXV0aC5wbApAQCAtMCwwICsxLDI0IEBACisjIENvcHlyaWdodCAo YykgMjAyNSwgUG9zdGdyZVNRTCBHbG9iYWwgRGV2ZWxvcG1lbnQgR3JvdXAKK3VzZSBzdHJpY3Q7 Cit1c2Ugd2FybmluZ3MgRkFUQUwgPT4gJ2FsbCc7CisKK3VzZSBQb3N0Z3JlU1FMOjpUZXN0OjpV dGlsczsKK3VzZSBUZXN0OjpNb3JlOworCisjIERlZmVyIGVudGlyZWx5IHRvIHRoZSBvYXV0aF90 ZXN0cyBleGVjdXRhYmxlLiBzdGRvdXQvZXJyIGlzIHJvdXRlZCB0aHJvdWdoCisjIFRlc3Q6Ok1v cmUgc28gdGhhdCBvdXIgbG9nZ2luZyBpbmZyYXN0cnVjdHVyZSBjYW4gaGFuZGxlIGl0IGNvcnJl Y3RseS4gVXNpbmcKKyMgSVBDOjpSdW46Om5ld19jaHVua2VyIHNlZW1zIHRvIGhlbHAgaW50ZXJs ZWF2ZSB0aGUgdHdvIHN0cmVhbXMgYSBsaXR0bGUgYmV0dGVyCisjIHRoYW4gd2l0aG91dC4KKyMK KyMgVE9ETzogcHJvdmUgY2FuIGFsc28gZGVhbCB3aXRoIG5hdGl2ZSBleGVjdXRhYmxlcyBpdHNl bGYsIHdoaWNoIHdlIGNvdWxkCisjIHByb2JhYmx5IG1ha2UgdXNlIG9mIHZpYSBQUk9WRV9URVNU UyBvbiB0aGUgTWFrZWZpbGUgc2lkZS4gQnV0IHRoZSBNZXNvbiBzZXR1cAorIyBjYWxscyBQZXJs IGRpcmVjdGx5LCB3aGljaCB3b3VsZCByZXF1aXJlIG1vcmUgY29kZSB0byB3b3JrIGFyb3VuZC4u LiBhbmQKKyMgdGhlcmUncyBzdGlsbCB0aGUgbWF0dGVyIG9mIGxvZ2dpbmcuCitteSAkYnVpbGRl ciA9IFRlc3Q6Ok1vcmUtPmJ1aWxkZXI7CitteSAkb3V0ID0gJGJ1aWxkZXItPm91dHB1dDsKK215 ICRlcnIgPSAkYnVpbGRlci0+ZmFpbHVyZV9vdXRwdXQ7CisKK0lQQzo6UnVuOjpydW4gWydvYXV0 aF90ZXN0cyddLAorICAnPicsIElQQzo6UnVuOjpuZXdfY2h1bmtlciwgc3ViIHsgcHJpbnQgeyRv dXR9ICRfWzBdIH0sCisgICcyPicsIElQQzo6UnVuOjpuZXdfY2h1bmtlciwgc3ViIHsgcHJpbnQg eyRlcnJ9ICRfWzBdIH0KKyAgb3IgZGllICJvYXV0aF90ZXN0cyByZXR1cm5lZCAkPyI7CmRpZmYg LS1naXQgYS9zcmMvaW50ZXJmYWNlcy9saWJwcS1vYXV0aC90ZXN0LW9hdXRoLWN1cmwuYyBiL3Ny Yy9pbnRlcmZhY2VzL2xpYnBxLW9hdXRoL3Rlc3Qtb2F1dGgtY3VybC5jCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi5lNTJkNTk4NjNkZAotLS0gL2Rldi9udWxsCisrKyBi L3NyYy9pbnRlcmZhY2VzL2xpYnBxLW9hdXRoL3Rlc3Qtb2F1dGgtY3VybC5jCkBAIC0wLDAgKzEs NDc0IEBACisvKgorICogdGVzdC1vYXV0aC1jdXJsLmMKKyAqCisgKiBBIHVuaXQgdGVzdCBkcml2 ZXIgZm9yIGxpYnBxLW9hdXRoLiBUaGlzICNpbmNsdWRlcyBvYXV0aC1jdXJsLmMsIHdoaWNoIGxl dHMKKyAqIHRoZSB0ZXN0cyByZWZlcmVuY2Ugc3RhdGljIGZ1bmN0aW9ucyBhbmQgb3RoZXIgaW50 ZXJuYWxzLgorICoKKyAqIFVTRV9BU1NFUlRfQ0hFQ0tJTkcgaXMgcmVxdWlyZWQsIHRvIG1ha2Ug aXQgZWFzeSBmb3IgdGVzdHMgdG8gd3JhcAorICogbXVzdC1zdWNjZWVkIGNvZGUgYXMgcGFydCBv ZiB0ZXN0IHNldHVwLgorICoKKyAqIENvcHlyaWdodCAoYykgMjAyNSwgUG9zdGdyZVNRTCBHbG9i YWwgRGV2ZWxvcG1lbnQgR3JvdXAKKyAqLworCisjaW5jbHVkZSAib2F1dGgtY3VybC5jIgorCisj aW5jbHVkZSA8ZmNudGwuaD4KKworI2lmZGVmIFVTRV9BU1NFUlRfQ0hFQ0tJTkcKKworLyoKKyAq IFRBUCBIZWxwZXJzCisgKi8KKworc3RhdGljIGludAludW1fdGVzdHMgPSAwOworCisvKgorICog UmVwb3J0cyBvay9ub3Qgb2sgdG8gdGhlIFRBUCBzdHJlYW0gb24gc3Rkb3V0LgorICovCisjZGVm aW5lIG9rKE9LLCBURVNUKSBcCisJb2tfaW1wbChPSywgVEVTVCwgI09LLCBfX0ZJTEVfXywgX19M SU5FX18pCisKK3N0YXRpYyBib29sCitva19pbXBsKGJvb2wgb2ssIGNvbnN0IGNoYXIgKnRlc3Qs IGNvbnN0IGNoYXIgKnRlc3RzdHIsIGNvbnN0IGNoYXIgKmZpbGUsIGludCBsaW5lKQoreworCXBy aW50ZigiJXNvayAlZCAtICVzXG4iLCBvayA/ICIiIDogIm5vdCAiLCArK251bV90ZXN0cywgdGVz dCk7CisKKwlpZiAoIW9rKQorCXsKKwkJcHJpbnRmKCIjIGF0ICVzOiVkOlxuIiwgZmlsZSwgbGlu ZSk7CisJCXByaW50ZigiIyAgIGV4cHJlc3Npb24gaXMgZmFsc2U6ICVzXG4iLCB0ZXN0c3RyKTsK Kwl9CisKKwlyZXR1cm4gb2s7Cit9CisKKy8qCisgKiBMaWtlIG9rKHRoaXMgPT0gdGhhdCksIGJ1 dCB3aXRoIG1vcmUgZGlhZ25vc3RpY3Mgb24gZmFpbHVyZS4KKyAqCisgKiBPbmx5IHdvcmtzIG9u IGludHMsIGJ1dCBsdWNraWx5IHRoYXQncyBhbGwgd2UgbmVlZCBoZXJlLiBOb3RlIHRoYXQgdGhl IG11Y2gKKyAqIHNpbXBsZXItbG9va2luZyBtYWNybyBpbXBsZW1lbnRhdGlvbgorICoKKyAqICAg ICBpc19kaWFnKG9rKFRISVMgPT0gVEhBVCwgVEVTVCksIFRISVMsICNUSElTLCBUSEFULCAjVEhB VCkKKyAqCisgKiBzdWZmZXJzIGZyb20gbXVsdGlwbGUgZXZhbHVhdGlvbiBvZiB0aGUgbWFjcm8g YXJndW1lbnRzLi4uCisgKi8KKyNkZWZpbmUgaXMoVEhJUywgVEhBVCwgVEVTVCkgXAorCWRvIHsg XAorCQlpbnQgdGhpc18gPSAoVEhJUyksIFwKKwkJCXRoYXRfID0gKFRIQVQpOyBcCisJCWlzX2Rp YWcoIFwKKwkJCW9rX2ltcGwodGhpc18gPT0gdGhhdF8sIFRFU1QsICNUSElTICIgPT0gIiAjVEhB VCwgX19GSUxFX18sIF9fTElORV9fKSwgXAorCQkJdGhpc18sICNUSElTLCB0aGF0XywgI1RIQVQg XAorCQkpOyBcCisJfSB3aGlsZSAoMCkKKworc3RhdGljIGJvb2wKK2lzX2RpYWcoYm9vbCBvaywg aW50IHRoaXMsIGNvbnN0IGNoYXIgKnRoaXNzdHIsIGludCB0aGF0LCBjb25zdCBjaGFyICp0aGF0 c3RyKQoreworCWlmICghb2spCisJCXByaW50ZigiIyAgICVzID0gJWQ7ICVzID0gJWRcbiIsIHRo aXNzdHIsIHRoaXMsIHRoYXRzdHIsIHRoYXQpOworCisJcmV0dXJuIG9rOworfQorCisvKgorICog VXRpbGl0aWVzCisgKi8KKworLyoKKyAqIENyZWF0ZXMgYSBwYXJ0aWFsbHktaW5pdGlhbGl6ZWQg YXN5bmNfY3R4IGZvciB0aGUgcHVycG9zZXMgb2YgdGVzdGluZy4gRnJlZQorICogd2l0aCBmcmVl X3Rlc3RfYWN0eCgpLgorICovCitzdGF0aWMgc3RydWN0IGFzeW5jX2N0eCAqCitpbml0X3Rlc3Rf YWN0eCh2b2lkKQoreworCXN0cnVjdCBhc3luY19jdHggKmFjdHg7CisKKwlhY3R4ID0gY2FsbG9j KDEsIHNpemVvZigqYWN0eCkpOworCUFzc2VydChhY3R4KTsKKworCWFjdHgtPm11eCA9IFBHSU5W QUxJRF9TT0NLRVQ7CisJYWN0eC0+dGltZXJmZCA9IC0xOworCWFjdHgtPmRlYnVnZ2luZyA9IHRy dWU7CisKKwlpbml0UFFFeHBCdWZmZXIoJmFjdHgtPmVycmJ1Zik7CisKKwlBc3NlcnQoc2V0dXBf bXVsdGlwbGV4ZXIoYWN0eCkpOworCisJcmV0dXJuIGFjdHg7Cit9CisKK3N0YXRpYyB2b2lkCitm cmVlX3Rlc3RfYWN0eChzdHJ1Y3QgYXN5bmNfY3R4ICphY3R4KQoreworCXRlcm1QUUV4cEJ1ZmZl cigmYWN0eC0+ZXJyYnVmKTsKKworCWlmIChhY3R4LT5tdXggIT0gUEdJTlZBTElEX1NPQ0tFVCkK KwkJY2xvc2UoYWN0eC0+bXV4KTsKKwlpZiAoYWN0eC0+dGltZXJmZCA+PSAwKQorCQljbG9zZShh Y3R4LT50aW1lcmZkKTsKKworCWZyZWUoYWN0eCk7Cit9CisKK3N0YXRpYyBjaGFyIGR1bW15X2J1 Zls0ICogMTAyNF07CS8qIGZvciBmaWxsX3BpcGUvZHJhaW5fcGlwZSAqLworCisvKgorICogV3Jp dGVzIHRvIHRoZSB3cml0ZSBzaWRlIG9mIGEgcGlwZSB1bnRpbCBpdCB3b24ndCB0YWtlIGFueSBt b3JlIGRhdGEuIFJldHVybnMKKyAqIHRoZSBhbW91bnQgd3JpdHRlbi4KKyAqLworc3RhdGljIHNz aXplX3QKK2ZpbGxfcGlwZShpbnQgZmQpCit7CisJaW50CQkJbW9kZTsKKwlzc2l6ZV90CQl3cml0 dGVuID0gMDsKKworCS8qIERvbid0IGJsb2NrLiAqLworCUFzc2VydCgobW9kZSA9IGZjbnRsKGZk LCBGX0dFVEZMKSkgIT0gLTEpOworCUFzc2VydChmY250bChmZCwgRl9TRVRGTCwgbW9kZSB8IE9f Tk9OQkxPQ0spID09IDApOworCisJd2hpbGUgKHRydWUpCisJeworCQlzc2l6ZV90CQl3OworCisJ CXcgPSB3cml0ZShmZCwgZHVtbXlfYnVmLCBzaXplb2YoZHVtbXlfYnVmKSk7CisJCWlmICh3IDwg MCkKKwkJeworCQkJaWYgKGVycm5vICE9IEVBR0FJTiAmJiBlcnJubyAhPSBFV09VTERCTE9DSykK KwkJCXsKKwkJCQlwZXJyb3IoIndyaXRlIHRvIHBpcGUiKTsKKwkJCQl3cml0dGVuID0gLTE7CisJ CQl9CisJCQlicmVhazsKKwkJfQorCisJCXdyaXR0ZW4gKz0gdzsKKwl9CisKKwkvKiBSZXNldCB0 aGUgZGVzY3JpcHRvciBmbGFncy4gKi8KKwlBc3NlcnQoZmNudGwoZmQsIEZfU0VURkQsIG1vZGUp ID09IDApOworCisJcmV0dXJuIHdyaXR0ZW47Cit9CisKKy8qCisgKiBEcmFpbnMgdGhlIHJlcXVl c3RlZCBhbW91bnQgb2YgZGF0YSBmcm9tIHRoZSByZWFkIHNpZGUgb2YgYSBwaXBlLgorICovCitz dGF0aWMgYm9vbAorZHJhaW5fcGlwZShpbnQgZmQsIHNzaXplX3QgbikKK3sKKwlBc3NlcnQobiA+ IDApOworCisJd2hpbGUgKG4pCisJeworCQlzaXplX3QJCXRvX3JlYWQgPSAobiA8PSBzaXplb2Yo ZHVtbXlfYnVmKSkgPyBuIDogc2l6ZW9mKGR1bW15X2J1Zik7CisJCXNzaXplX3QJCWRyYWluZWQ7 CisKKwkJZHJhaW5lZCA9IHJlYWQoZmQsIGR1bW15X2J1ZiwgdG9fcmVhZCk7CisJCWlmIChkcmFp bmVkIDwgMCkKKwkJeworCQkJcGVycm9yKCJyZWFkIGZyb20gcGlwZSIpOworCQkJcmV0dXJuIGZh bHNlOworCQl9CisKKwkJbiAtPSBkcmFpbmVkOworCX0KKworCXJldHVybiB0cnVlOworfQorCisv KgorICogVGVzdHMgd2hldGhlciB0aGUgbXVsdGlwbGV4ZXIgaXMgbWFya2VkIHJlYWR5IGJ5IHRo ZSBkZWFkbGluZS4gVGhpcyBpcyBhCisgKiBtYWNybyBzbyB0aGF0IGZpbGUvbGluZSBpbmZvcm1h dGlvbiBtYWtlcyBzZW5zZSBkdXJpbmcgZmFpbHVyZXMuCisgKgorICogTkI6IG91ciBjdXJyZW50 IG11bHRpcGxleGVyIGltcGxlbWVudGF0aW9ucyAoZXBvbGwva3F1ZXVlKSBhcmUgKnJlYWRhYmxl KgorICogd2hlbiB0aGUgdW5kZXJseWluZyBsaWJjdXJsIHNvY2tldHMgYXJlICp3cml0YWJsZSou IFRoaXMgYmVoYXZpb3IgaXMgcGlubmVkCisgKiBoZXJlIHRvIHJlY29yZCB0aGF0IGV4cGVjdGF0 aW9uLCBidXQgaXQncyBub3QgYSByZXF1aXJlZCBwYXJ0IG9mIHRoZSBBUEkuIElmCisgKiB5b3Un dmUgYWRkZWQgYSBuZXcgaW1wbGVtZW50YXRpb24gdGhhdCBkb2Vzbid0IGhhdmUgdGhhdCBiZWhh dmlvciwgZmVlbCBmcmVlCisgKiB0byBtb2RpZnkgdGhpcyB0ZXN0LgorICovCisjZGVmaW5lIG11 eF9pc19yZWFkeShNVVgsIERFQURMSU5FLCBURVNUKSBcCisJZG8geyBcCisJCWludCByZXNfID0g UFFzb2NrZXRQb2xsKE1VWCwgMSwgMCwgREVBRExJTkUpOyBcCisJCUFzc2VydChyZXNfICE9IC0x KTsgXAorCQlvayhyZXNfID4gMCwgIm11bHRpcGxleGVyIGlzIHJlYWR5ICIgVEVTVCk7IFwKKwl9 IHdoaWxlICgwKQorCisvKgorICogVGhlIG9wcG9zaXRlIG9mIG11eF9pc19yZWFkeSgpLgorICov CisjZGVmaW5lIG11eF9pc19ub3RfcmVhZHkoTVVYLCBURVNUKSBcCisJZG8geyBcCisJCWludCBy ZXNfID0gUFFzb2NrZXRQb2xsKE1VWCwgMSwgMCwgMCk7IFwKKwkJQXNzZXJ0KHJlc18gIT0gLTEp OyBcCisJCWlzKHJlc18sIDAsICJtdWx0aXBsZXhlciBpcyBub3QgcmVhZHkgIiBURVNUKTsgXAor CX0gd2hpbGUgKDApCisKKy8qCisgKiBUZXN0IFN1aXRlcworICovCisKKy8qIFBlci1zdWl0ZSB0 aW1lb3V0LiBTZXQgdmlhIHRoZSBQR19URVNUX1RJTUVPVVRfREVGQVVMVCBlbnZ2YXIuICovCitz dGF0aWMgcGdfdXNlY190aW1lX3QgdGltZW91dF91cyA9IDE4MCAqIDEwMDAgKiAxMDAwOworCitz dGF0aWMgdm9pZAordGVzdF9zZXRfdGltZXIodm9pZCkKK3sKKwlzdHJ1Y3QgYXN5bmNfY3R4ICph Y3R4ID0gaW5pdF90ZXN0X2FjdHgoKTsKKwljb25zdCBwZ191c2VjX3RpbWVfdCBkZWFkbGluZSA9 IFBRZ2V0Q3VycmVudFRpbWVVU2VjKCkgKyB0aW1lb3V0X3VzOworCisJcHJpbnRmKCIjIHRlc3Rf c2V0X3RpbWVyXG4iKTsKKworCS8qIEEgemVyby1kdXJhdGlvbiB0aW1lciBzaG91bGQgcmVzdWx0 IGluIGEgbmVhci1pbW1lZGlhdGUgcmVhZHkgc2lnbmFsLiAqLworCUFzc2VydChzZXRfdGltZXIo YWN0eCwgMCkpOworCW11eF9pc19yZWFkeShhY3R4LT5tdXgsIGRlYWRsaW5lLCAid2hlbiB0aW1l ciBleHBpcmVzIik7CisJaXModGltZXJfZXhwaXJlZChhY3R4KSwgMSwgInRpbWVyX2V4cGlyZWQo KSByZXR1cm5zIDEgd2hlbiB0aW1lciBleHBpcmVzIik7CisKKwkvKiBSZXNldHRpbmcgdGhlIHRp bWVyIGZhciBpbiB0aGUgZnV0dXJlIHNob3VsZCB1bnNldCB0aGUgcmVhZHkgc2lnbmFsLiAqLwor CUFzc2VydChzZXRfdGltZXIoYWN0eCwgSU5UX01BWCkpOworCW11eF9pc19ub3RfcmVhZHkoYWN0 eC0+bXV4LCAid2hlbiB0aW1lciBpcyByZXNldCB0byB0aGUgZnV0dXJlIik7CisJaXModGltZXJf ZXhwaXJlZChhY3R4KSwgMCwgInRpbWVyX2V4cGlyZWQoKSByZXR1cm5zIDAgd2l0aCB1bmV4cGly ZWQgdGltZXIiKTsKKworCS8qIFNldHRpbmcgYW5vdGhlciB6ZXJvLWR1cmF0aW9uIHRpbWVyIHNo b3VsZCBvdmVycmlkZSB0aGUgcHJldmlvdXMgb25lLiAqLworCUFzc2VydChzZXRfdGltZXIoYWN0 eCwgMCkpOworCW11eF9pc19yZWFkeShhY3R4LT5tdXgsIGRlYWRsaW5lLCAid2hlbiB0aW1lciBp cyByZS1leHBpcmVkIik7CisJaXModGltZXJfZXhwaXJlZChhY3R4KSwgMSwgInRpbWVyX2V4cGly ZWQoKSByZXR1cm5zIDEgd2hlbiB0aW1lciBpcyByZS1leHBpcmVkIik7CisKKwkvKiBBbmQgZGlz YWJsaW5nIHRoYXQgdGltZXIgc2hvdWxkIG9uY2UgYWdhaW4gdW5zZXQgdGhlIHJlYWR5IHNpZ25h bC4gKi8KKwlBc3NlcnQoc2V0X3RpbWVyKGFjdHgsIC0xKSk7CisJbXV4X2lzX25vdF9yZWFkeShh Y3R4LT5tdXgsICJ3aGVuIHRpbWVyIGlzIHVuc2V0Iik7CisJaXModGltZXJfZXhwaXJlZChhY3R4 KSwgMCwgInRpbWVyX2V4cGlyZWQoKSByZXR1cm5zIDAgd2hlbiB0aW1lciBpcyB1bnNldCIpOwor CisJeworCQlib29sCQlleHBpcmVkOworCisJCS8qIE1ha2Ugc3VyZSBkcmFpbl90aW1lcl9ldmVu dHMoKSBmdW5jdGlvbnMgY29ycmVjdGx5IGFzIHdlbGwuICovCisJCUFzc2VydChzZXRfdGltZXIo YWN0eCwgMCkpOworCQltdXhfaXNfcmVhZHkoYWN0eC0+bXV4LCBkZWFkbGluZSwgIndoZW4gdGlt ZXIgaXMgcmUtZXhwaXJlZCAoZHJhaW5fdGltZXJfZXZlbnRzKSIpOworCisJCUFzc2VydChkcmFp bl90aW1lcl9ldmVudHMoYWN0eCwgJmV4cGlyZWQpKTsKKwkJbXV4X2lzX25vdF9yZWFkeShhY3R4 LT5tdXgsICJ3aGVuIHRpbWVyIGlzIGRyYWluZWQgYWZ0ZXIgZXhwaXJpbmciKTsKKwkJaXMoZXhw aXJlZCwgMSwgImRyYWluX3RpbWVyX2V2ZW50cygpIHJlcG9ydHMgZXhwaXJhdGlvbiIpOworCQlp cyh0aW1lcl9leHBpcmVkKGFjdHgpLCAwLCAidGltZXJfZXhwaXJlZCgpIHJldHVybnMgMCBhZnRl ciB0aW1lciBpcyBkcmFpbmVkIik7CisKKwkJLyogQSBzZWNvbmQgZHJhaW4gc2hvdWxkIGRvIG5v dGhpbmcuICovCisJCUFzc2VydChkcmFpbl90aW1lcl9ldmVudHMoYWN0eCwgJmV4cGlyZWQpKTsK KwkJbXV4X2lzX25vdF9yZWFkeShhY3R4LT5tdXgsICJ3aGVuIHRpbWVyIGlzIGRyYWluZWQgYSBz ZWNvbmQgdGltZSIpOworCQlpcyhleHBpcmVkLCAwLCAiZHJhaW5fdGltZXJfZXZlbnRzKCkgcmVw b3J0cyBubyBleHBpcmF0aW9uIik7CisJCWlzKHRpbWVyX2V4cGlyZWQoYWN0eCksIDAsICJ0aW1l cl9leHBpcmVkKCkgc3RpbGwgcmV0dXJucyAwIik7CisJfQorCisJZnJlZV90ZXN0X2FjdHgoYWN0 eCk7Cit9CisKK3N0YXRpYyB2b2lkCit0ZXN0X3JlZ2lzdGVyX3NvY2tldCh2b2lkKQoreworCXN0 cnVjdCBhc3luY19jdHggKmFjdHggPSBpbml0X3Rlc3RfYWN0eCgpOworCWludAkJCXBpcGVmZFsy XTsKKwlpbnQJCQlyZmQsCisJCQkJd2ZkOworCWJvb2wJCWJpZGlyZWN0aW9uYWw7CisKKwkvKiBD cmVhdGUgYSBsb2NhbCBwaXBlIGZvciBjb21tdW5pY2F0aW9uLiAqLworCUFzc2VydChwaXBlKHBp cGVmZCkgPT0gMCk7CisJcmZkID0gcGlwZWZkWzBdOworCXdmZCA9IHBpcGVmZFsxXTsKKworCS8q CisJICogU29tZSBwbGF0Zm9ybXMgKEZyZWVCU0QpIGltcGxlbWVudCBiaWRpcmVjdGlvbmFsIHBp cGVzLCBhZmZlY3RpbmcgdGhlCisJICogYmVoYXZpb3Igb2Ygc29tZSBvZiB0aGVzZSB0ZXN0cy4g U3RvcmUgdGhhdCBrbm93bGVkZ2UgZm9yIGxhdGVyLgorCSAqLworCWJpZGlyZWN0aW9uYWwgPSBQ UXNvY2tldFBvbGwocmZkIC8qIHJlYWQgKi8gLCAwLCAxIC8qIHdyaXRlICovICwgMCkgPiAwOwor CisJLyoKKwkgKiBUaGlzIHN1aXRlIHJ1bnMgdHdpY2UgLS0gb25jZSB1c2luZyBDVVJMX1BPTExf SU4vQ1VSTF9QT0xMX09VVCBmb3IKKwkgKiByZWFkL3dyaXRlIG9wZXJhdGlvbnMsIHJlc3BlY3Rp dmVseSwgYW5kIG9uY2UgdXNpbmcgQ1VSTF9QT0xMX0lOT1VUIGZvcgorCSAqIGJvdGggc2lkZXMu CisJICovCisJZm9yIChpbnQgaW5vdXQgPSAwOyBpbm91dCA8IDI7IGlub3V0KyspCisJeworCQlj b25zdCBpbnQJaW5fZXZlbnQgPSBpbm91dCA/IENVUkxfUE9MTF9JTk9VVCA6IENVUkxfUE9MTF9J TjsKKwkJY29uc3QgaW50CW91dF9ldmVudCA9IGlub3V0ID8gQ1VSTF9QT0xMX0lOT1VUIDogQ1VS TF9QT0xMX09VVDsKKwkJY29uc3QgcGdfdXNlY190aW1lX3QgZGVhZGxpbmUgPSBQUWdldEN1cnJl bnRUaW1lVVNlYygpICsgdGltZW91dF91czsKKwkJc2l6ZV90CQliaWRpX3BpcGVfc2l6ZSA9IDA7 IC8qIHNpbGVuY2UgY29tcGlsZXIgd2FybmluZ3MgKi8KKworCQlwcmludGYoIiMgdGVzdF9yZWdp c3Rlcl9zb2NrZXQgJXNcbiIsIGlub3V0ID8gIihJTk9VVCkiIDogIiIpOworCisJCS8qCisJCSAq IEF0IHRoZSBzdGFydCBvZiB0aGUgdGVzdCwgdGhlIHJlYWQgc2lkZSBzaG91bGQgYmUgYmxvY2tl ZCBhbmQgdGhlCisJCSAqIHdyaXRlIHNpZGUgc2hvdWxkIGJlIG9wZW4uIChUaGVyZSdzIGEgbWlz dGFrZSBhdCB0aGUgZW5kIG9mIHRoaXMKKwkJICogbG9vcCBvdGhlcndpc2UuKQorCQkgKi8KKwkJ QXNzZXJ0KFBRc29ja2V0UG9sbChyZmQsIDEsIDAsIDApID09IDApOworCQlBc3NlcnQoUFFzb2Nr ZXRQb2xsKHdmZCwgMCwgMSwgMCkgPiAwKTsKKworCQkvKgorCQkgKiBGb3IgYmlkaXJlY3Rpb25h bCBzeXN0ZW1zLCBlbXVsYXRlIHVuaWRpcmVjdGlvbmFsIGJlaGF2aW9yIGhlcmUgYnkKKwkJICog ZmlsbGluZyB1cCB0aGUgInJlYWQgc2lkZSIgb2YgdGhlIHBpcGUuCisJCSAqLworCQlpZiAoYmlk aXJlY3Rpb25hbCkKKwkJCUFzc2VydCgoYmlkaV9waXBlX3NpemUgPSBmaWxsX3BpcGUocmZkKSkg PiAwKTsKKworCQkvKiBMaXN0ZW4gb24gdGhlIHJlYWQgc2lkZS4gVGhlIG11bHRpcGxleGVyIHNo b3VsZG4ndCBiZSByZWFkeSB5ZXQuICovCisJCUFzc2VydChyZWdpc3Rlcl9zb2NrZXQoTlVMTCwg cmZkLCBpbl9ldmVudCwgYWN0eCwgTlVMTCkgPT0gMCk7CisJCW11eF9pc19ub3RfcmVhZHkoYWN0 eC0+bXV4LCAid2hlbiBmZCBpcyBub3QgcmVhZGFibGUiKTsKKworCQkvKiBXcml0aW5nIHRvIHRo ZSBwaXBlIHNob3VsZCByZXN1bHQgaW4gYSByZWFkLXJlYWR5IG11bHRpcGxleGVyLiAqLworCQlB c3NlcnQod3JpdGUod2ZkLCAieCIsIDEpID09IDEpOworCQltdXhfaXNfcmVhZHkoYWN0eC0+bXV4 LCBkZWFkbGluZSwgIndoZW4gZmQgaXMgcmVhZGFibGUiKTsKKworCQkvKgorCQkgKiBVcGRhdGUg dGhlIHJlZ2lzdHJhdGlvbiB0byB3YWl0IG9uIHdyaXRlIGV2ZW50cyBpbnN0ZWFkLiBUaGUKKwkJ ICogbXVsdGlwbGV4ZXIgc2hvdWxkIGJlIHVuc2V0LgorCQkgKi8KKwkJQXNzZXJ0KHJlZ2lzdGVy X3NvY2tldChOVUxMLCByZmQsIENVUkxfUE9MTF9PVVQsIGFjdHgsIE5VTEwpID09IDApOworCQlt dXhfaXNfbm90X3JlYWR5KGFjdHgtPm11eCwgIndoZW4gd2FpdGluZyBmb3Igd3JpdGVzIG9uIHJl YWRhYmxlIGZkIik7CisKKwkJLyogUmUtcmVnaXN0ZXIgZm9yIHJlYWQgZXZlbnRzLiAqLworCQlB c3NlcnQocmVnaXN0ZXJfc29ja2V0KE5VTEwsIHJmZCwgaW5fZXZlbnQsIGFjdHgsIE5VTEwpID09 IDApOworCQltdXhfaXNfcmVhZHkoYWN0eC0+bXV4LCBkZWFkbGluZSwgIndoZW4gd2FpdGluZyBm b3IgcmVhZHMgYWdhaW4iKTsKKworCQkvKiBTdG9wIGxpc3RlbmluZy4gVGhlIG11bHRpcGxleGVy IHNob3VsZCBiZSB1bnNldC4gKi8KKwkJQXNzZXJ0KHJlZ2lzdGVyX3NvY2tldChOVUxMLCByZmQs IENVUkxfUE9MTF9SRU1PVkUsIGFjdHgsIE5VTEwpID09IDApOworCQltdXhfaXNfbm90X3JlYWR5 KGFjdHgtPm11eCwgIndoZW4gcmVhZGFibGUgZmQgaXMgcmVtb3ZlZCIpOworCisJCS8qIExpc3Rl biBhZ2Fpbi4gKi8KKwkJQXNzZXJ0KHJlZ2lzdGVyX3NvY2tldChOVUxMLCByZmQsIGluX2V2ZW50 LCBhY3R4LCBOVUxMKSA9PSAwKTsKKwkJbXV4X2lzX3JlYWR5KGFjdHgtPm11eCwgZGVhZGxpbmUs ICJ3aGVuIHJlYWRhYmxlIGZkIGlzIHJlLWFkZGVkIik7CisKKwkJLyoKKwkJICogRHJhaW5pbmcg dGhlIHBpcGUgc2hvdWxkIHVuc2V0IHRoZSBtdWx0aXBsZXhlciBhZ2Fpbiwgb25jZSB0aGUgb2xk CisJCSAqIGV2ZW50IGlzIGRyYWluZWQuCisJCSAqLworCQlBc3NlcnQoZHJhaW5fcGlwZShyZmQs IDEpKTsKKwkJQXNzZXJ0KGRyYWluX3NvY2tldF9ldmVudHMoYWN0eCkpOworCQltdXhfaXNfbm90 X3JlYWR5KGFjdHgtPm11eCwgIndoZW4gZmQgaXMgZHJhaW5lZCIpOworCisJCS8qIFVuZG8gYW55 IHVuaWRpcmVjdGlvbmFsIGVtdWxhdGlvbi4gKi8KKwkJaWYgKGJpZGlyZWN0aW9uYWwpCisJCQlB c3NlcnQoZHJhaW5fcGlwZSh3ZmQsIGJpZGlfcGlwZV9zaXplKSk7CisKKwkJLyogTGlzdGVuIG9u IHRoZSB3cml0ZSBzaWRlLiBBbiBlbXB0eSBidWZmZXIgc2hvdWxkIGJlIHdyaXRhYmxlLiAqLwor CQlBc3NlcnQocmVnaXN0ZXJfc29ja2V0KE5VTEwsIHJmZCwgQ1VSTF9QT0xMX1JFTU9WRSwgYWN0 eCwgTlVMTCkgPT0gMCk7CisJCUFzc2VydChyZWdpc3Rlcl9zb2NrZXQoTlVMTCwgd2ZkLCBvdXRf ZXZlbnQsIGFjdHgsIE5VTEwpID09IDApOworCQltdXhfaXNfcmVhZHkoYWN0eC0+bXV4LCBkZWFk bGluZSwgIndoZW4gZmQgaXMgd3JpdGFibGUiKTsKKworCQkvKiBBcyBhYm92ZSwgd2FpdCBvbiBy ZWFkIGV2ZW50cyBpbnN0ZWFkLiAqLworCQlBc3NlcnQocmVnaXN0ZXJfc29ja2V0KE5VTEwsIHdm ZCwgQ1VSTF9QT0xMX0lOLCBhY3R4LCBOVUxMKSA9PSAwKTsKKwkJbXV4X2lzX25vdF9yZWFkeShh Y3R4LT5tdXgsICJ3aGVuIHdhaXRpbmcgZm9yIHJlYWRzIG9uIHdyaXRhYmxlIGZkIik7CisKKwkJ LyogUmUtcmVnaXN0ZXIgZm9yIHdyaXRlIGV2ZW50cy4gKi8KKwkJQXNzZXJ0KHJlZ2lzdGVyX3Nv Y2tldChOVUxMLCB3ZmQsIG91dF9ldmVudCwgYWN0eCwgTlVMTCkgPT0gMCk7CisJCW11eF9pc19y ZWFkeShhY3R4LT5tdXgsIGRlYWRsaW5lLCAid2hlbiB3YWl0aW5nIGZvciB3cml0ZXMgYWdhaW4i KTsKKworCQl7CisJCQlzc2l6ZV90CQl3cml0dGVuOworCisJCQkvKgorCQkJICogRmlsbCB0aGUg cGlwZS4gT25jZSB0aGUgb2xkIHdyaXRhYmxlIGV2ZW50IGlzIGRyYWluZWQsIHRoZSBtdXgKKwkJ CSAqIHNob3VsZCBub3QgYmUgcmVhZHkuCisJCQkgKi8KKwkJCUFzc2VydCgod3JpdHRlbiA9IGZp bGxfcGlwZSh3ZmQpKSA+IDApOworCQkJcHJpbnRmKCIjIHBpcGUgYnVmZmVyIGlzIGZ1bGwgYXQg JXpkIGJ5dGVzXG4iLCB3cml0dGVuKTsKKworCQkJQXNzZXJ0KGRyYWluX3NvY2tldF9ldmVudHMo YWN0eCkpOworCQkJbXV4X2lzX25vdF9yZWFkeShhY3R4LT5tdXgsICJ3aGVuIGZkIGJ1ZmZlciBp cyBmdWxsIik7CisKKwkJCS8qIERyYWluIHRoZSBwaXBlIGFnYWluLiAqLworCQkJQXNzZXJ0KGRy YWluX3BpcGUocmZkLCB3cml0dGVuKSk7CisJCQltdXhfaXNfcmVhZHkoYWN0eC0+bXV4LCBkZWFk bGluZSwgIndoZW4gZmQgYnVmZmVyIGlzIGRyYWluZWQiKTsKKwkJfQorCisJCS8qIFN0b3AgbGlz dGVuaW5nLiAqLworCQlBc3NlcnQocmVnaXN0ZXJfc29ja2V0KE5VTEwsIHdmZCwgQ1VSTF9QT0xM X1JFTU9WRSwgYWN0eCwgTlVMTCkgPT0gMCk7CisJCW11eF9pc19ub3RfcmVhZHkoYWN0eC0+bXV4 LCAid2hlbiBmZCBpcyByZW1vdmVkIik7CisKKwkJLyogTWFrZSBzdXJlIGFuIGV4cGlyZWQgdGlt ZXIgZG9lc24ndCBpbnRlcmZlcmUgd2l0aCBldmVudCBkcmFpbmluZy4gKi8KKwkJeworCQkJLyog TWFrZSB0aGUgcmZkIGFwcGVhciB1bmlkaXJlY3Rpb25hbCBpZiBuZWNlc3NhcnkuICovCisJCQlp ZiAoYmlkaXJlY3Rpb25hbCkKKwkJCQlBc3NlcnQoKGJpZGlfcGlwZV9zaXplID0gZmlsbF9waXBl KHJmZCkpID4gMCk7CisKKwkJCS8qIFNldCB0aGUgdGltZXIgYW5kIHdhaXQgZm9yIGl0IHRvIGV4 cGlyZS4gKi8KKwkJCUFzc2VydChzZXRfdGltZXIoYWN0eCwgMCkpOworCQkJQXNzZXJ0KFBRc29j a2V0UG9sbChhY3R4LT50aW1lcmZkLCAxLCAwLCBkZWFkbGluZSkgPiAwKTsKKwkJCWlzKHRpbWVy X2V4cGlyZWQoYWN0eCksIDEsICJ0aW1lciBpcyBleHBpcmVkIik7CisKKwkJCS8qIFJlZ2lzdGVy IGZvciByZWFkIGV2ZW50cyBhbmQgbWFrZSB0aGUgZmQgcmVhZGFibGUuICovCisJCQlBc3NlcnQo cmVnaXN0ZXJfc29ja2V0KE5VTEwsIHJmZCwgaW5fZXZlbnQsIGFjdHgsIE5VTEwpID09IDApOwor CQkJQXNzZXJ0KHdyaXRlKHdmZCwgIngiLCAxKSA9PSAxKTsKKwkJCW11eF9pc19yZWFkeShhY3R4 LT5tdXgsIGRlYWRsaW5lLCAid2hlbiBmZCBpcyByZWFkYWJsZSBhbmQgdGltZXIgZXhwaXJlZCIp OworCisJCQkvKgorCQkJICogRHJhaW5pbmcgdGhlIHBpcGUgc2hvdWxkIHVuc2V0IHRoZSBtdWx0 aXBsZXhlciBhZ2Fpbiwgb25jZSB0aGUKKwkJCSAqIG9sZCBldmVudCBpcyBkcmFpbmVkIGFuZCB0 aGUgdGltZXIgaXMgcmVzZXQuCisJCQkgKgorCQkJICogT3JkZXIgbWF0dGVycyB0byBhdm9pZCBm YWxzZSBuZWdhdGl2ZXMuIEZpcnN0IGRyYWluIHRoZSBzb2NrZXQsCisJCQkgKiB0aGVuIHVuc2V0 IHRoZSB0aW1lci4gV2UncmUgdHJ5aW5nIHRvIGNhdGNoIHRoZSBjYXNlIHdoZXJlIHRoZQorCQkJ ICogcGVuZGluZyB0aW1lciBleHBpcmF0aW9uIGV2ZW50IHRha2VzIHRoZSBwbGFjZSBvZiBvbmUg b2YgdGhlCisJCQkgKiBzb2NrZXQgZXZlbnRzIHdlJ3JlIGF0dGVtcHRpbmcgdG8gZHJhaW4uCisJ CQkgKi8KKwkJCUFzc2VydChkcmFpbl9waXBlKHJmZCwgMSkpOworCQkJQXNzZXJ0KGRyYWluX3Nv Y2tldF9ldmVudHMoYWN0eCkpOworCQkJQXNzZXJ0KHNldF90aW1lcihhY3R4LCAtMSkpOworCisJ CQlpcyh0aW1lcl9leHBpcmVkKGFjdHgpLCAwLCAidGltZXIgaXMgbm8gbG9uZ2VyIGV4cGlyZWQi KTsKKwkJCW11eF9pc19ub3RfcmVhZHkoYWN0eC0+bXV4LCAid2hlbiBmZCBpcyBkcmFpbmVkIGFu ZCB0aW1lciByZXNldCIpOworCisJCQkvKiBTdG9wIGxpc3RlbmluZy4gKi8KKwkJCUFzc2VydChy ZWdpc3Rlcl9zb2NrZXQoTlVMTCwgcmZkLCBDVVJMX1BPTExfUkVNT1ZFLCBhY3R4LCBOVUxMKSA9 PSAwKTsKKworCQkJLyogVW5kbyBhbnkgdW5pZGlyZWN0aW9uYWwgZW11bGF0aW9uLiAqLworCQkJ aWYgKGJpZGlyZWN0aW9uYWwpCisJCQkJQXNzZXJ0KGRyYWluX3BpcGUod2ZkLCBiaWRpX3BpcGVf c2l6ZSkpOworCQl9CisJfQorCisJY2xvc2UocmZkKTsKKwljbG9zZSh3ZmQpOworCWZyZWVfdGVz dF9hY3R4KGFjdHgpOworfQorCitpbnQKK21haW4oaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKK3sK Kwljb25zdCBjaGFyICp0aW1lb3V0OworCisJLyogR3JhYiB0aGUgZGVmYXVsdCB0aW1lb3V0LiAq LworCXRpbWVvdXQgPSBnZXRlbnYoIlBHX1RFU1RfVElNRU9VVF9ERUZBVUxUIik7CisJaWYgKHRp bWVvdXQpCisJeworCQlpbnQJCQl0aW1lb3V0X3MgPSBhdG9pKHRpbWVvdXQpOworCisJCWlmICh0 aW1lb3V0X3MgPiAwKQorCQkJdGltZW91dF91cyA9IHRpbWVvdXRfcyAqIDEwMDAgKiAxMDAwOwor CX0KKworCS8qCisJICogU2V0IHVwIGxpbmUgYnVmZmVyaW5nIGZvciBvdXIgb3V0cHV0LCB0byBs ZXQgc3RkZXJyIGludGVybGVhdmUgaW4gdGhlCisJICogbG9nIGZpbGVzLgorCSAqLworCXNldHZi dWYoc3Rkb3V0LCBOVUxMLCBQR19JT0xCRiwgMCk7CisKKwl0ZXN0X3NldF90aW1lcigpOworCXRl c3RfcmVnaXN0ZXJfc29ja2V0KCk7CisKKwlwcmludGYoIjEuLiVkXG4iLCBudW1fdGVzdHMpOwor CXJldHVybiAwOworfQorCisjZWxzZQkJCQkJCQkvKiAhVVNFX0FTU0VSVF9DSEVDS0lORyAqLwor CisvKgorICogU2tpcCB0aGUgdGVzdCBzdWl0ZSB3aGVuIHdlIGRvbid0IGhhdmUgYXNzZXJ0aW9u cy4KKyAqLworaW50CittYWluKGludCBhcmdjLCBjaGFyICphcmd2W10pCit7CisJcHJpbnRmKCIx Li4wICMgc2tpcDogY2Fzc2VydCBpcyBub3QgZW5hYmxlZFxuIik7CisKKwlyZXR1cm4gMDsKK30K KworI2VuZGlmCQkJCQkJCS8qIFVTRV9BU1NFUlRfQ0hFQ0tJTkcgKi8KLS0gCjIuMzQuMQoK --0000000000004886fa063881fe30--