Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vsSQ9-00237Z-2f for pgsql-hackers@arkaria.postgresql.org; Tue, 17 Feb 2026 21:15:50 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1vsSQ9-00CDxb-04 for pgsql-hackers@arkaria.postgresql.org; Tue, 17 Feb 2026 21:15:49 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vsSQ8-00CDxC-1H for pgsql-hackers@lists.postgresql.org; Tue, 17 Feb 2026 21:15:48 +0000 Received: from fhigh-b8-smtp.messagingengine.com ([202.12.124.159]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.98.2) (envelope-from ) id 1vsSQ5-00000001Fze-2UTP for pgsql-hackers@postgresql.org; Tue, 17 Feb 2026 21:15:48 +0000 Received: from phl-compute-02.internal (phl-compute-02.internal [10.202.2.42]) by mailfhigh.stl.internal (Postfix) with ESMTP id 36D017A00E6; Tue, 17 Feb 2026 16:15:43 -0500 (EST) Received: from phl-imap-14 ([10.202.2.87]) by phl-compute-02.internal (MEProxy); Tue, 17 Feb 2026 16:15:43 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=burd.me; h=cc:cc :content-type:content-type:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:subject :subject:to:to; s=fm3; t=1771362942; x=1771449342; bh=7C7wqag8ON M9otzW0nfMiVfepd5bIK/8yMMjMx0MN7w=; b=IAf51bESgQTW03o6jiHFSaIRri 30onGseop8xPHfKC9zCgDLNHPXMwngovfeFlGFrhmMSmb+jG30qCFSt6AtW7SOEI h8U5U65cisrUZzWzre7fXvvJH91bjlsN8kHFZz8HaGCxz+X8o0V6FCkHJk4HSnD7 G8GAK0VizLh7DQUBwPKEjITMMYCQRQmtT/EhSUudzgOM6NyFdo3dSh0smWVt0ler v0ibbS3tA2skyyzN0pKtRdsHZquhENOg0j+RegxwErzD4o8nXDH82g0RqVXIjRuy KUrrl/iXlHbyA04ghnZt4BbmFPsrYfEJVgSEbehOXLapIKMEm05EOhFPEcWg== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-type:content-type:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:subject:subject:to :to:x-me-proxy:x-me-sender:x-me-sender:x-sasl-enc; s=fm3; t= 1771362942; x=1771449342; bh=7C7wqag8ONM9otzW0nfMiVfepd5bIK/8yMM jMx0MN7w=; b=O0K/GdnEPIrDrpuWKhG9Kolfsg6RRHmMSGj2vBhyoYJdbfEZTCl kx+liNC0Y+37WKtgEBRrQULoLqfXdgOW4LRPS6EpFodJ/4KG369GggTYohhY6+jj wsGigdDPhy/jYjgwYqwHFGO1nvifElIHvf6lB96dImkdZVtl+TpFRoqOfB0sW/xj H2eRBtEu3XShmnXDN8ylFWCx76+UH3Mzh0TbknNHJlvrEjhr8XOMSAhPgk9mwUa8 wmxxHNzdHT3xY0n4d779XedyGH/4iFDzvbAxqp2+UAFujaBTl+k0csWvbS2Dfk+e 9n15sd1M458IEw3FMPH4Mje95XfshHvePXg== X-ME-Sender: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgeefgedrtddtgddvvddtkeduucetufdoteggodetrf dotffvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfurfetoffkrfgpnffqhgenuceu rghilhhouhhtmecufedttdenucenucfjughrpefoggffhffvvefkjghfufgtsehmtderre ertdejnecuhfhrohhmpedfifhrvghguceuuhhrugdfuceoghhrvghgsegsuhhrugdrmhgv qeenucggtffrrghtthgvrhhnpefgteejueejgeekffethfdvledtkeeffefgvedtleetke eggeduheefudehudfgleenucffohhmrghinhepphhoshhtghhrvghsqhhlrdhorhhgnecu vehluhhsthgvrhfuihiivgeptdenucfrrghrrghmpehmrghilhhfrhhomhepghhrvghgse gsuhhrugdrmhgvpdhnsggprhgtphhtthhopedvpdhmohguvgepshhmthhpohhuthdprhgt phhtthhopehpghhsqhhlsehjqdgurghvihhsrdgtohhmpdhrtghpthhtohepphhgshhqlh dqhhgrtghkvghrshesphhoshhtghhrvghsqhhlrdhorhhg X-ME-Proxy: Feedback-ID: i675e48f3:Fastmail Received: by mailuser.phl.internal (Postfix, from userid 501) id B497DC4006F; Tue, 17 Feb 2026 16:15:42 -0500 (EST) X-Mailer: MessagingEngine.com Webmail Interface MIME-Version: 1.0 X-ThreadId: A1gxZgRQNkgk Date: Tue, 17 Feb 2026 16:15:02 -0500 From: "Greg Burd" To: "Jeff Davis" Cc: pgsql-hackers Message-Id: In-Reply-To: References: <5165C147-B476-4E3D-AAA9-11C0B966FC4D@greg.burd.me> <9394564A-5764-4DCA-8845-8AE102DE61DC@greg.burd.me> <97769442-2ed7-4fe0-a393-7e2b5ff7ff58@app.fastmail.com> <3e1b9075c92808a7356e79087ba51910e5db5a30.camel@j-davis.com> Subject: Re: Expanding HOT updates for expression and partial indexes Content-Type: multipart/mixed; boundary=653b79df523c467eb04fef73b97e653b List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --653b79df523c467eb04fef73b97e653b Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable On Mon, Feb 16, 2026, at 2:36 PM, Jeff Davis wrote: > On Sun, 2026-02-15 at 15:39 -0500, Greg Burd wrote: > >> (2) Types don't influence this decision today.=C2=A0 Their equality >> operators are not used, attributes are memcmp().=C2=A0 This is a >> requirement for index-only scans.=C2=A0 I think it's insufficient for >> types like JSONB which have internal structure that can be extracted >> to form index keys, but that's for a later commit. > > That's an interesting path but would require more infrastructure, and > to justify going down that path we should look for other opportunities > to use that type infra beyond just HOT. Brainstorming: maybe something > in the planner can make use of intelligence around expressions that are > effectively setter/accessor methods on complex types? (Obviously work > for later.) Agreed, but this is my best idea at the moment to re-introduce $subjet i= nto this patch set. I'm open to other ideas, but fundamentally to allow= $subjet requires that somewhere we discover that while portions of the = JSONB attribute changed during the update the resulting index key attrib= utes extracted from the JSONB did not. In all patches v1-v29 that was discovered by evaluating the index expres= sions on the old and new tuples and comparing the index key datum that r= esulted for equality. When equal, while the attribute changed the index= es need not opening the door for a HOT update. The overhead of that was= n't horrible, but it does change some expectations about how often expre= ssions are evaluated and that might be confusing. >> I can see how this might be confusing, you're asking a good >> question.=C2=A0 Why not just add the mix_attrs as an argument to the = table >> AM update call and be done? >>=20 >> 1. Bitmapsets that are NULL mean empty, so how would >> simple_heap_update() signal to heap_update() that it needs to >> determine the modified indexed attributes?=C2=A0 We'd have to add a b= ool >> along with the mix_attrs Bitmapset to indicate: "we've not calculated >> the set yet, you need to do that." > > Maybe an extra bool is not ideal, but it's better than moving code onto > the wrong side of an API boundary. I'm not sure this is an "API boundary", but I'm open to debate on that. = The attached patch does add a bool to heap_update() in addition to the = Bitmapset of modified/indexed attributes (modified_attrs) and IMO is fin= e although I don't like that it further complicates (muddies?) an alread= y huge and highly complicated function, heap_update(). >> 2. After fetching the exclusive buffer lock there is the test >> `!ItemIdIsNormal(lp)` to cover the case where a simple_heap_update() >> the otid origin is the syscache, there is no pin or snapshot, and so >> there might be LP_* states other than LP_NORMAL due to concurrent >> pruning.=C2=A0 This only happens when updating catalog tuples, so this >> logic need not be present at all in the heapam_tuple_update().=C2=A0 = Yes, >> the if() branch will be fast (frequently predicted by the CPU) but >> this feels like logic specific to the update of catalog tuples. > > If convenient I'm fine with moving that branch out, but I think it > needs to be done with the buffer locked (right?), so heap_update() > looks like the right place for that test for now. > >> 3. HeapDetermineColumnsInfo() actually does more than find the >> modified indexed attributes, it also performs half of the check for >> the requirement to WAL log the replica identity attributes.=C2=A0 The >> replacement function in the executor doesn't do this work, so that is >> coded into heapam_tuple_update() but not simple_heap_update().=C2=A0 = The >> second half is in ExtractReplicaIdentity() that happens later in the >> heap_update() function after determining if HOT is a possibility or >> not. > > IIUC you are saying that the decision is too heap-specific to expose to > the executor. I think that's true today (as ExtractReplicaIdentity() is > in heapam.c), but perhaps that's not fundamental: TOAST is not heap- > specific, replica IDs are not heap-specific, and if you are WAL-logging > a replica identity key it seems like you need to know whether it's > external or not regardless of the AM. > > I'm not asking for a change here, just trying to understand the API > boundaries. I'm on the fence on this one, maybe all table AMs will need this same lo= gic but at the moment it feels very heap-specific to me. For now it liv= es in heap_update() and HeapDetermineColumnsInfo(). I think I called th= is out only to say that if you look at the new vs old method for computi= ng modified_attrs you'll see that's missing and done later in heap_updat= e(). >> I have moved these changes back into heap_update(), add the mix_attrs >> and mix_attrs_valid to see how things look, that's the attached >> patch. > > Thank you -- that's easier to understand. Excellent. I've muddied the review again a bit by abstracting out a function ExecCo= mpareSlots() which can loosely be thought of as a replacement for heap_a= ttr_equal(). Doing that let's me vastly simplify the replication worker= changes and reuse it after ExecBRUpdateTriggers(). > Why does simple_heap_update() need to do the HeapDetermineColumnsInfo() > inside heap_update()? It seems like you're trying to avoid doing the > same work the executor is doing to determine the modified_attrs bitmap, > but either (a) the work is cheap; or (b) the work to make the bitmap is > expensive. simple_heap_update() is exclusively called during catalog tuple updates = and does not involve the executor at all, these are direct calls into he= ap to store catalog tuples. These updates don't preserve the set of upd= ated attributes (see cf-6221 [0]) and so for them to potentially use the= HOT path in heap_update() we need to identify which attributes changed.= This requires comparing the new heap tuple vs the one read from the buf= fer page. This is the same logic as before the patch. If I could come = up with a simple method to retain the set of modified attributes during = catalog tuple updates then we could excise HeapDetermineColumnsInfo() en= tirely. > If (a), then just construct the correct bitmap in simple_heap_update() > and simplify the code. If (b), then optimizing the simple_heap_update() > case isn't good enough, we need to find ways of avoiding the work in > the most common cases in the executor, as well. Construct the correct bitmap how? That function is called with the otid= and the updated HeapTuple, not enough to build the bitmap of modified i= ndexed attributes. I said in an earlier email that the results for the modified/indexed bit= map and the replica identity are identical. I added some test code (mes= sy, but attached for your amusement should you want) that looks for diff= erences between the two. It turns out that for replica identity the res= ults are identical, for modified/indexed attributes there are a few diff= erences. In brin.sql at 409: UPDATE brintest SET int8col =3D int8col * int4col; This updates the indexed value of the int8col (attribute 4) which is cor= rectly detected in the new code, but isn't in HeapDetermineColumnsInfo()= . The "interesting_cols" are identical. I'm still investigating. I'm also working on a good benchmark that hopefully can show that under = heavy concurrent read/update mixed load the reduced exclusive lock time = will allow more work to be performed. Some contrived benchmarks have sh= own 15% improvement, but I need to zero in on this before publishing res= ults. > Regards, > Jeff Davis Attached is a new version of the patch. The file heap-check.c contains = the code I had been using to test for equal results across methods. Tha= t code is... well, it's just for me but I include it to show that I'm do= ing due diligence to ensure this stuff is either the same, or different = for a good reason. Thanks for your continued interest in this work. best. -greg [0] https://commitfest.postgresql.org/patch/6221/ --653b79df523c467eb04fef73b97e653b Content-Disposition: attachment; filename*0="v20260217-0001-Idenfity-modified-indexed-attributes-in-th.pat"; filename*1="ch" Content-Type: text/x-patch; name="=?UTF-8?Q?v20260217-0001-Idenfity-modified-indexed-attributes-in-th.patc?= =?UTF-8?Q?h?=" Content-Transfer-Encoding: base64 RnJvbSBiN2NmNTkyOGNmNDAwY2M2NmFjOGY2ZWNkZGQzNzM2MmY0NmRhMzg2IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBHcmVnIEJ1cmQgPGdyZWdAYnVyZC5tZT4KRGF0ZTog U3VuLCAyIE5vdiAyMDI1IDExOjM2OjIwIC0wNTAwClN1YmplY3Q6IFtQQVRDSCB2MjAyNjAy MTddIElkZW5maXR5IG1vZGlmaWVkIGluZGV4ZWQgYXR0cmlidXRlcyBpbiB0aGUKIGV4ZWN1 dG9yIG9uIFVQREFURQoKUmVmYWN0b3IgZXhlY3V0b3IgdXBkYXRlIGxvZ2ljIHRvIGRldGVy bWluZSB3aGljaCBpbmRleGVkIGNvbHVtbnMgaGF2ZQphY3R1YWxseSBjaGFuZ2VkIGR1cmlu ZyBhbiBVUERBVEUgb3BlcmF0aW9uIHJhdGhlciB0aGFuIGxlYXZpbmcgdGhpcyB1cAp0byBI ZWFwRGV0ZXJtaW5lQ29sdW1uc0luZm8oKSBpbiBoZWFwX3VwZGF0ZSgpLgoKRXhlY0NoZWNr SW5kZXhlZEF0dHJzRm9yQ2hhbmdlcygpIHJlcGxhY2VzIEhlYXBEZXRlcm1pbmVzQ29sdW1u c0luZm8oKQphbmQgaXMgY2FsbGVkIGJlZm9yZSB0YWJsZV90dXBsZV91cGRhdGUoKSBjcnVj aWFsbHkgd2l0aG91dCB0aGUgbmVlZApmb3IgYW4gZXhjbHVzaXZlIGJ1ZmZlciBsb2NrIG9u IHRoZSBwYWdlIHRoYXQgaG9sZHMgdGhlIHR1cGxlIGJlaW5nCnVwZGF0ZWQuICBUaGlzIHJl ZHVjZXMgdGhlIHRpbWUgdGhlIGxvY2sgaXMgaGVsZCBsYXRlciB3aXRoaW4KaGVhcGFtX3R1 cGxlX3VwZGF0ZSgpIGFuZCBoZWFwX3VwZGF0ZSgpLgoKRXhlY0NoZWNrSW5kZXhlZEF0dHJz Rm9yQ2hhbmdlcygpIGluIHR1cm4gdXNlcyBFeGVjQ29tcGFyZVNsb3RzKCkgdG8KaWRlbnRp Znkgd2hpY2ggYXR0cmlidXRlcyBoYXZlIGNoYW5nZWQgYW5kIHRoZW4gaW50ZXJzZWN0cyB0 aGF0IHdpdGggdGhlCnNldCBvZiBpbmRleGVkIGF0dHJpYnV0ZXMgdG8gaWRlbnRpZnkgdGhl IG1vZGlmaWVkIGluZGV4ZWQgc2V0LgoKQmVzaWRlcyBpZGVudGlmeWluZyB0aGUgc2V0IG9m IG1vZGlmaWVkIGluZGV4ZWQgYXR0cmlidXRlcwpIZWFwRGV0ZXJtaW5lQ29sdW1uc0luZm8o KSB3YXMgYWxzbyByZXNwb25zaWJsZSBmb3IgcGFydCBvZiB0aGUgbG9naWMKaW52b2xlZCBp biB0aGUgZGVjaXNpb24gdG8gaW5jbHVkZSB0aGUgcmVwbGljYSBpZGVudGl0eSBrZXkgb3Ig bm90LgpUaGlzIG5vdyBoYXBwZW5zIGluIGhlYXBfdXBkYXRlKCkgd2hlbiBtb2RpZmllZF9h dHRyc192YWxpZCBpcyBmYWxzZS4KCkNhdGFsb2cgdHVwbGUgdXBkYXRlcyB1c2Ugc2ltcGxl X2hlYXBfdXBkYXRlKCkgYW5kIGRvbid0IHBhc3MgYQptb2RpZmllZF9hdHRycyBCaXRtYXBz ZXQgaW50byBoZWFwX3VwZGF0ZSgpIGluZGljYXRlZCBieSB0aGUKbW9kaWZpZWRfYXR0cnNf dmFsaWQgYm9vbCBzZXQgdG8gZmFsc2UuCgpVcGRhdGVzIHN0ZW1taW5nIGZyb20gbG9naWNh bCByZXBsaWNhdGlvbiBhbHNvIHVzZSB0aGUgbmV3CkV4ZWNDaGVja0luZGV4ZWRBdHRyc0Zv ckNoYW5nZXMoKSBpbiBFeGVjU2ltcGxlUmVsYXRpb25VcGRhdGUoKS4KCkJlZm9yZSByb3cg dHJpZ2dlcnMgb24gVVBEQVRFIG1heSB1c2UgaGVhcF9tb2RpZnlfdHVwbGUoKSB0byB1cGRh dGUKYXR0cmlidXRlcyBub3QgaWRlbnRpZmllZCBieSBFeGVjR2V0QWxsVXBkYXRlZENvbHMo KSBhcyBpcyB0aGUgY2FzZSBpbgp0c3ZlY3Rvcl91cGRhdGVfdHJpZ2dlcigpLiAgRXhlY0JS VXBkYXRlVHJpZ2dlcnMoKSBub3cgaWRlbnRpZmllcyB0aGlzCmNhc2UgYW5kIGFkZHMgc3Vj aCBhdHRyaWJ1dGVzIHRvIHJpX2V4dHJhVXBkYXRlZENvbHMuICBTZWUgdHNlYXJjaC5zcWwK dGVzdHMgd2l0aCB0aGlzIHRyaWdnZXIgZm9yIGFuIGV4YW1wbGUgb2YgdGhpcy4KLS0tCiBz cmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW0uYyAgICAgICAgIHwgODAgKysrKysrKysr KysrKysrKysrKysrLS0tCiBzcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW1faGFuZGxl ci5jIHwgIDcgKy0tCiBzcmMvYmFja2VuZC9hY2Nlc3MvdGFibGUvdGFibGVhbS5jICAgICAg IHwgIDUgKy0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3RyaWdnZXIuYyAgICAgICAgICAgfCAx NSArKysrLQogc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1JlcGxpY2F0aW9uLmMgICB8IDEy ICsrKy0KIHNyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNUdXBsZXMuYyAgICAgICAgfCA3NCAr KysrKysrKysrKysrKysrKysrKysrCiBzcmMvYmFja2VuZC9leGVjdXRvci9ub2RlTW9kaWZ5 VGFibGUuYyAgIHwgNzIgKysrKysrKysrKysrKysrKysrLS0tCiBzcmMvYmFja2VuZC9yZXBs aWNhdGlvbi9sb2dpY2FsL3dvcmtlci5jIHwgMTUgKysrLS0KIHNyYy9iYWNrZW5kL3V0aWxz L2NhY2hlL3JlbGNhY2hlLmMgICAgICAgfCAxNSArKysrKwogc3JjL2luY2x1ZGUvYWNjZXNz L2hlYXBhbS5oICAgICAgICAgICAgICB8ICAxICsKIHNyYy9pbmNsdWRlL2FjY2Vzcy90YWJs ZWFtLmggICAgICAgICAgICAgfCAgOCArKy0KIHNyYy9pbmNsdWRlL2NhdGFsb2cvaW5kZXgu aCAgICAgICAgICAgICAgfCAgMSArCiBzcmMvaW5jbHVkZS9leGVjdXRvci9leGVjdXRvci5o ICAgICAgICAgIHwgMTAgKysrCiBzcmMvaW5jbHVkZS9ub2Rlcy9leGVjbm9kZXMuaCAgICAg ICAgICAgIHwgIDYgKysKIHNyYy9pbmNsdWRlL3V0aWxzL3JlbC5oICAgICAgICAgICAgICAg ICAgfCAgMSArCiBzcmMvaW5jbHVkZS91dGlscy9yZWxjYWNoZS5oICAgICAgICAgICAgIHwg IDEgKwogMTYgZmlsZXMgY2hhbmdlZCwgMjg3IGluc2VydGlvbnMoKyksIDM2IGRlbGV0aW9u cygtKQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL2hlYXBhbS5jIGIv c3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFtLmMKaW5kZXggOThkNTNjYWVlYTguLmFi OGI2ZGRiOGRlIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW0u YworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW0uYwpAQCAtMzMxMSw2ICsz MzExLDcgQEAgVE1fUmVzdWx0CiBoZWFwX3VwZGF0ZShSZWxhdGlvbiByZWxhdGlvbiwgY29u c3QgSXRlbVBvaW50ZXJEYXRhICpvdGlkLCBIZWFwVHVwbGUgbmV3dHVwLAogCQkJQ29tbWFu ZElkIGNpZCwgU25hcHNob3QgY3Jvc3NjaGVjaywgYm9vbCB3YWl0LAogCQkJVE1fRmFpbHVy ZURhdGEgKnRtZmQsIExvY2tUdXBsZU1vZGUgKmxvY2ttb2RlLAorCQkJY29uc3QgQml0bWFw c2V0ICptb2RpZmllZF9hdHRycywgYm9vbCBtb2RpZmllZF9hdHRyc192YWxpZCwKIAkJCVRV X1VwZGF0ZUluZGV4ZXMgKnVwZGF0ZV9pbmRleGVzKQogewogCVRNX1Jlc3VsdAlyZXN1bHQ7 CkBAIC0zMzIwLDcgKzMzMjEsNiBAQCBoZWFwX3VwZGF0ZShSZWxhdGlvbiByZWxhdGlvbiwg Y29uc3QgSXRlbVBvaW50ZXJEYXRhICpvdGlkLCBIZWFwVHVwbGUgbmV3dHVwLAogCUJpdG1h cHNldCAgKmtleV9hdHRyczsKIAlCaXRtYXBzZXQgICppZF9hdHRyczsKIAlCaXRtYXBzZXQg ICppbnRlcmVzdGluZ19hdHRyczsKLQlCaXRtYXBzZXQgICptb2RpZmllZF9hdHRyczsKIAlJ dGVtSWQJCWxwOwogCUhlYXBUdXBsZURhdGEgb2xkdHVwOwogCUhlYXBUdXBsZQloZWFwdHVw OwpAQCAtMzM0NSw3ICszMzQ1LDcgQEAgaGVhcF91cGRhdGUoUmVsYXRpb24gcmVsYXRpb24s IGNvbnN0IEl0ZW1Qb2ludGVyRGF0YSAqb3RpZCwgSGVhcFR1cGxlIG5ld3R1cCwKIAlib29s CQlhbGxfdmlzaWJsZV9jbGVhcmVkX25ldyA9IGZhbHNlOwogCWJvb2wJCWNoZWNrZWRfbG9j a2VyczsKIAlib29sCQlsb2NrZXJfcmVtYWluczsKLQlib29sCQlpZF9oYXNfZXh0ZXJuYWwg PSBmYWxzZTsKKwlib29sCQlyZXBfaWRfa2V5X3JlcXVpcmVkID0gZmFsc2U7CiAJVHJhbnNh Y3Rpb25JZCB4bWF4X25ld190dXBsZSwKIAkJCQl4bWF4X29sZF90dXBsZTsKIAl1aW50MTYJ CWluZm9tYXNrX29sZF90dXBsZSwKQEAgLTM0ODcsOSArMzQ4Nyw2OSBAQCBoZWFwX3VwZGF0 ZShSZWxhdGlvbiByZWxhdGlvbiwgY29uc3QgSXRlbVBvaW50ZXJEYXRhICpvdGlkLCBIZWFw VHVwbGUgbmV3dHVwLAogCSAqIG5ldyB0dXBsZSBzbyB3ZSBtdXN0IGluY2x1ZGUgaXQgYXMg cGFydCBvZiB0aGUgb2xkX2tleV90dXBsZS4gIFNlZQogCSAqIEV4dHJhY3RSZXBsaWNhSWRl bnRpdHkuCiAJICovCi0JbW9kaWZpZWRfYXR0cnMgPSBIZWFwRGV0ZXJtaW5lQ29sdW1uc0lu Zm8ocmVsYXRpb24sIGludGVyZXN0aW5nX2F0dHJzLAotCQkJCQkJCQkJCQkgIGlkX2F0dHJz LCAmb2xkdHVwLAotCQkJCQkJCQkJCQkgIG5ld3R1cCwgJmlkX2hhc19leHRlcm5hbCk7CisJ aWYgKCFtb2RpZmllZF9hdHRyc192YWxpZCkKKwl7CisJCWJvb2wJCWlkX2hhc19leHRlcm5h bCA9IGZhbHNlOworCisJCW1vZGlmaWVkX2F0dHJzID0gSGVhcERldGVybWluZUNvbHVtbnNJ bmZvKHJlbGF0aW9uLCBpbnRlcmVzdGluZ19hdHRycywKKwkJCQkJCQkJCQkJCSAgaWRfYXR0 cnMsICZvbGR0dXAsCisJCQkJCQkJCQkJCQkgIG5ld3R1cCwgJmlkX2hhc19leHRlcm5hbCk7 CisJCXJlcF9pZF9rZXlfcmVxdWlyZWQgPSBpZF9oYXNfZXh0ZXJuYWwgfHwKKwkJCWJtc19v dmVybGFwKG1vZGlmaWVkX2F0dHJzLCBpZF9hdHRycyk7CisJfQorCWVsc2UKKwl7CisJCS8q CisJCSAqIEV4dHJhY3RSZXBsaWNhdElkZW50aXR5KCkgbmVlZHMgdG8ga25vdyBpZiBhIG1v ZGlmaWVkIGF0dHJidXRlIGlzCisJCSAqIHVzZWQgYXMgYSByZXBsaWNhIGluZGVudGl0eSBv ciBpZiBhbnkgb2YgdGhlIHVubW9kaWZpZWQgaW5kZXhlZAorCQkgKiBhdHRyaWJ1dGVzIGlu IHRoZSBvbGQgdHVwbGUgYXJlIHN0b3JlZCBleHRlcm5hbGx5IGFuZCB1c2VkIGFzIGEKKwkJ ICogcmVwbGljYSBpZGVudGl0eS4KKwkJICovCisJCXJlcF9pZF9rZXlfcmVxdWlyZWQgPSBi bXNfb3ZlcmxhcChtb2RpZmllZF9hdHRycywgaWRfYXR0cnMpOworCQlpZiAoIXJlcF9pZF9r ZXlfcmVxdWlyZWQpCisJCXsKKwkJCUJpdG1hcHNldCAgKmF0dHJzOworCQkJVHVwbGVEZXNj CXR1cGRlc2MgPSBSZWxhdGlvbkdldERlc2NyKHJlbGF0aW9uKTsKKwkJCWludAkJCWF0dGlk eCA9IC0xOworCisJCQkvKiBDaGVjayBhbGwgdW5tb2RpZmllZCBpbmRleGVkIHJlcGxpY2Eg aWRlbnRpdHkga2V5IGF0dHJpYnV0ZXMgKi8KKwkJCWF0dHJzID0gYm1zX2RpZmZlcmVuY2Uo aW50ZXJlc3RpbmdfYXR0cnMsIG1vZGlmaWVkX2F0dHJzKTsKKwkJCWF0dHJzID0gYm1zX2lu dF9tZW1iZXJzKGF0dHJzLCBpZF9hdHRycyk7CisKKwkJCXdoaWxlICgoYXR0aWR4ID0gYm1z X25leHRfbWVtYmVyKGF0dHJzLCBhdHRpZHgpKSA+PSAwKQorCQkJeworCQkJCS8qCisJCQkJ ICogYXR0aWR4IGlzIHplcm8tYmFzZWQsIGF0dHJudW0gaXMgdGhlIG5vcm1hbCBhdHRyaWJ1 dGUKKwkJCQkgKiBudW1iZXIKKwkJCQkgKi8KKwkJCQlBdHRyTnVtYmVyCWF0dHJudW0gPSBh dHRpZHggKyBGaXJzdExvd0ludmFsaWRIZWFwQXR0cmlidXRlTnVtYmVyOworCQkJCURhdHVt CQl2YWx1ZTsKKwkJCQlib29sCQlpc251bGw7CisKKwkJCQkvKgorCQkJCSAqIFN5c3RlbSBh dHRyaWJ1dGVzIGFyZSBub3QgYWRkZWQgaW50byBpbnRlcmVzdGluZ19hdHRycyBpbgorCQkJ CSAqIHJlbGNhY2hlLgorCQkJCSAqLworCQkJCUFzc2VydChhdHRybnVtID4gMCk7CisKKwkJ CQl2YWx1ZSA9IGhlYXBfZ2V0YXR0cigmb2xkdHVwLCBhdHRybnVtLCB0dXBkZXNjLCAmaXNu dWxsKTsKKworCQkJCS8qIE5vIG5lZWQgdG8gY2hlY2sgYXR0cmlidXRlcyB0aGF0IGNhbid0 IGJlIHN0b3JlZCBleHRlcm5hbGx5ICovCisJCQkJaWYgKGlzbnVsbCB8fAorCQkJCQlUdXBs ZURlc2NDb21wYWN0QXR0cih0dXBkZXNjLCBhdHRybnVtIC0gMSktPmF0dGxlbiAhPSAtMSkK KwkJCQkJY29udGludWU7CisKKwkJCQkvKiBDaGVjayBpZiB0aGUgb2xkIHR1cGxlJ3MgYXR0 cmlidXRlIGlzIHN0b3JlZCBleHRlcm5hbGx5ICovCisJCQkJaWYgKFZBUkFUVF9JU19FWFRF Uk5BTCgoc3RydWN0IHZhcmxlbmEgKikgRGF0dW1HZXRQb2ludGVyKHZhbHVlKSkpCisJCQkJ eworCQkJCQlyZXBfaWRfa2V5X3JlcXVpcmVkID0gdHJ1ZTsKKwkJCQkJYnJlYWs7CisJCQkJ fQorCQkJfQorCisJCQlibXNfZnJlZShhdHRycyk7CisJCX0KKwl9CiAKIAkvKgogCSAqIElm IHdlJ3JlIG5vdCB1cGRhdGluZyBhbnkgImtleSIgY29sdW1uLCB3ZSBjYW4gZ3JhYiBhIHdl YWtlciBsb2NrIHR5cGUuCkBAIC0zNzYzLDcgKzM4MjMsNyBAQCBsMjoKIAkJYm1zX2ZyZWUo c3VtX2F0dHJzKTsKIAkJYm1zX2ZyZWUoa2V5X2F0dHJzKTsKIAkJYm1zX2ZyZWUoaWRfYXR0 cnMpOwotCQlibXNfZnJlZShtb2RpZmllZF9hdHRycyk7CisJCS8qIG1vZGlmaWVkIGF0dHJz IGlzIHBhc3NlZCBpbiBhbmQgZnJlZSdkIGJ5IHRoZSBjYWxsZXIsIG9yIE5VTEwgKi8KIAkJ Ym1zX2ZyZWUoaW50ZXJlc3RpbmdfYXR0cnMpOwogCQlyZXR1cm4gcmVzdWx0OwogCX0KQEAg LTQxMTEsOCArNDE3MSw3IEBAIGwyOgogCSAqIGNvbHVtbnMgYXJlIG1vZGlmaWVkIG9yIGl0 IGhhcyBleHRlcm5hbCBkYXRhLgogCSAqLwogCW9sZF9rZXlfdHVwbGUgPSBFeHRyYWN0UmVw bGljYUlkZW50aXR5KHJlbGF0aW9uLCAmb2xkdHVwLAotCQkJCQkJCQkJCSAgIGJtc19vdmVy bGFwKG1vZGlmaWVkX2F0dHJzLCBpZF9hdHRycykgfHwKLQkJCQkJCQkJCQkgICBpZF9oYXNf ZXh0ZXJuYWwsCisJCQkJCQkJCQkJICAgcmVwX2lkX2tleV9yZXF1aXJlZCwKIAkJCQkJCQkJ CQkgICAmb2xkX2tleV9jb3BpZWQpOwogCiAJLyogTk8gRVJFUE9SVChFUlJPUikgZnJvbSBo ZXJlIHRpbGwgY2hhbmdlcyBhcmUgbG9nZ2VkICovCkBAIC00Mjc4LDcgKzQzMzcsNyBAQCBs MjoKIAlibXNfZnJlZShzdW1fYXR0cnMpOwogCWJtc19mcmVlKGtleV9hdHRycyk7CiAJYm1z X2ZyZWUoaWRfYXR0cnMpOwotCWJtc19mcmVlKG1vZGlmaWVkX2F0dHJzKTsKKwkvKiBtb2Rp ZmllZCBhdHRycyBpcyBwYXNzZWQgaW4gYW5kIGZyZWUnZCBieSB0aGUgY2FsbGVyLCBvciBO VUxMICovCiAJYm1zX2ZyZWUoaW50ZXJlc3RpbmdfYXR0cnMpOwogCiAJcmV0dXJuIFRNX09r OwpAQCAtNDU2Miw3ICs0NjIxLDggQEAgc2ltcGxlX2hlYXBfdXBkYXRlKFJlbGF0aW9uIHJl bGF0aW9uLCBjb25zdCBJdGVtUG9pbnRlckRhdGEgKm90aWQsIEhlYXBUdXBsZSB0dXAKIAly ZXN1bHQgPSBoZWFwX3VwZGF0ZShyZWxhdGlvbiwgb3RpZCwgdHVwLAogCQkJCQkJIEdldEN1 cnJlbnRDb21tYW5kSWQodHJ1ZSksIEludmFsaWRTbmFwc2hvdCwKIAkJCQkJCSB0cnVlIC8q IHdhaXQgZm9yIGNvbW1pdCAqLyAsCi0JCQkJCQkgJnRtZmQsICZsb2NrbW9kZSwgdXBkYXRl X2luZGV4ZXMpOworCQkJCQkJICZ0bWZkLCAmbG9ja21vZGUsCisJCQkJCQkgTlVMTCwgZmFs c2UsIHVwZGF0ZV9pbmRleGVzKTsKIAlzd2l0Y2ggKHJlc3VsdCkKIAl7CiAJCWNhc2UgVE1f U2VsZk1vZGlmaWVkOgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVh cGFtX2hhbmRsZXIuYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL2hlYXBhbV9oYW5kbGVy LmMKaW5kZXggY2JlZjczZTVkNGIuLjJkNzRmYTkwYzdmIDEwMDY0NAotLS0gYS9zcmMvYmFj a2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW1faGFuZGxlci5jCisrKyBiL3NyYy9iYWNrZW5kL2Fj Y2Vzcy9oZWFwL2hlYXBhbV9oYW5kbGVyLmMKQEAgLTMxMiwxMiArMzEyLDExIEBAIGhlYXBh bV90dXBsZV9kZWxldGUoUmVsYXRpb24gcmVsYXRpb24sIEl0ZW1Qb2ludGVyIHRpZCwgQ29t bWFuZElkIGNpZCwKIAlyZXR1cm4gaGVhcF9kZWxldGUocmVsYXRpb24sIHRpZCwgY2lkLCBj cm9zc2NoZWNrLCB3YWl0LCB0bWZkLCBjaGFuZ2luZ1BhcnQpOwogfQogCi0KIHN0YXRpYyBU TV9SZXN1bHQKIGhlYXBhbV90dXBsZV91cGRhdGUoUmVsYXRpb24gcmVsYXRpb24sIEl0ZW1Q b2ludGVyIG90aWQsIFR1cGxlVGFibGVTbG90ICpzbG90LAogCQkJCQlDb21tYW5kSWQgY2lk LCBTbmFwc2hvdCBzbmFwc2hvdCwgU25hcHNob3QgY3Jvc3NjaGVjaywKLQkJCQkJYm9vbCB3 YWl0LCBUTV9GYWlsdXJlRGF0YSAqdG1mZCwKLQkJCQkJTG9ja1R1cGxlTW9kZSAqbG9ja21v ZGUsIFRVX1VwZGF0ZUluZGV4ZXMgKnVwZGF0ZV9pbmRleGVzKQorCQkJCQlib29sIHdhaXQs IFRNX0ZhaWx1cmVEYXRhICp0bWZkLCBMb2NrVHVwbGVNb2RlICpsb2NrbW9kZSwKKwkJCQkJ Y29uc3QgQml0bWFwc2V0ICptb2RpZmllZF9hdHRycywgVFVfVXBkYXRlSW5kZXhlcyAqdXBk YXRlX2luZGV4ZXMpCiB7CiAJYm9vbAkJc2hvdWxkRnJlZSA9IHRydWU7CiAJSGVhcFR1cGxl CXR1cGxlID0gRXhlY0ZldGNoU2xvdEhlYXBUdXBsZShzbG90LCB0cnVlLCAmc2hvdWxkRnJl ZSk7CkBAIC0zMjgsNyArMzI3LDcgQEAgaGVhcGFtX3R1cGxlX3VwZGF0ZShSZWxhdGlvbiBy ZWxhdGlvbiwgSXRlbVBvaW50ZXIgb3RpZCwgVHVwbGVUYWJsZVNsb3QgKnNsb3QsCiAJdHVw bGUtPnRfdGFibGVPaWQgPSBzbG90LT50dHNfdGFibGVPaWQ7CiAKIAlyZXN1bHQgPSBoZWFw X3VwZGF0ZShyZWxhdGlvbiwgb3RpZCwgdHVwbGUsIGNpZCwgY3Jvc3NjaGVjaywgd2FpdCwK LQkJCQkJCSB0bWZkLCBsb2NrbW9kZSwgdXBkYXRlX2luZGV4ZXMpOworCQkJCQkJIHRtZmQs IGxvY2ttb2RlLCBtb2RpZmllZF9hdHRycywgdHJ1ZSwgdXBkYXRlX2luZGV4ZXMpOwogCUl0 ZW1Qb2ludGVyQ29weSgmdHVwbGUtPnRfc2VsZiwgJnNsb3QtPnR0c190aWQpOwogCiAJLyoK ZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy90YWJsZS90YWJsZWFtLmMgYi9zcmMv YmFja2VuZC9hY2Nlc3MvdGFibGUvdGFibGVhbS5jCmluZGV4IGRmZGExYWY0MTJlLi40MmFj ZDViMTdhOSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvYWNjZXNzL3RhYmxlL3RhYmxlYW0u YworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvdGFibGUvdGFibGVhbS5jCkBAIC0zNTksNiAr MzU5LDcgQEAgdm9pZAogc2ltcGxlX3RhYmxlX3R1cGxlX3VwZGF0ZShSZWxhdGlvbiByZWws IEl0ZW1Qb2ludGVyIG90aWQsCiAJCQkJCQkgIFR1cGxlVGFibGVTbG90ICpzbG90LAogCQkJ CQkJICBTbmFwc2hvdCBzbmFwc2hvdCwKKwkJCQkJCSAgY29uc3QgQml0bWFwc2V0ICptaXhf YXR0cnMsCiAJCQkJCQkgIFRVX1VwZGF0ZUluZGV4ZXMgKnVwZGF0ZV9pbmRleGVzKQogewog CVRNX1Jlc3VsdAlyZXN1bHQ7CkBAIC0zNjksNyArMzcwLDkgQEAgc2ltcGxlX3RhYmxlX3R1 cGxlX3VwZGF0ZShSZWxhdGlvbiByZWwsIEl0ZW1Qb2ludGVyIG90aWQsCiAJCQkJCQkJCUdl dEN1cnJlbnRDb21tYW5kSWQodHJ1ZSksCiAJCQkJCQkJCXNuYXBzaG90LCBJbnZhbGlkU25h cHNob3QsCiAJCQkJCQkJCXRydWUgLyogd2FpdCBmb3IgY29tbWl0ICovICwKLQkJCQkJCQkJ JnRtZmQsICZsb2NrbW9kZSwgdXBkYXRlX2luZGV4ZXMpOworCQkJCQkJCQkmdG1mZCwgJmxv Y2ttb2RlLAorCQkJCQkJCQltaXhfYXR0cnMsCisJCQkJCQkJCXVwZGF0ZV9pbmRleGVzKTsK IAogCXN3aXRjaCAocmVzdWx0KQogCXsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1h bmRzL3RyaWdnZXIuYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3RyaWdnZXIuYwppbmRleCA4 ZGY5MTVmNjNmYi4uNzhjMDYzOTM5YjAgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1h bmRzL3RyaWdnZXIuYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy90cmlnZ2VyLmMKQEAg LTI5NzgsNiArMjk3OCw3IEBAIEV4ZWNCUlVwZGF0ZVRyaWdnZXJzKEVTdGF0ZSAqZXN0YXRl LCBFUFFTdGF0ZSAqZXBxc3RhdGUsCiAJCQkJCSBib29sIGlzX21lcmdlX3VwZGF0ZSkKIHsK IAlUcmlnZ2VyRGVzYyAqdHJpZ2Rlc2MgPSByZWxpbmZvLT5yaV9UcmlnRGVzYzsKKwlUdXBs ZURlc2MJdHVwZGVzYyA9IFJlbGF0aW9uR2V0RGVzY3IocmVsaW5mby0+cmlfUmVsYXRpb25E ZXNjKTsKIAlUdXBsZVRhYmxlU2xvdCAqb2xkc2xvdCA9IEV4ZWNHZXRUcmlnZ2VyT2xkU2xv dChlc3RhdGUsIHJlbGluZm8pOwogCUhlYXBUdXBsZQluZXd0dXBsZSA9IE5VTEw7CiAJSGVh cFR1cGxlCXRyaWd0dXBsZTsKQEAgLTI5ODUsNyArMjk4Niw4IEBAIEV4ZWNCUlVwZGF0ZVRy aWdnZXJzKEVTdGF0ZSAqZXN0YXRlLCBFUFFTdGF0ZSAqZXBxc3RhdGUsCiAJYm9vbAkJc2hv dWxkX2ZyZWVfbmV3ID0gZmFsc2U7CiAJVHJpZ2dlckRhdGEgTG9jVHJpZ2dlckRhdGEgPSB7 MH07CiAJaW50CQkJaTsKLQlCaXRtYXBzZXQgICp1cGRhdGVkQ29sczsKKwlCaXRtYXBzZXQg ICp1cGRhdGVkQ29scyA9IE5VTEw7CisJQml0bWFwc2V0ICAqbW9kaWZpZWRDb2xzOwogCUxv Y2tUdXBsZU1vZGUgbG9ja21vZGU7CiAKIAkvKiBEZXRlcm1pbmUgbG9jayBtb2RlIHRvIHVz ZSAqLwpAQCAtMzEyNyw2ICszMTI5LDE3IEBAIEV4ZWNCUlVwZGF0ZVRyaWdnZXJzKEVTdGF0 ZSAqZXN0YXRlLCBFUFFTdGF0ZSAqZXBxc3RhdGUsCiAJaWYgKHNob3VsZF9mcmVlX3RyaWcp CiAJCWhlYXBfZnJlZXR1cGxlKHRyaWd0dXBsZSk7CiAKKwkvKgorCSAqIEJlZm9yZSBVUERB VEUgdHJpZ2dlcnMgbWF5IGhhdmUgdXBkYXRlZCBhdHRyaWJ1dGVzIG5vdCBrbm93biB0bwor CSAqIEV4ZWNHZXRBbGxVcGRhdGVkQ29sdW1ucygpIHVzaW5nIGhlYXBfbW9kaWZ5X3R1cGxl KCkgb3IKKwkgKiBoZWFwX21vZGlmaXlfdHVwbGVfYnlfY29scygpLiAgRmluZCBhbmQgcmVj b3JkIHRob3NlIG5vdy4KKwkgKi8KKwltb2RpZmllZENvbHMgPSBFeGVjQ29tcGFyZVNsb3Rz KHJlbGluZm8sIHR1cGRlc2MsIHVwZGF0ZWRDb2xzLAorCQkJCQkJCQkJTlVMTCwgb2xkc2xv dCwgbmV3c2xvdCk7CisJcmVsaW5mby0+cmlfZXh0cmFVcGRhdGVkQ29scyA9CisJCWJtc19h ZGRfbWVtYmVycyhyZWxpbmZvLT5yaV9leHRyYVVwZGF0ZWRDb2xzLCBtb2RpZmllZENvbHMp OworCWJtc19mcmVlKG1vZGlmaWVkQ29scyk7CisKIAlyZXR1cm4gdHJ1ZTsKIH0KIApkaWZm IC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1JlcGxpY2F0aW9uLmMgYi9zcmMv YmFja2VuZC9leGVjdXRvci9leGVjUmVwbGljYXRpb24uYwppbmRleCA3NDNiMWVlMmIyOC4u MjEyMmZjMzM1NTQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNSZXBs aWNhdGlvbi5jCisrKyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNSZXBsaWNhdGlvbi5j CkBAIC0zMyw2ICszMyw3IEBACiAjaW5jbHVkZSAidXRpbHMvYnVpbHRpbnMuaCIKICNpbmNs dWRlICJ1dGlscy9sc3lzY2FjaGUuaCIKICNpbmNsdWRlICJ1dGlscy9yZWwuaCIKKyNpbmNs dWRlICJ1dGlscy9yZWxjYWNoZS5oIgogI2luY2x1ZGUgInV0aWxzL3NuYXBtZ3IuaCIKICNp bmNsdWRlICJ1dGlscy9zeXNjYWNoZS5oIgogI2luY2x1ZGUgInV0aWxzL3R5cGNhY2hlLmgi CkBAIC04OTksNiArOTAwLDcgQEAgRXhlY1NpbXBsZVJlbGF0aW9uVXBkYXRlKFJlc3VsdFJl bEluZm8gKnJlc3VsdFJlbEluZm8sCiAJYm9vbAkJc2tpcF90dXBsZSA9IGZhbHNlOwogCVJl bGF0aW9uCXJlbCA9IHJlc3VsdFJlbEluZm8tPnJpX1JlbGF0aW9uRGVzYzsKIAlJdGVtUG9p bnRlciB0aWQgPSAmKHNlYXJjaHNsb3QtPnR0c190aWQpOworCUJpdG1hcHNldCAgKm1peF9h dHRyczsKIAogCS8qCiAJICogV2Ugc3VwcG9ydCBvbmx5IG5vbi1zeXN0ZW0gdGFibGVzLCB3 aXRoCkBAIC05MzcsOCArOTM5LDE2IEBAIEV4ZWNTaW1wbGVSZWxhdGlvblVwZGF0ZShSZXN1 bHRSZWxJbmZvICpyZXN1bHRSZWxJbmZvLAogCQlpZiAocmVsLT5yZF9yZWwtPnJlbGlzcGFy dGl0aW9uKQogCQkJRXhlY1BhcnRpdGlvbkNoZWNrKHJlc3VsdFJlbEluZm8sIHNsb3QsIGVz dGF0ZSwgdHJ1ZSk7CiAKKwkJbWl4X2F0dHJzID0gRXhlY0NoZWNrSW5kZXhlZEF0dHJzRm9y Q2hhbmdlcyhyZXN1bHRSZWxJbmZvLAorCQkJCQkJCQkJCQkJCWVzdGF0ZSwgc2VhcmNoc2xv dCwgc2xvdCk7CisKKwkJLyoKKwkJICogV2UncmUgbm90IGdvaW5nIHRvIGNhbGwgRXhlY0No ZWNrSW5kZXhlZEF0dHJzRm9yQ2hhbmdlcyBoZXJlCisJCSAqIGJlY2F1c2Ugd2UndmUgYWxy ZWFkeSBpZGVudGlmaWVkIHRoZSBjaGFuZ2VzIGVhcmxpZXIgb24gdGhhbmtzIHRvCisJCSAq IHNsb3RfbW9kaWZ5X2RhdGEuCisJCSAqLwogCQlzaW1wbGVfdGFibGVfdHVwbGVfdXBkYXRl KHJlbCwgdGlkLCBzbG90LCBlc3RhdGUtPmVzX3NuYXBzaG90LAotCQkJCQkJCQkgICZ1cGRh dGVfaW5kZXhlcyk7CisJCQkJCQkJCSAgbWl4X2F0dHJzLCAmdXBkYXRlX2luZGV4ZXMpOwog CiAJCWNvbmZsaWN0aW5kZXhlcyA9IHJlc3VsdFJlbEluZm8tPnJpX29uQ29uZmxpY3RBcmJp dGVySW5kZXhlczsKIApkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1R1 cGxlcy5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1R1cGxlcy5jCmluZGV4IGI3Njhl YWU5ZTUzLi45YWQwOGIyNGMyZiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3Iv ZXhlY1R1cGxlcy5jCisrKyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNUdXBsZXMuYwpA QCAtNjYsNiArNjYsNyBAQAogI2luY2x1ZGUgIm5vZGVzL25vZGVGdW5jcy5oIgogI2luY2x1 ZGUgInN0b3JhZ2UvYnVmbWdyLmgiCiAjaW5jbHVkZSAidXRpbHMvYnVpbHRpbnMuaCIKKyNp bmNsdWRlICJ1dGlscy9kYXR1bS5oIgogI2luY2x1ZGUgInV0aWxzL2V4cGFuZGVkZGF0dW0u aCIKICNpbmNsdWRlICJ1dGlscy9sc3lzY2FjaGUuaCIKICNpbmNsdWRlICJ1dGlscy90eXBj YWNoZS5oIgpAQCAtMTkyOSw2ICsxOTMwLDc5IEBAIEV4ZWNGZXRjaFNsb3RIZWFwVHVwbGVE YXR1bShUdXBsZVRhYmxlU2xvdCAqc2xvdCkKIAlyZXR1cm4gcmV0OwogfQogCisvKgorICog RXhlY0NvbXBhcmVTbG90cworICoKKyAqIENvbXBhcmUgb2xkIGFuZCBuZXcgVHVwbGVUYWJs ZVNsb3RzIHRvIGRldGVjdCB3aGljaCBhdHRyaWJ1dGVzIGhhdmUgY2hhbmdlZC4KKyAqCisg KiBUaGlzIGZ1bmN0aW9uIHNlcnZlcyB0d28gcHVycG9zZXM6CisgKiAxKSBBZnRlciB0cmln Z2VyIGV4ZWN1dGlvbjogZGV0ZWN0IHRyaWdnZXItbW9kaWZpZWQgY29sdW1ucworICogICAg KHBhc3MgZXhjbHVkaW5nPWV4cGxpY2l0bHkgU0VUIGNvbHVtbnMsIGluY2x1ZGluZz1OVUxM KQorICogMikgSW5kZXggbWFpbnRlbmFuY2U6IGRldGVjdCBjaGFuZ2VzIGluIGluZGV4ZWQg Y29sdW1ucworICogICAgKHBhc3MgaW5jbHVkaW5nPWluZGV4ZWQgQU5EIGV4cGxpY2l0bHkg U0VUIGNvbHVtbnMsIGV4Y2x1ZGluZz1OVUxMKQorICoKKyAqIFBhcmFtZXRlcnM6CisgKiAg IHJlc3VsdFJlbEluZm8gLSByZWxhdGlvbiBpbmZvcm1hdGlvbgorICogICBleGNsdWRpbmcg LSBiaXRtYXBzZXQgb2YgYXR0cmlidXRlcyB0byBza2lwCisgKiAgIGluY2x1ZGluZyAtIGJp dG1hcHNldCBvZiBhdHRyaWJ1dGVzIHRvIGNoZWNrCisgKiAgIHR1cGRlc2MgLSBSZWxhdGlv bkdldERlc2NyKHJlbGF0aW9uKQorICogICBvbGRfdHRzIC0gb2xkIHR1cGxlIHNsb3QKKyAq ICAgbmV3X3R0cyAtIG5ldyB0dXBsZSBzbG90CisgKgorICogSWYgaW5jbHVkaW5nIGlzIE5V TEwsIGNoZWNrIGFsbCBhdHRyaWJ1dGVzIEVYQ0VQVCB0aG9zZSBpbiBleGNsdWRpbmcKKyAq IElmIGV4Y2x1ZGluZyBpcyBOVUxMLCBjaGVjayBPTkxZIGF0dHJpYnV0ZXMgaW4gaW5jbHVk aW5nCisgKiBJZiBib3RoIGFyZSBOVUxMLCBjaGVjayBhbGwgYXR0cmlidXRlcworICoKKyAq IFJldHVybnMgYSBCaXRtYXBzZXQgb2YgYXR0cmlidXRlIGluZGljZXMgKHVzaW5nIEZpcnN0 TG93SW52YWxpZEhlYXBBdHRyaWJ1dGVOdW1iZXIKKyAqIGNvbnZlbnRpb24pIHRoYXQgZGlm ZmVyIGJldHdlZW4gdGhlIHR3byBzbG90cy4KKyAqLworQml0bWFwc2V0ICoKK0V4ZWNDb21w YXJlU2xvdHMoUmVzdWx0UmVsSW5mbyAqcmVzdWx0UmVsSW5mbywKKwkJCQkgVHVwbGVEZXNj IHR1cGRlc2MsCisJCQkJIGNvbnN0IEJpdG1hcHNldCAqZXhjbHVkaW5nLAorCQkJCSBjb25z dCBCaXRtYXBzZXQgKmluY2x1ZGluZywKKwkJCQkgVHVwbGVUYWJsZVNsb3QgKm9sZF90dHMs CisJCQkJIFR1cGxlVGFibGVTbG90ICpuZXdfdHRzKQoreworCUJpdG1hcHNldCAgKm1vZGlm aWVkX2F0dHJzID0gTlVMTDsKKworCWZvciAoaW50IGkgPSAwOyBpIDwgdHVwZGVzYy0+bmF0 dHM7IGkrKykKKwl7CisJCUF0dHJOdW1iZXIJYXR0bnVtID0gaSArIDE7CisJCUF0dHJOdW1i ZXIJYXR0aWR4ID0gYXR0bnVtIC0gRmlyc3RMb3dJbnZhbGlkSGVhcEF0dHJpYnV0ZU51bWJl cjsKKwkJRGF0dW0JCW9sZF92YWx1ZSwKKwkJCQkJbmV3X3ZhbHVlOworCQlib29sCQlvbGRf bnVsbCwKKwkJCQkJbmV3X251bGw7CisJCUNvbXBhY3RBdHRyaWJ1dGUgKmF0dDsKKworCQkv KiBEZXRlcm1pbmUgd2hldGhlciB0byBjaGVjayB0aGlzIGF0dHJpYnV0ZSAqLworCQlpZiAo KCFibXNfaXNfZW1wdHkoaW5jbHVkaW5nKSAmJiAhYm1zX2lzX21lbWJlcihhdHRpZHgsIGlu Y2x1ZGluZykpIHx8CisJCQlibXNfaXNfbWVtYmVyKGF0dGlkeCwgZXhjbHVkaW5nKSkKKwkJ CWNvbnRpbnVlOworCisJCWF0dCA9IFR1cGxlRGVzY0NvbXBhY3RBdHRyKHR1cGRlc2MsIGF0 dG51bSAtIDEpOworCQlvbGRfdmFsdWUgPSBzbG90X2dldGF0dHIob2xkX3R0cywgYXR0bnVt LCAmb2xkX251bGwpOworCQluZXdfdmFsdWUgPSBzbG90X2dldGF0dHIobmV3X3R0cywgYXR0 bnVtLCAmbmV3X251bGwpOworCisJCS8qIEEgY2hhbmdlIHRvL2Zyb20gTlVMTCwgc28gbm90 IGVxdWFsICovCisJCWlmIChvbGRfbnVsbCAhPSBuZXdfbnVsbCkKKwkJeworCQkJbW9kaWZp ZWRfYXR0cnMgPSBibXNfYWRkX21lbWJlcihtb2RpZmllZF9hdHRycywgYXR0aWR4KTsKKwkJ CWNvbnRpbnVlOworCQl9CisKKwkJLyogQm90aCBOVUxMLCBubyBjaGFuZ2UvdW5tb2RpZmll ZCAqLworCQlpZiAob2xkX251bGwpCisJCQljb250aW51ZTsKKworCQlpZiAoIWRhdHVtX2lt YWdlX2VxKG9sZF92YWx1ZSwgbmV3X3ZhbHVlLCBhdHQtPmF0dGJ5dmFsLCBhdHQtPmF0dGxl bikpCisJCQltb2RpZmllZF9hdHRycyA9IGJtc19hZGRfbWVtYmVyKG1vZGlmaWVkX2F0dHJz LCBhdHRpZHgpOworCX0KKworCXJldHVybiBtb2RpZmllZF9hdHRyczsKK30KKwogLyogLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLQogICoJCQkJY29udmVuaWVuY2UgaW5pdGlhbGl6YXRpb24gcm91dGluZXMKICAq IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVNb2Rp ZnlUYWJsZS5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZU1vZGlmeVRhYmxlLmMKaW5k ZXggNjgwMmZjMTNlOTUuLmFmY2MzZGEyODM1IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9l eGVjdXRvci9ub2RlTW9kaWZ5VGFibGUuYworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9u b2RlTW9kaWZ5VGFibGUuYwpAQCAtMTcsNiArMTcsNyBAQAogICoJCUV4ZWNNb2RpZnlUYWJs ZQkJLSByZXRyaWV2ZSB0aGUgbmV4dCB0dXBsZSBmcm9tIHRoZSBub2RlCiAgKgkJRXhlY0Vu ZE1vZGlmeVRhYmxlCS0gc2h1dCBkb3duIHRoZSBNb2RpZnlUYWJsZSBub2RlCiAgKgkJRXhl Y1JlU2Nhbk1vZGlmeVRhYmxlIC0gcmVzY2FuIHRoZSBNb2RpZnlUYWJsZSBub2RlCisgKgkJ RXhlY0NoZWNrSW5kZXhlZEF0dHJzRm9yQ2hhbmdlcyAtIGZpbmQgc2V0IG9mIHVwZGF0ZWQg aW5kZXhlZCBjb2x1bW5zCiAgKgogICoJIE5PVEVTCiAgKgkJVGhlIE1vZGlmeVRhYmxlIG5v ZGUgcmVjZWl2ZXMgaW5wdXQgZnJvbSBpdHMgb3V0ZXJQbGFuLCB3aGljaCBpcwpAQCAtNTQs NiArNTUsNyBAQAogCiAjaW5jbHVkZSAiYWNjZXNzL2h0dXBfZGV0YWlscy5oIgogI2luY2x1 ZGUgImFjY2Vzcy90YWJsZWFtLmgiCisjaW5jbHVkZSAiYWNjZXNzL3R1cGRlc2MuaCIKICNp bmNsdWRlICJhY2Nlc3MveGFjdC5oIgogI2luY2x1ZGUgImNvbW1hbmRzL3RyaWdnZXIuaCIK ICNpbmNsdWRlICJleGVjdXRvci9leGVjUGFydGl0aW9uLmgiCkBAIC0xODgsNiArMTkwLDQ0 IEBAIHN0YXRpYyBUdXBsZVRhYmxlU2xvdCAqRXhlY01lcmdlTm90TWF0Y2hlZChNb2RpZnlU YWJsZUNvbnRleHQgKmNvbnRleHQsCiAJCQkJCQkJCQkJICAgUmVzdWx0UmVsSW5mbyAqcmVz dWx0UmVsSW5mbywKIAkJCQkJCQkJCQkgICBib29sIGNhblNldFRhZyk7CiAKKy8qCisgKiBF eGVjQ2hlY2tJbmRleGVkQXR0cnNGb3JDaGFuZ2VzCisgKgorICogRGV0ZXJtaW5lIHdoaWNo IGluZGV4ZXMgbmVlZCB1cGRhdGluZyBieSBmaW5kaW5nIHRoZSBzZXQgb2YgbW9kaWZpZWQg aW5kZXhlZAorICogYXR0cmlidXRlcy4KKyAqCisgKiBUaGUgZ29hbCBpcyBmb3IgdGhlIGV4 ZWN1dG9yIHRvIGtub3csIGFoZWFkIG9mIGNhbGxpbmcgaW50byB0aGUgdGFibGUgQU0gdG8K KyAqIHByb2Nlc3MgdGhlIHVwZGF0ZSBhbmQgYmVmb3JlIGNhbGxpbmcgaW50byB0aGUgaW5k ZXggQU0gZm9yIGluc2VydGluZyBuZXcKKyAqIGluZGV4IHR1cGxlcywgd2hpY2ggYXR0cmli dXRlcyBpbiB0aGUgbmV3IFR1cGxlVGFibGVTbG90LCBpZiBhbnksIHRydWVseQorICogbmVj ZXNzaXRhdGUgYSBuZXcgaW5kZXggdHVwbGUuCisgKgorICogUmV0dXJucyBhIEJpdG1hcHNl dCBvZiBhdHRyaWJ1dGVzIHRoYXQgaW50ZXJzZWN0cyB3aXRoIGluZGV4ZXMgd2hpY2ggcmVx dWlyZQorICogYSBuZXcgaW5kZXggdHVwbGUuCisgKi8KK0JpdG1hcHNldCAqCitFeGVjQ2hl Y2tJbmRleGVkQXR0cnNGb3JDaGFuZ2VzKFJlc3VsdFJlbEluZm8gKnJlc3VsdFJlbEluZm8s CisJCQkJCQkJCUVTdGF0ZSAqZXN0YXRlLAorCQkJCQkJCQlUdXBsZVRhYmxlU2xvdCAqb2xk X3R0cywKKwkJCQkJCQkJVHVwbGVUYWJsZVNsb3QgKm5ld190dHMpCit7CisJUmVsYXRpb24J cmVsYXRpb24gPSByZXN1bHRSZWxJbmZvLT5yaV9SZWxhdGlvbkRlc2M7CisJVHVwbGVEZXNj CXR1cGRlc2MgPSBSZWxhdGlvbkdldERlc2NyKHJlbGF0aW9uKTsKKwlCaXRtYXBzZXQgICp1 cGRfYXR0cnMgPSBOVUxMOwkvKiBhdHRyaWJ1dGVzIHNldCBpbiBVUERBVEUgc3RhdGVtZW50 ICovCisJQml0bWFwc2V0ICAqbWl4X2F0dHJzOworCisJLyogSWYgbm8gaW5kZXhlcywgd2Un cmUgZG9uZSAqLworCWlmIChyZXN1bHRSZWxJbmZvLT5yaV9OdW1JbmRpY2VzID09IDApCisJ CXJldHVybiBOVUxMOworCisJLyogRmV0Y2ggdGhlIHNldCBvZiBhdHRyaWJ1dGVzIGV4cGxp Y2l0eSBTRVQgaW4gdGhlIFVQREFURSBzdGF0ZW1lbnQgKi8KKwl1cGRfYXR0cnMgPSBFeGVj R2V0QWxsVXBkYXRlZENvbHMocmVzdWx0UmVsSW5mbywgZXN0YXRlKTsKKworCS8qIEZpbmQg b3V0IGlmIGFueSBjaGFuZ2VkICovCisJbWl4X2F0dHJzID0gRXhlY0NvbXBhcmVTbG90cyhy ZXN1bHRSZWxJbmZvLCB0dXBkZXNjLAorCQkJCQkJCQkgTlVMTCwgdXBkX2F0dHJzLCBvbGRf dHRzLCBuZXdfdHRzKTsKKworCXJldHVybiBtaXhfYXR0cnM7Cit9CiAKIC8qCiAgKiBWZXJp ZnkgdGhhdCB0aGUgdHVwbGVzIHRvIGJlIHByb2R1Y2VkIGJ5IElOU0VSVCBtYXRjaCB0aGUK QEAgLTIxOTcsMTQgKzIyMzcsMTcgQEAgRXhlY1VwZGF0ZVByZXBhcmVTbG90KFJlc3VsdFJl bEluZm8gKnJlc3VsdFJlbEluZm8sCiAgKi8KIHN0YXRpYyBUTV9SZXN1bHQKIEV4ZWNVcGRh dGVBY3QoTW9kaWZ5VGFibGVDb250ZXh0ICpjb250ZXh0LCBSZXN1bHRSZWxJbmZvICpyZXN1 bHRSZWxJbmZvLAotCQkJICBJdGVtUG9pbnRlciB0dXBsZWlkLCBIZWFwVHVwbGUgb2xkdHVw bGUsIFR1cGxlVGFibGVTbG90ICpzbG90LAotCQkJICBib29sIGNhblNldFRhZywgVXBkYXRl Q29udGV4dCAqdXBkYXRlQ3h0KQorCQkJICBJdGVtUG9pbnRlciB0dXBsZWlkLCBIZWFwVHVw bGUgb2xkdHVwbGUsIFR1cGxlVGFibGVTbG90ICpvbGRTbG90LAorCQkJICBUdXBsZVRhYmxl U2xvdCAqc2xvdCwgYm9vbCBjYW5TZXRUYWcsIFVwZGF0ZUNvbnRleHQgKnVwZGF0ZUN4dCkK IHsKIAlFU3RhdGUJICAgKmVzdGF0ZSA9IGNvbnRleHQtPmVzdGF0ZTsKIAlSZWxhdGlvbgly ZXN1bHRSZWxhdGlvbkRlc2MgPSByZXN1bHRSZWxJbmZvLT5yaV9SZWxhdGlvbkRlc2M7CiAJ Ym9vbAkJcGFydGl0aW9uX2NvbnN0cmFpbnRfZmFpbGVkOwogCVRNX1Jlc3VsdAlyZXN1bHQ7 CiAKKwkvKiBUaGUgc2V0IG9mIG1vZGlmaWVkIGluZGV4ZWQgYXR0cmlidXRlcyB0aGF0IHRy aWdnZXIgbmV3IGluZGV4IGVudHJpZXMgKi8KKwlCaXRtYXBzZXQgICptaXhfYXR0cnMgPSBO VUxMOworCiAJdXBkYXRlQ3h0LT5jcm9zc1BhcnRVcGRhdGUgPSBmYWxzZTsKIAogCS8qCkBA IC0yMzIxLDcgKzIzNjQsMTYgQEAgbHJlcGxhY2U6CiAJCUV4ZWNDb25zdHJhaW50cyhyZXN1 bHRSZWxJbmZvLCBzbG90LCBlc3RhdGUpOwogCiAJLyoKLQkgKiByZXBsYWNlIHRoZSBoZWFw IHR1cGxlCisJICogTmV4dCB1cCB3ZSBuZWVkIHRvIGZpbmQgb3V0IHRoZSBzZXQgb2YgaW5k ZXhlZCBhdHRyaWJ1dGVzIHRoYXQgaGF2ZQorCSAqIGNoYW5nZWQgaW4gdmFsdWUgYW5kIHNo b3VsZCB0cmlnZ2VyIGEgbmV3IGluZGV4IHR1cGxlLiAgV2UgY291bGQgc3RhcnQKKwkgKiB3 aXRoIHRoZSBzZXQgb2YgdXBkYXRlZCBjb2x1bW5zIHZpYSBFeGVjR2V0VXBkYXRlZENvbHMo KSwgYnV0IGlmIHdlIGRvCisJICogd2Ugd2lsbCBvdmVybG9vayBhdHRyaWJ1dGVzIGRpcmVj dGx5IG1vZGlmaWVkIGJ5IGhlYXBfbW9kaWZ5X3R1cGxlKCkKKwkgKiB3aGljaCBhcmUgbm90 IGtub3duIHRvIEV4ZWNHZXRVcGRhdGVkQ29scygpLgorCSAqLworCW1peF9hdHRycyA9IEV4 ZWNDaGVja0luZGV4ZWRBdHRyc0ZvckNoYW5nZXMocmVzdWx0UmVsSW5mbywgZXN0YXRlLCBv bGRTbG90LCBzbG90KTsKKworCS8qCisJICogQ2FsbCBpbnRvIHRoZSB0YWJsZSBBTSB0byB1 cGRhdGUgdGhlIGhlYXAgdHVwbGUuCiAJICoKIAkgKiBOb3RlOiBpZiBlc19jcm9zc2NoZWNr X3NuYXBzaG90IGlzbid0IEludmFsaWRTbmFwc2hvdCwgd2UgY2hlY2sgdGhhdAogCSAqIHRo ZSByb3cgdG8gYmUgdXBkYXRlZCBpcyB2aXNpYmxlIHRvIHRoYXQgc25hcHNob3QsIGFuZCB0 aHJvdyBhCkBAIC0yMzM1LDYgKzIzODcsNyBAQCBscmVwbGFjZToKIAkJCQkJCQkJZXN0YXRl LT5lc19jcm9zc2NoZWNrX3NuYXBzaG90LAogCQkJCQkJCQl0cnVlIC8qIHdhaXQgZm9yIGNv bW1pdCAqLyAsCiAJCQkJCQkJCSZjb250ZXh0LT50bWZkLCAmdXBkYXRlQ3h0LT5sb2NrbW9k ZSwKKwkJCQkJCQkJbWl4X2F0dHJzLAogCQkJCQkJCQkmdXBkYXRlQ3h0LT51cGRhdGVJbmRl eGVzKTsKIAogCXJldHVybiByZXN1bHQ7CkBAIC0yNTUzLDggKzI2MDYsOSBAQCBFeGVjVXBk YXRlKE1vZGlmeVRhYmxlQ29udGV4dCAqY29udGV4dCwgUmVzdWx0UmVsSW5mbyAqcmVzdWx0 UmVsSW5mbywKIAkJICovCiByZWRvX2FjdDoKIAkJbG9ja2VkdGlkID0gKnR1cGxlaWQ7Ci0J CXJlc3VsdCA9IEV4ZWNVcGRhdGVBY3QoY29udGV4dCwgcmVzdWx0UmVsSW5mbywgdHVwbGVp ZCwgb2xkdHVwbGUsIHNsb3QsCi0JCQkJCQkJICAgY2FuU2V0VGFnLCAmdXBkYXRlQ3h0KTsK KworCQlyZXN1bHQgPSBFeGVjVXBkYXRlQWN0KGNvbnRleHQsIHJlc3VsdFJlbEluZm8sIHR1 cGxlaWQsIG9sZHR1cGxlLCBvbGRTbG90LAorCQkJCQkJCSAgIHNsb3QsIGNhblNldFRhZywg JnVwZGF0ZUN4dCk7CiAKIAkJLyoKIAkJICogSWYgRXhlY1VwZGF0ZUFjdCByZXBvcnRzIHRo YXQgYSBjcm9zcy1wYXJ0aXRpb24gdXBkYXRlIHdhcyBkb25lLApAQCAtMzQwNCw4ICszNDU4 LDggQEAgbG1lcmdlX21hdGNoZWQ6CiAJCQkJCUFzc2VydChvbGR0dXBsZSA9PSBOVUxMKTsK IAogCQkJCQlyZXN1bHQgPSBFeGVjVXBkYXRlQWN0KGNvbnRleHQsIHJlc3VsdFJlbEluZm8s IHR1cGxlaWQsCi0JCQkJCQkJCQkJICAgTlVMTCwgbmV3c2xvdCwgY2FuU2V0VGFnLAotCQkJ CQkJCQkJCSAgICZ1cGRhdGVDeHQpOworCQkJCQkJCQkJCSAgIE5VTEwsIHJlc3VsdFJlbElu Zm8tPnJpX29sZFR1cGxlU2xvdCwKKwkJCQkJCQkJCQkgICBuZXdzbG90LCBjYW5TZXRUYWcs ICZ1cGRhdGVDeHQpOwogCiAJCQkJCS8qCiAJCQkJCSAqIEFzIGluIEV4ZWNVcGRhdGUoKSwg aWYgRXhlY1VwZGF0ZUFjdCgpIHJlcG9ydHMgdGhhdCBhCkBAIC0zNDMwLDYgKzM0ODQsNyBA QCBsbWVyZ2VfbWF0Y2hlZDoKIAkJCQkJCQkJCSAgIHR1cGxlaWQsIE5VTEwsIG5ld3Nsb3Qp OwogCQkJCQltdHN0YXRlLT5tdF9tZXJnZV91cGRhdGVkICs9IDE7CiAJCQkJfQorCiAJCQkJ YnJlYWs7CiAKIAkJCWNhc2UgQ01EX0RFTEVURToKQEAgLTQ1MzcsNyArNDU5Miw3IEBAIEV4 ZWNNb2RpZnlUYWJsZShQbGFuU3RhdGUgKnBzdGF0ZSkKIAkJICogRm9yIFVQREFURS9ERUxF VEUvTUVSR0UsIGZldGNoIHRoZSByb3cgaWRlbnRpdHkgaW5mbyBmb3IgdGhlIHR1cGxlCiAJ CSAqIHRvIGJlIHVwZGF0ZWQvZGVsZXRlZC9tZXJnZWQuICBGb3IgYSBoZWFwIHJlbGF0aW9u LCB0aGF0J3MgYSBUSUQ7CiAJCSAqIG90aGVyd2lzZSB3ZSBtYXkgaGF2ZSBhIHdob2xlcm93 IGp1bmsgYXR0ciB0aGF0IGNhcnJpZXMgdGhlIG9sZAotCQkgKiB0dXBsZSBpbiB0b3RvLiAg S2VlcCB0aGlzIGluIHN0ZXAgd2l0aCB0aGUgcGFydCBvZgorCQkgKiB0dXBsZSBpbiB0b3Rh bC4gIEtlZXAgdGhpcyBpbiBzdGVwIHdpdGggdGhlIHBhcnQgb2YKIAkJICogRXhlY0luaXRN b2RpZnlUYWJsZSB0aGF0IHNldHMgdXAgcmlfUm93SWRBdHROby4KIAkJICovCiAJCWlmIChv cGVyYXRpb24gPT0gQ01EX1VQREFURSB8fCBvcGVyYXRpb24gPT0gQ01EX0RFTEVURSB8fApA QCAtNDcxNyw2ICs0NzcyLDcgQEAgRXhlY01vZGlmeVRhYmxlKFBsYW5TdGF0ZSAqcHN0YXRl KQogCQkJCS8qIE5vdyBhcHBseSB0aGUgdXBkYXRlLiAqLwogCQkJCXNsb3QgPSBFeGVjVXBk YXRlKCZjb250ZXh0LCByZXN1bHRSZWxJbmZvLCB0dXBsZWlkLCBvbGR0dXBsZSwKIAkJCQkJ CQkJICBvbGRTbG90LCBzbG90LCBub2RlLT5jYW5TZXRUYWcpOworCiAJCQkJaWYgKHR1cGxv Y2spCiAJCQkJCVVubG9ja1R1cGxlKHJlc3VsdFJlbEluZm8tPnJpX1JlbGF0aW9uRGVzYywg dHVwbGVpZCwKIAkJCQkJCQkJSW5wbGFjZVVwZGF0ZVR1cGxlTG9jayk7CmRpZmYgLS1naXQg YS9zcmMvYmFja2VuZC9yZXBsaWNhdGlvbi9sb2dpY2FsL3dvcmtlci5jIGIvc3JjL2JhY2tl bmQvcmVwbGljYXRpb24vbG9naWNhbC93b3JrZXIuYwppbmRleCAzMjcyNWM0ODYyMy4uMmQ2 ZDlkNzZmODcgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwv d29ya2VyLmMKKysrIGIvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vbG9naWNhbC93b3JrZXIu YwpAQCAtMjg1LDEyICsyODUsMTQgQEAKICNpbmNsdWRlICJzdG9yYWdlL3Byb2NhcnJheS5o IgogI2luY2x1ZGUgInRjb3AvdGNvcHByb3QuaCIKICNpbmNsdWRlICJ1dGlscy9hY2wuaCIK KyNpbmNsdWRlICJ1dGlscy9kYXR1bS5oIgogI2luY2x1ZGUgInV0aWxzL2d1Yy5oIgogI2lu Y2x1ZGUgInV0aWxzL2ludmFsLmgiCiAjaW5jbHVkZSAidXRpbHMvbHN5c2NhY2hlLmgiCiAj aW5jbHVkZSAidXRpbHMvbWVtdXRpbHMuaCIKICNpbmNsdWRlICJ1dGlscy9wZ19sc24uaCIK ICNpbmNsdWRlICJ1dGlscy9yZWwuaCIKKyNpbmNsdWRlICJ1dGlscy9yZWxjYWNoZS5oIgog I2luY2x1ZGUgInV0aWxzL3Jscy5oIgogI2luY2x1ZGUgInV0aWxzL3NuYXBtZ3IuaCIKICNp bmNsdWRlICJ1dGlscy9zeXNjYWNoZS5oIgpAQCAtMjkxNyw3ICsyOTE5LDYgQEAgYXBwbHlf aGFuZGxlX3VwZGF0ZV9pbnRlcm5hbChBcHBseUV4ZWN1dGlvbkRhdGEgKmVkYXRhLAogCVR1 cGxlVGFibGVTbG90ICpsb2NhbHNsb3QgPSBOVUxMOwogCUNvbmZsaWN0VHVwbGVJbmZvIGNv bmZsaWN0dHVwbGUgPSB7MH07CiAJYm9vbAkJZm91bmQ7Ci0JTWVtb3J5Q29udGV4dCBvbGRj dHg7CiAKIAlFdmFsUGxhblF1YWxJbml0KCZlcHFzdGF0ZSwgZXN0YXRlLCBOVUxMLCBOSUws IC0xLCBOSUwpOwogCUV4ZWNPcGVuSW5kaWNlcyhyZWxpbmZvLCBmYWxzZSk7CkBAIC0yOTU2 LDE2ICsyOTU3LDE2IEBAIGFwcGx5X2hhbmRsZV91cGRhdGVfaW50ZXJuYWwoQXBwbHlFeGVj dXRpb25EYXRhICplZGF0YSwKIAkJfQogCiAJCS8qIFByb2Nlc3MgYW5kIHN0b3JlIHJlbW90 ZSB0dXBsZSBpbiB0aGUgc2xvdCAqLwotCQlvbGRjdHggPSBNZW1vcnlDb250ZXh0U3dpdGNo VG8oR2V0UGVyVHVwbGVNZW1vcnlDb250ZXh0KGVzdGF0ZSkpOwogCQlzbG90X21vZGlmeV9k YXRhKHJlbW90ZXNsb3QsIGxvY2Fsc2xvdCwgcmVsbWFwZW50cnksIG5ld3R1cCk7Ci0JCU1l bW9yeUNvbnRleHRTd2l0Y2hUbyhvbGRjdHgpOwogCiAJCUV2YWxQbGFuUXVhbFNldFNsb3Qo JmVwcXN0YXRlLCByZW1vdGVzbG90KTsKIAogCQlJbml0Q29uZmxpY3RJbmRleGVzKHJlbGlu Zm8pOwogCi0JCS8qIERvIHRoZSBhY3R1YWwgdXBkYXRlLiAqLworCQkvKiBGaXJzdCBjaGVj ayBwcml2aWxlZ2VzICovCiAJCVRhcmdldFByaXZpbGVnZXNDaGVjayhyZWxpbmZvLT5yaV9S ZWxhdGlvbkRlc2MsIEFDTF9VUERBVEUpOworCisJCS8qIFRoZW4gZG8gdGhlIGFjdHVhbCB1 cGRhdGUuICovCiAJCUV4ZWNTaW1wbGVSZWxhdGlvblVwZGF0ZShyZWxpbmZvLCBlc3RhdGUs ICZlcHFzdGF0ZSwgbG9jYWxzbG90LAogCQkJCQkJCQkgcmVtb3Rlc2xvdCk7CiAJfQpAQCAt MzUyMiwxMCArMzUyMyw3IEBAIGFwcGx5X2hhbmRsZV90dXBsZV9yb3V0aW5nKEFwcGx5RXhl Y3V0aW9uRGF0YSAqZWRhdGEsCiAJCQkJICogQXBwbHkgdGhlIHVwZGF0ZSB0byB0aGUgbG9j YWwgdHVwbGUsIHB1dHRpbmcgdGhlIHJlc3VsdCBpbgogCQkJCSAqIHJlbW90ZXNsb3RfcGFy dC4KIAkJCQkgKi8KLQkJCQlvbGRjdHggPSBNZW1vcnlDb250ZXh0U3dpdGNoVG8oR2V0UGVy VHVwbGVNZW1vcnlDb250ZXh0KGVzdGF0ZSkpOwotCQkJCXNsb3RfbW9kaWZ5X2RhdGEocmVt b3Rlc2xvdF9wYXJ0LCBsb2NhbHNsb3QsIHBhcnRfZW50cnksCi0JCQkJCQkJCSBuZXd0dXAp OwotCQkJCU1lbW9yeUNvbnRleHRTd2l0Y2hUbyhvbGRjdHgpOworCQkJCXNsb3RfbW9kaWZ5 X2RhdGEocmVtb3Rlc2xvdF9wYXJ0LCBsb2NhbHNsb3QsIHBhcnRfZW50cnksIG5ld3R1cCk7 CiAKIAkJCQlFdmFsUGxhblF1YWxJbml0KCZlcHFzdGF0ZSwgZXN0YXRlLCBOVUxMLCBOSUws IC0xLCBOSUwpOwogCkBAIC0zNTQ5LDYgKzM1NDcsNyBAQCBhcHBseV9oYW5kbGVfdHVwbGVf cm91dGluZyhBcHBseUV4ZWN1dGlvbkRhdGEgKmVkYXRhLAogCQkJCQlFdmFsUGxhblF1YWxT ZXRTbG90KCZlcHFzdGF0ZSwgcmVtb3Rlc2xvdF9wYXJ0KTsKIAkJCQkJVGFyZ2V0UHJpdmls ZWdlc0NoZWNrKHBhcnRyZWxpbmZvLT5yaV9SZWxhdGlvbkRlc2MsCiAJCQkJCQkJCQkJICBB Q0xfVVBEQVRFKTsKKwogCQkJCQlFeGVjU2ltcGxlUmVsYXRpb25VcGRhdGUocGFydHJlbGlu Zm8sIGVzdGF0ZSwgJmVwcXN0YXRlLAogCQkJCQkJCQkJCQkgbG9jYWxzbG90LCByZW1vdGVz bG90X3BhcnQpOwogCQkJCX0KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxzL2NhY2hl L3JlbGNhY2hlLmMgYi9zcmMvYmFja2VuZC91dGlscy9jYWNoZS9yZWxjYWNoZS5jCmluZGV4 IDZiNjM0YzlmZmYxLi41NDdjZjFkMDU0ZCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRp bHMvY2FjaGUvcmVsY2FjaGUuYworKysgYi9zcmMvYmFja2VuZC91dGlscy9jYWNoZS9yZWxj YWNoZS5jCkBAIC0yNDc3LDYgKzI0NzcsNyBAQCBSZWxhdGlvbkRlc3Ryb3lSZWxhdGlvbihS ZWxhdGlvbiByZWxhdGlvbiwgYm9vbCByZW1lbWJlcl90dXBkZXNjKQogCWJtc19mcmVlKHJl bGF0aW9uLT5yZF9pZGF0dHIpOwogCWJtc19mcmVlKHJlbGF0aW9uLT5yZF9ob3RibG9ja2lu Z2F0dHIpOwogCWJtc19mcmVlKHJlbGF0aW9uLT5yZF9zdW1tYXJpemVkYXR0cik7CisJYm1z X2ZyZWUocmVsYXRpb24tPnJkX2luZGV4ZWRhdHRyKTsKIAlpZiAocmVsYXRpb24tPnJkX3B1 YmRlc2MpCiAJCXBmcmVlKHJlbGF0aW9uLT5yZF9wdWJkZXNjKTsKIAlpZiAocmVsYXRpb24t PnJkX29wdGlvbnMpCkBAIC01Mjc4LDYgKzUyNzksNyBAQCBSZWxhdGlvbkdldEluZGV4UHJl ZGljYXRlKFJlbGF0aW9uIHJlbGF0aW9uKQogICoJCQkJCQkJCQlpbmRleCAoZW1wdHkgaWYg RlVMTCkKICAqCUlOREVYX0FUVFJfQklUTUFQX0hPVF9CTE9DS0lORwlDb2x1bW5zIHRoYXQg YmxvY2sgdXBkYXRlcyBmcm9tIGJlaW5nIEhPVAogICoJSU5ERVhfQVRUUl9CSVRNQVBfU1VN TUFSSVpFRAlDb2x1bW5zIGluY2x1ZGVkIGluIHN1bW1hcml6aW5nIGluZGV4ZXMKKyAqCUlO REVYX0FUVFJfQklUTUFQX0lOREVYRUQJCUNvbHVtbnMgcmVmZXJlbmNlZCBieSBpbmRleGVz CiAgKgogICogQXR0cmlidXRlIG51bWJlcnMgYXJlIG9mZnNldCBieSBGaXJzdExvd0ludmFs aWRIZWFwQXR0cmlidXRlTnVtYmVyIHNvIHRoYXQKICAqIHdlIGNhbiBpbmNsdWRlIHN5c3Rl bSBhdHRyaWJ1dGVzIChlLmcuLCBPSUQpIGluIHRoZSBiaXRtYXAgcmVwcmVzZW50YXRpb24u CkBAIC01MzAxLDYgKzUzMDMsNyBAQCBSZWxhdGlvbkdldEluZGV4QXR0ckJpdG1hcChSZWxh dGlvbiByZWxhdGlvbiwgSW5kZXhBdHRyQml0bWFwS2luZCBhdHRyS2luZCkKIAlCaXRtYXBz ZXQgICpwa2luZGV4YXR0cnM7CS8qIGNvbHVtbnMgaW4gdGhlIHByaW1hcnkgaW5kZXggKi8K IAlCaXRtYXBzZXQgICppZGluZGV4YXR0cnM7CS8qIGNvbHVtbnMgaW4gdGhlIHJlcGxpY2Eg aWRlbnRpdHkgKi8KIAlCaXRtYXBzZXQgICpob3RibG9ja2luZ2F0dHJzOwkvKiBjb2x1bW5z IHdpdGggSE9UIGJsb2NraW5nIGluZGV4ZXMgKi8KKwlCaXRtYXBzZXQgICppbmRleGVkYXR0 cnM7CS8qIGNvbHVtbnMgcmVmZXJlbmNlZCBieSBpbmRleGVzICovCiAJQml0bWFwc2V0ICAq c3VtbWFyaXplZGF0dHJzOwkvKiBjb2x1bW5zIHdpdGggc3VtbWFyaXppbmcgaW5kZXhlcyAq LwogCUxpc3QJICAgKmluZGV4b2lkbGlzdDsKIAlMaXN0CSAgICpuZXdpbmRleG9pZGxpc3Q7 CkBAIC01MzI0LDYgKzUzMjcsOCBAQCBSZWxhdGlvbkdldEluZGV4QXR0ckJpdG1hcChSZWxh dGlvbiByZWxhdGlvbiwgSW5kZXhBdHRyQml0bWFwS2luZCBhdHRyS2luZCkKIAkJCQlyZXR1 cm4gYm1zX2NvcHkocmVsYXRpb24tPnJkX2hvdGJsb2NraW5nYXR0cik7CiAJCQljYXNlIElO REVYX0FUVFJfQklUTUFQX1NVTU1BUklaRUQ6CiAJCQkJcmV0dXJuIGJtc19jb3B5KHJlbGF0 aW9uLT5yZF9zdW1tYXJpemVkYXR0cik7CisJCQljYXNlIElOREVYX0FUVFJfQklUTUFQX0lO REVYRUQ6CisJCQkJcmV0dXJuIGJtc19jb3B5KHJlbGF0aW9uLT5yZF9pbmRleGVkYXR0cik7 CiAJCQlkZWZhdWx0OgogCQkJCWVsb2coRVJST1IsICJ1bmtub3duIGF0dHJLaW5kICV1Iiwg YXR0cktpbmQpOwogCQl9CkBAIC01MzY4LDYgKzUzNzMsNyBAQCByZXN0YXJ0OgogCWlkaW5k ZXhhdHRycyA9IE5VTEw7CiAJaG90YmxvY2tpbmdhdHRycyA9IE5VTEw7CiAJc3VtbWFyaXpl ZGF0dHJzID0gTlVMTDsKKwlpbmRleGVkYXR0cnMgPSBOVUxMOwogCWZvcmVhY2gobCwgaW5k ZXhvaWRsaXN0KQogCXsKIAkJT2lkCQkJaW5kZXhPaWQgPSBsZmlyc3Rfb2lkKGwpOwpAQCAt NTUwMCwxMCArNTUwNiwxNCBAQCByZXN0YXJ0OgogCQlibXNfZnJlZShpZGluZGV4YXR0cnMp OwogCQlibXNfZnJlZShob3RibG9ja2luZ2F0dHJzKTsKIAkJYm1zX2ZyZWUoc3VtbWFyaXpl ZGF0dHJzKTsKKwkJLyogaW5kZXhlZGF0dHJzIG5vdCB5ZXQgaW5pdGlhbGl6ZWQgKi8KIAog CQlnb3RvIHJlc3RhcnQ7CiAJfQogCisJLyogU2V0IGluZGV4ZWQgYXR0cmlidXRlcyB0byB0 cmFjayBhbGwgcmVmZXJlbmNlZCBhdHRyaWJ1dGVzICovCisJaW5kZXhlZGF0dHJzID0gYm1z X3VuaW9uKGhvdGJsb2NraW5nYXR0cnMsIHN1bW1hcml6ZWRhdHRycyk7CisKIAkvKiBEb24n dCBsZWFrIHRoZSBvbGQgdmFsdWVzIG9mIHRoZXNlIGJpdG1hcHMsIGlmIGFueSAqLwogCXJl bGF0aW9uLT5yZF9hdHRyc3ZhbGlkID0gZmFsc2U7CiAJYm1zX2ZyZWUocmVsYXRpb24tPnJk X2tleWF0dHIpOwpAQCAtNTUxNiw2ICs1NTI2LDggQEAgcmVzdGFydDoKIAlyZWxhdGlvbi0+ cmRfaG90YmxvY2tpbmdhdHRyID0gTlVMTDsKIAlibXNfZnJlZShyZWxhdGlvbi0+cmRfc3Vt bWFyaXplZGF0dHIpOwogCXJlbGF0aW9uLT5yZF9zdW1tYXJpemVkYXR0ciA9IE5VTEw7CisJ Ym1zX2ZyZWUocmVsYXRpb24tPnJkX2luZGV4ZWRhdHRyKTsKKwlyZWxhdGlvbi0+cmRfaW5k ZXhlZGF0dHIgPSBOVUxMOwogCiAJLyoKIAkgKiBOb3cgc2F2ZSBjb3BpZXMgb2YgdGhlIGJp dG1hcHMgaW4gdGhlIHJlbGNhY2hlIGVudHJ5LiAgV2UgaW50ZW50aW9uYWxseQpAQCAtNTUz MCw2ICs1NTQyLDcgQEAgcmVzdGFydDoKIAlyZWxhdGlvbi0+cmRfaWRhdHRyID0gYm1zX2Nv cHkoaWRpbmRleGF0dHJzKTsKIAlyZWxhdGlvbi0+cmRfaG90YmxvY2tpbmdhdHRyID0gYm1z X2NvcHkoaG90YmxvY2tpbmdhdHRycyk7CiAJcmVsYXRpb24tPnJkX3N1bW1hcml6ZWRhdHRy ID0gYm1zX2NvcHkoc3VtbWFyaXplZGF0dHJzKTsKKwlyZWxhdGlvbi0+cmRfaW5kZXhlZGF0 dHIgPSBibXNfY29weShpbmRleGVkYXR0cnMpOwogCXJlbGF0aW9uLT5yZF9hdHRyc3ZhbGlk ID0gdHJ1ZTsKIAlNZW1vcnlDb250ZXh0U3dpdGNoVG8ob2xkY3h0KTsKIApAQCAtNTU0Niw2 ICs1NTU5LDggQEAgcmVzdGFydDoKIAkJCXJldHVybiBob3RibG9ja2luZ2F0dHJzOwogCQlj YXNlIElOREVYX0FUVFJfQklUTUFQX1NVTU1BUklaRUQ6CiAJCQlyZXR1cm4gc3VtbWFyaXpl ZGF0dHJzOworCQljYXNlIElOREVYX0FUVFJfQklUTUFQX0lOREVYRUQ6CisJCQlyZXR1cm4g aW5kZXhlZGF0dHJzOwogCQlkZWZhdWx0OgogCQkJZWxvZyhFUlJPUiwgInVua25vd24gYXR0 cktpbmQgJXUiLCBhdHRyS2luZCk7CiAJCQlyZXR1cm4gTlVMTDsKZGlmZiAtLWdpdCBhL3Ny Yy9pbmNsdWRlL2FjY2Vzcy9oZWFwYW0uaCBiL3NyYy9pbmNsdWRlL2FjY2Vzcy9oZWFwYW0u aAppbmRleCAzYzA5NjFhYjM2Yi4uYTU2ZjNkMWYzNzggMTAwNjQ0Ci0tLSBhL3NyYy9pbmNs dWRlL2FjY2Vzcy9oZWFwYW0uaAorKysgYi9zcmMvaW5jbHVkZS9hY2Nlc3MvaGVhcGFtLmgK QEAgLTM2OCw2ICszNjgsNyBAQCBleHRlcm4gVE1fUmVzdWx0IGhlYXBfdXBkYXRlKFJlbGF0 aW9uIHJlbGF0aW9uLCBjb25zdCBJdGVtUG9pbnRlckRhdGEgKm90aWQsCiAJCQkJCQkJIEhl YXBUdXBsZSBuZXd0dXAsCiAJCQkJCQkJIENvbW1hbmRJZCBjaWQsIFNuYXBzaG90IGNyb3Nz Y2hlY2ssIGJvb2wgd2FpdCwKIAkJCQkJCQkgVE1fRmFpbHVyZURhdGEgKnRtZmQsIExvY2tU dXBsZU1vZGUgKmxvY2ttb2RlLAorCQkJCQkJCSBjb25zdCBCaXRtYXBzZXQgKm1peF9hdHRy cywgYm9vbCBtaXhfYXR0cnNfdmFsaWQsCiAJCQkJCQkJIFRVX1VwZGF0ZUluZGV4ZXMgKnVw ZGF0ZV9pbmRleGVzKTsKIGV4dGVybiBUTV9SZXN1bHQgaGVhcF9sb2NrX3R1cGxlKFJlbGF0 aW9uIHJlbGF0aW9uLCBIZWFwVHVwbGUgdHVwbGUsCiAJCQkJCQkJCSBDb21tYW5kSWQgY2lk LCBMb2NrVHVwbGVNb2RlIG1vZGUsIExvY2tXYWl0UG9saWN5IHdhaXRfcG9saWN5LApkaWZm IC0tZ2l0IGEvc3JjL2luY2x1ZGUvYWNjZXNzL3RhYmxlYW0uaCBiL3NyYy9pbmNsdWRlL2Fj Y2Vzcy90YWJsZWFtLmgKaW5kZXggMjUxMzc5MDE2YjAuLjNiMDgwYWEzNzExIDEwMDY0NAot LS0gYS9zcmMvaW5jbHVkZS9hY2Nlc3MvdGFibGVhbS5oCisrKyBiL3NyYy9pbmNsdWRlL2Fj Y2Vzcy90YWJsZWFtLmgKQEAgLTU0OSw2ICs1NDksNyBAQCB0eXBlZGVmIHN0cnVjdCBUYWJs ZUFtUm91dGluZQogCQkJCQkJCQkgYm9vbCB3YWl0LAogCQkJCQkJCQkgVE1fRmFpbHVyZURh dGEgKnRtZmQsCiAJCQkJCQkJCSBMb2NrVHVwbGVNb2RlICpsb2NrbW9kZSwKKwkJCQkJCQkJ IGNvbnN0IEJpdG1hcHNldCAqdXBkYXRlZF9jb2xzLAogCQkJCQkJCQkgVFVfVXBkYXRlSW5k ZXhlcyAqdXBkYXRlX2luZGV4ZXMpOwogCiAJLyogc2VlIHRhYmxlX3R1cGxlX2xvY2soKSBm b3IgcmVmZXJlbmNlIGFib3V0IHBhcmFtZXRlcnMgKi8KQEAgLTE1MjQsMTIgKzE1MjUsMTIg QEAgc3RhdGljIGlubGluZSBUTV9SZXN1bHQKIHRhYmxlX3R1cGxlX3VwZGF0ZShSZWxhdGlv biByZWwsIEl0ZW1Qb2ludGVyIG90aWQsIFR1cGxlVGFibGVTbG90ICpzbG90LAogCQkJCSAg IENvbW1hbmRJZCBjaWQsIFNuYXBzaG90IHNuYXBzaG90LCBTbmFwc2hvdCBjcm9zc2NoZWNr LAogCQkJCSAgIGJvb2wgd2FpdCwgVE1fRmFpbHVyZURhdGEgKnRtZmQsIExvY2tUdXBsZU1v ZGUgKmxvY2ttb2RlLAotCQkJCSAgIFRVX1VwZGF0ZUluZGV4ZXMgKnVwZGF0ZV9pbmRleGVz KQorCQkJCSAgIGNvbnN0IEJpdG1hcHNldCAqbWl4X2NvbHMsIFRVX1VwZGF0ZUluZGV4ZXMg KnVwZGF0ZV9pbmRleGVzKQogewogCXJldHVybiByZWwtPnJkX3RhYmxlYW0tPnR1cGxlX3Vw ZGF0ZShyZWwsIG90aWQsIHNsb3QsCiAJCQkJCQkJCQkJIGNpZCwgc25hcHNob3QsIGNyb3Nz Y2hlY2ssCi0JCQkJCQkJCQkJIHdhaXQsIHRtZmQsCi0JCQkJCQkJCQkJIGxvY2ttb2RlLCB1 cGRhdGVfaW5kZXhlcyk7CisJCQkJCQkJCQkJIHdhaXQsIHRtZmQsIGxvY2ttb2RlLAorCQkJ CQkJCQkJCSBtaXhfY29scywgdXBkYXRlX2luZGV4ZXMpOwogfQogCiAvKgpAQCAtMjAxMCw2 ICsyMDExLDcgQEAgZXh0ZXJuIHZvaWQgc2ltcGxlX3RhYmxlX3R1cGxlX2RlbGV0ZShSZWxh dGlvbiByZWwsIEl0ZW1Qb2ludGVyIHRpZCwKIAkJCQkJCQkJCSAgU25hcHNob3Qgc25hcHNo b3QpOwogZXh0ZXJuIHZvaWQgc2ltcGxlX3RhYmxlX3R1cGxlX3VwZGF0ZShSZWxhdGlvbiBy ZWwsIEl0ZW1Qb2ludGVyIG90aWQsCiAJCQkJCQkJCQkgIFR1cGxlVGFibGVTbG90ICpzbG90 LCBTbmFwc2hvdCBzbmFwc2hvdCwKKwkJCQkJCQkJCSAgY29uc3QgQml0bWFwc2V0ICptaXhf YXR0cnMsCiAJCQkJCQkJCQkgIFRVX1VwZGF0ZUluZGV4ZXMgKnVwZGF0ZV9pbmRleGVzKTsK IAogCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9jYXRhbG9nL2luZGV4LmggYi9zcmMvaW5j bHVkZS9jYXRhbG9nL2luZGV4LmgKaW5kZXggYjI1OWM0MTQxZWQuLjE0YTM5YmVhYjZlIDEw MDY0NAotLS0gYS9zcmMvaW5jbHVkZS9jYXRhbG9nL2luZGV4LmgKKysrIGIvc3JjL2luY2x1 ZGUvY2F0YWxvZy9pbmRleC5oCkBAIC0xMzIsNiArMTMyLDcgQEAgZXh0ZXJuIGJvb2wgQ29t cGFyZUluZGV4SW5mbyhjb25zdCBJbmRleEluZm8gKmluZm8xLCBjb25zdCBJbmRleEluZm8g KmluZm8yLAogCQkJCQkJCSBjb25zdCBBdHRyTWFwICphdHRtYXApOwogCiBleHRlcm4gdm9p ZCBCdWlsZFNwZWN1bGF0aXZlSW5kZXhJbmZvKFJlbGF0aW9uIGluZGV4LCBJbmRleEluZm8g KmlpKTsKK2V4dGVybiB2b2lkIEJ1aWxkVXBkYXRlSW5kZXhJbmZvKFJlc3VsdFJlbEluZm8g KnJlc3VsdFJlbEluZm8pOwogCiBleHRlcm4gdm9pZCBGb3JtSW5kZXhEYXR1bShJbmRleElu Zm8gKmluZGV4SW5mbywKIAkJCQkJCSAgIFR1cGxlVGFibGVTbG90ICpzbG90LApkaWZmIC0t Z2l0IGEvc3JjL2luY2x1ZGUvZXhlY3V0b3IvZXhlY3V0b3IuaCBiL3NyYy9pbmNsdWRlL2V4 ZWN1dG9yL2V4ZWN1dG9yLmgKaW5kZXggNTVhN2Q5MzBkMjYuLjZlMjYzMjc4YTRlIDEwMDY0 NAotLS0gYS9zcmMvaW5jbHVkZS9leGVjdXRvci9leGVjdXRvci5oCisrKyBiL3NyYy9pbmNs dWRlL2V4ZWN1dG9yL2V4ZWN1dG9yLmgKQEAgLTYwNiw2ICs2MDYsMTIgQEAgZXh0ZXJuIFR1 cGxlRGVzYyBFeGVjQ2xlYW5UeXBlRnJvbVRMKExpc3QgKnRhcmdldExpc3QpOwogZXh0ZXJu IFR1cGxlRGVzYyBFeGVjVHlwZUZyb21FeHByTGlzdChMaXN0ICpleHByTGlzdCk7CiBleHRl cm4gdm9pZCBFeGVjVHlwZVNldENvbE5hbWVzKFR1cGxlRGVzYyB0eXBlSW5mbywgTGlzdCAq bmFtZXNMaXN0KTsKIGV4dGVybiB2b2lkIFVwZGF0ZUNoYW5nZWRQYXJhbVNldChQbGFuU3Rh dGUgKm5vZGUsIEJpdG1hcHNldCAqbmV3Y2hnKTsKK2V4dGVybiBCaXRtYXBzZXQgKkV4ZWND b21wYXJlU2xvdHMoUmVzdWx0UmVsSW5mbyAqcmVzdWx0UmVsSW5mbywKKwkJCQkJCQkJICAg VHVwbGVEZXNjIHR1cGRlc2MsCisJCQkJCQkJCSAgIGNvbnN0IEJpdG1hcHNldCAqZXhjbHVk aW5nLAorCQkJCQkJCQkgICBjb25zdCBCaXRtYXBzZXQgKmluY2x1ZGluZywKKwkJCQkJCQkJ ICAgVHVwbGVUYWJsZVNsb3QgKm9sZF90dHMsCisJCQkJCQkJCSAgIFR1cGxlVGFibGVTbG90 ICpuZXdfdHRzKTsKIAogdHlwZWRlZiBzdHJ1Y3QgVHVwT3V0cHV0U3RhdGUKIHsKQEAgLTgw MCw1ICs4MDYsOSBAQCBleHRlcm4gUmVzdWx0UmVsSW5mbyAqRXhlY0xvb2t1cFJlc3VsdFJl bEJ5T2lkKE1vZGlmeVRhYmxlU3RhdGUgKm5vZGUsCiAJCQkJCQkJCQkJCSAgIE9pZCByZXN1 bHRvaWQsCiAJCQkJCQkJCQkJCSAgIGJvb2wgbWlzc2luZ19vaywKIAkJCQkJCQkJCQkJICAg Ym9vbCB1cGRhdGVfY2FjaGUpOworZXh0ZXJuIEJpdG1hcHNldCAqRXhlY0NoZWNrSW5kZXhl ZEF0dHJzRm9yQ2hhbmdlcyhSZXN1bHRSZWxJbmZvICpyZWxpbmZvLAorCQkJCQkJCQkJCQkJ ICBFU3RhdGUgKmVzdGF0ZSwKKwkJCQkJCQkJCQkJCSAgVHVwbGVUYWJsZVNsb3QgKm9sZF90 dHMsCisJCQkJCQkJCQkJCQkgIFR1cGxlVGFibGVTbG90ICpuZXdfdHRzKTsKIAogI2VuZGlm CQkJCQkJCS8qIEVYRUNVVE9SX0ggICovCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9ub2Rl cy9leGVjbm9kZXMuaCBiL3NyYy9pbmNsdWRlL25vZGVzL2V4ZWNub2Rlcy5oCmluZGV4IDYz YzA2N2Q1YWFlLi4xMzI4NGRiZDcwYiAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvbm9kZXMv ZXhlY25vZGVzLmgKKysrIGIvc3JjL2luY2x1ZGUvbm9kZXMvZXhlY25vZGVzLmgKQEAgLTUw Miw2ICs1MDIsMTIgQEAgdHlwZWRlZiBzdHJ1Y3QgUmVzdWx0UmVsSW5mbwogCS8qIHRydWUg aWYgdGhlIGFib3ZlIGhhcyBiZWVuIGNvbXB1dGVkICovCiAJYm9vbAkJcmlfZXh0cmFVcGRh dGVkQ29sc192YWxpZDsKIAorCS8qCisJICogRm9yIFVQREFURSBhIEJpdG1hcHNldCBvZiB0 aGUgYXR0cmlidXRlcyB0aGF0IGFyZSBib3RoIGluZGV4ZWQgYW5kIGhhdmUKKwkgKiBjaGFu Z2VkIGluIHZhbHVlLgorCSAqLworCUJpdG1hcHNldCAgKnJpX0NoYW5nZWRJbmRleGVkQ29s czsKKwogCS8qIFByb2plY3Rpb24gdG8gZ2VuZXJhdGUgbmV3IHR1cGxlIGluIGFuIElOU0VS VC9VUERBVEUgKi8KIAlQcm9qZWN0aW9uSW5mbyAqcmlfcHJvamVjdE5ldzsKIAkvKiBTbG90 IHRvIGhvbGQgdGhhdCB0dXBsZSAqLwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvdXRpbHMv cmVsLmggYi9zcmMvaW5jbHVkZS91dGlscy9yZWwuaAppbmRleCAyMzY4MzBmNmI5My4uZGY1 NDI2ZmQ3ZmIgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL3V0aWxzL3JlbC5oCisrKyBiL3Ny Yy9pbmNsdWRlL3V0aWxzL3JlbC5oCkBAIC0xNjQsNiArMTY0LDcgQEAgdHlwZWRlZiBzdHJ1 Y3QgUmVsYXRpb25EYXRhCiAJQml0bWFwc2V0ICAqcmRfaWRhdHRyOwkJLyogaW5jbHVkZWQg aW4gcmVwbGljYSBpZGVudGl0eSBpbmRleCAqLwogCUJpdG1hcHNldCAgKnJkX2hvdGJsb2Nr aW5nYXR0cjsgLyogY29scyBibG9ja2luZyBIT1QgdXBkYXRlICovCiAJQml0bWFwc2V0ICAq cmRfc3VtbWFyaXplZGF0dHI7CS8qIGNvbHMgaW5kZXhlZCBieSBzdW1tYXJpemluZyBpbmRl eGVzICovCisJQml0bWFwc2V0ICAqcmRfaW5kZXhlZGF0dHI7IC8qIGFsbCBjb2xzIHJlZmVy ZW5jZWQgYnkgaW5kZXhlcyAqLwogCiAJUHVibGljYXRpb25EZXNjICpyZF9wdWJkZXNjOwkv KiBwdWJsaWNhdGlvbiBkZXNjcmlwdG9yLCBvciBOVUxMICovCiAKZGlmZiAtLWdpdCBhL3Ny Yy9pbmNsdWRlL3V0aWxzL3JlbGNhY2hlLmggYi9zcmMvaW5jbHVkZS91dGlscy9yZWxjYWNo ZS5oCmluZGV4IDI3MDAyMjQ5MzlhLi41ODM0YWI3YjkwMyAxMDA2NDQKLS0tIGEvc3JjL2lu Y2x1ZGUvdXRpbHMvcmVsY2FjaGUuaAorKysgYi9zcmMvaW5jbHVkZS91dGlscy9yZWxjYWNo ZS5oCkBAIC03MSw2ICs3MSw3IEBAIHR5cGVkZWYgZW51bSBJbmRleEF0dHJCaXRtYXBLaW5k CiAJSU5ERVhfQVRUUl9CSVRNQVBfSURFTlRJVFlfS0VZLAogCUlOREVYX0FUVFJfQklUTUFQ X0hPVF9CTE9DS0lORywKIAlJTkRFWF9BVFRSX0JJVE1BUF9TVU1NQVJJWkVELAorCUlOREVY X0FUVFJfQklUTUFQX0lOREVYRUQsCiB9IEluZGV4QXR0ckJpdG1hcEtpbmQ7CiAKIGV4dGVy biBCaXRtYXBzZXQgKlJlbGF0aW9uR2V0SW5kZXhBdHRyQml0bWFwKFJlbGF0aW9uIHJlbGF0 aW9uLAotLSAKMi41MS4yCgo= --653b79df523c467eb04fef73b97e653b Content-Disposition: attachment; filename="check-heapam.c" Content-Type: text/x-csrc; name="check-heapam.c" Content-Transfer-Encoding: base64 CiNpZiAwCglpZiAobW9kaWZpZWRfYXR0cnNfdmFsaWQpCgl7CgkJYm9vbAkJaWRfa2V5ID0g ZmFsc2U7CgkJYm9vbAkJaGRjaV9pZF9rZXlfcmVxOwoJCUJpdG1hcHNldCAgKmhkY2lfYXR0 cnMgPSBIZWFwRGV0ZXJtaW5lQ29sdW1uc0luZm8ocmVsYXRpb24sIGhvdF9hdHRycywgaWRf YXR0cnMsCgkJCQkJCQkJCQkJCQkJICAmb2xkdHVwLCBuZXd0dXAsICZpZF9rZXkpOwoKLyog CQloZGNpX2lkX2tleV9yZXEgPSBibXNfb3ZlcmxhcChtb2RpZmllZF9hdHRycywgaGRjaV9h dHRycykgfHwgaWRfa2V5OyAqLwovKiAgCQlBc3NlcnQoYm1zX2VxdWFsKG1vZGlmaWVkX2F0 dHJzLCBoZGNpX2F0dHJzKSk7ICovCi8qIAkJQXNzZXJ0KHJlcF9pZF9rZXlfcmVxdWlyZWQg PT0gaGRjaV9pZF9rZXlfcmVxKTsgKi8KCQlBc3NlcnQoaWRfa2V5ID09IGlkX2hhc19leHRl cm5hbCk7Cgl9CiNlbmRpZgoKI2lmIDAKCWlmIChtb2RpZmllZF9hdHRyc192YWxpZCkKCXsK CQlib29sCQlpZF9rZXkgPSBmYWxzZTsKCQlib29sCQloZGNpX2lkX2tleV9yZXE7CgkJQml0 bWFwc2V0ICAqaGRjaV9hdHRycyA9IEhlYXBEZXRlcm1pbmVDb2x1bW5zSW5mbyhyZWxhdGlv biwgaG90X2F0dHJzLCBpZF9hdHRycywKCQkJCQkJCQkJCQkJCQkgICZvbGR0dXAsIG5ld3R1 cCwgJmlkX2tleSk7CgoJCWhkY2lfaWRfa2V5X3JlcSA9IGJtc19vdmVybGFwKG1vZGlmaWVk X2F0dHJzLCBoZGNpX2F0dHJzKSB8fCBpZF9rZXk7CgoJCS8qIENvbXBhcmUgYml0bWFwc2V0 cyBhbmQgbG9nIGRpZmZlcmVuY2VzICovCgkJaWYgKCFibXNfZXF1YWwobW9kaWZpZWRfYXR0 cnMsIGhkY2lfYXR0cnMpKQoJCXsKCQkJQml0bWFwc2V0ICAqb25seV9pbl9tb2RpZmllZCA9 IGJtc19kaWZmZXJlbmNlKG1vZGlmaWVkX2F0dHJzLCBoZGNpX2F0dHJzKTsKCQkJQml0bWFw c2V0ICAqb25seV9pbl9oZGNpID0gYm1zX2RpZmZlcmVuY2UoaGRjaV9hdHRycywgbW9kaWZp ZWRfYXR0cnMpOwoJCQlpbnQJCQlhdHRpZHggPSAtMTsKCQkJVHVwbGVEZXNjCXR1cGRlc2Mg PSBSZWxhdGlvbkdldERlc2NyKHJlbGF0aW9uKTsKCgkJCWVsb2coV0FSTklORywgIkJpdG1h cHNldCBtaXNtYXRjaCBpbiBIZWFwRGV0ZXJtaW5lQ29sdW1uc0luZm8gZm9yIHJlbGF0aW9u ICVzIiwKCQkJCSBSZWxhdGlvbkdldFJlbGF0aW9uTmFtZShyZWxhdGlvbikpOwoJCQllbG9n KFdBUk5JTkcsICIgIEV4ZWNDaGVja0luZGV4ZWRBdHRyc0ZvckNoYW5nZXM6ICVzIiwgYm1z VG9TdHJpbmcobW9kaWZpZWRfYXR0cnMpKTsKCQkJZWxvZyhXQVJOSU5HLCAiICBIZWFwRGV0 ZXJtaW5lQ29sdW1uc0luZm86ICAgICAlcyIsIGJtc1RvU3RyaW5nKGhkY2lfYXR0cnMpKTsK CgkJCS8qIExvZyBhbmQgY29tcGFyZSBhdHRyaWJ1dGVzIG9ubHkgaW4gbW9kaWZpZWRfYXR0 cnMgKi8KCQkJYXR0aWR4ID0gLTE7CgkJCWlmIChibXNfbnVtX21lbWJlcnMob25seV9pbl9t b2RpZmllZCkgPiAwKQoJCQl7CgkJCQllbG9nKFdBUk5JTkcsICIgIEF0dHJpYnV0ZXMgcmVw b3J0ZWQgY2hhbmdlZCBieSBFeGVjQ2hlY2tJbmRleGVkQXR0cnNGb3JDaGFuZ2VzIGJ1dCBu b3QgSGVhcERldGVybWluZUNvbHVtbnNJbmZvOiIpOwoKCQkJCXdoaWxlICgoYXR0aWR4ID0g Ym1zX25leHRfbWVtYmVyKG9ubHlfaW5fbW9kaWZpZWQsIGF0dGlkeCkpID49IDApCgkJCQl7 CgkJCQkJQXR0ck51bWJlcglhdHRudW0gPSBhdHRpZHggKyBGaXJzdExvd0ludmFsaWRIZWFw QXR0cmlidXRlTnVtYmVyOwoKCQkJCQlpZiAoYXR0bnVtID4gMCAmJiBhdHRudW0gPD0gdHVw ZGVzYy0+bmF0dHMpCgkJCQkJewoJCQkJCQlGb3JtX3BnX2F0dHJpYnV0ZSBhdHQgPSBUdXBs ZURlc2NBdHRyKHR1cGRlc2MsIGF0dG51bSAtIDEpOwoJCQkJCQlEYXR1bQkJb2xkX3ZhbCwK CQkJCQkJCQkJbmV3X3ZhbDsKCQkJCQkJYm9vbAkJb2xkX2lzbnVsbCwKCQkJCQkJCQkJbmV3 X2lzbnVsbDsKCgkJCQkJCW9sZF92YWwgPSBoZWFwX2dldGF0dHIoJm9sZHR1cCwgYXR0bnVt LCB0dXBkZXNjLCAmb2xkX2lzbnVsbCk7CgkJCQkJCW5ld192YWwgPSBoZWFwX2dldGF0dHIo bmV3dHVwLCBhdHRudW0sIHR1cGRlc2MsICZuZXdfaXNudWxsKTsKCgkJCQkJCWlmIChvbGRf aXNudWxsICE9IG5ld19pc251bGwpCgkJCQkJCXsKCQkJCQkJCWVsb2coV0FSTklORywgIiAg ICAlcyAoYXR0bnVtICVkKTogTlVMTCBzdGF0dXMgZGlmZmVycyAob2xkPSVzLCBuZXc9JXMp IC0gQ09SUkVDVCBERVRFQ1RJT04iLAoJCQkJCQkJCSBOYW1lU3RyKGF0dC0+YXR0bmFtZSks IGF0dG51bSwKCQkJCQkJCQkgb2xkX2lzbnVsbCA/ICJOVUxMIiA6ICJOT1QgTlVMTCIsCgkJ CQkJCQkJIG5ld19pc251bGwgPyAiTlVMTCIgOiAiTk9UIE5VTEwiKTsKCQkJCQkJfQoJCQkJ CQllbHNlIGlmICghb2xkX2lzbnVsbCAmJiAhbmV3X2lzbnVsbCkKCQkJCQkJewoJCQkJCQkJ aWYgKCFkYXR1bV9pbWFnZV9lcShvbGRfdmFsLCBuZXdfdmFsLCBhdHQtPmF0dGJ5dmFsLCBh dHQtPmF0dGxlbikpCgkJCQkJCQl7CgkJCQkJCQkJZWxvZyhXQVJOSU5HLCAiICAgICVzIChh dHRudW0gJWQpOiBiaW5hcnkgdmFsdWVzIGRpZmZlciAtIENPUlJFQ1QgREVURUNUSU9OIiwK CQkJCQkJCQkJIE5hbWVTdHIoYXR0LT5hdHRuYW1lKSwgYXR0bnVtKTsKCQkJCQkJCX0KCQkJ CQkJCWVsc2UKCQkJCQkJCXsKCQkJCQkJCQllbG9nKFdBUk5JTkcsICIgICAgJXMgKGF0dG51 bSAlZCk6IGJpbmFyeSB2YWx1ZXMgYXJlIElERU5USUNBTCAtIEZBTFNFIFBPU0lUSVZFIChI ZWFwRGV0ZXJtaW5lQ29sdW1uc0luZm8gaXMgY29ycmVjdCkiLAoJCQkJCQkJCQkgTmFtZVN0 cihhdHQtPmF0dG5hbWUpLCBhdHRudW0pOwoJCQkJCQkJfQoJCQkJCQl9CgkJCQkJCWVsc2UK CQkJCQkJewoJCQkJCQkJZWxvZyhXQVJOSU5HLCAiICAgICVzIChhdHRudW0gJWQpOiBib3Ro IE5VTEwgLSBGQUxTRSBQT1NJVElWRSAoSGVhcERldGVybWluZUNvbHVtbnNJbmZvIGlzIGNv cnJlY3QpIiwKCQkJCQkJCQkgTmFtZVN0cihhdHQtPmF0dG5hbWUpLCBhdHRudW0pOwoJCQkJ CQl9CgkJCQkJfQoJCQkJfQoJCQl9CgoJCQkvKiBMb2cgYW5kIGNvbXBhcmUgYXR0cmlidXRl cyBvbmx5IGluIGhkY2lfYXR0cnMgKi8KCQkJYXR0aWR4ID0gLTE7CgkJCWlmIChibXNfbnVt X21lbWJlcnMob25seV9pbl9oZGNpKSA+IDApCgkJCXsKCQkJCWVsb2coV0FSTklORywgIiAg QXR0cmlidXRlcyByZXBvcnRlZCBjaGFuZ2VkIGJ5IEhlYXBEZXRlcm1pbmVDb2x1bW5zSW5m byBidXQgbm90IEV4ZWNDaGVja0luZGV4ZWRBdHRyc0ZvckNoYW5nZXM6Iik7CgoJCQkJd2hp bGUgKChhdHRpZHggPSBibXNfbmV4dF9tZW1iZXIob25seV9pbl9oZGNpLCBhdHRpZHgpKSA+ PSAwKQoJCQkJewoJCQkJCUF0dHJOdW1iZXIJYXR0bnVtID0gYXR0aWR4ICsgRmlyc3RMb3dJ bnZhbGlkSGVhcEF0dHJpYnV0ZU51bWJlcjsKCgkJCQkJaWYgKGF0dG51bSA+IDAgJiYgYXR0 bnVtIDw9IHR1cGRlc2MtPm5hdHRzKQoJCQkJCXsKCQkJCQkJRm9ybV9wZ19hdHRyaWJ1dGUg YXR0ID0gVHVwbGVEZXNjQXR0cih0dXBkZXNjLCBhdHRudW0gLSAxKTsKCQkJCQkJRGF0dW0J CW9sZF92YWwsCgkJCQkJCQkJCW5ld192YWw7CgkJCQkJCWJvb2wJCW9sZF9pc251bGwsCgkJ CQkJCQkJCW5ld19pc251bGw7CgoJCQkJCQlvbGRfdmFsID0gaGVhcF9nZXRhdHRyKCZvbGR0 dXAsIGF0dG51bSwgdHVwZGVzYywgJm9sZF9pc251bGwpOwoJCQkJCQluZXdfdmFsID0gaGVh cF9nZXRhdHRyKG5ld3R1cCwgYXR0bnVtLCB0dXBkZXNjLCAmbmV3X2lzbnVsbCk7CgoJCQkJ CQlpZiAob2xkX2lzbnVsbCAhPSBuZXdfaXNudWxsKQoJCQkJCQl7CgkJCQkJCQllbG9nKFdB Uk5JTkcsICIgICAgJXMgKGF0dG51bSAlZCk6IE5VTEwgc3RhdHVzIGRpZmZlcnMgKG9sZD0l cywgbmV3PSVzKSAtIENPUlJFQ1QgREVURUNUSU9OIiwKCQkJCQkJCQkgTmFtZVN0cihhdHQt PmF0dG5hbWUpLCBhdHRudW0sCgkJCQkJCQkJIG9sZF9pc251bGwgPyAiTlVMTCIgOiAiTk9U IE5VTEwiLAoJCQkJCQkJCSBuZXdfaXNudWxsID8gIk5VTEwiIDogIk5PVCBOVUxMIik7CgkJ CQkJCX0KCQkJCQkJZWxzZSBpZiAoIW9sZF9pc251bGwgJiYgIW5ld19pc251bGwpCgkJCQkJ CXsKCQkJCQkJCWlmICghZGF0dW1faW1hZ2VfZXEob2xkX3ZhbCwgbmV3X3ZhbCwgYXR0LT5h dHRieXZhbCwgYXR0LT5hdHRsZW4pKQoJCQkJCQkJewoJCQkJCQkJCWVsb2coV0FSTklORywg IiAgICAlcyAoYXR0bnVtICVkKTogYmluYXJ5IHZhbHVlcyBkaWZmZXIgLSBDT1JSRUNUIERF VEVDVElPTiIsCgkJCQkJCQkJCSBOYW1lU3RyKGF0dC0+YXR0bmFtZSksIGF0dG51bSk7CgkJ CQkJCQl9CgkJCQkJCQllbHNlCgkJCQkJCQl7CgkJCQkJCQkJZWxvZyhXQVJOSU5HLCAiICAg ICVzIChhdHRudW0gJWQpOiBiaW5hcnkgdmFsdWVzIGFyZSBJREVOVElDQUwgLSBGQUxTRSBO RUdBVElWRSAoRXhlY0NoZWNrSW5kZXhlZEF0dHJzRm9yQ2hhbmdlcyBpcyBjb3JyZWN0KSIs CgkJCQkJCQkJCSBOYW1lU3RyKGF0dC0+YXR0bmFtZSksIGF0dG51bSk7CgkJCQkJCQl9CgkJ CQkJCX0KCQkJCQkJZWxzZQoJCQkJCQl7CgkJCQkJCQllbG9nKFdBUk5JTkcsICIgICAgJXMg KGF0dG51bSAlZCk6IGJvdGggTlVMTCAtIEZBTFNFIE5FR0FUSVZFIChFeGVjQ2hlY2tJbmRl eGVkQXR0cnNGb3JDaGFuZ2VzIGlzIGNvcnJlY3QpIiwKCQkJCQkJCQkgTmFtZVN0cihhdHQt PmF0dG5hbWUpLCBhdHRudW0pOwoJCQkJCQl9CgkJCQkJfQoJCQkJfQoJCQl9CgoJCQlibXNf ZnJlZShvbmx5X2luX21vZGlmaWVkKTsKCQkJYm1zX2ZyZWUob25seV9pbl9oZGNpKTsKCQl9 CgoJCS8qIENvbXBhcmUgcmVwbGljYSBpZGVudGl0eSBsb2dpYyAqLwoJCWlmIChyZXBfaWRf a2V5X3JlcXVpcmVkICE9IGhkY2lfaWRfa2V5X3JlcSkKCQl7CgkJCWVsb2coV0FSTklORywg IlJlcGxpY2EgaWRlbnRpdHkgbG9naWMgbWlzbWF0Y2ggZm9yIHJlbGF0aW9uICVzIiwKCQkJ CSBSZWxhdGlvbkdldFJlbGF0aW9uTmFtZShyZWxhdGlvbikpOwoJCQllbG9nKFdBUk5JTkcs ICIgIEV4ZWNDaGVja0luZGV4ZWRBdHRyc0ZvckNoYW5nZXMgKHJlcF9pZF9rZXlfcmVxdWly ZWQpOiAlcyIsCgkJCQkgcmVwX2lkX2tleV9yZXF1aXJlZCA/ICJUUlVFIiA6ICJGQUxTRSIp OwoJCQllbG9nKFdBUk5JTkcsICIgIEhlYXBEZXRlcm1pbmVDb2x1bW5zSW5mbyAoaGRjaV9p ZF9rZXlfcmVxKTogICAgICAgICAgJXMiLAoJCQkJIGhkY2lfaWRfa2V5X3JlcSA/ICJUUlVF IiA6ICJGQUxTRSIpOwoJCX0KCX0KI2VuZGlmCgo= --653b79df523c467eb04fef73b97e653b--