100775 2012-10-30 11:46:30 -0700 [GTK] Remove dependency on SoupPasswordManager 2018-12-08 09:43:16 -0800 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 99914 1 mrobinson mrobinson bhhunter84 cgarcia danw dbates gtk-ews gustavo webkit.review.bot xan.lopez oldest_to_newest 754541 0 mrobinson 2012-10-30 11:46:30 -0700 We should remove the dependency on SoupPasswordManager in WebKitGTK+ and use libsecret directly. This is one step in the direction of full-fledged support for authentication. 754758 1 171542 mrobinson 2012-10-30 16:10:51 -0700 Created attachment 171542 Patch 754764 2 webkit.review.bot 2012-10-30 16:14:20 -0700 Attachment 171542 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'ChangeLog', u'Source/WebCore/ChangeLog', u..." exit_code: 1 Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:64: Use 0 instead of NULL. [readability/null] [5] Total errors found: 1 in 14 files If any of these errors are false positives, please file a bug against check-webkit-style. 754767 3 mrobinson 2012-10-30 16:17:43 -0700 (In reply to comment #2) > If any of these errors are false positives, please file a bug against check-webkit-style. The NULL is necessary here to avoid issues with varargs. 754815 4 171542 gtk-ews 2012-10-30 17:17:31 -0700 Comment on attachment 171542 Patch Attachment 171542 did not pass gtk-ews (gtk): Output: http://queues.webkit.org/results/14647056 754819 5 mrobinson 2012-10-30 17:24:07 -0700 Looks like the EWS needs libsecret-1. 754825 6 171542 gtk-ews 2012-10-30 17:30:41 -0700 Comment on attachment 171542 Patch Attachment 171542 did not pass gtk-ews (gtk): Output: http://queues.webkit.org/results/14660034 755049 7 171542 cgarcia 2012-10-31 01:29:57 -0700 Comment on attachment 171542 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=171542&action=review This looks great, the only problem I see is that I think we should use the async API of libsecret. I guess we need to install libsecret in EWS and the bots, should we update the jhbuild moduleset too? > Source/WebCore/ChangeLog:11 > + a dependency on SoupPasswordManager. I guess you forgot to remove this line. > Source/WebKit/gtk/ChangeLog:9 > + Add a libsecret dependency to the build. This is necessary so that we can remove > + a dependency on SoupPasswordManager. Note that we don't have a hard dependency on SoupPasswordManager, so maybe libsecret should also be used optionally. We could add ifdefs to the CredentialBackingStore implementation or make a specific class for libsecret similar to the geoclue geolocation manager class. > Source/WebCore/GNUmakefile.list.am:4740 > + Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp \ > + Source/WebCore/platform/network/gtk/CredentialBackingStore.h \ Maybe we could use a different name for the directory than gtk, since libsecret doesn't depend on gtk, like we did for geoclue code. Libsecret uses glib to implement the freedesktop secrets spec (I think) so it could be used by other ports that depend on glib, I'm not sure though. In any case it's just a name, we could leave gtk and just renamed it later if needed. > Source/WebCore/platform/gtk/GtkAuthenticationDialog.cpp:200 > - bool haveSavedLogin = getSavedLogin(m_auth.get(), &username, &password); > soup_session_pause_message(m_session, m_message.get()); > - gtk_entry_set_text(GTK_ENTRY(m_loginEntry), username ? username : ""); > - gtk_entry_set_text(GTK_ENTRY(m_passwordEntry), password ? password : ""); > - if (m_rememberCheckButton && haveSavedLogin) > + > + // This is just a temporary kludge until GtkAuthenticationDialog works directly with AuthenticationChallenges. > + AuthenticationChallenge challenge(0 /* session */, m_message.get(), m_auth.get(), false, 0); > + Credential savedCredential = credentialBackingStore().getCredentialForChallenge(challenge); > + if (!savedCredential.isEmpty()) { At this point in previous code, soup had already the users and passwords cached in hash tables, so that soup_auth_get_saved_users() and soup_auth_get_saved_password() can be used synchornously, but now we are using the sync api of libsecret that blocks the main loop until the service is created (the first time) and the users/passwords are retrieved. CredentialBackingStore API should be fully async, like the previous soup API, so that we don't show the dialog until the credential has been retrieved. > Source/WebCore/platform/gtk/GtkAuthenticationDialog.cpp:243 > - if (m_message.get()->status_code != 401 && m_message.get()->status_code < 500) > - soup_auth_save_password(m_auth.get(), m_username.data(), m_password.data()); > + if (m_message.get()->status_code != 401 && m_message.get()->status_code < 500) { > + // This is just a temporary kludge until GtkAuthenticationDialog works directly with AuthenticationChallenges. > + AuthenticationChallenge challenge(0 /* session */, m_message.get(), m_auth.get(), false, 0); > + Credential credentialToSave = Credential( > + String::fromUTF8(m_username.data()), > + String::fromUTF8(m_password.data()), > + CredentialPersistencePermanent); > + credentialBackingStore().storeCredentialsForChallenge(challenge, credentialToSave); Same here, this blocks the main loop, but we are not even interested in the result of the operation. > Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:81 > + GOwnPtr<GList> elements(secret_service_search_sync( > + 0, // The default SecretService. > + SECRET_SCHEMA_COMPAT_NETWORK, > + createAttributeHashTableFromChallenge(challenge).get(), > + static_cast<SecretSearchFlags>(SECRET_SEARCH_UNLOCK | SECRET_SEARCH_LOAD_SECRETS), // The default behavior is to only return the most recent item. > + 0, // cancellable > + &error.outPtr())); I think we should use the async API. > Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:113 > + secret_service_store_sync( > + 0, // The default SecretService. > + SECRET_SCHEMA_COMPAT_NETWORK, > + createAttributeHashTableFromChallenge(challenge, credential).get(), > + SECRET_COLLECTION_DEFAULT, > + _("WebKitGTK+ password"), > + newSecretValue.get(), > + 0, // cancellable > + &error.outPtr()); Ditto. In this case we could just pass NULL for the async ready callback, since we are not interested in the result of the operation. > Source/WebCore/platform/network/gtk/CredentialBackingStore.h:34 > +class KURL; Is KURL needed here? Could we use forward declarations of AuthenticationChallenge and Credential here too instead of including the headers? 755344 8 danw 2012-10-31 08:47:50 -0700 (In reply to comment #7) > Note that we don't have a hard dependency on SoupPasswordManager, so maybe libsecret should also be used optionally. The soft dependency on SoupPasswordManager was because it has been planned-to-be-deprecated almost as long as WebKit has been using it, and there was the possibility that it might just disappear in a future release of libsoup. > Maybe we could use a different name for the directory than gtk, since libsecret doesn't depend on gtk, like we did for geoclue code. Libsecret uses glib to implement the freedesktop secrets spec (I think) so it could be used by other ports that depend on glib Yes, in theory the EFL port should be able to use it as well (thought it would only be useful if they were running on a system that had a secrets/keyring/wallet daemon). If you're using the async API though, it doesn't just "depend on glib", it depends on you running a glib mainloop. So really, it's pretty much tied to the soup backend, so maybe it should just go into soup/ ? 755370 9 mrobinson 2012-10-31 09:24:40 -0700 (In reply to comment #7) > (From update of attachment 171542 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=171542&action=review > > This looks great, the only problem I see is that I think we should use the async API of libsecret. I guess we need to install libsecret in EWS and the bots, should we update the jhbuild moduleset too? Yes, I think so too, but I would like to do that in another patch. In this patch I would just like to establish feature parity with the libsoup code. I don't mind making code that sets the password asynchronous, since it's very simple. As for getting the password, I have not even decided yet where the code will go. It's even possible that the dialog will not show up for credentials that are saved cross-session (this is how the mac port works for instance), so writing a lot of wiring here for asynchronous behavior doesn't make sense yet. > > Source/WebCore/ChangeLog:11 > > + a dependency on SoupPasswordManager. > > I guess you forgot to remove this line. > > > Source/WebKit/gtk/ChangeLog:9 > > + Add a libsecret dependency to the build. This is necessary so that we can remove > > + a dependency on SoupPasswordManager. > > Note that we don't have a hard dependency on SoupPasswordManager, so maybe libsecret should also be used optionally. We could add ifdefs to the CredentialBackingStore implementation or make a specific class for libsecret similar to the geoclue geolocation manager class. I've been mulling this a bit and I think a hard dependency is fine right now for the GTK+ port. By the time that 2.0 ships, most desktop distributions be shipping it in the installed base. In any case, I think that making libsecret an optional dependency can be done in a followup patch. It makes sense to save the #ifdefs until this code is in the final place. That should happen soon, but I need to land this patch and the dependent as well. This was the approach we followed for spell checking. > > > Source/WebCore/GNUmakefile.list.am:4740 > > + Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp \ > > + Source/WebCore/platform/network/gtk/CredentialBackingStore.h \ > > Maybe we could use a different name for the directory than gtk, since libsecret doesn't depend on gtk, like we did for geoclue code. Libsecret uses glib to implement the freedesktop secrets spec (I think) so it could be used by other ports that depend on glib, I'm not sure though. In any case it's just a name, we could leave gtk and just renamed it later if needed. In this case "gtk" is better since it's not shared. If it's shared then it can move to a directory with a different name. It's in the "gtk" directory because it's only used by the GTK+ port. > > > Source/WebCore/platform/gtk/GtkAuthenticationDialog.cpp:200 > > - bool haveSavedLogin = getSavedLogin(m_auth.get(), &username, &password); > > soup_session_pause_message(m_session, m_message.get()); > > - gtk_entry_set_text(GTK_ENTRY(m_loginEntry), username ? username : ""); > > - gtk_entry_set_text(GTK_ENTRY(m_passwordEntry), password ? password : ""); > > - if (m_rememberCheckButton && haveSavedLogin) > > + > > + // This is just a temporary kludge until GtkAuthenticationDialog works directly with AuthenticationChallenges. > > + AuthenticationChallenge challenge(0 /* session */, m_message.get(), m_auth.get(), false, 0); > > + Credential savedCredential = credentialBackingStore().getCredentialForChallenge(challenge); > > + if (!savedCredential.isEmpty()) { > > At this point in previous code, soup had already the users and passwords cached in hash tables, so that soup_auth_get_saved_users() and soup_auth_get_saved_password() can be used synchornously, but now we are using the sync api of libsecret that blocks the main loop until the service is created (the first time) and the users/passwords are retrieved. CredentialBackingStore API should be fully async, like the previous soup API, so that we don't show the dialog until the credential has been retrieved. As I said above, I plan to make this asynchronous and this is just a step in that direction. There's a chicken and egg problem with these patches, since you won't allow me to regress any features even between releases and I don't want to build up a catalog of 5 patches and land them at once. This patch breaks the cycle. > > > Source/WebCore/platform/gtk/GtkAuthenticationDialog.cpp:243 > > - if (m_message.get()->status_code != 401 && m_message.get()->status_code < 500) > > - soup_auth_save_password(m_auth.get(), m_username.data(), m_password.data()); > > + if (m_message.get()->status_code != 401 && m_message.get()->status_code < 500) { > > + // This is just a temporary kludge until GtkAuthenticationDialog works directly with AuthenticationChallenges. > > + AuthenticationChallenge challenge(0 /* session */, m_message.get(), m_auth.get(), false, 0); > > + Credential credentialToSave = Credential( > > + String::fromUTF8(m_username.data()), > > + String::fromUTF8(m_password.data()), > > + CredentialPersistencePermanent); > > + credentialBackingStore().storeCredentialsForChallenge(challenge, credentialToSave); > > Same here, this blocks the main loop, but we are not even interested in the result of the operation. > > > Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:81 > > + GOwnPtr<GList> elements(secret_service_search_sync( > > + 0, // The default SecretService. > > + SECRET_SCHEMA_COMPAT_NETWORK, > > + createAttributeHashTableFromChallenge(challenge).get(), > > + static_cast<SecretSearchFlags>(SECRET_SEARCH_UNLOCK | SECRET_SEARCH_LOAD_SECRETS), // The default behavior is to only return the most recent item. > > + 0, // cancellable > > + &error.outPtr())); > > I think we should use the async API. > > > Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:113 > > + secret_service_store_sync( > > + 0, // The default SecretService. > > + SECRET_SCHEMA_COMPAT_NETWORK, > > + createAttributeHashTableFromChallenge(challenge, credential).get(), > > + SECRET_COLLECTION_DEFAULT, > > + _("WebKitGTK+ password"), > > + newSecretValue.get(), > > + 0, // cancellable > > + &error.outPtr()); > > Ditto. In this case we could just pass NULL for the async ready callback, since we are not interested in the result of the operation. > > > Source/WebCore/platform/network/gtk/CredentialBackingStore.h:34 > > +class KURL; > > Is KURL needed here? Could we use forward declarations of AuthenticationChallenge and Credential here too instead of including the headers? These forward declarations aren't necessary. I think I can add one for AuthenticationChallenge, but not Credential. I'll update the patch. 755399 10 cgarcia 2012-10-31 09:50:43 -0700 (In reply to comment #9) > (In reply to comment #7) > > (From update of attachment 171542 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=171542&action=review > > > > This looks great, the only problem I see is that I think we should use the async API of libsecret. I guess we need to install libsecret in EWS and the bots, should we update the jhbuild moduleset too? > > Yes, I think so too, but I would like to do that in another patch. In this patch I would just like to establish feature parity with the libsoup code. I don't mind making code that sets the password asynchronous, since it's very simple. As for getting the password, I have not even decided yet where the code will go. It's even possible that the dialog will not show up for credentials that are saved cross-session (this is how the mac port works for instance), so writing a lot of wiring here for asynchronous behavior doesn't make sense yet. Ah, ok, blocking the UI for some time is better than a regression after all :-) > > > Source/WebCore/ChangeLog:11 > > > + a dependency on SoupPasswordManager. > > > > I guess you forgot to remove this line. > > > > > Source/WebKit/gtk/ChangeLog:9 > > > + Add a libsecret dependency to the build. This is necessary so that we can remove > > > + a dependency on SoupPasswordManager. > > > > Note that we don't have a hard dependency on SoupPasswordManager, so maybe libsecret should also be used optionally. We could add ifdefs to the CredentialBackingStore implementation or make a specific class for libsecret similar to the geoclue geolocation manager class. > > I've been mulling this a bit and I think a hard dependency is fine right now for the GTK+ port. By the time that 2.0 ships, most desktop distributions be shipping it in the installed base. In any case, I think that making libsecret an optional dependency can be done in a followup patch. It makes sense to save the #ifdefs until this code is in the final place. That should happen soon, but I need to land this patch and the dependent as well. This was the approach we followed for spell checking. I'm fine with a hard dependency for now, if people complain in the future we can easily make it optional for the final code like enchant or geoclue. > > > > > Source/WebCore/GNUmakefile.list.am:4740 > > > + Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp \ > > > + Source/WebCore/platform/network/gtk/CredentialBackingStore.h \ > > > > Maybe we could use a different name for the directory than gtk, since libsecret doesn't depend on gtk, like we did for geoclue code. Libsecret uses glib to implement the freedesktop secrets spec (I think) so it could be used by other ports that depend on glib, I'm not sure though. In any case it's just a name, we could leave gtk and just renamed it later if needed. > > In this case "gtk" is better since it's not shared. If it's shared then it can move to a directory with a different name. It's in the "gtk" directory because it's only used by the GTK+ port. I guess it will be easier to decide later, yes, let's use gtk for now, we can always move it libsecret/soup or whatever. > > > Source/WebCore/platform/gtk/GtkAuthenticationDialog.cpp:200 > > > - bool haveSavedLogin = getSavedLogin(m_auth.get(), &username, &password); > > > soup_session_pause_message(m_session, m_message.get()); > > > - gtk_entry_set_text(GTK_ENTRY(m_loginEntry), username ? username : ""); > > > - gtk_entry_set_text(GTK_ENTRY(m_passwordEntry), password ? password : ""); > > > - if (m_rememberCheckButton && haveSavedLogin) > > > + > > > + // This is just a temporary kludge until GtkAuthenticationDialog works directly with AuthenticationChallenges. > > > + AuthenticationChallenge challenge(0 /* session */, m_message.get(), m_auth.get(), false, 0); > > > + Credential savedCredential = credentialBackingStore().getCredentialForChallenge(challenge); > > > + if (!savedCredential.isEmpty()) { > > > > At this point in previous code, soup had already the users and passwords cached in hash tables, so that soup_auth_get_saved_users() and soup_auth_get_saved_password() can be used synchornously, but now we are using the sync api of libsecret that blocks the main loop until the service is created (the first time) and the users/passwords are retrieved. CredentialBackingStore API should be fully async, like the previous soup API, so that we don't show the dialog until the credential has been retrieved. > > As I said above, I plan to make this asynchronous and this is just a step in that direction. There's a chicken and egg problem with these patches, since you won't allow me to regress any features even between releases and I don't want to build up a catalog of 5 patches and land them at once. This patch breaks the cycle. Sure, I didn't know you were planning to make it async in future patches. > > > > > Source/WebCore/platform/gtk/GtkAuthenticationDialog.cpp:243 > > > - if (m_message.get()->status_code != 401 && m_message.get()->status_code < 500) > > > - soup_auth_save_password(m_auth.get(), m_username.data(), m_password.data()); > > > + if (m_message.get()->status_code != 401 && m_message.get()->status_code < 500) { > > > + // This is just a temporary kludge until GtkAuthenticationDialog works directly with AuthenticationChallenges. > > > + AuthenticationChallenge challenge(0 /* session */, m_message.get(), m_auth.get(), false, 0); > > > + Credential credentialToSave = Credential( > > > + String::fromUTF8(m_username.data()), > > > + String::fromUTF8(m_password.data()), > > > + CredentialPersistencePermanent); > > > + credentialBackingStore().storeCredentialsForChallenge(challenge, credentialToSave); > > > > Same here, this blocks the main loop, but we are not even interested in the result of the operation. >> > > > Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:81 > > > + GOwnPtr<GList> elements(secret_service_search_sync( > > > + 0, // The default SecretService. > > > + SECRET_SCHEMA_COMPAT_NETWORK, > > > + createAttributeHashTableFromChallenge(challenge).get(), > > > + static_cast<SecretSearchFlags>(SECRET_SEARCH_UNLOCK | SECRET_SEARCH_LOAD_SECRETS), // The default behavior is to only return the most recent item. > > > + 0, // cancellable > > > + &error.outPtr())); > > > > I think we should use the async API. > > > > > Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:113 > > > + secret_service_store_sync( > > > + 0, // The default SecretService. > > > + SECRET_SCHEMA_COMPAT_NETWORK, > > > + createAttributeHashTableFromChallenge(challenge, credential).get(), > > > + SECRET_COLLECTION_DEFAULT, > > > + _("WebKitGTK+ password"), > > > + newSecretValue.get(), > > > + 0, // cancellable > > > + &error.outPtr()); > > > > Ditto. In this case we could just pass NULL for the async ready callback, since we are not interested in the result of the operation. If we are going to keep the sync api for now, it would be better to pass NULL for the error, since we are not using it. > > > Source/WebCore/platform/network/gtk/CredentialBackingStore.h:34 > > > +class KURL; > > > > Is KURL needed here? Could we use forward declarations of AuthenticationChallenge and Credential here too instead of including the headers? > > These forward declarations aren't necessary. I think I can add one for AuthenticationChallenge, but not Credential. I'll update the patch. Great, thanks! 755400 11 171676 mrobinson 2012-10-31 09:51:13 -0700 Created attachment 171676 Patch 755405 12 webkit.review.bot 2012-10-31 09:56:42 -0700 Attachment 171676 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'ChangeLog', u'Source/WebCore/ChangeLog', u..." exit_code: 1 Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:65: Use 0 instead of NULL. [readability/null] [5] Total errors found: 1 in 14 files If any of these errors are false positives, please file a bug against check-webkit-style. 755408 13 mrobinson 2012-10-31 10:04:30 -0700 (In reply to comment #10) Thanks for the review! This should be asynchronous in the next patch in the series or, less likely, the one after. > If we are going to keep the sync api for now, it would be better to pass NULL for the error, since we are not using it. I'm a bit nervous about this because it isn't marked allow-none. 755417 14 danw 2012-10-31 10:15:17 -0700 GErrors (and GCancellables) are always allow-none 755593 15 171676 gtk-ews 2012-10-31 13:32:55 -0700 Comment on attachment 171676 Patch Attachment 171676 did not pass gtk-ews (gtk): Output: http://queues.webkit.org/results/14685330 755869 16 171676 dbates 2012-10-31 22:15:26 -0700 Comment on attachment 171676 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=171676&action=review This patch looks sane to me. Feel free to have a GTK expert review this patch if you want a more thorough review. > Source/WebCore/ChangeLog:10 > + CredentialStoreGtk. The name is based on the name of a similar class from the Blackberry port. Nit: Blackberry => BlackBerry > Source/WebCore/ChangeLog:12 > + No new tests. This should not change behavior. Your use of the word "should" gives the impression that you are unsure whether this change may alter existing behavior. It would be beneficial to elaborate on any uncertainties. > Source/WebCore/platform/gtk/GtkAuthenticationDialog.cpp:197 > + // This is just a temporary kludge until GtkAuthenticationDialog works directly with AuthenticationChallenges. You may want to consider filing a bug (if one doesn't already exist (*)) and referencing the bug in this comment for removing this kludge so as to make it actionable. (*) If there is an existing bug for this issue then we should update this comment to reference it. > Source/WebCore/platform/gtk/GtkAuthenticationDialog.cpp:237 > + // This is just a temporary kludge until GtkAuthenticationDialog works directly with AuthenticationChallenges. Ditto. > Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:53 > +CredentialBackingStore::~CredentialBackingStore() > +{ > +} I take it you either plan to have this class to do something non-trivial in the destructor or explicitly don't want the default destructor inlined? If neither then I suggest we remove this implementation and the declaration in CredentialBackingStore.h as the compiler will generate such a destructor. > Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:81 > + 0, // cancellable Nit: cancellable => cancelable > Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:112 > + 0, // cancellable Ditto. > Source/WebCore/platform/network/gtk/CredentialBackingStore.h:35 > +class CredentialBackingStore { Can we make this non-copyable? > Source/WebCore/platform/network/gtk/CredentialBackingStore.h:40 > + Credential getCredentialForChallenge(const AuthenticationChallenge&); We tend to only use the prefix "get" for functions that have out arguments. Maybe credentialForChallenge? 755992 17 171676 cgarcia 2012-11-01 01:57:24 -0700 Comment on attachment 171676 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=171676&action=review Patch looks good to me too, I guess we need to wait until libsecret is installed in EWS bots before landing. And either install libsecret in all the bots too, or add libsecret to our jhbuild moduleset. Thanks! > Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:84 > + if (error || !elements || !elements->data) > + return Credential(); Since we are not interested in the actual error, and elements will always be NULL in case of error, you can simply pass NULL for the error, and simply check elements and elements->data are not NULL. 756143 18 mrobinson 2012-11-01 06:05:31 -0700 (In reply to comment #16) > (From update of attachment 171676 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=171676&action=review Thanks for the review! > > > Source/WebCore/ChangeLog:12 > > + No new tests. This should not change behavior. > > Your use of the word "should" gives the impression that you are unsure whether this change may alter existing behavior. It would be beneficial to elaborate on any uncertainties. I'm just a bit too cautious when I write my ChangeLogs. :) Removed "should" > > > Source/WebCore/platform/gtk/GtkAuthenticationDialog.cpp:197 > > + // This is just a temporary kludge until GtkAuthenticationDialog works directly with AuthenticationChallenges. > > You may want to consider filing a bug (if one doesn't already exist (*)) and referencing the bug in this comment for removing this kludge so as to make it actionable. I linked to the bug. > > > Source/WebCore/platform/gtk/GtkAuthenticationDialog.cpp:237 > > + // This is just a temporary kludge until GtkAuthenticationDialog works directly with AuthenticationChallenges. > > Ditto. > > > Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:53 > > +CredentialBackingStore::~CredentialBackingStore() > > +{ > > +} > > I take it you either plan to have this class to do something non-trivial in the destructor or explicitly don't want the default destructor inlined? If neither then I suggest we remove this implementation and the declaration in CredentialBackingStore.h as the compiler will generate such a destructor. I moved the empty bodies to the header. I'm not sure if there's any benefit of having the compiler generate them other than less typing, but I kind of like being explicit. If this violates the style guide I can remove them. > > Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:81 > > + 0, // cancellable > > Nit: cancellable => cancelable > > > Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:112 > > + 0, // cancellable > > Ditto. The interesting thing is that you can actually spell it both ways. :) I chose cancellable because that's what the documentation uses for the name. http://developer.gnome.org/libsecret/unstable/SecretService.html#secret-service-search-sync > > > Source/WebCore/platform/network/gtk/CredentialBackingStore.h:35 > > +class CredentialBackingStore { > > Can we make this non-copyable? Yes! > > Source/WebCore/platform/network/gtk/CredentialBackingStore.h:40 > > + Credential getCredentialForChallenge(const AuthenticationChallenge&); > > We tend to only use the prefix "get" for functions that have out arguments. Maybe credentialForChallenge? Nice catch. 756146 19 mrobinson 2012-11-01 06:06:15 -0700 (In reply to comment #17) > (From update of attachment 171676 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=171676&action=review > > Patch looks good to me too, I guess we need to wait until libsecret is installed in EWS bots before landing. And either install libsecret in all the bots too, or add libsecret to our jhbuild moduleset. Thanks! > > > Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:84 > > + if (error || !elements || !elements->data) > > + return Credential(); > > Since we are not interested in the actual error, and elements will always be NULL in case of error, you can simply pass NULL for the error, and simply check elements and elements->data are not NULL. Usually I check both for completeness sake, but if you insist... :) 756320 20 171868 mrobinson 2012-11-01 09:10:11 -0700 Created attachment 171868 Patch to commit 756403 21 webkit.review.bot 2012-11-01 10:15:58 -0700 Attachment 171868 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'ChangeLog', u'Source/WebCore/ChangeLog', u..." exit_code: 1 Source/WebCore/platform/network/gtk/CredentialBackingStore.cpp:57: Use 0 instead of NULL. [readability/null] [5] Total errors found: 1 in 14 files If any of these errors are false positives, please file a bug against check-webkit-style. 757324 22 171868 webkit.review.bot 2012-11-02 10:45:14 -0700 Comment on attachment 171868 Patch to commit Rejecting attachment 171868 from commit-queue. Failed to run "['/mnt/git/webkit-commit-queue/Tools/Scripts/webkit-patch', '--status-host=queues.webkit.org', '-..." exit_code: 1 ERROR: /mnt/git/webkit-commit-queue/ChangeLog neither lists a valid reviewer nor contains the string "Unreviewed" or "Rubber stamp" (case insensitive). Full output: http://queues.webkit.org/results/14656964 757352 23 171868 webkit.review.bot 2012-11-02 11:06:05 -0700 Comment on attachment 171868 Patch to commit Clearing flags on attachment: 171868 Committed r133317: <http://trac.webkit.org/changeset/133317> 757353 24 webkit.review.bot 2012-11-02 11:06:12 -0700 All reviewed patches have been landed. Closing bug. 171542 2012-10-30 16:10:51 -0700 2012-10-31 09:51:10 -0700 Patch bug-100775-20121030160915.patch text/plain 24959 mrobinson U3VidmVyc2lvbiBSZXZpc2lvbjogMTMyODQ3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTBmY2JhMTdhMjA3NDY1 N2VhMjg1Y2MxY2E3ZmNjYTU5N2E2YTI5Yi4uM2ExYzVkNTZiYzk2NjRiMjU4NGIyYjg1YjlkNTE1 ZmRlZjQ4OTE2NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2IEBACisyMDEyLTEwLTMwICBNYXJ0 aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBSZW1v dmUgZGVwZW5kZW5jeSBvbiBTb3VwUGFzc3dvcmRNYW5hZ2VyCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDA3NzUKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZW1lbWJlciBwYXNzd29yZHMgdXNpbmcgbGli c2VjcmV0IGluc3RlYWQgb2YgU291cFBhc3N3b3JkTWFuYWdlci4gV2UgYWNjb21wbGlzaCB0aGlz IHVzaW5nCisgICAgICAgIGEgbmV3IGNsYXNzLCBDcmVkZW50aWFsQmFja2luZ1N0b3JlLiBDcmVk ZW50aWFsQmFja2luZ1N0b3JlIHdpbGwgc29vbiBiZSB0aGUgdGhpbmcgdGhhdCBiYWNrcworICAg ICAgICBDcmVkZW50aWFsU3RvcmVHdGsuIFRoZSBuYW1lIGlzIGJhc2VkIG9uIHRoZSBuYW1lIG9m IGEgc2ltaWxhciBjbGFzcyBmcm9tIHRoZSBCbGFja2JlcnJ5IHBvcnQuCisgICAgICAgIGEgZGVw ZW5kZW5jeSBvbiBTb3VwUGFzc3dvcmRNYW5hZ2VyLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cy4g VGhpcyBzaG91bGQgbm90IGNoYW5nZSBiZWhhdmlvci4KKworICAgICAgICAqIEdOVW1ha2VmaWxl LmFtOiBBZGQgbGlic2VjcmV0IGZsYWdzIHRvIHRoZSBidWlsZCBhbmQgdGhlIG5ldyBkaXJlY3Rv cnkgdG8gdGhlIGluY2x1ZGUgbGlzdC4KKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFtOiBB ZGQgbmV3IGZpbGVzIHRvIHRoZSBzb3VyY2UgbGlzdC4KKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsv R1JlZlB0ckd0ay5jcHA6IEFkZCBzdXBwb3J0IGZvciBTZWNyZXRWYWx1ZSB0byBHUmVmUHRyR3Rr LgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9HdGtBdXRoZW50aWNhdGlvbkRpYWxvZy5jcHA6IFJl cGxhY2UgaW50ZXJhY3Rpb24gd2l0aCBTb3VwUGFzc3dvcmRNYW5nZXIgd2l0aAorICAgICAgICBp bnRlcmFjdGlvbiB3aXRoIHRoZSBDcmVkZW50aWFsQmFja2luZ1N0b3JlLiBSZW1vdmUgYWxsIGNv bmRpdGlvbmFsIFNvdXBQYXNzd29yZE1hbmFnZXIgZ3VhcmRzLgorICAgICAgICAqIHBsYXRmb3Jt L2d0ay9HdGtBdXRoZW50aWNhdGlvbkRpYWxvZy5oOiBEaXR0by4KKyAgICAgICAgKiBwbGF0Zm9y bS9uZXR3b3JrL2d0ay9DcmVkZW50aWFsQmFja2luZ1N0b3JlLmNwcDogQWRkZWQuCisgICAgICAg ICogcGxhdGZvcm0vbmV0d29yay9ndGsvQ3JlZGVudGlhbEJhY2tpbmdTdG9yZS5oOiBBZGRlZC4K KwogMjAxMi0xMC0yOSAgUGhpbGlwIFJvZ2VycyAgPHBkckBnb29nbGUuY29tPgogCiAgICAgICAg IExldCBTVkdFbGVtZW50cyBoYXZlIHBlbmRpbmcgcmVzb3VyY2VzLgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9ndGsvQ2hhbmdlTG9nCmlu ZGV4IDkwYWViNGYzM2RkYzc1NGJmNWYzNmZjMjk1MTI5ZjQ5NmJhMzQ5M2EuLjdiZDhlZTY5OTgx YjAzN2U5OTA1ZDM3YzZiOTU2YTc1NWFiNDlkNjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv Z3RrL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwxNSBAQAorMjAxMi0xMC0zMCAgTWFydGluIFJvYmluc29uICA8bXJvYmluc29uQGlnYWxpYS5j b20+CisKKyAgICAgICAgW0dUS10gUmVtb3ZlIGRlcGVuZGVuY3kgb24gU291cFBhc3N3b3JkTWFu YWdlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTAw Nzc1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRk IGEgbGlic2VjcmV0IGRlcGVuZGVuY3kgdG8gdGhlIGJ1aWxkLiBUaGlzIGlzIG5lY2Vzc2FyeSBz byB0aGF0IHdlIGNhbiByZW1vdmUKKyAgICAgICAgYSBkZXBlbmRlbmN5IG9uIFNvdXBQYXNzd29y ZE1hbmFnZXIuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5hbTogVXNlIGxpYnNlY3JldCBsaWJz IGR1cmluZyBXZWJLaXQxIGxpYnJhcnkgY29tcGlsYXRpb24uCisKIDIwMTItMTAtMjQgIEJyYWR5 IEVpZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgogCiAgICAgICAgIEFkZCBhIHN0cmF0ZWd5IGZv ciBsb2FkZXIgY3VzdG9taXphdGlvbi4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5n ZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwppbmRleCA1MjBhMGUyNzMzNDZhYzdhMmZi MjY2MGFlYmZjOTExYThlMjI2Y2I0Li45OGJiMDZkZjA0NmViODg4OTg0OGJmMWRjN2EwZjNkNjc3 OWU5NWEzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNl L1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTItMTAtMzAgIE1hcnRpbiBS b2JpbnNvbiAgPG1yb2JpbnNvbkBpZ2FsaWEuY29tPgorCisgICAgICAgIFtHVEtdIFJlbW92ZSBk ZXBlbmRlbmN5IG9uIFNvdXBQYXNzd29yZE1hbmFnZXIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwMDc3NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBhIGxpYnNlY3JldCBkZXBlbmRlbmN5IHRvIHRo ZSBidWlsZC4gVGhpcyBpcyBuZWNlc3Nhcnkgc28gdGhhdCB3ZSBjYW4gcmVtb3ZlCisgICAgICAg IGEgZGVwZW5kZW5jeSBvbiBTb3VwUGFzc3dvcmRNYW5hZ2VyLgorCisgICAgICAgICogR05VbWFr ZWZpbGUuYW06IEFkZCBsaWJzZWNyZXQgQ0ZMQUdTIHRvIHRoZSBXZWJLaXQyIGJ1aWxkLgorCiAy MDEyLTEwLTI5ICBNaWNoYWVsIFNhYm9mZiAgPG1zYWJvZmZAYXBwbGUuY29tPgogCiAgICAgICAg IGJ1aWxkSFRUUEhlYWRlcnMoKSBzaG91bGQgdXNlIGEgU3RyaW5nQnVpbGRlci5hcHBlbmRMaXRl cmFsKCkgZm9yIHNlcGFyYXRvcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZp bGUuYW0gYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCAzNjE2YTM4MGE2Y2Jk Mjk4ODQzMjI2MzAyOTNmMTJmZWU3Y2YwZTE4Li5lNjZiZjA1NDdjYjgwODg1ZWI3NDYyMDFiMGNl ZDlmYjQ3MzdhZTExIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQor KysgYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQpAQCAtNzMsNiArNzMsNyBAQCB3ZWJj b3JlX2NwcGZsYWdzICs9IFwKIAktSSQoc3JjZGlyKS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9t ZWRpYXN0cmVhbS9nc3RyZWFtZXIgXAogCS1JJChzcmNkaXIpL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL21vY2sgXAogCS1JJChzcmNkaXIpL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsg XAorCS1JJChzcmNkaXIpL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvZ3RrIFwKIAkt SSQoc3JjZGlyKS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9zcWwgXAogCS1JJChzcmNkaXIpL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQgXAogCS1JJChzcmNkaXIpL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL3RleHQvdHJhbnNjb2RlciBcCkBAIC02NDEsNiArNjQyLDcgQEAgbGliV2ViQ29y ZV9sYV9DUFBGTEFHUyA9IFwKIAkkKEdFT0NMVUVfQ0ZMQUdTKSBcCiAJJChHTElCX0NGTEFHUykg XAogCSQoR1NUUkVBTUVSX0NGTEFHUykgXAorCSQoTElCU0VDUkVUX0NGTEFHUykgXAogCSQoTElC U09VUF9DRkxBR1MpIFwKIAkkKExJQlhNTF9DRkxBR1MpIFwKIAkkKExJQlhTTFRfQ0ZMQUdTKSBc CkBAIC03MDQsNiArNzA2LDcgQEAgbGliV2ViQ29yZUd0a19sYV9DUFBGTEFHUyA9IFwKIAkkKEdT VFJFQU1FUl9DRkxBR1MpIFwKIAkkKEdUS19DRkxBR1MpIFwKIAkkKEhJTERPTl9DRkxBR1MpIFwK KwkkKExJQlNFQ1JFVF9DRkxBR1MpIFwKIAkkKExJQlNPVVBfQ0ZMQUdTKSBcCiAJJChMSUJYTUxf Q0ZMQUdTKSBcCiAJJChMSUJYU0xUX0NGTEFHUykgXApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvR05VbWFrZWZpbGUubGlzdC5hbSBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3Qu YW0KaW5kZXggYjBiZGQyZWJhYjczYmE5ZmIyNjEyOTM1MTkyY2IzZjU0OTIzNzAzYi4uNDAzYzcz NGE4ZWQxYWFlNmNjMDY1Y2QxNTQ2NTY1Y2E1ZDM1MGYxOCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmls ZS5saXN0LmFtCkBAIC00NzM2LDYgKzQ3MzYsOCBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVNv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvU29ja2V0U3RyZWFtSGFuZGxlQmFzZS5jcHAg XAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvU29ja2V0U3RyZWFtSGFuZGxlQmFz ZS5oIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1NvY2tldFN0cmVhbUhhbmRs ZUNsaWVudC5oIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2d0ay9DcmVkZW50 aWFsQmFja2luZ1N0b3JlLmNwcCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9n dGsvQ3JlZGVudGlhbEJhY2tpbmdTdG9yZS5oIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL3NvdXAvQXV0aGVudGljYXRpb25DaGFsbGVuZ2UuaCBcCiAJU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9zb3VwL0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlU291cC5jcHAgXAog CVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNwcCBc CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvR1JlZlB0ckd0ay5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvR1JlZlB0ckd0ay5jcHAKaW5kZXggOWE5ZDY3 OTVmODNhYWE1OWZmNTJjOTVmNDg5YmRkMmY1MmNlYzJhNC4uZmE1MDZkZjkwMDdkMjRjYzA3Njc3 NjhkZWZkMTA1NjYyZmMzOWIzZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3RrL0dSZWZQdHJHdGsuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9HUmVm UHRyR3RrLmNwcApAQCAtMjAsOCArMjAsMTIgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNs dWRlICJHUmVmUHRyR3RrLmgiCiAKKyNkZWZpbmUgU0VDUkVUX1dJVEhfVU5TVEFCTEUgMQorI2Rl ZmluZSBTRUNSRVRfQVBJX1NVQkpFQ1RfVE9fQ0hBTkdFIDEKKwogI2luY2x1ZGUgPGdsaWIuaD4K ICNpbmNsdWRlIDxndGsvZ3RrLmg+CisjaW5jbHVkZSA8bGlic2VjcmV0L3NlY3JldC5oPgogCiBu YW1lc3BhY2UgV1RGIHsKIApAQCAtMzgsNiArNDIsMTkgQEAgdGVtcGxhdGUgPD4gdm9pZCBkZXJl ZkdQdHIoR3RrVGFyZ2V0TGlzdCogcHRyKQogICAgICAgICBndGtfdGFyZ2V0X2xpc3RfdW5yZWYo cHRyKTsKIH0KIAordGVtcGxhdGUgPD4gU2VjcmV0VmFsdWUqIHJlZkdQdHIoU2VjcmV0VmFsdWUq IHB0cikKK3sKKyAgICBpZiAocHRyKQorICAgICAgICBzZWNyZXRfdmFsdWVfcmVmKHB0cik7Cisg ICAgcmV0dXJuIHB0cjsKK30KKwordGVtcGxhdGUgPD4gdm9pZCBkZXJlZkdQdHIoU2VjcmV0VmFs dWUqIHB0cikKK3sKKyAgICBpZiAocHRyKQorICAgICAgICBzZWNyZXRfdmFsdWVfdW5yZWYocHRy KTsKK30KKwogI2lmZGVmIEdUS19BUElfVkVSU0lPTl8yCiB0ZW1wbGF0ZSA8PiBHZGtDdXJzb3Iq IHJlZkdQdHIoR2RrQ3Vyc29yKiBwdHIpCiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ndGsvR1JlZlB0ckd0ay5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0dS ZWZQdHJHdGsuaAppbmRleCBhOWY0OTFmMTQ3MGU0MjE4OTEyN2ZmNGY4NjVhMzMxNjRhMTdhN2Y2 Li45MTkyODY0YTkyMjlkYWI4ODNiZWZhNTYyYjIzNWFkOGFjMzk2ZGM5IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvR1JlZlB0ckd0ay5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2d0ay9HUmVmUHRyR3RrLmgKQEAgLTIzLDExICsyMywxNiBAQAogCiAjaW5j bHVkZSA8d3RmL2dvYmplY3QvR1JlZlB0ci5oPgogCit0eXBlZGVmIHN0cnVjdCBfU2VjcmV0VmFs dWUgU2VjcmV0VmFsdWU7CisKIG5hbWVzcGFjZSBXVEYgewogCiB0ZW1wbGF0ZSA8PiBHdGtUYXJn ZXRMaXN0KiByZWZHUHRyKEd0a1RhcmdldExpc3QqIHB0cik7CiB0ZW1wbGF0ZSA8PiB2b2lkIGRl cmVmR1B0cihHdGtUYXJnZXRMaXN0KiBwdHIpOwogCit0ZW1wbGF0ZSA8PiBTZWNyZXRWYWx1ZSog cmVmR1B0cihTZWNyZXRWYWx1ZSogcHRyKTsKK3RlbXBsYXRlIDw+IHZvaWQgZGVyZWZHUHRyKFNl Y3JldFZhbHVlKiBwdHIpOworCiAjaWZkZWYgR1RLX0FQSV9WRVJTSU9OXzIKIHRlbXBsYXRlIDw+ IEdka0N1cnNvciogcmVmR1B0cihHZGtDdXJzb3IqIHB0cik7CiB0ZW1wbGF0ZSA8PiB2b2lkIGRl cmVmR1B0cihHZGtDdXJzb3IqIHB0cik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvR3RrQXV0aGVudGljYXRpb25EaWFsb2cuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3RrL0d0a0F1dGhlbnRpY2F0aW9uRGlhbG9nLmNwcAppbmRleCAzNmJkMzFiMWVhNTEz ZjUyNTYyOWQ4ZDkwMmJjZGMwZTU5YWZhODVmLi5jYzU2MTEzMmRkMjczZjNjZWRiNTE0YzVjZTBh ZWViMzEyZDE4MTE5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvR3Rr QXV0aGVudGljYXRpb25EaWFsb2cuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0 ay9HdGtBdXRoZW50aWNhdGlvbkRpYWxvZy5jcHAKQEAgLTIwLDYgKzIwLDggQEAKICNpbmNsdWRl ICJjb25maWcuaCIKICNpbmNsdWRlICJHdGtBdXRoZW50aWNhdGlvbkRpYWxvZy5oIgogCisjaW5j bHVkZSAiQXV0aGVudGljYXRpb25DaGFsbGVuZ2UuaCIKKyNpbmNsdWRlICJDcmVkZW50aWFsQmFj a2luZ1N0b3JlLmgiCiAjaW5jbHVkZSAiR3RrVmVyc2lvbmluZy5oIgogI2luY2x1ZGUgPGdsaWIv Z2kxOG4tbGliLmg+CiAjaW5jbHVkZSA8Z3RrL2d0ay5oPgpAQCAtNTQsMTUgKzU2LDYgQEAgc3Rh dGljIEd0a1dpZGdldCogYWRkRW50cnlUb0dyaWQoR3RrR3JpZCogZ3JpZCwgaW50IHJvdywgY29u c3QgY2hhciogbGFiZWxUZXh0KQogICAgIHJldHVybiBlbnRyeTsKIH0KIAotc3RhdGljIGJvb2wg c2Vzc2lvbkNhblNhdmVQYXNzd29yZHMoU291cFNlc3Npb24qIHNlc3Npb24pCi17Ci0jaWZkZWYg U09VUF9UWVBFX1BBU1NXT1JEX01BTkFHRVIKLSAgICByZXR1cm4gc291cF9zZXNzaW9uX2dldF9m ZWF0dXJlKHNlc3Npb24sIFNPVVBfVFlQRV9QQVNTV09SRF9NQU5BR0VSKTsKLSNlbHNlCi0gICAg cmV0dXJuIGZhbHNlOwotI2VuZGlmCi19Ci0KIEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9nOjp+R3Rr QXV0aGVudGljYXRpb25EaWFsb2coKQogewogfQpAQCAtNzUsMTAgKzY4LDggQEAgR3RrQXV0aGVu dGljYXRpb25EaWFsb2c6Okd0a0F1dGhlbnRpY2F0aW9uRGlhbG9nKEd0a1dpbmRvdyogcGFyZW50 V2luZG93LCBTb3VwU2UKICAgICAsIG1fbG9naW5FbnRyeSgwKQogICAgICwgbV9wYXNzd29yZEVu dHJ5KDApCiAgICAgLCBtX3JlbWVtYmVyQ2hlY2tCdXR0b24oMCkKLSNpZmRlZiBTT1VQX1RZUEVf UEFTU1dPUkRfTUFOQUdFUgogICAgICwgbV9pc1NhdmluZ1Bhc3N3b3JkKGZhbHNlKQogICAgICwg bV9zYXZlUGFzc3dvcmRIYW5kbGVyKDApCi0jZW5kaWYKIHsKICAgICBHdGtEaWFsb2cqIGRpYWxv ZyA9IEdUS19ESUFMT0cobV9kaWFsb2cpOwogICAgIGd0a19kaWFsb2dfYWRkX2J1dHRvbnMoZGlh bG9nLCBHVEtfU1RPQ0tfQ0FOQ0VMLCBHVEtfUkVTUE9OU0VfQ0FOQ0VMLCBHVEtfU1RPQ0tfT0ss IEdUS19SRVNQT05TRV9PSywgTlVMTCk7CkBAIC0xODcsNDcgKzE3OCwzMSBAQCBHdGtBdXRoZW50 aWNhdGlvbkRpYWxvZzo6R3RrQXV0aGVudGljYXRpb25EaWFsb2coR3RrV2luZG93KiBwYXJlbnRX aW5kb3csIFNvdXBTZQogCiAgICAgZ3RrX2VudHJ5X3NldF92aXNpYmlsaXR5KEdUS19FTlRSWSht X3Bhc3N3b3JkRW50cnkpLCBGQUxTRSk7CiAKLSAgICBpZiAoc2Vzc2lvbkNhblNhdmVQYXNzd29y ZHMobV9zZXNzaW9uKSkgewogI2lmZGVmIEdUS19BUElfVkVSU0lPTl8yCi0gICAgICAgIEd0a1dp ZGdldCogcmVtZW1iZXJCb3ggPSBndGtfdmJveF9uZXcoRkFMU0UsIDYpOworICAgIEd0a1dpZGdl dCogcmVtZW1iZXJCb3ggPSBndGtfdmJveF9uZXcoRkFMU0UsIDYpOwogI2Vsc2UKLSAgICAgICAg R3RrV2lkZ2V0KiByZW1lbWJlckJveCA9IGd0a19ib3hfbmV3KEdUS19PUklFTlRBVElPTl9WRVJU SUNBTCwgNik7CisgICAgR3RrV2lkZ2V0KiByZW1lbWJlckJveCA9IGd0a19ib3hfbmV3KEdUS19P UklFTlRBVElPTl9WRVJUSUNBTCwgNik7CiAjZW5kaWYKLSAgICAgICAgZ3RrX2JveF9wYWNrX3N0 YXJ0KEdUS19CT1godkJveCksIHJlbWVtYmVyQm94LCBGQUxTRSwgRkFMU0UsIDApOworICAgIGd0 a19ib3hfcGFja19zdGFydChHVEtfQk9YKHZCb3gpLCByZW1lbWJlckJveCwgRkFMU0UsIEZBTFNF LCAwKTsKIAotICAgICAgICBtX3JlbWVtYmVyQ2hlY2tCdXR0b24gPSBndGtfY2hlY2tfYnV0dG9u X25ld193aXRoX21uZW1vbmljKF8oIl9SZW1lbWJlciBwYXNzd29yZCIpKTsKLSAgICAgICAgZ3Rr X2xhYmVsX3NldF9saW5lX3dyYXAoR1RLX0xBQkVMKGd0a19iaW5fZ2V0X2NoaWxkKEdUS19CSU4o bV9yZW1lbWJlckNoZWNrQnV0dG9uKSkpLCBUUlVFKTsKLSAgICAgICAgZ3RrX2JveF9wYWNrX3N0 YXJ0KEdUS19CT1gocmVtZW1iZXJCb3gpLCBtX3JlbWVtYmVyQ2hlY2tCdXR0b24sIEZBTFNFLCBG QUxTRSwgMCk7Ci0gICAgfQotfQotCi1zdGF0aWMgYm9vbCBnZXRTYXZlZExvZ2luKFNvdXBBdXRo KiBhdXRoLCBjb25zdCBjaGFyKiogdXNlcm5hbWUsIGNvbnN0IGNoYXIqKiBwYXNzd29yZCkKLXsK LSNpZmRlZiBTT1VQX1RZUEVfUEFTU1dPUkRfTUFOQUdFUgotICAgIEdTTGlzdCogdXNlcnMgPSBz b3VwX2F1dGhfZ2V0X3NhdmVkX3VzZXJzKGF1dGgpOwotICAgIGlmICghdXNlcnMpCi0gICAgICAg IHJldHVybiBmYWxzZTsKLQotICAgICp1c2VybmFtZSA9IHN0YXRpY19jYXN0PGNoYXIqPih1c2Vy cy0+ZGF0YSk7Ci0gICAgKnBhc3N3b3JkID0gc291cF9hdXRoX2dldF9zYXZlZF9wYXNzd29yZChh dXRoLCAqdXNlcm5hbWUpOwotICAgIGdfc2xpc3RfZnJlZSh1c2Vycyk7Ci0KLSAgICByZXR1cm4g KnVzZXJuYW1lICYmICpwYXNzd29yZDsKLSNlbHNlCi0gICAgcmV0dXJuIGZhbHNlOwotI2VuZGlm CisgICAgbV9yZW1lbWJlckNoZWNrQnV0dG9uID0gZ3RrX2NoZWNrX2J1dHRvbl9uZXdfd2l0aF9t bmVtb25pYyhfKCJfUmVtZW1iZXIgcGFzc3dvcmQiKSk7CisgICAgZ3RrX2xhYmVsX3NldF9saW5l X3dyYXAoR1RLX0xBQkVMKGd0a19iaW5fZ2V0X2NoaWxkKEdUS19CSU4obV9yZW1lbWJlckNoZWNr QnV0dG9uKSkpLCBUUlVFKTsKKyAgICBndGtfYm94X3BhY2tfc3RhcnQoR1RLX0JPWChyZW1lbWJl ckJveCksIG1fcmVtZW1iZXJDaGVja0J1dHRvbiwgRkFMU0UsIEZBTFNFLCAwKTsKIH0KIAogdm9p ZCBHdGtBdXRoZW50aWNhdGlvbkRpYWxvZzo6c2hvdygpCiB7Ci0gICAgY29uc3QgY2hhciogdXNl cm5hbWUgPSAwOwotICAgIGNvbnN0IGNoYXIqIHBhc3N3b3JkID0gMDsKLSAgICBib29sIGhhdmVT YXZlZExvZ2luID0gZ2V0U2F2ZWRMb2dpbihtX2F1dGguZ2V0KCksICZ1c2VybmFtZSwgJnBhc3N3 b3JkKTsKICAgICBzb3VwX3Nlc3Npb25fcGF1c2VfbWVzc2FnZShtX3Nlc3Npb24sIG1fbWVzc2Fn ZS5nZXQoKSk7Ci0gICAgZ3RrX2VudHJ5X3NldF90ZXh0KEdUS19FTlRSWShtX2xvZ2luRW50cnkp LCB1c2VybmFtZSA/IHVzZXJuYW1lIDogIiIpOwotICAgIGd0a19lbnRyeV9zZXRfdGV4dChHVEtf RU5UUlkobV9wYXNzd29yZEVudHJ5KSwgcGFzc3dvcmQgPyBwYXNzd29yZCA6ICIiKTsKLSAgICBp ZiAobV9yZW1lbWJlckNoZWNrQnV0dG9uICYmIGhhdmVTYXZlZExvZ2luKQorCisgICAgLy8gVGhp cyBpcyBqdXN0IGEgdGVtcG9yYXJ5IGtsdWRnZSB1bnRpbCBHdGtBdXRoZW50aWNhdGlvbkRpYWxv ZyB3b3JrcyBkaXJlY3RseSB3aXRoIEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlcy4KKyAgICBBdXRo ZW50aWNhdGlvbkNoYWxsZW5nZSBjaGFsbGVuZ2UoMCAvKiBzZXNzaW9uICovLCBtX21lc3NhZ2Uu Z2V0KCksIG1fYXV0aC5nZXQoKSwgZmFsc2UsIDApOworICAgIENyZWRlbnRpYWwgc2F2ZWRDcmVk ZW50aWFsID0gY3JlZGVudGlhbEJhY2tpbmdTdG9yZSgpLmdldENyZWRlbnRpYWxGb3JDaGFsbGVu Z2UoY2hhbGxlbmdlKTsKKyAgICBpZiAoIXNhdmVkQ3JlZGVudGlhbC5pc0VtcHR5KCkpIHsKKyAg ICAgICAgZ3RrX2VudHJ5X3NldF90ZXh0KEdUS19FTlRSWShtX2xvZ2luRW50cnkpLCBzYXZlZENy ZWRlbnRpYWwudXNlcigpLnV0ZjgoKS5kYXRhKCkpOworICAgICAgICBndGtfZW50cnlfc2V0X3Rl eHQoR1RLX0VOVFJZKG1fcGFzc3dvcmRFbnRyeSksIHNhdmVkQ3JlZGVudGlhbC5wYXNzd29yZCgp LnV0ZjgoKS5kYXRhKCkpOwogICAgICAgICBndGtfdG9nZ2xlX2J1dHRvbl9zZXRfYWN0aXZlKEdU S19UT0dHTEVfQlVUVE9OKG1fcmVtZW1iZXJDaGVja0J1dHRvbiksIFRSVUUpOworICAgIH0KKwog ICAgIGdfc2lnbmFsX2Nvbm5lY3QobV9kaWFsb2csICJyZXNwb25zZSIsIEdfQ0FMTEJBQ0soYXV0 aGVudGljYXRpb25EaWFsb2dSZXNwb25zZUNhbGxiYWNrKSwgdGhpcyk7CiAgICAgZ3RrX3dpZGdl dF9zaG93X2FsbChtX2RpYWxvZyk7CiB9CkBAIC0yMzksOSArMjE0LDcgQEAgdm9pZCBHdGtBdXRo ZW50aWNhdGlvbkRpYWxvZzo6ZGVzdHJveSgpCiAgICAgc291cF9zZXNzaW9uX3VucGF1c2VfbWVz c2FnZShtX3Nlc3Npb24sIG1fbWVzc2FnZS5nZXQoKSk7CiAgICAgZ3RrX3dpZGdldF9kZXN0cm95 KG1fZGlhbG9nKTsKIAotI2lmZGVmIFNPVVBfVFlQRV9QQVNTV09SRF9NQU5BR0VSCiAgICAgc2hv dWxkRGVsZXRlID0gIW1faXNTYXZpbmdQYXNzd29yZDsKLSNlbmRpZgogCiAgICAgLy8gRG8gbm90 IGRlbGV0ZSB0aGUgb2JqZWN0IGlmIGl0J3Mgc3RpbGwgc2F2aW5nIHRoZSBwYXNzd29yZCwKICAg ICAvLyB0aGUgc2F2ZSBwYXNzd29yZCBjYWxsYmFjayB3aWxsIGRlbGV0ZSBpdC4KQEAgLTI0OSw3 ICsyMjIsNiBAQCB2b2lkIEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9nOjpkZXN0cm95KCkKICAgICAg ICAgZGVsZXRlIHRoaXM7CiB9CiAKLSNpZmRlZiBTT1VQX1RZUEVfUEFTU1dPUkRfTUFOQUdFUgog dm9pZCBHdGtBdXRoZW50aWNhdGlvbkRpYWxvZzo6c2F2ZVBhc3N3b3JkQ2FsbGJhY2soU291cE1l c3NhZ2UqIG1lc3NhZ2UsIEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9nKiBkaWFsb2cpCiB7CiAgICAg ZGlhbG9nLT5zYXZlUGFzc3dvcmQoKTsKQEAgLTI2MSw4ICsyMzMsMTUgQEAgdm9pZCBHdGtBdXRo ZW50aWNhdGlvbkRpYWxvZzo6c2F2ZVBhc3N3b3JkKCkKICAgICBBU1NFUlQoIW1fcGFzc3dvcmQu aXNOdWxsKCkpOwogCiAgICAgLy8gQW55dGhpbmcgYnV0IDQwMSBhbmQgNXh4IG1lYW5zIHRoZSBw YXNzd29yZCB3YXMgYWNjZXB0ZWQuCi0gICAgaWYgKG1fbWVzc2FnZS5nZXQoKS0+c3RhdHVzX2Nv ZGUgIT0gNDAxICYmIG1fbWVzc2FnZS5nZXQoKS0+c3RhdHVzX2NvZGUgPCA1MDApCi0gICAgICAg IHNvdXBfYXV0aF9zYXZlX3Bhc3N3b3JkKG1fYXV0aC5nZXQoKSwgbV91c2VybmFtZS5kYXRhKCks IG1fcGFzc3dvcmQuZGF0YSgpKTsKKyAgICBpZiAobV9tZXNzYWdlLmdldCgpLT5zdGF0dXNfY29k ZSAhPSA0MDEgJiYgbV9tZXNzYWdlLmdldCgpLT5zdGF0dXNfY29kZSA8IDUwMCkgeworICAgICAg ICAvLyBUaGlzIGlzIGp1c3QgYSB0ZW1wb3Jhcnkga2x1ZGdlIHVudGlsIEd0a0F1dGhlbnRpY2F0 aW9uRGlhbG9nIHdvcmtzIGRpcmVjdGx5IHdpdGggQXV0aGVudGljYXRpb25DaGFsbGVuZ2VzLgor ICAgICAgICBBdXRoZW50aWNhdGlvbkNoYWxsZW5nZSBjaGFsbGVuZ2UoMCAvKiBzZXNzaW9uICov LCBtX21lc3NhZ2UuZ2V0KCksIG1fYXV0aC5nZXQoKSwgZmFsc2UsIDApOworICAgICAgICBDcmVk ZW50aWFsIGNyZWRlbnRpYWxUb1NhdmUgPSBDcmVkZW50aWFsKAorICAgICAgICAgICAgU3RyaW5n Ojpmcm9tVVRGOChtX3VzZXJuYW1lLmRhdGEoKSksCisgICAgICAgICAgICBTdHJpbmc6OmZyb21V VEY4KG1fcGFzc3dvcmQuZGF0YSgpKSwKKyAgICAgICAgICAgIENyZWRlbnRpYWxQZXJzaXN0ZW5j ZVBlcm1hbmVudCk7CisgICAgICAgIGNyZWRlbnRpYWxCYWNraW5nU3RvcmUoKS5zdG9yZUNyZWRl bnRpYWxzRm9yQ2hhbGxlbmdlKGNoYWxsZW5nZSwgY3JlZGVudGlhbFRvU2F2ZSk7CisgICAgfQog CiAgICAgLy8gRGlzY29ubmVjdCB0aGUgY2FsbGJhY2suIElmIHRoZSBhdXRoZW50aWNhdGlvbiBz dWNjZWVkZWQgd2UgYXJlIGRvbmUsCiAgICAgLy8gYW5kIGlmIGl0IGZhaWxlZCB3ZSdsbCBjcmVh dGUgYSBuZXcgR3RrQXV0aGVudGljYXRpb25EaWFsb2cgYW5kIHdlJ2xsCkBAIC0yNzIsNyArMjUx LDYgQEAgdm9pZCBHdGtBdXRoZW50aWNhdGlvbkRpYWxvZzo6c2F2ZVBhc3N3b3JkKCkKICAgICAv LyBEaWFsb2cgaGFzIGJlZW4gYWxyZWFkeSBkZXN0cm95ZWQsIGFmdGVyIHNhdmluZyB0aGUgcGFz c3dvcmQgaXQgc2hvdWxkIGJlIGRlbGV0ZWQuCiAgICAgZGVsZXRlIHRoaXM7CiB9Ci0jZW5kaWYK IAogdm9pZCBHdGtBdXRoZW50aWNhdGlvbkRpYWxvZzo6YXV0aGVudGljYXRlKCkKIHsKQEAgLTI4 MCwxNCArMjU4LDEyIEBAIHZvaWQgR3RrQXV0aGVudGljYXRpb25EaWFsb2c6OmF1dGhlbnRpY2F0 ZSgpCiAgICAgY29uc3QgY2hhciAqcGFzc3dvcmQgPSBndGtfZW50cnlfZ2V0X3RleHQoR1RLX0VO VFJZKG1fcGFzc3dvcmRFbnRyeSkpOwogICAgIHNvdXBfYXV0aF9hdXRoZW50aWNhdGUobV9hdXRo LmdldCgpLCB1c2VybmFtZSwgcGFzc3dvcmQpOwogCi0jaWZkZWYgU09VUF9UWVBFX1BBU1NXT1JE X01BTkFHRVIKICAgICBpZiAobV9yZW1lbWJlckNoZWNrQnV0dG9uICYmIGd0a190b2dnbGVfYnV0 dG9uX2dldF9hY3RpdmUoR1RLX1RPR0dMRV9CVVRUT04obV9yZW1lbWJlckNoZWNrQnV0dG9uKSkp IHsKICAgICAgICAgbV91c2VybmFtZSA9IHVzZXJuYW1lOwogICAgICAgICBtX3Bhc3N3b3JkID0g cGFzc3dvcmQ7CiAgICAgICAgIG1faXNTYXZpbmdQYXNzd29yZCA9IHRydWU7CiAgICAgICAgIG1f c2F2ZVBhc3N3b3JkSGFuZGxlciA9IGdfc2lnbmFsX2Nvbm5lY3QobV9tZXNzYWdlLmdldCgpLCAi Z290LWhlYWRlcnMiLCBHX0NBTExCQUNLKHNhdmVQYXNzd29yZENhbGxiYWNrKSwgdGhpcyk7CiAg ICAgfQotI2VuZGlmCiB9CiAKIHZvaWQgR3RrQXV0aGVudGljYXRpb25EaWFsb2c6OmF1dGhlbnRp Y2F0aW9uRGlhbG9nUmVzcG9uc2VDYWxsYmFjayhHdGtXaWRnZXQqLCBnaW50IHJlc3BvbnNlSUQs IEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9nKiBkaWFsb2cpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvR3RrQXV0aGVudGljYXRpb25EaWFsb2cuaCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2d0ay9HdGtBdXRoZW50aWNhdGlvbkRpYWxvZy5oCmluZGV4IDc1ODI0MWNk MzM2ZDgzMzY1NDU5NTUwYTM4ZjBlMTZkNDk2OGI0MjUuLjkxMmY3NWQ3NjkxNjg3NWViZWU1OTQ5 YzdkMThlZGM4ZDBlOTdkNTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0 ay9HdGtBdXRoZW50aWNhdGlvbkRpYWxvZy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9HdGtBdXRoZW50aWNhdGlvbkRpYWxvZy5oCkBAIC0yMCw4ICsyMCw2IEBACiAjaWZuZGVm IEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9nX2gKICNkZWZpbmUgR3RrQXV0aGVudGljYXRpb25EaWFs b2dfaAogCi0jZGVmaW5lIExJQlNPVVBfSV9IQVZFX1JFQURfQlVHXzU5NDM3N19BTkRfS05PV19T T1VQX1BBU1NXT1JEX01BTkFHRVJfTUlHSFRfR09fQVdBWQotCiAjaW5jbHVkZSA8d3RmL2dvYmpl Y3QvR093blB0ci5oPgogI2luY2x1ZGUgIkdSZWZQdHJHdGsuaCIKICNpbmNsdWRlIDxsaWJzb3Vw L3NvdXAuaD4KQEAgLTQ0LDEyICs0Miw4IEBAIHB1YmxpYzoKIHByaXZhdGU6CiAgICAgdm9pZCBk ZXN0cm95KCk7CiAgICAgdm9pZCBhdXRoZW50aWNhdGUoKTsKLQotI2lmZGVmIFNPVVBfVFlQRV9Q QVNTV09SRF9NQU5BR0VSCiAgICAgdm9pZCBzYXZlUGFzc3dvcmQoKTsKICAgICBzdGF0aWMgdm9p ZCBzYXZlUGFzc3dvcmRDYWxsYmFjayhTb3VwTWVzc2FnZSosIEd0a0F1dGhlbnRpY2F0aW9uRGlh bG9nKik7Ci0jZW5kaWYKLQogICAgIHN0YXRpYyB2b2lkIGF1dGhlbnRpY2F0aW9uRGlhbG9nUmVz cG9uc2VDYWxsYmFjayhHdGtXaWRnZXQqLCBnaW50IHJlc3BvbnNlSUQsIEd0a0F1dGhlbnRpY2F0 aW9uRGlhbG9nKik7CiAKICAgICBHdGtXaWRnZXQqIG1fZGlhbG9nOwpAQCAtNjEsMTIgKzU1LDEw IEBAIHByaXZhdGU6CiAgICAgR3RrV2lkZ2V0KiBtX3Bhc3N3b3JkRW50cnk7CiAgICAgR3RrV2lk Z2V0KiBtX3JlbWVtYmVyQ2hlY2tCdXR0b247CiAKLSNpZmRlZiBTT1VQX1RZUEVfUEFTU1dPUkRf TUFOQUdFUgogICAgIGJvb2wgbV9pc1NhdmluZ1Bhc3N3b3JkOwogICAgIHVuc2lnbmVkIGxvbmcg bV9zYXZlUGFzc3dvcmRIYW5kbGVyOwogICAgIENTdHJpbmcgbV91c2VybmFtZTsKICAgICBDU3Ry aW5nIG1fcGFzc3dvcmQ7Ci0jZW5kaWYKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvZ3RrL0NyZWRlbnRpYWxC YWNraW5nU3RvcmUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9ndGsvQ3Jl ZGVudGlhbEJhY2tpbmdTdG9yZS5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uY2NmZTJiMWI3NjdlY2NhODJmYWMz NDZiODYzMDI4ODU1MTNkNTAyNAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvZ3RrL0NyZWRlbnRpYWxCYWNraW5nU3RvcmUuY3BwCkBAIC0wLDAgKzEs MTE2IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyIElnYWxpYSBTLkwuCisgKgorICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMg b2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisg KgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBJR0FMSUEgUy5MLiBgYEFTIElTJycg QU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFC SUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xB SU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwg U1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICog T0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNv bmZpZy5oIgorI2luY2x1ZGUgIkNyZWRlbnRpYWxCYWNraW5nU3RvcmUuaCIKKworI2RlZmluZSBT RUNSRVRfV0lUSF9VTlNUQUJMRSAxCisjZGVmaW5lIFNFQ1JFVF9BUElfU1VCSkVDVF9UT19DSEFO R0UgMQorI2luY2x1ZGUgIkdSZWZQdHJHdGsuaCIKKyNpbmNsdWRlIDxnbGliL2dpMThuLWxpYi5o PgorI2luY2x1ZGUgPGxpYnNlY3JldC9zZWNyZXQuaD4KKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAu aD4KKyNpbmNsdWRlIDx3dGYvZ29iamVjdC9HT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL3RleHQv Q1N0cmluZy5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0NyZWRlbnRpYWxCYWNraW5nU3Rv cmUmIGNyZWRlbnRpYWxCYWNraW5nU3RvcmUoKQoreworICAgIERFRklORV9TVEFUSUNfTE9DQUwo Q3JlZGVudGlhbEJhY2tpbmdTdG9yZSwgYmFja2luZ1N0b3JlLCAoKSk7CisgICAgcmV0dXJuIGJh Y2tpbmdTdG9yZTsKK30KKworQ3JlZGVudGlhbEJhY2tpbmdTdG9yZTo6Q3JlZGVudGlhbEJhY2tp bmdTdG9yZSgpCit7Cit9CisKK0NyZWRlbnRpYWxCYWNraW5nU3RvcmU6On5DcmVkZW50aWFsQmFj a2luZ1N0b3JlKCkKK3sKK30KKworc3RhdGljIEdSZWZQdHI8R0hhc2hUYWJsZT4gY3JlYXRlQXR0 cmlidXRlSGFzaFRhYmxlRnJvbUNoYWxsZW5nZShjb25zdCBBdXRoZW50aWNhdGlvbkNoYWxsZW5n ZSYgY2hhbGxlbmdlLCBjb25zdCBDcmVkZW50aWFsJiBjcmVkZW50aWFsID0gQ3JlZGVudGlhbCgp KQoreworICAgIFNvdXBVUkkqIHVyaSA9IHNvdXBfbWVzc2FnZV9nZXRfdXJpKGNoYWxsZW5nZS5z b3VwTWVzc2FnZSgpKTsKKyAgICBHUmVmUHRyPEdIYXNoVGFibGU+IGF0dHJpYnV0ZXMgPSBhZG9w dEdSZWYoc2VjcmV0X2F0dHJpYnV0ZXNfYnVpbGQoCisgICAgICAgIFNFQ1JFVF9TQ0hFTUFfQ09N UEFUX05FVFdPUkssCisgICAgICAgICJkb21haW4iLCBzb3VwX2F1dGhfZ2V0X3JlYWxtKGNoYWxs ZW5nZS5zb3VwQXV0aCgpKSwKKyAgICAgICAgInNlcnZlciIsIHVyaS0+aG9zdCwKKyAgICAgICAg InByb3RvY29sIiwgdXJpLT5zY2hlbWUsCisgICAgICAgICJhdXRodHlwZSIsIHNvdXBfYXV0aF9n ZXRfc2NoZW1lX25hbWUoY2hhbGxlbmdlLnNvdXBBdXRoKCkpLAorICAgICAgICAicG9ydCIsIHVy aS0+cG9ydCwKKyAgICAgICAgTlVMTCkpOworICAgIGlmIChjcmVkZW50aWFsLmlzRW1wdHkoKSkK KyAgICAgICAgcmV0dXJuIGF0dHJpYnV0ZXM7CisKKyAgICBnX2hhc2hfdGFibGVfaW5zZXJ0KGF0 dHJpYnV0ZXMuZ2V0KCksIGdfc3RyZHVwKCJ1c2VyIiksIGdfc3RyZHVwKGNyZWRlbnRpYWwudXNl cigpLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICByZXR1cm4gYXR0cmlidXRlczsKK30KKworQ3JlZGVu dGlhbCBDcmVkZW50aWFsQmFja2luZ1N0b3JlOjpnZXRDcmVkZW50aWFsRm9yQ2hhbGxlbmdlKGNv bnN0IEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlJiBjaGFsbGVuZ2UpCit7CisgICAgR093blB0cjxH RXJyb3I+IGVycm9yOworICAgIEdPd25QdHI8R0xpc3Q+IGVsZW1lbnRzKHNlY3JldF9zZXJ2aWNl X3NlYXJjaF9zeW5jKAorICAgICAgICAwLCAvLyBUaGUgZGVmYXVsdCBTZWNyZXRTZXJ2aWNlLgor ICAgICAgICBTRUNSRVRfU0NIRU1BX0NPTVBBVF9ORVRXT1JLLAorICAgICAgICBjcmVhdGVBdHRy aWJ1dGVIYXNoVGFibGVGcm9tQ2hhbGxlbmdlKGNoYWxsZW5nZSkuZ2V0KCksCisgICAgICAgIHN0 YXRpY19jYXN0PFNlY3JldFNlYXJjaEZsYWdzPihTRUNSRVRfU0VBUkNIX1VOTE9DSyB8IFNFQ1JF VF9TRUFSQ0hfTE9BRF9TRUNSRVRTKSwgLy8gVGhlIGRlZmF1bHQgYmVoYXZpb3IgaXMgdG8gb25s eSByZXR1cm4gdGhlIG1vc3QgcmVjZW50IGl0ZW0uCisgICAgICAgIDAsIC8vIGNhbmNlbGxhYmxl CisgICAgICAgICZlcnJvci5vdXRQdHIoKSkpOworICAgIGlmIChlcnJvciB8fCAhZWxlbWVudHMg fHwgIWVsZW1lbnRzLT5kYXRhKQorICAgICAgICByZXR1cm4gQ3JlZGVudGlhbCgpOworCisgICAg R1JlZlB0cjxTZWNyZXRJdGVtPiBzZWNyZXRJdGVtID0gYWRvcHRHUmVmKHN0YXRpY19jYXN0PFNl Y3JldEl0ZW0qPihlbGVtZW50cy0+ZGF0YSkpOworICAgIEdSZWZQdHI8R0hhc2hUYWJsZT4gYXR0 cmlidXRlcyA9IGFkb3B0R1JlZihzZWNyZXRfaXRlbV9nZXRfYXR0cmlidXRlcyhzZWNyZXRJdGVt LmdldCgpKSk7CisgICAgU3RyaW5nIHVzZXIgPSBTdHJpbmc6OmZyb21VVEY4KHN0YXRpY19jYXN0 PGNvbnN0IGNoYXIqPihnX2hhc2hfdGFibGVfbG9va3VwKGF0dHJpYnV0ZXMuZ2V0KCksICJ1c2Vy IikpKTsKKyAgICBpZiAodXNlci5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybiBDcmVkZW50aWFs KCk7CisKKyAgICBzaXplX3QgbGVuZ3RoOworICAgIEdSZWZQdHI8U2VjcmV0VmFsdWU+IHNlY3Jl dFZhbHVlID0gYWRvcHRHUmVmKHNlY3JldF9pdGVtX2dldF9zZWNyZXQoc2VjcmV0SXRlbS5nZXQo KSkpOworICAgIGNvbnN0IGNoYXIqIHBhc3N3b3JkRGF0YSA9IHNlY3JldF92YWx1ZV9nZXQoc2Vj cmV0VmFsdWUuZ2V0KCksICZsZW5ndGgpOworICAgIFN0cmluZyBwYXNzd29yZCA9IFN0cmluZzo6 ZnJvbVVURjgocGFzc3dvcmREYXRhLCBsZW5ndGgpOworCisgICAgcmV0dXJuIENyZWRlbnRpYWwo dXNlciwgcGFzc3dvcmQsIENyZWRlbnRpYWxQZXJzaXN0ZW5jZVBlcm1hbmVudCk7Cit9CisKK3Zv aWQgQ3JlZGVudGlhbEJhY2tpbmdTdG9yZTo6c3RvcmVDcmVkZW50aWFsc0ZvckNoYWxsZW5nZShj b25zdCBBdXRoZW50aWNhdGlvbkNoYWxsZW5nZSYgY2hhbGxlbmdlLCBjb25zdCBDcmVkZW50aWFs JiBjcmVkZW50aWFsKQoreworICAgIENTdHJpbmcgdXRmOFBhc3N3b3JkID0gY3JlZGVudGlhbC5w YXNzd29yZCgpLnV0ZjgoKTsKKyAgICBHUmVmUHRyPFNlY3JldFZhbHVlPiBuZXdTZWNyZXRWYWx1 ZSA9IGFkb3B0R1JlZihzZWNyZXRfdmFsdWVfbmV3KHV0ZjhQYXNzd29yZC5kYXRhKCksIHV0ZjhQ YXNzd29yZC5sZW5ndGgoKSwgInRleHQvcGxhaW4iKSk7CisKKyAgICBHT3duUHRyPEdFcnJvcj4g ZXJyb3I7CisgICAgc2VjcmV0X3NlcnZpY2Vfc3RvcmVfc3luYygKKyAgICAgICAgMCwgLy8gVGhl IGRlZmF1bHQgU2VjcmV0U2VydmljZS4KKyAgICAgICAgU0VDUkVUX1NDSEVNQV9DT01QQVRfTkVU V09SSywKKyAgICAgICAgY3JlYXRlQXR0cmlidXRlSGFzaFRhYmxlRnJvbUNoYWxsZW5nZShjaGFs bGVuZ2UsIGNyZWRlbnRpYWwpLmdldCgpLAorICAgICAgICBTRUNSRVRfQ09MTEVDVElPTl9ERUZB VUxULAorICAgICAgICBfKCJXZWJLaXRHVEsrIHBhc3N3b3JkIiksCisgICAgICAgIG5ld1NlY3Jl dFZhbHVlLmdldCgpLAorICAgICAgICAwLCAvLyBjYW5jZWxsYWJsZQorICAgICAgICAmZXJyb3Iu b3V0UHRyKCkpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2d0ay9DcmVkZW50aWFsQmFja2luZ1N0b3JlLmgg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2d0ay9DcmVkZW50aWFsQmFja2luZ1N0 b3JlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uN2EyMDRhODA1MWUyZjZhMDA4MjgxNWUwMTBlYzQzN2JmNTI0MDI2 OAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvZ3Rr L0NyZWRlbnRpYWxCYWNraW5nU3RvcmUuaApAQCAtMCwwICsxLDUzIEBACisvKgorICogQ29weXJp Z2h0IChDKSAyMDEyIElnYWxpYSBTLkwuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMK KyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRp b25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFs cyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBJR0FMSUEgUy5MLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUK KyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNI QUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZP UiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFS WSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1Mg T0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVS IElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5F R0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UK KyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBDcmVkZW50aWFsQmFja2luZ1N0b3JlX2gK KyNkZWZpbmUgQ3JlZGVudGlhbEJhY2tpbmdTdG9yZV9oCisKKyNpbmNsdWRlICJBdXRoZW50aWNh dGlvbkNoYWxsZW5nZS5oIgorI2luY2x1ZGUgIkNyZWRlbnRpYWwuaCIKKworbmFtZXNwYWNlIFdl YkNvcmUgeworCitjbGFzcyBLVVJMOworY2xhc3MgUHJvdGVjdGlvblNwYWNlOworCitjbGFzcyBD cmVkZW50aWFsQmFja2luZ1N0b3JlIHsKK3B1YmxpYzoKKyAgICBmcmllbmQgQ3JlZGVudGlhbEJh Y2tpbmdTdG9yZSYgY3JlZGVudGlhbEJhY2tpbmdTdG9yZSgpOworICAgIH5DcmVkZW50aWFsQmFj a2luZ1N0b3JlKCk7CisKKyAgICBDcmVkZW50aWFsIGdldENyZWRlbnRpYWxGb3JDaGFsbGVuZ2Uo Y29uc3QgQXV0aGVudGljYXRpb25DaGFsbGVuZ2UmKTsKKyAgICB2b2lkIHN0b3JlQ3JlZGVudGlh bHNGb3JDaGFsbGVuZ2UoY29uc3QgQXV0aGVudGljYXRpb25DaGFsbGVuZ2UmLCBjb25zdCBDcmVk ZW50aWFsJik7CisKK3ByaXZhdGU6CisgICAgQ3JlZGVudGlhbEJhY2tpbmdTdG9yZSgpOworfTsK KworQ3JlZGVudGlhbEJhY2tpbmdTdG9yZSYgY3JlZGVudGlhbEJhY2tpbmdTdG9yZSgpOworCit9 IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBDcmVkZW50aWFsQmFja2luZ1N0b3Jl X2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZ3RrL0dOVW1ha2VmaWxlLmFtIGIvU291cmNl L1dlYktpdC9ndGsvR05VbWFrZWZpbGUuYW0KaW5kZXggNWJlOWViNTQ4ZWUwMjNkMTQwYTM1ZDE2 NjI0MzNkNTgxYmI3MWI4My4uYzEzNmNiYzlkZmFjODk2YmIzZGNhYWY4NWJhZjFhMWY1Y2U3MzU4 ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9ndGsvR05VbWFrZWZpbGUuYW0KKysrIGIvU291 cmNlL1dlYktpdC9ndGsvR05VbWFrZWZpbGUuYW0KQEAgLTk1LDYgKzk1LDcgQEAgbGlid2Via2l0 Z3RrX0BXRUJLSVRHVEtfQVBJX01BSk9SX1ZFUlNJT05AX0BXRUJLSVRHVEtfQVBJX01JTk9SX1ZF UlNJT05AX2xhX0xJQkEKIAkkKEdTVFJFQU1FUl9MSUJTKSBcCiAJJChHVEtfTElCUykgXAogCSQo SlBFR19MSUJTKSBcCisJJChMSUJTRUNSRVRfTElCUykgXAogCSQoTElCU09VUF9MSUJTKSBcCiAJ JChMSUJYTUxfTElCUykgXAogCSQoTElCWFNMVF9MSUJTKSBcCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0Mi9HTlVtYWtlZmlsZS5hbSBiL1NvdXJjZS9XZWJLaXQyL0dOVW1ha2VmaWxlLmFtCmlu ZGV4IGY5NTZkMGVkZGZjMDkzOTc5YzViYzAyNjAzY2U1MTRjMjU3ODE4NmIuLmEyNTJjZDFkODRm MzA4YjUwOTQ3MjY5MWRjMDljYTk3YmQ5ZTlmMTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L0dOVW1ha2VmaWxlLmFtCisrKyBiL1NvdXJjZS9XZWJLaXQyL0dOVW1ha2VmaWxlLmFtCkBAIC0x NzUsNiArMTc1LDcgQEAgbGlid2Via2l0Mmd0a19AV0VCS0lUR1RLX0FQSV9NQUpPUl9WRVJTSU9O QF9AV0VCS0lUR1RLX0FQSV9NSU5PUl9WRVJTSU9OQF9sYV9MSUIKIAkkKEdUS19MSUJTKSBcCiAJ JChHVEtfVU5JWF9QUklOVElOR19MSUJTKSBcCiAJJChKUEVHX0xJQlMpIFwKKwkkKExJQlNFQ1JF VF9MSUJTKSBcCiAJJChMSUJTT1VQX0xJQlMpIFwKIAkkKExJQlhNTF9MSUJTKSBcCiAJJChMSUJY U0xUX0xJQlMpIFwKQEAgLTQwOSw2ICs0MTAsNyBAQCBsaWJXZWJDb3JlR3RrMl9sYV9DUFBGTEFH UyA9IFwKIAkkKEdMSUJfQ0ZMQUdTKSBcCiAJJChHU1RSRUFNRVJfQ0ZMQUdTKSBcCiAJJChHVEsy X0NGTEFHUykgXAorCSQoTElCU0VDUkVUX0NGTEFHUykgXAogCSQoTElCU09VUF9DRkxBR1MpIFwK IAkkKExJQlhNTF9DRkxBR1MpIFwKIAkkKExJQlhTTFRfQ0ZMQUdTKSBcCmRpZmYgLS1naXQgYS9D aGFuZ2VMb2cgYi9DaGFuZ2VMb2cKaW5kZXggN2U0NDA0MjVkYThiMGFmMWZiNzZlMWM3NDU0NTc1 Mjg3MmJiNmM3MC4uMmNlN2ZhMmY1Y2IwYjM4NjFhZmRlZDMwN2I1OGMyYjdhNjIyYjdlNCAxMDA2 NDQKLS0tIGEvQ2hhbmdlTG9nCisrKyBiL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEy LTEwLTMwICBNYXJ0aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KKworICAgICAg ICBbR1RLXSBSZW1vdmUgZGVwZW5kZW5jeSBvbiBTb3VwUGFzc3dvcmRNYW5hZ2VyCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDA3NzUKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgYSBsaWJzZWNyZXQg ZGVwZW5kZW5jeSB0byB0aGUgYnVpbGQuIFRoaXMgaXMgbmVjZXNzYXJ5IHNvIHRoYXQgd2UgY2Fu IHJlbW92ZQorICAgICAgICBhIGRlcGVuZGVuY3kgb24gU291cFBhc3N3b3JkTWFuYWdlci4KKwor ICAgICAgICAqIGNvbmZpZ3VyZS5hYzogTG9vayBmb3IgbGlic2VjcmV0IHVzaW5nIHRoZSBwa2ct Y29uZmlnIGNvbmZpZ3VyYXRpb24gbWFjcm8uCisKIDIwMTItMTAtMjYgIFJvYiBCdWlzICA8cmJ1 aXNAcmltLmNvbT4KIAogICAgICAgICBbQmxhY2tCZXJyeV0gUGxhdGZvcm0gQWJzdHJhY3Rpb24g Zm9yIFdlYktpdCBSZXNvdXJjZS9JbWFnZSBMb2FkaW5nCmRpZmYgLS1naXQgYS9jb25maWd1cmUu YWMgYi9jb25maWd1cmUuYWMKaW5kZXggOGI5Y2VhMDMxOWEzZDc5NmM3NmM1NjQxNmZmNTQ2NTVm NjY4MWQzOC4uMmRhYTZkYmNlM2FjOWUwZmY4ZGFjMjcxOTI2MzRjYWFmYjE5YTIzMCAxMDA2NDQK LS0tIGEvY29uZmlndXJlLmFjCisrKyBiL2NvbmZpZ3VyZS5hYwpAQCAtOTUzLDYgKzk1MywxMCBA QCBQS0dfQ0hFQ0tfTU9EVUxFUyhbTElCU09VUF0sCiBBQ19TVUJTVChbTElCU09VUF9DRkxBR1Nd KQogQUNfU1VCU1QoW0xJQlNPVVBfTElCU10pCiAKK1BLR19DSEVDS19NT0RVTEVTKFtMSUJTRUNS RVRdLCBbbGlic2VjcmV0LTFdKQorQUNfU1VCU1QoW0xJQlNFQ1JFVF9DRkxBR1NdKQorQUNfU1VC U1QoW0xJQlNFQ1JFVF9MSUJTXSkKKwogIyBjaGVjayBpZiBGcmVlVHlwZS9Gb250Q29uZmlnIGFy ZSBhdmFpbGFibGUKIGlmIHRlc3QgIiR3aXRoX2ZvbnRfYmFja2VuZCIgPSAiZnJlZXR5cGUiOyB0 aGVuCiAgICBpZiB0ZXN0ICIkd2l0aF90YXJnZXQiID0gImRpcmVjdGZiIjsgdGhlbgo= 171676 2012-10-31 09:51:13 -0700 2012-11-01 09:10:08 -0700 Patch bug-100775-20121031094936.patch text/plain 24893 mrobinson U3VidmVyc2lvbiBSZXZpc2lvbjogMTMyODQ3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTBmY2JhMTdhMjA3NDY1 N2VhMjg1Y2MxY2E3ZmNjYTU5N2E2YTI5Yi4uMDM3MWE3ZGM4NzUwMDI0NGQ1MjJlYjI2MTczYjFm YTEyZWJjYWMyMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDEyLTEwLTMwICBNYXJ0 aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBSZW1v dmUgZGVwZW5kZW5jeSBvbiBTb3VwUGFzc3dvcmRNYW5hZ2VyCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDA3NzUKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZW1lbWJlciBwYXNzd29yZHMgdXNpbmcgbGli c2VjcmV0IGluc3RlYWQgb2YgU291cFBhc3N3b3JkTWFuYWdlci4gV2UgYWNjb21wbGlzaCB0aGlz IHVzaW5nCisgICAgICAgIGEgbmV3IGNsYXNzLCBDcmVkZW50aWFsQmFja2luZ1N0b3JlLiBDcmVk ZW50aWFsQmFja2luZ1N0b3JlIHdpbGwgc29vbiBiZSB0aGUgdGhpbmcgdGhhdCBiYWNrcworICAg ICAgICBDcmVkZW50aWFsU3RvcmVHdGsuIFRoZSBuYW1lIGlzIGJhc2VkIG9uIHRoZSBuYW1lIG9m IGEgc2ltaWxhciBjbGFzcyBmcm9tIHRoZSBCbGFja2JlcnJ5IHBvcnQuCisKKyAgICAgICAgTm8g bmV3IHRlc3RzLiBUaGlzIHNob3VsZCBub3QgY2hhbmdlIGJlaGF2aW9yLgorCisgICAgICAgICog R05VbWFrZWZpbGUuYW06IEFkZCBsaWJzZWNyZXQgZmxhZ3MgdG8gdGhlIGJ1aWxkIGFuZCB0aGUg bmV3IGRpcmVjdG9yeSB0byB0aGUgaW5jbHVkZSBsaXN0LgorICAgICAgICAqIEdOVW1ha2VmaWxl Lmxpc3QuYW06IEFkZCBuZXcgZmlsZXMgdG8gdGhlIHNvdXJjZSBsaXN0LgorICAgICAgICAqIHBs YXRmb3JtL2d0ay9HUmVmUHRyR3RrLmNwcDogQWRkIHN1cHBvcnQgZm9yIFNlY3JldFZhbHVlIHRv IEdSZWZQdHJHdGsuCisgICAgICAgICogcGxhdGZvcm0vZ3RrL0d0a0F1dGhlbnRpY2F0aW9uRGlh bG9nLmNwcDogUmVwbGFjZSBpbnRlcmFjdGlvbiB3aXRoIFNvdXBQYXNzd29yZE1hbmdlciB3aXRo CisgICAgICAgIGludGVyYWN0aW9uIHdpdGggdGhlIENyZWRlbnRpYWxCYWNraW5nU3RvcmUuIFJl bW92ZSBhbGwgY29uZGl0aW9uYWwgU291cFBhc3N3b3JkTWFuYWdlciBndWFyZHMuCisgICAgICAg ICogcGxhdGZvcm0vZ3RrL0d0a0F1dGhlbnRpY2F0aW9uRGlhbG9nLmg6IERpdHRvLgorICAgICAg ICAqIHBsYXRmb3JtL25ldHdvcmsvZ3RrL0NyZWRlbnRpYWxCYWNraW5nU3RvcmUuY3BwOiBBZGRl ZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL2d0ay9DcmVkZW50aWFsQmFja2luZ1N0b3Jl Lmg6IEFkZGVkLgorCiAyMDEyLTEwLTI5ICBQaGlsaXAgUm9nZXJzICA8cGRyQGdvb2dsZS5jb20+ CiAKICAgICAgICAgTGV0IFNWR0VsZW1lbnRzIGhhdmUgcGVuZGluZyByZXNvdXJjZXMuCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2d0ay9D aGFuZ2VMb2cKaW5kZXggOTBhZWI0ZjMzZGRjNzU0YmY1ZjM2ZmMyOTUxMjlmNDk2YmEzNDkzYS4u N2JkOGVlNjk5ODFiMDM3ZTk5MDVkMzdjNmI5NTZhNzU1YWI0OWQ2MSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvZ3RrL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDE1IEBACisyMDEyLTEwLTMwICBNYXJ0aW4gUm9iaW5zb24gIDxtcm9iaW5z b25AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBSZW1vdmUgZGVwZW5kZW5jeSBvbiBTb3Vw UGFzc3dvcmRNYW5hZ2VyCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xMDA3NzUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBBZGQgYSBsaWJzZWNyZXQgZGVwZW5kZW5jeSB0byB0aGUgYnVpbGQuIFRoaXMgaXMg bmVjZXNzYXJ5IHNvIHRoYXQgd2UgY2FuIHJlbW92ZQorICAgICAgICBhIGRlcGVuZGVuY3kgb24g U291cFBhc3N3b3JkTWFuYWdlci4KKworICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOiBVc2UgbGli c2VjcmV0IGxpYnMgZHVyaW5nIFdlYktpdDEgbGlicmFyeSBjb21waWxhdGlvbi4KKwogMjAxMi0x MC0yNCAgQnJhZHkgRWlkc29uICA8YmVpZHNvbkBhcHBsZS5jb20+CiAKICAgICAgICAgQWRkIGEg c3RyYXRlZ3kgZm9yIGxvYWRlciBjdXN0b21pemF0aW9uLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdDIvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IDUyMGEwZTI3 MzM0NmFjN2EyZmIyNjYwYWViZmM5MTFhOGUyMjZjYjQuLjk4YmIwNmRmMDQ2ZWI4ODg5ODQ4YmYx ZGM3YTBmM2Q2Nzc5ZTk1YTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwor KysgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxMi0xMC0z MCAgTWFydGluIFJvYmluc29uICA8bXJvYmluc29uQGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dU S10gUmVtb3ZlIGRlcGVuZGVuY3kgb24gU291cFBhc3N3b3JkTWFuYWdlcgorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTAwNzc1CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGEgbGlic2VjcmV0IGRlcGVu ZGVuY3kgdG8gdGhlIGJ1aWxkLiBUaGlzIGlzIG5lY2Vzc2FyeSBzbyB0aGF0IHdlIGNhbiByZW1v dmUKKyAgICAgICAgYSBkZXBlbmRlbmN5IG9uIFNvdXBQYXNzd29yZE1hbmFnZXIuCisKKyAgICAg ICAgKiBHTlVtYWtlZmlsZS5hbTogQWRkIGxpYnNlY3JldCBDRkxBR1MgdG8gdGhlIFdlYktpdDIg YnVpbGQuCisKIDIwMTItMTAtMjkgIE1pY2hhZWwgU2Fib2ZmICA8bXNhYm9mZkBhcHBsZS5jb20+ CiAKICAgICAgICAgYnVpbGRIVFRQSGVhZGVycygpIHNob3VsZCB1c2UgYSBTdHJpbmdCdWlsZGVy LmFwcGVuZExpdGVyYWwoKSBmb3Igc2VwYXJhdG9yCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9HTlVtYWtlZmlsZS5hbSBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCmluZGV4IDM2 MTZhMzgwYTZjYmQyOTg4NDMyMjYzMDI5M2YxMmZlZTdjZjBlMTguLmU2NmJmMDU0N2NiODA4ODVl Yjc0NjIwMWIwY2VkOWZiNDczN2FlMTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0dOVW1h a2VmaWxlLmFtCisrKyBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCkBAIC03Myw2ICs3 Myw3IEBAIHdlYmNvcmVfY3BwZmxhZ3MgKz0gXAogCS1JJChzcmNkaXIpL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL21lZGlhc3RyZWFtL2dzdHJlYW1lciBcCiAJLUkkKHNyY2RpcikvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vbW9jayBcCiAJLUkkKHNyY2RpcikvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vbmV0d29yayBcCisJLUkkKHNyY2RpcikvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9ndGsgXAogCS1JJChzcmNkaXIpL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3NxbCBcCiAJLUkk KHNyY2RpcikvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dCBcCiAJLUkkKHNyY2RpcikvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC90cmFuc2NvZGVyIFwKQEAgLTY0MSw2ICs2NDIsNyBA QCBsaWJXZWJDb3JlX2xhX0NQUEZMQUdTID0gXAogCSQoR0VPQ0xVRV9DRkxBR1MpIFwKIAkkKEdM SUJfQ0ZMQUdTKSBcCiAJJChHU1RSRUFNRVJfQ0ZMQUdTKSBcCisJJChMSUJTRUNSRVRfQ0ZMQUdT KSBcCiAJJChMSUJTT1VQX0NGTEFHUykgXAogCSQoTElCWE1MX0NGTEFHUykgXAogCSQoTElCWFNM VF9DRkxBR1MpIFwKQEAgLTcwNCw2ICs3MDYsNyBAQCBsaWJXZWJDb3JlR3RrX2xhX0NQUEZMQUdT ID0gXAogCSQoR1NUUkVBTUVSX0NGTEFHUykgXAogCSQoR1RLX0NGTEFHUykgXAogCSQoSElMRE9O X0NGTEFHUykgXAorCSQoTElCU0VDUkVUX0NGTEFHUykgXAogCSQoTElCU09VUF9DRkxBR1MpIFwK IAkkKExJQlhNTF9DRkxBR1MpIFwKIAkkKExJQlhTTFRfQ0ZMQUdTKSBcCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtIGIvU291cmNlL1dlYkNvcmUvR05VbWFr ZWZpbGUubGlzdC5hbQppbmRleCBiMGJkZDJlYmFiNzNiYTlmYjI2MTI5MzUxOTJjYjNmNTQ5MjM3 MDNiLi40MDNjNzM0YThlZDFhYWU2Y2MwNjVjZDE1NDY1NjVjYTVkMzUwZjE4IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCisrKyBiL1NvdXJjZS9XZWJDb3Jl L0dOVW1ha2VmaWxlLmxpc3QuYW0KQEAgLTQ3MzYsNiArNDczNiw4IEBAIHdlYmNvcmVfc291cmNl cyArPSBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9Tb2NrZXRTdHJlYW1IYW5k bGVCYXNlLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9Tb2NrZXRTdHJl YW1IYW5kbGVCYXNlLmggXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvU29ja2V0 U3RyZWFtSGFuZGxlQ2xpZW50LmggXAorCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv Z3RrL0NyZWRlbnRpYWxCYWNraW5nU3RvcmUuY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9uZXR3b3JrL2d0ay9DcmVkZW50aWFsQmFja2luZ1N0b3JlLmggXAogCVNvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvc291cC9BdXRoZW50aWNhdGlvbkNoYWxsZW5nZS5oIFwKIAlTb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQXV0aGVudGljYXRpb25DaGFsbGVuZ2VT b3VwLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUph clNvdXAuY3BwIFwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9HUmVm UHRyR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9HUmVmUHRyR3RrLmNwcApp bmRleCA5YTlkNjc5NWY4M2FhYTU5ZmY1MmM5NWY0ODliZGQyZjUyY2VjMmE0Li5mYTUwNmRmOTAw N2QyNGNjMDc2Nzc2OGRlZmQxMDU2NjJmYzM5YjNkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ndGsvR1JlZlB0ckd0ay5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL0dSZWZQdHJHdGsuY3BwCkBAIC0yMCw4ICsyMCwxMiBAQAogI2luY2x1ZGUgImNvbmZp Zy5oIgogI2luY2x1ZGUgIkdSZWZQdHJHdGsuaCIKIAorI2RlZmluZSBTRUNSRVRfV0lUSF9VTlNU QUJMRSAxCisjZGVmaW5lIFNFQ1JFVF9BUElfU1VCSkVDVF9UT19DSEFOR0UgMQorCiAjaW5jbHVk ZSA8Z2xpYi5oPgogI2luY2x1ZGUgPGd0ay9ndGsuaD4KKyNpbmNsdWRlIDxsaWJzZWNyZXQvc2Vj cmV0Lmg+CiAKIG5hbWVzcGFjZSBXVEYgewogCkBAIC0zOCw2ICs0MiwxOSBAQCB0ZW1wbGF0ZSA8 PiB2b2lkIGRlcmVmR1B0cihHdGtUYXJnZXRMaXN0KiBwdHIpCiAgICAgICAgIGd0a190YXJnZXRf bGlzdF91bnJlZihwdHIpOwogfQogCit0ZW1wbGF0ZSA8PiBTZWNyZXRWYWx1ZSogcmVmR1B0cihT ZWNyZXRWYWx1ZSogcHRyKQoreworICAgIGlmIChwdHIpCisgICAgICAgIHNlY3JldF92YWx1ZV9y ZWYocHRyKTsKKyAgICByZXR1cm4gcHRyOworfQorCit0ZW1wbGF0ZSA8PiB2b2lkIGRlcmVmR1B0 cihTZWNyZXRWYWx1ZSogcHRyKQoreworICAgIGlmIChwdHIpCisgICAgICAgIHNlY3JldF92YWx1 ZV91bnJlZihwdHIpOworfQorCiAjaWZkZWYgR1RLX0FQSV9WRVJTSU9OXzIKIHRlbXBsYXRlIDw+ IEdka0N1cnNvciogcmVmR1B0cihHZGtDdXJzb3IqIHB0cikKIHsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9HUmVmUHRyR3RrLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvR1JlZlB0ckd0ay5oCmluZGV4IGE5ZjQ5MWYxNDcwZTQyMTg5MTI3ZmY0Zjg2NWEz MzE2NGExN2E3ZjYuLjkxOTI4NjRhOTIyOWRhYjg4M2JlZmE1NjJiMjM1YWQ4YWMzOTZkYzkgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9HUmVmUHRyR3RrLmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0dSZWZQdHJHdGsuaApAQCAtMjMsMTEgKzIzLDE2 IEBACiAKICNpbmNsdWRlIDx3dGYvZ29iamVjdC9HUmVmUHRyLmg+CiAKK3R5cGVkZWYgc3RydWN0 IF9TZWNyZXRWYWx1ZSBTZWNyZXRWYWx1ZTsKKwogbmFtZXNwYWNlIFdURiB7CiAKIHRlbXBsYXRl IDw+IEd0a1RhcmdldExpc3QqIHJlZkdQdHIoR3RrVGFyZ2V0TGlzdCogcHRyKTsKIHRlbXBsYXRl IDw+IHZvaWQgZGVyZWZHUHRyKEd0a1RhcmdldExpc3QqIHB0cik7CiAKK3RlbXBsYXRlIDw+IFNl Y3JldFZhbHVlKiByZWZHUHRyKFNlY3JldFZhbHVlKiBwdHIpOwordGVtcGxhdGUgPD4gdm9pZCBk ZXJlZkdQdHIoU2VjcmV0VmFsdWUqIHB0cik7CisKICNpZmRlZiBHVEtfQVBJX1ZFUlNJT05fMgog dGVtcGxhdGUgPD4gR2RrQ3Vyc29yKiByZWZHUHRyKEdka0N1cnNvciogcHRyKTsKIHRlbXBsYXRl IDw+IHZvaWQgZGVyZWZHUHRyKEdka0N1cnNvciogcHRyKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2d0ay9HdGtBdXRoZW50aWNhdGlvbkRpYWxvZy5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ndGsvR3RrQXV0aGVudGljYXRpb25EaWFsb2cuY3BwCmluZGV4IDM2 YmQzMWIxZWE1MTNmNTI1NjI5ZDhkOTAyYmNkYzBlNTlhZmE4NWYuLmNjNTYxMTMyZGQyNzNmM2Nl ZGI1MTRjNWNlMGFlZWIzMTJkMTgxMTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9HdGtBdXRoZW50aWNhdGlvbkRpYWxvZy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0d0a0F1dGhlbnRpY2F0aW9uRGlhbG9nLmNwcApAQCAtMjAsNiArMjAsOCBA QAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIkd0a0F1dGhlbnRpY2F0aW9uRGlhbG9n LmgiCiAKKyNpbmNsdWRlICJBdXRoZW50aWNhdGlvbkNoYWxsZW5nZS5oIgorI2luY2x1ZGUgIkNy ZWRlbnRpYWxCYWNraW5nU3RvcmUuaCIKICNpbmNsdWRlICJHdGtWZXJzaW9uaW5nLmgiCiAjaW5j bHVkZSA8Z2xpYi9naTE4bi1saWIuaD4KICNpbmNsdWRlIDxndGsvZ3RrLmg+CkBAIC01NCwxNSAr NTYsNiBAQCBzdGF0aWMgR3RrV2lkZ2V0KiBhZGRFbnRyeVRvR3JpZChHdGtHcmlkKiBncmlkLCBp bnQgcm93LCBjb25zdCBjaGFyKiBsYWJlbFRleHQpCiAgICAgcmV0dXJuIGVudHJ5OwogfQogCi1z dGF0aWMgYm9vbCBzZXNzaW9uQ2FuU2F2ZVBhc3N3b3JkcyhTb3VwU2Vzc2lvbiogc2Vzc2lvbikK LXsKLSNpZmRlZiBTT1VQX1RZUEVfUEFTU1dPUkRfTUFOQUdFUgotICAgIHJldHVybiBzb3VwX3Nl c3Npb25fZ2V0X2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9UWVBFX1BBU1NXT1JEX01BTkFHRVIpOwot I2Vsc2UKLSAgICByZXR1cm4gZmFsc2U7Ci0jZW5kaWYKLX0KLQogR3RrQXV0aGVudGljYXRpb25E aWFsb2c6On5HdGtBdXRoZW50aWNhdGlvbkRpYWxvZygpCiB7CiB9CkBAIC03NSwxMCArNjgsOCBA QCBHdGtBdXRoZW50aWNhdGlvbkRpYWxvZzo6R3RrQXV0aGVudGljYXRpb25EaWFsb2coR3RrV2lu ZG93KiBwYXJlbnRXaW5kb3csIFNvdXBTZQogICAgICwgbV9sb2dpbkVudHJ5KDApCiAgICAgLCBt X3Bhc3N3b3JkRW50cnkoMCkKICAgICAsIG1fcmVtZW1iZXJDaGVja0J1dHRvbigwKQotI2lmZGVm IFNPVVBfVFlQRV9QQVNTV09SRF9NQU5BR0VSCiAgICAgLCBtX2lzU2F2aW5nUGFzc3dvcmQoZmFs c2UpCiAgICAgLCBtX3NhdmVQYXNzd29yZEhhbmRsZXIoMCkKLSNlbmRpZgogewogICAgIEd0a0Rp YWxvZyogZGlhbG9nID0gR1RLX0RJQUxPRyhtX2RpYWxvZyk7CiAgICAgZ3RrX2RpYWxvZ19hZGRf YnV0dG9ucyhkaWFsb2csIEdUS19TVE9DS19DQU5DRUwsIEdUS19SRVNQT05TRV9DQU5DRUwsIEdU S19TVE9DS19PSywgR1RLX1JFU1BPTlNFX09LLCBOVUxMKTsKQEAgLTE4Nyw0NyArMTc4LDMxIEBA IEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9nOjpHdGtBdXRoZW50aWNhdGlvbkRpYWxvZyhHdGtXaW5k b3cqIHBhcmVudFdpbmRvdywgU291cFNlCiAKICAgICBndGtfZW50cnlfc2V0X3Zpc2liaWxpdHko R1RLX0VOVFJZKG1fcGFzc3dvcmRFbnRyeSksIEZBTFNFKTsKIAotICAgIGlmIChzZXNzaW9uQ2Fu U2F2ZVBhc3N3b3JkcyhtX3Nlc3Npb24pKSB7CiAjaWZkZWYgR1RLX0FQSV9WRVJTSU9OXzIKLSAg ICAgICAgR3RrV2lkZ2V0KiByZW1lbWJlckJveCA9IGd0a192Ym94X25ldyhGQUxTRSwgNik7Cisg ICAgR3RrV2lkZ2V0KiByZW1lbWJlckJveCA9IGd0a192Ym94X25ldyhGQUxTRSwgNik7CiAjZWxz ZQotICAgICAgICBHdGtXaWRnZXQqIHJlbWVtYmVyQm94ID0gZ3RrX2JveF9uZXcoR1RLX09SSUVO VEFUSU9OX1ZFUlRJQ0FMLCA2KTsKKyAgICBHdGtXaWRnZXQqIHJlbWVtYmVyQm94ID0gZ3RrX2Jv eF9uZXcoR1RLX09SSUVOVEFUSU9OX1ZFUlRJQ0FMLCA2KTsKICNlbmRpZgotICAgICAgICBndGtf Ym94X3BhY2tfc3RhcnQoR1RLX0JPWCh2Qm94KSwgcmVtZW1iZXJCb3gsIEZBTFNFLCBGQUxTRSwg MCk7CisgICAgZ3RrX2JveF9wYWNrX3N0YXJ0KEdUS19CT1godkJveCksIHJlbWVtYmVyQm94LCBG QUxTRSwgRkFMU0UsIDApOwogCi0gICAgICAgIG1fcmVtZW1iZXJDaGVja0J1dHRvbiA9IGd0a19j aGVja19idXR0b25fbmV3X3dpdGhfbW5lbW9uaWMoXygiX1JlbWVtYmVyIHBhc3N3b3JkIikpOwot ICAgICAgICBndGtfbGFiZWxfc2V0X2xpbmVfd3JhcChHVEtfTEFCRUwoZ3RrX2Jpbl9nZXRfY2hp bGQoR1RLX0JJTihtX3JlbWVtYmVyQ2hlY2tCdXR0b24pKSksIFRSVUUpOwotICAgICAgICBndGtf Ym94X3BhY2tfc3RhcnQoR1RLX0JPWChyZW1lbWJlckJveCksIG1fcmVtZW1iZXJDaGVja0J1dHRv biwgRkFMU0UsIEZBTFNFLCAwKTsKLSAgICB9Ci19Ci0KLXN0YXRpYyBib29sIGdldFNhdmVkTG9n aW4oU291cEF1dGgqIGF1dGgsIGNvbnN0IGNoYXIqKiB1c2VybmFtZSwgY29uc3QgY2hhcioqIHBh c3N3b3JkKQotewotI2lmZGVmIFNPVVBfVFlQRV9QQVNTV09SRF9NQU5BR0VSCi0gICAgR1NMaXN0 KiB1c2VycyA9IHNvdXBfYXV0aF9nZXRfc2F2ZWRfdXNlcnMoYXV0aCk7Ci0gICAgaWYgKCF1c2Vy cykKLSAgICAgICAgcmV0dXJuIGZhbHNlOwotCi0gICAgKnVzZXJuYW1lID0gc3RhdGljX2Nhc3Q8 Y2hhcio+KHVzZXJzLT5kYXRhKTsKLSAgICAqcGFzc3dvcmQgPSBzb3VwX2F1dGhfZ2V0X3NhdmVk X3Bhc3N3b3JkKGF1dGgsICp1c2VybmFtZSk7Ci0gICAgZ19zbGlzdF9mcmVlKHVzZXJzKTsKLQot ICAgIHJldHVybiAqdXNlcm5hbWUgJiYgKnBhc3N3b3JkOwotI2Vsc2UKLSAgICByZXR1cm4gZmFs c2U7Ci0jZW5kaWYKKyAgICBtX3JlbWVtYmVyQ2hlY2tCdXR0b24gPSBndGtfY2hlY2tfYnV0dG9u X25ld193aXRoX21uZW1vbmljKF8oIl9SZW1lbWJlciBwYXNzd29yZCIpKTsKKyAgICBndGtfbGFi ZWxfc2V0X2xpbmVfd3JhcChHVEtfTEFCRUwoZ3RrX2Jpbl9nZXRfY2hpbGQoR1RLX0JJTihtX3Jl bWVtYmVyQ2hlY2tCdXR0b24pKSksIFRSVUUpOworICAgIGd0a19ib3hfcGFja19zdGFydChHVEtf Qk9YKHJlbWVtYmVyQm94KSwgbV9yZW1lbWJlckNoZWNrQnV0dG9uLCBGQUxTRSwgRkFMU0UsIDAp OwogfQogCiB2b2lkIEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9nOjpzaG93KCkKIHsKLSAgICBjb25z dCBjaGFyKiB1c2VybmFtZSA9IDA7Ci0gICAgY29uc3QgY2hhciogcGFzc3dvcmQgPSAwOwotICAg IGJvb2wgaGF2ZVNhdmVkTG9naW4gPSBnZXRTYXZlZExvZ2luKG1fYXV0aC5nZXQoKSwgJnVzZXJu YW1lLCAmcGFzc3dvcmQpOwogICAgIHNvdXBfc2Vzc2lvbl9wYXVzZV9tZXNzYWdlKG1fc2Vzc2lv biwgbV9tZXNzYWdlLmdldCgpKTsKLSAgICBndGtfZW50cnlfc2V0X3RleHQoR1RLX0VOVFJZKG1f bG9naW5FbnRyeSksIHVzZXJuYW1lID8gdXNlcm5hbWUgOiAiIik7Ci0gICAgZ3RrX2VudHJ5X3Nl dF90ZXh0KEdUS19FTlRSWShtX3Bhc3N3b3JkRW50cnkpLCBwYXNzd29yZCA/IHBhc3N3b3JkIDog IiIpOwotICAgIGlmIChtX3JlbWVtYmVyQ2hlY2tCdXR0b24gJiYgaGF2ZVNhdmVkTG9naW4pCisK KyAgICAvLyBUaGlzIGlzIGp1c3QgYSB0ZW1wb3Jhcnkga2x1ZGdlIHVudGlsIEd0a0F1dGhlbnRp Y2F0aW9uRGlhbG9nIHdvcmtzIGRpcmVjdGx5IHdpdGggQXV0aGVudGljYXRpb25DaGFsbGVuZ2Vz LgorICAgIEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlIGNoYWxsZW5nZSgwIC8qIHNlc3Npb24gKi8s IG1fbWVzc2FnZS5nZXQoKSwgbV9hdXRoLmdldCgpLCBmYWxzZSwgMCk7CisgICAgQ3JlZGVudGlh bCBzYXZlZENyZWRlbnRpYWwgPSBjcmVkZW50aWFsQmFja2luZ1N0b3JlKCkuZ2V0Q3JlZGVudGlh bEZvckNoYWxsZW5nZShjaGFsbGVuZ2UpOworICAgIGlmICghc2F2ZWRDcmVkZW50aWFsLmlzRW1w dHkoKSkgeworICAgICAgICBndGtfZW50cnlfc2V0X3RleHQoR1RLX0VOVFJZKG1fbG9naW5FbnRy eSksIHNhdmVkQ3JlZGVudGlhbC51c2VyKCkudXRmOCgpLmRhdGEoKSk7CisgICAgICAgIGd0a19l bnRyeV9zZXRfdGV4dChHVEtfRU5UUlkobV9wYXNzd29yZEVudHJ5KSwgc2F2ZWRDcmVkZW50aWFs LnBhc3N3b3JkKCkudXRmOCgpLmRhdGEoKSk7CiAgICAgICAgIGd0a190b2dnbGVfYnV0dG9uX3Nl dF9hY3RpdmUoR1RLX1RPR0dMRV9CVVRUT04obV9yZW1lbWJlckNoZWNrQnV0dG9uKSwgVFJVRSk7 CisgICAgfQorCiAgICAgZ19zaWduYWxfY29ubmVjdChtX2RpYWxvZywgInJlc3BvbnNlIiwgR19D QUxMQkFDSyhhdXRoZW50aWNhdGlvbkRpYWxvZ1Jlc3BvbnNlQ2FsbGJhY2spLCB0aGlzKTsKICAg ICBndGtfd2lkZ2V0X3Nob3dfYWxsKG1fZGlhbG9nKTsKIH0KQEAgLTIzOSw5ICsyMTQsNyBAQCB2 b2lkIEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9nOjpkZXN0cm95KCkKICAgICBzb3VwX3Nlc3Npb25f dW5wYXVzZV9tZXNzYWdlKG1fc2Vzc2lvbiwgbV9tZXNzYWdlLmdldCgpKTsKICAgICBndGtfd2lk Z2V0X2Rlc3Ryb3kobV9kaWFsb2cpOwogCi0jaWZkZWYgU09VUF9UWVBFX1BBU1NXT1JEX01BTkFH RVIKICAgICBzaG91bGREZWxldGUgPSAhbV9pc1NhdmluZ1Bhc3N3b3JkOwotI2VuZGlmCiAKICAg ICAvLyBEbyBub3QgZGVsZXRlIHRoZSBvYmplY3QgaWYgaXQncyBzdGlsbCBzYXZpbmcgdGhlIHBh c3N3b3JkLAogICAgIC8vIHRoZSBzYXZlIHBhc3N3b3JkIGNhbGxiYWNrIHdpbGwgZGVsZXRlIGl0 LgpAQCAtMjQ5LDcgKzIyMiw2IEBAIHZvaWQgR3RrQXV0aGVudGljYXRpb25EaWFsb2c6OmRlc3Ry b3koKQogICAgICAgICBkZWxldGUgdGhpczsKIH0KIAotI2lmZGVmIFNPVVBfVFlQRV9QQVNTV09S RF9NQU5BR0VSCiB2b2lkIEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9nOjpzYXZlUGFzc3dvcmRDYWxs YmFjayhTb3VwTWVzc2FnZSogbWVzc2FnZSwgR3RrQXV0aGVudGljYXRpb25EaWFsb2cqIGRpYWxv ZykKIHsKICAgICBkaWFsb2ctPnNhdmVQYXNzd29yZCgpOwpAQCAtMjYxLDggKzIzMywxNSBAQCB2 b2lkIEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9nOjpzYXZlUGFzc3dvcmQoKQogICAgIEFTU0VSVCgh bV9wYXNzd29yZC5pc051bGwoKSk7CiAKICAgICAvLyBBbnl0aGluZyBidXQgNDAxIGFuZCA1eHgg bWVhbnMgdGhlIHBhc3N3b3JkIHdhcyBhY2NlcHRlZC4KLSAgICBpZiAobV9tZXNzYWdlLmdldCgp LT5zdGF0dXNfY29kZSAhPSA0MDEgJiYgbV9tZXNzYWdlLmdldCgpLT5zdGF0dXNfY29kZSA8IDUw MCkKLSAgICAgICAgc291cF9hdXRoX3NhdmVfcGFzc3dvcmQobV9hdXRoLmdldCgpLCBtX3VzZXJu YW1lLmRhdGEoKSwgbV9wYXNzd29yZC5kYXRhKCkpOworICAgIGlmIChtX21lc3NhZ2UuZ2V0KCkt PnN0YXR1c19jb2RlICE9IDQwMSAmJiBtX21lc3NhZ2UuZ2V0KCktPnN0YXR1c19jb2RlIDwgNTAw KSB7CisgICAgICAgIC8vIFRoaXMgaXMganVzdCBhIHRlbXBvcmFyeSBrbHVkZ2UgdW50aWwgR3Rr QXV0aGVudGljYXRpb25EaWFsb2cgd29ya3MgZGlyZWN0bHkgd2l0aCBBdXRoZW50aWNhdGlvbkNo YWxsZW5nZXMuCisgICAgICAgIEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlIGNoYWxsZW5nZSgwIC8q IHNlc3Npb24gKi8sIG1fbWVzc2FnZS5nZXQoKSwgbV9hdXRoLmdldCgpLCBmYWxzZSwgMCk7Cisg ICAgICAgIENyZWRlbnRpYWwgY3JlZGVudGlhbFRvU2F2ZSA9IENyZWRlbnRpYWwoCisgICAgICAg ICAgICBTdHJpbmc6OmZyb21VVEY4KG1fdXNlcm5hbWUuZGF0YSgpKSwKKyAgICAgICAgICAgIFN0 cmluZzo6ZnJvbVVURjgobV9wYXNzd29yZC5kYXRhKCkpLAorICAgICAgICAgICAgQ3JlZGVudGlh bFBlcnNpc3RlbmNlUGVybWFuZW50KTsKKyAgICAgICAgY3JlZGVudGlhbEJhY2tpbmdTdG9yZSgp LnN0b3JlQ3JlZGVudGlhbHNGb3JDaGFsbGVuZ2UoY2hhbGxlbmdlLCBjcmVkZW50aWFsVG9TYXZl KTsKKyAgICB9CiAKICAgICAvLyBEaXNjb25uZWN0IHRoZSBjYWxsYmFjay4gSWYgdGhlIGF1dGhl bnRpY2F0aW9uIHN1Y2NlZWRlZCB3ZSBhcmUgZG9uZSwKICAgICAvLyBhbmQgaWYgaXQgZmFpbGVk IHdlJ2xsIGNyZWF0ZSBhIG5ldyBHdGtBdXRoZW50aWNhdGlvbkRpYWxvZyBhbmQgd2UnbGwKQEAg LTI3Miw3ICsyNTEsNiBAQCB2b2lkIEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9nOjpzYXZlUGFzc3dv cmQoKQogICAgIC8vIERpYWxvZyBoYXMgYmVlbiBhbHJlYWR5IGRlc3Ryb3llZCwgYWZ0ZXIgc2F2 aW5nIHRoZSBwYXNzd29yZCBpdCBzaG91bGQgYmUgZGVsZXRlZC4KICAgICBkZWxldGUgdGhpczsK IH0KLSNlbmRpZgogCiB2b2lkIEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9nOjphdXRoZW50aWNhdGUo KQogewpAQCAtMjgwLDE0ICsyNTgsMTIgQEAgdm9pZCBHdGtBdXRoZW50aWNhdGlvbkRpYWxvZzo6 YXV0aGVudGljYXRlKCkKICAgICBjb25zdCBjaGFyICpwYXNzd29yZCA9IGd0a19lbnRyeV9nZXRf dGV4dChHVEtfRU5UUlkobV9wYXNzd29yZEVudHJ5KSk7CiAgICAgc291cF9hdXRoX2F1dGhlbnRp Y2F0ZShtX2F1dGguZ2V0KCksIHVzZXJuYW1lLCBwYXNzd29yZCk7CiAKLSNpZmRlZiBTT1VQX1RZ UEVfUEFTU1dPUkRfTUFOQUdFUgogICAgIGlmIChtX3JlbWVtYmVyQ2hlY2tCdXR0b24gJiYgZ3Rr X3RvZ2dsZV9idXR0b25fZ2V0X2FjdGl2ZShHVEtfVE9HR0xFX0JVVFRPTihtX3JlbWVtYmVyQ2hl Y2tCdXR0b24pKSkgewogICAgICAgICBtX3VzZXJuYW1lID0gdXNlcm5hbWU7CiAgICAgICAgIG1f cGFzc3dvcmQgPSBwYXNzd29yZDsKICAgICAgICAgbV9pc1NhdmluZ1Bhc3N3b3JkID0gdHJ1ZTsK ICAgICAgICAgbV9zYXZlUGFzc3dvcmRIYW5kbGVyID0gZ19zaWduYWxfY29ubmVjdChtX21lc3Nh Z2UuZ2V0KCksICJnb3QtaGVhZGVycyIsIEdfQ0FMTEJBQ0soc2F2ZVBhc3N3b3JkQ2FsbGJhY2sp LCB0aGlzKTsKICAgICB9Ci0jZW5kaWYKIH0KIAogdm9pZCBHdGtBdXRoZW50aWNhdGlvbkRpYWxv Zzo6YXV0aGVudGljYXRpb25EaWFsb2dSZXNwb25zZUNhbGxiYWNrKEd0a1dpZGdldCosIGdpbnQg cmVzcG9uc2VJRCwgR3RrQXV0aGVudGljYXRpb25EaWFsb2cqIGRpYWxvZykKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9HdGtBdXRoZW50aWNhdGlvbkRpYWxvZy5oIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0d0a0F1dGhlbnRpY2F0aW9uRGlhbG9nLmgKaW5k ZXggNzU4MjQxY2QzMzZkODMzNjU0NTk1NTBhMzhmMGUxNmQ0OTY4YjQyNS4uOTEyZjc1ZDc2OTE2 ODc1ZWJlZTU5NDljN2QxOGVkYzhkMGU5N2Q1OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0d0a0F1dGhlbnRpY2F0aW9uRGlhbG9nLmgKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3RrL0d0a0F1dGhlbnRpY2F0aW9uRGlhbG9nLmgKQEAgLTIwLDggKzIwLDYg QEAKICNpZm5kZWYgR3RrQXV0aGVudGljYXRpb25EaWFsb2dfaAogI2RlZmluZSBHdGtBdXRoZW50 aWNhdGlvbkRpYWxvZ19oCiAKLSNkZWZpbmUgTElCU09VUF9JX0hBVkVfUkVBRF9CVUdfNTk0Mzc3 X0FORF9LTk9XX1NPVVBfUEFTU1dPUkRfTUFOQUdFUl9NSUdIVF9HT19BV0FZCi0KICNpbmNsdWRl IDx3dGYvZ29iamVjdC9HT3duUHRyLmg+CiAjaW5jbHVkZSAiR1JlZlB0ckd0ay5oIgogI2luY2x1 ZGUgPGxpYnNvdXAvc291cC5oPgpAQCAtNDQsMTIgKzQyLDggQEAgcHVibGljOgogcHJpdmF0ZToK ICAgICB2b2lkIGRlc3Ryb3koKTsKICAgICB2b2lkIGF1dGhlbnRpY2F0ZSgpOwotCi0jaWZkZWYg U09VUF9UWVBFX1BBU1NXT1JEX01BTkFHRVIKICAgICB2b2lkIHNhdmVQYXNzd29yZCgpOwogICAg IHN0YXRpYyB2b2lkIHNhdmVQYXNzd29yZENhbGxiYWNrKFNvdXBNZXNzYWdlKiwgR3RrQXV0aGVu dGljYXRpb25EaWFsb2cqKTsKLSNlbmRpZgotCiAgICAgc3RhdGljIHZvaWQgYXV0aGVudGljYXRp b25EaWFsb2dSZXNwb25zZUNhbGxiYWNrKEd0a1dpZGdldCosIGdpbnQgcmVzcG9uc2VJRCwgR3Rr QXV0aGVudGljYXRpb25EaWFsb2cqKTsKIAogICAgIEd0a1dpZGdldCogbV9kaWFsb2c7CkBAIC02 MSwxMiArNTUsMTAgQEAgcHJpdmF0ZToKICAgICBHdGtXaWRnZXQqIG1fcGFzc3dvcmRFbnRyeTsK ICAgICBHdGtXaWRnZXQqIG1fcmVtZW1iZXJDaGVja0J1dHRvbjsKIAotI2lmZGVmIFNPVVBfVFlQ RV9QQVNTV09SRF9NQU5BR0VSCiAgICAgYm9vbCBtX2lzU2F2aW5nUGFzc3dvcmQ7CiAgICAgdW5z aWduZWQgbG9uZyBtX3NhdmVQYXNzd29yZEhhbmRsZXI7CiAgICAgQ1N0cmluZyBtX3VzZXJuYW1l OwogICAgIENTdHJpbmcgbV9wYXNzd29yZDsKLSNlbmRpZgogfTsKIAogfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9ndGsv Q3JlZGVudGlhbEJhY2tpbmdTdG9yZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3 b3JrL2d0ay9DcmVkZW50aWFsQmFja2luZ1N0b3JlLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44YTAzYTJiYjZi ZTNmMWU0YmEzZWVjZmQyMjk0YzEzNDUxNjIyYzk2Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9ndGsvQ3JlZGVudGlhbEJhY2tpbmdTdG9yZS5jcHAK QEAgLTAsMCArMSwxMTcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgSWdhbGlhIFMuTC4K KyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCBy ZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9j dW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3Ry aWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIElHQUxJQSBTLkwu IGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5D TFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9G IE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NF IEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgQ09NUFVURVIsIElOQy4g T1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFH RVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VC U1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9G SVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkg VEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFS SVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZF TiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisj aW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQ3JlZGVudGlhbEJhY2tpbmdTdG9yZS5oIgor CisjZGVmaW5lIFNFQ1JFVF9XSVRIX1VOU1RBQkxFIDEKKyNkZWZpbmUgU0VDUkVUX0FQSV9TVUJK RUNUX1RPX0NIQU5HRSAxCisjaW5jbHVkZSAiQXV0aGVudGljYXRpb25DaGFsbGVuZ2UuaCIKKyNp bmNsdWRlICJHUmVmUHRyR3RrLmgiCisjaW5jbHVkZSA8Z2xpYi9naTE4bi1saWIuaD4KKyNpbmNs dWRlIDxsaWJzZWNyZXQvc2VjcmV0Lmg+CisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+CisjaW5j bHVkZSA8d3RmL2dvYmplY3QvR093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcu aD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitDcmVkZW50aWFsQmFja2luZ1N0b3JlJiBjcmVk ZW50aWFsQmFja2luZ1N0b3JlKCkKK3sKKyAgICBERUZJTkVfU1RBVElDX0xPQ0FMKENyZWRlbnRp YWxCYWNraW5nU3RvcmUsIGJhY2tpbmdTdG9yZSwgKCkpOworICAgIHJldHVybiBiYWNraW5nU3Rv cmU7Cit9CisKK0NyZWRlbnRpYWxCYWNraW5nU3RvcmU6OkNyZWRlbnRpYWxCYWNraW5nU3RvcmUo KQoreworfQorCitDcmVkZW50aWFsQmFja2luZ1N0b3JlOjp+Q3JlZGVudGlhbEJhY2tpbmdTdG9y ZSgpCit7Cit9CisKK3N0YXRpYyBHUmVmUHRyPEdIYXNoVGFibGU+IGNyZWF0ZUF0dHJpYnV0ZUhh c2hUYWJsZUZyb21DaGFsbGVuZ2UoY29uc3QgQXV0aGVudGljYXRpb25DaGFsbGVuZ2UmIGNoYWxs ZW5nZSwgY29uc3QgQ3JlZGVudGlhbCYgY3JlZGVudGlhbCA9IENyZWRlbnRpYWwoKSkKK3sKKyAg ICBTb3VwVVJJKiB1cmkgPSBzb3VwX21lc3NhZ2VfZ2V0X3VyaShjaGFsbGVuZ2Uuc291cE1lc3Nh Z2UoKSk7CisgICAgR1JlZlB0cjxHSGFzaFRhYmxlPiBhdHRyaWJ1dGVzID0gYWRvcHRHUmVmKHNl Y3JldF9hdHRyaWJ1dGVzX2J1aWxkKAorICAgICAgICBTRUNSRVRfU0NIRU1BX0NPTVBBVF9ORVRX T1JLLAorICAgICAgICAiZG9tYWluIiwgc291cF9hdXRoX2dldF9yZWFsbShjaGFsbGVuZ2Uuc291 cEF1dGgoKSksCisgICAgICAgICJzZXJ2ZXIiLCB1cmktPmhvc3QsCisgICAgICAgICJwcm90b2Nv bCIsIHVyaS0+c2NoZW1lLAorICAgICAgICAiYXV0aHR5cGUiLCBzb3VwX2F1dGhfZ2V0X3NjaGVt ZV9uYW1lKGNoYWxsZW5nZS5zb3VwQXV0aCgpKSwKKyAgICAgICAgInBvcnQiLCB1cmktPnBvcnQs CisgICAgICAgIE5VTEwpKTsKKyAgICBpZiAoY3JlZGVudGlhbC5pc0VtcHR5KCkpCisgICAgICAg IHJldHVybiBhdHRyaWJ1dGVzOworCisgICAgZ19oYXNoX3RhYmxlX2luc2VydChhdHRyaWJ1dGVz LmdldCgpLCBnX3N0cmR1cCgidXNlciIpLCBnX3N0cmR1cChjcmVkZW50aWFsLnVzZXIoKS51dGY4 KCkuZGF0YSgpKSk7CisgICAgcmV0dXJuIGF0dHJpYnV0ZXM7Cit9CisKK0NyZWRlbnRpYWwgQ3Jl ZGVudGlhbEJhY2tpbmdTdG9yZTo6Z2V0Q3JlZGVudGlhbEZvckNoYWxsZW5nZShjb25zdCBBdXRo ZW50aWNhdGlvbkNoYWxsZW5nZSYgY2hhbGxlbmdlKQoreworICAgIEdPd25QdHI8R0Vycm9yPiBl cnJvcjsKKyAgICBHT3duUHRyPEdMaXN0PiBlbGVtZW50cyhzZWNyZXRfc2VydmljZV9zZWFyY2hf c3luYygKKyAgICAgICAgMCwgLy8gVGhlIGRlZmF1bHQgU2VjcmV0U2VydmljZS4KKyAgICAgICAg U0VDUkVUX1NDSEVNQV9DT01QQVRfTkVUV09SSywKKyAgICAgICAgY3JlYXRlQXR0cmlidXRlSGFz aFRhYmxlRnJvbUNoYWxsZW5nZShjaGFsbGVuZ2UpLmdldCgpLAorICAgICAgICBzdGF0aWNfY2Fz dDxTZWNyZXRTZWFyY2hGbGFncz4oU0VDUkVUX1NFQVJDSF9VTkxPQ0sgfCBTRUNSRVRfU0VBUkNI X0xPQURfU0VDUkVUUyksIC8vIFRoZSBkZWZhdWx0IGJlaGF2aW9yIGlzIHRvIG9ubHkgcmV0dXJu IHRoZSBtb3N0IHJlY2VudCBpdGVtLgorICAgICAgICAwLCAvLyBjYW5jZWxsYWJsZQorICAgICAg ICAmZXJyb3Iub3V0UHRyKCkpKTsKKyAgICBpZiAoZXJyb3IgfHwgIWVsZW1lbnRzIHx8ICFlbGVt ZW50cy0+ZGF0YSkKKyAgICAgICAgcmV0dXJuIENyZWRlbnRpYWwoKTsKKworICAgIEdSZWZQdHI8 U2VjcmV0SXRlbT4gc2VjcmV0SXRlbSA9IGFkb3B0R1JlZihzdGF0aWNfY2FzdDxTZWNyZXRJdGVt Kj4oZWxlbWVudHMtPmRhdGEpKTsKKyAgICBHUmVmUHRyPEdIYXNoVGFibGU+IGF0dHJpYnV0ZXMg PSBhZG9wdEdSZWYoc2VjcmV0X2l0ZW1fZ2V0X2F0dHJpYnV0ZXMoc2VjcmV0SXRlbS5nZXQoKSkp OworICAgIFN0cmluZyB1c2VyID0gU3RyaW5nOjpmcm9tVVRGOChzdGF0aWNfY2FzdDxjb25zdCBj aGFyKj4oZ19oYXNoX3RhYmxlX2xvb2t1cChhdHRyaWJ1dGVzLmdldCgpLCAidXNlciIpKSk7Cisg ICAgaWYgKHVzZXIuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm4gQ3JlZGVudGlhbCgpOworCisg ICAgc2l6ZV90IGxlbmd0aDsKKyAgICBHUmVmUHRyPFNlY3JldFZhbHVlPiBzZWNyZXRWYWx1ZSA9 IGFkb3B0R1JlZihzZWNyZXRfaXRlbV9nZXRfc2VjcmV0KHNlY3JldEl0ZW0uZ2V0KCkpKTsKKyAg ICBjb25zdCBjaGFyKiBwYXNzd29yZERhdGEgPSBzZWNyZXRfdmFsdWVfZ2V0KHNlY3JldFZhbHVl LmdldCgpLCAmbGVuZ3RoKTsKKyAgICBTdHJpbmcgcGFzc3dvcmQgPSBTdHJpbmc6OmZyb21VVEY4 KHBhc3N3b3JkRGF0YSwgbGVuZ3RoKTsKKworICAgIHJldHVybiBDcmVkZW50aWFsKHVzZXIsIHBh c3N3b3JkLCBDcmVkZW50aWFsUGVyc2lzdGVuY2VQZXJtYW5lbnQpOworfQorCit2b2lkIENyZWRl bnRpYWxCYWNraW5nU3RvcmU6OnN0b3JlQ3JlZGVudGlhbHNGb3JDaGFsbGVuZ2UoY29uc3QgQXV0 aGVudGljYXRpb25DaGFsbGVuZ2UmIGNoYWxsZW5nZSwgY29uc3QgQ3JlZGVudGlhbCYgY3JlZGVu dGlhbCkKK3sKKyAgICBDU3RyaW5nIHV0ZjhQYXNzd29yZCA9IGNyZWRlbnRpYWwucGFzc3dvcmQo KS51dGY4KCk7CisgICAgR1JlZlB0cjxTZWNyZXRWYWx1ZT4gbmV3U2VjcmV0VmFsdWUgPSBhZG9w dEdSZWYoc2VjcmV0X3ZhbHVlX25ldyh1dGY4UGFzc3dvcmQuZGF0YSgpLCB1dGY4UGFzc3dvcmQu bGVuZ3RoKCksICJ0ZXh0L3BsYWluIikpOworCisgICAgc2VjcmV0X3NlcnZpY2Vfc3RvcmUoCisg ICAgICAgIDAsIC8vIFRoZSBkZWZhdWx0IFNlY3JldFNlcnZpY2UuCisgICAgICAgIFNFQ1JFVF9T Q0hFTUFfQ09NUEFUX05FVFdPUkssCisgICAgICAgIGNyZWF0ZUF0dHJpYnV0ZUhhc2hUYWJsZUZy b21DaGFsbGVuZ2UoY2hhbGxlbmdlLCBjcmVkZW50aWFsKS5nZXQoKSwKKyAgICAgICAgU0VDUkVU X0NPTExFQ1RJT05fREVGQVVMVCwKKyAgICAgICAgXygiV2ViS2l0R1RLKyBwYXNzd29yZCIpLAor ICAgICAgICBuZXdTZWNyZXRWYWx1ZS5nZXQoKSwKKyAgICAgICAgMCwgLy8gY2FuY2VsbGFibGUK KyAgICAgICAgMCwgLy8gY2FsbGJhY2sKKyAgICAgICAgMCk7IC8vIGRhdGEKK30KKworfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9ndGsvQ3JlZGVudGlhbEJhY2tpbmdTdG9yZS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9ndGsvQ3JlZGVudGlhbEJhY2tpbmdTdG9yZS5oCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjNmODdm ZWVlOWNjYTUxMTVkMGJjYmE1OGE0YzdiMzNhMjQ4YTI1MjgKLS0tIC9kZXYvbnVsbAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2d0ay9DcmVkZW50aWFsQmFja2luZ1N0b3Jl LmgKQEAgLTAsMCArMSw1MSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMiBJZ2FsaWEgUy5M LgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3Zp ZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVk aXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0 IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBk b2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlz dHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgSUdBTElBIFMu TC4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBDT01QVVRFUiwgSU5D LiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1Qs IElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFN QUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBT VUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBS T0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFO WSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJ QUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkg QVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBF VkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisK KyNpZm5kZWYgQ3JlZGVudGlhbEJhY2tpbmdTdG9yZV9oCisjZGVmaW5lIENyZWRlbnRpYWxCYWNr aW5nU3RvcmVfaAorCisjaW5jbHVkZSAiQ3JlZGVudGlhbC5oIgorCituYW1lc3BhY2UgV2ViQ29y ZSB7CisKK2NsYXNzIEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlOworCitjbGFzcyBDcmVkZW50aWFs QmFja2luZ1N0b3JlIHsKK3B1YmxpYzoKKyAgICBmcmllbmQgQ3JlZGVudGlhbEJhY2tpbmdTdG9y ZSYgY3JlZGVudGlhbEJhY2tpbmdTdG9yZSgpOworICAgIH5DcmVkZW50aWFsQmFja2luZ1N0b3Jl KCk7CisKKyAgICBDcmVkZW50aWFsIGdldENyZWRlbnRpYWxGb3JDaGFsbGVuZ2UoY29uc3QgQXV0 aGVudGljYXRpb25DaGFsbGVuZ2UmKTsKKyAgICB2b2lkIHN0b3JlQ3JlZGVudGlhbHNGb3JDaGFs bGVuZ2UoY29uc3QgQXV0aGVudGljYXRpb25DaGFsbGVuZ2UmLCBjb25zdCBDcmVkZW50aWFsJik7 CisKK3ByaXZhdGU6CisgICAgQ3JlZGVudGlhbEJhY2tpbmdTdG9yZSgpOworfTsKKworQ3JlZGVu dGlhbEJhY2tpbmdTdG9yZSYgY3JlZGVudGlhbEJhY2tpbmdTdG9yZSgpOworCit9IC8vIG5hbWVz cGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBDcmVkZW50aWFsQmFja2luZ1N0b3JlX2gKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvZ3RrL0dOVW1ha2VmaWxlLmFtIGIvU291cmNlL1dlYktpdC9n dGsvR05VbWFrZWZpbGUuYW0KaW5kZXggNWJlOWViNTQ4ZWUwMjNkMTQwYTM1ZDE2NjI0MzNkNTgx YmI3MWI4My4uYzEzNmNiYzlkZmFjODk2YmIzZGNhYWY4NWJhZjFhMWY1Y2U3MzU4ZiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9ndGsvR05VbWFrZWZpbGUuYW0KKysrIGIvU291cmNlL1dlYktp dC9ndGsvR05VbWFrZWZpbGUuYW0KQEAgLTk1LDYgKzk1LDcgQEAgbGlid2Via2l0Z3RrX0BXRUJL SVRHVEtfQVBJX01BSk9SX1ZFUlNJT05AX0BXRUJLSVRHVEtfQVBJX01JTk9SX1ZFUlNJT05AX2xh X0xJQkEKIAkkKEdTVFJFQU1FUl9MSUJTKSBcCiAJJChHVEtfTElCUykgXAogCSQoSlBFR19MSUJT KSBcCisJJChMSUJTRUNSRVRfTElCUykgXAogCSQoTElCU09VUF9MSUJTKSBcCiAJJChMSUJYTUxf TElCUykgXAogCSQoTElCWFNMVF9MSUJTKSBcCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9H TlVtYWtlZmlsZS5hbSBiL1NvdXJjZS9XZWJLaXQyL0dOVW1ha2VmaWxlLmFtCmluZGV4IGY5NTZk MGVkZGZjMDkzOTc5YzViYzAyNjAzY2U1MTRjMjU3ODE4NmIuLmEyNTJjZDFkODRmMzA4YjUwOTQ3 MjY5MWRjMDljYTk3YmQ5ZTlmMTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL0dOVW1ha2Vm aWxlLmFtCisrKyBiL1NvdXJjZS9XZWJLaXQyL0dOVW1ha2VmaWxlLmFtCkBAIC0xNzUsNiArMTc1 LDcgQEAgbGlid2Via2l0Mmd0a19AV0VCS0lUR1RLX0FQSV9NQUpPUl9WRVJTSU9OQF9AV0VCS0lU R1RLX0FQSV9NSU5PUl9WRVJTSU9OQF9sYV9MSUIKIAkkKEdUS19MSUJTKSBcCiAJJChHVEtfVU5J WF9QUklOVElOR19MSUJTKSBcCiAJJChKUEVHX0xJQlMpIFwKKwkkKExJQlNFQ1JFVF9MSUJTKSBc CiAJJChMSUJTT1VQX0xJQlMpIFwKIAkkKExJQlhNTF9MSUJTKSBcCiAJJChMSUJYU0xUX0xJQlMp IFwKQEAgLTQwOSw2ICs0MTAsNyBAQCBsaWJXZWJDb3JlR3RrMl9sYV9DUFBGTEFHUyA9IFwKIAkk KEdMSUJfQ0ZMQUdTKSBcCiAJJChHU1RSRUFNRVJfQ0ZMQUdTKSBcCiAJJChHVEsyX0NGTEFHUykg XAorCSQoTElCU0VDUkVUX0NGTEFHUykgXAogCSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKExJQlhN TF9DRkxBR1MpIFwKIAkkKExJQlhTTFRfQ0ZMQUdTKSBcCmRpZmYgLS1naXQgYS9DaGFuZ2VMb2cg Yi9DaGFuZ2VMb2cKaW5kZXggN2U0NDA0MjVkYThiMGFmMWZiNzZlMWM3NDU0NTc1Mjg3MmJiNmM3 MC4uMmNlN2ZhMmY1Y2IwYjM4NjFhZmRlZDMwN2I1OGMyYjdhNjIyYjdlNCAxMDA2NDQKLS0tIGEv Q2hhbmdlTG9nCisrKyBiL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEyLTEwLTMwICBN YXJ0aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBS ZW1vdmUgZGVwZW5kZW5jeSBvbiBTb3VwUGFzc3dvcmRNYW5hZ2VyCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDA3NzUKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgYSBsaWJzZWNyZXQgZGVwZW5kZW5j eSB0byB0aGUgYnVpbGQuIFRoaXMgaXMgbmVjZXNzYXJ5IHNvIHRoYXQgd2UgY2FuIHJlbW92ZQor ICAgICAgICBhIGRlcGVuZGVuY3kgb24gU291cFBhc3N3b3JkTWFuYWdlci4KKworICAgICAgICAq IGNvbmZpZ3VyZS5hYzogTG9vayBmb3IgbGlic2VjcmV0IHVzaW5nIHRoZSBwa2ctY29uZmlnIGNv bmZpZ3VyYXRpb24gbWFjcm8uCisKIDIwMTItMTAtMjYgIFJvYiBCdWlzICA8cmJ1aXNAcmltLmNv bT4KIAogICAgICAgICBbQmxhY2tCZXJyeV0gUGxhdGZvcm0gQWJzdHJhY3Rpb24gZm9yIFdlYktp dCBSZXNvdXJjZS9JbWFnZSBMb2FkaW5nCmRpZmYgLS1naXQgYS9jb25maWd1cmUuYWMgYi9jb25m aWd1cmUuYWMKaW5kZXggOGI5Y2VhMDMxOWEzZDc5NmM3NmM1NjQxNmZmNTQ2NTVmNjY4MWQzOC4u MmRhYTZkYmNlM2FjOWUwZmY4ZGFjMjcxOTI2MzRjYWFmYjE5YTIzMCAxMDA2NDQKLS0tIGEvY29u ZmlndXJlLmFjCisrKyBiL2NvbmZpZ3VyZS5hYwpAQCAtOTUzLDYgKzk1MywxMCBAQCBQS0dfQ0hF Q0tfTU9EVUxFUyhbTElCU09VUF0sCiBBQ19TVUJTVChbTElCU09VUF9DRkxBR1NdKQogQUNfU1VC U1QoW0xJQlNPVVBfTElCU10pCiAKK1BLR19DSEVDS19NT0RVTEVTKFtMSUJTRUNSRVRdLCBbbGli c2VjcmV0LTFdKQorQUNfU1VCU1QoW0xJQlNFQ1JFVF9DRkxBR1NdKQorQUNfU1VCU1QoW0xJQlNF Q1JFVF9MSUJTXSkKKwogIyBjaGVjayBpZiBGcmVlVHlwZS9Gb250Q29uZmlnIGFyZSBhdmFpbGFi bGUKIGlmIHRlc3QgIiR3aXRoX2ZvbnRfYmFja2VuZCIgPSAiZnJlZXR5cGUiOyB0aGVuCiAgICBp ZiB0ZXN0ICIkd2l0aF90YXJnZXQiID0gImRpcmVjdGZiIjsgdGhlbgo= 171868 2012-11-01 09:10:11 -0700 2012-11-02 11:06:05 -0700 Patch to commit bug-100775-20121101090832.patch text/plain 24858 mrobinson U3VidmVyc2lvbiBSZXZpc2lvbjogMTMyODQ3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTBmY2JhMTdhMjA3NDY1 N2VhMjg1Y2MxY2E3ZmNjYTU5N2E2YTI5Yi4uMDM4OTEyOTgxNzdmZmM3Y2VjNWQ3NDBiYWE5ZTky MTFhNDczOWMzNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDEyLTEwLTMwICBNYXJ0 aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBSZW1v dmUgZGVwZW5kZW5jeSBvbiBTb3VwUGFzc3dvcmRNYW5hZ2VyCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDA3NzUKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZW1lbWJlciBwYXNzd29yZHMgdXNpbmcgbGli c2VjcmV0IGluc3RlYWQgb2YgU291cFBhc3N3b3JkTWFuYWdlci4gV2UgYWNjb21wbGlzaCB0aGlz IHVzaW5nCisgICAgICAgIGEgbmV3IGNsYXNzLCBDcmVkZW50aWFsQmFja2luZ1N0b3JlLiBDcmVk ZW50aWFsQmFja2luZ1N0b3JlIHdpbGwgc29vbiBiZSB0aGUgdGhpbmcgdGhhdCBiYWNrcworICAg ICAgICBDcmVkZW50aWFsU3RvcmVHdGsuIFRoZSBuYW1lIGlzIGJhc2VkIG9uIHRoZSBuYW1lIG9m IGEgc2ltaWxhciBjbGFzcyBmcm9tIHRoZSBCbGFja0JlcnJ5IHBvcnQuCisKKyAgICAgICAgTm8g bmV3IHRlc3RzLiBUaGlzIGRvZXMgbm90IGNoYW5nZSBiZWhhdmlvci4KKworICAgICAgICAqIEdO VW1ha2VmaWxlLmFtOiBBZGQgbGlic2VjcmV0IGZsYWdzIHRvIHRoZSBidWlsZCBhbmQgdGhlIG5l dyBkaXJlY3RvcnkgdG8gdGhlIGluY2x1ZGUgbGlzdC4KKyAgICAgICAgKiBHTlVtYWtlZmlsZS5s aXN0LmFtOiBBZGQgbmV3IGZpbGVzIHRvIHRoZSBzb3VyY2UgbGlzdC4KKyAgICAgICAgKiBwbGF0 Zm9ybS9ndGsvR1JlZlB0ckd0ay5jcHA6IEFkZCBzdXBwb3J0IGZvciBTZWNyZXRWYWx1ZSB0byBH UmVmUHRyR3RrLgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9HdGtBdXRoZW50aWNhdGlvbkRpYWxv Zy5jcHA6IFJlcGxhY2UgaW50ZXJhY3Rpb24gd2l0aCBTb3VwUGFzc3dvcmRNYW5nZXIgd2l0aAor ICAgICAgICBpbnRlcmFjdGlvbiB3aXRoIHRoZSBDcmVkZW50aWFsQmFja2luZ1N0b3JlLiBSZW1v dmUgYWxsIGNvbmRpdGlvbmFsIFNvdXBQYXNzd29yZE1hbmFnZXIgZ3VhcmRzLgorICAgICAgICAq IHBsYXRmb3JtL2d0ay9HdGtBdXRoZW50aWNhdGlvbkRpYWxvZy5oOiBEaXR0by4KKyAgICAgICAg KiBwbGF0Zm9ybS9uZXR3b3JrL2d0ay9DcmVkZW50aWFsQmFja2luZ1N0b3JlLmNwcDogQWRkZWQu CisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9ndGsvQ3JlZGVudGlhbEJhY2tpbmdTdG9yZS5o OiBBZGRlZC4KKwogMjAxMi0xMC0yOSAgUGhpbGlwIFJvZ2VycyAgPHBkckBnb29nbGUuY29tPgog CiAgICAgICAgIExldCBTVkdFbGVtZW50cyBoYXZlIHBlbmRpbmcgcmVzb3VyY2VzLgpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9ndGsvQ2hh bmdlTG9nCmluZGV4IDkwYWViNGYzM2RkYzc1NGJmNWYzNmZjMjk1MTI5ZjQ5NmJhMzQ5M2EuLjdi ZDhlZTY5OTgxYjAzN2U5OTA1ZDM3YzZiOTU2YTc1NWFiNDlkNjEgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L2d0ay9DaGFuZ2VMb2cK QEAgLTEsMyArMSwxNSBAQAorMjAxMi0xMC0zMCAgTWFydGluIFJvYmluc29uICA8bXJvYmluc29u QGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10gUmVtb3ZlIGRlcGVuZGVuY3kgb24gU291cFBh c3N3b3JkTWFuYWdlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MTAwNzc1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgQWRkIGEgbGlic2VjcmV0IGRlcGVuZGVuY3kgdG8gdGhlIGJ1aWxkLiBUaGlzIGlzIG5l Y2Vzc2FyeSBzbyB0aGF0IHdlIGNhbiByZW1vdmUKKyAgICAgICAgYSBkZXBlbmRlbmN5IG9uIFNv dXBQYXNzd29yZE1hbmFnZXIuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5hbTogVXNlIGxpYnNl Y3JldCBsaWJzIGR1cmluZyBXZWJLaXQxIGxpYnJhcnkgY29tcGlsYXRpb24uCisKIDIwMTItMTAt MjQgIEJyYWR5IEVpZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgogCiAgICAgICAgIEFkZCBhIHN0 cmF0ZWd5IGZvciBsb2FkZXIgY3VzdG9taXphdGlvbi4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwppbmRleCA1MjBhMGUyNzMz NDZhYzdhMmZiMjY2MGFlYmZjOTExYThlMjI2Y2I0Li45OGJiMDZkZjA0NmViODg4OTg0OGJmMWRj N2EwZjNkNjc3OWU5NWEzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKKysr IGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTItMTAtMzAg IE1hcnRpbiBSb2JpbnNvbiAgPG1yb2JpbnNvbkBpZ2FsaWEuY29tPgorCisgICAgICAgIFtHVEtd IFJlbW92ZSBkZXBlbmRlbmN5IG9uIFNvdXBQYXNzd29yZE1hbmFnZXIKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwMDc3NQorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBhIGxpYnNlY3JldCBkZXBlbmRl bmN5IHRvIHRoZSBidWlsZC4gVGhpcyBpcyBuZWNlc3Nhcnkgc28gdGhhdCB3ZSBjYW4gcmVtb3Zl CisgICAgICAgIGEgZGVwZW5kZW5jeSBvbiBTb3VwUGFzc3dvcmRNYW5hZ2VyLgorCisgICAgICAg ICogR05VbWFrZWZpbGUuYW06IEFkZCBsaWJzZWNyZXQgQ0ZMQUdTIHRvIHRoZSBXZWJLaXQyIGJ1 aWxkLgorCiAyMDEyLTEwLTI5ICBNaWNoYWVsIFNhYm9mZiAgPG1zYWJvZmZAYXBwbGUuY29tPgog CiAgICAgICAgIGJ1aWxkSFRUUEhlYWRlcnMoKSBzaG91bGQgdXNlIGEgU3RyaW5nQnVpbGRlci5h cHBlbmRMaXRlcmFsKCkgZm9yIHNlcGFyYXRvcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv R05VbWFrZWZpbGUuYW0gYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCAzNjE2 YTM4MGE2Y2JkMjk4ODQzMjI2MzAyOTNmMTJmZWU3Y2YwZTE4Li5lNjZiZjA1NDdjYjgwODg1ZWI3 NDYyMDFiMGNlZDlmYjQ3MzdhZTExIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtl ZmlsZS5hbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQpAQCAtNzMsNiArNzMs NyBAQCB3ZWJjb3JlX2NwcGZsYWdzICs9IFwKIAktSSQoc3JjZGlyKS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9tZWRpYXN0cmVhbS9nc3RyZWFtZXIgXAogCS1JJChzcmNkaXIpL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL21vY2sgXAogCS1JJChzcmNkaXIpL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsgXAorCS1JJChzcmNkaXIpL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv Z3RrIFwKIAktSSQoc3JjZGlyKS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9zcWwgXAogCS1JJChz cmNkaXIpL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQgXAogCS1JJChzcmNkaXIpL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvdHJhbnNjb2RlciBcCkBAIC02NDEsNiArNjQyLDcgQEAg bGliV2ViQ29yZV9sYV9DUFBGTEFHUyA9IFwKIAkkKEdFT0NMVUVfQ0ZMQUdTKSBcCiAJJChHTElC X0NGTEFHUykgXAogCSQoR1NUUkVBTUVSX0NGTEFHUykgXAorCSQoTElCU0VDUkVUX0NGTEFHUykg XAogCSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKExJQlhNTF9DRkxBR1MpIFwKIAkkKExJQlhTTFRf Q0ZMQUdTKSBcCkBAIC03MDQsNiArNzA2LDcgQEAgbGliV2ViQ29yZUd0a19sYV9DUFBGTEFHUyA9 IFwKIAkkKEdTVFJFQU1FUl9DRkxBR1MpIFwKIAkkKEdUS19DRkxBR1MpIFwKIAkkKEhJTERPTl9D RkxBR1MpIFwKKwkkKExJQlNFQ1JFVF9DRkxBR1MpIFwKIAkkKExJQlNPVVBfQ0ZMQUdTKSBcCiAJ JChMSUJYTUxfQ0ZMQUdTKSBcCiAJJChMSUJYU0xUX0NGTEFHUykgXApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbSBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2Vm aWxlLmxpc3QuYW0KaW5kZXggYjBiZGQyZWJhYjczYmE5ZmIyNjEyOTM1MTkyY2IzZjU0OTIzNzAz Yi4uNDAzYzczNGE4ZWQxYWFlNmNjMDY1Y2QxNTQ2NTY1Y2E1ZDM1MGYxOCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9H TlVtYWtlZmlsZS5saXN0LmFtCkBAIC00NzM2LDYgKzQ3MzYsOCBAQCB3ZWJjb3JlX3NvdXJjZXMg Kz0gXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvU29ja2V0U3RyZWFtSGFuZGxl QmFzZS5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvU29ja2V0U3RyZWFt SGFuZGxlQmFzZS5oIFwKIAlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1NvY2tldFN0 cmVhbUhhbmRsZUNsaWVudC5oIFwKKwlTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2d0 ay9DcmVkZW50aWFsQmFja2luZ1N0b3JlLmNwcCBcCisJU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v bmV0d29yay9ndGsvQ3JlZGVudGlhbEJhY2tpbmdTdG9yZS5oIFwKIAlTb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9uZXR3b3JrL3NvdXAvQXV0aGVudGljYXRpb25DaGFsbGVuZ2UuaCBcCiAJU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlU291 cC5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJT b3VwLmNwcCBcCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvR1JlZlB0 ckd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvR1JlZlB0ckd0ay5jcHAKaW5k ZXggOWE5ZDY3OTVmODNhYWE1OWZmNTJjOTVmNDg5YmRkMmY1MmNlYzJhNC4uZmE1MDZkZjkwMDdk MjRjYzA3Njc3NjhkZWZkMTA1NjYyZmMzOWIzZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0dSZWZQdHJHdGsuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9HUmVmUHRyR3RrLmNwcApAQCAtMjAsOCArMjAsMTIgQEAKICNpbmNsdWRlICJjb25maWcu aCIKICNpbmNsdWRlICJHUmVmUHRyR3RrLmgiCiAKKyNkZWZpbmUgU0VDUkVUX1dJVEhfVU5TVEFC TEUgMQorI2RlZmluZSBTRUNSRVRfQVBJX1NVQkpFQ1RfVE9fQ0hBTkdFIDEKKwogI2luY2x1ZGUg PGdsaWIuaD4KICNpbmNsdWRlIDxndGsvZ3RrLmg+CisjaW5jbHVkZSA8bGlic2VjcmV0L3NlY3Jl dC5oPgogCiBuYW1lc3BhY2UgV1RGIHsKIApAQCAtMzgsNiArNDIsMTkgQEAgdGVtcGxhdGUgPD4g dm9pZCBkZXJlZkdQdHIoR3RrVGFyZ2V0TGlzdCogcHRyKQogICAgICAgICBndGtfdGFyZ2V0X2xp c3RfdW5yZWYocHRyKTsKIH0KIAordGVtcGxhdGUgPD4gU2VjcmV0VmFsdWUqIHJlZkdQdHIoU2Vj cmV0VmFsdWUqIHB0cikKK3sKKyAgICBpZiAocHRyKQorICAgICAgICBzZWNyZXRfdmFsdWVfcmVm KHB0cik7CisgICAgcmV0dXJuIHB0cjsKK30KKwordGVtcGxhdGUgPD4gdm9pZCBkZXJlZkdQdHIo U2VjcmV0VmFsdWUqIHB0cikKK3sKKyAgICBpZiAocHRyKQorICAgICAgICBzZWNyZXRfdmFsdWVf dW5yZWYocHRyKTsKK30KKwogI2lmZGVmIEdUS19BUElfVkVSU0lPTl8yCiB0ZW1wbGF0ZSA8PiBH ZGtDdXJzb3IqIHJlZkdQdHIoR2RrQ3Vyc29yKiBwdHIpCiB7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ndGsvR1JlZlB0ckd0ay5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3RrL0dSZWZQdHJHdGsuaAppbmRleCBhOWY0OTFmMTQ3MGU0MjE4OTEyN2ZmNGY4NjVhMzMx NjRhMTdhN2Y2Li45MTkyODY0YTkyMjlkYWI4ODNiZWZhNTYyYjIzNWFkOGFjMzk2ZGM5IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvR1JlZlB0ckd0ay5oCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9HUmVmUHRyR3RrLmgKQEAgLTIzLDExICsyMywxNiBA QAogCiAjaW5jbHVkZSA8d3RmL2dvYmplY3QvR1JlZlB0ci5oPgogCit0eXBlZGVmIHN0cnVjdCBf U2VjcmV0VmFsdWUgU2VjcmV0VmFsdWU7CisKIG5hbWVzcGFjZSBXVEYgewogCiB0ZW1wbGF0ZSA8 PiBHdGtUYXJnZXRMaXN0KiByZWZHUHRyKEd0a1RhcmdldExpc3QqIHB0cik7CiB0ZW1wbGF0ZSA8 PiB2b2lkIGRlcmVmR1B0cihHdGtUYXJnZXRMaXN0KiBwdHIpOwogCit0ZW1wbGF0ZSA8PiBTZWNy ZXRWYWx1ZSogcmVmR1B0cihTZWNyZXRWYWx1ZSogcHRyKTsKK3RlbXBsYXRlIDw+IHZvaWQgZGVy ZWZHUHRyKFNlY3JldFZhbHVlKiBwdHIpOworCiAjaWZkZWYgR1RLX0FQSV9WRVJTSU9OXzIKIHRl bXBsYXRlIDw+IEdka0N1cnNvciogcmVmR1B0cihHZGtDdXJzb3IqIHB0cik7CiB0ZW1wbGF0ZSA8 PiB2b2lkIGRlcmVmR1B0cihHZGtDdXJzb3IqIHB0cik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvR3RrQXV0aGVudGljYXRpb25EaWFsb2cuY3BwIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL0d0a0F1dGhlbnRpY2F0aW9uRGlhbG9nLmNwcAppbmRleCAzNmJk MzFiMWVhNTEzZjUyNTYyOWQ4ZDkwMmJjZGMwZTU5YWZhODVmLi44ZmRiMGNmNzI3ZWExYTYwZmZk ZjdhZmE5Njk3YWUzMzMyNDFjMzgwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ndGsvR3RrQXV0aGVudGljYXRpb25EaWFsb2cuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9HdGtBdXRoZW50aWNhdGlvbkRpYWxvZy5jcHAKQEAgLTIwLDYgKzIwLDggQEAK ICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJHdGtBdXRoZW50aWNhdGlvbkRpYWxvZy5o IgogCisjaW5jbHVkZSAiQXV0aGVudGljYXRpb25DaGFsbGVuZ2UuaCIKKyNpbmNsdWRlICJDcmVk ZW50aWFsQmFja2luZ1N0b3JlLmgiCiAjaW5jbHVkZSAiR3RrVmVyc2lvbmluZy5oIgogI2luY2x1 ZGUgPGdsaWIvZ2kxOG4tbGliLmg+CiAjaW5jbHVkZSA8Z3RrL2d0ay5oPgpAQCAtNTQsMTUgKzU2 LDYgQEAgc3RhdGljIEd0a1dpZGdldCogYWRkRW50cnlUb0dyaWQoR3RrR3JpZCogZ3JpZCwgaW50 IHJvdywgY29uc3QgY2hhciogbGFiZWxUZXh0KQogICAgIHJldHVybiBlbnRyeTsKIH0KIAotc3Rh dGljIGJvb2wgc2Vzc2lvbkNhblNhdmVQYXNzd29yZHMoU291cFNlc3Npb24qIHNlc3Npb24pCi17 Ci0jaWZkZWYgU09VUF9UWVBFX1BBU1NXT1JEX01BTkFHRVIKLSAgICByZXR1cm4gc291cF9zZXNz aW9uX2dldF9mZWF0dXJlKHNlc3Npb24sIFNPVVBfVFlQRV9QQVNTV09SRF9NQU5BR0VSKTsKLSNl bHNlCi0gICAgcmV0dXJuIGZhbHNlOwotI2VuZGlmCi19Ci0KIEd0a0F1dGhlbnRpY2F0aW9uRGlh bG9nOjp+R3RrQXV0aGVudGljYXRpb25EaWFsb2coKQogewogfQpAQCAtNzUsMTAgKzY4LDggQEAg R3RrQXV0aGVudGljYXRpb25EaWFsb2c6Okd0a0F1dGhlbnRpY2F0aW9uRGlhbG9nKEd0a1dpbmRv dyogcGFyZW50V2luZG93LCBTb3VwU2UKICAgICAsIG1fbG9naW5FbnRyeSgwKQogICAgICwgbV9w YXNzd29yZEVudHJ5KDApCiAgICAgLCBtX3JlbWVtYmVyQ2hlY2tCdXR0b24oMCkKLSNpZmRlZiBT T1VQX1RZUEVfUEFTU1dPUkRfTUFOQUdFUgogICAgICwgbV9pc1NhdmluZ1Bhc3N3b3JkKGZhbHNl KQogICAgICwgbV9zYXZlUGFzc3dvcmRIYW5kbGVyKDApCi0jZW5kaWYKIHsKICAgICBHdGtEaWFs b2cqIGRpYWxvZyA9IEdUS19ESUFMT0cobV9kaWFsb2cpOwogICAgIGd0a19kaWFsb2dfYWRkX2J1 dHRvbnMoZGlhbG9nLCBHVEtfU1RPQ0tfQ0FOQ0VMLCBHVEtfUkVTUE9OU0VfQ0FOQ0VMLCBHVEtf U1RPQ0tfT0ssIEdUS19SRVNQT05TRV9PSywgTlVMTCk7CkBAIC0xODcsNDcgKzE3OCwzMiBAQCBH dGtBdXRoZW50aWNhdGlvbkRpYWxvZzo6R3RrQXV0aGVudGljYXRpb25EaWFsb2coR3RrV2luZG93 KiBwYXJlbnRXaW5kb3csIFNvdXBTZQogCiAgICAgZ3RrX2VudHJ5X3NldF92aXNpYmlsaXR5KEdU S19FTlRSWShtX3Bhc3N3b3JkRW50cnkpLCBGQUxTRSk7CiAKLSAgICBpZiAoc2Vzc2lvbkNhblNh dmVQYXNzd29yZHMobV9zZXNzaW9uKSkgewogI2lmZGVmIEdUS19BUElfVkVSU0lPTl8yCi0gICAg ICAgIEd0a1dpZGdldCogcmVtZW1iZXJCb3ggPSBndGtfdmJveF9uZXcoRkFMU0UsIDYpOworICAg IEd0a1dpZGdldCogcmVtZW1iZXJCb3ggPSBndGtfdmJveF9uZXcoRkFMU0UsIDYpOwogI2Vsc2UK LSAgICAgICAgR3RrV2lkZ2V0KiByZW1lbWJlckJveCA9IGd0a19ib3hfbmV3KEdUS19PUklFTlRB VElPTl9WRVJUSUNBTCwgNik7CisgICAgR3RrV2lkZ2V0KiByZW1lbWJlckJveCA9IGd0a19ib3hf bmV3KEdUS19PUklFTlRBVElPTl9WRVJUSUNBTCwgNik7CiAjZW5kaWYKLSAgICAgICAgZ3RrX2Jv eF9wYWNrX3N0YXJ0KEdUS19CT1godkJveCksIHJlbWVtYmVyQm94LCBGQUxTRSwgRkFMU0UsIDAp OworICAgIGd0a19ib3hfcGFja19zdGFydChHVEtfQk9YKHZCb3gpLCByZW1lbWJlckJveCwgRkFM U0UsIEZBTFNFLCAwKTsKIAotICAgICAgICBtX3JlbWVtYmVyQ2hlY2tCdXR0b24gPSBndGtfY2hl Y2tfYnV0dG9uX25ld193aXRoX21uZW1vbmljKF8oIl9SZW1lbWJlciBwYXNzd29yZCIpKTsKLSAg ICAgICAgZ3RrX2xhYmVsX3NldF9saW5lX3dyYXAoR1RLX0xBQkVMKGd0a19iaW5fZ2V0X2NoaWxk KEdUS19CSU4obV9yZW1lbWJlckNoZWNrQnV0dG9uKSkpLCBUUlVFKTsKLSAgICAgICAgZ3RrX2Jv eF9wYWNrX3N0YXJ0KEdUS19CT1gocmVtZW1iZXJCb3gpLCBtX3JlbWVtYmVyQ2hlY2tCdXR0b24s IEZBTFNFLCBGQUxTRSwgMCk7Ci0gICAgfQotfQotCi1zdGF0aWMgYm9vbCBnZXRTYXZlZExvZ2lu KFNvdXBBdXRoKiBhdXRoLCBjb25zdCBjaGFyKiogdXNlcm5hbWUsIGNvbnN0IGNoYXIqKiBwYXNz d29yZCkKLXsKLSNpZmRlZiBTT1VQX1RZUEVfUEFTU1dPUkRfTUFOQUdFUgotICAgIEdTTGlzdCog dXNlcnMgPSBzb3VwX2F1dGhfZ2V0X3NhdmVkX3VzZXJzKGF1dGgpOwotICAgIGlmICghdXNlcnMp Ci0gICAgICAgIHJldHVybiBmYWxzZTsKLQotICAgICp1c2VybmFtZSA9IHN0YXRpY19jYXN0PGNo YXIqPih1c2Vycy0+ZGF0YSk7Ci0gICAgKnBhc3N3b3JkID0gc291cF9hdXRoX2dldF9zYXZlZF9w YXNzd29yZChhdXRoLCAqdXNlcm5hbWUpOwotICAgIGdfc2xpc3RfZnJlZSh1c2Vycyk7Ci0KLSAg ICByZXR1cm4gKnVzZXJuYW1lICYmICpwYXNzd29yZDsKLSNlbHNlCi0gICAgcmV0dXJuIGZhbHNl OwotI2VuZGlmCisgICAgbV9yZW1lbWJlckNoZWNrQnV0dG9uID0gZ3RrX2NoZWNrX2J1dHRvbl9u ZXdfd2l0aF9tbmVtb25pYyhfKCJfUmVtZW1iZXIgcGFzc3dvcmQiKSk7CisgICAgZ3RrX2xhYmVs X3NldF9saW5lX3dyYXAoR1RLX0xBQkVMKGd0a19iaW5fZ2V0X2NoaWxkKEdUS19CSU4obV9yZW1l bWJlckNoZWNrQnV0dG9uKSkpLCBUUlVFKTsKKyAgICBndGtfYm94X3BhY2tfc3RhcnQoR1RLX0JP WChyZW1lbWJlckJveCksIG1fcmVtZW1iZXJDaGVja0J1dHRvbiwgRkFMU0UsIEZBTFNFLCAwKTsK IH0KIAogdm9pZCBHdGtBdXRoZW50aWNhdGlvbkRpYWxvZzo6c2hvdygpCiB7Ci0gICAgY29uc3Qg Y2hhciogdXNlcm5hbWUgPSAwOwotICAgIGNvbnN0IGNoYXIqIHBhc3N3b3JkID0gMDsKLSAgICBi b29sIGhhdmVTYXZlZExvZ2luID0gZ2V0U2F2ZWRMb2dpbihtX2F1dGguZ2V0KCksICZ1c2VybmFt ZSwgJnBhc3N3b3JkKTsKICAgICBzb3VwX3Nlc3Npb25fcGF1c2VfbWVzc2FnZShtX3Nlc3Npb24s IG1fbWVzc2FnZS5nZXQoKSk7Ci0gICAgZ3RrX2VudHJ5X3NldF90ZXh0KEdUS19FTlRSWShtX2xv Z2luRW50cnkpLCB1c2VybmFtZSA/IHVzZXJuYW1lIDogIiIpOwotICAgIGd0a19lbnRyeV9zZXRf dGV4dChHVEtfRU5UUlkobV9wYXNzd29yZEVudHJ5KSwgcGFzc3dvcmQgPyBwYXNzd29yZCA6ICIi KTsKLSAgICBpZiAobV9yZW1lbWJlckNoZWNrQnV0dG9uICYmIGhhdmVTYXZlZExvZ2luKQorCisg ICAgLy8gVGhpcyBpcyBqdXN0IGEgdGVtcG9yYXJ5IGtsdWRnZSB1bnRpbCBHdGtBdXRoZW50aWNh dGlvbkRpYWxvZyB3b3JrcyBkaXJlY3RseSB3aXRoIEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlcy4K KyAgICAvLyBTZWUgaHR0cDovL3drYnVnLmNvbS85OTkxNAorICAgIEF1dGhlbnRpY2F0aW9uQ2hh bGxlbmdlIGNoYWxsZW5nZSgwIC8qIHNlc3Npb24gKi8sIG1fbWVzc2FnZS5nZXQoKSwgbV9hdXRo LmdldCgpLCBmYWxzZSwgMCk7CisgICAgQ3JlZGVudGlhbCBzYXZlZENyZWRlbnRpYWwgPSBjcmVk ZW50aWFsQmFja2luZ1N0b3JlKCkuY3JlZGVudGlhbEZvckNoYWxsZW5nZShjaGFsbGVuZ2UpOwor ICAgIGlmICghc2F2ZWRDcmVkZW50aWFsLmlzRW1wdHkoKSkgeworICAgICAgICBndGtfZW50cnlf c2V0X3RleHQoR1RLX0VOVFJZKG1fbG9naW5FbnRyeSksIHNhdmVkQ3JlZGVudGlhbC51c2VyKCku dXRmOCgpLmRhdGEoKSk7CisgICAgICAgIGd0a19lbnRyeV9zZXRfdGV4dChHVEtfRU5UUlkobV9w YXNzd29yZEVudHJ5KSwgc2F2ZWRDcmVkZW50aWFsLnBhc3N3b3JkKCkudXRmOCgpLmRhdGEoKSk7 CiAgICAgICAgIGd0a190b2dnbGVfYnV0dG9uX3NldF9hY3RpdmUoR1RLX1RPR0dMRV9CVVRUT04o bV9yZW1lbWJlckNoZWNrQnV0dG9uKSwgVFJVRSk7CisgICAgfQorCiAgICAgZ19zaWduYWxfY29u bmVjdChtX2RpYWxvZywgInJlc3BvbnNlIiwgR19DQUxMQkFDSyhhdXRoZW50aWNhdGlvbkRpYWxv Z1Jlc3BvbnNlQ2FsbGJhY2spLCB0aGlzKTsKICAgICBndGtfd2lkZ2V0X3Nob3dfYWxsKG1fZGlh bG9nKTsKIH0KQEAgLTIzOSw5ICsyMTUsNyBAQCB2b2lkIEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9n OjpkZXN0cm95KCkKICAgICBzb3VwX3Nlc3Npb25fdW5wYXVzZV9tZXNzYWdlKG1fc2Vzc2lvbiwg bV9tZXNzYWdlLmdldCgpKTsKICAgICBndGtfd2lkZ2V0X2Rlc3Ryb3kobV9kaWFsb2cpOwogCi0j aWZkZWYgU09VUF9UWVBFX1BBU1NXT1JEX01BTkFHRVIKICAgICBzaG91bGREZWxldGUgPSAhbV9p c1NhdmluZ1Bhc3N3b3JkOwotI2VuZGlmCiAKICAgICAvLyBEbyBub3QgZGVsZXRlIHRoZSBvYmpl Y3QgaWYgaXQncyBzdGlsbCBzYXZpbmcgdGhlIHBhc3N3b3JkLAogICAgIC8vIHRoZSBzYXZlIHBh c3N3b3JkIGNhbGxiYWNrIHdpbGwgZGVsZXRlIGl0LgpAQCAtMjQ5LDcgKzIyMyw2IEBAIHZvaWQg R3RrQXV0aGVudGljYXRpb25EaWFsb2c6OmRlc3Ryb3koKQogICAgICAgICBkZWxldGUgdGhpczsK IH0KIAotI2lmZGVmIFNPVVBfVFlQRV9QQVNTV09SRF9NQU5BR0VSCiB2b2lkIEd0a0F1dGhlbnRp Y2F0aW9uRGlhbG9nOjpzYXZlUGFzc3dvcmRDYWxsYmFjayhTb3VwTWVzc2FnZSogbWVzc2FnZSwg R3RrQXV0aGVudGljYXRpb25EaWFsb2cqIGRpYWxvZykKIHsKICAgICBkaWFsb2ctPnNhdmVQYXNz d29yZCgpOwpAQCAtMjYxLDggKzIzNCwxNiBAQCB2b2lkIEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9n OjpzYXZlUGFzc3dvcmQoKQogICAgIEFTU0VSVCghbV9wYXNzd29yZC5pc051bGwoKSk7CiAKICAg ICAvLyBBbnl0aGluZyBidXQgNDAxIGFuZCA1eHggbWVhbnMgdGhlIHBhc3N3b3JkIHdhcyBhY2Nl cHRlZC4KLSAgICBpZiAobV9tZXNzYWdlLmdldCgpLT5zdGF0dXNfY29kZSAhPSA0MDEgJiYgbV9t ZXNzYWdlLmdldCgpLT5zdGF0dXNfY29kZSA8IDUwMCkKLSAgICAgICAgc291cF9hdXRoX3NhdmVf cGFzc3dvcmQobV9hdXRoLmdldCgpLCBtX3VzZXJuYW1lLmRhdGEoKSwgbV9wYXNzd29yZC5kYXRh KCkpOworICAgIGlmIChtX21lc3NhZ2UuZ2V0KCktPnN0YXR1c19jb2RlICE9IDQwMSAmJiBtX21l c3NhZ2UuZ2V0KCktPnN0YXR1c19jb2RlIDwgNTAwKSB7CisgICAgICAgIC8vIFRoaXMgaXMganVz dCBhIHRlbXBvcmFyeSBrbHVkZ2UgdW50aWwgR3RrQXV0aGVudGljYXRpb25EaWFsb2cgd29ya3Mg ZGlyZWN0bHkgd2l0aCBBdXRoZW50aWNhdGlvbkNoYWxsZW5nZXMuCisgICAgICAgIC8vIFNlZSBo dHRwOi8vd2tidWcuY29tLzk5OTE0CisgICAgICAgIEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlIGNo YWxsZW5nZSgwIC8qIHNlc3Npb24gKi8sIG1fbWVzc2FnZS5nZXQoKSwgbV9hdXRoLmdldCgpLCBm YWxzZSwgMCk7CisgICAgICAgIENyZWRlbnRpYWwgY3JlZGVudGlhbFRvU2F2ZSA9IENyZWRlbnRp YWwoCisgICAgICAgICAgICBTdHJpbmc6OmZyb21VVEY4KG1fdXNlcm5hbWUuZGF0YSgpKSwKKyAg ICAgICAgICAgIFN0cmluZzo6ZnJvbVVURjgobV9wYXNzd29yZC5kYXRhKCkpLAorICAgICAgICAg ICAgQ3JlZGVudGlhbFBlcnNpc3RlbmNlUGVybWFuZW50KTsKKyAgICAgICAgY3JlZGVudGlhbEJh Y2tpbmdTdG9yZSgpLnN0b3JlQ3JlZGVudGlhbHNGb3JDaGFsbGVuZ2UoY2hhbGxlbmdlLCBjcmVk ZW50aWFsVG9TYXZlKTsKKyAgICB9CiAKICAgICAvLyBEaXNjb25uZWN0IHRoZSBjYWxsYmFjay4g SWYgdGhlIGF1dGhlbnRpY2F0aW9uIHN1Y2NlZWRlZCB3ZSBhcmUgZG9uZSwKICAgICAvLyBhbmQg aWYgaXQgZmFpbGVkIHdlJ2xsIGNyZWF0ZSBhIG5ldyBHdGtBdXRoZW50aWNhdGlvbkRpYWxvZyBh bmQgd2UnbGwKQEAgLTI3Miw3ICsyNTMsNiBAQCB2b2lkIEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9n OjpzYXZlUGFzc3dvcmQoKQogICAgIC8vIERpYWxvZyBoYXMgYmVlbiBhbHJlYWR5IGRlc3Ryb3ll ZCwgYWZ0ZXIgc2F2aW5nIHRoZSBwYXNzd29yZCBpdCBzaG91bGQgYmUgZGVsZXRlZC4KICAgICBk ZWxldGUgdGhpczsKIH0KLSNlbmRpZgogCiB2b2lkIEd0a0F1dGhlbnRpY2F0aW9uRGlhbG9nOjph dXRoZW50aWNhdGUoKQogewpAQCAtMjgwLDE0ICsyNjAsMTIgQEAgdm9pZCBHdGtBdXRoZW50aWNh dGlvbkRpYWxvZzo6YXV0aGVudGljYXRlKCkKICAgICBjb25zdCBjaGFyICpwYXNzd29yZCA9IGd0 a19lbnRyeV9nZXRfdGV4dChHVEtfRU5UUlkobV9wYXNzd29yZEVudHJ5KSk7CiAgICAgc291cF9h dXRoX2F1dGhlbnRpY2F0ZShtX2F1dGguZ2V0KCksIHVzZXJuYW1lLCBwYXNzd29yZCk7CiAKLSNp ZmRlZiBTT1VQX1RZUEVfUEFTU1dPUkRfTUFOQUdFUgogICAgIGlmIChtX3JlbWVtYmVyQ2hlY2tC dXR0b24gJiYgZ3RrX3RvZ2dsZV9idXR0b25fZ2V0X2FjdGl2ZShHVEtfVE9HR0xFX0JVVFRPTiht X3JlbWVtYmVyQ2hlY2tCdXR0b24pKSkgewogICAgICAgICBtX3VzZXJuYW1lID0gdXNlcm5hbWU7 CiAgICAgICAgIG1fcGFzc3dvcmQgPSBwYXNzd29yZDsKICAgICAgICAgbV9pc1NhdmluZ1Bhc3N3 b3JkID0gdHJ1ZTsKICAgICAgICAgbV9zYXZlUGFzc3dvcmRIYW5kbGVyID0gZ19zaWduYWxfY29u bmVjdChtX21lc3NhZ2UuZ2V0KCksICJnb3QtaGVhZGVycyIsIEdfQ0FMTEJBQ0soc2F2ZVBhc3N3 b3JkQ2FsbGJhY2spLCB0aGlzKTsKICAgICB9Ci0jZW5kaWYKIH0KIAogdm9pZCBHdGtBdXRoZW50 aWNhdGlvbkRpYWxvZzo6YXV0aGVudGljYXRpb25EaWFsb2dSZXNwb25zZUNhbGxiYWNrKEd0a1dp ZGdldCosIGdpbnQgcmVzcG9uc2VJRCwgR3RrQXV0aGVudGljYXRpb25EaWFsb2cqIGRpYWxvZykK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9HdGtBdXRoZW50aWNhdGlv bkRpYWxvZy5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0d0a0F1dGhlbnRpY2F0aW9u RGlhbG9nLmgKaW5kZXggNzU4MjQxY2QzMzZkODMzNjU0NTk1NTBhMzhmMGUxNmQ0OTY4YjQyNS4u OTEyZjc1ZDc2OTE2ODc1ZWJlZTU5NDljN2QxOGVkYzhkMGU5N2Q1OSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0d0a0F1dGhlbnRpY2F0aW9uRGlhbG9nLmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0d0a0F1dGhlbnRpY2F0aW9uRGlhbG9nLmgKQEAg LTIwLDggKzIwLDYgQEAKICNpZm5kZWYgR3RrQXV0aGVudGljYXRpb25EaWFsb2dfaAogI2RlZmlu ZSBHdGtBdXRoZW50aWNhdGlvbkRpYWxvZ19oCiAKLSNkZWZpbmUgTElCU09VUF9JX0hBVkVfUkVB RF9CVUdfNTk0Mzc3X0FORF9LTk9XX1NPVVBfUEFTU1dPUkRfTUFOQUdFUl9NSUdIVF9HT19BV0FZ Ci0KICNpbmNsdWRlIDx3dGYvZ29iamVjdC9HT3duUHRyLmg+CiAjaW5jbHVkZSAiR1JlZlB0ckd0 ay5oIgogI2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgpAQCAtNDQsMTIgKzQyLDggQEAgcHVibGlj OgogcHJpdmF0ZToKICAgICB2b2lkIGRlc3Ryb3koKTsKICAgICB2b2lkIGF1dGhlbnRpY2F0ZSgp OwotCi0jaWZkZWYgU09VUF9UWVBFX1BBU1NXT1JEX01BTkFHRVIKICAgICB2b2lkIHNhdmVQYXNz d29yZCgpOwogICAgIHN0YXRpYyB2b2lkIHNhdmVQYXNzd29yZENhbGxiYWNrKFNvdXBNZXNzYWdl KiwgR3RrQXV0aGVudGljYXRpb25EaWFsb2cqKTsKLSNlbmRpZgotCiAgICAgc3RhdGljIHZvaWQg YXV0aGVudGljYXRpb25EaWFsb2dSZXNwb25zZUNhbGxiYWNrKEd0a1dpZGdldCosIGdpbnQgcmVz cG9uc2VJRCwgR3RrQXV0aGVudGljYXRpb25EaWFsb2cqKTsKIAogICAgIEd0a1dpZGdldCogbV9k aWFsb2c7CkBAIC02MSwxMiArNTUsMTAgQEAgcHJpdmF0ZToKICAgICBHdGtXaWRnZXQqIG1fcGFz c3dvcmRFbnRyeTsKICAgICBHdGtXaWRnZXQqIG1fcmVtZW1iZXJDaGVja0J1dHRvbjsKIAotI2lm ZGVmIFNPVVBfVFlQRV9QQVNTV09SRF9NQU5BR0VSCiAgICAgYm9vbCBtX2lzU2F2aW5nUGFzc3dv cmQ7CiAgICAgdW5zaWduZWQgbG9uZyBtX3NhdmVQYXNzd29yZEhhbmRsZXI7CiAgICAgQ1N0cmlu ZyBtX3VzZXJuYW1lOwogICAgIENTdHJpbmcgbV9wYXNzd29yZDsKLSNlbmRpZgogfTsKIAogfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v bmV0d29yay9ndGsvQ3JlZGVudGlhbEJhY2tpbmdTdG9yZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9uZXR3b3JrL2d0ay9DcmVkZW50aWFsQmFja2luZ1N0b3JlLmNwcApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li5lNGQxYmFmMjA4NmUxN2E1NGUzODQ1OWQ3NWM0M2YyNjE0ZWVjMzA4Ci0tLSAvZGV2L251bGwK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9ndGsvQ3JlZGVudGlhbEJhY2tp bmdTdG9yZS5jcHAKQEAgLTAsMCArMSwxMDggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIg SWdhbGlhIFMuTC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoK KyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5 IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRo ZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IElHQUxJQSBTLkwuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS CisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgQ09N UFVURVIsIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1Qs IElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFV RU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VS RU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEs IE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VE IEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1Qs IFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBP VEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBT T0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFH RS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQ3JlZGVudGlhbEJhY2tp bmdTdG9yZS5oIgorCisjZGVmaW5lIFNFQ1JFVF9XSVRIX1VOU1RBQkxFIDEKKyNkZWZpbmUgU0VD UkVUX0FQSV9TVUJKRUNUX1RPX0NIQU5HRSAxCisjaW5jbHVkZSAiQXV0aGVudGljYXRpb25DaGFs bGVuZ2UuaCIKKyNpbmNsdWRlICJHUmVmUHRyR3RrLmgiCisjaW5jbHVkZSA8Z2xpYi9naTE4bi1s aWIuaD4KKyNpbmNsdWRlIDxsaWJzZWNyZXQvc2VjcmV0Lmg+CisjaW5jbHVkZSA8bGlic291cC9z b3VwLmg+CisjaW5jbHVkZSA8d3RmL2dvYmplY3QvR093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi90 ZXh0L0NTdHJpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitDcmVkZW50aWFsQmFja2lu Z1N0b3JlJiBjcmVkZW50aWFsQmFja2luZ1N0b3JlKCkKK3sKKyAgICBERUZJTkVfU1RBVElDX0xP Q0FMKENyZWRlbnRpYWxCYWNraW5nU3RvcmUsIGJhY2tpbmdTdG9yZSwgKCkpOworICAgIHJldHVy biBiYWNraW5nU3RvcmU7Cit9CisKK3N0YXRpYyBHUmVmUHRyPEdIYXNoVGFibGU+IGNyZWF0ZUF0 dHJpYnV0ZUhhc2hUYWJsZUZyb21DaGFsbGVuZ2UoY29uc3QgQXV0aGVudGljYXRpb25DaGFsbGVu Z2UmIGNoYWxsZW5nZSwgY29uc3QgQ3JlZGVudGlhbCYgY3JlZGVudGlhbCA9IENyZWRlbnRpYWwo KSkKK3sKKyAgICBTb3VwVVJJKiB1cmkgPSBzb3VwX21lc3NhZ2VfZ2V0X3VyaShjaGFsbGVuZ2Uu c291cE1lc3NhZ2UoKSk7CisgICAgR1JlZlB0cjxHSGFzaFRhYmxlPiBhdHRyaWJ1dGVzID0gYWRv cHRHUmVmKHNlY3JldF9hdHRyaWJ1dGVzX2J1aWxkKAorICAgICAgICBTRUNSRVRfU0NIRU1BX0NP TVBBVF9ORVRXT1JLLAorICAgICAgICAiZG9tYWluIiwgc291cF9hdXRoX2dldF9yZWFsbShjaGFs bGVuZ2Uuc291cEF1dGgoKSksCisgICAgICAgICJzZXJ2ZXIiLCB1cmktPmhvc3QsCisgICAgICAg ICJwcm90b2NvbCIsIHVyaS0+c2NoZW1lLAorICAgICAgICAiYXV0aHR5cGUiLCBzb3VwX2F1dGhf Z2V0X3NjaGVtZV9uYW1lKGNoYWxsZW5nZS5zb3VwQXV0aCgpKSwKKyAgICAgICAgInBvcnQiLCB1 cmktPnBvcnQsCisgICAgICAgIE5VTEwpKTsKKyAgICBpZiAoY3JlZGVudGlhbC5pc0VtcHR5KCkp CisgICAgICAgIHJldHVybiBhdHRyaWJ1dGVzOworCisgICAgZ19oYXNoX3RhYmxlX2luc2VydChh dHRyaWJ1dGVzLmdldCgpLCBnX3N0cmR1cCgidXNlciIpLCBnX3N0cmR1cChjcmVkZW50aWFsLnVz ZXIoKS51dGY4KCkuZGF0YSgpKSk7CisgICAgcmV0dXJuIGF0dHJpYnV0ZXM7Cit9CisKK0NyZWRl bnRpYWwgQ3JlZGVudGlhbEJhY2tpbmdTdG9yZTo6Y3JlZGVudGlhbEZvckNoYWxsZW5nZShjb25z dCBBdXRoZW50aWNhdGlvbkNoYWxsZW5nZSYgY2hhbGxlbmdlKQoreworICAgIEdPd25QdHI8R0xp c3Q+IGVsZW1lbnRzKHNlY3JldF9zZXJ2aWNlX3NlYXJjaF9zeW5jKAorICAgICAgICAwLCAvLyBU aGUgZGVmYXVsdCBTZWNyZXRTZXJ2aWNlLgorICAgICAgICBTRUNSRVRfU0NIRU1BX0NPTVBBVF9O RVRXT1JLLAorICAgICAgICBjcmVhdGVBdHRyaWJ1dGVIYXNoVGFibGVGcm9tQ2hhbGxlbmdlKGNo YWxsZW5nZSkuZ2V0KCksCisgICAgICAgIHN0YXRpY19jYXN0PFNlY3JldFNlYXJjaEZsYWdzPihT RUNSRVRfU0VBUkNIX1VOTE9DSyB8IFNFQ1JFVF9TRUFSQ0hfTE9BRF9TRUNSRVRTKSwgLy8gVGhl IGRlZmF1bHQgYmVoYXZpb3IgaXMgdG8gb25seSByZXR1cm4gdGhlIG1vc3QgcmVjZW50IGl0ZW0u CisgICAgICAgIDAsIC8vIGNhbmNlbGxhYmxlCisgICAgICAgIDApKTsgLy8gZXJyb3IKKyAgICBp ZiAoIWVsZW1lbnRzIHx8ICFlbGVtZW50cy0+ZGF0YSkKKyAgICAgICAgcmV0dXJuIENyZWRlbnRp YWwoKTsKKworICAgIEdSZWZQdHI8U2VjcmV0SXRlbT4gc2VjcmV0SXRlbSA9IGFkb3B0R1JlZihz dGF0aWNfY2FzdDxTZWNyZXRJdGVtKj4oZWxlbWVudHMtPmRhdGEpKTsKKyAgICBHUmVmUHRyPEdI YXNoVGFibGU+IGF0dHJpYnV0ZXMgPSBhZG9wdEdSZWYoc2VjcmV0X2l0ZW1fZ2V0X2F0dHJpYnV0 ZXMoc2VjcmV0SXRlbS5nZXQoKSkpOworICAgIFN0cmluZyB1c2VyID0gU3RyaW5nOjpmcm9tVVRG OChzdGF0aWNfY2FzdDxjb25zdCBjaGFyKj4oZ19oYXNoX3RhYmxlX2xvb2t1cChhdHRyaWJ1dGVz LmdldCgpLCAidXNlciIpKSk7CisgICAgaWYgKHVzZXIuaXNFbXB0eSgpKQorICAgICAgICByZXR1 cm4gQ3JlZGVudGlhbCgpOworCisgICAgc2l6ZV90IGxlbmd0aDsKKyAgICBHUmVmUHRyPFNlY3Jl dFZhbHVlPiBzZWNyZXRWYWx1ZSA9IGFkb3B0R1JlZihzZWNyZXRfaXRlbV9nZXRfc2VjcmV0KHNl Y3JldEl0ZW0uZ2V0KCkpKTsKKyAgICBjb25zdCBjaGFyKiBwYXNzd29yZERhdGEgPSBzZWNyZXRf dmFsdWVfZ2V0KHNlY3JldFZhbHVlLmdldCgpLCAmbGVuZ3RoKTsKKyAgICBTdHJpbmcgcGFzc3dv cmQgPSBTdHJpbmc6OmZyb21VVEY4KHBhc3N3b3JkRGF0YSwgbGVuZ3RoKTsKKworICAgIHJldHVy biBDcmVkZW50aWFsKHVzZXIsIHBhc3N3b3JkLCBDcmVkZW50aWFsUGVyc2lzdGVuY2VQZXJtYW5l bnQpOworfQorCit2b2lkIENyZWRlbnRpYWxCYWNraW5nU3RvcmU6OnN0b3JlQ3JlZGVudGlhbHNG b3JDaGFsbGVuZ2UoY29uc3QgQXV0aGVudGljYXRpb25DaGFsbGVuZ2UmIGNoYWxsZW5nZSwgY29u c3QgQ3JlZGVudGlhbCYgY3JlZGVudGlhbCkKK3sKKyAgICBDU3RyaW5nIHV0ZjhQYXNzd29yZCA9 IGNyZWRlbnRpYWwucGFzc3dvcmQoKS51dGY4KCk7CisgICAgR1JlZlB0cjxTZWNyZXRWYWx1ZT4g bmV3U2VjcmV0VmFsdWUgPSBhZG9wdEdSZWYoc2VjcmV0X3ZhbHVlX25ldyh1dGY4UGFzc3dvcmQu ZGF0YSgpLCB1dGY4UGFzc3dvcmQubGVuZ3RoKCksICJ0ZXh0L3BsYWluIikpOworCisgICAgc2Vj cmV0X3NlcnZpY2Vfc3RvcmUoCisgICAgICAgIDAsIC8vIFRoZSBkZWZhdWx0IFNlY3JldFNlcnZp Y2UuCisgICAgICAgIFNFQ1JFVF9TQ0hFTUFfQ09NUEFUX05FVFdPUkssCisgICAgICAgIGNyZWF0 ZUF0dHJpYnV0ZUhhc2hUYWJsZUZyb21DaGFsbGVuZ2UoY2hhbGxlbmdlLCBjcmVkZW50aWFsKS5n ZXQoKSwKKyAgICAgICAgU0VDUkVUX0NPTExFQ1RJT05fREVGQVVMVCwKKyAgICAgICAgXygiV2Vi S2l0R1RLKyBwYXNzd29yZCIpLAorICAgICAgICBuZXdTZWNyZXRWYWx1ZS5nZXQoKSwKKyAgICAg ICAgMCwgLy8gY2FuY2VsbGFibGUKKyAgICAgICAgMCwgLy8gY2FsbGJhY2sKKyAgICAgICAgMCk7 IC8vIGRhdGEKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9ndGsvQ3JlZGVudGlhbEJhY2tpbmdTdG9yZS5oIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9ndGsvQ3JlZGVudGlhbEJhY2tpbmdTdG9y ZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLjM4M2RhZmNmMTI2MjRiNWRjYjY5YWFiMmZmMzk3YzQyY2I3YjNmYTMK LS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2d0ay9D cmVkZW50aWFsQmFja2luZ1N0b3JlLmgKQEAgLTAsMCArMSw1MiBAQAorLyoKKyAqIENvcHlyaWdo dCAoQykgMjAxMiBJZ2FsaWEgUy5MLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisg KiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgSUdBTElBIFMuTC4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1Ig SU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisg KiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFM TCBBUFBMRSBDT01QVVRFUiwgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s CisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisg KiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgQ3JlZGVudGlhbEJhY2tpbmdTdG9yZV9oCisj ZGVmaW5lIENyZWRlbnRpYWxCYWNraW5nU3RvcmVfaAorCisjaW5jbHVkZSAiQ3JlZGVudGlhbC5o IgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdl OworCitjbGFzcyBDcmVkZW50aWFsQmFja2luZ1N0b3JlIHsKK1dURl9NQUtFX05PTkNPUFlBQkxF KENyZWRlbnRpYWxCYWNraW5nU3RvcmUpOworcHVibGljOgorICAgIGZyaWVuZCBDcmVkZW50aWFs QmFja2luZ1N0b3JlJiBjcmVkZW50aWFsQmFja2luZ1N0b3JlKCk7CisgICAgdmlydHVhbCB+Q3Jl ZGVudGlhbEJhY2tpbmdTdG9yZSgpIHsgfQorCisgICAgQ3JlZGVudGlhbCBjcmVkZW50aWFsRm9y Q2hhbGxlbmdlKGNvbnN0IEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlJik7CisgICAgdm9pZCBzdG9y ZUNyZWRlbnRpYWxzRm9yQ2hhbGxlbmdlKGNvbnN0IEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlJiwg Y29uc3QgQ3JlZGVudGlhbCYpOworCitwcml2YXRlOgorICAgIENyZWRlbnRpYWxCYWNraW5nU3Rv cmUoKSB7IH0KK307CisKK0NyZWRlbnRpYWxCYWNraW5nU3RvcmUmIGNyZWRlbnRpYWxCYWNraW5n U3RvcmUoKTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gQ3JlZGVudGlh bEJhY2tpbmdTdG9yZV9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2d0ay9HTlVtYWtlZmls ZS5hbSBiL1NvdXJjZS9XZWJLaXQvZ3RrL0dOVW1ha2VmaWxlLmFtCmluZGV4IDViZTllYjU0OGVl MDIzZDE0MGEzNWQxNjYyNDMzZDU4MWJiNzFiODMuLmMxMzZjYmM5ZGZhYzg5NmJiM2RjYWFmODVi YWYxYTFmNWNlNzM1OGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvZ3RrL0dOVW1ha2VmaWxl LmFtCisrKyBiL1NvdXJjZS9XZWJLaXQvZ3RrL0dOVW1ha2VmaWxlLmFtCkBAIC05NSw2ICs5NSw3 IEBAIGxpYndlYmtpdGd0a19AV0VCS0lUR1RLX0FQSV9NQUpPUl9WRVJTSU9OQF9AV0VCS0lUR1RL X0FQSV9NSU5PUl9WRVJTSU9OQF9sYV9MSUJBCiAJJChHU1RSRUFNRVJfTElCUykgXAogCSQoR1RL X0xJQlMpIFwKIAkkKEpQRUdfTElCUykgXAorCSQoTElCU0VDUkVUX0xJQlMpIFwKIAkkKExJQlNP VVBfTElCUykgXAogCSQoTElCWE1MX0xJQlMpIFwKIAkkKExJQlhTTFRfTElCUykgXApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdDIvR05VbWFrZWZpbGUuYW0gYi9Tb3VyY2UvV2ViS2l0Mi9HTlVt YWtlZmlsZS5hbQppbmRleCBmOTU2ZDBlZGRmYzA5Mzk3OWM1YmMwMjYwM2NlNTE0YzI1NzgxODZi Li5hMjUyY2QxZDg0ZjMwOGI1MDk0NzI2OTFkYzA5Y2E5N2JkOWU5ZjExIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0Mi9HTlVtYWtlZmlsZS5hbQorKysgYi9Tb3VyY2UvV2ViS2l0Mi9HTlVtYWtl ZmlsZS5hbQpAQCAtMTc1LDYgKzE3NSw3IEBAIGxpYndlYmtpdDJndGtfQFdFQktJVEdUS19BUElf TUFKT1JfVkVSU0lPTkBfQFdFQktJVEdUS19BUElfTUlOT1JfVkVSU0lPTkBfbGFfTElCCiAJJChH VEtfTElCUykgXAogCSQoR1RLX1VOSVhfUFJJTlRJTkdfTElCUykgXAogCSQoSlBFR19MSUJTKSBc CisJJChMSUJTRUNSRVRfTElCUykgXAogCSQoTElCU09VUF9MSUJTKSBcCiAJJChMSUJYTUxfTElC UykgXAogCSQoTElCWFNMVF9MSUJTKSBcCkBAIC00MDksNiArNDEwLDcgQEAgbGliV2ViQ29yZUd0 azJfbGFfQ1BQRkxBR1MgPSBcCiAJJChHTElCX0NGTEFHUykgXAogCSQoR1NUUkVBTUVSX0NGTEFH UykgXAogCSQoR1RLMl9DRkxBR1MpIFwKKwkkKExJQlNFQ1JFVF9DRkxBR1MpIFwKIAkkKExJQlNP VVBfQ0ZMQUdTKSBcCiAJJChMSUJYTUxfQ0ZMQUdTKSBcCiAJJChMSUJYU0xUX0NGTEFHUykgXApk aWZmIC0tZ2l0IGEvQ2hhbmdlTG9nIGIvQ2hhbmdlTG9nCmluZGV4IDdlNDQwNDI1ZGE4YjBhZjFm Yjc2ZTFjNzQ1NDU3NTI4NzJiYjZjNzAuLjJjZTdmYTJmNWNiMGIzODYxYWZkZWQzMDdiNThjMmI3 YTYyMmI3ZTQgMTAwNjQ0Ci0tLSBhL0NoYW5nZUxvZworKysgYi9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwxNSBAQAorMjAxMi0xMC0zMCAgTWFydGluIFJvYmluc29uICA8bXJvYmluc29uQGlnYWxpYS5j b20+CisKKyAgICAgICAgW0dUS10gUmVtb3ZlIGRlcGVuZGVuY3kgb24gU291cFBhc3N3b3JkTWFu YWdlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTAw Nzc1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRk IGEgbGlic2VjcmV0IGRlcGVuZGVuY3kgdG8gdGhlIGJ1aWxkLiBUaGlzIGlzIG5lY2Vzc2FyeSBz byB0aGF0IHdlIGNhbiByZW1vdmUKKyAgICAgICAgYSBkZXBlbmRlbmN5IG9uIFNvdXBQYXNzd29y ZE1hbmFnZXIuCisKKyAgICAgICAgKiBjb25maWd1cmUuYWM6IExvb2sgZm9yIGxpYnNlY3JldCB1 c2luZyB0aGUgcGtnLWNvbmZpZyBjb25maWd1cmF0aW9uIG1hY3JvLgorCiAyMDEyLTEwLTI2ICBS b2IgQnVpcyAgPHJidWlzQHJpbS5jb20+CiAKICAgICAgICAgW0JsYWNrQmVycnldIFBsYXRmb3Jt IEFic3RyYWN0aW9uIGZvciBXZWJLaXQgUmVzb3VyY2UvSW1hZ2UgTG9hZGluZwpkaWZmIC0tZ2l0 IGEvY29uZmlndXJlLmFjIGIvY29uZmlndXJlLmFjCmluZGV4IDhiOWNlYTAzMTlhM2Q3OTZjNzZj NTY0MTZmZjU0NjU1ZjY2ODFkMzguLjJkYWE2ZGJjZTNhYzllMGZmOGRhYzI3MTkyNjM0Y2FhZmIx OWEyMzAgMTAwNjQ0Ci0tLSBhL2NvbmZpZ3VyZS5hYworKysgYi9jb25maWd1cmUuYWMKQEAgLTk1 Myw2ICs5NTMsMTAgQEAgUEtHX0NIRUNLX01PRFVMRVMoW0xJQlNPVVBdLAogQUNfU1VCU1QoW0xJ QlNPVVBfQ0ZMQUdTXSkKIEFDX1NVQlNUKFtMSUJTT1VQX0xJQlNdKQogCitQS0dfQ0hFQ0tfTU9E VUxFUyhbTElCU0VDUkVUXSwgW2xpYnNlY3JldC0xXSkKK0FDX1NVQlNUKFtMSUJTRUNSRVRfQ0ZM QUdTXSkKK0FDX1NVQlNUKFtMSUJTRUNSRVRfTElCU10pCisKICMgY2hlY2sgaWYgRnJlZVR5cGUv Rm9udENvbmZpZyBhcmUgYXZhaWxhYmxlCiBpZiB0ZXN0ICIkd2l0aF9mb250X2JhY2tlbmQiID0g ImZyZWV0eXBlIjsgdGhlbgogICAgaWYgdGVzdCAiJHdpdGhfdGFyZ2V0IiA9ICJkaXJlY3RmYiI7 IHRoZW4K