163366 2016-10-12 15:51:46 -0700 [GTK] No way for applications to set notification permissions without waiting for permission request 2017-01-27 07:04:44 -0800 1 1 1 Unclassified WebKit WebKitGTK Other PC Linux RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=164771 https://bugzilla.gnome.org/show_bug.cgi?id=777835 P2 Normal --- 166632 1 mcatanzaro mcatanzaro aperez bugs-noreply cgarcia clopez gustavo mcatanzaro oldest_to_newest 1239550 0 mcatanzaro 2016-10-12 15:51:46 -0700 Websites can check the Notification.permission DOM property [1] to check if they have permission to show notifications without triggering an intrusive permission request (that's done via Notification.requestPermission()). But the WebKitGTK+ API has no way to affirmatively indicate notifications are allowed. The only way is via the permission request API, which is too late. It's a problem for Epiphany. For example, open the Riot Matrix client in a web app; you will immediately see an info bar informing the user that Riot does not have permission to send desktop notifications, even though Epiphany automatically grants notification permission in web app mode when requested. The problem is in WebKitNotificationProvider.cpp, where we need to implement notificationPermissionsCallback of WKNotificationProviderV0. The WKDictionaryRef returned by that callback should be set by some new API function. Simple proposal: void webkit_web_context_set_notification_permissions (WebKitWebContext *context, GHashTable *permissions); where the hash table is a map of strings to bools. [1] https://developer.mozilla.org/en-US/docs/Web/API/Notifications_API/Using_the_Notifications_API 1244595 1 clopez 2016-10-25 18:39:58 -0700 Using Adrian's vector-gnome application If I open this HTML5 notification API test website like: $ ./vector http://www.bennish.net/web-notifications.html And I click on the 'Authorize' button on that website I get the request automatically granted without showing an infobar at all. However, using the same program with the Riot Matrix client, the infobar appears. Why is that? Also I just checked this on the Riot Matrix client (with vector-gnome): * Open it and ignore the infobar about granting desktop notifications * Go to settings on Riot (a gear icon at the bottom right) * Click on the checkbox "Enable desktop notifications" And you have now desktop notifications working without clicking on the infobar. So perhaps the issue is related with the way the Riot Matrix webapp client checks if notifications are enabled/granted/working ? 1244612 2 clopez 2016-10-25 19:54:53 -0700 A quick test based on this doc: ./vector https://jsfiddle.net/o8hfzbrc/ gives notifications are already granted Here seems to be the code from Riot Matrix React SDK: https://github.com/matrix-org/matrix-react-sdk/blob/master/src/Notifier.js ... Is not obvious to me what is going wrong. 1244860 3 mcatanzaro 2016-10-26 11:48:09 -0700 What's going wrong is that checking Notification.permission via JavaScript does not trigger a WebKitNotificationPermissionRequest (nor should it). The sites where notification permissions work properly simply don't check this property. If http://www.bennish.net/web-notifications.html were to attempt to tell you if notifications are authorized without creating a permission request (via Notification.requestPermission()), then it would say that notifications are not authorized (even though the permission request would be automatically granted by the application. WebKit already has a means to prepopulate notification permissions (see comment #0) that we need to expose in the WebKitGTK+ API. 1244908 4 clopez 2016-10-26 14:46:55 -0700 (In reply to comment #3) > What's going wrong is that checking Notification.permission via JavaScript > does not trigger a WebKitNotificationPermissionRequest (nor should it). The > sites where notification permissions work properly simply don't check this > property. If http://www.bennish.net/web-notifications.html were to attempt > to tell you if notifications are authorized without creating a permission > request (via Notification.requestPermission()), then it would say that > notifications are not authorized (even though the permission request would > be automatically granted by the application. WebKit already has a means to > prepopulate notification permissions (see comment #0) that we need to expose > in the WebKitGTK+ API. I see. Thanks for the explanation. I was confused, I was not checking properly that Notification.permission started with a value of "default" before the call to requestPermission() Checked with the inspector: > Notification.permission < "default" > Notification.requestPermission() < undefined > Notification.permission < "granted" Notification.permission 1253163 5 295281 mcatanzaro 2016-11-20 16:18:22 -0800 Created attachment 295281 Patch 1253589 6 295281 gustavo 2016-11-24 08:18:09 -0800 Comment on attachment 295281 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=295281&action=review I don't think I understand the need for this feature. Wouldn't it be the same if the application simply handled the permission request and looked at its hashtable to decide whether it should allow or not? > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1244 > + * Sets initial desktop notification permissions for the @context. > + * @permissions must be a #GHashTable of strings containing security > + * origins (protocol, host, and optional port, e.g. > + * http://www.example.com but not http://www.example.com/) to boolean > + * values (stored using GINT_TO_POINTER()). No I wonder if the hashtable will be friendly to introspection. Maybe we can add a method that takes uri and decision, the user has to call it as many times as it wants, instead? 1253609 7 mcatanzaro 2016-11-24 12:30:52 -0800 (In reply to comment #6) > I don't think I understand the need for this feature. Wouldn't it be the > same if the application simply handled the permission request and looked at > its hashtable to decide whether it should allow or not? Like I explain above, the problem is that the Notification JS API has separate functions to (a) look up the permission, and (b) request permission. In the case of (a), we don't want the browser to actually display a permission request. We could still use WebKitNotificationPermissionRequest by adding a property to indicate whether the request should be displayed to the user, but that's harder as it requires modifying cross-platform code. > I wonder if the hashtable will be friendly to introspection. Maybe we can > add a method that takes uri and decision, the user has to call it as many > times as it wants, instead? Hm, good point, I don't know about introspection.... 1253636 8 aperez 2016-11-25 02:41:36 -0800 (In reply to comment #7) > (In reply to comment #6) > > [...] > > > > I wonder if the hashtable will be friendly to introspection. Maybe we can > > add a method that takes uri and decision, the user has to call it as many > > times as it wants, instead? > > Hm, good point, I don't know about introspection.... Hash tables should play with introspection just fine, as long as the needed annotations are added. In this case the following would be needed: (element-type utf8 gboolean) This is supported since gobject-introspection 0.5.0, which is a non-issue as it is a super old version :-) 1253662 9 mcatanzaro 2016-11-25 14:04:40 -0800 (In reply to comment #8) > Hash tables should play with introspection just fine, as long as the needed > annotations are added. In this case the following would be needed: > > (element-type utf8 gboolean) Thanks, let's do this.... 1253663 10 295428 mcatanzaro 2016-11-25 14:06:10 -0800 Created attachment 295428 Patch 1253837 11 gustavo 2016-11-28 07:15:10 -0800 (In reply to comment #7) > Like I explain above, the problem is that the Notification JS API has > separate functions to (a) look up the permission, and (b) request > permission. In the case of (a), we don't want the browser to actually > display a permission request. > > We could still use WebKitNotificationPermissionRequest by adding a property > to indicate whether the request should be displayed to the user, but that's > harder as it requires modifying cross-platform code. I know that, but I still don't understand why the API user cannot simply reply to the request, since it knows the sites it should always allow, anyway. Is there any case where we need the site's look up permission to return true from the onset? The browser wouldn't display the permission request. Consider the following handler for the permission request signal: if (hosts_to_always_allow.contains(url.host)) { webkit_permission_request_allow (request); return TRUE; } g_object_ref (request); show_request_infobar (request); return TRUE; 1253848 12 mcatanzaro 2016-11-28 09:13:23 -0800 (In reply to comment #11) > I know that, but I still don't understand why the API user cannot simply > reply to the request, since it knows the sites it should always allow, > anyway. Is there any case where we need the site's look up permission to > return true from the onset? > > The browser wouldn't display the permission request. Consider the following > handler for the permission request signal: > > if (hosts_to_always_allow.contains(url.host)) { > webkit_permission_request_allow (request); > return TRUE; > } > > g_object_ref (request); > show_request_infobar (request); > return TRUE; This is possible, but there are two challenges: * If we do that, we must add a property to the permission request to indicate to the browser that it must not display the permission request. Otherwise the browser would have to way to distinguish between JavaScript calling Notification.permission (which must never trigger a user-visible request) and Notification.requestPermission(). It would break old versions of Epiphany using the notifications API without checking the property, although it's not a horrible problem. This means we have to add new API regardless, although it would be a different API. * Currently, Notification.permission is resolved entirely in the web process, and only Notification.requestPermission() goes to the UI process. Notification.requestPermission() is promise-based so the callback occurs asynchronously. If we use the existing WebKitNotificationPermissionRequest API to handle Notification.permission, that would require changing Notification.permission to use a *synchronous* UI process callback the first time it is called for a host, blocking all JS execution until it is resolved. It would require WK2 owner approval as we would have to change the cross-platform code to do this. Also, it will break existing versions of Epiphany in the case where notification permission has not yet been granted, as they will display a permission request to the user anyway and the web process will just hang until it's resolved. So it's a tough call, but there are some serious disadvantages to using the existing WebKitNotificationPermissionRequest API. 1255647 13 gustavo 2016-12-02 02:55:25 -0800 (In reply to comment #12) > This is possible, but there are two challenges: > > * If we do that, we must add a property to the permission request to > indicate to the browser that it must not display the permission request. > Otherwise the browser would have to way to distinguish between JavaScript > calling Notification.permission (which must never trigger a user-visible > request) and Notification.requestPermission(). It would break old versions > of Epiphany using the notifications API without checking the property, > although it's not a horrible problem. This means we have to add new API > regardless, although it would be a different API. I guess this is the bit I'm not understanding. Isn't Epiphany the one that would be pre-loading the permissions anyway? Doesn't Epiphany need to be modified already to add the call to this API and to keep track of a hash table? I don't see why we need that permission. The browser *is* the one handling this, it has all the information it needs to not show the info bar. Notification.permission does not trigger a request, there is no need for a property. > * Currently, Notification.permission is resolved entirely in the web > process, and only Notification.requestPermission() goes to the UI process. > Notification.requestPermission() is promise-based so the callback occurs > asynchronously. If we use the existing WebKitNotificationPermissionRequest > API to handle Notification.permission, that would require changing > Notification.permission to use a *synchronous* UI process callback the first > time it is called for a host, blocking all JS execution until it is > resolved. It would require WK2 owner approval as we would have to change the > cross-platform code to do this. Also, it will break existing versions of > Epiphany in the case where notification permission has not yet been granted, > as they will display a permission request to the user anyway and the web > process will just hang until it's resolved. > > So it's a tough call, but there are some serious disadvantages to using the > existing WebKitNotificationPermissionRequest API. Why would we want Notification.permission to generate a request? The spec does not call for a request to be generated from Notification.permission, right? This is what should happen from my point of view: 1. Web app checks Notification.permission -> "default" (means denied with no request done yet) 2. Web app calls Notification.requestPermission 3. Epiphany gets the permission-requested signal 4. Epiphany checks its database of pre-approved sites 4.1 if the site is pre-approved, reply to the request immediately without showing an infobar 4.2 if the site is pre-denied, reply to the request immediately without showing an infobar 4.3 if no decision is known for the site, show an infobar, reply to request async 1255648 14 gustavo 2016-12-02 02:56:22 -0800 (In reply to comment #13) > I don't see why we need that permission. s/permission/property/ 1255700 15 mcatanzaro 2016-12-02 09:13:35 -0800 > > So it's a tough call, but there are some serious disadvantages to using the > > existing WebKitNotificationPermissionRequest API. > > Why would we want Notification.permission to generate a request? The spec > does not call for a request to be generated from Notification.permission, > right? This is what should happen from my point of view: > > 1. Web app checks Notification.permission -> "default" (means denied with no > request done yet) > > 2. Web app calls Notification.requestPermission That's where the problem is. There exist real-world web apps that don't actually do that. In the case of Riot, if it sees "default" it displays an info bar "You do not have permission to display notifications, click here to request permission" and only calls Notification.requestPermission if the user clicks on its info bar. And the web app is right to do that, because "default" does mean "denied" like you say. It's our fault for not returning "granted" there. We can either solve it by adding API to preload permissions (as my patch does), or by overloading the existing WebKitNotificationPermissionRequest API (with the negative consequences I described above). 1255724 16 aperez 2016-12-02 09:47:03 -0800 (In reply to comment #15) > > > So it's a tough call, but there are some serious disadvantages to using the > > > existing WebKitNotificationPermissionRequest API. > > > > Why would we want Notification.permission to generate a request? The spec > > does not call for a request to be generated from Notification.permission, > > right? This is what should happen from my point of view: > > > > 1. Web app checks Notification.permission -> "default" (means denied with no > > request done yet) > > > > 2. Web app calls Notification.requestPermission > > That's where the problem is. There exist real-world web apps that don't > actually do that. In the case of Riot, if it sees "default" it displays an > info bar "You do not have permission to display notifications, click here to > request permission" and only calls Notification.requestPermission if the > user clicks on its info bar. And the web app is right to do that, because > "default" does mean "denied" like you say. It's our fault for not returning > "granted" there. We can either solve it by adding API to preload permissions > (as my patch does), or by overloading the existing > WebKitNotificationPermissionRequest API (with the negative consequences I > described above). Today I have found out that WhatsApp Web works in Epiphany now, and it also does a similar thing: It first checks “Notification.permission” and if it sees “default”, it will show a message in the left sidebar which the user can click, at which point “Notification.requestPermission” is used. Likely there are many other applications out in the wild that do something similar. The WebNotification spec allows for this kind of behaviours, and we should provide a spec-compliant implementation, even if it's more difficult to implement. 1257719 17 295428 gustavo 2016-12-08 09:19:37 -0800 Comment on attachment 295428 Patch Ah, so the web app itself is showing an infobar. OK, I thought you were talking about the browser's one. Well, I guess it makes sense. 1257759 18 mcatanzaro 2016-12-08 10:34:24 -0800 OK thanks. I'll wait until Monday to land this, in case Carlos has any comments. 1258103 19 295428 cgarcia 2016-12-09 00:47:28 -0800 Comment on attachment 295428 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=295428&action=review > Source/WebKit2/ChangeLog:7 > + You should explain here the purpose of this new API. > Source/WebKit2/UIProcess/API/gtk/WebKitNotificationProvider.cpp:164 > + m_notificationPermissions = API::Dictionary::create(permissionsMap); API::Dictionary::create(WTFMove(permissionsMap)); > Source/WebKit2/UIProcess/API/gtk/WebKitNotificationProvider.h:56 > + RefPtr<API::Dictionary> m_notificationPermissions { nullptr }; RefPtr already initializes its pointer to nullptr in the constructor. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1238 > + * values (stored using GINT_TO_POINTER()). No Boolean values that the user has to store using G_INT_TO_POINTER, looks complex and weak. Maybe it would be easier if we have two parameters, one for the list of security origins to allow, and another one for the ones to deny. Similar to the whitelist/blakclist parameters of webkit_user_style_sheet_new and webkit_user_script_new > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1243 > + * #WebKitNotificationPermissionRequest will ever be generated for > + * domains represented in the @permissions. If the boolean value > + * corresponding to the domain in @permissions is %TRUE, then the domain > + * will always have permission to show desktop notifications; if it is > + * %FALSE, then it will never have permission to do so. This function You started talking about security origins, and now you say domains. That's confusing. I think we should either ask for domains, or maybe expose security origins as WebKitSecurityOrigin, instead of requesting strings and explaining what a security origin is. I'm sure it will be used by other parts of the API eventually. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1250 > + * This function only affects web processes that have not already been > + * created, so it should usually be called before creating the first > + * #WebKitWebView. We can avoid this by using a signal, like we do for initializing web extensions. notificationPermissions callback is called everytime a web process is spawned, with a signal, the user just connect to it and provides the permissions, we don't even need to store them, and it's possible to provide updated permissions. > Tools/ChangeLog:17 > + * TestWebKitAPI/gtk/WebKit2Gtk/WebViewTest.cpp: Add ability to defer web view creation. Why do you needs this? > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:645 > + MAKE_GLIB_TEST_FIXTURE_WITH_SETUP_TEARDOWN(NotificationWebViewTest, setup, teardown); > + > + static void setup() > + { > + WebViewTest::shouldInitializeWebViewInConstructor = false; > + } > + > + static void teardown() > + { > + WebViewTest::shouldInitializeWebViewInConstructor = true; > + } Wouldn't it be possible to add a initialize virtual function to WebViewTest that calls initializeWebView by default? You could override it to do nothing and call initializeWebView on you own later if needed. I still don't understand why it's needed though. > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:731 > + auto test = static_cast<NotificationWebViewTest*>(userData); auto* > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:746 > + GError* error = nullptr; > + WebKitJavascriptResult* jsResult = webkit_web_view_run_javascript_finish(test->m_webView, result, &error); > + g_assert(!error); > + > + JSGlobalContextRef context = webkit_javascript_result_get_global_context(jsResult); > + JSValueRef value = webkit_javascript_result_get_value(jsResult); > + g_assert(JSValueIsString(context, value)); > + > + // Possible values: "denied", "granted", "default" (implicit deny) > + JSStringRef jsStringValue = JSValueToStringCopy(context, value, nullptr); > + test->m_hasPermission = JSStringIsEqualToUTF8CString(jsStringValue, "granted"); > + JSStringRelease(jsStringValue); > + webkit_javascript_result_unref(jsResult); > + > + g_main_loop_quit(test->m_mainLoop); All this is already implemented by WebViewTest, see below. > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:753 > + webkit_web_view_run_javascript(m_webView, "Notification.permission;", nullptr, hasPermissionCallback, this); > + g_main_loop_run(m_mainLoop); > + return m_hasPermission; This could be: auto* result = runJavaScriptAndWaitUntilFinished("Notification.permission;", nullptr); g_assert(result); GUniquePtr<char> value(javascriptResultToCString(result)); return !g_strcmp0(value.get(), "granted"); 1258158 20 mcatanzaro 2016-12-09 09:54:03 -0800 (In reply to comment #19) > You should explain here the purpose of this new API. OK. > > Source/WebKit2/UIProcess/API/gtk/WebKitNotificationProvider.cpp:164 > > + m_notificationPermissions = API::Dictionary::create(permissionsMap); > > API::Dictionary::create(WTFMove(permissionsMap)); Right, oops. I'm still not familiar enough with move operations. > > Source/WebKit2/UIProcess/API/gtk/WebKitNotificationProvider.h:56 > > + RefPtr<API::Dictionary> m_notificationPermissions { nullptr }; > > RefPtr already initializes its pointer to nullptr in the constructor. OK. > Boolean values that the user has to store using G_INT_TO_POINTER, looks > complex and weak. Maybe it would be easier if we have two parameters, one > for the list of security origins to allow, and another one for the ones to > deny. Similar to the whitelist/blakclist parameters of > webkit_user_style_sheet_new and webkit_user_script_new Good idea. > You started talking about security origins, and now you say domains. That's > confusing. I think we should either ask for domains, or maybe expose > security origins as WebKitSecurityOrigin, instead of requesting strings and > explaining what a security origin is. I'm sure it will be used by other > parts of the API eventually. Hm, the problem is a permission for http://example.com will have no effect on https://example.com, same as a permission for http://example.com:80 has no effect on http://example.com:8000. So we can't ask for domains. I guess we could expose a WebKitSecurityOrigin struct with separate protocol/host/port like SoupURI, is that what you suggest? > We can avoid this by using a signal, like we do for initializing web > extensions. notificationPermissions callback is called everytime a web > process is spawned, with a signal, the user just connect to it and provides > the permissions, we don't even need to store them, and it's possible to > provide updated permissions. Hm, good point, otherwise new web process would miss recently-added notification permissions. > > Tools/ChangeLog:17 > > + * TestWebKitAPI/gtk/WebKit2Gtk/WebViewTest.cpp: Add ability to defer web view creation. > > Why do you needs this? To set the permissions before the web process is created by webkit_web_view_new, otherwise the web process never sees any of the permissions and the test just fails. It's going to be needed regardless, to connect to a future notification-permission signal of the web context before it's emitted when the first web view is created. > Wouldn't it be possible to add a initialize virtual function to WebViewTest > that calls initializeWebView by default? You could override it to do nothing > and call initializeWebView on you own later if needed. I still don't > understand why it's needed though. No, because you can't call virtual functions from a constructor. The only alternative I could think of was to add explicit initialize calls in every test case that uses a WebViewTest, which we surely don't want to do. > > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:731 > > + auto test = static_cast<NotificationWebViewTest*>(userData); > > auto* Really? I don't think so? auto& is needed to disambiguate between a copy and a reference, but here the rhs is already a pointer. > This could be: > > auto* result = runJavaScriptAndWaitUntilFinished("Notification.permission;", > nullptr); > g_assert(result); > GUniquePtr<char> value(javascriptResultToCString(result)); > return !g_strcmp0(value.get(), "granted"); I'll try it. 1258646 21 cgarcia 2016-12-10 01:20:53 -0800 (In reply to comment #20) > (In reply to comment #19) > > You should explain here the purpose of this new API. > > OK. > > > > Source/WebKit2/UIProcess/API/gtk/WebKitNotificationProvider.cpp:164 > > > + m_notificationPermissions = API::Dictionary::create(permissionsMap); > > > > API::Dictionary::create(WTFMove(permissionsMap)); > > Right, oops. I'm still not familiar enough with move operations. > > > > Source/WebKit2/UIProcess/API/gtk/WebKitNotificationProvider.h:56 > > > + RefPtr<API::Dictionary> m_notificationPermissions { nullptr }; > > > > RefPtr already initializes its pointer to nullptr in the constructor. > > OK. > > > Boolean values that the user has to store using G_INT_TO_POINTER, looks > > complex and weak. Maybe it would be easier if we have two parameters, one > > for the list of security origins to allow, and another one for the ones to > > deny. Similar to the whitelist/blakclist parameters of > > webkit_user_style_sheet_new and webkit_user_script_new > > Good idea. > > > You started talking about security origins, and now you say domains. That's > > confusing. I think we should either ask for domains, or maybe expose > > security origins as WebKitSecurityOrigin, instead of requesting strings and > > explaining what a security origin is. I'm sure it will be used by other > > parts of the API eventually. > > Hm, the problem is a permission for http://example.com will have no effect > on https://example.com, same as a permission for http://example.com:80 has > no effect on http://example.com:8000. So we can't ask for domains. I guess > we could expose a WebKitSecurityOrigin struct with separate > protocol/host/port like SoupURI, is that what you suggest? See patch attached to bug #146589, you have WebKitSecurityOrigin implemented there. > > We can avoid this by using a signal, like we do for initializing web > > extensions. notificationPermissions callback is called everytime a web > > process is spawned, with a signal, the user just connect to it and provides > > the permissions, we don't even need to store them, and it's possible to > > provide updated permissions. > > Hm, good point, otherwise new web process would miss recently-added > notification permissions. > > > > Tools/ChangeLog:17 > > > + * TestWebKitAPI/gtk/WebKit2Gtk/WebViewTest.cpp: Add ability to defer web view creation. > > > > Why do you needs this? > > To set the permissions before the web process is created by > webkit_web_view_new, otherwise the web process never sees any of the > permissions and the test just fails. It's going to be needed regardless, to > connect to a future notification-permission signal of the web context before > it's emitted when the first web view is created. Yes, but you don't need any change in WebView creation. Notification permissions are a web context thing, so you can add a static Test::setNotificatinPermissions(), that you can call from setup and teardown (with nullptr in this case). Then, in Test() when setting up the context you connect to the new signal and set the permissions if they have been set. > > Wouldn't it be possible to add a initialize virtual function to WebViewTest > > that calls initializeWebView by default? You could override it to do nothing > > and call initializeWebView on you own later if needed. I still don't > > understand why it's needed though. > > No, because you can't call virtual functions from a constructor. The only > alternative I could think of was to add explicit initialize calls in every > test case that uses a WebViewTest, which we surely don't want to do. Ah, right! > > > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:731 > > > + auto test = static_cast<NotificationWebViewTest*>(userData); > > > > auto* > > Really? I don't think so? auto& is needed to disambiguate between a copy and > a reference, but here the rhs is already a pointer. It's not because it's needed, it's just for readability, making it explicit that what you get is a pointer. > > This could be: > > > > auto* result = runJavaScriptAndWaitUntilFinished("Notification.permission;", > > nullptr); > > g_assert(result); > > GUniquePtr<char> value(javascriptResultToCString(result)); > > return !g_strcmp0(value.get(), "granted"); > > I'll try it. 1258688 22 mcatanzaro 2016-12-10 08:31:50 -0800 (In reply to comment #21) > See patch attached to bug #146589, you have WebKitSecurityOrigin implemented > there. OK, will you be returning to that patch this cycle, or do you want me to just copy it from there? > Yes, but you don't need any change in WebView creation. Notification > permissions are a web context thing, so you can add a static > Test::setNotificatinPermissions(), that you can call from setup and teardown > (with nullptr in this case). Then, in Test() when setting up the context you > connect to the new signal and set the permissions if they have been set. Good idea, that's better. 1262820 23 mcatanzaro 2016-12-27 10:25:21 -0800 (In reply to comment #19) > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1250 > > + * This function only affects web processes that have not already been > > + * created, so it should usually be called before creating the first > > + * #WebKitWebView. > > We can avoid this by using a signal, like we do for initializing web > extensions. notificationPermissions callback is called everytime a web > process is spawned, with a signal, the user just connect to it and provides > the permissions, we don't even need to store them, and it's possible to > provide updated permissions. I think the only correct place to emit the signal would be from a new platform function at the top of WebProcessPool::createNewWebProcess. E.g. the existing initialize-web-extensions signal happens too late, after the notification permissions have already been copied inside WebProcessPool::createNewWebProcess. 1262830 24 mcatanzaro 2016-12-27 11:35:29 -0800 (In reply to comment #23) > I think the only correct place to emit the signal would be from a new > platform function at the top of WebProcessPool::createNewWebProcess. E.g. > the existing initialize-web-extensions signal happens too late, after the > notification permissions have already been copied inside > WebProcessPool::createNewWebProcess. It's actually kinda tricky to find a good way to call back into WebKitWebContext from WebProcessPool. Hopefully we don't need to add a new Client class just for this one callback. Do you have any suggestions, Carlos? 1262894 25 cgarcia 2016-12-28 00:45:51 -0800 We already have the callback, it's notificationPermissions, use that to emit our signal. 1262952 26 mcatanzaro 2016-12-28 10:43:15 -0800 (In reply to comment #25) > We already have the callback, it's notificationPermissions, use that to emit > our signal. Good point. 1263054 27 mcatanzaro 2016-12-29 08:43:07 -0800 (In reply to comment #21) > Yes, but you don't need any change in WebView creation. Notification > permissions are a web context thing, so you can add a static > Test::setNotificatinPermissions(), that you can call from setup and teardown > (with nullptr in this case). Then, in Test() when setting up the context you > connect to the new signal and set the permissions if they have been set. I tried this. While it's possible, it means you need a different Test subclass for each call to Test::setNotificationPermissions, to have a different implementation of setup. That's terrible; we surely want to be able to set the permissions from the testcase itself. Deferring the creation of the webview is more general, so it could be useful in the future, and seems better. And this isn't the first time I've wanted more control over when the webview is created in API tests; although I don't remember what the previous time was, I bet we might want this again in the future. So I haven't changed how the test works. 1263064 28 297834 mcatanzaro 2016-12-29 09:36:18 -0800 Created attachment 297834 Patch 1263169 29 297861 mcatanzaro 2016-12-30 12:27:53 -0800 Created attachment 297861 Patch 1263199 30 297861 cgarcia 2016-12-31 02:40:40 -0800 Comment on attachment 297861 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=297861&action=review > Source/WebKit2/PlatformGTK.cmake:225 > + UIProcess/API/gtk/WebKitSecurityOrigin.cpp > + UIProcess/API/gtk/WebKitSecurityOrigin.h > + UIProcess/API/gtk/WebKitSecurityOriginPrivate.h I think we can move security origin to its own patch/bug. > Source/WebKit2/UIProcess/API/gtk/WebKitNotificationProvider.cpp:59 > + return toAPI(toNotificationProvider(clientInfo)->notificationPermissions().leakRef()); Why leakRef()? If we are leaking our ref why do we keep a m_notificationPermissions member? > Source/WebKit2/UIProcess/API/gtk/WebKitNotificationProvider.cpp:167 > +RefPtr<API::Dictionary> WebKitNotificationProvider::notificationPermissions() > +{ > + webkitWebContextSetInitialNotificationPermissions(m_webContext); > + return m_notificationPermissions; Do we really need to keep the m_notificationPermissions member? Could we make webkitWebContextSetInitialNotificationPermissions return a RefPtr<API:Dictionary> and simply return it here transferring the ownership to the caller? > Source/WebKit2/UIProcess/API/gtk/WebKitNotificationProvider.cpp:173 > +void WebKitNotificationProvider::setNotificationPermissions(HashMap<String, RefPtr<API::Object>>&& permissionsMap) > +{ > + m_notificationPermissions = API::Dictionary::create(WTFMove(permissionsMap)); > +} And we don't need this at all > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:50 > + _WebKitSecurityOrigin(WebCore::SecurityOrigin* coreSecurityOrigin) WebKitSecurityOrigin always wraps a WebCore::SecurityOrigin and all create methods return a Ref<>, so I think we could use a reference here, or even better a Ref<> and also use Ref<> instead of RefPtr for the member, but that's already the other constructor. since this one is not realy used in this patch, simply remove it, if we need it eventually, we can add it later. > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:51 > + : securityOrigin(coreSecurityOrigin) There was a bug in my patch, referenceCount should be initialized to 1 here. > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:56 > + : securityOrigin(WTFMove(coreSecurityOrigin)) And here. > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:60 > + RefPtr<WebCore::SecurityOrigin> securityOrigin; I think this could be Ref<> > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:74 > +WebKitSecurityOrigin* webkitSecurityOriginCreate(WebCore::SecurityOrigin* coreSecurityOrigin) > +{ > + WebKitSecurityOrigin* origin = static_cast<WebKitSecurityOrigin*>(fastMalloc(sizeof(WebKitSecurityOrigin))); > + new (origin) WebKitSecurityOrigin(coreSecurityOrigin); > + return origin; > +} This is unused in this patch, let's remove it for now, we can add it eventually if actually needed. > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:110 > + if (port && WebCore::defaultPortForProtocol(protocol) != static_cast<uint16_t>(port)) Use guint16 instead of guint, then you don't need any cast here and it matches WebCore::SecurityOrigin. Here you are checking port != 0, so I assume you are considering that passing 0 as port means using the default. That should be document. > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:131 > + * webkit_security_origin_new_from_string: > + * @uri: The URI for the new origin > + * > + * Create a new security origin from the provided URI. Components of > + * @uri other than protocol, host, and port will be ignored. > + * > + * Returns: (transfer full): A #WebKitSecurityOrigin. > + * > + * Since: 2.16 > + */ > +WebKitSecurityOrigin* webkit_security_origin_new_from_string(const gchar* uri) > +{ > + g_return_val_if_fail(uri, nullptr); > + > + return webkitSecurityOriginCreate(WebCore::SecurityOrigin::createFromString(String::fromUTF8(uri))); There's an interesting mix here. The method is called from_string, and it indeed uses the createFromString() method, but the parameter is uri, and documentation says you provide a URI indeed. String is supposed to be a string representation of a security origin (so, it doesn't make sense the doc saying that other uri components will be ignored, for example). I think what we want here is the URL constructor, I would use for instead of from too, webkit_security_origin_new_for_uri(). Instead of saying that components will be ignored we should document that a security origin represents, so it's not that the path/query/fragment is ignored, it's that we are creating the security origin corresponding to the given URI. And of course we should use create() method that receives a URL. We could create a SoupURI and g_return_val_if_fail if it's invalid instead of just checking it's not null. > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:223 > + * Get the port of @origin. This function will always return 0 if the > + * port is the default port for the given protocol. For example, > + * http://example.com has the same security origin as > + * http://example.com:80, and this function will return 0 for a > + * #WebKitSecurityOrigin constructed from either string. Exactly, that's what we should document in webkit_security_origin_new(), since we also allow to pass 0 there meaning the default. Maybe we could add a macro to make it more explicit #define WEBKIT_SECURITY_ORIGIN_PORT_DEFAULT 0 Or something similar. > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:244 > + * Get a string representation of @origin. Be aware that this function > + * may return %NULL if the origin is unique. (For example, this will > + * occur if @origin represents a sandboxed iframe.) So, we are introducing here the concept of unique origins. We should explain what a unique origin is (maybe not here, but in the section documention), and probably also add webkit_security_origin_is_unique(). We should also explain what the string representation is (like the url without the path/query/fragment parts). > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:246 > + * Returns: (allow-none): a string representation of @origin. , or %NULL if @origin is unique > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:250 > +const gchar* webkit_security_origin_to_string(WebKitSecurityOrigin* origin) This is probably my personal opinion, but to_string sounds to me like a conversion, and conversion methods normally return a temp value and the transfer is ownership. Here we are caching and returning a const char*, which I think is very convenient, but then I think as_string or simply get_string_representation like any other getter. > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.h:65 > +WEBKIT_API guint guin16 > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:114 > + SET_INITIAL_NOTIFICATION_PERMISSIONS, what about INITIALIZE_NOTIFICATION_PERMISSIONS for consistency with the web extensions initialization signal? > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:398 > + * This signal is emitted when a new web process is about to be > + * launched. It signals the most appropriate moment to use > + * webkit_web_context_set_initial_notification_permissions(). In the case of web extensions it makes sense to explain that this happens before the new web process is spawned, in this case I wouldn't say anything about processes, just that this is emitted when the web context needs to initialize notification permissions, and that it can be emitted multiple times. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1245 > + String string = webkitSecurityOriginGetSecurityOrigin(origin).toString(); > + if (string != "null") It would be better to use webkit_security_origin_as_string() instead, since the value is cached and you would only need to check if it's nullptr. Also we don't need webkitSecurityOriginGetSecurityOrigin at all in such case. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1260 > + * webkit_web_context_set_initial_notification_permissions: initialize_notification_permissions? > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1288 > + context->priv->notificationProvider->setNotificationPermissions(WTFMove(map)); Ok, I see now that we need to keep the permissions somewhere, either here in the context or in the provider, so it's ok to keep them in the provider. But then we should not transfer the ownership, because the user can call this at any moment and not handle the signal for example. > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebContext.cpp:760 > +} I would also add tests for non HTTP uris, like file:// > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebContext.cpp:775 > + Test::add("WebKitSecurityOrigin", "basic", testSecurityOriginBasic); Why is this in TestWebKitWebContext.cpp? > Tools/TestWebKitAPI/gtk/WebKit2Gtk/WebViewTest.cpp:-38 > - assertObjectIsDeletedWhenTestFinishes(G_OBJECT(m_userContentManager.get())); You can leave this here, the m_userContentManager is still initialized here. 1263200 31 297861 cgarcia 2016-12-31 02:45:07 -0800 Comment on attachment 297861 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=297861&action=review >> Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:250 >> +const gchar* webkit_security_origin_to_string(WebKitSecurityOrigin* origin) > > This is probably my personal opinion, but to_string sounds to me like a conversion, and conversion methods normally return a temp value and the transfer is ownership. Here we are caching and returning a const char*, which I think is very convenient, but then I think as_string or simply get_string_representation like any other getter. the transfer is ownership? :-D I meant the ownership is transferred. 1263201 32 297861 cgarcia 2016-12-31 02:48:58 -0800 Comment on attachment 297861 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=297861&action=review > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:235 > + if (auto port = origin->securityOrigin->port()) > + return *port; > + return 0; We can simplify this by using value_or() 1263207 33 mcatanzaro 2016-12-31 09:49:10 -0800 (In reply to comment #30) > I think we can move security origin to its own patch/bug. Probably wise, yes. I will post an updated patch responding to these comments in a different bug, then return to this notifications one once we've landed that. Thanks for reviewing. > > Source/WebKit2/UIProcess/API/gtk/WebKitNotificationProvider.cpp:59 > > + return toAPI(toNotificationProvider(clientInfo)->notificationPermissions().leakRef()); > > Why leakRef()? If we are leaking our ref why do we keep a > m_notificationPermissions member? Hm, maybe that's just wrong. I would have added it in at some point a month ago when trying to make it not crash, but I suppose I need a paired unref somewhere? The to/from API casting is really confusing, and there's no docs so I have to dig through so many files to guess how it works. :( > > Source/WebKit2/UIProcess/API/gtk/WebKitNotificationProvider.cpp:167 > > +RefPtr<API::Dictionary> WebKitNotificationProvider::notificationPermissions() > > +{ > > + webkitWebContextSetInitialNotificationPermissions(m_webContext); > > + return m_notificationPermissions; > > Do we really need to keep the m_notificationPermissions member? Could we > make webkitWebContextSetInitialNotificationPermissions return a > RefPtr<API:Dictionary> and simply return it here transferring the ownership > to the caller? (You discovered below that it's still needed.) > > Source/WebKit2/UIProcess/API/gtk/WebKitNotificationProvider.cpp:173 > > +void WebKitNotificationProvider::setNotificationPermissions(HashMap<String, RefPtr<API::Object>>&& permissionsMap) > > +{ > > + m_notificationPermissions = API::Dictionary::create(WTFMove(permissionsMap)); > > +} > > And we don't need this at all Ditto. > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:50 > > + _WebKitSecurityOrigin(WebCore::SecurityOrigin* coreSecurityOrigin) > > WebKitSecurityOrigin always wraps a WebCore::SecurityOrigin and all create > methods return a Ref<>, so I think we could use a reference here, or even > better a Ref<> and also use Ref<> instead of RefPtr for the member, but > that's already the other constructor. since this one is not realy used in > this patch, simply remove it, if we need it eventually, we can add it later. OK. > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:51 > > + : securityOrigin(coreSecurityOrigin) > > There was a bug in my patch, referenceCount should be initialized to 1 here. Um, good catch. I guess my tests passed because g_atomic_int_dec_and_test brings the refcount down to -1 in the typical case webkit_security_origin_ref is never called, then g_atomic_int_dec_and_test always returns FALSE and it's never freed. > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:56 > > + : securityOrigin(WTFMove(coreSecurityOrigin)) > > And here. I'll initialize it in the declaration, it doesn't need to be in any constructor. > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:60 > > + RefPtr<WebCore::SecurityOrigin> securityOrigin; > > I think this could be Ref<> Absolutely. > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:74 > > +WebKitSecurityOrigin* webkitSecurityOriginCreate(WebCore::SecurityOrigin* coreSecurityOrigin) > > +{ > > + WebKitSecurityOrigin* origin = static_cast<WebKitSecurityOrigin*>(fastMalloc(sizeof(WebKitSecurityOrigin))); > > + new (origin) WebKitSecurityOrigin(coreSecurityOrigin); > > + return origin; > > +} > > This is unused in this patch, let's remove it for now, we can add it > eventually if actually needed. Yeah, I wondered about that but decided to leave it in. Probably a bad choice. > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:110 > > + if (port && WebCore::defaultPortForProtocol(protocol) != static_cast<uint16_t>(port)) > > Use guint16 instead of guint, then you don't need any cast here and it > matches WebCore::SecurityOrigin. Here you are checking port != 0, so I > assume you are considering that passing 0 as port means using the default. > That should be document. Believe it or not, I actually didn't know about guint16. I'll document that. > There's an interesting mix here. The method is called from_string, and it > indeed uses the createFromString() method, but the parameter is uri, and > documentation says you provide a URI indeed. String is supposed to be a > string representation of a security origin (so, it doesn't make sense the > doc saying that other uri components will be ignored, for example). I think > what we want here is the URL constructor, I would use for instead of from > too, webkit_security_origin_new_for_uri(). Instead of saying that components > will be ignored we should document that a security origin represents, so > it's not that the path/query/fragment is ignored, it's that we are creating > the security origin corresponding to the given URI. And of course we should > use create() method that receives a URL. We could create a SoupURI and > g_return_val_if_fail if it's invalid instead of just checking it's not null. Um, OK. End result will be the same either way. I agree that _for_uri is a better name than _from_string. > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:223 > > + * Get the port of @origin. This function will always return 0 if the > > + * port is the default port for the given protocol. For example, > > + * http://example.com has the same security origin as > > + * http://example.com:80, and this function will return 0 for a > > + * #WebKitSecurityOrigin constructed from either string. > > Exactly, that's what we should document in webkit_security_origin_new(), > since we also allow to pass 0 there meaning the default. Maybe we could add > a macro to make it more explicit > > #define WEBKIT_SECURITY_ORIGIN_PORT_DEFAULT 0 > > Or something similar. I don't think a macro is needed. I'll improve the documentation. > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:244 > > + * Get a string representation of @origin. Be aware that this function > > + * may return %NULL if the origin is unique. (For example, this will > > + * occur if @origin represents a sandboxed iframe.) > > So, we are introducing here the concept of unique origins. We should explain > what a unique origin is (maybe not here, but in the section documention), > and probably also add webkit_security_origin_is_unique(). We should also > explain what the string representation is (like the url without the > path/query/fragment parts). Hm, maybe. It's not currently possible to have a unique origin because we never create WebKitSecurityOrigin objects inside WebKit, they're only used currently to pass in notification permissions, so they have to be created externally by the client and we don't expose API for creating a unique origin. So it feels odd adding a function that just always returns FALSE. But if WebKit ever returns WebKitSecurityOrigin objects that it creates itself, it could be useful. Maybe I should just add it now? Probably if exposing that, I should expose a comparison function webkit_security_origin_is_same_origin() as well? Even though these are not currently useful, they are easy to add could be in the future. > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:246 > > + * Returns: (allow-none): a string representation of @origin. > > , or %NULL if @origin is unique > > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:250 > > +const gchar* webkit_security_origin_to_string(WebKitSecurityOrigin* origin) > > This is probably my personal opinion, but to_string sounds to me like a > conversion, and conversion methods normally return a temp value and the > transfer is ownership. Here we are caching and returning a const char*, > which I think is very convenient, but then I think as_string or simply > get_string_representation like any other getter. That's what I thought too, but I opened devhelp and searched for to_string and found that half the functions are transfer full and the other half transfer null, so GNOME at least has no such convention. I think I prefer the to_string() name, so maybe I should just make it transfer full. The copy will be often unnecessary but I agree it's probably better to transfer ownership. > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.h:65 > > +WEBKIT_API guint > > guin16 OK. > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:114 > > + SET_INITIAL_NOTIFICATION_PERMISSIONS, > > what about INITIALIZE_NOTIFICATION_PERMISSIONS for consistency with the web > extensions initialization signal? OK. > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:398 > > + * This signal is emitted when a new web process is about to be > > + * launched. It signals the most appropriate moment to use > > + * webkit_web_context_set_initial_notification_permissions(). > > In the case of web extensions it makes sense to explain that this happens > before the new web process is spawned, in this case I wouldn't say anything > about processes, just that this is emitted when the web context needs to > initialize notification permissions, and that it can be emitted multiple > times. I wondered about whether to mention this detail in the comments. I understand your argument that getting the permissions once per process launch is an implementation detail that could change. But it seems worthwhile to mention it here, because otherwise you might assume the signal is only emitted once, and do expensive work in it. For example, my (not very good yet) Epiphany implementation of this opens a file and synchronously reads permissions from it each time the signal is emitted. (Twice, I need to improve that. ;) But it could be emitted 50 or 100 or however many times when the application is started, once for each tab. So we probably want to mention that as a hint to the user to not do needlessly expensive stuff inside the signal handler. > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1245 > > + String string = webkitSecurityOriginGetSecurityOrigin(origin).toString(); > > + if (string != "null") > > It would be better to use webkit_security_origin_as_string() instead, since > the value is cached and you would only need to check if it's nullptr. Also > we don't need webkitSecurityOriginGetSecurityOrigin at all in such case. OK. > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1260 > > + * webkit_web_context_set_initial_notification_permissions: > > initialize_notification_permissions? OK. > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1288 > > + context->priv->notificationProvider->setNotificationPermissions(WTFMove(map)); > > Ok, I see now that we need to keep the permissions somewhere, either here in > the context or in the provider, so it's ok to keep them in the provider. But > then we should not transfer the ownership, because the user can call this at > any moment and not handle the signal for example. What do you mean "we should not transfer the ownership"? The map is never used again in this function, so it's moved into the Provider, which holds the ownership. What's wrong with that? > > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebContext.cpp:760 > > +} > > I would also add tests for non HTTP uris, like file:// Probably a good idea, yes. > > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebContext.cpp:775 > > + Test::add("WebKitSecurityOrigin", "basic", testSecurityOriginBasic); > > Why is this in TestWebKitWebContext.cpp? Because you put it there. ;) I will move it to a new file. > > Tools/TestWebKitAPI/gtk/WebKit2Gtk/WebViewTest.cpp:-38 > > - assertObjectIsDeletedWhenTestFinishes(G_OBJECT(m_userContentManager.get())); > > You can leave this here, the m_userContentManager is still initialized here. Good catch. 1263208 34 mcatanzaro 2016-12-31 09:50:37 -0800 (In reply to comment #32) > Comment on attachment 297861 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=297861&action=review > > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:235 > > + if (auto port = origin->securityOrigin->port()) > > + return *port; > > + return 0; > > We can simplify this by using value_or() Yes, good to know. 1263211 35 mcatanzaro 2016-12-31 11:14:49 -0800 Should webkitSecurityOriginGetSecurityOrigin return a WebCore::SecurityOrigin& or a Ref<WebCore::SecurityOrigin>? 1263212 36 mcatanzaro 2016-12-31 12:23:17 -0800 (In reply to comment #30) > So, we are introducing here the concept of unique origins. We should explain > what a unique origin is (maybe not here, but in the section documention), > and probably also add webkit_security_origin_is_unique(). We should also > explain what the string representation is (like the url without the > path/query/fragment parts). This is a hard decision. Eventually I decided we should not expose this yet as it's not currently possible to have a unique WebKitSecurityOrigin. If that were to be exposed, we would also want to start exposing more functions like is_same_origin and also the domain property. 1263214 37 mcatanzaro 2016-12-31 14:04:08 -0800 (In reply to comment #36) > This is a hard decision. Eventually I decided we should not expose this yet > as it's not currently possible to have a unique WebKitSecurityOrigin. Actually you can do it by passing a data URI to the URI constructor, but IMO that still doesn't justify exposing isUnique. 1263218 38 mcatanzaro 2016-12-31 14:15:27 -0800 Patch in bug #166632. 1263226 39 cgarcia 2017-01-01 01:55:21 -0800 (In reply to comment #33) > > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:244 > > > + * Get a string representation of @origin. Be aware that this function > > > + * may return %NULL if the origin is unique. (For example, this will > > > + * occur if @origin represents a sandboxed iframe.) > > > > So, we are introducing here the concept of unique origins. We should explain > > what a unique origin is (maybe not here, but in the section documention), > > and probably also add webkit_security_origin_is_unique(). We should also > > explain what the string representation is (like the url without the > > path/query/fragment parts). > > Hm, maybe. It's not currently possible to have a unique origin because we > never create WebKitSecurityOrigin objects inside WebKit, they're only used > currently to pass in notification permissions, so they have to be created > externally by the client and we don't expose API for creating a unique > origin. So it feels odd adding a function that just always returns FALSE. > But if WebKit ever returns WebKitSecurityOrigin objects that it creates > itself, it could be useful. Maybe I should just add it now? Probably if > exposing that, I should expose a comparison function > webkit_security_origin_is_same_origin() as well? Even though these are not > currently useful, they are easy to add could be in the future. If we don't want to expose is_unique(), then we shouldn't mention unique origins in the documentation. Actually, the string reprepsentation can null for non unique origins too, for example for local files when m_enforceFilePathSeparation is true. But again, that's not possible for security origins created by the user. With the current API creating a security origin for a URL that is considered unique, will create a unique origin, so it's indeed possible. Note that the user can register any scheme as no-access with webkit_security_manager_register_uri_scheme_as_no_access(). > > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:246 > > > + * Returns: (allow-none): a string representation of @origin. > > > > , or %NULL if @origin is unique > > > > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.cpp:250 > > > +const gchar* webkit_security_origin_to_string(WebKitSecurityOrigin* origin) > > > > This is probably my personal opinion, but to_string sounds to me like a > > conversion, and conversion methods normally return a temp value and the > > transfer is ownership. Here we are caching and returning a const char*, > > which I think is very convenient, but then I think as_string or simply > > get_string_representation like any other getter. > > That's what I thought too, but I opened devhelp and searched for to_string > and found that half the functions are transfer full and the other half > transfer null, so GNOME at least has no such convention. I think I prefer > the to_string() name, so maybe I should just make it transfer full. The copy > will be often unnecessary but I agree it's probably better to transfer > ownership. > > > > Source/WebKit2/UIProcess/API/gtk/WebKitSecurityOrigin.h:65 > > > +WEBKIT_API guint > > > > guin16 > > OK. > > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:114 > > > + SET_INITIAL_NOTIFICATION_PERMISSIONS, > > > > what about INITIALIZE_NOTIFICATION_PERMISSIONS for consistency with the web > > extensions initialization signal? > > OK. > > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:398 > > > + * This signal is emitted when a new web process is about to be > > > + * launched. It signals the most appropriate moment to use > > > + * webkit_web_context_set_initial_notification_permissions(). > > > > In the case of web extensions it makes sense to explain that this happens > > before the new web process is spawned, in this case I wouldn't say anything > > about processes, just that this is emitted when the web context needs to > > initialize notification permissions, and that it can be emitted multiple > > times. > > I wondered about whether to mention this detail in the comments. I > understand your argument that getting the permissions once per process > launch is an implementation detail that could change. But it seems > worthwhile to mention it here, because otherwise you might assume the signal > is only emitted once, and do expensive work in it. For example, my (not very > good yet) Epiphany implementation of this opens a file and synchronously > reads permissions from it each time the signal is emitted. (Twice, I need to > improve that. ;) But it could be emitted 50 or 100 or however many times > when the application is started, once for each tab. So we probably want to > mention that as a hint to the user to not do needlessly expensive stuff > inside the signal handler. Good point. Also the signal can't be handled asynchronously, you are supposed to call the initialize_method in the handler. > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1245 > > > + String string = webkitSecurityOriginGetSecurityOrigin(origin).toString(); > > > + if (string != "null") > > > > It would be better to use webkit_security_origin_as_string() instead, since > > the value is cached and you would only need to check if it's nullptr. Also > > we don't need webkitSecurityOriginGetSecurityOrigin at all in such case. > > OK. > > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1260 > > > + * webkit_web_context_set_initial_notification_permissions: > > > > initialize_notification_permissions? > > OK. > > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1288 > > > + context->priv->notificationProvider->setNotificationPermissions(WTFMove(map)); > > > > Ok, I see now that we need to keep the permissions somewhere, either here in > > the context or in the provider, so it's ok to keep them in the provider. But > > then we should not transfer the ownership, because the user can call this at > > any moment and not handle the signal for example. > > What do you mean "we should not transfer the ownership"? The map is never > used again in this function, so it's moved into the Provider, which holds > the ownership. What's wrong with that? I meant in the provider, the leakReaf() thing. > > > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebContext.cpp:760 > > > +} > > > > I would also add tests for non HTTP uris, like file:// > > Probably a good idea, yes. > > > > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebContext.cpp:775 > > > + Test::add("WebKitSecurityOrigin", "basic", testSecurityOriginBasic); > > > > Why is this in TestWebKitWebContext.cpp? > > Because you put it there. ;) I will move it to a new file. :-D 1263443 40 mcatanzaro 2017-01-03 07:51:20 -0800 (In reply to comment #30) > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1245 > > + String string = webkitSecurityOriginGetSecurityOrigin(origin).toString(); > > + if (string != "null") > > It would be better to use webkit_security_origin_as_string() instead, since > the value is cached and you would only need to check if it's nullptr. Also > we don't need webkitSecurityOriginGetSecurityOrigin at all in such case. In the end, I didn't add webkitSecurityOriginGetSecurityOrigin in the previous patch, but I still want to add it here to avoid using webkit_security_origin_to_string. One disadvantage of using the external API function is the unnecessary roundtrip encoding conversion from WTF::String (UTF-16) -> API UTF-8 -> back to :String (UTF-16). Also, since it's no longer transfer none, String can avoid heap memory allocation if the string is sufficiently-small. I imagine the performance characteristics are irrelevant, though: it's just nicer to use String instead of GUniquePtr<char>. 1263449 41 mcatanzaro 2017-01-03 08:52:05 -0800 (In reply to comment #30) > Why leakRef()? If we are leaking our ref why do we keep a > m_notificationPermissions member? Chatted about this. Agreed it's a returned temporary RefPtr and the goal is to transfer ownership, so that's right. It might even be what I was thinking when I wrote it! 1263564 42 297957 mcatanzaro 2017-01-03 15:00:37 -0800 Created attachment 297957 Patch 1263698 43 297957 cgarcia 2017-01-03 23:22:44 -0800 Comment on attachment 297957 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=297957&action=review > Source/WebKit2/UIProcess/API/gtk/WebKitNotificationProvider.h:45 > + RefPtr<API::Dictionary> notificationPermissions(); I think this could be const. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:398 > + * This signal is emitted when a new web process is about to be > + * launched. It signals the most appropriate moment to use > + * webkit_web_context_initialize_notification_permissions(). I would mention here that if you don't call webkit_web_context_initialize_notification_permissions() again, the permissions set previously will be used. That way apps can optimize and do nothing if nothing changed in their side. And as I said in previous review, I would start saying this signal is emitted when the web context needs to initialize the permissions, and then you can say this happens when a new process is about to be launched. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1257 > +static void addAllowedOriginToMap(WebKitSecurityOrigin* origin, HashMap<String, RefPtr<API::Object>>* map) > +{ > + addOriginToMap(origin, map, true); > +} > + > +static void addDisallowedOriginToMap(WebKitSecurityOrigin* origin, HashMap<String, RefPtr<API::Object>>* map) > +{ > + addOriginToMap(origin, map, false); > +} These can be lambdas > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1283 > +void webkit_web_context_initialize_notification_permissions(WebKitWebContext* context, GList* allowed_origins, GList* disallowed_origins) allowed_origins -> allowedOrigins disallowed_origins -> disallowedOrigins > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1287 > + g_list_foreach(allowed_origins, (GFunc)addAllowedOriginToMap, &map); > + g_list_foreach(disallowed_origins, (GFunc)addDisallowedOriginToMap, &map); Do not use C style casts here. You can use lambdas instead and cast the userData in the body. g_list_foreach(allowedOrigins, [](gpointer data, gpointer userData) { addOriginToMap(static_cast<WebKitSecurityOrigin*>(origin), static_cast<HashMap<String, RefPtr<API::Object>>*>(map), true); }, &map); > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:848 > + GList* allowedOrigins = nullptr; GList* allowedOrigins = g_list_prepend(nullptr, webkit_security_origin_new_for_uri()); > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:849 > + allowedOrigins = g_list_append(allowedOrigins, webkit_security_origin_new_for_uri(gServer->securityOrigin().data())); Why do you need gServer->securityOrigin()? You can pass the base uri and webkit_security_origin_new_for_uri will do the magic > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:851 > + g_list_free_full(allowedOrigins, (GDestroyNotify)webkit_security_origin_unref); Do not use C style casts > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:856 > + GList* disallowedOrigins = nullptr; GList* disallowedOrigins = g_list_prepend(nullptr, webkit_security_origin_new_for_uri()); > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:857 > + disallowedOrigins = g_list_append(disallowedOrigins, webkit_security_origin_new_for_uri(gServer->securityOrigin().data())); Ditto. > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:859 > + g_list_free_full(disallowedOrigins, (GDestroyNotify)webkit_security_origin_unref); Do not use C style casts > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:873 > + static const char* title = "This is a notification"; > + static const char* body = "This is the body."; > + test->requestNotificationAndWaitUntilShown(title, body); I guess we can probably pass the string literals directly, we don't really need the variables, no? > Tools/TestWebKitAPI/gtk/WebKit2Gtk/WebKitTestServer.cpp:76 > + // The security origin is the base URI minus the trailing slash. > + GUniquePtr<gchar> uriString(soup_uri_to_string(m_baseURI, FALSE)); > + uriString.get()[strlen(uriString.get()) - 1] = '\0'; > + return uriString.get(); Why are we reinventing the security origin here? I think we can either remove this and pass the base uri to webkit_security_origin_new_for_uri(), or make this return a WebKitSecurityOrigin and simply call webkit_security_origin_new_for_uri() with the base uri. 1263788 44 mcatanzaro 2017-01-04 09:47:33 -0800 (In reply to comment #43) > Comment on attachment 297957 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=297957&action=review > > > Source/WebKit2/UIProcess/API/gtk/WebKitNotificationProvider.h:45 > > + RefPtr<API::Dictionary> notificationPermissions(); > > I think this could be const. No, because the return value is non-const, because that's what the C API requires. I would make it const if we were returning a RefPtr<const API::Dictionary>, but we can't do that. > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:398 > > + * This signal is emitted when a new web process is about to be > > + * launched. It signals the most appropriate moment to use > > + * webkit_web_context_initialize_notification_permissions(). > > I would mention here that if you don't call > webkit_web_context_initialize_notification_permissions() again, the > permissions set previously will be used. That way apps can optimize and do > nothing if nothing changed in their side. And as I said in previous review, > I would start saying this signal is emitted when the web context needs to > initialize the permissions, and then you can say this happens when a new > process is about to be launched. OK. > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1257 > > +static void addAllowedOriginToMap(WebKitSecurityOrigin* origin, HashMap<String, RefPtr<API::Object>>* map) > > +{ > > + addOriginToMap(origin, map, true); > > +} > > + > > +static void addDisallowedOriginToMap(WebKitSecurityOrigin* origin, HashMap<String, RefPtr<API::Object>>* map) > > +{ > > + addOriginToMap(origin, map, false); > > +} > > These can be lambdas Think I tried that first. I'll try harder then. > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1283 > > +void webkit_web_context_initialize_notification_permissions(WebKitWebContext* context, GList* allowed_origins, GList* disallowed_origins) > > allowed_origins -> allowedOrigins > disallowed_origins -> disallowedOrigins Oops, surprised style checker did not complain. > > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:1287 > > + g_list_foreach(allowed_origins, (GFunc)addAllowedOriginToMap, &map); > > + g_list_foreach(disallowed_origins, (GFunc)addDisallowedOriginToMap, &map); > > Do not use C style casts here. You can use lambdas instead and cast the > userData in the body. > > g_list_foreach(allowedOrigins, [](gpointer data, gpointer userData) { > addOriginToMap(static_cast<WebKitSecurityOrigin*>(origin), > static_cast<HashMap<String, RefPtr<API::Object>>*>(map), true); > }, &map); Much nicer. > > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:848 > > + GList* allowedOrigins = nullptr; > > GList* allowedOrigins = g_list_prepend(nullptr, > webkit_security_origin_new_for_uri()); OK. > > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:849 > > + allowedOrigins = g_list_append(allowedOrigins, webkit_security_origin_new_for_uri(gServer->securityOrigin().data())); > > Why do you need gServer->securityOrigin()? You can pass the base uri and > webkit_security_origin_new_for_uri will do the magic Oops, yes, I wrote this before you suggested I add WebKitSecurityOrigin. > > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:851 > > + g_list_free_full(allowedOrigins, (GDestroyNotify)webkit_security_origin_unref); > > Do not use C style casts OK > > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:856 > > + GList* disallowedOrigins = nullptr; > > GList* disallowedOrigins = g_list_prepend(nullptr, > webkit_security_origin_new_for_uri()); OK > > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:857 > > + disallowedOrigins = g_list_append(disallowedOrigins, webkit_security_origin_new_for_uri(gServer->securityOrigin().data())); > > Ditto. OK > > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:859 > > + g_list_free_full(disallowedOrigins, (GDestroyNotify)webkit_security_origin_unref); > > Do not use C style casts OK > > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitWebView.cpp:873 > > + static const char* title = "This is a notification"; > > + static const char* body = "This is the body."; > > + test->requestNotificationAndWaitUntilShown(title, body); > > I guess we can probably pass the string literals directly, we don't really > need the variables, no? We could, yes. > > Tools/TestWebKitAPI/gtk/WebKit2Gtk/WebKitTestServer.cpp:76 > > + // The security origin is the base URI minus the trailing slash. > > + GUniquePtr<gchar> uriString(soup_uri_to_string(m_baseURI, FALSE)); > > + uriString.get()[strlen(uriString.get()) - 1] = '\0'; > > + return uriString.get(); > > Why are we reinventing the security origin here? I think we can either > remove this and pass the base uri to webkit_security_origin_new_for_uri(), > or make this return a WebKitSecurityOrigin and simply call > webkit_security_origin_new_for_uri() with the base uri. Indeed. 1265665 45 mcatanzaro 2017-01-10 19:57:17 -0800 Committed r210574: <http://trac.webkit.org/changeset/210574> 295281 2016-11-20 16:18:22 -0800 2016-11-25 14:06:06 -0800 Patch bug-163366-20161120181812.patch text/plain 22850 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjA4OTI3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggMzBlYTg0NTEwOGI4MjFh MjVlOWNjZWM3OWM4OTQ2OGM4ZmRlNzM5Zi4uMTEwOWMxZThmMjdkNWVhNTllYzExMTVhNTA0YzYw MzAzNjBlY2U2MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDE2LTExLTIwICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBO byB3YXkgZm9yIGFwcGxpY2F0aW9ucyB0byBzZXQgbm90aWZpY2F0aW9uIHBlcm1pc3Npb25zIHdp dGhvdXQgd2FpdGluZyBmb3IgcGVybWlzc2lvbiByZXF1ZXN0CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjMzNjYKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdE5v dGlmaWNhdGlvblByb3ZpZGVyLmNwcDoKKyAgICAgICAgKG5vdGlmaWNhdGlvblBlcm1pc3Npb25z Q2FsbGJhY2spOgorICAgICAgICAoV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI6OldlYktpdE5v dGlmaWNhdGlvblByb3ZpZGVyKToKKyAgICAgICAgKFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVy OjpzZXROb3RpZmljYXRpb25QZXJtaXNzaW9ucyk6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuaDoKKyAgICAgICAgKFdlYktpdDo6V2ViS2l0 Tm90aWZpY2F0aW9uUHJvdmlkZXI6Om5vdGlmaWNhdGlvblBlcm1pc3Npb25zKToKKyAgICAgICAg KiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcDoKKyAgICAgICAgKGFkZFRv UGVybWlzc2lvbk1hcCk6CisgICAgICAgICh3ZWJraXRfd2ViX2NvbnRleHRfc2V0X2luaXRpYWxf bm90aWZpY2F0aW9uX3Blcm1pc3Npb25zKToKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRXZWJDb250ZXh0Lmg6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJr aXQyZ3RrLTQuMC1zZWN0aW9ucy50eHQ6CisKIDIwMTYtMTEtMTkgIFNpbW9uIEZyYXNlciAgPHNp bW9uLmZyYXNlckBhcHBsZS5jb20+CiAKICAgICAgICAgW2lPUyBXSzJdIFdoZW4gem9vbWVkIGlu IGFuZCBwYW5uaW5nIG9uIHBhZ2VzIHdpdGggZml4ZWQgYmFycywgcGFydHMgb2YgdGhlIGJhcnMg YXJlIHNvbWV0aW1lcyBtaXNzaW5nCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5jcHAgYi9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5jcHAKaW5kZXgg NjIwNzUwYTQ0NzAzZTZlYWEwZjU2Njg2NGJlNzExMGQ3M2UyOWVmMi4uOTgxM2MzN2JhY2FkNmJh YjRjOGJiMjUyZWIyZmRhOGJkYmQwN2RmNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0FQSS9ndGsvV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyLmNw cApAQCAtMjgsNiArMjgsNyBAQAogI2luY2x1ZGUgIldlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVy LmgiCiAKICNpbmNsdWRlICJBUElBcnJheS5oIgorI2luY2x1ZGUgIkFQSURpY3Rpb25hcnkuaCIK ICNpbmNsdWRlICJXS05vdGlmaWNhdGlvbk1hbmFnZXIuaCIKICNpbmNsdWRlICJXZWJLaXROb3Rp ZmljYXRpb25Qcml2YXRlLmgiCiAjaW5jbHVkZSAiV2ViS2l0V2ViVmlld1ByaXZhdGUuaCIKQEAg LTUyLDYgKzUzLDExIEBAIHN0YXRpYyB2b2lkIGNhbmNlbENhbGxiYWNrKFdLTm90aWZpY2F0aW9u UmVmIG5vdGlmaWNhdGlvbiwgY29uc3Qgdm9pZCogY2xpZW50SW5mCiAgICAgdG9Ob3RpZmljYXRp b25Qcm92aWRlcihjbGllbnRJbmZvKS0+Y2FuY2VsKCp0b0ltcGwobm90aWZpY2F0aW9uKSk7CiB9 CiAKK3N0YXRpYyBXS0RpY3Rpb25hcnlSZWYgbm90aWZpY2F0aW9uUGVybWlzc2lvbnNDYWxsYmFj ayhjb25zdCB2b2lkKiBjbGllbnRJbmZvKQoreworICAgIHJldHVybiB0b0FQSSh0b05vdGlmaWNh dGlvblByb3ZpZGVyKGNsaWVudEluZm8pLT5ub3RpZmljYXRpb25QZXJtaXNzaW9ucygpLmxlYWtS ZWYoKSk7Cit9CisKIHN0YXRpYyB2b2lkIGNsZWFyTm90aWZpY2F0aW9uc0NhbGxiYWNrKFdLQXJy YXlSZWYgbm90aWZpY2F0aW9uSURzLCBjb25zdCB2b2lkKiBjbGllbnRJbmZvKQogewogICAgIHRv Tm90aWZpY2F0aW9uUHJvdmlkZXIoY2xpZW50SW5mbyktPmNsZWFyTm90aWZpY2F0aW9ucyh0b0lt cGwobm90aWZpY2F0aW9uSURzKSk7CkBAIC04MSw3ICs4Nyw3IEBAIFdlYktpdE5vdGlmaWNhdGlv blByb3ZpZGVyOjpXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcihXZWJOb3RpZmljYXRpb25NYW5h Z2VyUHJvCiAgICAgICAgIDAsIC8vIGRpZERlc3Ryb3lOb3RpZmljYXRpb25DYWxsYmFjaywKICAg ICAgICAgMCwgLy8gYWRkTm90aWZpY2F0aW9uTWFuYWdlckNhbGxiYWNrLAogICAgICAgICAwLCAv LyByZW1vdmVOb3RpZmljYXRpb25NYW5hZ2VyQ2FsbGJhY2ssCi0gICAgICAgIDAsIC8vIG5vdGlm aWNhdGlvblBlcm1pc3Npb25zQ2FsbGJhY2ssCisgICAgICAgIG5vdGlmaWNhdGlvblBlcm1pc3Np b25zQ2FsbGJhY2ssCiAgICAgICAgIGNsZWFyTm90aWZpY2F0aW9uc0NhbGxiYWNrLAogICAgIH07 CiAKQEAgLTEzMywzICsxMzksOCBAQCB2b2lkIFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyOjpj bGVhck5vdGlmaWNhdGlvbnMoY29uc3QgQVBJOjpBcnJheSogbm90aWZpY2F0aQogICAgIGZvciAo Y29uc3QgYXV0byYgaXRlbSA6IG5vdGlmaWNhdGlvbklEcy0+ZWxlbWVudHNPZlR5cGU8QVBJOjpV SW50NjQ+KCkpCiAgICAgICAgIGNhbmNlbE5vdGlmaWNhdGlvbkJ5SUQoaXRlbS0+dmFsdWUoKSk7 CiB9CisKK3ZvaWQgV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI6OnNldE5vdGlmaWNhdGlvblBl cm1pc3Npb25zKEhhc2hNYXA8U3RyaW5nLCBSZWZQdHI8QVBJOjpPYmplY3Q+PiYmIHBlcm1pc3Np b25zTWFwKQoreworICAgIG1fbm90aWZpY2F0aW9uUGVybWlzc2lvbnMgPSBBUEk6OkRpY3Rpb25h cnk6OmNyZWF0ZShwZXJtaXNzaW9uc01hcCk7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5oIGIvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuaApp bmRleCBlMDlkMmMwNDM1NTAzNmFkYzNjZjkzNTIxOWZiMDBlMjliZjYyMzMxLi45MTM4MTFjZjI1 YTMwNTllNzc0YmUwN2JiMjE4ZDRlNmRiZDQxODE4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5oCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVy LmgKQEAgLTQxLDYgKzQxLDkgQEAgcHVibGljOgogICAgIHZvaWQgY2FuY2VsKGNvbnN0IFdlYk5v dGlmaWNhdGlvbiYpOwogICAgIHZvaWQgY2xlYXJOb3RpZmljYXRpb25zKGNvbnN0IEFQSTo6QXJy YXkqKTsKIAorICAgIFJlZlB0cjxBUEk6OkRpY3Rpb25hcnk+IG5vdGlmaWNhdGlvblBlcm1pc3Np b25zKCkgeyByZXR1cm4gbV9ub3RpZmljYXRpb25QZXJtaXNzaW9uczsgfQorICAgIHZvaWQgc2V0 Tm90aWZpY2F0aW9uUGVybWlzc2lvbnMoSGFzaE1hcDxTdHJpbmcsIFJlZlB0cjxBUEk6Ok9iamVj dD4+JiYpOworCiBwcml2YXRlOgogICAgIFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyKFdlYk5v dGlmaWNhdGlvbk1hbmFnZXJQcm94eSopOwogCkBAIC00OCw2ICs1MSw3IEBAIHByaXZhdGU6CiAg ICAgc3RhdGljIHZvaWQgbm90aWZpY2F0aW9uQ2xvc2VDYWxsYmFjayhXZWJLaXROb3RpZmljYXRp b24qLCBXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlciopOwogICAgIHN0YXRpYyB2b2lkIG5vdGlm aWNhdGlvbkNsaWNrZWRDYWxsYmFjayhXZWJLaXROb3RpZmljYXRpb24qLCBXZWJLaXROb3RpZmlj YXRpb25Qcm92aWRlciopOwogCisgICAgUmVmUHRyPEFQSTo6RGljdGlvbmFyeT4gbV9ub3RpZmlj YXRpb25QZXJtaXNzaW9ucyB7IG51bGxwdHIgfTsKICAgICBSZWZQdHI8V2ViTm90aWZpY2F0aW9u TWFuYWdlclByb3h5PiBtX25vdGlmaWNhdGlvbk1hbmFnZXI7CiAgICAgSGFzaE1hcDx1aW50NjRf dCwgR1JlZlB0cjxXZWJLaXROb3RpZmljYXRpb24+PiBtX25vdGlmaWNhdGlvbnM7CiB9OwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4 dC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0 LmNwcAppbmRleCA3MjUzNTU5NjA3NzI3YmYyNzhhY2NkY2JjMzdkNDQ0NjE0ZDM0MGY2Li5hYmQ4 NzAxY2EwMjY0MjdlYWRkYjMzODY4MjhiNWNlOTllOGYzZjJmIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcAorKysgYi9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcApAQCAtMTIy NCw2ICsxMjI0LDQ2IEBAIGd1aW50IHdlYmtpdF93ZWJfY29udGV4dF9nZXRfd2ViX3Byb2Nlc3Nf Y291bnRfbGltaXQoV2ViS2l0V2ViQ29udGV4dCogY29udGV4dCkKICAgICByZXR1cm4gY29udGV4 dC0+cHJpdi0+cHJvY2Vzc0NvdW50TGltaXQ7CiB9CiAKK3N0YXRpYyB2b2lkIGFkZFRvUGVybWlz c2lvbk1hcChncG9pbnRlciBrZXksIGdwb2ludGVyIHZhbHVlLCBncG9pbnRlciB1c2VyRGF0YSkK K3sKKyAgICBhdXRvIGRvbWFpbiA9IHN0YXRpY19jYXN0PGNvbnN0IGNoYXIqPihrZXkpOworICAg IGJvb2wgcGVybWlzc2lvbiA9IEdQT0lOVEVSX1RPX0lOVCh2YWx1ZSk7CisgICAgYXV0byBtYXAg PSBzdGF0aWNfY2FzdDxIYXNoTWFwPFN0cmluZywgUmVmUHRyPEFQSTo6T2JqZWN0Pj4qPih1c2Vy RGF0YSk7CisgICAgbWFwLT5zZXQoU3RyaW5nOjpmcm9tVVRGOChkb21haW4pLCBBUEk6OkJvb2xl YW46OmNyZWF0ZShwZXJtaXNzaW9uKSk7Cit9CisKKy8qKgorICogd2Via2l0X3dlYl9jb250ZXh0 X3NldF9pbml0aWFsX25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uczoKKyAqIEBjb250ZXh0OiB0aGUg I1dlYktpdFdlYkNvbnRleHQKKyAqIEBwZXJtaXNzaW9uczogYSAjR0hhc2hUYWJsZSBvZiBzdHJp bmdzIHRvIGJvb2xlYW5zCisgKgorICogU2V0cyBpbml0aWFsIGRlc2t0b3Agbm90aWZpY2F0aW9u IHBlcm1pc3Npb25zIGZvciB0aGUgQGNvbnRleHQuCisgKiBAcGVybWlzc2lvbnMgbXVzdCBiZSBh ICNHSGFzaFRhYmxlIG9mIHN0cmluZ3MgY29udGFpbmluZyBzZWN1cml0eQorICogb3JpZ2lucyAo cHJvdG9jb2wsIGhvc3QsIGFuZCBvcHRpb25hbCBwb3J0LCBlLmcuCisgKiBodHRwOi8vd3d3LmV4 YW1wbGUuY29tIGJ1dCBub3QgaHR0cDovL3d3dy5leGFtcGxlLmNvbS8pIHRvIGJvb2xlYW4KKyAq IHZhbHVlcyAoc3RvcmVkIHVzaW5nIEdJTlRfVE9fUE9JTlRFUigpKS4gTm8KKyAqICNXZWJLaXRO b3RpZmljYXRpb25QZXJtaXNzaW9uUmVxdWVzdCB3aWxsIGV2ZXIgYmUgZ2VuZXJhdGVkIGZvcgor ICogZG9tYWlucyByZXByZXNlbnRlZCBpbiB0aGUgQHBlcm1pc3Npb25zLiBJZiB0aGUgYm9vbGVh biB2YWx1ZQorICogY29ycmVzcG9uZGluZyB0byB0aGUgZG9tYWluIGluIEBwZXJtaXNzaW9ucyBp cyAlVFJVRSwgdGhlbiB0aGUgZG9tYWluCisgKiB3aWxsIGFsd2F5cyBoYXZlIHBlcm1pc3Npb24g dG8gc2hvdyBkZXNrdG9wIG5vdGlmaWNhdGlvbnM7IGlmIGl0IGlzCisgKiAlRkFMU0UsIHRoZW4g aXQgd2lsbCBuZXZlciBoYXZlIHBlcm1pc3Npb24gdG8gZG8gc28uIFRoaXMgZnVuY3Rpb24KKyAq IGlzIG5lY2Vzc2FyeSBiZWNhdXNlIHNvbWUgd2VicGFnZXMgcHJvYWN0aXZlbHkgY2hlY2sgd2hl dGhlciB0aGV5CisgKiBoYXZlIHBlcm1pc3Npb24gdG8gZGlzcGxheSBub3RpZmljYXRpb25zIHdp dGhvdXQgZXZlciBjcmVhdGluZyBhCisgKiBwZXJtaXNzaW9uIHJlcXVlc3QuCisgKgorICogVGhp cyBmdW5jdGlvbiBvbmx5IGFmZmVjdHMgd2ViIHByb2Nlc3NlcyB0aGF0IGhhdmUgbm90IGFscmVh ZHkgYmVlbgorICogY3JlYXRlZCwgc28gaXQgc2hvdWxkIHVzdWFsbHkgYmUgY2FsbGVkIGJlZm9y ZSBjcmVhdGluZyB0aGUgZmlyc3QKKyAqICNXZWJLaXRXZWJWaWV3LgorICoKKyAqIFNpbmNlOiAy LjE2CisgKi8KK3ZvaWQgd2Via2l0X3dlYl9jb250ZXh0X3NldF9pbml0aWFsX25vdGlmaWNhdGlv bl9wZXJtaXNzaW9ucyhXZWJLaXRXZWJDb250ZXh0KiBjb250ZXh0LCBHSGFzaFRhYmxlKiBwZXJt aXNzaW9ucykKK3sKKyAgICBIYXNoTWFwPFN0cmluZywgUmVmUHRyPEFQSTo6T2JqZWN0Pj4gbWFw OworICAgIGdfaGFzaF90YWJsZV9mb3JlYWNoKHBlcm1pc3Npb25zLCBhZGRUb1Blcm1pc3Npb25N YXAsICZtYXApOworICAgIGNvbnRleHQtPnByaXYtPm5vdGlmaWNhdGlvblByb3ZpZGVyLT5zZXRO b3RpZmljYXRpb25QZXJtaXNzaW9ucyhXVEZNb3ZlKG1hcCkpOworfQorCiBXZWJLaXREb3dubG9h ZCogd2Via2l0V2ViQ29udGV4dEdldE9yQ3JlYXRlRG93bmxvYWQoRG93bmxvYWRQcm94eSogZG93 bmxvYWRQcm94eSkKIHsKICAgICBHUmVmUHRyPFdlYktpdERvd25sb2FkPiBkb3dubG9hZCA9IGRv d25sb2Fkc01hcCgpLmdldChkb3dubG9hZFByb3h5KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQuaCBiL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQuaAppbmRleCBjZDU1NDg2ZjRjMjMz OTVmMGU3N2JiODYyMzM3MGU3YzU3MGRlMWI3Li5jMjY0MjE5YzFiNzMxN2JjNTE4YzczY2IwNGMz ZDZkNTMyNjU2OTNiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0 ay9XZWJLaXRXZWJDb250ZXh0LmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0V2ViQ29udGV4dC5oCkBAIC0yNjQsNiArMjY0LDExIEBAIHdlYmtpdF93ZWJfY29u dGV4dF9zZXRfcHJvY2Vzc19tb2RlbCAgICAgICAgICAgICAgICAoV2ViS2l0V2ViQ29udGV4dAog V0VCS0lUX0FQSSBXZWJLaXRQcm9jZXNzTW9kZWwKIHdlYmtpdF93ZWJfY29udGV4dF9nZXRfcHJv Y2Vzc19tb2RlbCAgICAgICAgICAgICAgICAoV2ViS2l0V2ViQ29udGV4dCAgICAgICAgICAgICAg KmNvbnRleHQpOwogCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF93ZWJfY29udGV4dF9zZXRfaW5p dGlhbF9ub3RpZmljYXRpb25fcGVybWlzc2lvbnMKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAoV2ViS2l0V2ViQ29udGV4dCAgICAgICAgICAgICAg KmNvbnRleHQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIEdIYXNoVGFibGUgICAgICAgICAgICAgICAgICAgICpwZXJtaXNzaW9ucyk7CisKIEdf RU5EX0RFQ0xTCiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLTQuMC1zZWN0aW9ucy50eHQgYi9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstNC4wLXNlY3Rpb25zLnR4dAppbmRl eCAwMDJlZjMzYWE3OTJjMjVlYTY1M2IzMTY2NDE2MjJlMzQxODQwZGRjLi5jNWEyZGEyMmUwMzE3 Mzg3NWRhNDc4MWNjZDJiNDYzMTcwNGViM2E2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstNC4wLXNlY3Rpb25zLnR4dAorKysgYi9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstNC4wLXNlY3Rp b25zLnR4dApAQCAtNTksNiArNTksNyBAQCB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X2Rpc2tfY2Fj aGVfZGlyZWN0b3J5CiB3ZWJraXRfd2ViX2NvbnRleHRfYWxsb3dfdGxzX2NlcnRpZmljYXRlX2Zv cl9ob3N0CiB3ZWJraXRfd2ViX2NvbnRleHRfZ2V0X3Byb2Nlc3NfbW9kZWwKIHdlYmtpdF93ZWJf Y29udGV4dF9zZXRfcHJvY2Vzc19tb2RlbAord2Via2l0X3dlYl9jb250ZXh0X3NldF9pbml0aWFs X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9ucwogCiA8U1VCU0VDVElPTiBVUkkgU2NoZW1lPgogV2Vi S2l0VVJJU2NoZW1lUmVxdWVzdENhbGxiYWNrCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggMDhjMDg0NjgzZjUyZTljNmFkZDI1ZDM4ZjRjZGFhOGIy ZjBhZjU2OC4uZDliMTYxMTZhZWRhYzExZmI1ZTM1ZDlkOWJlMTY4M2UxMzc0ZDNjMCAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0 IEBACisyMDE2LTExLTIwICBNaWNoYWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNv bT4KKworICAgICAgICBbR1RLXSBObyB3YXkgZm9yIGFwcGxpY2F0aW9ucyB0byBzZXQgbm90aWZp Y2F0aW9uIHBlcm1pc3Npb25zIHdpdGhvdXQgd2FpdGluZyBmb3IgcGVybWlzc2lvbiByZXF1ZXN0 CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjMzNjYK KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFRlc3RX ZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9UZXN0V2ViS2l0V2ViVmlldy5jcHA6IEFkZCBuZXcg QVBJIHRlc3QuCisgICAgICAgICh0ZXN0V2ViVmlld05vdGlmaWNhdGlvbik6CisgICAgICAgICh0 ZXN0V2ViVmlld05vdGlmaWNhdGlvbkluaXRpYWxQZXJtaXNzaW9uKToKKyAgICAgICAgKGJlZm9y ZUFsbCk6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9UZXN0TWFpbi5o OiBBZGQgbWFjcm8gdG8gYWxsb3cgY3VzdG9tIHRlc3QgZml4dHVyZXMuCisgICAgICAgICogVGVz dFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJLaXRUZXN0U2VydmVyLmNwcDogQWRkIGhlbHBl ciB0byBnZXQgc2VjdXJpdHkgb3JpZ2luLgorICAgICAgICAoV2ViS2l0VGVzdFNlcnZlcjo6c2Vj dXJpdHlPcmlnaW4pOgorICAgICAgICAoV2ViS2l0VGVzdFNlcnZlcjo6Z2V0VVJJRm9yUGF0aCk6 IERyaXZlLWJ5OiBtYWRlIGl0IGNvbnN0LgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvZ3RrL1dl YktpdDJHdGsvV2ViS2l0VGVzdFNlcnZlci5oOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvZ3Rr L1dlYktpdDJHdGsvV2ViVmlld1Rlc3QuY3BwOiBBZGQgYWJpbGl0eSB0byBkZWZlciB3ZWIgdmll dyBjcmVhdGlvbi4KKyAgICAgICAgKFdlYlZpZXdUZXN0OjpXZWJWaWV3VGVzdCk6CisgICAgICAg IChXZWJWaWV3VGVzdDo6aW5pdGlhbGl6ZVdlYlZpZXcpOgorICAgICAgICAqIFRlc3RXZWJLaXRB UEkvZ3RrL1dlYktpdDJHdGsvV2ViVmlld1Rlc3QuaDoKKwogMjAxNi0xMS0xOCAgU2ltb24gRnJh c2VyICA8c2ltb24uZnJhc2VyQGFwcGxlLmNvbT4KIAogICAgICAgICBNYWtlIGl0IHBvc3NpYmxl IHRvIHRlc3Qgbm9uLXN0YWJsZS1zdGF0ZSBzY3JvbGxpbmcgb24gaU9TCmRpZmYgLS1naXQgYS9U b29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYktpdFdlYlZpZXcuY3Bw IGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RXZWJLaXRXZWJWaWV3 LmNwcAppbmRleCBmOGUzY2JmN2I3OWRlYWQ2ZjJkZmYzMzdiNGJhNDBmYWIyMGExOGZiLi44YzAz NGUwODYyMTMwYjRjMGJkMTE3YmQzMDY2MjFlZWJlY2ZmMjY3IDEwMDY0NAotLS0gYS9Ub29scy9U ZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYktpdFdlYlZpZXcuY3BwCisrKyBi L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9UZXN0V2ViS2l0V2ViVmlldy5j cHAKQEAgLTYzMiw3ICs2MzIsMTcgQEAgc3RhdGljIHZvaWQgdGVzdFdlYlZpZXdTbmFwc2hvdChT bmFwc2hvdFdlYlZpZXdUZXN0KiB0ZXN0LCBnY29uc3Rwb2ludGVyKQogCiBjbGFzcyBOb3RpZmlj YXRpb25XZWJWaWV3VGVzdDogcHVibGljIFdlYlZpZXdUZXN0IHsKIHB1YmxpYzoKLSAgICBNQUtF X0dMSUJfVEVTVF9GSVhUVVJFKE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0KTsKKyAgICBNQUtFX0dM SUJfVEVTVF9GSVhUVVJFX1dJVEhfU0VUVVBfVEVBUkRPV04oTm90aWZpY2F0aW9uV2ViVmlld1Rl c3QsIHNldHVwLCB0ZWFyZG93bik7CisKKyAgICBzdGF0aWMgdm9pZCBzZXR1cCgpCisgICAgewor ICAgICAgICBXZWJWaWV3VGVzdDo6c2hvdWxkSW5pdGlhbGl6ZVdlYlZpZXdJbkNvbnN0cnVjdG9y ID0gZmFsc2U7CisgICAgfQorCisgICAgc3RhdGljIHZvaWQgdGVhcmRvd24oKQorICAgIHsKKyAg ICAgICAgV2ViVmlld1Rlc3Q6OnNob3VsZEluaXRpYWxpemVXZWJWaWV3SW5Db25zdHJ1Y3RvciA9 IHRydWU7CisgICAgfQogCiAgICAgZW51bSBOb3RpZmljYXRpb25FdmVudCB7CiAgICAgICAgIE5v bmUsCkBAIC02NDcsNiArNjU3LDcgQEAgcHVibGljOgogICAgIHN0YXRpYyBnYm9vbGVhbiBwZXJt aXNzaW9uUmVxdWVzdENhbGxiYWNrKFdlYktpdFdlYlZpZXcqLCBXZWJLaXRQZXJtaXNzaW9uUmVx dWVzdCAqcmVxdWVzdCwgTm90aWZpY2F0aW9uV2ViVmlld1Rlc3QqIHRlc3QpCiAgICAgewogICAg ICAgICBnX2Fzc2VydChXRUJLSVRfSVNfTk9USUZJQ0FUSU9OX1BFUk1JU1NJT05fUkVRVUVTVChy ZXF1ZXN0KSk7CisgICAgICAgIGdfYXNzZXJ0KHRlc3QtPm1faXNFeHBlY3RpbmdQZXJtaXNzaW9u UmVxdWVzdCk7CiAgICAgICAgIHRlc3QtPmFzc2VydE9iamVjdElzRGVsZXRlZFdoZW5UZXN0Rmlu aXNoZXMoR19PQkpFQ1QocmVxdWVzdCkpOwogCiAgICAgICAgIHRlc3QtPm1fZXZlbnQgPSBQZXJt aXNzaW9uOwpAQCAtNjk4LDEwICs3MDksOSBAQCBwdWJsaWM6CiAgICAgICAgIGdfbWFpbl9sb29w X3F1aXQodGVzdC0+bV9tYWluTG9vcCk7CiAgICAgfQogCi0gICAgTm90aWZpY2F0aW9uV2ViVmll d1Rlc3QoKQotICAgICAgICA6IG1fbm90aWZpY2F0aW9uKG51bGxwdHIpCi0gICAgICAgICwgbV9l dmVudChOb25lKQorICAgIHZvaWQgaW5pdGlhbGl6ZSgpCiAgICAgeworICAgICAgICBpbml0aWFs aXplV2ViVmlldygpOwogICAgICAgICBnX3NpZ25hbF9jb25uZWN0KG1fd2ViVmlldywgInBlcm1p c3Npb24tcmVxdWVzdCIsIEdfQ0FMTEJBQ0socGVybWlzc2lvblJlcXVlc3RDYWxsYmFjayksIHRo aXMpOwogICAgICAgICBnX3NpZ25hbF9jb25uZWN0KG1fd2ViVmlldywgInNob3ctbm90aWZpY2F0 aW9uIiwgR19DQUxMQkFDSyhzaG93Tm90aWZpY2F0aW9uQ2FsbGJhY2spLCB0aGlzKTsKICAgICAg ICAgd2Via2l0X3VzZXJfY29udGVudF9tYW5hZ2VyX3JlZ2lzdGVyX3NjcmlwdF9tZXNzYWdlX2hh bmRsZXIobV91c2VyQ29udGVudE1hbmFnZXIuZ2V0KCksICJub3RpZmljYXRpb25zIik7CkBAIC03 MTUsOSArNzI1LDM3IEBAIHB1YmxpYzoKICAgICAgICAgd2Via2l0X3VzZXJfY29udGVudF9tYW5h Z2VyX3VucmVnaXN0ZXJfc2NyaXB0X21lc3NhZ2VfaGFuZGxlcihtX3VzZXJDb250ZW50TWFuYWdl ci5nZXQoKSwgIm5vdGlmaWNhdGlvbnMiKTsKICAgICB9CiAKKyAgICBzdGF0aWMgdm9pZCBoYXNQ ZXJtaXNzaW9uQ2FsbGJhY2soR09iamVjdCogb2JqZWN0LCBHQXN5bmNSZXN1bHQqIHJlc3VsdCwg Z3BvaW50ZXIgdXNlckRhdGEpCisgICAgeworICAgICAgICBhdXRvIHRlc3QgPSBzdGF0aWNfY2Fz dDxOb3RpZmljYXRpb25XZWJWaWV3VGVzdCo+KHVzZXJEYXRhKTsKKyAgICAgICAgR0Vycm9yKiBl cnJvciA9IG51bGxwdHI7CisgICAgICAgIFdlYktpdEphdmFzY3JpcHRSZXN1bHQqIGpzUmVzdWx0 ID0gd2Via2l0X3dlYl92aWV3X3J1bl9qYXZhc2NyaXB0X2ZpbmlzaCh0ZXN0LT5tX3dlYlZpZXcs IHJlc3VsdCwgJmVycm9yKTsKKyAgICAgICAgZ19hc3NlcnQoIWVycm9yKTsKKworICAgICAgICBK U0dsb2JhbENvbnRleHRSZWYgY29udGV4dCA9IHdlYmtpdF9qYXZhc2NyaXB0X3Jlc3VsdF9nZXRf Z2xvYmFsX2NvbnRleHQoanNSZXN1bHQpOworICAgICAgICBKU1ZhbHVlUmVmIHZhbHVlID0gd2Vi a2l0X2phdmFzY3JpcHRfcmVzdWx0X2dldF92YWx1ZShqc1Jlc3VsdCk7CisgICAgICAgIGdfYXNz ZXJ0KEpTVmFsdWVJc1N0cmluZyhjb250ZXh0LCB2YWx1ZSkpOworCisgICAgICAgIC8vIFBvc3Np YmxlIHZhbHVlczogImRlbmllZCIsICJncmFudGVkIiwgImRlZmF1bHQiIChpbXBsaWNpdCBkZW55 KQorICAgICAgICBKU1N0cmluZ1JlZiBqc1N0cmluZ1ZhbHVlID0gSlNWYWx1ZVRvU3RyaW5nQ29w eShjb250ZXh0LCB2YWx1ZSwgbnVsbHB0cik7CisgICAgICAgIHRlc3QtPm1faGFzUGVybWlzc2lv biA9IEpTU3RyaW5nSXNFcXVhbFRvVVRGOENTdHJpbmcoanNTdHJpbmdWYWx1ZSwgImdyYW50ZWQi KTsKKyAgICAgICAgSlNTdHJpbmdSZWxlYXNlKGpzU3RyaW5nVmFsdWUpOworICAgICAgICB3ZWJr aXRfamF2YXNjcmlwdF9yZXN1bHRfdW5yZWYoanNSZXN1bHQpOworCisgICAgICAgIGdfbWFpbl9s b29wX3F1aXQodGVzdC0+bV9tYWluTG9vcCk7CisgICAgfQorCisgICAgYm9vbCBoYXNQZXJtaXNz aW9uKCkKKyAgICB7CisgICAgICAgIHdlYmtpdF93ZWJfdmlld19ydW5famF2YXNjcmlwdChtX3dl YlZpZXcsICJOb3RpZmljYXRpb24ucGVybWlzc2lvbjsiLCBudWxscHRyLCBoYXNQZXJtaXNzaW9u Q2FsbGJhY2ssIHRoaXMpOworICAgICAgICBnX21haW5fbG9vcF9ydW4obV9tYWluTG9vcCk7Cisg ICAgICAgIHJldHVybiBtX2hhc1Blcm1pc3Npb247CisgICAgfQorCiAgICB2b2lkIHJlcXVlc3RQ ZXJtaXNzaW9uQW5kV2FpdFVudGlsR2l2ZW4oKQogICAgIHsKICAgICAgICAgbV9ldmVudCA9IE5v bmU7CisgICAgICAgIG1faXNFeHBlY3RpbmdQZXJtaXNzaW9uUmVxdWVzdCA9IHRydWU7CiAgICAg ICAgIHdlYmtpdF93ZWJfdmlld19ydW5famF2YXNjcmlwdChtX3dlYlZpZXcsICJOb3RpZmljYXRp b24ucmVxdWVzdFBlcm1pc3Npb24oKTsiLCBudWxscHRyLCBudWxscHRyLCBudWxscHRyKTsKICAg ICAgICAgZ19tYWluX2xvb3BfcnVuKG1fbWFpbkxvb3ApOwogICAgIH0KQEAgLTc1OCwxOCArNzk2 LDI0IEBAIHB1YmxpYzoKICAgICAgICAgZ19tYWluX2xvb3BfcnVuKG1fbWFpbkxvb3ApOwogICAg IH0KIAotICAgIE5vdGlmaWNhdGlvbkV2ZW50IG1fZXZlbnQ7Ci0gICAgV2ViS2l0Tm90aWZpY2F0 aW9uKiBtX25vdGlmaWNhdGlvbjsKKyAgICBOb3RpZmljYXRpb25FdmVudCBtX2V2ZW50IHsgTm9u ZSB9OworICAgIFdlYktpdE5vdGlmaWNhdGlvbiogbV9ub3RpZmljYXRpb24geyBudWxscHRyIH07 CisgICAgYm9vbCBtX2lzRXhwZWN0aW5nUGVybWlzc2lvblJlcXVlc3QgeyBmYWxzZSB9OworICAg IGJvb2wgbV9oYXNQZXJtaXNzaW9uIHsgZmFsc2UgfTsKIH07CiAKIHN0YXRpYyB2b2lkIHRlc3RX ZWJWaWV3Tm90aWZpY2F0aW9uKE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0KiB0ZXN0LCBnY29uc3Rw b2ludGVyKQogeworICAgIHRlc3QtPmluaXRpYWxpemUoKTsKKwogICAgIC8vIE5vdGlmaWNhdGlv bnMgZG9uJ3Qgd29yayB3aXRoIGxvY2FsIG9yIHNwZWNpYWwgc2NoZW1lcy4KICAgICB0ZXN0LT5s b2FkVVJJKGdTZXJ2ZXItPmdldFVSSUZvclBhdGgoIi8iKS5kYXRhKCkpOwogICAgIHRlc3QtPndh aXRVbnRpbExvYWRGaW5pc2hlZCgpOworICAgIGdfYXNzZXJ0KCF0ZXN0LT5oYXNQZXJtaXNzaW9u KCkpOwogCiAgICAgdGVzdC0+cmVxdWVzdFBlcm1pc3Npb25BbmRXYWl0VW50aWxHaXZlbigpOwog ICAgIGdfYXNzZXJ0KHRlc3QtPm1fZXZlbnQgPT0gTm90aWZpY2F0aW9uV2ViVmlld1Rlc3Q6OlBl cm1pc3Npb24pOworICAgIGdfYXNzZXJ0KHRlc3QtPmhhc1Blcm1pc3Npb24oKSk7CiAKICAgICBz dGF0aWMgY29uc3QgY2hhciogdGl0bGUgPSAiVGhpcyBpcyBhIG5vdGlmaWNhdGlvbiI7CiAgICAg c3RhdGljIGNvbnN0IGNoYXIqIGJvZHkgPSAiVGhpcyBpcyB0aGUgYm9keS4iOwpAQCAtODAwLDYg Kzg0NCwyNCBAQCBzdGF0aWMgdm9pZCB0ZXN0V2ViVmlld05vdGlmaWNhdGlvbihOb3RpZmljYXRp b25XZWJWaWV3VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRlcgogICAgIGdfYXNzZXJ0KHRlc3QtPm1f ZXZlbnQgPT0gTm90aWZpY2F0aW9uV2ViVmlld1Rlc3Q6OkNsb3NlZCk7CiB9CiAKK3N0YXRpYyB2 b2lkIHRlc3RXZWJWaWV3Tm90aWZpY2F0aW9uSW5pdGlhbFBlcm1pc3Npb24oTm90aWZpY2F0aW9u V2ViVmlld1Rlc3QqIHRlc3QsIGdjb25zdHBvaW50ZXIpCit7CisgICAgYXV0byB0YWJsZSA9IGFk b3B0R1JlZihnX2hhc2hfdGFibGVfbmV3X2Z1bGwoZ19zdHJfaGFzaCwgZ19zdHJfZXF1YWwsIGdf ZnJlZSwgbnVsbHB0cikpOworICAgIGdfaGFzaF90YWJsZV9pbnNlcnQodGFibGUuZ2V0KCksIGdf c3RyZHVwKGdTZXJ2ZXItPnNlY3VyaXR5T3JpZ2luKCkuZGF0YSgpKSwgR0lOVF9UT19QT0lOVEVS KFRSVUUpKTsKKworICAgIHdlYmtpdF93ZWJfY29udGV4dF9zZXRfaW5pdGlhbF9ub3RpZmljYXRp b25fcGVybWlzc2lvbnModGVzdC0+bV93ZWJDb250ZXh0LmdldCgpLCB0YWJsZS5nZXQoKSk7IAor ICAgIHRlc3QtPmluaXRpYWxpemUoKTsKKworICAgIHRlc3QtPmxvYWRVUkkoZ1NlcnZlci0+Z2V0 VVJJRm9yUGF0aCgiLyIpLmRhdGEoKSk7CisgICAgdGVzdC0+d2FpdFVudGlsTG9hZEZpbmlzaGVk KCk7CisgICAgZ19hc3NlcnQodGVzdC0+aGFzUGVybWlzc2lvbigpKTsKKworICAgIHN0YXRpYyBj b25zdCBjaGFyKiB0aXRsZSA9ICJUaGlzIGlzIGEgbm90aWZpY2F0aW9uIjsKKyAgICBzdGF0aWMg Y29uc3QgY2hhciogYm9keSA9ICJUaGlzIGlzIHRoZSBib2R5LiI7CisgICAgdGVzdC0+cmVxdWVz dE5vdGlmaWNhdGlvbkFuZFdhaXRVbnRpbFNob3duKHRpdGxlLCBib2R5KTsKKyAgICBnX2Fzc2Vy dCh0ZXN0LT5tX2V2ZW50ID09IE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0OjpTaG93bik7Cit9CisK IHN0YXRpYyB2b2lkIHRlc3RXZWJWaWV3SXNQbGF5aW5nQXVkaW8oSXNQbGF5aW5nQXVkaW9XZWJW aWV3VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRlcikKIHsKICAgICAvLyBUaGUgd2ViIHZpZXcgbXVz dCBiZSByZWFsaXplZCBmb3IgdGhlIHZpZGVvIHRvIHN0YXJ0IHBsYXliYWNrIGFuZApAQCAtODk3 LDYgKzk1OSw3IEBAIHZvaWQgYmVmb3JlQWxsKCkKICAgICBTbmFwc2hvdFdlYlZpZXdUZXN0Ojph ZGQoIldlYktpdFdlYlZpZXciLCAic25hcHNob3QiLCB0ZXN0V2ViVmlld1NuYXBzaG90KTsKICAg ICBXZWJWaWV3VGVzdDo6YWRkKCJXZWJLaXRXZWJWaWV3IiwgInBhZ2UtdmlzaWJpbGl0eSIsIHRl c3RXZWJWaWV3UGFnZVZpc2liaWxpdHkpOwogICAgIE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0Ojph ZGQoIldlYktpdFdlYlZpZXciLCAibm90aWZpY2F0aW9uIiwgdGVzdFdlYlZpZXdOb3RpZmljYXRp b24pOworICAgIE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAi bm90aWZpY2F0aW9uLWluaXRpYWwtcGVybWlzc2lvbiIsIHRlc3RXZWJWaWV3Tm90aWZpY2F0aW9u SW5pdGlhbFBlcm1pc3Npb24pOwogICAgIElzUGxheWluZ0F1ZGlvV2ViVmlld1Rlc3Q6OmFkZCgi V2ViS2l0V2ViVmlldyIsICJpcy1wbGF5aW5nLWF1ZGlvIiwgdGVzdFdlYlZpZXdJc1BsYXlpbmdB dWRpbyk7CiAgICAgV2ViVmlld1Rlc3Q6OmFkZCgiV2ViS2l0V2ViVmlldyIsICJiYWNrZ3JvdW5k LWNvbG9yIiwgdGVzdFdlYlZpZXdCYWNrZ3JvdW5kQ29sb3IpOwogICAgIFdlYlZpZXdUZXN0Ojph ZGQoIldlYktpdFdlYlZpZXciLCAicHJlZmVycmVkLXNpemUiLCB0ZXN0V2ViVmlld1ByZWZlcnJl ZFNpemUpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9U ZXN0TWFpbi5oIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9UZXN0TWFpbi5o CmluZGV4IDYwNTRmZTA5ZDQ3OWE4ODA2MDlmMzY1MjI1ZDg5M2M4NjI2ZWM5YzQuLmY2OGFmMmE5 NjUxNjJiM2QyZWZiOWJkZTk1NzgwMDFhNGI1NWFjZmYgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvVGVzdE1haW4uaAorKysgYi9Ub29scy9UZXN0V2ViS2l0 QVBJL2d0ay9XZWJLaXQyR3RrL1Rlc3RNYWluLmgKQEAgLTQzLDYgKzQzLDI1IEBACiAgICAgICAg IGdfdGVzdF9hZGQodGVzdFBhdGguZ2V0KCksIENsYXNzTmFtZSwgMCwgQ2xhc3NOYW1lOjpzZXRV cCwgdGVzdEZ1bmMsIENsYXNzTmFtZTo6dGVhckRvd24pOyBcCiAgICAgfQogCisjZGVmaW5lIE1B S0VfR0xJQl9URVNUX0ZJWFRVUkVfV0lUSF9TRVRVUF9URUFSRE9XTihDbGFzc05hbWUsIHNldHVw LCB0ZWFyZG93bikgXAorICAgIHN0YXRpYyB2b2lkIHNldFVwKENsYXNzTmFtZSogZml4dHVyZSwg Z2NvbnN0cG9pbnRlciBkYXRhKSBcCisgICAgeyBcCisgICAgICAgIGlmIChzZXR1cCkgXAorICAg ICAgICAgICAgc2V0dXAoKTsgXAorICAgICAgICBuZXcgKGZpeHR1cmUpIENsYXNzTmFtZTsgXAor ICAgIH0gXAorICAgIHN0YXRpYyB2b2lkIHRlYXJEb3duKENsYXNzTmFtZSogZml4dHVyZSwgZ2Nv bnN0cG9pbnRlciBkYXRhKSBcCisgICAgeyBcCisgICAgICAgIGZpeHR1cmUtPn5DbGFzc05hbWUo KTsgXAorICAgICAgICBpZiAodGVhcmRvd24pIFwKKyAgICAgICAgICAgIHRlYXJkb3duKCk7IFwK KyAgICB9IFwKKyAgICBzdGF0aWMgdm9pZCBhZGQoY29uc3QgY2hhciogc3VpdGVOYW1lLCBjb25z dCBjaGFyKiB0ZXN0TmFtZSwgdm9pZCAoKnRlc3RGdW5jKShDbGFzc05hbWUqLCBjb25zdCB2b2lk KikpIFwKKyAgICB7IFwKKyAgICAgICAgR1VuaXF1ZVB0cjxnY2hhcj4gdGVzdFBhdGgoZ19zdHJk dXBfcHJpbnRmKCIvd2Via2l0Mi8lcy8lcyIsIHN1aXRlTmFtZSwgdGVzdE5hbWUpKTsgXAorICAg ICAgICBnX3Rlc3RfYWRkKHRlc3RQYXRoLmdldCgpLCBDbGFzc05hbWUsIDAsIENsYXNzTmFtZTo6 c2V0VXAsIHRlc3RGdW5jLCBDbGFzc05hbWU6OnRlYXJEb3duKTsgXAorICAgIH0KKwogI2RlZmlu ZSBBU1NFUlRfQ01QX0NTVFJJTkcoczEsIGNtcCwgczIpIFwKICAgICBkbyB7ICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCiAg ICAgICAgIENTdHJpbmcgX19zMSA9IChzMSk7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgXApkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2Vi S2l0Mkd0ay9XZWJLaXRUZXN0U2VydmVyLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dl YktpdDJHdGsvV2ViS2l0VGVzdFNlcnZlci5jcHAKaW5kZXggZGU5NDY2YzM5ZDcxY2ZjMmFiZjQ0 OWZjZmRlMzg5YjU0NDlkZjMyNy4uYzQ5MjlkZThhMDhlODVlZmFkYWM2Y2Q0OWNiMTRkMDQxNTY3 NTI0YiAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJL aXRUZXN0U2VydmVyLmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3Rr L1dlYktpdFRlc3RTZXJ2ZXIuY3BwCkBAIC02OCw3ICs2OCwxNSBAQCB2b2lkIFdlYktpdFRlc3RT ZXJ2ZXI6OnJ1bihTb3VwU2VydmVyQ2FsbGJhY2sgc2VydmVyQ2FsbGJhY2spCiAgICAgfQogfQog Ci1DU3RyaW5nIFdlYktpdFRlc3RTZXJ2ZXI6OmdldFVSSUZvclBhdGgoY29uc3QgY2hhciogcGF0 aCkKK0NTdHJpbmcgV2ViS2l0VGVzdFNlcnZlcjo6c2VjdXJpdHlPcmlnaW4oKSBjb25zdAorewor ICAgIC8vIFRoZSBzZWN1cml0eSBvcmlnaW4gaXMgdGhlIGJhc2UgVVJJIG1pbnVzIHRoZSB0cmFp bGluZyBzbGFzaC4KKyAgICBHVW5pcXVlUHRyPGdjaGFyPiB1cmlTdHJpbmcoc291cF91cmlfdG9f c3RyaW5nKG1fYmFzZVVSSSwgRkFMU0UpKTsKKyAgICB1cmlTdHJpbmcuZ2V0KClbc3RybGVuKHVy aVN0cmluZy5nZXQoKSkgLSAxXSA9ICdcMCc7CisgICAgcmV0dXJuIHVyaVN0cmluZy5nZXQoKTsK K30KKworQ1N0cmluZyBXZWJLaXRUZXN0U2VydmVyOjpnZXRVUklGb3JQYXRoKGNvbnN0IGNoYXIq IHBhdGgpIGNvbnN0CiB7CiAgICAgU291cFVSSSogdXJpID0gc291cF91cmlfbmV3X3dpdGhfYmFz ZShtX2Jhc2VVUkksIHBhdGgpOwogICAgIEdVbmlxdWVQdHI8Z2NoYXI+IHVyaVN0cmluZyhzb3Vw X3VyaV90b19zdHJpbmcodXJpLCBGQUxTRSkpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktp dEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJLaXRUZXN0U2VydmVyLmggYi9Ub29scy9UZXN0V2ViS2l0 QVBJL2d0ay9XZWJLaXQyR3RrL1dlYktpdFRlc3RTZXJ2ZXIuaAppbmRleCA1OGYwMTlmYWI4NjAx YzJkMTMxNDZhY2M1NGZjNzg4ZGNlMjljNjhhLi5kMzgyMDk1YjI2ZjNiMjM3OTkzZTJhOTIyZTNj MmFkYzNhNGE3NWJhIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQy R3RrL1dlYktpdFRlc3RTZXJ2ZXIuaAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJL aXQyR3RrL1dlYktpdFRlc3RTZXJ2ZXIuaApAQCAtMzksOCArMzksOCBAQCBwdWJsaWM6CiAgICAg dmlydHVhbCB+V2ViS2l0VGVzdFNlcnZlcigpOwogCiAgICAgU291cFVSSSogYmFzZVVSSSgpIHsg cmV0dXJuIG1fYmFzZVVSSTsgfQotCi0gICAgQ1N0cmluZyBnZXRVUklGb3JQYXRoKGNvbnN0IGNo YXIqIHBhdGgpOworICAgIENTdHJpbmcgc2VjdXJpdHlPcmlnaW4oKSBjb25zdDsKKyAgICBDU3Ry aW5nIGdldFVSSUZvclBhdGgoY29uc3QgY2hhciogcGF0aCkgY29uc3Q7CiAgICAgdm9pZCBydW4o U291cFNlcnZlckNhbGxiYWNrKTsKIAogcHJpdmF0ZToKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViVmlld1Rlc3QuY3BwIGIvVG9vbHMvVGVzdFdlYktp dEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJWaWV3VGVzdC5jcHAKaW5kZXggNGEyMjE0NWM0NzE5OTJi ZTQwY2YzZGRjNTQ1OTA1ZDFhYzMzMDZmNC4uYmQ5NzFiYTNmZjI1YjYwMjRjYWY0MTFiMTA5MmE1 MjY5OTNmNDNmNCAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0 ay9XZWJWaWV3VGVzdC5jcHAKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0 ay9XZWJWaWV3VGVzdC5jcHAKQEAgLTI0LDE5ICsyNCwxNCBAQAogI2luY2x1ZGUgPEphdmFTY3Jp cHRDb3JlL0pTUmV0YWluUHRyLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9HVW5pcXVlUHRyR3RrLmg+ CiAKK2Jvb2wgV2ViVmlld1Rlc3Q6OnNob3VsZEluaXRpYWxpemVXZWJWaWV3SW5Db25zdHJ1Y3Rv ciA9IHRydWU7CisKIFdlYlZpZXdUZXN0OjpXZWJWaWV3VGVzdCgpCiAgICAgOiBtX3VzZXJDb250 ZW50TWFuYWdlcihhZG9wdEdSZWYod2Via2l0X3VzZXJfY29udGVudF9tYW5hZ2VyX25ldygpKSkK LSAgICAsIG1fd2ViVmlldyhXRUJLSVRfV0VCX1ZJRVcoZ19vYmplY3RfcmVmX3NpbmsoZ19vYmpl Y3RfbmV3KFdFQktJVF9UWVBFX1dFQl9WSUVXLCAid2ViLWNvbnRleHQiLCBtX3dlYkNvbnRleHQu Z2V0KCksICJ1c2VyLWNvbnRlbnQtbWFuYWdlciIsIG1fdXNlckNvbnRlbnRNYW5hZ2VyLmdldCgp LCBudWxscHRyKSkpKQogICAgICwgbV9tYWluTG9vcChnX21haW5fbG9vcF9uZXcobnVsbHB0ciwg VFJVRSkpCi0gICAgLCBtX3BhcmVudFdpbmRvdyhudWxscHRyKQotICAgICwgbV9qYXZhc2NyaXB0 UmVzdWx0KG51bGxwdHIpCi0gICAgLCBtX3Jlc291cmNlRGF0YVNpemUoMCkKLSAgICAsIG1fc3Vy ZmFjZShudWxscHRyKQotICAgICwgbV9leHBlY3RlZFdlYlByb2Nlc3NDcmFzaChmYWxzZSkKIHsK LSAgICBhc3NlcnRPYmplY3RJc0RlbGV0ZWRXaGVuVGVzdEZpbmlzaGVzKEdfT0JKRUNUKG1fd2Vi VmlldykpOwotICAgIGFzc2VydE9iamVjdElzRGVsZXRlZFdoZW5UZXN0RmluaXNoZXMoR19PQkpF Q1QobV91c2VyQ29udGVudE1hbmFnZXIuZ2V0KCkpKTsKLSAgICBnX3NpZ25hbF9jb25uZWN0KG1f d2ViVmlldywgIndlYi1wcm9jZXNzLWNyYXNoZWQiLCBHX0NBTExCQUNLKFdlYlZpZXdUZXN0Ojp3 ZWJQcm9jZXNzQ3Jhc2hlZCksIHRoaXMpOworICAgIGlmIChzaG91bGRJbml0aWFsaXplV2ViVmll d0luQ29uc3RydWN0b3IpCisgICAgICAgIGluaXRpYWxpemVXZWJWaWV3KCk7CiB9CiAKIFdlYlZp ZXdUZXN0Ojp+V2ViVmlld1Rlc3QoKQpAQCAtNTEsNiArNDYsMTUgQEAgV2ViVmlld1Rlc3Q6On5X ZWJWaWV3VGVzdCgpCiAgICAgZ19tYWluX2xvb3BfdW5yZWYobV9tYWluTG9vcCk7CiB9CiAKK3Zv aWQgV2ViVmlld1Rlc3Q6OmluaXRpYWxpemVXZWJWaWV3KCkKK3sKKyAgICBnX2Fzc2VydCghbV93 ZWJWaWV3KTsKKyAgICBtX3dlYlZpZXcgPSBXRUJLSVRfV0VCX1ZJRVcoZ19vYmplY3RfcmVmX3Np bmsoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX1dFQl9WSUVXLCAid2ViLWNvbnRleHQiLCBtX3dl YkNvbnRleHQuZ2V0KCksICJ1c2VyLWNvbnRlbnQtbWFuYWdlciIsIG1fdXNlckNvbnRlbnRNYW5h Z2VyLmdldCgpLCBudWxscHRyKSkpOworICAgIGFzc2VydE9iamVjdElzRGVsZXRlZFdoZW5UZXN0 RmluaXNoZXMoR19PQkpFQ1QobV93ZWJWaWV3KSk7CisgICAgYXNzZXJ0T2JqZWN0SXNEZWxldGVk V2hlblRlc3RGaW5pc2hlcyhHX09CSkVDVChtX3VzZXJDb250ZW50TWFuYWdlci5nZXQoKSkpOwor ICAgIGdfc2lnbmFsX2Nvbm5lY3QobV93ZWJWaWV3LCAid2ViLXByb2Nlc3MtY3Jhc2hlZCIsIEdf Q0FMTEJBQ0soV2ViVmlld1Rlc3Q6OndlYlByb2Nlc3NDcmFzaGVkKSwgdGhpcyk7Cit9CisKIGdi b29sZWFuIFdlYlZpZXdUZXN0Ojp3ZWJQcm9jZXNzQ3Jhc2hlZChXZWJLaXRXZWJWaWV3KiwgV2Vi Vmlld1Rlc3QqIHRlc3QpCiB7CiAgICAgaWYgKHRlc3QtPm1fZXhwZWN0ZWRXZWJQcm9jZXNzQ3Jh c2gpIHsKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2Vi Vmlld1Rlc3QuaCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViVmlld1Rl c3QuaAppbmRleCBhMzAwMWIyZGUzNDE4ZTcwYzlhNzM5YmVjYTdhZTIzMzY3MDRlY2MyLi40ZjBj NGM3YmY1OGQwMzU1OTYyZjY5YWUzOGE0YjAyODdhMzgyNjNiIDEwMDY0NAotLS0gYS9Ub29scy9U ZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYlZpZXdUZXN0LmgKKysrIGIvVG9vbHMvVGVz dFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJWaWV3VGVzdC5oCkBAIC0zMSw2ICszMSw5IEBA IHB1YmxpYzoKICAgICBXZWJWaWV3VGVzdCgpOwogICAgIHZpcnR1YWwgfldlYlZpZXdUZXN0KCk7 CiAKKyAgICBzdGF0aWMgYm9vbCBzaG91bGRJbml0aWFsaXplV2ViVmlld0luQ29uc3RydWN0b3I7 CisgICAgdm9pZCBpbml0aWFsaXplV2ViVmlldygpOworCiAgICAgdmlydHVhbCB2b2lkIGxvYWRV UkkoY29uc3QgY2hhciogdXJpKTsKICAgICB2aXJ0dWFsIHZvaWQgbG9hZEh0bWwoY29uc3QgY2hh ciogaHRtbCwgY29uc3QgY2hhciogYmFzZVVSSSk7CiAgICAgdmlydHVhbCB2b2lkIGxvYWRQbGFp blRleHQoY29uc3QgY2hhciogcGxhaW5UZXh0KTsKQEAgLTgxLDE3ICs4NCwxNyBAQCBwdWJsaWM6 CiAgICAgc3RhdGljIGdib29sZWFuIHdlYlByb2Nlc3NDcmFzaGVkKFdlYktpdFdlYlZpZXcqLCBX ZWJWaWV3VGVzdCopOwogCiAgICAgR1JlZlB0cjxXZWJLaXRVc2VyQ29udGVudE1hbmFnZXI+IG1f dXNlckNvbnRlbnRNYW5hZ2VyOwotICAgIFdlYktpdFdlYlZpZXcqIG1fd2ViVmlldzsKKyAgICBX ZWJLaXRXZWJWaWV3KiBtX3dlYlZpZXcgeyBudWxscHRyIH07CiAgICAgR01haW5Mb29wKiBtX21h aW5Mb29wOwogICAgIENTdHJpbmcgbV9hY3RpdmVVUkk7Ci0gICAgR3RrV2lkZ2V0KiBtX3BhcmVu dFdpbmRvdzsKKyAgICBHdGtXaWRnZXQqIG1fcGFyZW50V2luZG93IHsgbnVsbHB0ciB9OwogICAg IENTdHJpbmcgbV9leHBlY3RlZFRpdGxlOwotICAgIFdlYktpdEphdmFzY3JpcHRSZXN1bHQqIG1f amF2YXNjcmlwdFJlc3VsdDsKLSAgICBHRXJyb3IqKiBtX2phdmFzY3JpcHRFcnJvcjsKLSAgICBH VW5pcXVlUHRyPGNoYXI+IG1fcmVzb3VyY2VEYXRhOwotICAgIHNpemVfdCBtX3Jlc291cmNlRGF0 YVNpemU7Ci0gICAgY2Fpcm9fc3VyZmFjZV90KiBtX3N1cmZhY2U7Ci0gICAgYm9vbCBtX2V4cGVj dGVkV2ViUHJvY2Vzc0NyYXNoOworICAgIFdlYktpdEphdmFzY3JpcHRSZXN1bHQqIG1famF2YXNj cmlwdFJlc3VsdCB7IG51bGxwdHIgfTsKKyAgICBHRXJyb3IqKiBtX2phdmFzY3JpcHRFcnJvciB7 IG51bGxwdHIgfTsKKyAgICBHVW5pcXVlUHRyPGNoYXI+IG1fcmVzb3VyY2VEYXRhIHsgbnVsbHB0 ciB9OworICAgIHNpemVfdCBtX3Jlc291cmNlRGF0YVNpemUgeyAwIH07CisgICAgY2Fpcm9fc3Vy ZmFjZV90KiBtX3N1cmZhY2UgeyBudWxscHRyIH07CisgICAgYm9vbCBtX2V4cGVjdGVkV2ViUHJv Y2Vzc0NyYXNoIHsgZmFsc2UgfTsKIAogcHJpdmF0ZToKICAgICB2b2lkIGRvTW91c2VCdXR0b25F dmVudChHZGtFdmVudFR5cGUsIGludCwgaW50LCB1bnNpZ25lZCwgdW5zaWduZWQpOwo= 295428 2016-11-25 14:06:10 -0800 2016-12-29 09:36:13 -0800 Patch bug-163366-20161125160551.patch text/plain 22747 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjA4OTc3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggMjMwZGQyMmI5ODEzNDU0 ZTM5ODdhZTBkNTVkNzQwMjJlMjE1OTI0Zi4uOGI2MGE5NjBlZTNlODAwYjQ1NDJkMTVmMWJjNWJm NGNiZGExMWVhMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSw1ICsxLDI0IEBACiAyMDE2LTExLTI1ICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KIAorICAgICAgICBbR1RLXSBO byB3YXkgZm9yIGFwcGxpY2F0aW9ucyB0byBzZXQgbm90aWZpY2F0aW9uIHBlcm1pc3Npb25zIHdp dGhvdXQgd2FpdGluZyBmb3IgcGVybWlzc2lvbiByZXF1ZXN0CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjMzNjYKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdE5v dGlmaWNhdGlvblByb3ZpZGVyLmNwcDoKKyAgICAgICAgKG5vdGlmaWNhdGlvblBlcm1pc3Npb25z Q2FsbGJhY2spOgorICAgICAgICAoV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI6OldlYktpdE5v dGlmaWNhdGlvblByb3ZpZGVyKToKKyAgICAgICAgKFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVy OjpzZXROb3RpZmljYXRpb25QZXJtaXNzaW9ucyk6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuaDoKKyAgICAgICAgKFdlYktpdDo6V2ViS2l0 Tm90aWZpY2F0aW9uUHJvdmlkZXI6Om5vdGlmaWNhdGlvblBlcm1pc3Npb25zKToKKyAgICAgICAg KiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcDoKKyAgICAgICAgKGFkZFRv UGVybWlzc2lvbk1hcCk6CisgICAgICAgICh3ZWJraXRfd2ViX2NvbnRleHRfc2V0X2luaXRpYWxf bm90aWZpY2F0aW9uX3Blcm1pc3Npb25zKToKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRXZWJDb250ZXh0Lmg6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJr aXQyZ3RrLTQuMC1zZWN0aW9ucy50eHQ6CisKKzIwMTYtMTEtMjUgIE1pY2hhZWwgQ2F0YW56YXJv ICA8bWNhdGFuemFyb0BpZ2FsaWEuY29tPgorCiAgICAgICAgIFtHVEtdIEZvbGxvdy11cCBmaXhl cyB0byByMjA4OTc0CiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xNjQ3NzEKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuY3BwCmluZGV4IGE4MGU2ODY3 Nzk5MDBhYmRiMDExNTBhYmYyZjM5MGMxOGFmMDdkYTguLmI3MGJlNTczNTZlYjQxNjAyOTdkMTNi NmI5MzczMDk2ZGE3OTcxMDQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9B UEkvZ3RrL1dlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5jcHAKQEAgLTI4 LDYgKzI4LDcgQEAKICNpbmNsdWRlICJXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5oIgogCiAj aW5jbHVkZSAiQVBJQXJyYXkuaCIKKyNpbmNsdWRlICJBUElEaWN0aW9uYXJ5LmgiCiAjaW5jbHVk ZSAiV0tOb3RpZmljYXRpb25NYW5hZ2VyLmgiCiAjaW5jbHVkZSAiV2ViS2l0Tm90aWZpY2F0aW9u UHJpdmF0ZS5oIgogI2luY2x1ZGUgIldlYktpdFdlYlZpZXdQcml2YXRlLmgiCkBAIC01Miw2ICs1 MywxMSBAQCBzdGF0aWMgdm9pZCBjYW5jZWxDYWxsYmFjayhXS05vdGlmaWNhdGlvblJlZiBub3Rp ZmljYXRpb24sIGNvbnN0IHZvaWQqIGNsaWVudEluZgogICAgIHRvTm90aWZpY2F0aW9uUHJvdmlk ZXIoY2xpZW50SW5mbyktPmNhbmNlbCgqdG9JbXBsKG5vdGlmaWNhdGlvbikpOwogfQogCitzdGF0 aWMgV0tEaWN0aW9uYXJ5UmVmIG5vdGlmaWNhdGlvblBlcm1pc3Npb25zQ2FsbGJhY2soY29uc3Qg dm9pZCogY2xpZW50SW5mbykKK3sKKyAgICByZXR1cm4gdG9BUEkodG9Ob3RpZmljYXRpb25Qcm92 aWRlcihjbGllbnRJbmZvKS0+bm90aWZpY2F0aW9uUGVybWlzc2lvbnMoKS5sZWFrUmVmKCkpOwor fQorCiBzdGF0aWMgdm9pZCBjbGVhck5vdGlmaWNhdGlvbnNDYWxsYmFjayhXS0FycmF5UmVmIG5v dGlmaWNhdGlvbklEcywgY29uc3Qgdm9pZCogY2xpZW50SW5mbykKIHsKICAgICB0b05vdGlmaWNh dGlvblByb3ZpZGVyKGNsaWVudEluZm8pLT5jbGVhck5vdGlmaWNhdGlvbnModG9JbXBsKG5vdGlm aWNhdGlvbklEcykpOwpAQCAtODEsNyArODcsNyBAQCBXZWJLaXROb3RpZmljYXRpb25Qcm92aWRl cjo6V2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIoV2ViTm90aWZpY2F0aW9uTWFuYWdlclBybwog ICAgICAgICAwLCAvLyBkaWREZXN0cm95Tm90aWZpY2F0aW9uQ2FsbGJhY2ssCiAgICAgICAgIDAs IC8vIGFkZE5vdGlmaWNhdGlvbk1hbmFnZXJDYWxsYmFjaywKICAgICAgICAgMCwgLy8gcmVtb3Zl Tm90aWZpY2F0aW9uTWFuYWdlckNhbGxiYWNrLAotICAgICAgICAwLCAvLyBub3RpZmljYXRpb25Q ZXJtaXNzaW9uc0NhbGxiYWNrLAorICAgICAgICBub3RpZmljYXRpb25QZXJtaXNzaW9uc0NhbGxi YWNrLAogICAgICAgICBjbGVhck5vdGlmaWNhdGlvbnNDYWxsYmFjaywKICAgICB9OwogCkBAIC0x NTIsMyArMTU4LDggQEAgdm9pZCBXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcjo6Y2xlYXJOb3Rp ZmljYXRpb25zKGNvbnN0IEFQSTo6QXJyYXkqIG5vdGlmaWNhdGkKICAgICBmb3IgKGNvbnN0IGF1 dG8mIGl0ZW0gOiBub3RpZmljYXRpb25JRHMtPmVsZW1lbnRzT2ZUeXBlPEFQSTo6VUludDY0Pigp KQogICAgICAgICBjYW5jZWxOb3RpZmljYXRpb25CeUlEKGl0ZW0tPnZhbHVlKCkpOwogfQorCit2 b2lkIFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyOjpzZXROb3RpZmljYXRpb25QZXJtaXNzaW9u cyhIYXNoTWFwPFN0cmluZywgUmVmUHRyPEFQSTo6T2JqZWN0Pj4mJiBwZXJtaXNzaW9uc01hcCkK K3sKKyAgICBtX25vdGlmaWNhdGlvblBlcm1pc3Npb25zID0gQVBJOjpEaWN0aW9uYXJ5OjpjcmVh dGUocGVybWlzc2lvbnNNYXApOworfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuaCBiL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyLmgKaW5kZXggMjg5 NGJhMDA1NDNhMDI0MjdkOWZmOTM4MTFjYTE2M2ZkOTY4NDI4Ny4uNTI3MTk0NzdkZTcyNDQ4NDkx Nzk1ZjY5NThhNzY2OTU0ZTJhOGRlNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuaAorKysgYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5oCkBAIC00 MSw2ICs0MSw5IEBAIHB1YmxpYzoKICAgICB2b2lkIGNhbmNlbChjb25zdCBXZWJOb3RpZmljYXRp b24mKTsKICAgICB2b2lkIGNsZWFyTm90aWZpY2F0aW9ucyhjb25zdCBBUEk6OkFycmF5Kik7CiAK KyAgICBSZWZQdHI8QVBJOjpEaWN0aW9uYXJ5PiBub3RpZmljYXRpb25QZXJtaXNzaW9ucygpIHsg cmV0dXJuIG1fbm90aWZpY2F0aW9uUGVybWlzc2lvbnM7IH0KKyAgICB2b2lkIHNldE5vdGlmaWNh dGlvblBlcm1pc3Npb25zKEhhc2hNYXA8U3RyaW5nLCBSZWZQdHI8QVBJOjpPYmplY3Q+PiYmKTsK KwogcHJpdmF0ZToKICAgICBXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcihXZWJOb3RpZmljYXRp b25NYW5hZ2VyUHJveHkqKTsKIApAQCAtNTAsNiArNTMsNyBAQCBwcml2YXRlOgogCiAgICAgdm9p ZCB3aXRoZHJhd0FueVByZXZpb3VzTm90aWZpY2F0aW9uTWF0Y2hpbmdUYWcoY29uc3QgQ1N0cmlu ZyYpOwogCisgICAgUmVmUHRyPEFQSTo6RGljdGlvbmFyeT4gbV9ub3RpZmljYXRpb25QZXJtaXNz aW9ucyB7IG51bGxwdHIgfTsKICAgICBSZWZQdHI8V2ViTm90aWZpY2F0aW9uTWFuYWdlclByb3h5 PiBtX25vdGlmaWNhdGlvbk1hbmFnZXI7CiAgICAgSGFzaE1hcDx1aW50NjRfdCwgR1JlZlB0cjxX ZWJLaXROb3RpZmljYXRpb24+PiBtX25vdGlmaWNhdGlvbnM7CiB9OwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dC5jcHAgYi9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcAppbmRleCA3 MzgzNGNmM2FkMjVlYzFkZjI1YzgzMzEyOTBmN2VkM2I1OTkzZGQxLi4yMzBhMzQ5MmUyNDgwZDBm OWJmZTliZGI3YmU1YTIwMjgzNjMzYjIyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcApAQCAtMTIxOCw2ICsxMjE4LDQ2 IEBAIGd1aW50IHdlYmtpdF93ZWJfY29udGV4dF9nZXRfd2ViX3Byb2Nlc3NfY291bnRfbGltaXQo V2ViS2l0V2ViQ29udGV4dCogY29udGV4dCkKICAgICByZXR1cm4gY29udGV4dC0+cHJpdi0+cHJv Y2Vzc0NvdW50TGltaXQ7CiB9CiAKK3N0YXRpYyB2b2lkIGFkZFRvUGVybWlzc2lvbk1hcChncG9p bnRlciBrZXksIGdwb2ludGVyIHZhbHVlLCBncG9pbnRlciB1c2VyRGF0YSkKK3sKKyAgICBhdXRv IGRvbWFpbiA9IHN0YXRpY19jYXN0PGNvbnN0IGNoYXIqPihrZXkpOworICAgIGJvb2wgcGVybWlz c2lvbiA9IEdQT0lOVEVSX1RPX0lOVCh2YWx1ZSk7CisgICAgYXV0byBtYXAgPSBzdGF0aWNfY2Fz dDxIYXNoTWFwPFN0cmluZywgUmVmUHRyPEFQSTo6T2JqZWN0Pj4qPih1c2VyRGF0YSk7CisgICAg bWFwLT5zZXQoU3RyaW5nOjpmcm9tVVRGOChkb21haW4pLCBBUEk6OkJvb2xlYW46OmNyZWF0ZShw ZXJtaXNzaW9uKSk7Cit9CisKKy8qKgorICogd2Via2l0X3dlYl9jb250ZXh0X3NldF9pbml0aWFs X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uczoKKyAqIEBjb250ZXh0OiB0aGUgI1dlYktpdFdlYkNv bnRleHQKKyAqIEBwZXJtaXNzaW9uczogKGVsZW1lbnQtdHlwZSB1dGY4IGdib29sZWFuKTogYSAj R0hhc2hUYWJsZQorICoKKyAqIFNldHMgaW5pdGlhbCBkZXNrdG9wIG5vdGlmaWNhdGlvbiBwZXJt aXNzaW9ucyBmb3IgdGhlIEBjb250ZXh0LgorICogQHBlcm1pc3Npb25zIG11c3QgYmUgYSAjR0hh c2hUYWJsZSBvZiBzdHJpbmdzIGNvbnRhaW5pbmcgc2VjdXJpdHkKKyAqIG9yaWdpbnMgKHByb3Rv Y29sLCBob3N0LCBhbmQgb3B0aW9uYWwgcG9ydCwgZS5nLgorICogaHR0cDovL3d3dy5leGFtcGxl LmNvbSBidXQgbm90IGh0dHA6Ly93d3cuZXhhbXBsZS5jb20vKSB0byBib29sZWFuCisgKiB2YWx1 ZXMgKHN0b3JlZCB1c2luZyBHSU5UX1RPX1BPSU5URVIoKSkuIE5vCisgKiAjV2ViS2l0Tm90aWZp Y2F0aW9uUGVybWlzc2lvblJlcXVlc3Qgd2lsbCBldmVyIGJlIGdlbmVyYXRlZCBmb3IKKyAqIGRv bWFpbnMgcmVwcmVzZW50ZWQgaW4gdGhlIEBwZXJtaXNzaW9ucy4gSWYgdGhlIGJvb2xlYW4gdmFs dWUKKyAqIGNvcnJlc3BvbmRpbmcgdG8gdGhlIGRvbWFpbiBpbiBAcGVybWlzc2lvbnMgaXMgJVRS VUUsIHRoZW4gdGhlIGRvbWFpbgorICogd2lsbCBhbHdheXMgaGF2ZSBwZXJtaXNzaW9uIHRvIHNo b3cgZGVza3RvcCBub3RpZmljYXRpb25zOyBpZiBpdCBpcworICogJUZBTFNFLCB0aGVuIGl0IHdp bGwgbmV2ZXIgaGF2ZSBwZXJtaXNzaW9uIHRvIGRvIHNvLiBUaGlzIGZ1bmN0aW9uCisgKiBpcyBu ZWNlc3NhcnkgYmVjYXVzZSBzb21lIHdlYnBhZ2VzIHByb2FjdGl2ZWx5IGNoZWNrIHdoZXRoZXIg dGhleQorICogaGF2ZSBwZXJtaXNzaW9uIHRvIGRpc3BsYXkgbm90aWZpY2F0aW9ucyB3aXRob3V0 IGV2ZXIgY3JlYXRpbmcgYQorICogcGVybWlzc2lvbiByZXF1ZXN0LgorICoKKyAqIFRoaXMgZnVu Y3Rpb24gb25seSBhZmZlY3RzIHdlYiBwcm9jZXNzZXMgdGhhdCBoYXZlIG5vdCBhbHJlYWR5IGJl ZW4KKyAqIGNyZWF0ZWQsIHNvIGl0IHNob3VsZCB1c3VhbGx5IGJlIGNhbGxlZCBiZWZvcmUgY3Jl YXRpbmcgdGhlIGZpcnN0CisgKiAjV2ViS2l0V2ViVmlldy4KKyAqCisgKiBTaW5jZTogMi4xNgor ICovCit2b2lkIHdlYmtpdF93ZWJfY29udGV4dF9zZXRfaW5pdGlhbF9ub3RpZmljYXRpb25fcGVy bWlzc2lvbnMoV2ViS2l0V2ViQ29udGV4dCogY29udGV4dCwgR0hhc2hUYWJsZSogcGVybWlzc2lv bnMpCit7CisgICAgSGFzaE1hcDxTdHJpbmcsIFJlZlB0cjxBUEk6Ok9iamVjdD4+IG1hcDsKKyAg ICBnX2hhc2hfdGFibGVfZm9yZWFjaChwZXJtaXNzaW9ucywgYWRkVG9QZXJtaXNzaW9uTWFwLCAm bWFwKTsKKyAgICBjb250ZXh0LT5wcml2LT5ub3RpZmljYXRpb25Qcm92aWRlci0+c2V0Tm90aWZp Y2F0aW9uUGVybWlzc2lvbnMoV1RGTW92ZShtYXApKTsKK30KKwogV2ViS2l0RG93bmxvYWQqIHdl YmtpdFdlYkNvbnRleHRHZXRPckNyZWF0ZURvd25sb2FkKERvd25sb2FkUHJveHkqIGRvd25sb2Fk UHJveHkpCiB7CiAgICAgR1JlZlB0cjxXZWJLaXREb3dubG9hZD4gZG93bmxvYWQgPSBkb3dubG9h ZHNNYXAoKS5nZXQoZG93bmxvYWRQcm94eSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmgKaW5kZXggY2Q1NTQ4NmY0YzIzMzk1ZjBl NzdiYjg2MjMzNzBlN2M1NzBkZTFiNy4uYzI2NDIxOWMxYjczMTdiYzUxOGM3M2NiMDRjM2Q2ZDUz MjY1NjkzYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2Vi S2l0V2ViQ29udGV4dC5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dl YktpdFdlYkNvbnRleHQuaApAQCAtMjY0LDYgKzI2NCwxMSBAQCB3ZWJraXRfd2ViX2NvbnRleHRf c2V0X3Byb2Nlc3NfbW9kZWwgICAgICAgICAgICAgICAgKFdlYktpdFdlYkNvbnRleHQKIFdFQktJ VF9BUEkgV2ViS2l0UHJvY2Vzc01vZGVsCiB3ZWJraXRfd2ViX2NvbnRleHRfZ2V0X3Byb2Nlc3Nf bW9kZWwgICAgICAgICAgICAgICAgKFdlYktpdFdlYkNvbnRleHQgICAgICAgICAgICAgICpjb250 ZXh0KTsKIAorV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfd2ViX2NvbnRleHRfc2V0X2luaXRpYWxf bm90aWZpY2F0aW9uX3Blcm1pc3Npb25zCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgKFdlYktpdFdlYkNvbnRleHQgICAgICAgICAgICAgICpjb250 ZXh0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBHSGFzaFRhYmxlICAgICAgICAgICAgICAgICAgICAqcGVybWlzc2lvbnMpOworCiBHX0VORF9E RUNMUwogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkv Z3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0IGIvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLTQuMC1zZWN0aW9ucy50eHQKaW5kZXggMDEz MDNmNjg5MzllNWM0NTU1MzZhYzM0MWYyN2Y4ODBiMjgwZWY1Ny4uZjRjMGUwMjA1MGY1OTVkODY3 NDQwNmYwY2ZiMTc1MTQ5MzM1NjMzZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLTQuMC1zZWN0aW9ucy50eHQKKysrIGIvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLTQuMC1zZWN0aW9ucy50 eHQKQEAgLTU5LDYgKzU5LDcgQEAgd2Via2l0X3dlYl9jb250ZXh0X3NldF9kaXNrX2NhY2hlX2Rp cmVjdG9yeQogd2Via2l0X3dlYl9jb250ZXh0X2FsbG93X3Rsc19jZXJ0aWZpY2F0ZV9mb3JfaG9z dAogd2Via2l0X3dlYl9jb250ZXh0X2dldF9wcm9jZXNzX21vZGVsCiB3ZWJraXRfd2ViX2NvbnRl eHRfc2V0X3Byb2Nlc3NfbW9kZWwKK3dlYmtpdF93ZWJfY29udGV4dF9zZXRfaW5pdGlhbF9ub3Rp ZmljYXRpb25fcGVybWlzc2lvbnMKIAogPFNVQlNFQ1RJT04gVVJJIFNjaGVtZT4KIFdlYktpdFVS SVNjaGVtZVJlcXVlc3RDYWxsYmFjawpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9v bHMvQ2hhbmdlTG9nCmluZGV4IDg3NjMwMzA0ZGQ5NWM0N2VkN2QxY2UwMTNmYmZlNGZiNmMzNDMy ZWQuLjI0ZjhhODVhY2M1MWI3ZjFiNjNhZTdjYzJiOTllMTViNzVkYjVkMTMgMTAwNjQ0Ci0tLSBh L1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAor MjAxNi0xMS0yNSAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGlnYWxpYS5jb20+CisK KyAgICAgICAgW0dUS10gTm8gd2F5IGZvciBhcHBsaWNhdGlvbnMgdG8gc2V0IG5vdGlmaWNhdGlv biBwZXJtaXNzaW9ucyB3aXRob3V0IHdhaXRpbmcgZm9yIHBlcm1pc3Npb24gcmVxdWVzdAorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTYzMzY2CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0 QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYktpdFdlYlZpZXcuY3BwOiBBZGQgbmV3IEFQSSB0 ZXN0LgorICAgICAgICAodGVzdFdlYlZpZXdOb3RpZmljYXRpb24pOgorICAgICAgICAodGVzdFdl YlZpZXdOb3RpZmljYXRpb25Jbml0aWFsUGVybWlzc2lvbik6CisgICAgICAgIChiZWZvcmVBbGwp OgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvVGVzdE1haW4uaDogQWRk IG1hY3JvIHRvIGFsbG93IGN1c3RvbSB0ZXN0IGZpeHR1cmVzLgorICAgICAgICAqIFRlc3RXZWJL aXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViS2l0VGVzdFNlcnZlci5jcHA6IEFkZCBoZWxwZXIgdG8g Z2V0IHNlY3VyaXR5IG9yaWdpbi4KKyAgICAgICAgKFdlYktpdFRlc3RTZXJ2ZXI6OnNlY3VyaXR5 T3JpZ2luKToKKyAgICAgICAgKFdlYktpdFRlc3RTZXJ2ZXI6OmdldFVSSUZvclBhdGgpOiBEcml2 ZS1ieTogbWFkZSBpdCBjb25zdC4KKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQy R3RrL1dlYktpdFRlc3RTZXJ2ZXIuaDoKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL2d0ay9XZWJL aXQyR3RrL1dlYlZpZXdUZXN0LmNwcDogQWRkIGFiaWxpdHkgdG8gZGVmZXIgd2ViIHZpZXcgY3Jl YXRpb24uCisgICAgICAgIChXZWJWaWV3VGVzdDo6V2ViVmlld1Rlc3QpOgorICAgICAgICAoV2Vi Vmlld1Rlc3Q6OmluaXRpYWxpemVXZWJWaWV3KToKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL2d0 ay9XZWJLaXQyR3RrL1dlYlZpZXdUZXN0Lmg6CisKIDIwMTYtMTEtMjQgIE1pY2hhZWwgQ2F0YW56 YXJvICA8bWNhdGFuemFyb0BpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdIE5vdGlmaWNhdGlv bnMgQVBJIGRvZXMgbm90IGV4cG9zZSBvciByZXNwZWN0IHRoZSAidGFnIiBhdHRyaWJ1dGUKZGlm ZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9UZXN0V2ViS2l0 V2ViVmlldy5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdl YktpdFdlYlZpZXcuY3BwCmluZGV4IDI5MmY1NTYxNjAzMDhhMGI5Yzk1M2UxYmEzMjE0YjUwZDUz NWVlZjkuLmViOTRiMzAxMzdhZTgxZWVkM2U1N2RkM2Q0MWQ0NmMzNjBjOWI1ZTAgMTAwNjQ0Ci0t LSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9UZXN0V2ViS2l0V2ViVmll dy5jcHAKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RXZWJL aXRXZWJWaWV3LmNwcApAQCAtNjMyLDcgKzYzMiwxNyBAQCBzdGF0aWMgdm9pZCB0ZXN0V2ViVmll d1NuYXBzaG90KFNuYXBzaG90V2ViVmlld1Rlc3QqIHRlc3QsIGdjb25zdHBvaW50ZXIpCiAKIGNs YXNzIE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0OiBwdWJsaWMgV2ViVmlld1Rlc3QgewogcHVibGlj OgotICAgIE1BS0VfR0xJQl9URVNUX0ZJWFRVUkUoTm90aWZpY2F0aW9uV2ViVmlld1Rlc3QpOwor ICAgIE1BS0VfR0xJQl9URVNUX0ZJWFRVUkVfV0lUSF9TRVRVUF9URUFSRE9XTihOb3RpZmljYXRp b25XZWJWaWV3VGVzdCwgc2V0dXAsIHRlYXJkb3duKTsKKworICAgIHN0YXRpYyB2b2lkIHNldHVw KCkKKyAgICB7CisgICAgICAgIFdlYlZpZXdUZXN0OjpzaG91bGRJbml0aWFsaXplV2ViVmlld0lu Q29uc3RydWN0b3IgPSBmYWxzZTsKKyAgICB9CisKKyAgICBzdGF0aWMgdm9pZCB0ZWFyZG93bigp CisgICAgeworICAgICAgICBXZWJWaWV3VGVzdDo6c2hvdWxkSW5pdGlhbGl6ZVdlYlZpZXdJbkNv bnN0cnVjdG9yID0gdHJ1ZTsKKyAgICB9CiAKICAgICBlbnVtIE5vdGlmaWNhdGlvbkV2ZW50IHsK ICAgICAgICAgTm9uZSwKQEAgLTY0Nyw2ICs2NTcsNyBAQCBwdWJsaWM6CiAgICAgc3RhdGljIGdi b29sZWFuIHBlcm1pc3Npb25SZXF1ZXN0Q2FsbGJhY2soV2ViS2l0V2ViVmlldyosIFdlYktpdFBl cm1pc3Npb25SZXF1ZXN0ICpyZXF1ZXN0LCBOb3RpZmljYXRpb25XZWJWaWV3VGVzdCogdGVzdCkK ICAgICB7CiAgICAgICAgIGdfYXNzZXJ0KFdFQktJVF9JU19OT1RJRklDQVRJT05fUEVSTUlTU0lP Tl9SRVFVRVNUKHJlcXVlc3QpKTsKKyAgICAgICAgZ19hc3NlcnQodGVzdC0+bV9pc0V4cGVjdGlu Z1Blcm1pc3Npb25SZXF1ZXN0KTsKICAgICAgICAgdGVzdC0+YXNzZXJ0T2JqZWN0SXNEZWxldGVk V2hlblRlc3RGaW5pc2hlcyhHX09CSkVDVChyZXF1ZXN0KSk7CiAKICAgICAgICAgdGVzdC0+bV9l dmVudCA9IFBlcm1pc3Npb247CkBAIC02OTksMTAgKzcxMCw5IEBAIHB1YmxpYzoKICAgICAgICAg Z19tYWluX2xvb3BfcXVpdCh0ZXN0LT5tX21haW5Mb29wKTsKICAgICB9CiAKLSAgICBOb3RpZmlj YXRpb25XZWJWaWV3VGVzdCgpCi0gICAgICAgIDogbV9ub3RpZmljYXRpb24obnVsbHB0cikKLSAg ICAgICAgLCBtX2V2ZW50KE5vbmUpCisgICAgdm9pZCBpbml0aWFsaXplKCkKICAgICB7CisgICAg ICAgIGluaXRpYWxpemVXZWJWaWV3KCk7CiAgICAgICAgIGdfc2lnbmFsX2Nvbm5lY3QobV93ZWJW aWV3LCAicGVybWlzc2lvbi1yZXF1ZXN0IiwgR19DQUxMQkFDSyhwZXJtaXNzaW9uUmVxdWVzdENh bGxiYWNrKSwgdGhpcyk7CiAgICAgICAgIGdfc2lnbmFsX2Nvbm5lY3QobV93ZWJWaWV3LCAic2hv dy1ub3RpZmljYXRpb24iLCBHX0NBTExCQUNLKHNob3dOb3RpZmljYXRpb25DYWxsYmFjayksIHRo aXMpOwogICAgICAgICB3ZWJraXRfdXNlcl9jb250ZW50X21hbmFnZXJfcmVnaXN0ZXJfc2NyaXB0 X21lc3NhZ2VfaGFuZGxlcihtX3VzZXJDb250ZW50TWFuYWdlci5nZXQoKSwgIm5vdGlmaWNhdGlv bnMiKTsKQEAgLTcxNiw5ICs3MjYsMzcgQEAgcHVibGljOgogICAgICAgICB3ZWJraXRfdXNlcl9j b250ZW50X21hbmFnZXJfdW5yZWdpc3Rlcl9zY3JpcHRfbWVzc2FnZV9oYW5kbGVyKG1fdXNlckNv bnRlbnRNYW5hZ2VyLmdldCgpLCAibm90aWZpY2F0aW9ucyIpOwogICAgIH0KIAorICAgIHN0YXRp YyB2b2lkIGhhc1Blcm1pc3Npb25DYWxsYmFjayhHT2JqZWN0KiBvYmplY3QsIEdBc3luY1Jlc3Vs dCogcmVzdWx0LCBncG9pbnRlciB1c2VyRGF0YSkKKyAgICB7CisgICAgICAgIGF1dG8gdGVzdCA9 IHN0YXRpY19jYXN0PE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0Kj4odXNlckRhdGEpOworICAgICAg ICBHRXJyb3IqIGVycm9yID0gbnVsbHB0cjsKKyAgICAgICAgV2ViS2l0SmF2YXNjcmlwdFJlc3Vs dCoganNSZXN1bHQgPSB3ZWJraXRfd2ViX3ZpZXdfcnVuX2phdmFzY3JpcHRfZmluaXNoKHRlc3Qt Pm1fd2ViVmlldywgcmVzdWx0LCAmZXJyb3IpOworICAgICAgICBnX2Fzc2VydCghZXJyb3IpOwor CisgICAgICAgIEpTR2xvYmFsQ29udGV4dFJlZiBjb250ZXh0ID0gd2Via2l0X2phdmFzY3JpcHRf cmVzdWx0X2dldF9nbG9iYWxfY29udGV4dChqc1Jlc3VsdCk7CisgICAgICAgIEpTVmFsdWVSZWYg dmFsdWUgPSB3ZWJraXRfamF2YXNjcmlwdF9yZXN1bHRfZ2V0X3ZhbHVlKGpzUmVzdWx0KTsKKyAg ICAgICAgZ19hc3NlcnQoSlNWYWx1ZUlzU3RyaW5nKGNvbnRleHQsIHZhbHVlKSk7CisKKyAgICAg ICAgLy8gUG9zc2libGUgdmFsdWVzOiAiZGVuaWVkIiwgImdyYW50ZWQiLCAiZGVmYXVsdCIgKGlt cGxpY2l0IGRlbnkpCisgICAgICAgIEpTU3RyaW5nUmVmIGpzU3RyaW5nVmFsdWUgPSBKU1ZhbHVl VG9TdHJpbmdDb3B5KGNvbnRleHQsIHZhbHVlLCBudWxscHRyKTsKKyAgICAgICAgdGVzdC0+bV9o YXNQZXJtaXNzaW9uID0gSlNTdHJpbmdJc0VxdWFsVG9VVEY4Q1N0cmluZyhqc1N0cmluZ1ZhbHVl LCAiZ3JhbnRlZCIpOworICAgICAgICBKU1N0cmluZ1JlbGVhc2UoanNTdHJpbmdWYWx1ZSk7Cisg ICAgICAgIHdlYmtpdF9qYXZhc2NyaXB0X3Jlc3VsdF91bnJlZihqc1Jlc3VsdCk7CisKKyAgICAg ICAgZ19tYWluX2xvb3BfcXVpdCh0ZXN0LT5tX21haW5Mb29wKTsKKyAgICB9CisKKyAgICBib29s IGhhc1Blcm1pc3Npb24oKQorICAgIHsKKyAgICAgICAgd2Via2l0X3dlYl92aWV3X3J1bl9qYXZh c2NyaXB0KG1fd2ViVmlldywgIk5vdGlmaWNhdGlvbi5wZXJtaXNzaW9uOyIsIG51bGxwdHIsIGhh c1Blcm1pc3Npb25DYWxsYmFjaywgdGhpcyk7CisgICAgICAgIGdfbWFpbl9sb29wX3J1bihtX21h aW5Mb29wKTsKKyAgICAgICAgcmV0dXJuIG1faGFzUGVybWlzc2lvbjsKKyAgICB9CisKICAgIHZv aWQgcmVxdWVzdFBlcm1pc3Npb25BbmRXYWl0VW50aWxHaXZlbigpCiAgICAgewogICAgICAgICBt X2V2ZW50ID0gTm9uZTsKKyAgICAgICAgbV9pc0V4cGVjdGluZ1Blcm1pc3Npb25SZXF1ZXN0ID0g dHJ1ZTsKICAgICAgICAgd2Via2l0X3dlYl92aWV3X3J1bl9qYXZhc2NyaXB0KG1fd2ViVmlldywg Ik5vdGlmaWNhdGlvbi5yZXF1ZXN0UGVybWlzc2lvbigpOyIsIG51bGxwdHIsIG51bGxwdHIsIG51 bGxwdHIpOwogICAgICAgICBnX21haW5fbG9vcF9ydW4obV9tYWluTG9vcCk7CiAgICAgfQpAQCAt NzY5LDE4ICs4MDcsMjQgQEAgcHVibGljOgogICAgICAgICBnX21haW5fbG9vcF9ydW4obV9tYWlu TG9vcCk7CiAgICAgfQogCi0gICAgTm90aWZpY2F0aW9uRXZlbnQgbV9ldmVudDsKLSAgICBXZWJL aXROb3RpZmljYXRpb24qIG1fbm90aWZpY2F0aW9uOworICAgIE5vdGlmaWNhdGlvbkV2ZW50IG1f ZXZlbnQgeyBOb25lIH07CisgICAgV2ViS2l0Tm90aWZpY2F0aW9uKiBtX25vdGlmaWNhdGlvbiB7 IG51bGxwdHIgfTsKKyAgICBib29sIG1faXNFeHBlY3RpbmdQZXJtaXNzaW9uUmVxdWVzdCB7IGZh bHNlIH07CisgICAgYm9vbCBtX2hhc1Blcm1pc3Npb24geyBmYWxzZSB9OwogfTsKIAogc3RhdGlj IHZvaWQgdGVzdFdlYlZpZXdOb3RpZmljYXRpb24oTm90aWZpY2F0aW9uV2ViVmlld1Rlc3QqIHRl c3QsIGdjb25zdHBvaW50ZXIpCiB7CisgICAgdGVzdC0+aW5pdGlhbGl6ZSgpOworCiAgICAgLy8g Tm90aWZpY2F0aW9ucyBkb24ndCB3b3JrIHdpdGggbG9jYWwgb3Igc3BlY2lhbCBzY2hlbWVzLgog ICAgIHRlc3QtPmxvYWRVUkkoZ1NlcnZlci0+Z2V0VVJJRm9yUGF0aCgiLyIpLmRhdGEoKSk7CiAg ICAgdGVzdC0+d2FpdFVudGlsTG9hZEZpbmlzaGVkKCk7CisgICAgZ19hc3NlcnQoIXRlc3QtPmhh c1Blcm1pc3Npb24oKSk7CiAKICAgICB0ZXN0LT5yZXF1ZXN0UGVybWlzc2lvbkFuZFdhaXRVbnRp bEdpdmVuKCk7CiAgICAgZ19hc3NlcnQodGVzdC0+bV9ldmVudCA9PSBOb3RpZmljYXRpb25XZWJW aWV3VGVzdDo6UGVybWlzc2lvbik7CisgICAgZ19hc3NlcnQodGVzdC0+aGFzUGVybWlzc2lvbigp KTsKIAogICAgIHN0YXRpYyBjb25zdCBjaGFyKiB0aXRsZSA9ICJUaGlzIGlzIGEgbm90aWZpY2F0 aW9uIjsKICAgICBzdGF0aWMgY29uc3QgY2hhciogYm9keSA9ICJUaGlzIGlzIHRoZSBib2R5LiI7 CkBAIC04MTgsNiArODYyLDI0IEBAIHN0YXRpYyB2b2lkIHRlc3RXZWJWaWV3Tm90aWZpY2F0aW9u KE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0KiB0ZXN0LCBnY29uc3Rwb2ludGVyCiAgICAgZ19hc3Nl cnQodGVzdC0+bV9ldmVudCA9PSBOb3RpZmljYXRpb25XZWJWaWV3VGVzdDo6Q2xvc2VkKTsKIH0K IAorc3RhdGljIHZvaWQgdGVzdFdlYlZpZXdOb3RpZmljYXRpb25Jbml0aWFsUGVybWlzc2lvbihO b3RpZmljYXRpb25XZWJWaWV3VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRlcikKK3sKKyAgICBhdXRv IHRhYmxlID0gYWRvcHRHUmVmKGdfaGFzaF90YWJsZV9uZXdfZnVsbChnX3N0cl9oYXNoLCBnX3N0 cl9lcXVhbCwgZ19mcmVlLCBudWxscHRyKSk7CisgICAgZ19oYXNoX3RhYmxlX2luc2VydCh0YWJs ZS5nZXQoKSwgZ19zdHJkdXAoZ1NlcnZlci0+c2VjdXJpdHlPcmlnaW4oKS5kYXRhKCkpLCBHSU5U X1RPX1BPSU5URVIoVFJVRSkpOworCisgICAgd2Via2l0X3dlYl9jb250ZXh0X3NldF9pbml0aWFs X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9ucyh0ZXN0LT5tX3dlYkNvbnRleHQuZ2V0KCksIHRhYmxl LmdldCgpKTsgCisgICAgdGVzdC0+aW5pdGlhbGl6ZSgpOworCisgICAgdGVzdC0+bG9hZFVSSShn U2VydmVyLT5nZXRVUklGb3JQYXRoKCIvIikuZGF0YSgpKTsKKyAgICB0ZXN0LT53YWl0VW50aWxM b2FkRmluaXNoZWQoKTsKKyAgICBnX2Fzc2VydCh0ZXN0LT5oYXNQZXJtaXNzaW9uKCkpOworCisg ICAgc3RhdGljIGNvbnN0IGNoYXIqIHRpdGxlID0gIlRoaXMgaXMgYSBub3RpZmljYXRpb24iOwor ICAgIHN0YXRpYyBjb25zdCBjaGFyKiBib2R5ID0gIlRoaXMgaXMgdGhlIGJvZHkuIjsKKyAgICB0 ZXN0LT5yZXF1ZXN0Tm90aWZpY2F0aW9uQW5kV2FpdFVudGlsU2hvd24odGl0bGUsIGJvZHkpOwor ICAgIGdfYXNzZXJ0KHRlc3QtPm1fZXZlbnQgPT0gTm90aWZpY2F0aW9uV2ViVmlld1Rlc3Q6OlNo b3duKTsKK30KKwogc3RhdGljIHZvaWQgdGVzdFdlYlZpZXdJc1BsYXlpbmdBdWRpbyhJc1BsYXlp bmdBdWRpb1dlYlZpZXdUZXN0KiB0ZXN0LCBnY29uc3Rwb2ludGVyKQogewogICAgIC8vIFRoZSB3 ZWIgdmlldyBtdXN0IGJlIHJlYWxpemVkIGZvciB0aGUgdmlkZW8gdG8gc3RhcnQgcGxheWJhY2sg YW5kCkBAIC05MTUsNiArOTc3LDcgQEAgdm9pZCBiZWZvcmVBbGwoKQogICAgIFNuYXBzaG90V2Vi Vmlld1Rlc3Q6OmFkZCgiV2ViS2l0V2ViVmlldyIsICJzbmFwc2hvdCIsIHRlc3RXZWJWaWV3U25h cHNob3QpOwogICAgIFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAicGFnZS12aXNp YmlsaXR5IiwgdGVzdFdlYlZpZXdQYWdlVmlzaWJpbGl0eSk7CiAgICAgTm90aWZpY2F0aW9uV2Vi Vmlld1Rlc3Q6OmFkZCgiV2ViS2l0V2ViVmlldyIsICJub3RpZmljYXRpb24iLCB0ZXN0V2ViVmll d05vdGlmaWNhdGlvbik7CisgICAgTm90aWZpY2F0aW9uV2ViVmlld1Rlc3Q6OmFkZCgiV2ViS2l0 V2ViVmlldyIsICJub3RpZmljYXRpb24taW5pdGlhbC1wZXJtaXNzaW9uIiwgdGVzdFdlYlZpZXdO b3RpZmljYXRpb25Jbml0aWFsUGVybWlzc2lvbik7CiAgICAgSXNQbGF5aW5nQXVkaW9XZWJWaWV3 VGVzdDo6YWRkKCJXZWJLaXRXZWJWaWV3IiwgImlzLXBsYXlpbmctYXVkaW8iLCB0ZXN0V2ViVmll d0lzUGxheWluZ0F1ZGlvKTsKICAgICBXZWJWaWV3VGVzdDo6YWRkKCJXZWJLaXRXZWJWaWV3Iiwg ImJhY2tncm91bmQtY29sb3IiLCB0ZXN0V2ViVmlld0JhY2tncm91bmRDb2xvcik7CiAgICAgV2Vi Vmlld1Rlc3Q6OmFkZCgiV2ViS2l0V2ViVmlldyIsICJwcmVmZXJyZWQtc2l6ZSIsIHRlc3RXZWJW aWV3UHJlZmVycmVkU2l6ZSk7CmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL2d0ay9X ZWJLaXQyR3RrL1Rlc3RNYWluLmggYi9Ub29scy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3Rr L1Rlc3RNYWluLmgKaW5kZXggNjA1NGZlMDlkNDc5YTg4MDYwOWYzNjUyMjVkODkzYzg2MjZlYzlj NC4uZjY4YWYyYTk2NTE2MmIzZDJlZmI5YmRlOTU3ODAwMWE0YjU1YWNmZiAxMDA2NDQKLS0tIGEv VG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9UZXN0TWFpbi5oCisrKyBiL1Rvb2xz L1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvVGVzdE1haW4uaApAQCAtNDMsNiArNDMsMjUg QEAKICAgICAgICAgZ190ZXN0X2FkZCh0ZXN0UGF0aC5nZXQoKSwgQ2xhc3NOYW1lLCAwLCBDbGFz c05hbWU6OnNldFVwLCB0ZXN0RnVuYywgQ2xhc3NOYW1lOjp0ZWFyRG93bik7IFwKICAgICB9CiAK KyNkZWZpbmUgTUFLRV9HTElCX1RFU1RfRklYVFVSRV9XSVRIX1NFVFVQX1RFQVJET1dOKENsYXNz TmFtZSwgc2V0dXAsIHRlYXJkb3duKSBcCisgICAgc3RhdGljIHZvaWQgc2V0VXAoQ2xhc3NOYW1l KiBmaXh0dXJlLCBnY29uc3Rwb2ludGVyIGRhdGEpIFwKKyAgICB7IFwKKyAgICAgICAgaWYgKHNl dHVwKSBcCisgICAgICAgICAgICBzZXR1cCgpOyBcCisgICAgICAgIG5ldyAoZml4dHVyZSkgQ2xh c3NOYW1lOyBcCisgICAgfSBcCisgICAgc3RhdGljIHZvaWQgdGVhckRvd24oQ2xhc3NOYW1lKiBm aXh0dXJlLCBnY29uc3Rwb2ludGVyIGRhdGEpIFwKKyAgICB7IFwKKyAgICAgICAgZml4dHVyZS0+ fkNsYXNzTmFtZSgpOyBcCisgICAgICAgIGlmICh0ZWFyZG93bikgXAorICAgICAgICAgICAgdGVh cmRvd24oKTsgXAorICAgIH0gXAorICAgIHN0YXRpYyB2b2lkIGFkZChjb25zdCBjaGFyKiBzdWl0 ZU5hbWUsIGNvbnN0IGNoYXIqIHRlc3ROYW1lLCB2b2lkICgqdGVzdEZ1bmMpKENsYXNzTmFtZSos IGNvbnN0IHZvaWQqKSkgXAorICAgIHsgXAorICAgICAgICBHVW5pcXVlUHRyPGdjaGFyPiB0ZXN0 UGF0aChnX3N0cmR1cF9wcmludGYoIi93ZWJraXQyLyVzLyVzIiwgc3VpdGVOYW1lLCB0ZXN0TmFt ZSkpOyBcCisgICAgICAgIGdfdGVzdF9hZGQodGVzdFBhdGguZ2V0KCksIENsYXNzTmFtZSwgMCwg Q2xhc3NOYW1lOjpzZXRVcCwgdGVzdEZ1bmMsIENsYXNzTmFtZTo6dGVhckRvd24pOyBcCisgICAg fQorCiAjZGVmaW5lIEFTU0VSVF9DTVBfQ1NUUklORyhzMSwgY21wLCBzMikgXAogICAgIGRvIHsg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIFwKICAgICAgICAgQ1N0cmluZyBfX3MxID0gKHMxKTsgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBcCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0 QVBJL2d0ay9XZWJLaXQyR3RrL1dlYktpdFRlc3RTZXJ2ZXIuY3BwIGIvVG9vbHMvVGVzdFdlYktp dEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJLaXRUZXN0U2VydmVyLmNwcAppbmRleCBkZTk0NjZjMzlk NzFjZmMyYWJmNDQ5ZmNmZGUzODliNTQ0OWRmMzI3Li5jNDkyOWRlOGEwOGU4NWVmYWRhYzZjZDQ5 Y2IxNGQwNDE1Njc1MjRiIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJL aXQyR3RrL1dlYktpdFRlc3RTZXJ2ZXIuY3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3Rr L1dlYktpdDJHdGsvV2ViS2l0VGVzdFNlcnZlci5jcHAKQEAgLTY4LDcgKzY4LDE1IEBAIHZvaWQg V2ViS2l0VGVzdFNlcnZlcjo6cnVuKFNvdXBTZXJ2ZXJDYWxsYmFjayBzZXJ2ZXJDYWxsYmFjaykK ICAgICB9CiB9CiAKLUNTdHJpbmcgV2ViS2l0VGVzdFNlcnZlcjo6Z2V0VVJJRm9yUGF0aChjb25z dCBjaGFyKiBwYXRoKQorQ1N0cmluZyBXZWJLaXRUZXN0U2VydmVyOjpzZWN1cml0eU9yaWdpbigp IGNvbnN0Cit7CisgICAgLy8gVGhlIHNlY3VyaXR5IG9yaWdpbiBpcyB0aGUgYmFzZSBVUkkgbWlu dXMgdGhlIHRyYWlsaW5nIHNsYXNoLgorICAgIEdVbmlxdWVQdHI8Z2NoYXI+IHVyaVN0cmluZyhz b3VwX3VyaV90b19zdHJpbmcobV9iYXNlVVJJLCBGQUxTRSkpOworICAgIHVyaVN0cmluZy5nZXQo KVtzdHJsZW4odXJpU3RyaW5nLmdldCgpKSAtIDFdID0gJ1wwJzsKKyAgICByZXR1cm4gdXJpU3Ry aW5nLmdldCgpOworfQorCitDU3RyaW5nIFdlYktpdFRlc3RTZXJ2ZXI6OmdldFVSSUZvclBhdGgo Y29uc3QgY2hhciogcGF0aCkgY29uc3QKIHsKICAgICBTb3VwVVJJKiB1cmkgPSBzb3VwX3VyaV9u ZXdfd2l0aF9iYXNlKG1fYmFzZVVSSSwgcGF0aCk7CiAgICAgR1VuaXF1ZVB0cjxnY2hhcj4gdXJp U3RyaW5nKHNvdXBfdXJpX3RvX3N0cmluZyh1cmksIEZBTFNFKSk7CmRpZmYgLS1naXQgYS9Ub29s cy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYktpdFRlc3RTZXJ2ZXIuaCBiL1Rvb2xz L1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViS2l0VGVzdFNlcnZlci5oCmluZGV4IDU4 ZjAxOWZhYjg2MDFjMmQxMzE0NmFjYzU0ZmM3ODhkY2UyOWM2OGEuLmQzODIwOTViMjZmM2IyMzc5 OTNlMmE5MjJlM2MyYWRjM2E0YTc1YmEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkv Z3RrL1dlYktpdDJHdGsvV2ViS2l0VGVzdFNlcnZlci5oCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvZ3RrL1dlYktpdDJHdGsvV2ViS2l0VGVzdFNlcnZlci5oCkBAIC0zOSw4ICszOSw4IEBAIHB1 YmxpYzoKICAgICB2aXJ0dWFsIH5XZWJLaXRUZXN0U2VydmVyKCk7CiAKICAgICBTb3VwVVJJKiBi YXNlVVJJKCkgeyByZXR1cm4gbV9iYXNlVVJJOyB9Ci0KLSAgICBDU3RyaW5nIGdldFVSSUZvclBh dGgoY29uc3QgY2hhciogcGF0aCk7CisgICAgQ1N0cmluZyBzZWN1cml0eU9yaWdpbigpIGNvbnN0 OworICAgIENTdHJpbmcgZ2V0VVJJRm9yUGF0aChjb25zdCBjaGFyKiBwYXRoKSBjb25zdDsKICAg ICB2b2lkIHJ1bihTb3VwU2VydmVyQ2FsbGJhY2spOwogCiBwcml2YXRlOgpkaWZmIC0tZ2l0IGEv VG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJWaWV3VGVzdC5jcHAgYi9Ub29s cy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYlZpZXdUZXN0LmNwcAppbmRleCA0YTIy MTQ1YzQ3MTk5MmJlNDBjZjNkZGM1NDU5MDVkMWFjMzMwNmY0Li5iZDk3MWJhM2ZmMjViNjAyNGNh ZjQxMWIxMDkyYTUyNjk5M2Y0M2Y0IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL2d0 ay9XZWJLaXQyR3RrL1dlYlZpZXdUZXN0LmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL2d0 ay9XZWJLaXQyR3RrL1dlYlZpZXdUZXN0LmNwcApAQCAtMjQsMTkgKzI0LDE0IEBACiAjaW5jbHVk ZSA8SmF2YVNjcmlwdENvcmUvSlNSZXRhaW5QdHIuaD4KICNpbmNsdWRlIDxXZWJDb3JlL0dVbmlx dWVQdHJHdGsuaD4KIAorYm9vbCBXZWJWaWV3VGVzdDo6c2hvdWxkSW5pdGlhbGl6ZVdlYlZpZXdJ bkNvbnN0cnVjdG9yID0gdHJ1ZTsKKwogV2ViVmlld1Rlc3Q6OldlYlZpZXdUZXN0KCkKICAgICA6 IG1fdXNlckNvbnRlbnRNYW5hZ2VyKGFkb3B0R1JlZih3ZWJraXRfdXNlcl9jb250ZW50X21hbmFn ZXJfbmV3KCkpKQotICAgICwgbV93ZWJWaWV3KFdFQktJVF9XRUJfVklFVyhnX29iamVjdF9yZWZf c2luayhnX29iamVjdF9uZXcoV0VCS0lUX1RZUEVfV0VCX1ZJRVcsICJ3ZWItY29udGV4dCIsIG1f d2ViQ29udGV4dC5nZXQoKSwgInVzZXItY29udGVudC1tYW5hZ2VyIiwgbV91c2VyQ29udGVudE1h bmFnZXIuZ2V0KCksIG51bGxwdHIpKSkpCiAgICAgLCBtX21haW5Mb29wKGdfbWFpbl9sb29wX25l dyhudWxscHRyLCBUUlVFKSkKLSAgICAsIG1fcGFyZW50V2luZG93KG51bGxwdHIpCi0gICAgLCBt X2phdmFzY3JpcHRSZXN1bHQobnVsbHB0cikKLSAgICAsIG1fcmVzb3VyY2VEYXRhU2l6ZSgwKQot ICAgICwgbV9zdXJmYWNlKG51bGxwdHIpCi0gICAgLCBtX2V4cGVjdGVkV2ViUHJvY2Vzc0NyYXNo KGZhbHNlKQogewotICAgIGFzc2VydE9iamVjdElzRGVsZXRlZFdoZW5UZXN0RmluaXNoZXMoR19P QkpFQ1QobV93ZWJWaWV3KSk7Ci0gICAgYXNzZXJ0T2JqZWN0SXNEZWxldGVkV2hlblRlc3RGaW5p c2hlcyhHX09CSkVDVChtX3VzZXJDb250ZW50TWFuYWdlci5nZXQoKSkpOwotICAgIGdfc2lnbmFs X2Nvbm5lY3QobV93ZWJWaWV3LCAid2ViLXByb2Nlc3MtY3Jhc2hlZCIsIEdfQ0FMTEJBQ0soV2Vi Vmlld1Rlc3Q6OndlYlByb2Nlc3NDcmFzaGVkKSwgdGhpcyk7CisgICAgaWYgKHNob3VsZEluaXRp YWxpemVXZWJWaWV3SW5Db25zdHJ1Y3RvcikKKyAgICAgICAgaW5pdGlhbGl6ZVdlYlZpZXcoKTsK IH0KIAogV2ViVmlld1Rlc3Q6On5XZWJWaWV3VGVzdCgpCkBAIC01MSw2ICs0NiwxNSBAQCBXZWJW aWV3VGVzdDo6fldlYlZpZXdUZXN0KCkKICAgICBnX21haW5fbG9vcF91bnJlZihtX21haW5Mb29w KTsKIH0KIAordm9pZCBXZWJWaWV3VGVzdDo6aW5pdGlhbGl6ZVdlYlZpZXcoKQoreworICAgIGdf YXNzZXJ0KCFtX3dlYlZpZXcpOworICAgIG1fd2ViVmlldyA9IFdFQktJVF9XRUJfVklFVyhnX29i amVjdF9yZWZfc2luayhnX29iamVjdF9uZXcoV0VCS0lUX1RZUEVfV0VCX1ZJRVcsICJ3ZWItY29u dGV4dCIsIG1fd2ViQ29udGV4dC5nZXQoKSwgInVzZXItY29udGVudC1tYW5hZ2VyIiwgbV91c2Vy Q29udGVudE1hbmFnZXIuZ2V0KCksIG51bGxwdHIpKSk7CisgICAgYXNzZXJ0T2JqZWN0SXNEZWxl dGVkV2hlblRlc3RGaW5pc2hlcyhHX09CSkVDVChtX3dlYlZpZXcpKTsKKyAgICBhc3NlcnRPYmpl Y3RJc0RlbGV0ZWRXaGVuVGVzdEZpbmlzaGVzKEdfT0JKRUNUKG1fdXNlckNvbnRlbnRNYW5hZ2Vy LmdldCgpKSk7CisgICAgZ19zaWduYWxfY29ubmVjdChtX3dlYlZpZXcsICJ3ZWItcHJvY2Vzcy1j cmFzaGVkIiwgR19DQUxMQkFDSyhXZWJWaWV3VGVzdDo6d2ViUHJvY2Vzc0NyYXNoZWQpLCB0aGlz KTsKK30KKwogZ2Jvb2xlYW4gV2ViVmlld1Rlc3Q6OndlYlByb2Nlc3NDcmFzaGVkKFdlYktpdFdl YlZpZXcqLCBXZWJWaWV3VGVzdCogdGVzdCkKIHsKICAgICBpZiAodGVzdC0+bV9leHBlY3RlZFdl YlByb2Nlc3NDcmFzaCkgewpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2Vi S2l0Mkd0ay9XZWJWaWV3VGVzdC5oIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0 ay9XZWJWaWV3VGVzdC5oCmluZGV4IGEzMDAxYjJkZTM0MThlNzBjOWE3MzliZWNhN2FlMjMzNjcw NGVjYzIuLjRmMGM0YzdiZjU4ZDAzNTU5NjJmNjlhZTM4YTRiMDI4N2EzODI2M2IgMTAwNjQ0Ci0t LSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViVmlld1Rlc3QuaAorKysg Yi9Ub29scy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYlZpZXdUZXN0LmgKQEAgLTMx LDYgKzMxLDkgQEAgcHVibGljOgogICAgIFdlYlZpZXdUZXN0KCk7CiAgICAgdmlydHVhbCB+V2Vi Vmlld1Rlc3QoKTsKIAorICAgIHN0YXRpYyBib29sIHNob3VsZEluaXRpYWxpemVXZWJWaWV3SW5D b25zdHJ1Y3RvcjsKKyAgICB2b2lkIGluaXRpYWxpemVXZWJWaWV3KCk7CisKICAgICB2aXJ0dWFs IHZvaWQgbG9hZFVSSShjb25zdCBjaGFyKiB1cmkpOwogICAgIHZpcnR1YWwgdm9pZCBsb2FkSHRt bChjb25zdCBjaGFyKiBodG1sLCBjb25zdCBjaGFyKiBiYXNlVVJJKTsKICAgICB2aXJ0dWFsIHZv aWQgbG9hZFBsYWluVGV4dChjb25zdCBjaGFyKiBwbGFpblRleHQpOwpAQCAtODEsMTcgKzg0LDE3 IEBAIHB1YmxpYzoKICAgICBzdGF0aWMgZ2Jvb2xlYW4gd2ViUHJvY2Vzc0NyYXNoZWQoV2ViS2l0 V2ViVmlldyosIFdlYlZpZXdUZXN0Kik7CiAKICAgICBHUmVmUHRyPFdlYktpdFVzZXJDb250ZW50 TWFuYWdlcj4gbV91c2VyQ29udGVudE1hbmFnZXI7Ci0gICAgV2ViS2l0V2ViVmlldyogbV93ZWJW aWV3OworICAgIFdlYktpdFdlYlZpZXcqIG1fd2ViVmlldyB7IG51bGxwdHIgfTsKICAgICBHTWFp bkxvb3AqIG1fbWFpbkxvb3A7CiAgICAgQ1N0cmluZyBtX2FjdGl2ZVVSSTsKLSAgICBHdGtXaWRn ZXQqIG1fcGFyZW50V2luZG93OworICAgIEd0a1dpZGdldCogbV9wYXJlbnRXaW5kb3cgeyBudWxs cHRyIH07CiAgICAgQ1N0cmluZyBtX2V4cGVjdGVkVGl0bGU7Ci0gICAgV2ViS2l0SmF2YXNjcmlw dFJlc3VsdCogbV9qYXZhc2NyaXB0UmVzdWx0OwotICAgIEdFcnJvcioqIG1famF2YXNjcmlwdEVy cm9yOwotICAgIEdVbmlxdWVQdHI8Y2hhcj4gbV9yZXNvdXJjZURhdGE7Ci0gICAgc2l6ZV90IG1f cmVzb3VyY2VEYXRhU2l6ZTsKLSAgICBjYWlyb19zdXJmYWNlX3QqIG1fc3VyZmFjZTsKLSAgICBi b29sIG1fZXhwZWN0ZWRXZWJQcm9jZXNzQ3Jhc2g7CisgICAgV2ViS2l0SmF2YXNjcmlwdFJlc3Vs dCogbV9qYXZhc2NyaXB0UmVzdWx0IHsgbnVsbHB0ciB9OworICAgIEdFcnJvcioqIG1famF2YXNj cmlwdEVycm9yIHsgbnVsbHB0ciB9OworICAgIEdVbmlxdWVQdHI8Y2hhcj4gbV9yZXNvdXJjZURh dGEgeyBudWxscHRyIH07CisgICAgc2l6ZV90IG1fcmVzb3VyY2VEYXRhU2l6ZSB7IDAgfTsKKyAg ICBjYWlyb19zdXJmYWNlX3QqIG1fc3VyZmFjZSB7IG51bGxwdHIgfTsKKyAgICBib29sIG1fZXhw ZWN0ZWRXZWJQcm9jZXNzQ3Jhc2ggeyBmYWxzZSB9OwogCiBwcml2YXRlOgogICAgIHZvaWQgZG9N b3VzZUJ1dHRvbkV2ZW50KEdka0V2ZW50VHlwZSwgaW50LCBpbnQsIHVuc2lnbmVkLCB1bnNpZ25l ZCk7Cg== 297834 2016-12-29 09:36:18 -0800 2016-12-30 12:27:47 -0800 Patch bug-163366-20161229113502.patch text/plain 52457 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjEwMjAwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggNTI4MmRlNjkyNWFjOGVi OTcyYTRlMWRjOWQ3MWM5ZDU2MjMxNDg4MC4uZTY5ZTNjNTcyYjM1ZTQ2ZjM4MGExNmVhYzExYjJi ZTI4ZDk2ZDExOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDY2IEBACisyMDE2LTEyLTI5ICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBO byB3YXkgZm9yIGFwcGxpY2F0aW9ucyB0byBzZXQgbm90aWZpY2F0aW9uIHBlcm1pc3Npb25zIHdp dGhvdXQgd2FpdGluZyBmb3IgcGVybWlzc2lvbiByZXF1ZXN0CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjMzNjYKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXZWJzaXRlcyBjYW4gY2hlY2sgdGhlIE5vdGlm aWNhdGlvbi5wZXJtaXNzaW9uIERPTSBwcm9wZXJ0eSB0byBjaGVjayBpZiB0aGV5IGhhdmUgcGVy bWlzc2lvbgorICAgICAgICB0byBzaG93IG5vdGlmaWNhdGlvbnMgKndpdGhvdXQgdHJpZ2dlcmlu ZyBhIHBlcm1pc3Npb24gcmVxdWVzdCouIEJ1dCB0aGUgV2ViS2l0R1RLKyBBUEkgaGFzCisgICAg ICAgIG5vIHdheSB0byBhZmZpcm1hdGl2ZWx5IGluZGljYXRlIG5vdGlmaWNhdGlvbnMgYXJlIGFs bG93ZWQgd2l0aG91dCBhIHBlcm1pc3Npb24gcmVxdWVzdC4gVGhlCisgICAgICAgIG9ubHkgd2F5 IGlzIHZpYSB0aGUgcGVybWlzc2lvbiByZXF1ZXN0IEFQSSwgd2hpY2ggaXMgdG9vIGxhdGUuIEl0 J3MgYSBwcm9ibGVtIGZvciBFcGlwaGFueS4KKyAgICAgICAgRm9yIGV4YW1wbGUsIG9wZW4gdGhl IFJpb3QgTWF0cml4IGNsaWVudCBpbiBhIHdlYiBhcHA7IHlvdSB3aWxsIGltbWVkaWF0ZWx5IHNl ZSBhbiBpbmZvIGJhcgorICAgICAgICBpbmZvcm1pbmcgdGhlIHVzZXIgdGhhdCBSaW90IGRvZXMg bm90IGhhdmUgcGVybWlzc2lvbiB0byBzZW5kIGRlc2t0b3Agbm90aWZpY2F0aW9ucywgZXZlbgor ICAgICAgICB0aG91Z2ggRXBpcGhhbnkgYXV0b21hdGljYWxseSBncmFudHMgbm90aWZpY2F0aW9u IHBlcm1pc3Npb24gaW4gd2ViIGFwcCBtb2RlIHdoZW4gcmVxdWVzdGVkLgorICAgICAgICBUaGlz IHByb2JsZW0gaXMgbm90IGV4Y2x1c2l2ZSB0byB3ZWIgYXBwczsgdGhlcmUgaXMgc2ltcGx5IG5v IHdheSBmb3Igbm90aWZpY2F0aW9uCisgICAgICAgIHBlcm1pc3Npb24gdG8gYmUgc2V0IGNvcnJl Y3RseSBwcmlvciB0byBhIHBlcm1pc3Npb24gcmVxdWVzdCBmb3IgaXQuIEZpeCB0aGlzIGJ5IGlu dHJvZHVjaW5nCisgICAgICAgIGEgd2Via2l0X3dlYl9jb250ZXh0X3NldF9pbml0aWFsX25vdGlm aWNhdGlvbl9wZXJtaXNzaW9ucygpIEFQSSwgYW5kIGFkZCBhIHNpZ25hbAorICAgICAgICBXZWJL aXRXZWJDb250ZXh0OjpzZXQtaW5pdGlhbC1ub3RpZmljYXRpb24tcGVybWlzc2lvbnMgdG8gaW5k aWNhdGUgd2hlbiBpdCBzaG91bGQgYmUgY2FsbGVkLgorCisgICAgICAgIEFsc28sIGV4cG9zZSBX ZWJLaXRTZWN1cml0eU9yaWdpbiBBUEkuIFRoaXMgQVBJIHdhcyBvcmlnaW5hbGx5IGRldmVsb3Bl ZCBieSBDYXJsb3MgR2FyY2lhCisgICAgICAgIGxhc3QgeWVhciBmb3IgYSBXZWJLaXRXZWJzaXRl RGF0YU1hbmFnZXIgZW5oYW5jZW1lbnQgdGhhdCBoYXMgbmV2ZXIgbGFuZGVkLiBJIGhhdmUgdXBk YXRlZAorICAgICAgICBpdCB0byBhY2NvdW50IGZvciBXZWJDb3JlOjpTZWN1cml0eU9yaWdpbiBu b3cgdXNpbmcgc3RkOjpvcHRpb25hbCBmb3IgcG9ydHMsIGFuZCBhZGRlZAorICAgICAgICBfZnJv bV9zdHJpbmcoKSBhbmQgX3RvX3N0cmluZygpIG1ldGhvZHMgdG8gbWFrZSBpdCBjb252ZW5pZW50 IHRvIHVzZSBmb3Igbm90aWZpY2F0aW9uCisgICAgICAgIHBlcm1pc3Npb25zLiBXZWJLaXRTZWN1 cml0eU9yaWdpbiBzdXBlcmlvciB0byBwYXNzaW5nIHN0cmluZ3MgdG8gaW5kaWNhdGUgd2hpY2gg b3JpZ2lucyBoYXZlCisgICAgICAgIHBlcm1pc3Npb24gdG8gc2hvdyBub3RpZmljYXRpb25zLgor CisgICAgICAgICogUGxhdGZvcm1HVEsuY21ha2U6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0QXV0b2NsZWFudXBzLmg6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2Vi S2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuY3BwOgorICAgICAgICAobm90aWZpY2F0aW9uUGVybWlz c2lvbnNDYWxsYmFjayk6CisgICAgICAgIChXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcjo6Y3Jl YXRlKToKKyAgICAgICAgKFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyOjpXZWJLaXROb3RpZmlj YXRpb25Qcm92aWRlcik6CisgICAgICAgIChXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcjo6bm90 aWZpY2F0aW9uUGVybWlzc2lvbnMpOgorICAgICAgICAoV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlk ZXI6OnNldE5vdGlmaWNhdGlvblBlcm1pc3Npb25zKToKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9B UEkvZ3RrL1dlYktpdFNlY3VyaXR5T3JpZ2luLmNwcDogQWRkZWQuCisgICAgICAgIChfV2ViS2l0 U2VjdXJpdHlPcmlnaW46Ol9XZWJLaXRTZWN1cml0eU9yaWdpbik6CisgICAgICAgICh3ZWJraXRT ZWN1cml0eU9yaWdpbkNyZWF0ZSk6CisgICAgICAgICh3ZWJraXRTZWN1cml0eU9yaWdpbkdldFNl Y3VyaXR5T3JpZ2luKToKKyAgICAgICAgKHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fbmV3KToKKyAg ICAgICAgKHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fbmV3X2Zyb21fc3RyaW5nKToKKyAgICAgICAg KHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fcmVmKToKKyAgICAgICAgKHdlYmtpdF9zZWN1cml0eV9v cmlnaW5fdW5yZWYpOgorICAgICAgICAod2Via2l0X3NlY3VyaXR5X29yaWdpbl9nZXRfcHJvdG9j b2wpOgorICAgICAgICAod2Via2l0X3NlY3VyaXR5X29yaWdpbl9nZXRfaG9zdCk6CisgICAgICAg ICh3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dldF9wb3J0KToKKyAgICAgICAgKHdlYmtpdF9zZWN1 cml0eV9vcmlnaW5fdG9fc3RyaW5nKToKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRTZWN1cml0eU9yaWdpbi5oOiBBZGRlZC4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRTZWN1cml0eU9yaWdpblByaXZhdGUuaDogQ29waWVkIGZyb20gVG9vbHMvVGVzdFdlYktp dEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJLaXRUZXN0U2VydmVyLmguCisgICAgICAgICogVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dC5jcHA6CisgICAgICAgICh3ZWJraXRXZWJDb250 ZXh0Q29uc3RydWN0ZWQpOgorICAgICAgICAod2Via2l0X3dlYl9jb250ZXh0X2NsYXNzX2luaXQp OgorICAgICAgICAoYWRkT3JpZ2luVG9NYXApOgorICAgICAgICAoYWRkQWxsb3dlZE9yaWdpblRv TWFwKToKKyAgICAgICAgKGFkZERpc2FsbG93ZWRPcmlnaW5Ub01hcCk6CisgICAgICAgICh3ZWJr aXRfd2ViX2NvbnRleHRfc2V0X2luaXRpYWxfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25zKToKKyAg ICAgICAgKHdlYmtpdFdlYkNvbnRleHRTZXRJbml0aWFsTm90aWZpY2F0aW9uUGVybWlzc2lvbnMp OgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQuaDoKKyAgICAg ICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0UHJpdmF0ZS5oOgorICAgICAg ICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0Ogor ICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1kb2NzLnNnbWw6Cisg ICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvd2Via2l0Mi5oOgorCiAyMDE2LTEyLTI3ICBBbGV4 IENocmlzdGVuc2VuICA8YWNocmlzdGVuc2VuQHdlYmtpdC5vcmc+CiAKICAgICAgICAgcmVkdWNl IFBhc3NSZWZQdHIgdXNlIGluIFdlYktpdDIKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1Bs YXRmb3JtR1RLLmNtYWtlIGIvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UKaW5kZXgg MGE1ZTRkNGFlM2ZmOTA3MmFiZmQyNTlkNTM2ZjdiYzFjODljMWVmMy4uNDgzODQ3ODMxNDliZDA5 MjE3MjhiOGJmZmI3ZTI0NGI0NzFjZmQ4MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvUGxh dGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UKQEAg LTIyMCw2ICsyMjAsOSBAQCBsaXN0KEFQUEVORCBXZWJLaXQyX1NPVVJDRVMKICAgICBVSVByb2Nl c3MvQVBJL2d0ay9XZWJLaXRTZWN1cml0eU1hbmFnZXIuY3BwCiAgICAgVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0U2VjdXJpdHlNYW5hZ2VyLmgKICAgICBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRT ZWN1cml0eU1hbmFnZXJQcml2YXRlLmgKKyAgICBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRTZWN1 cml0eU9yaWdpbi5jcHAKKyAgICBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRTZWN1cml0eU9yaWdp bi5oCisgICAgVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2VjdXJpdHlPcmlnaW5Qcml2YXRlLmgK ICAgICBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRTZXR0aW5ncy5jcHAKICAgICBVSVByb2Nlc3Mv QVBJL2d0ay9XZWJLaXRTZXR0aW5ncy5oCiAgICAgVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2V0 dGluZ3NQcml2YXRlLmgKQEAgLTUzNCw2ICs1MzcsNyBAQCBzZXQoV2ViS2l0MkdUS19JTlNUQUxM RURfSEVBREVSUwogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFJl c3BvbnNlUG9saWN5RGVjaXNpb24uaAogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9BUEkv Z3RrL1dlYktpdFNjcmlwdERpYWxvZy5oCiAgICAgJHtXRUJLSVQyX0RJUn0vVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0U2VjdXJpdHlNYW5hZ2VyLmgKKyAgICAke1dFQktJVDJfRElSfS9VSVByb2Nl c3MvQVBJL2d0ay9XZWJLaXRTZWN1cml0eU9yaWdpbi5oCiAgICAgJHtXRUJLSVQyX0RJUn0vVUlQ cm9jZXNzL0FQSS9ndGsvV2ViS2l0U2V0dGluZ3MuaAogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFVSSVJlcXVlc3QuaAogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFVSSVJlc3BvbnNlLmgKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEF1dG9jbGVhbnVwcy5oIGIvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0QXV0b2NsZWFudXBzLmgKaW5kZXggZjg3MmYzMDY4 MTBjMTFhYWJkMjg0NGEwZjgzYzE1YWZmNTYwYmMzZi4uN2IwN2U4OTViMGJjNzZjNjc0NGZiMmRj YWMwMzgxOTc4ZmVmNDM0MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0QXV0b2NsZWFudXBzLmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L0FQSS9ndGsvV2ViS2l0QXV0b2NsZWFudXBzLmgKQEAgLTc1LDYgKzc1LDcgQEAgR19ERUZJTkVf QVVUT1BUUl9DTEVBTlVQX0ZVTkMgKFdlYktpdENyZWRlbnRpYWwsIHdlYmtpdF9jcmVkZW50aWFs X2ZyZWUpCiBHX0RFRklORV9BVVRPUFRSX0NMRUFOVVBfRlVOQyAoV2ViS2l0SmF2YXNjcmlwdFJl c3VsdCwgd2Via2l0X2phdmFzY3JpcHRfcmVzdWx0X3VucmVmKQogR19ERUZJTkVfQVVUT1BUUl9D TEVBTlVQX0ZVTkMgKFdlYktpdE1pbWVJbmZvLCB3ZWJraXRfbWltZV9pbmZvX3VucmVmKQogR19E RUZJTkVfQVVUT1BUUl9DTEVBTlVQX0ZVTkMgKFdlYktpdE5hdmlnYXRpb25BY3Rpb24sIHdlYmtp dF9uYXZpZ2F0aW9uX2FjdGlvbl9mcmVlKQorR19ERUZJTkVfQVVUT1BUUl9DTEVBTlVQX0ZVTkMg KFdlYktpdFNlY3VyaXR5T3JpZ2luLCB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3VucmVmKQogR19E RUZJTkVfQVVUT1BUUl9DTEVBTlVQX0ZVTkMgKFdlYktpdFVzZXJTY3JpcHQsIHdlYmtpdF91c2Vy X3NjcmlwdF91bnJlZikKIEdfREVGSU5FX0FVVE9QVFJfQ0xFQU5VUF9GVU5DIChXZWJLaXRVc2Vy U3R5bGVTaGVldCwgd2Via2l0X3VzZXJfc3R5bGVfc2hlZXRfdW5yZWYpCiBHX0RFRklORV9BVVRP UFRSX0NMRUFOVVBfRlVOQyAoV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSwgd2Via2l0X3dlYl92 aWV3X3Nlc3Npb25fc3RhdGVfdW5yZWYpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5jcHAgYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5jcHAKaW5k ZXggYTgwZTY4Njc3OTkwMGFiZGIwMTE1MGFiZjJmMzkwYzE4YWYwN2RhOC4uMDVmMGI4MWJjMDQy MzY1ZTBhNDA5ODhmYjAyZGZjZjBjZWI5ZmE1NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVy LmNwcApAQCAtMjgsOCArMjgsMTAgQEAKICNpbmNsdWRlICJXZWJLaXROb3RpZmljYXRpb25Qcm92 aWRlci5oIgogCiAjaW5jbHVkZSAiQVBJQXJyYXkuaCIKKyNpbmNsdWRlICJBUElEaWN0aW9uYXJ5 LmgiCiAjaW5jbHVkZSAiV0tOb3RpZmljYXRpb25NYW5hZ2VyLmgiCiAjaW5jbHVkZSAiV2ViS2l0 Tm90aWZpY2F0aW9uUHJpdmF0ZS5oIgorI2luY2x1ZGUgIldlYktpdFdlYkNvbnRleHRQcml2YXRl LmgiCiAjaW5jbHVkZSAiV2ViS2l0V2ViVmlld1ByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJOb3Rp ZmljYXRpb25NYW5hZ2VyUHJveHkuaCIKICNpbmNsdWRlICJXZWJQYWdlUHJveHkuaCIKQEAgLTUy LDYgKzU0LDExIEBAIHN0YXRpYyB2b2lkIGNhbmNlbENhbGxiYWNrKFdLTm90aWZpY2F0aW9uUmVm IG5vdGlmaWNhdGlvbiwgY29uc3Qgdm9pZCogY2xpZW50SW5mCiAgICAgdG9Ob3RpZmljYXRpb25Q cm92aWRlcihjbGllbnRJbmZvKS0+Y2FuY2VsKCp0b0ltcGwobm90aWZpY2F0aW9uKSk7CiB9CiAK K3N0YXRpYyBXS0RpY3Rpb25hcnlSZWYgbm90aWZpY2F0aW9uUGVybWlzc2lvbnNDYWxsYmFjayhj b25zdCB2b2lkKiBjbGllbnRJbmZvKQoreworICAgIHJldHVybiB0b0FQSSh0b05vdGlmaWNhdGlv blByb3ZpZGVyKGNsaWVudEluZm8pLT5ub3RpZmljYXRpb25QZXJtaXNzaW9ucygpLmxlYWtSZWYo KSk7Cit9CisKIHN0YXRpYyB2b2lkIGNsZWFyTm90aWZpY2F0aW9uc0NhbGxiYWNrKFdLQXJyYXlS ZWYgbm90aWZpY2F0aW9uSURzLCBjb25zdCB2b2lkKiBjbGllbnRJbmZvKQogewogICAgIHRvTm90 aWZpY2F0aW9uUHJvdmlkZXIoY2xpZW50SW5mbyktPmNsZWFyTm90aWZpY2F0aW9ucyh0b0ltcGwo bm90aWZpY2F0aW9uSURzKSk7CkBAIC02MSwxMyArNjgsMTQgQEAgV2ViS2l0Tm90aWZpY2F0aW9u UHJvdmlkZXI6On5XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcigpCiB7CiB9CiAKLVJlZjxXZWJL aXROb3RpZmljYXRpb25Qcm92aWRlcj4gV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI6OmNyZWF0 ZShXZWJOb3RpZmljYXRpb25NYW5hZ2VyUHJveHkqIG5vdGlmaWNhdGlvbk1hbmFnZXIpCitSZWY8 V2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI+IFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyOjpj cmVhdGUoV2ViTm90aWZpY2F0aW9uTWFuYWdlclByb3h5KiBub3RpZmljYXRpb25NYW5hZ2VyLCBX ZWJLaXRXZWJDb250ZXh0KiB3ZWJDb250ZXh0KQogewotICAgIHJldHVybiBhZG9wdFJlZigqbmV3 IFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyKG5vdGlmaWNhdGlvbk1hbmFnZXIpKTsKKyAgICBy ZXR1cm4gYWRvcHRSZWYoKm5ldyBXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcihub3RpZmljYXRp b25NYW5hZ2VyLCB3ZWJDb250ZXh0KSk7CiB9CiAKLVdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVy OjpXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcihXZWJOb3RpZmljYXRpb25NYW5hZ2VyUHJveHkq IG5vdGlmaWNhdGlvbk1hbmFnZXIpCi0gICAgOiBtX25vdGlmaWNhdGlvbk1hbmFnZXIobm90aWZp Y2F0aW9uTWFuYWdlcikKK1dlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyOjpXZWJLaXROb3RpZmlj YXRpb25Qcm92aWRlcihXZWJOb3RpZmljYXRpb25NYW5hZ2VyUHJveHkqIG5vdGlmaWNhdGlvbk1h bmFnZXIsIFdlYktpdFdlYkNvbnRleHQqIHdlYkNvbnRleHQpCisgICAgOiBtX3dlYkNvbnRleHQo d2ViQ29udGV4dCkKKyAgICAsIG1fbm90aWZpY2F0aW9uTWFuYWdlcihub3RpZmljYXRpb25NYW5h Z2VyKQogewogICAgIEFTU0VSVChub3RpZmljYXRpb25NYW5hZ2VyKTsKIApAQCAtODEsNyArODks NyBAQCBXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcjo6V2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlk ZXIoV2ViTm90aWZpY2F0aW9uTWFuYWdlclBybwogICAgICAgICAwLCAvLyBkaWREZXN0cm95Tm90 aWZpY2F0aW9uQ2FsbGJhY2ssCiAgICAgICAgIDAsIC8vIGFkZE5vdGlmaWNhdGlvbk1hbmFnZXJD YWxsYmFjaywKICAgICAgICAgMCwgLy8gcmVtb3ZlTm90aWZpY2F0aW9uTWFuYWdlckNhbGxiYWNr LAotICAgICAgICAwLCAvLyBub3RpZmljYXRpb25QZXJtaXNzaW9uc0NhbGxiYWNrLAorICAgICAg ICBub3RpZmljYXRpb25QZXJtaXNzaW9uc0NhbGxiYWNrLAogICAgICAgICBjbGVhck5vdGlmaWNh dGlvbnNDYWxsYmFjaywKICAgICB9OwogCkBAIC0xNTIsMyArMTYwLDE0IEBAIHZvaWQgV2ViS2l0 Tm90aWZpY2F0aW9uUHJvdmlkZXI6OmNsZWFyTm90aWZpY2F0aW9ucyhjb25zdCBBUEk6OkFycmF5 KiBub3RpZmljYXRpCiAgICAgZm9yIChjb25zdCBhdXRvJiBpdGVtIDogbm90aWZpY2F0aW9uSURz LT5lbGVtZW50c09mVHlwZTxBUEk6OlVJbnQ2ND4oKSkKICAgICAgICAgY2FuY2VsTm90aWZpY2F0 aW9uQnlJRChpdGVtLT52YWx1ZSgpKTsKIH0KKworUmVmUHRyPEFQSTo6RGljdGlvbmFyeT4gV2Vi S2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI6Om5vdGlmaWNhdGlvblBlcm1pc3Npb25zKCkKK3sKKyAg ICB3ZWJraXRXZWJDb250ZXh0U2V0SW5pdGlhbE5vdGlmaWNhdGlvblBlcm1pc3Npb25zKG1fd2Vi Q29udGV4dCk7CisgICAgcmV0dXJuIG1fbm90aWZpY2F0aW9uUGVybWlzc2lvbnM7Cit9CisKK3Zv aWQgV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI6OnNldE5vdGlmaWNhdGlvblBlcm1pc3Npb25z KEhhc2hNYXA8U3RyaW5nLCBSZWZQdHI8QVBJOjpPYmplY3Q+PiYmIHBlcm1pc3Npb25zTWFwKQor eworICAgIG1fbm90aWZpY2F0aW9uUGVybWlzc2lvbnMgPSBBUEk6OkRpY3Rpb25hcnk6OmNyZWF0 ZShXVEZNb3ZlKHBlcm1pc3Npb25zTWFwKSk7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5oIGIvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuaApp bmRleCAyODk0YmEwMDU0M2EwMjQyN2Q5ZmY5MzgxMWNhMTYzZmQ5Njg0Mjg3Li40OWM5YjlhYWZm NWI4ODFkZDJlYmI1MGQ5NjJkMmZmMDVkNGQxODc4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5oCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVy LmgKQEAgLTIyLDYgKzIyLDcgQEAKIAogI2luY2x1ZGUgIldlYktpdFByaXZhdGUuaCIKICNpbmNs dWRlICJXZWJLaXROb3RpZmljYXRpb24uaCIKKyNpbmNsdWRlICJXZWJLaXRXZWJDb250ZXh0Lmgi CiAjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvUmVmLmg+CiAjaW5jbHVk ZSA8d3RmL1JlZkNvdW50ZWQuaD4KQEAgLTM1LDE0ICszNiwxNyBAQCBuYW1lc3BhY2UgV2ViS2l0 IHsKIGNsYXNzIFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyIDogcHVibGljIFJlZkNvdW50ZWQ8 V2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI+IHsKIHB1YmxpYzoKICAgICB2aXJ0dWFsIH5XZWJL aXROb3RpZmljYXRpb25Qcm92aWRlcigpOwotICAgIHN0YXRpYyBSZWY8V2ViS2l0Tm90aWZpY2F0 aW9uUHJvdmlkZXI+IGNyZWF0ZShXZWJOb3RpZmljYXRpb25NYW5hZ2VyUHJveHkqKTsKKyAgICBz dGF0aWMgUmVmPFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyPiBjcmVhdGUoV2ViTm90aWZpY2F0 aW9uTWFuYWdlclByb3h5KiwgV2ViS2l0V2ViQ29udGV4dCopOwogCiAgICAgdm9pZCBzaG93KFdl YlBhZ2VQcm94eSosIGNvbnN0IFdlYk5vdGlmaWNhdGlvbiYpOwogICAgIHZvaWQgY2FuY2VsKGNv bnN0IFdlYk5vdGlmaWNhdGlvbiYpOwogICAgIHZvaWQgY2xlYXJOb3RpZmljYXRpb25zKGNvbnN0 IEFQSTo6QXJyYXkqKTsKIAorICAgIFJlZlB0cjxBUEk6OkRpY3Rpb25hcnk+IG5vdGlmaWNhdGlv blBlcm1pc3Npb25zKCk7CisgICAgdm9pZCBzZXROb3RpZmljYXRpb25QZXJtaXNzaW9ucyhIYXNo TWFwPFN0cmluZywgUmVmUHRyPEFQSTo6T2JqZWN0Pj4mJik7CisKIHByaXZhdGU6Ci0gICAgV2Vi S2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIoV2ViTm90aWZpY2F0aW9uTWFuYWdlclByb3h5Kik7Cisg ICAgV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIoV2ViTm90aWZpY2F0aW9uTWFuYWdlclByb3h5 KiwgV2ViS2l0V2ViQ29udGV4dCopOwogCiAgICAgdm9pZCBjYW5jZWxOb3RpZmljYXRpb25CeUlE KHVpbnQ2NF90KTsKICAgICBzdGF0aWMgdm9pZCBub3RpZmljYXRpb25DbG9zZUNhbGxiYWNrKFdl YktpdE5vdGlmaWNhdGlvbiosIFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyKik7CkBAIC01MCw2 ICs1NCw4IEBAIHByaXZhdGU6CiAKICAgICB2b2lkIHdpdGhkcmF3QW55UHJldmlvdXNOb3RpZmlj YXRpb25NYXRjaGluZ1RhZyhjb25zdCBDU3RyaW5nJik7CiAKKyAgICBXZWJLaXRXZWJDb250ZXh0 KiBtX3dlYkNvbnRleHQ7CisgICAgUmVmUHRyPEFQSTo6RGljdGlvbmFyeT4gbV9ub3RpZmljYXRp b25QZXJtaXNzaW9uczsKICAgICBSZWZQdHI8V2ViTm90aWZpY2F0aW9uTWFuYWdlclByb3h5PiBt X25vdGlmaWNhdGlvbk1hbmFnZXI7CiAgICAgSGFzaE1hcDx1aW50NjRfdCwgR1JlZlB0cjxXZWJL aXROb3RpZmljYXRpb24+PiBtX25vdGlmaWNhdGlvbnM7CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2VjdXJpdHlPcmlnaW4uY3BwIGIvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2VjdXJpdHlPcmlnaW4uY3BwCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLjI3Y2JiNDgzZTQxYWQxYjg0NzBmZDcyMjExYmRmODE0NWZmNjdjNWIKLS0tIC9k ZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRTZWN1 cml0eU9yaWdpbi5jcHAKQEAgLTAsMCArMSwyNDUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MTcgSWdhbGlhIFMuTC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1l dDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGlu IHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVE IEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5Z IEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRF RCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5P IEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxF IEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZ LCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRF RCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExP U1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9O KSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIg SU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVH TElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBV U0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJ VFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUg IldlYktpdFNlY3VyaXR5T3JpZ2luLmgiCisKKyNpbmNsdWRlICJXZWJLaXRTZWN1cml0eU9yaWdp blByaXZhdGUuaCIKKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CisKK3VzaW5nIG5hbWVz cGFjZSBXZWJLaXQ7CisKKy8qKgorICogU0VDVElPTjogV2ViS2l0U2VjdXJpdHlPcmlnaW4KKyAq IEBTaG9ydF9kZXNjcmlwdGlvbjogQSBzZWN1cml0eSBib3VuZGFyeSBmb3Igd2Vic2l0ZXMKKyAq IEBUaXRsZTogV2ViS2l0U2VjdXJpdHlPcmlnaW4KKyAqIEBTZWVfYWxzbzogI1dlYktpdFdlYnNp dGVEYXRhTWFuYWdlciwgI1dlYktpdFNlY3VyaXR5TWFuYWdlcgorICoKKyAqIFdlYktpdFNlY3Vy aXR5T3JpZ2luIGlzIGEgcmVwcmVzZW50YXRpb24gb2YgYSBzZWN1cml0eSBkb21haW4gZGVmaW5l ZAorICogYnkgd2Vic2l0ZXMuIEFuIG9yaWdpbiBjb25zaXN0cyBvZiBhIGhvc3RuYW1lLCBhIHBy b3RvY29sLCBhbmQgYSBwb3J0CisgKiBudW1iZXIuIFdlYnNpdGVzIHdpdGggdGhlIHNhbWUgc2Vj dXJpdHkgb3JpZ2luIGNhbiBhY2Nlc3MgZWFjaCBvdGhlcidzCisgKiByZXNvdXJjZXMgZm9yIGNs aWVudC1zaWRlIHNjcmlwdGluZyBvciBkYXRhYmFzZSBhY2Nlc3MuCisgKgorICogU2luY2U6IDIu MTYKKyAqLworCitzdHJ1Y3QgX1dlYktpdFNlY3VyaXR5T3JpZ2luIHsKKyAgICBfV2ViS2l0U2Vj dXJpdHlPcmlnaW4oV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4qIGNvcmVTZWN1cml0eU9yaWdpbikK KyAgICAgICAgOiBzZWN1cml0eU9yaWdpbihjb3JlU2VjdXJpdHlPcmlnaW4pCisgICAgeworICAg IH0KKworICAgIF9XZWJLaXRTZWN1cml0eU9yaWdpbihSZWY8V2ViQ29yZTo6U2VjdXJpdHlPcmln aW4+JiYgY29yZVNlY3VyaXR5T3JpZ2luKQorICAgICAgICA6IHNlY3VyaXR5T3JpZ2luKFdURk1v dmUoY29yZVNlY3VyaXR5T3JpZ2luKSkKKyAgICB7CisgICAgfQorCisgICAgUmVmUHRyPFdlYkNv cmU6OlNlY3VyaXR5T3JpZ2luPiBzZWN1cml0eU9yaWdpbjsKKyAgICBDU3RyaW5nIHByb3RvY29s OworICAgIENTdHJpbmcgaG9zdDsKKyAgICBDU3RyaW5nIGFzU3RyaW5nOworICAgIGludCByZWZl cmVuY2VDb3VudDsKK307CisKK0dfREVGSU5FX0JPWEVEX1RZUEUoV2ViS2l0U2VjdXJpdHlPcmln aW4sIHdlYmtpdF9zZWN1cml0eV9vcmlnaW4sIHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fcmVmLCB3 ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3VucmVmKQorCitXZWJLaXRTZWN1cml0eU9yaWdpbiogd2Vi a2l0U2VjdXJpdHlPcmlnaW5DcmVhdGUoV2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4qIGNvcmVTZWN1 cml0eU9yaWdpbikKK3sKKyAgICBXZWJLaXRTZWN1cml0eU9yaWdpbiogb3JpZ2luID0gc3RhdGlj X2Nhc3Q8V2ViS2l0U2VjdXJpdHlPcmlnaW4qPihmYXN0TWFsbG9jKHNpemVvZihXZWJLaXRTZWN1 cml0eU9yaWdpbikpKTsKKyAgICBuZXcgKG9yaWdpbikgV2ViS2l0U2VjdXJpdHlPcmlnaW4oY29y ZVNlY3VyaXR5T3JpZ2luKTsKKyAgICByZXR1cm4gb3JpZ2luOworfQorCitXZWJLaXRTZWN1cml0 eU9yaWdpbiogd2Via2l0U2VjdXJpdHlPcmlnaW5DcmVhdGUoUmVmPFdlYkNvcmU6OlNlY3VyaXR5 T3JpZ2luPiYmIGNvcmVTZWN1cml0eU9yaWdpbikKK3sKKyAgICBXZWJLaXRTZWN1cml0eU9yaWdp biogb3JpZ2luID0gc3RhdGljX2Nhc3Q8V2ViS2l0U2VjdXJpdHlPcmlnaW4qPihmYXN0TWFsbG9j KHNpemVvZihXZWJLaXRTZWN1cml0eU9yaWdpbikpKTsKKyAgICBuZXcgKG9yaWdpbikgV2ViS2l0 U2VjdXJpdHlPcmlnaW4oV1RGTW92ZShjb3JlU2VjdXJpdHlPcmlnaW4pKTsKKyAgICByZXR1cm4g b3JpZ2luOworfQorCitXZWJDb3JlOjpTZWN1cml0eU9yaWdpbiYgd2Via2l0U2VjdXJpdHlPcmln aW5HZXRTZWN1cml0eU9yaWdpbihXZWJLaXRTZWN1cml0eU9yaWdpbiogb3JpZ2luKQoreworICAg IEFTU0VSVChvcmlnaW4pOworICAgIHJldHVybiAqb3JpZ2luLT5zZWN1cml0eU9yaWdpbjsKK30K KworLyoqCisgKiB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX25ldzoKKyAqIEBwcm90b2NvbDogVGhl IHByb3RvY29sIGZvciB0aGUgbmV3IG9yaWdpbgorICogQGhvc3Q6IFRoZSBob3N0IGZvciB0aGUg bmV3IG9yaWdpbgorICogQHBvcnQ6IFRoZSBwb3J0IG51bWJlciBmb3IgdGhlIG5ldyBvcmlnaW4K KyAqCisgKiBDcmVhdGUgYSBuZXcgc2VjdXJpdHkgb3JpZ2luIGZyb20gdGhlIHByb3ZpZGVkIHBy b3RvY29sLCBob3N0IGFuZCBwb3J0LgorICoKKyAqIFJldHVybnM6ICh0cmFuc2ZlciBmdWxsKTog QSAjV2ViS2l0U2VjdXJpdHlPcmlnaW4uCisgKgorICogU2luY2U6IDIuMTYKKyAqLworV2ViS2l0 U2VjdXJpdHlPcmlnaW4qIHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fbmV3KGNvbnN0IGdjaGFyKiBw cm90b2NvbCwgY29uc3QgZ2NoYXIqIGhvc3QsIGd1aW50IHBvcnQpCit7CisgICAgZ19yZXR1cm5f dmFsX2lmX2ZhaWwocHJvdG9jb2wsIG51bGxwdHIpOworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWls KGhvc3QsIG51bGxwdHIpOworCisgICAgcmV0dXJuIHdlYmtpdFNlY3VyaXR5T3JpZ2luQ3JlYXRl KFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luOjpjcmVhdGUoU3RyaW5nOjpmcm9tVVRGOChwcm90b2Nv bCksIFN0cmluZzo6ZnJvbVVURjgoaG9zdCksIHBvcnQpKTsKK30KKworLyoqCisgKiB3ZWJraXRf c2VjdXJpdHlfb3JpZ2luX25ld19mcm9tX3N0cmluZzoKKyAqIEB1cmk6IFRoZSBVUkkgZm9yIHRo ZSBuZXcgb3JpZ2luCisgKgorICogQ3JlYXRlIGEgbmV3IHNlY3VyaXR5IG9yaWdpbiBmcm9tIHRo ZSBwcm92aWRlZCBVUkkuIENvbXBvbmVudHMgb2YKKyAqIEB1cmkgb3RoZXIgdGhhbiBwcm90b2Nv bCwgaG9zdCwgYW5kIHBvcnQgd2lsbCBiZSBpZ25vcmVkLgorICoKKyAqIFJldHVybnM6ICh0cmFu c2ZlciBmdWxsKTogQSAjV2ViS2l0U2VjdXJpdHlPcmlnaW4uCisgKgorICogU2luY2U6IDIuMTYK KyAqLworV2ViS2l0U2VjdXJpdHlPcmlnaW4qIHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fbmV3X2Zy b21fc3RyaW5nKGNvbnN0IGdjaGFyKiB1cmkpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwo dXJpLCBudWxscHRyKTsKKworICAgIHJldHVybiB3ZWJraXRTZWN1cml0eU9yaWdpbkNyZWF0ZShX ZWJDb3JlOjpTZWN1cml0eU9yaWdpbjo6Y3JlYXRlRnJvbVN0cmluZyhTdHJpbmc6OmZyb21VVEY4 KHVyaSkpKTsKK30KKworLyoqCisgKiB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3JlZjoKKyAqIEBv cmlnaW46IGEgI1dlYktpdFNlY3VyaXR5T3JpZ2luCisgKgorICogQXRvbWljYWxseSBpbmNyZW1l bnRzIHRoZSByZWZlcmVuY2UgY291bnQgb2YgQG9yaWdpbiBieSBvbmUuCisgKiBUaGlzIGZ1bmN0 aW9uIGlzIE1ULXNhZmUgYW5kIG1heSBiZSBjYWxsZWQgZnJvbSBhbnkgdGhyZWFkLgorICoKKyAq IFJldHVybnM6IFRoZSBwYXNzZWQgI1dlYktpdFNlY3VyaXR5T3JpZ2luCisgKgorICogU2luY2U6 IDIuMTYKKyAqLworV2ViS2l0U2VjdXJpdHlPcmlnaW4qIHdlYmtpdF9zZWN1cml0eV9vcmlnaW5f cmVmKFdlYktpdFNlY3VyaXR5T3JpZ2luKiBvcmlnaW4pCit7CisgICAgZ19yZXR1cm5fdmFsX2lm X2ZhaWwob3JpZ2luLCBudWxscHRyKTsKKworICAgIGdfYXRvbWljX2ludF9pbmMoJm9yaWdpbi0+ cmVmZXJlbmNlQ291bnQpOworICAgIHJldHVybiBvcmlnaW47Cit9CisKKy8qKgorICogd2Via2l0 X3NlY3VyaXR5X29yaWdpbl91bnJlZjoKKyAqIEBvcmlnaW46IEEgI1dlYktpdFNlY3VyaXR5T3Jp Z2luCisgKgorICogQXRvbWljYWxseSBkZWNyZW1lbnRzIHRoZSByZWZlcmVuY2UgY291bnQgb2Yg QG9yaWdpbiBieSBvbmUuCisgKiBJZiB0aGUgcmVmZXJlbmNlIGNvdW50IGRyb3BzIHRvIDAsIGFs bCBtZW1vcnkgYWxsb2NhdGVkIGJ5CisgKiAjV2ViS2l0U2VjdXJpdHlPcmlnaW4gaXMgcmVsZWFz ZWQuIFRoaXMgZnVuY3Rpb24gaXMgTVQtc2FmZSBhbmQgbWF5IGJlCisgKiBjYWxsZWQgZnJvbSBh bnkgdGhyZWFkLgorICoKKyAqIFNpbmNlOiAyLjE2CisgKi8KK3ZvaWQgd2Via2l0X3NlY3VyaXR5 X29yaWdpbl91bnJlZihXZWJLaXRTZWN1cml0eU9yaWdpbiogb3JpZ2luKQoreworICAgIGdfcmV0 dXJuX2lmX2ZhaWwob3JpZ2luKTsKKworICAgIGlmIChnX2F0b21pY19pbnRfZGVjX2FuZF90ZXN0 KCZvcmlnaW4tPnJlZmVyZW5jZUNvdW50KSkgeworICAgICAgICBvcmlnaW4tPn5XZWJLaXRTZWN1 cml0eU9yaWdpbigpOworICAgICAgICBmYXN0RnJlZShvcmlnaW4pOworICAgIH0KK30KKworLyoq CisgKiB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dldF9wcm90b2NvbDoKKyAqIEBvcmlnaW46IGEg I1dlYktpdFNlY3VyaXR5T3JpZ2luCisgKgorICogR2V0IHRoZSBwcm90b2NvbCBvZiBAb3JpZ2lu CisgKgorICogUmV0dXJuczogVGhlIHByb3RvY29sIG9mIHRoZSAjV2ViS2l0U2VjdXJpdHlPcmln aW4uCisgKgorICogU2luY2U6IDIuMTYKKyAqLworY29uc3QgZ2NoYXIqIHdlYmtpdF9zZWN1cml0 eV9vcmlnaW5fZ2V0X3Byb3RvY29sKFdlYktpdFNlY3VyaXR5T3JpZ2luKiBvcmlnaW4pCit7Cisg ICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwob3JpZ2luLCBudWxscHRyKTsKKworICAgIGlmIChvcmln aW4tPnByb3RvY29sLmlzTnVsbCgpKQorICAgICAgICBvcmlnaW4tPnByb3RvY29sID0gb3JpZ2lu LT5zZWN1cml0eU9yaWdpbi0+cHJvdG9jb2woKS51dGY4KCk7CisgICAgcmV0dXJuIG9yaWdpbi0+ cHJvdG9jb2wuZGF0YSgpOworfQorCisvKioKKyAqIHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0 X2hvc3Q6CisgKiBAb3JpZ2luOiBhICNXZWJLaXRTZWN1cml0eU9yaWdpbgorICoKKyAqIEdldCB0 aGUgaG9zdCBvZiBAb3JpZ2luCisgKgorICogUmV0dXJuczogKGFsbG93LW5vbmUpOiBUaGUgaG9z dCBvZiB0aGUgI1dlYktpdFNlY3VyaXR5T3JpZ2luLCBvciAlTlVMTC4KKyAqCisgKiBTaW5jZTog Mi4xNgorICovCitjb25zdCBnY2hhciogd2Via2l0X3NlY3VyaXR5X29yaWdpbl9nZXRfaG9zdChX ZWJLaXRTZWN1cml0eU9yaWdpbiogb3JpZ2luKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWls KG9yaWdpbiwgbnVsbHB0cik7CisKKyAgICBpZiAob3JpZ2luLT5zZWN1cml0eU9yaWdpbi0+aG9z dCgpLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisKKyAgICBpZiAob3JpZ2lu LT5ob3N0LmlzTnVsbCgpKQorICAgICAgICBvcmlnaW4tPmhvc3QgPSBvcmlnaW4tPnNlY3VyaXR5 T3JpZ2luLT5ob3N0KCkudXRmOCgpOworICAgIHJldHVybiBvcmlnaW4tPmhvc3QuZGF0YSgpOwor fQorCisvKioKKyAqIHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0X3BvcnQ6CisgKiBAb3JpZ2lu OiBhICNXZWJLaXRTZWN1cml0eU9yaWdpbgorICoKKyAqIEdldCB0aGUgcG9ydCBvZiBAb3JpZ2lu CisgKgorICogUmV0dXJuczogVGhlIHBvcnQgb2YgdGhlICNXZWJLaXRTZWN1cml0eU9yaWdpbi4K KyAqCisgKiBTaW5jZTogMi4xNgorICovCitndWludCB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dl dF9wb3J0KFdlYktpdFNlY3VyaXR5T3JpZ2luKiBvcmlnaW4pCit7CisgICAgZ19yZXR1cm5fdmFs X2lmX2ZhaWwob3JpZ2luLCAwKTsKKworICAgIGlmIChhdXRvIHBvcnQgPSBvcmlnaW4tPnNlY3Vy aXR5T3JpZ2luLT5wb3J0KCkpCisgICAgICAgIHJldHVybiAqcG9ydDsKKyAgICByZXR1cm4gMDsK K30KKworLyoqCisgKiB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3RvX3N0cmluZzoKKyAqIEBvcmln aW46IGEgI1dlYktpdFNlY3VyaXR5T3JpZ2luCisgKgorICogR2V0IGEgc3RyaW5nIHJlcHJlc2Vu dGF0aW9uIG9mIEBvcmlnaW4uIEJlIGF3YXJlIHRoYXQgdGhpcyBmdW5jdGlvbgorICogbWF5IHJl dHVybiAlTlVMTCBpZiB0aGUgb3JpZ2luIGlzIHVuaXF1ZS4gKEZvciBleGFtcGxlLCB0aGlzIHdp bGwKKyAqIG9jY3VyIGlmIEBvcmlnaW4gcmVwcmVzZW50cyBhIHNhbmRib3hlZCBpZnJhbWUuKQor ICoKKyAqIFJldHVybnM6IChhbGxvdy1ub25lKTogYSBzdHJpbmcgcmVwcmVzZW50YXRpb24gb2Yg QG9yaWdpbi4KKyAqCisgKiBTaW5jZTogMi4xNgorICovCitjb25zdCBnY2hhciogd2Via2l0X3Nl Y3VyaXR5X29yaWdpbl90b19zdHJpbmcoV2ViS2l0U2VjdXJpdHlPcmlnaW4qIG9yaWdpbikKK3sK KyAgICBnX3JldHVybl92YWxfaWZfZmFpbChvcmlnaW4sIG51bGxwdHIpOworCisgICAgaWYgKG9y aWdpbi0+YXNTdHJpbmcuaXNOdWxsKCkpCisgICAgICAgIG9yaWdpbi0+YXNTdHJpbmcgPSBvcmln aW4tPnNlY3VyaXR5T3JpZ2luLT50b1N0cmluZygpLnV0ZjgoKTsKKyAgICByZXR1cm4gb3JpZ2lu LT5hc1N0cmluZyA9PSAibnVsbCIgPyBudWxscHRyIDogb3JpZ2luLT5hc1N0cmluZy5kYXRhKCk7 Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRT ZWN1cml0eU9yaWdpbi5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0 U2VjdXJpdHlPcmlnaW4uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40NjI4NzQ1ZDRhMTA0MTQzMjUzM2YyYzRmNDc1 OTU3MmJlZTIzODhkCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L0FQSS9ndGsvV2ViS2l0U2VjdXJpdHlPcmlnaW4uaApAQCAtMCwwICsxLDczIEBACisvKgorICog Q29weXJpZ2h0IChDKSAyMDE3IElnYWxpYSBTLkwuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMg SVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNI QU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBE SVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRP UlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RT IE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MK KyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElB QklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9S VCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkg V0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgor ICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZiAhZGVmaW5lZChf X1dFQktJVDJfSF9JTlNJREVfXykgJiYgIWRlZmluZWQoV0VCS0lUMl9DT01QSUxBVElPTikKKyNl cnJvciAiT25seSA8d2Via2l0Mi93ZWJraXQyLmg+IGNhbiBiZSBpbmNsdWRlZCBkaXJlY3RseS4i CisjZW5kaWYKKworI2lmbmRlZiBXZWJLaXRTZWN1cml0eU9yaWdpbl9oCisjZGVmaW5lIFdlYktp dFNlY3VyaXR5T3JpZ2luX2gKKworI2luY2x1ZGUgPGdsaWItb2JqZWN0Lmg+CisjaW5jbHVkZSA8 d2Via2l0Mi9XZWJLaXREZWZpbmVzLmg+CisKK0dfQkVHSU5fREVDTFMKKworI2RlZmluZSBXRUJL SVRfVFlQRV9TRUNVUklUWV9PUklHSU4gKHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0X3R5cGUo KSkKKwordHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFNlY3VyaXR5T3JpZ2luIFdlYktpdFNlY3VyaXR5 T3JpZ2luOworCitXRUJLSVRfQVBJIEdUeXBlCit3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dldF90 eXBlICAgICAgICAodm9pZCk7CisKK1dFQktJVF9BUEkgV2ViS2l0U2VjdXJpdHlPcmlnaW4gKgor d2Via2l0X3NlY3VyaXR5X29yaWdpbl9uZXcgICAgICAgICAgICAgKGNvbnN0IGdjaGFyICAgICAg ICAgICpwcm90b2NvbCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBj b25zdCBnY2hhciAgICAgICAgICAqaG9zdCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBndWludCAgICAgICAgICAgICAgICAgcG9ydCk7CisKK1dFQktJVF9BUEkgV2Vi S2l0U2VjdXJpdHlPcmlnaW4gKgord2Via2l0X3NlY3VyaXR5X29yaWdpbl9uZXdfZnJvbV9zdHJp bmcgKGNvbnN0IGdjaGFyICAgICAgICAgICp1cmkpOworCitXRUJLSVRfQVBJIFdlYktpdFNlY3Vy aXR5T3JpZ2luICoKK3dlYmtpdF9zZWN1cml0eV9vcmlnaW5fcmVmICAgICAgICAgICAgIChXZWJL aXRTZWN1cml0eU9yaWdpbiAqb3JpZ2luKTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfc2Vj dXJpdHlfb3JpZ2luX3VucmVmICAgICAgICAgICAoV2ViS2l0U2VjdXJpdHlPcmlnaW4gKm9yaWdp bik7CisKK1dFQktJVF9BUEkgY29uc3QgZ2NoYXIgKgord2Via2l0X3NlY3VyaXR5X29yaWdpbl9n ZXRfcHJvdG9jb2wgICAgKFdlYktpdFNlY3VyaXR5T3JpZ2luICpvcmlnaW4pOworCitXRUJLSVRf QVBJIGNvbnN0IGdjaGFyICoKK3dlYmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0X2hvc3QgICAgICAg IChXZWJLaXRTZWN1cml0eU9yaWdpbiAqb3JpZ2luKTsKKworV0VCS0lUX0FQSSBndWludAord2Vi a2l0X3NlY3VyaXR5X29yaWdpbl9nZXRfcG9ydCAgICAgICAgKFdlYktpdFNlY3VyaXR5T3JpZ2lu ICpvcmlnaW4pOworCitXRUJLSVRfQVBJIGNvbnN0IGdjaGFyICoKK3dlYmtpdF9zZWN1cml0eV9v cmlnaW5fdG9fc3RyaW5nICAgICAgIChXZWJLaXRTZWN1cml0eU9yaWdpbiAqb3JpZ2luKTsKKwor R19FTkRfREVDTFMKKworI2VuZGlmIC8qIFdlYktpdFNlY3VyaXR5T3JpZ2luX2ggKi8KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFNlY3VyaXR5T3Jp Z2luUHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2Vj dXJpdHlPcmlnaW5Qcml2YXRlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODBiODBkNmE4ZmE0NjhhZWVhYWZjMTVh YzA5ZTAzM2NlZWE4NDRjNgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFNlY3VyaXR5T3JpZ2luUHJpdmF0ZS5oCkBAIC0wLDAgKzEsMzQg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTcgSWdhbGlhIFMuTC4KKyAqCisgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBz b3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisg KiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFi b3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQv b3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisg KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklC VVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVT LCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJ RVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBV UlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRT IENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5D SURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VT IChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNU SVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBP UiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRI RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklM SVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklT SU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBB RFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI3By YWdtYSBvbmNlCisKKyNpbmNsdWRlICJXZWJLaXRQcml2YXRlLmgiCisjaW5jbHVkZSAiV2ViS2l0 U2VjdXJpdHlPcmlnaW4uaCIKKyNpbmNsdWRlIDxXZWJDb3JlL1NlY3VyaXR5T3JpZ2luLmg+CisK K1dlYktpdFNlY3VyaXR5T3JpZ2luKiB3ZWJraXRTZWN1cml0eU9yaWdpbkNyZWF0ZShXZWJDb3Jl OjpTZWN1cml0eU9yaWdpbiopOworV2ViS2l0U2VjdXJpdHlPcmlnaW4qIHdlYmtpdFNlY3VyaXR5 T3JpZ2luQ3JlYXRlKFJlZjxXZWJDb3JlOjpTZWN1cml0eU9yaWdpbj4mJik7CitXZWJDb3JlOjpT ZWN1cml0eU9yaWdpbiYgd2Via2l0U2VjdXJpdHlPcmlnaW5HZXRTZWN1cml0eU9yaWdpbihXZWJL aXRTZWN1cml0eU9yaWdpbiopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv QVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcAppbmRleCA3MzgzNGNmM2FkMjVlYzFkZjI1Yzgz MzEyOTBmN2VkM2I1OTkzZGQxLi5iZDE4ZTFkNTRmNjg3YWI1NDY2MjFlODFlZTcyYjRkMjIwMzBm YmY5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRX ZWJDb250ZXh0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRXZWJDb250ZXh0LmNwcApAQCAtNDEsNiArNDEsNyBAQAogI2luY2x1ZGUgIldlYktpdFBsdWdp blByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJLaXRQcml2YXRlLmgiCiAjaW5jbHVkZSAiV2ViS2l0 U2VjdXJpdHlNYW5hZ2VyUHJpdmF0ZS5oIgorI2luY2x1ZGUgIldlYktpdFNlY3VyaXR5T3JpZ2lu UHJpdmF0ZS5oIgogI2luY2x1ZGUgIldlYktpdFNldHRpbmdzUHJpdmF0ZS5oIgogI2luY2x1ZGUg IldlYktpdFVSSVNjaGVtZVJlcXVlc3RQcml2YXRlLmgiCiAjaW5jbHVkZSAiV2ViS2l0VXNlckNv bnRlbnRNYW5hZ2VyUHJpdmF0ZS5oIgpAQCAtMTEwLDYgKzExMSw3IEBAIGVudW0gewogZW51bSB7 CiAgICAgRE9XTkxPQURfU1RBUlRFRCwKICAgICBJTklUSUFMSVpFX1dFQl9FWFRFTlNJT05TLAor ICAgIFNFVF9JTklUSUFMX05PVElGSUNBVElPTl9QRVJNSVNTSU9OUywKIAogICAgIExBU1RfU0lH TkFMCiB9OwpAQCAtMjg1LDcgKzI4Nyw3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdFdlYkNvbnRleHRD b25zdHJ1Y3RlZChHT2JqZWN0KiBvYmplY3QpCiAgICAgcHJpdi0+Z2VvbG9jYXRpb25Qcm92aWRl ciA9IFdlYktpdEdlb2xvY2F0aW9uUHJvdmlkZXI6OmNyZWF0ZShwcml2LT5wcm9jZXNzUG9vbC0+ c3VwcGxlbWVudDxXZWJHZW9sb2NhdGlvbk1hbmFnZXJQcm94eT4oKSk7CiAjZW5kaWYKICNpZiBF TkFCTEUoTk9USUZJQ0FUSU9OUykKLSAgICBwcml2LT5ub3RpZmljYXRpb25Qcm92aWRlciA9IFdl YktpdE5vdGlmaWNhdGlvblByb3ZpZGVyOjpjcmVhdGUocHJpdi0+cHJvY2Vzc1Bvb2wtPnN1cHBs ZW1lbnQ8V2ViTm90aWZpY2F0aW9uTWFuYWdlclByb3h5PigpKTsKKyAgICBwcml2LT5ub3RpZmlj YXRpb25Qcm92aWRlciA9IFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyOjpjcmVhdGUocHJpdi0+ cHJvY2Vzc1Bvb2wtPnN1cHBsZW1lbnQ8V2ViTm90aWZpY2F0aW9uTWFuYWdlclByb3h5PigpLCB3 ZWJDb250ZXh0KTsKICNlbmRpZgogfQogCkBAIC0zODYsNiArMzg4LDI1IEBAIHN0YXRpYyB2b2lk IHdlYmtpdF93ZWJfY29udGV4dF9jbGFzc19pbml0KFdlYktpdFdlYkNvbnRleHRDbGFzcyogd2Vi Q29udGV4dENsYXNzCiAgICAgICAgICAgICBudWxscHRyLCBudWxscHRyLAogICAgICAgICAgICAg Z19jY2xvc3VyZV9tYXJzaGFsX1ZPSURfX1ZPSUQsCiAgICAgICAgICAgICBHX1RZUEVfTk9ORSwg MCk7CisKKyAgICAvKioKKyAgICAgKiBXZWJLaXRXZWJDb250ZXh0OjpzZXQtaW5pdGlhbC1ub3Rp ZmljYXRpb24tcGVybWlzc2lvbnM6CisgICAgICogQGNvbnRleHQ6IHRoZSAjV2ViS2l0V2ViQ29u dGV4dAorICAgICAqCisgICAgICogVGhpcyBzaWduYWwgaXMgZW1pdHRlZCB3aGVuIGEgbmV3IHdl YiBwcm9jZXNzIGlzIGFib3V0IHRvIGJlCisgICAgICogbGF1bmNoZWQuIEl0IHNpZ25hbHMgdGhl IG1vc3QgYXBwcm9wcmlhdGUgbW9tZW50IHRvIHVzZQorICAgICAqIHdlYmtpdF93ZWJfY29udGV4 dF9zZXRfaW5pdGlhbF9ub3RpZmljYXRpb25fcGVybWlzc2lvbnMoKS4KKyAgICAgKgorICAgICAq IFNpbmNlOiAyLjE2CisgICAgICovCisgICAgc2lnbmFsc1tTRVRfSU5JVElBTF9OT1RJRklDQVRJ T05fUEVSTUlTU0lPTlNdID0KKyAgICAgICAgZ19zaWduYWxfbmV3KCJzZXQtaW5pdGlhbC1ub3Rp ZmljYXRpb24tcGVybWlzc2lvbnMiLAorICAgICAgICAgICAgR19UWVBFX0ZST01fQ0xBU1MoZ09i amVjdENsYXNzKSwKKyAgICAgICAgICAgIEdfU0lHTkFMX1JVTl9MQVNULAorICAgICAgICAgICAg R19TVFJVQ1RfT0ZGU0VUKFdlYktpdFdlYkNvbnRleHRDbGFzcywgc2V0X2luaXRpYWxfbm90aWZp Y2F0aW9uX3Blcm1pc3Npb25zKSwKKyAgICAgICAgICAgIG51bGxwdHIsIG51bGxwdHIsCisgICAg ICAgICAgICBnX2NjbG9zdXJlX21hcnNoYWxfVk9JRF9fVk9JRCwKKyAgICAgICAgICAgIEdfVFlQ RV9OT05FLCAwKTsKIH0KIAogc3RhdGljIGdwb2ludGVyIGNyZWF0ZURlZmF1bHRXZWJDb250ZXh0 KGdwb2ludGVyKQpAQCAtMTIxOCw2ICsxMjM5LDYwIEBAIGd1aW50IHdlYmtpdF93ZWJfY29udGV4 dF9nZXRfd2ViX3Byb2Nlc3NfY291bnRfbGltaXQoV2ViS2l0V2ViQ29udGV4dCogY29udGV4dCkK ICAgICByZXR1cm4gY29udGV4dC0+cHJpdi0+cHJvY2Vzc0NvdW50TGltaXQ7CiB9CiAKK3N0YXRp YyB2b2lkIGFkZE9yaWdpblRvTWFwKFdlYktpdFNlY3VyaXR5T3JpZ2luKiBvcmlnaW4sIEhhc2hN YXA8U3RyaW5nLCBSZWZQdHI8QVBJOjpPYmplY3Q+PiogbWFwLCBib29sIGFsbG93ZWQpCit7Cisg ICAgU3RyaW5nIHN0cmluZyA9IHdlYmtpdFNlY3VyaXR5T3JpZ2luR2V0U2VjdXJpdHlPcmlnaW4o b3JpZ2luKS50b1N0cmluZygpOworICAgIGlmIChzdHJpbmcgIT0gIm51bGwiKQorICAgICAgICBt YXAtPnNldChzdHJpbmcsIEFQSTo6Qm9vbGVhbjo6Y3JlYXRlKGFsbG93ZWQpKTsKK30KKworc3Rh dGljIHZvaWQgYWRkQWxsb3dlZE9yaWdpblRvTWFwKFdlYktpdFNlY3VyaXR5T3JpZ2luKiBvcmln aW4sIEhhc2hNYXA8U3RyaW5nLCBSZWZQdHI8QVBJOjpPYmplY3Q+PiogbWFwKQoreworICAgIGFk ZE9yaWdpblRvTWFwKG9yaWdpbiwgbWFwLCB0cnVlKTsKK30KKworc3RhdGljIHZvaWQgYWRkRGlz YWxsb3dlZE9yaWdpblRvTWFwKFdlYktpdFNlY3VyaXR5T3JpZ2luKiBvcmlnaW4sIEhhc2hNYXA8 U3RyaW5nLCBSZWZQdHI8QVBJOjpPYmplY3Q+PiogbWFwKQoreworICAgIGFkZE9yaWdpblRvTWFw KG9yaWdpbiwgbWFwLCBmYWxzZSk7Cit9CisKKy8qKgorICogd2Via2l0X3dlYl9jb250ZXh0X3Nl dF9pbml0aWFsX25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uczoKKyAqIEBjb250ZXh0OiB0aGUgI1dl YktpdFdlYkNvbnRleHQKKyAqIEBhbGxvd2VkX29yaWdpbnM6IChlbGVtZW50LXR5cGUgV2ViS2l0 U2VjdXJpdHlPcmlnaW4pOiBhICNHTGlzdCBvZiBzZWN1cml0eSBvcmlnaW5zCisgKiBAZGlzYWxs b3dlZF9vcmlnaW5zOiAoZWxlbWVudC10eXBlIFdlYktpdFNlY3VyaXR5T3JpZ2luKTogYSAjR0xp c3Qgb2Ygc2VjdXJpdHkgb3JpZ2lucworICoKKyAqIFNldHMgaW5pdGlhbCBkZXNrdG9wIG5vdGlm aWNhdGlvbiBwZXJtaXNzaW9ucyBmb3IgdGhlIEBjb250ZXh0LgorICogQGFsbG93ZWRfb3JpZ2lu cyBhbmQgQGRpc2FsbG93ZWRfb3JpZ2lucyBtdXN0IGVhY2ggYmUgI0dMaXN0IG9mCisgKiAjV2Vi S2l0U2VjdXJpdHlPcmlnaW4gb2JqZWN0cyByZXByZXNlbnRpbmcgb3JpZ2lucyB0aGF0IHdpbGws CisgKiByZXNwZWN0aXZlbHksIGVpdGhlciBhbHdheXMgb3IgbmV2ZXIgaGF2ZSBwZXJtaXNzaW9u IHRvIHNob3cgZGVza3RvcAorICogbm90aWZpY2F0aW9ucy4gTm8gI1dlYktpdE5vdGlmaWNhdGlv blBlcm1pc3Npb25SZXF1ZXN0IHdpbGwgZXZlciBiZQorICogZ2VuZXJhdGVkIGZvciBhbnkgb2Yg dGhlIHNlY3VyaXR5IG9yaWdpbnMgcmVwcmVzZW50ZWQgaW4KKyAqIEBhbGxvd2VkX29yaWdpbnMg b3IgQGRpc2FsbG93ZWRfb3JpZ2lucy4gVGhpcyBmdW5jdGlvbiBpcyBuZWNlc3NhcnkKKyAqIGJl Y2F1c2Ugc29tZSB3ZWJwYWdlcyBwcm9hY3RpdmVseSBjaGVjayB3aGV0aGVyIHRoZXkgaGF2ZSBw ZXJtaXNzaW9uCisgKiB0byBkaXNwbGF5IG5vdGlmaWNhdGlvbnMgd2l0aG91dCBldmVyIGNyZWF0 aW5nIGEgcGVybWlzc2lvbiByZXF1ZXN0LgorICoKKyAqIFRoaXMgZnVuY3Rpb24gb25seSBhZmZl Y3RzIHdlYiBwcm9jZXNzZXMgdGhhdCBoYXZlIG5vdCBhbHJlYWR5IGJlZW4KKyAqIGNyZWF0ZWQu IFRoZSBiZXN0IHRpbWUgdG8gY2FsbCBpdCBpcyB3aGVuIGhhbmRsaW5nCisgKiAjV2ViS2l0V2Vi Q29udGV4dDo6c2V0LWluaXRpYWwtbm90aWZpY2F0aW9uLXBlcm1pc3Npb25zIHNvIGFzIHRvCisg KiBlbnN1cmUgdGhhdCBuZXcgd2ViIHByb2Nlc3NlcyByZWNlaXZlIHRoZSBtb3N0IHJlY2VudCBz ZXQgb2YKKyAqIHBlcm1pc3Npb25zLgorICoKKyAqIFNpbmNlOiAyLjE2CisgKi8KK3ZvaWQgd2Vi a2l0X3dlYl9jb250ZXh0X3NldF9pbml0aWFsX25vdGlmaWNhdGlvbl9wZXJtaXNzaW9ucyhXZWJL aXRXZWJDb250ZXh0KiBjb250ZXh0LCBHTGlzdCogYWxsb3dlZF9vcmlnaW5zLCBHTGlzdCogZGlz YWxsb3dlZF9vcmlnaW5zKQoreworICAgIEhhc2hNYXA8U3RyaW5nLCBSZWZQdHI8QVBJOjpPYmpl Y3Q+PiBtYXA7CisgICAgZ19saXN0X2ZvcmVhY2goYWxsb3dlZF9vcmlnaW5zLCAoR0Z1bmMpYWRk QWxsb3dlZE9yaWdpblRvTWFwLCAmbWFwKTsKKyAgICBnX2xpc3RfZm9yZWFjaChkaXNhbGxvd2Vk X29yaWdpbnMsIChHRnVuYylhZGREaXNhbGxvd2VkT3JpZ2luVG9NYXAsICZtYXApOworICAgIGNv bnRleHQtPnByaXYtPm5vdGlmaWNhdGlvblByb3ZpZGVyLT5zZXROb3RpZmljYXRpb25QZXJtaXNz aW9ucyhXVEZNb3ZlKG1hcCkpOworfQorCit2b2lkIHdlYmtpdFdlYkNvbnRleHRTZXRJbml0aWFs Tm90aWZpY2F0aW9uUGVybWlzc2lvbnMoV2ViS2l0V2ViQ29udGV4dCogY29udGV4dCkKK3sKKyAg ICBnX3NpZ25hbF9lbWl0KGNvbnRleHQsIHNpZ25hbHNbU0VUX0lOSVRJQUxfTk9USUZJQ0FUSU9O X1BFUk1JU1NJT05TXSwgMCk7Cit9CisKIFdlYktpdERvd25sb2FkKiB3ZWJraXRXZWJDb250ZXh0 R2V0T3JDcmVhdGVEb3dubG9hZChEb3dubG9hZFByb3h5KiBkb3dubG9hZFByb3h5KQogewogICAg IEdSZWZQdHI8V2ViS2l0RG93bmxvYWQ+IGRvd25sb2FkID0gZG93bmxvYWRzTWFwKCkuZ2V0KGRv d25sb2FkUHJveHkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0V2ViQ29udGV4dC5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsv V2ViS2l0V2ViQ29udGV4dC5oCmluZGV4IGNkNTU0ODZmNGMyMzM5NWYwZTc3YmI4NjIzMzcwZTdj NTcwZGUxYjcuLjBjZjFiY2Q4OGQ2MGJhNTlhOWQzYjQxMGE4MmY3YjFjMWZlN2VlNDEgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQu aAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0 LmgKQEAgLTEyOCwxNiArMTI4LDE2IEBAIHN0cnVjdCBfV2ViS2l0V2ViQ29udGV4dCB7CiBzdHJ1 Y3QgX1dlYktpdFdlYkNvbnRleHRDbGFzcyB7CiAgICAgR09iamVjdENsYXNzIHBhcmVudDsKIAot ICAgIHZvaWQgKCogZG93bmxvYWRfc3RhcnRlZCkgICAgICAgICAgKFdlYktpdFdlYkNvbnRleHQg KmNvbnRleHQsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2ViS2l0 RG93bmxvYWQgICAqZG93bmxvYWQpOwotICAgIHZvaWQgKCogaW5pdGlhbGl6ZV93ZWJfZXh0ZW5z aW9ucykgKFdlYktpdFdlYkNvbnRleHQgKmNvbnRleHQpOworICAgIHZvaWQgKCogZG93bmxvYWRf c3RhcnRlZCkgICAgICAgICAgICAgICAgICAgICAoV2ViS2l0V2ViQ29udGV4dCAqY29udGV4dCwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdlYktp dERvd25sb2FkICAgKmRvd25sb2FkKTsKKyAgICB2b2lkICgqIGluaXRpYWxpemVfd2ViX2V4dGVu c2lvbnMpICAgICAgICAgICAgKFdlYktpdFdlYkNvbnRleHQgKmNvbnRleHQpOworICAgIHZvaWQg KCogc2V0X2luaXRpYWxfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25zKSAoV2ViS2l0V2ViQ29udGV4 dCAqY29udGV4dCk7CiAKICAgICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDApICh2b2lkKTsKICAg ICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDEpICh2b2lkKTsKICAgICB2b2lkICgqX3dlYmtpdF9y ZXNlcnZlZDIpICh2b2lkKTsKICAgICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDMpICh2b2lkKTsK ICAgICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDQpICh2b2lkKTsKLSAgICB2b2lkICgqX3dlYmtp dF9yZXNlcnZlZDUpICh2b2lkKTsKIH07CiAKIFdFQktJVF9BUEkgR1R5cGUKQEAgLTI2NCw2ICsy NjQsMTIgQEAgd2Via2l0X3dlYl9jb250ZXh0X3NldF9wcm9jZXNzX21vZGVsICAgICAgICAgICAg ICAgIChXZWJLaXRXZWJDb250ZXh0CiBXRUJLSVRfQVBJIFdlYktpdFByb2Nlc3NNb2RlbAogd2Vi a2l0X3dlYl9jb250ZXh0X2dldF9wcm9jZXNzX21vZGVsICAgICAgICAgICAgICAgIChXZWJLaXRX ZWJDb250ZXh0ICAgICAgICAgICAgICAqY29udGV4dCk7CiAKK1dFQktJVF9BUEkgdm9pZAord2Vi a2l0X3dlYl9jb250ZXh0X3NldF9pbml0aWFsX25vdGlmaWNhdGlvbl9wZXJtaXNzaW9ucworICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChXZWJLaXRX ZWJDb250ZXh0ICAgICAgICAgICAgICAqY29udGV4dCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0xpc3QgICAgICAgICAgICAgICAgICAgICAg ICAgKmFsbG93ZWRfb3JpZ2lucywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgR0xpc3QgICAgICAgICAgICAgICAgICAgICAgICAgKmRpc2FsbG93 ZWRfb3JpZ2lucyk7CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dFByaXZhdGUuaCBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHRQcml2YXRlLmgK aW5kZXggNjNlYjIxYTc3MjMyMDJkYzZkYWNlMmI2ZTNhZGE3YzI2NzAxZDFiNC4uMDZmNWIxMzNl YTQ5MzE4MmVmYzYzNmM3ZWM1YzVjZTk2NGQwMDg3MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dFByaXZhdGUuaAorKysgYi9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0UHJpdmF0ZS5oCkBA IC00OCw1ICs0OCw2IEBAIHZvaWQgd2Via2l0V2ViQ29udGV4dENyZWF0ZVBhZ2VGb3JXZWJWaWV3 KFdlYktpdFdlYkNvbnRleHQqLCBXZWJLaXRXZWJWaWV3KiwgV2ViCiB2b2lkIHdlYmtpdFdlYkNv bnRleHRXZWJWaWV3RGVzdHJveWVkKFdlYktpdFdlYkNvbnRleHQqLCBXZWJLaXRXZWJWaWV3Kik7 CiBXZWJLaXRXZWJWaWV3KiB3ZWJraXRXZWJDb250ZXh0R2V0V2ViVmlld0ZvclBhZ2UoV2ViS2l0 V2ViQ29udGV4dCosIFdlYktpdDo6V2ViUGFnZVByb3h5Kik7CiBHVmFyaWFudCogd2Via2l0V2Vi Q29udGV4dEluaXRpYWxpemVXZWJFeHRlbnNpb25zKFdlYktpdFdlYkNvbnRleHQqKTsKK3ZvaWQg d2Via2l0V2ViQ29udGV4dFNldEluaXRpYWxOb3RpZmljYXRpb25QZXJtaXNzaW9ucyhXZWJLaXRX ZWJDb250ZXh0Kik7CiAKICNlbmRpZiAvLyBXZWJLaXRXZWJDb250ZXh0UHJpdmF0ZV9oCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGst NC4wLXNlY3Rpb25zLnR4dCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mv d2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0CmluZGV4IDAxMzAzZjY4OTM5ZTVjNDU1NTM2YWMz NDFmMjdmODgwYjI4MGVmNTcuLjBjNjI4Y2YwYTJkNzBlMTEzYTk5Mzg1MGE1MGM1M2MxNDliMmI4 NTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Vi a2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9B UEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0CkBAIC01OSw2ICs1OSw3IEBA IHdlYmtpdF93ZWJfY29udGV4dF9zZXRfZGlza19jYWNoZV9kaXJlY3RvcnkKIHdlYmtpdF93ZWJf Y29udGV4dF9hbGxvd190bHNfY2VydGlmaWNhdGVfZm9yX2hvc3QKIHdlYmtpdF93ZWJfY29udGV4 dF9nZXRfcHJvY2Vzc19tb2RlbAogd2Via2l0X3dlYl9jb250ZXh0X3NldF9wcm9jZXNzX21vZGVs Cit3ZWJraXRfd2ViX2NvbnRleHRfc2V0X2luaXRpYWxfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25z CiAKIDxTVUJTRUNUSU9OIFVSSSBTY2hlbWU+CiBXZWJLaXRVUklTY2hlbWVSZXF1ZXN0Q2FsbGJh Y2sKQEAgLTEyMTEsNiArMTIxMiwyNSBAQCB3ZWJraXRfc2VjdXJpdHlfbWFuYWdlcl9nZXRfdHlw ZQogPC9TRUNUSU9OPgogCiA8U0VDVElPTj4KKzxGSUxFPldlYktpdFNlY3VyaXR5T3JpZ2luPC9G SUxFPgorV2ViS2l0U2VjdXJpdHlPcmlnaW4KK3dlYmtpdF9zZWN1cml0eV9vcmlnaW5fbmV3Cit3 ZWJraXRfc2VjdXJpdHlfb3JpZ2luX25ld19mcm9tX3N0cmluZword2Via2l0X3NlY3VyaXR5X29y aWdpbl9yZWYKK3dlYmtpdF9zZWN1cml0eV9vcmlnaW5fdW5yZWYKK3dlYmtpdF9zZWN1cml0eV9v cmlnaW5fZ2V0X3Byb3RvY29sCit3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dldF9ob3N0Cit3ZWJr aXRfc2VjdXJpdHlfb3JpZ2luX2dldF9wb3J0Cit3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3RvX3N0 cmluZworCis8U1VCU0VDVElPTiBTdGFuZGFyZD4KK1dFQktJVF9UWVBFX1NFQ1VSSVRZX09SSUdJ TgorCis8U1VCU0VDVElPTiBQcml2YXRlPgord2Via2l0X3NlY3VyaXR5X29yaWdpbl9nZXRfdHlw ZQorPC9TRUNUSU9OPgorCis8U0VDVElPTj4KIDxGSUxFPldlYktpdFdlYnNpdGVEYXRhTWFuYWdl cjwvRklMRT4KIFdlYktpdFdlYnNpdGVEYXRhTWFuYWdlcgogd2Via2l0X3dlYnNpdGVfZGF0YV9t YW5hZ2VyX25ldwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsv ZG9jcy93ZWJraXQyZ3RrLWRvY3Muc2dtbCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkv Z3RrL2RvY3Mvd2Via2l0Mmd0ay1kb2NzLnNnbWwKaW5kZXggZjhmNDJkY2Q5MmQ2ZDhhN2QwZWNj NDFlY2Q2NmY5YTUyMDYyYjQ1YS4uMDI0ZTliOGUyMzA4OGZiZDIzMzRlYWUxNWNjZTAxNzE1NWJj NjM0OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93 ZWJraXQyZ3RrLWRvY3Muc2dtbAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0 ay9kb2NzL3dlYmtpdDJndGstZG9jcy5zZ21sCkBAIC01MSw2ICs1MSw3IEBACiAgICAgPHhpOmlu Y2x1ZGUgaHJlZj0ieG1sL1dlYktpdFVzZXJDb250ZW50LnhtbCIvPgogICAgIDx4aTppbmNsdWRl IGhyZWY9InhtbC9XZWJLaXROb3RpZmljYXRpb24ueG1sIi8+CiAgICAgPHhpOmluY2x1ZGUgaHJl Zj0ieG1sL1dlYktpdE5vdGlmaWNhdGlvblBlcm1pc3Npb25SZXF1ZXN0LnhtbCIvPgorICAgIDx4 aTppbmNsdWRlIGhyZWY9InhtbC9XZWJLaXRTZWN1cml0eU9yaWdpbi54bWwiLz4KICAgICA8eGk6 aW5jbHVkZSBocmVmPSJ4bWwvV2ViS2l0V2Vic2l0ZURhdGFNYW5hZ2VyLnhtbCIvPgogICA8L2No YXB0ZXI+CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3dl YmtpdDIuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3dlYmtpdDIuaAppbmRl eCAzZTQ0ZDYwOTQ0YWY0MGM2NGQ3ZDU3MTJiNDZkZDQ0YWMwN2I3NjBmLi5mYzBmYTRlYmE1MGY2 NzU3ZjJhYzM4OTUwZTNhNmE4YmEwYjBiZGY4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvQVBJL2d0ay93ZWJraXQyLmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L0FQSS9ndGsvd2Via2l0Mi5oCkBAIC02MSw2ICs2MSw3IEBACiAjaW5jbHVkZSA8d2Via2l0Mi9X ZWJLaXRSZXNwb25zZVBvbGljeURlY2lzaW9uLmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJLaXRT Y3JpcHREaWFsb2cuaD4KICNpbmNsdWRlIDx3ZWJraXQyL1dlYktpdFNlY3VyaXR5TWFuYWdlci5o PgorI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0U2VjdXJpdHlPcmlnaW4uaD4KICNpbmNsdWRlIDx3 ZWJraXQyL1dlYktpdFNldHRpbmdzLmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJLaXRVUklSZXF1 ZXN0Lmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJLaXRVUklSZXNwb25zZS5oPgpkaWZmIC0tZ2l0 IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDBmOGEwMjU0MWU1Nzdm NjRkODJkYThkOTI1NTIzZmM2YmMzZWY5NzMuLjE1MDU3ZjcxYzc5MDg5OTU1NDQ4MjQ1ZTQ2N2E3 Y2QwOTAwZTQxYWIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFu Z2VMb2cKQEAgLTEsMyArMSwzMCBAQAorMjAxNi0xMi0yOSAgTWljaGFlbCBDYXRhbnphcm8gIDxt Y2F0YW56YXJvQGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10gTm8gd2F5IGZvciBhcHBsaWNh dGlvbnMgdG8gc2V0IG5vdGlmaWNhdGlvbiBwZXJtaXNzaW9ucyB3aXRob3V0IHdhaXRpbmcgZm9y IHBlcm1pc3Npb24gcmVxdWVzdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTYzMzY2CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYktpdFdl YkNvbnRleHQuY3BwOiBUZXN0IFdlYktpdFNlY3VyaXR5T3JpZ2luLgorICAgICAgICAodGVzdFNl Y3VyaXR5T3JpZ2luQmFzaWMpOgorICAgICAgICAoYmVmb3JlQWxsKToKKyAgICAgICAgKiBUZXN0 V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYktpdFdlYlZpZXcuY3BwOiBUZXN0IG5v dGlmaWNhdGlvbiBwZXJtaXNzaW9ucy4KKyAgICAgICAgKHRlc3RXZWJWaWV3Tm90aWZpY2F0aW9u KToKKyAgICAgICAgKHNldEluaXRpYWxOb3RpZmljYXRpb25QZXJtaXNzaW9uc0FsbG93ZWRDYWxs YmFjayk6CisgICAgICAgIChzZXRJbml0aWFsTm90aWZpY2F0aW9uUGVybWlzc2lvbnNEaXNhbGxv d2VkQ2FsbGJhY2spOgorICAgICAgICAodGVzdFdlYlZpZXdOb3RpZmljYXRpb25Jbml0aWFsUGVy bWlzc2lvbkFsbG93ZWQpOgorICAgICAgICAodGVzdFdlYlZpZXdOb3RpZmljYXRpb25Jbml0aWFs UGVybWlzc2lvbkRpc2FsbG93ZWQpOgorICAgICAgICAoYmVmb3JlQWxsKToKKyAgICAgICAgKiBU ZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1Rlc3RNYWluLmg6IEFkZCBtYWNybyB0byBhbGxv dyBmb3IgY3VzdG9tIHRlc3QgZml4dHVyZXMuCisgICAgICAgICogVGVzdFdlYktpdEFQSS9ndGsv V2ViS2l0Mkd0ay9XZWJLaXRUZXN0U2VydmVyLmNwcDogQWRkIGhlbHBlciB0byBnZXQgc2VjdXJp dHkgb3JpZ2luLgorICAgICAgICAoV2ViS2l0VGVzdFNlcnZlcjo6c2VjdXJpdHlPcmlnaW4pOgor ICAgICAgICAoV2ViS2l0VGVzdFNlcnZlcjo6Z2V0VVJJRm9yUGF0aCk6IERyaXZlLWJ5OiBtYWRl IGl0IGNvbnN0LgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViS2l0 VGVzdFNlcnZlci5oOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2Vi Vmlld1Rlc3QuY3BwOiBBZGQgYWJpbGl0eSB0byBkZWZlciB3ZWIgdmlldyBjcmVhdGlvbi4KKyAg ICAgICAgKFdlYlZpZXdUZXN0OjpXZWJWaWV3VGVzdCk6CisgICAgICAgIChXZWJWaWV3VGVzdDo6 aW5pdGlhbGl6ZVdlYlZpZXcpOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJH dGsvV2ViVmlld1Rlc3QuaDoKKwogMjAxNi0xMi0yNyAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0 YW56YXJvQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0dUS10gSW1wcm92ZSB1c2VyIGFnZW50IGNv bnN0cnVjdGlvbgpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQy R3RrL1Rlc3RXZWJLaXRXZWJDb250ZXh0LmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMv V2ViS2l0Mkd0ay9UZXN0V2ViS2l0V2ViQ29udGV4dC5jcHAKaW5kZXggYTc1NWE3MmZiMTc0Yjlj NTFiZjIzZWZmNDNlNDBmODg3YzNjOGI1Ni4uMTlkNmE4MjU1NWUzMWRjNzQ4MWVmYmE2NGNkZDZl YzgzMjM0MmJiYiAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQy R3RrL1Rlc3RXZWJLaXRXZWJDb250ZXh0LmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RzL1dlYktpdDJHdGsvVGVzdFdlYktpdFdlYkNvbnRleHQuY3BwCkBAIC03MDAsNiArNzAwLDI1 IEBAIHN0YXRpYyB2b2lkIHRlc3RXZWJDb250ZXh0U2VjdXJpdHlGaWxlWEhSKFdlYlZpZXdUZXN0 KiB0ZXN0LCBnY29uc3Rwb2ludGVyKQogICAgIHdlYmtpdF9zZXR0aW5nc19zZXRfYWxsb3dfZmls ZV9hY2Nlc3NfZnJvbV9maWxlX3VybHMod2Via2l0X3dlYl92aWV3X2dldF9zZXR0aW5ncyh0ZXN0 LT5tX3dlYlZpZXcpLCBGQUxTRSk7CiB9CiAKK3N0YXRpYyB2b2lkIHRlc3RTZWN1cml0eU9yaWdp bkJhc2ljKFRlc3QqLCBnY29uc3Rwb2ludGVyKQoreworICAgIFdlYktpdFNlY3VyaXR5T3JpZ2lu KiBvcmlnaW4gPSB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX25ldygiaHR0cCIsICIxMjcuMC4wLjEi LCAxMjM0KTsKKyAgICBnX2Fzc2VydChvcmlnaW4pOworICAgIGdfYXNzZXJ0X2NtcHN0cih3ZWJr aXRfc2VjdXJpdHlfb3JpZ2luX2dldF9wcm90b2NvbChvcmlnaW4pLCA9PSwgImh0dHAiKTsKKyAg ICBnX2Fzc2VydF9jbXBzdHIod2Via2l0X3NlY3VyaXR5X29yaWdpbl9nZXRfaG9zdChvcmlnaW4p LCA9PSwgIjEyNy4wLjAuMSIpOworICAgIGdfYXNzZXJ0X2NtcGludCh3ZWJraXRfc2VjdXJpdHlf b3JpZ2luX2dldF9wb3J0KG9yaWdpbiksID09LCAxMjM0KTsKKyAgICBnX2Fzc2VydF9jbXBzdHIo d2Via2l0X3NlY3VyaXR5X29yaWdpbl90b19zdHJpbmcob3JpZ2luKSwgPT0sICJodHRwOi8vMTI3 LjAuMC4xOjEyMzQiKTsKKyAgICB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3VucmVmKG9yaWdpbik7 CisKKyAgICBvcmlnaW4gPSB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX25ld19mcm9tX3N0cmluZygi aHR0cDovLzEyNy4wLjAuMToxMjM0Iik7CisgICAgZ19hc3NlcnQob3JpZ2luKTsKKyAgICBnX2Fz c2VydF9jbXBzdHIod2Via2l0X3NlY3VyaXR5X29yaWdpbl9nZXRfcHJvdG9jb2wob3JpZ2luKSwg PT0sICJodHRwIik7CisgICAgZ19hc3NlcnRfY21wc3RyKHdlYmtpdF9zZWN1cml0eV9vcmlnaW5f Z2V0X2hvc3Qob3JpZ2luKSwgPT0sICIxMjcuMC4wLjEiKTsKKyAgICBnX2Fzc2VydF9jbXBpbnQo d2Via2l0X3NlY3VyaXR5X29yaWdpbl9nZXRfcG9ydChvcmlnaW4pLCA9PSwgMTIzNCk7CisgICAg Z19hc3NlcnRfY21wc3RyKHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fdG9fc3RyaW5nKG9yaWdpbiks ID09LCAiaHR0cDovLzEyNy4wLjAuMToxMjM0Iik7CisgICAgd2Via2l0X3NlY3VyaXR5X29yaWdp bl91bnJlZihvcmlnaW4pOworfQorCiB2b2lkIGJlZm9yZUFsbCgpCiB7CiAgICAga1NlcnZlciA9 IG5ldyBXZWJLaXRUZXN0U2VydmVyKCk7CkBAIC03MTMsNiArNzMyLDcgQEAgdm9pZCBiZWZvcmVB bGwoKQogICAgIFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYkNvbnRleHQiLCAibGFuZ3VhZ2Vz IiwgdGVzdFdlYkNvbnRleHRMYW5ndWFnZXMpOwogICAgIFNlY3VyaXR5UG9saWN5VGVzdDo6YWRk KCJXZWJLaXRTZWN1cml0eU1hbmFnZXIiLCAic2VjdXJpdHktcG9saWN5IiwgdGVzdFdlYkNvbnRl eHRTZWN1cml0eVBvbGljeSk7CiAgICAgV2ViVmlld1Rlc3Q6OmFkZCgiV2ViS2l0U2VjdXJpdHlN YW5hZ2VyIiwgImZpbGUteGhyIiwgdGVzdFdlYkNvbnRleHRTZWN1cml0eUZpbGVYSFIpOworICAg IFRlc3Q6OmFkZCgiV2ViS2l0U2VjdXJpdHlPcmlnaW4iLCAiYmFzaWMiLCB0ZXN0U2VjdXJpdHlP cmlnaW5CYXNpYyk7CiB9CiAKIHZvaWQgYWZ0ZXJBbGwoKQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RXZWJLaXRXZWJWaWV3LmNwcCBiL1Rvb2xz L1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9UZXN0V2ViS2l0V2ViVmlldy5jcHAKaW5k ZXggMjkyZjU1NjE2MDMwOGEwYjljOTUzZTFiYTMyMTRiNTBkNTM1ZWVmOS4uMTdmOTc1M2E4MjBm YWEzOGY0NmJlMjE1NzYxYzEwN2FiN2QwMDU3NCAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RXZWJLaXRXZWJWaWV3LmNwcAorKysgYi9Ub29scy9U ZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYktpdFdlYlZpZXcuY3BwCkBAIC02 MzIsNyArNjMyLDE3IEBAIHN0YXRpYyB2b2lkIHRlc3RXZWJWaWV3U25hcHNob3QoU25hcHNob3RX ZWJWaWV3VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRlcikKIAogY2xhc3MgTm90aWZpY2F0aW9uV2Vi Vmlld1Rlc3Q6IHB1YmxpYyBXZWJWaWV3VGVzdCB7CiBwdWJsaWM6Ci0gICAgTUFLRV9HTElCX1RF U1RfRklYVFVSRShOb3RpZmljYXRpb25XZWJWaWV3VGVzdCk7CisgICAgTUFLRV9HTElCX1RFU1Rf RklYVFVSRV9XSVRIX1NFVFVQX1RFQVJET1dOKE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0LCBzZXR1 cCwgdGVhcmRvd24pOworCisgICAgc3RhdGljIHZvaWQgc2V0dXAoKQorICAgIHsKKyAgICAgICAg V2ViVmlld1Rlc3Q6OnNob3VsZEluaXRpYWxpemVXZWJWaWV3SW5Db25zdHJ1Y3RvciA9IGZhbHNl OworICAgIH0KKworICAgIHN0YXRpYyB2b2lkIHRlYXJkb3duKCkKKyAgICB7CisgICAgICAgIFdl YlZpZXdUZXN0OjpzaG91bGRJbml0aWFsaXplV2ViVmlld0luQ29uc3RydWN0b3IgPSB0cnVlOwor ICAgIH0KIAogICAgIGVudW0gTm90aWZpY2F0aW9uRXZlbnQgewogICAgICAgICBOb25lLApAQCAt NjQ3LDYgKzY1Nyw3IEBAIHB1YmxpYzoKICAgICBzdGF0aWMgZ2Jvb2xlYW4gcGVybWlzc2lvblJl cXVlc3RDYWxsYmFjayhXZWJLaXRXZWJWaWV3KiwgV2ViS2l0UGVybWlzc2lvblJlcXVlc3QgKnJl cXVlc3QsIE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0KiB0ZXN0KQogICAgIHsKICAgICAgICAgZ19h c3NlcnQoV0VCS0lUX0lTX05PVElGSUNBVElPTl9QRVJNSVNTSU9OX1JFUVVFU1QocmVxdWVzdCkp OworICAgICAgICBnX2Fzc2VydCh0ZXN0LT5tX2lzRXhwZWN0aW5nUGVybWlzc2lvblJlcXVlc3Qp OwogICAgICAgICB0ZXN0LT5hc3NlcnRPYmplY3RJc0RlbGV0ZWRXaGVuVGVzdEZpbmlzaGVzKEdf T0JKRUNUKHJlcXVlc3QpKTsKIAogICAgICAgICB0ZXN0LT5tX2V2ZW50ID0gUGVybWlzc2lvbjsK QEAgLTY5OSwxMCArNzEwLDkgQEAgcHVibGljOgogICAgICAgICBnX21haW5fbG9vcF9xdWl0KHRl c3QtPm1fbWFpbkxvb3ApOwogICAgIH0KIAotICAgIE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0KCkK LSAgICAgICAgOiBtX25vdGlmaWNhdGlvbihudWxscHRyKQotICAgICAgICAsIG1fZXZlbnQoTm9u ZSkKKyAgICB2b2lkIGluaXRpYWxpemUoKQogICAgIHsKKyAgICAgICAgaW5pdGlhbGl6ZVdlYlZp ZXcoKTsKICAgICAgICAgZ19zaWduYWxfY29ubmVjdChtX3dlYlZpZXcsICJwZXJtaXNzaW9uLXJl cXVlc3QiLCBHX0NBTExCQUNLKHBlcm1pc3Npb25SZXF1ZXN0Q2FsbGJhY2spLCB0aGlzKTsKICAg ICAgICAgZ19zaWduYWxfY29ubmVjdChtX3dlYlZpZXcsICJzaG93LW5vdGlmaWNhdGlvbiIsIEdf Q0FMTEJBQ0soc2hvd05vdGlmaWNhdGlvbkNhbGxiYWNrKSwgdGhpcyk7CiAgICAgICAgIHdlYmtp dF91c2VyX2NvbnRlbnRfbWFuYWdlcl9yZWdpc3Rlcl9zY3JpcHRfbWVzc2FnZV9oYW5kbGVyKG1f dXNlckNvbnRlbnRNYW5hZ2VyLmdldCgpLCAibm90aWZpY2F0aW9ucyIpOwpAQCAtNzE2LDkgKzcy NiwxOCBAQCBwdWJsaWM6CiAgICAgICAgIHdlYmtpdF91c2VyX2NvbnRlbnRfbWFuYWdlcl91bnJl Z2lzdGVyX3NjcmlwdF9tZXNzYWdlX2hhbmRsZXIobV91c2VyQ29udGVudE1hbmFnZXIuZ2V0KCks ICJub3RpZmljYXRpb25zIik7CiAgICAgfQogCisgICAgYm9vbCBoYXNQZXJtaXNzaW9uKCkKKyAg ICB7CisgICAgICAgIGF1dG8qIHJlc3VsdCA9IHJ1bkphdmFTY3JpcHRBbmRXYWl0VW50aWxGaW5p c2hlZCgiTm90aWZpY2F0aW9uLnBlcm1pc3Npb247IiwgbnVsbHB0cik7CisgICAgICAgIGdfYXNz ZXJ0KHJlc3VsdCk7CisgICAgICAgIEdVbmlxdWVQdHI8Y2hhcj4gdmFsdWUoamF2YXNjcmlwdFJl c3VsdFRvQ1N0cmluZyhyZXN1bHQpKTsKKyAgICAgICAgcmV0dXJuICFnX3N0cmNtcDAodmFsdWUu Z2V0KCksICJncmFudGVkIik7CisgICAgfQorCiAgICB2b2lkIHJlcXVlc3RQZXJtaXNzaW9uQW5k V2FpdFVudGlsR2l2ZW4oKQogICAgIHsKICAgICAgICAgbV9ldmVudCA9IE5vbmU7CisgICAgICAg IG1faXNFeHBlY3RpbmdQZXJtaXNzaW9uUmVxdWVzdCA9IHRydWU7CiAgICAgICAgIHdlYmtpdF93 ZWJfdmlld19ydW5famF2YXNjcmlwdChtX3dlYlZpZXcsICJOb3RpZmljYXRpb24ucmVxdWVzdFBl cm1pc3Npb24oKTsiLCBudWxscHRyLCBudWxscHRyLCBudWxscHRyKTsKICAgICAgICAgZ19tYWlu X2xvb3BfcnVuKG1fbWFpbkxvb3ApOwogICAgIH0KQEAgLTc2OSwxOCArNzg4LDI0IEBAIHB1Ymxp YzoKICAgICAgICAgZ19tYWluX2xvb3BfcnVuKG1fbWFpbkxvb3ApOwogICAgIH0KIAotICAgIE5v dGlmaWNhdGlvbkV2ZW50IG1fZXZlbnQ7Ci0gICAgV2ViS2l0Tm90aWZpY2F0aW9uKiBtX25vdGlm aWNhdGlvbjsKKyAgICBOb3RpZmljYXRpb25FdmVudCBtX2V2ZW50IHsgTm9uZSB9OworICAgIFdl YktpdE5vdGlmaWNhdGlvbiogbV9ub3RpZmljYXRpb24geyBudWxscHRyIH07CisgICAgYm9vbCBt X2lzRXhwZWN0aW5nUGVybWlzc2lvblJlcXVlc3QgeyBmYWxzZSB9OworICAgIGJvb2wgbV9oYXNQ ZXJtaXNzaW9uIHsgZmFsc2UgfTsKIH07CiAKIHN0YXRpYyB2b2lkIHRlc3RXZWJWaWV3Tm90aWZp Y2F0aW9uKE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0KiB0ZXN0LCBnY29uc3Rwb2ludGVyKQogewor ICAgIHRlc3QtPmluaXRpYWxpemUoKTsKKwogICAgIC8vIE5vdGlmaWNhdGlvbnMgZG9uJ3Qgd29y ayB3aXRoIGxvY2FsIG9yIHNwZWNpYWwgc2NoZW1lcy4KICAgICB0ZXN0LT5sb2FkVVJJKGdTZXJ2 ZXItPmdldFVSSUZvclBhdGgoIi8iKS5kYXRhKCkpOwogICAgIHRlc3QtPndhaXRVbnRpbExvYWRG aW5pc2hlZCgpOworICAgIGdfYXNzZXJ0KCF0ZXN0LT5oYXNQZXJtaXNzaW9uKCkpOwogCiAgICAg dGVzdC0+cmVxdWVzdFBlcm1pc3Npb25BbmRXYWl0VW50aWxHaXZlbigpOwogICAgIGdfYXNzZXJ0 KHRlc3QtPm1fZXZlbnQgPT0gTm90aWZpY2F0aW9uV2ViVmlld1Rlc3Q6OlBlcm1pc3Npb24pOwor ICAgIGdfYXNzZXJ0KHRlc3QtPmhhc1Blcm1pc3Npb24oKSk7CiAKICAgICBzdGF0aWMgY29uc3Qg Y2hhciogdGl0bGUgPSAiVGhpcyBpcyBhIG5vdGlmaWNhdGlvbiI7CiAgICAgc3RhdGljIGNvbnN0 IGNoYXIqIGJvZHkgPSAiVGhpcyBpcyB0aGUgYm9keS4iOwpAQCAtODE4LDYgKzg0Myw0NyBAQCBz dGF0aWMgdm9pZCB0ZXN0V2ViVmlld05vdGlmaWNhdGlvbihOb3RpZmljYXRpb25XZWJWaWV3VGVz dCogdGVzdCwgZ2NvbnN0cG9pbnRlcgogICAgIGdfYXNzZXJ0KHRlc3QtPm1fZXZlbnQgPT0gTm90 aWZpY2F0aW9uV2ViVmlld1Rlc3Q6OkNsb3NlZCk7CiB9CiAKK3N0YXRpYyB2b2lkIHNldEluaXRp YWxOb3RpZmljYXRpb25QZXJtaXNzaW9uc0FsbG93ZWRDYWxsYmFjayhXZWJLaXRXZWJDb250ZXh0 KiBjb250ZXh0LCBOb3RpZmljYXRpb25XZWJWaWV3VGVzdCogdGVzdCkKK3sKKyAgICBHTGlzdCog YWxsb3dlZE9yaWdpbnMgPSBudWxscHRyOworICAgIGFsbG93ZWRPcmlnaW5zID0gZ19saXN0X2Fw cGVuZChhbGxvd2VkT3JpZ2lucywgd2Via2l0X3NlY3VyaXR5X29yaWdpbl9uZXdfZnJvbV9zdHJp bmcoZ1NlcnZlci0+c2VjdXJpdHlPcmlnaW4oKS5kYXRhKCkpKTsKKyAgICB3ZWJraXRfd2ViX2Nv bnRleHRfc2V0X2luaXRpYWxfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25zKHRlc3QtPm1fd2ViQ29u dGV4dC5nZXQoKSwgYWxsb3dlZE9yaWdpbnMsIG51bGxwdHIpOworICAgIGdfbGlzdF9mcmVlX2Z1 bGwoYWxsb3dlZE9yaWdpbnMsIChHRGVzdHJveU5vdGlmeSl3ZWJraXRfc2VjdXJpdHlfb3JpZ2lu X3VucmVmKTsKK30KKworc3RhdGljIHZvaWQgc2V0SW5pdGlhbE5vdGlmaWNhdGlvblBlcm1pc3Np b25zRGlzYWxsb3dlZENhbGxiYWNrKFdlYktpdFdlYkNvbnRleHQqIGNvbnRleHQsIE5vdGlmaWNh dGlvbldlYlZpZXdUZXN0KiB0ZXN0KQoreworICAgIEdMaXN0KiBkaXNhbGxvd2VkT3JpZ2lucyA9 IG51bGxwdHI7CisgICAgZGlzYWxsb3dlZE9yaWdpbnMgPSBnX2xpc3RfYXBwZW5kKGRpc2FsbG93 ZWRPcmlnaW5zLCB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX25ld19mcm9tX3N0cmluZyhnU2VydmVy LT5zZWN1cml0eU9yaWdpbigpLmRhdGEoKSkpOworICAgIHdlYmtpdF93ZWJfY29udGV4dF9zZXRf aW5pdGlhbF9ub3RpZmljYXRpb25fcGVybWlzc2lvbnModGVzdC0+bV93ZWJDb250ZXh0LmdldCgp LCBudWxscHRyLCBkaXNhbGxvd2VkT3JpZ2lucyk7CisgICAgZ19saXN0X2ZyZWVfZnVsbChkaXNh bGxvd2VkT3JpZ2lucywgKEdEZXN0cm95Tm90aWZ5KXdlYmtpdF9zZWN1cml0eV9vcmlnaW5fdW5y ZWYpOworfQorCitzdGF0aWMgdm9pZCB0ZXN0V2ViVmlld05vdGlmaWNhdGlvbkluaXRpYWxQZXJt aXNzaW9uQWxsb3dlZChOb3RpZmljYXRpb25XZWJWaWV3VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRl cikKK3sKKyAgICBnX3NpZ25hbF9jb25uZWN0KHRlc3QtPm1fd2ViQ29udGV4dC5nZXQoKSwgInNl dC1pbml0aWFsLW5vdGlmaWNhdGlvbi1wZXJtaXNzaW9ucyIsIEdfQ0FMTEJBQ0soc2V0SW5pdGlh bE5vdGlmaWNhdGlvblBlcm1pc3Npb25zQWxsb3dlZENhbGxiYWNrKSwgdGVzdCk7CisgICAgdGVz dC0+aW5pdGlhbGl6ZSgpOworCisgICAgdGVzdC0+bG9hZFVSSShnU2VydmVyLT5nZXRVUklGb3JQ YXRoKCIvIikuZGF0YSgpKTsKKyAgICB0ZXN0LT53YWl0VW50aWxMb2FkRmluaXNoZWQoKTsKKyAg ICBnX2Fzc2VydCh0ZXN0LT5oYXNQZXJtaXNzaW9uKCkpOworCisgICAgc3RhdGljIGNvbnN0IGNo YXIqIHRpdGxlID0gIlRoaXMgaXMgYSBub3RpZmljYXRpb24iOworICAgIHN0YXRpYyBjb25zdCBj aGFyKiBib2R5ID0gIlRoaXMgaXMgdGhlIGJvZHkuIjsKKyAgICB0ZXN0LT5yZXF1ZXN0Tm90aWZp Y2F0aW9uQW5kV2FpdFVudGlsU2hvd24odGl0bGUsIGJvZHkpOworICAgIGdfYXNzZXJ0KHRlc3Qt Pm1fZXZlbnQgPT0gTm90aWZpY2F0aW9uV2ViVmlld1Rlc3Q6OlNob3duKTsKK30KKworc3RhdGlj IHZvaWQgdGVzdFdlYlZpZXdOb3RpZmljYXRpb25Jbml0aWFsUGVybWlzc2lvbkRpc2FsbG93ZWQo Tm90aWZpY2F0aW9uV2ViVmlld1Rlc3QqIHRlc3QsIGdjb25zdHBvaW50ZXIpCit7CisgICAgZ19z aWduYWxfY29ubmVjdCh0ZXN0LT5tX3dlYkNvbnRleHQuZ2V0KCksICJzZXQtaW5pdGlhbC1ub3Rp ZmljYXRpb24tcGVybWlzc2lvbnMiLCBHX0NBTExCQUNLKHNldEluaXRpYWxOb3RpZmljYXRpb25Q ZXJtaXNzaW9uc0Rpc2FsbG93ZWRDYWxsYmFjayksIHRlc3QpOworICAgIHRlc3QtPmluaXRpYWxp emUoKTsKKworICAgIHRlc3QtPmxvYWRVUkkoZ1NlcnZlci0+Z2V0VVJJRm9yUGF0aCgiLyIpLmRh dGEoKSk7CisgICAgdGVzdC0+d2FpdFVudGlsTG9hZEZpbmlzaGVkKCk7CisgICAgZ19hc3NlcnQo IXRlc3QtPmhhc1Blcm1pc3Npb24oKSk7Cit9CisKIHN0YXRpYyB2b2lkIHRlc3RXZWJWaWV3SXNQ bGF5aW5nQXVkaW8oSXNQbGF5aW5nQXVkaW9XZWJWaWV3VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRl cikKIHsKICAgICAvLyBUaGUgd2ViIHZpZXcgbXVzdCBiZSByZWFsaXplZCBmb3IgdGhlIHZpZGVv IHRvIHN0YXJ0IHBsYXliYWNrIGFuZApAQCAtOTE1LDYgKzk4MSw4IEBAIHZvaWQgYmVmb3JlQWxs KCkKICAgICBTbmFwc2hvdFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAic25hcHNo b3QiLCB0ZXN0V2ViVmlld1NuYXBzaG90KTsKICAgICBXZWJWaWV3VGVzdDo6YWRkKCJXZWJLaXRX ZWJWaWV3IiwgInBhZ2UtdmlzaWJpbGl0eSIsIHRlc3RXZWJWaWV3UGFnZVZpc2liaWxpdHkpOwog ICAgIE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAibm90aWZp Y2F0aW9uIiwgdGVzdFdlYlZpZXdOb3RpZmljYXRpb24pOworICAgIE5vdGlmaWNhdGlvbldlYlZp ZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAibm90aWZpY2F0aW9uLWluaXRpYWwtcGVybWlz c2lvbi1hbGxvd2VkIiwgdGVzdFdlYlZpZXdOb3RpZmljYXRpb25Jbml0aWFsUGVybWlzc2lvbkFs bG93ZWQpOworICAgIE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXci LCAibm90aWZpY2F0aW9uLWluaXRpYWwtcGVybWlzc2lvbi1kaXNhbGxvd2VkIiwgdGVzdFdlYlZp ZXdOb3RpZmljYXRpb25Jbml0aWFsUGVybWlzc2lvbkRpc2FsbG93ZWQpOwogICAgIElzUGxheWlu Z0F1ZGlvV2ViVmlld1Rlc3Q6OmFkZCgiV2ViS2l0V2ViVmlldyIsICJpcy1wbGF5aW5nLWF1ZGlv IiwgdGVzdFdlYlZpZXdJc1BsYXlpbmdBdWRpbyk7CiAgICAgV2ViVmlld1Rlc3Q6OmFkZCgiV2Vi S2l0V2ViVmlldyIsICJiYWNrZ3JvdW5kLWNvbG9yIiwgdGVzdFdlYlZpZXdCYWNrZ3JvdW5kQ29s b3IpOwogICAgIFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAicHJlZmVycmVkLXNp emUiLCB0ZXN0V2ViVmlld1ByZWZlcnJlZFNpemUpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdl YktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9UZXN0TWFpbi5oIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9n dGsvV2ViS2l0Mkd0ay9UZXN0TWFpbi5oCmluZGV4IDYwNTRmZTA5ZDQ3OWE4ODA2MDlmMzY1MjI1 ZDg5M2M4NjI2ZWM5YzQuLmY2OGFmMmE5NjUxNjJiM2QyZWZiOWJkZTk1NzgwMDFhNGI1NWFjZmYg MTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvVGVzdE1haW4u aAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1Rlc3RNYWluLmgKQEAg LTQzLDYgKzQzLDI1IEBACiAgICAgICAgIGdfdGVzdF9hZGQodGVzdFBhdGguZ2V0KCksIENsYXNz TmFtZSwgMCwgQ2xhc3NOYW1lOjpzZXRVcCwgdGVzdEZ1bmMsIENsYXNzTmFtZTo6dGVhckRvd24p OyBcCiAgICAgfQogCisjZGVmaW5lIE1BS0VfR0xJQl9URVNUX0ZJWFRVUkVfV0lUSF9TRVRVUF9U RUFSRE9XTihDbGFzc05hbWUsIHNldHVwLCB0ZWFyZG93bikgXAorICAgIHN0YXRpYyB2b2lkIHNl dFVwKENsYXNzTmFtZSogZml4dHVyZSwgZ2NvbnN0cG9pbnRlciBkYXRhKSBcCisgICAgeyBcCisg ICAgICAgIGlmIChzZXR1cCkgXAorICAgICAgICAgICAgc2V0dXAoKTsgXAorICAgICAgICBuZXcg KGZpeHR1cmUpIENsYXNzTmFtZTsgXAorICAgIH0gXAorICAgIHN0YXRpYyB2b2lkIHRlYXJEb3du KENsYXNzTmFtZSogZml4dHVyZSwgZ2NvbnN0cG9pbnRlciBkYXRhKSBcCisgICAgeyBcCisgICAg ICAgIGZpeHR1cmUtPn5DbGFzc05hbWUoKTsgXAorICAgICAgICBpZiAodGVhcmRvd24pIFwKKyAg ICAgICAgICAgIHRlYXJkb3duKCk7IFwKKyAgICB9IFwKKyAgICBzdGF0aWMgdm9pZCBhZGQoY29u c3QgY2hhciogc3VpdGVOYW1lLCBjb25zdCBjaGFyKiB0ZXN0TmFtZSwgdm9pZCAoKnRlc3RGdW5j KShDbGFzc05hbWUqLCBjb25zdCB2b2lkKikpIFwKKyAgICB7IFwKKyAgICAgICAgR1VuaXF1ZVB0 cjxnY2hhcj4gdGVzdFBhdGgoZ19zdHJkdXBfcHJpbnRmKCIvd2Via2l0Mi8lcy8lcyIsIHN1aXRl TmFtZSwgdGVzdE5hbWUpKTsgXAorICAgICAgICBnX3Rlc3RfYWRkKHRlc3RQYXRoLmdldCgpLCBD bGFzc05hbWUsIDAsIENsYXNzTmFtZTo6c2V0VXAsIHRlc3RGdW5jLCBDbGFzc05hbWU6OnRlYXJE b3duKTsgXAorICAgIH0KKwogI2RlZmluZSBBU1NFUlRfQ01QX0NTVFJJTkcoczEsIGNtcCwgczIp IFwKICAgICBkbyB7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBcCiAgICAgICAgIENTdHJpbmcgX19zMSA9IChzMSk7ICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXApkaWZmIC0tZ2l0IGEvVG9v bHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJLaXRUZXN0U2VydmVyLmNwcCBiL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViS2l0VGVzdFNlcnZlci5jcHAKaW5k ZXggZGU5NDY2YzM5ZDcxY2ZjMmFiZjQ0OWZjZmRlMzg5YjU0NDlkZjMyNy4uYzQ5MjlkZThhMDhl ODVlZmFkYWM2Y2Q0OWNiMTRkMDQxNTY3NTI0YiAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktp dEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJLaXRUZXN0U2VydmVyLmNwcAorKysgYi9Ub29scy9UZXN0 V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYktpdFRlc3RTZXJ2ZXIuY3BwCkBAIC02OCw3ICs2 OCwxNSBAQCB2b2lkIFdlYktpdFRlc3RTZXJ2ZXI6OnJ1bihTb3VwU2VydmVyQ2FsbGJhY2sgc2Vy dmVyQ2FsbGJhY2spCiAgICAgfQogfQogCi1DU3RyaW5nIFdlYktpdFRlc3RTZXJ2ZXI6OmdldFVS SUZvclBhdGgoY29uc3QgY2hhciogcGF0aCkKK0NTdHJpbmcgV2ViS2l0VGVzdFNlcnZlcjo6c2Vj dXJpdHlPcmlnaW4oKSBjb25zdAoreworICAgIC8vIFRoZSBzZWN1cml0eSBvcmlnaW4gaXMgdGhl IGJhc2UgVVJJIG1pbnVzIHRoZSB0cmFpbGluZyBzbGFzaC4KKyAgICBHVW5pcXVlUHRyPGdjaGFy PiB1cmlTdHJpbmcoc291cF91cmlfdG9fc3RyaW5nKG1fYmFzZVVSSSwgRkFMU0UpKTsKKyAgICB1 cmlTdHJpbmcuZ2V0KClbc3RybGVuKHVyaVN0cmluZy5nZXQoKSkgLSAxXSA9ICdcMCc7CisgICAg cmV0dXJuIHVyaVN0cmluZy5nZXQoKTsKK30KKworQ1N0cmluZyBXZWJLaXRUZXN0U2VydmVyOjpn ZXRVUklGb3JQYXRoKGNvbnN0IGNoYXIqIHBhdGgpIGNvbnN0CiB7CiAgICAgU291cFVSSSogdXJp ID0gc291cF91cmlfbmV3X3dpdGhfYmFzZShtX2Jhc2VVUkksIHBhdGgpOwogICAgIEdVbmlxdWVQ dHI8Z2NoYXI+IHVyaVN0cmluZyhzb3VwX3VyaV90b19zdHJpbmcodXJpLCBGQUxTRSkpOwpkaWZm IC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJLaXRUZXN0U2Vy dmVyLmggYi9Ub29scy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYktpdFRlc3RTZXJ2 ZXIuaAppbmRleCA1OGYwMTlmYWI4NjAxYzJkMTMxNDZhY2M1NGZjNzg4ZGNlMjljNjhhLi5kMzgy MDk1YjI2ZjNiMjM3OTkzZTJhOTIyZTNjMmFkYzNhNGE3NWJhIDEwMDY0NAotLS0gYS9Ub29scy9U ZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYktpdFRlc3RTZXJ2ZXIuaAorKysgYi9Ub29s cy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYktpdFRlc3RTZXJ2ZXIuaApAQCAtMzks OCArMzksOCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB+V2ViS2l0VGVzdFNlcnZlcigpOwogCiAg ICAgU291cFVSSSogYmFzZVVSSSgpIHsgcmV0dXJuIG1fYmFzZVVSSTsgfQotCi0gICAgQ1N0cmlu ZyBnZXRVUklGb3JQYXRoKGNvbnN0IGNoYXIqIHBhdGgpOworICAgIENTdHJpbmcgc2VjdXJpdHlP cmlnaW4oKSBjb25zdDsKKyAgICBDU3RyaW5nIGdldFVSSUZvclBhdGgoY29uc3QgY2hhciogcGF0 aCkgY29uc3Q7CiAgICAgdm9pZCBydW4oU291cFNlcnZlckNhbGxiYWNrKTsKIAogcHJpdmF0ZToK ZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViVmlld1Rl c3QuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJWaWV3VGVzdC5j cHAKaW5kZXggNGEyMjE0NWM0NzE5OTJiZTQwY2YzZGRjNTQ1OTA1ZDFhYzMzMDZmNC4uYmQ5NzFi YTNmZjI1YjYwMjRjYWY0MTFiMTA5MmE1MjY5OTNmNDNmNCAxMDA2NDQKLS0tIGEvVG9vbHMvVGVz dFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJWaWV3VGVzdC5jcHAKKysrIGIvVG9vbHMvVGVz dFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJWaWV3VGVzdC5jcHAKQEAgLTI0LDE5ICsyNCwx NCBAQAogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0pTUmV0YWluUHRyLmg+CiAjaW5jbHVkZSA8 V2ViQ29yZS9HVW5pcXVlUHRyR3RrLmg+CiAKK2Jvb2wgV2ViVmlld1Rlc3Q6OnNob3VsZEluaXRp YWxpemVXZWJWaWV3SW5Db25zdHJ1Y3RvciA9IHRydWU7CisKIFdlYlZpZXdUZXN0OjpXZWJWaWV3 VGVzdCgpCiAgICAgOiBtX3VzZXJDb250ZW50TWFuYWdlcihhZG9wdEdSZWYod2Via2l0X3VzZXJf Y29udGVudF9tYW5hZ2VyX25ldygpKSkKLSAgICAsIG1fd2ViVmlldyhXRUJLSVRfV0VCX1ZJRVco Z19vYmplY3RfcmVmX3NpbmsoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX1dFQl9WSUVXLCAid2Vi LWNvbnRleHQiLCBtX3dlYkNvbnRleHQuZ2V0KCksICJ1c2VyLWNvbnRlbnQtbWFuYWdlciIsIG1f dXNlckNvbnRlbnRNYW5hZ2VyLmdldCgpLCBudWxscHRyKSkpKQogICAgICwgbV9tYWluTG9vcChn X21haW5fbG9vcF9uZXcobnVsbHB0ciwgVFJVRSkpCi0gICAgLCBtX3BhcmVudFdpbmRvdyhudWxs cHRyKQotICAgICwgbV9qYXZhc2NyaXB0UmVzdWx0KG51bGxwdHIpCi0gICAgLCBtX3Jlc291cmNl RGF0YVNpemUoMCkKLSAgICAsIG1fc3VyZmFjZShudWxscHRyKQotICAgICwgbV9leHBlY3RlZFdl YlByb2Nlc3NDcmFzaChmYWxzZSkKIHsKLSAgICBhc3NlcnRPYmplY3RJc0RlbGV0ZWRXaGVuVGVz dEZpbmlzaGVzKEdfT0JKRUNUKG1fd2ViVmlldykpOwotICAgIGFzc2VydE9iamVjdElzRGVsZXRl ZFdoZW5UZXN0RmluaXNoZXMoR19PQkpFQ1QobV91c2VyQ29udGVudE1hbmFnZXIuZ2V0KCkpKTsK LSAgICBnX3NpZ25hbF9jb25uZWN0KG1fd2ViVmlldywgIndlYi1wcm9jZXNzLWNyYXNoZWQiLCBH X0NBTExCQUNLKFdlYlZpZXdUZXN0Ojp3ZWJQcm9jZXNzQ3Jhc2hlZCksIHRoaXMpOworICAgIGlm IChzaG91bGRJbml0aWFsaXplV2ViVmlld0luQ29uc3RydWN0b3IpCisgICAgICAgIGluaXRpYWxp emVXZWJWaWV3KCk7CiB9CiAKIFdlYlZpZXdUZXN0Ojp+V2ViVmlld1Rlc3QoKQpAQCAtNTEsNiAr NDYsMTUgQEAgV2ViVmlld1Rlc3Q6On5XZWJWaWV3VGVzdCgpCiAgICAgZ19tYWluX2xvb3BfdW5y ZWYobV9tYWluTG9vcCk7CiB9CiAKK3ZvaWQgV2ViVmlld1Rlc3Q6OmluaXRpYWxpemVXZWJWaWV3 KCkKK3sKKyAgICBnX2Fzc2VydCghbV93ZWJWaWV3KTsKKyAgICBtX3dlYlZpZXcgPSBXRUJLSVRf V0VCX1ZJRVcoZ19vYmplY3RfcmVmX3NpbmsoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX1dFQl9W SUVXLCAid2ViLWNvbnRleHQiLCBtX3dlYkNvbnRleHQuZ2V0KCksICJ1c2VyLWNvbnRlbnQtbWFu YWdlciIsIG1fdXNlckNvbnRlbnRNYW5hZ2VyLmdldCgpLCBudWxscHRyKSkpOworICAgIGFzc2Vy dE9iamVjdElzRGVsZXRlZFdoZW5UZXN0RmluaXNoZXMoR19PQkpFQ1QobV93ZWJWaWV3KSk7Cisg ICAgYXNzZXJ0T2JqZWN0SXNEZWxldGVkV2hlblRlc3RGaW5pc2hlcyhHX09CSkVDVChtX3VzZXJD b250ZW50TWFuYWdlci5nZXQoKSkpOworICAgIGdfc2lnbmFsX2Nvbm5lY3QobV93ZWJWaWV3LCAi d2ViLXByb2Nlc3MtY3Jhc2hlZCIsIEdfQ0FMTEJBQ0soV2ViVmlld1Rlc3Q6OndlYlByb2Nlc3ND cmFzaGVkKSwgdGhpcyk7Cit9CisKIGdib29sZWFuIFdlYlZpZXdUZXN0Ojp3ZWJQcm9jZXNzQ3Jh c2hlZChXZWJLaXRXZWJWaWV3KiwgV2ViVmlld1Rlc3QqIHRlc3QpCiB7CiAgICAgaWYgKHRlc3Qt Pm1fZXhwZWN0ZWRXZWJQcm9jZXNzQ3Jhc2gpIHsKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViVmlld1Rlc3QuaCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkv Z3RrL1dlYktpdDJHdGsvV2ViVmlld1Rlc3QuaAppbmRleCBhMzAwMWIyZGUzNDE4ZTcwYzlhNzM5 YmVjYTdhZTIzMzY3MDRlY2MyLi40ZjBjNGM3YmY1OGQwMzU1OTYyZjY5YWUzOGE0YjAyODdhMzgy NjNiIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYlZp ZXdUZXN0LmgKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJWaWV3 VGVzdC5oCkBAIC0zMSw2ICszMSw5IEBAIHB1YmxpYzoKICAgICBXZWJWaWV3VGVzdCgpOwogICAg IHZpcnR1YWwgfldlYlZpZXdUZXN0KCk7CiAKKyAgICBzdGF0aWMgYm9vbCBzaG91bGRJbml0aWFs aXplV2ViVmlld0luQ29uc3RydWN0b3I7CisgICAgdm9pZCBpbml0aWFsaXplV2ViVmlldygpOwor CiAgICAgdmlydHVhbCB2b2lkIGxvYWRVUkkoY29uc3QgY2hhciogdXJpKTsKICAgICB2aXJ0dWFs IHZvaWQgbG9hZEh0bWwoY29uc3QgY2hhciogaHRtbCwgY29uc3QgY2hhciogYmFzZVVSSSk7CiAg ICAgdmlydHVhbCB2b2lkIGxvYWRQbGFpblRleHQoY29uc3QgY2hhciogcGxhaW5UZXh0KTsKQEAg LTgxLDE3ICs4NCwxNyBAQCBwdWJsaWM6CiAgICAgc3RhdGljIGdib29sZWFuIHdlYlByb2Nlc3ND cmFzaGVkKFdlYktpdFdlYlZpZXcqLCBXZWJWaWV3VGVzdCopOwogCiAgICAgR1JlZlB0cjxXZWJL aXRVc2VyQ29udGVudE1hbmFnZXI+IG1fdXNlckNvbnRlbnRNYW5hZ2VyOwotICAgIFdlYktpdFdl YlZpZXcqIG1fd2ViVmlldzsKKyAgICBXZWJLaXRXZWJWaWV3KiBtX3dlYlZpZXcgeyBudWxscHRy IH07CiAgICAgR01haW5Mb29wKiBtX21haW5Mb29wOwogICAgIENTdHJpbmcgbV9hY3RpdmVVUkk7 Ci0gICAgR3RrV2lkZ2V0KiBtX3BhcmVudFdpbmRvdzsKKyAgICBHdGtXaWRnZXQqIG1fcGFyZW50 V2luZG93IHsgbnVsbHB0ciB9OwogICAgIENTdHJpbmcgbV9leHBlY3RlZFRpdGxlOwotICAgIFdl YktpdEphdmFzY3JpcHRSZXN1bHQqIG1famF2YXNjcmlwdFJlc3VsdDsKLSAgICBHRXJyb3IqKiBt X2phdmFzY3JpcHRFcnJvcjsKLSAgICBHVW5pcXVlUHRyPGNoYXI+IG1fcmVzb3VyY2VEYXRhOwot ICAgIHNpemVfdCBtX3Jlc291cmNlRGF0YVNpemU7Ci0gICAgY2Fpcm9fc3VyZmFjZV90KiBtX3N1 cmZhY2U7Ci0gICAgYm9vbCBtX2V4cGVjdGVkV2ViUHJvY2Vzc0NyYXNoOworICAgIFdlYktpdEph dmFzY3JpcHRSZXN1bHQqIG1famF2YXNjcmlwdFJlc3VsdCB7IG51bGxwdHIgfTsKKyAgICBHRXJy b3IqKiBtX2phdmFzY3JpcHRFcnJvciB7IG51bGxwdHIgfTsKKyAgICBHVW5pcXVlUHRyPGNoYXI+ IG1fcmVzb3VyY2VEYXRhIHsgbnVsbHB0ciB9OworICAgIHNpemVfdCBtX3Jlc291cmNlRGF0YVNp emUgeyAwIH07CisgICAgY2Fpcm9fc3VyZmFjZV90KiBtX3N1cmZhY2UgeyBudWxscHRyIH07Cisg ICAgYm9vbCBtX2V4cGVjdGVkV2ViUHJvY2Vzc0NyYXNoIHsgZmFsc2UgfTsKIAogcHJpdmF0ZToK ICAgICB2b2lkIGRvTW91c2VCdXR0b25FdmVudChHZGtFdmVudFR5cGUsIGludCwgaW50LCB1bnNp Z25lZCwgdW5zaWduZWQpOwo= 297861 2016-12-30 12:27:53 -0800 2017-01-03 15:00:32 -0800 Patch bug-163366-20161230142635.patch text/plain 55424 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjEwMjEyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggNTI4MmRlNjkyNWFjOGVi OTcyYTRlMWRjOWQ3MWM5ZDU2MjMxNDg4MC4uZTY5ZTNjNTcyYjM1ZTQ2ZjM4MGExNmVhYzExYjJi ZTI4ZDk2ZDExOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDY2IEBACisyMDE2LTEyLTI5ICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBO byB3YXkgZm9yIGFwcGxpY2F0aW9ucyB0byBzZXQgbm90aWZpY2F0aW9uIHBlcm1pc3Npb25zIHdp dGhvdXQgd2FpdGluZyBmb3IgcGVybWlzc2lvbiByZXF1ZXN0CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjMzNjYKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXZWJzaXRlcyBjYW4gY2hlY2sgdGhlIE5vdGlm aWNhdGlvbi5wZXJtaXNzaW9uIERPTSBwcm9wZXJ0eSB0byBjaGVjayBpZiB0aGV5IGhhdmUgcGVy bWlzc2lvbgorICAgICAgICB0byBzaG93IG5vdGlmaWNhdGlvbnMgKndpdGhvdXQgdHJpZ2dlcmlu ZyBhIHBlcm1pc3Npb24gcmVxdWVzdCouIEJ1dCB0aGUgV2ViS2l0R1RLKyBBUEkgaGFzCisgICAg ICAgIG5vIHdheSB0byBhZmZpcm1hdGl2ZWx5IGluZGljYXRlIG5vdGlmaWNhdGlvbnMgYXJlIGFs bG93ZWQgd2l0aG91dCBhIHBlcm1pc3Npb24gcmVxdWVzdC4gVGhlCisgICAgICAgIG9ubHkgd2F5 IGlzIHZpYSB0aGUgcGVybWlzc2lvbiByZXF1ZXN0IEFQSSwgd2hpY2ggaXMgdG9vIGxhdGUuIEl0 J3MgYSBwcm9ibGVtIGZvciBFcGlwaGFueS4KKyAgICAgICAgRm9yIGV4YW1wbGUsIG9wZW4gdGhl IFJpb3QgTWF0cml4IGNsaWVudCBpbiBhIHdlYiBhcHA7IHlvdSB3aWxsIGltbWVkaWF0ZWx5IHNl ZSBhbiBpbmZvIGJhcgorICAgICAgICBpbmZvcm1pbmcgdGhlIHVzZXIgdGhhdCBSaW90IGRvZXMg bm90IGhhdmUgcGVybWlzc2lvbiB0byBzZW5kIGRlc2t0b3Agbm90aWZpY2F0aW9ucywgZXZlbgor ICAgICAgICB0aG91Z2ggRXBpcGhhbnkgYXV0b21hdGljYWxseSBncmFudHMgbm90aWZpY2F0aW9u IHBlcm1pc3Npb24gaW4gd2ViIGFwcCBtb2RlIHdoZW4gcmVxdWVzdGVkLgorICAgICAgICBUaGlz IHByb2JsZW0gaXMgbm90IGV4Y2x1c2l2ZSB0byB3ZWIgYXBwczsgdGhlcmUgaXMgc2ltcGx5IG5v IHdheSBmb3Igbm90aWZpY2F0aW9uCisgICAgICAgIHBlcm1pc3Npb24gdG8gYmUgc2V0IGNvcnJl Y3RseSBwcmlvciB0byBhIHBlcm1pc3Npb24gcmVxdWVzdCBmb3IgaXQuIEZpeCB0aGlzIGJ5IGlu dHJvZHVjaW5nCisgICAgICAgIGEgd2Via2l0X3dlYl9jb250ZXh0X3NldF9pbml0aWFsX25vdGlm aWNhdGlvbl9wZXJtaXNzaW9ucygpIEFQSSwgYW5kIGFkZCBhIHNpZ25hbAorICAgICAgICBXZWJL aXRXZWJDb250ZXh0OjpzZXQtaW5pdGlhbC1ub3RpZmljYXRpb24tcGVybWlzc2lvbnMgdG8gaW5k aWNhdGUgd2hlbiBpdCBzaG91bGQgYmUgY2FsbGVkLgorCisgICAgICAgIEFsc28sIGV4cG9zZSBX ZWJLaXRTZWN1cml0eU9yaWdpbiBBUEkuIFRoaXMgQVBJIHdhcyBvcmlnaW5hbGx5IGRldmVsb3Bl ZCBieSBDYXJsb3MgR2FyY2lhCisgICAgICAgIGxhc3QgeWVhciBmb3IgYSBXZWJLaXRXZWJzaXRl RGF0YU1hbmFnZXIgZW5oYW5jZW1lbnQgdGhhdCBoYXMgbmV2ZXIgbGFuZGVkLiBJIGhhdmUgdXBk YXRlZAorICAgICAgICBpdCB0byBhY2NvdW50IGZvciBXZWJDb3JlOjpTZWN1cml0eU9yaWdpbiBu b3cgdXNpbmcgc3RkOjpvcHRpb25hbCBmb3IgcG9ydHMsIGFuZCBhZGRlZAorICAgICAgICBfZnJv bV9zdHJpbmcoKSBhbmQgX3RvX3N0cmluZygpIG1ldGhvZHMgdG8gbWFrZSBpdCBjb252ZW5pZW50 IHRvIHVzZSBmb3Igbm90aWZpY2F0aW9uCisgICAgICAgIHBlcm1pc3Npb25zLiBXZWJLaXRTZWN1 cml0eU9yaWdpbiBzdXBlcmlvciB0byBwYXNzaW5nIHN0cmluZ3MgdG8gaW5kaWNhdGUgd2hpY2gg b3JpZ2lucyBoYXZlCisgICAgICAgIHBlcm1pc3Npb24gdG8gc2hvdyBub3RpZmljYXRpb25zLgor CisgICAgICAgICogUGxhdGZvcm1HVEsuY21ha2U6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0QXV0b2NsZWFudXBzLmg6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2Vi S2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuY3BwOgorICAgICAgICAobm90aWZpY2F0aW9uUGVybWlz c2lvbnNDYWxsYmFjayk6CisgICAgICAgIChXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcjo6Y3Jl YXRlKToKKyAgICAgICAgKFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyOjpXZWJLaXROb3RpZmlj YXRpb25Qcm92aWRlcik6CisgICAgICAgIChXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcjo6bm90 aWZpY2F0aW9uUGVybWlzc2lvbnMpOgorICAgICAgICAoV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlk ZXI6OnNldE5vdGlmaWNhdGlvblBlcm1pc3Npb25zKToKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9B UEkvZ3RrL1dlYktpdFNlY3VyaXR5T3JpZ2luLmNwcDogQWRkZWQuCisgICAgICAgIChfV2ViS2l0 U2VjdXJpdHlPcmlnaW46Ol9XZWJLaXRTZWN1cml0eU9yaWdpbik6CisgICAgICAgICh3ZWJraXRT ZWN1cml0eU9yaWdpbkNyZWF0ZSk6CisgICAgICAgICh3ZWJraXRTZWN1cml0eU9yaWdpbkdldFNl Y3VyaXR5T3JpZ2luKToKKyAgICAgICAgKHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fbmV3KToKKyAg ICAgICAgKHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fbmV3X2Zyb21fc3RyaW5nKToKKyAgICAgICAg KHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fcmVmKToKKyAgICAgICAgKHdlYmtpdF9zZWN1cml0eV9v cmlnaW5fdW5yZWYpOgorICAgICAgICAod2Via2l0X3NlY3VyaXR5X29yaWdpbl9nZXRfcHJvdG9j b2wpOgorICAgICAgICAod2Via2l0X3NlY3VyaXR5X29yaWdpbl9nZXRfaG9zdCk6CisgICAgICAg ICh3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dldF9wb3J0KToKKyAgICAgICAgKHdlYmtpdF9zZWN1 cml0eV9vcmlnaW5fdG9fc3RyaW5nKToKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRTZWN1cml0eU9yaWdpbi5oOiBBZGRlZC4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRTZWN1cml0eU9yaWdpblByaXZhdGUuaDogQ29waWVkIGZyb20gVG9vbHMvVGVzdFdlYktp dEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJLaXRUZXN0U2VydmVyLmguCisgICAgICAgICogVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dC5jcHA6CisgICAgICAgICh3ZWJraXRXZWJDb250 ZXh0Q29uc3RydWN0ZWQpOgorICAgICAgICAod2Via2l0X3dlYl9jb250ZXh0X2NsYXNzX2luaXQp OgorICAgICAgICAoYWRkT3JpZ2luVG9NYXApOgorICAgICAgICAoYWRkQWxsb3dlZE9yaWdpblRv TWFwKToKKyAgICAgICAgKGFkZERpc2FsbG93ZWRPcmlnaW5Ub01hcCk6CisgICAgICAgICh3ZWJr aXRfd2ViX2NvbnRleHRfc2V0X2luaXRpYWxfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25zKToKKyAg ICAgICAgKHdlYmtpdFdlYkNvbnRleHRTZXRJbml0aWFsTm90aWZpY2F0aW9uUGVybWlzc2lvbnMp OgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQuaDoKKyAgICAg ICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0UHJpdmF0ZS5oOgorICAgICAg ICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0Ogor ICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1kb2NzLnNnbWw6Cisg ICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvd2Via2l0Mi5oOgorCiAyMDE2LTEyLTI3ICBBbGV4 IENocmlzdGVuc2VuICA8YWNocmlzdGVuc2VuQHdlYmtpdC5vcmc+CiAKICAgICAgICAgcmVkdWNl IFBhc3NSZWZQdHIgdXNlIGluIFdlYktpdDIKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1Bs YXRmb3JtR1RLLmNtYWtlIGIvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UKaW5kZXgg MGE1ZTRkNGFlM2ZmOTA3MmFiZmQyNTlkNTM2ZjdiYzFjODljMWVmMy4uNDgzODQ3ODMxNDliZDA5 MjE3MjhiOGJmZmI3ZTI0NGI0NzFjZmQ4MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvUGxh dGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UKQEAg LTIyMCw2ICsyMjAsOSBAQCBsaXN0KEFQUEVORCBXZWJLaXQyX1NPVVJDRVMKICAgICBVSVByb2Nl c3MvQVBJL2d0ay9XZWJLaXRTZWN1cml0eU1hbmFnZXIuY3BwCiAgICAgVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0U2VjdXJpdHlNYW5hZ2VyLmgKICAgICBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRT ZWN1cml0eU1hbmFnZXJQcml2YXRlLmgKKyAgICBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRTZWN1 cml0eU9yaWdpbi5jcHAKKyAgICBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRTZWN1cml0eU9yaWdp bi5oCisgICAgVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2VjdXJpdHlPcmlnaW5Qcml2YXRlLmgK ICAgICBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRTZXR0aW5ncy5jcHAKICAgICBVSVByb2Nlc3Mv QVBJL2d0ay9XZWJLaXRTZXR0aW5ncy5oCiAgICAgVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2V0 dGluZ3NQcml2YXRlLmgKQEAgLTUzNCw2ICs1MzcsNyBAQCBzZXQoV2ViS2l0MkdUS19JTlNUQUxM RURfSEVBREVSUwogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFJl c3BvbnNlUG9saWN5RGVjaXNpb24uaAogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9BUEkv Z3RrL1dlYktpdFNjcmlwdERpYWxvZy5oCiAgICAgJHtXRUJLSVQyX0RJUn0vVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0U2VjdXJpdHlNYW5hZ2VyLmgKKyAgICAke1dFQktJVDJfRElSfS9VSVByb2Nl c3MvQVBJL2d0ay9XZWJLaXRTZWN1cml0eU9yaWdpbi5oCiAgICAgJHtXRUJLSVQyX0RJUn0vVUlQ cm9jZXNzL0FQSS9ndGsvV2ViS2l0U2V0dGluZ3MuaAogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFVSSVJlcXVlc3QuaAogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFVSSVJlc3BvbnNlLmgKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEF1dG9jbGVhbnVwcy5oIGIvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0QXV0b2NsZWFudXBzLmgKaW5kZXggZjg3MmYzMDY4 MTBjMTFhYWJkMjg0NGEwZjgzYzE1YWZmNTYwYmMzZi4uN2IwN2U4OTViMGJjNzZjNjc0NGZiMmRj YWMwMzgxOTc4ZmVmNDM0MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0QXV0b2NsZWFudXBzLmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L0FQSS9ndGsvV2ViS2l0QXV0b2NsZWFudXBzLmgKQEAgLTc1LDYgKzc1LDcgQEAgR19ERUZJTkVf QVVUT1BUUl9DTEVBTlVQX0ZVTkMgKFdlYktpdENyZWRlbnRpYWwsIHdlYmtpdF9jcmVkZW50aWFs X2ZyZWUpCiBHX0RFRklORV9BVVRPUFRSX0NMRUFOVVBfRlVOQyAoV2ViS2l0SmF2YXNjcmlwdFJl c3VsdCwgd2Via2l0X2phdmFzY3JpcHRfcmVzdWx0X3VucmVmKQogR19ERUZJTkVfQVVUT1BUUl9D TEVBTlVQX0ZVTkMgKFdlYktpdE1pbWVJbmZvLCB3ZWJraXRfbWltZV9pbmZvX3VucmVmKQogR19E RUZJTkVfQVVUT1BUUl9DTEVBTlVQX0ZVTkMgKFdlYktpdE5hdmlnYXRpb25BY3Rpb24sIHdlYmtp dF9uYXZpZ2F0aW9uX2FjdGlvbl9mcmVlKQorR19ERUZJTkVfQVVUT1BUUl9DTEVBTlVQX0ZVTkMg KFdlYktpdFNlY3VyaXR5T3JpZ2luLCB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3VucmVmKQogR19E RUZJTkVfQVVUT1BUUl9DTEVBTlVQX0ZVTkMgKFdlYktpdFVzZXJTY3JpcHQsIHdlYmtpdF91c2Vy X3NjcmlwdF91bnJlZikKIEdfREVGSU5FX0FVVE9QVFJfQ0xFQU5VUF9GVU5DIChXZWJLaXRVc2Vy U3R5bGVTaGVldCwgd2Via2l0X3VzZXJfc3R5bGVfc2hlZXRfdW5yZWYpCiBHX0RFRklORV9BVVRP UFRSX0NMRUFOVVBfRlVOQyAoV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSwgd2Via2l0X3dlYl92 aWV3X3Nlc3Npb25fc3RhdGVfdW5yZWYpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5jcHAgYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5jcHAKaW5k ZXggYTgwZTY4Njc3OTkwMGFiZGIwMTE1MGFiZjJmMzkwYzE4YWYwN2RhOC4uMDVmMGI4MWJjMDQy MzY1ZTBhNDA5ODhmYjAyZGZjZjBjZWI5ZmE1NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVy LmNwcApAQCAtMjgsOCArMjgsMTAgQEAKICNpbmNsdWRlICJXZWJLaXROb3RpZmljYXRpb25Qcm92 aWRlci5oIgogCiAjaW5jbHVkZSAiQVBJQXJyYXkuaCIKKyNpbmNsdWRlICJBUElEaWN0aW9uYXJ5 LmgiCiAjaW5jbHVkZSAiV0tOb3RpZmljYXRpb25NYW5hZ2VyLmgiCiAjaW5jbHVkZSAiV2ViS2l0 Tm90aWZpY2F0aW9uUHJpdmF0ZS5oIgorI2luY2x1ZGUgIldlYktpdFdlYkNvbnRleHRQcml2YXRl LmgiCiAjaW5jbHVkZSAiV2ViS2l0V2ViVmlld1ByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJOb3Rp ZmljYXRpb25NYW5hZ2VyUHJveHkuaCIKICNpbmNsdWRlICJXZWJQYWdlUHJveHkuaCIKQEAgLTUy LDYgKzU0LDExIEBAIHN0YXRpYyB2b2lkIGNhbmNlbENhbGxiYWNrKFdLTm90aWZpY2F0aW9uUmVm IG5vdGlmaWNhdGlvbiwgY29uc3Qgdm9pZCogY2xpZW50SW5mCiAgICAgdG9Ob3RpZmljYXRpb25Q cm92aWRlcihjbGllbnRJbmZvKS0+Y2FuY2VsKCp0b0ltcGwobm90aWZpY2F0aW9uKSk7CiB9CiAK K3N0YXRpYyBXS0RpY3Rpb25hcnlSZWYgbm90aWZpY2F0aW9uUGVybWlzc2lvbnNDYWxsYmFjayhj b25zdCB2b2lkKiBjbGllbnRJbmZvKQoreworICAgIHJldHVybiB0b0FQSSh0b05vdGlmaWNhdGlv blByb3ZpZGVyKGNsaWVudEluZm8pLT5ub3RpZmljYXRpb25QZXJtaXNzaW9ucygpLmxlYWtSZWYo KSk7Cit9CisKIHN0YXRpYyB2b2lkIGNsZWFyTm90aWZpY2F0aW9uc0NhbGxiYWNrKFdLQXJyYXlS ZWYgbm90aWZpY2F0aW9uSURzLCBjb25zdCB2b2lkKiBjbGllbnRJbmZvKQogewogICAgIHRvTm90 aWZpY2F0aW9uUHJvdmlkZXIoY2xpZW50SW5mbyktPmNsZWFyTm90aWZpY2F0aW9ucyh0b0ltcGwo bm90aWZpY2F0aW9uSURzKSk7CkBAIC02MSwxMyArNjgsMTQgQEAgV2ViS2l0Tm90aWZpY2F0aW9u UHJvdmlkZXI6On5XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcigpCiB7CiB9CiAKLVJlZjxXZWJL aXROb3RpZmljYXRpb25Qcm92aWRlcj4gV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI6OmNyZWF0 ZShXZWJOb3RpZmljYXRpb25NYW5hZ2VyUHJveHkqIG5vdGlmaWNhdGlvbk1hbmFnZXIpCitSZWY8 V2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI+IFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyOjpj cmVhdGUoV2ViTm90aWZpY2F0aW9uTWFuYWdlclByb3h5KiBub3RpZmljYXRpb25NYW5hZ2VyLCBX ZWJLaXRXZWJDb250ZXh0KiB3ZWJDb250ZXh0KQogewotICAgIHJldHVybiBhZG9wdFJlZigqbmV3 IFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyKG5vdGlmaWNhdGlvbk1hbmFnZXIpKTsKKyAgICBy ZXR1cm4gYWRvcHRSZWYoKm5ldyBXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcihub3RpZmljYXRp b25NYW5hZ2VyLCB3ZWJDb250ZXh0KSk7CiB9CiAKLVdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVy OjpXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcihXZWJOb3RpZmljYXRpb25NYW5hZ2VyUHJveHkq IG5vdGlmaWNhdGlvbk1hbmFnZXIpCi0gICAgOiBtX25vdGlmaWNhdGlvbk1hbmFnZXIobm90aWZp Y2F0aW9uTWFuYWdlcikKK1dlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyOjpXZWJLaXROb3RpZmlj YXRpb25Qcm92aWRlcihXZWJOb3RpZmljYXRpb25NYW5hZ2VyUHJveHkqIG5vdGlmaWNhdGlvbk1h bmFnZXIsIFdlYktpdFdlYkNvbnRleHQqIHdlYkNvbnRleHQpCisgICAgOiBtX3dlYkNvbnRleHQo d2ViQ29udGV4dCkKKyAgICAsIG1fbm90aWZpY2F0aW9uTWFuYWdlcihub3RpZmljYXRpb25NYW5h Z2VyKQogewogICAgIEFTU0VSVChub3RpZmljYXRpb25NYW5hZ2VyKTsKIApAQCAtODEsNyArODks NyBAQCBXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcjo6V2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlk ZXIoV2ViTm90aWZpY2F0aW9uTWFuYWdlclBybwogICAgICAgICAwLCAvLyBkaWREZXN0cm95Tm90 aWZpY2F0aW9uQ2FsbGJhY2ssCiAgICAgICAgIDAsIC8vIGFkZE5vdGlmaWNhdGlvbk1hbmFnZXJD YWxsYmFjaywKICAgICAgICAgMCwgLy8gcmVtb3ZlTm90aWZpY2F0aW9uTWFuYWdlckNhbGxiYWNr LAotICAgICAgICAwLCAvLyBub3RpZmljYXRpb25QZXJtaXNzaW9uc0NhbGxiYWNrLAorICAgICAg ICBub3RpZmljYXRpb25QZXJtaXNzaW9uc0NhbGxiYWNrLAogICAgICAgICBjbGVhck5vdGlmaWNh dGlvbnNDYWxsYmFjaywKICAgICB9OwogCkBAIC0xNTIsMyArMTYwLDE0IEBAIHZvaWQgV2ViS2l0 Tm90aWZpY2F0aW9uUHJvdmlkZXI6OmNsZWFyTm90aWZpY2F0aW9ucyhjb25zdCBBUEk6OkFycmF5 KiBub3RpZmljYXRpCiAgICAgZm9yIChjb25zdCBhdXRvJiBpdGVtIDogbm90aWZpY2F0aW9uSURz LT5lbGVtZW50c09mVHlwZTxBUEk6OlVJbnQ2ND4oKSkKICAgICAgICAgY2FuY2VsTm90aWZpY2F0 aW9uQnlJRChpdGVtLT52YWx1ZSgpKTsKIH0KKworUmVmUHRyPEFQSTo6RGljdGlvbmFyeT4gV2Vi S2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI6Om5vdGlmaWNhdGlvblBlcm1pc3Npb25zKCkKK3sKKyAg ICB3ZWJraXRXZWJDb250ZXh0U2V0SW5pdGlhbE5vdGlmaWNhdGlvblBlcm1pc3Npb25zKG1fd2Vi Q29udGV4dCk7CisgICAgcmV0dXJuIG1fbm90aWZpY2F0aW9uUGVybWlzc2lvbnM7Cit9CisKK3Zv aWQgV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI6OnNldE5vdGlmaWNhdGlvblBlcm1pc3Npb25z KEhhc2hNYXA8U3RyaW5nLCBSZWZQdHI8QVBJOjpPYmplY3Q+PiYmIHBlcm1pc3Npb25zTWFwKQor eworICAgIG1fbm90aWZpY2F0aW9uUGVybWlzc2lvbnMgPSBBUEk6OkRpY3Rpb25hcnk6OmNyZWF0 ZShXVEZNb3ZlKHBlcm1pc3Npb25zTWFwKSk7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5oIGIvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuaApp bmRleCAyODk0YmEwMDU0M2EwMjQyN2Q5ZmY5MzgxMWNhMTYzZmQ5Njg0Mjg3Li40OWM5YjlhYWZm NWI4ODFkZDJlYmI1MGQ5NjJkMmZmMDVkNGQxODc4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5oCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVy LmgKQEAgLTIyLDYgKzIyLDcgQEAKIAogI2luY2x1ZGUgIldlYktpdFByaXZhdGUuaCIKICNpbmNs dWRlICJXZWJLaXROb3RpZmljYXRpb24uaCIKKyNpbmNsdWRlICJXZWJLaXRXZWJDb250ZXh0Lmgi CiAjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvUmVmLmg+CiAjaW5jbHVk ZSA8d3RmL1JlZkNvdW50ZWQuaD4KQEAgLTM1LDE0ICszNiwxNyBAQCBuYW1lc3BhY2UgV2ViS2l0 IHsKIGNsYXNzIFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyIDogcHVibGljIFJlZkNvdW50ZWQ8 V2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI+IHsKIHB1YmxpYzoKICAgICB2aXJ0dWFsIH5XZWJL aXROb3RpZmljYXRpb25Qcm92aWRlcigpOwotICAgIHN0YXRpYyBSZWY8V2ViS2l0Tm90aWZpY2F0 aW9uUHJvdmlkZXI+IGNyZWF0ZShXZWJOb3RpZmljYXRpb25NYW5hZ2VyUHJveHkqKTsKKyAgICBz dGF0aWMgUmVmPFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyPiBjcmVhdGUoV2ViTm90aWZpY2F0 aW9uTWFuYWdlclByb3h5KiwgV2ViS2l0V2ViQ29udGV4dCopOwogCiAgICAgdm9pZCBzaG93KFdl YlBhZ2VQcm94eSosIGNvbnN0IFdlYk5vdGlmaWNhdGlvbiYpOwogICAgIHZvaWQgY2FuY2VsKGNv bnN0IFdlYk5vdGlmaWNhdGlvbiYpOwogICAgIHZvaWQgY2xlYXJOb3RpZmljYXRpb25zKGNvbnN0 IEFQSTo6QXJyYXkqKTsKIAorICAgIFJlZlB0cjxBUEk6OkRpY3Rpb25hcnk+IG5vdGlmaWNhdGlv blBlcm1pc3Npb25zKCk7CisgICAgdm9pZCBzZXROb3RpZmljYXRpb25QZXJtaXNzaW9ucyhIYXNo TWFwPFN0cmluZywgUmVmUHRyPEFQSTo6T2JqZWN0Pj4mJik7CisKIHByaXZhdGU6Ci0gICAgV2Vi S2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIoV2ViTm90aWZpY2F0aW9uTWFuYWdlclByb3h5Kik7Cisg ICAgV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIoV2ViTm90aWZpY2F0aW9uTWFuYWdlclByb3h5 KiwgV2ViS2l0V2ViQ29udGV4dCopOwogCiAgICAgdm9pZCBjYW5jZWxOb3RpZmljYXRpb25CeUlE KHVpbnQ2NF90KTsKICAgICBzdGF0aWMgdm9pZCBub3RpZmljYXRpb25DbG9zZUNhbGxiYWNrKFdl YktpdE5vdGlmaWNhdGlvbiosIFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyKik7CkBAIC01MCw2 ICs1NCw4IEBAIHByaXZhdGU6CiAKICAgICB2b2lkIHdpdGhkcmF3QW55UHJldmlvdXNOb3RpZmlj YXRpb25NYXRjaGluZ1RhZyhjb25zdCBDU3RyaW5nJik7CiAKKyAgICBXZWJLaXRXZWJDb250ZXh0 KiBtX3dlYkNvbnRleHQ7CisgICAgUmVmUHRyPEFQSTo6RGljdGlvbmFyeT4gbV9ub3RpZmljYXRp b25QZXJtaXNzaW9uczsKICAgICBSZWZQdHI8V2ViTm90aWZpY2F0aW9uTWFuYWdlclByb3h5PiBt X25vdGlmaWNhdGlvbk1hbmFnZXI7CiAgICAgSGFzaE1hcDx1aW50NjRfdCwgR1JlZlB0cjxXZWJL aXROb3RpZmljYXRpb24+PiBtX25vdGlmaWNhdGlvbnM7CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2VjdXJpdHlPcmlnaW4uY3BwIGIvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2VjdXJpdHlPcmlnaW4uY3BwCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLmQ1MGFlMDA1N2ZmNmZkMmZiZDUwNWE1ZTAwYzc5MzdiZTc2NzI2YmQKLS0tIC9k ZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRTZWN1 cml0eU9yaWdpbi5jcHAKQEAgLTAsMCArMSwyNTcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MTcgSWdhbGlhIFMuTC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1l dDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGlu IHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVE IEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5Z IEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRF RCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5P IEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxF IEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZ LCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRF RCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExP U1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9O KSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIg SU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVH TElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBV U0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJ VFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUg IldlYktpdFNlY3VyaXR5T3JpZ2luLmgiCisKKyNpbmNsdWRlICJXZWJLaXRTZWN1cml0eU9yaWdp blByaXZhdGUuaCIKKyNpbmNsdWRlIDxXZWJDb3JlL1VSTFBhcnNlci5oPgorI2luY2x1ZGUgPHd0 Zi90ZXh0L0NTdHJpbmcuaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYktpdDsKKworLyoqCisgKiBT RUNUSU9OOiBXZWJLaXRTZWN1cml0eU9yaWdpbgorICogQFNob3J0X2Rlc2NyaXB0aW9uOiBBIHNl Y3VyaXR5IGJvdW5kYXJ5IGZvciB3ZWJzaXRlcworICogQFRpdGxlOiBXZWJLaXRTZWN1cml0eU9y aWdpbgorICogQFNlZV9hbHNvOiAjV2ViS2l0V2Vic2l0ZURhdGFNYW5hZ2VyLCAjV2ViS2l0U2Vj dXJpdHlNYW5hZ2VyCisgKgorICogV2ViS2l0U2VjdXJpdHlPcmlnaW4gaXMgYSByZXByZXNlbnRh dGlvbiBvZiBhIHNlY3VyaXR5IGRvbWFpbiBkZWZpbmVkCisgKiBieSB3ZWJzaXRlcy4gQW4gb3Jp Z2luIGNvbnNpc3RzIG9mIGEgaG9zdG5hbWUsIGEgcHJvdG9jb2wsIGFuZCBhIHBvcnQKKyAqIG51 bWJlci4gV2Vic2l0ZXMgd2l0aCB0aGUgc2FtZSBzZWN1cml0eSBvcmlnaW4gY2FuIGFjY2VzcyBl YWNoIG90aGVyJ3MKKyAqIHJlc291cmNlcyBmb3IgY2xpZW50LXNpZGUgc2NyaXB0aW5nIG9yIGRh dGFiYXNlIGFjY2Vzcy4KKyAqCisgKiBTaW5jZTogMi4xNgorICovCisKK3N0cnVjdCBfV2ViS2l0 U2VjdXJpdHlPcmlnaW4geworICAgIF9XZWJLaXRTZWN1cml0eU9yaWdpbihXZWJDb3JlOjpTZWN1 cml0eU9yaWdpbiogY29yZVNlY3VyaXR5T3JpZ2luKQorICAgICAgICA6IHNlY3VyaXR5T3JpZ2lu KGNvcmVTZWN1cml0eU9yaWdpbikKKyAgICB7CisgICAgfQorCisgICAgX1dlYktpdFNlY3VyaXR5 T3JpZ2luKFJlZjxXZWJDb3JlOjpTZWN1cml0eU9yaWdpbj4mJiBjb3JlU2VjdXJpdHlPcmlnaW4p CisgICAgICAgIDogc2VjdXJpdHlPcmlnaW4oV1RGTW92ZShjb3JlU2VjdXJpdHlPcmlnaW4pKQor ICAgIHsKKyAgICB9CisKKyAgICBSZWZQdHI8V2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4+IHNlY3Vy aXR5T3JpZ2luOworICAgIENTdHJpbmcgcHJvdG9jb2w7CisgICAgQ1N0cmluZyBob3N0OworICAg IENTdHJpbmcgYXNTdHJpbmc7CisgICAgaW50IHJlZmVyZW5jZUNvdW50OworfTsKKworR19ERUZJ TkVfQk9YRURfVFlQRShXZWJLaXRTZWN1cml0eU9yaWdpbiwgd2Via2l0X3NlY3VyaXR5X29yaWdp biwgd2Via2l0X3NlY3VyaXR5X29yaWdpbl9yZWYsIHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fdW5y ZWYpCisKK1dlYktpdFNlY3VyaXR5T3JpZ2luKiB3ZWJraXRTZWN1cml0eU9yaWdpbkNyZWF0ZShX ZWJDb3JlOjpTZWN1cml0eU9yaWdpbiogY29yZVNlY3VyaXR5T3JpZ2luKQoreworICAgIFdlYktp dFNlY3VyaXR5T3JpZ2luKiBvcmlnaW4gPSBzdGF0aWNfY2FzdDxXZWJLaXRTZWN1cml0eU9yaWdp bio+KGZhc3RNYWxsb2Moc2l6ZW9mKFdlYktpdFNlY3VyaXR5T3JpZ2luKSkpOworICAgIG5ldyAo b3JpZ2luKSBXZWJLaXRTZWN1cml0eU9yaWdpbihjb3JlU2VjdXJpdHlPcmlnaW4pOworICAgIHJl dHVybiBvcmlnaW47Cit9CisKK1dlYktpdFNlY3VyaXR5T3JpZ2luKiB3ZWJraXRTZWN1cml0eU9y aWdpbkNyZWF0ZShSZWY8V2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4+JiYgY29yZVNlY3VyaXR5T3Jp Z2luKQoreworICAgIFdlYktpdFNlY3VyaXR5T3JpZ2luKiBvcmlnaW4gPSBzdGF0aWNfY2FzdDxX ZWJLaXRTZWN1cml0eU9yaWdpbio+KGZhc3RNYWxsb2Moc2l6ZW9mKFdlYktpdFNlY3VyaXR5T3Jp Z2luKSkpOworICAgIG5ldyAob3JpZ2luKSBXZWJLaXRTZWN1cml0eU9yaWdpbihXVEZNb3ZlKGNv cmVTZWN1cml0eU9yaWdpbikpOworICAgIHJldHVybiBvcmlnaW47Cit9CisKK1dlYkNvcmU6OlNl Y3VyaXR5T3JpZ2luJiB3ZWJraXRTZWN1cml0eU9yaWdpbkdldFNlY3VyaXR5T3JpZ2luKFdlYktp dFNlY3VyaXR5T3JpZ2luKiBvcmlnaW4pCit7CisgICAgQVNTRVJUKG9yaWdpbik7CisgICAgcmV0 dXJuICpvcmlnaW4tPnNlY3VyaXR5T3JpZ2luOworfQorCisvKioKKyAqIHdlYmtpdF9zZWN1cml0 eV9vcmlnaW5fbmV3OgorICogQHByb3RvY29sOiBUaGUgcHJvdG9jb2wgZm9yIHRoZSBuZXcgb3Jp Z2luCisgKiBAaG9zdDogVGhlIGhvc3QgZm9yIHRoZSBuZXcgb3JpZ2luCisgKiBAcG9ydDogVGhl IHBvcnQgbnVtYmVyIGZvciB0aGUgbmV3IG9yaWdpbgorICoKKyAqIENyZWF0ZSBhIG5ldyBzZWN1 cml0eSBvcmlnaW4gZnJvbSB0aGUgcHJvdmlkZWQgcHJvdG9jb2wsIGhvc3QgYW5kCisgKiBwb3J0 LgorICoKKyAqIFJldHVybnM6ICh0cmFuc2ZlciBmdWxsKTogQSAjV2ViS2l0U2VjdXJpdHlPcmln aW4uCisgKgorICogU2luY2U6IDIuMTYKKyAqLworV2ViS2l0U2VjdXJpdHlPcmlnaW4qIHdlYmtp dF9zZWN1cml0eV9vcmlnaW5fbmV3KGNvbnN0IGdjaGFyKiBwcm90b2NvbCwgY29uc3QgZ2NoYXIq IGhvc3QsIGd1aW50IHBvcnQpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwocHJvdG9jb2ws IG51bGxwdHIpOworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKGhvc3QsIG51bGxwdHIpOworCisg ICAgc3RkOjpvcHRpb25hbDx1aW50MTZfdD4gb3B0aW9uYWxQb3J0OworICAgIC8vIEZJWE1FOiBU aGlzIGRlZmF1bHQgcHJvdG9jb2wgY2hlY2sgc2hvdWxkIHByb2JhYmx5IG1vdmUgaW50byBXZWJD b3JlLgorICAgIC8vIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjY2 MjQKKyAgICBpZiAocG9ydCAmJiBXZWJDb3JlOjpkZWZhdWx0UG9ydEZvclByb3RvY29sKHByb3Rv Y29sKSAhPSBzdGF0aWNfY2FzdDx1aW50MTZfdD4ocG9ydCkpCisgICAgICAgIG9wdGlvbmFsUG9y dCA9IHBvcnQ7CisKKyAgICByZXR1cm4gd2Via2l0U2VjdXJpdHlPcmlnaW5DcmVhdGUoV2ViQ29y ZTo6U2VjdXJpdHlPcmlnaW46OmNyZWF0ZShTdHJpbmc6OmZyb21VVEY4KHByb3RvY29sKSwgU3Ry aW5nOjpmcm9tVVRGOChob3N0KSwgb3B0aW9uYWxQb3J0KSk7Cit9CisKKy8qKgorICogd2Via2l0 X3NlY3VyaXR5X29yaWdpbl9uZXdfZnJvbV9zdHJpbmc6CisgKiBAdXJpOiBUaGUgVVJJIGZvciB0 aGUgbmV3IG9yaWdpbgorICoKKyAqIENyZWF0ZSBhIG5ldyBzZWN1cml0eSBvcmlnaW4gZnJvbSB0 aGUgcHJvdmlkZWQgVVJJLiBDb21wb25lbnRzIG9mCisgKiBAdXJpIG90aGVyIHRoYW4gcHJvdG9j b2wsIGhvc3QsIGFuZCBwb3J0IHdpbGwgYmUgaWdub3JlZC4KKyAqCisgKiBSZXR1cm5zOiAodHJh bnNmZXIgZnVsbCk6IEEgI1dlYktpdFNlY3VyaXR5T3JpZ2luLgorICoKKyAqIFNpbmNlOiAyLjE2 CisgKi8KK1dlYktpdFNlY3VyaXR5T3JpZ2luKiB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX25ld19m cm9tX3N0cmluZyhjb25zdCBnY2hhciogdXJpKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWls KHVyaSwgbnVsbHB0cik7CisKKyAgICByZXR1cm4gd2Via2l0U2VjdXJpdHlPcmlnaW5DcmVhdGUo V2ViQ29yZTo6U2VjdXJpdHlPcmlnaW46OmNyZWF0ZUZyb21TdHJpbmcoU3RyaW5nOjpmcm9tVVRG OCh1cmkpKSk7Cit9CisKKy8qKgorICogd2Via2l0X3NlY3VyaXR5X29yaWdpbl9yZWY6CisgKiBA b3JpZ2luOiBhICNXZWJLaXRTZWN1cml0eU9yaWdpbgorICoKKyAqIEF0b21pY2FsbHkgaW5jcmVt ZW50cyB0aGUgcmVmZXJlbmNlIGNvdW50IG9mIEBvcmlnaW4gYnkgb25lLgorICogVGhpcyBmdW5j dGlvbiBpcyBNVC1zYWZlIGFuZCBtYXkgYmUgY2FsbGVkIGZyb20gYW55IHRocmVhZC4KKyAqCisg KiBSZXR1cm5zOiBUaGUgcGFzc2VkICNXZWJLaXRTZWN1cml0eU9yaWdpbgorICoKKyAqIFNpbmNl OiAyLjE2CisgKi8KK1dlYktpdFNlY3VyaXR5T3JpZ2luKiB3ZWJraXRfc2VjdXJpdHlfb3JpZ2lu X3JlZihXZWJLaXRTZWN1cml0eU9yaWdpbiogb3JpZ2luKQoreworICAgIGdfcmV0dXJuX3ZhbF9p Zl9mYWlsKG9yaWdpbiwgbnVsbHB0cik7CisKKyAgICBnX2F0b21pY19pbnRfaW5jKCZvcmlnaW4t PnJlZmVyZW5jZUNvdW50KTsKKyAgICByZXR1cm4gb3JpZ2luOworfQorCisvKioKKyAqIHdlYmtp dF9zZWN1cml0eV9vcmlnaW5fdW5yZWY6CisgKiBAb3JpZ2luOiBBICNXZWJLaXRTZWN1cml0eU9y aWdpbgorICoKKyAqIEF0b21pY2FsbHkgZGVjcmVtZW50cyB0aGUgcmVmZXJlbmNlIGNvdW50IG9m IEBvcmlnaW4gYnkgb25lLgorICogSWYgdGhlIHJlZmVyZW5jZSBjb3VudCBkcm9wcyB0byAwLCBh bGwgbWVtb3J5IGFsbG9jYXRlZCBieQorICogI1dlYktpdFNlY3VyaXR5T3JpZ2luIGlzIHJlbGVh c2VkLiBUaGlzIGZ1bmN0aW9uIGlzIE1ULXNhZmUgYW5kIG1heSBiZQorICogY2FsbGVkIGZyb20g YW55IHRocmVhZC4KKyAqCisgKiBTaW5jZTogMi4xNgorICovCit2b2lkIHdlYmtpdF9zZWN1cml0 eV9vcmlnaW5fdW5yZWYoV2ViS2l0U2VjdXJpdHlPcmlnaW4qIG9yaWdpbikKK3sKKyAgICBnX3Jl dHVybl9pZl9mYWlsKG9yaWdpbik7CisKKyAgICBpZiAoZ19hdG9taWNfaW50X2RlY19hbmRfdGVz dCgmb3JpZ2luLT5yZWZlcmVuY2VDb3VudCkpIHsKKyAgICAgICAgb3JpZ2luLT5+V2ViS2l0U2Vj dXJpdHlPcmlnaW4oKTsKKyAgICAgICAgZmFzdEZyZWUob3JpZ2luKTsKKyAgICB9Cit9CisKKy8q KgorICogd2Via2l0X3NlY3VyaXR5X29yaWdpbl9nZXRfcHJvdG9jb2w6CisgKiBAb3JpZ2luOiBh ICNXZWJLaXRTZWN1cml0eU9yaWdpbgorICoKKyAqIEdldCB0aGUgcHJvdG9jb2wgb2YgQG9yaWdp bgorICoKKyAqIFJldHVybnM6IFRoZSBwcm90b2NvbCBvZiB0aGUgI1dlYktpdFNlY3VyaXR5T3Jp Z2luLgorICoKKyAqIFNpbmNlOiAyLjE2CisgKi8KK2NvbnN0IGdjaGFyKiB3ZWJraXRfc2VjdXJp dHlfb3JpZ2luX2dldF9wcm90b2NvbChXZWJLaXRTZWN1cml0eU9yaWdpbiogb3JpZ2luKQorewor ICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKG9yaWdpbiwgbnVsbHB0cik7CisKKyAgICBpZiAob3Jp Z2luLT5wcm90b2NvbC5pc051bGwoKSkKKyAgICAgICAgb3JpZ2luLT5wcm90b2NvbCA9IG9yaWdp bi0+c2VjdXJpdHlPcmlnaW4tPnByb3RvY29sKCkudXRmOCgpOworICAgIHJldHVybiBvcmlnaW4t PnByb3RvY29sLmRhdGEoKTsKK30KKworLyoqCisgKiB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dl dF9ob3N0OgorICogQG9yaWdpbjogYSAjV2ViS2l0U2VjdXJpdHlPcmlnaW4KKyAqCisgKiBHZXQg dGhlIGhvc3Qgb2YgQG9yaWdpbgorICoKKyAqIFJldHVybnM6IChhbGxvdy1ub25lKTogVGhlIGhv c3Qgb2YgdGhlICNXZWJLaXRTZWN1cml0eU9yaWdpbiwgb3IgJU5VTEwuCisgKgorICogU2luY2U6 IDIuMTYKKyAqLworY29uc3QgZ2NoYXIqIHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0X2hvc3Qo V2ViS2l0U2VjdXJpdHlPcmlnaW4qIG9yaWdpbikKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFp bChvcmlnaW4sIG51bGxwdHIpOworCisgICAgaWYgKG9yaWdpbi0+c2VjdXJpdHlPcmlnaW4tPmhv c3QoKS5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybiBudWxscHRyOworCisgICAgaWYgKG9yaWdp bi0+aG9zdC5pc051bGwoKSkKKyAgICAgICAgb3JpZ2luLT5ob3N0ID0gb3JpZ2luLT5zZWN1cml0 eU9yaWdpbi0+aG9zdCgpLnV0ZjgoKTsKKyAgICByZXR1cm4gb3JpZ2luLT5ob3N0LmRhdGEoKTsK K30KKworLyoqCisgKiB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dldF9wb3J0OgorICogQG9yaWdp bjogYSAjV2ViS2l0U2VjdXJpdHlPcmlnaW4KKyAqCisgKiBHZXQgdGhlIHBvcnQgb2YgQG9yaWdp bi4gVGhpcyBmdW5jdGlvbiB3aWxsIGFsd2F5cyByZXR1cm4gMCBpZiB0aGUKKyAqIHBvcnQgaXMg dGhlIGRlZmF1bHQgcG9ydCBmb3IgdGhlIGdpdmVuIHByb3RvY29sLiBGb3IgZXhhbXBsZSwKKyAq IGh0dHA6Ly9leGFtcGxlLmNvbSBoYXMgdGhlIHNhbWUgc2VjdXJpdHkgb3JpZ2luIGFzCisgKiBo dHRwOi8vZXhhbXBsZS5jb206ODAsIGFuZCB0aGlzIGZ1bmN0aW9uIHdpbGwgcmV0dXJuIDAgZm9y IGEKKyAqICNXZWJLaXRTZWN1cml0eU9yaWdpbiBjb25zdHJ1Y3RlZCBmcm9tIGVpdGhlciBzdHJp bmcuCisgKgorICogUmV0dXJuczogVGhlIHBvcnQgb2YgdGhlICNXZWJLaXRTZWN1cml0eU9yaWdp bi4KKyAqCisgKiBTaW5jZTogMi4xNgorICovCitndWludCB3ZWJraXRfc2VjdXJpdHlfb3JpZ2lu X2dldF9wb3J0KFdlYktpdFNlY3VyaXR5T3JpZ2luKiBvcmlnaW4pCit7CisgICAgZ19yZXR1cm5f dmFsX2lmX2ZhaWwob3JpZ2luLCAwKTsKKworICAgIGlmIChhdXRvIHBvcnQgPSBvcmlnaW4tPnNl Y3VyaXR5T3JpZ2luLT5wb3J0KCkpCisgICAgICAgIHJldHVybiAqcG9ydDsKKyAgICByZXR1cm4g MDsKK30KKworLyoqCisgKiB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3RvX3N0cmluZzoKKyAqIEBv cmlnaW46IGEgI1dlYktpdFNlY3VyaXR5T3JpZ2luCisgKgorICogR2V0IGEgc3RyaW5nIHJlcHJl c2VudGF0aW9uIG9mIEBvcmlnaW4uIEJlIGF3YXJlIHRoYXQgdGhpcyBmdW5jdGlvbgorICogbWF5 IHJldHVybiAlTlVMTCBpZiB0aGUgb3JpZ2luIGlzIHVuaXF1ZS4gKEZvciBleGFtcGxlLCB0aGlz IHdpbGwKKyAqIG9jY3VyIGlmIEBvcmlnaW4gcmVwcmVzZW50cyBhIHNhbmRib3hlZCBpZnJhbWUu KQorICoKKyAqIFJldHVybnM6IChhbGxvdy1ub25lKTogYSBzdHJpbmcgcmVwcmVzZW50YXRpb24g b2YgQG9yaWdpbi4KKyAqCisgKiBTaW5jZTogMi4xNgorICovCitjb25zdCBnY2hhciogd2Via2l0 X3NlY3VyaXR5X29yaWdpbl90b19zdHJpbmcoV2ViS2l0U2VjdXJpdHlPcmlnaW4qIG9yaWdpbikK K3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChvcmlnaW4sIG51bGxwdHIpOworCisgICAgaWYg KG9yaWdpbi0+YXNTdHJpbmcuaXNOdWxsKCkpCisgICAgICAgIG9yaWdpbi0+YXNTdHJpbmcgPSBv cmlnaW4tPnNlY3VyaXR5T3JpZ2luLT50b1N0cmluZygpLnV0ZjgoKTsKKyAgICByZXR1cm4gb3Jp Z2luLT5hc1N0cmluZyA9PSAibnVsbCIgPyBudWxscHRyIDogb3JpZ2luLT5hc1N0cmluZy5kYXRh KCk7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRTZWN1cml0eU9yaWdpbi5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2Vi S2l0U2VjdXJpdHlPcmlnaW4uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40NjI4NzQ1ZDRhMTA0MTQzMjUzM2YyYzRm NDc1OTU3MmJlZTIzODhkCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0U2VjdXJpdHlPcmlnaW4uaApAQCAtMCwwICsxLDczIEBACisvKgor ICogQ29weXJpZ2h0IChDKSAyMDE3IElnYWxpYSBTLkwuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBg QVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1F UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFS RSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklC VVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws IFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5F U1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZiAhZGVmaW5l ZChfX1dFQktJVDJfSF9JTlNJREVfXykgJiYgIWRlZmluZWQoV0VCS0lUMl9DT01QSUxBVElPTikK KyNlcnJvciAiT25seSA8d2Via2l0Mi93ZWJraXQyLmg+IGNhbiBiZSBpbmNsdWRlZCBkaXJlY3Rs eS4iCisjZW5kaWYKKworI2lmbmRlZiBXZWJLaXRTZWN1cml0eU9yaWdpbl9oCisjZGVmaW5lIFdl YktpdFNlY3VyaXR5T3JpZ2luX2gKKworI2luY2x1ZGUgPGdsaWItb2JqZWN0Lmg+CisjaW5jbHVk ZSA8d2Via2l0Mi9XZWJLaXREZWZpbmVzLmg+CisKK0dfQkVHSU5fREVDTFMKKworI2RlZmluZSBX RUJLSVRfVFlQRV9TRUNVUklUWV9PUklHSU4gKHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0X3R5 cGUoKSkKKwordHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFNlY3VyaXR5T3JpZ2luIFdlYktpdFNlY3Vy aXR5T3JpZ2luOworCitXRUJLSVRfQVBJIEdUeXBlCit3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dl dF90eXBlICAgICAgICAodm9pZCk7CisKK1dFQktJVF9BUEkgV2ViS2l0U2VjdXJpdHlPcmlnaW4g Kgord2Via2l0X3NlY3VyaXR5X29yaWdpbl9uZXcgICAgICAgICAgICAgKGNvbnN0IGdjaGFyICAg ICAgICAgICpwcm90b2NvbCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBjb25zdCBnY2hhciAgICAgICAgICAqaG9zdCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBndWludCAgICAgICAgICAgICAgICAgcG9ydCk7CisKK1dFQktJVF9BUEkg V2ViS2l0U2VjdXJpdHlPcmlnaW4gKgord2Via2l0X3NlY3VyaXR5X29yaWdpbl9uZXdfZnJvbV9z dHJpbmcgKGNvbnN0IGdjaGFyICAgICAgICAgICp1cmkpOworCitXRUJLSVRfQVBJIFdlYktpdFNl Y3VyaXR5T3JpZ2luICoKK3dlYmtpdF9zZWN1cml0eV9vcmlnaW5fcmVmICAgICAgICAgICAgIChX ZWJLaXRTZWN1cml0eU9yaWdpbiAqb3JpZ2luKTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRf c2VjdXJpdHlfb3JpZ2luX3VucmVmICAgICAgICAgICAoV2ViS2l0U2VjdXJpdHlPcmlnaW4gKm9y aWdpbik7CisKK1dFQktJVF9BUEkgY29uc3QgZ2NoYXIgKgord2Via2l0X3NlY3VyaXR5X29yaWdp bl9nZXRfcHJvdG9jb2wgICAgKFdlYktpdFNlY3VyaXR5T3JpZ2luICpvcmlnaW4pOworCitXRUJL SVRfQVBJIGNvbnN0IGdjaGFyICoKK3dlYmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0X2hvc3QgICAg ICAgIChXZWJLaXRTZWN1cml0eU9yaWdpbiAqb3JpZ2luKTsKKworV0VCS0lUX0FQSSBndWludAor d2Via2l0X3NlY3VyaXR5X29yaWdpbl9nZXRfcG9ydCAgICAgICAgKFdlYktpdFNlY3VyaXR5T3Jp Z2luICpvcmlnaW4pOworCitXRUJLSVRfQVBJIGNvbnN0IGdjaGFyICoKK3dlYmtpdF9zZWN1cml0 eV9vcmlnaW5fdG9fc3RyaW5nICAgICAgIChXZWJLaXRTZWN1cml0eU9yaWdpbiAqb3JpZ2luKTsK KworR19FTkRfREVDTFMKKworI2VuZGlmIC8qIFdlYktpdFNlY3VyaXR5T3JpZ2luX2ggKi8KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFNlY3VyaXR5 T3JpZ2luUHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0 U2VjdXJpdHlPcmlnaW5Qcml2YXRlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODBiODBkNmE4ZmE0NjhhZWVhYWZj MTVhYzA5ZTAzM2NlZWE4NDRjNgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFNlY3VyaXR5T3JpZ2luUHJpdmF0ZS5oCkBAIC0wLDAgKzEs MzQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTcgSWdhbGlhIFMuTC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBv ZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIu CisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhl IGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBh bmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAq CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05U UklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5U SUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJB TlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAq IFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1Ig SVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwg SU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1B R0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNV QlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRT OyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5Z IFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElB QklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBB UklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJ RiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKwor I3ByYWdtYSBvbmNlCisKKyNpbmNsdWRlICJXZWJLaXRQcml2YXRlLmgiCisjaW5jbHVkZSAiV2Vi S2l0U2VjdXJpdHlPcmlnaW4uaCIKKyNpbmNsdWRlIDxXZWJDb3JlL1NlY3VyaXR5T3JpZ2luLmg+ CisKK1dlYktpdFNlY3VyaXR5T3JpZ2luKiB3ZWJraXRTZWN1cml0eU9yaWdpbkNyZWF0ZShXZWJD b3JlOjpTZWN1cml0eU9yaWdpbiopOworV2ViS2l0U2VjdXJpdHlPcmlnaW4qIHdlYmtpdFNlY3Vy aXR5T3JpZ2luQ3JlYXRlKFJlZjxXZWJDb3JlOjpTZWN1cml0eU9yaWdpbj4mJik7CitXZWJDb3Jl OjpTZWN1cml0eU9yaWdpbiYgd2Via2l0U2VjdXJpdHlPcmlnaW5HZXRTZWN1cml0eU9yaWdpbihX ZWJLaXRTZWN1cml0eU9yaWdpbiopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcAppbmRleCA3MzgzNGNmM2FkMjVlYzFkZjI1 YzgzMzEyOTBmN2VkM2I1OTkzZGQxLi5iZDE4ZTFkNTRmNjg3YWI1NDY2MjFlODFlZTcyYjRkMjIw MzBmYmY5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRXZWJDb250ZXh0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRXZWJDb250ZXh0LmNwcApAQCAtNDEsNiArNDEsNyBAQAogI2luY2x1ZGUgIldlYktpdFBs dWdpblByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJLaXRQcml2YXRlLmgiCiAjaW5jbHVkZSAiV2Vi S2l0U2VjdXJpdHlNYW5hZ2VyUHJpdmF0ZS5oIgorI2luY2x1ZGUgIldlYktpdFNlY3VyaXR5T3Jp Z2luUHJpdmF0ZS5oIgogI2luY2x1ZGUgIldlYktpdFNldHRpbmdzUHJpdmF0ZS5oIgogI2luY2x1 ZGUgIldlYktpdFVSSVNjaGVtZVJlcXVlc3RQcml2YXRlLmgiCiAjaW5jbHVkZSAiV2ViS2l0VXNl ckNvbnRlbnRNYW5hZ2VyUHJpdmF0ZS5oIgpAQCAtMTEwLDYgKzExMSw3IEBAIGVudW0gewogZW51 bSB7CiAgICAgRE9XTkxPQURfU1RBUlRFRCwKICAgICBJTklUSUFMSVpFX1dFQl9FWFRFTlNJT05T LAorICAgIFNFVF9JTklUSUFMX05PVElGSUNBVElPTl9QRVJNSVNTSU9OUywKIAogICAgIExBU1Rf U0lHTkFMCiB9OwpAQCAtMjg1LDcgKzI4Nyw3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdFdlYkNvbnRl eHRDb25zdHJ1Y3RlZChHT2JqZWN0KiBvYmplY3QpCiAgICAgcHJpdi0+Z2VvbG9jYXRpb25Qcm92 aWRlciA9IFdlYktpdEdlb2xvY2F0aW9uUHJvdmlkZXI6OmNyZWF0ZShwcml2LT5wcm9jZXNzUG9v bC0+c3VwcGxlbWVudDxXZWJHZW9sb2NhdGlvbk1hbmFnZXJQcm94eT4oKSk7CiAjZW5kaWYKICNp ZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykKLSAgICBwcml2LT5ub3RpZmljYXRpb25Qcm92aWRlciA9 IFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyOjpjcmVhdGUocHJpdi0+cHJvY2Vzc1Bvb2wtPnN1 cHBsZW1lbnQ8V2ViTm90aWZpY2F0aW9uTWFuYWdlclByb3h5PigpKTsKKyAgICBwcml2LT5ub3Rp ZmljYXRpb25Qcm92aWRlciA9IFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyOjpjcmVhdGUocHJp di0+cHJvY2Vzc1Bvb2wtPnN1cHBsZW1lbnQ8V2ViTm90aWZpY2F0aW9uTWFuYWdlclByb3h5Pigp LCB3ZWJDb250ZXh0KTsKICNlbmRpZgogfQogCkBAIC0zODYsNiArMzg4LDI1IEBAIHN0YXRpYyB2 b2lkIHdlYmtpdF93ZWJfY29udGV4dF9jbGFzc19pbml0KFdlYktpdFdlYkNvbnRleHRDbGFzcyog d2ViQ29udGV4dENsYXNzCiAgICAgICAgICAgICBudWxscHRyLCBudWxscHRyLAogICAgICAgICAg ICAgZ19jY2xvc3VyZV9tYXJzaGFsX1ZPSURfX1ZPSUQsCiAgICAgICAgICAgICBHX1RZUEVfTk9O RSwgMCk7CisKKyAgICAvKioKKyAgICAgKiBXZWJLaXRXZWJDb250ZXh0OjpzZXQtaW5pdGlhbC1u b3RpZmljYXRpb24tcGVybWlzc2lvbnM6CisgICAgICogQGNvbnRleHQ6IHRoZSAjV2ViS2l0V2Vi Q29udGV4dAorICAgICAqCisgICAgICogVGhpcyBzaWduYWwgaXMgZW1pdHRlZCB3aGVuIGEgbmV3 IHdlYiBwcm9jZXNzIGlzIGFib3V0IHRvIGJlCisgICAgICogbGF1bmNoZWQuIEl0IHNpZ25hbHMg dGhlIG1vc3QgYXBwcm9wcmlhdGUgbW9tZW50IHRvIHVzZQorICAgICAqIHdlYmtpdF93ZWJfY29u dGV4dF9zZXRfaW5pdGlhbF9ub3RpZmljYXRpb25fcGVybWlzc2lvbnMoKS4KKyAgICAgKgorICAg ICAqIFNpbmNlOiAyLjE2CisgICAgICovCisgICAgc2lnbmFsc1tTRVRfSU5JVElBTF9OT1RJRklD QVRJT05fUEVSTUlTU0lPTlNdID0KKyAgICAgICAgZ19zaWduYWxfbmV3KCJzZXQtaW5pdGlhbC1u b3RpZmljYXRpb24tcGVybWlzc2lvbnMiLAorICAgICAgICAgICAgR19UWVBFX0ZST01fQ0xBU1Mo Z09iamVjdENsYXNzKSwKKyAgICAgICAgICAgIEdfU0lHTkFMX1JVTl9MQVNULAorICAgICAgICAg ICAgR19TVFJVQ1RfT0ZGU0VUKFdlYktpdFdlYkNvbnRleHRDbGFzcywgc2V0X2luaXRpYWxfbm90 aWZpY2F0aW9uX3Blcm1pc3Npb25zKSwKKyAgICAgICAgICAgIG51bGxwdHIsIG51bGxwdHIsCisg ICAgICAgICAgICBnX2NjbG9zdXJlX21hcnNoYWxfVk9JRF9fVk9JRCwKKyAgICAgICAgICAgIEdf VFlQRV9OT05FLCAwKTsKIH0KIAogc3RhdGljIGdwb2ludGVyIGNyZWF0ZURlZmF1bHRXZWJDb250 ZXh0KGdwb2ludGVyKQpAQCAtMTIxOCw2ICsxMjM5LDYwIEBAIGd1aW50IHdlYmtpdF93ZWJfY29u dGV4dF9nZXRfd2ViX3Byb2Nlc3NfY291bnRfbGltaXQoV2ViS2l0V2ViQ29udGV4dCogY29udGV4 dCkKICAgICByZXR1cm4gY29udGV4dC0+cHJpdi0+cHJvY2Vzc0NvdW50TGltaXQ7CiB9CiAKK3N0 YXRpYyB2b2lkIGFkZE9yaWdpblRvTWFwKFdlYktpdFNlY3VyaXR5T3JpZ2luKiBvcmlnaW4sIEhh c2hNYXA8U3RyaW5nLCBSZWZQdHI8QVBJOjpPYmplY3Q+PiogbWFwLCBib29sIGFsbG93ZWQpCit7 CisgICAgU3RyaW5nIHN0cmluZyA9IHdlYmtpdFNlY3VyaXR5T3JpZ2luR2V0U2VjdXJpdHlPcmln aW4ob3JpZ2luKS50b1N0cmluZygpOworICAgIGlmIChzdHJpbmcgIT0gIm51bGwiKQorICAgICAg ICBtYXAtPnNldChzdHJpbmcsIEFQSTo6Qm9vbGVhbjo6Y3JlYXRlKGFsbG93ZWQpKTsKK30KKwor c3RhdGljIHZvaWQgYWRkQWxsb3dlZE9yaWdpblRvTWFwKFdlYktpdFNlY3VyaXR5T3JpZ2luKiBv cmlnaW4sIEhhc2hNYXA8U3RyaW5nLCBSZWZQdHI8QVBJOjpPYmplY3Q+PiogbWFwKQoreworICAg IGFkZE9yaWdpblRvTWFwKG9yaWdpbiwgbWFwLCB0cnVlKTsKK30KKworc3RhdGljIHZvaWQgYWRk RGlzYWxsb3dlZE9yaWdpblRvTWFwKFdlYktpdFNlY3VyaXR5T3JpZ2luKiBvcmlnaW4sIEhhc2hN YXA8U3RyaW5nLCBSZWZQdHI8QVBJOjpPYmplY3Q+PiogbWFwKQoreworICAgIGFkZE9yaWdpblRv TWFwKG9yaWdpbiwgbWFwLCBmYWxzZSk7Cit9CisKKy8qKgorICogd2Via2l0X3dlYl9jb250ZXh0 X3NldF9pbml0aWFsX25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uczoKKyAqIEBjb250ZXh0OiB0aGUg I1dlYktpdFdlYkNvbnRleHQKKyAqIEBhbGxvd2VkX29yaWdpbnM6IChlbGVtZW50LXR5cGUgV2Vi S2l0U2VjdXJpdHlPcmlnaW4pOiBhICNHTGlzdCBvZiBzZWN1cml0eSBvcmlnaW5zCisgKiBAZGlz YWxsb3dlZF9vcmlnaW5zOiAoZWxlbWVudC10eXBlIFdlYktpdFNlY3VyaXR5T3JpZ2luKTogYSAj R0xpc3Qgb2Ygc2VjdXJpdHkgb3JpZ2lucworICoKKyAqIFNldHMgaW5pdGlhbCBkZXNrdG9wIG5v dGlmaWNhdGlvbiBwZXJtaXNzaW9ucyBmb3IgdGhlIEBjb250ZXh0LgorICogQGFsbG93ZWRfb3Jp Z2lucyBhbmQgQGRpc2FsbG93ZWRfb3JpZ2lucyBtdXN0IGVhY2ggYmUgI0dMaXN0IG9mCisgKiAj V2ViS2l0U2VjdXJpdHlPcmlnaW4gb2JqZWN0cyByZXByZXNlbnRpbmcgb3JpZ2lucyB0aGF0IHdp bGwsCisgKiByZXNwZWN0aXZlbHksIGVpdGhlciBhbHdheXMgb3IgbmV2ZXIgaGF2ZSBwZXJtaXNz aW9uIHRvIHNob3cgZGVza3RvcAorICogbm90aWZpY2F0aW9ucy4gTm8gI1dlYktpdE5vdGlmaWNh dGlvblBlcm1pc3Npb25SZXF1ZXN0IHdpbGwgZXZlciBiZQorICogZ2VuZXJhdGVkIGZvciBhbnkg b2YgdGhlIHNlY3VyaXR5IG9yaWdpbnMgcmVwcmVzZW50ZWQgaW4KKyAqIEBhbGxvd2VkX29yaWdp bnMgb3IgQGRpc2FsbG93ZWRfb3JpZ2lucy4gVGhpcyBmdW5jdGlvbiBpcyBuZWNlc3NhcnkKKyAq IGJlY2F1c2Ugc29tZSB3ZWJwYWdlcyBwcm9hY3RpdmVseSBjaGVjayB3aGV0aGVyIHRoZXkgaGF2 ZSBwZXJtaXNzaW9uCisgKiB0byBkaXNwbGF5IG5vdGlmaWNhdGlvbnMgd2l0aG91dCBldmVyIGNy ZWF0aW5nIGEgcGVybWlzc2lvbiByZXF1ZXN0LgorICoKKyAqIFRoaXMgZnVuY3Rpb24gb25seSBh ZmZlY3RzIHdlYiBwcm9jZXNzZXMgdGhhdCBoYXZlIG5vdCBhbHJlYWR5IGJlZW4KKyAqIGNyZWF0 ZWQuIFRoZSBiZXN0IHRpbWUgdG8gY2FsbCBpdCBpcyB3aGVuIGhhbmRsaW5nCisgKiAjV2ViS2l0 V2ViQ29udGV4dDo6c2V0LWluaXRpYWwtbm90aWZpY2F0aW9uLXBlcm1pc3Npb25zIHNvIGFzIHRv CisgKiBlbnN1cmUgdGhhdCBuZXcgd2ViIHByb2Nlc3NlcyByZWNlaXZlIHRoZSBtb3N0IHJlY2Vu dCBzZXQgb2YKKyAqIHBlcm1pc3Npb25zLgorICoKKyAqIFNpbmNlOiAyLjE2CisgKi8KK3ZvaWQg d2Via2l0X3dlYl9jb250ZXh0X3NldF9pbml0aWFsX25vdGlmaWNhdGlvbl9wZXJtaXNzaW9ucyhX ZWJLaXRXZWJDb250ZXh0KiBjb250ZXh0LCBHTGlzdCogYWxsb3dlZF9vcmlnaW5zLCBHTGlzdCog ZGlzYWxsb3dlZF9vcmlnaW5zKQoreworICAgIEhhc2hNYXA8U3RyaW5nLCBSZWZQdHI8QVBJOjpP YmplY3Q+PiBtYXA7CisgICAgZ19saXN0X2ZvcmVhY2goYWxsb3dlZF9vcmlnaW5zLCAoR0Z1bmMp YWRkQWxsb3dlZE9yaWdpblRvTWFwLCAmbWFwKTsKKyAgICBnX2xpc3RfZm9yZWFjaChkaXNhbGxv d2VkX29yaWdpbnMsIChHRnVuYylhZGREaXNhbGxvd2VkT3JpZ2luVG9NYXAsICZtYXApOworICAg IGNvbnRleHQtPnByaXYtPm5vdGlmaWNhdGlvblByb3ZpZGVyLT5zZXROb3RpZmljYXRpb25QZXJt aXNzaW9ucyhXVEZNb3ZlKG1hcCkpOworfQorCit2b2lkIHdlYmtpdFdlYkNvbnRleHRTZXRJbml0 aWFsTm90aWZpY2F0aW9uUGVybWlzc2lvbnMoV2ViS2l0V2ViQ29udGV4dCogY29udGV4dCkKK3sK KyAgICBnX3NpZ25hbF9lbWl0KGNvbnRleHQsIHNpZ25hbHNbU0VUX0lOSVRJQUxfTk9USUZJQ0FU SU9OX1BFUk1JU1NJT05TXSwgMCk7Cit9CisKIFdlYktpdERvd25sb2FkKiB3ZWJraXRXZWJDb250 ZXh0R2V0T3JDcmVhdGVEb3dubG9hZChEb3dubG9hZFByb3h5KiBkb3dubG9hZFByb3h5KQogewog ICAgIEdSZWZQdHI8V2ViS2l0RG93bmxvYWQ+IGRvd25sb2FkID0gZG93bmxvYWRzTWFwKCkuZ2V0 KGRvd25sb2FkUHJveHkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0V2ViQ29udGV4dC5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0V2ViQ29udGV4dC5oCmluZGV4IGNkNTU0ODZmNGMyMzM5NWYwZTc3YmI4NjIzMzcw ZTdjNTcwZGUxYjcuLjBjZjFiY2Q4OGQ2MGJhNTlhOWQzYjQxMGE4MmY3YjFjMWZlN2VlNDEgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRl eHQuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250 ZXh0LmgKQEAgLTEyOCwxNiArMTI4LDE2IEBAIHN0cnVjdCBfV2ViS2l0V2ViQ29udGV4dCB7CiBz dHJ1Y3QgX1dlYktpdFdlYkNvbnRleHRDbGFzcyB7CiAgICAgR09iamVjdENsYXNzIHBhcmVudDsK IAotICAgIHZvaWQgKCogZG93bmxvYWRfc3RhcnRlZCkgICAgICAgICAgKFdlYktpdFdlYkNvbnRl eHQgKmNvbnRleHQsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2Vi S2l0RG93bmxvYWQgICAqZG93bmxvYWQpOwotICAgIHZvaWQgKCogaW5pdGlhbGl6ZV93ZWJfZXh0 ZW5zaW9ucykgKFdlYktpdFdlYkNvbnRleHQgKmNvbnRleHQpOworICAgIHZvaWQgKCogZG93bmxv YWRfc3RhcnRlZCkgICAgICAgICAgICAgICAgICAgICAoV2ViS2l0V2ViQ29udGV4dCAqY29udGV4 dCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdl YktpdERvd25sb2FkICAgKmRvd25sb2FkKTsKKyAgICB2b2lkICgqIGluaXRpYWxpemVfd2ViX2V4 dGVuc2lvbnMpICAgICAgICAgICAgKFdlYktpdFdlYkNvbnRleHQgKmNvbnRleHQpOworICAgIHZv aWQgKCogc2V0X2luaXRpYWxfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25zKSAoV2ViS2l0V2ViQ29u dGV4dCAqY29udGV4dCk7CiAKICAgICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDApICh2b2lkKTsK ICAgICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDEpICh2b2lkKTsKICAgICB2b2lkICgqX3dlYmtp dF9yZXNlcnZlZDIpICh2b2lkKTsKICAgICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDMpICh2b2lk KTsKICAgICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDQpICh2b2lkKTsKLSAgICB2b2lkICgqX3dl YmtpdF9yZXNlcnZlZDUpICh2b2lkKTsKIH07CiAKIFdFQktJVF9BUEkgR1R5cGUKQEAgLTI2NCw2 ICsyNjQsMTIgQEAgd2Via2l0X3dlYl9jb250ZXh0X3NldF9wcm9jZXNzX21vZGVsICAgICAgICAg ICAgICAgIChXZWJLaXRXZWJDb250ZXh0CiBXRUJLSVRfQVBJIFdlYktpdFByb2Nlc3NNb2RlbAog d2Via2l0X3dlYl9jb250ZXh0X2dldF9wcm9jZXNzX21vZGVsICAgICAgICAgICAgICAgIChXZWJL aXRXZWJDb250ZXh0ICAgICAgICAgICAgICAqY29udGV4dCk7CiAKK1dFQktJVF9BUEkgdm9pZAor d2Via2l0X3dlYl9jb250ZXh0X3NldF9pbml0aWFsX25vdGlmaWNhdGlvbl9wZXJtaXNzaW9ucwor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChXZWJL aXRXZWJDb250ZXh0ICAgICAgICAgICAgICAqY29udGV4dCwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0xpc3QgICAgICAgICAgICAgICAgICAg ICAgICAgKmFsbG93ZWRfb3JpZ2lucywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgR0xpc3QgICAgICAgICAgICAgICAgICAgICAgICAgKmRpc2Fs bG93ZWRfb3JpZ2lucyk7CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dFByaXZhdGUuaCBi L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHRQcml2YXRl LmgKaW5kZXggNjNlYjIxYTc3MjMyMDJkYzZkYWNlMmI2ZTNhZGE3YzI2NzAxZDFiNC4uMDZmNWIx MzNlYTQ5MzE4MmVmYzYzNmM3ZWM1YzVjZTk2NGQwMDg3MCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dFByaXZhdGUuaAorKysgYi9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0UHJpdmF0ZS5o CkBAIC00OCw1ICs0OCw2IEBAIHZvaWQgd2Via2l0V2ViQ29udGV4dENyZWF0ZVBhZ2VGb3JXZWJW aWV3KFdlYktpdFdlYkNvbnRleHQqLCBXZWJLaXRXZWJWaWV3KiwgV2ViCiB2b2lkIHdlYmtpdFdl YkNvbnRleHRXZWJWaWV3RGVzdHJveWVkKFdlYktpdFdlYkNvbnRleHQqLCBXZWJLaXRXZWJWaWV3 Kik7CiBXZWJLaXRXZWJWaWV3KiB3ZWJraXRXZWJDb250ZXh0R2V0V2ViVmlld0ZvclBhZ2UoV2Vi S2l0V2ViQ29udGV4dCosIFdlYktpdDo6V2ViUGFnZVByb3h5Kik7CiBHVmFyaWFudCogd2Via2l0 V2ViQ29udGV4dEluaXRpYWxpemVXZWJFeHRlbnNpb25zKFdlYktpdFdlYkNvbnRleHQqKTsKK3Zv aWQgd2Via2l0V2ViQ29udGV4dFNldEluaXRpYWxOb3RpZmljYXRpb25QZXJtaXNzaW9ucyhXZWJL aXRXZWJDb250ZXh0Kik7CiAKICNlbmRpZiAvLyBXZWJLaXRXZWJDb250ZXh0UHJpdmF0ZV9oCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJn dGstNC4wLXNlY3Rpb25zLnR4dCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2Rv Y3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0CmluZGV4IDAxMzAzZjY4OTM5ZTVjNDU1NTM2 YWMzNDFmMjdmODgwYjI4MGVmNTcuLjBjNjI4Y2YwYTJkNzBlMTEzYTk5Mzg1MGE1MGM1M2MxNDli MmI4NTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mv d2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0CkBAIC01OSw2ICs1OSw3 IEBAIHdlYmtpdF93ZWJfY29udGV4dF9zZXRfZGlza19jYWNoZV9kaXJlY3RvcnkKIHdlYmtpdF93 ZWJfY29udGV4dF9hbGxvd190bHNfY2VydGlmaWNhdGVfZm9yX2hvc3QKIHdlYmtpdF93ZWJfY29u dGV4dF9nZXRfcHJvY2Vzc19tb2RlbAogd2Via2l0X3dlYl9jb250ZXh0X3NldF9wcm9jZXNzX21v ZGVsCit3ZWJraXRfd2ViX2NvbnRleHRfc2V0X2luaXRpYWxfbm90aWZpY2F0aW9uX3Blcm1pc3Np b25zCiAKIDxTVUJTRUNUSU9OIFVSSSBTY2hlbWU+CiBXZWJLaXRVUklTY2hlbWVSZXF1ZXN0Q2Fs bGJhY2sKQEAgLTEyMTEsNiArMTIxMiwyNSBAQCB3ZWJraXRfc2VjdXJpdHlfbWFuYWdlcl9nZXRf dHlwZQogPC9TRUNUSU9OPgogCiA8U0VDVElPTj4KKzxGSUxFPldlYktpdFNlY3VyaXR5T3JpZ2lu PC9GSUxFPgorV2ViS2l0U2VjdXJpdHlPcmlnaW4KK3dlYmtpdF9zZWN1cml0eV9vcmlnaW5fbmV3 Cit3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX25ld19mcm9tX3N0cmluZword2Via2l0X3NlY3VyaXR5 X29yaWdpbl9yZWYKK3dlYmtpdF9zZWN1cml0eV9vcmlnaW5fdW5yZWYKK3dlYmtpdF9zZWN1cml0 eV9vcmlnaW5fZ2V0X3Byb3RvY29sCit3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dldF9ob3N0Cit3 ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dldF9wb3J0Cit3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3Rv X3N0cmluZworCis8U1VCU0VDVElPTiBTdGFuZGFyZD4KK1dFQktJVF9UWVBFX1NFQ1VSSVRZX09S SUdJTgorCis8U1VCU0VDVElPTiBQcml2YXRlPgord2Via2l0X3NlY3VyaXR5X29yaWdpbl9nZXRf dHlwZQorPC9TRUNUSU9OPgorCis8U0VDVElPTj4KIDxGSUxFPldlYktpdFdlYnNpdGVEYXRhTWFu YWdlcjwvRklMRT4KIFdlYktpdFdlYnNpdGVEYXRhTWFuYWdlcgogd2Via2l0X3dlYnNpdGVfZGF0 YV9tYW5hZ2VyX25ldwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9n dGsvZG9jcy93ZWJraXQyZ3RrLWRvY3Muc2dtbCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9B UEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1kb2NzLnNnbWwKaW5kZXggZjhmNDJkY2Q5MmQ2ZDhhN2Qw ZWNjNDFlY2Q2NmY5YTUyMDYyYjQ1YS4uMDI0ZTliOGUyMzA4OGZiZDIzMzRlYWUxNWNjZTAxNzE1 NWJjNjM0OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9j cy93ZWJraXQyZ3RrLWRvY3Muc2dtbAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2d0ay9kb2NzL3dlYmtpdDJndGstZG9jcy5zZ21sCkBAIC01MSw2ICs1MSw3IEBACiAgICAgPHhp OmluY2x1ZGUgaHJlZj0ieG1sL1dlYktpdFVzZXJDb250ZW50LnhtbCIvPgogICAgIDx4aTppbmNs dWRlIGhyZWY9InhtbC9XZWJLaXROb3RpZmljYXRpb24ueG1sIi8+CiAgICAgPHhpOmluY2x1ZGUg aHJlZj0ieG1sL1dlYktpdE5vdGlmaWNhdGlvblBlcm1pc3Npb25SZXF1ZXN0LnhtbCIvPgorICAg IDx4aTppbmNsdWRlIGhyZWY9InhtbC9XZWJLaXRTZWN1cml0eU9yaWdpbi54bWwiLz4KICAgICA8 eGk6aW5jbHVkZSBocmVmPSJ4bWwvV2ViS2l0V2Vic2l0ZURhdGFNYW5hZ2VyLnhtbCIvPgogICA8 L2NoYXB0ZXI+CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3Rr L3dlYmtpdDIuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3dlYmtpdDIuaApp bmRleCAzZTQ0ZDYwOTQ0YWY0MGM2NGQ3ZDU3MTJiNDZkZDQ0YWMwN2I3NjBmLi5mYzBmYTRlYmE1 MGY2NzU3ZjJhYzM4OTUwZTNhNmE4YmEwYjBiZGY4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay93ZWJraXQyLmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9ndGsvd2Via2l0Mi5oCkBAIC02MSw2ICs2MSw3IEBACiAjaW5jbHVkZSA8d2Via2l0 Mi9XZWJLaXRSZXNwb25zZVBvbGljeURlY2lzaW9uLmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJL aXRTY3JpcHREaWFsb2cuaD4KICNpbmNsdWRlIDx3ZWJraXQyL1dlYktpdFNlY3VyaXR5TWFuYWdl ci5oPgorI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0U2VjdXJpdHlPcmlnaW4uaD4KICNpbmNsdWRl IDx3ZWJraXQyL1dlYktpdFNldHRpbmdzLmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJLaXRVUklS ZXF1ZXN0Lmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJLaXRVUklSZXNwb25zZS5oPgpkaWZmIC0t Z2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDJmMDA3OTc4Y2Fl MTdiMDIzYjkyYjJkMjg1MTdhODYwNDQ1NjEwZWEuLjQ3ZjAxYWMxNzQ3ODE4MWIzYzg4YmZiYmMx ZGIxOTc2NjVjMmRkNjMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9D aGFuZ2VMb2cKQEAgLTEsMyArMSwzMCBAQAorMjAxNi0xMi0yOSAgTWljaGFlbCBDYXRhbnphcm8g IDxtY2F0YW56YXJvQGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10gTm8gd2F5IGZvciBhcHBs aWNhdGlvbnMgdG8gc2V0IG5vdGlmaWNhdGlvbiBwZXJtaXNzaW9ucyB3aXRob3V0IHdhaXRpbmcg Zm9yIHBlcm1pc3Npb24gcmVxdWVzdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTYzMzY2CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYktp dFdlYkNvbnRleHQuY3BwOiBUZXN0IFdlYktpdFNlY3VyaXR5T3JpZ2luLgorICAgICAgICAodGVz dFNlY3VyaXR5T3JpZ2luQmFzaWMpOgorICAgICAgICAoYmVmb3JlQWxsKToKKyAgICAgICAgKiBU ZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYktpdFdlYlZpZXcuY3BwOiBUZXN0 IG5vdGlmaWNhdGlvbiBwZXJtaXNzaW9ucy4KKyAgICAgICAgKHRlc3RXZWJWaWV3Tm90aWZpY2F0 aW9uKToKKyAgICAgICAgKHNldEluaXRpYWxOb3RpZmljYXRpb25QZXJtaXNzaW9uc0FsbG93ZWRD YWxsYmFjayk6CisgICAgICAgIChzZXRJbml0aWFsTm90aWZpY2F0aW9uUGVybWlzc2lvbnNEaXNh bGxvd2VkQ2FsbGJhY2spOgorICAgICAgICAodGVzdFdlYlZpZXdOb3RpZmljYXRpb25Jbml0aWFs UGVybWlzc2lvbkFsbG93ZWQpOgorICAgICAgICAodGVzdFdlYlZpZXdOb3RpZmljYXRpb25Jbml0 aWFsUGVybWlzc2lvbkRpc2FsbG93ZWQpOgorICAgICAgICAoYmVmb3JlQWxsKToKKyAgICAgICAg KiBUZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1Rlc3RNYWluLmg6IEFkZCBtYWNybyB0byBh bGxvdyBmb3IgY3VzdG9tIHRlc3QgZml4dHVyZXMuCisgICAgICAgICogVGVzdFdlYktpdEFQSS9n dGsvV2ViS2l0Mkd0ay9XZWJLaXRUZXN0U2VydmVyLmNwcDogQWRkIGhlbHBlciB0byBnZXQgc2Vj dXJpdHkgb3JpZ2luLgorICAgICAgICAoV2ViS2l0VGVzdFNlcnZlcjo6c2VjdXJpdHlPcmlnaW4p OgorICAgICAgICAoV2ViS2l0VGVzdFNlcnZlcjo6Z2V0VVJJRm9yUGF0aCk6IERyaXZlLWJ5OiBt YWRlIGl0IGNvbnN0LgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2Vi S2l0VGVzdFNlcnZlci5oOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsv V2ViVmlld1Rlc3QuY3BwOiBBZGQgYWJpbGl0eSB0byBkZWZlciB3ZWIgdmlldyBjcmVhdGlvbi4K KyAgICAgICAgKFdlYlZpZXdUZXN0OjpXZWJWaWV3VGVzdCk6CisgICAgICAgIChXZWJWaWV3VGVz dDo6aW5pdGlhbGl6ZVdlYlZpZXcpOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvZ3RrL1dlYktp dDJHdGsvV2ViVmlld1Rlc3QuaDoKKwogMjAxNi0xMi0zMCAgTWljaGFlbCBDYXRhbnphcm8gIDxt Y2F0YW56YXJvQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0dUS10gSW1wcm92ZSB1c2VyIGFnZW50 IGNvbnN0cnVjdGlvbgpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQyR3RrL1Rlc3RXZWJLaXRXZWJDb250ZXh0LmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0Mkd0ay9UZXN0V2ViS2l0V2ViQ29udGV4dC5jcHAKaW5kZXggYTc1NWE3MmZiMTc0 YjljNTFiZjIzZWZmNDNlNDBmODg3YzNjOGI1Ni4uMDQ5NjUyYjAwMjhjMDAwNmIyNjhkN2U4MDYz NmUyZjk2NjU0MWQyZSAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQyR3RrL1Rlc3RXZWJLaXRXZWJDb250ZXh0LmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJ L1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYktpdFdlYkNvbnRleHQuY3BwCkBAIC03MDAsNiArNzAw LDY1IEBAIHN0YXRpYyB2b2lkIHRlc3RXZWJDb250ZXh0U2VjdXJpdHlGaWxlWEhSKFdlYlZpZXdU ZXN0KiB0ZXN0LCBnY29uc3Rwb2ludGVyKQogICAgIHdlYmtpdF9zZXR0aW5nc19zZXRfYWxsb3df ZmlsZV9hY2Nlc3NfZnJvbV9maWxlX3VybHMod2Via2l0X3dlYl92aWV3X2dldF9zZXR0aW5ncyh0 ZXN0LT5tX3dlYlZpZXcpLCBGQUxTRSk7CiB9CiAKK3N0YXRpYyB2b2lkIHRlc3RTZWN1cml0eU9y aWdpbkJhc2ljKFRlc3QqLCBnY29uc3Rwb2ludGVyKQoreworICAgIFdlYktpdFNlY3VyaXR5T3Jp Z2luKiBvcmlnaW4gPSB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX25ldygiaHR0cCIsICIxMjcuMC4w LjEiLCAxMjM0KTsKKyAgICBnX2Fzc2VydChvcmlnaW4pOworICAgIGdfYXNzZXJ0X2NtcHN0cih3 ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dldF9wcm90b2NvbChvcmlnaW4pLCA9PSwgImh0dHAiKTsK KyAgICBnX2Fzc2VydF9jbXBzdHIod2Via2l0X3NlY3VyaXR5X29yaWdpbl9nZXRfaG9zdChvcmln aW4pLCA9PSwgIjEyNy4wLjAuMSIpOworICAgIGdfYXNzZXJ0X2NtcGludCh3ZWJraXRfc2VjdXJp dHlfb3JpZ2luX2dldF9wb3J0KG9yaWdpbiksID09LCAxMjM0KTsKKyAgICBnX2Fzc2VydF9jbXBz dHIod2Via2l0X3NlY3VyaXR5X29yaWdpbl90b19zdHJpbmcob3JpZ2luKSwgPT0sICJodHRwOi8v MTI3LjAuMC4xOjEyMzQiKTsKKyAgICB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3VucmVmKG9yaWdp bik7CisKKyAgICBvcmlnaW4gPSB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX25ld19mcm9tX3N0cmlu ZygiaHR0cDovLzEyNy4wLjAuMToxMjM0Iik7CisgICAgZ19hc3NlcnQob3JpZ2luKTsKKyAgICBn X2Fzc2VydF9jbXBzdHIod2Via2l0X3NlY3VyaXR5X29yaWdpbl9nZXRfcHJvdG9jb2wob3JpZ2lu KSwgPT0sICJodHRwIik7CisgICAgZ19hc3NlcnRfY21wc3RyKHdlYmtpdF9zZWN1cml0eV9vcmln aW5fZ2V0X2hvc3Qob3JpZ2luKSwgPT0sICIxMjcuMC4wLjEiKTsKKyAgICBnX2Fzc2VydF9jbXBp bnQod2Via2l0X3NlY3VyaXR5X29yaWdpbl9nZXRfcG9ydChvcmlnaW4pLCA9PSwgMTIzNCk7Cisg ICAgZ19hc3NlcnRfY21wc3RyKHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fdG9fc3RyaW5nKG9yaWdp biksID09LCAiaHR0cDovLzEyNy4wLjAuMToxMjM0Iik7CisgICAgd2Via2l0X3NlY3VyaXR5X29y aWdpbl91bnJlZihvcmlnaW4pOworICAgIAorICAgIG9yaWdpbiA9IHdlYmtpdF9zZWN1cml0eV9v cmlnaW5fbmV3X2Zyb21fc3RyaW5nKCJodHRwOi8vMTI3LjAuMC4xOjEyMzQvdGhpcy9wYXRoLz9z aG91bGQ9YmUjaWdub3JlZCIpOworICAgIGdfYXNzZXJ0KG9yaWdpbik7CisgICAgZ19hc3NlcnRf Y21wc3RyKHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0X3Byb3RvY29sKG9yaWdpbiksID09LCAi aHR0cCIpOworICAgIGdfYXNzZXJ0X2NtcHN0cih3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dldF9o b3N0KG9yaWdpbiksID09LCAiMTI3LjAuMC4xIik7CisgICAgZ19hc3NlcnRfY21waW50KHdlYmtp dF9zZWN1cml0eV9vcmlnaW5fZ2V0X3BvcnQob3JpZ2luKSwgPT0sIDEyMzQpOworICAgIGdfYXNz ZXJ0X2NtcHN0cih3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3RvX3N0cmluZyhvcmlnaW4pLCA9PSwg Imh0dHA6Ly8xMjcuMC4wLjE6MTIzNCIpOworICAgIHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fdW5y ZWYob3JpZ2luKTsKKworICAgIG9yaWdpbiA9IHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fbmV3KCJo dHRwIiwgIjEyNy4wLjAuMSIsIDApOworICAgIGdfYXNzZXJ0KG9yaWdpbik7CisgICAgZ19hc3Nl cnRfY21wc3RyKHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0X3Byb3RvY29sKG9yaWdpbiksID09 LCAiaHR0cCIpOworICAgIGdfYXNzZXJ0X2NtcHN0cih3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dl dF9ob3N0KG9yaWdpbiksID09LCAiMTI3LjAuMC4xIik7CisgICAgZ19hc3NlcnRfY21waW50KHdl YmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0X3BvcnQob3JpZ2luKSwgPT0sIDApOworICAgIGdfYXNz ZXJ0X2NtcHN0cih3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3RvX3N0cmluZyhvcmlnaW4pLCA9PSwg Imh0dHA6Ly8xMjcuMC4wLjEiKTsKKyAgICB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3VucmVmKG9y aWdpbik7CisgICAgCisgICAgb3JpZ2luID0gd2Via2l0X3NlY3VyaXR5X29yaWdpbl9uZXcoImh0 dHAiLCAiMTI3LjAuMC4xIiwgODApOworICAgIGdfYXNzZXJ0KG9yaWdpbik7CisgICAgZ19hc3Nl cnRfY21wc3RyKHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0X3Byb3RvY29sKG9yaWdpbiksID09 LCAiaHR0cCIpOworICAgIGdfYXNzZXJ0X2NtcHN0cih3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dl dF9ob3N0KG9yaWdpbiksID09LCAiMTI3LjAuMC4xIik7CisgICAgZ19hc3NlcnRfY21waW50KHdl YmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0X3BvcnQob3JpZ2luKSwgPT0sIDApOworICAgIGdfYXNz ZXJ0X2NtcHN0cih3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3RvX3N0cmluZyhvcmlnaW4pLCA9PSwg Imh0dHA6Ly8xMjcuMC4wLjEiKTsKKyAgICB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3VucmVmKG9y aWdpbik7CisKKyAgICBvcmlnaW4gPSB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX25ld19mcm9tX3N0 cmluZygiaHR0cDovLzEyNy4wLjAuMSIpOworICAgIGdfYXNzZXJ0KG9yaWdpbik7CisgICAgZ19h c3NlcnRfY21wc3RyKHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0X3Byb3RvY29sKG9yaWdpbiks ID09LCAiaHR0cCIpOworICAgIGdfYXNzZXJ0X2NtcHN0cih3ZWJraXRfc2VjdXJpdHlfb3JpZ2lu X2dldF9ob3N0KG9yaWdpbiksID09LCAiMTI3LjAuMC4xIik7CisgICAgZ19hc3NlcnRfY21waW50 KHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0X3BvcnQob3JpZ2luKSwgPT0sIDApOworICAgIGdf YXNzZXJ0X2NtcHN0cih3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3RvX3N0cmluZyhvcmlnaW4pLCA9 PSwgImh0dHA6Ly8xMjcuMC4wLjEiKTsKKyAgICB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX3VucmVm KG9yaWdpbik7CisgICAgCisgICAgb3JpZ2luID0gd2Via2l0X3NlY3VyaXR5X29yaWdpbl9uZXdf ZnJvbV9zdHJpbmcoImh0dHA6Ly8xMjcuMC4wLjE6ODAiKTsKKyAgICBnX2Fzc2VydChvcmlnaW4p OworICAgIGdfYXNzZXJ0X2NtcHN0cih3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dldF9wcm90b2Nv bChvcmlnaW4pLCA9PSwgImh0dHAiKTsKKyAgICBnX2Fzc2VydF9jbXBzdHIod2Via2l0X3NlY3Vy aXR5X29yaWdpbl9nZXRfaG9zdChvcmlnaW4pLCA9PSwgIjEyNy4wLjAuMSIpOworICAgIGdfYXNz ZXJ0X2NtcGludCh3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX2dldF9wb3J0KG9yaWdpbiksID09LCAw KTsKKyAgICBnX2Fzc2VydF9jbXBzdHIod2Via2l0X3NlY3VyaXR5X29yaWdpbl90b19zdHJpbmco b3JpZ2luKSwgPT0sICJodHRwOi8vMTI3LjAuMC4xIik7CisgICAgd2Via2l0X3NlY3VyaXR5X29y aWdpbl91bnJlZihvcmlnaW4pOworfQorCiB2b2lkIGJlZm9yZUFsbCgpCiB7CiAgICAga1NlcnZl ciA9IG5ldyBXZWJLaXRUZXN0U2VydmVyKCk7CkBAIC03MTMsNiArNzcyLDcgQEAgdm9pZCBiZWZv cmVBbGwoKQogICAgIFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYkNvbnRleHQiLCAibGFuZ3Vh Z2VzIiwgdGVzdFdlYkNvbnRleHRMYW5ndWFnZXMpOwogICAgIFNlY3VyaXR5UG9saWN5VGVzdDo6 YWRkKCJXZWJLaXRTZWN1cml0eU1hbmFnZXIiLCAic2VjdXJpdHktcG9saWN5IiwgdGVzdFdlYkNv bnRleHRTZWN1cml0eVBvbGljeSk7CiAgICAgV2ViVmlld1Rlc3Q6OmFkZCgiV2ViS2l0U2VjdXJp dHlNYW5hZ2VyIiwgImZpbGUteGhyIiwgdGVzdFdlYkNvbnRleHRTZWN1cml0eUZpbGVYSFIpOwor ICAgIFRlc3Q6OmFkZCgiV2ViS2l0U2VjdXJpdHlPcmlnaW4iLCAiYmFzaWMiLCB0ZXN0U2VjdXJp dHlPcmlnaW5CYXNpYyk7CiB9CiAKIHZvaWQgYWZ0ZXJBbGwoKQpkaWZmIC0tZ2l0IGEvVG9vbHMv VGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RXZWJLaXRXZWJWaWV3LmNwcCBiL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9UZXN0V2ViS2l0V2ViVmlldy5jcHAK aW5kZXggMjkyZjU1NjE2MDMwOGEwYjljOTUzZTFiYTMyMTRiNTBkNTM1ZWVmOS4uMTdmOTc1M2E4 MjBmYWEzOGY0NmJlMjE1NzYxYzEwN2FiN2QwMDU3NCAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RXZWJLaXRXZWJWaWV3LmNwcAorKysgYi9Ub29s cy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYktpdFdlYlZpZXcuY3BwCkBA IC02MzIsNyArNjMyLDE3IEBAIHN0YXRpYyB2b2lkIHRlc3RXZWJWaWV3U25hcHNob3QoU25hcHNo b3RXZWJWaWV3VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRlcikKIAogY2xhc3MgTm90aWZpY2F0aW9u V2ViVmlld1Rlc3Q6IHB1YmxpYyBXZWJWaWV3VGVzdCB7CiBwdWJsaWM6Ci0gICAgTUFLRV9HTElC X1RFU1RfRklYVFVSRShOb3RpZmljYXRpb25XZWJWaWV3VGVzdCk7CisgICAgTUFLRV9HTElCX1RF U1RfRklYVFVSRV9XSVRIX1NFVFVQX1RFQVJET1dOKE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0LCBz ZXR1cCwgdGVhcmRvd24pOworCisgICAgc3RhdGljIHZvaWQgc2V0dXAoKQorICAgIHsKKyAgICAg ICAgV2ViVmlld1Rlc3Q6OnNob3VsZEluaXRpYWxpemVXZWJWaWV3SW5Db25zdHJ1Y3RvciA9IGZh bHNlOworICAgIH0KKworICAgIHN0YXRpYyB2b2lkIHRlYXJkb3duKCkKKyAgICB7CisgICAgICAg IFdlYlZpZXdUZXN0OjpzaG91bGRJbml0aWFsaXplV2ViVmlld0luQ29uc3RydWN0b3IgPSB0cnVl OworICAgIH0KIAogICAgIGVudW0gTm90aWZpY2F0aW9uRXZlbnQgewogICAgICAgICBOb25lLApA QCAtNjQ3LDYgKzY1Nyw3IEBAIHB1YmxpYzoKICAgICBzdGF0aWMgZ2Jvb2xlYW4gcGVybWlzc2lv blJlcXVlc3RDYWxsYmFjayhXZWJLaXRXZWJWaWV3KiwgV2ViS2l0UGVybWlzc2lvblJlcXVlc3Qg KnJlcXVlc3QsIE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0KiB0ZXN0KQogICAgIHsKICAgICAgICAg Z19hc3NlcnQoV0VCS0lUX0lTX05PVElGSUNBVElPTl9QRVJNSVNTSU9OX1JFUVVFU1QocmVxdWVz dCkpOworICAgICAgICBnX2Fzc2VydCh0ZXN0LT5tX2lzRXhwZWN0aW5nUGVybWlzc2lvblJlcXVl c3QpOwogICAgICAgICB0ZXN0LT5hc3NlcnRPYmplY3RJc0RlbGV0ZWRXaGVuVGVzdEZpbmlzaGVz KEdfT0JKRUNUKHJlcXVlc3QpKTsKIAogICAgICAgICB0ZXN0LT5tX2V2ZW50ID0gUGVybWlzc2lv bjsKQEAgLTY5OSwxMCArNzEwLDkgQEAgcHVibGljOgogICAgICAgICBnX21haW5fbG9vcF9xdWl0 KHRlc3QtPm1fbWFpbkxvb3ApOwogICAgIH0KIAotICAgIE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0 KCkKLSAgICAgICAgOiBtX25vdGlmaWNhdGlvbihudWxscHRyKQotICAgICAgICAsIG1fZXZlbnQo Tm9uZSkKKyAgICB2b2lkIGluaXRpYWxpemUoKQogICAgIHsKKyAgICAgICAgaW5pdGlhbGl6ZVdl YlZpZXcoKTsKICAgICAgICAgZ19zaWduYWxfY29ubmVjdChtX3dlYlZpZXcsICJwZXJtaXNzaW9u LXJlcXVlc3QiLCBHX0NBTExCQUNLKHBlcm1pc3Npb25SZXF1ZXN0Q2FsbGJhY2spLCB0aGlzKTsK ICAgICAgICAgZ19zaWduYWxfY29ubmVjdChtX3dlYlZpZXcsICJzaG93LW5vdGlmaWNhdGlvbiIs IEdfQ0FMTEJBQ0soc2hvd05vdGlmaWNhdGlvbkNhbGxiYWNrKSwgdGhpcyk7CiAgICAgICAgIHdl YmtpdF91c2VyX2NvbnRlbnRfbWFuYWdlcl9yZWdpc3Rlcl9zY3JpcHRfbWVzc2FnZV9oYW5kbGVy KG1fdXNlckNvbnRlbnRNYW5hZ2VyLmdldCgpLCAibm90aWZpY2F0aW9ucyIpOwpAQCAtNzE2LDkg KzcyNiwxOCBAQCBwdWJsaWM6CiAgICAgICAgIHdlYmtpdF91c2VyX2NvbnRlbnRfbWFuYWdlcl91 bnJlZ2lzdGVyX3NjcmlwdF9tZXNzYWdlX2hhbmRsZXIobV91c2VyQ29udGVudE1hbmFnZXIuZ2V0 KCksICJub3RpZmljYXRpb25zIik7CiAgICAgfQogCisgICAgYm9vbCBoYXNQZXJtaXNzaW9uKCkK KyAgICB7CisgICAgICAgIGF1dG8qIHJlc3VsdCA9IHJ1bkphdmFTY3JpcHRBbmRXYWl0VW50aWxG aW5pc2hlZCgiTm90aWZpY2F0aW9uLnBlcm1pc3Npb247IiwgbnVsbHB0cik7CisgICAgICAgIGdf YXNzZXJ0KHJlc3VsdCk7CisgICAgICAgIEdVbmlxdWVQdHI8Y2hhcj4gdmFsdWUoamF2YXNjcmlw dFJlc3VsdFRvQ1N0cmluZyhyZXN1bHQpKTsKKyAgICAgICAgcmV0dXJuICFnX3N0cmNtcDAodmFs dWUuZ2V0KCksICJncmFudGVkIik7CisgICAgfQorCiAgICB2b2lkIHJlcXVlc3RQZXJtaXNzaW9u QW5kV2FpdFVudGlsR2l2ZW4oKQogICAgIHsKICAgICAgICAgbV9ldmVudCA9IE5vbmU7CisgICAg ICAgIG1faXNFeHBlY3RpbmdQZXJtaXNzaW9uUmVxdWVzdCA9IHRydWU7CiAgICAgICAgIHdlYmtp dF93ZWJfdmlld19ydW5famF2YXNjcmlwdChtX3dlYlZpZXcsICJOb3RpZmljYXRpb24ucmVxdWVz dFBlcm1pc3Npb24oKTsiLCBudWxscHRyLCBudWxscHRyLCBudWxscHRyKTsKICAgICAgICAgZ19t YWluX2xvb3BfcnVuKG1fbWFpbkxvb3ApOwogICAgIH0KQEAgLTc2OSwxOCArNzg4LDI0IEBAIHB1 YmxpYzoKICAgICAgICAgZ19tYWluX2xvb3BfcnVuKG1fbWFpbkxvb3ApOwogICAgIH0KIAotICAg IE5vdGlmaWNhdGlvbkV2ZW50IG1fZXZlbnQ7Ci0gICAgV2ViS2l0Tm90aWZpY2F0aW9uKiBtX25v dGlmaWNhdGlvbjsKKyAgICBOb3RpZmljYXRpb25FdmVudCBtX2V2ZW50IHsgTm9uZSB9OworICAg IFdlYktpdE5vdGlmaWNhdGlvbiogbV9ub3RpZmljYXRpb24geyBudWxscHRyIH07CisgICAgYm9v bCBtX2lzRXhwZWN0aW5nUGVybWlzc2lvblJlcXVlc3QgeyBmYWxzZSB9OworICAgIGJvb2wgbV9o YXNQZXJtaXNzaW9uIHsgZmFsc2UgfTsKIH07CiAKIHN0YXRpYyB2b2lkIHRlc3RXZWJWaWV3Tm90 aWZpY2F0aW9uKE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0KiB0ZXN0LCBnY29uc3Rwb2ludGVyKQog eworICAgIHRlc3QtPmluaXRpYWxpemUoKTsKKwogICAgIC8vIE5vdGlmaWNhdGlvbnMgZG9uJ3Qg d29yayB3aXRoIGxvY2FsIG9yIHNwZWNpYWwgc2NoZW1lcy4KICAgICB0ZXN0LT5sb2FkVVJJKGdT ZXJ2ZXItPmdldFVSSUZvclBhdGgoIi8iKS5kYXRhKCkpOwogICAgIHRlc3QtPndhaXRVbnRpbExv YWRGaW5pc2hlZCgpOworICAgIGdfYXNzZXJ0KCF0ZXN0LT5oYXNQZXJtaXNzaW9uKCkpOwogCiAg ICAgdGVzdC0+cmVxdWVzdFBlcm1pc3Npb25BbmRXYWl0VW50aWxHaXZlbigpOwogICAgIGdfYXNz ZXJ0KHRlc3QtPm1fZXZlbnQgPT0gTm90aWZpY2F0aW9uV2ViVmlld1Rlc3Q6OlBlcm1pc3Npb24p OworICAgIGdfYXNzZXJ0KHRlc3QtPmhhc1Blcm1pc3Npb24oKSk7CiAKICAgICBzdGF0aWMgY29u c3QgY2hhciogdGl0bGUgPSAiVGhpcyBpcyBhIG5vdGlmaWNhdGlvbiI7CiAgICAgc3RhdGljIGNv bnN0IGNoYXIqIGJvZHkgPSAiVGhpcyBpcyB0aGUgYm9keS4iOwpAQCAtODE4LDYgKzg0Myw0NyBA QCBzdGF0aWMgdm9pZCB0ZXN0V2ViVmlld05vdGlmaWNhdGlvbihOb3RpZmljYXRpb25XZWJWaWV3 VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRlcgogICAgIGdfYXNzZXJ0KHRlc3QtPm1fZXZlbnQgPT0g Tm90aWZpY2F0aW9uV2ViVmlld1Rlc3Q6OkNsb3NlZCk7CiB9CiAKK3N0YXRpYyB2b2lkIHNldElu aXRpYWxOb3RpZmljYXRpb25QZXJtaXNzaW9uc0FsbG93ZWRDYWxsYmFjayhXZWJLaXRXZWJDb250 ZXh0KiBjb250ZXh0LCBOb3RpZmljYXRpb25XZWJWaWV3VGVzdCogdGVzdCkKK3sKKyAgICBHTGlz dCogYWxsb3dlZE9yaWdpbnMgPSBudWxscHRyOworICAgIGFsbG93ZWRPcmlnaW5zID0gZ19saXN0 X2FwcGVuZChhbGxvd2VkT3JpZ2lucywgd2Via2l0X3NlY3VyaXR5X29yaWdpbl9uZXdfZnJvbV9z dHJpbmcoZ1NlcnZlci0+c2VjdXJpdHlPcmlnaW4oKS5kYXRhKCkpKTsKKyAgICB3ZWJraXRfd2Vi X2NvbnRleHRfc2V0X2luaXRpYWxfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25zKHRlc3QtPm1fd2Vi Q29udGV4dC5nZXQoKSwgYWxsb3dlZE9yaWdpbnMsIG51bGxwdHIpOworICAgIGdfbGlzdF9mcmVl X2Z1bGwoYWxsb3dlZE9yaWdpbnMsIChHRGVzdHJveU5vdGlmeSl3ZWJraXRfc2VjdXJpdHlfb3Jp Z2luX3VucmVmKTsKK30KKworc3RhdGljIHZvaWQgc2V0SW5pdGlhbE5vdGlmaWNhdGlvblBlcm1p c3Npb25zRGlzYWxsb3dlZENhbGxiYWNrKFdlYktpdFdlYkNvbnRleHQqIGNvbnRleHQsIE5vdGlm aWNhdGlvbldlYlZpZXdUZXN0KiB0ZXN0KQoreworICAgIEdMaXN0KiBkaXNhbGxvd2VkT3JpZ2lu cyA9IG51bGxwdHI7CisgICAgZGlzYWxsb3dlZE9yaWdpbnMgPSBnX2xpc3RfYXBwZW5kKGRpc2Fs bG93ZWRPcmlnaW5zLCB3ZWJraXRfc2VjdXJpdHlfb3JpZ2luX25ld19mcm9tX3N0cmluZyhnU2Vy dmVyLT5zZWN1cml0eU9yaWdpbigpLmRhdGEoKSkpOworICAgIHdlYmtpdF93ZWJfY29udGV4dF9z ZXRfaW5pdGlhbF9ub3RpZmljYXRpb25fcGVybWlzc2lvbnModGVzdC0+bV93ZWJDb250ZXh0Lmdl dCgpLCBudWxscHRyLCBkaXNhbGxvd2VkT3JpZ2lucyk7CisgICAgZ19saXN0X2ZyZWVfZnVsbChk aXNhbGxvd2VkT3JpZ2lucywgKEdEZXN0cm95Tm90aWZ5KXdlYmtpdF9zZWN1cml0eV9vcmlnaW5f dW5yZWYpOworfQorCitzdGF0aWMgdm9pZCB0ZXN0V2ViVmlld05vdGlmaWNhdGlvbkluaXRpYWxQ ZXJtaXNzaW9uQWxsb3dlZChOb3RpZmljYXRpb25XZWJWaWV3VGVzdCogdGVzdCwgZ2NvbnN0cG9p bnRlcikKK3sKKyAgICBnX3NpZ25hbF9jb25uZWN0KHRlc3QtPm1fd2ViQ29udGV4dC5nZXQoKSwg InNldC1pbml0aWFsLW5vdGlmaWNhdGlvbi1wZXJtaXNzaW9ucyIsIEdfQ0FMTEJBQ0soc2V0SW5p dGlhbE5vdGlmaWNhdGlvblBlcm1pc3Npb25zQWxsb3dlZENhbGxiYWNrKSwgdGVzdCk7CisgICAg dGVzdC0+aW5pdGlhbGl6ZSgpOworCisgICAgdGVzdC0+bG9hZFVSSShnU2VydmVyLT5nZXRVUklG b3JQYXRoKCIvIikuZGF0YSgpKTsKKyAgICB0ZXN0LT53YWl0VW50aWxMb2FkRmluaXNoZWQoKTsK KyAgICBnX2Fzc2VydCh0ZXN0LT5oYXNQZXJtaXNzaW9uKCkpOworCisgICAgc3RhdGljIGNvbnN0 IGNoYXIqIHRpdGxlID0gIlRoaXMgaXMgYSBub3RpZmljYXRpb24iOworICAgIHN0YXRpYyBjb25z dCBjaGFyKiBib2R5ID0gIlRoaXMgaXMgdGhlIGJvZHkuIjsKKyAgICB0ZXN0LT5yZXF1ZXN0Tm90 aWZpY2F0aW9uQW5kV2FpdFVudGlsU2hvd24odGl0bGUsIGJvZHkpOworICAgIGdfYXNzZXJ0KHRl c3QtPm1fZXZlbnQgPT0gTm90aWZpY2F0aW9uV2ViVmlld1Rlc3Q6OlNob3duKTsKK30KKworc3Rh dGljIHZvaWQgdGVzdFdlYlZpZXdOb3RpZmljYXRpb25Jbml0aWFsUGVybWlzc2lvbkRpc2FsbG93 ZWQoTm90aWZpY2F0aW9uV2ViVmlld1Rlc3QqIHRlc3QsIGdjb25zdHBvaW50ZXIpCit7CisgICAg Z19zaWduYWxfY29ubmVjdCh0ZXN0LT5tX3dlYkNvbnRleHQuZ2V0KCksICJzZXQtaW5pdGlhbC1u b3RpZmljYXRpb24tcGVybWlzc2lvbnMiLCBHX0NBTExCQUNLKHNldEluaXRpYWxOb3RpZmljYXRp b25QZXJtaXNzaW9uc0Rpc2FsbG93ZWRDYWxsYmFjayksIHRlc3QpOworICAgIHRlc3QtPmluaXRp YWxpemUoKTsKKworICAgIHRlc3QtPmxvYWRVUkkoZ1NlcnZlci0+Z2V0VVJJRm9yUGF0aCgiLyIp LmRhdGEoKSk7CisgICAgdGVzdC0+d2FpdFVudGlsTG9hZEZpbmlzaGVkKCk7CisgICAgZ19hc3Nl cnQoIXRlc3QtPmhhc1Blcm1pc3Npb24oKSk7Cit9CisKIHN0YXRpYyB2b2lkIHRlc3RXZWJWaWV3 SXNQbGF5aW5nQXVkaW8oSXNQbGF5aW5nQXVkaW9XZWJWaWV3VGVzdCogdGVzdCwgZ2NvbnN0cG9p bnRlcikKIHsKICAgICAvLyBUaGUgd2ViIHZpZXcgbXVzdCBiZSByZWFsaXplZCBmb3IgdGhlIHZp ZGVvIHRvIHN0YXJ0IHBsYXliYWNrIGFuZApAQCAtOTE1LDYgKzk4MSw4IEBAIHZvaWQgYmVmb3Jl QWxsKCkKICAgICBTbmFwc2hvdFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAic25h cHNob3QiLCB0ZXN0V2ViVmlld1NuYXBzaG90KTsKICAgICBXZWJWaWV3VGVzdDo6YWRkKCJXZWJL aXRXZWJWaWV3IiwgInBhZ2UtdmlzaWJpbGl0eSIsIHRlc3RXZWJWaWV3UGFnZVZpc2liaWxpdHkp OwogICAgIE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAibm90 aWZpY2F0aW9uIiwgdGVzdFdlYlZpZXdOb3RpZmljYXRpb24pOworICAgIE5vdGlmaWNhdGlvbldl YlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAibm90aWZpY2F0aW9uLWluaXRpYWwtcGVy bWlzc2lvbi1hbGxvd2VkIiwgdGVzdFdlYlZpZXdOb3RpZmljYXRpb25Jbml0aWFsUGVybWlzc2lv bkFsbG93ZWQpOworICAgIE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZp ZXciLCAibm90aWZpY2F0aW9uLWluaXRpYWwtcGVybWlzc2lvbi1kaXNhbGxvd2VkIiwgdGVzdFdl YlZpZXdOb3RpZmljYXRpb25Jbml0aWFsUGVybWlzc2lvbkRpc2FsbG93ZWQpOwogICAgIElzUGxh eWluZ0F1ZGlvV2ViVmlld1Rlc3Q6OmFkZCgiV2ViS2l0V2ViVmlldyIsICJpcy1wbGF5aW5nLWF1 ZGlvIiwgdGVzdFdlYlZpZXdJc1BsYXlpbmdBdWRpbyk7CiAgICAgV2ViVmlld1Rlc3Q6OmFkZCgi V2ViS2l0V2ViVmlldyIsICJiYWNrZ3JvdW5kLWNvbG9yIiwgdGVzdFdlYlZpZXdCYWNrZ3JvdW5k Q29sb3IpOwogICAgIFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAicHJlZmVycmVk LXNpemUiLCB0ZXN0V2ViVmlld1ByZWZlcnJlZFNpemUpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVz dFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9UZXN0TWFpbi5oIGIvVG9vbHMvVGVzdFdlYktpdEFQ SS9ndGsvV2ViS2l0Mkd0ay9UZXN0TWFpbi5oCmluZGV4IDYwNTRmZTA5ZDQ3OWE4ODA2MDlmMzY1 MjI1ZDg5M2M4NjI2ZWM5YzQuLmY2OGFmMmE5NjUxNjJiM2QyZWZiOWJkZTk1NzgwMDFhNGI1NWFj ZmYgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvVGVzdE1h aW4uaAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1Rlc3RNYWluLmgK QEAgLTQzLDYgKzQzLDI1IEBACiAgICAgICAgIGdfdGVzdF9hZGQodGVzdFBhdGguZ2V0KCksIENs YXNzTmFtZSwgMCwgQ2xhc3NOYW1lOjpzZXRVcCwgdGVzdEZ1bmMsIENsYXNzTmFtZTo6dGVhckRv d24pOyBcCiAgICAgfQogCisjZGVmaW5lIE1BS0VfR0xJQl9URVNUX0ZJWFRVUkVfV0lUSF9TRVRV UF9URUFSRE9XTihDbGFzc05hbWUsIHNldHVwLCB0ZWFyZG93bikgXAorICAgIHN0YXRpYyB2b2lk IHNldFVwKENsYXNzTmFtZSogZml4dHVyZSwgZ2NvbnN0cG9pbnRlciBkYXRhKSBcCisgICAgeyBc CisgICAgICAgIGlmIChzZXR1cCkgXAorICAgICAgICAgICAgc2V0dXAoKTsgXAorICAgICAgICBu ZXcgKGZpeHR1cmUpIENsYXNzTmFtZTsgXAorICAgIH0gXAorICAgIHN0YXRpYyB2b2lkIHRlYXJE b3duKENsYXNzTmFtZSogZml4dHVyZSwgZ2NvbnN0cG9pbnRlciBkYXRhKSBcCisgICAgeyBcCisg ICAgICAgIGZpeHR1cmUtPn5DbGFzc05hbWUoKTsgXAorICAgICAgICBpZiAodGVhcmRvd24pIFwK KyAgICAgICAgICAgIHRlYXJkb3duKCk7IFwKKyAgICB9IFwKKyAgICBzdGF0aWMgdm9pZCBhZGQo Y29uc3QgY2hhciogc3VpdGVOYW1lLCBjb25zdCBjaGFyKiB0ZXN0TmFtZSwgdm9pZCAoKnRlc3RG dW5jKShDbGFzc05hbWUqLCBjb25zdCB2b2lkKikpIFwKKyAgICB7IFwKKyAgICAgICAgR1VuaXF1 ZVB0cjxnY2hhcj4gdGVzdFBhdGgoZ19zdHJkdXBfcHJpbnRmKCIvd2Via2l0Mi8lcy8lcyIsIHN1 aXRlTmFtZSwgdGVzdE5hbWUpKTsgXAorICAgICAgICBnX3Rlc3RfYWRkKHRlc3RQYXRoLmdldCgp LCBDbGFzc05hbWUsIDAsIENsYXNzTmFtZTo6c2V0VXAsIHRlc3RGdW5jLCBDbGFzc05hbWU6OnRl YXJEb3duKTsgXAorICAgIH0KKwogI2RlZmluZSBBU1NFUlRfQ01QX0NTVFJJTkcoczEsIGNtcCwg czIpIFwKICAgICBkbyB7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBcCiAgICAgICAgIENTdHJpbmcgX19zMSA9IChzMSk7ICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXApkaWZmIC0tZ2l0IGEv VG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJLaXRUZXN0U2VydmVyLmNwcCBi L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViS2l0VGVzdFNlcnZlci5jcHAK aW5kZXggZGU5NDY2YzM5ZDcxY2ZjMmFiZjQ0OWZjZmRlMzg5YjU0NDlkZjMyNy4uYzQ5MjlkZThh MDhlODVlZmFkYWM2Y2Q0OWNiMTRkMDQxNTY3NTI0YiAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdl YktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJLaXRUZXN0U2VydmVyLmNwcAorKysgYi9Ub29scy9U ZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYktpdFRlc3RTZXJ2ZXIuY3BwCkBAIC02OCw3 ICs2OCwxNSBAQCB2b2lkIFdlYktpdFRlc3RTZXJ2ZXI6OnJ1bihTb3VwU2VydmVyQ2FsbGJhY2sg c2VydmVyQ2FsbGJhY2spCiAgICAgfQogfQogCi1DU3RyaW5nIFdlYktpdFRlc3RTZXJ2ZXI6Omdl dFVSSUZvclBhdGgoY29uc3QgY2hhciogcGF0aCkKK0NTdHJpbmcgV2ViS2l0VGVzdFNlcnZlcjo6 c2VjdXJpdHlPcmlnaW4oKSBjb25zdAoreworICAgIC8vIFRoZSBzZWN1cml0eSBvcmlnaW4gaXMg dGhlIGJhc2UgVVJJIG1pbnVzIHRoZSB0cmFpbGluZyBzbGFzaC4KKyAgICBHVW5pcXVlUHRyPGdj aGFyPiB1cmlTdHJpbmcoc291cF91cmlfdG9fc3RyaW5nKG1fYmFzZVVSSSwgRkFMU0UpKTsKKyAg ICB1cmlTdHJpbmcuZ2V0KClbc3RybGVuKHVyaVN0cmluZy5nZXQoKSkgLSAxXSA9ICdcMCc7Cisg ICAgcmV0dXJuIHVyaVN0cmluZy5nZXQoKTsKK30KKworQ1N0cmluZyBXZWJLaXRUZXN0U2VydmVy OjpnZXRVUklGb3JQYXRoKGNvbnN0IGNoYXIqIHBhdGgpIGNvbnN0CiB7CiAgICAgU291cFVSSSog dXJpID0gc291cF91cmlfbmV3X3dpdGhfYmFzZShtX2Jhc2VVUkksIHBhdGgpOwogICAgIEdVbmlx dWVQdHI8Z2NoYXI+IHVyaVN0cmluZyhzb3VwX3VyaV90b19zdHJpbmcodXJpLCBGQUxTRSkpOwpk aWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJLaXRUZXN0 U2VydmVyLmggYi9Ub29scy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYktpdFRlc3RT ZXJ2ZXIuaAppbmRleCA1OGYwMTlmYWI4NjAxYzJkMTMxNDZhY2M1NGZjNzg4ZGNlMjljNjhhLi5k MzgyMDk1YjI2ZjNiMjM3OTkzZTJhOTIyZTNjMmFkYzNhNGE3NWJhIDEwMDY0NAotLS0gYS9Ub29s cy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYktpdFRlc3RTZXJ2ZXIuaAorKysgYi9U b29scy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYktpdFRlc3RTZXJ2ZXIuaApAQCAt MzksOCArMzksOCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB+V2ViS2l0VGVzdFNlcnZlcigpOwog CiAgICAgU291cFVSSSogYmFzZVVSSSgpIHsgcmV0dXJuIG1fYmFzZVVSSTsgfQotCi0gICAgQ1N0 cmluZyBnZXRVUklGb3JQYXRoKGNvbnN0IGNoYXIqIHBhdGgpOworICAgIENTdHJpbmcgc2VjdXJp dHlPcmlnaW4oKSBjb25zdDsKKyAgICBDU3RyaW5nIGdldFVSSUZvclBhdGgoY29uc3QgY2hhciog cGF0aCkgY29uc3Q7CiAgICAgdm9pZCBydW4oU291cFNlcnZlckNhbGxiYWNrKTsKIAogcHJpdmF0 ZToKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViVmll d1Rlc3QuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJWaWV3VGVz dC5jcHAKaW5kZXggNGEyMjE0NWM0NzE5OTJiZTQwY2YzZGRjNTQ1OTA1ZDFhYzMzMDZmNC4uYmQ5 NzFiYTNmZjI1YjYwMjRjYWY0MTFiMTA5MmE1MjY5OTNmNDNmNCAxMDA2NDQKLS0tIGEvVG9vbHMv VGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJWaWV3VGVzdC5jcHAKKysrIGIvVG9vbHMv VGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJWaWV3VGVzdC5jcHAKQEAgLTI0LDE5ICsy NCwxNCBAQAogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0pTUmV0YWluUHRyLmg+CiAjaW5jbHVk ZSA8V2ViQ29yZS9HVW5pcXVlUHRyR3RrLmg+CiAKK2Jvb2wgV2ViVmlld1Rlc3Q6OnNob3VsZElu aXRpYWxpemVXZWJWaWV3SW5Db25zdHJ1Y3RvciA9IHRydWU7CisKIFdlYlZpZXdUZXN0OjpXZWJW aWV3VGVzdCgpCiAgICAgOiBtX3VzZXJDb250ZW50TWFuYWdlcihhZG9wdEdSZWYod2Via2l0X3Vz ZXJfY29udGVudF9tYW5hZ2VyX25ldygpKSkKLSAgICAsIG1fd2ViVmlldyhXRUJLSVRfV0VCX1ZJ RVcoZ19vYmplY3RfcmVmX3NpbmsoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX1dFQl9WSUVXLCAi d2ViLWNvbnRleHQiLCBtX3dlYkNvbnRleHQuZ2V0KCksICJ1c2VyLWNvbnRlbnQtbWFuYWdlciIs IG1fdXNlckNvbnRlbnRNYW5hZ2VyLmdldCgpLCBudWxscHRyKSkpKQogICAgICwgbV9tYWluTG9v cChnX21haW5fbG9vcF9uZXcobnVsbHB0ciwgVFJVRSkpCi0gICAgLCBtX3BhcmVudFdpbmRvdyhu dWxscHRyKQotICAgICwgbV9qYXZhc2NyaXB0UmVzdWx0KG51bGxwdHIpCi0gICAgLCBtX3Jlc291 cmNlRGF0YVNpemUoMCkKLSAgICAsIG1fc3VyZmFjZShudWxscHRyKQotICAgICwgbV9leHBlY3Rl ZFdlYlByb2Nlc3NDcmFzaChmYWxzZSkKIHsKLSAgICBhc3NlcnRPYmplY3RJc0RlbGV0ZWRXaGVu VGVzdEZpbmlzaGVzKEdfT0JKRUNUKG1fd2ViVmlldykpOwotICAgIGFzc2VydE9iamVjdElzRGVs ZXRlZFdoZW5UZXN0RmluaXNoZXMoR19PQkpFQ1QobV91c2VyQ29udGVudE1hbmFnZXIuZ2V0KCkp KTsKLSAgICBnX3NpZ25hbF9jb25uZWN0KG1fd2ViVmlldywgIndlYi1wcm9jZXNzLWNyYXNoZWQi LCBHX0NBTExCQUNLKFdlYlZpZXdUZXN0Ojp3ZWJQcm9jZXNzQ3Jhc2hlZCksIHRoaXMpOworICAg IGlmIChzaG91bGRJbml0aWFsaXplV2ViVmlld0luQ29uc3RydWN0b3IpCisgICAgICAgIGluaXRp YWxpemVXZWJWaWV3KCk7CiB9CiAKIFdlYlZpZXdUZXN0Ojp+V2ViVmlld1Rlc3QoKQpAQCAtNTEs NiArNDYsMTUgQEAgV2ViVmlld1Rlc3Q6On5XZWJWaWV3VGVzdCgpCiAgICAgZ19tYWluX2xvb3Bf dW5yZWYobV9tYWluTG9vcCk7CiB9CiAKK3ZvaWQgV2ViVmlld1Rlc3Q6OmluaXRpYWxpemVXZWJW aWV3KCkKK3sKKyAgICBnX2Fzc2VydCghbV93ZWJWaWV3KTsKKyAgICBtX3dlYlZpZXcgPSBXRUJL SVRfV0VCX1ZJRVcoZ19vYmplY3RfcmVmX3NpbmsoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX1dF Ql9WSUVXLCAid2ViLWNvbnRleHQiLCBtX3dlYkNvbnRleHQuZ2V0KCksICJ1c2VyLWNvbnRlbnQt bWFuYWdlciIsIG1fdXNlckNvbnRlbnRNYW5hZ2VyLmdldCgpLCBudWxscHRyKSkpOworICAgIGFz c2VydE9iamVjdElzRGVsZXRlZFdoZW5UZXN0RmluaXNoZXMoR19PQkpFQ1QobV93ZWJWaWV3KSk7 CisgICAgYXNzZXJ0T2JqZWN0SXNEZWxldGVkV2hlblRlc3RGaW5pc2hlcyhHX09CSkVDVChtX3Vz ZXJDb250ZW50TWFuYWdlci5nZXQoKSkpOworICAgIGdfc2lnbmFsX2Nvbm5lY3QobV93ZWJWaWV3 LCAid2ViLXByb2Nlc3MtY3Jhc2hlZCIsIEdfQ0FMTEJBQ0soV2ViVmlld1Rlc3Q6OndlYlByb2Nl c3NDcmFzaGVkKSwgdGhpcyk7Cit9CisKIGdib29sZWFuIFdlYlZpZXdUZXN0Ojp3ZWJQcm9jZXNz Q3Jhc2hlZChXZWJLaXRXZWJWaWV3KiwgV2ViVmlld1Rlc3QqIHRlc3QpCiB7CiAgICAgaWYgKHRl c3QtPm1fZXhwZWN0ZWRXZWJQcm9jZXNzQ3Jhc2gpIHsKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViVmlld1Rlc3QuaCBiL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvZ3RrL1dlYktpdDJHdGsvV2ViVmlld1Rlc3QuaAppbmRleCBhMzAwMWIyZGUzNDE4ZTcwYzlh NzM5YmVjYTdhZTIzMzY3MDRlY2MyLi40ZjBjNGM3YmY1OGQwMzU1OTYyZjY5YWUzOGE0YjAyODdh MzgyNjNiIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dl YlZpZXdUZXN0LmgKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJW aWV3VGVzdC5oCkBAIC0zMSw2ICszMSw5IEBAIHB1YmxpYzoKICAgICBXZWJWaWV3VGVzdCgpOwog ICAgIHZpcnR1YWwgfldlYlZpZXdUZXN0KCk7CiAKKyAgICBzdGF0aWMgYm9vbCBzaG91bGRJbml0 aWFsaXplV2ViVmlld0luQ29uc3RydWN0b3I7CisgICAgdm9pZCBpbml0aWFsaXplV2ViVmlldygp OworCiAgICAgdmlydHVhbCB2b2lkIGxvYWRVUkkoY29uc3QgY2hhciogdXJpKTsKICAgICB2aXJ0 dWFsIHZvaWQgbG9hZEh0bWwoY29uc3QgY2hhciogaHRtbCwgY29uc3QgY2hhciogYmFzZVVSSSk7 CiAgICAgdmlydHVhbCB2b2lkIGxvYWRQbGFpblRleHQoY29uc3QgY2hhciogcGxhaW5UZXh0KTsK QEAgLTgxLDE3ICs4NCwxNyBAQCBwdWJsaWM6CiAgICAgc3RhdGljIGdib29sZWFuIHdlYlByb2Nl c3NDcmFzaGVkKFdlYktpdFdlYlZpZXcqLCBXZWJWaWV3VGVzdCopOwogCiAgICAgR1JlZlB0cjxX ZWJLaXRVc2VyQ29udGVudE1hbmFnZXI+IG1fdXNlckNvbnRlbnRNYW5hZ2VyOwotICAgIFdlYktp dFdlYlZpZXcqIG1fd2ViVmlldzsKKyAgICBXZWJLaXRXZWJWaWV3KiBtX3dlYlZpZXcgeyBudWxs cHRyIH07CiAgICAgR01haW5Mb29wKiBtX21haW5Mb29wOwogICAgIENTdHJpbmcgbV9hY3RpdmVV Ukk7Ci0gICAgR3RrV2lkZ2V0KiBtX3BhcmVudFdpbmRvdzsKKyAgICBHdGtXaWRnZXQqIG1fcGFy ZW50V2luZG93IHsgbnVsbHB0ciB9OwogICAgIENTdHJpbmcgbV9leHBlY3RlZFRpdGxlOwotICAg IFdlYktpdEphdmFzY3JpcHRSZXN1bHQqIG1famF2YXNjcmlwdFJlc3VsdDsKLSAgICBHRXJyb3Iq KiBtX2phdmFzY3JpcHRFcnJvcjsKLSAgICBHVW5pcXVlUHRyPGNoYXI+IG1fcmVzb3VyY2VEYXRh OwotICAgIHNpemVfdCBtX3Jlc291cmNlRGF0YVNpemU7Ci0gICAgY2Fpcm9fc3VyZmFjZV90KiBt X3N1cmZhY2U7Ci0gICAgYm9vbCBtX2V4cGVjdGVkV2ViUHJvY2Vzc0NyYXNoOworICAgIFdlYktp dEphdmFzY3JpcHRSZXN1bHQqIG1famF2YXNjcmlwdFJlc3VsdCB7IG51bGxwdHIgfTsKKyAgICBH RXJyb3IqKiBtX2phdmFzY3JpcHRFcnJvciB7IG51bGxwdHIgfTsKKyAgICBHVW5pcXVlUHRyPGNo YXI+IG1fcmVzb3VyY2VEYXRhIHsgbnVsbHB0ciB9OworICAgIHNpemVfdCBtX3Jlc291cmNlRGF0 YVNpemUgeyAwIH07CisgICAgY2Fpcm9fc3VyZmFjZV90KiBtX3N1cmZhY2UgeyBudWxscHRyIH07 CisgICAgYm9vbCBtX2V4cGVjdGVkV2ViUHJvY2Vzc0NyYXNoIHsgZmFsc2UgfTsKIAogcHJpdmF0 ZToKICAgICB2b2lkIGRvTW91c2VCdXR0b25FdmVudChHZGtFdmVudFR5cGUsIGludCwgaW50LCB1 bnNpZ25lZCwgdW5zaWduZWQpOwo= 297957 2017-01-03 15:00:37 -0800 2017-01-03 23:22:44 -0800 Patch bug-163366-20170103165911.patch text/plain 32563 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjEwMjQwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggOWQxNzJiOTRkZDg0MDFj NGNiOGU0M2JmOTU3NDYzNzA3MTY3MGViMy4uYTlmODMxMjMxNmMxMjNkZjQyOTQ3ZTU4ODk5MjNl NDliZjExNjYzYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ0IEBACisyMDE3LTAxLTAzICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBO byB3YXkgZm9yIGFwcGxpY2F0aW9ucyB0byBzZXQgbm90aWZpY2F0aW9uIHBlcm1pc3Npb25zIHdp dGhvdXQgd2FpdGluZyBmb3IgcGVybWlzc2lvbiByZXF1ZXN0CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjMzNjYKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXZWJzaXRlcyBjYW4gY2hlY2sgdGhlIE5vdGlm aWNhdGlvbi5wZXJtaXNzaW9uIERPTSBwcm9wZXJ0eSB0byBjaGVjayBpZiB0aGV5IGhhdmUgcGVy bWlzc2lvbgorICAgICAgICB0byBzaG93IG5vdGlmaWNhdGlvbnMgKndpdGhvdXQgdHJpZ2dlcmlu ZyBhIHBlcm1pc3Npb24gcmVxdWVzdCouIEJ1dCB0aGUgV2ViS2l0R1RLKyBBUEkgaGFzCisgICAg ICAgIG5vIHdheSB0byBhZmZpcm1hdGl2ZWx5IGluZGljYXRlIG5vdGlmaWNhdGlvbnMgYXJlIGFs bG93ZWQgd2l0aG91dCBhIHBlcm1pc3Npb24gcmVxdWVzdC4gVGhlCisgICAgICAgIG9ubHkgd2F5 IGlzIHZpYSB0aGUgcGVybWlzc2lvbiByZXF1ZXN0IEFQSSwgd2hpY2ggaXMgdG9vIGxhdGUuIEl0 J3MgYSBwcm9ibGVtIGZvciBFcGlwaGFueS4KKyAgICAgICAgRm9yIGV4YW1wbGUsIG9wZW4gdGhl IFJpb3QgTWF0cml4IGNsaWVudCBpbiBhIHdlYiBhcHA7IHlvdSB3aWxsIGltbWVkaWF0ZWx5IHNl ZSBhbiBpbmZvIGJhcgorICAgICAgICBpbmZvcm1pbmcgdGhlIHVzZXIgdGhhdCBSaW90IGRvZXMg bm90IGhhdmUgcGVybWlzc2lvbiB0byBzZW5kIGRlc2t0b3Agbm90aWZpY2F0aW9ucywgZXZlbgor ICAgICAgICB0aG91Z2ggRXBpcGhhbnkgYXV0b21hdGljYWxseSBncmFudHMgbm90aWZpY2F0aW9u IHBlcm1pc3Npb24gaW4gd2ViIGFwcCBtb2RlIHdoZW4gcmVxdWVzdGVkLgorICAgICAgICBUaGlz IHByb2JsZW0gaXMgbm90IGV4Y2x1c2l2ZSB0byB3ZWIgYXBwczsgdGhlcmUgaXMgc2ltcGx5IG5v IHdheSBmb3Igbm90aWZpY2F0aW9uCisgICAgICAgIHBlcm1pc3Npb24gdG8gYmUgc2V0IGNvcnJl Y3RseSBwcmlvciB0byBhIHBlcm1pc3Npb24gcmVxdWVzdCBmb3IgaXQuIEZpeCB0aGlzIGJ5IGlu dHJvZHVjaW5nCisgICAgICAgIGEgd2Via2l0X3dlYl9jb250ZXh0X2luaXRpYWxpemVfbm90aWZp Y2F0aW9uX3Blcm1pc3Npb25zKCkgQVBJLCBhbmQgYWRkIGEgc2lnbmFsCisgICAgICAgIFdlYktp dFdlYkNvbnRleHQ6OmluaXRpYWxpemUtbm90aWZpY2F0aW9uLXBlcm1pc3Npb25zIHRvIGluZGlj YXRlIHdoZW4gaXQgc2hvdWxkIGJlIGNhbGxlZC4KKworICAgICAgICAqIFVJUHJvY2Vzcy9BUEkv Z3RrL1dlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyLmNwcDoKKyAgICAgICAgKG5vdGlmaWNhdGlv blBlcm1pc3Npb25zQ2FsbGJhY2spOgorICAgICAgICAoV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlk ZXI6OmNyZWF0ZSk6CisgICAgICAgIChXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcjo6V2ViS2l0 Tm90aWZpY2F0aW9uUHJvdmlkZXIpOgorICAgICAgICAoV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlk ZXI6Om5vdGlmaWNhdGlvblBlcm1pc3Npb25zKToKKyAgICAgICAgKFdlYktpdE5vdGlmaWNhdGlv blByb3ZpZGVyOjpzZXROb3RpZmljYXRpb25QZXJtaXNzaW9ucyk6CisgICAgICAgICogVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuaDoKKyAgICAgICAgKiBVSVBy b2Nlc3MvQVBJL2d0ay9XZWJLaXRTZWN1cml0eU9yaWdpbi5jcHA6CisgICAgICAgICh3ZWJraXRT ZWN1cml0eU9yaWdpbkdldFNlY3VyaXR5T3JpZ2luKToKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXRTZWN1cml0eU9yaWdpblByaXZhdGUuaDoKKyAgICAgICAgKiBVSVByb2Nlc3Mv QVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcDoKKyAgICAgICAgKHdlYmtpdFdlYkNvbnRleHRD b25zdHJ1Y3RlZCk6CisgICAgICAgICh3ZWJraXRfd2ViX2NvbnRleHRfY2xhc3NfaW5pdCk6Cisg ICAgICAgIChhZGRPcmlnaW5Ub01hcCk6CisgICAgICAgIChhZGRBbGxvd2VkT3JpZ2luVG9NYXAp OgorICAgICAgICAoYWRkRGlzYWxsb3dlZE9yaWdpblRvTWFwKToKKyAgICAgICAgKHdlYmtpdF93 ZWJfY29udGV4dF9pbml0aWFsaXplX25vdGlmaWNhdGlvbl9wZXJtaXNzaW9ucyk6CisgICAgICAg ICh3ZWJraXRXZWJDb250ZXh0SW5pdGlhbGl6ZU5vdGlmaWNhdGlvblBlcm1pc3Npb25zKToKKyAg ICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0Lmg6CisgICAgICAgICog VUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dFByaXZhdGUuaDoKKyAgICAgICAgKiBV SVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstNC4wLXNlY3Rpb25zLnR4dDoKKwogMjAx Ny0wMS0wMyAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGlnYWxpYS5jb20+IGFuZCBD YXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KIAogICAgICAgICBbR1RL XSBFeHBvc2UgV2ViS2l0U2VjdXJpdHlPcmlnaW4gQVBJCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5jcHAgYi9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRl ci5jcHAKaW5kZXggYTgwZTY4Njc3OTkwMGFiZGIwMTE1MGFiZjJmMzkwYzE4YWYwN2RhOC4uYjYw NjY5YWRiODQxMmQxMDRmNDM1MDJhMzkyM2VkOGRjMzhiZmQ0MCAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIuY3Bw CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdE5vdGlmaWNhdGlv blByb3ZpZGVyLmNwcApAQCAtMjgsOCArMjgsMTAgQEAKICNpbmNsdWRlICJXZWJLaXROb3RpZmlj YXRpb25Qcm92aWRlci5oIgogCiAjaW5jbHVkZSAiQVBJQXJyYXkuaCIKKyNpbmNsdWRlICJBUElE aWN0aW9uYXJ5LmgiCiAjaW5jbHVkZSAiV0tOb3RpZmljYXRpb25NYW5hZ2VyLmgiCiAjaW5jbHVk ZSAiV2ViS2l0Tm90aWZpY2F0aW9uUHJpdmF0ZS5oIgorI2luY2x1ZGUgIldlYktpdFdlYkNvbnRl eHRQcml2YXRlLmgiCiAjaW5jbHVkZSAiV2ViS2l0V2ViVmlld1ByaXZhdGUuaCIKICNpbmNsdWRl ICJXZWJOb3RpZmljYXRpb25NYW5hZ2VyUHJveHkuaCIKICNpbmNsdWRlICJXZWJQYWdlUHJveHku aCIKQEAgLTUyLDYgKzU0LDExIEBAIHN0YXRpYyB2b2lkIGNhbmNlbENhbGxiYWNrKFdLTm90aWZp Y2F0aW9uUmVmIG5vdGlmaWNhdGlvbiwgY29uc3Qgdm9pZCogY2xpZW50SW5mCiAgICAgdG9Ob3Rp ZmljYXRpb25Qcm92aWRlcihjbGllbnRJbmZvKS0+Y2FuY2VsKCp0b0ltcGwobm90aWZpY2F0aW9u KSk7CiB9CiAKK3N0YXRpYyBXS0RpY3Rpb25hcnlSZWYgbm90aWZpY2F0aW9uUGVybWlzc2lvbnND YWxsYmFjayhjb25zdCB2b2lkKiBjbGllbnRJbmZvKQoreworICAgIHJldHVybiB0b0FQSSh0b05v dGlmaWNhdGlvblByb3ZpZGVyKGNsaWVudEluZm8pLT5ub3RpZmljYXRpb25QZXJtaXNzaW9ucygp LmxlYWtSZWYoKSk7Cit9CisKIHN0YXRpYyB2b2lkIGNsZWFyTm90aWZpY2F0aW9uc0NhbGxiYWNr KFdLQXJyYXlSZWYgbm90aWZpY2F0aW9uSURzLCBjb25zdCB2b2lkKiBjbGllbnRJbmZvKQogewog ICAgIHRvTm90aWZpY2F0aW9uUHJvdmlkZXIoY2xpZW50SW5mbyktPmNsZWFyTm90aWZpY2F0aW9u cyh0b0ltcGwobm90aWZpY2F0aW9uSURzKSk7CkBAIC02MSwxMyArNjgsMTQgQEAgV2ViS2l0Tm90 aWZpY2F0aW9uUHJvdmlkZXI6On5XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcigpCiB7CiB9CiAK LVJlZjxXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcj4gV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlk ZXI6OmNyZWF0ZShXZWJOb3RpZmljYXRpb25NYW5hZ2VyUHJveHkqIG5vdGlmaWNhdGlvbk1hbmFn ZXIpCitSZWY8V2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI+IFdlYktpdE5vdGlmaWNhdGlvblBy b3ZpZGVyOjpjcmVhdGUoV2ViTm90aWZpY2F0aW9uTWFuYWdlclByb3h5KiBub3RpZmljYXRpb25N YW5hZ2VyLCBXZWJLaXRXZWJDb250ZXh0KiB3ZWJDb250ZXh0KQogewotICAgIHJldHVybiBhZG9w dFJlZigqbmV3IFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyKG5vdGlmaWNhdGlvbk1hbmFnZXIp KTsKKyAgICByZXR1cm4gYWRvcHRSZWYoKm5ldyBXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcihu b3RpZmljYXRpb25NYW5hZ2VyLCB3ZWJDb250ZXh0KSk7CiB9CiAKLVdlYktpdE5vdGlmaWNhdGlv blByb3ZpZGVyOjpXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcihXZWJOb3RpZmljYXRpb25NYW5h Z2VyUHJveHkqIG5vdGlmaWNhdGlvbk1hbmFnZXIpCi0gICAgOiBtX25vdGlmaWNhdGlvbk1hbmFn ZXIobm90aWZpY2F0aW9uTWFuYWdlcikKK1dlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyOjpXZWJL aXROb3RpZmljYXRpb25Qcm92aWRlcihXZWJOb3RpZmljYXRpb25NYW5hZ2VyUHJveHkqIG5vdGlm aWNhdGlvbk1hbmFnZXIsIFdlYktpdFdlYkNvbnRleHQqIHdlYkNvbnRleHQpCisgICAgOiBtX3dl YkNvbnRleHQod2ViQ29udGV4dCkKKyAgICAsIG1fbm90aWZpY2F0aW9uTWFuYWdlcihub3RpZmlj YXRpb25NYW5hZ2VyKQogewogICAgIEFTU0VSVChub3RpZmljYXRpb25NYW5hZ2VyKTsKIApAQCAt ODEsNyArODksNyBAQCBXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcjo6V2ViS2l0Tm90aWZpY2F0 aW9uUHJvdmlkZXIoV2ViTm90aWZpY2F0aW9uTWFuYWdlclBybwogICAgICAgICAwLCAvLyBkaWRE ZXN0cm95Tm90aWZpY2F0aW9uQ2FsbGJhY2ssCiAgICAgICAgIDAsIC8vIGFkZE5vdGlmaWNhdGlv bk1hbmFnZXJDYWxsYmFjaywKICAgICAgICAgMCwgLy8gcmVtb3ZlTm90aWZpY2F0aW9uTWFuYWdl ckNhbGxiYWNrLAotICAgICAgICAwLCAvLyBub3RpZmljYXRpb25QZXJtaXNzaW9uc0NhbGxiYWNr LAorICAgICAgICBub3RpZmljYXRpb25QZXJtaXNzaW9uc0NhbGxiYWNrLAogICAgICAgICBjbGVh ck5vdGlmaWNhdGlvbnNDYWxsYmFjaywKICAgICB9OwogCkBAIC0xNTIsMyArMTYwLDE0IEBAIHZv aWQgV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI6OmNsZWFyTm90aWZpY2F0aW9ucyhjb25zdCBB UEk6OkFycmF5KiBub3RpZmljYXRpCiAgICAgZm9yIChjb25zdCBhdXRvJiBpdGVtIDogbm90aWZp Y2F0aW9uSURzLT5lbGVtZW50c09mVHlwZTxBUEk6OlVJbnQ2ND4oKSkKICAgICAgICAgY2FuY2Vs Tm90aWZpY2F0aW9uQnlJRChpdGVtLT52YWx1ZSgpKTsKIH0KKworUmVmUHRyPEFQSTo6RGljdGlv bmFyeT4gV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI6Om5vdGlmaWNhdGlvblBlcm1pc3Npb25z KCkKK3sKKyAgICB3ZWJraXRXZWJDb250ZXh0SW5pdGlhbGl6ZU5vdGlmaWNhdGlvblBlcm1pc3Np b25zKG1fd2ViQ29udGV4dCk7CisgICAgcmV0dXJuIG1fbm90aWZpY2F0aW9uUGVybWlzc2lvbnM7 Cit9CisKK3ZvaWQgV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI6OnNldE5vdGlmaWNhdGlvblBl cm1pc3Npb25zKEhhc2hNYXA8U3RyaW5nLCBSZWZQdHI8QVBJOjpPYmplY3Q+PiYmIHBlcm1pc3Np b25zTWFwKQoreworICAgIG1fbm90aWZpY2F0aW9uUGVybWlzc2lvbnMgPSBBUEk6OkRpY3Rpb25h cnk6OmNyZWF0ZShXVEZNb3ZlKHBlcm1pc3Npb25zTWFwKSk7Cit9CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5o IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0Tm90aWZpY2F0aW9uUHJv dmlkZXIuaAppbmRleCAyODk0YmEwMDU0M2EwMjQyN2Q5ZmY5MzgxMWNhMTYzZmQ5Njg0Mjg3Li40 OWM5YjlhYWZmNWI4ODFkZDJlYmI1MGQ5NjJkMmZmMDVkNGQxODc4IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlci5o CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdE5vdGlmaWNhdGlv blByb3ZpZGVyLmgKQEAgLTIyLDYgKzIyLDcgQEAKIAogI2luY2x1ZGUgIldlYktpdFByaXZhdGUu aCIKICNpbmNsdWRlICJXZWJLaXROb3RpZmljYXRpb24uaCIKKyNpbmNsdWRlICJXZWJLaXRXZWJD b250ZXh0LmgiCiAjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvUmVmLmg+ CiAjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4KQEAgLTM1LDE0ICszNiwxNyBAQCBuYW1lc3Bh Y2UgV2ViS2l0IHsKIGNsYXNzIFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyIDogcHVibGljIFJl ZkNvdW50ZWQ8V2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXI+IHsKIHB1YmxpYzoKICAgICB2aXJ0 dWFsIH5XZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcigpOwotICAgIHN0YXRpYyBSZWY8V2ViS2l0 Tm90aWZpY2F0aW9uUHJvdmlkZXI+IGNyZWF0ZShXZWJOb3RpZmljYXRpb25NYW5hZ2VyUHJveHkq KTsKKyAgICBzdGF0aWMgUmVmPFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyPiBjcmVhdGUoV2Vi Tm90aWZpY2F0aW9uTWFuYWdlclByb3h5KiwgV2ViS2l0V2ViQ29udGV4dCopOwogCiAgICAgdm9p ZCBzaG93KFdlYlBhZ2VQcm94eSosIGNvbnN0IFdlYk5vdGlmaWNhdGlvbiYpOwogICAgIHZvaWQg Y2FuY2VsKGNvbnN0IFdlYk5vdGlmaWNhdGlvbiYpOwogICAgIHZvaWQgY2xlYXJOb3RpZmljYXRp b25zKGNvbnN0IEFQSTo6QXJyYXkqKTsKIAorICAgIFJlZlB0cjxBUEk6OkRpY3Rpb25hcnk+IG5v dGlmaWNhdGlvblBlcm1pc3Npb25zKCk7CisgICAgdm9pZCBzZXROb3RpZmljYXRpb25QZXJtaXNz aW9ucyhIYXNoTWFwPFN0cmluZywgUmVmUHRyPEFQSTo6T2JqZWN0Pj4mJik7CisKIHByaXZhdGU6 Ci0gICAgV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIoV2ViTm90aWZpY2F0aW9uTWFuYWdlclBy b3h5Kik7CisgICAgV2ViS2l0Tm90aWZpY2F0aW9uUHJvdmlkZXIoV2ViTm90aWZpY2F0aW9uTWFu YWdlclByb3h5KiwgV2ViS2l0V2ViQ29udGV4dCopOwogCiAgICAgdm9pZCBjYW5jZWxOb3RpZmlj YXRpb25CeUlEKHVpbnQ2NF90KTsKICAgICBzdGF0aWMgdm9pZCBub3RpZmljYXRpb25DbG9zZUNh bGxiYWNrKFdlYktpdE5vdGlmaWNhdGlvbiosIFdlYktpdE5vdGlmaWNhdGlvblByb3ZpZGVyKik7 CkBAIC01MCw2ICs1NCw4IEBAIHByaXZhdGU6CiAKICAgICB2b2lkIHdpdGhkcmF3QW55UHJldmlv dXNOb3RpZmljYXRpb25NYXRjaGluZ1RhZyhjb25zdCBDU3RyaW5nJik7CiAKKyAgICBXZWJLaXRX ZWJDb250ZXh0KiBtX3dlYkNvbnRleHQ7CisgICAgUmVmUHRyPEFQSTo6RGljdGlvbmFyeT4gbV9u b3RpZmljYXRpb25QZXJtaXNzaW9uczsKICAgICBSZWZQdHI8V2ViTm90aWZpY2F0aW9uTWFuYWdl clByb3h5PiBtX25vdGlmaWNhdGlvbk1hbmFnZXI7CiAgICAgSGFzaE1hcDx1aW50NjRfdCwgR1Jl ZlB0cjxXZWJLaXROb3RpZmljYXRpb24+PiBtX25vdGlmaWNhdGlvbnM7CiB9OwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2VjdXJpdHlPcmlnaW4u Y3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0U2VjdXJpdHlPcmln aW4uY3BwCmluZGV4IDIzMzRjY2MzZjdkNjFiYzZhNzg4OTY0ZDYzYjA5NjU4Mzc5MmVkNjYuLjM5 MjI0Y2VjZDc0NTdiOWM1OGM3ZGE4NGQwNWRhMjBjZTlhMTJlMjYgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFNlY3VyaXR5T3JpZ2luLmNwcAorKysg Yi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRTZWN1cml0eU9yaWdpbi5j cHAKQEAgLTcwLDYgKzcwLDEyIEBAIFdlYktpdFNlY3VyaXR5T3JpZ2luKiB3ZWJraXRTZWN1cml0 eU9yaWdpbkNyZWF0ZShSZWY8V2ViQ29yZTo6U2VjdXJpdHlPcmlnaW4+JiYKICAgICByZXR1cm4g b3JpZ2luOwogfQogCitXZWJDb3JlOjpTZWN1cml0eU9yaWdpbiYgd2Via2l0U2VjdXJpdHlPcmln aW5HZXRTZWN1cml0eU9yaWdpbihXZWJLaXRTZWN1cml0eU9yaWdpbiogb3JpZ2luKQoreworICAg IEFTU0VSVChvcmlnaW4pOworICAgIHJldHVybiBvcmlnaW4tPnNlY3VyaXR5T3JpZ2luLmdldCgp OworfQorCiAvKioKICAqIHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fbmV3OgogICogQHByb3RvY29s OiBUaGUgcHJvdG9jb2wgZm9yIHRoZSBuZXcgb3JpZ2luCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRTZWN1cml0eU9yaWdpblByaXZhdGUuaCBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFNlY3VyaXR5T3JpZ2luUHJpdmF0 ZS5oCmluZGV4IDFkYjNlMzc3MTBkYzczZmM5M2FkZjVlZGU2MmVlYjRmYzhhYzliYjkuLmQ0ZTRh MDUxOGFlNzE5ZjI2ZTc0NjdlNzQ5NzQzNjU5MGM5NjcwYzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFNlY3VyaXR5T3JpZ2luUHJpdmF0ZS5oCisr KyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFNlY3VyaXR5T3JpZ2lu UHJpdmF0ZS5oCkBAIC0zMCwzICszMCw0IEBACiAjaW5jbHVkZSA8V2ViQ29yZS9TZWN1cml0eU9y aWdpbi5oPgogCiBXZWJLaXRTZWN1cml0eU9yaWdpbiogd2Via2l0U2VjdXJpdHlPcmlnaW5DcmVh dGUoUmVmPFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luPiYmKTsKK1dlYkNvcmU6OlNlY3VyaXR5T3Jp Z2luJiB3ZWJraXRTZWN1cml0eU9yaWdpbkdldFNlY3VyaXR5T3JpZ2luKFdlYktpdFNlY3VyaXR5 T3JpZ2luKik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRXZWJDb250ZXh0LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dl YktpdFdlYkNvbnRleHQuY3BwCmluZGV4IDczODM0Y2YzYWQyNWVjMWRmMjVjODMzMTI5MGY3ZWQz YjU5OTNkZDEuLjY5N2Y1OTEzYjJhNmQ5NmQxNjY1ODAzY2UxYzIwMmZkOGM1MjY4YmMgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQu Y3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRl eHQuY3BwCkBAIC00MSw2ICs0MSw3IEBACiAjaW5jbHVkZSAiV2ViS2l0UGx1Z2luUHJpdmF0ZS5o IgogI2luY2x1ZGUgIldlYktpdFByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJLaXRTZWN1cml0eU1h bmFnZXJQcml2YXRlLmgiCisjaW5jbHVkZSAiV2ViS2l0U2VjdXJpdHlPcmlnaW5Qcml2YXRlLmgi CiAjaW5jbHVkZSAiV2ViS2l0U2V0dGluZ3NQcml2YXRlLmgiCiAjaW5jbHVkZSAiV2ViS2l0VVJJ U2NoZW1lUmVxdWVzdFByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJLaXRVc2VyQ29udGVudE1hbmFn ZXJQcml2YXRlLmgiCkBAIC0xMTAsNiArMTExLDcgQEAgZW51bSB7CiBlbnVtIHsKICAgICBET1dO TE9BRF9TVEFSVEVELAogICAgIElOSVRJQUxJWkVfV0VCX0VYVEVOU0lPTlMsCisgICAgSU5JVElB TElaRV9OT1RJRklDQVRJT05fUEVSTUlTU0lPTlMsCiAKICAgICBMQVNUX1NJR05BTAogfTsKQEAg LTI4NSw3ICsyODcsNyBAQCBzdGF0aWMgdm9pZCB3ZWJraXRXZWJDb250ZXh0Q29uc3RydWN0ZWQo R09iamVjdCogb2JqZWN0KQogICAgIHByaXYtPmdlb2xvY2F0aW9uUHJvdmlkZXIgPSBXZWJLaXRH ZW9sb2NhdGlvblByb3ZpZGVyOjpjcmVhdGUocHJpdi0+cHJvY2Vzc1Bvb2wtPnN1cHBsZW1lbnQ8 V2ViR2VvbG9jYXRpb25NYW5hZ2VyUHJveHk+KCkpOwogI2VuZGlmCiAjaWYgRU5BQkxFKE5PVElG SUNBVElPTlMpCi0gICAgcHJpdi0+bm90aWZpY2F0aW9uUHJvdmlkZXIgPSBXZWJLaXROb3RpZmlj YXRpb25Qcm92aWRlcjo6Y3JlYXRlKHByaXYtPnByb2Nlc3NQb29sLT5zdXBwbGVtZW50PFdlYk5v dGlmaWNhdGlvbk1hbmFnZXJQcm94eT4oKSk7CisgICAgcHJpdi0+bm90aWZpY2F0aW9uUHJvdmlk ZXIgPSBXZWJLaXROb3RpZmljYXRpb25Qcm92aWRlcjo6Y3JlYXRlKHByaXYtPnByb2Nlc3NQb29s LT5zdXBwbGVtZW50PFdlYk5vdGlmaWNhdGlvbk1hbmFnZXJQcm94eT4oKSwgd2ViQ29udGV4dCk7 CiAjZW5kaWYKIH0KIApAQCAtMzg2LDYgKzM4OCwyNSBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfd2Vi X2NvbnRleHRfY2xhc3NfaW5pdChXZWJLaXRXZWJDb250ZXh0Q2xhc3MqIHdlYkNvbnRleHRDbGFz cwogICAgICAgICAgICAgbnVsbHB0ciwgbnVsbHB0ciwKICAgICAgICAgICAgIGdfY2Nsb3N1cmVf bWFyc2hhbF9WT0lEX19WT0lELAogICAgICAgICAgICAgR19UWVBFX05PTkUsIDApOworCisgICAg LyoqCisgICAgICogV2ViS2l0V2ViQ29udGV4dDo6aW5pdGlhbGl6ZS1ub3RpZmljYXRpb24tcGVy bWlzc2lvbnM6CisgICAgICogQGNvbnRleHQ6IHRoZSAjV2ViS2l0V2ViQ29udGV4dAorICAgICAq CisgICAgICogVGhpcyBzaWduYWwgaXMgZW1pdHRlZCB3aGVuIGEgbmV3IHdlYiBwcm9jZXNzIGlz IGFib3V0IHRvIGJlCisgICAgICogbGF1bmNoZWQuIEl0IHNpZ25hbHMgdGhlIG1vc3QgYXBwcm9w cmlhdGUgbW9tZW50IHRvIHVzZQorICAgICAqIHdlYmtpdF93ZWJfY29udGV4dF9pbml0aWFsaXpl X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9ucygpLgorICAgICAqCisgICAgICogU2luY2U6IDIuMTYK KyAgICAgKi8KKyAgICBzaWduYWxzW0lOSVRJQUxJWkVfTk9USUZJQ0FUSU9OX1BFUk1JU1NJT05T XSA9CisgICAgICAgIGdfc2lnbmFsX25ldygiaW5pdGlhbGl6ZS1ub3RpZmljYXRpb24tcGVybWlz c2lvbnMiLAorICAgICAgICAgICAgR19UWVBFX0ZST01fQ0xBU1MoZ09iamVjdENsYXNzKSwKKyAg ICAgICAgICAgIEdfU0lHTkFMX1JVTl9MQVNULAorICAgICAgICAgICAgR19TVFJVQ1RfT0ZGU0VU KFdlYktpdFdlYkNvbnRleHRDbGFzcywgaW5pdGlhbGl6ZV9ub3RpZmljYXRpb25fcGVybWlzc2lv bnMpLAorICAgICAgICAgICAgbnVsbHB0ciwgbnVsbHB0ciwKKyAgICAgICAgICAgIGdfY2Nsb3N1 cmVfbWFyc2hhbF9WT0lEX19WT0lELAorICAgICAgICAgICAgR19UWVBFX05PTkUsIDApOwogfQog CiBzdGF0aWMgZ3BvaW50ZXIgY3JlYXRlRGVmYXVsdFdlYkNvbnRleHQoZ3BvaW50ZXIpCkBAIC0x MjE4LDYgKzEyMzksNjAgQEAgZ3VpbnQgd2Via2l0X3dlYl9jb250ZXh0X2dldF93ZWJfcHJvY2Vz c19jb3VudF9saW1pdChXZWJLaXRXZWJDb250ZXh0KiBjb250ZXh0KQogICAgIHJldHVybiBjb250 ZXh0LT5wcml2LT5wcm9jZXNzQ291bnRMaW1pdDsKIH0KIAorc3RhdGljIHZvaWQgYWRkT3JpZ2lu VG9NYXAoV2ViS2l0U2VjdXJpdHlPcmlnaW4qIG9yaWdpbiwgSGFzaE1hcDxTdHJpbmcsIFJlZlB0 cjxBUEk6Ok9iamVjdD4+KiBtYXAsIGJvb2wgYWxsb3dlZCkKK3sKKyAgICBTdHJpbmcgc3RyaW5n ID0gd2Via2l0U2VjdXJpdHlPcmlnaW5HZXRTZWN1cml0eU9yaWdpbihvcmlnaW4pLnRvU3RyaW5n KCk7CisgICAgaWYgKHN0cmluZyAhPSAibnVsbCIpCisgICAgICAgIG1hcC0+c2V0KHN0cmluZywg QVBJOjpCb29sZWFuOjpjcmVhdGUoYWxsb3dlZCkpOworfQorCitzdGF0aWMgdm9pZCBhZGRBbGxv d2VkT3JpZ2luVG9NYXAoV2ViS2l0U2VjdXJpdHlPcmlnaW4qIG9yaWdpbiwgSGFzaE1hcDxTdHJp bmcsIFJlZlB0cjxBUEk6Ok9iamVjdD4+KiBtYXApCit7CisgICAgYWRkT3JpZ2luVG9NYXAob3Jp Z2luLCBtYXAsIHRydWUpOworfQorCitzdGF0aWMgdm9pZCBhZGREaXNhbGxvd2VkT3JpZ2luVG9N YXAoV2ViS2l0U2VjdXJpdHlPcmlnaW4qIG9yaWdpbiwgSGFzaE1hcDxTdHJpbmcsIFJlZlB0cjxB UEk6Ok9iamVjdD4+KiBtYXApCit7CisgICAgYWRkT3JpZ2luVG9NYXAob3JpZ2luLCBtYXAsIGZh bHNlKTsKK30KKworLyoqCisgKiB3ZWJraXRfd2ViX2NvbnRleHRfaW5pdGlhbGl6ZV9ub3RpZmlj YXRpb25fcGVybWlzc2lvbnM6CisgKiBAY29udGV4dDogdGhlICNXZWJLaXRXZWJDb250ZXh0Cisg KiBAYWxsb3dlZF9vcmlnaW5zOiAoZWxlbWVudC10eXBlIFdlYktpdFNlY3VyaXR5T3JpZ2luKTog YSAjR0xpc3Qgb2Ygc2VjdXJpdHkgb3JpZ2lucworICogQGRpc2FsbG93ZWRfb3JpZ2luczogKGVs ZW1lbnQtdHlwZSBXZWJLaXRTZWN1cml0eU9yaWdpbik6IGEgI0dMaXN0IG9mIHNlY3VyaXR5IG9y aWdpbnMKKyAqCisgKiBTZXRzIGluaXRpYWwgZGVza3RvcCBub3RpZmljYXRpb24gcGVybWlzc2lv bnMgZm9yIHRoZSBAY29udGV4dC4KKyAqIEBhbGxvd2VkX29yaWdpbnMgYW5kIEBkaXNhbGxvd2Vk X29yaWdpbnMgbXVzdCBlYWNoIGJlICNHTGlzdCBvZgorICogI1dlYktpdFNlY3VyaXR5T3JpZ2lu IG9iamVjdHMgcmVwcmVzZW50aW5nIG9yaWdpbnMgdGhhdCB3aWxsLAorICogcmVzcGVjdGl2ZWx5 LCBlaXRoZXIgYWx3YXlzIG9yIG5ldmVyIGhhdmUgcGVybWlzc2lvbiB0byBzaG93IGRlc2t0b3AK KyAqIG5vdGlmaWNhdGlvbnMuIE5vICNXZWJLaXROb3RpZmljYXRpb25QZXJtaXNzaW9uUmVxdWVz dCB3aWxsIGV2ZXIgYmUKKyAqIGdlbmVyYXRlZCBmb3IgYW55IG9mIHRoZSBzZWN1cml0eSBvcmln aW5zIHJlcHJlc2VudGVkIGluCisgKiBAYWxsb3dlZF9vcmlnaW5zIG9yIEBkaXNhbGxvd2VkX29y aWdpbnMuIFRoaXMgZnVuY3Rpb24gaXMgbmVjZXNzYXJ5CisgKiBiZWNhdXNlIHNvbWUgd2VicGFn ZXMgcHJvYWN0aXZlbHkgY2hlY2sgd2hldGhlciB0aGV5IGhhdmUgcGVybWlzc2lvbgorICogdG8g ZGlzcGxheSBub3RpZmljYXRpb25zIHdpdGhvdXQgZXZlciBjcmVhdGluZyBhIHBlcm1pc3Npb24g cmVxdWVzdC4KKyAqCisgKiBUaGlzIGZ1bmN0aW9uIG9ubHkgYWZmZWN0cyB3ZWIgcHJvY2Vzc2Vz IHRoYXQgaGF2ZSBub3QgYWxyZWFkeSBiZWVuCisgKiBjcmVhdGVkLiBUaGUgYmVzdCB0aW1lIHRv IGNhbGwgaXQgaXMgd2hlbiBoYW5kbGluZworICogI1dlYktpdFdlYkNvbnRleHQ6OmluaXRpYWxp emUtbm90aWZpY2F0aW9uLXBlcm1pc3Npb25zIHNvIGFzIHRvCisgKiBlbnN1cmUgdGhhdCBuZXcg d2ViIHByb2Nlc3NlcyByZWNlaXZlIHRoZSBtb3N0IHJlY2VudCBzZXQgb2YKKyAqIHBlcm1pc3Np b25zLgorICoKKyAqIFNpbmNlOiAyLjE2CisgKi8KK3ZvaWQgd2Via2l0X3dlYl9jb250ZXh0X2lu aXRpYWxpemVfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25zKFdlYktpdFdlYkNvbnRleHQqIGNvbnRl eHQsIEdMaXN0KiBhbGxvd2VkX29yaWdpbnMsIEdMaXN0KiBkaXNhbGxvd2VkX29yaWdpbnMpCit7 CisgICAgSGFzaE1hcDxTdHJpbmcsIFJlZlB0cjxBUEk6Ok9iamVjdD4+IG1hcDsKKyAgICBnX2xp c3RfZm9yZWFjaChhbGxvd2VkX29yaWdpbnMsIChHRnVuYylhZGRBbGxvd2VkT3JpZ2luVG9NYXAs ICZtYXApOworICAgIGdfbGlzdF9mb3JlYWNoKGRpc2FsbG93ZWRfb3JpZ2lucywgKEdGdW5jKWFk ZERpc2FsbG93ZWRPcmlnaW5Ub01hcCwgJm1hcCk7CisgICAgY29udGV4dC0+cHJpdi0+bm90aWZp Y2F0aW9uUHJvdmlkZXItPnNldE5vdGlmaWNhdGlvblBlcm1pc3Npb25zKFdURk1vdmUobWFwKSk7 Cit9CisKK3ZvaWQgd2Via2l0V2ViQ29udGV4dEluaXRpYWxpemVOb3RpZmljYXRpb25QZXJtaXNz aW9ucyhXZWJLaXRXZWJDb250ZXh0KiBjb250ZXh0KQoreworICAgIGdfc2lnbmFsX2VtaXQoY29u dGV4dCwgc2lnbmFsc1tJTklUSUFMSVpFX05PVElGSUNBVElPTl9QRVJNSVNTSU9OU10sIDApOwor fQorCiBXZWJLaXREb3dubG9hZCogd2Via2l0V2ViQ29udGV4dEdldE9yQ3JlYXRlRG93bmxvYWQo RG93bmxvYWRQcm94eSogZG93bmxvYWRQcm94eSkKIHsKICAgICBHUmVmUHRyPFdlYktpdERvd25s b2FkPiBkb3dubG9hZCA9IGRvd25sb2Fkc01hcCgpLmdldChkb3dubG9hZFByb3h5KTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQu aCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQuaApp bmRleCBjZDU1NDg2ZjRjMjMzOTVmMGU3N2JiODYyMzM3MGU3YzU3MGRlMWI3Li5mYzM3OTNhNjk0 NTg4ZDk5NWVlOTA3OTljMDA3NTMyODE3MGRmNmU4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmgKKysrIGIvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dC5oCkBAIC0xMjgsMTYgKzEyOCwx NiBAQCBzdHJ1Y3QgX1dlYktpdFdlYkNvbnRleHQgewogc3RydWN0IF9XZWJLaXRXZWJDb250ZXh0 Q2xhc3MgewogICAgIEdPYmplY3RDbGFzcyBwYXJlbnQ7CiAKLSAgICB2b2lkICgqIGRvd25sb2Fk X3N0YXJ0ZWQpICAgICAgICAgIChXZWJLaXRXZWJDb250ZXh0ICpjb250ZXh0LAotICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdlYktpdERvd25sb2FkICAgKmRvd25sb2Fk KTsKLSAgICB2b2lkICgqIGluaXRpYWxpemVfd2ViX2V4dGVuc2lvbnMpIChXZWJLaXRXZWJDb250 ZXh0ICpjb250ZXh0KTsKKyAgICB2b2lkICgqIGRvd25sb2FkX3N0YXJ0ZWQpICAgICAgICAgICAg ICAgICAgICAoV2ViS2l0V2ViQ29udGV4dCAqY29udGV4dCwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2ViS2l0RG93bmxvYWQgICAqZG93bmxvYWQp OworICAgIHZvaWQgKCogaW5pdGlhbGl6ZV93ZWJfZXh0ZW5zaW9ucykgICAgICAgICAgIChXZWJL aXRXZWJDb250ZXh0ICpjb250ZXh0KTsKKyAgICB2b2lkICgqIGluaXRpYWxpemVfbm90aWZpY2F0 aW9uX3Blcm1pc3Npb25zKSAoV2ViS2l0V2ViQ29udGV4dCAqY29udGV4dCk7CiAKICAgICB2b2lk ICgqX3dlYmtpdF9yZXNlcnZlZDApICh2b2lkKTsKICAgICB2b2lkICgqX3dlYmtpdF9yZXNlcnZl ZDEpICh2b2lkKTsKICAgICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDIpICh2b2lkKTsKICAgICB2 b2lkICgqX3dlYmtpdF9yZXNlcnZlZDMpICh2b2lkKTsKICAgICB2b2lkICgqX3dlYmtpdF9yZXNl cnZlZDQpICh2b2lkKTsKLSAgICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDUpICh2b2lkKTsKIH07 CiAKIFdFQktJVF9BUEkgR1R5cGUKQEAgLTI2NCw2ICsyNjQsMTIgQEAgd2Via2l0X3dlYl9jb250 ZXh0X3NldF9wcm9jZXNzX21vZGVsICAgICAgICAgICAgICAgIChXZWJLaXRXZWJDb250ZXh0CiBX RUJLSVRfQVBJIFdlYktpdFByb2Nlc3NNb2RlbAogd2Via2l0X3dlYl9jb250ZXh0X2dldF9wcm9j ZXNzX21vZGVsICAgICAgICAgICAgICAgIChXZWJLaXRXZWJDb250ZXh0ICAgICAgICAgICAgICAq Y29udGV4dCk7CiAKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X3dlYl9jb250ZXh0X2luaXRpYWxp emVfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25zCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgKFdlYktpdFdlYkNvbnRleHQgICAgICAgICAgICAgICpj b250ZXh0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBHTGlzdCAgICAgICAgICAgICAgICAgICAgICAgICAqYWxsb3dlZF9vcmlnaW5zLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHTGlzdCAg ICAgICAgICAgICAgICAgICAgICAgICAqZGlzYWxsb3dlZF9vcmlnaW5zKTsKKwogR19FTkRfREVD TFMKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0 ay9XZWJLaXRXZWJDb250ZXh0UHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0V2ViQ29udGV4dFByaXZhdGUuaAppbmRleCA2M2ViMjFhNzcyMzIwMmRjNmRh Y2UyYjZlM2FkYTdjMjY3MDFkMWI0Li5iOTRlNTE4NmM5M2JkYzgxNTFjODJlMGUzMzU2MjFjYjIw YmU0YmM2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRXZWJDb250ZXh0UHJpdmF0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkv Z3RrL1dlYktpdFdlYkNvbnRleHRQcml2YXRlLmgKQEAgLTQ4LDUgKzQ4LDYgQEAgdm9pZCB3ZWJr aXRXZWJDb250ZXh0Q3JlYXRlUGFnZUZvcldlYlZpZXcoV2ViS2l0V2ViQ29udGV4dCosIFdlYktp dFdlYlZpZXcqLCBXZWIKIHZvaWQgd2Via2l0V2ViQ29udGV4dFdlYlZpZXdEZXN0cm95ZWQoV2Vi S2l0V2ViQ29udGV4dCosIFdlYktpdFdlYlZpZXcqKTsKIFdlYktpdFdlYlZpZXcqIHdlYmtpdFdl YkNvbnRleHRHZXRXZWJWaWV3Rm9yUGFnZShXZWJLaXRXZWJDb250ZXh0KiwgV2ViS2l0OjpXZWJQ YWdlUHJveHkqKTsKIEdWYXJpYW50KiB3ZWJraXRXZWJDb250ZXh0SW5pdGlhbGl6ZVdlYkV4dGVu c2lvbnMoV2ViS2l0V2ViQ29udGV4dCopOwordm9pZCB3ZWJraXRXZWJDb250ZXh0SW5pdGlhbGl6 ZU5vdGlmaWNhdGlvblBlcm1pc3Npb25zKFdlYktpdFdlYkNvbnRleHQqKTsKIAogI2VuZGlmIC8v IFdlYktpdFdlYkNvbnRleHRQcml2YXRlX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0IGIvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLTQuMC1zZWN0aW9ucy50 eHQKaW5kZXggZWUzYWZiYmQxN2U5ODYxNzUwYWJkZTNkMmYwMmVlYzNiYmQ0MmViMy4uMzVhMDUz ZWZmYzA2NTk0MDk0M2M2MDlhMmVmODY1NjA0YTg3NDg3NSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLTQuMC1zZWN0aW9ucy50eHQK KysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLTQu MC1zZWN0aW9ucy50eHQKQEAgLTU5LDYgKzU5LDcgQEAgd2Via2l0X3dlYl9jb250ZXh0X3NldF9k aXNrX2NhY2hlX2RpcmVjdG9yeQogd2Via2l0X3dlYl9jb250ZXh0X2FsbG93X3Rsc19jZXJ0aWZp Y2F0ZV9mb3JfaG9zdAogd2Via2l0X3dlYl9jb250ZXh0X2dldF9wcm9jZXNzX21vZGVsCiB3ZWJr aXRfd2ViX2NvbnRleHRfc2V0X3Byb2Nlc3NfbW9kZWwKK3dlYmtpdF93ZWJfY29udGV4dF9pbml0 aWFsaXplX25vdGlmaWNhdGlvbl9wZXJtaXNzaW9ucwogCiA8U1VCU0VDVElPTiBVUkkgU2NoZW1l PgogV2ViS2l0VVJJU2NoZW1lUmVxdWVzdENhbGxiYWNrCmRpZmYgLS1naXQgYS9Ub29scy9DaGFu Z2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZWEyYjhiN2E2MGU3MTc0OGExYTFmNDhkZDRm ZjRmNzQ5Y2Q0NTIwNS4uYWFiODg3ODU4MjYwNDVlM2Q2Y2QwYTMyZGJkNzZkNGY0OGYyYTM1MyAx MDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSw1 ICsxLDI5IEBACiAyMDE3LTAxLTAzICBNaWNoYWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdh bGlhLmNvbT4KIAorICAgICAgICBbR1RLXSBObyB3YXkgZm9yIGFwcGxpY2F0aW9ucyB0byBzZXQg bm90aWZpY2F0aW9uIHBlcm1pc3Npb25zIHdpdGhvdXQgd2FpdGluZyBmb3IgcGVybWlzc2lvbiBy ZXF1ZXN0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x NjMzNjYKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAq IFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9UZXN0V2ViS2l0V2ViVmlldy5jcHA6Cisg ICAgICAgICh0ZXN0V2ViVmlld05vdGlmaWNhdGlvbik6CisgICAgICAgIChzZXRJbml0aWFsTm90 aWZpY2F0aW9uUGVybWlzc2lvbnNBbGxvd2VkQ2FsbGJhY2spOgorICAgICAgICAoc2V0SW5pdGlh bE5vdGlmaWNhdGlvblBlcm1pc3Npb25zRGlzYWxsb3dlZENhbGxiYWNrKToKKyAgICAgICAgKHRl c3RXZWJWaWV3Tm90aWZpY2F0aW9uSW5pdGlhbFBlcm1pc3Npb25BbGxvd2VkKToKKyAgICAgICAg KHRlc3RXZWJWaWV3Tm90aWZpY2F0aW9uSW5pdGlhbFBlcm1pc3Npb25EaXNhbGxvd2VkKToKKyAg ICAgICAgKGJlZm9yZUFsbCk6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0 ay9UZXN0TWFpbi5oOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2Vi S2l0VGVzdFNlcnZlci5jcHA6CisgICAgICAgIChXZWJLaXRUZXN0U2VydmVyOjpzZWN1cml0eU9y aWdpbik6CisgICAgICAgIChXZWJLaXRUZXN0U2VydmVyOjpnZXRVUklGb3JQYXRoKToKKyAgICAg ICAgKiBUZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYktpdFRlc3RTZXJ2ZXIuaDoKKyAg ICAgICAgKiBUZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYlZpZXdUZXN0LmNwcDoKKyAg ICAgICAgKFdlYlZpZXdUZXN0OjpXZWJWaWV3VGVzdCk6CisgICAgICAgIChXZWJWaWV3VGVzdDo6 aW5pdGlhbGl6ZVdlYlZpZXcpOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJH dGsvV2ViVmlld1Rlc3QuaDoKKworMjAxNy0wMS0wMyAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0 YW56YXJvQGlnYWxpYS5jb20+CisKICAgICAgICAgW0dUS10gRXhwb3NlIFdlYktpdFNlY3VyaXR5 T3JpZ2luIEFQSQogICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTY2NjMyCiAKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0 Mkd0ay9UZXN0V2ViS2l0V2ViVmlldy5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dl YktpdDJHdGsvVGVzdFdlYktpdFdlYlZpZXcuY3BwCmluZGV4IDI5MmY1NTYxNjAzMDhhMGI5Yzk1 M2UxYmEzMjE0YjUwZDUzNWVlZjkuLjQyOWM1MjAwNzcyMGI1NGI5ZGJmYTU2N2E3ZGVlY2VhOWVk NTY0Y2EgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9U ZXN0V2ViS2l0V2ViVmlldy5jcHAKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQyR3RrL1Rlc3RXZWJLaXRXZWJWaWV3LmNwcApAQCAtNjMyLDcgKzYzMiwxNyBAQCBzdGF0aWMg dm9pZCB0ZXN0V2ViVmlld1NuYXBzaG90KFNuYXBzaG90V2ViVmlld1Rlc3QqIHRlc3QsIGdjb25z dHBvaW50ZXIpCiAKIGNsYXNzIE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0OiBwdWJsaWMgV2ViVmll d1Rlc3QgewogcHVibGljOgotICAgIE1BS0VfR0xJQl9URVNUX0ZJWFRVUkUoTm90aWZpY2F0aW9u V2ViVmlld1Rlc3QpOworICAgIE1BS0VfR0xJQl9URVNUX0ZJWFRVUkVfV0lUSF9TRVRVUF9URUFS RE9XTihOb3RpZmljYXRpb25XZWJWaWV3VGVzdCwgc2V0dXAsIHRlYXJkb3duKTsKKworICAgIHN0 YXRpYyB2b2lkIHNldHVwKCkKKyAgICB7CisgICAgICAgIFdlYlZpZXdUZXN0OjpzaG91bGRJbml0 aWFsaXplV2ViVmlld0luQ29uc3RydWN0b3IgPSBmYWxzZTsKKyAgICB9CisKKyAgICBzdGF0aWMg dm9pZCB0ZWFyZG93bigpCisgICAgeworICAgICAgICBXZWJWaWV3VGVzdDo6c2hvdWxkSW5pdGlh bGl6ZVdlYlZpZXdJbkNvbnN0cnVjdG9yID0gdHJ1ZTsKKyAgICB9CiAKICAgICBlbnVtIE5vdGlm aWNhdGlvbkV2ZW50IHsKICAgICAgICAgTm9uZSwKQEAgLTY0Nyw2ICs2NTcsNyBAQCBwdWJsaWM6 CiAgICAgc3RhdGljIGdib29sZWFuIHBlcm1pc3Npb25SZXF1ZXN0Q2FsbGJhY2soV2ViS2l0V2Vi VmlldyosIFdlYktpdFBlcm1pc3Npb25SZXF1ZXN0ICpyZXF1ZXN0LCBOb3RpZmljYXRpb25XZWJW aWV3VGVzdCogdGVzdCkKICAgICB7CiAgICAgICAgIGdfYXNzZXJ0KFdFQktJVF9JU19OT1RJRklD QVRJT05fUEVSTUlTU0lPTl9SRVFVRVNUKHJlcXVlc3QpKTsKKyAgICAgICAgZ19hc3NlcnQodGVz dC0+bV9pc0V4cGVjdGluZ1Blcm1pc3Npb25SZXF1ZXN0KTsKICAgICAgICAgdGVzdC0+YXNzZXJ0 T2JqZWN0SXNEZWxldGVkV2hlblRlc3RGaW5pc2hlcyhHX09CSkVDVChyZXF1ZXN0KSk7CiAKICAg ICAgICAgdGVzdC0+bV9ldmVudCA9IFBlcm1pc3Npb247CkBAIC02OTksMTAgKzcxMCw5IEBAIHB1 YmxpYzoKICAgICAgICAgZ19tYWluX2xvb3BfcXVpdCh0ZXN0LT5tX21haW5Mb29wKTsKICAgICB9 CiAKLSAgICBOb3RpZmljYXRpb25XZWJWaWV3VGVzdCgpCi0gICAgICAgIDogbV9ub3RpZmljYXRp b24obnVsbHB0cikKLSAgICAgICAgLCBtX2V2ZW50KE5vbmUpCisgICAgdm9pZCBpbml0aWFsaXpl KCkKICAgICB7CisgICAgICAgIGluaXRpYWxpemVXZWJWaWV3KCk7CiAgICAgICAgIGdfc2lnbmFs X2Nvbm5lY3QobV93ZWJWaWV3LCAicGVybWlzc2lvbi1yZXF1ZXN0IiwgR19DQUxMQkFDSyhwZXJt aXNzaW9uUmVxdWVzdENhbGxiYWNrKSwgdGhpcyk7CiAgICAgICAgIGdfc2lnbmFsX2Nvbm5lY3Qo bV93ZWJWaWV3LCAic2hvdy1ub3RpZmljYXRpb24iLCBHX0NBTExCQUNLKHNob3dOb3RpZmljYXRp b25DYWxsYmFjayksIHRoaXMpOwogICAgICAgICB3ZWJraXRfdXNlcl9jb250ZW50X21hbmFnZXJf cmVnaXN0ZXJfc2NyaXB0X21lc3NhZ2VfaGFuZGxlcihtX3VzZXJDb250ZW50TWFuYWdlci5nZXQo KSwgIm5vdGlmaWNhdGlvbnMiKTsKQEAgLTcxNiw5ICs3MjYsMTggQEAgcHVibGljOgogICAgICAg ICB3ZWJraXRfdXNlcl9jb250ZW50X21hbmFnZXJfdW5yZWdpc3Rlcl9zY3JpcHRfbWVzc2FnZV9o YW5kbGVyKG1fdXNlckNvbnRlbnRNYW5hZ2VyLmdldCgpLCAibm90aWZpY2F0aW9ucyIpOwogICAg IH0KIAorICAgIGJvb2wgaGFzUGVybWlzc2lvbigpCisgICAgeworICAgICAgICBhdXRvKiByZXN1 bHQgPSBydW5KYXZhU2NyaXB0QW5kV2FpdFVudGlsRmluaXNoZWQoIk5vdGlmaWNhdGlvbi5wZXJt aXNzaW9uOyIsIG51bGxwdHIpOworICAgICAgICBnX2Fzc2VydChyZXN1bHQpOworICAgICAgICBH VW5pcXVlUHRyPGNoYXI+IHZhbHVlKGphdmFzY3JpcHRSZXN1bHRUb0NTdHJpbmcocmVzdWx0KSk7 CisgICAgICAgIHJldHVybiAhZ19zdHJjbXAwKHZhbHVlLmdldCgpLCAiZ3JhbnRlZCIpOworICAg IH0KKwogICAgdm9pZCByZXF1ZXN0UGVybWlzc2lvbkFuZFdhaXRVbnRpbEdpdmVuKCkKICAgICB7 CiAgICAgICAgIG1fZXZlbnQgPSBOb25lOworICAgICAgICBtX2lzRXhwZWN0aW5nUGVybWlzc2lv blJlcXVlc3QgPSB0cnVlOwogICAgICAgICB3ZWJraXRfd2ViX3ZpZXdfcnVuX2phdmFzY3JpcHQo bV93ZWJWaWV3LCAiTm90aWZpY2F0aW9uLnJlcXVlc3RQZXJtaXNzaW9uKCk7IiwgbnVsbHB0ciwg bnVsbHB0ciwgbnVsbHB0cik7CiAgICAgICAgIGdfbWFpbl9sb29wX3J1bihtX21haW5Mb29wKTsK ICAgICB9CkBAIC03NjksMTggKzc4OCwyNCBAQCBwdWJsaWM6CiAgICAgICAgIGdfbWFpbl9sb29w X3J1bihtX21haW5Mb29wKTsKICAgICB9CiAKLSAgICBOb3RpZmljYXRpb25FdmVudCBtX2V2ZW50 OwotICAgIFdlYktpdE5vdGlmaWNhdGlvbiogbV9ub3RpZmljYXRpb247CisgICAgTm90aWZpY2F0 aW9uRXZlbnQgbV9ldmVudCB7IE5vbmUgfTsKKyAgICBXZWJLaXROb3RpZmljYXRpb24qIG1fbm90 aWZpY2F0aW9uIHsgbnVsbHB0ciB9OworICAgIGJvb2wgbV9pc0V4cGVjdGluZ1Blcm1pc3Npb25S ZXF1ZXN0IHsgZmFsc2UgfTsKKyAgICBib29sIG1faGFzUGVybWlzc2lvbiB7IGZhbHNlIH07CiB9 OwogCiBzdGF0aWMgdm9pZCB0ZXN0V2ViVmlld05vdGlmaWNhdGlvbihOb3RpZmljYXRpb25XZWJW aWV3VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRlcikKIHsKKyAgICB0ZXN0LT5pbml0aWFsaXplKCk7 CisKICAgICAvLyBOb3RpZmljYXRpb25zIGRvbid0IHdvcmsgd2l0aCBsb2NhbCBvciBzcGVjaWFs IHNjaGVtZXMuCiAgICAgdGVzdC0+bG9hZFVSSShnU2VydmVyLT5nZXRVUklGb3JQYXRoKCIvIiku ZGF0YSgpKTsKICAgICB0ZXN0LT53YWl0VW50aWxMb2FkRmluaXNoZWQoKTsKKyAgICBnX2Fzc2Vy dCghdGVzdC0+aGFzUGVybWlzc2lvbigpKTsKIAogICAgIHRlc3QtPnJlcXVlc3RQZXJtaXNzaW9u QW5kV2FpdFVudGlsR2l2ZW4oKTsKICAgICBnX2Fzc2VydCh0ZXN0LT5tX2V2ZW50ID09IE5vdGlm aWNhdGlvbldlYlZpZXdUZXN0OjpQZXJtaXNzaW9uKTsKKyAgICBnX2Fzc2VydCh0ZXN0LT5oYXNQ ZXJtaXNzaW9uKCkpOwogCiAgICAgc3RhdGljIGNvbnN0IGNoYXIqIHRpdGxlID0gIlRoaXMgaXMg YSBub3RpZmljYXRpb24iOwogICAgIHN0YXRpYyBjb25zdCBjaGFyKiBib2R5ID0gIlRoaXMgaXMg dGhlIGJvZHkuIjsKQEAgLTgxOCw2ICs4NDMsNDcgQEAgc3RhdGljIHZvaWQgdGVzdFdlYlZpZXdO b3RpZmljYXRpb24oTm90aWZpY2F0aW9uV2ViVmlld1Rlc3QqIHRlc3QsIGdjb25zdHBvaW50ZXIK ICAgICBnX2Fzc2VydCh0ZXN0LT5tX2V2ZW50ID09IE5vdGlmaWNhdGlvbldlYlZpZXdUZXN0OjpD bG9zZWQpOwogfQogCitzdGF0aWMgdm9pZCBzZXRJbml0aWFsTm90aWZpY2F0aW9uUGVybWlzc2lv bnNBbGxvd2VkQ2FsbGJhY2soV2ViS2l0V2ViQ29udGV4dCogY29udGV4dCwgTm90aWZpY2F0aW9u V2ViVmlld1Rlc3QqIHRlc3QpCit7CisgICAgR0xpc3QqIGFsbG93ZWRPcmlnaW5zID0gbnVsbHB0 cjsKKyAgICBhbGxvd2VkT3JpZ2lucyA9IGdfbGlzdF9hcHBlbmQoYWxsb3dlZE9yaWdpbnMsIHdl YmtpdF9zZWN1cml0eV9vcmlnaW5fbmV3X2Zvcl91cmkoZ1NlcnZlci0+c2VjdXJpdHlPcmlnaW4o KS5kYXRhKCkpKTsKKyAgICB3ZWJraXRfd2ViX2NvbnRleHRfaW5pdGlhbGl6ZV9ub3RpZmljYXRp b25fcGVybWlzc2lvbnModGVzdC0+bV93ZWJDb250ZXh0LmdldCgpLCBhbGxvd2VkT3JpZ2lucywg bnVsbHB0cik7CisgICAgZ19saXN0X2ZyZWVfZnVsbChhbGxvd2VkT3JpZ2lucywgKEdEZXN0cm95 Tm90aWZ5KXdlYmtpdF9zZWN1cml0eV9vcmlnaW5fdW5yZWYpOworfQorCitzdGF0aWMgdm9pZCBz ZXRJbml0aWFsTm90aWZpY2F0aW9uUGVybWlzc2lvbnNEaXNhbGxvd2VkQ2FsbGJhY2soV2ViS2l0 V2ViQ29udGV4dCogY29udGV4dCwgTm90aWZpY2F0aW9uV2ViVmlld1Rlc3QqIHRlc3QpCit7Cisg ICAgR0xpc3QqIGRpc2FsbG93ZWRPcmlnaW5zID0gbnVsbHB0cjsKKyAgICBkaXNhbGxvd2VkT3Jp Z2lucyA9IGdfbGlzdF9hcHBlbmQoZGlzYWxsb3dlZE9yaWdpbnMsIHdlYmtpdF9zZWN1cml0eV9v cmlnaW5fbmV3X2Zvcl91cmkoZ1NlcnZlci0+c2VjdXJpdHlPcmlnaW4oKS5kYXRhKCkpKTsKKyAg ICB3ZWJraXRfd2ViX2NvbnRleHRfaW5pdGlhbGl6ZV9ub3RpZmljYXRpb25fcGVybWlzc2lvbnMo dGVzdC0+bV93ZWJDb250ZXh0LmdldCgpLCBudWxscHRyLCBkaXNhbGxvd2VkT3JpZ2lucyk7Cisg ICAgZ19saXN0X2ZyZWVfZnVsbChkaXNhbGxvd2VkT3JpZ2lucywgKEdEZXN0cm95Tm90aWZ5KXdl YmtpdF9zZWN1cml0eV9vcmlnaW5fdW5yZWYpOworfQorCitzdGF0aWMgdm9pZCB0ZXN0V2ViVmll d05vdGlmaWNhdGlvbkluaXRpYWxQZXJtaXNzaW9uQWxsb3dlZChOb3RpZmljYXRpb25XZWJWaWV3 VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRlcikKK3sKKyAgICBnX3NpZ25hbF9jb25uZWN0KHRlc3Qt Pm1fd2ViQ29udGV4dC5nZXQoKSwgImluaXRpYWxpemUtbm90aWZpY2F0aW9uLXBlcm1pc3Npb25z IiwgR19DQUxMQkFDSyhzZXRJbml0aWFsTm90aWZpY2F0aW9uUGVybWlzc2lvbnNBbGxvd2VkQ2Fs bGJhY2spLCB0ZXN0KTsKKyAgICB0ZXN0LT5pbml0aWFsaXplKCk7CisKKyAgICB0ZXN0LT5sb2Fk VVJJKGdTZXJ2ZXItPmdldFVSSUZvclBhdGgoIi8iKS5kYXRhKCkpOworICAgIHRlc3QtPndhaXRV bnRpbExvYWRGaW5pc2hlZCgpOworICAgIGdfYXNzZXJ0KHRlc3QtPmhhc1Blcm1pc3Npb24oKSk7 CisKKyAgICBzdGF0aWMgY29uc3QgY2hhciogdGl0bGUgPSAiVGhpcyBpcyBhIG5vdGlmaWNhdGlv biI7CisgICAgc3RhdGljIGNvbnN0IGNoYXIqIGJvZHkgPSAiVGhpcyBpcyB0aGUgYm9keS4iOwor ICAgIHRlc3QtPnJlcXVlc3ROb3RpZmljYXRpb25BbmRXYWl0VW50aWxTaG93bih0aXRsZSwgYm9k eSk7CisgICAgZ19hc3NlcnQodGVzdC0+bV9ldmVudCA9PSBOb3RpZmljYXRpb25XZWJWaWV3VGVz dDo6U2hvd24pOworfQorCitzdGF0aWMgdm9pZCB0ZXN0V2ViVmlld05vdGlmaWNhdGlvbkluaXRp YWxQZXJtaXNzaW9uRGlzYWxsb3dlZChOb3RpZmljYXRpb25XZWJWaWV3VGVzdCogdGVzdCwgZ2Nv bnN0cG9pbnRlcikKK3sKKyAgICBnX3NpZ25hbF9jb25uZWN0KHRlc3QtPm1fd2ViQ29udGV4dC5n ZXQoKSwgImluaXRpYWxpemUtbm90aWZpY2F0aW9uLXBlcm1pc3Npb25zIiwgR19DQUxMQkFDSyhz ZXRJbml0aWFsTm90aWZpY2F0aW9uUGVybWlzc2lvbnNEaXNhbGxvd2VkQ2FsbGJhY2spLCB0ZXN0 KTsKKyAgICB0ZXN0LT5pbml0aWFsaXplKCk7CisKKyAgICB0ZXN0LT5sb2FkVVJJKGdTZXJ2ZXIt PmdldFVSSUZvclBhdGgoIi8iKS5kYXRhKCkpOworICAgIHRlc3QtPndhaXRVbnRpbExvYWRGaW5p c2hlZCgpOworICAgIGdfYXNzZXJ0KCF0ZXN0LT5oYXNQZXJtaXNzaW9uKCkpOworfQorCiBzdGF0 aWMgdm9pZCB0ZXN0V2ViVmlld0lzUGxheWluZ0F1ZGlvKElzUGxheWluZ0F1ZGlvV2ViVmlld1Rl c3QqIHRlc3QsIGdjb25zdHBvaW50ZXIpCiB7CiAgICAgLy8gVGhlIHdlYiB2aWV3IG11c3QgYmUg cmVhbGl6ZWQgZm9yIHRoZSB2aWRlbyB0byBzdGFydCBwbGF5YmFjayBhbmQKQEAgLTkxNSw2ICs5 ODEsOCBAQCB2b2lkIGJlZm9yZUFsbCgpCiAgICAgU25hcHNob3RXZWJWaWV3VGVzdDo6YWRkKCJX ZWJLaXRXZWJWaWV3IiwgInNuYXBzaG90IiwgdGVzdFdlYlZpZXdTbmFwc2hvdCk7CiAgICAgV2Vi Vmlld1Rlc3Q6OmFkZCgiV2ViS2l0V2ViVmlldyIsICJwYWdlLXZpc2liaWxpdHkiLCB0ZXN0V2Vi Vmlld1BhZ2VWaXNpYmlsaXR5KTsKICAgICBOb3RpZmljYXRpb25XZWJWaWV3VGVzdDo6YWRkKCJX ZWJLaXRXZWJWaWV3IiwgIm5vdGlmaWNhdGlvbiIsIHRlc3RXZWJWaWV3Tm90aWZpY2F0aW9uKTsK KyAgICBOb3RpZmljYXRpb25XZWJWaWV3VGVzdDo6YWRkKCJXZWJLaXRXZWJWaWV3IiwgIm5vdGlm aWNhdGlvbi1pbml0aWFsLXBlcm1pc3Npb24tYWxsb3dlZCIsIHRlc3RXZWJWaWV3Tm90aWZpY2F0 aW9uSW5pdGlhbFBlcm1pc3Npb25BbGxvd2VkKTsKKyAgICBOb3RpZmljYXRpb25XZWJWaWV3VGVz dDo6YWRkKCJXZWJLaXRXZWJWaWV3IiwgIm5vdGlmaWNhdGlvbi1pbml0aWFsLXBlcm1pc3Npb24t ZGlzYWxsb3dlZCIsIHRlc3RXZWJWaWV3Tm90aWZpY2F0aW9uSW5pdGlhbFBlcm1pc3Npb25EaXNh bGxvd2VkKTsKICAgICBJc1BsYXlpbmdBdWRpb1dlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZp ZXciLCAiaXMtcGxheWluZy1hdWRpbyIsIHRlc3RXZWJWaWV3SXNQbGF5aW5nQXVkaW8pOwogICAg IFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAiYmFja2dyb3VuZC1jb2xvciIsIHRl c3RXZWJWaWV3QmFja2dyb3VuZENvbG9yKTsKICAgICBXZWJWaWV3VGVzdDo6YWRkKCJXZWJLaXRX ZWJWaWV3IiwgInByZWZlcnJlZC1zaXplIiwgdGVzdFdlYlZpZXdQcmVmZXJyZWRTaXplKTsKZGlm ZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvVGVzdE1haW4uaCBi L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvVGVzdE1haW4uaAppbmRleCA2MDU0 ZmUwOWQ0NzlhODgwNjA5ZjM2NTIyNWQ4OTNjODYyNmVjOWM0Li5mNjhhZjJhOTY1MTYyYjNkMmVm YjliZGU5NTc4MDAxYTRiNTVhY2ZmIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL2d0 ay9XZWJLaXQyR3RrL1Rlc3RNYWluLmgKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2Vi S2l0Mkd0ay9UZXN0TWFpbi5oCkBAIC00Myw2ICs0MywyNSBAQAogICAgICAgICBnX3Rlc3RfYWRk KHRlc3RQYXRoLmdldCgpLCBDbGFzc05hbWUsIDAsIENsYXNzTmFtZTo6c2V0VXAsIHRlc3RGdW5j LCBDbGFzc05hbWU6OnRlYXJEb3duKTsgXAogICAgIH0KIAorI2RlZmluZSBNQUtFX0dMSUJfVEVT VF9GSVhUVVJFX1dJVEhfU0VUVVBfVEVBUkRPV04oQ2xhc3NOYW1lLCBzZXR1cCwgdGVhcmRvd24p IFwKKyAgICBzdGF0aWMgdm9pZCBzZXRVcChDbGFzc05hbWUqIGZpeHR1cmUsIGdjb25zdHBvaW50 ZXIgZGF0YSkgXAorICAgIHsgXAorICAgICAgICBpZiAoc2V0dXApIFwKKyAgICAgICAgICAgIHNl dHVwKCk7IFwKKyAgICAgICAgbmV3IChmaXh0dXJlKSBDbGFzc05hbWU7IFwKKyAgICB9IFwKKyAg ICBzdGF0aWMgdm9pZCB0ZWFyRG93bihDbGFzc05hbWUqIGZpeHR1cmUsIGdjb25zdHBvaW50ZXIg ZGF0YSkgXAorICAgIHsgXAorICAgICAgICBmaXh0dXJlLT5+Q2xhc3NOYW1lKCk7IFwKKyAgICAg ICAgaWYgKHRlYXJkb3duKSBcCisgICAgICAgICAgICB0ZWFyZG93bigpOyBcCisgICAgfSBcCisg ICAgc3RhdGljIHZvaWQgYWRkKGNvbnN0IGNoYXIqIHN1aXRlTmFtZSwgY29uc3QgY2hhciogdGVz dE5hbWUsIHZvaWQgKCp0ZXN0RnVuYykoQ2xhc3NOYW1lKiwgY29uc3Qgdm9pZCopKSBcCisgICAg eyBcCisgICAgICAgIEdVbmlxdWVQdHI8Z2NoYXI+IHRlc3RQYXRoKGdfc3RyZHVwX3ByaW50Zigi L3dlYmtpdDIvJXMvJXMiLCBzdWl0ZU5hbWUsIHRlc3ROYW1lKSk7IFwKKyAgICAgICAgZ190ZXN0 X2FkZCh0ZXN0UGF0aC5nZXQoKSwgQ2xhc3NOYW1lLCAwLCBDbGFzc05hbWU6OnNldFVwLCB0ZXN0 RnVuYywgQ2xhc3NOYW1lOjp0ZWFyRG93bik7IFwKKyAgICB9CisKICNkZWZpbmUgQVNTRVJUX0NN UF9DU1RSSU5HKHMxLCBjbXAsIHMyKSBcCiAgICAgZG8geyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAogICAgICAgICBDU3Ry aW5nIF9fczEgPSAoczEpOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIFwKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2Vi S2l0VGVzdFNlcnZlci5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dl YktpdFRlc3RTZXJ2ZXIuY3BwCmluZGV4IGRlOTQ2NmMzOWQ3MWNmYzJhYmY0NDlmY2ZkZTM4OWI1 NDQ5ZGYzMjcuLmM0OTI5ZGU4YTA4ZTg1ZWZhZGFjNmNkNDljYjE0ZDA0MTU2NzUyNGIgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViS2l0VGVzdFNlcnZl ci5jcHAKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJLaXRUZXN0 U2VydmVyLmNwcApAQCAtNjgsNyArNjgsMTUgQEAgdm9pZCBXZWJLaXRUZXN0U2VydmVyOjpydW4o U291cFNlcnZlckNhbGxiYWNrIHNlcnZlckNhbGxiYWNrKQogICAgIH0KIH0KIAotQ1N0cmluZyBX ZWJLaXRUZXN0U2VydmVyOjpnZXRVUklGb3JQYXRoKGNvbnN0IGNoYXIqIHBhdGgpCitDU3RyaW5n IFdlYktpdFRlc3RTZXJ2ZXI6OnNlY3VyaXR5T3JpZ2luKCkgY29uc3QKK3sKKyAgICAvLyBUaGUg c2VjdXJpdHkgb3JpZ2luIGlzIHRoZSBiYXNlIFVSSSBtaW51cyB0aGUgdHJhaWxpbmcgc2xhc2gu CisgICAgR1VuaXF1ZVB0cjxnY2hhcj4gdXJpU3RyaW5nKHNvdXBfdXJpX3RvX3N0cmluZyhtX2Jh c2VVUkksIEZBTFNFKSk7CisgICAgdXJpU3RyaW5nLmdldCgpW3N0cmxlbih1cmlTdHJpbmcuZ2V0 KCkpIC0gMV0gPSAnXDAnOworICAgIHJldHVybiB1cmlTdHJpbmcuZ2V0KCk7Cit9CisKK0NTdHJp bmcgV2ViS2l0VGVzdFNlcnZlcjo6Z2V0VVJJRm9yUGF0aChjb25zdCBjaGFyKiBwYXRoKSBjb25z dAogewogICAgIFNvdXBVUkkqIHVyaSA9IHNvdXBfdXJpX25ld193aXRoX2Jhc2UobV9iYXNlVVJJ LCBwYXRoKTsKICAgICBHVW5pcXVlUHRyPGdjaGFyPiB1cmlTdHJpbmcoc291cF91cmlfdG9fc3Ry aW5nKHVyaSwgRkFMU0UpKTsKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dl YktpdDJHdGsvV2ViS2l0VGVzdFNlcnZlci5oIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2Vi S2l0Mkd0ay9XZWJLaXRUZXN0U2VydmVyLmgKaW5kZXggNThmMDE5ZmFiODYwMWMyZDEzMTQ2YWNj NTRmYzc4OGRjZTI5YzY4YS4uZDM4MjA5NWIyNmYzYjIzNzk5M2UyYTkyMmUzYzJhZGMzYTRhNzVi YSAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJLaXRU ZXN0U2VydmVyLmgKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJL aXRUZXN0U2VydmVyLmgKQEAgLTM5LDggKzM5LDggQEAgcHVibGljOgogICAgIHZpcnR1YWwgfldl YktpdFRlc3RTZXJ2ZXIoKTsKIAogICAgIFNvdXBVUkkqIGJhc2VVUkkoKSB7IHJldHVybiBtX2Jh c2VVUkk7IH0KLQotICAgIENTdHJpbmcgZ2V0VVJJRm9yUGF0aChjb25zdCBjaGFyKiBwYXRoKTsK KyAgICBDU3RyaW5nIHNlY3VyaXR5T3JpZ2luKCkgY29uc3Q7CisgICAgQ1N0cmluZyBnZXRVUklG b3JQYXRoKGNvbnN0IGNoYXIqIHBhdGgpIGNvbnN0OwogICAgIHZvaWQgcnVuKFNvdXBTZXJ2ZXJD YWxsYmFjayk7CiAKIHByaXZhdGU6CmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL2d0 ay9XZWJLaXQyR3RrL1dlYlZpZXdUZXN0LmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dl YktpdDJHdGsvV2ViVmlld1Rlc3QuY3BwCmluZGV4IDRhMjIxNDVjNDcxOTkyYmU0MGNmM2RkYzU0 NTkwNWQxYWMzMzA2ZjQuLjg4MGQwNjRkNGI5MDM0YjU4ZDJmZWY0YmMwNTIxZWRmYWZmOWUxNDkg MTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViVmlld1Rl c3QuY3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViVmlld1Rl c3QuY3BwCkBAIC0yNCwxOSArMjQsMTUgQEAKICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9KU1Jl dGFpblB0ci5oPgogI2luY2x1ZGUgPFdlYkNvcmUvR1VuaXF1ZVB0ckd0ay5oPgogCitib29sIFdl YlZpZXdUZXN0OjpzaG91bGRJbml0aWFsaXplV2ViVmlld0luQ29uc3RydWN0b3IgPSB0cnVlOwor CiBXZWJWaWV3VGVzdDo6V2ViVmlld1Rlc3QoKQogICAgIDogbV91c2VyQ29udGVudE1hbmFnZXIo YWRvcHRHUmVmKHdlYmtpdF91c2VyX2NvbnRlbnRfbWFuYWdlcl9uZXcoKSkpCi0gICAgLCBtX3dl YlZpZXcoV0VCS0lUX1dFQl9WSUVXKGdfb2JqZWN0X3JlZl9zaW5rKGdfb2JqZWN0X25ldyhXRUJL SVRfVFlQRV9XRUJfVklFVywgIndlYi1jb250ZXh0IiwgbV93ZWJDb250ZXh0LmdldCgpLCAidXNl ci1jb250ZW50LW1hbmFnZXIiLCBtX3VzZXJDb250ZW50TWFuYWdlci5nZXQoKSwgbnVsbHB0cikp KSkKICAgICAsIG1fbWFpbkxvb3AoZ19tYWluX2xvb3BfbmV3KG51bGxwdHIsIFRSVUUpKQotICAg ICwgbV9wYXJlbnRXaW5kb3cobnVsbHB0cikKLSAgICAsIG1famF2YXNjcmlwdFJlc3VsdChudWxs cHRyKQotICAgICwgbV9yZXNvdXJjZURhdGFTaXplKDApCi0gICAgLCBtX3N1cmZhY2UobnVsbHB0 cikKLSAgICAsIG1fZXhwZWN0ZWRXZWJQcm9jZXNzQ3Jhc2goZmFsc2UpCiB7Ci0gICAgYXNzZXJ0 T2JqZWN0SXNEZWxldGVkV2hlblRlc3RGaW5pc2hlcyhHX09CSkVDVChtX3dlYlZpZXcpKTsKKyAg ICBpZiAoc2hvdWxkSW5pdGlhbGl6ZVdlYlZpZXdJbkNvbnN0cnVjdG9yKQorICAgICAgICBpbml0 aWFsaXplV2ViVmlldygpOwogICAgIGFzc2VydE9iamVjdElzRGVsZXRlZFdoZW5UZXN0RmluaXNo ZXMoR19PQkpFQ1QobV91c2VyQ29udGVudE1hbmFnZXIuZ2V0KCkpKTsKLSAgICBnX3NpZ25hbF9j b25uZWN0KG1fd2ViVmlldywgIndlYi1wcm9jZXNzLWNyYXNoZWQiLCBHX0NBTExCQUNLKFdlYlZp ZXdUZXN0Ojp3ZWJQcm9jZXNzQ3Jhc2hlZCksIHRoaXMpOwogfQogCiBXZWJWaWV3VGVzdDo6fldl YlZpZXdUZXN0KCkKQEAgLTUxLDYgKzQ3LDE1IEBAIFdlYlZpZXdUZXN0Ojp+V2ViVmlld1Rlc3Qo KQogICAgIGdfbWFpbl9sb29wX3VucmVmKG1fbWFpbkxvb3ApOwogfQogCit2b2lkIFdlYlZpZXdU ZXN0Ojppbml0aWFsaXplV2ViVmlldygpCit7CisgICAgZ19hc3NlcnQoIW1fd2ViVmlldyk7Cisg ICAgbV93ZWJWaWV3ID0gV0VCS0lUX1dFQl9WSUVXKGdfb2JqZWN0X3JlZl9zaW5rKGdfb2JqZWN0 X25ldyhXRUJLSVRfVFlQRV9XRUJfVklFVywgIndlYi1jb250ZXh0IiwgbV93ZWJDb250ZXh0Lmdl dCgpLCAidXNlci1jb250ZW50LW1hbmFnZXIiLCBtX3VzZXJDb250ZW50TWFuYWdlci5nZXQoKSwg bnVsbHB0cikpKTsKKyAgICBhc3NlcnRPYmplY3RJc0RlbGV0ZWRXaGVuVGVzdEZpbmlzaGVzKEdf T0JKRUNUKG1fd2ViVmlldykpOworCisgICAgZ19zaWduYWxfY29ubmVjdChtX3dlYlZpZXcsICJ3 ZWItcHJvY2Vzcy1jcmFzaGVkIiwgR19DQUxMQkFDSyhXZWJWaWV3VGVzdDo6d2ViUHJvY2Vzc0Ny YXNoZWQpLCB0aGlzKTsKK30KKwogZ2Jvb2xlYW4gV2ViVmlld1Rlc3Q6OndlYlByb2Nlc3NDcmFz aGVkKFdlYktpdFdlYlZpZXcqLCBXZWJWaWV3VGVzdCogdGVzdCkKIHsKICAgICBpZiAodGVzdC0+ bV9leHBlY3RlZFdlYlByb2Nlc3NDcmFzaCkgewpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktp dEFQSS9ndGsvV2ViS2l0Mkd0ay9XZWJWaWV3VGVzdC5oIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9n dGsvV2ViS2l0Mkd0ay9XZWJWaWV3VGVzdC5oCmluZGV4IGEzMDAxYjJkZTM0MThlNzBjOWE3Mzli ZWNhN2FlMjMzNjcwNGVjYzIuLjRmMGM0YzdiZjU4ZDAzNTU5NjJmNjlhZTM4YTRiMDI4N2EzODI2 M2IgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ3RrL1dlYktpdDJHdGsvV2ViVmll d1Rlc3QuaAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL2d0ay9XZWJLaXQyR3RrL1dlYlZpZXdU ZXN0LmgKQEAgLTMxLDYgKzMxLDkgQEAgcHVibGljOgogICAgIFdlYlZpZXdUZXN0KCk7CiAgICAg dmlydHVhbCB+V2ViVmlld1Rlc3QoKTsKIAorICAgIHN0YXRpYyBib29sIHNob3VsZEluaXRpYWxp emVXZWJWaWV3SW5Db25zdHJ1Y3RvcjsKKyAgICB2b2lkIGluaXRpYWxpemVXZWJWaWV3KCk7CisK ICAgICB2aXJ0dWFsIHZvaWQgbG9hZFVSSShjb25zdCBjaGFyKiB1cmkpOwogICAgIHZpcnR1YWwg dm9pZCBsb2FkSHRtbChjb25zdCBjaGFyKiBodG1sLCBjb25zdCBjaGFyKiBiYXNlVVJJKTsKICAg ICB2aXJ0dWFsIHZvaWQgbG9hZFBsYWluVGV4dChjb25zdCBjaGFyKiBwbGFpblRleHQpOwpAQCAt ODEsMTcgKzg0LDE3IEBAIHB1YmxpYzoKICAgICBzdGF0aWMgZ2Jvb2xlYW4gd2ViUHJvY2Vzc0Ny YXNoZWQoV2ViS2l0V2ViVmlldyosIFdlYlZpZXdUZXN0Kik7CiAKICAgICBHUmVmUHRyPFdlYktp dFVzZXJDb250ZW50TWFuYWdlcj4gbV91c2VyQ29udGVudE1hbmFnZXI7Ci0gICAgV2ViS2l0V2Vi VmlldyogbV93ZWJWaWV3OworICAgIFdlYktpdFdlYlZpZXcqIG1fd2ViVmlldyB7IG51bGxwdHIg fTsKICAgICBHTWFpbkxvb3AqIG1fbWFpbkxvb3A7CiAgICAgQ1N0cmluZyBtX2FjdGl2ZVVSSTsK LSAgICBHdGtXaWRnZXQqIG1fcGFyZW50V2luZG93OworICAgIEd0a1dpZGdldCogbV9wYXJlbnRX aW5kb3cgeyBudWxscHRyIH07CiAgICAgQ1N0cmluZyBtX2V4cGVjdGVkVGl0bGU7Ci0gICAgV2Vi S2l0SmF2YXNjcmlwdFJlc3VsdCogbV9qYXZhc2NyaXB0UmVzdWx0OwotICAgIEdFcnJvcioqIG1f amF2YXNjcmlwdEVycm9yOwotICAgIEdVbmlxdWVQdHI8Y2hhcj4gbV9yZXNvdXJjZURhdGE7Ci0g ICAgc2l6ZV90IG1fcmVzb3VyY2VEYXRhU2l6ZTsKLSAgICBjYWlyb19zdXJmYWNlX3QqIG1fc3Vy ZmFjZTsKLSAgICBib29sIG1fZXhwZWN0ZWRXZWJQcm9jZXNzQ3Jhc2g7CisgICAgV2ViS2l0SmF2 YXNjcmlwdFJlc3VsdCogbV9qYXZhc2NyaXB0UmVzdWx0IHsgbnVsbHB0ciB9OworICAgIEdFcnJv cioqIG1famF2YXNjcmlwdEVycm9yIHsgbnVsbHB0ciB9OworICAgIEdVbmlxdWVQdHI8Y2hhcj4g bV9yZXNvdXJjZURhdGEgeyBudWxscHRyIH07CisgICAgc2l6ZV90IG1fcmVzb3VyY2VEYXRhU2l6 ZSB7IDAgfTsKKyAgICBjYWlyb19zdXJmYWNlX3QqIG1fc3VyZmFjZSB7IG51bGxwdHIgfTsKKyAg ICBib29sIG1fZXhwZWN0ZWRXZWJQcm9jZXNzQ3Jhc2ggeyBmYWxzZSB9OwogCiBwcml2YXRlOgog ICAgIHZvaWQgZG9Nb3VzZUJ1dHRvbkV2ZW50KEdka0V2ZW50VHlwZSwgaW50LCBpbnQsIHVuc2ln bmVkLCB1bnNpZ25lZCk7Cg==