MIME-Version: 1.0
References: 
 <CAER375PhG5an=p1=6QS6vWi=BHxR+ViJmYPDkkEtpgVsfCcu_w@mail.gmail.com>
 <CAE2r8H5QAng_rRrkVmGbLuQSgbMz94tpOOOdJKeuHj=go0nXqg@mail.gmail.com>
 <CAN4CZFOe-0jTR7_s2uciX9TNKxRvd2h8avAw9iFO6VPu0CChsQ@mail.gmail.com>
 <CAER375Oh6U_kqP0SK8OP47vy3PBd4p1C027Gaod3B2bqKgMFoQ@mail.gmail.com>
 <CAN4CZFNV69LS6H87sV-iPO9w_V-_uko4_G_0QKb1cokJvWhF6g@mail.gmail.com>
 <CAE2r8H6Tc6F2BM-JqC+gp-HQKCzfHOx02Xj5MmuS-AY4jfN5iw@mail.gmail.com>
 <CAER375Mtf-7LcR1zNks67k57r3b5yTy9sHxRQ78Y1+xmTVncMw@mail.gmail.com>
 <D3C75650-2FED-41B3-A6BF-E4D8F9E40EAE@yesql.se>
 <CAN4CZFPKY2m1bEm51g-1jmBfCMohfe5VFoKuCnbhiGP1FBBNrQ@mail.gmail.com>
 <7F3C1A8B-F0FF-49BF-A53C-DC043BBB1FE7@yesql.se>
 <CAN4CZFMaAvHSBbQ25o=yiWqn=p7jBNUBABZvqoU1x1-7NWPH9Q@mail.gmail.com>
 <CAER375P8M2b3Nd8r_+ynbhgHgGcybiLRPN64TAN=hQ4YQFO=nQ@mail.gmail.com>
In-Reply-To: 
 <CAER375P8M2b3Nd8r_+ynbhgHgGcybiLRPN64TAN=hQ4YQFO=nQ@mail.gmail.com>
From: Ajit Awekar <ajitpostgres@gmail.com>
Date: Mon, 16 Mar 2026 19:27:17 +0530
Message-ID: 
 <CAER375OVXtyp7GiYNes30jn_pOrXoC_qDEEVGS2aDErm4oKiYQ@mail.gmail.com>
Subject: Re: [OAuth2] Infrastructure for tracking token expiry time
To: Zsolt Parragi <zsolt.parragi@percona.com>
Cc: Daniel Gustafsson <daniel@yesql.se>, VASUKI M <vasukianand0119@gmail.com>,
	PostgreSQL Hackers <pgsql-hackers@lists.postgresql.org>
Content-Type: multipart/mixed; boundary="000000000000823645064d249927"
Archived-At: 
 <https://www.postgresql.org/message-id/CAER375OVXtyp7GiYNes30jn_pOrXoC_qDEEVGS2aDErm4oKiYQ%40mail.gmail.com>
Precedence: bulk

--000000000000823645064d249927
Content-Type: multipart/alternative; boundary="000000000000823643064d249925"

--000000000000823643064d249925
Content-Type: text/plain; charset="UTF-8"

Hi,

Please find the attached first version of the patch providing credential
validation framework.

The credential validation framework provides a mechanism to continuously
validate authentication credentials during an active session. This enables
the server to periodically check credential validity and take appropriate
action when credentials expire or become invalid.

  Currently, Postgres validates credentials only at connection time. Once
authenticated, a session remains active even if:

  - A user's rolvaliduntil expiration time passes
  - An OAuth bearer token expires


* Proposed Solution*
  The patch introduces a credential validation framework that:

  1. Periodically checks credential validity during active sessions
  2. Terminates sessions when credentials expire or become invalid

*Implementation*

  The framework consists of:

  - Core infrastructure (auth-validate.c/h): Manages validation callbacks,
dispatches validation checks based on authentication method
  - Method implementations (auth-validate-methods.c/h): Contains validators
