95697 2012-09-03 12:10:48 -0700 [WebKit2] [GTK] Add API for controlling the user agent 2012-09-24 07:45:44 -0700 1 1 1 Unclassified WebKit WebKitGTK 523.x (Safari 3) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 95745 1 mrobinson mrobinson cgarcia gustavo gyuyoung.kim rakuco thierry.reding webkit.review.bot oldest_to_newest 710736 0 mrobinson 2012-09-03 12:10:48 -0700 Choosing a default user agent and changing it is essential for a proper web engine embedding experience. This bug tracks adding that API to WebKit2GTK+. 710741 1 161944 mrobinson 2012-09-03 12:34:13 -0700 Created attachment 161944 Patch 710879 2 161944 cgarcia 2012-09-04 01:19:52 -0700 Comment on attachment 161944 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=161944&action=review I think this patch could be split in two, one to move the code to webcore and update WebKit1, and another one adding wk2 api. Regarding the wk2 patch, the logic to set user agent and application name is duplicated, because it's already in WebPageProxy. I think we could have two different properties: user-agent and application-name-for-user-agent. The view connects to notify signal for both properties and simply calls WKPageSetCustomUserAgent() for user-agent and WKPageSetApplicationNameForUserAgent() for application-name-for-user-agent. > Source/WebKit2/ChangeLog:11 > + in the lirary. lirary -> library > Source/WebCore/platform/gtk/UserAgentGtk.cpp:62 > + uaOSVersion = "Intel Mac OS X"; Extra space here after = > Source/WebCore/platform/gtk/UserAgentGtk.cpp:64 > + uaOSVersion = "PPC Mac OS X"; Ditto. > Source/WebCore/platform/gtk/UserAgentGtk.cpp:94 > + return String::format("%s %s/%s", staticUA.utf8().data(), > + applicationName.isEmpty() ? "WebKitGTK+" : applicationName.utf8().data(), uaVersion.data()); We could use g_get_application_name() or g_get_prgname() since I guess we don't want the localized name here, and maybe fallback to WebKitGTK+ if g_get_prgname() returns NULL. > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:51 > + CString userAgentString; userAgentString sounds a bit redundant, it's a CString, maybe just userAgent? > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:1023 > + * WebKitSettings:user-agent Trailing : missing here. > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:1031 > + * If this property is set to the empty string or NULL, it will revert to the standard NULL -> %NULL > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2597 > + * Get the #WebKitSettings::user-agent property. :: is for signals, for properties use : > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2613 > + * @user_agent: The new custom user agent string Add (allow-none) annotation. And you should comment here that when passing a NULL user agent, sets the default one. > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2615 > + * Set the #WebKitSettings::user-agent property. #WebKitSettings::user-agent -> #WebKitSettings:user-agent > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2622 > + CString newUserAgent = (!userAgent || !strlen(userAgent)) ? WebCore::standardUserAgent("").utf8() : userAgent; (userAgent && userAgent[0] != '\0') ? userAgent : WebCore::standardUserAgent("").utf8() To avoid using strlen(). > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2627 > + priv->userAgentString = newUserAgent; > + g_object_notify(G_OBJECT(settings), "user-agent"); This doesn't actually change the user agent, you should call WKPageSetCustomUserAgent() with the new user agent, so the web view should connect to notify::user-agent to update its user agent when the setting changes. > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2633 > + * @application_name: The application name used to create the user agent. I don't think we should allow NULL for the application name here > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2635 > + * Set the #WebKitSettings::user-agent property by forming the standard user #WebKitSettings::user-agent -> #WebKitSettings:user-agent > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2637 > + * string or null, this method sets the user agent property to the standard user null -> %NULL > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2638 > + * agent string with the application name "WebKitGTK+." That's already the default user agent when this method is not called, so I think we should enforce a non null value for the application name to actually change the user agent based on the application name. > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2641 > +void webkit_settings_set_user_agent_with_application_name(WebKitSettings* settings, const char* applicationName) webkit_settings_set_default_user_agent_with_application_name()? > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2651 > + WebKitSettingsPrivate* priv = settings->priv; > + CString newUserAgent = WebCore::standardUserAgent(String::fromUTF8(applicationName)).utf8(); > + if (newUserAgent == priv->userAgentString) > + return; > + > + priv->userAgentString = newUserAgent; > + g_object_notify(G_OBJECT(settings), "user-agent"); We could have a helper function to share this code with webkit_settings_set_user_agent(). set_user_agent (WebKitSettings* settings, const char* userAgent, const char* applicationName) webkit_settings_set_user_agent would call set_user_agent(settings, userAgent, 0) and webkit_settings_set_default_user_agent_with_application_name would call set_user_agent(settings, 0, applicationName); > Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitSettings.cpp:264 > + g_assert(g_strstr_len(defaultUserAgent.data(), -1, "Safari")); > + g_assert(g_strstr_len(defaultUserAgent.data(), -1, "Chromium")); > + g_assert(g_strstr_len(defaultUserAgent.data(), -1, "Chrome")); Why not passing defaultUserAgent.length() instead of -1 > Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitSettings.cpp:268 > + const char* funkyUserAgent = "Funky!"; > + webkit_settings_set_user_agent(settings.get(), funkyUserAgent); > + g_assert_cmpstr(funkyUserAgent, ==, webkit_settings_get_user_agent(settings.get())); It would be nice to test also that setting a NULL user agent returns the default user agent > Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitSettings.cpp:277 > + g_assert_cmpint(strlen(webCatUserAgent.data()), ==, strlen(defaultUserAgent.data())); could you use .length() instead of strlen? 711042 3 161944 mrobinson 2012-09-04 06:06:24 -0700 Comment on attachment 161944 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=161944&action=review >> Source/WebCore/platform/gtk/UserAgentGtk.cpp:94 >> + applicationName.isEmpty() ? "WebKitGTK+" : applicationName.utf8().data(), uaVersion.data()); > > We could use g_get_application_name() or g_get_prgname() since I guess we don't want the localized name here, and maybe fallback to WebKitGTK+ if g_get_prgname() returns NULL. That's reasonable, but it could potentially lead to unpredictable interaction with the page. For instance if an application has an unusual name like "Foo / Whatever" it could break the way a page parses the user agent. Perhaps it's better to choose the safest default? >> Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:51 >> + CString userAgentString; > > userAgentString sounds a bit redundant, it's a CString, maybe just userAgent? Sure. >> Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2622 >> + CString newUserAgent = (!userAgent || !strlen(userAgent)) ? WebCore::standardUserAgent("").utf8() : userAgent; > > (userAgent && userAgent[0] != '\0') ? userAgent : WebCore::standardUserAgent("").utf8() > > To avoid using strlen(). Is it useful to avoid strlen here? It feels like a micro-optimization. >> Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2627 >> + g_object_notify(G_OBJECT(settings), "user-agent"); > > This doesn't actually change the user agent, you should call WKPageSetCustomUserAgent() with the new user agent, so the web view should connect to notify::user-agent to update its user agent when the setting changes. I agree that would be better, but from what I can tell WebKitSettings does not store a page to interact with. Perhaps I was wrong? >> Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2633 >> + * @application_name: The application name used to create the user agent. > > I don't think we should allow NULL for the application name here Why? Wouldn't it be better to follow the Rubstness Principle here (http://en.wikipedia.org/wiki/Robustness_principle)? >> Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2638 >> + * agent string with the application name "WebKitGTK+." > > That's already the default user agent when this method is not called, so I think we should enforce a non null value for the application name to actually change the user agent based on the application name. I think it makes the APIs nicely symmetric. >> Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2641 >> +void webkit_settings_set_user_agent_with_application_name(WebKitSettings* settings, const char* applicationName) > > webkit_settings_set_default_user_agent_with_application_name()? Hrm. Not sure. It isn't the default user agent, it's just like the default user agent. >> Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2651 >> + g_object_notify(G_OBJECT(settings), "user-agent"); > > We could have a helper function to share this code with webkit_settings_set_user_agent(). > > set_user_agent (WebKitSettings* settings, const char* userAgent, const char* applicationName) > > webkit_settings_set_user_agent would call set_user_agent(settings, userAgent, 0) > and webkit_settings_set_default_user_agent_with_application_name would call set_user_agent(settings, 0, applicationName); Sure. >> Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitSettings.cpp:264 >> + g_assert(g_strstr_len(defaultUserAgent.data(), -1, "Chrome")); > > Why not passing defaultUserAgent.length() instead of -1 Well, I suppose this tests that webkit_settings_get_user_agent is returning null terminated strings, but I could easily turn your question around. :) >> Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitSettings.cpp:268 >> + g_assert_cmpstr(funkyUserAgent, ==, webkit_settings_get_user_agent(settings.get())); > > It would be nice to test also that setting a NULL user agent returns the default user agent Good point >> Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitSettings.cpp:277 >> + g_assert_cmpint(strlen(webCatUserAgent.data()), ==, strlen(defaultUserAgent.data())); > > could you use .length() instead of strlen? Yep! 711047 4 cgarcia 2012-09-04 06:16:32 -0700 (In reply to comment #3) > (From update of attachment 161944 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=161944&action=review > > >> Source/WebCore/platform/gtk/UserAgentGtk.cpp:94 > >> + applicationName.isEmpty() ? "WebKitGTK+" : applicationName.utf8().data(), uaVersion.data()); > > > > We could use g_get_application_name() or g_get_prgname() since I guess we don't want the localized name here, and maybe fallback to WebKitGTK+ if g_get_prgname() returns NULL. > > That's reasonable, but it could potentially lead to unpredictable interaction with the page. For instance if an application has an unusual name like "Foo / Whatever" it could break the way a page parses the user agent. Perhaps it's better to choose the safest default? That's why I said we don't want the localized app name as returned by g_get_application_name(), but the program name returned by g_get_prgname(). > >> Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2627 > >> + g_object_notify(G_OBJECT(settings), "user-agent"); > > > > This doesn't actually change the user agent, you should call WKPageSetCustomUserAgent() with the new user agent, so the web view should connect to notify::user-agent to update its user agent when the setting changes. > > I agree that would be better, but from what I can tell WebKitSettings does not store a page to interact with. Perhaps I was wrong? "so the web view should connect to notify::user-agent to update its user agent when the setting changes." I first reviewed, the code and then made the final comment, most of the comments ae no longer needed if we follow the approach I suggested in the global review comment: "I think this patch could be split in two, one to move the code to webcore and update WebKit1, and another one adding wk2 api. Regarding the wk2 patch, the logic to set user agent and application name is duplicated, because it's already in WebPageProxy. I think we could have two different properties: user-agent and application-name-for-user-agent. The view connects to notify signal for both properties and simply calls WKPageSetCustomUserAgent() for user-agent and WKPageSetApplicationNameForUserAgent() for application-name-for-user-agent." So, I propose to use two different properties, so the API code would be simpler, because all the logic is already in WebPageProxy. And I think the API is less confusing, you have user-agent and application-name-for-user-agent. What do you think? 711049 5 cgarcia 2012-09-04 06:23:37 -0700 (In reply to comment #3) > (From update of attachment 161944 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=161944&action=review > > >> Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitSettings.cpp:264 > >> + g_assert(g_strstr_len(defaultUserAgent.data(), -1, "Chrome")); > > > > Why not passing defaultUserAgent.length() instead of -1 > > Well, I suppose this tests that webkit_settings_get_user_agent is returning null terminated strings, but I could easily turn your question around. :) CString uses strlen() when size is not passed to constructor. > >> Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitSettings.cpp:268 > >> + g_assert_cmpstr(funkyUserAgent, ==, webkit_settings_get_user_agent(settings.get())); > > > > It would be nice to test also that setting a NULL user agent returns the default user agent > > Good point > > >> Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitSettings.cpp:277 > >> + g_assert_cmpint(strlen(webCatUserAgent.data()), ==, strlen(defaultUserAgent.data())); > > > > could you use .length() instead of strlen? > > Yep! 711073 6 mrobinson 2012-09-04 06:44:03 -0700 (In reply to comment #2) > (From update of attachment 161944 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=161944&action=review > > I think this patch could be split in two, one to move the code to webcore and update WebKit1, and another one adding wk2 api. Regarding the wk2 patch, the logic to set user agent and application name is duplicated, because it's already in WebPageProxy. I think we could have two different properties: user-agent and application-name-for-user-agent. The view connects to notify signal for both properties and simply calls WKPageSetCustomUserAgent() for user-agent and WKPageSetApplicationNameForUserAgent() for application-name-for-user-agent. On splitting the patch: Typically the barrier for splitting patches for the same bug/feature is whether they can be reviewed easily. I can split this, but are you sure it's totally necessary here? The code movement to WebCore is small and doesn't change the structure of the original code (it's still three free-floating functions). I didn't turn anything into a class or radically alter it. The only change is that the application name is now part of the user agent string. On code duplication: The version in WebPageProxy is for the WebKit2 C API, while the version in the majority of the code for this patch is for the GObject API. On having two properties: While I considered having two properties initially, given the fact that we don't control the page directly, the interface presented here is simpler, and it actually reflects what the C API does behind the scenes (just changes the user agent property in WebCore), I opted not to go that route. In addition to adding another property, introducing another property name also makes the logic of the patch more complicated. What do you do when both are set, for instance? One has to take precedence over the other and this must be documented. It introduces the same questions into the mind of the user of the API. This is what I mean by the interface being simpler. I ultimately chose to design it in a way where I didn't have to answer these questions. The properties are actually not independent of one another. If you examine the WebKit C API implementation you'll find that while WebPageProxy stores both the custom user agent and the user agent via the application name, changing these properties just changes the the same setting in WebCore, the user agent. It's also important to consider that we cannot call WKPageSetCustomUserAgent when the property changes. To call WKPageSetCustomUserAgent requires having a page and currently WebKitSettings does not store pages to which it has been attached -- though I think that would be a noble effort for the future. 711082 7 cgarcia 2012-09-04 06:54:29 -0700 (In reply to comment #6) > (In reply to comment #2) > > (From update of attachment 161944 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=161944&action=review > > > > I think this patch could be split in two, one to move the code to webcore and update WebKit1, and another one adding wk2 api. Regarding the wk2 patch, the logic to set user agent and application name is duplicated, because it's already in WebPageProxy. I think we could have two different properties: user-agent and application-name-for-user-agent. The view connects to notify signal for both properties and simply calls WKPageSetCustomUserAgent() for user-agent and WKPageSetApplicationNameForUserAgent() for application-name-for-user-agent. > > On splitting the patch: Typically the barrier for splitting patches for the same bug/feature is whether they can be reviewed easily. I can split this, but are you sure it's totally necessary here? The code movement to WebCore is small and doesn't change the structure of the original code (it's still three free-floating functions). I didn't turn anything into a class or radically alter it. The only change is that the application name is now part of the user agent string. The bug is marked as [WebKit2] but it changes WebCore and WebKit1 code, I still think it would be better to split it. > On code duplication: The version in WebPageProxy is for the WebKit2 C API, while the version in the majority of the code for this patch is for the GObject API. I know, I meant you avoid that duplication using the two properties. > On having two properties: While I considered having two properties initially, given the fact that we don't control the page directly, the interface presented here is simpler, and it actually reflects what the C API does behind the scenes (just changes the user agent property in WebCore), I opted not to go that route. It makes sense. What confused me when I read the patch was webkit_settings_set_user_agent_with_application_name(), because it doesn't receive a user agent to set. It sets the application name to be used when the default user agent is used. > In addition to adding another property, introducing another property name also makes the logic of the patch more complicated. What do you do when both are set, for instance? One has to take precedence over the other and this must be documented. It introduces the same questions into the mind of the user of the API. This is what I mean by the interface being simpler. I ultimately chose to design it in a way where I didn't have to answer these questions. I see your point, in your patch it's clear that both methods change the user agent. > The properties are actually not independent of one another. If you examine the WebKit C API implementation you'll find that while WebPageProxy stores both the custom user agent and the user agent via the application name, changing these properties just changes the the same setting in WebCore, the user agent. Yeah. > It's also important to consider that we cannot call WKPageSetCustomUserAgent when the property changes. To call WKPageSetCustomUserAgent requires having a page and currently WebKitSettings does not store pages to which it has been attached -- though I think that would be a noble effort for the future. Again, the web view should connect to the notify signal of its settings object to update the WebPage user agent when the property changes. 713718 8 162588 mrobinson 2012-09-06 14:34:40 -0700 Created attachment 162588 Patch 713719 9 webkit.review.bot 2012-09-06 14:37:01 -0700 Thanks for the patch. If this patch contains new public API please make sure it follows the guidelines for new WebKit2 GTK+ API. See http://trac.webkit.org/wiki/WebKitGTK/AddingNewWebKit2API 714257 10 162588 cgarcia 2012-09-07 01:13:32 -0700 Comment on attachment 162588 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=162588&action=review As I said this is not enough, if WKPageSetCustomUserAgent() is not called when the user agent property changes, the new user agent won't be sent to the WebProcess and it won't have any effect. See how it's done for zoom-text-only and allow-modal-dialogs properties in webkitWebViewSetSettings(). You should connect to the notify of user-agent from the view and call WKPageSetCustomUserAgent() from the callback using the new user agent string. You should also check that this is actually happening in the unit tests. See languages test in TestWebKitWebContext, you could use a soup server and get the header "User-Agent" after doing any request to check it's what you want. > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:1085 > + WKRetainPtr<WKStringRef> userAgent= adoptWK(WKStringCreateWithUTF8CString(priv->userAgent.data())); userAgent= -> userAgent = > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2636 > + * @application_name: The application name used to create the user agent. If the value passed > + * is %NULL or the empty string, the default user agent will be used. > + * @application_version: The application version used to create the user agent. If the value passed > + * is %NULL or the empty string, the version of Safari at the time of this release will be used. Leave a single line, and add the explanation in the body. @application_name: (allow-none): The application name used to create the user agent. @application_version: (allow-none): The application version used to create the user agent. > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2642 > + */ > + > +void webkit_settings_set_user_agent_with_application_details(WebKitSettings* settings, const char* applicationName, const char* applicationVersion) extra line there 714819 11 mrobinson 2012-09-07 12:00:39 -0700 (In reply to comment #10) > (From update of attachment 162588 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=162588&action=review > > As I said this is not enough, if WKPageSetCustomUserAgent() is not called when the user agent property changes, the new user agent won't be sent to the WebProcess and it won't have any effect. See how it's done for zoom-text-only and allow-modal-dialogs properties in webkitWebViewSetSettings(). You should connect to the notify of user-agent from the view and call WKPageSetCustomUserAgent() from the callback using the new user agent string. You should also check that this is actually happening in the unit tests. See languages test in TestWebKitWebContext, you could use a soup server and get the header "User-Agent" after doing any request to check it's what you want. Ah, I understand what you are saying now. Thanks. I've done this in my updated patch. > > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:1085 > > + WKRetainPtr<WKStringRef> userAgent= adoptWK(WKStringCreateWithUTF8CString(priv->userAgent.data())); > > userAgent= -> userAgent = Fixed. > > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2636 > > + * @application_name: The application name used to create the user agent. If the value passed > > + * is %NULL or the empty string, the default user agent will be used. > > + * @application_version: The application version used to create the user agent. If the value passed > > + * is %NULL or the empty string, the version of Safari at the time of this release will be used. > > Leave a single line, and add the explanation in the body. I'm not sure what your reasoning is here, but I've tightened up the language in the argument descriptions. The explanation is still there, but it's not longer than the ones for GtkWidget. > @application_name: (allow-none): The application name used to create the user agent. > @application_version: (allow-none): The application version used to create the user agent. > > > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2642 > > + */ > > + > > +void webkit_settings_set_user_agent_with_application_details(WebKitSettings* settings, const char* applicationName, const char* applicationVersion) > > extra line there Removed. 714826 12 162840 mrobinson 2012-09-07 12:04:43 -0700 Created attachment 162840 Patch 715757 13 162840 cgarcia 2012-09-10 00:01:29 -0700 Comment on attachment 162840 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=162840&action=review Looks good to me, please fix the minor issues I mentioned before landing, and consider adding a test case to check the user agent in the HTTP headers. > Source/WebKit2/ChangeLog:34 > + It seems changes in WebKitWebView are not mentioned in the ChangeLog. > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:1025 > + * The user-agent string used by WebKit in the headers. Unusual user-agent strings in the HTTP headers? > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2613 > + * @user_agent: (allow-none) The new custom user agent string or %NULL to use the default user agent : is missing after the annotation @user_agent: (allow-none): The new custom user agent string or %NULL to use the default user agent > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2634 > + * @application_name: (allow-none) The application name used for the user agent or %NULL to use the default user agent. > + * @application_version: (allow-none) The application version for the user agent or %NULL to user the default version. Ditto. > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:2638 > + * Set the #WebKitSettings:user-agent property by appending the application details to the default user > + * agent. If no application name or version is given, the default user agent used will be used. If only > + * the version is given, the default engine version is used with the given application name. Yes this is what I meant by moving the explanation to the body, thanks. > Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitSettings.cpp:289 > +} > + It would be great to include a test case to check that the expected user agent is actually included in the HTTP headers, it could be a simple test similar to the one used for languages. 723194 14 mrobinson 2012-09-18 19:32:15 -0700 (In reply to comment #13) > > Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp:1025 > > + * The user-agent string used by WebKit in the headers. Unusual user-agent strings > > in the HTTP headers? I just removed the mention of the headers. It was a bit awkward there. > > Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitSettings.cpp:289 > > +} > > + > > It would be great to include a test case to check that the expected user agent is actually included in the HTTP headers, it could be a simple test similar to the one used for languages. Included. Thanks for the review. 723196 15 mrobinson 2012-09-18 19:37:03 -0700 Committed r128960: <http://trac.webkit.org/changeset/128960> 726636 16 thierry.reding 2012-09-24 07:24:13 -0700 (In reply to comment #15) > Committed r128960: <http://trac.webkit.org/changeset/128960> This breaks compilation for me. UserAgentGtk.h seems to be missing. 726656 17 thierry.reding 2012-09-24 07:45:44 -0700 (In reply to comment #16) > (In reply to comment #15) > > Committed r128960: <http://trac.webkit.org/changeset/128960> > > This breaks compilation for me. UserAgentGtk.h seems to be missing. Okay, if cherry-picking specific commits I should really make sure I pick all the dependencies as well. Sorry for the noise. 161944 2012-09-03 12:34:13 -0700 2012-09-06 14:34:38 -0700 Patch bug-95697-20120903123357.patch text/plain 28508 mrobinson U3VidmVyc2lvbiBSZXZpc2lvbjogMTI3MDQ0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNGY1ODcwNzNlY2NmZjBl NWY1MGQ5YzhkYjA4MDZkZDQ4MDUxYjEzNC4uYmMzNDMwNjEyMWU1MTE2MjZhN2U3YTIxY2YwOThk ODJiYTY5ODgwYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDEyLTA5LTAzICBNYXJ0 aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KKworICAgICAgICBbV2ViS2l0Ml0g W0dUS10gQWRkIEFQSSBmb3IgY29udHJvbGxpbmcgdGhlIHVzZXIgYWdlbnQKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTk1Njk3CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTW92ZWQgdGhlIHVzZXIgYWdlbnQg ZGV0ZXJtaW5hdGlvbiBjb2RlIGZyb20gV2ViS2l0MSB0byBXZWJDb3JlIHNvIHRoYXQgaXQgY2Fu CisgICAgICAgIGJlIHNoYXJlZCB3aXRoIFdlYktpdDIuIEFsc28gYWRkIGEgbWV0aG9kIGZvciBj cmVhdGluZyB0aGUgdXNlciBhZ2VudCBnaXZlbgorICAgICAgICBhIG5vbi1kZWZhdWx0IGFwcGxp Y2F0aW9uIG5hbWUuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFtOiBBZGQgbmV3IGZp bGVzIHRvIHRoZSBsaXN0LgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Vc2VyQWdlbnRHdGsuY3Bw OiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvVXNlckFnZW50R3RrLmguaW46IEFkZGVk LgorCiAyMDEyLTA4LTI5ICBNYXJ0aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4K IAogICAgICAgICBbVGV4TWFwXVtjYWlyb10gQWRkIEdDM0Q6OlJlbmRlclRvQ3VycmVudEdMQ29u dGV4dCBzdXBwb3J0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9T b3VyY2UvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKaW5kZXggODVhNWQ5MjI3MGE4YWI5N2E5YmE0MjZh OTViY2Y5MzE1OTFjMjdmNy4uNGMzZGI2MzQyMTY2NzA3ZGFlODg0NzZmYTAzMmZlN2I5NWRlMGRl MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9X ZWJLaXQvZ3RrL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDEyLTA5LTAzICBNYXJ0aW4g Um9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KKworICAgICAgICBbV2ViS2l0Ml0gW0dU S10gQWRkIEFQSSBmb3IgY29udHJvbGxpbmcgdGhlIHVzZXIgYWdlbnQKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTk1Njk3CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTW92ZSB0aGUgY29kZSBmb3IgZGV0ZXJt aW5pbmcgdGhlIHVzZXIgYWdlbnQgdG8gV2ViQ29yZSBhbmQgaGF2ZSBXZWJLaXQxCisgICAgICAg IHVzZSB0aGUgbmV3IHNoYXJlZCBjb2RlLgorCisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYnNl dHRpbmdzLmNwcDogVXNlIHRoZSBXZWJDb3JlIGNvZGUgdG8gZGV0ZXJtaW5lIHRoZSB1c2VyCisg ICAgICAgIGFnZW50IGluIFdlYktpdDEuCisKIDIwMTItMDgtMjggIE1hcnRpbiBSb2JpbnNvbiAg PG1yb2JpbnNvbkBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdIEVuYWJsZSB0aGUgZWRnZSBk aXN0YW5jZSBhbnRpLWFsaWFzaW5nIGZvciBhY2NlbGVyYXRlZCBjb21wb3NpdGluZyBsYXllcnMK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwppbmRleCAwZjA0YjMxNjk0OTU3ZmYyNjM2YzExZTRmM2YzMjlkNzk4ZGEzMGZhLi4z OGJkNmY3NjNhZTcyMjQxZWRmYzVjYWY5Nzg1ODhlMGU2ZGM5YWY3IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMzcgQEAKKzIwMTItMDktMDMgIE1hcnRpbiBSb2JpbnNvbiAgPG1yb2JpbnNvbkBpZ2Fs aWEuY29tPgorCisgICAgICAgIFtXZWJLaXQyXSBbR1RLXSBBZGQgQVBJIGZvciBjb250cm9sbGlu ZyB0aGUgdXNlciBhZ2VudAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9OTU2OTcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBBZGQgQVBJIGZvciBjaGFuZ2luZyB0aGUgdXNlciBhZ2VudCBpbiBXZWJLaXQyLiBU aGlzIGFkZHMgdHdvIHN0eWxlcyBvZgorICAgICAgICBzZXR0aW5nIHRoZSB1c2VyIGFnZW50OiBj b21wbGV0ZSBvdmVycmlkZSBhbmQgYSBtZXRob2QgdGhhdCBqdXN0IHJlcGxhY2VzCisgICAgICAg IHRoZSBhcHBsaWNhdGlvbiBuYW1lLCBidXQgcHJlc2VydmVzIHRoZSBjYXJlZnVsbHkgY3JhZnRl ZCB1c2VyIGFnZW50CisgICAgICAgIGluIHRoZSBsaXJhcnkuCisKKyAgICAgICAgKiBVSVByb2Nl c3MvQVBJL2d0ay9XZWJLaXRTZXR0aW5ncy5jcHA6CisgICAgICAgIChfV2ViS2l0U2V0dGluZ3NQ cml2YXRlKTogQWRkZWQgYSBuZXcgZmllbGQgdG8gc3RvcmUgdGhlIHVzZXIgYWdlbnQuCisgICAg ICAgIFRoaXMgaXMgc3RvcmVkIGluIHRoZSBwcml2YXRlIGRhdGEgc3RydWN0dXJlLCBiZWNhdXNl IHdlIGNhbiBvbmx5CisgICAgICAgIHNldCB0aGUgdXNlciBhZ2VudCB3aGVuIGF0dGFjaGluZyB0 aGUgc2V0dGluZ3MgdG8gdGhlIHBhZ2UuCisgICAgICAgICh3ZWJLaXRTZXR0aW5nc1NldFByb3Bl cnR5KTogQWRkIGhvb2tzIGZvciB0aGUgbmV3IHVzZXIgYWdlbnQgcHJvcGVydHkuCisgICAgICAg ICh3ZWJLaXRTZXR0aW5nc0dldFByb3BlcnR5KTogRGl0dG8uCisgICAgICAgICh3ZWJraXRfc2V0 dGluZ3NfY2xhc3NfaW5pdCk6IERpdHRvLgorICAgICAgICAod2Via2l0U2V0dGluZ3NBdHRhY2hT ZXR0aW5nc1RvUGFnZSk6IERpdHRvLgorICAgICAgICAod2Via2l0X3NldHRpbmdzX2dldF91c2Vy X2FnZW50KTogQWRkZWQuCisgICAgICAgICh3ZWJraXRfc2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnQp OiBBZGRlZC4KKyAgICAgICAgKHdlYmtpdF9zZXR0aW5nc19zZXRfdXNlcl9hZ2VudF93aXRoX2Fw cGxpY2F0aW9uX25hbWUpOiBBZGRlZC4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRTZXR0aW5ncy5oOiBBZGRlZCBuZXcgbWV0aG9kcy4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJ L2d0ay9kb2NzL3dlYmtpdDJndGstc2VjdGlvbnMudHh0OiBBZGRlZCBuZXcgbWV0aG9kcyB0bwor ICAgICAgICB0aGUgZG9jdW1lbnRhdGlvbi4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay90 ZXN0cy9UZXN0V2ViS2l0U2V0dGluZ3MuY3BwOiBUZXN0IHRoZSBuZXcgdXNlciBhZ2VudAorICAg ICAgICBwcm9wZXJ0eS4KKyAgICAgICAgKHRlc3RXZWJLaXRTZXR0aW5nc1VzZXJBZ2VudCk6IERp dHRvLgorICAgICAgICAoYmVmb3JlQWxsKTogRGl0dG8uCisgICAgICAgICogVUlQcm9jZXNzL2d0 ay9XZWJQYWdlUHJveHlHdGsuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnN0 YW5kYXJkVXNlckFnZW50KTogTm93IHVzZSB0aGUgc2hhcmVkIFdlYkNvcmUKKyAgICAgICAgY29k ZSB3aGVuIHNldHRpbmcgdGhlIHVzZXIgYWdlbnQuCisKIDIwMTItMDgtMjkgIEpvbiBMZWUgIDxq b25sZWVAYXBwbGUuY29tPgogCiAgICAgICAgIEJ1aWxkIHBhdGNoIGZvciBRdApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbSBiL1NvdXJjZS9XZWJDb3JlL0dO VW1ha2VmaWxlLmxpc3QuYW0KaW5kZXggZGNjMzAwM2ViOTQxNjQ1ZWVkMzY2ZDc0NjlhNThkNTEx Yjc2MTI3MS4uM2VlNTMyYTBjNGQ0OGFkMTllYzMzZjlmOTI1ZGFjOTljNWYwMjgxYyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3VyY2UvV2Vi Q29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCkBAIC0xMTM5LDYgKzExMzksNyBAQCB3ZWJjb3JlX2J1 aWx0X3NvdXJjZXMgKz0gXAogCURlcml2ZWRTb3VyY2VzL1dlYkNvcmUvTWF0aE1MTmFtZXMuaCBc CiAJRGVyaXZlZFNvdXJjZXMvV2ViQ29yZS9TVkdFbGVtZW50RmFjdG9yeS5jcHAgXAogCURlcml2 ZWRTb3VyY2VzL1dlYkNvcmUvU1ZHTmFtZXMuY3BwIFwKKwlEZXJpdmVkU291cmNlcy9XZWJDb3Jl L1VzZXJBZ2VudEd0ay5oIFwKIAlEZXJpdmVkU291cmNlcy9XZWJDb3JlL1VzZXJBZ2VudFN0eWxl U2hlZXRzRGF0YS5jcHAgXAogCURlcml2ZWRTb3VyY2VzL1dlYkNvcmUvVXNlckFnZW50U3R5bGVT aGVldHMuaCBcCiAJRGVyaXZlZFNvdXJjZXMvV2ViQ29yZS9XZWJLaXRGb250RmFtaWx5TmFtZXMu Y3BwIFwKQEAgLTQ0NjAsNiArNDQ2MSw3IEBAIHdlYmNvcmVfc291cmNlcyArPSBcCiAJU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0xvZ2dpbmdHdGsuY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ndGsvTUlNRVR5cGVSZWdpc3RyeUd0ay5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9TaGFyZWRCdWZmZXJHdGsuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ndGsvVXNlckFnZW50R3RrLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1Rl bXBvcmFyeUxpbmtTdHVicy5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0hvc3RXaW5k b3cuaCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vS2lsbFJpbmcuaCBcCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvVXNlckFnZW50R3RrLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2d0ay9Vc2VyQWdlbnRHdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjNjZjM4ZTRl YzEyOTUwZTY4NDE0YjNmYzUyOGQwMjY3MmRlNjM2ODEKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvVXNlckFnZW50R3RrLmNwcApAQCAtMCwwICsxLDk4IEBA CisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyIElnYWxpYSBTLkwuCisgKgorICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291 cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICog Mi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICog VEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElT JycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBD T05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRB TCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUg R09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1Ig QlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQor ICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBP UiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElO IEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUg ImNvbmZpZy5oIgorI2luY2x1ZGUgIlVzZXJBZ2VudEd0ay5oIgorCisjaWYgT1MoVU5JWCkKKyNp bmNsdWRlIDxzeXMvdXRzbmFtZS5oPgorI2VsaWYgT1MoV0lORE9XUykKKyNpbmNsdWRlICJTeXN0 ZW1JbmZvLmgiCisjZW5kaWYKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjb25zdCBjaGFyKiBw bGF0Zm9ybUZvclVBU3RyaW5nKCkKK3sKKyNpZiBQTEFURk9STShYMTEpCisgICAgcmV0dXJuICJY MTEiOworI2VsaWYgT1MoV0lORE9XUykKKyAgICByZXR1cm4gIiI7CisjZWxpZiBQTEFURk9STShN QUMpCisgICAgcmV0dXJuICJNYWNpbnRvc2giOworI2VsaWYgZGVmaW5lZChHREtfV0lORE9XSU5H X0RJUkVDVEZCKQorICAgIHJldHVybiAiRGlyZWN0RkIiOworI2Vsc2UKKyAgICByZXR1cm4gIlVu a25vd24iOworI2VuZGlmCit9CisKK1N0cmluZyBwbGF0Zm9ybVZlcnNpb25Gb3JVQVN0cmluZygp Cit7CisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChTdHJpbmcsIHVhT1NWZXJzaW9uLCAoU3RyaW5n KCkpKTsKKyAgICBpZiAoIXVhT1NWZXJzaW9uLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuIHVh T1NWZXJzaW9uOworCisjaWYgT1MoV0lORE9XUykKKyAgICB1YU9TVmVyc2lvbiA9IHdpbmRvd3NW ZXJzaW9uRm9yVUFTdHJpbmcoKTsKKyNlbGlmIE9TKERBUldJTikKKyNpZiBDUFUoWDg2KQorICAg IHVhT1NWZXJzaW9uID0gICJJbnRlbCBNYWMgT1MgWCI7CisjZWxzZQorICAgIHVhT1NWZXJzaW9u ID0gICJQUEMgTWFjIE9TIFgiOworI2VuZGlmCisjZWxpZiBPUyhVTklYKQorICAgIHN0cnVjdCB1 dHNuYW1lIG5hbWU7CisgICAgaWYgKHVuYW1lKCZuYW1lKSAhPSAtMSkKKyAgICAgICAgdWFPU1Zl cnNpb24gPSBTdHJpbmc6OmZvcm1hdCgiJXMgJXMiLCBuYW1lLnN5c25hbWUsIG5hbWUubWFjaGlu ZSk7CisgICAgZWxzZQorICAgICAgICB1YU9TVmVyc2lvbiA9IFN0cmluZygiVW5rbm93biIpOwor I2Vsc2UKKyAgICB1YU9TVmVyc2lvbiA9IFN0cmluZygiVW5rbm93biIpOworI2VuZGlmCisgICAg cmV0dXJuIHVhT1NWZXJzaW9uOworfQorCitTdHJpbmcgc3RhbmRhcmRVc2VyQWdlbnQoY29uc3Qg U3RyaW5nJiBhcHBsaWNhdGlvbk5hbWUpCit7CisgICAgLy8gQ3JlYXRlIGEgZGVmYXVsdCB1c2Vy IGFnZW50IHN0cmluZyB3aXRoIGEgbGliZXJhbCBpbnRlcnByZXRhdGlvbiBvZiAKKyAgICAvLyBo dHRwczovL2RldmVsb3Blci5tb3ppbGxhLm9yZy9lbi1VUy9kb2NzL1VzZXJfQWdlbnRfU3RyaW5n c19SZWZlcmVuY2UKKyAgICAvLworICAgIC8vIEZvcm1pbmcgYSBmdW5jdGlvbmFsIHVzZXIgYWdl bnQgaXMgcmVhbGx5IGRpZmZpY3VsdC4gV2UgbXVzdCBtZW50aW9uIFNhZmFyaSwgYmVjYXVzZSBz b21lCisgICAgLy8gc2l0ZXMgY2hlY2sgZm9yIHRoYXQgd2hlbiBkZXRlY3RpbmcgV2ViS2l0IGJy b3dzZXJzLiBBZGRpdGlvbmFsbHkgc29tZSBzaXRlcyBhc3N1bWUgdGhhdAorICAgIC8vIGJyb3dz ZXJzIHRoYXQgYXJlICJTYWZhcmkiIGJ1dCBub3QgcnVubmluZyBvbiBPUyBYIGFyZSB0aGUgU2Fm YXJpIGlPUyBicm93c2VyLCBzbyB3ZQorICAgIC8vIGFsc28gY2xhaW0gdG8gYmUgIENocm9taXVt LiBHZXR0aW5nIHRoaXMgd3JvbmcgY2FuIGNhdXNlIHNpdGVzIHRvIGxvYWQgdGhlIHdyb25nIEph dmFTY3JpcHQsCisgICAgLy8gQ1NTLCBvciBjdXN0b20gZm9udHMuIEluIHNvbWUgY2FzZXMgc2l0 ZXMgd29uJ3QgbG9hZCByZXNvdXJjZXMgYXQgYWxsLgorICAgIERFRklORV9TVEFUSUNfTE9DQUwo Y29uc3QgQ1N0cmluZywgdWFWZXJzaW9uLCAoU3RyaW5nOjpmb3JtYXQoIiVpLiVpIiwgV0VCS0lU X1VTRVJfQUdFTlRfTUFKT1JfVkVSU0lPTiwgV0VCS0lUX1VTRVJfQUdFTlRfTUlOT1JfVkVSU0lP TikudXRmOCgpKSk7CisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChjb25zdCBTdHJpbmcsIHN0YXRp Y1VBLCAoU3RyaW5nOjpmb3JtYXQoIk1vemlsbGEvNS4wICglczsgJXMpIEFwcGxlV2ViS2l0LyVz IChLSFRNTCwgbGlrZSBHZWNrbykgIgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJDaHJvbWl1bS8xOC4wLjEwMjUuMTY4IENo cm9tZS8xOC4wLjEwMjUuMTY4IFNhZmFyaS8lcyIsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcGxhdGZvcm1Gb3JVQVN0cmlu ZygpLCBwbGF0Zm9ybVZlcnNpb25Gb3JVQVN0cmluZygpLnV0ZjgoKS5kYXRhKCksCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg dWFWZXJzaW9uLmRhdGEoKSwgdWFWZXJzaW9uLmRhdGEoKSkpKTsKKyAgICByZXR1cm4gU3RyaW5n Ojpmb3JtYXQoIiVzICVzLyVzIiwgc3RhdGljVUEudXRmOCgpLmRhdGEoKSwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgYXBwbGljYXRpb25OYW1lLmlzRW1wdHkoKSA/ICJXZWJLaXRHVEsrIiA6 IGFwcGxpY2F0aW9uTmFtZS51dGY4KCkuZGF0YSgpLCB1YVZlcnNpb24uZGF0YSgpKTsKK30KKwor fSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvVXNlckFnZW50R3RrLmguaW4gYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsv VXNlckFnZW50R3RrLmguaW4KbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNmE1MDc2OGQ1MzdiZTczNWYyOTgxZTgzZmMw MmU1MGM1MThlN2ZkYQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9Vc2VyQWdlbnRHdGsuaC5pbgpAQCAtMCwwICsxLDQ0IEBACisvKgorICogQ29weXJpZ2h0 IChDKSAyMDEyIElnYWxpYSBTLkwuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAq IGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25z IGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQ UkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5F U1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVW RU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBVc2VyQWdlbnRHdGtfaAorI2Rl ZmluZSBVc2VyQWdlbnRHdGtfaAorCisjaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgorI2lu Y2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgorCisjZGVmaW5lIFdFQktJVF9VU0VSX0FHRU5U X01BSk9SX1ZFUlNJT04gKEBXRUJLSVRfVVNFUl9BR0VOVF9NQUpPUl9WRVJTSU9OQCkKKyNkZWZp bmUgV0VCS0lUX1VTRVJfQUdFTlRfTUlOT1JfVkVSU0lPTiAoQFdFQktJVF9VU0VSX0FHRU5UX01J Tk9SX1ZFUlNJT05AKQorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NvbnN0IGNoYXIqIHBsYXRm b3JtRm9yVUFTdHJpbmcoKTsKK1N0cmluZyBwbGF0Zm9ybVZlcnNpb25Gb3JVQVN0cmluZygpOwor U3RyaW5nIHN0YW5kYXJkVXNlckFnZW50KGNvbnN0IFN0cmluZyYgYXBwbGljYXRpb25OYW1lKTsK KworfQorCisjZW5kaWYgLy8gVXNlckFnZW50R3RrX2gKKwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnNldHRpbmdzLmNwcCBiL1NvdXJjZS9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXR3ZWJzZXR0aW5ncy5jcHAKaW5kZXggY2U4NzdlNGYwZDFlY2VhZDg3OTgz NDNkMTdkMjYwNDdiNTYyZTFhZC4uODAyNWY5MGYxYWMxYzg1ODI0MWJmYmY5YzNlODMyNjIxNmI2 ZDI0MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnNldHRp bmdzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vic2V0dGluZ3Mu Y3BwCkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSAiRmlsZVN5c3RlbS5oIgogI2luY2x1ZGUg IktVUkwuaCIKICNpbmNsdWRlICJQbHVnaW5EYXRhYmFzZS5oIgorI2luY2x1ZGUgIlVzZXJBZ2Vu dEd0ay5oIgogI2luY2x1ZGUgIndlYmtpdGVudW10eXBlcy5oIgogI2luY2x1ZGUgIndlYmtpdGds b2JhbHNwcml2YXRlLmgiCiAjaW5jbHVkZSAid2Via2l0dmVyc2lvbi5oIgpAQCAtMzksMTIgKzQw LDYgQEAKICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdDb25jYXRlbmF0ZS5oPgogI2luY2x1ZGUg PGdsaWIvZ2kxOG4tbGliLmg+CiAKLSNpZiBPUyhVTklYKQotI2luY2x1ZGUgPHN5cy91dHNuYW1l Lmg+Ci0jZWxpZiBPUyhXSU5ET1dTKQotI2luY2x1ZGUgIlN5c3RlbUluZm8uaCIKLSNlbmRpZgot CiAvKioKICAqIFNFQ1RJT046d2Via2l0d2Vic2V0dGluZ3MKICAqIEBzaG9ydF9kZXNjcmlwdGlv bjogQ29udHJvbCB0aGUgYmVoYXZpb3VyIG9mIGEgI1dlYktpdFdlYlZpZXcKQEAgLTEyNiw3MSAr MTIxLDYgQEAgZW51bSB7CiAgICAgUFJPUF9NRURJQV9QTEFZQkFDS19BTExPV1NfSU5MSU5FCiB9 OwogCi0vLyBDcmVhdGUgYSBkZWZhdWx0IHVzZXIgYWdlbnQgc3RyaW5nCi0vLyBUaGlzIGlzIGEg bGliZXJhbCBpbnRlcnByZXRhdGlvbiBvZiBodHRwOi8vd3d3Lm1vemlsbGEub3JnL2J1aWxkL3Jl dmlzZWQtdXNlci1hZ2VudC1zdHJpbmdzLmh0bWwKLS8vIFNlZSBhbHNvIGh0dHA6Ly9kZXZlbG9w ZXIuYXBwbGUuY29tL2ludGVybmV0L3NhZmFyaS9mYXEuaHRtbCNhbmNob3IyCi1zdGF0aWMgU3Ry aW5nIHdlYmtpdFBsYXRmb3JtKCkKLXsKLSNpZiBQTEFURk9STShYMTEpCi0gICAgREVGSU5FX1NU QVRJQ19MT0NBTChjb25zdCBTdHJpbmcsIHVhUGxhdGZvcm0sIChTdHJpbmcoIlgxMTsgIikpKTsK LSNlbGlmIE9TKFdJTkRPV1MpCi0gICAgREVGSU5FX1NUQVRJQ19MT0NBTChjb25zdCBTdHJpbmcs IHVhUGxhdGZvcm0sIChTdHJpbmcoIiIpKSk7Ci0jZWxpZiBQTEFURk9STShNQUMpCi0gICAgREVG SU5FX1NUQVRJQ19MT0NBTChjb25zdCBTdHJpbmcsIHVhUGxhdGZvcm0sIChTdHJpbmcoIk1hY2lu dG9zaDsgIikpKTsKLSNlbGlmIGRlZmluZWQoR0RLX1dJTkRPV0lOR19ESVJFQ1RGQikKLSAgICBE RUZJTkVfU1RBVElDX0xPQ0FMKGNvbnN0IFN0cmluZywgdWFQbGF0Zm9ybSwgKFN0cmluZygiRGly ZWN0RkI7ICIpKSk7Ci0jZWxzZQotICAgIERFRklORV9TVEFUSUNfTE9DQUwoY29uc3QgU3RyaW5n LCB1YVBsYXRmb3JtLCAoU3RyaW5nKCJVbmtub3duOyAiKSkpOwotI2VuZGlmCi0KLSAgICByZXR1 cm4gdWFQbGF0Zm9ybTsKLX0KLQotc3RhdGljIFN0cmluZyB3ZWJraXRPU1ZlcnNpb24oKQotewot ICAgLy8gRklYTUU6IHBsYXRmb3JtL3ZlcnNpb24gZGV0ZWN0aW9uIGNhbiBiZSBzaGFyZWQuCi0j aWYgT1MoREFSV0lOKQotCi0jaWYgQ1BVKFg4NikKLSAgICBERUZJTkVfU1RBVElDX0xPQ0FMKGNv bnN0IFN0cmluZywgdWFPU1ZlcnNpb24sIChTdHJpbmcoIkludGVsIE1hYyBPUyBYIikpKTsKLSNl bHNlCi0gICAgREVGSU5FX1NUQVRJQ19MT0NBTChjb25zdCBTdHJpbmcsIHVhT1NWZXJzaW9uLCAo U3RyaW5nKCJQUEMgTWFjIE9TIFgiKSkpOwotI2VuZGlmCi0KLSNlbGlmIE9TKFVOSVgpCi0gICAg REVGSU5FX1NUQVRJQ19MT0NBTChTdHJpbmcsIHVhT1NWZXJzaW9uLCAoU3RyaW5nKCkpKTsKLQot ICAgIGlmICghdWFPU1ZlcnNpb24uaXNFbXB0eSgpKQotICAgICAgICByZXR1cm4gdWFPU1ZlcnNp b247Ci0KLSAgICBzdHJ1Y3QgdXRzbmFtZSBuYW1lOwotICAgIGlmICh1bmFtZSgmbmFtZSkgIT0g LTEpCi0gICAgICAgIHVhT1NWZXJzaW9uID0gbWFrZVN0cmluZyhuYW1lLnN5c25hbWUsICcgJywg bmFtZS5tYWNoaW5lKTsKLSAgICBlbHNlCi0gICAgICAgIHVhT1NWZXJzaW9uID0gU3RyaW5nKCJV bmtub3duIik7Ci0jZWxpZiBPUyhXSU5ET1dTKQotICAgIERFRklORV9TVEFUSUNfTE9DQUwoY29u c3QgU3RyaW5nLCB1YU9TVmVyc2lvbiwgKHdpbmRvd3NWZXJzaW9uRm9yVUFTdHJpbmcoKSkpOwot I2Vsc2UKLSAgICBERUZJTkVfU1RBVElDX0xPQ0FMKGNvbnN0IFN0cmluZywgdWFPU1ZlcnNpb24s IChTdHJpbmcoIlVua25vd24iKSkpOwotI2VuZGlmCi0KLSAgICByZXR1cm4gdWFPU1ZlcnNpb247 Ci19Ci0KLXN0YXRpYyBTdHJpbmcgY2hyb21lVXNlckFnZW50KCkKLXsKLSAgICAvLyBXZSBtZW50 aW9uIFNhZmFyaSBzaW5jZSBtYW55IGJyb2tlbiBzaXRlcyBjaGVjayBmb3IgaXQgKE9tbmlXZWIg ZG9lcyB0aGlzIHRvbykKLSAgICAvLyBXZSByZS11c2UgdGhlIFdlYktpdCB2ZXJzaW9uLCB0aG91 Z2ggaXQgZG9lc24ndCBzZWVtIHRvIG1hdHRlciBtdWNoIGluIHByYWN0aWNlCi0gICAgLy8gV2Ug Y2xhaW0gdG8gYmUgQ2hyb21lIGFzIHdlbGwsIHdoaWNoIHByZXZlbnRzIHNpdGVzIHRoYXQgbG9v ayBmb3IgU2FmYXJpIGFuZCBhc3N1bWUKLSAgICAvLyB0aGF0IHNpbmNlIHdlIGFyZSBub3QgT1Mg WCwgdGhhdCB3ZSBhcmUgdGhlIG1vYmlsZSB2ZXJzaW9uIG9mIFNhZmFyaS4KLQotICAgIERFRklO RV9TVEFUSUNfTE9DQUwoY29uc3QgU3RyaW5nLCB1YVZlcnNpb24sIChtYWtlU3RyaW5nKFN0cmlu Zzo6bnVtYmVyKFdFQktJVF9VU0VSX0FHRU5UX01BSk9SX1ZFUlNJT04pLCAnLicsIFN0cmluZzo6 bnVtYmVyKFdFQktJVF9VU0VSX0FHRU5UX01JTk9SX1ZFUlNJT04pLCAnKycpKSk7Ci0gICAgREVG SU5FX1NUQVRJQ19MT0NBTChjb25zdCBTdHJpbmcsIHN0YXRpY1VBLCAobWFrZVN0cmluZygiTW96 aWxsYS81LjAgKCIsIHdlYmtpdFBsYXRmb3JtKCksIHdlYmtpdE9TVmVyc2lvbigpLCAiKSBBcHBs ZVdlYktpdC8iLCB1YVZlcnNpb24pICsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBtYWtlU3RyaW5nKCIgKEtIVE1MLCBsaWtlIEdlY2tvKSBDaHJvbWl1 bS8xNy4wLjk2My41NiBDaHJvbWUvMTcuMC45NjMuNTYgU2FmYXJpLyIsIHVhVmVyc2lvbikpKTsK LQotICAgIHJldHVybiBzdGF0aWNVQTsKLX0KLQogc3RhdGljIHZvaWQgd2Via2l0X3dlYl9zZXR0 aW5nc19maW5hbGl6ZShHT2JqZWN0KiBvYmplY3QpOwogCiBzdGF0aWMgdm9pZCB3ZWJraXRfd2Vi X3NldHRpbmdzX3NldF9wcm9wZXJ0eShHT2JqZWN0KiBvYmplY3QsIGd1aW50IHByb3BfaWQsIGNv bnN0IEdWYWx1ZSogdmFsdWUsIEdQYXJhbVNwZWMqIHBzcGVjKTsKQEAgLTExMjUsNyArMTA1NSw3 IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfc2V0dGluZ3Nfc2V0X3Byb3BlcnR5KEdPYmplY3Qq IG9iamVjdCwgZ3VpbnQgcHJvcF9pZCwgY29uCiAgICAgICAgIGJyZWFrOwogICAgIGNhc2UgUFJP UF9VU0VSX0FHRU5UOgogICAgICAgICBpZiAoIWdfdmFsdWVfZ2V0X3N0cmluZyh2YWx1ZSkgfHwg IXN0cmxlbihnX3ZhbHVlX2dldF9zdHJpbmcodmFsdWUpKSkKLSAgICAgICAgICAgIHByaXYtPnVz ZXJBZ2VudCA9IGNocm9tZVVzZXJBZ2VudCgpLnV0ZjgoKTsKKyAgICAgICAgICAgIHByaXYtPnVz ZXJBZ2VudCA9IFdlYkNvcmU6OnN0YW5kYXJkVXNlckFnZW50KCIiKS51dGY4KCk7CiAgICAgICAg IGVsc2UKICAgICAgICAgICAgIHByaXYtPnVzZXJBZ2VudCA9IGdfdmFsdWVfZ2V0X3N0cmluZyh2 YWx1ZSk7CiAgICAgICAgIGJyZWFrOwpAQCAtMTU1OSw3ICsxNDg5LDcgQEAgc3RhdGljIFN0cmlu ZyB1c2VyQWdlbnRGb3JVUkwoY29uc3QgS1VSTCYgdXJsKQogICAgIC8vIEZvciBHb29nbGUgZG9t YWlucywgZHJvcCB0aGUgYnJvd3NlcidzIGN1c3RvbSBVc2VyIEFnZW50IHN0cmluZywgYW5kIHVz ZSB0aGUKICAgICAvLyBzdGFuZGFyZCBDaHJvbWUgb25lLCBzbyB0aGV5IGRvbid0IGdpdmUgdXMg YSBicm9rZW4gZXhwZXJpZW5jZS4KICAgICBpZiAoaXNHb29nbGVEb21haW4odXJsLmhvc3QoKSkp Ci0gICAgICAgIHJldHVybiBjaHJvbWVVc2VyQWdlbnQoKTsKKyAgICAgICAgcmV0dXJuIHN0YW5k YXJkVXNlckFnZW50KCIiKTsKIAogICAgIHJldHVybiBTdHJpbmcoKTsKIH0KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFNldHRpbmdzLmNwcCBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFNldHRpbmdzLmNwcAppbmRleCA1 ZTBiZTdkMzIyMDVkZmI3MGMyYjllZTYxMjA3YjAyZjlkN2U3MmNmLi5kNTEzYzgyZmI2NmFjODMy NWFjMDY4ZTFkY2FjZjhiMDViZjM3Y2VhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2d0ay9XZWJLaXRTZXR0aW5ncy5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0FQSS9ndGsvV2ViS2l0U2V0dGluZ3MuY3BwCkBAIC0zNCw2ICszNCw3IEBACiAjaW5j bHVkZSAiV2ViS2l0UHJpdmF0ZS5oIgogI2luY2x1ZGUgIldlYktpdFNldHRpbmdzUHJpdmF0ZS5o IgogI2luY2x1ZGUgIldlYlBhZ2VQcm94eS5oIgorI2luY2x1ZGUgPFdlYkNvcmUvVXNlckFnZW50 R3RrLmg+CiAjaW5jbHVkZSA8Z2xpYi9naTE4bi1saWIuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9D U3RyaW5nLmg+CiAKQEAgLTQ3LDYgKzQ4LDcgQEAgc3RydWN0IF9XZWJLaXRTZXR0aW5nc1ByaXZh dGUgewogICAgIENTdHJpbmcgZmFudGFzeUZvbnRGYW1pbHk7CiAgICAgQ1N0cmluZyBwaWN0b2dy YXBoRm9udEZhbWlseTsKICAgICBDU3RyaW5nIGRlZmF1bHRDaGFyc2V0OworICAgIENTdHJpbmcg dXNlckFnZW50U3RyaW5nOwogICAgIGJvb2wgYWxsb3dNb2RhbERpYWxvZ3M7CiAgICAgYm9vbCB6 b29tVGV4dE9ubHk7CiB9OwpAQCAtMTE0LDcgKzExNiw4IEBAIGVudW0gewogICAgIFBST1BfTUVE SUFfUExBWUJBQ0tfQUxMT1dTX0lOTElORSwKICAgICBQUk9QX0RSQVdfQ09NUE9TSVRJTkdfSU5E SUNBVE9SUywKICAgICBQUk9QX0VOQUJMRV9TSVRFX1NQRUNJRklDX1FVSVJLUywKLSAgICBQUk9Q X0VOQUJMRV9QQUdFX0NBQ0hFCisgICAgUFJPUF9FTkFCTEVfUEFHRV9DQUNIRSwKKyAgICBQUk9Q X1VTRVJfQUdFTlQKIH07CiAKIHN0YXRpYyB2b2lkIHdlYktpdFNldHRpbmdzU2V0UHJvcGVydHko R09iamVjdCogb2JqZWN0LCBndWludCBwcm9wSWQsIGNvbnN0IEdWYWx1ZSogdmFsdWUsIEdQYXJh bVNwZWMqIHBhcmFtU3BlYykKQEAgLTI0NSw2ICsyNDgsOSBAQCBzdGF0aWMgdm9pZCB3ZWJLaXRT ZXR0aW5nc1NldFByb3BlcnR5KEdPYmplY3QqIG9iamVjdCwgZ3VpbnQgcHJvcElkLCBjb25zdCBH VmFsdQogICAgIGNhc2UgUFJPUF9FTkFCTEVfUEFHRV9DQUNIRToKICAgICAgICAgd2Via2l0X3Nl dHRpbmdzX3NldF9lbmFibGVfcGFnZV9jYWNoZShzZXR0aW5ncywgZ192YWx1ZV9nZXRfYm9vbGVh bih2YWx1ZSkpOwogICAgICAgICBicmVhazsKKyAgICBjYXNlIFBST1BfVVNFUl9BR0VOVDoKKyAg ICAgICAgd2Via2l0X3NldHRpbmdzX3NldF91c2VyX2FnZW50KHNldHRpbmdzLCBnX3ZhbHVlX2dl dF9zdHJpbmcodmFsdWUpKTsKKyAgICAgICAgYnJlYWs7CiAgICAgZGVmYXVsdDoKICAgICAgICAg R19PQkpFQ1RfV0FSTl9JTlZBTElEX1BST1BFUlRZX0lEKG9iamVjdCwgcHJvcElkLCBwYXJhbVNw ZWMpOwogICAgICAgICBicmVhazsKQEAgLTM3OSw2ICszODUsOSBAQCBzdGF0aWMgdm9pZCB3ZWJL aXRTZXR0aW5nc0dldFByb3BlcnR5KEdPYmplY3QqIG9iamVjdCwgZ3VpbnQgcHJvcElkLCBHVmFs dWUqIHZhbAogICAgIGNhc2UgUFJPUF9FTkFCTEVfUEFHRV9DQUNIRToKICAgICAgICAgZ192YWx1 ZV9zZXRfYm9vbGVhbih2YWx1ZSwgd2Via2l0X3NldHRpbmdzX2dldF9lbmFibGVfcGFnZV9jYWNo ZShzZXR0aW5ncykpOwogICAgICAgICBicmVhazsKKyAgICBjYXNlIFBST1BfVVNFUl9BR0VOVDoK KyAgICAgICAgZ192YWx1ZV9zZXRfc3RyaW5nKHZhbHVlLCB3ZWJraXRfc2V0dGluZ3NfZ2V0X3Vz ZXJfYWdlbnQoc2V0dGluZ3MpKTsKKyAgICAgICAgYnJlYWs7CiAgICAgZGVmYXVsdDoKICAgICAg ICAgR19PQkpFQ1RfV0FSTl9JTlZBTElEX1BST1BFUlRZX0lEKG9iamVjdCwgcHJvcElkLCBwYXJh bVNwZWMpOwogICAgICAgICBicmVhazsKQEAgLTEwMTAsNiArMTAxOSwyNiBAQCBzdGF0aWMgdm9p ZCB3ZWJraXRfc2V0dGluZ3NfY2xhc3NfaW5pdChXZWJLaXRTZXR0aW5nc0NsYXNzKiBrbGFzcykK ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IFRSVUUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICByZWFkV3JpdGVDb25zdHJ1Y3RQYXJhbUZsYWdzKSk7CiAKKyAgICAvKioKKyAgICAg KiBXZWJLaXRTZXR0aW5nczp1c2VyLWFnZW50CisgICAgICoKKyAgICAgKiBUaGUgdXNlci1hZ2Vu dCBzdHJpbmcgdXNlZCBieSBXZWJLaXQgaW4gdGhlIGhlYWRlcnMuIFVudXN1YWwgdXNlci1hZ2Vu dCBzdHJpbmdzCisgICAgICogbWF5IGNhdXNlIHdlYiBjb250ZW50IHRvIHJlbmRlciBpbmNvcnJl Y3RseSBvciBmYWlsIHRvIHJ1biwgYXMgbWFueSB3ZWIgcGFnZXMgYXJlCisgICAgICogd3JpdHRl biB0byBwYXJzZSB0aGUgdXNlci1hZ2VudCBzdHJpbmdzIG9mIG9ubHkgdGhlIG1vc3QgcG9wdWxh ciBicm93c2Vycy4gVGhlcmVmb3JlLAorICAgICAqIGl0J3MgdHlwaWNhbGx5IGJldHRlciB0byBu b3QgY29tcGxldGVseSBvdmVycmlkZSB0aGUgc3RhbmRhcmQgdXNlci1hZ2VudCwgYnV0IHRvIHVz ZQorICAgICAqIHdlYmtpdF9zZXR0aW5nc19zZXRfdXNlcl9hZ2VudF93aXRoX2FwcGxpY2F0aW9u X25hbWUoKSBpbnN0ZWFkLgorICAgICAqCisgICAgICogSWYgdGhpcyBwcm9wZXJ0eSBpcyBzZXQg dG8gdGhlIGVtcHR5IHN0cmluZyBvciBOVUxMLCBpdCB3aWxsIHJldmVydCB0byB0aGUgc3RhbmRh cmQKKyAgICAgKiB1c2VyLWFnZW50LgorICAgICAqLworICAgIGdfb2JqZWN0X2NsYXNzX2luc3Rh bGxfcHJvcGVydHkoZ09iamVjdENsYXNzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgUFJPUF9VU0VSX0FHRU5ULAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgZ19wYXJhbV9zcGVjX3N0cmluZygidXNlci1hZ2VudCIsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIF8oIlVzZXIgYWdlbnQgc3RyaW5n IiksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIF8oIlRoZSB1c2VyIGFnZW50IHN0cmluZyIpLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAwLCAvLyBBIG51bGwgc3RyaW5nIGZvcmNl cyB0aGUgc3RhbmRhcmQgdXNlciBhZ2VudC4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVhZFdyaXRlQ29uc3RydWN0UGFyYW1GbGFncykp OworCiAgICAgZ190eXBlX2NsYXNzX2FkZF9wcml2YXRlKGtsYXNzLCBzaXplb2YoV2ViS2l0U2V0 dGluZ3NQcml2YXRlKSk7CiB9CiAKQEAgLTEwNDgsOCArMTA3NywxMyBAQCBzdGF0aWMgdm9pZCB3 ZWJraXRfc2V0dGluZ3NfaW5pdChXZWJLaXRTZXR0aW5ncyogc2V0dGluZ3MpCiAKIHZvaWQgd2Vi a2l0U2V0dGluZ3NBdHRhY2hTZXR0aW5nc1RvUGFnZShXZWJLaXRTZXR0aW5ncyogc2V0dGluZ3Ms IFdLUGFnZVJlZiB3a1BhZ2UpCiB7Ci0gICAgV0tQYWdlR3JvdXBTZXRQcmVmZXJlbmNlcyhXS1Bh Z2VHZXRQYWdlR3JvdXAod2tQYWdlKSwgc2V0dGluZ3MtPnByaXYtPnByZWZlcmVuY2VzLmdldCgp KTsKLSAgICBXZWJLaXQ6OnRvSW1wbCh3a1BhZ2UpLT5zZXRDYW5SdW5Nb2RhbChzZXR0aW5ncy0+ cHJpdi0+YWxsb3dNb2RhbERpYWxvZ3MpOworICAgIFdlYktpdFNldHRpbmdzUHJpdmF0ZSogcHJp diA9IHNldHRpbmdzLT5wcml2OworICAgIFdLUGFnZUdyb3VwU2V0UHJlZmVyZW5jZXMoV0tQYWdl R2V0UGFnZUdyb3VwKHdrUGFnZSksIHByaXYtPnByZWZlcmVuY2VzLmdldCgpKTsKKyAgICBXZWJL aXQ6OnRvSW1wbCh3a1BhZ2UpLT5zZXRDYW5SdW5Nb2RhbChwcml2LT5hbGxvd01vZGFsRGlhbG9n cyk7CisKKyAgICBBU1NFUlQoIXByaXYtPnVzZXJBZ2VudFN0cmluZy5pc051bGwoKSk7CisgICAg V0tSZXRhaW5QdHI8V0tTdHJpbmdSZWY+IHVzZXJBZ2VudFN0cmluZyA9IGFkb3B0V0soV0tTdHJp bmdDcmVhdGVXaXRoVVRGOENTdHJpbmcocHJpdi0+dXNlckFnZW50U3RyaW5nLmRhdGEoKSkpOwor ICAgIFdLUGFnZVNldEN1c3RvbVVzZXJBZ2VudCh3a1BhZ2UsIHVzZXJBZ2VudFN0cmluZy5nZXQo KSk7CiB9CiAKIC8qKgpAQCAtMjU1NSwzICsyNTg5LDY0IEBAIHZvaWQgd2Via2l0X3NldHRpbmdz X3NldF9lbmFibGVfcGFnZV9jYWNoZShXZWJLaXRTZXR0aW5ncyogc2V0dGluZ3MsIGdib29sZWFu IGVuCiAgICAgV0tQcmVmZXJlbmNlc1NldFBhZ2VDYWNoZUVuYWJsZWQocHJpdi0+cHJlZmVyZW5j ZXMuZ2V0KCksIGVuYWJsZWQpOwogICAgIGdfb2JqZWN0X25vdGlmeShHX09CSkVDVChzZXR0aW5n cyksICJlbmFibGUtcGFnZS1jYWNoZSIpOwogfQorCisvKioKKyAqIHdlYmtpdF9zZXR0aW5nc19n ZXRfdXNlcl9hZ2VudDoKKyAqIEBzZXR0aW5nczogYSAjV2ViS2l0U2V0dGluZ3MKKyAqCisgKiBH ZXQgdGhlICNXZWJLaXRTZXR0aW5nczo6dXNlci1hZ2VudCBwcm9wZXJ0eS4KKyAqCisgKiBSZXR1 cm5zOiBUaGUgY3VycmVudCB2YWx1ZSBvZiB0aGUgdXNlci1hZ2VudCBwcm9wZXJ0eS4KKyAqLwor Y29uc3QgY2hhciogd2Via2l0X3NldHRpbmdzX2dldF91c2VyX2FnZW50KFdlYktpdFNldHRpbmdz KiBzZXR0aW5ncykKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfU0VUVElO R1Moc2V0dGluZ3MpLCAwKTsKKworICAgIFdlYktpdFNldHRpbmdzUHJpdmF0ZSogcHJpdiA9IHNl dHRpbmdzLT5wcml2OworICAgIEFTU0VSVCghcHJpdi0+dXNlckFnZW50U3RyaW5nLmlzTnVsbCgp KTsKKyAgICByZXR1cm4gcHJpdi0+dXNlckFnZW50U3RyaW5nLmRhdGEoKTsKK30KKworLyoqCisg KiB3ZWJraXRfc2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnQ6CisgKiBAc2V0dGluZ3M6IGEgI1dlYktp dFNldHRpbmdzCisgKiBAdXNlcl9hZ2VudDogVGhlIG5ldyBjdXN0b20gdXNlciBhZ2VudCBzdHJp bmcKKyAqCisgKiBTZXQgdGhlICNXZWJLaXRTZXR0aW5nczo6dXNlci1hZ2VudCBwcm9wZXJ0eS4K KyAqLwordm9pZCB3ZWJraXRfc2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnQoV2ViS2l0U2V0dGluZ3Mq IHNldHRpbmdzLCBjb25zdCBjaGFyKiB1c2VyQWdlbnQpCit7CisgICAgZ19yZXR1cm5faWZfZmFp bChXRUJLSVRfSVNfU0VUVElOR1Moc2V0dGluZ3MpKTsKKworICAgIFdlYktpdFNldHRpbmdzUHJp dmF0ZSogcHJpdiA9IHNldHRpbmdzLT5wcml2OworICAgIENTdHJpbmcgbmV3VXNlckFnZW50ID0g KCF1c2VyQWdlbnQgfHwgIXN0cmxlbih1c2VyQWdlbnQpKSA/IFdlYkNvcmU6OnN0YW5kYXJkVXNl ckFnZW50KCIiKS51dGY4KCkgOiB1c2VyQWdlbnQ7CisgICAgaWYgKG5ld1VzZXJBZ2VudCA9PSBw cml2LT51c2VyQWdlbnRTdHJpbmcpCisgICAgICAgIHJldHVybjsKKworICAgIHByaXYtPnVzZXJB Z2VudFN0cmluZyA9IG5ld1VzZXJBZ2VudDsKKyAgICBnX29iamVjdF9ub3RpZnkoR19PQkpFQ1Qo c2V0dGluZ3MpLCAidXNlci1hZ2VudCIpOworfQorCisvKioKKyAqIHdlYmtpdF9zZXR0aW5nc19z ZXRfdXNlcl9hZ2VudF93aXRoX2FwcGxpY2F0aW9uX25hbWU6CisgKiBAc2V0dGluZ3M6IGEgI1dl YktpdFNldHRpbmdzCisgKiBAYXBwbGljYXRpb25fbmFtZTogVGhlIGFwcGxpY2F0aW9uIG5hbWUg dXNlZCB0byBjcmVhdGUgdGhlIHVzZXIgYWdlbnQuCisgKgorICogU2V0IHRoZSAjV2ViS2l0U2V0 dGluZ3M6OnVzZXItYWdlbnQgcHJvcGVydHkgYnkgZm9ybWluZyB0aGUgc3RhbmRhcmQgdXNlcgor ICogYWdlbnQgd2l0aCB0aGUgZ2l2ZW4gYXBwbGljYXRpb24gbmFtZS4gSWYgQGFwcGxpY2F0aW9u X25hbWUgaXMgdGhlIGVtcHR5CisgKiBzdHJpbmcgb3IgbnVsbCwgdGhpcyBtZXRob2Qgc2V0cyB0 aGUgdXNlciBhZ2VudCBwcm9wZXJ0eSB0byB0aGUgc3RhbmRhcmQgdXNlcgorICogYWdlbnQgc3Ry aW5nIHdpdGggdGhlIGFwcGxpY2F0aW9uIG5hbWUgIldlYktpdEdUSysuIgorICovCisKK3ZvaWQg d2Via2l0X3NldHRpbmdzX3NldF91c2VyX2FnZW50X3dpdGhfYXBwbGljYXRpb25fbmFtZShXZWJL aXRTZXR0aW5ncyogc2V0dGluZ3MsIGNvbnN0IGNoYXIqIGFwcGxpY2F0aW9uTmFtZSkKK3sKKyAg ICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19TRVRUSU5HUyhzZXR0aW5ncykpOworCisgICAg V2ViS2l0U2V0dGluZ3NQcml2YXRlKiBwcml2ID0gc2V0dGluZ3MtPnByaXY7CisgICAgQ1N0cmlu ZyBuZXdVc2VyQWdlbnQgPSBXZWJDb3JlOjpzdGFuZGFyZFVzZXJBZ2VudChTdHJpbmc6OmZyb21V VEY4KGFwcGxpY2F0aW9uTmFtZSkpLnV0ZjgoKTsKKyAgICBpZiAobmV3VXNlckFnZW50ID09IHBy aXYtPnVzZXJBZ2VudFN0cmluZykKKyAgICAgICAgcmV0dXJuOworCisgICAgcHJpdi0+dXNlckFn ZW50U3RyaW5nID0gbmV3VXNlckFnZW50OworICAgIGdfb2JqZWN0X25vdGlmeShHX09CSkVDVChz ZXR0aW5ncyksICJ1c2VyLWFnZW50Iik7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRTZXR0aW5ncy5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0U2V0dGluZ3MuaAppbmRleCAwYzcxOWNkNDc5YTA0MDMyNDFkN2Jl Y2Q5ZmFhYjE2MzNhMDU1ODEzLi4zNGJkZTAxYTZhNTRkZDY2ZTIxZDQzZGNjZWRmZmVjZWMzYTA2 OWZlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRT ZXR0aW5ncy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFNl dHRpbmdzLmgKQEAgLTM2Miw2ICszNjIsMTYgQEAgV0VCS0lUX0FQSSB2b2lkCiB3ZWJraXRfc2V0 dGluZ3Nfc2V0X2VuYWJsZV9wYWdlX2NhY2hlICAgICAgICAgICAgICAgICAgICAgICAgICAoV2Vi S2l0U2V0dGluZ3MgKnNldHRpbmdzLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdib29sZWFuICAgICAgICBlbmFibGVkKTsK IAorV0VCS0lUX0FQSSBjb25zdCBnY2hhciAqCit3ZWJraXRfc2V0dGluZ3NfZ2V0X3VzZXJfYWdl bnQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoV2ViS2l0U2V0dGluZ3MgKnNldHRp bmdzKTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfc2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnQg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoV2ViS2l0U2V0dGluZ3MgKnNldHRpbmdz LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGNvbnN0IGdjaGFyICAgICp1c2VyX2FnZW50KTsKK1dFQktJVF9BUEkgdm9pZAor d2Via2l0X3NldHRpbmdzX3NldF91c2VyX2FnZW50X3dpdGhfYXBwbGljYXRpb25fbmFtZSAgICAg ICAgICAgKFdlYktpdFNldHRpbmdzICpzZXR0aW5ncywKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBnY2hhciAgICAq YXBwbGljYXRpb25fbmFtZSk7CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZiAvKiBXZWJLaXRTZXR0 aW5nc19oICovCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9k b2NzL3dlYmtpdDJndGstc2VjdGlvbnMudHh0IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQ SS9ndGsvZG9jcy93ZWJraXQyZ3RrLXNlY3Rpb25zLnR4dAppbmRleCA1OTY0OThjODM0MGM5MzE5 YmI1NWM5N2IzMTFlMjA0ODMwMjQ1ZTQwLi5lMGM3OGQzYThmOTcwMTdhYjZmODUzYjc3OTU3MTQ0 YmFkMzE0MzhlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9k b2NzL3dlYmtpdDJndGstc2VjdGlvbnMudHh0CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQKQEAgLTI4Myw2ICsyODMsOSBA QCB3ZWJraXRfc2V0dGluZ3NfZ2V0X2VuYWJsZV9zaXRlX3NwZWNpZmljX3F1aXJrcwogd2Via2l0 X3NldHRpbmdzX3NldF9lbmFibGVfc2l0ZV9zcGVjaWZpY19xdWlya3MKIHdlYmtpdF9zZXR0aW5n c19nZXRfZW5hYmxlX3BhZ2VfY2FjaGUKIHdlYmtpdF9zZXR0aW5nc19zZXRfZW5hYmxlX3BhZ2Vf Y2FjaGUKK3dlYmtpdF9zZXR0aW5nc19nZXRfdXNlcl9hZ2VudAord2Via2l0X3NldHRpbmdzX3Nl dF91c2VyX2FnZW50Cit3ZWJraXRfc2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnRfd2l0aF9hcHBsaWNh dGlvbl9uYW1lCiAKIDxTVUJTRUNUSU9OIFN0YW5kYXJkPgogV2ViS2l0U2V0dGluZ3NDbGFzcwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdFdl YktpdFNldHRpbmdzLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3Rz L1Rlc3RXZWJLaXRTZXR0aW5ncy5jcHAKaW5kZXggNWU2ZTkxYjA5Y2ZlYmM4MGViOGE0OTMyNGYx OGU5Y2M0OTZlOGNkZi4uOTZmYWI2ZDEyNTE2NTk1NmZjZmNhNmRlNjc4MGYzMmU1Yzg1NWQ1MCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdFdl YktpdFNldHRpbmdzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90 ZXN0cy9UZXN0V2ViS2l0U2V0dGluZ3MuY3BwCkBAIC0yNTQsMTAgKzI1NCwzOSBAQCB2b2lkIHRl c3RXZWJLaXRTZXR0aW5nc05ld1dpdGhTZXR0aW5ncyhUZXN0KiB0ZXN0LCBnY29uc3Rwb2ludGVy KQogICAgIGdfYXNzZXJ0KHdlYmtpdF9zZXR0aW5nc19nZXRfbG9hZF9pY29uc19pZ25vcmluZ19p bWFnZV9sb2FkX3NldHRpbmcoc2V0dGluZ3MuZ2V0KCkpKTsKIH0KIAorc3RhdGljIHZvaWQgdGVz dFdlYktpdFNldHRpbmdzVXNlckFnZW50KFRlc3QqLCBnY29uc3Rwb2ludGVyKQoreworICAgIEdS ZWZQdHI8V2ViS2l0U2V0dGluZ3M+IHNldHRpbmdzID0gYWRvcHRHUmVmKHdlYmtpdF9zZXR0aW5n c19uZXcoKSk7CisgICAgQ1N0cmluZyBkZWZhdWx0VXNlckFnZW50ID0gd2Via2l0X3NldHRpbmdz X2dldF91c2VyX2FnZW50KHNldHRpbmdzLmdldCgpKTsKKworICAgIGdfYXNzZXJ0KGdfc3Ryc3Ry X2xlbihkZWZhdWx0VXNlckFnZW50LmRhdGEoKSwgLTEsICJTYWZhcmkiKSk7CisgICAgZ19hc3Nl cnQoZ19zdHJzdHJfbGVuKGRlZmF1bHRVc2VyQWdlbnQuZGF0YSgpLCAtMSwgIkNocm9taXVtIikp OworICAgIGdfYXNzZXJ0KGdfc3Ryc3RyX2xlbihkZWZhdWx0VXNlckFnZW50LmRhdGEoKSwgLTEs ICJDaHJvbWUiKSk7CisKKyAgICBjb25zdCBjaGFyKiBmdW5reVVzZXJBZ2VudCA9ICJGdW5reSEi OworICAgIHdlYmtpdF9zZXR0aW5nc19zZXRfdXNlcl9hZ2VudChzZXR0aW5ncy5nZXQoKSwgZnVu a3lVc2VyQWdlbnQpOworICAgIGdfYXNzZXJ0X2NtcHN0cihmdW5reVVzZXJBZ2VudCwgPT0sIHdl YmtpdF9zZXR0aW5nc19nZXRfdXNlcl9hZ2VudChzZXR0aW5ncy5nZXQoKSkpOworCisgICAgd2Vi a2l0X3NldHRpbmdzX3NldF91c2VyX2FnZW50X3dpdGhfYXBwbGljYXRpb25fbmFtZShzZXR0aW5n cy5nZXQoKSwgIldlYktpdEdUSysiKTsKKyAgICBnX2Fzc2VydF9jbXBzdHIoZGVmYXVsdFVzZXJB Z2VudC5kYXRhKCksID09LCB3ZWJraXRfc2V0dGluZ3NfZ2V0X3VzZXJfYWdlbnQoc2V0dGluZ3Mu Z2V0KCkpKTsKKworICAgIHdlYmtpdF9zZXR0aW5nc19zZXRfdXNlcl9hZ2VudF93aXRoX2FwcGxp Y2F0aW9uX25hbWUoc2V0dGluZ3MuZ2V0KCksICJXZWJDYXRHVEsrIik7CisgICAgQ1N0cmluZyB3 ZWJDYXRVc2VyQWdlbnQgPSB3ZWJraXRfc2V0dGluZ3NfZ2V0X3VzZXJfYWdlbnQoc2V0dGluZ3Mu Z2V0KCkpOworICAgIGNoYXIqIHdlYkNhdCA9IGdfc3Ryc3RyX2xlbih3ZWJDYXRVc2VyQWdlbnQu ZGF0YSgpLCAtMSwgIldlYkNhdEdUSysiKTsKKyAgICBnX2Fzc2VydCh3ZWJDYXQpOworICAgIGdf YXNzZXJ0X2NtcGludChzdHJsZW4od2ViQ2F0VXNlckFnZW50LmRhdGEoKSksID09LCBzdHJsZW4o ZGVmYXVsdFVzZXJBZ2VudC5kYXRhKCkpKTsKKworICAgIC8vIFRlc3QgdGhhdCB0aGUgb25seSBk aWZmZXJlbmNlIGJldHdlZW4gdGhlIGRlZmF1bHQgYW5kIHRoZSB1c2VyIGFnZW50IHNldCB3aXRo IHRoZQorICAgIC8vIGFwcGxpY2F0aW9uIG5hbWUgaXMgdGhlIGFwcGxpY2F0aW9uIG5hbWUuCisg ICAgc3RybmNweSh3ZWJDYXQsICJXZWJLaXRHVEsrIiwgc3RybGVuKCJXZWJLaXRHVEsrIikpOwor ICAgIGdfYXNzZXJ0X2NtcHN0cihkZWZhdWx0VXNlckFnZW50LmRhdGEoKSwgPT0sIHdlYkNhdFVz ZXJBZ2VudC5kYXRhKCkpOworfQorCiB2b2lkIGJlZm9yZUFsbCgpCiB7CiAgICAgVGVzdDo6YWRk KCJXZWJLaXRTZXR0aW5ncyIsICJ3ZWJraXQtc2V0dGluZ3MiLCB0ZXN0V2ViS2l0U2V0dGluZ3Mp OwogICAgIFRlc3Q6OmFkZCgiV2ViS2l0U2V0dGluZ3MiLCAibmV3LXdpdGgtc2V0dGluZ3MiLCB0 ZXN0V2ViS2l0U2V0dGluZ3NOZXdXaXRoU2V0dGluZ3MpOworICAgIFRlc3Q6OmFkZCgiV2ViS2l0 U2V0dGluZ3MiLCAidXNlci1hZ2VudCIsIHRlc3RXZWJLaXRTZXR0aW5nc1VzZXJBZ2VudCk7CiB9 CiAKIHZvaWQgYWZ0ZXJBbGwoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L2d0ay9XZWJQYWdlUHJveHlHdGsuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2d0ay9X ZWJQYWdlUHJveHlHdGsuY3BwCmluZGV4IGFjMjZjMGNiOGZkYmI4YzllNzI1ZjkzM2I4NDc4YTJh NGRjYzBmN2MuLmRkNDEzZWRkMTBmYTllNTc3MWU5MWRmNzA4MzljZDY5MTkwMzc4YjEgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9ndGsvV2ViUGFnZVByb3h5R3RrLmNwcAor KysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL1dlYlBhZ2VQcm94eUd0ay5jcHAKQEAg LTMzLDYgKzMzLDcgQEAKICNpbmNsdWRlICJXZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUuaCIKICNp bmNsdWRlICJXZWJQYWdlTWVzc2FnZXMuaCIKICNpbmNsdWRlICJXZWJQcm9jZXNzUHJveHkuaCIK KyNpbmNsdWRlIDxXZWJDb3JlL1VzZXJBZ2VudEd0ay5oPgogI2luY2x1ZGUgPGd0ay9ndGt4Lmg+ CiAKIG5hbWVzcGFjZSBXZWJLaXQgewpAQCAtNDQsOCArNDUsNyBAQCBHdGtXaWRnZXQqIFdlYlBh Z2VQcm94eTo6dmlld1dpZGdldCgpCiAKIFN0cmluZyBXZWJQYWdlUHJveHk6OnN0YW5kYXJkVXNl ckFnZW50KGNvbnN0IFN0cmluZyYgYXBwbGljYXRpb25OYW1lRm9yVXNlckFnZW50KQogewotICAg IC8vIEZJWE1FOiBUaGlzIHNob3VsZCBub3QgYmUgaGFyZCBjb2RlZC4KLSAgICByZXR1cm4gIk1v emlsbGEvNS4wIChYMTE7IExpbnV4IGk2ODYpIEFwcGxlV2ViS2l0LzUzNC43IChLSFRNTCwgbGlr ZSBHZWNrbykgVmVyc2lvbi81LjAgU2FmYXJpLzUzNC43IjsKKyAgICByZXR1cm4gV2ViQ29yZTo6 c3RhbmRhcmRVc2VyQWdlbnQoYXBwbGljYXRpb25OYW1lRm9yVXNlckFnZW50KTsKIH0KIAogdm9p ZCBXZWJQYWdlUHJveHk6OmdldEVkaXRvckNvbW1hbmRzRm9yS2V5RXZlbnQoY29uc3QgQXRvbWlj U3RyaW5nJiBldmVudFR5cGUsIFZlY3RvcjxXVEY6OlN0cmluZz4mIGNvbW1hbmRzTGlzdCkKZGlm ZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0NoYW5nZUxvZwppbmRleCA0MDE5OWQ1ZWM5OTMxZGYwODZi ZDY4N2RmMDY5NjE1NmQ0N2I2NDE1Li43NGUxNzY0NTI5YzIwMDYwMWVmYzU4NmFmOWY3YzI3NTE5 YzAzMzdkIDEwMDY0NAotLS0gYS9DaGFuZ2VMb2cKKysrIGIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MTYgQEAKKzIwMTItMDktMDMgIE1hcnRpbiBSb2JpbnNvbiAgPG1yb2JpbnNvbkBpZ2FsaWEuY29t PgorCisgICAgICAgIFtXZWJLaXQyXSBbR1RLXSBBZGQgQVBJIGZvciBjb250cm9sbGluZyB0aGUg dXNlciBhZ2VudAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9OTU2OTcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBBZGRlZCBhbiBhdXRvY29uZiBzdGVwIGZvciB0aGUgbmV3IHVzZXIgYWdlbnQgc2hhcmVkIGNv ZGUgaGVhZGVyIGluCisgICAgICAgIFdlYkNvcmUuIFRoaXMgaXMgbmVjZXNzYXJ5IHNvIHRoYXQg d2UgY2FuIHVzZSB0aGUgdXNlciBhZ2VudCB2ZXJzaW9uCisgICAgICAgIGJhc2VkIG9uIHRoZSBp bmZvcm1hdGlvbiBpbiB0aGUgY29uZmlndXJlLmFjIGZpbGUuCisKKyAgICAgICAgKiBjb25maWd1 cmUuYWM6CisKIDIwMTItMDgtMjkgIFRoaWFnbyBNYWNpZWlyYSAgPHRoaWFnby5tYWNpZWlyYUBp bnRlbC5jb20+CiAKICAgICAgICAgVGVsbCBnaXQtYXJjaGl2ZSB0byBub3QgZXhwb3J0IC5naXRh dHRyaWJ1dGVzIGFuZCAuZ2l0aWdub3JlCmRpZmYgLS1naXQgYS9jb25maWd1cmUuYWMgYi9jb25m aWd1cmUuYWMKaW5kZXggMTIxZGNjYWUzYTlhMTE3ODlkMTJlNzYyODRiYWNlZjc1ZjdmNjgyYy4u MTQwMjQxM2NmNWU0YzhmODkzODAxYjI2MWE0ODc4MTY0YjNlNTRlZSAxMDA2NDQKLS0tIGEvY29u ZmlndXJlLmFjCisrKyBiL2NvbmZpZ3VyZS5hYwpAQCAtMTUxNSw2ICsxNTE1LDcgQEAgR05VbWFr ZWZpbGUKIAogQUNfQ09ORklHX0ZJTEVTKFsKIFNvdXJjZS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXR2ZXJzaW9uLmgKK0Rlcml2ZWRTb3VyY2VzL1dlYkNvcmUvVXNlckFnZW50R3RrLmg6U291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1VzZXJBZ2VudEd0ay5oLmluCiBdKQogCiBBQ19DT05GSUdf RklMRVMoWwo= 162588 2012-09-06 14:34:40 -0700 2012-09-07 12:04:39 -0700 Patch bug-95697-20120906143421.patch text/plain 14448 mrobinson U3VidmVyc2lvbiBSZXZpc2lvbjogMTI3NzgzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggNGI5ODc3ODU5OWY2ODlj NGU1OTM3OTk3YWJmNzQ3NjIyNTJjMTVlNi4uNjVmYzE5OTk4YTQ3OWM4MzNmM2JiZmQ3OTg4OTU2 YmNiNTkwZDRjNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDEyLTA5LTA0ICBNYXJ0 aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KKworICAgICAgICBbV2ViS2l0Ml0g W0dUS10gQWRkIEFQSSBmb3IgY29udHJvbGxpbmcgdGhlIHVzZXIgYWdlbnQKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTk1Njk3CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEFQSSBmb3IgY2hhbmdpbmcg dGhlIHVzZXIgYWdlbnQgaW4gV2ViS2l0Mi4gVGhpcyBhZGRzIHR3byBzdHlsZXMgb2YKKyAgICAg ICAgc2V0dGluZyB0aGUgdXNlciBhZ2VudDogY29tcGxldGUgb3ZlcnJpZGUgYW5kIGEgbWV0aG9k IHRoYXQganVzdCBpbnNlcnRzCisgICAgICAgIHRoZSBhcHBsaWNhdGlvbiBuYW1lIGFuZCB2ZXJz aW9uLCBidXQgcHJlc2VydmVzIHRoZSBjYXJlZnVsbHkgY3JhZnRlZCB1c2VyIGFnZW50CisgICAg ICAgIGluIHRoZSBsaWJyYXJ5LgorCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0 U2V0dGluZ3MuY3BwOgorICAgICAgICAoX1dlYktpdFNldHRpbmdzUHJpdmF0ZSk6IEFkZGVkIGEg bmV3IGZpZWxkIHRvIHN0b3JlIHRoZSB1c2VyIGFnZW50LgorICAgICAgICBUaGlzIGlzIHN0b3Jl ZCBpbiB0aGUgcHJpdmF0ZSBkYXRhIHN0cnVjdHVyZSwgYmVjYXVzZSB3ZSBjYW4gb25seQorICAg ICAgICBzZXQgdGhlIHVzZXIgYWdlbnQgd2hlbiBhdHRhY2hpbmcgdGhlIHNldHRpbmdzIHRvIHRo ZSBwYWdlLgorICAgICAgICAod2ViS2l0U2V0dGluZ3NTZXRQcm9wZXJ0eSk6IEFkZCBob29rcyBm b3IgdGhlIG5ldyB1c2VyIGFnZW50IHByb3BlcnR5LgorICAgICAgICAod2ViS2l0U2V0dGluZ3NH ZXRQcm9wZXJ0eSk6IERpdHRvLgorICAgICAgICAod2Via2l0X3NldHRpbmdzX2NsYXNzX2luaXQp OiBEaXR0by4KKyAgICAgICAgKHdlYmtpdFNldHRpbmdzQXR0YWNoU2V0dGluZ3NUb1BhZ2UpOiBE aXR0by4KKyAgICAgICAgKHdlYmtpdF9zZXR0aW5nc19nZXRfdXNlcl9hZ2VudCk6IEFkZGVkLgor ICAgICAgICAod2Via2l0X3NldHRpbmdzX3NldF91c2VyX2FnZW50KTogQWRkZWQuCisgICAgICAg ICh3ZWJraXRfc2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnRfd2l0aF9hcHBsaWNhdGlvbl9uYW1lKTog QWRkZWQuCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2V0dGluZ3MuaDogQWRk ZWQgbmV3IG1ldGhvZHMuCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQy Z3RrLXNlY3Rpb25zLnR4dDogQWRkZWQgbmV3IG1ldGhvZHMgdG8KKyAgICAgICAgdGhlIGRvY3Vt ZW50YXRpb24uCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdFdlYktpdFNl dHRpbmdzLmNwcDogVGVzdCB0aGUgbmV3IHVzZXIgYWdlbnQKKyAgICAgICAgcHJvcGVydHkuCisg ICAgICAgICh0ZXN0V2ViS2l0U2V0dGluZ3NVc2VyQWdlbnQpOiBEaXR0by4KKyAgICAgICAgKGJl Zm9yZUFsbCk6IERpdHRvLgorICAgICAgICAqIFVJUHJvY2Vzcy9ndGsvV2ViUGFnZVByb3h5R3Rr LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpzdGFuZGFyZFVzZXJBZ2VudCk6 IE5vdyB1c2UgdGhlIHNoYXJlZCBXZWJDb3JlCisgICAgICAgIGNvZGUgd2hlbiBzZXR0aW5nIHRo ZSB1c2VyIGFnZW50LgorCiAyMDEyLTA5LTA1ICBBbGV4ZXkgUHJvc2t1cnlha292ICA8YXBAYXBw bGUuY29tPgogCiAgICAgICAgIFtXSzJdIEFubm90YXRlIG11bHRpLXByb2Nlc3MgRklYTUVzIHdp dGggYnVnIG51bWJlcnMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkv Z3RrL1dlYktpdFNldHRpbmdzLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3Rr L1dlYktpdFNldHRpbmdzLmNwcAppbmRleCA1ZTBiZTdkMzIyMDVkZmI3MGMyYjllZTYxMjA3YjAy ZjlkN2U3MmNmLi5kYTA3ODY0NDY3Y2NkZmQ2ZjEyMzZhOGI4OTRlYTdiNTJkNGIxOTBlIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRTZXR0aW5ncy5j cHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2V0dGluZ3Mu Y3BwCkBAIC0zNCw2ICszNCw3IEBACiAjaW5jbHVkZSAiV2ViS2l0UHJpdmF0ZS5oIgogI2luY2x1 ZGUgIldlYktpdFNldHRpbmdzUHJpdmF0ZS5oIgogI2luY2x1ZGUgIldlYlBhZ2VQcm94eS5oIgor I2luY2x1ZGUgPFdlYkNvcmUvVXNlckFnZW50R3RrLmg+CiAjaW5jbHVkZSA8Z2xpYi9naTE4bi1s aWIuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CiAKQEAgLTQ3LDYgKzQ4LDcgQEAg c3RydWN0IF9XZWJLaXRTZXR0aW5nc1ByaXZhdGUgewogICAgIENTdHJpbmcgZmFudGFzeUZvbnRG YW1pbHk7CiAgICAgQ1N0cmluZyBwaWN0b2dyYXBoRm9udEZhbWlseTsKICAgICBDU3RyaW5nIGRl ZmF1bHRDaGFyc2V0OworICAgIENTdHJpbmcgdXNlckFnZW50OwogICAgIGJvb2wgYWxsb3dNb2Rh bERpYWxvZ3M7CiAgICAgYm9vbCB6b29tVGV4dE9ubHk7CiB9OwpAQCAtMTE0LDcgKzExNiw4IEBA IGVudW0gewogICAgIFBST1BfTUVESUFfUExBWUJBQ0tfQUxMT1dTX0lOTElORSwKICAgICBQUk9Q X0RSQVdfQ09NUE9TSVRJTkdfSU5ESUNBVE9SUywKICAgICBQUk9QX0VOQUJMRV9TSVRFX1NQRUNJ RklDX1FVSVJLUywKLSAgICBQUk9QX0VOQUJMRV9QQUdFX0NBQ0hFCisgICAgUFJPUF9FTkFCTEVf UEFHRV9DQUNIRSwKKyAgICBQUk9QX1VTRVJfQUdFTlQKIH07CiAKIHN0YXRpYyB2b2lkIHdlYktp dFNldHRpbmdzU2V0UHJvcGVydHkoR09iamVjdCogb2JqZWN0LCBndWludCBwcm9wSWQsIGNvbnN0 IEdWYWx1ZSogdmFsdWUsIEdQYXJhbVNwZWMqIHBhcmFtU3BlYykKQEAgLTI0NSw2ICsyNDgsOSBA QCBzdGF0aWMgdm9pZCB3ZWJLaXRTZXR0aW5nc1NldFByb3BlcnR5KEdPYmplY3QqIG9iamVjdCwg Z3VpbnQgcHJvcElkLCBjb25zdCBHVmFsdQogICAgIGNhc2UgUFJPUF9FTkFCTEVfUEFHRV9DQUNI RToKICAgICAgICAgd2Via2l0X3NldHRpbmdzX3NldF9lbmFibGVfcGFnZV9jYWNoZShzZXR0aW5n cywgZ192YWx1ZV9nZXRfYm9vbGVhbih2YWx1ZSkpOwogICAgICAgICBicmVhazsKKyAgICBjYXNl IFBST1BfVVNFUl9BR0VOVDoKKyAgICAgICAgd2Via2l0X3NldHRpbmdzX3NldF91c2VyX2FnZW50 KHNldHRpbmdzLCBnX3ZhbHVlX2dldF9zdHJpbmcodmFsdWUpKTsKKyAgICAgICAgYnJlYWs7CiAg ICAgZGVmYXVsdDoKICAgICAgICAgR19PQkpFQ1RfV0FSTl9JTlZBTElEX1BST1BFUlRZX0lEKG9i amVjdCwgcHJvcElkLCBwYXJhbVNwZWMpOwogICAgICAgICBicmVhazsKQEAgLTM3OSw2ICszODUs OSBAQCBzdGF0aWMgdm9pZCB3ZWJLaXRTZXR0aW5nc0dldFByb3BlcnR5KEdPYmplY3QqIG9iamVj dCwgZ3VpbnQgcHJvcElkLCBHVmFsdWUqIHZhbAogICAgIGNhc2UgUFJPUF9FTkFCTEVfUEFHRV9D QUNIRToKICAgICAgICAgZ192YWx1ZV9zZXRfYm9vbGVhbih2YWx1ZSwgd2Via2l0X3NldHRpbmdz X2dldF9lbmFibGVfcGFnZV9jYWNoZShzZXR0aW5ncykpOwogICAgICAgICBicmVhazsKKyAgICBj YXNlIFBST1BfVVNFUl9BR0VOVDoKKyAgICAgICAgZ192YWx1ZV9zZXRfc3RyaW5nKHZhbHVlLCB3 ZWJraXRfc2V0dGluZ3NfZ2V0X3VzZXJfYWdlbnQoc2V0dGluZ3MpKTsKKyAgICAgICAgYnJlYWs7 CiAgICAgZGVmYXVsdDoKICAgICAgICAgR19PQkpFQ1RfV0FSTl9JTlZBTElEX1BST1BFUlRZX0lE KG9iamVjdCwgcHJvcElkLCBwYXJhbVNwZWMpOwogICAgICAgICBicmVhazsKQEAgLTEwMTAsNiAr MTAxOSwyNiBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfc2V0dGluZ3NfY2xhc3NfaW5pdChXZWJLaXRT ZXR0aW5nc0NsYXNzKiBrbGFzcykKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIFRSVUUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWFkV3JpdGVDb25zdHJ1Y3RQYXJhbUZsYWdz KSk7CiAKKyAgICAvKioKKyAgICAgKiBXZWJLaXRTZXR0aW5nczp1c2VyLWFnZW50OgorICAgICAq CisgICAgICogVGhlIHVzZXItYWdlbnQgc3RyaW5nIHVzZWQgYnkgV2ViS2l0IGluIHRoZSBoZWFk ZXJzLiBVbnVzdWFsIHVzZXItYWdlbnQgc3RyaW5ncworICAgICAqIG1heSBjYXVzZSB3ZWIgY29u dGVudCB0byByZW5kZXIgaW5jb3JyZWN0bHkgb3IgZmFpbCB0byBydW4sIGFzIG1hbnkgd2ViIHBh Z2VzIGFyZQorICAgICAqIHdyaXR0ZW4gdG8gcGFyc2UgdGhlIHVzZXItYWdlbnQgc3RyaW5ncyBv ZiBvbmx5IHRoZSBtb3N0IHBvcHVsYXIgYnJvd3NlcnMuIFRoZXJlZm9yZSwKKyAgICAgKiBpdCdz IHR5cGljYWxseSBiZXR0ZXIgdG8gbm90IGNvbXBsZXRlbHkgb3ZlcnJpZGUgdGhlIHN0YW5kYXJk IHVzZXItYWdlbnQsIGJ1dCB0byB1c2UKKyAgICAgKiB3ZWJraXRfc2V0dGluZ3Nfc2V0X3VzZXJf YWdlbnRfd2l0aF9hcHBsaWNhdGlvbl9kZXRhaWxzKCkgaW5zdGVhZC4KKyAgICAgKgorICAgICAq IElmIHRoaXMgcHJvcGVydHkgaXMgc2V0IHRvIHRoZSBlbXB0eSBzdHJpbmcgb3IgJU5VTEwsIGl0 IHdpbGwgcmV2ZXJ0IHRvIHRoZSBzdGFuZGFyZAorICAgICAqIHVzZXItYWdlbnQuCisgICAgICov CisgICAgZ19vYmplY3RfY2xhc3NfaW5zdGFsbF9wcm9wZXJ0eShnT2JqZWN0Q2xhc3MsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQUk9QX1VTRVJfQUdFTlQsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnX3BhcmFtX3NwZWNfc3RyaW5nKCJ1c2VyLWFn ZW50IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgXygiVXNlciBhZ2VudCBzdHJpbmciKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXygiVGhlIHVzZXIgYWdlbnQgc3RyaW5nIiks CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IDAsIC8vIEEgbnVsbCBzdHJpbmcgZm9yY2VzIHRoZSBzdGFuZGFyZCB1c2VyIGFnZW50LgorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWFk V3JpdGVDb25zdHJ1Y3RQYXJhbUZsYWdzKSk7CisKICAgICBnX3R5cGVfY2xhc3NfYWRkX3ByaXZh dGUoa2xhc3MsIHNpemVvZihXZWJLaXRTZXR0aW5nc1ByaXZhdGUpKTsKIH0KIApAQCAtMTA0OCw4 ICsxMDc3LDEzIEBAIHN0YXRpYyB2b2lkIHdlYmtpdF9zZXR0aW5nc19pbml0KFdlYktpdFNldHRp bmdzKiBzZXR0aW5ncykKIAogdm9pZCB3ZWJraXRTZXR0aW5nc0F0dGFjaFNldHRpbmdzVG9QYWdl KFdlYktpdFNldHRpbmdzKiBzZXR0aW5ncywgV0tQYWdlUmVmIHdrUGFnZSkKIHsKLSAgICBXS1Bh Z2VHcm91cFNldFByZWZlcmVuY2VzKFdLUGFnZUdldFBhZ2VHcm91cCh3a1BhZ2UpLCBzZXR0aW5n cy0+cHJpdi0+cHJlZmVyZW5jZXMuZ2V0KCkpOwotICAgIFdlYktpdDo6dG9JbXBsKHdrUGFnZSkt PnNldENhblJ1bk1vZGFsKHNldHRpbmdzLT5wcml2LT5hbGxvd01vZGFsRGlhbG9ncyk7CisgICAg V2ViS2l0U2V0dGluZ3NQcml2YXRlKiBwcml2ID0gc2V0dGluZ3MtPnByaXY7CisgICAgV0tQYWdl R3JvdXBTZXRQcmVmZXJlbmNlcyhXS1BhZ2VHZXRQYWdlR3JvdXAod2tQYWdlKSwgcHJpdi0+cHJl ZmVyZW5jZXMuZ2V0KCkpOworICAgIFdlYktpdDo6dG9JbXBsKHdrUGFnZSktPnNldENhblJ1bk1v ZGFsKHByaXYtPmFsbG93TW9kYWxEaWFsb2dzKTsKKworICAgIEFTU0VSVCghcHJpdi0+dXNlckFn ZW50LmlzTnVsbCgpKTsKKyAgICBXS1JldGFpblB0cjxXS1N0cmluZ1JlZj4gdXNlckFnZW50PSBh ZG9wdFdLKFdLU3RyaW5nQ3JlYXRlV2l0aFVURjhDU3RyaW5nKHByaXYtPnVzZXJBZ2VudC5kYXRh KCkpKTsKKyAgICBXS1BhZ2VTZXRDdXN0b21Vc2VyQWdlbnQod2tQYWdlLCB1c2VyQWdlbnQuZ2V0 KCkpOwogfQogCiAvKioKQEAgLTI1NTUsMyArMjU4OSw2MCBAQCB2b2lkIHdlYmtpdF9zZXR0aW5n c19zZXRfZW5hYmxlX3BhZ2VfY2FjaGUoV2ViS2l0U2V0dGluZ3MqIHNldHRpbmdzLCBnYm9vbGVh biBlbgogICAgIFdLUHJlZmVyZW5jZXNTZXRQYWdlQ2FjaGVFbmFibGVkKHByaXYtPnByZWZlcmVu Y2VzLmdldCgpLCBlbmFibGVkKTsKICAgICBnX29iamVjdF9ub3RpZnkoR19PQkpFQ1Qoc2V0dGlu Z3MpLCAiZW5hYmxlLXBhZ2UtY2FjaGUiKTsKIH0KKworLyoqCisgKiB3ZWJraXRfc2V0dGluZ3Nf Z2V0X3VzZXJfYWdlbnQ6CisgKiBAc2V0dGluZ3M6IGEgI1dlYktpdFNldHRpbmdzCisgKgorICog R2V0IHRoZSAjV2ViS2l0U2V0dGluZ3M6dXNlci1hZ2VudCBwcm9wZXJ0eS4KKyAqCisgKiBSZXR1 cm5zOiBUaGUgY3VycmVudCB2YWx1ZSBvZiB0aGUgdXNlci1hZ2VudCBwcm9wZXJ0eS4KKyAqLwor Y29uc3QgY2hhciogd2Via2l0X3NldHRpbmdzX2dldF91c2VyX2FnZW50KFdlYktpdFNldHRpbmdz KiBzZXR0aW5ncykKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfU0VUVElO R1Moc2V0dGluZ3MpLCAwKTsKKworICAgIFdlYktpdFNldHRpbmdzUHJpdmF0ZSogcHJpdiA9IHNl dHRpbmdzLT5wcml2OworICAgIEFTU0VSVCghcHJpdi0+dXNlckFnZW50LmlzTnVsbCgpKTsKKyAg ICByZXR1cm4gcHJpdi0+dXNlckFnZW50LmRhdGEoKTsKK30KKworLyoqCisgKiB3ZWJraXRfc2V0 dGluZ3Nfc2V0X3VzZXJfYWdlbnQ6CisgKiBAc2V0dGluZ3M6IGEgI1dlYktpdFNldHRpbmdzCisg KiBAdXNlcl9hZ2VudDogVGhlIG5ldyBjdXN0b20gdXNlciBhZ2VudCBzdHJpbmcKKyAqCisgKiBT ZXQgdGhlICNXZWJLaXRTZXR0aW5nczp1c2VyLWFnZW50IHByb3BlcnR5LgorICovCit2b2lkIHdl YmtpdF9zZXR0aW5nc19zZXRfdXNlcl9hZ2VudChXZWJLaXRTZXR0aW5ncyogc2V0dGluZ3MsIGNv bnN0IGNoYXIqIHVzZXJBZ2VudCkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19T RVRUSU5HUyhzZXR0aW5ncykpOworCisgICAgV2ViS2l0U2V0dGluZ3NQcml2YXRlKiBwcml2ID0g c2V0dGluZ3MtPnByaXY7CisgICAgQ1N0cmluZyBuZXdVc2VyQWdlbnQgPSAoIXVzZXJBZ2VudCB8 fCAhc3RybGVuKHVzZXJBZ2VudCkpID8gV2ViQ29yZTo6c3RhbmRhcmRVc2VyQWdlbnQoIiIpLnV0 ZjgoKSA6IHVzZXJBZ2VudDsKKyAgICBpZiAobmV3VXNlckFnZW50ID09IHByaXYtPnVzZXJBZ2Vu dCkKKyAgICAgICAgcmV0dXJuOworCisgICAgcHJpdi0+dXNlckFnZW50ID0gbmV3VXNlckFnZW50 OworICAgIGdfb2JqZWN0X25vdGlmeShHX09CSkVDVChzZXR0aW5ncyksICJ1c2VyLWFnZW50Iik7 Cit9CisKKy8qKgorICogd2Via2l0X3NldHRpbmdzX3NldF91c2VyX2FnZW50X3dpdGhfYXBwbGlj YXRpb25fZGV0YWlsczoKKyAqIEBzZXR0aW5nczogYSAjV2ViS2l0U2V0dGluZ3MKKyAqIEBhcHBs aWNhdGlvbl9uYW1lOiBUaGUgYXBwbGljYXRpb24gbmFtZSB1c2VkIHRvIGNyZWF0ZSB0aGUgdXNl ciBhZ2VudC4gSWYgdGhlIHZhbHVlIHBhc3NlZAorICogaXMgJU5VTEwgb3IgdGhlIGVtcHR5IHN0 cmluZywgdGhlIGRlZmF1bHQgdXNlciBhZ2VudCB3aWxsIGJlIHVzZWQuCisgKiBAYXBwbGljYXRp b25fdmVyc2lvbjogVGhlIGFwcGxpY2F0aW9uIHZlcnNpb24gdXNlZCB0byBjcmVhdGUgdGhlIHVz ZXIgYWdlbnQuIElmIHRoZSB2YWx1ZSBwYXNzZWQKKyAqIGlzICVOVUxMIG9yIHRoZSBlbXB0eSBz dHJpbmcsIHRoZSB2ZXJzaW9uIG9mIFNhZmFyaSBhdCB0aGUgdGltZSBvZiB0aGlzIHJlbGVhc2Ug d2lsbCBiZSB1c2VkLgorICoKKyAqIFNldCB0aGUgI1dlYktpdFNldHRpbmdzOnVzZXItYWdlbnQg cHJvcGVydHkgYnkgYXBwZW5kaW5nIHRoZSBhcHBsaWNhdGlvbiBkZXRhaWxzIHRvIHRoZSBkZWZh dWx0IHVzZXIKKyAqIGFnZW50LiBJZiBubyBhcHBsaWNhdGlvbiBuYW1lIG9yIHZlcnNpb24gaXMg Z2l2ZW4sIHRoZSBkZWZhdWx0IHVzZXIgYWdlbnQgdXNlZCB3aWxsIGJlIHVzZWQuCisgKi8KKwor dm9pZCB3ZWJraXRfc2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnRfd2l0aF9hcHBsaWNhdGlvbl9kZXRh aWxzKFdlYktpdFNldHRpbmdzKiBzZXR0aW5ncywgY29uc3QgY2hhciogYXBwbGljYXRpb25OYW1l LCBjb25zdCBjaGFyKiBhcHBsaWNhdGlvblZlcnNpb24pCit7CisgICAgZ19yZXR1cm5faWZfZmFp bChXRUJLSVRfSVNfU0VUVElOR1Moc2V0dGluZ3MpKTsKKworICAgIENTdHJpbmcgbmV3VXNlckFn ZW50ID0gV2ViQ29yZTo6c3RhbmRhcmRVc2VyQWdlbnQoU3RyaW5nOjpmcm9tVVRGOChhcHBsaWNh dGlvbk5hbWUpLCBTdHJpbmc6OmZyb21VVEY4KGFwcGxpY2F0aW9uVmVyc2lvbikpLnV0ZjgoKTsK KyAgICB3ZWJraXRfc2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnQoc2V0dGluZ3MsIG5ld1VzZXJBZ2Vu dC5kYXRhKCkpOworfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0U2V0dGluZ3MuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dl YktpdFNldHRpbmdzLmgKaW5kZXggMGM3MTljZDQ3OWEwNDAzMjQxZDdiZWNkOWZhYWIxNjMzYTA1 NTgxMy4uYjM1YTIzZjA2MTg5MzE5MDVhM2NjNmJlZGRmNmQxZmRjMzVhZDY4YSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2V0dGluZ3MuaAorKysg Yi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRTZXR0aW5ncy5oCkBAIC0z NjIsNiArMzYyLDE3IEBAIFdFQktJVF9BUEkgdm9pZAogd2Via2l0X3NldHRpbmdzX3NldF9lbmFi bGVfcGFnZV9jYWNoZSAgICAgICAgICAgICAgICAgICAgICAgICAgKFdlYktpdFNldHRpbmdzICpz ZXR0aW5ncywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBnYm9vbGVhbiAgICAgICAgZW5hYmxlZCk7CiAKK1dFQktJVF9BUEkg Y29uc3QgZ2NoYXIgKgord2Via2l0X3NldHRpbmdzX2dldF91c2VyX2FnZW50ICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgKFdlYktpdFNldHRpbmdzICpzZXR0aW5ncyk7CisKK1dFQktJ VF9BUEkgdm9pZAord2Via2l0X3NldHRpbmdzX3NldF91c2VyX2FnZW50ICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgKFdlYktpdFNldHRpbmdzICpzZXR0aW5ncywKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25z dCBnY2hhciAgICAqdXNlcl9hZ2VudCk7CitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF9zZXR0aW5n c19zZXRfdXNlcl9hZ2VudF93aXRoX2FwcGxpY2F0aW9uX2RldGFpbHMgICAgICAgIChXZWJLaXRT ZXR0aW5ncyAqc2V0dGluZ3MsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgZ2NoYXIgICAgKmFwcGxpY2F0aW9uX25h bWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgY29uc3QgZ2NoYXIgICAgKmFwcGxpY2F0aW9uX3ZlcnNpb24pOworCiBHX0VO RF9ERUNMUwogCiAjZW5kaWYgLyogV2ViS2l0U2V0dGluZ3NfaCAqLwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLXNlY3Rpb25zLnR4 dCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0 aW9ucy50eHQKaW5kZXggNTk2NDk4YzgzNDBjOTMxOWJiNTVjOTdiMzExZTIwNDgzMDI0NWU0MC4u ZjMwZTg0ZTgzMzk2ZjkxMGI2MzliNzllNTliZDkwNWIzZWY3OWQwZiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLXNlY3Rpb25zLnR4 dAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGst c2VjdGlvbnMudHh0CkBAIC0yODMsNiArMjgzLDkgQEAgd2Via2l0X3NldHRpbmdzX2dldF9lbmFi bGVfc2l0ZV9zcGVjaWZpY19xdWlya3MKIHdlYmtpdF9zZXR0aW5nc19zZXRfZW5hYmxlX3NpdGVf c3BlY2lmaWNfcXVpcmtzCiB3ZWJraXRfc2V0dGluZ3NfZ2V0X2VuYWJsZV9wYWdlX2NhY2hlCiB3 ZWJraXRfc2V0dGluZ3Nfc2V0X2VuYWJsZV9wYWdlX2NhY2hlCit3ZWJraXRfc2V0dGluZ3NfZ2V0 X3VzZXJfYWdlbnQKK3dlYmtpdF9zZXR0aW5nc19zZXRfdXNlcl9hZ2VudAord2Via2l0X3NldHRp bmdzX3NldF91c2VyX2FnZW50X3dpdGhfYXBwbGljYXRpb25fZGV0YWlscwogCiA8U1VCU0VDVElP TiBTdGFuZGFyZD4KIFdlYktpdFNldHRpbmdzQ2xhc3MKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RXZWJLaXRTZXR0aW5ncy5jcHAgYi9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9UZXN0V2ViS2l0U2V0dGluZ3MuY3Bw CmluZGV4IDVlNmU5MWIwOWNmZWJjODBlYjhhNDkzMjRmMThlOWNjNDk2ZThjZGYuLjAzZmEzOGNj MDZmNzI0Yjc3ZTgxZjZiYWNmN2U5NGEwYjg2NmFlNzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RXZWJLaXRTZXR0aW5ncy5jcHAKKysrIGIv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdFdlYktpdFNldHRpbmdz LmNwcApAQCAtMjU0LDEwICsyNTQsNDQgQEAgdm9pZCB0ZXN0V2ViS2l0U2V0dGluZ3NOZXdXaXRo U2V0dGluZ3MoVGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRlcikKICAgICBnX2Fzc2VydCh3ZWJraXRf c2V0dGluZ3NfZ2V0X2xvYWRfaWNvbnNfaWdub3JpbmdfaW1hZ2VfbG9hZF9zZXR0aW5nKHNldHRp bmdzLmdldCgpKSk7CiB9CiAKK3N0YXRpYyB2b2lkIHRlc3RXZWJLaXRTZXR0aW5nc1VzZXJBZ2Vu dChUZXN0KiwgZ2NvbnN0cG9pbnRlcikKK3sKKyAgICBHUmVmUHRyPFdlYktpdFNldHRpbmdzPiBz ZXR0aW5ncyA9IGFkb3B0R1JlZih3ZWJraXRfc2V0dGluZ3NfbmV3KCkpOworICAgIENTdHJpbmcg ZGVmYXVsdFVzZXJBZ2VudCA9IHdlYmtpdF9zZXR0aW5nc19nZXRfdXNlcl9hZ2VudChzZXR0aW5n cy5nZXQoKSk7CisKKyAgICBnX2Fzc2VydChnX3N0cnN0cl9sZW4oZGVmYXVsdFVzZXJBZ2VudC5k YXRhKCksIC0xLCAiU2FmYXJpIikpOworICAgIGdfYXNzZXJ0KGdfc3Ryc3RyX2xlbihkZWZhdWx0 VXNlckFnZW50LmRhdGEoKSwgLTEsICJDaHJvbWl1bSIpKTsKKyAgICBnX2Fzc2VydChnX3N0cnN0 cl9sZW4oZGVmYXVsdFVzZXJBZ2VudC5kYXRhKCksIC0xLCAiQ2hyb21lIikpOworCisgICAgd2Vi a2l0X3NldHRpbmdzX3NldF91c2VyX2FnZW50KHNldHRpbmdzLmdldCgpLCAwKTsKKyAgICBnX2Fz c2VydF9jbXBzdHIoZGVmYXVsdFVzZXJBZ2VudC5kYXRhKCksID09LCB3ZWJraXRfc2V0dGluZ3Nf Z2V0X3VzZXJfYWdlbnQoc2V0dGluZ3MuZ2V0KCkpKTsKKworICAgIHdlYmtpdF9zZXR0aW5nc19z ZXRfdXNlcl9hZ2VudChzZXR0aW5ncy5nZXQoKSwgIiIpOworICAgIGdfYXNzZXJ0X2NtcHN0cihk ZWZhdWx0VXNlckFnZW50LmRhdGEoKSwgPT0sIHdlYmtpdF9zZXR0aW5nc19nZXRfdXNlcl9hZ2Vu dChzZXR0aW5ncy5nZXQoKSkpOworCisgICAgY29uc3QgY2hhciogZnVua3lVc2VyQWdlbnQgPSAi RnVua3khIjsKKyAgICB3ZWJraXRfc2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnQoc2V0dGluZ3MuZ2V0 KCksIGZ1bmt5VXNlckFnZW50KTsKKyAgICBnX2Fzc2VydF9jbXBzdHIoZnVua3lVc2VyQWdlbnQs ID09LCB3ZWJraXRfc2V0dGluZ3NfZ2V0X3VzZXJfYWdlbnQoc2V0dGluZ3MuZ2V0KCkpKTsKKwor ICAgIHdlYmtpdF9zZXR0aW5nc19zZXRfdXNlcl9hZ2VudF93aXRoX2FwcGxpY2F0aW9uX2RldGFp bHMoc2V0dGluZ3MuZ2V0KCksICJXZWJLaXRHVEsrIiwgMCk7CisgICAgQ1N0cmluZyB1c2VyQWdl bnRXaXRoTnVsbFZlcnNpb24gPSB3ZWJraXRfc2V0dGluZ3NfZ2V0X3VzZXJfYWdlbnQoc2V0dGlu Z3MuZ2V0KCkpOworICAgIGdfYXNzZXJ0X2NtcHN0cihnX3N0cnN0cl9sZW4odXNlckFnZW50V2l0 aE51bGxWZXJzaW9uLmRhdGEoKSwgLTEsIGRlZmF1bHRVc2VyQWdlbnQuZGF0YSgpKSwgPT0sIHVz ZXJBZ2VudFdpdGhOdWxsVmVyc2lvbi5kYXRhKCkpOworICAgIGdfYXNzZXJ0KGdfc3Ryc3RyX2xl bih1c2VyQWdlbnRXaXRoTnVsbFZlcnNpb24uZGF0YSgpLCAtMSwgIldlYktpdEdUSysiKSk7CisK KyAgICB3ZWJraXRfc2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnRfd2l0aF9hcHBsaWNhdGlvbl9kZXRh aWxzKHNldHRpbmdzLmdldCgpLCAiV2ViS2l0R1RLKyIsICIiKTsKKyAgICBnX2Fzc2VydF9jbXBz dHIod2Via2l0X3NldHRpbmdzX2dldF91c2VyX2FnZW50KHNldHRpbmdzLmdldCgpKSwgPT0sIHVz ZXJBZ2VudFdpdGhOdWxsVmVyc2lvbi5kYXRhKCkpOworCisgICAgd2Via2l0X3NldHRpbmdzX3Nl dF91c2VyX2FnZW50X3dpdGhfYXBwbGljYXRpb25fZGV0YWlscyhzZXR0aW5ncy5nZXQoKSwgIldl YkNhdEdUSysiLCAiMy40LjUiKTsKKyAgICBjb25zdCBjaGFyKiBuZXdVc2VyQWdlbnQgPSB3ZWJr aXRfc2V0dGluZ3NfZ2V0X3VzZXJfYWdlbnQoc2V0dGluZ3MuZ2V0KCkpOworICAgIGdfYXNzZXJ0 KGdfc3Ryc3RyX2xlbihuZXdVc2VyQWdlbnQsIC0xLCAiMy40LjUiKSk7CisgICAgZ19hc3NlcnQo Z19zdHJzdHJfbGVuKG5ld1VzZXJBZ2VudCwgLTEsICJXZWJDYXRHVEsrIikpOworfQorCiB2b2lk IGJlZm9yZUFsbCgpCiB7CiAgICAgVGVzdDo6YWRkKCJXZWJLaXRTZXR0aW5ncyIsICJ3ZWJraXQt c2V0dGluZ3MiLCB0ZXN0V2ViS2l0U2V0dGluZ3MpOwogICAgIFRlc3Q6OmFkZCgiV2ViS2l0U2V0 dGluZ3MiLCAibmV3LXdpdGgtc2V0dGluZ3MiLCB0ZXN0V2ViS2l0U2V0dGluZ3NOZXdXaXRoU2V0 dGluZ3MpOworICAgIFRlc3Q6OmFkZCgiV2ViS2l0U2V0dGluZ3MiLCAidXNlci1hZ2VudCIsIHRl c3RXZWJLaXRTZXR0aW5nc1VzZXJBZ2VudCk7CiB9CiAKIHZvaWQgYWZ0ZXJBbGwoKQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2d0ay9XZWJQYWdlUHJveHlHdGsuY3BwIGIv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2d0ay9XZWJQYWdlUHJveHlHdGsuY3BwCmluZGV4IGFj MjZjMGNiOGZkYmI4YzllNzI1ZjkzM2I4NDc4YTJhNGRjYzBmN2MuLmRkNDEzZWRkMTBmYTllNTc3 MWU5MWRmNzA4MzljZDY5MTkwMzc4YjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9ndGsvV2ViUGFnZVByb3h5R3RrLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvZ3RrL1dlYlBhZ2VQcm94eUd0ay5jcHAKQEAgLTMzLDYgKzMzLDcgQEAKICNpbmNsdWRlICJX ZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJQYWdlTWVzc2FnZXMuaCIK ICNpbmNsdWRlICJXZWJQcm9jZXNzUHJveHkuaCIKKyNpbmNsdWRlIDxXZWJDb3JlL1VzZXJBZ2Vu dEd0ay5oPgogI2luY2x1ZGUgPGd0ay9ndGt4Lmg+CiAKIG5hbWVzcGFjZSBXZWJLaXQgewpAQCAt NDQsOCArNDUsNyBAQCBHdGtXaWRnZXQqIFdlYlBhZ2VQcm94eTo6dmlld1dpZGdldCgpCiAKIFN0 cmluZyBXZWJQYWdlUHJveHk6OnN0YW5kYXJkVXNlckFnZW50KGNvbnN0IFN0cmluZyYgYXBwbGlj YXRpb25OYW1lRm9yVXNlckFnZW50KQogewotICAgIC8vIEZJWE1FOiBUaGlzIHNob3VsZCBub3Qg YmUgaGFyZCBjb2RlZC4KLSAgICByZXR1cm4gIk1vemlsbGEvNS4wIChYMTE7IExpbnV4IGk2ODYp IEFwcGxlV2ViS2l0LzUzNC43IChLSFRNTCwgbGlrZSBHZWNrbykgVmVyc2lvbi81LjAgU2FmYXJp LzUzNC43IjsKKyAgICByZXR1cm4gV2ViQ29yZTo6c3RhbmRhcmRVc2VyQWdlbnQoYXBwbGljYXRp b25OYW1lRm9yVXNlckFnZW50KTsKIH0KIAogdm9pZCBXZWJQYWdlUHJveHk6OmdldEVkaXRvckNv bW1hbmRzRm9yS2V5RXZlbnQoY29uc3QgQXRvbWljU3RyaW5nJiBldmVudFR5cGUsIFZlY3RvcjxX VEY6OlN0cmluZz4mIGNvbW1hbmRzTGlzdCkK 162840 2012-09-07 12:04:43 -0700 2012-09-10 00:01:29 -0700 Patch bug-95697-20120907120422.patch text/plain 16568 mrobinson U3VidmVyc2lvbiBSZXZpc2lvbjogMTI3ODg5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggNWVhN2ZhNjFhNGUxOGJi NjgzNmM4YjFjYWMxMDI3NjMwYzlkZTg5MC4uMjBlMTUwOTcyMGI0NmRmYTEzOTRmYzdiYjQzZWEw ZWYyOWUyNzkxYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDEyLTA5LTA3ICBNYXJ0 aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KKworICAgICAgICBbV2ViS2l0Ml0g W0dUS10gQWRkIEFQSSBmb3IgY29udHJvbGxpbmcgdGhlIHVzZXIgYWdlbnQKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTk1Njk3CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEFQSSBmb3IgY2hhbmdpbmcg dGhlIHVzZXIgYWdlbnQgaW4gV2ViS2l0Mi4gVGhpcyBhZGRzIHR3byBzdHlsZXMgb2YKKyAgICAg ICAgc2V0dGluZyB0aGUgdXNlciBhZ2VudDogY29tcGxldGUgb3ZlcnJpZGUgYW5kIGEgbWV0aG9k IHRoYXQganVzdCBpbnNlcnRzCisgICAgICAgIHRoZSBhcHBsaWNhdGlvbiBuYW1lIGFuZCB2ZXJz aW9uLCBidXQgcHJlc2VydmVzIHRoZSBjYXJlZnVsbHkgY3JhZnRlZCB1c2VyIGFnZW50CisgICAg ICAgIGluIHRoZSBsaWJyYXJ5LgorCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0 U2V0dGluZ3MuY3BwOgorICAgICAgICAoX1dlYktpdFNldHRpbmdzUHJpdmF0ZSk6IEFkZGVkIGEg bmV3IGZpZWxkIHRvIHN0b3JlIHRoZSB1c2VyIGFnZW50LgorICAgICAgICBUaGlzIGlzIHN0b3Jl ZCBpbiB0aGUgcHJpdmF0ZSBkYXRhIHN0cnVjdHVyZSwgYmVjYXVzZSB3ZSBjYW4gb25seQorICAg ICAgICBzZXQgdGhlIHVzZXIgYWdlbnQgd2hlbiBhdHRhY2hpbmcgdGhlIHNldHRpbmdzIHRvIHRo ZSBwYWdlLgorICAgICAgICAod2ViS2l0U2V0dGluZ3NTZXRQcm9wZXJ0eSk6IEFkZCBob29rcyBm b3IgdGhlIG5ldyB1c2VyIGFnZW50IHByb3BlcnR5LgorICAgICAgICAod2ViS2l0U2V0dGluZ3NH ZXRQcm9wZXJ0eSk6IERpdHRvLgorICAgICAgICAod2Via2l0X3NldHRpbmdzX2NsYXNzX2luaXQp OiBEaXR0by4KKyAgICAgICAgKHdlYmtpdFNldHRpbmdzQXR0YWNoU2V0dGluZ3NUb1BhZ2UpOiBE aXR0by4KKyAgICAgICAgKHdlYmtpdF9zZXR0aW5nc19nZXRfdXNlcl9hZ2VudCk6IEFkZGVkLgor ICAgICAgICAod2Via2l0X3NldHRpbmdzX3NldF91c2VyX2FnZW50KTogQWRkZWQuCisgICAgICAg ICh3ZWJraXRfc2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnRfd2l0aF9hcHBsaWNhdGlvbl9uYW1lKTog QWRkZWQuCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2V0dGluZ3MuaDogQWRk ZWQgbmV3IG1ldGhvZHMuCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQy Z3RrLXNlY3Rpb25zLnR4dDogQWRkZWQgbmV3IG1ldGhvZHMgdG8KKyAgICAgICAgdGhlIGRvY3Vt ZW50YXRpb24uCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdFdlYktpdFNl dHRpbmdzLmNwcDogVGVzdCB0aGUgbmV3IHVzZXIgYWdlbnQKKyAgICAgICAgcHJvcGVydHkuCisg ICAgICAgICh0ZXN0V2ViS2l0U2V0dGluZ3NVc2VyQWdlbnQpOiBEaXR0by4KKyAgICAgICAgKGJl Zm9yZUFsbCk6IERpdHRvLgorICAgICAgICAqIFVJUHJvY2Vzcy9ndGsvV2ViUGFnZVByb3h5R3Rr LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpzdGFuZGFyZFVzZXJBZ2VudCk6 IE5vdyB1c2UgdGhlIHNoYXJlZCBXZWJDb3JlCisgICAgICAgIGNvZGUgd2hlbiBzZXR0aW5nIHRo ZSB1c2VyIGFnZW50LgorCiAyMDEyLTA5LTA3ICBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gIDxhbGxh bi5qZW5zZW5Abm9raWEuY29tPgogCiAgICAgICAgIFNpbXBsaWZ5IGhpdFRlc3RSZXN1bHRBdFBv aW50IGFuZCBub2Rlc0Zyb21SZWN0IEFQSXMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFNldHRpbmdzLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFNldHRpbmdzLmNwcAppbmRleCA1ZTBiZTdkMzIyMDVkZmI3MGMy YjllZTYxMjA3YjAyZjlkN2U3MmNmLi5lZTFmODE0NzBlYjNjNjYzYzcxOGVmNGJkNzk2OWExN2Rm YTRhOTFhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRTZXR0aW5ncy5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2Vi S2l0U2V0dGluZ3MuY3BwCkBAIC0zNCw2ICszNCw3IEBACiAjaW5jbHVkZSAiV2ViS2l0UHJpdmF0 ZS5oIgogI2luY2x1ZGUgIldlYktpdFNldHRpbmdzUHJpdmF0ZS5oIgogI2luY2x1ZGUgIldlYlBh Z2VQcm94eS5oIgorI2luY2x1ZGUgPFdlYkNvcmUvVXNlckFnZW50R3RrLmg+CiAjaW5jbHVkZSA8 Z2xpYi9naTE4bi1saWIuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CiAKQEAgLTQ3 LDYgKzQ4LDcgQEAgc3RydWN0IF9XZWJLaXRTZXR0aW5nc1ByaXZhdGUgewogICAgIENTdHJpbmcg ZmFudGFzeUZvbnRGYW1pbHk7CiAgICAgQ1N0cmluZyBwaWN0b2dyYXBoRm9udEZhbWlseTsKICAg ICBDU3RyaW5nIGRlZmF1bHRDaGFyc2V0OworICAgIENTdHJpbmcgdXNlckFnZW50OwogICAgIGJv b2wgYWxsb3dNb2RhbERpYWxvZ3M7CiAgICAgYm9vbCB6b29tVGV4dE9ubHk7CiB9OwpAQCAtMTE0 LDcgKzExNiw4IEBAIGVudW0gewogICAgIFBST1BfTUVESUFfUExBWUJBQ0tfQUxMT1dTX0lOTElO RSwKICAgICBQUk9QX0RSQVdfQ09NUE9TSVRJTkdfSU5ESUNBVE9SUywKICAgICBQUk9QX0VOQUJM RV9TSVRFX1NQRUNJRklDX1FVSVJLUywKLSAgICBQUk9QX0VOQUJMRV9QQUdFX0NBQ0hFCisgICAg UFJPUF9FTkFCTEVfUEFHRV9DQUNIRSwKKyAgICBQUk9QX1VTRVJfQUdFTlQKIH07CiAKIHN0YXRp YyB2b2lkIHdlYktpdFNldHRpbmdzU2V0UHJvcGVydHkoR09iamVjdCogb2JqZWN0LCBndWludCBw cm9wSWQsIGNvbnN0IEdWYWx1ZSogdmFsdWUsIEdQYXJhbVNwZWMqIHBhcmFtU3BlYykKQEAgLTI0 NSw2ICsyNDgsOSBAQCBzdGF0aWMgdm9pZCB3ZWJLaXRTZXR0aW5nc1NldFByb3BlcnR5KEdPYmpl Y3QqIG9iamVjdCwgZ3VpbnQgcHJvcElkLCBjb25zdCBHVmFsdQogICAgIGNhc2UgUFJPUF9FTkFC TEVfUEFHRV9DQUNIRToKICAgICAgICAgd2Via2l0X3NldHRpbmdzX3NldF9lbmFibGVfcGFnZV9j YWNoZShzZXR0aW5ncywgZ192YWx1ZV9nZXRfYm9vbGVhbih2YWx1ZSkpOwogICAgICAgICBicmVh azsKKyAgICBjYXNlIFBST1BfVVNFUl9BR0VOVDoKKyAgICAgICAgd2Via2l0X3NldHRpbmdzX3Nl dF91c2VyX2FnZW50KHNldHRpbmdzLCBnX3ZhbHVlX2dldF9zdHJpbmcodmFsdWUpKTsKKyAgICAg ICAgYnJlYWs7CiAgICAgZGVmYXVsdDoKICAgICAgICAgR19PQkpFQ1RfV0FSTl9JTlZBTElEX1BS T1BFUlRZX0lEKG9iamVjdCwgcHJvcElkLCBwYXJhbVNwZWMpOwogICAgICAgICBicmVhazsKQEAg LTM3OSw2ICszODUsOSBAQCBzdGF0aWMgdm9pZCB3ZWJLaXRTZXR0aW5nc0dldFByb3BlcnR5KEdP YmplY3QqIG9iamVjdCwgZ3VpbnQgcHJvcElkLCBHVmFsdWUqIHZhbAogICAgIGNhc2UgUFJPUF9F TkFCTEVfUEFHRV9DQUNIRToKICAgICAgICAgZ192YWx1ZV9zZXRfYm9vbGVhbih2YWx1ZSwgd2Vi a2l0X3NldHRpbmdzX2dldF9lbmFibGVfcGFnZV9jYWNoZShzZXR0aW5ncykpOwogICAgICAgICBi cmVhazsKKyAgICBjYXNlIFBST1BfVVNFUl9BR0VOVDoKKyAgICAgICAgZ192YWx1ZV9zZXRfc3Ry aW5nKHZhbHVlLCB3ZWJraXRfc2V0dGluZ3NfZ2V0X3VzZXJfYWdlbnQoc2V0dGluZ3MpKTsKKyAg ICAgICAgYnJlYWs7CiAgICAgZGVmYXVsdDoKICAgICAgICAgR19PQkpFQ1RfV0FSTl9JTlZBTElE X1BST1BFUlRZX0lEKG9iamVjdCwgcHJvcElkLCBwYXJhbVNwZWMpOwogICAgICAgICBicmVhazsK QEAgLTEwMTAsNiArMTAxOSwyNiBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfc2V0dGluZ3NfY2xhc3Nf aW5pdChXZWJLaXRTZXR0aW5nc0NsYXNzKiBrbGFzcykKICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFRSVUUsCiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWFkV3JpdGVDb25zdHJ1 Y3RQYXJhbUZsYWdzKSk7CiAKKyAgICAvKioKKyAgICAgKiBXZWJLaXRTZXR0aW5nczp1c2VyLWFn ZW50OgorICAgICAqCisgICAgICogVGhlIHVzZXItYWdlbnQgc3RyaW5nIHVzZWQgYnkgV2ViS2l0 IGluIHRoZSBoZWFkZXJzLiBVbnVzdWFsIHVzZXItYWdlbnQgc3RyaW5ncworICAgICAqIG1heSBj YXVzZSB3ZWIgY29udGVudCB0byByZW5kZXIgaW5jb3JyZWN0bHkgb3IgZmFpbCB0byBydW4sIGFz IG1hbnkgd2ViIHBhZ2VzIGFyZQorICAgICAqIHdyaXR0ZW4gdG8gcGFyc2UgdGhlIHVzZXItYWdl bnQgc3RyaW5ncyBvZiBvbmx5IHRoZSBtb3N0IHBvcHVsYXIgYnJvd3NlcnMuIFRoZXJlZm9yZSwK KyAgICAgKiBpdCdzIHR5cGljYWxseSBiZXR0ZXIgdG8gbm90IGNvbXBsZXRlbHkgb3ZlcnJpZGUg dGhlIHN0YW5kYXJkIHVzZXItYWdlbnQsIGJ1dCB0byB1c2UKKyAgICAgKiB3ZWJraXRfc2V0dGlu Z3Nfc2V0X3VzZXJfYWdlbnRfd2l0aF9hcHBsaWNhdGlvbl9kZXRhaWxzKCkgaW5zdGVhZC4KKyAg ICAgKgorICAgICAqIElmIHRoaXMgcHJvcGVydHkgaXMgc2V0IHRvIHRoZSBlbXB0eSBzdHJpbmcg b3IgJU5VTEwsIGl0IHdpbGwgcmV2ZXJ0IHRvIHRoZSBzdGFuZGFyZAorICAgICAqIHVzZXItYWdl bnQuCisgICAgICovCisgICAgZ19vYmplY3RfY2xhc3NfaW5zdGFsbF9wcm9wZXJ0eShnT2JqZWN0 Q2xhc3MsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQUk9QX1VTRVJfQUdF TlQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnX3BhcmFtX3NwZWNfc3Ry aW5nKCJ1c2VyLWFnZW50IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgXygiVXNlciBhZ2VudCBzdHJpbmciKSwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXygiVGhlIHVzZXIgYWdl bnQgc3RyaW5nIiksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIDAsIC8vIEEgbnVsbCBzdHJpbmcgZm9yY2VzIHRoZSBzdGFuZGFyZCB1c2Vy IGFnZW50LgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICByZWFkV3JpdGVDb25zdHJ1Y3RQYXJhbUZsYWdzKSk7CisKICAgICBnX3R5cGVfY2xh c3NfYWRkX3ByaXZhdGUoa2xhc3MsIHNpemVvZihXZWJLaXRTZXR0aW5nc1ByaXZhdGUpKTsKIH0K IApAQCAtMTA0OCw4ICsxMDc3LDEzIEBAIHN0YXRpYyB2b2lkIHdlYmtpdF9zZXR0aW5nc19pbml0 KFdlYktpdFNldHRpbmdzKiBzZXR0aW5ncykKIAogdm9pZCB3ZWJraXRTZXR0aW5nc0F0dGFjaFNl dHRpbmdzVG9QYWdlKFdlYktpdFNldHRpbmdzKiBzZXR0aW5ncywgV0tQYWdlUmVmIHdrUGFnZSkK IHsKLSAgICBXS1BhZ2VHcm91cFNldFByZWZlcmVuY2VzKFdLUGFnZUdldFBhZ2VHcm91cCh3a1Bh Z2UpLCBzZXR0aW5ncy0+cHJpdi0+cHJlZmVyZW5jZXMuZ2V0KCkpOwotICAgIFdlYktpdDo6dG9J bXBsKHdrUGFnZSktPnNldENhblJ1bk1vZGFsKHNldHRpbmdzLT5wcml2LT5hbGxvd01vZGFsRGlh bG9ncyk7CisgICAgV2ViS2l0U2V0dGluZ3NQcml2YXRlKiBwcml2ID0gc2V0dGluZ3MtPnByaXY7 CisgICAgV0tQYWdlR3JvdXBTZXRQcmVmZXJlbmNlcyhXS1BhZ2VHZXRQYWdlR3JvdXAod2tQYWdl KSwgcHJpdi0+cHJlZmVyZW5jZXMuZ2V0KCkpOworICAgIFdlYktpdDo6dG9JbXBsKHdrUGFnZSkt PnNldENhblJ1bk1vZGFsKHByaXYtPmFsbG93TW9kYWxEaWFsb2dzKTsKKworICAgIEFTU0VSVCgh cHJpdi0+dXNlckFnZW50LmlzTnVsbCgpKTsKKyAgICBXS1JldGFpblB0cjxXS1N0cmluZ1JlZj4g dXNlckFnZW50ID0gYWRvcHRXSyhXS1N0cmluZ0NyZWF0ZVdpdGhVVEY4Q1N0cmluZyhwcml2LT51 c2VyQWdlbnQuZGF0YSgpKSk7CisgICAgV0tQYWdlU2V0Q3VzdG9tVXNlckFnZW50KHdrUGFnZSwg dXNlckFnZW50LmdldCgpKTsKIH0KIAogLyoqCkBAIC0yNTU1LDMgKzI1ODksNTggQEAgdm9pZCB3 ZWJraXRfc2V0dGluZ3Nfc2V0X2VuYWJsZV9wYWdlX2NhY2hlKFdlYktpdFNldHRpbmdzKiBzZXR0 aW5ncywgZ2Jvb2xlYW4gZW4KICAgICBXS1ByZWZlcmVuY2VzU2V0UGFnZUNhY2hlRW5hYmxlZChw cml2LT5wcmVmZXJlbmNlcy5nZXQoKSwgZW5hYmxlZCk7CiAgICAgZ19vYmplY3Rfbm90aWZ5KEdf T0JKRUNUKHNldHRpbmdzKSwgImVuYWJsZS1wYWdlLWNhY2hlIik7CiB9CisKKy8qKgorICogd2Vi a2l0X3NldHRpbmdzX2dldF91c2VyX2FnZW50OgorICogQHNldHRpbmdzOiBhICNXZWJLaXRTZXR0 aW5ncworICoKKyAqIEdldCB0aGUgI1dlYktpdFNldHRpbmdzOnVzZXItYWdlbnQgcHJvcGVydHku CisgKgorICogUmV0dXJuczogVGhlIGN1cnJlbnQgdmFsdWUgb2YgdGhlIHVzZXItYWdlbnQgcHJv cGVydHkuCisgKi8KK2NvbnN0IGNoYXIqIHdlYmtpdF9zZXR0aW5nc19nZXRfdXNlcl9hZ2VudChX ZWJLaXRTZXR0aW5ncyogc2V0dGluZ3MpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VC S0lUX0lTX1NFVFRJTkdTKHNldHRpbmdzKSwgMCk7CisKKyAgICBXZWJLaXRTZXR0aW5nc1ByaXZh dGUqIHByaXYgPSBzZXR0aW5ncy0+cHJpdjsKKyAgICBBU1NFUlQoIXByaXYtPnVzZXJBZ2VudC5p c051bGwoKSk7CisgICAgcmV0dXJuIHByaXYtPnVzZXJBZ2VudC5kYXRhKCk7Cit9CisKKy8qKgor ICogd2Via2l0X3NldHRpbmdzX3NldF91c2VyX2FnZW50OgorICogQHNldHRpbmdzOiBhICNXZWJL aXRTZXR0aW5ncworICogQHVzZXJfYWdlbnQ6IChhbGxvdy1ub25lKSBUaGUgbmV3IGN1c3RvbSB1 c2VyIGFnZW50IHN0cmluZyBvciAlTlVMTCB0byB1c2UgdGhlIGRlZmF1bHQgdXNlciBhZ2VudAor ICoKKyAqIFNldCB0aGUgI1dlYktpdFNldHRpbmdzOnVzZXItYWdlbnQgcHJvcGVydHkuCisgKi8K K3ZvaWQgd2Via2l0X3NldHRpbmdzX3NldF91c2VyX2FnZW50KFdlYktpdFNldHRpbmdzKiBzZXR0 aW5ncywgY29uc3QgY2hhciogdXNlckFnZW50KQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VC S0lUX0lTX1NFVFRJTkdTKHNldHRpbmdzKSk7CisKKyAgICBXZWJLaXRTZXR0aW5nc1ByaXZhdGUq IHByaXYgPSBzZXR0aW5ncy0+cHJpdjsKKyAgICBDU3RyaW5nIG5ld1VzZXJBZ2VudCA9ICghdXNl ckFnZW50IHx8ICFzdHJsZW4odXNlckFnZW50KSkgPyBXZWJDb3JlOjpzdGFuZGFyZFVzZXJBZ2Vu dCgiIikudXRmOCgpIDogdXNlckFnZW50OworICAgIGlmIChuZXdVc2VyQWdlbnQgPT0gcHJpdi0+ dXNlckFnZW50KQorICAgICAgICByZXR1cm47CisKKyAgICBwcml2LT51c2VyQWdlbnQgPSBuZXdV c2VyQWdlbnQ7CisgICAgZ19vYmplY3Rfbm90aWZ5KEdfT0JKRUNUKHNldHRpbmdzKSwgInVzZXIt YWdlbnQiKTsKK30KKworLyoqCisgKiB3ZWJraXRfc2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnRfd2l0 aF9hcHBsaWNhdGlvbl9kZXRhaWxzOgorICogQHNldHRpbmdzOiBhICNXZWJLaXRTZXR0aW5ncwor ICogQGFwcGxpY2F0aW9uX25hbWU6IChhbGxvdy1ub25lKSBUaGUgYXBwbGljYXRpb24gbmFtZSB1 c2VkIGZvciB0aGUgdXNlciBhZ2VudCBvciAlTlVMTCB0byB1c2UgdGhlIGRlZmF1bHQgdXNlciBh Z2VudC4KKyAqIEBhcHBsaWNhdGlvbl92ZXJzaW9uOiAoYWxsb3ctbm9uZSkgVGhlIGFwcGxpY2F0 aW9uIHZlcnNpb24gZm9yIHRoZSB1c2VyIGFnZW50IG9yICVOVUxMIHRvIHVzZXIgdGhlIGRlZmF1 bHQgdmVyc2lvbi4KKyAqCisgKiBTZXQgdGhlICNXZWJLaXRTZXR0aW5nczp1c2VyLWFnZW50IHBy b3BlcnR5IGJ5IGFwcGVuZGluZyB0aGUgYXBwbGljYXRpb24gZGV0YWlscyB0byB0aGUgZGVmYXVs dCB1c2VyCisgKiBhZ2VudC4gSWYgbm8gYXBwbGljYXRpb24gbmFtZSBvciB2ZXJzaW9uIGlzIGdp dmVuLCB0aGUgZGVmYXVsdCB1c2VyIGFnZW50IHVzZWQgd2lsbCBiZSB1c2VkLiBJZiBvbmx5Cisg KiB0aGUgdmVyc2lvbiBpcyBnaXZlbiwgdGhlIGRlZmF1bHQgZW5naW5lIHZlcnNpb24gaXMgdXNl ZCB3aXRoIHRoZSBnaXZlbiBhcHBsaWNhdGlvbiBuYW1lLgorICovCit2b2lkIHdlYmtpdF9zZXR0 aW5nc19zZXRfdXNlcl9hZ2VudF93aXRoX2FwcGxpY2F0aW9uX2RldGFpbHMoV2ViS2l0U2V0dGlu Z3MqIHNldHRpbmdzLCBjb25zdCBjaGFyKiBhcHBsaWNhdGlvbk5hbWUsIGNvbnN0IGNoYXIqIGFw cGxpY2F0aW9uVmVyc2lvbikKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19TRVRU SU5HUyhzZXR0aW5ncykpOworCisgICAgQ1N0cmluZyBuZXdVc2VyQWdlbnQgPSBXZWJDb3JlOjpz dGFuZGFyZFVzZXJBZ2VudChTdHJpbmc6OmZyb21VVEY4KGFwcGxpY2F0aW9uTmFtZSksIFN0cmlu Zzo6ZnJvbVVURjgoYXBwbGljYXRpb25WZXJzaW9uKSkudXRmOCgpOworICAgIHdlYmtpdF9zZXR0 aW5nc19zZXRfdXNlcl9hZ2VudChzZXR0aW5ncywgbmV3VXNlckFnZW50LmRhdGEoKSk7Cit9CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRTZXR0aW5n cy5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2V0dGluZ3MuaApp bmRleCAwYzcxOWNkNDc5YTA0MDMyNDFkN2JlY2Q5ZmFhYjE2MzNhMDU1ODEzLi5iMzVhMjNmMDYx ODkzMTkwNWEzY2M2YmVkZGY2ZDFmZGMzNWFkNjhhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRTZXR0aW5ncy5oCisrKyBiL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFNldHRpbmdzLmgKQEAgLTM2Miw2ICszNjIsMTcgQEAg V0VCS0lUX0FQSSB2b2lkCiB3ZWJraXRfc2V0dGluZ3Nfc2V0X2VuYWJsZV9wYWdlX2NhY2hlICAg ICAgICAgICAgICAgICAgICAgICAgICAoV2ViS2l0U2V0dGluZ3MgKnNldHRpbmdzLAogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGdib29sZWFuICAgICAgICBlbmFibGVkKTsKIAorV0VCS0lUX0FQSSBjb25zdCBnY2hhciAqCit3 ZWJraXRfc2V0dGluZ3NfZ2V0X3VzZXJfYWdlbnQgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAoV2ViS2l0U2V0dGluZ3MgKnNldHRpbmdzKTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJr aXRfc2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAoV2ViS2l0U2V0dGluZ3MgKnNldHRpbmdzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGdjaGFyICAgICp1c2Vy X2FnZW50KTsKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X3NldHRpbmdzX3NldF91c2VyX2FnZW50 X3dpdGhfYXBwbGljYXRpb25fZGV0YWlscyAgICAgICAgKFdlYktpdFNldHRpbmdzICpzZXR0aW5n cywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBjb25zdCBnY2hhciAgICAqYXBwbGljYXRpb25fbmFtZSwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25z dCBnY2hhciAgICAqYXBwbGljYXRpb25fdmVyc2lvbik7CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRp ZiAvKiBXZWJLaXRTZXR0aW5nc19oICovCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9BUEkvZ3RrL1dlYktpdFdlYlZpZXcuY3BwCmluZGV4IDZmZWZiNjUyYjcxNmI4MDYzODlmN2Iy Mzc1NmQ3OGFlOWRjNTQ0ZDQuLjFlYTc4ZGU5N2UyZWE5MDJlMWY1OGEyYjgxMmFkYzAyZTEyMzgx NDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdl YlZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdl YlZpZXcuY3BwCkBAIC0yNDgsMTIgKzI0OCwxOSBAQCBzdGF0aWMgdm9pZCB6b29tVGV4dE9ubHlD aGFuZ2VkKFdlYktpdFNldHRpbmdzKiBzZXR0aW5ncywgR1BhcmFtU3BlYyosIFdlYktpdFdlYgog ICAgIFdLUGFnZVNldFBhZ2VBbmRUZXh0Wm9vbUZhY3RvcnMod2tQYWdlLCBwYWdlWm9vbUxldmVs LCB0ZXh0Wm9vbUxldmVsKTsKIH0KIAorc3RhdGljIHZvaWQgdXNlckFnZW50Q2hhbmdlZChXZWJL aXRTZXR0aW5ncyogc2V0dGluZ3MsIEdQYXJhbVNwZWMqLCBXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3 KQoreworICAgIFdLUmV0YWluUHRyPFdLU3RyaW5nUmVmPiB1c2VyQWdlbnQgPSBhZG9wdFdLKFdL U3RyaW5nQ3JlYXRlV2l0aFVURjhDU3RyaW5nKHdlYmtpdF9zZXR0aW5nc19nZXRfdXNlcl9hZ2Vu dChzZXR0aW5ncykpKTsKKyAgICBXS1BhZ2VTZXRDdXN0b21Vc2VyQWdlbnQodG9BUEkod2Via2l0 V2ViVmlld0Jhc2VHZXRQYWdlKFdFQktJVF9XRUJfVklFV19CQVNFKHdlYlZpZXcpKSksIHVzZXJB Z2VudC5nZXQoKSk7Cit9CisKIHN0YXRpYyB2b2lkIHdlYmtpdFdlYlZpZXdTZXRTZXR0aW5ncyhX ZWJLaXRXZWJWaWV3KiB3ZWJWaWV3LCBXZWJLaXRTZXR0aW5ncyogc2V0dGluZ3MsIFdLUGFnZVJl ZiB3a1BhZ2UpCiB7CiAgICAgd2ViVmlldy0+cHJpdi0+c2V0dGluZ3MgPSBzZXR0aW5nczsKICAg ICB3ZWJraXRTZXR0aW5nc0F0dGFjaFNldHRpbmdzVG9QYWdlKHdlYlZpZXctPnByaXYtPnNldHRp bmdzLmdldCgpLCB3a1BhZ2UpOwogICAgIGdfc2lnbmFsX2Nvbm5lY3Qoc2V0dGluZ3MsICJub3Rp Znk6OmFsbG93LW1vZGFsLWRpYWxvZ3MiLCBHX0NBTExCQUNLKGFsbG93TW9kYWxEaWFsb2dzQ2hh bmdlZCksIHdlYlZpZXcpOwogICAgIGdfc2lnbmFsX2Nvbm5lY3Qoc2V0dGluZ3MsICJub3RpZnk6 Onpvb20tdGV4dC1vbmx5IiwgR19DQUxMQkFDSyh6b29tVGV4dE9ubHlDaGFuZ2VkKSwgd2ViVmll dyk7CisgICAgZ19zaWduYWxfY29ubmVjdChzZXR0aW5ncywgIm5vdGlmeTo6dXNlci1hZ2VudCIs IEdfQ0FMTEJBQ0sodXNlckFnZW50Q2hhbmdlZCksIHdlYlZpZXcpOwogfQogCiBzdGF0aWMgdm9p ZCB3ZWJraXRXZWJWaWV3RGlzY29ubmVjdFNldHRpbmdzU2lnbmFsSGFuZGxlcnMoV2ViS2l0V2Vi Vmlldyogd2ViVmlldykKQEAgLTI2MSw3ICsyNjgsNyBAQCBzdGF0aWMgdm9pZCB3ZWJraXRXZWJW aWV3RGlzY29ubmVjdFNldHRpbmdzU2lnbmFsSGFuZGxlcnMoV2ViS2l0V2ViVmlldyogd2ViVmll dwogICAgIFdlYktpdFNldHRpbmdzKiBzZXR0aW5ncyA9IHdlYlZpZXctPnByaXYtPnNldHRpbmdz LmdldCgpOwogICAgIGdfc2lnbmFsX2hhbmRsZXJzX2Rpc2Nvbm5lY3RfYnlfZnVuYyhzZXR0aW5n cywgcmVpbnRlcnByZXRfY2FzdDxncG9pbnRlcj4oYWxsb3dNb2RhbERpYWxvZ3NDaGFuZ2VkKSwg d2ViVmlldyk7CiAgICAgZ19zaWduYWxfaGFuZGxlcnNfZGlzY29ubmVjdF9ieV9mdW5jKHNldHRp bmdzLCByZWludGVycHJldF9jYXN0PGdwb2ludGVyPih6b29tVGV4dE9ubHlDaGFuZ2VkKSwgd2Vi Vmlldyk7Ci0KKyAgICBnX3NpZ25hbF9oYW5kbGVyc19kaXNjb25uZWN0X2J5X2Z1bmMoc2V0dGlu Z3MsIHJlaW50ZXJwcmV0X2Nhc3Q8Z3BvaW50ZXI+KHVzZXJBZ2VudENoYW5nZWQpLCB3ZWJWaWV3 KTsKIH0KIAogc3RhdGljIHZvaWQgd2Via2l0V2ViVmlld0Rpc2Nvbm5lY3RNYWluUmVzb3VyY2VS ZXNwb25zZUNoYW5nZWRTaWduYWxIYW5kbGVyKFdlYktpdFdlYlZpZXcqIHdlYlZpZXcpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGst c2VjdGlvbnMudHh0IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJr aXQyZ3RrLXNlY3Rpb25zLnR4dAppbmRleCA1OTY0OThjODM0MGM5MzE5YmI1NWM5N2IzMTFlMjA0 ODMwMjQ1ZTQwLi5mMzBlODRlODMzOTZmOTEwYjYzOWI3OWU1OWJkOTA1YjNlZjc5ZDBmIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGst c2VjdGlvbnMudHh0CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mv d2Via2l0Mmd0ay1zZWN0aW9ucy50eHQKQEAgLTI4Myw2ICsyODMsOSBAQCB3ZWJraXRfc2V0dGlu Z3NfZ2V0X2VuYWJsZV9zaXRlX3NwZWNpZmljX3F1aXJrcwogd2Via2l0X3NldHRpbmdzX3NldF9l bmFibGVfc2l0ZV9zcGVjaWZpY19xdWlya3MKIHdlYmtpdF9zZXR0aW5nc19nZXRfZW5hYmxlX3Bh Z2VfY2FjaGUKIHdlYmtpdF9zZXR0aW5nc19zZXRfZW5hYmxlX3BhZ2VfY2FjaGUKK3dlYmtpdF9z ZXR0aW5nc19nZXRfdXNlcl9hZ2VudAord2Via2l0X3NldHRpbmdzX3NldF91c2VyX2FnZW50Cit3 ZWJraXRfc2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnRfd2l0aF9hcHBsaWNhdGlvbl9kZXRhaWxzCiAK IDxTVUJTRUNUSU9OIFN0YW5kYXJkPgogV2ViS2l0U2V0dGluZ3NDbGFzcwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdFdlYktpdFNldHRpbmdz LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RXZWJLaXRT ZXR0aW5ncy5jcHAKaW5kZXggNWU2ZTkxYjA5Y2ZlYmM4MGViOGE0OTMyNGYxOGU5Y2M0OTZlOGNk Zi4uMDNmYTM4Y2MwNmY3MjRiNzdlODFmNmJhY2Y3ZTk0YTBiODY2YWU3MiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdFdlYktpdFNldHRpbmdz LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9UZXN0V2Vi S2l0U2V0dGluZ3MuY3BwCkBAIC0yNTQsMTAgKzI1NCw0NCBAQCB2b2lkIHRlc3RXZWJLaXRTZXR0 aW5nc05ld1dpdGhTZXR0aW5ncyhUZXN0KiB0ZXN0LCBnY29uc3Rwb2ludGVyKQogICAgIGdfYXNz ZXJ0KHdlYmtpdF9zZXR0aW5nc19nZXRfbG9hZF9pY29uc19pZ25vcmluZ19pbWFnZV9sb2FkX3Nl dHRpbmcoc2V0dGluZ3MuZ2V0KCkpKTsKIH0KIAorc3RhdGljIHZvaWQgdGVzdFdlYktpdFNldHRp bmdzVXNlckFnZW50KFRlc3QqLCBnY29uc3Rwb2ludGVyKQoreworICAgIEdSZWZQdHI8V2ViS2l0 U2V0dGluZ3M+IHNldHRpbmdzID0gYWRvcHRHUmVmKHdlYmtpdF9zZXR0aW5nc19uZXcoKSk7Cisg ICAgQ1N0cmluZyBkZWZhdWx0VXNlckFnZW50ID0gd2Via2l0X3NldHRpbmdzX2dldF91c2VyX2Fn ZW50KHNldHRpbmdzLmdldCgpKTsKKworICAgIGdfYXNzZXJ0KGdfc3Ryc3RyX2xlbihkZWZhdWx0 VXNlckFnZW50LmRhdGEoKSwgLTEsICJTYWZhcmkiKSk7CisgICAgZ19hc3NlcnQoZ19zdHJzdHJf bGVuKGRlZmF1bHRVc2VyQWdlbnQuZGF0YSgpLCAtMSwgIkNocm9taXVtIikpOworICAgIGdfYXNz ZXJ0KGdfc3Ryc3RyX2xlbihkZWZhdWx0VXNlckFnZW50LmRhdGEoKSwgLTEsICJDaHJvbWUiKSk7 CisKKyAgICB3ZWJraXRfc2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnQoc2V0dGluZ3MuZ2V0KCksIDAp OworICAgIGdfYXNzZXJ0X2NtcHN0cihkZWZhdWx0VXNlckFnZW50LmRhdGEoKSwgPT0sIHdlYmtp dF9zZXR0aW5nc19nZXRfdXNlcl9hZ2VudChzZXR0aW5ncy5nZXQoKSkpOworCisgICAgd2Via2l0 X3NldHRpbmdzX3NldF91c2VyX2FnZW50KHNldHRpbmdzLmdldCgpLCAiIik7CisgICAgZ19hc3Nl cnRfY21wc3RyKGRlZmF1bHRVc2VyQWdlbnQuZGF0YSgpLCA9PSwgd2Via2l0X3NldHRpbmdzX2dl dF91c2VyX2FnZW50KHNldHRpbmdzLmdldCgpKSk7CisKKyAgICBjb25zdCBjaGFyKiBmdW5reVVz ZXJBZ2VudCA9ICJGdW5reSEiOworICAgIHdlYmtpdF9zZXR0aW5nc19zZXRfdXNlcl9hZ2VudChz ZXR0aW5ncy5nZXQoKSwgZnVua3lVc2VyQWdlbnQpOworICAgIGdfYXNzZXJ0X2NtcHN0cihmdW5r eVVzZXJBZ2VudCwgPT0sIHdlYmtpdF9zZXR0aW5nc19nZXRfdXNlcl9hZ2VudChzZXR0aW5ncy5n ZXQoKSkpOworCisgICAgd2Via2l0X3NldHRpbmdzX3NldF91c2VyX2FnZW50X3dpdGhfYXBwbGlj YXRpb25fZGV0YWlscyhzZXR0aW5ncy5nZXQoKSwgIldlYktpdEdUSysiLCAwKTsKKyAgICBDU3Ry aW5nIHVzZXJBZ2VudFdpdGhOdWxsVmVyc2lvbiA9IHdlYmtpdF9zZXR0aW5nc19nZXRfdXNlcl9h Z2VudChzZXR0aW5ncy5nZXQoKSk7CisgICAgZ19hc3NlcnRfY21wc3RyKGdfc3Ryc3RyX2xlbih1 c2VyQWdlbnRXaXRoTnVsbFZlcnNpb24uZGF0YSgpLCAtMSwgZGVmYXVsdFVzZXJBZ2VudC5kYXRh KCkpLCA9PSwgdXNlckFnZW50V2l0aE51bGxWZXJzaW9uLmRhdGEoKSk7CisgICAgZ19hc3NlcnQo Z19zdHJzdHJfbGVuKHVzZXJBZ2VudFdpdGhOdWxsVmVyc2lvbi5kYXRhKCksIC0xLCAiV2ViS2l0 R1RLKyIpKTsKKworICAgIHdlYmtpdF9zZXR0aW5nc19zZXRfdXNlcl9hZ2VudF93aXRoX2FwcGxp Y2F0aW9uX2RldGFpbHMoc2V0dGluZ3MuZ2V0KCksICJXZWJLaXRHVEsrIiwgIiIpOworICAgIGdf YXNzZXJ0X2NtcHN0cih3ZWJraXRfc2V0dGluZ3NfZ2V0X3VzZXJfYWdlbnQoc2V0dGluZ3MuZ2V0 KCkpLCA9PSwgdXNlckFnZW50V2l0aE51bGxWZXJzaW9uLmRhdGEoKSk7CisKKyAgICB3ZWJraXRf c2V0dGluZ3Nfc2V0X3VzZXJfYWdlbnRfd2l0aF9hcHBsaWNhdGlvbl9kZXRhaWxzKHNldHRpbmdz LmdldCgpLCAiV2ViQ2F0R1RLKyIsICIzLjQuNSIpOworICAgIGNvbnN0IGNoYXIqIG5ld1VzZXJB Z2VudCA9IHdlYmtpdF9zZXR0aW5nc19nZXRfdXNlcl9hZ2VudChzZXR0aW5ncy5nZXQoKSk7Cisg ICAgZ19hc3NlcnQoZ19zdHJzdHJfbGVuKG5ld1VzZXJBZ2VudCwgLTEsICIzLjQuNSIpKTsKKyAg ICBnX2Fzc2VydChnX3N0cnN0cl9sZW4obmV3VXNlckFnZW50LCAtMSwgIldlYkNhdEdUSysiKSk7 Cit9CisKIHZvaWQgYmVmb3JlQWxsKCkKIHsKICAgICBUZXN0OjphZGQoIldlYktpdFNldHRpbmdz IiwgIndlYmtpdC1zZXR0aW5ncyIsIHRlc3RXZWJLaXRTZXR0aW5ncyk7CiAgICAgVGVzdDo6YWRk KCJXZWJLaXRTZXR0aW5ncyIsICJuZXctd2l0aC1zZXR0aW5ncyIsIHRlc3RXZWJLaXRTZXR0aW5n c05ld1dpdGhTZXR0aW5ncyk7CisgICAgVGVzdDo6YWRkKCJXZWJLaXRTZXR0aW5ncyIsICJ1c2Vy LWFnZW50IiwgdGVzdFdlYktpdFNldHRpbmdzVXNlckFnZW50KTsKIH0KIAogdm9pZCBhZnRlckFs bCgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL1dlYlBhZ2VQcm94 eUd0ay5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL1dlYlBhZ2VQcm94eUd0ay5j cHAKaW5kZXggYWMyNmMwY2I4ZmRiYjhjOWU3MjVmOTMzYjg0NzhhMmE0ZGNjMGY3Yy4uZGQ0MTNl ZGQxMGZhOWU1NzcxZTkxZGY3MDgzOWNkNjkxOTAzNzhiMSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL2d0ay9XZWJQYWdlUHJveHlHdGsuY3BwCisrKyBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9ndGsvV2ViUGFnZVByb3h5R3RrLmNwcApAQCAtMzMsNiArMzMsNyBAQAog I2luY2x1ZGUgIldlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZS5oIgogI2luY2x1ZGUgIldlYlBhZ2VN ZXNzYWdlcy5oIgogI2luY2x1ZGUgIldlYlByb2Nlc3NQcm94eS5oIgorI2luY2x1ZGUgPFdlYkNv cmUvVXNlckFnZW50R3RrLmg+CiAjaW5jbHVkZSA8Z3RrL2d0a3guaD4KIAogbmFtZXNwYWNlIFdl YktpdCB7CkBAIC00NCw4ICs0NSw3IEBAIEd0a1dpZGdldCogV2ViUGFnZVByb3h5Ojp2aWV3V2lk Z2V0KCkKIAogU3RyaW5nIFdlYlBhZ2VQcm94eTo6c3RhbmRhcmRVc2VyQWdlbnQoY29uc3QgU3Ry aW5nJiBhcHBsaWNhdGlvbk5hbWVGb3JVc2VyQWdlbnQpCiB7Ci0gICAgLy8gRklYTUU6IFRoaXMg c2hvdWxkIG5vdCBiZSBoYXJkIGNvZGVkLgotICAgIHJldHVybiAiTW96aWxsYS81LjAgKFgxMTsg TGludXggaTY4NikgQXBwbGVXZWJLaXQvNTM0LjcgKEtIVE1MLCBsaWtlIEdlY2tvKSBWZXJzaW9u LzUuMCBTYWZhcmkvNTM0LjciOworICAgIHJldHVybiBXZWJDb3JlOjpzdGFuZGFyZFVzZXJBZ2Vu dChhcHBsaWNhdGlvbk5hbWVGb3JVc2VyQWdlbnQpOwogfQogCiB2b2lkIFdlYlBhZ2VQcm94eTo6 Z2V0RWRpdG9yQ29tbWFuZHNGb3JLZXlFdmVudChjb25zdCBBdG9taWNTdHJpbmcmIGV2ZW50VHlw ZSwgVmVjdG9yPFdURjo6U3RyaW5nPiYgY29tbWFuZHNMaXN0KQo=