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.96) (envelope-from ) id 1wi8cn-00029A-2T for pgsql-hackers@arkaria.postgresql.org; Fri, 10 Jul 2026 10:38:30 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1wi8ck-00HKff-1d for pgsql-hackers@arkaria.postgresql.org; Fri, 10 Jul 2026 10:38:27 +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.96) (envelope-from ) id 1wi8cj-00HKfW-32 for pgsql-hackers@lists.postgresql.org; Fri, 10 Jul 2026 10:38:26 +0000 Received: from mail-ed1-x529.google.com ([2a00:1450:4864:20::529]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.98.2) (envelope-from ) id 1wi8ch-0000000017d-3dxj for pgsql-hackers@lists.postgresql.org; Fri, 10 Jul 2026 10:38:25 +0000 Received: by mail-ed1-x529.google.com with SMTP id 4fb4d7f45d1cf-693c51a8a19so1195022a12.3 for ; Fri, 10 Jul 2026 03:38:23 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1783679902; cv=none; d=google.com; s=arc-20260327; b=HsOcsB1W6mNA07barVMkMXQg1XaF09aT5ZjVJiz8qjNXpGKRbpL7Q7g54q0iz3dmU/ K32Xua8WeElwNIcZamOa4QNA5LJjROJUH4N4Ksyx4nvDKjB8Ubj8kCewUAUqyUPZKlU7 roN/jQH8vjE0YHjZcEJh0yEA/wtz/z+spbZk/P+9xJeMGrg1e6nBgmHVGPsg1gbhVIJM 7nwmoUv3C0F9Y/pidP9jKzOG7rdwgJeXiGN74S6Vy/SyEeIcQrEHiHhUPVqvBRHMbyV2 yaLcewZLgkZ8i5j3CtPfMpAuVhAx6qKlh1bHRJYIrwkj65PL6WlA9b7gLn5ueFO+NVcV dO8g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20260327; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:dkim-signature; bh=6RKRzDOLiSGPFAIPEt5z5l2lyaE82blkxoT6Ov058rg=; fh=pbBTIvISdfChRsaUWZVngtLfzSHF64nUsCdCyhvLO54=; b=Pw+GJwfkYc1pmbBdHE/p8A4bkUoRCcVnWCO3lGeJ/8S/5P5eioE7yJ+fMlNMJxVPng QMBzq4pICeQGaOQUdUMTB4w6fkH/QMLpo/5VwMG8Jhy0WuY2ozJMts8s78oTk6V8Y/WP Z0XlypUSwu6pkwEsGx8m9S7p5RlN6rIciY1EJ3sPQx32rJFAKWqHeCmAN4xQlafB1r3r qiQn4SE/fYAo39ZGEtv0ZUWZtKcAC7I2b8eb001KTf8dy+He1jRUs+psM2o+vGYZKvGE 5FR+HbmBVryBiFumGJssCGdRK1Uni/d4yvpb3mg2RXrv3w2YnzSDrFIGv3D4/1CjOV4S 2hsQ==; darn=lists.postgresql.org ARC-Authentication-Results: i=1; mx.google.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=adyen.com; s=google; t=1783679902; x=1784284702; darn=lists.postgresql.org; h=content-type:cc:to:subject:message-id:date:from:in-reply-to :references:mime-version:from:to:cc:subject:date:message-id:reply-to :content-type; bh=6RKRzDOLiSGPFAIPEt5z5l2lyaE82blkxoT6Ov058rg=; b=AuAgKzLMfi+qepJfhHNzzTP1+jRglpeIVR/Ef7L2uii5q3N7ruMFgPSNwcMHRDKxiF mwqTNEzCy9F2B5aSL7w3LLHCmS+xVfaiFZjT662K0I1L+1OWC7OVQ7QCD69XNmKvVmBM rmhw35DxsvUnzF1t7MCpAvNeuYZYA7KHNMUGY= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1783679902; x=1784284702; h=content-type:cc:to:subject:message-id:date:from:in-reply-to :references:mime-version:x-gm-gg:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to:content-type; bh=6RKRzDOLiSGPFAIPEt5z5l2lyaE82blkxoT6Ov058rg=; b=JePzxDbdDNxC+iPtGPfnArsrLspttfsXzhg7v/2XhyGK2il5gzWbAN3SvJdTelPGQV LTH/xZdniXaPJJYMtOHbLSws0qDbN/+lrtbWYRO4tr1WC5HWKziNXijbYDcphrXL+8zD 4H4+OfpE3NNFo0+UilUp6Na4cdmsTSpTlkb1j2Uy408v/YRN7ofbAATY5KHQWZxJFKRm sX42cAWZo+IJnbrF3VJIOhA1W+tDahjxboEhn2EGAGegwnqksN23HqqiKV989TJOAfb3 /e1C+CF8q0fq2NbhdrYXiBHi5NVk3OxlC3EL2l8Qa20YbXT2R28mPSddimzeu/g4hHLm MB9w== X-Gm-Message-State: AOJu0YxCYMPpFk7yE2pocG4D5EGOnBoLy5z2Z+41EigVMMLubV+VLPTN 6VBeNrUBs/NOKmX6c+umTTX79w4jkQFiwl11w2KutgCPYNKbzDRAvq+zNXyk4HIBEs8GoFfTHxf xXLfLtojun/vMXBqGWz64HdF+aVz76r8QRlsMSd3XKg== X-Gm-Gg: AfdE7clpNsOeiYS7cpSMDQRh2tFIa2uxTaRkucJTPpZoY6oJwRrZnjq9JhpMXDwwOCc C3hHUBW5NZ5gmG+oT/4qbqil5GQDFLIvoQ011Z77PolIJbWvJP1NFWr/8I6s+qY2Q7sEypvalRV 5iVMv453et0M9fNxOC1u8tNwzokJmYkgDHnN/IcyDcjmv7iOyhjszHXgqSMA32p0IkIX3+yiLa5 o3h9naAwWB3EwDJt0HGLSWDSVO9zPqHJ/mYet2nNYTPNSXfn2WTAIX9FGB+OQr/9Lb7zmHSF54K 7qdY X-Received: by 2002:a05:6402:51c6:b0:69a:9c13:a2a2 with SMTP id 4fb4d7f45d1cf-69ab44ab465mr4619953a12.41.1783679902102; Fri, 10 Jul 2026 03:38:22 -0700 (PDT) MIME-Version: 1.0 References: In-Reply-To: From: Cagri Biroglu Date: Fri, 10 Jul 2026 12:38:10 +0200 X-Gm-Features: AUfX_myq1czr41mcV--pA9ZU3w40xdjZzWVHa3HEDV7OjlFcnM81vTVAXeKcxfk Message-ID: Subject: Re: Per-table resync for logical replication subscriptions To: Masahiko Sawada , "smithpb2250@gmail.com" Cc: pgsql-hackers@lists.postgresql.org Content-Type: multipart/mixed; boundary="000000000000f56aad06563f56ad" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --000000000000f56aad06563f56ad Content-Type: multipart/alternative; boundary="000000000000f56aa906563f56ab" --000000000000f56aa906563f56ab Content-Type: text/plain; charset="UTF-8" > > Thanks a lot for looking at this. > > Before the point-by-point: one change after getting feedback on this from the sketch in my first mail is that I dropped the WITH (copy_data, truncate) options. For refreshing > a table that is already subscribed, only one combination is useful, so > REFRESH TABLE now always truncates the local copy and re-copies (what > would have been copy_data = true, truncate = true). Without truncating, > the re-copy hits duplicate-key errors or doubles the rows; skipping the > copy leaves the drift in place. So neither other combination is > meaningful, and there is nothing to configure. > > > REFRESH TABLE is better to me. It's more consistent with the existing > > commands such as REFRESH SEQUENCES. > > Great, I've kept REFRESH TABLE. > > > I think it might be a good idea that the REFRESH TABLE command can > > take multiple tables rather than one table. > > Agreed. v2 makes REFRESH TABLE take a comma-separated list: > > ALTER SUBSCRIPTION name REFRESH TABLE t1, t2, ... > > It's all-or-nothing: every named relation is validated (part of the > subscription, not a sequence, exists) before any of them is reset, so a > bad table name aborts the whole command without touching the others. The > listed tables are also truncated together, which lets a set connected by > foreign keys be re-seeded as a unit. > > One note on scope: this doesn't add resource risk over doing one table > at a time, because the re-copy is still performed by tablesync workers > that are capped by max_sync_workers_per_subscription; resetting N tables > just queues them rather than starting N copies at once. > > > Why does the REFRESH TABLE command require for the subscription to be > > disabled while REFRESH PUBLICATIONS doesn't? > > Good question, but I'd actually argue the disabled requirement is a > reasonable design choice here rather than a limitation to remove. > > The reason the two commands differ is that REFRESH PUBLICATION only adds > *new* relations to pg_subscription_rel (in init state), whereas REFRESH > TABLE resets a relation that is already in ready state, and those hit > different caches in the apply worker: > > - The set of not-ready relations is cached (table_states_not_ready in > syncutils.c) and correctly invalidated by the SUBSCRIPTIONRELMAP > syscache callback (InvalidateSyncingRelStates). So after the reset the > apply worker does notice the table is non-ready and does launch a > tablesync worker for it. That part works whether enabled or not. > > - However, whether the apply worker applies incoming changes for a > relation is decided by should_apply_changes_for_rel(), which reads the > per-relation LogicalRepRelMapEntry.state. That state is only refreshed > from the catalog while it is not READY: > > /* relation.c, logicalrep_rel_open() */ > if (entry->state != SUBREL_STATE_READY) > entry->state = GetSubscriptionRelState(...); > > For an already-ready table the entry stays READY, and the relcache > invalidation only clears localrelvalid (rebuilds the attrmap); it does > not reset entry->state. So the running apply worker keeps treating the > table as READY and keeps applying live changes to it, at the same time > as the freshly launched tablesync worker re-copies it, with no handoff > on the sync LSN. In my testing that reliably diverges the table. > > For a newly added table (REFRESH PUBLICATION) there is no stale READY > entry, so the normal init -> datasync -> syncdone -> ready handoff works > without any disable. > > Requiring the subscription to be disabled sidesteps this cleanly. When > you re-enable, a fresh apply worker starts and reads the reset table's > state from the catalog as init, so the same init -> datasync -> syncdone > -> ready handoff kicks in, exactly as for a newly added table. And the > disable only needs to bracket the quick catalog reset, not the re-copy > itself: REFRESH TABLE just truncates and flips the state, and after > ENABLE the tablesync worker does the (possibly long) copy while the > apply worker resumes the other tables as usual, so the pause is short > and scoped to the metadata change, not the data copy. > > Supporting the enabled case would instead mean reaching into the running > apply worker to force it to drop and re-read the cached state of the > reset relation mid-flight. That is doable, but it adds moving parts and > a new invalidation path to get right, for what is a deliberate, > occasional maintenance action where briefly disabling the subscription > does no harm. So my inclination is to keep the disabled requirement here > rather than trade that simplicity away. Happy to reconsider if you think > the enabled case matters enough to justify the extra machinery or i am > missing sth. Regards, > Cagri Biroglu > --000000000000f56aa906563f56ab Content-Type: text/html; charset="UTF-8" Content-Transfer-Encoding: quoted-printable
Thanks a lot for looking at this.= =C2=A0

