154553 2016-02-22 12:45:02 -0800 [GTK] Expose user content filters in WebKitUserContentManager 2018-12-13 00:12:04 -0800 1 1 1 Unclassified WebKit WebKitGTK Other Unspecified Unspecified RESOLVED DUPLICATE 167941 P2 Normal --- 160363 160364 167941 169037 169607 192562 1 aperez aperez achristensen alcinnz benjamin bugs-noreply cgarcia hilobakho mcatanzaro sam steefhegeman oldest_to_newest 1167151 0 aperez 2016-02-22 12:45:02 -0800 Expose support for “content blockers” (a.k.a. “user content filters”) in the WebKitGTK+ API. Like user style sheets and user scripts, this could be added as methods on WebKitUserContentManager: void webkit_user_content_manager_add_filter(WebKitUserContentManager* WebKitUserContentFilter*); void webkit_user_content_manager_remove_all_filters(WebKitUserContentManager*); Plus functions to instantiate and ref/unref WebKitUserContentFilter objects, like it's done for WebKitUser{Script,StyleSheet}. (As per discussion at https://lists.webkit.org/pipermail/webkit-gtk/2016-February/002628.html) 1167154 1 aperez 2016-02-22 12:49:44 -0800 I have started to implement this. The bits to add the new API functions are easy, but how to parse and compile a ruleset is a bit involved :P There is interest in this API addition so GNOME Web (Epiphany) can make use of it. The corresponding bug is: https://bugzilla.gnome.org/show_bug.cgi?id=757824 1197700 2 steefhegeman 2016-05-30 17:50:29 -0700 Are you still working on this? I'm new to WebKit but I wouldn't mind giving it a shot. It looks like API::UserContentExtensionStore provides a good example of how compiling should be implemented. This class stores compiled extensions to disk though. Is that also the goal of this implementation? If so, in what directory should they be stored? I assume this is only used to save compile time instead of memory, so I'm inclined to just store the compiled extensions in memory as in this case there's no real extension system where the same rules have to be used frequently (for that situation it would be best to use an exposed UserContentExtensionStore but that's out of the scope of this task as is, assuming webkit_user_content_filter_new takes json data and it isn't supposed to be an abstraction of UserContentExtensionStore). API::UserContentExtension also has a name property which is used by UserContentExtensionStore to create a filename for the compiled extension and to identify it with the WebUserContentControllerProxy. So either a unique string has to be generated for each filter or the user has to specify one with a call to webkit_user_content_filter_new. It seems silly to me to ask the user for such a thing if the filter isn't going to be stored on disk anyway, so I think an automatically generated identifier would be the way to go, using WebCore::createCanonicalUUIDString. Consecutively, WebKitUserContentFilter won't have a public name property in contrast to UserContentExtension. To save the compile time, extra functions could be added to create a Filter from compiled data and to retrieve compiled data from a Filter. On the other hand, UserContentExtensionStore could just be exposed and compiled extensions just saved on disk, which would look a lot cleaner from the WebKit side. I wouldn't know a default location to save this data though. What are your thoughts? 1197731 3 cgarcia 2016-05-31 00:13:48 -0700 (In reply to comment #2) > Are you still working on this? I'm new to WebKit but I wouldn't mind giving > it a shot. Yes, Adrian is still working on this, he has a WIP patch already. > It looks like API::UserContentExtensionStore provides a good example of how > compiling should be implemented. This class stores compiled extensions to > disk though. Is that also the goal of this implementation? If so, in what > directory should they be stored? I assume this is only used to save compile > time instead of memory, so I'm inclined to just store the compiled > extensions in memory as in this case there's no real extension system where > the same rules have to be used frequently (for that situation it would be > best to use an exposed UserContentExtensionStore but that's out of the scope > of this task as is, assuming webkit_user_content_filter_new takes json data > and it isn't supposed to be an abstraction of UserContentExtensionStore). > > API::UserContentExtension also has a name property which is used by > UserContentExtensionStore to create a filename for the compiled extension > and to identify it with the WebUserContentControllerProxy. So either a > unique string has to be generated for each filter or the user has to specify > one with a call to webkit_user_content_filter_new. It seems silly to me to > ask the user for such a thing if the filter isn't going to be stored on disk > anyway, so I think an automatically generated identifier would be the way to > go, using WebCore::createCanonicalUUIDString. Consecutively, > WebKitUserContentFilter won't have a public name property in contrast to > UserContentExtension. > > To save the compile time, extra functions could be added to create a Filter > from compiled data and to retrieve compiled data from a Filter. > > On the other hand, UserContentExtensionStore could just be exposed and > compiled extensions just saved on disk, which would look a lot cleaner from > the WebKit side. I wouldn't know a default location to save this data though. > > What are your thoughts? Thanks for your feedback! Adrian can comment on all this, but I think it would also be useful to have some input from apple guys, since I'm not familiar with the content extensions API. 1197825 4 achristensen 2016-05-31 10:38:31 -0700 (In reply to comment #2) > Are you still working on this? I'm new to WebKit but I wouldn't mind giving > it a shot. > > It looks like API::UserContentExtensionStore provides a good example of how > compiling should be implemented. This class stores compiled extensions to > disk though. Is that also the goal of this implementation? If so, in what > directory should they be stored? I assume this is only used to save compile > time instead of memory, so I'm inclined to just store the compiled > extensions in memory as in this case there's no real extension system where > the same rules have to be used frequently (for that situation it would be > best to use an exposed UserContentExtensionStore but that's out of the scope > of this task as is, assuming webkit_user_content_filter_new takes json data > and it isn't supposed to be an abstraction of UserContentExtensionStore). > > API::UserContentExtension also has a name property which is used by > UserContentExtensionStore to create a filename for the compiled extension > and to identify it with the WebUserContentControllerProxy. So either a > unique string has to be generated for each filter or the user has to specify > one with a call to webkit_user_content_filter_new. It seems silly to me to > ask the user for such a thing if the filter isn't going to be stored on disk > anyway, so I think an automatically generated identifier would be the way to > go, using WebCore::createCanonicalUUIDString. Consecutively, > WebKitUserContentFilter won't have a public name property in contrast to > UserContentExtension. The whole feature is designed to use shared mmap'd memory from a file so we don't use a lot of memory with many web processes using the same filters. The only input is a string containing the json list of regexes. There are many things in WebKit that are stored in files. > > To save the compile time, extra functions could be added to create a Filter > from compiled data and to retrieve compiled data from a Filter. We considered this. This would save compile time, but we didn't want to expose the ability for content blocker authors to write their own byte code because that would allow authors to do strange things. For example, right now there is a guarantee that there are no infinite loops in the byte code, and this would not be guaranteed any more. > > On the other hand, UserContentExtensionStore could just be exposed and > compiled extensions just saved on disk, which would look a lot cleaner from > the WebKit side. I wouldn't know a default location to save this data though. That is what we did in cocoa, and that's what it's designed for. See _WKUserContentExtensionStore > > What are your thoughts? 1198311 5 280273 aperez 2016-06-01 15:43:51 -0700 Created attachment 280273 [WIP] Expose content filters in WebKitGTK+ I'm attaching my current very-WIP (builds, but there are crashes which need debugging) so we have something to comment on. Some notes: * API::UserContentStore is reused to compile filters, but not exposed in the public WebKitGTK+ API. Code using the API passes the JSON source to webkit_user_content_filter_new_sync() to start compilation in background. Before compiling, a lookup is tried first (to avoid uneeded compilations). The identifiers for the filters are the SHA1 hashes of the JSON source text. The completion callback then uses webkit_user_content_filter_new_finish() to obtain a valid WebKitUserContentFilter instance. * API::UserContentStore::defaultStore() is always used: This is okay because the on-disk path is derived from the values returned by g_get_user_cache_dir() and g_get_prgname(). This way each program uses a separate directory automatically, and each user gets its own. (For example a similar thing is done in the GTK+ port for the “Local Storage” databases.) * The webkit_user_content_manager_add_content_filter() will enable a filter in all the WebKitWebViews which use the WebKitUserContentManager. 1198321 6 aperez 2016-06-01 16:00:31 -0700 (In reply to comment #3) > (In reply to comment #2) > > Are you still working on this? I'm new to WebKit but I wouldn't mind giving > > it a shot. > > Yes, Adrian is still working on this, he has a WIP patch already. ...which is now attached as a sneak peek ;-) > > It looks like API::UserContentExtensionStore provides a good example of how > > compiling should be implemented. This class stores compiled extensions to > > disk though. Is that also the goal of this implementation? Yes. It seems like good idea to reuse the mechanism provided by the API::UserContentExtensionStore class. Also, it seems like a good idea to cache compiled extensions (more on this below). > > [...] If so, in what directory should they be stored? It is stored in the per-user cache directory, and each application gets its own cache directory (see g_get_user_cache_dir() and g_get_prgname() in GLib). > > [...] I assume this is only used to save compile > > time instead of memory, so I'm inclined to just store the compiled > > extensions in memory as in this case there's no real extension system where > > the same rules have to be used frequently (for that situation it would be > > best to use an exposed UserContentExtensionStore but that's out of the scope > > of this task as is, assuming webkit_user_content_filter_new takes json data > > and it isn't supposed to be an abstraction of UserContentExtensionStore). I would rather provide a simple API first which covers an usual "I am making a browser with ad blocking" use-case. If somebody comes up later with an use-case later on which does really need an additional degree of flexibility being provided by the WebKitGTK+ public API, it is better to add new API later — once new API functions make it to a stable release, we have to maintain it forever, so keeping it small and simple benefits boths its users and we developers :-) > > API::UserContentExtension also has a name property which is used by > > UserContentExtensionStore to create a filename for the compiled extension > > and to identify it with the WebUserContentControllerProxy. So either a > > unique string has to be generated for each filter or the user has to specify > > one with a call to webkit_user_content_filter_new. It seems silly to me to > > ask the user for such a thing if the filter isn't going to be stored on disk > > anyway, so I think an automatically generated identifier would be the way to > > go, using WebCore::createCanonicalUUIDString. Consecutively, > > WebKitUserContentFilter won't have a public name property in contrast to > > UserContentExtension. I have opted for generating the identifiers automatically (more on this below). > > To save the compile time, extra functions could be added to create a Filter > > from compiled data and to retrieve compiled data from a Filter. > > > > On the other hand, UserContentExtensionStore could just be exposed and > > compiled extensions just saved on disk, which would look a lot cleaner from > > the WebKit side. I wouldn't know a default location to save this data though. > > > > What are your thoughts? > > Thanks for your feedback! Adrian can comment on all this, but I think it > would also be useful to have some input from apple guys, since I'm not > familiar with the content extensions API. As I (briefly) commented in the comment when attaching the WIP patch, I think it is enough for now to provide a simple API which follows the same model as the other "user content" things like injected scripts and style sheets: * There is a way to instantiate a content filter (or an injected style sheet, or an injected script). * WebKitUserContentManager provides a method to "enable" using the filter (or injected style sheet, or injected script). This way we can hide the details of how/whether content filters are compiled and stored and from the point of view of the users of our public API things Just Work™. Many other things in WebKit(GTK+) already depend on having a writable file system, and therefore it should not be much of an issue to also have content filters saved to disk. Note that the identifiers in my WIP patch are the SHA1 hex digest of the input JSON, which neatly allows to lookup compiled filters from the disk cache: as long as the input source does not change, nor will the hash, and the cached version will be always used. 1198324 7 aperez 2016-06-01 16:06:45 -0700 (In reply to comment #4) > (In reply to comment #2) > > > [...] > > > > API::UserContentExtension also has a name property which is used by > > UserContentExtensionStore to create a filename for the compiled extension > > and to identify it with the WebUserContentControllerProxy. So either a > > unique string has to be generated for each filter or the user has to specify > > one with a call to webkit_user_content_filter_new. It seems silly to me to > > ask the user for such a thing if the filter isn't going to be stored on disk > > anyway, so I think an automatically generated identifier would be the way to > > go, using WebCore::createCanonicalUUIDString. Consecutively, > > WebKitUserContentFilter won't have a public name property in contrast to > > UserContentExtension. > > The whole feature is designed to use shared mmap'd memory from a file so we > don't use a lot of memory with many web processes using the same filters. > The only input is a string containing the json list of regexes. There are > many things in WebKit that are stored in files. > > > To save the compile time, extra functions could be added to create a Filter > > from compiled data and to retrieve compiled data from a Filter. > > We considered this. This would save compile time, but we didn't want to > expose the ability for content blocker authors to write their own byte code > because that would allow authors to do strange things. For example, right > now there is a guarantee that there are no infinite loops in the byte code, > and this would not be guaranteed any more. These are a couple of very good reasons to use files, and for us to to reuse API::UserContentExtensionStore as-is. Plus, the closest we stay to the other ports and the more shared code we have means that the common code gets more used and well tested, and we can share the maintenance effort :-) 1199972 8 280273 cgarcia 2016-06-07 01:51:44 -0700 Comment on attachment 280273 [WIP] Expose content filters in WebKitGTK+ View in context: https://bugs.webkit.org/attachment.cgi?id=280273&action=review I think we should split the patch, enabling content extensions first, and unskipping the layout tests, and then another patch to add the GTK+ API. It would help a lot to start working on a patch for epiphany in parallel. > Source/WebCore/PlatformGTK.cmake:77 > + loader/ResourceLoadInfo.cpp > + This is not platform specific, I think we could add this in the CMakeList.txt > Source/WebCore/platform/glib/FileSystemGlib.cpp:367 > +// XXX: This probably can go into FileSystemPOSIX.cpp, but if I put it there > +// then linking fails. This is because we don't use FileSystemPOSIX at all in the GTK+ port. The GLib implementation is supposed to work on windows too (even though it's not currently used), so this implementation should use glib so that it will work in all platforms supported by glib. Use unescapedFilename() for both paths and then just g_rename(). We could probably do this in a separate bug/patch. > Source/WebKit2/Platform/unix/SharedMemoryUnix.cpp:109 > +RefPtr<SharedMemory> SharedMemory::create(void* addr, size_t size, Protection protection) hmm, we didn't implement ::create(), this could also be moved to its own bug/patch. > Source/WebKit2/UIProcess/API/gtk/WebKitError.h:150 > + * Enum values used to denote errors happening when handling user content. > + */ I know this is a wip patch, but remember to add all since: 2.14 tags > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:267 > + _WebKitUserContentFilterPrivate(): jsonSource(), userContentExtension() { } Split this in different lines. > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:270 > + RefPtr<API::UserContentExtension> userContentExtension; Move member declaration after the methods > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:272 > + String identifier() const { Move the { to the next line. > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:284 > + GTask* task = g_task_new(initable, cancellable, callback, userData); I think we should make more explicit the ownership of the task, now that we have switched to C++ 14 we can use a GrefPtr here, adopting the ref, and then pass the ownership to the lambda. > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:287 > + [identifier, task](RefPtr<API::UserContentExtension> userContentExtension, std::error_code error) { task = WTFMove(task) and identifier will be passed to a secondary thread, so we probably want to pass an isolated copy: identifier = identifier.isolatedCopy() > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:290 > + WebKitUserContentFilter* userContentFilter = WEBKIT_USER_CONTENT_FILTER(g_task_get_source_object(task)); This is done in both branch of the if, so we could move it before the if > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:292 > + [task](RefPtr<API::UserContentExtension> userContentExtension, std::error_code error) { task = WTFMove(task) > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:298 > + userContentFilter->priv->jsonSource = ""; // The JSON source is not needed anymore. = nullptr > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:305 > + userContentFilter->priv->userContentExtension = userContentExtension; > + userContentFilter->priv->jsonSource = ""; // The JSON source is not needed anymore. We could add a helper to reduce code duplication here. webkitUserContentFilterSetContentExtension() that sets the extension and clears the json source. > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:329 > +WEBKIT_DEFINE_TYPE_WITH_CODE( > + WebKitUserContentFilter, webkit_user_content_filter, G_TYPE_OBJECT, > + G_IMPLEMENT_INTERFACE(G_TYPE_ASYNC_INITABLE, webkit_user_content_filter_interface_init)) Move this to the beginning, after the private struct declaration > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:332 > + * webkit_user_content_filter_new_async: Do not use async suffix, it's obvious this is async, and we don't have a sync version, so better to use just webkit_user_content_filter_new(). If we eventually add a sync version we'll use _sync suffix. > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:360 > +void webkit_user_content_filter_new_async(const gchar* jsonSource, > + GAsyncReadyCallback callback, > + gpointer userData) { This should be a single line and the { should be in the next line. > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:362 > + g_return_if_fail(jsonSource); WebKitUserContentFilter* userContentFilter = > + WEBKIT_USER_CONTENT_FILTER(g_object_new(WEBKIT_TYPE_USER_CONTENT_FILTER, Split this in lines too, > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:364 > + userContentFilter->priv->jsonSource = jsonSource; The json source could be a writable construct only property, so here you could just use g_async_initable_new_async(). > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:372 > + * @initable: The #GAsyncInitable passed to the completion callback. GAsyncInitable should be an implementation detail from the API user point of view. This function should just receive the async result and error > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:381 > + * Returns a #WebKitUserContentFilter if successful. If an error has occured, Returns: > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:387 > +{ This is public API, you should add g_return macros to check passed in values. g_return_val_if_fail (G_IS_ASYNC_RESULT(result), nullptr); g_return_val_if_fail(error == nullptr || *error == nullptr, nullptr); > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:389 > + if (g_async_initable_init_finish(initable, result, error)) { > + return WEBKIT_USER_CONTENT_FILTER(g_object_ref(initable)); And here we would use g_async_initable_new_finish() instead. > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.cpp:392 > + } else { > + return nullptr; > + } Don't use else after a return, and do not use { for single line bodies. > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.h:156 > +webkit_user_content_filter_new_async (const gchar *json_source, GAsyncReadyCallback callback, gpointer user_data); Move every parameter to its own line > Source/WebKit2/UIProcess/API/gtk/WebKitUserContent.h:159 > +webkit_user_content_filter_new_finish (GAsyncInitable *initable, GAsyncResult *result, GError **error); Ditto. > Source/WebKit2/UIProcess/API/gtk/WebKitUserContentManager.cpp:275 > + * Since: 2.12 2.14 > Source/WebKit2/UIProcess/API/gtk/WebKitUserContentManager.cpp:292 > + * Since: 2.12 2.14 > Source/WebKit2/UIProcess/API/gtk/WebKitUserContentPrivate.h:33 > +API::UserContentExtension& webkitUserContentFilterGetUserContentExtension(WebKitUserContentFilter *userContentFilter); WebKitUserContentFilter *userContentFilter -> WebKitUserContentFilter* > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitUserContentManager.cpp:224 > + char *dummy[1] = { nullptr }; > + removeOldInjectedContentAndResetLists(test->m_userContentManager.get(), dummy, dummy); I guess this is still TODO. 1215746 9 aperez 2016-07-29 16:38:55 -0700 (In reply to comment #8) > Comment on attachment 280273 [details] > [WIP] Expose content filters in WebKitGTK+ > > View in context: > https://bugs.webkit.org/attachment.cgi?id=280273&action=review > > I think we should split the patch, enabling content extensions first, and > unskipping the layout tests, and then another patch to add the GTK+ API. It > would help a lot to start working on a patch for epiphany in parallel. ACK. I have been working on the split, and while doing the first part which unskips the layout test I noticed that there was missing some changes to the CMake files to have ENABLE_CONTENT_FILTERING defined, and once that was enabled it was needed to add more files to the build, and ContentFilterUnblockHandler needs refactoring as it's only implemented for Cocoa. The refactor be a separate patch as well, which will add a port-agnostic ContentFilterUnblockHandlerBase, and move the Cocoa-specific implementation into WebCore/platform/cocoa/ContentFilterUnblockHandler.{h,mm}. After that is done, we can add an implementation for the GTK port. > > Source/WebCore/platform/glib/FileSystemGlib.cpp:367 > > +// XXX: This probably can go into FileSystemPOSIX.cpp, but if I put it there > > +// then linking fails. > > This is because we don't use FileSystemPOSIX at all in the GTK+ port. The > GLib implementation is supposed to work on windows too (even though it's not > currently used), so this implementation should use glib so that it will work > in all platforms supported by glib. Use unescapedFilename() for both paths > and then just g_rename(). We could probably do this in a separate bug/patch. Moved to separate bug/patch: https://bugs.webkit.org/show_bug.cgi?id=160363 > > Source/WebKit2/Platform/unix/SharedMemoryUnix.cpp:109 > > +RefPtr<SharedMemory> SharedMemory::create(void* addr, size_t size, Protection protection) > > hmm, we didn't implement ::create(), this could also be moved to its own > bug/patch. Moved to separate bug/patch: https://bugs.webkit.org/show_bug.cgi?id=160364 1273966 10 aperez 2017-02-07 06:01:20 -0800 I have had some time to work again on this during the flights to/from FOSDEM. Sometimes there's nothing like being a few hours in an isolated environment with a laptop to get some stuff done :-) (In reply to comment #8) > Comment on attachment 280273 [details] > [WIP] Expose content filters in WebKitGTK+ > > View in context: > https://bugs.webkit.org/attachment.cgi?id=280273&action=review > > I think we should split the patch, enabling content extensions first, and > unskipping the layout tests, and then another patch to add the GTK+ API. It > would help a lot to start working on a patch for epiphany in parallel. TL;DR: we need the API added first, then update WKTR, then unskip the tests. We cannot unskip first because “Tools/WebKitTestRunner/gtk/TestControllerGtk.cpp” needs changes to detect whether test cases are inside the “contentextensions/” subdirectory, and if yes compile and enable the correspoding JSON ruleset file. The WebKit2 C API does not have public functions for content extensions, so for example the Mac port #imports the public Objective-C API headers in the “TestControllerMac.mm” file and use the public API to do the needed configuration in “TestController::platformConfigureViewForTest()”. 1274002 11 aperez 2017-02-07 08:41:24 -0800 There is one thing that is bothering me with the API as it is currently. Consider the following actions: 1. Instantiate a WebKitUserContentFilter. This picks the JSON source, calculates its SHA1 to use as identifier, and compiles it. The last step saves it to disk in a way that it can be retrieved if the SHA1 (the identifier) is known. 2. The JSON source changes, and the process above repeated. The new compiled extension has a *different* identifier because the SHA1 hash of the source has changed. 3a. The old version of the content extension cannot be removed from disk, because the SHA1 hash of the first JSON source is never returned to the caller. 3b. Even if the SHA1 of the JSON source is calculated by the program without relying on WebKitGTK+ to return it, we provide no API at all to remove compiled content extensions from disk. So WebKitGTK+ would be leaking all the compiled content extensions on disk. Ouch. Therefore, I think it makes sense to go all-in and also expose an API for for the storage of compiled content extensions. That would mean adding the following to our public API: * Methods to instantiate a WebKitUserContentDataManager, or to obtain the default singleton instance: WebKitUserContentDataManager* webkit_user_content_data_managar_get_default (void) WebKitUserContentDataManager* webkit_user_content_data_manager_new (const char *path) * Asynchronous methods to lookup an already-compiled filter, compile a filter (with the side effect of being saved to disk), and removing a filter (with the side effect of being removed from disk): void webkit_user_content_data_manager_find_filter (WebKitUserContentDataManager*, const char *identifier, GAsyncResultCallback callback, gpointer userdata) WebKitUserContentFilter* webkit_user_content_data_manager_find_filter_finish (WebKitUserContentDataManager*, GAsyncResult *result, GError **error) void webkit_user_content_data_manager_compile_filter (WebKitUserContentDataManager*, const char *identifier, const char *json_source, GAsyncResultCallback callback, gpointer userdata) WebKitUserContentFilter* webkit_user_content_data_manager_compile_filter_finish (WebKitUserContentDataManager* GAsyncResult *result, GError **error) void webkit_user_content_data_manager_remove_filter (WebKitUserContentDataManager*, const char *identifier, GAsyncResultCallback callback, gpointer userdata) gboolean webkit_user_content_data_manager_remove_filter_finish (WebKitUserContentDataManager*, GASyncResult *result, GError **error) * Methods in WebKitUserContentManager to add/remove *active* filters. These have effect on content loaded by webviews which use the WebKitUserContentManager, but _no effect_ on the compiled filters stored on disk: void webkit_user_content_manager_add_filter (WebKitUserContentManager*, WebKitUserContentFilter*) void webkit_user_content_manager_remove_filter (WebKitUserContentManager*, WebKitUserContentFilter*) void webkit_user_content_manager_remove_all_filters (WebKitUserContentManager*) * Last by not least, by having the responsibility of compiling filters moved to the new WebKitUserContentDataManager class, WebKitUserContentFilter can be a boxed struct, and the public API only needs to provide the webkit_user_content_filter_ref() and webkit_user_content_filter_unref() methods. Note that direct instantiation would not be possible, and always done using the the lookup/compile methods from WebKitUserContentDataManager. I think this approach gives a better idea at the API level compiled filters are saved “somewhere” (i.e. on disk) because there is a WebKitUserContentDataManager class which is named in a way similar to WebKitWebsiteDataManager, which also deals with persisted data. Also, this kind of API also transmits the idea that compiling a filter and storing it on disk is a separate “process”, and it is possible to do it independently without having to instantiate webviews and so on. WDYT? 1274009 12 aperez 2017-02-07 08:49:26 -0800 (In reply to comment #11) > Therefore, I think it makes sense to go all-in and also expose an API for > for the storage of compiled content extensions. That would mean adding the > following to our public API: With the API that I have just proposed, when a browser obtains a new version of a filters ruleset, it would use the following: 1. webkit_user_content_data_manager_compile() to compile the new version. This is done asynchronously and the browser can continue using the old version of the filter in the meanwhile. 2. webkit_user_content_manager_remove_filter() to stop using the old version of the filter. 3. webkit_user_content_manager_add_filter() to start using the new version of the filter. 4. webkit_user_content_data_manager_remove() to remove the old compiled version of the filter from disk. I think it could even be possible to remove the compiled filter from disk with webkit_user_content_data_manager_remove() as _first_ step while still using the filter: it will be unlinked from disk, and the space freed once the filter gets disabled by webkit_user_content_manager_remove_filter() and munmap() called and the low-level file descriptor closed. This method allows reusing the same identifier for the new version of the filter. 1274188 13 mcatanzaro 2017-02-07 15:34:49 -0800 (In reply to comment #11) > 3b. Even if the SHA1 of the JSON source is calculated by the program > without relying on WebKitGTK+ to return it, we provide no API at > all to remove compiled content extensions from disk. So WebKitGTK+ > would be leaking all the compiled content extensions on disk. Ouch. It would be desirable that this work automatically, without applications needing to keep track of it themselves. Is that not possible...? > * Methods in WebKitUserContentManager to add/remove *active* filters. These > have > effect on content loaded by webviews which use the > WebKitUserContentManager, but > _no effect_ on the compiled filters stored on disk: Ideally applications would only think about what's happening in their web views, and not worry about what's being cached on disk. Is there no reasonable way for WebKit to know when a filter is no longer needed? If not, then perhaps applications will just have to manage it manually like you suggest. 1274351 14 aperez 2017-02-08 08:46:42 -0800 (In reply to comment #13) > (In reply to comment #11) > > 3b. Even if the SHA1 of the JSON source is calculated by the program > > without relying on WebKitGTK+ to return it, we provide no API at > > all to remove compiled content extensions from disk. So WebKitGTK+ > > would be leaking all the compiled content extensions on disk. Ouch. > > It would be desirable that this work automatically, without applications > needing to keep track of it themselves. Is that not possible...? Not quite. Content extensions are essentially a completely separate entity and they do not go through the usual cache paths (e.g. there's no cache replacement or anything like that). In my understanding, this is intentional because of the following reasons: - Content extensions are, well *extensions*, which are installed due to explicit user actions (“user enables EasyList”, “user disables EasyList” (“user removes EasyList”). Therefore we *know* when an extension has to be compiled/enabled/disabled/removed. - Also, we don't want WebKit to do cache replacement or removing compiled content extensions randomly, because there is no way for WebKit to know from which source file(s) to recreate them. - In contrast, the user does not directly control data saved locally by websites, and the code of websites can change at any time out of the control of the browser. That's why for website-stored data, we consider it “a cache”, while for content extension it is “a _storage_ area”. As such, a _storage_ is permanent and explicitly controlled. > > * Methods in WebKitUserContentManager to add/remove *active* filters. These > > have > > effect on content loaded by webviews which use the > > WebKitUserContentManager, but > > _no effect_ on the compiled filters stored on disk: > > Ideally applications would only think about what's happening in their web > views, and not worry about what's being cached on disk. Is there no > reasonable way for WebKit to know when a filter is no longer needed? If not, > then perhaps applications will just have to manage it manually like you > suggest. Thing is, as I tried to explain above (and hopefully succeeded!), content extension are *not* cached data. If you think that the “EasyList adblock list” maps 1:1 to a content extension, then you want the user to be able to enable or disable it with a checkbox in your UI, or add/remove more. So in the end the user is under control, therefore the WebKit API should cater to that need. Something we can discuss is whether we allow users of this API to give their own identifier or we calculate them and return them after compilation. 1274377 15 aperez 2017-02-08 09:13:01 -0800 One clarification more... When choosing the names for new API elements like WebKitUserContentDataManager my reasons were: - We already have other classes ending in *Manager (and *DataManager), let's be consistent with that. - We are already using the “UserContent” moniker for other pieces of data provided by the user (either final user or a developer who uses WebKitGTK+), like injected CSS style sheets and injected JavaScript snippets. - I did not want to have “Extension” or “Filter” in the name. The idea is that in the future we might have other “user content” data (local content not originated from a website). The WebKitUserContentDataManager name is generic, so it could handle other kinds of “user content” in the future as well. This name would potentially avoid having to add other WebKitUserContent${NAME}DataManager classes a the future. I hope this helps further clarify what's behind the naming choices :-) 1457874 16 alcinnz 2018-09-07 22:59:00 -0700 Is this bug still active? Is there anything I can do to help? According to the metadata it hasn't see any activity over the last year. 1486636 17 aperez 2018-12-10 11:35:12 -0800 (In reply to Adrian Cochrane from comment #16) > Is this bug still active? Is there anything I can do to help? > > According to the metadata it hasn't see any activity over the last year. I have resumed work on this a couple of weeks ago. 1487524 18 aperez 2018-12-13 00:12:04 -0800 I'm handling this as part of #167941 in the end. *** This bug has been marked as a duplicate of bug 167941 *** 280273 2016-06-01 15:43:51 -0700 2016-06-01 15:43:51 -0700 [WIP] Expose content filters in WebKitGTK+ usercontentfilter.patch text/plain 30829 aperez ZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL0ZlYXR1cmVEZWZpbmVzLmggYi9Tb3VyY2UvV1RG L3d0Zi9GZWF0dXJlRGVmaW5lcy5oCmluZGV4IDlkYWRiZjMuLjg5OTdlZGYgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XVEYvd3RmL0ZlYXR1cmVEZWZpbmVzLmgKKysrIGIvU291cmNlL1dURi93dGYvRmVh dHVyZURlZmluZXMuaApAQCAtMzE0LDYgKzMxNCwxMSBAQCB0aGUgcHVibGljIGlPUyBTREsuIFdl IHdpbGwgYWxzbyBuZWVkIHRvIHVwZGF0ZSB0aGUgRmVhdHVyZURlZmluZXMueGNjb25maWcgZmls ZQogCiAvKiAtLS0tLS0tLS0gR3RrIHBvcnQgKFVuaXgsIFdpbmRvd3MsIE1hYykgLS0tLS0tLS0t ICovCiAjaWYgUExBVEZPUk0oR1RLKQorCisjaWYgIWRlZmluZWQoRU5BQkxFX0NPTlRFTlRfRVhU RU5TSU9OUykKKyNkZWZpbmUgRU5BQkxFX0NPTlRFTlRfRVhURU5TSU9OUyAxCisjZW5kaWYKKwog I2VuZGlmIC8qIFBMQVRGT1JNKEdUSykgKi8KIAogLyogRU5BQkxFIG1hY3JvIGRlZmF1bHRzIGZv ciBXZWJDb3JlICovCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUdUSy5jbWFr ZSBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlCmluZGV4IGQ3MWNlZWUuLmJkZmUz MjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlCisrKyBiL1Nv dXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlCkBAIC03Myw2ICs3Myw4IEBAIGxpc3QoQVBQ RU5EIFdlYkNvcmVfU09VUkNFUwogCiAgICAgZWRpdGluZy9hdGsvRnJhbWVTZWxlY3Rpb25BdGsu Y3BwCiAKKyAgICBsb2FkZXIvUmVzb3VyY2VMb2FkSW5mby5jcHAKKwogICAgIGxvYWRlci9zb3Vw L0NhY2hlZFJhd1Jlc291cmNlU291cC5jcHAKICAgICBsb2FkZXIvc291cC9TdWJyZXNvdXJjZUxv YWRlclNvdXAuY3BwCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dsaWIv RmlsZVN5c3RlbUdsaWIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ2xpYi9GaWxlU3lz dGVtR2xpYi5jcHAKaW5kZXggYTA4OTJlYy4uYzRhMjFkNiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ2xpYi9GaWxlU3lzdGVtR2xpYi5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ2xpYi9GaWxlU3lzdGVtR2xpYi5jcHAKQEAgLTM2Myw2ICszNjMsMTUgQEAg aW50IHJlYWRGcm9tRmlsZShQbGF0Zm9ybUZpbGVIYW5kbGUgaGFuZGxlLCBjaGFyKiBkYXRhLCBp bnQgbGVuZ3RoKQogICAgIHJldHVybiAtMTsKIH0KIAorLy8gWFhYOiBUaGlzIHByb2JhYmx5IGNh biBnbyBpbnRvIEZpbGVTeXN0ZW1QT1NJWC5jcHAsIGJ1dCBpZiBJIHB1dCBpdCB0aGVyZQorLy8g ICAgICB0aGVuIGxpbmtpbmcgZmFpbHMuCitib29sIG1vdmVGaWxlKGNvbnN0IFN0cmluZyYgb2xk UGF0aCwgY29uc3QgU3RyaW5nJiBuZXdQYXRoKQoreworICAgIENTdHJpbmcgY09sZFBhdGggPSBv bGRQYXRoLnV0ZjgoKTsKKyAgICBDU3RyaW5nIGNOZXdQYXRoID0gbmV3UGF0aC51dGY4KCk7Cisg ICAgcmV0dXJuIHJlbmFtZShjT2xkUGF0aC5kYXRhKCksIGNOZXdQYXRoLmRhdGEoKSk7Cit9CisK IGJvb2wgdW5sb2FkTW9kdWxlKFBsYXRmb3JtTW9kdWxlIG1vZHVsZSkKIHsKICNpZiBPUyhXSU5E T1dTKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvY2FjaGUvTmV0 d29ya0NhY2hlRGF0YS5oIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvY2FjaGUvTmV0 d29ya0NhY2hlRGF0YS5oCmluZGV4IDIyNTU4OTguLmFmMDMwOTggMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL2NhY2hlL05ldHdvcmtDYWNoZURhdGEuaAorKysgYi9T b3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9jYWNoZS9OZXR3b3JrQ2FjaGVEYXRhLmgKQEAg LTE1Myw2ICsxNTMsOSBAQCBwcml2YXRlOgogRGF0YSBjb25jYXRlbmF0ZShjb25zdCBEYXRhJiwg Y29uc3QgRGF0YSYpOwogYm9vbCBieXRlc0VxdWFsKGNvbnN0IERhdGEmLCBjb25zdCBEYXRhJik7 CiBEYXRhIGFkb3B0QW5kTWFwRmlsZShpbnQgZmQsIHNpemVfdCBvZmZzZXQsIHNpemVfdCk7Cisj aWYgVVNFKFNPVVApCitEYXRhIGFkb3B0QW5kTWFwRmlsZShHUmVmUHRyPEdGaWxlSU9TdHJlYW0+ IHN0cmVhbSwgc2l6ZV90IG9mZnNldCwgc2l6ZV90KTsKKyNlbmRpZgogRGF0YSBtYXBGaWxlKGNv bnN0IGNoYXIqIHBhdGgpOwogU0hBMTo6RGlnZXN0IGNvbXB1dGVTSEExKGNvbnN0IERhdGEmKTsK IApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvY2FjaGUvTmV0d29y a0NhY2hlRGF0YVNvdXAuY3BwIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvY2FjaGUv TmV0d29ya0NhY2hlRGF0YVNvdXAuY3BwCmluZGV4IDY0NGMzOGUuLjNhODk5ZDggMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL2NhY2hlL05ldHdvcmtDYWNoZURhdGFT b3VwLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9jYWNoZS9OZXR3b3Jr Q2FjaGVEYXRhU291cC5jcHAKQEAgLTM0LDYgKzM0LDcgQEAKICNpbmNsdWRlIDxzeXMvc3RhdC5o PgogI2luY2x1ZGUgPHN5cy90eXBlcy5oPgogI2luY2x1ZGUgPHVuaXN0ZC5oPgorI2luY2x1ZGUg PGdpby9nZmlsZWRlc2NyaXB0b3JiYXNlZC5oPgogCiBuYW1lc3BhY2UgV2ViS2l0IHsKIG5hbWVz cGFjZSBOZXR3b3JrQ2FjaGUgewpAQCAtMTI4LDYgKzEyOSwxMyBAQCBEYXRhIERhdGE6OmFkb3B0 TWFwKHZvaWQqIG1hcCwgc2l6ZV90IHNpemUsIGludCBmZCkKICAgICByZXR1cm4geyBXVEZNb3Zl KGJ1ZmZlciksIGZkIH07CiB9CiAKK0RhdGEgYWRvcHRBbmRNYXBGaWxlKEdSZWZQdHI8R0ZpbGVJ T1N0cmVhbT4gc3RyZWFtLCBzaXplX3Qgb2Zmc2V0LCBzaXplX3Qgc2l6ZSkKK3sKKyAgICBHSW5w dXRTdHJlYW0gKmlucHV0U3RyZWFtID0gZ19pb19zdHJlYW1fZ2V0X2lucHV0X3N0cmVhbShHX0lP X1NUUkVBTSAoc3RyZWFtLmdldCgpKSk7CisgICAgaW50IGZkID0gZ19maWxlX2Rlc2NyaXB0b3Jf YmFzZWRfZ2V0X2ZkKEdfRklMRV9ERVNDUklQVE9SX0JBU0VEKGlucHV0U3RyZWFtKSk7CisgICAg cmV0dXJuIGFkb3B0QW5kTWFwRmlsZShmZCwgb2Zmc2V0LCBzaXplKTsKK30KKwogUmVmUHRyPFNo YXJlZE1lbW9yeT4gRGF0YTo6dHJ5Q3JlYXRlU2hhcmVkTWVtb3J5KCkgY29uc3QKIHsKICAgICBp ZiAoaXNOdWxsKCkgfHwgIWlzTWFwKCkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9QbGF0 Zm9ybS91bml4L1NoYXJlZE1lbW9yeVVuaXguY3BwIGIvU291cmNlL1dlYktpdDIvUGxhdGZvcm0v dW5peC9TaGFyZWRNZW1vcnlVbml4LmNwcAppbmRleCA1NjgzNWU3Li41MmM2MDIwIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0Mi9QbGF0Zm9ybS91bml4L1NoYXJlZE1lbW9yeVVuaXguY3BwCisr KyBiL1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtL3VuaXgvU2hhcmVkTWVtb3J5VW5peC5jcHAKQEAg LTkzLDcgKzkzLDIwIEBAIHZvaWQgU2hhcmVkTWVtb3J5OjpIYW5kbGU6OmFkb3B0QXR0YWNobWVu dChJUEM6OkF0dGFjaG1lbnQmJiBhdHRhY2htZW50KQogICAgIG1fYXR0YWNobWVudCA9IFdURk1v dmUoYXR0YWNobWVudCk7CiB9CiAKLVJlZlB0cjxTaGFyZWRNZW1vcnk+IFNoYXJlZE1lbW9yeTo6 YWxsb2NhdGUoc2l6ZV90IHNpemUpCitzdGF0aWMgaW5saW5lIGludCBhY2Nlc3NNb2RlTU1hcChT aGFyZWRNZW1vcnk6OlByb3RlY3Rpb24gcHJvdGVjdGlvbikKK3sKKyAgICBzd2l0Y2ggKHByb3Rl Y3Rpb24pIHsKKyAgICBjYXNlIFNoYXJlZE1lbW9yeTo6UHJvdGVjdGlvbjo6UmVhZE9ubHk6Cisg ICAgICAgIHJldHVybiBQUk9UX1JFQUQ7CisgICAgY2FzZSBTaGFyZWRNZW1vcnk6OlByb3RlY3Rp b246OlJlYWRXcml0ZToKKyAgICAgICAgcmV0dXJuIFBST1RfUkVBRCB8IFBST1RfV1JJVEU7Cisg ICAgfQorCisgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgcmV0dXJuIFBST1RfUkVBRCB8 IFBST1RfV1JJVEU7Cit9CisKK1JlZlB0cjxTaGFyZWRNZW1vcnk+IFNoYXJlZE1lbW9yeTo6Y3Jl YXRlKHZvaWQqIGFkZHIsIHNpemVfdCBzaXplLCBQcm90ZWN0aW9uIHByb3RlY3Rpb24pCiB7CiAg ICAgQ1N0cmluZyB0ZW1wTmFtZTsKIApAQCAtMTE5LDcgKzEzMiw3IEBAIFJlZlB0cjxTaGFyZWRN ZW1vcnk+IFNoYXJlZE1lbW9yeTo6YWxsb2NhdGUoc2l6ZV90IHNpemUpCiAgICAgICAgIH0KICAg ICB9CiAKLSAgICB2b2lkKiBkYXRhID0gbW1hcCgwLCBzaXplLCBQUk9UX1JFQUQgfCBQUk9UX1dS SVRFLCBNQVBfU0hBUkVELCBmaWxlRGVzY3JpcHRvciwgMCk7CisgICAgdm9pZCogZGF0YSA9IG1t YXAoYWRkciwgc2l6ZSwgYWNjZXNzTW9kZU1NYXAocHJvdGVjdGlvbiksIE1BUF9TSEFSRUQsIGZp bGVEZXNjcmlwdG9yLCAwKTsKICAgICBpZiAoZGF0YSA9PSBNQVBfRkFJTEVEKSB7CiAgICAgICAg IGNsb3NlV2l0aFJldHJ5KGZpbGVEZXNjcmlwdG9yKTsKICAgICAgICAgc2htX3VubGluayh0ZW1w TmFtZS5kYXRhKCkpOwpAQCAtMTM1LDE3ICsxNDgsOSBAQCBSZWZQdHI8U2hhcmVkTWVtb3J5PiBT aGFyZWRNZW1vcnk6OmFsbG9jYXRlKHNpemVfdCBzaXplKQogICAgIHJldHVybiBpbnN0YW5jZS5y ZWxlYXNlKCk7CiB9CiAKLXN0YXRpYyBpbmxpbmUgaW50IGFjY2Vzc01vZGVNTWFwKFNoYXJlZE1l bW9yeTo6UHJvdGVjdGlvbiBwcm90ZWN0aW9uKQorUmVmUHRyPFNoYXJlZE1lbW9yeT4gU2hhcmVk TWVtb3J5OjphbGxvY2F0ZShzaXplX3Qgc2l6ZSkKIHsKLSAgICBzd2l0Y2ggKHByb3RlY3Rpb24p IHsKLSAgICBjYXNlIFNoYXJlZE1lbW9yeTo6UHJvdGVjdGlvbjo6UmVhZE9ubHk6Ci0gICAgICAg IHJldHVybiBQUk9UX1JFQUQ7Ci0gICAgY2FzZSBTaGFyZWRNZW1vcnk6OlByb3RlY3Rpb246OlJl YWRXcml0ZToKLSAgICAgICAgcmV0dXJuIFBST1RfUkVBRCB8IFBST1RfV1JJVEU7Ci0gICAgfQot Ci0gICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7Ci0gICAgcmV0dXJuIFBST1RfUkVBRCB8IFBST1Rf V1JJVEU7CisgICAgcmV0dXJuIFNoYXJlZE1lbW9yeTo6Y3JlYXRlKDAsIHNpemUsIFNoYXJlZE1l bW9yeTo6UHJvdGVjdGlvbjo6UmVhZFdyaXRlKTsKIH0KIAogUmVmUHRyPFNoYXJlZE1lbW9yeT4g U2hhcmVkTWVtb3J5OjptYXAoY29uc3QgSGFuZGxlJiBoYW5kbGUsIFByb3RlY3Rpb24gcHJvdGVj dGlvbikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtR1RLLmNtYWtlIGIvU291 cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UKaW5kZXggYWMwMmU0Yy4uYmI5Nzg2NyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dl YktpdDIvUGxhdGZvcm1HVEsuY21ha2UKQEAgLTk3LDYgKzk3LDcgQEAgbGlzdChBUFBFTkQgV2Vi S2l0Ml9TT1VSQ0VTCiAgICAgVUlQcm9jZXNzL0FQSS9DL3NvdXAvV0tTb3VwQ3VzdG9tUHJvdG9j b2xSZXF1ZXN0TWFuYWdlci5jcHAKIAogICAgIFVJUHJvY2Vzcy9BUEkvZ3RrL0FQSVdlYnNpdGVE YXRhU3RvcmVHdGsuY3BwCisgICAgVUlQcm9jZXNzL0FQSS9ndGsvQVBJVXNlckNvbnRlbnRFeHRl bnNpb25TdG9yZUd0ay5jcHAKICAgICBVSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5j cHAKICAgICBVSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5oCiAgICAgVUlQcm9jZXNz L0FQSS9ndGsvV2ViS2l0QXV0aGVudGljYXRpb25EaWFsb2cuY3BwCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9BUElVc2VyQ29udGVudEV4dGVuc2lvblN0b3Jl R3RrLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL0FQSVVzZXJDb250ZW50 RXh0ZW5zaW9uU3RvcmVHdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LmVlOWU3MDYKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2d0ay9BUElVc2VyQ29udGVudEV4dGVuc2lvblN0b3JlR3RrLmNwcApAQCAtMCwwICsxLDM5IEBA CisvKgorICogQ29weXJpZ2h0IChDKSAyMDE2IElnYWxpYSBTLkwuCisgKgorICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291 cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICog Mi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICog VEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVU T1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVT IE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQ T1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBD T05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAo SU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1Ig QlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVP UlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNs dWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBUElVc2VyQ29udGVudEV4dGVuc2lvblN0b3JlLmgi CisKKyNpbmNsdWRlIDxnbGliLmg+CisjaW5jbHVkZSA8V2ViQ29yZS9GaWxlU3lzdGVtLmg+CisK K25hbWVzcGFjZSBBUEkgeworCitTdHJpbmcgVXNlckNvbnRlbnRFeHRlbnNpb25TdG9yZTo6ZGVm YXVsdFN0b3JlUGF0aCgpCit7CisgICAgcmV0dXJuIFdlYkNvcmU6OnBhdGhCeUFwcGVuZGluZ0Nv bXBvbmVudChXZWJDb3JlOjpwYXRoQnlBcHBlbmRpbmdDb21wb25lbnQoV2ViQ29yZTo6ZmlsZW5h bWVUb1N0cmluZyhnX2dldF91c2VyX2NhY2hlX2RpcigpKSwgV2ViQ29yZTo6ZmlsZW5hbWVUb1N0 cmluZyhnX2dldF9wcmduYW1lKCkpKSwgIldlYktpdFVzZXJDb250ZW50RXh0ZW5zaW9uQ2FjaGUi KTsKK30KKworfTsgLy8gbmFtZXNwYWNlIEFQSQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0RXJyb3IuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0RXJyb3IuY3BwCmluZGV4IDc0MTllZTcuLjEzZjFmN2IgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEVycm9yLmNwcAor KysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRFcnJvci5jcHAKQEAg LTY5LDMgKzY5LDggQEAgR1F1YXJrIHdlYmtpdF9zbmFwc2hvdF9lcnJvcl9xdWFyaygpCiB7CiAg ICAgcmV0dXJuIGdfcXVhcmtfZnJvbV9zdGF0aWNfc3RyaW5nKCJXZWJLaXRTbmFwc2hvdEVycm9y Iik7CiB9CisKK0dRdWFyayB3ZWJraXRfdXNlcl9jb250ZW50X2Vycm9yX3F1YXJrKCkKK3sKKyAg ICByZXR1cm4gZ19xdWFya19mcm9tX3N0YXRpY19zdHJpbmcoIldlYktpdFVzZXJDb250ZW50RXJy b3IiKTsKK30KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dl YktpdEVycm9yLmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRFcnJv ci5oCmluZGV4IGU3ZGU5M2IuLjlkZmFmNzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEVycm9yLmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0RXJyb3IuaApAQCAtMjksMTMgKzI5LDE0IEBACiAKIEdfQkVHSU5f REVDTFMKIAotI2RlZmluZSBXRUJLSVRfTkVUV09SS19FUlJPUiAgICB3ZWJraXRfbmV0d29ya19l cnJvcl9xdWFyayAoKQotI2RlZmluZSBXRUJLSVRfUE9MSUNZX0VSUk9SICAgICB3ZWJraXRfcG9s aWN5X2Vycm9yX3F1YXJrICgpCi0jZGVmaW5lIFdFQktJVF9QTFVHSU5fRVJST1IgICAgIHdlYmtp dF9wbHVnaW5fZXJyb3JfcXVhcmsgKCkKLSNkZWZpbmUgV0VCS0lUX0RPV05MT0FEX0VSUk9SICAg d2Via2l0X2Rvd25sb2FkX2Vycm9yX3F1YXJrICgpCi0jZGVmaW5lIFdFQktJVF9QUklOVF9FUlJP UiAgICAgIHdlYmtpdF9wcmludF9lcnJvcl9xdWFyayAoKQotI2RlZmluZSBXRUJLSVRfSkFWQVND UklQVF9FUlJPUiB3ZWJraXRfcHJpbnRfZXJyb3JfcXVhcmsgKCkKLSNkZWZpbmUgV0VCS0lUX1NO QVBTSE9UX0VSUk9SICAgd2Via2l0X3NuYXBzaG90X2Vycm9yX3F1YXJrICgpCisjZGVmaW5lIFdF QktJVF9ORVRXT1JLX0VSUk9SICAgICAgd2Via2l0X25ldHdvcmtfZXJyb3JfcXVhcmsgKCkKKyNk ZWZpbmUgV0VCS0lUX1BPTElDWV9FUlJPUiAgICAgICB3ZWJraXRfcG9saWN5X2Vycm9yX3F1YXJr ICgpCisjZGVmaW5lIFdFQktJVF9QTFVHSU5fRVJST1IgICAgICAgd2Via2l0X3BsdWdpbl9lcnJv cl9xdWFyayAoKQorI2RlZmluZSBXRUJLSVRfRE9XTkxPQURfRVJST1IgICAgIHdlYmtpdF9kb3du bG9hZF9lcnJvcl9xdWFyayAoKQorI2RlZmluZSBXRUJLSVRfUFJJTlRfRVJST1IgICAgICAgIHdl YmtpdF9wcmludF9lcnJvcl9xdWFyayAoKQorI2RlZmluZSBXRUJLSVRfSkFWQVNDUklQVF9FUlJP UiAgIHdlYmtpdF9wcmludF9lcnJvcl9xdWFyayAoKQorI2RlZmluZSBXRUJLSVRfU05BUFNIT1Rf RVJST1IgICAgIHdlYmtpdF9zbmFwc2hvdF9lcnJvcl9xdWFyayAoKQorI2RlZmluZSBXRUJLSVRf VVNFUl9DT05URU5UX0VSUk9SIHdlYmtpdF91c2VyX2NvbnRlbnRfZXJyb3JfcXVhcmsgKCkKIAog LyoqCiAgKiBXZWJLaXROZXR3b3JrRXJyb3I6CkBAIC0xNDEsMjYgKzE0MiwzOSBAQCB0eXBlZGVm IGVudW0gewogICAgIFdFQktJVF9TTkFQU0hPVF9FUlJPUl9GQUlMRURfVE9fQ1JFQVRFID0gNzk5 CiB9IFdlYktpdFNuYXBzaG90RXJyb3I7CiAKKy8qKgorICogV2ViS2l0VXNlckNvbnRlbnRFcnJv cjoKKyAqIEBXRUJLSVRfVVNFUl9DT05URU5UX0VSUk9SX0ZJTFRFUl9DT01QSUxBVElPTl9GQUlM RUQ6IEFuIGVycm9yIG9jY3VycmVkIHdoZW4gY29tcGlsaW5nIGFuIHVzZXIgY29udGVudCBmaWx0 ZXIuCisgKgorICogRW51bSB2YWx1ZXMgdXNlZCB0byBkZW5vdGUgZXJyb3JzIGhhcHBlbmluZyB3 aGVuIGhhbmRsaW5nIHVzZXIgY29udGVudC4KKyAqLwordHlwZWRlZiBlbnVtIHsKKyAgICBXRUJL SVRfVVNFUl9DT05URU5UX0VSUk9SX0ZJTFRFUl9DT01QSUxBVElPTl9GQUlMRUQgPSA4OTkKK30g V2ViS2l0VXNlckNvbnRlbnRFcnJvcjsKKworV0VCS0lUX0FQSSBHUXVhcmsKK3dlYmtpdF9uZXR3 b3JrX2Vycm9yX3F1YXJrICAgICAgKHZvaWQpOworCiBXRUJLSVRfQVBJIEdRdWFyawotd2Via2l0 X25ldHdvcmtfZXJyb3JfcXVhcmsgICAgKHZvaWQpOword2Via2l0X3BvbGljeV9lcnJvcl9xdWFy ayAgICAgICAodm9pZCk7CiAKIFdFQktJVF9BUEkgR1F1YXJrCi13ZWJraXRfcG9saWN5X2Vycm9y X3F1YXJrICAgICAodm9pZCk7Cit3ZWJraXRfcGx1Z2luX2Vycm9yX3F1YXJrICAgICAgICh2b2lk KTsKIAogV0VCS0lUX0FQSSBHUXVhcmsKLXdlYmtpdF9wbHVnaW5fZXJyb3JfcXVhcmsgICAgICh2 b2lkKTsKK3dlYmtpdF9kb3dubG9hZF9lcnJvcl9xdWFyayAgICAgKHZvaWQpOwogCiBXRUJLSVRf QVBJIEdRdWFyawotd2Via2l0X2Rvd25sb2FkX2Vycm9yX3F1YXJrICAgKHZvaWQpOword2Via2l0 X3ByaW50X2Vycm9yX3F1YXJrICAgICAgICAodm9pZCk7CiAKIFdFQktJVF9BUEkgR1F1YXJrCi13 ZWJraXRfcHJpbnRfZXJyb3JfcXVhcmsgICAgICAodm9pZCk7Cit3ZWJraXRfamF2YXNjcmlwdF9l cnJvcl9xdWFyayAgICh2b2lkKTsKIAogV0VCS0lUX0FQSSBHUXVhcmsKLXdlYmtpdF9qYXZhc2Ny aXB0X2Vycm9yX3F1YXJrICh2b2lkKTsKK3dlYmtpdF9zbmFwc2hvdF9lcnJvcl9xdWFyayAgICAg KHZvaWQpOwogCiBXRUJLSVRfQVBJIEdRdWFyawotd2Via2l0X3NuYXBzaG90X2Vycm9yX3F1YXJr ICAgKHZvaWQpOword2Via2l0X3VzZXJfY29udGVudF9lcnJvcl9xdWFyayAodm9pZCk7CiAKIEdf RU5EX0RFQ0xTCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3Rr L1dlYktpdFVzZXJDb250ZW50LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3Rr L1dlYktpdFVzZXJDb250ZW50LmNwcAppbmRleCBhNWY2MDM5Li4zZmEzYzJkIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRVc2VyQ29udGVudC5jcHAK KysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0VXNlckNvbnRlbnQu Y3BwCkBAIC0yMCwxMCArMjAsMTMgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJX ZWJLaXRVc2VyQ29udGVudC5oIgogCisjaW5jbHVkZSAiQVBJVXNlckNvbnRlbnRFeHRlbnNpb25T dG9yZS5oIgorI2luY2x1ZGUgIldlYktpdEVycm9yLmgiCiAjaW5jbHVkZSAiV2ViS2l0UHJpdmF0 ZS5oIgogI2luY2x1ZGUgIldlYktpdFVzZXJDb250ZW50UHJpdmF0ZS5oIgogI2luY2x1ZGUgPHd0 Zi90ZXh0L0NTdHJpbmcuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+Cisj aW5jbHVkZSA8d3RmL1NIQTEuaD4KIAogdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiAKQEAgLTI1 OCwzICsyNjEsMTM4IEBAIEFQSTo6VXNlclNjcmlwdCYgd2Via2l0VXNlclNjcmlwdEdldFVzZXJT Y3JpcHQoV2ViS2l0VXNlclNjcmlwdCogdXNlclNjcmlwdCkKIHsKICAgICByZXR1cm4gKnVzZXJT Y3JpcHQtPnVzZXJTY3JpcHQ7CiB9CisKKworc3RydWN0IF9XZWJLaXRVc2VyQ29udGVudEZpbHRl clByaXZhdGUgeworICAgIF9XZWJLaXRVc2VyQ29udGVudEZpbHRlclByaXZhdGUoKToganNvblNv dXJjZSgpLCB1c2VyQ29udGVudEV4dGVuc2lvbigpIHsgfQorCisgICAgQ1N0cmluZyBqc29uU291 cmNlOworICAgIFJlZlB0cjxBUEk6OlVzZXJDb250ZW50RXh0ZW5zaW9uPiB1c2VyQ29udGVudEV4 dGVuc2lvbjsKKworICAgIFN0cmluZyBpZGVudGlmaWVyKCkgY29uc3QgeworICAgICAgICBXVEY6 OlNIQTEgc2hhOworICAgICAgICBzaGEuYWRkQnl0ZXMoanNvblNvdXJjZSk7CisgICAgICAgIHJl dHVybiBTdHJpbmc6OmZyb21VVEY4KHNoYS5jb21wdXRlSGV4RGlnZXN0KCkpOworICAgIH0KK307 CisKKworc3RhdGljIHZvaWQgdXNlckNvbnRlbnRGaWx0ZXJJbml0QXN5bmMoR0FzeW5jSW5pdGFi bGUqIGluaXRhYmxlLCBpbnQgaW9Qcmlvcml0eSwgR0NhbmNlbGxhYmxlKiBjYW5jZWxsYWJsZSwg R0FzeW5jUmVhZHlDYWxsYmFjayBjYWxsYmFjaywgZ3BvaW50ZXIgdXNlckRhdGEpCit7CisgICAg V2ViS2l0VXNlckNvbnRlbnRGaWx0ZXIqIHVzZXJDb250ZW50RmlsdGVyID0gV0VCS0lUX1VTRVJf Q09OVEVOVF9GSUxURVIoaW5pdGFibGUpOworICAgIFN0cmluZyBpZGVudGlmaWVyKHVzZXJDb250 ZW50RmlsdGVyLT5wcml2LT5pZGVudGlmaWVyKCkpOworICAgIEdUYXNrKiB0YXNrID0gZ190YXNr X25ldyhpbml0YWJsZSwgY2FuY2VsbGFibGUsIGNhbGxiYWNrLCB1c2VyRGF0YSk7CisKKyAgICBB UEk6OlVzZXJDb250ZW50RXh0ZW5zaW9uU3RvcmU6OmRlZmF1bHRTdG9yZSgpLmxvb2t1cENvbnRl bnRFeHRlbnNpb24oaWRlbnRpZmllciwKKyAgICAgICAgW2lkZW50aWZpZXIsIHRhc2tdKFJlZlB0 cjxBUEk6OlVzZXJDb250ZW50RXh0ZW5zaW9uPiB1c2VyQ29udGVudEV4dGVuc2lvbiwgc3RkOjpl cnJvcl9jb2RlIGVycm9yKSB7CisgICAgICAgICAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAgICAg ICAgICAvLyBMb29rdXAgZmFpbGVkLCBvciBjb21waWxlZCB2ZXJzaW9uIGlzIG9sZDogc2NoZWR1 bGUgY29tcGlsYXRpb24uCisgICAgICAgICAgICAgICAgV2ViS2l0VXNlckNvbnRlbnRGaWx0ZXIq IHVzZXJDb250ZW50RmlsdGVyID0gV0VCS0lUX1VTRVJfQ09OVEVOVF9GSUxURVIoZ190YXNrX2dl dF9zb3VyY2Vfb2JqZWN0KHRhc2spKTsKKyAgICAgICAgICAgICAgICBBUEk6OlVzZXJDb250ZW50 RXh0ZW5zaW9uU3RvcmU6OmRlZmF1bHRTdG9yZSgpLmNvbXBpbGVDb250ZW50RXh0ZW5zaW9uKGlk ZW50aWZpZXIsIFN0cmluZzo6ZnJvbVVURjgodXNlckNvbnRlbnRGaWx0ZXItPnByaXYtPmpzb25T b3VyY2UpLAorICAgICAgICAgICAgICAgICAgICBbdGFza10oUmVmUHRyPEFQSTo6VXNlckNvbnRl bnRFeHRlbnNpb24+IHVzZXJDb250ZW50RXh0ZW5zaW9uLCBzdGQ6OmVycm9yX2NvZGUgZXJyb3Ip IHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGlmIChlcnJvcikgeworICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGdfdGFza19yZXR1cm5fbmV3X2Vycm9yKGFkb3B0R1JlZih0YXNrKS5nZXQo KSwgV0VCS0lUX1VTRVJfQ09OVEVOVF9FUlJPUiwgV0VCS0lUX1VTRVJfQ09OVEVOVF9FUlJPUl9G SUxURVJfQ09NUElMQVRJT05fRkFJTEVELCAiJXMiLCBlcnJvci5tZXNzYWdlKCkuY19zdHIoKSk7 CisgICAgICAgICAgICAgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAgICAg ICAgICAgIFdlYktpdFVzZXJDb250ZW50RmlsdGVyKiB1c2VyQ29udGVudEZpbHRlciA9IFdFQktJ VF9VU0VSX0NPTlRFTlRfRklMVEVSKGdfdGFza19nZXRfc291cmNlX29iamVjdCh0YXNrKSk7Cisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgdXNlckNvbnRlbnRGaWx0ZXItPnByaXYtPnVzZXJD b250ZW50RXh0ZW5zaW9uID0gdXNlckNvbnRlbnRFeHRlbnNpb247CisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgdXNlckNvbnRlbnRGaWx0ZXItPnByaXYtPmpzb25Tb3VyY2UgPSAiIjsgLy8g VGhlIEpTT04gc291cmNlIGlzIG5vdCBuZWVkZWQgYW55bW9yZS4KKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICBnX3Rhc2tfcmV0dXJuX2Jvb2xlYW4oYWRvcHRHUmVmKHRhc2spLmdldCgpLCBU UlVFKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgfSk7 CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIFdlYktpdFVzZXJDb250ZW50 RmlsdGVyKiB1c2VyQ29udGVudEZpbHRlciA9IFdFQktJVF9VU0VSX0NPTlRFTlRfRklMVEVSKGdf dGFza19nZXRfc291cmNlX29iamVjdCh0YXNrKSk7CisgICAgICAgICAgICAgICAgdXNlckNvbnRl bnRGaWx0ZXItPnByaXYtPnVzZXJDb250ZW50RXh0ZW5zaW9uID0gdXNlckNvbnRlbnRFeHRlbnNp b247CisgICAgICAgICAgICAgICAgdXNlckNvbnRlbnRGaWx0ZXItPnByaXYtPmpzb25Tb3VyY2Ug PSAiIjsgLy8gVGhlIEpTT04gc291cmNlIGlzIG5vdCBuZWVkZWQgYW55bW9yZS4KKyAgICAgICAg ICAgICAgICBnX3Rhc2tfcmV0dXJuX2Jvb2xlYW4oYWRvcHRHUmVmKHRhc2spLmdldCgpLCBUUlVF KTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSk7Cit9CisKK3N0YXRpYyBnYm9vbGVhbiB1c2Vy Q29udGVudEZpbHRlckluaXRGaW5pc2goR0FzeW5jSW5pdGFibGUqIGluaXRhYmxlLCBHQXN5bmNS ZXN1bHQqIHJlc3VsdCwgR0Vycm9yKiogZXJyb3IpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2Zh aWwoZ190YXNrX2lzX3ZhbGlkKHJlc3VsdCwgaW5pdGFibGUpLCBGQUxTRSk7CisgICAgcmV0dXJu IGdfdGFza19wcm9wYWdhdGVfYm9vbGVhbihHX1RBU0socmVzdWx0KSwgZXJyb3IpOworfQorCitz dGF0aWMgdm9pZCB3ZWJraXRfdXNlcl9jb250ZW50X2ZpbHRlcl9pbnRlcmZhY2VfaW5pdChHQXN5 bmNJbml0YWJsZUlmYWNlKiBpZmFjZSkKK3sKKyAgICBpZmFjZS0+aW5pdF9hc3luYyA9IHVzZXJD b250ZW50RmlsdGVySW5pdEFzeW5jOworICAgIGlmYWNlLT5pbml0X2ZpbmlzaCA9IHVzZXJDb250 ZW50RmlsdGVySW5pdEZpbmlzaDsKK30KKworc3RhdGljIHZvaWQgd2Via2l0X3VzZXJfY29udGVu dF9maWx0ZXJfY2xhc3NfaW5pdChXZWJLaXRVc2VyQ29udGVudEZpbHRlckNsYXNzKiBrbGFzcykK K3sKK30KKworV0VCS0lUX0RFRklORV9UWVBFX1dJVEhfQ09ERSgKKyAgICBXZWJLaXRVc2VyQ29u dGVudEZpbHRlciwgd2Via2l0X3VzZXJfY29udGVudF9maWx0ZXIsIEdfVFlQRV9PQkpFQ1QsCisg ICAgR19JTVBMRU1FTlRfSU5URVJGQUNFKEdfVFlQRV9BU1lOQ19JTklUQUJMRSwgd2Via2l0X3Vz ZXJfY29udGVudF9maWx0ZXJfaW50ZXJmYWNlX2luaXQpKQorCisvKioKKyAqIHdlYmtpdF91c2Vy X2NvbnRlbnRfZmlsdGVyX25ld19hc3luYzoKKyAqIEBqc29uX3NvdXJjZTogU291cmNlIHRleHQg aW4gSlNPTiBmb3JtYXQgY29udGFpbmluZyBmaWx0ZXJpbmcgcnVsZXMuCisgKiBAY2FsbGJhY2s6 IChzY29wZSBhc3luYyk6IEEgI0dBc3luY1JlYWR5Q2FsbGJhY2sgdG8gY2FsbCB3aGVuIHRoZSBv YmplY3QgY3JlYXRpb24gaGFzIGZpbmlzaGVkLgorICogQHVzZXJfZGF0YTogKGNsb3N1cmUpOiBE YXRhIHRvIHBhc3MgdG8gdGhlIGNhbGxiYWNrIGZ1bmN0aW9uLgorICoKKyAqIFN0YXJ0cyBhc3lu Y2hyb25vdXMgaW5zdGFudGlhdGlvbiBvZiBhbiB1c2VyIGNvbnRlbnQgZmlsdGVyLiBDb250ZW50 CisgKiBmaWx0ZXJzIG11c3QgYmUgcHJvdmlkZWQgYXMgYSBzZXQgb2YgcnVsZXMgaW4gSlNPTiBm b3JtYXQsIGFuZCBhcmUgY29tcGlsZWQKKyAqIGJlZm9yZSB0aGV5IGNhbiBiZSB1c2VkLiBUaGUg Y29tcGlsYXRpb24gcHJvY2VzcyBjYW4gYmUgbGVuZ3RoeSwgYW5kIHRodXMKKyAqIGl0IGlzIGRv bmUgYXN5bmNocm9ub3VzbHkuCisgKgorICogQ29tcGlsZWQgcnVsZSBzZXRzIGFyZSBjYWNoZWQg YW5kIHJldXNlZCB3aGVuZXZlciBwb3NzaWJsZTogYSBTSEExIGRpZ2VzdAorICogb2YgdGhlIEBq c29uX3NvdXJjZSBpcyBjYWxjdWxhdGVkLCBhbmQgaWYgdGhlIHNhbWUgc291cmNlIHdhcyBwcmV2 aW91c2x5CisgKiBjb21waWxlZCAqYW5kKiB0aGVyZSBpcyBhbiB1c2VhYmxlIGNvbXBpbGVkIHZl cnNpb24gb2YgaXQgaW4gdGhlIGNhY2hlLCBpdAorICogd2lsbCBiZSB1c2VkLiBPdGhlcndpc2Ug dGhlIHByb3ZpZGVkIEBqc29uX3NvdXJjZSB3aWxsIGJlIGNvbXBpbGVkIGFuZAorICogc3RvcmVk IGluIHRoZSBjYWNoZS4KKyAqCisgKiBPbmNlIHRoZSBmaWx0ZXIgaXMgcmVhZHkgdG8gYmUgdXNl ZCB0aGUgcHJvdmlkZWQgQGNhbGxiYWNrIHdpbGwgYmUgaW52b2tlZCwKKyAqIHBhc3NpbmcgdGhl IEB1c2VyX2RhdGEgdG8gaXQuIFRoZSBAY2FsbGJhY2sgaXMgYWx3YXlzIGludm9rZWQgYXN5bmNo cm9ub3VzbHkKKyAqIGF0IGEgbGF0ZXIgdGltZSwgcmVnYXJkbGVzcyBvZiBhIGNvbXBpbGVkIHZl cnNpb24gYmVpbmcgYXZhaWxhYmxlIGluIHRoZQorICogY2FjaGUuIFRoZSBAY2FsbGJhY2sgbXVz dCB1c2Ugd2Via2l0X3VzZXJfY29udGVudF9maWx0ZXJfbmV3X2ZpbmlzaCgpIHRvCisgKiBvYnRh aW4gdGhlIHJlYWR5LXRvLXVzZSAjV2ViS2l0VXNlckNvbnRlbnRGaWx0ZXIuCisgKgorICogU2Vl IHdlYmtpdF91c2VyX2NvbnRlbnRfZmlsdGVyX25ld19maW5pc2goKS4KKyAqCisgKiBTaW5jZTog Mi4xNAorICovCit2b2lkIHdlYmtpdF91c2VyX2NvbnRlbnRfZmlsdGVyX25ld19hc3luYyhjb25z dCBnY2hhcioganNvblNvdXJjZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIEdBc3luY1JlYWR5Q2FsbGJhY2sgY2FsbGJhY2ssCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBncG9pbnRlciB1c2VyRGF0YSkgeworICAgIGdfcmV0dXJu X2lmX2ZhaWwoanNvblNvdXJjZSk7IFdlYktpdFVzZXJDb250ZW50RmlsdGVyKiB1c2VyQ29udGVu dEZpbHRlciA9CisgICAgICAgIFdFQktJVF9VU0VSX0NPTlRFTlRfRklMVEVSKGdfb2JqZWN0X25l dyhXRUJLSVRfVFlQRV9VU0VSX0NPTlRFTlRfRklMVEVSLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgbnVsbHB0cikpOworICAgIHVzZXJDb250ZW50Rmls dGVyLT5wcml2LT5qc29uU291cmNlID0ganNvblNvdXJjZTsKKyAgICBnX2FzeW5jX2luaXRhYmxl X2luaXRfYXN5bmMoR19BU1lOQ19JTklUQUJMRSh1c2VyQ29udGVudEZpbHRlciksIDAsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIG51bGxwdHIsIGNhbGxiYWNrLCB1c2VyRGF0YSk7 CisgICAgZ19vYmplY3RfdW5yZWYodXNlckNvbnRlbnRGaWx0ZXIpOyAgLy8gUGFzc2VkIG93bmVy c2hpcCB0byBhc3luYyBjYWxsLgorfQorCisvKioKKyAqIHdlYmtpdF91c2VyX2NvbnRlbnRfZmls dGVyX25ld19maW5pc2g6CisgKiBAaW5pdGFibGU6IFRoZSAjR0FzeW5jSW5pdGFibGUgcGFzc2Vk IHRvIHRoZSBjb21wbGV0aW9uIGNhbGxiYWNrLgorICogQHJlc3VsdDogVGhlICNHQXN5bmNSZXN1 bHQgcGFzc2VkIHRvIHRoZSBjb21wbGV0aW9uIGNhbGxiYWNrLgorICogQGVycm9yOiAoYWxsb3ct bm9uZSk6IEEgI0dFcnJvciBsb2NhdGlvbiB0byBzdG9yZSB0aGUgZXJyb3Igb2NjdXJpbmcsIG9y ICVOVUxMIHRvIGlnbm9yZS4KKyAqCisgKiBGaW5pc2hlcyBhc3luY2hyb25vdXMgaW5pdGlhbGl6 YXRpb24gb2YgYW4gdXNlciBjb250ZW50IGZpbHRlciBhbmQgcmV0dXJucworICogdGhlIHJlc3Vs dGluZyBvYmplY3QuCisgKgorICogU2VlIHdlYmtpdF91c2VyX2NvbnRlbnRfZmlsdGVyX25ld19h c3luYygpLgorICoKKyAqIFJldHVybnMgYSAjV2ViS2l0VXNlckNvbnRlbnRGaWx0ZXIgaWYgc3Vj Y2Vzc2Z1bC4gSWYgYW4gZXJyb3IgaGFzIG9jY3VyZWQsCisgKiB0aGlzIGZ1bmN0aW9uIHdpbGwg cmV0dXJuICVOVUxMIGFuZCBzZXQgQGVycm9yIGFwcHJvcHJpYXRlbHkgaWYgcHJlc2VudC4KKyAq CisgKiBTaW5jZTogMi4xNAorICovCitXZWJLaXRVc2VyQ29udGVudEZpbHRlciogd2Via2l0X3Vz ZXJfY29udGVudF9maWx0ZXJfbmV3X2ZpbmlzaChHQXN5bmNJbml0YWJsZSogaW5pdGFibGUsIEdB c3luY1Jlc3VsdCAqcmVzdWx0LCBHRXJyb3IgKiplcnJvcikKK3sKKyAgICBpZiAoZ19hc3luY19p bml0YWJsZV9pbml0X2ZpbmlzaChpbml0YWJsZSwgcmVzdWx0LCBlcnJvcikpIHsKKyAgICAgICAg cmV0dXJuIFdFQktJVF9VU0VSX0NPTlRFTlRfRklMVEVSKGdfb2JqZWN0X3JlZihpbml0YWJsZSkp OworICAgIH0gZWxzZSB7CisgICAgICAgIHJldHVybiBudWxscHRyOworICAgIH0KK30KKworQVBJ OjpVc2VyQ29udGVudEV4dGVuc2lvbiYgd2Via2l0VXNlckNvbnRlbnRGaWx0ZXJHZXRVc2VyQ29u dGVudEV4dGVuc2lvbihXZWJLaXRVc2VyQ29udGVudEZpbHRlciAqdXNlckNvbnRlbnRGaWx0ZXIp Cit7CisgICAgcmV0dXJuICp1c2VyQ29udGVudEZpbHRlci0+cHJpdi0+dXNlckNvbnRlbnRFeHRl bnNpb247Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRVc2VyQ29udGVudC5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2Vi S2l0VXNlckNvbnRlbnQuaAppbmRleCBjM2YxZWQ1Li4yMDkyYzRmIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRVc2VyQ29udGVudC5oCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFVzZXJDb250ZW50LmgKQEAgLTI1 LDYgKzI1LDcgQEAKICNkZWZpbmUgV2ViS2l0VXNlckNvbnRlbnRfaAogCiAjaW5jbHVkZSA8Z2xp Yi1vYmplY3QuaD4KKyNpbmNsdWRlIDxnaW8vZ2lvLmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJL aXREZWZpbmVzLmg+CiAKIEdfQkVHSU5fREVDTFMKQEAgLTEyMCw2ICsxMjEsNDMgQEAgd2Via2l0 X3VzZXJfc2NyaXB0X25ldyAgICAgICAgICAgKGNvbnN0IGdjaGFyICAgICAgICAgICAgICAgICAg ICAqc291cmNlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGdjaGFy KiBjb25zdCAgICAgICAgICAgICAqd2hpdGVsaXN0LAogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGNvbnN0IGdjaGFyKiBjb25zdCAgICAgICAgICAgICAqYmxhY2tsaXN0KTsKIAor I2RlZmluZSBXRUJLSVRfVFlQRV9VU0VSX0NPTlRFTlRfRklMVEVSICAgICAgICAgICAgKHdlYmtp dF91c2VyX2NvbnRlbnRfZmlsdGVyX2dldF90eXBlKCkpCisjZGVmaW5lIFdFQktJVF9VU0VSX0NP TlRFTlRfRklMVEVSKG9iaikgICAgICAgICAgICAoR19UWVBFX0NIRUNLX0lOU1RBTkNFX0NBU1Qo KG9iaiksIFdFQktJVF9UWVBFX1VTRVJfQ09OVEVOVF9GSUxURVIsIFdlYktpdFVzZXJDb250ZW50 RmlsdGVyKSkKKyNkZWZpbmUgV0VCS0lUX0lTX1VTRVJfQ09OVEVOVF9GSUxURVIob2JqKSAgICAg ICAgIChHX1RZUEVfQ0hFQ0tfSU5TVEFOQ0VfVFlQRSgob2JqKSwgV0VCS0lUX1RZUEVfVVNFUl9D T05URU5UX0ZJTFRFUikpCisjZGVmaW5lIFdFQktJVF9VU0VSX0NPTlRFTlRfRklMVEVSX0NMQVNT KGtsYXNzKSAgICAoR19UWVBFX0NIRUNLX0NMQVNTX0NBU1QoKGtsYXNzKSwgIFdFQktJVF9UWVBF X1VTRVJfQ09OVEVOVF9GSUxURVIsIFdlYktpdFVzZXJDb250ZW50RmlsdGVyQ2xhc3MpKQorI2Rl ZmluZSBXRUJLSVRfSVNfVVNFUl9DT05URU5UX0ZJTFRFUl9DTEFTUyhrbGFzcykgKEdfVFlQRV9D SEVDS19DTEFTU19UWVBFKChrbGFzcyksICBXRUJLSVRfVFlQRV9VU0VSX0NPTlRFTlRfRklMVEVS KSkKKyNkZWZpbmUgV0VCS0lUX1VTRVJfQ09OVEVOVF9GSUxURVJfR0VUX0NMQVNTKG9iaikgIChH X1RZUEVfSU5TVEFOQ0VfR0VUX0NMQVNTKChvYmopLCAgV0VCS0lUX1RZUEVfVVNFUl9DT05URU5U X0ZJTFRFUiwgV2ViS2l0VXNlckNvbnRlbnRGaWx0ZXJDbGFzcykpCisKK3R5cGVkZWYgc3RydWN0 IF9XZWJLaXRVc2VyQ29udGVudEZpbHRlciAgICAgICAgV2ViS2l0VXNlckNvbnRlbnRGaWx0ZXI7 Cit0eXBlZGVmIHN0cnVjdCBfV2ViS2l0VXNlckNvbnRlbnRGaWx0ZXJDbGFzcyAgIFdlYktpdFVz ZXJDb250ZW50RmlsdGVyQ2xhc3M7Cit0eXBlZGVmIHN0cnVjdCBfV2ViS2l0VXNlckNvbnRlbnRG aWx0ZXJQcml2YXRlIFdlYktpdFVzZXJDb250ZW50RmlsdGVyUHJpdmF0ZTsKKworCitzdHJ1Y3Qg X1dlYktpdFVzZXJDb250ZW50RmlsdGVyIHsKKyAgICBHT2JqZWN0IHBhcmVudDsKKworICAgIC8q PCBwcml2YXRlID4qLworICAgIFdlYktpdFVzZXJDb250ZW50RmlsdGVyUHJpdmF0ZSAqcHJpdjsK K307CisKK3N0cnVjdCBfV2ViS2l0VXNlckNvbnRlbnRGaWx0ZXJDbGFzcyB7CisgICAgR09iamVj dENsYXNzIHBhcmVudF9jbGFzczsKKworICAgIHZvaWQgKCpfd2Via2l0X3Jlc2VydmVkMCkgKHZv aWQpOworICAgIHZvaWQgKCpfd2Via2l0X3Jlc2VydmVkMSkgKHZvaWQpOworICAgIHZvaWQgKCpf d2Via2l0X3Jlc2VydmVkMikgKHZvaWQpOworICAgIHZvaWQgKCpfd2Via2l0X3Jlc2VydmVkMykg KHZvaWQpOworfTsKKworV0VCS0lUX0FQSSBHVHlwZQord2Via2l0X3VzZXJfY29udGVudF9maWx0 ZXJfZ2V0X3R5cGUgKHZvaWQpOworCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF91c2VyX2NvbnRl bnRfZmlsdGVyX25ld19hc3luYyAgKGNvbnN0IGdjaGFyICpqc29uX3NvdXJjZSwgR0FzeW5jUmVh ZHlDYWxsYmFjayBjYWxsYmFjaywgZ3BvaW50ZXIgdXNlcl9kYXRhKTsKKworV0VCS0lUX0FQSSBX ZWJLaXRVc2VyQ29udGVudEZpbHRlcioKK3dlYmtpdF91c2VyX2NvbnRlbnRfZmlsdGVyX25ld19m aW5pc2ggKEdBc3luY0luaXRhYmxlICppbml0YWJsZSwgR0FzeW5jUmVzdWx0ICpyZXN1bHQsIEdF cnJvciAqKmVycm9yKTsKKwogR19FTkRfREVDTFMKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRVc2VyQ29udGVudE1hbmFnZXIuY3Bw IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0VXNlckNvbnRlbnRNYW5h Z2VyLmNwcAppbmRleCBkZjc4YjgyLi44ZGI2ZDQzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRVc2VyQ29udGVudE1hbmFnZXIuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFVzZXJDb250ZW50TWFuYWdlci5j cHAKQEAgLTIxLDYgKzIxLDcgQEAKICNpbmNsdWRlICJXZWJLaXRVc2VyQ29udGVudE1hbmFnZXIu aCIKIAogI2luY2x1ZGUgIkFQSVNlcmlhbGl6ZWRTY3JpcHRWYWx1ZS5oIgorI2luY2x1ZGUgIkFQ SVVzZXJDb250ZW50RXh0ZW5zaW9uU3RvcmUuaCIKICNpbmNsdWRlICJXZWJLaXRKYXZhc2NyaXB0 UmVzdWx0UHJpdmF0ZS5oIgogI2luY2x1ZGUgIldlYktpdFByaXZhdGUuaCIKICNpbmNsdWRlICJX ZWJLaXRVc2VyQ29udGVudE1hbmFnZXJQcml2YXRlLmgiCkBAIC0yNjAsNiArMjYxLDQyIEBAIHZv aWQgd2Via2l0X3VzZXJfY29udGVudF9tYW5hZ2VyX3VucmVnaXN0ZXJfc2NyaXB0X21lc3NhZ2Vf aGFuZGxlcihXZWJLaXRVc2VyQ29uCiAgICAgbWFuYWdlci0+cHJpdi0+dXNlckNvbnRlbnRDb250 cm9sbGVyLT5yZW1vdmVVc2VyTWVzc2FnZUhhbmRsZXJGb3JOYW1lKFN0cmluZzo6ZnJvbVVURjgo bmFtZSksIEFQSTo6VXNlckNvbnRlbnRXb3JsZDo6bm9ybWFsV29ybGQoKSk7CiB9CiAKKy8qKgor ICogd2Via2l0X3VzZXJfY29udGVudF9tYW5hZ2VyX2FkZF9jb250ZW50X2ZpbHRlcjoKKyAqIEBt YW5hZ2VyOiBBICNXZWJLaXRVc2VyQ29udGVudE1hbmFnZXIKKyAqIEBmaWx0ZXI6IEEgI1dlYktp dFVzZXJDb250ZW50RmlsdGVyCisgKgorICogQWRkcyBhICNXZWJLaXRVc2VyQ29udGVudEZpbHRl ciB0byB0aGUgZ2l2ZW4gI1dlYktpdFVzZXJDb250ZW50TWFuYWdlci4KKyAqIFRoZSBzYW1lICNX ZWJLaXRVc2VyQ29udGVudEZpbHRlciBjYW4gYmUgcmV1c2VkIHdpdGggbXVsdGlwbGUKKyAqICNX ZWJLaXRVc2VyQ29udGVudE1hbmFnZXIgaW5zdGFuY2VzCisgKgorICogU2VlIGFsc28gd2Via2l0 X3VzZXJfY29udGVudF9tYW5hZ2VyX3JlbW92ZV9hbGxfY29udGVudF9maWx0ZXJzKCkKKyAqCisg KiBTaW5jZTogMi4xMgorICovCit2b2lkIHdlYmtpdF91c2VyX2NvbnRlbnRfbWFuYWdlcl9hZGRf Y29udGVudF9maWx0ZXIoV2ViS2l0VXNlckNvbnRlbnRNYW5hZ2VyKiBtYW5hZ2VyLCBXZWJLaXRV c2VyQ29udGVudEZpbHRlciogZmlsdGVyKQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lU X0lTX1VTRVJfQ09OVEVOVF9NQU5BR0VSKG1hbmFnZXIpKTsKKyAgICBnX3JldHVybl9pZl9mYWls KGZpbHRlcik7CisgICAgbWFuYWdlci0+cHJpdi0+dXNlckNvbnRlbnRDb250cm9sbGVyLT5hZGRV c2VyQ29udGVudEV4dGVuc2lvbih3ZWJraXRVc2VyQ29udGVudEZpbHRlckdldFVzZXJDb250ZW50 RXh0ZW5zaW9uKGZpbHRlcikpOworfQorCisvKioKKyAqIHdlYmtpdF91c2VyX2NvbnRlbnRfbWFu YWdlcl9yZW1vdmVfYWxsX2NvbnRlbnRfZmlsdGVyczoKKyAqIEBtYW5hZ2VyOiBBICNXZWJLaXRV c2VyQ29udGVudE1hbmFnZXIKKyAqCisgKiBSZW1vdmVzIGFsbCB0aGUgdXNlciBjb250ZW50IGZp bHRlcnMgZnJvbSB0aGUgZ2l2ZW4gI1dlYktpdFVzZXJDb250ZW50TWFuYWdlci4KKyAqCisgKiBT ZWUgYWxzbyB3ZWJraXRfdXNlcl9jb250ZW50X21hbmFnZXJfYWRkX2NvbnRlbnRfZmlsdGVyKCkK KyAqCisgKiBTaW5jZTogMi4xMgorICovCit2b2lkIHdlYmtpdF91c2VyX2NvbnRlbnRfbWFuYWdl cl9yZW1vdmVfYWxsX2NvbnRlbnRfZmlsdGVycyhXZWJLaXRVc2VyQ29udGVudE1hbmFnZXIqIG1h bmFnZXIpCit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfVVNFUl9DT05URU5UX01B TkFHRVIobWFuYWdlcikpOworICAgIG1hbmFnZXItPnByaXYtPnVzZXJDb250ZW50Q29udHJvbGxl ci0+cmVtb3ZlQWxsVXNlckNvbnRlbnRFeHRlbnNpb25zKCk7Cit9CisKIFdlYlVzZXJDb250ZW50 Q29udHJvbGxlclByb3h5KiB3ZWJraXRVc2VyQ29udGVudE1hbmFnZXJHZXRVc2VyQ29udGVudENv bnRyb2xsZXJQcm94eShXZWJLaXRVc2VyQ29udGVudE1hbmFnZXIqIG1hbmFnZXIpCiB7CiAgICAg cmV0dXJuIG1hbmFnZXItPnByaXYtPnVzZXJDb250ZW50Q29udHJvbGxlci5nZXQoKTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFVzZXJDb250ZW50 TWFuYWdlci5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0VXNlckNv bnRlbnRNYW5hZ2VyLmgKaW5kZXggODZkMjRhMS4uNGE0MGEzZSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0VXNlckNvbnRlbnRNYW5hZ2VyLmgKKysr IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0VXNlckNvbnRlbnRNYW5h Z2VyLmgKQEAgLTQwLDYgKzQwLDcgQEAgR19CRUdJTl9ERUNMUwogdHlwZWRlZiBzdHJ1Y3QgX1dl YktpdFVzZXJDb250ZW50TWFuYWdlciAgICAgICAgV2ViS2l0VXNlckNvbnRlbnRNYW5hZ2VyOwog dHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFVzZXJDb250ZW50TWFuYWdlckNsYXNzICAgV2ViS2l0VXNl ckNvbnRlbnRNYW5hZ2VyQ2xhc3M7CiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0VXNlckNvbnRlbnRN YW5hZ2VyUHJpdmF0ZSBXZWJLaXRVc2VyQ29udGVudE1hbmFnZXJQcml2YXRlOwordHlwZWRlZiBz dHJ1Y3QgX1dlYktpdFVzZXJDb250ZW50RmlsdGVyICAgICAgICAgV2ViS2l0VXNlckNvbnRlbnRG aWx0ZXI7CiAKIAogc3RydWN0IF9XZWJLaXRVc2VyQ29udGVudE1hbmFnZXIgewpAQCAtODUsNiAr ODYsMTMgQEAgd2Via2l0X3VzZXJfY29udGVudF9tYW5hZ2VyX2FkZF9zY3JpcHQgICAgICAgICAg ICAgIChXZWJLaXRVc2VyQ29udGVudE1hbmFnZXIgKm0KIFdFQktJVF9BUEkgdm9pZAogd2Via2l0 X3VzZXJfY29udGVudF9tYW5hZ2VyX3JlbW92ZV9hbGxfc2NyaXB0cyAgICAgIChXZWJLaXRVc2Vy Q29udGVudE1hbmFnZXIgKm1hbmFnZXIpOwogCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF91c2Vy X2NvbnRlbnRfbWFuYWdlcl9hZGRfY29udGVudF9maWx0ZXIgICAgICAgICAoV2ViS2l0VXNlckNv bnRlbnRNYW5hZ2VyICptYW5hZ2VyLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBXZWJLaXRVc2VyQ29udGVudEZpbHRlciAgKmZpbHRlcik7 CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X3VzZXJfY29udGVudF9tYW5hZ2VyX3JlbW92ZV9h bGxfY29udGVudF9maWx0ZXJzIChXZWJLaXRVc2VyQ29udGVudE1hbmFnZXIgKm1hbmFnZXIpOwor CiBHX0VORF9ERUNMUwogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFVzZXJDb250ZW50UHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0VXNlckNvbnRlbnRQcml2YXRlLmgKaW5kZXggNDQ0ZTJj YS4uM2Q2ZDc0MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsv V2ViS2l0VXNlckNvbnRlbnRQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L0FQSS9ndGsvV2ViS2l0VXNlckNvbnRlbnRQcml2YXRlLmgKQEAgLTIwLDEzICsyMCwxNiBAQAog I2lmbmRlZiBXZWJLaXRVc2VyQ29udGVudFByaXZhdGVfaAogI2RlZmluZSBXZWJLaXRVc2VyQ29u dGVudFByaXZhdGVfaAogCisjaW5jbHVkZSAiQVBJVXNlckNvbnRlbnRFeHRlbnNpb24uaCIKICNp bmNsdWRlICJBUElVc2VyU2NyaXB0LmgiCiAjaW5jbHVkZSAiQVBJVXNlclN0eWxlU2hlZXQuaCIK ICNpbmNsdWRlICJXZWJLaXRVc2VyQ29udGVudC5oIgogI2luY2x1ZGUgPFdlYkNvcmUvVXNlclNj cmlwdC5oPgogI2luY2x1ZGUgPFdlYkNvcmUvVXNlclN0eWxlU2hlZXQuaD4KKyNpbmNsdWRlIDxX ZWJDb3JlL0NvbnRlbnRFeHRlbnNpb24uaD4KIAogQVBJOjpVc2VyU2NyaXB0JiB3ZWJraXRVc2Vy U2NyaXB0R2V0VXNlclNjcmlwdChXZWJLaXRVc2VyU2NyaXB0Kik7CiBBUEk6OlVzZXJTdHlsZVNo ZWV0JiB3ZWJraXRVc2VyU3R5bGVTaGVldEdldFVzZXJTdHlsZVNoZWV0KFdlYktpdFVzZXJTdHls ZVNoZWV0Kik7CitBUEk6OlVzZXJDb250ZW50RXh0ZW5zaW9uJiB3ZWJraXRVc2VyQ29udGVudEZp bHRlckdldFVzZXJDb250ZW50RXh0ZW5zaW9uKFdlYktpdFVzZXJDb250ZW50RmlsdGVyICp1c2Vy Q29udGVudEZpbHRlcik7CiAKICNlbmRpZiAvLyBXZWJLaXRVc2VyQ29udGVudFByaXZhdGVfaApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQy Z3RrLTQuMC1zZWN0aW9ucy50eHQgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9k b2NzL3dlYmtpdDJndGstNC4wLXNlY3Rpb25zLnR4dAppbmRleCAwMDJlZjMzLi5iZGZiYWJlIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJn dGstNC4wLXNlY3Rpb25zLnR4dAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0 ay9kb2NzL3dlYmtpdDJndGstNC4wLXNlY3Rpb25zLnR4dApAQCAtODMsNiArODMsNyBAQCB3ZWJr aXRfd2ViX2NvbnRleHRfZ2V0X3R5cGUKIDxUSVRMRT5XZWJLaXRVc2VyQ29udGVudDwvVElUTEU+ CiBXZWJLaXRVc2VyU3R5bGVTaGVldAogV2ViS2l0VXNlclNjcmlwdAorV2ViS2l0VXNlckNvbnRl bnRGaWx0ZXIKIFdlYktpdFVzZXJDb250ZW50SW5qZWN0ZWRGcmFtZXMKIFdlYktpdFVzZXJTdHls ZUxldmVsCiBXZWJLaXRVc2VyU2NyaXB0SW5qZWN0aW9uVGltZQpAQCAtOTIsMTQgKzkzLDE4IEBA IHdlYmtpdF91c2VyX3N0eWxlX3NoZWV0X25ldwogd2Via2l0X3VzZXJfc2NyaXB0X3JlZgogd2Vi a2l0X3VzZXJfc2NyaXB0X3VucmVmCiB3ZWJraXRfdXNlcl9zY3JpcHRfbmV3Cit3ZWJraXRfdXNl cl9jb250ZW50X2ZpbHRlcl9uZXdfYXN5bmMKK3dlYmtpdF91c2VyX2NvbnRlbnRfZmlsdGVyX25l d19maW5pc2gKIAogPFNVQlNFQ1RJT04gU3RhbmRhcmQ+CiBXRUJLSVRfVFlQRV9VU0VSX1NUWUxF X1NIRUVUCiBXRUJLSVRfVFlQRV9VU0VSX1NDUklQVAorV0VCS0lUX1RZUEVfVVNFUl9DT05URU5U X0ZJTFRFUgogCiA8U1VCU0VDVElPTiBQcml2YXRlPgogd2Via2l0X3VzZXJfc3R5bGVfc2hlZXRf Z2V0X3R5cGUKIHdlYmtpdF91c2VyX3NjcmlwdF9nZXRfdHlwZQord2Via2l0X3VzZXJfY29udGVu dF9maWx0ZXJfZ2V0X3R5cGUKIDwvU0VDVElPTj4KIAogPFNFQ1RJT04+CkBAIC0xMTMsMTcgKzEx OCwyNyBAQCB3ZWJraXRfdXNlcl9jb250ZW50X21hbmFnZXJfYWRkX3NjcmlwdAogd2Via2l0X3Vz ZXJfY29udGVudF9tYW5hZ2VyX3JlbW92ZV9hbGxfc2NyaXB0cwogd2Via2l0X3VzZXJfY29udGVu dF9tYW5hZ2VyX3JlZ2lzdGVyX3NjcmlwdF9tZXNzYWdlX2hhbmRsZXIKIHdlYmtpdF91c2VyX2Nv bnRlbnRfbWFuYWdlcl91bnJlZ2lzdGVyX3NjcmlwdF9tZXNzYWdlX2hhbmRsZXIKK3dlYmtpdF91 c2VyX2NvbnRlbnRfbWFuYWdlcl9hZGRfY29udGVudF9maWx0ZXIKK3dlYmtpdF91c2VyX2NvbnRl bnRfbWFuYWdlcl9yZW1vdmVfYWxsX2NvbnRlbnRfZmlsdGVycwogCiA8U1VCU0VDVElPTiBTdGFu ZGFyZD4KK1dFQktJVF9JU19VU0VSX0NPTlRFTlRfRklMVEVSCitXRUJLSVRfSVNfVVNFUl9DT05U RU5UX0ZJTFRFUl9DTEFTUwogV0VCS0lUX0lTX1VTRVJfQ09OVEVOVF9NQU5BR0VSCiBXRUJLSVRf SVNfVVNFUl9DT05URU5UX01BTkFHRVJfQ0xBU1MKK1dFQktJVF9UWVBFX1VTRVJfQ09OVEVOVF9G SUxURVIKIFdFQktJVF9UWVBFX1VTRVJfQ09OVEVOVF9NQU5BR0VSCitXRUJLSVRfVVNFUl9DT05U RU5UX0ZJTFRFUgorV0VCS0lUX1VTRVJfQ09OVEVOVF9GSUxURVJfQ0xBU1MKK1dFQktJVF9VU0VS X0NPTlRFTlRfRklMVEVSX0dFVF9DTEFTUwogV0VCS0lUX1VTRVJfQ09OVEVOVF9NQU5BR0VSCiBX RUJLSVRfVVNFUl9DT05URU5UX01BTkFHRVJfQ0xBU1MKIFdFQktJVF9VU0VSX0NPTlRFTlRfTUFO QUdFUl9HRVRfQ0xBU1MKK1dlYktpdFVzZXJDb250ZW50RmlsdGVyQ2xhc3MKIFdlYktpdFVzZXJD b250ZW50TWFuYWdlckNsYXNzCiAKIDxTVUJTRUNUSU9OIFByaXZhdGU+CitXZWJLaXRVc2VyQ29u dGVudEZpbHRlclByaXZhdGUKIFdlYktpdFVzZXJDb250ZW50TWFuYWdlclByaXZhdGUKIHdlYmtp dF91c2VyX2NvbnRlbnRfbWFuYWdlcl9nZXRfdHlwZQogPC9TRUNUSU9OPgpAQCAtODgwLDYgKzg5 NSw3IEBAIFdFQktJVF9ET1dOTE9BRF9FUlJPUgogV0VCS0lUX1BSSU5UX0VSUk9SCiBXRUJLSVRf SkFWQVNDUklQVF9FUlJPUgogV0VCS0lUX1NOQVBTSE9UX0VSUk9SCitXRUJLSVRfVVNFUl9DT05U RU5UX0VSUk9SCiBXZWJLaXROZXR3b3JrRXJyb3IKIFdlYktpdFBsdWdpbkVycm9yCiBXZWJLaXRQ b2xpY3lFcnJvcgpAQCAtODg3LDYgKzkwMyw3IEBAIFdlYktpdERvd25sb2FkRXJyb3IKIFdlYktp dFByaW50RXJyb3IKIFdlYktpdEphdmFzY3JpcHRFcnJvcgogV2ViS2l0U25hcHNob3RFcnJvcgor V2ViS2l0VXNlckNvbnRlbnRFcnJvcgogd2Via2l0X25ldHdvcmtfZXJyb3JfcXVhcmsKIHdlYmtp dF9wbHVnaW5fZXJyb3JfcXVhcmsKIHdlYmtpdF9wb2xpY3lfZXJyb3JfcXVhcmsKQEAgLTg5NCw2 ICs5MTEsNyBAQCB3ZWJraXRfZG93bmxvYWRfZXJyb3JfcXVhcmsKIHdlYmtpdF9wcmludF9lcnJv cl9xdWFyawogd2Via2l0X2phdmFzY3JpcHRfZXJyb3JfcXVhcmsKIHdlYmtpdF9zbmFwc2hvdF9l cnJvcl9xdWFyaword2Via2l0X3VzZXJfY29udGVudF9lcnJvcl9xdWFyawogPC9TRUNUSU9OPgog CiA8U0VDVElPTj4KZGlmZiAtLWdpdCBhL1NvdXJjZS9jbWFrZS9PcHRpb25zR1RLLmNtYWtlIGIv U291cmNlL2NtYWtlL09wdGlvbnNHVEsuY21ha2UKaW5kZXggYWFlOGZlOC4uNjFlYTQyMSAxMDA2 NDQKLS0tIGEvU291cmNlL2NtYWtlL09wdGlvbnNHVEsuY21ha2UKKysrIGIvU291cmNlL2NtYWtl L09wdGlvbnNHVEsuY21ha2UKQEAgLTE3Myw2ICsxNzMsNyBAQCBXRUJLSVRfT1BUSU9OX0RFRkFV TFRfUE9SVF9WQUxVRShFTkFCTEVfVVNFUlNFTEVDVF9BTEwgUFJJVkFURSBPTikKIFdFQktJVF9P UFRJT05fREVGQVVMVF9QT1JUX1ZBTFVFKEVOQUJMRV9VU0VSX01FU1NBR0VfSEFORExFUlMgUFJJ VkFURSBPTikKIFdFQktJVF9PUFRJT05fREVGQVVMVF9QT1JUX1ZBTFVFKEVOQUJMRV9WSURFT19U UkFDSyBQUklWQVRFIE9OKQogV0VCS0lUX09QVElPTl9ERUZBVUxUX1BPUlRfVkFMVUUoRU5BQkxF X1dFQkdMIFBSSVZBVEUgT04pCisjV0VCS0lUX09QVElPTl9ERUZBVUxUX1BPUlRfVkFMVUUoRU5B QkxFX0NPTlRFTlRfRklMVEVSSU5HIFBSSVZBVEUgT04pCiAKICMgRmluYWxpemUgdGhlIHZhbHVl IGZvciBhbGwgb3B0aW9ucy4gRG8gbm90IGF0dGVtcHQgdG8gdXNlIGFuIG9wdGlvbiBiZWZvcmUK ICMgdGhpcyBwb2ludCwgYW5kIGRvIG5vdCBhdHRlbXB0IHRvIGNoYW5nZSBhbnkgb3B0aW9uIGFm dGVyIHRoaXMgcG9pbnQuCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dl YktpdDJHdGsvVGVzdFdlYktpdFVzZXJDb250ZW50TWFuYWdlci5jcHAgYi9Ub29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYktpdFVzZXJDb250ZW50TWFuYWdlci5jcHAK aW5kZXggZTg0Y2I1Yy4uZDE4ZGRjZiAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0cy9XZWJLaXQyR3RrL1Rlc3RXZWJLaXRVc2VyQ29udGVudE1hbmFnZXIuY3BwCisrKyBiL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9UZXN0V2ViS2l0VXNlckNvbnRlbnRN YW5hZ2VyLmNwcApAQCAtNTQsNiArNTQsMTAgQEAgc3RhdGljIGNvbnN0IGNoYXIqIGtTdHlsZVNo ZWV0VGVzdFNjcmlwdFJlc3VsdCA9ICJib2xkIjsKIHN0YXRpYyBjb25zdCBjaGFyKiBrSW5qZWN0 ZWRTY3JpcHQgPSAiZG9jdW1lbnQud3JpdGUoJzxkaXYgaWQ9XCJpdGVtXCI+R2VuZXJhdGVkIGJ5 IGEgc2NyaXB0PC9kaXY+JykiOwogc3RhdGljIGNvbnN0IGNoYXIqIGtTY3JpcHRUZXN0U2NyaXB0 ID0gImRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdpdGVtJykuaW5uZXJUZXh0IjsKIHN0YXRpYyBj b25zdCBjaGFyKiBrU2NyaXB0VGVzdFNjcmlwdFJlc3VsdCA9ICJHZW5lcmF0ZWQgYnkgYSBzY3Jp cHQiOworc3RhdGljIGNvbnN0IGNoYXIqIGtDb250ZW50RmlsdGVyID0gIlt7XG4iCisgICAgIiAg XCJ0cmlnZ2VyXCI6IHsgXCJ1cmwtZmlsdGVyXCI6IFwiLipcIiB9LFxuIgorICAgICIgIFwiYWN0 aW9uXCI6IHsgXCJ0eXBlXCI6IFwiY3NzLWRpc3BsYXktbm9uZVwiLCBcInNlbGVjdG9yXCI6IFwi I3N0eWxlZEVsZW1lbnRcIiB9XG4iCisgICAgIn1dIjsKIAogc3RhdGljIHZvaWQgdGVzdFdlYlZp ZXdOZXdXaXRoVXNlckNvbnRlbnRNYW5hZ2VyKFRlc3QqIHRlc3QsIGdjb25zdHBvaW50ZXIpCiB7 CkBAIC0xMTMsNiArMTE3LDcgQEAgc3RhdGljIHZvaWQgcmVtb3ZlT2xkSW5qZWN0ZWRDb250ZW50 QW5kUmVzZXRMaXN0cyhXZWJLaXRVc2VyQ29udGVudE1hbmFnZXIqIHVzZXIKIHsKICAgICB3ZWJr aXRfdXNlcl9jb250ZW50X21hbmFnZXJfcmVtb3ZlX2FsbF9zdHlsZV9zaGVldHModXNlckNvbnRl bnRNYW5hZ2VyKTsKICAgICB3ZWJraXRfdXNlcl9jb250ZW50X21hbmFnZXJfcmVtb3ZlX2FsbF9z Y3JpcHRzKHVzZXJDb250ZW50TWFuYWdlcik7CisgICAgd2Via2l0X3VzZXJfY29udGVudF9tYW5h Z2VyX3JlbW92ZV9hbGxfY29udGVudF9maWx0ZXJzKHVzZXJDb250ZW50TWFuYWdlcik7CiAKICAg ICB3aGlsZSAoKndoaXRlbGlzdCkgewogICAgICAgICBnX2ZyZWUoKndoaXRlbGlzdCk7CkBAIC0y MTMsNiArMjE4LDEyIEBAIHN0YXRpYyB2b2lkIHRlc3RVc2VyQ29udGVudE1hbmFnZXJJbmplY3Rl ZFNjcmlwdChVc2VyQ29udGVudE1hbmFnZXJUZXN0KiB0ZXN0LCBnCiAgICAgcmVtb3ZlT2xkSW5q ZWN0ZWRDb250ZW50QW5kUmVzZXRMaXN0cyh0ZXN0LT5tX3VzZXJDb250ZW50TWFuYWdlci5nZXQo KSwgd2hpdGVsaXN0LCBibGFja2xpc3QpOwogfQogCitzdGF0aWMgdm9pZCB0ZXN0VXNlckNvbnRl bnRNYW5hZ2VyQ29udGVudEZpbHRlcihVc2VyQ29udGVudE1hbmFnZXJUZXN0KiB0ZXN0LCBnY29u c3Rwb2ludGVyKQoreworICAgIGNoYXIgKmR1bW15WzFdID0geyBudWxscHRyIH07CisgICAgcmVt b3ZlT2xkSW5qZWN0ZWRDb250ZW50QW5kUmVzZXRMaXN0cyh0ZXN0LT5tX3VzZXJDb250ZW50TWFu YWdlci5nZXQoKSwgZHVtbXksIGR1bW15KTsKK30KKwogY2xhc3MgVXNlclNjcmlwdE1lc3NhZ2VU ZXN0IDogcHVibGljIFVzZXJDb250ZW50TWFuYWdlclRlc3QgewogcHVibGljOgogICAgIE1BS0Vf R0xJQl9URVNUX0ZJWFRVUkUoVXNlclNjcmlwdE1lc3NhZ2VUZXN0KTsKQEAgLTM4MCw2ICszOTEs NyBAQCB2b2lkIGJlZm9yZUFsbCgpCiAgICAgVXNlckNvbnRlbnRNYW5hZ2VyVGVzdDo6YWRkKCJX ZWJLaXRVc2VyQ29udGVudE1hbmFnZXIiLCAiaW5qZWN0ZWQtc2NyaXB0IiwgdGVzdFVzZXJDb250 ZW50TWFuYWdlckluamVjdGVkU2NyaXB0KTsKICAgICBVc2VyU2NyaXB0TWVzc2FnZVRlc3Q6OmFk ZCgiV2ViS2l0VXNlckNvbnRlbnRNYW5hZ2VyIiwgInNjcmlwdC1tZXNzYWdlLXJlY2VpdmVkIiwg dGVzdFVzZXJDb250ZW50TWFuYWdlclNjcmlwdE1lc3NhZ2VSZWNlaXZlZCk7CiAgICAgVXNlclNj cmlwdE1lc3NhZ2VUZXN0OjphZGQoIldlYktpdFVzZXJDb250ZW50TWFuYWdlciIsICJzY3JpcHQt bWVzc2FnZS1mcm9tLWRvbS1iaW5kaW5ncyIsIHRlc3RVc2VyQ29udGVudE1hbmFnZXJTY3JpcHRN ZXNzYWdlRnJvbURPTUJpbmRpbmdzKTsKKyAgICBVc2VyQ29udGVudE1hbmFnZXJUZXN0OjphZGQo IldlYktpdFVzZXJDb250ZW50TWFuYWdlciIsICJjb250ZW50LWZpbHRlciIsIHRlc3RVc2VyQ29u dGVudE1hbmFnZXJDb250ZW50RmlsdGVyKTsKIH0KIAogdm9pZCBhZnRlckFsbCgpCg==