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.94.2) (envelope-from ) id 1rOKcM-003IWJ-EO for pgsql-hackers@arkaria.postgresql.org; Fri, 12 Jan 2024 16:42:51 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.94.2) (envelope-from ) id 1rOKcL-003TFH-Dm for pgsql-hackers@arkaria.postgresql.org; Fri, 12 Jan 2024 16:42: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.94.2) (envelope-from ) id 1rOKcK-003TEe-Uu for pgsql-hackers@lists.postgresql.org; Fri, 12 Jan 2024 16:42:49 +0000 Received: from mail-ej1-x629.google.com ([2a00:1450:4864:20::629]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.94.2) (envelope-from ) id 1rOKcE-001DVl-U6 for pgsql-hackers@lists.postgresql.org; Fri, 12 Jan 2024 16:42:47 +0000 Received: by mail-ej1-x629.google.com with SMTP id a640c23a62f3a-a28da6285c1so1201484266b.0 for ; Fri, 12 Jan 2024 08:42:42 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=enterprisedb.com; s=google; t=1705077761; x=1705682561; darn=lists.postgresql.org; h=in-reply-to:from:content-language:references:cc:to:subject :user-agent:mime-version:date:message-id:from:to:cc:subject:date :message-id:reply-to; bh=jyMnEsXle3q9s+DY9fPX1vCoBXt3BIH4Ey19+JXKCsA=; b=TGSSbZjbNOT5p4MMqO1DHVvRUmCPGyqVfkVW9sNLctCEU7MQeGNkdjZCHK3SvzqiaN 4ZW3j4WPQoCEiXAn+tniQQmvi5hPq6dRa6+xxpvPuha9cim7qYpqX9RLBzDt9RVNYIDi fv3MZ2nMSREWaZSwCJg9DPeCmoB5RF3Mtd6AFd+9snU4I1Lk6+aLHKxDR0qgTzl/A7lI awd4VRpwq1fXJsJA8PtmT6z3l/Np/qBWsIUibm8WK4kmYRMFzaJSL1W1XbjTTwHfcrUn Vmlp/GBbmb/3L6sKdME1Gv4wS5t30nWluaR0WmXrVnRWOKi7rBURe/swC+i+2QaRUNeV b3hw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1705077761; x=1705682561; h=in-reply-to:from:content-language:references:cc:to:subject :user-agent:mime-version:date:message-id:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=jyMnEsXle3q9s+DY9fPX1vCoBXt3BIH4Ey19+JXKCsA=; b=Rd7ghmqMVA+I3dSR4FbZKb+QEJZ0ZYo+tbyemLLWtMjBMD+7OOpcRtgkEx0s6cs4FM z86Br0WDfRXeB7KYjEZ5ISULrfOEkIKewKyvpwaZyW7CEh4gZ5yQWpIuQsogpK9RwP92 86u0z1IzM/jxAjkGA23HKlEVsF2I67qx3gMn23/tRn84kXazCZ7brIPlHs1ZxGU81AQ1 IGEmoUjyj8LAsOejCtFdheU22zrzyNbyQTH4bGOp3G2yiv6gdmbQ1zI1nhxflt7VgSI4 HNgcRIgNcO88Vb2ncz3c4MG9H6TpoRu7xDMiGbH7susrXf1WZjJCjnfzTX0W5PGLLvXn rtOw== X-Gm-Message-State: AOJu0Yw3/TYukvCCIN+HEhWTKVlJCxAEj8wzi6JUMW2O7VMJx9QV4I4H 8rpYjPD0dxz38giCHg1fzsavveq0jeyv X-Google-Smtp-Source: AGHT+IGWCts1tmg/JVeDP9rKnLzguAE2pjlZOr00NRoYxDCzWO8q/aQbbIlhC+yDS56I8SahIa9mjw== X-Received: by 2002:a17:906:b0d2:b0:a2a:dc24:849 with SMTP id bk18-20020a170906b0d200b00a2adc240849mr1559350ejb.43.1705077761059; Fri, 12 Jan 2024 08:42:41 -0800 (PST) Received: from [10.137.0.18] (srv1.mobissw.com. [89.235.0.226]) by smtp.gmail.com with ESMTPSA id xo16-20020a170907bb9000b00a26aa5c5a60sm1992806ejc.19.2024.01.12.08.42.40 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Fri, 12 Jan 2024 08:42:40 -0800 (PST) Content-Type: multipart/mixed; boundary="------------rk0Ajra5AwFQP08i7beMRGga" Message-ID: <482ec3ff-52ad-415d-96fd-f3832a894023@enterprisedb.com> Date: Fri, 12 Jan 2024 17:42:39 +0100 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: index prefetching To: Robert Haas Cc: Andres Freund , PostgreSQL Hackers , Georgios References: <8ec36f51-b863-60e3-20e2-b9c981c5ce5e@enterprisedb.com> <06bb7d02-2c44-3062-731e-a735ba13da7e@enterprisedb.com> <367160ea-b1ed-4481-e804-bca509128878@enterprisedb.com> <280dc83c-a16f-4424-1319-95e7e3f798bd@enterprisedb.com> <98ba4b25-fae8-c1f4-1597-8093375a1986@enterprisedb.com> <20231221134314.wf2rs62d37u62j7t@alap3.anarazel.de> <20231221154352.ijtg6wloa3nowivh@alap3.anarazel.de> Content-Language: en-US From: Tomas Vondra In-Reply-To: List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk This is a multi-part message in MIME format. --------------rk0Ajra5AwFQP08i7beMRGga Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Hi, Here's an improved version of this patch, finishing a lot of the stuff that I alluded to earlier - moving the code from indexam.c, renaming a bunch of stuff, etc. I've also squashed it into a single patch, to make it easier to review. I'll briefly go through the main changes in the patch, and then will respond in-line to Robert's points. 1) I moved the code from indexam.c to (new) execPrefetch.c. All the prototypes / typedefs now live in executor.h, with only minimal changes in execnodes.h (adding it to scan descriptors). I believe this finally moves the code to the right place - it feels much nicer and cleaner than in indexam.c. And it allowed me to hide a bunch of internal structs and improve the general API, I think. I'm sure there's stuff that could be named differently, but the layering feels about right, I think. 2) A bunch of stuff got renamed to start with IndexPrefetch... to make the naming consistent / clearer. I'm not entirely sure IndexPrefetch is the right name, though - it's still a bit misleading, as it might seem it's about prefetching index stuff, but really it's about heap pages from indexes. Maybe IndexScanPrefetch() or something like that? 3) If there's a way to make this work with the streaming I/O API, I'm not aware of it. But the overall design seems somewhat similar (based on "next" callback etc.) so hopefully that'd make it easier to adopt it. 4) I initially relied on parallelModeOK to disable prefetching, which kinda worked, but not really. Robert suggested to use the execute_once flag directly, and I think that's much better - not only is it cleaner, it also seems more appropriate (the parallel flag considers other stuff that is not quite relevant to prefetching). Thinking about this, I think it should be possible to make prefetching work even for plans with execute_once=false. In particular, when the plan changes direction it should be possible to simply "walk back" the prefetch queue, to get to the "correct" place in in the scan. But I'm not sure it's worth it, because plans that change direction often can't really benefit from prefetches anyway - they'll often visit stuff they accessed shortly before anyway. For plans that don't change direction but may pause, we don't know if the plan pauses long enough for the prefetched pages to get evicted or something. So I think it's OK that execute_once=false means no prefetching. 5) I haven't done anything about the xs_heap_continue=true case yet. 6) I went through all the comments and reworked them considerably. The main comment at execPrefetch.c start, with some overall design etc. And then there are comments for each function, explaining that bit in more detail. Or at least that's the goal - there's still work to do. There's two trivial FIXMEs, but you can ignore those - it's not that there's a bug, but that I'd like to rework something and just don't know how yet. There's also a couple of XXX comments. Some are a bit wild ideas for the future, others are somewhat "open questions" to be discussed during a review. Anyway, there should be no outright obsolete comments - if there's something I missed, let me know. Now to Robert's message ... On 1/9/24 21:31, Robert Haas wrote: > On Thu, Jan 4, 2024 at 9:55 AM Tomas Vondra > wrote: >> Here's a somewhat reworked version of the patch. My initial goal was to >> see if it could adopt the StreamingRead API proposed in [1], but that >> turned out to be less straight-forward than I hoped, for two reasons: > > I guess we need Thomas or Andres or maybe Melanie to comment on this. > Yeah. Or maybe Thomas if he has thoughts on how to combine this with the streaming I/O stuff. >> Perhaps a bigger change is that I decided to move this into a separate >> API on top of indexam.c. The original idea was to integrate this into >> index_getnext_tid/index_getnext_slot, so that all callers benefit from >> the prefetching automatically. Which would be nice, but it also meant >> it's need to happen in the indexam.c code, which seemed dirty. > > This patch is hard to review right now because there's a bunch of > comment updating that doesn't seem to have been done for the new > design. For instance: > > + * XXX This does not support prefetching of heap pages. When such > prefetching is > + * desirable, use index_getnext_tid(). > > But not any more. > True. And this is now even more obsolete, as the prefetching was moved from indexam.c layer to the executor. > + * XXX The prefetching may interfere with the patch allowing us to evaluate > + * conditions on the index tuple, in which case we may not need the heap > + * tuple. Maybe if there's such filter, we should prefetch only pages that > + * are not all-visible (and the same idea would also work for IOS), but > + * it also makes the indexing a bit "aware" of the visibility stuff (which > + * seems a somewhat wrong). Also, maybe we should consider the filter > selectivity > > I'm not sure whether all the problems in this area are solved, but I > think you've solved enough of them that this at least needs rewording, > if not removing. > > + * XXX Comment/check seems obsolete. > > This occurs in two places. I'm not sure if it's accurate or not. > > + * XXX Could this be an issue for the prefetching? What if we > prefetch something > + * but the direction changes before we get to the read? If that > could happen, > + * maybe we should discard the prefetched data and go back? But can we even > + * do that, if we already fetched some TIDs from the index? I don't think > + * indexorderdir can't change, but es_direction maybe can? > > But your email claims that "The patch simply disables prefetching for > such queries, using the same logic that we do for parallelism." FWIW, > I think that's a fine way to handle that case. > True. I left behind this comment partly intentionally, to point out why we disable the prefetching in these cases, but you're right the comment now explains something that can't happen. > + * XXX Maybe we should enable prefetching, but prefetch only pages that > + * are not all-visible (but checking that from the index code seems like > + * a violation of layering etc). > > Isn't this fixed now? Note this comment occurs twice. > > + * XXX We need to disable this in some cases (e.g. when using index-only > + * scans, we don't want to prefetch pages). Or maybe we should prefetch > + * only pages that are not all-visible, that'd be even better. > > Here again. > Sorry, you're right those comments (and a couple more nearby) were stale. Removed / clarified. > And now for some comments on other parts of the patch, mostly other > XXX comments: > > + * XXX This does not support prefetching of heap pages. When such > prefetching is > + * desirable, use index_getnext_tid(). > > There's probably no reason to write XXX here. The comment is fine. > > + * XXX Notice we haven't added the block to the block queue yet, and there > + * is a preceding block (i.e. blockIndex-1 is valid). > > Same here, possibly? If this XXX indicates a defect in the code, I > don't know what the defect is, so I guess it needs to be more clear. > If it is just explaining the code, then there's no reason for the > comment to say XXX. > Yeah, removed the XXX / reworded a bit. > + * XXX Could it be harmful that we read the queue backwards? Maybe memory > + * prefetching works better for the forward direction? > > It does. But I don't know whether that matters here or not. > > + * XXX We do add the cache size to the request in order not to > + * have issues with uint64 underflows. > > I don't know what this means. > There's a check that does this: (x + PREFETCH_CACHE_SIZE) >= y it might also be done as "mathematically equivalent" x >= (y - PREFETCH_CACHE_SIZE) but if the "y" is an uint64, and the value is smaller than the constant, this would underflow. It'd eventually disappear, once the "y" gets large enough, ofc. > + * XXX not sure this correctly handles xs_heap_continue - see > index_getnext_slot, > + * maybe nodeIndexscan needs to do something more to handle this? > Although, that > + * should be in the indexscan next_cb callback, probably. > + * > + * XXX If xs_heap_continue=true, we need to return the last TID. > > You've got a bunch of comments about xs_heap_continue here -- and I > don't fully understand what the issues are here with respect to this > particular patch, but I think that the general purpose of > xs_heap_continue is to handle the case where we need to return more > than one tuple from the same HOT chain. With an MVCC snapshot that > doesn't happen, but with say SnapshotAny or SnapshotDirty, it could. > As far as possible, the prefetcher shouldn't be involved at all when > xs_heap_continue is set, I believe, because in that case we're just > returning a bunch of tuples from the same page, and the extra fetches > from that heap page shouldn't trigger or require any further > prefetching. > Yes, that's correct. The current code simply ignores that flag and just proceeds to the next TID. Which is correct for xs_heap_continue=false, and thus all MVCC snapshots work fine. But for the Any/Dirty case it needs to work a bit differently. > + * XXX Should this also look at plan.plan_rows and maybe cap the target > + * to that? Pointless to prefetch more than we expect to use. Or maybe > + * just reset to that value during prefetching, after reading the next > + * index page (or rather after rescan)? > > It seems questionable to use plan_rows here because (1) I don't think > we have existing cases where we use the estimated row count in the > executor for anything, we just carry it through so EXPLAIN can print > it and (2) row count estimates can be really far off, especially if > we're on the inner side of a nested loop, we might like to figure that > out eventually instead of just DTWT forever. But on the other hand > this does feel like an important case where we have a clue that > prefetching might need to be done less aggressively or not at all, and > it doesn't seem right to ignore that signal either. I wonder if we > want this shaped in some other way, like a Boolean that says > are-we-under-a-potentially-row-limiting-construct e.g. limit or inner > side of a semi-join or anti-join. > The current code actually does look at plan_rows when calculating the prefetch target: prefetch_max = IndexPrefetchComputeTarget(node->ss.ss_currentRelation, node->ss.ps.plan->plan_rows, estate->es_use_prefetching); but I agree maybe it should not, for the reasons you explain. I'm not attached to this part. > + * We reach here if the index only scan is not parallel, or if we're > + * serially executing an index only scan that was planned to be > + * parallel. > > Well, this seems sad. > Stale comment, I believe. However, I didn't see much benefits with parallel index scan during testing. Having I/O from multiple workers generally had the same effect, I think. > + * XXX This might lead to IOS being slower than plain index scan, if the > + * table has a lot of pages that need recheck. > > How? > The comment is not particularly clear what "this" means, but I believe this was about index-only scan with many not-all-visible pages. If it didn't do prefetching, a regular index scan with prefetching may be way faster. But the code actually allows doing prefetching even for IOS, by checking the vm in the "next" callback. > + /* > + * XXX Only allow index prefetching when parallelModeOK=true. This is a bit > + * of a misuse of the flag, but we need to disable prefetching for cursors > + * (which might change direction), and parallelModeOK does that. But maybe > + * we might (or should) have a separate flag. > + */ > > I think the correct flag to be using here is execute_once, which > captures whether the executor could potentially be invoked a second > time for the same portal. Changes in the fetch direction are possible > if and only if !execute_once. > Right. The new patch version does that. >> Note 1: The IndexPrefetch name is a bit misleading, because it's used >> even with prefetching disabled - all index reads from the index scan >> happen through it. Maybe it should be called IndexReader or something >> like that. > > My biggest gripe here is the capitalization. This version adds, inter > alia, IndexPrefetchAlloc, PREFETCH_QUEUE_INDEX, and > index_heap_prefetch_target, which seems like one or two too many > conventions. But maybe the PREFETCH_* macros don't even belong in a > public header. > > I do like the index_heap_prefetch_* naming. Possibly that's too > verbose to use for everything, but calling this index-heap-prefetch > rather than index-prefetch seems clearer. > Yeah. I renamed all the structs and functions to IndexPrefetchSomething, to keep it consistent. And then the constants are all capital, ofc. regards -- Tomas Vondra EnterpriseDB: http://www.enterprisedb.com The Enterprise PostgreSQL Company --------------rk0Ajra5AwFQP08i7beMRGga Content-Type: text/x-patch; charset=UTF-8; name="v20240112-0001-Prefetch-heap-pages-during-index-scans.patch" Content-Disposition: attachment; filename*0="v20240112-0001-Prefetch-heap-pages-during-index-scans.patch" Content-Transfer-Encoding: base64 RnJvbSBhM2Y5OWNjMGFhYTY0ZWY5NGIwOWZjMGE1OGJlZTcwOWNkMjlhZGQ5IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBUb21hcyBWb25kcmEgPHRvbWFzQDJuZHF1YWRyYW50 LmNvbT4KRGF0ZTogRnJpLCAxNyBOb3YgMjAyMyAyMzo1NDoxOSArMDEwMApTdWJqZWN0OiBb UEFUQ0ggdjIwMjQwMTEyXSBQcmVmZXRjaCBoZWFwIHBhZ2VzIGR1cmluZyBpbmRleCBzY2Fu cwoKSW5kZXggc2NhbnMgYXJlIGEgc2lnbmlmaWNhbnQgc291cmNlIG9mIHJhbmRvbSBJL08g b24gdGhlIGluZGV4ZWQgaGVhcCwKYnV0IGNhbid0IGJlbmVmaXQgZnJvbSBrZXJuZWwgcmVh ZC1haGVhZC4gRm9yIGJpdG1hcCBzY2FucyB0aGF0IGlzIG5vdAphbiBpc3N1ZSwgYmVjYXVz ZSB0aGV5IGRvIHByZWZldGNoIGV4cGxpY2l0bHksIGJ1dCBmb3IgcGxhaW4gaW5kZXggc2Nh bnMKdGhpcyBpcyBhIG1ham9yIGJvdHRsZW5lY2sgLSByZWFkaW5nIHBhZ2UgYXQgYSB0aW1l IGRvZXMgbm90IGFsbG93CnNhdHVyYXRpbmcgbW9kZXJuIHN0b3JhZ2Ugc3lzdGVtcy4KClRo aXMgZW5oYW5jZXMgaW5kZXggc2NhbnMgKGluY2x1ZGluZyBpbmRleC1vbmx5IHNjYW5zKSB0 byBwcmVmZXRjaCBoZWFwCnBhZ2VzLiBUaGUgc2NhbiBtYWludGFpbnMgYSBxdWV1ZSBvZiBm dXR1cmUgVElEcyByZWNlaXZlZCBmcm9tIGFuIGluZGV4LApwcmVmZXRjaCB0aGUgYXNzb2Np YXRlZCBoZWFwIHBhZ2UsIGFuZCB0aGVuIGV2ZW50dWFsbHkgcGFzcyB0aGUgVElEIHRvCnRo ZSBjYWxsZXIuCgpUbyBlbGltaW5hdGUgdW5uZWNlc3NhcnkgcHJlZmV0Y2hlcywgYSBzbWFs bCBjYWNoZSBvZiByZWNlbnQgcHJlZmV0Y2hlcwppcyBtYWludGFpbmVkLCBhbmQgdGhlIHBy ZWZldGNoZXMgYXJlIHNraXBwZWQuIEZ1cnRoZXJtb3JlLCBzZXF1ZW50aWFsCmFjY2VzcyBw YXR0ZXJucyBhcmUgZGV0ZWN0ZWQgYW5kIG5vdCBwcmVmZXRjaGVkLCBvbiB0aGUgYXNzdW1w dGlvbiB0aGF0CnRoZSBrZXJuZWwgcmVhZC1haGVhZCB3aWxsIGRvIHRoaXMgbW9yZSBlZmZp Y2llbnRseS4KClRoZXNlIG9wdGltaXphdGlvbnMgYXJlIGJlc3QtZWZmb3J0IGhldXJpc3Rp Y3MgLSB3ZSBkb24ndCBrbm93IGlmIHRoZQprZXJuZWwgd2lsbCBhY3R1YWxseSBwcmVmZXRj aCB0aGUgcGFnZXMgb24gaXQncyBvd24sIGFuZCB3ZSBjYW4ndCBlYXNpbHkKY2hlY2sgdGhh dC4gTW9yZW92ZXIsIGRpZmZlcmVudCBrZXJuZWxzIChhbmQga2VybmVsKSB2ZXJzaW9ucyBt YXkgYmVoYXZlCmRpZmZlcmVudGx5LgoKTm90ZTogRm9yIHNoYXJlZCBidWZmZXJzIHdlIGNh biBlYXNpbHkgY2hlY2sgaWYgYSBwYWdlIGlzIGNhY2hlZCwgYW5kCnRoZSBQcmVmZXRjaEJ1 ZmZlcigpIGZ1bmN0aW9uIGFscmVhZHkgdGFrZXMgY2FyZSBvZiB0aGF0LiBUaGVzZQpvcHRp bWl6YXRpb25zIGFyZSBwcmltYXJpbHkgYWJvdXQgdGhlIHBhZ2UgY2FjaGUuCgpUaGUgcHJl ZmV0Y2hpbmcgaXMgYWxzbyBkaXNhYmxlZCBmb3IgcGxhbnMgdGhhdCBtYXkgbm90IGJlIGV4 ZWN1dGVkIG9ubHkKb25jZSAtIHRoZXNlIHBsYW5zIG1heSBjaGFuZ2UgZGlyZWN0aW9uLCBp bnRlcmZlcmluZyB3aXRoIHRoZSBwcmVmZXRjaApxdWV1ZS4gQ29uc2lkZXIgc2Nyb2xsYWJs ZSBjdXJzb3JzIHdpdGggYmFja3dhcmRzIHNjYW5zLiBUaGlzIG1pZ2h0IGdldAppbXByb3Zl ZCB0byBhbGxvdyB0aGUgcHJlZmV0Y2hlciB0byBoYW5kbGUgZGlyZWN0aW9uIGNoYW5nZXMs IGJ1dCBpdCdzCm5vdCBjbGVhciBpZiBpdCdzIHdvcnRoIGl0LgoKTm90ZTogSWYgYSBwbGFu IGNoYW5nZXMgdGhlIHNjYW4gZGlyZWN0aW9uLCB0aGF0IGluaGVyZW50bHkgd2FzdGVzIHRo ZQppc3N1ZWQgcHJlZmV0Y2hlcy4gSWYgdGhlIGRpcmVjdGlvbiBjaGFuZ2VzIG9mdGVuLCBp dCBsaWtlbHkgbWVhbnMgYSBsb3QKb2YgdGhlIHBhZ2VzIGFyZSBzdGlsbCBjYWNoZWQuIFNp bWlsYXJseSwgaWYgYSBwbGFuIHBhdXNlcyBmb3IgYSBsb25nCnRpbWUsIHRoZSBhbHJlYWR5 IHByZWZldGNoZWQgcGFnZXMgbWF5IGdldCBldmljdGVkLgotLS0KIHNyYy9iYWNrZW5kL2Nv bW1hbmRzL2V4cGxhaW4uYyAgICAgICAgICAgfCAgMTggKwogc3JjL2JhY2tlbmQvZXhlY3V0 b3IvTWFrZWZpbGUgICAgICAgICAgICB8ICAgMSArCiBzcmMvYmFja2VuZC9leGVjdXRvci9l eGVjTWFpbi5jICAgICAgICAgIHwgIDEyICsKIHNyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNQ cmVmZXRjaC5jICAgICAgfCA4ODQgKysrKysrKysrKysrKysrKysrKysrKysKIHNyYy9iYWNr ZW5kL2V4ZWN1dG9yL2luc3RydW1lbnQuYyAgICAgICAgfCAgIDQgKwogc3JjL2JhY2tlbmQv ZXhlY3V0b3Ivbm9kZUluZGV4b25seXNjYW4uYyB8IDExMyArKy0KIHNyYy9iYWNrZW5kL2V4 ZWN1dG9yL25vZGVJbmRleHNjYW4uYyAgICAgfCAgNjggKy0KIHNyYy9pbmNsdWRlL2V4ZWN1 dG9yL2V4ZWN1dG9yLmggICAgICAgICAgfCAgNTIgKysKIHNyYy9pbmNsdWRlL2V4ZWN1dG9y L2luc3RydW1lbnQuaCAgICAgICAgfCAgIDIgKwogc3JjL2luY2x1ZGUvbm9kZXMvZXhlY25v ZGVzLmggICAgICAgICAgICB8ICAxMCArCiBzcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMu bGlzdCAgICAgICAgIHwgICAzICsKIDExIGZpbGVzIGNoYW5nZWQsIDExNjIgaW5zZXJ0aW9u cygrKSwgNSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzcmMvYmFja2VuZC9l eGVjdXRvci9leGVjUHJlZmV0Y2guYwoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1h bmRzL2V4cGxhaW4uYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2V4cGxhaW4uYwppbmRleCAz ZDU5MGE2YjlmNS4uOWJiZTI3MGFiN2QgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1h bmRzL2V4cGxhaW4uYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy9leHBsYWluLmMKQEAg LTM1NjgsNiArMzU2OCw3IEBAIHNob3dfYnVmZmVyX3VzYWdlKEV4cGxhaW5TdGF0ZSAqZXMs IGNvbnN0IEJ1ZmZlclVzYWdlICp1c2FnZSwgYm9vbCBwbGFubmluZykKIAkJCQkJCQkJCQkh SU5TVFJfVElNRV9JU19aRVJPKHVzYWdlLT5sb2NhbF9ibGtfd3JpdGVfdGltZSkpOwogCQli b29sCQloYXNfdGVtcF90aW1pbmcgPSAoIUlOU1RSX1RJTUVfSVNfWkVSTyh1c2FnZS0+dGVt cF9ibGtfcmVhZF90aW1lKSB8fAogCQkJCQkJCQkJICAgIUlOU1RSX1RJTUVfSVNfWkVSTyh1 c2FnZS0+dGVtcF9ibGtfd3JpdGVfdGltZSkpOworCQlib29sCQloYXNfcHJlZmV0Y2hlcyA9 ICh1c2FnZS0+Ymxrc19wcmVmZXRjaGVzID4gMCk7CiAJCWJvb2wJCXNob3dfcGxhbm5pbmcg PSAocGxhbm5pbmcgJiYgKGhhc19zaGFyZWQgfHwKIAkJCQkJCQkJCQkJCSAgaGFzX2xvY2Fs IHx8IGhhc190ZW1wIHx8CiAJCQkJCQkJCQkJCQkgIGhhc19zaGFyZWRfdGltaW5nIHx8CkBA IC0zNjc5LDYgKzM2ODAsMjMgQEAgc2hvd19idWZmZXJfdXNhZ2UoRXhwbGFpblN0YXRlICpl cywgY29uc3QgQnVmZmVyVXNhZ2UgKnVzYWdlLCBib29sIHBsYW5uaW5nKQogCQkJYXBwZW5k U3RyaW5nSW5mb0NoYXIoZXMtPnN0ciwgJ1xuJyk7CiAJCX0KIAorCQkvKiBBcyBhYm92ZSwg c2hvdyBvbmx5IHBvc2l0aXZlIGNvdW50ZXIgdmFsdWVzLiAqLworCQlpZiAoaGFzX3ByZWZl dGNoZXMpCisJCXsKKwkJCUV4cGxhaW5JbmRlbnRUZXh0KGVzKTsKKwkJCWFwcGVuZFN0cmlu Z0luZm9TdHJpbmcoZXMtPnN0ciwgIlByZWZldGNoZXM6Iik7CisKKwkJCWlmICh1c2FnZS0+ Ymxrc19wcmVmZXRjaGVzID4gMCkKKwkJCQlhcHBlbmRTdHJpbmdJbmZvKGVzLT5zdHIsICIg YmxvY2tzPSVsbGQiLAorCQkJCQkJCQkgKGxvbmcgbG9uZykgdXNhZ2UtPmJsa3NfcHJlZmV0 Y2hlcyk7CisKKwkJCWlmICh1c2FnZS0+Ymxrc19wcmVmZXRjaF9yb3VuZHMgPiAwKQorCQkJ CWFwcGVuZFN0cmluZ0luZm8oZXMtPnN0ciwgIiByb3VuZHM9JWxsZCIsCisJCQkJCQkJCSAo bG9uZyBsb25nKSB1c2FnZS0+Ymxrc19wcmVmZXRjaF9yb3VuZHMpOworCisJCQlhcHBlbmRT dHJpbmdJbmZvQ2hhcihlcy0+c3RyLCAnXG4nKTsKKwkJfQorCiAJCWlmIChzaG93X3BsYW5u aW5nKQogCQkJZXMtPmluZGVudC0tOwogCX0KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4 ZWN1dG9yL01ha2VmaWxlIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvTWFrZWZpbGUKaW5kZXgg MTExMThkMGNlMDIuLjg0MGY1YTY1OTZhIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9leGVj dXRvci9NYWtlZmlsZQorKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9NYWtlZmlsZQpAQCAt MjQsNiArMjQsNyBAQCBPQkpTID0gXAogCWV4ZWNNYWluLm8gXAogCWV4ZWNQYXJhbGxlbC5v IFwKIAlleGVjUGFydGl0aW9uLm8gXAorCWV4ZWNQcmVmZXRjaC5vIFwKIAlleGVjUHJvY25v ZGUubyBcCiAJZXhlY1JlcGxpY2F0aW9uLm8gXAogCWV4ZWNTUkYubyBcCmRpZmYgLS1naXQg YS9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjTWFpbi5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0 b3IvZXhlY01haW4uYwppbmRleCAxM2E5YjdkYTgzYi4uZTNlOTEzMWJkNjIgMTAwNjQ0Ci0t LSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNNYWluLmMKKysrIGIvc3JjL2JhY2tlbmQv ZXhlY3V0b3IvZXhlY01haW4uYwpAQCAtMTY0NSw2ICsxNjQ1LDE4IEBAIEV4ZWN1dGVQbGFu KEVTdGF0ZSAqZXN0YXRlLAogCSAqLwogCWVzdGF0ZS0+ZXNfZGlyZWN0aW9uID0gZGlyZWN0 aW9uOwogCisJLyoKKwkgKiBFbmFibGUgcHJlZmV0Y2hpbmcgb25seSBpZiB0aGUgcGxhbiBp cyBleGVjdXRlZCBleGFjdGx5IG9uY2UuIFdlIG5lZWQKKwkgKiB0byBkaXNhYmxlIHByZWZl dGNoaW5nIGZvciBjYXNlcyB3aGVuIHRoZSBzY2FuIGRpcmVjdGlvbiBtYXkgY2hhbmdlCisJ ICogKGUuZy4gZm9yIHNjcm9sbGFibGUgY3Vyc29ycykuCisJICoKKwkgKiBYWFggSXQgbWln aHQgYmUgcG9zc2libGUgdG8gaW1wcm92ZSB0aGUgcHJlZmV0Y2hpbmcgY29kZSB0byBoYW5k bGUgdGhpcworCSAqIGJ5ICJ3YWxraW5nIGJhY2siIHRoZSBUSUQgcXVldWUsIGJ1dCBpdCdz IG5vdCBjbGVhciBpZiBpdCdzIHdvcnRoIGl0LgorCSAqIEFuZCBpZiB0aGVyZSBwYXVzZXMg aW4gYmV0d2VlbiB0aGUgZmV0Y2hlcywgdGhlIHByZWZldGNoZWQgcGFnZXMgbWF5CisJICog Z2V0IGV2aWN0ZWQsIHdhc3RpbmcgdGhlIHByZWZldGNoIGVmZm9ydC4KKwkgKi8KKwllc3Rh dGUtPmVzX3VzZV9wcmVmZXRjaGluZyA9IGV4ZWN1dGVfb25jZTsKKwogCS8qCiAJICogSWYg dGhlIHBsYW4gbWlnaHQgcG90ZW50aWFsbHkgYmUgZXhlY3V0ZWQgbXVsdGlwbGUgdGltZXMs IHdlIG11c3QgZm9yY2UKIAkgKiBpdCB0byBydW4gd2l0aG91dCBwYXJhbGxlbGlzbSwgYmVj YXVzZSB3ZSBtaWdodCBleGl0IGVhcmx5LgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhl Y3V0b3IvZXhlY1ByZWZldGNoLmMgYi9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjUHJlZmV0 Y2guYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uMDAwYmI3OTZk NTEKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjUHJlZmV0 Y2guYwpAQCAtMCwwICsxLDg4NCBAQAorLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgKgorICog ZXhlY1ByZWZldGNoLmMKKyAqCSAgcm91dGluZXMgZm9yIHByZWZldGNoaW5nIGhlYXAgcGFn ZXMgZm9yIGluZGV4IHNjYW5zLgorICoKKyAqIFRoZSBJbmRleFByZWZldGNoIG5vZGUgcmVw cmVzZW50cyBhbiAiaW5kZXggcHJlZmV0Y2hlciIgd2hpY2ggcmVhZHMgVElEcworICogZnJv bSBhbiBpbmRleCBzY2FuLCBhbmQgcHJlZmV0Y2hlcyB0aGUgcmVmZXJlbmNlZCBoZWFwIHBh Z2VzLiBUaGUgYmFzaWMKKyAqIEFQSSBjb25zaXN0cyBvZiB0aGVzZSBtZXRob2RzOgorICoK KyAqCUluZGV4UHJlZmV0Y2hBbGxvYyAtIGFsbG9jYXRlIEluZGV4UHJlZmV0Y2ggd2l0aCBj dXN0b20gY2FsbGJhY2tzCisgKglJbmRleFByZWZldGNoTmV4dCAtIHJlYWQgbmV4dCBUSUQg ZnJvbSB0aGUgaW5kZXggc2NhbiwgZG8gcHJlZmV0Y2hlcworICoJSW5kZXhQcmVmZXRjaFJl c2V0IC0gcmVzZXQgc3RhdGUgb2YgdGhlIHByZWZldGNoZXIgKGZvciByZXNjYW5zKQorICoJ SW5kZXhQcmVmZXRjaEVuZCAtIHJlbGVhc2UgcmVzb3VyY2VzIGhlbGQgYnkgdGhlIHByZWZl dGNoZXIKKyAqCisgKiBXaGVuIGFsbG9jYXRpbmcgYSBwcmVmZXRjaGVyLCB0aGUgY2FsbGVy IGNhbiBzdXBwbHkgdHdvIGN1c3RvbSBjYWxsYmFja3M6CisgKgorICoJSW5kZXhQcmVmZXRj aE5leHRDQiAtIHJlYWRzIHRoZSBuZXh0IFRJRCBmcm9tIHRoZSBpbmRleCBzY2FuIChyZXF1 aXJlZCkKKyAqCUluZGV4UHJlZmV0Y2hDbGVhbnVwQ0IgLSByZWxlYXNlIHByaXZhdGUgcHJl ZmV0Y2ggZGF0YSAob3B0aW9uYWwpCisgKgorICogVGhlc2UgY2FsbGJhY2tzIGFsbG93IGN1 c3RvbWl6aW5nIHRoZSBiZWhhdmlvciBmb3IgZGlmZmVyZW50IHR5cGVzIG9mCisgKiBpbmRl eCBzY2FucyAtIGZvciBleGFtcGVsIGluZGV4LW9ubHkgc2NhbnMgbWF5IGluc3BlY3Qgdmlz aWJpbGl0eSBtYXAsCisgKiBhbmQgYWRqdXN0IHByZWZldGNoZXMgYmFzZWQgb24gdGhhdC4K KyAqCisgKgorICogVElEIHF1ZXVlCisgKiAtLS0tLS0tLS0KKyAqIFRoZSBwcmVmZXRjaGVy IG1haW50YWlucyBhIHNpbXBsZSBxdWV1ZSBvZiBUSURzIGZldGNoZWQgZnJvbSB0aGUgaW5k ZXguCisgKiBUaGUgbGVuZ3RoIG9mIHRoZSBxdWV1ZSAobnVtYmVyIG9mIFRJRHMpIGlzIGRl dGVybWluZWQgYnkgdGhlIHByZWZldGNoCisgKiB0YXJnZXQsIGkuZS4gZWZmZWN0aXZlX2lv X2NvbmN1cnJlbmN5LiBBZGRpbmcgZW50cmllcyB0byB0aGUgcXVldWUgaXMKKyAqIHRoZSBy ZXNwb25zaWJpbGl0eSBvZiBJbmRleFByZWZldGNoRmlsbFF1ZXVlKCksIGRlcGVuZGluZyBv biB0aGUgc3RhdGUKKyAqIG9mIHRoZSBzY2FuIGV0Yy4gSXQgYWxzbyBwcmVmZXRjaGVzIHRo ZSBwYWdlcywgaWYgYXBwcm9wcmlhdGUuCisgKgorICogTm90ZTogVGhpcyBwcmVmZXRjaGlu ZyBhcHBsaWVzIG9ubHkgdG8gaGVhcCBwYWdlcyBmcm9tIHRoZSBpbmRleGVkCisgKiByZWxh dGlvbiwgbm90IHRoZSBpbnRlcm5hbCBpbmRleCBwYWdlcy4KKyAqCisgKgorICogcGF0dGVy biBkZXRlY3Rpb24KKyAqIC0tLS0tLS0tLS0tLS0tLS0tCisgKiBGb3IgY2VydGFpbiBhY2Nl c3MgcGF0dGVybnMsIHByZWZldGNoaW5nIGlzIGluZWZmaWNpZW50LiBJbiBwYXJ0aWN1bGFy LAorICogdGhpcyBhcHBsaWVzIHRvIHNlcXVlbnRpYWwgYWNjZXNzICh3aGVyZSBrZXJuZWwg cmVhZC1haGVhZCB3b3JrcyBmaW5lKQorICogYW5kIGZvciBwYWdlcyB0aGF0IGFyZSBhbHJl YWR5IGluIG1lbW9yeSAocHJlZmV0Y2hlZCByZWNlbnRseSkuIFRoZQorICogcHJlZmV0Y2hl ciBhdHRlbXB0cyB0byBpZGVudGlmeSB0aGVzZSB0d28gY2FzZXMgLSBzZXF1ZW50aWFsIHBh dHRlcm5zCisgKiBhcmUgZGV0ZWN0ZWQgYnkgSW5kZXhQcmVmZXRjaEJsb2NrSXNTZXF1ZW50 aWFsLCB1c2lnbiBhIHRpbnkgcXVldWUgb2YKKyAqIHJlY2VudGx5IHByZWZldGNoZWQgYmxv Y2tzLiBSZWNlbnRseSBwcmVmZXRjaGVkIGJsb2NrcyBhcmUgdHJhY2tlZCBpbgorICogYSAi cGFydGl0aW9uZWQiIExSVSBjYWNoZS4KKyAqCisgKiBOb3RlOiBUaGVzZSBhcmUgaW5oZXJl bnRseSBiZXN0LWVmZm9ydCBoZXVyaXN0aWNzLiBXZSBkb24ndCBrbm93IHdoYXQKKyAqIHRo ZSBrZXJuZWwgYWxnb3JpdGhtL2NvbmZpZ3VyYXRpb24gaXMsIG9yIG1vcmUgcHJlY2lzZWx5 IHdoYXQgYWxyZWFkeQorICogaXMgaW4gcGFnZSBjYWNoZS4KKyAqCisgKgorICogY2FjaGUg b2YgcmVjZW50IHByZWZldGNoZXMKKyAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisg KiBDYWNoZSBvZiByZWNlbnRseSBwcmVmZXRjaGVkIGJsb2Nrcywgb3JnYW5pemVkIGFzIGEg aGFzaCB0YWJsZSBvZiBMUlUKKyAqIExSVSBjYWNoZXMuIERvZXNuJ3QgbmVlZCB0byBiZSBw ZXJmZWN0bHkgYWNjdXJhdGUsIGJ1dCB3ZSBhaW0gdG8gbWFrZQorICogZmFsc2UgcG9zaXRp dmVzL25lZ2F0aXZlcyByZWFzb25hYmx5IGxvdy4gRm9yIG1vcmUgZGV0YWlscyBzZWUgdGhl CisgKiBjb21tZW50cyBhdCBJbmRleFByZWZldGNoSXNDYWNoZWQuCisgKgorICoKKyAqIHBy ZWZldGNoIHJlcXVlc3QgbnVtYmVyCisgKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICog UHJlZmV0Y2hpbmcgd29ya3Mgd2l0aCB0aGUgY29uY2VwdCBvZiAiYWdlIiAoZS5nLiAicmVj ZW50bHkgcHJlZmV0Y2hlZAorICogcGFnZXMiKS4gVGhpcyByZWxpZXMgb24gYSBzaW1wbGUg cHJlZmV0Y2ggY291bnRlciwgaW5jcmVtZW50ZWQgZXZlcnkKKyAqIHRpbWUgYSBwcmVmZXRj aCBpcyBpc3N1ZWQuIFRoaXMgaXMgbm90IGV4YWN0bHkgdGhlIHNhbWUgdGhpbmcgYXMgdGlt ZSwKKyAqIGFzIHRoZXJlIG1heSBiZSBhcmJpdHJhcnkgZGVsYXlzLCBpdCdzIGdvb2QgZW5v dWdoIGZvciB0aGlzIHB1cnBvc2UuCisgKgorICoKKyAqIGF1dG8tdHVuaW5nIC8gc2VsZi1h ZGp1c3RtZW50CisgKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICoKKyAqIFhY WCBTb21lIGlkZWFzIGhvdyB0byBhdXRvLXR1bmUgdGhlIHByZWZldGNoaW5nLCBzbyB0aGF0 IHVubmVjZXNzYXJ5CisgKiBwcmVmZXRjaGluZyBkb2VzIG5vdCBjYXVzZSBzaWduaWZpY2Fu dCByZWdyZXNzaW9ucyAoZS5nLiBmb3IgbmVzdGxvb3AKKyAqIHdpdGggaW5uZXIgaW5kZXgg c2NhbikuIFdlIGNvdWxkIHRyYWNrIG51bWJlciBvZiByZXNjYW5zIGFuZCBudW1iZXIgb2YK KyAqIGl0ZW1zIChUSURzKSBhY3R1YWxseSByZXR1cm5lZCBmcm9tIHRoZSBzY2FuLiBUaGVu IHdlIGNvdWxkIGNhbGN1bGF0ZQorICogcm93cyAvIHJlc2NhbiBhbmQgYWRqdXN0IHRoZSBw cmVmZXRjaCB0YXJnZXQgYWNjb3JkaW5nbHkuIFRoYXQnZCBoZWxwCisgKiB3aXRoIGNhc2Vz IHdoZW4gYSBzY2FuIG1hdGNoZXMgb25seSB2ZXJ5IGZldyByb3dzLCBmYXIgbGVzcyB0aGFu IHRoZQorICogcHJlZmV0Y2hUYXJnZXQsIGJlY2F1c2UgdGhlIHVubmVjZXNzYXJ5IHByZWZl dGNoZXMgYXJlIHdhc3RlZCBJL08uCisgKiBJbWFnaW5lIGEgTElNSVQgb24gdG9wIG9mIGlu ZGV4IHNjYW4sIG9yIHNvbWV0aGluZyBsaWtlIHRoYXQuCisgKgorICogWFhYIENvdWxkIHdl IHR1bmUgdGhlIGNhY2hlIHNpemUgYmFzZWQgb24gZXhlY3V0aW9uIHN0YXRpc3RpY3M/IFdl IGhhdmUKKyAqIGEgY2FjaGUgb2YgbGltaXRlZCBzaXplIChQUkVGRVRDSF9DQUNIRV9TSVpF ID0gMTAyNCBieSBkZWZhdWx0KSwgYnV0CisgKiBob3cgZG8gd2Uga25vdyBpdCdzIHRoZSBy aWdodCBzaXplPyBJZGVhbGx5LCB3ZSdkIGhhdmUgYSBjYWNoZSBsYXJnZQorICogZW5vdWdo IHRvIHRyYWNrIGFjdHVhbGx5IGNhY2hlZCBibG9ja3MuIElmIHRoZSBPUyBjYWNoZXMgMTAy NDAgcGFnZXMsCisgKiB0aGVuIHdlIG1heSBkbyA5MCUgb2YgcHJlZmV0Y2ggcmVxdWVzdHMg dW5uZWNlc3NhcmlseS4gT3IgbWF5YmUgdGhlcmUncworICogYSBsb3Qgb2YgY29udGVudGlv biwgYmxvY2tzIGFyZSBldmljdGVkIHF1aWNrbHksIGFuZCA5MCUgb2YgdGhlIGJsb2Nrcwor ICogaW4gdGhlIGNhY2hlIGFyZSBub3QgYWN0dWFsbHkgY2FjaGVkIGFueW1vcmU/IEJ1dCB3 ZSBkbyBoYXZlIGEgY29uY2VwdAorICogb2Ygc2VxdWVudGlhbCByZXF1ZXN0IElEIChQcmVm ZXRjaENhY2hlRW50cnktPnJlcXVlc3QpLCB3aGljaCBnaXZlcyB1cworICogaW5mb3JtYXRp b24gYWJvdXQgImFnZSIgb2YgdGhlIGxhc3QgcHJlZmV0Y2guIE5vdyBpdCdzIHVzZWQgb25s eSB3aGVuCisgKiBldmljdGluZyBlbnRyaWVzICh0byBrZWVwIHRoZSBtb3JlIHJlY2VudCBv bmUpLCBidXQgbWF5YmUgd2UgY291bGQgYWxzbworICogdXNlIGl0IHdoZW4gZGVjaWRpbmcg aWYgdGhlIHBhZ2UgaXMgY2FjaGVkLiBSaWdodCBub3cgYW55IGJsb2NrIHRoYXQncworICog aW4gdGhlIGNhY2hlIGlzIGNvbnNpZGVyZWQgY2FjaGVkIGFuZCBub3QgcHJlZmV0Y2hlZCwg YnV0IG1heWJlIHdlIGNvdWxkCisgKiBoYXZlICJtYXggYWdlIiwgYW5kIHR1bmUgaXQgYmFz ZWQgb24gZmVlZGJhY2sgZnJvbSByZWFkaW5nIHRoZSBibG9ja3MKKyAqIGxhdGVyLiBGb3Ig ZXhhbXBsZSwgaWYgd2UgZmluZCB0aGUgYmxvY2sgaW4gY2FjaGUgYW5kIGRlY2lkZSBub3Qg dG8KKyAqIHByZWZldGNoIGl0LCBidXQgdGhlbiBsYXRlciBmaW5kIHdlIGhhdmUgdG8gZG8g SS9PLCBpdCBtZWFucyBvdXIgY2FjaGUKKyAqIGlzIHRvbyBsYXJnZS4gQW5kIHdlIGNvdWxk ICJyZWR1Y2UiIHRoZSBtYXhpbXVtIGFnZSAobWVhc3VyZWQgZnJvbSB0aGUKKyAqIGN1cnJl bnQgcHJlZmV0Y2hSZXF1ZXN0IHZhbHVlKSwgc28gdGhhdCBvbmx5IG1vcmUgcmVjZW50IGJs b2NrcyB3b3VsZAorICogYmUgY29uc2lkZXJlZCBjYWNoZWQuIE5vdCBzdXJlIGFib3V0IHRo ZSBvcHBvc2l0ZSBkaXJlY3Rpb24sIHdoZXJlIHdlCisgKiBkZWNpZGUgdG8gcHJlZmV0Y2gg YSBibG9jayAtIEFGQUlLIHdlIGRvbid0IGhhdmUgYSB3YXkgdG8gZGV0ZXJtaW5lIGlmCisg KiBJL08gd2FzIG5lZWRlZCBvciBub3QgaW4gdGhpcyBjYXNlIChzbyB3ZSBjYW4ndCBpbmNy ZWFzZSB0aGUgbWF4IGFnZSkuCisgKiBCdXQgbWF5YmUgd2UgY291bGQgZGkgdGhhdCBzb21l aG93IHNwZWN1bGF0aXZlbHksIGkuZS4gaW5jcmVhc2UgdGhlCisgKiB2YWx1ZSBvbmNlIGlu IGEgd2hpbGUsIGFuZCBzZWUgd2hhdCBoYXBwZW5zLgorICoKKyAqCisgKiBQb3J0aW9ucyBD b3B5cmlnaHQgKGMpIDE5OTYtMjAyNCwgUG9zdGdyZVNRTCBHbG9iYWwgRGV2ZWxvcG1lbnQg R3JvdXAKKyAqIFBvcnRpb25zIENvcHlyaWdodCAoYykgMTk5NCwgUmVnZW50cyBvZiB0aGUg VW5pdmVyc2l0eSBvZiBDYWxpZm9ybmlhCisgKgorICoKKyAqIElERU5USUZJQ0FUSU9OCisg KgkgIHNyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNQcmVmZXRjaC5jCisgKgorICotLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tCisgKi8KKyNpbmNsdWRlICJwb3N0Z3Jlcy5oIgorCisjaW5jbHVkZSAi YWNjZXNzL2dlbmFtLmgiCisjaW5jbHVkZSAiYWNjZXNzL3JlbHNjYW4uaCIKKyNpbmNsdWRl ICJhY2Nlc3MvdGFibGVhbS5oIgorI2luY2x1ZGUgImFjY2Vzcy94YWN0LmgiCisjaW5jbHVk ZSAiY2F0YWxvZy9pbmRleC5oIgorI2luY2x1ZGUgImNvbW1vbi9oYXNoZm4uaCIKKyNpbmNs dWRlICJleGVjdXRvci9leGVjdXRvci5oIgorI2luY2x1ZGUgIm5vZGVzL25vZGVGdW5jcy5o IgorI2luY2x1ZGUgInN0b3JhZ2UvYnVmbWdyLmgiCisjaW5jbHVkZSAidXRpbHMvc3BjY2Fj aGUuaCIKKworCisvKgorICogQW4gZW50cnkgcmVwcmVzZW50aW5nIGEgcmVjZW50bHkgcHJl ZmV0Y2hlZCBibG9jay4gRm9yIGVhY2ggYmxvY2sgd2Uga25vdworICogdGhlIHJlcXVlc3Qg bnVtYmVyLCBhc3NpZ25lZCBzZXF1ZW50aWFsbHksIGFsbG93aW5nIHVzIHRvIGRlY2lkZSBo b3cgb2xkCisgKiB0aGUgcmVxdWVzdCBpcy4KKyAqCisgKiBYWFggSXMgaXQgZW5vdWdoIHRv IGtlZXAgdGhlIHJlcXVlc3QgYXMgdWludDMyPyBUaGlzIHdheSB3ZSBjYW4gcHJlZmV0Y2gK KyAqIDMyVEIgb2YgZGF0YSwgYW5kIHRoaXMgYWxsb3dzIHVzIHRvIGZpdCB0aGUgd2hvbGUg ZW50cnkgaW50byA2NEIsIGkuZS4KKyAqIG9uZSBjYWNoZWxpbmUuIFdoaWNoIHNlZW1zIGxp a2UgYSBnb29kIHRoaW5nLgorICoKKyAqIFhYWCBJZiB3ZSdyZSBleHRyYSBjYXJlZnVsIC8g cGFyYW5vaWQgYWJvdXQgdWludDMyLCB3ZSBjb3VsZCByZXNldCB0aGUKKyAqIGNhY2hlIG9u Y2UgdGhlIHJlcXVlc3Qgd3JhcHMgYXJvdW5kLgorICovCit0eXBlZGVmIHN0cnVjdCBJbmRl eFByZWZldGNoQ2FjaGVFbnRyeQoreworCUJsb2NrTnVtYmVyIGJsb2NrOworCXVpbnQzMgkJ cmVxdWVzdDsKK30gSW5kZXhQcmVmZXRjaENhY2hlRW50cnk7CisKKy8qCisgKiBTaXplIG9m IHRoZSBjYWNoZSBvZiByZWNlbnRseSBwcmVmZXRjaGVkIGJsb2NrcyAtIHNob3VsZG4ndCBi ZSB0b28gc21hbGwgb3IKKyAqIHRvbyBsYXJnZS4gMTAyNCBlbnRyaWVzIHNlZW1zIGFib3V0 IHJpZ2h0LCBpdCBjb3ZlcnMgfjhNQiBvZiBkYXRhLiBUaGlzIGlzCisgKiByYXRoZXIgYXJi aXRyYXJ5IC0gdGhlcmUncyBubyBmb3JtdWxhIHRoYXQnZCB0ZWxsIHVzIHdoYXQgdGhlIG9w dGltYWwgc2l6ZQorICogaXMsIGFuZCB3ZSBjYW4ndCBldmVuIHR1bmUgaXQgYmFzZWQgb24g cnVudGltZSAoYXMgaXQgZGVwZW5kcyBvbiB3aGF0IHRoZQorICogb3RoZXIgYmFja2VuZHMg ZG8gdG9vKS4KKyAqCisgKiBBIHZhbHVlIHRvbyBzbWFsbCB3b3VsZCBtZWFuIHdlIG1heSBp c3N1ZSB1bm5lY2Vzc2FyeSBwcmVmZXRjaGVzIGZvciBwYWdlcworICogdGhhdCBoYXZlIGFs cmVhZHkgYmVlbiBwcmVmZXRjaGVkIHJlY2VudGx5IChhbmQgYXJlIHN0aWxsIGluIHBhZ2Ug Y2FjaGUpLAorICogaW5jdXJyaW5nIGNvc3RzIGZvciB1bm5lY2Vzc2FyeSBmYWR2aXNlKCkg Y2FsbHMuCisgKgorICogQSB2YWx1ZSB0b28gbGFyZ2Ugd291bGQgbWVhbiB3ZSBkbyBub3Qg aXNzdWUgcHJlZmV0Y2hlcyBmb3IgcGFnZXMgdGhhdCBoYXZlCisgKiBhbHJlYWR5IGJlZW4g ZXZpY3RlZCBmcm9tIG1lbW9yeSAoYm90aCBzaGFyZWQgYnVmZmVycyBhbmQgcGFnZSBjYWNo ZSkuCisgKgorICogTm90ZSBob3dldmVyIHRoYXQgUHJlZmV0Y2hCdWZmZXIoKSBjaGVja3Mg c2hhcmVkIGJ1ZmZlcnMgYmVmb3JlIGRvaW5nIHRoZQorICogZmFkdmlzZSBjYWxsLCB3aGlj aCBzb21ld2hhdCBsaW1pdHMgdGhlIHJpc2sgb2YgYSBzbWFsbCBjYWNoZSAtIHRoZSBwYWdl CisgKiB3b3VsZCBoYXZlIHRvIGdldCBldmljdGVkIGZyb20gc2hhcmVkIGJ1ZmZlcnMgbm90 IHlldCBmcm9tIHBhZ2UgY2FjaGUuCisgKiBBbHNvLCB0aGUgY29zdCBvZiBub3QgaXNzdWlu ZyBhIGZhZHZpc2UgY2FsbCAoYW5kIGRvaW5nIHN5bmNocm9ub3VzIEkvTworICogbGF0ZXIp IGlzIG11Y2ggaGlnaGVyIHRoYW4gdGhlIHVubmVjZXNzYXJ5IGZhZHZpc2UgY2FsbC4gRm9y IHRoZXNlIHJlYXNvbnMKKyAqIGl0J3MgYmV0dGVyIHRvIGtlZXAgdGhlIGNhY2hlIGZhaXJs eSBzbWFsbC4KKyAqCisgKiBUaGUgY2FjaGUgaXMgc3RydWN0dXJlZCBhcyBhbiBhcnJheSBv ZiBzbWFsbCBMUlUgY2FjaGVzIC0geW91IG1heSBhbHNvCisgKiBpbWFnaW5lIGl0IGFzIGEg aGFzaCB0YWJsZSBvZiBMUlUgY2FjaGVzLiBUbyByZW1lbWJlciBhIHByZWZldGNoZWQgYmxv Y2ssCisgKiB0aGUgYmxvY2sgbnVtYmVyIG1hcHBlZCB0byBhIExSVSB1c2luZyBieSBoYXNo aW5nLiBBbmQgdGhlbiBpbiBlYWNoIExSVQorICogd2Ugb3JnYW5pemUgdGhlIGVudHJpZXMg YnkgYWdlIChwZXIgcmVxdWVzdCBudW1iZXIpIC0gaW4gcGFydGljdWxhciwgdGhlCisgKiBh Z2UgZGV0ZXJtaW5lcyB3aGljaCBlbnRyeSBnZXRzIGV2aWN0ZWQgYWZ0ZXIgdGhlIExSVSBn ZXRzIGZ1bGwuCisgKgorICogVGhlIExSVSBuZWVkcyB0byBiZSBzbWFsbCBlbm91Z2ggdG8g YmUgc2VhcmNoZWQgbGluZWFybHkuIEF0IHRoZSBzYW1lCisgKiB0aW1lIGl0IG5lZWRzIHRv IGJlIHN1ZmZpY2llbnRseSBsYXJnZSB0byBoYW5kbGUgY29sbGlzaW9ucyB3aGVuIHNldmVy YWwKKyAqIGhvdCBibG9ja3MgZ2V0IG1hcHBlZCB0byB0aGUgc2FtZSBMUlUuIEZvciBleGFt cGxlLCBpZiB0aGUgTFJVIHdhcyBvbmx5CisgKiBhIHNpbmdsZSBlbnRyeSwgYW5kIHRoZXJl IHdlcmUgdHdvIGhvdCBibG9ja3MgbWFwcGVkIHRvIGl0LCB0aGF0IHdvdWxkCisgKiBvZnRl biBnaXZlIGluY29ycmVjdCBhbnN3ZXIuCisgKgorICogVGhlIDggZW50cmllcyBwZXIgTFJV IHNlZW1zIGFib3V0IHJpZ2h0IC0gaXQncyBzbWFsbCBlbm91Z2ggZm9yIGxpbmVhcgorICog c2VhcmNoIHRvIHdvcmsgd2VsbCwgYnV0IGxhcmdlIGVub3VnaCB0byBiZSBhZGFwdGl2ZS4g SXQncyBub3QgdmVyeQorICogbGlrZWx5IGZvciA5KyBidXN5IGJsb2NrcyAob3V0IG9mIDEw MDAgcmVjZW50IHJlcXVlc3RzKSB0byBtYXAgdG8gdGhlCisgKiBzYW1lIExSVS4gQXNzdW1p bmcgcmVhc29uYWJsZSBoYXNoIGZ1bmN0aW9uLgorICoKKyAqIFhYWCBNYXliZSB3ZSBjb3Vs ZCBjb25zaWRlciBlZmZlY3RpdmVfY2FjaGVfc2l6ZSB3aGVuIHNpemluZyB0aGUgY2FjaGU/ CisgKiBOb3QgdG8gc2l6ZSB0aGUgY2FjaGUgZm9yIHRoYXQsIG9mYywgYnV0IG1heWJlIGFz IGEgZ3VpZGFuY2Ugb2YgaG93IG1hbnkKKyAqIGhlYXAgcGFnZXMgaXQgbWlnaHQga2VlcC4g TWF5YmUganVzdCBhIGZyYWN0aW9uIGZyYWN0aW9uIG9mIHRoZSB2YWx1ZSwKKyAqIHNheSBN YXgoOE1CLCBlZmZlY3RpdmVfY2FjaGVfc2l6ZSAvIG1heF9jb25uZWN0aW9ucykgb3Igc29t ZXRoaW5nLgorICovCisjZGVmaW5lCQlQUkVGRVRDSF9MUlVfU0laRQkJOAkvKiBzbG90cyBp biBvbmUgTFJVICovCisjZGVmaW5lCQlQUkVGRVRDSF9MUlVfQ09VTlQJCTEyOCAvKiBudW1i ZXIgb2YgTFJVcyAqLworI2RlZmluZQkJUFJFRkVUQ0hfQ0FDSEVfU0laRQkJKFBSRUZFVENI X0xSVV9TSVpFICogUFJFRkVUQ0hfTFJVX0NPVU5UKQorCisvKgorICogU2l6ZSBvZiBzbWFs bCBzZXF1ZW50aWFsIHF1ZXVlIG9mIG1vc3QgcmVjZW50bHkgcHJlZmV0Y2hlZCBibG9ja3Ms IHVzZWQKKyAqIHRvIGNoZWNrIGlmIHRoZSBibG9jayBpcyBleGFjdGx5IHRoZSBzYW1lIGFz IHRoZSBpbW1lZGlhdGVseSBwcmVjZWRpbmcKKyAqIG9uZSAoaW4gd2hpY2ggY2FzZSBwcmVm ZXRjaGluZyBpcyBub3QgbmVlZGVkKSwgYW5kIGlmIHRoZSBibG9ja3MgYXJlIGEKKyAqIHNl cXVlbnRpYWwgcGF0dGVybiAoaW4gd2hpY2ggY2FzZSB0aGUga2VybmVsIHJlYWQtYWhlYWQg aXMgbGlrZWx5IGdvaW5nCisgKiB0byBiZSBtb3JlIGVmZmljaWVudCwgYW5kIHdlIGRvbid0 IHdhbnQgdG8gaW50ZXJmZXJlIHdpdGggaXQpLgorICovCisjZGVmaW5lCQlQUkVGRVRDSF9R VUVVRV9ISVNUT1JZCTgKKworLyoKKyAqIEFuIGluZGV4IHByZWZldGNoZXIsIHdoaWNoIG1h aW50YWlucyBhIHF1ZXVlIG9mIFRJRHMgZnJvbSBhbiBpbmRleCwgYW5kCisgKiBpc3N1ZXMg cHJlZmV0Y2hlcyAoaWYgZGVlbWVkIGJlbmVmaWNpYWwgYW5kIHN1cHBvcnRlZCBieSB0aGUg T1MpLgorICovCit0eXBlZGVmIHN0cnVjdCBJbmRleFByZWZldGNoCit7CisJaW50CQkJcHJl ZmV0Y2hUYXJnZXQ7IC8qIGhvdyBmYXIgd2Ugc2hvdWxkIGJlIHByZWZldGNoaW5nICovCisJ aW50CQkJcHJlZmV0Y2hNYXhUYXJnZXQ7CS8qIG1heGltdW0gcHJlZmV0Y2hpbmcgZGlzdGFu Y2UgKi8KKwlpbnQJCQlwcmVmZXRjaFJlc2V0OwkvKiByZXNldCB0byB0aGlzIGRpc3RhbmNl IG9uIHJlc2NhbiAqLworCWJvb2wJCXByZWZldGNoRG9uZTsJLyogZGlkIHdlIGdldCBhbGwg VElEcyBmcm9tIHRoZSBpbmRleD8gKi8KKworCS8qIHJ1bnRpbWUgc3RhdGlzdGljcywgZGlz cGxheWVkIGluIEVYUExBSU4gZXRjLiAqLworCXVpbnQzMgkJY291bnRBbGw7CQkvKiBhbGwg cHJlZmV0Y2ggcmVxdWVzdHMgKGluY2x1ZGluZyBza2lwcGVkKSAqLworCXVpbnQzMgkJY291 bnRQcmVmZXRjaDsJLyogUHJlZmV0Y2hCdWZmZXIgY2FsbHMgKi8KKwl1aW50MzIJCWNvdW50 U2tpcFNlcXVlbnRpYWw7CS8qIHNraXBwZWQgYXMgc2VxdWVudGlhbCBwYXR0ZXJuICovCisJ dWludDMyCQljb3VudFNraXBDYWNoZWQ7CS8qIHNraXBwZWQgYXMgcmVjZW50bHkgcHJlZmV0 Y2hlZCAqLworCisJLyoKKwkgKiBRdWV1ZSBvZiBUSURzIHRvIHByZWZldGNoLgorCSAqCisJ ICogWFhYIFNpemluZyBmb3IgTUFYX0lPX0NPTkNVUlJFTkNZIG1heSBiZSBvdmVya2lsbCwg YnV0IGl0IHNlZW1zIHNpbXBsZXIKKwkgKiB0aGFuIGR5bmFtaWNhbGx5IGFkanVzdGluZyBm b3IgY3VzdG9tIHZhbHVlcy4gSG93ZXZlciwgMTAwMCBlbnRyaWVzCisJICogbWVhbnMgfjE2 a0IsIHdoaWNoIG1lYW5zIGFuIG92ZXJzaXplZCBjaHVuaywgYW5kIHRodXMgYWx3YXlzIGEg bWFsbG9jKCkKKwkgKiBjYWxsLiBIb3dldmVyLCB3ZSBhbHJlYWR5IGhhdmUgdGhlIHByZWZl dGNoQ2FjaGUsIHdoaWNoIGlzIGFsc28gbGFyZ2UKKwkgKiBlbm91Z2ggdG8gY2F1c2UgdGhp cyA6LSgKKwkgKgorCSAqIFhYWCBIb3dldmVyIHdoYXQgYWJvdXQgdGhlIGNhc2Ugd2l0aG91 dCBwcmVmZXRjaGluZz8gSW4gdGhhdCBjYXNlIGl0CisJICogd291bGQgYmUgbmljZSB0byBs b3dlciB0aGUgbWFsbG9jIG92ZXJoZWFkLCBtYXliZT8KKwkgKi8KKwlJbmRleFByZWZldGNo RW50cnkgcXVldWVJdGVtc1tNQVhfSU9fQ09OQ1VSUkVOQ1ldOworCXVpbnQzMgkJcXVldWVJ bmRleDsJCS8qIG5leHQgVElEIHRvIHByZWZldGNoICovCisJdWludDMyCQlxdWV1ZVN0YXJ0 OwkJLyogZmlyc3QgdmFsaWQgVElEIGluIHF1ZXVlICovCisJdWludDMyCQlxdWV1ZUVuZDsJ CS8qIGZpcnN0IGludmFsaWQgKGVtcHR5KSBUSUQgaW4gcXVldWUgKi8KKworCS8qCisJICog QSBjb3VwbGUgb2YgbGFzdCBwcmVmZXRjaGVkIGJsb2NrcywgdXNlZCB0byBjaGVjayBmb3Ig Y2VydGFpbiBhY2Nlc3MKKwkgKiBwYXR0ZXJuIGFuZCBza2lwIHByZWZldGNoaW5nIC0gZS5n LiBmb3Igc2VxdWVudGlhbCBhY2Nlc3MpLgorCSAqCisJICogWFhYIFNlcGFyYXRlIGZyb20g dGhlIG1haW4gcXVldWUsIGJlY2F1c2Ugd2Ugb25seSB3YW50IHRvIGNvbXBhcmUgdGhlCisJ ICogYmxvY2sgbnVtYmVycywgbm90IHRoZSB3aG9sZSBUSUQuIEluIHNlcXVlbnRpYWwgYWNj ZXNzIGl0J3MgbGlrZWx5IHdlCisJICogcmVhZCBtYW55IGl0ZW1zIGZyb20gZWFjaCBwYWdl LCBhbmQgd2UgZG9uJ3Qgd2FudCB0byBjaGVjayBtYW55IGl0ZW1zCisJICogKGFzIHRoYXQg aXMgbXVjaCBtb3JlIGV4cGVuc2l2ZSkuCisJICovCisJQmxvY2tOdW1iZXIgYmxvY2tJdGVt c1tQUkVGRVRDSF9RVUVVRV9ISVNUT1JZXTsKKwl1aW50MzIJCWJsb2NrSW5kZXg7CQkvKiBp bmRleCBpbiB0aGUgYmxvY2sgKHBvaW50cyB0byB0aGUgZmlyc3QKKwkJCQkJCQkJICogZW1w dHkgZW50cnkpICovCisKKwkvKgorCSAqIENhY2hlIG9mIHJlY2VudGx5IHByZWZldGNoZWQg YmxvY2tzLCBvcmdhbml6ZWQgYXMgYSBoYXNoIHRhYmxlIG9mIHNtYWxsCisJICogTFJVIGNh Y2hlcy4KKwkgKi8KKwl1aW50MzIJCXByZWZldGNoUmVxdWVzdDsKKwlJbmRleFByZWZldGNo Q2FjaGVFbnRyeSBwcmVmZXRjaENhY2hlW1BSRUZFVENIX0NBQ0hFX1NJWkVdOworCisKKwkv KgorCSAqIENhbGxiYWNrIHRvIGN1c3RvbWl6ZSB0aGUgcHJlZmV0Y2ggKGRlY2lkZSB3aGlj aCBibG9jayBuZWVkIHRvIGJlCisJICogcHJlZmV0Y2hlZCwgZXRjLikKKwkgKi8KKwlJbmRl eFByZWZldGNoTmV4dENCIG5leHRfY2I7CS8qIHJlYWQgbmV4dCBUSUQgKi8KKwlJbmRleFBy ZWZldGNoQ2xlYW51cENCIGNsZWFudXBfY2I7CS8qIGNsZWFudXAgZGF0YSAqLworCisJLyoK KwkgKiBJZiBhIGNhbGxiYWNrIGlzIHNwZWNpZmllZCwgaXQgbWF5IHN0b3JlIGdsb2JhbCBz dGF0ZSAoZm9yIGFsbCBUSURzKS4KKwkgKiBGb3IgZXhhbXBsZSBWTSBidWZmZXIgbWF5IGJl IGtlcHQgZHVyaW5nIElPUy4gVGhpcyBpcyBzaW1pbGFyIHRvIHRoZQorCSAqIGRhdGEgZmll bGQgaW4gSW5kZXhQcmVmZXRjaEVudHJ5LCBidXQgdGhhdCdzIHBlci1USUQuCisJICovCisJ dm9pZAkgICAqZGF0YTsKK30gSW5kZXhQcmVmZXRjaDsKKworLyogc21hbGwgc2VxdWVudGlh bCBxdWV1ZSBvZiByZWNlbnQgYmxvY2tzICovCisjZGVmaW5lIFBSRUZFVENIX0JMT0NLX0lO REVYKHYpCSgodikgJSBQUkVGRVRDSF9RVUVVRV9ISVNUT1JZKQorCisvKiBhY2Nlc3MgdG8g dGhlIG1haW4gaHlicmlkIGNhY2hlIChoYXNoIG9mIExSVXMpICovCisjZGVmaW5lIFBSRUZF VENIX0xSVV9FTlRSWShwLCBscnUsIGlkeCkJXAorCSYoKHApLT5wcmVmZXRjaENhY2hlWyhs cnUpICogUFJFRkVUQ0hfTFJVX1NJWkUgKyAoaWR4KV0pCisKKy8qIGFjY2VzcyB0byBxdWV1 ZSBvZiBUSURzICh1cCB0byBNQVhfSU9fQ09OQ1VSUkVOQ1kgZWxlbWVudHMpICovCisjZGVm aW5lIFBSRUZFVENIX1FVRVVFX0lOREVYKGEpCSgoYSkgJSAoTUFYX0lPX0NPTkNVUlJFTkNZ KSkKKyNkZWZpbmUgUFJFRkVUQ0hfUVVFVUVfRU1QVFkocCkJKChwKS0+cXVldWVFbmQgPT0g KHApLT5xdWV1ZUluZGV4KQorCisvKgorICogbWFjcm9zIHRvIGRlYWwgd2l0aCBwcmVmZXRj aGVyIHN0YXRlCisgKgorICogRklYTUUgbWF5IG5lZWQgcmV0aGlua2luZywgZWFzeSB0byBj b25mdXNlIFBSRUZFVENIX0VOQUJMRUQvUFJFRkVUQ0hfQUNUSVZFCisgKi8KKyNkZWZpbmUg UFJFRkVUQ0hfRU5BQkxFRChwKQkJKChwKSAmJiAoKHApLT5wcmVmZXRjaE1heFRhcmdldCA+ IDApKQorI2RlZmluZSBQUkVGRVRDSF9RVUVVRV9GVUxMKHApCQkoKHApLT5xdWV1ZUVuZCAt IChwKS0+cXVldWVJbmRleCA9PSAocCktPnByZWZldGNoVGFyZ2V0KQorI2RlZmluZSBQUkVG RVRDSF9ET05FKHApCQkoKHApICYmICgocCktPnByZWZldGNoRG9uZSAmJiBQUkVGRVRDSF9R VUVVRV9FTVBUWShwKSkpCisjZGVmaW5lIFBSRUZFVENIX0FDVElWRShwKQkJKFBSRUZFVENI X0VOQUJMRUQocCkgJiYgIShwKS0+cHJlZmV0Y2hEb25lKQorCisKKy8qCisgKiBJbmRleFBy ZWZldGNoQmxvY2tJc1NlcXVlbnRpYWwKKyAqCQlUcmFjayB0aGUgYmxvY2sgbnVtYmVyIGFu ZCBjaGVjayBpZiB0aGUgSS9PIHBhdHRlcm4gaXMgc2VxdWVudGlhbCwKKyAqCQlvciBpZiB0 aGUgYmxvY2sgaXMgdGhlIHNhbWUgYXMgdGhlIGltbWVkaWF0ZWx5IHByZWNlZGluZyBvbmUu CisgKgorICogVGhpcyBhbHNvIHVwZGF0ZXMgdGhlIHNtYWxsIHNlcXVlbnRpYWwgY2FjaGUg b2YgYmxvY2tzLgorICoKKyAqIFRoZSBwcmVmZXRjaGluZyBvdmVyaGVhZCBpcyBmYWlybHkg bG93LCBidXQgZm9yIHNvbWUgYWNjZXNzIHBhdHRlcm5zIHRoZQorICogYmVuZWZpdHMgYXJl IHNtYWxsIGNvbXBhcmVkIHRvIHRoZSBleHRyYSBvdmVyaGVhZCwgb3IgdGhlIHByZWZldGNo aW5nIG1heQorICogZXZlbiBiZSBoYXJtZnVsLiBJbiBwYXJ0aWN1bGFyLCBmb3Igc2VxdWVu dGlhbCBhY2Nlc3MgdGhlIHJlYWQtYWhlYWQKKyAqIHBlcmZvcm1lZCBieSB0aGUgT1MgaXMg dmVyeSBlZmZlY3RpdmUvZWZmaWNpZW50IGFuZCBvdXIgcHJlZmV0Y2hpbmcgbWF5CisgKiBi ZSBwb2ludGxlc3Mgb3IgKHdvcnNlKSBldmVuIGludGVyZmVyZSB3aXRoIGl0LgorICoKKyAq IFRoaXMgaWRlbnRpZmllcyBzaW1wbGUgc2VxdWVudGlhbCBwYXR0ZXJucywgdXNpbmcgYSB0 aW55IHF1ZXVlIG9mIHJlY2VudGx5CisgKiBwcmVmZXRjaGVkIGJsb2NrIG51bWJlcnMgKFBS RUZFVENIX1FVRVVFX0hJU1RPUlkgYmxvY2tzKS4gSXQgYWxzbyBjaGVja3MKKyAqIGlmIHRo ZSBibG9jayBpcyBleGFjdGx5IHRoZSBzYW1lIGFzIGFueSBvZiB0aGUgYmxvY2tzIGluIHRo ZSBxdWV1ZSAodGhlCisgKiBtYWluIGNhY2hlIGhhcyBibG9jayB0b28sIGJ1dCBjaGVja2lu ZyB0aGUgdGlueSBjYWNoZSBpcyBsaWtlbHkgY2hlYXBlcikuCisgKgorICogVGhlIHRoZSBt YWluIHByZWZldGNoIHF1ZXVlIGlzIG5vdCByZWFsbHkgdXNlZnVsIGZvciB0aGlzLCBhcyBp dCBzdG9yZXMKKyAqIGZ1bGwgVElEcywgYnV0IHdoaWxlIHdlIG9ubHkgY2FyZSBhYm91dCBi bG9jayBudW1iZXJzLiBDb25zaWRlciBhIG5pY2VseQorICogY2x1c3RlcmVkIHRhYmxlLCB3 aXRoIGEgcGVyZmVjdGx5IHNlcXVlbnRpYWwgcGF0dGVybiB3aGVuIGFjY2Vzc2VkIHRocm91 Z2gKKyAqIGFuIGluZGV4LiBFYWNoIGhlYXAgcGFnZSBtYXkgaGF2ZSBkb3plbnMgb2YgVElE cywgZmlsbGluZyB0aGUgcHJlZmV0Y2gKKyAqIHF1ZXVlLiBCdXQgd2UgbmVlZCB0byBjb21w YXJlIGJsb2NrIG51bWJlcnMgLSB0aG9zZSBtYXkgZWl0aGVyIG5vdCBiZQorICogaW4gdGhl IHF1ZXVlIGFueW1vcmUsIG9yIHdlIGhhdmUgdG8gd2FsayBtYW55IFRJRHMgKG1ha2luZyBp dCBleHBlbnNpdmUsCisgKiBhbmQgd2UncmUgaW4gaG90IHBhdGgpLgorICoKKyAqIFNvIGEg dGlueSBxdWV1ZSBvZiBqdXN0IGJsb2NrIG51bWJlcnMgc2VlbXMgbGlrZSBhIGJldHRlciBv cHRpb24uCisgKgorICogUmV0dXJucyB0cnVlIGlmIHRoZSBibG9jayBpcyBpbiBhIHNlcXVl bnRpYWwgcGF0dGVybiBvciB3YXMgcHJlZmV0Y2hlZAorICogcmVjZW50bHkgKGFuZCBzbyBz aG91bGQgbm90IGJlIHByZWZldGNoZWQgdGhpcyB0aW1lKSwgb3IgZmFsc2UgKGluIHdoaWNo CisgKiBjYXNlIGl0IHNob3VsZCBiZSBwcmVmZXRjaGVkKS4KKyAqLworc3RhdGljIGJvb2wK K0luZGV4UHJlZmV0Y2hCbG9ja0lzU2VxdWVudGlhbChJbmRleFByZWZldGNoICpwcmVmZXRj aCwgQmxvY2tOdW1iZXIgYmxvY2spCit7CisJaW50CQkJaWR4OworCisJLyoKKwkgKiBJZiB0 aGUgYmxvY2sgcXVldWUgaXMgZW1wdHksIGp1c3Qgc3RvcmUgdGhlIGJsb2NrIGFuZCB3ZSdy ZSBkb25lIChpdCdzCisJICogbmVpdGhlciBhIHNlcXVlbnRpYWwgcGF0dGVybiwgbmVpdGhl ciByZWNlbnRseSBwcmVmZXRjaGVkIGJsb2NrKS4KKwkgKi8KKwlpZiAocHJlZmV0Y2gtPmJs b2NrSW5kZXggPT0gMCkKKwl7CisJCXByZWZldGNoLT5ibG9ja0l0ZW1zW1BSRUZFVENIX0JM T0NLX0lOREVYKHByZWZldGNoLT5ibG9ja0luZGV4KV0gPSBibG9jazsKKwkJcHJlZmV0Y2gt PmJsb2NrSW5kZXgrKzsKKwkJcmV0dXJuIGZhbHNlOworCX0KKworCS8qCisJICogQ2hlY2sg aWYgaXQncyB0aGUgc2FtZSBhcyB0aGUgaW1tZWRpYXRlbHkgcHJlY2VkaW5nIGJsb2NrLiBX ZSBkb24ndAorCSAqIHdhbnQgdG8gcHJlZmV0Y2ggdGhlIHNhbWUgYmxvY2sgb3ZlciBhbmQg b3ZlciAod2hpY2ggd291bGQgaGFwcGVuIGZvcgorCSAqIHdlbGwgY29ycmVsYXRlZCBpbmRl eGVzKS4KKwkgKgorCSAqIEluIHByaW5jaXBsZSB3ZSBjb3VsZCByZWx5IG9uIEluZGV4UHJl ZmV0Y2hJc0NhY2hlZCBkb2luZyB0aGlzIHVzaW5nCisJICogdGhlIGZ1bGwgY2FjaGUsIGJ1 dCB0aGlzIGNoZWNrIGlzIG11Y2ggY2hlYXBlciBhbmQgd2UgbmVlZCB0byBsb29rIGF0CisJ ICogdGhlIHByZWNlZGluZyBibG9jayBhbnl3YXksIHNvIHdlIGp1c3QgZG8gaXQuCisJICoK KwkgKiBOb3RpY2Ugd2UgaGF2ZW4ndCBhZGRlZCB0aGUgYmxvY2sgdG8gdGhlIGJsb2NrIHF1 ZXVlIHlldCwgYW5kIHRoZXJlCisJICogaXMgYSBwcmVjZWRpbmcgYmxvY2sgKGkuZS4gYmxv Y2tJbmRleC0xIGlzIHZhbGlkKS4KKwkgKi8KKwlpZiAocHJlZmV0Y2gtPmJsb2NrSXRlbXNb UFJFRkVUQ0hfQkxPQ0tfSU5ERVgocHJlZmV0Y2gtPmJsb2NrSW5kZXggLSAxKV0gPT0gYmxv Y2spCisJCXJldHVybiB0cnVlOworCisJLyoKKwkgKiBBZGQgdGhlIGJsb2NrIG51bWJlciB0 byB0aGUgc21hbGwgcXVldWUuCisJICoKKwkgKiBEb25lIGJlZm9yZSBjaGVja2luZyBpZiB0 aGUgcGF0dGVybiBpcyBzZXF1ZW50aWFsLCBiZWNhdXNlIHdlIHdhbnQgdG8KKwkgKiBrbm93 IGFib3V0IHRoZSBibG9jayBsYXRlciwgZXZlbiBpZiB3ZSBlbmQgdXAgc2tpcHBpbmcgdGhl IHByZWZldGNoLgorCSAqIE90aGVyd2lzZSB3ZSdkIG5vdCBiZSBhYmxlIHRvIGRldGVjdCBs b25nZXIgc2VxdWVudGlhbCBwYXR0ZW5zIC0gd2UnZAorCSAqIHNraXAgb25lIGJsb2NrIGFu ZCB0aGVuIGZhaWwgdG8gc2tpcCB0aGUgbmV4dCBjb3VwbGUgYmxvY2tzIGV2ZW4gaW4gYQor CSAqIHBlcmZlY3RseSBzZXF1ZW50aWFsIHBhdHRlcm4uIEFuZCB0aGlzIG9jaWxsYXRpb24g bWlnaHQgZXZlbiBwcmV2ZW50CisJICogdGhlIE9TIHJlYWQtYWhlYWQgZnJvbSBraWNraW5n IGluLgorCSAqLworCXByZWZldGNoLT5ibG9ja0l0ZW1zW1BSRUZFVENIX0JMT0NLX0lOREVY KHByZWZldGNoLT5ibG9ja0luZGV4KV0gPSBibG9jazsKKwlwcmVmZXRjaC0+YmxvY2tJbmRl eCsrOworCisJLyoKKwkgKiBBcmUgdGhlcmUgZW5vdWdoIHJlcXVlc3RzIHRvIGNvbmZpcm0g YSBzZXF1ZW50aWFsIHBhdHRlcm4/IFdlIG9ubHkKKwkgKiBjb25zaWRlciBzb21ldGhpbmcg dG8gYmUgc2VxdWVudGlhbCBhZnRlciBmaW5kaW5nIGEgc2VxdWVuY2Ugb2YKKwkgKiBQUkVG RVRDSF9RVUVVRV9ISVNUT1JZIGJsb2Nrcy4KKwkgKi8KKwlpZiAocHJlZmV0Y2gtPmJsb2Nr SW5kZXggPCBQUkVGRVRDSF9RVUVVRV9ISVNUT1JZKQorCQlyZXR1cm4gZmFsc2U7CisKKwkv KgorCSAqIENoZWNrIGlmIHRoZSBsYXN0IGNvdXBsZSBibG9ja3MgYXJlIGluIGEgc2VxdWVu dGlhbCBwYXR0ZXJuLiBXZSBsb29rCisJICogZm9yIGEgc2VxdWVudGlhbCBwYXR0ZXJuIG9m IFBSRUZFVENIX1FVRVVFX0hJU1RPUlkgKDggYnkgZGVmYXVsdCksIHNvCisJICogd2UgbG9v ayBmb3IgcGF0dGVybnMgb2YgOCBwYWdlcyAoNjRrQikgaW5jbHVkaW5nIHRoZSBuZXcgYmxv Y2suCisJICoKKwkgKiBYWFggQ291bGQgaXQgYmUgaGFybWZ1bCB0aGF0IHdlIHJlYWQgdGhl IHF1ZXVlIGJhY2t3YXJkcz8gTWF5YmUgbWVtb3J5CisJICogcHJlZmV0Y2hpbmcgd29ya3Mg YmV0dGVyIGZvciB0aGUgZm9yd2FyZCBkaXJlY3Rpb24/CisJICovCisJZm9yIChpbnQgaSA9 IDE7IGkgPCBQUkVGRVRDSF9RVUVVRV9ISVNUT1JZOyBpKyspCisJeworCQkvKgorCQkgKiBD YWxjdWxhdGUgaW5kZXggb2YgdGhlIGVhcmxpZXIgYmxvY2sgKHdlIG5lZWQgdG8gZG8gLTEg YXMgd2UKKwkJICogYWxyZWFkeSBpbmNyZW1lbnRlZCB0aGUgaW5kZXggYWZ0ZXIgYWRkaW5n IHRoZSBuZXcgYmxvY2sgdG8gdGhlCisJCSAqIHF1ZXVlKS4gU28gKGJsb2NrSW5kZXgtMSkg aXMgdGhlIG5ldyBibG9jay4KKwkJICovCisJCWlkeCA9IFBSRUZFVENIX0JMT0NLX0lOREVY KHByZWZldGNoLT5ibG9ja0luZGV4IC0gaSAtIDEpOworCisJCS8qCisJCSAqIEZvciBhIHNl cXVlbnRpYWwgcGF0dGVybiwgYmxvY2tzICJrIiBzdGVwIGFnbyBuZWVkcyB0byBoYXZlIGJs b2NrCisJCSAqIG51bWJlciBieSAiayIgc21hbGxlciBjb21wYXJlZCB0byB0aGUgY3VycmVu dCBibG9jay4KKwkJICovCisJCWlmIChwcmVmZXRjaC0+YmxvY2tJdGVtc1tpZHhdICE9IChi bG9jayAtIGkpKQorCQkJcmV0dXJuIGZhbHNlOworCisJCS8qIERvbid0IHByZWZldGNoIGlm IHRoZSBibG9jayBoYXBwZW5zIHRvIGJlIHRoZSBzYW1lLiAqLworCQlpZiAocHJlZmV0Y2gt PmJsb2NrSXRlbXNbaWR4XSA9PSBibG9jaykKKwkJCXJldHVybiBmYWxzZTsKKwl9CisKKwkv KiBub3Qgc2VxdWVudGlhbCwgbm90IHJlY2VudGx5IHByZWZldGNoZWQgKi8KKwlyZXR1cm4g dHJ1ZTsKK30KKworLyoKKyAqIEluZGV4UHJlZmV0Y2hJc0NhY2hlZAorICoJCUNoZWNrIGlm IHRoZSBibG9jayB3YXMgcHJlZmV0Y2hlZCByZWNlbnRseSwgYW5kIHVwZGF0ZSB0aGUgY2Fj aGUuCisgKgorICogV2UgZG9uJ3Qgd2FudCB0byBwcmVmZXRjaCBibG9ja3MgdGhhdCB3ZSBh bHJlYWR5IHByZWZldGNoZWQgcmVjZW50bHkuIEl0J3MKKyAqIGNoZWFwIGJ1dCBub3QgZnJl ZSwgYW5kIHRoZSBvdmVyaGVhZCBtYXkgYmUgcXVpdGUgc2lnbmlmaWNhbnQuCisgKgorICog V2Ugd2FudCB0byByZW1lbWJlciB3aGljaCBibG9ja3Mgd2VyZSBwcmVmZXRjaGVkIHJlY2Vu dGx5LCBzbyB0aGF0IHdlIGNhbgorICogc2tpcCByZXBlYXRlZCBwcmVmZXRjaGVzLiBXZSBh bHNvIG5lZWQgdG8gZXZlbnR1YWxseSBmb3JnZXQgdGhlc2UgYmxvY2tzCisgKiBhcyB0aGV5 IG1heSBnZXQgZXZpY3RlZCBmcm9tIG1lbW9yeSAocGFydGljdWxhcmx5IHBhZ2UgY2FjaGUs IHdoaWNoIGlzCisgKiBvdXRzaWRlIG91ciBjb250cm9sKS4KKyAqCisgKiBBIHNpbXBsZSBx dWV1ZSBpcyBub3QgYSB2aWFibGUgb3B0aW9uIC0gaXQgd291bGQgYWxsb3cgZXhwaXJpbmcg cmVxdWVzdHMKKyAqIGJhc2VkIG9uIGFnZSwgYnV0IGl0J3MgdmVyeSBleHBlbnNpdmUgdG8g Y2hlY2sgKGFzIGl0IHJlcXVpcmVzIGxpbmVhcgorICogc2VhcmNoLCBhbmQgd2UgbmVlZCBm YWlybHkgbGFyZ2UgbnVtYmVyIG9mIGVudHJpZXMpLiBIYXNoIHRhYmxlIGRvZXMgbm90Cisg KiB3b3JrIGJlY2F1c2UgaXQgZG9lcyBub3QgYWxsb3cgZXhwaXJpbmcgZW50cmllcyBieSBh Z2UuCisgKgorICogVGhlIGNhY2hlIGRvZXMgbm90IG5lZWQgdG8gYmUgcGVyZmVjdCAtIGZh bHNlIHBvc2l0aXZlcy9uZWdhdGl2ZXMgYXJlCisgKiBib3RoIGFjY2VwdGFibGUsIGFzIGxv bmcgYXMgdGhlIHJhdGUgaXMgcmVhc29uYWJseSBsb3cuCisgKgorICogV2UgdXNlIGEgaHli cmlkIGNhY2hlIHRoYXQgaXMgb3JnYW5pemVkIGFzIG1hbnkgc21hbGwgTFJVIGNhY2hlcy4g RWFjaAorICogYmxvY2sgaXMgbWFwcGVkIHRvIGEgcGFydGljdWxhciBMUlUgYnkgaGFzaGlu ZyAoc28gaXQncyBhIGJpdCBsaWtlIGEKKyAqIGhhc2ggdGFibGUgb2YgTFJVcykuIFRoZSBM UlUgY2FjaGVzIGFyZSB0aW55IChlLmcuIDggZW50cmllcyksIGFuZCB0aGUKKyAqIGV4cGly YXRpb24gaGFwcGVucyBhdCB0aGUgbGV2ZWwgb2YgYSBzaW5nbGUgTFJVICh1c2luZyBhZ2Ug ZGV0ZXJtaW5lZAorICogYnkgc2VxdWVudGlhbCByZXF1ZXN0IG51bWJlcikuCisgKgorICog VGhpcyBhbGxvd3MgcXVpY2sgc2VhcmNoZXMgYW5kIGV4cGlyYXRpb24sIHdpdGggZmFsc2Ug bmVnYXRpdmVzICh3aGVuIGEKKyAqIHBhcnRpY3VsYXIgTFJVIGhhcyB0b28gbWFueSBjb2xs aXNpb25zIHdpdGggaG90IGJsb2Nrcywgd2UgbWF5IGVuZCB1cAorICogZXZpY3RpbmcgZW50 cmllcyB0aGF0IGFyZSBtb3JlIHJlY2VudCB0aGFuIHNvbWUgb3RoZXIgTFJVKS4KKyAqCisg KiBGb3IgZXhhbXBsZSwgaW1hZ2luZSAxMjggTFJVIGNhY2hlcywgZWFjaCB3aXRoIDggZW50 cmllcyAtIHRoYXQncyAxMDI0CisgKiByZXF1ZXN0IGluIHRvdGFsICh0aGVzZSBhcmUgdGhl IGRlZmF1bHQgcGFyYW1ldGVycy4pIHJlcHJlc2VudGluZyBhYm91dAorICogOE1CIG9mIGRh dGEuCisgKgorICogSWYgd2Ugd2FudCB0byBjaGVjayBpZiBhIGJsb2NrIHdhcyByZWNlbnRs eSBwcmVmZXRjaGVkLCB3ZSBjYWxjdWxhdGUKKyAqIChoYXNoKGJsa25vKSAlIDEyOCkgYW5k IHNlYXJjaCBvbmx5IExSVSBhdCB0aGlzIGluZGV4LCB1c2luZyBhIGxpbmVhcgorICogc2Vh cmNoLiBJZiB3ZSB3YW50IHRvIGFkZCB0aGUgYmxvY2sgdG8gdGhlIGNhY2hlLCB3ZSBmaW5k IGVpdGhlciBhbgorICogZW1wdHkgc2xvdCBvciB0aGUgIm9sZGVzdCIgZW50cnkgaW4gdGhl IExSVSwgYW5kIHN0b3JlIHRoZSBibG9jayBpbiBpdC4KKyAqIElmIHRoZSBibG9jayBpcyBh bHJlYWR5IGluIHRoZSBMUlUsIHdlIG9ubHkgdXBkYXRlIHRoZSByZXF1ZXN0IG51bWJlci4K KyAqCisgKiBUaGUgcmVxdWVzdCBhZ2UgaXMgZGV0ZXJtaW5lZCB1c2luZyBhIHByZWZldGNo IGNvdW50ZXIsIGluY3JlbWVudGVkIGV2ZXJ5CisgKiB0aW1lIHdlIGVuZCB1cCBwcmVmZXRj aGluZyBhIGJsb2NrLiBUaGUgY291bnRlciBpcyB1aW50MzIsIHNvIGl0IHNob3VsZAorICog bm90IHdyYXAgKHdlJ2QgaGF2ZSB0byBwcmVmZXRjaCAzMlRCKS4KKyAqCisgKiBJZiB0aGUg cmVxdWVzdCBudW1iZXIgaXMgbm90IGxlc3MgdGhhbiBQUkVGRVRDSF9DQUNIRV9TSVpFIGFn bywgaXQncworICogY29uc2lkZXJlZCAicmVjZW50bHkgcHJlZmV0Y2hlZCIuIFRoYXQgaXMs IHRoZSBtYXhpbXVtIGFnZSBpcyB0aGUgc2FtZQorICogYXMgdGhlIHRvdGFsIGNhcGFjaXR5 IG9mIHRoZSBjYWNoZS4KKyAqCisgKiBSZXR1cm5zIHRydWUgaWYgdGhlIGJsb2NrIHdhcyBy ZWNlbnRseSBwcmVmZXRjaGVkIChhbmQgdGh1cyB3ZSBkb24ndAorICogbmVlZCB0byBwcmVm ZXRjaCBpdCBhZ2FpbiksIG9yIGZhbHNlIChzaG91bGQgZG8gYSBwcmVmZXRjaCkuCisgKgor ICogWFhYIEl0J3MgYSBiaXQgY29uZnVzaW5nIHRoZXNlIHJldHVybiB2YWx1ZXMgYXJlIGlu dmVyc2UgY29tcGFyZWQgdG8KKyAqIHdoYXQgSW5kZXhQcmVmZXRjaEJsb2NrSXNTZXF1ZW50 aWFsIGRvZXMuCisgKgorICogWFhYIFNob3VsZCB3ZSBpbmNyZWFzZSB0aGUgcHJlZmV0Y2gg Y291bnRlciBldmVuIGlmIHdlIGRldGVybWluZSB0aGUKKyAqIGVudHJ5IHdhcyByZWNlbnRs eSBwcmVmZXRjaGVkPyBUaGVuIHdlIG1pZ2h0IHNraXAgc29tZSByZXF1ZXN0IG51bWJlcnMK KyAqICh0aGVyZSdzIGJlIG5vIGVudHJ5IHdpdGggdGhlbSkuCisgKi8KK3N0YXRpYyBib29s CitJbmRleFByZWZldGNoSXNDYWNoZWQoSW5kZXhQcmVmZXRjaCAqcHJlZmV0Y2gsIEJsb2Nr TnVtYmVyIGJsb2NrKQoreworCUluZGV4UHJlZmV0Y2hDYWNoZUVudHJ5ICplbnRyeTsKKwor CS8qIG1hcCB0aGUgYmxvY2sgbnVtYmVyIHRoZSB0aGUgTFJVICovCisJaW50CQkJbHJ1Owor CisJLyogYWdlL2luZGV4IG9mIHRoZSBvbGRlc3QgZW50cnkgaW4gdGhlIExSVSwgdG8gbWF5 YmUgdXNlICovCisJdWludDY0CQlvbGRlc3RSZXF1ZXN0ID0gUEdfVUlOVDY0X01BWDsKKwlp bnQJCQlvbGRlc3RJbmRleCA9IC0xOworCisJLyoKKwkgKiBGaXJzdCBhZGQgdGhlIGJsb2Nr IHRvIHRoZSAodGlueSkgcXVldWUgYW5kIHNlZSBpZiBpdCdzIHBhcnQgb2YgYQorCSAqIHNl cXVlbnRpYWwgcGF0dGVybi4gSW4gdGhpcyBjYXNlIHdlIGp1c3QgaWdub3JlIHRoZSBibG9j ayBhbmQgZG9uJ3QKKwkgKiBwcmVmZXRjaCBpdCAtIHdlIGV4cGVjdCBPUyByZWFkLWFoZWFk IHRvIGRvIGEgYmV0dGVyIGpvYi4KKwkgKgorCSAqIFhYWCBNYXliZSB3ZSBzaG91bGQgc3Rp bGwgYWRkIHRoZSBibG9jayB0byB0aGUgbWFpbiBjYWNoZSwgaW4gY2FzZSB3ZQorCSAqIGhh cHBlbiB0byBhY2Nlc3MgaXQgbGF0ZXIuIFRoYXQgbWlnaHQgaGVscCBpZiB3ZSBoYXBwZW4g dG8gc2NhbiBhIGxvdAorCSAqIG9mIHRoZSB0YWJsZSBzZXF1ZW50aWFsbHksIGFuZCB0aGVu IHJhbmRvbWx5LiBOb3Qgc3VyZSB0aGF0J3MgdmVyeQorCSAqIGxpa2VseSB3aXRoIGluZGV4 IGFjY2VzcywgdGhvdWdoLgorCSAqLworCWlmIChJbmRleFByZWZldGNoQmxvY2tJc1NlcXVl bnRpYWwocHJlZmV0Y2gsIGJsb2NrKSkKKwl7CisJCXByZWZldGNoLT5jb3VudFNraXBTZXF1 ZW50aWFsKys7CisJCXJldHVybiB0cnVlOworCX0KKworCS8qIFdoaWNoIExSVSBkb2VzIHRo aXMgYmxvY2sgYmVsb25nIHRvPyAqLworCWxydSA9IGhhc2hfdWludDMyKGJsb2NrKSAlIFBS RUZFVENIX0xSVV9DT1VOVDsKKworCS8qCisJICogRGlkIHdlIHByZWZldGNoIHRoaXMgYmxv Y2sgcmVjZW50bHk/IFNjYW4gdGhlIExSVSBsaW5lYXJseSwgYW5kIHdoaWxlCisJICogZG9p bmcgdGhhdCwgdHJhY2sgdGhlIG9sZGVzdCAob3IgZW1wdHkpIGVudHJ5LCBzbyB0aGF0IHdl IGtub3cgd2hlcmUgdG8KKwkgKiBwdXQgdGhlIGJsb2NrIGlmIHdlIGRvbid0IGZpbmQgYSBt YXRjaC4KKwkgKi8KKwlmb3IgKGludCBpID0gMDsgaSA8IFBSRUZFVENIX0xSVV9TSVpFOyBp KyspCisJeworCQllbnRyeSA9IFBSRUZFVENIX0xSVV9FTlRSWShwcmVmZXRjaCwgbHJ1LCBp KTsKKworCQkvKgorCQkgKiBJcyB0aGlzIHRoZSBvbGRlc3QgcHJlZmV0Y2ggcmVxdWVzdCBp biB0aGlzIExSVT8KKwkJICoKKwkJICogTm90aWNlIHRoYXQgcmVxdWVzdCBpcyB1aW50MzIs IHNvIGFuIGVtcHR5IGVudHJ5ICh3aXRoIHJlcXVlc3Q9MCkKKwkJICogaXMgYXV0b21hdGlj YWxseSBvbGRlc3Qgb25lLgorCQkgKi8KKwkJaWYgKGVudHJ5LT5yZXF1ZXN0IDwgb2xkZXN0 UmVxdWVzdCkKKwkJeworCQkJb2xkZXN0UmVxdWVzdCA9IGVudHJ5LT5yZXF1ZXN0OworCQkJ b2xkZXN0SW5kZXggPSBpOworCQl9CisKKwkJLyogU2tpcCB1bnVzZWQgZW50cmllcy4gKi8K KwkJaWYgKGVudHJ5LT5yZXF1ZXN0ID09IDApCisJCQljb250aW51ZTsKKworCQkvKiBJcyB0 aGlzIGVudHJ5IGZvciB0aGUgc2FtZSBibG9jayBhcyB0aGUgY3VycmVudCByZXF1ZXN0PyAq LworCQlpZiAoZW50cnktPmJsb2NrID09IGJsb2NrKQorCQl7CisJCQlib29sCQlwcmVmZXRj aGVkOworCisJCQkvKgorCQkJICogSXMgdGhlIG9sZCByZXF1ZXN0IHN1ZmZpY2llbnRseSBy ZWNlbnQ/IElmIHllcywgd2UgdHJlYXQgdGhlCisJCQkgKiBibG9jayBhcyBhbHJlYWR5IHBy ZWZldGNoZWQuIFdlIG5lZWQgdG8gY2hlY2sgYmVmb3JlIHVwZGF0aW5nCisJCQkgKiB0aGUg cHJlZmV0Y2ggcmVxdWVzdC4KKwkJCSAqCisJCQkgKiBYWFggV2UgZG8gYWRkIHRoZSBjYWNo ZSBzaXplIHRvIHRoZSByZXF1ZXN0IGluIG9yZGVyIG5vdCB0bworCQkJICogaGF2ZSBpc3N1 ZXMgd2l0aCB1bmRlcmZsb3dzLgorCQkJICovCisJCQlwcmVmZXRjaGVkID0gKChlbnRyeS0+ cmVxdWVzdCArIFBSRUZFVENIX0NBQ0hFX1NJWkUpID49IHByZWZldGNoLT5wcmVmZXRjaFJl cXVlc3QpOworCisJCQlwcmVmZXRjaC0+Y291bnRTa2lwQ2FjaGVkICs9IChwcmVmZXRjaGVk KSA/IDEgOiAwOworCisJCQkvKiBVcGRhdGUgdGhlIHJlcXVlc3QgbnVtYmVyLiAqLworCQkJ ZW50cnktPnJlcXVlc3QgPSArK3ByZWZldGNoLT5wcmVmZXRjaFJlcXVlc3Q7CisKKwkJCXJl dHVybiBwcmVmZXRjaGVkOworCQl9CisJfQorCisJLyoKKwkgKiBXZSBkaWRuJ3QgZmluZCB0 aGUgYmxvY2sgaW4gdGhlIExSVSwgc28gc3RvcmUgaXQgdGhlICJvbGRlc3QiIHByZWZldGNo CisJICogcmVxdWVzdCBpbiB0aGlzIExSVSAod2hpY2ggbWlnaHQgYmUgYW4gZW1wdHkgZW50 cnkpLgorCSAqLworCUFzc2VydCgob2xkZXN0SW5kZXggPj0gMCkgJiYgKG9sZGVzdEluZGV4 IDwgUFJFRkVUQ0hfTFJVX1NJWkUpKTsKKworCWVudHJ5ID0gUFJFRkVUQ0hfTFJVX0VOVFJZ KHByZWZldGNoLCBscnUsIG9sZGVzdEluZGV4KTsKKworCWVudHJ5LT5ibG9jayA9IGJsb2Nr OworCWVudHJ5LT5yZXF1ZXN0ID0gKytwcmVmZXRjaC0+cHJlZmV0Y2hSZXF1ZXN0OworCisJ Lyogbm90IGluIHRoZSBwcmVmZXRjaCBjYWNoZSAqLworCXJldHVybiBmYWxzZTsKK30KKwor LyoKKyAqIEluZGV4UHJlZmV0Y2hIZWFwUGFnZQorICoJCVByZWZldGNoIGEgaGVhcCBwYWdl IGZvciB0aGUgVElELCB1bmxlc3MgaXQncyBzZXF1ZW50aWFsIG9yIHdhcworICoJCXJlY2Vu dGx5IHByZWZldGNoZWQuCisgKi8KK3N0YXRpYyB2b2lkCitJbmRleFByZWZldGNoSGVhcFBh Z2UoSW5kZXhTY2FuRGVzYyBzY2FuLCBJbmRleFByZWZldGNoICpwcmVmZXRjaCwgSW5kZXhQ cmVmZXRjaEVudHJ5ICplbnRyeSkKK3sKKwlCbG9ja051bWJlciBibG9jayA9IEl0ZW1Qb2lu dGVyR2V0QmxvY2tOdW1iZXIoJmVudHJ5LT50aWQpOworCisJcHJlZmV0Y2gtPmNvdW50QWxs Kys7CisKKwkvKgorCSAqIERvIG5vdCBwcmVmZXRjaCB0aGUgc2FtZSBibG9jayBvdmVyIGFu ZCBvdmVyIGFnYWluLCBpZiBpdCdzIHByb2JhYmx5CisJICogc3RpbGwgaW4gbWVtb3J5IChw YWdlIGNhY2hlKS4KKwkgKgorCSAqIFRoaXMgaGFwcGVucyBlLmcuIGZvciBjbHVzdGVyZWQg b3IgbmF0dXJhbGx5IGNvcnJlbGF0ZWQgaW5kZXhlcyAoZmtleQorCSAqIHRvIGEgc2VxdWVu Y2UgSUQpLiBJdCdzIG5vdCBleHBlbnNpdmUgKHRoZSBibG9jayBpcyBpbiBwYWdlIGNhY2hl CisJICogYWxyZWFkeSwgc28gbm8gSS9PKSwgYnV0IGl0J3Mgbm90IGZyZWUgZWl0aGVyLgor CSAqCisJICogSWYgd2UgbWFrZSBhIG1pc3Rha2UgYW5kIHByZWZldGNoIGEgYnVmZmVyIHRo YXQncyBzdGlsbCBpbiBvdXIgc2hhcmVkCisJICogYnVmZmVycywgUHJlZmV0Y2hCdWZmZXIg d2lsbCB0YWtlIGNhcmUgb2YgdGhhdC4gSWYgaXQncyBpbiBwYWdlIGNhY2hlLAorCSAqIHdl J2xsIGlzc3VlIGFuIHVubmVjZXNzYXJ5IHByZWZldGNoLiBUaGVyZSdzIG5vdCBtdWNoIHdl IGNhbiBkbyBhYm91dAorCSAqIHRoYXQsIHVuZm9ydHVuYXRlbHkuCisJICoKKwkgKiBYWFgg TWF5YmUgd2UgY291bGQgY2hlY2sgUHJlZmV0Y2hCdWZmZXJSZXN1bHQgYW5kIGFkanVzdCBj b3VudFByZWZldGNoCisJICogYmFzZWQgb24gdGhhdD8KKwkgKi8KKwlpZiAoSW5kZXhQcmVm ZXRjaElzQ2FjaGVkKHByZWZldGNoLCBibG9jaykpCisJCXJldHVybjsKKworCXByZWZldGNo LT5jb3VudFByZWZldGNoKys7CisKKwlQcmVmZXRjaEJ1ZmZlcihzY2FuLT5oZWFwUmVsYXRp b24sIE1BSU5fRk9SS05VTSwgYmxvY2spOworCXBnQnVmZmVyVXNhZ2UuYmxrc19wcmVmZXRj aGVzKys7Cit9CisKKy8qCisgKiBJbmRleFByZWZldGNoRmlsbFF1ZXVlCisgKgkJRmlsbCB0 aGUgcHJlZmV0Y2ggcXVldWUgYW5kIGlzc3VlIG5lY2Vzc2FyeSBwcmVmZXRjaCByZXF1ZXN0 cy4KKyAqCisgKiBJZiB0aGUgcHJlZmV0Y2hpbmcgaXMgc3RpbGwgYWN0aXZlIChlbmFibGVk LCBub3QgcmVhY2hlZCBlbmQgb2Ygc2NhbiksIHJlYWQKKyAqIFRJRHMgaW50byB0aGUgcXVl dWUgdW50aWwgd2UgaGl0IHRoZSBjdXJyZW50IHRhcmdldC4KKyAqCisgKiBUaGlzIGFsc28g cmFtcHMtdXAgdGhlIHByZWZldGNoIHRhcmdldCBmcm9tIDAgdG8gcHJlZmV0Y2hfbWF4LCBk ZXRlcm1pbmVkCisgKiB3aGVuIGFsbG9jYXRpbmcgdGhlIHByZWZldGNoZXIuCisgKi8KK3N0 YXRpYyB2b2lkCitJbmRleFByZWZldGNoRmlsbFF1ZXVlKEluZGV4U2NhbkRlc2Mgc2Nhbiwg SW5kZXhQcmVmZXRjaCAqcHJlZmV0Y2gsIFNjYW5EaXJlY3Rpb24gZGlyZWN0aW9uKQorewor CS8qIFdoZW4gaW5hY3RpdmUgKG5vdCBlbmFibGVkIG9yIGVuZCBvZiBzY2FuIHJlYWNoZWQp LCB3ZSdyZSBkb25lLiAqLworCWlmICghUFJFRkVUQ0hfQUNUSVZFKHByZWZldGNoKSkKKwkJ cmV0dXJuOworCisJLyoKKwkgKiBSYW1wIHVwIHRoZSBwcmVmZXRjaCBkaXN0YW5jZSBpbmNy ZW1lbnRhbGx5LgorCSAqCisJICogSW50ZW50aW9uYWxseSBkb25lIGFzIGZpcnN0LCBiZWZv cmUgcmVhZGluZyB0aGUgVElEcyBpbnRvIHRoZSBxdWV1ZSwgc28KKwkgKiB0aGF0IHRoZXJl J3MgYWx3YXlzIGF0IGxlYXN0IG9uZSBpdGVtLiBPdGhlcndpc2Ugd2UgbWlnaHQgZ2V0IGlu dG8gYQorCSAqIHNpdHVhdGlvbiB3aGVyZSB3ZSBzdGFydCB3aXRoIHRhcmdldD0wIGFuZCBu byBUSURzIGxvYWRlZC4KKwkgKi8KKwlwcmVmZXRjaC0+cHJlZmV0Y2hUYXJnZXQgPSBNaW4o cHJlZmV0Y2gtPnByZWZldGNoVGFyZ2V0ICsgMSwKKwkJCQkJCQkJICAgcHJlZmV0Y2gtPnBy ZWZldGNoTWF4VGFyZ2V0KTsKKworCS8qCisJICogUmVhZCBUSURzIGZyb20gdGhlIGluZGV4 IHVudGlsIHRoZSBxdWV1ZSBpcyBmdWxsICh3aXRoIHJlc3BlY3QgdG8gdGhlCisJICogY3Vy cmVudCBwcmVmZXRjaCB0YXJnZXQpLgorCSAqLworCXdoaWxlICghUFJFRkVUQ0hfUVVFVUVf RlVMTChwcmVmZXRjaCkpCisJeworCQlJbmRleFByZWZldGNoRW50cnkgKmVudHJ5CisJCT0g cHJlZmV0Y2gtPm5leHRfY2Ioc2NhbiwgZGlyZWN0aW9uLCBwcmVmZXRjaC0+ZGF0YSk7CisK KwkJLyogbm8gbW9yZSBlbnRyaWVzIGluIHRoaXMgaW5kZXggc2NhbiAqLworCQlpZiAoZW50 cnkgPT0gTlVMTCkKKwkJeworCQkJcHJlZmV0Y2gtPnByZWZldGNoRG9uZSA9IHRydWU7CisJ CQlyZXR1cm47CisJCX0KKworCQlBc3NlcnQoSXRlbVBvaW50ZXJFcXVhbHMoJmVudHJ5LT50 aWQsICZzY2FuLT54c19oZWFwdGlkKSk7CisKKwkJLyogc3RvcmUgdGhlIGVudHJ5IGFuZCB0 aGVuIG1heWJlIGlzc3VlIHRoZSBwcmVmZXRjaCByZXF1ZXN0ICovCisJCXByZWZldGNoLT5x dWV1ZUl0ZW1zW1BSRUZFVENIX1FVRVVFX0lOREVYKHByZWZldGNoLT5xdWV1ZUVuZCsrKV0g PSAqZW50cnk7CisKKwkJLyogaXNzdWUgdGhlIHByZWZldGNoIHJlcXVlc3Q/ICovCisJCWlm IChlbnRyeS0+cHJlZmV0Y2gpCisJCQlJbmRleFByZWZldGNoSGVhcFBhZ2Uoc2NhbiwgcHJl ZmV0Y2gsIGVudHJ5KTsKKwl9Cit9CisKKy8qCisgKiBJbmRleFByZWZldGNoTmV4dEVudHJ5 CisgKgkJR2V0IHRoZSBuZXh0IGVudHJ5IGZyb20gdGhlIHByZWZldGNoIHF1ZXVlIChvciBm cm9tIHRoZSBpbmRleCBkaXJlY3RseSkuCisgKgorICogSWYgcHJlZmV0Y2hpbmcgaXMgZW5h YmxlZCwgZ2V0IG5leHQgZW50cnkgZnJvbSB0aGUgcHJlZmV0Y2ggcXVldWUgKHVubGVzcwor ICogcXVldWUgaXMgZW1wdHkpLiBXaXRoIHByZWZldGNoaW5nIGRpc2FibGVkLCByZWFkIGFu IGVudHJ5IGRpcmVjdGx5IGZyb20gdGhlCisgKiBpbmRleCBzY2FuLgorICoKKyAqIFhYWCBu b3Qgc3VyZSB0aGlzIGNvcnJlY3RseSBoYW5kbGVzIHhzX2hlYXBfY29udGludWUgLSBzZWUg aW5kZXhfZ2V0bmV4dF9zbG90LAorICogbWF5YmUgbm9kZUluZGV4c2NhbiBuZWVkcyB0byBk byBzb21ldGhpbmcgbW9yZSB0byBoYW5kbGUgdGhpcz8gQWx0aG91Z2gsIHRoYXQKKyAqIHNo b3VsZCBiZSBpbiB0aGUgaW5kZXhzY2FuIG5leHRfY2IgY2FsbGJhY2ssIHByb2JhYmx5Lgor ICoKKyAqIFhYWCBJZiB4c19oZWFwX2NvbnRpbnVlPXRydWUsIHdlIG5lZWQgdG8gcmV0dXJu IHRoZSBsYXN0IFRJRC4KKyAqLworc3RhdGljIEluZGV4UHJlZmV0Y2hFbnRyeSAqCitJbmRl eFByZWZldGNoTmV4dEVudHJ5KEluZGV4U2NhbkRlc2Mgc2NhbiwgSW5kZXhQcmVmZXRjaCAq cHJlZmV0Y2gsIFNjYW5EaXJlY3Rpb24gZGlyZWN0aW9uKQoreworCUluZGV4UHJlZmV0Y2hF bnRyeSAqZW50cnkgPSBOVUxMOworCisJLyoKKwkgKiBXaXRoIHByZWZldGNoaW5nIGVuYWJs ZWQgKGV2ZW4gaWYgd2UgYWxyZWFkeSBmaW5pc2hlZCByZWFkaW5nIGFsbCBUSURzCisJICog ZnJvbSB0aGUgaW5kZXggc2NhbiksIHdlIG5lZWQgdG8gcmV0dXJuIGEgVElEIGZyb20gdGhl IHF1ZXVlLgorCSAqIE90aGVyd2lzZSwgd2UganVzdCBnZXQgdGhlIG5leHQgVElEIGZyb20g dGhlIHNjYW4gZGlyZWN0bHkuCisJICovCisJaWYgKFBSRUZFVENIX0VOQUJMRUQocHJlZmV0 Y2gpKQorCXsKKwkJLyogRGlkIHdlIHJlYWNoIHRoZSBlbmQgb2YgdGhlIHNjYW4gYW5kIHRo ZSBxdWV1ZSBpcyBlbXB0eT8gKi8KKwkJaWYgKFBSRUZFVENIX0RPTkUocHJlZmV0Y2gpKQor CQkJcmV0dXJuIE5VTEw7CisKKwkJZW50cnkgPSBwYWxsb2Moc2l6ZW9mKEluZGV4UHJlZmV0 Y2hFbnRyeSkpOworCisJCWVudHJ5LT50aWQgPSBwcmVmZXRjaC0+cXVldWVJdGVtc1tQUkVG RVRDSF9RVUVVRV9JTkRFWChwcmVmZXRjaC0+cXVldWVJbmRleCldLnRpZDsKKwkJZW50cnkt PmRhdGEgPSBwcmVmZXRjaC0+cXVldWVJdGVtc1tQUkVGRVRDSF9RVUVVRV9JTkRFWChwcmVm ZXRjaC0+cXVldWVJbmRleCldLmRhdGE7CisKKwkJcHJlZmV0Y2gtPnF1ZXVlSW5kZXgrKzsK KworCQlzY2FuLT54c19oZWFwdGlkID0gZW50cnktPnRpZDsKKwl9CisJZWxzZQkJCQkJCS8q IG5vdCBwcmVmZXRjaGluZywganVzdCBkbyB0aGUgcmVndWxhciB3b3JrICAqLworCXsKKwkJ SXRlbVBvaW50ZXIgdGlkOworCisJCS8qIFRpbWUgdG8gZmV0Y2ggdGhlIG5leHQgVElEIGZy b20gdGhlIGluZGV4ICovCisJCXRpZCA9IGluZGV4X2dldG5leHRfdGlkKHNjYW4sIGRpcmVj dGlvbik7CisKKwkJLyogSWYgd2UncmUgb3V0IG9mIGluZGV4IGVudHJpZXMsIHdlJ3JlIGRv bmUgKi8KKwkJaWYgKHRpZCA9PSBOVUxMKQorCQkJcmV0dXJuIE5VTEw7CisKKwkJQXNzZXJ0 KEl0ZW1Qb2ludGVyRXF1YWxzKHRpZCwgJnNjYW4tPnhzX2hlYXB0aWQpKTsKKworCQllbnRy eSA9IHBhbGxvYyhzaXplb2YoSW5kZXhQcmVmZXRjaEVudHJ5KSk7CisKKwkJZW50cnktPnRp ZCA9IHNjYW4tPnhzX2hlYXB0aWQ7CisJCWVudHJ5LT5kYXRhID0gTlVMTDsKKwl9CisKKwly ZXR1cm4gZW50cnk7Cit9CisKKy8qCisgKiBJbmRleFByZWZldGNoQ29tcHV0ZVRhcmdldAor ICoJCUNhbGN1bGF0ZSBwcmVmZXRjaCBkaXN0YW5jZSBmb3IgdGhlIGdpdmVuIGhlYXAgcmVs YXRpb24uCisgKgorICogV2UgZGlzYWJsZSBwcmVmZXRjaGluZyB3aGVuIHVzaW5nIGRpcmVj dCBJL08gKHdoZW4gdGhlcmUncyBubyBwYWdlIGNhY2hlCisgKiB0byBwcmVmZXRjaCBpbnRv KSwgYW5kIHNjYW5zIHdoZXJlIHRoZSBwcmVmZXRjaCBkaXN0YW5jZSBtYXkgY2hhbmdlIChl LmcuCisgKiBmb3Igc2Nyb2xsYWJsZSBjdXJzb3JzKS4KKyAqCisgKiBJbiByZWd1bGFyIGNh c2VzIHdlIGxvb2sgYXQgZWZmZWN0aXZlX2lvX2NvbmN1cnJlbmN5IGZvciB0aGUgdGFibGVw YWNlCisgKiAob2YgdGhlIGhlYXAsIG5vdCB0aGUgaW5kZXgpLCBhbmQgY2FwIGl0IHdpdGgg cGxhbl9yb3dzLgorICoKKyAqIFhYWCBXZSBjYXAgdGhlIHRhcmdldCB0byBwbGFuX3Jvd3Ms IGJlY2F1c3NlIGl0J3MgcG9pbnRsZXNzIHRvIHByZWZldGNoCisgKiBtb3JlIHRoYW4gd2Ug ZXhwZWN0IHRvIHVzZS4KKyAqCisgKiBYWFggTWF5YmUgd2Ugc2hvdWxkIHJlZHVjZSB0aGUg dmFsdWUgd2l0aCBwYXJhbGxlbCB3b3JrZXJzPworICovCitpbnQKK0luZGV4UHJlZmV0Y2hD b21wdXRlVGFyZ2V0KFJlbGF0aW9uIGhlYXBSZWwsIGRvdWJsZSBwbGFuX3Jvd3MsIGJvb2wg cHJlZmV0Y2gpCit7CisJLyoKKwkgKiBObyBwcmVmZXRjaGluZyBmb3IgZGlyZWN0IEkvTy4K KwkgKgorCSAqIFhYWCBTaG91bGRuJ3Qgd2UgZG8gcHJlZmV0Y2hpbmcgZXZlbiBmb3IgZGly ZWN0IEkvTz8gV2Ugd291bGQgb25seQorCSAqIHByZXRlbmQgZG9pbmcgaXQgbm93LCBvZmMs IGJlY2F1c2Ugd2UnZCBub3QgZG8gcG9zaXhfZmFkdmlzZSgpLCBidXQKKwkgKiBvbmNlIHRo ZSBjb2RlIHN0YXJ0cyBsb2FkaW5nIGludG8gc2hhcmVkIGJ1ZmZlcnMsIHRoYXQnZCB3b3Jr LgorCSAqLworCWlmICgoaW9fZGlyZWN0X2ZsYWdzICYgSU9fRElSRUNUX0RBVEEpICE9IDAp CisJCXJldHVybiAwOworCisJLyogZGlzYWJsZSBwcmVmZXRjaGluZyAoZm9yIGN1cnNvcnMg ZXRjLikgKi8KKwlpZiAoIXByZWZldGNoKQorCQlyZXR1cm4gMDsKKworCS8qIHJlZ3VsYXIg Y2FzZSwgbG9vayBhdCB0YWJsZXNwYWNlIGVmZmVjdGl2ZV9pb19jb25jdXJyZW5jeSAqLwor CXJldHVybiBNaW4oZ2V0X3RhYmxlc3BhY2VfaW9fY29uY3VycmVuY3koaGVhcFJlbC0+cmRf cmVsLT5yZWx0YWJsZXNwYWNlKSwKKwkJCSAgIHBsYW5fcm93cyk7Cit9CisKKy8qCisgKiBJ bmRleFByZWZldGNoQWxsb2MKKyAqCQlBbGxvY2F0ZSB0aGUgaW5kZXggcHJlZmV0Y2hlci4K KyAqCisgKiBUaGUgYmVoYXZpb3IgaXMgY3VzdG9taXplZCBieSB0d28gY2FsbGJhY2tzIC0g bmV4dF9jYiwgd2hpY2ggZ2VuZXJhdGVzIFRJRAorICogdmFsdWVzIHRvIHB1dCBpbnRvIHRo ZSBwcmVmZXRjaCBxdWV1ZSwgYW5kIChvcHRpb25hbCkgY2xlYW51cF9jYiB3aGljaAorICog cmVsZWFzZXMgcmVzb3VyY2VzIGF0IHRoZSBlbmQuCisgKgorICogcHJlZmV0Y2hfbWF4IHNw ZWNpZmllcyB0aGUgbWF4aW11bSBwcmVmZXRjaCBkaXN0YW5jZSwgaS5lLiBob3cgbWFueSBU SURzCisgKiBhaGVhZCB0byBrZWVwIGluIHRoZSBwcmVmZXRjaCBxdWV1ZS4gcHJlZmV0Y2hf bWF4PTAgbWVhbnMgcHJlZmV0Y2hpbmcgaXMKKyAqIGRpc2FibGVkLgorICoKKyAqIGRhdGEg bWF5IHBvaW50IHRvIGEgY3VzdG9tIGRhdGEsIGFzc29jaWF0ZWQgd2l0aCB0aGUgcHJlZmV0 Y2hlci4KKyAqLworSW5kZXhQcmVmZXRjaCAqCitJbmRleFByZWZldGNoQWxsb2MoSW5kZXhQ cmVmZXRjaE5leHRDQiBuZXh0X2NiLCBJbmRleFByZWZldGNoQ2xlYW51cENCIGNsZWFudXBf Y2IsCisJCQkJICAgaW50IHByZWZldGNoX21heCwgdm9pZCAqZGF0YSkKK3sKKwlJbmRleFBy ZWZldGNoICpwcmVmZXRjaCA9IHBhbGxvYzAoc2l6ZW9mKEluZGV4UHJlZmV0Y2gpKTsKKwor CS8qIHRoZSBuZXh0X2NiIGNhbGxiYWNrIGlzIHJlcXVpcmVkICovCisJQXNzZXJ0KG5leHRf Y2IpOworCisJLyogdmFsaWQgcHJlZmV0Y2ggZGlzdGFuY2UgKi8KKwlBc3NlcnQoKHByZWZl dGNoX21heCA+PSAwKSAmJiAocHJlZmV0Y2hfbWF4IDw9IE1BWF9JT19DT05DVVJSRU5DWSkp OworCisJcHJlZmV0Y2gtPnF1ZXVlSW5kZXggPSAwOworCXByZWZldGNoLT5xdWV1ZVN0YXJ0 ID0gMDsKKwlwcmVmZXRjaC0+cXVldWVFbmQgPSAwOworCisJcHJlZmV0Y2gtPnByZWZldGNo VGFyZ2V0ID0gMDsKKwlwcmVmZXRjaC0+cHJlZmV0Y2hNYXhUYXJnZXQgPSBwcmVmZXRjaF9t YXg7CisKKwkvKgorCSAqIEN1c3RvbWl6ZSB0aGUgcHJlZmV0Y2ggdG8gYWxzbyBjaGVjayB2 aXNpYmlsaXR5IG1hcCBhbmQga2VlcCB0aGUgcmVzdWx0CisJICogc28gdGhhdCBJT1MgZG9l cyBub3QgbmVlZCB0byByZXBlYXQgaXQuCisJICovCisJcHJlZmV0Y2gtPm5leHRfY2IgPSBu ZXh0X2NiOworCXByZWZldGNoLT5jbGVhbnVwX2NiID0gY2xlYW51cF9jYjsKKwlwcmVmZXRj aC0+ZGF0YSA9IGRhdGE7CisKKwlyZXR1cm4gcHJlZmV0Y2g7Cit9CisKKy8qCisgKiBJbmRl eFByZWZldGNoTmV4dAorICoJCVJlYWQgdGhlIG5leHQgZW50cnkgZnJvbSB0aGUgcHJlZmV0 Y2ggcXVldWUuCisgKgorICogUmV0dXJucyB0aGUgbmV4dCBUSUQgaW4gdGhlIHByZWZldGNo IHF1ZXVlICh3aGljaCBtaWdodCBoYXZlIGJlZW4gcHJlZmV0Y2hlZAorICogc29tZXRpbWUg aW4gdGhlIHBhc3QpLiBJZiBuZWVkZWQsIGl0IGFkZHMgbW9yZSBlbnRyaWVzIHRvIHRoZSBx dWV1ZSBhbmQgZG9lcworICogdGhlIHByZWZldGNoaW5nIGZvciB0aGVtLgorICoKKyAqIFJl dHVybnMgSW5kZXhQcmVmZXRjaEVudHJ5IHdpdGggdGhlIFRJRCBhbmQgb3B0aW9uYWwgZGF0 YSBhc3NvY2lhdGVkIHdpdGgKKyAqIHRoZSBUSUQgaW4gdGhlIG5leHRfY2IgY2FsbGJhY2su CisgKi8KK0luZGV4UHJlZmV0Y2hFbnRyeSAqCitJbmRleFByZWZldGNoTmV4dChJbmRleFNj YW5EZXNjIHNjYW4sIEluZGV4UHJlZmV0Y2ggKnByZWZldGNoLCBTY2FuRGlyZWN0aW9uIGRp cmVjdGlvbikKK3sKKwkvKiBEbyBwcmVmZXRjaGluZyAoaWYgcmVxdWVzdGVkL2VuYWJsZWQp LiAqLworCUluZGV4UHJlZmV0Y2hGaWxsUXVldWUoc2NhbiwgcHJlZmV0Y2gsIGRpcmVjdGlv bik7CisKKwkvKiBSZWFkIHRoZSBUSUQgZnJvbSB0aGUgcXVldWUgKG9yIGRpcmVjdGx5IGZy b20gdGhlIGluZGV4KS4gKi8KKwlyZXR1cm4gSW5kZXhQcmVmZXRjaE5leHRFbnRyeShzY2Fu LCBwcmVmZXRjaCwgZGlyZWN0aW9uKTsKK30KKworLyoKKyAqIEluZGV4UHJlZmV0Y2hSZXNl dAorICoJCVJlc2V0IHRoZSBwcmVmZXRjaCBUSUQsIHJlc3RhcnQgdGhlIHByZWZldGNoaW5n LgorICoKKyAqIFVzZWZ1bCBkdXJpbmcgcmVzY2FucyBldGMuIFRoaXMgYWxzbyByZXNldHMg dGhlIHByZWZldGNoIHRhcmdldCwgc28gdGhhdAorICogZWFjaCByZXNjYW4gZG9lcyB0aGUg aW5pdGlhbCBwcmVmZXRjaCByYW1wLXVwIGZyb20gdGFyZ2V0PTAgdG8gbWF4aW11bQorICog cHJlZmV0Y2ggZGlzdGFuY2UuCisgKi8KK3ZvaWQKK0luZGV4UHJlZmV0Y2hSZXNldChJbmRl eFNjYW5EZXNjIHNjYW4sIEluZGV4UHJlZmV0Y2ggKnN0YXRlKQoreworCWlmICghc3RhdGUp CisJCXJldHVybjsKKworCXN0YXRlLT5xdWV1ZUluZGV4ID0gMDsKKwlzdGF0ZS0+cXVldWVT dGFydCA9IDA7CisJc3RhdGUtPnF1ZXVlRW5kID0gMDsKKworCXN0YXRlLT5wcmVmZXRjaERv bmUgPSBmYWxzZTsKKwlzdGF0ZS0+cHJlZmV0Y2hUYXJnZXQgPSAwOworfQorCisvKgorICog SW5kZXhQcmVmZXRjaFN0YXRzCisgKgkJTG9nIGJhc2ljIHJ1bnRpbWUgZGVidWcgc3RhdHMg b2YgdGhlIHByZWZldGNoZXIuCisgKgorICogRklYTUUgU2hvdWxkIGJlIG9ubHkgaW4gZGVi dWcgYnVpbGRzLCBvciBzb21ldGhpbmcgbGlrZSB0aGF0LgorICovCit2b2lkCitJbmRleFBy ZWZldGNoU3RhdHMoSW5kZXhTY2FuRGVzYyBzY2FuLCBJbmRleFByZWZldGNoICpzdGF0ZSkK K3sKKwlpZiAoIXN0YXRlKQorCQlyZXR1cm47CisKKwllbG9nKExPRywgImluZGV4IHByZWZl dGNoIHN0YXRzOiByZXF1ZXN0cyAldSBwcmVmZXRjaGVzICV1ICglZikgc2tpcCBjYWNoZWQg JXUgc2VxdWVudGlhbCAldSIsCisJCSBzdGF0ZS0+Y291bnRBbGwsCisJCSBzdGF0ZS0+Y291 bnRQcmVmZXRjaCwKKwkJIHN0YXRlLT5jb3VudFByZWZldGNoICogMTAwLjAgLyBzdGF0ZS0+ Y291bnRBbGwsCisJCSBzdGF0ZS0+Y291bnRTa2lwQ2FjaGVkLAorCQkgc3RhdGUtPmNvdW50 U2tpcFNlcXVlbnRpYWwpOworfQorCisvKgorICogSW5kZXhQcmVmZXRjaEVuZAorICoJCVJl bGVhc2UgcmVzb3VyY2VzIGFzc29jaWF0ZWQgd2l0aCB0aGUgcHJlZmV0Y2hlci4KKyAqCisg KiBUaGlzIGlzIHByaW1hcmlseSBhYm91dCB0aGUgcHJpdmF0ZSBkYXRhIHRoZSBjYWxsZXIg bWlnaHQgaGF2ZSBhbGxvY2F0ZWQKKyAqIGluIHRoZSBuZXh0X2NiLCBhbmQgc3RvcmVkIGlu IHRoZSBkYXRhIGZpZWxkLiBXZSBkb24ndCBrbm93IHdoYXQgdGhlCisgKiBkYXRhIG1pZ2h0 IGNvbnRhaW4gKGUuZy4gYnVmZmVycyBldGMuKSwgcmVxdWlyaW5nIGFkZGl0aW9uYWwgY2xl YW51cCwgc28KKyAqIHdlIGNhbGwgYW5vdGhlciBjdXN0b20gY2FsbGJhY2suCisgKgorICog TmVlZHMgdG8gYmUgY2FsbGVkIGF0IHRoZSBlbmQgb2YgdGhlIGV4ZWN1dG9yIG5vZGUuCisg KgorICogWFhYIE1heWJlIGlmIHRoZXJlJ3Mgbm8gY2FsbGJhY2ssIHdlIHNob3VsZCBqdXN0 IHBmcmVlIHRoZSBkYXRhPyBEb2VzCisgKiBub3Qgc2VlbSB2ZXJ5IHVzZWZ1bCwgdGhvdWdo LgorICovCit2b2lkCitJbmRleFByZWZldGNoRW5kKEluZGV4U2NhbkRlc2Mgc2NhbiwgSW5k ZXhQcmVmZXRjaCAqc3RhdGUpCit7CisJaWYgKCFzdGF0ZSkKKwkJcmV0dXJuOworCisJaWYg KCFzdGF0ZS0+Y2xlYW51cF9jYikKKwkJcmV0dXJuOworCisJc3RhdGUtPmNsZWFudXBfY2Io c2Nhbiwgc3RhdGUtPmRhdGEpOworfQpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0 b3IvaW5zdHJ1bWVudC5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvaW5zdHJ1bWVudC5jCmlu ZGV4IDI2OGFlOGE5NDVmLi44ZmRhODY5NDM1MCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQv ZXhlY3V0b3IvaW5zdHJ1bWVudC5jCisrKyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2luc3Ry dW1lbnQuYwpAQCAtMjM1LDYgKzIzNSw4IEBAIEJ1ZmZlclVzYWdlQWRkKEJ1ZmZlclVzYWdl ICpkc3QsIGNvbnN0IEJ1ZmZlclVzYWdlICphZGQpCiAJZHN0LT5sb2NhbF9ibGtzX3dyaXR0 ZW4gKz0gYWRkLT5sb2NhbF9ibGtzX3dyaXR0ZW47CiAJZHN0LT50ZW1wX2Jsa3NfcmVhZCAr PSBhZGQtPnRlbXBfYmxrc19yZWFkOwogCWRzdC0+dGVtcF9ibGtzX3dyaXR0ZW4gKz0gYWRk LT50ZW1wX2Jsa3Nfd3JpdHRlbjsKKwlkc3QtPmJsa3NfcHJlZmV0Y2hfcm91bmRzICs9IGFk ZC0+Ymxrc19wcmVmZXRjaF9yb3VuZHM7CisJZHN0LT5ibGtzX3ByZWZldGNoZXMgKz0gYWRk LT5ibGtzX3ByZWZldGNoZXM7CiAJSU5TVFJfVElNRV9BREQoZHN0LT5zaGFyZWRfYmxrX3Jl YWRfdGltZSwgYWRkLT5zaGFyZWRfYmxrX3JlYWRfdGltZSk7CiAJSU5TVFJfVElNRV9BREQo ZHN0LT5zaGFyZWRfYmxrX3dyaXRlX3RpbWUsIGFkZC0+c2hhcmVkX2Jsa193cml0ZV90aW1l KTsKIAlJTlNUUl9USU1FX0FERChkc3QtPmxvY2FsX2Jsa19yZWFkX3RpbWUsIGFkZC0+bG9j YWxfYmxrX3JlYWRfdGltZSk7CkBAIC0yNTksNiArMjYxLDggQEAgQnVmZmVyVXNhZ2VBY2N1 bURpZmYoQnVmZmVyVXNhZ2UgKmRzdCwKIAlkc3QtPmxvY2FsX2Jsa3Nfd3JpdHRlbiArPSBh ZGQtPmxvY2FsX2Jsa3Nfd3JpdHRlbiAtIHN1Yi0+bG9jYWxfYmxrc193cml0dGVuOwogCWRz dC0+dGVtcF9ibGtzX3JlYWQgKz0gYWRkLT50ZW1wX2Jsa3NfcmVhZCAtIHN1Yi0+dGVtcF9i bGtzX3JlYWQ7CiAJZHN0LT50ZW1wX2Jsa3Nfd3JpdHRlbiArPSBhZGQtPnRlbXBfYmxrc193 cml0dGVuIC0gc3ViLT50ZW1wX2Jsa3Nfd3JpdHRlbjsKKwlkc3QtPmJsa3NfcHJlZmV0Y2hl cyArPSBhZGQtPmJsa3NfcHJlZmV0Y2hlcyAtIHN1Yi0+Ymxrc19wcmVmZXRjaGVzOworCWRz dC0+Ymxrc19wcmVmZXRjaF9yb3VuZHMgKz0gYWRkLT5ibGtzX3ByZWZldGNoX3JvdW5kcyAt IHN1Yi0+Ymxrc19wcmVmZXRjaF9yb3VuZHM7CiAJSU5TVFJfVElNRV9BQ0NVTV9ESUZGKGRz dC0+c2hhcmVkX2Jsa19yZWFkX3RpbWUsCiAJCQkJCQkgIGFkZC0+c2hhcmVkX2Jsa19yZWFk X3RpbWUsIHN1Yi0+c2hhcmVkX2Jsa19yZWFkX3RpbWUpOwogCUlOU1RSX1RJTUVfQUNDVU1f RElGRihkc3QtPnNoYXJlZF9ibGtfd3JpdGVfdGltZSwKZGlmZiAtLWdpdCBhL3NyYy9iYWNr ZW5kL2V4ZWN1dG9yL25vZGVJbmRleG9ubHlzY2FuLmMgYi9zcmMvYmFja2VuZC9leGVjdXRv ci9ub2RlSW5kZXhvbmx5c2Nhbi5jCmluZGV4IDJjMmM5YzEwYjU3Li5mY2UxMGVhNjUxOCAx MDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUluZGV4b25seXNjYW4uYwor KysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlSW5kZXhvbmx5c2Nhbi5jCkBAIC0zNiw2 ICszNiw3IEBACiAjaW5jbHVkZSAiYWNjZXNzL3R1cGRlc2MuaCIKICNpbmNsdWRlICJhY2Nl c3MvdmlzaWJpbGl0eW1hcC5oIgogI2luY2x1ZGUgImV4ZWN1dG9yL2V4ZWNkZWJ1Zy5oIgor I2luY2x1ZGUgImV4ZWN1dG9yL2V4ZWN1dG9yLmgiCiAjaW5jbHVkZSAiZXhlY3V0b3Ivbm9k ZUluZGV4b25seXNjYW4uaCIKICNpbmNsdWRlICJleGVjdXRvci9ub2RlSW5kZXhzY2FuLmgi CiAjaW5jbHVkZSAibWlzY2FkbWluLmgiCkBAIC00NCwxMSArNDUsMTQgQEAKICNpbmNsdWRl ICJ1dGlscy9tZW11dGlscy5oIgogI2luY2x1ZGUgInV0aWxzL3JlbC5oIgogCi0KIHN0YXRp YyBUdXBsZVRhYmxlU2xvdCAqSW5kZXhPbmx5TmV4dChJbmRleE9ubHlTY2FuU3RhdGUgKm5v ZGUpOwogc3RhdGljIHZvaWQgU3RvcmVJbmRleFR1cGxlKFR1cGxlVGFibGVTbG90ICpzbG90 LCBJbmRleFR1cGxlIGl0dXAsCiAJCQkJCQkJVHVwbGVEZXNjIGl0dXBkZXNjKTsKLQorc3Rh dGljIEluZGV4UHJlZmV0Y2hFbnRyeSAqSW5kZXhPbmx5UHJlZmV0Y2hOZXh0KEluZGV4U2Nh bkRlc2Mgc2NhbiwKKwkJCQkJCQkJCQkJCSBTY2FuRGlyZWN0aW9uIGRpcmVjdGlvbiwKKwkJ CQkJCQkJCQkJCSB2b2lkICpkYXRhKTsKK3N0YXRpYyB2b2lkIEluZGV4T25seVByZWZldGNo Q2xlYW51cChJbmRleFNjYW5EZXNjIHNjYW4sCisJCQkJCQkJCQkgdm9pZCAqZGF0YSk7CiAK IC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0KICAqCQlJbmRleE9ubHlOZXh0CkBAIC02NSw2ICs2OSw4IEBAIElu ZGV4T25seU5leHQoSW5kZXhPbmx5U2NhblN0YXRlICpub2RlKQogCUluZGV4U2NhbkRlc2Mg c2NhbmRlc2M7CiAJVHVwbGVUYWJsZVNsb3QgKnNsb3Q7CiAJSXRlbVBvaW50ZXIgdGlkOwor CUluZGV4UHJlZmV0Y2ggKnByZWZldGNoOworCUluZGV4UHJlZmV0Y2hFbnRyeSAqZW50cnk7 CiAKIAkvKgogCSAqIGV4dHJhY3QgbmVjZXNzYXJ5IGluZm9ybWF0aW9uIGZyb20gaW5kZXgg c2NhbiBub2RlCkBAIC03OCwxMSArODQsMTQgQEAgSW5kZXhPbmx5TmV4dChJbmRleE9ubHlT Y2FuU3RhdGUgKm5vZGUpCiAJZGlyZWN0aW9uID0gU2NhbkRpcmVjdGlvbkNvbWJpbmUoZXN0 YXRlLT5lc19kaXJlY3Rpb24sCiAJCQkJCQkJCQkgKChJbmRleE9ubHlTY2FuICopIG5vZGUt PnNzLnBzLnBsYW4pLT5pbmRleG9yZGVyZGlyKTsKIAlzY2FuZGVzYyA9IG5vZGUtPmlvc3Nf U2NhbkRlc2M7CisJcHJlZmV0Y2ggPSBub2RlLT5pb3NzX3ByZWZldGNoOwogCWVjb250ZXh0 ID0gbm9kZS0+c3MucHMucHNfRXhwckNvbnRleHQ7CiAJc2xvdCA9IG5vZGUtPnNzLnNzX1Nj YW5UdXBsZVNsb3Q7CiAKIAlpZiAoc2NhbmRlc2MgPT0gTlVMTCkKIAl7CisJCWludAlwcmVm ZXRjaF9tYXg7CisKIAkJLyoKIAkJICogV2UgcmVhY2ggaGVyZSBpZiB0aGUgaW5kZXggb25s eSBzY2FuIGlzIG5vdCBwYXJhbGxlbCwgb3IgaWYgd2UncmUKIAkJICogc2VyaWFsbHkgZXhl Y3V0aW5nIGFuIGluZGV4IG9ubHkgc2NhbiB0aGF0IHdhcyBwbGFubmVkIHRvIGJlCkBAIC0x MTEsMTUgKzEyMCwzOSBAQCBJbmRleE9ubHlOZXh0KEluZGV4T25seVNjYW5TdGF0ZSAqbm9k ZSkKIAkJCQkJCSBub2RlLT5pb3NzX051bVNjYW5LZXlzLAogCQkJCQkJIG5vZGUtPmlvc3Nf T3JkZXJCeUtleXMsCiAJCQkJCQkgbm9kZS0+aW9zc19OdW1PcmRlckJ5S2V5cyk7CisKKwkJ LyoKKwkJICogQWxzbyBpbml0aWFsaXplIGluZGV4IHByZWZldGNoZXIuIFdlIGRvIHRoaXMg ZXZlbiB3aGVuIHByZWZldGNoaW5nIGlzCisJCSAqIG5vdCBkb25lIChzZWUgSW5kZXhQcmVm ZXRjaENvbXB1dGVUYXJnZXQpLCBiZWNhdXNlIHRoZSBwcmVmZXRjaGVyIGlzCisJCSAqIHVz ZWQgZm9yIGFsbCBpbmRleCByZWFkcy4KKwkJICoKKwkJICogWFhYIE1heWJlIHdlIHNob3Vs ZCByZWR1Y2UgdGhlIHRhcmdldCBpbiBjYXNlIHRoaXMgaXMgYSBwYXJhbGxlbCBpbmRleAor CQkgKiBzY2FuLiBXZSBkb24ndCB3YW50IHRvIGlzc3VlIGEgbXVsdGlwbGUgb2YgZWZmZWN0 aXZlX2lvX2NvbmN1cnJlbmN5LgorCQkgKgorCQkgKiBYWFggTWF5YmUgcmVuYW1lIHRoZSBv YmplY3QgdG8gImluZGV4IHJlYWRlciIgb3Igc29tZXRoaW5nPworCQkgKi8KKwkJcHJlZmV0 Y2hfbWF4ID0gSW5kZXhQcmVmZXRjaENvbXB1dGVUYXJnZXQobm9kZS0+c3Muc3NfY3VycmVu dFJlbGF0aW9uLAorCQkJCQkJCQkJCQkJICBub2RlLT5zcy5wcy5wbGFuLT5wbGFuX3Jvd3Ms CisJCQkJCQkJCQkJCQkgIGVzdGF0ZS0+ZXNfdXNlX3ByZWZldGNoaW5nKTsKKworCQlub2Rl LT5pb3NzX3ByZWZldGNoID0gSW5kZXhQcmVmZXRjaEFsbG9jKEluZGV4T25seVByZWZldGNo TmV4dCwKKwkJCQkJCQkJCQkJCSBJbmRleE9ubHlQcmVmZXRjaENsZWFudXAsCisJCQkJCQkJ CQkJCQkgcHJlZmV0Y2hfbWF4LAorCQkJCQkJCQkJCQkJIHBhbGxvYzAoc2l6ZW9mKEJ1ZmZl cikpKTsKIAl9CiAKIAkvKgogCSAqIE9LLCBub3cgdGhhdCB3ZSBoYXZlIHdoYXQgd2UgbmVl ZCwgZmV0Y2ggdGhlIG5leHQgdHVwbGUuCiAJICovCi0Jd2hpbGUgKCh0aWQgPSBpbmRleF9n ZXRuZXh0X3RpZChzY2FuZGVzYywgZGlyZWN0aW9uKSkgIT0gTlVMTCkKKwl3aGlsZSAoKGVu dHJ5ID0gSW5kZXhQcmVmZXRjaE5leHQoc2NhbmRlc2MsIHByZWZldGNoLCBkaXJlY3Rpb24p KSAhPSBOVUxMKQogCXsKKwkJYm9vbAkgICAqYWxsX3Zpc2libGUgPSBOVUxMOwogCQlib29s CQl0dXBsZV9mcm9tX2hlYXAgPSBmYWxzZTsKIAorCQkvKiB1bnBhY2sgdGhlIGVudHJ5ICov CisJCXRpZCA9ICZlbnRyeS0+dGlkOworCQlhbGxfdmlzaWJsZSA9IChib29sICopIGVudHJ5 LT5kYXRhOyAvKiByZXN1bHQgb2YgdmlzaWJpbGl0eSBjaGVjayAqLworCiAJCUNIRUNLX0ZP Ul9JTlRFUlJVUFRTKCk7CiAKIAkJLyoKQEAgLTE1NSw4ICsxODgsMTIgQEAgSW5kZXhPbmx5 TmV4dChJbmRleE9ubHlTY2FuU3RhdGUgKm5vZGUpCiAJCSAqCiAJCSAqIEl0J3Mgd29ydGgg Z29pbmcgdGhyb3VnaCB0aGlzIGNvbXBsZXhpdHkgdG8gYXZvaWQgbmVlZGluZyB0byBsb2Nr CiAJCSAqIHRoZSBWTSBidWZmZXIsIHdoaWNoIGNvdWxkIGNhdXNlIHNpZ25pZmljYW50IGNv bnRlbnRpb24uCisJCSAqCisJCSAqIFhYWCBTa2lwIGlmIHdlIGFscmVhZHkga25vdyB0aGUg cGFnZSBpcyBhbGwgdmlzaWJsZSBmcm9tCisJCSAqIHByZWZldGNoZXIuCiAJCSAqLwotCQlp ZiAoIVZNX0FMTF9WSVNJQkxFKHNjYW5kZXNjLT5oZWFwUmVsYXRpb24sCisJCWlmICghKGFs bF92aXNpYmxlICYmICphbGxfdmlzaWJsZSkgJiYKKwkJCSFWTV9BTExfVklTSUJMRShzY2Fu ZGVzYy0+aGVhcFJlbGF0aW9uLAogCQkJCQkJCUl0ZW1Qb2ludGVyR2V0QmxvY2tOdW1iZXIo dGlkKSwKIAkJCQkJCQkmbm9kZS0+aW9zc19WTUJ1ZmZlcikpCiAJCXsKQEAgLTM1Myw2ICsz OTAsOSBAQCBFeGVjUmVTY2FuSW5kZXhPbmx5U2NhbihJbmRleE9ubHlTY2FuU3RhdGUgKm5v ZGUpCiAJCQkJCSBub2RlLT5pb3NzX1NjYW5LZXlzLCBub2RlLT5pb3NzX051bVNjYW5LZXlz LAogCQkJCQkgbm9kZS0+aW9zc19PcmRlckJ5S2V5cywgbm9kZS0+aW9zc19OdW1PcmRlckJ5 S2V5cyk7CiAKKwkvKiBhbHNvIHJlc2V0IHRoZSBwcmVmZXRjaGVyLCBzbyB0aGF0IHdlIHN0 YXJ0IGZyb20gc2NyYXRjaCAqLworCUluZGV4UHJlZmV0Y2hSZXNldChub2RlLT5pb3NzX1Nj YW5EZXNjLCBub2RlLT5pb3NzX3ByZWZldGNoKTsKKwogCUV4ZWNTY2FuUmVTY2FuKCZub2Rl LT5zcyk7CiB9CiAKQEAgLTM4MCw2ICs0MjAsMTIgQEAgRXhlY0VuZEluZGV4T25seVNjYW4o SW5kZXhPbmx5U2NhblN0YXRlICpub2RlKQogCQlub2RlLT5pb3NzX1ZNQnVmZmVyID0gSW52 YWxpZEJ1ZmZlcjsKIAl9CiAKKwkvKiBYWFggUHJpbnQgc29tZSBkZWJ1ZyBzdGF0cy4gU2hv dWxkIGJlIHJlbW92ZWQuICovCisJSW5kZXhQcmVmZXRjaFN0YXRzKGluZGV4U2NhbkRlc2Ms IG5vZGUtPmlvc3NfcHJlZmV0Y2gpOworCisJLyogUmVsZWFzZSBWTSBidWZmZXIgcGluIGZy b20gcHJlZmV0Y2hlciwgaWYgYW55LiAqLworCUluZGV4UHJlZmV0Y2hFbmQoaW5kZXhTY2Fu RGVzYywgbm9kZS0+aW9zc19wcmVmZXRjaCk7CisKIAkvKgogCSAqIGNsb3NlIHRoZSBpbmRl eCByZWxhdGlvbiAobm8tb3AgaWYgd2UgZGlkbid0IG9wZW4gaXQpCiAJICovCkBAIC03MTUs MyArNzYxLDYyIEBAIEV4ZWNJbmRleE9ubHlTY2FuSW5pdGlhbGl6ZVdvcmtlcihJbmRleE9u bHlTY2FuU3RhdGUgKm5vZGUsCiAJCQkJCSBub2RlLT5pb3NzX1NjYW5LZXlzLCBub2RlLT5p b3NzX051bVNjYW5LZXlzLAogCQkJCQkgbm9kZS0+aW9zc19PcmRlckJ5S2V5cywgbm9kZS0+ aW9zc19OdW1PcmRlckJ5S2V5cyk7CiB9CisKKy8qCisgKiBXaGVuIHByZWZldGNoaW5nIGZv ciBJT1MsIHdlIHdhbnQgdG8gb25seSBwcmVmZXRjaCBwYWdlcyB0aGF0IGFyZSBub3QKKyAq IG1hcmtlZCBhcyBhbGwtdmlzaWJsZSAoYmVjYXVzZSBub3QgZmV0Y2hpbmcgYWxsLXZpc2li bGUgcGFnZXMgaXMgdGhlCisgKiBwb2ludCBvZiBJT1MpLgorICoKKyAqIFRoZSBidWZmZXIg dXNlZCBieSB0aGUgVk1fQUxMX1ZJU0lCTEUoKSBjaGVjayBpcyByZXVzZWQsIHNpbWlsYXJs eSB0bworICogaW9zc19WTUJ1ZmZlciAobWF5YmUgd2UgY291bGQvc2hvdWxkIHVzZSBpdCBo ZXJlIHRvbz8pLiBXZSBhbHNvIGtlZXAKKyAqIHRoZSByZXN1bHQgb2YgdGhlIGFsbF92aXNp YmxlIGZsYWcsIHNvIHRoYXQgdGhlIG1haW4gbG9vcCBkb2VzIG5vdCB0bworICogZG8gaXQg YWdhaW4uCisgKi8KK3N0YXRpYyBJbmRleFByZWZldGNoRW50cnkgKgorSW5kZXhPbmx5UHJl ZmV0Y2hOZXh0KEluZGV4U2NhbkRlc2Mgc2NhbiwgU2NhbkRpcmVjdGlvbiBkaXJlY3Rpb24s IHZvaWQgKmRhdGEpCit7CisJSW5kZXhQcmVmZXRjaEVudHJ5ICplbnRyeSA9IE5VTEw7CisJ SXRlbVBvaW50ZXIgdGlkOworCisJQXNzZXJ0KGRhdGEpOworCisJaWYgKCh0aWQgPSBpbmRl eF9nZXRuZXh0X3RpZChzY2FuLCBkaXJlY3Rpb24pKSAhPSBOVUxMKQorCXsKKwkJQmxvY2tO dW1iZXIgYmxrbm8gPSBJdGVtUG9pbnRlckdldEJsb2NrTnVtYmVyKHRpZCk7CisKKwkJYm9v bAkJYWxsX3Zpc2libGUgPSBWTV9BTExfVklTSUJMRShzY2FuLT5oZWFwUmVsYXRpb24sCisJ CQkJCQkJCQkJCQkgYmxrbm8sCisJCQkJCQkJCQkJCQkgKEJ1ZmZlciAqKSBkYXRhKTsKKwor CQllbnRyeSA9IHBhbGxvYzAoc2l6ZW9mKEluZGV4UHJlZmV0Y2hFbnRyeSkpOworCisJCWVu dHJ5LT50aWQgPSAqdGlkOworCisJCS8qIHByZWZldGNoIG9ubHkgaWYgbm90IGFsbCB2aXNp YmxlICovCisJCWVudHJ5LT5wcmVmZXRjaCA9ICFhbGxfdmlzaWJsZTsKKworCQkvKiBzdG9y ZSB0aGUgYWxsX3Zpc2libGUgZmxhZyBpbiB0aGUgcHJpdmF0ZSBwYXJ0IG9mIHRoZSBlbnRy eSAqLworCQllbnRyeS0+ZGF0YSA9IHBhbGxvYyhzaXplb2YoYm9vbCkpOworCQkqKGJvb2wg KikgZW50cnktPmRhdGEgPSBhbGxfdmlzaWJsZTsKKwl9CisKKwlyZXR1cm4gZW50cnk7Cit9 CisKKy8qCisgKiBGb3IgSU9TLCB3ZSBtYXkgaGF2ZSBhIFZNIGJ1ZmZlciBpbiB0aGUgcHJp dmF0ZSBkYXRhLCBzbyBtYWtlIHN1cmUgdG8KKyAqIHJlbGVhc2UgaXQgcHJvcGVybHkuCisg Ki8KK3N0YXRpYyB2b2lkCitJbmRleE9ubHlQcmVmZXRjaENsZWFudXAoSW5kZXhTY2FuRGVz YyBzY2FuLCB2b2lkICpkYXRhKQoreworCUJ1ZmZlcgkgICAqYnVmZmVyID0gKEJ1ZmZlciAq KSBkYXRhOworCisJQXNzZXJ0KGRhdGEpOworCisJaWYgKCpidWZmZXIgIT0gSW52YWxpZEJ1 ZmZlcikKKwl7CisJCVJlbGVhc2VCdWZmZXIoKmJ1ZmZlcik7CisJCSpidWZmZXIgPSBJbnZh bGlkQnVmZmVyOworCX0KK30KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25v ZGVJbmRleHNjYW4uYyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVJbmRleHNjYW4uYwpp bmRleCAwMzE0MmI0YTk0Ni4uMDU0ODQwM2RjNTAgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5k L2V4ZWN1dG9yL25vZGVJbmRleHNjYW4uYworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9u b2RlSW5kZXhzY2FuLmMKQEAgLTM0LDYgKzM0LDcgQEAKICNpbmNsdWRlICJhY2Nlc3MvdGFi bGVhbS5oIgogI2luY2x1ZGUgImNhdGFsb2cvcGdfYW0uaCIKICNpbmNsdWRlICJleGVjdXRv ci9leGVjZGVidWcuaCIKKyNpbmNsdWRlICJleGVjdXRvci9leGVjdXRvci5oIgogI2luY2x1 ZGUgImV4ZWN1dG9yL25vZGVJbmRleHNjYW4uaCIKICNpbmNsdWRlICJsaWIvcGFpcmluZ2hl YXAuaCIKICNpbmNsdWRlICJtaXNjYWRtaW4uaCIKQEAgLTY5LDYgKzcwLDkgQEAgc3RhdGlj IHZvaWQgcmVvcmRlcnF1ZXVlX3B1c2goSW5kZXhTY2FuU3RhdGUgKm5vZGUsIFR1cGxlVGFi bGVTbG90ICpzbG90LAogCQkJCQkJCSAgRGF0dW0gKm9yZGVyYnl2YWxzLCBib29sICpvcmRl cmJ5bnVsbHMpOwogc3RhdGljIEhlYXBUdXBsZSByZW9yZGVycXVldWVfcG9wKEluZGV4U2Nh blN0YXRlICpub2RlKTsKIAorc3RhdGljIEluZGV4UHJlZmV0Y2hFbnRyeSAqSW5kZXhTY2Fu UHJlZmV0Y2hOZXh0KEluZGV4U2NhbkRlc2Mgc2NhbiwKKwkJCQkJCQkJCQkJCSBTY2FuRGly ZWN0aW9uIGRpcmVjdGlvbiwKKwkJCQkJCQkJCQkJCSB2b2lkICpkYXRhKTsKIAogLyogLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLQogICoJCUluZGV4TmV4dApAQCAtODUsNiArODksOCBAQCBJbmRleE5leHQoSW5k ZXhTY2FuU3RhdGUgKm5vZGUpCiAJU2NhbkRpcmVjdGlvbiBkaXJlY3Rpb247CiAJSW5kZXhT Y2FuRGVzYyBzY2FuZGVzYzsKIAlUdXBsZVRhYmxlU2xvdCAqc2xvdDsKKwlJbmRleFByZWZl dGNoICpwcmVmZXRjaDsKKwlJbmRleFByZWZldGNoRW50cnkgKmVudHJ5OwogCiAJLyoKIAkg KiBleHRyYWN0IG5lY2Vzc2FyeSBpbmZvcm1hdGlvbiBmcm9tIGluZGV4IHNjYW4gbm9kZQpA QCAtOTgsMTEgKzEwNCwxNCBAQCBJbmRleE5leHQoSW5kZXhTY2FuU3RhdGUgKm5vZGUpCiAJ ZGlyZWN0aW9uID0gU2NhbkRpcmVjdGlvbkNvbWJpbmUoZXN0YXRlLT5lc19kaXJlY3Rpb24s CiAJCQkJCQkJCQkgKChJbmRleFNjYW4gKikgbm9kZS0+c3MucHMucGxhbiktPmluZGV4b3Jk ZXJkaXIpOwogCXNjYW5kZXNjID0gbm9kZS0+aXNzX1NjYW5EZXNjOworCXByZWZldGNoID0g bm9kZS0+aXNzX3ByZWZldGNoOwogCWVjb250ZXh0ID0gbm9kZS0+c3MucHMucHNfRXhwckNv bnRleHQ7CiAJc2xvdCA9IG5vZGUtPnNzLnNzX1NjYW5UdXBsZVNsb3Q7CiAKIAlpZiAoc2Nh bmRlc2MgPT0gTlVMTCkKIAl7CisJCWludCBwcmVmZXRjaF9tYXg7CisKIAkJLyoKIAkJICog V2UgcmVhY2ggaGVyZSBpZiB0aGUgaW5kZXggc2NhbiBpcyBub3QgcGFyYWxsZWwsIG9yIGlm IHdlJ3JlCiAJCSAqIHNlcmlhbGx5IGV4ZWN1dGluZyBhbiBpbmRleCBzY2FuIHRoYXQgd2Fz IHBsYW5uZWQgdG8gYmUgcGFyYWxsZWwuCkBAIC0xMjMsMTUgKzEzMiw0MyBAQCBJbmRleE5l eHQoSW5kZXhTY2FuU3RhdGUgKm5vZGUpCiAJCQlpbmRleF9yZXNjYW4oc2NhbmRlc2MsCiAJ CQkJCQkgbm9kZS0+aXNzX1NjYW5LZXlzLCBub2RlLT5pc3NfTnVtU2NhbktleXMsCiAJCQkJ CQkgbm9kZS0+aXNzX09yZGVyQnlLZXlzLCBub2RlLT5pc3NfTnVtT3JkZXJCeUtleXMpOwor CisJCS8qCisJCSAqIEFsc28gaW5pdGlhbGl6ZSBpbmRleCBwcmVmZXRjaGVyLiBXZSBkbyB0 aGlzIGV2ZW4gd2hlbiBwcmVmZXRjaGluZyBpcworCQkgKiBub3QgZG9uZSAoc2VlIEluZGV4 UHJlZmV0Y2hDb21wdXRlVGFyZ2V0KSwgYmVjYXVzZSB0aGUgcHJlZmV0Y2hlciBpcworCQkg KiB1c2VkIGZvciBhbGwgaW5kZXggcmVhZHMuCisJCSAqCisJCSAqIFhYWCBNYXliZSB3ZSBz aG91bGQgcmVkdWNlIHRoZSB0YXJnZXQgaW4gY2FzZSB0aGlzIGlzIGEgcGFyYWxsZWwgaW5k ZXgKKwkJICogc2Nhbi4gV2UgZG9uJ3Qgd2FudCB0byBpc3N1ZSBhIG11bHRpcGxlIG9mIGVm ZmVjdGl2ZV9pb19jb25jdXJyZW5jeS4KKwkJICoKKwkJICogWFhYIE1heWJlIHJlbmFtZSB0 aGUgb2JqZWN0IHRvICJpbmRleCByZWFkZXIiIG9yIHNvbWV0aGluZz8KKwkJICovCisJCXBy ZWZldGNoX21heCA9IEluZGV4UHJlZmV0Y2hDb21wdXRlVGFyZ2V0KG5vZGUtPnNzLnNzX2N1 cnJlbnRSZWxhdGlvbiwKKwkJCQkJCQkJCQkJCSAgbm9kZS0+c3MucHMucGxhbi0+cGxhbl9y b3dzLAorCQkJCQkJCQkJCQkJICBlc3RhdGUtPmVzX3VzZV9wcmVmZXRjaGluZyk7CisKKwkJ bm9kZS0+aXNzX3ByZWZldGNoID0gSW5kZXhQcmVmZXRjaEFsbG9jKEluZGV4U2NhblByZWZl dGNoTmV4dCwKKwkJCQkJCQkJCQkJCU5VTEwsIC8qIG5vIGV4dHJhIGNsZWFudXAgKi8KKwkJ CQkJCQkJCQkJCXByZWZldGNoX21heCwKKwkJCQkJCQkJCQkJCU5VTEwpOwogCX0KIAogCS8q CiAJICogb2ssIG5vdyB0aGF0IHdlIGhhdmUgd2hhdCB3ZSBuZWVkLCBmZXRjaCB0aGUgbmV4 dCB0dXBsZS4KIAkgKi8KLQl3aGlsZSAoaW5kZXhfZ2V0bmV4dF9zbG90KHNjYW5kZXNjLCBk aXJlY3Rpb24sIHNsb3QpKQorCXdoaWxlICgoZW50cnkgPSBJbmRleFByZWZldGNoTmV4dChz Y2FuZGVzYywgcHJlZmV0Y2gsIGRpcmVjdGlvbikpICE9IE5VTEwpCiAJewogCQlDSEVDS19G T1JfSU5URVJSVVBUUygpOwogCisJCS8qCisJCSAqIEZldGNoIHRoZSBuZXh0IChvciBvbmx5 KSB2aXNpYmxlIGhlYXAgdHVwbGUgZm9yIHRoaXMgaW5kZXggZW50cnkuCisJCSAqIElmIHdl IGRvbid0IGZpbmQgYW55dGhpbmcsIGxvb3AgYXJvdW5kIGFuZCBncmFiIHRoZSBuZXh0IFRJ RCBmcm9tCisJCSAqIHRoZSBpbmRleC4KKwkJICovCisJCUFzc2VydChJdGVtUG9pbnRlcklz VmFsaWQoJnNjYW5kZXNjLT54c19oZWFwdGlkKSk7CisJCWlmICghaW5kZXhfZmV0Y2hfaGVh cChzY2FuZGVzYywgc2xvdCkpCisJCQljb250aW51ZTsKKwogCQkvKgogCQkgKiBJZiB0aGUg aW5kZXggd2FzIGxvc3N5LCB3ZSBoYXZlIHRvIHJlY2hlY2sgdGhlIGluZGV4IHF1YWxzIHVz aW5nCiAJCSAqIHRoZSBmZXRjaGVkIHR1cGxlLgpAQCAtNTg4LDYgKzYyNSw5IEBAIEV4ZWNS ZVNjYW5JbmRleFNjYW4oSW5kZXhTY2FuU3RhdGUgKm5vZGUpCiAJCQkJCSBub2RlLT5pc3Nf T3JkZXJCeUtleXMsIG5vZGUtPmlzc19OdW1PcmRlckJ5S2V5cyk7CiAJbm9kZS0+aXNzX1Jl YWNoZWRFbmQgPSBmYWxzZTsKIAorCS8qIGFsc28gcmVzZXQgdGhlIHByZWZldGNoZXIsIHNv IHRoYXQgd2Ugc3RhcnQgZnJvbSBzY3JhdGNoICovCisJSW5kZXhQcmVmZXRjaFJlc2V0KG5v ZGUtPmlzc19TY2FuRGVzYywgbm9kZS0+aXNzX3ByZWZldGNoKTsKKwogCUV4ZWNTY2FuUmVT Y2FuKCZub2RlLT5zcyk7CiB9CiAKQEAgLTc5NCw2ICs4MzQsOSBAQCBFeGVjRW5kSW5kZXhT Y2FuKEluZGV4U2NhblN0YXRlICpub2RlKQogCWluZGV4UmVsYXRpb25EZXNjID0gbm9kZS0+ aXNzX1JlbGF0aW9uRGVzYzsKIAlpbmRleFNjYW5EZXNjID0gbm9kZS0+aXNzX1NjYW5EZXNj OwogCisJLyogWFhYIFByaW50IHNvbWUgZGVidWcgc3RhdHMuIFNob3VsZCBiZSByZW1vdmVk LiAqLworCUluZGV4UHJlZmV0Y2hTdGF0cyhpbmRleFNjYW5EZXNjLCBub2RlLT5pc3NfcHJl ZmV0Y2gpOworCiAJLyoKIAkgKiBjbG9zZSB0aGUgaW5kZXggcmVsYXRpb24gKG5vLW9wIGlm IHdlIGRpZG4ndCBvcGVuIGl0KQogCSAqLwpAQCAtMTcyOCwzICsxNzcxLDI2IEBAIEV4ZWNJ bmRleFNjYW5Jbml0aWFsaXplV29ya2VyKEluZGV4U2NhblN0YXRlICpub2RlLAogCQkJCQkg bm9kZS0+aXNzX1NjYW5LZXlzLCBub2RlLT5pc3NfTnVtU2NhbktleXMsCiAJCQkJCSBub2Rl LT5pc3NfT3JkZXJCeUtleXMsIG5vZGUtPmlzc19OdW1PcmRlckJ5S2V5cyk7CiB9CisKKy8q CisgKiBYWFggbm90IHN1cmUgdGhpcyBjb3JyZWN0bHkgaGFuZGxlcyB4c19oZWFwX2NvbnRp bnVlIC0gc2VlIGluZGV4X2dldG5leHRfc2xvdCwKKyAqIG1heWJlIG5vZGVJbmRleHNjYW4g bmVlZHMgdG8gZG8gc29tZXRoaW5nIG1vcmUgdG8gaGFuZGxlIHRoaXM/CisgKi8KK3N0YXRp YyBJbmRleFByZWZldGNoRW50cnkgKgorSW5kZXhTY2FuUHJlZmV0Y2hOZXh0KEluZGV4U2Nh bkRlc2Mgc2NhbiwgU2NhbkRpcmVjdGlvbiBkaXJlY3Rpb24sIHZvaWQgKmRhdGEpCit7CisJ SW5kZXhQcmVmZXRjaEVudHJ5ICplbnRyeSA9IE5VTEw7CisJSXRlbVBvaW50ZXIgdGlkOwor CisJaWYgKCh0aWQgPSBpbmRleF9nZXRuZXh0X3RpZChzY2FuLCBkaXJlY3Rpb24pKSAhPSBO VUxMKQorCXsKKwkJZW50cnkgPSBwYWxsb2MwKHNpemVvZihJbmRleFByZWZldGNoRW50cnkp KTsKKworCQllbnRyeS0+dGlkID0gKnRpZDsKKworCQkvKiBwcmVmZXRjaCBhbHdheXMgKi8K KwkJZW50cnktPnByZWZldGNoID0gdHJ1ZTsKKwl9CisKKwlyZXR1cm4gZW50cnk7Cit9CmRp ZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9leGVjdXRvci9leGVjdXRvci5oIGIvc3JjL2luY2x1 ZGUvZXhlY3V0b3IvZXhlY3V0b3IuaAppbmRleCA1ZThjMzM1YTczNy4uZTc5MmMzZmM4ZDgg MTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2V4ZWN1dG9yLmgKKysrIGIvc3Jj L2luY2x1ZGUvZXhlY3V0b3IvZXhlY3V0b3IuaApAQCAtNjc3LDQgKzY3Nyw1NiBAQCBleHRl cm4gUmVzdWx0UmVsSW5mbyAqRXhlY0xvb2t1cFJlc3VsdFJlbEJ5T2lkKE1vZGlmeVRhYmxl U3RhdGUgKm5vZGUsCiAJCQkJCQkJCQkJCSAgIGJvb2wgbWlzc2luZ19vaywKIAkJCQkJCQkJ CQkJICAgYm9vbCB1cGRhdGVfY2FjaGUpOwogCisvKgorICogcHJvdG90eXBlcyBmcm9tIGZ1 bmN0aW9ucyBpbiBleGVjUHJlZmV0Y2guYworICovCisKK3R5cGVkZWYgc3RydWN0IEluZGV4 UHJlZmV0Y2hFbnRyeQoreworCUl0ZW1Qb2ludGVyRGF0YSB0aWQ7CisKKwkvKiBzaG91bGQg d2UgcHJlZmV0Y2ggaGVhcCBwYWdlIGZvciB0aGlzIFRJRD8gKi8KKwlib29sCQlwcmVmZXRj aDsKKworCS8qCisJICogSWYgYSBjYWxsYmFjayBpcyBzcGVjaWZpZWQsIGl0IG1heSBzdG9y ZSBwZXItdGlkIGluZm9ybWF0aW9uLiBUaGUgZGF0YQorCSAqIGhhcyB0byBiZSBhIHNpbmds ZSBwYWxsb2MtZWQgcGllY2Ugb2YgZGF0YSwgc28gdGhhdCBpdCBjYW4gYmUgZWFzaWx5CisJ ICogcGZyZWVkLgorCSAqCisJICogWFhYIFdlIGNvdWxkIHJlbGF4IHRoaXMgYnkgcHJvdmlk aW5nIGFub3RoZXIgY2xlYW51cCBjYWxsYmFjaywgYnV0IHRoYXQKKwkgKiBzZWVtcyB1bm5l Y2Vzc2FyaWx5IGNvbXBsZXggLSB3ZSBleHBlY3QgdGhlIGluZm9ybWF0aW9uIHRvIGJlIHZl cnkKKwkgKiBzaW1wbGUsIGxpa2UgYm9vbCBmbGFncyBvciBzb21ldGhpbmcuIEVhc3kgdG8g ZG8gaW4gYSBzaW1wbGUgc3RydWN0LAorCSAqIGFuZCBwZXJoYXBzIGV2ZW4gcmV1c2Ugd2l0 aG91dCBwZnJlZS9wYWxsb2MuCisJICovCisJdm9pZAkgICAqZGF0YTsKK30gSW5kZXhQcmVm ZXRjaEVudHJ5OworCisvKgorICogY3VzdG9tIGNhbGxiYWNrLCBhbGxvd2luZyB0aGUgdXNl ciBjb2RlIHRvIGRldGVybWluZSB3aGljaCBUSUQgdG8gcmVhZAorICoKKyAqIElmIHRoZXJl IGlzIG5vIFRJRCB0byBwcmVmZXRjaCwgdGhlIHJldHVybiB2YWx1ZSBpcyBleHBlY3RlZCB0 byBiZSBOVUxMLgorICoKKyAqIE90aGVyd2lzZSB0aGUgInRpZCIgZmllbGQgaXMgZXhwZWN0 ZWQgdG8gY29udGFpbiB0aGUgVElEIHRvIHByZWZldGNoLCBhbmQKKyAqICJkYXRhIiBtYXkg YmUgc2V0IHRvIGN1c3RvbSBpbmZvcm1hdGlvbiB0aGUgY2FsbGJhY2sgbmVlZHMgdG8gcGFz cyBvdXRzaWRlLgorICovCit0eXBlZGVmIEluZGV4UHJlZmV0Y2hFbnRyeSAqKCpJbmRleFBy ZWZldGNoTmV4dENCKSAoSW5kZXhTY2FuRGVzYyBzY2FuLAorCQkJCQkJCQkJCQkJCVNjYW5E aXJlY3Rpb24gZGlyZWN0aW9uLAorCQkJCQkJCQkJCQkJCXZvaWQgKmRhdGEpOworCit0eXBl ZGVmIHZvaWQgKCpJbmRleFByZWZldGNoQ2xlYW51cENCKSAoSW5kZXhTY2FuRGVzYyBzY2Fu LAorCQkJCQkJCQkJCXZvaWQgKmRhdGEpOworCitJbmRleFByZWZldGNoICpJbmRleFByZWZl dGNoQWxsb2MoSW5kZXhQcmVmZXRjaE5leHRDQiBuZXh0X2NiLAorCQkJCQkJCQkgIEluZGV4 UHJlZmV0Y2hDbGVhbnVwQ0IgY2xlYW51cF9jYiwKKwkJCQkJCQkJICBpbnQgcHJlZmV0Y2hf bWF4LCB2b2lkICpkYXRhKTsKKworSW5kZXhQcmVmZXRjaEVudHJ5ICpJbmRleFByZWZldGNo TmV4dChJbmRleFNjYW5EZXNjIHNjYW4sIEluZGV4UHJlZmV0Y2ggKnN0YXRlLAorCQkJCQkJ CQkJICBTY2FuRGlyZWN0aW9uIGRpcmVjdGlvbik7CisKK2V4dGVybiB2b2lkIEluZGV4UHJl ZmV0Y2hSZXNldChJbmRleFNjYW5EZXNjIHNjYW4sIEluZGV4UHJlZmV0Y2ggKnN0YXRlKTsK K2V4dGVybiB2b2lkIEluZGV4UHJlZmV0Y2hTdGF0cyhJbmRleFNjYW5EZXNjIHNjYW4sIElu ZGV4UHJlZmV0Y2ggKnN0YXRlKTsKK2V4dGVybiB2b2lkIEluZGV4UHJlZmV0Y2hFbmQoSW5k ZXhTY2FuRGVzYyBzY2FuLCBJbmRleFByZWZldGNoICpzdGF0ZSk7CisKK2V4dGVybiBpbnQJ SW5kZXhQcmVmZXRjaENvbXB1dGVUYXJnZXQoUmVsYXRpb24gaGVhcFJlbCwgZG91YmxlIHBs YW5fcm93cywgYm9vbCBwcmVmZXRjaCk7CisKICNlbmRpZgkJCQkJCQkvKiBFWEVDVVRPUl9I ICAqLwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvZXhlY3V0b3IvaW5zdHJ1bWVudC5oIGIv c3JjL2luY2x1ZGUvZXhlY3V0b3IvaW5zdHJ1bWVudC5oCmluZGV4IGJmZDdiNmQ4NDQ1Li5m YWRlYjM4OTQ5NSAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvZXhlY3V0b3IvaW5zdHJ1bWVu dC5oCisrKyBiL3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2luc3RydW1lbnQuaApAQCAtMzMsNiAr MzMsOCBAQCB0eXBlZGVmIHN0cnVjdCBCdWZmZXJVc2FnZQogCWludDY0CQlsb2NhbF9ibGtz X3dyaXR0ZW47IC8qICMgb2YgbG9jYWwgZGlzayBibG9ja3Mgd3JpdHRlbiAqLwogCWludDY0 CQl0ZW1wX2Jsa3NfcmVhZDsgLyogIyBvZiB0ZW1wIGJsb2NrcyByZWFkICovCiAJaW50NjQJ CXRlbXBfYmxrc193cml0dGVuOwkvKiAjIG9mIHRlbXAgYmxvY2tzIHdyaXR0ZW4gKi8KKwlp bnQ2NAkJYmxrc19wcmVmZXRjaF9yb3VuZHM7CS8qICMgb2YgcHJlZmV0Y2ggcm91bmRzICov CisJaW50NjQJCWJsa3NfcHJlZmV0Y2hlczsJLyogIyBvZiBidWZmZXJzIHByZWZldGNoZWQg Ki8KIAlpbnN0cl90aW1lCXNoYXJlZF9ibGtfcmVhZF90aW1lOwkvKiB0aW1lIHNwZW50IHJl YWRpbmcgc2hhcmVkIGJsb2NrcyAqLwogCWluc3RyX3RpbWUJc2hhcmVkX2Jsa193cml0ZV90 aW1lOwkvKiB0aW1lIHNwZW50IHdyaXRpbmcgc2hhcmVkIGJsb2NrcyAqLwogCWluc3RyX3Rp bWUJbG9jYWxfYmxrX3JlYWRfdGltZTsJLyogdGltZSBzcGVudCByZWFkaW5nIGxvY2FsIGJs b2NrcyAqLwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvbm9kZXMvZXhlY25vZGVzLmggYi9z cmMvaW5jbHVkZS9ub2Rlcy9leGVjbm9kZXMuaAppbmRleCA1NjFmZGQ5OGYxYi4uMTQxZGI1 ZDRhZTIgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL25vZGVzL2V4ZWNub2Rlcy5oCisrKyBi L3NyYy9pbmNsdWRlL25vZGVzL2V4ZWNub2Rlcy5oCkBAIC02OTAsNiArNjkwLDcgQEAgdHlw ZWRlZiBzdHJ1Y3QgRVN0YXRlCiAJc3RydWN0IEVQUVN0YXRlICplc19lcHFfYWN0aXZlOwog CiAJYm9vbAkJZXNfdXNlX3BhcmFsbGVsX21vZGU7CS8qIGNhbiB3ZSB1c2UgcGFyYWxsZWwg d29ya2Vycz8gKi8KKwlib29sCQllc191c2VfcHJlZmV0Y2hpbmc7IC8qIGNhbiB3ZSB1c2Ug cHJlZmV0Y2hpbmc/ICovCiAKIAkvKiBUaGUgcGVyLXF1ZXJ5IHNoYXJlZCBtZW1vcnkgYXJl YSB0byB1c2UgZm9yIHBhcmFsbGVsIGV4ZWN1dGlvbi4gKi8KIAlzdHJ1Y3QgZHNhX2FyZWEg KmVzX3F1ZXJ5X2RzYTsKQEAgLTE1MjksNiArMTUzMCw5IEBAIHR5cGVkZWYgc3RydWN0CiAJ Ym9vbAkgICAqZWxlbV9udWxsczsJCS8qIGFycmF5IG9mIG51bV9lbGVtcyBpcy1udWxsIGZs YWdzICovCiB9IEluZGV4QXJyYXlLZXlJbmZvOwogCisvKiBuZWVkcyB0byBiZSBiZWZvcmUg SW5kZXhQcmVmZXRjaENhbGxiYWNrIHR5cGVkZWYgKi8KK3R5cGVkZWYgc3RydWN0IEluZGV4 UHJlZmV0Y2ggSW5kZXhQcmVmZXRjaDsKKwogLyogLS0tLS0tLS0tLS0tLS0tLQogICoJIElu ZGV4U2NhblN0YXRlIGluZm9ybWF0aW9uCiAgKgpAQCAtMTU4MCw2ICsxNTg0LDkgQEAgdHlw ZWRlZiBzdHJ1Y3QgSW5kZXhTY2FuU3RhdGUKIAlib29sCSAgICppc3NfT3JkZXJCeVR5cEJ5 VmFsczsKIAlpbnQxNgkgICAqaXNzX09yZGVyQnlUeXBMZW5zOwogCVNpemUJCWlzc19Qc2Nh bkxlbjsKKworCS8qIHByZWZldGNoaW5nICovCisJSW5kZXhQcmVmZXRjaCAqaXNzX3ByZWZl dGNoOwogfSBJbmRleFNjYW5TdGF0ZTsKIAogLyogLS0tLS0tLS0tLS0tLS0tLQpAQCAtMTYx OCw2ICsxNjI1LDkgQEAgdHlwZWRlZiBzdHJ1Y3QgSW5kZXhPbmx5U2NhblN0YXRlCiAJVHVw bGVUYWJsZVNsb3QgKmlvc3NfVGFibGVTbG90OwogCUJ1ZmZlcgkJaW9zc19WTUJ1ZmZlcjsK IAlTaXplCQlpb3NzX1BzY2FuTGVuOworCisJLyogcHJlZmV0Y2hpbmcgKi8KKwlJbmRleFBy ZWZldGNoICppb3NzX3ByZWZldGNoOwogfSBJbmRleE9ubHlTY2FuU3RhdGU7CiAKIC8qIC0t LS0tLS0tLS0tLS0tLS0KZGlmZiAtLWdpdCBhL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVm cy5saXN0IGIvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKaW5kZXggZjU4MmVi NTllN2QuLjlkMTk0ZWMyNzE1IDEwMDY0NAotLS0gYS9zcmMvdG9vbHMvcGdpbmRlbnQvdHlw ZWRlZnMubGlzdAorKysgYi9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdApAQCAt MTE4Myw2ICsxMTgzLDkgQEAgSW5kZXhPbmx5U2NhblN0YXRlCiBJbmRleE9wdEluZm8KIElu ZGV4T3JkZXJCeURpc3RhbmNlCiBJbmRleFBhdGgKK0luZGV4UHJlZmV0Y2gKK0luZGV4UHJl ZmV0Y2hDYWNoZUVudHJ5CitJbmRleFByZWZldGNoRW50cnkKIEluZGV4UnVudGltZUtleUlu Zm8KIEluZGV4U2NhbgogSW5kZXhTY2FuRGVzYwotLSAKMi40My4wCgo= --------------rk0Ajra5AwFQP08i7beMRGga--