Before the point-by-point: one change after getting feedback = on this=C2=A0
from the sketch in my = first mail=C2=A0
is that I dropped the WITH (copy_data, truncate) options. For refreshin= g
a table that is already subscribed, only one combination is useful, so=
REFRESH TABLE now always truncates the local copy and re-copies (whatwould have been copy_data =3D true, truncate =3D true). Without truncatin= g,
the re-copy hits duplicate-key errors or doubles the rows; skipping t= he
copy leaves the drift in place. So neither other combination is
me= aningful, and there is nothing to configure.

> REFRESH TABLE is b= etter to me. It's more consistent with the existing
> commands su= ch as REFRESH SEQUENCES.

Great, I've kept REFRESH TABLE.

= > I think it might be a good idea that the REFRESH TABLE command can
= > take multiple tables rather than one table.

Agreed. v2 makes RE= FRESH TABLE take a comma-separated list:

=C2=A0 =C2=A0 ALTER SUBSCRI= PTION name REFRESH TABLE t1, t2, ...

It's all-or-nothing: every = named relation is validated (part of the
subscription, not a sequence, e= xists) before any of them is reset, so a
bad table name aborts the whole= command without touching the others. The
listed tables are also truncat= ed together, which lets a set connected by
foreign keys be re-seeded as = a unit.

One note on scope: this doesn't add resource risk over d= oing one table
at a time, because the re-copy is still performed by tabl= esync workers
that are capped by max_sync_workers_per_subscription; rese= tting N tables
just queues them rather than starting N copies at once.
> Why does the REFRESH TABLE command require for the subscription = to be
> disabled while REFRESH PUBLICATIONS doesn't?

Good = question, but I'd actually argue the disabled requirement is a
reaso= nable design choice here rather than a limitation to remove.

The rea= son the two commands differ is that REFRESH PUBLICATION only adds
*new* = relations to pg_subscription_rel (in init state), whereas REFRESH
TABLE = resets a relation that is already in ready state, and those hit
differen= t caches in the apply worker:

- The set of not-ready relations is ca= ched (table_states_not_ready in
=C2=A0 syncutils.c) and correctly invali= dated by the SUBSCRIPTIONRELMAP
=C2=A0 syscache callback (InvalidateSync= ingRelStates). So after the reset the
=C2=A0 apply worker does notice th= e table is non-ready and does launch a
=C2=A0 tablesync worker for it. T= hat part works whether enabled or not.

- However, whether the apply = worker applies incoming changes for a
=C2=A0 relation is decided by shou= ld_apply_changes_for_rel(), which reads the
=C2=A0 per-relation LogicalR= epRelMapEntry.state. That state is only refreshed
=C2=A0 from the catalo= g while it is not READY:

=C2=A0 =C2=A0 =C2=A0 /* relation.c, logical= rep_rel_open() */
=C2=A0 =C2=A0 =C2=A0 if (entry->state !=3D SUBREL_S= TATE_READY)
=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 entry->state =3D GetSu= bscriptionRelState(...);

=C2=A0 For an already-ready table the entry= stays READY, and the relcache
=C2=A0 invalidation only clears localrelv= alid (rebuilds the attrmap); it does
=C2=A0 not reset entry->state. S= o the running apply worker keeps treating the
=C2=A0 table as READY and = keeps applying live changes to it, at the same time
=C2=A0 as the freshl= y launched tablesync worker re-copies it, with no handoff
=C2=A0 on the = sync LSN. In my testing that reliably diverges the table.

For a newl= y added table (REFRESH PUBLICATION) there is no stale READY
entry, so th= e normal init -> datasync -> syncdone -> ready handoff works
wi= thout any disable.

Requiring the subscription to be disabled sideste= ps this cleanly. When
you re-enable, a fresh apply worker starts and rea= ds the reset table's
state from the catalog as init, so the same ini= t -> datasync -> syncdone
-> ready handoff kicks in, exactly as= for a newly added table. And the
disable only needs to bracket the quic= k catalog reset, not the re-copy
itself: REFRESH TABLE just truncates an= d flips the state, and after
ENABLE the tablesync worker does the (possi= bly long) copy while the
apply worker resumes the other tables as usual,= so the pause is short
and scoped to the metadata change, not the data c= opy.

