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 1vuqEb-009CUb-0z for pgsql-hackers@arkaria.postgresql.org; Tue, 24 Feb 2026 11:05:45 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1vuqDa-000jZC-2V for pgsql-hackers@arkaria.postgresql.org; Tue, 24 Feb 2026 11:04:42 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vuqDa-000jZ1-18 for pgsql-hackers@lists.postgresql.org; Tue, 24 Feb 2026 11:04:42 +0000 Received: from mail-lj1-x22f.google.com ([2a00:1450:4864:20::22f]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.98.2) (envelope-from ) id 1vuqDX-000000012Id-0zv0 for pgsql-hackers@lists.postgresql.org; Tue, 24 Feb 2026 11:04:42 +0000 Received: by mail-lj1-x22f.google.com with SMTP id 38308e7fff4ca-385c2f88618so44816211fa.2 for ; Tue, 24 Feb 2026 03:04:40 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1771931079; cv=none; d=google.com; s=arc-20240605; b=Ezs2jL6u9A54Z1ummZA74rmvdH8qScZ4SHFZy/pogkxO3sOzIlREoa4IWx4VabRlQg CHAZDDCaV0Pi1rh0e4TxuQ2N9gPA9iXSgqlDddD5dCbKZJP49POiwYailewAkC0mSh35 XIpgbZF8mFtoxTGIz+OZjCYI+SQCX5u/J70j42SgQ/sj7tAjktQ5BMlPvTsk1oMSrEq5 Y7J1GsaFChlVegofhZEVgU1UrP926ZYBTQ3sb2nHpTdkv+BN+ICb+GSjgprTTIf44cKg Hw918NDPGd9E2OBTcEXoMjz26gzlRTpB0+J/axfeBuUTsyS78xp/5ND/ErmVQDE9YEN6 T9Mw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:dkim-signature; bh=EmJl/ZYfmtuImnSJvZn+IvT2iA5pGL7s4qAyOYKnGZg=; fh=pJ7vuZxPFfKnwGO36jLcGrX72ITv630UI2sLKSbTH/g=; b=KtSLYqUVfhOB0JddQytV3pAGBRjkT9xQsWEbRNI+8yPMDhr5XsKJOa8G2+GFT4QURs VtThQoaN2b7hpExXmygbpBo9nzslBUnfynDba65OUkftc/dLOLvRtIdUJLp0/LO8eqck Akx/BQkNTICYvtRwhUkLrZYbg5jmSB13FiKhACazbjQG8r338CMdIKTmbAVXBbqN3UHJ rhKEVKLNkEHpVu8NAtjRit1yfI9lnrumv7SdNQ6FKWI1IGfh/mwhEWDZan9RX1MrcB5p Y8CV0C6cNW59auh70KVoV7DR4MG7S03FcbEhLodPhWPuqnNepNHQXK4eAUHUpu9U6+sY H6jQ==; 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=gmail.com; s=20230601; t=1771931079; x=1772535879; darn=lists.postgresql.org; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=EmJl/ZYfmtuImnSJvZn+IvT2iA5pGL7s4qAyOYKnGZg=; b=BR/EpUzFH1N64+v0OxcxagEdwcMyM9zEUG1/ob//dAXOQxLYhVkk5KvTs6WnAmn10H hQ9U+1E2/NpHVrS885m8NxYnQA/3lBrpt2Ei9Atc7H/J2oe6YS+Vgfe6YPjiSfCmJ7iv YPBtY/5xtdZrAkGc9+r2v+SqrvOPpE1Qe+hJWjnva4OkYL8oY3xv6/zL2gkKri/Ibtnz ZlOy/2V7lJkqphnetj1JAR8dv3WbH1R9mb8j7AFkKJGL7uMi55Dy8CywGgpCq6Typ1WE EgLyY01zed0xJLTVdyD4p5pL0aiEw5vnpwAvagnID+t6fCiZFFZOJGn0uCtdGXgUAMQk ti7A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771931079; x=1772535879; h=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; bh=EmJl/ZYfmtuImnSJvZn+IvT2iA5pGL7s4qAyOYKnGZg=; b=sWWiSeuoSfzrZ/5VBatz6KWW8CNycknCJuwgSDjsl0FaJnAHC/zlHtMzNv5SD7BlSn 1tL/6ARx4sdXvGyTPz9qIbrALwXYz5LTVQcq5gbTy0u5oc36PKLKgZBlMmiLTMFria5L caK582VR7CzOitbOqM+o+JBxzrImLrtcNzvVKe/t56VAD1nMXh16zlbxnA870Hvz5uaQ ghHNqKYoXNvIzR9m40YNi/tIntrWaIhOiykn4c0ux/lSXwuqFVuz/hVeZkJe95xXdrbC dv+h/bsLQ8OtSr8+/LyXOhI5JLaBxQ5QJQsWKMOWWclOtZSVwBAl4sG+yqRC5LiVWvl5 rrRg== X-Forwarded-Encrypted: i=1; AJvYcCUNXzAjZHDqGlFWXNFx0t+tV1Yc/b4AcU2LJlJCpSlve0VnmQ5vCavNjZao8VsO261jHufvrXj4jChEq5G4@lists.postgresql.org X-Gm-Message-State: AOJu0Yxh0/UyuLVnliKoG7lyCCMg0ZZD9q9yeQ1Yw8xMGwEjY+4THtaX wqcBr9hGz/V7MOJYjtWMUOVLY49W0r5LwfyA4Me+akjpUu5zGkG9MtqZFX+cUfBUn0pYeywF8j1 1GApl0RmoaKifYOciYiBfTYv0FqCZzLM= X-Gm-Gg: ATEYQzw0c4r5Cn6xR20xgcEgLr/Zugj9fYeQM0Nh6VUJ0w1PzTskhLjZjbrLNsEJUX7 CzHU7xKxrMBVdwWycoWADcscI/WPobXdAgDjxDNQUnm3nN/xa2PRpgc7/mSWeeBnNorW+wGq65h HIFY6fdBhmUoeaBCqDA6rq2m2Dph75ESv0Pq60eQ4dEaY+1M6EeaKFvIUmpzzwt/+4bCormoWbN qVn5Noiqx2v2+7E1XsSznUsey9PPZtKeKsr1bm+jeBGskKD23KukYYcJZyRQCCZlazafsr+QLkq xulNg2W+ X-Received: by 2002:a2e:b8d5:0:b0:386:e8bd:505e with SMTP id 38308e7fff4ca-389a5e9672dmr39046031fa.40.1771931078904; Tue, 24 Feb 2026 03:04:38 -0800 (PST) MIME-Version: 1.0 References: In-Reply-To: From: Ajin Cherian Date: Tue, 24 Feb 2026 22:04:26 +1100 X-Gm-Features: AaiRm50pqUlhx5m2DD3VOwiRGDeXHON61OzMPWQrp7iOhRBwfrRi_3O86TMgBes Message-ID: Subject: Re: [PATCH] Support automatic sequence replication To: Amit Kapila Cc: "Hayato Kuroda (Fujitsu)" , shveta malik , Ashutosh Sharma , PostgreSQL Hackers Content-Type: multipart/mixed; boundary="000000000000866fd6064b8fda78" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --000000000000866fd6064b8fda78 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable On Tue, Feb 24, 2026 at 4:36=E2=80=AFPM Amit Kapila wrote: > > On Mon, Feb 23, 2026 at 6:56=E2=80=AFAM Hayato Kuroda (Fujitsu) > wrote: > > > > Thanks for updating the patch. Here are my comments. > > > > 01. start_sequence_sync() > > ``` > > /* Need to start transaction for cache lookup */ > > StartTransactionCommand(); > > ``` > > > > Here, we must check additional parameter changes, such as conninfo and = passwordrequired. > > Also, it's inefficient because transactions are started each time. > > > > Can we re-use maybe_reread_subscription() here? Some parameters do not = take > > effect for the sequence sync worker, but it is OK to exit even if they > > are changed. If we use the function, no need to include "storage/ipc.h"= . > > > > I also think it is better to restart the sequencesync worker on > subscription parameter change and probably it is okay to use > maybe_reread_subscription() but need to be careful to avoid anything > apply_worker specific in that function. BTW, what happens now without > this change when apply_worker stops due to parameter change, does > sequencesync worker continue? If so, we should make it restart as we > are doing for apply worker. > I have changed it to use maybe_reread_subscription() and modified maybe_reread_subscription() to have have some special handling sequence sync workers as well. Yes, the apply worker will again restart the sequence worker when it finds that it isn't running and there are sequences in the subscription_rel. > Also, shouldn't we need to invoke AcceptInvalidationMessages() as we > are doing in apply worker when not in a remote transaction? I think it > will be required to get local_sequence definition changes , if any. I will need to investigate this further. > > > 02. match_previous_words > > > > No need to remove "REFRESH SEQUENCES" anymore. > > > > 03. CopySeqResult > > ``` > > COPYSEQ_NOWORK, > > ``` > > > > It describes why the copying is skipped. How about "COPYSEQ_NO_DRIFT"? > > > > +1. Fixed. > > > 04. LogicalRepSyncSequences() > > > > ``` > > oldctx =3D MemoryContextSwitchTo(ApplyContext); > > > > seq =3D palloc0_object(LogicalRepSequenceInfo); > > seq->localrelid =3D subrel->srrelid; > > seq->nspname =3D get_namespace_name(RelationGetNamespace(sequence_rel= )); > > seq->seqname =3D pstrdup(RelationGetRelationName(sequence_rel)); > > seq->relstate =3D relstate; > > seqinfos =3D lappend(seqinfos, seq); > > > > MemoryContextSwitchTo(oldctx); > > ``` > > > > ISTM they are palloc'd but not pfree'd. > > > > They are freed, see following code. But it seems nspname and seqname > should be freed separately for each sequence element and each sequence > element also needs to be freed independently. > > + /* Clean up */ > + list_free(seqinfos); > > > Since the sequencesync worker now has a long lifetime, we must take car= e of the > > memory allocation/freeing more carefully. How about introducing per-int= eraction > > memory context like ApplyMessageContext? > > > > Yeah, I feel that would be a better approach than retail pfree > especially because it is also required at other places in sequencesync > worker (see places where currently ApplyContext is used in > sequencesync worker). I think it would be better if we name this new > context as SequenceSyncContext. > Done. Changed as requested. > Few other miscellaneous comments > =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D > 1. > > - Refreshing Out-of-Sync Sequences > - > - Subscriber sequence values will become out of sync as the publisher > - advances them. > - > - > - To detect this, compare the > - pg_subscription_rel.srsublsn > - on the subscriber with the page_lsn obtai= ned > - from the linkend=3D"func-pg-get-sequence-data">pg_get_sequence_data > - function for the sequence on the publisher. Then run > - > - ALTER SUBSCRIPTION ... REFRESH SEQUENCES t= o > - re-synchronize if necessary. > - > + Out-of-Sync Sequences > > > Each sequence caches a block of values (typically 32) in memory bef= ore > @@ -1961,16 +1941,6 @@ Publications: > ------------+-----------+------------ > 610 | t | 0/017CEDF8 > (1 row) > - > - > - > - The difference between the sequence page LSNs on the publisher and t= he > - sequence page LSNs on the subscriber indicates that the sequences ar= e out > - of sync. Re-synchronize all sequences known to the subscriber using > - > - ALTER SUBSCRIPTION ... REFRESH SEQUENCES. > - > -/* sub # */ ALTER SUBSCRIPTION sub1 REFRESH SEQUENCES; > > ... > ... > - > - > - Incremental sequence changes are not replicated. Although the data= in > - serial or identity columns backed by sequences will be replicated a= s part > - of the table, the sequences themselves do not replicate ongoing cha= nges. > - On the subscriber, a sequence will retain the last value it synchro= nized > - from the publisher. If the subscriber is used as a read-only databa= se, > - then this should typically not be a problem. If, however, some kin= d of > - switchover or failover to the subscriber database is intended, then= the > - sequences would need to be updated to the latest values, either by > - executing > - ALTER SUBSCRIPTION ... REFRESH SEQUENCES > - or by copying the current data from the publisher (perhaps using > - pg_dump) or by determining a sufficiently high v= alue > - from the tables themselves. > - > - > - > > I think this can still happen after this patch but chances are much > lower, so we need some of this before upgrade. We should reword it > accordingly. Similarly check other parts of the doc you removed. > I have re-added them and modified them. > 2. > - "logical replication synchronization for subscription \"%s\", > sequence \"%s.%s\" has finished", > + "logical replication sync for subscription \"%s\", sequence > \"%s.%s\" has been updated", > > Is there a need to shorten synchronization to sync in above message? > Removed. > 3. > elog(DEBUG1, > - "logical replication sequence synchronization for subscription > \"%s\" - batch #%d =3D %d attempted, %d succeeded, %d mismatched, %d > insufficient permission, %d missing from publisher, %d skipped", > - MySubscription->name, > - (cur_batch_base_index / MAX_SEQUENCES_SYNC_PER_BATCH) + 1, > - batch_size, batch_succeeded_count, batch_mismatched_count, > - batch_insuffperm_count, batch_missing_count, batch_skipped_count); > + "logical replication sequence synchronization for subscription > \"%s\" - batch #%d =3D %d attempted, %d succeeded, %d mismatched, %d > insufficient permission, %d missing from publisher, %d skipped, %d no > drift", > + MySubscription->name, > + (cur_batch_base_index / MAX_SEQUENCES_SYNC_PER_BATCH) + 1, > + batch_size, batch_succeeded_count, batch_mismatched_count, > + batch_insuffperm_count, batch_missing_count, batch_skipped_count, > batch_no_drift); > > Here, the formatting of message is incorrect. > Fixed. > 4. > table_states_not_ready =3D NIL; > - > if (!IsTransactionState()) > > Spurious line removal. > > 5. > MemoryContextSwitchTo(oldctx); > - > + list_free_deep(seq_states); > /* > * Does the subscription have tables? > * > @@ -260,7 +253,6 @@ FetchRelationStates(bool *has_pending_subtables, > */ > has_subtables =3D (table_states_not_ready !=3D NIL) || > HasSubscriptionTables(MySubscription->oid); > - > /* > * If the subscription relation cache has been invalidated since we > * entered this routine, we still use and return the relations we just > @@ -271,10 +263,8 @@ FetchRelationStates(bool *has_pending_subtables, > if (relation_states_validity =3D=3D SYNC_RELATIONS_STATE_REBUILD_STARTE= D) > relation_states_validity =3D SYNC_RELATIONS_STATE_VALID; > } > - > if (has_pending_subtables) > *has_pending_subtables =3D has_subtables; > - > if (has_pending_subsequences) > ... > ... > > } > > + > if (rc & WL_TIMEOUT) > > All above places have spurious line removals and additions which made > code harder to understand. > Fixed. > 6. > else if (Matches("ALTER", "SUBSCRIPTION", MatchAny)) > COMPLETE_WITH("CONNECTION", "ENABLE", "DISABLE", "OWNER TO", > - "RENAME TO", "REFRESH PUBLICATION", "REFRESH SEQUENCES", > - "SET", "SKIP (", "ADD PUBLICATION", "DROP PUBLICATION"); > + "RENAME TO", "REFRESH PUBLICATION", "SET", "SKIP (", > + "ADD PUBLICATION", "DROP PUBLICATION"); > > unrelated change. > Removed. > 7. > + else > + { > + > + /* > + * Double the sleep time, but not beyond > + * the maximum allowable value. > + */ > + sleep_ms =3D Min(sleep_ms * 2, SEQSYNC_MAX_SLEEP_MS); > > Comments are not properly aligned. > Fixed. On Tue, Feb 24, 2026 at 5:17=E2=80=AFPM Amit Kapila wrote: > > On Mon, Feb 23, 2026 at 6:56=E2=80=AFAM Hayato Kuroda (Fujitsu) > wrote: > > > > 05. LogicalRepApplyLoop() > > > > MaybeLaunchSequenceSyncWorker() should be called more; otherwise, the s= equencesync > > worker won't be launched if the worker always receives messages and WL_= TIMEOUT does > > not happen. Can you add most of the places under maybe_advance_nonremov= able_xid()? > > Personally considered, no need to add within `else if (c =3D=3D PqReplM= sg_PrimaryStatusUpdate)` > > because it just consumes status updates from the primary. > > > > I don't think we need to be as aggressive as > maybe_advance_nonremovable_xid because not doing that can lead to > bload if slot is not advanced. The only minor downside with checking > too frequently is that we need to traverse the all logical replication > workers to find if sequencesync worker is available. I feel doing in > ProcessSyncingRelations() where earlier we were doing > ProcessSequencesForSync() should be sufficient. Added it back as previous. Can we find some cheap > way to detect if sequencesync worker is present or not? Can you think > some other way to not incur the cost of traversing the worker array > and also detect sequence worker exit without much delay? > I will need to investigate this further. > ... > > > > 07. > > Question: Can we introduce an intermediate state, such as SYNC, to clar= ify > > whether synchronization is proceeding? > > > > What is the advantage of this? For external purposes, the presence of > sequencesync worker, which can be checked via pg_stat_subscription > should be sufficient. > > BTW, what is the behavior of REFRESH SEQUENCES command if the sequence > worker is active? Does it still try to refresh sequences, if so, is > that required/good idea? > Currently REFRESH SEQUENCES can only be called if the subscription is enabled. All it does is change the states of all the sequences in subscription_rel to INIT, this will prompt the sequence worker to wake up and unconditionally sync all the sequences. For sequences in the INIT state, it doesn't check if there is drift or not, it updates all sequences unconditionally. From your discussions with Dilip, I understand we want to reduce the time it takes to REFRESH SEQUENCES at the time of an upgrade. If so, then this might not be a good approach. As not only does the sequence worker have to update all sequences even if they have not drifted, it also has to update the relstate of all these sequences to READY. I propose, we change the logic such that REFRESH SEQUENCES only wakes up the sequence worker, that will reduce the time as most sequences will already be in READY state (unless newly added) and only sequences that have not drifted need to be updated and no catalog update is required for sequence states already in READY state. One downside to this is that, earlier users could issue a REFRESH SEQUENCES and wait to see if all the sequences have returned to the READY state to confirm that the sync has completed, with this approach that advantage is not there. Users might have to use a query to find the sequence values of all the sequences and compare that with the values in the publisher. I have addressed the above comments in the attached patch v6. regards, Ajin Cherian Fujitsu Australia --000000000000866fd6064b8fda78 Content-Type: application/octet-stream; name="v6-0001-Support-automatic-sequence-replication.patch" Content-Disposition: attachment; filename="v6-0001-Support-automatic-sequence-replication.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mm0hylfy0 RnJvbSBlMjYyODdlYTEzNDExMjdjZDcxMzgxZjc4MjgyN2FhYjk4YzMzN2JlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBamluIENoZXJpYW4gPGl0c2FqaW5AZ21haWwuY29tPgpEYXRl OiBUdWUsIDI0IEZlYiAyMDI2IDIxOjM3OjAxICsxMTAwClN1YmplY3Q6IFtQQVRDSCB2Nl0gU3Vw cG9ydCBhdXRvbWF0aWMgc2VxdWVuY2UgcmVwbGljYXRpb24uCgpMb2dpY2FsIHJlcGxpY2F0aW9u IHNlcXVlbmNlcyBjYW4gZHJpZnQgYmV0d2VlbiBwdWJsaXNoZXIgYW5kCnN1YnNjcmliZXIgYXMg dmFsdWVzIGFyZSBjb25zdW1lZCBpbmRlcGVuZGVudGx5IG9uIGVhY2ggbm9kZS4KUHJldmlvdXNs eSwgdGhlIHNlcXVlbmNlIHN5bmMgd29ya2VyIGV4aXRlZCBhZnRlciB0aGUgaW5pdGlhbApzeW5j aHJvbml6YXRpb24sIGFsbG93aW5nIHNlcXVlbmNlcyB0byBkaXZlcmdlIG92ZXIgdGltZS4KClRo aXMgY2hhbmdlIGtlZXBzIHRoZSBzZXF1ZW5jZSBzeW5jIHdvcmtlciBydW5uaW5nIGNvbnRpbnVv dXNseQpzbyBpdCBjYW4gbW9uaXRvciBzZXF1ZW5jZXMgYW5kIHJlc3luY2hyb25pemUgdGhlbSB3 aGVuIGRyaWZ0CmlzIGRldGVjdGVkLiBUaGUgd29ya2VyIHVzZXMgYW4gYWRhcHRpdmUgc2xlZXAg aW50ZXJ2YWw6Cml0IHN0YXJ0cyBhdCAyIHNlY29uZHMsIGRvdWJsZXMgdXAgdG8gYSBtYXhpbXVt IG9mIDMwIHNlY29uZHMKd2hlbiBubyBkcmlmdCBpcyBvYnNlcnZlZCwgYW5kIHJlc2V0cyB0byB0 aGUgbWluaW11bSBpbnRlcnZhbApvbmNlIGRyaWZ0IGlzIGZvdW5kLgoKU2VxdWVuY2VzIHJlbWFp biBpbiB0aGUgUkVBRFkgc3RhdGUgZHVyaW5nIGNvbnRpbnVvdXMKc3luY2hyb25pemF0aW9uLgoK QXV0aG9yOiBBamluIENoZXJpYW4gPGl0c2FqaW5AZ21haWwuY29tPgpSZXZpZXdlZC1ieTogU2h2 ZXRhIE1hbGlrIDxzaHZldGEubWFsaWtAZ21haWwuY29tPgpSZXZpZXdlZC1ieTogUGV0ZXIgU21p dGggPHNtaXRocGIyMjUwQGdtYWlsLmNvbT4KUmV2aWV3ZWQtYnk6IEFzaHV0b3NoIFNoYXJtYSA8 YXNodS5jb2VrODhAZ21haWwuY29tPgpSZXZpZXdlZC1ieTogQW1pdCBLYXBpbGEgPGFtaXQua2Fw aWxhMTZAZ21haWwuY29tPgotLS0KIGRvYy9zcmMvc2dtbC9sb2dpY2FsLXJlcGxpY2F0aW9uLnNn bWwgICAgICAgICB8ICAyMyArLQogZG9jL3NyYy9zZ21sL3JlZi9hbHRlcl9zdWJzY3JpcHRpb24u c2dtbCAgICAgIHwgICA5IC0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3NlcXVlbmNlLmMgICAgICAg ICAgICAgICB8ICAyNyArKwogLi4uL3JlcGxpY2F0aW9uL2xvZ2ljYWwvc2VxdWVuY2VzeW5jLmMg ICAgICAgIHwgMzE5ICsrKysrKysrKysrKystLS0tLQogc3JjL2JhY2tlbmQvcmVwbGljYXRpb24v bG9naWNhbC9zeW5jdXRpbHMuYyAgIHwgIDQ2ICsrLQogc3JjL2JhY2tlbmQvcmVwbGljYXRpb24v bG9naWNhbC93b3JrZXIuYyAgICAgIHwgIDEyICsKIHNyYy9pbmNsdWRlL2NhdGFsb2cvcGdfc3Vi c2NyaXB0aW9uX3JlbC5oICAgICB8ICAgMSArCiBzcmMvaW5jbHVkZS9jb21tYW5kcy9zZXF1ZW5j ZS5oICAgICAgICAgICAgICAgfCAgIDEgKwogc3JjL2luY2x1ZGUvcmVwbGljYXRpb24vd29ya2Vy X2ludGVybmFsLmggICAgIHwgICAyICstCiBzcmMvdGVzdC9zdWJzY3JpcHRpb24vdC8wMjZfc3Rh dHMucGwgICAgICAgICAgfCAgIDIgKwogc3JjL3Rlc3Qvc3Vic2NyaXB0aW9uL3QvMDM2X3NlcXVl bmNlcy5wbCAgICAgIHwgIDc5ICstLS0tCiAxMSBmaWxlcyBjaGFuZ2VkLCAzMjAgaW5zZXJ0aW9u cygrKSwgMjAxIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RvYy9zcmMvc2dtbC9sb2dpY2Fs LXJlcGxpY2F0aW9uLnNnbWwgYi9kb2Mvc3JjL3NnbWwvbG9naWNhbC1yZXBsaWNhdGlvbi5zZ21s CmluZGV4IDUwMjhmZTlhZjA5Li5iYjUyM2FmNWQzNyAxMDA2NDQKLS0tIGEvZG9jL3NyYy9zZ21s L2xvZ2ljYWwtcmVwbGljYXRpb24uc2dtbAorKysgYi9kb2Mvc3JjL3NnbWwvbG9naWNhbC1yZXBs aWNhdGlvbi5zZ21sCkBAIC0xNzg3LDggKzE3ODcsOSBAQCBQdWJsaWNhdGlvbnM6CiAKICAgPHBh cmE+CiAgICBBIDxmaXJzdHRlcm0+c2VxdWVuY2Ugc3luY2hyb25pemF0aW9uIHdvcmtlcjwvZmly c3R0ZXJtPiB3aWxsIGJlIHN0YXJ0ZWQKLSAgIGFmdGVyIGV4ZWN1dGluZyBhbnkgb2YgdGhlIGFi b3ZlIHN1YnNjcmliZXIgY29tbWFuZHMsIGFuZCB3aWxsIGV4aXQgb25jZSB0aGUKLSAgIHNlcXVl bmNlcyBhcmUgc3luY2hyb25pemVkLgorICAgYWZ0ZXIgZXhlY3V0aW5nIGFueSBvZiB0aGUgYWJv dmUgc3Vic2NyaWJlciBjb21tYW5kcy4gVGhlIHdvcmtlciB3aWxsCisgICByZW1haW4gcnVubmlu ZyBmb3IgdGhlIGxpZmUgb2YgdGhlIHN1YnNjcmlwdGlvbiwgcGVyaW9kaWNhbGx5CisgICBzeW5j aHJvbml6aW5nIGFsbCBwdWJsaXNoZWQgc2VxdWVuY2VzLgogICA8L3BhcmE+CiAgIDxwYXJhPgog ICAgVGhlIGFiaWxpdHkgdG8gbGF1bmNoIGEgc2VxdWVuY2Ugc3luY2hyb25pemF0aW9uIHdvcmtl ciBpcyBsaW1pdGVkIGJ5IHRoZQpAQCAtMTgxNyw3ICsxODE4LDcgQEAgUHVibGljYXRpb25zOgog ICA8c2VjdDIgaWQ9InNlcXVlbmNlcy1vdXQtb2Ytc3luYyI+CiAgICA8dGl0bGU+UmVmcmVzaGlu ZyBPdXQtb2YtU3luYyBTZXF1ZW5jZXM8L3RpdGxlPgogICAgPHBhcmE+Ci0gICAgU3Vic2NyaWJl ciBzZXF1ZW5jZSB2YWx1ZXMgd2lsbCBiZWNvbWUgb3V0IG9mIHN5bmMgYXMgdGhlIHB1Ymxpc2hl cgorICAgIFN1YnNjcmliZXIgc2VxdWVuY2UgdmFsdWVzIGNhbiBiZWNvbWUgb3V0IG9mIHN5bmMg YXMgdGhlIHB1Ymxpc2hlcgogICAgIGFkdmFuY2VzIHRoZW0uCiAgICA8L3BhcmE+CiAgICA8cGFy YT4KQEAgLTIzMzUsMTUgKzIzMzYsMTMgQEAgQ09OVEVYVDogIHByb2Nlc3NpbmcgcmVtb3RlIGRh dGEgZm9yIHJlcGxpY2F0aW9uIG9yaWdpbiAicGdfMTYzOTUiIGR1cmluZyAiSU5TRVIKIAogICAg PGxpc3RpdGVtPgogICAgIDxwYXJhPgotICAgICBJbmNyZW1lbnRhbCBzZXF1ZW5jZSBjaGFuZ2Vz IGFyZSBub3QgcmVwbGljYXRlZC4gIEFsdGhvdWdoIHRoZSBkYXRhIGluCi0gICAgIHNlcmlhbCBv ciBpZGVudGl0eSBjb2x1bW5zIGJhY2tlZCBieSBzZXF1ZW5jZXMgd2lsbCBiZSByZXBsaWNhdGVk IGFzIHBhcnQKLSAgICAgb2YgdGhlIHRhYmxlLCB0aGUgc2VxdWVuY2VzIHRoZW1zZWx2ZXMgZG8g bm90IHJlcGxpY2F0ZSBvbmdvaW5nIGNoYW5nZXMuCi0gICAgIE9uIHRoZSBzdWJzY3JpYmVyLCBh IHNlcXVlbmNlIHdpbGwgcmV0YWluIHRoZSBsYXN0IHZhbHVlIGl0IHN5bmNocm9uaXplZAotICAg ICBmcm9tIHRoZSBwdWJsaXNoZXIuIElmIHRoZSBzdWJzY3JpYmVyIGlzIHVzZWQgYXMgYSByZWFk LW9ubHkgZGF0YWJhc2UsCi0gICAgIHRoZW4gdGhpcyBzaG91bGQgdHlwaWNhbGx5IG5vdCBiZSBh IHByb2JsZW0uICBJZiwgaG93ZXZlciwgc29tZSBraW5kIG9mCi0gICAgIHN3aXRjaG92ZXIgb3Ig ZmFpbG92ZXIgdG8gdGhlIHN1YnNjcmliZXIgZGF0YWJhc2UgaXMgaW50ZW5kZWQsIHRoZW4gdGhl Ci0gICAgIHNlcXVlbmNlcyB3b3VsZCBuZWVkIHRvIGJlIHVwZGF0ZWQgdG8gdGhlIGxhdGVzdCB2 YWx1ZXMsIGVpdGhlciBieQotICAgICBleGVjdXRpbmcgPGxpbmsgbGlua2VuZD0ic3FsLWFsdGVy c3Vic2NyaXB0aW9uLXBhcmFtcy1yZWZyZXNoLXNlcXVlbmNlcyI+CisgICAgIEluY3JlbWVudGFs IHNlcXVlbmNlIGNoYW5nZXMgYXJlIGNvbnRpbnVvdXNseSByZXBsaWNhdGVkLiBJZiwgaG93ZXZl ciwKKyAgICAgc29tZSBraW5kIG9mIHN3aXRjaG92ZXIgb3IgZmFpbG92ZXIgdG8gdGhlIHN1YnNj cmliZXIgZGF0YWJhc2UgaXMKKyAgICAgaW50ZW5kZWQsIHRoZW4gdGhlIHNlcXVlbmNlcyByZXBs aWNhdGlvbiBjb3VsZCBiZSBsYWdnaW5nIGJlaGluZCBhbmQKKyAgICAgdGhlIHNlcXVlbmNlcyBv biB0aGUgc3Vic2NyaWJlciBzaG91bGQgYmUgY29tcGFyZWQgd2l0aCB0aGF0IG9mIHRoZQorICAg ICBwdWJsaXNoZXIgdG8gbWFrZSBzdXJlIHRoYXQgdGhleSBhcmUgdXAgdG8gZGF0ZSwgaWYgbm90 IHRoZXkKKyAgICAgbmVlZCB0byBiZSB1cGRhdGVkIHRvIHRoZSBsYXRlc3QgdmFsdWVzLCBlaXRo ZXIgYnkgZXhlY3V0aW5nCisgICAgIDxsaW5rIGxpbmtlbmQ9InNxbC1hbHRlcnN1YnNjcmlwdGlv bi1wYXJhbXMtcmVmcmVzaC1zZXF1ZW5jZXMiPgogICAgICA8Y29tbWFuZD5BTFRFUiBTVUJTQ1JJ UFRJT04gLi4uIFJFRlJFU0ggU0VRVUVOQ0VTPC9jb21tYW5kPjwvbGluaz4KICAgICAgb3IgYnkg Y29weWluZyB0aGUgY3VycmVudCBkYXRhIGZyb20gdGhlIHB1Ymxpc2hlciAocGVyaGFwcyB1c2lu ZwogICAgICA8Y29tbWFuZD5wZ19kdW1wPC9jb21tYW5kPikgb3IgYnkgZGV0ZXJtaW5pbmcgYSBz dWZmaWNpZW50bHkgaGlnaCB2YWx1ZQpkaWZmIC0tZ2l0IGEvZG9jL3NyYy9zZ21sL3JlZi9hbHRl cl9zdWJzY3JpcHRpb24uc2dtbCBiL2RvYy9zcmMvc2dtbC9yZWYvYWx0ZXJfc3Vic2NyaXB0aW9u LnNnbWwKaW5kZXggNTMxODk5OGU4MGMuLmE4ZGQ3YTZiNDJkIDEwMDY0NAotLS0gYS9kb2Mvc3Jj L3NnbWwvcmVmL2FsdGVyX3N1YnNjcmlwdGlvbi5zZ21sCisrKyBiL2RvYy9zcmMvc2dtbC9yZWYv YWx0ZXJfc3Vic2NyaXB0aW9uLnNnbWwKQEAgLTE5MCwxMSArMTkwLDYgQEAgQUxURVIgU1VCU0NS SVBUSU9OIDxyZXBsYWNlYWJsZSBjbGFzcz0icGFyYW1ldGVyIj5uYW1lPC9yZXBsYWNlYWJsZT4g UkVOQU1FIFRPIDwKICAgICAgICAgICBQcmV2aW91c2x5IHN1YnNjcmliZWQgdGFibGVzIGFyZSBu b3QgY29waWVkLCBldmVuIGlmIGEgdGFibGUncyByb3cKICAgICAgICAgICBmaWx0ZXIgPGxpdGVy YWw+V0hFUkU8L2xpdGVyYWw+IGNsYXVzZSBoYXMgc2luY2UgYmVlbiBtb2RpZmllZC4KICAgICAg ICAgIDwvcGFyYT4KLSAgICAgICAgIDxwYXJhPgotICAgICAgICAgIFByZXZpb3VzbHkgc3Vic2Ny aWJlZCBzZXF1ZW5jZXMgYXJlIG5vdCByZS1zeW5jaHJvbml6ZWQuIFRvIGRvIHRoYXQsCi0gICAg ICAgICAgdXNlIDxsaW5rIGxpbmtlbmQ9InNxbC1hbHRlcnN1YnNjcmlwdGlvbi1wYXJhbXMtcmVm cmVzaC1zZXF1ZW5jZXMiPgotICAgICAgICAgIDxjb21tYW5kPkFMVEVSIFNVQlNDUklQVElPTiAu Li4gUkVGUkVTSCBTRVFVRU5DRVM8L2NvbW1hbmQ+PC9saW5rPi4KLSAgICAgICAgIDwvcGFyYT4K ICAgICAgICAgIDxwYXJhPgogICAgICAgICAgIFNlZSA8eHJlZiBsaW5rZW5kPSJzZXF1ZW5jZS1k ZWZpbml0aW9uLW1pc21hdGNoZXMiLz4gZm9yIHJlY29tbWVuZGF0aW9ucyBvbiBob3cKICAgICAg ICAgICB0byBoYW5kbGUgYW55IHdhcm5pbmdzIGFib3V0IHNlcXVlbmNlIGRlZmluaXRpb24gZGlm ZmVyZW5jZXMgYmV0d2VlbgpAQCAtMjM2LDEwICsyMzEsNiBAQCBBTFRFUiBTVUJTQ1JJUFRJT04g PHJlcGxhY2VhYmxlIGNsYXNzPSJwYXJhbWV0ZXIiPm5hbWU8L3JlcGxhY2VhYmxlPiBSRU5BTUUg VE8gPAogICAgICAgcmVjb21tZW5kYXRpb25zIG9uIGhvdyB0byBoYW5kbGUgYW55IHdhcm5pbmdz IGFib3V0IHNlcXVlbmNlIGRlZmluaXRpb24KICAgICAgIGRpZmZlcmVuY2VzIGJldHdlZW4gdGhl IHB1Ymxpc2hlciBhbmQgdGhlIHN1YnNjcmliZXIuCiAgICAgIDwvcGFyYT4KLSAgICAgPHBhcmE+ Ci0gICAgICBTZWUgPHhyZWYgbGlua2VuZD0ic2VxdWVuY2VzLW91dC1vZi1zeW5jIi8+IGZvciBy ZWNvbW1lbmRhdGlvbnMgb24gaG93IHRvCi0gICAgICBpZGVudGlmeSBhbmQgaGFuZGxlIG91dC1v Zi1zeW5jIHNlcXVlbmNlcy4KLSAgICAgPC9wYXJhPgogICAgIDwvbGlzdGl0ZW0+CiAgICA8L3Zh cmxpc3RlbnRyeT4KIApkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvc2VxdWVuY2Uu YyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3NlcXVlbmNlLmMKaW5kZXggZTFiODA4YmJiNjAuLmFh ODE1ZGQxOWFmIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9jb21tYW5kcy9zZXF1ZW5jZS5jCisr KyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3NlcXVlbmNlLmMKQEAgLTkyOSw2ICs5MjksMzMgQEAg bGFzdHZhbChQR19GVU5DVElPTl9BUkdTKQogCVBHX1JFVFVSTl9JTlQ2NChyZXN1bHQpOwogfQog CisvKgorICogUmVhZCB0aGUgY3VycmVudCBzZXF1ZW5jZSB2YWx1ZXMgKGxhc3RfdmFsdWUgYW5k IGlzX2NhbGxlZCkKKyAqCisgKiBUaGlzIGlzIGEgcmVhZC1vbmx5IG9wZXJhdGlvbiB1c2VkIGJ5 IGxvZ2ljYWwgcmVwbGljYXRpb24gc2VxdWVuY2UKKyAqIHN5bmNocm9uaXphdGlvbiB0byBkZXRl Y3QgZHJpZnQuCisgKi8KK3ZvaWQKK0dldFNlcXVlbmNlKFJlbGF0aW9uIHNlcXJlbCwgaW50NjQg Kmxhc3RfdmFsdWUsIGJvb2wgKmlzX2NhbGxlZCkKK3sKKwlCdWZmZXIJCWJ1ZjsKKwlIZWFwVHVw bGVEYXRhIHNlcXR1cGxlOworCUZvcm1fcGdfc2VxdWVuY2VfZGF0YSBzZXE7CisKKwkvKiBDb25m aXJtIHRoYXQgdGhlIHJlbGF0aW9uIGlzIGEgc2VxdWVuY2UgKi8KKwlBc3NlcnQoc2VxcmVsLT5y ZF9yZWwtPnJlbGtpbmQgPT0gUkVMS0lORF9TRVFVRU5DRSk7CisKKwkvKiBSZWFkIHRoZSBzZXF1 ZW5jZSB0dXBsZSAqLworCXNlcSA9IHJlYWRfc2VxX3R1cGxlKHNlcXJlbCwgJmJ1ZiwgJnNlcXR1 cGxlKTsKKworCS8qIEV4dHJhY3QgdGhlIHZhbHVlcyAqLworCSpsYXN0X3ZhbHVlID0gc2VxLT5s YXN0X3ZhbHVlOworCSppc19jYWxsZWQgPSBzZXEtPmlzX2NhbGxlZDsKKworCS8qIFJlbGVhc2Ug YnVmZmVyICovCisJVW5sb2NrUmVsZWFzZUJ1ZmZlcihidWYpOworfQorCiAvKgogICogTWFpbiBp bnRlcm5hbCBwcm9jZWR1cmUgdGhhdCBoYW5kbGVzIDIgJiAzIGFyZyBmb3JtcyBvZiBTRVRWQUwu CiAgKgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vbG9naWNhbC9zZXF1ZW5j ZXN5bmMuYyBiL3NyYy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwvc2VxdWVuY2VzeW5jLmMK aW5kZXggOWM5MmZkZGQ2MjQuLmRiMDE1ZTliNWRlIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9y ZXBsaWNhdGlvbi9sb2dpY2FsL3NlcXVlbmNlc3luYy5jCisrKyBiL3NyYy9iYWNrZW5kL3JlcGxp Y2F0aW9uL2xvZ2ljYWwvc2VxdWVuY2VzeW5jLmMKQEAgLTE5LDEwICsxOSw2IEBACiAgKiBDUkVB VEUgU1VCU0NSSVBUSU9OCiAgKiBBTFRFUiBTVUJTQ1JJUFRJT04gLi4uIFJFRlJFU0ggUFVCTElD QVRJT04KICAqCi0gKiBFeGVjdXRpbmcgdGhlIGZvbGxvd2luZyBjb21tYW5kIHJlc2V0cyBhbGwg c2VxdWVuY2VzIGluIHRoZSBzdWJzY3JpcHRpb24gdG8KLSAqIHN0YXRlIElOSVQsIHRyaWdnZXJp bmcgcmUtc3luY2hyb25pemF0aW9uOgotICogQUxURVIgU1VCU0NSSVBUSU9OIC4uLiBSRUZSRVNI IFNFUVVFTkNFUwotICoKICAqIFRoZSBhcHBseSB3b3JrZXIgcGVyaW9kaWNhbGx5IHNjYW5zIHBn X3N1YnNjcmlwdGlvbl9yZWwgZm9yIHNlcXVlbmNlcyBpbgogICogSU5JVCBzdGF0ZS4gV2hlbiBz dWNoIHNlcXVlbmNlcyBhcmUgZm91bmQsIGl0IHNwYXducyBhIHNlcXVlbmNlc3luYyB3b3JrZXIK ICAqIHRvIGhhbmRsZSBzeW5jaHJvbml6YXRpb24uCkBAIC0zNiw4ICszMiwyNCBAQAogICogbG9j YWwgc3Vic2NyaWJlciwgYW5kIGZpbmFsbHkgbWFya3MgZWFjaCBzZXF1ZW5jZSBhcyBSRUFEWSB1 cG9uIHN1Y2Nlc3NmdWwKICAqIHN5bmNocm9uaXphdGlvbi4KICAqCisgKiBUaGUgc2VxdWVuY2Vz eW5jIHdvcmtlciB0aGVuIGZldGNoZXMgYWxsIHNlcXVlbmNlcyB0aGF0IGFyZQorICogaW4gdGhl IFJFQURZIHN0YXRlLCBxdWVyaWVzIHRoZSBwdWJsaXNoZXIgZm9yIGN1cnJlbnQgc2VxdWVuY2Ug dmFsdWVzLCBhbmQKKyAqIHVwZGF0ZXMgYW55IHNlcXVlbmNlcyB0aGF0IGhhdmUgZHJpZnRlZCBh bmQgdGhlbiBnb2VzIHRvIHNsZWVwLiBUaGUgc2xlZXAKKyAqIGludGVydmFsIHN0YXJ0cyBhcyBT RVFTWU5DX01JTl9TTEVFUF9NUyBhbmQgZG91YmxlcyBhZnRlciBlYWNoIHdha2UgY3ljbGUKKyAq ICh1cCB0byBTRVFTWU5DX01BWF9TTEVFUF9NUykuIFdoZW4gZHJpZnQgaXMgZGV0ZWN0ZWQsIHRo ZSBpbnRlcnZhbCByZXNldHMgdG8KKyAqIHRoZSBtaW5pbXVtIHRvIGVuc3VyZSB0aW1lbHkgdXBk YXRlcy4KKyAqCisgKiBBZnRlciBDUkVBVEUgU1VCU0NSSVBUSU9OLCBzZXF1ZW5jZXMgYmVnaW4g aW4gdGhlIElOSVQgc3RhdGUuIFNlcXVlbmNlcworICogYWRkZWQgdGhyb3VnaCBBTFRFUiBTVUJT Q1JJUFRJT04uLiBSRUZSRVNIIFBVQkxJQ0FUSU9OIGFsc28gc3RhcnQgaW4gdGhlIElOSVQKKyAq IHN0YXRlLiBBbGwgSU5JVCBzZXF1ZW5jZXMgYXJlIHN5bmNocm9uaXplZCB1bmNvbmRpdGlvbmFs bHksIHRoZW4gdHJhbnNpdGlvbgorICogdG8gdGhlIFJFQURZIHN0YXRlLiBPbmNlIGluIHRoZSBS RUFEWSBzdGF0ZSwgc2VxdWVuY2VzIGFyZSBjaGVja2VkIGZvciBkcmlmdAorICogZnJvbSB0aGUg cHVibGlzaGVyIGFuZCBzeW5jaHJvbml6ZWQgb25seSB3aGVuIGRyaWZ0IGlzIGRldGVjdGVkLgor ICoKICAqIFNlcXVlbmNlIHN0YXRlIHRyYW5zaXRpb25zIGZvbGxvdyB0aGlzIHBhdHRlcm46Ci0g KiAgIElOSVQgLT4gUkVBRFkKKyAqICBJTklUIC0tPiBSRUFEWSAtPi0rCisgKiAgICAgICAgICAg ICBeICAgICAgfCAoY2hlY2svc3luY2hyb25pemUpCisgKiAgICAgICAgICAgICB8ICAgICAgfAor ICogICAgICAgICAgICAgKy0tPC0tLSsKICAqCiAgKiBUbyBhdm9pZCBjcmVhdGluZyB0b28gbWFu eSB0cmFuc2FjdGlvbnMsIHVwIHRvIE1BWF9TRVFVRU5DRVNfU1lOQ19QRVJfQkFUQ0gKICAqIHNl cXVlbmNlcyBhcmUgc3luY2hyb25pemVkIHBlciB0cmFuc2FjdGlvbi4gVGhlIGxvY2tzIG9uIHRo ZSBzZXF1ZW5jZQpAQCAtNzgsMjEgKzkwLDI5IEBAIHR5cGVkZWYgZW51bSBDb3B5U2VxUmVzdWx0 CiAJQ09QWVNFUV9TVUNDRVNTLAogCUNPUFlTRVFfTUlTTUFUQ0gsCiAJQ09QWVNFUV9JTlNVRkZJ Q0lFTlRfUEVSTSwKLQlDT1BZU0VRX1NLSVBQRUQKKwlDT1BZU0VRX1NLSVBQRUQsCisJQ09QWVNF UV9OT19EUklGVCwKIH0gQ29weVNlcVJlc3VsdDsKIAotc3RhdGljIExpc3QgKnNlcWluZm9zID0g TklMOworLyogU2xlZXAgaW50ZXJ2YWxzIGZvciBzeW5jICovCisjZGVmaW5lIFNFUVNZTkNfTUlO X1NMRUVQX01TIDIwMDAJCS8qIDIgc2Vjb25kcyAqLworI2RlZmluZSBTRVFTWU5DX01BWF9TTEVF UF9NUyAzMDAwMAkJLyogMzAgc2Vjb25kcyAqLworCitzdGF0aWMgbG9uZyBzbGVlcF9tcyA9IFNF UVNZTkNfTUlOX1NMRUVQX01TOworCitNZW1vcnlDb250ZXh0IFNlcXVlbmNlU3luY0NvbnRleHQg PSBOVUxMOwogCiAvKgotICogQXBwbHkgd29ya2VyIGRldGVybWluZXMgaWYgc2VxdWVuY2Ugc3lu Y2hyb25pemF0aW9uIGlzIG5lZWRlZC4KKyAqIEFwcGx5IHdvcmtlciBkZXRlcm1pbmVzIHdoZXRo ZXIgYSBzZXF1ZW5jZSBzeW5jIHdvcmtlciBpcyBuZWVkZWQuCiAgKgotICogU3RhcnQgYSBzZXF1 ZW5jZXN5bmMgd29ya2VyIGlmIG9uZSBpcyBub3QgYWxyZWFkeSBydW5uaW5nLiBUaGUgYWN0aXZl Ci0gKiBzZXF1ZW5jZXN5bmMgd29ya2VyIHdpbGwgaGFuZGxlIGFsbCBwZW5kaW5nIHNlcXVlbmNl IHN5bmNocm9uaXphdGlvbi4gSWYgYW55Ci0gKiBzZXF1ZW5jZXMgcmVtYWluIHVuc3luY2hyb25p emVkIGFmdGVyIGl0IGV4aXRzLCBhIG5ldyB3b3JrZXIgY2FuIGJlIHN0YXJ0ZWQKLSAqIGluIHRo ZSBuZXh0IGl0ZXJhdGlvbi4KKyAqIENoZWNrIGlmIHRoZSBzdWJzY3JpcHRpb24gaW5jbHVkZXMg c2VxdWVuY2VzIGFuZCBzdGFydCBhIHNlcXVlbmNlc3luYworICogd29ya2VyIGlmIG9uZSBpcyBu b3QgYWxyZWFkeSBydW5uaW5nLiBUaGUgYWN0aXZlIHNlcXVlbmNlc3luYyB3b3JrZXIgd2lsbAor ICogaGFuZGxlIGFsbCBwZW5kaW5nIHNlcXVlbmNlIHN5bmNocm9uaXphdGlvbi4gSWYgYW55IHNl cXVlbmNlcyByZW1haW4KKyAqIHVuc3luY2hyb25pemVkIGFmdGVyIGl0IGV4aXRzLCBhIG5ldyB3 b3JrZXIgY2FuIGJlIHN0YXJ0ZWQgaW4gdGhlIG5leHQKKyAqIGl0ZXJhdGlvbi4KICAqLwogdm9p ZAotUHJvY2Vzc1NlcXVlbmNlc0ZvclN5bmModm9pZCkKK01heWJlTGF1bmNoU2VxdWVuY2VTeW5j V29ya2VyKHZvaWQpCiB7CiAJTG9naWNhbFJlcFdvcmtlciAqc2VxdWVuY2VzeW5jX3dvcmtlcjsK IAlpbnQJCQluc3luY3dvcmtlcnM7CkBAIC0xNDQsNyArMTY0LDcgQEAgUHJvY2Vzc1NlcXVlbmNl c0ZvclN5bmModm9pZCkKICAqIGZvciB0aGUgZ2l2ZW4gbGlzdCBvZiBzZXF1ZW5jZSBpbmRleGVz LgogICovCiBzdGF0aWMgdm9pZAotZ2V0X3NlcXVlbmNlc19zdHJpbmcoTGlzdCAqc2VxaW5kZXhl cywgU3RyaW5nSW5mbyBidWYpCitnZXRfc2VxdWVuY2VzX3N0cmluZyhMaXN0ICpzZXFpbmRleGVz LCBMaXN0ICpzZXFpbmZvcywgU3RyaW5nSW5mbyBidWYpCiB7CiAJcmVzZXRTdHJpbmdJbmZvKGJ1 Zik7CiAJZm9yZWFjaF9pbnQoc2VxaWR4LCBzZXFpbmRleGVzKQpAQCAtMTcxLDcgKzE5MSw3IEBA IGdldF9zZXF1ZW5jZXNfc3RyaW5nKExpc3QgKnNlcWluZGV4ZXMsIFN0cmluZ0luZm8gYnVmKQog ICovCiBzdGF0aWMgdm9pZAogcmVwb3J0X3NlcXVlbmNlX2Vycm9ycyhMaXN0ICptaXNtYXRjaGVk X3NlcXNfaWR4LCBMaXN0ICppbnN1ZmZwZXJtX3NlcXNfaWR4LAotCQkJCQkgICBMaXN0ICptaXNz aW5nX3NlcXNfaWR4KQorCQkJCQkgICBMaXN0ICptaXNzaW5nX3NlcXNfaWR4LCBMaXN0ICpzZXFp bmZvcykKIHsKIAlTdHJpbmdJbmZvCXNlcXN0cjsKIApAQCAtMTgzLDcgKzIwMyw3IEBAIHJlcG9y dF9zZXF1ZW5jZV9lcnJvcnMoTGlzdCAqbWlzbWF0Y2hlZF9zZXFzX2lkeCwgTGlzdCAqaW5zdWZm cGVybV9zZXFzX2lkeCwKIAogCWlmIChtaXNtYXRjaGVkX3NlcXNfaWR4KQogCXsKLQkJZ2V0X3Nl cXVlbmNlc19zdHJpbmcobWlzbWF0Y2hlZF9zZXFzX2lkeCwgc2Vxc3RyKTsKKwkJZ2V0X3NlcXVl bmNlc19zdHJpbmcobWlzbWF0Y2hlZF9zZXFzX2lkeCwgc2VxaW5mb3MsIHNlcXN0cik7CiAJCWVy ZXBvcnQoV0FSTklORywKIAkJCQllcnJjb2RlKEVSUkNPREVfT0JKRUNUX05PVF9JTl9QUkVSRVFV SVNJVEVfU1RBVEUpLAogCQkJCWVycm1zZ19wbHVyYWwoIm1pc21hdGNoZWQgb3IgcmVuYW1lZCBz ZXF1ZW5jZSBvbiBzdWJzY3JpYmVyICglcykiLApAQCAtMTk0LDcgKzIxNCw3IEBAIHJlcG9ydF9z ZXF1ZW5jZV9lcnJvcnMoTGlzdCAqbWlzbWF0Y2hlZF9zZXFzX2lkeCwgTGlzdCAqaW5zdWZmcGVy bV9zZXFzX2lkeCwKIAogCWlmIChpbnN1ZmZwZXJtX3NlcXNfaWR4KQogCXsKLQkJZ2V0X3NlcXVl bmNlc19zdHJpbmcoaW5zdWZmcGVybV9zZXFzX2lkeCwgc2Vxc3RyKTsKKwkJZ2V0X3NlcXVlbmNl c19zdHJpbmcoaW5zdWZmcGVybV9zZXFzX2lkeCwgc2VxaW5mb3MsIHNlcXN0cik7CiAJCWVyZXBv cnQoV0FSTklORywKIAkJCQllcnJjb2RlKEVSUkNPREVfT0JKRUNUX05PVF9JTl9QUkVSRVFVSVNJ VEVfU1RBVEUpLAogCQkJCWVycm1zZ19wbHVyYWwoImluc3VmZmljaWVudCBwcml2aWxlZ2VzIG9u IHNlcXVlbmNlICglcykiLApAQCAtMjA1LDcgKzIyNSw3IEBAIHJlcG9ydF9zZXF1ZW5jZV9lcnJv cnMoTGlzdCAqbWlzbWF0Y2hlZF9zZXFzX2lkeCwgTGlzdCAqaW5zdWZmcGVybV9zZXFzX2lkeCwK IAogCWlmIChtaXNzaW5nX3NlcXNfaWR4KQogCXsKLQkJZ2V0X3NlcXVlbmNlc19zdHJpbmcobWlz c2luZ19zZXFzX2lkeCwgc2Vxc3RyKTsKKwkJZ2V0X3NlcXVlbmNlc19zdHJpbmcobWlzc2luZ19z ZXFzX2lkeCwgc2VxaW5mb3MsIHNlcXN0cik7CiAJCWVyZXBvcnQoV0FSTklORywKIAkJCQllcnJj b2RlKEVSUkNPREVfT0JKRUNUX05PVF9JTl9QUkVSRVFVSVNJVEVfU1RBVEUpLAogCQkJCWVycm1z Z19wbHVyYWwoIm1pc3Npbmcgc2VxdWVuY2Ugb24gcHVibGlzaGVyICglcykiLApAQCAtMjI5LDcg KzI0OSw4IEBAIHJlcG9ydF9zZXF1ZW5jZV9lcnJvcnMoTGlzdCAqbWlzbWF0Y2hlZF9zZXFzX2lk eCwgTGlzdCAqaW5zdWZmcGVybV9zZXFzX2lkeCwKICAqLwogc3RhdGljIENvcHlTZXFSZXN1bHQK IGdldF9hbmRfdmFsaWRhdGVfc2VxX2luZm8oVHVwbGVUYWJsZVNsb3QgKnNsb3QsIFJlbGF0aW9u ICpzZXF1ZW5jZV9yZWwsCi0JCQkJCQkgIExvZ2ljYWxSZXBTZXF1ZW5jZUluZm8gKipzZXFpbmZv LCBpbnQgKnNlcWlkeCkKKwkJCQkJCSAgTG9naWNhbFJlcFNlcXVlbmNlSW5mbyAqKnNlcWluZm8s IGludCAqc2VxaWR4LAorCQkJCQkJICBMaXN0ICpzZXFpbmZvcykKIHsKIAlib29sCQlpc251bGw7 CiAJaW50CQkJY29sID0gMDsKQEAgLTMyNSwxMSArMzQ2LDEyIEBAIGdldF9hbmRfdmFsaWRhdGVf c2VxX2luZm8oVHVwbGVUYWJsZVNsb3QgKnNsb3QsIFJlbGF0aW9uICpzZXF1ZW5jZV9yZWwsCiB9 CiAKIC8qCi0gKiBBcHBseSByZW1vdGUgc2VxdWVuY2Ugc3RhdGUgdG8gbG9jYWwgc2VxdWVuY2Ug YW5kIG1hcmsgaXQgYXMKLSAqIHN5bmNocm9uaXplZCAoUkVBRFkpLgorICogQXBwbHkgcmVtb3Rl IHNlcXVlbmNlIHN0YXRlIHRvIGxvY2FsIHNlcXVlbmNlLiBJZiB3ZSBhcmUgZG9pbmcgdGhpcwor ICogZm9yIHNlcXVlbmNlcyBpbiB0aGUgSU5JVCBzdGF0ZSwgbW92ZSB0aGVtIHRvIHRoZSBSRUFE WSBzdGF0ZSBvbmNlCisgKiBzeW5jaHJvbml6ZWQuCiAgKi8KIHN0YXRpYyBDb3B5U2VxUmVzdWx0 Ci1jb3B5X3NlcXVlbmNlKExvZ2ljYWxSZXBTZXF1ZW5jZUluZm8gKnNlcWluZm8sIE9pZCBzZXFv d25lcikKK2NvcHlfc2VxdWVuY2UoTG9naWNhbFJlcFNlcXVlbmNlSW5mbyAqc2VxaW5mbywgT2lk IHNlcW93bmVyLCBjaGFyIHJlbHN0YXRlKQogewogCVVzZXJDb250ZXh0IHVjeHQ7CiAJQWNsUmVz dWx0CWFjbHJlc3VsdDsKQEAgLTM2OCwxOSArMzkwLDQ2IEBAIGNvcHlfc2VxdWVuY2UoTG9naWNh bFJlcFNlcXVlbmNlSW5mbyAqc2VxaW5mbywgT2lkIHNlcW93bmVyKQogCiAJLyoKIAkgKiBSZWNv cmQgdGhlIHJlbW90ZSBzZXF1ZW5jZSdzIExTTiBpbiBwZ19zdWJzY3JpcHRpb25fcmVsIGFuZCBt YXJrIHRoZQotCSAqIHNlcXVlbmNlIGFzIFJFQURZLgorCSAqIHNlcXVlbmNlIGFzIFJFQURZIGlm IHVwZGF0aW5nIGEgc2VxdWVuY2UgdGhhdCBpcyBpbiBJTklUIHN0YXRlLgogCSAqLwotCVVwZGF0 ZVN1YnNjcmlwdGlvblJlbFN0YXRlKE15U3Vic2NyaXB0aW9uLT5vaWQsIHNlcW9pZCwgU1VCUkVM X1NUQVRFX1JFQURZLAotCQkJCQkJCSAgIHNlcWluZm8tPnBhZ2VfbHNuLCBmYWxzZSk7CisJaWYg KHJlbHN0YXRlID09IFNVQlJFTF9TVEFURV9JTklUKQorCQlVcGRhdGVTdWJzY3JpcHRpb25SZWxT dGF0ZShNeVN1YnNjcmlwdGlvbi0+b2lkLCBzZXFvaWQsIFNVQlJFTF9TVEFURV9SRUFEWSwKKwkJ CQkJCQkJICAgc2VxaW5mby0+cGFnZV9sc24sIGZhbHNlKTsKIAogCXJldHVybiBDT1BZU0VRX1NV Q0NFU1M7CiB9CiAKKy8qCisgKiBjaGVja19zZXF1ZW5jZV9kcmlmdAorICoKKyAqIENoZWNrIGlm IHRoZSByZW1vdGUgc2VxdWVuY2UgdmFsdWVzIGRpZmZlciBmcm9tIHRoZSBsb2NhbCBzZXF1ZW5j ZS4KKyAqIFJldHVybnMgdHJ1ZS9mYWxzZSBpZiBhbnkgc2VxdWVuY2VzIGRyaWZ0ZWQuCisgKi8K K3N0YXRpYyBib29sCitjaGVja19zZXF1ZW5jZV9kcmlmdChSZWxhdGlvbiBzZXF1ZW5jZV9yZWws IExvZ2ljYWxSZXBTZXF1ZW5jZUluZm8gKnNlcWluZm8pCit7CisJaW50NjQJCWxvY2FsX2xhc3Rf dmFsdWU7CisJYm9vbAkJbG9jYWxfaXNfY2FsbGVkOworCisJLyogR2V0IGN1cnJlbnQgbG9jYWwg c2VxdWVuY2Ugc3RhdGUgKi8KKwlHZXRTZXF1ZW5jZShzZXF1ZW5jZV9yZWwsICZsb2NhbF9sYXN0 X3ZhbHVlLCAmbG9jYWxfaXNfY2FsbGVkKTsKKworCS8qIENoZWNrIGlmIHZhbHVlcyBoYXZlIGRy aWZ0ZWQgYW5kIHJldHVybiBhY2NvcmRpbmdseSAqLworCXJldHVybiAobG9jYWxfbGFzdF92YWx1 ZSAhPSBzZXFpbmZvLT5sYXN0X3ZhbHVlIHx8CisJCWxvY2FsX2lzX2NhbGxlZCAhPSBzZXFpbmZv LT5pc19jYWxsZWQpOworfQorCiAvKgogICogQ29weSBleGlzdGluZyBkYXRhIG9mIHNlcXVlbmNl cyBmcm9tIHRoZSBwdWJsaXNoZXIuCisgKgorICogSWYgcmVsc3RhdGUgaXMgU1VCUkVMX1NUQVRF X1JFQURZLCBvbmx5IHN5bmNocm9uaXplIHNlcXVlbmNlcyB0aGF0CisgKiBoYXZlIGRyaWZ0ZWQg ZnJvbSB0aGVpciBwdWJsaXNoZXIgdmFsdWVzLiBPdGhlcndpc2UsIHN5bmNocm9uaXplCisgKiBh bGwgc2VxdWVuY2VzLgorICoKKyAqIFJldHVybnMgdHJ1ZS9mYWxzZSBpZiBhbnkgc2VxdWVuY2Vz IHdlcmUgYWN0dWFsbHkgY29waWVkLgogICovCi1zdGF0aWMgdm9pZAotY29weV9zZXF1ZW5jZXMo V2FsUmVjZWl2ZXJDb25uICpjb25uKQorc3RhdGljIGJvb2wKK2NvcHlfc2VxdWVuY2VzKFdhbFJl Y2VpdmVyQ29ubiAqY29ubiwgTGlzdCAqc2VxaW5mb3MpCiB7CiAJaW50CQkJY3VyX2JhdGNoX2Jh c2VfaW5kZXggPSAwOwogCWludAkJCW5fc2VxaW5mb3MgPSBsaXN0X2xlbmd0aChzZXFpbmZvcyk7 CkBAIC0zOTAsMTMgKzQzOSwxMCBAQCBjb3B5X3NlcXVlbmNlcyhXYWxSZWNlaXZlckNvbm4gKmNv bm4pCiAJU3RyaW5nSW5mbwlzZXFzdHIgPSBtYWtlU3RyaW5nSW5mbygpOwogCVN0cmluZ0luZm8J Y21kID0gbWFrZVN0cmluZ0luZm8oKTsKIAlNZW1vcnlDb250ZXh0IG9sZGN0eDsKKwlib29sCQlz ZXF1ZW5jZV9jb3BpZWQgPSBmYWxzZTsKIAogI2RlZmluZSBNQVhfU0VRVUVOQ0VTX1NZTkNfUEVS X0JBVENIIDEwMAogCi0JZWxvZyhERUJVRzEsCi0JCSAibG9naWNhbCByZXBsaWNhdGlvbiBzZXF1 ZW5jZSBzeW5jaHJvbml6YXRpb24gZm9yIHN1YnNjcmlwdGlvbiBcIiVzXCIgLSB0b3RhbCB1bnN5 bmNocm9uaXplZDogJWQiLAotCQkgTXlTdWJzY3JpcHRpb24tPm5hbWUsIG5fc2VxaW5mb3MpOwot CiAJd2hpbGUgKGN1cl9iYXRjaF9iYXNlX2luZGV4IDwgbl9zZXFpbmZvcykKIAl7CiAJCU9pZAkJ CXNlcVJvd1tSRU1PVEVfU0VRX0NPTF9DT1VOVF0gPSB7SU5UOE9JRCwgSU5UOE9JRCwKQEAgLTQw Niw2ICs0NTIsNyBAQCBjb3B5X3NlcXVlbmNlcyhXYWxSZWNlaXZlckNvbm4gKmNvbm4pCiAJCWlu dAkJCWJhdGNoX21pc21hdGNoZWRfY291bnQgPSAwOwogCQlpbnQJCQliYXRjaF9za2lwcGVkX2Nv dW50ID0gMDsKIAkJaW50CQkJYmF0Y2hfaW5zdWZmcGVybV9jb3VudCA9IDA7CisJCWludAkJCWJh dGNoX25vX2RyaWZ0ID0gMDsKIAkJaW50CQkJYmF0Y2hfbWlzc2luZ19jb3VudDsKIAkJUmVsYXRp b24Jc2VxdWVuY2VfcmVsID0gTlVMTDsKIApAQCAtNTAxLDQ2ICs1NDgsNjIgQEAgY29weV9zZXF1 ZW5jZXMoV2FsUmVjZWl2ZXJDb25uICpjb25uKQogCQkJfQogCiAJCQlzeW5jX3N0YXR1cyA9IGdl dF9hbmRfdmFsaWRhdGVfc2VxX2luZm8oc2xvdCwgJnNlcXVlbmNlX3JlbCwKLQkJCQkJCQkJCQkJ CQkmc2VxaW5mbywgJnNlcWlkeCk7CisJCQkJCQkJCQkJCQkJJnNlcWluZm8sICZzZXFpZHgsIHNl cWluZm9zKTsKKworCQkJLyoKKwkJCSAqIEZvciBzZXF1ZW5jZXMgaW4gSU5JVCBzdGF0ZSwgYWx3 YXlzIHN5bmMuCisJCQkgKiBPdGhlcndpc2UsIGZvciBzZXF1ZW5jZXMgaW4gUkVBRFkgc3RhdGUs IG9ubHkgc3luYyBpZiB0aGVyZSdzIGRyaWZ0LgorCQkJICovCiAJCQlpZiAoc3luY19zdGF0dXMg PT0gQ09QWVNFUV9TVUNDRVNTKQotCQkJCXN5bmNfc3RhdHVzID0gY29weV9zZXF1ZW5jZShzZXFp bmZvLAotCQkJCQkJCQkJCQlzZXF1ZW5jZV9yZWwtPnJkX3JlbC0+cmVsb3duZXIpOworCQkJewor CQkJCWlmICgoc2VxaW5mby0+cmVsc3RhdGUgPT0gU1VCUkVMX1NUQVRFX0lOSVQpIHx8CisJCQkJ ICAgY2hlY2tfc2VxdWVuY2VfZHJpZnQoc2VxdWVuY2VfcmVsLCBzZXFpbmZvKSkKKwkJCQkJc3lu Y19zdGF0dXMgPSBjb3B5X3NlcXVlbmNlKHNlcWluZm8sCisJCQkJCQkJCQkJCQlzZXF1ZW5jZV9y ZWwtPnJkX3JlbC0+cmVsb3duZXIsCisJCQkJCQkJCQkJCQlzZXFpbmZvLT5yZWxzdGF0ZSk7CisJ CQkJZWxzZQorCQkJCQlzeW5jX3N0YXR1cyA9IENPUFlTRVFfTk9fRFJJRlQ7CisJCQl9CiAKIAkJ CXN3aXRjaCAoc3luY19zdGF0dXMpCiAJCQl7CiAJCQkJY2FzZSBDT1BZU0VRX1NVQ0NFU1M6CiAJ CQkJCWVsb2coREVCVUcxLAotCQkJCQkJICJsb2dpY2FsIHJlcGxpY2F0aW9uIHN5bmNocm9uaXph dGlvbiBmb3Igc3Vic2NyaXB0aW9uIFwiJXNcIiwgc2VxdWVuY2UgXCIlcy4lc1wiIGhhcyBmaW5p c2hlZCIsCisJCQkJCQkgImxvZ2ljYWwgcmVwbGljYXRpb24gc3luY2hyb25pemF0aW8gZm9yIHN1 YnNjcmlwdGlvbiBcIiVzXCIsIHNlcXVlbmNlIFwiJXMuJXNcIiBoYXMgYmVlbiB1cGRhdGVkIiwK IAkJCQkJCSBNeVN1YnNjcmlwdGlvbi0+bmFtZSwgc2VxaW5mby0+bnNwbmFtZSwKIAkJCQkJCSBz ZXFpbmZvLT5zZXFuYW1lKTsKIAkJCQkJYmF0Y2hfc3VjY2VlZGVkX2NvdW50Kys7CisJCQkJCXNl cXVlbmNlX2NvcGllZCA9IHRydWU7CiAJCQkJCWJyZWFrOworCiAJCQkJY2FzZSBDT1BZU0VRX01J U01BVENIOgogCiAJCQkJCS8qCi0JCQkJCSAqIFJlbWVtYmVyIG1pc21hdGNoZWQgc2VxdWVuY2Vz IGluIGEgbG9uZy1saXZlZCBtZW1vcnkKLQkJCQkJICogY29udGV4dCBzaW5jZSB0aGVzZSB3aWxs IGJlIHVzZWQgYWZ0ZXIgdGhlIHRyYW5zYWN0aW9uCi0JCQkJCSAqIGlzIGNvbW1pdHRlZC4KKwkJ CQkJICogUmVtZW1iZXIgbWlzbWF0Y2hlZCBzZXF1ZW5jZXMgaW4gU2VxdWVuY2VTeW5jQ29udGV4 dAorCQkJCQkgKiBzaW5jZSB0aGVzZSB3aWxsIGJlIHVzZWQgYWZ0ZXIgdGhlIHRyYW5zYWN0aW9u IGlzCisJCQkJCSAqIGNvbW1pdHRlZC4KIAkJCQkJICovCi0JCQkJCW9sZGN0eCA9IE1lbW9yeUNv bnRleHRTd2l0Y2hUbyhBcHBseUNvbnRleHQpOworCQkJCQlvbGRjdHggPSBNZW1vcnlDb250ZXh0 U3dpdGNoVG8oU2VxdWVuY2VTeW5jQ29udGV4dCk7CiAJCQkJCW1pc21hdGNoZWRfc2Vxc19pZHgg PSBsYXBwZW5kX2ludChtaXNtYXRjaGVkX3NlcXNfaWR4LAogCQkJCQkJCQkJCQkJCSAgc2VxaWR4 KTsKIAkJCQkJTWVtb3J5Q29udGV4dFN3aXRjaFRvKG9sZGN0eCk7CiAJCQkJCWJhdGNoX21pc21h dGNoZWRfY291bnQrKzsKIAkJCQkJYnJlYWs7CisKIAkJCQljYXNlIENPUFlTRVFfSU5TVUZGSUNJ RU5UX1BFUk06CiAKIAkJCQkJLyoKLQkJCQkJICogUmVtZW1iZXIgc2VxdWVuY2VzIHdpdGggaW5z dWZmaWNpZW50IHByaXZpbGVnZXMgaW4gYQotCQkJCQkgKiBsb25nLWxpdmVkIG1lbW9yeSBjb250 ZXh0IHNpbmNlIHRoZXNlIHdpbGwgYmUgdXNlZAotCQkJCQkgKiBhZnRlciB0aGUgdHJhbnNhY3Rp b24gaXMgY29tbWl0dGVkLgorCQkJCQkgKiBSZW1lbWJlciBzZXF1ZW5jZXMgd2l0aCBpbnN1ZmZp Y2llbnQgcHJpdmlsZWdlcyBpbgorCQkJCQkgKiBTZXF1ZW5jZVN5bmNDb250ZXh0IHNpbmNlIHRo ZXNlIHdpbGwgYmUgdXNlZCBhZnRlciB0aGUKKwkJCQkJICogdHJhbnNhY3Rpb24gaXMgY29tbWl0 dGVkLgogCQkJCQkgKi8KLQkJCQkJb2xkY3R4ID0gTWVtb3J5Q29udGV4dFN3aXRjaFRvKEFwcGx5 Q29udGV4dCk7CisJCQkJCW9sZGN0eCA9IE1lbW9yeUNvbnRleHRTd2l0Y2hUbyhTZXF1ZW5jZVN5 bmNDb250ZXh0KTsKIAkJCQkJaW5zdWZmcGVybV9zZXFzX2lkeCA9IGxhcHBlbmRfaW50KGluc3Vm ZnBlcm1fc2Vxc19pZHgsCiAJCQkJCQkJCQkJCQkJICBzZXFpZHgpOwogCQkJCQlNZW1vcnlDb250 ZXh0U3dpdGNoVG8ob2xkY3R4KTsKIAkJCQkJYmF0Y2hfaW5zdWZmcGVybV9jb3VudCsrOwogCQkJ CQlicmVhazsKKwogCQkJCWNhc2UgQ09QWVNFUV9TS0lQUEVEOgogCiAJCQkJCS8qCkBAIC01NTgs NiArNjIxLDE1IEBAIGNvcHlfc2VxdWVuY2VzKFdhbFJlY2VpdmVyQ29ubiAqY29ubikKIAkJCQkJ CWJhdGNoX3NraXBwZWRfY291bnQrKzsKIAkJCQkJfQogCQkJCQlicmVhazsKKworCQkJCWNhc2Ug Q09QWVNFUV9OT19EUklGVDoKKwkJCQkJLyogTm90aGluZyB0byBkbyAqLworCQkJCQliYXRjaF9u b19kcmlmdCsrOworCQkJCQlicmVhazsKKworCQkJCWRlZmF1bHQ6CisJCQkJCWVsb2coRVJST1Is ICJ1bnJlY29nbml6ZWQgU2VxdWVuY2UgcmVwbGljYXRpb24gcmVzdWx0OiAlZCIsIChpbnQpIHN5 bmNfc3RhdHVzKTsKKwogCQkJfQogCiAJCQlpZiAoc2VxdWVuY2VfcmVsKQpAQCAtNTY2LDIwICs2 MzgsMTkgQEAgY29weV9zZXF1ZW5jZXMoV2FsUmVjZWl2ZXJDb25uICpjb25uKQogCiAJCUV4ZWNE cm9wU2luZ2xlVHVwbGVUYWJsZVNsb3Qoc2xvdCk7CiAJCXdhbHJjdl9jbGVhcl9yZXN1bHQocmVz KTsKLQkJcmVzZXRTdHJpbmdJbmZvKHNlcXN0cik7Ci0JCXJlc2V0U3RyaW5nSW5mbyhjbWQpOwog CiAJCWJhdGNoX21pc3NpbmdfY291bnQgPSBiYXRjaF9zaXplIC0gKGJhdGNoX3N1Y2NlZWRlZF9j b3VudCArCiAJCQkJCQkJCQkJCWJhdGNoX21pc21hdGNoZWRfY291bnQgKwogCQkJCQkJCQkJCQli YXRjaF9pbnN1ZmZwZXJtX2NvdW50ICsKLQkJCQkJCQkJCQkJYmF0Y2hfc2tpcHBlZF9jb3VudCk7 CisJCQkJCQkJCQkJCWJhdGNoX3NraXBwZWRfY291bnQgKworCQkJCQkJCQkJCQliYXRjaF9ub19k cmlmdCk7CiAKIAkJZWxvZyhERUJVRzEsCi0JCQkgImxvZ2ljYWwgcmVwbGljYXRpb24gc2VxdWVu Y2Ugc3luY2hyb25pemF0aW9uIGZvciBzdWJzY3JpcHRpb24gXCIlc1wiIC0gYmF0Y2ggIyVkID0g JWQgYXR0ZW1wdGVkLCAlZCBzdWNjZWVkZWQsICVkIG1pc21hdGNoZWQsICVkIGluc3VmZmljaWVu dCBwZXJtaXNzaW9uLCAlZCBtaXNzaW5nIGZyb20gcHVibGlzaGVyLCAlZCBza2lwcGVkIiwKLQkJ CSBNeVN1YnNjcmlwdGlvbi0+bmFtZSwKLQkJCSAoY3VyX2JhdGNoX2Jhc2VfaW5kZXggLyBNQVhf U0VRVUVOQ0VTX1NZTkNfUEVSX0JBVENIKSArIDEsCi0JCQkgYmF0Y2hfc2l6ZSwgYmF0Y2hfc3Vj Y2VlZGVkX2NvdW50LCBiYXRjaF9taXNtYXRjaGVkX2NvdW50LAotCQkJIGJhdGNoX2luc3VmZnBl cm1fY291bnQsIGJhdGNoX21pc3NpbmdfY291bnQsIGJhdGNoX3NraXBwZWRfY291bnQpOworCQkJ ImxvZ2ljYWwgcmVwbGljYXRpb24gc2VxdWVuY2Ugc3luY2hyb25pemF0aW9uIGZvciBzdWJzY3Jp cHRpb24gXCIlc1wiIC0gYmF0Y2ggIyVkID0gJWQgYXR0ZW1wdGVkLCAlZCBzdWNjZWVkZWQsICVk IG1pc21hdGNoZWQsICVkIGluc3VmZmljaWVudCBwZXJtaXNzaW9uLCAlZCBtaXNzaW5nIGZyb20g cHVibGlzaGVyLCAlZCBza2lwcGVkLCAlZCBubyBkcmlmdCIsCisJCQlNeVN1YnNjcmlwdGlvbi0+ bmFtZSwKKwkJCShjdXJfYmF0Y2hfYmFzZV9pbmRleCAvIE1BWF9TRVFVRU5DRVNfU1lOQ19QRVJf QkFUQ0gpICsgMSwKKwkJCWJhdGNoX3NpemUsIGJhdGNoX3N1Y2NlZWRlZF9jb3VudCwgYmF0Y2hf bWlzbWF0Y2hlZF9jb3VudCwKKwkJCWJhdGNoX2luc3VmZnBlcm1fY291bnQsIGJhdGNoX21pc3Np bmdfY291bnQsIGJhdGNoX3NraXBwZWRfY291bnQsIGJhdGNoX25vX2RyaWZ0KTsKIAogCQkvKiBD b21taXQgdGhpcyBiYXRjaCwgYW5kIHByZXBhcmUgZm9yIG5leHQgYmF0Y2ggKi8KIAkJQ29tbWl0 VHJhbnNhY3Rpb25Db21tYW5kKCk7CkBAIC02MDcsNTEgKzY3OCw1NSBAQCBjb3B5X3NlcXVlbmNl cyhXYWxSZWNlaXZlckNvbm4gKmNvbm4pCiAKIAkvKiBSZXBvcnQgbWlzbWF0Y2hlcywgcGVybWlz c2lvbiBpc3N1ZXMsIG9yIG1pc3Npbmcgc2VxdWVuY2VzICovCiAJcmVwb3J0X3NlcXVlbmNlX2Vy cm9ycyhtaXNtYXRjaGVkX3NlcXNfaWR4LCBpbnN1ZmZwZXJtX3NlcXNfaWR4LAotCQkJCQkJICAg bWlzc2luZ19zZXFzX2lkeCk7CisJCQkJCQkgICBtaXNzaW5nX3NlcXNfaWR4LCBzZXFpbmZvcyk7 CisKKwlyZXR1cm4gc2VxdWVuY2VfY29waWVkOwogfQogCiAvKgogICogSWRlbnRpZmllcyBzZXF1 ZW5jZXMgdGhhdCByZXF1aXJlIHN5bmNocm9uaXphdGlvbiBhbmQgaW5pdGlhdGVzIHRoZQogICog c3luY2hyb25pemF0aW9uIHByb2Nlc3MuCisgKgorICogUmV0dXJucyB0cnVlIGlmIHNlcXVlbmNl cyBoYXZlIGJlZW4gdXBkYXRlZC4KICAqLwotc3RhdGljIHZvaWQKLUxvZ2ljYWxSZXBTeW5jU2Vx dWVuY2VzKHZvaWQpCitzdGF0aWMgYm9vbAorTG9naWNhbFJlcFN5bmNTZXF1ZW5jZXMoV2FsUmVj ZWl2ZXJDb25uICpjb25uKQogewotCWNoYXIJICAgKmVycjsKLQlib29sCQltdXN0X3VzZV9wYXNz d29yZDsKIAlSZWxhdGlvbglyZWw7CiAJSGVhcFR1cGxlCXR1cDsKLQlTY2FuS2V5RGF0YSBza2V5 WzJdOworCVNjYW5LZXlEYXRhIHNrZXlbMV07CiAJU3lzU2NhbkRlc2Mgc2NhbjsKIAlPaWQJCQlz dWJpZCA9IE15TG9naWNhbFJlcFdvcmtlci0+c3ViaWQ7Ci0JU3RyaW5nSW5mb0RhdGEgYXBwX25h bWU7CisJYm9vbAkJc2VxdWVuY2VfY29waWVkID0gZmFsc2U7CisJTGlzdAkgICAqc2VxaW5mb3Mg PSBOSUw7CisJTWVtb3J5Q29udGV4dCBvbGRjdHg7CisKKwlBc3NlcnQoU2VxdWVuY2VTeW5jQ29u dGV4dCk7CiAKIAlTdGFydFRyYW5zYWN0aW9uQ29tbWFuZCgpOwogCiAJcmVsID0gdGFibGVfb3Bl bihTdWJzY3JpcHRpb25SZWxSZWxhdGlvbklkLCBBY2Nlc3NTaGFyZUxvY2spOwogCisJLyogU2Nh biBmb3IgYWxsIHNlcXVlbmNlcyBiZWxvbmdpbmcgdG8gdGhpcyBzdWJzY3JpcHRpb24gKi8KIAlT Y2FuS2V5SW5pdCgmc2tleVswXSwKIAkJCQlBbnVtX3BnX3N1YnNjcmlwdGlvbl9yZWxfc3JzdWJp ZCwKIAkJCQlCVEVxdWFsU3RyYXRlZ3lOdW1iZXIsIEZfT0lERVEsCiAJCQkJT2JqZWN0SWRHZXRE YXR1bShzdWJpZCkpOwogCi0JU2NhbktleUluaXQoJnNrZXlbMV0sCi0JCQkJQW51bV9wZ19zdWJz Y3JpcHRpb25fcmVsX3Nyc3Vic3RhdGUsCi0JCQkJQlRFcXVhbFN0cmF0ZWd5TnVtYmVyLCBGX0NI QVJFUSwKLQkJCQlDaGFyR2V0RGF0dW0oU1VCUkVMX1NUQVRFX0lOSVQpKTsKLQogCXNjYW4gPSBz eXN0YWJsZV9iZWdpbnNjYW4ocmVsLCBJbnZhbGlkT2lkLCBmYWxzZSwKLQkJCQkJCQkgIE5VTEws IDIsIHNrZXkpOworCQkJCQkJCSAgTlVMTCwgMSwgc2tleSk7CisKIAl3aGlsZSAoSGVhcFR1cGxl SXNWYWxpZCh0dXAgPSBzeXN0YWJsZV9nZXRuZXh0KHNjYW4pKSkKIAl7CiAJCUZvcm1fcGdfc3Vi c2NyaXB0aW9uX3JlbCBzdWJyZWw7CiAJCUxvZ2ljYWxSZXBTZXF1ZW5jZUluZm8gKnNlcTsKIAkJ UmVsYXRpb24Jc2VxdWVuY2VfcmVsOwotCQlNZW1vcnlDb250ZXh0IG9sZGN0eDsKKwkJY2hhcgkJ cmVsc3RhdGU7CiAKIAkJQ0hFQ0tfRk9SX0lOVEVSUlVQVFMoKTsKIAogCQlzdWJyZWwgPSAoRm9y bV9wZ19zdWJzY3JpcHRpb25fcmVsKSBHRVRTVFJVQ1QodHVwKTsKKwkJcmVsc3RhdGUgPSBzdWJy ZWwtPnNyc3Vic3RhdGU7CiAKIAkJc2VxdWVuY2VfcmVsID0gdHJ5X3RhYmxlX29wZW4oc3VicmVs LT5zcnJlbGlkLCBSb3dFeGNsdXNpdmVMb2NrKTsKIApAQCAtNjY2LDE2ICs3NDEsMTkgQEAgTG9n aWNhbFJlcFN5bmNTZXF1ZW5jZXModm9pZCkKIAkJCWNvbnRpbnVlOwogCQl9CiAKKwkJQXNzZXJ0 KHJlbHN0YXRlID09IFNVQlJFTF9TVEFURV9JTklUIHx8IHJlbHN0YXRlID09IFNVQlJFTF9TVEFU RV9SRUFEWSk7CisKIAkJLyoKIAkJICogV29ya2VyIG5lZWRzIHRvIHByb2Nlc3Mgc2VxdWVuY2Vz IGFjcm9zcyB0cmFuc2FjdGlvbiBib3VuZGFyeSwgc28KLQkJICogYWxsb2NhdGUgdGhlbSB1bmRl ciBsb25nLWxpdmVkIGNvbnRleHQuCisJCSAqIGFsbG9jYXRlIHRoZW0gdW5kZXIgU2VxdWVuY2VT eW5jQ29udGV4dC4KIAkJICovCi0JCW9sZGN0eCA9IE1lbW9yeUNvbnRleHRTd2l0Y2hUbyhBcHBs eUNvbnRleHQpOworCQlvbGRjdHggPSBNZW1vcnlDb250ZXh0U3dpdGNoVG8oU2VxdWVuY2VTeW5j Q29udGV4dCk7CiAKIAkJc2VxID0gcGFsbG9jMF9vYmplY3QoTG9naWNhbFJlcFNlcXVlbmNlSW5m byk7CiAJCXNlcS0+bG9jYWxyZWxpZCA9IHN1YnJlbC0+c3JyZWxpZDsKIAkJc2VxLT5uc3BuYW1l ID0gZ2V0X25hbWVzcGFjZV9uYW1lKFJlbGF0aW9uR2V0TmFtZXNwYWNlKHNlcXVlbmNlX3JlbCkp OwogCQlzZXEtPnNlcW5hbWUgPSBwc3RyZHVwKFJlbGF0aW9uR2V0UmVsYXRpb25OYW1lKHNlcXVl bmNlX3JlbCkpOworCQlzZXEtPnJlbHN0YXRlID0gcmVsc3RhdGU7CiAJCXNlcWluZm9zID0gbGFw cGVuZChzZXFpbmZvcywgc2VxKTsKIAogCQlNZW1vcnlDb250ZXh0U3dpdGNoVG8ob2xkY3R4KTsK QEAgLTY5MywzNiArNzcxLDIzIEBAIExvZ2ljYWxSZXBTeW5jU2VxdWVuY2VzKHZvaWQpCiAJICog RXhpdCBlYXJseSBpZiBubyBjYXRhbG9nIGVudHJpZXMgZm91bmQsIGxpa2VseSBkdWUgdG8gY29u Y3VycmVudCBkcm9wcy4KIAkgKi8KIAlpZiAoIXNlcWluZm9zKQotCQlyZXR1cm47CisJCXJldHVy biBmYWxzZTsKIAotCS8qIElzIHRoZSB1c2Ugb2YgYSBwYXNzd29yZCBtYW5kYXRvcnk/ICovCi0J bXVzdF91c2VfcGFzc3dvcmQgPSBNeVN1YnNjcmlwdGlvbi0+cGFzc3dvcmRyZXF1aXJlZCAmJgot CQkhTXlTdWJzY3JpcHRpb24tPm93bmVyc3VwZXJ1c2VyOworCW9sZGN0eCA9IE1lbW9yeUNvbnRl eHRTd2l0Y2hUbyhTZXF1ZW5jZVN5bmNDb250ZXh0KTsKIAotCWluaXRTdHJpbmdJbmZvKCZhcHBf bmFtZSk7Ci0JYXBwZW5kU3RyaW5nSW5mbygmYXBwX25hbWUsICJwZ18ldV9zZXF1ZW5jZV9zeW5j XyIgVUlOVDY0X0ZPUk1BVCwKLQkJCQkJIE15U3Vic2NyaXB0aW9uLT5vaWQsIEdldFN5c3RlbUlk ZW50aWZpZXIoKSk7CisJLyogUHJvY2VzcyBzZXF1ZW5jZXMgKi8KKwlzZXF1ZW5jZV9jb3BpZWQg PSBjb3B5X3NlcXVlbmNlcyhjb25uLCBzZXFpbmZvcyk7CiAKLQkvKgotCSAqIEVzdGFibGlzaCB0 aGUgY29ubmVjdGlvbiB0byB0aGUgcHVibGlzaGVyIGZvciBzZXF1ZW5jZSBzeW5jaHJvbml6YXRp b24uCi0JICovCi0JTG9nUmVwV29ya2VyV2FsUmN2Q29ubiA9Ci0JCXdhbHJjdl9jb25uZWN0KE15 U3Vic2NyaXB0aW9uLT5jb25uaW5mbywgdHJ1ZSwgdHJ1ZSwKLQkJCQkJICAgbXVzdF91c2VfcGFz c3dvcmQsCi0JCQkJCSAgIGFwcF9uYW1lLmRhdGEsICZlcnIpOwotCWlmIChMb2dSZXBXb3JrZXJX YWxSY3ZDb25uID09IE5VTEwpCi0JCWVyZXBvcnQoRVJST1IsCi0JCQkJZXJyY29kZShFUlJDT0RF X0NPTk5FQ1RJT05fRkFJTFVSRSksCi0JCQkJZXJybXNnKCJzZXF1ZW5jZXN5bmMgd29ya2VyIGZv ciBzdWJzY3JpcHRpb24gXCIlc1wiIGNvdWxkIG5vdCBjb25uZWN0IHRvIHRoZSBwdWJsaXNoZXI6 ICVzIiwKLQkJCQkJICAgTXlTdWJzY3JpcHRpb24tPm5hbWUsIGVycikpOwotCi0JcGZyZWUoYXBw X25hbWUuZGF0YSk7Ci0KLQljb3B5X3NlcXVlbmNlcyhMb2dSZXBXb3JrZXJXYWxSY3ZDb25uKTsK KwlNZW1vcnlDb250ZXh0U3dpdGNoVG8ob2xkY3R4KTsKKworCS8qIENsZWFudXAgdGhlIG1lbW9y eS4gKi8KKwlNZW1vcnlDb250ZXh0UmVzZXQoU2VxdWVuY2VTeW5jQ29udGV4dCk7CisKKwlyZXR1 cm4gc2VxdWVuY2VfY29waWVkOwogfQogCiAvKgotICogRXhlY3V0ZSB0aGUgaW5pdGlhbCBzeW5j IHdpdGggZXJyb3IgaGFuZGxpbmcuIERpc2FibGUgdGhlIHN1YnNjcmlwdGlvbiwKKyAqIEV4ZWN1 dGUgdGhlIHNlcXVlbmNlIHN5bmMgd2l0aCBlcnJvciBoYW5kbGluZy4gRGlzYWJsZSB0aGUgc3Vi c2NyaXB0aW9uLAogICogaWYgcmVxdWlyZWQuCiAgKgogICogTm90ZSB0aGF0IHdlIGRvbid0IGhh bmRsZSBGQVRBTCBlcnJvcnMgd2hpY2ggYXJlIHByb2JhYmx5IGJlY2F1c2Ugb2Ygc3lzdGVtCkBA IC03MzUsOCArODAwLDc2IEBAIHN0YXJ0X3NlcXVlbmNlX3N5bmModm9pZCkKIAogCVBHX1RSWSgp OwogCXsKLQkJLyogQ2FsbCBpbml0aWFsIHN5bmMuICovCi0JCUxvZ2ljYWxSZXBTeW5jU2VxdWVu Y2VzKCk7CisJCWNoYXIgICAgICAgKmVycjsKKwkJYm9vbAkJbXVzdF91c2VfcGFzc3dvcmQ7CisJ CVN0cmluZ0luZm9EYXRhIGFwcF9uYW1lOworCisJCS8qIElzIHRoZSB1c2Ugb2YgYSBwYXNzd29y ZCBtYW5kYXRvcnk/ICovCisJCW11c3RfdXNlX3Bhc3N3b3JkID0gTXlTdWJzY3JpcHRpb24tPnBh c3N3b3JkcmVxdWlyZWQgJiYKKwkJCSFNeVN1YnNjcmlwdGlvbi0+b3duZXJzdXBlcnVzZXI7CisK KwkJaW5pdFN0cmluZ0luZm8oJmFwcF9uYW1lKTsKKwkJYXBwZW5kU3RyaW5nSW5mbygmYXBwX25h bWUsICJwZ18ldV9zZXF1ZW5jZV9zeW5jXyIgVUlOVDY0X0ZPUk1BVCwKKwkJCQkJCSBNeVN1YnNj cmlwdGlvbi0+b2lkLCBHZXRTeXN0ZW1JZGVudGlmaWVyKCkpOworCisJCS8qCisJCSAqIEVzdGFi bGlzaCB0aGUgY29ubmVjdGlvbiB0byB0aGUgcHVibGlzaGVyIGZvciBzZXF1ZW5jZSBzeW5jaHJv bml6YXRpb24uCisJCSAqLworCQlMb2dSZXBXb3JrZXJXYWxSY3ZDb25uID0KKwkJCXdhbHJjdl9j b25uZWN0KE15U3Vic2NyaXB0aW9uLT5jb25uaW5mbywgdHJ1ZSwgdHJ1ZSwKKwkJCQkJCSAgIG11 c3RfdXNlX3Bhc3N3b3JkLAorCQkJCQkJICAgYXBwX25hbWUuZGF0YSwgJmVycik7CisJCWlmIChM b2dSZXBXb3JrZXJXYWxSY3ZDb25uID09IE5VTEwpCisJCQllcmVwb3J0KEVSUk9SLAorCQkJCQll cnJjb2RlKEVSUkNPREVfQ09OTkVDVElPTl9GQUlMVVJFKSwKKwkJCQkJZXJybXNnKCJzZXF1ZW5j ZXN5bmMgd29ya2VyIGZvciBzdWJzY3JpcHRpb24gXCIlc1wiIGNvdWxkIG5vdCBjb25uZWN0IHRv IHRoZSBwdWJsaXNoZXI6ICVzIiwKKwkJCQkJCSAgIE15U3Vic2NyaXB0aW9uLT5uYW1lLCBlcnIp KTsKKworCQlwZnJlZShhcHBfbmFtZS5kYXRhKTsKKworCQkvKgorCQkgKiBJbml0IHRoZSBTZXF1 ZW5jZVN5bmNDb250ZXh0IHdoaWNoIHdlIGNsZWFuIHVwIGFmdGVyIGVhY2ggc2VxdWVuY2UKKwkJ ICogc3luY2hyb25pemF0aW9uLgorCQkgKi8KKwkJU2VxdWVuY2VTeW5jQ29udGV4dCA9IEFsbG9j U2V0Q29udGV4dENyZWF0ZShBcHBseUNvbnRleHQsCisJCQkJCQkJCQkJCQkJIlNlcXVlbmNlU3lu Y0NvbnRleHQiLAorCQkJCQkJCQkJCQkJCUFMTE9DU0VUX0RFRkFVTFRfU0laRVMpOworCisJCWZv ciAoOzspCisJCXsKKwkJCWJvb2wgc2VxdWVuY2VfY29waWVkID0gZmFsc2U7CisKKwkJCUNIRUNL X0ZPUl9JTlRFUlJVUFRTKCk7CisKKwkJCW1heWJlX3JlcmVhZF9zdWJzY3JpcHRpb24oKTsKKwor CQkJLyoKKwkJCSAqIFN5bmNocm9uaXplIGFsbCBzZXF1ZW5jZXMgKGJvdGggUkVBRFkgYW5kIElO SVQgc3RhdGVzKS4KKwkJCSAqLworCQkJc2VxdWVuY2VfY29waWVkID0gTG9naWNhbFJlcFN5bmNT ZXF1ZW5jZXMoTG9nUmVwV29ya2VyV2FsUmN2Q29ubik7CisKKwkJCS8qIEFkanVzdCBzbGVlcCBp bnRlcnZhbCBiYXNlZCBvbiB3aGV0aGVyIHNlcXVlbmNlcyB3ZXJlIGNvcGllZCBvdmVyICovCisJ CQlpZiAoc2VxdWVuY2VfY29waWVkKQorCQkJeworCQkJCXNsZWVwX21zID0gU0VRU1lOQ19NSU5f U0xFRVBfTVM7CisJCQl9CisJCQllbHNlCisJCQl7CisKKwkJCQkvKgorCQkJCSAqIERvdWJsZSB0 aGUgc2xlZXAgdGltZSwgYnV0IG5vdCBiZXlvbmQKKwkJCQkgKiB0aGUgbWF4aW11bSBhbGxvd2Fi bGUgdmFsdWUuCisJCQkJICovCisJCQkJc2xlZXBfbXMgPSBNaW4oc2xlZXBfbXMgKiAyLCBTRVFT WU5DX01BWF9TTEVFUF9NUyk7CisJCQl9CisKKwkJCS8qIFNsZWVwIGZvciB0aGUgY29uZmlndXJl ZCBpbnRlcnZhbCAqLworCQkJKHZvaWQpIFdhaXRMYXRjaChNeUxhdGNoLAorCQkJCQkJCSBXTF9M QVRDSF9TRVQgfCBXTF9USU1FT1VUIHwgV0xfRVhJVF9PTl9QTV9ERUFUSCwKKwkJCQkJCQkgc2xl ZXBfbXMsCisJCQkJCQkJIFdBSVRfRVZFTlRfTE9HSUNBTF9TWU5DX1NUQVRFX0NIQU5HRSk7CisJ CQlSZXNldExhdGNoKE15TGF0Y2gpOworCQl9CiAJfQogCVBHX0NBVENIKCk7CiAJewpkaWZmIC0t Z2l0IGEvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vbG9naWNhbC9zeW5jdXRpbHMuYyBiL3NyYy9i YWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwvc3luY3V0aWxzLmMKaW5kZXggZWY2MWNhMDQzN2Qu LmU4ZDIxZjU1YWYwIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9yZXBsaWNhdGlvbi9sb2dpY2Fs L3N5bmN1dGlscy5jCisrKyBiL3NyYy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwvc3luY3V0 aWxzLmMKQEAgLTE3Miw3ICsxNzIsOSBAQCBQcm9jZXNzU3luY2luZ1JlbGF0aW9ucyhYTG9nUmVj UHRyIGN1cnJlbnRfbHNuKQogCiAJCWNhc2UgV09SS0VSVFlQRV9BUFBMWToKIAkJCVByb2Nlc3NT eW5jaW5nVGFibGVzRm9yQXBwbHkoY3VycmVudF9sc24pOwotCQkJUHJvY2Vzc1NlcXVlbmNlc0Zv clN5bmMoKTsKKworCQkJLyogQ2hlY2sgaWYgc2VxdWVuY2Ugd29ya2VyIG5lZWRzIHRvIGJlIHN0 YXJ0ZWQgKi8KKwkJCU1heWJlTGF1bmNoU2VxdWVuY2VTeW5jV29ya2VyKCk7CiAJCQlicmVhazsK IAogCQljYXNlIFdPUktFUlRZUEVfU0VRVUVOQ0VTWU5DOgpAQCAtMTkxLDEzICsxOTMsMTMgQEAg UHJvY2Vzc1N5bmNpbmdSZWxhdGlvbnMoWExvZ1JlY1B0ciBjdXJyZW50X2xzbikKICAqCiAgKiBU aGUgcGdfc3Vic2NyaXB0aW9uX3JlbCBjYXRhbG9nIGlzIHNoYXJlZCBieSB0YWJsZXMgYW5kIHNl cXVlbmNlcy4gQ2hhbmdlcwogICogdG8gZWl0aGVyIHNlcXVlbmNlcyBvciB0YWJsZXMgY2FuIGFm ZmVjdCB0aGUgdmFsaWRpdHkgb2YgcmVsYXRpb24gc3RhdGVzLCBzbwotICogd2UgaWRlbnRpZnkg bm9uLVJFQURZIHRhYmxlcyBhbmQgbm9uLVJFQURZIHNlcXVlbmNlcyB0b2dldGhlciB0byBlbnN1 cmUKKyAqIHdlIGlkZW50aWZ5IG5vbi1SRUFEWSB0YWJsZXMgYW5kIHNlcXVlbmNlcyAoaW4gYW55 IHN0YXRlKSB0b2dldGhlciB0byBlbnN1cmUKICAqIGNvbnNpc3RlbmN5LgogICoKICAqIGhhc19w ZW5kaW5nX3N1YnRhYmxlczogdHJ1ZSBpZiB0aGUgc3Vic2NyaXB0aW9uIGhhcyBvbmUgb3IgbW9y ZSB0YWJsZXMgdGhhdAogICogYXJlIG5vdCBpbiBSRUFEWSBzdGF0ZSwgb3RoZXJ3aXNlIGZhbHNl LgogICogaGFzX3BlbmRpbmdfc3Vic2VxdWVuY2VzOiB0cnVlIGlmIHRoZSBzdWJzY3JpcHRpb24g aGFzIG9uZSBvciBtb3JlIHNlcXVlbmNlcwotICogdGhhdCBhcmUgbm90IGluIFJFQURZIHN0YXRl LCBvdGhlcndpc2UgZmFsc2UuCisgKiAoaW4gYW55IHN0YXRlKSwgb3RoZXJ3aXNlIGZhbHNlLgog ICovCiB2b2lkCiBGZXRjaFJlbGF0aW9uU3RhdGVzKGJvb2wgKmhhc19wZW5kaW5nX3N1YnRhYmxl cywKQEAgLTIwNSwyMyArMjA3LDIwIEBAIEZldGNoUmVsYXRpb25TdGF0ZXMoYm9vbCAqaGFzX3Bl bmRpbmdfc3VidGFibGVzLAogCQkJCQlib29sICpzdGFydGVkX3R4KQogewogCS8qCi0JICogaGFz X3N1YnRhYmxlcyBhbmQgaGFzX3N1YnNlcXVlbmNlc19ub25fcmVhZHkgYXJlIGRlY2xhcmVkIGFz IHN0YXRpYywKKwkgKiBoYXNfc3VidGFibGVzIGFuZCBoYXNfc3Vic2VxdWVuY2VzIGFyZSBkZWNs YXJlZCBhcyBzdGF0aWMsCiAJICogc2luY2UgdGhlIHNhbWUgdmFsdWUgY2FuIGJlIHVzZWQgdW50 aWwgdGhlIHN5c3RlbSB0YWJsZSBpcyBpbnZhbGlkYXRlZC4KIAkgKi8KIAlzdGF0aWMgYm9vbCBo YXNfc3VidGFibGVzID0gZmFsc2U7Ci0Jc3RhdGljIGJvb2wgaGFzX3N1YnNlcXVlbmNlc19ub25f cmVhZHkgPSBmYWxzZTsKLQorCXN0YXRpYyBib29sIGhhc19zdWJzZXF1ZW5jZXMgPSBmYWxzZTsK IAkqc3RhcnRlZF90eCA9IGZhbHNlOwotCiAJaWYgKHJlbGF0aW9uX3N0YXRlc192YWxpZGl0eSAh PSBTWU5DX1JFTEFUSU9OU19TVEFURV9WQUxJRCkKIAl7CiAJCU1lbW9yeUNvbnRleHQgb2xkY3R4 OwogCQlMaXN0CSAgICpyc3RhdGVzOworCQlMaXN0CSAgICpzZXFfc3RhdGVzOwogCQlTdWJzY3Jp cHRpb25SZWxTdGF0ZSAqcnN0YXRlOwotCiAJCXJlbGF0aW9uX3N0YXRlc192YWxpZGl0eSA9IFNZ TkNfUkVMQVRJT05TX1NUQVRFX1JFQlVJTERfU1RBUlRFRDsKLQkJaGFzX3N1YnNlcXVlbmNlc19u b25fcmVhZHkgPSBmYWxzZTsKLQorCQloYXNfc3Vic2VxdWVuY2VzID0gZmFsc2U7CiAJCS8qIENs ZWFuIHRoZSBvbGQgbGlzdHMuICovCiAJCWxpc3RfZnJlZV9kZWVwKHRhYmxlX3N0YXRlc19ub3Rf cmVhZHkpOwogCQl0YWJsZV9zdGF0ZXNfbm90X3JlYWR5ID0gTklMOwpAQCAtMjMxLDI3ICsyMzAs MjYgQEAgRmV0Y2hSZWxhdGlvblN0YXRlcyhib29sICpoYXNfcGVuZGluZ19zdWJ0YWJsZXMsCiAJ CQlTdGFydFRyYW5zYWN0aW9uQ29tbWFuZCgpOwogCQkJKnN0YXJ0ZWRfdHggPSB0cnVlOwogCQl9 Ci0KLQkJLyogRmV0Y2ggdGFibGVzIGFuZCBzZXF1ZW5jZXMgdGhhdCBhcmUgaW4gbm9uLVJFQURZ IHN0YXRlLiAqLwotCQlyc3RhdGVzID0gR2V0U3Vic2NyaXB0aW9uUmVsYXRpb25zKE15U3Vic2Ny aXB0aW9uLT5vaWQsIHRydWUsIHRydWUsCisJCS8qIEZldGNoIHRhYmxlcyB0aGF0IGFyZSBpbiBu b24tUkVBRFkgc3RhdGUuICovCisJCXJzdGF0ZXMgPSBHZXRTdWJzY3JpcHRpb25SZWxhdGlvbnMo TXlTdWJzY3JpcHRpb24tPm9pZCwgdHJ1ZSwgZmFsc2UsCiAJCQkJCQkJCQkJICAgdHJ1ZSk7Ci0K KwkJLyogRmV0Y2ggYWxsIHNlcXVlbmNlcyAocmVnYXJkbGVzcyBvZiBzdGF0ZSkuICovCisJCXNl cV9zdGF0ZXMgPSBHZXRTdWJzY3JpcHRpb25SZWxhdGlvbnMoTXlTdWJzY3JpcHRpb24tPm9pZCwg ZmFsc2UsIHRydWUsCisJCQkJCQkJCQkJCSAgZmFsc2UpOwogCQkvKiBBbGxvY2F0ZSB0aGUgdHJh Y2tpbmcgaW5mbyBpbiBhIHBlcm1hbmVudCBtZW1vcnkgY29udGV4dC4gKi8KIAkJb2xkY3R4ID0g TWVtb3J5Q29udGV4dFN3aXRjaFRvKENhY2hlTWVtb3J5Q29udGV4dCk7CiAJCWZvcmVhY2hfcHRy KFN1YnNjcmlwdGlvblJlbFN0YXRlLCBzdWJyZWwsIHJzdGF0ZXMpCiAJCXsKLQkJCWlmIChnZXRf cmVsX3JlbGtpbmQoc3VicmVsLT5yZWxpZCkgPT0gUkVMS0lORF9TRVFVRU5DRSkKLQkJCQloYXNf c3Vic2VxdWVuY2VzX25vbl9yZWFkeSA9IHRydWU7Ci0JCQllbHNlCi0JCQl7Ci0JCQkJcnN0YXRl ID0gcGFsbG9jX29iamVjdChTdWJzY3JpcHRpb25SZWxTdGF0ZSk7Ci0JCQkJbWVtY3B5KHJzdGF0 ZSwgc3VicmVsLCBzaXplb2YoU3Vic2NyaXB0aW9uUmVsU3RhdGUpKTsKLQkJCQl0YWJsZV9zdGF0 ZXNfbm90X3JlYWR5ID0gbGFwcGVuZCh0YWJsZV9zdGF0ZXNfbm90X3JlYWR5LAotCQkJCQkJCQkJ CQkJIHJzdGF0ZSk7Ci0JCQl9CisJCQlyc3RhdGUgPSBwYWxsb2Nfb2JqZWN0KFN1YnNjcmlwdGlv blJlbFN0YXRlKTsKKwkJCW1lbWNweShyc3RhdGUsIHN1YnJlbCwgc2l6ZW9mKFN1YnNjcmlwdGlv blJlbFN0YXRlKSk7CisJCQl0YWJsZV9zdGF0ZXNfbm90X3JlYWR5ID0gbGFwcGVuZCh0YWJsZV9z dGF0ZXNfbm90X3JlYWR5LAorCQkJCQkJCQkJCQkgcnN0YXRlKTsKIAkJfQorCQkvKiBDaGVjayBp ZiB0aGVyZSBhcmUgYW55IHNlcXVlbmNlcy4gKi8KKwkJaGFzX3N1YnNlcXVlbmNlcyA9IChzZXFf c3RhdGVzICE9IE5JTCk7CiAJCU1lbW9yeUNvbnRleHRTd2l0Y2hUbyhvbGRjdHgpOwogCisJCWxp c3RfZnJlZV9kZWVwKHNlcV9zdGF0ZXMpOwogCQkvKgogCQkgKiBEb2VzIHRoZSBzdWJzY3JpcHRp b24gaGF2ZSB0YWJsZXM/CiAJCSAqCkBAIC0yNzcsNSArMjc1LDUgQEAgRmV0Y2hSZWxhdGlvblN0 YXRlcyhib29sICpoYXNfcGVuZGluZ19zdWJ0YWJsZXMsCiAJCSpoYXNfcGVuZGluZ19zdWJ0YWJs ZXMgPSBoYXNfc3VidGFibGVzOwogCiAJaWYgKGhhc19wZW5kaW5nX3N1YnNlcXVlbmNlcykKLQkJ Kmhhc19wZW5kaW5nX3N1YnNlcXVlbmNlcyA9IGhhc19zdWJzZXF1ZW5jZXNfbm9uX3JlYWR5Owor CQkqaGFzX3BlbmRpbmdfc3Vic2VxdWVuY2VzID0gaGFzX3N1YnNlcXVlbmNlczsKIH0KZGlmZiAt LWdpdCBhL3NyYy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwvd29ya2VyLmMgYi9zcmMvYmFj a2VuZC9yZXBsaWNhdGlvbi9sb2dpY2FsL3dvcmtlci5jCmluZGV4IGJhZThjMDExMzkwLi42ZGNl M2NlZDkwYiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vbG9naWNhbC93b3Jr ZXIuYworKysgYi9zcmMvYmFja2VuZC9yZXBsaWNhdGlvbi9sb2dpY2FsL3dvcmtlci5jCkBAIC00 MjIxLDYgKzQyMjEsNyBAQCBMb2dpY2FsUmVwQXBwbHlMb29wKFhMb2dSZWNQdHIgbGFzdF9yZWNl aXZlZCkKIAkJCVByb2Nlc3NDb25maWdGaWxlKFBHQ19TSUdIVVApOwogCQl9CiAKKwogCQlpZiAo cmMgJiBXTF9USU1FT1VUKQogCQl7CiAJCQkvKgpAQCAtNTA5OCw2ICs1MDk5LDkgQEAgbWF5YmVf cmVyZWFkX3N1YnNjcmlwdGlvbih2b2lkKQogCSAqIHdvcmtlciB3b24ndCByZXN0YXJ0IGlmIHRo ZSBzdHJlYW1pbmcgb3B0aW9uJ3MgdmFsdWUgaXMgY2hhbmdlZCBmcm9tCiAJICogJ3BhcmFsbGVs JyB0byBhbnkgb3RoZXIgdmFsdWUgb3IgdGhlIHNlcnZlciBkZWNpZGVzIG5vdCB0byBzdHJlYW0g dGhlCiAJICogaW4tcHJvZ3Jlc3MgdHJhbnNhY3Rpb24uCisJICoKKwkgKiBOb3RlOiBzb21lIHBh cmFtZXRlcnMgbWF5IG5vdCBiZSByZWxldmFudCB0byB0aGUgc2VxdWVuY2Ugc3luYyB3b3JrZXIs CisJICogYnV0IGV4aXQgYW55d2F5LgogCSAqLwogCWlmIChzdHJjbXAobmV3c3ViLT5jb25uaW5m bywgTXlTdWJzY3JpcHRpb24tPmNvbm5pbmZvKSAhPSAwIHx8CiAJCXN0cmNtcChuZXdzdWItPm5h bWUsIE15U3Vic2NyaXB0aW9uLT5uYW1lKSAhPSAwIHx8CkBAIC01MTEzLDYgKzUxMTcsMTAgQEAg bWF5YmVfcmVyZWFkX3N1YnNjcmlwdGlvbih2b2lkKQogCQkJZXJlcG9ydChMT0csCiAJCQkJCShl cnJtc2coImxvZ2ljYWwgcmVwbGljYXRpb24gcGFyYWxsZWwgYXBwbHkgd29ya2VyIGZvciBzdWJz Y3JpcHRpb24gXCIlc1wiIHdpbGwgc3RvcCBiZWNhdXNlIG9mIGEgcGFyYW1ldGVyIGNoYW5nZSIs CiAJCQkJCQkJTXlTdWJzY3JpcHRpb24tPm5hbWUpKSk7CisJCWVsc2UgaWYgKGFtX3NlcXVlbmNl c3luY193b3JrZXIoKSkKKwkJCWVyZXBvcnQoTE9HLAorCQkJCQkoZXJybXNnKCJsb2dpY2FsIHJl cGxpY2F0aW9uIHNlcXVlbmNlIHN5bmNocm9uaXphdGlvbiB3b3JrZXIgZm9yIHN1YnNjcmlwdGlv biBcIiVzXCIgd2lsbCBzdG9wIGJlY2F1c2Ugb2YgYSBwYXJhbWV0ZXIgY2hhbmdlIiwKKwkJCQkJ CQlNeVN1YnNjcmlwdGlvbi0+bmFtZSkpKTsKIAkJZWxzZQogCQkJZXJlcG9ydChMT0csCiAJCQkJ CShlcnJtc2coImxvZ2ljYWwgcmVwbGljYXRpb24gd29ya2VyIGZvciBzdWJzY3JpcHRpb24gXCIl c1wiIHdpbGwgcmVzdGFydCBiZWNhdXNlIG9mIGEgcGFyYW1ldGVyIGNoYW5nZSIsCkBAIC01MTMx LDYgKzUxMzksMTAgQEAgbWF5YmVfcmVyZWFkX3N1YnNjcmlwdGlvbih2b2lkKQogCQkJZXJlcG9y dChMT0csCiAJCQkJCWVycm1zZygibG9naWNhbCByZXBsaWNhdGlvbiBwYXJhbGxlbCBhcHBseSB3 b3JrZXIgZm9yIHN1YnNjcmlwdGlvbiBcIiVzXCIgd2lsbCBzdG9wIGJlY2F1c2UgdGhlIHN1YnNj cmlwdGlvbiBvd25lcidzIHN1cGVydXNlciBwcml2aWxlZ2VzIGhhdmUgYmVlbiByZXZva2VkIiwK IAkJCQkJCSAgIE15U3Vic2NyaXB0aW9uLT5uYW1lKSk7CisJCWVsc2UgaWYgKGFtX3NlcXVlbmNl c3luY193b3JrZXIoKSkKKwkJCWVyZXBvcnQoTE9HLAorCQkJCQllcnJtc2coImxvZ2ljYWwgcmVw bGljYXRpb24gc2VxdWVuY2Ugc3luY2hyb25pemF0aW9uIHdvcmtlciBmb3Igc3Vic2NyaXB0aW9u IFwiJXNcIiB3aWxsIHN0b3AgYmVjYXVzZSB0aGUgc3Vic2NyaXB0aW9uIG93bmVyJ3Mgc3VwZXJ1 c2VyIHByaXZpbGVnZXMgaGF2ZSBiZWVuIHJldm9rZWQiLAorCQkJCQkJCU15U3Vic2NyaXB0aW9u LT5uYW1lKSk7CiAJCWVsc2UKIAkJCWVyZXBvcnQoTE9HLAogCQkJCQllcnJtc2coImxvZ2ljYWwg cmVwbGljYXRpb24gd29ya2VyIGZvciBzdWJzY3JpcHRpb24gXCIlc1wiIHdpbGwgcmVzdGFydCBi ZWNhdXNlIHRoZSBzdWJzY3JpcHRpb24gb3duZXIncyBzdXBlcnVzZXIgcHJpdmlsZWdlcyBoYXZl IGJlZW4gcmV2b2tlZCIsCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9jYXRhbG9nL3BnX3N1YnNj cmlwdGlvbl9yZWwuaCBiL3NyYy9pbmNsdWRlL2NhdGFsb2cvcGdfc3Vic2NyaXB0aW9uX3JlbC5o CmluZGV4IDUwMjY0MGQzMDE4Li44NjU3NGI2OTE2OSAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUv Y2F0YWxvZy9wZ19zdWJzY3JpcHRpb25fcmVsLmgKKysrIGIvc3JjL2luY2x1ZGUvY2F0YWxvZy9w Z19zdWJzY3JpcHRpb25fcmVsLmgKQEAgLTk2LDYgKzk2LDcgQEAgdHlwZWRlZiBzdHJ1Y3QgTG9n aWNhbFJlcFNlcXVlbmNlSW5mbwogCWNoYXIJICAgKnNlcW5hbWU7CiAJY2hhcgkgICAqbnNwbmFt ZTsKIAlPaWQJCQlsb2NhbHJlbGlkOworCWNoYXIJCXJlbHN0YXRlOwogCiAJLyogU2VxdWVuY2Ug aW5mb3JtYXRpb24gcmV0cmlldmVkIGZyb20gdGhlIHB1Ymxpc2hlciBub2RlICovCiAJWExvZ1Jl Y1B0cglwYWdlX2xzbjsKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3NlcXVlbmNl LmggYi9zcmMvaW5jbHVkZS9jb21tYW5kcy9zZXF1ZW5jZS5oCmluZGV4IDJjM2M0YTNmMDc0Li5m MDBlZWE5ZmJkMSAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvY29tbWFuZHMvc2VxdWVuY2UuaAor KysgYi9zcmMvaW5jbHVkZS9jb21tYW5kcy9zZXF1ZW5jZS5oCkBAIC00Nyw2ICs0Nyw3IEBAIGV4 dGVybiBPYmplY3RBZGRyZXNzIEFsdGVyU2VxdWVuY2UoUGFyc2VTdGF0ZSAqcHN0YXRlLCBBbHRl clNlcVN0bXQgKnN0bXQpOwogZXh0ZXJuIHZvaWQgU2VxdWVuY2VDaGFuZ2VQZXJzaXN0ZW5jZShP aWQgcmVsaWQsIGNoYXIgbmV3cmVscGVyc2lzdGVuY2UpOwogZXh0ZXJuIHZvaWQgRGVsZXRlU2Vx dWVuY2VUdXBsZShPaWQgcmVsaWQpOwogZXh0ZXJuIHZvaWQgUmVzZXRTZXF1ZW5jZShPaWQgc2Vx X3JlbGlkKTsKK2V4dGVybiB2b2lkIEdldFNlcXVlbmNlKFJlbGF0aW9uIHNlcXJlbCwgaW50NjQg Kmxhc3RfdmFsdWUsIGJvb2wgKmlzX2NhbGxlZCk7CiBleHRlcm4gdm9pZCBTZXRTZXF1ZW5jZShP aWQgcmVsaWQsIGludDY0IG5leHQsIGJvb2wgaXNjYWxsZWQpOwogZXh0ZXJuIHZvaWQgUmVzZXRT ZXF1ZW5jZUNhY2hlcyh2b2lkKTsKIApkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvcmVwbGljYXRp b24vd29ya2VyX2ludGVybmFsLmggYi9zcmMvaW5jbHVkZS9yZXBsaWNhdGlvbi93b3JrZXJfaW50 ZXJuYWwuaAppbmRleCA0ZWNiZGNmYWRhYy4uYTQxY2IwNDVmMTkgMTAwNjQ0Ci0tLSBhL3NyYy9p bmNsdWRlL3JlcGxpY2F0aW9uL3dvcmtlcl9pbnRlcm5hbC5oCisrKyBiL3NyYy9pbmNsdWRlL3Jl cGxpY2F0aW9uL3dvcmtlcl9pbnRlcm5hbC5oCkBAIC0yODYsNyArMjg2LDcgQEAgZXh0ZXJuIHZv aWQgVXBkYXRlVHdvUGhhc2VTdGF0ZShPaWQgc3Vib2lkLCBjaGFyIG5ld19zdGF0ZSk7CiAKIGV4 dGVybiB2b2lkIFByb2Nlc3NTeW5jaW5nVGFibGVzRm9yU3luYyhYTG9nUmVjUHRyIGN1cnJlbnRf bHNuKTsKIGV4dGVybiB2b2lkIFByb2Nlc3NTeW5jaW5nVGFibGVzRm9yQXBwbHkoWExvZ1JlY1B0 ciBjdXJyZW50X2xzbik7Ci1leHRlcm4gdm9pZCBQcm9jZXNzU2VxdWVuY2VzRm9yU3luYyh2b2lk KTsKK2V4dGVybiB2b2lkIE1heWJlTGF1bmNoU2VxdWVuY2VTeW5jV29ya2VyKHZvaWQpOwogCiBw Z19ub3JldHVybiBleHRlcm4gdm9pZCBGaW5pc2hTeW5jV29ya2VyKHZvaWQpOwogZXh0ZXJuIHZv aWQgSW52YWxpZGF0ZVN5bmNpbmdSZWxTdGF0ZXMoRGF0dW0gYXJnLCBTeXNDYWNoZUlkZW50aWZp ZXIgY2FjaGVpZCwKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L3N1YnNjcmlwdGlvbi90LzAyNl9zdGF0 cy5wbCBiL3NyYy90ZXN0L3N1YnNjcmlwdGlvbi90LzAyNl9zdGF0cy5wbAppbmRleCA1ZDQ1NzA2 MGEwMi4uMmZlMjA5ZjQ2MWYgMTAwNjQ0Ci0tLSBhL3NyYy90ZXN0L3N1YnNjcmlwdGlvbi90LzAy Nl9zdGF0cy5wbAorKysgYi9zcmMvdGVzdC9zdWJzY3JpcHRpb24vdC8wMjZfc3RhdHMucGwKQEAg LTE2LDYgKzE2LDggQEAgJG5vZGVfcHVibGlzaGVyLT5zdGFydDsKICMgQ3JlYXRlIHN1YnNjcmli ZXIgbm9kZS4KIG15ICRub2RlX3N1YnNjcmliZXIgPSBQb3N0Z3JlU1FMOjpUZXN0OjpDbHVzdGVy LT5uZXcoJ3N1YnNjcmliZXInKTsKICRub2RlX3N1YnNjcmliZXItPmluaXQ7Ciskbm9kZV9zdWJz Y3JpYmVyLT5hcHBlbmRfY29uZigncG9zdGdyZXNxbC5jb25mJywKKwkibWF4X2xvZ2ljYWxfcmVw bGljYXRpb25fd29ya2VycyA9IDEwIik7CiAkbm9kZV9zdWJzY3JpYmVyLT5zdGFydDsKIAogCmRp ZmYgLS1naXQgYS9zcmMvdGVzdC9zdWJzY3JpcHRpb24vdC8wMzZfc2VxdWVuY2VzLnBsIGIvc3Jj L3Rlc3Qvc3Vic2NyaXB0aW9uL3QvMDM2X3NlcXVlbmNlcy5wbAppbmRleCA0NzE3ODBhMzU4NS4u MWQ4MTUxOGZlMjIgMTAwNjQ0Ci0tLSBhL3NyYy90ZXN0L3N1YnNjcmlwdGlvbi90LzAzNl9zZXF1 ZW5jZXMucGwKKysrIGIvc3JjL3Rlc3Qvc3Vic2NyaXB0aW9uL3QvMDM2X3NlcXVlbmNlcy5wbApA QCAtNzUsOCArNzUsNyBAQCBpcygkcmVzdWx0LCAnMTAwfHQnLAogCiAjIyMjIyMjIyMjCiAjIyBB TFRFUiBTVUJTQ1JJUFRJT04gLi4uIFJFRlJFU0ggUFVCTElDQVRJT04gc2hvdWxkIGNhdXNlIHN5 bmMgb2YgbmV3Ci0jIHNlcXVlbmNlcyBvZiB0aGUgcHVibGlzaGVyLCBidXQgY2hhbmdlcyB0byBl eGlzdGluZyBzZXF1ZW5jZXMgc2hvdWxkCi0jIG5vdCBiZSBzeW5jZWQuCisjIHNlcXVlbmNlcyBv ZiB0aGUgcHVibGlzaGVyLgogIyMjIyMjIyMjIwogCiAjIENyZWF0ZSBhIG5ldyBzZXF1ZW5jZSAn cmVncmVzc19zMicsIGFuZCB1cGRhdGUgZXhpc3Rpbmcgc2VxdWVuY2UgJ3JlZ3Jlc3NfczEnCkBA IC04NCw5ICs4Myw2IEBAICRub2RlX3B1Ymxpc2hlci0+c2FmZV9wc3FsKAogCSdwb3N0Z3Jlcycs IHFxKAogCUNSRUFURSBTRVFVRU5DRSByZWdyZXNzX3MyOwogCUlOU0VSVCBJTlRPIHJlZ3Jlc3Nf c2VxX3Rlc3QgU0VMRUNUIG5leHR2YWwoJ3JlZ3Jlc3NfczInKSBGUk9NIGdlbmVyYXRlX3Nlcmll cygxLDEwMCk7Ci0KLQktLSBFeGlzdGluZyBzZXF1ZW5jZQotCUlOU0VSVCBJTlRPIHJlZ3Jlc3Nf c2VxX3Rlc3QgU0VMRUNUIG5leHR2YWwoJ3JlZ3Jlc3NfczEnKSBGUk9NIGdlbmVyYXRlX3Nlcmll cygxLDEwMCk7CiApKTsKIAogIyBEbyBBTFRFUiBTVUJTQ1JJUFRJT04gLi4uIFJFRlJFU0ggUFVC TElDQVRJT04KQEAgLTk3LDE5ICs5Myw2IEBAICRyZXN1bHQgPSAkbm9kZV9zdWJzY3JpYmVyLT5z YWZlX3BzcWwoCiAkbm9kZV9zdWJzY3JpYmVyLT5wb2xsX3F1ZXJ5X3VudGlsKCdwb3N0Z3Jlcycs ICRzeW5jZWRfcXVlcnkpCiAgIG9yIGRpZSAiVGltZWQgb3V0IHdoaWxlIHdhaXRpbmcgZm9yIHN1 YnNjcmliZXIgdG8gc3luY2hyb25pemUgZGF0YSI7CiAKLSRyZXN1bHQgPSAkbm9kZV9wdWJsaXNo ZXItPnNhZmVfcHNxbCgKLQkncG9zdGdyZXMnLCBxcSgKLQlTRUxFQ1QgbGFzdF92YWx1ZSwgaXNf Y2FsbGVkIEZST00gcmVncmVzc19zMTsKLSkpOwotaXMoJHJlc3VsdCwgJzIwMHx0JywgJ0NoZWNr IHNlcXVlbmNlIHZhbHVlIGluIHRoZSBwdWJsaXNoZXInKTsKLQotIyBDaGVjayAtIGV4aXN0aW5n IHNlcXVlbmNlICgncmVncmVzc19zMScpIGlzIG5vdCBzeW5jZWQKLSRyZXN1bHQgPSAkbm9kZV9z dWJzY3JpYmVyLT5zYWZlX3BzcWwoCi0JJ3Bvc3RncmVzJywgcXEoCi0JU0VMRUNUIGxhc3RfdmFs dWUsIGlzX2NhbGxlZCBGUk9NIHJlZ3Jlc3NfczE7Ci0pKTsKLWlzKCRyZXN1bHQsICcxMDB8dCcs ICdSRUZSRVNIIFBVQkxJQ0FUSU9OIHdpbGwgbm90IHN5bmMgZXhpc3Rpbmcgc2VxdWVuY2UnKTsK LQogIyBDaGVjayAtIG5ld2x5IHB1Ymxpc2hlZCBzZXF1ZW5jZSAoJ3JlZ3Jlc3NfczInKSBpcyBz eW5jZWQKICRyZXN1bHQgPSAkbm9kZV9zdWJzY3JpYmVyLT5zYWZlX3BzcWwoCiAJJ3Bvc3RncmVz JywgcXEoCkBAIC0xMTksMTYgKzEwMiwxMyBAQCBpcygkcmVzdWx0LCAnMTAwfHQnLAogCSdSRUZS RVNIIFBVQkxJQ0FUSU9OIHdpbGwgc3luYyBuZXdseSBwdWJsaXNoZWQgc2VxdWVuY2UnKTsKIAog IyMjIyMjIyMjIwotIyBUZXN0OiBSRUZSRVNIIFNFUVVFTkNFUyBhbmQgUkVGUkVTSCBQVUJMSUNB VElPTiAoY29weV9kYXRhID0gZmFsc2UpCi0jCi0jIDEuIEFMVEVSIFNVQlNDUklQVElPTiAuLi4g UkVGUkVTSCBTRVFVRU5DRVMgc2hvdWxkIHJlLXN5bmNocm9uaXplIGFsbAotIyAgICBleGlzdGlu ZyBzZXF1ZW5jZXMsIGJ1dCBub3Qgc3luY2hyb25pemUgbmV3bHkgYWRkZWQgb25lcy4KLSMgMi4g QUxURVIgU1VCU0NSSVBUSU9OIC4uLiBSRUZSRVNIIFBVQkxJQ0FUSU9OIHdpdGggKGNvcHlfZGF0 YSA9IGZhbHNlKSBzaG91bGQKLSMgICAgYWxzbyBub3QgdXBkYXRlIHNlcXVlbmNlIHZhbHVlcyBm b3IgbmV3bHkgYWRkZWQgc2VxdWVuY2VzLgorIyBUZXN0OgorIyAxLiBBdXRvbWF0aWMgdXBkYXRl IG9mIGV4aXN0aW5nIHNlcXVlbmNlIHZhbHVlcworIyAyLiBOZXdseSBhZGRlZCBzZXF1ZW5jZXMg YXJlIG5vdCBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQuCiAjIyMjIyMjIyMjCiAKLSMgQ3JlYXRlIGEg bmV3IHNlcXVlbmNlICdyZWdyZXNzX3MzJywgYW5kIHVwZGF0ZSB0aGUgZXhpc3Rpbmcgc2VxdWVu Y2UKLSMgJ3JlZ3Jlc3NfczInLgorIyBDcmVhdGUgYSBuZXcgc2VxdWVuY2UgJ3JlZ3Jlc3NfczMn LCBhbmQgdXBkYXRlIHRoZSBleGlzdGluZyBzZXF1ZW5jZXMKKyMgJ3JlZ3Jlc3NfczInIGFuZCAn cmVncmVzc19zMScuCiAkbm9kZV9wdWJsaXNoZXItPnNhZmVfcHNxbCgKIAkncG9zdGdyZXMnLCBx cSgKIAlDUkVBVEUgU0VRVUVOQ0UgcmVncmVzc19zMzsKQEAgLTEzNiw1MyArMTE2LDI4IEBAICRu b2RlX3B1Ymxpc2hlci0+c2FmZV9wc3FsKAogCiAJLS0gRXhpc3Rpbmcgc2VxdWVuY2UKIAlJTlNF UlQgSU5UTyByZWdyZXNzX3NlcV90ZXN0IFNFTEVDVCBuZXh0dmFsKCdyZWdyZXNzX3MyJykgRlJP TSBnZW5lcmF0ZV9zZXJpZXMoMSwxMDApOworCUlOU0VSVCBJTlRPIHJlZ3Jlc3Nfc2VxX3Rlc3Qg U0VMRUNUIG5leHR2YWwoJ3JlZ3Jlc3NfczEnKSBGUk9NIGdlbmVyYXRlX3NlcmllcygxLDEwMCk7 CiApKTsKIAotIyAxLiBEbyBBTFRFUiBTVUJTQ1JJUFRJT04gLi4uIFJFRlJFU0ggU0VRVUVOQ0VT Ci0kcmVzdWx0ID0gJG5vZGVfc3Vic2NyaWJlci0+c2FmZV9wc3FsKAotCSdwb3N0Z3JlcycsIHFx KAotCUFMVEVSIFNVQlNDUklQVElPTiByZWdyZXNzX3NlcV9zdWIgUkVGUkVTSCBTRVFVRU5DRVM7 Ci0pKTsKLSRub2RlX3N1YnNjcmliZXItPnBvbGxfcXVlcnlfdW50aWwoJ3Bvc3RncmVzJywgJHN5 bmNlZF9xdWVyeSkKLSAgb3IgZGllICJUaW1lZCBvdXQgd2hpbGUgd2FpdGluZyBmb3Igc3Vic2Ny aWJlciB0byBzeW5jaHJvbml6ZSBkYXRhIjsKLQogIyBDaGVjayAtIGV4aXN0aW5nIHNlcXVlbmNl cyAoJ3JlZ3Jlc3NfczEnIGFuZCAncmVncmVzc19zMicpIGFyZSBzeW5jZWQKLSRyZXN1bHQgPSAk bm9kZV9zdWJzY3JpYmVyLT5zYWZlX3BzcWwoCi0JJ3Bvc3RncmVzJywgcXEoCi0JU0VMRUNUIGxh c3RfdmFsdWUsIGlzX2NhbGxlZCBGUk9NIHJlZ3Jlc3NfczE7Ci0pKTsKLWlzKCRyZXN1bHQsICcy MDB8dCcsICdSRUZSRVNIIFNFUVVFTkNFUyB3aWxsIHN5bmMgZXhpc3Rpbmcgc2VxdWVuY2VzJyk7 Ci0kcmVzdWx0ID0gJG5vZGVfc3Vic2NyaWJlci0+c2FmZV9wc3FsKAotCSdwb3N0Z3JlcycsIHFx KAotCVNFTEVDVCBsYXN0X3ZhbHVlLCBpc19jYWxsZWQgRlJPTSByZWdyZXNzX3MyOwotKSk7Ci1p cygkcmVzdWx0LCAnMjAwfHQnLCAnUkVGUkVTSCBTRVFVRU5DRVMgd2lsbCBzeW5jIGV4aXN0aW5n IHNlcXVlbmNlcycpOwogCi0jIENoZWNrIC0gbmV3bHkgcHVibGlzaGVkIHNlcXVlbmNlICgncmVn cmVzc19zMycpIGlzIG5vdCBzeW5jZWQKLSRyZXN1bHQgPSAkbm9kZV9zdWJzY3JpYmVyLT5zYWZl X3BzcWwoCi0JJ3Bvc3RncmVzJywgcXEoCi0JU0VMRUNUIGxhc3RfdmFsdWUsIGlzX2NhbGxlZCBG Uk9NIHJlZ3Jlc3NfczM7Ci0pKTsKLWlzKCRyZXN1bHQsICcxfGYnLAotCSdSRUZSRVNIIFNFUVVF TkNFUyB3aWxsIG5vdCBzeW5jIG5ld2x5IHB1Ymxpc2hlZCBzZXF1ZW5jZScpOworIyBQb2xsIHVu dGlsIHJlZ3Jlc3NfczEgcmVmbGVjdHMgdGhlIHVwZGF0ZWQgc2VxdWVuY2UgdmFsdWUKKyRub2Rl X3N1YnNjcmliZXItPnBvbGxfcXVlcnlfdW50aWwoJ3Bvc3RncmVzJywKKyAgICBxcShTRUxFQ1Qg bGFzdF92YWx1ZSA9IDIwMCBBTkQgaXNfY2FsbGVkID0gJ3QnIEZST00gcmVncmVzc19zMTspKQor ICBvciBkaWUgIlRpbWVkIG91dCB3aGlsZSB3YWl0aW5nIGZvciByZWdyZXNzX3MxIHNlcXVlbmNl IHRvIHN5bmMiOwogCi0jIDIuIERvIEFMVEVSIFNVQlNDUklQVElPTiAuLi4gUkVGUkVTSCBQVUJM SUNBVElPTiB3aXRoIGNvcHlfZGF0YSBhcyBmYWxzZQotJHJlc3VsdCA9ICRub2RlX3N1YnNjcmli ZXItPnNhZmVfcHNxbCgKLQkncG9zdGdyZXMnLCBxcSgKLQlBTFRFUiBTVUJTQ1JJUFRJT04gcmVn cmVzc19zZXFfc3ViIFJFRlJFU0ggUFVCTElDQVRJT04gV0lUSCAoY29weV9kYXRhID0gZmFsc2Up OwotKSk7Ci0kbm9kZV9zdWJzY3JpYmVyLT5wb2xsX3F1ZXJ5X3VudGlsKCdwb3N0Z3JlcycsICRz eW5jZWRfcXVlcnkpCi0gIG9yIGRpZSAiVGltZWQgb3V0IHdoaWxlIHdhaXRpbmcgZm9yIHN1YnNj cmliZXIgdG8gc3luY2hyb25pemUgZGF0YSI7CisjIFBvbGwgdW50aWwgcmVncmVzc19zMiByZWZs ZWN0cyB0aGUgdXBkYXRlZCBzZXF1ZW5jZSB2YWx1ZQorJG5vZGVfc3Vic2NyaWJlci0+cG9sbF9x dWVyeV91bnRpbCgncG9zdGdyZXMnLAorICAgIHFxKFNFTEVDVCBsYXN0X3ZhbHVlID0gMjAwIEFO RCBpc19jYWxsZWQgPSAndCcgRlJPTSByZWdyZXNzX3MyOykpCisgIG9yIGRpZSAiVGltZWQgb3V0 IHdoaWxlIHdhaXRpbmcgZm9yIHJlZ3Jlc3NfczIgc2VxdWVuY2UgdG8gc3luYyI7CiAKLSMgQ2hl Y2sgLSBuZXdseSBwdWJsaXNoZWQgc2VxdWVuY2UgKCdyZWdyZXNzX3MzJykgaXMgbm90IHN5bmNl ZCB3aXRoIGNvcHlfZGF0YQotIyBhcyBmYWxzZS4KKyMgQ2hlY2sgLSBuZXdseSBwdWJsaXNoZWQg c2VxdWVuY2UgKCdyZWdyZXNzX3MzJykgaXMgbm90IHN5bmNlZAogJHJlc3VsdCA9ICRub2RlX3N1 YnNjcmliZXItPnNhZmVfcHNxbCgKIAkncG9zdGdyZXMnLCBxcSgKIAlTRUxFQ1QgbGFzdF92YWx1 ZSwgaXNfY2FsbGVkIEZST00gcmVncmVzc19zMzsKICkpOwogaXMoJHJlc3VsdCwgJzF8ZicsCi0J J1JFRlJFU0ggUFVCTElDQVRJT04gd2lsbCBub3Qgc3luYyBuZXdseSBwdWJsaXNoZWQgc2VxdWVu Y2Ugd2l0aCBjb3B5X2RhdGEgYXMgZmFsc2UnCi0pOworCSdOZXdseSBwdWJsaXNoZWQgc2VxdWVu Y2VzIGFyZSBub3Qgc3luY2VkIGF1dG9tYXRpY2FsbHknKTsKIAogIyMjIyMjIyMjIwogIyBBTFRF UiBTVUJTQ1JJUFRJT04gLi4uIFJFRlJFU0ggUFVCTElDQVRJT04gc2hvdWxkIHJlcG9ydCBhbiBl cnJvciB3aGVuOgotLSAKMi40Ny4zCgo= --000000000000866fd6064b8fda78--