for password-based auth (checks rolvaliduntil in pg_authid) and OAuth
  (delegates to validator's expire_cb)

  Validation is triggered during query execution in both simple and
extended query protocol paths, using a time-based approach to limit
overhead.


*  Configuration*
  Two new GUC parameters:

  credential_validation.enabled = false   # enable/disable validation
  credential_validation.interval = 1      # check interval in minutes (1-60)


* Extensibility*
  New authentication methods can be supported by:
  1. Adding an enum value to CredentialValidationType
  2. Implementing a validation callback
  3. Registering it via RegisterCredentialValidator()


 Should there be per-authentication-method enable/disable settings?

Thanks & Best Regards,
Ajit


On Fri, 20 Feb 2026 at 15:12, Ajit Awekar <ajitpostgres@gmail.com> wrote:

>
> Thanks a lot Daniel, Zslot, Vasuki for your review comments.
>
> >The mechanism used is however a secondary discussion,
> >first thing to get in place is a design for how to handle mid-connection
> >credential expiration.
>
> This patch introduces a generic credential validation framework that
> allows
>  us to periodically validate authentication credentials during active
>  database sessions. When enabled, this feature detects expired
>  credentials and terminates sessions that are no longer valid.
>
>  Added GUCs
> Credential_validation.enabled = on   // Enable or Disable Credential
> validation
> Credential_validation.interval = 120  //Frequency in seconds of running
> credential validation
>
>  The callback mechanism works by:
>   - Defining a CredentialValidationCallback function pointer type
>   - Maintaining an array of validators indexed by authentication method
>   - Allowing other auth mechanisms to register validators via
>     RegisterCredentialValidator()
>   - Selecting the appropriate validator at runtime based on the session's
>     authentication method
>
> The current implementation primarily supports password-based
> authentication methods, verifying that passwords haven't expired. It can be
> extended to any authentication method.
> This patch is WIP. I am submitting it now to get early feedback on the
> overall design and approach.
>
> Thanks & Best Regards,
> Ajit
>
> On Wed, 18 Feb 2026 at 22:29, Zsolt Parragi <zsolt.parragi@percona.com>
> wrote:
>
>> > but I still think that neither should overload
>> > what FATAL error means
>>
>> I see, I misunderstood what you meant by graceful there. In this case,
>> this is also a good comment for the password expiration thread,
>> currently that also uses FATAL errors for terminating a connection
>> when the password expires.
>>
>> What other option do you see? Something new for this use case like
>> GoAway, and clients not understanding it simply get disconnected after
>> some grace period? Or using the recently merged connectionWarning to
>> send a warning to the client, and disconnect it shortly if it doesn't
>> do anything to fix the situation?
>>
>> When I tested the password expiration patch I noticed that deleted
>> users who still have remaining active connections currently get ERRORs
>> for every statement that requires permission checks, so in this regard
>> using ERROR/FATAL for the situation seemed fine to me - it's similar
>> to what already happens in some edge cases with authentication.
>>
>

--000000000000823643064d249925
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">Hi,<div><br></div><div>Please find the attached first vers=
ion of the patch providing credential validation framework.=C2=A0</div><div=
><br></div><div>The credential validation framework provides a mechanism to=
 continuously validate authentication credentials during an active=C2=A0ses=
sion. This enables the server to periodically check credential validity and=
 take appropriate action when credentials expire or become invalid.</div><d=
iv><br></div><div>=C2=A0 Currently, Postgres validates credentials only at =
connection time. Once authenticated, a session remains active even if:<br><=
br>=C2=A0 - A user&#39;s rolvaliduntil expiration time passes<br>=C2=A0 - A=
n OAuth bearer token expires<br><br></div><div><br></div><div><b>=C2=A0Prop=
osed Solution<br></b><br>=C2=A0 The patch introduces a credential validatio=
n framework that:<br><br>=C2=A0 1. Periodically checks credential validity =
during active sessions<br>=C2=A0 2. Terminates sessions when credentials ex=
pire or become invalid<br><br><b>Implementation</b><br><br>=C2=A0 The frame=
work consists of:<br><br>=C2=A0 - Core infrastructure (auth-validate.c/h): =
Manages validation callbacks, dispatches validation checks based on authent=
ication method<br>=C2=A0 - Method implementations (auth-validate-methods.c/=
h): Contains validators for password-based auth (checks rolvaliduntil in pg=
_authid) and OAuth<br>=C2=A0 (delegates to validator&#39;s expire_cb)<br><b=
r>=C2=A0 Validation is triggered during query execution in both simple and =
extended query protocol paths, using a time-based approach to limit overhea=
d.<br><br><b>=C2=A0 Configuration<br></b><br>=C2=A0 Two new GUC parameters:=
<br><br>=C2=A0 credential_validation.enabled =3D false =C2=A0 # enable/disa=
ble validation<br>=C2=A0 credential_validation.interval =3D 1 =C2=A0 =C2=A0=
 =C2=A0# check interval in minutes (1-60)<br></div><div><br></div><div><b>=
=C2=A0Extensibility<br></b><br>=C2=A0 New authentication methods can be sup=
ported by:<br>=C2=A0 1. Adding an enum value to CredentialValidationType<br=
>=C2=A0 2. Implementing a validation callback<br>=C2=A0 3. Registering it v=
ia RegisterCredentialValidator()</div><div><br></div><div><br></div><div>=
=C2=A0Should there be per-authentication-method enable/disable settings?</d=
iv><div><br></div><div>Thanks &amp; Best Regards,</div><div>Ajit</div><div>=
<br></div><div></div></div><br><div class=3D"gmail_quote"><div dir=3D"ltr" =
class=3D"gmail_attr">On Fri, 20 Feb 2026 at 15:12, Ajit Awekar &lt;<a href=
=3D"mailto:ajitpostgres@gmail.com" target=3D"_blank">ajitpostgres@gmail.com=
</a>&gt; wrote:<br></div><blockquote class=3D"gmail_quote" style=3D"margin:=
0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex">=
<div dir=3D"ltr"><br><div>Thanks a lot Daniel, Zslot, Vasuki for your revie=
w=C2=A0comments.</div><div><br></div><div>&gt;The mechanism used is however=
 a secondary discussion,<br>&gt;first thing to get in place is a design for=
 how to handle mid-connection<br><div>&gt;credential expiration.</div><div>=
<br>This patch introduces a generic credential validation framework that al=
lows =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =
=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=
=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =
=C2=A0 =C2=A0 =C2=A0 <br>=C2=A0us to periodically validate authentication c=
redentials during active<br>=C2=A0database sessions. When enabled, this fea=
ture detects expired=C2=A0<br>=C2=A0credentials and terminates sessions tha=
t are no longer valid.<br>=C2=A0 <br>=C2=A0Added GUCs<br>Credential_validat=
ion.enabled =3D on =C2=A0 // Enable or Disable Credential validation<br>Cre=
dential_validation.interval =3D 120 =C2=A0//Frequency in seconds of running=
 credential validation<br><br>=C2=A0The callback mechanism works by:<br>=C2=
=A0 - Defining a CredentialValidationCallback function pointer type<br>=C2=
=A0 - Maintaining an array of validators indexed by authentication method<b=
r>=C2=A0 - Allowing other auth mechanisms to register validators via<br>=C2=
=A0 =C2=A0 RegisterCredentialValidator()<br>=C2=A0 - Selecting the appropri=
ate validator at runtime based on the session&#39;s<br>=C2=A0 =C2=A0 authen=
tication method<br><br>The current implementation primarily supports passwo=
rd-based authentication methods, verifying that passwords haven&#39;t expir=
ed. It can be extended to any authentication method.<br>This patch is WIP. =
I am submitting it now to get early feedback on the overall design and appr=
oach.<br>=C2=A0=C2=A0</div><div>Thanks &amp; Best Regards,</div><div>Ajit</=
div></div><div></div></div><br><div class=3D"gmail_quote"><div dir=3D"ltr" =
class=3D"gmail_attr">On Wed, 18 Feb 2026 at 22:29, Zsolt Parragi &lt;<a hre=
f=3D"mailto:zsolt.parragi@percona.com" target=3D"_blank">zsolt.parragi@perc=
ona.com</a>&gt; wrote:<br></div><blockquote class=3D"gmail_quote" style=3D"=
margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-lef=
t:1ex">&gt; but I still think that neither should overload<br>
&gt; what FATAL error means<br>
<br>
I see, I misunderstood what you meant by graceful there. In this case,<br>
this is also a good comment for the password expiration thread,<br>
currently that also uses FATAL errors for terminating a connection<br>
when the password expires.<br>
<br>
What other option do you see? Something new for this use case like<br>
GoAway, and clients not understanding it simply get disconnected after<br>
some grace period? Or using the recently merged connectionWarning to<br>
send a warning to the client, and disconnect it shortly if it doesn&#39;t<b=
r>
do anything to fix the situation?<br>
<br>
When I tested the password expiration patch I noticed that deleted<br>
users who still have remaining active connections currently get ERRORs<br>
for every statement that requires permission checks, so in this regard<br>
using ERROR/FATAL for the situation seemed fine to me - it&#39;s similar<br=
>
to what already happens in some edge cases with authentication.<br>
</blockquote></div>
</blockquote></div>

--000000000000823643064d249925--

--000000000000823645064d249927
Content-Type: application/octet-stream;
	name="credential_validation_V1.patch"
Content-Disposition: attachment; filename="credential_validation_V1.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmt8ykzt0>
X-Attachment-Id: f_mmt8ykzt0

ZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2xpYnBxL01ha2VmaWxlIGIvc3JjL2JhY2tlbmQvbGli
cHEvTWFrZWZpbGUKaW5kZXggOThlYjJhODI0MmQuLjMyZTRjNzI4MGU1IDEwMDY0NAotLS0gYS9z
cmMvYmFja2VuZC9saWJwcS9NYWtlZmlsZQorKysgYi9zcmMvYmFja2VuZC9saWJwcS9NYWtlZmls
ZQpAQCAtMTgsNiArMTgsOCBAQCBPQkpTID0gXAogCWF1dGgtb2F1dGgubyBcCiAJYXV0aC1zYXNs
Lm8gXAogCWF1dGgtc2NyYW0ubyBcCisJYXV0aC12YWxpZGF0ZS1tZXRob2RzLm8gXAorCWF1dGgt
dmFsaWRhdGUubyBcCiAJYXV0aC5vIFwKIAliZS1mc3N0dWJzLm8gXAogCWJlLXNlY3VyZS1jb21t
b24ubyBcCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9saWJwcS9hdXRoLW9hdXRoLmMgYi9zcmMv
YmFja2VuZC9saWJwcS9hdXRoLW9hdXRoLmMKaW5kZXggMTEzNjUwNDg5NTEuLmM2YTc4NDBjYjdh
IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9saWJwcS9hdXRoLW9hdXRoLmMKKysrIGIvc3JjL2Jh
Y2tlbmQvbGlicHEvYXV0aC1vYXV0aC5jCkBAIC04OTIsMyArODkyLDE4IEBAIGRvbmU6CiAKIAly
ZXR1cm4gKCplcnJfbXNnID09IE5VTEwpOwogfQorCisvKgorICogQ2hlY2sgaWYgYW4gT0F1dGgg
dG9rZW4gaGFzIGV4cGlyZWQuCisgKiBUaGlzIGlzIGNhbGxlZCBmcm9tIGNyZWRlbnRpYWwgdmFs
aWRhdGlvbiB0byBjaGVjayB0b2tlbiB2YWxpZGl0eS4KKyAqLworYm9vbAorQ2hlY2tPQXV0aFZh
bGlkYXRvckV4cGlyYXRpb24odm9pZCkKK3sKKwkvKiBEZWxlZ2F0ZSB0byB2YWxpZGF0b3IncyBl
eHBpcmVfY2IgaWYgYXZhaWxhYmxlICovCisJaWYgKFZhbGlkYXRvckNhbGxiYWNrcyAhPSBOVUxM
ICYmIFZhbGlkYXRvckNhbGxiYWNrcy0+ZXhwaXJlX2NiICE9IE5VTEwpCisJCXJldHVybiBWYWxp
ZGF0b3JDYWxsYmFja3MtPmV4cGlyZV9jYih2YWxpZGF0b3JfbW9kdWxlX3N0YXRlKTsKKworCS8q
IE5vIGV4cGlyZV9jYiwgYXNzdW1lIHZhbGlkICovCisJcmV0dXJuIHRydWU7Cit9CmRpZmYgLS1n
aXQgYS9zcmMvYmFja2VuZC9saWJwcS9hdXRoLXZhbGlkYXRlLW1ldGhvZHMuYyBiL3NyYy9iYWNr
ZW5kL2xpYnBxL2F1dGgtdmFsaWRhdGUtbWV0aG9kcy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu
ZGV4IDAwMDAwMDAwMDAwLi5kN2UxNTA2YzJhMQotLS0gL2Rldi9udWxsCisrKyBiL3NyYy9iYWNr
ZW5kL2xpYnBxL2F1dGgtdmFsaWRhdGUtbWV0aG9kcy5jCkBAIC0wLDAgKzEsMTQwIEBACisvKi0t
LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0KKyAqCisgKiBhdXRoLXZhbGlkYXRlLW1ldGhvZHMuYworICogICAgICBJ
bXBsZW1lbnRhdGlvbiBvZiBhdXRoZW50aWNhdGlvbiBjcmVkZW50aWFsIHZhbGlkYXRpb24gbWV0
aG9kcworICoKKyAqIFRoaXMgbW9kdWxlIHByb3ZpZGVzIGNyZWRlbnRpYWwgdmFsaWRhdGlvbiBt
ZXRob2RzIGZvciB2YXJpb3VzIGF1dGhlbnRpY2F0aW9uCisgKiB0eXBlcyBkdXJpbmcgYWN0aXZl
IFBvc3RncmVTUUwgc2Vzc2lvbnMuIEl0IGluY2x1ZGVzIHZhbGlkYXRpb24gZm9yIHBhc3N3b3Jk
CisgKiBleHBpcnksIE9BdXRoIHRva2VuIGV4cGlyeSwgYW5kIGNhbiBiZSBleHRlbmRlZCB0byBv
dGhlciBhdXRoZW50aWNhdGlvbgorICogbWVjaGFuaXNtcy4KKyAqCisgKiBQb3J0aW9ucyBDb3B5
cmlnaHQgKGMpIDE5OTYtMjAyNiwgUG9zdGdyZVNRTCBHbG9iYWwgRGV2ZWxvcG1lbnQgR3JvdXAK
KyAqIFBvcnRpb25zIENvcHlyaWdodCAoYykgMTk5NCwgUmVnZW50cyBvZiB0aGUgVW5pdmVyc2l0
eSBvZiBDYWxpZm9ybmlhCisgKgorICogSURFTlRJRklDQVRJT04KKyAqICAgICAgc3JjL2JhY2tl
bmQvbGlicHEvYXV0aC12YWxpZGF0ZS1tZXRob2RzLmMKKyAqCisgKi0tLS0tLS0tLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0K
KyAqLworI2luY2x1ZGUgInBvc3RncmVzLmgiCisKKyNpbmNsdWRlICJhY2Nlc3MvaHR1cF9kZXRh
aWxzLmgiCisjaW5jbHVkZSAiYWNjZXNzL3hhY3QuaCIKKyNpbmNsdWRlICJjYXRhbG9nL3BnX2F1
dGhpZC5oIgorI2luY2x1ZGUgImNhdGFsb2cvY2F0YWxvZy5oIgorI2luY2x1ZGUgImxpYnBxL2F1
dGgtdmFsaWRhdGUuaCIKKyNpbmNsdWRlICJsaWJwcS9saWJwcS1iZS5oIgorI2luY2x1ZGUgImxp
YnBxL29hdXRoLmgiCisjaW5jbHVkZSAibWlzY2FkbWluLmgiCisjaW5jbHVkZSAic3RvcmFnZS9s
bWdyLmgiCisjaW5jbHVkZSAidXRpbHMvc3lzY2FjaGUuaCIKKyNpbmNsdWRlICJ1dGlscy90aW1l
c3RhbXAuaCIKKworLyogRnVuY3Rpb24gZGVjbGFyYXRpb25zIGZvciBpbnRlcm5hbCB1c2UgKi8K
K3N0YXRpYyBib29sIHZhbGlkYXRlX3Bhc3N3b3JkX2NyZWRlbnRpYWxzKHZvaWQpOworc3RhdGlj
IGJvb2wgdmFsaWRhdGVfb2F1dGhfY3JlZGVudGlhbHModm9pZCk7CisKKy8qIEZ1bmN0aW9uIHBy
b3RvdHlwZXMgKi8KK3ZvaWQgSW5pdGlhbGl6ZVZhbGlkYXRpb25NZXRob2RzKHZvaWQpOworCisv
KgorICogSW5pdGlhbGl6ZSB2YWxpZGF0aW9uIG1ldGhvZHMKKyAqLwordm9pZAorSW5pdGlhbGl6
ZVZhbGlkYXRpb25NZXRob2RzKHZvaWQpCit7CisJLyogUmVnaXN0ZXIgYWxsIHRoZSB2YWxpZGF0
aW9uIG1ldGhvZHMgKi8KKwlSZWdpc3RlckNyZWRlbnRpYWxWYWxpZGF0b3IoQ1ZUX1BBU1NXT1JE
LCB2YWxpZGF0ZV9wYXNzd29yZF9jcmVkZW50aWFscyk7CisJUmVnaXN0ZXJDcmVkZW50aWFsVmFs
aWRhdG9yKENWVF9PQVVUSCwgdmFsaWRhdGVfb2F1dGhfY3JlZGVudGlhbHMpOworfQorCisvKgor
ICogVmFsaWRhdGUgcGFzc3dvcmQgY3JlZGVudGlhbHMgYnkgY2hlY2tpbmcgcm9sdmFsaWR1bnRp
bAorICogUmV0dXJucyB0cnVlIGlmIGNyZWRlbnRpYWxzIGFyZSBzdGlsbCB2YWxpZCwgZmFsc2Ug
aWYgdGhleSBoYXZlIGV4cGlyZWQuCisgKi8KK3N0YXRpYyBib29sCit2YWxpZGF0ZV9wYXNzd29y
ZF9jcmVkZW50aWFscyh2b2lkKQoreworCUhlYXBUdXBsZSAgIHR1cGxlID0gTlVMTDsKKwlEYXR1
bSAgICAgICByb2x2YWxpZHVudGlsX2RhdHVtOworCWJvb2wgICAgICAgIHZhbGlkdW50aWxfbnVs
bDsKKwlUaW1lc3RhbXBUeiB2YWxpZF91bnRpbCA9IDA7CisJVGltZXN0YW1wVHogY3VycmVudF90
aW1lOworCU9pZCAgICAgICAgIHVzZXJpZDsKKwlib29sICAgICAgICByZXN1bHQgPSBmYWxzZTsK
KworCXVzZXJpZCA9IEdldFNlc3Npb25Vc2VySWQoKTsKKworCS8qCisJICogVHJ5IHRvIHRha2Ug
QWNjZXNzU2hhcmVMb2NrIG9uIHBnX2F1dGhpZCB0byBwcmV2ZW50IGNvbmN1cnJlbnQgbW9kaWZp
Y2F0aW9ucworCSAqIGZyb20gaW50ZXJmZXJpbmcgd2l0aCBvdXIgdmFsaWRhdGlvbi4gVXNlIGNv
bmRpdGlvbmFsIGFjcXVpc2l0aW9uIHRvIGF2b2lkCisJICogaW5kZWZpbml0ZSB3YWl0aW5nIGR1
cmluZyBjcmVkZW50aWFsIHZhbGlkYXRpb24uCisJICovCisJaWYgKCFDb25kaXRpb25hbExvY2tS
ZWxhdGlvbk9pZChBdXRoSWRSZWxhdGlvbklkLCBBY2Nlc3NTaGFyZUxvY2spKQorCXsKKwkJLyoK
KwkJICogQ291bGQgbm90IGFjcXVpcmUgbG9jayBpbW1lZGlhdGVseSwgd2hpY2ggbGlrZWx5IG1l
YW5zIGFub3RoZXIgc2Vzc2lvbgorCQkgKiBpcyBtb2RpZnlpbmcgdXNlciBkYXRhLiBGb3IgY3Jl
ZGVudGlhbCB2YWxpZGF0aW9uLCBpdCdzIGJldHRlciB0bworCQkgKiBjb25zaWRlciBjcmVkZW50
aWFscyB2YWxpZCBhbmQgcmV0cnkgbGF0ZXIgdGhhbiB0byBibG9jayBpbmRlZmluaXRlbHkuCisJ
CSAqLworCQllbG9nKExPRywgImNyZWRlbnRpYWwgdmFsaWRhdGlvbjogY291bGQgbm90IGFjcXVp
cmUgbG9jayBvbiBwZ19hdXRoaWQgaW1tZWRpYXRlbHksIHdpbGwgcmV0cnkgbGF0ZXIiKTsKKwkJ
cmV0dXJuIHRydWU7IC8qIENvbnNpZGVyIHZhbGlkICovCisJfQorCisJUEdfVFJZKCk7CisJewor
CQl0dXBsZSA9IFNlYXJjaFN5c0NhY2hlMShBVVRIT0lELCBPYmplY3RJZEdldERhdHVtKHVzZXJp
ZCkpOworCisJCWlmIChIZWFwVHVwbGVJc1ZhbGlkKHR1cGxlKSkKKwkJeworCQkJLyogR2V0IHRo
ZSBleHBpcmF0aW9uIHRpbWUgY29sdW1uICovCisJCQlyb2x2YWxpZHVudGlsX2RhdHVtID0gU3lz
Q2FjaGVHZXRBdHRyKEFVVEhPSUQsIHR1cGxlLAorCQkJCQkJCQkJCQkJICBBbnVtX3BnX2F1dGhp
ZF9yb2x2YWxpZHVudGlsLAorCQkJCQkJCQkJCQkJICAmdmFsaWR1bnRpbF9udWxsKTsKKwkJCWlm
ICghdmFsaWR1bnRpbF9udWxsKQorCQkJeworCQkJCXZhbGlkX3VudGlsID0gRGF0dW1HZXRUaW1l
c3RhbXBUeihyb2x2YWxpZHVudGlsX2RhdHVtKTsKKwkJCQljdXJyZW50X3RpbWUgPSBHZXRDdXJy
ZW50VGltZXN0YW1wKCk7CisKKwkJCQlyZXN1bHQgPSAhKHZhbGlkX3VudGlsIDwgY3VycmVudF90
aW1lKTsKKwkJCX0KKwkJCWVsc2UKKwkJCQlyZXN1bHQgPSB0cnVlOworCisJCQlSZWxlYXNlU3lz
Q2FjaGUodHVwbGUpOworCQkJdHVwbGUgPSBOVUxMOworCQl9CisJfQorCVBHX0NBVENIKCk7CisJ
eworCQlpZiAodHVwbGUgIT0gTlVMTCkKKwkJCVJlbGVhc2VTeXNDYWNoZSh0dXBsZSk7CisKKwkJ
VW5sb2NrUmVsYXRpb25PaWQoQXV0aElkUmVsYXRpb25JZCwgQWNjZXNzU2hhcmVMb2NrKTsKKwkJ
UEdfUkVfVEhST1coKTsKKwl9CisJUEdfRU5EX1RSWSgpOworCisJLyogUmVsZWFzZSB0aGUgcmVs
YXRpb24gbG9jayAqLworCVVubG9ja1JlbGF0aW9uT2lkKEF1dGhJZFJlbGF0aW9uSWQsIEFjY2Vz
c1NoYXJlTG9jayk7CisKKwlyZXR1cm4gcmVzdWx0OworfQorCisvKgorICogQ2hlY2sgaWYgYW4g
T0F1dGggdG9rZW4gaGFzIGV4cGlyZWQuCisgKgorICogUmV0dXJucyB0cnVlIGlmIHRoZSB0b2tl
biBpcyBzdGlsbCB2YWxpZCwgZmFsc2UgaWYgaXQgaGFzIGV4cGlyZWQuCisgKgorICogQ2FsbHMg
d3JhcHBlciBDaGVja09BdXRoVmFsaWRhdG9yRXhwaXJhdGlvbigpIGZ1bmN0aW9uCisgKiB0byB2
ZXJpZnkgdGhhdCB0aGUgdG9rZW4gaGFzbid0IGV4cGlyZWQuCisgKi8KK3N0YXRpYyBib29sCit2
YWxpZGF0ZV9vYXV0aF9jcmVkZW50aWFscyh2b2lkKQoreworCS8qIENhbGwgdGhlIHZhbGlkYXRv
cidzIGV4cGlyZV9jYiB0byBjaGVjayB0b2tlbiBleHBpcmF0aW9uICovCisJaWYgKCFDaGVja09B
dXRoVmFsaWRhdG9yRXhwaXJhdGlvbigpKQorCQlyZXR1cm4gZmFsc2U7CisKKwlyZXR1cm4gdHJ1
ZTsKK30KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2xpYnBxL2F1dGgtdmFsaWRhdGUuYyBiL3Ny
Yy9iYWNrZW5kL2xpYnBxL2F1dGgtdmFsaWRhdGUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl
eCAwMDAwMDAwMDAwMC4uODJjNDc1ZjZkZjAKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvYmFja2Vu
ZC9saWJwcS9hdXRoLXZhbGlkYXRlLmMKQEAgLTAsMCArMSwyNDQgQEAKKy8qLS0tLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LS0tLQorKgorKiBhdXRoLXZhbGlkYXRlLmMKKyogICAgICBJbXBsZW1lbnRhdGlvbiBvZiBhdXRo
ZW50aWNhdGlvbiBjcmVkZW50aWFsIHZhbGlkYXRpb24KKyoKKyogVGhpcyBtb2R1bGUgcHJvdmlk
ZXMgYSBtZWNoYW5pc20gZm9yIHZhbGlkYXRpbmcgY3JlZGVudGlhbHMgZHVyaW5nCisqIGFuIGFj
dGl2ZSBQb3N0Z3JlU1FMIHNlc3Npb24uCisqCisqIFBvcnRpb25zIENvcHlyaWdodCAoYykgMTk5
Ni0yMDI2LCBQb3N0Z3JlU1FMIEdsb2JhbCBEZXZlbG9wbWVudCBHcm91cAorKiBQb3J0aW9ucyBD
b3B5cmlnaHQgKGMpIDE5OTQsIFJlZ2VudHMgb2YgdGhlIFVuaXZlcnNpdHkgb2YgQ2FsaWZvcm5p
YQorKgorKiBJREVOVElGSUNBVElPTgorKiAgICAgIHNyYy9iYWNrZW5kL2xpYnBxL2F1dGgtdmFs
aWRhdGUuYworKgorKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyovCisjaW5jbHVkZSAicG9zdGdyZXMuaCIK
KworI2luY2x1ZGUgImFjY2Vzcy94YWN0LmgiCisjaW5jbHVkZSAiYWNjZXNzL3hsb2cuaCIKKyNp
bmNsdWRlICJsaWJwcS9hdXRoLmgiCisjaW5jbHVkZSAibGlicHEvbGlicHEtYmUuaCIKKyNpbmNs
dWRlICJsaWJwcS9hdXRoLXZhbGlkYXRlLmgiCisjaW5jbHVkZSAibGlicHEvYXV0aC12YWxpZGF0
ZS1tZXRob2RzLmgiCisjaW5jbHVkZSAibWlzY2FkbWluLmgiCisjaW5jbHVkZSAicG9zdG1hc3Rl
ci9wb3N0bWFzdGVyLmgiCisjaW5jbHVkZSAic3RvcmFnZS9pcGMuaCIKKyNpbmNsdWRlICJ0Y29w
L3Rjb3Bwcm90LmgiCisjaW5jbHVkZSAidXRpbHMvZWxvZy5oIgorI2luY2x1ZGUgInV0aWxzL2d1
Yy5oIgorI2luY2x1ZGUgInV0aWxzL3RpbWVzdGFtcC5oIgorI2luY2x1ZGUgInV0aWxzL3RpbWVv
dXQuaCIKKworLyogR1VDIHZhcmlhYmxlcyAqLworYm9vbAkJY3JlZGVudGlhbF92YWxpZGF0aW9u
X2VuYWJsZWQ7CitpbnQJCQljcmVkZW50aWFsX3ZhbGlkYXRpb25faW50ZXJ2YWw7CisKKy8qIFJl
Z2lzdGVyZWQgY3JlZGVudGlhbCB2YWxpZGF0b3JzICovCitzdGF0aWMgQ3JlZGVudGlhbFZhbGlk
YXRpb25DYWxsYmFjayB2YWxpZGF0b3JzW0NWVF9DT1VOVF07CisKKy8qCisgKiBDb252ZXJ0IFVz
ZXJBdXRoIGVudW0gdG8gQ3JlZGVudGlhbFZhbGlkYXRpb25UeXBlIGZvciB2YWxpZGF0b3Igc2Vs
ZWN0aW9uCisgKi8KK3N0YXRpYyBDcmVkZW50aWFsVmFsaWRhdGlvblR5cGUKK1VzZXJBdXRoVG9W
YWxpZGF0aW9uVHlwZShVc2VyQXV0aCBhdXRoX21ldGhvZCkKK3sKKwlzd2l0Y2ggKGF1dGhfbWV0
aG9kKQorCXsKKwkJY2FzZSB1YVBhc3N3b3JkOgorCQljYXNlIHVhTUQ1OgorCQljYXNlIHVhU0NS
QU06CisJCS8qIEFsbCBwYXNzd29yZC1iYXNlZCBtZXRob2RzIHVzZSB0aGUgcGFzc3dvcmQgdmFs
aWRhdG9yICovCisJCQlyZXR1cm4gQ1ZUX1BBU1NXT1JEOworCQljYXNlIHVhT0F1dGg6CisJCQly
ZXR1cm4gQ1ZUX09BVVRIOworCQlkZWZhdWx0OgorCQkJLyogTm8gc3BlY2lmaWMgdmFsaWRhdG9y
IGZvciBvdGhlciBhdXRoIG1ldGhvZHMgKi8KKwkJCXJldHVybiBDVlRfQ09VTlQ7ICAvKiBJbnZh
bGlkIHZhbHVlICovCisJfQorfQorCisvKgorICogUHJvY2VzcyBjcmVkZW50aWFsIHZhbGlkYXRp
b24KKyAqLwordm9pZAorUHJvY2Vzc0NyZWRlbnRpYWxWYWxpZGF0aW9uKHZvaWQpCit7CisJLyog
U2tpcCB2YWxpZGF0aW9uIGR1cmluZyBpbml0aWFsaXphdGlvbiwgYm9vdHN0cmFwLCBhdXRoZW50
aWNhdGlvbiBvciBjb25uZWN0aW9uIHNldHVwICovCisJaWYgKENsaWVudEF1dGhJblByb2dyZXNz
IHx8IElzSW5pdFByb2Nlc3NpbmdNb2RlKCkgfHwgSXNCb290c3RyYXBQcm9jZXNzaW5nTW9kZSgp
KQorCQlyZXR1cm47CisKKwkvKiBDaGVjayBjcmVkZW50aWFscyBpZiB2YWxpZGF0aW9uIGlzIGVu
YWJsZWQgKi8KKwlpZiAoY3JlZGVudGlhbF92YWxpZGF0aW9uX2VuYWJsZWQgJiYgTXlDbGllbnRD
b25uZWN0aW9uSW5mby5hdXRobl9pZCAhPSBOVUxMKQorCXsKKwkJQ3JlZGVudGlhbFZhbGlkYXRp
b25TdGF0dXMgc3RhdHVzOworCQlVc2VyQXV0aAlhdXRoX21ldGhvZCA9IE15Q2xpZW50Q29ubmVj
dGlvbkluZm8uYXV0aF9tZXRob2Q7CisKKwkJc3RhdHVzID0gQ2hlY2tDcmVkZW50aWFsVmFsaWRp
dHkoKTsKKworCQlzd2l0Y2ggKHN0YXR1cykKKwkJeworCQkJY2FzZSBDVlNfVkFMSUQ6CisJCQkJ
LyogQ3JlZGVudGlhbHMgYXJlIHZhbGlkLCBjb250aW51ZSAqLworCQkJCWJyZWFrOworCisJCQlj
YXNlIENWU19FWFBJUkVEOgorCQkJCWVsb2coTE9HLCAiY3JlZGVudGlhbCB2YWxpZGF0aW9uOiBj
cmVkZW50aWFscyBleHBpcmVkIGZvciBhdXRoX21ldGhvZD0lZCIsCisJCQkJCSAoaW50KSBhdXRo
X21ldGhvZCk7CisJCQkJZXJlcG9ydChGQVRBTCwKKwkJCQkJCShlcnJjb2RlKEVSUkNPREVfSU5W
QUxJRF9BVVRIT1JJWkFUSU9OX1NQRUNJRklDQVRJT04pLAorCQkJCQkJIGVycm1zZygic2Vzc2lv
biBjcmVkZW50aWFscyBoYXZlIGV4cGlyZWQiKSwKKwkJCQkJCSBlcnJoaW50KCJQbGVhc2UgcmVj
b25uZWN0IHRvIGVzdGFibGlzaCBhIG5ldyBhdXRoZW50aWNhdGVkIHNlc3Npb24iKSkpOworCQkJ
CWJyZWFrOworCisJCQljYXNlIENWU19FUlJPUjoKKwkJCQllbG9nKExPRywgImNyZWRlbnRpYWwg
dmFsaWRhdGlvbjogZXJyb3IgY2hlY2tpbmcgY3JlZGVudGlhbHMgZm9yIGF1dGhfbWV0aG9kPSVk
IiwKKwkJCQkJIChpbnQpIGF1dGhfbWV0aG9kKTsKKwkJCQllcmVwb3J0KFdBUk5JTkcsCisJCQkJ
CQkoZXJyY29kZShFUlJDT0RFX0lOVkFMSURfQVVUSE9SSVpBVElPTl9TUEVDSUZJQ0FUSU9OKSwK
KwkJCQkJCSBlcnJtc2coImVycm9yIGNoZWNraW5nIGNyZWRlbnRpYWwgdmFsaWRpdHkiKSwKKwkJ
CQkJCSBlcnJoaW50KCJDcmVkZW50aWFsIHZhbGlkYXRpb24gd2lsbCBiZSByZXRyaWVkIGF0IHRo
ZSBuZXh0IGludGVydmFsIikpKTsKKwkJCQlicmVhazsKKwkJCX0KKwl9Cit9CisKKy8qCisgKiBJ
bml0aWFsaXplIGNyZWRlbnRpYWwgdmFsaWRhdGlvbiBzeXN0ZW0gQ2FsbGVkIGZyb20gSW5pdFBv
c3RncmVzIGFmdGVyCisgKiBhdXRoZW50aWNhdGlvbiBjb21wbGV0ZXMKKyAqLwordm9pZAorSW5p
dGlhbGl6ZUNyZWRlbnRpYWxWYWxpZGF0aW9uKHZvaWQpCit7CisJaW50CQkJaTsKKworCS8qIERl
ZmluZSBHVUMgdmFyaWFibGVzICovCisJRGVmaW5lQ3VzdG9tQm9vbFZhcmlhYmxlKCJjcmVkZW50
aWFsX3ZhbGlkYXRpb24uZW5hYmxlZCIsCisJCQkJCQkJICJFbmFibGUgcGVyaW9kaWMgY3JlZGVu
dGlhbCB2YWxpZGF0aW9uLiIsCisJCQkJCQkJIE5VTEwsCisJCQkJCQkJICZjcmVkZW50aWFsX3Zh
bGlkYXRpb25fZW5hYmxlZCwKKwkJCQkJCQkgZmFsc2UsCisJCQkJCQkJIFBHQ19TVVNFVCwKKwkJ
CQkJCQkgMCwKKwkJCQkJCQkgTlVMTCwKKwkJCQkJCQkgTlVMTCwKKwkJCQkJCQkgTlVMTCk7CisK
KwlEZWZpbmVDdXN0b21JbnRWYXJpYWJsZSgiY3JlZGVudGlhbF92YWxpZGF0aW9uLmludGVydmFs
IiwKKwkJCQkJCQkiQ3JlZGVudGlhbCB2YWxpZGF0aW9uIGludGVydmFsIGluIG1pbnV0ZXMuIiwK
KwkJCQkJCQlOVUxMLAorCQkJCQkJCSZjcmVkZW50aWFsX3ZhbGlkYXRpb25faW50ZXJ2YWwsCisJ
CQkJCQkJMSwJLyogZGVmYXVsdDogMSBtaW51dGUgKi8KKwkJCQkJCQkxLAkvKiBtaW46IDEgbWlu
dXRlICovCisJCQkJCQkJNjAsCS8qIG1heDogNjAgbWludXRlcyAqLworCQkJCQkJCVBHQ19TVVNF
VCwKKwkJCQkJCQlHVUNfVU5JVF9NSU4sCisJCQkJCQkJTlVMTCwKKwkJCQkJCQlOVUxMLAorCQkJ
CQkJCU5VTEwpOworCisJLyogSW5pdGlhbGl6ZSB2YWxpZGF0b3IgY2FsbGJhY2tzIHRvIE5VTEwg
Ki8KKwlmb3IgKGkgPSAwOyBpIDwgQ1ZUX0NPVU5UOyBpKyspCisJCXZhbGlkYXRvcnNbaV0gPSBO
VUxMOworCisJLyogSW5pdGlhbGl6ZSBhbmQgcmVnaXN0ZXIgYWxsIHZhbGlkYXRpb24gbWV0aG9k
cyAqLworCUluaXRpYWxpemVWYWxpZGF0aW9uTWV0aG9kcygpOworfQorCisvKgorICogUmVnaXN0
ZXIgYSB2YWxpZGF0b3IgY2FsbGJhY2sgZm9yIGEgc3BlY2lmaWMgYXV0aGVudGljYXRpb24gbWV0
aG9kCisgKi8KK3ZvaWQKK1JlZ2lzdGVyQ3JlZGVudGlhbFZhbGlkYXRvcihDcmVkZW50aWFsVmFs
aWRhdGlvblR5cGUgbWV0aG9kX3R5cGUsIENyZWRlbnRpYWxWYWxpZGF0aW9uQ2FsbGJhY2sgdmFs
aWRhdG9yKQoreworCWlmIChtZXRob2RfdHlwZSA8IDAgfHwgbWV0aG9kX3R5cGUgPj0gQ1ZUX0NP
VU5UKQorCQllcmVwb3J0KEVSUk9SLAorCQkJCShlcnJjb2RlKEVSUkNPREVfSU5WQUxJRF9QQVJB
TUVURVJfVkFMVUUpLAorCQkJCSBlcnJtc2coImludmFsaWQgdmFsaWRhdGlvbiBtZXRob2QgdHlw
ZTogJWQiLCBtZXRob2RfdHlwZSkpKTsKKworCXZhbGlkYXRvcnNbbWV0aG9kX3R5cGVdID0gdmFs
aWRhdG9yOworfQorCisvKgorICogQ2hlY2sgY3JlZGVudGlhbCB2YWxpZGl0eSB1c2luZyB0aGUg
YXBwcm9wcmlhdGUgdmFsaWRhdG9yCisgKi8KK0NyZWRlbnRpYWxWYWxpZGF0aW9uU3RhdHVzCitD
aGVja0NyZWRlbnRpYWxWYWxpZGl0eSh2b2lkKQoreworCUNyZWRlbnRpYWxWYWxpZGF0aW9uQ2Fs
bGJhY2sgdmFsaWRhdG9yID0gTlVMTDsKKwlDcmVkZW50aWFsVmFsaWRhdGlvblN0YXR1cyBzdGF0
dXM7CisKKwkvKgorCSAqIFNraXAgdmFsaWRhdGlvbiBmb3I6CisJICogLSBEdXJpbmcgc2h1dGRv
d24gb3IgcmVjb3ZlcnkKKwkgKiAtIE5vbi1jbGllbnQgYmFja2VuZHMgKGFueSBwcm9jZXNzIG5v
dCBzZXJ2aW5nIGEgY2xpZW50IGNvbm5lY3Rpb24pCisJICogLSBBdXRvVmFjdXVtIHByb2Nlc3Nl
cyAobGF1bmNoZXIgYW5kIHdvcmtlcnMpCisJICogLSBCYWNrZ3JvdW5kIHdvcmtlciBwcm9jZXNz
ZXMKKwkgKiAtIEF1dGhlbnRpY2F0aW9uIGlzIGluIHByb2dyZXNzCisJICovCisJaWYgKHByb2Nf
ZXhpdF9pbnByb2dyZXNzIHx8CisJCVJlY292ZXJ5SW5Qcm9ncmVzcygpIHx8CisJCSFJc0V4dGVy
bmFsQ29ubmVjdGlvbkJhY2tlbmQoTXlCYWNrZW5kVHlwZSkgfHwKKwkJQW1BdXRvVmFjdXVtTGF1
bmNoZXJQcm9jZXNzKCkgfHwKKwkJQW1BdXRvVmFjdXVtV29ya2VyUHJvY2VzcygpIHx8CisJCUFt
QmFja2dyb3VuZFdvcmtlclByb2Nlc3MoKSB8fAorCQlDbGllbnRBdXRoSW5Qcm9ncmVzcykKKwkJ
cmV0dXJuIENWU19WQUxJRDsKKwkvKgorCSAqIFVzZSB0aGUgc2Vzc2lvbidzIGF1dGhlbnRpY2F0
aW9uIG1ldGhvZCBmcm9tIE15Q2xpZW50Q29ubmVjdGlvbkluZm8KKwkgKiB0byBzZWxlY3QgdGhl
IGFwcHJvcHJpYXRlIHZhbGlkYXRvci4KKwkgKi8KKwlpZiAoTXlDbGllbnRDb25uZWN0aW9uSW5m
by5hdXRobl9pZCAhPSBOVUxMKQorCXsKKwkJQ3JlZGVudGlhbFZhbGlkYXRpb25UeXBlIHZhbGlk
YXRpb25fdHlwZTsKKworCQl2YWxpZGF0aW9uX3R5cGUgPSBVc2VyQXV0aFRvVmFsaWRhdGlvblR5
cGUoTXlDbGllbnRDb25uZWN0aW9uSW5mby5hdXRoX21ldGhvZCk7CisKKwkJLyoKKwkJICogSWYg
d2UgaGF2ZSBhIHZhbGlkIHZhbGlkYXRpb24gdHlwZSwgZ2V0IHRoZSBjb3JyZXNwb25kaW5nCisJ
CSAqIHZhbGlkYXRvcgorCQkgKi8KKwkJaWYgKHZhbGlkYXRpb25fdHlwZSA8IENWVF9DT1VOVCkK
KwkJCXZhbGlkYXRvciA9IHZhbGlkYXRvcnNbdmFsaWRhdGlvbl90eXBlXTsKKworCX0KKworCS8q
CisJICogSWYgbm8gdmFsaWRhdG9yIGZvdW5kIGZvciB0aGUgY3VycmVudCBhdXRoIG1ldGhvZCBv
ciBubworCSAqIGF1dGhlbnRpY2F0ZWQgc2Vzc2lvbiwgc2tpcCB2YWxpZGF0aW9uIGFuZCBjb25z
aWRlciBjcmVkZW50aWFscworCSAqIHZhbGlkCisJICovCisJaWYgKHZhbGlkYXRvciA9PSBOVUxM
IHx8ICFNeUNsaWVudENvbm5lY3Rpb25JbmZvLmF1dGhuX2lkKQorCQkJcmV0dXJuIENWU19WQUxJ
RDsKKworCS8qIENhbGwgdGhlIHZhbGlkYXRvciBhbmQgaW50ZXJwcmV0IHJlc3VsdCAqLworCVBH
X1RSWSgpOworCXsKKwkJYm9vbAkJcmVzdWx0OworCisJCWVsb2coREVCVUcxLCAiY3JlZGVudGlh
bCB2YWxpZGF0aW9uOiBjYWxsaW5nIHZhbGlkYXRvciBmb3IgYXV0aF9tZXRob2Q9JWQiLAorCQkJ
IChpbnQpIE15Q2xpZW50Q29ubmVjdGlvbkluZm8uYXV0aF9tZXRob2QpOworCisJCXJlc3VsdCA9
IHZhbGlkYXRvcigpOworCisJCWlmICghcmVzdWx0KQorCQl7CisJCQllbG9nKERFQlVHMSwgImNy
ZWRlbnRpYWwgdmFsaWRhdGlvbjogY3JlZGVudGlhbHMgZXhwaXJlZCIpOworCQkJc3RhdHVzID0g
Q1ZTX0VYUElSRUQ7CS8qIFZhbGlkYXRvciByZXBvcnRzIGNyZWRlbnRpYWxzIGV4cGlyZWQgKi8K
KwkJfQorCQllbHNlCisJCQlzdGF0dXMgPSBDVlNfVkFMSUQ7CisKKwkJcmV0dXJuIHN0YXR1czsK
Kwl9CisJUEdfQ0FUQ0goKTsKKwl7CisJCS8qIEVycm9yIGR1cmluZyB2YWxpZGF0aW9uICovCisJ
CWVsb2coREVCVUcxLCAiY3JlZGVudGlhbCB2YWxpZGF0aW9uOiBlcnJvciBkdXJpbmcgdmFsaWRh
dGlvbiIpOworCisJCUZsdXNoRXJyb3JTdGF0ZSgpOworCQlyZXR1cm4gQ1ZTX0VSUk9SOworCX0K
KwlQR19FTkRfVFJZKCk7Cit9CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9saWJwcS9tZXNvbi5i
dWlsZCBiL3NyYy9iYWNrZW5kL2xpYnBxL21lc29uLmJ1aWxkCmluZGV4IGVlMzM3Y2Y0MmNjLi42
MDhkOWUxMGViMCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvbGlicHEvbWVzb24uYnVpbGQKKysr
IGIvc3JjL2JhY2tlbmQvbGlicHEvbWVzb24uYnVpbGQKQEAgLTQsNiArNCw4IEBAIGJhY2tlbmRf
c291cmNlcyArPSBmaWxlcygKICAgJ2F1dGgtb2F1dGguYycsCiAgICdhdXRoLXNhc2wuYycsCiAg
ICdhdXRoLXNjcmFtLmMnLAorICAnYXV0aC12YWxpZGF0ZS1tZXRob2RzLmMnLAorICAnYXV0aC12
YWxpZGF0ZS5jJywKICAgJ2F1dGguYycsCiAgICdiZS1mc3N0dWJzLmMnLAogICAnYmUtc2VjdXJl
LWNvbW1vbi5jJywKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3Rjb3AvcG9zdGdyZXMuYyBiL3Ny
Yy9iYWNrZW5kL3Rjb3AvcG9zdGdyZXMuYwppbmRleCBkMDFhMDlkZDBjNC4uNzMwNzY2MGU4NWEg
MTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3Rjb3AvcG9zdGdyZXMuYworKysgYi9zcmMvYmFja2Vu
ZC90Y29wL3Bvc3RncmVzLmMKQEAgLTQ0LDYgKzQ0LDcgQEAKICNpbmNsdWRlICJsaWJwcS9saWJw
cS5oIgogI2luY2x1ZGUgImxpYnBxL3BxZm9ybWF0LmgiCiAjaW5jbHVkZSAibGlicHEvcHFzaWdu
YWwuaCIKKyNpbmNsdWRlICJsaWJwcS9hdXRoLXZhbGlkYXRlLmgiCiAjaW5jbHVkZSAibWIvcGdf
d2NoYXIuaCIKICNpbmNsdWRlICJtYi9zdHJpbmdpbmZvX21iLmgiCiAjaW5jbHVkZSAibWlzY2Fk
bWluLmgiCkBAIC05Nyw2ICs5OCw0OSBAQCBib29sCQlMb2dfZGlzY29ubmVjdGlvbnMgPSBmYWxz
ZTsKIAogaW50CQkJbG9nX3N0YXRlbWVudCA9IExPR1NUTVRfTk9ORTsKIAorCisKKy8qCisgKiBG
dW5jdGlvbiB0aGF0IHBlcmZvcm1zIGNyZWRlbnRpYWwgdmFsaWRhdGlvbiB3aGVuIG5lZWRlZAor
ICogVXNlcyBhIHRpbWUtYmFzZWQgYXBwcm9hY2ggdG8gcGVyaW9kaWNhbGx5IHZhbGlkYXRlIGNy
ZWRlbnRpYWxzCisgKiBkdXJpbmcgbm9ybWFsIG9wZXJhdGlvbiwgc2tpcHBpbmcgdmFsaWRhdGlv
biBpbiBib290c3RyYXBwaW5nLgorICovCitzdGF0aWMgdm9pZAorQ2hlY2tBbmRFeGVjdXRlQ3Jl
ZGVudGlhbFZhbGlkYXRpb24odm9pZCkKK3sKKwlUaW1lc3RhbXBUeiBub3c7CisJVGltZXN0YW1w
VHogZGlmZjsKKworCS8qIEZhc3QgZWFybHkgcmV0dXJucyBmb3IgYWxsIGNhc2VzIHdoZXJlIHdl
IHNob3VsZCBza2lwIHZhbGlkYXRpb24gKi8KKwlpZiAoSXNJbml0UHJvY2Vzc2luZ01vZGUoKSB8
fCBJc0Jvb3RzdHJhcFByb2Nlc3NpbmdNb2RlKCkpCisJCXJldHVybjsKKworCS8qIEdldCB0aGUg
Y3VycmVudCB0aW1lICovCisJbm93ID0gR2V0Q3VycmVudFRpbWVzdGFtcCgpOworCisJLyogVXNl
IGRpcmVjdCB0aW1lc3RhbXAgY29tcGFyaXNvbiBmb3IgYmV0dGVyIHBlcmZvcm1hbmNlICovCisJ
aWYgKExhc3RDcmVkZW50aWFsVmFsaWRhdGlvblRpbWUgIT0gMCkKKwl7CisJCWludDY0IGludGVy
dmFsX3VzOworCisJCWRpZmYgPSBub3cgLSBMYXN0Q3JlZGVudGlhbFZhbGlkYXRpb25UaW1lOwor
CQlpbnRlcnZhbF91cyA9IChpbnQ2NCkgY3JlZGVudGlhbF92YWxpZGF0aW9uX2ludGVydmFsICog
NjAgKiBJTlQ2NENPTlNUKDEwMDAwMDApOyAvKiBtaW51dGVzIHRvIG1pY3Jvc2Vjb25kcyAqLwor
CisJCS8qIEV4aXQgZWFybHkgaWYgbm90IGVub3VnaCB0aW1lIGhhcyBwYXNzZWQgKi8KKwkJaWYg
KGRpZmYgPCBpbnRlcnZhbF91cykKKwkJCXJldHVybjsKKwl9CisKKwkvKiBQcm9jZXNzIGNyZWRl
bnRpYWwgdmFsaWRhdGlvbiAqLworCVByb2Nlc3NDcmVkZW50aWFsVmFsaWRhdGlvbigpOworCisJ
LyogVXBkYXRlIHRoZSBsYXN0IHZhbGlkYXRpb24gdGltZSAqLworCUxhc3RDcmVkZW50aWFsVmFs
aWRhdGlvblRpbWUgPSBub3c7CisKKwkvKiBPbmx5IGxvZyBhdCBERUJVRyBsZXZlbCB0byByZWR1
Y2Ugbm9pc2UgKi8KKwllbG9nKERFQlVHMSwgIkNyZWRlbnRpYWwgdmFsaWRhdGlvbiBjb21wbGV0
ZWQgc3VjY2Vzc2Z1bGx5Iik7Cit9CisKIC8qIHdhaXQgTiBzZWNvbmRzIHRvIGFsbG93IGF0dGFj
aCBmcm9tIGEgZGVidWdnZXIgKi8KIGludAkJCVBvc3RBdXRoRGVsYXkgPSAwOwogCkBAIC0xMDQ5
LDYgKzEwOTMsMTAgQEAgZXhlY19zaW1wbGVfcXVlcnkoY29uc3QgY2hhciAqcXVlcnlfc3RyaW5n
KQogCSAqLwogCXN0YXJ0X3hhY3RfY29tbWFuZCgpOwogCisJLyogQ2hlY2sgYW5kIHBvdGVudGlh
bGx5IGV4ZWN1dGUgY3JlZGVudGlhbCB2YWxpZGF0aW9uIHVzaW5nIHRpbWUtYmFzZWQgYXBwcm9h
Y2ggKi8KKwlpZiAoY3JlZGVudGlhbF92YWxpZGF0aW9uX2VuYWJsZWQgJiYgY3JlZGVudGlhbF92
YWxpZGF0aW9uX2ludGVydmFsID4gMCAmJiBJc05vcm1hbFByb2Nlc3NpbmdNb2RlKCkpCisJCUNo
ZWNrQW5kRXhlY3V0ZUNyZWRlbnRpYWxWYWxpZGF0aW9uKCk7CisKIAkvKgogCSAqIFphcCBhbnkg
cHJlLWV4aXN0aW5nIHVubmFtZWQgc3RhdGVtZW50LiAgKFdoaWxlIG5vdCBzdHJpY3RseSBuZWNl
c3NhcnksCiAJICogaXQgc2VlbXMgYmVzdCB0byBkZWZpbmUgc2ltcGxlLVF1ZXJ5IG1vZGUgYXMg
aWYgaXQgdXNlZCB0aGUgdW5uYW1lZApAQCAtMTQzMCw2ICsxNDc4LDEwIEBAIGV4ZWNfcGFyc2Vf
bWVzc2FnZShjb25zdCBjaGFyICpxdWVyeV9zdHJpbmcsCS8qIHN0cmluZyB0byBleGVjdXRlICov
CiAJICovCiAJc3RhcnRfeGFjdF9jb21tYW5kKCk7CiAKKwkvKiBDaGVjayBhbmQgcG90ZW50aWFs
bHkgZXhlY3V0ZSBjcmVkZW50aWFsIHZhbGlkYXRpb24gZm9yIGV4dGVuZGVkIHByb3RvY29sICov
CisJaWYgKGNyZWRlbnRpYWxfdmFsaWRhdGlvbl9lbmFibGVkICYmIGNyZWRlbnRpYWxfdmFsaWRh
dGlvbl9pbnRlcnZhbCA+IDAgJiYgSXNOb3JtYWxQcm9jZXNzaW5nTW9kZSgpKQorCQlDaGVja0Fu
ZEV4ZWN1dGVDcmVkZW50aWFsVmFsaWRhdGlvbigpOworCiAJLyoKIAkgKiBTd2l0Y2ggdG8gYXBw
cm9wcmlhdGUgY29udGV4dCBmb3IgY29uc3RydWN0aW5nIHBhcnNldHJlZXMuCiAJICoKQEAgLTE3
MDUsNiArMTc1NywxMCBAQCBleGVjX2JpbmRfbWVzc2FnZShTdHJpbmdJbmZvIGlucHV0X21lc3Nh
Z2UpCiAJICovCiAJc3RhcnRfeGFjdF9jb21tYW5kKCk7CiAKKwkvKiBDaGVjayBhbmQgcG90ZW50
aWFsbHkgZXhlY3V0ZSBjcmVkZW50aWFsIHZhbGlkYXRpb24gZm9yIGV4dGVuZGVkIHByb3RvY29s
ICovCisJaWYgKGNyZWRlbnRpYWxfdmFsaWRhdGlvbl9lbmFibGVkICYmIGNyZWRlbnRpYWxfdmFs
aWRhdGlvbl9pbnRlcnZhbCA+IDAgJiYgSXNOb3JtYWxQcm9jZXNzaW5nTW9kZSgpKQorCQlDaGVj
a0FuZEV4ZWN1dGVDcmVkZW50aWFsVmFsaWRhdGlvbigpOworCiAJLyogU3dpdGNoIGJhY2sgdG8g
bWVzc2FnZSBjb250ZXh0ICovCiAJTWVtb3J5Q29udGV4dFN3aXRjaFRvKE1lc3NhZ2VDb250ZXh0
KTsKIApAQCAtMjIxNyw2ICsyMjczLDEwIEBAIGV4ZWNfZXhlY3V0ZV9tZXNzYWdlKGNvbnN0IGNo
YXIgKnBvcnRhbF9uYW1lLCBsb25nIG1heF9yb3dzKQogCSAqLwogCXN0YXJ0X3hhY3RfY29tbWFu
ZCgpOwogCisJLyogQ2hlY2sgYW5kIHBvdGVudGlhbGx5IGV4ZWN1dGUgY3JlZGVudGlhbCB2YWxp
ZGF0aW9uIGZvciBleHRlbmRlZCBwcm90b2NvbCAqLworCWlmIChjcmVkZW50aWFsX3ZhbGlkYXRp
b25fZW5hYmxlZCAmJiBjcmVkZW50aWFsX3ZhbGlkYXRpb25faW50ZXJ2YWwgPiAwICYmIElzTm9y
bWFsUHJvY2Vzc2luZ01vZGUoKSkKKwkJQ2hlY2tBbmRFeGVjdXRlQ3JlZGVudGlhbFZhbGlkYXRp
b24oKTsKKwogCS8qCiAJICogSWYgd2UgcmUtaXNzdWUgYW4gRXhlY3V0ZSBwcm90b2NvbCByZXF1
ZXN0IGFnYWluc3QgYW4gZXhpc3RpbmcgcG9ydGFsLAogCSAqIHRoZW4gd2UgYXJlIG9ubHkgZmV0
Y2hpbmcgbW9yZSByb3dzIHJhdGhlciB0aGFuIGNvbXBsZXRlbHkgcmUtZXhlY3V0aW5nCkBAIC0y
NjM1LDYgKzI2OTUsMTAgQEAgZXhlY19kZXNjcmliZV9zdGF0ZW1lbnRfbWVzc2FnZShjb25zdCBj
aGFyICpzdG10X25hbWUpCiAJICovCiAJc3RhcnRfeGFjdF9jb21tYW5kKCk7CiAKKwkvKiBDaGVj
ayBhbmQgcG90ZW50aWFsbHkgZXhlY3V0ZSBjcmVkZW50aWFsIHZhbGlkYXRpb24gZm9yIGV4dGVu
ZGVkIHByb3RvY29sICovCisJaWYgKGNyZWRlbnRpYWxfdmFsaWRhdGlvbl9lbmFibGVkICYmIGNy
ZWRlbnRpYWxfdmFsaWRhdGlvbl9pbnRlcnZhbCA+IDAgJiYgSXNOb3JtYWxQcm9jZXNzaW5nTW9k
ZSgpKQorCQlDaGVja0FuZEV4ZWN1dGVDcmVkZW50aWFsVmFsaWRhdGlvbigpOworCiAJLyogU3dp
dGNoIGJhY2sgdG8gbWVzc2FnZSBjb250ZXh0ICovCiAJTWVtb3J5Q29udGV4dFN3aXRjaFRvKE1l
c3NhZ2VDb250ZXh0KTsKIApAQCAtMjcyNyw2ICsyNzkxLDEwIEBAIGV4ZWNfZGVzY3JpYmVfcG9y
dGFsX21lc3NhZ2UoY29uc3QgY2hhciAqcG9ydGFsX25hbWUpCiAJICovCiAJc3RhcnRfeGFjdF9j
b21tYW5kKCk7CiAKKwkvKiBDaGVjayBhbmQgcG90ZW50aWFsbHkgZXhlY3V0ZSBjcmVkZW50aWFs
IHZhbGlkYXRpb24gZm9yIGV4dGVuZGVkIHByb3RvY29sICovCisJaWYgKGNyZWRlbnRpYWxfdmFs
aWRhdGlvbl9lbmFibGVkICYmIGNyZWRlbnRpYWxfdmFsaWRhdGlvbl9pbnRlcnZhbCA+IDAgJiYg
SXNOb3JtYWxQcm9jZXNzaW5nTW9kZSgpKQorCQlDaGVja0FuZEV4ZWN1dGVDcmVkZW50aWFsVmFs
aWRhdGlvbigpOworCiAJLyogU3dpdGNoIGJhY2sgdG8gbWVzc2FnZSBjb250ZXh0ICovCiAJTWVt
b3J5Q29udGV4dFN3aXRjaFRvKE1lc3NhZ2VDb250ZXh0KTsKIApkaWZmIC0tZ2l0IGEvc3JjL2Jh
Y2tlbmQvdXRpbHMvaW5pdC9nbG9iYWxzLmMgYi9zcmMvYmFja2VuZC91dGlscy9pbml0L2dsb2Jh
bHMuYwppbmRleCAzNmFkNzA4YjM2MC4uNDViZWI3MWVmMjIgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNr
ZW5kL3V0aWxzL2luaXQvZ2xvYmFscy5jCisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL2luaXQvZ2xv
YmFscy5jCkBAIC0zNCw2ICszNCw3IEBAIHZvbGF0aWxlIHNpZ19hdG9taWNfdCBRdWVyeUNhbmNl
bFBlbmRpbmcgPSBmYWxzZTsKIHZvbGF0aWxlIHNpZ19hdG9taWNfdCBQcm9jRGllUGVuZGluZyA9
IGZhbHNlOwogdm9sYXRpbGUgc2lnX2F0b21pY190IENoZWNrQ2xpZW50Q29ubmVjdGlvblBlbmRp
bmcgPSBmYWxzZTsKIHZvbGF0aWxlIHNpZ19hdG9taWNfdCBDbGllbnRDb25uZWN0aW9uTG9zdCA9
IGZhbHNlOworVGltZXN0YW1wVHogTGFzdENyZWRlbnRpYWxWYWxpZGF0aW9uVGltZSA9IDA7CiB2
b2xhdGlsZSBzaWdfYXRvbWljX3QgSWRsZUluVHJhbnNhY3Rpb25TZXNzaW9uVGltZW91dFBlbmRp
bmcgPSBmYWxzZTsKIHZvbGF0aWxlIHNpZ19hdG9taWNfdCBUcmFuc2FjdGlvblRpbWVvdXRQZW5k
aW5nID0gZmFsc2U7CiB2b2xhdGlsZSBzaWdfYXRvbWljX3QgSWRsZVNlc3Npb25UaW1lb3V0UGVu
ZGluZyA9IGZhbHNlOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvdXRpbHMvaW5pdC9wb3N0aW5p
dC5jIGIvc3JjL2JhY2tlbmQvdXRpbHMvaW5pdC9wb3N0aW5pdC5jCmluZGV4IGI1OWUwODYwNWNj
Li4xMzhmZDQ0MDYwMCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvaW5pdC9wb3N0aW5p
dC5jCisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL2luaXQvcG9zdGluaXQuYwpAQCAtMzQsNiArMzQs
NyBAQAogI2luY2x1ZGUgImNhdGFsb2cvcGdfZGJfcm9sZV9zZXR0aW5nLmgiCiAjaW5jbHVkZSAi
Y2F0YWxvZy9wZ190YWJsZXNwYWNlLmgiCiAjaW5jbHVkZSAibGlicHEvYXV0aC5oIgorI2luY2x1
ZGUgImxpYnBxL2F1dGgtdmFsaWRhdGUuaCIKICNpbmNsdWRlICJsaWJwcS9saWJwcS1iZS5oIgog
I2luY2x1ZGUgIm1iL3BnX3djaGFyLmgiCiAjaW5jbHVkZSAibWlzY2FkbWluLmgiCkBAIC0xMjI2
LDYgKzEyMjcsOSBAQCBJbml0UG9zdGdyZXMoY29uc3QgY2hhciAqaW5fZGJuYW1lLCBPaWQgZGJv
aWQsCiAJLyogSW5pdGlhbGl6ZSB0aGlzIGJhY2tlbmQncyBzZXNzaW9uIHN0YXRlLiAqLwogCUlu
aXRpYWxpemVTZXNzaW9uKCk7CiAKKwkvKiBJbml0aWFsaXplIGNyZWRlbnRpYWwgdmFsaWRhdGlv
biBzeXN0ZW0gKi8KKwlJbml0aWFsaXplQ3JlZGVudGlhbFZhbGlkYXRpb24oKTsKKwogCS8qCiAJ
ICogSWYgdGhpcyBpcyBhbiBpbnRlcmFjdGl2ZSBzZXNzaW9uLCBsb2FkIGFueSBsaWJyYXJpZXMg
dGhhdCBzaG91bGQgYmUKIAkgKiBwcmVsb2FkZWQgYXQgYmFja2VuZCBzdGFydC4gIFNpbmNlIHRo
b3NlIGFyZSBkZXRlcm1pbmVkIGJ5IEdVQ3MsIHRoaXMKQEAgLTE0NDAsNiArMTQ0NCw3IEBAIENs
aWVudENoZWNrVGltZW91dEhhbmRsZXIodm9pZCkKIAlTZXRMYXRjaChNeUxhdGNoKTsKIH0KIAor
CiAvKgogICogUmV0dXJucyB0cnVlIGlmIGF0IGxlYXN0IG9uZSByb2xlIGlzIGRlZmluZWQgaW4g
dGhpcyBkYXRhYmFzZSBjbHVzdGVyLgogICovCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9saWJw
cS9hdXRoLXZhbGlkYXRlLW1ldGhvZHMuaCBiL3NyYy9pbmNsdWRlL2xpYnBxL2F1dGgtdmFsaWRh
dGUtbWV0aG9kcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi40MjAx
ODNhMWM3ZAotLS0gL2Rldi9udWxsCisrKyBiL3NyYy9pbmNsdWRlL2xpYnBxL2F1dGgtdmFsaWRh
dGUtbWV0aG9kcy5oCkBAIC0wLDAgKzEsMjUgQEAKKy8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICoKKyAq
IGF1dGgtdmFsaWRhdGUtbWV0aG9kcy5oCisgKiAgICAgIEludGVyZmFjZSBmb3IgYXV0aGVudGlj
YXRpb24gY3JlZGVudGlhbCB2YWxpZGF0aW9uIG1ldGhvZHMKKyAqCisgKiBUaGlzIGZpbGUgcHJv
dmlkZXMgZGVjbGFyYXRpb25zIGZvciB2YXJpb3VzIGNyZWRlbnRpYWwgdmFsaWRhdGlvbiBtZXRo
b2RzCisgKiB1c2VkIHdpdGggdGhlIGNyZWRlbnRpYWwgdmFsaWRhdGlvbiBzeXN0ZW0uCisgKgor
ICogUG9ydGlvbnMgQ29weXJpZ2h0IChjKSAxOTk2LTIwMjYsIFBvc3RncmVTUUwgR2xvYmFsIERl
dmVsb3BtZW50IEdyb3VwCisgKiBQb3J0aW9ucyBDb3B5cmlnaHQgKGMpIDE5OTQsIFJlZ2VudHMg
b2YgdGhlIFVuaXZlcnNpdHkgb2YgQ2FsaWZvcm5pYQorICoKKyAqIHNyYy9pbmNsdWRlL2xpYnBx
L2F1dGgtdmFsaWRhdGUtbWV0aG9kcy5oCisgKgorICotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgKi8KKyNp
Zm5kZWYgQVVUSF9WQUxJREFURV9NRVRIT0RTX0gKKyNkZWZpbmUgQVVUSF9WQUxJREFURV9NRVRI
T0RTX0gKKworI2luY2x1ZGUgImxpYnBxL2xpYnBxLWJlLmgiCisjaW5jbHVkZSAidXRpbHMvdGlt
ZXN0YW1wLmgiCisKKy8qIEluaXRpYWxpemUgYWxsIHZhbGlkYXRpb24gbWV0aG9kcyAqLworZXh0
ZXJuIHZvaWQgSW5pdGlhbGl6ZVZhbGlkYXRpb25NZXRob2RzKHZvaWQpOworCisjZW5kaWYgICAg
ICAgICAgICAgICAgICAgICAgICAgIC8qIEFVVEhfVkFMSURBVEVfTUVUSE9EU19IICovCmRpZmYg
LS1naXQgYS9zcmMvaW5jbHVkZS9saWJwcS9hdXRoLXZhbGlkYXRlLmggYi9zcmMvaW5jbHVkZS9s
aWJwcS9hdXRoLXZhbGlkYXRlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw
MDAuLjUyYjE3OTUyNzQ0Ci0tLSAvZGV2L251bGwKKysrIGIvc3JjL2luY2x1ZGUvbGlicHEvYXV0
aC12YWxpZGF0ZS5oCkBAIC0wLDAgKzEsNjEgQEAKKy8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICoKKyAq
IGF1dGgtdmFsaWRhdGUuaAorICoJICBJbnRlcmZhY2UgZm9yIGF1dGhlbnRpY2F0aW9uIGNyZWRl
bnRpYWwgdmFsaWRhdGlvbgorICoKKyAqIFRoaXMgZmlsZSBwcm92aWRlcyBhIGNvbW1vbiBpbnRl
cmZhY2UgZm9yIHZhbGlkYXRpbmcgY3JlZGVudGlhbHMKKyAqIGR1cmluZyBhbiBhY3RpdmUgUG9z
dGdyZVNRTCBzZXNzaW9uLgorICoKKyAqIFBvcnRpb25zIENvcHlyaWdodCAoYykgMTk5Ni0yMDI2
LCBQb3N0Z3JlU1FMIEdsb2JhbCBEZXZlbG9wbWVudCBHcm91cAorICogUG9ydGlvbnMgQ29weXJp
Z2h0IChjKSAxOTk0LCBSZWdlbnRzIG9mIHRoZSBVbml2ZXJzaXR5IG9mIENhbGlmb3JuaWEKKyAq
CisgKiBzcmMvaW5jbHVkZS9saWJwcS9hdXRoLXZhbGlkYXRlLmgKKyAqCisgKi0tLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LS0tLS0KKyAqLworI2lmbmRlZiBBVVRIX1ZBTElEQVRFX0gKKyNkZWZpbmUgQVVUSF9WQUxJREFU
RV9ICisKKyNpbmNsdWRlICJsaWJwcS9saWJwcS1iZS5oIgorI2luY2x1ZGUgImxpYnBxL3Byb3Rv
Y29sLmgiCisjaW5jbHVkZSAicG9zdG1hc3Rlci9wb3N0bWFzdGVyLmgiCisjaW5jbHVkZSAidXRp
bHMvZ3VjLmgiCisjaW5jbHVkZSAidXRpbHMvdGltZW91dC5oIgorCisvKiBEZWZpbmUgY3JlZGVu
dGlhbCB2YWxpZGF0aW9uIG1ldGhvZCB0eXBlcyBhcyBhbiBlbnVtICovCit0eXBlZGVmIGVudW0g
Q3JlZGVudGlhbFZhbGlkYXRpb25UeXBlCit7CisJQ1ZUX1BBU1NXT1JEID0gMCwgICAgICAgICAg
LyogQWxsIHBhc3N3b3JkLWJhc2VkIG1ldGhvZHMgKG1kNSwgc2NyYW0sIGV0YykgKi8KKwlDVlRf
T0FVVEgsICAgICAgICAgICAgICAgICAvKiBPQXV0aCBiZWFyZXIgdG9rZW4gYXV0aGVudGljYXRp
b24gKi8KKwlDVlRfQ09VTlQgICAgICAgICAgICAgICAgICAvKiBUb3RhbCBudW1iZXIgb2YgY3Jl
ZGVudGlhbCB2YWxpZGF0aW9uIHR5cGVzICovCit9IENyZWRlbnRpYWxWYWxpZGF0aW9uVHlwZTsK
KworLyogUHJvY2VzcyBjcmVkZW50aWFsIHZhbGlkYXRpb24gKi8KK2V4dGVybiB2b2lkIFByb2Nl
c3NDcmVkZW50aWFsVmFsaWRhdGlvbih2b2lkKTsKKworLyogR1VDIHZhcmlhYmxlcyAqLworZXh0
ZXJuIFBHRExMSU1QT1JUIGJvb2wgY3JlZGVudGlhbF92YWxpZGF0aW9uX2VuYWJsZWQ7CitleHRl
cm4gUEdETExJTVBPUlQgaW50IGNyZWRlbnRpYWxfdmFsaWRhdGlvbl9pbnRlcnZhbDsKKworLyog
Q29tbW9uIGNyZWRlbnRpYWwgdmFsaWRhdGlvbiBjYWxsYmFjayBwcm90b3R5cGUgKi8KK3R5cGVk
ZWYgYm9vbCAoKkNyZWRlbnRpYWxWYWxpZGF0aW9uQ2FsbGJhY2spICh2b2lkKTsKKworLyogQ3Jl
ZGVudGlhbCB2YWxpZGF0aW9uIHN0YXR1cyAqLwordHlwZWRlZiBlbnVtIENyZWRlbnRpYWxWYWxp
ZGF0aW9uU3RhdHVzCit7CisJQ1ZTX1ZBTElELAkJCQkJLyogQ3JlZGVudGlhbHMgYXJlIHZhbGlk
ICovCisJQ1ZTX0VYUElSRUQsCQkJCS8qIENyZWRlbnRpYWxzIGhhdmUgZXhwaXJlZCAqLworCUNW
U19FUlJPUgkJCQkJLyogRXJyb3IgZHVyaW5nIHZhbGlkYXRpb24gKi8KK30gQ3JlZGVudGlhbFZh
bGlkYXRpb25TdGF0dXM7CisKKy8qIEluaXRpYWxpemUgY3JlZGVudGlhbCB2YWxpZGF0aW9uIHN5
c3RlbSAqLworZXh0ZXJuIHZvaWQgSW5pdGlhbGl6ZUNyZWRlbnRpYWxWYWxpZGF0aW9uKHZvaWQp
OworCisvKiBSZWdpc3RlciBhIHZhbGlkYXRpb24gY2FsbGJhY2sgZm9yIGEgc3BlY2lmaWMgYXV0
aGVudGljYXRpb24gbWV0aG9kICovCitleHRlcm4gdm9pZCBSZWdpc3RlckNyZWRlbnRpYWxWYWxp
ZGF0b3IoQ3JlZGVudGlhbFZhbGlkYXRpb25UeXBlIG1ldGhvZF90eXBlLAorCQkJCQkJCQkJCUNy
ZWRlbnRpYWxWYWxpZGF0aW9uQ2FsbGJhY2sgdmFsaWRhdG9yKTsKKworLyogQ2hlY2sgY3JlZGVu
dGlhbCB2YWxpZGl0eSAqLworZXh0ZXJuIENyZWRlbnRpYWxWYWxpZGF0aW9uU3RhdHVzIENoZWNr
Q3JlZGVudGlhbFZhbGlkaXR5KHZvaWQpOworCisjZW5kaWYJCQkJCQkJLyogQVVUSF9WQUxJREFU
RV9IICovCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9saWJwcS9vYXV0aC5oIGIvc3JjL2luY2x1
ZGUvbGlicHEvb2F1dGguaAppbmRleCA0YTgyMmU5YTFmMi4uYmJiOTI5MDYyNmMgMTAwNjQ0Ci0t
LSBhL3NyYy9pbmNsdWRlL2xpYnBxL29hdXRoLmgKKysrIGIvc3JjL2luY2x1ZGUvbGlicHEvb2F1
dGguaApAQCAtNjQsNiArNjQsNyBAQCB0eXBlZGVmIHZvaWQgKCpWYWxpZGF0b3JTaHV0ZG93bkNC
KSAoVmFsaWRhdG9yTW9kdWxlU3RhdGUgKnN0YXRlKTsKIHR5cGVkZWYgYm9vbCAoKlZhbGlkYXRv
clZhbGlkYXRlQ0IpIChjb25zdCBWYWxpZGF0b3JNb2R1bGVTdGF0ZSAqc3RhdGUsCiAJCQkJCQkJ
CQkgY29uc3QgY2hhciAqdG9rZW4sIGNvbnN0IGNoYXIgKnJvbGUsCiAJCQkJCQkJCQkgVmFsaWRh
dG9yTW9kdWxlUmVzdWx0ICpyZXN1bHQpOwordHlwZWRlZiBib29sICgqVmFsaWRhdG9yRXhwaXJl
Q0IpIChjb25zdCBWYWxpZGF0b3JNb2R1bGVTdGF0ZSAqc3RhdGUpOwogCiAvKgogICogSWRlbnRp
ZmllcyB0aGUgY29tcGlsZWQgQUJJIHZlcnNpb24gb2YgdGhlIHZhbGlkYXRvciBtb2R1bGUuIFNp
bmNlIHRoZSBzZXJ2ZXIKQEAgLTgwLDYgKzgxLDcgQEAgdHlwZWRlZiBzdHJ1Y3QgT0F1dGhWYWxp
ZGF0b3JDYWxsYmFja3MKIAlWYWxpZGF0b3JTdGFydHVwQ0Igc3RhcnR1cF9jYjsKIAlWYWxpZGF0
b3JTaHV0ZG93bkNCIHNodXRkb3duX2NiOwogCVZhbGlkYXRvclZhbGlkYXRlQ0IgdmFsaWRhdGVf
Y2I7CisJVmFsaWRhdG9yRXhwaXJlQ0IgZXhwaXJlX2NiOyAgLyogT3B0aW9uYWw6IENoZWNrIHRv
a2VuIGV4cGlyYXRpb24gKi8KIH0gT0F1dGhWYWxpZGF0b3JDYWxsYmFja3M7CiAKIC8qCkBAIC05
OCw0ICsxMDAsOCBAQCBleHRlcm4gUEdETExJTVBPUlQgY29uc3QgcGdfYmVfc2FzbF9tZWNoIHBn
X2JlX29hdXRoX21lY2g7CiAgKi8KIGV4dGVybiBib29sIGNoZWNrX29hdXRoX3ZhbGlkYXRvcihI
YmFMaW5lICpoYmFsaW5lLCBpbnQgZWxldmVsLCBjaGFyICoqZXJyX21zZyk7CiAKKy8qCisgKiBD
aGVjayBPQXV0aCB0b2tlbiBleHBpcmF0aW9uIHVzaW5nIHZhbGlkYXRvcidzIGV4cGlyZV9jYiBp
ZiBhdmFpbGFibGUuCisgKi8KK2Jvb2wgQ2hlY2tPQXV0aFZhbGlkYXRvckV4cGlyYXRpb24odm9p
ZCk7CiAjZW5kaWYJCQkJCQkJLyogUEdfT0FVVEhfSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1
ZGUvbWlzY2FkbWluLmggYi9zcmMvaW5jbHVkZS9taXNjYWRtaW4uaAppbmRleCBmMTZmMzU2NTli
OS4uMzBjM2Q0MGQ0MTggMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL21pc2NhZG1pbi5oCisrKyBi
L3NyYy9pbmNsdWRlL21pc2NhZG1pbi5oCkBAIC05OSw2ICs5OSw3IEBAIGV4dGVybiBQR0RMTElN
UE9SVCB2b2xhdGlsZSBzaWdfYXRvbWljX3QgSWRsZVN0YXRzVXBkYXRlVGltZW91dFBlbmRpbmc7
CiAKIGV4dGVybiBQR0RMTElNUE9SVCB2b2xhdGlsZSBzaWdfYXRvbWljX3QgQ2hlY2tDbGllbnRD
b25uZWN0aW9uUGVuZGluZzsKIGV4dGVybiBQR0RMTElNUE9SVCB2b2xhdGlsZSBzaWdfYXRvbWlj
X3QgQ2xpZW50Q29ubmVjdGlvbkxvc3Q7CitleHRlcm4gUEdETExJTVBPUlQgVGltZXN0YW1wVHog
TGFzdENyZWRlbnRpYWxWYWxpZGF0aW9uVGltZTsKIAogLyogdGhlc2UgYXJlIG1hcmtlZCB2b2xh
dGlsZSBiZWNhdXNlIHRoZXkgYXJlIGV4YW1pbmVkIGJ5IHNpZ25hbCBoYW5kbGVyczogKi8KIGV4
dGVybiBQR0RMTElNUE9SVCB2b2xhdGlsZSB1aW50MzIgSW50ZXJydXB0SG9sZG9mZkNvdW50Owo=
--000000000000823645064d249927--