72154 2011-11-11 10:57:27 -0800 Synchronous XHR in window context should not support new XHR responseTypes for HTTP(S) requests 2012-03-20 08:25:11 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 73648 74802 1 jamesr jarred abarth annevk ap bugs darin dglazkov eric fishd gw japhet jarred kbr miguel.pastor mike sam webkit.review.bot oldest_to_newest 500925 0 jamesr 2011-11-11 10:57:27 -0800 Synchronous XMLHttpRequest in the window (not worker) context is an abomination, but we have to support it for compat reasons. For new response types, though, we don't have this legacy constraint. Mozilla has floated the idea of not supporting any new response types in sync XHR as a way to encourage authors to stick to asynchronous mode and I think it's a great idea. 500935 1 bugs 2011-11-11 11:04:54 -0800 https://bugzilla.mozilla.org/show_bug.cgi?id=701787 http://www.w3.org/Bugs/Public/show_bug.cgi?id=14773 500938 2 dglazkov 2011-11-11 11:07:16 -0800 Big fan of this. 501142 3 ap 2011-11-11 15:08:54 -0800 Good idea. 502360 4 fishd 2011-11-14 15:11:12 -0800 Yes, +1 513689 5 jarred 2011-12-02 05:12:19 -0800 brilliant 523648 6 119801 jarred 2011-12-18 19:08:28 -0800 Created attachment 119801 Patch 523739 7 119801 webkit.review.bot 2011-12-18 22:43:54 -0800 Comment on attachment 119801 Patch Attachment 119801 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/10921502 New failing tests: http/tests/xmlhttprequest/cross-origin-no-authorization.html http/tests/xmlhttprequest/cross-origin-cookie-storage.html http/tests/xmlhttprequest/cross-origin-authorization.html 523856 8 119854 jarred 2011-12-19 05:46:25 -0800 Created attachment 119854 Patch 524859 9 ap 2011-12-20 15:06:34 -0800 WebKit and other engines have been shipping withCredentials for a while now. It seems unlikely that we can remove it. What research did you perform that demonstrates that it won't break the Web? I suggest keeping this bug for new response types as originally filed - even so, it may not be easy to decide which types are sufficiently new at this point. 524869 10 bugs 2011-12-20 15:14:49 -0800 withCredentials is reasonable new thing and using it with sync XHR (in window context) has been disabled in Gecko. https://bugzilla.mozilla.org/show_bug.cgi?id=701787 There has been talk about disabling all CORS when using sync XHR (in window context), but that sounds too risky to me. See https://www.w3.org/Bugs/Public/show_bug.cgi?id=14773 524947 11 jarred 2011-12-20 16:29:50 -0800 (In reply to comment #9) > WebKit and other engines have been shipping withCredentials for a while now. It seems unlikely that we can remove it. What research did you perform that demonstrates that it won't break the Web? For sync requests in window context? I discovered that Firefox and Opera have or are in the process of doing the same. If you have doubts or reservations about this, you may be too late for that argument :) I'd like to think it's not breaking the web but instead moving the web forward. Considering no version of IE supports it...well need I say more. > > I suggest keeping this bug for new response types as originally filed - even so, it may not be easy to decide which types are sufficiently new at this point. Going for the whole tamale here... 525083 12 119854 ap 2011-12-20 21:31:36 -0800 Comment on attachment 119854 Patch Discouraging use doesn't mean that we should break existing callers. Unlike Mozilla and Opera engines, WebKit is widely used for non-Web content (and that's an explicit goal of the project). It's also more commonly used with walled garden content. As far as web content is concerned, I did a quick Google search, and withCredentials is widely used, including by libraries such as jQuery and mooTools. Said libraries use it for decisions that would be icky to make based on disabled functionality, even if that doesn't directly render results invalid. It just adds too much complexity to the Web when you study and debug code like the below: // Does this browser support crossDomain XHR requests jQuery.support.cors = testXHR && ( "withCredentials" in testXHR ); In fact, looking at those search results, I'm slightly less supportive of this idea than before. We engine vendors have little say in whether to discourage sync requests, it's library vendors who do. Since new responseTypes are basically syntactic sugar, they can work with or without engine support. It might be good to demonstrate our position, however with understanding that benefits will be indirect if any, while damage will be direct. > Going for the whole tamale here... Changes that have the potential of breaking sites should be done separately to ease finding the culprit later. That's the case for most kinds of changes, in fact. 525107 13 jamesr 2011-12-20 22:23:27 -0800 Supporting walled garden and non-Web content is a more important goal for this project than supporting the future of the web platform? Unless you have some evidence that making this change will cause nontrivial compatibility concerns, I think your objections are out of line. By delaying this you are increasing the chance that we will need to maintain this behavior forever. 525122 14 ap 2011-12-20 23:12:20 -0800 > Supporting walled garden and non-Web content is a more important goal for this project than supporting the future of the web platform? I don't think that this question is relevant to the discussion. Sync XHRs are not the future of the Web platform. This bug is a about a very far fetched attempt to influence authors in order to make user experience better, not about building the future of the platform. In this case, we don't have to choose between explicitly stated goals of the project to make the decision, or to admit that our goals are not exactly the same as for other browser vendors whose opinion has been mentioned. > By delaying this you are increasing the chance that we will need to maintain this behavior forever. That's not scary at all, the existing behavior easy to support. Blocking it is what takes work, and has long term costs in the complexity of the platform. 525221 15 jarred 2011-12-21 04:52:36 -0800 (In reply to comment #12) > (From update of attachment 119854 [details]) > Discouraging use doesn't mean that we should break existing callers. Unlike Mozilla and Opera engines, WebKit is widely used for non-Web content (and that's an explicit goal of the project). It's also more commonly used with walled garden content. Alexey, I love your conservatism around changing the status quo and all of the same scenarios that run through your head also run through mine; but then I wake up and realize I'm not only over reacting to an *extreme* edge case, but also hamstringing the web by not following through with its natural progression. With the noted chance of sounding presumptuous, I'll continue... Forget about Mozilla and Opera, we should be holding the torch and leading the way on this change and I'm shocked we are dead last in the race. What is equally worse for WebKit is to deliberately choose to fragment the web platform to satisfy a use case that *no one wants or cares about*. I agree that supporting the status quo is easier - what I don't want is for the hemorrhaging of this wound to continue until so much time has passed that we've reached a point of no turning back. But rather I see a future of the opposite occurring: the future where synchronous XHR in the window context is so utterly abandoned that it can be turned off completely; we've now just made the web platform a simpler place. > > As far as web content is concerned, I did a quick Google search, and withCredentials is widely used, including by libraries such as jQuery and mooTools. I work for and represent a major JS library vendor - dare I say our mobile app framework is the most popular, targeting WebKit mobile browsers. Our XHR wrapper (Ext.Ajax / Ext.data.Connection) doesn't publicly support synchronous requests *at all*. It's possible, but purposefully undocumented. > Said libraries use it for decisions that would be icky to make based on disabled functionality, even if that doesn't directly render results invalid. It just adds too much complexity to the Web when you study and debug code like the below: > > // Does this browser support crossDomain XHR requests > jQuery.support.cors = testXHR && ( "withCredentials" in testXHR ); I know all of the code you speak of - I added CORS support to Ext JS and Sencha Touch. The above is simply a detection mechanism that CORS is supported. But your facts aren't complete: jQuery, after detecting CORS support, explicitly disables synchronous CORS requests. From their docs: "async (Boolean) Default: true By default, all requests are sent asynchronously (i.e. this is set to true by default). If you need synchronous requests, set this option to false. Cross-domain requests and dataType: "jsonp" requests do not support synchronous operation. Note that synchronous requests may temporarily lock the browser, disabling any actions while the request is active." The functionality we're trying to disable here is not even allowed in jQuery and not even documented in Ext JS or Sencha Touch. I'm not sure what further data is needed to prove that no one wants this functionality, nor will anyone miss it. > > In fact, looking at those search results, I'm slightly less supportive of this idea than before. We engine vendors have little say in whether to discourage sync requests, it's library vendors who do. See above... > Since new responseTypes are basically syntactic sugar, they can work with or without engine support. That's not true. .response is polymorphic and .responseType determines the type of .response. It's not just syntactic sugar, it has a real purpose in particular for binary types such as ArrayBuffer and Blob where .response is the only means to accessing that data. > It might be good to demonstrate our position, however with understanding that benefits will be indirect if any, while damage will be direct. I agree - we're in demolition mode. But the benefit isn't seen today, it's seen tomorrow. Imagine a world as I described above: sync requests in the window context are completely turned off, leading to a simpler web platform. That future takes time by making choices like this one today. > > > Going for the whole tamale here... > > Changes that have the potential of breaking sites should be done separately to ease finding the culprit later. That's the case for most kinds of changes, in fact. I think this particular change would be very easy to find (and reverse if necessary) whether or not it's separate - but in principle I am totally with you. > > By delaying this you are increasing the chance that we will need to maintain this behavior forever. > > That's not scary at all, the existing behavior easy to support. Blocking it is what takes work, and has long term costs in the complexity of the platform. See above. I disagree, I think this is to make the platform simpler in the long term, not more complex. A minor prick of the finger today... 525234 16 bugs 2011-12-21 06:05:11 -0800 (In reply to comment #15) > I agree - we're in demolition mode. But the benefit isn't seen today, it's seen tomorrow. > Imagine a world as I described above: sync requests in the window context are completely turned off, leading to a simpler web platform. > That future takes time by making choices like this one today. Since we're anyway in a mode where specs like DOM4 remove features from web platform, I think it is a good time to try to get rid of possibly the most annoying feature in the platform. It may take time, or it may not succeed, but if all or most of the browser vendors try to do it actively, we can hopefully remove sync XHR (in window context) at some point. That would be a clear victory to user experience. (Gecko developer hat on) 525253 17 annevk 2011-12-21 06:53:18 -0800 Alexey, while you are right that there is increased complexity for implementations, for end users and developers (as they will have to use the right way API) this is a win that I think outweighs the fairly minimal implementation cost. In any event, if you really think this is the wrong behavior you should say so on the public list and not block someone trying to implement the specification. 525340 18 abarth 2011-12-21 10:48:59 -0800 > Unlike Mozilla and Opera engines, WebKit is widely used for non-Web content (and that's an explicit goal of the project). Can you show me where on <http://www.webkit.org/projects/goals.html> it says that "wall garden" considerations should take precedence over standards? Here's the text that I see: ---8<--- The project's primary focus is content deployed on the World Wide Web, using standards-based technologies such as HTML, CSS, JavaScript and the DOM. However, we also want to make it possible to embed WebKit in other applications, and to use it as a general-purpose display and interaction engine. --->8--- That says that WebKit's primary focus is content deployed on the World Wide Web. We want to make it *possible* to embed WebKit in other applications, but that's not the primary focus of the project. The goals page also says: ---8<--- WebKit aims for compliance with relevant web standards, and support for new standards In addition to improving compliance, we participate in the web standards community to bring new technologies into standards, and to make sure new standards are practical to implement in our engine. --->8--- It seems that if you are opposed to this change, you should take your point of view to the web standards community instead of trying to end-run the process in this bug. 525479 19 ap 2011-12-21 12:42:20 -0800 Jarred: I did not know that jQuery disabled sync CORS. This is great news, as well as what you say about Ext.Ajax. I'm not sure if that has direct effect on any decision of ours, but it's great to consider in this context. I think that this is an order of magnitude more important than what engines can do, however disruptive we're willing to be. Anne: Is there a specific e-mail that I could respond to, saying that WebKit is rather unlikely to make changes that are not backwards compatible? I'm not an ultimate decision maker, but think that I have a reasonable share of authority over XHR in WebKit. Adam: I am not going to show you where in project goals "wall garden" content is said to take precedence. I never claimed or implied anything even remotely close to that, so you are arguing with a straw man. Also, we should be able to discuss the strategy of getting rid of sync XHR without a holy war. Everyone: I think that we're largely missing step 2 here. 1. Remove some newer features from XHR. Ones that we think almost no one is using yet. 2. ??? 3. Authors stop using sync XHR. Sync XHR has been used before these features were added. Not only we can't change old unmaintained code, but even most authors of new code won't notice that something is missing. Enlightenment can occur in cases where code evolves and hits a wall, but I don't see that as a very common scenario, or one where lack of support for features would be the primary driver for change (when starting to use CORS, you're quite likely to be hugely redesigning your application, and will switch to a more modern library anyway). Getting rid of sync XHR is a goal I wholeheartedly support. Some approaches are more helpful (JS library changes and engines logging console warnings seem to be the best ones at this point). Some are nearly useless for achieving step 3, yet safe and easy, like not enabling any new functionality. Disabling already shipping functionality is both nearly useless, and fairly dangerous. I think that this is quite clearly not the change we should make. 525499 20 jarred 2011-12-21 13:00:28 -0800 (In reply to comment #19) > Jarred: I did not know that jQuery disabled sync CORS. This is great news, as well as what you say about Ext.Ajax. I'm not sure if that has direct effect on any decision of ours, but it's great to consider in this context. I think that this is an order of magnitude more important than what engines can do, however disruptive we're willing to be. Maybe sync [CORS] XHR requests in the window context is an exception because user experience is so utterly bad, but you would be surprised how JS libraries are willing and wanting to follow along and/or expose the features of the engines to the T; mostly for the sake of claiming "completeness". I think there are times where the standards community and the UAs should take the lead on an issue, and this is one of those times where they all have; except we are the only ones spinning wheels. > Disabling already shipping functionality is both nearly useless, and fairly dangerous. I think that this is quite clearly not the change we should make. So are you reneging on the idea of disabling responseType for sync XHR in the window context? It's already shipped. What about responseType "json" that I'm working on? Are you suggesting we should disable "json" responseType but leave "text" "document" and "arraybuffer" turned on because they're shipped? I don't want to make the stubborn mistake of sticking to certain principles for the sake of the principles, and would rather consider each change we make individually. When I consider only the change of disabling responseType and withCredentials for sync requests in the window context, given the facts and positions and the minimal impact on real-world use, I have to support disabling them because it lays the ground work for future simplification. I don't want to make a mountain out of a mole hill. If we were talking about removing <table> then this would be an entirely different conversation. 525632 21 ap 2011-12-21 14:42:09 -0800 > Maybe sync [CORS] XHR requests in the window context is an exception It certainly appears so! > Are you suggesting we should disable "json" responseType but leave "text" "document" and "arraybuffer" turned on because they're shipped? Yes, that formally follows from what I said, and I think that this would be the responsible approach. However that would be offensively inconsistent. Maybe preserving our sanity as engine developers outweighs being responsible. I'm not sure, so I'm willing to agree with vocal requests that are being made. I don't think that withCredentials deserves getting such (counter?)preferential treatment. 526225 22 jarred 2011-12-22 06:45:59 -0800 > However that would be offensively inconsistent. Totally, you can't have it both ways... > Maybe preserving our sanity as engine developers outweighs being responsible. ...because it's not about our sanity, it's about the sanity of web developers and the confusion it would cause having Firefox & Opera all in one direction but WebKit being scatterbrained and indecisive like a toddler. > I'm not sure, so I'm willing to agree with vocal requests that are being made. So what are the next steps? Do we take a democratic vote to r+ this? 526269 23 darin 2011-12-22 08:34:25 -0800 (In reply to comment #22) > Do we take a democratic vote to r+ this? Absolutely not, that is not how we run the project. 526271 24 jarred 2011-12-22 08:35:29 -0800 (In reply to comment #23) > (In reply to comment #22) > > Do we take a democratic vote to r+ this? > > Absolutely not, that is not how we run the project. Good to hear! Conflicts of interest galore... 526292 25 jarred 2011-12-22 09:03:53 -0800 Alexey, I appreciate your responsible level-headed stance and will leave the ball in your court. If you have any questions you know where to find me. If you would be so kind as to give a nod of approval or object to removing the block on bug #73648 (with the notion that bug #73648 can go in prior to a resolution on this bug, so no one's time is wasted) I would appreciate it - just so I know where I can focus next. Thanks! 526323 26 ap 2011-12-22 09:38:45 -0800 One more thought: do we want to disable new(-ish) functionality in sync requests to file: URLs? What about data: ones? Custom URL handlers implemented by applications embedding WebKit? These don't appear like something we should discourage. >> I'm not sure, so I'm willing to agree with vocal requests that are being made. > So what are the next steps? Do we take a democratic vote to r+ this? Decisions are generally made and explained by people who do the work, and are then approved by reviewers. I think that you are in a good position to decide whether to only disable "json", or all functionality available through responseType, so I'd r+ an otherwise good patch that does either. > If you would be so kind as to give a nod of approval or object to removing the block on bug #73648 If you and others feel that this moves in the direction of WONTFIX, then it is appropriate to unblock "json" implementation. I still think that disabling new functionality was a good idea, but inconsistencies - including the new one with dependency on URL scheme - appear to be killing it. 526430 27 jarred 2011-12-22 12:14:12 -0800 > I think that you are in a good position to decide whether to only disable "json", or all functionality available through responseType, so I'd r+ an otherwise good patch that does either. Sounds good Alexey, thanks. Patch on the way. 526432 28 120361 jarred 2011-12-22 12:15:24 -0800 Created attachment 120361 Patch 526435 29 jarred 2011-12-22 12:18:36 -0800 For those who oppose following the spec for withCredentials (http://dvcs.w3.org/hg/xhr/raw-file/tip/Overview.html#the-withcredentials-attribute) should hit up public-webapps and dispute it accordingly. Thanks. 526478 30 ap 2011-12-22 13:34:41 -0800 Thanks. So what are the opinions about file, data and custom URL schemes? There isn't anything wrong about sync requests to those, and Anne's spec doesn't cover non-HTTP protocols anyway. 526481 31 jarred 2011-12-22 13:36:30 -0800 (In reply to comment #30) > Thanks. So what are the opinions about file, data and custom URL schemes? There isn't anything wrong about sync requests to those, and Anne's spec doesn't cover non-HTTP protocols anyway. I think those being synchronous are okay. If between you and I we're good with that idea, I can modify the patch to only reject HTTP requests. Thanks for bringing that up. 526507 32 120361 ap 2011-12-22 14:18:39 -0800 Comment on attachment 120361 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=120361&action=review > If between you and I we're good with that idea, I can modify the patch to only reject HTTP requests. Thanks, let's limit this to http and https then. Comments about the current version below. > Source/WebCore/xml/XMLHttpRequest.cpp:286 > - if (m_state != OPENED || m_loader) { > + if (m_state > OPENED || m_loader) { This change is not explained in ChangeLog, and doesn't match the spec (one should also be able to set this property in HEADERS_RECEIVED state). Please address this, and add a separate test case. > Source/WebCore/xml/XMLHttpRequest.cpp:293 > + ec = INVALID_ACCESS_ERR; > + return; I think that we owe developers a console message here. > Source/WebCore/xml/XMLHttpRequest.cpp:-418 > - m_responseTypeCode = ResponseTypeDefault; In fact, this should not be only tested and mentioned in ChangeLog, but be done in a separate bug. > Source/WebCore/xml/XMLHttpRequest.cpp:447 > + // Synchronous requests from a window context should not be able to use responseType per W3C spec. You have a comment here, but not in setResponseType(). The comment could say more about "why", e.g. "Newer functionality is not available to synchronous requests in window contexts, as a spec-mandated attempt to discourage synchronous XHR use." > Source/WebCore/xml/XMLHttpRequest.cpp:449 > + if (!async && scriptExecutionContext()->isDocument() > + && m_responseTypeCode != ResponseTypeDefault) { I wouldn't have wrapped this line. > Source/WebCore/xml/XMLHttpRequest.cpp:451 > + ec = INVALID_ACCESS_ERR; > + return; I think that we owe developers a console message here. > LayoutTests/fast/xmlhttprequest/xmlhttprequest-responsetype-sync-request.html:6 > + description('This tests that the XMLHttpRequest responseType attribute is not usable with synchronous requests.'); We can still read it, so I would say "not modifiable". 526545 33 120361 jarred 2011-12-22 14:56:59 -0800 Comment on attachment 120361 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=120361&action=review Thanks for the review! >> Source/WebCore/xml/XMLHttpRequest.cpp:286 >> + if (m_state > OPENED || m_loader) { > > This change is not explained in ChangeLog, and doesn't match the spec (one should also be able to set this property in HEADERS_RECEIVED state). Please address this, and add a separate test case. This is explained in the ChangeLog: "responseType can be set before or directly after a call to open()", meaning the request doesn't need to be exactly in the OPENED state to be set. I can make that more clear. And you're right, per the spec, HEADERS_RECEIVED is a valid state to set it; however, HEADERS_RECEIVED is set in didReceiveData() and then choices are made directly after that regarding text decoding etc. etc., which need the responseType set in stone in order for those decisions to be made. The LOADING state isn't set until until after those decisions have been made. Maybe I'm missing something, but I assume the ThreadableLoaderClient is called asynchronously as data loads in, allowing someone to (with wicked timing) set the responseType after the decoder decisions have been made, but before the state is changed to LOADING. >> Source/WebCore/xml/XMLHttpRequest.cpp:293 >> + return; > > I think that we owe developers a console message here. Fair enough. >> Source/WebCore/xml/XMLHttpRequest.cpp:-418 >> - m_responseTypeCode = ResponseTypeDefault; > > In fact, this should not be only tested and mentioned in ChangeLog, but be done in a separate bug. Again I can make this more clear, but this is to support the notion that "responseType can be set before or directly after a call to open()", otherwise a call to open() will trump any value set to responseType before the call to open() was made. I'm not sure I totally agree that this is to be done in a separate bug because it's all related to denying access to responseType. The decision to "deny access" obviously depends upon the value of responseType when the call to open() is made. A separate bug would likely be called "responseType should be modifiable <= OPENED" but it would have to additionally include the "deny access" snippet further down in open(), which is then arguably unrelated to the bug. It's better coupled together I think then split out over X amount of time. >> Source/WebCore/xml/XMLHttpRequest.cpp:447 >> + // Synchronous requests from a window context should not be able to use responseType per W3C spec. > > You have a comment here, but not in setResponseType(). The comment could say more about "why", e.g. "Newer functionality is not available to synchronous requests in window contexts, as a spec-mandated attempt to discourage synchronous XHR use." Ok. >> Source/WebCore/xml/XMLHttpRequest.cpp:449 >> + && m_responseTypeCode != ResponseTypeDefault) { > > I wouldn't have wrapped this line. Yeah I will hoist it. >> LayoutTests/fast/xmlhttprequest/xmlhttprequest-responsetype-sync-request.html:6 >> + description('This tests that the XMLHttpRequest responseType attribute is not usable with synchronous requests.'); > > We can still read it, so I would say "not modifiable". Agreed. 526574 34 ap 2011-12-22 15:30:06 -0800 > This is explained in the ChangeLog My apologies, I looked at (missing) per-function comments, and didn't notice that there was an explanation above. > Maybe I'm missing something, but I assume the ThreadableLoaderClient is called asynchronously as data loads in, allowing someone to (with wicked timing) set the responseType after the decoder decisions have been made, but before the state is changed to LOADING. This should be easy to do in a readystatechange event handler. Probably not a very practical use case, but we could just as well do what the spec says. > I'm not sure I totally agree that this is to be done in a separate bug because it's all related to denying access to responseType. The parts of the change I'd like split into a separate bug affect async requests and make it permissible to change responseType when it didn't use to be allowed, so they feel quite out of place in a patch for a bug entitled "Synchronous XHR in window context should not support new XHR responseTypes". I'd like to have the potentially disruptive part where we block stuff that used to be allowed in a completely isolated patch, so that it would be easier to investigate and address potential regressions. 526584 35 jarred 2011-12-22 15:43:15 -0800 Sure I'm with you, makes good sense. I'll work on it this evening. 526731 36 120434 jarred 2011-12-22 21:59:10 -0800 Created attachment 120434 Patch 526748 37 120434 ap 2011-12-22 22:34:46 -0800 Comment on attachment 120434 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=120434&action=review r- because of inappropriate use of reportUnsafeUsage. I suggest just using addConsoleMessage directly (you can consider abstracting it out when adding the second check later). > Source/WebCore/xml/XMLHttpRequest.cpp:301 > + // attempt to discourage synchronous XHR use. responseType is one such function. responseType is not a function :) > Source/WebCore/xml/XMLHttpRequest.cpp:305 > + reportUnsafeUsage(scriptExecutionContext(), "XMLHttpRequest cannot set responseType for synchronous HTTP(S) requests made from the window context."); This is not unsafe usage, so calling a function named "reportUnsafeUsage" is not appropriate. The comment appears OK, although grammar seems slightly off (it's not XMLHttpRequest who does the setting). I'd have said "XMLHttpRequest.responseType cannot be changed ... from a window context". 526822 38 120434 jarred 2011-12-23 04:12:32 -0800 Comment on attachment 120434 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=120434&action=review >> Source/WebCore/xml/XMLHttpRequest.cpp:301 >> + // attempt to discourage synchronous XHR use. responseType is one such function. > > responseType is not a function :) I didn't mean function as in "method", but function as in "a piece of functionality", i.e., "responseType is one such [piece of functionality] that I was just talking about in the previous sentence". Programmers are likely to misinterpret this, so I'll make it more clear :) >> Source/WebCore/xml/XMLHttpRequest.cpp:305 >> + reportUnsafeUsage(scriptExecutionContext(), "XMLHttpRequest cannot set responseType for synchronous HTTP(S) requests made from the window context."); > > This is not unsafe usage, so calling a function named "reportUnsafeUsage" is not appropriate. > > The comment appears OK, although grammar seems slightly off (it's not XMLHttpRequest who does the setting). I'd have said "XMLHttpRequest.responseType cannot be changed ... from a window context". I'll rename reportUnsafeUsage to something more generic, like "reportErrorToConsole" or "(write|log)ConsoleError". Thanks I'll clean up the console message. 526828 39 120458 jarred 2011-12-23 04:47:25 -0800 Created attachment 120458 Patch 526858 40 120458 ap 2011-12-23 08:07:03 -0800 Comment on attachment 120458 Patch OK. I'm now thinking that we should add "Please use asynchronous requests" to console message. But that can be considered later. 526868 41 120458 jarred 2011-12-23 08:36:27 -0800 Comment on attachment 120458 Patch Clearing flags on attachment: 120458 Committed r103629: <http://trac.webkit.org/changeset/103629> 526869 42 jarred 2011-12-23 08:36:35 -0800 All reviewed patches have been landed. Closing bug. 532542 43 fishd 2012-01-09 14:52:50 -0800 It looks like this change broke Mandreel WebGL-based apps. For example: http://chrome.monsterdashgame.com/ Generates this error: "XMLHttpRequest.responseType cannot be changed for synchronous HTTP(S) requests made from the window context." 532543 44 fishd 2012-01-09 14:56:07 -0800 It looks like Mandreel is using this to simulate fopen. In their case, they use it to load local files from the WebFileSystem. Given that they are trying to support fopen (for emulating an OS runtime), I don't see any other way for them to implement this. 532899 45 bugs 2012-01-10 02:09:52 -0800 (In reply to comment #44) > It looks like Mandreel is using this to simulate fopen. In their case, they use it to load local files from the WebFileSystem. Given that they are trying to support fopen (for emulating an OS runtime), I don't see any other way for them to implement this. That is not a reason to make web platform worse, IMO. There should not be any UI blocking APIs in the window context. Mandreel could just wait for async XHR load before doing anything else. 533094 46 jarred 2012-01-10 08:33:41 -0800 (In reply to comment #44) > It looks like Mandreel is using this to simulate fopen. In their case, they use it to load local files from the WebFileSystem. Given that they are trying to support fopen (for emulating an OS runtime), I don't see any other way for them to implement this. I don't know the internals of their compiler, but since they are in control of it, they could work around this by translating any sync call stack that invokes fopen() into an async pattern that doesn't continue execution until the async XHR request has completed. I'm quite certain this is easier said than done, since their fopen() translation use to be self-contained but will now have to be context sensitive to where it is used...but it is definitely doable and would yield a better experience for fully web-based games that are loading large resources (e.g. textures) from remote sources. 533342 47 fishd 2012-01-10 13:26:31 -0800 Olli, Jarred: I certainly have no love for synchronous XHR. It is an abomination to be sure. I'm more concerned about the fact that this behavior has been in WebKit / Chrome for nearly a year, and we have changed it suddenly without warning and broken real web pages as a result. It seems like bad form to make breaking changes in this fashion. (I'm in contact with the Mandreel devs.) 533346 48 jarred 2012-01-10 13:34:30 -0800 (In reply to comment #47) > Olli, Jarred: I certainly have no love for synchronous XHR. It is an abomination to be sure. I'm more concerned about the fact that this behavior has been in WebKit / Chrome for nearly a year, and we have changed it suddenly without warning and broken real web pages as a result. It seems like bad form to make breaking changes in this fashion. (I'm in contact with the Mandreel devs.) Let us know what Mandreel devs come back with. I agree it is bad form; we all had to of expected someone, somewhere, would be affected by this change, but I always had in the back of my mind that the switch to async XHR would be trivial for those edge cases. Mandreel is one that may not be so trivial. If they can work around it, great, but if they cannot, we should do another kumbaya/huddle with those who have implemented this already (Mozilla, Opera) and public-webapps. 533615 49 miguel.pastor 2012-01-10 21:13:18 -0800 (In reply to comment #48) > (In reply to comment #47) > > Olli, Jarred: I certainly have no love for synchronous XHR. It is an abomination to be sure. I'm more concerned about the fact that this behavior has been in WebKit / Chrome for nearly a year, and we have changed it suddenly without warning and broken real web pages as a result. It seems like bad form to make breaking changes in this fashion. (I'm in contact with the Mandreel devs.) > > Let us know what Mandreel devs come back with. I agree it is bad form; we all had to of expected someone, somewhere, would be affected by this change, but I always had in the back of my mind that the switch to async XHR would be trivial for those edge cases. Mandreel is one that may not be so trivial. > > If they can work around it, great, but if they cannot, we should do another kumbaya/huddle with those who have implemented this already (Mozilla, Opera) and public-webapps. Hi, I'm Miguel Angel Pastor, Mandreel developer when porting native apps to web we encountered the issue with fopen. The solution we figured out was using application cache + synchronous XHR. Mandreel games wait for application cache to be ready with all the files game is using, so we know all the fopen are gonna open files stored in the application cache. We understand synchronous XHR in the web context are evil, but using Application Cache we know the fopen is gonna be always a hit We recently added a new way to load files in Mandreel, having an ArrayBuffer with all the files in memory, it works for most of the games, but we have 2 games having more than 100 megabytes in resources, memory usage for those games is gonna be big. From next week we are gonna fix the already published games to address this issue, but we don't see any problem with using synchronous XHR for CWS installed apps or when opening files in the application cache, the XHR is safe Thanks, Miguel 533747 50 bugs 2012-01-11 01:54:09 -0800 (In reply to comment #49) > when porting native apps to web we encountered the issue with fopen. The solution we figured out was using application cache + synchronous XHR. Mandreel games wait for application cache to be ready with all the files game is using, so we know all the fopen are gonna open files stored in the application cache. > We understand synchronous XHR in the web context are evil, but using Application Cache we know the fopen is gonna be always a hit But if application cache is stored on disk, sync XHR may block UI for a long time. So, in general case, I don't see how using Application Cache helps here. > We recently added a new way to load files in Mandreel, having an ArrayBuffer with all the files in memory, it works for most of the games, but we have 2 games having more than 100 megabytes in resources, memory usage for those games is gonna be big. > From next week we are gonna fix the already published games to address this issue, but we don't see any problem with using synchronous XHR for CWS installed apps or when opening files in the application cache, the XHR is safe Sync XHR is not about "safety" but about blocking UI thread. Have you tested Mandreel when the application cache data is stored somewhere in NFS? 533749 51 miguel.pastor 2012-01-11 01:58:46 -0800 in all the tests we did and so far clients haven't complained, using synchronous XHR from application cache files is fast enough reading from disk it has been fast enough, we never got a "this script is taking too long" message and we haven't tested on NFS, didn't know application cache can be saved there (In reply to comment #50) > (In reply to comment #49) > > when porting native apps to web we encountered the issue with fopen. The solution we figured out was using application cache + synchronous XHR. Mandreel games wait for application cache to be ready with all the files game is using, so we know all the fopen are gonna open files stored in the application cache. > > We understand synchronous XHR in the web context are evil, but using Application Cache we know the fopen is gonna be always a hit > But if application cache is stored on disk, sync XHR may block UI for a long time. So, in general case, I don't see how using Application Cache helps here. > > > > We recently added a new way to load files in Mandreel, having an ArrayBuffer with all the files in memory, it works for most of the games, but we have 2 games having more than 100 megabytes in resources, memory usage for those games is gonna be big. > > From next week we are gonna fix the already published games to address this issue, but we don't see any problem with using synchronous XHR for CWS installed apps or when opening files in the application cache, the XHR is safe > Sync XHR is not about "safety" but about blocking UI thread. > Have you tested Mandreel when the application cache data is stored somewhere in NFS? 533750 52 bugs 2012-01-11 02:04:24 -0800 (In reply to comment #49) > but we don't see any problem with using synchronous XHR for CWS installed apps Oh, and if CWS means Chrome Web Apps, that is a walled garden thing, so, not really about this bug, IMO. (I'm a Gecko developer who cares about the open web ;) ) 533751 53 miguel.pastor 2012-01-11 02:05:30 -0800 (In reply to comment #52) > (In reply to comment #49) > > but we don't see any problem with using synchronous XHR for CWS installed apps > Oh, and if CWS means Chrome Web Apps, that is a walled garden thing, so, not really about this bug, IMO. > (I'm a Gecko developer who cares about the open web ;) ) yeah, CWS mean Chrome Web Store 533754 54 bugs 2012-01-11 02:09:55 -0800 (In reply to comment #51) > in all the tests we did and so far clients haven't complained, using synchronous XHR from application cache files is fast enough > > reading from disk it has been fast enough, we never got a "this script is taking too long" message > and we haven't tested on NFS, didn't know application cache can be saved there Web browsers may or may not store application cache somewhere in disk. And the disk is possibly NFS. Or even if it is not NFS, reading from disk might cause fsyncs. What I mean that there is no guarantee that application cache is really fast. There is only (reasonable good) guaranteed that the application cached data is really there. 533999 55 jarred 2012-01-11 10:20:21 -0800 Miguel, sync XHR still works in Workers (where it belongs). Can you utilize workers and run Mandreel's processing in a worker, and post message notifications on UI updates? Let's at least attempt to analyze and resolve this as it is now before deciding to renege on a very favorable change to the web platform (one that's drafted in the spec). 534078 56 ap 2012-01-11 11:48:51 -0800 I disagree with the view that we should treat network loading and local cache access as equivalent in terms of expected performance characteristics. If local cache is configured in a way that does not provide seamless experience, it's not an API design issue. 534097 57 miguel.pastor 2012-01-11 12:00:24 -0800 (In reply to comment #55) > Miguel, sync XHR still works in Workers (where it belongs). Can you utilize workers and run Mandreel's processing in a worker, and post message notifications on UI updates? Let's at least attempt to analyze and resolve this as it is now before deciding to renege on a very favorable change to the web platform (one that's drafted in the spec). If we can get access to the WebGL context and Web Audio context in the Web Worker, we are more than happy and that's what we really want. 534117 58 jamesr 2012-01-11 12:13:15 -0800 (In reply to comment #57) > (In reply to comment #55) > > Miguel, sync XHR still works in Workers (where it belongs). Can you utilize workers and run Mandreel's processing in a worker, and post message notifications on UI updates? Let's at least attempt to analyze and resolve this as it is now before deciding to renege on a very favorable change to the web platform (one that's drafted in the spec). > > If we can get access to the WebGL context and Web Audio context in the Web Worker, we are more than happy and that's what we really want. I think that'd be the best long-term way to fix this particular problem. Workers have some other tricky issues - such as how to handle events - but I think they are tractable. 534779 59 miguel.pastor 2012-01-12 06:20:11 -0800 > I think that'd be the best long-term way to fix this particular problem. > > Workers have some other tricky issues - such as how to handle events - but I think they are tractable. so we agreed with this solution, we just need to know when it's gonna be ready :) for the moment we are just happy with only WebGL context and being exclusive, we don't need WebGL on the UI 577389 60 ap 2012-03-13 09:01:29 -0700 This caused bug 80991. 583079 61 gw 2012-03-20 08:17:01 -0700 Hi, Please can somebody clarify the situation here? This change has just broken our WebGL-based website: www.morphyre.com/scenedesign/go Can WebGL be accessed from a Worker thread currently? A quick search seems to suggest not. Is there any way around this change for a WebGL website currently, other than to convert JavaScript to asynchronous? We're in a similar situation to Mandreel where we are converting code that was designed to be synchronous. Our compilation process works from binaries, not source, so trying to automatically convert the code to be asynchronous is amazingly difficult. I think realistically our workaround will have to be to use a server-side script to create JSON, pass this back as a string and then evaluate it with eval - which will result in SIGNIFICANTLY worse user experience than if this had just been left alone. 583087 62 jarred 2012-03-20 08:25:11 -0700 (In reply to comment #61) > Hi, Please can somebody clarify the situation here? > > This change has just broken our WebGL-based website: www.morphyre.com/scenedesign/go > > Can WebGL be accessed from a Worker thread currently? A quick search seems to suggest not. > > Is there any way around this change for a WebGL website currently, other than to convert JavaScript to asynchronous? > > We're in a similar situation to Mandreel where we are converting code that was designed to be synchronous. Our compilation process works from binaries, not source, so trying to automatically convert the code to be asynchronous is amazingly difficult. > > I think realistically our workaround will have to be to use a server-side script to create JSON, pass this back as a string and then evaluate it with eval - which will result in SIGNIFICANTLY worse user experience than if this had just been left alone. If everyone doesn't mind: let's continue this conversation on public-webapps and not on 3 different bug tickets in 2 different bug tracking systems. It's becoming redundant. 119801 2011-12-18 19:08:28 -0800 2011-12-19 05:46:18 -0800 Patch bug-72154-20111218220827.patch text/plain 9709 jarred U3VidmVyc2lvbiBSZXZpc2lvbjogMTAzMTc4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDdlM2IwZGJhMTFmZjU4 MjY1YTdlZGIyMGRmY2YyYWEwNWY2ZmI4OS4uMjQ3YWNiODA2NzQwMTA0YWYxOTM0YmZhMDJlYjJk ODUwYjFiMTA4MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2IEBACisyMDExLTEyLTE4ICBKYXJy ZWQgTmljaG9sbHMgIDxqYXJyZWRAc2VuY2hhLmNvbT4KKworICAgICAgICBTeW5jaHJvbm91cyBY SFIgaW4gd2luZG93IGNvbnRleHQgc2hvdWxkIG5vdCBzdXBwb3J0IG5ldyBYSFIgcmVzcG9uc2VU eXBlcyBvciB3aXRoQ3JlZGVudGlhbHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTcyMTU0CisKKyAgICAgICAgUGVyIHRoZSBsYXRlc3QgVzNDIGVkaXRv ciBkcmFmdDogaHR0cDovL2R2Y3MudzMub3JnL2hnL3hoci9yYXctZmlsZS90aXAvT3ZlcnZpZXcu aHRtbAorICAgICAgICAtIEluIGEgd2luZG93IGNvbnRleHQsIHN5bmNocm9ub3VzIFhIUiByZXF1 ZXN0cyBzaG91bGQgbm90IHN1cHBvcnQgc2V0dGluZyBhIHJlc3BvbnNlVHlwZS4KKyAgICAgICAg ICByZXNwb25zZVR5cGUgY2FuIGJlIHNldCBiZWZvcmUgb3IgZGlyZWN0bHkgYWZ0ZXIgYSBjYWxs IHRvIG9wZW4oKSwgYnV0IHNob3VsZCB0aHJvdyBhbiBJbnZhbGlkQWNjZXNzRXJyb3IKKyAgICAg ICAgICB3aGVuIHVzZWQgaW4gY29tYmluYXRpb24gd2l0aCBhIHN5bmNocm9ub3VzIHJlcXVlc3Qu CisgICAgICAgIC0gSW4gYSB3aW5kb3cgY29udGV4dCwgc3luY2hyb25vdXMgWEhSIHJlcXVlc3Rz IHNob3VsZCBub3Qgc3VwcG9ydCBzZXR0aW5nIHRoZSB3aXRoQ3JlZGVudGlhbHMgZmxhZy4KKyAg ICAgICAgICB3aXRoQ3JlZGVudGlhbHMgY2FuIGJlIHNldCBiZWZvcmUgb3IgZGlyZWN0bHkgYWZ0 ZXIgYSBjYWxsIHRvIG9wZW4oKSwgYnV0IHNob3VsZCB0aHJvdyBhbgorICAgICAgICAgIEludmFs aWRBY2Nlc3NFcnJvciB3aGVuIHVzZWQgaW4gY29tYmluYXRpb24gd2l0aCBhIHN5bmNocm9ub3Vz IHJlcXVlc3QuCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgVGVzdHM6IGZhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3QtcmVzcG9uc2V0eXBl LXN5bmMtcmVxdWVzdC5odG1sCisgICAgICAgICAgICAgICBmYXN0L3htbGh0dHByZXF1ZXN0L3ht bGh0dHByZXF1ZXN0LXdpdGhjcmVkZW50aWFscy1zeW5jLXJlcXVlc3QuaHRtbAorCisgICAgICAg ICogeG1sL1hNTEh0dHBSZXF1ZXN0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlhNTEh0dHBSZXF1 ZXN0OjpzZXRSZXNwb25zZVR5cGUpOgorICAgICAgICAoV2ViQ29yZTo6WE1MSHR0cFJlcXVlc3Q6 OnNldFdpdGhDcmVkZW50aWFscyk6CisgICAgICAgIChXZWJDb3JlOjpYTUxIdHRwUmVxdWVzdDo6 b3Blbik6CisKIDIwMTEtMTItMTggIFJhdWwgSHVkZWEgIDxyaHVkZWFAYWRvYmUuY29tPgogCiAg ICAgICAgIEFkZCB0cmFuc2Zvcm0gZnVuY3Rpb24gY29tcGxldGlvbiB0byB3ZWItaW5zcGVjdG9y CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS94bWwvWE1MSHR0cFJlcXVlc3QuY3BwIGIvU291 cmNlL1dlYkNvcmUveG1sL1hNTEh0dHBSZXF1ZXN0LmNwcAppbmRleCA0OGM3MTNjZDE5Y2ZlYTg1 MTYzYjk3NDRlN2E3Mjc5NjY0MjQ4MDY2Li4zMWViMDZiYzFmYWI0MDlmOTYyM2ZlMGRmMjlkZGM4 ZWQwMDBlMzY4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS94bWwvWE1MSHR0cFJlcXVlc3Qu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3htbC9YTUxIdHRwUmVxdWVzdC5jcHAKQEAgLTI4Mywx MSArMjgzLDE2IEBAIEFycmF5QnVmZmVyKiBYTUxIdHRwUmVxdWVzdDo6cmVzcG9uc2VBcnJheUJ1 ZmZlcihFeGNlcHRpb25Db2RlJiBlYykKIAogdm9pZCBYTUxIdHRwUmVxdWVzdDo6c2V0UmVzcG9u c2VUeXBlKGNvbnN0IFN0cmluZyYgcmVzcG9uc2VUeXBlLCBFeGNlcHRpb25Db2RlJiBlYykKIHsK LSAgICBpZiAobV9zdGF0ZSAhPSBPUEVORUQgfHwgbV9sb2FkZXIpIHsKKyAgICBpZiAobV9zdGF0 ZSA+IE9QRU5FRCB8fCBtX2xvYWRlcikgewogICAgICAgICBlYyA9IElOVkFMSURfU1RBVEVfRVJS OwogICAgICAgICByZXR1cm47CiAgICAgfQogCisgICAgaWYgKCFtX2FzeW5jICYmIHNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQoKS0+aXNEb2N1bWVudCgpKSB7CisgICAgICAgIGVjID0gSU5WQUxJRF9B Q0NFU1NfRVJSOworICAgICAgICByZXR1cm47CisgICAgfQorCiAgICAgaWYgKHJlc3BvbnNlVHlw ZSA9PSAiIikKICAgICAgICAgbV9yZXNwb25zZVR5cGVDb2RlID0gUmVzcG9uc2VUeXBlRGVmYXVs dDsKICAgICBlbHNlIGlmIChyZXNwb25zZVR5cGUgPT0gInRleHQiKQpAQCAtMzU3LDExICszNjIs MTYgQEAgdm9pZCBYTUxIdHRwUmVxdWVzdDo6Y2FsbFJlYWR5U3RhdGVDaGFuZ2VMaXN0ZW5lcigp CiAKIHZvaWQgWE1MSHR0cFJlcXVlc3Q6OnNldFdpdGhDcmVkZW50aWFscyhib29sIHZhbHVlLCBF eGNlcHRpb25Db2RlJiBlYykKIHsKLSAgICBpZiAobV9zdGF0ZSAhPSBPUEVORUQgfHwgbV9sb2Fk ZXIpIHsKKyAgICBpZiAobV9zdGF0ZSA+IE9QRU5FRCB8fCBtX2xvYWRlcikgewogICAgICAgICBl YyA9IElOVkFMSURfU1RBVEVfRVJSOwogICAgICAgICByZXR1cm47CiAgICAgfQogCisgICAgaWYg KCFtX2FzeW5jICYmIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+aXNEb2N1bWVudCgpKSB7Cisg ICAgICAgIGVjID0gSU5WQUxJRF9BQ0NFU1NfRVJSOworICAgICAgICByZXR1cm47CisgICAgfQor CiAgICAgbV9pbmNsdWRlQ3JlZGVudGlhbHMgPSB2YWx1ZTsKIH0KIApAQCAtNDE0LDcgKzQyNCw2 IEBAIHZvaWQgWE1MSHR0cFJlcXVlc3Q6Om9wZW4oY29uc3QgU3RyaW5nJiBtZXRob2QsIGNvbnN0 IEtVUkwmIHVybCwgYm9vbCBhc3luYywgRXhjCiAgICAgU3RhdGUgcHJldmlvdXNTdGF0ZSA9IG1f c3RhdGU7CiAgICAgbV9zdGF0ZSA9IFVOU0VOVDsKICAgICBtX2Vycm9yID0gZmFsc2U7Ci0gICAg bV9yZXNwb25zZVR5cGVDb2RlID0gUmVzcG9uc2VUeXBlRGVmYXVsdDsKICAgICBtX3VwbG9hZENv bXBsZXRlID0gZmFsc2U7CiAKICAgICAvLyBjbGVhciBzdHVmZiBmcm9tIHBvc3NpYmxlIHByZXZp b3VzIGxvYWQKQEAgLTQzOSw2ICs0NDgsMTQgQEAgdm9pZCBYTUxIdHRwUmVxdWVzdDo6b3Blbihj b25zdCBTdHJpbmcmIG1ldGhvZCwgY29uc3QgS1VSTCYgdXJsLCBib29sIGFzeW5jLCBFeGMKICAg ICAgICAgcmV0dXJuOwogICAgIH0KIAorICAgIC8vIFN5bmNocm9ub3VzIHJlcXVlc3RzIGZyb20g YSB3aW5kb3cgY29udGV4dCBzaG91bGQgbm90IGJlIGFibGUgdG8gdXNlIGNlcnRhaW4gWEhSIGZl YXR1cmVzCisgICAgLy8gc3VjaCBhcyByZXNwb25zZVR5cGUgYW5kIHdpdGhDcmVkZW50aWFscywg cGVyIHRoZSBXM0Mgc3BlYy4KKyAgICBpZiAoIWFzeW5jICYmIHNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQoKS0+aXNEb2N1bWVudCgpCisgICAgICAgICYmIChtX2luY2x1ZGVDcmVkZW50aWFscyB8fCBt X3Jlc3BvbnNlVHlwZUNvZGUgIT0gUmVzcG9uc2VUeXBlRGVmYXVsdCkpIHsKKyAgICAgICAgZWMg PSBJTlZBTElEX0FDQ0VTU19FUlI7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKICAgICBtX21l dGhvZCA9IHVwcGVyY2FzZUtub3duSFRUUE1ldGhvZChtZXRob2QpOwogCiAgICAgbV91cmwgPSB1 cmw7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cKaW5kZXggZWEzMDIyYmNiZWVmNDcyYzUxMGU3ZjlhYTExZmQ3OTQ0ZDI0MzZiYy4uZmEy ZWUzNTRkNTk0NWQzMDQxYTVkZTMzNzFiZWI4ZGVkMDU3MWNkMyAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4 IEBACisyMDExLTEyLTE4ICBKYXJyZWQgTmljaG9sbHMgIDxqYXJyZWRAc2VuY2hhLmNvbT4KKwor ICAgICAgICBTeW5jaHJvbm91cyBYSFIgaW4gd2luZG93IGNvbnRleHQgc2hvdWxkIG5vdCBzdXBw b3J0IG5ldyBYSFIgcmVzcG9uc2VUeXBlcyBvciB3aXRoQ3JlZGVudGlhbHMKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTcyMTU0CisKKyAgICAgICAgTmV3 IHRlc3RzIHRoYXQgdmFsaWRhdGUgc3luY2hyb25vdXMgWEhSIHJlcXVlc3RzIGNhbm5vdCB1c2Ug cmVzcG9uc2VUeXBlIG9yIHdpdGhDcmVkZW50aWFscywgYW5kCisgICAgICAgIGFsc28gdmFsaWRh dGUgdGhhdCByZXNwb25zZVR5cGUgYW5kIHdpdGhDcmVkZW50aWFscyBjYW4gYmUgc2V0IGJlZm9y ZSBhIGNhbGwgdG8gb3BlbigpLgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgICogZmFzdC94bWxodHRwcmVxdWVzdC94bWxodHRwcmVxdWVzdC1yZXNwb25z ZXR5cGUtc3luYy1yZXF1ZXN0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC94 bWxodHRwcmVxdWVzdC94bWxodHRwcmVxdWVzdC1yZXNwb25zZXR5cGUtc3luYy1yZXF1ZXN0Lmh0 bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3Qt d2l0aGNyZWRlbnRpYWxzLXN5bmMtcmVxdWVzdC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAg ICAqIGZhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3Qtd2l0aGNyZWRlbnRpYWxzLXN5 bmMtcmVxdWVzdC5odG1sOiBBZGRlZC4KKwogMjAxMS0xMi0xOCAgUGV0ZXIgUnliaW4gIDxwZXRl ci5yeWJpbkBnbWFpbC5jb20+CiAKICAgICAgICAgV2ViIEluc3BlY3RvcjogU3dpdGNoIHRvIHR5 cGUtc2FmZSBKU09OIENvbnNvbGVNZXNzYWdlLmNwcCwgSW5zcGVjdG9yRE9NQWdlbnQuY3BwLCBJ bnNwZWN0b3JEZWJ1Z2dlckFnZW50LmNwcCwgU2NyaXB0Q2FsbEZyYW1lLmNwcApkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvZmFzdC94bWxodHRwcmVxdWVzdC94bWxodHRwcmVxdWVzdC1yZXNwb25z ZXR5cGUtc3luYy1yZXF1ZXN0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QveG1saHR0 cHJlcXVlc3QveG1saHR0cHJlcXVlc3QtcmVzcG9uc2V0eXBlLXN5bmMtcmVxdWVzdC1leHBlY3Rl ZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uMDkyMmI4YTNmMmY1OTBiMjE5YWIyNmIxYzkyOTZmYTMzYWFhMmE3 OAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QveG1saHR0cHJlcXVlc3QveG1s aHR0cHJlcXVlc3QtcmVzcG9uc2V0eXBlLXN5bmMtcmVxdWVzdC1leHBlY3RlZC50eHQKQEAgLTAs MCArMSwxMiBAQAorVGhpcyB0ZXN0cyB0aGF0IHRoZSBYTUxIdHRwUmVxdWVzdCByZXNwb25zZVR5 cGUgYXR0cmlidXRlIGlzIG5vdCB1c2FibGUgd2l0aCBzeW5jaHJvbm91cyByZXF1ZXN0cy4KKwor T24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9s bG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisKK3hoci5vcGVuKCdHRVQnLCB3aW5kb3cubG9j YXRpb24sIGZhbHNlKTsKK1BBU1MgeGhyLm9wZW4oJ0dFVCcsIHdpbmRvdy5sb2NhdGlvbiwgZmFs c2UpOyB0aHJldyBleGNlcHRpb24gRXJyb3I6IElOVkFMSURfQUNDRVNTX0VSUjogRE9NIEV4Y2Vw dGlvbiAxNS4KK1BBU1MgeGhyLnJlc3BvbnNlVHlwZSA9ICdkb2N1bWVudCc7IHRocmV3IGV4Y2Vw dGlvbiBFcnJvcjogSU5WQUxJRF9BQ0NFU1NfRVJSOiBET00gRXhjZXB0aW9uIDE1LgorUEFTUyBz dWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2Zhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3QtcmVzcG9uc2V0 eXBlLXN5bmMtcmVxdWVzdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC94bWxodHRwcmVxdWVzdC94 bWxodHRwcmVxdWVzdC1yZXNwb25zZXR5cGUtc3luYy1yZXF1ZXN0Lmh0bWwKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4u N2Y2N2QyMzU5YTkyNjkxNTE0MTNiM2I1MTg5M2U4MTNjNmEwYzk5ZgotLS0gL2Rldi9udWxsCisr KyBiL0xheW91dFRlc3RzL2Zhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3QtcmVzcG9u c2V0eXBlLXN5bmMtcmVxdWVzdC5odG1sCkBAIC0wLDAgKzEsMjkgQEAKKzwhRE9DVFlQRSBodG1s PgorPGh0bWw+Cis8aGVhZD4KKyAgICA8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRl c3QtcHJlLmpzIj48L3NjcmlwdD4KKyAgICA8c2NyaXB0PgorICAgICAgICBkZXNjcmlwdGlvbign VGhpcyB0ZXN0cyB0aGF0IHRoZSBYTUxIdHRwUmVxdWVzdCByZXNwb25zZVR5cGUgYXR0cmlidXRl IGlzIG5vdCB1c2FibGUgd2l0aCBzeW5jaHJvbm91cyByZXF1ZXN0cy4nKTsKKyAgICAgICAgdmFy IHhocjsKKworICAgICAgICAvLyBTeW5jaHJvbm91cyBvcGVuKCkgd2l0aCBubyByZXNwb25zZVR5 cGUgc2V0LgorICAgICAgICB4aHIgPSBuZXcgWE1MSHR0cFJlcXVlc3QoKTsKKyAgICAgICAgZXZh bEFuZExvZygieGhyLm9wZW4oJ0dFVCcsIHdpbmRvdy5sb2NhdGlvbiwgZmFsc2UpOyIpOworCisg ICAgICAgIC8vIFN5bmNocm9ub3VzIG9wZW4oKSB3aXRoIGEgcmVzcG9uc2VUeXBlIHNldC4KKyAg ICAgICAgeGhyID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgICAgIHhoci5yZXNwb25zZVR5 cGUgPSAnZG9jdW1lbnQnOworICAgICAgICBzaG91bGRUaHJvdygieGhyLm9wZW4oJ0dFVCcsIHdp bmRvdy5sb2NhdGlvbiwgZmFsc2UpOyIpOworCisgICAgICAgIC8vIFN5bmNocm9ub3VzIG9wZW4o KSB3aXRoIGEgc3Vic2VxdWVudCByZXNwb25zZVR5cGUgc2V0IGF0dGVtcHQuCisgICAgICAgIHho ciA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgICAgICB4aHIub3BlbignR0VUJywgd2luZG93 LmxvY2F0aW9uLCBmYWxzZSk7CisgICAgICAgIHNob3VsZFRocm93KCJ4aHIucmVzcG9uc2VUeXBl ID0gJ2RvY3VtZW50JzsiKTsKKyAgICA8L3NjcmlwdD4KKyAgICA8c2NyaXB0IHNyYz0iLi4vanMv cmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKyAg ICA8ZGl2IGlkPSJkZXNjcmlwdGlvbiI+PC9kaXY+CisgICAgPGRpdiBpZD0iY29uc29sZSI+PC9k aXY+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3htbGh0 dHByZXF1ZXN0L3htbGh0dHByZXF1ZXN0LXdpdGhjcmVkZW50aWFscy1zeW5jLXJlcXVlc3QtZXhw ZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC94bWxodHRwcmVxdWVzdC94bWxodHRwcmVxdWVz dC13aXRoY3JlZGVudGlhbHMtc3luYy1yZXF1ZXN0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45 NjllYTljZTJhMTUzMmJkNzU2OTQ0NWNlNWJlZDBiOTVjOGEzYjcwCi0tLSAvZGV2L251bGwKKysr IGIvTGF5b3V0VGVzdHMvZmFzdC94bWxodHRwcmVxdWVzdC94bWxodHRwcmVxdWVzdC13aXRoY3Jl ZGVudGlhbHMtc3luYy1yZXF1ZXN0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDEyIEBACitUaGlz IHRlc3RzIHRoYXQgdGhlIFhNTEh0dHBSZXF1ZXN0IHdpdGhDcmVkZW50aWFscyBhdHRyaWJ1dGUg aXMgbm90IHVzYWJsZSB3aXRoIHN5bmNocm9ub3VzIHJlcXVlc3RzLgorCitPbiBzdWNjZXNzLCB5 b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVT VCBDT01QTEVURSIuCisKKworeGhyLm9wZW4oJ0dFVCcsIHdpbmRvdy5sb2NhdGlvbiwgZmFsc2Up OworUEFTUyB4aHIub3BlbignR0VUJywgd2luZG93LmxvY2F0aW9uLCBmYWxzZSk7IHRocmV3IGV4 Y2VwdGlvbiBFcnJvcjogSU5WQUxJRF9BQ0NFU1NfRVJSOiBET00gRXhjZXB0aW9uIDE1LgorUEFT UyB4aHIud2l0aENyZWRlbnRpYWxzID0gdHJ1ZTsgdGhyZXcgZXhjZXB0aW9uIEVycm9yOiBJTlZB TElEX0FDQ0VTU19FUlI6IERPTSBFeGNlcHRpb24gMTUuCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNl ZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFz dC94bWxodHRwcmVxdWVzdC94bWxodHRwcmVxdWVzdC13aXRoY3JlZGVudGlhbHMtc3luYy1yZXF1 ZXN0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3htbGh0dHByZXF1ZXN0L3htbGh0dHByZXF1ZXN0 LXdpdGhjcmVkZW50aWFscy1zeW5jLXJlcXVlc3QuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40ZmZjYjdkMGI3 OTNmNTA1ODA4Nzg4YTQ0NWFhMzU2YTcwZWJlZTczCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC94bWxodHRwcmVxdWVzdC94bWxodHRwcmVxdWVzdC13aXRoY3JlZGVudGlhbHMt c3luYy1yZXF1ZXN0Lmh0bWwKQEAgLTAsMCArMSwyOSBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRt bD4KKzxoZWFkPgorICAgIDxzY3JpcHQgc3JjPSIuLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUu anMiPjwvc2NyaXB0PgorICAgIDxzY3JpcHQ+CisgICAgICAgIGRlc2NyaXB0aW9uKCdUaGlzIHRl c3RzIHRoYXQgdGhlIFhNTEh0dHBSZXF1ZXN0IHdpdGhDcmVkZW50aWFscyBhdHRyaWJ1dGUgaXMg bm90IHVzYWJsZSB3aXRoIHN5bmNocm9ub3VzIHJlcXVlc3RzLicpOworICAgICAgICB2YXIgeGhy OworCisgICAgICAgIC8vIFN5bmNocm9ub3VzIG9wZW4oKSB3aXRob3V0IHdpdGhDcmVkZW50aWFs cyBzZXQuCisgICAgICAgIHhociA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgICAgICBldmFs QW5kTG9nKCJ4aHIub3BlbignR0VUJywgd2luZG93LmxvY2F0aW9uLCBmYWxzZSk7Iik7CisKKyAg ICAgICAgLy8gU3luY2hyb25vdXMgb3BlbigpIHdpdGggd2l0aENyZWRlbnRpYWxzIHNldC4KKyAg ICAgICAgeGhyID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAgICAgIHhoci53aXRoQ3JlZGVu dGlhbHMgPSB0cnVlOworICAgICAgICBzaG91bGRUaHJvdygieGhyLm9wZW4oJ0dFVCcsIHdpbmRv dy5sb2NhdGlvbiwgZmFsc2UpOyIpOworCisgICAgICAgIC8vIFN5bmNocm9ub3VzIG9wZW4oKSB3 aXRoIGEgc3Vic2VxdWVudCB3aXRoQ3JlZGVudGlhbHMgc2V0IGF0dGVtcHQuCisgICAgICAgIHho ciA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgICAgICB4aHIub3BlbignR0VUJywgd2luZG93 LmxvY2F0aW9uLCBmYWxzZSk7CisgICAgICAgIHNob3VsZFRocm93KCJ4aHIud2l0aENyZWRlbnRp YWxzID0gdHJ1ZTsiKTsKKyAgICA8L3NjcmlwdD4KKyAgICA8c2NyaXB0IHNyYz0iLi4vanMvcmVz b3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKyAgICA8 ZGl2IGlkPSJkZXNjcmlwdGlvbiI+PC9kaXY+CisgICAgPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+ Cis8L2JvZHk+Cis8L2h0bWw+Cg== 119854 2011-12-19 05:46:25 -0800 2011-12-22 12:15:18 -0800 Patch bug-72154-20111219084623.patch text/plain 29679 jarred U3VidmVyc2lvbiBSZXZpc2lvbjogMTAzMjI4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggN2ZmODI5Yjk1YTMzNGM0 MDI1MGU3YmZlYmM3NTcxNmQ3NjJkMzZmMC4uZWJhMGM4MzE5NmVjMjllZmFlZDZkMzkwZTM3ZTZm ZDgwYTNmMTJhNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2IEBACisyMDExLTEyLTE5ICBKYXJy ZWQgTmljaG9sbHMgIDxqYXJyZWRAc2VuY2hhLmNvbT4KKworICAgICAgICBTeW5jaHJvbm91cyBY SFIgaW4gd2luZG93IGNvbnRleHQgc2hvdWxkIG5vdCBzdXBwb3J0IG5ldyBYSFIgcmVzcG9uc2VU eXBlcyBvciB3aXRoQ3JlZGVudGlhbHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTcyMTU0CisKKyAgICAgICAgUGVyIHRoZSBsYXRlc3QgVzNDIGVkaXRv ciBkcmFmdDogaHR0cDovL2R2Y3MudzMub3JnL2hnL3hoci9yYXctZmlsZS90aXAvT3ZlcnZpZXcu aHRtbAorICAgICAgICAtIEluIGEgd2luZG93IGNvbnRleHQsIHN5bmNocm9ub3VzIFhIUiByZXF1 ZXN0cyBzaG91bGQgbm90IHN1cHBvcnQgc2V0dGluZyBhIHJlc3BvbnNlVHlwZS4KKyAgICAgICAg ICByZXNwb25zZVR5cGUgY2FuIGJlIHNldCBiZWZvcmUgb3IgZGlyZWN0bHkgYWZ0ZXIgYSBjYWxs IHRvIG9wZW4oKSwgYnV0IHNob3VsZCB0aHJvdyBhbiBJbnZhbGlkQWNjZXNzRXJyb3IKKyAgICAg ICAgICB3aGVuIHVzZWQgaW4gY29tYmluYXRpb24gd2l0aCBhIHN5bmNocm9ub3VzIHJlcXVlc3Qu CisgICAgICAgIC0gSW4gYSB3aW5kb3cgY29udGV4dCwgc3luY2hyb25vdXMgWEhSIHJlcXVlc3Rz IHNob3VsZCBub3Qgc3VwcG9ydCBzZXR0aW5nIHRoZSB3aXRoQ3JlZGVudGlhbHMgZmxhZy4KKyAg ICAgICAgICB3aXRoQ3JlZGVudGlhbHMgY2FuIGJlIHNldCBiZWZvcmUgb3IgZGlyZWN0bHkgYWZ0 ZXIgYSBjYWxsIHRvIG9wZW4oKSwgYnV0IHNob3VsZCB0aHJvdyBhbgorICAgICAgICAgIEludmFs aWRBY2Nlc3NFcnJvciB3aGVuIHVzZWQgaW4gY29tYmluYXRpb24gd2l0aCBhIHN5bmNocm9ub3Vz IHJlcXVlc3QuCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgVGVzdHM6IGZhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3QtcmVzcG9uc2V0eXBl LXN5bmMtcmVxdWVzdC5odG1sCisgICAgICAgICAgICAgICBmYXN0L3htbGh0dHByZXF1ZXN0L3ht bGh0dHByZXF1ZXN0LXdpdGhjcmVkZW50aWFscy1zeW5jLXJlcXVlc3QuaHRtbAorCisgICAgICAg ICogeG1sL1hNTEh0dHBSZXF1ZXN0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlhNTEh0dHBSZXF1 ZXN0OjpzZXRSZXNwb25zZVR5cGUpOgorICAgICAgICAoV2ViQ29yZTo6WE1MSHR0cFJlcXVlc3Q6 OnNldFdpdGhDcmVkZW50aWFscyk6CisgICAgICAgIChXZWJDb3JlOjpYTUxIdHRwUmVxdWVzdDo6 b3Blbik6CisKIDIwMTEtMTItMTkgIEJlbmphbWluIFBvdWxhaW4gIDxiZW5qYW1pbkB3ZWJraXQu b3JnPgogCiAgICAgICAgIEJ1aWxkIGZpeCBmb3IgU2Nyb2xsaW5nQ29vcmRpbmF0b3JNYWMubW0g d2hlbiBidWlsZGluZyBvbiBhIGNhc2Ugc2Vuc2l0aXZlIHN5c3RlbQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUveG1sL1hNTEh0dHBSZXF1ZXN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3htbC9Y TUxIdHRwUmVxdWVzdC5jcHAKaW5kZXggNDhjNzEzY2QxOWNmZWE4NTE2M2I5NzQ0ZTdhNzI3OTY2 NDI0ODA2Ni4uMzFlYjA2YmMxZmFiNDA5Zjk2MjNmZTBkZjI5ZGRjOGVkMDAwZTM2OCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUveG1sL1hNTEh0dHBSZXF1ZXN0LmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS94bWwvWE1MSHR0cFJlcXVlc3QuY3BwCkBAIC0yODMsMTEgKzI4MywxNiBAQCBBcnJh eUJ1ZmZlciogWE1MSHR0cFJlcXVlc3Q6OnJlc3BvbnNlQXJyYXlCdWZmZXIoRXhjZXB0aW9uQ29k ZSYgZWMpCiAKIHZvaWQgWE1MSHR0cFJlcXVlc3Q6OnNldFJlc3BvbnNlVHlwZShjb25zdCBTdHJp bmcmIHJlc3BvbnNlVHlwZSwgRXhjZXB0aW9uQ29kZSYgZWMpCiB7Ci0gICAgaWYgKG1fc3RhdGUg IT0gT1BFTkVEIHx8IG1fbG9hZGVyKSB7CisgICAgaWYgKG1fc3RhdGUgPiBPUEVORUQgfHwgbV9s b2FkZXIpIHsKICAgICAgICAgZWMgPSBJTlZBTElEX1NUQVRFX0VSUjsKICAgICAgICAgcmV0dXJu OwogICAgIH0KIAorICAgIGlmICghbV9hc3luYyAmJiBzY3JpcHRFeGVjdXRpb25Db250ZXh0KCkt PmlzRG9jdW1lbnQoKSkgeworICAgICAgICBlYyA9IElOVkFMSURfQUNDRVNTX0VSUjsKKyAgICAg ICAgcmV0dXJuOworICAgIH0KKwogICAgIGlmIChyZXNwb25zZVR5cGUgPT0gIiIpCiAgICAgICAg IG1fcmVzcG9uc2VUeXBlQ29kZSA9IFJlc3BvbnNlVHlwZURlZmF1bHQ7CiAgICAgZWxzZSBpZiAo cmVzcG9uc2VUeXBlID09ICJ0ZXh0IikKQEAgLTM1NywxMSArMzYyLDE2IEBAIHZvaWQgWE1MSHR0 cFJlcXVlc3Q6OmNhbGxSZWFkeVN0YXRlQ2hhbmdlTGlzdGVuZXIoKQogCiB2b2lkIFhNTEh0dHBS ZXF1ZXN0OjpzZXRXaXRoQ3JlZGVudGlhbHMoYm9vbCB2YWx1ZSwgRXhjZXB0aW9uQ29kZSYgZWMp CiB7Ci0gICAgaWYgKG1fc3RhdGUgIT0gT1BFTkVEIHx8IG1fbG9hZGVyKSB7CisgICAgaWYgKG1f c3RhdGUgPiBPUEVORUQgfHwgbV9sb2FkZXIpIHsKICAgICAgICAgZWMgPSBJTlZBTElEX1NUQVRF X0VSUjsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAorICAgIGlmICghbV9hc3luYyAmJiBzY3Jp cHRFeGVjdXRpb25Db250ZXh0KCktPmlzRG9jdW1lbnQoKSkgeworICAgICAgICBlYyA9IElOVkFM SURfQUNDRVNTX0VSUjsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwogICAgIG1faW5jbHVkZUNy ZWRlbnRpYWxzID0gdmFsdWU7CiB9CiAKQEAgLTQxNCw3ICs0MjQsNiBAQCB2b2lkIFhNTEh0dHBS ZXF1ZXN0OjpvcGVuKGNvbnN0IFN0cmluZyYgbWV0aG9kLCBjb25zdCBLVVJMJiB1cmwsIGJvb2wg YXN5bmMsIEV4YwogICAgIFN0YXRlIHByZXZpb3VzU3RhdGUgPSBtX3N0YXRlOwogICAgIG1fc3Rh dGUgPSBVTlNFTlQ7CiAgICAgbV9lcnJvciA9IGZhbHNlOwotICAgIG1fcmVzcG9uc2VUeXBlQ29k ZSA9IFJlc3BvbnNlVHlwZURlZmF1bHQ7CiAgICAgbV91cGxvYWRDb21wbGV0ZSA9IGZhbHNlOwog CiAgICAgLy8gY2xlYXIgc3R1ZmYgZnJvbSBwb3NzaWJsZSBwcmV2aW91cyBsb2FkCkBAIC00Mzks NiArNDQ4LDE0IEBAIHZvaWQgWE1MSHR0cFJlcXVlc3Q6Om9wZW4oY29uc3QgU3RyaW5nJiBtZXRo b2QsIGNvbnN0IEtVUkwmIHVybCwgYm9vbCBhc3luYywgRXhjCiAgICAgICAgIHJldHVybjsKICAg ICB9CiAKKyAgICAvLyBTeW5jaHJvbm91cyByZXF1ZXN0cyBmcm9tIGEgd2luZG93IGNvbnRleHQg c2hvdWxkIG5vdCBiZSBhYmxlIHRvIHVzZSBjZXJ0YWluIFhIUiBmZWF0dXJlcworICAgIC8vIHN1 Y2ggYXMgcmVzcG9uc2VUeXBlIGFuZCB3aXRoQ3JlZGVudGlhbHMsIHBlciB0aGUgVzNDIHNwZWMu CisgICAgaWYgKCFhc3luYyAmJiBzY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmlzRG9jdW1lbnQo KQorICAgICAgICAmJiAobV9pbmNsdWRlQ3JlZGVudGlhbHMgfHwgbV9yZXNwb25zZVR5cGVDb2Rl ICE9IFJlc3BvbnNlVHlwZURlZmF1bHQpKSB7CisgICAgICAgIGVjID0gSU5WQUxJRF9BQ0NFU1Nf RVJSOworICAgICAgICByZXR1cm47CisgICAgfQorCiAgICAgbV9tZXRob2QgPSB1cHBlcmNhc2VL bm93bkhUVFBNZXRob2QobWV0aG9kKTsKIAogICAgIG1fdXJsID0gdXJsOwpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IGM0OTdi OTMwYjc1ZjBjNjI5ZDMzYzY4NTcxMWQ1ZWMyOGJkMDI1OTMuLjBiYzcxMjRiYmE4NTBlZjBiMmI5 MmE4NDljNjZlZDQxNzAxNzUyMTQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZwor KysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNyBAQAorMjAxMS0xMi0xOSAg SmFycmVkIE5pY2hvbGxzICA8amFycmVkQHNlbmNoYS5jb20+CisKKyAgICAgICAgU3luY2hyb25v dXMgWEhSIGluIHdpbmRvdyBjb250ZXh0IHNob3VsZCBub3Qgc3VwcG9ydCBuZXcgWEhSIHJlc3Bv bnNlVHlwZXMgb3Igd2l0aENyZWRlbnRpYWxzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD03MjE1NAorCisgICAgICAgIE5ldyB0ZXN0cyB0aGF0IHZhbGlk YXRlIHN5bmNocm9ub3VzIFhIUiByZXF1ZXN0cyBjYW5ub3QgdXNlIHJlc3BvbnNlVHlwZSBvciB3 aXRoQ3JlZGVudGlhbHMsIGFuZAorICAgICAgICBhbHNvIHZhbGlkYXRlIHRoYXQgcmVzcG9uc2VU eXBlIGFuZCB3aXRoQ3JlZGVudGlhbHMgY2FuIGJlIHNldCBiZWZvcmUgYSBjYWxsIHRvIG9wZW4o KS4KKworICAgICAgICBVcGRhdGVkIGV4aXN0aW5nIGh0dHAgeG1saHR0cHJlcXVlc3QgdGVzdHMg dGhhdCB1c2VkIHdpdGhDcmVkZW50aWFscyBzeW5jaHJvbm91c2x5IHRvIGluc3RlYWQKKyAgICAg ICAgb25seSB0ZXN0IGF1dGhvcml6YXRpb24gYW5kIGNvb2tpZSBzdG9yYWdlIGFzeW5jaHJvbm91 c2x5LgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICog ZmFzdC94bWxodHRwcmVxdWVzdC94bWxodHRwcmVxdWVzdC1yZXNwb25zZXR5cGUtc3luYy1yZXF1 ZXN0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC94bWxodHRwcmVxdWVzdC94 bWxodHRwcmVxdWVzdC1yZXNwb25zZXR5cGUtc3luYy1yZXF1ZXN0Lmh0bWw6IEFkZGVkLgorICAg ICAgICAqIGZhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3Qtd2l0aGNyZWRlbnRpYWxz LXN5bmMtcmVxdWVzdC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QveG1saHR0 cHJlcXVlc3QveG1saHR0cHJlcXVlc3Qtd2l0aGNyZWRlbnRpYWxzLXN5bmMtcmVxdWVzdC5odG1s OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L2Nyb3NzLW9yaWdp bi1hdXRob3JpemF0aW9uLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiBodHRwL3Rlc3RzL3htbGh0 dHByZXF1ZXN0L2Nyb3NzLW9yaWdpbi1hdXRob3JpemF0aW9uLmh0bWw6CisgICAgICAgICogaHR0 cC90ZXN0cy94bWxodHRwcmVxdWVzdC9jcm9zcy1vcmlnaW4tY29va2llLXN0b3JhZ2UtZXhwZWN0 ZWQudHh0OgorICAgICAgICAqIGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3QvY3Jvc3Mtb3JpZ2lu LWNvb2tpZS1zdG9yYWdlLmh0bWw6CisgICAgICAgICogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVz dC9jcm9zcy1vcmlnaW4tbm8tYXV0aG9yaXphdGlvbi1leHBlY3RlZC50eHQ6CisgICAgICAgICog aHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9jcm9zcy1vcmlnaW4tbm8tYXV0aG9yaXphdGlvbi5o dG1sOgorCiAyMDExLTEyLTE5ICBNaWtoYWlsIE5hZ2Fub3YgIDxtbmFnYW5vdkBjaHJvbWl1bS5v cmc+CiAKICAgICAgICAgW0Nocm9taXVtXSBSZW1vdmluZyBzdXBwcmVzc2lvbnMgZnJvbToKZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3Qt cmVzcG9uc2V0eXBlLXN5bmMtcmVxdWVzdC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0 L3htbGh0dHByZXF1ZXN0L3htbGh0dHByZXF1ZXN0LXJlc3BvbnNldHlwZS1zeW5jLXJlcXVlc3Qt ZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjA5MjJiOGEzZjJmNTkwYjIxOWFiMjZiMWM5Mjk2ZmEz M2FhYTJhNzgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3htbGh0dHByZXF1 ZXN0L3htbGh0dHByZXF1ZXN0LXJlc3BvbnNldHlwZS1zeW5jLXJlcXVlc3QtZXhwZWN0ZWQudHh0 CkBAIC0wLDAgKzEsMTIgQEAKK1RoaXMgdGVzdHMgdGhhdCB0aGUgWE1MSHR0cFJlcXVlc3QgcmVz cG9uc2VUeXBlIGF0dHJpYnV0ZSBpcyBub3QgdXNhYmxlIHdpdGggc3luY2hyb25vdXMgcmVxdWVz dHMuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2Fn ZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCit4aHIub3BlbignR0VUJywgd2lu ZG93LmxvY2F0aW9uLCBmYWxzZSk7CitQQVNTIHhoci5vcGVuKCdHRVQnLCB3aW5kb3cubG9jYXRp b24sIGZhbHNlKTsgdGhyZXcgZXhjZXB0aW9uIEVycm9yOiBJTlZBTElEX0FDQ0VTU19FUlI6IERP TSBFeGNlcHRpb24gMTUuCitQQVNTIHhoci5yZXNwb25zZVR5cGUgPSAnZG9jdW1lbnQnOyB0aHJl dyBleGNlcHRpb24gRXJyb3I6IElOVkFMSURfQUNDRVNTX0VSUjogRE9NIEV4Y2VwdGlvbiAxNS4K K1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3htbGh0dHByZXF1ZXN0L3htbGh0dHByZXF1ZXN0LXJl c3BvbnNldHlwZS1zeW5jLXJlcXVlc3QuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QveG1saHR0cHJl cXVlc3QveG1saHR0cHJlcXVlc3QtcmVzcG9uc2V0eXBlLXN5bmMtcmVxdWVzdC5odG1sCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjdmNjdkMjM1OWE5MjY5MTUxNDEzYjNiNTE4OTNlODEzYzZhMGM5OWYKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3htbGh0dHByZXF1ZXN0L3htbGh0dHByZXF1ZXN0 LXJlc3BvbnNldHlwZS1zeW5jLXJlcXVlc3QuaHRtbApAQCAtMCwwICsxLDI5IEBACis8IURPQ1RZ UEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+CisgICAgPHNjcmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNl cy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+CisgICAgPHNjcmlwdD4KKyAgICAgICAgZGVzY3Jp cHRpb24oJ1RoaXMgdGVzdHMgdGhhdCB0aGUgWE1MSHR0cFJlcXVlc3QgcmVzcG9uc2VUeXBlIGF0 dHJpYnV0ZSBpcyBub3QgdXNhYmxlIHdpdGggc3luY2hyb25vdXMgcmVxdWVzdHMuJyk7CisgICAg ICAgIHZhciB4aHI7CisKKyAgICAgICAgLy8gU3luY2hyb25vdXMgb3BlbigpIHdpdGggbm8gcmVz cG9uc2VUeXBlIHNldC4KKyAgICAgICAgeGhyID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CisgICAg ICAgIGV2YWxBbmRMb2coInhoci5vcGVuKCdHRVQnLCB3aW5kb3cubG9jYXRpb24sIGZhbHNlKTsi KTsKKworICAgICAgICAvLyBTeW5jaHJvbm91cyBvcGVuKCkgd2l0aCBhIHJlc3BvbnNlVHlwZSBz ZXQuCisgICAgICAgIHhociA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgICAgICB4aHIucmVz cG9uc2VUeXBlID0gJ2RvY3VtZW50JzsKKyAgICAgICAgc2hvdWxkVGhyb3coInhoci5vcGVuKCdH RVQnLCB3aW5kb3cubG9jYXRpb24sIGZhbHNlKTsiKTsKKworICAgICAgICAvLyBTeW5jaHJvbm91 cyBvcGVuKCkgd2l0aCBhIHN1YnNlcXVlbnQgcmVzcG9uc2VUeXBlIHNldCBhdHRlbXB0LgorICAg ICAgICB4aHIgPSBuZXcgWE1MSHR0cFJlcXVlc3QoKTsKKyAgICAgICAgeGhyLm9wZW4oJ0dFVCcs IHdpbmRvdy5sb2NhdGlvbiwgZmFsc2UpOworICAgICAgICBzaG91bGRUaHJvdygieGhyLnJlc3Bv bnNlVHlwZSA9ICdkb2N1bWVudCc7Iik7CisgICAgPC9zY3JpcHQ+CisgICAgPHNjcmlwdCBzcmM9 Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJv ZHk+CisgICAgPGRpdiBpZD0iZGVzY3JpcHRpb24iPjwvZGl2PgorICAgIDxkaXYgaWQ9ImNvbnNv bGUiPjwvZGl2PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFz dC94bWxodHRwcmVxdWVzdC94bWxodHRwcmVxdWVzdC13aXRoY3JlZGVudGlhbHMtc3luYy1yZXF1 ZXN0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QveG1saHR0cHJlcXVlc3QveG1saHR0 cHJlcXVlc3Qtd2l0aGNyZWRlbnRpYWxzLXN5bmMtcmVxdWVzdC1leHBlY3RlZC50eHQKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uOTY5ZWE5Y2UyYTE1MzJiZDc1Njk0NDVjZTViZWQwYjk1YzhhM2I3MAotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3Qt d2l0aGNyZWRlbnRpYWxzLXN5bmMtcmVxdWVzdC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMiBA QAorVGhpcyB0ZXN0cyB0aGF0IHRoZSBYTUxIdHRwUmVxdWVzdCB3aXRoQ3JlZGVudGlhbHMgYXR0 cmlidXRlIGlzIG5vdCB1c2FibGUgd2l0aCBzeW5jaHJvbm91cyByZXF1ZXN0cy4KKworT24gc3Vj Y2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQg YnkgIlRFU1QgQ09NUExFVEUiLgorCisKK3hoci5vcGVuKCdHRVQnLCB3aW5kb3cubG9jYXRpb24s IGZhbHNlKTsKK1BBU1MgeGhyLm9wZW4oJ0dFVCcsIHdpbmRvdy5sb2NhdGlvbiwgZmFsc2UpOyB0 aHJldyBleGNlcHRpb24gRXJyb3I6IElOVkFMSURfQUNDRVNTX0VSUjogRE9NIEV4Y2VwdGlvbiAx NS4KK1BBU1MgeGhyLndpdGhDcmVkZW50aWFscyA9IHRydWU7IHRocmV3IGV4Y2VwdGlvbiBFcnJv cjogSU5WQUxJRF9BQ0NFU1NfRVJSOiBET00gRXhjZXB0aW9uIDE1LgorUEFTUyBzdWNjZXNzZnVs bHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3Qtd2l0aGNyZWRlbnRpYWxzLXN5 bmMtcmVxdWVzdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC94bWxodHRwcmVxdWVzdC94bWxodHRw cmVxdWVzdC13aXRoY3JlZGVudGlhbHMtc3luYy1yZXF1ZXN0Lmh0bWwKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNGZm Y2I3ZDBiNzkzZjUwNTgwODc4OGE0NDVhYTM1NmE3MGViZWU3MwotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2Zhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3Qtd2l0aGNyZWRl bnRpYWxzLXN5bmMtcmVxdWVzdC5odG1sCkBAIC0wLDAgKzEsMjkgQEAKKzwhRE9DVFlQRSBodG1s PgorPGh0bWw+Cis8aGVhZD4KKyAgICA8c2NyaXB0IHNyYz0iLi4vanMvcmVzb3VyY2VzL2pzLXRl c3QtcHJlLmpzIj48L3NjcmlwdD4KKyAgICA8c2NyaXB0PgorICAgICAgICBkZXNjcmlwdGlvbign VGhpcyB0ZXN0cyB0aGF0IHRoZSBYTUxIdHRwUmVxdWVzdCB3aXRoQ3JlZGVudGlhbHMgYXR0cmli dXRlIGlzIG5vdCB1c2FibGUgd2l0aCBzeW5jaHJvbm91cyByZXF1ZXN0cy4nKTsKKyAgICAgICAg dmFyIHhocjsKKworICAgICAgICAvLyBTeW5jaHJvbm91cyBvcGVuKCkgd2l0aG91dCB3aXRoQ3Jl ZGVudGlhbHMgc2V0LgorICAgICAgICB4aHIgPSBuZXcgWE1MSHR0cFJlcXVlc3QoKTsKKyAgICAg ICAgZXZhbEFuZExvZygieGhyLm9wZW4oJ0dFVCcsIHdpbmRvdy5sb2NhdGlvbiwgZmFsc2UpOyIp OworCisgICAgICAgIC8vIFN5bmNocm9ub3VzIG9wZW4oKSB3aXRoIHdpdGhDcmVkZW50aWFscyBz ZXQuCisgICAgICAgIHhociA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgICAgICB4aHIud2l0 aENyZWRlbnRpYWxzID0gdHJ1ZTsKKyAgICAgICAgc2hvdWxkVGhyb3coInhoci5vcGVuKCdHRVQn LCB3aW5kb3cubG9jYXRpb24sIGZhbHNlKTsiKTsKKworICAgICAgICAvLyBTeW5jaHJvbm91cyBv cGVuKCkgd2l0aCBhIHN1YnNlcXVlbnQgd2l0aENyZWRlbnRpYWxzIHNldCBhdHRlbXB0LgorICAg ICAgICB4aHIgPSBuZXcgWE1MSHR0cFJlcXVlc3QoKTsKKyAgICAgICAgeGhyLm9wZW4oJ0dFVCcs IHdpbmRvdy5sb2NhdGlvbiwgZmFsc2UpOworICAgICAgICBzaG91bGRUaHJvdygieGhyLndpdGhD cmVkZW50aWFscyA9IHRydWU7Iik7CisgICAgPC9zY3JpcHQ+CisgICAgPHNjcmlwdCBzcmM9Ii4u L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+ CisgICAgPGRpdiBpZD0iZGVzY3JpcHRpb24iPjwvZGl2PgorICAgIDxkaXYgaWQ9ImNvbnNvbGUi PjwvZGl2PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy94bWxodHRwcmVxdWVzdC9jcm9zcy1vcmlnaW4tYXV0aG9yaXphdGlvbi1leHBlY3RlZC50 eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L2Nyb3NzLW9yaWdpbi1h dXRob3JpemF0aW9uLWV4cGVjdGVkLnR4dAppbmRleCBjZWMwMDA5OGY1OTUxNTJmNDg3OTlkZjYy MmI1MzQ2NDQ5YzU2ZWU4Li5mYmY3NGNiMGM2ZjJhYWVhMGEyYWZkMjk1ZjkxZDUyYTU5OTYzZDFi IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L2Nyb3Nz LW9yaWdpbi1hdXRob3JpemF0aW9uLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL3htbGh0dHByZXF1ZXN0L2Nyb3NzLW9yaWdpbi1hdXRob3JpemF0aW9uLWV4cGVjdGVk LnR4dApAQCAtNSwxNiArNSwxMCBAQCBZb3Ugc2hvdWxkIHNlZSBzZXZlcmFsIFBBU1MgbWVzc2Fn ZXMgZm9sbG93ZWQgYnkgYSBET05FCiAKIFNDUklQVCBTUkM9Jy4uLicgU2hvdWxkIHN1Y2NlZWQs IHNpbmNlIGF1dGhvcml6YXRpb24gaXMgc2VudCBmb3IgY3Jvc3Mtb3JpZ2luIHN1YnJlc291cmNl IGxvYWRzLgogUEFTUzogTG9hZGVkLCB1c2VyIHRlc3QKLUNyb3NzLW9yaWdpbiBYTUxIdHRwUmVx dWVzdCAoc3luYyksIHRlc3Rpbmcgc3RvcmVkIGF1dGhvcml6YXRpb24uCi1QQVNTCi1Dcm9zcy1v cmlnaW4gWE1MSHR0cFJlcXVlc3QgKHN5bmMpLCB0ZXN0aW5nIGNvb2tpZXMuCi1QQVNTCiBDcm9z cy1vcmlnaW4gWE1MSHR0cFJlcXVlc3QgKGFzeW5jKSwgdGVzdGluZyBzdG9yZWQgYXV0aG9yaXph dGlvbi4KIFBBU1MKIENyb3NzLW9yaWdpbiBYTUxIdHRwUmVxdWVzdCAoYXN5bmMpLCB0ZXN0aW5n IGNvb2tpZXMuCiBQQVNTCi1Dcm9zcy1vcmlnaW4gWE1MSHR0cFJlcXVlc3QgKHN5bmMpLCB0ZXN0 aW5nIGF1dGhvcml6YXRpb24gd2l0aCBleHBsaWNpdGx5IHByb3ZpZGVkIGNyZWRlbnRpYWxzIHRo YXQgc2hvdWxkIGJlIGlnbm9yZWQuCi1QQVNTCiBDcm9zcy1vcmlnaW4gWE1MSHR0cFJlcXVlc3Qg KGFzeW5jKSwgdGVzdGluZyBhdXRob3JpemF0aW9uIHdpdGggZXhwbGljaXRseSBwcm92aWRlZCBj cmVkZW50aWFscyB0aGF0IHNob3VsZCBiZSBpZ25vcmVkLgogUEFTUwogRE9ORQpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9jcm9zcy1vcmlnaW4tYXV0 aG9yaXphdGlvbi5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9j cm9zcy1vcmlnaW4tYXV0aG9yaXphdGlvbi5odG1sCmluZGV4IGIyMDc2ZWZkNjI4NmYzNjc4Zjdk MmY2OTI5NjgxYjc3ODg4OTk5YzkuLjI2OGE5MDJlNGJjMDZkNDExNzg0ZjQwNWU1YWMwZDkzNDU1 OWYyNzIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3Qv Y3Jvc3Mtb3JpZ2luLWF1dGhvcml6YXRpb24uaHRtbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3htbGh0dHByZXF1ZXN0L2Nyb3NzLW9yaWdpbi1hdXRob3JpemF0aW9uLmh0bWwKQEAgLTI1 LDQyICsyNSwxMSBAQCBmdW5jdGlvbiB0ZXN0KCkKICAgICBsb2coIlNDUklQVCBTUkM9Jy4uLicg U2hvdWxkIHN1Y2NlZWQsIHNpbmNlIGF1dGhvcml6YXRpb24gaXMgc2VudCBmb3IgY3Jvc3Mtb3Jp Z2luIHN1YnJlc291cmNlIGxvYWRzLiIpOwogICAgIHZhciBzY3JpcHRFbGVtZW50ID0gZG9jdW1l bnQuY3JlYXRlRWxlbWVudCgic2NyaXB0Iik7CiAgICAgc2NyaXB0RWxlbWVudC5zZXRBdHRyaWJ1 dGUoInNyYyIsICJodHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2Vz L2Nyb3NzLW9yaWdpbi1hdXRob3JpemF0aW9uLnBocCIpOwotICAgIHNjcmlwdEVsZW1lbnQuc2V0 QXR0cmlidXRlKCJvbmxvYWQiLCAidGVzdF9zeW5jX2F1dGhfc3RvcmVkKCkiKTsKLSAgICBzY3Jp cHRFbGVtZW50LnNldEF0dHJpYnV0ZSgib25lcnJvciIsICJ0ZXN0X3N5bmNfYXV0aF9zdG9yZWQo KSIpOworICAgIHNjcmlwdEVsZW1lbnQuc2V0QXR0cmlidXRlKCJvbmxvYWQiLCAidGVzdF9hc3lu Y19hdXRoX3N0b3JlZCgpIik7CisgICAgc2NyaXB0RWxlbWVudC5zZXRBdHRyaWJ1dGUoIm9uZXJy b3IiLCAidGVzdF9hc3luY19hdXRoX3N0b3JlZCgpIik7CiAgICAgZG9jdW1lbnQuYm9keS5hcHBl bmRDaGlsZChzY3JpcHRFbGVtZW50KTsKIH0KIAotZnVuY3Rpb24gdGVzdF9zeW5jX2F1dGhfc3Rv cmVkKCkKLXsKLSAgICBsb2coIkNyb3NzLW9yaWdpbiBYTUxIdHRwUmVxdWVzdCAoc3luYyksIHRl c3Rpbmcgc3RvcmVkIGF1dGhvcml6YXRpb24uIik7Ci0gICAgCi0gICAgdmFyIHJlcSA9IG5ldyBY TUxIdHRwUmVxdWVzdDsKLSAgICByZXEub3BlbigiR0VUIiwgImh0dHA6Ly9sb2NhbGhvc3Q6ODAw MC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvY3Jvc3Mtb3JpZ2luLWF1dGhvcml6YXRpb24ucGhw IiwgZmFsc2UpOwotICAgIHJlcS53aXRoQ3JlZGVudGlhbHMgPSB0cnVlOwotICAgIHRyeSB7Ci0g ICAgICAgIHJlcS5zZW5kKCk7Ci0gICAgICAgIGxvZygocmVxLnN0YXR1cyA9PSA0MDEpID8gIkZB SUw6IDQwMSBBdXRob3JpemF0aW9uIHJlcXVpcmVkIiA6ICJQQVNTIik7Ci0gICAgfSBjYXRjaCAo ZXgpIHsKLSAgICAgICAgbG9nKCJGQUlMOiBHb3QgYW4gZXhjZXB0aW9uLiAiICsgZXgpOwotICAg IH0KLSAgICB0ZXN0X3N5bmNfY29va2llcygpOwotfQotCi1mdW5jdGlvbiB0ZXN0X3N5bmNfY29v a2llcygpCi17Ci0gICAgbG9nKCJDcm9zcy1vcmlnaW4gWE1MSHR0cFJlcXVlc3QgKHN5bmMpLCB0 ZXN0aW5nIGNvb2tpZXMuIik7Ci0gICAgCi0gICAgdmFyIHJlcSA9IG5ldyBYTUxIdHRwUmVxdWVz dDsKLSAgICByZXEub3BlbigiR0VUIiwgImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVx dWVzdC9yZXNvdXJjZXMvY3Jvc3Mtb3JpZ2luLWNoZWNrLWNvb2tpZXMucGhwIiwgZmFsc2UpOwot ICAgIHJlcS53aXRoQ3JlZGVudGlhbHMgPSB0cnVlOwotICAgIHJlcS5zZW5kKCk7Ci0gICAgaWYg KHJlcS5zdGF0dXMgPT0gMjAwKQotICAgICAgICBsb2cocmVxLnJlc3BvbnNlVGV4dC5tYXRjaCgv V0tcLWNyb3NzXC1vcmlnaW4vKSA/ICJQQVNTIiA6ICJGQUlMIik7Ci0gICAgZWxzZQotICAgICAg ICBsb2coIkZBSUw6IFdyb25nIHN0YXR1cyBjb2RlICIgKyByZXEuc3RhdHVzKTsKLSAgICB0ZXN0 X2FzeW5jX2F1dGhfc3RvcmVkKCk7Ci19Ci0KIGZ1bmN0aW9uIHRlc3RfYXN5bmNfYXV0aF9zdG9y ZWQoKQogewogICAgIGxvZygiQ3Jvc3Mtb3JpZ2luIFhNTEh0dHBSZXF1ZXN0IChhc3luYyksIHRl c3Rpbmcgc3RvcmVkIGF1dGhvcml6YXRpb24uIik7CkBAIC03MiwxMSArNDEsMTEgQEAgZnVuY3Rp b24gdGVzdF9hc3luY19hdXRoX3N0b3JlZCgpCiAgICAgcmVxLm9ubG9hZCA9IGZ1bmN0aW9uKCkg ewogICAgICAgICBsb2coKHJlcS5zdGF0dXMgPT0gNDAxKSA/ICJGQUlMOiA0MDEgQXV0aG9yaXph dGlvbiByZXF1aXJlZCIgOiAiUEFTUyIpOwogICAgICAgICB0ZXN0X2FzeW5jX2Nvb2tpZXMoKTsK LSAgICB9CisgICAgfTsKICAgICByZXEub25lcnJvciA9IGZ1bmN0aW9uKCkgewogICAgICAgICBs b2coIkZBSUw6IFJlY2VpdmVkIGVycm9yIGV2ZW50LiIpOwogICAgICAgICB0ZXN0X2FzeW5jX2Nv b2tpZXMoKTsKLSAgICB9CisgICAgfTsKIH0KIAogZnVuY3Rpb24gdGVzdF9hc3luY19jb29raWVz KCkKQEAgLTg5LDMwICs1OCwxMCBAQCBmdW5jdGlvbiB0ZXN0X2FzeW5jX2Nvb2tpZXMoKQogICAg IHJlcS5zZW5kKCk7CiAgICAgcmVxLm9ubG9hZCA9IGZ1bmN0aW9uKCkgewogICAgICAgICBsb2co cmVxLnJlc3BvbnNlVGV4dC5tYXRjaCgvV0tcLWNyb3NzXC1vcmlnaW4vKSA/ICJQQVNTIiA6ICJG QUlMIik7Ci0gICAgICAgIHRlc3Rfc3luY19hdXRoX2V4cGxpY2l0KCk7Ci0gICAgfQorICAgICAg ICB0ZXN0X2FzeW5jX2F1dGhfZXhwbGljaXQoKTsKKyAgICB9OwogfQogCi1mdW5jdGlvbiB0ZXN0 X3N5bmNfYXV0aF9leHBsaWNpdCgpCi17Ci0gICAgbG9nKCJDcm9zcy1vcmlnaW4gWE1MSHR0cFJl cXVlc3QgKHN5bmMpLCB0ZXN0aW5nIGF1dGhvcml6YXRpb24gd2l0aCBleHBsaWNpdGx5IHByb3Zp ZGVkIGNyZWRlbnRpYWxzIHRoYXQgc2hvdWxkIGJlIGlnbm9yZWQuIik7Ci0gICAgCi0gICAgdmFy IHJlcSA9IG5ldyBYTUxIdHRwUmVxdWVzdDsKLSAgICByZXEub3BlbigiR0VUIiwgImh0dHA6Ly9s b2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMvY3Jvc3Mtb3JpZ2luLWF1dGhv cml6YXRpb24ucGhwIiwgZmFsc2UsICJ0ZXN0MiIsICJ0ZXN0MiIpOwotICAgIHJlcS53aXRoQ3Jl ZGVudGlhbHMgPSB0cnVlOwotICAgIHRyeSB7Ci0gICAgICAgIHJlcS5zZW5kKCk7Ci0gICAgICAg IGlmIChyZXEuc3RhdHVzID09IDIwMCkKLSAgICAgICAgICAgIGxvZyhyZXEucmVzcG9uc2VUZXh0 Lm1hdGNoKC90ZXN0Mi8pID8gIkZBSUw6IEV4cGxpY2l0IGNyZWRlbnRpYWxzIHdlcmUgbm90IGln bm9yZWQiIDogIlBBU1MiKTsKLSAgICAgICAgZWxzZQotICAgICAgICAgICAgbG9nKCJGQUlMOiBX cm9uZyBzdGF0dXMgY29kZSAiICsgcmVxLnN0YXR1cyk7Ci0gICAgfSBjYXRjaCAoZXgpIHsKLSAg ICAgICAgbG9nKCJGQUlMOiBHb3QgYW4gZXhjZXB0aW9uLiAiICsgZXgpOwotICAgIH0KLSAgICB0 ZXN0X2FzeW5jX2F1dGhfZXhwbGljaXQoKTsKLX0KLQotCiBmdW5jdGlvbiB0ZXN0X2FzeW5jX2F1 dGhfZXhwbGljaXQoKQogewogICAgIGxvZygiQ3Jvc3Mtb3JpZ2luIFhNTEh0dHBSZXF1ZXN0IChh c3luYyksIHRlc3RpbmcgYXV0aG9yaXphdGlvbiB3aXRoIGV4cGxpY2l0bHkgcHJvdmlkZWQgY3Jl ZGVudGlhbHMgdGhhdCBzaG91bGQgYmUgaWdub3JlZC4iKTsKQEAgLTEyOSwxMyArNzgsMTMgQEAg ZnVuY3Rpb24gdGVzdF9hc3luY19hdXRoX2V4cGxpY2l0KCkKICAgICAgICAgbG9nKCJET05FIik7 CiAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCiAgICAgICAgICAgICBs YXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Ci0gICAgfQorICAgIH07CiAgICAgcmVx Lm9uZXJyb3IgPSBmdW5jdGlvbigpIHsKICAgICAgICAgbG9nKCJGQUlMOiBSZWNlaXZlZCBlcnJv ciBldmVudC4iKTsKICAgICAgICAgbG9nKCJET05FIik7CiAgICAgICAgIGlmICh3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIpCiAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3Rp ZnlEb25lKCk7Ci0gICAgfQorICAgIH07CiB9CiAKIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0 L2Nyb3NzLW9yaWdpbi1jb29raWUtc3RvcmFnZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L2Nyb3NzLW9yaWdpbi1jb29raWUtc3RvcmFnZS1leHBl Y3RlZC50eHQKaW5kZXggMTRjY2U2NzAwOGQ5ZDBjNjAzOTNkNjQ4NmQwNjQ2YTZkYzcxZWVhZS4u YWZmMGZmMjlmMDEyZDlkNjU0ZjMxNmNjMmE2NmY5MGY1NTQxZjUyOSAxMDA2NDQKLS0tIGEvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9jcm9zcy1vcmlnaW4tY29va2llLXN0 b3JhZ2UtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJl cXVlc3QvY3Jvc3Mtb3JpZ2luLWNvb2tpZS1zdG9yYWdlLWV4cGVjdGVkLnR4dApAQCAtMSwxMiAr MSw5IEBACiBTdGFydAotQ3Jvc3Mtb3JpZ2luIFhNTEh0dHBSZXF1ZXN0IChzeW5jKSwgdGVzdGlu ZyB0aGF0IGNvb2tpZXMgYXJlIG5vdCBzZXQgd2hlbiBub3Qgc2VuZGluZyBjcmVkZW50aWFscy4K LVBBU1M6IEZpbmlzaGVkIHN5bmMgeGhyLgotUEFTUzogTm8gY29va2llcyBzZXQuCiBDcm9zcy1v cmlnaW4gWE1MSHR0cFJlcXVlc3QgKGFzeW5jKSwgdGVzdGluZyB0aGF0IGNvb2tpZXMgYXJlIG5v dCBzZXQgd2hlbiBub3Qgc2VuZGluZyBjcmVkZW50aWFscy4KIFBBU1M6IEZpbmlzaGVkIGFzeW5j IHhoci4KIFBBU1M6IE5vIGNvb2tpZXMgc2V0LgotQ3Jvc3Mtb3JpZ2luIFhNTEh0dHBSZXF1ZXN0 IChzeW5jKSwgdGVzdGluZyB0aGF0IGNvb2tpZXMgYXJlIHNldCB3aGVuIHNlbmRpbmcgY3JlZGVu dGlhbHMuCi1QQVNTOiBGaW5pc2hlZCBzeW5jIHhoci4KK0Nyb3NzLW9yaWdpbiBYTUxIdHRwUmVx dWVzdCAoYXN5bmMpLCB0ZXN0aW5nIHRoYXQgY29va2llcyBhcmUgc2V0IHdoZW4gc2VuZGluZyBj cmVkZW50aWFscy4KK1BBU1M6IEZpbmlzaGVkIGFzeW5jIHhoci4KIFBBU1M6IENvb2tpZSBzZXQu CiBET05FCiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVl c3QvY3Jvc3Mtb3JpZ2luLWNvb2tpZS1zdG9yYWdlLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL3htbGh0dHByZXF1ZXN0L2Nyb3NzLW9yaWdpbi1jb29raWUtc3RvcmFnZS5odG1sCmluZGV4 IDQwYzlkMmFkZjE5YzQ5M2U2YmMxNGE2NmYwMzRjZjk0ZGZkMzc1MjguLmYxZDcxYjNmMjYzNmVl ZjFlZmZiZjM4YWUxYjhiZWY1YzZmMWFiYWIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2h0dHAv dGVzdHMveG1saHR0cHJlcXVlc3QvY3Jvc3Mtb3JpZ2luLWNvb2tpZS1zdG9yYWdlLmh0bWwKKysr IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9jcm9zcy1vcmlnaW4tY29v a2llLXN0b3JhZ2UuaHRtbApAQCAtMSw0ICsxLDQgQEAKLTxidXR0b24gb25jbGljaz0idGVzdFN5 bmNDb29raWVzTm9DcmVkZW50aWFscygpOyI+U3RhcnQ8L2J1dHRvbj4KKzxidXR0b24gb25jbGlj az0idGVzdEFzeW5jQ29va2llc05vQ3JlZGVudGlhbHMoKTsiPlN0YXJ0PC9idXR0b24+CiA8cHJl IGlkPSJjb25zb2xlIj48L3ByZT4KIDxzY3JpcHQ+CiBpZiAod2luZG93LmxheW91dFRlc3RDb250 cm9sbGVyKSB7CkBAIC0xOSw5MyArMTksOTAgQEAgZnVuY3Rpb24gcmVzb3VyY2VVUkwocmVzb3Vy Y2VOYW1lKQogICAgIHJldHVybiAiaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0 L3Jlc291cmNlcy8iICsgcmVzb3VyY2VOYW1lOwogfQogCi1mdW5jdGlvbiBjbGVhckNvb2tpZXMo KQorZnVuY3Rpb24gY2xlYXJDb29raWVzKGNiKQogewogICAgIHZhciB4aHIgPSBuZXcgWE1MSHR0 cFJlcXVlc3Q7Ci0gICAgeGhyLm9wZW4oIkdFVCIsIHJlc291cmNlVVJMKCJjcm9zcy1vcmlnaW4t c2V0LWNvb2tpZXMucGhwP2NsZWFyPTEiKSwgZmFsc2UpOworICAgIHhoci5vcGVuKCJHRVQiLCBy ZXNvdXJjZVVSTCgiY3Jvc3Mtb3JpZ2luLXNldC1jb29raWVzLnBocD9jbGVhcj0xIiksIHRydWUp OwogICAgIHhoci53aXRoQ3JlZGVudGlhbHMgPSB0cnVlOworICAgIHhoci5vbmxvYWQgPSBjYjsK KyAgICB4aHIub25lcnJvciA9IGNiOwogICAgIHhoci5zZW5kKCIiKTsKIH0KIAogZnVuY3Rpb24g ZW5kVGVzdGluZygpCiB7Ci0gICAgY2xlYXJDb29raWVzKCk7Ci0gICAgaWYgKHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlcikKLSAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9u ZSgpOworICAgIGNsZWFyQ29va2llcyhmdW5jdGlvbigpeworICAgICAgICBpZiAod2luZG93Lmxh eW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90 aWZ5RG9uZSgpOworICAgIH0pOwogfQogCi1mdW5jdGlvbiBjaGVja0ZvckNvb2tpZSgpCitmdW5j dGlvbiBjaGVja0ZvckNvb2tpZShjYikKIHsKICAgICB2YXIgeGhyID0gbmV3IFhNTEh0dHBSZXF1 ZXN0OwotICAgIHhoci5vcGVuKCJHRVQiLCByZXNvdXJjZVVSTCgiY3Jvc3Mtb3JpZ2luLWNoZWNr LWNvb2tpZXMucGhwP2Nvb2tpZT1XSy14aHItY29va2llLXN0b3JhZ2UiKSwgZmFsc2UpOworICAg IHhoci5vcGVuKCJHRVQiLCByZXNvdXJjZVVSTCgiY3Jvc3Mtb3JpZ2luLWNoZWNrLWNvb2tpZXMu cGhwP2Nvb2tpZT1XSy14aHItY29va2llLXN0b3JhZ2UiKSwgdHJ1ZSk7CiAgICAgeGhyLndpdGhD cmVkZW50aWFscyA9IHRydWU7CisgICAgeGhyLm9ubG9hZCA9IGZ1bmN0aW9uKCkgeworICAgICAg ICBjYih4aHIucmVzcG9uc2VUZXh0KTsKKyAgICB9OworICAgIHhoci5vbmVycm9yID0gZnVuY3Rp b24oKSB7CisgICAgICAgIGNiKHhoci5yZXNwb25zZVRleHQpOworICAgIH07CiAgICAgdHJ5IHsK ICAgICAgICAgeGhyLnNlbmQoKTsKLSAgICAgICAgcmV0dXJuIHhoci5yZXNwb25zZVRleHQKICAg ICB9IGNhdGNoIChleCkgewogICAgICAgICBsb2coIkZBSUw6IEdvdCBhbiBleGNlcHRpb24uICIg KyBleCk7CiAgICAgfQogfQogCi1mdW5jdGlvbiB0ZXN0U3luY0Nvb2tpZXNOb0NyZWRlbnRpYWxz KCkKLXsKLSAgICBsb2coIkNyb3NzLW9yaWdpbiBYTUxIdHRwUmVxdWVzdCAoc3luYyksIHRlc3Rp bmcgdGhhdCBjb29raWVzIGFyZSBub3Qgc2V0IHdoZW4gbm90IHNlbmRpbmcgY3JlZGVudGlhbHMu Iik7Ci0KLSAgICBjbGVhckNvb2tpZXMoKTsKLQotICAgIHZhciByZXEgPSBuZXcgWE1MSHR0cFJl cXVlc3Q7Ci0gICAgcmVxLm9wZW4oIkdFVCIsIHJlc291cmNlVVJMKCJjcm9zcy1vcmlnaW4tc2V0 LWNvb2tpZXMucGhwIiksIGZhbHNlKTsKLSAgICByZXEud2l0aENyZWRlbnRpYWxzID0gZmFsc2U7 Ci0gICAgcmVxLnNlbmQoKTsKLSAgICBsb2coIlBBU1M6IEZpbmlzaGVkIHN5bmMgeGhyLiIpOwot Ci0gICAgdmFyIHJlc3BvbnNlID0gY2hlY2tGb3JDb29raWUoKQotICAgIGxvZyghcmVzcG9uc2Uu bWF0Y2goL1dLXC14aHJcLWNvb2tpZVwtc3RvcmFnZTogTXlTcGVjaWFsVmFsdWUvKSA/ICJQQVNT OiBObyBjb29raWVzIHNldC4iIDogKCJGQUlMOiAiICsgcmVzcG9uc2UpKTsKLQotICAgIHRlc3RB c3luY0Nvb2tpZXNOb0NyZWRlbnRpYWxzKCk7Ci19Ci0KIGZ1bmN0aW9uIHRlc3RBc3luY0Nvb2tp ZXNOb0NyZWRlbnRpYWxzKCkKIHsKICAgICBsb2coIkNyb3NzLW9yaWdpbiBYTUxIdHRwUmVxdWVz dCAoYXN5bmMpLCB0ZXN0aW5nIHRoYXQgY29va2llcyBhcmUgbm90IHNldCB3aGVuIG5vdCBzZW5k aW5nIGNyZWRlbnRpYWxzLiIpOwogCi0gICAgY2xlYXJDb29raWVzKCk7Ci0KLSAgICB2YXIgcmVx ID0gbmV3IFhNTEh0dHBSZXF1ZXN0OwotICAgIHJlcS5vcGVuKCJHRVQiLCByZXNvdXJjZVVSTCgi Y3Jvc3Mtb3JpZ2luLXNldC1jb29raWVzLnBocCIpLCB0cnVlKTsKLSAgICByZXEud2l0aENyZWRl bnRpYWxzID0gZmFsc2U7Ci0gICAgcmVxLnNlbmQoKTsKLSAgICByZXEub25lcnJvciA9IGZ1bmN0 aW9uKCkgewotICAgICAgICBsb2coIkZBSUw6IEFzeW5jIHhociB0byBzZXQgY29va2llcy4iKTsK LSAgICAgICAgZW5kVGVzdGluZygpOwotICAgIH0KLSAgICByZXEub25sb2FkID0gZnVuY3Rpb24o KSB7Ci0gICAgICAgIGxvZygiUEFTUzogRmluaXNoZWQgYXN5bmMgeGhyLiIpOwotICAgICAgICB2 YXIgcmVzcG9uc2UgPSBjaGVja0ZvckNvb2tpZSgpOwotICAgICAgICBsb2coIXJlc3BvbnNlLm1h dGNoKC9XS1wteGhyXC1jb29raWVcLXN0b3JhZ2U6IE15U3BlY2lhbFZhbHVlLykgPyAiUEFTUzog Tm8gY29va2llcyBzZXQuIiA6ICgiRkFJTDogIiArIHJlc3BvbnNlKSk7Ci0gICAgICAgIHRlc3RT eW5jQ29va2llc1dpdGhDcmVkZW50aWFscygpOwotICAgIH0KKyAgICBjbGVhckNvb2tpZXMoZnVu Y3Rpb24oKSB7CisgICAgICAgIHZhciByZXEgPSBuZXcgWE1MSHR0cFJlcXVlc3Q7CisgICAgICAg IHJlcS5vcGVuKCJHRVQiLCByZXNvdXJjZVVSTCgiY3Jvc3Mtb3JpZ2luLXNldC1jb29raWVzLnBo cCIpLCB0cnVlKTsKKyAgICAgICAgcmVxLndpdGhDcmVkZW50aWFscyA9IGZhbHNlOworICAgICAg ICByZXEub25lcnJvciA9IGZ1bmN0aW9uKCkgeworICAgICAgICAgICAgbG9nKCJGQUlMOiBBc3lu YyB4aHIgdG8gc2V0IGNvb2tpZXMuIik7CisgICAgICAgICAgICBlbmRUZXN0aW5nKCk7CisgICAg ICAgIH07CisgICAgICAgIHJlcS5vbmxvYWQgPSBmdW5jdGlvbigpIHsKKyAgICAgICAgICAgIGxv ZygiUEFTUzogRmluaXNoZWQgYXN5bmMgeGhyLiIpOworICAgICAgICAgICAgY2hlY2tGb3JDb29r aWUoZnVuY3Rpb24ocmVzcG9uc2UpIHsKKyAgICAgICAgICAgICAgICBsb2coIXJlc3BvbnNlLm1h dGNoKC9XS1wteGhyXC1jb29raWVcLXN0b3JhZ2U6IE15U3BlY2lhbFZhbHVlLykgPyAiUEFTUzog Tm8gY29va2llcyBzZXQuIiA6ICgiRkFJTDogIiArIHJlc3BvbnNlKSk7CisgICAgICAgICAgICAg ICAgdGVzdEFzeW5jQ29va2llc1dpdGhDcmVkZW50aWFscygpOworICAgICAgICAgICAgfSk7Cisg ICAgICAgIH07CisgICAgICAgIHJlcS5zZW5kKCk7CisgICAgfSk7CiB9CiAKLWZ1bmN0aW9uIHRl c3RTeW5jQ29va2llc1dpdGhDcmVkZW50aWFscygpCitmdW5jdGlvbiB0ZXN0QXN5bmNDb29raWVz V2l0aENyZWRlbnRpYWxzKCkKIHsKLSAgICBsb2coIkNyb3NzLW9yaWdpbiBYTUxIdHRwUmVxdWVz dCAoc3luYyksIHRlc3RpbmcgdGhhdCBjb29raWVzIGFyZSBzZXQgd2hlbiBzZW5kaW5nIGNyZWRl bnRpYWxzLiIpOwotCi0gICAgY2xlYXJDb29raWVzKCk7Ci0KLSAgICB2YXIgcmVxID0gbmV3IFhN TEh0dHBSZXF1ZXN0OwotICAgIHJlcS5vcGVuKCJHRVQiLCByZXNvdXJjZVVSTCgiY3Jvc3Mtb3Jp Z2luLXNldC1jb29raWVzLnBocCIpLCBmYWxzZSk7Ci0gICAgcmVxLndpdGhDcmVkZW50aWFscyA9 IHRydWU7Ci0gICAgcmVxLnNlbmQoKTsKLSAgICBsb2coIlBBU1M6IEZpbmlzaGVkIHN5bmMgeGhy LiIpOwotCi0gICAgdmFyIHJlc3BvbnNlID0gY2hlY2tGb3JDb29raWUoKTsKLSAgICBsb2cocmVz cG9uc2UubWF0Y2goL1dLXC14aHJcLWNvb2tpZVwtc3RvcmFnZTogTXlTcGVjaWFsVmFsdWUvKSA/ ICJQQVNTOiBDb29raWUgc2V0LiIgOiAiRkFJTDogbm8gY29va2llIHNldC4iKTsKLSAgICBsb2co IkRPTkUiKTsKLSAgICBlbmRUZXN0aW5nKCk7CisgICAgbG9nKCJDcm9zcy1vcmlnaW4gWE1MSHR0 cFJlcXVlc3QgKGFzeW5jKSwgdGVzdGluZyB0aGF0IGNvb2tpZXMgYXJlIHNldCB3aGVuIHNlbmRp bmcgY3JlZGVudGlhbHMuIik7CisKKyAgICBjbGVhckNvb2tpZXMoZnVuY3Rpb24oKSB7CisgICAg ICAgIHZhciByZXEgPSBuZXcgWE1MSHR0cFJlcXVlc3Q7CisgICAgICAgIHJlcS5vcGVuKCJHRVQi LCByZXNvdXJjZVVSTCgiY3Jvc3Mtb3JpZ2luLXNldC1jb29raWVzLnBocCIpLCB0cnVlKTsKKyAg ICAgICAgcmVxLndpdGhDcmVkZW50aWFscyA9IHRydWU7CisgICAgICAgIHJlcS5vbmVycm9yID0g ZnVuY3Rpb24oKSB7CisgICAgICAgICAgICBsb2coIkZBSUw6IEFzeW5jIHhociB0byBzZXQgY29v a2llcy4iKTsKKyAgICAgICAgICAgIGVuZFRlc3RpbmcoKTsKKyAgICAgICAgfTsKKyAgICAgICAg cmVxLm9ubG9hZCA9IGZ1bmN0aW9uKCkgeworICAgICAgICAgICAgbG9nKCJQQVNTOiBGaW5pc2hl ZCBhc3luYyB4aHIuIik7CisgICAgICAgICAgICBjaGVja0ZvckNvb2tpZShmdW5jdGlvbihyZXNw b25zZSkgeworICAgICAgICAgICAgICAgIGxvZyhyZXNwb25zZS5tYXRjaCgvV0tcLXhoclwtY29v a2llXC1zdG9yYWdlOiBNeVNwZWNpYWxWYWx1ZS8pID8gIlBBU1M6IENvb2tpZSBzZXQuIiA6ICJG QUlMOiBubyBjb29raWUgc2V0LiIpOworICAgICAgICAgICAgICAgIGxvZygiRE9ORSIpOworICAg ICAgICAgICAgICAgIGVuZFRlc3RpbmcoKTsKKyAgICAgICAgICAgIH0pOworICAgICAgICB9Owor ICAgICAgICByZXEuc2VuZCgpOworICAgIH0pOwogfQogCiBpZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKQotICAgIHRlc3RTeW5jQ29va2llc05vQ3JlZGVudGlhbHMoKTsKKyAgICB0ZXN0 QXN5bmNDb29raWVzTm9DcmVkZW50aWFscygpOwogPC9zY3JpcHQ+CiAKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3QvY3Jvc3Mtb3JpZ2luLW5vLWF1dGhv cml6YXRpb24tZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVx dWVzdC9jcm9zcy1vcmlnaW4tbm8tYXV0aG9yaXphdGlvbi1leHBlY3RlZC50eHQKaW5kZXggZWYz ZTExZTM3ZDI2YWQ0OTcxNjNjYmI3M2ZmYzJlYmVhMDc0ZDUzMi4uZDA1YzVhMjNmMzNjYTRjNzJi NGJjMDI3NzU3MTY5ZGU4MDQzNWYzMyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy94bWxodHRwcmVxdWVzdC9jcm9zcy1vcmlnaW4tbm8tYXV0aG9yaXphdGlvbi1leHBlY3RlZC50 eHQKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC9jcm9zcy1vcmln aW4tbm8tYXV0aG9yaXphdGlvbi1leHBlY3RlZC50eHQKQEAgLTEsNSArMSw0IEBACiBDT05TT0xF IE1FU1NBR0U6IGxpbmUgMTogWE1MSHR0cFJlcXVlc3QgY2Fubm90IGxvYWQgaHR0cDovL2xvY2Fs aG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9jcm9zcy1vcmlnaW4tbm8tYXV0aG9y aXphdGlvbi5waHAuIENyZWRlbnRpYWxzIGZsYWcgaXMgdHJ1ZSwgYnV0IEFjY2Vzcy1Db250cm9s LUFsbG93LUNyZWRlbnRpYWxzIGlzIG5vdCAidHJ1ZSIuCi1DT05TT0xFIE1FU1NBR0U6IGxpbmUg MTogWE1MSHR0cFJlcXVlc3QgY2Fubm90IGxvYWQgaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0 dHByZXF1ZXN0L3Jlc291cmNlcy9jcm9zcy1vcmlnaW4tbm8tYXV0aG9yaXphdGlvbi5waHAuIENy ZWRlbnRpYWxzIGZsYWcgaXMgdHJ1ZSwgYnV0IEFjY2Vzcy1Db250cm9sLUFsbG93LUNyZWRlbnRp YWxzIGlzIG5vdCAidHJ1ZSIuCiBTdGFydAogVHJ5aW5nIGRpZmZlcmVudCB3YXlzIHRvIGFjY2Vz cyBhIHBhc3N3b3JkIHByb3RlY3RlZCByZXNvdXJjZSBmcm9tIGFub3RoZXIgb3JpZ2luLiBUaGUg VUEgYWxyZWFkeSBoYXMgbG9naW4gYW5kIHBhc3N3b3JkIGZvciB0aGlzIHByb3RlY3Rpb24gc3Bh Y2UuCiAKQEAgLTcsMjAgKzYsMTIgQEAgWW91IHNob3VsZCBzZWUgc2V2ZXJhbCBQQVNTIG1lc3Nh Z2VzIGZvbGxvd2VkIGJ5IGEgRE9ORQogCiBTQ1JJUFQgU1JDPScuLi4nIFNob3VsZCBzdWNjZWVk LCBzaW5jZSBhdXRob3JpemF0aW9uIGlzIHNlbnQgZm9yIGNyb3NzLW9yaWdpbiBzdWJyZXNvdXJj ZSBsb2Fkcy4KIFBBU1M6IExvYWRlZCwgdXNlciB0ZXN0Ci1Dcm9zcy1vcmlnaW4gWE1MSHR0cFJl cXVlc3QgKHN5bmMpLCBhdXRob3JpemF0aW9uIHdpbGwgbm90IGJlIHNlbnQsIGJlY2F1c2Ugd2l0 aENyZWRlbnRpYWxzIGlzIGZhbHNlLgotUEFTUzogNDAxIEF1dGhvcml6YXRpb24gcmVxdWlyZWQK LUNyb3NzLW9yaWdpbiBYTUxIdHRwUmVxdWVzdCAoc3luYyksIHRlc3RpbmcgYXV0aG9yaXphdGlv biB0aGF0J3Mgbm90IGFsbG93ZWQgYnkgdGhlIHNlcnZlciAod2l0aENyZWRlbnRpYWxzIGlzIHRy dWUsIGJ1dCBhY2Nlc3MgY29udHJvbCBoZWFkZXJzIGFyZSBub3Qgc2V0KS4KLVBBU1M6IEdvdCBh biBleGNlcHRpb24uIEVycm9yOiBORVRXT1JLX0VSUjogWE1MSHR0cFJlcXVlc3QgRXhjZXB0aW9u IDEwMQotQ3Jvc3Mtb3JpZ2luIFhNTEh0dHBSZXF1ZXN0IChzeW5jKSwgdGVzdGluZyBjb29raWVz LgotUEFTUwogQ3Jvc3Mtb3JpZ2luIFhNTEh0dHBSZXF1ZXN0IChhc3luYyksIGF1dGhvcml6YXRp b24gd2lsbCBub3QgYmUgc2VudCwgYmVjYXVzZSB3aXRoQ3JlZGVudGlhbHMgaXMgZmFsc2UuCiBQ QVNTOiA0MDEgQXV0aG9yaXphdGlvbiByZXF1aXJlZAogQ3Jvc3Mtb3JpZ2luIFhNTEh0dHBSZXF1 ZXN0IChhc3luYyksIHRlc3RpbmcgYXV0aG9yaXphdGlvbiB0aGF0J3Mgbm90IGFsbG93ZWQgYnkg dGhlIHNlcnZlciAod2l0aENyZWRlbnRpYWxzIGlzIHRydWUsIGJ1dCBhY2Nlc3MgY29udHJvbCBo ZWFkZXJzIGFyZSBub3Qgc2V0KS4KIFBBU1M6IFJlY2VpdmVkIGVycm9yIGV2ZW50LgogQ3Jvc3Mt b3JpZ2luIFhNTEh0dHBSZXF1ZXN0IChhc3luYyksIHRlc3RpbmcgY29va2llcy4KIFBBU1MKLUNy b3NzLW9yaWdpbiBYTUxIdHRwUmVxdWVzdCAoc3luYyksIHRlc3RpbmcgYXV0aG9yaXphdGlvbiB3 aXRoIGV4cGxpY2l0bHkgcHJvdmlkZWQgY3JlZGVudGlhbHMgdGhhdCBzaG91bGQgYmUgaWdub3Jl ZC4KLVBBU1M6IDQwMSBBdXRob3JpemF0aW9uIHJlcXVpcmVkCiBDcm9zcy1vcmlnaW4gWE1MSHR0 cFJlcXVlc3QgKGFzeW5jKSwgdGVzdGluZyBhdXRob3JpemF0aW9uIHdpdGggZXhwbGljaXRseSBw cm92aWRlZCBjcmVkZW50aWFscyB0aGF0IHNob3VsZCBiZSBpZ25vcmVkLgogUEFTUzogNDAxIEF1 dGhvcml6YXRpb24gcmVxdWlyZWQKIERPTkUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAv dGVzdHMveG1saHR0cHJlcXVlc3QvY3Jvc3Mtb3JpZ2luLW5vLWF1dGhvcml6YXRpb24uaHRtbCBi L0xheW91dFRlc3RzL2h0dHAvdGVzdHMveG1saHR0cHJlcXVlc3QvY3Jvc3Mtb3JpZ2luLW5vLWF1 dGhvcml6YXRpb24uaHRtbAppbmRleCAxMTJjZTk0YmVlMzE2NmM5MGM2YmUyOTg4NTNjZTdlYzAw MDA0MGM2Li40ZTJkN2E1MWE0OGRiNDA4NTk4MGFkOTFjYzFhY2IwMjk4MDZmZGI2IDEwMDY0NAot LS0gYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L2Nyb3NzLW9yaWdpbi1u by1hdXRob3JpemF0aW9uLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy94bWxodHRw cmVxdWVzdC9jcm9zcy1vcmlnaW4tbm8tYXV0aG9yaXphdGlvbi5odG1sCkBAIC0yNSw1MyArMjUs MTEgQEAgZnVuY3Rpb24gdGVzdCgpCiAgICAgbG9nKCJTQ1JJUFQgU1JDPScuLi4nIFNob3VsZCBz dWNjZWVkLCBzaW5jZSBhdXRob3JpemF0aW9uIGlzIHNlbnQgZm9yIGNyb3NzLW9yaWdpbiBzdWJy ZXNvdXJjZSBsb2Fkcy4iKTsKICAgICB2YXIgc2NyaXB0RWxlbWVudCA9IGRvY3VtZW50LmNyZWF0 ZUVsZW1lbnQoInNjcmlwdCIpOwogICAgIHNjcmlwdEVsZW1lbnQuc2V0QXR0cmlidXRlKCJzcmMi LCAiaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9jcm9zcy1v cmlnaW4tbm8tYXV0aG9yaXphdGlvbi5waHAiKTsKLSAgICBzY3JpcHRFbGVtZW50LnNldEF0dHJp YnV0ZSgib25sb2FkIiwgInRlc3Rfc3luY19hdXRoX3N0b3JlZCgpIik7Ci0gICAgc2NyaXB0RWxl bWVudC5zZXRBdHRyaWJ1dGUoIm9uZXJyb3IiLCAidGVzdF9zeW5jX2F1dGhfc3RvcmVkKCkiKTsK KyAgICBzY3JpcHRFbGVtZW50LnNldEF0dHJpYnV0ZSgib25sb2FkIiwgInRlc3RfYXN5bmNfYXV0 aF9zdG9yZWQoKSIpOworICAgIHNjcmlwdEVsZW1lbnQuc2V0QXR0cmlidXRlKCJvbmVycm9yIiwg InRlc3RfYXN5bmNfYXV0aF9zdG9yZWQoKSIpOwogICAgIGRvY3VtZW50LmJvZHkuYXBwZW5kQ2hp bGQoc2NyaXB0RWxlbWVudCk7CiB9CiAKLWZ1bmN0aW9uIHRlc3Rfc3luY19hdXRoX3N0b3JlZCgp Ci17Ci0gICAgbG9nKCJDcm9zcy1vcmlnaW4gWE1MSHR0cFJlcXVlc3QgKHN5bmMpLCBhdXRob3Jp emF0aW9uIHdpbGwgbm90IGJlIHNlbnQsIGJlY2F1c2Ugd2l0aENyZWRlbnRpYWxzIGlzIGZhbHNl LiIpOwotICAgIAotICAgIHZhciByZXEgPSBuZXcgWE1MSHR0cFJlcXVlc3Q7Ci0gICAgcmVxLm9w ZW4oIkdFVCIsICJodHRwOi8vbG9jYWxob3N0OjgwMDAveG1saHR0cHJlcXVlc3QvcmVzb3VyY2Vz L2Nyb3NzLW9yaWdpbi1uby1hdXRob3JpemF0aW9uLnBocCIsIGZhbHNlKTsKLSAgICB0cnkgewot ICAgICAgICByZXEuc2VuZCgpOwotICAgICAgICBsb2coKHJlcS5zdGF0dXMgPT0gNDAxKSA/ICJQ QVNTOiA0MDEgQXV0aG9yaXphdGlvbiByZXF1aXJlZCIgOiAiRkFJTDogTG9hZGVkIik7Ci0gICAg fSBjYXRjaCAoZXgpIHsKLSAgICAgICAgbG9nKCJQQVNTOiBHb3QgYW4gZXhjZXB0aW9uLiAiICsg ZXgpOwotICAgIH0KLSAgICB0ZXN0X3N5bmNfYXV0aF9zdG9yZWRfd2l0aF9jcmVkZW50aWFscygp OwotfQotCi1mdW5jdGlvbiB0ZXN0X3N5bmNfYXV0aF9zdG9yZWRfd2l0aF9jcmVkZW50aWFscygp Ci17Ci0gICAgbG9nKCJDcm9zcy1vcmlnaW4gWE1MSHR0cFJlcXVlc3QgKHN5bmMpLCB0ZXN0aW5n IGF1dGhvcml6YXRpb24gdGhhdCdzIG5vdCBhbGxvd2VkIGJ5IHRoZSBzZXJ2ZXIgKHdpdGhDcmVk ZW50aWFscyBpcyB0cnVlLCBidXQgYWNjZXNzIGNvbnRyb2wgaGVhZGVycyBhcmUgbm90IHNldCku Iik7Ci0gICAgCi0gICAgdmFyIHJlcSA9IG5ldyBYTUxIdHRwUmVxdWVzdDsKLSAgICByZXEub3Bl bigiR0VUIiwgImh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC94bWxodHRwcmVxdWVzdC9yZXNvdXJjZXMv Y3Jvc3Mtb3JpZ2luLW5vLWF1dGhvcml6YXRpb24ucGhwIiwgZmFsc2UpOwotICAgIHJlcS53aXRo Q3JlZGVudGlhbHMgPSB0cnVlOwotICAgIHRyeSB7Ci0gICAgICAgIHJlcS5zZW5kKCk7Ci0gICAg ICAgIGxvZygocmVxLnN0YXR1cyA9PSA0MDEpID8gIlBBU1M6IDQwMSBBdXRob3JpemF0aW9uIHJl cXVpcmVkIiA6ICJGQUlMOiBMb2FkZWQiKTsKLSAgICB9IGNhdGNoIChleCkgewotICAgICAgICBs b2coIlBBU1M6IEdvdCBhbiBleGNlcHRpb24uICIgKyBleCk7Ci0gICAgfQotICAgIHRlc3Rfc3lu Y19jb29raWVzKCk7Ci19Ci0KLWZ1bmN0aW9uIHRlc3Rfc3luY19jb29raWVzKCkKLXsKLSAgICBs b2coIkNyb3NzLW9yaWdpbiBYTUxIdHRwUmVxdWVzdCAoc3luYyksIHRlc3RpbmcgY29va2llcy4i KTsKLSAgICAKLSAgICB2YXIgcmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0OwotICAgIHJlcS5vcGVu KCJHRVQiLCAiaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9j cm9zcy1vcmlnaW4tY2hlY2stY29va2llcy5waHAiLCBmYWxzZSk7Ci0gICAgcmVxLnNlbmQoKTsK LSAgICBsb2cocmVxLnJlc3BvbnNlVGV4dC5tYXRjaCgvV0tcLWNyb3NzXC1vcmlnaW4vKSA/ICJG QUlMIiA6ICJQQVNTIik7Ci0gICAgdGVzdF9hc3luY19hdXRoX3N0b3JlZCgpOwotfQotCiBmdW5j dGlvbiB0ZXN0X2FzeW5jX2F1dGhfc3RvcmVkKCkKIHsKICAgICBsb2coIkNyb3NzLW9yaWdpbiBY TUxIdHRwUmVxdWVzdCAoYXN5bmMpLCBhdXRob3JpemF0aW9uIHdpbGwgbm90IGJlIHNlbnQsIGJl Y2F1c2Ugd2l0aENyZWRlbnRpYWxzIGlzIGZhbHNlLiIpOwpAQCAtODIsMTEgKzQwLDExIEBAIGZ1 bmN0aW9uIHRlc3RfYXN5bmNfYXV0aF9zdG9yZWQoKQogICAgIHJlcS5vbmxvYWQgPSBmdW5jdGlv bigpIHsKICAgICAgICAgbG9nKChyZXEuc3RhdHVzID09IDQwMSkgPyAiUEFTUzogNDAxIEF1dGhv cml6YXRpb24gcmVxdWlyZWQiIDogIkZBSUw6IExvYWRlZCIpOwogICAgICAgICB0ZXN0X2FzeW5j X2F1dGhfc3RvcmVkX3dpdGhfY3JlZGVudGlhbHMoKTsKLSAgICB9CisgICAgfTsKICAgICByZXEu b25lcnJvciA9IGZ1bmN0aW9uKCkgewogICAgICAgICBsb2coIlBBU1M6IFJlY2VpdmVkIGVycm9y IGV2ZW50LiIpOwogICAgICAgICB0ZXN0X2FzeW5jX2F1dGhfc3RvcmVkX3dpdGhfY3JlZGVudGlh bHMoKTsKLSAgICB9CisgICAgfTsKIH0KIAogZnVuY3Rpb24gdGVzdF9hc3luY19hdXRoX3N0b3Jl ZF93aXRoX2NyZWRlbnRpYWxzKCkKQEAgLTEwMCwxMSArNTgsMTEgQEAgZnVuY3Rpb24gdGVzdF9h c3luY19hdXRoX3N0b3JlZF93aXRoX2NyZWRlbnRpYWxzKCkKICAgICByZXEub25sb2FkID0gZnVu Y3Rpb24oKSB7CiAgICAgICAgIGxvZygocmVxLnN0YXR1cyA9PSA0MDEpID8gIlBBU1M6IDQwMSBB dXRob3JpemF0aW9uIHJlcXVpcmVkIiA6ICJGQUlMOiBMb2FkZWQiKTsKICAgICAgICAgdGVzdF9h c3luY19jb29raWVzKCk7Ci0gICAgfQorICAgIH07CiAgICAgcmVxLm9uZXJyb3IgPSBmdW5jdGlv bigpIHsKICAgICAgICAgbG9nKCJQQVNTOiBSZWNlaXZlZCBlcnJvciBldmVudC4iKTsKICAgICAg ICAgdGVzdF9hc3luY19jb29raWVzKCk7Ci0gICAgfQorICAgIH07CiB9CiAKIGZ1bmN0aW9uIHRl c3RfYXN5bmNfY29va2llcygpCkBAIC0xMTYsMjYgKzc0LDEwIEBAIGZ1bmN0aW9uIHRlc3RfYXN5 bmNfY29va2llcygpCiAgICAgcmVxLnNlbmQoKTsKICAgICByZXEub25sb2FkID0gZnVuY3Rpb24o KSB7CiAgICAgICAgIGxvZyhyZXEucmVzcG9uc2VUZXh0Lm1hdGNoKC9XS1wtY3Jvc3NcLW9yaWdp bi8pID8gIkZBSUwiIDogIlBBU1MiKTsKLSAgICAgICAgdGVzdF9zeW5jX2F1dGhfZXhwbGljaXQo KTsKLSAgICB9CisgICAgICAgIHRlc3RfYXN5bmNfYXV0aF9leHBsaWNpdCgpOworICAgIH07CiB9 CiAKLWZ1bmN0aW9uIHRlc3Rfc3luY19hdXRoX2V4cGxpY2l0KCkKLXsKLSAgICBsb2coIkNyb3Nz LW9yaWdpbiBYTUxIdHRwUmVxdWVzdCAoc3luYyksIHRlc3RpbmcgYXV0aG9yaXphdGlvbiB3aXRo IGV4cGxpY2l0bHkgcHJvdmlkZWQgY3JlZGVudGlhbHMgdGhhdCBzaG91bGQgYmUgaWdub3JlZC4i KTsKLSAgICAKLSAgICB2YXIgcmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0OwotICAgIHJlcS5vcGVu KCJHRVQiLCAiaHR0cDovL2xvY2FsaG9zdDo4MDAwL3htbGh0dHByZXF1ZXN0L3Jlc291cmNlcy9j cm9zcy1vcmlnaW4tbm8tYXV0aG9yaXphdGlvbi5waHAiLCBmYWxzZSwgInRlc3QiLCAidGVzdCIp OwotICAgIHRyeSB7Ci0gICAgICAgIHJlcS5zZW5kKCk7Ci0gICAgICAgIGxvZygocmVxLnN0YXR1 cyA9PSA0MDEpID8gIlBBU1M6IDQwMSBBdXRob3JpemF0aW9uIHJlcXVpcmVkIiA6ICJGQUlMOiBM b2FkZWQiKTsKLSAgICB9IGNhdGNoIChleCkgewotICAgICAgICBsb2coIlBBU1M6IEdvdCBhbiBl eGNlcHRpb24uICIgKyBleCk7Ci0gICAgfQotICAgIHRlc3RfYXN5bmNfYXV0aF9leHBsaWNpdCgp OwotfQotCi0KIGZ1bmN0aW9uIHRlc3RfYXN5bmNfYXV0aF9leHBsaWNpdCgpCiB7CiAgICAgbG9n KCJDcm9zcy1vcmlnaW4gWE1MSHR0cFJlcXVlc3QgKGFzeW5jKSwgdGVzdGluZyBhdXRob3JpemF0 aW9uIHdpdGggZXhwbGljaXRseSBwcm92aWRlZCBjcmVkZW50aWFscyB0aGF0IHNob3VsZCBiZSBp Z25vcmVkLiIpOwpAQCAtMTQ4LDEzICs5MCwxMyBAQCBmdW5jdGlvbiB0ZXN0X2FzeW5jX2F1dGhf ZXhwbGljaXQoKQogICAgICAgICBsb2coIkRPTkUiKTsKICAgICAgICAgaWYgKHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlcikKICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlm eURvbmUoKTsKLSAgICB9CisgICAgfTsKICAgICByZXEub25lcnJvciA9IGZ1bmN0aW9uKCkgewog ICAgICAgICBsb2coIlBBU1M6IFJlY2VpdmVkIGVycm9yIGV2ZW50LiIpOwogICAgICAgICBsb2co IkRPTkUiKTsKICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKICAgICAg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKLSAgICB9CisgICAgfTsK IH0KIAogaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikK 120361 2011-12-22 12:15:24 -0800 2011-12-22 21:59:03 -0800 Patch bug-72154-20111222151522.patch text/plain 6077 jarred U3VidmVyc2lvbiBSZXZpc2lvbjogMTAzNTY0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzYyYWQwMGQ5ZmE5OGIy NjlmZGY2NzgxZDRlZDlkNWEyNDcwMDY0MS4uZDIxNmE2ZTlmOTI2Y2U0YjdmMzU5ZjU5YzNlMTRk NjYyOWY1N2M1MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDExLTEyLTIyICBKYXJy ZWQgTmljaG9sbHMgIDxqYXJyZWRAc2VuY2hhLmNvbT4KKworICAgICAgICBTeW5jaHJvbm91cyBY SFIgaW4gd2luZG93IGNvbnRleHQgc2hvdWxkIG5vdCBzdXBwb3J0IG5ldyBYSFIgcmVzcG9uc2VU eXBlcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzIx NTQKKworICAgICAgICBQZXIgdGhlIGxhdGVzdCBXM0MgZWRpdG9yIGRyYWZ0OiBodHRwOi8vZHZj cy53My5vcmcvaGcveGhyL3Jhdy1maWxlL3RpcC9PdmVydmlldy5odG1sCisgICAgICAgIEluIGEg d2luZG93IGNvbnRleHQsIHN5bmNocm9ub3VzIFhIUiByZXF1ZXN0cyBzaG91bGQgbm90IHN1cHBv cnQgc2V0dGluZyBhIHJlc3BvbnNlVHlwZS4KKyAgICAgICAgcmVzcG9uc2VUeXBlIGNhbiBiZSBz ZXQgYmVmb3JlIG9yIGRpcmVjdGx5IGFmdGVyIGEgY2FsbCB0byBvcGVuKCksIGJ1dCBzaG91bGQg dGhyb3cgYW4gSW52YWxpZEFjY2Vzc0Vycm9yCisgICAgICAgIHdoZW4gdXNlZCBpbiBjb21iaW5h dGlvbiB3aXRoIGEgc3luY2hyb25vdXMgcmVxdWVzdC4KKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUZXN0czogZmFzdC94bWxodHRwcmVxdWVzdC94bWxo dHRwcmVxdWVzdC1yZXNwb25zZXR5cGUtc3luYy1yZXF1ZXN0Lmh0bWwKKworICAgICAgICAqIHht bC9YTUxIdHRwUmVxdWVzdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpYTUxIdHRwUmVxdWVzdDo6 c2V0UmVzcG9uc2VUeXBlKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTEh0dHBSZXF1ZXN0OjpvcGVu KToKKwogMjAxMS0xMi0yMiAgQW5kZXJzIENhcmxzc29uICA8YW5kZXJzY2FAYXBwbGUuY29tPgog CiAgICAgICAgIFJlbW92ZSBkaWRTdGFydFJ1YmJlckJhbmQgYW5kIGRpZENvbXBsZXRlUnViYmVy QmFuZCBjYWxsYmFja3MKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3htbC9YTUxIdHRwUmVx dWVzdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS94bWwvWE1MSHR0cFJlcXVlc3QuY3BwCmluZGV4IGMy YjU4MjkzMTJkZTA1MWUyZTEwZDEwYWEzNzZjMjYyZjJjMmNlZDUuLjFhZTIwODhlMGNkYjQxODFh N2E4OWUzMTQwY2RhMDcxYzExMzEzNTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3htbC9Y TUxIdHRwUmVxdWVzdC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUveG1sL1hNTEh0dHBSZXF1ZXN0 LmNwcApAQCAtMjgzLDExICsyODMsMTYgQEAgQXJyYXlCdWZmZXIqIFhNTEh0dHBSZXF1ZXN0Ojpy ZXNwb25zZUFycmF5QnVmZmVyKEV4Y2VwdGlvbkNvZGUmIGVjKQogCiB2b2lkIFhNTEh0dHBSZXF1 ZXN0OjpzZXRSZXNwb25zZVR5cGUoY29uc3QgU3RyaW5nJiByZXNwb25zZVR5cGUsIEV4Y2VwdGlv bkNvZGUmIGVjKQogewotICAgIGlmIChtX3N0YXRlICE9IE9QRU5FRCB8fCBtX2xvYWRlcikgewor ICAgIGlmIChtX3N0YXRlID4gT1BFTkVEIHx8IG1fbG9hZGVyKSB7CiAgICAgICAgIGVjID0gSU5W QUxJRF9TVEFURV9FUlI7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAKKyAgICBpZiAoIW1fYXN5 bmMgJiYgc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLT5pc0RvY3VtZW50KCkpIHsKKyAgICAgICAg ZWMgPSBJTlZBTElEX0FDQ0VTU19FUlI7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKICAgICBp ZiAocmVzcG9uc2VUeXBlID09ICIiKQogICAgICAgICBtX3Jlc3BvbnNlVHlwZUNvZGUgPSBSZXNw b25zZVR5cGVEZWZhdWx0OwogICAgIGVsc2UgaWYgKHJlc3BvbnNlVHlwZSA9PSAidGV4dCIpCkBA IC00MTUsNyArNDIwLDYgQEAgdm9pZCBYTUxIdHRwUmVxdWVzdDo6b3Blbihjb25zdCBTdHJpbmcm IG1ldGhvZCwgY29uc3QgS1VSTCYgdXJsLCBib29sIGFzeW5jLCBFeGMKICAgICBTdGF0ZSBwcmV2 aW91c1N0YXRlID0gbV9zdGF0ZTsKICAgICBtX3N0YXRlID0gVU5TRU5UOwogICAgIG1fZXJyb3Ig PSBmYWxzZTsKLSAgICBtX3Jlc3BvbnNlVHlwZUNvZGUgPSBSZXNwb25zZVR5cGVEZWZhdWx0Owog ICAgIG1fdXBsb2FkQ29tcGxldGUgPSBmYWxzZTsKIAogICAgIC8vIGNsZWFyIHN0dWZmIGZyb20g cG9zc2libGUgcHJldmlvdXMgbG9hZApAQCAtNDQwLDYgKzQ0NCwxMyBAQCB2b2lkIFhNTEh0dHBS ZXF1ZXN0OjpvcGVuKGNvbnN0IFN0cmluZyYgbWV0aG9kLCBjb25zdCBLVVJMJiB1cmwsIGJvb2wg YXN5bmMsIEV4YwogICAgICAgICByZXR1cm47CiAgICAgfQogCisgICAgLy8gU3luY2hyb25vdXMg cmVxdWVzdHMgZnJvbSBhIHdpbmRvdyBjb250ZXh0IHNob3VsZCBub3QgYmUgYWJsZSB0byB1c2Ug cmVzcG9uc2VUeXBlIHBlciBXM0Mgc3BlYy4KKyAgICBpZiAoIWFzeW5jICYmIHNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQoKS0+aXNEb2N1bWVudCgpCisgICAgICAgICYmIG1fcmVzcG9uc2VUeXBlQ29k ZSAhPSBSZXNwb25zZVR5cGVEZWZhdWx0KSB7CisgICAgICAgIGVjID0gSU5WQUxJRF9BQ0NFU1Nf RVJSOworICAgICAgICByZXR1cm47CisgICAgfQorCiAgICAgbV9tZXRob2QgPSB1cHBlcmNhc2VL bm93bkhUVFBNZXRob2QobWV0aG9kKTsKIAogICAgIG1fdXJsID0gdXJsOwpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDY1N2M2 ZjY4MDNlMmZmNzA5ZTI2YTU2NmJjNjk2M2FiNzY2OWJlZGYuLjViOTM5NzQ2OTY2Y2VhMTYxYTE1 NWFmM2MxZmM3MGJiMWE3YTc5NDggMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZwor KysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxMS0xMi0yMiAg SmFycmVkIE5pY2hvbGxzICA8amFycmVkQHNlbmNoYS5jb20+CisKKyAgICAgICAgU3luY2hyb25v dXMgWEhSIGluIHdpbmRvdyBjb250ZXh0IHNob3VsZCBub3Qgc3VwcG9ydCBuZXcgWEhSIHJlc3Bv bnNlVHlwZXMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTcyMTU0CisKKyAgICAgICAgTmV3IHRlc3RzIHRoYXQgdmFsaWRhdGUgc3luY2hyb25vdXMgWEhS IHJlcXVlc3RzIGNhbm5vdCB1c2UgcmVzcG9uc2VUeXBlLCBhbmQKKyAgICAgICAgYWxzbyB2YWxp ZGF0ZSB0aGF0IHJlc3BvbnNlVHlwZSBjYW4gYmUgc2V0IGJlZm9yZSBhIGNhbGwgdG8gb3Blbigp LgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogZmFz dC94bWxodHRwcmVxdWVzdC94bWxodHRwcmVxdWVzdC1yZXNwb25zZXR5cGUtc3luYy1yZXF1ZXN0 LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC94bWxodHRwcmVxdWVzdC94bWxo dHRwcmVxdWVzdC1yZXNwb25zZXR5cGUtc3luYy1yZXF1ZXN0Lmh0bWw6IEFkZGVkLgorCiAyMDEx LTEyLTIyICBSeW9zdWtlIE5pd2EgIDxybml3YUB3ZWJraXQub3JnPgogCiAgICAgICAgIENocm9t aXVtIFNWRyByZWJhc2VsaW5lcy4gQWxzbyBvcHRpbWl6ZSByZXN1bHRzIGZvciB0aG9zZSB0ZXN0 cy4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJl cXVlc3QtcmVzcG9uc2V0eXBlLXN5bmMtcmVxdWVzdC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0 cy9mYXN0L3htbGh0dHByZXF1ZXN0L3htbGh0dHByZXF1ZXN0LXJlc3BvbnNldHlwZS1zeW5jLXJl cXVlc3QtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjA5MjJiOGEzZjJmNTkwYjIxOWFiMjZiMWM5 Mjk2ZmEzM2FhYTJhNzgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3htbGh0 dHByZXF1ZXN0L3htbGh0dHByZXF1ZXN0LXJlc3BvbnNldHlwZS1zeW5jLXJlcXVlc3QtZXhwZWN0 ZWQudHh0CkBAIC0wLDAgKzEsMTIgQEAKK1RoaXMgdGVzdHMgdGhhdCB0aGUgWE1MSHR0cFJlcXVl c3QgcmVzcG9uc2VUeXBlIGF0dHJpYnV0ZSBpcyBub3QgdXNhYmxlIHdpdGggc3luY2hyb25vdXMg cmVxdWVzdHMuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIg bWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCit4aHIub3BlbignR0VU Jywgd2luZG93LmxvY2F0aW9uLCBmYWxzZSk7CitQQVNTIHhoci5vcGVuKCdHRVQnLCB3aW5kb3cu bG9jYXRpb24sIGZhbHNlKTsgdGhyZXcgZXhjZXB0aW9uIEVycm9yOiBJTlZBTElEX0FDQ0VTU19F UlI6IERPTSBFeGNlcHRpb24gMTUuCitQQVNTIHhoci5yZXNwb25zZVR5cGUgPSAnZG9jdW1lbnQn OyB0aHJldyBleGNlcHRpb24gRXJyb3I6IElOVkFMSURfQUNDRVNTX0VSUjogRE9NIEV4Y2VwdGlv biAxNS4KK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQor CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3htbGh0dHByZXF1ZXN0L3htbGh0dHByZXF1 ZXN0LXJlc3BvbnNldHlwZS1zeW5jLXJlcXVlc3QuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QveG1s aHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3QtcmVzcG9uc2V0eXBlLXN5bmMtcmVxdWVzdC5odG1s Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLjdmNjdkMjM1OWE5MjY5MTUxNDEzYjNiNTE4OTNlODEzYzZhMGM5OWYKLS0t IC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3htbGh0dHByZXF1ZXN0L3htbGh0dHBy ZXF1ZXN0LXJlc3BvbnNldHlwZS1zeW5jLXJlcXVlc3QuaHRtbApAQCAtMCwwICsxLDI5IEBACis8 IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+CisgICAgPHNjcmlwdCBzcmM9Ii4uL2pzL3Jl c291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+CisgICAgPHNjcmlwdD4KKyAgICAgICAg ZGVzY3JpcHRpb24oJ1RoaXMgdGVzdHMgdGhhdCB0aGUgWE1MSHR0cFJlcXVlc3QgcmVzcG9uc2VU eXBlIGF0dHJpYnV0ZSBpcyBub3QgdXNhYmxlIHdpdGggc3luY2hyb25vdXMgcmVxdWVzdHMuJyk7 CisgICAgICAgIHZhciB4aHI7CisKKyAgICAgICAgLy8gU3luY2hyb25vdXMgb3BlbigpIHdpdGgg bm8gcmVzcG9uc2VUeXBlIHNldC4KKyAgICAgICAgeGhyID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7 CisgICAgICAgIGV2YWxBbmRMb2coInhoci5vcGVuKCdHRVQnLCB3aW5kb3cubG9jYXRpb24sIGZh bHNlKTsiKTsKKworICAgICAgICAvLyBTeW5jaHJvbm91cyBvcGVuKCkgd2l0aCBhIHJlc3BvbnNl VHlwZSBzZXQuCisgICAgICAgIHhociA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgICAgICB4 aHIucmVzcG9uc2VUeXBlID0gJ2RvY3VtZW50JzsKKyAgICAgICAgc2hvdWxkVGhyb3coInhoci5v cGVuKCdHRVQnLCB3aW5kb3cubG9jYXRpb24sIGZhbHNlKTsiKTsKKworICAgICAgICAvLyBTeW5j aHJvbm91cyBvcGVuKCkgd2l0aCBhIHN1YnNlcXVlbnQgcmVzcG9uc2VUeXBlIHNldCBhdHRlbXB0 LgorICAgICAgICB4aHIgPSBuZXcgWE1MSHR0cFJlcXVlc3QoKTsKKyAgICAgICAgeGhyLm9wZW4o J0dFVCcsIHdpbmRvdy5sb2NhdGlvbiwgZmFsc2UpOworICAgICAgICBzaG91bGRUaHJvdygieGhy LnJlc3BvbnNlVHlwZSA9ICdkb2N1bWVudCc7Iik7CisgICAgPC9zY3JpcHQ+CisgICAgPHNjcmlw dCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9oZWFk PgorPGJvZHk+CisgICAgPGRpdiBpZD0iZGVzY3JpcHRpb24iPjwvZGl2PgorICAgIDxkaXYgaWQ9 ImNvbnNvbGUiPjwvZGl2PgorPC9ib2R5PgorPC9odG1sPgo= 120434 2011-12-22 21:59:10 -0800 2011-12-23 04:47:18 -0800 Patch bug-72154-20111223005908.patch text/plain 8477 jarred U3VidmVyc2lvbiBSZXZpc2lvbjogMTAzNjAzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDllMzE1YWQwMDkzODMz MzliZTAwYWRiYjVjZWQ2MzdiOTQwZTExMi4uOWMxYmY3ODBkYzM2MTRjMWJkNTZjMjc1OGJiNjNh YmFlZWQ1YjA2ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDExLTEyLTIyICBKYXJy ZWQgTmljaG9sbHMgIDxqYXJyZWRAc2VuY2hhLmNvbT4KKworICAgICAgICBTeW5jaHJvbm91cyBY SFIgaW4gd2luZG93IGNvbnRleHQgc2hvdWxkIG5vdCBzdXBwb3J0IG5ldyBYSFIgcmVzcG9uc2VU eXBlcyBmb3IgSFRUUChTKSByZXF1ZXN0cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9NzIxNTQKKworICAgICAgICBQZXIgdGhlIGxhdGVzdCBXM0MgZWRp dG9yIGRyYWZ0OiBodHRwOi8vZHZjcy53My5vcmcvaGcveGhyL3Jhdy1maWxlL3RpcC9PdmVydmll dy5odG1sCisgICAgICAgIFRoaXMgaXMgYSBzcGVjLW1hbmRhdGVkIGF0dGVtcHQgdG8gdGh3YXJ0 IGFuZCBvdGhlcndpc2UgZGlzY291cmFnZSB0aGUgdXNlIG9mIHN5bmNocm9ub3VzIFhIUgorICAg ICAgICBpbiB0aGUgd2luZG93IGNvbnRleHQgYnkgZGVsaWJlcmF0ZWx5IG5vdCBleHBvc2luZyBu ZXdlciBmdW5jdGlvbmFsaXR5LiBIZXJlIHdlIGFyZSBkaXNhYmxpbmcKKyAgICAgICAgdGhlIHVz ZSBvZiByZXNwb25zZVR5cGUgaW4gc3luY2hyb25vdXMgSFRUUChTKSBYSFIgcmVxdWVzdHMgZnJv bSB0aGUgd2luZG93IGNvbnRleHQuCisKKyAgICAgICAgV2hlbiBhIHVzZXIgYXR0ZW1wdHMgdGhp cyBhY3Rpb24sIGFuIEludmFsaWRBY2Nlc3NFcnJvciBleGNlcHRpb24gaXMgdGhyb3duIGFuZCBh IG1lc3NhZ2UgaXMKKyAgICAgICAgcHJpbnRlZCB0byB0aGUgY29uc29sZSB0byBmdXJ0aGVyIGV4 cGxhaW4uCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg VGVzdHM6IGZhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3QtcmVzcG9uc2V0eXBlLXN5 bmMtcmVxdWVzdC5odG1sCisKKyAgICAgICAgKiB4bWwvWE1MSHR0cFJlcXVlc3QuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6cmVwb3J0VW5zYWZlVXNhZ2UpOiBIb2lzdGVkIHJlcG9ydFVuc2FmZVVz YWdlIHVwIHNvIGl0IGlzIGRlZmluZWQgZWFybGllcgorICAgICAgICBhbmQgdGh1cyByZWZlcmVu Y2VhYmxlIGJ5IHNldFJlc3BvbnNlVHlwZSgpLgorICAgICAgICAoV2ViQ29yZTo6WE1MSHR0cFJl cXVlc3Q6OnNldFJlc3BvbnNlVHlwZSk6CisKIDIwMTEtMTItMjIgIENocmlzIE1hcnJpbiAgPGNt YXJyaW5AYXBwbGUuY29tPgogCiAgICAgICAgIENyYXNoIGFuZCBpbmNvcnJlY3QgYmVoYXZpb3Ig d2hlbiBzd2l0Y2hpbmcgYmV0d2VlbiBoYXJkd2FyZSBhbmQgc29mdHdhcmUgQ1NTIGZpbHRlcnMK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3htbC9YTUxIdHRwUmVxdWVzdC5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS94bWwvWE1MSHR0cFJlcXVlc3QuY3BwCmluZGV4IGMyYjU4MjkzMTJkZTA1MWUy ZTEwZDEwYWEzNzZjMjYyZjJjMmNlZDUuLmQ3NGZlMjFhMDUwODU5MjJjMDAzODI0YzM2NTc2ODU4 Y2NkYTI0YTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3htbC9YTUxIdHRwUmVxdWVzdC5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUveG1sL1hNTEh0dHBSZXF1ZXN0LmNwcApAQCAtMTQzLDYg KzE0MywxNSBAQCBzdGF0aWMgY29uc3QgWE1MSHR0cFJlcXVlc3RTdGF0aWNEYXRhKiBpbml0aWFs aXplWE1MSHR0cFJlcXVlc3RTdGF0aWNEYXRhKCkKICAgICByZXR1cm4gZHVtbXk7CiB9CiAKK3N0 YXRpYyB2b2lkIHJlcG9ydFVuc2FmZVVzYWdlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRl eHQsIGNvbnN0IFN0cmluZyYgbWVzc2FnZSkKK3sKKyAgICBpZiAoIWNvbnRleHQpCisgICAgICAg IHJldHVybjsKKyAgICAvLyBGSVhNRTogSXQncyBub3QgZ29vZCB0byByZXBvcnQgdGhlIGJhZCB1 c2FnZSB3aXRob3V0IGluZGljYXRpbmcgd2hhdCBzb3VyY2UgbGluZSBpdCBjYW1lIGZyb20uCisg ICAgLy8gV2Ugc2hvdWxkIHBhc3MgYWRkaXRpb25hbCBwYXJhbWV0ZXJzIHNvIHdlIGNhbiB0ZWxs IHRoZSBjb25zb2xlIHdoZXJlIHRoZSBtaXN0YWtlIG9jY3VycmVkLgorICAgIGNvbnRleHQtPmFk ZENvbnNvbGVNZXNzYWdlKEpTTWVzc2FnZVNvdXJjZSwgTG9nTWVzc2FnZVR5cGUsIEVycm9yTWVz c2FnZUxldmVsLCBtZXNzYWdlKTsKK30KKwogUGFzc1JlZlB0cjxYTUxIdHRwUmVxdWVzdD4gWE1M SHR0cFJlcXVlc3Q6OmNyZWF0ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBQYXNz UmVmUHRyPFNlY3VyaXR5T3JpZ2luPiBzZWN1cml0eU9yaWdpbikKIHsKICAgICByZXR1cm4gYWRv cHRSZWYobmV3IFhNTEh0dHBSZXF1ZXN0KGNvbnRleHQsIHNlY3VyaXR5T3JpZ2luKSk7CkBAIC0y ODgsNiArMjk3LDE2IEBAIHZvaWQgWE1MSHR0cFJlcXVlc3Q6OnNldFJlc3BvbnNlVHlwZShjb25z dCBTdHJpbmcmIHJlc3BvbnNlVHlwZSwgRXhjZXB0aW9uQ29kZSYKICAgICAgICAgcmV0dXJuOwog ICAgIH0KIAorICAgIC8vIE5ld2VyIGZ1bmN0aW9uYWxpdHkgaXMgbm90IGF2YWlsYWJsZSB0byBz eW5jaHJvbm91cyByZXF1ZXN0cyBpbiB3aW5kb3cgY29udGV4dHMsIGFzIGEgc3BlYy1tYW5kYXRl ZCAKKyAgICAvLyBhdHRlbXB0IHRvIGRpc2NvdXJhZ2Ugc3luY2hyb25vdXMgWEhSIHVzZS4gcmVz cG9uc2VUeXBlIGlzIG9uZSBzdWNoIGZ1bmN0aW9uLgorICAgIC8vIFdlJ2xsIG9ubHkgZGlzYWJs ZSB0aGlzIGZ1bmN0aW9uYWxpdHkgZm9yIEhUVFAoUykgcmVxdWVzdHMgc2luY2Ugc3luYyByZXF1 ZXN0cyBmb3IgbG9jYWwgcHJvdG9jb2xzCisgICAgLy8gc3VjaCBhcyBmaWxlOiBhbmQgZGF0YTog c3RpbGwgbWFrZSBzZW5zZSB0byBhbGxvdy4KKyAgICBpZiAoIW1fYXN5bmMgJiYgc2NyaXB0RXhl Y3V0aW9uQ29udGV4dCgpLT5pc0RvY3VtZW50KCkgJiYgbV91cmwucHJvdG9jb2xJc0luSFRUUEZh bWlseSgpKSB7CisgICAgICAgIHJlcG9ydFVuc2FmZVVzYWdlKHNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQoKSwgIlhNTEh0dHBSZXF1ZXN0IGNhbm5vdCBzZXQgcmVzcG9uc2VUeXBlIGZvciBzeW5jaHJv bm91cyBIVFRQKFMpIHJlcXVlc3RzIG1hZGUgZnJvbSB0aGUgd2luZG93IGNvbnRleHQuIik7Cisg ICAgICAgIGVjID0gSU5WQUxJRF9BQ0NFU1NfRVJSOworICAgICAgICByZXR1cm47CisgICAgfQor CiAgICAgaWYgKHJlc3BvbnNlVHlwZSA9PSAiIikKICAgICAgICAgbV9yZXNwb25zZVR5cGVDb2Rl ID0gUmVzcG9uc2VUeXBlRGVmYXVsdDsKICAgICBlbHNlIGlmIChyZXNwb25zZVR5cGUgPT0gInRl eHQiKQpAQCAtODE3LDE1ICs4MzYsNiBAQCB2b2lkIFhNTEh0dHBSZXF1ZXN0OjpvdmVycmlkZU1p bWVUeXBlKGNvbnN0IFN0cmluZyYgb3ZlcnJpZGUpCiAgICAgbV9taW1lVHlwZU92ZXJyaWRlID0g b3ZlcnJpZGU7CiB9CiAKLXN0YXRpYyB2b2lkIHJlcG9ydFVuc2FmZVVzYWdlKFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqIGNvbnRleHQsIGNvbnN0IFN0cmluZyYgbWVzc2FnZSkKLXsKLSAgICBpZiAo IWNvbnRleHQpCi0gICAgICAgIHJldHVybjsKLSAgICAvLyBGSVhNRTogSXQncyBub3QgZ29vZCB0 byByZXBvcnQgdGhlIGJhZCB1c2FnZSB3aXRob3V0IGluZGljYXRpbmcgd2hhdCBzb3VyY2UgbGlu ZSBpdCBjYW1lIGZyb20uCi0gICAgLy8gV2Ugc2hvdWxkIHBhc3MgYWRkaXRpb25hbCBwYXJhbWV0 ZXJzIHNvIHdlIGNhbiB0ZWxsIHRoZSBjb25zb2xlIHdoZXJlIHRoZSBtaXN0YWtlIG9jY3VycmVk LgotICAgIGNvbnRleHQtPmFkZENvbnNvbGVNZXNzYWdlKEpTTWVzc2FnZVNvdXJjZSwgTG9nTWVz c2FnZVR5cGUsIEVycm9yTWVzc2FnZUxldmVsLCBtZXNzYWdlKTsKLX0KLQogdm9pZCBYTUxIdHRw UmVxdWVzdDo6c2V0UmVxdWVzdEhlYWRlcihjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUsIGNvbnN0 IFN0cmluZyYgdmFsdWUsIEV4Y2VwdGlvbkNvZGUmIGVjKQogewogICAgIGlmIChtX3N0YXRlICE9 IE9QRU5FRCB8fCBtX2xvYWRlcikgewpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9n IGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IGRhMmQzN2U3NDFjYTI4M2JjZDE2NzMxMjI2 Nzc4Yjk5YmFmNzdmYTUuLmFiODA0NjYzNzMxMGYxNzcyMTVmZTUyMjFmNzJiN2QzZjZiMDEwNmQg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxMS0xMi0yMiAgSmFycmVkIE5pY2hvbGxzICA8amFy cmVkQHNlbmNoYS5jb20+CisKKyAgICAgICAgU3luY2hyb25vdXMgWEhSIGluIHdpbmRvdyBjb250 ZXh0IHNob3VsZCBub3Qgc3VwcG9ydCBuZXcgWEhSIHJlc3BvbnNlVHlwZXMgZm9yIEhUVFAoUykg cmVxdWVzdHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTcyMTU0CisKKyAgICAgICAgTmV3IHRlc3RzIHRoYXQgdmFsaWRhdGUgc3luY2hyb25vdXMgSFRU UChTKSBYSFIgcmVxdWVzdHMgZnJvbSB0aGUgd2luZG93IGNvbnRleHQKKyAgICAgICAgY2Fubm90 IHVzZSByZXNwb25zZVR5cGUsIHdoaWxlIG90aGVyIHByb3RvY29scyBjb250aW51ZSB0byB3b3Jr LgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogZmFz dC94bWxodHRwcmVxdWVzdC94bWxodHRwcmVxdWVzdC1yZXNwb25zZXR5cGUtc3luYy1yZXF1ZXN0 LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC94bWxodHRwcmVxdWVzdC94bWxo dHRwcmVxdWVzdC1yZXNwb25zZXR5cGUtc3luYy1yZXF1ZXN0Lmh0bWw6IEFkZGVkLgorCiAyMDEx LTEyLTIyICBSeW9zdWtlIE5pd2EgIDxybml3YUB3ZWJraXQub3JnPgogCiAgICAgICAgIENocm9t aXVtIHJlYmFzZWxpbmVzIGFmdGVyIHIxMDM1OTUgYW5kIHIxMDM0NzcuCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9mYXN0L3htbGh0dHByZXF1ZXN0L3htbGh0dHByZXF1ZXN0LXJlc3BvbnNldHlw ZS1zeW5jLXJlcXVlc3QtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC94bWxodHRwcmVx dWVzdC94bWxodHRwcmVxdWVzdC1yZXNwb25zZXR5cGUtc3luYy1yZXF1ZXN0LWV4cGVjdGVkLnR4 dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi5iYmI0OWQ5YjMyYTI3ODg5YzY1NjZjMzM1YTJlZTllMDljYmMwZjZjCi0t LSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC94bWxodHRwcmVxdWVzdC94bWxodHRw cmVxdWVzdC1yZXNwb25zZXR5cGUtc3luYy1yZXF1ZXN0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsx LDE4IEBACitDT05TT0xFIE1FU1NBR0U6IGxpbmUgMTogWE1MSHR0cFJlcXVlc3QgY2Fubm90IHNl dCByZXNwb25zZVR5cGUgZm9yIHN5bmNocm9ub3VzIEhUVFAoUykgcmVxdWVzdHMgbWFkZSBmcm9t IHRoZSB3aW5kb3cgY29udGV4dC4KK0NPTlNPTEUgTUVTU0FHRTogbGluZSAxOiBYTUxIdHRwUmVx dWVzdCBjYW5ub3Qgc2V0IHJlc3BvbnNlVHlwZSBmb3Igc3luY2hyb25vdXMgSFRUUChTKSByZXF1 ZXN0cyBtYWRlIGZyb20gdGhlIHdpbmRvdyBjb250ZXh0LgorVGhpcyB0ZXN0cyB0aGF0IHRoZSBY TUxIdHRwUmVxdWVzdCByZXNwb25zZVR5cGUgYXR0cmlidXRlIGlzIG5vdCBtb2RpZmlhYmxlIGZv ciBzeW5jaHJvbm91cyBIVFRQKFMpIHJlcXVlc3RzLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBz ZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVU RSIuCisKKworUEFTUyB4aHIucmVzcG9uc2VUeXBlID0gJ2RvY3VtZW50JzsgdGhyZXcgZXhjZXB0 aW9uIEVycm9yOiBJTlZBTElEX0FDQ0VTU19FUlI6IERPTSBFeGNlcHRpb24gMTUuCitQQVNTIHho ci5yZXNwb25zZVR5cGUgPSAnZG9jdW1lbnQnOyB0aHJldyBleGNlcHRpb24gRXJyb3I6IElOVkFM SURfQUNDRVNTX0VSUjogRE9NIEV4Y2VwdGlvbiAxNS4KK1BBU1Mgd2luZG93LmxvY2F0aW9uLnBy b3RvY29sIGlzICJmaWxlOiIKK3hoci5yZXNwb25zZVR5cGUgPSAnZG9jdW1lbnQnOworUEFTUyB4 aHIucmVzcG9uc2VUeXBlIGlzICJkb2N1bWVudCIKK3hoci5yZXNwb25zZVR5cGUgPSAnZG9jdW1l bnQnOworUEFTUyB4aHIucmVzcG9uc2VUeXBlIGlzICJkb2N1bWVudCIKK1BBU1Mgc3VjY2Vzc2Z1 bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L3htbGh0dHByZXF1ZXN0L3htbGh0dHByZXF1ZXN0LXJlc3BvbnNldHlwZS1zeW5j LXJlcXVlc3QuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJl cXVlc3QtcmVzcG9uc2V0eXBlLXN5bmMtcmVxdWVzdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjFkZDlmZTkz ZDcwZGRiY2MxNmYxMWI1M2YyNWI5ZGJlNWM2NjgzOGUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L3htbGh0dHByZXF1ZXN0L3htbGh0dHByZXF1ZXN0LXJlc3BvbnNldHlwZS1z eW5jLXJlcXVlc3QuaHRtbApAQCAtMCwwICsxLDQzIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1s PgorPGhlYWQ+CisgICAgPHNjcmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5q cyI+PC9zY3JpcHQ+CisgICAgPHNjcmlwdD4KKyAgICAgICAgZGVzY3JpcHRpb24oJ1RoaXMgdGVz dHMgdGhhdCB0aGUgWE1MSHR0cFJlcXVlc3QgcmVzcG9uc2VUeXBlIGF0dHJpYnV0ZSBpcyBub3Qg bW9kaWZpYWJsZSBmb3Igc3luY2hyb25vdXMgSFRUUChTKSByZXF1ZXN0cy4nKTsKKyAgICAgICAg dmFyIHhocjsKKworICAgICAgICAvLyBIVFRQCisgICAgICAgIHhociA9IG5ldyBYTUxIdHRwUmVx dWVzdCgpOworICAgICAgICB4aHIub3BlbignR0VUJywgJ2h0dHA6Ly9teWRvbWFpbi8nLCBmYWxz ZSk7CisgICAgICAgIHNob3VsZFRocm93KCJ4aHIucmVzcG9uc2VUeXBlID0gJ2RvY3VtZW50Jzsi KTsKKworICAgICAgICAvLyBIVFRQUworICAgICAgICB4aHIgPSBuZXcgWE1MSHR0cFJlcXVlc3Qo KTsKKyAgICAgICAgeGhyLm9wZW4oJ0dFVCcsICdodHRwczovL215c2VjdXJlZG9tYWluLycsIGZh bHNlKTsKKyAgICAgICAgc2hvdWxkVGhyb3coInhoci5yZXNwb25zZVR5cGUgPSAnZG9jdW1lbnQn OyIpOworCisgICAgICAgIC8vIEZJTEUKKyAgICAgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCd3 aW5kb3cubG9jYXRpb24ucHJvdG9jb2wnLCAnZmlsZTonKTsKKyAgICAgICAgeGhyID0gbmV3IFhN TEh0dHBSZXF1ZXN0KCk7CisgICAgICAgIHhoci5vcGVuKCdHRVQnLCB3aW5kb3cubG9jYXRpb24u aHJlZiwgZmFsc2UpOworICAgICAgICBldmFsQW5kTG9nKCJ4aHIucmVzcG9uc2VUeXBlID0gJ2Rv Y3VtZW50JzsiKTsKKyAgICAgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCd4aHIucmVzcG9uc2VU eXBlJywgJ2RvY3VtZW50Jyk7CisKKyAgICAgICAgLy8gREFUQQorICAgICAgICB2YXIgZGF0YVVy bCA9ICdkYXRhOnRleHQvaHRtbDtjaGFyc2V0PXV0Zi04LCUzQyUyMURPQ1RZUEUlMjAnICsKKyAg ICAgICAgICAgICAgICAgICAgICAnaHRtbCUzRSUwRCUwQSUzQ2h0bWwlMjBsYW5nJTNEJTIyZW4l MjIlM0UlMEQlMEElM0NoZWFkJScgKworICAgICAgICAgICAgICAgICAgICAgICczRSUzQ3RpdGxl JTNFRW1iZWRkZWQlMjBXaW5kb3clM0MlMkZ0aXRsZSUzRSUzQyUyRmhlYWQlJyArCisgICAgICAg ICAgICAgICAgICAgICAgJzNFJTBEJTBBJTNDYm9keSUzRSUzQ2gxJTNFNDIlM0MlMkZoMSUzRSUz QyUyRmJvZHklM0UlMEEnICsKKyAgICAgICAgICAgICAgICAgICAgICAnJTNDJTJGaHRtbCUzRSUw QSUwRCUwQSc7CisgICAgICAgIHhociA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgICAgICB4 aHIub3BlbignR0VUJywgZGF0YVVybCwgZmFsc2UpOworICAgICAgICBldmFsQW5kTG9nKCJ4aHIu cmVzcG9uc2VUeXBlID0gJ2RvY3VtZW50JzsiKTsKKyAgICAgICAgc2hvdWxkQmVFcXVhbFRvU3Ry aW5nKCd4aHIucmVzcG9uc2VUeXBlJywgJ2RvY3VtZW50Jyk7CisgICAgPC9zY3JpcHQ+CisgICAg PHNjcmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0Pgor PC9oZWFkPgorPGJvZHk+CisgICAgPGRpdiBpZD0iZGVzY3JpcHRpb24iPjwvZGl2PgorICAgIDxk aXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPC9ib2R5PgorPC9odG1sPgo= 120458 2011-12-23 04:47:25 -0800 2011-12-23 08:36:27 -0800 Patch bug-72154-20111223074723.patch text/plain 10805 jarred U3VidmVyc2lvbiBSZXZpc2lvbjogMTAzNjIxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMTQwNzhlMTQ5YzQxNjZl MDk2NjgwZjUyMTdkZmI0YjU4ZGQ0MWMxYy4uNmRhNGUzZTMwYTVkMjJiMjFiYTQwYWI1YjA2ZmY2 NGJmZmI0NjRlYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM0IEBACisyMDExLTEyLTIzICBKYXJy ZWQgTmljaG9sbHMgIDxqYXJyZWRAc2VuY2hhLmNvbT4KKworICAgICAgICBTeW5jaHJvbm91cyBY SFIgaW4gd2luZG93IGNvbnRleHQgc2hvdWxkIG5vdCBzdXBwb3J0IG5ldyBYSFIgcmVzcG9uc2VU eXBlcyBmb3IgSFRUUChTKSByZXF1ZXN0cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9NzIxNTQKKworICAgICAgICBQZXIgdGhlIGxhdGVzdCBXM0MgZWRp dG9yIGRyYWZ0OiBodHRwOi8vZHZjcy53My5vcmcvaGcveGhyL3Jhdy1maWxlL3RpcC9PdmVydmll dy5odG1sCisgICAgICAgIFRoaXMgaXMgYSBzcGVjLW1hbmRhdGVkIGF0dGVtcHQgdG8gdGh3YXJ0 IGFuZCBvdGhlcndpc2UgZGlzY291cmFnZSB0aGUgdXNlIG9mIHN5bmNocm9ub3VzIFhIUgorICAg ICAgICBpbiB0aGUgd2luZG93IGNvbnRleHQgYnkgZGVsaWJlcmF0ZWx5IG5vdCBleHBvc2luZyBu ZXdlciBmdW5jdGlvbmFsaXR5LiBIZXJlIHdlIGFyZSBkaXNhYmxpbmcKKyAgICAgICAgdGhlIHVz ZSBvZiByZXNwb25zZVR5cGUgaW4gc3luY2hyb25vdXMgSFRUUChTKSBYSFIgcmVxdWVzdHMgZnJv bSB0aGUgd2luZG93IGNvbnRleHQuCisKKyAgICAgICAgV2hlbiBhIHVzZXIgYXR0ZW1wdHMgdGhp cyBhY3Rpb24sIGFuIEludmFsaWRBY2Nlc3NFcnJvciBleGNlcHRpb24gaXMgdGhyb3duIGFuZCBh IG1lc3NhZ2UgaXMKKyAgICAgICAgcHJpbnRlZCB0byB0aGUgY29uc29sZSB0byBmdXJ0aGVyIGV4 cGxhaW4uCisKKyAgICAgICAgUmVuYW1lZCByZXBvcnRVbnNhZmVVc2FnZSB0byBhIG1vcmUgZ2Vu ZXJpYyBuYW1lLCBhbmQgaG9pc3RlZCBpdCB1cCBzbyBpdCB3b3VsZCBiZSBkZWZpbmVkCisgICAg ICAgIGVhcmxpZXIgYW5kIHRodXMgcmVmZXJlbmNlYWJsZSBieSBzZXRSZXNwb25zZVR5cGUuCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGVzdDogZmFz dC94bWxodHRwcmVxdWVzdC94bWxodHRwcmVxdWVzdC1yZXNwb25zZXR5cGUtc3luYy1yZXF1ZXN0 Lmh0bWwKKworICAgICAgICAqIHhtbC9YTUxIdHRwUmVxdWVzdC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpsb2dDb25zb2xlRXJyb3IpOgorICAgICAgICByZXBvcnRVbnNhZmVVc2FnZSAtPiBsb2dD b25zb2xlRXJyb3IKKyAgICAgICAgKFdlYkNvcmU6OlhNTEh0dHBSZXF1ZXN0OjpzZXRSZXNwb25z ZVR5cGUpOgorICAgICAgICAoV2ViQ29yZTo6WE1MSHR0cFJlcXVlc3Q6OnNldFJlcXVlc3RIZWFk ZXIpOgorICAgICAgICByZXBvcnRVbnNhZmVVc2FnZSAtPiBsb2dDb25zb2xlRXJyb3IKKyAgICAg ICAgKFdlYkNvcmU6OlhNTEh0dHBSZXF1ZXN0OjpnZXRSZXNwb25zZUhlYWRlcik6CisgICAgICAg IHJlcG9ydFVuc2FmZVVzYWdlIC0+IGxvZ0NvbnNvbGVFcnJvcgorICAgICAgICAoV2ViQ29yZTo6 WE1MSHR0cFJlcXVlc3Q6OmRpZEZhaWwpOgorICAgICAgICByZXBvcnRVbnNhZmVVc2FnZSAtPiBs b2dDb25zb2xlRXJyb3IKKwogMjAxMS0xMi0yMyAgS2FybCBLb3NjaGVyICA8c3VwZXJzYXRAY2hy b21pdW0ub3JnPgogCiAgICAgICAgIEdpdmUgZW1iZWRkZXJzIGEgY2hhbmNlIHRvIGhhbmRsZSBw b3N0TWVzc2FnZSBjYWxscwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUveG1sL1hNTEh0dHBS ZXF1ZXN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3htbC9YTUxIdHRwUmVxdWVzdC5jcHAKaW5kZXgg YzJiNTgyOTMxMmRlMDUxZTJlMTBkMTBhYTM3NmMyNjJmMmMyY2VkNS4uMjdiNDE5MTAxMWQ3M2Fh ZTVjNWZlZmUyZDllODc2MDhhNGQyYjNkYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUveG1s L1hNTEh0dHBSZXF1ZXN0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS94bWwvWE1MSHR0cFJlcXVl c3QuY3BwCkBAIC0xNDMsNiArMTQzLDE1IEBAIHN0YXRpYyBjb25zdCBYTUxIdHRwUmVxdWVzdFN0 YXRpY0RhdGEqIGluaXRpYWxpemVYTUxIdHRwUmVxdWVzdFN0YXRpY0RhdGEoKQogICAgIHJldHVy biBkdW1teTsKIH0KIAorc3RhdGljIHZvaWQgbG9nQ29uc29sZUVycm9yKFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQqIGNvbnRleHQsIGNvbnN0IFN0cmluZyYgbWVzc2FnZSkKK3sKKyAgICBpZiAoIWNv bnRleHQpCisgICAgICAgIHJldHVybjsKKyAgICAvLyBGSVhNRTogSXQncyBub3QgZ29vZCB0byBy ZXBvcnQgdGhlIGJhZCB1c2FnZSB3aXRob3V0IGluZGljYXRpbmcgd2hhdCBzb3VyY2UgbGluZSBp dCBjYW1lIGZyb20uCisgICAgLy8gV2Ugc2hvdWxkIHBhc3MgYWRkaXRpb25hbCBwYXJhbWV0ZXJz IHNvIHdlIGNhbiB0ZWxsIHRoZSBjb25zb2xlIHdoZXJlIHRoZSBtaXN0YWtlIG9jY3VycmVkLgor ICAgIGNvbnRleHQtPmFkZENvbnNvbGVNZXNzYWdlKEpTTWVzc2FnZVNvdXJjZSwgTG9nTWVzc2Fn ZVR5cGUsIEVycm9yTWVzc2FnZUxldmVsLCBtZXNzYWdlKTsKK30KKwogUGFzc1JlZlB0cjxYTUxI dHRwUmVxdWVzdD4gWE1MSHR0cFJlcXVlc3Q6OmNyZWF0ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiBjb250ZXh0LCBQYXNzUmVmUHRyPFNlY3VyaXR5T3JpZ2luPiBzZWN1cml0eU9yaWdpbikKIHsK ICAgICByZXR1cm4gYWRvcHRSZWYobmV3IFhNTEh0dHBSZXF1ZXN0KGNvbnRleHQsIHNlY3VyaXR5 T3JpZ2luKSk7CkBAIC0yODgsNiArMjk3LDE2IEBAIHZvaWQgWE1MSHR0cFJlcXVlc3Q6OnNldFJl c3BvbnNlVHlwZShjb25zdCBTdHJpbmcmIHJlc3BvbnNlVHlwZSwgRXhjZXB0aW9uQ29kZSYKICAg ICAgICAgcmV0dXJuOwogICAgIH0KIAorICAgIC8vIE5ld2VyIGZ1bmN0aW9uYWxpdHkgaXMgbm90 IGF2YWlsYWJsZSB0byBzeW5jaHJvbm91cyByZXF1ZXN0cyBpbiB3aW5kb3cgY29udGV4dHMsIGFz IGEgc3BlYy1tYW5kYXRlZCAKKyAgICAvLyBhdHRlbXB0IHRvIGRpc2NvdXJhZ2Ugc3luY2hyb25v dXMgWEhSIHVzZS4gcmVzcG9uc2VUeXBlIGlzIG9uZSBzdWNoIHBpZWNlIG9mIGZ1bmN0aW9uYWxp dHkuCisgICAgLy8gV2UnbGwgb25seSBkaXNhYmxlIHRoaXMgZnVuY3Rpb25hbGl0eSBmb3IgSFRU UChTKSByZXF1ZXN0cyBzaW5jZSBzeW5jIHJlcXVlc3RzIGZvciBsb2NhbCBwcm90b2NvbHMKKyAg ICAvLyBzdWNoIGFzIGZpbGU6IGFuZCBkYXRhOiBzdGlsbCBtYWtlIHNlbnNlIHRvIGFsbG93Lgor ICAgIGlmICghbV9hc3luYyAmJiBzY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmlzRG9jdW1lbnQo KSAmJiBtX3VybC5wcm90b2NvbElzSW5IVFRQRmFtaWx5KCkpIHsKKyAgICAgICAgbG9nQ29uc29s ZUVycm9yKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKSwgIlhNTEh0dHBSZXF1ZXN0LnJlc3BvbnNl VHlwZSBjYW5ub3QgYmUgY2hhbmdlZCBmb3Igc3luY2hyb25vdXMgSFRUUChTKSByZXF1ZXN0cyBt YWRlIGZyb20gdGhlIHdpbmRvdyBjb250ZXh0LiIpOworICAgICAgICBlYyA9IElOVkFMSURfQUND RVNTX0VSUjsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwogICAgIGlmIChyZXNwb25zZVR5cGUg PT0gIiIpCiAgICAgICAgIG1fcmVzcG9uc2VUeXBlQ29kZSA9IFJlc3BvbnNlVHlwZURlZmF1bHQ7 CiAgICAgZWxzZSBpZiAocmVzcG9uc2VUeXBlID09ICJ0ZXh0IikKQEAgLTgxNywxNSArODM2LDYg QEAgdm9pZCBYTUxIdHRwUmVxdWVzdDo6b3ZlcnJpZGVNaW1lVHlwZShjb25zdCBTdHJpbmcmIG92 ZXJyaWRlKQogICAgIG1fbWltZVR5cGVPdmVycmlkZSA9IG92ZXJyaWRlOwogfQogCi1zdGF0aWMg dm9pZCByZXBvcnRVbnNhZmVVc2FnZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBj b25zdCBTdHJpbmcmIG1lc3NhZ2UpCi17Ci0gICAgaWYgKCFjb250ZXh0KQotICAgICAgICByZXR1 cm47Ci0gICAgLy8gRklYTUU6IEl0J3Mgbm90IGdvb2QgdG8gcmVwb3J0IHRoZSBiYWQgdXNhZ2Ug d2l0aG91dCBpbmRpY2F0aW5nIHdoYXQgc291cmNlIGxpbmUgaXQgY2FtZSBmcm9tLgotICAgIC8v IFdlIHNob3VsZCBwYXNzIGFkZGl0aW9uYWwgcGFyYW1ldGVycyBzbyB3ZSBjYW4gdGVsbCB0aGUg Y29uc29sZSB3aGVyZSB0aGUgbWlzdGFrZSBvY2N1cnJlZC4KLSAgICBjb250ZXh0LT5hZGRDb25z b2xlTWVzc2FnZShKU01lc3NhZ2VTb3VyY2UsIExvZ01lc3NhZ2VUeXBlLCBFcnJvck1lc3NhZ2VM ZXZlbCwgbWVzc2FnZSk7Ci19Ci0KIHZvaWQgWE1MSHR0cFJlcXVlc3Q6OnNldFJlcXVlc3RIZWFk ZXIoY29uc3QgQXRvbWljU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIHZhbHVlLCBFeGNlcHRp b25Db2RlJiBlYykKIHsKICAgICBpZiAobV9zdGF0ZSAhPSBPUEVORUQgfHwgbV9sb2FkZXIpIHsK QEAgLTg0NSw3ICs4NTUsNyBAQCB2b2lkIFhNTEh0dHBSZXF1ZXN0OjpzZXRSZXF1ZXN0SGVhZGVy KGNvbnN0IEF0b21pY1N0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiB2YQogCiAgICAgLy8gQSBw cml2aWxlZ2VkIHNjcmlwdCAoZS5nLiBhIERhc2hib2FyZCB3aWRnZXQpIGNhbiBzZXQgYW55IGhl YWRlcnMuCiAgICAgaWYgKCFzZWN1cml0eU9yaWdpbigpLT5jYW5Mb2FkTG9jYWxSZXNvdXJjZXMo KSAmJiAhaXNBbGxvd2VkSFRUUEhlYWRlcihuYW1lKSkgewotICAgICAgICByZXBvcnRVbnNhZmVV c2FnZShzY3JpcHRFeGVjdXRpb25Db250ZXh0KCksICJSZWZ1c2VkIHRvIHNldCB1bnNhZmUgaGVh ZGVyIFwiIiArIG5hbWUgKyAiXCIiKTsKKyAgICAgICAgbG9nQ29uc29sZUVycm9yKHNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQoKSwgIlJlZnVzZWQgdG8gc2V0IHVuc2FmZSBoZWFkZXIgXCIiICsgbmFt ZSArICJcIiIpOwogICAgICAgICByZXR1cm47CiAgICAgfQogCkBAIC05MDcsMTIgKzkxNywxMiBA QCBTdHJpbmcgWE1MSHR0cFJlcXVlc3Q6OmdldFJlc3BvbnNlSGVhZGVyKGNvbnN0IEF0b21pY1N0 cmluZyYgbmFtZSwgRXhjZXB0aW9uQ29kZQogCiAgICAgLy8gU2VlIGNvbW1lbnQgaW4gZ2V0QWxs UmVzcG9uc2VIZWFkZXJzIGFib3ZlLgogICAgIGlmIChpc1NldENvb2tpZUhlYWRlcihuYW1lKSAm JiAhc2VjdXJpdHlPcmlnaW4oKS0+Y2FuTG9hZExvY2FsUmVzb3VyY2VzKCkpIHsKLSAgICAgICAg cmVwb3J0VW5zYWZlVXNhZ2Uoc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLCAiUmVmdXNlZCB0byBn ZXQgdW5zYWZlIGhlYWRlciBcIiIgKyBuYW1lICsgIlwiIik7CisgICAgICAgIGxvZ0NvbnNvbGVF cnJvcihzY3JpcHRFeGVjdXRpb25Db250ZXh0KCksICJSZWZ1c2VkIHRvIGdldCB1bnNhZmUgaGVh ZGVyIFwiIiArIG5hbWUgKyAiXCIiKTsKICAgICAgICAgcmV0dXJuIFN0cmluZygpOwogICAgIH0K IAogICAgIGlmICghbV9zYW1lT3JpZ2luUmVxdWVzdCAmJiAhaXNPbkFjY2Vzc0NvbnRyb2xSZXNw b25zZUhlYWRlcldoaXRlbGlzdChuYW1lKSkgewotICAgICAgICByZXBvcnRVbnNhZmVVc2FnZShz Y3JpcHRFeGVjdXRpb25Db250ZXh0KCksICJSZWZ1c2VkIHRvIGdldCB1bnNhZmUgaGVhZGVyIFwi IiArIG5hbWUgKyAiXCIiKTsKKyAgICAgICAgbG9nQ29uc29sZUVycm9yKHNjcmlwdEV4ZWN1dGlv bkNvbnRleHQoKSwgIlJlZnVzZWQgdG8gZ2V0IHVuc2FmZSBoZWFkZXIgXCIiICsgbmFtZSArICJc IiIpOwogICAgICAgICByZXR1cm4gU3RyaW5nKCk7CiAgICAgfQogICAgIHJldHVybiBtX3Jlc3Bv bnNlLmh0dHBIZWFkZXJGaWVsZChuYW1lKTsKQEAgLTk4Miw3ICs5OTIsNyBAQCB2b2lkIFhNTEh0 dHBSZXF1ZXN0OjpkaWRGYWlsKGNvbnN0IFJlc291cmNlRXJyb3ImIGVycm9yKQogCiAgICAgLy8g TmV0d29yayBmYWlsdXJlcyBhcmUgYWxyZWFkeSByZXBvcnRlZCB0byBXZWIgSW5zcGVjdG9yIGJ5 IFJlc291cmNlTG9hZGVyLgogICAgIGlmIChlcnJvci5kb21haW4oKSA9PSBlcnJvckRvbWFpbldl YktpdEludGVybmFsKQotICAgICAgICByZXBvcnRVbnNhZmVVc2FnZShzY3JpcHRFeGVjdXRpb25D b250ZXh0KCksICJYTUxIdHRwUmVxdWVzdCBjYW5ub3QgbG9hZCAiICsgZXJyb3IuZmFpbGluZ1VS TCgpICsgIi4gIiArIGVycm9yLmxvY2FsaXplZERlc2NyaXB0aW9uKCkpOworICAgICAgICBsb2dD b25zb2xlRXJyb3Ioc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpLCAiWE1MSHR0cFJlcXVlc3QgY2Fu bm90IGxvYWQgIiArIGVycm9yLmZhaWxpbmdVUkwoKSArICIuICIgKyBlcnJvci5sb2NhbGl6ZWRE ZXNjcmlwdGlvbigpKTsKIAogICAgIG1fZXhjZXB0aW9uQ29kZSA9IFhNTEh0dHBSZXF1ZXN0RXhj ZXB0aW9uOjpORVRXT1JLX0VSUjsKICAgICBuZXR3b3JrRXJyb3IoKTsKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA1M2UxYWJi MzM3YWExMzBhYTdmZmI5ODY0MzA2ZmI0ZTQwZTg1NDY3Li40MTVlMjQ0YTkwMzQwZDc0NjZiNWI3 MmVlMzI4NTk1ODQxZDU5ZTNmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysr IGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTEtMTItMjMgIEph cnJlZCBOaWNob2xscyAgPGphcnJlZEBzZW5jaGEuY29tPgorCisgICAgICAgIFN5bmNocm9ub3Vz IFhIUiBpbiB3aW5kb3cgY29udGV4dCBzaG91bGQgbm90IHN1cHBvcnQgbmV3IFhIUiByZXNwb25z ZVR5cGVzIGZvciBIVFRQKFMpIHJlcXVlc3RzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD03MjE1NAorCisgICAgICAgIE5ldyB0ZXN0cyB0aGF0IHZhbGlk YXRlIHN5bmNocm9ub3VzIEhUVFAoUykgWEhSIHJlcXVlc3RzIGZyb20gdGhlIHdpbmRvdyBjb250 ZXh0CisgICAgICAgIGNhbm5vdCB1c2UgcmVzcG9uc2VUeXBlLCB3aGlsZSBvdGhlciBwcm90b2Nv bHMgY29udGludWUgdG8gd29yay4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICAqIGZhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3QtcmVzcG9u c2V0eXBlLXN5bmMtcmVxdWVzdC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3Qv eG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3QtcmVzcG9uc2V0eXBlLXN5bmMtcmVxdWVzdC5o dG1sOiBBZGRlZC4KKwogMjAxMS0xMi0yMyAgTm9lbCBHb3Jkb24gIDxub2VsLmdvcmRvbkBnbWFp bC5jb20+CiAKICAgICAgICAgW2Nocm9taXVtXSBNQUM6IHNob3VsZCBwYXNzIENTUzMgZWxsaXB0 aWNhbCBncmFkaWVudCB0ZXN0cwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC94bWxodHRw cmVxdWVzdC94bWxodHRwcmVxdWVzdC1yZXNwb25zZXR5cGUtc3luYy1yZXF1ZXN0LWV4cGVjdGVk LnR4dCBiL0xheW91dFRlc3RzL2Zhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3QtcmVz cG9uc2V0eXBlLXN5bmMtcmVxdWVzdC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYjljMjM2YjI5 ZDNjMDhhZTM1MzRkMWYxMGM5ZGM2YTAyZGI0ODk4NAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3QtcmVzcG9uc2V0eXBlLXN5 bmMtcmVxdWVzdC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxOCBAQAorQ09OU09MRSBNRVNTQUdF OiBsaW5lIDE6IFhNTEh0dHBSZXF1ZXN0LnJlc3BvbnNlVHlwZSBjYW5ub3QgYmUgY2hhbmdlZCBm b3Igc3luY2hyb25vdXMgSFRUUChTKSByZXF1ZXN0cyBtYWRlIGZyb20gdGhlIHdpbmRvdyBjb250 ZXh0LgorQ09OU09MRSBNRVNTQUdFOiBsaW5lIDE6IFhNTEh0dHBSZXF1ZXN0LnJlc3BvbnNlVHlw ZSBjYW5ub3QgYmUgY2hhbmdlZCBmb3Igc3luY2hyb25vdXMgSFRUUChTKSByZXF1ZXN0cyBtYWRl IGZyb20gdGhlIHdpbmRvdyBjb250ZXh0LgorVGhpcyB0ZXN0cyB0aGF0IHRoZSBYTUxIdHRwUmVx dWVzdCByZXNwb25zZVR5cGUgYXR0cmlidXRlIGlzIG5vdCBtb2RpZmlhYmxlIGZvciBzeW5jaHJv bm91cyBIVFRQKFMpIHJlcXVlc3RzLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJp ZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKwor UEFTUyB4aHIucmVzcG9uc2VUeXBlID0gJ2RvY3VtZW50JzsgdGhyZXcgZXhjZXB0aW9uIEVycm9y OiBJTlZBTElEX0FDQ0VTU19FUlI6IERPTSBFeGNlcHRpb24gMTUuCitQQVNTIHhoci5yZXNwb25z ZVR5cGUgPSAnZG9jdW1lbnQnOyB0aHJldyBleGNlcHRpb24gRXJyb3I6IElOVkFMSURfQUNDRVNT X0VSUjogRE9NIEV4Y2VwdGlvbiAxNS4KK1BBU1Mgd2luZG93LmxvY2F0aW9uLnByb3RvY29sIGlz ICJmaWxlOiIKK3hoci5yZXNwb25zZVR5cGUgPSAnZG9jdW1lbnQnOworUEFTUyB4aHIucmVzcG9u c2VUeXBlIGlzICJkb2N1bWVudCIKK3hoci5yZXNwb25zZVR5cGUgPSAnZG9jdW1lbnQnOworUEFT UyB4aHIucmVzcG9uc2VUeXBlIGlzICJkb2N1bWVudCIKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2Vk IGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L3htbGh0dHByZXF1ZXN0L3htbGh0dHByZXF1ZXN0LXJlc3BvbnNldHlwZS1zeW5jLXJlcXVlc3Qu aHRtbCBiL0xheW91dFRlc3RzL2Zhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3QtcmVz cG9uc2V0eXBlLXN5bmMtcmVxdWVzdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjFkZDlmZTkzZDcwZGRiY2Mx NmYxMWI1M2YyNWI5ZGJlNWM2NjgzOGUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L3htbGh0dHByZXF1ZXN0L3htbGh0dHByZXF1ZXN0LXJlc3BvbnNldHlwZS1zeW5jLXJlcXVl c3QuaHRtbApAQCAtMCwwICsxLDQzIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+ CisgICAgPHNjcmlwdCBzcmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3Jp cHQ+CisgICAgPHNjcmlwdD4KKyAgICAgICAgZGVzY3JpcHRpb24oJ1RoaXMgdGVzdHMgdGhhdCB0 aGUgWE1MSHR0cFJlcXVlc3QgcmVzcG9uc2VUeXBlIGF0dHJpYnV0ZSBpcyBub3QgbW9kaWZpYWJs ZSBmb3Igc3luY2hyb25vdXMgSFRUUChTKSByZXF1ZXN0cy4nKTsKKyAgICAgICAgdmFyIHhocjsK KworICAgICAgICAvLyBIVFRQCisgICAgICAgIHhociA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOwor ICAgICAgICB4aHIub3BlbignR0VUJywgJ2h0dHA6Ly9teWRvbWFpbi8nLCBmYWxzZSk7CisgICAg ICAgIHNob3VsZFRocm93KCJ4aHIucmVzcG9uc2VUeXBlID0gJ2RvY3VtZW50JzsiKTsKKworICAg ICAgICAvLyBIVFRQUworICAgICAgICB4aHIgPSBuZXcgWE1MSHR0cFJlcXVlc3QoKTsKKyAgICAg ICAgeGhyLm9wZW4oJ0dFVCcsICdodHRwczovL215c2VjdXJlZG9tYWluLycsIGZhbHNlKTsKKyAg ICAgICAgc2hvdWxkVGhyb3coInhoci5yZXNwb25zZVR5cGUgPSAnZG9jdW1lbnQnOyIpOworCisg ICAgICAgIC8vIEZJTEUKKyAgICAgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCd3aW5kb3cubG9j YXRpb24ucHJvdG9jb2wnLCAnZmlsZTonKTsKKyAgICAgICAgeGhyID0gbmV3IFhNTEh0dHBSZXF1 ZXN0KCk7CisgICAgICAgIHhoci5vcGVuKCdHRVQnLCB3aW5kb3cubG9jYXRpb24uaHJlZiwgZmFs c2UpOworICAgICAgICBldmFsQW5kTG9nKCJ4aHIucmVzcG9uc2VUeXBlID0gJ2RvY3VtZW50Jzsi KTsKKyAgICAgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCd4aHIucmVzcG9uc2VUeXBlJywgJ2Rv Y3VtZW50Jyk7CisKKyAgICAgICAgLy8gREFUQQorICAgICAgICB2YXIgZGF0YVVybCA9ICdkYXRh OnRleHQvaHRtbDtjaGFyc2V0PXV0Zi04LCUzQyUyMURPQ1RZUEUlMjAnICsKKyAgICAgICAgICAg ICAgICAgICAgICAnaHRtbCUzRSUwRCUwQSUzQ2h0bWwlMjBsYW5nJTNEJTIyZW4lMjIlM0UlMEQl MEElM0NoZWFkJScgKworICAgICAgICAgICAgICAgICAgICAgICczRSUzQ3RpdGxlJTNFRW1iZWRk ZWQlMjBXaW5kb3clM0MlMkZ0aXRsZSUzRSUzQyUyRmhlYWQlJyArCisgICAgICAgICAgICAgICAg ICAgICAgJzNFJTBEJTBBJTNDYm9keSUzRSUzQ2gxJTNFNDIlM0MlMkZoMSUzRSUzQyUyRmJvZHkl M0UlMEEnICsKKyAgICAgICAgICAgICAgICAgICAgICAnJTNDJTJGaHRtbCUzRSUwQSUwRCUwQSc7 CisgICAgICAgIHhociA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOworICAgICAgICB4aHIub3Blbign R0VUJywgZGF0YVVybCwgZmFsc2UpOworICAgICAgICBldmFsQW5kTG9nKCJ4aHIucmVzcG9uc2VU eXBlID0gJ2RvY3VtZW50JzsiKTsKKyAgICAgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCd4aHIu cmVzcG9uc2VUeXBlJywgJ2RvY3VtZW50Jyk7CisgICAgPC9zY3JpcHQ+CisgICAgPHNjcmlwdCBz cmM9Ii4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9oZWFkPgor PGJvZHk+CisgICAgPGRpdiBpZD0iZGVzY3JpcHRpb24iPjwvZGl2PgorICAgIDxkaXYgaWQ9ImNv bnNvbGUiPjwvZGl2PgorPC9ib2R5PgorPC9odG1sPgo=