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 1vriue-002dYc-0X for pgsql-hackers@arkaria.postgresql.org; Sun, 15 Feb 2026 20:40:16 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1vriua-002Auz-2X for pgsql-hackers@arkaria.postgresql.org; Sun, 15 Feb 2026 20:40:12 +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 1vriuZ-002Auq-2Q for pgsql-hackers@lists.postgresql.org; Sun, 15 Feb 2026 20:40:12 +0000 Received: from fhigh-a3-smtp.messagingengine.com ([103.168.172.154]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.98.2) (envelope-from ) id 1vriuW-00000000qKc-3GqR for pgsql-hackers@postgresql.org; Sun, 15 Feb 2026 20:40:11 +0000 Received: from phl-compute-02.internal (phl-compute-02.internal [10.202.2.42]) by mailfhigh.phl.internal (Postfix) with ESMTP id 8E62414001BB; Sun, 15 Feb 2026 15:40:06 -0500 (EST) Received: from phl-imap-14 ([10.202.2.87]) by phl-compute-02.internal (MEProxy); Sun, 15 Feb 2026 15:40:06 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=burd.me; h=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=1771188006; x=1771274406; bh=5CGnfd4bgb i+NoGsTX52MVSaLtFraYOY/xnTJswJQUg=; b=hJyFLDyp4YIWcOhe1y6YwI2rTV SAYsn48a5xrOzbQ7gcLkY1DZ0huC6Qo3BavtOq6PcoOftrWzEfQRMzkFSKS5b6qu wUiJtGKYk/keY+4dy71CPLwjbRJWR76ZEV0KWQVDiBK2VjjrOTtAIJRYTUIzkE6Y o7Cgtz3ppcCfMe7zHQ89FivULas59hLs9qHi8oK25kIaPPBe1AYmBP1QhkwuWaqA HWf1eWl+l5DyHIZnbABGolmf4UWThCSNuViTBh1cpk/evpqDv38LUbCcvD863I3x 47ielxB5D92qvY2/byjlkGphBokoqypMHUekYwFTKHx77A5yD+C3qp2KVNjA== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=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= 1771188006; x=1771274406; bh=5CGnfd4bgbi+NoGsTX52MVSaLtFraYOY/xn TJswJQUg=; b=l49EokrDb7uPNP5trAjEsAqc90Iv2MsZk7POD2RO9THGecmM+qE w5CUBgFHnivlyH9eUaODYJz1CQPnm417WXV+U45saDRv1uXXaqpShazdZZf9mb2N UTgPweXV5EcMRS/x0Xld1uZnrOVqG9HMTrG/n1gMA03x5j1N9lu8XyvbCKrb7b+L tvWLwPgMj4bENLOLDmMmDEq17wxrjO2lox8/fq1JOHpx1BHn7beLCBIaEhLfA4rG 95aV1i8MyRMqKL6M/m1cCynIWREO43nDIcROfGpCqaIeJbcJNYF5LGY/bzy58GhY U2j+AycUOcBDtMjxxTZZD+Y1Vf2YnBRJGdw== X-ME-Sender: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgeefgedrtddtgddvudegleejucetufdoteggodetrf dotffvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfurfetoffkrfgpnffqhgenuceu rghilhhouhhtmecufedttdenucenucfjughrpefoggffhffvkfgjfhfutgesmhdtreerre dtjeenucfhrhhomhepfdfirhgvghcuuehurhgufdcuoehgrhgvghessghurhgurdhmvgeq necuggftrfgrthhtvghrnhepffevudelffevuefffffgudegieefkeevlefhtdegffefff dttdeguedvgeefjeefnecuvehluhhsthgvrhfuihiivgeptdenucfrrghrrghmpehmrghi lhhfrhhomhepghhrvghgsegsuhhrugdrmhgvpdhnsggprhgtphhtthhopedvpdhmohguvg epshhmthhpohhuthdprhgtphhtthhopehpghhsqhhlsehjqdgurghvihhsrdgtohhmpdhr tghpthhtohepphhgshhqlhdqhhgrtghkvghrshesphhoshhtghhrvghsqhhlrdhorhhg X-ME-Proxy: Feedback-ID: i675e48f3:Fastmail Received: by mailuser.phl.internal (Postfix, from userid 501) id 7110AC4006E; Sun, 15 Feb 2026 15:40:04 -0500 (EST) X-Mailer: MessagingEngine.com Webmail Interface MIME-Version: 1.0 X-ThreadId: A1gxZgRQNkgk Date: Sun, 15 Feb 2026 15:39:42 -0500 From: "Greg Burd" To: "Jeff Davis" , pgsql-hackers Message-Id: In-Reply-To: <3e1b9075c92808a7356e79087ba51910e5db5a30.camel@j-davis.com> 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=a067f11d97b94211b4d5ca22476a83fd List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --a067f11d97b94211b4d5ca22476a83fd Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable On Sat, Feb 14, 2026, at 2:39 PM, Jeff Davis wrote: > On Fri, 2026-02-13 at 16:06 -0500, Greg Burd wrote: >> Here's my thinking, this patch set can be thought of as: >>=20 >> a) moving HeapDetermineColumnsInfo() into the executor Hey Jeff, thanks for taking a look at this! :) > This feels like the core of the series: moving the logic into the > executor make it possible to be smarter about whether HOT can be > applied or not. Yes, but put a different way this change moves what is not heap-specific= outside the heap and leaves heap-isms inside heap. > I think that is a good direction to go. I don't think HOT is > fundamentally a heap concept because other AMs may do something similar > and would want similar information. The ability for a table AM to skip writing new index entries for a subse= t of updates is the non-heap-specific feature I'm making more general in= this patch. Heap calls this "HOT" (heap-only tuple) but while the name= is a heap-ism, the concept isn't. Other table AM implementations might= have different behavior as they might implement MVCC differently, have = UNDO logs, or even be Index-oriented tables (IoT). What's baked into th= e code today is very tightly aligned with how heap works. The first thi= ng I'd like to adjust is the identification of the "modified indexed att= ributes" on update. The second will be the TU_UpdateIndexes enum. > There are two parts to the decision > of whether to use HOT: first, is there a logical change to the indexed > value; and second, does the AM need to=C2=A0break the change for some = other > reason (e.g. the current page is full). I view this as, "agreeing on which indexes require index writes during a= n update" and I think there are three parts of the system that work toge= ther to determine this: 1. indexes 2. types 3. tables (1) Indexes influence this decision when they are summarizing. Otherwis= e it is assumed they only need updates when the table AM signals TU_All.= I think indexes need more influence over this, but that's for a later = commit. (2) Types don't influence this decision today. Their equality operators= are not used, attributes are memcmp(). This is a requirement for index= -only scans. 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. (3) Tables, really only heap today, own this decision in our code as it = stands now. The heap informs the executor: TU_All, TU_None, TU_Summariz= ing (all, none, some). The choice between these three outcomes is the "= HOT decision" in the heap_update() code. All indexes are updated when a= ny indexed attribute is modified. No indexes are updated when there are= no modifications to indexed attributes. If only attributes referenced = by summarizing indexes were modified then all summarizing indexes are up= dated (even those without modified attributes). Of course if the newly = updated tuple (even after being compressed/TOASTed) won't fit on the sam= e page as the old one then the result is TU_All. This is where HEAD's l= ogic is today. Future AMs, or even heap, might be able to: - chain updates across pages - serve as the primary key index as well as tuple storage (IoT) Indexes might be able to: - identify that they only index portions of the key datum provided - ask types if that portion of the data changed or not Types might be able to: - record how they've been indexed on a relation=20 - record during mutation on update if the changes intersect with what's = provided to indexes But none of that is in this patch now. The only change that might be us= eful is to avoid updating unmodified summarized indexes on a HOT/summari= zed update. That's a simple addition on top of this patch, but not in t= he attached patch. > It seems reasonable to me that the executor is the right place for the > first check, because it can be more precise. The motivating example > here is a JSON document where one field is indexed and unrelated fields > are being updated, in which case we can still do a HOT update because > the indexed value isn't actually changing. Yes, JSON is a good example of how a type plays a role in deciding which= indexes need updates. That's where this thread started, expression ind= exes on JSONB that are unchanged during update should allow HOT updates = when unchanged (IMO). > As far as the patch itself, it seems like you're moving a lot of code > out of heap_update() and into simple_heap_update() & > heapam_tuple_update(). Can you explain why that's needed? Perhaps I > just need to look closer. I can see how this might be confusing, you're asking a good question. W= hy not just add the mix_attrs as an argument to the table AM update call= and be done? 1. Bitmapsets that are NULL mean empty, so how would simple_heap_update(= ) signal to heap_update() that it needs to determine the modified indexe= d attributes? We'd have to add a bool along with the mix_attrs Bitmapse= t to indicate: "we've not calculated the set yet, you need to do that." 2. After fetching the exclusive buffer lock there is the test `!ItemIdIs= Normal(lp)` to cover the case where a simple_heap_update() the otid orig= in is the syscache, there is no pin or snapshot, and so there might be L= P_* states other than LP_NORMAL due to concurrent pruning. This only ha= ppens when updating catalog tuples, so this logic need not be present at= all in the heapam_tuple_update(). Yes, the if() branch will be fast (f= requently predicted by the CPU) but this feels like logic specific to th= e update of catalog tuples. 3. HeapDetermineColumnsInfo() actually does more than find the modified = indexed attributes, it also performs half of the check for the requireme= nt to WAL log the replica identity attributes. The replacement function= in the executor doesn't do this work, so that is coded into heapam_tupl= e_update() but not simple_heap_update(). The second half is in ExtractR= eplicaIdentity() that happens later in the heap_update() function after = determining if HOT is a possibility or not. I have moved these changes back into heap_update(), add the mix_attrs an= d mix_attrs_valid to see how things look, that's the attached patch. >> b) all that HOT nonsense >>=20 >> I feel that (a) has value even without (b), that removing a chunk of >> work from within an exclusive buffer lock to outside that lock is a >> Good Thing(TM) and could in this case result in more concurrency. > > Right. It would be nice to see some numbers here, but moving work > outside of the buffer lock seems like a good idea. No numbers yet. >> To that end, present to you a single patch that *only* does (a), it >> moves the logic of HeapDeterminColumnsInfo() into the executor and >> doesn't change anything else.=C2=A0 Meaning that what goes HOT today >> (without this patch), should continue to be HOT tomorrow (with this >> patch) and nothing else. > > Why are there test diffs? Removed test differences. > Also, does this move us (slightly) closer to PHOT? I'd argue that it does move the code closer to something WARM/PHOT-like = meaning an ability to only update a subset of indexes on update; a chang= e from "all/none/some" to "the required subset, and no more." That's a = ways off. > Regards, > Jeff Davis thanks again for looking Jeff, -greg --a067f11d97b94211b4d5ca22476a83fd Content-Disposition: attachment; filename*0="v20260215-0001-Idenfity-modified-indexed-attributes-in-th.pat"; filename*1="ch" Content-Type: text/x-patch; name="=?UTF-8?Q?v20260215-0001-Idenfity-modified-indexed-attributes-in-th.patc?= =?UTF-8?Q?h?=" Content-Transfer-Encoding: base64 RnJvbSAwODZhNzNjZGQ5ZGQyZGFkMzU5ZmIyODNmOWVkOTkyNzM5ZjhiNjY2IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBHcmVnIEJ1cmQgPGdyZWdAYnVyZC5tZT4KRGF0ZTog U3VuLCAyIE5vdiAyMDI1IDExOjM2OjIwIC0wNTAwClN1YmplY3Q6IFtQQVRDSCB2MjAyNjAy MTVdIElkZW5maXR5IG1vZGlmaWVkIGluZGV4ZWQgYXR0cmlidXRlcyBpbiB0aGUKIGV4ZWN1 dG9yIG9uIFVQREFURQoKUmVmYWN0b3IgZXhlY3V0b3IgdXBkYXRlIGxvZ2ljIHRvIGRldGVy bWluZSB3aGljaCBpbmRleGVkIGNvbHVtbnMgaGF2ZQphY3R1YWxseSBjaGFuZ2VkIGR1cmlu ZyBhbiBVUERBVEUgb3BlcmF0aW9uIHJhdGhlciB0aGFuIGxlYXZpbmcgdGhpcyB1cAp0byBI ZWFwRGV0ZXJtaW5lQ29sdW1uc0luZm8oKSBpbiBoZWFwX3VwZGF0ZSgpLgoKRXhlY1doaWNo SW5kZXhlc1JlcXVpcmVVcGRhdGVzKCkgcmVwbGFjZXMgSGVhcERldGVybWluZXNDb2x1bW5z SW5mbygpCmFuZCBpcyBjYWxsZWQgYmVmb3JlIHRhYmxlX3R1cGxlX3VwZGF0ZSgpIGNydWNp YWxseSB3aXRob3V0IHRoZSBuZWVkCmZvciBhbiBleGNsdXNpdmUgYnVmZmVyIGxvY2sgb24g dGhlIHBhZ2UgdGhhdCBob2xkcyB0aGUgdHVwbGUgYmVpbmcKdXBkYXRlZC4gIFRoaXMgcmVk dWNlcyB0aGUgdGltZSB0aGUgbG9jayBpcyBoZWxkIGxhdGVyIHdpdGhpbgpoZWFwYW1fdHVw bGVfdXBkYXRlKCkgYW5kIGhlYXBfdXBkYXRlKCkuCgpCZXNpZGVzIGlkZW50aWZ5aW5nIHRo ZSBzZXQgb2YgbW9kaWZpZWQgaW5kZXhlZCBhdHRyaWJ1dGVzCkhlYXBEZXRlcm1pbmVDb2x1 bW5zSW5mbygpIHdhcyBhbHNvIHJlc3BvbnNpYmxlIGZvciBwYXJ0IG9mIHRoZSBsb2dpYwpp bnZvbGVkIGluIHRoZSBkZWNpc2lvbiB0byBpbmNsdWRlIHRoZSByZXBsaWNhIGlkZW50aXR5 IGtleSBvciBub3QuClRoaXMgbm93IGhhcHBlbnMgaW4gaGVhcF91cGRhdGUoKSB3aGVuIG1v ZGlmaWVkX2F0dHJzX3ZhbGlkIGlzIGZhbHNlLgoKQ2F0YWxvZyB0dXBsZSB1cGRhdGVzIHVz ZSBzaW1wbGVfaGVhcF91cGRhdGUoKSBhbmQgZG9uJ3QgcGFzcyBpbiBhCm1vZGlmaWVkX2F0 dHJzIEJpdG1hcHNldCBpbmRpY2F0ZWQgYnkgdGhlIG1vZGlmaWVkX2F0dHJzX3ZhbGlkIGJv b2wKc2V0IHRvIGZhbHNlLgoKVXBkYXRlcyBzdGVtbWluZyBmcm9tIGxvZ2ljYWwgcmVwbGlj YXRpb24gbm93IGF2b2lkIGNhbGxpbmcKSGVhcERldGVybWluZUNvbHVtbnNJbmZvKCkgYXMg d2VsbC4gVGhlIG1vZGlmaWVkIGluZGV4ZWQgYXR0cmlidXRlcyBmb3IKdGhlc2UgdXBkYXRl cyBhcmUgbm93IHNpbXBseSB0aGUgaW50ZXJzZWN0aW9uIG9mIHRoZSBhdHRyYnV0ZXMgcmV0 dXJuZWQKZnJvbSBzbG90X21vZGlmeV9kYXRhKCkgd2l0aCB0aGUgc2V0IG9mIGluZGV4ZWQg YXR0cmlidXRlcyBvbiBhCnJlbGF0aW9uIHBhc3NlZCBvbiB0byB0aGUgdGFibGUgQU0gdXBk YXRlIHZpYSByaV9DaGFuZ2VkSW5kZXhlZENvbHMgYW5kCmludG8gRXhlY1NpbXBsZVJlbGF0 aW9uVXBkYXRlKCkgd2hpY2ggY2FsbHMgc2ltcGxlX3RhYmxlX3R1cGxlX3VwZGF0ZSgpCmFu ZCB0aGVuIHRhYmxlX3R1cGxlX3VwZGF0ZSgpIHdpdGggdGhhdCBhcyB0aGUgbW9kaWZpZWQg aW5kZXhlZAphdHRyaWJ1dGVzIEJpdG1hcHNldC4KLS0tCiBzcmMvYmFja2VuZC9hY2Nlc3Mv aGVhcC9oZWFwYW0uYyAgICAgICAgIHwgIDc1ICsrKysrKysrLS0KIHNyYy9iYWNrZW5kL2Fj Y2Vzcy9oZWFwL2hlYXBhbV9oYW5kbGVyLmMgfCAgIDcgKy0KIHNyYy9iYWNrZW5kL2FjY2Vz cy90YWJsZS90YWJsZWFtLmMgICAgICAgfCAgIDUgKy0KIHNyYy9iYWNrZW5kL2V4ZWN1dG9y L2V4ZWNNYWluLmMgICAgICAgICAgfCAgIDEgKwogc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhl Y1JlcGxpY2F0aW9uLmMgICB8ICAgNyArCiBzcmMvYmFja2VuZC9leGVjdXRvci9ub2RlTW9k aWZ5VGFibGUuYyAgIHwgMTY5ICsrKysrKysrKysrKysrKysrKysrKy0tCiBzcmMvYmFja2Vu ZC9yZXBsaWNhdGlvbi9sb2dpY2FsL3dvcmtlci5jIHwgIDY5ICsrKysrKysrLQogc3JjL2Jh Y2tlbmQvdXRpbHMvY2FjaGUvcmVsY2FjaGUuYyAgICAgICB8ICAxNSArKwogc3JjL2luY2x1 ZGUvYWNjZXNzL2hlYXBhbS5oICAgICAgICAgICAgICB8ICAgMSArCiBzcmMvaW5jbHVkZS9h Y2Nlc3MvdGFibGVhbS5oICAgICAgICAgICAgIHwgICA4ICstCiBzcmMvaW5jbHVkZS9jYXRh bG9nL2luZGV4LmggICAgICAgICAgICAgIHwgICAxICsKIHNyYy9pbmNsdWRlL2V4ZWN1dG9y L2V4ZWN1dG9yLmggICAgICAgICAgfCAgIDMgKwogc3JjL2luY2x1ZGUvbm9kZXMvZXhlY25v ZGVzLmggICAgICAgICAgICB8ICAgNiArCiBzcmMvaW5jbHVkZS91dGlscy9yZWwuaCAgICAg ICAgICAgICAgICAgIHwgICAxICsKIHNyYy9pbmNsdWRlL3V0aWxzL3JlbGNhY2hlLmggICAg ICAgICAgICAgfCAgIDEgKwogMTUgZmlsZXMgY2hhbmdlZCwgMzM5IGluc2VydGlvbnMoKyks IDMwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFw L2hlYXBhbS5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFtLmMKaW5kZXggOThk NTNjYWVlYTguLmQ3OGU4YWU5MTUwIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3Mv aGVhcC9oZWFwYW0uYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW0uYwpA QCAtMzMxMSw2ICszMzExLDcgQEAgVE1fUmVzdWx0CiBoZWFwX3VwZGF0ZShSZWxhdGlvbiBy ZWxhdGlvbiwgY29uc3QgSXRlbVBvaW50ZXJEYXRhICpvdGlkLCBIZWFwVHVwbGUgbmV3dHVw LAogCQkJQ29tbWFuZElkIGNpZCwgU25hcHNob3QgY3Jvc3NjaGVjaywgYm9vbCB3YWl0LAog CQkJVE1fRmFpbHVyZURhdGEgKnRtZmQsIExvY2tUdXBsZU1vZGUgKmxvY2ttb2RlLAorCQkJ Y29uc3QgQml0bWFwc2V0ICptb2RpZmllZF9hdHRycywgYm9vbCBtb2RpZmllZF9hdHRyc192 YWxpZCwKIAkJCVRVX1VwZGF0ZUluZGV4ZXMgKnVwZGF0ZV9pbmRleGVzKQogewogCVRNX1Jl c3VsdAlyZXN1bHQ7CkBAIC0zMzIwLDcgKzMzMjEsNiBAQCBoZWFwX3VwZGF0ZShSZWxhdGlv biByZWxhdGlvbiwgY29uc3QgSXRlbVBvaW50ZXJEYXRhICpvdGlkLCBIZWFwVHVwbGUgbmV3 dHVwLAogCUJpdG1hcHNldCAgKmtleV9hdHRyczsKIAlCaXRtYXBzZXQgICppZF9hdHRyczsK IAlCaXRtYXBzZXQgICppbnRlcmVzdGluZ19hdHRyczsKLQlCaXRtYXBzZXQgICptb2RpZmll ZF9hdHRyczsKIAlJdGVtSWQJCWxwOwogCUhlYXBUdXBsZURhdGEgb2xkdHVwOwogCUhlYXBU dXBsZQloZWFwdHVwOwpAQCAtMzM0Niw2ICszMzQ2LDcgQEAgaGVhcF91cGRhdGUoUmVsYXRp b24gcmVsYXRpb24sIGNvbnN0IEl0ZW1Qb2ludGVyRGF0YSAqb3RpZCwgSGVhcFR1cGxlIG5l d3R1cCwKIAlib29sCQljaGVja2VkX2xvY2tlcnM7CiAJYm9vbAkJbG9ja2VyX3JlbWFpbnM7 CiAJYm9vbAkJaWRfaGFzX2V4dGVybmFsID0gZmFsc2U7CisJYm9vbAkJcmVwX2lkX2tleV9y ZXF1aXJlZCA9IGZhbHNlOwogCVRyYW5zYWN0aW9uSWQgeG1heF9uZXdfdHVwbGUsCiAJCQkJ eG1heF9vbGRfdHVwbGU7CiAJdWludDE2CQlpbmZvbWFza19vbGRfdHVwbGUsCkBAIC0zNDg3 LDkgKzM0ODgsNjUgQEAgaGVhcF91cGRhdGUoUmVsYXRpb24gcmVsYXRpb24sIGNvbnN0IEl0 ZW1Qb2ludGVyRGF0YSAqb3RpZCwgSGVhcFR1cGxlIG5ld3R1cCwKIAkgKiBuZXcgdHVwbGUg c28gd2UgbXVzdCBpbmNsdWRlIGl0IGFzIHBhcnQgb2YgdGhlIG9sZF9rZXlfdHVwbGUuICBT ZWUKIAkgKiBFeHRyYWN0UmVwbGljYUlkZW50aXR5LgogCSAqLwotCW1vZGlmaWVkX2F0dHJz ID0gSGVhcERldGVybWluZUNvbHVtbnNJbmZvKHJlbGF0aW9uLCBpbnRlcmVzdGluZ19hdHRy cywKLQkJCQkJCQkJCQkJICBpZF9hdHRycywgJm9sZHR1cCwKLQkJCQkJCQkJCQkJICBuZXd0 dXAsICZpZF9oYXNfZXh0ZXJuYWwpOworCWlmICghbW9kaWZpZWRfYXR0cnNfdmFsaWQpCisJ eworCQltb2RpZmllZF9hdHRycyA9IEhlYXBEZXRlcm1pbmVDb2x1bW5zSW5mbyhyZWxhdGlv biwgaW50ZXJlc3RpbmdfYXR0cnMsCisJCQkJCQkJCQkJCQkgIGlkX2F0dHJzLCAmb2xkdHVw LAorCQkJCQkJCQkJCQkJICBuZXd0dXAsICZpZF9oYXNfZXh0ZXJuYWwpOworCQlyZXBfaWRf a2V5X3JlcXVpcmVkID0gYm1zX292ZXJsYXAobW9kaWZpZWRfYXR0cnMsIGlkX2F0dHJzKSB8 fAorCQkJaWRfaGFzX2V4dGVybmFsOworCX0KKwllbHNlCisJeworCQlyZXBfaWRfa2V5X3Jl cXVpcmVkID0gYm1zX292ZXJsYXAobW9kaWZpZWRfYXR0cnMsIGlkX2F0dHJzKTsKKwkJaWYg KCFyZXBfaWRfa2V5X3JlcXVpcmVkKQorCQl7CisJCQlCaXRtYXBzZXQgICphdHRyczsKKwkJ CVR1cGxlRGVzYwl0dXBkZXNjID0gUmVsYXRpb25HZXREZXNjcihyZWxhdGlvbik7CisJCQlp bnQJCQlhdHRpZHggPSAtMTsKKworCQkJLyoKKwkJCSAqIFdlIGRvbid0IG93biBpZHhfYXR0 cnMgc28gd2UnbGwgY29weSBpdCBhbmQgcmVtb3ZlIHRoZSBtb2RpZmllZAorCQkJICogc2V0 IHRvIHJlZHVjZSB0aGUgYXR0cmlidXRlcyB3ZSBuZWVkIHRvIHRlc3QgaW4gdGhlIHdoaWxl IGxvb3AKKwkJCSAqIGFuZCBhdm9pZCBhIHR3byBicmFuY2hlcyBpbiB0aGUgbG9vcC4KKwkJ CSAqLworCQkJYXR0cnMgPSBibXNfZGlmZmVyZW5jZShpbnRlcmVzdGluZ19hdHRycywgbW9k aWZpZWRfYXR0cnMpOworCQkJYXR0cnMgPSBibXNfaW50X21lbWJlcnMoYXR0cnMsIGlkX2F0 dHJzKTsKKworCQkJd2hpbGUgKChhdHRpZHggPSBibXNfbmV4dF9tZW1iZXIoYXR0cnMsIGF0 dGlkeCkpID49IDApCisJCQl7CisJCQkJLyoKKwkJCQkgKiBhdHRpZHggaXMgemVyby1iYXNl ZCwgYXR0cm51bSBpcyB0aGUgbm9ybWFsIGF0dHJpYnV0ZQorCQkJCSAqIG51bWJlcgorCQkJ CSAqLworCQkJCUF0dHJOdW1iZXIJYXR0cm51bSA9IGF0dGlkeCArIEZpcnN0TG93SW52YWxp ZEhlYXBBdHRyaWJ1dGVOdW1iZXI7CisJCQkJRGF0dW0JCXZhbHVlOworCQkJCWJvb2wJCWlz bnVsbDsKKworCQkJCS8qCisJCQkJICogU3lzdGVtIGF0dHJpYnV0ZXMgYXJlIG5vdCBhZGRl ZCBpbnRvIGludGVyZXN0aW5nX2F0dHJzIGluCisJCQkJICogcmVsY2FjaGUKKwkJCQkgKi8K KwkJCQlBc3NlcnQoYXR0cm51bSA+IDApOworCisJCQkJdmFsdWUgPSBoZWFwX2dldGF0dHIo Jm9sZHR1cCwgYXR0cm51bSwgdHVwZGVzYywgJmlzbnVsbCk7CisKKwkJCQkvKiBObyBuZWVk IHRvIGNoZWNrIGF0dHJpYnV0ZXMgdGhhdCBjYW4ndCBiZSBzdG9yZWQgZXh0ZXJuYWxseSAq LworCQkJCWlmIChpc251bGwgfHwKKwkJCQkJVHVwbGVEZXNjQ29tcGFjdEF0dHIodHVwZGVz YywgYXR0cm51bSAtIDEpLT5hdHRsZW4gIT0gLTEpCisJCQkJCWNvbnRpbnVlOworCisJCQkJ LyogQ2hlY2sgaWYgdGhlIG9sZCB0dXBsZSdzIGF0dHJpYnV0ZSBpcyBzdG9yZWQgZXh0ZXJu YWxseSAqLworCQkJCWlmIChWQVJBVFRfSVNfRVhURVJOQUwoKHN0cnVjdCB2YXJsZW5hICop IERhdHVtR2V0UG9pbnRlcih2YWx1ZSkpKQorCQkJCXsKKwkJCQkJcmVwX2lkX2tleV9yZXF1 aXJlZCA9IHRydWU7CisJCQkJCWJyZWFrOworCQkJCX0KKwkJCX0KKworCQkJYm1zX2ZyZWUo YXR0cnMpOworCQl9CisJfQogCiAJLyoKIAkgKiBJZiB3ZSdyZSBub3QgdXBkYXRpbmcgYW55 ICJrZXkiIGNvbHVtbiwgd2UgY2FuIGdyYWIgYSB3ZWFrZXIgbG9jayB0eXBlLgpAQCAtMzc2 Myw3ICszODIwLDcgQEAgbDI6CiAJCWJtc19mcmVlKHN1bV9hdHRycyk7CiAJCWJtc19mcmVl KGtleV9hdHRycyk7CiAJCWJtc19mcmVlKGlkX2F0dHJzKTsKLQkJYm1zX2ZyZWUobW9kaWZp ZWRfYXR0cnMpOworCQkvKiBtb2RpZmllZCBhdHRycyBpcyBwYXNzZWQgaW4gYW5kIGZyZWUn ZCBieSB0aGUgY2FsbGVyLCBvciBOVUxMICovCiAJCWJtc19mcmVlKGludGVyZXN0aW5nX2F0 dHJzKTsKIAkJcmV0dXJuIHJlc3VsdDsKIAl9CkBAIC00MTExLDggKzQxNjgsNyBAQCBsMjoK IAkgKiBjb2x1bW5zIGFyZSBtb2RpZmllZCBvciBpdCBoYXMgZXh0ZXJuYWwgZGF0YS4KIAkg Ki8KIAlvbGRfa2V5X3R1cGxlID0gRXh0cmFjdFJlcGxpY2FJZGVudGl0eShyZWxhdGlvbiwg Jm9sZHR1cCwKLQkJCQkJCQkJCQkgICBibXNfb3ZlcmxhcChtb2RpZmllZF9hdHRycywgaWRf YXR0cnMpIHx8Ci0JCQkJCQkJCQkJICAgaWRfaGFzX2V4dGVybmFsLAorCQkJCQkJCQkJCSAg IHJlcF9pZF9rZXlfcmVxdWlyZWQsCiAJCQkJCQkJCQkJICAgJm9sZF9rZXlfY29waWVkKTsK IAogCS8qIE5PIEVSRVBPUlQoRVJST1IpIGZyb20gaGVyZSB0aWxsIGNoYW5nZXMgYXJlIGxv Z2dlZCAqLwpAQCAtNDI3OCw3ICs0MzM0LDcgQEAgbDI6CiAJYm1zX2ZyZWUoc3VtX2F0dHJz KTsKIAlibXNfZnJlZShrZXlfYXR0cnMpOwogCWJtc19mcmVlKGlkX2F0dHJzKTsKLQlibXNf ZnJlZShtb2RpZmllZF9hdHRycyk7CisJLyogbW9kaWZpZWQgYXR0cnMgaXMgcGFzc2VkIGlu IGFuZCBmcmVlJ2QgYnkgdGhlIGNhbGxlciwgb3IgTlVMTCAqLwogCWJtc19mcmVlKGludGVy ZXN0aW5nX2F0dHJzKTsKIAogCXJldHVybiBUTV9PazsKQEAgLTQ1NjIsNyArNDYxOCw4IEBA IHNpbXBsZV9oZWFwX3VwZGF0ZShSZWxhdGlvbiByZWxhdGlvbiwgY29uc3QgSXRlbVBvaW50 ZXJEYXRhICpvdGlkLCBIZWFwVHVwbGUgdHVwCiAJcmVzdWx0ID0gaGVhcF91cGRhdGUocmVs YXRpb24sIG90aWQsIHR1cCwKIAkJCQkJCSBHZXRDdXJyZW50Q29tbWFuZElkKHRydWUpLCBJ bnZhbGlkU25hcHNob3QsCiAJCQkJCQkgdHJ1ZSAvKiB3YWl0IGZvciBjb21taXQgKi8gLAot CQkJCQkJICZ0bWZkLCAmbG9ja21vZGUsIHVwZGF0ZV9pbmRleGVzKTsKKwkJCQkJCSAmdG1m ZCwgJmxvY2ttb2RlLAorCQkJCQkJIE5VTEwsIGZhbHNlLCB1cGRhdGVfaW5kZXhlcyk7CiAJ c3dpdGNoIChyZXN1bHQpCiAJewogCQljYXNlIFRNX1NlbGZNb2RpZmllZDoKZGlmZiAtLWdp dCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL2hlYXBhbV9oYW5kbGVyLmMgYi9zcmMvYmFj a2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW1faGFuZGxlci5jCmluZGV4IGNiZWY3M2U1ZDRiLi4y ZDc0ZmE5MGM3ZiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFt X2hhbmRsZXIuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW1faGFuZGxl ci5jCkBAIC0zMTIsMTIgKzMxMiwxMSBAQCBoZWFwYW1fdHVwbGVfZGVsZXRlKFJlbGF0aW9u IHJlbGF0aW9uLCBJdGVtUG9pbnRlciB0aWQsIENvbW1hbmRJZCBjaWQsCiAJcmV0dXJuIGhl YXBfZGVsZXRlKHJlbGF0aW9uLCB0aWQsIGNpZCwgY3Jvc3NjaGVjaywgd2FpdCwgdG1mZCwg Y2hhbmdpbmdQYXJ0KTsKIH0KIAotCiBzdGF0aWMgVE1fUmVzdWx0CiBoZWFwYW1fdHVwbGVf dXBkYXRlKFJlbGF0aW9uIHJlbGF0aW9uLCBJdGVtUG9pbnRlciBvdGlkLCBUdXBsZVRhYmxl U2xvdCAqc2xvdCwKIAkJCQkJQ29tbWFuZElkIGNpZCwgU25hcHNob3Qgc25hcHNob3QsIFNu YXBzaG90IGNyb3NzY2hlY2ssCi0JCQkJCWJvb2wgd2FpdCwgVE1fRmFpbHVyZURhdGEgKnRt ZmQsCi0JCQkJCUxvY2tUdXBsZU1vZGUgKmxvY2ttb2RlLCBUVV9VcGRhdGVJbmRleGVzICp1 cGRhdGVfaW5kZXhlcykKKwkJCQkJYm9vbCB3YWl0LCBUTV9GYWlsdXJlRGF0YSAqdG1mZCwg TG9ja1R1cGxlTW9kZSAqbG9ja21vZGUsCisJCQkJCWNvbnN0IEJpdG1hcHNldCAqbW9kaWZp ZWRfYXR0cnMsIFRVX1VwZGF0ZUluZGV4ZXMgKnVwZGF0ZV9pbmRleGVzKQogewogCWJvb2wJ CXNob3VsZEZyZWUgPSB0cnVlOwogCUhlYXBUdXBsZQl0dXBsZSA9IEV4ZWNGZXRjaFNsb3RI ZWFwVHVwbGUoc2xvdCwgdHJ1ZSwgJnNob3VsZEZyZWUpOwpAQCAtMzI4LDcgKzMyNyw3IEBA IGhlYXBhbV90dXBsZV91cGRhdGUoUmVsYXRpb24gcmVsYXRpb24sIEl0ZW1Qb2ludGVyIG90 aWQsIFR1cGxlVGFibGVTbG90ICpzbG90LAogCXR1cGxlLT50X3RhYmxlT2lkID0gc2xvdC0+ dHRzX3RhYmxlT2lkOwogCiAJcmVzdWx0ID0gaGVhcF91cGRhdGUocmVsYXRpb24sIG90aWQs IHR1cGxlLCBjaWQsIGNyb3NzY2hlY2ssIHdhaXQsCi0JCQkJCQkgdG1mZCwgbG9ja21vZGUs IHVwZGF0ZV9pbmRleGVzKTsKKwkJCQkJCSB0bWZkLCBsb2NrbW9kZSwgbW9kaWZpZWRfYXR0 cnMsIHRydWUsIHVwZGF0ZV9pbmRleGVzKTsKIAlJdGVtUG9pbnRlckNvcHkoJnR1cGxlLT50 X3NlbGYsICZzbG90LT50dHNfdGlkKTsKIAogCS8qCmRpZmYgLS1naXQgYS9zcmMvYmFja2Vu ZC9hY2Nlc3MvdGFibGUvdGFibGVhbS5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL3RhYmxlL3Rh YmxlYW0uYwppbmRleCBkZmRhMWFmNDEyZS4uNDJhY2Q1YjE3YTkgMTAwNjQ0Ci0tLSBhL3Ny Yy9iYWNrZW5kL2FjY2Vzcy90YWJsZS90YWJsZWFtLmMKKysrIGIvc3JjL2JhY2tlbmQvYWNj ZXNzL3RhYmxlL3RhYmxlYW0uYwpAQCAtMzU5LDYgKzM1OSw3IEBAIHZvaWQKIHNpbXBsZV90 YWJsZV90dXBsZV91cGRhdGUoUmVsYXRpb24gcmVsLCBJdGVtUG9pbnRlciBvdGlkLAogCQkJ CQkJICBUdXBsZVRhYmxlU2xvdCAqc2xvdCwKIAkJCQkJCSAgU25hcHNob3Qgc25hcHNob3Qs CisJCQkJCQkgIGNvbnN0IEJpdG1hcHNldCAqbWl4X2F0dHJzLAogCQkJCQkJICBUVV9VcGRh dGVJbmRleGVzICp1cGRhdGVfaW5kZXhlcykKIHsKIAlUTV9SZXN1bHQJcmVzdWx0OwpAQCAt MzY5LDcgKzM3MCw5IEBAIHNpbXBsZV90YWJsZV90dXBsZV91cGRhdGUoUmVsYXRpb24gcmVs LCBJdGVtUG9pbnRlciBvdGlkLAogCQkJCQkJCQlHZXRDdXJyZW50Q29tbWFuZElkKHRydWUp LAogCQkJCQkJCQlzbmFwc2hvdCwgSW52YWxpZFNuYXBzaG90LAogCQkJCQkJCQl0cnVlIC8q IHdhaXQgZm9yIGNvbW1pdCAqLyAsCi0JCQkJCQkJCSZ0bWZkLCAmbG9ja21vZGUsIHVwZGF0 ZV9pbmRleGVzKTsKKwkJCQkJCQkJJnRtZmQsICZsb2NrbW9kZSwKKwkJCQkJCQkJbWl4X2F0 dHJzLAorCQkJCQkJCQl1cGRhdGVfaW5kZXhlcyk7CiAKIAlzd2l0Y2ggKHJlc3VsdCkKIAl7 CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjTWFpbi5jIGIvc3JjL2Jh Y2tlbmQvZXhlY3V0b3IvZXhlY01haW4uYwppbmRleCBiZmQzZWJjNjAxZS4uY2Q3YWU0YWVl YzIgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNNYWluLmMKKysrIGIv c3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY01haW4uYwpAQCAtMTI4Niw2ICsxMjg2LDcgQEAg SW5pdFJlc3VsdFJlbEluZm8oUmVzdWx0UmVsSW5mbyAqcmVzdWx0UmVsSW5mbywKIAkvKiBU aGUgZm9sbG93aW5nIGZpZWxkcyBhcmUgc2V0IGxhdGVyIGlmIG5lZWRlZCAqLwogCXJlc3Vs dFJlbEluZm8tPnJpX1Jvd0lkQXR0Tm8gPSAwOwogCXJlc3VsdFJlbEluZm8tPnJpX2V4dHJh VXBkYXRlZENvbHMgPSBOVUxMOworCXJlc3VsdFJlbEluZm8tPnJpX0NoYW5nZWRJbmRleGVk Q29scyA9IE5VTEw7CiAJcmVzdWx0UmVsSW5mby0+cmlfcHJvamVjdE5ldyA9IE5VTEw7CiAJ cmVzdWx0UmVsSW5mby0+cmlfbmV3VHVwbGVTbG90ID0gTlVMTDsKIAlyZXN1bHRSZWxJbmZv LT5yaV9vbGRUdXBsZVNsb3QgPSBOVUxMOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhl Y3V0b3IvZXhlY1JlcGxpY2F0aW9uLmMgYi9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjUmVw bGljYXRpb24uYwppbmRleCA3NDNiMWVlMmIyOC4uNzA0MGE2OWMyNzUgMTAwNjQ0Ci0tLSBh L3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNSZXBsaWNhdGlvbi5jCisrKyBiL3NyYy9iYWNr ZW5kL2V4ZWN1dG9yL2V4ZWNSZXBsaWNhdGlvbi5jCkBAIC0zMyw2ICszMyw3IEBACiAjaW5j bHVkZSAidXRpbHMvYnVpbHRpbnMuaCIKICNpbmNsdWRlICJ1dGlscy9sc3lzY2FjaGUuaCIK ICNpbmNsdWRlICJ1dGlscy9yZWwuaCIKKyNpbmNsdWRlICJ1dGlscy9yZWxjYWNoZS5oIgog I2luY2x1ZGUgInV0aWxzL3NuYXBtZ3IuaCIKICNpbmNsdWRlICJ1dGlscy9zeXNjYWNoZS5o IgogI2luY2x1ZGUgInV0aWxzL3R5cGNhY2hlLmgiCkBAIC05MzcsNyArOTM4LDEzIEBAIEV4 ZWNTaW1wbGVSZWxhdGlvblVwZGF0ZShSZXN1bHRSZWxJbmZvICpyZXN1bHRSZWxJbmZvLAog CQlpZiAocmVsLT5yZF9yZWwtPnJlbGlzcGFydGl0aW9uKQogCQkJRXhlY1BhcnRpdGlvbkNo ZWNrKHJlc3VsdFJlbEluZm8sIHNsb3QsIGVzdGF0ZSwgdHJ1ZSk7CiAKKwkJLyoKKwkJICog V2UncmUgbm90IGdvaW5nIHRvIGNhbGwgRXhlY0NoZWNrSW5kZXhlZEF0dHJzRm9yQ2hhbmdl cyBoZXJlCisJCSAqIGJlY2F1c2Ugd2UndmUgYWxyZWFkeSBpZGVudGlmaWVkIHRoZSBjaGFu Z2VzIGVhcmxpZXIgb24gdGhhbmtzIHRvCisJCSAqIHNsb3RfbW9kaWZ5X2RhdGEuCisJCSAq LwogCQlzaW1wbGVfdGFibGVfdHVwbGVfdXBkYXRlKHJlbCwgdGlkLCBzbG90LCBlc3RhdGUt PmVzX3NuYXBzaG90LAorCQkJCQkJCQkgIHJlc3VsdFJlbEluZm8tPnJpX0NoYW5nZWRJbmRl eGVkQ29scywKIAkJCQkJCQkJICAmdXBkYXRlX2luZGV4ZXMpOwogCiAJCWNvbmZsaWN0aW5k ZXhlcyA9IHJlc3VsdFJlbEluZm8tPnJpX29uQ29uZmxpY3RBcmJpdGVySW5kZXhlczsKZGlm ZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVNb2RpZnlUYWJsZS5jIGIvc3Jj L2JhY2tlbmQvZXhlY3V0b3Ivbm9kZU1vZGlmeVRhYmxlLmMKaW5kZXggNjgwMmZjMTNlOTUu LmQwOTllYzc5Mzc1IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlTW9k aWZ5VGFibGUuYworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlTW9kaWZ5VGFibGUu YwpAQCAtMTcsNiArMTcsNyBAQAogICoJCUV4ZWNNb2RpZnlUYWJsZQkJLSByZXRyaWV2ZSB0 aGUgbmV4dCB0dXBsZSBmcm9tIHRoZSBub2RlCiAgKgkJRXhlY0VuZE1vZGlmeVRhYmxlCS0g c2h1dCBkb3duIHRoZSBNb2RpZnlUYWJsZSBub2RlCiAgKgkJRXhlY1JlU2Nhbk1vZGlmeVRh YmxlIC0gcmVzY2FuIHRoZSBNb2RpZnlUYWJsZSBub2RlCisgKgkJRXhlY0NoZWNrSW5kZXhl ZEF0dHJzRm9yQ2hhbmdlcyAtIGZpbmQgc2V0IG9mIHVwZGF0ZWQgaW5kZXhlZCBjb2x1bW5z CiAgKgogICoJIE5PVEVTCiAgKgkJVGhlIE1vZGlmeVRhYmxlIG5vZGUgcmVjZWl2ZXMgaW5w dXQgZnJvbSBpdHMgb3V0ZXJQbGFuLCB3aGljaCBpcwpAQCAtNTQsNiArNTUsNyBAQAogCiAj aW5jbHVkZSAiYWNjZXNzL2h0dXBfZGV0YWlscy5oIgogI2luY2x1ZGUgImFjY2Vzcy90YWJs ZWFtLmgiCisjaW5jbHVkZSAiYWNjZXNzL3R1cGRlc2MuaCIKICNpbmNsdWRlICJhY2Nlc3Mv eGFjdC5oIgogI2luY2x1ZGUgImNvbW1hbmRzL3RyaWdnZXIuaCIKICNpbmNsdWRlICJleGVj dXRvci9leGVjUGFydGl0aW9uLmgiCkBAIC0xODgsNiArMTkwLDEzMSBAQCBzdGF0aWMgVHVw bGVUYWJsZVNsb3QgKkV4ZWNNZXJnZU5vdE1hdGNoZWQoTW9kaWZ5VGFibGVDb250ZXh0ICpj b250ZXh0LAogCQkJCQkJCQkJCSAgIFJlc3VsdFJlbEluZm8gKnJlc3VsdFJlbEluZm8sCiAJ CQkJCQkJCQkJICAgYm9vbCBjYW5TZXRUYWcpOwogCisvKgorICogRXhlY0NoZWNrSW5kZXhl ZEF0dHJzRm9yQ2hhbmdlcworICoKKyAqIERldGVybWluZSB3aGljaCBpbmRleGVzIG5lZWQg dXBkYXRpbmcgYnkgZmluZGluZyB0aGUgc2V0IG9mIG1vZGlmaWVkIGluZGV4ZWQKKyAqIGF0 dHJpYnV0ZXMuCisgKgorICogVGhlIGdvYWwgaXMgZm9yIHRoZSBleGVjdXRvciB0byBrbm93 LCBhaGVhZCBvZiBjYWxsaW5nIGludG8gdGhlIHRhYmxlIEFNIHRvCisgKiBwcm9jZXNzIHRo ZSB1cGRhdGUgYW5kIGJlZm9yZSBjYWxsaW5nIGludG8gdGhlIGluZGV4IEFNIGZvciBpbnNl cnRpbmcgbmV3CisgKiBpbmRleCB0dXBsZXMsIHdoaWNoIGF0dHJpYnV0ZXMgaW4gdGhlIG5l dyBUdXBsZVRhYmxlU2xvdCwgaWYgYW55LCB0cnVlbHkKKyAqIG5lY2Vzc2l0YXRlIGEgbmV3 IGluZGV4IHR1cGxlLgorICoKKyAqIFJldHVybnMgYSBCaXRtYXBzZXQgb2YgYXR0cmlidXRl cyB0aGF0IGludGVyc2VjdHMgd2l0aCBpbmRleGVzIHdoaWNoIHJlcXVpcmUKKyAqIGEgbmV3 IGluZGV4IHR1cGxlLgorICovCitCaXRtYXBzZXQgKgorRXhlY0NoZWNrSW5kZXhlZEF0dHJz Rm9yQ2hhbmdlcyhSZXN1bHRSZWxJbmZvICpyZXN1bHRSZWxJbmZvLAorCQkJCQkJCQlUdXBs ZVRhYmxlU2xvdCAqb2xkX3R0cywKKwkJCQkJCQkJVHVwbGVUYWJsZVNsb3QgKm5ld190dHMp Cit7CisJaW50CQkJYXR0aWR4ID0gLTE7CisJUmVsYXRpb24JcmVsYXRpb24gPSByZXN1bHRS ZWxJbmZvLT5yaV9SZWxhdGlvbkRlc2M7CisJVHVwbGVEZXNjCXR1cGRlc2MgPSBSZWxhdGlv bkdldERlc2NyKHJlbGF0aW9uKTsKKwlCaXRtYXBzZXQgICppZHhfYXR0cnM7CQkvKiBpbnRl cmVzdGluZyBhdHRycyAqLworCUJpdG1hcHNldCAgKm1peF9hdHRycyA9IE5VTEw7CS8qIG1v ZGlmaWVkLCBpbmRleGVkIGF0dHJpYnV0ZXMgKi8KKworCS8qIElmIG5vIGluZGV4ZXMsIHdl J3JlIGRvbmUgKi8KKwlpZiAocmVzdWx0UmVsSW5mby0+cmlfTnVtSW5kaWNlcyA9PSAwKQor CQlyZXR1cm4gTlVMTDsKKworCS8qCisJICogRmV0Y2ggdGhlIHNldCBvZiBhbGwgYXR0cmli dXRlcyByZWZlcmVuY2VkIGFjcm9zcyBhbGwgaW5kZXhlcyBvbiB0aGUKKwkgKiByZWxhdGlv biBhcyB3ZWxsIGFzIHRoZSBzZXQgb2YgYXR0cmlidXRlcyByZWZlcmVuY2VkIGluIGV4cHJl c3Npb25zCisJICogdGhhdCBnZW5lcmF0ZSBhdHRyaWJ1dGVzLgorCSAqLworCWlkeF9hdHRy cyA9IFJlbGF0aW9uR2V0SW5kZXhBdHRyQml0bWFwKHJlbGF0aW9uLCBJTkRFWF9BVFRSX0JJ VE1BUF9JTkRFWEVEKTsKKworCS8qIFJldmlldyBhbGwgYXR0cmlidXRlcyByZWZlcmVuY2Vk IGluIGluZGV4ZXMgb24gdGhpcyByZWxhdGlvbiAqLworCXdoaWxlICgoYXR0aWR4ID0gYm1z X25leHRfbWVtYmVyKGlkeF9hdHRycywgYXR0aWR4KSkgPj0gMCkKKwl7CisJCS8qIGF0dGlk eCBpcyB6ZXJvLWJhc2VkLCBhdHRudW0gaXMgdGhlIG5vcm1hbCBhdHRyaWJ1dGUgbnVtYmVy ICovCisJCUF0dHJOdW1iZXIJYXR0bnVtID0gYXR0aWR4ICsgRmlyc3RMb3dJbnZhbGlkSGVh cEF0dHJpYnV0ZU51bWJlcjsKKwkJRGF0dW0JCW9sZF92YWx1ZSwKKwkJCQkJbmV3X3ZhbHVl OworCQlib29sCQlvbGRfbnVsbCwKKwkJCQkJbmV3X251bGw7CisJCUNvbXBhY3RBdHRyaWJ1 dGUgKmF0dDsKKworCQkvKgorCQkgKiBJZiBpdCdzIGEgd2hvbGUtdHVwbGUgcmVmZXJlbmNl LCBzYXkgIm5vdCBlcXVhbCIuICBJdCdzIG5vdCByZWFsbHkKKwkJICogd29ydGggc3VwcG9y dGluZyB0aGlzIGNhc2UsIHNpbmNlIGl0IGNvdWxkIG9ubHkgc3VjY2VlZCBhZnRlciBhCisJ CSAqIG5vLW9wIHVwZGF0ZSwgd2hpY2ggaXMgaGFyZGx5IGEgY2FzZSB3b3J0aCBvcHRpbWl6 aW5nIGZvci4KKwkJICovCisJCWlmIChhdHRudW0gPT0gMCkKKwkJeworCQkJbWl4X2F0dHJz ID0gYm1zX2FkZF9tZW1iZXIobWl4X2F0dHJzLCBhdHRpZHgpOworCisJCQljb250aW51ZTsK KwkJfQorCisJCS8qCisJCSAqIExpa2V3aXNlLCBhdXRvbWF0aWNhbGx5IHNheSAibm90IGVx dWFsIiBmb3IgYW55IHN5c3RlbSBhdHRyaWJ1dGUKKwkJICogb3RoZXIgdGhhbiB0YWJsZU9J RDsgd2UgY2Fubm90IGV4cGVjdCB0aGVzZSB0byBiZSBjb25zaXN0ZW50IGluIGEKKwkJICog SE9UIGNoYWluLCBvciBldmVuIHRvIGJlIHNldCBjb3JyZWN0bHkgeWV0IGluIHRoZSBuZXcg dHVwbGUuCisJCSAqLworCQlpZiAoYXR0bnVtIDwgMCkKKwkJeworCQkJaWYgKGF0dG51bSAh PSBUYWJsZU9pZEF0dHJpYnV0ZU51bWJlcikKKwkJCQltaXhfYXR0cnMgPSBibXNfYWRkX21l bWJlcihtaXhfYXR0cnMsIGF0dGlkeCk7CisKKwkJCWNvbnRpbnVlOworCQl9CisKKwkJLyog RXh0cmFjdCB0aGUgY29ycmVzcG9uZGluZyB2YWx1ZXMgKi8KKwkJYXR0ID0gVHVwbGVEZXNj Q29tcGFjdEF0dHIodHVwZGVzYywgYXR0bnVtIC0gMSk7CisKKworCQkvKgorCQkgKiBTa2lw IGNoZWNraW5nIGdlbmVyYXRlZCBjb2x1bW5zIGJlY2F1c2UgaWYgYW55IG9mIHRoZSBiYXNl IGNvbHVtbnMKKwkJICogcmVmZXJlbmNlZCBpbiB0aGUgZ2VuZXJhdGlvbiBleHByZXNzaW9u IGhhdmUgY2hhbmdlZC4gSWYgbm9uZSBoYXZlCisJCSAqIGNoYW5nZWQsIHRoZSBnZW5lcmF0 ZWQgY29sdW1uIHZhbHVlIGlzIHVuY2hhbmdlZC4KKwkJICovCisJCWlmIChhdHQtPmF0dGdl bmVyYXRlZCkKKwkJCWNvbnRpbnVlOworCisJCS8qIEV4dHJhY3QgdmFsdWVzIGZyb20gYm90 aCBzbG90cyBmb3IgdGhpcyBhdHRyaWJ1dGUgKi8KKwkJb2xkX3ZhbHVlID0gc2xvdF9nZXRh dHRyKG9sZF90dHMsIGF0dG51bSwgJm9sZF9udWxsKTsKKwkJbmV3X3ZhbHVlID0gc2xvdF9n ZXRhdHRyKG5ld190dHMsIGF0dG51bSwgJm5ld19udWxsKTsKKworCQkvKiBBIGNoYW5nZSB0 by9mcm9tIE5VTEwsIHNvIG5vdCBlcXVhbCAqLworCQlpZiAob2xkX251bGwgIT0gbmV3X251 bGwpCisJCXsKKwkJCW1peF9hdHRycyA9IGJtc19hZGRfbWVtYmVyKG1peF9hdHRycywgYXR0 aWR4KTsKKwkJCWNvbnRpbnVlOworCQl9CisKKwkJLyogQm90aCBOVUxMLCBubyBjaGFuZ2Uv dW5tb2RpZmllZCAqLworCQlpZiAob2xkX251bGwpCisJCQljb250aW51ZTsKKworCQkvKgor CQkgKiBXZSBkbyBzaW1wbGUgYmluYXJ5IGNvbXBhcmlzb24gb2YgdGhlIHR3byBkYXR1bXMu ICBUaGlzIG1heSBiZQorCQkgKiBvdmVybHkgc3RyaWN0IGJlY2F1c2UgdGhlcmUgY2FuIGJl IG11bHRpcGxlIGJpbmFyeSByZXByZXNlbnRhdGlvbnMKKwkJICogZm9yIHRoZSBzYW1lIGxv Z2ljYWwgdmFsdWUuICBCdXQgd2Ugc2hvdWxkIGJlIE9LIGFzIGxvbmcgYXMgdGhlcmUKKwkJ ICogYXJlIG5vIGZhbHNlIHBvc2l0aXZlcy4gIFVzaW5nIGEgdHlwZS1zcGVjaWZpYyBlcXVh bGl0eSBvcGVyYXRvciBpcworCQkgKiBtZXNzeSBiZWNhdXNlIHRoZXJlIGNvdWxkIGJlIG11 bHRpcGxlIG5vdGlvbnMgb2YgZXF1YWxpdHkgaW4KKwkJICogZGlmZmVyZW50IG9wZXJhdG9y IGNsYXNzZXM7IGZ1cnRoZXJtb3JlLCB3ZSBjYW5ub3Qgc2FmZWx5IGludm9rZQorCQkgKiB1 c2VyLWRlZmluZWQgZnVuY3Rpb25zIHdoaWxlIGhvbGRpbmcgZXhjbHVzaXZlIGJ1ZmZlciBs b2NrLgorCQkgKi8KKwkJaWYgKGF0dG51bSA8PSAwKQorCQl7CisJCQkvKiBUaGUgb25seSBh bGxvd2VkIHN5c3RlbSBjb2x1bW5zIGFyZSBPSURzLCBzbyBkbyB0aGlzICovCisJCQlpZiAo RGF0dW1HZXRPYmplY3RJZChvbGRfdmFsdWUpICE9IERhdHVtR2V0T2JqZWN0SWQobmV3X3Zh bHVlKSkKKwkJCQltaXhfYXR0cnMgPSBibXNfYWRkX21lbWJlcihtaXhfYXR0cnMsIGF0dGlk eCk7CisJCX0KKwkJZWxzZQorCQl7CisJCQlpZiAoIWRhdHVtX2ltYWdlX2VxKG9sZF92YWx1 ZSwgbmV3X3ZhbHVlLCBhdHQtPmF0dGJ5dmFsLCBhdHQtPmF0dGxlbikpCisJCQkJbWl4X2F0 dHJzID0gYm1zX2FkZF9tZW1iZXIobWl4X2F0dHJzLCBhdHRpZHgpOworCQl9CisJfQorCisJ Ym1zX2ZyZWUoaWR4X2F0dHJzKTsKKworCXJldHVybiBtaXhfYXR0cnM7Cit9CiAKIC8qCiAg KiBWZXJpZnkgdGhhdCB0aGUgdHVwbGVzIHRvIGJlIHByb2R1Y2VkIGJ5IElOU0VSVCBtYXRj aCB0aGUKQEAgLTIxOTcsMTQgKzIzMjQsMTcgQEAgRXhlY1VwZGF0ZVByZXBhcmVTbG90KFJl c3VsdFJlbEluZm8gKnJlc3VsdFJlbEluZm8sCiAgKi8KIHN0YXRpYyBUTV9SZXN1bHQKIEV4 ZWNVcGRhdGVBY3QoTW9kaWZ5VGFibGVDb250ZXh0ICpjb250ZXh0LCBSZXN1bHRSZWxJbmZv ICpyZXN1bHRSZWxJbmZvLAotCQkJICBJdGVtUG9pbnRlciB0dXBsZWlkLCBIZWFwVHVwbGUg b2xkdHVwbGUsIFR1cGxlVGFibGVTbG90ICpzbG90LAotCQkJICBib29sIGNhblNldFRhZywg VXBkYXRlQ29udGV4dCAqdXBkYXRlQ3h0KQorCQkJICBJdGVtUG9pbnRlciB0dXBsZWlkLCBI ZWFwVHVwbGUgb2xkdHVwbGUsIFR1cGxlVGFibGVTbG90ICpvbGRTbG90LAorCQkJICBUdXBs ZVRhYmxlU2xvdCAqc2xvdCwgYm9vbCBjYW5TZXRUYWcsIFVwZGF0ZUNvbnRleHQgKnVwZGF0 ZUN4dCkKIHsKIAlFU3RhdGUJICAgKmVzdGF0ZSA9IGNvbnRleHQtPmVzdGF0ZTsKIAlSZWxh dGlvbglyZXN1bHRSZWxhdGlvbkRlc2MgPSByZXN1bHRSZWxJbmZvLT5yaV9SZWxhdGlvbkRl c2M7CiAJYm9vbAkJcGFydGl0aW9uX2NvbnN0cmFpbnRfZmFpbGVkOwogCVRNX1Jlc3VsdAly ZXN1bHQ7CiAKKwkvKiBUaGUgc2V0IG9mIG1vZGlmaWVkIGluZGV4ZWQgYXR0cmlidXRlcyB0 aGF0IHRyaWdnZXIgbmV3IGluZGV4IGVudHJpZXMgKi8KKwlCaXRtYXBzZXQgICptaXhfYXR0 cnMgPSBOVUxMOworCiAJdXBkYXRlQ3h0LT5jcm9zc1BhcnRVcGRhdGUgPSBmYWxzZTsKIAog CS8qCkBAIC0yMzIxLDcgKzI0NTEsMjMgQEAgbHJlcGxhY2U6CiAJCUV4ZWNDb25zdHJhaW50 cyhyZXN1bHRSZWxJbmZvLCBzbG90LCBlc3RhdGUpOwogCiAJLyoKLQkgKiByZXBsYWNlIHRo ZSBoZWFwIHR1cGxlCisJICogSWRlbnRpZnkgd2hpY2gsIGlmIGFueSwgaW5kZXhlZCBhdHRy aWJ1dGVzIHdlcmUgbW9kaWZpZWQgaGVyZSBzbyB0aGF0CisJICogd2UgbWlnaHQgcmV1c2Ug aXQgaW4gYSBmZXcgcGxhY2VzLgorCSAqLworCWJtc19mcmVlKHJlc3VsdFJlbEluZm8tPnJp X0NoYW5nZWRJbmRleGVkQ29scyk7CisJcmVzdWx0UmVsSW5mby0+cmlfQ2hhbmdlZEluZGV4 ZWRDb2xzID0gTlVMTDsKKworCS8qCisJICogTmV4dCB1cCB3ZSBuZWVkIHRvIGZpbmQgb3V0 IHRoZSBzZXQgb2YgaW5kZXhlZCBhdHRyaWJ1dGVzIHRoYXQgaGF2ZQorCSAqIGNoYW5nZWQg aW4gdmFsdWUgYW5kIHNob3VsZCB0cmlnZ2VyIGEgbmV3IGluZGV4IHR1cGxlLiAgV2UgY291 bGQgc3RhcnQKKwkgKiB3aXRoIHRoZSBzZXQgb2YgdXBkYXRlZCBjb2x1bW5zIHZpYSBFeGVj R2V0VXBkYXRlZENvbHMoKSwgYnV0IGlmIHdlIGRvCisJICogd2Ugd2lsbCBvdmVybG9vayBh dHRyaWJ1dGVzIGRpcmVjdGx5IG1vZGlmaWVkIGJ5IGhlYXBfbW9kaWZ5X3R1cGxlKCkKKwkg KiB3aGljaCBhcmUgbm90IGtub3duIHRvIEV4ZWNHZXRVcGRhdGVkQ29scygpLgorCSAqLwor CW1peF9hdHRycyA9IEV4ZWNDaGVja0luZGV4ZWRBdHRyc0ZvckNoYW5nZXMocmVzdWx0UmVs SW5mbywgb2xkU2xvdCwgc2xvdCk7CisKKwkvKgorCSAqIENhbGwgaW50byB0aGUgdGFibGUg QU0gdG8gdXBkYXRlIHRoZSBoZWFwIHR1cGxlLgogCSAqCiAJICogTm90ZTogaWYgZXNfY3Jv c3NjaGVja19zbmFwc2hvdCBpc24ndCBJbnZhbGlkU25hcHNob3QsIHdlIGNoZWNrIHRoYXQK IAkgKiB0aGUgcm93IHRvIGJlIHVwZGF0ZWQgaXMgdmlzaWJsZSB0byB0aGF0IHNuYXBzaG90 LCBhbmQgdGhyb3cgYQpAQCAtMjMzNSw4ICsyNDgxLDEyIEBAIGxyZXBsYWNlOgogCQkJCQkJ CQllc3RhdGUtPmVzX2Nyb3NzY2hlY2tfc25hcHNob3QsCiAJCQkJCQkJCXRydWUgLyogd2Fp dCBmb3IgY29tbWl0ICovICwKIAkJCQkJCQkJJmNvbnRleHQtPnRtZmQsICZ1cGRhdGVDeHQt PmxvY2ttb2RlLAorCQkJCQkJCQltaXhfYXR0cnMsCiAJCQkJCQkJCSZ1cGRhdGVDeHQtPnVw ZGF0ZUluZGV4ZXMpOwogCisJQXNzZXJ0KGJtc19pc19lbXB0eShyZXN1bHRSZWxJbmZvLT5y aV9DaGFuZ2VkSW5kZXhlZENvbHMpKTsKKwlyZXN1bHRSZWxJbmZvLT5yaV9DaGFuZ2VkSW5k ZXhlZENvbHMgPSBtaXhfYXR0cnM7CisKIAlyZXR1cm4gcmVzdWx0OwogfQogCkBAIC0yNTUz LDggKzI3MDMsOSBAQCBFeGVjVXBkYXRlKE1vZGlmeVRhYmxlQ29udGV4dCAqY29udGV4dCwg UmVzdWx0UmVsSW5mbyAqcmVzdWx0UmVsSW5mbywKIAkJICovCiByZWRvX2FjdDoKIAkJbG9j a2VkdGlkID0gKnR1cGxlaWQ7Ci0JCXJlc3VsdCA9IEV4ZWNVcGRhdGVBY3QoY29udGV4dCwg cmVzdWx0UmVsSW5mbywgdHVwbGVpZCwgb2xkdHVwbGUsIHNsb3QsCi0JCQkJCQkJICAgY2Fu U2V0VGFnLCAmdXBkYXRlQ3h0KTsKKworCQlyZXN1bHQgPSBFeGVjVXBkYXRlQWN0KGNvbnRl eHQsIHJlc3VsdFJlbEluZm8sIHR1cGxlaWQsIG9sZHR1cGxlLCBvbGRTbG90LAorCQkJCQkJ CSAgIHNsb3QsIGNhblNldFRhZywgJnVwZGF0ZUN4dCk7CiAKIAkJLyoKIAkJICogSWYgRXhl Y1VwZGF0ZUFjdCByZXBvcnRzIHRoYXQgYSBjcm9zcy1wYXJ0aXRpb24gdXBkYXRlIHdhcyBk b25lLApAQCAtMzQwNCw4ICszNTU1LDggQEAgbG1lcmdlX21hdGNoZWQ6CiAJCQkJCUFzc2Vy dChvbGR0dXBsZSA9PSBOVUxMKTsKIAogCQkJCQlyZXN1bHQgPSBFeGVjVXBkYXRlQWN0KGNv bnRleHQsIHJlc3VsdFJlbEluZm8sIHR1cGxlaWQsCi0JCQkJCQkJCQkJICAgTlVMTCwgbmV3 c2xvdCwgY2FuU2V0VGFnLAotCQkJCQkJCQkJCSAgICZ1cGRhdGVDeHQpOworCQkJCQkJCQkJ CSAgIE5VTEwsIHJlc3VsdFJlbEluZm8tPnJpX29sZFR1cGxlU2xvdCwKKwkJCQkJCQkJCQkg ICBuZXdzbG90LCBjYW5TZXRUYWcsICZ1cGRhdGVDeHQpOwogCiAJCQkJCS8qCiAJCQkJCSAq IEFzIGluIEV4ZWNVcGRhdGUoKSwgaWYgRXhlY1VwZGF0ZUFjdCgpIHJlcG9ydHMgdGhhdCBh CkBAIC0zNDMwLDYgKzM1ODEsNyBAQCBsbWVyZ2VfbWF0Y2hlZDoKIAkJCQkJCQkJCSAgIHR1 cGxlaWQsIE5VTEwsIG5ld3Nsb3QpOwogCQkJCQltdHN0YXRlLT5tdF9tZXJnZV91cGRhdGVk ICs9IDE7CiAJCQkJfQorCiAJCQkJYnJlYWs7CiAKIAkJCWNhc2UgQ01EX0RFTEVURToKQEAg LTQ1MzcsNyArNDY4OSw3IEBAIEV4ZWNNb2RpZnlUYWJsZShQbGFuU3RhdGUgKnBzdGF0ZSkK IAkJICogRm9yIFVQREFURS9ERUxFVEUvTUVSR0UsIGZldGNoIHRoZSByb3cgaWRlbnRpdHkg aW5mbyBmb3IgdGhlIHR1cGxlCiAJCSAqIHRvIGJlIHVwZGF0ZWQvZGVsZXRlZC9tZXJnZWQu ICBGb3IgYSBoZWFwIHJlbGF0aW9uLCB0aGF0J3MgYSBUSUQ7CiAJCSAqIG90aGVyd2lzZSB3 ZSBtYXkgaGF2ZSBhIHdob2xlcm93IGp1bmsgYXR0ciB0aGF0IGNhcnJpZXMgdGhlIG9sZAot CQkgKiB0dXBsZSBpbiB0b3RvLiAgS2VlcCB0aGlzIGluIHN0ZXAgd2l0aCB0aGUgcGFydCBv ZgorCQkgKiB0dXBsZSBpbiB0b3RhbC4gIEtlZXAgdGhpcyBpbiBzdGVwIHdpdGggdGhlIHBh cnQgb2YKIAkJICogRXhlY0luaXRNb2RpZnlUYWJsZSB0aGF0IHNldHMgdXAgcmlfUm93SWRB dHROby4KIAkJICovCiAJCWlmIChvcGVyYXRpb24gPT0gQ01EX1VQREFURSB8fCBvcGVyYXRp b24gPT0gQ01EX0RFTEVURSB8fApAQCAtNDcxNyw2ICs0ODY5LDcgQEAgRXhlY01vZGlmeVRh YmxlKFBsYW5TdGF0ZSAqcHN0YXRlKQogCQkJCS8qIE5vdyBhcHBseSB0aGUgdXBkYXRlLiAq LwogCQkJCXNsb3QgPSBFeGVjVXBkYXRlKCZjb250ZXh0LCByZXN1bHRSZWxJbmZvLCB0dXBs ZWlkLCBvbGR0dXBsZSwKIAkJCQkJCQkJICBvbGRTbG90LCBzbG90LCBub2RlLT5jYW5TZXRU YWcpOworCiAJCQkJaWYgKHR1cGxvY2spCiAJCQkJCVVubG9ja1R1cGxlKHJlc3VsdFJlbElu Zm8tPnJpX1JlbGF0aW9uRGVzYywgdHVwbGVpZCwKIAkJCQkJCQkJSW5wbGFjZVVwZGF0ZVR1 cGxlTG9jayk7CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9yZXBsaWNhdGlvbi9sb2dpY2Fs L3dvcmtlci5jIGIvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vbG9naWNhbC93b3JrZXIuYwpp bmRleCAzMjcyNWM0ODYyMy4uOTY4ZmY2MjZmMDQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5k L3JlcGxpY2F0aW9uL2xvZ2ljYWwvd29ya2VyLmMKKysrIGIvc3JjL2JhY2tlbmQvcmVwbGlj YXRpb24vbG9naWNhbC93b3JrZXIuYwpAQCAtMjg1LDEyICsyODUsMTQgQEAKICNpbmNsdWRl ICJzdG9yYWdlL3Byb2NhcnJheS5oIgogI2luY2x1ZGUgInRjb3AvdGNvcHByb3QuaCIKICNp bmNsdWRlICJ1dGlscy9hY2wuaCIKKyNpbmNsdWRlICJ1dGlscy9kYXR1bS5oIgogI2luY2x1 ZGUgInV0aWxzL2d1Yy5oIgogI2luY2x1ZGUgInV0aWxzL2ludmFsLmgiCiAjaW5jbHVkZSAi dXRpbHMvbHN5c2NhY2hlLmgiCiAjaW5jbHVkZSAidXRpbHMvbWVtdXRpbHMuaCIKICNpbmNs dWRlICJ1dGlscy9wZ19sc24uaCIKICNpbmNsdWRlICJ1dGlscy9yZWwuaCIKKyNpbmNsdWRl ICJ1dGlscy9yZWxjYWNoZS5oIgogI2luY2x1ZGUgInV0aWxzL3Jscy5oIgogI2luY2x1ZGUg InV0aWxzL3NuYXBtZ3IuaCIKICNpbmNsdWRlICJ1dGlscy9zeXNjYWNoZS5oIgpAQCAtMTEx MCwxNSArMTExMiwxOCBAQCBzbG90X3N0b3JlX2RhdGEoVHVwbGVUYWJsZVNsb3QgKnNsb3Qs IExvZ2ljYWxSZXBSZWxNYXBFbnRyeSAqcmVsLAogICogInNsb3QiIGlzIGZpbGxlZCB3aXRo IGEgY29weSBvZiB0aGUgdHVwbGUgaW4gInNyY3Nsb3QiLCByZXBsYWNpbmcKICAqIGNvbHVt bnMgcHJvdmlkZWQgaW4gInR1cGxlRGF0YSIgYW5kIGxlYXZpbmcgb3RoZXJzIGFzLWlzLgog ICoKKyAqIFJldHVybnMgYSBiaXRtYXAgb2YgdGhlIG1vZGlmaWVkIGNvbHVtbnMuCisgKgog ICogQ2F1dGlvbjogdW5yZXBsYWNlZCBwYXNzLWJ5LXJlZiBjb2x1bW5zIGluICJzbG90IiB3 aWxsIHBvaW50IGludG8gdGhlCiAgKiBzdG9yYWdlIGZvciAic3Jjc2xvdCIuICBUaGlzIGlz IE9LIGZvciBjdXJyZW50IHVzYWdlLCBidXQgc29tZWRheSB3ZSBtYXkKICAqIG5lZWQgdG8g bWF0ZXJpYWxpemUgInNsb3QiIGF0IHRoZSBlbmQgdG8gbWFrZSBpdCBpbmRlcGVuZGVudCBv ZiAic3Jjc2xvdCIuCiAgKi8KLXN0YXRpYyB2b2lkCitzdGF0aWMgQml0bWFwc2V0ICoKIHNs b3RfbW9kaWZ5X2RhdGEoVHVwbGVUYWJsZVNsb3QgKnNsb3QsIFR1cGxlVGFibGVTbG90ICpz cmNzbG90LAogCQkJCSBMb2dpY2FsUmVwUmVsTWFwRW50cnkgKnJlbCwKIAkJCQkgTG9naWNh bFJlcFR1cGxlRGF0YSAqdHVwbGVEYXRhKQogeworCUJpdG1hcHNldCAgKm1vZGlmaWVkID0g TlVMTDsKIAlpbnQJCQluYXR0cyA9IHNsb3QtPnR0c190dXBsZURlc2NyaXB0b3ItPm5hdHRz OwogCWludAkJCWk7CiAKQEAgLTExOTUsNiArMTIwMCwyNyBAQCBzbG90X21vZGlmeV9kYXRh KFR1cGxlVGFibGVTbG90ICpzbG90LCBUdXBsZVRhYmxlU2xvdCAqc3Jjc2xvdCwKIAkJCQlz bG90LT50dHNfaXNudWxsW2ldID0gdHJ1ZTsKIAkJCX0KIAorCQkJLyoKKwkJCSAqIERldGVy bWluZSBpZiB0aGUgcmVwbGljYXRlZCB2YWx1ZSBjaGFuZ2VkIHRoZSBsb2NhbCB2YWx1ZSBi eQorCQkJICogY29tcGFyaW5nIHNsb3RzLiAgVGhpcyBpcyBhIHN1YnNldCBvZgorCQkJICog RXhlY0NoZWNrSW5kZXhlZEF0dHJzRm9yQ2hhbmdlcy4KKwkJCSAqLworCQkJaWYgKHNyY3Ns b3QtPnR0c19pc251bGxbaV0gIT0gc2xvdC0+dHRzX2lzbnVsbFtpXSkKKwkJCXsKKwkJCQkv KiBPbmUgaXMgTlVMTCwgdGhlIG90aGVyIGlzIG5vdCBzbyB0aGUgdmFsdWUgY2hhbmdlZCAq LworCQkJCW1vZGlmaWVkID0gYm1zX2FkZF9tZW1iZXIobW9kaWZpZWQsIGkgKyAxIC0gRmly c3RMb3dJbnZhbGlkSGVhcEF0dHJpYnV0ZU51bWJlcik7CisJCQl9CisJCQllbHNlIGlmICgh c3Jjc2xvdC0+dHRzX2lzbnVsbFtpXSkKKwkJCXsKKwkJCQkvKiBCb3RoIGFyZSBub3QgTlVM TCwgY29tcGFyZSB0aGVpciB2YWx1ZXMgKi8KKworCQkJCWlmICghZGF0dW1Jc0VxdWFsKHNy Y3Nsb3QtPnR0c192YWx1ZXNbaV0sCisJCQkJCQkJCSAgc2xvdC0+dHRzX3ZhbHVlc1tpXSwK KwkJCQkJCQkJICBhdHQtPmF0dGJ5dmFsLAorCQkJCQkJCQkgIGF0dC0+YXR0bGVuKSkKKwkJ CQkJbW9kaWZpZWQgPSBibXNfYWRkX21lbWJlcihtb2RpZmllZCwgaSArIDEgLSBGaXJzdExv d0ludmFsaWRIZWFwQXR0cmlidXRlTnVtYmVyKTsKKwkJCX0KKwogCQkJLyogUmVzZXQgYXR0 bnVtIGZvciBlcnJvciBjYWxsYmFjayAqLwogCQkJYXBwbHlfZXJyb3JfY2FsbGJhY2tfYXJn LnJlbW90ZV9hdHRudW0gPSAtMTsKIAkJfQpAQCAtMTIwMiw2ICsxMjI4LDggQEAgc2xvdF9t b2RpZnlfZGF0YShUdXBsZVRhYmxlU2xvdCAqc2xvdCwgVHVwbGVUYWJsZVNsb3QgKnNyY3Ns b3QsCiAKIAkvKiBBbmQgZmluYWxseSwgZGVjbGFyZSB0aGF0ICJzbG90IiBjb250YWlucyBh IHZhbGlkIHZpcnR1YWwgdHVwbGUgKi8KIAlFeGVjU3RvcmVWaXJ0dWFsVHVwbGUoc2xvdCk7 CisKKwlyZXR1cm4gbW9kaWZpZWQ7CiB9CiAKIC8qCkBAIC0yOTE4LDYgKzI5NDYsNyBAQCBh cHBseV9oYW5kbGVfdXBkYXRlX2ludGVybmFsKEFwcGx5RXhlY3V0aW9uRGF0YSAqZWRhdGEs CiAJQ29uZmxpY3RUdXBsZUluZm8gY29uZmxpY3R0dXBsZSA9IHswfTsKIAlib29sCQlmb3Vu ZDsKIAlNZW1vcnlDb250ZXh0IG9sZGN0eDsKKwlCaXRtYXBzZXQgICppbmRleGVkID0gTlVM TDsKIAogCUV2YWxQbGFuUXVhbEluaXQoJmVwcXN0YXRlLCBlc3RhdGUsIE5VTEwsIE5JTCwg LTEsIE5JTCk7CiAJRXhlY09wZW5JbmRpY2VzKHJlbGluZm8sIGZhbHNlKTsKQEAgLTI5MzQs NiArMjk2Myw4IEBAIGFwcGx5X2hhbmRsZV91cGRhdGVfaW50ZXJuYWwoQXBwbHlFeGVjdXRp b25EYXRhICplZGF0YSwKIAkgKi8KIAlpZiAoZm91bmQpCiAJeworCQlCaXRtYXBzZXQgICpt b2RpZmllZCA9IE5VTEw7CisKIAkJLyoKIAkJICogUmVwb3J0IHRoZSBjb25mbGljdCBpZiB0 aGUgdHVwbGUgd2FzIG1vZGlmaWVkIGJ5IGEgZGlmZmVyZW50CiAJCSAqIG9yaWdpbi4KQEAg LTI5NTcsMTUgKzI5ODgsMjkgQEAgYXBwbHlfaGFuZGxlX3VwZGF0ZV9pbnRlcm5hbChBcHBs eUV4ZWN1dGlvbkRhdGEgKmVkYXRhLAogCiAJCS8qIFByb2Nlc3MgYW5kIHN0b3JlIHJlbW90 ZSB0dXBsZSBpbiB0aGUgc2xvdCAqLwogCQlvbGRjdHggPSBNZW1vcnlDb250ZXh0U3dpdGNo VG8oR2V0UGVyVHVwbGVNZW1vcnlDb250ZXh0KGVzdGF0ZSkpOwotCQlzbG90X21vZGlmeV9k YXRhKHJlbW90ZXNsb3QsIGxvY2Fsc2xvdCwgcmVsbWFwZW50cnksIG5ld3R1cCk7CisJCW1v ZGlmaWVkID0gc2xvdF9tb2RpZnlfZGF0YShyZW1vdGVzbG90LCBsb2NhbHNsb3QsIHJlbG1h cGVudHJ5LCBuZXd0dXApOwogCQlNZW1vcnlDb250ZXh0U3dpdGNoVG8ob2xkY3R4KTsKIAor CQkvKgorCQkgKiBOb3JtYWxseSB3ZSdkIGNhbGwgRXhlY0NoZWNrSW5kZXhlZEF0dHJGb3JD aGFuZ2VzIGJ1dCBoZXJlIHdlIGhhdmUKKwkJICogdGhlIHJlY29yZCBvZiBjaGFuZ2VkIGNv bHVtbnMgaW4gdGhlIHJlcGxpY2F0aW9uIHN0YXRlLCBzbyBsZXQncworCQkgKiB1c2UgdGhh dCBpbnN0ZWFkLgorCQkgKi8KKwkJaW5kZXhlZCA9IFJlbGF0aW9uR2V0SW5kZXhBdHRyQml0 bWFwKHJlbGluZm8tPnJpX1JlbGF0aW9uRGVzYywKKwkJCQkJCQkJCQkJIElOREVYX0FUVFJf QklUTUFQX0lOREVYRUQpOworCisJCWJtc19mcmVlKHJlbGluZm8tPnJpX0NoYW5nZWRJbmRl eGVkQ29scyk7CisJCXJlbGluZm8tPnJpX0NoYW5nZWRJbmRleGVkQ29scyA9IGJtc19pbnRf bWVtYmVycyhtb2RpZmllZCwgaW5kZXhlZCk7CisJCWJtc19mcmVlKGluZGV4ZWQpOworCiAJ CUV2YWxQbGFuUXVhbFNldFNsb3QoJmVwcXN0YXRlLCByZW1vdGVzbG90KTsKIAogCQlJbml0 Q29uZmxpY3RJbmRleGVzKHJlbGluZm8pOwogCi0JCS8qIERvIHRoZSBhY3R1YWwgdXBkYXRl LiAqLworCQkvKiBGaXJzdCBjaGVjayBwcml2aWxlZ2VzICovCiAJCVRhcmdldFByaXZpbGVn ZXNDaGVjayhyZWxpbmZvLT5yaV9SZWxhdGlvbkRlc2MsIEFDTF9VUERBVEUpOworCisJCS8q IFRoZW4gZG8gdGhlIGFjdHVhbCB1cGRhdGUuICovCiAJCUV4ZWNTaW1wbGVSZWxhdGlvblVw ZGF0ZShyZWxpbmZvLCBlc3RhdGUsICZlcHFzdGF0ZSwgbG9jYWxzbG90LAogCQkJCQkJCQkg cmVtb3Rlc2xvdCk7CiAJfQpAQCAtMzQ1NSw2ICszNTAwLDggQEAgYXBwbHlfaGFuZGxlX3R1 cGxlX3JvdXRpbmcoQXBwbHlFeGVjdXRpb25EYXRhICplZGF0YSwKIAkJCQlib29sCQlmb3Vu ZDsKIAkJCQlFUFFTdGF0ZQllcHFzdGF0ZTsKIAkJCQlDb25mbGljdFR1cGxlSW5mbyBjb25m bGljdHR1cGxlID0gezB9OworCQkJCUJpdG1hcHNldCAgKm1vZGlmaWVkID0gTlVMTDsKKwkJ CQlCaXRtYXBzZXQgICppbmRleGVkOwogCiAJCQkJLyogR2V0IHRoZSBtYXRjaGluZyBsb2Nh bCB0dXBsZSBmcm9tIHRoZSBwYXJ0aXRpb24uICovCiAJCQkJZm91bmQgPSBGaW5kUmVwbFR1 cGxlSW5Mb2NhbFJlbChlZGF0YSwgcGFydHJlbCwKQEAgLTM1MjMsOCArMzU3MCw4IEBAIGFw cGx5X2hhbmRsZV90dXBsZV9yb3V0aW5nKEFwcGx5RXhlY3V0aW9uRGF0YSAqZWRhdGEsCiAJ CQkJICogcmVtb3Rlc2xvdF9wYXJ0LgogCQkJCSAqLwogCQkJCW9sZGN0eCA9IE1lbW9yeUNv bnRleHRTd2l0Y2hUbyhHZXRQZXJUdXBsZU1lbW9yeUNvbnRleHQoZXN0YXRlKSk7Ci0JCQkJ c2xvdF9tb2RpZnlfZGF0YShyZW1vdGVzbG90X3BhcnQsIGxvY2Fsc2xvdCwgcGFydF9lbnRy eSwKLQkJCQkJCQkJIG5ld3R1cCk7CisJCQkJbW9kaWZpZWQgPSBzbG90X21vZGlmeV9kYXRh KHJlbW90ZXNsb3RfcGFydCwgbG9jYWxzbG90LCBwYXJ0X2VudHJ5LAorCQkJCQkJCQkJCQlu ZXd0dXApOwogCQkJCU1lbW9yeUNvbnRleHRTd2l0Y2hUbyhvbGRjdHgpOwogCiAJCQkJRXZh bFBsYW5RdWFsSW5pdCgmZXBxc3RhdGUsIGVzdGF0ZSwgTlVMTCwgTklMLCAtMSwgTklMKTsK QEAgLTM1NDksNiArMzU5NiwxOCBAQCBhcHBseV9oYW5kbGVfdHVwbGVfcm91dGluZyhBcHBs eUV4ZWN1dGlvbkRhdGEgKmVkYXRhLAogCQkJCQlFdmFsUGxhblF1YWxTZXRTbG90KCZlcHFz dGF0ZSwgcmVtb3Rlc2xvdF9wYXJ0KTsKIAkJCQkJVGFyZ2V0UHJpdmlsZWdlc0NoZWNrKHBh cnRyZWxpbmZvLT5yaV9SZWxhdGlvbkRlc2MsCiAJCQkJCQkJCQkJICBBQ0xfVVBEQVRFKTsK KworCQkJCQkvKgorCQkJCQkgKiBOb3JtYWxseSB3ZSdkIGNhbGwgRXhlY0NoZWNrSW5kZXhl ZEF0dHJGb3JDaGFuZ2VzIGJ1dAorCQkJCQkgKiBoZXJlIHdlIGhhdmUgdGhlIHJlY29yZCBv ZiBjaGFuZ2VkIGNvbHVtbnMgaW4gdGhlCisJCQkJCSAqIHJlcGxpY2F0aW9uIHN0YXRlLCBz byBsZXQncyB1c2UgdGhhdCBpbnN0ZWFkLgorCQkJCQkgKi8KKwkJCQkJaW5kZXhlZCA9IFJl bGF0aW9uR2V0SW5kZXhBdHRyQml0bWFwKHBhcnRyZWxpbmZvLT5yaV9SZWxhdGlvbkRlc2Ms CisJCQkJCQkJCQkJCQkJCSBJTkRFWF9BVFRSX0JJVE1BUF9JTkRFWEVEKTsKKwkJCQkJYm1z X2ZyZWUocGFydHJlbGluZm8tPnJpX0NoYW5nZWRJbmRleGVkQ29scyk7CisJCQkJCXBhcnRy ZWxpbmZvLT5yaV9DaGFuZ2VkSW5kZXhlZENvbHMgPSBibXNfaW50X21lbWJlcnMobW9kaWZp ZWQsIGluZGV4ZWQpOworCQkJCQlibXNfZnJlZShpbmRleGVkKTsKKwogCQkJCQlFeGVjU2lt cGxlUmVsYXRpb25VcGRhdGUocGFydHJlbGluZm8sIGVzdGF0ZSwgJmVwcXN0YXRlLAogCQkJ CQkJCQkJCQkgbG9jYWxzbG90LCByZW1vdGVzbG90X3BhcnQpOwogCQkJCX0KZGlmZiAtLWdp dCBhL3NyYy9iYWNrZW5kL3V0aWxzL2NhY2hlL3JlbGNhY2hlLmMgYi9zcmMvYmFja2VuZC91 dGlscy9jYWNoZS9yZWxjYWNoZS5jCmluZGV4IDZiNjM0YzlmZmYxLi41NDdjZjFkMDU0ZCAx MDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvY2FjaGUvcmVsY2FjaGUuYworKysgYi9z cmMvYmFja2VuZC91dGlscy9jYWNoZS9yZWxjYWNoZS5jCkBAIC0yNDc3LDYgKzI0NzcsNyBA QCBSZWxhdGlvbkRlc3Ryb3lSZWxhdGlvbihSZWxhdGlvbiByZWxhdGlvbiwgYm9vbCByZW1l bWJlcl90dXBkZXNjKQogCWJtc19mcmVlKHJlbGF0aW9uLT5yZF9pZGF0dHIpOwogCWJtc19m cmVlKHJlbGF0aW9uLT5yZF9ob3RibG9ja2luZ2F0dHIpOwogCWJtc19mcmVlKHJlbGF0aW9u LT5yZF9zdW1tYXJpemVkYXR0cik7CisJYm1zX2ZyZWUocmVsYXRpb24tPnJkX2luZGV4ZWRh dHRyKTsKIAlpZiAocmVsYXRpb24tPnJkX3B1YmRlc2MpCiAJCXBmcmVlKHJlbGF0aW9uLT5y ZF9wdWJkZXNjKTsKIAlpZiAocmVsYXRpb24tPnJkX29wdGlvbnMpCkBAIC01Mjc4LDYgKzUy NzksNyBAQCBSZWxhdGlvbkdldEluZGV4UHJlZGljYXRlKFJlbGF0aW9uIHJlbGF0aW9uKQog ICoJCQkJCQkJCQlpbmRleCAoZW1wdHkgaWYgRlVMTCkKICAqCUlOREVYX0FUVFJfQklUTUFQ X0hPVF9CTE9DS0lORwlDb2x1bW5zIHRoYXQgYmxvY2sgdXBkYXRlcyBmcm9tIGJlaW5nIEhP VAogICoJSU5ERVhfQVRUUl9CSVRNQVBfU1VNTUFSSVpFRAlDb2x1bW5zIGluY2x1ZGVkIGlu IHN1bW1hcml6aW5nIGluZGV4ZXMKKyAqCUlOREVYX0FUVFJfQklUTUFQX0lOREVYRUQJCUNv bHVtbnMgcmVmZXJlbmNlZCBieSBpbmRleGVzCiAgKgogICogQXR0cmlidXRlIG51bWJlcnMg YXJlIG9mZnNldCBieSBGaXJzdExvd0ludmFsaWRIZWFwQXR0cmlidXRlTnVtYmVyIHNvIHRo YXQKICAqIHdlIGNhbiBpbmNsdWRlIHN5c3RlbSBhdHRyaWJ1dGVzIChlLmcuLCBPSUQpIGlu IHRoZSBiaXRtYXAgcmVwcmVzZW50YXRpb24uCkBAIC01MzAxLDYgKzUzMDMsNyBAQCBSZWxh dGlvbkdldEluZGV4QXR0ckJpdG1hcChSZWxhdGlvbiByZWxhdGlvbiwgSW5kZXhBdHRyQml0 bWFwS2luZCBhdHRyS2luZCkKIAlCaXRtYXBzZXQgICpwa2luZGV4YXR0cnM7CS8qIGNvbHVt bnMgaW4gdGhlIHByaW1hcnkgaW5kZXggKi8KIAlCaXRtYXBzZXQgICppZGluZGV4YXR0cnM7 CS8qIGNvbHVtbnMgaW4gdGhlIHJlcGxpY2EgaWRlbnRpdHkgKi8KIAlCaXRtYXBzZXQgICpo b3RibG9ja2luZ2F0dHJzOwkvKiBjb2x1bW5zIHdpdGggSE9UIGJsb2NraW5nIGluZGV4ZXMg Ki8KKwlCaXRtYXBzZXQgICppbmRleGVkYXR0cnM7CS8qIGNvbHVtbnMgcmVmZXJlbmNlZCBi eSBpbmRleGVzICovCiAJQml0bWFwc2V0ICAqc3VtbWFyaXplZGF0dHJzOwkvKiBjb2x1bW5z IHdpdGggc3VtbWFyaXppbmcgaW5kZXhlcyAqLwogCUxpc3QJICAgKmluZGV4b2lkbGlzdDsK IAlMaXN0CSAgICpuZXdpbmRleG9pZGxpc3Q7CkBAIC01MzI0LDYgKzUzMjcsOCBAQCBSZWxh dGlvbkdldEluZGV4QXR0ckJpdG1hcChSZWxhdGlvbiByZWxhdGlvbiwgSW5kZXhBdHRyQml0 bWFwS2luZCBhdHRyS2luZCkKIAkJCQlyZXR1cm4gYm1zX2NvcHkocmVsYXRpb24tPnJkX2hv dGJsb2NraW5nYXR0cik7CiAJCQljYXNlIElOREVYX0FUVFJfQklUTUFQX1NVTU1BUklaRUQ6 CiAJCQkJcmV0dXJuIGJtc19jb3B5KHJlbGF0aW9uLT5yZF9zdW1tYXJpemVkYXR0cik7CisJ CQljYXNlIElOREVYX0FUVFJfQklUTUFQX0lOREVYRUQ6CisJCQkJcmV0dXJuIGJtc19jb3B5 KHJlbGF0aW9uLT5yZF9pbmRleGVkYXR0cik7CiAJCQlkZWZhdWx0OgogCQkJCWVsb2coRVJS T1IsICJ1bmtub3duIGF0dHJLaW5kICV1IiwgYXR0cktpbmQpOwogCQl9CkBAIC01MzY4LDYg KzUzNzMsNyBAQCByZXN0YXJ0OgogCWlkaW5kZXhhdHRycyA9IE5VTEw7CiAJaG90YmxvY2tp bmdhdHRycyA9IE5VTEw7CiAJc3VtbWFyaXplZGF0dHJzID0gTlVMTDsKKwlpbmRleGVkYXR0 cnMgPSBOVUxMOwogCWZvcmVhY2gobCwgaW5kZXhvaWRsaXN0KQogCXsKIAkJT2lkCQkJaW5k ZXhPaWQgPSBsZmlyc3Rfb2lkKGwpOwpAQCAtNTUwMCwxMCArNTUwNiwxNCBAQCByZXN0YXJ0 OgogCQlibXNfZnJlZShpZGluZGV4YXR0cnMpOwogCQlibXNfZnJlZShob3RibG9ja2luZ2F0 dHJzKTsKIAkJYm1zX2ZyZWUoc3VtbWFyaXplZGF0dHJzKTsKKwkJLyogaW5kZXhlZGF0dHJz IG5vdCB5ZXQgaW5pdGlhbGl6ZWQgKi8KIAogCQlnb3RvIHJlc3RhcnQ7CiAJfQogCisJLyog U2V0IGluZGV4ZWQgYXR0cmlidXRlcyB0byB0cmFjayBhbGwgcmVmZXJlbmNlZCBhdHRyaWJ1 dGVzICovCisJaW5kZXhlZGF0dHJzID0gYm1zX3VuaW9uKGhvdGJsb2NraW5nYXR0cnMsIHN1 bW1hcml6ZWRhdHRycyk7CisKIAkvKiBEb24ndCBsZWFrIHRoZSBvbGQgdmFsdWVzIG9mIHRo ZXNlIGJpdG1hcHMsIGlmIGFueSAqLwogCXJlbGF0aW9uLT5yZF9hdHRyc3ZhbGlkID0gZmFs c2U7CiAJYm1zX2ZyZWUocmVsYXRpb24tPnJkX2tleWF0dHIpOwpAQCAtNTUxNiw2ICs1NTI2 LDggQEAgcmVzdGFydDoKIAlyZWxhdGlvbi0+cmRfaG90YmxvY2tpbmdhdHRyID0gTlVMTDsK IAlibXNfZnJlZShyZWxhdGlvbi0+cmRfc3VtbWFyaXplZGF0dHIpOwogCXJlbGF0aW9uLT5y ZF9zdW1tYXJpemVkYXR0ciA9IE5VTEw7CisJYm1zX2ZyZWUocmVsYXRpb24tPnJkX2luZGV4 ZWRhdHRyKTsKKwlyZWxhdGlvbi0+cmRfaW5kZXhlZGF0dHIgPSBOVUxMOwogCiAJLyoKIAkg KiBOb3cgc2F2ZSBjb3BpZXMgb2YgdGhlIGJpdG1hcHMgaW4gdGhlIHJlbGNhY2hlIGVudHJ5 LiAgV2UgaW50ZW50aW9uYWxseQpAQCAtNTUzMCw2ICs1NTQyLDcgQEAgcmVzdGFydDoKIAly ZWxhdGlvbi0+cmRfaWRhdHRyID0gYm1zX2NvcHkoaWRpbmRleGF0dHJzKTsKIAlyZWxhdGlv bi0+cmRfaG90YmxvY2tpbmdhdHRyID0gYm1zX2NvcHkoaG90YmxvY2tpbmdhdHRycyk7CiAJ cmVsYXRpb24tPnJkX3N1bW1hcml6ZWRhdHRyID0gYm1zX2NvcHkoc3VtbWFyaXplZGF0dHJz KTsKKwlyZWxhdGlvbi0+cmRfaW5kZXhlZGF0dHIgPSBibXNfY29weShpbmRleGVkYXR0cnMp OwogCXJlbGF0aW9uLT5yZF9hdHRyc3ZhbGlkID0gdHJ1ZTsKIAlNZW1vcnlDb250ZXh0U3dp dGNoVG8ob2xkY3h0KTsKIApAQCAtNTU0Niw2ICs1NTU5LDggQEAgcmVzdGFydDoKIAkJCXJl dHVybiBob3RibG9ja2luZ2F0dHJzOwogCQljYXNlIElOREVYX0FUVFJfQklUTUFQX1NVTU1B UklaRUQ6CiAJCQlyZXR1cm4gc3VtbWFyaXplZGF0dHJzOworCQljYXNlIElOREVYX0FUVFJf QklUTUFQX0lOREVYRUQ6CisJCQlyZXR1cm4gaW5kZXhlZGF0dHJzOwogCQlkZWZhdWx0Ogog CQkJZWxvZyhFUlJPUiwgInVua25vd24gYXR0cktpbmQgJXUiLCBhdHRyS2luZCk7CiAJCQly ZXR1cm4gTlVMTDsKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2FjY2Vzcy9oZWFwYW0uaCBi L3NyYy9pbmNsdWRlL2FjY2Vzcy9oZWFwYW0uaAppbmRleCAzYzA5NjFhYjM2Yi4uYTU2ZjNk MWYzNzggMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL2FjY2Vzcy9oZWFwYW0uaAorKysgYi9z cmMvaW5jbHVkZS9hY2Nlc3MvaGVhcGFtLmgKQEAgLTM2OCw2ICszNjgsNyBAQCBleHRlcm4g VE1fUmVzdWx0IGhlYXBfdXBkYXRlKFJlbGF0aW9uIHJlbGF0aW9uLCBjb25zdCBJdGVtUG9p bnRlckRhdGEgKm90aWQsCiAJCQkJCQkJIEhlYXBUdXBsZSBuZXd0dXAsCiAJCQkJCQkJIENv bW1hbmRJZCBjaWQsIFNuYXBzaG90IGNyb3NzY2hlY2ssIGJvb2wgd2FpdCwKIAkJCQkJCQkg VE1fRmFpbHVyZURhdGEgKnRtZmQsIExvY2tUdXBsZU1vZGUgKmxvY2ttb2RlLAorCQkJCQkJ CSBjb25zdCBCaXRtYXBzZXQgKm1peF9hdHRycywgYm9vbCBtaXhfYXR0cnNfdmFsaWQsCiAJ CQkJCQkJIFRVX1VwZGF0ZUluZGV4ZXMgKnVwZGF0ZV9pbmRleGVzKTsKIGV4dGVybiBUTV9S ZXN1bHQgaGVhcF9sb2NrX3R1cGxlKFJlbGF0aW9uIHJlbGF0aW9uLCBIZWFwVHVwbGUgdHVw bGUsCiAJCQkJCQkJCSBDb21tYW5kSWQgY2lkLCBMb2NrVHVwbGVNb2RlIG1vZGUsIExvY2tX YWl0UG9saWN5IHdhaXRfcG9saWN5LApkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvYWNjZXNz L3RhYmxlYW0uaCBiL3NyYy9pbmNsdWRlL2FjY2Vzcy90YWJsZWFtLmgKaW5kZXggMjUxMzc5 MDE2YjAuLjNiMDgwYWEzNzExIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9hY2Nlc3MvdGFi bGVhbS5oCisrKyBiL3NyYy9pbmNsdWRlL2FjY2Vzcy90YWJsZWFtLmgKQEAgLTU0OSw2ICs1 NDksNyBAQCB0eXBlZGVmIHN0cnVjdCBUYWJsZUFtUm91dGluZQogCQkJCQkJCQkgYm9vbCB3 YWl0LAogCQkJCQkJCQkgVE1fRmFpbHVyZURhdGEgKnRtZmQsCiAJCQkJCQkJCSBMb2NrVHVw bGVNb2RlICpsb2NrbW9kZSwKKwkJCQkJCQkJIGNvbnN0IEJpdG1hcHNldCAqdXBkYXRlZF9j b2xzLAogCQkJCQkJCQkgVFVfVXBkYXRlSW5kZXhlcyAqdXBkYXRlX2luZGV4ZXMpOwogCiAJ Lyogc2VlIHRhYmxlX3R1cGxlX2xvY2soKSBmb3IgcmVmZXJlbmNlIGFib3V0IHBhcmFtZXRl cnMgKi8KQEAgLTE1MjQsMTIgKzE1MjUsMTIgQEAgc3RhdGljIGlubGluZSBUTV9SZXN1bHQK IHRhYmxlX3R1cGxlX3VwZGF0ZShSZWxhdGlvbiByZWwsIEl0ZW1Qb2ludGVyIG90aWQsIFR1 cGxlVGFibGVTbG90ICpzbG90LAogCQkJCSAgIENvbW1hbmRJZCBjaWQsIFNuYXBzaG90IHNu YXBzaG90LCBTbmFwc2hvdCBjcm9zc2NoZWNrLAogCQkJCSAgIGJvb2wgd2FpdCwgVE1fRmFp bHVyZURhdGEgKnRtZmQsIExvY2tUdXBsZU1vZGUgKmxvY2ttb2RlLAotCQkJCSAgIFRVX1Vw ZGF0ZUluZGV4ZXMgKnVwZGF0ZV9pbmRleGVzKQorCQkJCSAgIGNvbnN0IEJpdG1hcHNldCAq bWl4X2NvbHMsIFRVX1VwZGF0ZUluZGV4ZXMgKnVwZGF0ZV9pbmRleGVzKQogewogCXJldHVy biByZWwtPnJkX3RhYmxlYW0tPnR1cGxlX3VwZGF0ZShyZWwsIG90aWQsIHNsb3QsCiAJCQkJ CQkJCQkJIGNpZCwgc25hcHNob3QsIGNyb3NzY2hlY2ssCi0JCQkJCQkJCQkJIHdhaXQsIHRt ZmQsCi0JCQkJCQkJCQkJIGxvY2ttb2RlLCB1cGRhdGVfaW5kZXhlcyk7CisJCQkJCQkJCQkJ IHdhaXQsIHRtZmQsIGxvY2ttb2RlLAorCQkJCQkJCQkJCSBtaXhfY29scywgdXBkYXRlX2lu ZGV4ZXMpOwogfQogCiAvKgpAQCAtMjAxMCw2ICsyMDExLDcgQEAgZXh0ZXJuIHZvaWQgc2lt cGxlX3RhYmxlX3R1cGxlX2RlbGV0ZShSZWxhdGlvbiByZWwsIEl0ZW1Qb2ludGVyIHRpZCwK IAkJCQkJCQkJCSAgU25hcHNob3Qgc25hcHNob3QpOwogZXh0ZXJuIHZvaWQgc2ltcGxlX3Rh YmxlX3R1cGxlX3VwZGF0ZShSZWxhdGlvbiByZWwsIEl0ZW1Qb2ludGVyIG90aWQsCiAJCQkJ CQkJCQkgIFR1cGxlVGFibGVTbG90ICpzbG90LCBTbmFwc2hvdCBzbmFwc2hvdCwKKwkJCQkJ CQkJCSAgY29uc3QgQml0bWFwc2V0ICptaXhfYXR0cnMsCiAJCQkJCQkJCQkgIFRVX1VwZGF0 ZUluZGV4ZXMgKnVwZGF0ZV9pbmRleGVzKTsKIAogCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVk ZS9jYXRhbG9nL2luZGV4LmggYi9zcmMvaW5jbHVkZS9jYXRhbG9nL2luZGV4LmgKaW5kZXgg YjI1OWM0MTQxZWQuLjE0YTM5YmVhYjZlIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9jYXRh bG9nL2luZGV4LmgKKysrIGIvc3JjL2luY2x1ZGUvY2F0YWxvZy9pbmRleC5oCkBAIC0xMzIs NiArMTMyLDcgQEAgZXh0ZXJuIGJvb2wgQ29tcGFyZUluZGV4SW5mbyhjb25zdCBJbmRleElu Zm8gKmluZm8xLCBjb25zdCBJbmRleEluZm8gKmluZm8yLAogCQkJCQkJCSBjb25zdCBBdHRy TWFwICphdHRtYXApOwogCiBleHRlcm4gdm9pZCBCdWlsZFNwZWN1bGF0aXZlSW5kZXhJbmZv KFJlbGF0aW9uIGluZGV4LCBJbmRleEluZm8gKmlpKTsKK2V4dGVybiB2b2lkIEJ1aWxkVXBk YXRlSW5kZXhJbmZvKFJlc3VsdFJlbEluZm8gKnJlc3VsdFJlbEluZm8pOwogCiBleHRlcm4g dm9pZCBGb3JtSW5kZXhEYXR1bShJbmRleEluZm8gKmluZGV4SW5mbywKIAkJCQkJCSAgIFR1 cGxlVGFibGVTbG90ICpzbG90LApkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvZXhlY3V0b3Iv ZXhlY3V0b3IuaCBiL3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2V4ZWN1dG9yLmgKaW5kZXggNTVh N2Q5MzBkMjYuLjY3ZWNiMTc3MWMzIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9leGVjdXRv ci9leGVjdXRvci5oCisrKyBiL3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2V4ZWN1dG9yLmgKQEAg LTgwMCw1ICs4MDAsOCBAQCBleHRlcm4gUmVzdWx0UmVsSW5mbyAqRXhlY0xvb2t1cFJlc3Vs dFJlbEJ5T2lkKE1vZGlmeVRhYmxlU3RhdGUgKm5vZGUsCiAJCQkJCQkJCQkJCSAgIE9pZCBy ZXN1bHRvaWQsCiAJCQkJCQkJCQkJCSAgIGJvb2wgbWlzc2luZ19vaywKIAkJCQkJCQkJCQkJ ICAgYm9vbCB1cGRhdGVfY2FjaGUpOworZXh0ZXJuIEJpdG1hcHNldCAqRXhlY0NoZWNrSW5k ZXhlZEF0dHJzRm9yQ2hhbmdlcyhSZXN1bHRSZWxJbmZvICpyZWxpbmZvLAorCQkJCQkJCQkJ CQkJICBUdXBsZVRhYmxlU2xvdCAqb2xkX3R0cywKKwkJCQkJCQkJCQkJCSAgVHVwbGVUYWJs ZVNsb3QgKm5ld190dHMpOwogCiAjZW5kaWYJCQkJCQkJLyogRVhFQ1VUT1JfSCAgKi8KZGlm ZiAtLWdpdCBhL3NyYy9pbmNsdWRlL25vZGVzL2V4ZWNub2Rlcy5oIGIvc3JjL2luY2x1ZGUv bm9kZXMvZXhlY25vZGVzLmgKaW5kZXggNjNjMDY3ZDVhYWUuLjEzMjg0ZGJkNzBiIDEwMDY0 NAotLS0gYS9zcmMvaW5jbHVkZS9ub2Rlcy9leGVjbm9kZXMuaAorKysgYi9zcmMvaW5jbHVk ZS9ub2Rlcy9leGVjbm9kZXMuaApAQCAtNTAyLDYgKzUwMiwxMiBAQCB0eXBlZGVmIHN0cnVj dCBSZXN1bHRSZWxJbmZvCiAJLyogdHJ1ZSBpZiB0aGUgYWJvdmUgaGFzIGJlZW4gY29tcHV0 ZWQgKi8KIAlib29sCQlyaV9leHRyYVVwZGF0ZWRDb2xzX3ZhbGlkOwogCisJLyoKKwkgKiBG b3IgVVBEQVRFIGEgQml0bWFwc2V0IG9mIHRoZSBhdHRyaWJ1dGVzIHRoYXQgYXJlIGJvdGgg aW5kZXhlZCBhbmQgaGF2ZQorCSAqIGNoYW5nZWQgaW4gdmFsdWUuCisJICovCisJQml0bWFw c2V0ICAqcmlfQ2hhbmdlZEluZGV4ZWRDb2xzOworCiAJLyogUHJvamVjdGlvbiB0byBnZW5l cmF0ZSBuZXcgdHVwbGUgaW4gYW4gSU5TRVJUL1VQREFURSAqLwogCVByb2plY3Rpb25JbmZv ICpyaV9wcm9qZWN0TmV3OwogCS8qIFNsb3QgdG8gaG9sZCB0aGF0IHR1cGxlICovCmRpZmYg LS1naXQgYS9zcmMvaW5jbHVkZS91dGlscy9yZWwuaCBiL3NyYy9pbmNsdWRlL3V0aWxzL3Jl bC5oCmluZGV4IDIzNjgzMGY2YjkzLi5kZjU0MjZmZDdmYiAxMDA2NDQKLS0tIGEvc3JjL2lu Y2x1ZGUvdXRpbHMvcmVsLmgKKysrIGIvc3JjL2luY2x1ZGUvdXRpbHMvcmVsLmgKQEAgLTE2 NCw2ICsxNjQsNyBAQCB0eXBlZGVmIHN0cnVjdCBSZWxhdGlvbkRhdGEKIAlCaXRtYXBzZXQg ICpyZF9pZGF0dHI7CQkvKiBpbmNsdWRlZCBpbiByZXBsaWNhIGlkZW50aXR5IGluZGV4ICov CiAJQml0bWFwc2V0ICAqcmRfaG90YmxvY2tpbmdhdHRyOyAvKiBjb2xzIGJsb2NraW5nIEhP VCB1cGRhdGUgKi8KIAlCaXRtYXBzZXQgICpyZF9zdW1tYXJpemVkYXR0cjsJLyogY29scyBp bmRleGVkIGJ5IHN1bW1hcml6aW5nIGluZGV4ZXMgKi8KKwlCaXRtYXBzZXQgICpyZF9pbmRl eGVkYXR0cjsgLyogYWxsIGNvbHMgcmVmZXJlbmNlZCBieSBpbmRleGVzICovCiAKIAlQdWJs aWNhdGlvbkRlc2MgKnJkX3B1YmRlc2M7CS8qIHB1YmxpY2F0aW9uIGRlc2NyaXB0b3IsIG9y IE5VTEwgKi8KIApkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvdXRpbHMvcmVsY2FjaGUuaCBi L3NyYy9pbmNsdWRlL3V0aWxzL3JlbGNhY2hlLmgKaW5kZXggMjcwMDIyNDkzOWEuLjU4MzRh YjdiOTAzIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS91dGlscy9yZWxjYWNoZS5oCisrKyBi L3NyYy9pbmNsdWRlL3V0aWxzL3JlbGNhY2hlLmgKQEAgLTcxLDYgKzcxLDcgQEAgdHlwZWRl ZiBlbnVtIEluZGV4QXR0ckJpdG1hcEtpbmQKIAlJTkRFWF9BVFRSX0JJVE1BUF9JREVOVElU WV9LRVksCiAJSU5ERVhfQVRUUl9CSVRNQVBfSE9UX0JMT0NLSU5HLAogCUlOREVYX0FUVFJf QklUTUFQX1NVTU1BUklaRUQsCisJSU5ERVhfQVRUUl9CSVRNQVBfSU5ERVhFRCwKIH0gSW5k ZXhBdHRyQml0bWFwS2luZDsKIAogZXh0ZXJuIEJpdG1hcHNldCAqUmVsYXRpb25HZXRJbmRl eEF0dHJCaXRtYXAoUmVsYXRpb24gcmVsYXRpb24sCi0tIAoyLjUxLjIKCg== --a067f11d97b94211b4d5ca22476a83fd--