90772 2012-07-09 03:48:13 -0700 [EFL][WK2] ewk_context needs to route InjectedBundle messages correctly. 2014-02-04 02:20:26 -0800 1 1 1 Unclassified WebKit WebKit EFL 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 61838 1 d-r enmi.lee bunhere cdumez commit-queue enmi.lee gyuyoung.kim gyuyoung.kim kangil.han lucas.de.marchi naginenis ryuan.choi sw0524.lee tmpsantos oldest_to_newest 664779 0 d-r 2012-07-09 03:48:13 -0700 ewk context does not handle received messages from InjectedBundles, so that in many of the remaining ~400 test cases that fail (compared to DRT), we see a callstack like : STDERR: SHOULD NEVER BE REACHED STDERR: /fast/dominik/dev/WebKitGit_EFL/Tools/WebKitTestRunner/TestInvocation.cpp(322) : WebKit::WKRetainPtr<const void*> WTR::TestInvocation::didReceiveSynchronousMessageFromInjectedBundle(WKStringRef, WKTypeRef) STDERR: 1 0x410290 WTR::TestInvocation::didReceiveSynchronousMessageFromInjectedBundle(OpaqueWKString const*, void const*) STDERR: 2 0x40cf6b WTR::TestController::didReceiveSynchronousMessageFromInjectedBundle(OpaqueWKString const*, void const*) STDERR: 3 0x40cec6 WTR::TestController::didReceiveSynchronousMessageFromInjectedBundle(OpaqueWKContext const*, OpaqueWKString const*, void const*, void const**, void const*) STDERR: 4 0x7f6954ec7a68 WebKit::WebContextInjectedBundleClient::didReceiveSynchronousMessageFromInjectedBundle(WebKit::WebContext*, WTF::String const&, WebKit::APIObject*, WTF::RefPtr<WebKit::APIObject>&) So, the didReceiveSynchronousMessageFromInjectedBundle callback is falling through to TestController, while it should be routed by ewk context. If this is fixed, many of those test remaining test case issues can be addressed. 666491 1 enmi.lee 2012-07-11 01:06:41 -0700 (In reply to comment #0) > ewk context does not handle received messages from InjectedBundles, so that in many of the remaining ~400 test cases that fail (compared to DRT), we see a callstack like : > > STDERR: SHOULD NEVER BE REACHED > STDERR: /fast/dominik/dev/WebKitGit_EFL/Tools/WebKitTestRunner/TestInvocation.cpp(322) : WebKit::WKRetainPtr<const void*> WTR::TestInvocation::didReceiveSynchronousMessageFromInjectedBundle(WKStringRef, WKTypeRef) > STDERR: 1 0x410290 WTR::TestInvocation::didReceiveSynchronousMessageFromInjectedBundle(OpaqueWKString const*, void const*) > STDERR: 2 0x40cf6b WTR::TestController::didReceiveSynchronousMessageFromInjectedBundle(OpaqueWKString const*, void const*) > STDERR: 3 0x40cec6 WTR::TestController::didReceiveSynchronousMessageFromInjectedBundle(OpaqueWKContext const*, OpaqueWKString const*, void const*, void const**, void const*) > STDERR: 4 0x7f6954ec7a68 WebKit::WebContextInjectedBundleClient::didReceiveSynchronousMessageFromInjectedBundle(WebKit::WebContext*, WTF::String const&, WebKit::APIObject*, WTF::RefPtr<WebKit::APIObject>&) > > So, the didReceiveSynchronousMessageFromInjectedBundle callback is falling through to TestController, while it should be routed by ewk context. If this is fixed, many of those test remaining test case issues can be addressed. I think this WTR error is not about ewk_context. If we want to fix this issue, we have to implement TestController.cpp's WKRetainPtr<WKTypeRef> TestController::didReceiveSynchronousMessageFromInjectedBundle(WKStringRef messageName, WKTypeRef messageBody) for PLATFORM(EFL). 666497 2 cdumez 2012-07-11 01:16:54 -0700 (In reply to comment #1) > (In reply to comment #0) > > ewk context does not handle received messages from InjectedBundles, so that in many of the remaining ~400 test cases that fail (compared to DRT), we see a callstack like : > > > > STDERR: SHOULD NEVER BE REACHED > > STDERR: /fast/dominik/dev/WebKitGit_EFL/Tools/WebKitTestRunner/TestInvocation.cpp(322) : WebKit::WKRetainPtr<const void*> WTR::TestInvocation::didReceiveSynchronousMessageFromInjectedBundle(WKStringRef, WKTypeRef) > > STDERR: 1 0x410290 WTR::TestInvocation::didReceiveSynchronousMessageFromInjectedBundle(OpaqueWKString const*, void const*) > > STDERR: 2 0x40cf6b WTR::TestController::didReceiveSynchronousMessageFromInjectedBundle(OpaqueWKString const*, void const*) > > STDERR: 3 0x40cec6 WTR::TestController::didReceiveSynchronousMessageFromInjectedBundle(OpaqueWKContext const*, OpaqueWKString const*, void const*, void const**, void const*) > > STDERR: 4 0x7f6954ec7a68 WebKit::WebContextInjectedBundleClient::didReceiveSynchronousMessageFromInjectedBundle(WebKit::WebContext*, WTF::String const&, WebKit::APIObject*, WTF::RefPtr<WebKit::APIObject>&) > > > > So, the didReceiveSynchronousMessageFromInjectedBundle callback is falling through to TestController, while it should be routed by ewk context. If this is fixed, many of those test remaining test case issues can be addressed. > > I think this WTR error is not about ewk_context. > If we want to fix this issue, we have to implement TestController.cpp's > WKRetainPtr<WKTypeRef> TestController::didReceiveSynchronousMessageFromInjectedBundle(WKStringRef messageName, WKTypeRef messageBody) > for PLATFORM(EFL). Yes, I think it makes sense: WKRetainPtr<WKTypeRef> TestController::didReceiveSynchronousMessageFromInjectedBundle(WKStringRef messageName, WKTypeRef messageBody) { #if PLATFORM(MAC) || PLATFORM(QT) || PLATFORM(GTK) ... 666514 3 d-r 2012-07-11 01:35:28 -0700 (In reply to comment #2) > (In reply to comment #1) > > Yes, I think it makes sense: > > WKRetainPtr<WKTypeRef> TestController::didReceiveSynchronousMessageFromInjectedBundle(WKStringRef messageName, WKTypeRef messageBody) > { > #if PLATFORM(MAC) || PLATFORM(QT) || PLATFORM(GTK) > ... But also, if you look at the QtContext (or similarly named, can't recall) implementation, it talks about a different routing and actually handling those messages things in Context, and not letting it fall through to TestController::didReceiveSynchronousMessageFromInjectedBundle. So this implementation might not be used. 668590 4 enmi.lee 2012-07-12 21:24:52 -0700 (In reply to comment #3) > (In reply to comment #2) > > (In reply to comment #1) > > > > Yes, I think it makes sense: > > > > WKRetainPtr<WKTypeRef> TestController::didReceiveSynchronousMessageFromInjectedBundle(WKStringRef messageName, WKTypeRef messageBody) > > { > > #if PLATFORM(MAC) || PLATFORM(QT) || PLATFORM(GTK) > > ... > > But also, if you look at the QtContext (or similarly named, can't recall) implementation, it talks about a different routing and actually handling those messages things in Context, and not letting it fall through to TestController::didReceiveSynchronousMessageFromInjectedBundle. So this implementation might not be used. Yes, there is a different routing in the QtContext, but it is not used in the WebKitTestRunner. They are also using WKContext directly in the WebKitTestRunner, and they are using QtContext for Applications. So, we don't have to care about ewk_context for WTR. and, I will make the patch to handle injectedBundle in the ewk_context for "Applications". :) 672233 5 d-r 2012-07-18 04:19:24 -0700 (In reply to comment #4) > So, we don't have to care about ewk_context for WTR. > and, I will make the patch to handle injectedBundle in the ewk_context for "Applications". :) Great, thanks - any news here - when do you think you could provide a patch? 673263 6 ryuan.choi 2012-07-19 00:53:36 -0700 (In reply to comment #5) > (In reply to comment #4) > > > So, we don't have to care about ewk_context for WTR. > > and, I will make the patch to handle injectedBundle in the ewk_context for "Applications". :) > > Great, thanks - any news here - when do you think you could provide a patch? Kangil, could you share EventSenderProxyEfl ? 673275 7 kangil.han 2012-07-19 01:04:22 -0700 (In reply to comment #6) > Kangil, could you share EventSenderProxyEfl ? No problem. I will do it soon. :) 673285 8 enmi.lee 2012-07-19 01:12:24 -0700 (In reply to comment #5) > (In reply to comment #4) > > > So, we don't have to care about ewk_context for WTR. > > and, I will make the patch to handle injectedBundle in the ewk_context for "Applications". :) > > Great, thanks - any news here - when do you think you could provide a patch? I can make the patch for ewk_context's injectedBundle codes next week. I think I can create the new Bug for that, and Kangil will make the patch of EventSenderProxyEfl for this Bug. :) 673290 9 d-r 2012-07-19 01:18:21 -0700 (In reply to comment #8) > (In reply to comment #5) > > (In reply to comment #4) > > > > > So, we don't have to care about ewk_context for WTR. > > > and, I will make the patch to handle injectedBundle in the ewk_context for "Applications". :) > > > > Great, thanks - any news here - when do you think you could provide a patch? > > I can make the patch for ewk_context's injectedBundle codes next week. > I think I can create the new Bug for that, > and Kangil will make the patch of EventSenderProxyEfl for this Bug. :) Let's have injectedBundle routing patch on this bug, and create a new one for EventSenderProxyEfl. 680397 10 154894 enmi.lee 2012-07-27 03:32:57 -0700 Created attachment 154894 [WIP] patch for injected bundle client patch for injected bundle client which is a work in progress. 680417 11 154894 cdumez 2012-07-27 04:08:37 -0700 Comment on attachment 154894 [WIP] patch for injected bundle client View in context: https://bugs.webkit.org/attachment.cgi?id=154894&action=review > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:30 > +#include "ewk_context_injected_bundle_client.h" Should be _private.h > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:70 > + struct { Could you move this struct out of _Ewk_Context struct please? > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:72 > + void* userData; It is a good idea to add constructors, a default one and one that takes 2 parameters. > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:79 > + , messageFromInjectedBundle.callback(0) Would not be needed if you had a default constructor for that struct. > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:80 > + , messageFromInjectedBundle.userData(0) Ditto. > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:196 > + ewkContext->messageFromInjectedBundle.callback = callback; Would be nice to use a constructor for this. > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:222 > + } else { useless { > Source/WebKit2/UIProcess/API/efl/ewk_context.h:64 > + * Callback for didReceiveMessageFromInjectedBundle and didReceiveSynchronousMessageFromInjectedBundle for "ewk_context_message_from_injected_bundle_callback_set()" ? You use names that are not part of public API here. > Source/WebKit2/UIProcess/API/efl/ewk_context.h:67 > + * The return_data string will be freed in the WebKit side. "on WebKit side" > Source/WebKit2/UIProcess/API/efl/ewk_context.h:158 > +EAPI void ewk_context_message_post_to_injected_bundle(Ewk_Context* context, const char* name, const char* body); Stars on wrong side. > Source/WebKit2/UIProcess/API/efl/ewk_context.h:162 > + * Probably you should document that the client can pass NULL for callback to stop listening for messages. > Source/WebKit2/UIProcess/API/efl/ewk_context.h:164 > + * @param callback callback for received injected bundle message (may be @c NULL) > Source/WebKit2/UIProcess/API/efl/ewk_context.h:167 > +EAPI void ewk_context_message_from_injected_bundle_callback_set(Ewk_Context* context, Ewk_Context_Message_From_Injected_Bundle_Callback callback, void* user_data); Ditto. > Source/WebKit2/UIProcess/API/efl/ewk_context_injected_bundle_client.cpp:29 > + Ewk_Context* ewkContext = static_cast<Ewk_Context*>(const_cast<void*>(clientInfo)); It would be nice to define a static inline function that does this double casting for you. Check other clients for examples. > Source/WebKit2/UIProcess/API/efl/ewk_context_injected_bundle_client.cpp:30 > + ewkContextDidReceiveMessageFromInjectedBundle(ewkContext, messageName, messageBody, 0); So far we have be using underscore naming for private functions as well, not camel case. > Source/WebKit2/UIProcess/API/efl/ewk_context_injected_bundle_client.cpp:35 > + Ewk_Context* ewkContext = static_cast<Ewk_Context*>(const_cast<void*>(clientInfo)); Ditto. > Source/WebKit2/UIProcess/API/efl/ewk_context_injected_bundle_client.cpp:36 > + ewkContextDidReceiveMessageFromInjectedBundle(ewkContext, messageName, messageBody, returnData); Ditto. > Source/WebKit2/UIProcess/API/efl/ewk_context_injected_bundle_client.cpp:43 > + WKContextInjectedBundleClient injectedBundleClient = { Please assign callbacks after initialization and use memset to initialize all callbacks to 0. This will avoid compilation errors when new callbacks are added in the future. > Source/WebKit2/UIProcess/API/efl/ewk_context_injected_bundle_client.h:4 > + * This library is free software; you can redistribute it and/or I think Gyuyoung is encouraging people to use BSD license now. > Source/WebKit2/UIProcess/API/efl/ewk_context_injected_bundle_client.h:20 > +#ifndef ewk_view_injected_bundle_client_h Missing _private 971540 12 enmi.lee 2014-01-24 00:31:21 -0800 Thanks, I will rebase and update new patch for below comments! (In reply to comment #11) > (From update of attachment 154894 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=154894&action=review > > > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:30 > > +#include "ewk_context_injected_bundle_client.h" > > Should be _private.h > > > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:70 > > + struct { > > Could you move this struct out of _Ewk_Context struct please? > > > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:72 > > + void* userData; > > It is a good idea to add constructors, a default one and one that takes 2 parameters. > > > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:79 > > + , messageFromInjectedBundle.callback(0) > > Would not be needed if you had a default constructor for that struct. > > > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:80 > > + , messageFromInjectedBundle.userData(0) > > Ditto. > > > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:196 > > + ewkContext->messageFromInjectedBundle.callback = callback; > > Would be nice to use a constructor for this. > > > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:222 > > + } else { > > useless { > > > Source/WebKit2/UIProcess/API/efl/ewk_context.h:64 > > + * Callback for didReceiveMessageFromInjectedBundle and didReceiveSynchronousMessageFromInjectedBundle > > for "ewk_context_message_from_injected_bundle_callback_set()" ? You use names that are not part of public API here. > > > Source/WebKit2/UIProcess/API/efl/ewk_context.h:67 > > + * The return_data string will be freed in the WebKit side. > > "on WebKit side" > > > Source/WebKit2/UIProcess/API/efl/ewk_context.h:158 > > +EAPI void ewk_context_message_post_to_injected_bundle(Ewk_Context* context, const char* name, const char* body); > > Stars on wrong side. > > > Source/WebKit2/UIProcess/API/efl/ewk_context.h:162 > > + * > > Probably you should document that the client can pass NULL for callback to stop listening for messages. > > > Source/WebKit2/UIProcess/API/efl/ewk_context.h:164 > > + * @param callback callback for received injected bundle message > > (may be @c NULL) > > > Source/WebKit2/UIProcess/API/efl/ewk_context.h:167 > > +EAPI void ewk_context_message_from_injected_bundle_callback_set(Ewk_Context* context, Ewk_Context_Message_From_Injected_Bundle_Callback callback, void* user_data); > > Ditto. > > > Source/WebKit2/UIProcess/API/efl/ewk_context_injected_bundle_client.cpp:29 > > + Ewk_Context* ewkContext = static_cast<Ewk_Context*>(const_cast<void*>(clientInfo)); > > It would be nice to define a static inline function that does this double casting for you. Check other clients for examples. > > > Source/WebKit2/UIProcess/API/efl/ewk_context_injected_bundle_client.cpp:30 > > + ewkContextDidReceiveMessageFromInjectedBundle(ewkContext, messageName, messageBody, 0); > > So far we have be using underscore naming for private functions as well, not camel case. > > > Source/WebKit2/UIProcess/API/efl/ewk_context_injected_bundle_client.cpp:35 > > + Ewk_Context* ewkContext = static_cast<Ewk_Context*>(const_cast<void*>(clientInfo)); > > Ditto. > > > Source/WebKit2/UIProcess/API/efl/ewk_context_injected_bundle_client.cpp:36 > > + ewkContextDidReceiveMessageFromInjectedBundle(ewkContext, messageName, messageBody, returnData); > > Ditto. > > > Source/WebKit2/UIProcess/API/efl/ewk_context_injected_bundle_client.cpp:43 > > + WKContextInjectedBundleClient injectedBundleClient = { > > Please assign callbacks after initialization and use memset to initialize all callbacks to 0. This will avoid compilation errors when new callbacks are added in the future. > > > Source/WebKit2/UIProcess/API/efl/ewk_context_injected_bundle_client.h:4 > > + * This library is free software; you can redistribute it and/or > > I think Gyuyoung is encouraging people to use BSD license now. > > > Source/WebKit2/UIProcess/API/efl/ewk_context_injected_bundle_client.h:20 > > +#ifndef ewk_view_injected_bundle_client_h > > Missing _private 971542 13 222085 enmi.lee 2014-01-24 00:44:55 -0800 Created attachment 222085 Patch 971554 14 gyuyoung.kim 2014-01-24 01:46:07 -0800 (In reply to comment #0) > ewk context does not handle received messages from InjectedBundles, so that in many of the remaining ~400 test cases that fail (compared to DRT), we see a callstack like : Eunmi, can't we unskip failing tests by this patch ? 971556 15 222085 jinwoo7.song 2014-01-24 02:08:57 -0800 Comment on attachment 222085 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=222085&action=review > Source/WebKit2/ChangeLog:3 > + [EFL][WK2] ewk_context needs to route InjectedBundle Messages correctly s/Messages/messages > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:98 > + m_callbackForMessageFromInjectedBundle.callback = 0; Can't we use nullptr? > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:99 > + m_callbackForMessageFromInjectedBundle.userData = 0; ditto. > Source/WebKit2/UIProcess/API/efl/ewk_context.cpp:288 > + toEwkContext(clientInfo)->processReceivedMessageFromInjectedBundle(messageName, messageBody, 0); ditto. > Source/WebKit2/UIProcess/API/efl/ewk_context.h:125 > +typedef void (*Ewk_Context_Message_From_Injected_Bundle_Callback)(const char *name, const char *body, char **return_data, void *user_data); s/Ewk_Context_Message_From_Injected_Bundle_Callback/Ewk_Context_Message_From_Injected_Bundle_Cb 972282 16 enmi.lee 2014-01-26 16:50:54 -0800 (In reply to comment #14) > (In reply to comment #0) > > ewk context does not handle received messages from InjectedBundles, so that in many of the remaining ~400 test cases that fail (compared to DRT), we see a callstack like : > > Eunmi, can't we unskip failing tests by this patch ? That problem was fixed by Bug 91731. 972283 17 222085 enmi.lee 2014-01-26 16:57:45 -0800 Comment on attachment 222085 Patch Thank you :) I will update new patch for comments. 972285 18 222292 enmi.lee 2014-01-26 17:21:25 -0800 Created attachment 222292 Patch Update patch for jinwoo's comment. 976243 19 222292 gyuyoung.kim 2014-02-04 00:51:00 -0800 Comment on attachment 222292 Patch LGTM. r=me based on previous a lot of review comments. 976254 20 222292 commit-queue 2014-02-04 02:20:22 -0800 Comment on attachment 222292 Patch Clearing flags on attachment: 222292 Committed r163370: <http://trac.webkit.org/changeset/163370> 976255 21 commit-queue 2014-02-04 02:20:26 -0800 All reviewed patches have been landed. Closing bug. 154894 2012-07-27 03:32:57 -0700 2014-01-24 00:44:49 -0800 [WIP] patch for injected bundle client injected_bundle_client.patch text/plain 10065 enmi.lee ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtRWZsLmNtYWtlIGIvU291cmNlL1dl YktpdDIvUGxhdGZvcm1FZmwuY21ha2UKaW5kZXggYjRmYTBhYy4uMGRkOTMzYyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdDIvUGxhdGZvcm1FZmwuY21ha2UKKysrIGIvU291cmNlL1dlYktpdDIv UGxhdGZvcm1FZmwuY21ha2UKQEAgLTQyLDYgKzQyLDcgQEAgTElTVChBUFBFTkQgV2ViS2l0Ml9T T1VSQ0VTCiAgICAgVUlQcm9jZXNzL0FQSS9lZmwvUGFnZUNsaWVudEltcGwuY3BwCiAgICAgVUlQ cm9jZXNzL0FQSS9lZmwvVmlicmF0aW9uUHJvdmlkZXIuY3BwCiAgICAgVUlQcm9jZXNzL0FQSS9l ZmwvZXdrX2NvbnRleHQuY3BwCisgICAgVUlQcm9jZXNzL0FQSS9lZmwvZXdrX2NvbnRleHRfaW5q ZWN0ZWRfYnVuZGxlX2NsaWVudC5jcHAKICAgICBVSVByb2Nlc3MvQVBJL2VmbC9ld2tfY29udGV4 dF9yZXF1ZXN0X21hbmFnZXJfY2xpZW50LmNwcAogICAgIFVJUHJvY2Vzcy9BUEkvZWZsL2V3a19j b29raWVfbWFuYWdlci5jcHAKICAgICBVSVByb2Nlc3MvQVBJL2VmbC9ld2tfZm9ybV9zdWJtaXNz aW9uX3JlcXVlc3QuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2VmbC9ld2tfY29udGV4dC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2VmbC9l d2tfY29udGV4dC5jcHAKaW5kZXggYzJmOTI0Ny4uY2MxZDVjNiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9lZmwvZXdrX2NvbnRleHQuY3BwCisrKyBiL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZWZsL2V3a19jb250ZXh0LmNwcApAQCAtMjcsNiArMjcsNyBA QAogI2luY2x1ZGUgIldLQ29udGV4dFNvdXAuaCIKICNpbmNsdWRlICJXS1JldGFpblB0ci5oIgog I2luY2x1ZGUgIldLU3RyaW5nLmgiCisjaW5jbHVkZSAiZXdrX2NvbnRleHRfaW5qZWN0ZWRfYnVu ZGxlX2NsaWVudC5oIgogI2luY2x1ZGUgImV3a19jb250ZXh0X3ByaXZhdGUuaCIKICNpbmNsdWRl ICJld2tfY29udGV4dF9yZXF1ZXN0X21hbmFnZXJfY2xpZW50X3ByaXZhdGUuaCIKICNpbmNsdWRl ICJld2tfY29va2llX21hbmFnZXJfcHJpdmF0ZS5oIgpAQCAtNjYsMTAgKzY3LDE3IEBAIHN0cnVj dCBfRXdrX0NvbnRleHQgewogICAgIFdLUmV0YWluUHRyPFdLU291cFJlcXVlc3RNYW5hZ2VyUmVm PiByZXF1ZXN0TWFuYWdlcjsKICAgICBVUkxTY2hlbWVIYW5kbGVyTWFwIHVybFNjaGVtZUhhbmRs ZXJzOwogCisgICAgc3RydWN0IHsKKyAgICAgICAgRXdrX0NvbnRleHRfTWVzc2FnZV9Gcm9tX0lu amVjdGVkX0J1bmRsZV9DYWxsYmFjayBjYWxsYmFjazsKKyAgICAgICAgdm9pZCogdXNlckRhdGE7 CisgICAgfSBtZXNzYWdlRnJvbUluamVjdGVkQnVuZGxlOworCiAgICAgX0V3a19Db250ZXh0KFdL Q29udGV4dFJlZiBjb250ZXh0UmVmKQogICAgICAgICA6IGNvbnRleHQoY29udGV4dFJlZikKICAg ICAgICAgLCBjb29raWVNYW5hZ2VyKDApCiAgICAgICAgICwgcmVxdWVzdE1hbmFnZXIoV0tDb250 ZXh0R2V0U291cFJlcXVlc3RNYW5hZ2VyKGNvbnRleHRSZWYpKQorICAgICAgICAsIG1lc3NhZ2VG cm9tSW5qZWN0ZWRCdW5kbGUuY2FsbGJhY2soMCkKKyAgICAgICAgLCBtZXNzYWdlRnJvbUluamVj dGVkQnVuZGxlLnVzZXJEYXRhKDApCiAgICAgewogI2lmIEVOQUJMRShCQVRURVJZX1NUQVRVUykK ICAgICAgICAgV0tCYXR0ZXJ5TWFuYWdlclJlZiB3a0JhdHRlcnlNYW5hZ2VyID0gV0tDb250ZXh0 R2V0QmF0dGVyeU1hbmFnZXIoY29udGV4dFJlZik7CkBAIC0xNjksMyArMTc3LDUwIEBAIHZvaWQg ZXdrX2NvbnRleHRfdmlicmF0aW9uX2NsaWVudF9jYWxsYmFja3Nfc2V0KEV3a19Db250ZXh0KiBl d2tDb250ZXh0LCBFd2tfVmliCiAgICAgZXdrQ29udGV4dC0+dmlicmF0aW9uUHJvdmlkZXItPnNl dFZpYnJhdGlvbkNsaWVudENhbGxiYWNrcyh2aWJyYXRlLCBjYW5jZWwsIGRhdGEpOwogI2VuZGlm CiB9CisKK3ZvaWQgZXdrX2NvbnRleHRfbWVzc2FnZV9wb3N0X3RvX2luamVjdGVkX2J1bmRsZShF d2tfQ29udGV4dCogZXdrQ29udGV4dCwgY29uc3QgY2hhciogbmFtZSwgY29uc3QgY2hhciogYm9k eSkKK3sKKyAgICBFSU5BX1NBRkVUWV9PTl9OVUxMX1JFVFVSTihld2tDb250ZXh0KTsKKyAgICBF SU5BX1NBRkVUWV9PTl9OVUxMX1JFVFVSTihuYW1lKTsKKyAgICBFSU5BX1NBRkVUWV9PTl9OVUxM X1JFVFVSTihib2R5KTsKKworICAgIFdLUmV0YWluUHRyPFdLU3RyaW5nUmVmPiBtZXNzYWdlTmFt ZShBZG9wdFdLLCBXS1N0cmluZ0NyZWF0ZVdpdGhVVEY4Q1N0cmluZyhuYW1lKSk7CisgICAgV0tS ZXRhaW5QdHI8V0tTdHJpbmdSZWY+IG1lc3NhZ2VCb2R5KEFkb3B0V0ssIFdLU3RyaW5nQ3JlYXRl V2l0aFVURjhDU3RyaW5nKGJvZHkpKTsKKyAgICBXS0NvbnRleHRQb3N0TWVzc2FnZVRvSW5qZWN0 ZWRCdW5kbGUoZXdrX2NvbnRleHRfV0tDb250ZXh0X2dldChld2tDb250ZXh0KSwgbWVzc2FnZU5h bWUuZ2V0KCksIG1lc3NhZ2VCb2R5LmdldCgpKTsKK30KKwordm9pZCBld2tfY29udGV4dF9tZXNz YWdlX2Zyb21faW5qZWN0ZWRfYnVuZGxlX2NhbGxiYWNrX3NldChFd2tfQ29udGV4dCogZXdrQ29u dGV4dCwgRXdrX0NvbnRleHRfTWVzc2FnZV9Gcm9tX0luamVjdGVkX0J1bmRsZV9DYWxsYmFjayBj YWxsYmFjaywgdm9pZCogdXNlckRhdGEpCit7CisgICAgRUlOQV9TQUZFVFlfT05fTlVMTF9SRVRV Uk4oZXdrQ29udGV4dCk7CisKKyAgICBld2tDb250ZXh0LT5tZXNzYWdlRnJvbUluamVjdGVkQnVu ZGxlLmNhbGxiYWNrID0gY2FsbGJhY2s7CisgICAgZXdrQ29udGV4dC0+bWVzc2FnZUZyb21Jbmpl Y3RlZEJ1bmRsZS51c2VyRGF0YSA9IHVzZXJEYXRhOworfQorCit2b2lkIGV3a0NvbnRleHREaWRS ZWNlaXZlTWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZShFd2tfQ29udGV4dCogZXdrQ29udGV4dCwg V0tTdHJpbmdSZWYgbWVzc2FnZU5hbWUsIFdLVHlwZVJlZiBtZXNzYWdlQm9keSwgV0tUeXBlUmVm KiByZXR1cm5EYXRhKQoreworICAgIEVJTkFfU0FGRVRZX09OX05VTExfUkVUVVJOKGV3a0NvbnRl eHQpOworCisgICAgaWYgKCFld2tDb250ZXh0LT5tZXNzYWdlRnJvbUluamVjdGVkQnVuZGxlLmNh bGxiYWNrKQorICAgICAgICByZXR1cm47CisKKyAgICBDU3RyaW5nIG5hbWUgPSB0b0ltcGwobWVz c2FnZU5hbWUpLT5zdHJpbmcoKS51dGY4KCk7CisgICAgQ1N0cmluZyBib2R5OworICAgIGlmICht ZXNzYWdlQm9keSAmJiBXS1N0cmluZ0dldFR5cGVJRCgpID09IFdLR2V0VHlwZUlEKG1lc3NhZ2VC b2R5KSkKKyAgICAgICAgYm9keSA9IHRvSW1wbChzdGF0aWNfY2FzdDxXS1N0cmluZ1JlZj4obWVz c2FnZUJvZHkpKS0+c3RyaW5nKCkudXRmOCgpOworCisgICAgaWYgKHJldHVybkRhdGEpIHsKKyAg ICAgICAgY2hhciogcmV0dXJuU3RyaW5nID0gMDsKKyAgICAgICAgZXdrQ29udGV4dC0+bWVzc2Fn ZUZyb21JbmplY3RlZEJ1bmRsZS5jYWxsYmFjayhuYW1lLmRhdGEoKSwgYm9keS5kYXRhKCksICZy ZXR1cm5TdHJpbmcsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgZXdrQ29udGV4dC0+bWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZS51c2VyRGF0 YSk7CisgICAgICAgIGlmIChyZXR1cm5TdHJpbmcpIHsKKyAgICAgICAgICAgICpyZXR1cm5EYXRh ID0gV0tTdHJpbmdDcmVhdGVXaXRoVVRGOENTdHJpbmcocmV0dXJuU3RyaW5nKTsKKyAgICAgICAg ICAgIGZyZWUocmV0dXJuU3RyaW5nKTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICpy ZXR1cm5EYXRhID0gV0tTdHJpbmdDcmVhdGVXaXRoVVRGOENTdHJpbmcoIiIpOworICAgICAgICB9 CisgICAgfSBlbHNlIHsKKyAgICAgICAgZXdrQ29udGV4dC0+bWVzc2FnZUZyb21JbmplY3RlZEJ1 bmRsZS5jYWxsYmFjayhuYW1lLmRhdGEoKSwgYm9keS5kYXRhKCksIDAsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZXdrQ29udGV4dC0+bWVz c2FnZUZyb21JbmplY3RlZEJ1bmRsZS51c2VyRGF0YSk7CisgICAgfQorfQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9lZmwvZXdrX2NvbnRleHQuaCBiL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZWZsL2V3a19jb250ZXh0LmgKaW5kZXggNWU0ZDM0Mi4uMWI1 OThhOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9lZmwvZXdrX2Nv bnRleHQuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2VmbC9ld2tfY29udGV4 dC5oCkBAIC02MSw2ICs2MSwxOSBAQCB0eXBlZGVmIHZvaWQgKCpFd2tfVmlicmF0aW9uX0NsaWVu dF9WaWJyYXRlX0NiKSh1aW50NjRfdCB2aWJyYXRpb25fdGltZSwgdm9pZCAqdQogdHlwZWRlZiB2 b2lkICgqRXdrX1ZpYnJhdGlvbl9DbGllbnRfVmlicmF0aW9uX0NhbmNlbF9DYikodm9pZCAqdXNl cl9kYXRhKTsKIAogLyoqCisgKiBDYWxsYmFjayBmb3IgZGlkUmVjZWl2ZU1lc3NhZ2VGcm9tSW5q ZWN0ZWRCdW5kbGUgYW5kIGRpZFJlY2VpdmVTeW5jaHJvbm91c01lc3NhZ2VGcm9tSW5qZWN0ZWRC dW5kbGUKKyAqCisgKiBVc2VyIHNob3VsZCBhbGxvY2F0ZSBuZXcgc3RyaW5nIGZvciByZXR1cm5f ZGF0YSBiZWZvcmUgc2V0dGluZyBpdC4KKyAqIFRoZSByZXR1cm5fZGF0YSBzdHJpbmcgd2lsbCBi ZSBmcmVlZCBpbiB0aGUgV2ViS2l0IHNpZGUuCisgKgorICogQHBhcmFtIG5hbWUgbmFtZSBvZiBt ZXNzYWdlIGZyb20gaW5qZWN0ZWQgYnVuZGxlCisgKiBAcGFyYW0gYm9keSBib2R5IG9mIG1lc3Nh Z2UgZnJvbSBpbmplY3RlZCBidW5kbGUKKyAqIEBwYXJhbSByZXR1cm5fZGF0YSByZXR1cm5fZGF0 YSBzdHJpbmcgZnJvbSBhcHBsaWNhdGlvbgorICogQHBhcmFtIHVzZXJfZGF0YSB1c2VyX2RhdGEg d2lsbCBiZSBwYXNzc2VkIHdoZW4gcmVjZWl2aW5nIG1lc3NhZ2UgZnJvbSBpbmplY3RlZCBidW5k bGUKKyAqLwordHlwZWRlZiB2b2lkICgqRXdrX0NvbnRleHRfTWVzc2FnZV9Gcm9tX0luamVjdGVk X0J1bmRsZV9DYWxsYmFjaykoY29uc3QgY2hhciogbmFtZSwgY29uc3QgY2hhciogYm9keSwgY2hh cioqIHJldHVybl9kYXRhLCB2b2lkKiB1c2VyX2RhdGEpOworCisvKioKICAqIEdldHMgZGVmYXVs dCBFd2tfQ29udGV4dCBpbnN0YW5jZS4KICAqCiAgKiBAcmV0dXJuIEV3a19Db250ZXh0IG9iamVj dC4KQEAgLTEzNSw2ICsxNDgsMjQgQEAgRUFQSSBFaW5hX0Jvb2wgZXdrX2NvbnRleHRfdXJpX3Nj aGVtZV9yZWdpc3RlcihFd2tfQ29udGV4dCAqY29udGV4dCwgY29uc3QgY2hhcgogICovCiBFQVBJ IHZvaWQgZXdrX2NvbnRleHRfdmlicmF0aW9uX2NsaWVudF9jYWxsYmFja3Nfc2V0KEV3a19Db250 ZXh0ICpjb250ZXh0LCBFd2tfVmlicmF0aW9uX0NsaWVudF9WaWJyYXRlX0NiIHZpYnJhdGUsIEV3 a19WaWJyYXRpb25fQ2xpZW50X1ZpYnJhdGlvbl9DYW5jZWxfQ2IgY2FuY2VsLCB2b2lkICpkYXRh KTsKIAorLyoqCisgKiBQb3N0cyBtZXNzYWdlIHRvIGluamVjdGVkIGJ1bmRsZS4KKyAqCisgKiBA cGFyYW0gY29udGV4dCBjb250ZXh0IG9iamVjdAorICogQHBhcmFtIG5hbWUgbWVzc2FnZSBuYW1l CisgKiBAcGFyYW0gYm9keSBtZXNzYWdlIGJvZHkKKyAqLworRUFQSSB2b2lkIGV3a19jb250ZXh0 X21lc3NhZ2VfcG9zdF90b19pbmplY3RlZF9idW5kbGUoRXdrX0NvbnRleHQqIGNvbnRleHQsIGNv bnN0IGNoYXIqIG5hbWUsIGNvbnN0IGNoYXIqIGJvZHkpOworCisvKioKKyAqIFNldHMgY2FsbGJh Y2sgZm9yIHJlY2VpdmVkIGluamVjdGVkIGJ1bmRsZSBtZXNzYWdlLgorICoKKyAqIEBwYXJhbSBj b250ZXh0IGNvbnRleHQgb2JqZWN0CisgKiBAcGFyYW0gY2FsbGJhY2sgY2FsbGJhY2sgZm9yIHJl Y2VpdmVkIGluamVjdGVkIGJ1bmRsZSBtZXNzYWdlCisgKiBAcGFyYW0gdXNlcl9kYXRhIHVzZXIg ZGF0YQorICovCitFQVBJIHZvaWQgZXdrX2NvbnRleHRfbWVzc2FnZV9mcm9tX2luamVjdGVkX2J1 bmRsZV9jYWxsYmFja19zZXQoRXdrX0NvbnRleHQqIGNvbnRleHQsIEV3a19Db250ZXh0X01lc3Nh Z2VfRnJvbV9JbmplY3RlZF9CdW5kbGVfQ2FsbGJhY2sgY2FsbGJhY2ssIHZvaWQqIHVzZXJfZGF0 YSk7CisKICNpZmRlZiBfX2NwbHVzcGx1cwogfQogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2VmbC9ld2tfY29udGV4dF9pbmplY3RlZF9idW5kbGVfY2xp ZW50LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZWZsL2V3a19jb250ZXh0X2lu amVjdGVkX2J1bmRsZV9jbGllbnQuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLjQzYTRiYzMKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv QVBJL2VmbC9ld2tfY29udGV4dF9pbmplY3RlZF9idW5kbGVfY2xpZW50LmNwcApAQCAtMCwwICsx LDUxIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyIFNhbXN1bmcgRWxlY3Ryb25pY3MKKyAq CisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUg aXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFy eSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29m dHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9y IChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5 IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBi dXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50 eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3Ig bW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2Yg dGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhp cyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisg KiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQs IEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2lu Y2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgImV3a19jb250ZXh0X2luamVjdGVkX2J1bmRsZV9j bGllbnQuaCIKKworI2luY2x1ZGUgIldLQ29udGV4dC5oIgorI2luY2x1ZGUgImV3a19jb250ZXh0 X3ByaXZhdGUuaCIKKyNpbmNsdWRlICJld2tfdmlld19wcml2YXRlLmgiCisKK3ZvaWQgZGlkUmVj ZWl2ZU1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUoV0tDb250ZXh0UmVmIHBhZ2UsIFdLU3RyaW5n UmVmIG1lc3NhZ2VOYW1lLCBXS1R5cGVSZWYgbWVzc2FnZUJvZHksIGNvbnN0IHZvaWQqIGNsaWVu dEluZm8pCit7CisgICAgRXdrX0NvbnRleHQqIGV3a0NvbnRleHQgPSBzdGF0aWNfY2FzdDxFd2tf Q29udGV4dCo+KGNvbnN0X2Nhc3Q8dm9pZCo+KGNsaWVudEluZm8pKTsKKyAgICBld2tDb250ZXh0 RGlkUmVjZWl2ZU1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUoZXdrQ29udGV4dCwgbWVzc2FnZU5h bWUsIG1lc3NhZ2VCb2R5LCAwKTsKK30KKwordm9pZCBkaWRSZWNlaXZlU3luY2hyb25vdXNNZXNz YWdlRnJvbUluamVjdGVkQnVuZGxlKFdLQ29udGV4dFJlZiBwYWdlLCBXS1N0cmluZ1JlZiBtZXNz YWdlTmFtZSwgV0tUeXBlUmVmIG1lc3NhZ2VCb2R5LCBXS1R5cGVSZWYqIHJldHVybkRhdGEsIGNv bnN0IHZvaWQqIGNsaWVudEluZm8pCit7CisgICAgRXdrX0NvbnRleHQqIGV3a0NvbnRleHQgPSBz dGF0aWNfY2FzdDxFd2tfQ29udGV4dCo+KGNvbnN0X2Nhc3Q8dm9pZCo+KGNsaWVudEluZm8pKTsK KyAgICBld2tDb250ZXh0RGlkUmVjZWl2ZU1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUoZXdrQ29u dGV4dCwgbWVzc2FnZU5hbWUsIG1lc3NhZ2VCb2R5LCByZXR1cm5EYXRhKTsKK30KKwordm9pZCBl d2tDb250ZXh0SW5qZWN0ZWRCdW5kbGVDbGllbnRBdHRhY2hDbGllbnQoRXdrX0NvbnRleHQqIGV3 a0NvbnRleHQpCit7CisgICAgRUlOQV9TQUZFVFlfT05fTlVMTF9SRVRVUk4oZXdrQ29udGV4dCk7 CisKKyAgICBXS0NvbnRleHRJbmplY3RlZEJ1bmRsZUNsaWVudCBpbmplY3RlZEJ1bmRsZUNsaWVu dCA9IHsKKyAgICAgICAga1dLQ29udGV4dEluamVjdGVkQnVuZGxlQ2xpZW50Q3VycmVudFZlcnNp b24sCisgICAgICAgIGV3a0NvbnRleHQsCisgICAgICAgIGRpZFJlY2VpdmVNZXNzYWdlRnJvbUlu amVjdGVkQnVuZGxlLAorICAgICAgICBkaWRSZWNlaXZlU3luY2hyb25vdXNNZXNzYWdlRnJvbUlu amVjdGVkQnVuZGxlCisgICAgfTsKKworICAgIFdLQ29udGV4dFNldEluamVjdGVkQnVuZGxlQ2xp ZW50KGV3a19jb250ZXh0X1dLQ29udGV4dF9nZXQoZXdrQ29udGV4dCksICZpbmplY3RlZEJ1bmRs ZUNsaWVudCk7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2Vm bC9ld2tfY29udGV4dF9pbmplY3RlZF9idW5kbGVfY2xpZW50LmggYi9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvQVBJL2VmbC9ld2tfY29udGV4dF9pbmplY3RlZF9idW5kbGVfY2xpZW50LmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTRhNmUxNAotLS0gL2Rldi9udWxsCisr KyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZWZsL2V3a19jb250ZXh0X2luamVjdGVk X2J1bmRsZV9jbGllbnQuaApAQCAtMCwwICsxLDI3IEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDEyIFNhbXN1bmcgRWxlY3Ryb25pY3MKKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBh cyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2 ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZl cnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRo YXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhv dXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91 bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGlj IExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlO Ry5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9u LCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAw MjExMC0xMzAxLCBVU0EuCisgKi8KKworI2lmbmRlZiBld2tfdmlld19pbmplY3RlZF9idW5kbGVf Y2xpZW50X2gKKyNkZWZpbmUgZXdrX3ZpZXdfaW5qZWN0ZWRfYnVuZGxlX2NsaWVudF9oCisKKyNp bmNsdWRlICJld2tfY29udGV4dC5oIgorCit2b2lkIGV3a0NvbnRleHRJbmplY3RlZEJ1bmRsZUNs aWVudEF0dGFjaENsaWVudChFd2tfQ29udGV4dCogZXdrQ29udGV4dCk7CisKKyNlbmRpZiAvLyBl d2tfdmlld19pbmplY3RlZF9idW5kbGVfY2xpZW50X2gK 222085 2014-01-24 00:44:55 -0800 2014-01-26 17:21:19 -0800 Patch bug-90772-20140124174455.patch text/plain 9573 enmi.lee U3VidmVyc2lvbiBSZXZpc2lvbjogMTYyNjkzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggYzllNDM3MzUxMWY5MzBj NGM3NjU3YTk5NzY1MjIxOTg0YTkxYzZmZS4uYzUyMWE5ZDcwYmIzNTZkMTY3NTE2OGNlYmYxMzY5 MGQ4ODI3N2M5YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2IEBACisyMDE0LTAxLTI0ICBFdW5t aSBMZWUgIDxldW5taTE1LmxlZUBzYW1zdW5nLmNvbT4KKworICAgICAgICBbRUZMXVtXSzJdIGV3 a19jb250ZXh0IG5lZWRzIHRvIHJvdXRlIEluamVjdGVkQnVuZGxlIE1lc3NhZ2VzIGNvcnJlY3Rs eQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9OTA3NzIK KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgQVBJ cyB0byBwb3N0IG1lc3NhZ2UgdG8gaW5qZWN0ZWQgYnVuZGxlIGFuZCByZWdpc3RlciBjYWxsYmFj ayB0bworICAgICAgICBnZXQgbWVzc2FnZSBmcm9tIGluamVjdGVkIGJ1bmRsZS4gV2hlbiBjYWxs YmFjayBpcyByZWdpc3RlcmVkLAorICAgICAgICBXS0NvbnRleHRJbmplY3RlZEJ1bmRsZUNsaWVu dCBpcyBzZXQgdG8gZ2V0IG1lc3NhZ2VzIGZyb20gaW5qZWN0ZWQgYnVuZGxlLgorCisgICAgICAg ICogVUlQcm9jZXNzL0FQSS9lZmwvZXdrX2NvbnRleHQuY3BwOgorICAgICAgICAoRXdrQ29udGV4 dDo6RXdrQ29udGV4dCk6CisgICAgICAgICh0b0V3a0NvbnRleHQpOgorICAgICAgICAoRXdrQ29u dGV4dDo6ZGlkUmVjZWl2ZU1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUpOgorICAgICAgICAoRXdr Q29udGV4dDo6ZGlkUmVjZWl2ZVN5bmNocm9ub3VzTWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZSk6 CisgICAgICAgIChFd2tDb250ZXh0OjpzZXRNZXNzYWdlRnJvbUluamVjdGVkQnVuZGxlQ2FsbGJh Y2spOiByZWdpc3RlciBjYWxsYmFjayB0byBnZXQgbWVzc2FnZSBmcm9tIGluamVjdGVkIGJ1bmRs ZS4KKyAgICAgICAgKEV3a0NvbnRleHQ6OnByb2Nlc3NSZWNlaXZlZE1lc3NhZ2VGcm9tSW5qZWN0 ZWRCdW5kbGUpOiBwcm9jZXNzIG1lc3NhZ2UgZnJvbSBpbmplY3RlZCBidW5kbGUuCisgICAgICAg IChld2tfY29udGV4dF9tZXNzYWdlX3Bvc3RfdG9faW5qZWN0ZWRfYnVuZGxlKToKKyAgICAgICAg KGV3a19jb250ZXh0X21lc3NhZ2VfZnJvbV9pbmplY3RlZF9idW5kbGVfY2FsbGJhY2tfc2V0KToK KyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2VmbC9ld2tfY29udGV4dC5oOgorICAgICAgICAqIFVJ UHJvY2Vzcy9BUEkvZWZsL2V3a19jb250ZXh0X3ByaXZhdGUuaDoKKwogMjAxNC0wMS0yMyAgQnJh ZHkgRWlkc29uICA8YmVpZHNvbkBhcHBsZS5jb20+CiAKICAgICAgICAgSURCOiBTdXBwb3J0IElE Qk9iamVjdFN0b3JlLmNsZWFyKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9BUEkvZWZsL2V3a19jb250ZXh0LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkv ZWZsL2V3a19jb250ZXh0LmNwcAppbmRleCBlNDNlYTk3NWFkNjA0ODY3N2JlZDBmNWJhZjVmN2M5 NWYyMzc0NTljLi43NDFkNjI3NGY3MjZhNWUxODY2MjZkNWNmMmU2ZjM4MWJmZmUxNTlkIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2VmbC9ld2tfY29udGV4dC5jcHAK KysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9lZmwvZXdrX2NvbnRleHQuY3BwCkBA IC05NCw2ICs5NCw5IEBAIEV3a0NvbnRleHQ6OkV3a0NvbnRleHQoV0tDb250ZXh0UmVmIGNvbnRl eHQpCiAgICAgLy8gaW5kZXBlbmRlbnRseSBvZiBjaGVja2luZyBzcGVsbGluZyB3aGlsZSB0eXBp bmcgc2V0dGluZy4KICAgICBUZXh0Q2hlY2tlckNsaWVudEVmbDo6aW5zdGFuY2UoKS5lbnN1cmVT cGVsbENoZWNraW5nTGFuZ3VhZ2UoKTsKICNlbmRpZgorCisgICAgbV9jYWxsYmFja0Zvck1lc3Nh Z2VGcm9tSW5qZWN0ZWRCdW5kbGUuY2FsbGJhY2sgPSAwOworICAgIG1fY2FsbGJhY2tGb3JNZXNz YWdlRnJvbUluamVjdGVkQnVuZGxlLnVzZXJEYXRhID0gMDsKIH0KIAogRXdrQ29udGV4dDo6fkV3 a0NvbnRleHQoKQpAQCAtMjc1LDYgKzI3OCw2NiBAQCBDb250ZXh0SGlzdG9yeUNsaWVudEVmbCog RXdrQ29udGV4dDo6aGlzdG9yeUNsaWVudCgpCiAgICAgcmV0dXJuIG1faGlzdG9yeUNsaWVudC5n ZXQoKTsKIH0KIAorc3RhdGljIGlubGluZSBFd2tDb250ZXh0KiB0b0V3a0NvbnRleHQoY29uc3Qg dm9pZCogY2xpZW50SW5mbykKK3sKKyAgICByZXR1cm4gc3RhdGljX2Nhc3Q8RXdrQ29udGV4dCo+ KGNvbnN0X2Nhc3Q8dm9pZCo+KGNsaWVudEluZm8pKTsKK30KKwordm9pZCBFd2tDb250ZXh0Ojpk aWRSZWNlaXZlTWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZShXS0NvbnRleHRSZWYsIFdLU3RyaW5n UmVmIG1lc3NhZ2VOYW1lLCBXS1R5cGVSZWYgbWVzc2FnZUJvZHksIGNvbnN0IHZvaWQqIGNsaWVu dEluZm8pCit7CisgICAgdG9Fd2tDb250ZXh0KGNsaWVudEluZm8pLT5wcm9jZXNzUmVjZWl2ZWRN ZXNzYWdlRnJvbUluamVjdGVkQnVuZGxlKG1lc3NhZ2VOYW1lLCBtZXNzYWdlQm9keSwgMCk7Cit9 CisKK3ZvaWQgRXdrQ29udGV4dDo6ZGlkUmVjZWl2ZVN5bmNocm9ub3VzTWVzc2FnZUZyb21Jbmpl Y3RlZEJ1bmRsZShXS0NvbnRleHRSZWYsIFdLU3RyaW5nUmVmIG1lc3NhZ2VOYW1lLCBXS1R5cGVS ZWYgbWVzc2FnZUJvZHksIFdLVHlwZVJlZiogcmV0dXJuRGF0YSwgY29uc3Qgdm9pZCogY2xpZW50 SW5mbykKK3sKKyAgICB0b0V3a0NvbnRleHQoY2xpZW50SW5mbyktPnByb2Nlc3NSZWNlaXZlZE1l c3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUobWVzc2FnZU5hbWUsIG1lc3NhZ2VCb2R5LCByZXR1cm5E YXRhKTsKK30KKwordm9pZCBFd2tDb250ZXh0OjpzZXRNZXNzYWdlRnJvbUluamVjdGVkQnVuZGxl Q2FsbGJhY2soRXdrX0NvbnRleHRfTWVzc2FnZV9Gcm9tX0luamVjdGVkX0J1bmRsZV9DYWxsYmFj ayBjYWxsYmFjaywgdm9pZCogdXNlckRhdGEpCit7CisgICAgbV9jYWxsYmFja0Zvck1lc3NhZ2VG cm9tSW5qZWN0ZWRCdW5kbGUudXNlckRhdGEgPSB1c2VyRGF0YTsKKworICAgIGlmIChtX2NhbGxi YWNrRm9yTWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZS5jYWxsYmFjayA9PSBjYWxsYmFjaykKKyAg ICAgICAgcmV0dXJuOworCisgICAgaWYgKCFtX2NhbGxiYWNrRm9yTWVzc2FnZUZyb21JbmplY3Rl ZEJ1bmRsZS5jYWxsYmFjaykgeworICAgICAgICBXS0NvbnRleHRJbmplY3RlZEJ1bmRsZUNsaWVu dFYxIGNsaWVudDsKKyAgICAgICAgbWVtc2V0KCZjbGllbnQsIDAsIHNpemVvZihjbGllbnQpKTsK KworICAgICAgICBjbGllbnQuYmFzZS52ZXJzaW9uID0gMTsKKyAgICAgICAgY2xpZW50LmJhc2Uu Y2xpZW50SW5mbyA9IHRoaXM7CisgICAgICAgIGNsaWVudC5kaWRSZWNlaXZlTWVzc2FnZUZyb21J bmplY3RlZEJ1bmRsZSA9IGRpZFJlY2VpdmVNZXNzYWdlRnJvbUluamVjdGVkQnVuZGxlOworICAg ICAgICBjbGllbnQuZGlkUmVjZWl2ZVN5bmNocm9ub3VzTWVzc2FnZUZyb21JbmplY3RlZEJ1bmRs ZSA9IGRpZFJlY2VpdmVTeW5jaHJvbm91c01lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGU7CisKKyAg ICAgICAgV0tDb250ZXh0U2V0SW5qZWN0ZWRCdW5kbGVDbGllbnQobV9jb250ZXh0LmdldCgpLCAm Y2xpZW50LmJhc2UpOworICAgIH0gZWxzZSBpZiAoIWNhbGxiYWNrKQorICAgICAgICBXS0NvbnRl eHRTZXRJbmplY3RlZEJ1bmRsZUNsaWVudChtX2NvbnRleHQuZ2V0KCksIDApOworCisgICAgbV9j YWxsYmFja0Zvck1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUuY2FsbGJhY2sgPSBjYWxsYmFjazsK K30KKwordm9pZCBFd2tDb250ZXh0Ojpwcm9jZXNzUmVjZWl2ZWRNZXNzYWdlRnJvbUluamVjdGVk QnVuZGxlKFdLU3RyaW5nUmVmIG1lc3NhZ2VOYW1lLCBXS1R5cGVSZWYgbWVzc2FnZUJvZHksIFdL VHlwZVJlZiogcmV0dXJuRGF0YSkKK3sKKyAgICBpZiAoIW1fY2FsbGJhY2tGb3JNZXNzYWdlRnJv bUluamVjdGVkQnVuZGxlLmNhbGxiYWNrKQorICAgICAgICByZXR1cm47CisKKyAgICBDU3RyaW5n IG5hbWUgPSB0b0ltcGwobWVzc2FnZU5hbWUpLT5zdHJpbmcoKS51dGY4KCk7CisgICAgQ1N0cmlu ZyBib2R5OworICAgIGlmIChtZXNzYWdlQm9keSAmJiBXS1N0cmluZ0dldFR5cGVJRCgpID09IFdL R2V0VHlwZUlEKG1lc3NhZ2VCb2R5KSkKKyAgICAgICAgYm9keSA9IHRvSW1wbChzdGF0aWNfY2Fz dDxXS1N0cmluZ1JlZj4obWVzc2FnZUJvZHkpKS0+c3RyaW5nKCkudXRmOCgpOworCisgICAgaWYg KHJldHVybkRhdGEpIHsKKyAgICAgICAgY2hhciogcmV0dXJuU3RyaW5nID0gMDsKKyAgICAgICAg bV9jYWxsYmFja0Zvck1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUuY2FsbGJhY2sobmFtZS5kYXRh KCksIGJvZHkuZGF0YSgpLCAmcmV0dXJuU3RyaW5nLCBtX2NhbGxiYWNrRm9yTWVzc2FnZUZyb21J bmplY3RlZEJ1bmRsZS51c2VyRGF0YSk7CisgICAgICAgIGlmIChyZXR1cm5TdHJpbmcpIHsKKyAg ICAgICAgICAgICpyZXR1cm5EYXRhID0gV0tTdHJpbmdDcmVhdGVXaXRoVVRGOENTdHJpbmcocmV0 dXJuU3RyaW5nKTsKKyAgICAgICAgICAgIGZyZWUocmV0dXJuU3RyaW5nKTsKKyAgICAgICAgfSBl bHNlCisgICAgICAgICAgICAqcmV0dXJuRGF0YSA9IFdLU3RyaW5nQ3JlYXRlV2l0aFVURjhDU3Ry aW5nKCIiKTsKKyAgICB9IGVsc2UKKyAgICAgICAgbV9jYWxsYmFja0Zvck1lc3NhZ2VGcm9tSW5q ZWN0ZWRCdW5kbGUuY2FsbGJhY2sobmFtZS5kYXRhKCksIGJvZHkuZGF0YSgpLCAwLCBtX2NhbGxi YWNrRm9yTWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZS51c2VyRGF0YSk7Cit9CisKIEV3a19Db250 ZXh0KiBld2tfY29udGV4dF9kZWZhdWx0X2dldCgpCiB7CiAgICAgcmV0dXJuIEV3a0NvbnRleHQ6 OmRlZmF1bHRDb250ZXh0KCk7CkBAIC0zNjEsMyArNDI0LDIwIEBAIHZvaWQgZXdrX2NvbnRleHRf cmVzb3VyY2VfY2FjaGVfY2xlYXIoRXdrX0NvbnRleHQqIGV3a0NvbnRleHQpCiAgICAgaW1wbC0+ Y2xlYXJSZXNvdXJjZUNhY2hlKCk7CiB9CiAKK3ZvaWQgZXdrX2NvbnRleHRfbWVzc2FnZV9wb3N0 X3RvX2luamVjdGVkX2J1bmRsZShFd2tfQ29udGV4dCogZXdrQ29udGV4dCwgY29uc3QgY2hhciog bmFtZSwgY29uc3QgY2hhciogYm9keSkKK3sKKyAgICBFV0tfT0JKX0dFVF9JTVBMX09SX1JFVFVS TihFd2tDb250ZXh0LCBld2tDb250ZXh0LCBpbXBsKTsKKyAgICBFSU5BX1NBRkVUWV9PTl9OVUxM X1JFVFVSTihuYW1lKTsKKyAgICBFSU5BX1NBRkVUWV9PTl9OVUxMX1JFVFVSTihib2R5KTsKKwor ICAgIFdLUmV0YWluUHRyPFdLU3RyaW5nUmVmPiBtZXNzYWdlTmFtZShBZG9wdFdLLCBXS1N0cmlu Z0NyZWF0ZVdpdGhVVEY4Q1N0cmluZyhuYW1lKSk7CisgICAgV0tSZXRhaW5QdHI8V0tTdHJpbmdS ZWY+IG1lc3NhZ2VCb2R5KEFkb3B0V0ssIFdLU3RyaW5nQ3JlYXRlV2l0aFVURjhDU3RyaW5nKGJv ZHkpKTsKKyAgICBXS0NvbnRleHRQb3N0TWVzc2FnZVRvSW5qZWN0ZWRCdW5kbGUoaW1wbC0+d2tD b250ZXh0KCksIG1lc3NhZ2VOYW1lLmdldCgpLCBtZXNzYWdlQm9keS5nZXQoKSk7Cit9CisKK3Zv aWQgZXdrX2NvbnRleHRfbWVzc2FnZV9mcm9tX2luamVjdGVkX2J1bmRsZV9jYWxsYmFja19zZXQo RXdrX0NvbnRleHQqIGV3a0NvbnRleHQsIEV3a19Db250ZXh0X01lc3NhZ2VfRnJvbV9JbmplY3Rl ZF9CdW5kbGVfQ2FsbGJhY2sgY2FsbGJhY2ssIHZvaWQqIHVzZXJEYXRhKQoreworICAgIEVXS19P QkpfR0VUX0lNUExfT1JfUkVUVVJOKEV3a0NvbnRleHQsIGV3a0NvbnRleHQsIGltcGwpOworCisg ICAgaW1wbC0+c2V0TWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZUNhbGxiYWNrKGNhbGxiYWNrLCB1 c2VyRGF0YSk7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2Vm bC9ld2tfY29udGV4dC5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9lZmwvZXdrX2Nv bnRleHQuaAppbmRleCA1ZDQ0MGFhOTQ2YTMxZTBhOTRmMTg3OGVmMGEzZWYyNzg0Y2VjYTgxLi5l NmFlZmJhNjUwYmI3NjJkYjY0OGY3ODMxZWJkYjdhYzRjZjRkMDYwIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2VmbC9ld2tfY29udGV4dC5oCisrKyBiL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZWZsL2V3a19jb250ZXh0LmgKQEAgLTExMiw2ICsxMTIsMTkg QEAgdHlwZWRlZiB2b2lkICgqRXdrX0hpc3RvcnlfVGl0bGVfVXBkYXRlX0NiKShjb25zdCBFdmFz X09iamVjdCAqdmlldywgY29uc3QgY2hhcgogdHlwZWRlZiB2b2lkICgqRXdrX0hpc3RvcnlfUG9w dWxhdGVfVmlzaXRlZF9MaW5rc19DYikodm9pZCAqdXNlcl9kYXRhKTsKIAogLyoqCisgKiBDYWxs YmFjayBmb3IgZGlkUmVjZWl2ZU1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUgYW5kIGRpZFJlY2Vp dmVTeW5jaHJvbm91c01lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUKKyAqCisgKiBVc2VyIHNob3Vs ZCBhbGxvY2F0ZSBuZXcgc3RyaW5nIGZvciByZXR1cm5fZGF0YSBiZWZvcmUgc2V0dGluZyBpdC4K KyAqIFRoZSByZXR1cm5fZGF0YSBzdHJpbmcgd2lsbCBiZSBmcmVlZCBvbiBXZWJLaXQgc2lkZS4K KyAqCisgKiBAcGFyYW0gbmFtZSBuYW1lIG9mIG1lc3NhZ2UgZnJvbSBpbmplY3RlZCBidW5kbGUK KyAqIEBwYXJhbSBib2R5IGJvZHkgb2YgbWVzc2FnZSBmcm9tIGluamVjdGVkIGJ1bmRsZQorICog QHBhcmFtIHJldHVybl9kYXRhIHJldHVybl9kYXRhIHN0cmluZyBmcm9tIGFwcGxpY2F0aW9uCisg KiBAcGFyYW0gdXNlcl9kYXRhIHVzZXJfZGF0YSB3aWxsIGJlIHBhc3NzZWQgd2hlbiByZWNlaXZp bmcgbWVzc2FnZSBmcm9tIGluamVjdGVkIGJ1bmRsZQorICovCit0eXBlZGVmIHZvaWQgKCpFd2tf Q29udGV4dF9NZXNzYWdlX0Zyb21fSW5qZWN0ZWRfQnVuZGxlX0NhbGxiYWNrKShjb25zdCBjaGFy ICpuYW1lLCBjb25zdCBjaGFyICpib2R5LCBjaGFyICoqcmV0dXJuX2RhdGEsIHZvaWQgKnVzZXJf ZGF0YSk7CisKKy8qKgogICogR2V0cyBkZWZhdWx0IEV3a19Db250ZXh0IGluc3RhbmNlLgogICoK ICAqIFRoZSByZXR1cm5lZCBFd2tfQ29udGV4dCBvYmplY3QgQGIgc2hvdWxkIG5vdCBiZSB1bnJl ZidlZCBpZiBhcHBsaWNhdGlvbgpAQCAtMzE5LDYgKzMzMiwyNiBAQCBFQVBJIEVpbmFfQm9vbCBl d2tfY29udGV4dF9hZGRpdGlvbmFsX3BsdWdpbl9wYXRoX3NldChFd2tfQ29udGV4dCAqY29udGV4 dCwgY29ucwogICovCiBFQVBJIHZvaWQgZXdrX2NvbnRleHRfcmVzb3VyY2VfY2FjaGVfY2xlYXIo RXdrX0NvbnRleHQgKmNvbnRleHQpOwogCisvKioKKyAqIFBvc3RzIG1lc3NhZ2UgdG8gaW5qZWN0 ZWQgYnVuZGxlLgorICoKKyAqIEBwYXJhbSBjb250ZXh0IGNvbnRleHQgb2JqZWN0IHRvIHBvc3Qg bWVzc2FnZSB0byBpbmplY3RlZCBidW5kbGUKKyAqIEBwYXJhbSBuYW1lIG1lc3NhZ2UgbmFtZQor ICogQHBhcmFtIGJvZHkgbWVzc2FnZSBib2R5CisgKi8KK0VBUEkgdm9pZCBld2tfY29udGV4dF9t ZXNzYWdlX3Bvc3RfdG9faW5qZWN0ZWRfYnVuZGxlKEV3a19Db250ZXh0ICpjb250ZXh0LCBjb25z dCBjaGFyICpuYW1lLCBjb25zdCBjaGFyICpib2R5KTsKKworLyoqCisgKiBTZXRzIGNhbGxiYWNr IGZvciByZWNlaXZlZCBpbmplY3RlZCBidW5kbGUgbWVzc2FnZS4KKyAqCisgKiBDbGllbnQgY2Fu IHBhc3MgQGMgTlVMTCBmb3IgY2FsbGJhY2sgdG8gc3RvcCBsaXN0ZW5pbmcgZm9yIG1lc3NhZ2Vz LgorICoKKyAqIEBwYXJhbSBjb250ZXh0IGNvbnRleHQgb2JqZWN0CisgKiBAcGFyYW0gY2FsbGJh Y2sgY2FsbGJhY2sgZm9yIHJlY2VpdmVkIGluamVjdGVkIGJ1bmRsZSBtZXNzYWdlIG9yIEBjIE5V TEwKKyAqIEBwYXJhbSB1c2VyX2RhdGEgdXNlciBkYXRhCisgKi8KK0VBUEkgdm9pZCBld2tfY29u dGV4dF9tZXNzYWdlX2Zyb21faW5qZWN0ZWRfYnVuZGxlX2NhbGxiYWNrX3NldChFd2tfQ29udGV4 dCAqY29udGV4dCwgRXdrX0NvbnRleHRfTWVzc2FnZV9Gcm9tX0luamVjdGVkX0J1bmRsZV9DYWxs YmFjayBjYWxsYmFjaywgdm9pZCAqdXNlcl9kYXRhKTsKKwogI2lmZGVmIF9fY3BsdXNwbHVzCiB9 CiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZWZsL2V3 a19jb250ZXh0X3ByaXZhdGUuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZWZsL2V3 a19jb250ZXh0X3ByaXZhdGUuaAppbmRleCBlMjAyM2QxODkzM2I0N2ZmY2FhMTUyNGJjMzRlMGYw MjQ4OWExOTljLi4wYTlmYWZmN2EyZDUwZTM5M2YyZGNkNDliZTEzNDI4NDRkM2M2MmEyIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2VmbC9ld2tfY29udGV4dF9wcml2 YXRlLmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9lZmwvZXdrX2NvbnRleHRf cHJpdmF0ZS5oCkBAIC04OCw2ICs4OCwxMSBAQCBwdWJsaWM6CiAKICAgICBKU0dsb2JhbENvbnRl eHRSZWYganNHbG9iYWxDb250ZXh0KCk7CiAKKyAgICBzdGF0aWMgdm9pZCBkaWRSZWNlaXZlTWVz c2FnZUZyb21JbmplY3RlZEJ1bmRsZShXS0NvbnRleHRSZWYsIFdLU3RyaW5nUmVmIG1lc3NhZ2VO YW1lLCBXS1R5cGVSZWYgbWVzc2FnZUJvZHksIGNvbnN0IHZvaWQqIGNsaWVudEluZm8pOworICAg IHN0YXRpYyB2b2lkIGRpZFJlY2VpdmVTeW5jaHJvbm91c01lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5k bGUoV0tDb250ZXh0UmVmLCBXS1N0cmluZ1JlZiBtZXNzYWdlTmFtZSwgV0tUeXBlUmVmIG1lc3Nh Z2VCb2R5LCBXS1R5cGVSZWYqIHJldHVybkRhdGEsIGNvbnN0IHZvaWQqIGNsaWVudEluZm8pOwor ICAgIHZvaWQgc2V0TWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZUNhbGxiYWNrKEV3a19Db250ZXh0 X01lc3NhZ2VfRnJvbV9JbmplY3RlZF9CdW5kbGVfQ2FsbGJhY2ssIHZvaWQqKTsKKyAgICB2b2lk IHByb2Nlc3NSZWNlaXZlZE1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUoV0tTdHJpbmdSZWYgbWVz c2FnZU5hbWUsIFdLVHlwZVJlZiBtZXNzYWdlQm9keSwgV0tUeXBlUmVmKiByZXR1cm5EYXRhKTsK KwogcHJpdmF0ZToKICAgICBleHBsaWNpdCBFd2tDb250ZXh0KFdLQ29udGV4dFJlZik7CiAKQEAg LTExMSw2ICsxMTYsMTEgQEAgcHJpdmF0ZToKICAgICBzdGQ6OnVuaXF1ZV9wdHI8V2ViS2l0OjpD b250ZXh0SGlzdG9yeUNsaWVudEVmbD4gbV9oaXN0b3J5Q2xpZW50OwogCiAgICAgSlNHbG9iYWxD b250ZXh0UmVmIG1fanNHbG9iYWxDb250ZXh0OworCisgICAgc3RydWN0IHsKKyAgICAgICAgRXdr X0NvbnRleHRfTWVzc2FnZV9Gcm9tX0luamVjdGVkX0J1bmRsZV9DYWxsYmFjayBjYWxsYmFjazsK KyAgICAgICAgdm9pZCogdXNlckRhdGE7CisgICAgfSBtX2NhbGxiYWNrRm9yTWVzc2FnZUZyb21J bmplY3RlZEJ1bmRsZTsKIH07CiAKICNlbmRpZiAvLyBld2tfY29udGV4dF9wcml2YXRlX2gK 222292 2014-01-26 17:21:25 -0800 2014-02-04 02:20:21 -0800 Patch bug-90772-20140127102125.patch text/plain 9574 enmi.lee U3VidmVyc2lvbiBSZXZpc2lvbjogMTYyNjkzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggYzllNDM3MzUxMWY5MzBj NGM3NjU3YTk5NzY1MjIxOTg0YTkxYzZmZS4uYTBjOWNiYjJjNmI4MDNhOTBlOGVhNWI5Y2VkZWMx NGEyYTgyNDc5YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2IEBACisyMDE0LTAxLTI2ICBFdW5t aSBMZWUgIDxldW5taTE1LmxlZUBzYW1zdW5nLmNvbT4KKworICAgICAgICBbRUZMXVtXSzJdIGV3 a19jb250ZXh0IG5lZWRzIHRvIHJvdXRlIEluamVjdGVkQnVuZGxlIG1lc3NhZ2VzIGNvcnJlY3Rs eS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTkwNzcy CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIEFQ SXMgdG8gcG9zdCBtZXNzYWdlIHRvIGluamVjdGVkIGJ1bmRsZSBhbmQgcmVnaXN0ZXIgY2FsbGJh Y2sgdG8KKyAgICAgICAgZ2V0IG1lc3NhZ2UgZnJvbSBpbmplY3RlZCBidW5kbGUuIFdoZW4gY2Fs bGJhY2sgaXMgcmVnaXN0ZXJlZCwKKyAgICAgICAgV0tDb250ZXh0SW5qZWN0ZWRCdW5kbGVDbGll bnQgaXMgc2V0IHRvIGdldCBtZXNzYWdlcyBmcm9tIGluamVjdGVkIGJ1bmRsZS4KKworICAgICAg ICAqIFVJUHJvY2Vzcy9BUEkvZWZsL2V3a19jb250ZXh0LmNwcDoKKyAgICAgICAgKEV3a0NvbnRl eHQ6OkV3a0NvbnRleHQpOgorICAgICAgICAodG9Fd2tDb250ZXh0KToKKyAgICAgICAgKEV3a0Nv bnRleHQ6OmRpZFJlY2VpdmVNZXNzYWdlRnJvbUluamVjdGVkQnVuZGxlKToKKyAgICAgICAgKEV3 a0NvbnRleHQ6OmRpZFJlY2VpdmVTeW5jaHJvbm91c01lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUp OgorICAgICAgICAoRXdrQ29udGV4dDo6c2V0TWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZUNhbGxi YWNrKTogcmVnaXN0ZXIgY2FsbGJhY2sgdG8gZ2V0IG1lc3NhZ2UgZnJvbSBpbmplY3RlZCBidW5k bGUuCisgICAgICAgIChFd2tDb250ZXh0Ojpwcm9jZXNzUmVjZWl2ZWRNZXNzYWdlRnJvbUluamVj dGVkQnVuZGxlKTogcHJvY2VzcyBtZXNzYWdlIGZyb20gaW5qZWN0ZWQgYnVuZGxlLgorICAgICAg ICAoZXdrX2NvbnRleHRfbWVzc2FnZV9wb3N0X3RvX2luamVjdGVkX2J1bmRsZSk6CisgICAgICAg IChld2tfY29udGV4dF9tZXNzYWdlX2Zyb21faW5qZWN0ZWRfYnVuZGxlX2NhbGxiYWNrX3NldCk6 CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9lZmwvZXdrX2NvbnRleHQuaDoKKyAgICAgICAgKiBV SVByb2Nlc3MvQVBJL2VmbC9ld2tfY29udGV4dF9wcml2YXRlLmg6CisKIDIwMTQtMDEtMjMgIEJy YWR5IEVpZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgogCiAgICAgICAgIElEQjogU3VwcG9ydCBJ REJPYmplY3RTdG9yZS5jbGVhcigpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvQVBJL2VmbC9ld2tfY29udGV4dC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2VmbC9ld2tfY29udGV4dC5jcHAKaW5kZXggZTQzZWE5NzVhZDYwNDg2NzdiZWQwZjViYWY1Zjdj OTVmMjM3NDU5Yy4uNTM2MmUwMmUzZWJkYTA4Y2Q5NzQ3NzVjMWNlMzRkNzQ3Yjg0ZTJlNSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9lZmwvZXdrX2NvbnRleHQuY3Bw CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZWZsL2V3a19jb250ZXh0LmNwcApA QCAtOTQsNiArOTQsOSBAQCBFd2tDb250ZXh0OjpFd2tDb250ZXh0KFdLQ29udGV4dFJlZiBjb250 ZXh0KQogICAgIC8vIGluZGVwZW5kZW50bHkgb2YgY2hlY2tpbmcgc3BlbGxpbmcgd2hpbGUgdHlw aW5nIHNldHRpbmcuCiAgICAgVGV4dENoZWNrZXJDbGllbnRFZmw6Omluc3RhbmNlKCkuZW5zdXJl U3BlbGxDaGVja2luZ0xhbmd1YWdlKCk7CiAjZW5kaWYKKworICAgIG1fY2FsbGJhY2tGb3JNZXNz YWdlRnJvbUluamVjdGVkQnVuZGxlLmNhbGxiYWNrID0gbnVsbHB0cjsKKyAgICBtX2NhbGxiYWNr Rm9yTWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZS51c2VyRGF0YSA9IG51bGxwdHI7CiB9CiAKIEV3 a0NvbnRleHQ6On5Fd2tDb250ZXh0KCkKQEAgLTI3NSw2ICsyNzgsNjYgQEAgQ29udGV4dEhpc3Rv cnlDbGllbnRFZmwqIEV3a0NvbnRleHQ6Omhpc3RvcnlDbGllbnQoKQogICAgIHJldHVybiBtX2hp c3RvcnlDbGllbnQuZ2V0KCk7CiB9CiAKK3N0YXRpYyBpbmxpbmUgRXdrQ29udGV4dCogdG9Fd2tD b250ZXh0KGNvbnN0IHZvaWQqIGNsaWVudEluZm8pCit7CisgICAgcmV0dXJuIHN0YXRpY19jYXN0 PEV3a0NvbnRleHQqPihjb25zdF9jYXN0PHZvaWQqPihjbGllbnRJbmZvKSk7Cit9CisKK3ZvaWQg RXdrQ29udGV4dDo6ZGlkUmVjZWl2ZU1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUoV0tDb250ZXh0 UmVmLCBXS1N0cmluZ1JlZiBtZXNzYWdlTmFtZSwgV0tUeXBlUmVmIG1lc3NhZ2VCb2R5LCBjb25z dCB2b2lkKiBjbGllbnRJbmZvKQoreworICAgIHRvRXdrQ29udGV4dChjbGllbnRJbmZvKS0+cHJv Y2Vzc1JlY2VpdmVkTWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZShtZXNzYWdlTmFtZSwgbWVzc2Fn ZUJvZHksIG51bGxwdHIpOworfQorCit2b2lkIEV3a0NvbnRleHQ6OmRpZFJlY2VpdmVTeW5jaHJv bm91c01lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUoV0tDb250ZXh0UmVmLCBXS1N0cmluZ1JlZiBt ZXNzYWdlTmFtZSwgV0tUeXBlUmVmIG1lc3NhZ2VCb2R5LCBXS1R5cGVSZWYqIHJldHVybkRhdGEs IGNvbnN0IHZvaWQqIGNsaWVudEluZm8pCit7CisgICAgdG9Fd2tDb250ZXh0KGNsaWVudEluZm8p LT5wcm9jZXNzUmVjZWl2ZWRNZXNzYWdlRnJvbUluamVjdGVkQnVuZGxlKG1lc3NhZ2VOYW1lLCBt ZXNzYWdlQm9keSwgcmV0dXJuRGF0YSk7Cit9CisKK3ZvaWQgRXdrQ29udGV4dDo6c2V0TWVzc2Fn ZUZyb21JbmplY3RlZEJ1bmRsZUNhbGxiYWNrKEV3a19Db250ZXh0X01lc3NhZ2VfRnJvbV9Jbmpl Y3RlZF9CdW5kbGVfQ2IgY2FsbGJhY2ssIHZvaWQqIHVzZXJEYXRhKQoreworICAgIG1fY2FsbGJh Y2tGb3JNZXNzYWdlRnJvbUluamVjdGVkQnVuZGxlLnVzZXJEYXRhID0gdXNlckRhdGE7CisKKyAg ICBpZiAobV9jYWxsYmFja0Zvck1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUuY2FsbGJhY2sgPT0g Y2FsbGJhY2spCisgICAgICAgIHJldHVybjsKKworICAgIGlmICghbV9jYWxsYmFja0Zvck1lc3Nh Z2VGcm9tSW5qZWN0ZWRCdW5kbGUuY2FsbGJhY2spIHsKKyAgICAgICAgV0tDb250ZXh0SW5qZWN0 ZWRCdW5kbGVDbGllbnRWMSBjbGllbnQ7CisgICAgICAgIG1lbXNldCgmY2xpZW50LCAwLCBzaXpl b2YoY2xpZW50KSk7CisKKyAgICAgICAgY2xpZW50LmJhc2UudmVyc2lvbiA9IDE7CisgICAgICAg IGNsaWVudC5iYXNlLmNsaWVudEluZm8gPSB0aGlzOworICAgICAgICBjbGllbnQuZGlkUmVjZWl2 ZU1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUgPSBkaWRSZWNlaXZlTWVzc2FnZUZyb21JbmplY3Rl ZEJ1bmRsZTsKKyAgICAgICAgY2xpZW50LmRpZFJlY2VpdmVTeW5jaHJvbm91c01lc3NhZ2VGcm9t SW5qZWN0ZWRCdW5kbGUgPSBkaWRSZWNlaXZlU3luY2hyb25vdXNNZXNzYWdlRnJvbUluamVjdGVk QnVuZGxlOworCisgICAgICAgIFdLQ29udGV4dFNldEluamVjdGVkQnVuZGxlQ2xpZW50KG1fY29u dGV4dC5nZXQoKSwgJmNsaWVudC5iYXNlKTsKKyAgICB9IGVsc2UgaWYgKCFjYWxsYmFjaykKKyAg ICAgICAgV0tDb250ZXh0U2V0SW5qZWN0ZWRCdW5kbGVDbGllbnQobV9jb250ZXh0LmdldCgpLCBu dWxscHRyKTsKKworICAgIG1fY2FsbGJhY2tGb3JNZXNzYWdlRnJvbUluamVjdGVkQnVuZGxlLmNh bGxiYWNrID0gY2FsbGJhY2s7Cit9CisKK3ZvaWQgRXdrQ29udGV4dDo6cHJvY2Vzc1JlY2VpdmVk TWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZShXS1N0cmluZ1JlZiBtZXNzYWdlTmFtZSwgV0tUeXBl UmVmIG1lc3NhZ2VCb2R5LCBXS1R5cGVSZWYqIHJldHVybkRhdGEpCit7CisgICAgaWYgKCFtX2Nh bGxiYWNrRm9yTWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZS5jYWxsYmFjaykKKyAgICAgICAgcmV0 dXJuOworCisgICAgQ1N0cmluZyBuYW1lID0gdG9JbXBsKG1lc3NhZ2VOYW1lKS0+c3RyaW5nKCku dXRmOCgpOworICAgIENTdHJpbmcgYm9keTsKKyAgICBpZiAobWVzc2FnZUJvZHkgJiYgV0tTdHJp bmdHZXRUeXBlSUQoKSA9PSBXS0dldFR5cGVJRChtZXNzYWdlQm9keSkpCisgICAgICAgIGJvZHkg PSB0b0ltcGwoc3RhdGljX2Nhc3Q8V0tTdHJpbmdSZWY+KG1lc3NhZ2VCb2R5KSktPnN0cmluZygp LnV0ZjgoKTsKKworICAgIGlmIChyZXR1cm5EYXRhKSB7CisgICAgICAgIGNoYXIqIHJldHVyblN0 cmluZyA9IG51bGxwdHI7CisgICAgICAgIG1fY2FsbGJhY2tGb3JNZXNzYWdlRnJvbUluamVjdGVk QnVuZGxlLmNhbGxiYWNrKG5hbWUuZGF0YSgpLCBib2R5LmRhdGEoKSwgJnJldHVyblN0cmluZywg bV9jYWxsYmFja0Zvck1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUudXNlckRhdGEpOworICAgICAg ICBpZiAocmV0dXJuU3RyaW5nKSB7CisgICAgICAgICAgICAqcmV0dXJuRGF0YSA9IFdLU3RyaW5n Q3JlYXRlV2l0aFVURjhDU3RyaW5nKHJldHVyblN0cmluZyk7CisgICAgICAgICAgICBmcmVlKHJl dHVyblN0cmluZyk7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgKnJldHVybkRhdGEgPSBX S1N0cmluZ0NyZWF0ZVdpdGhVVEY4Q1N0cmluZygiIik7CisgICAgfSBlbHNlCisgICAgICAgIG1f Y2FsbGJhY2tGb3JNZXNzYWdlRnJvbUluamVjdGVkQnVuZGxlLmNhbGxiYWNrKG5hbWUuZGF0YSgp LCBib2R5LmRhdGEoKSwgbnVsbHB0ciwgbV9jYWxsYmFja0Zvck1lc3NhZ2VGcm9tSW5qZWN0ZWRC dW5kbGUudXNlckRhdGEpOworfQorCiBFd2tfQ29udGV4dCogZXdrX2NvbnRleHRfZGVmYXVsdF9n ZXQoKQogewogICAgIHJldHVybiBFd2tDb250ZXh0OjpkZWZhdWx0Q29udGV4dCgpOwpAQCAtMzYx LDMgKzQyNCwyMCBAQCB2b2lkIGV3a19jb250ZXh0X3Jlc291cmNlX2NhY2hlX2NsZWFyKEV3a19D b250ZXh0KiBld2tDb250ZXh0KQogICAgIGltcGwtPmNsZWFyUmVzb3VyY2VDYWNoZSgpOwogfQog Cit2b2lkIGV3a19jb250ZXh0X21lc3NhZ2VfcG9zdF90b19pbmplY3RlZF9idW5kbGUoRXdrX0Nv bnRleHQqIGV3a0NvbnRleHQsIGNvbnN0IGNoYXIqIG5hbWUsIGNvbnN0IGNoYXIqIGJvZHkpCit7 CisgICAgRVdLX09CSl9HRVRfSU1QTF9PUl9SRVRVUk4oRXdrQ29udGV4dCwgZXdrQ29udGV4dCwg aW1wbCk7CisgICAgRUlOQV9TQUZFVFlfT05fTlVMTF9SRVRVUk4obmFtZSk7CisgICAgRUlOQV9T QUZFVFlfT05fTlVMTF9SRVRVUk4oYm9keSk7CisKKyAgICBXS1JldGFpblB0cjxXS1N0cmluZ1Jl Zj4gbWVzc2FnZU5hbWUoQWRvcHRXSywgV0tTdHJpbmdDcmVhdGVXaXRoVVRGOENTdHJpbmcobmFt ZSkpOworICAgIFdLUmV0YWluUHRyPFdLU3RyaW5nUmVmPiBtZXNzYWdlQm9keShBZG9wdFdLLCBX S1N0cmluZ0NyZWF0ZVdpdGhVVEY4Q1N0cmluZyhib2R5KSk7CisgICAgV0tDb250ZXh0UG9zdE1l c3NhZ2VUb0luamVjdGVkQnVuZGxlKGltcGwtPndrQ29udGV4dCgpLCBtZXNzYWdlTmFtZS5nZXQo KSwgbWVzc2FnZUJvZHkuZ2V0KCkpOworfQorCit2b2lkIGV3a19jb250ZXh0X21lc3NhZ2VfZnJv bV9pbmplY3RlZF9idW5kbGVfY2FsbGJhY2tfc2V0KEV3a19Db250ZXh0KiBld2tDb250ZXh0LCBF d2tfQ29udGV4dF9NZXNzYWdlX0Zyb21fSW5qZWN0ZWRfQnVuZGxlX0NiIGNhbGxiYWNrLCB2b2lk KiB1c2VyRGF0YSkKK3sKKyAgICBFV0tfT0JKX0dFVF9JTVBMX09SX1JFVFVSTihFd2tDb250ZXh0 LCBld2tDb250ZXh0LCBpbXBsKTsKKworICAgIGltcGwtPnNldE1lc3NhZ2VGcm9tSW5qZWN0ZWRC dW5kbGVDYWxsYmFjayhjYWxsYmFjaywgdXNlckRhdGEpOworfQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9lZmwvZXdrX2NvbnRleHQuaCBiL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9BUEkvZWZsL2V3a19jb250ZXh0LmgKaW5kZXggNWQ0NDBhYTk0NmEzMWUwYTk0 ZjE4NzhlZjBhM2VmMjc4NGNlY2E4MS4uMTNiMTZkM2MxNDY4ZDRmMDQwYWZiMGJlMDYzYjg4MGU5 MDNkN2JmNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9lZmwvZXdr X2NvbnRleHQuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2VmbC9ld2tfY29u dGV4dC5oCkBAIC0xMTIsNiArMTEyLDE5IEBAIHR5cGVkZWYgdm9pZCAoKkV3a19IaXN0b3J5X1Rp dGxlX1VwZGF0ZV9DYikoY29uc3QgRXZhc19PYmplY3QgKnZpZXcsIGNvbnN0IGNoYXIKIHR5cGVk ZWYgdm9pZCAoKkV3a19IaXN0b3J5X1BvcHVsYXRlX1Zpc2l0ZWRfTGlua3NfQ2IpKHZvaWQgKnVz ZXJfZGF0YSk7CiAKIC8qKgorICogQ2FsbGJhY2sgZm9yIGRpZFJlY2VpdmVNZXNzYWdlRnJvbUlu amVjdGVkQnVuZGxlIGFuZCBkaWRSZWNlaXZlU3luY2hyb25vdXNNZXNzYWdlRnJvbUluamVjdGVk QnVuZGxlCisgKgorICogVXNlciBzaG91bGQgYWxsb2NhdGUgbmV3IHN0cmluZyBmb3IgcmV0dXJu X2RhdGEgYmVmb3JlIHNldHRpbmcgaXQuCisgKiBUaGUgcmV0dXJuX2RhdGEgc3RyaW5nIHdpbGwg YmUgZnJlZWQgb24gV2ViS2l0IHNpZGUuCisgKgorICogQHBhcmFtIG5hbWUgbmFtZSBvZiBtZXNz YWdlIGZyb20gaW5qZWN0ZWQgYnVuZGxlCisgKiBAcGFyYW0gYm9keSBib2R5IG9mIG1lc3NhZ2Ug ZnJvbSBpbmplY3RlZCBidW5kbGUKKyAqIEBwYXJhbSByZXR1cm5fZGF0YSByZXR1cm5fZGF0YSBz dHJpbmcgZnJvbSBhcHBsaWNhdGlvbgorICogQHBhcmFtIHVzZXJfZGF0YSB1c2VyX2RhdGEgd2ls bCBiZSBwYXNzc2VkIHdoZW4gcmVjZWl2aW5nIG1lc3NhZ2UgZnJvbSBpbmplY3RlZCBidW5kbGUK KyAqLwordHlwZWRlZiB2b2lkICgqRXdrX0NvbnRleHRfTWVzc2FnZV9Gcm9tX0luamVjdGVkX0J1 bmRsZV9DYikoY29uc3QgY2hhciAqbmFtZSwgY29uc3QgY2hhciAqYm9keSwgY2hhciAqKnJldHVy bl9kYXRhLCB2b2lkICp1c2VyX2RhdGEpOworCisvKioKICAqIEdldHMgZGVmYXVsdCBFd2tfQ29u dGV4dCBpbnN0YW5jZS4KICAqCiAgKiBUaGUgcmV0dXJuZWQgRXdrX0NvbnRleHQgb2JqZWN0IEBi IHNob3VsZCBub3QgYmUgdW5yZWYnZWQgaWYgYXBwbGljYXRpb24KQEAgLTMxOSw2ICszMzIsMjYg QEAgRUFQSSBFaW5hX0Jvb2wgZXdrX2NvbnRleHRfYWRkaXRpb25hbF9wbHVnaW5fcGF0aF9zZXQo RXdrX0NvbnRleHQgKmNvbnRleHQsIGNvbnMKICAqLwogRUFQSSB2b2lkIGV3a19jb250ZXh0X3Jl c291cmNlX2NhY2hlX2NsZWFyKEV3a19Db250ZXh0ICpjb250ZXh0KTsKIAorLyoqCisgKiBQb3N0 cyBtZXNzYWdlIHRvIGluamVjdGVkIGJ1bmRsZS4KKyAqCisgKiBAcGFyYW0gY29udGV4dCBjb250 ZXh0IG9iamVjdCB0byBwb3N0IG1lc3NhZ2UgdG8gaW5qZWN0ZWQgYnVuZGxlCisgKiBAcGFyYW0g bmFtZSBtZXNzYWdlIG5hbWUKKyAqIEBwYXJhbSBib2R5IG1lc3NhZ2UgYm9keQorICovCitFQVBJ IHZvaWQgZXdrX2NvbnRleHRfbWVzc2FnZV9wb3N0X3RvX2luamVjdGVkX2J1bmRsZShFd2tfQ29u dGV4dCAqY29udGV4dCwgY29uc3QgY2hhciAqbmFtZSwgY29uc3QgY2hhciAqYm9keSk7CisKKy8q KgorICogU2V0cyBjYWxsYmFjayBmb3IgcmVjZWl2ZWQgaW5qZWN0ZWQgYnVuZGxlIG1lc3NhZ2Uu CisgKgorICogQ2xpZW50IGNhbiBwYXNzIEBjIE5VTEwgZm9yIGNhbGxiYWNrIHRvIHN0b3AgbGlz dGVuaW5nIGZvciBtZXNzYWdlcy4KKyAqCisgKiBAcGFyYW0gY29udGV4dCBjb250ZXh0IG9iamVj dAorICogQHBhcmFtIGNhbGxiYWNrIGNhbGxiYWNrIGZvciByZWNlaXZlZCBpbmplY3RlZCBidW5k bGUgbWVzc2FnZSBvciBAYyBOVUxMCisgKiBAcGFyYW0gdXNlcl9kYXRhIHVzZXIgZGF0YQorICov CitFQVBJIHZvaWQgZXdrX2NvbnRleHRfbWVzc2FnZV9mcm9tX2luamVjdGVkX2J1bmRsZV9jYWxs YmFja19zZXQoRXdrX0NvbnRleHQgKmNvbnRleHQsIEV3a19Db250ZXh0X01lc3NhZ2VfRnJvbV9J bmplY3RlZF9CdW5kbGVfQ2IgY2FsbGJhY2ssIHZvaWQgKnVzZXJfZGF0YSk7CisKICNpZmRlZiBf X2NwbHVzcGx1cwogfQogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvQVBJL2VmbC9ld2tfY29udGV4dF9wcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvQVBJL2VmbC9ld2tfY29udGV4dF9wcml2YXRlLmgKaW5kZXggZTIwMjNkMTg5MzNiNDdmZmNh YTE1MjRiYzM0ZTBmMDI0ODlhMTk5Yy4uZmUzMzE0OTU2MjZhNjQzZDczY2EwMDNjZjkxOGU1NGE2 N2E3ZWMzOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9lZmwvZXdr X2NvbnRleHRfcHJpdmF0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZWZs L2V3a19jb250ZXh0X3ByaXZhdGUuaApAQCAtODgsNiArODgsMTEgQEAgcHVibGljOgogCiAgICAg SlNHbG9iYWxDb250ZXh0UmVmIGpzR2xvYmFsQ29udGV4dCgpOwogCisgICAgc3RhdGljIHZvaWQg ZGlkUmVjZWl2ZU1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUoV0tDb250ZXh0UmVmLCBXS1N0cmlu Z1JlZiBtZXNzYWdlTmFtZSwgV0tUeXBlUmVmIG1lc3NhZ2VCb2R5LCBjb25zdCB2b2lkKiBjbGll bnRJbmZvKTsKKyAgICBzdGF0aWMgdm9pZCBkaWRSZWNlaXZlU3luY2hyb25vdXNNZXNzYWdlRnJv bUluamVjdGVkQnVuZGxlKFdLQ29udGV4dFJlZiwgV0tTdHJpbmdSZWYgbWVzc2FnZU5hbWUsIFdL VHlwZVJlZiBtZXNzYWdlQm9keSwgV0tUeXBlUmVmKiByZXR1cm5EYXRhLCBjb25zdCB2b2lkKiBj bGllbnRJbmZvKTsKKyAgICB2b2lkIHNldE1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGVDYWxsYmFj ayhFd2tfQ29udGV4dF9NZXNzYWdlX0Zyb21fSW5qZWN0ZWRfQnVuZGxlX0NiLCB2b2lkKik7Cisg ICAgdm9pZCBwcm9jZXNzUmVjZWl2ZWRNZXNzYWdlRnJvbUluamVjdGVkQnVuZGxlKFdLU3RyaW5n UmVmIG1lc3NhZ2VOYW1lLCBXS1R5cGVSZWYgbWVzc2FnZUJvZHksIFdLVHlwZVJlZiogcmV0dXJu RGF0YSk7CisKIHByaXZhdGU6CiAgICAgZXhwbGljaXQgRXdrQ29udGV4dChXS0NvbnRleHRSZWYp OwogCkBAIC0xMTEsNiArMTE2LDExIEBAIHByaXZhdGU6CiAgICAgc3RkOjp1bmlxdWVfcHRyPFdl YktpdDo6Q29udGV4dEhpc3RvcnlDbGllbnRFZmw+IG1faGlzdG9yeUNsaWVudDsKIAogICAgIEpT R2xvYmFsQ29udGV4dFJlZiBtX2pzR2xvYmFsQ29udGV4dDsKKworICAgIHN0cnVjdCB7CisgICAg ICAgIEV3a19Db250ZXh0X01lc3NhZ2VfRnJvbV9JbmplY3RlZF9CdW5kbGVfQ2IgY2FsbGJhY2s7 CisgICAgICAgIHZvaWQqIHVzZXJEYXRhOworICAgIH0gbV9jYWxsYmFja0Zvck1lc3NhZ2VGcm9t SW5qZWN0ZWRCdW5kbGU7CiB9OwogCiAjZW5kaWYgLy8gZXdrX2NvbnRleHRfcHJpdmF0ZV9oCg==