31875 2009-11-25 07:56:27 -0800 QWebView: Impossible to make XMLHttpRequest from locally stored HTML page 2013-06-25 02:23:17 -0700 1 1 1 Unclassified WebKit WebKit Qt 528+ (Nightly build) PC All RESOLVED DUPLICATE 117823 Qt P2 Major --- 1 juhana.koski hausmann abarth allan.jensen ap buisson carol hausmann kenneth kling koshuin laszlo.gombos rafael.lobo rich webkit.review.bot yael oldest_to_newest 166448 0 43848 juhana.koski 2009-11-25 07:56:27 -0800 Created attachment 43848 demonstrates the problem XMLHttpRequests from locally stored HTML file always fails in QWebView. Security restrictions are understandable when running JavaScript code inside QWebView component. But I think it should be possible somehow for developer to allow/whitelist some URLS where XMLHttpRequest can be established. This was possible in Qt 4.6.0 beta using WebSecurityOrigin::whiteListAccessFromOrigin() function but this function is removed from 4.6.0 Release candidate 1. Can similar functionality be restored to next Qt 4.6 release? Following example shows the problem. QWebView is created in following way: --- QWebView view; view.load(QUrl("qrc:/script/index.html")); view.show(); --- index.html has following script inside body tags: --- <script type="text/javascript"> var xmlhttp=new XMLHttpRequest() try { xmlhttp.open('get', 'http://api.flickr.com/services/rest/?method=flickr.test.echo&api_key=bd9cc5d539f02a3833dcde44ddfe9d5b') xmlhttp.onreadystatechange = httpCallBack; xmlhttp.send(null); } catch (e) { alert("An exception occurred in the script. Error name: " + e.name + ". Error message: " + e.message); } function httpCallBack() { if (xmlhttp.readyState == 4) { alert("state 4" + xmlhttp.responseText); } else { alert("state " + xmlhttp.readyState) } } </script> --- onreadystatechange/httpCallBack gets called with readyState 4. But responseText is empty and no actual HTTP request goes out. Qt version: 4.6.0 Release candidate 1 Reference discussion: http://discussion.forum.nokia.com/forum/showthread.php?t=186338 (full example attached) 171415 1 carol 2009-12-14 08:18:41 -0800 Working on this. Patch to come soon 173030 2 45124 carol 2009-12-17 21:03:37 -0800 Created attachment 45124 Proposed Patch This patch exposes in the Qt port the already existing WebCore whitelist API. Most of the patch is the test harness for this API. I suggest that tests that refer to QWebSecurityOrigin and are now included in tst_wqebpage be moved to tst_qwebsecurityorigin. 173242 3 45124 laszlo.gombos 2009-12-18 11:50:50 -0800 Comment on attachment 45124 Proposed Patch I think the need for this API is quite evident. Excellent patch. Looks good to me but I think we can do better documenting the testcase. Please create comments inside the code for the followings: - function runTest() in test.html. - class CannedResponseNetworkReply - why do we need this how does it work - explanation on why these tests can not be implemented as LayoutTests. You can maybe also get a better summary for this change/ChangeLog. r-, only because of the lack of documentation. 173469 4 45223 carol 2009-12-18 20:32:32 -0800 Created attachment 45223 Proposed Patch; Addressed Laszlo's concerns 173470 5 webkit.review.bot 2009-12-18 20:34:43 -0800 Attachment 45223 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 WebKit/qt/tests/qwebsecurityorigin/tst_qwebsecurityorigin.cpp:21: Found other header before WebCore config.h. Should be: config.h, primary header, blank line, and then alphabetically sorted. [build/include_order] [4] WebKit/qt/tests/qwebsecurityorigin/tst_qwebsecurityorigin.cpp:26: Alphabetical sorting problem. [build/include_order] [4] WebKit/qt/tests/qwebsecurityorigin/tst_qwebsecurityorigin.cpp:30: Should have a space between // and comment [whitespace/comments] [4] WebKit/qt/tests/qwebsecurityorigin/tst_qwebsecurityorigin.cpp:31: Should have a space between // and comment [whitespace/comments] [4] WebKit/qt/tests/qwebsecurityorigin/tst_qwebsecurityorigin.cpp:42: create_data is incorrectly named. Don't use underscores in your identifier names. [readability/naming] [4] WebKit/qt/tests/qwebsecurityorigin/tst_qwebsecurityorigin.cpp:44: whiteList_data is incorrectly named. Don't use underscores in your identifier names. [readability/naming] [4] WebKit/qt/tests/qwebsecurityorigin/tst_qwebsecurityorigin.cpp:251: Found header this file implements after other header. Should be: config.h, primary header, blank line, and then alphabetically sorted. [build/include_order] [4] WebKitTools/DumpRenderTree/qt/LayoutTestControllerQt.cpp:350: Missing space after , [whitespace/comma] [3] Total errors found: 8 173472 6 abarth 2009-12-18 20:52:36 -0800 The stylebot isn't that great at understanding Qt unit tests. Some of those warnings are real, but some are bogus. Can you fix the real ones and let me know the bogus ones so we can fix the stylebot? Thanks. 173509 7 laszlo.gombos 2009-12-19 04:25:36 -0800 Carol, comments looks good to me, thanks ! Can you also address the style issues as suggested by Adam ? 173819 8 45223 hausmann 2009-12-20 14:01:18 -0800 Comment on attachment 45223 Proposed Patch; Addressed Laszlo's concerns > /*! > + \since 4.7 > + Constructs a security origin for \a url. > +*/ > +QWebSecurityOrigin* QWebSecurityOrigin::create(const QUrl& url) > +{ > + return new QWebSecurityOrigin(new QWebSecurityOriginPrivate(SecurityOrigin::createFromString(url.toString()).get())); > +}; QWebSecurityOrigin is a class that is designed to be value based, so returning a pointer seems wrong to me. In addition the "create" pattern is not typically used in Qt APIs. > +*/ > +void QWebSecurityOrigin::addToWhiteList(const QUrl& url, bool includeSubDomains) > +{ > + SecurityOrigin::whiteListAccessFromOrigin(*d->origin.get(), url.scheme(), url.host(), includeSubDomains); > +} I think the boolean as second argument is not a good choice for the API, as it makes the caller code hard to read. See also http://doc.trolltech.com/qq/qq13-apis.html#thebooleanparametertrap for a more detailed explanation of this pattern. I think we sohuld discuss this API on the mailing list first ( see https://trac.webkit.org/wiki/QtWebKitAPI ) 174017 9 laszlo.gombos 2009-12-21 11:20:28 -0800 Commit http://trac.webkit.org/changeset/52444 probably regressed this patch - please take this commit into account. 175543 10 kenneth 2009-12-29 07:01:19 -0800 > a pointer seems wrong to me. In addition > the "create" pattern is not typically used in Qt APIs. We have createWindow and createPlugin in our Qt WebKit API's, though, but not on the class itself. 182225 11 hausmann 2010-01-19 07:15:20 -0800 We've had a long API discussion in the office here in Oslo today about this, and concluded the following proposal for an API: -- qwebsecurityorigin.h class QWebSecurityOrigin { ... class AccessEntry { public: AccessEntry(); AccessEntry(const QString& destination); ~AccessEntry(); QString domain() const { return m_domain; } void setDomain(const QString& domain) { m_domain = domain; } void setScheme(const QString& scheme) const { m_scheme = scheme; } QString scheme() const { return m_scheme; } void setAllowSubDomains(bool allow) { m_allowSubDomains = allow; } bool allowSubDomains() const { return m_allowSubDomains; } private: QString m_domain; QString m_scheme; bool m_allowSubDomains; struct Private; Private *d; }; ... static QList<QWebSecurityOrigin::AccessEntry> crossOriginAccessList(const QString& origin); static void setCrossOriginAccessList(const QString& origin, const QList<QWebSecurityOrigin::AcessEntry>& list); static clearCrossOriginAccessLists(); ... -- qwebsecurityorigin.cpp QWebSecurityOrigin::AccessEntry::AcessEntry() : m_allowSubDomains(false) , d(0) { } QWebSecurityOrigin::AccessEntry::AcessEntry(const QString& destination) : m_allowSubDomains(false) , d(0) { RefPtr<SecurityOrigin> dest = SecurityOrigin::createFromString(destination); m_domain = dest.host(); m_scheme = dest.protocol(); } QWebSecurityOrigin::AccessEntry::~AcessEntry() { delete d; } -- example use-cases QList<QWebSecurityOrigin::AccessEntry> accessList = QWebSecuritOrigin::crossOriginAccessList("wheatherwidget.com"); for (...) { QWebSecurityOrigin::AccessEntry entry; entry.setDomain("google.com"); entry.setAllowSubDomains(true); accessList.append(entry); } accessList.append(QWebSecurityOrigin::AccessEntry("https://google.com")); QWebSecurityOrigin::AccessEntry entry("https://google.com"); entry.setAllowSubDomains(true); accessList.append(entry); QWebSecurityOrigin::setCrossOriginAccessList("weatherwidget.com", accessList); QWebSecurityOrigin::clearCrossOriginAccessLists(); 182490 12 carol 2010-01-19 15:56:10 -0800 (In reply to comment #11) > We've had a long API discussion in the office here in Oslo today about this, > and concluded the following proposal for an API: > > > -- qwebsecurityorigin.h > > class QWebSecurityOrigin { > ... > > class AccessEntry { > public: > AccessEntry(); > AccessEntry(const QString& destination); > ~AccessEntry(); > > QString domain() const { return m_domain; } > void setDomain(const QString& domain) { m_domain = domain; } > > void setScheme(const QString& scheme) const { m_scheme = scheme; } > QString scheme() const { return m_scheme; } > > void setAllowSubDomains(bool allow) { m_allowSubDomains = allow; } > bool allowSubDomains() const { return m_allowSubDomains; } > > private: > QString m_domain; > QString m_scheme; > bool m_allowSubDomains; > struct Private; > Private *d; > }; > > ... > static QList<QWebSecurityOrigin::AccessEntry> crossOriginAccessList(const > QString& origin); > static void setCrossOriginAccessList(const QString& origin, const > QList<QWebSecurityOrigin::AcessEntry>& list); > static clearCrossOriginAccessLists(); > ... > > -- qwebsecurityorigin.cpp > > QWebSecurityOrigin::AccessEntry::AcessEntry() > : m_allowSubDomains(false) > , d(0) > { > } > > QWebSecurityOrigin::AccessEntry::AcessEntry(const QString& destination) > : m_allowSubDomains(false) > , d(0) > { > RefPtr<SecurityOrigin> dest = > SecurityOrigin::createFromString(destination); > m_domain = dest.host(); > m_scheme = dest.protocol(); > } > > QWebSecurityOrigin::AccessEntry::~AcessEntry() > { > delete d; > } > > -- example use-cases > > QList<QWebSecurityOrigin::AccessEntry> accessList = > QWebSecuritOrigin::crossOriginAccessList("wheatherwidget.com"); > > for (...) { > QWebSecurityOrigin::AccessEntry entry; > entry.setDomain("google.com"); > entry.setAllowSubDomains(true); > > accessList.append(entry); > } > > accessList.append(QWebSecurityOrigin::AccessEntry("https://google.com")); > > QWebSecurityOrigin::AccessEntry entry("https://google.com"); > entry.setAllowSubDomains(true); > accessList.append(entry); > > QWebSecurityOrigin::setCrossOriginAccessList("weatherwidget.com", accessList); > > QWebSecurityOrigin::clearCrossOriginAccessLists(); I hope you guys realize that this interface cannot be implemented (except in a hackish way) as a thin wrapper over existing WebCore functionality because webkit supports a write only API for whitelists. The WebCore/page/OriginAccessEntry and SecurityOrigin classes will need to be enriched with code implementing the supporting functionality for this API, or otherwise duplicate copies need to be kept for the lists associated with every origin until they are removed. Also, the crossOriginAccessList function involves returning by value a structure of significant complexity, which usually involves a lot of copying and reallocating memory, not a brilliant idea in my opinion, even when the list is usually small and the function is rarely called. I suggest changing the crossOriginAccessList function to return a smart pointer of some kind to the whiteList and adding a constructor to the AccessEntry that would construct it based on parts retrieved from the WebCore OriginAccessEntry: scheme, domain, allow subdomains. If we are to make changes to WebCore, I would argue for adding a port field to the access entry structure since the SecurityOrigin is also defined by the port in addition to the host and security. You realize that in your example with allowSubDomains=false www.google.com would not be included, as what is called domain, when allowSubDomains is false, really means virtual host at list for HTTP, that is why I am not sure how to call this field that has dual meaning. 183165 13 rich 2010-01-21 04:54:35 -0800 I had some discussions with torarne yesterday, suggesting that we extend the AccessEntry class slightly in order to support future extensions (eg. the ability to add both Allow and Deny rules, or rules about the allowed methods). It makes sense to consider the http://www.w3.org/TR/access-control/ specification when considering the naming policy as this is likely to be supported in other areas of webkit. Initially I'm just suggesting we have an enum specifying what kind of ACL rule the AccessEntry represents eg. enum AccessEntryPolicy { AllowAccess, DenyAccess } and a corresponding accessor. 185408 14 47601 hausmann 2010-01-28 03:15:50 -0800 Created attachment 47601 Initial patch of proposed API 185484 15 47601 abarth 2010-01-28 08:20:53 -0800 Comment on attachment 47601 Initial patch of proposed API This patch is really confusing. createIfNotExisting doesn't seem to be used for anything. Also, it's unclear why the names for things change in the Qt API. Shouldn't use the same names at least at the beginning? You might want to compare with how this works in the Chromium WebKit API because that's another place this functionality is exposed to clients. 185517 16 carol 2010-01-28 08:57:59 -0800 (In reply to comment #14) > Created an attachment (id=47601) [details] > Initial patch of proposed API QWebSecurityOrigin::setAccessListForOrigin does not do what the name leads me to believe, that is replace the current access list for that origin if any, with the one passed as argument. It merely adds to the existing list if that list already exists. In order to do that, a further extension of WebCore functionality is needed in order to wipe out the old list. Adam noticed correctly that there is a bug in the securityListForOrigin implementation, that is basically that the createIfNeeded flag is not checked before creating a new list, but that is a minor issue. With the risk of repeating my self, I cannot avoid noticing that the access list is returned by value from the QWebSecurityOrigin::originAcceessList() method which seems inefficient, I would prefer a smart pointer to a list. I will look at the Chromium implementation as Adam suggested, but given what support I see on the WebKit trunk, it can't be pretty unless they have a private version of page/SecurityOrigin. 185871 17 47717 hausmann 2010-01-29 07:55:09 -0800 Created attachment 47717 Updated patch with createIfNotExisting bug fixed 185872 18 hausmann 2010-01-29 07:58:48 -0800 (In reply to comment #15) > (From update of attachment 47601 [details]) > This patch is really confusing. createIfNotExisting doesn't seem to be used > for anything. Ooops, the use of it was missing in whiteListForOrigin(). The idea is to create the white list only if the caller wants that. > Also, it's unclear why the names for things change in the Qt API. Shouldn't > use the same names at least at the beginning? Scheme at least is a term that is used instead of protocol in the Qt APIs. The other names If host is a better name then I'm all in favour of using it. I just noticed the use of domain in the original static fuction in SecurityOrigin. > You might want to compare with how this works in the Chromium WebKit API > because that's another place this functionality is exposed to clients. The chromium API seems to map the SecurityOrigin function very closely. We would like to have something slightly more elaborate than just the one function to add an entry to the list. 185874 19 hausmann 2010-01-29 08:02:58 -0800 (In reply to comment #16) > (In reply to comment #14) > > Created an attachment (id=47601) [details] [details] > > Initial patch of proposed API > > QWebSecurityOrigin::setAccessListForOrigin does not do what the name leads me > to believe, that is replace the current access list for that origin if any, > with the one passed as argument. It merely adds to the existing list if that > list already exists. Before it adds it clears the existing list, so it is a replacement as the name suggests. > In order to do that, a further extension of WebCore functionality is needed in > order to wipe out the old list. That's not needed, it's a wtf::Vector and we all clear() on it already. Am I missing something there? > Adam noticed correctly that there is a bug in the securityListForOrigin > implementation, that is basically that the createIfNeeded flag is not checked > before creating a new list, but that is a minor issue. Right :) > With the risk of repeating my self, I cannot avoid noticing that the access > list is returned by value from the QWebSecurityOrigin::originAcceessList() > method which seems inefficient, I would prefer a smart pointer to a list. > I will look at the Chromium implementation as Adam suggested, but given what > support I see on the WebKit trunk, it can't be pretty unless they have a > private version of page/SecurityOrigin. I understand that a smart pointer referencing the internal data structure is more efficient, but that's not how we try to design the Qt APIs. In this particular case I'm less worried about performance given that setting up the white lists is I would assume a one-in-a-while task that may mostly happen at the startup of say the web runtime? 185876 20 carol 2010-01-29 08:24:25 -0800 (In reply to comment #19) > (In reply to comment #16) > > (In reply to comment #14) > > > Created an attachment (id=47601) [details] [details] [details] > > > Initial patch of proposed API > > > > QWebSecurityOrigin::setAccessListForOrigin does not do what the name leads me > > to believe, that is replace the current access list for that origin if any, > > with the one passed as argument. It merely adds to the existing list if that > > list already exists. > > Before it adds it clears the existing list, so it is a replacement as the name > suggests. > > > In order to do that, a further extension of WebCore functionality is needed in > > order to wipe out the old list. > > That's not needed, it's a wtf::Vector and we all clear() on it already. Am I > missing something there? Sorry, I missed the call to clear. > I understand that a smart pointer referencing the internal data structure is > more efficient, but that's not how we try to design the Qt APIs. In this > particular case I'm less worried about performance given that setting up the > white lists is I would assume a one-in-a-while task that may mostly happen at > the startup of say the web runtime? Actually in the current use case this needs to happen before the first page from every special origin is loaded (which may be multiple times per web runtime initialization, as for example each local app and javascript library may be in its own security domain). This observation leads me to spot another potential issue in the current implementation: When setAccessListForOrigin is called with an empty list, the list is cleared, but the list itself remains. If one implementation caches the process and loads multiple apps in it, this may lead to leaking of some memory. This is likely a small issue, but I thought I'd mention it. 185906 21 abarth 2010-01-29 10:16:29 -0800 Note that host and domain are different concepts in SecurityOrigin. Host refers to host name of the server in question. Domain refers to the value of document.domain, which might be set to something wacky. In this case, you're interested in the "host" concept. 804326 22 buisson 2013-01-10 06:41:41 -0800 (In reply to comment #1) > Working on this. Patch to come soon Has the patch been published? Why the bug is still opened? 903243 23 allan.jensen 2013-06-25 02:23:17 -0700 *** This bug has been marked as a duplicate of bug 117823 *** 43848 2009-11-25 07:56:27 -0800 2009-11-25 07:56:27 -0800 demonstrates the problem WebViewTest.zip application/empty 2836 juhana.koski UEsDBAoAAAAAALiJeTsAAAAAAAAAAAAAAAASAAAAV2ViVmlld1Rlc3QvZGVidWcvUEsDBBQAAAAI AHllWjv6CdrKrwAAAAQBAAAUAAAAV2ViVmlld1Rlc3QvbWFpbi5jcHBNjjELwjAQhfdA/kNIl1Sk 3bUITs4d1EEcYhrMQZrUNG0K4n830RZ6w/F47+PeZWCEHhpJqtqfBijrY9dpENyDNQeMsiWmLQcT wDQ2FIqugqq+yscFZIg0RmA8SSRLgrun2BKhuCObqMfbPcfojRGJs+4hnP3RBOX7GZjPkjGu2Uuy 0JY3rD47zejLiV3ZCwedL+NrciqUbzXN8zXfKxvY4jjpBxcLCzlJ8XM/GH0BUEsDBBQAAAAIALCJ eTuKiOUJ3QAAALMBAAAaAAAAV2ViVmlld1Rlc3QvbWFpbndpbmRvdy5jcHB1kMFqwzAQRO8C/cOS XqSQ9AMUyKX01h58CDmr1tZe6irGWsWEkn57FcfCorS6SOzMPHb0QL7uokNYfVryI3l3Gh/blRRS vKbBcRoYs7xVdSTXIMO6twN61mCkgHSqwjNLm7sSSXkc4UAlR0vxleXtPiDH/kCKWwp6J8X19wLf BX2JOuyQMRFy5HwiB2Wubq1v8Pmc1lHVdMEaF0D1nxdvW9wcYSSuW1C43fOlR6U1zNnaBoQ705iX FI22waeJMX9JbjcgD9aHzjIWHbPjbUD7scuF3m3s2PytXqeWP1BLAwQUAAAACAAMYFo7VLDUHcwA AABhAQAAGAAAAFdlYlZpZXdUZXN0L21haW53aW5kb3cuaF2QTQuCQBCG74L/YcBLebGzfUBfUEGJ kHiMbXe0ARslVztE/fbWLBLnMvDsMy8z61DCChPYz7eHeHtYBfFpY1uOQcTYo4YTy6xSCJNwL4hj YpXfZ80LiyuWhZAIEcHDtsCUzERZwl8c29azcfscfCiqc0YSOqm/kPAULHbr5dG2Wsdv8V8chDGp FDW4hbgha5jCaDhurVdHa5gJueUapUb1zalzUiAvglNc12Z6EH4auPjzqRYav3ZEvt9Z0a2ouekj OsiKEvC83qe9AVBLAwQUAAAACAAMYFo7piXOCRoBAACOAgAAGQAAAFdlYlZpZXdUZXN0L21haW53 aW5kb3cudWltksFuwyAMhu+T9g6IBxitVPVEOEy79jCtUs+IugkSgQjMkrz9CAlpOuUU+/P/244F j5r8gg/a2YqePg5UvL8RrowMQVyktjdt767nbCZTrdf3GpBkUNHvp4gSK1uo6JZMDsI77zrwOC6C GlwL6MelTLgHhXNI+CAOnA0lG6dsLFkajY04HxKbw4U3oOsGxWkqLPHcmK2dOStL7K7U532vGg2s WwX02tYvV1jQXsP/ZwEbP6UvN2lLynbVV+fMVp1GrmjfcctpMSiw6KUpcN/ygxJj2IwJT5Ad+arJ kWMjRxfxCx4yGiShkyr9eUXPlLTS1zq9luOx+Do9tLJ7RKswvSORTvMKJo2H4KJXEGaLctZCrmbA WdTp8wdQSwMECgAAAAAAKGBaOwAAAAAAAAAAAAAAABQAAABXZWJWaWV3VGVzdC9yZWxlYXNlL1BL AwQKAAAAAAA8iHk7AAAAAAAAAAAAAAAAFQAAAFdlYlZpZXdUZXN0L3Jlc291cmNlL1BLAwQUAAAA CACViXk7+IhDlWYBAABTAgAAHwAAAFdlYlZpZXdUZXN0L3Jlc291cmNlL2luZGV4Lmh0bWxVUk1P wzAMvVfqf7B2oK2GWkQ7iX0UBAiJA1yAAzeUJe5aLU1Kko5VaP+dpOvGJkWK7bzn5xd5UZqa3/re okTC3J0cAk1V1RgbbYiCbc1LY5pc4A98vr482/gNv1vUJox8z6jO9359b0DFskERBis0wSUErjJL EtJUccErulYxlXWiUW0qijpRtkdyV6MpJcsHgLG1GGkpLyzra41dvmRTSidskk6Lq2uS3qQpowyz jLECp2yyDKITdaGshU4bYmwPIlYIObiXR8L5A6Hr+T9Wo2ChaDmPbHHne5QYWkKIUe+HcFQmHN0L wC3FxlRSgKS0VQoZVAJMibD/phielJIKBKlxBiMYA8YuBt8bw+jwWqPWZHUEDGk0h167aAXtJU5n DfeTQFVAeBi6t/fu7EGeQxZZOjiMPcPEvXfInMw/STdSaPzArXFmwSoCco0D+Yx5TjyoRXvWzm3J cTtcspSs2++OW6Y/UEsDBBQAAAAIAECIeTsC5FmhVQAAAHsAAAAYAAAAV2ViVmlld1Rlc3QvcmVz b3VyY2UucXJjswlydrbjUgACm8Ki1OL80qLkVIWCotS0zApbJf3i5KLMghIliAKworTMnFSFxJzM xGJbpcy8lNQKvYyS3BwlO5hefYSgjT5IMdRwfbjpdlw2+mBLAVBLAwQUAAAACABsZFo7DAjvE50A AAARAQAAGwAAAFdlYlZpZXdUZXN0L1dlYlZpZXdUZXN0LnByb5WMvQrCMBRG90De4UJHaUkzCBY6 lBJcFPsTdXFp4x1qsam3keLb22ziIp7tO/CdAMJ/4SyAguwNjQND2Di8QvuC0uV+WAIpxCaMRSjX OpaJEImU/vO7/AVnpYZVCgO62VIPF85gYca27xxnOqu2SkMKZ2xPHc4aJ2/VvthlWi2+GUfO6sOx ylXtO/emGyLjZaU+NOFkn2QwepDh7A1QSwMECgAAAAAAqYl5OwAAAAAAAAAAAAAAAAwAAABXZWJW aWV3VGVzdC9QSwECFAAKAAAAAAC4iXk7AAAAAAAAAAAAAAAAEgAAAAAAAAAAABAAAAAAAAAAV2Vi Vmlld1Rlc3QvZGVidWcvUEsBAhQAFAAAAAgAeWVaO/oJ2sqvAAAABAEAABQAAAAAAAAAAQAgAAAA MAAAAFdlYlZpZXdUZXN0L21haW4uY3BwUEsBAhQAFAAAAAgAsIl5O4qI5QndAAAAswEAABoAAAAA AAAAAQAgAAAAEQEAAFdlYlZpZXdUZXN0L21haW53aW5kb3cuY3BwUEsBAhQAFAAAAAgADGBaO1Sw 1B3MAAAAYQEAABgAAAAAAAAAAQAgAAAAJgIAAFdlYlZpZXdUZXN0L21haW53aW5kb3cuaFBLAQIU ABQAAAAIAAxgWjumJc4JGgEAAI4CAAAZAAAAAAAAAAEAIAAAACgDAABXZWJWaWV3VGVzdC9tYWlu d2luZG93LnVpUEsBAhQACgAAAAAAKGBaOwAAAAAAAAAAAAAAABQAAAAAAAAAAAAQAAAAeQQAAFdl YlZpZXdUZXN0L3JlbGVhc2UvUEsBAhQACgAAAAAAPIh5OwAAAAAAAAAAAAAAABUAAAAAAAAAAAAQ AAAAqwQAAFdlYlZpZXdUZXN0L3Jlc291cmNlL1BLAQIUABQAAAAIAJWJeTv4iEOVZgEAAFMCAAAf AAAAAAAAAAEAIAAAAN4EAABXZWJWaWV3VGVzdC9yZXNvdXJjZS9pbmRleC5odG1sUEsBAhQAFAAA AAgAQIh5OwLkWaFVAAAAewAAABgAAAAAAAAAAQAgAAAAgQYAAFdlYlZpZXdUZXN0L3Jlc291cmNl LnFyY1BLAQIUABQAAAAIAGxkWjsMCO8TnQAAABEBAAAbAAAAAAAAAAEAIAAAAAwHAABXZWJWaWV3 VGVzdC9XZWJWaWV3VGVzdC5wcm9QSwECFAAKAAAAAACpiXk7AAAAAAAAAAAAAAAADAAAAAAAAAAA ABAAAADiBwAAV2ViVmlld1Rlc3QvUEsFBgAAAAALAAsA8gIAAAwIAAAAAA== 45124 2009-12-17 21:03:37 -0800 2009-12-18 20:32:32 -0800 Proposed Patch patchFor31875-1.patch text/plain 21818 carol SW5kZXg6IFdlYktpdC9xdC9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3F0L0NoYW5n ZUxvZwkocmV2aXNpb24gNTIyOTgpCisrKyBXZWJLaXQvcXQvQ2hhbmdlTG9nCSh3b3JraW5nIGNv cHkpCkBAIC0xLDMgKzEsMzUgQEAKKzIwMDktMTItMTcgIENhcm9sIFN6YWJvICA8Y2Fyb2wuc3ph Ym9Abm9raWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFFXZWJWaWV3OiBJbXBvc3NpYmxlIHRvIG1ha2UgWE1MSHR0cFJlcXVlc3QgZnJvbSBs b2NhbGx5IHN0b3JlZCBIVE1MIHBhZ2UKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTMxODc1CisKKyAgICAgICAgKiBBcGkvcXdlYnNlY3VyaXR5b3JpZ2lu LmNwcDoKKyAgICAgICAgKFFXZWJTZWN1cml0eU9yaWdpbjo6Y3JlYXRlKToKKyAgICAgICAgKFFX ZWJTZWN1cml0eU9yaWdpbjo6Y2xlYXJXaGl0ZUxpc3RzKToKKyAgICAgICAgKFFXZWJTZWN1cml0 eU9yaWdpbjo6YWRkVG9XaGl0ZUxpc3QpOgorICAgICAgICBBZGRlZCBmdW5jdGlvbnMgdG8gZXhw b3NlIHdoaXRlbGlzdCBmdW5jdGlvbmFsaXR5LgorICAgICAgICBXQVJOSU5HOiBIb3N0cyBhbmQg RG9tYWlucyBjYW4gYmUgd2hpdGVsaXN0ZWQuIFBvcnQgc3BlY2lmaWNhdGlvbnMgYXJlIHZhbGlk IGluIHdoaXRlbGlzdGVkIFVSTHMsIGJ1dCBhcmUgaWdub3JlZC4KKyAgICAgICAgKiBBcGkvcXdl YnNlY3VyaXR5b3JpZ2luLmg6CisgICAgICAgICogdGVzdHMvcXdlYnNlY3VyaXR5b3JpZ2luOiBB ZGRlZC4KKyAgICAgICAgKiB0ZXN0cy9xd2Vic2VjdXJpdHlvcmlnaW4vcXdlYnNlY3VyaXR5b3Jp Z2luLnBybzogQWRkZWQuCisgICAgICAgICogdGVzdHMvcXdlYnNlY3VyaXR5b3JpZ2luL3Rlc3Qu aHRtbDogQWRkZWQuCisgICAgICAgICogdGVzdHMvcXdlYnNlY3VyaXR5b3JpZ2luL3RzdF9xd2Vi c2VjdXJpdHlvcmlnaW4uY3BwOiBBZGRlZC4KKyAgICAgICAgKHRzdF9RV2ViU2VjdXJpdHlPcmln aW46OnRzdF9RV2ViU2VjdXJpdHlPcmlnaW4pOgorICAgICAgICAodHN0X1FXZWJTZWN1cml0eU9y aWdpbjo6fnRzdF9RV2ViU2VjdXJpdHlPcmlnaW4pOgorICAgICAgICAodHN0X1FXZWJTZWN1cml0 eU9yaWdpbjo6aW5pdCk6CisgICAgICAgICh0c3RfUVdlYlNlY3VyaXR5T3JpZ2luOjpjbGVhbnVw KToKKyAgICAgICAgKHRzdF9RV2ViU2VjdXJpdHlPcmlnaW46OmNyZWF0ZV9kYXRhKToKKyAgICAg ICAgKHRzdF9RV2ViU2VjdXJpdHlPcmlnaW46OmNyZWF0ZSk6CisgICAgICAgICh0c3RfUVdlYlNl Y3VyaXR5T3JpZ2luOjp3aGl0ZUxpc3RfZGF0YSk6CisgICAgICAgICh0c3RfUVdlYlNlY3VyaXR5 T3JpZ2luOjp3aGl0ZUxpc3QpOgorICAgICAgICBBZGRlZCB0ZXN0cyBmb3IgdGhlIG5ld2x5IGFk ZGVkIEFQSXMuCisgICAgICAgIEluIGEgZnV0dXJlIHBhdGNoIHRlc3QgZnJvbSB0c3RfcXdlYnBh Z2UgdGhhdCBjb25jZXJuIHNlY3VyaXR5IG9yaWdpbiBzaG91bGQgYmUgbW92ZWQgdG8gaGVyZS4K KyAgICAgICAgKiB0ZXN0cy9xd2Vic2VjdXJpdHlvcmlnaW4vdHN0X3F3ZWJzZWN1cml0eW9yaWdp bi5xcmM6IEFkZGVkLgorICAgICAgICAqIHRlc3RzL3Rlc3RzLnBybzoKKyAgICAgICAgQWRkZWQg dGhlIG5ldyB0ZXN0cyBpbiB0aGUgZGVmYXVsdCBidWlsZC4KKwogMjAwOS0xMi0xNyAgQmVuamFt aW4gUG91bGFpbiAgPGJlbmphbWluLnBvdWxhaW5Abm9raWEuY29tPgogCiAgICAgICAgIFJldmll d2VkIGJ5IFNpbW9uIEhhdXNtYW5uLgpJbmRleDogV2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJpdHlv cmlnaW4uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2lu LmNwcAkocmV2aXNpb24gNTIxMTIpCisrKyBXZWJLaXQvcXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdp bi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTMwLDE2ICszMCw2IEBACiAKIHVzaW5nIG5hbWVzcGFj ZSBXZWJDb3JlOwogCi12b2lkIFFXRUJLSVRfRVhQT1JUIHF0X2RydF93aGl0ZUxpc3RBY2Nlc3NG cm9tT3JpZ2luKGNvbnN0IFFTdHJpbmcmIHNvdXJjZU9yaWdpbiwgY29uc3QgUVN0cmluZyYgZGVz dGluYXRpb25Qcm90b2NvbCwgY29uc3QgUVN0cmluZyYgZGVzdGluYXRpb25Ib3N0LCBib29sIGFs bG93RGVzdGluYXRpb25TdWJkb21haW5zKQotewotICAgIFNlY3VyaXR5T3JpZ2luOjp3aGl0ZUxp c3RBY2Nlc3NGcm9tT3JpZ2luKCpTZWN1cml0eU9yaWdpbjo6Y3JlYXRlRnJvbVN0cmluZyhzb3Vy Y2VPcmlnaW4pLCBkZXN0aW5hdGlvblByb3RvY29sLCBkZXN0aW5hdGlvbkhvc3QsIGFsbG93RGVz dGluYXRpb25TdWJkb21haW5zKTsKLX0KLQotdm9pZCBRV0VCS0lUX0VYUE9SVCBxdF9kcnRfcmVz ZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCkKLXsKLSAgICBTZWN1cml0eU9yaWdpbjo6cmVzZXRP cmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCk7Ci19Ci0KIC8qIQogICAgIFxjbGFzcyBRV2ViU2VjdXJp dHlPcmlnaW4KICAgICBcc2luY2UgNC41CkBAIC04MCw2ICs3MCwxNSBAQCBRV2ViU2VjdXJpdHlP cmlnaW46OlFXZWJTZWN1cml0eU9yaWdpbihjCiB9CiAKIC8qIQorICAgIFxzaW5jZSA0LjcKKyAg ICBDb25zdHJ1Y3RzIGEgc2VjdXJpdHkgb3JpZ2luIGZvciBcYSB1cmwuCisqLworUVdlYlNlY3Vy aXR5T3JpZ2luKiBRV2ViU2VjdXJpdHlPcmlnaW46OmNyZWF0ZShjb25zdCBRVXJsJiB1cmwpCit7 CisgICAgcmV0dXJuIG5ldyBRV2ViU2VjdXJpdHlPcmlnaW4obmV3IFFXZWJTZWN1cml0eU9yaWdp blByaXZhdGUoU2VjdXJpdHlPcmlnaW46OmNyZWF0ZUZyb21TdHJpbmcodXJsLnRvU3RyaW5nKCkp LmdldCgpKSk7Cit9OworCisvKiEKICAgICBBc3NpZ25zIHRoZSBcYSBvdGhlciBzZWN1cml0eSBv cmlnaW4gdG8gdGhpcy4KICovCiBRV2ViU2VjdXJpdHlPcmlnaW4mIFFXZWJTZWN1cml0eU9yaWdp bjo6b3BlcmF0b3I9KGNvbnN0IFFXZWJTZWN1cml0eU9yaWdpbiYgb3RoZXIpCkBAIC0yNDksMyAr MjQ4LDM1IEBAIFFTdHJpbmdMaXN0IFFXZWJTZWN1cml0eU9yaWdpbjo6bG9jYWxTY2gKICAgICB9 CiAgICAgcmV0dXJuIGxpc3Q7CiB9CisKKy8qIQorICAgIFxzaW5jZSA0LjcKKyAgICBFbXB0aWVz IGFsbCBjdXJyZW50bHkgZGVmaW5lZCB3aGl0ZWxpc3RzIGFzc29jaWF0ZWQgd2l0aCBzZWN1cml0 eSBvcmlnaW5zLgorICAgIFxzYSBhZGRUb1doaXRlTGlzdCgpCisqLwordm9pZCBRV2ViU2VjdXJp dHlPcmlnaW46OmNsZWFyV2hpdGVMaXN0cygpCit7CisgICAgU2VjdXJpdHlPcmlnaW46OnJlc2V0 T3JpZ2luQWNjZXNzV2hpdGVMaXN0cygpOworfQorCisvKiEKKyAgICBcc2luY2UgNC43CisgICAg QWxsb3dzIHBhZ2VzIHdpdGggXGMgdGhpcyBzZWN1cml0eSBvcmlnaW4gdG8gc2VuZCBYTUxIdHRw UmVxdWVzdHMgKGluY2x1ZGluZyBQT1NUcykgdG8gc2l0ZXMgCisgICAgd2l0aCB0aGUgc2FtZSBz ZWN1cml0eSBvcmlnaW4gYXMgXGEgdXJsIGFuZCBzaXRlcyB3aXRoIHNlY3VyaXR5IG9yaWdpbnMg dGhhdCBkaWZmZXIgZnJvbSB0aGF0CisgICAgb2YgXGEgdXJsIG9ubHkgdGhyb3VnaCB0aGUgcG9y dCBudW1iZXIuCisKKyAgICBJZiBcYSBpbmNsdWRlU3ViRG9tYWlucyBpcyBzZXQgdG8gdHJ1ZSAo ZGVmYXVsdCBpcyBmYWxzZSksIHRoZSBob3N0IHBvcnRpb24gb2YgXGEgdXJsIGlzIAorICAgIHRy ZWF0ZWQgYXMgYSBkb21haW4gbmFtZSBhbmQgdGhlIHBlcm1pc3Npb24gdG8gc2VuZCBYTUxIdHRw UmVxdWVzdHMgaXMgYWxzbyBncmFudGVkIGZvciB0YXJnZXRzCisgICAgdGhhdCBhcmUgc3ViZG9t YWlucyBvZiB0aGlzIGRvbWFpbi4KKworICAgIElmIHRoZSBob3N0IHBvcnRpb24gb2YgXGEgdXJs IGlzIGVtcHR5LCB3ZWIgcGFnZXMgY29tbWluZyBmcm9tIHRoZSBjdXJyZW50IHNlY3VyaXR5IG9y aWdpbiwgYXJlIAorICAgIGdyYW50ZWQgdGhlIHJpZ2h0IHRvIHNlbmQgWE1MSHR0cFJlcXVlc3Rz IHRvIGFsbCBVUkxzIHRoYXQgdXNlIHRoZSBzYW1lIHNjaGVtYSBhcyBcYSB1cmwuCisKKyAgICBJ ZiB0aGUgaG9zdCBwb3J0aW9uIG9mIFxhIHVybCBpcyBhbiBJUCBhZGRyZXNzIGFuZCBpbmNsdWRl U3ViRG9tYWlucyBpcyB0cnVlLCB0aGUgYmVoYXZpb3IgaXMgdGhlCisgICAgc2FtZSBhcyBpZiBp bmNsdWRlU3ViRG9tYWlucyBpcyBmYWxzZSwgdGhhdCBpcyB0aGUgdHdvIHBhcmFncmFwaHMgYWJv dmUgZG8gbm90IGFwcGx5LgorKi8KK3ZvaWQgUVdlYlNlY3VyaXR5T3JpZ2luOjphZGRUb1doaXRl TGlzdChjb25zdCBRVXJsJiB1cmwsIGJvb2wgaW5jbHVkZVN1YkRvbWFpbnMpCit7CisgICAgU2Vj dXJpdHlPcmlnaW46OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oKmQtPm9yaWdpbi5nZXQoKSwg dXJsLnNjaGVtZSgpLCB1cmwuaG9zdCgpLCBpbmNsdWRlU3ViRG9tYWlucyk7Cit9CisKSW5kZXg6 IFdlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2luLmgKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0 L3F0L0FwaS9xd2Vic2VjdXJpdHlvcmlnaW4uaAkocmV2aXNpb24gNTIxMTIpCisrKyBXZWJLaXQv cXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5oCSh3b3JraW5nIGNvcHkpCkBAIC00MCw2ICs0MCw3 IEBAIHB1YmxpYzoKICAgICBzdGF0aWMgdm9pZCBhZGRMb2NhbFNjaGVtZShjb25zdCBRU3RyaW5n JiBzY2hlbWUpOwogICAgIHN0YXRpYyB2b2lkIHJlbW92ZUxvY2FsU2NoZW1lKGNvbnN0IFFTdHJp bmcmIHNjaGVtZSk7CiAgICAgc3RhdGljIFFTdHJpbmdMaXN0IGxvY2FsU2NoZW1lcygpOworICAg IHN0YXRpYyBRV2ViU2VjdXJpdHlPcmlnaW4qIGNyZWF0ZShjb25zdCBRVXJsJik7CiAKICAgICB+ UVdlYlNlY3VyaXR5T3JpZ2luKCk7CiAKQEAgLTU2LDYgKzU3LDEwIEBAIHB1YmxpYzoKIAogICAg IFFXZWJTZWN1cml0eU9yaWdpbihjb25zdCBRV2ViU2VjdXJpdHlPcmlnaW4mIG90aGVyKTsKICAg ICBRV2ViU2VjdXJpdHlPcmlnaW4gJm9wZXJhdG9yPShjb25zdCBRV2ViU2VjdXJpdHlPcmlnaW4m IG90aGVyKTsKKworICAgIHZvaWQgYWRkVG9XaGl0ZUxpc3QoY29uc3QgUVVybCYsIGJvb2wgaW5j bHVkZVN1YkRvbWFpbnMgPSBmYWxzZSk7CisgICAgc3RhdGljIHZvaWQgY2xlYXJXaGl0ZUxpc3Rz KCk7CisKIHByaXZhdGU6CiAgICAgZnJpZW5kIGNsYXNzIFFXZWJEYXRhYmFzZTsKICAgICBmcmll bmQgY2xhc3MgUVdlYkZyYW1lOwpJbmRleDogV2ViS2l0L3F0L3Rlc3RzL3Rlc3RzLnBybwo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJLaXQvcXQvdGVzdHMvdGVzdHMucHJvCShyZXZpc2lvbiA1MjExMikKKysr IFdlYktpdC9xdC90ZXN0cy90ZXN0cy5wcm8JKHdvcmtpbmcgY29weSkKQEAgLTEsNCArMSw0IEBA CiAKIFRFTVBMQVRFID0gc3ViZGlycwotU1VCRElSUyA9IHF3ZWJmcmFtZSBxd2VicGFnZSBxd2Vi ZWxlbWVudCBxZ3JhcGhpY3N3ZWJ2aWV3IHF3ZWJoaXN0b3J5aW50ZXJmYWNlIHF3ZWJ2aWV3IHF3 ZWJoaXN0b3J5IHF3ZWJpbnNwZWN0b3IKK1NVQkRJUlMgPSBxd2ViZnJhbWUgcXdlYnBhZ2UgcXdl YmVsZW1lbnQgcWdyYXBoaWNzd2VidmlldyBxd2ViaGlzdG9yeWludGVyZmFjZSBxd2VidmlldyBx d2ViaGlzdG9yeSBxd2Vic2VjdXJpdHlvcmlnaW4gcXdlYmluc3BlY3RvcgogZ3JlYXRlclRoYW4o UVRfTUlOT1JfVkVSU0lPTiwgNCk6IFNVQkRJUlMgKz0gYmVuY2htYXJrcy9wYWludGluZy90c3Rf cGFpbnRpbmcucHJvIGJlbmNobWFya3MvbG9hZGluZy90c3RfbG9hZGluZy5wcm8KSW5kZXg6IFdl YktpdC9xdC90ZXN0cy9xd2Vic2VjdXJpdHlvcmlnaW4vcXdlYnNlY3VyaXR5b3JpZ2luLnBybwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJLaXQvcXQvdGVzdHMvcXdlYnNlY3VyaXR5b3JpZ2luL3F3ZWJzZWN1 cml0eW9yaWdpbi5wcm8JKHJldmlzaW9uIDApCisrKyBXZWJLaXQvcXQvdGVzdHMvcXdlYnNlY3Vy aXR5b3JpZ2luL3F3ZWJzZWN1cml0eW9yaWdpbi5wcm8JKHJldmlzaW9uIDApCkBAIC0wLDAgKzEs MTIgQEAKK1RFTVBMQVRFID0gYXBwCitUQVJHRVQgPSB0c3RfcXdlYnNlY3VyaXR5b3JpZ2luCitp bmNsdWRlKC4uLy4uLy4uLy4uL1dlYktpdC5wcmkpCitTT1VSQ0VTICo9IHRzdF9xd2Vic2VjdXJp dHlvcmlnaW4uY3BwCitRVCAqPSB0ZXN0bGliIG5ldHdvcmsKK1JFU09VUkNFUyAqPSB0c3RfcXdl YnNlY3VyaXR5b3JpZ2luLnFyYworUU1BS0VfUlBBVEhESVIgPSAkJE9VVFBVVF9ESVIvbGliICQk UU1BS0VfUlBBVEhESVIKKworc3ltYmlhbiB7CisgICAgVEFSR0VULlVJRDMgPSAweEEwMDBDQTgw CisgICAgVEFSR0VULkNBUEFCSUxJVFkgPSBSZWFkVXNlckRhdGEgV3JpdGVVc2VyRGF0YQorfQpJ bmRleDogV2ViS2l0L3F0L3Rlc3RzL3F3ZWJzZWN1cml0eW9yaWdpbi90ZXN0Lmh0bWwKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViS2l0L3F0L3Rlc3RzL3F3ZWJzZWN1cml0eW9yaWdpbi90ZXN0Lmh0bWwJKHJl dmlzaW9uIDApCisrKyBXZWJLaXQvcXQvdGVzdHMvcXdlYnNlY3VyaXR5b3JpZ2luL3Rlc3QuaHRt bAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw1MyBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICIt Ly9XM0MvL0RURCBIVE1MIDQuMDEvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvVFIvaHRtbDQvc3Ry aWN0LmR0ZCI+DQorPGh0bWw+DQorICAgIDxoZWFkPg0KKyAgICAgICAgPG1ldGEgaHR0cC1lcXVp dj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9aXNvLTg4NTktMSI+ DQorICAgICAgICA8dGl0bGU+UVdlYlNlY3VyaXR5T3JpZ2luIHRlc3QgcGFnZTwvdGl0bGU+DQor ICAgICAgICA8c2NyaXB0IExhbmd1YWdlPSJKYXZhU2NyaXB0Ij4NCisgICAgICAgICAgICBmdW5j dGlvbiBydW5UZXN0KHVybCkNCisgICAgICAgICAgICB7DQorICAgICAgICAgICAgICAgIHZhciBy ZXN1bHQgPSAiIjsNCisgICAgICAgICAgICAgICAgZnVuY3Rpb24gdHJhY2UocG9pbnQpDQorICAg ICAgICAgICAgICAgIHsNCisgICAgICAgICAgICAgICAgICAgIHZhciBlbCA9IGRvY3VtZW50LmNy ZWF0ZUVsZW1lbnQoIlAiKTsNCisgICAgICAgICAgICAgICAgICAgIGVsLmlubmVySFRNTCA9IHBv aW50ICsgIjogUmVzdWx0IGlzOlwiIiArIHJlc3VsdCArICJcIiINCisgICAgICAgICAgICAgICAg ICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJDb25zb2xlIikuYXBwZW5kQ2hpbGQoZWwpOw0K KyAgICAgICAgICAgICAgICB9DQorICAgICAgICAgICAgICAgIHRyeSB7DQorICAgICAgICAgICAg ICAgICAgICB2YXIgeG1saHR0cCA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOw0KKyAgICAgICAgICAg ICAgICAgICAgeG1saHR0cC5vcGVuKCdHRVQnLHVybCwgZmFsc2UpOw0KKyAgICAgICAgICAgICAg ICAgICAgeG1saHR0cC5vbnJlYWR5c3RhdGVjaGFuZ2UgPSBkb25lOw0KKyAgICAgICAgICAgICAg ICAgICAgeG1saHR0cC5vbmVycm9yID0gZXJyb3I7DQorICAgICAgICAgICAgICAgICAgICB4bWxo dHRwLnNlbmQobnVsbCk7DQorICAgICAgICAgICAgICAgICAgICByZXN1bHQgPSB4bWxodHRwLnJl c3BvbnNlVGV4dDsNCisgICAgICAgICAgICAgICAgfSBjYXRjaCAoZSkgew0KKyAgICAgICAgICAg ICAgICAgICAgaWYgKHJlc3VsdCA9PSAiIikgew0KKyAgICAgICAgICAgICAgICAgICAgICAgIHJl c3VsdCA9IGU7DQorICAgICAgICAgICAgICAgICAgICAgICAgdHJhY2UoIkNhdGNoMSIpOw0KKyAg ICAgICAgICAgICAgICAgICAgfSBlbHNlDQorICAgICAgICAgICAgICAgICAgICAgICAgdHJhY2Uo IkNhdGNoMiIpOw0KKyAgICAgICAgICAgICAgICB9DQorDQorICAgICAgICAgICAgICAgIGZ1bmN0 aW9uIGRvbmUoKQ0KKyAgICAgICAgICAgICAgICB7DQorICAgICAgICAgICAgICAgICAgICBpZiAo cmVzdWx0Lmxlbmd0aCA8IDUpIHsNCisgICAgICAgICAgICAgICAgICAgICAgICByZXN1bHQgPSAi IiArIHhtbGh0dHAucmVhZHlTdGF0ZTsNCisgICAgICAgICAgICAgICAgICAgICAgICB0cmFjZSgi RG9uZTEiKTsNCisgICAgICAgICAgICAgICAgICAgIH0gZWxzZQ0KKyAgICAgICAgICAgICAgICAg ICAgICAgIHRyYWNlKCJEb25lMiIpOw0KKyAgICAgICAgICAgICAgICB9DQorICAgICAgICAgICAg ICAgIGZ1bmN0aW9uIGVycm9yKCkNCisgICAgICAgICAgICAgICAgew0KKyAgICAgICAgICAgICAg ICAgICAgcmVzdWx0ID0gIkZBSUxFRCI7DQorICAgICAgICAgICAgICAgICAgICB0cmFjZSgiRXJy b3IiKTsNCisgICAgICAgICAgICAgICAgfQ0KKyAgICAgICAgICAgICAgICB0cmFjZSgiRXhpdCIp Ow0KKyAgICAgICAgICAgICAgICByZXR1cm4gcmVzdWx0ID09ICJUZXN0IjsNCisgICAgICAgICAg ICB9DQorICAgICAgICA8L3NjcmlwdD4NCisgICAgPC9oZWFkPg0KKyAgICA8Ym9keT4NCisgICAg ICAgIDxpbnB1dCB0eXBlPSJidXR0b24iIG9uY2xpY2s9ImphdmFzY3JpcHQ6YWxlcnQocnVuVGVz dCgnaHR0cDovL3d3dy5nb29nbGUuY29tJykpIiB2YWx1ZT0iUnVuIFRlc3QiLz48YnIvPg0KKyAg ICAgICAgPGRpdiBpZD0iQ29uc29sZSIvPg0KKyAgICA8L2JvZHk+DQorPC9odG1sPg0KSW5kZXg6 IFdlYktpdC9xdC90ZXN0cy9xd2Vic2VjdXJpdHlvcmlnaW4vdHN0X3F3ZWJzZWN1cml0eW9yaWdp bi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3F0L3Rlc3RzL3F3ZWJzZWN1cml0eW9yaWdpbi90 c3RfcXdlYnNlY3VyaXR5b3JpZ2luLmNwcAkocmV2aXNpb24gMCkKKysrIFdlYktpdC9xdC90ZXN0 cy9xd2Vic2VjdXJpdHlvcmlnaW4vdHN0X3F3ZWJzZWN1cml0eW9yaWdpbi5jcHAJKHJldmlzaW9u IDApCkBAIC0wLDAgKzEsMjIwIEBACisvKgorICAgIENvcHlyaWdodCAoQykgMjAwOSBOb2tpYSBD b3Jwb3JhdGlvbiBhbmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykKKworICAgIFRoaXMgbGlicmFy eSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAgICBt b2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1Ymxp YworICAgIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b247IGVpdGhlcgorICAgIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0 aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAgIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRl ZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICAgIGJ1dCBXSVRIT1VUIEFO WSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgICAgTUVS Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRo ZSBHTlUKKyAgICBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWls cy4KKworICAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJy YXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAgICBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsg c2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICAgIHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxv b3IsCisgICAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisqLworCisKKyNpbmNsdWRlIDxx d2ViZnJhbWUuaD4KKyNpbmNsdWRlIDxxd2VicGFnZS5oPgorI2luY2x1ZGUgPHF3ZWJzZWN1cml0 eW9yaWdpbi5oPgorI2luY2x1ZGUgPHF3ZWJ2aWV3Lmg+CisKKyNpbmNsdWRlIDxRRGVidWc+Cisj aW5jbHVkZSA8UU5ldHdvcmtSZXBseT4KKyNpbmNsdWRlIDxRdFRlc3Q+CisKKy8vVEVTVEVEX0NM QVNTPVFXZWJTZWN1cml0eU9yaWdpbgorLy9URVNURURfRklMRVM9V2ViS2l0L3F0L0FwaS9xd2Vi c2VjdXJpdHlvcmlnaW4uKgorCitjbGFzcyB0c3RfUVdlYlNlY3VyaXR5T3JpZ2luIDogcHVibGlj IFFPYmplY3QgeworICAgIFFfT0JKRUNUCitwdWJsaWM6CisgICAgdHN0X1FXZWJTZWN1cml0eU9y aWdpbigpOworICAgIHZpcnR1YWwgfnRzdF9RV2ViU2VjdXJpdHlPcmlnaW4oKTsKKworcHJpdmF0 ZSBzbG90czoKKyAgICB2b2lkIGluaXQoKTsKKyAgICB2b2lkIGNsZWFudXAoKTsKKyAgICB2b2lk IGNyZWF0ZV9kYXRhKCk7CisgICAgdm9pZCBjcmVhdGUoKTsKKyAgICB2b2lkIHdoaXRlTGlzdF9k YXRhKCk7CisgICAgdm9pZCB3aGl0ZUxpc3QoKTsKK3ByaXZhdGU6CisgICAgUVdlYlZpZXcqIG1f dmlldzsKKyAgICBRV2ViUGFnZSogbV9wYWdlOworfTsKKwordHN0X1FXZWJTZWN1cml0eU9yaWdp bjo6dHN0X1FXZWJTZWN1cml0eU9yaWdpbigpCit7Cit9CisKK3RzdF9RV2ViU2VjdXJpdHlPcmln aW46On50c3RfUVdlYlNlY3VyaXR5T3JpZ2luKCkKK3sKK30KKwordm9pZCB0c3RfUVdlYlNlY3Vy aXR5T3JpZ2luOjppbml0KCkKK3sKKyAgICBtX3ZpZXcgPSBuZXcgUVdlYlZpZXcoKTsKKyAgICBt X3BhZ2UgPSBtX3ZpZXctPnBhZ2UoKTsKK30KKwordm9pZCB0c3RfUVdlYlNlY3VyaXR5T3JpZ2lu OjpjbGVhbnVwKCkKK3sKKyAgICBkZWxldGUgbV92aWV3OworfQorCit2b2lkIHRzdF9RV2ViU2Vj dXJpdHlPcmlnaW46OmNyZWF0ZV9kYXRhKCkKK3sKKyAgICBRVGVzdDo6YWRkQ29sdW1uPFFTdHJp bmc+KCJ1cmwiKTsKKyAgICBRVGVzdDo6YWRkQ29sdW1uPFFTdHJpbmc+KCJzY2hlbWUiKTsKKyAg ICBRVGVzdDo6YWRkQ29sdW1uPFFTdHJpbmc+KCJob3N0Iik7CisgICAgUVRlc3Q6OmFkZENvbHVt bjxpbnQ+KCJwb3J0Iik7CisgICAgUVRlc3Q6Om5ld1JvdygiaHR0cCIpIDw8ICJodHRwOi8vd3d3 Lmdvb2dsZS5jb20iIDw8ICJodHRwIiA8PCAid3d3Lmdvb2dsZS5jb20iIDw8IDA7CisgICAgUVRl c3Q6Om5ld1JvdygiaHR0cFNsYXNoIikgPDwgImh0dHA6Ly93d3cuZ29vZ2xlLmNvbS8iIDw8ICJo dHRwIiA8PCAid3d3Lmdvb2dsZS5jb20iIDw8IDA7CisgICAgUVRlc3Q6Om5ld1JvdygiaHR0cFBv cnRTbGFzaCIpIDw8ICJodHRwOi8vd3d3Lmdvb2dsZS5jb206ODA4MC8iIDw8ICJodHRwIiA8PCAi d3d3Lmdvb2dsZS5jb20iIDw8IDgwODA7CisgICAgUVRlc3Q6Om5ld1JvdygiaHR0cERlZlBvcnRT bGFzaCIpIDw8ICJodHRwOi8vd3d3Lmdvb2dsZS5jb206ODAvIiA8PCAiaHR0cCIgPDwgInd3dy5n b29nbGUuY29tIiA8PCAwOworICAgIFFUZXN0OjpuZXdSb3coImZpbGUiKSA8PCAiZmlsZTovLy9o b21lL3Rlc3QvODA4MC8iIDw8ICJmaWxlIiA8PCAiIiA8PCAwOworfQordm9pZCB0c3RfUVdlYlNl Y3VyaXR5T3JpZ2luOjpjcmVhdGUoKQoreworICAgIFFGRVRDSChRU3RyaW5nLCB1cmwpOworICAg IFFGRVRDSChRU3RyaW5nLCBzY2hlbWUpOworICAgIFFGRVRDSChRU3RyaW5nLCBob3N0KTsKKyAg ICBRRkVUQ0goaW50LCBwb3J0KTsKKworICAgIFFXZWJTZWN1cml0eU9yaWdpbiogdGVzdCA9IFFX ZWJTZWN1cml0eU9yaWdpbjo6Y3JlYXRlKHVybCk7CisgICAgUUNPTVBBUkUodGVzdC0+c2NoZW1l KCksIHNjaGVtZSk7CisgICAgUUNPTVBBUkUodGVzdC0+aG9zdCgpLCBob3N0KTsKKyAgICBRQ09N UEFSRSh0ZXN0LT5wb3J0KCksIHBvcnQpOworfQorCit2b2lkIHRzdF9RV2ViU2VjdXJpdHlPcmln aW46OndoaXRlTGlzdF9kYXRhKCkKK3sKKyAgICBRVGVzdDo6YWRkQ29sdW1uPFFTdHJpbmc+KCJz b3VyY2UiKTsKKyAgICBRVGVzdDo6YWRkQ29sdW1uPFFTdHJpbmc+KCJ0YXJnZXQiKTsKKyAgICBR VGVzdDo6YWRkQ29sdW1uPGJvb2w+KCJpbmNsdWRlU3ViRG9tYWlucyIpOworICAgIFFUZXN0Ojph ZGRDb2x1bW48UVN0cmluZz4oInRlc3RVcmwiKTsKKyAgICBRVGVzdDo6YWRkQ29sdW1uPGJvb2w+ KCJzdWNjZXNzQmVmb3JlQWRkIik7CisgICAgUVRlc3Q6OmFkZENvbHVtbjxib29sPigic3VjY2Vz c0FmdGVyQWRkIik7CisgICAgUVRlc3Q6OmFkZENvbHVtbjxib29sPigic3VjY2Vzc0FmdGVyUmVt b3ZlIik7CisgICAgUVRlc3Q6Om5ld1Jvdygic2NoZW1lIikgPDwgImh0dHA6Ly93d3cuZ29vZ2xl LmNvbS9teVN0dWZmIiA8PCAiaHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS8xMjMiIDw8IGZhbHNlIDw8 ICJodHRwczovL3d3dy5nb29nbGUuY29tL215U3VmZiIgPDwgZmFsc2UgPDwgdHJ1ZSA8PCBmYWxz ZTsKKyAgICBRVGVzdDo6bmV3Um93KCJzY2hlbWVGYWlsIikgPDwgImh0dHA6Ly93d3cuZ29vZ2xl LmNvbS9teVN0dWZmIiA8PCAiaHR0cHM6Ly9nb29nbGUuY29tLzEyMyIgPDwgZmFsc2UgPDwgImh0 dHBzOi8vd3d3Lmdvb2dsZS5jb20vbXlTdWZmIiA8PCBmYWxzZSA8PCBmYWxzZSA8PCBmYWxzZTsK KyAgICBRVGVzdDo6bmV3Um93KCJzY2hlbWVTdWJEb20iKSA8PCAiaHR0cDovL3d3dy5nb29nbGUu Y29tL215U3R1ZmYiIDw8ICJodHRwczovL2dvb2dsZS5jb20vMTIzIiA8PCB0cnVlIDw8ICJodHRw czovL3d3dy5nb29nbGUuY29tL215U3VmZiIgPDwgZmFsc2UgPDwgdHJ1ZSA8PCBmYWxzZTsKKyAg ICBRVGVzdDo6bmV3Um93KCJzY2hlbWVTdWJEb21GYWlsIikgPDwgImh0dHA6Ly93d3cuZ29vZ2xl LmNvbS9teVN0dWZmIiA8PCAiaHR0cHM6Ly9nb29nbGUuY29tLzEyMyIgPDwgdHJ1ZSA8PCAiaHR0 cHM6Ly93d3dnb29nbGUuY29tL215U3VmZiIgPDwgZmFsc2UgPDwgZmFsc2UgPDwgZmFsc2U7Cisg ICAgUVRlc3Q6Om5ld1Jvdygic2NoZW1lU3ViRG9tIikgPDwgImh0dHA6Ly93d3cuZ29vZ2xlLmNv bS9teVN0dWZmIiA8PCAiaHR0cHM6Ly8vMTIzIiA8PCB0cnVlIDw8ICJodHRwczovL3d3d2dvb2ds ZS5vcmcvbXlTdWZmIiA8PCBmYWxzZSA8PCB0cnVlIDw8IGZhbHNlOworICAgIFFUZXN0OjpuZXdS b3coInNjaGVtZVN1YkRvbUZhaWwiKSA8PCAiaHR0cDovL3d3dy5nb29nbGUuY29tL215U3R1ZmYi IDw8ICJodHRwczovLy8xMjMiIDw8IHRydWUgPDwgImZpbGU6Ly8vd3d3Lmdvb2dsZS5vcmcvbXlT dWZmIiA8PCBmYWxzZSA8PCBmYWxzZSA8PCBmYWxzZTsKKyAgICBRVGVzdDo6bmV3Um93KCJob3N0 IikgPDwgImh0dHA6Ly93d3cuZ29vZ2xlLmNvbS9teXN0dWZmIiA8PCAiaHR0cDovL2dvb2dsZS5j b20vMTIzIiA8PCBmYWxzZSA8PCAiaHR0cDovL2dvb2dsZS5jb20vbXlzdHVmZiIgPDwgZmFsc2Ug PDwgdHJ1ZSA8PCBmYWxzZTsKKyAgICBRVGVzdDo6bmV3Um93KCJob3N0RmFpbCIpIDw8ICJodHRw Oi8vd3d3Lmdvb2dsZS5jb20vbXlzdHVmZiIgPDwgImh0dHA6Ly9nb29nbGUuY29tLzEyMyIgPDwg ZmFsc2UgPDwgImh0dHA6Ly9hYmMuZ29vZ2xlLmNvbS9teXN0dWZmIiA8PCBmYWxzZSA8PCBmYWxz ZSA8PCBmYWxzZTsKKyAgICBRVGVzdDo6bmV3Um93KCJob3N0U3ViRG9tIikgPDwgImh0dHA6Ly93 d3cuZ29vZ2xlLmNvbSIgPDwgImh0dHA6Ly9nb29nbGUuY29tIiA8PCB0cnVlIDw8ICJodHRwOi8v YWJjMi5nb29nbGUuY29tIiA8PCBmYWxzZSA8PCB0cnVlIDw8IGZhbHNlOworICAgIFFUZXN0Ojpu ZXdSb3coImhvc3RTdWJEb21GYWlsIikgPDwgImh0dHA6Ly93d3cuZ29vZ2xlLmNvbSIgPDwgImh0 dHA6Ly9nb29nbGUuY29tIiA8PCB0cnVlIDw8ICJodHRwOi8vYWJjMmdvb2dsZS5jb20iIDw8IGZh bHNlIDw8IGZhbHNlIDw8IGZhbHNlOworICAgIFFUZXN0OjpuZXdSb3coImhvc3RTdWJEb21GYWls Q291bnRyeSIpIDw8ICJodHRwOi8vd3d3Lmdvb2dsZS5jb20iIDw8ICJodHRwOi8vZ29vZ2xlLmNv bSIgPDwgdHJ1ZSA8PCAiaHR0cDovL3d3dy5nb29nbGUuY29tLnR3IiA8PCBmYWxzZSA8PCBmYWxz ZSA8PCBmYWxzZTsKKyAgICBRVGVzdDo6bmV3Um93KCJwb3J0IikgPDwgImh0dHA6Ly93d3cuZ29v Z2xlLmNvbTo4MDgwIiA8PCAiaHR0cDovL3d3dy5nb29nbGUuY29tOjkwIiA8PCBmYWxzZSA8PCAi aHR0cDovL3d3dy5nb29nbGUuY29tOjkwIiA8PCBmYWxzZSA8PCB0cnVlIDw8IGZhbHNlOworICAg IFFUZXN0OjpuZXdSb3coInBvcnRTdWJEb20iKSA8PCAiaHR0cDovL3d3dy5nb29nbGUuY29tOjgw ODAiIDw8ICJodHRwOi8vYWJjLmNvbTo5MCIgPDwgdHJ1ZSA8PCAiaHR0cDovL3h5ei5hYmMuY29t OjkwIiA8PCBmYWxzZSA8PCB0cnVlIDw8IGZhbHNlOworfQorCitjbGFzcyBDYW5uZWRSZXNwb25z ZU5ldHdvcmtSZXBseTogcHVibGljIFFOZXR3b3JrUmVwbHkgeworICAgIFFfT0JKRUNUCitwdWJs aWM6CisgICAgQ2FubmVkUmVzcG9uc2VOZXR3b3JrUmVwbHkoUU9iamVjdCogcGFyZW50LCBRTmV0 d29ya0FjY2Vzc01hbmFnZXI6Ok9wZXJhdGlvbiBvcCwgY29uc3QgUU5ldHdvcmtSZXF1ZXN0JiBy ZXEsIGNvbnN0IFFCdWZmZXImIGJvZHkpOiBRTmV0d29ya1JlcGx5KHBhcmVudCkKKyAgICB7Cisg ICAgICAgIHNldFJlcXVlc3QocmVxKTsKKyAgICAgICAgc2V0VXJsKHJlcS51cmwoKSk7CisgICAg ICAgIHNldE9wZXJhdGlvbihvcCk7CisgICAgICAgIG1fYnVmZmVyLnNldERhdGEoYm9keS5kYXRh KCkpOworICAgICAgICBjb25uZWN0KCZtX2J1ZmZlciwgU0lHTkFMKHJlYWR5UmVhZCgpKSwgU0xP VChlbWl0UmVhZHlSZWFkKCkpKTsKKyAgICAgICAgY29ubmVjdCgmbV9idWZmZXIsIFNJR05BTChy ZWFkQ2hhbm5lbEZpbmlzaGVkKCkpLCBTTE9UKGVtaXRSZWFkQ2hhbm5lbEZpbmlzaGVkKCkpKTsK KyAgICAgICAgY29ubmVjdCgmbV9idWZmZXIsIFNJR05BTChyZWFkQ2hhbm5lbEZpbmlzaGVkKCkp LCBTTE9UKGVtaXRSZWFkQ2hhbm5lbEZpbmlzaGVkKCkpKTsKKyAgICAgICAgbV9idWZmZXIub3Bl bihRSU9EZXZpY2U6OlJlYWRPbmx5KTsKKyAgICAgICAgb3BlbihRSU9EZXZpY2U6OlJlYWRPbmx5 KTsKKyAgICAgICAgUVRpbWVyOjpzaW5nbGVTaG90KDEwLCB0aGlzLCBTTE9UKHVwZGF0ZSgpKSk7 CisgICAgfQorcHJvdGVjdGVkOgorICAgIHFpbnQ2NCByZWFkRGF0YShjaGFyICogZGF0YSwgcWlu dDY0IG1heFNpemUpCisgICAgeworICAgICAgICBxaW50NjQgcmVzdWx0ID0gbV9idWZmZXIucmVh ZChkYXRhLCBtYXhTaXplKTsKKyAgICAgICAgaWYgKCFtX2J1ZmZlci5ieXRlc0F2YWlsYWJsZSgp KQorICAgICAgICAgICAgUVRpbWVyOjpzaW5nbGVTaG90KDEwLCB0aGlzLCBTTE9UKGVtaXRSZWFk Q2hhbm5lbEZpbmlzaGVkKCkpKTsKKyAgICAgICAgcmV0dXJuIHJlc3VsdDsKKyAgICB9CisKKyAg ICB2aXJ0dWFsIHFpbnQ2NCBieXRlc0F2YWlsYWJsZSgpIGNvbnN0CisgICAgeworICAgICAgICBy ZXR1cm4gbV9idWZmZXIuYnl0ZXNBdmFpbGFibGUoKTsKKyAgICB9CisKK3ByaXZhdGUgc2xvdHM6 CisgICAgdm9pZCBlbWl0UmVhZHlSZWFkKCkKKyAgICB7CisgICAgICAgIGVtaXQgcmVhZHlSZWFk KCk7CisgICAgfQorCisgICAgdm9pZCBlbWl0UmVhZENoYW5uZWxGaW5pc2hlZCgpCisgICAgewor ICAgICAgICBlbWl0IHJlYWRDaGFubmVsRmluaXNoZWQoKTsKKyAgICAgICAgZW1pdCBmaW5pc2hl ZCgpOworICAgIH0KKyAgICB2b2lkIGFib3J0KCkge307CisKKyAgICB2b2lkIHVwZGF0ZSgpCisg ICAgeworICAgICAgICBzZXRIZWFkZXIoUU5ldHdvcmtSZXF1ZXN0OjpDb250ZW50VHlwZUhlYWRl ciwgInRleHQvcGxhaW4iKTsKKyAgICAgICAgc2V0SGVhZGVyKFFOZXR3b3JrUmVxdWVzdDo6Q29u dGVudExlbmd0aEhlYWRlciwgbV9idWZmZXIuc2l6ZSgpKTsKKyAgICAgICAgc2V0RXJyb3IoUU5l dHdvcmtSZXBseTo6Tm9FcnJvciwgIiIpOworICAgICAgICBzZXRBdHRyaWJ1dGUoUU5ldHdvcmtS ZXF1ZXN0OjpIdHRwU3RhdHVzQ29kZUF0dHJpYnV0ZSwgMjAwKTsKKyAgICAgICAgc2V0QXR0cmli dXRlKFFOZXR3b3JrUmVxdWVzdDo6SHR0cFJlYXNvblBocmFzZUF0dHJpYnV0ZSwgUVN0cmluZygi T2siKS50b0xhdGluMSgpKTsKKyAgICAgICAgZW1pdCBtZXRhRGF0YUNoYW5nZWQoKTsKKyAgICAg ICAgZW1pdCByZWFkeVJlYWQoKTsKKyAgICB9CitwdWJsaWM6CisgICAgUUJ1ZmZlciBtX2J1ZmZl cjsKK307CisKK2NsYXNzIENhbm5lZFJlc3BvbnNlTmV0d29ya0FjY2Vzc01hbmFnZXI6IHB1Ymxp YyBRTmV0d29ya0FjY2Vzc01hbmFnZXIgeworICAgIFFfT0JKRUNUCitwcm90ZWN0ZWQ6CisgICAg dmlydHVhbCBRTmV0d29ya1JlcGx5KiBjcmVhdGVSZXF1ZXN0KE9wZXJhdGlvbiBvcCwgY29uc3Qg UU5ldHdvcmtSZXF1ZXN0JiByZXEsIFFJT0RldmljZSogb3V0Z29pbmdEYXRhID0gMCkKKyAgICB7 CisgICAgICAgIHJldHVybiBuZXcgQ2FubmVkUmVzcG9uc2VOZXR3b3JrUmVwbHkodGhpcywgb3As IHJlcSwgKm1fYnVmZmVyKTsKKyAgICB9OworcHVibGljOgorICAgIFFCdWZmZXIqIG1fYnVmZmVy OworfTsKKworc3RhdGljIGNvbnN0IGNoYXIgY2FubmVkUmVzcG9uc2VbXSA9ICJUZXN0IjsKKwor dm9pZCB0c3RfUVdlYlNlY3VyaXR5T3JpZ2luOjp3aGl0ZUxpc3QoKQoreworICAgIFFGRVRDSChR U3RyaW5nLCBzb3VyY2UpOworICAgIFFGRVRDSChRU3RyaW5nLCB0YXJnZXQpOworICAgIFFGRVRD SChib29sLCBpbmNsdWRlU3ViRG9tYWlucyk7CisgICAgUUZFVENIKFFTdHJpbmcsIHRlc3RVcmwp OworICAgIFFGRVRDSChib29sLCBzdWNjZXNzQmVmb3JlQWRkKTsKKyAgICBRRkVUQ0goYm9vbCwg c3VjY2Vzc0FmdGVyQWRkKTsKKyAgICBRRkVUQ0goYm9vbCwgc3VjY2Vzc0FmdGVyUmVtb3ZlKTsK KyAgICBRV2ViU2VjdXJpdHlPcmlnaW46OmNsZWFyV2hpdGVMaXN0cygpOworICAgIENhbm5lZFJl c3BvbnNlTmV0d29ya0FjY2Vzc01hbmFnZXIgbWFuYWdlcjsKKyAgICBRQnVmZmVyIGJ1ZmZlcjsK KyAgICBidWZmZXIuc2V0RGF0YShjYW5uZWRSZXNwb25zZSwgc2l6ZW9mKGNhbm5lZFJlc3BvbnNl KS0xKTsKKyAgICBtYW5hZ2VyLm1fYnVmZmVyID0gJmJ1ZmZlcjsKKyAgICBRRmlsZSB0ZXN0UGFn ZUZpbGUoIjovdGVzdC5odG1sIik7CisgICAgUVZFUklGWSh0ZXN0UGFnZUZpbGUub3BlbihRSU9E ZXZpY2U6OlJlYWRPbmx5KSk7CisgICAgdWNoYXIqIHRlc3RQYWdlID0gdGVzdFBhZ2VGaWxlLm1h cCgwLCB0ZXN0UGFnZUZpbGUuc2l6ZSgpKTsKKyAgICBRVkVSSUZZKHRlc3RQYWdlKTsKKyAgICBt X3ZpZXctPnNldEh0bWwoUVN0cmluZygoY29uc3QgY2hhciopdGVzdFBhZ2UpLCBRVXJsKHNvdXJj ZSkpOworICAgIG1fdmlldy0+cGFnZSgpLT5zZXROZXR3b3JrQWNjZXNzTWFuYWdlcigmbWFuYWdl cik7CisgICAgUVN0cmluZyB0ZXN0SlM9InJ1blRlc3QoXCIiICsgdGVzdFVybCArICJcIikiOwor ICAgIFFDT01QQVJFKG1fdmlldy0+cGFnZSgpLT5tYWluRnJhbWUoKS0+ZXZhbHVhdGVKYXZhU2Ny aXB0KHRlc3RKUyksIFFWYXJpYW50KHN1Y2Nlc3NCZWZvcmVBZGQpKTsKKyAgICBRV2ViU2VjdXJp dHlPcmlnaW4gc291cmNlT3JpZ2luID0gbV92aWV3LT5wYWdlKCktPm1haW5GcmFtZSgpLT5zZWN1 cml0eU9yaWdpbigpOworICAgIHNvdXJjZU9yaWdpbi5hZGRUb1doaXRlTGlzdCh0YXJnZXQsIGlu Y2x1ZGVTdWJEb21haW5zKTsKKyAgICBRQ09NUEFSRShtX3ZpZXctPnBhZ2UoKS0+bWFpbkZyYW1l KCktPmV2YWx1YXRlSmF2YVNjcmlwdCh0ZXN0SlMpLCBRVmFyaWFudChzdWNjZXNzQWZ0ZXJBZGQp KTsKKyAgICBRV2ViU2VjdXJpdHlPcmlnaW46OmNsZWFyV2hpdGVMaXN0cygpOworICAgIFFDT01Q QVJFKG1fdmlldy0+cGFnZSgpLT5tYWluRnJhbWUoKS0+ZXZhbHVhdGVKYXZhU2NyaXB0KHRlc3RK UyksIFFWYXJpYW50KHN1Y2Nlc3NBZnRlclJlbW92ZSkpOworICAgIG1fdmlldy0+cGFnZSgpLT5z ZXROZXR3b3JrQWNjZXNzTWFuYWdlcigwKTsKK30KKworUVRFU1RfTUFJTih0c3RfUVdlYlNlY3Vy aXR5T3JpZ2luKQorI2luY2x1ZGUgInRzdF9xd2Vic2VjdXJpdHlvcmlnaW4ubW9jIgpJbmRleDog V2ViS2l0L3F0L3Rlc3RzL3F3ZWJzZWN1cml0eW9yaWdpbi90c3RfcXdlYnNlY3VyaXR5b3JpZ2lu LnFyYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvcXQvdGVzdHMvcXdlYnNlY3VyaXR5b3JpZ2luL3Rz dF9xd2Vic2VjdXJpdHlvcmlnaW4ucXJjCShyZXZpc2lvbiAwKQorKysgV2ViS2l0L3F0L3Rlc3Rz L3F3ZWJzZWN1cml0eW9yaWdpbi90c3RfcXdlYnNlY3VyaXR5b3JpZ2luLnFyYwkocmV2aXNpb24g MCkKQEAgLTAsMCArMSw2IEBACis8IURPQ1RZUEUgUkNDPjxSQ0MgdmVyc2lvbj0iMS4wIj4KKzxx cmVzb3VyY2U+CisgICAgPGZpbGU+dGVzdC5odG1sPC9maWxlPgorPC9xcmVzb3VyY2U+Cis8L1JD Qz4KKwpJbmRleDogV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRv b2xzL0NoYW5nZUxvZwkocmV2aXNpb24gNTIyOTgpCisrKyBXZWJLaXRUb29scy9DaGFuZ2VMb2cJ KHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNiBAQAorMjAwOS0xMi0xNyAgQ2Fyb2wgU3phYm8g IDxjYXJvbC5zemFib0Bub2tpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgUVdlYlZpZXc6IEltcG9zc2libGUgdG8gbWFrZSBYTUxIdHRwUmVx dWVzdCBmcm9tIGxvY2FsbHkgc3RvcmVkIEhUTUwgcGFnZQorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzE4NzUKKworICAgICAgICAqIER1bXBSZW5kZXJU cmVlL3F0L0R1bXBSZW5kZXJUcmVlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkR1bXBSZW5kZXJU cmVlOjpyZXNldFRvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGluZyk6CisgICAgICAgICogRHVt cFJlbmRlclRyZWUvcXQvTGF5b3V0VGVzdENvbnRyb2xsZXJRdC5jcHA6CisgICAgICAgIChMYXlv dXRUZXN0Q29udHJvbGxlcjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbik6CisgICAgICAgIENo YW5nZWQgdG8gdXNlIHRoZSBub3cgb2ZmaWNpYWwgd2hpdGVsaXN0IEFQSSBpbnN0ZWFkIG9mIHRo ZSBmb3JtZXIgaGlkZGVuIG9uZS4KKwogMjAwOS0xMi0xNyAgU2FtIFdlaW5pZyAgPHNhbUB3ZWJr aXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IE1hcmsgUm93ZS4KSW5kZXg6IFdlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL3F0L0R1bXBSZW5kZXJUcmVlLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9EdW1wUmVuZGVyVHJlZS5jcHAJKHJldmlzaW9u IDUyMTEyKQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvcXQvRHVtcFJlbmRlclRyZWUu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC03NCw3ICs3NCw2IEBAIGV4dGVybiB2b2lkIHF0X2R1bXBf c2V0X2FjY2VwdHNfZWRpdGluZygKIGV4dGVybiB2b2lkIHF0X2R1bXBfZnJhbWVfbG9hZGVyKGJv b2wgYik7CiBleHRlcm4gdm9pZCBxdF9kcnRfY2xlYXJGcmFtZU5hbWUoUVdlYkZyYW1lKiBxRnJh bWUpOwogZXh0ZXJuIHZvaWQgcXRfZHJ0X292ZXJ3cml0ZVBsdWdpbkRpcmVjdG9yaWVzKCk7Ci1l eHRlcm4gdm9pZCBxdF9kcnRfcmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCk7CiBleHRlcm4g Ym9vbCBxdF9kcnRfaGFzRG9jdW1lbnRFbGVtZW50KFFXZWJGcmFtZSogcUZyYW1lKTsKIAogbmFt ZXNwYWNlIFdlYkNvcmUgewpAQCAtNDA0LDcgKzQwMyw3IEBAIHZvaWQgRHVtcFJlbmRlclRyZWU6 OnJlc2V0VG9Db25zaXN0ZW50U3QKICAgICBXb3JrUXVldWU6OnNoYXJlZCgpLT5jbGVhcigpOwog ICAgIFdvcmtRdWV1ZTo6c2hhcmVkKCktPnNldEZyb3plbihmYWxzZSk7CiAKLSAgICBxdF9kcnRf cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCk7CisgICAgUVdlYlNlY3VyaXR5T3JpZ2luOjpj bGVhcldoaXRlTGlzdHMoKTsKIAogICAgIFFMb2NhbGU6OnNldERlZmF1bHQoUUxvY2FsZTo6Yygp KTsKICAgICBzZXRsb2NhbGUoTENfQUxMLCAiIik7CkluZGV4OiBXZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmNwcAkocmV2 aXNpb24gNTIxMTIpCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0 Q29udHJvbGxlclF0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDIsNyArNDIsNiBAQCBleHRlcm4g Ym9vbCBxdF9kcnRfcGF1c2VUcmFuc2l0aW9uT2ZQcm9wCiBleHRlcm4gYm9vbCBxdF9kcnRfcGF1 c2VTVkdBbmltYXRpb24oUVdlYkZyYW1lKiwgY29uc3QgUVN0cmluZyYgYW5pbWF0aW9uSWQsIGRv dWJsZSB0aW1lLCBjb25zdCBRU3RyaW5nJiBlbGVtZW50SWQpOwogZXh0ZXJuIGludCBxdF9kcnRf bnVtYmVyT2ZBY3RpdmVBbmltYXRpb25zKFFXZWJGcmFtZSopOwogCi1leHRlcm4gdm9pZCBxdF9k cnRfd2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihjb25zdCBRU3RyaW5nJiBzb3VyY2VPcmlnaW4s IGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0aW9uUHJvdG9jb2wsIGNvbnN0IFFTdHJpbmcmIGRlc3Rp bmF0aW9uSG9zdCwgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7CiBleHRlcm4gUVN0 cmluZyBxdF9kcnRfY291bnRlclZhbHVlRm9yRWxlbWVudEJ5SWQoUVdlYkZyYW1lKiBxRnJhbWUs IGNvbnN0IFFTdHJpbmcmIGlkKTsKIAogTGF5b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRlc3RD b250cm9sbGVyKFdlYkNvcmU6OkR1bXBSZW5kZXJUcmVlKiBkcnQpCkBAIC0zMzksNyArMzM4LDkg QEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6Y2xlYXJBbGxEYXRhYgogCiB2b2lkIExheW91 dFRlc3RDb250cm9sbGVyOjp3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKGNvbnN0IFFTdHJpbmcm IHNvdXJjZU9yaWdpbiwgY29uc3QgUVN0cmluZyYgZGVzdGluYXRpb25Qcm90b2NvbCwgY29uc3Qg UVN0cmluZyYgZGVzdGluYXRpb25Ib3N0LCBib29sIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5z KQogewotICAgIHF0X2RydF93aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKHNvdXJjZU9yaWdpbiwg ZGVzdGluYXRpb25Qcm90b2NvbCwgZGVzdGluYXRpb25Ib3N0LCBhbGxvd0Rlc3RpbmF0aW9uU3Vi ZG9tYWlucyk7CisgICAgUVdlYlNlY3VyaXR5T3JpZ2luKiBzb3VyY2UgPSBRV2ViU2VjdXJpdHlP cmlnaW46OmNyZWF0ZShzb3VyY2VPcmlnaW4pOworICAgIHNvdXJjZS0+YWRkVG9XaGl0ZUxpc3Qo UVVybChkZXN0aW5hdGlvblByb3RvY29sICsiOi8vIiArIGRlc3RpbmF0aW9uSG9zdCksIGFsbG93 RGVzdGluYXRpb25TdWJkb21haW5zKTsKKyAgICBkZWxldGUgc291cmNlOwogfQogCiB2b2lkIExh eW91dFRlc3RDb250cm9sbGVyOjp3YWl0Rm9yUG9saWN5RGVsZWdhdGUoKQo= 45223 2009-12-18 20:32:32 -0800 2010-06-11 12:09:05 -0700 Proposed Patch; Addressed Laszlo's concerns patchFor31875-2.patch text/plain 25867 carol SW5kZXg6IFdlYktpdC9xdC9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3F0L0NoYW5n ZUxvZwkocmV2aXNpb24gNTIzMTMpCisrKyBXZWJLaXQvcXQvQ2hhbmdlTG9nCSh3b3JraW5nIGNv cHkpCkBAIC0xLDMgKzEsNDEgQEAKKzIwMDktMTItMTggIENhcm9sIFN6YWJvICA8Y2Fyb2wuc3ph Ym9Abm9raWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFFXZWJWaWV3OiBJbXBvc3NpYmxlIHRvIG1ha2UgWE1MSHR0cFJlcXVlc3QgZnJvbSBs b2NhbGx5IHN0b3JlZCBIVE1MIHBhZ2UKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTMxODc1CisgICAgICAgIEFkZGVkIEFQSXMgaW4gUVdlYlNlY3VyaXR5 IG9yaWdpbiB0byBlbmFibGUgd2hpdGVsaXN0aW5nIG9mIGhvc3RzLCBkb21haW5zIG9yIGVudGly ZSBzY2hlbWVzIGZvciBhY2Nlc3MgdmlhCisgICAgICAgIFhNTEh0dHBSZXF1ZXN0IGFuZCB0byBl bmFibGUgY2xlYXJpbmcgdGhlIHdoaXRlbGlzdHMgYnkgZXhwb3NpbmcgcHJlZXhpc3RpbmcgV2Vi Q29yZSBmdW5jdGlvbmFsaXR5LgorICAgICAgICBBIHRlc3QgaGFzIGJlZW4gYWRkZWQgdG8gdmVy aWZ5IHRoYXQgd2hpdGVsaXN0cyB3b3JrIGFzIGludGVuZGVkLiBUaGUgdGVzdCBtYWtlcyB1c2Ug b2YgYSBzcGVjaWFsIG5ldHdvcmsKKyAgICAgICAgYWNjZXNzIG1hbmFnZXIgdGhhdCByZXR1cm5z IGEgY2FubmVkIHN1Y2Nlc3NmdWwgcmVzcG9uc2UgZm9yIGFueSBVUkwgcmVxdWVzdGVkIHRoYXQg cGFzc2VzIFdlYkNvcmUgc2VjdXJpdHkKKyAgICAgICAgY2hlY2tzLCByZWdhcmRsZXNzIG9mIHdo ZXRoZXIgdGhlIHJlc291cmNlIGlzIGF2YWlsYWJsZSBpbiB0aGUgdGVzdCBlbnZpcm9ubWVudC4K KyAgICAgICAgQ3VycmVudGx5IHRoZSB0ZXN0IGlzIHNwZWNpZmljIHRvIFF0IGFzIG90aGVyIHBs YXRmb3JtcyBkbyBub3Qgc3VwcG9ydCB0aGUgcmVxdWlyZWQgZnVuY3Rpb25hbGl0eS4KKworICAg ICAgICAqIEFwaS9xd2Vic2VjdXJpdHlvcmlnaW4uY3BwOgorICAgICAgICAoUVdlYlNlY3VyaXR5 T3JpZ2luOjpjcmVhdGUpOgorICAgICAgICAoUVdlYlNlY3VyaXR5T3JpZ2luOjpjbGVhcldoaXRl TGlzdHMpOgorICAgICAgICAoUVdlYlNlY3VyaXR5T3JpZ2luOjphZGRUb1doaXRlTGlzdCk6Cisg ICAgICAgIEFkZGVkIGZ1bmN0aW9ucyB0byBleHBvc2Ugd2hpdGVsaXN0IGZ1bmN0aW9uYWxpdHku CisgICAgICAgIFdBUk5JTkc6IEhvc3RzIGFuZCBEb21haW5zIGNhbiBiZSB3aGl0ZWxpc3RlZC4g UG9ydCBzcGVjaWZpY2F0aW9ucyBhcmUgdmFsaWQgaW4gd2hpdGVsaXN0ZWQgVVJMcywgYnV0IGFy ZSBpZ25vcmVkLgorICAgICAgICAqIEFwaS9xd2Vic2VjdXJpdHlvcmlnaW4uaDoKKyAgICAgICAg KiB0ZXN0cy9xd2Vic2VjdXJpdHlvcmlnaW46IEFkZGVkLgorICAgICAgICAqIHRlc3RzL3F3ZWJz ZWN1cml0eW9yaWdpbi9xd2Vic2VjdXJpdHlvcmlnaW4ucHJvOiBBZGRlZC4KKyAgICAgICAgKiB0 ZXN0cy9xd2Vic2VjdXJpdHlvcmlnaW4vdGVzdC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiB0ZXN0 cy9xd2Vic2VjdXJpdHlvcmlnaW4vdHN0X3F3ZWJzZWN1cml0eW9yaWdpbi5jcHA6IEFkZGVkLgor ICAgICAgICAodHN0X1FXZWJTZWN1cml0eU9yaWdpbjo6dHN0X1FXZWJTZWN1cml0eU9yaWdpbik6 CisgICAgICAgICh0c3RfUVdlYlNlY3VyaXR5T3JpZ2luOjp+dHN0X1FXZWJTZWN1cml0eU9yaWdp bik6CisgICAgICAgICh0c3RfUVdlYlNlY3VyaXR5T3JpZ2luOjppbml0KToKKyAgICAgICAgKHRz dF9RV2ViU2VjdXJpdHlPcmlnaW46OmNsZWFudXApOgorICAgICAgICAodHN0X1FXZWJTZWN1cml0 eU9yaWdpbjo6Y3JlYXRlX2RhdGEpOgorICAgICAgICAodHN0X1FXZWJTZWN1cml0eU9yaWdpbjo6 Y3JlYXRlKToKKyAgICAgICAgKHRzdF9RV2ViU2VjdXJpdHlPcmlnaW46OndoaXRlTGlzdF9kYXRh KToKKyAgICAgICAgKHRzdF9RV2ViU2VjdXJpdHlPcmlnaW46OndoaXRlTGlzdCk6CisgICAgICAg IEFkZGVkIHRlc3RzIGZvciB0aGUgbmV3bHkgYWRkZWQgQVBJcy4KKyAgICAgICAgSW4gYSBmdXR1 cmUgcGF0Y2ggdGVzdCBmcm9tIHRzdF9xd2VicGFnZSB0aGF0IGNvbmNlcm4gc2VjdXJpdHkgb3Jp Z2luIHNob3VsZCBiZSBtb3ZlZCB0byBoZXJlLgorICAgICAgICAqIHRlc3RzL3F3ZWJzZWN1cml0 eW9yaWdpbi90c3RfcXdlYnNlY3VyaXR5b3JpZ2luLnFyYzogQWRkZWQuCisgICAgICAgICogdGVz dHMvdGVzdHMucHJvOgorICAgICAgICBBZGRlZCB0aGUgbmV3IHRlc3RzIGluIHRoZSBkZWZhdWx0 IGJ1aWxkLgorCiAyMDA5LTEyLTE4ICBKb2UgTGlnbWFuICA8am9zZXBoLmxpZ21hbkBub2tpYS5j b20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgS2VubmV0aCBSb2hkZSBDaHJpc3RpYW5zZW4uCklu ZGV4OiBXZWJLaXQvcXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJpdHlvcmlnaW4uY3BwCShyZXZpc2lvbiA1MjMxMykKKysr IFdlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2luLmNwcAkod29ya2luZyBjb3B5KQpAQCAt MzAsMTYgKzMwLDYgQEAKIAogdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiAKLXZvaWQgUVdFQktJ VF9FWFBPUlQgcXRfZHJ0X3doaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oY29uc3QgUVN0cmluZyYg c291cmNlT3JpZ2luLCBjb25zdCBRU3RyaW5nJiBkZXN0aW5hdGlvblByb3RvY29sLCBjb25zdCBR U3RyaW5nJiBkZXN0aW5hdGlvbkhvc3QsIGJvb2wgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMp Ci17Ci0gICAgU2VjdXJpdHlPcmlnaW46OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oKlNlY3Vy aXR5T3JpZ2luOjpjcmVhdGVGcm9tU3RyaW5nKHNvdXJjZU9yaWdpbiksIGRlc3RpbmF0aW9uUHJv dG9jb2wsIGRlc3RpbmF0aW9uSG9zdCwgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpOwotfQot Ci12b2lkIFFXRUJLSVRfRVhQT1JUIHF0X2RydF9yZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMo KQotewotICAgIFNlY3VyaXR5T3JpZ2luOjpyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsK LX0KLQogLyohCiAgICAgXGNsYXNzIFFXZWJTZWN1cml0eU9yaWdpbgogICAgIFxzaW5jZSA0LjUK QEAgLTgwLDYgKzcwLDE1IEBAIFFXZWJTZWN1cml0eU9yaWdpbjo6UVdlYlNlY3VyaXR5T3JpZ2lu KGMKIH0KIAogLyohCisgICAgXHNpbmNlIDQuNworICAgIENvbnN0cnVjdHMgYSBzZWN1cml0eSBv cmlnaW4gZm9yIFxhIHVybC4KKyovCitRV2ViU2VjdXJpdHlPcmlnaW4qIFFXZWJTZWN1cml0eU9y aWdpbjo6Y3JlYXRlKGNvbnN0IFFVcmwmIHVybCkKK3sKKyAgICByZXR1cm4gbmV3IFFXZWJTZWN1 cml0eU9yaWdpbihuZXcgUVdlYlNlY3VyaXR5T3JpZ2luUHJpdmF0ZShTZWN1cml0eU9yaWdpbjo6 Y3JlYXRlRnJvbVN0cmluZyh1cmwudG9TdHJpbmcoKSkuZ2V0KCkpKTsKK307CisKKy8qIQogICAg IEFzc2lnbnMgdGhlIFxhIG90aGVyIHNlY3VyaXR5IG9yaWdpbiB0byB0aGlzLgogKi8KIFFXZWJT ZWN1cml0eU9yaWdpbiYgUVdlYlNlY3VyaXR5T3JpZ2luOjpvcGVyYXRvcj0oY29uc3QgUVdlYlNl Y3VyaXR5T3JpZ2luJiBvdGhlcikKQEAgLTI0OSwzICsyNDgsMzUgQEAgUVN0cmluZ0xpc3QgUVdl YlNlY3VyaXR5T3JpZ2luOjpsb2NhbFNjaAogICAgIH0KICAgICByZXR1cm4gbGlzdDsKIH0KKwor LyohCisgICAgXHNpbmNlIDQuNworICAgIEVtcHRpZXMgYWxsIGN1cnJlbnRseSBkZWZpbmVkIHdo aXRlbGlzdHMgYXNzb2NpYXRlZCB3aXRoIHNlY3VyaXR5IG9yaWdpbnMuCisgICAgXHNhIGFkZFRv V2hpdGVMaXN0KCkKKyovCit2b2lkIFFXZWJTZWN1cml0eU9yaWdpbjo6Y2xlYXJXaGl0ZUxpc3Rz KCkKK3sKKyAgICBTZWN1cml0eU9yaWdpbjo6cmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCk7 Cit9CisKKy8qIQorICAgIFxzaW5jZSA0LjcKKyAgICBBbGxvd3MgcGFnZXMgd2l0aCBcYyB0aGlz IHNlY3VyaXR5IG9yaWdpbiB0byBzZW5kIFhNTEh0dHBSZXF1ZXN0cyAoaW5jbHVkaW5nIFBPU1Rz KSB0byBzaXRlcyAKKyAgICB3aXRoIHRoZSBzYW1lIHNlY3VyaXR5IG9yaWdpbiBhcyBcYSB1cmwg YW5kIHNpdGVzIHdpdGggc2VjdXJpdHkgb3JpZ2lucyB0aGF0IGRpZmZlciBmcm9tIHRoYXQKKyAg ICBvZiBcYSB1cmwgb25seSB0aHJvdWdoIHRoZSBwb3J0IG51bWJlci4KKworICAgIElmIFxhIGlu Y2x1ZGVTdWJEb21haW5zIGlzIHNldCB0byB0cnVlIChkZWZhdWx0IGlzIGZhbHNlKSwgdGhlIGhv c3QgcG9ydGlvbiBvZiBcYSB1cmwgaXMgCisgICAgdHJlYXRlZCBhcyBhIGRvbWFpbiBuYW1lIGFu ZCB0aGUgcGVybWlzc2lvbiB0byBzZW5kIFhNTEh0dHBSZXF1ZXN0cyBpcyBhbHNvIGdyYW50ZWQg Zm9yIHRhcmdldHMKKyAgICB0aGF0IGFyZSBzdWJkb21haW5zIG9mIHRoaXMgZG9tYWluLgorCisg ICAgSWYgdGhlIGhvc3QgcG9ydGlvbiBvZiBcYSB1cmwgaXMgZW1wdHksIHdlYiBwYWdlcyBjb21t aW5nIGZyb20gdGhlIGN1cnJlbnQgc2VjdXJpdHkgb3JpZ2luLCBhcmUgCisgICAgZ3JhbnRlZCB0 aGUgcmlnaHQgdG8gc2VuZCBYTUxIdHRwUmVxdWVzdHMgdG8gYWxsIFVSTHMgdGhhdCB1c2UgdGhl IHNhbWUgc2NoZW1hIGFzIFxhIHVybC4KKworICAgIElmIHRoZSBob3N0IHBvcnRpb24gb2YgXGEg dXJsIGlzIGFuIElQIGFkZHJlc3MgYW5kIGluY2x1ZGVTdWJEb21haW5zIGlzIHRydWUsIHRoZSBi ZWhhdmlvciBpcyB0aGUKKyAgICBzYW1lIGFzIGlmIGluY2x1ZGVTdWJEb21haW5zIGlzIGZhbHNl LCB0aGF0IGlzIHRoZSB0d28gcGFyYWdyYXBocyBhYm92ZSBkbyBub3QgYXBwbHkuCisqLwordm9p ZCBRV2ViU2VjdXJpdHlPcmlnaW46OmFkZFRvV2hpdGVMaXN0KGNvbnN0IFFVcmwmIHVybCwgYm9v bCBpbmNsdWRlU3ViRG9tYWlucykKK3sKKyAgICBTZWN1cml0eU9yaWdpbjo6d2hpdGVMaXN0QWNj ZXNzRnJvbU9yaWdpbigqZC0+b3JpZ2luLmdldCgpLCB1cmwuc2NoZW1lKCksIHVybC5ob3N0KCks IGluY2x1ZGVTdWJEb21haW5zKTsKK30KKwpJbmRleDogV2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJp dHlvcmlnaW4uaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvcXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdp bi5oCShyZXZpc2lvbiA1MjMxMykKKysrIFdlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2lu LmgJKHdvcmtpbmcgY29weSkKQEAgLTQwLDYgKzQwLDcgQEAgcHVibGljOgogICAgIHN0YXRpYyB2 b2lkIGFkZExvY2FsU2NoZW1lKGNvbnN0IFFTdHJpbmcmIHNjaGVtZSk7CiAgICAgc3RhdGljIHZv aWQgcmVtb3ZlTG9jYWxTY2hlbWUoY29uc3QgUVN0cmluZyYgc2NoZW1lKTsKICAgICBzdGF0aWMg UVN0cmluZ0xpc3QgbG9jYWxTY2hlbWVzKCk7CisgICAgc3RhdGljIFFXZWJTZWN1cml0eU9yaWdp biogY3JlYXRlKGNvbnN0IFFVcmwmKTsKIAogICAgIH5RV2ViU2VjdXJpdHlPcmlnaW4oKTsKIApA QCAtNTYsNiArNTcsMTAgQEAgcHVibGljOgogCiAgICAgUVdlYlNlY3VyaXR5T3JpZ2luKGNvbnN0 IFFXZWJTZWN1cml0eU9yaWdpbiYgb3RoZXIpOwogICAgIFFXZWJTZWN1cml0eU9yaWdpbiAmb3Bl cmF0b3I9KGNvbnN0IFFXZWJTZWN1cml0eU9yaWdpbiYgb3RoZXIpOworCisgICAgdm9pZCBhZGRU b1doaXRlTGlzdChjb25zdCBRVXJsJiwgYm9vbCBpbmNsdWRlU3ViRG9tYWlucyA9IGZhbHNlKTsK KyAgICBzdGF0aWMgdm9pZCBjbGVhcldoaXRlTGlzdHMoKTsKKwogcHJpdmF0ZToKICAgICBmcmll bmQgY2xhc3MgUVdlYkRhdGFiYXNlOwogICAgIGZyaWVuZCBjbGFzcyBRV2ViRnJhbWU7CkluZGV4 OiBXZWJLaXQvcXQvdGVzdHMvdGVzdHMucHJvCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9xdC90ZXN0 cy90ZXN0cy5wcm8JKHJldmlzaW9uIDUyMzEzKQorKysgV2ViS2l0L3F0L3Rlc3RzL3Rlc3RzLnBy bwkod29ya2luZyBjb3B5KQpAQCAtMSw0ICsxLDQgQEAKIAogVEVNUExBVEUgPSBzdWJkaXJzCi1T VUJESVJTID0gcXdlYmZyYW1lIHF3ZWJwYWdlIHF3ZWJlbGVtZW50IHFncmFwaGljc3dlYnZpZXcg cXdlYmhpc3RvcnlpbnRlcmZhY2UgcXdlYnZpZXcgcXdlYmhpc3RvcnkgcXdlYmluc3BlY3Rvcgor U1VCRElSUyA9IHF3ZWJmcmFtZSBxd2VicGFnZSBxd2ViZWxlbWVudCBxZ3JhcGhpY3N3ZWJ2aWV3 IHF3ZWJoaXN0b3J5aW50ZXJmYWNlIHF3ZWJ2aWV3IHF3ZWJoaXN0b3J5IHF3ZWJzZWN1cml0eW9y aWdpbiBxd2ViaW5zcGVjdG9yCiBncmVhdGVyVGhhbihRVF9NSU5PUl9WRVJTSU9OLCA0KTogU1VC RElSUyArPSBiZW5jaG1hcmtzL3BhaW50aW5nL3RzdF9wYWludGluZy5wcm8gYmVuY2htYXJrcy9s b2FkaW5nL3RzdF9sb2FkaW5nLnBybwpJbmRleDogV2ViS2l0L3F0L3Rlc3RzL3F3ZWJzZWN1cml0 eW9yaWdpbi9xd2Vic2VjdXJpdHlvcmlnaW4ucHJvCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9xdC90 ZXN0cy9xd2Vic2VjdXJpdHlvcmlnaW4vcXdlYnNlY3VyaXR5b3JpZ2luLnBybwkocmV2aXNpb24g MCkKKysrIFdlYktpdC9xdC90ZXN0cy9xd2Vic2VjdXJpdHlvcmlnaW4vcXdlYnNlY3VyaXR5b3Jp Z2luLnBybwkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxMiBAQAorVEVNUExBVEUgPSBhcHAKK1RB UkdFVCA9IHRzdF9xd2Vic2VjdXJpdHlvcmlnaW4KK2luY2x1ZGUoLi4vLi4vLi4vLi4vV2ViS2l0 LnByaSkKK1NPVVJDRVMgKj0gdHN0X3F3ZWJzZWN1cml0eW9yaWdpbi5jcHAKK1FUICo9IHRlc3Rs aWIgbmV0d29yaworUkVTT1VSQ0VTICo9IHRzdF9xd2Vic2VjdXJpdHlvcmlnaW4ucXJjCitRTUFL RV9SUEFUSERJUiA9ICQkT1VUUFVUX0RJUi9saWIgJCRRTUFLRV9SUEFUSERJUgorCitzeW1iaWFu IHsKKyAgICBUQVJHRVQuVUlEMyA9IDB4QTAwMENBODAKKyAgICBUQVJHRVQuQ0FQQUJJTElUWSA9 IFJlYWRVc2VyRGF0YSBXcml0ZVVzZXJEYXRhCit9CkluZGV4OiBXZWJLaXQvcXQvdGVzdHMvcXdl YnNlY3VyaXR5b3JpZ2luL3Rlc3QuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvcXQvdGVzdHMv cXdlYnNlY3VyaXR5b3JpZ2luL3Rlc3QuaHRtbAkocmV2aXNpb24gMCkKKysrIFdlYktpdC9xdC90 ZXN0cy9xd2Vic2VjdXJpdHlvcmlnaW4vdGVzdC5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsx LDU4IEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4wMS8vRU4i ICJodHRwOi8vd3d3LnczLm9yZy9UUi9odG1sNC9zdHJpY3QuZHRkIj4NCis8aHRtbD4NCisgICAg PGhlYWQ+DQorICAgICAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9 InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIj4NCisgICAgICAgIDx0aXRsZT5RV2ViU2Vj dXJpdHlPcmlnaW4gdGVzdCBwYWdlPC90aXRsZT4NCisgICAgICAgIDxzY3JpcHQgTGFuZ3VhZ2U9 IkphdmFTY3JpcHQiPgorICAgICAgICAgICAgLy8gVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgYnkg dGhlIHRlc3QgcHJvZ3JhbSB0byB2ZXJpZnkgd2hldGhlciBhbiBYSFIgY2FuIGJlIHNlbnQgc3Vj Y2Vzc2Z1bGx5CisgICAgICAgICAgICAvLyB0byB0aGUgdXJsIHBhc3NlZCBpbi4KKyAgICAgICAg ICAgIC8vIFRoZSBmdW5jdGlvbiByZXR1cm5zIHRydWUgaWYgdGhlIHJlcXVlc3Qgd2FzIHN1Y2Nl c3NmdWxseSBzZW50IGFuZCB0aGUgY29udGVudCBvZiB0aGUgcmVzcG9uc2UKKyAgICAgICAgICAg IC8vIGlzIGV4YWN0bHkgIlRlc3QiIGFuZCBmYWxzZSBvdGhlcndpc2UuIFRodXMgdGhlIGZ1bmN0 aW9uIGlzIHRpZ2h0bHkgaW50ZWdyYXRlZCB3aXRoIHRoZSB0ZXN0IGFwcAorICAgICAgICAgICAg Ly8gd2hpY2ggY2F1c2VzIGFueSBzdWNjZXNzZnVsbHkgc3VibWl0dGVkIFhIUiB0byByZXN1bHQg aW4gYSByZXNwb25zZSB0aGF0IGNvbnRhaW5zIGV4YWN0bHkgIlRlc3QiCisgICAgICAgICAgICAv LyByZWdhcmRsZXNzIG9mIHRoZSByZXF1ZXN0ZWQgVVJMLgorICAgICAgICAgICAgLy8gVGhlIHBy b2dyZXNzaW9uIG9mIHRoZSByZXF1ZXN0IGlzIHRyYWNlZCBpbiB0aGUgcGFnZSBmb3IgZGVidWdn aW5nIHB1cnBvc2VzLg0KKyAgICAgICAgICAgIGZ1bmN0aW9uIHJ1blRlc3QodXJsKQ0KKyAgICAg ICAgICAgIHsNCisgICAgICAgICAgICAgICAgdmFyIHJlc3VsdCA9ICIiOw0KKyAgICAgICAgICAg ICAgICBmdW5jdGlvbiB0cmFjZShwb2ludCkNCisgICAgICAgICAgICAgICAgew0KKyAgICAgICAg ICAgICAgICAgICAgdmFyIGVsID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiUCIpOw0KKyAgICAg ICAgICAgICAgICAgICAgZWwuaW5uZXJIVE1MID0gcG9pbnQgKyAiOiBSZXN1bHQgaXM6XCIiICsg cmVzdWx0ICsgIlwiIg0KKyAgICAgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoIkNvbnNvbGUiKS5hcHBlbmRDaGlsZChlbCk7DQorICAgICAgICAgICAgICAgIH0NCisgICAg ICAgICAgICAgICAgdHJ5IHsNCisgICAgICAgICAgICAgICAgICAgIHZhciB4bWxodHRwID0gbmV3 IFhNTEh0dHBSZXF1ZXN0KCk7DQorICAgICAgICAgICAgICAgICAgICB4bWxodHRwLm9wZW4oJ0dF VCcsdXJsLCBmYWxzZSk7DQorICAgICAgICAgICAgICAgICAgICB4bWxodHRwLm9ucmVhZHlzdGF0 ZWNoYW5nZSA9IGZ1bmN0aW9uKCkgeworICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vU3Vj Y2VzcyByZXN1bHRzIGFyZSBsZXNzIHRoYW4gNSBjaGFyYWN0ZXJzIGxvbmcuIEVycm9yIHJlc3Vs dHMgYXJlIGxvbmdlciAoNiBvciBtb3JlKS4NCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg aWYgKHJlc3VsdC5sZW5ndGggPCA1KSB7DQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICByZXN1bHQgPSAiIiArIHhtbGh0dHAucmVhZHlTdGF0ZTsNCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHRyYWNlKCJEb25lMSIpOw0KKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICB9IGVsc2UNCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRyYWNlKCJEb25lMiIp Ow0KKyAgICAgICAgICAgICAgICAgICAgICAgIH07DQorICAgICAgICAgICAgICAgICAgICB4bWxo dHRwLm9uZXJyb3IgPSBmdW5jdGlvbigpIHsNCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg cmVzdWx0ID0gIkZBSUxFRCI7DQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRyYWNlKCJF cnJvciIpOw0KKyAgICAgICAgICAgICAgICAgICAgICAgIH07DQorICAgICAgICAgICAgICAgICAg ICB4bWxodHRwLnNlbmQobnVsbCk7DQorICAgICAgICAgICAgICAgICAgICByZXN1bHQgPSB4bWxo dHRwLnJlc3BvbnNlVGV4dDsNCisgICAgICAgICAgICAgICAgfSBjYXRjaCAoZSkgew0KKyAgICAg ICAgICAgICAgICAgICAgaWYgKHJlc3VsdCA9PSAiIikgew0KKyAgICAgICAgICAgICAgICAgICAg ICAgIHJlc3VsdCA9IGU7DQorICAgICAgICAgICAgICAgICAgICAgICAgdHJhY2UoIkNhdGNoMSIp Ow0KKyAgICAgICAgICAgICAgICAgICAgfSBlbHNlDQorICAgICAgICAgICAgICAgICAgICAgICAg dHJhY2UoIkNhdGNoMiIpOw0KKyAgICAgICAgICAgICAgICB9DQorDQorICAgICAgICAgICAgICAg IHRyYWNlKCJFeGl0Iik7DQorICAgICAgICAgICAgICAgIHJldHVybiByZXN1bHQgPT0gIlRlc3Qi Ow0KKyAgICAgICAgICAgIH0KKyAgICAgICAgPC9zY3JpcHQ+DQorICAgIDwvaGVhZD4NCisgICAg PGJvZHk+CisgICAgICAgIFhIUiB0YXJnZXQgVXJsOjxpbnB1dCBpZD0iVVJMIi8+DQorICAgICAg ICA8aW5wdXQgdHlwZT0iYnV0dG9uIiBvbmNsaWNrPSJqYXZhc2NyaXB0OmFsZXJ0KHJ1blRlc3Qo ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ1VSTCcpLnZhbHVlKSkiIHZhbHVlPSJSdW4gVGVzdCIv Pjxici8+DQorICAgICAgICA8ZGl2IGlkPSJDb25zb2xlIi8+DQorICAgIDwvYm9keT4NCis8L2h0 bWw+DQpJbmRleDogV2ViS2l0L3F0L3Rlc3RzL3F3ZWJzZWN1cml0eW9yaWdpbi90c3RfcXdlYnNl Y3VyaXR5b3JpZ2luLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvcXQvdGVzdHMvcXdlYnNlY3Vy aXR5b3JpZ2luL3RzdF9xd2Vic2VjdXJpdHlvcmlnaW4uY3BwCShyZXZpc2lvbiAwKQorKysgV2Vi S2l0L3F0L3Rlc3RzL3F3ZWJzZWN1cml0eW9yaWdpbi90c3RfcXdlYnNlY3VyaXR5b3JpZ2luLmNw cAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyNTEgQEAKKy8qCisgICAgQ29weXJpZ2h0IChDKSAy MDA5IE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorCisgICAg VGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFu ZC9vcgorICAgIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdl bmVyYWwgUHVibGljCisgICAgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbjsgZWl0aGVyCisgICAgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAo YXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisgICAgVGhpcyBsaWJyYXJ5IGlz IGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgICAgYnV0 IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkg b2YKKyAgICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBP U0UuICBTZWUgdGhlIEdOVQorICAgIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3Ig bW9yZSBkZXRhaWxzLgorCisgICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0 aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICAgIGFsb25nIHdpdGggdGhp cyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisg ICAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0 LCBGaWZ0aCBGbG9vciwKKyAgICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyovCisKKwor I2luY2x1ZGUgPHF3ZWJmcmFtZS5oPgorI2luY2x1ZGUgPHF3ZWJwYWdlLmg+CisjaW5jbHVkZSA8 cXdlYnNlY3VyaXR5b3JpZ2luLmg+CisjaW5jbHVkZSA8cXdlYnZpZXcuaD4KKworI2luY2x1ZGUg PFFEZWJ1Zz4KKyNpbmNsdWRlIDxRTmV0d29ya1JlcGx5PgorI2luY2x1ZGUgPFF0VGVzdD4KKwor Ly9URVNURURfQ0xBU1M9UVdlYlNlY3VyaXR5T3JpZ2luCisvL1RFU1RFRF9GSUxFUz1XZWJLaXQv cXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi4qCisKK2NsYXNzIHRzdF9RV2ViU2VjdXJpdHlPcmln aW4gOiBwdWJsaWMgUU9iamVjdCB7CisgICAgUV9PQkpFQ1QKK3B1YmxpYzoKKyAgICB0c3RfUVdl YlNlY3VyaXR5T3JpZ2luKCk7CisgICAgdmlydHVhbCB+dHN0X1FXZWJTZWN1cml0eU9yaWdpbigp OworCitwcml2YXRlIHNsb3RzOgorICAgIHZvaWQgaW5pdCgpOworICAgIHZvaWQgY2xlYW51cCgp OworICAgIHZvaWQgY3JlYXRlX2RhdGEoKTsKKyAgICB2b2lkIGNyZWF0ZSgpOworICAgIHZvaWQg d2hpdGVMaXN0X2RhdGEoKTsKKyAgICB2b2lkIHdoaXRlTGlzdCgpOworcHJpdmF0ZToKKyAgICBR V2ViVmlldyogbV92aWV3OworICAgIFFXZWJQYWdlKiBtX3BhZ2U7Cit9OworCit0c3RfUVdlYlNl Y3VyaXR5T3JpZ2luOjp0c3RfUVdlYlNlY3VyaXR5T3JpZ2luKCkKK3sKK30KKwordHN0X1FXZWJT ZWN1cml0eU9yaWdpbjo6fnRzdF9RV2ViU2VjdXJpdHlPcmlnaW4oKQoreworfQorCit2b2lkIHRz dF9RV2ViU2VjdXJpdHlPcmlnaW46OmluaXQoKQoreworICAgIG1fdmlldyA9IG5ldyBRV2ViVmll dygpOworICAgIG1fcGFnZSA9IG1fdmlldy0+cGFnZSgpOworfQorCit2b2lkIHRzdF9RV2ViU2Vj dXJpdHlPcmlnaW46OmNsZWFudXAoKQoreworICAgIGRlbGV0ZSBtX3ZpZXc7Cit9CisKK3ZvaWQg dHN0X1FXZWJTZWN1cml0eU9yaWdpbjo6Y3JlYXRlX2RhdGEoKQoreworICAgIFFUZXN0OjphZGRD b2x1bW48UVN0cmluZz4oInVybCIpOworICAgIFFUZXN0OjphZGRDb2x1bW48UVN0cmluZz4oInNj aGVtZSIpOworICAgIFFUZXN0OjphZGRDb2x1bW48UVN0cmluZz4oImhvc3QiKTsKKyAgICBRVGVz dDo6YWRkQ29sdW1uPGludD4oInBvcnQiKTsKKyAgICBRVGVzdDo6bmV3Um93KCJodHRwIikgPDwg Imh0dHA6Ly93d3cuZ29vZ2xlLmNvbSIgPDwgImh0dHAiIDw8ICJ3d3cuZ29vZ2xlLmNvbSIgPDwg MDsKKyAgICBRVGVzdDo6bmV3Um93KCJodHRwU2xhc2giKSA8PCAiaHR0cDovL3d3dy5nb29nbGUu Y29tLyIgPDwgImh0dHAiIDw8ICJ3d3cuZ29vZ2xlLmNvbSIgPDwgMDsKKyAgICBRVGVzdDo6bmV3 Um93KCJodHRwUG9ydFNsYXNoIikgPDwgImh0dHA6Ly93d3cuZ29vZ2xlLmNvbTo4MDgwLyIgPDwg Imh0dHAiIDw8ICJ3d3cuZ29vZ2xlLmNvbSIgPDwgODA4MDsKKyAgICBRVGVzdDo6bmV3Um93KCJo dHRwRGVmUG9ydFNsYXNoIikgPDwgImh0dHA6Ly93d3cuZ29vZ2xlLmNvbTo4MC8iIDw8ICJodHRw IiA8PCAid3d3Lmdvb2dsZS5jb20iIDw8IDA7CisgICAgUVRlc3Q6Om5ld1JvdygiZmlsZSIpIDw8 ICJmaWxlOi8vL2hvbWUvdGVzdC84MDgwLyIgPDwgImZpbGUiIDw8ICIiIDw8IDA7Cit9Cit2b2lk IHRzdF9RV2ViU2VjdXJpdHlPcmlnaW46OmNyZWF0ZSgpCit7CisgICAgUUZFVENIKFFTdHJpbmcs IHVybCk7CisgICAgUUZFVENIKFFTdHJpbmcsIHNjaGVtZSk7CisgICAgUUZFVENIKFFTdHJpbmcs IGhvc3QpOworICAgIFFGRVRDSChpbnQsIHBvcnQpOworCisgICAgUVdlYlNlY3VyaXR5T3JpZ2lu KiB0ZXN0ID0gUVdlYlNlY3VyaXR5T3JpZ2luOjpjcmVhdGUodXJsKTsKKyAgICBRQ09NUEFSRSh0 ZXN0LT5zY2hlbWUoKSwgc2NoZW1lKTsKKyAgICBRQ09NUEFSRSh0ZXN0LT5ob3N0KCksIGhvc3Qp OworICAgIFFDT01QQVJFKHRlc3QtPnBvcnQoKSwgcG9ydCk7Cit9CisKK3ZvaWQgdHN0X1FXZWJT ZWN1cml0eU9yaWdpbjo6d2hpdGVMaXN0X2RhdGEoKQoreworICAgIFFUZXN0OjphZGRDb2x1bW48 UVN0cmluZz4oInNvdXJjZSIpOworICAgIFFUZXN0OjphZGRDb2x1bW48UVN0cmluZz4oInRhcmdl dCIpOworICAgIFFUZXN0OjphZGRDb2x1bW48Ym9vbD4oImluY2x1ZGVTdWJEb21haW5zIik7Cisg ICAgUVRlc3Q6OmFkZENvbHVtbjxRU3RyaW5nPigidGVzdFVybCIpOworICAgIFFUZXN0OjphZGRD b2x1bW48Ym9vbD4oInN1Y2Nlc3NCZWZvcmVBZGQiKTsKKyAgICBRVGVzdDo6YWRkQ29sdW1uPGJv b2w+KCJzdWNjZXNzQWZ0ZXJBZGQiKTsKKyAgICBRVGVzdDo6bmV3Um93KCJzaW1wbGUiKSA8PCAi aHR0cDovL3d3dy5nb29nbGUuY29tL215U3R1ZmYiIDw8ICJodHRwOi8vYWJjLmRlZiIgPDwgZmFs c2UgPDwgImh0dHA6Ly93d3cuZ29vZ2xlLmNvbS9YSFIiIDw8IHRydWUgPDwgdHJ1ZTsKKyAgICBR VGVzdDo6bmV3Um93KCJzaW1wbGVJUCIpIDw8ICJodHRwOi8vMTIzLjEyMy4xMjMuMTMyL215U3R1 ZmYiIDw8ICJodHRwOi8vYWJjLmRlZiIgPDwgZmFsc2UgPDwgImh0dHA6Ly8xMjMuMTIzLjEyMy4x MzIvWEhSIiA8PCB0cnVlIDw8IHRydWU7CisgICAgUVRlc3Q6Om5ld1JvdygiaXBGYWlsIikgPDwg Imh0dHA6Ly8xMjcuMC4wLjEvbXlTdHVmZiIgPDwgImh0dHA6Ly9hYmMuZGVmIiA8PCBmYWxzZSA8 PCAiaHR0cDovL2xvY2FsaG9zdC9YSFIiIDw8IGZhbHNlIDw8IGZhbHNlOworICAgIFFUZXN0Ojpu ZXdSb3coImlwUmV2ZXJzZUZhaWwiKSA8PCAiaHR0cDovL2xvY2FsaG9zdC9teVN0dWZmIiA8PCAi aHR0cDovL2FiYy5kZWYiIDw8IGZhbHNlIDw8ICJodHRwOi8vMTI3LjAuMC4xL1hIUiIgPDwgZmFs c2UgPDwgZmFsc2U7CisgICAgUVRlc3Q6Om5ld1JvdygiaXBSZXZlcnNlRml4ZWQiKSA8PCAiaHR0 cDovL2xvY2FsaG9zdC9teVN0dWZmIiA8PCAiaHR0cDovLzEyNy4wLjAuMTo4MDgwIiA8PCBmYWxz ZSA8PCAiaHR0cDovLzEyNy4wLjAuMS9YSFIiIDw8IGZhbHNlIDw8IHRydWU7CisgICAgUVRlc3Q6 Om5ld1JvdygiaXBOb3RGaXhlZCIpIDw8ICJodHRwOi8vMTMyLjEwMC4xLjEvbXlTdHVmZiIgPDwg Imh0dHA6Ly8qLjAuMC4xOjgwODAiIDw8IGZhbHNlIDw8ICJodHRwOi8vMTI3LjAuMC4xL1hIUiIg PDwgZmFsc2UgPDwgZmFsc2U7CisgICAgUVRlc3Q6Om5ld1JvdygiaXBOb3RGaXhlZFNob3J0Iikg PDwgImh0dHA6Ly8xMzIuMTAwLjEuMS9teVN0dWZmIiA8PCAiaHR0cDovLzAuMC4xOjgwODAiIDw8 IGZhbHNlIDw8ICJodHRwOi8vMTI3LjAuMC4xL1hIUiIgPDwgZmFsc2UgPDwgZmFsc2U7CisgICAg UVRlc3Q6Om5ld1Jvdygic2NoZW1lIikgPDwgImh0dHA6Ly93d3cuZ29vZ2xlLmNvbS9teVN0dWZm IiA8PCAiaHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS8xMjMiIDw8IGZhbHNlIDw8ICJodHRwczovL3d3 dy5nb29nbGUuY29tL215U3VmZiIgPDwgZmFsc2UgPDwgdHJ1ZTsKKyAgICBRVGVzdDo6bmV3Um93 KCJzY2hlbWVGYWlsIikgPDwgImh0dHA6Ly93d3cuZ29vZ2xlLmNvbS9teVN0dWZmIiA8PCAiaHR0 cHM6Ly9nb29nbGUuY29tLzEyMyIgPDwgZmFsc2UgPDwgImh0dHBzOi8vd3d3Lmdvb2dsZS5jb20v bXlTdWZmIiA8PCBmYWxzZSA8PCBmYWxzZTsKKyAgICBRVGVzdDo6bmV3Um93KCJzY2hlbWVTdWJE b20iKSA8PCAiaHR0cDovL3d3dy5nb29nbGUuY29tL215U3R1ZmYiIDw8ICJodHRwczovL2dvb2ds ZS5jb20vMTIzIiA8PCB0cnVlIDw8ICJodHRwczovL3d3dy5nb29nbGUuY29tL215U3VmZiIgPDwg ZmFsc2UgPDwgdHJ1ZTsKKyAgICBRVGVzdDo6bmV3Um93KCJzY2hlbWVTdWJEb21GYWlsIikgPDwg Imh0dHA6Ly93d3cuZ29vZ2xlLmNvbS9teVN0dWZmIiA8PCAiaHR0cHM6Ly9nb29nbGUuY29tLzEy MyIgPDwgdHJ1ZSA8PCAiaHR0cHM6Ly93d3dnb29nbGUuY29tL215U3VmZiIgPDwgZmFsc2UgPDwg ZmFsc2U7CisgICAgUVRlc3Q6Om5ld1Jvdygic2NoZW1lU3ViRG9tIikgPDwgImh0dHA6Ly93d3cu Z29vZ2xlLmNvbS9teVN0dWZmIiA8PCAiaHR0cHM6Ly8vMTIzIiA8PCB0cnVlIDw8ICJodHRwczov L3d3d2dvb2dsZS5vcmcvbXlTdWZmIiA8PCBmYWxzZSA8PCB0cnVlOworICAgIFFUZXN0OjpuZXdS b3coInNjaGVtZVN1YkRvbUZhaWwiKSA8PCAiaHR0cDovL3d3dy5nb29nbGUuY29tL215U3R1ZmYi IDw8ICJodHRwczovLy8xMjMiIDw8IHRydWUgPDwgImZpbGU6Ly8vd3d3Lmdvb2dsZS5vcmcvbXlT dWZmIiA8PCBmYWxzZSA8PCBmYWxzZTsKKyAgICBRVGVzdDo6bmV3Um93KCJob3N0IikgPDwgImh0 dHA6Ly93d3cuZ29vZ2xlLmNvbS9teXN0dWZmIiA8PCAiaHR0cDovL2dvb2dsZS5jb20vMTIzIiA8 PCBmYWxzZSA8PCAiaHR0cDovL2dvb2dsZS5jb20vbXlzdHVmZiIgPDwgZmFsc2UgPDwgdHJ1ZTsK KyAgICBRVGVzdDo6bmV3Um93KCJob3N0RmFpbCIpIDw8ICJodHRwOi8vd3d3Lmdvb2dsZS5jb20v bXlzdHVmZiIgPDwgImh0dHA6Ly9nb29nbGUuY29tLzEyMyIgPDwgZmFsc2UgPDwgImh0dHA6Ly9h YmMuZ29vZ2xlLmNvbS9teXN0dWZmIiA8PCBmYWxzZSA8PCBmYWxzZTsKKyAgICBRVGVzdDo6bmV3 Um93KCJob3N0U3ViRG9tIikgPDwgImh0dHA6Ly93d3cuZ29vZ2xlLmNvbSIgPDwgImh0dHA6Ly9n b29nbGUuY29tIiA8PCB0cnVlIDw8ICJodHRwOi8vYWJjMi5nb29nbGUuY29tIiA8PCBmYWxzZSA8 PCB0cnVlOworICAgIFFUZXN0OjpuZXdSb3coImhvc3RTdWJEb21TdGFyIikgPDwgImh0dHA6Ly93 d3cuZ29vZ2xlLmNvbSIgPDwgImh0dHA6Ly8qLmdvb2dsZS5jb20iIDw8IHRydWUgPDwgImh0dHA6 Ly9hYmMyLmdvb2dsZS5jb20iIDw8IGZhbHNlIDw8IHRydWU7CisgICAgUVRlc3Q6Om5ld1Jvdygi aG9zdFN1YkRvbUZhaWwiKSA8PCAiaHR0cDovL3d3dy5nb29nbGUuY29tIiA8PCAiaHR0cDovL2dv b2dsZS5jb20iIDw8IHRydWUgPDwgImh0dHA6Ly9hYmMyZ29vZ2xlLmNvbSIgPDwgZmFsc2UgPDwg ZmFsc2U7CisgICAgUVRlc3Q6Om5ld1JvdygiaG9zdFN1YkRvbUZhaWxDb3VudHJ5IikgPDwgImh0 dHA6Ly93d3cuZ29vZ2xlLmNvbSIgPDwgImh0dHA6Ly9nb29nbGUuY29tIiA8PCB0cnVlIDw8ICJo dHRwOi8vd3d3Lmdvb2dsZS5jb20udHciIDw8IGZhbHNlIDw8IGZhbHNlOworICAgIFFUZXN0Ojpu ZXdSb3coInBvcnQiKSA8PCAiaHR0cDovL3d3dy5nb29nbGUuY29tOjgwODAiIDw8ICJodHRwOi8v d3d3Lmdvb2dsZS5jb206OTAiIDw8IGZhbHNlIDw8ICJodHRwOi8vd3d3Lmdvb2dsZS5jb206OTAi IDw8IGZhbHNlIDw8IHRydWU7CisgICAgUVRlc3Q6Om5ld1JvdygicG9ydFN1YkRvbSIpIDw8ICJo dHRwOi8vd3d3Lmdvb2dsZS5jb206ODA4MCIgPDwgImh0dHA6Ly9hYmMuY29tOjkwIiA8PCB0cnVl IDw8ICJodHRwOi8veHl6LmFiYy5jb206OTAiIDw8IGZhbHNlIDw8IHRydWU7Cit9CisKKy8qIFRo aXMgY2xhc3MgaW1wbGVtZW50cyBRTmV0d29ya1JlcGx5IGJ5IHJldHVybmluZyBkYXRhIGZyb20g dGhlIFFCdWZmZXIgcGFzc2VkIHRvIHRoZSBjb25zdHJ1Y3RvciByZWdhcmRsZXNzIG9mIHRoZSBy ZXFlc3QgcGFzc2VkIGluIHRvIHRoZSBjb25zdHJ1Y3Rvci4KKyAqIGEgY29weSBvZiB0aGUgUUJ1 ZmZlciBpcyBtYWRlLCBidXQgdGhlIFFCdWZmZXIgZGF0YSBpcyBzaGFyZWQuCisgKiBUaGlzIGNs YXNzIGFsc28gc2V0cyB0aGUgY29udGVudCB0eXBlIHRvIHRleHQvcGxhaW4gdGhlIGNvbnRlbnQg bGVuZ3RoIHRvIHRoZSBwcm9wZXIgdmFsdWUsIHRoZSBIdHRwIHJlc3BvbnNlIGNvZGUgYW5kIHRl eHQgdG8gMjAwIGFuZCBPSyByZXNwZWN0aXZlbHkuCisgKiBUaGUgVXJsIG9mIHRoZSByZXNwb25z ZSBpcyBjb3BpZWQgZnJvbSB0aGUgcmVxdWVzdC4KKyAqCisgKiBUaGlzIGNsYXNzIHdvcmtzIGlu IGNvbmp1bmN0aW9uIHdpdGggQ2FubmVkUmVzcG9uc2VOZXR3b3JrQWNjZXNzTWFuYWdlciB0byBl bmFibGUgdGVzdGluZyBvZiBhbnkgdGFyZ2V0IFVybCByZWdhcmRsZXNzIG9mIHdoZXRoZXIgaXQg aXMgYWNjZXNzaWJsZSBvcgorICogbm90IGluIHRoZSB0ZXN0IGVudmlyb25tZW50LgorICovCitj bGFzcyBDYW5uZWRSZXNwb25zZU5ldHdvcmtSZXBseTogcHVibGljIFFOZXR3b3JrUmVwbHkgewor ICAgIFFfT0JKRUNUCitwdWJsaWM6CisgICAgQ2FubmVkUmVzcG9uc2VOZXR3b3JrUmVwbHkoUU9i amVjdCogcGFyZW50LCBRTmV0d29ya0FjY2Vzc01hbmFnZXI6Ok9wZXJhdGlvbiBvcCwgY29uc3Qg UU5ldHdvcmtSZXF1ZXN0JiByZXEsIGNvbnN0IFFCdWZmZXImIGJvZHkpOiBRTmV0d29ya1JlcGx5 KHBhcmVudCkKKyAgICB7CisgICAgICAgIHNldFJlcXVlc3QocmVxKTsKKyAgICAgICAgc2V0VXJs KHJlcS51cmwoKSk7CisgICAgICAgIHNldE9wZXJhdGlvbihvcCk7CisgICAgICAgIG1fYnVmZmVy LnNldERhdGEoYm9keS5kYXRhKCkpOworICAgICAgICBjb25uZWN0KCZtX2J1ZmZlciwgU0lHTkFM KHJlYWR5UmVhZCgpKSwgU0xPVChlbWl0UmVhZHlSZWFkKCkpKTsKKyAgICAgICAgY29ubmVjdCgm bV9idWZmZXIsIFNJR05BTChyZWFkQ2hhbm5lbEZpbmlzaGVkKCkpLCBTTE9UKGVtaXRSZWFkQ2hh bm5lbEZpbmlzaGVkKCkpKTsKKyAgICAgICAgY29ubmVjdCgmbV9idWZmZXIsIFNJR05BTChyZWFk Q2hhbm5lbEZpbmlzaGVkKCkpLCBTTE9UKGVtaXRSZWFkQ2hhbm5lbEZpbmlzaGVkKCkpKTsKKyAg ICAgICAgbV9idWZmZXIub3BlbihRSU9EZXZpY2U6OlJlYWRPbmx5KTsKKyAgICAgICAgb3BlbihR SU9EZXZpY2U6OlJlYWRPbmx5KTsKKyAgICAgICAgUVRpbWVyOjpzaW5nbGVTaG90KDEwLCB0aGlz LCBTTE9UKHVwZGF0ZSgpKSk7CisgICAgfQorcHJvdGVjdGVkOgorICAgIHFpbnQ2NCByZWFkRGF0 YShjaGFyICogZGF0YSwgcWludDY0IG1heFNpemUpCisgICAgeworICAgICAgICBxaW50NjQgcmVz dWx0ID0gbV9idWZmZXIucmVhZChkYXRhLCBtYXhTaXplKTsKKyAgICAgICAgaWYgKCFtX2J1ZmZl ci5ieXRlc0F2YWlsYWJsZSgpKQorICAgICAgICAgICAgUVRpbWVyOjpzaW5nbGVTaG90KDEwLCB0 aGlzLCBTTE9UKGVtaXRSZWFkQ2hhbm5lbEZpbmlzaGVkKCkpKTsKKyAgICAgICAgcmV0dXJuIHJl c3VsdDsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHFpbnQ2NCBieXRlc0F2YWlsYWJsZSgpIGNvbnN0 CisgICAgeworICAgICAgICByZXR1cm4gbV9idWZmZXIuYnl0ZXNBdmFpbGFibGUoKTsKKyAgICB9 CisKK3ByaXZhdGUgc2xvdHM6CisgICAgdm9pZCBlbWl0UmVhZHlSZWFkKCkKKyAgICB7CisgICAg ICAgIGVtaXQgcmVhZHlSZWFkKCk7CisgICAgfQorCisgICAgdm9pZCBlbWl0UmVhZENoYW5uZWxG aW5pc2hlZCgpCisgICAgeworICAgICAgICBlbWl0IHJlYWRDaGFubmVsRmluaXNoZWQoKTsKKyAg ICAgICAgZW1pdCBmaW5pc2hlZCgpOworICAgIH0KKyAgICB2b2lkIGFib3J0KCkge307CisKKyAg ICB2b2lkIHVwZGF0ZSgpCisgICAgeworICAgICAgICBzZXRIZWFkZXIoUU5ldHdvcmtSZXF1ZXN0 OjpDb250ZW50VHlwZUhlYWRlciwgInRleHQvcGxhaW4iKTsKKyAgICAgICAgc2V0SGVhZGVyKFFO ZXR3b3JrUmVxdWVzdDo6Q29udGVudExlbmd0aEhlYWRlciwgbV9idWZmZXIuc2l6ZSgpKTsKKyAg ICAgICAgc2V0RXJyb3IoUU5ldHdvcmtSZXBseTo6Tm9FcnJvciwgIiIpOworICAgICAgICBzZXRB dHRyaWJ1dGUoUU5ldHdvcmtSZXF1ZXN0OjpIdHRwU3RhdHVzQ29kZUF0dHJpYnV0ZSwgMjAwKTsK KyAgICAgICAgc2V0QXR0cmlidXRlKFFOZXR3b3JrUmVxdWVzdDo6SHR0cFJlYXNvblBocmFzZUF0 dHJpYnV0ZSwgUVN0cmluZygiT2siKS50b0xhdGluMSgpKTsKKyAgICAgICAgZW1pdCBtZXRhRGF0 YUNoYW5nZWQoKTsKKyAgICAgICAgZW1pdCByZWFkeVJlYWQoKTsKKyAgICB9CitwdWJsaWM6Cisg ICAgUUJ1ZmZlciBtX2J1ZmZlcjsKK307CisKKy8qIFRoaXMgY2xhc3MgYWx3YXlzIHJldHVybnMg YSBDYW5uZWRSZXNwb25zZU5ldHdvcmtSZXBseSByZWdhcmRsZXNzIG9mIHRoZSByZXF1ZXN0ZWQg cmVzb3VyY2UuCisgKiBUaGUgQ2FubmVkUmVzcG9uc2VOZXR3b3JrUmVwbHkgaXMgaW5pdGlhbGl6 ZWQgZnJvbSBtX2J1ZmZlciwgdGh1cyBtX2J1ZmZlciBtdXN0IGJlIGluaXRpYWxpemVkCisgKiBh cHByb3ByaWF0ZWx5IGJlZm9yZSByZXF1ZXN0cyBjYW4gYmUgcm91dGVkIHRocm91Z2ggb2JqZWN0 cyBvZiB0aGlzIGNsYXNzLgorICovCitjbGFzcyBDYW5uZWRSZXNwb25zZU5ldHdvcmtBY2Nlc3NN YW5hZ2VyOiBwdWJsaWMgUU5ldHdvcmtBY2Nlc3NNYW5hZ2VyIHsKKyAgICBRX09CSkVDVAorcHJv dGVjdGVkOgorICAgIHZpcnR1YWwgUU5ldHdvcmtSZXBseSogY3JlYXRlUmVxdWVzdChPcGVyYXRp b24gb3AsIGNvbnN0IFFOZXR3b3JrUmVxdWVzdCYgcmVxLCBRSU9EZXZpY2UqIG91dGdvaW5nRGF0 YSA9IDApCisgICAgeworICAgICAgICByZXR1cm4gbmV3IENhbm5lZFJlc3BvbnNlTmV0d29ya1Jl cGx5KHRoaXMsIG9wLCByZXEsICptX2J1ZmZlcik7CisgICAgfTsKK3B1YmxpYzoKKyAgICBRQnVm ZmVyKiBtX2J1ZmZlcjsKK307CisKKy8vIFRoaXMgaXMgdGhlIGJvZHkgb2YgdGhlIGNhbm5lZCBy ZXNwb25zZSB1c2VkIGZvciBhbGwgVXJsIGFuZCB0ZXN0ZWQgZm9yIGJ5IHRoZSBydW5UZXN0IGZ1 bmN0aW9uIGluIHRlc3QuaHRtbC4KKy8vIElmIHRoZSB2YWx1ZSBpcyBjaGFuZ2VkIHJ1blRlc3Qg aW4gdGVzdC5odG1sIG5lZWRzIHRvIGJlIGNoYW5nZWQgYWNjb3JkaW5nbHkuCitzdGF0aWMgY29u c3QgY2hhciBjYW5uZWRSZXNwb25zZVtdID0gIlRlc3QiOworCit2b2lkIHRzdF9RV2ViU2VjdXJp dHlPcmlnaW46OndoaXRlTGlzdCgpCit7CisgICAgUUZFVENIKFFTdHJpbmcsIHNvdXJjZSk7Cisg ICAgUUZFVENIKFFTdHJpbmcsIHRhcmdldCk7CisgICAgUUZFVENIKGJvb2wsIGluY2x1ZGVTdWJE b21haW5zKTsKKyAgICBRRkVUQ0goUVN0cmluZywgdGVzdFVybCk7CisgICAgUUZFVENIKGJvb2ws IHN1Y2Nlc3NCZWZvcmVBZGQpOworICAgIFFGRVRDSChib29sLCBzdWNjZXNzQWZ0ZXJBZGQpOwor CisgICAgLy8gTWFrZSBzdXJlIHRoYXQgYWxsIHdoaXRlbGlzdHMgYXJlIGVtcHR5LgorICAgIFFX ZWJTZWN1cml0eU9yaWdpbjo6Y2xlYXJXaGl0ZUxpc3RzKCk7CisKKyAgICAvLyBJbml0aWFsaXpl IHRoZSBjYW5uZWQgcmVzcG9uc2UgbWVjaGFuaXNtLgorICAgIENhbm5lZFJlc3BvbnNlTmV0d29y a0FjY2Vzc01hbmFnZXIgbWFuYWdlcjsKKyAgICBRQnVmZmVyIGJ1ZmZlcjsKKyAgICBidWZmZXIu c2V0RGF0YShjYW5uZWRSZXNwb25zZSwgc2l6ZW9mKGNhbm5lZFJlc3BvbnNlKS0xKTsKKyAgICBt YW5hZ2VyLm1fYnVmZmVyID0gJmJ1ZmZlcjsKKworICAgIC8vIExvYWQgdGhlIEphdmFTY3JpcHQg cG9ydGlvbiBvZiB0aGUgdGVzdCBmcm9tIGEgcmVzb3VyY2UuCisgICAgUUZpbGUgdGVzdFBhZ2VG aWxlKCI6L3Rlc3QuaHRtbCIpOworICAgIFFWRVJJRlkodGVzdFBhZ2VGaWxlLm9wZW4oUUlPRGV2 aWNlOjpSZWFkT25seSkpOworICAgIHVjaGFyKiB0ZXN0UGFnZSA9IHRlc3RQYWdlRmlsZS5tYXAo MCwgdGVzdFBhZ2VGaWxlLnNpemUoKSk7CisgICAgUVZFUklGWSh0ZXN0UGFnZSk7CisgICAgLy8g TG9hZGluZyB0aGUgdGVzdFBhZ2UgYW5kIGFzc2lnbmluZyBpdCB0aGUgc291cmNlIFVSTC4KKyAg ICBtX3ZpZXctPnNldEh0bWwoUVN0cmluZygoY29uc3QgY2hhciopdGVzdFBhZ2UpLCBRVXJsKHNv dXJjZSkpOworICAgIC8vIFNldHRpbmcgdXAgdGhlIENhbm5lZFJlc3BvbnNlTmV0d29ya0FjY2Vz c01hbmFnZXIgaGVyZSB0byBtYWtlIHN1cmUgdGhhdCBpdCBkb2VzIG5vdCBpbnRlcmZlcmUgd2l0 aCB0aGUgcGFnZSBsb2FkaW5nLgorICAgIG1fdmlldy0+cGFnZSgpLT5zZXROZXR3b3JrQWNjZXNz TWFuYWdlcigmbWFuYWdlcik7CisgICAgUVN0cmluZyB0ZXN0SlM9InJ1blRlc3QoXCIiICsgdGVz dFVybCArICJcIikiOworICAgIC8vIFJ1bm5pbmcgdGhlIGJlZm9yZSB0ZXN0CisgICAgUUNPTVBB UkUobV92aWV3LT5wYWdlKCktPm1haW5GcmFtZSgpLT5ldmFsdWF0ZUphdmFTY3JpcHQodGVzdEpT KSwgUVZhcmlhbnQoc3VjY2Vzc0JlZm9yZUFkZCkpOworICAgIC8vIFNldHRpbmcgdXAgYW5kIHJ1 bm5pbmcgdGhlIGFmdGVyIHRlc3QKKyAgICBRV2ViU2VjdXJpdHlPcmlnaW4gc291cmNlT3JpZ2lu ID0gbV92aWV3LT5wYWdlKCktPm1haW5GcmFtZSgpLT5zZWN1cml0eU9yaWdpbigpOworICAgIHNv dXJjZU9yaWdpbi5hZGRUb1doaXRlTGlzdCh0YXJnZXQsIGluY2x1ZGVTdWJEb21haW5zKTsKKyAg ICBRQ09NUEFSRShtX3ZpZXctPnBhZ2UoKS0+bWFpbkZyYW1lKCktPmV2YWx1YXRlSmF2YVNjcmlw dCh0ZXN0SlMpLCBRVmFyaWFudChzdWNjZXNzQWZ0ZXJBZGQpKTsKKyAgICAvLyBDbGVhbmluZyB1 cCB0aGUgd2hpdGVsaXN0IGFuZCBydW5uaW5nIHRoZSBhZnRlciB0ZXN0LgorICAgIFFXZWJTZWN1 cml0eU9yaWdpbjo6Y2xlYXJXaGl0ZUxpc3RzKCk7CisgICAgUUNPTVBBUkUobV92aWV3LT5wYWdl KCktPm1haW5GcmFtZSgpLT5ldmFsdWF0ZUphdmFTY3JpcHQodGVzdEpTKSwgUVZhcmlhbnQoc3Vj Y2Vzc0JlZm9yZUFkZCkpOworICAgIG1fdmlldy0+cGFnZSgpLT5zZXROZXR3b3JrQWNjZXNzTWFu YWdlcigwKTsKK30KKworUVRFU1RfTUFJTih0c3RfUVdlYlNlY3VyaXR5T3JpZ2luKQorI2luY2x1 ZGUgInRzdF9xd2Vic2VjdXJpdHlvcmlnaW4ubW9jIgpJbmRleDogV2ViS2l0L3F0L3Rlc3RzL3F3 ZWJzZWN1cml0eW9yaWdpbi90c3RfcXdlYnNlY3VyaXR5b3JpZ2luLnFyYwo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXQvcXQvdGVzdHMvcXdlYnNlY3VyaXR5b3JpZ2luL3RzdF9xd2Vic2VjdXJpdHlvcmln aW4ucXJjCShyZXZpc2lvbiAwKQorKysgV2ViS2l0L3F0L3Rlc3RzL3F3ZWJzZWN1cml0eW9yaWdp bi90c3RfcXdlYnNlY3VyaXR5b3JpZ2luLnFyYwkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw2IEBA Cis8IURPQ1RZUEUgUkNDPjxSQ0MgdmVyc2lvbj0iMS4wIj4KKzxxcmVzb3VyY2U+CisgICAgPGZp bGU+dGVzdC5odG1sPC9maWxlPgorPC9xcmVzb3VyY2U+Cis8L1JDQz4KKwpJbmRleDogV2ViS2l0 VG9vbHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0NoYW5nZUxvZwkocmV2 aXNpb24gNTIzMTMpCisrKyBXZWJLaXRUb29scy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAg LTEsMyArMSwxNiBAQAorMjAwOS0xMi0xOCAgQ2Fyb2wgU3phYm8gIDxjYXJvbC5zemFib0Bub2tp YS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg UVdlYlZpZXc6IEltcG9zc2libGUgdG8gbWFrZSBYTUxIdHRwUmVxdWVzdCBmcm9tIGxvY2FsbHkg c3RvcmVkIEhUTUwgcGFnZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MzE4NzUKKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3F0L0R1bXBSZW5kZXJU cmVlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkR1bXBSZW5kZXJUcmVlOjpyZXNldFRvQ29uc2lz dGVudFN0YXRlQmVmb3JlVGVzdGluZyk6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvcXQvTGF5 b3V0VGVzdENvbnRyb2xsZXJRdC5jcHA6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6 d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbik6CisgICAgICAgIENoYW5nZWQgdG8gdXNlIHRoZSBu b3cgb2ZmaWNpYWwgd2hpdGVsaXN0IEFQSSBpbnN0ZWFkIG9mIHRoZSBmb3JtZXIgaGlkZGVuIG9u ZS4KKwogMjAwOS0xMi0xNyAgU2FtIFdlaW5pZyAgPHNhbUB3ZWJraXQub3JnPgogCiAgICAgICAg IFJldmlld2VkIGJ5IE1hcmsgUm93ZS4KSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L3F0L0R1bXBSZW5kZXJUcmVlUXQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL3F0L0R1bXBSZW5kZXJUcmVlUXQuY3BwCShyZXZpc2lvbiA1MjMxMykKKysrIFdl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3F0L0R1bXBSZW5kZXJUcmVlUXQuY3BwCSh3b3JraW5n IGNvcHkpCkBAIC03NCw3ICs3NCw2IEBAIGV4dGVybiB2b2lkIHF0X2R1bXBfc2V0X2FjY2VwdHNf ZWRpdGluZygKIGV4dGVybiB2b2lkIHF0X2R1bXBfZnJhbWVfbG9hZGVyKGJvb2wgYik7CiBleHRl cm4gdm9pZCBxdF9kcnRfY2xlYXJGcmFtZU5hbWUoUVdlYkZyYW1lKiBxRnJhbWUpOwogZXh0ZXJu IHZvaWQgcXRfZHJ0X292ZXJ3cml0ZVBsdWdpbkRpcmVjdG9yaWVzKCk7Ci1leHRlcm4gdm9pZCBx dF9kcnRfcmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCk7CiBleHRlcm4gYm9vbCBxdF9kcnRf aGFzRG9jdW1lbnRFbGVtZW50KFFXZWJGcmFtZSogcUZyYW1lKTsKIAogbmFtZXNwYWNlIFdlYkNv cmUgewpAQCAtNDA4LDcgKzQwNyw3IEBAIHZvaWQgRHVtcFJlbmRlclRyZWU6OnJlc2V0VG9Db25z aXN0ZW50U3QKICAgICBXb3JrUXVldWU6OnNoYXJlZCgpLT5jbGVhcigpOwogICAgIFdvcmtRdWV1 ZTo6c2hhcmVkKCktPnNldEZyb3plbihmYWxzZSk7CiAKLSAgICBxdF9kcnRfcmVzZXRPcmlnaW5B Y2Nlc3NXaGl0ZUxpc3RzKCk7CisgICAgUVdlYlNlY3VyaXR5T3JpZ2luOjpjbGVhcldoaXRlTGlz dHMoKTsKIAogICAgIFFMb2NhbGU6OnNldERlZmF1bHQoUUxvY2FsZTo6YygpKTsKICAgICBzZXRs b2NhbGUoTENfQUxMLCAiIik7CkluZGV4OiBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9M YXlvdXRUZXN0Q29udHJvbGxlclF0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0LmNwcAkocmV2aXNpb24gNTIzMTMp CisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9xdC9MYXlvdXRUZXN0Q29udHJvbGxlclF0 LmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDIsNyArNDIsNiBAQCBleHRlcm4gYm9vbCBxdF9kcnRf cGF1c2VUcmFuc2l0aW9uT2ZQcm9wCiBleHRlcm4gYm9vbCBxdF9kcnRfcGF1c2VTVkdBbmltYXRp b24oUVdlYkZyYW1lKiwgY29uc3QgUVN0cmluZyYgYW5pbWF0aW9uSWQsIGRvdWJsZSB0aW1lLCBj b25zdCBRU3RyaW5nJiBlbGVtZW50SWQpOwogZXh0ZXJuIGludCBxdF9kcnRfbnVtYmVyT2ZBY3Rp dmVBbmltYXRpb25zKFFXZWJGcmFtZSopOwogCi1leHRlcm4gdm9pZCBxdF9kcnRfd2hpdGVMaXN0 QWNjZXNzRnJvbU9yaWdpbihjb25zdCBRU3RyaW5nJiBzb3VyY2VPcmlnaW4sIGNvbnN0IFFTdHJp bmcmIGRlc3RpbmF0aW9uUHJvdG9jb2wsIGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0aW9uSG9zdCwg Ym9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7CiBleHRlcm4gUVN0cmluZyBxdF9kcnRf Y291bnRlclZhbHVlRm9yRWxlbWVudEJ5SWQoUVdlYkZyYW1lKiBxRnJhbWUsIGNvbnN0IFFTdHJp bmcmIGlkKTsKIAogTGF5b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRlc3RDb250cm9sbGVyKFdl YkNvcmU6OkR1bXBSZW5kZXJUcmVlKiBkcnQpCkBAIC0zNDUsNyArMzQ0LDEyIEBAIHZvaWQgTGF5 b3V0VGVzdENvbnRyb2xsZXI6OmNsZWFyQWxsRGF0YWIKIAogdm9pZCBMYXlvdXRUZXN0Q29udHJv bGxlcjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihjb25zdCBRU3RyaW5nJiBzb3VyY2VPcmln aW4sIGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0aW9uUHJvdG9jb2wsIGNvbnN0IFFTdHJpbmcmIGRl c3RpbmF0aW9uSG9zdCwgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucykKIHsKLSAgICBx dF9kcnRfd2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihzb3VyY2VPcmlnaW4sIGRlc3RpbmF0aW9u UHJvdG9jb2wsIGRlc3RpbmF0aW9uSG9zdCwgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpOwor ICAgIFFXZWJTZWN1cml0eU9yaWdpbiogc291cmNlID0gUVdlYlNlY3VyaXR5T3JpZ2luOjpjcmVh dGUoc291cmNlT3JpZ2luKTsKKyAgICBRVXJsIHVybDsKKyAgICB1cmwuc2V0U2NoZW1lKGRlc3Rp bmF0aW9uUHJvdG9jb2wpOworICAgIHVybC5zZXRIb3N0KFFTdHJpbmcoZGVzdGluYXRpb25Ib3N0 KS5yZXBsYWNlKCIqLiIsIiIpKTsKKyAgICBzb3VyY2UtPmFkZFRvV2hpdGVMaXN0KHVybCwgYWxs b3dEZXN0aW5hdGlvblN1YmRvbWFpbnMpOworICAgIGRlbGV0ZSBzb3VyY2U7CiB9CiAKIHZvaWQg TGF5b3V0VGVzdENvbnRyb2xsZXI6OndhaXRGb3JQb2xpY3lEZWxlZ2F0ZSgpCg== 47601 2010-01-28 03:15:50 -0800 2010-01-29 07:55:09 -0800 Initial patch of proposed API bug-31875-20100128121548.patch text/plain 7511 hausmann ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9PcmlnaW5BY2Nlc3NFbnRyeS5oIGIvV2ViQ29yZS9w YWdlL09yaWdpbkFjY2Vzc0VudHJ5LmgKaW5kZXggNzY3ZDc1Zi4uMDhmMTNiNiAxMDA2NDQKLS0t IGEvV2ViQ29yZS9wYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmgKKysrIGIvV2ViQ29yZS9wYWdlL09y aWdpbkFjY2Vzc0VudHJ5LmgKQEAgLTQ4LDYgKzQ4LDEwIEBAIHB1YmxpYzoKICAgICBPcmlnaW5B Y2Nlc3NFbnRyeShjb25zdCBTdHJpbmcmIHByb3RvY29sLCBjb25zdCBTdHJpbmcmIGhvc3QsIFN1 YmRvbWFpblNldHRpbmcpOwogICAgIGJvb2wgbWF0Y2hlc09yaWdpbihjb25zdCBTZWN1cml0eU9y aWdpbiYpIGNvbnN0OwogICAgIAorICAgIFN1YmRvbWFpblNldHRpbmcgc3ViZG9tYWluU2V0dGlu ZygpIGNvbnN0IHsgcmV0dXJuIG1fc3ViZG9tYWluU2V0dGluZ3M7IH0KKyAgICBTdHJpbmcgcHJv dG9jb2woKSBjb25zdCB7IHJldHVybiBtX3Byb3RvY29sOyB9CisgICAgU3RyaW5nIGhvc3QoKSBj b25zdCB7IHJldHVybiBtX2hvc3Q7IH0KKwogcHJpdmF0ZToKICAgICBTdHJpbmcgbV9wcm90b2Nv bDsKICAgICBTdHJpbmcgbV9ob3N0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5 T3JpZ2luLmNwcCBiL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5jcHAKaW5kZXggYjJhMWM4 OS4uNjVlNjZkMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmNwcAor KysgYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uY3BwCkBAIC0zMiwxNCArMzIsMTIgQEAK ICNpbmNsdWRlICJDU3RyaW5nLmgiCiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNsdWRlICJL VVJMLmgiCi0jaW5jbHVkZSAiT3JpZ2luQWNjZXNzRW50cnkuaCIKICNpbmNsdWRlIDx3dGYvU3Rk TGliRXh0cmFzLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogc3RhdGljIFNlY3VyaXR5T3Jp Z2luOjpMb2NhbExvYWRQb2xpY3kgbG9jYWxMb2FkUG9saWN5ID0gU2VjdXJpdHlPcmlnaW46OkFs bG93TG9jYWxMb2Fkc0ZvckxvY2FsT25seTsKIAotdHlwZWRlZiBWZWN0b3I8T3JpZ2luQWNjZXNz RW50cnk+IE9yaWdpbkFjY2Vzc1doaXRlTGlzdDsKIHR5cGVkZWYgSGFzaE1hcDxTdHJpbmcsIE9y aWdpbkFjY2Vzc1doaXRlTGlzdCo+IE9yaWdpbkFjY2Vzc01hcDsKIAogc3RhdGljIE9yaWdpbkFj Y2Vzc01hcCYgb3JpZ2luQWNjZXNzTWFwKCkKQEAgLTUxMiw2ICs1MTAsMTYgQEAgYm9vbCBTZWN1 cml0eU9yaWdpbjo6YWxsb3dTdWJzdGl0dXRlRGF0YUFjY2Vzc1RvTG9jYWwoKQogICAgIHJldHVy biBsb2NhbExvYWRQb2xpY3kgIT0gU2VjdXJpdHlPcmlnaW46OkFsbG93TG9jYWxMb2Fkc0Zvckxv Y2FsT25seTsKIH0KIAorT3JpZ2luQWNjZXNzV2hpdGVMaXN0KiBTZWN1cml0eU9yaWdpbjo6d2hp dGVMaXN0Rm9yT3JpZ2luKGNvbnN0IFN0cmluZyYgb3JpZ2luLCBib29sIGNyZWF0ZUlmTm90RXhp c3RpbmcpCit7CisgICAgT3JpZ2luQWNjZXNzV2hpdGVMaXN0KiBsaXN0ID0gb3JpZ2luQWNjZXNz TWFwKCkuZ2V0KG9yaWdpbik7CisgICAgaWYgKCFsaXN0KSB7CisgICAgICAgIGxpc3QgPSBuZXcg T3JpZ2luQWNjZXNzV2hpdGVMaXN0OworICAgICAgICBvcmlnaW5BY2Nlc3NNYXAoKS5zZXQob3Jp Z2luLCBsaXN0KTsKKyAgICB9CisgICAgcmV0dXJuIGxpc3Q7Cit9CisKIHZvaWQgU2VjdXJpdHlP cmlnaW46OndoaXRlTGlzdEFjY2Vzc0Zyb21PcmlnaW4oY29uc3QgU2VjdXJpdHlPcmlnaW4mIHNv dXJjZU9yaWdpbiwgY29uc3QgU3RyaW5nJiBkZXN0aW5hdGlvblByb3RvY29sLCBjb25zdCBTdHJp bmcmIGRlc3RpbmF0aW9uRG9tYWlucywgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucykK IHsKICAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOwpAQCAtNTIwLDE0ICs1MjgsOSBAQCB2b2lk IFNlY3VyaXR5T3JpZ2luOjp3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKGNvbnN0IFNlY3VyaXR5 T3JpZ2luJiBzb3VyY2VPcmlnaQogICAgICAgICByZXR1cm47CiAKICAgICBTdHJpbmcgc291cmNl U3RyaW5nID0gc291cmNlT3JpZ2luLnRvU3RyaW5nKCk7Ci0gICAgT3JpZ2luQWNjZXNzV2hpdGVM aXN0KiBsaXN0ID0gb3JpZ2luQWNjZXNzTWFwKCkuZ2V0KHNvdXJjZVN0cmluZyk7Ci0gICAgaWYg KCFsaXN0KSB7Ci0gICAgICAgIGxpc3QgPSBuZXcgT3JpZ2luQWNjZXNzV2hpdGVMaXN0OwotICAg ICAgICBvcmlnaW5BY2Nlc3NNYXAoKS5zZXQoc291cmNlU3RyaW5nLCBsaXN0KTsKLSAgICB9Cisg ICAgT3JpZ2luQWNjZXNzV2hpdGVMaXN0KiBsaXN0ID0gd2hpdGVMaXN0Rm9yT3JpZ2luKHNvdXJj ZVN0cmluZywgLypjcmVhdGVJZk5vdEV4aXN0aW5nKi8gdHJ1ZSk7CiAgICAgbGlzdC0+YXBwZW5k KE9yaWdpbkFjY2Vzc0VudHJ5KGRlc3RpbmF0aW9uUHJvdG9jb2wsIGRlc3RpbmF0aW9uRG9tYWlu cywgYWxsb3dEZXN0aW5hdGlvblN1YmRvbWFpbnMgPyBPcmlnaW5BY2Nlc3NFbnRyeTo6QWxsb3dT dWJkb21haW5zIDogT3JpZ2luQWNjZXNzRW50cnk6OkRpc2FsbG93U3ViZG9tYWlucykpOwogfQot CiB2b2lkIFNlY3VyaXR5T3JpZ2luOjpyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKQogewog ICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvU2Vj dXJpdHlPcmlnaW4uaCBiL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCmluZGV4IDcxNjgx ZDcuLjVlOTIxMzAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCisr KyBiL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oCkBAIC0zNSwxMiArMzUsMTQgQEAKICNp bmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CiAKICNpbmNsdWRlICJGcmFtZUxvYWRlclR5cGVzLmgi CisjaW5jbHVkZSAiT3JpZ2luQWNjZXNzRW50cnkuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVN0cmlu Zy5oIgogI2luY2x1ZGUgIlN0cmluZ0hhc2guaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiB0 eXBlZGVmIEhhc2hTZXQ8U3RyaW5nLCBDYXNlRm9sZGluZ0hhc2g+IFVSTFNjaGVtZXNNYXA7Cit0 eXBlZGVmIFZlY3RvcjxPcmlnaW5BY2Nlc3NFbnRyeT4gT3JpZ2luQWNjZXNzV2hpdGVMaXN0Owog CiBjbGFzcyBEb2N1bWVudDsKIGNsYXNzIEtVUkw7CkBAIC0xODYsNiArMTg4LDcgQEAgcHVibGlj OgogICAgIHN0YXRpYyB2b2lkIHJlZ2lzdGVyVVJMU2NoZW1lQXNOb0FjY2Vzcyhjb25zdCBTdHJp bmcmKTsKICAgICBzdGF0aWMgYm9vbCBzaG91bGRUcmVhdFVSTFNjaGVtZUFzTm9BY2Nlc3MoY29u c3QgU3RyaW5nJik7CiAKKyAgICBzdGF0aWMgT3JpZ2luQWNjZXNzV2hpdGVMaXN0KiB3aGl0ZUxp c3RGb3JPcmlnaW4oY29uc3QgU3RyaW5nJiBvcmlnaW4sIGJvb2wgY3JlYXRlSWZOb3RFeGlzdGlu ZyA9IGZhbHNlKTsKICAgICBzdGF0aWMgdm9pZCB3aGl0ZUxpc3RBY2Nlc3NGcm9tT3JpZ2luKGNv bnN0IFNlY3VyaXR5T3JpZ2luJiBzb3VyY2VPcmlnaW4sIGNvbnN0IFN0cmluZyYgZGVzdGluYXRp b25Qcm90b2NvbCwgY29uc3QgU3RyaW5nJiBkZXN0aW5hdGlvbkRvbWFpbnMsIGJvb2wgYWxsb3dE ZXN0aW5hdGlvblN1YmRvbWFpbnMpOwogICAgIHN0YXRpYyB2b2lkIHJlc2V0T3JpZ2luQWNjZXNz V2hpdGVMaXN0cygpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJzZWN1cml0eW9y aWdpbi5jcHAgYi9XZWJLaXQvcXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5jcHAKaW5kZXggNmMy NmJkNy4uZTI4ZWQwZCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJpdHlvcmln aW4uY3BwCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2luLmNwcApAQCAtNDUs NiArNDUsMjUgQEAgdm9pZCBRV0VCS0lUX0VYUE9SVCBxdF9kcnRfc2V0RG9tYWluUmVsYXhhdGlv bkZvcmJpZGRlbkZvclVSTFNjaGVtZShib29sIGZvcmJpZGQKICAgICBTZWN1cml0eU9yaWdpbjo6 c2V0RG9tYWluUmVsYXhhdGlvbkZvcmJpZGRlbkZvclVSTFNjaGVtZShmb3JiaWRkZW4sIHNjaGVt ZSk7CiB9CiAKK1FXZWJTZWN1cml0eU9yaWdpbjo6QWNjZXNzRW50cnk6OkFjY2Vzc0VudHJ5KCkK KyAgICA6IG1fYWxsb3dTdWJEb21haW5zKGZhbHNlKQorICAgICwgZCgwKQoreworfQorCitRV2Vi U2VjdXJpdHlPcmlnaW46OkFjY2Vzc0VudHJ5OjpBY2Nlc3NFbnRyeShjb25zdCBRU3RyaW5nJiBk ZXN0aW5hdGlvbikKKyAgICA6IG1fYWxsb3dTdWJEb21haW5zKGZhbHNlKQorICAgICwgZCgwKQor eworICAgIFJlZlB0cjxTZWN1cml0eU9yaWdpbj4gZGVzdCA9IFNlY3VyaXR5T3JpZ2luOjpjcmVh dGVGcm9tU3RyaW5nKGRlc3RpbmF0aW9uKTsKKyAgICBtX2RvbWFpbiA9IGRlc3QtPmhvc3QoKTsK KyAgICBtX3NjaGVtZSA9IGRlc3QtPnByb3RvY29sKCk7Cit9CisKK1FXZWJTZWN1cml0eU9yaWdp bjo6QWNjZXNzRW50cnk6On5BY2Nlc3NFbnRyeSgpCit7Cit9CisKIC8qIQogICAgIFxjbGFzcyBR V2ViU2VjdXJpdHlPcmlnaW4KICAgICBcc2luY2UgNC41CkBAIC05Myw2ICsxMTIsNDIgQEAgUVdl YlNlY3VyaXR5T3JpZ2luJiBRV2ViU2VjdXJpdHlPcmlnaW46Om9wZXJhdG9yPShjb25zdCBRV2Vi U2VjdXJpdHlPcmlnaW4mIG90aGUKICAgICByZXR1cm4gKnRoaXM7CiB9CiAKK1FMaXN0PFFXZWJT ZWN1cml0eU9yaWdpbjo6QWNjZXNzRW50cnk+IFFXZWJTZWN1cml0eU9yaWdpbjo6Y3Jvc3NPcmln aW5BY2Nlc3NMaXN0KGNvbnN0IFFTdHJpbmcmIG9yaWdpbikKK3sKKyAgICBPcmlnaW5BY2Nlc3NX aGl0ZUxpc3QqIGxpc3QgPSBTZWN1cml0eU9yaWdpbjo6d2hpdGVMaXN0Rm9yT3JpZ2luKG9yaWdp biwgLypjcmVhdGVJZk5vdEV4aXN0aW5nKi9mYWxzZSk7CisgICAgUUxpc3Q8UVdlYlNlY3VyaXR5 T3JpZ2luOjpBY2Nlc3NFbnRyeT4gYWNjZXNzTGlzdDsKKworICAgIGlmICghbGlzdCkKKyAgICAg ICAgcmV0dXJuIGFjY2Vzc0xpc3Q7CisKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbGlz dC0+c2l6ZSgpOyArK2kpIHsKKyAgICAgICAgT3JpZ2luQWNjZXNzRW50cnkmIGVudHJ5ID0gKCps aXN0KVtpXTsKKworICAgICAgICBRV2ViU2VjdXJpdHlPcmlnaW46OkFjY2Vzc0VudHJ5IHF0RW50 cnk7CisgICAgICAgIHF0RW50cnkuc2V0QWxsb3dTdWJEb21haW5zKGVudHJ5LnN1YmRvbWFpblNl dHRpbmcoKSA9PSBPcmlnaW5BY2Nlc3NFbnRyeTo6QWxsb3dTdWJkb21haW5zKTsKKyAgICAgICAg cXRFbnRyeS5zZXREb21haW4oZW50cnkuaG9zdCgpKTsKKyAgICAgICAgcXRFbnRyeS5zZXRTY2hl bWUoZW50cnkucHJvdG9jb2woKSk7CisgICAgICAgIGFjY2Vzc0xpc3QuYXBwZW5kKHF0RW50cnkp OworICAgIH0KKworICAgIHJldHVybiBhY2Nlc3NMaXN0OworfQorCit2b2lkIFFXZWJTZWN1cml0 eU9yaWdpbjo6c2V0Q3Jvc3NPcmlnaW5BY2Nlc3NMaXN0KGNvbnN0IFFTdHJpbmcmIG9yaWdpbiwg Y29uc3QgUUxpc3Q8UVdlYlNlY3VyaXR5T3JpZ2luOjpBY2Nlc3NFbnRyeT4mIGVudHJpZXMpCit7 CisgICAgT3JpZ2luQWNjZXNzV2hpdGVMaXN0KiBsaXN0ID0gU2VjdXJpdHlPcmlnaW46OndoaXRl TGlzdEZvck9yaWdpbihvcmlnaW4sIC8qY3JlYXRlSWZOb3RFeGlzdGluZyovdHJ1ZSk7CisgICAg bGlzdC0+Y2xlYXIoKTsKKyAgICBmb3JlYWNoIChjb25zdCBRV2ViU2VjdXJpdHlPcmlnaW46OkFj Y2Vzc0VudHJ5JiBlbnRyeSwgZW50cmllcykKKyAgICAgICAgbGlzdC0+YXBwZW5kKE9yaWdpbkFj Y2Vzc0VudHJ5KGVudHJ5LnNjaGVtZSgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgZW50cnkuZG9tYWluKCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBlbnRyeS5hbGxvd1N1YkRvbWFpbnMoKSA/IE9yaWdpbkFjY2Vzc0VudHJ5OjpBbGxv d1N1YmRvbWFpbnMgOiBPcmlnaW5BY2Nlc3NFbnRyeTo6RGlzYWxsb3dTdWJkb21haW5zKSk7Cit9 CisKK3ZvaWQgUVdlYlNlY3VyaXR5T3JpZ2luOjpjbGVhckNyb3NzT3JpZ2luQWNjZXNzTGlzdHMo KQoreworICAgIFNlY3VyaXR5T3JpZ2luOjpyZXNldE9yaWdpbkFjY2Vzc1doaXRlTGlzdHMoKTsK K30KKwogLyohCiAgICAgUmV0dXJucyB0aGUgc2NoZW1lIGRlZmluaW5nIHRoZSBzZWN1cml0eSBv cmlnaW4uCiAqLwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJpdHlvcmlnaW4u aCBiL1dlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2luLmgKaW5kZXggMTZmOGJjMS4uYTQx ZDdjOCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJpdHlvcmlnaW4uaAorKysg Yi9XZWJLaXQvcXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5oCkBAIC00MSw2ICs0MSwzMyBAQCBw dWJsaWM6CiAgICAgc3RhdGljIHZvaWQgcmVtb3ZlTG9jYWxTY2hlbWUoY29uc3QgUVN0cmluZyYg c2NoZW1lKTsKICAgICBzdGF0aWMgUVN0cmluZ0xpc3QgbG9jYWxTY2hlbWVzKCk7CiAKKyAgICBj bGFzcyBBY2Nlc3NFbnRyeSB7CisgICAgcHVibGljOgorICAgICAgICBBY2Nlc3NFbnRyeSgpOwor ICAgICAgICBBY2Nlc3NFbnRyeShjb25zdCBRU3RyaW5nJiBkZXN0aW5hdGlvbik7CisgICAgICAg IH5BY2Nlc3NFbnRyeSgpOworCisgICAgICAgIFFTdHJpbmcgZG9tYWluKCkgY29uc3QgeyByZXR1 cm4gbV9kb21haW47IH0KKyAgICAgICAgdm9pZCBzZXREb21haW4oY29uc3QgUVN0cmluZyYgZG9t YWluKSB7IG1fZG9tYWluID0gZG9tYWluOyB9CisKKyAgICAgICAgUVN0cmluZyBzY2hlbWUoKSBj b25zdCB7IHJldHVybiBtX3NjaGVtZTsgfQorICAgICAgICB2b2lkIHNldFNjaGVtZShjb25zdCBR U3RyaW5nJiBzY2hlbWUpIHsgbV9zY2hlbWUgPSBzY2hlbWU7IH0KKworICAgICAgICBib29sIGFs bG93U3ViRG9tYWlucygpIGNvbnN0IHsgcmV0dXJuIG1fYWxsb3dTdWJEb21haW5zOyB9CisgICAg ICAgIHZvaWQgc2V0QWxsb3dTdWJEb21haW5zKGJvb2wgYWxsb3cpIHsgbV9hbGxvd1N1YkRvbWFp bnMgPSBhbGxvdzsgfQorCisgICAgcHJpdmF0ZToKKyAgICAgICAgUVN0cmluZyBtX2RvbWFpbjsK KyAgICAgICAgUVN0cmluZyBtX3NjaGVtZTsKKyAgICAgICAgYm9vbCBtX2FsbG93U3ViRG9tYWlu czsKKyAgICAgICAgc3RydWN0IFByaXZhdGU7CisgICAgICAgIFByaXZhdGUqIGQ7CisgICAgfTsK KworICAgIHN0YXRpYyBRTGlzdDxRV2ViU2VjdXJpdHlPcmlnaW46OkFjY2Vzc0VudHJ5PiBjcm9z c09yaWdpbkFjY2Vzc0xpc3QoY29uc3QgUVN0cmluZyYgb3JpZ2luKTsKKyAgICBzdGF0aWMgdm9p ZCBzZXRDcm9zc09yaWdpbkFjY2Vzc0xpc3QoY29uc3QgUVN0cmluZyYgb3JpZ2luLCBjb25zdCBR TGlzdDxRV2ViU2VjdXJpdHlPcmlnaW46OkFjY2Vzc0VudHJ5PiYgZW50cmllcyk7CisgICAgc3Rh dGljIHZvaWQgY2xlYXJDcm9zc09yaWdpbkFjY2Vzc0xpc3RzKCk7CisKICAgICB+UVdlYlNlY3Vy aXR5T3JpZ2luKCk7CiAKICAgICBRU3RyaW5nIHNjaGVtZSgpIGNvbnN0Owo= 47717 2010-01-29 07:55:09 -0800 2010-01-29 07:55:09 -0800 Updated patch with createIfNotExisting bug fixed patch.txt text/plain 7534 hausmann ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9PcmlnaW5BY2Nlc3NFbnRyeS5oIGIvV2ViQ29yZS9w YWdlL09yaWdpbkFjY2Vzc0VudHJ5LmgKaW5kZXggNzY3ZDc1Zi4uMDhmMTNiNiAxMDA2NDQKLS0t IGEvV2ViQ29yZS9wYWdlL09yaWdpbkFjY2Vzc0VudHJ5LmgKKysrIGIvV2ViQ29yZS9wYWdlL09y aWdpbkFjY2Vzc0VudHJ5LmgKQEAgLTQ4LDYgKzQ4LDEwIEBAIHB1YmxpYzoKICAgICBPcmlnaW5B Y2Nlc3NFbnRyeShjb25zdCBTdHJpbmcmIHByb3RvY29sLCBjb25zdCBTdHJpbmcmIGhvc3QsIFN1 YmRvbWFpblNldHRpbmcpOwogICAgIGJvb2wgbWF0Y2hlc09yaWdpbihjb25zdCBTZWN1cml0eU9y aWdpbiYpIGNvbnN0OwogICAgIAorICAgIFN1YmRvbWFpblNldHRpbmcgc3ViZG9tYWluU2V0dGlu ZygpIGNvbnN0IHsgcmV0dXJuIG1fc3ViZG9tYWluU2V0dGluZ3M7IH0KKyAgICBTdHJpbmcgcHJv dG9jb2woKSBjb25zdCB7IHJldHVybiBtX3Byb3RvY29sOyB9CisgICAgU3RyaW5nIGhvc3QoKSBj b25zdCB7IHJldHVybiBtX2hvc3Q7IH0KKwogcHJpdmF0ZToKICAgICBTdHJpbmcgbV9wcm90b2Nv bDsKICAgICBTdHJpbmcgbV9ob3N0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5 T3JpZ2luLmNwcCBiL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5jcHAKaW5kZXggYjJhMWM4 OS4uYjY0ZmMzYiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmNwcAor KysgYi9XZWJDb3JlL3BhZ2UvU2VjdXJpdHlPcmlnaW4uY3BwCkBAIC0zMiwxNCArMzIsMTIgQEAK ICNpbmNsdWRlICJDU3RyaW5nLmgiCiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNsdWRlICJL VVJMLmgiCi0jaW5jbHVkZSAiT3JpZ2luQWNjZXNzRW50cnkuaCIKICNpbmNsdWRlIDx3dGYvU3Rk TGliRXh0cmFzLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogc3RhdGljIFNlY3VyaXR5T3Jp Z2luOjpMb2NhbExvYWRQb2xpY3kgbG9jYWxMb2FkUG9saWN5ID0gU2VjdXJpdHlPcmlnaW46OkFs bG93TG9jYWxMb2Fkc0ZvckxvY2FsT25seTsKIAotdHlwZWRlZiBWZWN0b3I8T3JpZ2luQWNjZXNz RW50cnk+IE9yaWdpbkFjY2Vzc1doaXRlTGlzdDsKIHR5cGVkZWYgSGFzaE1hcDxTdHJpbmcsIE9y aWdpbkFjY2Vzc1doaXRlTGlzdCo+IE9yaWdpbkFjY2Vzc01hcDsKIAogc3RhdGljIE9yaWdpbkFj Y2Vzc01hcCYgb3JpZ2luQWNjZXNzTWFwKCkKQEAgLTUxMiw2ICs1MTAsMTYgQEAgYm9vbCBTZWN1 cml0eU9yaWdpbjo6YWxsb3dTdWJzdGl0dXRlRGF0YUFjY2Vzc1RvTG9jYWwoKQogICAgIHJldHVy biBsb2NhbExvYWRQb2xpY3kgIT0gU2VjdXJpdHlPcmlnaW46OkFsbG93TG9jYWxMb2Fkc0Zvckxv Y2FsT25seTsKIH0KIAorT3JpZ2luQWNjZXNzV2hpdGVMaXN0KiBTZWN1cml0eU9yaWdpbjo6d2hp dGVMaXN0Rm9yT3JpZ2luKGNvbnN0IFN0cmluZyYgb3JpZ2luLCBib29sIGNyZWF0ZUlmTm90RXhp c3RpbmcpCit7CisgICAgT3JpZ2luQWNjZXNzV2hpdGVMaXN0KiBsaXN0ID0gb3JpZ2luQWNjZXNz TWFwKCkuZ2V0KG9yaWdpbik7CisgICAgaWYgKCFsaXN0ICYmIGNyZWF0ZUlmTm90RXhpc3Rpbmcp IHsKKyAgICAgICAgbGlzdCA9IG5ldyBPcmlnaW5BY2Nlc3NXaGl0ZUxpc3Q7CisgICAgICAgIG9y aWdpbkFjY2Vzc01hcCgpLnNldChvcmlnaW4sIGxpc3QpOworICAgIH0KKyAgICByZXR1cm4gbGlz dDsKK30KKwogdm9pZCBTZWN1cml0eU9yaWdpbjo6d2hpdGVMaXN0QWNjZXNzRnJvbU9yaWdpbihj b25zdCBTZWN1cml0eU9yaWdpbiYgc291cmNlT3JpZ2luLCBjb25zdCBTdHJpbmcmIGRlc3RpbmF0 aW9uUHJvdG9jb2wsIGNvbnN0IFN0cmluZyYgZGVzdGluYXRpb25Eb21haW5zLCBib29sIGFsbG93 RGVzdGluYXRpb25TdWJkb21haW5zKQogewogICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CkBA IC01MjAsMTQgKzUyOCw5IEBAIHZvaWQgU2VjdXJpdHlPcmlnaW46OndoaXRlTGlzdEFjY2Vzc0Zy b21PcmlnaW4oY29uc3QgU2VjdXJpdHlPcmlnaW4mIHNvdXJjZU9yaWdpCiAgICAgICAgIHJldHVy bjsKIAogICAgIFN0cmluZyBzb3VyY2VTdHJpbmcgPSBzb3VyY2VPcmlnaW4udG9TdHJpbmcoKTsK LSAgICBPcmlnaW5BY2Nlc3NXaGl0ZUxpc3QqIGxpc3QgPSBvcmlnaW5BY2Nlc3NNYXAoKS5nZXQo c291cmNlU3RyaW5nKTsKLSAgICBpZiAoIWxpc3QpIHsKLSAgICAgICAgbGlzdCA9IG5ldyBPcmln aW5BY2Nlc3NXaGl0ZUxpc3Q7Ci0gICAgICAgIG9yaWdpbkFjY2Vzc01hcCgpLnNldChzb3VyY2VT dHJpbmcsIGxpc3QpOwotICAgIH0KKyAgICBPcmlnaW5BY2Nlc3NXaGl0ZUxpc3QqIGxpc3QgPSB3 aGl0ZUxpc3RGb3JPcmlnaW4oc291cmNlU3RyaW5nLCAvKmNyZWF0ZUlmTm90RXhpc3RpbmcqLyB0 cnVlKTsKICAgICBsaXN0LT5hcHBlbmQoT3JpZ2luQWNjZXNzRW50cnkoZGVzdGluYXRpb25Qcm90 b2NvbCwgZGVzdGluYXRpb25Eb21haW5zLCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyA/IE9y aWdpbkFjY2Vzc0VudHJ5OjpBbGxvd1N1YmRvbWFpbnMgOiBPcmlnaW5BY2Nlc3NFbnRyeTo6RGlz YWxsb3dTdWJkb21haW5zKSk7CiB9Ci0KIHZvaWQgU2VjdXJpdHlPcmlnaW46OnJlc2V0T3JpZ2lu QWNjZXNzV2hpdGVMaXN0cygpCiB7CiAgICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKZGlmZiAt LWdpdCBhL1dlYkNvcmUvcGFnZS9TZWN1cml0eU9yaWdpbi5oIGIvV2ViQ29yZS9wYWdlL1NlY3Vy aXR5T3JpZ2luLmgKaW5kZXggNzE2ODFkNy4uNWU5MjEzMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9w YWdlL1NlY3VyaXR5T3JpZ2luLmgKKysrIGIvV2ViQ29yZS9wYWdlL1NlY3VyaXR5T3JpZ2luLmgK QEAgLTM1LDEyICszNSwxNCBAQAogI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KIAogI2luY2x1 ZGUgIkZyYW1lTG9hZGVyVHlwZXMuaCIKKyNpbmNsdWRlICJPcmlnaW5BY2Nlc3NFbnRyeS5oIgog I2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCiAjaW5jbHVkZSAiU3RyaW5nSGFzaC5oIgogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKIHR5cGVkZWYgSGFzaFNldDxTdHJpbmcsIENhc2VGb2xkaW5n SGFzaD4gVVJMU2NoZW1lc01hcDsKK3R5cGVkZWYgVmVjdG9yPE9yaWdpbkFjY2Vzc0VudHJ5PiBP cmlnaW5BY2Nlc3NXaGl0ZUxpc3Q7CiAKIGNsYXNzIERvY3VtZW50OwogY2xhc3MgS1VSTDsKQEAg LTE4Niw2ICsxODgsNyBAQCBwdWJsaWM6CiAgICAgc3RhdGljIHZvaWQgcmVnaXN0ZXJVUkxTY2hl bWVBc05vQWNjZXNzKGNvbnN0IFN0cmluZyYpOwogICAgIHN0YXRpYyBib29sIHNob3VsZFRyZWF0 VVJMU2NoZW1lQXNOb0FjY2Vzcyhjb25zdCBTdHJpbmcmKTsKIAorICAgIHN0YXRpYyBPcmlnaW5B Y2Nlc3NXaGl0ZUxpc3QqIHdoaXRlTGlzdEZvck9yaWdpbihjb25zdCBTdHJpbmcmIG9yaWdpbiwg Ym9vbCBjcmVhdGVJZk5vdEV4aXN0aW5nID0gZmFsc2UpOwogICAgIHN0YXRpYyB2b2lkIHdoaXRl TGlzdEFjY2Vzc0Zyb21PcmlnaW4oY29uc3QgU2VjdXJpdHlPcmlnaW4mIHNvdXJjZU9yaWdpbiwg Y29uc3QgU3RyaW5nJiBkZXN0aW5hdGlvblByb3RvY29sLCBjb25zdCBTdHJpbmcmIGRlc3RpbmF0 aW9uRG9tYWlucywgYm9vbCBhbGxvd0Rlc3RpbmF0aW9uU3ViZG9tYWlucyk7CiAgICAgc3RhdGlj IHZvaWQgcmVzZXRPcmlnaW5BY2Nlc3NXaGl0ZUxpc3RzKCk7CiAKZGlmZiAtLWdpdCBhL1dlYktp dC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2luLmNwcCBiL1dlYktpdC9xdC9BcGkvcXdlYnNlY3Vy aXR5b3JpZ2luLmNwcAppbmRleCA2YzI2YmQ3Li5lMjhlZDBkIDEwMDY0NAotLS0gYS9XZWJLaXQv cXQvQXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2Vic2Vj dXJpdHlvcmlnaW4uY3BwCkBAIC00NSw2ICs0NSwyNSBAQCB2b2lkIFFXRUJLSVRfRVhQT1JUIHF0 X2RydF9zZXREb21haW5SZWxheGF0aW9uRm9yYmlkZGVuRm9yVVJMU2NoZW1lKGJvb2wgZm9yYmlk ZAogICAgIFNlY3VyaXR5T3JpZ2luOjpzZXREb21haW5SZWxheGF0aW9uRm9yYmlkZGVuRm9yVVJM U2NoZW1lKGZvcmJpZGRlbiwgc2NoZW1lKTsKIH0KIAorUVdlYlNlY3VyaXR5T3JpZ2luOjpBY2Nl c3NFbnRyeTo6QWNjZXNzRW50cnkoKQorICAgIDogbV9hbGxvd1N1YkRvbWFpbnMoZmFsc2UpCisg ICAgLCBkKDApCit7Cit9CisKK1FXZWJTZWN1cml0eU9yaWdpbjo6QWNjZXNzRW50cnk6OkFjY2Vz c0VudHJ5KGNvbnN0IFFTdHJpbmcmIGRlc3RpbmF0aW9uKQorICAgIDogbV9hbGxvd1N1YkRvbWFp bnMoZmFsc2UpCisgICAgLCBkKDApCit7CisgICAgUmVmUHRyPFNlY3VyaXR5T3JpZ2luPiBkZXN0 ID0gU2VjdXJpdHlPcmlnaW46OmNyZWF0ZUZyb21TdHJpbmcoZGVzdGluYXRpb24pOworICAgIG1f ZG9tYWluID0gZGVzdC0+aG9zdCgpOworICAgIG1fc2NoZW1lID0gZGVzdC0+cHJvdG9jb2woKTsK K30KKworUVdlYlNlY3VyaXR5T3JpZ2luOjpBY2Nlc3NFbnRyeTo6fkFjY2Vzc0VudHJ5KCkKK3sK K30KKwogLyohCiAgICAgXGNsYXNzIFFXZWJTZWN1cml0eU9yaWdpbgogICAgIFxzaW5jZSA0LjUK QEAgLTkzLDYgKzExMiw0MiBAQCBRV2ViU2VjdXJpdHlPcmlnaW4mIFFXZWJTZWN1cml0eU9yaWdp bjo6b3BlcmF0b3I9KGNvbnN0IFFXZWJTZWN1cml0eU9yaWdpbiYgb3RoZQogICAgIHJldHVybiAq dGhpczsKIH0KIAorUUxpc3Q8UVdlYlNlY3VyaXR5T3JpZ2luOjpBY2Nlc3NFbnRyeT4gUVdlYlNl Y3VyaXR5T3JpZ2luOjpjcm9zc09yaWdpbkFjY2Vzc0xpc3QoY29uc3QgUVN0cmluZyYgb3JpZ2lu KQoreworICAgIE9yaWdpbkFjY2Vzc1doaXRlTGlzdCogbGlzdCA9IFNlY3VyaXR5T3JpZ2luOjp3 aGl0ZUxpc3RGb3JPcmlnaW4ob3JpZ2luLCAvKmNyZWF0ZUlmTm90RXhpc3RpbmcqL2ZhbHNlKTsK KyAgICBRTGlzdDxRV2ViU2VjdXJpdHlPcmlnaW46OkFjY2Vzc0VudHJ5PiBhY2Nlc3NMaXN0Owor CisgICAgaWYgKCFsaXN0KQorICAgICAgICByZXR1cm4gYWNjZXNzTGlzdDsKKworICAgIGZvciAo dW5zaWduZWQgaSA9IDA7IGkgPCBsaXN0LT5zaXplKCk7ICsraSkgeworICAgICAgICBPcmlnaW5B Y2Nlc3NFbnRyeSYgZW50cnkgPSAoKmxpc3QpW2ldOworCisgICAgICAgIFFXZWJTZWN1cml0eU9y aWdpbjo6QWNjZXNzRW50cnkgcXRFbnRyeTsKKyAgICAgICAgcXRFbnRyeS5zZXRBbGxvd1N1YkRv bWFpbnMoZW50cnkuc3ViZG9tYWluU2V0dGluZygpID09IE9yaWdpbkFjY2Vzc0VudHJ5OjpBbGxv d1N1YmRvbWFpbnMpOworICAgICAgICBxdEVudHJ5LnNldERvbWFpbihlbnRyeS5ob3N0KCkpOwor ICAgICAgICBxdEVudHJ5LnNldFNjaGVtZShlbnRyeS5wcm90b2NvbCgpKTsKKyAgICAgICAgYWNj ZXNzTGlzdC5hcHBlbmQocXRFbnRyeSk7CisgICAgfQorCisgICAgcmV0dXJuIGFjY2Vzc0xpc3Q7 Cit9CisKK3ZvaWQgUVdlYlNlY3VyaXR5T3JpZ2luOjpzZXRDcm9zc09yaWdpbkFjY2Vzc0xpc3Qo Y29uc3QgUVN0cmluZyYgb3JpZ2luLCBjb25zdCBRTGlzdDxRV2ViU2VjdXJpdHlPcmlnaW46OkFj Y2Vzc0VudHJ5PiYgZW50cmllcykKK3sKKyAgICBPcmlnaW5BY2Nlc3NXaGl0ZUxpc3QqIGxpc3Qg PSBTZWN1cml0eU9yaWdpbjo6d2hpdGVMaXN0Rm9yT3JpZ2luKG9yaWdpbiwgLypjcmVhdGVJZk5v dEV4aXN0aW5nKi90cnVlKTsKKyAgICBsaXN0LT5jbGVhcigpOworICAgIGZvcmVhY2ggKGNvbnN0 IFFXZWJTZWN1cml0eU9yaWdpbjo6QWNjZXNzRW50cnkmIGVudHJ5LCBlbnRyaWVzKQorICAgICAg ICBsaXN0LT5hcHBlbmQoT3JpZ2luQWNjZXNzRW50cnkoZW50cnkuc2NoZW1lKCksCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS5kb21haW4oKSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVudHJ5LmFsbG93U3ViRG9tYWlucygpID8g T3JpZ2luQWNjZXNzRW50cnk6OkFsbG93U3ViZG9tYWlucyA6IE9yaWdpbkFjY2Vzc0VudHJ5OjpE aXNhbGxvd1N1YmRvbWFpbnMpKTsKK30KKwordm9pZCBRV2ViU2VjdXJpdHlPcmlnaW46OmNsZWFy Q3Jvc3NPcmlnaW5BY2Nlc3NMaXN0cygpCit7CisgICAgU2VjdXJpdHlPcmlnaW46OnJlc2V0T3Jp Z2luQWNjZXNzV2hpdGVMaXN0cygpOworfQorCiAvKiEKICAgICBSZXR1cm5zIHRoZSBzY2hlbWUg ZGVmaW5pbmcgdGhlIHNlY3VyaXR5IG9yaWdpbi4KICovCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQv QXBpL3F3ZWJzZWN1cml0eW9yaWdpbi5oIGIvV2ViS2l0L3F0L0FwaS9xd2Vic2VjdXJpdHlvcmln aW4uaAppbmRleCAxNmY4YmMxLi5hNDFkN2M4IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3 ZWJzZWN1cml0eW9yaWdpbi5oCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYnNlY3VyaXR5b3JpZ2lu LmgKQEAgLTQxLDYgKzQxLDMzIEBAIHB1YmxpYzoKICAgICBzdGF0aWMgdm9pZCByZW1vdmVMb2Nh bFNjaGVtZShjb25zdCBRU3RyaW5nJiBzY2hlbWUpOwogICAgIHN0YXRpYyBRU3RyaW5nTGlzdCBs b2NhbFNjaGVtZXMoKTsKIAorICAgIGNsYXNzIEFjY2Vzc0VudHJ5IHsKKyAgICBwdWJsaWM6Cisg ICAgICAgIEFjY2Vzc0VudHJ5KCk7CisgICAgICAgIEFjY2Vzc0VudHJ5KGNvbnN0IFFTdHJpbmcm IGRlc3RpbmF0aW9uKTsKKyAgICAgICAgfkFjY2Vzc0VudHJ5KCk7CisKKyAgICAgICAgUVN0cmlu ZyBkb21haW4oKSBjb25zdCB7IHJldHVybiBtX2RvbWFpbjsgfQorICAgICAgICB2b2lkIHNldERv bWFpbihjb25zdCBRU3RyaW5nJiBkb21haW4pIHsgbV9kb21haW4gPSBkb21haW47IH0KKworICAg ICAgICBRU3RyaW5nIHNjaGVtZSgpIGNvbnN0IHsgcmV0dXJuIG1fc2NoZW1lOyB9CisgICAgICAg IHZvaWQgc2V0U2NoZW1lKGNvbnN0IFFTdHJpbmcmIHNjaGVtZSkgeyBtX3NjaGVtZSA9IHNjaGVt ZTsgfQorCisgICAgICAgIGJvb2wgYWxsb3dTdWJEb21haW5zKCkgY29uc3QgeyByZXR1cm4gbV9h bGxvd1N1YkRvbWFpbnM7IH0KKyAgICAgICAgdm9pZCBzZXRBbGxvd1N1YkRvbWFpbnMoYm9vbCBh bGxvdykgeyBtX2FsbG93U3ViRG9tYWlucyA9IGFsbG93OyB9CisKKyAgICBwcml2YXRlOgorICAg ICAgICBRU3RyaW5nIG1fZG9tYWluOworICAgICAgICBRU3RyaW5nIG1fc2NoZW1lOworICAgICAg ICBib29sIG1fYWxsb3dTdWJEb21haW5zOworICAgICAgICBzdHJ1Y3QgUHJpdmF0ZTsKKyAgICAg ICAgUHJpdmF0ZSogZDsKKyAgICB9OworCisgICAgc3RhdGljIFFMaXN0PFFXZWJTZWN1cml0eU9y aWdpbjo6QWNjZXNzRW50cnk+IGNyb3NzT3JpZ2luQWNjZXNzTGlzdChjb25zdCBRU3RyaW5nJiBv cmlnaW4pOworICAgIHN0YXRpYyB2b2lkIHNldENyb3NzT3JpZ2luQWNjZXNzTGlzdChjb25zdCBR U3RyaW5nJiBvcmlnaW4sIGNvbnN0IFFMaXN0PFFXZWJTZWN1cml0eU9yaWdpbjo6QWNjZXNzRW50 cnk+JiBlbnRyaWVzKTsKKyAgICBzdGF0aWMgdm9pZCBjbGVhckNyb3NzT3JpZ2luQWNjZXNzTGlz dHMoKTsKKwogICAgIH5RV2ViU2VjdXJpdHlPcmlnaW4oKTsKIAogICAgIFFTdHJpbmcgc2NoZW1l KCkgY29uc3Q7Cg==