22382 2008-11-20 06:34:16 -0800 Middle click fires onclick event. Fire auxclick instead? 2024-07-20 18:55:41 -0700 1 1 1 Unclassified WebKit DOM 528+ (Nightly build) PC Windows XP RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=218665 http://www.guildportal.com/Guild.aspx?GuildID=209853&TabID=1770902 InRadar, WebExposed P2 Normal --- 46733 45628 1 mads.s.ager webkit-unassigned 7raivis abarth adele Blinkjt bugs.webkit.org-19b cdumez cmarcelo darin drtifti dwwoelfel eric evan isherman japhet justin krit mkterra nzolghadr petergrabs pkasting possum.bracing0v rbyers simon.fraser thesnabber tonikitoo webkit webkit-bug-importer webkit webkit zanetu oldest_to_newest 99471 0 mads.s.ager 2008-11-20 06:34:16 -0800 Middle clicking fires an onclick event in Safari 3.1.2 on Windows and in the latests nightly build on Windows (r38492). Middle clicking does not fire an onclick event in Firefox and IE. Here is a simple test example: <html> <body> <script> function f() { alert('onclick'); } </script> <div onclick="f()"> <a href="http://webkit.org">middle click here</a> ... or middle click here. </div> </body> </html> Some websites have links inside other elements that have onclick event handlers that navigate. If you middle click on one of those links, you will open the link in a new tab, but you will also fire the onclick event handler which will navigate the original window as well. This is happening for instance on the URL that I have entered for this bug when middle clicking one of the sub forum links. 135053 1 drtifti 2009-07-27 15:51:33 -0700 This is the same problem I tried to explain here: https://bugs.webkit.org/show_bug.cgi?id=18161 160776 2 mkterra 2009-11-05 02:25:23 -0800 Google Chrome is being affected by this bug too. Downstream bug here: http://code.google.com/p/chromium/issues/detail?id=5447 And a simple test page: http://pimpbot.gifpaste.net/gid/test/chrome1.html 171128 3 thesnabber 2009-12-12 14:52:00 -0800 I can verify that this bug is occurring in the latest nightly build of Google Chromium (4.0.269.0 (34425)) for Windows 7 x64. Behaviour is just as described on mkterra's demo page. 221944 4 pkasting 2010-05-06 13:44:24 -0700 *** Bug 18161 has been marked as a duplicate of this bug. *** 221948 5 pkasting 2010-05-06 13:50:19 -0700 This was originally filed as bug 15173, which was RESOLVED FIXED with, as far as I can tell, absolutely no behavior change in terms of whether middle mouse fires onclick. I'm not sure why Eric closed this. This bug still trips all kinds of different sites. It is a major compat bug. 221994 6 abarth 2010-05-06 15:05:54 -0700 *** Bug 15173 has been marked as a duplicate of this bug. *** 222039 7 abarth 2010-05-06 16:21:33 -0700 Hum... This bug is a big pain to fix. 222709 8 ojan 2010-05-07 17:03:17 -0700 I did a quick bit of testing. Gecko: Click only fires for left-click. WebKit: Click fires for left/middle-click, but not right-click. Trident: Click fires for left/middle-click, but not right-click and not if the middle-click was on a link. Not firing click events for middle-clicks is probably the only sane direction to take things. I tested with the following html: <div id=foo> <a href="http://webkit.org">middle click here</a> ... or middle click here. </div> <script> document.getElementById('foo').onclick = function() { alert('onclick'); }; </script> 222718 9 abarth 2010-05-07 17:18:44 -0700 Do we want the Gecko behavior or the Trident behavior? The Gecko behavior seems to have lower entropy. 222719 10 ojan 2010-05-07 17:19:39 -0700 (In reply to comment #9) > Do we want the Gecko behavior or the Trident behavior? The Gecko behavior seems > to have lower entropy. I prefer the gecko behavior. 1. WebKit more often gets sent down gecko codepaths than trident ones. 2. The Trident behavior is confusingly inconsistent. Avoiding it gives one less gotcha for web developers to learn. 222721 11 abarth 2010-05-07 17:27:39 -0700 Working on a new approach. 222726 12 abarth 2010-05-07 17:34:44 -0700 Ojan, can you test what happens for DOM-created events (as opposed to UI-created events)? 222738 13 55445 abarth 2010-05-07 18:02:47 -0700 Created attachment 55445 Sample fix, no tests 222739 14 abarth 2010-05-07 18:06:28 -0700 Here's one approach to a fix. The patch probably needs some cleanup and testing (of course). The idea is that we move the previous check for "right click" down a layer and add the middle click case. The benefit of being at a lower layer is that we can call the default handler directly, bypassing the dispatch to the DOM-registered events. One side-effect of this change, however, is that the ban might go into effect for DOM-created events as well. We need testing for that case as well. I'm not sure I'll be able to drive this patch to completion in the near term, so someone else who's interested might want to pick it up. Here's a nice test case to play with: data:text/html,<button onclick="this.innerHTML='clicked'">click here</button> 224961 15 abarth 2010-05-12 15:48:14 -0700 I'm going to try to finish this now. 224998 16 55914 abarth 2010-05-12 17:25:04 -0700 Created attachment 55914 Patch 225006 17 abarth 2010-05-12 17:33:45 -0700 I'm not 100% confident in this patch. Any additional ideas about how to test this would be appreciated. 229508 18 Blinkjt 2010-05-23 14:15:18 -0700 how do we install the patch? 229509 19 Blinkjt 2010-05-23 14:15:42 -0700 (In reply to comment #18) > how do we install the patch? and will it be included in chromium release soon? 234364 20 57911 japhet 2010-06-04 13:48:47 -0700 Created attachment 57911 Patch with middle dblclick blocking + shared code with right click event blocking Building on abarth's patch... This change also blocks dblclick events (which Gecko doesn't send for right or middle clicks either) and removes the FIXMEs in abarth's previous patch. Thanks for doing the hard parts, Adam! :) 235997 21 55914 pkasting 2010-06-09 14:09:02 -0700 Comment on attachment 55914 Patch Clearing review flags for abarth's patch since there is a newer patch here. 236005 22 57911 abarth 2010-06-09 14:15:29 -0700 Comment on attachment 57911 Patch with middle dblclick blocking + shared code with right click event blocking I had hoped someone else would review this change since I wrote an earlier version, but this LGTM. 236011 23 57911 abarth 2010-06-09 14:30:14 -0700 Comment on attachment 57911 Patch with middle dblclick blocking + shared code with right click event blocking Evan thinks we should get a more "outside" review on this patch. 236042 24 japhet 2010-06-09 15:18:09 -0700 (In reply to comment #23) > (From update of attachment 57911 [details]) > Evan thinks we should get a more "outside" review on this patch. FWIW, I quasi-reviewed your patch before I started working on it, but I agree that an "outside" review is a good idea. 237391 25 57911 darin 2010-06-12 18:21:19 -0700 Comment on attachment 57911 Patch with middle dblclick blocking + shared code with right click event blocking For our internal convenience we have decided to retain an internal-only click event for middle clicks. And we are now creating such an event for right clicks. To me, it seems unfortunate to do so and we may want to consider another way of handling that in the future. It seems confusing to have a click event that is used internally that is otherwise the same as the click events that go to the DOM. Is there really a need to create these click events and block them at the event dispatch level? > + bool dispatchEventToDefaultEventHandler(PassRefPtr<Event> event); > + void callDefaultEventHandler(Event* event, const Vector<RefPtr<ContainerNode> >& ancestors); I think both of these functions should take PassRefPtr or neither should. It’s not obvious to me whether these functions should take ownership of the event or not, but I suppose the safer design is to use PassRefPtr, since a default event handler could do a lot of work and there’s a chance this could result in the last reference to the event being released. The argument name "event" is not needed in either case. > + RefPtr<EventTarget> protect = this; The use of "protect" here is OK, I suppose, but it's not explained. I guess it's just copied and pasted from dispatchEvent. This is one of the most troubling idioms in our code, because there's no good way to prove such protection is needed nor to notice a case where it's needed and not present! > + // For clicks by the non-left mouse button, Gecko doesn't dispatch the > + // event to the DOM. However, we still want to call the default event > + // handler so that the we can open links in new tabs, etc. This comment is oblique. It says what Gecko does, and then segues into what we will do. The implication is that we plan to do the same thing Gecko does, but no reason is given. In my mind this raises others questions, like what W3C specifications say we should do and what other browsers do. Is this just a Gecko/WebKit alignment, or something we have noticed and are would like to have match among all web browsers? > + if (eventType == eventNames().clickEvent && button != LeftButton) > + dispatchEventToDefaultEventHandler(mouseEvent); > + else > + dispatchEvent(mouseEvent); I think that having this down here at the Node level is unfortunate layering. I'd like to see the code that creates the click event do this instead and it seems that the existing code for right click was at that more appropriate higher level; I suppose it was inelegant to have that in two places in EventHandler, but that code could have been refactored instead of moving the code down here. The code here makes it clear to me that dispatchEventToDefaultEventHandler should be named dispatchEventToDefaultEventHandlerOnly. One of the reasons for that is that the function is not used in the normal dispatch code path. The sole reason for its existence is to have a code path that simulates event dispatch but only sends the event to the default event handler. It's not the "dispatch to default event handler" part of the normal dispatch machinery. I’m going to say review-. Why do we need click events at all for middle clicks? Can’t we fix this at the EventHandler level? 237605 26 abarth 2010-06-13 14:08:21 -0700 > For our internal convenience we have decided to retain an internal-only click event for middle clicks. And we are now creating such an event for right clicks. Yes. I didn't see another technical solution. The events remain, they just aren't dispatched to the DOM because that confuses sites into doing dumb things and is different from Gecko (note that these two facts are likely related). > To me, it seems unfortunate to do so and we may want to consider another way of handling that in the future. It seems confusing to have a click event that is used internally that is otherwise the same as the click events that go to the DOM. Is there really a need to create these click events and block them at the event dispatch level? I don't see another way to fix this bug, but I'm open to suggestions. The problem is that current WebKit clients have behavior we want to retain as the default event handler for these events. If we don't create an event, I'm not sure how to call the proper default event handler. Note that Eric tried to fix this bug a couple years ago at the higher level but couldn't quite come up with a working solution. > I think that having this down here at the Node level is unfortunate layering. I'd like to see the code that creates the click event do this instead and it seems that the existing code for right click was at that more appropriate higher level; I suppose it was inelegant to have that in two places in EventHandler, but that code could have been refactored instead of moving the code down here. I tried to extend the code for handling right-click to handle middle-click, but I couldn't get the right behavior. I posted the patch for review a month ago, so I've forgotten the details by now. > The code here makes it clear to me that dispatchEventToDefaultEventHandler should be named dispatchEventToDefaultEventHandlerOnly. One of the reasons for that is that the function is not used in the normal dispatch code path. The sole reason for its existence is to have a code path that simulates event dispatch but only sends the event to the default event handler. It's not the "dispatch to default event handler" part of the normal dispatch machinery. Well, that and it removes a nasty goto that's simulating a function call return address. :) > I’m going to say review-. Why do we need click events at all for middle clicks? Can’t we fix this at the EventHandler level? I'm open to suggestions for how to do that. I'm certainly not an expert at the event code and could be missing how to get that done. I bet we could do it by breaking all existing clients that handle middle-click via default events, but that sounds like a bad idea. 237618 27 pkasting 2010-06-13 16:04:59 -0700 (In reply to comment #25) > > + // For clicks by the non-left mouse button, Gecko doesn't dispatch the > > + // event to the DOM. However, we still want to call the default event > > + // handler so that the we can open links in new tabs, etc. > > This comment is oblique. It says what Gecko does, and then segues into what we will do. The implication is that we plan to do the same thing Gecko does, but no reason is given. In my mind this raises others questions, like what W3C specifications say we should do and what other browsers do. Is this just a Gecko/WebKit alignment, or something we have noticed and are would like to have match among all web browsers? The W3C spec (that I found) was extremely vague. Some of the Chromium folks looked at this a month or so ago. Here's some background discussion from that thread if you're interested. *** <Ojan Vafai> Firing onclick on middle-click is clearly the more consistent behavior given that it has a property of which mouse button was clicked.. Hixie's suggestion to capture any navigations caused by middle-click and open them in a new tab instead seems like the ideal behavior. ... It's just a lot tricker. <Peter Kasting> Capturing navigations and opening in a new tab seems hard in principle -- how do you know that a navigation was "caused by" this click in the presence of things like setTimeout()? Note that no one fires onclick for right-mouse-button. The argument I'd make is that "click" means "left-click", which lines up well with UI conventions that speak of "click to ____" and mean left-click. Middle- and right-click (and clicking the thumb buttons, etc.) are special kinds of clicks. If I were redoing things from the start I'd make all mouse buttons fire click and put in the button, or else I'd make each have a different event. Given what we have today, however, I'd say that click should be left-click, and if we really want, we should add a different event (or two) for middle click and/or right-click. <Ojan Vafai> Ugh. It's more gross than I realized. I agree, just not firing click on middle-click is probably the only sane result. Gecko: Click only fires for left-click. WebKit: Click fires for left/middle-click, but not right-click. Trident: Click fires for left/middle-click, but not right-click and not if the middle-click was on a link. <Adam Barth> Joy. Do we want the Gecko behavior or the Trident behavior? The Gecko behavior seems to have lower entropy. <Ojan Vafai> I prefer the gecko behavior. 1. WebKit more often gets sent down gecko codepaths than trident ones. 2. The Trident behavior is confusingly inconsistent. Avoiding it gives one less gotcha for web developers to learn. <Evan Martin> I like the idea that "click" is something you do with your primary mouse button, whereas the other behaviors can be caught with onmousedown etc. (Really I prefer click to just be any mouse button, but that ship obviously sailed.) 237672 28 darin 2010-06-13 19:46:28 -0700 (In reply to comment #26) > > For our internal convenience we have decided to retain an internal-only click event for middle clicks. And we are now creating such an event for right clicks. > > Yes. I didn't see another technical solution. The alternative solution would be to move the code that responds to to middle and right clicks into event handlers for events that do get sent instead of the click event. Once we've changed all the event handlers so they don’t depend on receiving a click event for a middle click, then we can change the code to not emit that event. > The problem is that current WebKit clients have behavior we want to retain as the default event handler for these events. This is the part I am not clear on. What are these clients? Are they you talking about something outside the defaultEventHandler functions in WebCore itself? > I bet we could do it by breaking all existing clients that handle middle-click via default events, but that sounds like a bad idea. It all depends on what you mean by clients. Maybe you could give me a specific example of a client outside WebCore? 237673 29 darin 2010-06-13 19:47:54 -0700 (In reply to comment #27) > (In reply to comment #25) > > > + // For clicks by the non-left mouse button, Gecko doesn't dispatch the > > > + // event to the DOM. However, we still want to call the default event > > > + // handler so that the we can open links in new tabs, etc. > > > > This comment is oblique. It says what Gecko does, and then segues into what we will do. The implication is that we plan to do the same thing Gecko does, but no reason is given. In my mind this raises others questions, like what W3C specifications say we should do and what other browsers do. Is this just a Gecko/WebKit alignment, or something we have noticed and are would like to have match among all web browsers? > > The W3C spec (that I found) was extremely vague. Some of the Chromium folks looked at this a month or so ago. Here's some background discussion from that thread if you're interested. I think we should just write a comment saying what we do. "Only clicks on the left mouse button trigger click events." Then if we want to comment on other browser engines, we could, but I would mention both Gecko and Trident behavior. 237683 30 abarth 2010-06-13 20:50:02 -0700 > It all depends on what you mean by clients. Maybe you could give me a specific example of a client outside WebCore? I'll study the code in more detail to see where this code is located. 256972 31 Blinkjt 2010-07-27 18:29:37 -0700 hi, any new updates on this fix? 271552 32 abarth 2010-08-30 12:13:48 -0700 I've become frustrated with this bug. As far as I can tell, this bug is causing pain for a bunch of users and the above patch fixes the bug in all observable ways. Multiple people have tried to fix it at a higher level and were unable to. I think it's likely that it can be done. We just don't know how. If someone would be willing to take this over, I'm sure that would make many folks very happy. 271667 33 darin 2010-08-30 15:04:45 -0700 I’ll take a crack at it. 271673 34 abarth 2010-08-30 15:09:12 -0700 (In reply to comment #33) > I’ll take a crack at it. Thanks Darin. 274265 35 darin 2010-09-03 17:00:33 -0700 I’ve made some progress on this and will be uploading some patches soon. 274271 36 abarth 2010-09-03 17:03:58 -0700 (In reply to comment #35) > I’ve made some progress on this and will be uploading some patches soon. You're my hero. 275082 37 66729 darin 2010-09-07 09:33:07 -0700 Created attachment 66729 Work in progress -- not ready to go yet and probably should be broken up and landed in pieces. 275416 38 66793 darin 2010-09-07 17:07:52 -0700 Created attachment 66793 Patch 275693 39 66793 abarth 2010-09-08 02:16:34 -0700 Comment on attachment 66793 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=66793&action=prettypatch It's a bit difficult for me to see what's going on here. There seems to be a bunch of cleanup mixed in with the functional change. Chasing down a bunch of the diffs, they turn out to just be changing an if to use an early return, etc. If someone else is interested in reviewing this change, then great. Otherwise, I'd appreciate separating out the functional change, mostly because I'm not as familiar with this code as I am with other parts of WebCore. Thanks for working on this bug. :) 275857 40 darin 2010-09-08 08:45:31 -0700 I’m in no rush to get this landed. I might have a chance to refactor it some day, but I have other things to work on next. If someone else wants to pick up the patch and refactor it that’s OK with me too. The total patch size is relatively small, under 30kB. 275928 41 pkasting 2010-09-08 10:44:17 -0700 I'll take a shot today at splitting Darin's patch into a cleanup patch and a functional patch. 276041 42 darin 2010-09-08 13:55:02 -0700 (In reply to comment #41) > I'll take a shot today at splitting Darin's patch into a cleanup patch and a functional patch. Thanks, Peter. I appreciate it. 276113 43 pkasting 2010-09-08 15:30:18 -0700 Darin, I'm not sure this patch is precisely correct. In HTMLAnchorElement::defaultEventHandler(), if this is a focused contenteditable link that is EditableLinkNeverLive, and the event is a keydown of the Enter key, I believe the old code calls the defaultEventHandler(), while your patch will setDefaultHandled() + dispatchSimulatedClick(). Unless this change is harmless, or the old code is actively wrong, it seems like you need to check for !shouldFollowLink() (if we're using your new helper functions) and bail if so. 276128 44 darin 2010-09-08 15:45:25 -0700 (In reply to comment #43) > Darin, I'm not sure this patch is precisely correct. > > In HTMLAnchorElement::defaultEventHandler(), if this is a focused contenteditable link that is EditableLinkNeverLive, and the event is a keydown of the Enter key, I believe the old code calls the defaultEventHandler(), while your patch will setDefaultHandled() + dispatchSimulatedClick(). > > Unless this change is harmless, or the old code is actively wrong, it seems like you need to check for !shouldFollowLink() (if we're using your new helper functions) and bail if so. Sounds good. 276138 45 darin 2010-09-08 15:55:21 -0700 I’m pretty sure that Enter key change is harmless. If you try to reproduce it I think you’ll discover that case does not exist. But still, good catch. 276140 46 66793 darin 2010-09-08 15:56:09 -0700 Comment on attachment 66793 Patch Clearing review flag since Peter and Adam are looking to land this in an incremental fashion, and Peter spotted an unwanted minor change in the logic too. 276254 47 pkasting 2010-09-08 18:33:26 -0700 Here's another weird case. According to ap on IRC, it's possible to have e.g. "keydown" events that are not keyboard events, say if JS does: document.createEvent("CustomEvent").initEvent("keydown", false, false) The various modified defaultEventHandler() functions in the patch no longer behave the same when handling such events. For example, take the simplest of the three, WMLAElement::defaultEventHandler(). When given such an event with a focused link before, it would run what Darin has helpfully factored into a function called handleLinkClicked(). Now it simply calls WMLElement::defaultEventHandler(event);. I have no idea whether this matters; I'm trying to break this patch apart without actually well-understanding the bits of the web platform it underlies :/. Any tips on what I should do here? 276607 48 darin 2010-09-09 11:16:39 -0700 (In reply to comment #47) > According to ap on IRC, it's possible to have e.g. "keydown" events that are not keyboard events, say if JS does: document.createEvent("CustomEvent").initEvent("keydown", false, false) Yes, that’s true. > The various modified defaultEventHandler() functions in the patch no longer behave the same when handling such events. For example, take the simplest of the three, WMLAElement::defaultEventHandler(). When given such an event with a focused link before, it would run what Darin has helpfully factored into a function called handleLinkClicked(). Now it simply calls WMLElement::defaultEventHandler(event);. What you describe is a programming mistake in WMLAElement. It was unintentional on the part of those who originally wrote the code. That’s pretty obvious. For keydown events, "Enter" simulates a click and others are ignored. But incorrectly-constructed keydown events all cause the link to be followed. That’s clearly accidental mistaken code. My rewrite fixes those cases, but they are so obscure I didn’t add test cases for them. > I have no idea whether this matters; I'm trying to break this patch apart without actually well-understanding the bits of the web platform it underlies :/. Any tips on what I should do here? I think you’ll have to decide for yourself. The behavior of these functions with some forms of badly-constructor DOM events was sloppy and a bit random. I changed the behavior to be more logical for these obscure edge cases. My change was intentional, if that’s what you’re asking. 276615 49 pkasting 2010-09-09 11:20:01 -0700 OK, thanks; that's very helpful since I wasn't sure what the desired behavior was. 276797 50 pkasting 2010-09-09 15:28:49 -0700 I'm sorry to keep bringing up minutiae. I think I've got this stuff right but I want to double-check because I'm still learning about event handling. In SVGAElement::defaultEventHandler(), there are two notable changes: (1) The block that begins "if (url[0] == '#')" and does some default handling is no longer protected by "if (!event->defaultPrevented())". I think this is a bug in the patch and that condition needs to be restored. (2) Inside that block, before calling the superclass defaultEventHandler(), "event->setDefaultHandled()" is removed. I assume this is safe because the superclass event handler is supposed to be guaranteed to set this before it returns. 276806 51 darin 2010-09-09 15:43:30 -0700 (In reply to comment #50) > I'm sorry to keep bringing up minutiae. I think I've got this stuff right but I want to double-check because I'm still learning about event handling. > > In SVGAElement::defaultEventHandler(), there are two notable changes: > > (1) The block that begins "if (url[0] == '#')" and does some default handling is no longer protected by "if (!event->defaultPrevented())". I think this is a bug in the patch and that condition needs to be restored. Node::dispatchGenericEvent is responsible for checking defaultPrevented and does it before calling defaultEventHandler. There is no need to check defaultPrevented inside defaultEventHandler functions. Unless there is something highly unusual going on here, that check is just dead code. The check for defaultPrevented inside handleLinkClick is also unneeded for the same reason, but I did not remove it because I didn’t think it through. Adding the defaultPrevented check back in the '#' case would be OK, but it would be better to remove it since it’s not needed. > (2) Inside that block, before calling the superclass defaultEventHandler(), "event->setDefaultHandled()" is removed. I assume this is safe because the superclass event handler is supposed to be guaranteed to set this before it returns. handleLinkClick calls setDefaultHandled, so that was refactored inside that function, rather than removed. The code no longer calls base class's defaultEventHandler function. It’s typically not correct to call the base class’s defaultEventHandler function if you’ve already handled the event, and I checked the base class defaultEventHandler in this case and saw there was no benefit to doing so. 276811 52 pkasting 2010-09-09 15:51:10 -0700 (In reply to comment #51) > > (2) Inside that block, before calling the superclass defaultEventHandler(), "event->setDefaultHandled()" is removed. Oops, I misread the diff here. setDefaultHandled() was preserved while calling the base class handler was removed. That's what you discussed in your last paragraph, so this is fine. Thanks again. 276873 53 67124 pkasting 2010-09-09 17:37:49 -0700 Created attachment 67124 patch, cleanup portion, v1 This is my shot at a "cleanup" patch which doesn't make any changes to how the middle mouse button generates click events. It does contain the other functional changes from Darin's patch except one or two places that seems questionable (mostly discussed above), which are generally only noticeable in weird edge cases. 276883 54 67124 darin 2010-09-09 17:46:06 -0700 Comment on attachment 67124 patch, cleanup portion, v1 Thanks for doing this. I really appreciate you picking up the ball on this. > void DeleteButton::defaultEventHandler(Event* event) > { > - // FIXME: Is it really import to check the type of the event? > - // Seems OK to respond to any event named click even if it does not have the correct type. > - if (event->isMouseEvent()) { > - if (event->type() == eventNames().clickEvent) { > - document()->frame()->editor()->deleteButtonController()->deleteTarget(); > - event->setDefaultHandled(); > - // FIXME: Shouldn't we return here instead of falling through? > - } > + if (event->type() == eventNames().clickEvent) { > + document()->frame()->editor()->deleteButtonController()->deleteTarget(); > + event->setDefaultHandled(); > + } else { > + HTMLImageElement::defaultEventHandler(event); > } > - > - HTMLImageElement::defaultEventHandler(event); > } In the WebKit project we use early return, not else, for cases like this. A single line else does not get braces around it in the WebKit coding style. > +HTMLAnchorElement::EventType HTMLAnchorElement::eventTypeFromEvent(Event* event) > +{ > + if (!event->isMouseEvent()) > + return NonMouseEvent; > + return static_cast<MouseEvent*>(event)->shiftKey() ? MouseEventWithShiftKey : MouseEventWithoutShiftKey; > +} This seems unnecessarily complicated. Why do we need to introduce this enum. Can't we just pass in an event? > +bool HTMLAnchorElement::isLiveLinkImpl(EventType eventType) const I am really confused by the function name "isLiveLinkImpl". When I translate it to English "is this a live link impl" it remains unclear. What is this for? Can we give it a sensible name? > + case EditableLinkLiveWhenNotFocused: > + return (eventType == MouseEventWithShiftKey) || ((eventType == MouseEventWithoutShiftKey) && (m_rootEditableElementForSelectionOnMouseDown != rootEditableElement())); This has too many parentheses in it. In the WebKit project we normally don't include parentheses when mixing "==" and "!=" with logical operators. > + return (event->type() == eventNames().keydownEvent) && event->isKeyboardEvent() && (static_cast<KeyboardEvent*>(event)->keyIdentifier() == "Enter"); Same here. > + return event->isMouseEvent() && (static_cast<MouseEvent*>(event)->button() == MiddleButton); Here too. > + return (event->type() == eventNames().clickEvent) && (!event->isMouseEvent() || (static_cast<MouseEvent*>(event)->button() != RightButton)); And here. > +void handleLinkClick(Event* event, Document* document, const String& url, const String& target, bool hideReferrer) > +{ > + event->setDefaultHandled(); > + Frame* frame = document->frame(); > + if (frame) > + frame->loader()->urlSelected(document->completeURL(url), target, event, false, false, true, hideReferrer ? NoReferrer : SendReferrer); > } In WebKit, we normally use early return rather than nesting things inside an if. > + static EventType eventTypeFromEvent(Event* event); > + bool isLiveLinkImpl(EventType eventType) const; We omit argument names when they are clear from the argument type as in these cases. review- mainly because of isLiveLinkImpl, but also because you made many style changes that do not match the usual WebKit style 276898 55 pkasting 2010-09-09 18:07:54 -0700 (In reply to comment #54) > > + if (event->type() == eventNames().clickEvent) { > > + document()->frame()->editor()->deleteButtonController()->deleteTarget(); > > + event->setDefaultHandled(); > > + } else { > > + HTMLImageElement::defaultEventHandler(event); > > } > > - > > - HTMLImageElement::defaultEventHandler(event); > > } > > In the WebKit project we use early return, not else, for cases like this. I'm not sure what is distinguishing "cases like this" as early-return cases? I tried writing it with early return (each direction), but this was shorter and seemed more readable. > A single line else does not get braces around it in the WebKit coding style. Oops. Will fix. > > +HTMLAnchorElement::EventType HTMLAnchorElement::eventTypeFromEvent(Event* event) > > +{ > > + if (!event->isMouseEvent()) > > + return NonMouseEvent; > > + return static_cast<MouseEvent*>(event)->shiftKey() ? MouseEventWithShiftKey : MouseEventWithoutShiftKey; > > +} > > This seems unnecessarily complicated. Why do we need to introduce this enum. Can't we just pass in an event? Sadly can't, because one of the callers of isLiveLinkImpl() doesn't have an event to work with. We also can't pass in a bool "is the shift key down" (which was my original, simpler choice) because the shift-key-related policies should only allow navigation for mouse events, and the case that comes from a keyboard event couldn't duplicate the correct return values by passing either true or false. > > +bool HTMLAnchorElement::isLiveLinkImpl(EventType eventType) const > > I am really confused by the function name "isLiveLinkImpl". When I translate it to English "is this a live link impl" it remains unclear. > > What is this for? Can we give it a sensible name? This is the low-level implementation of most of the high-level function isLiveLink(). I thought it was a standard pattern that "FooImpl" in any identifier means "implementation of foo". I could call the function isLiveLink(), but I didn't because the existing isLiveLink() wasn't a pure passthrough to this function. I'm not at all wedded to the name, but I'm not sure what would be more clear. I can do the name overloading if you prefer though. > > + case EditableLinkLiveWhenNotFocused: > > + return (eventType == MouseEventWithShiftKey) || ((eventType == MouseEventWithoutShiftKey) && (m_rootEditableElementForSelectionOnMouseDown != rootEditableElement())); > > This has too many parentheses in it. In the WebKit project we normally don't include parentheses when mixing "==" and "!=" with logical operators. I'm going to push back a little here. There's nothing at all in the style guidelines about this, and I've seen code that does both. I personally find parentheses more readable. If we're going to ban them, that's fine, but it should be written down somewhere so that my personal style opinions are not in question (or anyone else's). More importantly in this particular case, I find: a || b && c ...to be extremely confusing as a reader as I don't happen to remember && vs. || precedence. It's also highly error-prone as a writer. If you're allergic to parentheses, how about a compromise on: return eventType == MouseEventWithShiftKey || (eventType == MouseEventWithoutShiftKey && m_rootEditableElementForSelectionOnMouseDown != rootEditableElement()); ...dropping all but one set of parentheses, the critical one that makes precedence clear. Is that acceptable? I can remove the other parentheses, but I really would prefer to do it in the context of an update to the formal style guide. > > +void handleLinkClick(Event* event, Document* document, const String& url, const String& target, bool hideReferrer) > > +{ > > + event->setDefaultHandled(); > > + Frame* frame = document->frame(); > > + if (frame) > > + frame->loader()->urlSelected(document->completeURL(url), target, event, false, false, true, hideReferrer ? NoReferrer : SendReferrer); > > } > > In WebKit, we normally use early return rather than nesting things inside an if. I'm even more confused here than when you mentioned early returns before. I'm not really sure what you're saying when you say "nesting". It sounds like you're saying: "We never write: if (foo) bar();" ...which can't be true. And if (!frame) return; foo(); ...is more code and doesn't save big blocks of indenting or anything. I really am mystified how early-return does anything other than add an unnecessary statement here. (And I'm normally a huge fan of early return! I evangelize it on Chromium code reviews constantly.) > > + static EventType eventTypeFromEvent(Event* event); > > + bool isLiveLinkImpl(EventType eventType) const; > > We omit argument names when they are clear from the argument type as in these cases. Yep, will fix, thanks. 276921 56 darin 2010-09-09 18:30:43 -0700 (In reply to comment #55) > (In reply to comment #54) > > > + if (event->type() == eventNames().clickEvent) { > > > + document()->frame()->editor()->deleteButtonController()->deleteTarget(); > > > + event->setDefaultHandled(); > > > + } else { > > > + HTMLImageElement::defaultEventHandler(event); > > > } > > > - > > > - HTMLImageElement::defaultEventHandler(event); > > > } > > > > In the WebKit project we use early return, not else, for cases like this. > > I'm not sure what is distinguishing "cases like this" as early-return cases? I tried writing it with early return (each direction), but this was shorter and seemed more readable. In a function like this, detecting one type of event and handling it is an early return case. Then the next event handled, then the next. Finally, a call through to the base class. That’s the pattern. Generally speaking the function flows through to the base class, except for a few exceptional cases, events that are detected and handled. The general concept of early return is that there's a "normal case", and then "unusual cases" that are handled early. In the case of an event handler, each kind of event we choose to handle is one of these "unusual cases", which is a little backwards from some other situations where the unusual cases are more often error cases, but still fits the early return pattern well. Please change this. I am pretty passionate about this pattern in these event handler functions. > I thought it was a standard pattern that "FooImpl" in any identifier means "implementation of foo". I don’t think “implementation of is live link” is clear either. The Impl suffix is barely tolerable on class names. We try to avoid it, but we do have some notable exceptions. When the WebKit project began from KHTML, every single class in the DOM had an Impl suffix! But in function names it’s no good, and I’d prefer we not start to proliferate uses of it. > I could call the function isLiveLink(), but I didn't because the existing isLiveLink() wasn't a pure passthrough to this function. I'm not at all wedded to the name, but I'm not sure what would be more clear. I can do the name overloading if you prefer though. We want these helper functions to make the code more readable. Consider a call site like this: if (isLiveLinkImpl(eventType)) How can an event type be a link? What is "Impl"? The original function was named based on being a member function and answered the question "is this a currently live link". Its name was good, but not great. Given what you’re doing in this new function, one name I’d suggest is isLinkLiveForEvent or treatLinkAsLiveForEvent, since it is for use when you already know something is a link answers the question of whether the link should be treated as live for a particular event. I’m still finding the enum inelegant, but I suppose I can live with it. > I find: > a || b && c > ...to be extremely confusing as a reader as I don't happen to remember && vs. || precedence. Yes, those parentheses you should definitely keep, even though they were not in my original patch. I suppose I can’t blame you for noticing those were missing and then going on a parenthesis addition binge! if (a || (b && c)) There's even a GCC warning for this, and we are recommending these parentheses everywhere, and fixing them when the GCC warning turns them up. > how about a compromise on: > return eventType == MouseEventWithShiftKey || (eventType == MouseEventWithoutShiftKey && m_rootEditableElementForSelectionOnMouseDown != rootEditableElement()); > ...dropping all but one set of parentheses, the critical one that makes precedence clear. Is that acceptable? Yes, that's what I was asking for, in fact! Sorry I wasn’t more clear. > > > +void handleLinkClick(Event* event, Document* document, const String& url, const String& target, bool hideReferrer) > > > +{ > > > + event->setDefaultHandled(); > > > + Frame* frame = document->frame(); > > > + if (frame) > > > + frame->loader()->urlSelected(document->completeURL(url), target, event, false, false, true, hideReferrer ? NoReferrer : SendReferrer); > > > } > > > > In WebKit, we normally use early return rather than nesting things inside an if. > > I'm even more confused here than when you mentioned early returns before. I'm not really sure what you're saying when you say "nesting". It sounds like you're saying: > > "We never write: > if (foo) > bar();" > > ...which can't be true. And > > if (!frame) > return; > foo(); > > ...is more code and doesn't save big blocks of indenting or anything. I really am mystified how early-return does anything other than add an unnecessary statement here. (And I'm normally a huge fan of early return! I evangelize it on Chromium code reviews constantly.) When the main flow of the function needs to use something, and that something happens to be null, that's a case where we want to do an early return rather than nesting the real work of the function inside an if. The logic here is not, "if there's a frame we'd like to tell it the URL was selected". It's "we need to tell the frame a URL was selected -- oops, there's no frame!" This kind of exceptional case is almost always done with a return. In this case, our job is to handle a link click, and there's an unusual case where the frame is 0. We deal with that with an early return and then continue with the rest of the work. The fact that the rest of the work is (currently) one line is not particularly important. The point is that the main flow of the function doesn't flow into an if statement body just because there's a need for a null check. 277002 57 pkasting 2010-09-09 21:43:14 -0700 Thanks for the detailed explanations, Darin! They really help. I only had time to skim your message now, so if there's still anything unclear I'll ask tomorrow, but I bet this addresses my questions. 277394 58 67225 pkasting 2010-09-10 13:10:36 -0700 Created attachment 67225 patch, cleanup portion, v1.1 This should address all Darin's comments. I elected to rename isLiveLinkImpl() as treatLinkAsLiveForEventType(). 277449 59 67225 darin 2010-09-10 14:53:23 -0700 Comment on attachment 67225 patch, cleanup portion, v1.1 > + return isLink() ? treatLinkAsLiveForEventType(m_wasShiftKeyDownOnMouseDown ? MouseEventWithShiftKey : MouseEventWithoutShiftKey) : false; I think that && would be clearer here than ? : false. > + static EventType eventTypeFromEvent(Event*); I don’t think this function’s name needs the “FromEvent” suffix. > + String target(isMiddleMouseButtonEvent(event) ? "_blank" : this->target()); I think this would read more clearly with "=" than with construction-style syntax. > + // FIXME: It's not clear why setting target to "_self" is ever > + // helpful. This comment would be better if it was one line instead of two. r=me 277478 60 67225 pkasting 2010-09-10 15:25:16 -0700 Comment on attachment 67225 patch, cleanup portion, v1.1 Clearing flags, I'll land this myself with most of Darin's followup comments also addressed. 277486 61 pkasting 2010-09-10 15:43:20 -0700 Landed cleanup patch in r67246. Functional patch coming soon. 277543 62 67266 pkasting 2010-09-10 16:56:18 -0700 Created attachment 67266 patch, functional portion, v1 This should do the heavy lifting. I'm still building this patch to test that it does what it claims. 277558 63 pkasting 2010-09-10 17:26:41 -0700 Real-world tests show that the patch works as advertised, hooray! 277559 64 67266 abarth 2010-09-10 17:30:18 -0700 Comment on attachment 67266 patch, functional portion, v1 View in context: https://bugs.webkit.org/attachment.cgi?id=67266&action=prettypatch Looks reasonable. I'd need to look at more of the surrounding code to give it a full review. Thanks for working on this bug. > WebCore/ChangeLog:1 > -2010-09-109 Peter Kasting <pkasting@google.com> > +2010-09-10 Peter Kasting <pkasting@google.com> This changelog diff is kind of wonky. 277561 65 pkasting 2010-09-10 17:31:47 -0700 (In reply to comment #64) > > WebCore/ChangeLog:1 > > -2010-09-109 Peter Kasting <pkasting@google.com> > > +2010-09-10 Peter Kasting <pkasting@google.com> > This changelog diff is kind of wonky. That's because I accidentally typo'd the cleanup patch, and committed it. So this fixes the typo :) 277583 66 pkasting 2010-09-10 18:18:03 -0700 Landed myself in r67261, in case the commit queue was confused by the ChangeLog mucking, because I'm gone all next week and wouldn't be able to fix. 277584 67 67266 pkasting 2010-09-10 18:18:24 -0700 Comment on attachment 67266 patch, functional portion, v1 (Clearing flags) 277632 68 mkterra 2010-09-10 22:12:56 -0700 Thanks, all! :) 278042 69 krit 2010-09-13 01:05:12 -0700 http://trac.webkit.org/changeset/67246 broke WML builds. Sadly we don't have bots for WML :-( See bug 45628. 293292 70 petergrabs 2010-10-13 00:28:04 -0700 i get the impression that you fixed this bug by firing click events only on left clicks. is that correct? before writing any more i just wanted to make sure that i got it right, because i cant believe it. 293473 71 darin 2010-10-13 09:52:05 -0700 (In reply to comment #70) > i get the impression that you fixed this bug by firing click events only on left clicks. Yes. To be consistent with the behavior of all other web browsers. 294617 72 petergrabs 2010-10-15 00:48:18 -0700 how can developing new browsers possibly be about "being like the other browsers"? wouldn't this defeat the whole point? shouldn't it be about being better than the others, e.g. by more standard compliance? in webpage development it's commonplace to test for all major browsers anyway, so deviating from the others is no particular problem, especially if the developer after finding one such problem determines that the others are at fault resulting in him liking the new product even more (see IE bashing). for me, being standard compliant vs. being like the others is a no-brainer. you can always add additional functionality and convenience functions to help the developer, but never at the price of losing standard compliance. 294620 73 abarth 2010-10-15 00:55:45 -0700 (In reply to comment #72) > how can developing new browsers possibly be about "being like the other browsers"? wouldn't this defeat the whole point? shouldn't it be about being better than the others, e.g. by more standard compliance? Ideally, the goal is to align the behavior of every browser and the standards so that developers can write code once and have it work properly in every browser. 294627 74 petergrabs 2010-10-15 01:16:14 -0700 exactly. and the way to achieve this is typically that everyone tries to approach the standard as good as they can, not giving in to the most stubborn/unresponsive vendor. if standard compliance really doesn't sound as attractive to you as it does to me, at least make sure that you don't lose functionality, i.e. provide a new event like "standardClick" which behaves like the standard click event. 294635 75 abarth 2010-10-15 01:29:50 -0700 Thanks for sharing your perspective. Indeed, the question of when to match other browsers and when to create new "more standard" ways of doing things is a tricky one. We try to balance these competing factors in the WebKit project, sometimes with more success than others. In the case of this bug, we're trying to achieve better behavior on sites that apparently didn't test this case on WebKit because they're surprised when a click even fires for a middle click. Some of that might be because WebKit has historically been used more on Mac, where middle click is a less common operation than on other platforms, such as Linux. 294655 76 petergrabs 2010-10-15 02:27:04 -0700 so we have a non standard compliant script and a browser. the script doesnt work. ... so we of course adapt the browser to it! if it is one versus the other, i firmly remain on the side of standard compliance (especially if as in this case the standard is more logical than the suggested deviation; were it the other way round, one could hope that the standard will become reality compliant). but i see your point too, you want things to be easy for old code. this makes me think of visual basic's "option explicit". using that the programmer can decide that he wants stricter rules applied to him and thus make better code, without having to touch the old one. might something like that be possible in javascript? tell the browser at the beginning of the script that you want maximum standard compliance, this way newly created stuff will have higher quality while the old stuff keeps working. one might continue phantasizing about more that a "default mode" and a "standard mode", e.g. IE or FF compatibility modes ... but all this is complicated and in my opinion destructive since it encourages sticking with bad old code while enforcing a standard makes code versions converge. 294659 77 abarth 2010-10-15 02:35:11 -0700 Keep in mind that another option is to change the standards to say what browsers actually do. In any case, this sort of high-level discussion isn't really appropriate for the bug tracker. If you'd like to influence the direction of the project, one path is to become a contributor and write patches that improve the project in your view. You can find more information about contributing code on this web page: http://webkit.org/coding/contributing.html Kind regards. 294759 78 ayg 2010-10-15 08:32:37 -0700 (In reply to comment #72) > how can developing new browsers possibly be about "being like the other browsers"? wouldn't this defeat the whole point? shouldn't it be about being better than the others, e.g. by more standard compliance? There is no standard that currently specifies this behavior, so this is irrelevant. Generally speaking, web standards don't specify UI at all if they can avoid it. Should such a standard be created (it probably will be sometime), it would undoubtedly specify that click events fire only on left clicks, since that's now what all major browsers do. Standards are normally written to match what browsers do unless there are strong reasons not to. However, as Adam says, Bugzilla isn't really the right place for this kind of discussion. 294775 79 petergrabs 2010-10-15 09:20:58 -0700 i am reading this from the fact that the click event has a button attribute. 339414 80 pkasting 2011-01-24 17:50:48 -0800 r67261 was rolled back due to regressions covered by bug 46733. On that bug there was some discussion of the ideal behavior here and some testcases posted. I will attempt to summarize and paraphrase: Me, after much discussion: "We need to change our behavior to: * Links are not opened in response to DOM click events. Instead, they're opened directly in response to UI actions such as clicks and keypresses. * For left-clicks, we need to process the DOM click event first, so that if it is default-prevented, we do not open the link." Darin Adler: "We need to either: 1) Put some hidden state on the "real" click event so that the defaultEventHandler function can tell what to do. 2) Put the code to open links at the call site that sends the event rather than in the defaultEventHandler function. But to prevent EventHandler from becoming a giant god class we still may want to involve some virtual functions on the element involved." Me: "We can't use the existing fromUserGesture() function because that just tells us whether we're in the chain of functionality triggered by a user event, meaning a click on one element could call a handler function that generates a click on a different element, and we'd go ahead and navigate." Darin: "We should start by adding LayoutTests that cover everything we care about here. The tests should be written so that PASS is what we want to eventually happen, and we should land expected results that show the current failures (no use of skipped lists). This does not require expertise at code changes -- it's entirely about embodying our research and plans in test form. To test the difference between DOM-created events and user-created ones we will need to use eventSender." Next I'll attach some testcases to this bug that I attached to the other bug, and summarize how we ought to behave on them. 339418 81 80001 pkasting 2011-01-24 17:54:30 -0800 Created attachment 80001 onmouseup target testcase This testcase can be used to verify where onmouseup is targeted, for both left and middle clicks. Regardless of where mousedown occurs, mouseup should trigger an alert with the element that mouseup occurred over. 339420 82 80002 pkasting 2011-01-24 18:00:03 -0800 Created attachment 80002 opening links on events testcase This testcase can be used to see what should happen in response to artificially-created events. Neither mousing over link 2, nor mousing over link 1 and then link 2, should open any pages. Modify the original testcase to change the mouse button from "1" to "0", then test again, and you should get the same results. Modify the original testcase to uncomment the preventDefault() call in displayEventName(), then left-clicking link 3 should open nothing, while middle-clicking should open one background tab displaying bing.com. Modify the original testcase to uncomment the preventDefault() call in the link 3 click listener, then you should get the same results as just above (left-clicking link 3 should open nothing, while middle-clicking should open one background tab displaying bing.com). 339422 83 80003 pkasting 2011-01-24 18:02:45 -0800 Created attachment 80003 middle-mouse autoscroll testcase This testcase can be used to check default prevention on autoscrolling. Resize your window small enough to get scrollbars, then middle-click. An autoscroll ("pan scroll") cursor should not appear. 491380 84 drtifti 2011-10-27 00:36:01 -0700 10 months later... Any news on this correction ? I have read all the technical and philosophical discussion on this bug and bug #46733, but this one is still annoying 609483 85 138742 webkit 2012-04-24 23:24:17 -0700 Created attachment 138742 Safari extension to cancel unwanted click events Here is a simple browser extension which effectively implements the Gecko behaviour, to fix those annoying sites that assume it while this is still being resolved. A Chrome version is available at https://chrome.google.com/webstore/developer/edit/ndinbeikllkfjbmlfghokbkmcciflpek 609484 86 webkit 2012-04-24 23:26:02 -0700 Sorry... that URL should be https://chrome.google.com/webstore/detail/ndinbeikllkfjbmlfghokbkmcciflpek 609501 87 petergrabs 2012-04-24 23:59:10 -0700 there has been an extension for that for a long time: https://chrome.google.com/webstore/detail/ikbkhpkapkmhaoiabhlkmicpeakhhpip there is even a version as minimalist as yours: https://chrome.google.com/webstore/detail/jnpgomjchhllpeehnmjfcfoceboliing 609578 88 webkit 2012-04-25 02:29:17 -0700 *** Bug 70070 has been marked as a duplicate of this bug. *** 609909 89 138843 webkit 2012-04-25 10:58:52 -0700 Created attachment 138843 Example of click event that Gecko fires on all clicks Just to complicate things, it seems that Gecko actually fires click for all click types on listeners attached to document or window. See the attached case. 1188361 90 tonikitoo 2016-04-28 13:31:30 -0700 (In reply to comment #89) > Created attachment 138843 [details] > Example of click event that Gecko fires on all clicks > > Just to complicate things, it seems that Gecko actually fires click for all > click types on listeners attached to document or window. See the attached > case. Please note that Blink has moved on here and now matches the spec: https://groups.google.com/a/chromium.org/forum/#!topic/blink-dev/pYAh8bBl5Yc On this same thread, one can see that Edge has filed an issue to follow up. Firefox has already been matching the spec for some time. 1188376 91 webkit-bug-importer 2016-04-28 14:00:46 -0700 <rdar://problem/25988904> 1268101 92 rbyers 2017-01-19 08:07:11 -0800 Specifically we successfully changed blink by adding a new 'auxclick' event that's fired in special cases like middle click (and right click when the contextmenu is suppressed). https://wicg.github.io/auxclick/ I'd encourage WebKit to do the same thing. We've seen very little compat problems as a result. 1268273 93 ap 2017-01-19 17:36:01 -0800 *** Bug 166849 has been marked as a duplicate of this bug. *** 2028492 94 possum.bracing0v 2024-04-15 05:49:25 -0700 Would be nice if this was re-looked at. Support for auxclick is important for gaming with a mouse that has multiple buttons on macOS, iOS, iPadOS, and visionOS. 2046796 95 richard_robinson2 2024-07-17 13:37:58 -0700 Pull request: https://github.com/WebKit/WebKit/pull/30917 2046797 96 possum.bracing0v 2024-07-17 13:42:28 -0700 Is this being worked on for macOS, iPadOS, & visionOS (iOS does not have mouse support)? Or is it just macOS? Also closing a duplicate bug I had: https://bugs.webkit.org/show_bug.cgi?id=273946 2046800 97 possum.bracing0v 2024-07-17 13:43:55 -0700 *** Bug 273946 has been marked as a duplicate of this bug. *** 2047367 98 ews-feeder 2024-07-20 18:55:36 -0700 Committed 281169@main (62f87d3a9254): <https://commits.webkit.org/281169@main> Reviewed commits have been landed. Closing PR #30917 and removing active labels. 55445 2010-05-07 18:02:47 -0700 2010-05-12 17:24:57 -0700 Sample fix, no tests bug-22382-20100507180245.patch text/plain 6718 abarth SW5kZXg6IFdlYkNvcmUvZG9tL05vZGUuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZG9tL05v ZGUuY3BwCShyZXZpc2lvbiA1ODk4NikKKysrIFdlYkNvcmUvZG9tL05vZGUuY3BwCSh3b3JraW5n IGNvcHkpCkBAIC0yNTY2LDYgKzI1NjYsMTggQEAgYm9vbCBOb2RlOjpkaXNwYXRjaEV2ZW50KFBh c3NSZWZQdHI8RXZlbgogICAgIHJldHVybiBkaXNwYXRjaEdlbmVyaWNFdmVudChldmVudC5yZWxl YXNlKCkpOwogfQogCit2b2lkIE5vZGU6OmRpc3BhdGNoRXZlbnRUb0RlZmF1bHRFdmVudEhhbmRs ZXIoRXZlbnQqIGV2ZW50KQoreworICAgIFJlZlB0cjxFdmVudFRhcmdldD4gcHJvdGVjdCA9IHRo aXM7CisgICAgUmVmUHRyPEZyYW1lVmlldz4gdmlldyA9IGRvY3VtZW50KCktPnZpZXcoKTsKKwor ICAgIGV2ZW50LT5zZXRUYXJnZXQoZXZlbnRUYXJnZXRSZXNwZWN0aW5nU1ZHVGFyZ2V0UnVsZXMo dGhpcykpOworCisgICAgVmVjdG9yPFJlZlB0cjxDb250YWluZXJOb2RlPiA+IGFuY2VzdG9yczsK KyAgICBldmVudEFuY2VzdG9ycyhhbmNlc3RvcnMpOworICAgIGNhbGxEZWZhdWx0RXZlbnRIYW5k bGVyKGV2ZW50LCBhbmNlc3RvcnMpOworfQorCiBzdGF0aWMgYm9vbCBldmVudEhhc0xpc3RlbmVy cyhjb25zdCBBdG9taWNTdHJpbmcmIGV2ZW50VHlwZSwgRE9NV2luZG93KiB3aW5kb3csIE5vZGUq IG5vZGUsIFZlY3RvcjxSZWZQdHI8Q29udGFpbmVyTm9kZT4gPiYgYW5jZXN0b3JzKQogewogICAg IGlmICh3aW5kb3cgJiYgd2luZG93LT5oYXNFdmVudExpc3RlbmVycyhldmVudFR5cGUpKQpAQCAt MjY3NywyNyArMjY4OSw5IEBAIGRvbmVEaXNwYXRjaGluZzoKICAgICAvLyBDYWxsIGRlZmF1bHQg ZXZlbnQgaGFuZGxlcnMuIFdoaWxlIHRoZSBET00gZG9lcyBoYXZlIGEgY29uY2VwdCBvZiBwcmV2 ZW50aW5nCiAgICAgLy8gZGVmYXVsdCBoYW5kbGluZywgdGhlIGRldGFpbCBvZiB3aGljaCBoYW5k bGVycyBhcmUgY2FsbGVkIGlzIGFuIGludGVybmFsCiAgICAgLy8gaW1wbGVtZW50YXRpb24gZGV0 YWlsIGFuZCBub3QgcGFydCBvZiB0aGUgRE9NLgotICAgIGlmICghZXZlbnQtPmRlZmF1bHRQcmV2 ZW50ZWQoKSAmJiAhZXZlbnQtPmRlZmF1bHRIYW5kbGVkKCkpIHsKLSAgICAgICAgLy8gTm9uLWJ1 YmJsaW5nIGV2ZW50cyBjYWxsIG9ubHkgb25lIGRlZmF1bHQgZXZlbnQgaGFuZGxlciwgdGhlIG9u ZSBmb3IgdGhlIHRhcmdldC4KLSAgICAgICAgZGVmYXVsdEV2ZW50SGFuZGxlcihldmVudC5nZXQo KSk7Ci0gICAgICAgIEFTU0VSVCghZXZlbnQtPmRlZmF1bHRQcmV2ZW50ZWQoKSk7Ci0gICAgICAg IGlmIChldmVudC0+ZGVmYXVsdEhhbmRsZWQoKSkKLSAgICAgICAgICAgIGdvdG8gZG9uZVdpdGhE ZWZhdWx0OwotICAgICAgICAvLyBGb3IgYnViYmxpbmcgZXZlbnRzLCBjYWxsIGRlZmF1bHQgZXZl bnQgaGFuZGxlcnMgb24gdGhlIHNhbWUgdGFyZ2V0cyBpbiB0aGUKLSAgICAgICAgLy8gc2FtZSBv cmRlciBhcyB0aGUgYnViYmxpbmcgcGhhc2UuCi0gICAgICAgIGlmIChldmVudC0+YnViYmxlcygp KSB7Ci0gICAgICAgICAgICBzaXplX3Qgc2l6ZSA9IGFuY2VzdG9ycy5zaXplKCk7Ci0gICAgICAg ICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IHNpemU7ICsraSkgewotICAgICAgICAgICAgICAg IENvbnRhaW5lck5vZGUqIGFuY2VzdG9yID0gYW5jZXN0b3JzW2ldLmdldCgpOwotICAgICAgICAg ICAgICAgIGFuY2VzdG9yLT5kZWZhdWx0RXZlbnRIYW5kbGVyKGV2ZW50LmdldCgpKTsKLSAgICAg ICAgICAgICAgICBBU1NFUlQoIWV2ZW50LT5kZWZhdWx0UHJldmVudGVkKCkpOwotICAgICAgICAg ICAgICAgIGlmIChldmVudC0+ZGVmYXVsdEhhbmRsZWQoKSkKLSAgICAgICAgICAgICAgICAgICAg Z290byBkb25lV2l0aERlZmF1bHQ7Ci0gICAgICAgICAgICB9Ci0gICAgICAgIH0KLSAgICB9Cisg ICAgaWYgKCFldmVudC0+ZGVmYXVsdFByZXZlbnRlZCgpICYmICFldmVudC0+ZGVmYXVsdEhhbmRs ZWQoKSkKKyAgICAgICAgY2FsbERlZmF1bHRFdmVudEhhbmRsZXIoZXZlbnQuZ2V0KCksIGFuY2Vz dG9ycyk7CiAKLWRvbmVXaXRoRGVmYXVsdDoKICNpZiBFTkFCTEUoSU5TUEVDVE9SKQogICAgIGlm IChpbnNwZWN0ZWRQYWdlKQogICAgICAgICBpZiAoSW5zcGVjdG9yVGltZWxpbmVBZ2VudCogdGlt ZWxpbmVBZ2VudCA9IGluc3BlY3RlZFBhZ2UtPmluc3BlY3RvclRpbWVsaW5lQWdlbnQoKSkKQEAg LTI3MDcsNiArMjcwMSwyNyBAQCBkb25lV2l0aERlZmF1bHQ6CiAgICAgcmV0dXJuICFldmVudC0+ ZGVmYXVsdFByZXZlbnRlZCgpOwogfQogCit2b2lkIE5vZGU6OmNhbGxEZWZhdWx0RXZlbnRIYW5k bGVyKEV2ZW50KiBldmVudCwgY29uc3QgVmVjdG9yPFJlZlB0cjxDb250YWluZXJOb2RlPiA+JiBh bmNlc3RvcnMpCit7CisgICAgLy8gTm9uLWJ1YmJsaW5nIGV2ZW50cyBjYWxsIG9ubHkgb25lIGRl ZmF1bHQgZXZlbnQgaGFuZGxlciwgdGhlIG9uZSBmb3IgdGhlIHRhcmdldC4KKyAgICBkZWZhdWx0 RXZlbnRIYW5kbGVyKGV2ZW50KTsKKyAgICBBU1NFUlQoIWV2ZW50LT5kZWZhdWx0UHJldmVudGVk KCkpOworICAgIGlmIChldmVudC0+ZGVmYXVsdEhhbmRsZWQoKSkKKyAgICAgICAgcmV0dXJuOwor ICAgIC8vIEZvciBidWJibGluZyBldmVudHMsIGNhbGwgZGVmYXVsdCBldmVudCBoYW5kbGVycyBv biB0aGUgc2FtZSB0YXJnZXRzIGluIHRoZQorICAgIC8vIHNhbWUgb3JkZXIgYXMgdGhlIGJ1YmJs aW5nIHBoYXNlLgorICAgIGlmIChldmVudC0+YnViYmxlcygpKSB7CisgICAgICAgIHNpemVfdCBz aXplID0gYW5jZXN0b3JzLnNpemUoKTsKKyAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBz aXplOyArK2kpIHsKKyAgICAgICAgICAgIENvbnRhaW5lck5vZGUqIGFuY2VzdG9yID0gYW5jZXN0 b3JzW2ldLmdldCgpOworICAgICAgICAgICAgYW5jZXN0b3ItPmRlZmF1bHRFdmVudEhhbmRsZXIo ZXZlbnQpOworICAgICAgICAgICAgQVNTRVJUKCFldmVudC0+ZGVmYXVsdFByZXZlbnRlZCgpKTsK KyAgICAgICAgICAgIGlmIChldmVudC0+ZGVmYXVsdEhhbmRsZWQoKSkKKyAgICAgICAgICAgICAg ICByZXR1cm47CisgICAgICAgIH0KKyAgICB9Cit9CisKIHZvaWQgTm9kZTo6ZGlzcGF0Y2hTdWJ0 cmVlTW9kaWZpZWRFdmVudCgpCiB7CiAgICAgQVNTRVJUKCFldmVudERpc3BhdGNoRm9yYmlkZGVu KCkpOwpAQCAtMjg1NCwxMyArMjg2OSwxOSBAQCBib29sIE5vZGU6OmRpc3BhdGNoTW91c2VFdmVu dChjb25zdCBBdG9tCiAgICAgICAgIHJlbGF0ZWRUYXJnZXQsIDAsIGlzU2ltdWxhdGVkKTsKICAg ICBtb3VzZUV2ZW50LT5zZXRVbmRlcmx5aW5nRXZlbnQodW5kZXJseWluZ0V2ZW50LmdldCgpKTsK ICAgICBtb3VzZUV2ZW50LT5zZXRBYnNvbHV0ZUxvY2F0aW9uKEludFBvaW50KHBhZ2VYLCBwYWdl WSkpOwotICAgIAotICAgIGRpc3BhdGNoRXZlbnQobW91c2VFdmVudCk7CisKKyAgICAvLyBGb3Ig Y2xpY2tzIGJ5IHRoZSBub24tbGVmdCBtb3VzZSBidXR0b24sIEdlY2tvIGRvZXNuJ3QgZGlzcGF0 Y2ggdGhlCisgICAgLy8gZXZlbnQgdG8gdGhlIERPTS4gIEhvd2V2ZXIsIHdlIHN0aWxsIHdhbnQg dG8gY2FsbCB0aGUgZGVmYXVsdCBldmVudAorICAgIC8vIGhhbmRsZXIgc28gdGhhdCB0aGUgd2Ug Y2FuIG9wZW4gbGlua3MgaW4gbmV3IHRhYnMsIGV0Yy4KKyAgICBpZiAoZXZlbnRUeXBlID09IGV2 ZW50TmFtZXMoKS5jbGlja0V2ZW50ICYmIGJ1dHRvbiAhPSBMZWZ0QnV0dG9uKQorICAgICAgICBk aXNwYXRjaEV2ZW50VG9EZWZhdWx0RXZlbnRIYW5kbGVyKG1vdXNlRXZlbnQuZ2V0KCkpOworICAg IGVsc2UKKyAgICAgICAgZGlzcGF0Y2hFdmVudChtb3VzZUV2ZW50KTsKICAgICBib29sIGRlZmF1 bHRIYW5kbGVkID0gbW91c2VFdmVudC0+ZGVmYXVsdEhhbmRsZWQoKTsKICAgICBib29sIGRlZmF1 bHRQcmV2ZW50ZWQgPSBtb3VzZUV2ZW50LT5kZWZhdWx0UHJldmVudGVkKCk7CiAgICAgaWYgKGRl ZmF1bHRIYW5kbGVkIHx8IGRlZmF1bHRQcmV2ZW50ZWQpCiAgICAgICAgIHN3YWxsb3dFdmVudCA9 IHRydWU7Ci0gICAgCisKICAgICAvLyBTcGVjaWFsIGNhc2U6IElmIGl0J3MgYSBkb3VibGUgY2xp Y2sgZXZlbnQsIHdlIGFsc28gc2VuZCB0aGUgZGJsY2xpY2sgZXZlbnQuIFRoaXMgaXMgbm90IHBh cnQKICAgICAvLyBvZiB0aGUgRE9NIHNwZWNzLCBidXQgaXMgdXNlZCBmb3IgY29tcGF0aWJpbGl0 eSB3aXRoIHRoZSBvbmRibGNsaWNrPSIiIGF0dHJpYnV0ZS4gIFRoaXMgaXMgdHJlYXRlZAogICAg IC8vIGFzIGEgc2VwYXJhdGUgZXZlbnQgaW4gb3RoZXIgRE9NLWNvbXBsaWFudCBicm93c2VycyBs aWtlIEZpcmVmb3gsIGFuZCBzbyB3ZSBkbyB0aGUgc2FtZS4KSW5kZXg6IFdlYkNvcmUvZG9tL05v ZGUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9Ob2RlLmgJKHJldmlzaW9uIDU4OTg2KQor KysgV2ViQ29yZS9kb20vTm9kZS5oCSh3b3JraW5nIGNvcHkpCkBAIC02OTYsNiArNjk2LDkgQEAg cHJpdmF0ZToKICAgICBOb2RlKiBjb250YWluZXJMYXN0Q2hpbGQoKSBjb25zdDsKICAgICBib29s IHJhcmVEYXRhRm9jdXNlZCgpIGNvbnN0OwogCisgICAgdm9pZCBkaXNwYXRjaEV2ZW50VG9EZWZh dWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldmVudCk7CisgICAgdm9pZCBjYWxsRGVmYXVsdEV2ZW50 SGFuZGxlcihFdmVudCogZXZlbnQsIGNvbnN0IFZlY3RvcjxSZWZQdHI8Q29udGFpbmVyTm9kZT4g PiYgYW5jZXN0b3JzKTsKKwogICAgIHZpcnR1YWwgUmVuZGVyU3R5bGUqIG5vblJlbmRlcmVyUmVu ZGVyU3R5bGUoKSBjb25zdDsKIAogICAgIHZpcnR1YWwgY29uc3QgQXRvbWljU3RyaW5nJiB2aXJ0 dWFsUHJlZml4KCkgY29uc3Q7CkluZGV4OiBXZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAkocmV2aXNpb24gNTg5 ODYpCisrKyBXZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAt MTM2MCwxMSArMTM2MCw3IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZURvdWJsZUNs aWMKIAogICAgIG1fY2xpY2tDb3VudCA9IG1vdXNlRXZlbnQuY2xpY2tDb3VudCgpOwogICAgIGJv b2wgc3dhbGxvd01vdXNlVXBFdmVudCA9IGRpc3BhdGNoTW91c2VFdmVudChldmVudE5hbWVzKCku bW91c2V1cEV2ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNrQ291bnQsIG1vdXNl RXZlbnQsIGZhbHNlKTsKLQotICAgIGJvb2wgc3dhbGxvd0NsaWNrRXZlbnQgPSBmYWxzZTsKLSAg ICAvLyBEb24ndCBldmVyIGRpc3BhdGNoIGNsaWNrIGV2ZW50cyBmb3IgcmlnaHQgY2xpY2tzCi0g ICAgaWYgKG1vdXNlRXZlbnQuYnV0dG9uKCkgIT0gUmlnaHRCdXR0b24gJiYgbWV2LnRhcmdldE5v ZGUoKSA9PSBtX2NsaWNrTm9kZSkKLSAgICAgICAgc3dhbGxvd0NsaWNrRXZlbnQgPSBkaXNwYXRj aE1vdXNlRXZlbnQoZXZlbnROYW1lcygpLmNsaWNrRXZlbnQsIG1ldi50YXJnZXROb2RlKCksIHRy dWUsIG1fY2xpY2tDb3VudCwgbW91c2VFdmVudCwgdHJ1ZSk7CisgICAgYm9vbCBzd2FsbG93Q2xp Y2tFdmVudCA9IGRpc3BhdGNoTW91c2VFdmVudChldmVudE5hbWVzKCkuY2xpY2tFdmVudCwgbWV2 LnRhcmdldE5vZGUoKSwgdHJ1ZSwgbV9jbGlja0NvdW50LCBtb3VzZUV2ZW50LCB0cnVlKTsKIAog ICAgIGlmIChtX2xhc3RTY3JvbGxiYXJVbmRlck1vdXNlKQogICAgICAgICBzd2FsbG93TW91c2VV cEV2ZW50ID0gbV9sYXN0U2Nyb2xsYmFyVW5kZXJNb3VzZS0+bW91c2VVcCgpOwpAQCAtMTU1MCwx MSArMTU0Niw3IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZVJlbGVhc2VFdmUKICAg ICB9CiAKICAgICBib29sIHN3YWxsb3dNb3VzZVVwRXZlbnQgPSBkaXNwYXRjaE1vdXNlRXZlbnQo ZXZlbnROYW1lcygpLm1vdXNldXBFdmVudCwgbWV2LnRhcmdldE5vZGUoKSwgdHJ1ZSwgbV9jbGlj a0NvdW50LCBtb3VzZUV2ZW50LCBmYWxzZSk7Ci0KLSAgICAvLyBEb24ndCBldmVyIGRpc3BhdGNo IGNsaWNrIGV2ZW50cyBmb3IgcmlnaHQgY2xpY2tzCi0gICAgYm9vbCBzd2FsbG93Q2xpY2tFdmVu dCA9IGZhbHNlOwotICAgIGlmIChtX2NsaWNrQ291bnQgPiAwICYmIG1vdXNlRXZlbnQuYnV0dG9u KCkgIT0gUmlnaHRCdXR0b24gJiYgbWV2LnRhcmdldE5vZGUoKSA9PSBtX2NsaWNrTm9kZSkKLSAg ICAgICAgc3dhbGxvd0NsaWNrRXZlbnQgPSBkaXNwYXRjaE1vdXNlRXZlbnQoZXZlbnROYW1lcygp LmNsaWNrRXZlbnQsIG1ldi50YXJnZXROb2RlKCksIHRydWUsIG1fY2xpY2tDb3VudCwgbW91c2VF dmVudCwgdHJ1ZSk7CisgICAgYm9vbCBzd2FsbG93Q2xpY2tFdmVudCA9IGRpc3BhdGNoTW91c2VF dmVudChldmVudE5hbWVzKCkuY2xpY2tFdmVudCwgbWV2LnRhcmdldE5vZGUoKSwgdHJ1ZSwgbV9j bGlja0NvdW50LCBtb3VzZUV2ZW50LCB0cnVlKTsKIAogICAgIGlmIChtX3Jlc2l6ZUxheWVyKSB7 CiAgICAgICAgIG1fcmVzaXplTGF5ZXItPnNldEluUmVzaXplTW9kZShmYWxzZSk7Cg== 55914 2010-05-12 17:25:04 -0700 2010-06-09 14:09:01 -0700 Patch bug-22382-20100512172503.patch text/plain 11552 abarth ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA5ZTcwNDZkNzAwODM1YzBkY2RhZmNkNDEwZDg1NWFhNDE4ZDQ0NDQ0Li4wOTgwZmQ1 OTYyZTQ2YjU3MjEyN2NkNGExMzUwNTZkZGY3NzYyMDllIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAK KzIwMTAtMDUtMTIgIEFkYW0gQmFydGggIDxhYmFydGhAd2Via2l0Lm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBNaWRkbGUgY2xpY2sgZmlyZXMg b25jbGljayBldmVudAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjIzODIKKworICAgICAgICBVcGRhdGUgZXhwZWN0ZWQgcmVzdWx0cyB0byBzaG93IHRo YXQgd2UncmUgbm90IHNlbmRpbmcgbWlkZGxlIGNsaWNrCisgICAgICAgIGV2ZW50cyBhbnltb3Jl LgorCisgICAgICAgICogZmFzdC9ldmVudHMvbW91c2UtY2xpY2stZXZlbnRzLWV4cGVjdGVkLnR4 dDoKKwogMjAxMC0wNS0xMiAgRGlyayBQcmFua2UgIDxkcHJhbmtlQGNocm9taXVtLm9yZz4KIAog ICAgICAgICBVbnJldmlld2VkLCBidWlsZCBmaXguCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9m YXN0L2V2ZW50cy9tb3VzZS1jbGljay1ldmVudHMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv ZmFzdC9ldmVudHMvbW91c2UtY2xpY2stZXZlbnRzLWV4cGVjdGVkLnR4dAppbmRleCBhNjJhZGFl MmM0YTc2NTU5N2E0YmY3NTJkM2JhNWE0OTM2YjNjNjUxLi4yODBhZDE3YmM5NzY5NmMwNDQzYTEy YjhlNzY1YTU4Y2U2NDEyY2E1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9t b3VzZS1jbGljay1ldmVudHMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZl bnRzL21vdXNlLWNsaWNrLWV2ZW50cy1leHBlY3RlZC50eHQKQEAgLTYsMTEgKzYsMTEgQEAgT24g c3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93 ZWQgYnkgIlRFU1QgQ09NUExFVEUKIExlZnQgTW91c2UgQnV0dG9uCiBQQVNTIGV2ZW50TG9nIGlz ICJtb3VzZWRvd24oMCkgbW91c2V1cCgwKSBjbGljaygwKSBtb3VzZWRvd24oMCkgbW91c2V1cCgw KSBjbGljaygwKSBkYmxjbGljaygwKSAiCiBNaWRkbGUgTW91c2UgQnV0dG9uCi1QQVNTIGV2ZW50 TG9nIGlzICJtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBjbGljaygxKSBtb3VzZWRvd24oMSkgbW91 c2V1cCgxKSBjbGljaygxKSBkYmxjbGljaygxKSAiCitQQVNTIGV2ZW50TG9nIGlzICJtb3VzZWRv d24oMSkgbW91c2V1cCgxKSBtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBkYmxjbGljaygxKSAiCiBS aWdodCBNb3VzZSBCdXR0b24KIFBBU1MgZXZlbnRMb2cgaXMgIm1vdXNlZG93bigyKSBtb3VzZXVw KDIpIG1vdXNlZG93bigyKSBtb3VzZXVwKDIpICIKIDR0aCBNb3VzZSBCdXR0b24KLVBBU1MgZXZl bnRMb2cgaXMgIm1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGNsaWNrKDEpIG1vdXNlZG93bigxKSBt b3VzZXVwKDEpIGNsaWNrKDEpIGRibGNsaWNrKDEpICIKK1BBU1MgZXZlbnRMb2cgaXMgIm1vdXNl ZG93bigxKSBtb3VzZXVwKDEpIG1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGRibGNsaWNrKDEpICIK IFBBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKIAogVEVTVCBDT01QTEVURQpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2NyaXB0LXRlc3RzL21vdXNlLWNsaWNrLWV2 ZW50cy5qcyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3NjcmlwdC10ZXN0cy9tb3VzZS1jbGlj ay1ldmVudHMuanMKaW5kZXggNzJhMzQxYjdlZDkyMzUyNWU3NjBiMzQyMjBlODY4YTY0OTVlM2Vk Zi4uYjVmNDJiYmZjOTc2OGU1YTE2M2NkNDkwOGI5OTk3ZGIyOGVmYmY1ZCAxMDA2NDQKLS0tIGEv TGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2NyaXB0LXRlc3RzL21vdXNlLWNsaWNrLWV2ZW50cy5q cworKysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JpcHQtdGVzdHMvbW91c2UtY2xpY2st ZXZlbnRzLmpzCkBAIC00OSw5ICs0OSw5IEBAIGZ1bmN0aW9uIHRlc3RFdmVudHMoZGVzY3JpcHRp b24sIGJ1dHRvbiwgZXhwZWN0ZWRTdHJpbmcpIHsKIAogaWYgKHdpbmRvdy5ldmVudFNlbmRlcikg ewogICAgIHRlc3RFdmVudHMoIkxlZnQgTW91c2UgQnV0dG9uIiwgMCwgIm1vdXNlZG93bigwKSBt b3VzZXVwKDApIGNsaWNrKDApIG1vdXNlZG93bigwKSBtb3VzZXVwKDApIGNsaWNrKDApIGRibGNs aWNrKDApICIpOwotICAgIHRlc3RFdmVudHMoIk1pZGRsZSBNb3VzZSBCdXR0b24iLCAxLCAibW91 c2Vkb3duKDEpIG1vdXNldXAoMSkgY2xpY2soMSkgbW91c2Vkb3duKDEpIG1vdXNldXAoMSkgY2xp Y2soMSkgZGJsY2xpY2soMSkgIik7CisgICAgdGVzdEV2ZW50cygiTWlkZGxlIE1vdXNlIEJ1dHRv biIsIDEsICJtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBk YmxjbGljaygxKSAiKTsKICAgICB0ZXN0RXZlbnRzKCJSaWdodCBNb3VzZSBCdXR0b24iLCAyLCAi bW91c2Vkb3duKDIpIG1vdXNldXAoMikgbW91c2Vkb3duKDIpIG1vdXNldXAoMikgIik7Ci0gICAg dGVzdEV2ZW50cygiNHRoIE1vdXNlIEJ1dHRvbiIsIDMsICJtb3VzZWRvd24oMSkgbW91c2V1cCgx KSBjbGljaygxKSBtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBjbGljaygxKSBkYmxjbGljaygxKSAi KTsKKyAgICB0ZXN0RXZlbnRzKCI0dGggTW91c2UgQnV0dG9uIiwgMywgIm1vdXNlZG93bigxKSBt b3VzZXVwKDEpIG1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGRibGNsaWNrKDEpICIpOwogfQogCiB2 YXIgc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdl TG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmNiZWUxZWRjMmEyYmIwZTUzZjdlZTQ0MDdi NmM2ZTRiMjE5Zjc0NC4uMDgwZmNkYmQyNGNhNTg2YzUwZWViNGQ1ZTA5MTNhNDMxZTE0MGFkNyAx MDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAg LTEsMyArMSwzMiBAQAorMjAxMC0wNS0xMiAgQWRhbSBCYXJ0aCAgPGFiYXJ0aEB3ZWJraXQub3Jn PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE1pZGRs ZSBjbGljayBmaXJlcyBvbmNsaWNrIGV2ZW50CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yMjM4MgorCisgICAgICAgIEJsb2NrIG1pZGRsZSBjbGlja3Mg ZnJvbSBmaXJpbmcgdGhlIGNsaWNrIGV2ZW50LCBtYXRjaGluZyBGaXJlZm94LgorICAgICAgICBG aXJpbmcgdGhlc2UgZXZlbnRzIGlzIGEgYmFkIHVzZXIgZXhwZXJpZW5jZSBvbiBhIG51bWJlciBv ZiBzaXRlcyB0aGF0CisgICAgICAgIGFzc3VtZSB0aGUgY2xpY2sgZXZlbnQgaXMgZmlyZWQgb25s eSBmb3IgbGVmdCBjbGljay4KKworICAgICAgICBXZSBhbHJlYWR5IGJsb2NrIHJpZ2h0IGNsaWNr LCBidXQgd2UgYmxvY2sgaXQgYXQgdGhlIEV2ZW50SGFuZGxlcgorICAgICAgICBsYXllci4gIFRo YXQncyBub3Qgc3VmZmljaWVudCBmb3IgbWlkZGxlIGNsaWNrIGJlY2F1c2Ugd2Ugd2FudCB0bwor ICAgICAgICB0cmlnZ2VyIHRoZSBkZWZhdWx0IGV2ZW50IGhhbmRsZXIsIHdoaWNoIHdpbGwgdXN1 YWxseSBjcmVhdGUgYSBuZXcgdGFiLgorCisgICAgICAgIEkgd2FudGVkIHRvIG1vdmUgdGhlIGVu dGlyZSBjaGVjayBkb3duIGEgbGF5ZXIsIGJ1dCBkb2luZyBzbyBicm9rZSBhCisgICAgICAgIGJ1 bmNoIG9mIHRlc3RzIGZvciByZWFzb25zIEkgZG9uJ3QgZnVsbHkgdW5kZXJzdGFuZC4gIEkndmUg YWRkZWQgYQorICAgICAgICBGSVhNRSB0byB1bmlmeSB0aGVzZSBjaGVja3MgYXQgc29tZSBwb2lu dC4KKworICAgICAgICAqIGRvbS9Ob2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok5vZGU6OmRp c3BhdGNoRXZlbnRUb0RlZmF1bHRFdmVudEhhbmRsZXIpOgorICAgICAgICAoV2ViQ29yZTo6Tm9k ZTo6ZGlzcGF0Y2hHZW5lcmljRXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6Tm9kZTo6Y2FsbERl ZmF1bHRFdmVudEhhbmRsZXIpOgorICAgICAgICAoV2ViQ29yZTo6Tm9kZTo6ZGlzcGF0Y2hNb3Vz ZUV2ZW50KToKKyAgICAgICAgKiBkb20vTm9kZS5oOgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5k bGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VEb3Vi bGVDbGlja0V2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91 c2VSZWxlYXNlRXZlbnQpOgorCiAyMDEwLTA1LTEyICBEYXZpZCBIeWF0dCAgPGh5YXR0QGFwcGxl LmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBTYW0gV2VpbmlnLgpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9kb20vTm9kZS5jcHAgYi9XZWJDb3JlL2RvbS9Ob2RlLmNwcAppbmRleCBjODk5MTRmZThj ZmNjMGI0YTlhMDViOTNkZWE5Y2NiYTE3YTJkNzUxLi5jMjM0ZGQxZTk5OTEzZmJlNWI0NTY2NWU0 ZjFlZWJiOTcwMmI2NDA1IDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9Ob2RlLmNwcAorKysgYi9X ZWJDb3JlL2RvbS9Ob2RlLmNwcApAQCAtMjU2Nyw2ICsyNTY3LDIxIEBAIGJvb2wgTm9kZTo6ZGlz cGF0Y2hFdmVudChQYXNzUmVmUHRyPEV2ZW50PiBwcnBFdmVudCkKICAgICByZXR1cm4gZGlzcGF0 Y2hHZW5lcmljRXZlbnQoZXZlbnQucmVsZWFzZSgpKTsKIH0KIAorYm9vbCBOb2RlOjpkaXNwYXRj aEV2ZW50VG9EZWZhdWx0RXZlbnRIYW5kbGVyKFBhc3NSZWZQdHI8RXZlbnQ+IHBycEV2ZW50KQor eworICAgIFJlZlB0cjxFdmVudFRhcmdldD4gcHJvdGVjdCA9IHRoaXM7CisgICAgUmVmUHRyPEV2 ZW50PiBldmVudCA9IHBycEV2ZW50OworCisgICAgZXZlbnQtPnNldFRhcmdldChldmVudFRhcmdl dFJlc3BlY3RpbmdTVkdUYXJnZXRSdWxlcyh0aGlzKSk7CisKKyAgICBSZWZQdHI8RnJhbWVWaWV3 PiB2aWV3ID0gZG9jdW1lbnQoKS0+dmlldygpOworCisgICAgVmVjdG9yPFJlZlB0cjxDb250YWlu ZXJOb2RlPiA+IGFuY2VzdG9yczsKKyAgICBldmVudEFuY2VzdG9ycyhhbmNlc3RvcnMpOworICAg IGNhbGxEZWZhdWx0RXZlbnRIYW5kbGVyKGV2ZW50LmdldCgpLCBhbmNlc3RvcnMpOworICAgIHJl dHVybiAhZXZlbnQtPmRlZmF1bHRQcmV2ZW50ZWQoKTsKK30KKwogc3RhdGljIGJvb2wgZXZlbnRI YXNMaXN0ZW5lcnMoY29uc3QgQXRvbWljU3RyaW5nJiBldmVudFR5cGUsIERPTVdpbmRvdyogd2lu ZG93LCBOb2RlKiBub2RlLCBWZWN0b3I8UmVmUHRyPENvbnRhaW5lck5vZGU+ID4mIGFuY2VzdG9y cykKIHsKICAgICBpZiAod2luZG93ICYmIHdpbmRvdy0+aGFzRXZlbnRMaXN0ZW5lcnMoZXZlbnRU eXBlKSkKQEAgLTI2NzgsMjcgKzI2OTMsOSBAQCBkb25lRGlzcGF0Y2hpbmc6CiAgICAgLy8gQ2Fs bCBkZWZhdWx0IGV2ZW50IGhhbmRsZXJzLiBXaGlsZSB0aGUgRE9NIGRvZXMgaGF2ZSBhIGNvbmNl cHQgb2YgcHJldmVudGluZwogICAgIC8vIGRlZmF1bHQgaGFuZGxpbmcsIHRoZSBkZXRhaWwgb2Yg d2hpY2ggaGFuZGxlcnMgYXJlIGNhbGxlZCBpcyBhbiBpbnRlcm5hbAogICAgIC8vIGltcGxlbWVu dGF0aW9uIGRldGFpbCBhbmQgbm90IHBhcnQgb2YgdGhlIERPTS4KLSAgICBpZiAoIWV2ZW50LT5k ZWZhdWx0UHJldmVudGVkKCkgJiYgIWV2ZW50LT5kZWZhdWx0SGFuZGxlZCgpKSB7Ci0gICAgICAg IC8vIE5vbi1idWJibGluZyBldmVudHMgY2FsbCBvbmx5IG9uZSBkZWZhdWx0IGV2ZW50IGhhbmRs ZXIsIHRoZSBvbmUgZm9yIHRoZSB0YXJnZXQuCi0gICAgICAgIGRlZmF1bHRFdmVudEhhbmRsZXIo ZXZlbnQuZ2V0KCkpOwotICAgICAgICBBU1NFUlQoIWV2ZW50LT5kZWZhdWx0UHJldmVudGVkKCkp OwotICAgICAgICBpZiAoZXZlbnQtPmRlZmF1bHRIYW5kbGVkKCkpCi0gICAgICAgICAgICBnb3Rv IGRvbmVXaXRoRGVmYXVsdDsKLSAgICAgICAgLy8gRm9yIGJ1YmJsaW5nIGV2ZW50cywgY2FsbCBk ZWZhdWx0IGV2ZW50IGhhbmRsZXJzIG9uIHRoZSBzYW1lIHRhcmdldHMgaW4gdGhlCi0gICAgICAg IC8vIHNhbWUgb3JkZXIgYXMgdGhlIGJ1YmJsaW5nIHBoYXNlLgotICAgICAgICBpZiAoZXZlbnQt PmJ1YmJsZXMoKSkgewotICAgICAgICAgICAgc2l6ZV90IHNpemUgPSBhbmNlc3RvcnMuc2l6ZSgp OwotICAgICAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBzaXplOyArK2kpIHsKLSAgICAg ICAgICAgICAgICBDb250YWluZXJOb2RlKiBhbmNlc3RvciA9IGFuY2VzdG9yc1tpXS5nZXQoKTsK LSAgICAgICAgICAgICAgICBhbmNlc3Rvci0+ZGVmYXVsdEV2ZW50SGFuZGxlcihldmVudC5nZXQo KSk7Ci0gICAgICAgICAgICAgICAgQVNTRVJUKCFldmVudC0+ZGVmYXVsdFByZXZlbnRlZCgpKTsK LSAgICAgICAgICAgICAgICBpZiAoZXZlbnQtPmRlZmF1bHRIYW5kbGVkKCkpCi0gICAgICAgICAg ICAgICAgICAgIGdvdG8gZG9uZVdpdGhEZWZhdWx0OwotICAgICAgICAgICAgfQotICAgICAgICB9 Ci0gICAgfQorICAgIGlmICghZXZlbnQtPmRlZmF1bHRQcmV2ZW50ZWQoKSAmJiAhZXZlbnQtPmRl ZmF1bHRIYW5kbGVkKCkpCisgICAgICAgIGNhbGxEZWZhdWx0RXZlbnRIYW5kbGVyKGV2ZW50Lmdl dCgpLCBhbmNlc3RvcnMpOwogCi1kb25lV2l0aERlZmF1bHQ6CiAjaWYgRU5BQkxFKElOU1BFQ1RP UikKICAgICBpZiAoaW5zcGVjdGVkUGFnZSkKICAgICAgICAgaWYgKEluc3BlY3RvclRpbWVsaW5l QWdlbnQqIHRpbWVsaW5lQWdlbnQgPSBpbnNwZWN0ZWRQYWdlLT5pbnNwZWN0b3JUaW1lbGluZUFn ZW50KCkpCkBAIC0yNzA4LDYgKzI3MDUsMjcgQEAgZG9uZVdpdGhEZWZhdWx0OgogICAgIHJldHVy biAhZXZlbnQtPmRlZmF1bHRQcmV2ZW50ZWQoKTsKIH0KIAordm9pZCBOb2RlOjpjYWxsRGVmYXVs dEV2ZW50SGFuZGxlcihFdmVudCogZXZlbnQsIGNvbnN0IFZlY3RvcjxSZWZQdHI8Q29udGFpbmVy Tm9kZT4gPiYgYW5jZXN0b3JzKQoreworICAgIC8vIE5vbi1idWJibGluZyBldmVudHMgY2FsbCBv bmx5IG9uZSBkZWZhdWx0IGV2ZW50IGhhbmRsZXIsIHRoZSBvbmUgZm9yIHRoZSB0YXJnZXQuCisg ICAgZGVmYXVsdEV2ZW50SGFuZGxlcihldmVudCk7CisgICAgQVNTRVJUKCFldmVudC0+ZGVmYXVs dFByZXZlbnRlZCgpKTsKKyAgICBpZiAoZXZlbnQtPmRlZmF1bHRIYW5kbGVkKCkpCisgICAgICAg IHJldHVybjsKKyAgICAvLyBGb3IgYnViYmxpbmcgZXZlbnRzLCBjYWxsIGRlZmF1bHQgZXZlbnQg aGFuZGxlcnMgb24gdGhlIHNhbWUgdGFyZ2V0cyBpbiB0aGUKKyAgICAvLyBzYW1lIG9yZGVyIGFz IHRoZSBidWJibGluZyBwaGFzZS4KKyAgICBpZiAoZXZlbnQtPmJ1YmJsZXMoKSkgeworICAgICAg ICBzaXplX3Qgc2l6ZSA9IGFuY2VzdG9ycy5zaXplKCk7CisgICAgICAgIGZvciAoc2l6ZV90IGkg PSAwOyBpIDwgc2l6ZTsgKytpKSB7CisgICAgICAgICAgICBDb250YWluZXJOb2RlKiBhbmNlc3Rv ciA9IGFuY2VzdG9yc1tpXS5nZXQoKTsKKyAgICAgICAgICAgIGFuY2VzdG9yLT5kZWZhdWx0RXZl bnRIYW5kbGVyKGV2ZW50KTsKKyAgICAgICAgICAgIEFTU0VSVCghZXZlbnQtPmRlZmF1bHRQcmV2 ZW50ZWQoKSk7CisgICAgICAgICAgICBpZiAoZXZlbnQtPmRlZmF1bHRIYW5kbGVkKCkpCisgICAg ICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQorfQorCiB2b2lkIE5vZGU6OmRp c3BhdGNoU3VidHJlZU1vZGlmaWVkRXZlbnQoKQogewogICAgIEFTU0VSVCghZXZlbnREaXNwYXRj aEZvcmJpZGRlbigpKTsKQEAgLTI4NTUsMTMgKzI4NzMsMTkgQEAgYm9vbCBOb2RlOjpkaXNwYXRj aE1vdXNlRXZlbnQoY29uc3QgQXRvbWljU3RyaW5nJiBldmVudFR5cGUsIGludCBidXR0b24sIGlu dCBkZXQKICAgICAgICAgcmVsYXRlZFRhcmdldCwgMCwgaXNTaW11bGF0ZWQpOwogICAgIG1vdXNl RXZlbnQtPnNldFVuZGVybHlpbmdFdmVudCh1bmRlcmx5aW5nRXZlbnQuZ2V0KCkpOwogICAgIG1v dXNlRXZlbnQtPnNldEFic29sdXRlTG9jYXRpb24oSW50UG9pbnQocGFnZVgsIHBhZ2VZKSk7Ci0g ICAgCi0gICAgZGlzcGF0Y2hFdmVudChtb3VzZUV2ZW50KTsKKworICAgIC8vIEZvciBjbGlja3Mg YnkgdGhlIG5vbi1sZWZ0IG1vdXNlIGJ1dHRvbiwgR2Vja28gZG9lc24ndCBkaXNwYXRjaCB0aGUK KyAgICAvLyBldmVudCB0byB0aGUgRE9NLiAgSG93ZXZlciwgd2Ugc3RpbGwgd2FudCB0byBjYWxs IHRoZSBkZWZhdWx0IGV2ZW50CisgICAgLy8gaGFuZGxlciBzbyB0aGF0IHRoZSB3ZSBjYW4gb3Bl biBsaW5rcyBpbiBuZXcgdGFicywgZXRjLgorICAgIGlmIChldmVudFR5cGUgPT0gZXZlbnROYW1l cygpLmNsaWNrRXZlbnQgJiYgYnV0dG9uICE9IExlZnRCdXR0b24pCisgICAgICAgIGRpc3BhdGNo RXZlbnRUb0RlZmF1bHRFdmVudEhhbmRsZXIobW91c2VFdmVudCk7CisgICAgZWxzZQorICAgICAg ICBkaXNwYXRjaEV2ZW50KG1vdXNlRXZlbnQpOwogICAgIGJvb2wgZGVmYXVsdEhhbmRsZWQgPSBt b3VzZUV2ZW50LT5kZWZhdWx0SGFuZGxlZCgpOwogICAgIGJvb2wgZGVmYXVsdFByZXZlbnRlZCA9 IG1vdXNlRXZlbnQtPmRlZmF1bHRQcmV2ZW50ZWQoKTsKICAgICBpZiAoZGVmYXVsdEhhbmRsZWQg fHwgZGVmYXVsdFByZXZlbnRlZCkKICAgICAgICAgc3dhbGxvd0V2ZW50ID0gdHJ1ZTsKLSAgICAK KwogICAgIC8vIFNwZWNpYWwgY2FzZTogSWYgaXQncyBhIGRvdWJsZSBjbGljayBldmVudCwgd2Ug YWxzbyBzZW5kIHRoZSBkYmxjbGljayBldmVudC4gVGhpcyBpcyBub3QgcGFydAogICAgIC8vIG9m IHRoZSBET00gc3BlY3MsIGJ1dCBpcyB1c2VkIGZvciBjb21wYXRpYmlsaXR5IHdpdGggdGhlIG9u ZGJsY2xpY2s9IiIgYXR0cmlidXRlLiAgVGhpcyBpcyB0cmVhdGVkCiAgICAgLy8gYXMgYSBzZXBh cmF0ZSBldmVudCBpbiBvdGhlciBET00tY29tcGxpYW50IGJyb3dzZXJzIGxpa2UgRmlyZWZveCwg YW5kIHNvIHdlIGRvIHRoZSBzYW1lLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vTm9kZS5oIGIv V2ViQ29yZS9kb20vTm9kZS5oCmluZGV4IGQ2YmE4ZDZlMmU3ZmEyMTM0NDExMmVjMGY5YjhmYjcx YWI2ZjJjNGQuLjFiZTNhYTU3NjBkNWI2ZDA0NjY1YzdhNzkyMzg2MTA5ZTU3M2U3NTIgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvZG9tL05vZGUuaAorKysgYi9XZWJDb3JlL2RvbS9Ob2RlLmgKQEAgLTY5 OSw2ICs2OTksOSBAQCBwcml2YXRlOgogICAgIE5vZGUqIGNvbnRhaW5lckxhc3RDaGlsZCgpIGNv bnN0OwogICAgIGJvb2wgcmFyZURhdGFGb2N1c2VkKCkgY29uc3Q7CiAKKyAgICBib29sIGRpc3Bh dGNoRXZlbnRUb0RlZmF1bHRFdmVudEhhbmRsZXIoUGFzc1JlZlB0cjxFdmVudD4gZXZlbnQpOwor ICAgIHZvaWQgY2FsbERlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2ZW50LCBjb25zdCBWZWN0 b3I8UmVmUHRyPENvbnRhaW5lck5vZGU+ID4mIGFuY2VzdG9ycyk7CisKICAgICB2aXJ0dWFsIFJl bmRlclN0eWxlKiBub25SZW5kZXJlclJlbmRlclN0eWxlKCkgY29uc3Q7CiAKICAgICB2aXJ0dWFs IGNvbnN0IEF0b21pY1N0cmluZyYgdmlydHVhbFByZWZpeCgpIGNvbnN0OwpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAgYi9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVy LmNwcAppbmRleCA5MDVlNjIyMWJlMGYyM2FhMGQyMDZmZWFmYjViNDY5MjUxMWM0ZDEwLi4zMTRi ZGQ1OTdmYWI3Yjc4YTk0NDJjNjY5NDg0N2M0ZjhkNjE3MTU1IDEwMDY0NAotLS0gYS9XZWJDb3Jl L3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNw cApAQCAtMTM2Miw3ICsxMzYyLDEwIEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZURv dWJsZUNsaWNrRXZlbnQoY29uc3QgUGxhdGZvcm1Nb3VzZUV2ZW50JiBtb3VzZUV2CiAgICAgYm9v bCBzd2FsbG93TW91c2VVcEV2ZW50ID0gZGlzcGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5t b3VzZXVwRXZlbnQsIG1ldi50YXJnZXROb2RlKCksIHRydWUsIG1fY2xpY2tDb3VudCwgbW91c2VF dmVudCwgZmFsc2UpOwogCiAgICAgYm9vbCBzd2FsbG93Q2xpY2tFdmVudCA9IGZhbHNlOwotICAg IC8vIERvbid0IGV2ZXIgZGlzcGF0Y2ggY2xpY2sgZXZlbnRzIGZvciByaWdodCBjbGlja3MKKyAg ICAvLyBEb24ndCBldmVyIGRpc3BhdGNoIGNsaWNrIGV2ZW50cyBmb3IgcmlnaHQgY2xpY2tzLgor ICAgIC8vIEZJWE1FOiBJbiBwcmluY2lwbGUsIHdlIHNob3VsZCBiZSBhYmxlIHRvIHJlbW92ZSB0 aGlzIGNoZWNrIG5vdyB0aGF0IHdlCisgICAgLy8gICAgICAgIHNwZWNpYWwgY2FzZSB0aGUgZGlz cGF0Y2hpbmcgb2YgY2xpY2sgZXZlbnRzIGluIE5vZGUuY3BwLCBidXQKKyAgICAvLyAgICAgICAg cmVtb3ZlIGJyZWFrcyBzb21lIHRlc3RzLgogICAgIGlmIChtb3VzZUV2ZW50LmJ1dHRvbigpICE9 IFJpZ2h0QnV0dG9uICYmIG1ldi50YXJnZXROb2RlKCkgPT0gbV9jbGlja05vZGUpCiAgICAgICAg IHN3YWxsb3dDbGlja0V2ZW50ID0gZGlzcGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5jbGlj a0V2ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNrQ291bnQsIG1vdXNlRXZlbnQs IHRydWUpOwogCkBAIC0xNTUxLDcgKzE1NTQsMTAgQEAgYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRs ZU1vdXNlUmVsZWFzZUV2ZW50KGNvbnN0IFBsYXRmb3JtTW91c2VFdmVudCYgbW91c2VFdmVudCkK IAogICAgIGJvb2wgc3dhbGxvd01vdXNlVXBFdmVudCA9IGRpc3BhdGNoTW91c2VFdmVudChldmVu dE5hbWVzKCkubW91c2V1cEV2ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNrQ291 bnQsIG1vdXNlRXZlbnQsIGZhbHNlKTsKIAotICAgIC8vIERvbid0IGV2ZXIgZGlzcGF0Y2ggY2xp Y2sgZXZlbnRzIGZvciByaWdodCBjbGlja3MKKyAgICAvLyBEb24ndCBldmVyIGRpc3BhdGNoIGNs aWNrIGV2ZW50cyBmb3IgcmlnaHQgY2xpY2tzLgorICAgIC8vIEZJWE1FOiBJbiBwcmluY2lwbGUs IHdlIHNob3VsZCBiZSBhYmxlIHRvIHJlbW92ZSB0aGlzIGNoZWNrIG5vdyB0aGF0IHdlCisgICAg Ly8gICAgICAgIHNwZWNpYWwgY2FzZSB0aGUgZGlzcGF0Y2hpbmcgb2YgY2xpY2sgZXZlbnRzIGlu IE5vZGUuY3BwLCBidXQKKyAgICAvLyAgICAgICAgcmVtb3ZlIGJyZWFrcyBzb21lIHRlc3RzLgog ICAgIGJvb2wgc3dhbGxvd0NsaWNrRXZlbnQgPSBmYWxzZTsKICAgICBpZiAobV9jbGlja0NvdW50 ID4gMCAmJiBtb3VzZUV2ZW50LmJ1dHRvbigpICE9IFJpZ2h0QnV0dG9uICYmIG1ldi50YXJnZXRO b2RlKCkgPT0gbV9jbGlja05vZGUpCiAgICAgICAgIHN3YWxsb3dDbGlja0V2ZW50ID0gZGlzcGF0 Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0 cnVlLCBtX2NsaWNrQ291bnQsIG1vdXNlRXZlbnQsIHRydWUpOwo= 57911 2010-06-04 13:48:47 -0700 2010-09-07 09:33:02 -0700 Patch with middle dblclick blocking + shared code with right click event blocking patch.txt text/plain 10672 japhet SW5kZXg6IFdlYkNvcmUvZG9tL05vZGUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9Ob2Rl LmgJKHJldmlzaW9uIDYwNjg3KQorKysgV2ViQ29yZS9kb20vTm9kZS5oCSh3b3JraW5nIGNvcHkp CkBAIC03MDEsNiArNzAxLDkgQEAKICAgICBOb2RlKiBjb250YWluZXJMYXN0Q2hpbGQoKSBjb25z dDsKICAgICBib29sIHJhcmVEYXRhRm9jdXNlZCgpIGNvbnN0OwogCisgICAgYm9vbCBkaXNwYXRj aEV2ZW50VG9EZWZhdWx0RXZlbnRIYW5kbGVyKFBhc3NSZWZQdHI8RXZlbnQ+IGV2ZW50KTsKKyAg ICB2b2lkIGNhbGxEZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldmVudCwgY29uc3QgVmVjdG9y PFJlZlB0cjxDb250YWluZXJOb2RlPiA+JiBhbmNlc3RvcnMpOworCiAgICAgdmlydHVhbCBSZW5k ZXJTdHlsZSogbm9uUmVuZGVyZXJSZW5kZXJTdHlsZSgpIGNvbnN0OwogCiAgICAgdmlydHVhbCBj b25zdCBBdG9taWNTdHJpbmcmIHZpcnR1YWxQcmVmaXgoKSBjb25zdDsKSW5kZXg6IFdlYkNvcmUv ZG9tL05vZGUuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZG9tL05vZGUuY3BwCShyZXZpc2lv biA2MDY4NykKKysrIFdlYkNvcmUvZG9tL05vZGUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yNTk4 LDYgKzI1OTgsMjEgQEAKICAgICByZXR1cm4gZGlzcGF0Y2hHZW5lcmljRXZlbnQoZXZlbnQucmVs ZWFzZSgpKTsKIH0KIAorYm9vbCBOb2RlOjpkaXNwYXRjaEV2ZW50VG9EZWZhdWx0RXZlbnRIYW5k bGVyKFBhc3NSZWZQdHI8RXZlbnQ+IHBycEV2ZW50KQoreworICAgIFJlZlB0cjxFdmVudFRhcmdl dD4gcHJvdGVjdCA9IHRoaXM7CisgICAgUmVmUHRyPEV2ZW50PiBldmVudCA9IHBycEV2ZW50Owor CisgICAgZXZlbnQtPnNldFRhcmdldChldmVudFRhcmdldFJlc3BlY3RpbmdTVkdUYXJnZXRSdWxl cyh0aGlzKSk7CisKKyAgICBSZWZQdHI8RnJhbWVWaWV3PiB2aWV3ID0gZG9jdW1lbnQoKS0+dmll dygpOworCisgICAgVmVjdG9yPFJlZlB0cjxDb250YWluZXJOb2RlPiA+IGFuY2VzdG9yczsKKyAg ICBldmVudEFuY2VzdG9ycyhhbmNlc3RvcnMpOworICAgIGNhbGxEZWZhdWx0RXZlbnRIYW5kbGVy KGV2ZW50LmdldCgpLCBhbmNlc3RvcnMpOworICAgIHJldHVybiAhZXZlbnQtPmRlZmF1bHRQcmV2 ZW50ZWQoKTsKK30KKwogc3RhdGljIGJvb2wgZXZlbnRIYXNMaXN0ZW5lcnMoY29uc3QgQXRvbWlj U3RyaW5nJiBldmVudFR5cGUsIERPTVdpbmRvdyogd2luZG93LCBOb2RlKiBub2RlLCBWZWN0b3I8 UmVmUHRyPENvbnRhaW5lck5vZGU+ID4mIGFuY2VzdG9ycykKIHsKICAgICBpZiAod2luZG93ICYm IHdpbmRvdy0+aGFzRXZlbnRMaXN0ZW5lcnMoZXZlbnRUeXBlKSkKQEAgLTI3MDksMjcgKzI3MjQs OSBAQAogICAgIC8vIENhbGwgZGVmYXVsdCBldmVudCBoYW5kbGVycy4gV2hpbGUgdGhlIERPTSBk b2VzIGhhdmUgYSBjb25jZXB0IG9mIHByZXZlbnRpbmcKICAgICAvLyBkZWZhdWx0IGhhbmRsaW5n LCB0aGUgZGV0YWlsIG9mIHdoaWNoIGhhbmRsZXJzIGFyZSBjYWxsZWQgaXMgYW4gaW50ZXJuYWwK ICAgICAvLyBpbXBsZW1lbnRhdGlvbiBkZXRhaWwgYW5kIG5vdCBwYXJ0IG9mIHRoZSBET00uCi0g ICAgaWYgKCFldmVudC0+ZGVmYXVsdFByZXZlbnRlZCgpICYmICFldmVudC0+ZGVmYXVsdEhhbmRs ZWQoKSkgewotICAgICAgICAvLyBOb24tYnViYmxpbmcgZXZlbnRzIGNhbGwgb25seSBvbmUgZGVm YXVsdCBldmVudCBoYW5kbGVyLCB0aGUgb25lIGZvciB0aGUgdGFyZ2V0LgotICAgICAgICBkZWZh dWx0RXZlbnRIYW5kbGVyKGV2ZW50LmdldCgpKTsKLSAgICAgICAgQVNTRVJUKCFldmVudC0+ZGVm YXVsdFByZXZlbnRlZCgpKTsKLSAgICAgICAgaWYgKGV2ZW50LT5kZWZhdWx0SGFuZGxlZCgpKQot ICAgICAgICAgICAgZ290byBkb25lV2l0aERlZmF1bHQ7Ci0gICAgICAgIC8vIEZvciBidWJibGlu ZyBldmVudHMsIGNhbGwgZGVmYXVsdCBldmVudCBoYW5kbGVycyBvbiB0aGUgc2FtZSB0YXJnZXRz IGluIHRoZQotICAgICAgICAvLyBzYW1lIG9yZGVyIGFzIHRoZSBidWJibGluZyBwaGFzZS4KLSAg ICAgICAgaWYgKGV2ZW50LT5idWJibGVzKCkpIHsKLSAgICAgICAgICAgIHNpemVfdCBzaXplID0g YW5jZXN0b3JzLnNpemUoKTsKLSAgICAgICAgICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgc2l6 ZTsgKytpKSB7Ci0gICAgICAgICAgICAgICAgQ29udGFpbmVyTm9kZSogYW5jZXN0b3IgPSBhbmNl c3RvcnNbaV0uZ2V0KCk7Ci0gICAgICAgICAgICAgICAgYW5jZXN0b3ItPmRlZmF1bHRFdmVudEhh bmRsZXIoZXZlbnQuZ2V0KCkpOwotICAgICAgICAgICAgICAgIEFTU0VSVCghZXZlbnQtPmRlZmF1 bHRQcmV2ZW50ZWQoKSk7Ci0gICAgICAgICAgICAgICAgaWYgKGV2ZW50LT5kZWZhdWx0SGFuZGxl ZCgpKQotICAgICAgICAgICAgICAgICAgICBnb3RvIGRvbmVXaXRoRGVmYXVsdDsKLSAgICAgICAg ICAgIH0KLSAgICAgICAgfQotICAgIH0KKyAgICBpZiAoIWV2ZW50LT5kZWZhdWx0UHJldmVudGVk KCkgJiYgIWV2ZW50LT5kZWZhdWx0SGFuZGxlZCgpKQorICAgICAgICBjYWxsRGVmYXVsdEV2ZW50 SGFuZGxlcihldmVudC5nZXQoKSwgYW5jZXN0b3JzKTsKIAotZG9uZVdpdGhEZWZhdWx0OgogI2lm IEVOQUJMRShJTlNQRUNUT1IpCiAgICAgaWYgKGluc3BlY3RlZFBhZ2UpCiAgICAgICAgIGlmIChJ bnNwZWN0b3JUaW1lbGluZUFnZW50KiB0aW1lbGluZUFnZW50ID0gaW5zcGVjdGVkUGFnZS0+aW5z cGVjdG9yVGltZWxpbmVBZ2VudCgpKQpAQCAtMjczOSw2ICsyNzM2LDI3IEBACiAgICAgcmV0dXJu ICFldmVudC0+ZGVmYXVsdFByZXZlbnRlZCgpOwogfQogCit2b2lkIE5vZGU6OmNhbGxEZWZhdWx0 RXZlbnRIYW5kbGVyKEV2ZW50KiBldmVudCwgY29uc3QgVmVjdG9yPFJlZlB0cjxDb250YWluZXJO b2RlPiA+JiBhbmNlc3RvcnMpCit7CisgICAgLy8gTm9uLWJ1YmJsaW5nIGV2ZW50cyBjYWxsIG9u bHkgb25lIGRlZmF1bHQgZXZlbnQgaGFuZGxlciwgdGhlIG9uZSBmb3IgdGhlIHRhcmdldC4KKyAg ICBkZWZhdWx0RXZlbnRIYW5kbGVyKGV2ZW50KTsKKyAgICBBU1NFUlQoIWV2ZW50LT5kZWZhdWx0 UHJldmVudGVkKCkpOworICAgIGlmIChldmVudC0+ZGVmYXVsdEhhbmRsZWQoKSkKKyAgICAgICAg cmV0dXJuOworICAgIC8vIEZvciBidWJibGluZyBldmVudHMsIGNhbGwgZGVmYXVsdCBldmVudCBo YW5kbGVycyBvbiB0aGUgc2FtZSB0YXJnZXRzIGluIHRoZQorICAgIC8vIHNhbWUgb3JkZXIgYXMg dGhlIGJ1YmJsaW5nIHBoYXNlLgorICAgIGlmIChldmVudC0+YnViYmxlcygpKSB7CisgICAgICAg IHNpemVfdCBzaXplID0gYW5jZXN0b3JzLnNpemUoKTsKKyAgICAgICAgZm9yIChzaXplX3QgaSA9 IDA7IGkgPCBzaXplOyArK2kpIHsKKyAgICAgICAgICAgIENvbnRhaW5lck5vZGUqIGFuY2VzdG9y ID0gYW5jZXN0b3JzW2ldLmdldCgpOworICAgICAgICAgICAgYW5jZXN0b3ItPmRlZmF1bHRFdmVu dEhhbmRsZXIoZXZlbnQpOworICAgICAgICAgICAgQVNTRVJUKCFldmVudC0+ZGVmYXVsdFByZXZl bnRlZCgpKTsKKyAgICAgICAgICAgIGlmIChldmVudC0+ZGVmYXVsdEhhbmRsZWQoKSkKKyAgICAg ICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9Cit9CisKIHZvaWQgTm9kZTo6ZGlz cGF0Y2hTdWJ0cmVlTW9kaWZpZWRFdmVudCgpCiB7CiAgICAgQVNTRVJUKCFldmVudERpc3BhdGNo Rm9yYmlkZGVuKCkpOwpAQCAtMjg4NiwxNyArMjkwNCwyMyBAQAogICAgICAgICByZWxhdGVkVGFy Z2V0LCAwLCBpc1NpbXVsYXRlZCk7CiAgICAgbW91c2VFdmVudC0+c2V0VW5kZXJseWluZ0V2ZW50 KHVuZGVybHlpbmdFdmVudC5nZXQoKSk7CiAgICAgbW91c2VFdmVudC0+c2V0QWJzb2x1dGVMb2Nh dGlvbihJbnRQb2ludChwYWdlWCwgcGFnZVkpKTsKLSAgICAKLSAgICBkaXNwYXRjaEV2ZW50KG1v dXNlRXZlbnQpOworCisgICAgLy8gRm9yIGNsaWNrcyBieSB0aGUgbm9uLWxlZnQgbW91c2UgYnV0 dG9uLCBHZWNrbyBkb2Vzbid0IGRpc3BhdGNoIHRoZQorICAgIC8vIGV2ZW50IHRvIHRoZSBET00u ICBIb3dldmVyLCB3ZSBzdGlsbCB3YW50IHRvIGNhbGwgdGhlIGRlZmF1bHQgZXZlbnQKKyAgICAv LyBoYW5kbGVyIHNvIHRoYXQgdGhlIHdlIGNhbiBvcGVuIGxpbmtzIGluIG5ldyB0YWJzLCBldGMu CisgICAgaWYgKGV2ZW50VHlwZSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCAmJiBidXR0b24g IT0gTGVmdEJ1dHRvbikKKyAgICAgICAgZGlzcGF0Y2hFdmVudFRvRGVmYXVsdEV2ZW50SGFuZGxl cihtb3VzZUV2ZW50KTsKKyAgICBlbHNlCisgICAgICAgIGRpc3BhdGNoRXZlbnQobW91c2VFdmVu dCk7CiAgICAgYm9vbCBkZWZhdWx0SGFuZGxlZCA9IG1vdXNlRXZlbnQtPmRlZmF1bHRIYW5kbGVk KCk7CiAgICAgYm9vbCBkZWZhdWx0UHJldmVudGVkID0gbW91c2VFdmVudC0+ZGVmYXVsdFByZXZl bnRlZCgpOwogICAgIGlmIChkZWZhdWx0SGFuZGxlZCB8fCBkZWZhdWx0UHJldmVudGVkKQogICAg ICAgICBzd2FsbG93RXZlbnQgPSB0cnVlOwotICAgIAotICAgIC8vIFNwZWNpYWwgY2FzZTogSWYg aXQncyBhIGRvdWJsZSBjbGljayBldmVudCwgd2UgYWxzbyBzZW5kIHRoZSBkYmxjbGljayBldmVu dC4gVGhpcyBpcyBub3QgcGFydAorCisgICAgLy8gU3BlY2lhbCBjYXNlOiBJZiBpdCdzIGEgbGVm dCBidXR0b24gZG91YmxlIGNsaWNrIGV2ZW50LCB3ZSBhbHNvIHNlbmQgdGhlIGRibGNsaWNrIGV2 ZW50LiBUaGlzIGlzIG5vdCBwYXJ0CiAgICAgLy8gb2YgdGhlIERPTSBzcGVjcywgYnV0IGlzIHVz ZWQgZm9yIGNvbXBhdGliaWxpdHkgd2l0aCB0aGUgb25kYmxjbGljaz0iIiBhdHRyaWJ1dGUuICBU aGlzIGlzIHRyZWF0ZWQKICAgICAvLyBhcyBhIHNlcGFyYXRlIGV2ZW50IGluIG90aGVyIERPTS1j b21wbGlhbnQgYnJvd3NlcnMgbGlrZSBGaXJlZm94LCBhbmQgc28gd2UgZG8gdGhlIHNhbWUuCi0g ICAgaWYgKGV2ZW50VHlwZSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCAmJiBkZXRhaWwgPT0g MikgeworICAgIGlmIChldmVudFR5cGUgPT0gZXZlbnROYW1lcygpLmNsaWNrRXZlbnQgJiYgYnV0 dG9uID09IExlZnRCdXR0b24gJiYgZGV0YWlsID09IDIpIHsKICAgICAgICAgUmVmUHRyPEV2ZW50 PiBkb3VibGVDbGlja0V2ZW50ID0gTW91c2VFdmVudDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5kYmxj bGlja0V2ZW50LAogICAgICAgICAgICAgdHJ1ZSwgY2FuY2VsYWJsZSwgZG9jdW1lbnQoKS0+ZGVm YXVsdFZpZXcoKSwKICAgICAgICAgICAgIGRldGFpbCwgc2NyZWVuWCwgc2NyZWVuWSwgYWRqdXN0 ZWRQYWdlWCwgYWRqdXN0ZWRQYWdlWSwKSW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9nCShyZXZpc2lvbiA2MDcwNCkKKysrIFdlYkNvcmUvQ2hh bmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjcgQEAKKzIwMTAtMDYtMDQgIE5hdGUg Q2hhcGluICA8amFwaGV0QGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBNaWRkbGUgY2xpY2sgZmlyZXMgb25jbGljayBldmVudAor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjIzODIKKwor ICAgICAgICBCbG9jayBtaWRkbGUgY2xpY2tzIGZyb20gZmlyaW5nIHRoZSBjbGljayBhbmQgZGJs Y2xpY2sgZXZlbnQsIG1hdGNoaW5nIEZpcmVmb3guCisgICAgICAgIEZpcmluZyB0aGVzZSBldmVu dHMgaXMgYSBiYWQgdXNlciBleHBlcmllbmNlIG9uIGEgbnVtYmVyIG9mIHNpdGVzIHRoYXQKKyAg ICAgICAgYXNzdW1lIHRoZSBjbGljayBldmVudCBpcyBmaXJlZCBvbmx5IGZvciBsZWZ0IGNsaWNr LgorCisgICAgICAgIEFsc28sIHJlbW92ZSB0aGUgY29kZSB0aGF0IGJsb2NrcyByaWdodCBjbGlj ayBldmVudHMgYXQgdGhlIEV2ZW50SGFuZGxlcgorICAgICAgICBsYXllciBhbmQgc2hhcmUgY29k ZSB3aXRoIGJsb2NraW5nIG1pZGRsZSBjbGljayBldmVudHMuCisKKyAgICAgICAgKiBkb20vTm9k ZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpOb2RlOjpkaXNwYXRjaEV2ZW50VG9EZWZhdWx0RXZl bnRIYW5kbGVyKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vZGU6OmRpc3BhdGNoR2VuZXJpY0V2ZW50 KToKKyAgICAgICAgKFdlYkNvcmU6Ok5vZGU6OmNhbGxEZWZhdWx0RXZlbnRIYW5kbGVyKToKKyAg ICAgICAgKFdlYkNvcmU6Ok5vZGU6OmRpc3BhdGNoTW91c2VFdmVudCk6CisgICAgICAgICogZG9t L05vZGUuaDoKKyAgICAgICAgKiBwYWdlL0V2ZW50SGFuZGxlci5jcHA6CisgICAgICAgIChXZWJD b3JlOjpFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNlRG91YmxlQ2xpY2tFdmVudCk6CisgICAgICAg IChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNlUmVsZWFzZUV2ZW50KToKKwogMjAx MC0wNi0wNCAgQWRhbSBCYXJ0aCAgPGFiYXJ0aEB3ZWJraXQub3JnPgogCiAgICAgICAgIFJldmll d2VkIGJ5IEVyaWMgU2VpZGVsLgpJbmRleDogV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAJKHJldmlzaW9uIDYw Njg3KQorKysgV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAJKHdvcmtpbmcgY29weSkKQEAg LTEzNjgsOCArMTM2OCw3IEBACiAgICAgYm9vbCBzd2FsbG93TW91c2VVcEV2ZW50ID0gZGlzcGF0 Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5tb3VzZXVwRXZlbnQsIG1ldi50YXJnZXROb2RlKCks IHRydWUsIG1fY2xpY2tDb3VudCwgbW91c2VFdmVudCwgZmFsc2UpOwogCiAgICAgYm9vbCBzd2Fs bG93Q2xpY2tFdmVudCA9IGZhbHNlOwotICAgIC8vIERvbid0IGV2ZXIgZGlzcGF0Y2ggY2xpY2sg ZXZlbnRzIGZvciByaWdodCBjbGlja3MKLSAgICBpZiAobW91c2VFdmVudC5idXR0b24oKSAhPSBS aWdodEJ1dHRvbiAmJiBtZXYudGFyZ2V0Tm9kZSgpID09IG1fY2xpY2tOb2RlKQorICAgIGlmICht ZXYudGFyZ2V0Tm9kZSgpID09IG1fY2xpY2tOb2RlKQogICAgICAgICBzd2FsbG93Q2xpY2tFdmVu dCA9IGRpc3BhdGNoTW91c2VFdmVudChldmVudE5hbWVzKCkuY2xpY2tFdmVudCwgbWV2LnRhcmdl dE5vZGUoKSwgdHJ1ZSwgbV9jbGlja0NvdW50LCBtb3VzZUV2ZW50LCB0cnVlKTsKIAogICAgIGlm IChtX2xhc3RTY3JvbGxiYXJVbmRlck1vdXNlKQpAQCAtMTU1Nyw5ICsxNTU2LDggQEAKIAogICAg IGJvb2wgc3dhbGxvd01vdXNlVXBFdmVudCA9IGRpc3BhdGNoTW91c2VFdmVudChldmVudE5hbWVz KCkubW91c2V1cEV2ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNrQ291bnQsIG1v dXNlRXZlbnQsIGZhbHNlKTsKIAotICAgIC8vIERvbid0IGV2ZXIgZGlzcGF0Y2ggY2xpY2sgZXZl bnRzIGZvciByaWdodCBjbGlja3MKICAgICBib29sIHN3YWxsb3dDbGlja0V2ZW50ID0gZmFsc2U7 Ci0gICAgaWYgKG1fY2xpY2tDb3VudCA+IDAgJiYgbW91c2VFdmVudC5idXR0b24oKSAhPSBSaWdo dEJ1dHRvbiAmJiBtZXYudGFyZ2V0Tm9kZSgpID09IG1fY2xpY2tOb2RlKQorICAgIGlmIChtX2Ns aWNrQ291bnQgPiAwICYmIG1ldi50YXJnZXROb2RlKCkgPT0gbV9jbGlja05vZGUpCiAgICAgICAg IHN3YWxsb3dDbGlja0V2ZW50ID0gZGlzcGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5jbGlj a0V2ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNrQ291bnQsIG1vdXNlRXZlbnQs IHRydWUpOwogCiAgICAgaWYgKG1fcmVzaXplTGF5ZXIpIHsKSW5kZXg6IExheW91dFRlc3RzL2Zh c3QvZXZlbnRzL3NjcmlwdC10ZXN0cy9tb3VzZS1jbGljay1ldmVudHMuanMKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2NyaXB0LXRlc3RzL21vdXNlLWNsaWNrLWV2ZW50 cy5qcwkocmV2aXNpb24gNjA2ODcpCisrKyBMYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JpcHQt dGVzdHMvbW91c2UtY2xpY2stZXZlbnRzLmpzCSh3b3JraW5nIGNvcHkpCkBAIC00OSw5ICs0OSw5 IEBACiAKIGlmICh3aW5kb3cuZXZlbnRTZW5kZXIpIHsKICAgICB0ZXN0RXZlbnRzKCJMZWZ0IE1v dXNlIEJ1dHRvbiIsIDAsICJtb3VzZWRvd24oMCkgbW91c2V1cCgwKSBjbGljaygwKSBtb3VzZWRv d24oMCkgbW91c2V1cCgwKSBjbGljaygwKSBkYmxjbGljaygwKSAiKTsKLSAgICB0ZXN0RXZlbnRz KCJNaWRkbGUgTW91c2UgQnV0dG9uIiwgMSwgIm1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGNsaWNr KDEpIG1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGNsaWNrKDEpIGRibGNsaWNrKDEpICIpOworICAg IHRlc3RFdmVudHMoIk1pZGRsZSBNb3VzZSBCdXR0b24iLCAxLCAibW91c2Vkb3duKDEpIG1vdXNl dXAoMSkgbW91c2Vkb3duKDEpIG1vdXNldXAoMSkgIik7CiAgICAgdGVzdEV2ZW50cygiUmlnaHQg TW91c2UgQnV0dG9uIiwgMiwgIm1vdXNlZG93bigyKSBtb3VzZXVwKDIpIG1vdXNlZG93bigyKSBt b3VzZXVwKDIpICIpOwotICAgIHRlc3RFdmVudHMoIjR0aCBNb3VzZSBCdXR0b24iLCAzLCAibW91 c2Vkb3duKDEpIG1vdXNldXAoMSkgY2xpY2soMSkgbW91c2Vkb3duKDEpIG1vdXNldXAoMSkgY2xp Y2soMSkgZGJsY2xpY2soMSkgIik7CisgICAgdGVzdEV2ZW50cygiNHRoIE1vdXNlIEJ1dHRvbiIs IDMsICJtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBtb3VzZWRvd24oMSkgbW91c2V1cCgxKSAiKTsK IH0KIAogdmFyIHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7CkluZGV4OiBMYXlvdXRUZXN0cy9m YXN0L2V2ZW50cy9tb3VzZS1jbGljay1ldmVudHMtZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IExheW91dFRlc3RzL2Zhc3QvZXZlbnRzL21vdXNlLWNsaWNrLWV2ZW50cy1leHBlY3RlZC50eHQJ KHJldmlzaW9uIDYwNjg3KQorKysgTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvbW91c2UtY2xpY2st ZXZlbnRzLWV4cGVjdGVkLnR4dAkod29ya2luZyBjb3B5KQpAQCAtNiwxMSArNiwxMSBAQAogTGVm dCBNb3VzZSBCdXR0b24KIFBBU1MgZXZlbnRMb2cgaXMgIm1vdXNlZG93bigwKSBtb3VzZXVwKDAp IGNsaWNrKDApIG1vdXNlZG93bigwKSBtb3VzZXVwKDApIGNsaWNrKDApIGRibGNsaWNrKDApICIK IE1pZGRsZSBNb3VzZSBCdXR0b24KLVBBU1MgZXZlbnRMb2cgaXMgIm1vdXNlZG93bigxKSBtb3Vz ZXVwKDEpIGNsaWNrKDEpIG1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGNsaWNrKDEpIGRibGNsaWNr KDEpICIKK1BBU1MgZXZlbnRMb2cgaXMgIm1vdXNlZG93bigxKSBtb3VzZXVwKDEpIG1vdXNlZG93 bigxKSBtb3VzZXVwKDEpICIKIFJpZ2h0IE1vdXNlIEJ1dHRvbgogUEFTUyBldmVudExvZyBpcyAi bW91c2Vkb3duKDIpIG1vdXNldXAoMikgbW91c2Vkb3duKDIpIG1vdXNldXAoMikgIgogNHRoIE1v dXNlIEJ1dHRvbgotUEFTUyBldmVudExvZyBpcyAibW91c2Vkb3duKDEpIG1vdXNldXAoMSkgY2xp Y2soMSkgbW91c2Vkb3duKDEpIG1vdXNldXAoMSkgY2xpY2soMSkgZGJsY2xpY2soMSkgIgorUEFT UyBldmVudExvZyBpcyAibW91c2Vkb3duKDEpIG1vdXNldXAoMSkgbW91c2Vkb3duKDEpIG1vdXNl dXAoMSkgIgogUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQogCiBURVNUIENPTVBMRVRF CkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCShyZXZpc2lvbiA2MDcwNCkKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29y a2luZyBjb3B5KQpAQCAtMSwzICsxLDE2IEBACisyMDEwLTA2LTA0ICBOYXRlIENoYXBpbiAgPGph cGhldEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgTWlkZGxlIGNsaWNrIGZpcmVzIG9uY2xpY2sgZXZlbnQKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyMzgyCisKKyAgICAgICAgVXBk YXRlIGV4cGVjdGVkIHJlc3VsdHMgdG8gc2hvdyB0aGF0IHdlJ3JlIG5vdCBzZW5kaW5nIG1pZGRs ZSBjbGljaworICAgICAgICBldmVudHMgYW55bW9yZS4KKworICAgICAgICAqIGZhc3QvZXZlbnRz L21vdXNlLWNsaWNrLWV2ZW50cy1leHBlY3RlZC50eHQ6CisgICAgICAgICogZmFzdC9ldmVudHMv c2NyaXB0LXRlc3RzL21vdXNlLWNsaWNrLWV2ZW50cy5qczoKKwogMjAxMC0wNi0wNCAgU3RlcGhl biBXaGl0ZSAgPHNlbm9yYmxhbmNvQGNocm9taXVtLm9yZz4KIAogICAgICAgICBVbnJldmlld2Vk OyBidWlsZCBmaXguCg== 66729 2010-09-07 09:33:07 -0700 2010-09-07 17:07:47 -0700 Work in progress -- not ready to go yet and probably should be broken up and landed in pieces. bug-22382-20100907093306.patch text/plain 22653 darin SW5kZXg6IFdlYkNvcmUvZWRpdGluZy9EZWxldGVCdXR0b24uY3BwCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvZWRpdGluZy9EZWxldGVCdXR0b24uY3BwCShyZXZpc2lvbiA2NjU2NSkKKysrIFdlYkNv cmUvZWRpdGluZy9EZWxldGVCdXR0b24uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01MCwxNCArNTAs MTAgQEAgUGFzc1JlZlB0cjxEZWxldGVCdXR0b24+IERlbGV0ZUJ1dHRvbjo6YwogCiB2b2lkIERl bGV0ZUJ1dHRvbjo6ZGVmYXVsdEV2ZW50SGFuZGxlcihFdmVudCogZXZlbnQpCiB7Ci0gICAgLy8g RklYTUU6IElzIGl0IHJlYWxseSBpbXBvcnQgdG8gY2hlY2sgdGhlIHR5cGUgb2YgdGhlIGV2ZW50 PwotICAgIC8vIFNlZW1zIE9LIHRvIHJlc3BvbmQgdG8gYW55IGV2ZW50IG5hbWVkIGNsaWNrIGV2 ZW4gaWYgaXQgZG9lcyBub3QgaGF2ZSB0aGUgY29ycmVjdCB0eXBlLgotICAgIGlmIChldmVudC0+ aXNNb3VzZUV2ZW50KCkpIHsKLSAgICAgICAgaWYgKGV2ZW50LT50eXBlKCkgPT0gZXZlbnROYW1l cygpLmNsaWNrRXZlbnQpIHsKLSAgICAgICAgICAgIGRvY3VtZW50KCktPmZyYW1lKCktPmVkaXRv cigpLT5kZWxldGVCdXR0b25Db250cm9sbGVyKCktPmRlbGV0ZVRhcmdldCgpOwotICAgICAgICAg ICAgZXZlbnQtPnNldERlZmF1bHRIYW5kbGVkKCk7Ci0gICAgICAgICAgICAvLyBGSVhNRTogU2hv dWxkbid0IHdlIHJldHVybiBoZXJlIGluc3RlYWQgb2YgZmFsbGluZyB0aHJvdWdoPwotICAgICAg ICB9CisgICAgaWYgKGV2ZW50LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmNsaWNrRXZlbnQpIHsK KyAgICAgICAgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+ZWRpdG9yKCktPmRlbGV0ZUJ1dHRvbkNvbnRy b2xsZXIoKS0+ZGVsZXRlVGFyZ2V0KCk7CisgICAgICAgIGV2ZW50LT5zZXREZWZhdWx0SGFuZGxl ZCgpOworICAgICAgICByZXR1cm47CiAgICAgfQogCiAgICAgSFRNTEltYWdlRWxlbWVudDo6ZGVm YXVsdEV2ZW50SGFuZGxlcihldmVudCk7CkluZGV4OiBXZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVs ZW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5j cHAJKHJldmlzaW9uIDY2NTY1KQorKysgV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmNw cAkod29ya2luZyBjb3B5KQpAQCAtMiw3ICsyLDcgQEAKICAqIENvcHlyaWdodCAoQykgMTk5OSBM YXJzIEtub2xsIChrbm9sbEBrZGUub3JnKQogICogICAgICAgICAgIChDKSAxOTk5IEFudHRpIEtv aXZpc3RvIChrb2l2aXN0b0BrZGUub3JnKQogICogICAgICAgICAgIChDKSAyMDAwIFNpbW9uIEhh dXNtYW5uIDxoYXVzbWFubkBrZGUub3JnPgotICogQ29weXJpZ2h0IChDKSAyMDAzLCAyMDA2LCAy MDA3LCAyMDA4LCAyMDA5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHly aWdodCAoQykgMjAwMywgMjAwNiwgMjAwNywgMjAwOCwgMjAwOSwgMjAxMCBBcHBsZSBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCiAgKiAgICAgICAgICAgKEMpIDIwMDYgR3JhaGFtIERlbm5pcyAo Z3JhaGFtLmRlbm5pc0BnbWFpbC5jb20pCiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29m dHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgpAQCAtMTA1LDEwOSArMTA1LDEx MCBAQCBib29sIEhUTUxBbmNob3JFbGVtZW50Ojppc0tleWJvYXJkRm9jdXNhCiAgICAgcmV0dXJu IGhhc05vbkVtcHR5Qm91bmRpbmdCb3goKTsKIH0KIAotdm9pZCBIVE1MQW5jaG9yRWxlbWVudDo6 ZGVmYXVsdEV2ZW50SGFuZGxlcihFdmVudCogZXZ0KQorc3RhdGljIGJvb2wgaXNNb3VzZUV2ZW50 V2l0aG91dFNoaWZ0S2V5RG93bihFdmVudCogZXZlbnQpCiB7Ci0gICAgLy8gUmVhY3Qgb24gY2xp Y2tzIGFuZCBvbiBrZXlwcmVzc2VzLgotICAgIC8vIERvbid0IG1ha2UgdGhpcyBLRVlVUF9FVkVO VCBhZ2FpbiwgaXQgbWFrZXMga2h0bWwgZm9sbG93IGxpbmtzIGl0IHNob3VsZG4ndCwKLSAgICAv LyB3aGVuIHByZXNzaW5nIEVudGVyIGluIHRoZSBjb21iby4KLSAgICBpZiAoaXNMaW5rKCkgJiYg KGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50IHx8IChldnQtPnR5cGUoKSA9 PSBldmVudE5hbWVzKCkua2V5ZG93bkV2ZW50ICYmIGZvY3VzZWQoKSkpKSB7Ci0gICAgICAgIE1v dXNlRXZlbnQqIGUgPSAwOwotICAgICAgICBpZiAoZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygp LmNsaWNrRXZlbnQgJiYgZXZ0LT5pc01vdXNlRXZlbnQoKSkKLSAgICAgICAgICAgIGUgPSBzdGF0 aWNfY2FzdDxNb3VzZUV2ZW50Kj4oZXZ0KTsKLQotICAgICAgICBLZXlib2FyZEV2ZW50KiBrID0g MDsKLSAgICAgICAgaWYgKGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5rZXlkb3duRXZlbnQg JiYgZXZ0LT5pc0tleWJvYXJkRXZlbnQoKSkKLSAgICAgICAgICAgIGsgPSBzdGF0aWNfY2FzdDxL ZXlib2FyZEV2ZW50Kj4oZXZ0KTsKLQotICAgICAgICBpZiAoZSAmJiBlLT5idXR0b24oKSA9PSBS aWdodEJ1dHRvbikgewotICAgICAgICAgICAgSFRNTEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRs ZXIoZXZ0KTsKLSAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgfQorICAgIHJldHVybiBldmVu dC0+aXNNb3VzZUV2ZW50KCkKKyAgICAgICAgJiYgIXN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihl dmVudCktPnNoaWZ0S2V5KCk7Cit9CiAKLSAgICAgICAgLy8gSWYgdGhlIGxpbmsgaXMgZWRpdGFi bGUsIHRoZW4gd2UgbmVlZCB0byBjaGVjayB0aGUgc2V0dGluZ3MgdG8gc2VlIHdoZXRoZXIgb3Ig bm90IHRvIGZvbGxvdyB0aGUgbGluawotICAgICAgICBpZiAoaXNDb250ZW50RWRpdGFibGUoKSkg ewotICAgICAgICAgICAgRWRpdGFibGVMaW5rQmVoYXZpb3IgZWRpdGFibGVMaW5rQmVoYXZpb3Ig PSBFZGl0YWJsZUxpbmtEZWZhdWx0QmVoYXZpb3I7Ci0gICAgICAgICAgICBpZiAoU2V0dGluZ3Mq IHNldHRpbmdzID0gZG9jdW1lbnQoKS0+c2V0dGluZ3MoKSkKLSAgICAgICAgICAgICAgICBlZGl0 YWJsZUxpbmtCZWhhdmlvciA9IHNldHRpbmdzLT5lZGl0YWJsZUxpbmtCZWhhdmlvcigpOwotICAg ICAgICAgICAgICAgIAotICAgICAgICAgICAgc3dpdGNoIChlZGl0YWJsZUxpbmtCZWhhdmlvcikg ewotICAgICAgICAgICAgICAgIC8vIEFsd2F5cyBmb2xsb3cgdGhlIGxpbmsgKFNhZmFyaSAyLjAg YmVoYXZpb3IpCi0gICAgICAgICAgICAgICAgZGVmYXVsdDoKLSAgICAgICAgICAgICAgICBjYXNl IEVkaXRhYmxlTGlua0RlZmF1bHRCZWhhdmlvcjoKLSAgICAgICAgICAgICAgICBjYXNlIEVkaXRh YmxlTGlua0Fsd2F5c0xpdmU6Ci0gICAgICAgICAgICAgICAgICAgIGJyZWFrOworYm9vbCBIVE1M QW5jaG9yRWxlbWVudDo6c2hvdWxkRm9sbG93TGluayhFdmVudCogZXZlbnQpIGNvbnN0Cit7Cisg ICAgaWYgKCFpc0NvbnRlbnRFZGl0YWJsZSgpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKIAotICAg ICAgICAgICAgICAgIGNhc2UgRWRpdGFibGVMaW5rTmV2ZXJMaXZlOgotICAgICAgICAgICAgICAg ICAgICBIVE1MRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihldnQpOwotICAgICAgICAgICAg ICAgICAgICByZXR1cm47CisgICAgU2V0dGluZ3MqIHNldHRpbmdzID0gZG9jdW1lbnQoKS0+c2V0 dGluZ3MoKTsKKyAgICBpZiAoIXNldHRpbmdzKQorICAgICAgICByZXR1cm4gdHJ1ZTsKIAotICAg ICAgICAgICAgICAgIC8vIElmIHRoZSBzZWxlY3Rpb24gcHJpb3IgdG8gY2xpY2tpbmcgb24gdGhp cyBsaW5rIHJlc2lkZWQgaW4gdGhlIHNhbWUgZWRpdGFibGUgYmxvY2sgYXMgdGhpcyBsaW5rLAot ICAgICAgICAgICAgICAgIC8vIGFuZCB0aGUgc2hpZnQga2V5IGlzbid0IHByZXNzZWQsIHdlIGRv bid0IHdhbnQgdG8gZm9sbG93IHRoZSBsaW5rCi0gICAgICAgICAgICAgICAgY2FzZSBFZGl0YWJs ZUxpbmtMaXZlV2hlbk5vdEZvY3VzZWQ6Ci0gICAgICAgICAgICAgICAgICAgIGlmIChlICYmICFl LT5zaGlmdEtleSgpICYmIG1fcm9vdEVkaXRhYmxlRWxlbWVudEZvclNlbGVjdGlvbk9uTW91c2VE b3duID09IHJvb3RFZGl0YWJsZUVsZW1lbnQoKSkgewotICAgICAgICAgICAgICAgICAgICAgICAg SFRNTEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoZXZ0KTsKLSAgICAgICAgICAgICAgICAg ICAgICAgIHJldHVybjsKLSAgICAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgICAg ICBicmVhazsKLQotICAgICAgICAgICAgICAgIC8vIE9ubHkgZm9sbG93IHRoZSBsaW5rIGlmIHRo ZSBzaGlmdCBrZXkgaXMgZG93biAoV2luSUUvRmlyZWZveCBiZWhhdmlvcikKLSAgICAgICAgICAg ICAgICBjYXNlIEVkaXRhYmxlTGlua09ubHlMaXZlV2l0aFNoaWZ0S2V5OgotICAgICAgICAgICAg ICAgICAgICBpZiAoZSAmJiAhZS0+c2hpZnRLZXkoKSkgewotICAgICAgICAgICAgICAgICAgICAg ICAgSFRNTEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoZXZ0KTsKLSAgICAgICAgICAgICAg ICAgICAgICAgIHJldHVybjsKLSAgICAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAg ICAgICBicmVhazsKLSAgICAgICAgICAgIH0KLSAgICAgICAgfQorICAgIHN3aXRjaCAoc2V0dGlu Z3MtPmVkaXRhYmxlTGlua0JlaGF2aW9yKCkpIHsKKyAgICBjYXNlIEVkaXRhYmxlTGlua0RlZmF1 bHRCZWhhdmlvcjoKKyAgICBjYXNlIEVkaXRhYmxlTGlua0Fsd2F5c0xpdmU6CisgICAgICAgIHJl dHVybiB0cnVlOwogCi0gICAgICAgIGlmIChrKSB7Ci0gICAgICAgICAgICBpZiAoay0+a2V5SWRl bnRpZmllcigpICE9ICJFbnRlciIpIHsKLSAgICAgICAgICAgICAgICBIVE1MRWxlbWVudDo6ZGVm YXVsdEV2ZW50SGFuZGxlcihldnQpOwotICAgICAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAg ICAgIH0KLSAgICAgICAgICAgIGV2dC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKLSAgICAgICAgICAg IGRpc3BhdGNoU2ltdWxhdGVkQ2xpY2soZXZ0KTsKLSAgICAgICAgICAgIHJldHVybjsKLSAgICAg ICAgfQorICAgIGNhc2UgRWRpdGFibGVMaW5rTmV2ZXJMaXZlOgorICAgICAgICByZXR1cm4gZmFs c2U7CiAKKyAgICAvLyBJZiB0aGUgc2VsZWN0aW9uIHByaW9yIHRvIGNsaWNraW5nIG9uIHRoaXMg bGluayByZXNpZGVkIGluIHRoZSBzYW1lIGVkaXRhYmxlIGJsb2NrIGFzIHRoaXMgbGluaywKKyAg ICAvLyBhbmQgdGhlIHNoaWZ0IGtleSBpc24ndCBwcmVzc2VkLCB3ZSBkb24ndCB3YW50IHRvIGZv bGxvdyB0aGUgbGluay4KKyAgICBjYXNlIEVkaXRhYmxlTGlua0xpdmVXaGVuTm90Rm9jdXNlZDoK KyAgICAgICAgcmV0dXJuICEoaXNNb3VzZUV2ZW50V2l0aG91dFNoaWZ0S2V5RG93bihldmVudCkg JiYgbV9yb290RWRpdGFibGVFbGVtZW50Rm9yU2VsZWN0aW9uT25Nb3VzZURvd24gPT0gcm9vdEVk aXRhYmxlRWxlbWVudCgpKTsKKworICAgIGNhc2UgRWRpdGFibGVMaW5rT25seUxpdmVXaXRoU2hp ZnRLZXk6CisgICAgICAgIHJldHVybiAhaXNNb3VzZUV2ZW50V2l0aG91dFNoaWZ0S2V5RG93bihl dmVudCk7CisgICAgfQorCisgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgcmV0dXJuIGZh bHNlOworfQorCitib29sIGlzTWlkZGxlTW91c2VCdXR0b25FdmVudChFdmVudCogZXZlbnQpCit7 CisgICAgcmV0dXJuIGV2ZW50LT5pc01vdXNlRXZlbnQoKQorICAgICAgICAmJiBzdGF0aWNfY2Fz dDxNb3VzZUV2ZW50Kj4oZXZlbnQpLT5idXR0b24oKSA9PSAxOworfQorCitib29sIGlzRW50ZXJL ZXlLZXlkb3duRXZlbnQoRXZlbnQqIGV2ZW50KQoreworICAgIHJldHVybiBldmVudC0+dHlwZSgp ID09IGV2ZW50TmFtZXMoKS5rZXlkb3duRXZlbnQKKyAgICAgICAgJiYgZXZlbnQtPmlzS2V5Ym9h cmRFdmVudCgpCisgICAgICAgICYmIHN0YXRpY19jYXN0PEtleWJvYXJkRXZlbnQqPihldmVudCkt PmtleUlkZW50aWZpZXIoKSA9PSAiRW50ZXIiOworfQorCitib29sIGlzTGlua0NsaWNrKEV2ZW50 KiBldmVudCkKK3sKKyAgICByZXR1cm4gZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xp Y2tFdmVudAorICAgICAgICB8fCBldmVudC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5tb3VzZXVw RXZlbnQgJiYgaXNNaWRkbGVNb3VzZUJ1dHRvbkV2ZW50KGV2ZW50KTsKK30KKwordm9pZCBIVE1M QW5jaG9yRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihFdmVudCogZXZlbnQpCit7CisgICAg aWYgKGlzTGluaygpICYmIGZvY3VzZWQoKSAmJiBpc0VudGVyS2V5S2V5ZG93bkV2ZW50KGV2ZW50 KSkgeworICAgICAgICBldmVudC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKKyAgICAgICAgZGlzcGF0 Y2hTaW11bGF0ZWRDbGljayhldmVudCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBp ZiAoaXNMaW5rKCkgJiYgaXNMaW5rQ2xpY2soZXZlbnQpICYmIHNob3VsZEZvbGxvd0xpbmsoZXZl bnQpKSB7CiAgICAgICAgIFN0cmluZyB1cmwgPSBkZXByZWNhdGVkUGFyc2VVUkwoZ2V0QXR0cmli dXRlKGhyZWZBdHRyKSk7CiAKLSAgICAgICAgQVNTRVJUKGV2dC0+dGFyZ2V0KCkpOwotICAgICAg ICBBU1NFUlQoZXZ0LT50YXJnZXQoKS0+dG9Ob2RlKCkpOwotICAgICAgICBpZiAoZXZ0LT50YXJn ZXQoKS0+dG9Ob2RlKCktPmhhc1RhZ05hbWUoaW1nVGFnKSkgewotICAgICAgICAgICAgSFRNTElt YWdlRWxlbWVudCogaW1nID0gc3RhdGljX2Nhc3Q8SFRNTEltYWdlRWxlbWVudCo+KGV2dC0+dGFy Z2V0KCktPnRvTm9kZSgpKTsKLSAgICAgICAgICAgIGlmIChpbWcgJiYgaW1nLT5pc1NlcnZlck1h cCgpKSB7Ci0gICAgICAgICAgICAgICAgUmVuZGVySW1hZ2UqIHIgPSB0b1JlbmRlckltYWdlKGlt Zy0+cmVuZGVyZXIoKSk7Ci0gICAgICAgICAgICAgICAgaWYgKHIgJiYgZSkgewotICAgICAgICAg ICAgICAgICAgICAvLyBGSVhNRTogYnJva2VuIHdpdGggdHJhbnNmb3JtcwotICAgICAgICAgICAg ICAgICAgICBGbG9hdFBvaW50IGFic1BvcyA9IHItPmxvY2FsVG9BYnNvbHV0ZSgpOwotICAgICAg ICAgICAgICAgICAgICBpbnQgeCA9IGUtPnBhZ2VYKCkgLSBhYnNQb3MueCgpOwotICAgICAgICAg ICAgICAgICAgICBpbnQgeSA9IGUtPnBhZ2VZKCkgLSBhYnNQb3MueSgpOworICAgICAgICBBU1NF UlQoZXZlbnQtPnRhcmdldCgpKTsKKyAgICAgICAgTm9kZSogdGFyZ2V0ID0gZXZlbnQtPnRhcmdl dCgpLT50b05vZGUoKTsKKyAgICAgICAgQVNTRVJUKHRhcmdldCk7CisgICAgICAgIGlmICh0YXJn ZXQtPmhhc1RhZ05hbWUoaW1nVGFnKSkgeworICAgICAgICAgICAgSFRNTEltYWdlRWxlbWVudCog aW1hZ2VFbGVtZW50ID0gc3RhdGljX2Nhc3Q8SFRNTEltYWdlRWxlbWVudCo+KGV2ZW50LT50YXJn ZXQoKS0+dG9Ob2RlKCkpOworICAgICAgICAgICAgaWYgKGltYWdlRWxlbWVudCAmJiBpbWFnZUVs ZW1lbnQtPmlzU2VydmVyTWFwKCkpIHsKKyAgICAgICAgICAgICAgICBSZW5kZXJJbWFnZSogcmVu ZGVyZXIgPSB0b1JlbmRlckltYWdlKGltYWdlRWxlbWVudC0+cmVuZGVyZXIoKSk7CisgICAgICAg ICAgICAgICAgaWYgKHJlbmRlcmVyICYmIGV2ZW50LT5pc01vdXNlRXZlbnQoKSkgeworICAgICAg ICAgICAgICAgICAgICAvLyBGSVhNRTogV2Ugc2hvdWxkIHBhc3MgdHJ1ZSBmb3IgdXNlVHJhbnNm b3Jtcy4KKyAgICAgICAgICAgICAgICAgICAgRmxvYXRQb2ludCBhYnNvbHV0ZVBvc2l0aW9uID0g cmVuZGVyZXItPmFic29sdXRlVG9Mb2NhbChGbG9hdFBvaW50KHN0YXRpY19jYXN0PE1vdXNlRXZl bnQqPihldmVudCktPnBhZ2VYKCksIHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldmVudCktPnBh Z2VZKCkpKTsKKyAgICAgICAgICAgICAgICAgICAgaW50IHggPSBhYnNvbHV0ZVBvc2l0aW9uLngo KTsKKyAgICAgICAgICAgICAgICAgICAgaW50IHkgPSBhYnNvbHV0ZVBvc2l0aW9uLnkoKTsKICAg ICAgICAgICAgICAgICAgICAgdXJsICs9ICI/IjsKICAgICAgICAgICAgICAgICAgICAgdXJsICs9 IFN0cmluZzo6bnVtYmVyKHgpOwogICAgICAgICAgICAgICAgICAgICB1cmwgKz0gIiwiOwogICAg ICAgICAgICAgICAgICAgICB1cmwgKz0gU3RyaW5nOjpudW1iZXIoeSk7Ci0gICAgICAgICAgICAg ICAgfSBlbHNlIHsKLSAgICAgICAgICAgICAgICAgICAgZXZ0LT5zZXREZWZhdWx0SGFuZGxlZCgp OwotICAgICAgICAgICAgICAgICAgICBIVE1MRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihl dnQpOwotICAgICAgICAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgICAgICAgICAgfQogICAg ICAgICAgICAgfQogICAgICAgICB9CiAKLSAgICAgICAgaWYgKCFldnQtPmRlZmF1bHRQcmV2ZW50 ZWQoKSAmJiBkb2N1bWVudCgpLT5mcmFtZSgpKQotICAgICAgICAgICAgZG9jdW1lbnQoKS0+ZnJh bWUoKS0+bG9hZGVyKCktPnVybFNlbGVjdGVkKGRvY3VtZW50KCktPmNvbXBsZXRlVVJMKHVybCks IGdldEF0dHJpYnV0ZSh0YXJnZXRBdHRyKSwgZXZ0LCBmYWxzZSwgZmFsc2UsIHRydWUsIGhhc1Jl bChSZWxhdGlvbk5vUmVmZXJyZXIpID8gTm9SZWZlcnJlciA6IFNlbmRSZWZlcnJlcik7CisgICAg ICAgIGlmICghZXZlbnQtPmRlZmF1bHRQcmV2ZW50ZWQoKSAmJiBkb2N1bWVudCgpLT5mcmFtZSgp KQorICAgICAgICAgICAgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+bG9hZGVyKCktPnVybFNlbGVjdGVk KGRvY3VtZW50KCktPmNvbXBsZXRlVVJMKHVybCksCisgICAgICAgICAgICAgICAgZ2V0QXR0cmli dXRlKHRhcmdldEF0dHIpLCBldmVudCwKKyAgICAgICAgICAgICAgICBmYWxzZSwgZmFsc2UsIHRy dWUsCisgICAgICAgICAgICAgICAgaGFzUmVsKFJlbGF0aW9uTm9SZWZlcnJlcikgPyBOb1JlZmVy cmVyIDogU2VuZFJlZmVycmVyKTsKKworICAgICAgICBldmVudC0+c2V0RGVmYXVsdEhhbmRsZWQo KTsKKyAgICB9CiAKLSAgICAgICAgZXZ0LT5zZXREZWZhdWx0SGFuZGxlZCgpOwotICAgIH0gZWxz ZSBpZiAoaXNMaW5rKCkgJiYgaXNDb250ZW50RWRpdGFibGUoKSkgeworICAgIGlmIChpc0xpbmso KSAmJiBpc0NvbnRlbnRFZGl0YWJsZSgpKSB7CiAgICAgICAgIC8vIFRoaXMga2VlcHMgdHJhY2sg b2YgdGhlIGVkaXRhYmxlIGJsb2NrIHRoYXQgdGhlIHNlbGVjdGlvbiB3YXMgaW4gKGlmIGl0IHdh cyBpbiBvbmUpIGp1c3QgYmVmb3JlIHRoZSBsaW5rIHdhcyBjbGlja2VkCiAgICAgICAgIC8vIGZv ciB0aGUgTGl2ZVdoZW5Ob3RGb2N1c2VkIGVkaXRhYmxlIGxpbmsgYmVoYXZpb3IKLSAgICAgICAg aWYgKGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5tb3VzZWRvd25FdmVudCAmJiBldnQtPmlz TW91c2VFdmVudCgpICYmIHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldnQpLT5idXR0b24oKSAh PSBSaWdodEJ1dHRvbiAmJiBkb2N1bWVudCgpLT5mcmFtZSgpICYmIGRvY3VtZW50KCktPmZyYW1l KCktPnNlbGVjdGlvbigpKSB7Ci0gICAgICAgICAgICBNb3VzZUV2ZW50KiBlID0gc3RhdGljX2Nh c3Q8TW91c2VFdmVudCo+KGV2dCk7CisgICAgICAgIGlmIChldmVudC0+dHlwZSgpID09IGV2ZW50 TmFtZXMoKS5tb3VzZWRvd25FdmVudCAmJiBldmVudC0+aXNNb3VzZUV2ZW50KCkgJiYgc3RhdGlj X2Nhc3Q8TW91c2VFdmVudCo+KGV2ZW50KS0+YnV0dG9uKCkgIT0gUmlnaHRCdXR0b24gJiYgZG9j dW1lbnQoKS0+ZnJhbWUoKSAmJiBkb2N1bWVudCgpLT5mcmFtZSgpLT5zZWxlY3Rpb24oKSkgewor ICAgICAgICAgICAgTW91c2VFdmVudCogbW91c2VFdmVudCA9IHN0YXRpY19jYXN0PE1vdXNlRXZl bnQqPihldmVudCk7CiAKICAgICAgICAgICAgIG1fcm9vdEVkaXRhYmxlRWxlbWVudEZvclNlbGVj dGlvbk9uTW91c2VEb3duID0gZG9jdW1lbnQoKS0+ZnJhbWUoKS0+c2VsZWN0aW9uKCktPnJvb3RF ZGl0YWJsZUVsZW1lbnQoKTsKLSAgICAgICAgICAgIG1fd2FzU2hpZnRLZXlEb3duT25Nb3VzZURv d24gPSBlICYmIGUtPnNoaWZ0S2V5KCk7Ci0gICAgICAgIH0gZWxzZSBpZiAoZXZ0LT50eXBlKCkg PT0gZXZlbnROYW1lcygpLm1vdXNlb3ZlckV2ZW50KSB7CisgICAgICAgICAgICBtX3dhc1NoaWZ0 S2V5RG93bk9uTW91c2VEb3duID0gbW91c2VFdmVudCAmJiBtb3VzZUV2ZW50LT5zaGlmdEtleSgp OworICAgICAgICB9IGVsc2UgaWYgKGV2ZW50LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLm1vdXNl b3ZlckV2ZW50KSB7CiAgICAgICAgICAgICAvLyBUaGVzZSBhcmUgY2xlYXJlZCBvbiBtb3VzZW92 ZXIgYW5kIG5vdCBtb3VzZW91dCBiZWNhdXNlIHRoZWlyIHZhbHVlcyBhcmUgbmVlZGVkIGZvciBk cmFnIGV2ZW50cywgYnV0IHRoZXNlIGhhcHBlbgogICAgICAgICAgICAgLy8gYWZ0ZXIgbW91c2Ug b3V0IGV2ZW50cy4KICAgICAgICAgICAgIG1fcm9vdEVkaXRhYmxlRWxlbWVudEZvclNlbGVjdGlv bk9uTW91c2VEb3duID0gMDsKQEAgLTIxNSw3ICsyMTYsNyBAQCB2b2lkIEhUTUxBbmNob3JFbGVt ZW50OjpkZWZhdWx0RXZlbnRIYW5kCiAgICAgICAgIH0KICAgICB9CiAKLSAgICBIVE1MRWxlbWVu dDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihldnQpOworICAgIEhUTUxFbGVtZW50OjpkZWZhdWx0RXZl bnRIYW5kbGVyKGV2ZW50KTsKIH0KIAogdm9pZCBIVE1MQW5jaG9yRWxlbWVudDo6c2V0QWN0aXZl KGJvb2wgZG93biwgYm9vbCBwYXVzZSkKSW5kZXg6IFdlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxl bWVudC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCShy ZXZpc2lvbiA2NjU2NSkKKysrIFdlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCSh3b3Jr aW5nIGNvcHkpCkBAIC0xMDksMTEgKzEwOSwxOSBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwgc2hv cnQgdGFiSW5kZXgoKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgZHJhZ2dhYmxlKCkgY29uc3Q7 CiAKKyAgICBib29sIHNob3VsZEZvbGxvd0xpbmsoRXZlbnQqKSBjb25zdDsKKwogICAgIFJlZlB0 cjxFbGVtZW50PiBtX3Jvb3RFZGl0YWJsZUVsZW1lbnRGb3JTZWxlY3Rpb25Pbk1vdXNlRG93bjsK ICAgICBib29sIG1fd2FzU2hpZnRLZXlEb3duT25Nb3VzZURvd247CiAgICAgdWludDMyX3QgbV9s aW5rUmVsYXRpb25zOwogfTsKIAorLy8gVGhlc2UgZnVuY3Rpb25zIGFyZSBzaGFyZWQgc28gdGhl IFdNTCBhbmQgU1ZHIGFuY2hvciBlbGVtZW50cyBjYW4gdXNlIHRoZW0uCisKK2Jvb2wgaXNNaWRk bGVNb3VzZUJ1dHRvbkV2ZW50KEV2ZW50Kik7Citib29sIGlzRW50ZXJLZXlLZXlkb3duRXZlbnQo RXZlbnQqKTsKK2Jvb2wgaXNMaW5rQ2xpY2soRXZlbnQqKTsKKwogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQogCiAjZW5kaWYgLy8gSFRNTEFuY2hvckVsZW1lbnRfaApJbmRleDogV2ViQ29yZS9odG1s L0hUTUxJbnB1dEVsZW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaHRtbC9IVE1MSW5w dXRFbGVtZW50LmNwcAkocmV2aXNpb24gNjY1NjUpCisrKyBXZWJDb3JlL2h0bWwvSFRNTElucHV0 RWxlbWVudC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTIxNDYsMTYgKzIxNDYsMTMgQEAgc3RydWN0 IEV2ZW50SGFuZGxpbmdTdGF0ZSA6IEZhc3RBbGxvY0JhcwogICAgICAgICAsIG1fY2hlY2tlZChj aGVja2VkKSB7IH0KIH07CiAKLXZvaWQqIEhUTUxJbnB1dEVsZW1lbnQ6OnByZURpc3BhdGNoRXZl bnRIYW5kbGVyKEV2ZW50ICpldnQpCit2b2lkKiBIVE1MSW5wdXRFbGVtZW50OjpwcmVEaXNwYXRj aEV2ZW50SGFuZGxlcihFdmVudCogZXZ0KQogewogICAgIC8vIHByZXZlbnREZWZhdWx0IG9yICJy ZXR1cm4gZmFsc2UiIGFyZSB1c2VkIHRvIHJldmVyc2UgdGhlIGF1dG9tYXRpYyBjaGVja2luZy9z ZWxlY3Rpb24gd2UgZG8gaGVyZS4KICAgICAvLyBUaGlzIHJlc3VsdCBnaXZlcyB1cyBlbm91Z2gg aW5mbyB0byBwZXJmb3JtIHRoZSAidW5kbyIgaW4gcG9zdERpc3BhdGNoIG9mIHRoZSBhY3Rpb24g d2UgdGFrZSBoZXJlLgogICAgIHZvaWQqIHJlc3VsdCA9IDA7IAotICAgIGlmICgoaW5wdXRUeXBl KCkgPT0gQ0hFQ0tCT1ggfHwgaW5wdXRUeXBlKCkgPT0gUkFESU8pICYmIGV2dC0+aXNNb3VzZUV2 ZW50KCkKLSAgICAgICAgICAgICYmIGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2 ZW50ICYmIHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldnQpLT5idXR0b24oKSA9PSBMZWZ0QnV0 dG9uKSB7Ci0gICAgICAgIAorICAgIGlmICgoaW5wdXRUeXBlKCkgPT0gQ0hFQ0tCT1ggfHwgaW5w dXRUeXBlKCkgPT0gUkFESU8pICYmIGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2 ZW50KSB7CiAgICAgICAgIE93blB0cjxFdmVudEhhbmRsaW5nU3RhdGU+IHN0YXRlID0gYWRvcHRQ dHIobmV3IEV2ZW50SGFuZGxpbmdTdGF0ZShpbmRldGVybWluYXRlKCksIGNoZWNrZWQoKSkpOwot CiAgICAgICAgIGlmIChpbnB1dFR5cGUoKSA9PSBDSEVDS0JPWCkgewogICAgICAgICAgICAgaWYg KGluZGV0ZXJtaW5hdGUoKSkKICAgICAgICAgICAgICAgICBzZXRJbmRldGVybWluYXRlKGZhbHNl KTsKQEAgLTIxODMsOCArMjE4MCw3IEBAIHZvaWQqIEhUTUxJbnB1dEVsZW1lbnQ6OnByZURpc3Bh dGNoRXZlbnQKIAogdm9pZCBIVE1MSW5wdXRFbGVtZW50Ojpwb3N0RGlzcGF0Y2hFdmVudEhhbmRs ZXIoRXZlbnQgKmV2dCwgdm9pZCogZGF0YSkKIHsKLSAgICBpZiAoKGlucHV0VHlwZSgpID09IENI RUNLQk9YIHx8IGlucHV0VHlwZSgpID09IFJBRElPKSAmJiBldnQtPmlzTW91c2VFdmVudCgpCi0g ICAgICAgICAgICAmJiBldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCAmJiBz dGF0aWNfY2FzdDxNb3VzZUV2ZW50Kj4oZXZ0KS0+YnV0dG9uKCkgPT0gTGVmdEJ1dHRvbikgewor ICAgIGlmICgoaW5wdXRUeXBlKCkgPT0gQ0hFQ0tCT1ggfHwgaW5wdXRUeXBlKCkgPT0gUkFESU8p ICYmIGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50KSB7CiAgICAgICAgIAog ICAgICAgICBpZiAoRXZlbnRIYW5kbGluZ1N0YXRlKiBzdGF0ZSA9IHJlaW50ZXJwcmV0X2Nhc3Q8 RXZlbnRIYW5kbGluZ1N0YXRlKj4oZGF0YSkpIHsKICAgICAgICAgICAgIGlmIChpbnB1dFR5cGUo KSA9PSBDSEVDS0JPWCkgewpAQCAtMjI2NywxMCArMjI2Myw3IEBAIHZvaWQgSFRNTElucHV0RWxl bWVudDo6ZGVmYXVsdEV2ZW50SGFuZGwKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAgIGlm IChpbnB1dFR5cGUoKSA9PSBSQURJTwotICAgICAgICAgICAgJiYgZXZ0LT5pc01vdXNlRXZlbnQo KQotICAgICAgICAgICAgJiYgZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmNsaWNrRXZlbnQK LSAgICAgICAgICAgICYmIHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldnQpLT5idXR0b24oKSA9 PSBMZWZ0QnV0dG9uKSB7CisgICAgaWYgKGlucHV0VHlwZSgpID09IFJBRElPICYmIGV2dC0+dHlw ZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50KSB7CiAgICAgICAgIGV2dC0+c2V0RGVmYXVs dEhhbmRsZWQoKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KSW5kZXg6IFdlYkNvcmUvcGFnZS9F dmVudEhhbmRsZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIu Y3BwCShyZXZpc2lvbiA2NjU2NSkKKysrIFdlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC0xMzc1LDE3ICsxMzc1LDE0IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpo YW5kbGVNb3VzZURvdWJsZUNsaWMKICAgICBtX2NsaWNrQ291bnQgPSBtb3VzZUV2ZW50LmNsaWNr Q291bnQoKTsKICAgICBib29sIHN3YWxsb3dNb3VzZVVwRXZlbnQgPSBkaXNwYXRjaE1vdXNlRXZl bnQoZXZlbnROYW1lcygpLm1vdXNldXBFdmVudCwgbWV2LnRhcmdldE5vZGUoKSwgdHJ1ZSwgbV9j bGlja0NvdW50LCBtb3VzZUV2ZW50LCBmYWxzZSk7CiAKLSAgICBib29sIHN3YWxsb3dDbGlja0V2 ZW50ID0gZmFsc2U7Ci0gICAgLy8gRG9uJ3QgZXZlciBkaXNwYXRjaCBjbGljayBldmVudHMgZm9y IHJpZ2h0IGNsaWNrcwotICAgIGlmIChtb3VzZUV2ZW50LmJ1dHRvbigpICE9IFJpZ2h0QnV0dG9u ICYmIG1ldi50YXJnZXROb2RlKCkgPT0gbV9jbGlja05vZGUpCi0gICAgICAgIHN3YWxsb3dDbGlj a0V2ZW50ID0gZGlzcGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50LCBtZXYu dGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNrQ291bnQsIG1vdXNlRXZlbnQsIHRydWUpOworICAg IGJvb2wgc3dhbGxvd0NsaWNrRXZlbnQgPSBtb3VzZUV2ZW50LmJ1dHRvbigpID09IExlZnRCdXR0 b24KKyAgICAgICAgJiYgbWV2LnRhcmdldE5vZGUoKSA9PSBtX2NsaWNrTm9kZQorICAgICAgICAm JiBkaXNwYXRjaE1vdXNlRXZlbnQoZXZlbnROYW1lcygpLmNsaWNrRXZlbnQsIG1ldi50YXJnZXRO b2RlKCksIHRydWUsIG1fY2xpY2tDb3VudCwgbW91c2VFdmVudCwgdHJ1ZSk7CiAKICAgICBpZiAo bV9sYXN0U2Nyb2xsYmFyVW5kZXJNb3VzZSkKICAgICAgICAgc3dhbGxvd01vdXNlVXBFdmVudCA9 IG1fbGFzdFNjcm9sbGJhclVuZGVyTW91c2UtPm1vdXNlVXAoKTsKLSAgICAgICAgICAgIAotICAg IGJvb2wgc3dhbGxvd01vdXNlUmVsZWFzZUV2ZW50ID0gZmFsc2U7Ci0gICAgaWYgKCFzd2FsbG93 TW91c2VVcEV2ZW50KQotICAgICAgICBzd2FsbG93TW91c2VSZWxlYXNlRXZlbnQgPSBoYW5kbGVN b3VzZVJlbGVhc2VFdmVudChtZXYpOworCisgICAgYm9vbCBzd2FsbG93TW91c2VSZWxlYXNlRXZl bnQgPSAhc3dhbGxvd01vdXNlVXBFdmVudCAmJiBoYW5kbGVNb3VzZVJlbGVhc2VFdmVudChtZXYp OwogCiAgICAgaW52YWxpZGF0ZUNsaWNrKCk7CiAKQEAgLTE1NzEsMTAgKzE1NjgsMTAgQEAgYm9v bCBFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNlUmVsZWFzZUV2ZQogCiAgICAgYm9vbCBzd2FsbG93 TW91c2VVcEV2ZW50ID0gZGlzcGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5tb3VzZXVwRXZl bnQsIG1ldi50YXJnZXROb2RlKCksIHRydWUsIG1fY2xpY2tDb3VudCwgbW91c2VFdmVudCwgZmFs c2UpOwogCi0gICAgLy8gRG9uJ3QgZXZlciBkaXNwYXRjaCBjbGljayBldmVudHMgZm9yIHJpZ2h0 IGNsaWNrcwotICAgIGJvb2wgc3dhbGxvd0NsaWNrRXZlbnQgPSBmYWxzZTsKLSAgICBpZiAobV9j bGlja0NvdW50ID4gMCAmJiBtb3VzZUV2ZW50LmJ1dHRvbigpICE9IFJpZ2h0QnV0dG9uICYmIG1l di50YXJnZXROb2RlKCkgPT0gbV9jbGlja05vZGUpCi0gICAgICAgIHN3YWxsb3dDbGlja0V2ZW50 ID0gZGlzcGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50LCBtZXYudGFyZ2V0 Tm9kZSgpLCB0cnVlLCBtX2NsaWNrQ291bnQsIG1vdXNlRXZlbnQsIHRydWUpOworICAgIGJvb2wg c3dhbGxvd0NsaWNrRXZlbnQgPSBtX2NsaWNrQ291bnQgPiAwCisgICAgICAgICYmIG1vdXNlRXZl bnQuYnV0dG9uKCkgPT0gTGVmdEJ1dHRvbgorICAgICAgICAmJiBtZXYudGFyZ2V0Tm9kZSgpID09 IG1fY2xpY2tOb2RlCisgICAgICAgICYmIGRpc3BhdGNoTW91c2VFdmVudChldmVudE5hbWVzKCku Y2xpY2tFdmVudCwgbWV2LnRhcmdldE5vZGUoKSwgdHJ1ZSwgbV9jbGlja0NvdW50LCBtb3VzZUV2 ZW50LCB0cnVlKTsKIAogICAgIGlmIChtX3Jlc2l6ZUxheWVyKSB7CiAgICAgICAgIG1fcmVzaXpl TGF5ZXItPnNldEluUmVzaXplTW9kZShmYWxzZSk7CkluZGV4OiBXZWJDb3JlL3N2Zy9TVkdBRWxl bWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdmcvU1ZHQUVsZW1lbnQuY3BwCShyZXZp c2lvbiA2NjU2NSkKKysrIFdlYkNvcmUvc3ZnL1NWR0FFbGVtZW50LmNwcAkod29ya2luZyBjb3B5 KQpAQCAtMiw2ICsyLDcgQEAKICAqIENvcHlyaWdodCAoQykgMjAwNCwgMjAwNSwgMjAwOCBOaWtv bGFzIFppbW1lcm1hbm4gPHppbW1lcm1hbm5Aa2RlLm9yZz4KICAqIENvcHlyaWdodCAoQykgMjAw NCwgMjAwNSwgMjAwNyBSb2IgQnVpcyA8YnVpc0BrZGUub3JnPgogICogQ29weXJpZ2h0IChDKSAy MDA3IEVyaWMgU2VpZGVsIDxlcmljQHdlYmtpdC5vcmc+CisgKiBDb3B5cmlnaHQgKEMpIDIwMTAg QXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBm cmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlmeSBp dCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCkBAIC0z Myw2ICszNCw3IEBACiAjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRlci5o IgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyVHlwZXMuaCIKKyNpbmNsdWRlICJIVE1MQW5jaG9yRWxl bWVudC5oIgogI2luY2x1ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJNb3VzZUV2ZW50 LmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1Nb3VzZUV2ZW50LmgiCkBAIC0xMjUsMzkgKzEyNywyOCBA QCBSZW5kZXJPYmplY3QqIFNWR0FFbGVtZW50OjpjcmVhdGVSZW5kZXJlCiAgICAgcmV0dXJuIG5l dyAoYXJlbmEpIFJlbmRlclNWR1RyYW5zZm9ybWFibGVDb250YWluZXIodGhpcyk7CiB9CiAKLXZv aWQgU1ZHQUVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2dCkKK3ZvaWQgU1ZH QUVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2ZW50KQogewotICAgIGlmIChp c0xpbmsoKSAmJiAoZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmNsaWNrRXZlbnQgfHwgKGV2 dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5rZXlkb3duRXZlbnQgJiYgZm9jdXNlZCgpKSkpIHsK LSAgICAgICAgTW91c2VFdmVudCogZSA9IDA7Ci0gICAgICAgIGlmIChldnQtPnR5cGUoKSA9PSBl dmVudE5hbWVzKCkuY2xpY2tFdmVudCAmJiBldnQtPmlzTW91c2VFdmVudCgpKQotICAgICAgICAg ICAgZSA9IHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldnQpOwotICAgICAgICAKLSAgICAgICAg S2V5Ym9hcmRFdmVudCogayA9IDA7Ci0gICAgICAgIGlmIChldnQtPnR5cGUoKSA9PSBldmVudE5h bWVzKCkua2V5ZG93bkV2ZW50ICYmIGV2dC0+aXNLZXlib2FyZEV2ZW50KCkpCi0gICAgICAgICAg ICBrID0gc3RhdGljX2Nhc3Q8S2V5Ym9hcmRFdmVudCo+KGV2dCk7Ci0gICAgICAgIAotICAgICAg ICBpZiAoZSAmJiBlLT5idXR0b24oKSA9PSBSaWdodEJ1dHRvbikgewotICAgICAgICAgICAgU1ZH U3R5bGVkVHJhbnNmb3JtYWJsZUVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoZXZ0KTsKLSAg ICAgICAgICAgIHJldHVybjsKLSAgICAgICAgfQotICAgICAgICAKLSAgICAgICAgaWYgKGspIHsK LSAgICAgICAgICAgIGlmIChrLT5rZXlJZGVudGlmaWVyKCkgIT0gIkVudGVyIikgewotICAgICAg ICAgICAgICAgIFNWR1N0eWxlZFRyYW5zZm9ybWFibGVFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5k bGVyKGV2dCk7Ci0gICAgICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICAgICAgfQotICAgICAg ICAgICAgZXZ0LT5zZXREZWZhdWx0SGFuZGxlZCgpOwotICAgICAgICAgICAgZGlzcGF0Y2hTaW11 bGF0ZWRDbGljayhldnQpOwotICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICB9Ci0gICAgICAg IAorICAgIGlmIChpc0xpbmsoKSAmJiBmb2N1c2VkKCkgJiYgaXNFbnRlcktleUtleWRvd25FdmVu dChldmVudCkpIHsKKyAgICAgICAgZXZlbnQtPnNldERlZmF1bHRIYW5kbGVkKCk7CisgICAgICAg IGRpc3BhdGNoU2ltdWxhdGVkQ2xpY2soZXZlbnQpOworICAgICAgICByZXR1cm47CisgICAgfQor CisgICAgaWYgKGlzTGluaygpICYmIGlzTGlua0NsaWNrKGV2ZW50KSkgewogICAgICAgICBTdHJp bmcgdGFyZ2V0ID0gdGhpcy0+dGFyZ2V0KCk7Ci0gICAgICAgIGlmIChlICYmIGUtPmJ1dHRvbigp ID09IE1pZGRsZUJ1dHRvbikKKworICAgICAgICAvLyBGSVhNRTogV2h5IGRvZXMgdGhlIFNWRyBh bmNob3IgZWxlbWVudCBoYXZlIHRoaXMgc3BlY2lhbCBsb2dpYyBmb3IgbWlkZGxlIGNsaWNrIHRo YXQgdGhlCisgICAgICAgIC8vIEhUTUwgYW5jaG9yIGVsZW1lbnQgZG9lcyBub3QgaGF2ZT8gSXQg c2VlbXMgdGhhdCBlbnN1cmluZyB0aGF0IGEgbWlkZGxlIGNsaWNrIG9wZW5zIHRoZQorICAgICAg ICAvLyBsaW5rIGluIGEgbmV3IHdpbmRvdyBvciB0YWIgaXMgbm9ybWFsbHkgaGFuZGxlZCBhdCB0 aGUgY2xpZW50IGxldmVsIGFuZCB0aGlzIGNvZGUgY2FuCisgICAgICAgIC8vIGp1c3QgYmUgZGVs ZXRlZC4KKyAgICAgICAgaWYgKGlzTWlkZGxlTW91c2VCdXR0b25FdmVudChldmVudCkpCiAgICAg ICAgICAgICB0YXJnZXQgPSAiX2JsYW5rIjsKLSAgICAgICAgZWxzZSBpZiAodGFyZ2V0LmlzRW1w dHkoKSkgLy8gaWYgdGFyZ2V0IGlzIGVtcHR5LCBkZWZhdWx0IHRvICJfc2VsZiIgb3IgdXNlIHhs aW5rOnRhcmdldCBpZiBzZXQKKworICAgICAgICBpZiAodGFyZ2V0LmlzRW1wdHkoKSkgLy8gaWYg dGFyZ2V0IGlzIGVtcHR5LCBkZWZhdWx0IHRvICJfc2VsZiIgb3IgdXNlIHhsaW5rOnRhcmdldCBp ZiBzZXQKICAgICAgICAgICAgIHRhcmdldCA9IChnZXRBdHRyaWJ1dGUoWExpbmtOYW1lczo6c2hv d0F0dHIpID09ICJuZXciKSA/ICJfYmxhbmsiIDogIl9zZWxmIjsKIAotICAgICAgICBpZiAoIWV2 dC0+ZGVmYXVsdFByZXZlbnRlZCgpKSB7CisgICAgICAgIGlmICghZXZlbnQtPmRlZmF1bHRQcmV2 ZW50ZWQoKSkgewogICAgICAgICAgICAgU3RyaW5nIHVybCA9IGRlcHJlY2F0ZWRQYXJzZVVSTCho cmVmKCkpOwogI2lmIEVOQUJMRShTVkdfQU5JTUFUSU9OKQogICAgICAgICAgICAgaWYgKHVybC5z dGFydHNXaXRoKCIjIikpIHsKQEAgLTE2NSwyMCArMTU2LDIwIEBAIHZvaWQgU1ZHQUVsZW1lbnQ6 OmRlZmF1bHRFdmVudEhhbmRsZXIoRXYKICAgICAgICAgICAgICAgICBpZiAoU1ZHU01JTEVsZW1l bnQ6OmlzU01JTEVsZW1lbnQodGFyZ2V0RWxlbWVudCkpIHsKICAgICAgICAgICAgICAgICAgICAg U1ZHU01JTEVsZW1lbnQqIHRpbWVkID0gc3RhdGljX2Nhc3Q8U1ZHU01JTEVsZW1lbnQqPih0YXJn ZXRFbGVtZW50KTsKICAgICAgICAgICAgICAgICAgICAgdGltZWQtPmJlZ2luQnlMaW5rQWN0aXZh dGlvbigpOwotICAgICAgICAgICAgICAgICAgICBldnQtPnNldERlZmF1bHRIYW5kbGVkKCk7Ci0g ICAgICAgICAgICAgICAgICAgIFNWR1N0eWxlZFRyYW5zZm9ybWFibGVFbGVtZW50OjpkZWZhdWx0 RXZlbnRIYW5kbGVyKGV2dCk7CisgICAgICAgICAgICAgICAgICAgIGV2ZW50LT5zZXREZWZhdWx0 SGFuZGxlZCgpOworICAgICAgICAgICAgICAgICAgICBTVkdTdHlsZWRUcmFuc2Zvcm1hYmxlRWxl bWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihldmVudCk7CiAgICAgICAgICAgICAgICAgICAgIHJl dHVybjsKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9CiAjZW5kaWYKICAgICAgICAg ICAgIGlmIChkb2N1bWVudCgpLT5mcmFtZSgpKQotICAgICAgICAgICAgICAgIGRvY3VtZW50KCkt PmZyYW1lKCktPmxvYWRlcigpLT51cmxTZWxlY3RlZChkb2N1bWVudCgpLT5jb21wbGV0ZVVSTCh1 cmwpLCB0YXJnZXQsIGV2dCwgZmFsc2UsIGZhbHNlLCB0cnVlLCBTZW5kUmVmZXJyZXIpOworICAg ICAgICAgICAgICAgIGRvY3VtZW50KCktPmZyYW1lKCktPmxvYWRlcigpLT51cmxTZWxlY3RlZChk b2N1bWVudCgpLT5jb21wbGV0ZVVSTCh1cmwpLCB0YXJnZXQsIGV2ZW50LCBmYWxzZSwgZmFsc2Us IHRydWUsIFNlbmRSZWZlcnJlcik7CiAgICAgICAgIH0KIAotICAgICAgICBldnQtPnNldERlZmF1 bHRIYW5kbGVkKCk7CisgICAgICAgIGV2ZW50LT5zZXREZWZhdWx0SGFuZGxlZCgpOwogICAgIH0K IAotICAgIFNWR1N0eWxlZFRyYW5zZm9ybWFibGVFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVy KGV2dCk7CisgICAgU1ZHU3R5bGVkVHJhbnNmb3JtYWJsZUVsZW1lbnQ6OmRlZmF1bHRFdmVudEhh bmRsZXIoZXZlbnQpOwogfQogCiBib29sIFNWR0FFbGVtZW50OjpzdXBwb3J0c0ZvY3VzKCkgY29u c3QKSW5kZXg6IFdlYkNvcmUvd21sL1dNTEFFbGVtZW50LmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL3dtbC9XTUxBRWxlbWVudC5jcHAJKHJldmlzaW9uIDY2NTY1KQorKysgV2ViQ29yZS93bWwv V01MQUVsZW1lbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00LDcgKzQsNyBAQAogICogQ29weXJp Z2h0IChDKSAxOTk5IExhcnMgS25vbGwgKGtub2xsQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMp IDE5OTkgQW50dGkgS29pdmlzdG8gKGtvaXZpc3RvQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMp IDIwMDAgU2ltb24gSGF1c21hbm4gPGhhdXNtYW5uQGtkZS5vcmc+Ci0gKiBDb3B5cmlnaHQgKEMp IDIwMDMsIDIwMDYsIDIwMDcsIDIwMDggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgor ICogQ29weXJpZ2h0IChDKSAyMDAzLCAyMDA2LCAyMDA3LCAyMDA4LCAyMDEwIEFwcGxlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqICAgICAgICAgICAoQykgMjAwNiBHcmFoYW0gRGVubmlz IChncmFoYW0uZGVubmlzQGdtYWlsLmNvbSkKICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBz b2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCkBAIC0zNSw2ICszNSw3IEBA CiAjaW5jbHVkZSAiRXZlbnROYW1lcy5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAi RnJhbWVMb2FkZXIuaCIKKyNpbmNsdWRlICJIVE1MQW5jaG9yRWxlbWVudC5oIgogI2luY2x1ZGUg IkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJNb3Vz ZUV2ZW50LmgiCkBAIC0xMTksMzEgKzEyMCwxMyBAQCBib29sIFdNTEFFbGVtZW50Ojppc0tleWJv YXJkRm9jdXNhYmxlKEtlCiAKIHZvaWQgV01MQUVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIo RXZlbnQqIGV2ZW50KQogewotICAgIGlmIChpc0xpbmsoKSAmJiAoZXZlbnQtPnR5cGUoKSA9PSBl dmVudE5hbWVzKCkuY2xpY2tFdmVudCB8fCAoZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCku a2V5ZG93bkV2ZW50ICYmIGZvY3VzZWQoKSkpKSB7Ci0gICAgICAgIE1vdXNlRXZlbnQqIGUgPSAw OwotICAgICAgICBpZiAoZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCAm JiBldmVudC0+aXNNb3VzZUV2ZW50KCkpCi0gICAgICAgICAgICBlID0gc3RhdGljX2Nhc3Q8TW91 c2VFdmVudCo+KGV2ZW50KTsKLQotICAgICAgICBLZXlib2FyZEV2ZW50KiBrID0gMDsKLSAgICAg ICAgaWYgKGV2ZW50LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmtleWRvd25FdmVudCAmJiBldmVu dC0+aXNLZXlib2FyZEV2ZW50KCkpCi0gICAgICAgICAgICBrID0gc3RhdGljX2Nhc3Q8S2V5Ym9h cmRFdmVudCo+KGV2ZW50KTsKLQotICAgICAgICBpZiAoZSAmJiBlLT5idXR0b24oKSA9PSBSaWdo dEJ1dHRvbikgewotICAgICAgICAgICAgV01MRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihl dmVudCk7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAgIH0KKyAgICBpZiAoaXNMaW5rKCkg JiYgZm9jdXNlZCgpICYmIGlzRW50ZXJLZXlLZXlkb3duRXZlbnQoZXZlbnQpKSB7CisgICAgICAg IGV2ZW50LT5zZXREZWZhdWx0SGFuZGxlZCgpOworICAgICAgICBkaXNwYXRjaFNpbXVsYXRlZENs aWNrKGV2ZW50KTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KIAotICAgICAgICBpZiAoaykgewot ICAgICAgICAgICAgaWYgKGstPmtleUlkZW50aWZpZXIoKSAhPSAiRW50ZXIiKSB7Ci0gICAgICAg ICAgICAgICAgV01MRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihldmVudCk7Ci0gICAgICAg ICAgICAgICAgcmV0dXJuOwotICAgICAgICAgICAgfQotCi0gICAgICAgICAgICBldmVudC0+c2V0 RGVmYXVsdEhhbmRsZWQoKTsKLSAgICAgICAgICAgIGRpc3BhdGNoU2ltdWxhdGVkQ2xpY2soZXZl bnQpOwotICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICB9Ci0gCisgICAgaWYgKGlzTGluaygp ICYmIGlzTGlua0NsaWNrKGV2ZW50KSkgewogICAgICAgICBpZiAoIWV2ZW50LT5kZWZhdWx0UHJl dmVudGVkKCkgJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKSkgewogICAgICAgICAgICAgS1VSTCB1cmwg PSBkb2N1bWVudCgpLT5jb21wbGV0ZVVSTChkZXByZWNhdGVkUGFyc2VVUkwoZ2V0QXR0cmlidXRl KEhUTUxOYW1lczo6aHJlZkF0dHIpKSk7CiAgICAgICAgICAgICBkb2N1bWVudCgpLT5mcmFtZSgp LT5sb2FkZXIoKS0+dXJsU2VsZWN0ZWQodXJsLCB0YXJnZXQoKSwgZXZlbnQsIGZhbHNlLCBmYWxz ZSwgdHJ1ZSwgU2VuZFJlZmVycmVyKTsK 66793 2010-09-07 17:07:52 -0700 2010-09-10 16:56:18 -0700 Patch bug-22382-20100907170751.patch text/plain 30581 darin SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjkzMykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNjIgQEAKKzIwMTAtMDktMDcgIERhcmluIEFkbGVyICA8ZGFyaW5AYXBwbGUuY29t PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE1pZGRs ZSBjbGljayBmaXJlcyBvbmNsaWNrIGV2ZW50CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yMjM4MgorCisgICAgICAgIFJlc3RydWN0dXJlZCBsaW5rLWNs aWNraW5nIGxvZ2ljIHRvIGNsZWFuIGl0IHVwIGFuZCBoYW5kbGUgbWlkZGxlCisgICAgICAgIG1v dXNlIGJ1dHRvbiBjbGlja3Mgb24gbW91c2V1cCBpbnN0ZWFkIG9mIGNsaWNrLiBUaGVuIHJlbW92 ZWQgdGhlCisgICAgICAgIGNvZGUgdG8gc2VuZCBjbGljayBldmVudHMgZm9yIG1pZGRsZSBjbGlj a3MuCisKKyAgICAgICAgKiBlZGl0aW5nL0RlbGV0ZUJ1dHRvbi5jcHA6CisgICAgICAgIChXZWJD b3JlOjpEZWxldGVCdXR0b246OmRlZmF1bHRFdmVudEhhbmRsZXIpOiBSZW1vdmVkIHVubmVlZGVk CisgICAgICAgIGNvZGUgdG8gY2hlY2sgaWYgdGhlIGV2ZW50IGlzIGEgTW91c2VFdmVudC4gQW55 IGNsaWNrIGV2ZW50IHdpbGwgZG8uCisKKyAgICAgICAgKiBodG1sL0hUTUxBbmNob3JFbGVtZW50 LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmlzTW91c2VFdmVudFdpdGhvdXRTaGlmdEtleURvd24p OiBBZGRlZC4gRmFjdG9ycyBvdXQgYQorICAgICAgICBjaGVjayB0byBtYWtlIHRoZSBsb2dpYyBp biB0aGUgc2hvdWxkRm9sbG93TGluayBmdW5jdGlvbiBjbGVhcmVyLgorICAgICAgICAoV2ViQ29y ZTo6SFRNTEFuY2hvckVsZW1lbnQ6OnNob3VsZEZvbGxvd0xpbmspOiBBZGRlZC4gRmFjdG9ycyBv dXQKKyAgICAgICAgdGhlIHJ1bGVzIGFib3V0IHdoZW4gdG8gZm9sbG93IGEgbGluayBzbyB0aGF0 IHRoZSBkZWZhdWx0IGV2ZW50CisgICAgICAgIGhhbmRsZXIgZnVuY3Rpb24gaXMgZWFzaWVyIHRv IHJlYWQuIE5vIGNoYW5nZSB0byB0aGUgcnVsZS4KKyAgICAgICAgKFdlYkNvcmU6OmFwcGVuZFNl cnZlck1hcE1vdXNlUG9zaXRpb24pOiBBZGRlZC4gRmFjdG9ycyBvdXQgdGhlCisgICAgICAgIG1v ZGlmaWNhdGlvbnMgdG8gdGhlIFVSTCB0byBhZGQgdGhlIG1vdXNlIHBvc2l0aW9uIHRvIG1ha2Ug dGhlCisgICAgICAgIGRlZmF1bHQgZXZlbnQgaGFuZGxlciBmdW5jdGlvbiBlYXNpZXIgdG8gcmVh ZC4KKyAgICAgICAgKFdlYkNvcmU6OkhUTUxBbmNob3JFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5k bGVyKTogUmVvcmdhbml6ZWQKKyAgICAgICAgdG8gbWFrZSB0aGUgZW50ZXIga2V5IGxvZ2ljIHNl cGFyYXRlIGZyb20gdGhlIGxpbmsgY2xpY2tpbmcgbG9naWMuCisgICAgICAgIE5vdyB0aGF0IGNs aWNrcyBhcmUgc2VudCBvbmx5IGJ5IHRoZSBsZWZ0IG1vdXNlIGJ1dHRvbiwgd2FzIGFibGUKKyAg ICAgICAgdG8gcmVtb3ZlIHF1aXRlIGEgZmV3IHJlZHVuZGFudCBjaGVja3MuCisgICAgICAgIChX ZWJDb3JlOjppc0VudGVyS2V5S2V5ZG93bkV2ZW50KTogQWRkZWQuIFNoYXJlZCBieSB0aGUgZGVm YXVsdAorICAgICAgICBldmVudCBoYW5kbGVycyBmb3IgYWxsIHRocmVlIGFuY2hvciBlbGVtZW50 cy4KKyAgICAgICAgKFdlYkNvcmU6OmlzTWlkZGxlTW91c2VCdXR0b25FdmVudCk6IEFkZGVkLiBT aGFyZWQgYnkgdGhlIGlzTGlua0NsaWNrCisgICAgICAgIGZ1bmN0aW9uIGJlbG93IGFuZCBzb21l IGNvZGUgaW4gU1ZHLiBMYXRlciB3ZSBjYW4gbWFrZSB0aGlzIHByaXZhdGUKKyAgICAgICAgdG8g dGhpcyBzb3VyY2UgZmlsZSBvbmNlIHdlIHJlbW92ZSB0aGUgdW5uZWVkZWQgU1ZHIGNvZGUuCisg ICAgICAgIChXZWJDb3JlOjppc0xpbmtDbGljayk6IEFkZGVkLiBTaGFyZWQgYnkgdGhlIGRlZmF1 bHQgZXZlbnQgaGFuZGxlcnMKKyAgICAgICAgZm9yIGFsbCB0aHJlZSBhbmNob3IgZWxlbWVudHMu CisgICAgICAgIChXZWJDb3JlOjpoYW5kbGVMaW5rQ2xpY2spOiBEaXR0by4KKworICAgICAgICAq IGh0bWwvSFRNTEFuY2hvckVsZW1lbnQuaDogQWRkZWQgdGhlIGZvdXIgbmV3IGZ1Y3Rpb25zLgor CisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OkhUTUxJbnB1dEVsZW1lbnQ6OnByZURpc3BhdGNoRXZlbnRIYW5kbGVyKTogUmVtb3ZlZAorICAg ICAgICB1bm5lZWRlZCBjaGVjayB0aGF0IGEgY2xpY2sgZXZlbnQgaXMgY29taW5nIGZyb20gdGhl IGxlZnQgbW91c2UgYnV0dG9uLAorICAgICAgICBzaW5jZSB0aGV5IGFsbCBhcmUgbm93LgorICAg ICAgICAoV2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6cG9zdERpc3BhdGNoRXZlbnRIYW5kbGVy KTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpIVE1MSW5wdXRFbGVtZW50OjpkZWZhdWx0RXZl bnRIYW5kbGVyKTogRGl0dG8uCisKKyAgICAgICAgKiBwYWdlL0V2ZW50SGFuZGxlci5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNlRG91YmxlQ2xpY2tFdmVu dCk6IENoYW5nZWQgbG9naWMgdG8KKyAgICAgICAgc2VuZCBhIGNsaWNrIGV2ZW50IG9ubHkgZm9y IHRoZSBsZWZ0IGJ1dHRvbi4KKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxl TW91c2VSZWxlYXNlRXZlbnQpOiBEaXR0by4KKworICAgICAgICAqIHN2Zy9TVkdBRWxlbWVudC5j cHA6CisgICAgICAgIChXZWJDb3JlOjpTVkdBRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcik6 IFJlbW92ZWQgbG90cyBvZiB1bm5lZWRlZAorICAgICAgICBsb2dpYyBhbmQgc3RyZWFtbGluZWQg dGhlIGNvZGUgdG8gbW9yZSBjbG9zZWx5IG1hdGNoIHRoZSBIVE1MQW5jaG9yRWxlbWVudAorICAg ICAgICBjb2RlIGFuZCBzaGFyZSBmdW5jdGlvbnMgd2l0aCBpdC4KKworICAgICAgICAqIHdtbC9X TUxBRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpXTUxBRWxlbWVudDo6ZGVmYXVsdEV2 ZW50SGFuZGxlcik6IERpdHRvLgorCiAyMDEwLTA5LTA3ICBKYW1lcyBSb2JpbnNvbiAgPGphbWVz ckBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgS2VubmV0aCBSdXNzZWxsLgpJ bmRleDogV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZUJ1dHRvbi5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9lZGl0aW5nL0RlbGV0ZUJ1dHRvbi5jcHAJKHJldmlzaW9uIDY2OTMzKQorKysgV2ViQ29y ZS9lZGl0aW5nL0RlbGV0ZUJ1dHRvbi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTUwLDE0ICs1MCwx MCBAQCBQYXNzUmVmUHRyPERlbGV0ZUJ1dHRvbj4gRGVsZXRlQnV0dG9uOjpjCiAKIHZvaWQgRGVs ZXRlQnV0dG9uOjpkZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldmVudCkKIHsKLSAgICAvLyBG SVhNRTogSXMgaXQgcmVhbGx5IGltcG9ydCB0byBjaGVjayB0aGUgdHlwZSBvZiB0aGUgZXZlbnQ/ Ci0gICAgLy8gU2VlbXMgT0sgdG8gcmVzcG9uZCB0byBhbnkgZXZlbnQgbmFtZWQgY2xpY2sgZXZl biBpZiBpdCBkb2VzIG5vdCBoYXZlIHRoZSBjb3JyZWN0IHR5cGUuCi0gICAgaWYgKGV2ZW50LT5p c01vdXNlRXZlbnQoKSkgewotICAgICAgICBpZiAoZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVz KCkuY2xpY2tFdmVudCkgewotICAgICAgICAgICAgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+ZWRpdG9y KCktPmRlbGV0ZUJ1dHRvbkNvbnRyb2xsZXIoKS0+ZGVsZXRlVGFyZ2V0KCk7Ci0gICAgICAgICAg ICBldmVudC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKLSAgICAgICAgICAgIC8vIEZJWE1FOiBTaG91 bGRuJ3Qgd2UgcmV0dXJuIGhlcmUgaW5zdGVhZCBvZiBmYWxsaW5nIHRocm91Z2g/Ci0gICAgICAg IH0KKyAgICBpZiAoZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCkgewor ICAgICAgICBkb2N1bWVudCgpLT5mcmFtZSgpLT5lZGl0b3IoKS0+ZGVsZXRlQnV0dG9uQ29udHJv bGxlcigpLT5kZWxldGVUYXJnZXQoKTsKKyAgICAgICAgZXZlbnQtPnNldERlZmF1bHRIYW5kbGVk KCk7CisgICAgICAgIHJldHVybjsKICAgICB9CiAKICAgICBIVE1MSW1hZ2VFbGVtZW50OjpkZWZh dWx0RXZlbnRIYW5kbGVyKGV2ZW50KTsKSW5kZXg6IFdlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxl bWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmNw cAkocmV2aXNpb24gNjY5MzMpCisrKyBXZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC0yLDcgKzIsNyBAQAogICogQ29weXJpZ2h0IChDKSAxOTk5IExh cnMgS25vbGwgKGtub2xsQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDE5OTkgQW50dGkgS29p dmlzdG8gKGtvaXZpc3RvQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDIwMDAgU2ltb24gSGF1 c21hbm4gPGhhdXNtYW5uQGtkZS5vcmc+Ci0gKiBDb3B5cmlnaHQgKEMpIDIwMDMsIDIwMDYsIDIw MDcsIDIwMDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJp Z2h0IChDKSAyMDAzLCAyMDA2LCAyMDA3LCAyMDA4LCAyMDA5LCAyMDEwIEFwcGxlIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KICAqICAgICAgICAgICAoQykgMjAwNiBHcmFoYW0gRGVubmlzIChn cmFoYW0uZGVubmlzQGdtYWlsLmNvbSkKICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCkBAIC0xMDUsMTE3ICsxMDUsMTA0 IEBAIGJvb2wgSFRNTEFuY2hvckVsZW1lbnQ6OmlzS2V5Ym9hcmRGb2N1c2EKICAgICByZXR1cm4g aGFzTm9uRW1wdHlCb3VuZGluZ0JveCgpOwogfQogCi12b2lkIEhUTUxBbmNob3JFbGVtZW50Ojpk ZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldnQpCitzdGF0aWMgYm9vbCBpc01vdXNlRXZlbnRX aXRob3V0U2hpZnRLZXlEb3duKEV2ZW50KiBldmVudCkKIHsKLSAgICAvLyBSZWFjdCBvbiBjbGlj a3MgYW5kIG9uIGtleXByZXNzZXMuCi0gICAgLy8gRG9uJ3QgbWFrZSB0aGlzIEtFWVVQX0VWRU5U IGFnYWluLCBpdCBtYWtlcyBraHRtbCBmb2xsb3cgbGlua3MgaXQgc2hvdWxkbid0LAotICAgIC8v IHdoZW4gcHJlc3NpbmcgRW50ZXIgaW4gdGhlIGNvbWJvLgotICAgIGlmIChpc0xpbmsoKSAmJiAo ZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmNsaWNrRXZlbnQgfHwgKGV2dC0+dHlwZSgpID09 IGV2ZW50TmFtZXMoKS5rZXlkb3duRXZlbnQgJiYgZm9jdXNlZCgpKSkpIHsKLSAgICAgICAgTW91 c2VFdmVudCogZSA9IDA7Ci0gICAgICAgIGlmIChldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCku Y2xpY2tFdmVudCAmJiBldnQtPmlzTW91c2VFdmVudCgpKQotICAgICAgICAgICAgZSA9IHN0YXRp Y19jYXN0PE1vdXNlRXZlbnQqPihldnQpOwotCi0gICAgICAgIEtleWJvYXJkRXZlbnQqIGsgPSAw OwotICAgICAgICBpZiAoZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmtleWRvd25FdmVudCAm JiBldnQtPmlzS2V5Ym9hcmRFdmVudCgpKQotICAgICAgICAgICAgayA9IHN0YXRpY19jYXN0PEtl eWJvYXJkRXZlbnQqPihldnQpOworICAgIHJldHVybiBldmVudC0+aXNNb3VzZUV2ZW50KCkKKyAg ICAgICAgJiYgIXN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldmVudCktPnNoaWZ0S2V5KCk7Cit9 CiAKLSAgICAgICAgaWYgKGUgJiYgZS0+YnV0dG9uKCkgPT0gUmlnaHRCdXR0b24pIHsKLSAgICAg ICAgICAgIEhUTUxFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKGV2dCk7Ci0gICAgICAgICAg ICByZXR1cm47Ci0gICAgICAgIH0KK2Jvb2wgSFRNTEFuY2hvckVsZW1lbnQ6OnNob3VsZEZvbGxv d0xpbmsoRXZlbnQqIGV2ZW50KSBjb25zdAoreworICAgIGlmICghaXNDb250ZW50RWRpdGFibGUo KSkKKyAgICAgICAgcmV0dXJuIHRydWU7CiAKLSAgICAgICAgLy8gSWYgdGhlIGxpbmsgaXMgZWRp dGFibGUsIHRoZW4gd2UgbmVlZCB0byBjaGVjayB0aGUgc2V0dGluZ3MgdG8gc2VlIHdoZXRoZXIg b3Igbm90IHRvIGZvbGxvdyB0aGUgbGluawotICAgICAgICBpZiAoaXNDb250ZW50RWRpdGFibGUo KSkgewotICAgICAgICAgICAgRWRpdGFibGVMaW5rQmVoYXZpb3IgZWRpdGFibGVMaW5rQmVoYXZp b3IgPSBFZGl0YWJsZUxpbmtEZWZhdWx0QmVoYXZpb3I7Ci0gICAgICAgICAgICBpZiAoU2V0dGlu Z3MqIHNldHRpbmdzID0gZG9jdW1lbnQoKS0+c2V0dGluZ3MoKSkKLSAgICAgICAgICAgICAgICBl ZGl0YWJsZUxpbmtCZWhhdmlvciA9IHNldHRpbmdzLT5lZGl0YWJsZUxpbmtCZWhhdmlvcigpOwot ICAgICAgICAgICAgICAgIAotICAgICAgICAgICAgc3dpdGNoIChlZGl0YWJsZUxpbmtCZWhhdmlv cikgewotICAgICAgICAgICAgICAgIC8vIEFsd2F5cyBmb2xsb3cgdGhlIGxpbmsgKFNhZmFyaSAy LjAgYmVoYXZpb3IpCi0gICAgICAgICAgICAgICAgZGVmYXVsdDoKLSAgICAgICAgICAgICAgICBj YXNlIEVkaXRhYmxlTGlua0RlZmF1bHRCZWhhdmlvcjoKLSAgICAgICAgICAgICAgICBjYXNlIEVk aXRhYmxlTGlua0Fsd2F5c0xpdmU6Ci0gICAgICAgICAgICAgICAgICAgIGJyZWFrOworICAgIFNl dHRpbmdzKiBzZXR0aW5ncyA9IGRvY3VtZW50KCktPnNldHRpbmdzKCk7CisgICAgaWYgKCFzZXR0 aW5ncykKKyAgICAgICAgcmV0dXJuIHRydWU7CiAKLSAgICAgICAgICAgICAgICBjYXNlIEVkaXRh YmxlTGlua05ldmVyTGl2ZToKLSAgICAgICAgICAgICAgICAgICAgSFRNTEVsZW1lbnQ6OmRlZmF1 bHRFdmVudEhhbmRsZXIoZXZ0KTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuOworICAgIHN3 aXRjaCAoc2V0dGluZ3MtPmVkaXRhYmxlTGlua0JlaGF2aW9yKCkpIHsKKyAgICBjYXNlIEVkaXRh YmxlTGlua0RlZmF1bHRCZWhhdmlvcjoKKyAgICBjYXNlIEVkaXRhYmxlTGlua0Fsd2F5c0xpdmU6 CisgICAgICAgIHJldHVybiB0cnVlOwogCi0gICAgICAgICAgICAgICAgLy8gSWYgdGhlIHNlbGVj dGlvbiBwcmlvciB0byBjbGlja2luZyBvbiB0aGlzIGxpbmsgcmVzaWRlZCBpbiB0aGUgc2FtZSBl ZGl0YWJsZSBibG9jayBhcyB0aGlzIGxpbmssCi0gICAgICAgICAgICAgICAgLy8gYW5kIHRoZSBz aGlmdCBrZXkgaXNuJ3QgcHJlc3NlZCwgd2UgZG9uJ3Qgd2FudCB0byBmb2xsb3cgdGhlIGxpbmsK LSAgICAgICAgICAgICAgICBjYXNlIEVkaXRhYmxlTGlua0xpdmVXaGVuTm90Rm9jdXNlZDoKLSAg ICAgICAgICAgICAgICAgICAgaWYgKGUgJiYgIWUtPnNoaWZ0S2V5KCkgJiYgbV9yb290RWRpdGFi bGVFbGVtZW50Rm9yU2VsZWN0aW9uT25Nb3VzZURvd24gPT0gcm9vdEVkaXRhYmxlRWxlbWVudCgp KSB7Ci0gICAgICAgICAgICAgICAgICAgICAgICBIVE1MRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFu ZGxlcihldnQpOwotICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICAgICAg ICAgICAgICB9Ci0gICAgICAgICAgICAgICAgICAgIGJyZWFrOwotCi0gICAgICAgICAgICAgICAg Ly8gT25seSBmb2xsb3cgdGhlIGxpbmsgaWYgdGhlIHNoaWZ0IGtleSBpcyBkb3duIChXaW5JRS9G aXJlZm94IGJlaGF2aW9yKQotICAgICAgICAgICAgICAgIGNhc2UgRWRpdGFibGVMaW5rT25seUxp dmVXaXRoU2hpZnRLZXk6Ci0gICAgICAgICAgICAgICAgICAgIGlmIChlICYmICFlLT5zaGlmdEtl eSgpKSB7Ci0gICAgICAgICAgICAgICAgICAgICAgICBIVE1MRWxlbWVudDo6ZGVmYXVsdEV2ZW50 SGFuZGxlcihldnQpOwotICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICAg ICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgICAgIGJyZWFrOwotICAgICAgICAgICAgfQot ICAgICAgICB9CisgICAgY2FzZSBFZGl0YWJsZUxpbmtOZXZlckxpdmU6CisgICAgICAgIHJldHVy biBmYWxzZTsKIAotICAgICAgICBpZiAoaykgewotICAgICAgICAgICAgaWYgKGstPmtleUlkZW50 aWZpZXIoKSAhPSAiRW50ZXIiKSB7Ci0gICAgICAgICAgICAgICAgSFRNTEVsZW1lbnQ6OmRlZmF1 bHRFdmVudEhhbmRsZXIoZXZ0KTsKLSAgICAgICAgICAgICAgICByZXR1cm47Ci0gICAgICAgICAg ICB9Ci0gICAgICAgICAgICBldnQtPnNldERlZmF1bHRIYW5kbGVkKCk7Ci0gICAgICAgICAgICBk aXNwYXRjaFNpbXVsYXRlZENsaWNrKGV2dCk7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAg IH0KKyAgICAvLyBJZiB0aGUgc2VsZWN0aW9uIHByaW9yIHRvIGNsaWNraW5nIG9uIHRoaXMgbGlu ayByZXNpZGVkIGluIHRoZSBzYW1lIGVkaXRhYmxlIGJsb2NrIGFzIHRoaXMgbGluaywKKyAgICAv LyBhbmQgdGhlIHNoaWZ0IGtleSBpc24ndCBwcmVzc2VkLCB3ZSBkb24ndCB3YW50IHRvIGZvbGxv dyB0aGUgbGluay4KKyAgICBjYXNlIEVkaXRhYmxlTGlua0xpdmVXaGVuTm90Rm9jdXNlZDoKKyAg ICAgICAgcmV0dXJuICEoaXNNb3VzZUV2ZW50V2l0aG91dFNoaWZ0S2V5RG93bihldmVudCkgJiYg bV9yb290RWRpdGFibGVFbGVtZW50Rm9yU2VsZWN0aW9uT25Nb3VzZURvd24gPT0gcm9vdEVkaXRh YmxlRWxlbWVudCgpKTsKIAotICAgICAgICBTdHJpbmcgdXJsID0gZGVwcmVjYXRlZFBhcnNlVVJM KGdldEF0dHJpYnV0ZShocmVmQXR0cikpOworICAgIGNhc2UgRWRpdGFibGVMaW5rT25seUxpdmVX aXRoU2hpZnRLZXk6CisgICAgICAgIHJldHVybiAhaXNNb3VzZUV2ZW50V2l0aG91dFNoaWZ0S2V5 RG93bihldmVudCk7CisgICAgfQogCi0gICAgICAgIEFTU0VSVChldnQtPnRhcmdldCgpKTsKLSAg ICAgICAgQVNTRVJUKGV2dC0+dGFyZ2V0KCktPnRvTm9kZSgpKTsKLSAgICAgICAgaWYgKGV2dC0+ dGFyZ2V0KCktPnRvTm9kZSgpLT5oYXNUYWdOYW1lKGltZ1RhZykpIHsKLSAgICAgICAgICAgIEhU TUxJbWFnZUVsZW1lbnQqIGltZyA9IHN0YXRpY19jYXN0PEhUTUxJbWFnZUVsZW1lbnQqPihldnQt PnRhcmdldCgpLT50b05vZGUoKSk7Ci0gICAgICAgICAgICBpZiAoaW1nICYmIGltZy0+aXNTZXJ2 ZXJNYXAoKSkgewotICAgICAgICAgICAgICAgIFJlbmRlckltYWdlKiByID0gdG9SZW5kZXJJbWFn ZShpbWctPnJlbmRlcmVyKCkpOwotICAgICAgICAgICAgICAgIGlmIChyICYmIGUpIHsKLSAgICAg ICAgICAgICAgICAgICAgLy8gRklYTUU6IGJyb2tlbiB3aXRoIHRyYW5zZm9ybXMKLSAgICAgICAg ICAgICAgICAgICAgRmxvYXRQb2ludCBhYnNQb3MgPSByLT5sb2NhbFRvQWJzb2x1dGUoKTsKLSAg ICAgICAgICAgICAgICAgICAgaW50IHggPSBlLT5wYWdlWCgpIC0gYWJzUG9zLngoKTsKLSAgICAg ICAgICAgICAgICAgICAgaW50IHkgPSBlLT5wYWdlWSgpIC0gYWJzUG9zLnkoKTsKLSAgICAgICAg ICAgICAgICAgICAgdXJsICs9ICI/IjsKLSAgICAgICAgICAgICAgICAgICAgdXJsICs9IFN0cmlu Zzo6bnVtYmVyKHgpOwotICAgICAgICAgICAgICAgICAgICB1cmwgKz0gIiwiOwotICAgICAgICAg ICAgICAgICAgICB1cmwgKz0gU3RyaW5nOjpudW1iZXIoeSk7Ci0gICAgICAgICAgICAgICAgfSBl bHNlIHsKLSAgICAgICAgICAgICAgICAgICAgZXZ0LT5zZXREZWZhdWx0SGFuZGxlZCgpOwotICAg ICAgICAgICAgICAgICAgICBIVE1MRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihldnQpOwot ICAgICAgICAgICAgICAgICAgICByZXR1cm47Ci0gICAgICAgICAgICAgICAgfQotICAgICAgICAg ICAgfQorICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIHJldHVybiBmYWxzZTsKK30KKwor c3RhdGljIHZvaWQgYXBwZW5kU2VydmVyTWFwTW91c2VQb3NpdGlvbihTdHJpbmcmIHVybCwgRXZl bnQqIGV2ZW50KQoreworICAgIEFTU0VSVChldmVudC0+dGFyZ2V0KCkpOworICAgIE5vZGUqIHRh cmdldCA9IGV2ZW50LT50YXJnZXQoKS0+dG9Ob2RlKCk7CisgICAgQVNTRVJUKHRhcmdldCk7Cisg ICAgaWYgKCF0YXJnZXQtPmhhc1RhZ05hbWUoaW1nVGFnKSkKKyAgICAgICAgcmV0dXJuOworCisg ICAgSFRNTEltYWdlRWxlbWVudCogaW1hZ2VFbGVtZW50ID0gc3RhdGljX2Nhc3Q8SFRNTEltYWdl RWxlbWVudCo+KGV2ZW50LT50YXJnZXQoKS0+dG9Ob2RlKCkpOworICAgIGlmICghaW1hZ2VFbGVt ZW50KQorICAgICAgICByZXR1cm47CisgICAgaWYgKCFpbWFnZUVsZW1lbnQtPmlzU2VydmVyTWFw KCkpCisgICAgICAgIHJldHVybjsKKworICAgIFJlbmRlckltYWdlKiByZW5kZXJlciA9IHRvUmVu ZGVySW1hZ2UoaW1hZ2VFbGVtZW50LT5yZW5kZXJlcigpKTsKKyAgICBpZiAoIXJlbmRlcmVyKQor ICAgICAgICByZXR1cm47CisgICAgaWYgKCFldmVudC0+aXNNb3VzZUV2ZW50KCkpCisgICAgICAg IHJldHVybjsKKworICAgIC8vIEZJWE1FOiBUaGlzIHNob3VsZCBwcm9iYWJseSBwYXNzIHRydWUg Zm9yIHVzZVRyYW5zZm9ybXMuCisgICAgRmxvYXRQb2ludCBhYnNvbHV0ZVBvc2l0aW9uID0gcmVu ZGVyZXItPmFic29sdXRlVG9Mb2NhbChGbG9hdFBvaW50KHN0YXRpY19jYXN0PE1vdXNlRXZlbnQq PihldmVudCktPnBhZ2VYKCksIHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldmVudCktPnBhZ2VZ KCkpKTsKKyAgICBpbnQgeCA9IGFic29sdXRlUG9zaXRpb24ueCgpOworICAgIGludCB5ID0gYWJz b2x1dGVQb3NpdGlvbi55KCk7CisgICAgdXJsICs9ICI/IjsKKyAgICB1cmwgKz0gU3RyaW5nOjpu dW1iZXIoeCk7CisgICAgdXJsICs9ICIsIjsKKyAgICB1cmwgKz0gU3RyaW5nOjpudW1iZXIoeSk7 Cit9CisKK3ZvaWQgSFRNTEFuY2hvckVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQq IGV2ZW50KQoreworICAgIGlmIChpc0xpbmsoKSkgeworICAgICAgICBpZiAoZm9jdXNlZCgpICYm IGlzRW50ZXJLZXlLZXlkb3duRXZlbnQoZXZlbnQpKSB7CisgICAgICAgICAgICBldmVudC0+c2V0 RGVmYXVsdEhhbmRsZWQoKTsKKyAgICAgICAgICAgIGRpc3BhdGNoU2ltdWxhdGVkQ2xpY2soZXZl bnQpOworICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CiAKLSAgICAgICAgaWYgKCFldnQt PmRlZmF1bHRQcmV2ZW50ZWQoKSAmJiBkb2N1bWVudCgpLT5mcmFtZSgpKQotICAgICAgICAgICAg ZG9jdW1lbnQoKS0+ZnJhbWUoKS0+bG9hZGVyKCktPnVybFNlbGVjdGVkKGRvY3VtZW50KCktPmNv bXBsZXRlVVJMKHVybCksIGdldEF0dHJpYnV0ZSh0YXJnZXRBdHRyKSwgZXZ0LCBmYWxzZSwgZmFs c2UsIHRydWUsIGhhc1JlbChSZWxhdGlvbk5vUmVmZXJyZXIpID8gTm9SZWZlcnJlciA6IFNlbmRS ZWZlcnJlcik7CisgICAgICAgIGlmIChpc0xpbmtDbGljayhldmVudCkgJiYgc2hvdWxkRm9sbG93 TGluayhldmVudCkpIHsKKyAgICAgICAgICAgIFN0cmluZyB1cmwgPSBkZXByZWNhdGVkUGFyc2VV UkwoZ2V0QXR0cmlidXRlKGhyZWZBdHRyKSk7CisgICAgICAgICAgICBhcHBlbmRTZXJ2ZXJNYXBN b3VzZVBvc2l0aW9uKHVybCwgZXZlbnQpOworICAgICAgICAgICAgaGFuZGxlTGlua0NsaWNrKGV2 ZW50LCBkb2N1bWVudCgpLCB1cmwsIGdldEF0dHJpYnV0ZSh0YXJnZXRBdHRyKSwgaGFzUmVsKFJl bGF0aW9uTm9SZWZlcnJlcikpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CiAKLSAg ICAgICAgZXZ0LT5zZXREZWZhdWx0SGFuZGxlZCgpOwotICAgIH0gZWxzZSBpZiAoaXNMaW5rKCkg JiYgaXNDb250ZW50RWRpdGFibGUoKSkgewotICAgICAgICAvLyBUaGlzIGtlZXBzIHRyYWNrIG9m IHRoZSBlZGl0YWJsZSBibG9jayB0aGF0IHRoZSBzZWxlY3Rpb24gd2FzIGluIChpZiBpdCB3YXMg aW4gb25lKSBqdXN0IGJlZm9yZSB0aGUgbGluayB3YXMgY2xpY2tlZAotICAgICAgICAvLyBmb3Ig dGhlIExpdmVXaGVuTm90Rm9jdXNlZCBlZGl0YWJsZSBsaW5rIGJlaGF2aW9yCi0gICAgICAgIGlm IChldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkubW91c2Vkb3duRXZlbnQgJiYgZXZ0LT5pc01v dXNlRXZlbnQoKSAmJiBzdGF0aWNfY2FzdDxNb3VzZUV2ZW50Kj4oZXZ0KS0+YnV0dG9uKCkgIT0g UmlnaHRCdXR0b24gJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKSAmJiBkb2N1bWVudCgpLT5mcmFtZSgp LT5zZWxlY3Rpb24oKSkgewotICAgICAgICAgICAgTW91c2VFdmVudCogZSA9IHN0YXRpY19jYXN0 PE1vdXNlRXZlbnQqPihldnQpOwotCi0gICAgICAgICAgICBtX3Jvb3RFZGl0YWJsZUVsZW1lbnRG b3JTZWxlY3Rpb25Pbk1vdXNlRG93biA9IGRvY3VtZW50KCktPmZyYW1lKCktPnNlbGVjdGlvbigp LT5yb290RWRpdGFibGVFbGVtZW50KCk7Ci0gICAgICAgICAgICBtX3dhc1NoaWZ0S2V5RG93bk9u TW91c2VEb3duID0gZSAmJiBlLT5zaGlmdEtleSgpOwotICAgICAgICB9IGVsc2UgaWYgKGV2dC0+ dHlwZSgpID09IGV2ZW50TmFtZXMoKS5tb3VzZW92ZXJFdmVudCkgewotICAgICAgICAgICAgLy8g VGhlc2UgYXJlIGNsZWFyZWQgb24gbW91c2VvdmVyIGFuZCBub3QgbW91c2VvdXQgYmVjYXVzZSB0 aGVpciB2YWx1ZXMgYXJlIG5lZWRlZCBmb3IgZHJhZyBldmVudHMsIGJ1dCB0aGVzZSBoYXBwZW4K LSAgICAgICAgICAgIC8vIGFmdGVyIG1vdXNlIG91dCBldmVudHMuCi0gICAgICAgICAgICBtX3Jv b3RFZGl0YWJsZUVsZW1lbnRGb3JTZWxlY3Rpb25Pbk1vdXNlRG93biA9IDA7Ci0gICAgICAgICAg ICBtX3dhc1NoaWZ0S2V5RG93bk9uTW91c2VEb3duID0gZmFsc2U7CisgICAgICAgIGlmIChpc0Nv bnRlbnRFZGl0YWJsZSgpKSB7CisgICAgICAgICAgICAvLyBUaGlzIGtlZXBzIHRyYWNrIG9mIHRo ZSBlZGl0YWJsZSBibG9jayB0aGF0IHRoZSBzZWxlY3Rpb24gd2FzIGluIChpZiBpdCB3YXMgaW4g b25lKSBqdXN0IGJlZm9yZSB0aGUgbGluayB3YXMgY2xpY2tlZAorICAgICAgICAgICAgLy8gZm9y IHRoZSBMaXZlV2hlbk5vdEZvY3VzZWQgZWRpdGFibGUgbGluayBiZWhhdmlvcgorICAgICAgICAg ICAgaWYgKGV2ZW50LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLm1vdXNlZG93bkV2ZW50ICYmIGV2 ZW50LT5pc01vdXNlRXZlbnQoKSAmJiBzdGF0aWNfY2FzdDxNb3VzZUV2ZW50Kj4oZXZlbnQpLT5i dXR0b24oKSAhPSBSaWdodEJ1dHRvbiAmJiBkb2N1bWVudCgpLT5mcmFtZSgpICYmIGRvY3VtZW50 KCktPmZyYW1lKCktPnNlbGVjdGlvbigpKSB7CisgICAgICAgICAgICAgICAgbV9yb290RWRpdGFi bGVFbGVtZW50Rm9yU2VsZWN0aW9uT25Nb3VzZURvd24gPSBkb2N1bWVudCgpLT5mcmFtZSgpLT5z ZWxlY3Rpb24oKS0+cm9vdEVkaXRhYmxlRWxlbWVudCgpOworICAgICAgICAgICAgICAgIG1fd2Fz U2hpZnRLZXlEb3duT25Nb3VzZURvd24gPSBzdGF0aWNfY2FzdDxNb3VzZUV2ZW50Kj4oZXZlbnQp LT5zaGlmdEtleSgpOworICAgICAgICAgICAgfSBlbHNlIGlmIChldmVudC0+dHlwZSgpID09IGV2 ZW50TmFtZXMoKS5tb3VzZW92ZXJFdmVudCkgeworICAgICAgICAgICAgICAgIC8vIFRoZXNlIGFy ZSBjbGVhcmVkIG9uIG1vdXNlb3ZlciBhbmQgbm90IG1vdXNlb3V0IGJlY2F1c2UgdGhlaXIgdmFs dWVzIGFyZSBuZWVkZWQgZm9yIGRyYWcgZXZlbnRzLAorICAgICAgICAgICAgICAgIC8vIGJ1dCBk cmFnIGV2ZW50cyBoYXBwZW4gYWZ0ZXIgbW91c2Ugb3V0IGV2ZW50cy4KKyAgICAgICAgICAgICAg ICBtX3Jvb3RFZGl0YWJsZUVsZW1lbnRGb3JTZWxlY3Rpb25Pbk1vdXNlRG93biA9IDA7CisgICAg ICAgICAgICAgICAgbV93YXNTaGlmdEtleURvd25Pbk1vdXNlRG93biA9IGZhbHNlOworICAgICAg ICAgICAgfQogICAgICAgICB9CiAgICAgfQogCi0gICAgSFRNTEVsZW1lbnQ6OmRlZmF1bHRFdmVu dEhhbmRsZXIoZXZ0KTsKKyAgICBIVE1MRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihldmVu dCk7CiB9CiAKIHZvaWQgSFRNTEFuY2hvckVsZW1lbnQ6OnNldEFjdGl2ZShib29sIGRvd24sIGJv b2wgcGF1c2UpCkBAIC01NDAsNCArNTI3LDM4IEBAIGJvb2wgSFRNTEFuY2hvckVsZW1lbnQ6Omlz TGl2ZUxpbmsoKSBjb24KICAgICB9CiB9CiAKK2Jvb2wgaXNFbnRlcktleUtleWRvd25FdmVudChF dmVudCogZXZlbnQpCit7CisgICAgcmV0dXJuIGV2ZW50LT50eXBlKCkgPT0gZXZlbnROYW1lcygp LmtleWRvd25FdmVudAorICAgICAgICAmJiBldmVudC0+aXNLZXlib2FyZEV2ZW50KCkKKyAgICAg ICAgJiYgc3RhdGljX2Nhc3Q8S2V5Ym9hcmRFdmVudCo+KGV2ZW50KS0+a2V5SWRlbnRpZmllcigp ID09ICJFbnRlciI7Cit9CisKK2Jvb2wgaXNNaWRkbGVNb3VzZUJ1dHRvbkV2ZW50KEV2ZW50KiBl dmVudCkKK3sKKyAgICByZXR1cm4gZXZlbnQtPmlzTW91c2VFdmVudCgpCisgICAgICAgICYmIHN0 YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldmVudCktPmJ1dHRvbigpID09IDE7Cit9CisKK2Jvb2wg aXNMaW5rQ2xpY2soRXZlbnQqIGV2ZW50KQoreworICAgIHJldHVybiBldmVudC0+dHlwZSgpID09 IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50CisgICAgICAgIHx8IGV2ZW50LT50eXBlKCkgPT0gZXZl bnROYW1lcygpLm1vdXNldXBFdmVudCAmJiBpc01pZGRsZU1vdXNlQnV0dG9uRXZlbnQoZXZlbnQp OworfQorCit2b2lkIGhhbmRsZUxpbmtDbGljayhFdmVudCogZXZlbnQsIERvY3VtZW50KiBkb2N1 bWVudCwgY29uc3QgU3RyaW5nJiB1cmwsIGNvbnN0IFN0cmluZyYgdGFyZ2V0LCBib29sIGhpZGVS ZWZlcnJlcikKK3sKKyAgICBldmVudC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKKworICAgIGlmIChl dmVudC0+ZGVmYXVsdFByZXZlbnRlZCgpKQorICAgICAgICByZXR1cm47CisKKyAgICBGcmFtZSog ZnJhbWUgPSBkb2N1bWVudC0+ZnJhbWUoKTsKKyAgICBpZiAoIWZyYW1lKQorICAgICAgICByZXR1 cm47CisKKyAgICBmcmFtZS0+bG9hZGVyKCktPnVybFNlbGVjdGVkKGRvY3VtZW50LT5jb21wbGV0 ZVVSTCh1cmwpLCB0YXJnZXQsIGV2ZW50LCBmYWxzZSwgZmFsc2UsIHRydWUsCisgICAgICAgIGhp ZGVSZWZlcnJlciA/IE5vUmVmZXJyZXIgOiBTZW5kUmVmZXJyZXIpOworfQorCiB9CkluZGV4OiBX ZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2h0 bWwvSFRNTEFuY2hvckVsZW1lbnQuaAkocmV2aXNpb24gNjY5MzMpCisrKyBXZWJDb3JlL2h0bWwv SFRNTEFuY2hvckVsZW1lbnQuaAkod29ya2luZyBjb3B5KQpAQCAtMiw3ICsyLDcgQEAKICAqIENv cHlyaWdodCAoQykgMTk5OSBMYXJzIEtub2xsIChrbm9sbEBrZGUub3JnKQogICogICAgICAgICAg IChDKSAxOTk5IEFudHRpIEtvaXZpc3RvIChrb2l2aXN0b0BrZGUub3JnKQogICogICAgICAgICAg IChDKSAyMDAwIFNpbW9uIEhhdXNtYW5uIDxoYXVzbWFubkBrZGUub3JnPgotICogQ29weXJpZ2h0 IChDKSAyMDA3LCAyMDA4LCAyMDA5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAq IENvcHlyaWdodCAoQykgMjAwNywgMjAwOCwgMjAwOSwgMjAxMCBBcHBsZSBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBj YW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBv ZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAgLTEwOSwxMSArMTA5LDIwIEBAIHBy aXZhdGU6CiAgICAgdmlydHVhbCBzaG9ydCB0YWJJbmRleCgpIGNvbnN0OwogICAgIHZpcnR1YWwg Ym9vbCBkcmFnZ2FibGUoKSBjb25zdDsKIAorICAgIGJvb2wgc2hvdWxkRm9sbG93TGluayhFdmVu dCopIGNvbnN0OworCiAgICAgUmVmUHRyPEVsZW1lbnQ+IG1fcm9vdEVkaXRhYmxlRWxlbWVudEZv clNlbGVjdGlvbk9uTW91c2VEb3duOwogICAgIGJvb2wgbV93YXNTaGlmdEtleURvd25Pbk1vdXNl RG93bjsKICAgICB1aW50MzJfdCBtX2xpbmtSZWxhdGlvbnM7CiB9OwogCisvLyBGdW5jdGlvbnMg c2hhcmVkIHdpdGggdGhlIG90aGVyIGFuY2hvciBlbGVtZW50cyAoU1ZHIGFuZCBXTUwpLgorCiti b29sIGlzTWlkZGxlTW91c2VCdXR0b25FdmVudChFdmVudCopOworYm9vbCBpc0VudGVyS2V5S2V5 ZG93bkV2ZW50KEV2ZW50Kik7Citib29sIGlzTGlua0NsaWNrKEV2ZW50Kik7Cit2b2lkIGhhbmRs ZUxpbmtDbGljayhFdmVudCosIERvY3VtZW50KiwgY29uc3QgU3RyaW5nJiB1cmwsIGNvbnN0IFN0 cmluZyYgdGFyZ2V0LCBib29sIGhpZGVSZWZlcnJlciA9IGZhbHNlKTsKKwogfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gSFRNTEFuY2hvckVsZW1lbnRfaApJbmRleDogV2ViQ29y ZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaHRtbC9I VE1MSW5wdXRFbGVtZW50LmNwcAkocmV2aXNpb24gNjY5MzMpCisrKyBXZWJDb3JlL2h0bWwvSFRN TElucHV0RWxlbWVudC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTIxNDYsMTYgKzIxNDYsMTMgQEAg c3RydWN0IEV2ZW50SGFuZGxpbmdTdGF0ZSA6IEZhc3RBbGxvY0JhcwogICAgICAgICAsIG1fY2hl Y2tlZChjaGVja2VkKSB7IH0KIH07CiAKLXZvaWQqIEhUTUxJbnB1dEVsZW1lbnQ6OnByZURpc3Bh dGNoRXZlbnRIYW5kbGVyKEV2ZW50ICpldnQpCit2b2lkKiBIVE1MSW5wdXRFbGVtZW50OjpwcmVE aXNwYXRjaEV2ZW50SGFuZGxlcihFdmVudCogZXZ0KQogewogICAgIC8vIHByZXZlbnREZWZhdWx0 IG9yICJyZXR1cm4gZmFsc2UiIGFyZSB1c2VkIHRvIHJldmVyc2UgdGhlIGF1dG9tYXRpYyBjaGVj a2luZy9zZWxlY3Rpb24gd2UgZG8gaGVyZS4KICAgICAvLyBUaGlzIHJlc3VsdCBnaXZlcyB1cyBl bm91Z2ggaW5mbyB0byBwZXJmb3JtIHRoZSAidW5kbyIgaW4gcG9zdERpc3BhdGNoIG9mIHRoZSBh Y3Rpb24gd2UgdGFrZSBoZXJlLgogICAgIHZvaWQqIHJlc3VsdCA9IDA7IAotICAgIGlmICgoaW5w dXRUeXBlKCkgPT0gQ0hFQ0tCT1ggfHwgaW5wdXRUeXBlKCkgPT0gUkFESU8pICYmIGV2dC0+aXNN b3VzZUV2ZW50KCkKLSAgICAgICAgICAgICYmIGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5j bGlja0V2ZW50ICYmIHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldnQpLT5idXR0b24oKSA9PSBM ZWZ0QnV0dG9uKSB7Ci0gICAgICAgIAorICAgIGlmICgoaW5wdXRUeXBlKCkgPT0gQ0hFQ0tCT1gg fHwgaW5wdXRUeXBlKCkgPT0gUkFESU8pICYmIGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5j bGlja0V2ZW50KSB7CiAgICAgICAgIE93blB0cjxFdmVudEhhbmRsaW5nU3RhdGU+IHN0YXRlID0g YWRvcHRQdHIobmV3IEV2ZW50SGFuZGxpbmdTdGF0ZShpbmRldGVybWluYXRlKCksIGNoZWNrZWQo KSkpOwotCiAgICAgICAgIGlmIChpbnB1dFR5cGUoKSA9PSBDSEVDS0JPWCkgewogICAgICAgICAg ICAgaWYgKGluZGV0ZXJtaW5hdGUoKSkKICAgICAgICAgICAgICAgICBzZXRJbmRldGVybWluYXRl KGZhbHNlKTsKQEAgLTIxODMsOCArMjE4MCw3IEBAIHZvaWQqIEhUTUxJbnB1dEVsZW1lbnQ6OnBy ZURpc3BhdGNoRXZlbnQKIAogdm9pZCBIVE1MSW5wdXRFbGVtZW50Ojpwb3N0RGlzcGF0Y2hFdmVu dEhhbmRsZXIoRXZlbnQgKmV2dCwgdm9pZCogZGF0YSkKIHsKLSAgICBpZiAoKGlucHV0VHlwZSgp ID09IENIRUNLQk9YIHx8IGlucHV0VHlwZSgpID09IFJBRElPKSAmJiBldnQtPmlzTW91c2VFdmVu dCgpCi0gICAgICAgICAgICAmJiBldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVu dCAmJiBzdGF0aWNfY2FzdDxNb3VzZUV2ZW50Kj4oZXZ0KS0+YnV0dG9uKCkgPT0gTGVmdEJ1dHRv bikgeworICAgIGlmICgoaW5wdXRUeXBlKCkgPT0gQ0hFQ0tCT1ggfHwgaW5wdXRUeXBlKCkgPT0g UkFESU8pICYmIGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50KSB7CiAgICAg ICAgIAogICAgICAgICBpZiAoRXZlbnRIYW5kbGluZ1N0YXRlKiBzdGF0ZSA9IHJlaW50ZXJwcmV0 X2Nhc3Q8RXZlbnRIYW5kbGluZ1N0YXRlKj4oZGF0YSkpIHsKICAgICAgICAgICAgIGlmIChpbnB1 dFR5cGUoKSA9PSBDSEVDS0JPWCkgewpAQCAtMjI2NywxMCArMjI2Myw3IEBAIHZvaWQgSFRNTElu cHV0RWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGwKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAot ICAgIGlmIChpbnB1dFR5cGUoKSA9PSBSQURJTwotICAgICAgICAgICAgJiYgZXZ0LT5pc01vdXNl RXZlbnQoKQotICAgICAgICAgICAgJiYgZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmNsaWNr RXZlbnQKLSAgICAgICAgICAgICYmIHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldnQpLT5idXR0 b24oKSA9PSBMZWZ0QnV0dG9uKSB7CisgICAgaWYgKGlucHV0VHlwZSgpID09IFJBRElPICYmIGV2 dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50KSB7CiAgICAgICAgIGV2dC0+c2V0 RGVmYXVsdEhhbmRsZWQoKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KSW5kZXg6IFdlYkNvcmUv cGFnZS9FdmVudEhhbmRsZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9FdmVudEhh bmRsZXIuY3BwCShyZXZpc2lvbiA2NjkzMykKKysrIFdlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMzc1LDE3ICsxMzc1LDE0IEBAIGJvb2wgRXZlbnRIYW5k bGVyOjpoYW5kbGVNb3VzZURvdWJsZUNsaWMKICAgICBtX2NsaWNrQ291bnQgPSBtb3VzZUV2ZW50 LmNsaWNrQ291bnQoKTsKICAgICBib29sIHN3YWxsb3dNb3VzZVVwRXZlbnQgPSBkaXNwYXRjaE1v dXNlRXZlbnQoZXZlbnROYW1lcygpLm1vdXNldXBFdmVudCwgbWV2LnRhcmdldE5vZGUoKSwgdHJ1 ZSwgbV9jbGlja0NvdW50LCBtb3VzZUV2ZW50LCBmYWxzZSk7CiAKLSAgICBib29sIHN3YWxsb3dD bGlja0V2ZW50ID0gZmFsc2U7Ci0gICAgLy8gRG9uJ3QgZXZlciBkaXNwYXRjaCBjbGljayBldmVu dHMgZm9yIHJpZ2h0IGNsaWNrcwotICAgIGlmIChtb3VzZUV2ZW50LmJ1dHRvbigpICE9IFJpZ2h0 QnV0dG9uICYmIG1ldi50YXJnZXROb2RlKCkgPT0gbV9jbGlja05vZGUpCi0gICAgICAgIHN3YWxs b3dDbGlja0V2ZW50ID0gZGlzcGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50 LCBtZXYudGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNrQ291bnQsIG1vdXNlRXZlbnQsIHRydWUp OworICAgIGJvb2wgc3dhbGxvd0NsaWNrRXZlbnQgPSBtb3VzZUV2ZW50LmJ1dHRvbigpID09IExl ZnRCdXR0b24KKyAgICAgICAgJiYgbWV2LnRhcmdldE5vZGUoKSA9PSBtX2NsaWNrTm9kZQorICAg ICAgICAmJiBkaXNwYXRjaE1vdXNlRXZlbnQoZXZlbnROYW1lcygpLmNsaWNrRXZlbnQsIG1ldi50 YXJnZXROb2RlKCksIHRydWUsIG1fY2xpY2tDb3VudCwgbW91c2VFdmVudCwgdHJ1ZSk7CiAKICAg ICBpZiAobV9sYXN0U2Nyb2xsYmFyVW5kZXJNb3VzZSkKICAgICAgICAgc3dhbGxvd01vdXNlVXBF dmVudCA9IG1fbGFzdFNjcm9sbGJhclVuZGVyTW91c2UtPm1vdXNlVXAoKTsKLSAgICAgICAgICAg IAotICAgIGJvb2wgc3dhbGxvd01vdXNlUmVsZWFzZUV2ZW50ID0gZmFsc2U7Ci0gICAgaWYgKCFz d2FsbG93TW91c2VVcEV2ZW50KQotICAgICAgICBzd2FsbG93TW91c2VSZWxlYXNlRXZlbnQgPSBo YW5kbGVNb3VzZVJlbGVhc2VFdmVudChtZXYpOworCisgICAgYm9vbCBzd2FsbG93TW91c2VSZWxl YXNlRXZlbnQgPSAhc3dhbGxvd01vdXNlVXBFdmVudCAmJiBoYW5kbGVNb3VzZVJlbGVhc2VFdmVu dChtZXYpOwogCiAgICAgaW52YWxpZGF0ZUNsaWNrKCk7CiAKQEAgLTE1NzEsMTAgKzE1NjgsMTAg QEAgYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNlUmVsZWFzZUV2ZQogCiAgICAgYm9vbCBz d2FsbG93TW91c2VVcEV2ZW50ID0gZGlzcGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5tb3Vz ZXVwRXZlbnQsIG1ldi50YXJnZXROb2RlKCksIHRydWUsIG1fY2xpY2tDb3VudCwgbW91c2VFdmVu dCwgZmFsc2UpOwogCi0gICAgLy8gRG9uJ3QgZXZlciBkaXNwYXRjaCBjbGljayBldmVudHMgZm9y IHJpZ2h0IGNsaWNrcwotICAgIGJvb2wgc3dhbGxvd0NsaWNrRXZlbnQgPSBmYWxzZTsKLSAgICBp ZiAobV9jbGlja0NvdW50ID4gMCAmJiBtb3VzZUV2ZW50LmJ1dHRvbigpICE9IFJpZ2h0QnV0dG9u ICYmIG1ldi50YXJnZXROb2RlKCkgPT0gbV9jbGlja05vZGUpCi0gICAgICAgIHN3YWxsb3dDbGlj a0V2ZW50ID0gZGlzcGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50LCBtZXYu dGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNrQ291bnQsIG1vdXNlRXZlbnQsIHRydWUpOworICAg IGJvb2wgc3dhbGxvd0NsaWNrRXZlbnQgPSBtX2NsaWNrQ291bnQgPiAwCisgICAgICAgICYmIG1v dXNlRXZlbnQuYnV0dG9uKCkgPT0gTGVmdEJ1dHRvbgorICAgICAgICAmJiBtZXYudGFyZ2V0Tm9k ZSgpID09IG1fY2xpY2tOb2RlCisgICAgICAgICYmIGRpc3BhdGNoTW91c2VFdmVudChldmVudE5h bWVzKCkuY2xpY2tFdmVudCwgbWV2LnRhcmdldE5vZGUoKSwgdHJ1ZSwgbV9jbGlja0NvdW50LCBt b3VzZUV2ZW50LCB0cnVlKTsKIAogICAgIGlmIChtX3Jlc2l6ZUxheWVyKSB7CiAgICAgICAgIG1f cmVzaXplTGF5ZXItPnNldEluUmVzaXplTW9kZShmYWxzZSk7CkluZGV4OiBXZWJDb3JlL3N2Zy9T VkdBRWxlbWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdmcvU1ZHQUVsZW1lbnQuY3Bw CShyZXZpc2lvbiA2NjkzMykKKysrIFdlYkNvcmUvc3ZnL1NWR0FFbGVtZW50LmNwcAkod29ya2lu ZyBjb3B5KQpAQCAtMiw2ICsyLDcgQEAKICAqIENvcHlyaWdodCAoQykgMjAwNCwgMjAwNSwgMjAw OCBOaWtvbGFzIFppbW1lcm1hbm4gPHppbW1lcm1hbm5Aa2RlLm9yZz4KICAqIENvcHlyaWdodCAo QykgMjAwNCwgMjAwNSwgMjAwNyBSb2IgQnVpcyA8YnVpc0BrZGUub3JnPgogICogQ29weXJpZ2h0 IChDKSAyMDA3IEVyaWMgU2VpZGVsIDxlcmljQHdlYmtpdC5vcmc+CisgKiBDb3B5cmlnaHQgKEMp IDIwMTAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFRoaXMgbGlicmFy eSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1v ZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGlj CkBAIC0zMyw2ICszNCw3IEBACiAjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJGcmFtZUxv YWRlci5oIgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyVHlwZXMuaCIKKyNpbmNsdWRlICJIVE1MQW5j aG9yRWxlbWVudC5oIgogI2luY2x1ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJNb3Vz ZUV2ZW50LmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1Nb3VzZUV2ZW50LmgiCkBAIC0xMjUsNjAgKzEy Nyw0OCBAQCBSZW5kZXJPYmplY3QqIFNWR0FFbGVtZW50OjpjcmVhdGVSZW5kZXJlCiAgICAgcmV0 dXJuIG5ldyAoYXJlbmEpIFJlbmRlclNWR1RyYW5zZm9ybWFibGVDb250YWluZXIodGhpcyk7CiB9 CiAKLXZvaWQgU1ZHQUVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2dCkKK3Zv aWQgU1ZHQUVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2ZW50KQogewotICAg IGlmIChpc0xpbmsoKSAmJiAoZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmNsaWNrRXZlbnQg fHwgKGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5rZXlkb3duRXZlbnQgJiYgZm9jdXNlZCgp KSkpIHsKLSAgICAgICAgTW91c2VFdmVudCogZSA9IDA7Ci0gICAgICAgIGlmIChldnQtPnR5cGUo KSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCAmJiBldnQtPmlzTW91c2VFdmVudCgpKQotICAg ICAgICAgICAgZSA9IHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldnQpOwotICAgICAgICAKLSAg ICAgICAgS2V5Ym9hcmRFdmVudCogayA9IDA7Ci0gICAgICAgIGlmIChldnQtPnR5cGUoKSA9PSBl dmVudE5hbWVzKCkua2V5ZG93bkV2ZW50ICYmIGV2dC0+aXNLZXlib2FyZEV2ZW50KCkpCi0gICAg ICAgICAgICBrID0gc3RhdGljX2Nhc3Q8S2V5Ym9hcmRFdmVudCo+KGV2dCk7Ci0gICAgICAgIAot ICAgICAgICBpZiAoZSAmJiBlLT5idXR0b24oKSA9PSBSaWdodEJ1dHRvbikgewotICAgICAgICAg ICAgU1ZHU3R5bGVkVHJhbnNmb3JtYWJsZUVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoZXZ0 KTsKKyAgICBpZiAoaXNMaW5rKCkpIHsKKyAgICAgICAgaWYgKGZvY3VzZWQoKSAmJiBpc0VudGVy S2V5S2V5ZG93bkV2ZW50KGV2ZW50KSkgeworICAgICAgICAgICAgZXZlbnQtPnNldERlZmF1bHRI YW5kbGVkKCk7CisgICAgICAgICAgICBkaXNwYXRjaFNpbXVsYXRlZENsaWNrKGV2ZW50KTsKICAg ICAgICAgICAgIHJldHVybjsKICAgICAgICAgfQotICAgICAgICAKLSAgICAgICAgaWYgKGspIHsK LSAgICAgICAgICAgIGlmIChrLT5rZXlJZGVudGlmaWVyKCkgIT0gIkVudGVyIikgewotICAgICAg ICAgICAgICAgIFNWR1N0eWxlZFRyYW5zZm9ybWFibGVFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5k bGVyKGV2dCk7Ci0gICAgICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICAgICAgfQotICAgICAg ICAgICAgZXZ0LT5zZXREZWZhdWx0SGFuZGxlZCgpOwotICAgICAgICAgICAgZGlzcGF0Y2hTaW11 bGF0ZWRDbGljayhldnQpOwotICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICB9Ci0gICAgICAg IAotICAgICAgICBTdHJpbmcgdGFyZ2V0ID0gdGhpcy0+dGFyZ2V0KCk7Ci0gICAgICAgIGlmIChl ICYmIGUtPmJ1dHRvbigpID09IE1pZGRsZUJ1dHRvbikKLSAgICAgICAgICAgIHRhcmdldCA9ICJf YmxhbmsiOwotICAgICAgICBlbHNlIGlmICh0YXJnZXQuaXNFbXB0eSgpKSAvLyBpZiB0YXJnZXQg aXMgZW1wdHksIGRlZmF1bHQgdG8gIl9zZWxmIiBvciB1c2UgeGxpbms6dGFyZ2V0IGlmIHNldAot ICAgICAgICAgICAgdGFyZ2V0ID0gKGdldEF0dHJpYnV0ZShYTGlua05hbWVzOjpzaG93QXR0cikg PT0gIm5ldyIpID8gIl9ibGFuayIgOiAiX3NlbGYiOwogCi0gICAgICAgIGlmICghZXZ0LT5kZWZh dWx0UHJldmVudGVkKCkpIHsKKyAgICAgICAgaWYgKGlzTGlua0NsaWNrKGV2ZW50KSkgewogICAg ICAgICAgICAgU3RyaW5nIHVybCA9IGRlcHJlY2F0ZWRQYXJzZVVSTChocmVmKCkpOwotI2lmIEVO QUJMRShTVkdfQU5JTUFUSU9OKQotICAgICAgICAgICAgaWYgKHVybC5zdGFydHNXaXRoKCIjIikp IHsKKworICAgICNpZiBFTkFCTEUoU1ZHX0FOSU1BVElPTikKKyAgICAgICAgICAgIGlmICh1cmxb MF0gPT0gJyMnKSB7CiAgICAgICAgICAgICAgICAgRWxlbWVudCogdGFyZ2V0RWxlbWVudCA9IGRv Y3VtZW50KCktPmdldEVsZW1lbnRCeUlkKHVybC5zdWJzdHJpbmcoMSkpOwogICAgICAgICAgICAg ICAgIGlmIChTVkdTTUlMRWxlbWVudDo6aXNTTUlMRWxlbWVudCh0YXJnZXRFbGVtZW50KSkgewog ICAgICAgICAgICAgICAgICAgICBTVkdTTUlMRWxlbWVudCogdGltZWQgPSBzdGF0aWNfY2FzdDxT VkdTTUlMRWxlbWVudCo+KHRhcmdldEVsZW1lbnQpOwogICAgICAgICAgICAgICAgICAgICB0aW1l ZC0+YmVnaW5CeUxpbmtBY3RpdmF0aW9uKCk7Ci0gICAgICAgICAgICAgICAgICAgIGV2dC0+c2V0 RGVmYXVsdEhhbmRsZWQoKTsKLSAgICAgICAgICAgICAgICAgICAgU1ZHU3R5bGVkVHJhbnNmb3Jt YWJsZUVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoZXZ0KTsKKyAgICAgICAgICAgICAgICAg ICAgZXZlbnQtPnNldERlZmF1bHRIYW5kbGVkKCk7CiAgICAgICAgICAgICAgICAgICAgIHJldHVy bjsKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9Ci0jZW5kaWYKLSAgICAgICAgICAg IGlmIChkb2N1bWVudCgpLT5mcmFtZSgpKQotICAgICAgICAgICAgICAgIGRvY3VtZW50KCktPmZy YW1lKCktPmxvYWRlcigpLT51cmxTZWxlY3RlZChkb2N1bWVudCgpLT5jb21wbGV0ZVVSTCh1cmwp LCB0YXJnZXQsIGV2dCwgZmFsc2UsIGZhbHNlLCB0cnVlLCBTZW5kUmVmZXJyZXIpOwotICAgICAg ICB9CisgICAgI2VuZGlmCiAKLSAgICAgICAgZXZ0LT5zZXREZWZhdWx0SGFuZGxlZCgpOworICAg ICAgICAgICAgU3RyaW5nIHRhcmdldCA9IHRoaXMtPnRhcmdldCgpOworCisgICAgICAgICAgICAv LyBGSVhNRTogV2h5IGRvZXMgdGhlIFNWRyBhbmNob3IgZWxlbWVudCBoYXZlIHRoaXMgc3BlY2lh bCBsb2dpYyBmb3IgbWlkZGxlIGNsaWNrIHRoYXQgdGhlCisgICAgICAgICAgICAvLyBIVE1MIGFu Y2hvciBlbGVtZW50IGRvZXMgbm90IGhhdmU/IE1ha2luZyBhIG1pZGRsZSBjbGljayBvcGVuIGEg bGluayBpbiBhIG5ldyB3aW5kb3cgb3IgdGFiCisgICAgICAgICAgICAvLyBpcyBwcm9wZXJseSBo YW5kbGVkIGF0IHRoZSBjbGllbnQgbGV2ZWwsIG5vdCBpbnNpZGUgV2ViS2l0OyB0aGlzIGNvZGUg c2hvdWxkIGJlIGRlbGV0ZWQuCisgICAgICAgICAgICBpZiAoaXNNaWRkbGVNb3VzZUJ1dHRvbkV2 ZW50KGV2ZW50KSkKKyAgICAgICAgICAgICAgICB0YXJnZXQgPSAiX2JsYW5rIjsKKworICAgICAg ICAgICAgLy8gRklYTUU6IEl0J3Mgbm90IGNsZWFyIHdoeSBzZXR0aW5nIHRhcmdldCB0byAiX3Nl bGYiIGlzIGV2ZXIgaGVscGZ1bC4KKyAgICAgICAgICAgIGlmICh0YXJnZXQuaXNFbXB0eSgpKQor ICAgICAgICAgICAgICAgIHRhcmdldCA9IChnZXRBdHRyaWJ1dGUoWExpbmtOYW1lczo6c2hvd0F0 dHIpID09ICJuZXciKSA/ICJfYmxhbmsiIDogIl9zZWxmIjsKKworICAgICAgICAgICAgaGFuZGxl TGlua0NsaWNrKGV2ZW50LCBkb2N1bWVudCgpLCB1cmwsIHRhcmdldCk7CisgICAgICAgICAgICBy ZXR1cm47CisgICAgICAgIH0KICAgICB9CiAKLSAgICBTVkdTdHlsZWRUcmFuc2Zvcm1hYmxlRWxl bWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihldnQpOworICAgIFNWR1N0eWxlZFRyYW5zZm9ybWFi bGVFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKGV2ZW50KTsKIH0KIAogYm9vbCBTVkdBRWxl bWVudDo6c3VwcG9ydHNGb2N1cygpIGNvbnN0CkluZGV4OiBXZWJDb3JlL3dtbC9XTUxBRWxlbWVu dC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS93bWwvV01MQUVsZW1lbnQuY3BwCShyZXZpc2lv biA2NjkzMykKKysrIFdlYkNvcmUvd21sL1dNTEFFbGVtZW50LmNwcAkod29ya2luZyBjb3B5KQpA QCAtNCw3ICs0LDcgQEAKICAqIENvcHlyaWdodCAoQykgMTk5OSBMYXJzIEtub2xsIChrbm9sbEBr ZGUub3JnKQogICogICAgICAgICAgIChDKSAxOTk5IEFudHRpIEtvaXZpc3RvIChrb2l2aXN0b0Br ZGUub3JnKQogICogICAgICAgICAgIChDKSAyMDAwIFNpbW9uIEhhdXNtYW5uIDxoYXVzbWFubkBr ZGUub3JnPgotICogQ29weXJpZ2h0IChDKSAyMDAzLCAyMDA2LCAyMDA3LCAyMDA4IEFwcGxlIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAwMywgMjAwNiwgMjAw NywgMjAwOCwgMjAxMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKiAgICAgICAg ICAgKEMpIDIwMDYgR3JhaGFtIERlbm5pcyAoZ3JhaGFtLmRlbm5pc0BnbWFpbC5jb20pCiAgKgog ICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgpAQCAtMzUsNiArMzUsNyBAQAogI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKICNpbmNs dWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyLmgiCisjaW5jbHVkZSAiSFRNTEFu Y2hvckVsZW1lbnQuaCIKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKICNpbmNsdWRlICJLZXlib2Fy ZEV2ZW50LmgiCiAjaW5jbHVkZSAiTW91c2VFdmVudC5oIgpAQCAtMTE5LDM3ICsxMjAsMTcgQEAg Ym9vbCBXTUxBRWxlbWVudDo6aXNLZXlib2FyZEZvY3VzYWJsZShLZQogCiB2b2lkIFdNTEFFbGVt ZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldmVudCkKIHsKLSAgICBpZiAoaXNMaW5r KCkgJiYgKGV2ZW50LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmNsaWNrRXZlbnQgfHwgKGV2ZW50 LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmtleWRvd25FdmVudCAmJiBmb2N1c2VkKCkpKSkgewot ICAgICAgICBNb3VzZUV2ZW50KiBlID0gMDsKLSAgICAgICAgaWYgKGV2ZW50LT50eXBlKCkgPT0g ZXZlbnROYW1lcygpLmNsaWNrRXZlbnQgJiYgZXZlbnQtPmlzTW91c2VFdmVudCgpKQotICAgICAg ICAgICAgZSA9IHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldmVudCk7Ci0KLSAgICAgICAgS2V5 Ym9hcmRFdmVudCogayA9IDA7Ci0gICAgICAgIGlmIChldmVudC0+dHlwZSgpID09IGV2ZW50TmFt ZXMoKS5rZXlkb3duRXZlbnQgJiYgZXZlbnQtPmlzS2V5Ym9hcmRFdmVudCgpKQotICAgICAgICAg ICAgayA9IHN0YXRpY19jYXN0PEtleWJvYXJkRXZlbnQqPihldmVudCk7Ci0KLSAgICAgICAgaWYg KGUgJiYgZS0+YnV0dG9uKCkgPT0gUmlnaHRCdXR0b24pIHsKLSAgICAgICAgICAgIFdNTEVsZW1l bnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoZXZlbnQpOwotICAgICAgICAgICAgcmV0dXJuOwotICAg ICAgICB9Ci0KLSAgICAgICAgaWYgKGspIHsKLSAgICAgICAgICAgIGlmIChrLT5rZXlJZGVudGlm aWVyKCkgIT0gIkVudGVyIikgewotICAgICAgICAgICAgICAgIFdNTEVsZW1lbnQ6OmRlZmF1bHRF dmVudEhhbmRsZXIoZXZlbnQpOwotICAgICAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgICAg IH0KLQorICAgIGlmIChpc0xpbmsoKSkgeworICAgICAgICBpZiAoZm9jdXNlZCgpICYmIGlzRW50 ZXJLZXlLZXlkb3duRXZlbnQoZXZlbnQpKSB7CiAgICAgICAgICAgICBldmVudC0+c2V0RGVmYXVs dEhhbmRsZWQoKTsKICAgICAgICAgICAgIGRpc3BhdGNoU2ltdWxhdGVkQ2xpY2soZXZlbnQpOwog ICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9Ci0gCi0gICAgICAgIGlmICghZXZlbnQtPmRl ZmF1bHRQcmV2ZW50ZWQoKSAmJiBkb2N1bWVudCgpLT5mcmFtZSgpKSB7Ci0gICAgICAgICAgICBL VVJMIHVybCA9IGRvY3VtZW50KCktPmNvbXBsZXRlVVJMKGRlcHJlY2F0ZWRQYXJzZVVSTChnZXRB dHRyaWJ1dGUoSFRNTE5hbWVzOjpocmVmQXR0cikpKTsKLSAgICAgICAgICAgIGRvY3VtZW50KCkt PmZyYW1lKCktPmxvYWRlcigpLT51cmxTZWxlY3RlZCh1cmwsIHRhcmdldCgpLCBldmVudCwgZmFs c2UsIGZhbHNlLCB0cnVlLCBTZW5kUmVmZXJyZXIpOwotICAgICAgICB9CiAKLSAgICAgICAgZXZl bnQtPnNldERlZmF1bHRIYW5kbGVkKCk7CisgICAgICAgIGlmIChpc0xpbmtDbGljayhldmVudCkp IHsKKyAgICAgICAgICAgIGhhbmRsZUxpbmtDbGljayhkb2N1bWVudCgpLCBkZXByZWNhdGVkUGFy c2VVUkwoZ2V0QXR0cmlidXRlKEhUTUxOYW1lczo6aHJlZkF0dHIpKSwgdGFyZ2V0KCksIGV2ZW50 KTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQogICAgIH0KIAogICAgIFdNTEVsZW1l bnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoZXZlbnQpOwpJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gNjY5MzMp CisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNCBA QAorMjAxMC0wOS0wNyAgRGFyaW4gQWRsZXIgIDxkYXJpbkBhcHBsZS5jb20+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWlkZGxlIGNsaWNrIGZpcmVz IG9uY2xpY2sgZXZlbnQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTIyMzgyCisKKyAgICAgICAgKiBmYXN0L2V2ZW50cy9tb3VzZS1jbGljay1ldmVudHMt ZXhwZWN0ZWQudHh0OiBVcGRhdGVkLgorICAgICAgICAqIGZhc3QvZXZlbnRzL3NjcmlwdC10ZXN0 cy9tb3VzZS1jbGljay1ldmVudHMuanM6IFVwZGF0ZWQgdG8gZXhwZWN0CisgICAgICAgIGNsaWNr IGV2ZW50cyBvbmx5IGZvciB0aGUgbGVmdCBtb3VzZSBidXR0b24uCisKIDIwMTAtMDktMDcgIFRv bnkgQ2hhbmcgIDx0b255QGNocm9taXVtLm9yZz4KIAogICAgICAgICBVbnJldmlld2VkLCB1cGRh dGluZyBjaHJvbWl1bSBsaW51eCB0ZXN0IGV4cGVjdGF0aW9ucy4KSW5kZXg6IExheW91dFRlc3Rz L2Zhc3QvZXZlbnRzL21vdXNlLWNsaWNrLWV2ZW50cy1leHBlY3RlZC50eHQKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvbW91c2UtY2xpY2stZXZlbnRzLWV4cGVjdGVkLnR4 dAkocmV2aXNpb24gNjY5MzMpCisrKyBMYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9tb3VzZS1jbGlj ay1ldmVudHMtZXhwZWN0ZWQudHh0CSh3b3JraW5nIGNvcHkpCkBAIC02LDExICs2LDExIEBAIE9u IHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEEKIExlZnQgTW91c2UgQnV0dG9u CiBQQVNTIGV2ZW50TG9nIGlzICJtb3VzZWRvd24oMCkgbW91c2V1cCgwKSBjbGljaygwKSBtb3Vz ZWRvd24oMCkgbW91c2V1cCgwKSBjbGljaygwKSBkYmxjbGljaygwKSAiCiBNaWRkbGUgTW91c2Ug QnV0dG9uCi1QQVNTIGV2ZW50TG9nIGlzICJtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBjbGljaygx KSBtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBjbGljaygxKSBkYmxjbGljaygxKSAiCitQQVNTIGV2 ZW50TG9nIGlzICJtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBtb3VzZWRvd24oMSkgbW91c2V1cCgx KSAiCiBSaWdodCBNb3VzZSBCdXR0b24KIFBBU1MgZXZlbnRMb2cgaXMgIm1vdXNlZG93bigyKSBt b3VzZXVwKDIpIG1vdXNlZG93bigyKSBtb3VzZXVwKDIpICIKIDR0aCBNb3VzZSBCdXR0b24KLVBB U1MgZXZlbnRMb2cgaXMgIm1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGNsaWNrKDEpIG1vdXNlZG93 bigxKSBtb3VzZXVwKDEpIGNsaWNrKDEpIGRibGNsaWNrKDEpICIKK1BBU1MgZXZlbnRMb2cgaXMg Im1vdXNlZG93bigxKSBtb3VzZXVwKDEpIG1vdXNlZG93bigxKSBtb3VzZXVwKDEpICIKIFBBU1Mg c3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKIAogVEVTVCBDT01QTEVURQpJbmRleDogTGF5b3V0 VGVzdHMvZmFzdC9ldmVudHMvc2NyaXB0LXRlc3RzL21vdXNlLWNsaWNrLWV2ZW50cy5qcwo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9zY3JpcHQtdGVzdHMvbW91c2UtY2xp Y2stZXZlbnRzLmpzCShyZXZpc2lvbiA2NjkzMykKKysrIExheW91dFRlc3RzL2Zhc3QvZXZlbnRz L3NjcmlwdC10ZXN0cy9tb3VzZS1jbGljay1ldmVudHMuanMJKHdvcmtpbmcgY29weSkKQEAgLTQ5 LDkgKzQ5LDkgQEAgZnVuY3Rpb24gdGVzdEV2ZW50cyhkZXNjcmlwdGlvbiwgYnV0dG9uLAogCiBp ZiAod2luZG93LmV2ZW50U2VuZGVyKSB7CiAgICAgdGVzdEV2ZW50cygiTGVmdCBNb3VzZSBCdXR0 b24iLCAwLCAibW91c2Vkb3duKDApIG1vdXNldXAoMCkgY2xpY2soMCkgbW91c2Vkb3duKDApIG1v dXNldXAoMCkgY2xpY2soMCkgZGJsY2xpY2soMCkgIik7Ci0gICAgdGVzdEV2ZW50cygiTWlkZGxl IE1vdXNlIEJ1dHRvbiIsIDEsICJtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBjbGljaygxKSBtb3Vz ZWRvd24oMSkgbW91c2V1cCgxKSBjbGljaygxKSBkYmxjbGljaygxKSAiKTsKKyAgICB0ZXN0RXZl bnRzKCJNaWRkbGUgTW91c2UgQnV0dG9uIiwgMSwgIm1vdXNlZG93bigxKSBtb3VzZXVwKDEpIG1v dXNlZG93bigxKSBtb3VzZXVwKDEpICIpOwogICAgIHRlc3RFdmVudHMoIlJpZ2h0IE1vdXNlIEJ1 dHRvbiIsIDIsICJtb3VzZWRvd24oMikgbW91c2V1cCgyKSBtb3VzZWRvd24oMikgbW91c2V1cCgy KSAiKTsKLSAgICB0ZXN0RXZlbnRzKCI0dGggTW91c2UgQnV0dG9uIiwgMywgIm1vdXNlZG93bigx KSBtb3VzZXVwKDEpIGNsaWNrKDEpIG1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGNsaWNrKDEpIGRi bGNsaWNrKDEpICIpOworICAgIHRlc3RFdmVudHMoIjR0aCBNb3VzZSBCdXR0b24iLCAzLCAibW91 c2Vkb3duKDEpIG1vdXNldXAoMSkgbW91c2Vkb3duKDEpIG1vdXNldXAoMSkgIik7CiB9CiAKIHZh ciBzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOwo= 67124 2010-09-09 17:37:49 -0700 2010-09-10 13:10:36 -0700 patch, cleanup portion, v1 patch text/plain 21616 pkasting SW5kZXg6IFdlYkNvcmUvZWRpdGluZy9EZWxldGVCdXR0b24uY3BwCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvZWRpdGluZy9EZWxldGVCdXR0b24uY3BwCShyZXZpc2lvbiA2NzEyOCkKKysrIFdlYkNv cmUvZWRpdGluZy9EZWxldGVCdXR0b24uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01MCwxNyArNTAs MTIgQEAgUGFzc1JlZlB0cjxEZWxldGVCdXR0b24+IERlbGV0ZUJ1dHRvbjo6YwogCiB2b2lkIERl bGV0ZUJ1dHRvbjo6ZGVmYXVsdEV2ZW50SGFuZGxlcihFdmVudCogZXZlbnQpCiB7Ci0gICAgLy8g RklYTUU6IElzIGl0IHJlYWxseSBpbXBvcnQgdG8gY2hlY2sgdGhlIHR5cGUgb2YgdGhlIGV2ZW50 PwotICAgIC8vIFNlZW1zIE9LIHRvIHJlc3BvbmQgdG8gYW55IGV2ZW50IG5hbWVkIGNsaWNrIGV2 ZW4gaWYgaXQgZG9lcyBub3QgaGF2ZSB0aGUgY29ycmVjdCB0eXBlLgotICAgIGlmIChldmVudC0+ aXNNb3VzZUV2ZW50KCkpIHsKLSAgICAgICAgaWYgKGV2ZW50LT50eXBlKCkgPT0gZXZlbnROYW1l cygpLmNsaWNrRXZlbnQpIHsKLSAgICAgICAgICAgIGRvY3VtZW50KCktPmZyYW1lKCktPmVkaXRv cigpLT5kZWxldGVCdXR0b25Db250cm9sbGVyKCktPmRlbGV0ZVRhcmdldCgpOwotICAgICAgICAg ICAgZXZlbnQtPnNldERlZmF1bHRIYW5kbGVkKCk7Ci0gICAgICAgICAgICAvLyBGSVhNRTogU2hv dWxkbid0IHdlIHJldHVybiBoZXJlIGluc3RlYWQgb2YgZmFsbGluZyB0aHJvdWdoPwotICAgICAg ICB9CisgICAgaWYgKGV2ZW50LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmNsaWNrRXZlbnQpIHsK KyAgICAgICAgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+ZWRpdG9yKCktPmRlbGV0ZUJ1dHRvbkNvbnRy b2xsZXIoKS0+ZGVsZXRlVGFyZ2V0KCk7CisgICAgICAgIGV2ZW50LT5zZXREZWZhdWx0SGFuZGxl ZCgpOworICAgIH0gZWxzZSB7CisgICAgICAgIEhUTUxJbWFnZUVsZW1lbnQ6OmRlZmF1bHRFdmVu dEhhbmRsZXIoZXZlbnQpOwogICAgIH0KLQotICAgIEhUTUxJbWFnZUVsZW1lbnQ6OmRlZmF1bHRF dmVudEhhbmRsZXIoZXZlbnQpOwogfQogCiB9IC8vIG5hbWVzcGFjZQpJbmRleDogV2ViQ29yZS9o dG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2h0bWwvSFRN TEFuY2hvckVsZW1lbnQuY3BwCShyZXZpc2lvbiA2NzEyOCkKKysrIFdlYkNvcmUvaHRtbC9IVE1M QW5jaG9yRWxlbWVudC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTIsNyArMiw3IEBACiAgKiBDb3B5 cmlnaHQgKEMpIDE5OTkgTGFycyBLbm9sbCAoa25vbGxAa2RlLm9yZykKICAqICAgICAgICAgICAo QykgMTk5OSBBbnR0aSBLb2l2aXN0byAoa29pdmlzdG9Aa2RlLm9yZykKICAqICAgICAgICAgICAo QykgMjAwMCBTaW1vbiBIYXVzbWFubiA8aGF1c21hbm5Aa2RlLm9yZz4KLSAqIENvcHlyaWdodCAo QykgMjAwMywgMjAwNiwgMjAwNywgMjAwOCwgMjAwOSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDMsIDIwMDYsIDIwMDcsIDIwMDgsIDIwMDksIDIw MTAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICogICAgICAgICAgIChDKSAyMDA2 IEdyYWhhbSBEZW5uaXMgKGdyYWhhbS5kZW5uaXNAZ21haWwuY29tKQogICoKICAqIFRoaXMgbGli cmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKQEAg LTEwNSwxMTcgKzEwNSw2NyBAQCBib29sIEhUTUxBbmNob3JFbGVtZW50Ojppc0tleWJvYXJkRm9j dXNhCiAgICAgcmV0dXJuIGhhc05vbkVtcHR5Qm91bmRpbmdCb3goKTsKIH0KIAotdm9pZCBIVE1M QW5jaG9yRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihFdmVudCogZXZ0KQorc3RhdGljIHZv aWQgYXBwZW5kU2VydmVyTWFwTW91c2VQb3NpdGlvbihTdHJpbmcmIHVybCwgRXZlbnQqIGV2ZW50 KQogewotICAgIC8vIFJlYWN0IG9uIGNsaWNrcyBhbmQgb24ga2V5cHJlc3Nlcy4KLSAgICAvLyBE b24ndCBtYWtlIHRoaXMgS0VZVVBfRVZFTlQgYWdhaW4sIGl0IG1ha2VzIGtodG1sIGZvbGxvdyBs aW5rcyBpdCBzaG91bGRuJ3QsCi0gICAgLy8gd2hlbiBwcmVzc2luZyBFbnRlciBpbiB0aGUgY29t Ym8uCi0gICAgaWYgKGlzTGluaygpICYmIChldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xp Y2tFdmVudCB8fCAoZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmtleWRvd25FdmVudCAmJiBm b2N1c2VkKCkpKSkgewotICAgICAgICBNb3VzZUV2ZW50KiBlID0gMDsKLSAgICAgICAgaWYgKGV2 dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50ICYmIGV2dC0+aXNNb3VzZUV2ZW50 KCkpCi0gICAgICAgICAgICBlID0gc3RhdGljX2Nhc3Q8TW91c2VFdmVudCo+KGV2dCk7Ci0KLSAg ICAgICAgS2V5Ym9hcmRFdmVudCogayA9IDA7Ci0gICAgICAgIGlmIChldnQtPnR5cGUoKSA9PSBl dmVudE5hbWVzKCkua2V5ZG93bkV2ZW50ICYmIGV2dC0+aXNLZXlib2FyZEV2ZW50KCkpCi0gICAg ICAgICAgICBrID0gc3RhdGljX2Nhc3Q8S2V5Ym9hcmRFdmVudCo+KGV2dCk7CisgICAgaWYgKCFl dmVudC0+aXNNb3VzZUV2ZW50KCkpCisgICAgICAgIHJldHVybjsKIAotICAgICAgICBpZiAoZSAm JiBlLT5idXR0b24oKSA9PSBSaWdodEJ1dHRvbikgewotICAgICAgICAgICAgSFRNTEVsZW1lbnQ6 OmRlZmF1bHRFdmVudEhhbmRsZXIoZXZ0KTsKLSAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAg fQorICAgIEFTU0VSVChldmVudC0+dGFyZ2V0KCkpOworICAgIE5vZGUqIHRhcmdldCA9IGV2ZW50 LT50YXJnZXQoKS0+dG9Ob2RlKCk7CisgICAgQVNTRVJUKHRhcmdldCk7CisgICAgaWYgKCF0YXJn ZXQtPmhhc1RhZ05hbWUoaW1nVGFnKSkKKyAgICAgICAgcmV0dXJuOwogCi0gICAgICAgIC8vIElm IHRoZSBsaW5rIGlzIGVkaXRhYmxlLCB0aGVuIHdlIG5lZWQgdG8gY2hlY2sgdGhlIHNldHRpbmdz IHRvIHNlZSB3aGV0aGVyIG9yIG5vdCB0byBmb2xsb3cgdGhlIGxpbmsKLSAgICAgICAgaWYgKGlz Q29udGVudEVkaXRhYmxlKCkpIHsKLSAgICAgICAgICAgIEVkaXRhYmxlTGlua0JlaGF2aW9yIGVk aXRhYmxlTGlua0JlaGF2aW9yID0gRWRpdGFibGVMaW5rRGVmYXVsdEJlaGF2aW9yOwotICAgICAg ICAgICAgaWYgKFNldHRpbmdzKiBzZXR0aW5ncyA9IGRvY3VtZW50KCktPnNldHRpbmdzKCkpCi0g ICAgICAgICAgICAgICAgZWRpdGFibGVMaW5rQmVoYXZpb3IgPSBzZXR0aW5ncy0+ZWRpdGFibGVM aW5rQmVoYXZpb3IoKTsKLSAgICAgICAgICAgICAgICAKLSAgICAgICAgICAgIHN3aXRjaCAoZWRp dGFibGVMaW5rQmVoYXZpb3IpIHsKLSAgICAgICAgICAgICAgICAvLyBBbHdheXMgZm9sbG93IHRo ZSBsaW5rIChTYWZhcmkgMi4wIGJlaGF2aW9yKQotICAgICAgICAgICAgICAgIGRlZmF1bHQ6Ci0g ICAgICAgICAgICAgICAgY2FzZSBFZGl0YWJsZUxpbmtEZWZhdWx0QmVoYXZpb3I6Ci0gICAgICAg ICAgICAgICAgY2FzZSBFZGl0YWJsZUxpbmtBbHdheXNMaXZlOgotICAgICAgICAgICAgICAgICAg ICBicmVhazsKKyAgICBIVE1MSW1hZ2VFbGVtZW50KiBpbWFnZUVsZW1lbnQgPSBzdGF0aWNfY2Fz dDxIVE1MSW1hZ2VFbGVtZW50Kj4oZXZlbnQtPnRhcmdldCgpLT50b05vZGUoKSk7CisgICAgaWYg KCFpbWFnZUVsZW1lbnQgfHwgIWltYWdlRWxlbWVudC0+aXNTZXJ2ZXJNYXAoKSkKKyAgICAgICAg cmV0dXJuOwogCi0gICAgICAgICAgICAgICAgY2FzZSBFZGl0YWJsZUxpbmtOZXZlckxpdmU6Ci0g ICAgICAgICAgICAgICAgICAgIEhUTUxFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKGV2dCk7 Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybjsKKyAgICBSZW5kZXJJbWFnZSogcmVuZGVyZXIg PSB0b1JlbmRlckltYWdlKGltYWdlRWxlbWVudC0+cmVuZGVyZXIoKSk7CisgICAgaWYgKCFyZW5k ZXJlcikKKyAgICAgICAgcmV0dXJuOwogCi0gICAgICAgICAgICAgICAgLy8gSWYgdGhlIHNlbGVj dGlvbiBwcmlvciB0byBjbGlja2luZyBvbiB0aGlzIGxpbmsgcmVzaWRlZCBpbiB0aGUgc2FtZSBl ZGl0YWJsZSBibG9jayBhcyB0aGlzIGxpbmssCi0gICAgICAgICAgICAgICAgLy8gYW5kIHRoZSBz aGlmdCBrZXkgaXNuJ3QgcHJlc3NlZCwgd2UgZG9uJ3Qgd2FudCB0byBmb2xsb3cgdGhlIGxpbmsK LSAgICAgICAgICAgICAgICBjYXNlIEVkaXRhYmxlTGlua0xpdmVXaGVuTm90Rm9jdXNlZDoKLSAg ICAgICAgICAgICAgICAgICAgaWYgKGUgJiYgIWUtPnNoaWZ0S2V5KCkgJiYgbV9yb290RWRpdGFi bGVFbGVtZW50Rm9yU2VsZWN0aW9uT25Nb3VzZURvd24gPT0gcm9vdEVkaXRhYmxlRWxlbWVudCgp KSB7Ci0gICAgICAgICAgICAgICAgICAgICAgICBIVE1MRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFu ZGxlcihldnQpOwotICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICAgICAg ICAgICAgICB9Ci0gICAgICAgICAgICAgICAgICAgIGJyZWFrOwotCi0gICAgICAgICAgICAgICAg Ly8gT25seSBmb2xsb3cgdGhlIGxpbmsgaWYgdGhlIHNoaWZ0IGtleSBpcyBkb3duIChXaW5JRS9G aXJlZm94IGJlaGF2aW9yKQotICAgICAgICAgICAgICAgIGNhc2UgRWRpdGFibGVMaW5rT25seUxp dmVXaXRoU2hpZnRLZXk6Ci0gICAgICAgICAgICAgICAgICAgIGlmIChlICYmICFlLT5zaGlmdEtl eSgpKSB7Ci0gICAgICAgICAgICAgICAgICAgICAgICBIVE1MRWxlbWVudDo6ZGVmYXVsdEV2ZW50 SGFuZGxlcihldnQpOwotICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICAg ICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgICAgIGJyZWFrOwotICAgICAgICAgICAgfQor ICAgIC8vIEZJWE1FOiBUaGlzIHNob3VsZCBwcm9iYWJseSBwYXNzIHRydWUgZm9yIHVzZVRyYW5z Zm9ybXMuCisgICAgRmxvYXRQb2ludCBhYnNvbHV0ZVBvc2l0aW9uID0gcmVuZGVyZXItPmFic29s dXRlVG9Mb2NhbChGbG9hdFBvaW50KHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldmVudCktPnBh Z2VYKCksIHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldmVudCktPnBhZ2VZKCkpKTsKKyAgICBp bnQgeCA9IGFic29sdXRlUG9zaXRpb24ueCgpOworICAgIGludCB5ID0gYWJzb2x1dGVQb3NpdGlv bi55KCk7CisgICAgdXJsICs9ICI/IjsKKyAgICB1cmwgKz0gU3RyaW5nOjpudW1iZXIoeCk7Cisg ICAgdXJsICs9ICIsIjsKKyAgICB1cmwgKz0gU3RyaW5nOjpudW1iZXIoeSk7Cit9CisKK3ZvaWQg SFRNTEFuY2hvckVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2ZW50KQorewor ICAgIGlmIChpc0xpbmsoKSkgeworICAgICAgICBpZiAoZm9jdXNlZCgpICYmIGlzRW50ZXJLZXlL ZXlkb3duRXZlbnQoZXZlbnQpICYmIGlzTGl2ZUxpbmtJbXBsKE5vbk1vdXNlRXZlbnQpKSB7Cisg ICAgICAgICAgICBldmVudC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKKyAgICAgICAgICAgIGRpc3Bh dGNoU2ltdWxhdGVkQ2xpY2soZXZlbnQpOworICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9 CiAKLSAgICAgICAgaWYgKGspIHsKLSAgICAgICAgICAgIGlmIChrLT5rZXlJZGVudGlmaWVyKCkg IT0gIkVudGVyIikgewotICAgICAgICAgICAgICAgIEhUTUxFbGVtZW50OjpkZWZhdWx0RXZlbnRI YW5kbGVyKGV2dCk7Ci0gICAgICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICAgICAgfQotICAg ICAgICAgICAgZXZ0LT5zZXREZWZhdWx0SGFuZGxlZCgpOwotICAgICAgICAgICAgZGlzcGF0Y2hT aW11bGF0ZWRDbGljayhldnQpOworICAgICAgICBpZiAoaXNMaW5rQ2xpY2soZXZlbnQpICYmIGlz TGl2ZUxpbmtJbXBsKGV2ZW50VHlwZUZyb21FdmVudChldmVudCkpKSB7CisgICAgICAgICAgICBT dHJpbmcgdXJsID0gZGVwcmVjYXRlZFBhcnNlVVJMKGdldEF0dHJpYnV0ZShocmVmQXR0cikpOwor ICAgICAgICAgICAgYXBwZW5kU2VydmVyTWFwTW91c2VQb3NpdGlvbih1cmwsIGV2ZW50KTsKKyAg ICAgICAgICAgIGhhbmRsZUxpbmtDbGljayhldmVudCwgZG9jdW1lbnQoKSwgdXJsLCBnZXRBdHRy aWJ1dGUodGFyZ2V0QXR0ciksIGhhc1JlbChSZWxhdGlvbk5vUmVmZXJyZXIpKTsKICAgICAgICAg ICAgIHJldHVybjsKICAgICAgICAgfQogCi0gICAgICAgIFN0cmluZyB1cmwgPSBkZXByZWNhdGVk UGFyc2VVUkwoZ2V0QXR0cmlidXRlKGhyZWZBdHRyKSk7Ci0KLSAgICAgICAgQVNTRVJUKGV2dC0+ dGFyZ2V0KCkpOwotICAgICAgICBBU1NFUlQoZXZ0LT50YXJnZXQoKS0+dG9Ob2RlKCkpOwotICAg ICAgICBpZiAoZXZ0LT50YXJnZXQoKS0+dG9Ob2RlKCktPmhhc1RhZ05hbWUoaW1nVGFnKSkgewot ICAgICAgICAgICAgSFRNTEltYWdlRWxlbWVudCogaW1nID0gc3RhdGljX2Nhc3Q8SFRNTEltYWdl RWxlbWVudCo+KGV2dC0+dGFyZ2V0KCktPnRvTm9kZSgpKTsKLSAgICAgICAgICAgIGlmIChpbWcg JiYgaW1nLT5pc1NlcnZlck1hcCgpKSB7Ci0gICAgICAgICAgICAgICAgUmVuZGVySW1hZ2UqIHIg PSB0b1JlbmRlckltYWdlKGltZy0+cmVuZGVyZXIoKSk7Ci0gICAgICAgICAgICAgICAgaWYgKHIg JiYgZSkgewotICAgICAgICAgICAgICAgICAgICAvLyBGSVhNRTogYnJva2VuIHdpdGggdHJhbnNm b3JtcwotICAgICAgICAgICAgICAgICAgICBGbG9hdFBvaW50IGFic1BvcyA9IHItPmxvY2FsVG9B YnNvbHV0ZSgpOwotICAgICAgICAgICAgICAgICAgICBpbnQgeCA9IGUtPnBhZ2VYKCkgLSBhYnNQ b3MueCgpOwotICAgICAgICAgICAgICAgICAgICBpbnQgeSA9IGUtPnBhZ2VZKCkgLSBhYnNQb3Mu eSgpOwotICAgICAgICAgICAgICAgICAgICB1cmwgKz0gIj8iOwotICAgICAgICAgICAgICAgICAg ICB1cmwgKz0gU3RyaW5nOjpudW1iZXIoeCk7Ci0gICAgICAgICAgICAgICAgICAgIHVybCArPSAi LCI7Ci0gICAgICAgICAgICAgICAgICAgIHVybCArPSBTdHJpbmc6Om51bWJlcih5KTsKLSAgICAg ICAgICAgICAgICB9IGVsc2UgewotICAgICAgICAgICAgICAgICAgICBldnQtPnNldERlZmF1bHRI YW5kbGVkKCk7Ci0gICAgICAgICAgICAgICAgICAgIEhUTUxFbGVtZW50OjpkZWZhdWx0RXZlbnRI YW5kbGVyKGV2dCk7Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgICAgICAg ICB9CisgICAgICAgIGlmIChpc0NvbnRlbnRFZGl0YWJsZSgpKSB7CisgICAgICAgICAgICAvLyBU aGlzIGtlZXBzIHRyYWNrIG9mIHRoZSBlZGl0YWJsZSBibG9jayB0aGF0IHRoZSBzZWxlY3Rpb24g d2FzIGluIChpZiBpdCB3YXMgaW4gb25lKSBqdXN0IGJlZm9yZSB0aGUgbGluayB3YXMgY2xpY2tl ZAorICAgICAgICAgICAgLy8gZm9yIHRoZSBMaXZlV2hlbk5vdEZvY3VzZWQgZWRpdGFibGUgbGlu ayBiZWhhdmlvcgorICAgICAgICAgICAgaWYgKGV2ZW50LT50eXBlKCkgPT0gZXZlbnROYW1lcygp Lm1vdXNlZG93bkV2ZW50ICYmIGV2ZW50LT5pc01vdXNlRXZlbnQoKSAmJiBzdGF0aWNfY2FzdDxN b3VzZUV2ZW50Kj4oZXZlbnQpLT5idXR0b24oKSAhPSBSaWdodEJ1dHRvbiAmJiBkb2N1bWVudCgp LT5mcmFtZSgpICYmIGRvY3VtZW50KCktPmZyYW1lKCktPnNlbGVjdGlvbigpKSB7CisgICAgICAg ICAgICAgICAgbV9yb290RWRpdGFibGVFbGVtZW50Rm9yU2VsZWN0aW9uT25Nb3VzZURvd24gPSBk b2N1bWVudCgpLT5mcmFtZSgpLT5zZWxlY3Rpb24oKS0+cm9vdEVkaXRhYmxlRWxlbWVudCgpOwor ICAgICAgICAgICAgICAgIG1fd2FzU2hpZnRLZXlEb3duT25Nb3VzZURvd24gPSBzdGF0aWNfY2Fz dDxNb3VzZUV2ZW50Kj4oZXZlbnQpLT5zaGlmdEtleSgpOworICAgICAgICAgICAgfSBlbHNlIGlm IChldmVudC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5tb3VzZW92ZXJFdmVudCkgeworICAgICAg ICAgICAgICAgIC8vIFRoZXNlIGFyZSBjbGVhcmVkIG9uIG1vdXNlb3ZlciBhbmQgbm90IG1vdXNl b3V0IGJlY2F1c2UgdGhlaXIgdmFsdWVzIGFyZSBuZWVkZWQgZm9yIGRyYWcgZXZlbnRzLAorICAg ICAgICAgICAgICAgIC8vIGJ1dCBkcmFnIGV2ZW50cyBoYXBwZW4gYWZ0ZXIgbW91c2Ugb3V0IGV2 ZW50cy4KKyAgICAgICAgICAgICAgICBtX3Jvb3RFZGl0YWJsZUVsZW1lbnRGb3JTZWxlY3Rpb25P bk1vdXNlRG93biA9IDA7CisgICAgICAgICAgICAgICAgbV93YXNTaGlmdEtleURvd25Pbk1vdXNl RG93biA9IGZhbHNlOwogICAgICAgICAgICAgfQogICAgICAgICB9Ci0KLSAgICAgICAgaWYgKCFl dnQtPmRlZmF1bHRQcmV2ZW50ZWQoKSAmJiBkb2N1bWVudCgpLT5mcmFtZSgpKQotICAgICAgICAg ICAgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+bG9hZGVyKCktPnVybFNlbGVjdGVkKGRvY3VtZW50KCkt PmNvbXBsZXRlVVJMKHVybCksIGdldEF0dHJpYnV0ZSh0YXJnZXRBdHRyKSwgZXZ0LCBmYWxzZSwg ZmFsc2UsIHRydWUsIGhhc1JlbChSZWxhdGlvbk5vUmVmZXJyZXIpID8gTm9SZWZlcnJlciA6IFNl bmRSZWZlcnJlcik7Ci0KLSAgICAgICAgZXZ0LT5zZXREZWZhdWx0SGFuZGxlZCgpOwotICAgIH0g ZWxzZSBpZiAoaXNMaW5rKCkgJiYgaXNDb250ZW50RWRpdGFibGUoKSkgewotICAgICAgICAvLyBU aGlzIGtlZXBzIHRyYWNrIG9mIHRoZSBlZGl0YWJsZSBibG9jayB0aGF0IHRoZSBzZWxlY3Rpb24g d2FzIGluIChpZiBpdCB3YXMgaW4gb25lKSBqdXN0IGJlZm9yZSB0aGUgbGluayB3YXMgY2xpY2tl ZAotICAgICAgICAvLyBmb3IgdGhlIExpdmVXaGVuTm90Rm9jdXNlZCBlZGl0YWJsZSBsaW5rIGJl aGF2aW9yCi0gICAgICAgIGlmIChldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkubW91c2Vkb3du RXZlbnQgJiYgZXZ0LT5pc01vdXNlRXZlbnQoKSAmJiBzdGF0aWNfY2FzdDxNb3VzZUV2ZW50Kj4o ZXZ0KS0+YnV0dG9uKCkgIT0gUmlnaHRCdXR0b24gJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKSAmJiBk b2N1bWVudCgpLT5mcmFtZSgpLT5zZWxlY3Rpb24oKSkgewotICAgICAgICAgICAgTW91c2VFdmVu dCogZSA9IHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldnQpOwotCi0gICAgICAgICAgICBtX3Jv b3RFZGl0YWJsZUVsZW1lbnRGb3JTZWxlY3Rpb25Pbk1vdXNlRG93biA9IGRvY3VtZW50KCktPmZy YW1lKCktPnNlbGVjdGlvbigpLT5yb290RWRpdGFibGVFbGVtZW50KCk7Ci0gICAgICAgICAgICBt X3dhc1NoaWZ0S2V5RG93bk9uTW91c2VEb3duID0gZSAmJiBlLT5zaGlmdEtleSgpOwotICAgICAg ICB9IGVsc2UgaWYgKGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5tb3VzZW92ZXJFdmVudCkg ewotICAgICAgICAgICAgLy8gVGhlc2UgYXJlIGNsZWFyZWQgb24gbW91c2VvdmVyIGFuZCBub3Qg bW91c2VvdXQgYmVjYXVzZSB0aGVpciB2YWx1ZXMgYXJlIG5lZWRlZCBmb3IgZHJhZyBldmVudHMs IGJ1dCB0aGVzZSBoYXBwZW4KLSAgICAgICAgICAgIC8vIGFmdGVyIG1vdXNlIG91dCBldmVudHMu Ci0gICAgICAgICAgICBtX3Jvb3RFZGl0YWJsZUVsZW1lbnRGb3JTZWxlY3Rpb25Pbk1vdXNlRG93 biA9IDA7Ci0gICAgICAgICAgICBtX3dhc1NoaWZ0S2V5RG93bk9uTW91c2VEb3duID0gZmFsc2U7 Ci0gICAgICAgIH0KICAgICB9CiAKLSAgICBIVE1MRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxl cihldnQpOworICAgIEhUTUxFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKGV2ZW50KTsKIH0K IAogdm9pZCBIVE1MQW5jaG9yRWxlbWVudDo6c2V0QWN0aXZlKGJvb2wgZG93biwgYm9vbCBwYXVz ZSkKQEAgLTUxMiwzMiArNDYyLDY3IEBAIFN0cmluZyBIVE1MQW5jaG9yRWxlbWVudDo6dG9TdHJp bmcoKSBjb24KIAogYm9vbCBIVE1MQW5jaG9yRWxlbWVudDo6aXNMaXZlTGluaygpIGNvbnN0CiB7 Ci0gICAgaWYgKCFpc0xpbmsoKSkKLSAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIHJldHVybiBp c0xpbmsoKSA/IGlzTGl2ZUxpbmtJbXBsKG1fd2FzU2hpZnRLZXlEb3duT25Nb3VzZURvd24gPyBN b3VzZUV2ZW50V2l0aFNoaWZ0S2V5IDogTW91c2VFdmVudFdpdGhvdXRTaGlmdEtleSkgOiBmYWxz ZTsKK30KKworSFRNTEFuY2hvckVsZW1lbnQ6OkV2ZW50VHlwZSBIVE1MQW5jaG9yRWxlbWVudDo6 ZXZlbnRUeXBlRnJvbUV2ZW50KEV2ZW50KiBldmVudCkKK3sKKyAgICBpZiAoIWV2ZW50LT5pc01v dXNlRXZlbnQoKSkKKyAgICAgICAgcmV0dXJuIE5vbk1vdXNlRXZlbnQ7CisgICAgcmV0dXJuIHN0 YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldmVudCktPnNoaWZ0S2V5KCkgPyBNb3VzZUV2ZW50V2l0 aFNoaWZ0S2V5IDogTW91c2VFdmVudFdpdGhvdXRTaGlmdEtleTsKK30KKworYm9vbCBIVE1MQW5j aG9yRWxlbWVudDo6aXNMaXZlTGlua0ltcGwoRXZlbnRUeXBlIGV2ZW50VHlwZSkgY29uc3QKK3sK ICAgICBpZiAoIWlzQ29udGVudEVkaXRhYmxlKCkpCiAgICAgICAgIHJldHVybiB0cnVlOwotICAg IAotICAgIEVkaXRhYmxlTGlua0JlaGF2aW9yIGVkaXRhYmxlTGlua0JlaGF2aW9yID0gRWRpdGFi bGVMaW5rRGVmYXVsdEJlaGF2aW9yOwotICAgIGlmIChTZXR0aW5ncyogc2V0dGluZ3MgPSBkb2N1 bWVudCgpLT5zZXR0aW5ncygpKQotICAgICAgICBlZGl0YWJsZUxpbmtCZWhhdmlvciA9IHNldHRp bmdzLT5lZGl0YWJsZUxpbmtCZWhhdmlvcigpOwotICAgICAgICAKLSAgICBzd2l0Y2ggKGVkaXRh YmxlTGlua0JlaGF2aW9yKSB7Ci0gICAgICAgIGRlZmF1bHQ6Ci0gICAgICAgIGNhc2UgRWRpdGFi bGVMaW5rRGVmYXVsdEJlaGF2aW9yOgotICAgICAgICBjYXNlIEVkaXRhYmxlTGlua0Fsd2F5c0xp dmU6Ci0gICAgICAgICAgICByZXR1cm4gdHJ1ZTsKLQotICAgICAgICBjYXNlIEVkaXRhYmxlTGlu a05ldmVyTGl2ZToKLSAgICAgICAgICAgIHJldHVybiBmYWxzZTsKLQotICAgICAgICAvLyBEb24n dCBzZXQgdGhlIGxpbmsgdG8gYmUgbGl2ZSBpZiB0aGUgY3VycmVudCBzZWxlY3Rpb24gaXMgaW4g dGhlIHNhbWUgZWRpdGFibGUgYmxvY2sgYXMKLSAgICAgICAgLy8gdGhpcyBsaW5rIG9yIGlmIHRo ZSBzaGlmdCBrZXkgaXMgZG93bgotICAgICAgICBjYXNlIEVkaXRhYmxlTGlua0xpdmVXaGVuTm90 Rm9jdXNlZDoKLSAgICAgICAgICAgIHJldHVybiBtX3dhc1NoaWZ0S2V5RG93bk9uTW91c2VEb3du IHx8IG1fcm9vdEVkaXRhYmxlRWxlbWVudEZvclNlbGVjdGlvbk9uTW91c2VEb3duICE9IHJvb3RF ZGl0YWJsZUVsZW1lbnQoKTsKLSAgICAgICAgICAgIAotICAgICAgICBjYXNlIEVkaXRhYmxlTGlu a09ubHlMaXZlV2l0aFNoaWZ0S2V5OgotICAgICAgICAgICAgcmV0dXJuIG1fd2FzU2hpZnRLZXlE b3duT25Nb3VzZURvd247CisKKyAgICBTZXR0aW5ncyogc2V0dGluZ3MgPSBkb2N1bWVudCgpLT5z ZXR0aW5ncygpOworICAgIGlmICghc2V0dGluZ3MpCisgICAgICAgIHJldHVybiB0cnVlOworCisg ICAgc3dpdGNoIChzZXR0aW5ncy0+ZWRpdGFibGVMaW5rQmVoYXZpb3IoKSkgeworICAgIGNhc2Ug RWRpdGFibGVMaW5rRGVmYXVsdEJlaGF2aW9yOgorICAgIGNhc2UgRWRpdGFibGVMaW5rQWx3YXlz TGl2ZToKKyAgICAgICAgcmV0dXJuIHRydWU7CisKKyAgICBjYXNlIEVkaXRhYmxlTGlua05ldmVy TGl2ZToKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgLy8gSWYgdGhlIHNlbGVjdGlvbiBw cmlvciB0byBjbGlja2luZyBvbiB0aGlzIGxpbmsgcmVzaWRlZCBpbiB0aGUgc2FtZSBlZGl0YWJs ZSBibG9jayBhcyB0aGlzIGxpbmssCisgICAgLy8gYW5kIHRoZSBzaGlmdCBrZXkgaXNuJ3QgcHJl c3NlZCwgd2UgZG9uJ3Qgd2FudCB0byBmb2xsb3cgdGhlIGxpbmsuCisgICAgY2FzZSBFZGl0YWJs ZUxpbmtMaXZlV2hlbk5vdEZvY3VzZWQ6CisgICAgICAgIHJldHVybiAoZXZlbnRUeXBlID09IE1v dXNlRXZlbnRXaXRoU2hpZnRLZXkpIHx8ICgoZXZlbnRUeXBlID09IE1vdXNlRXZlbnRXaXRob3V0 U2hpZnRLZXkpICYmIChtX3Jvb3RFZGl0YWJsZUVsZW1lbnRGb3JTZWxlY3Rpb25Pbk1vdXNlRG93 biAhPSByb290RWRpdGFibGVFbGVtZW50KCkpKTsKKworICAgIGNhc2UgRWRpdGFibGVMaW5rT25s eUxpdmVXaXRoU2hpZnRLZXk6CisgICAgICAgIHJldHVybiAoZXZlbnRUeXBlID09IE1vdXNlRXZl bnRXaXRoU2hpZnRLZXkpOwogICAgIH0KKworICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAg IHJldHVybiBmYWxzZTsKK30KKworYm9vbCBpc0VudGVyS2V5S2V5ZG93bkV2ZW50KEV2ZW50KiBl dmVudCkKK3sKKyAgICByZXR1cm4gKGV2ZW50LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmtleWRv d25FdmVudCkgJiYgZXZlbnQtPmlzS2V5Ym9hcmRFdmVudCgpICYmIChzdGF0aWNfY2FzdDxLZXli b2FyZEV2ZW50Kj4oZXZlbnQpLT5rZXlJZGVudGlmaWVyKCkgPT0gIkVudGVyIik7Cit9CisKK2Jv b2wgaXNNaWRkbGVNb3VzZUJ1dHRvbkV2ZW50KEV2ZW50KiBldmVudCkKK3sKKyAgICByZXR1cm4g ZXZlbnQtPmlzTW91c2VFdmVudCgpICYmIChzdGF0aWNfY2FzdDxNb3VzZUV2ZW50Kj4oZXZlbnQp LT5idXR0b24oKSA9PSBNaWRkbGVCdXR0b24pOworfQorCitib29sIGlzTGlua0NsaWNrKEV2ZW50 KiBldmVudCkKK3sKKyAgICByZXR1cm4gKGV2ZW50LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmNs aWNrRXZlbnQpICYmICghZXZlbnQtPmlzTW91c2VFdmVudCgpIHx8IChzdGF0aWNfY2FzdDxNb3Vz ZUV2ZW50Kj4oZXZlbnQpLT5idXR0b24oKSAhPSBSaWdodEJ1dHRvbikpOworfQorCit2b2lkIGhh bmRsZUxpbmtDbGljayhFdmVudCogZXZlbnQsIERvY3VtZW50KiBkb2N1bWVudCwgY29uc3QgU3Ry aW5nJiB1cmwsIGNvbnN0IFN0cmluZyYgdGFyZ2V0LCBib29sIGhpZGVSZWZlcnJlcikKK3sKKyAg ICBldmVudC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKKyAgICBGcmFtZSogZnJhbWUgPSBkb2N1bWVu dC0+ZnJhbWUoKTsKKyAgICBpZiAoZnJhbWUpCisgICAgICAgIGZyYW1lLT5sb2FkZXIoKS0+dXJs U2VsZWN0ZWQoZG9jdW1lbnQtPmNvbXBsZXRlVVJMKHVybCksIHRhcmdldCwgZXZlbnQsIGZhbHNl LCBmYWxzZSwgdHJ1ZSwgaGlkZVJlZmVycmVyID8gTm9SZWZlcnJlciA6IFNlbmRSZWZlcnJlcik7 CiB9CiAKIH0KSW5kZXg6IFdlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCShyZXZpc2lvbiA2NzEyOCkK KysrIFdlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCSh3b3JraW5nIGNvcHkpCkBAIC0y LDcgKzIsNyBAQAogICogQ29weXJpZ2h0IChDKSAxOTk5IExhcnMgS25vbGwgKGtub2xsQGtkZS5v cmcpCiAgKiAgICAgICAgICAgKEMpIDE5OTkgQW50dGkgS29pdmlzdG8gKGtvaXZpc3RvQGtkZS5v cmcpCiAgKiAgICAgICAgICAgKEMpIDIwMDAgU2ltb24gSGF1c21hbm4gPGhhdXNtYW5uQGtkZS5v cmc+Ci0gKiBDb3B5cmlnaHQgKEMpIDIwMDcsIDIwMDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA3LCAyMDA4LCAyMDA5LCAyMDEwIEFw cGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJl ZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgKiBtb2RpZnkgaXQg dW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYwpAQCAtMTA5 LDExICsxMDksMjYgQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIHNob3J0IHRhYkluZGV4KCkgY29u c3Q7CiAgICAgdmlydHVhbCBib29sIGRyYWdnYWJsZSgpIGNvbnN0OwogCisgICAgZW51bSBFdmVu dFR5cGUgeworICAgICAgICBNb3VzZUV2ZW50V2l0aG91dFNoaWZ0S2V5LAorICAgICAgICBNb3Vz ZUV2ZW50V2l0aFNoaWZ0S2V5LAorICAgICAgICBOb25Nb3VzZUV2ZW50LAorICAgIH07CisgICAg c3RhdGljIEV2ZW50VHlwZSBldmVudFR5cGVGcm9tRXZlbnQoRXZlbnQqIGV2ZW50KTsKKyAgICBi b29sIGlzTGl2ZUxpbmtJbXBsKEV2ZW50VHlwZSBldmVudFR5cGUpIGNvbnN0OworCiAgICAgUmVm UHRyPEVsZW1lbnQ+IG1fcm9vdEVkaXRhYmxlRWxlbWVudEZvclNlbGVjdGlvbk9uTW91c2VEb3du OwogICAgIGJvb2wgbV93YXNTaGlmdEtleURvd25Pbk1vdXNlRG93bjsKICAgICB1aW50MzJfdCBt X2xpbmtSZWxhdGlvbnM7CiB9OwogCisvLyBGdW5jdGlvbnMgc2hhcmVkIHdpdGggdGhlIG90aGVy IGFuY2hvciBlbGVtZW50cyAoU1ZHIGFuZCBXTUwpLgorCitib29sIGlzRW50ZXJLZXlLZXlkb3du RXZlbnQoRXZlbnQqKTsKK2Jvb2wgaXNNaWRkbGVNb3VzZUJ1dHRvbkV2ZW50KEV2ZW50Kik7Citi b29sIGlzTGlua0NsaWNrKEV2ZW50Kik7Cit2b2lkIGhhbmRsZUxpbmtDbGljayhFdmVudCosIERv Y3VtZW50KiwgY29uc3QgU3RyaW5nJiB1cmwsIGNvbnN0IFN0cmluZyYgdGFyZ2V0LCBib29sIGhp ZGVSZWZlcnJlciA9IGZhbHNlKTsKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYg Ly8gSFRNTEFuY2hvckVsZW1lbnRfaApJbmRleDogV2ViQ29yZS9zdmcvU1ZHQUVsZW1lbnQuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3ZnL1NWR0FFbGVtZW50LmNwcAkocmV2aXNpb24gNjcx MjgpCisrKyBXZWJDb3JlL3N2Zy9TVkdBRWxlbWVudC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTIs NiArMiw3IEBACiAgKiBDb3B5cmlnaHQgKEMpIDIwMDQsIDIwMDUsIDIwMDggTmlrb2xhcyBaaW1t ZXJtYW5uIDx6aW1tZXJtYW5uQGtkZS5vcmc+CiAgKiBDb3B5cmlnaHQgKEMpIDIwMDQsIDIwMDUs IDIwMDcgUm9iIEJ1aXMgPGJ1aXNAa2RlLm9yZz4KICAqIENvcHlyaWdodCAoQykgMjAwNyBFcmlj IFNlaWRlbCA8ZXJpY0B3ZWJraXQub3JnPgorICogQ29weXJpZ2h0IChDKSAyMDEwIEFwcGxlIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgKiBtb2RpZnkgaXQgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYwpAQCAtMzMsNiArMzQs NyBAQAogI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkZXIuaCIKICNpbmNs dWRlICJGcmFtZUxvYWRlclR5cGVzLmgiCisjaW5jbHVkZSAiSFRNTEFuY2hvckVsZW1lbnQuaCIK ICNpbmNsdWRlICJLZXlib2FyZEV2ZW50LmgiCiAjaW5jbHVkZSAiTW91c2VFdmVudC5oIgogI2lu Y2x1ZGUgIlBsYXRmb3JtTW91c2VFdmVudC5oIgpAQCAtMTI1LDYwICsxMjcsNDcgQEAgUmVuZGVy T2JqZWN0KiBTVkdBRWxlbWVudDo6Y3JlYXRlUmVuZGVyZQogICAgIHJldHVybiBuZXcgKGFyZW5h KSBSZW5kZXJTVkdUcmFuc2Zvcm1hYmxlQ29udGFpbmVyKHRoaXMpOwogfQogCi12b2lkIFNWR0FF bGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldnQpCit2b2lkIFNWR0FFbGVtZW50 OjpkZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldmVudCkKIHsKLSAgICBpZiAoaXNMaW5rKCkg JiYgKGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50IHx8IChldnQtPnR5cGUo KSA9PSBldmVudE5hbWVzKCkua2V5ZG93bkV2ZW50ICYmIGZvY3VzZWQoKSkpKSB7Ci0gICAgICAg IE1vdXNlRXZlbnQqIGUgPSAwOwotICAgICAgICBpZiAoZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1l cygpLmNsaWNrRXZlbnQgJiYgZXZ0LT5pc01vdXNlRXZlbnQoKSkKLSAgICAgICAgICAgIGUgPSBz dGF0aWNfY2FzdDxNb3VzZUV2ZW50Kj4oZXZ0KTsKLSAgICAgICAgCi0gICAgICAgIEtleWJvYXJk RXZlbnQqIGsgPSAwOwotICAgICAgICBpZiAoZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmtl eWRvd25FdmVudCAmJiBldnQtPmlzS2V5Ym9hcmRFdmVudCgpKQotICAgICAgICAgICAgayA9IHN0 YXRpY19jYXN0PEtleWJvYXJkRXZlbnQqPihldnQpOwotICAgICAgICAKLSAgICAgICAgaWYgKGUg JiYgZS0+YnV0dG9uKCkgPT0gUmlnaHRCdXR0b24pIHsKLSAgICAgICAgICAgIFNWR1N0eWxlZFRy YW5zZm9ybWFibGVFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKGV2dCk7CisgICAgaWYgKGlz TGluaygpKSB7CisgICAgICAgIGlmIChmb2N1c2VkKCkgJiYgaXNFbnRlcktleUtleWRvd25FdmVu dChldmVudCkpIHsKKyAgICAgICAgICAgIGV2ZW50LT5zZXREZWZhdWx0SGFuZGxlZCgpOworICAg ICAgICAgICAgZGlzcGF0Y2hTaW11bGF0ZWRDbGljayhldmVudCk7CiAgICAgICAgICAgICByZXR1 cm47CiAgICAgICAgIH0KLSAgICAgICAgCi0gICAgICAgIGlmIChrKSB7Ci0gICAgICAgICAgICBp ZiAoay0+a2V5SWRlbnRpZmllcigpICE9ICJFbnRlciIpIHsKLSAgICAgICAgICAgICAgICBTVkdT dHlsZWRUcmFuc2Zvcm1hYmxlRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihldnQpOwotICAg ICAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgICAgIH0KLSAgICAgICAgICAgIGV2dC0+c2V0 RGVmYXVsdEhhbmRsZWQoKTsKLSAgICAgICAgICAgIGRpc3BhdGNoU2ltdWxhdGVkQ2xpY2soZXZ0 KTsKLSAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgfQotICAgICAgICAKLSAgICAgICAgU3Ry aW5nIHRhcmdldCA9IHRoaXMtPnRhcmdldCgpOwotICAgICAgICBpZiAoZSAmJiBlLT5idXR0b24o KSA9PSBNaWRkbGVCdXR0b24pCi0gICAgICAgICAgICB0YXJnZXQgPSAiX2JsYW5rIjsKLSAgICAg ICAgZWxzZSBpZiAodGFyZ2V0LmlzRW1wdHkoKSkgLy8gaWYgdGFyZ2V0IGlzIGVtcHR5LCBkZWZh dWx0IHRvICJfc2VsZiIgb3IgdXNlIHhsaW5rOnRhcmdldCBpZiBzZXQKLSAgICAgICAgICAgIHRh cmdldCA9IChnZXRBdHRyaWJ1dGUoWExpbmtOYW1lczo6c2hvd0F0dHIpID09ICJuZXciKSA/ICJf YmxhbmsiIDogIl9zZWxmIjsKIAotICAgICAgICBpZiAoIWV2dC0+ZGVmYXVsdFByZXZlbnRlZCgp KSB7CisgICAgICAgIGlmIChpc0xpbmtDbGljayhldmVudCkpIHsKICAgICAgICAgICAgIFN0cmlu ZyB1cmwgPSBkZXByZWNhdGVkUGFyc2VVUkwoaHJlZigpKTsKKwogI2lmIEVOQUJMRShTVkdfQU5J TUFUSU9OKQotICAgICAgICAgICAgaWYgKHVybC5zdGFydHNXaXRoKCIjIikpIHsKKyAgICAgICAg ICAgIGlmICh1cmxbMF0gPT0gJyMnKSB7CiAgICAgICAgICAgICAgICAgRWxlbWVudCogdGFyZ2V0 RWxlbWVudCA9IGRvY3VtZW50KCktPmdldEVsZW1lbnRCeUlkKHVybC5zdWJzdHJpbmcoMSkpOwog ICAgICAgICAgICAgICAgIGlmIChTVkdTTUlMRWxlbWVudDo6aXNTTUlMRWxlbWVudCh0YXJnZXRF bGVtZW50KSkgewotICAgICAgICAgICAgICAgICAgICBTVkdTTUlMRWxlbWVudCogdGltZWQgPSBz dGF0aWNfY2FzdDxTVkdTTUlMRWxlbWVudCo+KHRhcmdldEVsZW1lbnQpOwotICAgICAgICAgICAg ICAgICAgICB0aW1lZC0+YmVnaW5CeUxpbmtBY3RpdmF0aW9uKCk7Ci0gICAgICAgICAgICAgICAg ICAgIGV2dC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKLSAgICAgICAgICAgICAgICAgICAgU1ZHU3R5 bGVkVHJhbnNmb3JtYWJsZUVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoZXZ0KTsKKyAgICAg ICAgICAgICAgICAgICAgc3RhdGljX2Nhc3Q8U1ZHU01JTEVsZW1lbnQqPih0YXJnZXRFbGVtZW50 KS0+YmVnaW5CeUxpbmtBY3RpdmF0aW9uKCk7CisgICAgICAgICAgICAgICAgICAgIGV2ZW50LT5z ZXREZWZhdWx0SGFuZGxlZCgpOwogICAgICAgICAgICAgICAgICAgICByZXR1cm47CiAgICAgICAg ICAgICAgICAgfQogICAgICAgICAgICAgfQogI2VuZGlmCi0gICAgICAgICAgICBpZiAoZG9jdW1l bnQoKS0+ZnJhbWUoKSkKLSAgICAgICAgICAgICAgICBkb2N1bWVudCgpLT5mcmFtZSgpLT5sb2Fk ZXIoKS0+dXJsU2VsZWN0ZWQoZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwodXJsKSwgdGFyZ2V0LCBl dnQsIGZhbHNlLCBmYWxzZSwgdHJ1ZSwgU2VuZFJlZmVycmVyKTsKLSAgICAgICAgfQogCi0gICAg ICAgIGV2dC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKKyAgICAgICAgICAgIC8vIEZJWE1FOiBXaHkg ZG9lcyB0aGUgU1ZHIGFuY2hvciBlbGVtZW50IGhhdmUgdGhpcyBzcGVjaWFsIGxvZ2ljCisgICAg ICAgICAgICAvLyBmb3IgbWlkZGxlIGNsaWNrIHRoYXQgdGhlIEhUTUwgYW5jaG9yIGVsZW1lbnQg ZG9lcyBub3QgaGF2ZT8KKyAgICAgICAgICAgIC8vIE1ha2luZyBhIG1pZGRsZSBjbGljayBvcGVu IGEgbGluayBpbiBhIG5ldyB3aW5kb3cgb3IgdGFiIGlzCisgICAgICAgICAgICAvLyBwcm9wZXJs eSBoYW5kbGVkIGF0IHRoZSBjbGllbnQgbGV2ZWwsIG5vdCBpbnNpZGUgV2ViS2l0OyB0aGlzCisg ICAgICAgICAgICAvLyBjb2RlIHNob3VsZCBiZSBkZWxldGVkLgorICAgICAgICAgICAgU3RyaW5n IHRhcmdldChpc01pZGRsZU1vdXNlQnV0dG9uRXZlbnQoZXZlbnQpID8gIl9ibGFuayIgOiB0aGlz LT50YXJnZXQoKSk7CisKKyAgICAgICAgICAgIC8vIEZJWE1FOiBJdCdzIG5vdCBjbGVhciB3aHkg c2V0dGluZyB0YXJnZXQgdG8gIl9zZWxmIiBpcyBldmVyCisgICAgICAgICAgICAvLyBoZWxwZnVs LgorICAgICAgICAgICAgaWYgKHRhcmdldC5pc0VtcHR5KCkpCisgICAgICAgICAgICAgICAgdGFy Z2V0ID0gKGdldEF0dHJpYnV0ZShYTGlua05hbWVzOjpzaG93QXR0cikgPT0gIm5ldyIpID8gIl9i bGFuayIgOiAiX3NlbGYiOworCisgICAgICAgICAgICBoYW5kbGVMaW5rQ2xpY2soZXZlbnQsIGRv Y3VtZW50KCksIHVybCwgdGFyZ2V0KTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQog ICAgIH0KIAotICAgIFNWR1N0eWxlZFRyYW5zZm9ybWFibGVFbGVtZW50OjpkZWZhdWx0RXZlbnRI YW5kbGVyKGV2dCk7CisgICAgU1ZHU3R5bGVkVHJhbnNmb3JtYWJsZUVsZW1lbnQ6OmRlZmF1bHRF dmVudEhhbmRsZXIoZXZlbnQpOwogfQogCiBib29sIFNWR0FFbGVtZW50OjpzdXBwb3J0c0ZvY3Vz KCkgY29uc3QKSW5kZXg6IFdlYkNvcmUvd21sL1dNTEFFbGVtZW50LmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL3dtbC9XTUxBRWxlbWVudC5jcHAJKHJldmlzaW9uIDY3MTI4KQorKysgV2ViQ29y ZS93bWwvV01MQUVsZW1lbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00LDcgKzQsNyBAQAogICog Q29weXJpZ2h0IChDKSAxOTk5IExhcnMgS25vbGwgKGtub2xsQGtkZS5vcmcpCiAgKiAgICAgICAg ICAgKEMpIDE5OTkgQW50dGkgS29pdmlzdG8gKGtvaXZpc3RvQGtkZS5vcmcpCiAgKiAgICAgICAg ICAgKEMpIDIwMDAgU2ltb24gSGF1c21hbm4gPGhhdXNtYW5uQGtkZS5vcmc+Ci0gKiBDb3B5cmln aHQgKEMpIDIwMDMsIDIwMDYsIDIwMDcsIDIwMDggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLgorICogQ29weXJpZ2h0IChDKSAyMDAzLCAyMDA2LCAyMDA3LCAyMDA4LCAyMDEwIEFwcGxl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqICAgICAgICAgICAoQykgMjAwNiBHcmFoYW0g RGVubmlzIChncmFoYW0uZGVubmlzQGdtYWlsLmNvbSkKICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMg ZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCkBAIC0zNSw2ICsz NSw3IEBACiAjaW5jbHVkZSAiRXZlbnROYW1lcy5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5j bHVkZSAiRnJhbWVMb2FkZXIuaCIKKyNpbmNsdWRlICJIVE1MQW5jaG9yRWxlbWVudC5oIgogI2lu Y2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRl ICJNb3VzZUV2ZW50LmgiCkBAIC0xMTksMzcgKzEyMCwxNyBAQCBib29sIFdNTEFFbGVtZW50Ojpp c0tleWJvYXJkRm9jdXNhYmxlKEtlCiAKIHZvaWQgV01MQUVsZW1lbnQ6OmRlZmF1bHRFdmVudEhh bmRsZXIoRXZlbnQqIGV2ZW50KQogewotICAgIGlmIChpc0xpbmsoKSAmJiAoZXZlbnQtPnR5cGUo KSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCB8fCAoZXZlbnQtPnR5cGUoKSA9PSBldmVudE5h bWVzKCkua2V5ZG93bkV2ZW50ICYmIGZvY3VzZWQoKSkpKSB7Ci0gICAgICAgIE1vdXNlRXZlbnQq IGUgPSAwOwotICAgICAgICBpZiAoZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xpY2tF dmVudCAmJiBldmVudC0+aXNNb3VzZUV2ZW50KCkpCi0gICAgICAgICAgICBlID0gc3RhdGljX2Nh c3Q8TW91c2VFdmVudCo+KGV2ZW50KTsKLQotICAgICAgICBLZXlib2FyZEV2ZW50KiBrID0gMDsK LSAgICAgICAgaWYgKGV2ZW50LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmtleWRvd25FdmVudCAm JiBldmVudC0+aXNLZXlib2FyZEV2ZW50KCkpCi0gICAgICAgICAgICBrID0gc3RhdGljX2Nhc3Q8 S2V5Ym9hcmRFdmVudCo+KGV2ZW50KTsKLQotICAgICAgICBpZiAoZSAmJiBlLT5idXR0b24oKSA9 PSBSaWdodEJ1dHRvbikgewotICAgICAgICAgICAgV01MRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFu ZGxlcihldmVudCk7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAgIH0KLQotICAgICAgICBp ZiAoaykgewotICAgICAgICAgICAgaWYgKGstPmtleUlkZW50aWZpZXIoKSAhPSAiRW50ZXIiKSB7 Ci0gICAgICAgICAgICAgICAgV01MRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihldmVudCk7 Ci0gICAgICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICAgICAgfQotCisgICAgaWYgKGlzTGlu aygpKSB7CisgICAgICAgIGlmIChmb2N1c2VkKCkgJiYgaXNFbnRlcktleUtleWRvd25FdmVudChl dmVudCkpIHsKICAgICAgICAgICAgIGV2ZW50LT5zZXREZWZhdWx0SGFuZGxlZCgpOwogICAgICAg ICAgICAgZGlzcGF0Y2hTaW11bGF0ZWRDbGljayhldmVudCk7CiAgICAgICAgICAgICByZXR1cm47 CiAgICAgICAgIH0KLSAKLSAgICAgICAgaWYgKCFldmVudC0+ZGVmYXVsdFByZXZlbnRlZCgpICYm IGRvY3VtZW50KCktPmZyYW1lKCkpIHsKLSAgICAgICAgICAgIEtVUkwgdXJsID0gZG9jdW1lbnQo KS0+Y29tcGxldGVVUkwoZGVwcmVjYXRlZFBhcnNlVVJMKGdldEF0dHJpYnV0ZShIVE1MTmFtZXM6 OmhyZWZBdHRyKSkpOwotICAgICAgICAgICAgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+bG9hZGVyKCkt PnVybFNlbGVjdGVkKHVybCwgdGFyZ2V0KCksIGV2ZW50LCBmYWxzZSwgZmFsc2UsIHRydWUsIFNl bmRSZWZlcnJlcik7Ci0gICAgICAgIH0KIAotICAgICAgICBldmVudC0+c2V0RGVmYXVsdEhhbmRs ZWQoKTsKKyAgICAgICAgaWYgKGlzTGlua0NsaWNrKGV2ZW50KSkgeworICAgICAgICAgICAgaGFu ZGxlTGlua0NsaWNrKGRvY3VtZW50KCksIGRlcHJlY2F0ZWRQYXJzZVVSTChnZXRBdHRyaWJ1dGUo SFRNTE5hbWVzOjpocmVmQXR0cikpLCB0YXJnZXQoKSwgZXZlbnQpOworICAgICAgICAgICAgcmV0 dXJuOworICAgICAgICB9CiAgICAgfQogCiAgICAgV01MRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFu ZGxlcihldmVudCk7Cg== 67225 2010-09-10 13:10:36 -0700 2010-09-10 15:25:15 -0700 patch, cleanup portion, v1.1 patch text/plain 24306 pkasting SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NzIyNCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNDcgQEAKKzIwMTAtMDktMTA5ICBQZXRlciBLYXN0aW5nICA8cGthc3RpbmdAZ29v Z2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBDbGVhbnVwIGFuZCBzaW1wbGlmaWNhdGlvbiBpbiBhZHZhbmNlIG9mIG1ha2luZyBtaWRkbGUg Y2xpY2tzIG5vdCBzZW5kIGEKKyAgICAgICAgY2xpY2sgZXZlbnQuCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjM4MgorCisgICAgICAgICogZWRpdGlu Zy9EZWxldGVCdXR0b24uY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGVsZXRlQnV0dG9uOjpkZWZh dWx0RXZlbnRIYW5kbGVyKTogUmVtb3ZlZCB1bm5lZWRlZCBjb2RlIHRvCisgICAgICAgIGNoZWNr IGlmIHRoZSBldmVudCBpcyBhIE1vdXNlRXZlbnQuIEFueSBjbGljayBldmVudCB3aWxsIGRvLgor ICAgICAgICAqIGh0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 YXBwZW5kU2VydmVyTWFwTW91c2VQb3NpdGlvbik6IEFkZGVkLiBGYWN0b3JzIG91dCB0aGUKKyAg ICAgICAgbW9kaWZpY2F0aW9ucyB0byB0aGUgVVJMIHRvIGFkZCB0aGUgbW91c2UgcG9zaXRpb24g dG8gbWFrZSB0aGUgZGVmYXVsdAorICAgICAgICBldmVudCBoYW5kbGVyIGZ1bmN0aW9uIGVhc2ll ciB0byByZWFkLgorICAgICAgICAoV2ViQ29yZTo6SFRNTEFuY2hvckVsZW1lbnQ6OmRlZmF1bHRF dmVudEhhbmRsZXIpOiBSZW9yZ2FuaXplZCB0byBtYWtlCisgICAgICAgIHRoZSBlbnRlciBrZXkg bG9naWMgc2VwYXJhdGUgZnJvbSB0aGUgbGluayBjbGlja2luZyBsb2dpYyBhbmQgc2ltcGxpZnkK KyAgICAgICAgdGhlIGZ1bmN0aW9uLiAgVGhpcyBtYWtlcyBtaW5vciBmdW5jdGlvbmFsIGNoYW5n ZXMgbGlrZSBub3QgY2FsbGluZworICAgICAgICBGcmFtZUxvYWRlcjo6dXJsU2VsZWN0ZWQoKSBm b3IgZmFrZSAia2V5ZG93biIgZXZlbnRzIGNvbnN0cnVjdGVkIGZyb20KKyAgICAgICAgSmF2YVNj cmlwdC4KKyAgICAgICAgKFdlYkNvcmU6OkhUTUxBbmNob3JFbGVtZW50Ojppc0xpdmVMaW5rKTog UmVmYWN0b3JlZCB0byB1c2UgbmV3IHNoYXJlZAorICAgICAgICBpbXBsZW1lbnRhdGlvbiBpbiB0 cmVhdExpbmtBc0xpdmVGb3JFdmVudFR5cGUoKS4KKyAgICAgICAgKFdlYkNvcmU6OmV2ZW50VHlw ZUZyb21FdmVudCk6IEZhY3RvcnMgb3V0IGV2ZW50IHR5cGUgY2FsY3VsYXRpb24gKGZvcgorICAg ICAgICB0cmVhdExpbmtBc0xpdmVGb3JFdmVudFR5cGUoKSkgZnJvbSB0aGUgZGVmYXVsdCBldmVu dCBoYW5kbGVyIHRvIG1ha2UgaXQKKyAgICAgICAgZWFzaWVyIHRvIHJlYWQuCisgICAgICAgIChX ZWJDb3JlOjpIVE1MQW5jaG9yRWxlbWVudDo6dHJlYXRMaW5rQXNMaXZlRm9yRXZlbnRUeXBlKToK KyAgICAgICAgSW1wbGVtZW50YXRpb24gb2YgdGhlIHBvcnRpb25zIG9mIGlzTGl2ZUxpbmsoKSB0 aGF0IGFyZSBjb21tb24gd2l0aCB0aGUKKyAgICAgICAgY2hlY2tzIGRlZmF1bHRFdmVudEhhbmRs ZXIoKSB3YW50cyB0byBkby4KKyAgICAgICAgKFdlYkNvcmU6OmlzRW50ZXJLZXlLZXlkb3duRXZl bnQpOiBBZGRlZC4gU2hhcmVkIGJ5IHRoZSBkZWZhdWx0CisgICAgICAgIGV2ZW50IGhhbmRsZXJz IGZvciBhbGwgdGhyZWUgYW5jaG9yIGVsZW1lbnRzLgorICAgICAgICAoV2ViQ29yZTo6aXNNaWRk bGVNb3VzZUJ1dHRvbkV2ZW50KTogQWRkZWQuIFNoYXJlZCBieSB0aGUgaXNMaW5rQ2xpY2sKKyAg ICAgICAgZnVuY3Rpb24gYmVsb3cgYW5kIHNvbWUgY29kZSBpbiBTVkcuIExhdGVyIHdlIGNhbiBt YWtlIHRoaXMgcHJpdmF0ZSB0bworICAgICAgICB0aGlzIHNvdXJjZSBmaWxlIG9uY2Ugd2UgcmVt b3ZlIHRoZSB1bm5lZWRlZCBTVkcgY29kZS4KKyAgICAgICAgKFdlYkNvcmU6OmlzTGlua0NsaWNr KTogQWRkZWQuIFNoYXJlZCBieSB0aGUgZGVmYXVsdCBldmVudCBoYW5kbGVycyBmb3IKKyAgICAg ICAgYWxsIHRocmVlIGFuY2hvciBlbGVtZW50cy4KKyAgICAgICAgKFdlYkNvcmU6OmhhbmRsZUxp bmtDbGljayk6IERpdHRvLgorICAgICAgICAqIGh0bWwvSFRNTEFuY2hvckVsZW1lbnQuaDogQWRk ZWQgdGhlIG5ldyBmdW5jdGlvbnMuCisgICAgICAgICogc3ZnL1NWR0FFbGVtZW50LmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OlNWR0FFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKTogUmVtb3Zl ZCBsb3RzIG9mIHVubmVlZGVkCisgICAgICAgIGxvZ2ljIGFuZCBzdHJlYW1saW5lZCB0aGUgY29k ZSB0byBtb3JlIGNsb3NlbHkgbWF0Y2ggdGhlCisgICAgICAgIEhUTUxBbmNob3JFbGVtZW50IGNv ZGUgYW5kIHNoYXJlIGZ1bmN0aW9ucyB3aXRoIGl0LgorICAgICAgICAqIHdtbC9XTUxBRWxlbWVu dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpXTUxBRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxl cik6IERpdHRvLgorCiAyMDEwLTA5LTEwICBBZGFtIEJhcnRoICA8YWJhcnRoQHdlYmtpdC5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCkluZGV4OiBXZWJDb3JlL2VkaXRp bmcvRGVsZXRlQnV0dG9uLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2VkaXRpbmcvRGVsZXRl QnV0dG9uLmNwcAkocmV2aXNpb24gNjcyMjQpCisrKyBXZWJDb3JlL2VkaXRpbmcvRGVsZXRlQnV0 dG9uLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNTAsMTQgKzUwLDEwIEBAIFBhc3NSZWZQdHI8RGVs ZXRlQnV0dG9uPiBEZWxldGVCdXR0b246OmMKIAogdm9pZCBEZWxldGVCdXR0b246OmRlZmF1bHRF dmVudEhhbmRsZXIoRXZlbnQqIGV2ZW50KQogewotICAgIC8vIEZJWE1FOiBJcyBpdCByZWFsbHkg aW1wb3J0IHRvIGNoZWNrIHRoZSB0eXBlIG9mIHRoZSBldmVudD8KLSAgICAvLyBTZWVtcyBPSyB0 byByZXNwb25kIHRvIGFueSBldmVudCBuYW1lZCBjbGljayBldmVuIGlmIGl0IGRvZXMgbm90IGhh dmUgdGhlIGNvcnJlY3QgdHlwZS4KLSAgICBpZiAoZXZlbnQtPmlzTW91c2VFdmVudCgpKSB7Ci0g ICAgICAgIGlmIChldmVudC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50KSB7Ci0g ICAgICAgICAgICBkb2N1bWVudCgpLT5mcmFtZSgpLT5lZGl0b3IoKS0+ZGVsZXRlQnV0dG9uQ29u dHJvbGxlcigpLT5kZWxldGVUYXJnZXQoKTsKLSAgICAgICAgICAgIGV2ZW50LT5zZXREZWZhdWx0 SGFuZGxlZCgpOwotICAgICAgICAgICAgLy8gRklYTUU6IFNob3VsZG4ndCB3ZSByZXR1cm4gaGVy ZSBpbnN0ZWFkIG9mIGZhbGxpbmcgdGhyb3VnaD8KLSAgICAgICAgfQorICAgIGlmIChldmVudC0+ dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50KSB7CisgICAgICAgIGRvY3VtZW50KCkt PmZyYW1lKCktPmVkaXRvcigpLT5kZWxldGVCdXR0b25Db250cm9sbGVyKCktPmRlbGV0ZVRhcmdl dCgpOworICAgICAgICBldmVudC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKKyAgICAgICAgcmV0dXJu OwogICAgIH0KIAogICAgIEhUTUxJbWFnZUVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoZXZl bnQpOwpJbmRleDogV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3BwCShyZXZpc2lvbiA2NzIyNCkK KysrIFdlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAJKHdvcmtpbmcgY29weSkKQEAg LTIsNyArMiw3IEBACiAgKiBDb3B5cmlnaHQgKEMpIDE5OTkgTGFycyBLbm9sbCAoa25vbGxAa2Rl Lm9yZykKICAqICAgICAgICAgICAoQykgMTk5OSBBbnR0aSBLb2l2aXN0byAoa29pdmlzdG9Aa2Rl Lm9yZykKICAqICAgICAgICAgICAoQykgMjAwMCBTaW1vbiBIYXVzbWFubiA8aGF1c21hbm5Aa2Rl Lm9yZz4KLSAqIENvcHlyaWdodCAoQykgMjAwMywgMjAwNiwgMjAwNywgMjAwOCwgMjAwOSBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDMsIDIwMDYs IDIwMDcsIDIwMDgsIDIwMDksIDIwMTAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgog ICogICAgICAgICAgIChDKSAyMDA2IEdyYWhhbSBEZW5uaXMgKGdyYWhhbS5kZW5uaXNAZ21haWwu Y29tKQogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IKQEAgLTEwNSwxMTcgKzEwNSw2NyBAQCBib29sIEhUTUxBbmNob3JF bGVtZW50Ojppc0tleWJvYXJkRm9jdXNhCiAgICAgcmV0dXJuIGhhc05vbkVtcHR5Qm91bmRpbmdC b3goKTsKIH0KIAotdm9pZCBIVE1MQW5jaG9yRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihF dmVudCogZXZ0KQorc3RhdGljIHZvaWQgYXBwZW5kU2VydmVyTWFwTW91c2VQb3NpdGlvbihTdHJp bmcmIHVybCwgRXZlbnQqIGV2ZW50KQogewotICAgIC8vIFJlYWN0IG9uIGNsaWNrcyBhbmQgb24g a2V5cHJlc3Nlcy4KLSAgICAvLyBEb24ndCBtYWtlIHRoaXMgS0VZVVBfRVZFTlQgYWdhaW4sIGl0 IG1ha2VzIGtodG1sIGZvbGxvdyBsaW5rcyBpdCBzaG91bGRuJ3QsCi0gICAgLy8gd2hlbiBwcmVz c2luZyBFbnRlciBpbiB0aGUgY29tYm8uCi0gICAgaWYgKGlzTGluaygpICYmIChldnQtPnR5cGUo KSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCB8fCAoZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1l cygpLmtleWRvd25FdmVudCAmJiBmb2N1c2VkKCkpKSkgewotICAgICAgICBNb3VzZUV2ZW50KiBl ID0gMDsKLSAgICAgICAgaWYgKGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50 ICYmIGV2dC0+aXNNb3VzZUV2ZW50KCkpCi0gICAgICAgICAgICBlID0gc3RhdGljX2Nhc3Q8TW91 c2VFdmVudCo+KGV2dCk7Ci0KLSAgICAgICAgS2V5Ym9hcmRFdmVudCogayA9IDA7Ci0gICAgICAg IGlmIChldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkua2V5ZG93bkV2ZW50ICYmIGV2dC0+aXNL ZXlib2FyZEV2ZW50KCkpCi0gICAgICAgICAgICBrID0gc3RhdGljX2Nhc3Q8S2V5Ym9hcmRFdmVu dCo+KGV2dCk7CisgICAgaWYgKCFldmVudC0+aXNNb3VzZUV2ZW50KCkpCisgICAgICAgIHJldHVy bjsKIAotICAgICAgICBpZiAoZSAmJiBlLT5idXR0b24oKSA9PSBSaWdodEJ1dHRvbikgewotICAg ICAgICAgICAgSFRNTEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoZXZ0KTsKLSAgICAgICAg ICAgIHJldHVybjsKLSAgICAgICAgfQorICAgIEFTU0VSVChldmVudC0+dGFyZ2V0KCkpOworICAg IE5vZGUqIHRhcmdldCA9IGV2ZW50LT50YXJnZXQoKS0+dG9Ob2RlKCk7CisgICAgQVNTRVJUKHRh cmdldCk7CisgICAgaWYgKCF0YXJnZXQtPmhhc1RhZ05hbWUoaW1nVGFnKSkKKyAgICAgICAgcmV0 dXJuOwogCi0gICAgICAgIC8vIElmIHRoZSBsaW5rIGlzIGVkaXRhYmxlLCB0aGVuIHdlIG5lZWQg dG8gY2hlY2sgdGhlIHNldHRpbmdzIHRvIHNlZSB3aGV0aGVyIG9yIG5vdCB0byBmb2xsb3cgdGhl IGxpbmsKLSAgICAgICAgaWYgKGlzQ29udGVudEVkaXRhYmxlKCkpIHsKLSAgICAgICAgICAgIEVk aXRhYmxlTGlua0JlaGF2aW9yIGVkaXRhYmxlTGlua0JlaGF2aW9yID0gRWRpdGFibGVMaW5rRGVm YXVsdEJlaGF2aW9yOwotICAgICAgICAgICAgaWYgKFNldHRpbmdzKiBzZXR0aW5ncyA9IGRvY3Vt ZW50KCktPnNldHRpbmdzKCkpCi0gICAgICAgICAgICAgICAgZWRpdGFibGVMaW5rQmVoYXZpb3Ig PSBzZXR0aW5ncy0+ZWRpdGFibGVMaW5rQmVoYXZpb3IoKTsKLSAgICAgICAgICAgICAgICAKLSAg ICAgICAgICAgIHN3aXRjaCAoZWRpdGFibGVMaW5rQmVoYXZpb3IpIHsKLSAgICAgICAgICAgICAg ICAvLyBBbHdheXMgZm9sbG93IHRoZSBsaW5rIChTYWZhcmkgMi4wIGJlaGF2aW9yKQotICAgICAg ICAgICAgICAgIGRlZmF1bHQ6Ci0gICAgICAgICAgICAgICAgY2FzZSBFZGl0YWJsZUxpbmtEZWZh dWx0QmVoYXZpb3I6Ci0gICAgICAgICAgICAgICAgY2FzZSBFZGl0YWJsZUxpbmtBbHdheXNMaXZl OgotICAgICAgICAgICAgICAgICAgICBicmVhazsKKyAgICBIVE1MSW1hZ2VFbGVtZW50KiBpbWFn ZUVsZW1lbnQgPSBzdGF0aWNfY2FzdDxIVE1MSW1hZ2VFbGVtZW50Kj4oZXZlbnQtPnRhcmdldCgp LT50b05vZGUoKSk7CisgICAgaWYgKCFpbWFnZUVsZW1lbnQgfHwgIWltYWdlRWxlbWVudC0+aXNT ZXJ2ZXJNYXAoKSkKKyAgICAgICAgcmV0dXJuOwogCi0gICAgICAgICAgICAgICAgY2FzZSBFZGl0 YWJsZUxpbmtOZXZlckxpdmU6Ci0gICAgICAgICAgICAgICAgICAgIEhUTUxFbGVtZW50OjpkZWZh dWx0RXZlbnRIYW5kbGVyKGV2dCk7Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybjsKKyAgICBS ZW5kZXJJbWFnZSogcmVuZGVyZXIgPSB0b1JlbmRlckltYWdlKGltYWdlRWxlbWVudC0+cmVuZGVy ZXIoKSk7CisgICAgaWYgKCFyZW5kZXJlcikKKyAgICAgICAgcmV0dXJuOwogCi0gICAgICAgICAg ICAgICAgLy8gSWYgdGhlIHNlbGVjdGlvbiBwcmlvciB0byBjbGlja2luZyBvbiB0aGlzIGxpbmsg cmVzaWRlZCBpbiB0aGUgc2FtZSBlZGl0YWJsZSBibG9jayBhcyB0aGlzIGxpbmssCi0gICAgICAg ICAgICAgICAgLy8gYW5kIHRoZSBzaGlmdCBrZXkgaXNuJ3QgcHJlc3NlZCwgd2UgZG9uJ3Qgd2Fu dCB0byBmb2xsb3cgdGhlIGxpbmsKLSAgICAgICAgICAgICAgICBjYXNlIEVkaXRhYmxlTGlua0xp dmVXaGVuTm90Rm9jdXNlZDoKLSAgICAgICAgICAgICAgICAgICAgaWYgKGUgJiYgIWUtPnNoaWZ0 S2V5KCkgJiYgbV9yb290RWRpdGFibGVFbGVtZW50Rm9yU2VsZWN0aW9uT25Nb3VzZURvd24gPT0g cm9vdEVkaXRhYmxlRWxlbWVudCgpKSB7Ci0gICAgICAgICAgICAgICAgICAgICAgICBIVE1MRWxl bWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihldnQpOwotICAgICAgICAgICAgICAgICAgICAgICAg cmV0dXJuOwotICAgICAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgICAgIGJyZWFr OwotCi0gICAgICAgICAgICAgICAgLy8gT25seSBmb2xsb3cgdGhlIGxpbmsgaWYgdGhlIHNoaWZ0 IGtleSBpcyBkb3duIChXaW5JRS9GaXJlZm94IGJlaGF2aW9yKQotICAgICAgICAgICAgICAgIGNh c2UgRWRpdGFibGVMaW5rT25seUxpdmVXaXRoU2hpZnRLZXk6Ci0gICAgICAgICAgICAgICAgICAg IGlmIChlICYmICFlLT5zaGlmdEtleSgpKSB7Ci0gICAgICAgICAgICAgICAgICAgICAgICBIVE1M RWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihldnQpOwotICAgICAgICAgICAgICAgICAgICAg ICAgcmV0dXJuOwotICAgICAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgICAgIGJy ZWFrOwotICAgICAgICAgICAgfQorICAgIC8vIEZJWE1FOiBUaGlzIHNob3VsZCBwcm9iYWJseSBw YXNzIHRydWUgZm9yIHVzZVRyYW5zZm9ybXMuCisgICAgRmxvYXRQb2ludCBhYnNvbHV0ZVBvc2l0 aW9uID0gcmVuZGVyZXItPmFic29sdXRlVG9Mb2NhbChGbG9hdFBvaW50KHN0YXRpY19jYXN0PE1v dXNlRXZlbnQqPihldmVudCktPnBhZ2VYKCksIHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldmVu dCktPnBhZ2VZKCkpKTsKKyAgICBpbnQgeCA9IGFic29sdXRlUG9zaXRpb24ueCgpOworICAgIGlu dCB5ID0gYWJzb2x1dGVQb3NpdGlvbi55KCk7CisgICAgdXJsICs9ICI/IjsKKyAgICB1cmwgKz0g U3RyaW5nOjpudW1iZXIoeCk7CisgICAgdXJsICs9ICIsIjsKKyAgICB1cmwgKz0gU3RyaW5nOjpu dW1iZXIoeSk7Cit9CisKK3ZvaWQgSFRNTEFuY2hvckVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRs ZXIoRXZlbnQqIGV2ZW50KQoreworICAgIGlmIChpc0xpbmsoKSkgeworICAgICAgICBpZiAoZm9j dXNlZCgpICYmIGlzRW50ZXJLZXlLZXlkb3duRXZlbnQoZXZlbnQpICYmIHRyZWF0TGlua0FzTGl2 ZUZvckV2ZW50VHlwZShOb25Nb3VzZUV2ZW50KSkgeworICAgICAgICAgICAgZXZlbnQtPnNldERl ZmF1bHRIYW5kbGVkKCk7CisgICAgICAgICAgICBkaXNwYXRjaFNpbXVsYXRlZENsaWNrKGV2ZW50 KTsKKyAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgfQogCi0gICAgICAgIGlmIChrKSB7Ci0g ICAgICAgICAgICBpZiAoay0+a2V5SWRlbnRpZmllcigpICE9ICJFbnRlciIpIHsKLSAgICAgICAg ICAgICAgICBIVE1MRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihldnQpOwotICAgICAgICAg ICAgICAgIHJldHVybjsKLSAgICAgICAgICAgIH0KLSAgICAgICAgICAgIGV2dC0+c2V0RGVmYXVs dEhhbmRsZWQoKTsKLSAgICAgICAgICAgIGRpc3BhdGNoU2ltdWxhdGVkQ2xpY2soZXZ0KTsKKyAg ICAgICAgaWYgKGlzTGlua0NsaWNrKGV2ZW50KSAmJiB0cmVhdExpbmtBc0xpdmVGb3JFdmVudFR5 cGUoZXZlbnRUeXBlRnJvbUV2ZW50KGV2ZW50KSkpIHsKKyAgICAgICAgICAgIFN0cmluZyB1cmwg PSBkZXByZWNhdGVkUGFyc2VVUkwoZ2V0QXR0cmlidXRlKGhyZWZBdHRyKSk7CisgICAgICAgICAg ICBhcHBlbmRTZXJ2ZXJNYXBNb3VzZVBvc2l0aW9uKHVybCwgZXZlbnQpOworICAgICAgICAgICAg aGFuZGxlTGlua0NsaWNrKGV2ZW50LCBkb2N1bWVudCgpLCB1cmwsIGdldEF0dHJpYnV0ZSh0YXJn ZXRBdHRyKSwgaGFzUmVsKFJlbGF0aW9uTm9SZWZlcnJlcikpOwogICAgICAgICAgICAgcmV0dXJu OwogICAgICAgICB9CiAKLSAgICAgICAgU3RyaW5nIHVybCA9IGRlcHJlY2F0ZWRQYXJzZVVSTChn ZXRBdHRyaWJ1dGUoaHJlZkF0dHIpKTsKLQotICAgICAgICBBU1NFUlQoZXZ0LT50YXJnZXQoKSk7 Ci0gICAgICAgIEFTU0VSVChldnQtPnRhcmdldCgpLT50b05vZGUoKSk7Ci0gICAgICAgIGlmIChl dnQtPnRhcmdldCgpLT50b05vZGUoKS0+aGFzVGFnTmFtZShpbWdUYWcpKSB7Ci0gICAgICAgICAg ICBIVE1MSW1hZ2VFbGVtZW50KiBpbWcgPSBzdGF0aWNfY2FzdDxIVE1MSW1hZ2VFbGVtZW50Kj4o ZXZ0LT50YXJnZXQoKS0+dG9Ob2RlKCkpOwotICAgICAgICAgICAgaWYgKGltZyAmJiBpbWctPmlz U2VydmVyTWFwKCkpIHsKLSAgICAgICAgICAgICAgICBSZW5kZXJJbWFnZSogciA9IHRvUmVuZGVy SW1hZ2UoaW1nLT5yZW5kZXJlcigpKTsKLSAgICAgICAgICAgICAgICBpZiAociAmJiBlKSB7Ci0g ICAgICAgICAgICAgICAgICAgIC8vIEZJWE1FOiBicm9rZW4gd2l0aCB0cmFuc2Zvcm1zCi0gICAg ICAgICAgICAgICAgICAgIEZsb2F0UG9pbnQgYWJzUG9zID0gci0+bG9jYWxUb0Fic29sdXRlKCk7 Ci0gICAgICAgICAgICAgICAgICAgIGludCB4ID0gZS0+cGFnZVgoKSAtIGFic1Bvcy54KCk7Ci0g ICAgICAgICAgICAgICAgICAgIGludCB5ID0gZS0+cGFnZVkoKSAtIGFic1Bvcy55KCk7Ci0gICAg ICAgICAgICAgICAgICAgIHVybCArPSAiPyI7Ci0gICAgICAgICAgICAgICAgICAgIHVybCArPSBT dHJpbmc6Om51bWJlcih4KTsKLSAgICAgICAgICAgICAgICAgICAgdXJsICs9ICIsIjsKLSAgICAg ICAgICAgICAgICAgICAgdXJsICs9IFN0cmluZzo6bnVtYmVyKHkpOwotICAgICAgICAgICAgICAg IH0gZWxzZSB7Ci0gICAgICAgICAgICAgICAgICAgIGV2dC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsK LSAgICAgICAgICAgICAgICAgICAgSFRNTEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoZXZ0 KTsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICAgICAgICAgIH0KKyAgICAg ICAgaWYgKGlzQ29udGVudEVkaXRhYmxlKCkpIHsKKyAgICAgICAgICAgIC8vIFRoaXMga2VlcHMg dHJhY2sgb2YgdGhlIGVkaXRhYmxlIGJsb2NrIHRoYXQgdGhlIHNlbGVjdGlvbiB3YXMgaW4gKGlm IGl0IHdhcyBpbiBvbmUpIGp1c3QgYmVmb3JlIHRoZSBsaW5rIHdhcyBjbGlja2VkCisgICAgICAg ICAgICAvLyBmb3IgdGhlIExpdmVXaGVuTm90Rm9jdXNlZCBlZGl0YWJsZSBsaW5rIGJlaGF2aW9y CisgICAgICAgICAgICBpZiAoZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkubW91c2Vkb3du RXZlbnQgJiYgZXZlbnQtPmlzTW91c2VFdmVudCgpICYmIHN0YXRpY19jYXN0PE1vdXNlRXZlbnQq PihldmVudCktPmJ1dHRvbigpICE9IFJpZ2h0QnV0dG9uICYmIGRvY3VtZW50KCktPmZyYW1lKCkg JiYgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+c2VsZWN0aW9uKCkpIHsKKyAgICAgICAgICAgICAgICBt X3Jvb3RFZGl0YWJsZUVsZW1lbnRGb3JTZWxlY3Rpb25Pbk1vdXNlRG93biA9IGRvY3VtZW50KCkt PmZyYW1lKCktPnNlbGVjdGlvbigpLT5yb290RWRpdGFibGVFbGVtZW50KCk7CisgICAgICAgICAg ICAgICAgbV93YXNTaGlmdEtleURvd25Pbk1vdXNlRG93biA9IHN0YXRpY19jYXN0PE1vdXNlRXZl bnQqPihldmVudCktPnNoaWZ0S2V5KCk7CisgICAgICAgICAgICB9IGVsc2UgaWYgKGV2ZW50LT50 eXBlKCkgPT0gZXZlbnROYW1lcygpLm1vdXNlb3ZlckV2ZW50KSB7CisgICAgICAgICAgICAgICAg Ly8gVGhlc2UgYXJlIGNsZWFyZWQgb24gbW91c2VvdmVyIGFuZCBub3QgbW91c2VvdXQgYmVjYXVz ZSB0aGVpciB2YWx1ZXMgYXJlIG5lZWRlZCBmb3IgZHJhZyBldmVudHMsCisgICAgICAgICAgICAg ICAgLy8gYnV0IGRyYWcgZXZlbnRzIGhhcHBlbiBhZnRlciBtb3VzZSBvdXQgZXZlbnRzLgorICAg ICAgICAgICAgICAgIG1fcm9vdEVkaXRhYmxlRWxlbWVudEZvclNlbGVjdGlvbk9uTW91c2VEb3du ID0gMDsKKyAgICAgICAgICAgICAgICBtX3dhc1NoaWZ0S2V5RG93bk9uTW91c2VEb3duID0gZmFs c2U7CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KLQotICAgICAgICBpZiAoIWV2dC0+ZGVmYXVs dFByZXZlbnRlZCgpICYmIGRvY3VtZW50KCktPmZyYW1lKCkpCi0gICAgICAgICAgICBkb2N1bWVu dCgpLT5mcmFtZSgpLT5sb2FkZXIoKS0+dXJsU2VsZWN0ZWQoZG9jdW1lbnQoKS0+Y29tcGxldGVV UkwodXJsKSwgZ2V0QXR0cmlidXRlKHRhcmdldEF0dHIpLCBldnQsIGZhbHNlLCBmYWxzZSwgdHJ1 ZSwgaGFzUmVsKFJlbGF0aW9uTm9SZWZlcnJlcikgPyBOb1JlZmVycmVyIDogU2VuZFJlZmVycmVy KTsKLQotICAgICAgICBldnQtPnNldERlZmF1bHRIYW5kbGVkKCk7Ci0gICAgfSBlbHNlIGlmIChp c0xpbmsoKSAmJiBpc0NvbnRlbnRFZGl0YWJsZSgpKSB7Ci0gICAgICAgIC8vIFRoaXMga2VlcHMg dHJhY2sgb2YgdGhlIGVkaXRhYmxlIGJsb2NrIHRoYXQgdGhlIHNlbGVjdGlvbiB3YXMgaW4gKGlm IGl0IHdhcyBpbiBvbmUpIGp1c3QgYmVmb3JlIHRoZSBsaW5rIHdhcyBjbGlja2VkCi0gICAgICAg IC8vIGZvciB0aGUgTGl2ZVdoZW5Ob3RGb2N1c2VkIGVkaXRhYmxlIGxpbmsgYmVoYXZpb3IKLSAg ICAgICAgaWYgKGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5tb3VzZWRvd25FdmVudCAmJiBl dnQtPmlzTW91c2VFdmVudCgpICYmIHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldnQpLT5idXR0 b24oKSAhPSBSaWdodEJ1dHRvbiAmJiBkb2N1bWVudCgpLT5mcmFtZSgpICYmIGRvY3VtZW50KCkt PmZyYW1lKCktPnNlbGVjdGlvbigpKSB7Ci0gICAgICAgICAgICBNb3VzZUV2ZW50KiBlID0gc3Rh dGljX2Nhc3Q8TW91c2VFdmVudCo+KGV2dCk7Ci0KLSAgICAgICAgICAgIG1fcm9vdEVkaXRhYmxl RWxlbWVudEZvclNlbGVjdGlvbk9uTW91c2VEb3duID0gZG9jdW1lbnQoKS0+ZnJhbWUoKS0+c2Vs ZWN0aW9uKCktPnJvb3RFZGl0YWJsZUVsZW1lbnQoKTsKLSAgICAgICAgICAgIG1fd2FzU2hpZnRL ZXlEb3duT25Nb3VzZURvd24gPSBlICYmIGUtPnNoaWZ0S2V5KCk7Ci0gICAgICAgIH0gZWxzZSBp ZiAoZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLm1vdXNlb3ZlckV2ZW50KSB7Ci0gICAgICAg ICAgICAvLyBUaGVzZSBhcmUgY2xlYXJlZCBvbiBtb3VzZW92ZXIgYW5kIG5vdCBtb3VzZW91dCBi ZWNhdXNlIHRoZWlyIHZhbHVlcyBhcmUgbmVlZGVkIGZvciBkcmFnIGV2ZW50cywgYnV0IHRoZXNl IGhhcHBlbgotICAgICAgICAgICAgLy8gYWZ0ZXIgbW91c2Ugb3V0IGV2ZW50cy4KLSAgICAgICAg ICAgIG1fcm9vdEVkaXRhYmxlRWxlbWVudEZvclNlbGVjdGlvbk9uTW91c2VEb3duID0gMDsKLSAg ICAgICAgICAgIG1fd2FzU2hpZnRLZXlEb3duT25Nb3VzZURvd24gPSBmYWxzZTsKLSAgICAgICAg fQogICAgIH0KIAotICAgIEhUTUxFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKGV2dCk7Cisg ICAgSFRNTEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoZXZlbnQpOwogfQogCiB2b2lkIEhU TUxBbmNob3JFbGVtZW50OjpzZXRBY3RpdmUoYm9vbCBkb3duLCBib29sIHBhdXNlKQpAQCAtNTEy LDMyICs0NjIsNjkgQEAgU3RyaW5nIEhUTUxBbmNob3JFbGVtZW50Ojp0b1N0cmluZygpIGNvbgog CiBib29sIEhUTUxBbmNob3JFbGVtZW50Ojppc0xpdmVMaW5rKCkgY29uc3QKIHsKLSAgICBpZiAo IWlzTGluaygpKQotICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgcmV0dXJuIGlzTGluaygpID8g dHJlYXRMaW5rQXNMaXZlRm9yRXZlbnRUeXBlKG1fd2FzU2hpZnRLZXlEb3duT25Nb3VzZURvd24g PyBNb3VzZUV2ZW50V2l0aFNoaWZ0S2V5IDogTW91c2VFdmVudFdpdGhvdXRTaGlmdEtleSkgOiBm YWxzZTsKK30KKworSFRNTEFuY2hvckVsZW1lbnQ6OkV2ZW50VHlwZSBIVE1MQW5jaG9yRWxlbWVu dDo6ZXZlbnRUeXBlRnJvbUV2ZW50KEV2ZW50KiBldmVudCkKK3sKKyAgICBpZiAoIWV2ZW50LT5p c01vdXNlRXZlbnQoKSkKKyAgICAgICAgcmV0dXJuIE5vbk1vdXNlRXZlbnQ7CisgICAgcmV0dXJu IHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldmVudCktPnNoaWZ0S2V5KCkgPyBNb3VzZUV2ZW50 V2l0aFNoaWZ0S2V5IDogTW91c2VFdmVudFdpdGhvdXRTaGlmdEtleTsKK30KKworYm9vbCBIVE1M QW5jaG9yRWxlbWVudDo6dHJlYXRMaW5rQXNMaXZlRm9yRXZlbnRUeXBlKEV2ZW50VHlwZSBldmVu dFR5cGUpIGNvbnN0Cit7CiAgICAgaWYgKCFpc0NvbnRlbnRFZGl0YWJsZSgpKQogICAgICAgICBy ZXR1cm4gdHJ1ZTsKLSAgICAKLSAgICBFZGl0YWJsZUxpbmtCZWhhdmlvciBlZGl0YWJsZUxpbmtC ZWhhdmlvciA9IEVkaXRhYmxlTGlua0RlZmF1bHRCZWhhdmlvcjsKLSAgICBpZiAoU2V0dGluZ3Mq IHNldHRpbmdzID0gZG9jdW1lbnQoKS0+c2V0dGluZ3MoKSkKLSAgICAgICAgZWRpdGFibGVMaW5r QmVoYXZpb3IgPSBzZXR0aW5ncy0+ZWRpdGFibGVMaW5rQmVoYXZpb3IoKTsKLSAgICAgICAgCi0g ICAgc3dpdGNoIChlZGl0YWJsZUxpbmtCZWhhdmlvcikgewotICAgICAgICBkZWZhdWx0OgotICAg ICAgICBjYXNlIEVkaXRhYmxlTGlua0RlZmF1bHRCZWhhdmlvcjoKLSAgICAgICAgY2FzZSBFZGl0 YWJsZUxpbmtBbHdheXNMaXZlOgotICAgICAgICAgICAgcmV0dXJuIHRydWU7Ci0KLSAgICAgICAg Y2FzZSBFZGl0YWJsZUxpbmtOZXZlckxpdmU6Ci0gICAgICAgICAgICByZXR1cm4gZmFsc2U7Ci0K LSAgICAgICAgLy8gRG9uJ3Qgc2V0IHRoZSBsaW5rIHRvIGJlIGxpdmUgaWYgdGhlIGN1cnJlbnQg c2VsZWN0aW9uIGlzIGluIHRoZSBzYW1lIGVkaXRhYmxlIGJsb2NrIGFzCi0gICAgICAgIC8vIHRo aXMgbGluayBvciBpZiB0aGUgc2hpZnQga2V5IGlzIGRvd24KLSAgICAgICAgY2FzZSBFZGl0YWJs ZUxpbmtMaXZlV2hlbk5vdEZvY3VzZWQ6Ci0gICAgICAgICAgICByZXR1cm4gbV93YXNTaGlmdEtl eURvd25Pbk1vdXNlRG93biB8fCBtX3Jvb3RFZGl0YWJsZUVsZW1lbnRGb3JTZWxlY3Rpb25Pbk1v dXNlRG93biAhPSByb290RWRpdGFibGVFbGVtZW50KCk7Ci0gICAgICAgICAgICAKLSAgICAgICAg Y2FzZSBFZGl0YWJsZUxpbmtPbmx5TGl2ZVdpdGhTaGlmdEtleToKLSAgICAgICAgICAgIHJldHVy biBtX3dhc1NoaWZ0S2V5RG93bk9uTW91c2VEb3duOworCisgICAgU2V0dGluZ3MqIHNldHRpbmdz ID0gZG9jdW1lbnQoKS0+c2V0dGluZ3MoKTsKKyAgICBpZiAoIXNldHRpbmdzKQorICAgICAgICBy ZXR1cm4gdHJ1ZTsKKworICAgIHN3aXRjaCAoc2V0dGluZ3MtPmVkaXRhYmxlTGlua0JlaGF2aW9y KCkpIHsKKyAgICBjYXNlIEVkaXRhYmxlTGlua0RlZmF1bHRCZWhhdmlvcjoKKyAgICBjYXNlIEVk aXRhYmxlTGlua0Fsd2F5c0xpdmU6CisgICAgICAgIHJldHVybiB0cnVlOworCisgICAgY2FzZSBF ZGl0YWJsZUxpbmtOZXZlckxpdmU6CisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIC8vIElm IHRoZSBzZWxlY3Rpb24gcHJpb3IgdG8gY2xpY2tpbmcgb24gdGhpcyBsaW5rIHJlc2lkZWQgaW4g dGhlIHNhbWUgZWRpdGFibGUgYmxvY2sgYXMgdGhpcyBsaW5rLAorICAgIC8vIGFuZCB0aGUgc2hp ZnQga2V5IGlzbid0IHByZXNzZWQsIHdlIGRvbid0IHdhbnQgdG8gZm9sbG93IHRoZSBsaW5rLgor ICAgIGNhc2UgRWRpdGFibGVMaW5rTGl2ZVdoZW5Ob3RGb2N1c2VkOgorICAgICAgICByZXR1cm4g ZXZlbnRUeXBlID09IE1vdXNlRXZlbnRXaXRoU2hpZnRLZXkgfHwgKGV2ZW50VHlwZSA9PSBNb3Vz ZUV2ZW50V2l0aG91dFNoaWZ0S2V5ICYmIG1fcm9vdEVkaXRhYmxlRWxlbWVudEZvclNlbGVjdGlv bk9uTW91c2VEb3duICE9IHJvb3RFZGl0YWJsZUVsZW1lbnQoKSk7CisKKyAgICBjYXNlIEVkaXRh YmxlTGlua09ubHlMaXZlV2l0aFNoaWZ0S2V5OgorICAgICAgICByZXR1cm4gZXZlbnRUeXBlID09 IE1vdXNlRXZlbnRXaXRoU2hpZnRLZXk7CiAgICAgfQorCisgICAgQVNTRVJUX05PVF9SRUFDSEVE KCk7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIGlzRW50ZXJLZXlLZXlkb3duRXZlbnQo RXZlbnQqIGV2ZW50KQoreworICAgIHJldHVybiBldmVudC0+dHlwZSgpID09IGV2ZW50TmFtZXMo KS5rZXlkb3duRXZlbnQgJiYgZXZlbnQtPmlzS2V5Ym9hcmRFdmVudCgpICYmIHN0YXRpY19jYXN0 PEtleWJvYXJkRXZlbnQqPihldmVudCktPmtleUlkZW50aWZpZXIoKSA9PSAiRW50ZXIiOworfQor Citib29sIGlzTWlkZGxlTW91c2VCdXR0b25FdmVudChFdmVudCogZXZlbnQpCit7CisgICAgcmV0 dXJuIGV2ZW50LT5pc01vdXNlRXZlbnQoKSAmJiBzdGF0aWNfY2FzdDxNb3VzZUV2ZW50Kj4oZXZl bnQpLT5idXR0b24oKSA9PSBNaWRkbGVCdXR0b247Cit9CisKK2Jvb2wgaXNMaW5rQ2xpY2soRXZl bnQqIGV2ZW50KQoreworICAgIHJldHVybiBldmVudC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5j bGlja0V2ZW50ICYmICghZXZlbnQtPmlzTW91c2VFdmVudCgpIHx8IHN0YXRpY19jYXN0PE1vdXNl RXZlbnQqPihldmVudCktPmJ1dHRvbigpICE9IFJpZ2h0QnV0dG9uKTsKK30KKwordm9pZCBoYW5k bGVMaW5rQ2xpY2soRXZlbnQqIGV2ZW50LCBEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmlu ZyYgdXJsLCBjb25zdCBTdHJpbmcmIHRhcmdldCwgYm9vbCBoaWRlUmVmZXJyZXIpCit7CisgICAg ZXZlbnQtPnNldERlZmF1bHRIYW5kbGVkKCk7CisKKyAgICBGcmFtZSogZnJhbWUgPSBkb2N1bWVu dC0+ZnJhbWUoKTsKKyAgICBpZiAoIWZyYW1lKQorICAgICAgICByZXR1cm47CisgICAgZnJhbWUt PmxvYWRlcigpLT51cmxTZWxlY3RlZChkb2N1bWVudC0+Y29tcGxldGVVUkwodXJsKSwgdGFyZ2V0 LCBldmVudCwgZmFsc2UsIGZhbHNlLCB0cnVlLCBoaWRlUmVmZXJyZXIgPyBOb1JlZmVycmVyIDog U2VuZFJlZmVycmVyKTsKIH0KIAogfQpJbmRleDogV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVt ZW50LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmgJKHJl dmlzaW9uIDY3MjI0KQorKysgV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmgJKHdvcmtp bmcgY29weSkKQEAgLTIsNyArMiw3IEBACiAgKiBDb3B5cmlnaHQgKEMpIDE5OTkgTGFycyBLbm9s bCAoa25vbGxAa2RlLm9yZykKICAqICAgICAgICAgICAoQykgMTk5OSBBbnR0aSBLb2l2aXN0byAo a29pdmlzdG9Aa2RlLm9yZykKICAqICAgICAgICAgICAoQykgMjAwMCBTaW1vbiBIYXVzbWFubiA8 aGF1c21hbm5Aa2RlLm9yZz4KLSAqIENvcHlyaWdodCAoQykgMjAwNywgMjAwOCwgMjAwOSBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDcsIDIwMDgs IDIwMDksIDIwMTAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFRoaXMg bGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IK ICAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwg UHVibGljCkBAIC0xMDksMTEgKzEwOSwyNiBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwgc2hvcnQg dGFiSW5kZXgoKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgZHJhZ2dhYmxlKCkgY29uc3Q7CiAK KyAgICBlbnVtIEV2ZW50VHlwZSB7CisgICAgICAgIE1vdXNlRXZlbnRXaXRob3V0U2hpZnRLZXks CisgICAgICAgIE1vdXNlRXZlbnRXaXRoU2hpZnRLZXksCisgICAgICAgIE5vbk1vdXNlRXZlbnQs CisgICAgfTsKKyAgICBzdGF0aWMgRXZlbnRUeXBlIGV2ZW50VHlwZUZyb21FdmVudChFdmVudCop OworICAgIGJvb2wgdHJlYXRMaW5rQXNMaXZlRm9yRXZlbnRUeXBlKEV2ZW50VHlwZSkgY29uc3Q7 CisKICAgICBSZWZQdHI8RWxlbWVudD4gbV9yb290RWRpdGFibGVFbGVtZW50Rm9yU2VsZWN0aW9u T25Nb3VzZURvd247CiAgICAgYm9vbCBtX3dhc1NoaWZ0S2V5RG93bk9uTW91c2VEb3duOwogICAg IHVpbnQzMl90IG1fbGlua1JlbGF0aW9uczsKIH07CiAKKy8vIEZ1bmN0aW9ucyBzaGFyZWQgd2l0 aCB0aGUgb3RoZXIgYW5jaG9yIGVsZW1lbnRzIChTVkcgYW5kIFdNTCkuCisKK2Jvb2wgaXNFbnRl cktleUtleWRvd25FdmVudChFdmVudCopOworYm9vbCBpc01pZGRsZU1vdXNlQnV0dG9uRXZlbnQo RXZlbnQqKTsKK2Jvb2wgaXNMaW5rQ2xpY2soRXZlbnQqKTsKK3ZvaWQgaGFuZGxlTGlua0NsaWNr KEV2ZW50KiwgRG9jdW1lbnQqLCBjb25zdCBTdHJpbmcmIHVybCwgY29uc3QgU3RyaW5nJiB0YXJn ZXQsIGJvb2wgaGlkZVJlZmVycmVyID0gZmFsc2UpOworCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3Jl CiAKICNlbmRpZiAvLyBIVE1MQW5jaG9yRWxlbWVudF9oCkluZGV4OiBXZWJDb3JlL3N2Zy9TVkdB RWxlbWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdmcvU1ZHQUVsZW1lbnQuY3BwCShy ZXZpc2lvbiA2NzIyNCkKKysrIFdlYkNvcmUvc3ZnL1NWR0FFbGVtZW50LmNwcAkod29ya2luZyBj b3B5KQpAQCAtMiw2ICsyLDcgQEAKICAqIENvcHlyaWdodCAoQykgMjAwNCwgMjAwNSwgMjAwOCBO aWtvbGFzIFppbW1lcm1hbm4gPHppbW1lcm1hbm5Aa2RlLm9yZz4KICAqIENvcHlyaWdodCAoQykg MjAwNCwgMjAwNSwgMjAwNyBSb2IgQnVpcyA8YnVpc0BrZGUub3JnPgogICogQ29weXJpZ2h0IChD KSAyMDA3IEVyaWMgU2VpZGVsIDxlcmljQHdlYmtpdC5vcmc+CisgKiBDb3B5cmlnaHQgKEMpIDIw MTAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFRoaXMgbGlicmFyeSBp cyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlm eSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCkBA IC0zMyw2ICszNCw3IEBACiAjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRl ci5oIgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyVHlwZXMuaCIKKyNpbmNsdWRlICJIVE1MQW5jaG9y RWxlbWVudC5oIgogI2luY2x1ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJNb3VzZUV2 ZW50LmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1Nb3VzZUV2ZW50LmgiCkBAIC0xMjUsNjAgKzEyNyw0 NyBAQCBSZW5kZXJPYmplY3QqIFNWR0FFbGVtZW50OjpjcmVhdGVSZW5kZXJlCiAgICAgcmV0dXJu IG5ldyAoYXJlbmEpIFJlbmRlclNWR1RyYW5zZm9ybWFibGVDb250YWluZXIodGhpcyk7CiB9CiAK LXZvaWQgU1ZHQUVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2dCkKK3ZvaWQg U1ZHQUVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2ZW50KQogewotICAgIGlm IChpc0xpbmsoKSAmJiAoZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmNsaWNrRXZlbnQgfHwg KGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5rZXlkb3duRXZlbnQgJiYgZm9jdXNlZCgpKSkp IHsKLSAgICAgICAgTW91c2VFdmVudCogZSA9IDA7Ci0gICAgICAgIGlmIChldnQtPnR5cGUoKSA9 PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCAmJiBldnQtPmlzTW91c2VFdmVudCgpKQotICAgICAg ICAgICAgZSA9IHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldnQpOwotICAgICAgICAKLSAgICAg ICAgS2V5Ym9hcmRFdmVudCogayA9IDA7Ci0gICAgICAgIGlmIChldnQtPnR5cGUoKSA9PSBldmVu dE5hbWVzKCkua2V5ZG93bkV2ZW50ICYmIGV2dC0+aXNLZXlib2FyZEV2ZW50KCkpCi0gICAgICAg ICAgICBrID0gc3RhdGljX2Nhc3Q8S2V5Ym9hcmRFdmVudCo+KGV2dCk7Ci0gICAgICAgIAotICAg ICAgICBpZiAoZSAmJiBlLT5idXR0b24oKSA9PSBSaWdodEJ1dHRvbikgewotICAgICAgICAgICAg U1ZHU3R5bGVkVHJhbnNmb3JtYWJsZUVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoZXZ0KTsK KyAgICBpZiAoaXNMaW5rKCkpIHsKKyAgICAgICAgaWYgKGZvY3VzZWQoKSAmJiBpc0VudGVyS2V5 S2V5ZG93bkV2ZW50KGV2ZW50KSkgeworICAgICAgICAgICAgZXZlbnQtPnNldERlZmF1bHRIYW5k bGVkKCk7CisgICAgICAgICAgICBkaXNwYXRjaFNpbXVsYXRlZENsaWNrKGV2ZW50KTsKICAgICAg ICAgICAgIHJldHVybjsKICAgICAgICAgfQotICAgICAgICAKLSAgICAgICAgaWYgKGspIHsKLSAg ICAgICAgICAgIGlmIChrLT5rZXlJZGVudGlmaWVyKCkgIT0gIkVudGVyIikgewotICAgICAgICAg ICAgICAgIFNWR1N0eWxlZFRyYW5zZm9ybWFibGVFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVy KGV2dCk7Ci0gICAgICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICAgICAgfQotICAgICAgICAg ICAgZXZ0LT5zZXREZWZhdWx0SGFuZGxlZCgpOwotICAgICAgICAgICAgZGlzcGF0Y2hTaW11bGF0 ZWRDbGljayhldnQpOwotICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICB9Ci0gICAgICAgIAot ICAgICAgICBTdHJpbmcgdGFyZ2V0ID0gdGhpcy0+dGFyZ2V0KCk7Ci0gICAgICAgIGlmIChlICYm IGUtPmJ1dHRvbigpID09IE1pZGRsZUJ1dHRvbikKLSAgICAgICAgICAgIHRhcmdldCA9ICJfYmxh bmsiOwotICAgICAgICBlbHNlIGlmICh0YXJnZXQuaXNFbXB0eSgpKSAvLyBpZiB0YXJnZXQgaXMg ZW1wdHksIGRlZmF1bHQgdG8gIl9zZWxmIiBvciB1c2UgeGxpbms6dGFyZ2V0IGlmIHNldAotICAg ICAgICAgICAgdGFyZ2V0ID0gKGdldEF0dHJpYnV0ZShYTGlua05hbWVzOjpzaG93QXR0cikgPT0g Im5ldyIpID8gIl9ibGFuayIgOiAiX3NlbGYiOwogCi0gICAgICAgIGlmICghZXZ0LT5kZWZhdWx0 UHJldmVudGVkKCkpIHsKKyAgICAgICAgaWYgKGlzTGlua0NsaWNrKGV2ZW50KSkgewogICAgICAg ICAgICAgU3RyaW5nIHVybCA9IGRlcHJlY2F0ZWRQYXJzZVVSTChocmVmKCkpOworCiAjaWYgRU5B QkxFKFNWR19BTklNQVRJT04pCi0gICAgICAgICAgICBpZiAodXJsLnN0YXJ0c1dpdGgoIiMiKSkg eworICAgICAgICAgICAgaWYgKHVybFswXSA9PSAnIycpIHsKICAgICAgICAgICAgICAgICBFbGVt ZW50KiB0YXJnZXRFbGVtZW50ID0gZG9jdW1lbnQoKS0+Z2V0RWxlbWVudEJ5SWQodXJsLnN1YnN0 cmluZygxKSk7CiAgICAgICAgICAgICAgICAgaWYgKFNWR1NNSUxFbGVtZW50Ojppc1NNSUxFbGVt ZW50KHRhcmdldEVsZW1lbnQpKSB7Ci0gICAgICAgICAgICAgICAgICAgIFNWR1NNSUxFbGVtZW50 KiB0aW1lZCA9IHN0YXRpY19jYXN0PFNWR1NNSUxFbGVtZW50Kj4odGFyZ2V0RWxlbWVudCk7Ci0g ICAgICAgICAgICAgICAgICAgIHRpbWVkLT5iZWdpbkJ5TGlua0FjdGl2YXRpb24oKTsKLSAgICAg ICAgICAgICAgICAgICAgZXZ0LT5zZXREZWZhdWx0SGFuZGxlZCgpOwotICAgICAgICAgICAgICAg ICAgICBTVkdTdHlsZWRUcmFuc2Zvcm1hYmxlRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihl dnQpOworICAgICAgICAgICAgICAgICAgICBzdGF0aWNfY2FzdDxTVkdTTUlMRWxlbWVudCo+KHRh cmdldEVsZW1lbnQpLT5iZWdpbkJ5TGlua0FjdGl2YXRpb24oKTsKKyAgICAgICAgICAgICAgICAg ICAgZXZlbnQtPnNldERlZmF1bHRIYW5kbGVkKCk7CiAgICAgICAgICAgICAgICAgICAgIHJldHVy bjsKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9CiAjZW5kaWYKLSAgICAgICAgICAg IGlmIChkb2N1bWVudCgpLT5mcmFtZSgpKQotICAgICAgICAgICAgICAgIGRvY3VtZW50KCktPmZy YW1lKCktPmxvYWRlcigpLT51cmxTZWxlY3RlZChkb2N1bWVudCgpLT5jb21wbGV0ZVVSTCh1cmwp LCB0YXJnZXQsIGV2dCwgZmFsc2UsIGZhbHNlLCB0cnVlLCBTZW5kUmVmZXJyZXIpOwotICAgICAg ICB9CiAKLSAgICAgICAgZXZ0LT5zZXREZWZhdWx0SGFuZGxlZCgpOworICAgICAgICAgICAgLy8g RklYTUU6IFdoeSBkb2VzIHRoZSBTVkcgYW5jaG9yIGVsZW1lbnQgaGF2ZSB0aGlzIHNwZWNpYWwg bG9naWMKKyAgICAgICAgICAgIC8vIGZvciBtaWRkbGUgY2xpY2sgdGhhdCB0aGUgSFRNTCBhbmNo b3IgZWxlbWVudCBkb2VzIG5vdCBoYXZlPworICAgICAgICAgICAgLy8gTWFraW5nIGEgbWlkZGxl IGNsaWNrIG9wZW4gYSBsaW5rIGluIGEgbmV3IHdpbmRvdyBvciB0YWIgaXMKKyAgICAgICAgICAg IC8vIHByb3Blcmx5IGhhbmRsZWQgYXQgdGhlIGNsaWVudCBsZXZlbCwgbm90IGluc2lkZSBXZWJL aXQ7IHRoaXMKKyAgICAgICAgICAgIC8vIGNvZGUgc2hvdWxkIGJlIGRlbGV0ZWQuCisgICAgICAg ICAgICBTdHJpbmcgdGFyZ2V0KGlzTWlkZGxlTW91c2VCdXR0b25FdmVudChldmVudCkgPyAiX2Js YW5rIiA6IHRoaXMtPnRhcmdldCgpKTsKKworICAgICAgICAgICAgLy8gRklYTUU6IEl0J3Mgbm90 IGNsZWFyIHdoeSBzZXR0aW5nIHRhcmdldCB0byAiX3NlbGYiIGlzIGV2ZXIKKyAgICAgICAgICAg IC8vIGhlbHBmdWwuCisgICAgICAgICAgICBpZiAodGFyZ2V0LmlzRW1wdHkoKSkKKyAgICAgICAg ICAgICAgICB0YXJnZXQgPSAoZ2V0QXR0cmlidXRlKFhMaW5rTmFtZXM6OnNob3dBdHRyKSA9PSAi bmV3IikgPyAiX2JsYW5rIiA6ICJfc2VsZiI7CisKKyAgICAgICAgICAgIGhhbmRsZUxpbmtDbGlj ayhldmVudCwgZG9jdW1lbnQoKSwgdXJsLCB0YXJnZXQpOworICAgICAgICAgICAgcmV0dXJuOwor ICAgICAgICB9CiAgICAgfQogCi0gICAgU1ZHU3R5bGVkVHJhbnNmb3JtYWJsZUVsZW1lbnQ6OmRl ZmF1bHRFdmVudEhhbmRsZXIoZXZ0KTsKKyAgICBTVkdTdHlsZWRUcmFuc2Zvcm1hYmxlRWxlbWVu dDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihldmVudCk7CiB9CiAKIGJvb2wgU1ZHQUVsZW1lbnQ6OnN1 cHBvcnRzRm9jdXMoKSBjb25zdApJbmRleDogV2ViQ29yZS93bWwvV01MQUVsZW1lbnQuY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvd21sL1dNTEFFbGVtZW50LmNwcAkocmV2aXNpb24gNjcyMjQp CisrKyBXZWJDb3JlL3dtbC9XTUxBRWxlbWVudC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQsNyAr NCw3IEBACiAgKiBDb3B5cmlnaHQgKEMpIDE5OTkgTGFycyBLbm9sbCAoa25vbGxAa2RlLm9yZykK ICAqICAgICAgICAgICAoQykgMTk5OSBBbnR0aSBLb2l2aXN0byAoa29pdmlzdG9Aa2RlLm9yZykK ICAqICAgICAgICAgICAoQykgMjAwMCBTaW1vbiBIYXVzbWFubiA8aGF1c21hbm5Aa2RlLm9yZz4K LSAqIENvcHlyaWdodCAoQykgMjAwMywgMjAwNiwgMjAwNywgMjAwOCBBcHBsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDMsIDIwMDYsIDIwMDcsIDIwMDgs IDIwMTAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICogICAgICAgICAgIChDKSAy MDA2IEdyYWhhbSBEZW5uaXMgKGdyYWhhbS5kZW5uaXNAZ21haWwuY29tKQogICoKICAqIFRoaXMg bGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IK QEAgLTM1LDYgKzM1LDcgQEAKICNpbmNsdWRlICJFdmVudE5hbWVzLmgiCiAjaW5jbHVkZSAiRnJh bWUuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRlci5oIgorI2luY2x1ZGUgIkhUTUxBbmNob3JFbGVt ZW50LmgiCiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCiAjaW5jbHVkZSAiS2V5Ym9hcmRFdmVudC5o IgogI2luY2x1ZGUgIk1vdXNlRXZlbnQuaCIKQEAgLTExOSwzNyArMTIwLDE3IEBAIGJvb2wgV01M QUVsZW1lbnQ6OmlzS2V5Ym9hcmRGb2N1c2FibGUoS2UKIAogdm9pZCBXTUxBRWxlbWVudDo6ZGVm YXVsdEV2ZW50SGFuZGxlcihFdmVudCogZXZlbnQpCiB7Ci0gICAgaWYgKGlzTGluaygpICYmIChl dmVudC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50IHx8IChldmVudC0+dHlwZSgp ID09IGV2ZW50TmFtZXMoKS5rZXlkb3duRXZlbnQgJiYgZm9jdXNlZCgpKSkpIHsKLSAgICAgICAg TW91c2VFdmVudCogZSA9IDA7Ci0gICAgICAgIGlmIChldmVudC0+dHlwZSgpID09IGV2ZW50TmFt ZXMoKS5jbGlja0V2ZW50ICYmIGV2ZW50LT5pc01vdXNlRXZlbnQoKSkKLSAgICAgICAgICAgIGUg PSBzdGF0aWNfY2FzdDxNb3VzZUV2ZW50Kj4oZXZlbnQpOwotCi0gICAgICAgIEtleWJvYXJkRXZl bnQqIGsgPSAwOwotICAgICAgICBpZiAoZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkua2V5 ZG93bkV2ZW50ICYmIGV2ZW50LT5pc0tleWJvYXJkRXZlbnQoKSkKLSAgICAgICAgICAgIGsgPSBz dGF0aWNfY2FzdDxLZXlib2FyZEV2ZW50Kj4oZXZlbnQpOwotCi0gICAgICAgIGlmIChlICYmIGUt PmJ1dHRvbigpID09IFJpZ2h0QnV0dG9uKSB7Ci0gICAgICAgICAgICBXTUxFbGVtZW50OjpkZWZh dWx0RXZlbnRIYW5kbGVyKGV2ZW50KTsKLSAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgfQot Ci0gICAgICAgIGlmIChrKSB7Ci0gICAgICAgICAgICBpZiAoay0+a2V5SWRlbnRpZmllcigpICE9 ICJFbnRlciIpIHsKLSAgICAgICAgICAgICAgICBXTUxFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5k bGVyKGV2ZW50KTsKLSAgICAgICAgICAgICAgICByZXR1cm47Ci0gICAgICAgICAgICB9Ci0KKyAg ICBpZiAoaXNMaW5rKCkpIHsKKyAgICAgICAgaWYgKGZvY3VzZWQoKSAmJiBpc0VudGVyS2V5S2V5 ZG93bkV2ZW50KGV2ZW50KSkgewogICAgICAgICAgICAgZXZlbnQtPnNldERlZmF1bHRIYW5kbGVk KCk7CiAgICAgICAgICAgICBkaXNwYXRjaFNpbXVsYXRlZENsaWNrKGV2ZW50KTsKICAgICAgICAg ICAgIHJldHVybjsKICAgICAgICAgfQotIAotICAgICAgICBpZiAoIWV2ZW50LT5kZWZhdWx0UHJl dmVudGVkKCkgJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKSkgewotICAgICAgICAgICAgS1VSTCB1cmwg PSBkb2N1bWVudCgpLT5jb21wbGV0ZVVSTChkZXByZWNhdGVkUGFyc2VVUkwoZ2V0QXR0cmlidXRl KEhUTUxOYW1lczo6aHJlZkF0dHIpKSk7Ci0gICAgICAgICAgICBkb2N1bWVudCgpLT5mcmFtZSgp LT5sb2FkZXIoKS0+dXJsU2VsZWN0ZWQodXJsLCB0YXJnZXQoKSwgZXZlbnQsIGZhbHNlLCBmYWxz ZSwgdHJ1ZSwgU2VuZFJlZmVycmVyKTsKLSAgICAgICAgfQogCi0gICAgICAgIGV2ZW50LT5zZXRE ZWZhdWx0SGFuZGxlZCgpOworICAgICAgICBpZiAoaXNMaW5rQ2xpY2soZXZlbnQpKSB7CisgICAg ICAgICAgICBoYW5kbGVMaW5rQ2xpY2soZG9jdW1lbnQoKSwgZGVwcmVjYXRlZFBhcnNlVVJMKGdl dEF0dHJpYnV0ZShIVE1MTmFtZXM6OmhyZWZBdHRyKSksIHRhcmdldCgpLCBldmVudCk7CisgICAg ICAgICAgICByZXR1cm47CisgICAgICAgIH0KICAgICB9CiAKICAgICBXTUxFbGVtZW50OjpkZWZh dWx0RXZlbnRIYW5kbGVyKGV2ZW50KTsK 67266 2010-09-10 16:56:18 -0700 2010-09-10 18:18:24 -0700 patch, functional portion, v1 patch text/plain 9122 pkasting SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NzI1MCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDQgKzEsMjUgQEAKLTIwMTAtMDktMTA5ICBQZXRlciBLYXN0aW5nICA8cGthc3RpbmdAZ29v Z2xlLmNvbT4KKzIwMTAtMDktMTAgIFBldGVyIEthc3RpbmcgIDxwa2FzdGluZ0Bnb29nbGUuY29t PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE1ha2Ug bWlkZGxlIGNsaWNrcyBub3QgZmlyZSBET00gb25jbGljayBldmVudHMuCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjM4MgorCisgICAgICAgICogaHRt bC9IVE1MQW5jaG9yRWxlbWVudC5jcHA6IEV4cGxpY2l0bHkgaW5jbHVkZSBtaWRkbGUtY2xpY2tz IGluIHRoZQorICAgICAgICBjb21wdXRhdGlvbiBvZiB3aGF0IGNvbnN0aXR1dGVzIGEgbGluayBj bGljaywgc2luY2UgdGhleSdyZSBubyBsb25nZXIKKyAgICAgICAgaW1wbGljaXRseSBpbmNsdWRl ZC4KKyAgICAgICAgKFdlYkNvcmU6OmlzTGlua0NsaWNrKToKKyAgICAgICAgKiBodG1sL0hUTUxJ bnB1dEVsZW1lbnQuY3BwOiBSZW1vdmVkIHVubmVlZGVkIGNoZWNrcyB0aGF0IGNsaWNrIGV2ZW50 cworICAgICAgICBhcmUgY29taW5nIGZyb20gdGhlIGxlZnQgbW91c2UgYnV0dG9uLCBzaW5jZSB0 aGV5IGFsbCBhcmUgbm93LgorICAgICAgICAoV2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6cHJl RGlzcGF0Y2hFdmVudEhhbmRsZXIpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTElucHV0RWxlbWVu dDo6cG9zdERpc3BhdGNoRXZlbnRIYW5kbGVyKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1 dEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIpOgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5k bGVyLmNwcDogQ2hhbmdlZCBsb2dpYyB0byBzZW5kIGEgY2xpY2sgZXZlbnQgb25seSBmb3IKKyAg ICAgICAgdGhlIGxlZnQgYnV0dG9uLgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpo YW5kbGVNb3VzZURvdWJsZUNsaWNrRXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5k bGVyOjpoYW5kbGVNb3VzZVJlbGVhc2VFdmVudCk6CisKKzIwMTAtMDktMTAgIFBldGVyIEthc3Rp bmcgIDxwa2FzdGluZ0Bnb29nbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFk bGVyLgogCkluZGV4OiBXZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAJKHJldmlzaW9uIDY3MjQ2 KQorKysgV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcAkod29ya2luZyBjb3B5KQpA QCAtNTE0LDcgKzUxNCw3IEBAIGJvb2wgaXNNaWRkbGVNb3VzZUJ1dHRvbkV2ZW50KEV2ZW50KiBl dmUKIAogYm9vbCBpc0xpbmtDbGljayhFdmVudCogZXZlbnQpCiB7Ci0gICAgcmV0dXJuIGV2ZW50 LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmNsaWNrRXZlbnQgJiYgKCFldmVudC0+aXNNb3VzZUV2 ZW50KCkgfHwgc3RhdGljX2Nhc3Q8TW91c2VFdmVudCo+KGV2ZW50KS0+YnV0dG9uKCkgIT0gUmln aHRCdXR0b24pOworICAgIHJldHVybiBldmVudC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlj a0V2ZW50IHx8IChldmVudC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5tb3VzZXVwRXZlbnQgJiYg aXNNaWRkbGVNb3VzZUJ1dHRvbkV2ZW50KGV2ZW50KSk7CiB9CiAKIHZvaWQgaGFuZGxlTGlua0Ns aWNrKEV2ZW50KiBldmVudCwgRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBTdHJpbmcmIHVybCwg Y29uc3QgU3RyaW5nJiB0YXJnZXQsIGJvb2wgaGlkZVJlZmVycmVyKQpJbmRleDogV2ViQ29yZS9o dG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaHRtbC9IVE1M SW5wdXRFbGVtZW50LmNwcAkocmV2aXNpb24gNjcyNDIpCisrKyBXZWJDb3JlL2h0bWwvSFRNTElu cHV0RWxlbWVudC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTIxNTUsMTYgKzIxNTUsMTMgQEAgc3Ry dWN0IEV2ZW50SGFuZGxpbmdTdGF0ZSA6IEZhc3RBbGxvY0JhcwogICAgICAgICAsIG1fY2hlY2tl ZChjaGVja2VkKSB7IH0KIH07CiAKLXZvaWQqIEhUTUxJbnB1dEVsZW1lbnQ6OnByZURpc3BhdGNo RXZlbnRIYW5kbGVyKEV2ZW50ICpldnQpCit2b2lkKiBIVE1MSW5wdXRFbGVtZW50OjpwcmVEaXNw YXRjaEV2ZW50SGFuZGxlcihFdmVudCogZXZ0KQogewogICAgIC8vIHByZXZlbnREZWZhdWx0IG9y ICJyZXR1cm4gZmFsc2UiIGFyZSB1c2VkIHRvIHJldmVyc2UgdGhlIGF1dG9tYXRpYyBjaGVja2lu Zy9zZWxlY3Rpb24gd2UgZG8gaGVyZS4KICAgICAvLyBUaGlzIHJlc3VsdCBnaXZlcyB1cyBlbm91 Z2ggaW5mbyB0byBwZXJmb3JtIHRoZSAidW5kbyIgaW4gcG9zdERpc3BhdGNoIG9mIHRoZSBhY3Rp b24gd2UgdGFrZSBoZXJlLgogICAgIHZvaWQqIHJlc3VsdCA9IDA7IAotICAgIGlmICgoaW5wdXRU eXBlKCkgPT0gQ0hFQ0tCT1ggfHwgaW5wdXRUeXBlKCkgPT0gUkFESU8pICYmIGV2dC0+aXNNb3Vz ZUV2ZW50KCkKLSAgICAgICAgICAgICYmIGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlj a0V2ZW50ICYmIHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldnQpLT5idXR0b24oKSA9PSBMZWZ0 QnV0dG9uKSB7Ci0gICAgICAgIAorICAgIGlmICgoaW5wdXRUeXBlKCkgPT0gQ0hFQ0tCT1ggfHwg aW5wdXRUeXBlKCkgPT0gUkFESU8pICYmIGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlj a0V2ZW50KSB7CiAgICAgICAgIE93blB0cjxFdmVudEhhbmRsaW5nU3RhdGU+IHN0YXRlID0gYWRv cHRQdHIobmV3IEV2ZW50SGFuZGxpbmdTdGF0ZShpbmRldGVybWluYXRlKCksIGNoZWNrZWQoKSkp OwotCiAgICAgICAgIGlmIChpbnB1dFR5cGUoKSA9PSBDSEVDS0JPWCkgewogICAgICAgICAgICAg aWYgKGluZGV0ZXJtaW5hdGUoKSkKICAgICAgICAgICAgICAgICBzZXRJbmRldGVybWluYXRlKGZh bHNlKTsKQEAgLTIxOTIsOCArMjE4OSw3IEBAIHZvaWQqIEhUTUxJbnB1dEVsZW1lbnQ6OnByZURp c3BhdGNoRXZlbnQKIAogdm9pZCBIVE1MSW5wdXRFbGVtZW50Ojpwb3N0RGlzcGF0Y2hFdmVudEhh bmRsZXIoRXZlbnQgKmV2dCwgdm9pZCogZGF0YSkKIHsKLSAgICBpZiAoKGlucHV0VHlwZSgpID09 IENIRUNLQk9YIHx8IGlucHV0VHlwZSgpID09IFJBRElPKSAmJiBldnQtPmlzTW91c2VFdmVudCgp Ci0gICAgICAgICAgICAmJiBldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCAm JiBzdGF0aWNfY2FzdDxNb3VzZUV2ZW50Kj4oZXZ0KS0+YnV0dG9uKCkgPT0gTGVmdEJ1dHRvbikg eworICAgIGlmICgoaW5wdXRUeXBlKCkgPT0gQ0hFQ0tCT1ggfHwgaW5wdXRUeXBlKCkgPT0gUkFE SU8pICYmIGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50KSB7CiAgICAgICAg IAogICAgICAgICBpZiAoRXZlbnRIYW5kbGluZ1N0YXRlKiBzdGF0ZSA9IHJlaW50ZXJwcmV0X2Nh c3Q8RXZlbnRIYW5kbGluZ1N0YXRlKj4oZGF0YSkpIHsKICAgICAgICAgICAgIGlmIChpbnB1dFR5 cGUoKSA9PSBDSEVDS0JPWCkgewpAQCAtMjI3NiwxMCArMjI3Miw3IEBAIHZvaWQgSFRNTElucHV0 RWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGwKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAg IGlmIChpbnB1dFR5cGUoKSA9PSBSQURJTwotICAgICAgICAgICAgJiYgZXZ0LT5pc01vdXNlRXZl bnQoKQotICAgICAgICAgICAgJiYgZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmNsaWNrRXZl bnQKLSAgICAgICAgICAgICYmIHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldnQpLT5idXR0b24o KSA9PSBMZWZ0QnV0dG9uKSB7CisgICAgaWYgKGlucHV0VHlwZSgpID09IFJBRElPICYmIGV2dC0+ dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50KSB7CiAgICAgICAgIGV2dC0+c2V0RGVm YXVsdEhhbmRsZWQoKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KSW5kZXg6IFdlYkNvcmUvcGFn ZS9FdmVudEhhbmRsZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9FdmVudEhhbmRs ZXIuY3BwCShyZXZpc2lvbiA2NzI0MikKKysrIFdlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC0xMzc1LDE3ICsxMzc1LDEyIEBAIGJvb2wgRXZlbnRIYW5kbGVy OjpoYW5kbGVNb3VzZURvdWJsZUNsaWMKICAgICBtX2NsaWNrQ291bnQgPSBtb3VzZUV2ZW50LmNs aWNrQ291bnQoKTsKICAgICBib29sIHN3YWxsb3dNb3VzZVVwRXZlbnQgPSBkaXNwYXRjaE1vdXNl RXZlbnQoZXZlbnROYW1lcygpLm1vdXNldXBFdmVudCwgbWV2LnRhcmdldE5vZGUoKSwgdHJ1ZSwg bV9jbGlja0NvdW50LCBtb3VzZUV2ZW50LCBmYWxzZSk7CiAKLSAgICBib29sIHN3YWxsb3dDbGlj a0V2ZW50ID0gZmFsc2U7Ci0gICAgLy8gRG9uJ3QgZXZlciBkaXNwYXRjaCBjbGljayBldmVudHMg Zm9yIHJpZ2h0IGNsaWNrcwotICAgIGlmIChtb3VzZUV2ZW50LmJ1dHRvbigpICE9IFJpZ2h0QnV0 dG9uICYmIG1ldi50YXJnZXROb2RlKCkgPT0gbV9jbGlja05vZGUpCi0gICAgICAgIHN3YWxsb3dD bGlja0V2ZW50ID0gZGlzcGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50LCBt ZXYudGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNrQ291bnQsIG1vdXNlRXZlbnQsIHRydWUpOwor ICAgIGJvb2wgc3dhbGxvd0NsaWNrRXZlbnQgPSBtb3VzZUV2ZW50LmJ1dHRvbigpID09IExlZnRC dXR0b24gJiYgbWV2LnRhcmdldE5vZGUoKSA9PSBtX2NsaWNrTm9kZSAmJiBkaXNwYXRjaE1vdXNl RXZlbnQoZXZlbnROYW1lcygpLmNsaWNrRXZlbnQsIG1ldi50YXJnZXROb2RlKCksIHRydWUsIG1f Y2xpY2tDb3VudCwgbW91c2VFdmVudCwgdHJ1ZSk7CiAKICAgICBpZiAobV9sYXN0U2Nyb2xsYmFy VW5kZXJNb3VzZSkKICAgICAgICAgc3dhbGxvd01vdXNlVXBFdmVudCA9IG1fbGFzdFNjcm9sbGJh clVuZGVyTW91c2UtPm1vdXNlVXAoKTsKLSAgICAgICAgICAgIAotICAgIGJvb2wgc3dhbGxvd01v dXNlUmVsZWFzZUV2ZW50ID0gZmFsc2U7Ci0gICAgaWYgKCFzd2FsbG93TW91c2VVcEV2ZW50KQot ICAgICAgICBzd2FsbG93TW91c2VSZWxlYXNlRXZlbnQgPSBoYW5kbGVNb3VzZVJlbGVhc2VFdmVu dChtZXYpOworCisgICAgYm9vbCBzd2FsbG93TW91c2VSZWxlYXNlRXZlbnQgPSAhc3dhbGxvd01v dXNlVXBFdmVudCAmJiBoYW5kbGVNb3VzZVJlbGVhc2VFdmVudChtZXYpOwogCiAgICAgaW52YWxp ZGF0ZUNsaWNrKCk7CiAKQEAgLTE1NzEsMTAgKzE1NjYsNyBAQCBib29sIEV2ZW50SGFuZGxlcjo6 aGFuZGxlTW91c2VSZWxlYXNlRXZlCiAKICAgICBib29sIHN3YWxsb3dNb3VzZVVwRXZlbnQgPSBk aXNwYXRjaE1vdXNlRXZlbnQoZXZlbnROYW1lcygpLm1vdXNldXBFdmVudCwgbWV2LnRhcmdldE5v ZGUoKSwgdHJ1ZSwgbV9jbGlja0NvdW50LCBtb3VzZUV2ZW50LCBmYWxzZSk7CiAKLSAgICAvLyBE b24ndCBldmVyIGRpc3BhdGNoIGNsaWNrIGV2ZW50cyBmb3IgcmlnaHQgY2xpY2tzCi0gICAgYm9v bCBzd2FsbG93Q2xpY2tFdmVudCA9IGZhbHNlOwotICAgIGlmIChtX2NsaWNrQ291bnQgPiAwICYm IG1vdXNlRXZlbnQuYnV0dG9uKCkgIT0gUmlnaHRCdXR0b24gJiYgbWV2LnRhcmdldE5vZGUoKSA9 PSBtX2NsaWNrTm9kZSkKLSAgICAgICAgc3dhbGxvd0NsaWNrRXZlbnQgPSBkaXNwYXRjaE1vdXNl RXZlbnQoZXZlbnROYW1lcygpLmNsaWNrRXZlbnQsIG1ldi50YXJnZXROb2RlKCksIHRydWUsIG1f Y2xpY2tDb3VudCwgbW91c2VFdmVudCwgdHJ1ZSk7CisgICAgYm9vbCBzd2FsbG93Q2xpY2tFdmVu dCA9IG1fY2xpY2tDb3VudCA+IDAgJiYgbW91c2VFdmVudC5idXR0b24oKSA9PSBMZWZ0QnV0dG9u ICYmIG1ldi50YXJnZXROb2RlKCkgPT0gbV9jbGlja05vZGUgJiYgZGlzcGF0Y2hNb3VzZUV2ZW50 KGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNr Q291bnQsIG1vdXNlRXZlbnQsIHRydWUpOwogCiAgICAgaWYgKG1fcmVzaXplTGF5ZXIpIHsKICAg ICAgICAgbV9yZXNpemVMYXllci0+c2V0SW5SZXNpemVNb2RlKGZhbHNlKTsKSW5kZXg6IExheW91 dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHJl dmlzaW9uIDY3MjUwKQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTMgQEAKKzIwMTAtMDktMTAgIFBldGVyIEthc3RpbmcgIDxwa2FzdGluZ0Bnb29n bGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IE1ha2UgbWlkZGxlIGNsaWNrcyBub3QgZmlyZSBET00gb25jbGljayBldmVudHMuCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjM4MgorCisgICAgICAg ICogZmFzdC9ldmVudHMvbW91c2UtY2xpY2stZXZlbnRzLWV4cGVjdGVkLnR4dDoKKyAgICAgICAg KiBmYXN0L2V2ZW50cy9zY3JpcHQtdGVzdHMvbW91c2UtY2xpY2stZXZlbnRzLmpzOgorCiAyMDEw LTA5LTEwICBKaWFuIExpICA8amlhbmxpQGNocm9taXVtLm9yZz4KIAogICAgICAgICBVcGRhdGUg bWFjL1NraXBwZWQgdG8gaW5jbHVkZSB0aGUgYnVnIG51bWJlcnMgZm9yIG5ld2x5IGFkZGVkIHNr aXAgZW50cmllcy4KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZXZlbnRzL21vdXNlLWNsaWNrLWV2 ZW50cy1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMv bW91c2UtY2xpY2stZXZlbnRzLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gNjcyNDIpCisrKyBMYXlv dXRUZXN0cy9mYXN0L2V2ZW50cy9tb3VzZS1jbGljay1ldmVudHMtZXhwZWN0ZWQudHh0CSh3b3Jr aW5nIGNvcHkpCkBAIC02LDExICs2LDExIEBAIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNl cmllcyBvZiAiUEEKIExlZnQgTW91c2UgQnV0dG9uCiBQQVNTIGV2ZW50TG9nIGlzICJtb3VzZWRv d24oMCkgbW91c2V1cCgwKSBjbGljaygwKSBtb3VzZWRvd24oMCkgbW91c2V1cCgwKSBjbGljaygw KSBkYmxjbGljaygwKSAiCiBNaWRkbGUgTW91c2UgQnV0dG9uCi1QQVNTIGV2ZW50TG9nIGlzICJt b3VzZWRvd24oMSkgbW91c2V1cCgxKSBjbGljaygxKSBtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBj bGljaygxKSBkYmxjbGljaygxKSAiCitQQVNTIGV2ZW50TG9nIGlzICJtb3VzZWRvd24oMSkgbW91 c2V1cCgxKSBtb3VzZWRvd24oMSkgbW91c2V1cCgxKSAiCiBSaWdodCBNb3VzZSBCdXR0b24KIFBB U1MgZXZlbnRMb2cgaXMgIm1vdXNlZG93bigyKSBtb3VzZXVwKDIpIG1vdXNlZG93bigyKSBtb3Vz ZXVwKDIpICIKIDR0aCBNb3VzZSBCdXR0b24KLVBBU1MgZXZlbnRMb2cgaXMgIm1vdXNlZG93bigx KSBtb3VzZXVwKDEpIGNsaWNrKDEpIG1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGNsaWNrKDEpIGRi bGNsaWNrKDEpICIKK1BBU1MgZXZlbnRMb2cgaXMgIm1vdXNlZG93bigxKSBtb3VzZXVwKDEpIG1v dXNlZG93bigxKSBtb3VzZXVwKDEpICIKIFBBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUK IAogVEVTVCBDT01QTEVURQpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2NyaXB0LXRl c3RzL21vdXNlLWNsaWNrLWV2ZW50cy5qcwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0 L2V2ZW50cy9zY3JpcHQtdGVzdHMvbW91c2UtY2xpY2stZXZlbnRzLmpzCShyZXZpc2lvbiA2NzI0 MikKKysrIExheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3NjcmlwdC10ZXN0cy9tb3VzZS1jbGljay1l dmVudHMuanMJKHdvcmtpbmcgY29weSkKQEAgLTQ5LDkgKzQ5LDkgQEAgZnVuY3Rpb24gdGVzdEV2 ZW50cyhkZXNjcmlwdGlvbiwgYnV0dG9uLAogCiBpZiAod2luZG93LmV2ZW50U2VuZGVyKSB7CiAg ICAgdGVzdEV2ZW50cygiTGVmdCBNb3VzZSBCdXR0b24iLCAwLCAibW91c2Vkb3duKDApIG1vdXNl dXAoMCkgY2xpY2soMCkgbW91c2Vkb3duKDApIG1vdXNldXAoMCkgY2xpY2soMCkgZGJsY2xpY2so MCkgIik7Ci0gICAgdGVzdEV2ZW50cygiTWlkZGxlIE1vdXNlIEJ1dHRvbiIsIDEsICJtb3VzZWRv d24oMSkgbW91c2V1cCgxKSBjbGljaygxKSBtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBjbGljaygx KSBkYmxjbGljaygxKSAiKTsKKyAgICB0ZXN0RXZlbnRzKCJNaWRkbGUgTW91c2UgQnV0dG9uIiwg MSwgIm1vdXNlZG93bigxKSBtb3VzZXVwKDEpIG1vdXNlZG93bigxKSBtb3VzZXVwKDEpICIpOwog ICAgIHRlc3RFdmVudHMoIlJpZ2h0IE1vdXNlIEJ1dHRvbiIsIDIsICJtb3VzZWRvd24oMikgbW91 c2V1cCgyKSBtb3VzZWRvd24oMikgbW91c2V1cCgyKSAiKTsKLSAgICB0ZXN0RXZlbnRzKCI0dGgg TW91c2UgQnV0dG9uIiwgMywgIm1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGNsaWNrKDEpIG1vdXNl ZG93bigxKSBtb3VzZXVwKDEpIGNsaWNrKDEpIGRibGNsaWNrKDEpICIpOworICAgIHRlc3RFdmVu dHMoIjR0aCBNb3VzZSBCdXR0b24iLCAzLCAibW91c2Vkb3duKDEpIG1vdXNldXAoMSkgbW91c2Vk b3duKDEpIG1vdXNldXAoMSkgIik7CiB9CiAKIHZhciBzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVl Owo= 80001 2011-01-24 17:54:30 -0800 2011-01-24 17:54:30 -0800 onmouseup target testcase test1.html text/html 534 pkasting PGh0bWw+DQo8aGVhZD4NCjxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4NCmZ1bmN0aW9u IHdoaWNoRWxlbWVudChlKQ0Kew0KdmFyIHRhcmc7DQppZiAoIWUpIHZhciBlID0gd2luZG93LmV2 ZW50Ow0KaWYgKGUudGFyZ2V0KSB0YXJnID0gZS50YXJnZXQ7DQplbHNlIGlmIChlLnNyY0VsZW1l bnQpIHRhcmcgPSBlLnNyY0VsZW1lbnQ7DQppZiAodGFyZy5ub2RlVHlwZSA9PSAzKSAvLyBkZWZl YXQgU2FmYXJpIGJ1Zw0KdGFyZyA9IHRhcmcucGFyZW50Tm9kZTsNCnZhciB0bmFtZTsNCnRuYW1l PXRhcmcudGFnTmFtZTsNCmFsZXJ0KCJZb3UgY2xpY2tlZCBvbiBhICIgKyB0bmFtZSArICIgZWxl bWVudC4iKTsNCn0NCjwvc2NyaXB0Pg0KPC9oZWFkPg0KDQo8Ym9keSBvbm1vdXNldXA9IndoaWNo RWxlbWVudChldmVudCkiPg0KPGgyPlRoaXMgaXMgYSBoZWFkZXI8L2gyPg0KPHA+VGhpcyBpcyBh IHBhcmFncmFwaDwvcD4NCjxpbWcgYm9yZGVyPSIwIiBzcmM9ImJhbGwxNi5naWYiIGFsdD0iQmFs bCI+DQo8L2JvZHk+DQo8L2h0bWw+ 80002 2011-01-24 18:00:03 -0800 2011-01-24 18:00:03 -0800 opening links on events testcase test2.html text/html 1658 pkasting PGh0bWw+DQo8aGVhZD4NCjxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4NCmZ1bmN0aW9u IGZpcmVNb3VzZUV2ZW50KG5hbWUpIHsNCiAgdmFyIG1vdXNlRXZlbnQgPSBkb2N1bWVudC5jcmVh dGVFdmVudCgnTW91c2VFdmVudHMnKTsNCiAgbW91c2VFdmVudC5pbml0TW91c2VFdmVudCggbmFt ZSwgdHJ1ZSwgdHJ1ZSwgd2luZG93LCAwLCAwLCAwLCAwLCAwLCBmYWxzZSwgZmFsc2UsIGZhbHNl LCBmYWxzZSwgMSwgbnVsbCApOw0KICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnbGluazMnKS5k aXNwYXRjaEV2ZW50KG1vdXNlRXZlbnQpOw0KfQ0KZnVuY3Rpb24gZGlzcGxheUV2ZW50TmFtZShl dmVudCkgew0KICB2YXIgb3V0cHV0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ291dHB1dCcp Ow0KICBvdXRwdXQuaW5uZXJIVE1MICs9IGV2ZW50LnR5cGUgKyAnPGJyPic7DQogIC8vZXZlbnQu cHJldmVudERlZmF1bHQoKTsNCn0NCmZ1bmN0aW9uIGluaXQoKSB7DQogIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCdsaW5rMScpLmFkZEV2ZW50TGlzdGVuZXIoJ21vdXNlb3ZlcicsIGZ1bmN0aW9u KCkgeyBmaXJlTW91c2VFdmVudCgnbW91c2Vkb3duJyk7IH0sIGZhbHNlKTsNCiAgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ2xpbmsyJykuYWRkRXZlbnRMaXN0ZW5lcignbW91c2VvdmVyJywgZnVu Y3Rpb24oKSB7IGZpcmVNb3VzZUV2ZW50KCdtb3VzZXVwJyk7IGZpcmVNb3VzZUV2ZW50KCdjbGlj aycsIGZpcmVUYXJnZXQpOyB9LCBmYWxzZSk7DQogIHZhciBmaXJlVGFyZ2V0ID0gZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ2xpbmszJyk7DQogIGZpcmVUYXJnZXQuYWRkRXZlbnRMaXN0ZW5lcign bW91c2Vkb3duJywgZnVuY3Rpb24oZXZlbnQpIHsgZGlzcGxheUV2ZW50TmFtZShldmVudCk7IH0s IGZhbHNlKTsNCiAgZmlyZVRhcmdldC5hZGRFdmVudExpc3RlbmVyKCdtb3VzZXVwJywgZnVuY3Rp b24oZXZlbnQpIHsgZGlzcGxheUV2ZW50TmFtZShldmVudCk7IH0sIGZhbHNlKTsNCiAgZmlyZVRh cmdldC5hZGRFdmVudExpc3RlbmVyKCdjbGljaycsIGZ1bmN0aW9uKGV2ZW50KSB7IGRpc3BsYXlF dmVudE5hbWUoZXZlbnQpOyAvKmV2ZW50LnByZXZlbnREZWZhdWx0KCk7Ki8gfSwgZmFsc2UpOw0K fQ0Kd2luZG93Lm9ubG9hZCA9IGluaXQ7DQo8L3NjcmlwdD4NCjwvaGVhZD4NCg0KPGJvZHk+DQo8 cD5Nb3VzaW5nIG92ZXIgbGluayAxIHdpbGwgZmlyZSAibW91c2Vkb3duIiBhdCBsaW5rIDMuICBN b3VzaW5nIG92ZXIgbGluayAyIHdpbGwgZmlyZSAibW91c2V1cCIgYW5kICJjbGljayIgYXQgbGlu ayAzLiAgQWxsIGV2ZW50cyBhcmUgc2V0IHRvIGJ1dHRvbiAxIChtaWRkbGUgYnV0dG9uKS48L3A+ DQo8cD5IZXJlIGlzIGxpbmsgMTogPGEgaHJlZj0iaHR0cDovL3d3dy5nb29nbGUuY29tIiBpZD0i bGluazEiPkdvb2dsZTwvYT48YnI+DQpIZXJlIGlzIGxpbmsgMjogPGEgaHJlZj0iaHR0cDovL3d3 dy55YWhvby5jb20iIGlkPSJsaW5rMiI+WWFob288L2E+PGJyPg0KSGVyZSBpcyBsaW5rIDM6IDxh IGhyZWY9Imh0dHA6Ly93d3cuYmluZy5jb20iIGlkPSJsaW5rMyI+QmluZzwvYT48YnI+PC9wPg0K PGRpdiBpZD0ib3V0cHV0IiB3aWR0aD01MDAgaGVpZ2h0PTUwMD48L2Rpdj4NCjwvYm9keT4NCjwv aHRtbD4= 80003 2011-01-24 18:02:45 -0800 2011-01-24 18:02:45 -0800 middle-mouse autoscroll testcase test3.html text/html 486 pkasting PGh0bWw+DQo8aGVhZD4NCjxzY3JpcHQ+DQogICAgZnVuY3Rpb24gaW5pdCgpIHsNCiAgICAgICAg ZG9jdW1lbnQuYm9keS5hZGRFdmVudExpc3RlbmVyKCdtb3VzZWRvd24nLCBmdW5jdGlvbihlKSB7 IGUucHJldmVudERlZmF1bHQoKTsgfSwgZmFsc2UpOw0KICAgICAgICBkb2N1bWVudC5ib2R5LmFk ZEV2ZW50TGlzdGVuZXIoJ21vdXNldXAnLCBmdW5jdGlvbihlKSB7IGUucHJldmVudERlZmF1bHQo KTsgfSwgZmFsc2UpOw0KICAgICAgICBkb2N1bWVudC5ib2R5LmFkZEV2ZW50TGlzdGVuZXIoJ2Ns aWNrJywgZnVuY3Rpb24oZSkgeyBlLnByZXZlbnREZWZhdWx0KCk7IH0sIGZhbHNlKTsNCiAgICB9 DQogICAgd2luZG93Lm9ubG9hZCA9IGluaXQ7DQo8L3NjcmlwdD4NCjwvaGVhZD4NCjxib2R5IHN0 eWxlPSJvdmVyZmxvdzphdXRvIj4NCjxkaXYgc3R5bGU9ImhlaWdodDoxMDAwcHg7d2lkdGg6MTAw MHB4OyI+PC9kaXY+DQo8L2JvZHk+DQo8L2h0bWw+ 138742 2012-04-24 23:24:17 -0700 2012-04-24 23:24:17 -0700 Safari extension to cancel unwanted click events click.safariextz application/x-safari-safariextz 4696 webkit eGFyIQAcAAEAAAAAAAAO3gAAAAAAABpMAAAAAXja1FdZs6LIEn43wv9wou+j0S2guEyc7okq9l1A EHhjk0UWFZHl199S+8zcM9MTN+7jfTAsqrIyk8z8vkzef+/L4u0eX5usrr5/wb9hX97iKqyjrEq+ f7H27NfNl99/TN57//pj8vZ+q0P09/YeXmP/hm58vWVl/IPAcOIrtvxKkHts9Ru++o1cv88/izwv pXF4atryrbkNRfz9S5P6+JfHydt7fTw28e0H9j7/uXruNtn4UP4+fy4eKuYfOp5PTZZU/q29xl8/ G1uQa4xYL/H1t8Xj7q+FPin4cMkwwWePiF+6RK7+9OntXYoHoTrWbyiSVfP9S3q7nX+bz7uu+9Yt vtXXZE5gGDbHtnMkECGT/3qZeHt3SGxL+zf/9fh6puLrLTtmoX+LfyiCwHo5RUFmlYBOgCARBL3B g5IL2Q2FdbTuilLtCek9VIHOsFAHXeK5PTUCESaqDYG7B4W9n04UQ+kY3aVtXZdocIYhDxvPhGJQ Kq1idp2UPM9kmlI/zpxgITYeH509zkoMzia8Q3+fTkLOHgRWLAKOxfzDtg1HllEYgQO4xYCuW+sO 7AJ0wya2Q8AZC/9gFAJjFFFpN8ECFmEGTaQpnU4irrgHlZLohD2gdekf1PS5l0EYOUaN7J8j/tTx aagqe6FTaQFXaAtXRr07PPeU5x56u4/dHJ4Vo+444EqUJ5SZtxtkTodA7ySLSW2l8Gy9iDSNZmYK 3X34jFsEW7qOeJ5OPnma14nEhoSC3dQ9Gxl27p4Fju1Cri90FJeA62vfEUeXSFqX2LTRofkj8tPJ M/aniEI5hEIOVJicLukp47YdBh+5AkCjgL4Bj3MqkdCaAZUGuxTvbUZrBcdWtj1bF9PJIlsJLbce jdWsvGKMEWpEuze6upwfUz3ZijNiu5XzVSHF43o3cMA76RQuLPt1EXcG6Z88bEdRo40ifk2jjZwe j0cDN2khIMWUlNnosksOS8kPQnwb3kF1PB8FquvDo32W0u60b081tbI7aAn3ikyFg2wp00kvCStu GccAKuoi0ha7mCL2NxO35/0AV6kQznRJutoqgxlgdg1LO0+KDJ/7JF4c2rUWKJK0Jh1en05qXcTO 1MBrvbNYqykDhut55gvq4uIbc129dJd7nAuUl0ARu3GW6RnUITc9q73inqQlemDQVkgW5nRSmTtB rQsgnSJVJMbZApqr8MicdXx52ZDOOuoEGugA1ksBLhGqQLTsdrorSJ0LoW7xKAOMsgeoxhUK4yiq 4YBusXAEMM3YOuKNTss294BQx5Ai0xdKyDwgsJ97+CIijEGhhY5/IM3ANFQF0GVYfmNns93A1umK VaRaFJsqYCPidJFFBTyrMGI6Bs47nVIA6PjueTuHMOnYGlgZFTrTCeWXBMdR8lprV9tT5PW2aNXr sEsSZveoON4EDFpzj3oCOYW0fXBDlHvAgorA9+hHI5+S5AqTB1uE1EPylgywwR+ILtKgVAuB27YC b6DaVhL3EzatxK1OiXsgSYGHqJ7CyiARIsZwYd+8h/RBzT0HYkgiRwxy9zKI+ehWxKUFQvUzZg9N btkXAq8+5E4IdyeEO94owhIfkbbWoyCKKnnyHeOM/tHethR4e/TM7m/+hNz2oZH8uDedeI6IeMk7 u8SLn5CnA/ILrdWXTccogoPdRjxiPur0Z54Rv7Ip/keeET8tooVcvvAul+o9MLevrCPb8gi0Z9T1 DQTHDQOBQsEl6NhX7gqg83MIsI5CWZhO/syDLihQ4ajswplCsHAJ/WH7qQEkFlAAqjvzdUbrzKMq AUDVCnQoWJ7voxr3aNza+rrlnHV4gc7+QGX8pjFEgjBbfrA2QZps6INxtG631UZsYM9m8jkuW1ko +bC9cgY92zAcNp0c+IyGfgyjzlXvM0fd9pdlqe68fOm1deku/HS46ifKATbYXnk5u116Yq4nZ4u6 uaNyvyyDcesW3QVVpiWYPp8Rcwvv8J0TJWPcb5occ5q5fT5YnM8b2gLbuOt5iq2t2I0aE98p9U6v bp7KxdJ1vta5Oc+jOJnV8mDP6mzRtrY8Mwx7c0tFFlu43H0m1bCnZnLS3y+zI7PCQ13kLFE4XsYS G3iMVOM9f9DglkvC6WSV7ISQ1cqF7ebQB/jVIsjSW/mVNxuP3lYctdXQiYqkVv0eCgp4n/+19/5z S2aEEZFH1360ZMjt/0rvFgtomCl601GvpssxnWhbI7NXIPNsOyhsqSJ9NEsTAUbOmVKh9Ocp1SvR x9l/aY/9dMLmCN/Pdq/saetVsKhF34OFnugY82qgdNIpOYMp+wRXcwV/NVD30x4qCkQHRc7ICjg9 /YCpQtm20jMjMF4WaoSZnxaYonWHZS/T4PI6axQBe50hQLPRPSz7U0QUJ0QFjOd4iGC2necIiYUa rPsT3Iqld/pr+KBp+va34QMB+j/Gj78NHwOk/wZ4hsUR4SDrBRbvUaZM4TkofcDwOSohaAH6QZ2A RhJ6TaE1Cl+9tKVAti9XQaQLYeWO7ZqdLY+Db9xpYx835MZdPogPEX181sP8llczi8Jsu0g72Vkz QcNK6X5536grhruwzuBv19xue5mllmkalsD5w4UY6mHtebnPCmhM2LmDtJa3V050ErDq4NELWW+z 1FLPWvgtJt4uZDXa7KnaeCEW9E5QhnjCu8RZiGGQZzuCaux91aCIE+xlvq93MI+kPW6c+9uBCqu9 qtnHk3kAA9dCV+1ie2G4uG7K9VWOTSuN+boXF5wvHbp63lfHilpNJ6Ao5AiTDC2o8DFmlfUGrE1h KEmTjeaH86VdhQf1QJvkZTEaWSWuFE1eORXwS7ZiA7mbx3Z958TjdBI0M28RbwJ3vjI9v0GoYQDw NXhFdXb5BYUC1+3oF4XuXxRqdegOnE7mI4he0kuGTfRnU/ynlvjXBipt4dkgDYI6rhHx+Uus1aVg YWD4nGKXnZo8pY+Q2nTyHlxrqkzEpVsg2sJCur7LqA1Ew+eG7yJsorfj0EhoojGX2GKoQQwBGi9g Ur94gFBPEHEDBALigl/ww3P8YwCRC2A6KRrbKlRlneRReTTJGg93XKs0Zc5k+tgrJ//ka+52j+4q 3CLKmW4f2ptc2Wumexsz0tY1RQarOcod08gVbXJL3KV3Vyq5jxkx7i8zjtP33Mqmoz1V8Ay12wRy gz4jbkIWs0EVkRwxHlg13swwTXTNMUdxWju2z+N9x9suybROShv8KTMt7h4dMNYlY4wtnZNWyEks Hzlpy0Rw6dX0mR9FJtLaJj/cV4XsHRfTSby+H1LMo9L4Zu5Mf3BXGdaEl91WGbNmk/JLeeYf3N2K OKd7qZbxI2e1RXQanaNz88KuVze2D7X0Op2giVMA2Bmvzk09YGeQceiVUJfWMivvPdKZUWsNu5Sm UymtPNg4q3///j9Re/ug9pX2B7WD/P+B2t3Xt9GDymmFeFL7aCFqB+TH3oPaf+n1vwEAAP//tFlb k5pKEH7fqv0PqbxaCTBcJ+XZKvGugOAVeYOZQRBEFxHBX59BV+Mxu8mppM6Tc2mHrv6anv4+bl7/ V5+fn37n9e98pqU2rDodGqe7Xqfx1uu06AtPLYaNbdX3tCKa+4Oe2PN6Ebako53ZyaatkT3Yxlif E0rvlgl5fqrNsj20SEqZVlNSV7VapzFgeai+DtYii3abpDlO27i5PtQsb7jX/dgRpdZw3Au5fNZZ o1OpWOYUCTNaHnBv0LU1zrbkuc/VPCWctQ7xwpzOWUNZWFy/mGudeYT34pSHu5KcuKZ0nAeWIyj9 rNniS+m4px0rLQ/ZWqFdd8lbimImU/40ZKNtd7+undKF2Mpi0jM8zfRmUupbZmvVnDTldtAJRZab Hg0A+otXySiiCFP2PkfdXGO7p5qZr5HOb7Zs0fEDqLtcc2Etkzbu9rV231CD02i48trHxahw1dZQ d7WR2cNijBiY2JuF8vw0wQFI6KXruB0+1qOssdLVRqO7Xq06UsUc8Pqdomz9XJTpJVExloeifF9o H8vsR0WZZsE71jQDxnespl/5pp6v6satQ6bdc6cxbarKumpAVmnFbN5YzXhJzuW7p0taCWkBR4fl JX8pU4eZBi5ZuQTtvOJEj4yIYhe8/hEnemREz09/yokeGRG9bv6QEz02SBXb+gUn+piDIGMX65od 8vKy9HjToKV9wwwAm6DjVGn7wXLU6YoRHJ/88tXJGuvwNNs7jQnQZBaJ+YHdWGbJx6ZhhKGZxwID 8r5aK+BoOdKen2ZlazrSJ0Uu7szmJmeGTOHsjrOBr+LGPGgTbIz4sNTlsWTOvXIaSrDLI0Mxx6Sd lHknIyM+ycYVU341ilp/bQ8H2HZa0Em5YT/qFz1+65YmEjqrIsi85qQ22edBe0K582ggzOGU3Thl c6iDlG8tNZMSEBpxjYmnbpxFx65+wgyS1LJYSHBr9i3ZPSS6M5Vtx0gYNeBsZyduRD3SZGDMiySR glmKvNwxmgO1TzlScVRwFgFkb8z+RGjYs+HrkMNpxBiNgXoiR2zPgg8uqsvyTSasM29y40UPvSmY 56kfxuRTiP/5fNVV0U/6rPhN5L8B4NQZdJVBP9U3H8i4HDXb/DBzf2Hm/jBbhbhScquf8/xwmR+u 880WkxdWlmV6eDU8L2KSh4gk2xdQZ27j806YnO3rzGVwXsvKHXnBYUpQtk3LOnOen3cSl7qB4hBF X/eu76YhKTKSVOp2nTnvna1ugQJXLRbf6bAxSVZZ8CJA6uHb+G3nqgrL0r9k4aswzHGycqcM0+Wr ln4VmN3dLq7Apf4wxZfVKdx9Zq62boqCMCf4y/tCOUSuDyELeAgl1xNFJAqcjxFLkOdjAlysKK7r CyLF4vGgmzdFlroo+/ARRGIBBkgiRPAEHrFYFIHrQkkQIA8B4UQEgKBgisXPJ12z9UcgLyhVob4D 6A2hKoO/0lDss3tYmMr4ASH+Fwgp8AOAZJl/FyBF+t/g4X0R8R6QWRF5LFA8DIECRY+XZUEWRBcL ru/JiuD/BTySIiCFSLJED0S+DLAvyYrnQY7zOegDH/FI8SWE/h6ePUrDXfZ1vX8XnduI/rH6IFRn zp+HvgMAAP//AwDO4UsN1Of2KYauBw1sk3Ps7Oc7wo6A+Fl7K+ctFXtk9ZpedLiMZOiqaneMYxZR d+u8ElssT/yggkpEcpsYCR/bqGjWRluAGkAAqTksvpGz/STdHj43OzPnFMQvt8v1SpSgJ/rxgXSm dSKc+3zC6GCM3/yV5Ozy6OeIDOCiWCMiLFtEKjAK/C6VBw/tXDnfgqgjHf6EsjfUaTo1T7K1di5X 2XbTnciJ85//HftVlHzEXrf6vv8jmdBgepN3MEJzI2zH+Vz0GUlcuDWfUREEtFpHLSGraxqS+NV0 nUW8ETy+UAC8u8Xq1K5zq1LThKpyv3qG/tEwmzVWEePR9cbXNytT4GOkHZcUsVq0iRrff0lAVDIf GXU0DXOIeNqNVN9v2jAQfh5/xS0vfcIu6pimKaUCQjck2kWCrtqjcY7Gw9iR7ZTmv5+TUEgDkfYU 674fvvvOSnj3tpPwisYKrW6DAbkOABXXiVAvt8HT6r7/Lbgb9cLP0a/p6k88g0wK6yB+mizmUwj6 lI6zTCKl0SqCeDFfrsB7UDp7DCBIncu+U7rf7wkrWYTrXUm0NDY6Q+OKhTfrewFJXBL4a2r3D+34 aiK4G/U+hVssRuPcpdqEtDz7knXGdzp6FlLCT2EsT0N6qB0Ek1zIBA38rk3byuHNFzIckpu2bHo/ yVUiMRI2k6x4ZDtsSz3E1hLhikvBt1eAr6gcbLQBpVVf4sZBhdgu73niBWIj8GweHxTZ+5nSaiRS 2XS6qI2OfEJ+OGaKjjG/kusu/dLn6Q6yZcVoiwfd4o7rBmf81OhGguVG6RHTyvkgPoD+W4NLbkTm 7Dt4Qg+wY+ao9DVmDKuPx15s5UD+NtfgUXqkhvT9gdHmS4uwVl4Y74FtEVzaXv0aU/aKIIVHhYIf yLca1gVwpjhK6ZWwEaVBWdReb+oHAq7I0JJ2ZrM3H0uZ7n9t+MKSYjQ7YUuyvRzuM66tcAhjztF2 ZjxXXOYJwhJ5bhBi9oK2EbkzOdITe+GzkA340NJYymb+Z5mfvtU/YNT7B4mZfop42h3KsQqAIBAA 0M9RQaRdaGtr6BdMzziKO9Ezh+jfg978BlLi4UJKyw0kKzYBgqpVvDCeyuZOUZBJg3kwa3B7F2Ga JwOuCZetcglH+Ivxr5XawfgPdBEfag== 138843 2012-04-25 10:58:52 -0700 2012-04-25 10:58:52 -0700 Example of click event that Gecko fires on all clicks click.html text/html 481 webkit PCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgU3RyaWN0Ly9FTiIg Imh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXN0cmljdC5kdGQiPg0KPGh0 bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiIHhtbDpsYW5nPSJlbiIgbGFu Zz0iZW4iPg0KPGhlYWQ+DQoJPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50 PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXRmLTgiIC8+DQoJPHRpdGxlPkNsaWNrIG1lPC90aXRsZT4N Cgk8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+ZG9jdW1lbnQuYWRkRXZlbnRMaXN0ZW5l cignY2xpY2snLGZ1bmN0aW9uKGUpe2FsZXJ0KGUuYnV0dG9uKTt9KTs8L3NjcmlwdD4NCjwvaGVh ZD4NCjxib2R5Pg0KCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vIj5BIGxpbms8 L2E+PC9wPg0KPC9ib2R5Pg0KPC9odG1sPg==