Supporting the enabled case would instead mean reaching into th= e running
apply worker to force it to drop and re-read the cached state = of the
reset relation mid-flight. That is doable, but it adds moving par= ts and
a new invalidation path to get right, for what is a deliberate,occasional maintenance action where briefly disabling the subscriptiondoes no harm. So my inclination is to keep the disabled requirement hererather than trade that simplicity away. Happy to reconsider if you think<= br>the enabled case matters enough to justify the extra machinery or i am m= issing sth.
<= span style=3D"background-color:transparent">=C2=A0
Regards,
Cagri Biroglu
--000000000000f56aa906563f56ab-- --000000000000f56aad06563f56ad Content-Type: application/octet-stream; name="v2-0001-refresh-table.patch" Content-Disposition: attachment; filename="v2-0001-refresh-table.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mreskbkk0 RnJvbSBmYTgyZjlmMGVjZTAzNDMwNjcxMjczOTA1MDczZjMzNjRlOWVlNmQ0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBjYWdyaWIgPGNhZ3JpLmJpcm9nbHVAYWR5ZW4uY29tPgpEYXRl OiBUdWUsIDcgSnVsIDIwMjYgMTQ6MTc6MTkgKzAyMDAKU3ViamVjdDogW1BBVENIIHYyXSBBZGQg QUxURVIgU1VCU0NSSVBUSU9OIC4uLiBSRUZSRVNIIFRBQkxFIHRvIHJlc3luYyB0YWJsZXMKClJF RlJFU0ggUFVCTElDQVRJT04gb25seSBzdGFydHMgc3luY2luZyB0YWJsZXMgdGhhdCB3ZXJlIG5l d2x5IGFkZGVkIHRvCnRoZSBwdWJsaWNhdGlvbjsgaXQgbmV2ZXIgcmUtY29waWVzIGEgdGFibGUg dGhhdCBpcyBhbHJlYWR5IHBhcnQgb2YgdGhlCnN1YnNjcmlwdGlvbi4gIFRvZGF5IHRoZSBvbmx5 IHdheXMgdG8gcmUtc2VlZCBhbiBhbHJlYWR5LXN1YnNjcmliZWQgdGFibGUKYXJlIHRvIGNodXJu IHB1YmxpY2F0aW9uIG1lbWJlcnNoaXAgKHdoaWNoIGlzIG5vdCBsb2NhbCB0byBvbmUgc3Vic2Ny aWJlcgphbmQgY2FuIGRpc3R1cmIgc2libGluZyBzdWJzY3JpYmVycyBvciBjYXNjYWRlIGRvd25z dHJlYW0pIG9yIHRvIGhhbmQtZWRpdApwZ19zdWJzY3JpcHRpb25fcmVsICh1bnN1cHBvcnRlZCBh bmQgcmFjeSBhZ2FpbnN0IHRoZSBhcHBseSB3b3JrZXIpLgoKQWRkIGEgc3Vic2NyaWJlci1sb2Nh bCBjb21tYW5kOgoKICAgIEFMVEVSIFNVQlNDUklQVElPTiBuYW1lIFJFRlJFU0ggVEFCTEUgdGFi bGVfbmFtZSBbLCAuLi5dCgpJdCB0cnVuY2F0ZXMgdGhlIGxvY2FsIGNvcHkgb2YgZWFjaCBuYW1l ZCB0YWJsZSBhbmQgcmVzZXRzIGl0cyBzdGF0ZSBpbgpwZ19zdWJzY3JpcHRpb25fcmVsIGJhY2sg dG8gaW5pdCBzbyB0aGF0IGEgdGFibGVzeW5jIHdvcmtlciByZS1jb3BpZXMganVzdAp0aG9zZSB0 YWJsZXMsIHJldXNpbmcgdGhlIGV4aXN0aW5nIHRhYmxlIHN5bmNocm9uaXphdGlvbiBtYWNoaW5l cnkuICBBbGwKbmFtZWQgcmVsYXRpb25zIGFyZSB2YWxpZGF0ZWQgYmVmb3JlIGFueSBpcyByZXNl dCwgc28gdGhlIGNvbW1hbmQgaXMKYWxsLW9yLW5vdGhpbmcsIGFuZCB0aGV5IGFyZSB0cnVuY2F0 ZWQgdG9nZXRoZXIgc28gYSBzZXQgY29ubmVjdGVkIGJ5CmZvcmVpZ24ga2V5cyBjYW4gYmUgcmUt c2VlZGVkIGFzIGEgdW5pdC4gIFB1YmxpY2F0aW9uIG1lbWJlcnNoaXAgYW5kIG90aGVyCnRhYmxl cyBhcmUgbGVmdCB1bnRvdWNoZWQuICBUaGlzIG1pcnJvcnMgUkVGUkVTSCBTRVFVRU5DRVMsIHdo aWNoIGxpa2V3aXNlCnJlLXN5bmNocm9uaXplcyBvYmplY3RzIGFscmVhZHkga25vd24gdG8gdGhl IHN1YnNjcmlwdGlvbiByYXRoZXIgdGhhbiBvbmx5CmRpc2NvdmVyaW5nIG5ld2x5IGFkZGVkIG9u ZXMuCgpUaGlzIGZpcnN0IHZlcnNpb24gcmVxdWlyZXMgdGhlIHN1YnNjcmlwdGlvbiB0byBiZSBk aXNhYmxlZCwgd2hpY2ggYXZvaWRzCnJhY2luZyB0aGUgYXBwbHkgd29ya2VyJ3MgY2FjaGVkIHJl bGF0aW9uIHN0YXRlLgoKQSBUQVAgdGVzdCBpcyBpbmNsdWRlZC4KLS0tCiBzcmMvYmFja2VuZC9j b21tYW5kcy9zdWJzY3JpcHRpb25jbWRzLmMgICAgICB8IDE4NyArKysrKysrKysrKysrKysKIHNy Yy9iYWNrZW5kL3BhcnNlci9ncmFtLnkgICAgICAgICAgICAgICAgICAgIHwgIDEwICsKIHNyYy9p bmNsdWRlL25vZGVzL3BhcnNlbm9kZXMuaCAgICAgICAgICAgICAgIHwgICAyICsKIHNyYy90ZXN0 L3N1YnNjcmlwdGlvbi90LzAzOV9yZWZyZXNoX3RhYmxlLnBsIHwgMjI4ICsrKysrKysrKysrKysr KysrKysKIDQgZmlsZXMgY2hhbmdlZCwgNDI3IGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEw MDY0NCBzcmMvdGVzdC9zdWJzY3JpcHRpb24vdC8wMzlfcmVmcmVzaF90YWJsZS5wbAoKZGlmZiAt LWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3N1YnNjcmlwdGlvbmNtZHMuYyBiL3NyYy9iYWNr ZW5kL2NvbW1hbmRzL3N1YnNjcmlwdGlvbmNtZHMuYwppbmRleCA0MjkyZTdmYjhmNC4uZGQ2MDk2 ZDU4NDMgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3N1YnNjcmlwdGlvbmNtZHMu YworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy9zdWJzY3JpcHRpb25jbWRzLmMKQEAgLTE0MDUs NiArMTQwNSwxNzAgQEAgQWx0ZXJTdWJzY3JpcHRpb25fcmVmcmVzaF9zZXEoU3Vic2NyaXB0aW9u ICpzdWIpCiAJUEdfRU5EX1RSWSgpOwogfQogCisvKgorICogUmVzeW5jaHJvbml6ZSBvbmUgb3Ig bW9yZSBhbHJlYWR5LXN1YnNjcmliZWQgdGFibGVzLgorICoKKyAqIFRydW5jYXRlcyB0aGUgbG9j YWwgY29weSBvZiBlYWNoIG5hbWVkIHRhYmxlIGFuZCByZXNldHMgaXRzCisgKiBwZ19zdWJzY3Jp cHRpb25fcmVsIHN0YXRlIGJhY2sgdG8gaW5pdCBzbyB0aGF0LCBvbmNlIHRoZSBzdWJzY3JpcHRp b24gaXMKKyAqIGVuYWJsZWQsIGEgdGFibGVzeW5jIHdvcmtlciByZS1jb3BpZXMganVzdCB0aG9z ZSB0YWJsZXMuICBUaGlzIGlzCisgKiBzdWJzY3JpYmVyLWxvY2FsIGFuZCBkb2VzIG5vdCB0b3Vj aCBwdWJsaWNhdGlvbiBtZW1iZXJzaGlwLCBzbyBzaWJsaW5nCisgKiBzdWJzY3JpYmVycyBhcmUg dW5hZmZlY3RlZC4KKyAqCisgKiBFdmVyeSBuYW1lZCByZWxhdGlvbiBpcyB2YWxpZGF0ZWQgYmVm b3JlIGFueSBvZiB0aGVtIGlzIHJlc2V0LCBzbyB0aGUKKyAqIGNvbW1hbmQgaXMgYWxsLW9yLW5v dGhpbmc6IGEgYmFkIHRhYmxlIG5hbWUgYWJvcnRzIHRoZSB3aG9sZSBjb21tYW5kCisgKiB3aXRo b3V0IHRvdWNoaW5nIHRoZSBvdGhlcnMuICBUaGUgdGFibGVzIGFyZSB0cnVuY2F0ZWQgdG9nZXRo ZXIsIHdoaWNoIGxldHMKKyAqIGEgc2V0IGNvbm5lY3RlZCBieSBmb3JlaWduIGtleXMgYmUgcmUt c2VlZGVkIGFzIGEgdW5pdC4KKyAqCisgKiBUaGUgY2FsbGVyIG11c3QgZW5zdXJlIHRoZSBzdWJz Y3JpcHRpb24gaXMgZGlzYWJsZWQ6IHdpdGggbm8gYXBwbHkgd29ya2VyCisgKiBydW5uaW5nIHRo ZXJlIGlzIG5vIGNhY2hlZCByZWxhdGlvbiBzdGF0ZSB0byBpbnZhbGlkYXRlIGFuZCBubyByYWNl IGFnYWluc3QKKyAqIGEgY29uY3VycmVudGx5IGxhdW5jaGVkIHRhYmxlc3luYyB3b3JrZXIuCisg Ki8KK3N0YXRpYyB2b2lkCitBbHRlclN1YnNjcmlwdGlvbl9yZWZyZXNoX3RhYmxlKFN1YnNjcmlw dGlvbiAqc3ViLCBMaXN0ICpyZWxhdGlvbnMpCit7CisJUmVsYXRpb24JcmVsOworCUxpc3RDZWxs ICAgKmxjOworCUxpc3QJICAgKnJlbGlkcyA9IE5JTDsKKwlMaXN0CSAgICp0cnVuY3JlbHMgPSBO SUw7CisJVHJ1bmNhdGVTdG10ICp0c3RtdDsKKworCS8qCisJICogTG9jayBwZ19zdWJzY3JpcHRp b25fcmVsIHdpdGggQWNjZXNzRXhjbHVzaXZlTG9jaywgbWF0Y2hpbmcKKwkgKiBBbHRlclN1YnNj cmlwdGlvbl9yZWZyZXNoKCksIHNvIHRoZSByZWxhdGlvbiBzdGF0ZXMgY2Fubm90IGNoYW5nZSB1 bmRlcgorCSAqIHVzIGZvciB0aGUgZHVyYXRpb24gb2YgdGhlIGNvbW1hbmQuCisJICovCisJcmVs ID0gdGFibGVfb3BlbihTdWJzY3JpcHRpb25SZWxSZWxhdGlvbklkLCBBY2Nlc3NFeGNsdXNpdmVM b2NrKTsKKworCS8qCisJICogRmlyc3QgcGFzczogdmFsaWRhdGUgZXZlcnkgbmFtZWQgcmVsYXRp b24gYmVmb3JlIGNoYW5naW5nIGFueXRoaW5nLCBzbworCSAqIHRoZSBjb21tYW5kIGlzIGFsbC1v ci1ub3RoaW5nLiAgRHVwbGljYXRlcyBpbiB0aGUgbGlzdCBhcmUgaWdub3JlZC4KKwkgKi8KKwlm b3JlYWNoKGxjLCByZWxhdGlvbnMpCisJeworCQlSYW5nZVZhciAgICpydiA9IGxmaXJzdF9ub2Rl KFJhbmdlVmFyLCBsYyk7CisJCU9pZAkJCXJlbGlkOworCQljaGFyCQlyZWxzdGF0ZTsKKwkJWExv Z1JlY1B0cglyZWxzdGF0ZWxzbjsKKworCQlyZWxpZCA9IFJhbmdlVmFyR2V0UmVsaWQocnYsIEFj Y2Vzc1NoYXJlTG9jaywgZmFsc2UpOworCisJCWlmIChnZXRfcmVsX3JlbGtpbmQocmVsaWQpID09 IFJFTEtJTkRfU0VRVUVOQ0UpCisJCQllcmVwb3J0KEVSUk9SLAorCQkJCQllcnJjb2RlKEVSUkNP REVfV1JPTkdfT0JKRUNUX1RZUEUpLAorCQkJCQllcnJtc2coImNhbm5vdCByZWZyZXNoIHNlcXVl bmNlIFwiJXNcIiBhcyBhIHRhYmxlIiwKKwkJCQkJCSAgIHJ2LT5yZWxuYW1lKSwKKwkJCQkJZXJy aGludCgiVXNlIEFMVEVSIFNVQlNDUklQVElPTiAuLi4gUkVGUkVTSCBTRVFVRU5DRVMgaW5zdGVh ZC4iKSk7CisKKwkJLyogVGhlIHJlbGF0aW9uIG11c3QgYWxyZWFkeSBiZSBwYXJ0IG9mIHRoZSBz dWJzY3JpcHRpb24uICovCisJCXJlbHN0YXRlID0gR2V0U3Vic2NyaXB0aW9uUmVsU3RhdGUoc3Vi LT5vaWQsIHJlbGlkLCAmcmVsc3RhdGVsc24pOworCQlpZiAocmVsc3RhdGUgPT0gU1VCUkVMX1NU QVRFX1VOS05PV04pCisJCQllcmVwb3J0KEVSUk9SLAorCQkJCQllcnJjb2RlKEVSUkNPREVfT0JK RUNUX05PVF9JTl9QUkVSRVFVSVNJVEVfU1RBVEUpLAorCQkJCQllcnJtc2coInRhYmxlIFwiJXNc IiBpcyBub3QgcGFydCBvZiB0aGUgc3Vic2NyaXB0aW9uIFwiJXNcIiIsCisJCQkJCQkgICBydi0+ cmVsbmFtZSwgc3ViLT5uYW1lKSk7CisKKwkJaWYgKGxpc3RfbWVtYmVyX29pZChyZWxpZHMsIHJl bGlkKSkKKwkJCWNvbnRpbnVlOworCisJCXJlbGlkcyA9IGxhcHBlbmRfb2lkKHJlbGlkcywgcmVs aWQpOworCQl0cnVuY3JlbHMgPSBsYXBwZW5kKHRydW5jcmVscywgcnYpOworCX0KKworCS8qCisJ ICogU2Vjb25kIHBhc3M6IHN0b3AgYW55IGxlZnRvdmVyIHRhYmxlc3luYyB3b3JrZXIgZm9yIGVh Y2ggcmVsYXRpb24gYW5kLAorCSAqIGlmIGl0IHdhcyBjYXVnaHQgbWlkLXN5bmMsIGNsZWFuIHVw IGl0cyBvcmlnaW4gYW5kIHB1Ymxpc2hlciBzbG90LgorCSAqLworCWZvcmVhY2hfb2lkKHJlbGlk LCByZWxpZHMpCisJeworCQljaGFyCQlyZWxzdGF0ZTsKKwkJWExvZ1JlY1B0cglyZWxzdGF0ZWxz bjsKKworCQlyZWxzdGF0ZSA9IEdldFN1YnNjcmlwdGlvblJlbFN0YXRlKHN1Yi0+b2lkLCByZWxp ZCwgJnJlbHN0YXRlbHNuKTsKKworCQkvKiBTdG9wIGFueSBsZWZ0b3ZlciB0YWJsZXN5bmMgd29y a2VyIGZvciB0aGlzIHJlbGF0aW9uLiAqLworCQlsb2dpY2FscmVwX3dvcmtlcl9zdG9wKFdPUktF UlRZUEVfVEFCTEVTWU5DLCBzdWItPm9pZCwgcmVsaWQpOworCisJCS8qCisJCSAqIElmIHRoZSBy ZWxhdGlvbiB3YXMgY2F1Z2h0IG1pZC1zeW5jLCBkcm9wIGl0cyB0YWJsZXN5bmMgb3JpZ2luLiAg Rm9yCisJCSAqIFJFQURZIHN0YXRlIHRoZSB0YWJsZXN5bmMgd29ya2VyIGFscmVhZHkgZHJvcHBl ZCBpdCwgc28gbm90aGluZyBpcworCQkgKiBuZWVkZWQgdGhlcmUuICBQYXNzIG1pc3Npbmdfb2sg PSB0cnVlIGFzIHRoZSBvcmlnaW4gbWF5IG5vdCBleGlzdAorCQkgKiB5ZXQuCisJCSAqLworCQlp ZiAocmVsc3RhdGUgIT0gU1VCUkVMX1NUQVRFX1JFQURZKQorCQl7CisJCQljaGFyCQlvcmlnaW5u YW1lW05BTUVEQVRBTEVOXTsKKworCQkJUmVwbGljYXRpb25PcmlnaW5OYW1lRm9yTG9naWNhbFJl cChzdWItPm9pZCwgcmVsaWQsIG9yaWdpbm5hbWUsCisJCQkJCQkJCQkJCSAgIHNpemVvZihvcmln aW5uYW1lKSk7CisJCQlyZXBsb3JpZ2luX2Ryb3BfYnlfbmFtZShvcmlnaW5uYW1lLCB0cnVlLCBm YWxzZSk7CisJCX0KKworCQkvKgorCQkgKiBMaWtld2lzZSBkcm9wIHRoZSB0YWJsZXN5bmMgc2xv dCBvbiB0aGUgcHVibGlzaGVyIGZvciBhIG1pZC1zeW5jCisJCSAqIHJlbGF0aW9uLiAgUkVBRFkv U1lOQ0RPTkUgcmVsYXRpb25zIGhhdmUgbm8gc3VjaCBzbG90LCBzbyB0aGUgY29tbW9uCisJCSAq IGNhc2UgbmVlZHMgbm8gcHVibGlzaGVyIGNvbm5lY3Rpb24gYXQgYWxsLgorCQkgKi8KKwkJaWYg KHJlbHN0YXRlICE9IFNVQlJFTF9TVEFURV9SRUFEWSAmJiByZWxzdGF0ZSAhPSBTVUJSRUxfU1RB VEVfU1lOQ0RPTkUpCisJCXsKKwkJCWNoYXIJCXN5bmNzbG90bmFtZVtOQU1FREFUQUxFTl0gPSB7 MH07CisJCQljaGFyCSAgICplcnIgPSBOVUxMOworCQkJV2FsUmVjZWl2ZXJDb25uICp3cmNvbm47 CisJCQlib29sCQltdXN0X3VzZV9wYXNzd29yZDsKKworCQkJbG9hZF9maWxlKCJsaWJwcXdhbHJl Y2VpdmVyIiwgZmFsc2UpOworCisJCQltdXN0X3VzZV9wYXNzd29yZCA9IHN1Yi0+cGFzc3dvcmRy ZXF1aXJlZCAmJiAhc3ViLT5vd25lcnN1cGVydXNlcjsKKwkJCXdyY29ubiA9IHdhbHJjdl9jb25u ZWN0KHN1Yi0+Y29ubmluZm8sIHRydWUsIHRydWUsIG11c3RfdXNlX3Bhc3N3b3JkLAorCQkJCQkJ CQkJc3ViLT5uYW1lLCAmZXJyKTsKKwkJCWlmICghd3Jjb25uKQorCQkJCWVyZXBvcnQoRVJST1Is CisJCQkJCQllcnJjb2RlKEVSUkNPREVfQ09OTkVDVElPTl9GQUlMVVJFKSwKKwkJCQkJCWVycm1z Zygic3Vic2NyaXB0aW9uIFwiJXNcIiBjb3VsZCBub3QgY29ubmVjdCB0byB0aGUgcHVibGlzaGVy OiAlcyIsCisJCQkJCQkJICAgc3ViLT5uYW1lLCBlcnIpKTsKKworCQkJUEdfVFJZKCk7CisJCQl7 CisJCQkJUmVwbGljYXRpb25TbG90TmFtZUZvclRhYmxlc3luYyhzdWItPm9pZCwgcmVsaWQsIHN5 bmNzbG90bmFtZSwKKwkJCQkJCQkJCQkJCXNpemVvZihzeW5jc2xvdG5hbWUpKTsKKwkJCQlSZXBs aWNhdGlvblNsb3REcm9wQXRQdWJOb2RlKHdyY29ubiwgc3luY3Nsb3RuYW1lLCB0cnVlKTsKKwkJ CX0KKwkJCVBHX0ZJTkFMTFkoKTsKKwkJCXsKKwkJCQl3YWxyY3ZfZGlzY29ubmVjdCh3cmNvbm4p OworCQkJfQorCQkJUEdfRU5EX1RSWSgpOworCQl9CisJfQorCisJLyoKKwkgKiBDbGVhciB0aGUg bG9jYWwgY29waWVzIHNvIHRoZSByZS1jb3B5IHN0YXJ0cyBmcm9tIGVtcHR5LiAgVHJ1bmNhdGlu ZyB0aGUKKwkgKiB0YWJsZXMgdG9nZXRoZXIgbGV0cyBhIHNldCBjb25uZWN0ZWQgYnkgZm9yZWln biBrZXlzIGJlIHJlLXNlZWRlZCBhcyBhCisJICogdW5pdC4KKwkgKi8KKwl0c3RtdCA9IG1ha2VO b2RlKFRydW5jYXRlU3RtdCk7CisJdHN0bXQtPnJlbGF0aW9ucyA9IHRydW5jcmVsczsKKwl0c3Rt dC0+cmVzdGFydF9zZXFzID0gZmFsc2U7CisJdHN0bXQtPmJlaGF2aW9yID0gRFJPUF9SRVNUUklD VDsKKwlFeGVjdXRlVHJ1bmNhdGUodHN0bXQpOworCisJLyoKKwkgKiBSZXNldCBlYWNoIHJlbGF0 aW9uIHRvIGluaXQgc28gdGhhdCBhIHRhYmxlc3luYyB3b3JrZXIgcmUtY29waWVzIGl0IG9uY2UK KwkgKiB0aGUgc3Vic2NyaXB0aW9uIGlzIGVuYWJsZWQuCisJICovCisJZm9yZWFjaF9vaWQocmVs aWQsIHJlbGlkcykKKwl7CisJCVVwZGF0ZVN1YnNjcmlwdGlvblJlbFN0YXRlKHN1Yi0+b2lkLCBy ZWxpZCwgU1VCUkVMX1NUQVRFX0lOSVQsCisJCQkJCQkJCSAgIEludmFsaWRYTG9nUmVjUHRyLCBm YWxzZSk7CisKKwkJZXJlcG9ydChERUJVRzEsCisJCQkJZXJybXNnX2ludGVybmFsKCJ0YWJsZSBc IiVzLiVzXCIgb2Ygc3Vic2NyaXB0aW9uIFwiJXNcIiByZXNldCBmb3IgcmVzeW5jIiwKKwkJCQkJ CQkJZ2V0X25hbWVzcGFjZV9uYW1lKGdldF9yZWxfbmFtZXNwYWNlKHJlbGlkKSksCisJCQkJCQkJ CWdldF9yZWxfbmFtZShyZWxpZCksIHN1Yi0+bmFtZSkpOworCX0KKworCXRhYmxlX2Nsb3NlKHJl bCwgTm9Mb2NrKTsKK30KKwogLyoKICAqIENvbW1vbiBjaGVja3MgZm9yIGFsdGVyaW5nIGZhaWxv dmVyLCB0d29fcGhhc2UsIGFuZCByZXRhaW5fZGVhZF90dXBsZXMKICAqIG9wdGlvbnMuCkBAIC0y Mjk2LDYgKzI0NjAsMjkgQEAgQWx0ZXJTdWJzY3JpcHRpb24oUGFyc2VTdGF0ZSAqcHN0YXRlLCBB bHRlclN1YnNjcmlwdGlvblN0bXQgKnN0bXQsCiAJCQkJYnJlYWs7CiAJCQl9CiAKKwkJY2FzZSBB TFRFUl9TVUJTQ1JJUFRJT05fUkVGUkVTSF9UQUJMRToKKwkJCXsKKwkJCQkvKgorCQkJCSAqIFRo ZSBmaXJzdCB2ZXJzaW9uIHJlcXVpcmVzIHRoZSBzdWJzY3JpcHRpb24gdG8gYmUgZGlzYWJsZWQu CisJCQkJICogV2l0aCBubyBhcHBseSB3b3JrZXIgcnVubmluZyB0aGVyZSBpcyBubyBjYWNoZWQg cmVsYXRpb24KKwkJCQkgKiBzdGF0ZSB0byBpbnZhbGlkYXRlIGFuZCBubyByYWNlIGFnYWluc3Qg YSBjb25jdXJyZW50bHkKKwkJCQkgKiBsYXVuY2hlZCB0YWJsZXN5bmMgd29ya2VyIHdoaWxlIHdl IHJlc2V0IHRoZSByZWxhdGlvbi4KKwkJCQkgKi8KKwkJCQlpZiAoc3ViLT5lbmFibGVkKQorCQkJ CQllcmVwb3J0KEVSUk9SLAorCQkJCQkJCWVycmNvZGUoRVJSQ09ERV9PQkpFQ1RfTk9UX0lOX1BS RVJFUVVJU0lURV9TVEFURSksCisJCQkJCQkJZXJybXNnKCIlcyBpcyBub3QgYWxsb3dlZCBmb3Ig ZW5hYmxlZCBzdWJzY3JpcHRpb25zIiwKKwkJCQkJCQkJICAgIkFMVEVSIFNVQlNDUklQVElPTiAu Li4gUkVGUkVTSCBUQUJMRSIpLAorCQkJCQkJCWVycmhpbnQoIkRpc2FibGUgdGhlIHN1YnNjcmlw dGlvbiB3aXRoIEFMVEVSIFNVQlNDUklQVElPTiAuLi4gRElTQUJMRSBmaXJzdC4iKSk7CisKKwkJ CQlQcmV2ZW50SW5UcmFuc2FjdGlvbkJsb2NrKGlzVG9wTGV2ZWwsCisJCQkJCQkJCQkJICAiQUxU RVIgU1VCU0NSSVBUSU9OIC4uLiBSRUZSRVNIIFRBQkxFIik7CisKKwkJCQlBbHRlclN1YnNjcmlw dGlvbl9yZWZyZXNoX3RhYmxlKHN1Yiwgc3RtdC0+cmVsYXRpb25zKTsKKworCQkJCWJyZWFrOwor CQkJfQorCiAJCWNhc2UgQUxURVJfU1VCU0NSSVBUSU9OX1NLSVA6CiAJCQl7CiAJCQkJLyogQUxU RVIgU1VCU0NSSVBUSU9OIC4uLiBTS0lQIHN1cHBvcnRzIG9ubHkgTFNOIG9wdGlvbiAqLwpkaWZm IC0tZ2l0IGEvc3JjL2JhY2tlbmQvcGFyc2VyL2dyYW0ueSBiL3NyYy9iYWNrZW5kL3BhcnNlci9n cmFtLnkKaW5kZXggZmY0ZTEzODhjNTUuLjgyNzE2YzQ2OTQ3IDEwMDY0NAotLS0gYS9zcmMvYmFj a2VuZC9wYXJzZXIvZ3JhbS55CisrKyBiL3NyYy9iYWNrZW5kL3BhcnNlci9ncmFtLnkKQEAgLTEx NjE3LDYgKzExNjE3LDE2IEBAIEFsdGVyU3Vic2NyaXB0aW9uU3RtdDoKIAkJCQkJbi0+c3VibmFt ZSA9ICQzOwogCQkJCQkkJCA9IChOb2RlICopIG47CiAJCQkJfQorCQkJfCBBTFRFUiBTVUJTQ1JJ UFRJT04gbmFtZSBSRUZSRVNIIFRBQkxFIHF1YWxpZmllZF9uYW1lX2xpc3QKKwkJCQl7CisJCQkJ CUFsdGVyU3Vic2NyaXB0aW9uU3RtdCAqbiA9CisJCQkJCQltYWtlTm9kZShBbHRlclN1YnNjcmlw dGlvblN0bXQpOworCisJCQkJCW4tPmtpbmQgPSBBTFRFUl9TVUJTQ1JJUFRJT05fUkVGUkVTSF9U QUJMRTsKKwkJCQkJbi0+c3VibmFtZSA9ICQzOworCQkJCQluLT5yZWxhdGlvbnMgPSAkNjsKKwkJ CQkJJCQgPSAoTm9kZSAqKSBuOworCQkJCX0KIAkJCXwgQUxURVIgU1VCU0NSSVBUSU9OIG5hbWUg QUREX1AgUFVCTElDQVRJT04gbmFtZV9saXN0IG9wdF9kZWZpbml0aW9uCiAJCQkJewogCQkJCQlB bHRlclN1YnNjcmlwdGlvblN0bXQgKm4gPQpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvbm9kZXMv cGFyc2Vub2Rlcy5oIGIvc3JjL2luY2x1ZGUvbm9kZXMvcGFyc2Vub2Rlcy5oCmluZGV4IGUwMzU1 NjM5OWFiLi5jZmViMDlhYjQxNyAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvbm9kZXMvcGFyc2Vu b2Rlcy5oCisrKyBiL3NyYy9pbmNsdWRlL25vZGVzL3BhcnNlbm9kZXMuaApAQCAtNDU2Niw2ICs0 NTY2LDcgQEAgdHlwZWRlZiBlbnVtIEFsdGVyU3Vic2NyaXB0aW9uVHlwZQogCUFMVEVSX1NVQlND UklQVElPTl9EUk9QX1BVQkxJQ0FUSU9OLAogCUFMVEVSX1NVQlNDUklQVElPTl9SRUZSRVNIX1BV QkxJQ0FUSU9OLAogCUFMVEVSX1NVQlNDUklQVElPTl9SRUZSRVNIX1NFUVVFTkNFUywKKwlBTFRF Ul9TVUJTQ1JJUFRJT05fUkVGUkVTSF9UQUJMRSwKIAlBTFRFUl9TVUJTQ1JJUFRJT05fRU5BQkxF RCwKIAlBTFRFUl9TVUJTQ1JJUFRJT05fU0tJUCwKIH0gQWx0ZXJTdWJzY3JpcHRpb25UeXBlOwpA QCAtNDU3OCw2ICs0NTc5LDcgQEAgdHlwZWRlZiBzdHJ1Y3QgQWx0ZXJTdWJzY3JpcHRpb25TdG10 CiAJY2hhcgkgICAqc2VydmVybmFtZTsJCS8qIFNlcnZlciBuYW1lIG9mIHB1Ymxpc2hlciAqLwog CWNoYXIJICAgKmNvbm5pbmZvOwkJLyogQ29ubmVjdGlvbiBzdHJpbmcgdG8gcHVibGlzaGVyICov CiAJTGlzdAkgICAqcHVibGljYXRpb247CS8qIE9uZSBvciBtb3JlIHB1YmxpY2F0aW9uIHRvIHN1 YnNjcmliZSB0byAqLworCUxpc3QJICAgKnJlbGF0aW9uczsJCS8qIFRhYmxlcyB0byByZXN5bmMg KGZvciBSRUZSRVNIIFRBQkxFKSAqLwogCUxpc3QJICAgKm9wdGlvbnM7CQkvKiBMaXN0IG9mIERl ZkVsZW0gbm9kZXMgKi8KIH0gQWx0ZXJTdWJzY3JpcHRpb25TdG10OwogCmRpZmYgLS1naXQgYS9z cmMvdGVzdC9zdWJzY3JpcHRpb24vdC8wMzlfcmVmcmVzaF90YWJsZS5wbCBiL3NyYy90ZXN0L3N1 YnNjcmlwdGlvbi90LzAzOV9yZWZyZXNoX3RhYmxlLnBsCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwLi5iMDlmMWUxNDliZgotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0 L3N1YnNjcmlwdGlvbi90LzAzOV9yZWZyZXNoX3RhYmxlLnBsCkBAIC0wLDAgKzEsMjI4IEBACisK KyMgQ29weXJpZ2h0IChjKSAyMDIxLTIwMjYsIFBvc3RncmVTUUwgR2xvYmFsIERldmVsb3BtZW50 IEdyb3VwCisKKyMgVGVzdHMgZm9yIEFMVEVSIFNVQlNDUklQVElPTiAuLi4gUkVGUkVTSCBUQUJM RSwgd2hpY2ggcmUtY29waWVzIG9uZSBvciBtb3JlCisjIGFscmVhZHktc3Vic2NyaWJlZCB0YWJs ZXMgb24gdGhlIHN1YnNjcmliZXIgd2l0aG91dCB0b3VjaGluZyBwdWJsaWNhdGlvbgorIyBtZW1i ZXJzaGlwIG9yIG90aGVyIHRhYmxlcy4gIFRoZSBmaXJzdCB2ZXJzaW9uIHJlcXVpcmVzIHRoZSBz dWJzY3JpcHRpb24KKyMgdG8gYmUgZGlzYWJsZWQuCit1c2Ugc3RyaWN0OwordXNlIHdhcm5pbmdz IEZBVEFMID0+ICdhbGwnOwordXNlIFBvc3RncmVTUUw6OlRlc3Q6OkNsdXN0ZXI7Cit1c2UgUG9z dGdyZVNRTDo6VGVzdDo6VXRpbHM7Cit1c2UgVGVzdDo6TW9yZTsKKworIyBJbml0aWFsaXplIHB1 Ymxpc2hlciBhbmQgc3Vic2NyaWJlciBub2RlcworbXkgJG5vZGVfcHVibGlzaGVyID0gUG9zdGdy ZVNRTDo6VGVzdDo6Q2x1c3Rlci0+bmV3KCdwdWJsaXNoZXInKTsKKyRub2RlX3B1Ymxpc2hlci0+ aW5pdChhbGxvd3Nfc3RyZWFtaW5nID0+ICdsb2dpY2FsJyk7Ciskbm9kZV9wdWJsaXNoZXItPnN0 YXJ0OworCitteSAkbm9kZV9zdWJzY3JpYmVyID0gUG9zdGdyZVNRTDo6VGVzdDo6Q2x1c3Rlci0+ bmV3KCdzdWJzY3JpYmVyJyk7Ciskbm9kZV9zdWJzY3JpYmVyLT5pbml0OworJG5vZGVfc3Vic2Ny aWJlci0+YXBwZW5kX2NvbmYoJ3Bvc3RncmVzcWwuY29uZicsCisJIndhbF9yZXRyaWV2ZV9yZXRy eV9pbnRlcnZhbCA9IDFtcyIpOworJG5vZGVfc3Vic2NyaWJlci0+c3RhcnQ7CisKK215ICRwdWJs aXNoZXJfY29ubnN0ciA9ICRub2RlX3B1Ymxpc2hlci0+Y29ubnN0ciAuICcgZGJuYW1lPXBvc3Rn cmVzJzsKKworIyBQcmVleGlzdGluZyBjb250ZW50IG9uIHRoZSBwdWJsaXNoZXI6IHR3byBwdWJs aXNoZWQgdGFibGVzLgorJG5vZGVfcHVibGlzaGVyLT5zYWZlX3BzcWwoCisJJ3Bvc3RncmVzJywg cXEoCisJQ1JFQVRFIFRBQkxFIHRhYl9yZXMgICAoYSBpbnQgcHJpbWFyeSBrZXksIGIgdGV4dCk7 CisJQ1JFQVRFIFRBQkxFIHRhYl9vdGhlciAoYSBpbnQgcHJpbWFyeSBrZXksIGIgdGV4dCk7CisJ SU5TRVJUIElOVE8gdGFiX3JlcyAgIFNFTEVDVCBnLCAncCcgfHwgZyBGUk9NIGdlbmVyYXRlX3Nl cmllcygxLCAxMDApIGc7CisJSU5TRVJUIElOVE8gdGFiX290aGVyIFNFTEVDVCBnLCAncScgfHwg ZyBGUk9NIGdlbmVyYXRlX3NlcmllcygxLCAxMDApIGc7CisJQ1JFQVRFIFBVQkxJQ0FUSU9OIHRh cF9wdWIgRk9SIFRBQkxFIHRhYl9yZXMsIHRhYl9vdGhlcjsKKykpOworCisjIE1hdGNoaW5nIHN0 cnVjdHVyZSBvbiB0aGUgc3Vic2NyaWJlciwgcGx1cyBvYmplY3RzIHVzZWQgZm9yIGVycm9yIGNh c2VzLgorJG5vZGVfc3Vic2NyaWJlci0+c2FmZV9wc3FsKAorCSdwb3N0Z3JlcycsIHFxKAorCUNS RUFURSBUQUJMRSB0YWJfcmVzICAgKGEgaW50IHByaW1hcnkga2V5LCBiIHRleHQpOworCUNSRUFU RSBUQUJMRSB0YWJfb3RoZXIgKGEgaW50IHByaW1hcnkga2V5LCBiIHRleHQpOworCUNSRUFURSBU QUJMRSB0YWJfbG9jYWwgKGEgaW50IHByaW1hcnkga2V5KTsKKwlDUkVBVEUgU0VRVUVOQ0Ugc2Vx X2xvY2FsOworKSk7CisKKyRub2RlX3N1YnNjcmliZXItPnNhZmVfcHNxbCgncG9zdGdyZXMnLAor CSJDUkVBVEUgU1VCU0NSSVBUSU9OIHRhcF9zdWIgQ09OTkVDVElPTiAnJHB1Ymxpc2hlcl9jb25u c3RyJyBQVUJMSUNBVElPTiB0YXBfcHViIgorKTsKKworIyBXYWl0IGZvciBpbml0aWFsIHN5bmMg b2YgYm90aCB0YWJsZXMuCiskbm9kZV9zdWJzY3JpYmVyLT53YWl0X2Zvcl9zdWJzY3JpcHRpb25f c3luYygkbm9kZV9wdWJsaXNoZXIsICd0YXBfc3ViJyk7CisKK2lzKCAkbm9kZV9zdWJzY3JpYmVy LT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgIlNFTEVDVCBjb3VudCgqKSBGUk9NIHRhYl9yZXMiKSwK KwknMTAwJywgJ2luaXRpYWwgc3luYyBvZiB0YWJfcmVzJyk7CitpcyggJG5vZGVfc3Vic2NyaWJl ci0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsICJTRUxFQ1QgY291bnQoKikgRlJPTSB0YWJfb3RoZXIi KSwKKwknMTAwJywgJ2luaXRpYWwgc3luYyBvZiB0YWJfb3RoZXInKTsKKworIyBBIHNtYWxsIGhl bHBlcjogcnVuIFNRTCBleHBlY3RlZCB0byBmYWlsLCBhbmQgY2hlY2sgdGhlIGVycm9yIG1lc3Nh Z2UuCitzdWIgcmVmcmVzaF9zaG91bGRfZmFpbAoreworCW15ICgkc3FsLCAkcGF0dGVybiwgJGRl c2MpID0gQF87CisJbXkgKCRyZXQsICRzdGRvdXQsICRzdGRlcnIpID0gKCcnLCAnJywgJycpOwor CSRyZXQgPSAkbm9kZV9zdWJzY3JpYmVyLT5wc3FsKCdwb3N0Z3JlcycsICRzcWwsCisJCXN0ZG91 dCA9PiBcJHN0ZG91dCwgc3RkZXJyID0+IFwkc3RkZXJyKTsKKwlvaygkcmV0ICE9IDAgJiYgJHN0 ZGVyciA9fiAvJHBhdHRlcm4vLAorCQkkZGVzYykKKwkgIG9yIGRpYWcoImdvdCByZXQ9JHJldCBz dGRlcnI9JHN0ZGVyciIpOworfQorCisjIFJFRlJFU0ggVEFCTEUgaXMgbm90IGFsbG93ZWQgd2hp bGUgdGhlIHN1YnNjcmlwdGlvbiBpcyBlbmFibGVkLgorcmVmcmVzaF9zaG91bGRfZmFpbCgKKwki QUxURVIgU1VCU0NSSVBUSU9OIHRhcF9zdWIgUkVGUkVTSCBUQUJMRSB0YWJfcmVzIiwKKwlxci9u b3QgYWxsb3dlZCBmb3IgZW5hYmxlZCBzdWJzY3JpcHRpb25zLywKKwknUkVGUkVTSCBUQUJMRSBy ZWplY3RlZCB3aGlsZSBlbmFibGVkJyk7CisKKyMgRGlzYWJsZSB0aGUgc3Vic2NyaXB0aW9uIGFu ZCB3YWl0IGZvciBpdHMgd29ya2VycyB0byBzdG9wLgorJG5vZGVfc3Vic2NyaWJlci0+c2FmZV9w c3FsKCdwb3N0Z3JlcycsCisJIkFMVEVSIFNVQlNDUklQVElPTiB0YXBfc3ViIERJU0FCTEUiKTsK KyRub2RlX3N1YnNjcmliZXItPnBvbGxfcXVlcnlfdW50aWwoJ3Bvc3RncmVzJywKKwkiU0VMRUNU IGNvdW50KCopID0gMCBGUk9NIHBnX3N0YXRfc3Vic2NyaXB0aW9uIFdIRVJFIHN1Ym5hbWUgPSAn dGFwX3N1YicgQU5EIHBpZCBJUyBOT1QgTlVMTCIKKykgb3IgZGllICJUaW1lZCBvdXQgd2FpdGlu ZyBmb3Igc3Vic2NyaXB0aW9uIHdvcmtlcnMgdG8gc3RvcCI7CisKKyMgQSB0YWJsZSB0aGF0IGlz IG5vdCBwYXJ0IG9mIHRoZSBzdWJzY3JpcHRpb24gaXMgcmVqZWN0ZWQuCityZWZyZXNoX3Nob3Vs ZF9mYWlsKAorCSJBTFRFUiBTVUJTQ1JJUFRJT04gdGFwX3N1YiBSRUZSRVNIIFRBQkxFIHRhYl9s b2NhbCIsCisJcXIvaXMgbm90IHBhcnQgb2YgdGhlIHN1YnNjcmlwdGlvbi8sCisJJ1JFRlJFU0gg VEFCTEUgcmVqZWN0ZWQgZm9yIHRhYmxlIG5vdCBpbiBzdWJzY3JpcHRpb24nKTsKKworIyBBIHNl cXVlbmNlIGNhbm5vdCBiZSByZWZyZXNoZWQgYXMgYSB0YWJsZS4KK3JlZnJlc2hfc2hvdWxkX2Zh aWwoCisJIkFMVEVSIFNVQlNDUklQVElPTiB0YXBfc3ViIFJFRlJFU0ggVEFCTEUgc2VxX2xvY2Fs IiwKKwlxci9jYW5ub3QgcmVmcmVzaCBzZXF1ZW5jZS8sCisJJ1JFRlJFU0ggVEFCTEUgcmVqZWN0 ZWQgZm9yIGEgc2VxdWVuY2UnKTsKKworIyBUaGUgY29tbWFuZCBjYW5ub3QgcnVuIGluc2lkZSBh IHRyYW5zYWN0aW9uIGJsb2NrLgorcmVmcmVzaF9zaG91bGRfZmFpbCgKKwkiQkVHSU47IEFMVEVS IFNVQlNDUklQVElPTiB0YXBfc3ViIFJFRlJFU0ggVEFCTEUgdGFiX3JlczsiLAorCXFyL2Nhbm5v dCBydW4gaW5zaWRlIGEgdHJhbnNhY3Rpb24gYmxvY2svLAorCSdSRUZSRVNIIFRBQkxFIHJlamVj dGVkIGluc2lkZSBhIHRyYW5zYWN0aW9uIGJsb2NrJyk7CisKKyMgQWxsLW9yLW5vdGhpbmc6IGEg bGlzdCBjb250YWluaW5nIG9uZSBiYWQgdGFibGUgYWJvcnRzIHRoZSB3aG9sZSBjb21tYW5kIGFu ZAorIyBsZWF2ZXMgdGhlIHZhbGlkIHRhYmxlIHVudG91Y2hlZC4KK3JlZnJlc2hfc2hvdWxkX2Zh aWwoCisJIkFMVEVSIFNVQlNDUklQVElPTiB0YXBfc3ViIFJFRlJFU0ggVEFCTEUgdGFiX3Jlcywg dGFiX2xvY2FsIiwKKwlxci9pcyBub3QgcGFydCBvZiB0aGUgc3Vic2NyaXB0aW9uLywKKwknUkVG UkVTSCBUQUJMRSB3aXRoIGEgYmFkIHRhYmxlIGluIHRoZSBsaXN0IGlzIHJlamVjdGVkJyk7Citp cyggJG5vZGVfc3Vic2NyaWJlci0+c2FmZV9wc3FsKAorCQkncG9zdGdyZXMnLAorCQkiU0VMRUNU IHNyc3Vic3RhdGUgRlJPTSBwZ19zdWJzY3JpcHRpb25fcmVsIHIgSk9JTiBwZ19jbGFzcyBjIE9O IGMub2lkID0gci5zcnJlbGlkIFdIRVJFIGMucmVsbmFtZSA9ICd0YWJfcmVzJyIKKwkpLAorCSdy JywKKwkndmFsaWQgdGFibGUgbm90IHJlc2V0IHdoZW4gYW5vdGhlciB0YWJsZSBpbiB0aGUgbGlz dCBpcyBpbnZhbGlkJyk7CisKKyMgSW50cm9kdWNlIGRyaWZ0IG9uIHRoZSBzdWJzY3JpYmVyLCBv bmx5IGluIHRhYl9yZXMuCiskbm9kZV9zdWJzY3JpYmVyLT5zYWZlX3BzcWwoCisJJ3Bvc3RncmVz JywgcXEoCisJREVMRVRFIEZST00gdGFiX3JlcyBXSEVSRSBhIDw9IDQwOworCVVQREFURSB0YWJf cmVzIFNFVCBiID0gJ0NPUlJVUFQnIFdIRVJFIGEgPSA2MDsKKykpOworaXMoICRub2RlX3N1YnNj cmliZXItPnNhZmVfcHNxbCgncG9zdGdyZXMnLCAiU0VMRUNUIGNvdW50KCopIEZST00gdGFiX3Jl cyIpLAorCSc2MCcsICdkcmlmdCBpbnRyb2R1Y2VkIGluIHRhYl9yZXMnKTsKKworIyBSZWNvcmQg dGhlIHByZS1yZWZyZXNoIHN0YXRlIG9mIHRoZSBvdGhlciB0YWJsZS4KK215ICRvdGhlcl9zdGF0 ZV9iZWZvcmUgPSAkbm9kZV9zdWJzY3JpYmVyLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywKKwkiU0VM RUNUIHNyc3Vic3RhdGUgRlJPTSBwZ19zdWJzY3JpcHRpb25fcmVsIHIgSk9JTiBwZ19jbGFzcyBj IE9OIGMub2lkID0gci5zcnJlbGlkIFdIRVJFIGMucmVsbmFtZSA9ICd0YWJfb3RoZXInIgorKTsK K2lzKCRvdGhlcl9zdGF0ZV9iZWZvcmUsICdyJywgJ3RhYl9vdGhlciBpcyByZWFkeSBiZWZvcmUg cmVmcmVzaCcpOworCisjIFJlc3luYyBqdXN0IHRhYl9yZXMuCiskbm9kZV9zdWJzY3JpYmVyLT5z YWZlX3BzcWwoJ3Bvc3RncmVzJywKKwkiQUxURVIgU1VCU0NSSVBUSU9OIHRhcF9zdWIgUkVGUkVT SCBUQUJMRSB0YWJfcmVzIik7CisKKyMgT25seSB0YWJfcmVzIGlzIHJlc2V0IHRvIGluaXQ7IHRh Yl9vdGhlciBpcyB1bnRvdWNoZWQ7IGxvY2FsIGNvcHkgdHJ1bmNhdGVkLgoraXMoICRub2RlX3N1 YnNjcmliZXItPnNhZmVfcHNxbCgKKwkJJ3Bvc3RncmVzJywKKwkJIlNFTEVDVCBzcnN1YnN0YXRl IEZST00gcGdfc3Vic2NyaXB0aW9uX3JlbCByIEpPSU4gcGdfY2xhc3MgYyBPTiBjLm9pZCA9IHIu c3JyZWxpZCBXSEVSRSBjLnJlbG5hbWUgPSAndGFiX3JlcyciCisJKSwKKwknaScsCisJJ3RhYl9y ZXMgcmVzZXQgdG8gaW5pdCBzdGF0ZScpOworaXMoICRub2RlX3N1YnNjcmliZXItPnNhZmVfcHNx bCgKKwkJJ3Bvc3RncmVzJywKKwkJIlNFTEVDVCBzcnN1YnN0YXRlIEZST00gcGdfc3Vic2NyaXB0 aW9uX3JlbCByIEpPSU4gcGdfY2xhc3MgYyBPTiBjLm9pZCA9IHIuc3JyZWxpZCBXSEVSRSBjLnJl bG5hbWUgPSAndGFiX290aGVyJyIKKwkpLAorCSdyJywKKwkndGFiX290aGVyIGxlZnQgdW50b3Vj aGVkIChzdGlsbCByZWFkeSknKTsKK2lzKCAkbm9kZV9zdWJzY3JpYmVyLT5zYWZlX3BzcWwoJ3Bv c3RncmVzJywgIlNFTEVDVCBjb3VudCgqKSBGUk9NIHRhYl9yZXMiKSwKKwknMCcsICd0YWJfcmVz IHRydW5jYXRlZCBsb2NhbGx5IGJ5IFJFRlJFU0ggd2hpbGUgZGlzYWJsZWQnKTsKKworIyBSZS1l bmFibGUgYW5kIHdhaXQgZm9yIHRoZSBzaW5nbGUgdGFibGUgdG8gcmUtY29weS4KKyRub2RlX3N1 YnNjcmliZXItPnNhZmVfcHNxbCgncG9zdGdyZXMnLAorCSJBTFRFUiBTVUJTQ1JJUFRJT04gdGFw X3N1YiBFTkFCTEUiKTsKKyRub2RlX3N1YnNjcmliZXItPndhaXRfZm9yX3N1YnNjcmlwdGlvbl9z eW5jKCRub2RlX3B1Ymxpc2hlciwgJ3RhcF9zdWInKTsKKworaXMoICRub2RlX3N1YnNjcmliZXIt PnNhZmVfcHNxbCgncG9zdGdyZXMnLCAiU0VMRUNUIGNvdW50KCopIEZST00gdGFiX3JlcyIpLAor CScxMDAnLCAndGFiX3JlcyByZS1jb3BpZWQgYWZ0ZXIgZW5hYmxlJyk7CitpcyggJG5vZGVfc3Vi c2NyaWJlci0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsCisJCSJTRUxFQ1QgYiBGUk9NIHRhYl9yZXMg V0hFUkUgYSA9IDYwIiksCisJJ3A2MCcsICd0YWJfcmVzIGNvcnJ1cHRpb24gcmVwYWlyZWQgYnkg cmVzeW5jJyk7CisKKyMgRnVsbCBjb250ZW50IG1hdGNoZXMgdGhlIHB1Ymxpc2hlci4KK215ICRw dWJfbWQ1ID0gJG5vZGVfcHVibGlzaGVyLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywKKwkiU0VMRUNU IG1kNShzdHJpbmdfYWdnKGEgfHwgJzonIHx8IGIsICcsJyBPUkRFUiBCWSBhKSkgRlJPTSB0YWJf cmVzIik7CitteSAkc3ViX21kNSA9ICRub2RlX3N1YnNjcmliZXItPnNhZmVfcHNxbCgncG9zdGdy ZXMnLAorCSJTRUxFQ1QgbWQ1KHN0cmluZ19hZ2coYSB8fCAnOicgfHwgYiwgJywnIE9SREVSIEJZ IGEpKSBGUk9NIHRhYl9yZXMiKTsKK2lzKCRzdWJfbWQ1LCAkcHViX21kNSwgJ3RhYl9yZXMgbWF0 Y2hlcyBwdWJsaXNoZXIgYWZ0ZXIgcmVzeW5jJyk7CisKKyMgdGFiX290aGVyIHdhcyBuZXZlciBk aXN0dXJiZWQuCitpcyggJG5vZGVfc3Vic2NyaWJlci0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsICJT RUxFQ1QgY291bnQoKikgRlJPTSB0YWJfb3RoZXIiKSwKKwknMTAwJywgJ3RhYl9vdGhlciBpbnRh Y3QgdGhyb3VnaG91dCcpOworCisjIE9uZ29pbmcgcmVwbGljYXRpb24gc3RpbGwgd29ya3MgZm9y IHRoZSByZXN5bmNlZCB0YWJsZS4KKyRub2RlX3B1Ymxpc2hlci0+c2FmZV9wc3FsKCdwb3N0Z3Jl cycsCisJIklOU0VSVCBJTlRPIHRhYl9yZXMgVkFMVUVTICgxMDEsICdwMTAxJykiKTsKKyRub2Rl X3B1Ymxpc2hlci0+d2FpdF9mb3JfY2F0Y2h1cCgndGFwX3N1YicpOworaXMoICRub2RlX3N1YnNj cmliZXItPnNhZmVfcHNxbCgncG9zdGdyZXMnLAorCQkiU0VMRUNUIGNvdW50KCopIEZST00gdGFi X3JlcyBXSEVSRSBhID0gMTAxIiksCisJJzEnLCAnc3RyZWFtaW5nIHJlc3VtZXMgb24gcmVzeW5j ZWQgdGFibGUnKTsKKworIyBNdWx0aXBsZSB0YWJsZXMgY2FuIGJlIHJlc3luY2VkIGluIGEgc2lu Z2xlIGNvbW1hbmQuICBEaXNhYmxlLCBkcmlmdCBib3RoCisjIHRhYmxlcywgYW5kIHJlZnJlc2gg dGhlbSB0b2dldGhlci4KKyRub2RlX3N1YnNjcmliZXItPnNhZmVfcHNxbCgncG9zdGdyZXMnLAor CSJBTFRFUiBTVUJTQ1JJUFRJT04gdGFwX3N1YiBESVNBQkxFIik7Ciskbm9kZV9zdWJzY3JpYmVy LT5wb2xsX3F1ZXJ5X3VudGlsKCdwb3N0Z3JlcycsCisJIlNFTEVDVCBjb3VudCgqKSA9IDAgRlJP TSBwZ19zdGF0X3N1YnNjcmlwdGlvbiBXSEVSRSBzdWJuYW1lID0gJ3RhcF9zdWInIEFORCBwaWQg SVMgTk9UIE5VTEwiCispIG9yIGRpZSAiVGltZWQgb3V0IHdhaXRpbmcgZm9yIHN1YnNjcmlwdGlv biB3b3JrZXJzIHRvIHN0b3AiOworCiskbm9kZV9zdWJzY3JpYmVyLT5zYWZlX3BzcWwoCisJJ3Bv c3RncmVzJywgcXEoCisJREVMRVRFIEZST00gdGFiX3JlcyAgIFdIRVJFIGEgPD0gMjA7CisJREVM RVRFIEZST00gdGFiX290aGVyIFdIRVJFIGEgPD0gMjA7CispKTsKKworJG5vZGVfc3Vic2NyaWJl ci0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsCisJIkFMVEVSIFNVQlNDUklQVElPTiB0YXBfc3ViIFJF RlJFU0ggVEFCTEUgdGFiX3JlcywgdGFiX290aGVyIik7CisKKyMgQm90aCBsaXN0ZWQgdGFibGVz IGFyZSByZXNldCB0byBpbml0IGFuZCB0cnVuY2F0ZWQgbG9jYWxseS4KK2lzKCAkbm9kZV9zdWJz Y3JpYmVyLT5zYWZlX3BzcWwoCisJCSdwb3N0Z3JlcycsCisJCSJTRUxFQ1Qgc3RyaW5nX2FnZyhz cnN1YnN0YXRlLCAnLCcgT1JERVIgQlkgYy5yZWxuYW1lKSBGUk9NIHBnX3N1YnNjcmlwdGlvbl9y ZWwgciBKT0lOIHBnX2NsYXNzIGMgT04gYy5vaWQgPSByLnNycmVsaWQgV0hFUkUgYy5yZWxuYW1l IElOICgndGFiX290aGVyJywgJ3RhYl9yZXMnKSIKKwkpLAorCSdpLGknLAorCSdib3RoIGxpc3Rl ZCB0YWJsZXMgcmVzZXQgdG8gaW5pdCBzdGF0ZScpOworaXMoICRub2RlX3N1YnNjcmliZXItPnNh ZmVfcHNxbCgncG9zdGdyZXMnLAorCQkiU0VMRUNUIChTRUxFQ1QgY291bnQoKikgRlJPTSB0YWJf cmVzKSArIChTRUxFQ1QgY291bnQoKikgRlJPTSB0YWJfb3RoZXIpIiksCisJJzAnLCAnYm90aCBs aXN0ZWQgdGFibGVzIHRydW5jYXRlZCBsb2NhbGx5Jyk7CisKKyMgUmUtZW5hYmxlIGFuZCB3YWl0 IGZvciBib3RoIHRhYmxlcyB0byByZS1jb3B5LgorJG5vZGVfc3Vic2NyaWJlci0+c2FmZV9wc3Fs KCdwb3N0Z3JlcycsCisJIkFMVEVSIFNVQlNDUklQVElPTiB0YXBfc3ViIEVOQUJMRSIpOworJG5v ZGVfc3Vic2NyaWJlci0+d2FpdF9mb3Jfc3Vic2NyaXB0aW9uX3N5bmMoJG5vZGVfcHVibGlzaGVy LCAndGFwX3N1YicpOworCitteSAkcHViX3JlcyA9ICRub2RlX3B1Ymxpc2hlci0+c2FmZV9wc3Fs KCdwb3N0Z3JlcycsCisJIlNFTEVDVCBtZDUoc3RyaW5nX2FnZyhhIHx8ICc6JyB8fCBiLCAnLCcg T1JERVIgQlkgYSkpIEZST00gdGFiX3JlcyIpOworbXkgJHN1Yl9yZXMgPSAkbm9kZV9zdWJzY3Jp YmVyLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywKKwkiU0VMRUNUIG1kNShzdHJpbmdfYWdnKGEgfHwg JzonIHx8IGIsICcsJyBPUkRFUiBCWSBhKSkgRlJPTSB0YWJfcmVzIik7Citpcygkc3ViX3Jlcywg JHB1Yl9yZXMsICd0YWJfcmVzIG1hdGNoZXMgcHVibGlzaGVyIGFmdGVyIG11bHRpLXRhYmxlIHJl c3luYycpOworCitteSAkcHViX290aCA9ICRub2RlX3B1Ymxpc2hlci0+c2FmZV9wc3FsKCdwb3N0 Z3JlcycsCisJIlNFTEVDVCBtZDUoc3RyaW5nX2FnZyhhIHx8ICc6JyB8fCBiLCAnLCcgT1JERVIg QlkgYSkpIEZST00gdGFiX290aGVyIik7CitteSAkc3ViX290aCA9ICRub2RlX3N1YnNjcmliZXIt PnNhZmVfcHNxbCgncG9zdGdyZXMnLAorCSJTRUxFQ1QgbWQ1KHN0cmluZ19hZ2coYSB8fCAnOicg fHwgYiwgJywnIE9SREVSIEJZIGEpKSBGUk9NIHRhYl9vdGhlciIpOworaXMoJHN1Yl9vdGgsICRw dWJfb3RoLCAndGFiX290aGVyIG1hdGNoZXMgcHVibGlzaGVyIGFmdGVyIG11bHRpLXRhYmxlIHJl c3luYycpOworCiskbm9kZV9zdWJzY3JpYmVyLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgIkRST1Ag U1VCU0NSSVBUSU9OIHRhcF9zdWIiKTsKKyRub2RlX3N1YnNjcmliZXItPnN0b3AoJ2Zhc3QnKTsK KyRub2RlX3B1Ymxpc2hlci0+c3RvcCgnZmFzdCcpOworCitkb25lX3Rlc3RpbmcoKTsKLS0gCjIu NTQuMAoK --000000000000f56aad06563f56ad--