Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1nc6QC-0001vg-JJ for pgsql-hackers@arkaria.postgresql.org; Wed, 06 Apr 2022 14:14:09 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.92) (envelope-from ) id 1nc6QA-0000Ez-FK for pgsql-hackers@arkaria.postgresql.org; Wed, 06 Apr 2022 14:14:06 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1nc6Q9-0000Cr-62 for pgsql-hackers@lists.postgresql.org; Wed, 06 Apr 2022 14:14:06 +0000 Received: from mail-ed1-x52b.google.com ([2a00:1450:4864:20::52b]) by makus.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.92) (envelope-from ) id 1nc6Pz-00042H-7f for pgsql-hackers@lists.postgresql.org; Wed, 06 Apr 2022 14:14:03 +0000 Received: by mail-ed1-x52b.google.com with SMTP id b15so2804643edn.4 for ; Wed, 06 Apr 2022 07:13:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=enterprisedb.com; s=google; h=message-id:date:mime-version:user-agent:subject:content-language:to :cc:references:from:in-reply-to; bh=Fg0db3dc2Z7RWSPzROv2SrrIKjEas9roHA9B0TVFV24=; b=VHQ6YW46U3QYRrL7ZstZmkxm5F4XRlmhTmfuUpmV5p1h7+N9yueLA0F6wKSNn0w4lF aetPiH4V09mRsT7becaSPW8zWGUbMy8wfLUJp8HuSb5ZMhxx6DzACopIcR/Dk7e4Xnqh KbdQXJiKQB028LejWizJAsRUKFV4vySPJBo5cAW6uO9nvP7qdfrwpdcMwyDtlJ0A7xaO o4XWdSsNU54LOWKTaFYOO91EJ1/b+i/9kNDyF0GinybF14a2/U0rdBnvLWhVFWFyC7+E 0PrYvrQp+FQh2aFlkC0Bo3rmd7vFy1VGe+bDlxrkpgkAkNFyhLZ54AO9XqI7+qHqA0h8 MFFg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:date:mime-version:user-agent:subject :content-language:to:cc:references:from:in-reply-to; bh=Fg0db3dc2Z7RWSPzROv2SrrIKjEas9roHA9B0TVFV24=; b=mhWtx4+xfscQgbpxVTwUOVd90L7WQg1cfUxKYni/o6uhe9/JACRpR5wBHe0WZV7wWa SMEoqI1v9PDx9fU3VE9dn91XL8zMizQWNxZ4FqHWpJdkUM0JyI4z6jY7Pmb420XYMe8A Bj8VK6tAtqZ8i3YfR7eAVO//WOa/NBOpHzZS6GopwtD4zRWnICZr+gBpRbFmIcAngezS BaVxMxj1DX9ns/d842ITdazdfpE1iVaGFRt3Qn1SoHkyFK1k5MaUIxUB7fUN7Is+Vsbz yjKOw1jxiRw3QjL+VuPXWqco2VpNLaz5qMr4eVYRneqieeL9F9kq+yvQwxBNukhTILz6 PUtw== X-Gm-Message-State: AOAM530oT80i3xCsn+D/AoF2chzs0aiBAeam6rrEhrunOXyt9d7fRM1W LcoNOVCWrjBHwUIjrGnJO+corOXy8bDfn0ZpmBXHfO67IvsN4wuMO+uQizrw3e48D3Bbxk12aMk eJitJDcMXh5nXQQsQRMuIIHceFsSKaBcWJEfRUaW4Dl9VA2P8prsa6HMs0/mK9scipSnVS4UV6T hjcegPTNgw+QXxqssCyPXUZAIq/93/XUBOLtVrSd8vBDWfhpytKtJ2 X-Google-Smtp-Source: ABdhPJwfcUsSnT/OecIEzaqRtryVl5ukIpNJjEs1HcrVycrouc7poVXKYlofxFrC+FfLOibrzOPP7w== X-Received: by 2002:a05:6402:1cc1:b0:413:2cfb:b6ca with SMTP id ds1-20020a0564021cc100b004132cfbb6camr8790372edb.265.1649254433161; Wed, 06 Apr 2022 07:13:53 -0700 (PDT) Received: from [10.137.0.17] (static-84-42-175-93.net.upcbroadband.cz. [84.42.175.93]) by smtp.gmail.com with ESMTPSA id uz12-20020a170907118c00b006e7475db2d6sm4670341ejb.217.2022.04.06.07.13.51 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Wed, 06 Apr 2022 07:13:52 -0700 (PDT) Content-Type: multipart/mixed; boundary="------------h4MkX15oBsPcg0TtcAqSF4HX" Message-ID: Date: Wed, 6 Apr 2022 16:13:52 +0200 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:91.0) Gecko/20100101 Thunderbird/91.7.0 Subject: Re: logical decoding and replication of sequences Content-Language: en-US To: Amit Kapila Cc: Petr Jelinek , Peter Eisentraut , PostgreSQL Hackers References: <74729cc5-960b-9295-912a-a7c37356a0c4@enterprisedb.com> <9d7635f8-2402-e038-64da-cbc3732ce8cf@enterprisedb.com> <83c682bf-7164-5976-608c-385cc394bb6c@enterprisedb.com> <494bb2d9-0c1c-b429-e6bb-231f00f2c36f@enterprisedb.com> <95345a19-d508-63d1-860a-f5c2f41e8d40@enterprisedb.com> From: Tomas Vondra In-Reply-To: X-CLOUD-SEC-AV-Info: enterprisedb,google_mail,monitor X-CLOUD-SEC-AV-Sent: true X-Gm-Spam: 0 X-Gm-Phishy: 0 List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk This is a multi-part message in MIME format. --------------h4MkX15oBsPcg0TtcAqSF4HX Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit On 4/5/22 12:06, Amit Kapila wrote: > On Mon, Apr 4, 2022 at 3:10 AM Tomas Vondra > wrote: >> >> I did some experiments over the weekend, exploring how to rework the >> sequence decoding in various ways. Let me share some WIP patches, >> hopefully that can be useful for trying more stuff and moving this >> discussion forward. >> >> I tried two things - (1) accumulating sequence increments in global >> array and then doing something with it, and (2) treating all sequence >> increments as regular changes (in a TXN) and then doing something >> special during the replay. Attached are two patchsets, one for each >> approach. >> >> Note: It's important to remember decoding of sequences is not the only >> code affected by this. The logical messages have the same issue, >> certainly when it comes to transactional vs. non-transactional stuff and >> handling of snapshots. Even if the sequence decoding ends up being >> reverted, we still need to fix that, somehow. And my feeling is the >> solutions ought to be pretty similar in both cases. >> >> Now, regarding the two approaches: >> >> (1) accumulating sequences in global hash table >> >> The main problem with regular sequence increments is that those need to >> be non-transactional - a transaction may use a sequence without any >> WAL-logging, if the WAL was written by an earlier transaction. The >> problem is the earlier trasaction might have been rolled back, and thus >> simply discarded by the logical decoding. But we still need to apply >> that, in order not to lose the sequence increment. >> >> The current code just applies those non-transactional increments right >> after decoding the increment, but that does not work because we may not >> have a snapshot at that point. And we only have the snapshot when within >> a transaction (AFAICS) so this queues all changes and then applies the >> changes later. >> >> The changes need to be shared by all transactions, so queueing them in a >> global works fairly well - otherwise we'd have to walk all transactions, >> in order to see if there are relevant sequence increments. >> >> But some increments may be transactional, e.g. when the sequence is >> created or altered in a transaction. To allow tracking this, this uses a >> hash table, with relfilenode as a key. >> >> There's a couple issues with this, though. Firstly, stashing the changes >> outside transactions, it's not included in memory accounting, it's not >> spilled to disk or streamed, etc. I guess fixing this is possible, but >> it's certainly not straightforward, because we mix increments from many >> different transactions. >> >> A bigger issue is that I'm not sure this actually handles the snapshots >> correctly either. >> >> The non-transactional increments affect all transactions, so when >> ReorderBufferProcessSequences gets executed, it processes all of them, >> no matter the source transaction. Can we be sure the snapshot in the >> applying transaction is the same (or "compatible") as the snapshot in >> the source transaction? >> > > I don't think we can assume that. I think it is possible that some > other transaction's WAL can be in-between start/end lsn of txn (which > we decide to send) which may not finally reach a consistent state. > Consider a case similar to shown in one of my previous emails: > Session-2: > Begin; > SELECT pg_current_xact_id(); > > Session-1: > SELECT 'init' FROM pg_create_logical_replication_slot('test_slot', > 'test_decoding', false, true); > > Session-3: > Begin; > SELECT pg_current_xact_id(); > > Session-2: > Commit; > Begin; > INSERT INTO t1_seq SELECT nextval('seq1') FROM generate_series(1,100); > > Session-3: > Commit; > > Session-2: > Commit; > > Here, we send changes (say insert from txn 700) from session-2 because > session-3's commit happens before it. Now, consider another > transaction parallel to txn 700 which generates some WAL related to > sequences but it committed before session-3's commit. So though, its > changes will be the in-between start/end LSN of txn 700 but those > shouldn't be sent. > > I have not tried this and also this may be solvable in some way but I > think processing changes from other TXNs sounds risky to me in terms > of snapshot handling. > Yes, I know this can happen. I was only really thinking about what might happen to the relfilenode of the sequence itself - and I don't think any concurrent transaction could swoop in and change the relfilenode in any meaningful way, due to locking. But of course, if we expect/require to have a perfect snapshot for that exact position in the transaction, this won't work. IMO the whole idea that we can have non-transactional bits in naturally transactional decoding seems a bit suspicious (at least in hindsight). No matter what we do for sequences, though, this still affects logical messages too. Not sure what to do there :-( >> >> >> (2) treating sequence change as regular changes >> >> This adopts a different approach - instead of accumulating the sequence >> increments in a global hash table, it treats them as regular changes. >> Which solves the snapshot issue, and issues with spilling to disk, >> streaming and so on. >> >> But it has various other issues with handling concurrent transactions, >> unfortunately, which probably make this approach infeasible: >> >> * The non-transactional stuff has to be applied in the first transaction >> that commits, not in the transaction that generated the WAL. That does >> not work too well with this approach, because we have to walk changes in >> all other transactions. >> > > Why do you want to traverse other TXNs in this approach? Is it because > the current TXN might be using some value of sequence which has been > actually WAL logged in the other transaction but that other > transaction has not been sent yet? I think if we don't send that then > probably replica sequences columns (in some tables) have some values > but actually the sequence itself won't have still that value which > sounds problematic. Is that correct? > Well, how else would you get to sequence changes in the other TXNs? Consider this: T1: begin T2: begin T2: nextval('s') -> writes WAL for 32 values T1: nextval('s') -> gets value without WAL T1: commit T2: commit Now, if we commit T1 without "applying" the sequence change from T2, we loose the sequence state. But we still write/replicate the value generated from the sequence. >> * Another serious issue seems to be streaming - if we already streamed >> some of the changes, we can't iterate through them anymore. >> >> Also, having to walk the transactions over and over for each change, to >> apply relevant sequence increments, that's mighty expensive. The other >> approach needs to do that too, but walking the global hash table seems >> much cheaper. >> >> The other issue this handling of aborted transactions - we need to apply >> sequence increments even from those transactions, of course. The other >> approach has this issue too, though. >> >> >> (3) tracking sequences touched by transaction >> >> This is the approach proposed by Hannu Krosing. I haven't explored this >> again yet, but I recall I wrote a PoC patch a couple months back. >> >> It seems to me most of the problems stems from trying to derive sequence >> state from decoded WAL changes, which is problematic because of the >> non-transactional nature of sequences (i.e. WAL for one transaction >> affects other transactions in non-obvious ways). And this approach >> simply works around that entirely - instead of trying to deduce the >> sequence state from WAL, we'd make sure to write the current sequence >> state (or maybe just ID of the sequence) at commit time. Which should >> eliminate most of the complexity / problems, I think. >> > > That sounds promising but I haven't thought in detail about that approach. > So, here's a patch doing that. It's a reworked/improved version of the patch [1] shared in November. It seems to be working pretty nicely. The behavior is a little bit different, of course, because we only replicate "committed" changes, so if you do nextval() in aborted transaction that is not replicated. Which I think is fine, because we generally make no durability guarantees for aborted transactions in general. But there are a couple issues too: 1) locking We have to read sequence change before the commit, but we must not allow reordering (because then the state might go backwards again). I'm not sure how serious impact could this have on performance. 2) dropped sequences I'm not sure what to do about sequences dropped in the transaction. The patch simply attempts to read the current sequence state before the commit, but if the sequence was dropped (in that transaction), that can't happen. I'm not sure if that's OK or not. 3) WAL record To replicate the stuff the patch uses a LogicalMessage, but I guess a separate WAL record would be better. But that's a technical detail. regards [1] https://www.postgresql.org/message-id/2cd38bab-c874-8e0b-98e7-d9abaaf9806a@enterprisedb.com >> >> I'm not really sure what to do about this. All of those reworks seems >> like an extensive redesign of the patch, and considering the last CF is >> already over ... not great. >> > > Yeah, I share the same feeling that even if we devise solutions to all > the known problems it requires quite some time to ensure everything is > correct. > True. Let's keep working on this for a bit more time and then we can decide what to do. regards -- Tomas Vondra EnterpriseDB: http://www.enterprisedb.com The Enterprise PostgreSQL Company --------------h4MkX15oBsPcg0TtcAqSF4HX Content-Type: text/x-patch; charset=UTF-8; name="0001-rework-sequence-decoding.patch" Content-Disposition: attachment; filename="0001-rework-sequence-decoding.patch" Content-Transfer-Encoding: base64 RnJvbSAwYmExNTRlZWY5MzNhOWIzOWJiN2VhYTBlMzM5NjIwYTJmOThhMzdiIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb21hcyBWb25kcmEgPHRvbWFzLnZvbmRyYUBwb3N0 Z3Jlc3FsLm9yZz4KRGF0ZTogVHVlLCA1IEFwciAyMDIyIDAwOjI1OjAyICswMjAwClN1Ympl Y3Q6IFtQQVRDSF0gcmV3b3JrIHNlcXVlbmNlIGRlY29kaW5nCgotLS0KIGNvbnRyaWIvdGVz dF9kZWNvZGluZy90ZXN0X2RlY29kaW5nLmMgICAgICAgICB8ICAyNCArLQogc3JjL2JhY2tl bmQvYWNjZXNzL3JtZ3JkZXNjL2xvZ2ljYWxtc2dkZXNjLmMgIHwgIDEzICsKIHNyYy9iYWNr ZW5kL2FjY2Vzcy90cmFuc2FtL3hhY3QuYyAgICAgICAgICAgICB8ICAyNSArKwogc3JjL2Jh Y2tlbmQvY29tbWFuZHMvc2VxdWVuY2UuYyAgICAgICAgICAgICAgIHwgMjYzICsrKysrKyst LS0tLQogc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vbG9naWNhbC9kZWNvZGUuYyAgICAgIHwg MTEyICsrLS0tCiBzcmMvYmFja2VuZC9yZXBsaWNhdGlvbi9sb2dpY2FsL2xvZ2ljYWwuYyAg ICAgfCAgIDkgKy0KIHNyYy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwvbWVzc2FnZS5j ICAgICB8ICAgMyArLQogc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vbG9naWNhbC9wcm90by5j ICAgICAgIHwgICA0ICstCiAuLi4vcmVwbGljYXRpb24vbG9naWNhbC9yZW9yZGVyYnVmZmVy LmMgICAgICAgfCAzODcgKystLS0tLS0tLS0tLS0tLS0tCiBzcmMvYmFja2VuZC9yZXBsaWNh dGlvbi9sb2dpY2FsL3RhYmxlc3luYy5jICAgfCAgIDMgKy0KIHNyYy9iYWNrZW5kL3JlcGxp Y2F0aW9uL2xvZ2ljYWwvd29ya2VyLmMgICAgICB8ICAxNiArLQogc3JjL2JhY2tlbmQvcmVw bGljYXRpb24vcGdvdXRwdXQvcGdvdXRwdXQuYyAgIHwgIDIxICstCiBzcmMvaW5jbHVkZS9h Y2Nlc3Mvcm1ncmxpc3QuaCAgICAgICAgICAgICAgICAgfCAgIDIgKy0KIHNyYy9pbmNsdWRl L2NvbW1hbmRzL3NlcXVlbmNlLmggICAgICAgICAgICAgICB8ICAgNSArLQogc3JjL2luY2x1 ZGUvcmVwbGljYXRpb24vbG9naWNhbHByb3RvLmggICAgICAgIHwgICAyIC0KIHNyYy9pbmNs dWRlL3JlcGxpY2F0aW9uL21lc3NhZ2UuaCAgICAgICAgICAgICB8ICAxNSArCiBzcmMvaW5j bHVkZS9yZXBsaWNhdGlvbi9vdXRwdXRfcGx1Z2luLmggICAgICAgfCAgIDIgLQogc3JjL2lu Y2x1ZGUvcmVwbGljYXRpb24vcmVvcmRlcmJ1ZmZlci5oICAgICAgIHwgIDE2ICstCiAxOCBm aWxlcyBjaGFuZ2VkLCAzMzAgaW5zZXJ0aW9ucygrKSwgNTkyIGRlbGV0aW9ucygtKQoKZGlm ZiAtLWdpdCBhL2NvbnRyaWIvdGVzdF9kZWNvZGluZy90ZXN0X2RlY29kaW5nLmMgYi9jb250 cmliL3Rlc3RfZGVjb2RpbmcvdGVzdF9kZWNvZGluZy5jCmluZGV4IGM3YTg3ZjVmZTViLi44 NTExMTdiNDE1NSAxMDA2NDQKLS0tIGEvY29udHJpYi90ZXN0X2RlY29kaW5nL3Rlc3RfZGVj b2RpbmcuYworKysgYi9jb250cmliL3Rlc3RfZGVjb2RpbmcvdGVzdF9kZWNvZGluZy5jCkBA IC03OSw3ICs3OSw3IEBAIHN0YXRpYyB2b2lkIHBnX2RlY29kZV9tZXNzYWdlKExvZ2ljYWxE ZWNvZGluZ0NvbnRleHQgKmN0eCwKIAkJCQkJCQkgIFNpemUgc3osIGNvbnN0IGNoYXIgKm1l c3NhZ2UpOwogc3RhdGljIHZvaWQgcGdfZGVjb2RlX3NlcXVlbmNlKExvZ2ljYWxEZWNvZGlu Z0NvbnRleHQgKmN0eCwKIAkJCQkJCQkgIFJlb3JkZXJCdWZmZXJUWE4gKnR4biwgWExvZ1Jl Y1B0ciBzZXF1ZW5jZV9sc24sCi0JCQkJCQkJICBSZWxhdGlvbiByZWwsIGJvb2wgdHJhbnNh Y3Rpb25hbCwKKwkJCQkJCQkgIFJlbGF0aW9uIHJlbCwKIAkJCQkJCQkgIGludDY0IGxhc3Rf dmFsdWUsIGludDY0IGxvZ19jbnQsIGJvb2wgaXNfY2FsbGVkKTsKIHN0YXRpYyBib29sIHBn X2RlY29kZV9maWx0ZXJfcHJlcGFyZShMb2dpY2FsRGVjb2RpbmdDb250ZXh0ICpjdHgsCiAJ CQkJCQkJCQkgVHJhbnNhY3Rpb25JZCB4aWQsCkBAIC0xMjMsNyArMTIzLDcgQEAgc3RhdGlj IHZvaWQgcGdfZGVjb2RlX3N0cmVhbV9tZXNzYWdlKExvZ2ljYWxEZWNvZGluZ0NvbnRleHQg KmN0eCwKIAkJCQkJCQkJCSBTaXplIHN6LCBjb25zdCBjaGFyICptZXNzYWdlKTsKIHN0YXRp YyB2b2lkIHBnX2RlY29kZV9zdHJlYW1fc2VxdWVuY2UoTG9naWNhbERlY29kaW5nQ29udGV4 dCAqY3R4LAogCQkJCQkJCQkJICBSZW9yZGVyQnVmZmVyVFhOICp0eG4sIFhMb2dSZWNQdHIg c2VxdWVuY2VfbHNuLAotCQkJCQkJCQkJICBSZWxhdGlvbiByZWwsIGJvb2wgdHJhbnNhY3Rp b25hbCwKKwkJCQkJCQkJCSAgUmVsYXRpb24gcmVsLAogCQkJCQkJCQkJICBpbnQ2NCBsYXN0 X3ZhbHVlLCBpbnQ2NCBsb2dfY250LCBib29sIGlzX2NhbGxlZCk7CiBzdGF0aWMgdm9pZCBw Z19kZWNvZGVfc3RyZWFtX3RydW5jYXRlKExvZ2ljYWxEZWNvZGluZ0NvbnRleHQgKmN0eCwK IAkJCQkJCQkJCSAgUmVvcmRlckJ1ZmZlclRYTiAqdHhuLApAQCAtNzgyLDcgKzc4Miw2IEBA IHBnX2RlY29kZV9tZXNzYWdlKExvZ2ljYWxEZWNvZGluZ0NvbnRleHQgKmN0eCwKIHN0YXRp YyB2b2lkCiBwZ19kZWNvZGVfc2VxdWVuY2UoTG9naWNhbERlY29kaW5nQ29udGV4dCAqY3R4 LCBSZW9yZGVyQnVmZmVyVFhOICp0eG4sCiAJCQkJICAgWExvZ1JlY1B0ciBzZXF1ZW5jZV9s c24sIFJlbGF0aW9uIHJlbCwKLQkJCQkgICBib29sIHRyYW5zYWN0aW9uYWwsCiAJCQkJICAg aW50NjQgbGFzdF92YWx1ZSwgaW50NjQgbG9nX2NudCwgYm9vbCBpc19jYWxsZWQpCiB7CiAJ VGVzdERlY29kaW5nRGF0YSAqZGF0YSA9IGN0eC0+b3V0cHV0X3BsdWdpbl9wcml2YXRlOwpA QCAtNzkyLDIyICs3OTEsMTkgQEAgcGdfZGVjb2RlX3NlcXVlbmNlKExvZ2ljYWxEZWNvZGlu Z0NvbnRleHQgKmN0eCwgUmVvcmRlckJ1ZmZlclRYTiAqdHhuLAogCQlyZXR1cm47CiAKIAkv KiBvdXRwdXQgQkVHSU4gaWYgd2UgaGF2ZW4ndCB5ZXQsIGJ1dCBvbmx5IGZvciB0aGUgdHJh bnNhY3Rpb25hbCBjYXNlICovCi0JaWYgKHRyYW5zYWN0aW9uYWwpCisJaWYgKGRhdGEtPnNr aXBfZW1wdHlfeGFjdHMgJiYgIXR4bmRhdGEtPnhhY3Rfd3JvdGVfY2hhbmdlcykKIAl7Ci0J CWlmIChkYXRhLT5za2lwX2VtcHR5X3hhY3RzICYmICF0eG5kYXRhLT54YWN0X3dyb3RlX2No YW5nZXMpCi0JCXsKLQkJCXBnX291dHB1dF9iZWdpbihjdHgsIGRhdGEsIHR4biwgZmFsc2Up OwotCQl9Ci0JCXR4bmRhdGEtPnhhY3Rfd3JvdGVfY2hhbmdlcyA9IHRydWU7CisJCXBnX291 dHB1dF9iZWdpbihjdHgsIGRhdGEsIHR4biwgZmFsc2UpOwogCX0KKwl0eG5kYXRhLT54YWN0 X3dyb3RlX2NoYW5nZXMgPSB0cnVlOwogCiAJT3V0cHV0UGx1Z2luUHJlcGFyZVdyaXRlKGN0 eCwgdHJ1ZSk7CiAJYXBwZW5kU3RyaW5nSW5mb1N0cmluZyhjdHgtPm91dCwgInNlcXVlbmNl ICIpOwogCWFwcGVuZFN0cmluZ0luZm9TdHJpbmcoY3R4LT5vdXQsCiAJCQkJCQkgICBxdW90 ZV9xdWFsaWZpZWRfaWRlbnRpZmllcihnZXRfbmFtZXNwYWNlX25hbWUoZ2V0X3JlbF9uYW1l c3BhY2UoUmVsYXRpb25HZXRSZWxpZChyZWwpKSksCiAJCQkJCQkJCQkJCQkJICBSZWxhdGlv bkdldFJlbGF0aW9uTmFtZShyZWwpKSk7Ci0JYXBwZW5kU3RyaW5nSW5mbyhjdHgtPm91dCwg CSI6IHRyYW5zYWN0aW9uYWw6JWQgbGFzdF92YWx1ZTogIiBJTlQ2NF9GT1JNQVQgIiBsb2df Y250OiAiIElOVDY0X0ZPUk1BVCAiIGlzX2NhbGxlZDolZCIsCi0JCQkJCSB0cmFuc2FjdGlv bmFsLCBsYXN0X3ZhbHVlLCBsb2dfY250LCBpc19jYWxsZWQpOworCWFwcGVuZFN0cmluZ0lu Zm8oY3R4LT5vdXQsIAkiOiBsYXN0X3ZhbHVlOiAlenUgbG9nX2NudDogJXp1IGlzX2NhbGxl ZDolZCIsCisJCQkJCSBsYXN0X3ZhbHVlLCBsb2dfY250LCBpc19jYWxsZWQpOwogCU91dHB1 dFBsdWdpbldyaXRlKGN0eCwgdHJ1ZSk7CiB9CiAKQEAgLTEwMTMsNyArMTAwOSw2IEBAIHBn X2RlY29kZV9zdHJlYW1fbWVzc2FnZShMb2dpY2FsRGVjb2RpbmdDb250ZXh0ICpjdHgsCiBz dGF0aWMgdm9pZAogcGdfZGVjb2RlX3N0cmVhbV9zZXF1ZW5jZShMb2dpY2FsRGVjb2RpbmdD b250ZXh0ICpjdHgsIFJlb3JkZXJCdWZmZXJUWE4gKnR4biwKIAkJCQkJCSAgWExvZ1JlY1B0 ciBzZXF1ZW5jZV9sc24sIFJlbGF0aW9uIHJlbCwKLQkJCQkJCSAgYm9vbCB0cmFuc2FjdGlv bmFsLAogCQkJCQkJICBpbnQ2NCBsYXN0X3ZhbHVlLCBpbnQ2NCBsb2dfY250LCBib29sIGlz X2NhbGxlZCkKIHsKIAlUZXN0RGVjb2RpbmdEYXRhICpkYXRhID0gY3R4LT5vdXRwdXRfcGx1 Z2luX3ByaXZhdGU7CkBAIC0xMDIzLDcgKzEwMTgsNiBAQCBwZ19kZWNvZGVfc3RyZWFtX3Nl cXVlbmNlKExvZ2ljYWxEZWNvZGluZ0NvbnRleHQgKmN0eCwgUmVvcmRlckJ1ZmZlclRYTiAq dHhuLAogCQlyZXR1cm47CiAKIAkvKiBvdXRwdXQgQkVHSU4gaWYgd2UgaGF2ZW4ndCB5ZXQs IGJ1dCBvbmx5IGZvciB0aGUgdHJhbnNhY3Rpb25hbCBjYXNlICovCi0JaWYgKHRyYW5zYWN0 aW9uYWwpCiAJewogCQlpZiAoZGF0YS0+c2tpcF9lbXB0eV94YWN0cyAmJiAhdHhuZGF0YS0+ eGFjdF93cm90ZV9jaGFuZ2VzKQogCQl7CkBAIC0xMDM3LDggKzEwMzEsOCBAQCBwZ19kZWNv ZGVfc3RyZWFtX3NlcXVlbmNlKExvZ2ljYWxEZWNvZGluZ0NvbnRleHQgKmN0eCwgUmVvcmRl ckJ1ZmZlclRYTiAqdHhuLAogCWFwcGVuZFN0cmluZ0luZm9TdHJpbmcoY3R4LT5vdXQsCiAJ CQkJCQkgICBxdW90ZV9xdWFsaWZpZWRfaWRlbnRpZmllcihnZXRfbmFtZXNwYWNlX25hbWUo Z2V0X3JlbF9uYW1lc3BhY2UoUmVsYXRpb25HZXRSZWxpZChyZWwpKSksCiAJCQkJCQkJCQkJ CQkJICBSZWxhdGlvbkdldFJlbGF0aW9uTmFtZShyZWwpKSk7Ci0JYXBwZW5kU3RyaW5nSW5m byhjdHgtPm91dCwgCSI6IHRyYW5zYWN0aW9uYWw6JWQgbGFzdF92YWx1ZTogIiBJTlQ2NF9G T1JNQVQgIiBsb2dfY250OiAiIElOVDY0X0ZPUk1BVCAiIGlzX2NhbGxlZDolZCIsCi0JCQkJ CSB0cmFuc2FjdGlvbmFsLCBsYXN0X3ZhbHVlLCBsb2dfY250LCBpc19jYWxsZWQpOworCWFw cGVuZFN0cmluZ0luZm8oY3R4LT5vdXQsIAkiOiBsYXN0X3ZhbHVlOiAiIElOVDY0X0ZPUk1B VCAiIGxvZ19jbnQ6ICIgSU5UNjRfRk9STUFUICIgaXNfY2FsbGVkOiVkIiwKKwkJCQkJIGxh c3RfdmFsdWUsIGxvZ19jbnQsIGlzX2NhbGxlZCk7CiAJT3V0cHV0UGx1Z2luV3JpdGUoY3R4 LCB0cnVlKTsKIH0KIApkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvYWNjZXNzL3JtZ3JkZXNj L2xvZ2ljYWxtc2dkZXNjLmMgYi9zcmMvYmFja2VuZC9hY2Nlc3Mvcm1ncmRlc2MvbG9naWNh bG1zZ2Rlc2MuYwppbmRleCAwOTllMTFhODRlNy4uZGU3N2RjYjBkYzIgMTAwNjQ0Ci0tLSBh L3NyYy9iYWNrZW5kL2FjY2Vzcy9ybWdyZGVzYy9sb2dpY2FsbXNnZGVzYy5jCisrKyBiL3Ny Yy9iYWNrZW5kL2FjY2Vzcy9ybWdyZGVzYy9sb2dpY2FsbXNnZGVzYy5jCkBAIC00MCw2ICs0 MCwxNiBAQCBsb2dpY2FsbXNnX2Rlc2MoU3RyaW5nSW5mbyBidWYsIFhMb2dSZWFkZXJTdGF0 ZSAqcmVjb3JkKQogCQkJc2VwID0gIiAiOwogCQl9CiAJfQorCWVsc2UgaWYgKGluZm8gPT0g WExPR19MT0dJQ0FMX1NFUVVFTkNFKQorCXsKKwkJeGxfbG9naWNhbF9zZXF1ZW5jZSAqeGxy ZWMgPSAoeGxfbG9naWNhbF9zZXF1ZW5jZSAqKSByZWM7CisKKwkJYXBwZW5kU3RyaW5nSW5m byhidWYsICJyZWwgJXUvJXUvJXUgbGFzdDogJWx1IGxvZ19jbnQ6ICVsdSBpc19jYWxsZWQ6 ICVkIiwKKwkJCQkJCSB4bHJlYy0+bm9kZS5zcGNOb2RlLAorCQkJCQkJIHhscmVjLT5ub2Rl LmRiTm9kZSwKKwkJCQkJCSB4bHJlYy0+bm9kZS5yZWxOb2RlLAorCQkJCQkJIHhscmVjLT5s YXN0LCB4bHJlYy0+bG9nX2NudCwgeGxyZWMtPmlzX2NhbGxlZCk7CisJfQogfQogCiBjb25z dCBjaGFyICoKQEAgLTQ4LDUgKzU4LDggQEAgbG9naWNhbG1zZ19pZGVudGlmeSh1aW50OCBp bmZvKQogCWlmICgoaW5mbyAmIH5YTFJfSU5GT19NQVNLKSA9PSBYTE9HX0xPR0lDQUxfTUVT U0FHRSkKIAkJcmV0dXJuICJNRVNTQUdFIjsKIAorCWlmICgoaW5mbyAmIH5YTFJfSU5GT19N QVNLKSA9PSBYTE9HX0xPR0lDQUxfU0VRVUVOQ0UpCisJCXJldHVybiAiU0VRVUVOQ0UiOwor CiAJcmV0dXJuIE5VTEw7CiB9CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvdHJh bnNhbS94YWN0LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvdHJhbnNhbS94YWN0LmMKaW5kZXgg MzU5NmE3ZDczNDUuLjViNmEwN2NhODkyIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nl c3MvdHJhbnNhbS94YWN0LmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL3RyYW5zYW0veGFj dC5jCkBAIC0zNyw2ICszNyw3IEBACiAjaW5jbHVkZSAiY2F0YWxvZy9zdG9yYWdlLmgiCiAj aW5jbHVkZSAiY29tbWFuZHMvYXN5bmMuaCIKICNpbmNsdWRlICJjb21tYW5kcy90YWJsZWNt ZHMuaCIKKyNpbmNsdWRlICJjb21tYW5kcy9zZXF1ZW5jZS5oIgogI2luY2x1ZGUgImNvbW1h bmRzL3RyaWdnZXIuaCIKICNpbmNsdWRlICJjb21tb24vcGdfcHJuZy5oIgogI2luY2x1ZGUg ImV4ZWN1dG9yL3NwaS5oIgpAQCAtMjIyMyw2ICsyMjI0LDE1IEBAIENvbW1pdFRyYW5zYWN0 aW9uKHZvaWQpCiAJLyogUHJldmVudCBjYW5jZWwvZGllIGludGVycnVwdCB3aGlsZSBjbGVh bmluZyB1cCAqLwogCUhPTERfSU5URVJSVVBUUygpOwogCisJLyoKKwkgKiBXcml0ZSBzdGF0 ZSBvZiBzZXF1ZW5jZXMgdG8gV0FMLiBXZSBuZWVkIHRvIGRvIHRoaXMgZWFybHkgZW5vdWdo IHNvCisJICogdGhhdCB3ZSBjYW4gc3RpbGwgd3JpdGUgc3R1ZmYgdG8gV0FMLCBidXQgcHJv YmFibHkgYmVmb3JlIGNoYW5naW5nCisJICogdGhlIHRyYW5zYWN0aW9uIHN0YXRlLgorCSAq CisJICogWFhYIFNob3VsZCB0aGlzIGhhcHBlbiBiZWZvcmUvYWZ0ZXIgaG9sZGluZyB0aGUg aW50ZXJydXB0cz8KKwkgKi8KKwlBdEVPWGFjdF9TZXF1ZW5jZXModHJ1ZSk7CisKIAkvKiBD b21taXQgdXBkYXRlcyB0byB0aGUgcmVsYXRpb24gbWFwIC0tLSBkbyB0aGlzIGFzIGxhdGUg YXMgcG9zc2libGUgKi8KIAlBdEVPWGFjdF9SZWxhdGlvbk1hcCh0cnVlLCBpc19wYXJhbGxl bF93b3JrZXIpOwogCkBAIC0yNDk5LDYgKzI1MDksMTUgQEAgUHJlcGFyZVRyYW5zYWN0aW9u KHZvaWQpCiAJLyogUHJldmVudCBjYW5jZWwvZGllIGludGVycnVwdCB3aGlsZSBjbGVhbmlu ZyB1cCAqLwogCUhPTERfSU5URVJSVVBUUygpOwogCisJLyoKKwkgKiBXcml0ZSBzdGF0ZSBv ZiBzZXF1ZW5jZXMgdG8gV0FMLiBXZSBuZWVkIHRvIGRvIHRoaXMgZWFybHkgZW5vdWdoIHNv CisJICogdGhhdCB3ZSBjYW4gc3RpbGwgd3JpdGUgc3R1ZmYgdG8gV0FMLCBidXQgcHJvYmFi bHkgYmVmb3JlIGNoYW5naW5nCisJICogdGhlIHRyYW5zYWN0aW9uIHN0YXRlLgorCSAqCisJ ICogWFhYIFNob3VsZCB0aGlzIGhhcHBlbiBiZWZvcmUvYWZ0ZXIgaG9sZGluZyB0aGUgaW50 ZXJydXB0cz8KKwkgKi8KKwlBdEVPWGFjdF9TZXF1ZW5jZXModHJ1ZSk7CisKIAkvKgogCSAq IHNldCB0aGUgY3VycmVudCB0cmFuc2FjdGlvbiBzdGF0ZSBpbmZvcm1hdGlvbiBhcHByb3By aWF0ZWx5IGR1cmluZwogCSAqIHByZXBhcmUgcHJvY2Vzc2luZwpAQCAtMjczNCw2ICsyNzUz LDEyIEBAIEFib3J0VHJhbnNhY3Rpb24odm9pZCkKIAkJCSBUcmFuc1N0YXRlQXNTdHJpbmco cy0+c3RhdGUpKTsKIAlBc3NlcnQocy0+cGFyZW50ID09IE5VTEwpOwogCisJLyoKKwkgKiBG b3IgdHJhbnNhY3Rpb24gYWJvcnQgd2UgZG9uJ3QgbmVlZCB0byB3cml0ZSBhbnl0aGluZyB0 byBXQUwsIHdlIGp1c3QKKwkgKiBkbyBjbGVhbnVwIG9mIHRoZSBoYXNoIHRhYmxlIGV0Yy4K KwkgKi8KKwlBdEVPWGFjdF9TZXF1ZW5jZXMoZmFsc2UpOworCiAJLyoKIAkgKiBzZXQgdGhl IGN1cnJlbnQgdHJhbnNhY3Rpb24gc3RhdGUgaW5mb3JtYXRpb24gYXBwcm9wcmlhdGVseSBk dXJpbmcgdGhlCiAJICogYWJvcnQgcHJvY2Vzc2luZwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tl bmQvY29tbWFuZHMvc2VxdWVuY2UuYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3NlcXVlbmNl LmMKaW5kZXggNzE3YmIwYjJhYTkuLjUwYzAzYjcxZGFjIDEwMDY0NAotLS0gYS9zcmMvYmFj a2VuZC9jb21tYW5kcy9zZXF1ZW5jZS5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3Nl cXVlbmNlLmMKQEAgLTM3LDYgKzM3LDcgQEAKICNpbmNsdWRlICJtaXNjYWRtaW4uaCIKICNp bmNsdWRlICJub2Rlcy9tYWtlZnVuY3MuaCIKICNpbmNsdWRlICJwYXJzZXIvcGFyc2VfdHlw ZS5oIgorI2luY2x1ZGUgInJlcGxpY2F0aW9uL21lc3NhZ2UuaCIKICNpbmNsdWRlICJzdG9y YWdlL2xtZ3IuaCIKICNpbmNsdWRlICJzdG9yYWdlL3Byb2MuaCIKICNpbmNsdWRlICJzdG9y YWdlL3NtZ3IuaCIKQEAgLTc1LDYgKzc2LDcgQEAgdHlwZWRlZiBzdHJ1Y3QgU2VxVGFibGVE YXRhCiB7CiAJT2lkCQkJcmVsaWQ7CQkJLyogcGdfY2xhc3MgT0lEIG9mIHRoaXMgc2VxdWVu Y2UgKGhhc2gga2V5KSAqLwogCU9pZAkJCWZpbGVub2RlOwkJLyogbGFzdCBzZWVuIHJlbGZp bGVub2RlIG9mIHRoaXMgc2VxdWVuY2UgKi8KKwlPaWQJCQl0YWJsZXNwYWNlOwkJLyogbGFz dCBzZWVuIHRhYmxlc3BhY2Ugb2YgdGhpcyBzZXF1ZW5jZSAqLwogCUxvY2FsVHJhbnNhY3Rp b25JZCBseGlkOwkvKiB4YWN0IGluIHdoaWNoIHdlIGxhc3QgZGlkIGEgc2VxIG9wICovCiAJ Ym9vbAkJbGFzdF92YWxpZDsJCS8qIGRvIHdlIGhhdmUgYSB2YWxpZCAibGFzdCIgdmFsdWU/ ICovCiAJaW50NjQJCWxhc3Q7CQkJLyogdmFsdWUgbGFzdCByZXR1cm5lZCBieSBuZXh0dmFs ICovCkBAIC04Miw2ICs4NCw3IEBAIHR5cGVkZWYgc3RydWN0IFNlcVRhYmxlRGF0YQogCS8q IGlmIGxhc3QgIT0gY2FjaGVkLCB3ZSBoYXZlIG5vdCB1c2VkIHVwIGFsbCB0aGUgY2FjaGVk IHZhbHVlcyAqLwogCWludDY0CQlpbmNyZW1lbnQ7CQkvKiBjb3B5IG9mIHNlcXVlbmNlJ3Mg aW5jcmVtZW50IGZpZWxkICovCiAJLyogbm90ZSB0aGF0IGluY3JlbWVudCBpcyB6ZXJvIHVu dGlsIHdlIGZpcnN0IGRvIG5leHR2YWxfaW50ZXJuYWwoKSAqLworCWJvb2wJCW5lZWRfbG9n OwkJLyogc2hvdWxkIGJlIHdyaXR0ZW4gdG8gV0FMIGF0IGNvbW1pdD8gKi8KIH0gU2VxVGFi bGVEYXRhOwogCiB0eXBlZGVmIFNlcVRhYmxlRGF0YSAqU2VxVGFibGU7CkBAIC0zMzYsODMg KzMzOSwxMyBAQCBSZXNldFNlcXVlbmNlKE9pZCBzZXFfcmVsaWQpCiAJcmVsYXRpb25fY2xv c2Uoc2VxX3JlbCwgTm9Mb2NrKTsKIH0KIAotLyoKLSAqIFVwZGF0ZSB0aGUgc2VxdWVuY2Ug c3RhdGUgYnkgbW9kaWZ5aW5nIHRoZSBleGlzdGluZyBzZXF1ZW5jZSBkYXRhIHJvdy4KLSAq Ci0gKiBUaGlzIGtlZXBzIHRoZSBzYW1lIHJlbGZpbGVub2RlLCBzbyB0aGUgYmVoYXZpb3Ig aXMgbm9uLXRyYW5zYWN0aW9uYWwuCi0gKi8KLXN0YXRpYyB2b2lkCi1TZXRTZXF1ZW5jZV9u b25fdHJhbnNhY3Rpb25hbChPaWQgc2VxcmVsaWQsIGludDY0IGxhc3RfdmFsdWUsIGludDY0 IGxvZ19jbnQsIGJvb2wgaXNfY2FsbGVkKQotewotCVNlcVRhYmxlCWVsbTsKLQlSZWxhdGlv bglzZXFyZWw7Ci0JQnVmZmVyCQlidWY7Ci0JSGVhcFR1cGxlRGF0YSBzZXFkYXRhdHVwbGU7 Ci0JRm9ybV9wZ19zZXF1ZW5jZV9kYXRhIHNlcTsKLQotCS8qIG9wZW4gYW5kIGxvY2sgc2Vx dWVuY2UgKi8KLQlpbml0X3NlcXVlbmNlKHNlcXJlbGlkLCAmZWxtLCAmc2VxcmVsKTsKLQot CS8qIGxvY2sgcGFnZScgYnVmZmVyIGFuZCByZWFkIHR1cGxlICovCi0Jc2VxID0gcmVhZF9z ZXFfdHVwbGUoc2VxcmVsLCAmYnVmLCAmc2VxZGF0YXR1cGxlKTsKLQotCS8qIGNoZWNrIHRo ZSBjb21tZW50IGFib3ZlIG5leHR2YWxfaW50ZXJuYWwoKSdzIGVxdWl2YWxlbnQgY2FsbC4g Ki8KLQlpZiAoUmVsYXRpb25OZWVkc1dBTChzZXFyZWwpKQotCXsKLQkJR2V0VG9wVHJhbnNh Y3Rpb25JZCgpOwotCi0JCWlmIChYTG9nTG9naWNhbEluZm9BY3RpdmUoKSkKLQkJCUdldEN1 cnJlbnRUcmFuc2FjdGlvbklkKCk7Ci0JfQotCi0JLyogcmVhZHkgdG8gY2hhbmdlIHRoZSBv bi1kaXNrIChvciByZWFsbHksIGluLWJ1ZmZlcikgdHVwbGUgKi8KLQlTVEFSVF9DUklUX1NF Q1RJT04oKTsKLQotCXNlcS0+bGFzdF92YWx1ZSA9IGxhc3RfdmFsdWU7Ci0Jc2VxLT5pc19j YWxsZWQgPSBpc19jYWxsZWQ7Ci0Jc2VxLT5sb2dfY250ID0gbG9nX2NudDsKLQotCU1hcmtC dWZmZXJEaXJ0eShidWYpOwotCi0JLyogWExPRyBzdHVmZiAqLwotCWlmIChSZWxhdGlvbk5l ZWRzV0FMKHNlcXJlbCkpCi0JewotCQl4bF9zZXFfcmVjCXhscmVjOwotCQlYTG9nUmVjUHRy CXJlY3B0cjsKLQkJUGFnZQkJcGFnZSA9IEJ1ZmZlckdldFBhZ2UoYnVmKTsKLQotCQlYTG9n QmVnaW5JbnNlcnQoKTsKLQkJWExvZ1JlZ2lzdGVyQnVmZmVyKDAsIGJ1ZiwgUkVHQlVGX1dJ TExfSU5JVCk7Ci0KLQkJeGxyZWMubm9kZSA9IHNlcXJlbC0+cmRfbm9kZTsKLQkJeGxyZWMu Y3JlYXRlZCA9IGZhbHNlOwotCi0JCVhMb2dSZWdpc3RlckRhdGEoKGNoYXIgKikgJnhscmVj LCBzaXplb2YoeGxfc2VxX3JlYykpOwotCQlYTG9nUmVnaXN0ZXJEYXRhKChjaGFyICopIHNl cWRhdGF0dXBsZS50X2RhdGEsIHNlcWRhdGF0dXBsZS50X2xlbik7Ci0KLQkJcmVjcHRyID0g WExvZ0luc2VydChSTV9TRVFfSUQsIFhMT0dfU0VRX0xPRyk7Ci0KLQkJUGFnZVNldExTTihw YWdlLCByZWNwdHIpOwotCX0KLQotCUVORF9DUklUX1NFQ1RJT04oKTsKLQotCVVubG9ja1Jl bGVhc2VCdWZmZXIoYnVmKTsKLQotCS8qIENsZWFyIGxvY2FsIGNhY2hlIHNvIHRoYXQgd2Ug ZG9uJ3QgdGhpbmsgd2UgaGF2ZSBjYWNoZWQgbnVtYmVycyAqLwotCS8qIE5vdGUgdGhhdCB3 ZSBkbyBub3QgY2hhbmdlIHRoZSBjdXJydmFsKCkgc3RhdGUgKi8KLQllbG0tPmNhY2hlZCA9 IGVsbS0+bGFzdDsKLQotCXJlbGF0aW9uX2Nsb3NlKHNlcXJlbCwgTm9Mb2NrKTsKLX0KLQog LyoKICAqIFVwZGF0ZSB0aGUgc2VxdWVuY2Ugc3RhdGUgYnkgY3JlYXRpbmcgYSBuZXcgcmVs ZmlsZW5vZGUuCiAgKgogICogVGhpcyBjcmVhdGVzIGEgbmV3IHJlbGZpbGVub2RlLCB0byBh bGxvdyB0cmFuc2FjdGlvbmFsIGJlaGF2aW9yLgogICovCi1zdGF0aWMgdm9pZAotU2V0U2Vx dWVuY2VfdHJhbnNhY3Rpb25hbChPaWQgc2VxX3JlbGlkLCBpbnQ2NCBsYXN0X3ZhbHVlLCBp bnQ2NCBsb2dfY250LCBib29sIGlzX2NhbGxlZCkKK3ZvaWQKK1NldFNlcXVlbmNlKE9pZCBz ZXFfcmVsaWQsIGludDY0IGxhc3RfdmFsdWUsIGludDY0IGxvZ19jbnQsIGJvb2wgaXNfY2Fs bGVkKQogewogCVNlcVRhYmxlCWVsbTsKIAlSZWxhdGlvbglzZXFyZWw7CkBAIC00NjksMjcg KzQwMiw2IEBAIFNldFNlcXVlbmNlX3RyYW5zYWN0aW9uYWwoT2lkIHNlcV9yZWxpZCwgaW50 NjQgbGFzdF92YWx1ZSwgaW50NjQgbG9nX2NudCwgYm9vbCBpCiAJcmVsYXRpb25fY2xvc2Uo c2VxcmVsLCBOb0xvY2spOwogfQogCi0vKgotICogU2V0IGEgc2VxdWVuY2UgdG8gYSBzcGVj aWZpZWQgaW50ZXJuYWwgc3RhdGUuCi0gKgotICogVGhlIGNoYW5nZSBpcyBtYWRlIHRyYW5z YWN0aW9uYWxseSwgc28gdGhhdCBvbiBmYWlsdXJlIG9mIHRoZSBjdXJyZW50Ci0gKiB0cmFu c2FjdGlvbiwgdGhlIHNlcXVlbmNlIHdpbGwgYmUgcmVzdG9yZWQgdG8gaXRzIHByZXZpb3Vz IHN0YXRlLgotICogV2UgZG8gdGhhdCBieSBjcmVhdGluZyBhIHdob2xlIG5ldyByZWxmaWxl bm9kZSBmb3IgdGhlIHNlcXVlbmNlOyBzbyB0aGlzCi0gKiB3b3JrcyBtdWNoIGxpa2UgdGhl IHJld3JpdGluZyBmb3JtcyBvZiBBTFRFUiBUQUJMRS4KLSAqCi0gKiBDYWxsZXIgaXMgYXNz dW1lZCB0byBoYXZlIGFjcXVpcmVkIEFjY2Vzc0V4Y2x1c2l2ZUxvY2sgb24gdGhlIHNlcXVl bmNlLAotICogd2hpY2ggbXVzdCBub3QgYmUgcmVsZWFzZWQgdW50aWwgZW5kIG9mIHRyYW5z YWN0aW9uLiAgQ2FsbGVyIGlzIGFsc28KLSAqIHJlc3BvbnNpYmxlIGZvciBwZXJtaXNzaW9u cyBjaGVja2luZy4KLSAqLwotdm9pZAotU2V0U2VxdWVuY2UoT2lkIHNlcV9yZWxpZCwgYm9v bCB0cmFuc2FjdGlvbmFsLCBpbnQ2NCBsYXN0X3ZhbHVlLCBpbnQ2NCBsb2dfY250LCBib29s IGlzX2NhbGxlZCkKLXsKLQlpZiAodHJhbnNhY3Rpb25hbCkKLQkJU2V0U2VxdWVuY2VfdHJh bnNhY3Rpb25hbChzZXFfcmVsaWQsIGxhc3RfdmFsdWUsIGxvZ19jbnQsIGlzX2NhbGxlZCk7 Ci0JZWxzZQotCQlTZXRTZXF1ZW5jZV9ub25fdHJhbnNhY3Rpb25hbChzZXFfcmVsaWQsIGxh c3RfdmFsdWUsIGxvZ19jbnQsIGlzX2NhbGxlZCk7Ci19Ci0KIC8qCiAgKiBJbml0aWFsaXpl IGEgc2VxdWVuY2UncyByZWxhdGlvbiB3aXRoIHRoZSBzcGVjaWZpZWQgdHVwbGUgYXMgY29u dGVudAogICovCkBAIC01MzAsNyArNDQyLDEzIEBAIGZpbGxfc2VxX3dpdGhfZGF0YShSZWxh dGlvbiByZWwsIEhlYXBUdXBsZSB0dXBsZSkKIAl0dXBsZS0+dF9kYXRhLT50X2luZm9tYXNr IHw9IEhFQVBfWE1BWF9JTlZBTElEOwogCUl0ZW1Qb2ludGVyU2V0KCZ0dXBsZS0+dF9kYXRh LT50X2N0aWQsIDAsIEZpcnN0T2Zmc2V0TnVtYmVyKTsKIAotCS8qIGNoZWNrIHRoZSBjb21t ZW50IGFib3ZlIG5leHR2YWxfaW50ZXJuYWwoKSdzIGVxdWl2YWxlbnQgY2FsbC4gKi8KKwkv KgorCSAqIFJlbWVtYmVyIHdlIG5lZWQgdG8gd3JpdGUgdGhpcyBzZXF1ZW5jZSB0byBXQUwg YXQgY29tbWl0LCBhbmQgbWFrZSBzdXJlCisJICogd2UgaGF2ZSBYSUQgaWYgd2UgbWF5IG5l ZWQgdG8gZGVjb2RlIHRoaXMgc2VxdWVuY2UuCisJICoKKwkgKiBYWFggTWF5YmUgd2Ugc2hv dWxkIG5vdCBiZSBkb2luZyB0aGlzIGV4Y2VwdCB3aGVuIGFjdHVhbGx5IHJlYWRpbmcgYQor CSAqIHZhbHVlIGZyb20gdGhlIHNlcXVlbmNlPworCSAqLwogCWlmIChSZWxhdGlvbk5lZWRz V0FMKHJlbCkpCiAJewogCQlHZXRUb3BUcmFuc2FjdGlvbklkKCk7CkBAIC01NTgsNyArNDc2 LDYgQEAgZmlsbF9zZXFfd2l0aF9kYXRhKFJlbGF0aW9uIHJlbCwgSGVhcFR1cGxlIHR1cGxl KQogCQlYTG9nUmVnaXN0ZXJCdWZmZXIoMCwgYnVmLCBSRUdCVUZfV0lMTF9JTklUKTsKIAog CQl4bHJlYy5ub2RlID0gcmVsLT5yZF9ub2RlOwotCQl4bHJlYy5jcmVhdGVkID0gdHJ1ZTsK IAogCQlYTG9nUmVnaXN0ZXJEYXRhKChjaGFyICopICZ4bHJlYywgc2l6ZW9mKHhsX3NlcV9y ZWMpKTsKIAkJWExvZ1JlZ2lzdGVyRGF0YSgoY2hhciAqKSB0dXBsZS0+dF9kYXRhLCB0dXBs ZS0+dF9sZW4pOwpAQCAtNzYyLDYgKzY3OSwyMyBAQCBuZXh0dmFsX2ludGVybmFsKE9pZCBy ZWxpZCwgYm9vbCBjaGVja19wZXJtaXNzaW9ucykKIAkvKiBvcGVuIGFuZCBsb2NrIHNlcXVl bmNlICovCiAJaW5pdF9zZXF1ZW5jZShyZWxpZCwgJmVsbSwgJnNlcXJlbCk7CiAKKwkvKgor CSAqIFJlbWVtYmVyIHdlIG5lZWQgdG8gd3JpdGUgdGhpcyBzZXF1ZW5jZSB0byBXQUwgYXQg Y29tbWl0LCBhbmQgbWFrZSBzdXJlCisJICogd2UgaGF2ZSBYSUQgaWYgd2UgbWF5IG5lZWQg dG8gZGVjb2RlIHRoaXMgc2VxdWVuY2UuCisJICoKKwkgKiBYWFggTWF5YmUgd2Ugc2hvdWxk IG5vdCBiZSBkb2luZyB0aGlzIGV4Y2VwdCB3aGVuIGFjdHVhbGx5IHJlYWRpbmcgYQorCSAq IHZhbHVlIGZyb20gdGhlIHNlcXVlbmNlPworCSAqLworCWlmIChSZWxhdGlvbk5lZWRzV0FM KHNlcXJlbCkpCisJeworCQllbG0tPm5lZWRfbG9nID0gdHJ1ZTsKKworCQlHZXRUb3BUcmFu c2FjdGlvbklkKCk7CisKKwkJaWYgKFhMb2dMb2dpY2FsSW5mb0FjdGl2ZSgpKQorCQkJR2V0 Q3VycmVudFRyYW5zYWN0aW9uSWQoKTsKKwl9CisKIAlpZiAoY2hlY2tfcGVybWlzc2lvbnMg JiYKIAkJcGdfY2xhc3NfYWNsY2hlY2soZWxtLT5yZWxpZCwgR2V0VXNlcklkKCksCiAJCQkJ CQkgIEFDTF9VU0FHRSB8IEFDTF9VUERBVEUpICE9IEFDTENIRUNLX09LKQpAQCAtOTczLDcg KzkwNyw2IEBAIG5leHR2YWxfaW50ZXJuYWwoT2lkIHJlbGlkLCBib29sIGNoZWNrX3Blcm1p c3Npb25zKQogCQlzZXEtPmxvZ19jbnQgPSAwOwogCiAJCXhscmVjLm5vZGUgPSBzZXFyZWwt PnJkX25vZGU7Ci0JCXhscmVjLmNyZWF0ZWQgPSBmYWxzZTsKIAogCQlYTG9nUmVnaXN0ZXJE YXRhKChjaGFyICopICZ4bHJlYywgc2l6ZW9mKHhsX3NlcV9yZWMpKTsKIAkJWExvZ1JlZ2lz dGVyRGF0YSgoY2hhciAqKSBzZXFkYXRhdHVwbGUudF9kYXRhLCBzZXFkYXRhdHVwbGUudF9s ZW4pOwpAQCAtMTA5Miw2ICsxMDI1LDIzIEBAIGRvX3NldHZhbChPaWQgcmVsaWQsIGludDY0 IG5leHQsIGJvb2wgaXNjYWxsZWQpCiAJLyogb3BlbiBhbmQgbG9jayBzZXF1ZW5jZSAqLwog CWluaXRfc2VxdWVuY2UocmVsaWQsICZlbG0sICZzZXFyZWwpOwogCisJLyoKKwkgKiBSZW1l bWJlciB3ZSBuZWVkIHRvIHdyaXRlIHRoaXMgc2VxdWVuY2UgdG8gV0FMIGF0IGNvbW1pdCwg YW5kIG1ha2Ugc3VyZQorCSAqIHdlIGhhdmUgWElEIGlmIHdlIG1heSBuZWVkIHRvIGRlY29k ZSB0aGlzIHNlcXVlbmNlLgorCSAqCisJICogWFhYIE1heWJlIHdlIHNob3VsZCBub3QgYmUg ZG9pbmcgdGhpcyBleGNlcHQgd2hlbiBhY3R1YWxseSByZWFkaW5nIGEKKwkgKiB2YWx1ZSBm cm9tIHRoZSBzZXF1ZW5jZT8KKwkgKi8KKwlpZiAoUmVsYXRpb25OZWVkc1dBTChzZXFyZWwp KQorCXsKKwkJZWxtLT5uZWVkX2xvZyA9IHRydWU7CisKKwkJR2V0VG9wVHJhbnNhY3Rpb25J ZCgpOworCisJCWlmIChYTG9nTG9naWNhbEluZm9BY3RpdmUoKSkKKwkJCUdldEN1cnJlbnRU cmFuc2FjdGlvbklkKCk7CisJfQorCiAJaWYgKHBnX2NsYXNzX2FjbGNoZWNrKGVsbS0+cmVs aWQsIEdldFVzZXJJZCgpLCBBQ0xfVVBEQVRFKSAhPSBBQ0xDSEVDS19PSykKIAkJZXJlcG9y dChFUlJPUiwKIAkJCQkoZXJyY29kZShFUlJDT0RFX0lOU1VGRklDSUVOVF9QUklWSUxFR0Up LApAQCAtMTE2Niw4ICsxMTE2LDYgQEAgZG9fc2V0dmFsKE9pZCByZWxpZCwgaW50NjQgbmV4 dCwgYm9vbCBpc2NhbGxlZCkKIAkJWExvZ1JlZ2lzdGVyQnVmZmVyKDAsIGJ1ZiwgUkVHQlVG X1dJTExfSU5JVCk7CiAKIAkJeGxyZWMubm9kZSA9IHNlcXJlbC0+cmRfbm9kZTsKLQkJeGxy ZWMuY3JlYXRlZCA9IGZhbHNlOwotCiAJCVhMb2dSZWdpc3RlckRhdGEoKGNoYXIgKikgJnhs cmVjLCBzaXplb2YoeGxfc2VxX3JlYykpOwogCQlYTG9nUmVnaXN0ZXJEYXRhKChjaGFyICop IHNlcWRhdGF0dXBsZS50X2RhdGEsIHNlcWRhdGF0dXBsZS50X2xlbik7CiAKQEAgLTEzMTYs NiArMTI2NCw3IEBAIGluaXRfc2VxdWVuY2UoT2lkIHJlbGlkLCBTZXFUYWJsZSAqcF9lbG0s IFJlbGF0aW9uICpwX3JlbCkKIAlpZiAoc2VxcmVsLT5yZF9yZWwtPnJlbGZpbGVub2RlICE9 IGVsbS0+ZmlsZW5vZGUpCiAJewogCQllbG0tPmZpbGVub2RlID0gc2VxcmVsLT5yZF9yZWwt PnJlbGZpbGVub2RlOworCQllbG0tPnRhYmxlc3BhY2UgPSBzZXFyZWwtPnJkX3JlbC0+cmVs dGFibGVzcGFjZTsKIAkJZWxtLT5jYWNoZWQgPSBlbG0tPmxhc3Q7CiAJfQogCkBAIC0yMDUx LDMgKzIwMDAsMTIxIEBAIHNlcV9tYXNrKGNoYXIgKnBhZ2UsIEJsb2NrTnVtYmVyIGJsa25v KQogCiAJbWFza191bnVzZWRfc3BhY2UocGFnZSk7CiB9CisKKworc3RhdGljIHZvaWQKK3Jl YWRfc2VxdWVuY2VfaW5mbyhSZWxhdGlvbiBzZXFyZWwsIGludDY0ICpsYXN0X3ZhbHVlLCBp bnQ2NCAqbG9nX2NudCwgYm9vbCAqaXNfY2FsbGVkKQoreworCUJ1ZmZlcgkJYnVmOworCUZv cm1fcGdfc2VxdWVuY2VfZGF0YSBzZXE7CisJSGVhcFR1cGxlRGF0YQlzZXFkYXRhdHVwbGU7 CisKKwlzZXEgPSByZWFkX3NlcV90dXBsZShzZXFyZWwsICZidWYsICZzZXFkYXRhdHVwbGUp OworCisJKmxhc3RfdmFsdWUgPSBzZXEtPmxhc3RfdmFsdWU7CisJKmlzX2NhbGxlZCA9IHNl cS0+aXNfY2FsbGVkOworCSpsb2dfY250ID0gc2VxLT5sb2dfY250OworCisJVW5sb2NrUmVs ZWFzZUJ1ZmZlcihidWYpOworfQorCisvKiBYWFggRG8gdGhpcyBvbmx5IGZvciB3YWxfbGV2 ZWwgPSBsb2dpY2FsLCBwcm9iYWJseT8gKi8KK3ZvaWQKK0F0RU9YYWN0X1NlcXVlbmNlcyhi b29sIGlzQ29tbWl0KQoreworCVNlcVRhYmxlCQllbnRyeTsKKwlIQVNIX1NFUV9TVEFUVVMJ c2NhbjsKKworCWlmICghc2VxaGFzaHRhYikKKwkJcmV0dXJuOworCisJLyogb25seSBkbyB0 aGlzIHdpdGggd2FsX2xldmVsPWxvZ2ljYWwgKi8KKwlpZiAoIVhMb2dMb2dpY2FsSW5mb0Fj dGl2ZSgpKQorCQlyZXR1cm47CisKKwkvKgorCSAqIFhYWCBNYXliZSB3ZSBjb3VsZCBlbmZv cmNlIGhhdmluZyBYSUQgaGVyZT8gT3IgaXMgaXQgdG9vIGxhdGU/CisJICovCisJLy8gQXNz ZXJ0KEdldFRvcFRyYW5zYWN0aW9uSWQoKSAhPSBJbnZhbGlkVHJhbnNhY3Rpb25JZCk7CisJ Ly8gQXNzZXJ0KEdldEN1cnJlbnRUcmFuc2FjdGlvbklkKCkgIT0gSW52YWxpZFRyYW5zYWN0 aW9uSWQpOworCisJaGFzaF9zZXFfaW5pdCgmc2Nhbiwgc2VxaGFzaHRhYik7CisKKwl3aGls ZSAoKGVudHJ5ID0gKFNlcVRhYmxlKSBoYXNoX3NlcV9zZWFyY2goJnNjYW4pKSkKKwl7CisJ CVJlbGF0aW9uCQkJcmVsOworCQlSZWxGaWxlTm9kZQkJCXJub2RlOworCQl4bF9sb2dpY2Fs X3NlcXVlbmNlCXhscmVjOworCisJCS8qIG5vdCBjb21taXQsIHdlIGRvbid0IGd1YXJhbnRl ZSBhbnkgZGF0YSB0byBiZSBkdXJhYmxlICovCisJCWlmICghaXNDb21taXQpCisJCQllbnRy eS0+bmVlZF9sb2cgPSBmYWxzZTsKKworCQkvKgorCQkgKiBJZiBub3QgdG91Y2hlZCBpbiB0 aGUgY3VycmVudCB0cmFuc2FjdGlvbiwgZG9uJ3QgbG9nIGFueXRoaW5nLgorCQkgKiBXZSBs ZWF2ZSBuZWVkc19sb2cgc2V0LCBzbyB0aGF0IGlmIGZ1dHVyZSB0cmFuc2FjdGlvbnMgdG91 Y2gKKwkJICogdGhlIHNlcXVlbmNlIHdlJ2xsIGxvZyBpdCBwcm9wZXJseS4KKwkJICovCisJ CWlmICghZW50cnktPm5lZWRfbG9nKQorCQkJY29udGludWU7CisKKwkJLyogaWYgdGhpcyBp cyBjb21taXQsIHdlJ2xsIGxvZyB0aGUgKi8KKwkJZW50cnktPm5lZWRfbG9nID0gZmFsc2U7 CisKKwkJLyoKKwkJICogZG9lcyB0aGUgcmVsYXRpb24gc3RpbGwgZXhpc3Q/CisJCSAqCisJ CSAqIFhYWCBXZSBuZWVkIHRvIG1ha2Ugc3VyZSBhbm90aGVyIHRyYW5zYWN0aW9uIGNhbid0 IGp1bXAgYWhlYWQgb2YKKwkJICogdGhpcyBvbmUsIG90aGVyd2lzZSB0aGUgb3JkZXJpbmcg b2Ygc2VxdWVuY2UgY2hhbmdlcyBjb3VsZCBjaGFuZ2UuCisJCSAqIEltYWdpbmUgVDEgYW5k IFQyLCB3aGVyZSBUMSB3cml0ZXMgc2VxdWVuY2Ugc3RhdGUgZmlyc3QsIGJ1dCB0aGVuCisJ CSAqIFQyIGRvZXMgaXQgdG9vIGFuZCBjb21taXRzIGZpcnN0OgorCQkgKgorCQkgKiBUMTog bG9nIHNlcXVlbmNlIHN0YXRlCisJCSAqIFQyOiBpbmNyZW1lbnQgc2VxdWVuY2UKKwkJICog VDI6IGxvZyBzZXF1ZW5jZSBzdGF0ZQorCQkgKiBUMjogY29tbWl0CisJCSAqIFQxOiBjb21t aXQKKwkJICoKKwkJICogSWYgd2UgYXBwbHkgdGhlIHNlcXVlbmNlcyBpbiB0aGlzIG9yZGVy LCBpdCdkIGJlIGJyb2tlbiBhcyB0aGUKKwkJICogdmFsdWUgbWlnaHQgZ28gYmFja3dhcnMu IFNoYXJlVXBkYXRlRXhjbHVzaXZlIHByb3RlY3RzIGFnYWluc3QKKwkJICogdGhhdCwgYnV0 IGl0J3MgYWxzbyByZXN0cmljdGluZyBjb21taXQgdGhyb3VnaHRwdXQsIHByb2JhYmx5Lgor CQkgKgorCQkgKiBYWFggVGhpcyBtaWdodCBiZSBhbiBpc3N1ZSBmb3IgZGVhZGxvY2tzLCB0 b28sIGlmIHR3byB4YWN0cyB0cnkKKwkJICogdG8gd3JpdGUgc2VxdWVuY2VzIGluIGRpZmZl cmVudCBvcmRlcmluZy4gV2UgbWF5IG5lZWQgdG8gc29ydAorCQkgKiB0aGUgT0lEcyBmaXJz dCwgdG8gZW5mb3JjZSB0aGUgc2FtZSBsb2NrIG9yZGVyaW5nLgorCQkgKi8KKwkJcmVsID0g dHJ5X3JlbGF0aW9uX29wZW4oZW50cnktPnJlbGlkLCBTaGFyZVVwZGF0ZUV4Y2x1c2l2ZUxv Y2spOworCisJCS8qIFhYWCByZWxhdGlvbiBtaWdodCBoYXZlIGJlZW4gZHJvcHBlZCwgbWF5 YmUgd2Ugc2hvdWxkIGhhdmUgbG9nZ2VkCisJCSAqIHRoZSBsYXN0IGNoYW5nZT8gKi8KKwkJ aWYgKCFyZWwpCisJCQljb250aW51ZTsKKworCQkvKiB0YWJsZXNwYWNlICovCisJCWlmIChP aWRJc1ZhbGlkKGVudHJ5LT50YWJsZXNwYWNlKSkKKwkJCXJub2RlLnNwY05vZGUgPSBlbnRy eS0+dGFibGVzcGFjZTsKKwkJZWxzZQorCQkJcm5vZGUuc3BjTm9kZSA9IE15RGF0YWJhc2VU YWJsZVNwYWNlOworCisJCXJub2RlLmRiTm9kZSA9IE15RGF0YWJhc2VJZDsJCQkvKiBkYXRh YmFzZSAqLworCQlybm9kZS5yZWxOb2RlID0gZW50cnktPmZpbGVub2RlOwkJLyogcmVsYXRp b24gKi8KKworCQl4bHJlYy5ub2RlID0gcm5vZGU7CisJCXhscmVjLnJlbG9pZCA9IGVudHJ5 LT5yZWxpZDsKKworCQkvKiBYWFggaXMgaXQgZ29vZCBlbm91Z2ggdG8gbG9nIHZhbHVlcyB3 ZSBoYXZlIGluIGNhY2hlPyBzZWVtcworCQkgKiB3cm9uZyBhbmQgd2UgbWF5IG5lZWQgdG8g cmUtcmVhZCB0aGF0LiAqLworCQlyZWFkX3NlcXVlbmNlX2luZm8ocmVsLCAmeGxyZWMubGFz dCwgJnhscmVjLmxvZ19jbnQsICZ4bHJlYy5pc19jYWxsZWQpOworCisJCVhMb2dCZWdpbklu c2VydCgpOworCQlYTG9nUmVnaXN0ZXJEYXRhKChjaGFyICopICZ4bHJlYywgU2l6ZU9mTG9n aWNhbFNlcXVlbmNlKTsKKworCQkvKiBhbGxvdyBvcmlnaW4gZmlsdGVyaW5nICovCisJCVhM b2dTZXRSZWNvcmRGbGFncyhYTE9HX0lOQ0xVREVfT1JJR0lOKTsKKworCQkodm9pZCkgWExv Z0luc2VydChSTV9MT0dJQ0FMTVNHX0lELCBYTE9HX0xPR0lDQUxfU0VRVUVOQ0UpOworCisJ CS8qIGhvbGQgdGhlIHNlcXVlbmNlIGxvY2sgdW50aWwgdGhlIGVuZCBvZiB0aGUgdHJhbnNh Y3Rpb24gKi8KKwkJcmVsYXRpb25fY2xvc2UocmVsLCBOb0xvY2spOworCX0KK30KZGlmZiAt LWdpdCBhL3NyYy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwvZGVjb2RlLmMgYi9zcmMv YmFja2VuZC9yZXBsaWNhdGlvbi9sb2dpY2FsL2RlY29kZS5jCmluZGV4IDc3YmM3YWVhN2Ew Li5hODU0OGY5YWM2NCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vbG9n aWNhbC9kZWNvZGUuYworKysgYi9zcmMvYmFja2VuZC9yZXBsaWNhdGlvbi9sb2dpY2FsL2Rl Y29kZS5jCkBAIC00NCw2ICs0NCw5IEBACiAjaW5jbHVkZSAic3RvcmFnZS9zdGFuZGJ5Lmgi CiAjaW5jbHVkZSAiY29tbWFuZHMvc2VxdWVuY2UuaCIKIAorc3RhdGljIHZvaWQgRGVjb2Rl TG9naWNhbE1lc3NhZ2UoTG9naWNhbERlY29kaW5nQ29udGV4dCAqY3R4LCBYTG9nUmVjb3Jk QnVmZmVyICpidWYpOworc3RhdGljIHZvaWQgRGVjb2RlTG9naWNhbFNlcXVlbmNlKExvZ2lj YWxEZWNvZGluZ0NvbnRleHQgKmN0eCwgWExvZ1JlY29yZEJ1ZmZlciAqYnVmKTsKKwogLyog aW5kaXZpZHVhbCByZWNvcmQoZ3JvdXApJ3MgaGFuZGxlcnMgKi8KIHN0YXRpYyB2b2lkIERl Y29kZUluc2VydChMb2dpY2FsRGVjb2RpbmdDb250ZXh0ICpjdHgsIFhMb2dSZWNvcmRCdWZm ZXIgKmJ1Zik7CiBzdGF0aWMgdm9pZCBEZWNvZGVVcGRhdGUoTG9naWNhbERlY29kaW5nQ29u dGV4dCAqY3R4LCBYTG9nUmVjb3JkQnVmZmVyICpidWYpOwpAQCAtNjQsNyArNjcsNiBAQCBz dGF0aWMgdm9pZCBEZWNvZGVQcmVwYXJlKExvZ2ljYWxEZWNvZGluZ0NvbnRleHQgKmN0eCwg WExvZ1JlY29yZEJ1ZmZlciAqYnVmLAogCiAvKiBjb21tb24gZnVuY3Rpb24gdG8gZGVjb2Rl IHR1cGxlcyAqLwogc3RhdGljIHZvaWQgRGVjb2RlWExvZ1R1cGxlKGNoYXIgKmRhdGEsIFNp emUgbGVuLCBSZW9yZGVyQnVmZmVyVHVwbGVCdWYgKnR1cCk7Ci1zdGF0aWMgdm9pZCBEZWNv ZGVTZXFUdXBsZShjaGFyICpkYXRhLCBTaXplIGxlbiwgUmVvcmRlckJ1ZmZlclR1cGxlQnVm ICp0dXBsZSk7CiAKIC8qIGhlbHBlciBmdW5jdGlvbnMgZm9yIGRlY29kaW5nIHRyYW5zYWN0 aW9ucyAqLwogc3RhdGljIGlubGluZSBib29sIEZpbHRlclByZXBhcmUoTG9naWNhbERlY29k aW5nQ29udGV4dCAqY3R4LApAQCAtNTYwLDYgKzU2MiwyNyBAQCBGaWx0ZXJCeU9yaWdpbihM b2dpY2FsRGVjb2RpbmdDb250ZXh0ICpjdHgsIFJlcE9yaWdpbklkIG9yaWdpbl9pZCkKICAq Lwogdm9pZAogbG9naWNhbG1zZ19kZWNvZGUoTG9naWNhbERlY29kaW5nQ29udGV4dCAqY3R4 LCBYTG9nUmVjb3JkQnVmZmVyICpidWYpCit7CisJWExvZ1JlYWRlclN0YXRlICpyID0gYnVm LT5yZWNvcmQ7CisJdWludDgJCWluZm8gPSBYTG9nUmVjR2V0SW5mbyhyKSAmIH5YTFJfSU5G T19NQVNLOworCisJc3dpdGNoIChpbmZvKQorCXsKKwkJY2FzZSBYTE9HX0xPR0lDQUxfTUVT U0FHRToKKwkJCURlY29kZUxvZ2ljYWxNZXNzYWdlKGN0eCwgYnVmKTsKKwkJCWJyZWFrOwor CisJCWNhc2UgWExPR19MT0dJQ0FMX1NFUVVFTkNFOgorCQkJRGVjb2RlTG9naWNhbFNlcXVl bmNlKGN0eCwgYnVmKTsKKwkJCWJyZWFrOworCisJCWRlZmF1bHQ6CisJCQllbG9nKEVSUk9S LCAidW5leHBlY3RlZCBSTV9MT0dJQ0FMTVNHX0lEIHJlY29yZCB0eXBlOiAldSIsIGluZm8p OworCX0KK30KKworc3RhdGljIHZvaWQKK0RlY29kZUxvZ2ljYWxNZXNzYWdlKExvZ2ljYWxE ZWNvZGluZ0NvbnRleHQgKmN0eCwgWExvZ1JlY29yZEJ1ZmZlciAqYnVmKQogewogCVNuYXBC dWlsZCAgKmJ1aWxkZXIgPSBjdHgtPnNuYXBzaG90X2J1aWxkZXI7CiAJWExvZ1JlYWRlclN0 YXRlICpyID0gYnVmLT5yZWNvcmQ7CkBAIC0xMjUzLDM2ICsxMjc2LDYgQEAgRGVjb2RlVFhO TmVlZFNraXAoTG9naWNhbERlY29kaW5nQ29udGV4dCAqY3R4LCBYTG9nUmVjb3JkQnVmZmVy ICpidWYsCiAJCQljdHgtPmZhc3RfZm9yd2FyZCB8fCBGaWx0ZXJCeU9yaWdpbihjdHgsIG9y aWdpbl9pZCkpOwogfQogCi0vKgotICogRGVjb2RlU2VxVHVwbGUKLSAqCQlkZWNvZGUgdHVw bGUgZGVzY3JpYmluZyB0aGUgc2VxdWVuY2UgaW5jcmVtZW50Ci0gKgotICogU2VxdWVuY2Vz IGFyZSByZXByZXNlbnRlZCBhcyBhIHRhYmxlIHdpdGggYSBzaW5nbGUgcm93LCB3aGljaCBn ZXRzIHVwZGF0ZWQKLSAqIGJ5IG5leHR2YWwoKS4gVGhlIHR1cGxlIGlzIHN0b3JlZCBpbiBX QUwgcmlnaHQgYWZ0ZXIgdGhlIHhsX3NlcV9yZWMsIHNvIHdlCi0gKiBzaW1wbHkgY29weSBp dCBpbnRvIHRoZSB0dXBsZWJ1ZiAoc2ltaWxhciB0byBzZXFfcmVkbykuCi0gKi8KLXN0YXRp YyB2b2lkCi1EZWNvZGVTZXFUdXBsZShjaGFyICpkYXRhLCBTaXplIGxlbiwgUmVvcmRlckJ1 ZmZlclR1cGxlQnVmICp0dXBsZSkKLXsKLQlpbnQJCQlkYXRhbGVuID0gbGVuIC0gc2l6ZW9m KHhsX3NlcV9yZWMpIC0gU2l6ZW9mSGVhcFR1cGxlSGVhZGVyOwotCi0JQXNzZXJ0KGRhdGFs ZW4gPj0gMCk7Ci0KLQl0dXBsZS0+dHVwbGUudF9sZW4gPSBkYXRhbGVuICsgU2l6ZW9mSGVh cFR1cGxlSGVhZGVyOwotCi0JSXRlbVBvaW50ZXJTZXRJbnZhbGlkKCZ0dXBsZS0+dHVwbGUu dF9zZWxmKTsKLQotCXR1cGxlLT50dXBsZS50X3RhYmxlT2lkID0gSW52YWxpZE9pZDsKLQot CW1lbWNweSgoKGNoYXIgKikgdHVwbGUtPnR1cGxlLnRfZGF0YSksCi0JCSAgIGRhdGEgKyBz aXplb2YoeGxfc2VxX3JlYyksCi0JCSAgIFNpemVvZkhlYXBUdXBsZUhlYWRlcik7Ci0KLQlt ZW1jcHkoKChjaGFyICopIHR1cGxlLT50dXBsZS50X2RhdGEpICsgU2l6ZW9mSGVhcFR1cGxl SGVhZGVyLAotCQkgICBkYXRhICsgc2l6ZW9mKHhsX3NlcV9yZWMpICsgU2l6ZW9mSGVhcFR1 cGxlSGVhZGVyLAotCQkgICBkYXRhbGVuKTsKLX0KLQogLyoKICAqIEhhbmRsZSBzZXF1ZW5j ZSBkZWNvZGUKICAqCkBAIC0xMzAxLDI0ICsxMjk0LDE4IEBAIERlY29kZVNlcVR1cGxlKGNo YXIgKmRhdGEsIFNpemUgbGVuLCBSZW9yZGVyQnVmZmVyVHVwbGVCdWYgKnR1cGxlKQogICog cGx1Z2luIC0gaXQgbWlnaHQgZ2V0IGNvbmZ1c2VkIGFib3V0IHdoaWNoIHNlcXVlbmNlIGl0 J3MgcmVsYXRlZCB0byBldGMuCiAgKi8KIHZvaWQKLXNlcXVlbmNlX2RlY29kZShMb2dpY2Fs RGVjb2RpbmdDb250ZXh0ICpjdHgsIFhMb2dSZWNvcmRCdWZmZXIgKmJ1ZikKK0RlY29kZUxv Z2ljYWxTZXF1ZW5jZShMb2dpY2FsRGVjb2RpbmdDb250ZXh0ICpjdHgsIFhMb2dSZWNvcmRC dWZmZXIgKmJ1ZikKIHsKIAlTbmFwQnVpbGQgICpidWlsZGVyID0gY3R4LT5zbmFwc2hvdF9i dWlsZGVyOwotCVJlb3JkZXJCdWZmZXJUdXBsZUJ1ZiAqdHVwbGVidWY7CiAJUmVsRmlsZU5v ZGUgdGFyZ2V0X25vZGU7CiAJWExvZ1JlYWRlclN0YXRlICpyID0gYnVmLT5yZWNvcmQ7Ci0J Y2hhcgkgICAqdHVwbGVkYXRhID0gTlVMTDsKLQlTaXplCQl0dXBsZWxlbjsKLQlTaXplCQlk YXRhbGVuID0gMDsKIAlUcmFuc2FjdGlvbklkIHhpZCA9IFhMb2dSZWNHZXRYaWQocik7CiAJ dWludDgJCWluZm8gPSBYTG9nUmVjR2V0SW5mbyhidWYtPnJlY29yZCkgJiB+WExSX0lORk9f TUFTSzsKLQl4bF9zZXFfcmVjICp4bHJlYzsKLQlTbmFwc2hvdAlzbmFwc2hvdDsKKwl4bF9s b2dpY2FsX3NlcXVlbmNlICp4bHJlYzsKIAlSZXBPcmlnaW5JZCBvcmlnaW5faWQgPSBYTG9n UmVjR2V0T3JpZ2luKHIpOwotCWJvb2wJCXRyYW5zYWN0aW9uYWw7CiAKIAkvKiBvbmx5IGRl Y29kZSBjaGFuZ2VzIGZsYWdnZWQgd2l0aCBYTE9HX1NFUV9MT0cgKi8KLQlpZiAoaW5mbyAh PSBYTE9HX1NFUV9MT0cpCisJaWYgKGluZm8gIT0gWExPR19MT0dJQ0FMX1NFUVVFTkNFKQog CQllbG9nKEVSUk9SLCAidW5leHBlY3RlZCBSTV9TRVFfSUQgcmVjb3JkIHR5cGU6ICV1Iiwg aW5mbyk7CiAKIAlSZW9yZGVyQnVmZmVyUHJvY2Vzc1hpZChjdHgtPnJlb3JkZXIsIFhMb2dS ZWNHZXRYaWQociksIGJ1Zi0+b3JpZ3B0cik7CkBAIC0xMzMxLDggKzEzMTgsMTEgQEAgc2Vx dWVuY2VfZGVjb2RlKExvZ2ljYWxEZWNvZGluZ0NvbnRleHQgKmN0eCwgWExvZ1JlY29yZEJ1 ZmZlciAqYnVmKQogCQljdHgtPmZhc3RfZm9yd2FyZCkKIAkJcmV0dXJuOwogCisJLyogZXh0 cmFjdCB0aGUgV0FMIHJlY29yZCwgd2l0aCAiY3JlYXRlZCIgZmxhZyAqLworCXhscmVjID0g KHhsX2xvZ2ljYWxfc2VxdWVuY2UgKikgWExvZ1JlY0dldERhdGEocik7CisKIAkvKiBvbmx5 IGludGVyZXN0ZWQgaW4gb3VyIGRhdGFiYXNlICovCi0JWExvZ1JlY0dldEJsb2NrVGFnKHIs IDAsICZ0YXJnZXRfbm9kZSwgTlVMTCwgTlVMTCk7CisJdGFyZ2V0X25vZGUgPSB4bHJlYy0+ bm9kZTsKIAlpZiAodGFyZ2V0X25vZGUuZGJOb2RlICE9IGN0eC0+c2xvdC0+ZGF0YS5kYXRh YmFzZSkKIAkJcmV0dXJuOwogCkBAIC0xMzQwLDQ0ICsxMzMwLDEyIEBAIHNlcXVlbmNlX2Rl Y29kZShMb2dpY2FsRGVjb2RpbmdDb250ZXh0ICpjdHgsIFhMb2dSZWNvcmRCdWZmZXIgKmJ1 ZikKIAlpZiAoRmlsdGVyQnlPcmlnaW4oY3R4LCBYTG9nUmVjR2V0T3JpZ2luKHIpKSkKIAkJ cmV0dXJuOwogCi0JdHVwbGVkYXRhID0gWExvZ1JlY0dldERhdGEocik7Ci0JZGF0YWxlbiA9 IFhMb2dSZWNHZXREYXRhTGVuKHIpOwotCXR1cGxlbGVuID0gZGF0YWxlbiAtIFNpemVPZkhl YXBIZWFkZXIgLSBzaXplb2YoeGxfc2VxX3JlYyk7Ci0KLQkvKiBleHRyYWN0IHRoZSBXQUwg cmVjb3JkLCB3aXRoICJjcmVhdGVkIiBmbGFnICovCi0JeGxyZWMgPSAoeGxfc2VxX3JlYyAq KSBYTG9nUmVjR2V0RGF0YShyKTsKLQotCS8qIFhYWCBob3cgY291bGQgd2UgaGF2ZSBzZXF1 ZW5jZSBjaGFuZ2Ugd2l0aG91dCBkYXRhPyAqLwotCWlmKCFkYXRhbGVuIHx8ICF0dXBsZWRh dGEpCi0JCXJldHVybjsKLQotCXR1cGxlYnVmID0gUmVvcmRlckJ1ZmZlckdldFR1cGxlQnVm KGN0eC0+cmVvcmRlciwgdHVwbGVsZW4pOwotCURlY29kZVNlcVR1cGxlKHR1cGxlZGF0YSwg ZGF0YWxlbiwgdHVwbGVidWYpOwotCi0JLyoKLQkgKiBTaG91bGQgd2UgaGFuZGxlIHRoZSBz ZXF1ZW5jZSBpbmNyZW1lbnQgYXMgdHJhbnNhY3Rpb25hbCBvciBub3Q/Ci0JICoKLQkgKiBJ ZiB0aGUgc2VxdWVuY2Ugd2FzIGNyZWF0ZWQgaW4gYSBzdGlsbC1ydW5uaW5nIHRyYW5zYWN0 aW9uLCB0cmVhdAotCSAqIGl0IGFzIHRyYW5zYWN0aW9uYWwgYW5kIHF1ZXVlIHRoZSBpbmNy ZW1lbnRzLiBPdGhlcndpc2UgaXQgbmVlZHMKLQkgKiB0byBiZSB0cmVhdGVkIGFzIG5vbi10 cmFuc2FjdGlvbmFsLCBpbiB3aGljaCBjYXNlIHdlIHNlbmQgaXQgdG8KLQkgKiB0aGUgcGx1 Z2luIHJpZ2h0IGF3YXkuCi0JICovCi0JdHJhbnNhY3Rpb25hbCA9IFJlb3JkZXJCdWZmZXJT ZXF1ZW5jZUlzVHJhbnNhY3Rpb25hbChjdHgtPnJlb3JkZXIsCi0JCQkJCQkJCQkJCQkJCSB0 YXJnZXRfbm9kZSwKLQkJCQkJCQkJCQkJCQkJIHhscmVjLT5jcmVhdGVkKTsKLQogCS8qIFNr aXAgdGhlIGNoYW5nZSBpZiBhbHJlYWR5IHByb2Nlc3NlZCAocGVyIHRoZSBzbmFwc2hvdCku ICovCi0JaWYgKHRyYW5zYWN0aW9uYWwgJiYKLQkJIVNuYXBCdWlsZFByb2Nlc3NDaGFuZ2Uo YnVpbGRlciwgeGlkLCBidWYtPm9yaWdwdHIpKQotCQlyZXR1cm47Ci0JZWxzZSBpZiAoIXRy YW5zYWN0aW9uYWwgJiYKLQkJCSAoU25hcEJ1aWxkQ3VycmVudFN0YXRlKGJ1aWxkZXIpICE9 IFNOQVBCVUlMRF9DT05TSVNURU5UIHx8Ci0JCQkgIFNuYXBCdWlsZFhhY3ROZWVkc1NraXAo YnVpbGRlciwgYnVmLT5vcmlncHRyKSkpCisJaWYgKCFTbmFwQnVpbGRQcm9jZXNzQ2hhbmdl KGJ1aWxkZXIsIHhpZCwgYnVmLT5vcmlncHRyKSkKIAkJcmV0dXJuOwogCiAJLyogUXVldWUg dGhlIGluY3JlbWVudCAob3Igc2VuZCBpbW1lZGlhdGVseSBpZiBub3QgdHJhbnNhY3Rpb25h bCkuICovCi0Jc25hcHNob3QgPSBTbmFwQnVpbGRHZXRPckJ1aWxkU25hcHNob3QoYnVpbGRl ciwgeGlkKTsKLQlSZW9yZGVyQnVmZmVyUXVldWVTZXF1ZW5jZShjdHgtPnJlb3JkZXIsIHhp ZCwgc25hcHNob3QsIGJ1Zi0+ZW5kcHRyLAotCQkJCQkJCSAgIG9yaWdpbl9pZCwgdGFyZ2V0 X25vZGUsIHRyYW5zYWN0aW9uYWwsCi0JCQkJCQkJICAgeGxyZWMtPmNyZWF0ZWQsIHR1cGxl YnVmKTsKKwlSZW9yZGVyQnVmZmVyUXVldWVTZXF1ZW5jZShjdHgtPnJlb3JkZXIsIHhpZCwg YnVmLT5lbmRwdHIsCisJCQkJCQkJICAgb3JpZ2luX2lkLCB4bHJlYy0+cmVsb2lkLCB0YXJn ZXRfbm9kZSwKKwkJCQkJCQkgICB4bHJlYy0+bGFzdCwgeGxyZWMtPmxvZ19jbnQsIHhscmVj LT5pc19jYWxsZWQpOwogfQpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24v bG9naWNhbC9sb2dpY2FsLmMgYi9zcmMvYmFja2VuZC9yZXBsaWNhdGlvbi9sb2dpY2FsL2xv Z2ljYWwuYwppbmRleCBlMWYxNGFlZWNiNS4uZDAwY2MwOGZiM2EgMTAwNjQ0Ci0tLSBhL3Ny Yy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwvbG9naWNhbC5jCisrKyBiL3NyYy9iYWNr ZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwvbG9naWNhbC5jCkBAIC03NSw3ICs3NSw2IEBAIHN0 YXRpYyB2b2lkIG1lc3NhZ2VfY2Jfd3JhcHBlcihSZW9yZGVyQnVmZmVyICpjYWNoZSwgUmVv cmRlckJ1ZmZlclRYTiAqdHhuLAogCQkJCQkJCSAgIGNvbnN0IGNoYXIgKnByZWZpeCwgU2l6 ZSBtZXNzYWdlX3NpemUsIGNvbnN0IGNoYXIgKm1lc3NhZ2UpOwogc3RhdGljIHZvaWQgc2Vx dWVuY2VfY2Jfd3JhcHBlcihSZW9yZGVyQnVmZmVyICpjYWNoZSwgUmVvcmRlckJ1ZmZlclRY TiAqdHhuLAogCQkJCQkJCQlYTG9nUmVjUHRyIHNlcXVlbmNlX2xzbiwgUmVsYXRpb24gcmVs LAotCQkJCQkJCQlib29sIHRyYW5zYWN0aW9uYWwsCiAJCQkJCQkJCWludDY0IGxhc3RfdmFs dWUsIGludDY0IGxvZ19jbnQsIGJvb2wgaXNfY2FsbGVkKTsKIAogLyogc3RyZWFtaW5nIGNh bGxiYWNrcyAqLwpAQCAtOTYsNyArOTUsNiBAQCBzdGF0aWMgdm9pZCBzdHJlYW1fbWVzc2Fn ZV9jYl93cmFwcGVyKFJlb3JkZXJCdWZmZXIgKmNhY2hlLCBSZW9yZGVyQnVmZmVyVFhOICp0 eAogCQkJCQkJCQkJICBjb25zdCBjaGFyICpwcmVmaXgsIFNpemUgbWVzc2FnZV9zaXplLCBj b25zdCBjaGFyICptZXNzYWdlKTsKIHN0YXRpYyB2b2lkIHN0cmVhbV9zZXF1ZW5jZV9jYl93 cmFwcGVyKFJlb3JkZXJCdWZmZXIgKmNhY2hlLCBSZW9yZGVyQnVmZmVyVFhOICp0eG4sCiAJ CQkJCQkJCQkgICBYTG9nUmVjUHRyIHNlcXVlbmNlX2xzbiwgUmVsYXRpb24gcmVsLAotCQkJ CQkJCQkJICAgYm9vbCB0cmFuc2FjdGlvbmFsLAogCQkJCQkJCQkJICAgaW50NjQgbGFzdF92 YWx1ZSwgaW50NjQgbG9nX2NudCwgYm9vbCBpc19jYWxsZWQpOwogc3RhdGljIHZvaWQgc3Ry ZWFtX3RydW5jYXRlX2NiX3dyYXBwZXIoUmVvcmRlckJ1ZmZlciAqY2FjaGUsIFJlb3JkZXJC dWZmZXJUWE4gKnR4biwKIAkJCQkJCQkJCSAgIGludCBucmVsYXRpb25zLCBSZWxhdGlvbiBy ZWxhdGlvbnNbXSwgUmVvcmRlckJ1ZmZlckNoYW5nZSAqY2hhbmdlKTsKQEAgLTEyMTgsNyAr MTIxNiw3IEBAIG1lc3NhZ2VfY2Jfd3JhcHBlcihSZW9yZGVyQnVmZmVyICpjYWNoZSwgUmVv cmRlckJ1ZmZlclRYTiAqdHhuLAogCiBzdGF0aWMgdm9pZAogc2VxdWVuY2VfY2Jfd3JhcHBl cihSZW9yZGVyQnVmZmVyICpjYWNoZSwgUmVvcmRlckJ1ZmZlclRYTiAqdHhuLAotCQkJCQlY TG9nUmVjUHRyIHNlcXVlbmNlX2xzbiwgUmVsYXRpb24gcmVsLCBib29sIHRyYW5zYWN0aW9u YWwsCisJCQkJCVhMb2dSZWNQdHIgc2VxdWVuY2VfbHNuLCBSZWxhdGlvbiByZWwsCiAJCQkJ CWludDY0IGxhc3RfdmFsdWUsIGludDY0IGxvZ19jbnQsIGJvb2wgaXNfY2FsbGVkKQogewog CUxvZ2ljYWxEZWNvZGluZ0NvbnRleHQgKmN0eCA9IGNhY2hlLT5wcml2YXRlX2RhdGE7CkBA IC0xMjQ1LDcgKzEyNDMsNyBAQCBzZXF1ZW5jZV9jYl93cmFwcGVyKFJlb3JkZXJCdWZmZXIg KmNhY2hlLCBSZW9yZGVyQnVmZmVyVFhOICp0eG4sCiAJY3R4LT53cml0ZV9sb2NhdGlvbiA9 IHNlcXVlbmNlX2xzbjsKIAogCS8qIGRvIHRoZSBhY3R1YWwgd29yazogY2FsbCBjYWxsYmFj ayAqLwotCWN0eC0+Y2FsbGJhY2tzLnNlcXVlbmNlX2NiKGN0eCwgdHhuLCBzZXF1ZW5jZV9s c24sIHJlbCwgdHJhbnNhY3Rpb25hbCwKKwljdHgtPmNhbGxiYWNrcy5zZXF1ZW5jZV9jYihj dHgsIHR4biwgc2VxdWVuY2VfbHNuLCByZWwsCiAJCQkJCQkJICAgbGFzdF92YWx1ZSwgbG9n X2NudCwgaXNfY2FsbGVkKTsKIAogCS8qIFBvcCB0aGUgZXJyb3IgY29udGV4dCBzdGFjayAq LwpAQCAtMTU2MCw3ICsxNTU4LDYgQEAgc3RyZWFtX21lc3NhZ2VfY2Jfd3JhcHBlcihSZW9y ZGVyQnVmZmVyICpjYWNoZSwgUmVvcmRlckJ1ZmZlclRYTiAqdHhuLAogc3RhdGljIHZvaWQK IHN0cmVhbV9zZXF1ZW5jZV9jYl93cmFwcGVyKFJlb3JkZXJCdWZmZXIgKmNhY2hlLCBSZW9y ZGVyQnVmZmVyVFhOICp0eG4sCiAJCQkJCQkgICBYTG9nUmVjUHRyIHNlcXVlbmNlX2xzbiwg UmVsYXRpb24gcmVsLAotCQkJCQkJICAgYm9vbCB0cmFuc2FjdGlvbmFsLAogCQkJCQkJICAg aW50NjQgbGFzdF92YWx1ZSwgaW50NjQgbG9nX2NudCwgYm9vbCBpc19jYWxsZWQpCiB7CiAJ TG9naWNhbERlY29kaW5nQ29udGV4dCAqY3R4ID0gY2FjaGUtPnByaXZhdGVfZGF0YTsKQEAg LTE1OTEsNyArMTU4OCw3IEBAIHN0cmVhbV9zZXF1ZW5jZV9jYl93cmFwcGVyKFJlb3JkZXJC dWZmZXIgKmNhY2hlLCBSZW9yZGVyQnVmZmVyVFhOICp0eG4sCiAJY3R4LT53cml0ZV9sb2Nh dGlvbiA9IHNlcXVlbmNlX2xzbjsKIAogCS8qIGRvIHRoZSBhY3R1YWwgd29yazogY2FsbCBj YWxsYmFjayAqLwotCWN0eC0+Y2FsbGJhY2tzLnNlcXVlbmNlX2NiKGN0eCwgdHhuLCBzZXF1 ZW5jZV9sc24sIHJlbCwgdHJhbnNhY3Rpb25hbCwKKwljdHgtPmNhbGxiYWNrcy5zZXF1ZW5j ZV9jYihjdHgsIHR4biwgc2VxdWVuY2VfbHNuLCByZWwsCiAJCQkJCQkJICAgbGFzdF92YWx1 ZSwgbG9nX2NudCwgaXNfY2FsbGVkKTsKIAogCS8qIFBvcCB0aGUgZXJyb3IgY29udGV4dCBz dGFjayAqLwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vbG9naWNhbC9t ZXNzYWdlLmMgYi9zcmMvYmFja2VuZC9yZXBsaWNhdGlvbi9sb2dpY2FsL21lc3NhZ2UuYwpp bmRleCAxYzM0OTEyNjEwZS4uNjkxNzhkYzFjZmIgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5k L3JlcGxpY2F0aW9uL2xvZ2ljYWwvbWVzc2FnZS5jCisrKyBiL3NyYy9iYWNrZW5kL3JlcGxp Y2F0aW9uL2xvZ2ljYWwvbWVzc2FnZS5jCkBAIC04Miw3ICs4Miw4IEBAIGxvZ2ljYWxtc2df cmVkbyhYTG9nUmVhZGVyU3RhdGUgKnJlY29yZCkKIHsKIAl1aW50OAkJaW5mbyA9IFhMb2dS ZWNHZXRJbmZvKHJlY29yZCkgJiB+WExSX0lORk9fTUFTSzsKIAotCWlmIChpbmZvICE9IFhM T0dfTE9HSUNBTF9NRVNTQUdFKQorCWlmIChpbmZvICE9IFhMT0dfTE9HSUNBTF9NRVNTQUdF ICYmCisJCWluZm8gIT0gWExPR19MT0dJQ0FMX1NFUVVFTkNFKQogCQllbG9nKFBBTklDLCAi bG9naWNhbG1zZ19yZWRvOiB1bmtub3duIG9wIGNvZGUgJXUiLCBpbmZvKTsKIAogCS8qIFRo aXMgaXMgb25seSBpbnRlcmVzdGluZyBmb3IgbG9naWNhbCBkZWNvZGluZywgc2VlIGRlY29k ZS5jLiAqLwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vbG9naWNhbC9w cm90by5jIGIvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vbG9naWNhbC9wcm90by5jCmluZGV4 IDE4ZDNjYmI5MjQ4Li5hZTA3OGVlZDA0OCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvcmVw bGljYXRpb24vbG9naWNhbC9wcm90by5jCisrKyBiL3NyYy9iYWNrZW5kL3JlcGxpY2F0aW9u L2xvZ2ljYWwvcHJvdG8uYwpAQCAtNjY3LDcgKzY2Nyw3IEBAIGxvZ2ljYWxyZXBfd3JpdGVf bWVzc2FnZShTdHJpbmdJbmZvIG91dCwgVHJhbnNhY3Rpb25JZCB4aWQsIFhMb2dSZWNQdHIg bHNuLAogICovCiB2b2lkCiBsb2dpY2FscmVwX3dyaXRlX3NlcXVlbmNlKFN0cmluZ0luZm8g b3V0LCBSZWxhdGlvbiByZWwsIFRyYW5zYWN0aW9uSWQgeGlkLAotCQkJCQkJICBYTG9nUmVj UHRyIGxzbiwgYm9vbCB0cmFuc2FjdGlvbmFsLAorCQkJCQkJICBYTG9nUmVjUHRyIGxzbiwK IAkJCQkJCSAgaW50NjQgbGFzdF92YWx1ZSwgaW50NjQgbG9nX2NudCwgYm9vbCBpc19jYWxs ZWQpCiB7CiAJdWludDgJCWZsYWdzID0gMDsKQEAgLTY4Niw3ICs2ODYsNiBAQCBsb2dpY2Fs cmVwX3dyaXRlX3NlcXVlbmNlKFN0cmluZ0luZm8gb3V0LCBSZWxhdGlvbiByZWwsIFRyYW5z YWN0aW9uSWQgeGlkLAogCXJlbG5hbWUgPSBSZWxhdGlvbkdldFJlbGF0aW9uTmFtZShyZWwp OwogCXBxX3NlbmRzdHJpbmcob3V0LCByZWxuYW1lKTsKIAotCXBxX3NlbmRpbnQ4KG91dCwg dHJhbnNhY3Rpb25hbCk7CiAJcHFfc2VuZGludDY0KG91dCwgbGFzdF92YWx1ZSk7CiAJcHFf c2VuZGludDY0KG91dCwgbG9nX2NudCk7CiAJcHFfc2VuZGludDgob3V0LCBpc19jYWxsZWQp OwpAQCAtNzA2LDcgKzcwNSw2IEBAIGxvZ2ljYWxyZXBfcmVhZF9zZXF1ZW5jZShTdHJpbmdJ bmZvIGluLCBMb2dpY2FsUmVwU2VxdWVuY2UgKnNlcWRhdGEpCiAJc2VxZGF0YS0+bnNwbmFt ZSA9IHBzdHJkdXAobG9naWNhbHJlcF9yZWFkX25hbWVzcGFjZShpbikpOwogCXNlcWRhdGEt PnNlcW5hbWUgPSBwc3RyZHVwKHBxX2dldG1zZ3N0cmluZyhpbikpOwogCi0Jc2VxZGF0YS0+ dHJhbnNhY3Rpb25hbCA9IHBxX2dldG1zZ2ludChpbiwgMSk7CiAJc2VxZGF0YS0+bGFzdF92 YWx1ZSA9IHBxX2dldG1zZ2ludDY0KGluKTsKIAlzZXFkYXRhLT5sb2dfY250ID0gcHFfZ2V0 bXNnaW50NjQoaW4pOwogCXNlcWRhdGEtPmlzX2NhbGxlZCA9IHBxX2dldG1zZ2ludChpbiwg MSk7CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9yZXBsaWNhdGlvbi9sb2dpY2FsL3Jlb3Jk ZXJidWZmZXIuYyBiL3NyYy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwvcmVvcmRlcmJ1 ZmZlci5jCmluZGV4IDQ3MDI3NTBhMmU3Li4wY2M3YzhkM2JjNCAxMDA2NDQKLS0tIGEvc3Jj L2JhY2tlbmQvcmVwbGljYXRpb24vbG9naWNhbC9yZW9yZGVyYnVmZmVyLmMKKysrIGIvc3Jj L2JhY2tlbmQvcmVwbGljYXRpb24vbG9naWNhbC9yZW9yZGVyYnVmZmVyLmMKQEAgLTc3LDM5 ICs3Nyw3IEBACiAgKgkgIGEgYml0IG1vcmUgbWVtb3J5IHRvIHRoZSBvbGRlc3Qgc3VidHJh bnNhY3Rpb25zLCBiZWNhdXNlIGl0J3MgbGlrZWx5CiAgKgkgIHRoZXkgYXJlIHRoZSBzb3Vy Y2UgZm9yIHRoZSBuZXh0IHNlcXVlbmNlIG9mIGNoYW5nZXMuCiAgKgotICoJICBXaGVuIGRl Y29kaW5nIHNlcXVlbmNlcywgd2UgZGlmZmVyZW50aWF0ZSBiZXR3ZWVuIGEgc2VxdWVuY2Vz IGNyZWF0ZWQKLSAqCSAgaW4gYSAocnVubmluZykgdHJhbnNhY3Rpb24sIGFuZCBzZXF1ZW5j ZXMgY3JlYXRlZCBpbiBvdGhlciAoYWxyZWFkeQotICoJICBjb21taXR0ZWQpIHRyYW5zYWN0 aW9ucy4gQ2hhbmdlcyBmb3Igc2VxdWVuY2VzIGNyZWF0ZWQgaW4gdGhlIHNhbWUKLSAqCSAg dG9wLWxldmVsIHRyYW5zYWN0aW9uIGFyZSB0cmVhdGVkIGFzICJ0cmFuc2FjdGlvbmFsIiBp LmUuIGp1c3QgbGlrZQotICoJICBhbnkgb3RoZXIgY2hhbmdlIGZyb20gdGhhdCB0cmFuc2Fj dGlvbiAoYW5kIGRpc2NhcmRlZCBpbiBjYXNlIG9mIGEKLSAqCSAgcm9sbGJhY2spLiBDaGFu Z2VzIGZvciBzZXF1ZW5jZXMgY3JlYXRlZCBlYXJsaWVyIGFyZSB0cmVhdGVkIGFzIG5vdAot ICoJICB0cmFuc2FjdGlvbmFsIC0gYXJlIHByb2Nlc3NlZCBpbW1lZGlhdGVseSwgYXMgaWYg cGVyZm9ybWVkIG91dHNpZGUKLSAqCSAgYW55IHRyYW5zYWN0aW9uIChhbmQgdGh1cyBub3Qg cm9sbGVkIGJhY2spLgotICoKLSAqCSAgVGhpcyBtaXhlZCBiZWhhdmlvciBpcyBuZWNlc3Nh cnkgLSBzZXF1ZW5jZXMgYXJlIG5vbi10cmFuc2FjdGlvbmFsCi0gKgkgIChlLmcuIFJPTExC QUNLIGRvZXMgbm90IHVuZG8gdGhlIHNlcXVlbmNlIGluY3JlbWVudHMpLiBCdXQgZm9yIG5l dwotICoJICBzZXF1ZW5jZXMsIHdlIG5lZWQgdG8gaGFuZGxlIHRoZW0gaW4gYSB0cmFuc2Fj dGlvbmFsIHdheSwgYmVjYXVzZSBpZgotICoJICB3ZSBldmVyIGdldCBzb21lIERETCBzdXBw b3J0LCB0aGUgc2VxdWVuY2Ugd29uJ3QgZXhpc3QgdW50aWwgdGhlCi0gKgkgIHRyYW5zYWN0 aW9uIGdldHMgYXBwbGllZC4gU28gd2UgbmVlZCB0byBlbnN1cmUgdGhlIGluY3JlbWVudHMg ZG9uJ3QKLSAqCSAgaGFwcGVuIHVudGlsIHRoZSBzZXF1ZW5jZSBnZXRzIGNyZWF0ZWQuCi0g KgotICoJICBUbyBkaWZmZXJlbnRpYXRlIHdoaWNoIHNlcXVlbmNlcyBhcmUgIm9sZCIgYW5k IHdoaWNoIHdlcmUgY3JlYXRlZAotICoJICBpbiBhIHN0aWxsLXJ1bm5pbmcgdHJhbnNhY3Rp b24sIHdlIHRyYWNrIHNlcXVlbmNlcyBjcmVhdGVkIGluIHJ1bm5pbmcKLSAqCSAgdHJhbnNh Y3Rpb25zIGluIGEgaGFzaCB0YWJsZS4gU2VxdWVuY2VzIGFyZSBpZGVudGlmaWVkIGJ5IHJl bGZpbGVub2RlLAotICoJICBhbmQgd2UgdHJhY2sgWElEIG9mIHRoZSAoc3ViKXRyYW5zYWN0 aW9uIHRoYXQgY3JlYXRlZCBpdC4gVGhpcyBtZWFucwotICoJICB0aGF0IGlmIGEgdHJhbnNh Y3Rpb24gZG9lcyBzb21ldGhpbmcgdGhhdCBjaGFuZ2VzIHRoZSByZWxmaWxlbm9kZQotICoJ ICAobGlrZSBhbiBhbHRlciAvIHJlc2V0IG9mIGEgc2VxdWVuY2UpLCB0aGUgbmV3IHJlbGZp bGVub2RlIHdpbGwgYmUKLSAqCSAgdHJlYXRlZCBhcyBpZiBjcmVhdGVkIGluIHRoZSB0cmFu c2FjdGlvbi4gVGhlIGxpc3Qgb2Ygc2VxdWVuY2VzIGdldHMKLSAqCSAgZGlzY2FyZGVkIHdo ZW4gdGhlIHRyYW5zYWN0aW9uIGNvbXBsZXRlcyAoY29tbWl0L3JvbGxiYWNrKS4KLSAqCi0g KgkgIFdlIGRvbid0IHVzZSB0aGUgWElEIHRvIGNoZWNrIGlmIGl0J3MgdGhlIHNhbWUgdG9w LWxldmVsIHRyYW5zYWN0aW9uLgotICoJICBJdCdzIGVub3VnaCB0byBrbm93IGl0IHdhcyBj cmVhdGVkIGluIGFuIGluLXByb2dyZXNzIHRyYW5zYWN0aW9uLAotICoJICBhbmQgd2Uga25v dyBpdCBtdXN0IGJlIHRoZSBjdXJyZW50IG9uZSBiZWNhdXNlIG90aGVyd2lzZSBpdCB3b3Vs ZG4ndAotICoJICBzZWUgdGhlIHNlcXVlbmNlIG9iamVjdC4KLSAqCi0gKgkgIFRoZSBYSUQg bWF5IGJlIHZhbGlkIGV2ZW4gZm9yIG5vbi10cmFuc2FjdGlvbmFsIHNlcXVlbmNlcyAtIHdl IHNpbXBseQotICoJICBrZWVwIHRoZSBYSUQgbG9nZ2VkIHRvIFdBTCwgaXQncyB1cCB0byB0 aGUgcmVvcmRlcmJ1ZmZlciB0byBkZWNpZGUgaWYKLSAqCSAgdGhlIGluY3JlbWVudCBpcyB0 cmFuc2FjdGlvbmFsLgorICoJICBGSVhNRQogICoKICAqIC0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0K ICAqLwpAQCAtMTUxLDEzICsxMTksNiBAQCB0eXBlZGVmIHN0cnVjdCBSZW9yZGVyQnVmZmVy VFhOQnlJZEVudAogCVJlb3JkZXJCdWZmZXJUWE4gKnR4bjsKIH0gUmVvcmRlckJ1ZmZlclRY TkJ5SWRFbnQ7CiAKLS8qIGVudHJ5IGZvciBoYXNoIHRhYmxlIHdlIHVzZSB0byB0cmFjayBz ZXF1ZW5jZXMgY3JlYXRlZCBpbiBydW5uaW5nIHhhY3RzICovCi10eXBlZGVmIHN0cnVjdCBS ZW9yZGVyQnVmZmVyU2VxdWVuY2VFbnQKLXsKLQlSZWxGaWxlTm9kZQkJcm5vZGU7Ci0JVHJh bnNhY3Rpb25JZAl4aWQ7Ci19IFJlb3JkZXJCdWZmZXJTZXF1ZW5jZUVudDsKLQogLyogZGF0 YSBzdHJ1Y3R1cmVzIGZvciAocmVsZmlsZW5vZGUsIGN0aWQpID0+IChjbWluLCBjbWF4KSBt YXBwaW5nICovCiB0eXBlZGVmIHN0cnVjdCBSZW9yZGVyQnVmZmVyVHVwbGVDaWRLZXkKIHsK QEAgLTM4OCwxNCArMzQ5LDYgQEAgUmVvcmRlckJ1ZmZlckFsbG9jYXRlKHZvaWQpCiAJYnVm ZmVyLT5ieV90eG4gPSBoYXNoX2NyZWF0ZSgiUmVvcmRlckJ1ZmZlckJ5WGlkIiwgMTAwMCwg Jmhhc2hfY3RsLAogCQkJCQkJCQkgSEFTSF9FTEVNIHwgSEFTSF9CTE9CUyB8IEhBU0hfQ09O VEVYVCk7CiAKLQkvKiBoYXNoIHRhYmxlIG9mIHNlcXVlbmNlcywgbWFwcGluZyByZWxmaWxl bm9kZSB0byBYSUQgb2YgdHJhbnNhY3Rpb24gKi8KLQloYXNoX2N0bC5rZXlzaXplID0gc2l6 ZW9mKFJlbEZpbGVOb2RlKTsKLQloYXNoX2N0bC5lbnRyeXNpemUgPSBzaXplb2YoUmVvcmRl ckJ1ZmZlclNlcXVlbmNlRW50KTsKLQloYXNoX2N0bC5oY3h0ID0gYnVmZmVyLT5jb250ZXh0 OwotCi0JYnVmZmVyLT5zZXF1ZW5jZXMgPSBoYXNoX2NyZWF0ZSgiUmVvcmRlckJ1ZmZlclNl cXVlbmNlSGFzaCIsIDEwMDAsICZoYXNoX2N0bCwKLQkJCQkJCQkJIEhBU0hfRUxFTSB8IEhB U0hfQkxPQlMgfCBIQVNIX0NPTlRFWFQpOwotCiAJYnVmZmVyLT5ieV90eG5fbGFzdF94aWQg PSBJbnZhbGlkVHJhbnNhY3Rpb25JZDsKIAlidWZmZXItPmJ5X3R4bl9sYXN0X3R4biA9IE5V TEw7CiAKQEAgLTU4MiwxNyArNTM1LDExIEBAIFJlb3JkZXJCdWZmZXJSZXR1cm5DaGFuZ2Uo UmVvcmRlckJ1ZmZlciAqcmIsIFJlb3JkZXJCdWZmZXJDaGFuZ2UgKmNoYW5nZSwKIAkJCQlj aGFuZ2UtPmRhdGEudHJ1bmNhdGUucmVsaWRzID0gTlVMTDsKIAkJCX0KIAkJCWJyZWFrOwot CQljYXNlIFJFT1JERVJfQlVGRkVSX0NIQU5HRV9TRVFVRU5DRToKLQkJCWlmIChjaGFuZ2Ut PmRhdGEuc2VxdWVuY2UudHVwbGUpCi0JCQl7Ci0JCQkJUmVvcmRlckJ1ZmZlclJldHVyblR1 cGxlQnVmKHJiLCBjaGFuZ2UtPmRhdGEuc2VxdWVuY2UudHVwbGUpOwotCQkJCWNoYW5nZS0+ ZGF0YS5zZXF1ZW5jZS50dXBsZSA9IE5VTEw7Ci0JCQl9Ci0JCQlicmVhazsKIAkJY2FzZSBS RU9SREVSX0JVRkZFUl9DSEFOR0VfSU5URVJOQUxfU1BFQ19DT05GSVJNOgogCQljYXNlIFJF T1JERVJfQlVGRkVSX0NIQU5HRV9JTlRFUk5BTF9TUEVDX0FCT1JUOgogCQljYXNlIFJFT1JE RVJfQlVGRkVSX0NIQU5HRV9JTlRFUk5BTF9DT01NQU5EX0lEOgogCQljYXNlIFJFT1JERVJf QlVGRkVSX0NIQU5HRV9JTlRFUk5BTF9UVVBMRUNJRDoKKwkJY2FzZSBSRU9SREVSX0JVRkZF Ul9DSEFOR0VfU0VRVUVOQ0U6CiAJCQlicmVhazsKIAl9CiAKQEAgLTkyMyw1NyArODcwLDYg QEAgUmVvcmRlckJ1ZmZlclF1ZXVlTWVzc2FnZShSZW9yZGVyQnVmZmVyICpyYiwgVHJhbnNh Y3Rpb25JZCB4aWQsCiAJfQogfQogCi0vKgotICogVHJlYXQgdGhlIHNlcXVlbmNlIGluY3Jl bWVudCBhcyB0cmFuc2FjdGlvbmFsPwotICoKLSAqIFRoZSBoYXNoIHRhYmxlIHRyYWNrcyBh bGwgc2VxdWVuY2VzIGNyZWF0ZWQgaW4gaW4tcHJvZ3Jlc3MgdHJhbnNhY3Rpb25zLAotICog c28gd2Ugc2ltcGx5IGRvIGEgbG9va3VwICh0aGUgc2VxdWVuY2UgaXMgaWRlbnRpZmllZCBi eSByZWxmaWxlbmRlKS4gSWYKLSAqIHdlIGZpbmQgYSBtYXRjaCwgdGhlIGluY3JlbWVudCBz aG91bGQgYmUgaGFuZGxlZCBhcyB0cmFuc2FjdGlvbmFsLgotICovCi1ib29sCi1SZW9yZGVy QnVmZmVyU2VxdWVuY2VJc1RyYW5zYWN0aW9uYWwoUmVvcmRlckJ1ZmZlciAqcmIsCi0JCQkJ CQkJCQkgUmVsRmlsZU5vZGUgcm5vZGUsIGJvb2wgY3JlYXRlZCkKLXsKLQlib29sCWZvdW5k ID0gZmFsc2U7Ci0KLQlpZiAoY3JlYXRlZCkKLQkJcmV0dXJuIHRydWU7Ci0KLQloYXNoX3Nl YXJjaChyYi0+c2VxdWVuY2VzLAotCQkJCSh2b2lkICopICZybm9kZSwKLQkJCQlIQVNIX0ZJ TkQsCi0JCQkJJmZvdW5kKTsKLQotCXJldHVybiBmb3VuZDsKLX0KLQotLyoKLSAqIENsZWFu dXAgc2VxdWVuY2VzIGNyZWF0ZWQgaW4gaW4tcHJvZ3Jlc3MgdHJhbnNhY3Rpb25zLgotICoK LSAqIFRoZXJlJ3Mgbm8gd2F5IHRvIHNlYXJjaCBieSBYSUQsIHNvIHdlIHNpbXBseSBkbyBh IHNlcXNjYW4gb2YgYWxsCi0gKiB0aGUgZW50cmllcyBpbiB0aGUgaGFzaCB0YWJsZS4gSG9w ZWZ1bGx5IHRoZXJlIGFyZSBvbmx5IGEgY291cGxlCi0gKiBlbnRyaWVzIGluIG1vc3QgY2Fz ZXMgLSBwZW9wbGUgZ2VuZXJhbGx5IGRvbid0IGNyZWF0ZSBtYW55IG5ldwotICogc2VxdWVu Y2VzIG92ZXIgYW5kIG92ZXIuCi0gKi8KLXN0YXRpYyB2b2lkCi1SZW9yZGVyQnVmZmVyU2Vx dWVuY2VDbGVhbnVwKFJlb3JkZXJCdWZmZXIgKnJiLCBUcmFuc2FjdGlvbklkIHhpZCkKLXsK LQlIQVNIX1NFUV9TVEFUVVMgc2Nhbl9zdGF0dXM7Ci0JUmVvcmRlckJ1ZmZlclNlcXVlbmNl RW50ICplbnQ7Ci0KLQloYXNoX3NlcV9pbml0KCZzY2FuX3N0YXR1cywgcmItPnNlcXVlbmNl cyk7Ci0Jd2hpbGUgKChlbnQgPSAoUmVvcmRlckJ1ZmZlclNlcXVlbmNlRW50ICopIGhhc2hf c2VxX3NlYXJjaCgmc2Nhbl9zdGF0dXMpKSAhPSBOVUxMKQotCXsKLQkJLyogc2tpcCBzZXF1 ZW5jZXMgbm90IGZyb20gdGhpcyB0cmFuc2FjdGlvbiAqLwotCQlpZiAoZW50LT54aWQgIT0g eGlkKQotCQkJY29udGludWU7Ci0KLQkJKHZvaWQpIGhhc2hfc2VhcmNoKHJiLT5zZXF1ZW5j ZXMsCi0JCQkJCSAgICh2b2lkICopICYoZW50LT5ybm9kZSksCi0JCQkJCSAgIEhBU0hfUkVN T1ZFLCBOVUxMKTsKLQl9Ci19Ci0KIC8qCiAgKiBBIHRyYW5zYWN0aW9uYWwgc2VxdWVuY2Ug aW5jcmVtZW50IGlzIHF1ZXVlZCB0byBiZSBwcm9jZXNzZWQgdXBvbiBjb21taXQKICAqIGFu ZCBhIG5vbi10cmFuc2FjdGlvbmFsIGluY3JlbWVudCBnZXRzIHByb2Nlc3NlZCBpbW1lZGlh dGVseS4KQEAgLTk4NSwxNjYgKzg4MSwzMiBAQCBSZW9yZGVyQnVmZmVyU2VxdWVuY2VDbGVh bnVwKFJlb3JkZXJCdWZmZXIgKnJiLCBUcmFuc2FjdGlvbklkIHhpZCkKICAqLwogdm9pZAog UmVvcmRlckJ1ZmZlclF1ZXVlU2VxdWVuY2UoUmVvcmRlckJ1ZmZlciAqcmIsIFRyYW5zYWN0 aW9uSWQgeGlkLAotCQkJCQkJICAgU25hcHNob3Qgc25hcHNob3QsIFhMb2dSZWNQdHIgbHNu LCBSZXBPcmlnaW5JZCBvcmlnaW5faWQsCi0JCQkJCQkgICBSZWxGaWxlTm9kZSBybm9kZSwg Ym9vbCB0cmFuc2FjdGlvbmFsLCBib29sIGNyZWF0ZWQsCi0JCQkJCQkgICBSZW9yZGVyQnVm ZmVyVHVwbGVCdWYgKnR1cGxlYnVmKQorCQkJCQkJICAgWExvZ1JlY1B0ciBsc24sIFJlcE9y aWdpbklkIG9yaWdpbl9pZCwKKwkJCQkJCSAgIE9pZCByZWxvaWQsIFJlbEZpbGVOb2RlIHJu b2RlLAorCQkJCQkJICAgaW50NjQgbGFzdCwgaW50NjQgbG9nX2NudCwgYm9vbCBpc19jYWxs ZWQpCiB7Ci0JLyoKLQkgKiBDaGFuZ2UgbmVlZHMgdG8gYmUgaGFuZGxlZCBhcyB0cmFuc2Fj dGlvbmFsLCBiZWNhdXNlIHRoZSBzZXF1ZW5jZSB3YXMKLQkgKiBjcmVhdGVkIGluIGEgdHJh bnNhY3Rpb24gdGhhdCBpcyBzdGlsbCBydW5uaW5nLiBJbiB0aGF0IGNhc2UgYWxsIHRoZQot CSAqIGNoYW5nZXMgbmVlZCB0byBiZSBxdWV1ZWQgaW4gdGhhdCB0cmFuc2FjdGlvbiwgd2Ug bXVzdCBub3Qgc2VuZCB0aGVtCi0JICogdG8gdGhlIGRvd25zdHJlYW0gdW50aWwgdGhlIHRy YW5zYWN0aW9uIGNvbW1pdHMuCi0JICoKLQkgKiBUaGVyZSdzIGEgYml0IG9mIGEgdHJvdWJs ZSB3aXRoIHN1YnRyYW5zYWN0aW9ucyAtIHdlIGNhbid0IHF1ZXVlIGl0Ci0JICogaW50byB0 aGUgc3VieGFjdCwgYmVjYXVzZSBpdCBtaWdodCBiZSByb2xsZWQgYmFjayBhbmQgd2UnZCBs b3NlIHRoZQotCSAqIGluY3JlbWVudC4gV2UgbmVlZCB0byBxdWV1ZSBpdCBpbnRvIHRoZSBz YW1lIChzdWIpeGFjdCB0aGF0IGNyZWF0ZWQKLQkgKiB0aGUgc2VxdWVuY2UsIHdoaWNoIGlz IHdoeSB3ZSB0cmFjayB0aGUgWElEIGluIHRoZSBoYXNoIHRhYmxlLgotCSAqLwotCWlmICh0 cmFuc2FjdGlvbmFsKQotCXsKLQkJTWVtb3J5Q29udGV4dCBvbGRjb250ZXh0OwotCQlSZW9y ZGVyQnVmZmVyQ2hhbmdlICpjaGFuZ2U7Ci0KLQkJLyogbG9va3VwIHNlcXVlbmNlIGJ5IHJl bGZpbGVub2RlICovCi0JCVJlb3JkZXJCdWZmZXJTZXF1ZW5jZUVudCAgICplbnQ7Ci0JCWJv b2wJCQkJCQlmb3VuZDsKLQotCQkvKiB0cmFuc2FjdGlvbmFsIGNoYW5nZXMgcmVxdWlyZSBh IHRyYW5zYWN0aW9uICovCi0JCUFzc2VydCh4aWQgIT0gSW52YWxpZFRyYW5zYWN0aW9uSWQp OwotCi0JCS8qIHNlYXJjaCB0aGUgbG9va3VwIHRhYmxlICh3ZSBpZ25vcmUgdGhlIHJldHVy biB2YWx1ZSwgZm91bmQgaXMgZW5vdWdoKSAqLwotCQllbnQgPSBoYXNoX3NlYXJjaChyYi0+ c2VxdWVuY2VzLAotCQkJCQkJICAodm9pZCAqKSAmcm5vZGUsCi0JCQkJCQkgIGNyZWF0ZWQg PyBIQVNIX0VOVEVSIDogSEFTSF9GSU5ELAotCQkJCQkJICAmZm91bmQpOwotCi0JCS8qCi0J CSAqIElmIHRoaXMgaXMgdGhlICJjcmVhdGUiIGluY3JlbWVudCwgd2UgbXVzdCBub3QgaGF2 ZSBmb3VuZCBhbnkKLQkJICogcHJlLWV4aXN0aW5nIGVudHJ5IGluIHRoZSBoYXNoIHRhYmxl IChpLmUuIHRoZXJlIG11c3Qgbm90IGJlCi0JCSAqIGFueSBjb25mbGljdGluZyBzZXF1ZW5j ZSkuCi0JCSAqLwotCQlBc3NlcnQoIShjcmVhdGVkICYmIGZvdW5kKSk7Ci0KLQkJLyogQnV0 IHdlIG11c3QgaGF2ZSBlaXRoZXIgY3JlYXRlZCBvciBmb3VuZCBhbiBleGlzdGluZyBlbnRy eS4gKi8KLQkJQXNzZXJ0KGNyZWF0ZWQgfHwgZm91bmQpOwotCi0JCS8qCi0JCSAqIFdoZW4g Y3JlYXRpbmcgdGhlIHNlcXVlbmNlLCByZW1lbWJlciB0aGUgWElEIG9mIHRoZSB0cmFuc2Fj dGlvbgotCQkgKiB0aGF0IGNyZWF0ZWQgaWQuCi0JCSAqLwotCQlpZiAoY3JlYXRlZCkKLQkJ CWVudC0+eGlkID0geGlkOwotCi0JCS8qIFhYWCBNYXliZSBjaGVjayB0aGF0IHdlJ3JlIHN0 aWxsIGluIHRoZSBzYW1lIHRvcC1sZXZlbCB4YWN0PyAqLwotCi0JCS8qIE9LLCBhbGxvY2F0 ZSBhbmQgcXVldWUgdGhlIGNoYW5nZSAqLwotCQlvbGRjb250ZXh0ID0gTWVtb3J5Q29udGV4 dFN3aXRjaFRvKHJiLT5jb250ZXh0KTsKLQotCQljaGFuZ2UgPSBSZW9yZGVyQnVmZmVyR2V0 Q2hhbmdlKHJiKTsKLQotCQljaGFuZ2UtPmFjdGlvbiA9IFJFT1JERVJfQlVGRkVSX0NIQU5H RV9TRVFVRU5DRTsKLQkJY2hhbmdlLT5vcmlnaW5faWQgPSBvcmlnaW5faWQ7Ci0KLQkJbWVt Y3B5KCZjaGFuZ2UtPmRhdGEuc2VxdWVuY2UucmVsbm9kZSwgJnJub2RlLCBzaXplb2YoUmVs RmlsZU5vZGUpKTsKLQotCQljaGFuZ2UtPmRhdGEuc2VxdWVuY2UudHVwbGUgPSB0dXBsZWJ1 ZjsKLQotCQkvKiBhZGQgaXQgdG8gdGhlIHNhbWUgc3VieGFjdCB0aGF0IGNyZWF0ZWQgdGhl IHNlcXVlbmNlICovCi0JCVJlb3JkZXJCdWZmZXJRdWV1ZUNoYW5nZShyYiwgZW50LT54aWQs IGxzbiwgY2hhbmdlLCBmYWxzZSk7Ci0KLQkJTWVtb3J5Q29udGV4dFN3aXRjaFRvKG9sZGNv bnRleHQpOwotCX0KLQllbHNlCi0JewotCQkvKgotCQkgKiBUaGlzIGluY3JlbWVudCBpcyBm b3IgYSBzZXF1ZW5jZSB0aGF0IHdhcyBub3QgY3JlYXRlZCBpbiBhbnkKLQkJICogcnVubmlu ZyB0cmFuc2FjdGlvbiwgc28gd2UgdHJlYXQgaXQgYXMgbm9uLXRyYW5zYWN0aW9uYWwgYW5k Ci0JCSAqIGp1c3Qgc2VuZCBpdCB0byB0aGUgb3V0cHV0IHBsdWdpbiBkaXJlY3RseS4KLQkJ ICovCi0JCVJlb3JkZXJCdWZmZXJUWE4gKnR4biA9IE5VTEw7Ci0JCXZvbGF0aWxlIFNuYXBz aG90IHNuYXBzaG90X25vdyA9IHNuYXBzaG90OwotCQlib29sCXVzaW5nX3N1YnR4bjsKLQot I2lmZGVmIFVTRV9BU1NFUlRfQ0hFQ0tJTkcKLQkJLyogQWxsICJjcmVhdGVzIiBoYXZlIHRv IGJlIGhhbmRsZWQgYXMgdHJhbnNhY3Rpb25hbC4gKi8KLQkJQXNzZXJ0KCFjcmVhdGVkKTsK LQotCQkvKiBNYWtlIHN1cmUgdGhlIHNlcXVlbmNlIGlzIG5vdCBpbiB0aGUgaGFzaCB0YWJs ZS4gKi8KLQkJewotCQkJYm9vbAlmb3VuZDsKLQkJCWhhc2hfc2VhcmNoKHJiLT5zZXF1ZW5j ZXMsCi0JCQkJCQkodm9pZCAqKSAmcm5vZGUsCi0JCQkJCQlIQVNIX0ZJTkQsICZmb3VuZCk7 Ci0JCQlBc3NlcnQoIWZvdW5kKTsKLQkJfQotI2VuZGlmCi0KLQkJaWYgKHhpZCAhPSBJbnZh bGlkVHJhbnNhY3Rpb25JZCkKLQkJCXR4biA9IFJlb3JkZXJCdWZmZXJUWE5CeVhpZChyYiwg eGlkLCB0cnVlLCBOVUxMLCBsc24sIHRydWUpOwotCi0JCS8qIHNldHVwIHNuYXBzaG90IHRv IGFsbG93IGNhdGFsb2cgYWNjZXNzICovCi0JCVNldHVwSGlzdG9yaWNTbmFwc2hvdChzbmFw c2hvdF9ub3csIE5VTEwpOwotCi0JCS8qCi0JCSAqIERlY29kaW5nIG5lZWRzIGFjY2VzcyB0 byBzeXNjYWNoZXMgZXQgYWwuLCB3aGljaCBpbiB0dXJuIHVzZQotCQkgKiBoZWF2eXdlaWdo dCBsb2NrcyBhbmQgc3VjaC4gVGh1cyB3ZSBuZWVkIHRvIGhhdmUgZW5vdWdoIHN0YXRlIGFy b3VuZCB0bwotCQkgKiBrZWVwIHRyYWNrIG9mIHRob3NlLiAgVGhlIGVhc2llc3Qgd2F5IGlz IHRvIHNpbXBseSB1c2UgYSB0cmFuc2FjdGlvbgotCQkgKiBpbnRlcm5hbGx5LiAgVGhhdCBh bHNvIGFsbG93cyB1cyB0byBlYXNpbHkgZW5mb3JjZSB0aGF0IG5vdGhpbmcgd3JpdGVzCi0J CSAqIHRvIHRoZSBkYXRhYmFzZSBieSBjaGVja2luZyBmb3IgeGlkIGFzc2lnbm1lbnRzLgot CQkgKgotCQkgKiBXaGVuIHdlJ3JlIGNhbGxlZCB2aWEgdGhlIFNRTCBTUkYgdGhlcmUncyBh bHJlYWR5IGEgdHJhbnNhY3Rpb24KLQkJICogc3RhcnRlZCwgc28gc3RhcnQgYW4gZXhwbGlj aXQgc3VidHJhbnNhY3Rpb24gdGhlcmUuCi0JCSAqLwotCQl1c2luZ19zdWJ0eG4gPSBJc1Ry YW5zYWN0aW9uT3JUcmFuc2FjdGlvbkJsb2NrKCk7Ci0KLQkJUEdfVFJZKCk7Ci0JCXsKLQkJ CVJlbGF0aW9uCXJlbGF0aW9uOwotCQkJSGVhcFR1cGxlCXR1cGxlOwotCQkJRm9ybV9wZ19z ZXF1ZW5jZV9kYXRhIHNlcTsKLQkJCU9pZAkJCXJlbG9pZDsKLQotCQkJaWYgKHVzaW5nX3N1 YnR4bikKLQkJCQlCZWdpbkludGVybmFsU3ViVHJhbnNhY3Rpb24oInNlcXVlbmNlIik7Ci0J CQllbHNlCi0JCQkJU3RhcnRUcmFuc2FjdGlvbkNvbW1hbmQoKTsKLQotCQkJcmVsb2lkID0g UmVsaWRCeVJlbGZpbGVub2RlKHJub2RlLnNwY05vZGUsIHJub2RlLnJlbE5vZGUpOwotCi0J CQlpZiAocmVsb2lkID09IEludmFsaWRPaWQpCi0JCQkJZWxvZyhFUlJPUiwgImNvdWxkIG5v dCBtYXAgZmlsZW5vZGUgXCIlc1wiIHRvIHJlbGF0aW9uIE9JRCIsCi0JCQkJCSByZWxwYXRo cGVybShybm9kZSwKLQkJCQkJCQkJIE1BSU5fRk9SS05VTSkpOwotCi0JCQlyZWxhdGlvbiA9 IFJlbGF0aW9uSWRHZXRSZWxhdGlvbihyZWxvaWQpOwotCQkJdHVwbGUgPSAmdHVwbGVidWYt PnR1cGxlOwotCQkJc2VxID0gKEZvcm1fcGdfc2VxdWVuY2VfZGF0YSkgR0VUU1RSVUNUKHR1 cGxlKTsKKwlNZW1vcnlDb250ZXh0IG9sZGNvbnRleHQ7CisJUmVvcmRlckJ1ZmZlckNoYW5n ZSAqY2hhbmdlOwogCi0JCQlyYi0+c2VxdWVuY2UocmIsIHR4biwgbHNuLCByZWxhdGlvbiwg dHJhbnNhY3Rpb25hbCwKLQkJCQkJCSBzZXEtPmxhc3RfdmFsdWUsIHNlcS0+bG9nX2NudCwg c2VxLT5pc19jYWxsZWQpOworCS8qIE9LLCBhbGxvY2F0ZSBhbmQgcXVldWUgdGhlIGNoYW5n ZSAqLworCW9sZGNvbnRleHQgPSBNZW1vcnlDb250ZXh0U3dpdGNoVG8ocmItPmNvbnRleHQp OwogCi0JCQlSZWxhdGlvbkNsb3NlKHJlbGF0aW9uKTsKKwljaGFuZ2UgPSBSZW9yZGVyQnVm ZmVyR2V0Q2hhbmdlKHJiKTsKIAotCQkJVGVhcmRvd25IaXN0b3JpY1NuYXBzaG90KGZhbHNl KTsKKwljaGFuZ2UtPmFjdGlvbiA9IFJFT1JERVJfQlVGRkVSX0NIQU5HRV9TRVFVRU5DRTsK KwljaGFuZ2UtPm9yaWdpbl9pZCA9IG9yaWdpbl9pZDsKIAotCQkJQWJvcnRDdXJyZW50VHJh bnNhY3Rpb24oKTsKKwltZW1jcHkoJmNoYW5nZS0+ZGF0YS5zZXF1ZW5jZS5yZWxub2RlLCAm cm5vZGUsIHNpemVvZihSZWxGaWxlTm9kZSkpOwogCi0JCQlpZiAodXNpbmdfc3VidHhuKQot CQkJCVJvbGxiYWNrQW5kUmVsZWFzZUN1cnJlbnRTdWJUcmFuc2FjdGlvbigpOwotCQl9Ci0J CVBHX0NBVENIKCk7Ci0JCXsKLQkJCVRlYXJkb3duSGlzdG9yaWNTbmFwc2hvdCh0cnVlKTsK KwljaGFuZ2UtPmRhdGEuc2VxdWVuY2UucmVsb2lkID0gcmVsb2lkOworCWNoYW5nZS0+ZGF0 YS5zZXF1ZW5jZS5sYXN0ID0gbGFzdDsKKwljaGFuZ2UtPmRhdGEuc2VxdWVuY2UubG9nX2Nu dCA9IGxvZ19jbnQ7CisJY2hhbmdlLT5kYXRhLnNlcXVlbmNlLmlzX2NhbGxlZCA9IGlzX2Nh bGxlZDsKIAotCQkJQWJvcnRDdXJyZW50VHJhbnNhY3Rpb24oKTsKLQotCQkJaWYgKHVzaW5n X3N1YnR4bikKLQkJCQlSb2xsYmFja0FuZFJlbGVhc2VDdXJyZW50U3ViVHJhbnNhY3Rpb24o KTsKKwkvKiBhZGQgaXQgdG8gdGhlIHNhbWUgc3VieGFjdCB0aGF0IGNyZWF0ZWQgdGhlIHNl cXVlbmNlICovCisJUmVvcmRlckJ1ZmZlclF1ZXVlQ2hhbmdlKHJiLCB4aWQsIGxzbiwgY2hh bmdlLCBmYWxzZSk7CiAKLQkJCVBHX1JFX1RIUk9XKCk7Ci0JCX0KLQkJUEdfRU5EX1RSWSgp OwotCX0KKwlNZW1vcnlDb250ZXh0U3dpdGNoVG8ob2xkY29udGV4dCk7CiB9CiAKIC8qCkBA IC0xODIzLDkgKzE1ODUsNiBAQCBSZW9yZGVyQnVmZmVyQ2xlYW51cFRYTihSZW9yZGVyQnVm ZmVyICpyYiwgUmVvcmRlckJ1ZmZlclRYTiAqdHhuKQogCQkJCSZmb3VuZCk7CiAJQXNzZXJ0 KGZvdW5kKTsKIAotCS8qIFJlbW92ZSBzZXF1ZW5jZXMgY3JlYXRlZCBpbiB0aGlzIHRyYW5z YWN0aW9uIChpZiBhbnkpLiAqLwotCVJlb3JkZXJCdWZmZXJTZXF1ZW5jZUNsZWFudXAocmIs IHR4bi0+eGlkKTsKLQogCS8qIHJlbW92ZSBlbnRyaWVzIHNwaWxsZWQgdG8gZGlzayAqLwog CWlmIChyYnR4bl9pc19zZXJpYWxpemVkKHR4bikpCiAJCVJlb3JkZXJCdWZmZXJSZXN0b3Jl Q2xlYW51cChyYiwgdHhuKTsKQEAgLTIyNDksMTkgKzIwMDgsMjMgQEAgUmVvcmRlckJ1ZmZl ckFwcGx5U2VxdWVuY2UoUmVvcmRlckJ1ZmZlciAqcmIsIFJlb3JkZXJCdWZmZXJUWE4gKnR4 biwKIAkJCQkJCSAgIFJlbGF0aW9uIHJlbGF0aW9uLCBSZW9yZGVyQnVmZmVyQ2hhbmdlICpj aGFuZ2UsCiAJCQkJCQkgICBib29sIHN0cmVhbWluZykKIHsKLQlIZWFwVHVwbGUJdHVwbGU7 Ci0JRm9ybV9wZ19zZXF1ZW5jZV9kYXRhIHNlcTsKLQotCXR1cGxlID0gJmNoYW5nZS0+ZGF0 YS5zZXF1ZW5jZS50dXBsZS0+dHVwbGU7Ci0Jc2VxID0gKEZvcm1fcGdfc2VxdWVuY2VfZGF0 YSkgR0VUU1RSVUNUKHR1cGxlKTsKKwlpbnQ2NAkJbGFzdF92YWx1ZSwgbG9nX2NudDsKKwli b29sCQlpc19jYWxsZWQ7CisvKgorICogRklYTUUgaXMgaXQgcG9zc2libGUgdGhhdCB3ZSB3 cml0ZSBzZXF1ZW5jZSBzdGF0ZSBmb3IgVDEgYmVmb3JlIFQyLCBidXQKKyAqIHRoZW4gZW5k IHVwIGNvbW1pdHRpbmcgVDIgZmlyc3Q/IElmIHRoZSBzZXF1ZW5jZSBjb3VsZCBiZSBpbmNy ZW1lbnRlZAorICogaW4gYmV0d2VlbiwgdGhhdCBtaWdodCBjYXVzZSBkYXRhIGNvcnJ1cHRp b24gcmVzdWx0LgorICovCisJbGFzdF92YWx1ZSA9IGNoYW5nZS0+ZGF0YS5zZXF1ZW5jZS5s YXN0OworCWxvZ19jbnQgPSBjaGFuZ2UtPmRhdGEuc2VxdWVuY2UubG9nX2NudDsKKwlpc19j YWxsZWQgPSBjaGFuZ2UtPmRhdGEuc2VxdWVuY2UuaXNfY2FsbGVkOwogCi0JLyogT25seSBl dmVyIGNhbGxlZCBmcm9tIFJlb3JkZXJCdWZmZXJBcHBseVNlcXVlbmNlLCBzbyB0cmFuc2F0 aW9uYWwuICovCiAJaWYgKHN0cmVhbWluZykKLQkJcmItPnN0cmVhbV9zZXF1ZW5jZShyYiwg dHhuLCBjaGFuZ2UtPmxzbiwgcmVsYXRpb24sIHRydWUsCi0JCQkJCQkJc2VxLT5sYXN0X3Zh bHVlLCBzZXEtPmxvZ19jbnQsIHNlcS0+aXNfY2FsbGVkKTsKKwkJcmItPnN0cmVhbV9zZXF1 ZW5jZShyYiwgdHhuLCBjaGFuZ2UtPmxzbiwgcmVsYXRpb24sCisJCQkJCQkJbGFzdF92YWx1 ZSwgbG9nX2NudCwgaXNfY2FsbGVkKTsKIAllbHNlCi0JCXJiLT5zZXF1ZW5jZShyYiwgdHhu LCBjaGFuZ2UtPmxzbiwgcmVsYXRpb24sIHRydWUsCi0JCQkJCSBzZXEtPmxhc3RfdmFsdWUs IHNlcS0+bG9nX2NudCwgc2VxLT5pc19jYWxsZWQpOworCQlyYi0+c2VxdWVuY2UocmIsIHR4 biwgY2hhbmdlLT5sc24sIHJlbGF0aW9uLAorCQkJCQkgbGFzdF92YWx1ZSwgbG9nX2NudCwg aXNfY2FsbGVkKTsKIH0KIAogLyoKQEAgLTI3MTAsMTUgKzI0NzMsMTcgQEAgUmVvcmRlckJ1 ZmZlclByb2Nlc3NUWE4oUmVvcmRlckJ1ZmZlciAqcmIsIFJlb3JkZXJCdWZmZXJUWE4gKnR4 biwKIAkJCQljYXNlIFJFT1JERVJfQlVGRkVSX0NIQU5HRV9TRVFVRU5DRToKIAkJCQkJQXNz ZXJ0KHNuYXBzaG90X25vdyk7CiAKKwkJCQkJLyoKIAkJCQkJcmVsb2lkID0gUmVsaWRCeVJl bGZpbGVub2RlKGNoYW5nZS0+ZGF0YS5zZXF1ZW5jZS5yZWxub2RlLnNwY05vZGUsCiAJCQkJ CQkJCQkJCQljaGFuZ2UtPmRhdGEuc2VxdWVuY2UucmVsbm9kZS5yZWxOb2RlKTsKIAogCQkJ CQlpZiAocmVsb2lkID09IEludmFsaWRPaWQpCi0JCQkJCQllbG9nKEVSUk9SLCAiY291bGQg bm90IG1hcCBmaWxlbm9kZSBcIiVzXCIgdG8gcmVsYXRpb24gT0lEIiwKKwkJCQkJCWVsb2co RVJST1IsICJ6eiBjb3VsZCBub3QgbWFwIGZpbGVub2RlIFwiJXNcIiB0byByZWxhdGlvbiBP SUQiLAogCQkJCQkJCSByZWxwYXRocGVybShjaGFuZ2UtPmRhdGEuc2VxdWVuY2UucmVsbm9k ZSwKIAkJCQkJCQkJCQkgTUFJTl9GT1JLTlVNKSk7CiAKLQkJCQkJcmVsYXRpb24gPSBSZWxh dGlvbklkR2V0UmVsYXRpb24ocmVsb2lkKTsKKwkJCQkJKi8KKwkJCQkJcmVsYXRpb24gPSBS ZWxhdGlvbklkR2V0UmVsYXRpb24oY2hhbmdlLT5kYXRhLnNlcXVlbmNlLnJlbG9pZCk7CiAK IAkJCQkJaWYgKCFSZWxhdGlvbklzVmFsaWQocmVsYXRpb24pKQogCQkJCQkJZWxvZyhFUlJP UiwgImNvdWxkIG5vdCBvcGVuIHJlbGF0aW9uIHdpdGggT0lEICV1IChmb3IgZmlsZW5vZGUg XCIlc1wiKSIsCkBAIC00MTE1LDQ1ICszODgwLDEzIEBAIFJlb3JkZXJCdWZmZXJTZXJpYWxp emVDaGFuZ2UoUmVvcmRlckJ1ZmZlciAqcmIsIFJlb3JkZXJCdWZmZXJUWE4gKnR4biwKIAkJ CQltZW1jcHkoZGF0YSwgY2hhbmdlLT5kYXRhLnRydW5jYXRlLnJlbGlkcywgc2l6ZSk7CiAJ CQkJZGF0YSArPSBzaXplOwogCi0JCQkJYnJlYWs7Ci0JCQl9Ci0JCWNhc2UgUkVPUkRFUl9C VUZGRVJfQ0hBTkdFX1NFUVVFTkNFOgotCQkJewotCQkJCWNoYXIJICAgKmRhdGE7Ci0JCQkJ UmVvcmRlckJ1ZmZlclR1cGxlQnVmICp0dXA7Ci0JCQkJU2l6ZQkJbGVuID0gMDsKLQotCQkJ CXR1cCA9IGNoYW5nZS0+ZGF0YS5zZXF1ZW5jZS50dXBsZTsKLQotCQkJCWlmICh0dXApCi0J CQkJewotCQkJCQlzeiArPSBzaXplb2YoSGVhcFR1cGxlRGF0YSk7Ci0JCQkJCWxlbiA9IHR1 cC0+dHVwbGUudF9sZW47Ci0JCQkJCXN6ICs9IGxlbjsKLQkJCQl9Ci0KLQkJCQkvKiBtYWtl IHN1cmUgd2UgaGF2ZSBlbm91Z2ggc3BhY2UgKi8KLQkJCQlSZW9yZGVyQnVmZmVyU2VyaWFs aXplUmVzZXJ2ZShyYiwgc3opOwotCi0JCQkJZGF0YSA9ICgoY2hhciAqKSByYi0+b3V0YnVm KSArIHNpemVvZihSZW9yZGVyQnVmZmVyRGlza0NoYW5nZSk7Ci0JCQkJLyogbWlnaHQgaGF2 ZSBiZWVuIHJlYWxsb2NhdGVkIGFib3ZlICovCi0JCQkJb25kaXNrID0gKFJlb3JkZXJCdWZm ZXJEaXNrQ2hhbmdlICopIHJiLT5vdXRidWY7Ci0KLQkJCQlpZiAobGVuKQotCQkJCXsKLQkJ CQkJbWVtY3B5KGRhdGEsICZ0dXAtPnR1cGxlLCBzaXplb2YoSGVhcFR1cGxlRGF0YSkpOwot CQkJCQlkYXRhICs9IHNpemVvZihIZWFwVHVwbGVEYXRhKTsKLQotCQkJCQltZW1jcHkoZGF0 YSwgdHVwLT50dXBsZS50X2RhdGEsIGxlbik7Ci0JCQkJCWRhdGEgKz0gbGVuOwotCQkJCX0K LQogCQkJCWJyZWFrOwogCQkJfQogCQljYXNlIFJFT1JERVJfQlVGRkVSX0NIQU5HRV9JTlRF Uk5BTF9TUEVDX0NPTkZJUk06CiAJCWNhc2UgUkVPUkRFUl9CVUZGRVJfQ0hBTkdFX0lOVEVS TkFMX1NQRUNfQUJPUlQ6CiAJCWNhc2UgUkVPUkRFUl9CVUZGRVJfQ0hBTkdFX0lOVEVSTkFM X0NPTU1BTkRfSUQ6CiAJCWNhc2UgUkVPUkRFUl9CVUZGRVJfQ0hBTkdFX0lOVEVSTkFMX1RV UExFQ0lEOgorCQljYXNlIFJFT1JERVJfQlVGRkVSX0NIQU5HRV9TRVFVRU5DRToKIAkJCS8q IFJlb3JkZXJCdWZmZXJDaGFuZ2UgY29udGFpbnMgZXZlcnl0aGluZyBpbXBvcnRhbnQgKi8K IAkJCWJyZWFrOwogCX0KQEAgLTQ0MTIsMjggKzQxNDUsMTMgQEAgUmVvcmRlckJ1ZmZlckNo YW5nZVNpemUoUmVvcmRlckJ1ZmZlckNoYW5nZSAqY2hhbmdlKQogCQkJewogCQkJCXN6ICs9 IHNpemVvZihPaWQpICogY2hhbmdlLT5kYXRhLnRydW5jYXRlLm5yZWxpZHM7CiAKLQkJCQli cmVhazsKLQkJCX0KLQkJY2FzZSBSRU9SREVSX0JVRkZFUl9DSEFOR0VfU0VRVUVOQ0U6Ci0J CQl7Ci0JCQkJUmVvcmRlckJ1ZmZlclR1cGxlQnVmICp0dXA7Ci0JCQkJU2l6ZQkJbGVuID0g MDsKLQotCQkJCXR1cCA9IGNoYW5nZS0+ZGF0YS5zZXF1ZW5jZS50dXBsZTsKLQotCQkJCWlm ICh0dXApCi0JCQkJewotCQkJCQlzeiArPSBzaXplb2YoSGVhcFR1cGxlRGF0YSk7Ci0JCQkJ CWxlbiA9IHR1cC0+dHVwbGUudF9sZW47Ci0JCQkJCXN6ICs9IGxlbjsKLQkJCQl9Ci0KIAkJ CQlicmVhazsKIAkJCX0KIAkJY2FzZSBSRU9SREVSX0JVRkZFUl9DSEFOR0VfSU5URVJOQUxf U1BFQ19DT05GSVJNOgogCQljYXNlIFJFT1JERVJfQlVGRkVSX0NIQU5HRV9JTlRFUk5BTF9T UEVDX0FCT1JUOgogCQljYXNlIFJFT1JERVJfQlVGRkVSX0NIQU5HRV9JTlRFUk5BTF9DT01N QU5EX0lEOgogCQljYXNlIFJFT1JERVJfQlVGRkVSX0NIQU5HRV9JTlRFUk5BTF9UVVBMRUNJ RDoKKwkJY2FzZSBSRU9SREVSX0JVRkZFUl9DSEFOR0VfU0VRVUVOQ0U6CiAJCQkvKiBSZW9y ZGVyQnVmZmVyQ2hhbmdlIGNvbnRhaW5zIGV2ZXJ5dGhpbmcgaW1wb3J0YW50ICovCiAJCQli cmVhazsKIAl9CkBAIC00NzI5LDM0ICs0NDQ3LDExIEBAIFJlb3JkZXJCdWZmZXJSZXN0b3Jl Q2hhbmdlKFJlb3JkZXJCdWZmZXIgKnJiLCBSZW9yZGVyQnVmZmVyVFhOICp0eG4sCiAKIAkJ CQlicmVhazsKIAkJCX0KLQotCQljYXNlIFJFT1JERVJfQlVGRkVSX0NIQU5HRV9TRVFVRU5D RToKLQkJCWlmIChjaGFuZ2UtPmRhdGEuc2VxdWVuY2UudHVwbGUpCi0JCQl7Ci0JCQkJdWlu dDMyCQl0dXBsZWxlbiA9ICgoSGVhcFR1cGxlKSBkYXRhKS0+dF9sZW47Ci0KLQkJCQljaGFu Z2UtPmRhdGEuc2VxdWVuY2UudHVwbGUgPQotCQkJCQlSZW9yZGVyQnVmZmVyR2V0VHVwbGVC dWYocmIsIHR1cGxlbGVuIC0gU2l6ZW9mSGVhcFR1cGxlSGVhZGVyKTsKLQotCQkJCS8qIHJl c3RvcmUgLT50dXBsZSAqLwotCQkJCW1lbWNweSgmY2hhbmdlLT5kYXRhLnNlcXVlbmNlLnR1 cGxlLT50dXBsZSwgZGF0YSwKLQkJCQkJICAgc2l6ZW9mKEhlYXBUdXBsZURhdGEpKTsKLQkJ CQlkYXRhICs9IHNpemVvZihIZWFwVHVwbGVEYXRhKTsKLQotCQkJCS8qIHJlc2V0IHRfZGF0 YSBwb2ludGVyIGludG8gdGhlIG5ldyB0dXBsZWJ1ZiAqLwotCQkJCWNoYW5nZS0+ZGF0YS5z ZXF1ZW5jZS50dXBsZS0+dHVwbGUudF9kYXRhID0KLQkJCQkJUmVvcmRlckJ1ZmZlclR1cGxl QnVmRGF0YShjaGFuZ2UtPmRhdGEuc2VxdWVuY2UudHVwbGUpOwotCi0JCQkJLyogcmVzdG9y ZSB0dXBsZSBkYXRhIGl0c2VsZiAqLwotCQkJCW1lbWNweShjaGFuZ2UtPmRhdGEuc2VxdWVu Y2UudHVwbGUtPnR1cGxlLnRfZGF0YSwgZGF0YSwgdHVwbGVsZW4pOwotCQkJCWRhdGEgKz0g dHVwbGVsZW47Ci0JCQl9Ci0JCQlicmVhazsKLQogCQljYXNlIFJFT1JERVJfQlVGRkVSX0NI QU5HRV9JTlRFUk5BTF9TUEVDX0NPTkZJUk06CiAJCWNhc2UgUkVPUkRFUl9CVUZGRVJfQ0hB TkdFX0lOVEVSTkFMX1NQRUNfQUJPUlQ6CiAJCWNhc2UgUkVPUkRFUl9CVUZGRVJfQ0hBTkdF X0lOVEVSTkFMX0NPTU1BTkRfSUQ6CiAJCWNhc2UgUkVPUkRFUl9CVUZGRVJfQ0hBTkdFX0lO VEVSTkFMX1RVUExFQ0lEOgorCQljYXNlIFJFT1JERVJfQlVGRkVSX0NIQU5HRV9TRVFVRU5D RToKIAkJCWJyZWFrOwogCX0KIApkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvcmVwbGljYXRp b24vbG9naWNhbC90YWJsZXN5bmMuYyBiL3NyYy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2lj YWwvdGFibGVzeW5jLmMKaW5kZXggNjk3ZmIyMzYzNGMuLmQ2YWRiZDZlNDZkIDEwMDY0NAot LS0gYS9zcmMvYmFja2VuZC9yZXBsaWNhdGlvbi9sb2dpY2FsL3RhYmxlc3luYy5jCisrKyBi L3NyYy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwvdGFibGVzeW5jLmMKQEAgLTEyMjAs OCArMTIyMCw3IEBAIGNvcHlfc2VxdWVuY2UoUmVsYXRpb24gcmVsKQogCiAJZmV0Y2hfc2Vx dWVuY2VfZGF0YShscmVsLm5zcG5hbWUsIGxyZWwucmVsbmFtZSwgJmxhc3RfdmFsdWUsICZs b2dfY250LCAmaXNfY2FsbGVkKTsKIAotCS8qIHRhYmxlc3luYyBzZXRzIHRoZSBzZXF1ZW5j ZXMgaW4gbm9uLXRyYW5zYWN0aW9uYWwgd2F5ICovCi0JU2V0U2VxdWVuY2UoUmVsYXRpb25H ZXRSZWxpZChyZWwpLCBmYWxzZSwgbGFzdF92YWx1ZSwgbG9nX2NudCwgaXNfY2FsbGVkKTsK KwlTZXRTZXF1ZW5jZShSZWxhdGlvbkdldFJlbGlkKHJlbCksIGxhc3RfdmFsdWUsIGxvZ19j bnQsIGlzX2NhbGxlZCk7CiAKIAlsb2dpY2FscmVwX3JlbF9jbG9zZShyZWxtYXBlbnRyeSwg Tm9Mb2NrKTsKIH0KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2lj YWwvd29ya2VyLmMgYi9zcmMvYmFja2VuZC9yZXBsaWNhdGlvbi9sb2dpY2FsL3dvcmtlci5j CmluZGV4IGYzODY4YjNlMWY4Li5mYmM2NWYyNzdlYSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tl bmQvcmVwbGljYXRpb24vbG9naWNhbC93b3JrZXIuYworKysgYi9zcmMvYmFja2VuZC9yZXBs aWNhdGlvbi9sb2dpY2FsL3dvcmtlci5jCkBAIC0xMTU5LDEyICsxMTU5LDkgQEAgYXBwbHlf aGFuZGxlX3NlcXVlbmNlKFN0cmluZ0luZm8gcykKIAlsb2dpY2FscmVwX3JlYWRfc2VxdWVu Y2UocywgJnNlcSk7CiAKIAkvKgotCSAqIE5vbi10cmFuc2FjdGlvbmFsIHNlcXVlbmNlIHVw ZGF0ZXMgc2hvdWxkIG5vdCBiZSBwYXJ0IG9mIGEgcmVtb3RlCi0JICogdHJhbnNhY3Rpb24u IFRoZXJlIHNob3VsZCBub3QgYmUgYW55IHJ1bm5pbmcgdHJhbnNhY3Rpb24uCisJICogV2Ug c2hvdWxkIGJlIGluIHJlbW90ZSB0cmFuc2FjdGlvbi4KIAkgKi8KLQlBc3NlcnQoKCFzZXEu dHJhbnNhY3Rpb25hbCkgfHwgaW5fcmVtb3RlX3RyYW5zYWN0aW9uKTsKLQlBc3NlcnQoISgh c2VxLnRyYW5zYWN0aW9uYWwgJiYgaW5fcmVtb3RlX3RyYW5zYWN0aW9uKSk7Ci0JQXNzZXJ0 KCEoIXNlcS50cmFuc2FjdGlvbmFsICYmIElzVHJhbnNhY3Rpb25TdGF0ZSgpKSk7CisJQXNz ZXJ0KGluX3JlbW90ZV90cmFuc2FjdGlvbik7CiAKIAkvKgogCSAqIE1ha2Ugc3VyZSB3ZSdy ZSBpbiBhIHRyYW5zYWN0aW9uIChuZWVkZWQgYnkgU2V0U2VxdWVuY2UpLiBGb3IKQEAgLTEx ODUsMTQgKzExODIsNyBAQCBhcHBseV9oYW5kbGVfc2VxdWVuY2UoU3RyaW5nSW5mbyBzKQog CUxvY2tSZWxhdGlvbk9pZChyZWxpZCwgQWNjZXNzRXhjbHVzaXZlTG9jayk7CiAKIAkvKiBh cHBseSB0aGUgc2VxdWVuY2UgY2hhbmdlICovCi0JU2V0U2VxdWVuY2UocmVsaWQsIHNlcS50 cmFuc2FjdGlvbmFsLCBzZXEubGFzdF92YWx1ZSwgc2VxLmxvZ19jbnQsIHNlcS5pc19jYWxs ZWQpOwotCi0JLyoKLQkgKiBDb21taXQgdGhlIHBlci1zdHJlYW0gdHJhbnNhY3Rpb24gKHdl IG9ubHkgZG8gdGhpcyB3aGVuIG5vdCBpbgotCSAqIHJlbW90ZSB0cmFuc2FjdGlvbiwgaS5l LiBmb3Igbm9uLXRyYW5zYWN0aW9uYWwgc2VxdWVuY2UgdXBkYXRlcy4KLQkgKi8KLQlpZiAo IWluX3JlbW90ZV90cmFuc2FjdGlvbikKLQkJQ29tbWl0VHJhbnNhY3Rpb25Db21tYW5kKCk7 CisJU2V0U2VxdWVuY2UocmVsaWQsIHNlcS5sYXN0X3ZhbHVlLCBzZXEubG9nX2NudCwgc2Vx LmlzX2NhbGxlZCk7CiB9CiAKIC8qCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9yZXBsaWNh dGlvbi9wZ291dHB1dC9wZ291dHB1dC5jIGIvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vcGdv dXRwdXQvcGdvdXRwdXQuYwppbmRleCA5ZDMzNjMwNDY0Yy4uMzFiZTgwNjRlYmUgMTAwNjQ0 Ci0tLSBhL3NyYy9iYWNrZW5kL3JlcGxpY2F0aW9uL3Bnb3V0cHV0L3Bnb3V0cHV0LmMKKysr IGIvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vcGdvdXRwdXQvcGdvdXRwdXQuYwpAQCAtNTcs NyArNTcsNyBAQCBzdGF0aWMgdm9pZCBwZ291dHB1dF9tZXNzYWdlKExvZ2ljYWxEZWNvZGlu Z0NvbnRleHQgKmN0eCwKIAkJCQkJCQkgU2l6ZSBzeiwgY29uc3QgY2hhciAqbWVzc2FnZSk7 CiBzdGF0aWMgdm9pZCBwZ291dHB1dF9zZXF1ZW5jZShMb2dpY2FsRGVjb2RpbmdDb250ZXh0 ICpjdHgsCiAJCQkJCQkJICBSZW9yZGVyQnVmZmVyVFhOICp0eG4sIFhMb2dSZWNQdHIgc2Vx dWVuY2VfbHNuLAotCQkJCQkJCSAgUmVsYXRpb24gcmVsYXRpb24sIGJvb2wgdHJhbnNhY3Rp b25hbCwKKwkJCQkJCQkgIFJlbGF0aW9uIHJlbGF0aW9uLAogCQkJCQkJCSAgaW50NjQgbGFz dF92YWx1ZSwgaW50NjQgbG9nX2NudCwgYm9vbCBpc19jYWxsZWQpOwogc3RhdGljIGJvb2wg cGdvdXRwdXRfb3JpZ2luX2ZpbHRlcihMb2dpY2FsRGVjb2RpbmdDb250ZXh0ICpjdHgsCiAJ CQkJCQkJCSAgIFJlcE9yaWdpbklkIG9yaWdpbl9pZCk7CkBAIC0xNzEyLDEyICsxNzEyLDEz IEBAIHBnb3V0cHV0X21lc3NhZ2UoTG9naWNhbERlY29kaW5nQ29udGV4dCAqY3R4LCBSZW9y ZGVyQnVmZmVyVFhOICp0eG4sCiBzdGF0aWMgdm9pZAogcGdvdXRwdXRfc2VxdWVuY2UoTG9n aWNhbERlY29kaW5nQ29udGV4dCAqY3R4LAogCQkJCSAgUmVvcmRlckJ1ZmZlclRYTiAqdHhu LCBYTG9nUmVjUHRyIHNlcXVlbmNlX2xzbiwKLQkJCQkgIFJlbGF0aW9uIHJlbGF0aW9uLCBi b29sIHRyYW5zYWN0aW9uYWwsCisJCQkJICBSZWxhdGlvbiByZWxhdGlvbiwKIAkJCQkgIGlu dDY0IGxhc3RfdmFsdWUsIGludDY0IGxvZ19jbnQsIGJvb2wgaXNfY2FsbGVkKQogewogCVBH T3V0cHV0RGF0YSAqZGF0YSA9IChQR091dHB1dERhdGEgKikgY3R4LT5vdXRwdXRfcGx1Z2lu X3ByaXZhdGU7CiAJVHJhbnNhY3Rpb25JZCB4aWQgPSBJbnZhbGlkVHJhbnNhY3Rpb25JZDsK IAlSZWxhdGlvblN5bmNFbnRyeSAqcmVsZW50cnk7CisJUEdPdXRwdXRUeG5EYXRhICp0eG5k YXRhID0gKFBHT3V0cHV0VHhuRGF0YSAqKSB0eG4tPm91dHB1dF9wbHVnaW5fcHJpdmF0ZTsK IAogCWlmICghZGF0YS0+c2VxdWVuY2VzKQogCQlyZXR1cm47CkBAIC0xNzQyLDI1ICsxNzQz LDE1IEBAIHBnb3V0cHV0X3NlcXVlbmNlKExvZ2ljYWxEZWNvZGluZ0NvbnRleHQgKmN0eCwK IAlpZiAoIXJlbGVudHJ5LT5wdWJhY3Rpb25zLnB1YnNlcXVlbmNlKQogCQlyZXR1cm47CiAK LQkvKgotCSAqIE91dHB1dCBCRUdJTiBpZiB3ZSBoYXZlbid0IHlldC4gQXZvaWQgZm9yIG5v bi10cmFuc2FjdGlvbmFsCi0JICogc2VxdWVuY2UgY2hhbmdlcy4KLQkgKi8KLQlpZiAodHJh bnNhY3Rpb25hbCkKLQl7Ci0JCVBHT3V0cHV0VHhuRGF0YSAqdHhuZGF0YSA9IChQR091dHB1 dFR4bkRhdGEgKikgdHhuLT5vdXRwdXRfcGx1Z2luX3ByaXZhdGU7Ci0KLQkJLyogU2VuZCBC RUdJTiBpZiB3ZSBoYXZlbid0IHlldCAqLwotCQlpZiAodHhuZGF0YSAmJiAhdHhuZGF0YS0+ c2VudF9iZWdpbl90eG4pCi0JCQlwZ291dHB1dF9zZW5kX2JlZ2luKGN0eCwgdHhuKTsKLQl9 CisJLyogU2VuZCBCRUdJTiBpZiB3ZSBoYXZlbid0IHlldCAqLworCWlmICh0eG5kYXRhICYm ICF0eG5kYXRhLT5zZW50X2JlZ2luX3R4bikKKwkJcGdvdXRwdXRfc2VuZF9iZWdpbihjdHgs IHR4bik7CiAKIAlPdXRwdXRQbHVnaW5QcmVwYXJlV3JpdGUoY3R4LCB0cnVlKTsKIAlsb2dp Y2FscmVwX3dyaXRlX3NlcXVlbmNlKGN0eC0+b3V0LAogCQkJCQkJCSAgcmVsYXRpb24sCiAJ CQkJCQkJICB4aWQsCiAJCQkJCQkJICBzZXF1ZW5jZV9sc24sCi0JCQkJCQkJICB0cmFuc2Fj dGlvbmFsLAogCQkJCQkJCSAgbGFzdF92YWx1ZSwKIAkJCQkJCQkgIGxvZ19jbnQsCiAJCQkJ CQkJICBpc19jYWxsZWQpOwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvYWNjZXNzL3JtZ3Js aXN0LmggYi9zcmMvaW5jbHVkZS9hY2Nlc3Mvcm1ncmxpc3QuaAppbmRleCBjZjhiNmQ0ODE5 My4uOWE3NDcyMWM5N2MgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL2FjY2Vzcy9ybWdybGlz dC5oCisrKyBiL3NyYy9pbmNsdWRlL2FjY2Vzcy9ybWdybGlzdC5oCkBAIC00MCw3ICs0MCw3 IEBAIFBHX1JNR1IoUk1fQlRSRUVfSUQsICJCdHJlZSIsIGJ0cmVlX3JlZG8sIGJ0cmVlX2Rl c2MsIGJ0cmVlX2lkZW50aWZ5LCBidHJlZV94bG9nCiBQR19STUdSKFJNX0hBU0hfSUQsICJI YXNoIiwgaGFzaF9yZWRvLCBoYXNoX2Rlc2MsIGhhc2hfaWRlbnRpZnksIE5VTEwsIE5VTEws IGhhc2hfbWFzaywgTlVMTCkKIFBHX1JNR1IoUk1fR0lOX0lELCAiR2luIiwgZ2luX3JlZG8s IGdpbl9kZXNjLCBnaW5faWRlbnRpZnksIGdpbl94bG9nX3N0YXJ0dXAsIGdpbl94bG9nX2Ns ZWFudXAsIGdpbl9tYXNrLCBOVUxMKQogUEdfUk1HUihSTV9HSVNUX0lELCAiR2lzdCIsIGdp c3RfcmVkbywgZ2lzdF9kZXNjLCBnaXN0X2lkZW50aWZ5LCBnaXN0X3hsb2dfc3RhcnR1cCwg Z2lzdF94bG9nX2NsZWFudXAsIGdpc3RfbWFzaywgTlVMTCkKLVBHX1JNR1IoUk1fU0VRX0lE LCAiU2VxdWVuY2UiLCBzZXFfcmVkbywgc2VxX2Rlc2MsIHNlcV9pZGVudGlmeSwgTlVMTCwg TlVMTCwgc2VxX21hc2ssIHNlcXVlbmNlX2RlY29kZSkKK1BHX1JNR1IoUk1fU0VRX0lELCAi U2VxdWVuY2UiLCBzZXFfcmVkbywgc2VxX2Rlc2MsIHNlcV9pZGVudGlmeSwgTlVMTCwgTlVM TCwgc2VxX21hc2ssIE5VTEwpCiBQR19STUdSKFJNX1NQR0lTVF9JRCwgIlNQR2lzdCIsIHNw Z19yZWRvLCBzcGdfZGVzYywgc3BnX2lkZW50aWZ5LCBzcGdfeGxvZ19zdGFydHVwLCBzcGdf eGxvZ19jbGVhbnVwLCBzcGdfbWFzaywgTlVMTCkKIFBHX1JNR1IoUk1fQlJJTl9JRCwgIkJS SU4iLCBicmluX3JlZG8sIGJyaW5fZGVzYywgYnJpbl9pZGVudGlmeSwgTlVMTCwgTlVMTCwg YnJpbl9tYXNrLCBOVUxMKQogUEdfUk1HUihSTV9DT01NSVRfVFNfSUQsICJDb21taXRUcyIs IGNvbW1pdF90c19yZWRvLCBjb21taXRfdHNfZGVzYywgY29tbWl0X3RzX2lkZW50aWZ5LCBO VUxMLCBOVUxMLCBOVUxMLCBOVUxMKQpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvY29tbWFu ZHMvc2VxdWVuY2UuaCBiL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3NlcXVlbmNlLmgKaW5kZXgg NWJhYjkwZGI4ZTAuLjBiYzkwYzkyMmJhIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9jb21t YW5kcy9zZXF1ZW5jZS5oCisrKyBiL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3NlcXVlbmNlLmgK QEAgLTQ4LDcgKzQ4LDYgQEAgdHlwZWRlZiBGb3JtRGF0YV9wZ19zZXF1ZW5jZV9kYXRhICpG b3JtX3BnX3NlcXVlbmNlX2RhdGE7CiB0eXBlZGVmIHN0cnVjdCB4bF9zZXFfcmVjCiB7CiAJ UmVsRmlsZU5vZGUgbm9kZTsKLQlib29sCQljcmVhdGVkOwkvKiBjcmVhdGVzIGEgbmV3IHJl bGZpbGVub2RlIChDUkVBVEUvQUxURVIpICovCiAJLyogU0VRVUVOQ0UgVFVQTEUgREFUQSBG T0xMT1dTIEFUIFRIRSBFTkQgKi8KIH0geGxfc2VxX3JlYzsKIApAQCAtNjAsOSArNTksMTEg QEAgZXh0ZXJuIE9iamVjdEFkZHJlc3MgRGVmaW5lU2VxdWVuY2UoUGFyc2VTdGF0ZSAqcHN0 YXRlLCBDcmVhdGVTZXFTdG10ICpzdG10KTsKIGV4dGVybiBPYmplY3RBZGRyZXNzIEFsdGVy U2VxdWVuY2UoUGFyc2VTdGF0ZSAqcHN0YXRlLCBBbHRlclNlcVN0bXQgKnN0bXQpOwogZXh0 ZXJuIHZvaWQgRGVsZXRlU2VxdWVuY2VUdXBsZShPaWQgcmVsaWQpOwogZXh0ZXJuIHZvaWQg UmVzZXRTZXF1ZW5jZShPaWQgc2VxX3JlbGlkKTsKLWV4dGVybiB2b2lkIFNldFNlcXVlbmNl KE9pZCBzZXFfcmVsaWQsIGJvb2wgdHJhbnNhY3Rpb25hbCwgaW50NjQgbGFzdF92YWx1ZSwg aW50NjQgbG9nX2NudCwgYm9vbCBpc19jYWxsZWQpOworZXh0ZXJuIHZvaWQgU2V0U2VxdWVu Y2UoT2lkIHNlcV9yZWxpZCwgaW50NjQgbGFzdF92YWx1ZSwgaW50NjQgbG9nX2NudCwgYm9v bCBpc19jYWxsZWQpOwogZXh0ZXJuIHZvaWQgUmVzZXRTZXF1ZW5jZUNhY2hlcyh2b2lkKTsK IAorZXh0ZXJuIHZvaWQgQXRFT1hhY3RfU2VxdWVuY2VzKGJvb2wgaXNDb21taXQpOworCiBl eHRlcm4gdm9pZCBzZXFfcmVkbyhYTG9nUmVhZGVyU3RhdGUgKnJwdHIpOwogZXh0ZXJuIHZv aWQgc2VxX2Rlc2MoU3RyaW5nSW5mbyBidWYsIFhMb2dSZWFkZXJTdGF0ZSAqcnB0cik7CiBl eHRlcm4gY29uc3QgY2hhciAqc2VxX2lkZW50aWZ5KHVpbnQ4IGluZm8pOwpkaWZmIC0tZ2l0 IGEvc3JjL2luY2x1ZGUvcmVwbGljYXRpb24vbG9naWNhbHByb3RvLmggYi9zcmMvaW5jbHVk ZS9yZXBsaWNhdGlvbi9sb2dpY2FscHJvdG8uaAppbmRleCAxM2VlMTBmZGQ0ZS4uYTQ2NmRi Mzk0YjggMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL3JlcGxpY2F0aW9uL2xvZ2ljYWxwcm90 by5oCisrKyBiL3NyYy9pbmNsdWRlL3JlcGxpY2F0aW9uL2xvZ2ljYWxwcm90by5oCkBAIC0x MjUsNyArMTI1LDYgQEAgdHlwZWRlZiBzdHJ1Y3QgTG9naWNhbFJlcFNlcXVlbmNlCiAJT2lk CQkJcmVtb3RlaWQ7CQkvKiB1bmlxdWUgaWQgb2YgdGhlIHJlbW90ZSBzZXF1ZW5jZSAqLwog CWNoYXIJICAgKm5zcG5hbWU7CQkvKiBzY2hlbWEgbmFtZSBvZiByZW1vdGUgc2VxdWVuY2Ug Ki8KIAljaGFyCSAgICpzZXFuYW1lOwkJLyogbmFtZSBvZiB0aGUgcmVtb3RlIHNlcXVlbmNl ICovCi0JYm9vbAkJdHJhbnNhY3Rpb25hbDsKIAlpbnQ2NAkJbGFzdF92YWx1ZTsKIAlpbnQ2 NAkJbG9nX2NudDsKIAlib29sCQlpc19jYWxsZWQ7CkBAIC0yNDUsNyArMjQ0LDYgQEAgZXh0 ZXJuIHZvaWQgbG9naWNhbHJlcF93cml0ZV9tZXNzYWdlKFN0cmluZ0luZm8gb3V0LCBUcmFu c2FjdGlvbklkIHhpZCwgWExvZ1JlY1AKIAkJCQkJCQkJCSBib29sIHRyYW5zYWN0aW9uYWws IGNvbnN0IGNoYXIgKnByZWZpeCwgU2l6ZSBzeiwgY29uc3QgY2hhciAqbWVzc2FnZSk7CiBl eHRlcm4gdm9pZCBsb2dpY2FscmVwX3dyaXRlX3NlcXVlbmNlKFN0cmluZ0luZm8gb3V0LCBS ZWxhdGlvbiByZWwsCiAJCQkJCQkJCQkgIFRyYW5zYWN0aW9uSWQgeGlkLCBYTG9nUmVjUHRy IGxzbiwKLQkJCQkJCQkJCSAgYm9vbCB0cmFuc2FjdGlvbmFsLAogCQkJCQkJCQkJICBpbnQ2 NCBsYXN0X3ZhbHVlLCBpbnQ2NCBsb2dfY250LAogCQkJCQkJCQkJICBib29sIGlzX2NhbGxl ZCk7CiBleHRlcm4gdm9pZCBsb2dpY2FscmVwX3JlYWRfc2VxdWVuY2UoU3RyaW5nSW5mbyBp biwgTG9naWNhbFJlcFNlcXVlbmNlICpzZXFkYXRhKTsKZGlmZiAtLWdpdCBhL3NyYy9pbmNs dWRlL3JlcGxpY2F0aW9uL21lc3NhZ2UuaCBiL3NyYy9pbmNsdWRlL3JlcGxpY2F0aW9uL21l c3NhZ2UuaAppbmRleCA3ZDc3ODUyOTJmMS4uYTA4NGFjYzA2YWIgMTAwNjQ0Ci0tLSBhL3Ny Yy9pbmNsdWRlL3JlcGxpY2F0aW9uL21lc3NhZ2UuaAorKysgYi9zcmMvaW5jbHVkZS9yZXBs aWNhdGlvbi9tZXNzYWdlLmgKQEAgLTI3LDEzICsyNywyOCBAQCB0eXBlZGVmIHN0cnVjdCB4 bF9sb2dpY2FsX21lc3NhZ2UKIAljaGFyCQltZXNzYWdlW0ZMRVhJQkxFX0FSUkFZX01FTUJF Ul07CiB9IHhsX2xvZ2ljYWxfbWVzc2FnZTsKIAorLyoKKyAqIEdlbmVyaWMgbG9naWNhbCBk ZWNvZGluZyBzZXF1ZW5jZSB3YWwgcmVjb3JkLgorICovCit0eXBlZGVmIHN0cnVjdCB4bF9s b2dpY2FsX3NlcXVlbmNlCit7CisJUmVsRmlsZU5vZGUJbm9kZTsKKwlPaWQJCQlyZWxvaWQ7 CisJaW50NjQJCWxhc3Q7CQkJLyogbGFzdCB2YWx1ZSBlbWl0dGVkIGZvciBzZXF1ZW5jZSAq LworCWludDY0CQlsb2dfY250OwkJLyogbGFzdCB2YWx1ZSBjYWNoZWQgZm9yIHNlcXVlbmNl ICovCisJYm9vbAkJaXNfY2FsbGVkOworfSB4bF9sb2dpY2FsX3NlcXVlbmNlOworCiAjZGVm aW5lIFNpemVPZkxvZ2ljYWxNZXNzYWdlCShvZmZzZXRvZih4bF9sb2dpY2FsX21lc3NhZ2Us IG1lc3NhZ2UpKQorI2RlZmluZSBTaXplT2ZMb2dpY2FsU2VxdWVuY2UJKHNpemVvZih4bF9s b2dpY2FsX3NlcXVlbmNlKSkKIAogZXh0ZXJuIFhMb2dSZWNQdHIgTG9nTG9naWNhbE1lc3Nh Z2UoY29uc3QgY2hhciAqcHJlZml4LCBjb25zdCBjaGFyICptZXNzYWdlLAogCQkJCQkJCQkJ c2l6ZV90IHNpemUsIGJvb2wgdHJhbnNhY3Rpb25hbCk7CiAKIC8qIFJNR1IgQVBJKi8KICNk ZWZpbmUgWExPR19MT0dJQ0FMX01FU1NBR0UJMHgwMAorI2RlZmluZSBYTE9HX0xPR0lDQUxf U0VRVUVOQ0UJMHgxMAorCiB2b2lkCQlsb2dpY2FsbXNnX3JlZG8oWExvZ1JlYWRlclN0YXRl ICpyZWNvcmQpOwogdm9pZAkJbG9naWNhbG1zZ19kZXNjKFN0cmluZ0luZm8gYnVmLCBYTG9n UmVhZGVyU3RhdGUgKnJlY29yZCk7CiBjb25zdCBjaGFyICpsb2dpY2FsbXNnX2lkZW50aWZ5 KHVpbnQ4IGluZm8pOwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvcmVwbGljYXRpb24vb3V0 cHV0X3BsdWdpbi5oIGIvc3JjL2luY2x1ZGUvcmVwbGljYXRpb24vb3V0cHV0X3BsdWdpbi5o CmluZGV4IGZlODVkNDlhMDMwLi5hYmMwNTY0NDUxNiAxMDA2NDQKLS0tIGEvc3JjL2luY2x1 ZGUvcmVwbGljYXRpb24vb3V0cHV0X3BsdWdpbi5oCisrKyBiL3NyYy9pbmNsdWRlL3JlcGxp Y2F0aW9uL291dHB1dF9wbHVnaW4uaApAQCAtOTUsNyArOTUsNiBAQCB0eXBlZGVmIHZvaWQg KCpMb2dpY2FsRGVjb2RlU2VxdWVuY2VDQikgKHN0cnVjdCBMb2dpY2FsRGVjb2RpbmdDb250 ZXh0ICpjdHgsCiAJCQkJCQkJCQkJIFJlb3JkZXJCdWZmZXJUWE4gKnR4biwKIAkJCQkJCQkJ CQkgWExvZ1JlY1B0ciBzZXF1ZW5jZV9sc24sCiAJCQkJCQkJCQkJIFJlbGF0aW9uIHJlbCwK LQkJCQkJCQkJCQkgYm9vbCB0cmFuc2FjdGlvbmFsLAogCQkJCQkJCQkJCSBpbnQ2NCBsYXN0 X3ZhbHVlLAogCQkJCQkJCQkJCSBpbnQ2NCBsb2dfY250LAogCQkJCQkJCQkJCSBib29sIGlz X2NhbGxlZCk7CkBAIC0yMTksNyArMjE4LDYgQEAgdHlwZWRlZiB2b2lkICgqTG9naWNhbERl Y29kZVN0cmVhbVNlcXVlbmNlQ0IpIChzdHJ1Y3QgTG9naWNhbERlY29kaW5nQ29udGV4dCAq Y3QKIAkJCQkJCQkJCQkJICAgUmVvcmRlckJ1ZmZlclRYTiAqdHhuLAogCQkJCQkJCQkJCQkg ICBYTG9nUmVjUHRyIHNlcXVlbmNlX2xzbiwKIAkJCQkJCQkJCQkJICAgUmVsYXRpb24gcmVs LAotCQkJCQkJCQkJCQkgICBib29sIHRyYW5zYWN0aW9uYWwsCiAJCQkJCQkJCQkJCSAgIGlu dDY0IGxhc3RfdmFsdWUsCiAJCQkJCQkJCQkJCSAgIGludDY0IGxvZ19jbnQsCiAJCQkJCQkJ CQkJCSAgIGJvb2wgaXNfY2FsbGVkKTsKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL3JlcGxp Y2F0aW9uL3Jlb3JkZXJidWZmZXIuaCBiL3NyYy9pbmNsdWRlL3JlcGxpY2F0aW9uL3Jlb3Jk ZXJidWZmZXIuaAppbmRleCAwYmNjMTUwYjMzMS4uMjYwNjMwYzJiYTUgMTAwNjQ0Ci0tLSBh L3NyYy9pbmNsdWRlL3JlcGxpY2F0aW9uL3Jlb3JkZXJidWZmZXIuaAorKysgYi9zcmMvaW5j bHVkZS9yZXBsaWNhdGlvbi9yZW9yZGVyYnVmZmVyLmgKQEAgLTE2NCw3ICsxNjQsMTAgQEAg dHlwZWRlZiBzdHJ1Y3QgUmVvcmRlckJ1ZmZlckNoYW5nZQogCQlzdHJ1Y3QKIAkJewogCQkJ UmVsRmlsZU5vZGUgcmVsbm9kZTsKLQkJCVJlb3JkZXJCdWZmZXJUdXBsZUJ1ZiAqdHVwbGU7 CisJCQlPaWQJCQlyZWxvaWQ7CisJCQlpbnQ2NAkJbGFzdDsKKwkJCWludDY0CQlsb2dfY250 OworCQkJYm9vbAkJaXNfY2FsbGVkOwogCQl9CQkJc2VxdWVuY2U7CiAJfQkJCWRhdGE7CiAK QEAgLTQ0Myw3ICs0NDYsNiBAQCB0eXBlZGVmIHZvaWQgKCpSZW9yZGVyQnVmZmVyU2VxdWVu Y2VDQikgKFJlb3JkZXJCdWZmZXIgKnJiLAogCQkJCQkJCQkJCSBSZW9yZGVyQnVmZmVyVFhO ICp0eG4sCiAJCQkJCQkJCQkJIFhMb2dSZWNQdHIgc2VxdWVuY2VfbHNuLAogCQkJCQkJCQkJ CSBSZWxhdGlvbiByZWwsCi0JCQkJCQkJCQkJIGJvb2wgdHJhbnNhY3Rpb25hbCwKIAkJCQkJ CQkJCQkgaW50NjQgbGFzdF92YWx1ZSwgaW50NjQgbG9nX2NudCwKIAkJCQkJCQkJCQkgYm9v bCBpc19jYWxsZWQpOwogCkBAIC01MTgsNyArNTIwLDYgQEAgdHlwZWRlZiB2b2lkICgqUmVv cmRlckJ1ZmZlclN0cmVhbVNlcXVlbmNlQ0IpIChSZW9yZGVyQnVmZmVyICpyYiwKIAkJCQkJ CQkJCQkJICAgUmVvcmRlckJ1ZmZlclRYTiAqdHhuLAogCQkJCQkJCQkJCQkgICBYTG9nUmVj UHRyIHNlcXVlbmNlX2xzbiwKIAkJCQkJCQkJCQkJICAgUmVsYXRpb24gcmVsLAotCQkJCQkJ CQkJCQkgICBib29sIHRyYW5zYWN0aW9uYWwsCiAJCQkJCQkJCQkJCSAgIGludDY0IGxhc3Rf dmFsdWUsIGludDY0IGxvZ19jbnQsCiAJCQkJCQkJCQkJCSAgIGJvb2wgaXNfY2FsbGVkKTsK IApAQCAtNjcwLDkgKzY3MSw5IEBAIHZvaWQJCVJlb3JkZXJCdWZmZXJRdWV1ZU1lc3NhZ2Uo UmVvcmRlckJ1ZmZlciAqLCBUcmFuc2FjdGlvbklkLCBTbmFwc2hvdCBzbmFwc2hvCiAJCQkJ CQkJCQkgIGJvb2wgdHJhbnNhY3Rpb25hbCwgY29uc3QgY2hhciAqcHJlZml4LAogCQkJCQkJ CQkJICBTaXplIG1lc3NhZ2Vfc2l6ZSwgY29uc3QgY2hhciAqbWVzc2FnZSk7CiB2b2lkCQlS ZW9yZGVyQnVmZmVyUXVldWVTZXF1ZW5jZShSZW9yZGVyQnVmZmVyICpyYiwgVHJhbnNhY3Rp b25JZCB4aWQsCi0JCQkJCQkJCQkgICBTbmFwc2hvdCBzbmFwc2hvdCwgWExvZ1JlY1B0ciBs c24sIFJlcE9yaWdpbklkIG9yaWdpbl9pZCwKLQkJCQkJCQkJCSAgIFJlbEZpbGVOb2RlIHJu b2RlLCBib29sIHRyYW5zYWN0aW9uYWwsIGJvb2wgY3JlYXRlZCwKLQkJCQkJCQkJCSAgIFJl b3JkZXJCdWZmZXJUdXBsZUJ1ZiAqdHVwbGVidWYpOworCQkJCQkJCQkJICAgWExvZ1JlY1B0 ciBsc24sIFJlcE9yaWdpbklkIG9yaWdpbl9pZCwKKwkJCQkJCQkJCSAgIE9pZCByZWxvaWQs IFJlbEZpbGVOb2RlIHJub2RlLAorCQkJCQkJCQkJICAgaW50NjQgbGFzdCwgaW50NjQgbG9n X2NudCwgYm9vbCBpc19jYWxsZWQpOwogdm9pZAkJUmVvcmRlckJ1ZmZlckNvbW1pdChSZW9y ZGVyQnVmZmVyICosIFRyYW5zYWN0aW9uSWQsCiAJCQkJCQkJCVhMb2dSZWNQdHIgY29tbWl0 X2xzbiwgWExvZ1JlY1B0ciBlbmRfbHNuLAogCQkJCQkJCQlUaW1lc3RhbXBUeiBjb21taXRf dGltZSwgUmVwT3JpZ2luSWQgb3JpZ2luX2lkLCBYTG9nUmVjUHRyIG9yaWdpbl9sc24pOwpA QCAtNzIwLDcgKzcyMSw0IEBAIHZvaWQJCVJlb3JkZXJCdWZmZXJTZXRSZXN0YXJ0UG9pbnQo UmVvcmRlckJ1ZmZlciAqLCBYTG9nUmVjUHRyIHB0cik7CiAKIHZvaWQJCVN0YXJ0dXBSZW9y ZGVyQnVmZmVyKHZvaWQpOwogCi1ib29sCQlSZW9yZGVyQnVmZmVyU2VxdWVuY2VJc1RyYW5z YWN0aW9uYWwoUmVvcmRlckJ1ZmZlciAqcmIsCi0JCQkJCQkJCQkJCQkgUmVsRmlsZU5vZGUg cm5vZGUsIGJvb2wgY3JlYXRlZCk7Ci0KICNlbmRpZgotLSAKMi4zNC4xCgo= --------------h4MkX15oBsPcg0TtcAqSF4HX--