214079 2020-07-08 06:59:17 -0700 [Cocoa] Make it possible to establish direct XPC connections between WebKit processes 2020-07-09 13:17:07 -0700 1 1 1 Unclassified WebKit WebKit Misc. WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 pvollan pvollan andersca benjamin bfulgham cdumez cmarcelo ews-watchlist ggaren jiewen_tan sam thorton webkit-bug-importer oldest_to_newest 1669737 0 pvollan 2020-07-08 06:59:17 -0700 In order to be able to share XPC objects with other WebKit processes, it should be possible to establish direct XPC connections between WebKit processes. See https://bugs.webkit.org/show_bug.cgi?id=213794 for an example of when this is needed. 1669738 1 403777 pvollan 2020-07-08 07:04:37 -0700 Created attachment 403777 Patch 1669820 2 403777 bfulgham 2020-07-08 11:23:41 -0700 Comment on attachment 403777 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=403777&action=review r=me > Source/WTF/ChangeLog:3 > + [Cocoa] Update Launch Services database in the WebContent process from the Network process Title should probably be: Make it possible to establish direct XPC connections between WebKit processes > Source/WTF/ChangeLog:4 > + https://bugs.webkit.org/show_bug.cgi?id=213794 This should be 214079 > Source/WebCore/ChangeLog:4 > + https://bugs.webkit.org/show_bug.cgi?id=213794 Same comments as above. > Tools/ChangeLog:4 > + https://bugs.webkit.org/show_bug.cgi?id=213794 Ditto. 1669835 3 pvollan 2020-07-08 11:49:44 -0700 (In reply to Brent Fulgham from comment #2) > Comment on attachment 403777 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=403777&action=review > > r=me > > > Source/WTF/ChangeLog:3 > > + [Cocoa] Update Launch Services database in the WebContent process from the Network process > > Title should probably be: Make it possible to establish direct XPC > connections between WebKit processes > > > Source/WTF/ChangeLog:4 > > + https://bugs.webkit.org/show_bug.cgi?id=213794 > > This should be 214079 > > > Source/WebCore/ChangeLog:4 > > + https://bugs.webkit.org/show_bug.cgi?id=213794 > > Same comments as above. > > > Tools/ChangeLog:4 > > + https://bugs.webkit.org/show_bug.cgi?id=213794 > > Ditto. Will fix. Thanks for reviewing! 1669839 4 403799 pvollan 2020-07-08 12:00:07 -0700 Created attachment 403799 Patch 1669857 5 ews-feeder 2020-07-08 12:42:12 -0700 Committed r264128: <https://trac.webkit.org/changeset/264128> All reviewed patches have been landed. Closing bug and clearing flags on attachment 403799. 1669859 6 webkit-bug-importer 2020-07-08 12:43:17 -0700 <rdar://problem/65236537> 1669877 7 403799 sam 2020-07-08 13:50:48 -0700 Comment on attachment 403799 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=403799&action=review > Source/WebCore/platform/cocoa/XPCEndpoint.h:34 > +class XPCEndpoint { > +public: Why is this class in WebCore? In what scenarios do we see WebCore needing to use XPC endpoints directly? 1669880 8 pvollan 2020-07-08 14:05:06 -0700 (In reply to Sam Weinig from comment #7) > Comment on attachment 403799 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=403799&action=review > > > Source/WebCore/platform/cocoa/XPCEndpoint.h:34 > > +class XPCEndpoint { > > +public: > > Why is this class in WebCore? In what scenarios do we see WebCore needing to > use XPC endpoints directly? I moved this to WebCore to be able to unit test the classes by exporting symbols with WEBCORE_EXPORT. But perhaps there is another define for exporting symbols from WebKit? 1669889 9 sam 2020-07-08 14:24:48 -0700 (In reply to Per Arne Vollan from comment #8) > (In reply to Sam Weinig from comment #7) > > Comment on attachment 403799 [details] > > Patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=403799&action=review > > > > > Source/WebCore/platform/cocoa/XPCEndpoint.h:34 > > > +class XPCEndpoint { > > > +public: > > > > Why is this class in WebCore? In what scenarios do we see WebCore needing to > > use XPC endpoints directly? > > I moved this to WebCore to be able to unit test the classes by exporting > symbols with WEBCORE_EXPORT. But perhaps there is another define for > exporting symbols from WebKit? Yeah, that's what WK_EXPORT does. I am also not certain that XPCEndpoint really needs a wrapper class, it really doesn't expose enough API for it to seem warranted. We generally don't wrap classes just because, but rather to create abstractions for multiple ports, and that doesn't apply here. It seems like using OSObjectPtr<xpc_endpoint_t> is likely fine. 1669897 10 pvollan 2020-07-08 14:36:21 -0700 (In reply to Sam Weinig from comment #9) > (In reply to Per Arne Vollan from comment #8) > > (In reply to Sam Weinig from comment #7) > > > Comment on attachment 403799 [details] > > > Patch > > > > > > View in context: > > > https://bugs.webkit.org/attachment.cgi?id=403799&action=review > > > > > > > Source/WebCore/platform/cocoa/XPCEndpoint.h:34 > > > > +class XPCEndpoint { > > > > +public: > > > > > > Why is this class in WebCore? In what scenarios do we see WebCore needing to > > > use XPC endpoints directly? > > > > I moved this to WebCore to be able to unit test the classes by exporting > > symbols with WEBCORE_EXPORT. But perhaps there is another define for > > exporting symbols from WebKit? > > Yeah, that's what WK_EXPORT does. > Ah, I see! I will move the classes back to WebKit. > I am also not certain that XPCEndpoint really needs a wrapper class, it > really doesn't expose enough API for it to seem warranted. We generally > don't wrap classes just because, but rather to create abstractions for > multiple ports, and that doesn't apply here. It seems like using > OSObjectPtr<xpc_endpoint_t> is likely fine. I actually intended for them to be more than just wrappers. There is additional code in these classes to create and establish the XPC connection with the endpoint, as well as checking that the other end really is a WebKit process before initiating communication. Perhaps they would benefit from being renamed? 1669900 11 sam 2020-07-08 14:47:00 -0700 (In reply to Per Arne Vollan from comment #10) > (In reply to Sam Weinig from comment #9) > > (In reply to Per Arne Vollan from comment #8) > > > (In reply to Sam Weinig from comment #7) > > > > Comment on attachment 403799 [details] > > > > Patch > > > > > > > > View in context: > > > > https://bugs.webkit.org/attachment.cgi?id=403799&action=review > > > > > > > > > Source/WebCore/platform/cocoa/XPCEndpoint.h:34 > > > > > +class XPCEndpoint { > > > > > +public: > > > > > > > > Why is this class in WebCore? In what scenarios do we see WebCore needing to > > > > use XPC endpoints directly? > > > > > > I moved this to WebCore to be able to unit test the classes by exporting > > > symbols with WEBCORE_EXPORT. But perhaps there is another define for > > > exporting symbols from WebKit? > > > > Yeah, that's what WK_EXPORT does. > > > > Ah, I see! I will move the classes back to WebKit. > > > I am also not certain that XPCEndpoint really needs a wrapper class, it > > really doesn't expose enough API for it to seem warranted. We generally > > don't wrap classes just because, but rather to create abstractions for > > multiple ports, and that doesn't apply here. It seems like using > > OSObjectPtr<xpc_endpoint_t> is likely fine. > > I actually intended for them to be more than just wrappers. There is > additional code in these classes to create and establish the XPC connection > with the endpoint, as well as checking that the other end really is a WebKit > process before initiating communication. Perhaps they would benefit from > being renamed? Yes, if you intend for them to be more than what xpc_endpoint_t's do, I think we are better off with a different name. Otherwise, it will be quite confusing. Can you explain a bit more about what the use case here is? I am really not sure this is the right way to go. Adding more IPC primitives is something we should do very carefully. It's really easy to get this stuff wrong. 1669906 12 pvollan 2020-07-08 15:04:34 -0700 (In reply to Sam Weinig from comment #11) > (In reply to Per Arne Vollan from comment #10) > > (In reply to Sam Weinig from comment #9) > > > (In reply to Per Arne Vollan from comment #8) > > > > (In reply to Sam Weinig from comment #7) > > > > > Comment on attachment 403799 [details] > > > > > Patch > > > > > > > > > > View in context: > > > > > https://bugs.webkit.org/attachment.cgi?id=403799&action=review > > > > > > > > > > > Source/WebCore/platform/cocoa/XPCEndpoint.h:34 > > > > > > +class XPCEndpoint { > > > > > > +public: > > > > > > > > > > Why is this class in WebCore? In what scenarios do we see WebCore needing to > > > > > use XPC endpoints directly? > > > > > > > > I moved this to WebCore to be able to unit test the classes by exporting > > > > symbols with WEBCORE_EXPORT. But perhaps there is another define for > > > > exporting symbols from WebKit? > > > > > > Yeah, that's what WK_EXPORT does. > > > > > > > Ah, I see! I will move the classes back to WebKit. > > > > > I am also not certain that XPCEndpoint really needs a wrapper class, it > > > really doesn't expose enough API for it to seem warranted. We generally > > > don't wrap classes just because, but rather to create abstractions for > > > multiple ports, and that doesn't apply here. It seems like using > > > OSObjectPtr<xpc_endpoint_t> is likely fine. > > > > I actually intended for them to be more than just wrappers. There is > > additional code in these classes to create and establish the XPC connection > > with the endpoint, as well as checking that the other end really is a WebKit > > process before initiating communication. Perhaps they would benefit from > > being renamed? > > Yes, if you intend for them to be more than what xpc_endpoint_t's do, I > think we are better off with a different name. Otherwise, it will be quite > confusing. > > Can you explain a bit more about what the use case here is? I am really not > sure this is the right way to go. Adding more IPC primitives is something we > should do very carefully. It's really easy to get this stuff wrong. Yes, the use case is to send the Launch Services database represented in an XPC object from the Networking process to the WebContent process; see https://bugs.webkit.org/show_bug.cgi?id=213794. The database is only available as an XPC object, so it cannot be sent over the existing CoreIPC connection between the Networking and WebContent process. The Networking process was chosen as the source, since we are controlling its sandbox, making sure that the database is available for sending in the Networking process. 1669944 13 sam 2020-07-08 16:49:09 -0700 (In reply to Per Arne Vollan from comment #12) > (In reply to Sam Weinig from comment #11) > > (In reply to Per Arne Vollan from comment #10) > > > (In reply to Sam Weinig from comment #9) > > > > (In reply to Per Arne Vollan from comment #8) > > > > > (In reply to Sam Weinig from comment #7) > > > > > > Comment on attachment 403799 [details] > > > > > > Patch > > > > > > > > > > > > View in context: > > > > > > https://bugs.webkit.org/attachment.cgi?id=403799&action=review > > > > > > > > > > > > > Source/WebCore/platform/cocoa/XPCEndpoint.h:34 > > > > > > > +class XPCEndpoint { > > > > > > > +public: > > > > > > > > > > > > Why is this class in WebCore? In what scenarios do we see WebCore needing to > > > > > > use XPC endpoints directly? > > > > > > > > > > I moved this to WebCore to be able to unit test the classes by exporting > > > > > symbols with WEBCORE_EXPORT. But perhaps there is another define for > > > > > exporting symbols from WebKit? > > > > > > > > Yeah, that's what WK_EXPORT does. > > > > > > > > > > Ah, I see! I will move the classes back to WebKit. > > > > > > > I am also not certain that XPCEndpoint really needs a wrapper class, it > > > > really doesn't expose enough API for it to seem warranted. We generally > > > > don't wrap classes just because, but rather to create abstractions for > > > > multiple ports, and that doesn't apply here. It seems like using > > > > OSObjectPtr<xpc_endpoint_t> is likely fine. > > > > > > I actually intended for them to be more than just wrappers. There is > > > additional code in these classes to create and establish the XPC connection > > > with the endpoint, as well as checking that the other end really is a WebKit > > > process before initiating communication. Perhaps they would benefit from > > > being renamed? > > > > Yes, if you intend for them to be more than what xpc_endpoint_t's do, I > > think we are better off with a different name. Otherwise, it will be quite > > confusing. > > > > Can you explain a bit more about what the use case here is? I am really not > > sure this is the right way to go. Adding more IPC primitives is something we > > should do very carefully. It's really easy to get this stuff wrong. > > Yes, the use case is to send the Launch Services database represented in an > XPC object from the Networking process to the WebContent process; see > https://bugs.webkit.org/show_bug.cgi?id=213794. The database is only > available as an XPC object, so it cannot be sent over the existing CoreIPC > connection between the Networking and WebContent process. The Networking > process was chosen as the source, since we are controlling its sandbox, > making sure that the database is available for sending in the Networking > process. I'm trying to follow the logic in that other patch, but it's pretty gnarly. It seems like it sets things up so, at least in the web process, messages are coming in both over the mach port and over the xpc connection. It really seems like what this is asking for is to just switch to using xpc messaging for CoreIPC (e.g. each CoreIPC message on Darwin platforms gets encoded as one xpc_data, and not using xpc_object encoding in the more traditional sense). I would really like you to reconsider the amount of complexity this current system you have written adds, and whether it is the right trade off. I think if you spend a bit more time working through the design, you could come up with something much cleaner, that doesn't add new primitives and doesn't add platform specific code into platform agnostic classes. 1670098 14 pvollan 2020-07-09 07:37:43 -0700 (In reply to Sam Weinig from comment #13) > (In reply to Per Arne Vollan from comment #12) > > (In reply to Sam Weinig from comment #11) > > > (In reply to Per Arne Vollan from comment #10) > > > > (In reply to Sam Weinig from comment #9) > > > > > (In reply to Per Arne Vollan from comment #8) > > > > > > (In reply to Sam Weinig from comment #7) > > > > > > > Comment on attachment 403799 [details] > > > > > > > Patch > > > > > > > > > > > > > > View in context: > > > > > > > https://bugs.webkit.org/attachment.cgi?id=403799&action=review > > > > > > > > > > > > > > > Source/WebCore/platform/cocoa/XPCEndpoint.h:34 > > > > > > > > +class XPCEndpoint { > > > > > > > > +public: > > > > > > > > > > > > > > Why is this class in WebCore? In what scenarios do we see WebCore needing to > > > > > > > use XPC endpoints directly? > > > > > > > > > > > > I moved this to WebCore to be able to unit test the classes by exporting > > > > > > symbols with WEBCORE_EXPORT. But perhaps there is another define for > > > > > > exporting symbols from WebKit? > > > > > > > > > > Yeah, that's what WK_EXPORT does. > > > > > > > > > > > > > Ah, I see! I will move the classes back to WebKit. > > > > > > > > > I am also not certain that XPCEndpoint really needs a wrapper class, it > > > > > really doesn't expose enough API for it to seem warranted. We generally > > > > > don't wrap classes just because, but rather to create abstractions for > > > > > multiple ports, and that doesn't apply here. It seems like using > > > > > OSObjectPtr<xpc_endpoint_t> is likely fine. > > > > > > > > I actually intended for them to be more than just wrappers. There is > > > > additional code in these classes to create and establish the XPC connection > > > > with the endpoint, as well as checking that the other end really is a WebKit > > > > process before initiating communication. Perhaps they would benefit from > > > > being renamed? > > > > > > Yes, if you intend for them to be more than what xpc_endpoint_t's do, I > > > think we are better off with a different name. Otherwise, it will be quite > > > confusing. > > > > > > Can you explain a bit more about what the use case here is? I am really not > > > sure this is the right way to go. Adding more IPC primitives is something we > > > should do very carefully. It's really easy to get this stuff wrong. > > > > Yes, the use case is to send the Launch Services database represented in an > > XPC object from the Networking process to the WebContent process; see > > https://bugs.webkit.org/show_bug.cgi?id=213794. The database is only > > available as an XPC object, so it cannot be sent over the existing CoreIPC > > connection between the Networking and WebContent process. The Networking > > process was chosen as the source, since we are controlling its sandbox, > > making sure that the database is available for sending in the Networking > > process. > > I'm trying to follow the logic in that other patch, but it's pretty gnarly. > It seems like it sets things up so, at least in the web process, messages > are coming in both over the mach port and over the xpc connection. > > It really seems like what this is asking for is to just switch to using xpc > messaging for CoreIPC (e.g. each CoreIPC message on Darwin platforms gets > encoded as one xpc_data, and not using xpc_object encoding in the more > traditional sense). > > I would really like you to reconsider the amount of complexity this current > system you have written adds, and whether it is the right trade off. I think > if you spend a bit more time working through the design, you could come up > with something much cleaner, that doesn't add new primitives and doesn't add > platform specific code into platform agnostic classes. That it a good point. So if I understand you correctly, we should aim to replace the current CoreIPC connection between the Networking process and the WebContent process with an XPC connection? I think that makes sense, since it will allow us to send XPC objects over this connection. Are there some performance benefits to a low level CoreIPC connection? Or security benefits? Thanks for reviewing! 1670234 15 sam 2020-07-09 12:48:00 -0700 (In reply to Per Arne Vollan from comment #14) > (In reply to Sam Weinig from comment #13) > > (In reply to Per Arne Vollan from comment #12) > > > (In reply to Sam Weinig from comment #11) > > > > (In reply to Per Arne Vollan from comment #10) > > > > > (In reply to Sam Weinig from comment #9) > > > > > > (In reply to Per Arne Vollan from comment #8) > > > > > > > (In reply to Sam Weinig from comment #7) > > > > > > > > Comment on attachment 403799 [details] > > > > > > > > Patch > > > > > > > > > > > > > > > > View in context: > > > > > > > > https://bugs.webkit.org/attachment.cgi?id=403799&action=review > > > > > > > > > > > > > > > > > Source/WebCore/platform/cocoa/XPCEndpoint.h:34 > > > > > > > > > +class XPCEndpoint { > > > > > > > > > +public: > > > > > > > > > > > > > > > > Why is this class in WebCore? In what scenarios do we see WebCore needing to > > > > > > > > use XPC endpoints directly? > > > > > > > > > > > > > > I moved this to WebCore to be able to unit test the classes by exporting > > > > > > > symbols with WEBCORE_EXPORT. But perhaps there is another define for > > > > > > > exporting symbols from WebKit? > > > > > > > > > > > > Yeah, that's what WK_EXPORT does. > > > > > > > > > > > > > > > > Ah, I see! I will move the classes back to WebKit. > > > > > > > > > > > I am also not certain that XPCEndpoint really needs a wrapper class, it > > > > > > really doesn't expose enough API for it to seem warranted. We generally > > > > > > don't wrap classes just because, but rather to create abstractions for > > > > > > multiple ports, and that doesn't apply here. It seems like using > > > > > > OSObjectPtr<xpc_endpoint_t> is likely fine. > > > > > > > > > > I actually intended for them to be more than just wrappers. There is > > > > > additional code in these classes to create and establish the XPC connection > > > > > with the endpoint, as well as checking that the other end really is a WebKit > > > > > process before initiating communication. Perhaps they would benefit from > > > > > being renamed? > > > > > > > > Yes, if you intend for them to be more than what xpc_endpoint_t's do, I > > > > think we are better off with a different name. Otherwise, it will be quite > > > > confusing. > > > > > > > > Can you explain a bit more about what the use case here is? I am really not > > > > sure this is the right way to go. Adding more IPC primitives is something we > > > > should do very carefully. It's really easy to get this stuff wrong. > > > > > > Yes, the use case is to send the Launch Services database represented in an > > > XPC object from the Networking process to the WebContent process; see > > > https://bugs.webkit.org/show_bug.cgi?id=213794. The database is only > > > available as an XPC object, so it cannot be sent over the existing CoreIPC > > > connection between the Networking and WebContent process. The Networking > > > process was chosen as the source, since we are controlling its sandbox, > > > making sure that the database is available for sending in the Networking > > > process. > > > > I'm trying to follow the logic in that other patch, but it's pretty gnarly. > > It seems like it sets things up so, at least in the web process, messages > > are coming in both over the mach port and over the xpc connection. > > > > It really seems like what this is asking for is to just switch to using xpc > > messaging for CoreIPC (e.g. each CoreIPC message on Darwin platforms gets > > encoded as one xpc_data, and not using xpc_object encoding in the more > > traditional sense). > > > > I would really like you to reconsider the amount of complexity this current > > system you have written adds, and whether it is the right trade off. I think > > if you spend a bit more time working through the design, you could come up > > with something much cleaner, that doesn't add new primitives and doesn't add > > platform specific code into platform agnostic classes. > > That it a good point. So if I understand you correctly, we should aim to > replace the current CoreIPC connection between the Networking process and > the WebContent process with an XPC connection? I think that makes sense, > since it will allow us to send XPC objects over this connection. Are there > some performance benefits to a low level CoreIPC connection? Or security > benefits? > > Thanks for reviewing! I can't remember all the details, but if memory and a little digging serve me, the way we establish a connection between the network process and WebContent processes is by passing a IPC::Connection::Identifier (which contains a machport) to the WebContent process (this is in the sync message from the WebProcess to the UIProcess called Messages::WebProcessProxy::GetNetworkProcessConnection(). The sync thing is another whole issue for another day). If we used xpc as the underlying transport, rather than just for bootstrapping our machports, we could replace the machport in IPC::Connection::Identifier with an xpc_endpoint_t, and establish the connection by creating a new CoreIPC::Connection from the endpoint, rather than the machport. As for you questions about benefits / tradeoffs, the tradeoff is a little less flexibility (you can play a lot of tricks using machports directly) and potentially a tiny bit of performance, but that would have to be measured, I can't actually be sure of that. What we would gain quite a bit. We would be able to interact with system in a more coherent way, working better with scheduling and boosting, of which WebKit currently does a pretty hacky job. We would also be able to send things like xpc_enpoints directly, rather than requiring a side channel connection for them. 1670248 16 pvollan 2020-07-09 13:17:07 -0700 (In reply to Per Arne Vollan from comment #14) > (In reply to Sam Weinig from comment #13) > > (In reply to Per Arne Vollan from comment #12) > > > (In reply to Sam Weinig from comment #11) > > > > (In reply to Per Arne Vollan from comment #10) > > > > > (In reply to Sam Weinig from comment #9) > > > > > > (In reply to Per Arne Vollan from comment #8) > > > > > > > (In reply to Sam Weinig from comment #7) > > > > > > > > Comment on attachment 403799 [details] > > > > > > > > Patch > > > > > > > > > > > > > > > > View in context: > > > > > > > > https://bugs.webkit.org/attachment.cgi?id=403799&action=review > > > > > > > > > > > > > > > > > Source/WebCore/platform/cocoa/XPCEndpoint.h:34 > > > > > > > > > +class XPCEndpoint { > > > > > > > > > +public: > > > > > > > > > > > > > > > > Why is this class in WebCore? In what scenarios do we see WebCore needing to > > > > > > > > use XPC endpoints directly? > > > > > > > > > > > > > > I moved this to WebCore to be able to unit test the classes by exporting > > > > > > > symbols with WEBCORE_EXPORT. But perhaps there is another define for > > > > > > > exporting symbols from WebKit? > > > > > > > > > > > > Yeah, that's what WK_EXPORT does. > > > > > > > > > > > > > > > > Ah, I see! I will move the classes back to WebKit. > > > > > > > > > > > I am also not certain that XPCEndpoint really needs a wrapper class, it > > > > > > really doesn't expose enough API for it to seem warranted. We generally > > > > > > don't wrap classes just because, but rather to create abstractions for > > > > > > multiple ports, and that doesn't apply here. It seems like using > > > > > > OSObjectPtr<xpc_endpoint_t> is likely fine. > > > > > > > > > > I actually intended for them to be more than just wrappers. There is > > > > > additional code in these classes to create and establish the XPC connection > > > > > with the endpoint, as well as checking that the other end really is a WebKit > > > > > process before initiating communication. Perhaps they would benefit from > > > > > being renamed? > > > > > > > > Yes, if you intend for them to be more than what xpc_endpoint_t's do, I > > > > think we are better off with a different name. Otherwise, it will be quite > > > > confusing. > > > > > > > > Can you explain a bit more about what the use case here is? I am really not > > > > sure this is the right way to go. Adding more IPC primitives is something we > > > > should do very carefully. It's really easy to get this stuff wrong. > > > > > > Yes, the use case is to send the Launch Services database represented in an > > > XPC object from the Networking process to the WebContent process; see > > > https://bugs.webkit.org/show_bug.cgi?id=213794. The database is only > > > available as an XPC object, so it cannot be sent over the existing CoreIPC > > > connection between the Networking and WebContent process. The Networking > > > process was chosen as the source, since we are controlling its sandbox, > > > making sure that the database is available for sending in the Networking > > > process. > > > > I'm trying to follow the logic in that other patch, but it's pretty gnarly. > > It seems like it sets things up so, at least in the web process, messages > > are coming in both over the mach port and over the xpc connection. > > > > It really seems like what this is asking for is to just switch to using xpc > > messaging for CoreIPC (e.g. each CoreIPC message on Darwin platforms gets > > encoded as one xpc_data, and not using xpc_object encoding in the more > > traditional sense). > > > > I would really like you to reconsider the amount of complexity this current > > system you have written adds, and whether it is the right trade off. I think > > if you spend a bit more time working through the design, you could come up > > with something much cleaner, that doesn't add new primitives and doesn't add > > platform specific code into platform agnostic classes. > > That it a good point. So if I understand you correctly, we should aim to > replace the current CoreIPC connection between the Networking process and > the WebContent process with an XPC connection? I think that makes sense, > since it will allow us to send XPC objects over this connection. Are there > some performance benefits to a low level CoreIPC connection? Or security > benefits? > > Thanks for reviewing! (In reply to Sam Weinig from comment #15) > (In reply to Per Arne Vollan from comment #14) > > (In reply to Sam Weinig from comment #13) > > > (In reply to Per Arne Vollan from comment #12) > > > > (In reply to Sam Weinig from comment #11) > > > > > (In reply to Per Arne Vollan from comment #10) > > > > > > (In reply to Sam Weinig from comment #9) > > > > > > > (In reply to Per Arne Vollan from comment #8) > > > > > > > > (In reply to Sam Weinig from comment #7) > > > > > > > > > Comment on attachment 403799 [details] > > > > > > > > > Patch > > > > > > > > > > > > > > > > > > View in context: > > > > > > > > > https://bugs.webkit.org/attachment.cgi?id=403799&action=review > > > > > > > > > > > > > > > > > > > Source/WebCore/platform/cocoa/XPCEndpoint.h:34 > > > > > > > > > > +class XPCEndpoint { > > > > > > > > > > +public: > > > > > > > > > > > > > > > > > > Why is this class in WebCore? In what scenarios do we see WebCore needing to > > > > > > > > > use XPC endpoints directly? > > > > > > > > > > > > > > > > I moved this to WebCore to be able to unit test the classes by exporting > > > > > > > > symbols with WEBCORE_EXPORT. But perhaps there is another define for > > > > > > > > exporting symbols from WebKit? > > > > > > > > > > > > > > Yeah, that's what WK_EXPORT does. > > > > > > > > > > > > > > > > > > > Ah, I see! I will move the classes back to WebKit. > > > > > > > > > > > > > I am also not certain that XPCEndpoint really needs a wrapper class, it > > > > > > > really doesn't expose enough API for it to seem warranted. We generally > > > > > > > don't wrap classes just because, but rather to create abstractions for > > > > > > > multiple ports, and that doesn't apply here. It seems like using > > > > > > > OSObjectPtr<xpc_endpoint_t> is likely fine. > > > > > > > > > > > > I actually intended for them to be more than just wrappers. There is > > > > > > additional code in these classes to create and establish the XPC connection > > > > > > with the endpoint, as well as checking that the other end really is a WebKit > > > > > > process before initiating communication. Perhaps they would benefit from > > > > > > being renamed? > > > > > > > > > > Yes, if you intend for them to be more than what xpc_endpoint_t's do, I > > > > > think we are better off with a different name. Otherwise, it will be quite > > > > > confusing. > > > > > > > > > > Can you explain a bit more about what the use case here is? I am really not > > > > > sure this is the right way to go. Adding more IPC primitives is something we > > > > > should do very carefully. It's really easy to get this stuff wrong. > > > > > > > > Yes, the use case is to send the Launch Services database represented in an > > > > XPC object from the Networking process to the WebContent process; see > > > > https://bugs.webkit.org/show_bug.cgi?id=213794. The database is only > > > > available as an XPC object, so it cannot be sent over the existing CoreIPC > > > > connection between the Networking and WebContent process. The Networking > > > > process was chosen as the source, since we are controlling its sandbox, > > > > making sure that the database is available for sending in the Networking > > > > process. > > > > > > I'm trying to follow the logic in that other patch, but it's pretty gnarly. > > > It seems like it sets things up so, at least in the web process, messages > > > are coming in both over the mach port and over the xpc connection. > > > > > > It really seems like what this is asking for is to just switch to using xpc > > > messaging for CoreIPC (e.g. each CoreIPC message on Darwin platforms gets > > > encoded as one xpc_data, and not using xpc_object encoding in the more > > > traditional sense). > > > > > > I would really like you to reconsider the amount of complexity this current > > > system you have written adds, and whether it is the right trade off. I think > > > if you spend a bit more time working through the design, you could come up > > > with something much cleaner, that doesn't add new primitives and doesn't add > > > platform specific code into platform agnostic classes. > > > > That it a good point. So if I understand you correctly, we should aim to > > replace the current CoreIPC connection between the Networking process and > > the WebContent process with an XPC connection? I think that makes sense, > > since it will allow us to send XPC objects over this connection. Are there > > some performance benefits to a low level CoreIPC connection? Or security > > benefits? > > > > Thanks for reviewing! > > I can't remember all the details, but if memory and a little digging serve > me, the way we establish a connection between the network process and > WebContent processes is by passing a IPC::Connection::Identifier (which > contains a machport) to the WebContent process (this is in the sync message > from the WebProcess to the UIProcess called > Messages::WebProcessProxy::GetNetworkProcessConnection(). The sync thing is > another whole issue for another day). > > If we used xpc as the underlying transport, rather than just for > bootstrapping our machports, we could replace the machport in > IPC::Connection::Identifier with an xpc_endpoint_t, and establish the > connection by creating a new CoreIPC::Connection from the endpoint, rather > than the machport. > > As for you questions about benefits / tradeoffs, the tradeoff is a little > less flexibility (you can play a lot of tricks using machports directly) and > potentially a tiny bit of performance, but that would have to be measured, I > can't actually be sure of that. > > What we would gain quite a bit. We would be able to interact with system in > a more coherent way, working better with scheduling and boosting, of which > WebKit currently does a pretty hacky job. We would also be able to send > things like xpc_enpoints directly, rather than requiring a side channel > connection for them. Sounds good. We could also stop creating CoreIPC connections between the UI process and the Networking/WebContent process. We could just reuse the bootstrap XPC connection. I think we should do it :) 403777 2020-07-08 07:04:37 -0700 2020-07-08 11:23:41 -0700 Patch bug-214079-20200708070436.patch text/plain 30238 pvollan SW5kZXg6IFNvdXJjZS9XVEYvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvQ2hh bmdlTG9nCShyZXZpc2lvbiAyNjQwMzkpCisrKyBTb3VyY2UvV1RGL0NoYW5nZUxvZwkod29ya2lu ZyBjb3B5KQpAQCAtMSwzICsxLDE0IEBACisyMDIwLTA3LTAyICBQZXIgQXJuZSBWb2xsYW4gIDxw dm9sbGFuQGFwcGxlLmNvbT4KKworICAgICAgICBbQ29jb2FdIFVwZGF0ZSBMYXVuY2ggU2Vydmlj ZXMgZGF0YWJhc2UgaW4gdGhlIFdlYkNvbnRlbnQgcHJvY2VzcyBmcm9tIHRoZSBOZXR3b3JrIHBy b2Nlc3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIx Mzc5NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIERl Y2xhcmUgZnVuY3Rpb24gdG8gY3JlYXRlIGEgeHBjIGVuZHBvaW50LCBhcyB3ZWxsIGFzIGEgZnVu Y3Rpb24gdG8gY3JlYXRlIGEgY29ubmVjdGlvbiBmcm9tIGFuIGVuZHBvaW50LgorCisgICAgICAg ICogd3RmL3NwaS9kYXJ3aW4vWFBDU1BJLmg6CisKIDIwMjAtMDctMDcgIENhcmxvcyBHYXJjaWEg Q2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdIFdlYlByb2Nlc3Mg aGFuZ3Mgd2hlbiBicm93c2luZyBHaXRIdWIKSW5kZXg6IFNvdXJjZS9XVEYvd3RmL3NwaS9kYXJ3 aW4vWFBDU1BJLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dURi93dGYvc3BpL2Rhcndpbi9YUENT UEkuaAkocmV2aXNpb24gMjY0MDM5KQorKysgU291cmNlL1dURi93dGYvc3BpL2Rhcndpbi9YUENT UEkuaAkod29ya2luZyBjb3B5KQpAQCAtNDksNiArNDksNyBAQCBzdGF0aWMgQUxXQVlTX0lOTElO RSB2b2lkIF94cGNfb2JqZWN0X3ZhCiAKIHR5cGVkZWYgdm9pZCogeHBjX29iamVjdF90OwogdHlw ZWRlZiB2b2lkKiB4cGNfY29ubmVjdGlvbl90OwordHlwZWRlZiB2b2lkKiB4cGNfZW5kcG9pbnRf dDsKIAogI2RlZmluZSBYUENfR0xPQkFMX09CSkVDVChvYmplY3QpICgmKG9iamVjdCkpCiAKQEAg LTEyMSw2ICsxMjIsOCBAQCB2b2lkIHhwY19hcnJheV9zZXRfc3RyaW5nKHhwY19vYmplY3RfdCwg CiBib29sIHhwY19ib29sX2dldF92YWx1ZSh4cGNfb2JqZWN0X3QpOwogdm9pZCB4cGNfY29ubmVj dGlvbl9jYW5jZWwoeHBjX2Nvbm5lY3Rpb25fdCk7CiB4cGNfY29ubmVjdGlvbl90IHhwY19jb25u ZWN0aW9uX2NyZWF0ZShjb25zdCBjaGFyKiBuYW1lLCBkaXNwYXRjaF9xdWV1ZV90KTsKK3hwY19l bmRwb2ludF90IHhwY19lbmRwb2ludF9jcmVhdGUoeHBjX2Nvbm5lY3Rpb25fdCk7Cit4cGNfY29u bmVjdGlvbl90IHhwY19jb25uZWN0aW9uX2NyZWF0ZV9mcm9tX2VuZHBvaW50KHhwY19lbmRwb2lu dF90KTsKIHhwY19jb25uZWN0aW9uX3QgeHBjX2Nvbm5lY3Rpb25fY3JlYXRlX21hY2hfc2Vydmlj ZShjb25zdCBjaGFyKiBuYW1lLCBkaXNwYXRjaF9xdWV1ZV90LCB1aW50NjRfdCBmbGFncyk7CiBw aWRfdCB4cGNfY29ubmVjdGlvbl9nZXRfcGlkKHhwY19jb25uZWN0aW9uX3QpOwogdm9pZCB4cGNf Y29ubmVjdGlvbl9yZXN1bWUoeHBjX2Nvbm5lY3Rpb25fdCk7CkluZGV4OiBTb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCShyZXZp c2lvbiAyNjQwMzkpCisrKyBTb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkK QEAgLTEsMyArMSwzMSBAQAorMjAyMC0wNy0wNyAgUGVyIEFybmUgVm9sbGFuICA8cHZvbGxhbkBh cHBsZS5jb20+CisKKyAgICAgICAgW0NvY29hXSBVcGRhdGUgTGF1bmNoIFNlcnZpY2VzIGRhdGFi YXNlIGluIHRoZSBXZWJDb250ZW50IHByb2Nlc3MgZnJvbSB0aGUgTmV0d29yayBwcm9jZXNzCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTM3OTQKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgYWJzdHJh Y3QgY2xhc3NlcyBYUENFbmRwb2ludCBhbmQgWFBDRW5kcG9pbnRDbGllbnQgdG8gaGFuZGxlIHRo ZSBjcmVhdGlvbiBvZiBkaXJlY3QgeHBjIGNvbm5lY3Rpb25zIGJldHdlZW4gV2ViS2l0IHByb2Nl c3Nlcy4KKyAgICAgICAgSW4gb3JkZXIgdG8gY3JlYXRlIGEgZGlyZWN0IHhwYyBjb25uZWN0aW9u IGJldHdlZW4gdHdvIHByb2Nlc3NlcywgdGhlc2UgdHdvIGNsYXNzZXMgY2FuIGJlIHN1YmNsYXNz ZWQsIGFuZCB0aGUgeHBjIGVuZHBvaW50IGNyZWF0ZWQKKyAgICAgICAgYnkgdGhlIFhQQ0VuZHBv aW50IG9iamVjdCwgY2FuIGJlIHNlbnQgdmlhIHRoZSBVSSBwcm9jZXNzIG92ZXIgdGhlIGJvb3Rz dHJhcCB4cGMgY29ubmVjdGlvbi4gVGhlIFVJIHByb2Nlc3MgY2FuIHRoZW4gZm9yd2FyZCB0aGlz CisgICAgICAgIGVuZHBvaW50IHRvIGFub3RoZXIgV2ViS2l0IHByb2Nlc3MgYnkgc2VuZGluZyBp dCBvdmVyIHRoZSBib290c3RyYXAgeHBjIGNvbm5lY3Rpb24uIFRoZSByZWNlaXZpbmcgcHJvY2Vz cyBjYW4gdGhlbiBpbml0aWFsaXplIGFuCisgICAgICAgIFhQQ0VuZHBvaW50Q2xpZW50IG9iamVj dCB3aXRoIHRoaXMgZW5kcG9pbnQsIGFuZCBhIG5ldyBkaXJlY3QgY29ubmVjdGlvbiB3aWxsIHRo ZW4gYmUgYXZhaWxhYmxlLCBvdmVyIHdoaWNoIHRoZSB0d28gcHJvY2Vzc2VzIGNhbgorICAgICAg ICBjb21tdW5pY2F0ZS4KKworICAgICAgICBBUEkgdGVzdDogV2ViS2l0LlhQQ0VuZHBvaW50CisK KyAgICAgICAgKiBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICog cGxhdGZvcm0vY29jb2EvWFBDRW5kcG9pbnQuaDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0v Y29jb2EvWFBDRW5kcG9pbnQubW06IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6WFBDRW5kcG9p bnQ6OlhQQ0VuZHBvaW50KToKKyAgICAgICAgKFdlYkNvcmU6OlhQQ0VuZHBvaW50OjpzZW5kRW5k cG9pbnRUb0Nvbm5lY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6WFBDRW5kcG9pbnQ6OmVuZHBv aW50IGNvbnN0KToKKyAgICAgICAgKiBwbGF0Zm9ybS9jb2NvYS9YUENFbmRwb2ludENsaWVudC5o OiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlhQQ0VuZHBvaW50Q2xpZW50Ojp+WFBDRW5kcG9p bnRDbGllbnQpOgorICAgICAgICAqIHBsYXRmb3JtL2NvY29hL1hQQ0VuZHBvaW50Q2xpZW50Lm1t OiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlhQQ0VuZHBvaW50Q2xpZW50OjpzZXRFbmRwb2lu dCk6CisgICAgICAgIChXZWJDb3JlOjpYUENFbmRwb2ludENsaWVudDo6Y29ubmVjdGlvbik6CisK IDIwMjAtMDctMDcgIEFuZHJlcyBHb256YWxleiAgPGFuZHJlc2dfMjJAYXBwbGUuY29tPgogCiAg ICAgICAgIFdlYiBjb250ZW50IHByb2Nlc3MgaGFuZ3MgaW4gQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdDo6c2V0U2VsZWN0ZWRWaXNpYmxlUG9zaXRpb25SYW5nZSBpbiBzb21lIGNvcm5lciBjYXNl cy4KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv ago9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0 LnBieHByb2oJKHJldmlzaW9uIDI2NDAzOSkKKysrIFNvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNv ZGVwcm9qL3Byb2plY3QucGJ4cHJvagkod29ya2luZyBjb3B5KQpAQCAtNDAwMiw2ICs0MDAyLDEw IEBACiAJCUMxNDlENTVEMjQyRUE2QjkwMDNFQkIxMiAvKiBTbGVlcERpc2FibGVyLmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDMTQ5RDU1QTI0MkVBNEY5 MDAzRUJCMTIgLyogU2xlZXBEaXNhYmxlci5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0g KFByaXZhdGUsICk7IH07IH07CiAJCUMxNDlENTVGMjQyRUE3QjgwMDNFQkIxMiAvKiBTbGVlcERp c2FibGVyQ2xpZW50LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSBDMTQ5RDU1QjI0MkVBNEZBMDAzRUJCMTIgLyogU2xlZXBEaXNhYmxlckNsaWVudC5oICov OyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUMxNDlENTY3 MjQyRUI4NEEwMDNFQkIxMiAvKiBTbGVlcERpc2FibGVySWRlbnRpZmllci5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzE0OUQ1NjUyNDJFQjc2NTAwM0VC QjEyIC8qIFNsZWVwRGlzYWJsZXJJZGVudGlmaWVyLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVU RVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKKwkJQzE0RDMwNDkyNEI0RUFCMTAwNDgwMzg3IC8qIFhQ Q0VuZHBvaW50LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSBDMTREMzA0NzI0QjRFQUE4MDA0ODAzODcgLyogWFBDRW5kcG9pbnQuaCAqLzsgc2V0dGluZ3Mg PSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQlDMTREMzA0QjI0QjRGN0VGMDA0 ODAzODcgLyogWFBDRW5kcG9pbnQubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBDMTREMzA0QTI0QjRFQjFFMDA0ODAzODcgLyogWFBDRW5kcG9pbnQubW0g Ki87IH07CisJCUMxNEQzMDRFMjRCNEY4RkEwMDQ4MDM4NyAvKiBYUENFbmRwb2ludENsaWVudC5t bSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEMxNEQzMDRD MjRCNEY4RjYwMDQ4MDM4NyAvKiBYUENFbmRwb2ludENsaWVudC5tbSAqLzsgfTsKKwkJQzE0RDMw NEYyNEI0RjhGRjAwNDgwMzg3IC8qIFhQQ0VuZHBvaW50Q2xpZW50LmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDMTREMzA0RDI0QjRGOEY3MDA0ODAzODcg LyogWFBDRW5kcG9pbnRDbGllbnQuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2 YXRlLCApOyB9OyB9OwogCQlDMTY5MkREMjIzRDIzQUJEMDA2RTg4RjcgLyogU3lzdGVtQmF0dGVy eS5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEMxNjky REQxMjNEMjNBQkQwMDZFODhGNyAvKiBTeXN0ZW1CYXR0ZXJ5Lm1tICovOyB9OwogCQlDMTY5MkRE NTIzRDIzRTA4MDA2RTg4RjcgLyogU3lzdGVtQmF0dGVyeS5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzE2OTJERDQyM0QyM0FFMDAwNkU4OEY3IC8qIFN5 c3RlbUJhdHRlcnkuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9 OyB9OwogCQlDMUUxRDIzNjIwM0RGMTU0MDA1ODQ2NjUgLyogU2NyZWVuUHJvcGVydGllcy5oIGlu IEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzFFMUQyMzUyMDNE RjE1NDAwNTg0NjY1IC8qIFNjcmVlblByb3BlcnRpZXMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklC VVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwpAQCAtMTM3MzAsNiArMTM3MzQsMTAgQEAKIAkJQzE0 OUQ1NUEyNDJFQTRGOTAwM0VCQjEyIC8qIFNsZWVwRGlzYWJsZXIuaCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuYy5oOyBwYXRoID0gU2xlZXBEaXNhYmxlci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQlDMTQ5RDU1QjI0MkVBNEZBMDAzRUJCMTIgLyogU2xlZXBEaXNhYmxlckNsaWVudC5o ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBTbGVlcERpc2FibGVyQ2xpZW50Lmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUMxNDlENTY1MjQyRUI3NjUwMDNFQkIxMiAv KiBTbGVlcERpc2FibGVySWRlbnRpZmllci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBTbGVlcERpc2FibGVy SWRlbnRpZmllci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDMTREMzA0NzI0QjRF QUE4MDA0ODAzODcgLyogWFBDRW5kcG9pbnQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBw YXRoID0gWFBDRW5kcG9pbnQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJQzE0RDMw NEEyNEI0RUIxRTAwNDgwMzg3IC8qIFhQQ0VuZHBvaW50Lm1tICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAub2JqY3BwOyBwYXRoID0gWFBDRW5kcG9pbnQubW07IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CisJCUMxNEQzMDRDMjRCNEY4RjYwMDQ4MDM4NyAvKiBYUENFbmRwb2ludENsaWVudC5t bSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFhQQ0VuZHBvaW50Q2xp ZW50Lm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDMTREMzA0RDI0QjRGOEY3MDA0 ODAzODcgLyogWFBDRW5kcG9pbnRDbGllbnQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBw YXRoID0gWFBDRW5kcG9pbnRDbGllbnQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ QzE2OTJERDEyM0QyM0FCRDAwNkU4OEY3IC8qIFN5c3RlbUJhdHRlcnkubW0gKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpj cHA7IHBhdGggPSBTeXN0ZW1CYXR0ZXJ5Lm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQlDMTY5MkRENDIzRDIzQUUwMDA2RTg4RjcgLyogU3lzdGVtQmF0dGVyeS5oICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBTeXN0ZW1CYXR0ZXJ5Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUMxOEZC NTE4MjQyRjkzODIwMDdFOTg3NSAvKiBTbGVlcERpc2FibGVyQ2xpZW50LmNwcCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNw cDsgcGF0aCA9IFNsZWVwRGlzYWJsZXJDbGllbnQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwpAQCAtMjM2MzIsNiArMjM2NDAsMTAgQEAKIAkJCQlDREM5NzlGMzFDNDk4QzA5MDBEQjUw RDQgLyogV2ViQ29yZU5TRXJyb3JFeHRyYXMuaCAqLywKIAkJCQlDREM5NzlGMjFDNDk4QzA5MDBE QjUwRDQgLyogV2ViQ29yZU5TRXJyb3JFeHRyYXMubW0gKi8sCiAJCQkJNURGRUJBQjYxODU5MkI2 RDAwQzc1QkVCIC8qIFdlYktpdEF2YWlsYWJpbGl0eS5oICovLAorCQkJCUMxNEQzMDQ3MjRCNEVB QTgwMDQ4MDM4NyAvKiBYUENFbmRwb2ludC5oICovLAorCQkJCUMxNEQzMDRBMjRCNEVCMUUwMDQ4 MDM4NyAvKiBYUENFbmRwb2ludC5tbSAqLywKKwkJCQlDMTREMzA0RDI0QjRGOEY3MDA0ODAzODcg LyogWFBDRW5kcG9pbnRDbGllbnQuaCAqLywKKwkJCQlDMTREMzA0QzI0QjRGOEY2MDA0ODAzODcg LyogWFBDRW5kcG9pbnRDbGllbnQubW0gKi8sCiAJCQkpOwogCQkJcGF0aCA9IGNvY29hOwogCQkJ c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsKQEAgLTMwMDk3LDYgKzMwMTA5LDcgQEAKIAkJCQlDMzdD REVCRDE0OUVGMjAzMDA0MjA5MEQgLyogQ29sb3JDaG9vc2VyQ2xpZW50LmggaW4gSGVhZGVycyAq LywKIAkJCQlGNDhEMkFBNTIxNTk3NDBEMDBDNjc1MkIgLyogQ29sb3JDb2NvYS5oIGluIEhlYWRl cnMgKi8sCiAJCQkJN0NBQzZBRjAyNDdGNDExMDAwRTYxRDU5IC8qIENvbG9yQ29tcG9uZW50cy5o IGluIEhlYWRlcnMgKi8sCisJCQkJN0M1MTRFMDMyNEFGODA1RTAwNTA3MTBGIC8qIENvbG9yQ29u dmVyc2lvbi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMzEwM0I3REYxREIwMTU2NzAwOEJCODkwIC8q IENvbG9ySGFzaC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJRjU1QjNEQjQxMjUxRjEyRDAwM0VGMjY5 IC8qIENvbG9ySW5wdXRUeXBlLmggaW4gSGVhZGVycyAqLywKIAkJCQlDRTUxNjlFNzIxRjFCODQ3 MDBFQTRGNzggLyogQ29sb3JJT1MuaCBpbiBIZWFkZXJzICovLApAQCAtMzM5MjMsNyArMzM5MzYs NiBAQAogCQkJCTkxMjc4RDYyMjFERURBRjAwMEI1NzE4NCAvKiBXb3JrZXJBdWRpdEFnZW50Lmgg aW4gSGVhZGVycyAqLywKIAkJCQk0MUE3RDM1MzFGNDM4RDE2MDA4OTg4REUgLyogV29ya2VyQ2Fj aGVTdG9yYWdlQ29ubmVjdGlvbi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTVCODFDQ0QxRkFBNDRE RTAwMzdEMUU2IC8qIFdvcmtlckNvbnNvbGVBZ2VudC5oIGluIEhlYWRlcnMgKi8sCi0JCQkJN0M1 MTRFMDMyNEFGODA1RTAwNTA3MTBGIC8qIENvbG9yQ29udmVyc2lvbi5oIGluIEhlYWRlcnMgKi8s CiAJCQkJQTU1NjM5RDExQzZGMDlFMzAwODA2RDhFIC8qIFdvcmtlckNvbnNvbGVDbGllbnQuaCBp biBIZWFkZXJzICovLAogCQkJCUE1QjgxQ0NFMUZBQTQ0REUwMDM3RDFFNiAvKiBXb3JrZXJEZWJ1 Z2dlckFnZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlBNTJCMzQ5RTFGQTQxNzAzMDA4QjYyNDYg LyogV29ya2VyRGVidWdnZXJQcm94eS5oIGluIEhlYWRlcnMgKi8sCkBAIC0zMzk5MCw2ICszNDAw Miw4IEBACiAJCQkJMUFCN0ZDODQwQThCOTJFQzAwRDlEMzdCIC8qIFhQYXRoVXRpbC5oIGluIEhl YWRlcnMgKi8sCiAJCQkJMUFCN0ZDODYwQThCOTJFQzAwRDlEMzdCIC8qIFhQYXRoVmFsdWUuaCBp biBIZWFkZXJzICovLAogCQkJCTFBQjdGQzg4MEE4QjkyRUMwMEQ5RDM3QiAvKiBYUGF0aFZhcmlh YmxlUmVmZXJlbmNlLmggaW4gSGVhZGVycyAqLywKKwkJCQlDMTREMzA0OTI0QjRFQUIxMDA0ODAz ODcgLyogWFBDRW5kcG9pbnQuaCBpbiBIZWFkZXJzICovLAorCQkJCUMxNEQzMDRGMjRCNEY4RkYw MDQ4MDM4NyAvKiBYUENFbmRwb2ludENsaWVudC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJRTFFRThC OUMyNDEzMTk1MDAwRTc5NEQ2IC8qIFhSRW52aXJvbm1lbnRCbGVuZE1vZGUuaCBpbiBIZWFkZXJz ICovLAogCQkJCUUxRUU4Qjk3MjQxMzE5NTAwMEU3OTRENiAvKiBYUkV5ZS5oIGluIEhlYWRlcnMg Ki8sCiAJCQkJRTFFRThCOEYyNDEzMTk1MDAwRTc5NEQ2IC8qIFhSRnJhbWVSZXF1ZXN0Q2FsbGJh Y2suaCBpbiBIZWFkZXJzICovLApAQCAtMzUxODUsNiArMzUxOTksOCBAQAogCQkJCUE4MzNDN0ND MEEyQ0YwNzQwMEQ1NzY2NCAvKiBYTGlua05hbWVzLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUE4 MzNDODBDMEEyQ0YyNTYwMEQ1NzY2NCAvKiBYTUxOYW1lcy5jcHAgaW4gU291cmNlcyAqLywKIAkJ CQlFMTVBMzZEOTExMDQ1NzI3MDBCN0I2MzkgLyogWE1MTlNOYW1lcy5jcHAgaW4gU291cmNlcyAq LywKKwkJCQlDMTREMzA0QjI0QjRGN0VGMDA0ODAzODcgLyogWFBDRW5kcG9pbnQubW0gaW4gU291 cmNlcyAqLywKKwkJCQlDMTREMzA0RTI0QjRGOEZBMDA0ODAzODcgLyogWFBDRW5kcG9pbnRDbGll bnQubW0gaW4gU291cmNlcyAqLywKIAkJCQlFMUVFOEI3QTI0MTMxOTFGMDBFNzk0RDYgLyogWFJJ bnB1dFNvdXJjZUV2ZW50LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUUxRUU4QkE3MjQxMzE5NjMw MEU3OTRENiAvKiBYUklucHV0U291cmNlc0NoYW5nZUV2ZW50LmNwcCBpbiBTb3VyY2VzICovLAog CQkJCUUxRUU4Qjk1MjQxMzE5NTAwMEU3OTRENiAvKiBYUlJlZmVyZW5jZVNwYWNlRXZlbnQuY3Bw IGluIFNvdXJjZXMgKi8sCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9jb2NvYS9YUENF bmRwb2ludC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29hL1hQ Q0VuZHBvaW50LmgJKG5vbmV4aXN0ZW50KQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vY29j b2EvWFBDRW5kcG9pbnQuaAkod29ya2luZyBjb3B5KQpAQCAtMCwwICsxLDU0IEBACisvKgorICog Q29weXJpZ2h0IChDKSAyMDIwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0 aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1 Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlv bi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElU UyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBX QVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElO Qy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJ UkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElB TCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YK KyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQg T04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJ Q1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up CisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisg Ki8KKworI3ByYWdtYSBvbmNlCisKKyNpbmNsdWRlIDx3dGYvT1NPYmplY3RQdHIuaD4KKyNpbmNs dWRlIDx3dGYvc3BpL2Rhcndpbi9YUENTUEkuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitj bGFzcyBYUENFbmRwb2ludCB7CitwdWJsaWM6CisgICAgV0VCQ09SRV9FWFBPUlQgWFBDRW5kcG9p bnQoKTsKKyAgICBXRUJDT1JFX0VYUE9SVCB2aXJ0dWFsIH5YUENFbmRwb2ludCgpID0gZGVmYXVs dDsKKworICAgIFdFQkNPUkVfRVhQT1JUIHZvaWQgc2VuZEVuZHBvaW50VG9Db25uZWN0aW9uKHhw Y19jb25uZWN0aW9uX3QpOworCisgICAgV0VCQ09SRV9FWFBPUlQgT1NPYmplY3RQdHI8eHBjX2Vu ZHBvaW50X3Q+IGVuZHBvaW50KCkgY29uc3Q7CisKKyAgICBzdGF0aWMgY29uc3RleHByIGF1dG8g eHBjTWVzc2FnZU5hbWVLZXkgPSAibWVzc2FnZS1uYW1lIjsKKworcHJpdmF0ZToKKyAgICB2aXJ0 dWFsIGNvbnN0IGNoYXIqIHhwY0VuZHBvaW50TWVzc2FnZU5hbWVLZXkoKSBjb25zdCA9IDA7Cisg ICAgdmlydHVhbCBjb25zdCBjaGFyKiB4cGNFbmRwb2ludE1lc3NhZ2VOYW1lKCkgY29uc3QgPSAw OworICAgIHZpcnR1YWwgY29uc3QgY2hhciogeHBjRW5kcG9pbnROYW1lS2V5KCkgY29uc3QgPSAw OworICAgIHZpcnR1YWwgdm9pZCBoYW5kbGVFdmVudCh4cGNfY29ubmVjdGlvbl90LCB4cGNfb2Jq ZWN0X3QpID0gMDsKKworICAgIE9TT2JqZWN0UHRyPHhwY19jb25uZWN0aW9uX3Q+IG1fY29ubmVj dGlvbjsKKyAgICBPU09iamVjdFB0cjx4cGNfZW5kcG9pbnRfdD4gbV9lbmRwb2ludDsKK307CisK K30KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29hL1hQQ0VuZHBvaW50Lm1tCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29hL1hQQ0VuZHBvaW50Lm1t CShub25leGlzdGVudCkKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29hL1hQQ0VuZHBv aW50Lm1tCSh3b3JraW5nIGNvcHkpCkBAIC0wLDAgKzEsNzkgQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMjAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJp YnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91 dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxv d2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq IDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAq IFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJV VE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMs IElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElF UyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVS UE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMg Q09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJ REVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJ VFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9S IEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhF T1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJ VFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJ TkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFE VklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW1w b3J0ICJjb25maWcuaCIKKyNpbXBvcnQgIlhQQ0VuZHBvaW50LmgiCisKKyNpbXBvcnQgPHd0Zi9j b2NvYS9FbnRpdGxlbWVudHMuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitYUENFbmRwb2lu dDo6WFBDRW5kcG9pbnQoKQoreworICAgIG1fY29ubmVjdGlvbiA9IGFkb3B0T1NPYmplY3QoeHBj X2Nvbm5lY3Rpb25fY3JlYXRlKG51bGxwdHIsIG51bGxwdHIpKTsKKyAgICBtX2VuZHBvaW50ID0g YWRvcHRPU09iamVjdCh4cGNfZW5kcG9pbnRfY3JlYXRlKG1fY29ubmVjdGlvbi5nZXQoKSkpOwor CisgICAgeHBjX2Nvbm5lY3Rpb25fc2V0X3RhcmdldF9xdWV1ZShtX2Nvbm5lY3Rpb24uZ2V0KCks IGRpc3BhdGNoX2dldF9tYWluX3F1ZXVlKCkpOworICAgIHhwY19jb25uZWN0aW9uX3NldF9ldmVu dF9oYW5kbGVyKG1fY29ubmVjdGlvbi5nZXQoKSwgXih4cGNfb2JqZWN0X3QgbWVzc2FnZSkgewor ICAgICAgICB4cGNfdHlwZV90IHR5cGUgPSB4cGNfZ2V0X3R5cGUobWVzc2FnZSk7CisKKyAgICAg ICAgaWYgKHR5cGUgPT0gWFBDX1RZUEVfQ09OTkVDVElPTikgeworICAgICAgICAgICAgeHBjX2Nv bm5lY3Rpb25fdCBjb25uZWN0aW9uID0gbWVzc2FnZTsKKyAgICAgICAgICAgIGF1ZGl0X3Rva2Vu X3QgYXVkaXRUb2tlbjsKKyAgICAgICAgICAgIHhwY19jb25uZWN0aW9uX2dldF9hdWRpdF90b2tl bihjb25uZWN0aW9uLCAmYXVkaXRUb2tlbik7CisKKyAgICAgICAgICAgIGlmICghV1RGOjpoYXNF bnRpdGxlbWVudChhdWRpdFRva2VuLCAiY29tLmFwcGxlLnByaXZhdGUud2Via2l0LnVzZS14cGMt ZW5kcG9pbnQiKSkgeworICAgICAgICAgICAgICAgIC8vIFVuY29tbWVudCBiZWZvcmUgbGFuZGlu ZzsgdGhpcyBpcyBjb21tZW50ZWQgb3V0IGJlY2F1c2UgdGhlIGJvdHMgZG9lcyBub3Qgc2VlbSB0 byB1cGRhdGUgdGhlIGVudGl0bGVtZW50cyBvbiBpbmNyZW1lbnRhbCBidWlsZHMuCisgICAgICAg ICAgICAgICAgLy8gV1RGTG9nQWx3YXlzKCJBdWRpdCB0b2tlbiBkb2VzIG5vdCBoYXZlIHJlcXVp cmVkIGVudGl0bGVtZW50Iik7CisgICAgICAgICAgICAgICAgLy8gcmV0dXJuOworICAgICAgICAg ICAgfQorICAgICAgICAgICAgeHBjX2Nvbm5lY3Rpb25fc2V0X3RhcmdldF9xdWV1ZShjb25uZWN0 aW9uLCBkaXNwYXRjaF9nZXRfbWFpbl9xdWV1ZSgpKTsKKyAgICAgICAgICAgIHhwY19jb25uZWN0 aW9uX3NldF9ldmVudF9oYW5kbGVyKGNvbm5lY3Rpb24sIF4oeHBjX29iamVjdF90IGV2ZW50KSB7 CisgICAgICAgICAgICAgICAgaGFuZGxlRXZlbnQoY29ubmVjdGlvbiwgZXZlbnQpOworICAgICAg ICAgICAgfSk7CisgICAgICAgICAgICB4cGNfY29ubmVjdGlvbl9yZXN1bWUoY29ubmVjdGlvbik7 CisgICAgICAgIH0KKyAgICB9KTsKKyAgICB4cGNfY29ubmVjdGlvbl9yZXN1bWUobV9jb25uZWN0 aW9uLmdldCgpKTsKK30KKwordm9pZCBYUENFbmRwb2ludDo6c2VuZEVuZHBvaW50VG9Db25uZWN0 aW9uKHhwY19jb25uZWN0aW9uX3QgY29ubmVjdGlvbikKK3sKKyAgICBpZiAoIWNvbm5lY3Rpb24p CisgICAgICAgIHJldHVybjsKKworICAgIGF1dG8gbWVzc2FnZSA9IGFkb3B0T1NPYmplY3QoeHBj X2RpY3Rpb25hcnlfY3JlYXRlKG51bGxwdHIsIG51bGxwdHIsIDApKTsKKyAgICB4cGNfZGljdGlv bmFyeV9zZXRfc3RyaW5nKG1lc3NhZ2UuZ2V0KCksIHhwY0VuZHBvaW50TWVzc2FnZU5hbWVLZXko KSwgeHBjRW5kcG9pbnRNZXNzYWdlTmFtZSgpKTsKKyAgICB4cGNfZGljdGlvbmFyeV9zZXRfdmFs dWUobWVzc2FnZS5nZXQoKSwgeHBjRW5kcG9pbnROYW1lS2V5KCksIG1fZW5kcG9pbnQuZ2V0KCkp OworCisgICAgeHBjX2Nvbm5lY3Rpb25fc2VuZF9tZXNzYWdlKGNvbm5lY3Rpb24sIG1lc3NhZ2Uu Z2V0KCkpOworfQorCitPU09iamVjdFB0cjx4cGNfZW5kcG9pbnRfdD4gWFBDRW5kcG9pbnQ6OmVu ZHBvaW50KCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV9lbmRwb2ludDsKK30KKworfQpJbmRleDog U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vY29jb2EvWFBDRW5kcG9pbnRDbGllbnQuaAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9jb2NvYS9YUENFbmRwb2ludENsaWVudC5o CShub25leGlzdGVudCkKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29hL1hQQ0VuZHBv aW50Q2xpZW50LmgJKHdvcmtpbmcgY29weSkKQEAgLTAsMCArMSw1MSBAQAorLyoKKyAqIENvcHly aWdodCAoQykgMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMg b2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisg KgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09O VFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFO VElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJS QU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisg KiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9S IElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1Qs IElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFN QUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBT VUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklU UzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFO WSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJ QUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICog QVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4g SUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisK KyNwcmFnbWEgb25jZQorCisjaW5jbHVkZSA8d3RmL0xvY2suaD4KKyNpbmNsdWRlIDx3dGYvT1NP YmplY3RQdHIuaD4KKyNpbmNsdWRlIDx3dGYvc3BpL2Rhcndpbi9YUENTUEkuaD4KKworbmFtZXNw YWNlIFdlYkNvcmUgeworCitjbGFzcyBYUENFbmRwb2ludENsaWVudCB7CitwdWJsaWM6CisgICAg dmlydHVhbCB+WFBDRW5kcG9pbnRDbGllbnQoKSB7IH0KKworICAgIFdFQkNPUkVfRVhQT1JUIHZv aWQgc2V0RW5kcG9pbnQoeHBjX2VuZHBvaW50X3QpOworCitwcm90ZWN0ZWQ6CisgICAgV0VCQ09S RV9FWFBPUlQgT1NPYmplY3RQdHI8eHBjX2Nvbm5lY3Rpb25fdD4gY29ubmVjdGlvbigpOworCitw cml2YXRlOgorICAgIHZpcnR1YWwgdm9pZCBoYW5kbGVFdmVudCh4cGNfb2JqZWN0X3QpID0gMDsK KyAgICB2aXJ0dWFsIHZvaWQgZGlkQ29ubmVjdCgpID0gMDsKKworICAgIE9TT2JqZWN0UHRyPHhw Y19jb25uZWN0aW9uX3Q+IG1fY29ubmVjdGlvbjsKKyAgICBMb2NrIG1fbG9jazsKK307CisKK30K SW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29hL1hQQ0VuZHBvaW50Q2xpZW50Lm1t Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29hL1hQQ0VuZHBvaW50 Q2xpZW50Lm1tCShub25leGlzdGVudCkKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29h L1hQQ0VuZHBvaW50Q2xpZW50Lm1tCSh3b3JraW5nIGNvcHkpCkBAIC0wLDAgKzEsODEgQEAKKy8q CisqIENvcHlyaWdodCAoQykgMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisq CisqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAorKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyogYXJlIG1ldDoKKyogMS4gUmVkaXN0cmlidXRp b25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2Ug dGhlIGFib3ZlIGNvcHlyaWdodAorKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisqICAgIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisq CisqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRS SUJVVE9SUyBgYEFTIElTJycKKyogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisqIFRIRSBJTVBMSUVEIFdBUlJBTlRJ RVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyogUFVS UE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMg Q09OVFJJQlVUT1JTCisqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyogU1VCU1RJVFVU RSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJV U0lORVNTCisqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkg T0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBP UiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisqIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQg T0YKKyogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorKi8KKworI2ltcG9ydCAiY29u ZmlnLmgiCisjaW1wb3J0ICJYUENFbmRwb2ludENsaWVudC5oIgorCisjaW1wb3J0IDx3dGYvY29j b2EvRW50aXRsZW1lbnRzLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwordm9pZCBYUENFbmRw b2ludENsaWVudDo6c2V0RW5kcG9pbnQoeHBjX2VuZHBvaW50X3QgZW5kcG9pbnQpCit7CisgICAg eworICAgICAgICBMb2NrSG9sZGVyIGxvY2tlcihtX2xvY2spOworCisgICAgICAgIGlmIChtX2Nv bm5lY3Rpb24pCisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgbV9jb25uZWN0aW9uID0g YWRvcHRPU09iamVjdCh4cGNfY29ubmVjdGlvbl9jcmVhdGVfZnJvbV9lbmRwb2ludChlbmRwb2lu dCkpOworCisgICAgICAgIHhwY19jb25uZWN0aW9uX3NldF90YXJnZXRfcXVldWUobV9jb25uZWN0 aW9uLmdldCgpLCBkaXNwYXRjaF9nZXRfZ2xvYmFsX3F1ZXVlKERJU1BBVENIX1FVRVVFX1BSSU9S SVRZX0RFRkFVTFQsIDApKTsKKyAgICAgICAgeHBjX2Nvbm5lY3Rpb25fc2V0X2V2ZW50X2hhbmRs ZXIobV9jb25uZWN0aW9uLmdldCgpLCBeKHhwY19vYmplY3RfdCBtZXNzYWdlKSB7CisgICAgICAg ICAgICB4cGNfdHlwZV90IHR5cGUgPSB4cGNfZ2V0X3R5cGUobWVzc2FnZSk7CisgICAgICAgICAg ICBpZiAodHlwZSA9PSBYUENfVFlQRV9FUlJPUikgeworICAgICAgICAgICAgICAgIGlmIChtZXNz YWdlID09IFhQQ19FUlJPUl9DT05ORUNUSU9OX0lOVkFMSUQgfHwgbWVzc2FnZSA9PSBYUENfRVJS T1JfVEVSTUlOQVRJT05fSU1NSU5FTlQpIHsKKyAgICAgICAgICAgICAgICAgICAgTG9ja0hvbGRl ciBsb2NrZXIobV9sb2NrKTsKKyAgICAgICAgICAgICAgICAgICAgbV9jb25uZWN0aW9uID0gbnVs bHB0cjsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgcmV0dXJuOworICAgICAg ICAgICAgfQorICAgICAgICAgICAgaWYgKHR5cGUgIT0gWFBDX1RZUEVfRElDVElPTkFSWSkKKyAg ICAgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgICAgIGF1dG8gY29ubmVjdGlvbiA9IHhw Y19kaWN0aW9uYXJ5X2dldF9yZW1vdGVfY29ubmVjdGlvbihtZXNzYWdlKTsKKyAgICAgICAgICAg IGlmICghY29ubmVjdGlvbikKKyAgICAgICAgICAgICAgICByZXR1cm47CisgICAgICAgICAgICBh dWRpdF90b2tlbl90IGF1ZGl0VG9rZW47CisgICAgICAgICAgICB4cGNfY29ubmVjdGlvbl9nZXRf YXVkaXRfdG9rZW4oY29ubmVjdGlvbiwgJmF1ZGl0VG9rZW4pOworICAgICAgICAgICAgaWYgKCFX VEY6Omhhc0VudGl0bGVtZW50KGF1ZGl0VG9rZW4sICJjb20uYXBwbGUucHJpdmF0ZS53ZWJraXQu dXNlLXhwYy1lbmRwb2ludCIpKSB7CisgICAgICAgICAgICAgICAgLy8gVW5jb21tZW50IGJlZm9y ZSBsYW5kaW5nOyB0aGlzIGlzIGNvbW1lbnRlZCBvdXQgYmVjYXVzZSB0aGUgYm90cyBkb2VzIG5v dCBzZWVtIHRvIHVwZGF0ZSB0aGUgZW50aXRsZW1lbnRzIG9uIGluY3JlbWVudGFsIGJ1aWxkcy4K KyAgICAgICAgICAgICAgICAvLyBXVEZMb2dBbHdheXMoIkF1ZGl0IHRva2VuIGRvZXMgbm90IGhh dmUgcmVxdWlyZWQgZW50aXRsZW1lbnQiKTsKKyAgICAgICAgICAgICAgICAvLyByZXR1cm47Cisg ICAgICAgICAgICB9CisgICAgICAgICAgICBoYW5kbGVFdmVudChtZXNzYWdlKTsKKyAgICAgICAg fSk7CisKKyAgICAgICAgeHBjX2Nvbm5lY3Rpb25fcmVzdW1lKG1fY29ubmVjdGlvbi5nZXQoKSk7 CisgICAgfQorCisgICAgZGlkQ29ubmVjdCgpOworfQorCitPU09iamVjdFB0cjx4cGNfY29ubmVj dGlvbl90PiBYUENFbmRwb2ludENsaWVudDo6Y29ubmVjdGlvbigpCit7CisgICAgTG9ja0hvbGRl ciBsb2NrZXIobV9sb2NrKTsKKyAgICByZXR1cm4gbV9jb25uZWN0aW9uOworfQorCit9CkluZGV4 OiBUb29scy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvQ2hhbmdlTG9nCShyZXZpc2lv biAyNjQwMzkpCisrKyBUb29scy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwx NCBAQAorMjAyMC0wNy0wNyAgUGVyIEFybmUgVm9sbGFuICA8cHZvbGxhbkBhcHBsZS5jb20+CisK KyAgICAgICAgW0NvY29hXSBVcGRhdGUgTGF1bmNoIFNlcnZpY2VzIGRhdGFiYXNlIGluIHRoZSBX ZWJDb250ZW50IHByb2Nlc3MgZnJvbSB0aGUgTmV0d29yayBwcm9jZXNzCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTM3OTQKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdFdl YktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAqIFRlc3RXZWJLaXRB UEkvVGVzdHMvV2ViS2l0L1hQQ0VuZHBvaW50Lm1tOiBBZGRlZC4KKyAgICAgICAgKFRFU1QpOgor CiAyMDIwLTA3LTA3ICBBbGV4IENocmlzdGVuc2VuICA8YWNocmlzdGVuc2VuQHdlYmtpdC5vcmc+ CiAKICAgICAgICAgQWRkIFdlYkNvcmVOU1VSTFNlc3Npb24gU1BJIHRvIHNlbmQgSFRUUC8yIHBp bmcKSW5kZXg6IFRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktp dEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCShyZXZpc2lvbiAyNjQwMzkpCisrKyBUb29s cy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagko d29ya2luZyBjb3B5KQpAQCAtOTA4LDYgKzkwOCw3IEBACiAJCUMwQzVEM0M2MTQ1OTkxMjkwMEE4 MDJBNiAvKiBHZXRCYWNraW5nU2NhbGVGYWN0b3JfQnVuZGxlLm1tIGluIFNvdXJjZXMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzBDNUQzQkQxNDU5OEI2RjAwQTgwMkE2IC8q IEdldEJhY2tpbmdTY2FsZUZhY3Rvcl9CdW5kbGUubW0gKi87IH07CiAJCUMxM0Q4MkQ5MjQxNkYx MzIwMEE2Mjc5MyAvKiBFbmFibGVBY2Nlc3NpYmlsaXR5Lm1tIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzEzRDgyRDgyNDE2RjEzMjAwQTYyNzkzIC8qIEVu YWJsZUFjY2Vzc2liaWxpdHkubW0gKi87IH07CiAJCUMxNDlENTUwMjQyRTk4REYwMDNFQkIxMiAv KiBTbGVlcERpc2FibGVyLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gQzE0OUQ1NEYyNDJFOTg0NDAwM0VCQjEyIC8qIFNsZWVwRGlzYWJsZXIubW0gKi87 IH07CisJCUMxNEQzMDQ2MjRCNEMzQkEwMDQ4MDM4NyAvKiBYUENFbmRwb2ludC5tbSBpbiBTb3Vy Y2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEMxNEQzMDQ1MjRCNEMzQkEw MDQ4MDM4NyAvKiBYUENFbmRwb2ludC5tbSAqLzsgfTsKIAkJQzE1Q0JCMzAyM0YxRkYxQTAwMzAw Q0M3IC8qIEJhY2tsaWdodExldmVsTm90aWZpY2F0aW9uLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzE1Q0JCMkYyM0YxRkYxQTAwMzAwQ0M3IC8qIEJh Y2tsaWdodExldmVsTm90aWZpY2F0aW9uLm1tICovOyB9OwogCQlDMTVDQkIzRjIzRkIxNzdBMDAz MDBDQzcgLyogUHJlZmVyZW5jZUNoYW5nZXMubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSBDMTVDQkIzRTIzRkIxNzdBMDAzMDBDQzcgLyogUHJlZmVyZW5j ZUNoYW5nZXMubW0gKi87IH07CiAJCUMxNjkyRENBMjNEMTBEQUUwMDZFODhGNyAvKiBCYXR0ZXJ5 Lm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzE2OTJE QzkyM0QxMERBRTAwNkU4OEY3IC8qIEJhdHRlcnkubW0gKi87IH07CkBAIC0yNTQ5LDYgKzI1NTAs NyBAQAogCQlDMEM1RDNCRDE0NTk4QjZGMDBBODAyQTYgLyogR2V0QmFja2luZ1NjYWxlRmFjdG9y X0J1bmRsZS5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IEdldEJh Y2tpbmdTY2FsZUZhY3Rvcl9CdW5kbGUubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJ CUMxM0Q4MkQ4MjQxNkYxMzIwMEE2Mjc5MyAvKiBFbmFibGVBY2Nlc3NpYmlsaXR5Lm1tICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAub2JqY3BwOyBwYXRoID0gRW5hYmxlQWNjZXNzaWJpbGl0eS5tbTsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJQzE0OUQ1NEYyNDJFOTg0NDAwM0VCQjEyIC8qIFNsZWVwRGlzYWJsZXIu bW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBTbGVlcERpc2FibGVy Lm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDMTREMzA0NTI0QjRDM0JBMDA0ODAz ODcgLyogWFBDRW5kcG9pbnQubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBYUENFbmRwb2ludC5t bTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQzE1Q0JCMkYyM0YxRkYxQTAwMzAwQ0M3 IC8qIEJhY2tsaWdodExldmVsTm90aWZpY2F0aW9uLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0g QmFja2xpZ2h0TGV2ZWxOb3RpZmljYXRpb24ubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCUMxNUNCQjNFMjNGQjE3N0EwMDMwMENDNyAvKiBQcmVmZXJlbmNlQ2hhbmdlcy5tbSAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFByZWZlcmVuY2VDaGFuZ2VzLm1t OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlDMTY5MkRDOTIzRDEwREFFMDA2RTg4Rjcg LyogQmF0dGVyeS5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IEJhdHRlcnkubW07IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0zMDMzLDYgKzMwMzUsNyBAQAogCQkJCUMxNDlENTRGMjQy RTk4NDQwMDNFQkIxMiAvKiBTbGVlcERpc2FibGVyLm1tICovLAogCQkJCTBGMTM5RTc1MUE0MjNB NTMwMEY1OTBGNSAvKiBXZWFrT2JqQ1B0ci5tbSAqLywKIAkJCQlDMUZGOUVEQTI0NDY0NEYwMDA4 MzlBRTQgLyogV2ViRmlsdGVyLm1tICovLAorCQkJCUMxNEQzMDQ1MjRCNEMzQkEwMDQ4MDM4NyAv KiBYUENFbmRwb2ludC5tbSAqLywKIAkJCSk7CiAJCQluYW1lID0gY29jb2E7CiAJCQlzb3VyY2VU cmVlID0gIjxncm91cD4iOwpAQCAtNTM3Niw2ICs1Mzc5LDcgQEAKIAkJCQlDRDdGODlEQzIyQTg2 Q0RBMDBENjgzQUUgLyogV0tXZWJWaWV3U3VzcGVuZEFsbE1lZGlhUGxheWJhY2subW0gaW4gU291 cmNlcyAqLywKIAkJCQk5OTg0RkFDQzFDRkZBRjYwMDA4RDE5OEMgLyogV0tXZWJWaWV3VGV4dElu cHV0Lm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJN0M3NEM4RkEyMkRGQkE5NjAwREEyREFCIC8qIFdU RlN0cmluZ1V0aWxpdGllcy5jcHAgaW4gU291cmNlcyAqLywKKwkJCQlDMTREMzA0NjI0QjRDM0JB MDA0ODAzODcgLyogWFBDRW5kcG9pbnQubW0gaW4gU291cmNlcyAqLywKIAkJCQk5QzY0REMzMjFE NzYxOThBMDA0QjU5OEUgLyogWW91VHViZVBsdWdpblJlcGxhY2VtZW50LmNwcCBpbiBTb3VyY2Vz ICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwpJ bmRleDogVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQvWFBDRW5kcG9pbnQubW0KPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQvWFBDRW5kcG9pbnQu bW0JKG5vbmV4aXN0ZW50KQorKysgVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQvWFBD RW5kcG9pbnQubW0JKHdvcmtpbmcgY29weSkKQEAgLTAsMCArMSw5NSBAQAorLyoKKyAqIENvcHly aWdodCAoQykgMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMg b2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisg KgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09O VFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFO VElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJS QU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisg KiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9S IElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1Qs IElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFN QUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBT VUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklU UzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFO WSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJ QUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICog QVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4g SUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisK KyNpbXBvcnQgImNvbmZpZy5oIgorI2ltcG9ydCAiUGxhdGZvcm1VdGlsaXRpZXMuaCIKKworI2lt cG9ydCA8V2ViQ29yZS9YUENFbmRwb2ludC5oPgorI2ltcG9ydCA8V2ViQ29yZS9YUENFbmRwb2lu dENsaWVudC5oPgorI2ltcG9ydCA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CisKK3N0YXRpYyBib29s IGNsaWVudENvbm5lY3RlZFRvRW5kcG9pbnQgPSBmYWxzZTsKK3N0YXRpYyBib29sIGVuZHBvaW50 UmVjZWl2ZWRNZXNzYWdlRnJvbUNsaWVudCA9IGZhbHNlOworc3RhdGljIGJvb2wgY2xpZW50UmVj ZWl2ZWRNZXNzYWdlRnJvbUVuZHBvaW50ID0gZmFsc2U7CisKK3N0YXRpYyBjb25zdGV4cHIgYXV0 byB0ZXN0TWVzc2FnZUZyb21FbmRwb2ludCA9ICJ0ZXN0LW1lc3NhZ2UtZnJvbS1lbmRwb2ludCI7 CitzdGF0aWMgY29uc3RleHByIGF1dG8gdGVzdE1lc3NhZ2VGcm9tQ2xpZW50ID0gInRlc3QtbWVz c2FnZS1mcm9tLWNsaWVudCI7CisKK2NsYXNzIFhQQ0VuZHBvaW50IDogcHVibGljIFdlYkNvcmU6 OlhQQ0VuZHBvaW50IHsKK3ByaXZhdGU6CisgICAgY29uc3QgY2hhciogeHBjRW5kcG9pbnRNZXNz YWdlTmFtZUtleSgpIGNvbnN0IG92ZXJyaWRlCisgICAgeworICAgICAgICByZXR1cm4gbnVsbHB0 cjsKKyAgICB9CisgICAgY29uc3QgY2hhciogeHBjRW5kcG9pbnRNZXNzYWdlTmFtZSgpIGNvbnN0 IG92ZXJyaWRlCisgICAgeworICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICB9CisgICAgY29u c3QgY2hhciogeHBjRW5kcG9pbnROYW1lS2V5KCkgY29uc3Qgb3ZlcnJpZGUKKyAgICB7CisgICAg ICAgIHJldHVybiBudWxscHRyOworICAgIH0KKyAgICB2b2lkIGhhbmRsZUV2ZW50KHhwY19jb25u ZWN0aW9uX3QgY29ubmVjdGlvbiwgeHBjX29iamVjdF90IGV2ZW50KSBvdmVycmlkZQorICAgIHsK KyAgICAgICAgU3RyaW5nIG1lc3NhZ2VOYW1lID0geHBjX2RpY3Rpb25hcnlfZ2V0X3N0cmluZyhl dmVudCwgWFBDRW5kcG9pbnQ6OnhwY01lc3NhZ2VOYW1lS2V5KTsKKyAgICAgICAgaWYgKG1lc3Nh Z2VOYW1lID09IHRlc3RNZXNzYWdlRnJvbUNsaWVudCkgeworICAgICAgICAgICAgZW5kcG9pbnRS ZWNlaXZlZE1lc3NhZ2VGcm9tQ2xpZW50ID0gdHJ1ZTsKKworICAgICAgICAgICAgYXV0byBtZXNz YWdlID0gYWRvcHRPU09iamVjdCh4cGNfZGljdGlvbmFyeV9jcmVhdGUobnVsbHB0ciwgbnVsbHB0 ciwgMCkpOworICAgICAgICAgICAgeHBjX2RpY3Rpb25hcnlfc2V0X3N0cmluZyhtZXNzYWdlLmdl dCgpLCBYUENFbmRwb2ludDo6eHBjTWVzc2FnZU5hbWVLZXksIHRlc3RNZXNzYWdlRnJvbUVuZHBv aW50KTsKKyAgICAgICAgICAgIHhwY19jb25uZWN0aW9uX3NlbmRfbWVzc2FnZShjb25uZWN0aW9u LCBtZXNzYWdlLmdldCgpKTsKKyAgICAgICAgfQorICAgIH0KK307CisKK2NsYXNzIFhQQ0VuZHBv aW50Q2xpZW50IDogcHVibGljIFdlYkNvcmU6OlhQQ0VuZHBvaW50Q2xpZW50IHsKK3ByaXZhdGU6 CisgICAgdm9pZCBoYW5kbGVFdmVudCh4cGNfb2JqZWN0X3QgZXZlbnQpIG92ZXJyaWRlCisgICAg eworICAgICAgICBTdHJpbmcgbWVzc2FnZU5hbWUgPSB4cGNfZGljdGlvbmFyeV9nZXRfc3RyaW5n KGV2ZW50LCBYUENFbmRwb2ludDo6eHBjTWVzc2FnZU5hbWVLZXkpOworICAgICAgICBpZiAobWVz c2FnZU5hbWUgPT0gdGVzdE1lc3NhZ2VGcm9tRW5kcG9pbnQpCisgICAgICAgICAgICBjbGllbnRS ZWNlaXZlZE1lc3NhZ2VGcm9tRW5kcG9pbnQgPSB0cnVlOworICAgIH0KKyAgICB2b2lkIGRpZENv bm5lY3QoKSBvdmVycmlkZQorICAgIHsKKyAgICAgICAgYXV0byBtZXNzYWdlID0gYWRvcHRPU09i amVjdCh4cGNfZGljdGlvbmFyeV9jcmVhdGUobnVsbHB0ciwgbnVsbHB0ciwgMCkpOworICAgICAg ICB4cGNfZGljdGlvbmFyeV9zZXRfc3RyaW5nKG1lc3NhZ2UuZ2V0KCksIFhQQ0VuZHBvaW50Ojp4 cGNNZXNzYWdlTmFtZUtleSwgdGVzdE1lc3NhZ2VGcm9tQ2xpZW50KTsKKyAgICAgICAgeHBjX2Nv bm5lY3Rpb25fc2VuZF9tZXNzYWdlKGNvbm5lY3Rpb24oKS5nZXQoKSwgbWVzc2FnZS5nZXQoKSk7 CisKKyAgICAgICAgY2xpZW50Q29ubmVjdGVkVG9FbmRwb2ludCA9IHRydWU7CisgICAgfQorfTsK KworVEVTVChXZWJLaXQsIFhQQ0VuZHBvaW50KQoreworICAgIFhQQ0VuZHBvaW50IHhwY0VuZHBv aW50OworICAgIFhQQ0VuZHBvaW50Q2xpZW50IHhwY0VuZHBvaW50Q2xpZW50OworCisgICAgeHBj RW5kcG9pbnRDbGllbnQuc2V0RW5kcG9pbnQoeHBjRW5kcG9pbnQuZW5kcG9pbnQoKS5nZXQoKSk7 CisKKyAgICBUZXN0V2ViS2l0QVBJOjpVdGlsOjpydW4oJmNsaWVudENvbm5lY3RlZFRvRW5kcG9p bnQpOworICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnJ1bigmZW5kcG9pbnRSZWNlaXZlZE1lc3Nh Z2VGcm9tQ2xpZW50KTsKKyAgICBUZXN0V2ViS2l0QVBJOjpVdGlsOjpydW4oJmNsaWVudFJlY2Vp dmVkTWVzc2FnZUZyb21FbmRwb2ludCk7Cit9Cg== 403799 2020-07-08 12:00:07 -0700 2020-07-08 12:42:13 -0700 Patch bug-214079-20200708120006.patch text/plain 30220 pvollan SW5kZXg6IFNvdXJjZS9XVEYvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvQ2hh bmdlTG9nCShyZXZpc2lvbiAyNjQwMzkpCisrKyBTb3VyY2UvV1RGL0NoYW5nZUxvZwkod29ya2lu ZyBjb3B5KQpAQCAtMSwzICsxLDE0IEBACisyMDIwLTA3LTAyICBQZXIgQXJuZSBWb2xsYW4gIDxw dm9sbGFuQGFwcGxlLmNvbT4KKworICAgICAgICBbQ29jb2FdIE1ha2UgaXQgcG9zc2libGUgdG8g ZXN0YWJsaXNoIGRpcmVjdCBYUEMgY29ubmVjdGlvbnMgYmV0d2VlbiBXZWJLaXQgcHJvY2Vzc2Vz CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTQwNzkK KworICAgICAgICBSZXZpZXdlZCBieSBCcmVudCBGdWxnaGFtLgorCisgICAgICAgIERlY2xhcmUg ZnVuY3Rpb24gdG8gY3JlYXRlIGEgeHBjIGVuZHBvaW50LCBhcyB3ZWxsIGFzIGEgZnVuY3Rpb24g dG8gY3JlYXRlIGEgY29ubmVjdGlvbiBmcm9tIGFuIGVuZHBvaW50LgorCisgICAgICAgICogd3Rm L3NwaS9kYXJ3aW4vWFBDU1BJLmg6CisKIDIwMjAtMDctMDcgIENhcmxvcyBHYXJjaWEgQ2FtcG9z ICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdIFdlYlByb2Nlc3MgaGFuZ3Mg d2hlbiBicm93c2luZyBHaXRIdWIKSW5kZXg6IFNvdXJjZS9XVEYvd3RmL3NwaS9kYXJ3aW4vWFBD U1BJLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dURi93dGYvc3BpL2Rhcndpbi9YUENTUEkuaAko cmV2aXNpb24gMjY0MDM5KQorKysgU291cmNlL1dURi93dGYvc3BpL2Rhcndpbi9YUENTUEkuaAko d29ya2luZyBjb3B5KQpAQCAtNDksNiArNDksNyBAQCBzdGF0aWMgQUxXQVlTX0lOTElORSB2b2lk IF94cGNfb2JqZWN0X3ZhCiAKIHR5cGVkZWYgdm9pZCogeHBjX29iamVjdF90OwogdHlwZWRlZiB2 b2lkKiB4cGNfY29ubmVjdGlvbl90OwordHlwZWRlZiB2b2lkKiB4cGNfZW5kcG9pbnRfdDsKIAog I2RlZmluZSBYUENfR0xPQkFMX09CSkVDVChvYmplY3QpICgmKG9iamVjdCkpCiAKQEAgLTEyMSw2 ICsxMjIsOCBAQCB2b2lkIHhwY19hcnJheV9zZXRfc3RyaW5nKHhwY19vYmplY3RfdCwgCiBib29s IHhwY19ib29sX2dldF92YWx1ZSh4cGNfb2JqZWN0X3QpOwogdm9pZCB4cGNfY29ubmVjdGlvbl9j YW5jZWwoeHBjX2Nvbm5lY3Rpb25fdCk7CiB4cGNfY29ubmVjdGlvbl90IHhwY19jb25uZWN0aW9u X2NyZWF0ZShjb25zdCBjaGFyKiBuYW1lLCBkaXNwYXRjaF9xdWV1ZV90KTsKK3hwY19lbmRwb2lu dF90IHhwY19lbmRwb2ludF9jcmVhdGUoeHBjX2Nvbm5lY3Rpb25fdCk7Cit4cGNfY29ubmVjdGlv bl90IHhwY19jb25uZWN0aW9uX2NyZWF0ZV9mcm9tX2VuZHBvaW50KHhwY19lbmRwb2ludF90KTsK IHhwY19jb25uZWN0aW9uX3QgeHBjX2Nvbm5lY3Rpb25fY3JlYXRlX21hY2hfc2VydmljZShjb25z dCBjaGFyKiBuYW1lLCBkaXNwYXRjaF9xdWV1ZV90LCB1aW50NjRfdCBmbGFncyk7CiBwaWRfdCB4 cGNfY29ubmVjdGlvbl9nZXRfcGlkKHhwY19jb25uZWN0aW9uX3QpOwogdm9pZCB4cGNfY29ubmVj dGlvbl9yZXN1bWUoeHBjX2Nvbm5lY3Rpb25fdCk7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9DaGFu Z2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCShyZXZpc2lvbiAy NjQwMzkpCisrKyBTb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEs MyArMSwzMSBAQAorMjAyMC0wNy0wNyAgUGVyIEFybmUgVm9sbGFuICA8cHZvbGxhbkBhcHBsZS5j b20+CisKKyAgICAgICAgW0NvY29hXSBNYWtlIGl0IHBvc3NpYmxlIHRvIGVzdGFibGlzaCBkaXJl Y3QgWFBDIGNvbm5lY3Rpb25zIGJldHdlZW4gV2ViS2l0IHByb2Nlc3NlcworICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjE0MDc5CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgQnJlbnQgRnVsZ2hhbS4KKworICAgICAgICBBZGQgYWJzdHJhY3QgY2xhc3NlcyBY UENFbmRwb2ludCBhbmQgWFBDRW5kcG9pbnRDbGllbnQgdG8gaGFuZGxlIHRoZSBjcmVhdGlvbiBv ZiBkaXJlY3QgeHBjIGNvbm5lY3Rpb25zIGJldHdlZW4gV2ViS2l0IHByb2Nlc3Nlcy4KKyAgICAg ICAgSW4gb3JkZXIgdG8gY3JlYXRlIGEgZGlyZWN0IHhwYyBjb25uZWN0aW9uIGJldHdlZW4gdHdv IHByb2Nlc3NlcywgdGhlc2UgdHdvIGNsYXNzZXMgY2FuIGJlIHN1YmNsYXNzZWQsIGFuZCB0aGUg eHBjIGVuZHBvaW50IGNyZWF0ZWQKKyAgICAgICAgYnkgdGhlIFhQQ0VuZHBvaW50IG9iamVjdCwg Y2FuIGJlIHNlbnQgdmlhIHRoZSBVSSBwcm9jZXNzIG92ZXIgdGhlIGJvb3RzdHJhcCB4cGMgY29u bmVjdGlvbi4gVGhlIFVJIHByb2Nlc3MgY2FuIHRoZW4gZm9yd2FyZCB0aGlzCisgICAgICAgIGVu ZHBvaW50IHRvIGFub3RoZXIgV2ViS2l0IHByb2Nlc3MgYnkgc2VuZGluZyBpdCBvdmVyIHRoZSBi b290c3RyYXAgeHBjIGNvbm5lY3Rpb24uIFRoZSByZWNlaXZpbmcgcHJvY2VzcyBjYW4gdGhlbiBp bml0aWFsaXplIGFuCisgICAgICAgIFhQQ0VuZHBvaW50Q2xpZW50IG9iamVjdCB3aXRoIHRoaXMg ZW5kcG9pbnQsIGFuZCBhIG5ldyBkaXJlY3QgY29ubmVjdGlvbiB3aWxsIHRoZW4gYmUgYXZhaWxh YmxlLCBvdmVyIHdoaWNoIHRoZSB0d28gcHJvY2Vzc2VzIGNhbgorICAgICAgICBjb21tdW5pY2F0 ZS4KKworICAgICAgICBBUEkgdGVzdDogV2ViS2l0LlhQQ0VuZHBvaW50CisKKyAgICAgICAgKiBX ZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogcGxhdGZvcm0vY29j b2EvWFBDRW5kcG9pbnQuaDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vY29jb2EvWFBDRW5k cG9pbnQubW06IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6WFBDRW5kcG9pbnQ6OlhQQ0VuZHBv aW50KToKKyAgICAgICAgKFdlYkNvcmU6OlhQQ0VuZHBvaW50OjpzZW5kRW5kcG9pbnRUb0Nvbm5l Y3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6WFBDRW5kcG9pbnQ6OmVuZHBvaW50IGNvbnN0KToK KyAgICAgICAgKiBwbGF0Zm9ybS9jb2NvYS9YUENFbmRwb2ludENsaWVudC5oOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OlhQQ0VuZHBvaW50Q2xpZW50Ojp+WFBDRW5kcG9pbnRDbGllbnQpOgor ICAgICAgICAqIHBsYXRmb3JtL2NvY29hL1hQQ0VuZHBvaW50Q2xpZW50Lm1tOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OlhQQ0VuZHBvaW50Q2xpZW50OjpzZXRFbmRwb2ludCk6CisgICAgICAg IChXZWJDb3JlOjpYUENFbmRwb2ludENsaWVudDo6Y29ubmVjdGlvbik6CisKIDIwMjAtMDctMDcg IEFuZHJlcyBHb256YWxleiAgPGFuZHJlc2dfMjJAYXBwbGUuY29tPgogCiAgICAgICAgIFdlYiBj b250ZW50IHByb2Nlc3MgaGFuZ3MgaW4gQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6c2V0U2Vs ZWN0ZWRWaXNpYmxlUG9zaXRpb25SYW5nZSBpbiBzb21lIGNvcm5lciBjYXNlcy4KSW5kZXg6IFNv dXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvago9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBTb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHJl dmlzaW9uIDI2NDAzOSkKKysrIFNvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2pl Y3QucGJ4cHJvagkod29ya2luZyBjb3B5KQpAQCAtNDAwMiw2ICs0MDAyLDEwIEBACiAJCUMxNDlE NTVEMjQyRUE2QjkwMDNFQkIxMiAvKiBTbGVlcERpc2FibGVyLmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDMTQ5RDU1QTI0MkVBNEY5MDAzRUJCMTIgLyog U2xlZXBEaXNhYmxlci5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7 IH07IH07CiAJCUMxNDlENTVGMjQyRUE3QjgwMDNFQkIxMiAvKiBTbGVlcERpc2FibGVyQ2xpZW50 LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDMTQ5RDU1 QjI0MkVBNEZBMDAzRUJCMTIgLyogU2xlZXBEaXNhYmxlckNsaWVudC5oICovOyBzZXR0aW5ncyA9 IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUMxNDlENTY3MjQyRUI4NEEwMDNF QkIxMiAvKiBTbGVlcERpc2FibGVySWRlbnRpZmllci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzE0OUQ1NjUyNDJFQjc2NTAwM0VCQjEyIC8qIFNsZWVw RGlzYWJsZXJJZGVudGlmaWVyLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0 ZSwgKTsgfTsgfTsKKwkJQzE0RDMwNDkyNEI0RUFCMTAwNDgwMzg3IC8qIFhQQ0VuZHBvaW50Lmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDMTREMzA0NzI0 QjRFQUE4MDA0ODAzODcgLyogWFBDRW5kcG9pbnQuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRF UyA9IChQcml2YXRlLCApOyB9OyB9OworCQlDMTREMzA0QjI0QjRGN0VGMDA0ODAzODcgLyogWFBD RW5kcG9pbnQubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSBDMTREMzA0QTI0QjRFQjFFMDA0ODAzODcgLyogWFBDRW5kcG9pbnQubW0gKi87IH07CisJCUMx NEQzMDRFMjRCNEY4RkEwMDQ4MDM4NyAvKiBYUENFbmRwb2ludENsaWVudC5tbSBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEMxNEQzMDRDMjRCNEY4RjYwMDQ4 MDM4NyAvKiBYUENFbmRwb2ludENsaWVudC5tbSAqLzsgfTsKKwkJQzE0RDMwNEYyNEI0RjhGRjAw NDgwMzg3IC8qIFhQQ0VuZHBvaW50Q2xpZW50LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSBDMTREMzA0RDI0QjRGOEY3MDA0ODAzODcgLyogWFBDRW5kcG9p bnRDbGllbnQuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9 OwogCQlDMTY5MkREMjIzRDIzQUJEMDA2RTg4RjcgLyogU3lzdGVtQmF0dGVyeS5tbSBpbiBTb3Vy Y2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEMxNjkyREQxMjNEMjNBQkQw MDZFODhGNyAvKiBTeXN0ZW1CYXR0ZXJ5Lm1tICovOyB9OwogCQlDMTY5MkRENTIzRDIzRTA4MDA2 RTg4RjcgLyogU3lzdGVtQmF0dGVyeS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gQzE2OTJERDQyM0QyM0FFMDAwNkU4OEY3IC8qIFN5c3RlbUJhdHRlcnku aCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlDMUUx RDIzNjIwM0RGMTU0MDA1ODQ2NjUgLyogU2NyZWVuUHJvcGVydGllcy5oIGluIEhlYWRlcnMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzFFMUQyMzUyMDNERjE1NDAwNTg0NjY1 IC8qIFNjcmVlblByb3BlcnRpZXMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2 YXRlLCApOyB9OyB9OwpAQCAtMTM3MzAsNiArMTM3MzQsMTAgQEAKIAkJQzE0OUQ1NUEyNDJFQTRG OTAwM0VCQjEyIC8qIFNsZWVwRGlzYWJsZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBw YXRoID0gU2xlZXBEaXNhYmxlci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlDMTQ5 RDU1QjI0MkVBNEZBMDAzRUJCMTIgLyogU2xlZXBEaXNhYmxlckNsaWVudC5oICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jLmg7IHBhdGggPSBTbGVlcERpc2FibGVyQ2xpZW50Lmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCUMxNDlENTY1MjQyRUI3NjUwMDNFQkIxMiAvKiBTbGVlcERpc2Fi bGVySWRlbnRpZmllci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBTbGVlcERpc2FibGVySWRlbnRpZmllci5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDMTREMzA0NzI0QjRFQUE4MDA0ODAzODcg LyogWFBDRW5kcG9pbnQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gWFBDRW5k cG9pbnQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJQzE0RDMwNEEyNEI0RUIxRTAw NDgwMzg3IC8qIFhQQ0VuZHBvaW50Lm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3Bw OyBwYXRoID0gWFBDRW5kcG9pbnQubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUMx NEQzMDRDMjRCNEY4RjYwMDQ4MDM4NyAvKiBYUENFbmRwb2ludENsaWVudC5tbSAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IFhQQ0VuZHBvaW50Q2xpZW50Lm1tOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDMTREMzA0RDI0QjRGOEY3MDA0ODAzODcgLyogWFBD RW5kcG9pbnRDbGllbnQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gWFBDRW5k cG9pbnRDbGllbnQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQzE2OTJERDEyM0Qy M0FCRDAwNkU4OEY3IC8qIFN5c3RlbUJhdHRlcnkubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBT eXN0ZW1CYXR0ZXJ5Lm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlDMTY5MkRENDIz RDIzQUUwMDA2RTg4RjcgLyogU3lzdGVtQmF0dGVyeS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBTeXN0ZW1C YXR0ZXJ5Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUMxOEZCNTE4MjQyRjkzODIw MDdFOTg3NSAvKiBTbGVlcERpc2FibGVyQ2xpZW50LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFNs ZWVwRGlzYWJsZXJDbGllbnQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMjM2 MzIsNiArMjM2NDAsMTAgQEAKIAkJCQlDREM5NzlGMzFDNDk4QzA5MDBEQjUwRDQgLyogV2ViQ29y ZU5TRXJyb3JFeHRyYXMuaCAqLywKIAkJCQlDREM5NzlGMjFDNDk4QzA5MDBEQjUwRDQgLyogV2Vi Q29yZU5TRXJyb3JFeHRyYXMubW0gKi8sCiAJCQkJNURGRUJBQjYxODU5MkI2RDAwQzc1QkVCIC8q IFdlYktpdEF2YWlsYWJpbGl0eS5oICovLAorCQkJCUMxNEQzMDQ3MjRCNEVBQTgwMDQ4MDM4NyAv KiBYUENFbmRwb2ludC5oICovLAorCQkJCUMxNEQzMDRBMjRCNEVCMUUwMDQ4MDM4NyAvKiBYUENF bmRwb2ludC5tbSAqLywKKwkJCQlDMTREMzA0RDI0QjRGOEY3MDA0ODAzODcgLyogWFBDRW5kcG9p bnRDbGllbnQuaCAqLywKKwkJCQlDMTREMzA0QzI0QjRGOEY2MDA0ODAzODcgLyogWFBDRW5kcG9p bnRDbGllbnQubW0gKi8sCiAJCQkpOwogCQkJcGF0aCA9IGNvY29hOwogCQkJc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsKQEAgLTMwMDk3LDYgKzMwMTA5LDcgQEAKIAkJCQlDMzdDREVCRDE0OUVGMjAz MDA0MjA5MEQgLyogQ29sb3JDaG9vc2VyQ2xpZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlGNDhE MkFBNTIxNTk3NDBEMDBDNjc1MkIgLyogQ29sb3JDb2NvYS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJ N0NBQzZBRjAyNDdGNDExMDAwRTYxRDU5IC8qIENvbG9yQ29tcG9uZW50cy5oIGluIEhlYWRlcnMg Ki8sCisJCQkJN0M1MTRFMDMyNEFGODA1RTAwNTA3MTBGIC8qIENvbG9yQ29udmVyc2lvbi5oIGlu IEhlYWRlcnMgKi8sCiAJCQkJMzEwM0I3REYxREIwMTU2NzAwOEJCODkwIC8qIENvbG9ySGFzaC5o IGluIEhlYWRlcnMgKi8sCiAJCQkJRjU1QjNEQjQxMjUxRjEyRDAwM0VGMjY5IC8qIENvbG9ySW5w dXRUeXBlLmggaW4gSGVhZGVycyAqLywKIAkJCQlDRTUxNjlFNzIxRjFCODQ3MDBFQTRGNzggLyog Q29sb3JJT1MuaCBpbiBIZWFkZXJzICovLApAQCAtMzM5MjMsNyArMzM5MzYsNiBAQAogCQkJCTkx Mjc4RDYyMjFERURBRjAwMEI1NzE4NCAvKiBXb3JrZXJBdWRpdEFnZW50LmggaW4gSGVhZGVycyAq LywKIAkJCQk0MUE3RDM1MzFGNDM4RDE2MDA4OTg4REUgLyogV29ya2VyQ2FjaGVTdG9yYWdlQ29u bmVjdGlvbi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTVCODFDQ0QxRkFBNDRERTAwMzdEMUU2IC8q IFdvcmtlckNvbnNvbGVBZ2VudC5oIGluIEhlYWRlcnMgKi8sCi0JCQkJN0M1MTRFMDMyNEFGODA1 RTAwNTA3MTBGIC8qIENvbG9yQ29udmVyc2lvbi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTU1NjM5 RDExQzZGMDlFMzAwODA2RDhFIC8qIFdvcmtlckNvbnNvbGVDbGllbnQuaCBpbiBIZWFkZXJzICov LAogCQkJCUE1QjgxQ0NFMUZBQTQ0REUwMDM3RDFFNiAvKiBXb3JrZXJEZWJ1Z2dlckFnZW50Lmgg aW4gSGVhZGVycyAqLywKIAkJCQlBNTJCMzQ5RTFGQTQxNzAzMDA4QjYyNDYgLyogV29ya2VyRGVi dWdnZXJQcm94eS5oIGluIEhlYWRlcnMgKi8sCkBAIC0zMzk5MCw2ICszNDAwMiw4IEBACiAJCQkJ MUFCN0ZDODQwQThCOTJFQzAwRDlEMzdCIC8qIFhQYXRoVXRpbC5oIGluIEhlYWRlcnMgKi8sCiAJ CQkJMUFCN0ZDODYwQThCOTJFQzAwRDlEMzdCIC8qIFhQYXRoVmFsdWUuaCBpbiBIZWFkZXJzICov LAogCQkJCTFBQjdGQzg4MEE4QjkyRUMwMEQ5RDM3QiAvKiBYUGF0aFZhcmlhYmxlUmVmZXJlbmNl LmggaW4gSGVhZGVycyAqLywKKwkJCQlDMTREMzA0OTI0QjRFQUIxMDA0ODAzODcgLyogWFBDRW5k cG9pbnQuaCBpbiBIZWFkZXJzICovLAorCQkJCUMxNEQzMDRGMjRCNEY4RkYwMDQ4MDM4NyAvKiBY UENFbmRwb2ludENsaWVudC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJRTFFRThCOUMyNDEzMTk1MDAw RTc5NEQ2IC8qIFhSRW52aXJvbm1lbnRCbGVuZE1vZGUuaCBpbiBIZWFkZXJzICovLAogCQkJCUUx RUU4Qjk3MjQxMzE5NTAwMEU3OTRENiAvKiBYUkV5ZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJRTFF RThCOEYyNDEzMTk1MDAwRTc5NEQ2IC8qIFhSRnJhbWVSZXF1ZXN0Q2FsbGJhY2suaCBpbiBIZWFk ZXJzICovLApAQCAtMzUxODUsNiArMzUxOTksOCBAQAogCQkJCUE4MzNDN0NDMEEyQ0YwNzQwMEQ1 NzY2NCAvKiBYTGlua05hbWVzLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUE4MzNDODBDMEEyQ0Yy NTYwMEQ1NzY2NCAvKiBYTUxOYW1lcy5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlFMTVBMzZEOTEx MDQ1NzI3MDBCN0I2MzkgLyogWE1MTlNOYW1lcy5jcHAgaW4gU291cmNlcyAqLywKKwkJCQlDMTRE MzA0QjI0QjRGN0VGMDA0ODAzODcgLyogWFBDRW5kcG9pbnQubW0gaW4gU291cmNlcyAqLywKKwkJ CQlDMTREMzA0RTI0QjRGOEZBMDA0ODAzODcgLyogWFBDRW5kcG9pbnRDbGllbnQubW0gaW4gU291 cmNlcyAqLywKIAkJCQlFMUVFOEI3QTI0MTMxOTFGMDBFNzk0RDYgLyogWFJJbnB1dFNvdXJjZUV2 ZW50LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUUxRUU4QkE3MjQxMzE5NjMwMEU3OTRENiAvKiBY UklucHV0U291cmNlc0NoYW5nZUV2ZW50LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUUxRUU4Qjk1 MjQxMzE5NTAwMEU3OTRENiAvKiBYUlJlZmVyZW5jZVNwYWNlRXZlbnQuY3BwIGluIFNvdXJjZXMg Ki8sCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9jb2NvYS9YUENFbmRwb2ludC5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29hL1hQQ0VuZHBvaW50LmgJ KG5vbmV4aXN0ZW50KQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vY29jb2EvWFBDRW5kcG9p bnQuaAkod29ya2luZyBjb3B5KQpAQCAtMCwwICsxLDU0IEBACisvKgorICogQ29weXJpZ2h0IChD KSAyMDIwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1 dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQK KyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dp bmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3Vy Y2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAy LiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3Zl IGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Ig b3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBU SElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRP UlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENP TlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURF TlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRV VEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBC VVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9S WSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZ LCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5H IElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ U0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI3ByYWdt YSBvbmNlCisKKyNpbmNsdWRlIDx3dGYvT1NPYmplY3RQdHIuaD4KKyNpbmNsdWRlIDx3dGYvc3Bp L2Rhcndpbi9YUENTUEkuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBYUENFbmRw b2ludCB7CitwdWJsaWM6CisgICAgV0VCQ09SRV9FWFBPUlQgWFBDRW5kcG9pbnQoKTsKKyAgICBX RUJDT1JFX0VYUE9SVCB2aXJ0dWFsIH5YUENFbmRwb2ludCgpID0gZGVmYXVsdDsKKworICAgIFdF QkNPUkVfRVhQT1JUIHZvaWQgc2VuZEVuZHBvaW50VG9Db25uZWN0aW9uKHhwY19jb25uZWN0aW9u X3QpOworCisgICAgV0VCQ09SRV9FWFBPUlQgT1NPYmplY3RQdHI8eHBjX2VuZHBvaW50X3Q+IGVu ZHBvaW50KCkgY29uc3Q7CisKKyAgICBzdGF0aWMgY29uc3RleHByIGF1dG8geHBjTWVzc2FnZU5h bWVLZXkgPSAibWVzc2FnZS1uYW1lIjsKKworcHJpdmF0ZToKKyAgICB2aXJ0dWFsIGNvbnN0IGNo YXIqIHhwY0VuZHBvaW50TWVzc2FnZU5hbWVLZXkoKSBjb25zdCA9IDA7CisgICAgdmlydHVhbCBj b25zdCBjaGFyKiB4cGNFbmRwb2ludE1lc3NhZ2VOYW1lKCkgY29uc3QgPSAwOworICAgIHZpcnR1 YWwgY29uc3QgY2hhciogeHBjRW5kcG9pbnROYW1lS2V5KCkgY29uc3QgPSAwOworICAgIHZpcnR1 YWwgdm9pZCBoYW5kbGVFdmVudCh4cGNfY29ubmVjdGlvbl90LCB4cGNfb2JqZWN0X3QpID0gMDsK KworICAgIE9TT2JqZWN0UHRyPHhwY19jb25uZWN0aW9uX3Q+IG1fY29ubmVjdGlvbjsKKyAgICBP U09iamVjdFB0cjx4cGNfZW5kcG9pbnRfdD4gbV9lbmRwb2ludDsKK307CisKK30KSW5kZXg6IFNv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29hL1hQQ0VuZHBvaW50Lm1tCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29hL1hQQ0VuZHBvaW50Lm1tCShub25leGlzdGVu dCkKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29hL1hQQ0VuZHBvaW50Lm1tCSh3b3Jr aW5nIGNvcHkpCkBAIC0wLDAgKzEsNzkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjAgQXBw bGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZp Y2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRp b25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11 c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdB UkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElT JycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JT CisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVD SUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisg KiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJ TElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQg KElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAq IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW1wb3J0ICJjb25maWcu aCIKKyNpbXBvcnQgIlhQQ0VuZHBvaW50LmgiCisKKyNpbXBvcnQgPHd0Zi9jb2NvYS9FbnRpdGxl bWVudHMuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitYUENFbmRwb2ludDo6WFBDRW5kcG9p bnQoKQoreworICAgIG1fY29ubmVjdGlvbiA9IGFkb3B0T1NPYmplY3QoeHBjX2Nvbm5lY3Rpb25f Y3JlYXRlKG51bGxwdHIsIG51bGxwdHIpKTsKKyAgICBtX2VuZHBvaW50ID0gYWRvcHRPU09iamVj dCh4cGNfZW5kcG9pbnRfY3JlYXRlKG1fY29ubmVjdGlvbi5nZXQoKSkpOworCisgICAgeHBjX2Nv bm5lY3Rpb25fc2V0X3RhcmdldF9xdWV1ZShtX2Nvbm5lY3Rpb24uZ2V0KCksIGRpc3BhdGNoX2dl dF9tYWluX3F1ZXVlKCkpOworICAgIHhwY19jb25uZWN0aW9uX3NldF9ldmVudF9oYW5kbGVyKG1f Y29ubmVjdGlvbi5nZXQoKSwgXih4cGNfb2JqZWN0X3QgbWVzc2FnZSkgeworICAgICAgICB4cGNf dHlwZV90IHR5cGUgPSB4cGNfZ2V0X3R5cGUobWVzc2FnZSk7CisKKyAgICAgICAgaWYgKHR5cGUg PT0gWFBDX1RZUEVfQ09OTkVDVElPTikgeworICAgICAgICAgICAgeHBjX2Nvbm5lY3Rpb25fdCBj b25uZWN0aW9uID0gbWVzc2FnZTsKKyAgICAgICAgICAgIGF1ZGl0X3Rva2VuX3QgYXVkaXRUb2tl bjsKKyAgICAgICAgICAgIHhwY19jb25uZWN0aW9uX2dldF9hdWRpdF90b2tlbihjb25uZWN0aW9u LCAmYXVkaXRUb2tlbik7CisKKyAgICAgICAgICAgIGlmICghV1RGOjpoYXNFbnRpdGxlbWVudChh dWRpdFRva2VuLCAiY29tLmFwcGxlLnByaXZhdGUud2Via2l0LnVzZS14cGMtZW5kcG9pbnQiKSkg eworICAgICAgICAgICAgICAgIC8vIFVuY29tbWVudCBiZWZvcmUgbGFuZGluZzsgdGhpcyBpcyBj b21tZW50ZWQgb3V0IGJlY2F1c2UgdGhlIGJvdHMgZG9lcyBub3Qgc2VlbSB0byB1cGRhdGUgdGhl IGVudGl0bGVtZW50cyBvbiBpbmNyZW1lbnRhbCBidWlsZHMuCisgICAgICAgICAgICAgICAgLy8g V1RGTG9nQWx3YXlzKCJBdWRpdCB0b2tlbiBkb2VzIG5vdCBoYXZlIHJlcXVpcmVkIGVudGl0bGVt ZW50Iik7CisgICAgICAgICAgICAgICAgLy8gcmV0dXJuOworICAgICAgICAgICAgfQorICAgICAg ICAgICAgeHBjX2Nvbm5lY3Rpb25fc2V0X3RhcmdldF9xdWV1ZShjb25uZWN0aW9uLCBkaXNwYXRj aF9nZXRfbWFpbl9xdWV1ZSgpKTsKKyAgICAgICAgICAgIHhwY19jb25uZWN0aW9uX3NldF9ldmVu dF9oYW5kbGVyKGNvbm5lY3Rpb24sIF4oeHBjX29iamVjdF90IGV2ZW50KSB7CisgICAgICAgICAg ICAgICAgaGFuZGxlRXZlbnQoY29ubmVjdGlvbiwgZXZlbnQpOworICAgICAgICAgICAgfSk7Cisg ICAgICAgICAgICB4cGNfY29ubmVjdGlvbl9yZXN1bWUoY29ubmVjdGlvbik7CisgICAgICAgIH0K KyAgICB9KTsKKyAgICB4cGNfY29ubmVjdGlvbl9yZXN1bWUobV9jb25uZWN0aW9uLmdldCgpKTsK K30KKwordm9pZCBYUENFbmRwb2ludDo6c2VuZEVuZHBvaW50VG9Db25uZWN0aW9uKHhwY19jb25u ZWN0aW9uX3QgY29ubmVjdGlvbikKK3sKKyAgICBpZiAoIWNvbm5lY3Rpb24pCisgICAgICAgIHJl dHVybjsKKworICAgIGF1dG8gbWVzc2FnZSA9IGFkb3B0T1NPYmplY3QoeHBjX2RpY3Rpb25hcnlf Y3JlYXRlKG51bGxwdHIsIG51bGxwdHIsIDApKTsKKyAgICB4cGNfZGljdGlvbmFyeV9zZXRfc3Ry aW5nKG1lc3NhZ2UuZ2V0KCksIHhwY0VuZHBvaW50TWVzc2FnZU5hbWVLZXkoKSwgeHBjRW5kcG9p bnRNZXNzYWdlTmFtZSgpKTsKKyAgICB4cGNfZGljdGlvbmFyeV9zZXRfdmFsdWUobWVzc2FnZS5n ZXQoKSwgeHBjRW5kcG9pbnROYW1lS2V5KCksIG1fZW5kcG9pbnQuZ2V0KCkpOworCisgICAgeHBj X2Nvbm5lY3Rpb25fc2VuZF9tZXNzYWdlKGNvbm5lY3Rpb24sIG1lc3NhZ2UuZ2V0KCkpOworfQor CitPU09iamVjdFB0cjx4cGNfZW5kcG9pbnRfdD4gWFBDRW5kcG9pbnQ6OmVuZHBvaW50KCkgY29u c3QKK3sKKyAgICByZXR1cm4gbV9lbmRwb2ludDsKK30KKworfQpJbmRleDogU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vY29jb2EvWFBDRW5kcG9pbnRDbGllbnQuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9jb2NvYS9YUENFbmRwb2ludENsaWVudC5oCShub25leGlzdGVu dCkKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29hL1hQQ0VuZHBvaW50Q2xpZW50LmgJ KHdvcmtpbmcgY29weSkKQEAgLTAsMCArMSw1MSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAy MCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBg QVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1F UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFS RSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklC VVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws IFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5F U1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNwcmFnbWEgb25j ZQorCisjaW5jbHVkZSA8d3RmL0xvY2suaD4KKyNpbmNsdWRlIDx3dGYvT1NPYmplY3RQdHIuaD4K KyNpbmNsdWRlIDx3dGYvc3BpL2Rhcndpbi9YUENTUEkuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUg eworCitjbGFzcyBYUENFbmRwb2ludENsaWVudCB7CitwdWJsaWM6CisgICAgdmlydHVhbCB+WFBD RW5kcG9pbnRDbGllbnQoKSB7IH0KKworICAgIFdFQkNPUkVfRVhQT1JUIHZvaWQgc2V0RW5kcG9p bnQoeHBjX2VuZHBvaW50X3QpOworCitwcm90ZWN0ZWQ6CisgICAgV0VCQ09SRV9FWFBPUlQgT1NP YmplY3RQdHI8eHBjX2Nvbm5lY3Rpb25fdD4gY29ubmVjdGlvbigpOworCitwcml2YXRlOgorICAg IHZpcnR1YWwgdm9pZCBoYW5kbGVFdmVudCh4cGNfb2JqZWN0X3QpID0gMDsKKyAgICB2aXJ0dWFs IHZvaWQgZGlkQ29ubmVjdCgpID0gMDsKKworICAgIE9TT2JqZWN0UHRyPHhwY19jb25uZWN0aW9u X3Q+IG1fY29ubmVjdGlvbjsKKyAgICBMb2NrIG1fbG9jazsKK307CisKK30KSW5kZXg6IFNvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29hL1hQQ0VuZHBvaW50Q2xpZW50Lm1tCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29hL1hQQ0VuZHBvaW50Q2xpZW50Lm1tCShu b25leGlzdGVudCkKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2NvY29hL1hQQ0VuZHBvaW50 Q2xpZW50Lm1tCSh3b3JraW5nIGNvcHkpCkBAIC0wLDAgKzEsODEgQEAKKy8qCisqIENvcHlyaWdo dCAoQykgMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisqCisqIFJlZGlzdHJp YnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91 dAorKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMKKyogYXJlIG1ldDoKKyogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorKiAyLiBS ZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNv cHlyaWdodAorKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisqCisqIFRISVMgU09G VFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFT IElTJycKKyogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sCisqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hB TlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyogUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JT CisqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJ QUwsIEVYRU1QTEFSWSwgT1IKKyogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyogU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisqIElO VEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZ LCBXSEVUSEVSIElOCisqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyogVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorKi8KKworI2ltcG9ydCAiY29uZmlnLmgiCisjaW1w b3J0ICJYUENFbmRwb2ludENsaWVudC5oIgorCisjaW1wb3J0IDx3dGYvY29jb2EvRW50aXRsZW1l bnRzLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwordm9pZCBYUENFbmRwb2ludENsaWVudDo6 c2V0RW5kcG9pbnQoeHBjX2VuZHBvaW50X3QgZW5kcG9pbnQpCit7CisgICAgeworICAgICAgICBM b2NrSG9sZGVyIGxvY2tlcihtX2xvY2spOworCisgICAgICAgIGlmIChtX2Nvbm5lY3Rpb24pCisg ICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgbV9jb25uZWN0aW9uID0gYWRvcHRPU09iamVj dCh4cGNfY29ubmVjdGlvbl9jcmVhdGVfZnJvbV9lbmRwb2ludChlbmRwb2ludCkpOworCisgICAg ICAgIHhwY19jb25uZWN0aW9uX3NldF90YXJnZXRfcXVldWUobV9jb25uZWN0aW9uLmdldCgpLCBk aXNwYXRjaF9nZXRfZ2xvYmFsX3F1ZXVlKERJU1BBVENIX1FVRVVFX1BSSU9SSVRZX0RFRkFVTFQs IDApKTsKKyAgICAgICAgeHBjX2Nvbm5lY3Rpb25fc2V0X2V2ZW50X2hhbmRsZXIobV9jb25uZWN0 aW9uLmdldCgpLCBeKHhwY19vYmplY3RfdCBtZXNzYWdlKSB7CisgICAgICAgICAgICB4cGNfdHlw ZV90IHR5cGUgPSB4cGNfZ2V0X3R5cGUobWVzc2FnZSk7CisgICAgICAgICAgICBpZiAodHlwZSA9 PSBYUENfVFlQRV9FUlJPUikgeworICAgICAgICAgICAgICAgIGlmIChtZXNzYWdlID09IFhQQ19F UlJPUl9DT05ORUNUSU9OX0lOVkFMSUQgfHwgbWVzc2FnZSA9PSBYUENfRVJST1JfVEVSTUlOQVRJ T05fSU1NSU5FTlQpIHsKKyAgICAgICAgICAgICAgICAgICAgTG9ja0hvbGRlciBsb2NrZXIobV9s b2NrKTsKKyAgICAgICAgICAgICAgICAgICAgbV9jb25uZWN0aW9uID0gbnVsbHB0cjsKKyAgICAg ICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgcmV0dXJuOworICAgICAgICAgICAgfQorICAg ICAgICAgICAgaWYgKHR5cGUgIT0gWFBDX1RZUEVfRElDVElPTkFSWSkKKyAgICAgICAgICAgICAg ICByZXR1cm47CisKKyAgICAgICAgICAgIGF1dG8gY29ubmVjdGlvbiA9IHhwY19kaWN0aW9uYXJ5 X2dldF9yZW1vdGVfY29ubmVjdGlvbihtZXNzYWdlKTsKKyAgICAgICAgICAgIGlmICghY29ubmVj dGlvbikKKyAgICAgICAgICAgICAgICByZXR1cm47CisgICAgICAgICAgICBhdWRpdF90b2tlbl90 IGF1ZGl0VG9rZW47CisgICAgICAgICAgICB4cGNfY29ubmVjdGlvbl9nZXRfYXVkaXRfdG9rZW4o Y29ubmVjdGlvbiwgJmF1ZGl0VG9rZW4pOworICAgICAgICAgICAgaWYgKCFXVEY6Omhhc0VudGl0 bGVtZW50KGF1ZGl0VG9rZW4sICJjb20uYXBwbGUucHJpdmF0ZS53ZWJraXQudXNlLXhwYy1lbmRw b2ludCIpKSB7CisgICAgICAgICAgICAgICAgLy8gVW5jb21tZW50IGJlZm9yZSBsYW5kaW5nOyB0 aGlzIGlzIGNvbW1lbnRlZCBvdXQgYmVjYXVzZSB0aGUgYm90cyBkb2VzIG5vdCBzZWVtIHRvIHVw ZGF0ZSB0aGUgZW50aXRsZW1lbnRzIG9uIGluY3JlbWVudGFsIGJ1aWxkcy4KKyAgICAgICAgICAg ICAgICAvLyBXVEZMb2dBbHdheXMoIkF1ZGl0IHRva2VuIGRvZXMgbm90IGhhdmUgcmVxdWlyZWQg ZW50aXRsZW1lbnQiKTsKKyAgICAgICAgICAgICAgICAvLyByZXR1cm47CisgICAgICAgICAgICB9 CisgICAgICAgICAgICBoYW5kbGVFdmVudChtZXNzYWdlKTsKKyAgICAgICAgfSk7CisKKyAgICAg ICAgeHBjX2Nvbm5lY3Rpb25fcmVzdW1lKG1fY29ubmVjdGlvbi5nZXQoKSk7CisgICAgfQorCisg ICAgZGlkQ29ubmVjdCgpOworfQorCitPU09iamVjdFB0cjx4cGNfY29ubmVjdGlvbl90PiBYUENF bmRwb2ludENsaWVudDo6Y29ubmVjdGlvbigpCit7CisgICAgTG9ja0hvbGRlciBsb2NrZXIobV9s b2NrKTsKKyAgICByZXR1cm4gbV9jb25uZWN0aW9uOworfQorCit9CkluZGV4OiBUb29scy9DaGFu Z2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvQ2hhbmdlTG9nCShyZXZpc2lvbiAyNjQwMzkpCisr KyBUb29scy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNCBAQAorMjAyMC0w Ny0wNyAgUGVyIEFybmUgVm9sbGFuICA8cHZvbGxhbkBhcHBsZS5jb20+CisKKyAgICAgICAgW0Nv Y29hXSBNYWtlIGl0IHBvc3NpYmxlIHRvIGVzdGFibGlzaCBkaXJlY3QgWFBDIGNvbm5lY3Rpb25z IGJldHdlZW4gV2ViS2l0IHByb2Nlc3NlcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjE0MDc5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgQnJlbnQgRnVs Z2hhbS4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ov cHJvamVjdC5wYnhwcm9qOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0L1hQ Q0VuZHBvaW50Lm1tOiBBZGRlZC4KKyAgICAgICAgKFRFU1QpOgorCiAyMDIwLTA3LTA3ICBBbGV4 IENocmlzdGVuc2VuICA8YWNocmlzdGVuc2VuQHdlYmtpdC5vcmc+CiAKICAgICAgICAgQWRkIFdl YkNvcmVOU1VSTFNlc3Npb24gU1BJIHRvIHNlbmQgSFRUUC8yIHBpbmcKSW5kZXg6IFRvb2xzL1Rl c3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qCShyZXZpc2lvbiAyNjQwMzkpCisrKyBUb29scy9UZXN0V2ViS2l0QVBJL1Rl c3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagkod29ya2luZyBjb3B5KQpAQCAt OTA4LDYgKzkwOCw3IEBACiAJCUMwQzVEM0M2MTQ1OTkxMjkwMEE4MDJBNiAvKiBHZXRCYWNraW5n U2NhbGVGYWN0b3JfQnVuZGxlLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gQzBDNUQzQkQxNDU5OEI2RjAwQTgwMkE2IC8qIEdldEJhY2tpbmdTY2FsZUZh Y3Rvcl9CdW5kbGUubW0gKi87IH07CiAJCUMxM0Q4MkQ5MjQxNkYxMzIwMEE2Mjc5MyAvKiBFbmFi bGVBY2Nlc3NpYmlsaXR5Lm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gQzEzRDgyRDgyNDE2RjEzMjAwQTYyNzkzIC8qIEVuYWJsZUFjY2Vzc2liaWxpdHku bW0gKi87IH07CiAJCUMxNDlENTUwMjQyRTk4REYwMDNFQkIxMiAvKiBTbGVlcERpc2FibGVyLm1t IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzE0OUQ1NEYy NDJFOTg0NDAwM0VCQjEyIC8qIFNsZWVwRGlzYWJsZXIubW0gKi87IH07CisJCUMxNEQzMDQ2MjRC NEMzQkEwMDQ4MDM4NyAvKiBYUENFbmRwb2ludC5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEMxNEQzMDQ1MjRCNEMzQkEwMDQ4MDM4NyAvKiBYUENFbmRw b2ludC5tbSAqLzsgfTsKIAkJQzE1Q0JCMzAyM0YxRkYxQTAwMzAwQ0M3IC8qIEJhY2tsaWdodExl dmVsTm90aWZpY2F0aW9uLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gQzE1Q0JCMkYyM0YxRkYxQTAwMzAwQ0M3IC8qIEJhY2tsaWdodExldmVsTm90aWZp Y2F0aW9uLm1tICovOyB9OwogCQlDMTVDQkIzRjIzRkIxNzdBMDAzMDBDQzcgLyogUHJlZmVyZW5j ZUNoYW5nZXMubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSBDMTVDQkIzRTIzRkIxNzdBMDAzMDBDQzcgLyogUHJlZmVyZW5jZUNoYW5nZXMubW0gKi87IH07 CiAJCUMxNjkyRENBMjNEMTBEQUUwMDZFODhGNyAvKiBCYXR0ZXJ5Lm1tIGluIFNvdXJjZXMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzE2OTJEQzkyM0QxMERBRTAwNkU4OEY3 IC8qIEJhdHRlcnkubW0gKi87IH07CkBAIC0yNTQ5LDYgKzI1NTAsNyBAQAogCQlDMEM1RDNCRDE0 NTk4QjZGMDBBODAyQTYgLyogR2V0QmFja2luZ1NjYWxlRmFjdG9yX0J1bmRsZS5tbSAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IEdldEJhY2tpbmdTY2FsZUZhY3Rvcl9C dW5kbGUubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUMxM0Q4MkQ4MjQxNkYxMzIw MEE2Mjc5MyAvKiBFbmFibGVBY2Nlc3NpYmlsaXR5Lm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0g RW5hYmxlQWNjZXNzaWJpbGl0eS5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQzE0 OUQ1NEYyNDJFOTg0NDAwM0VCQjEyIC8qIFNsZWVwRGlzYWJsZXIubW0gKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBTbGVlcERpc2FibGVyLm1tOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OworCQlDMTREMzA0NTI0QjRDM0JBMDA0ODAzODcgLyogWFBDRW5kcG9pbnQu bW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBYUENFbmRwb2ludC5tbTsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJQzE1Q0JCMkYyM0YxRkYxQTAwMzAwQ0M3IC8qIEJhY2tsaWdodExldmVs Tm90aWZpY2F0aW9uLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gQmFja2xpZ2h0TGV2ZWxOb3Rp ZmljYXRpb24ubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUMxNUNCQjNFMjNGQjE3 N0EwMDMwMENDNyAvKiBQcmVmZXJlbmNlQ2hhbmdlcy5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLm9iamNwcDsgcGF0aCA9IFByZWZlcmVuY2VDaGFuZ2VzLm1tOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQlDMTY5MkRDOTIzRDEwREFFMDA2RTg4RjcgLyogQmF0dGVyeS5tbSAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLm9iamNwcDsgcGF0aCA9IEJhdHRlcnkubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CkBAIC0zMDMzLDYgKzMwMzUsNyBAQAogCQkJCUMxNDlENTRGMjQyRTk4NDQwMDNFQkIxMiAvKiBT bGVlcERpc2FibGVyLm1tICovLAogCQkJCTBGMTM5RTc1MUE0MjNBNTMwMEY1OTBGNSAvKiBXZWFr T2JqQ1B0ci5tbSAqLywKIAkJCQlDMUZGOUVEQTI0NDY0NEYwMDA4MzlBRTQgLyogV2ViRmlsdGVy Lm1tICovLAorCQkJCUMxNEQzMDQ1MjRCNEMzQkEwMDQ4MDM4NyAvKiBYUENFbmRwb2ludC5tbSAq LywKIAkJCSk7CiAJCQluYW1lID0gY29jb2E7CiAJCQlzb3VyY2VUcmVlID0gIjxncm91cD4iOwpA QCAtNTM3Niw2ICs1Mzc5LDcgQEAKIAkJCQlDRDdGODlEQzIyQTg2Q0RBMDBENjgzQUUgLyogV0tX ZWJWaWV3U3VzcGVuZEFsbE1lZGlhUGxheWJhY2subW0gaW4gU291cmNlcyAqLywKIAkJCQk5OTg0 RkFDQzFDRkZBRjYwMDA4RDE5OEMgLyogV0tXZWJWaWV3VGV4dElucHV0Lm1tIGluIFNvdXJjZXMg Ki8sCiAJCQkJN0M3NEM4RkEyMkRGQkE5NjAwREEyREFCIC8qIFdURlN0cmluZ1V0aWxpdGllcy5j cHAgaW4gU291cmNlcyAqLywKKwkJCQlDMTREMzA0NjI0QjRDM0JBMDA0ODAzODcgLyogWFBDRW5k cG9pbnQubW0gaW4gU291cmNlcyAqLywKIAkJCQk5QzY0REMzMjFENzYxOThBMDA0QjU5OEUgLyog WW91VHViZVBsdWdpblJlcGxhY2VtZW50LmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsKIAkJCXJ1 bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwpJbmRleDogVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0cy9XZWJLaXQvWFBDRW5kcG9pbnQubW0KPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMv VGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQvWFBDRW5kcG9pbnQubW0JKG5vbmV4aXN0ZW50KQor KysgVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQvWFBDRW5kcG9pbnQubW0JKHdvcmtp bmcgY29weSkKQEAgLTAsMCArMSw5NSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMCBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMn JworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVND TEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMK KyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJ QUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAq IElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklM SVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZ IE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICog VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbXBvcnQgImNvbmZpZy5o IgorI2ltcG9ydCAiUGxhdGZvcm1VdGlsaXRpZXMuaCIKKworI2ltcG9ydCA8V2ViQ29yZS9YUENF bmRwb2ludC5oPgorI2ltcG9ydCA8V2ViQ29yZS9YUENFbmRwb2ludENsaWVudC5oPgorI2ltcG9y dCA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CisKK3N0YXRpYyBib29sIGNsaWVudENvbm5lY3RlZFRv RW5kcG9pbnQgPSBmYWxzZTsKK3N0YXRpYyBib29sIGVuZHBvaW50UmVjZWl2ZWRNZXNzYWdlRnJv bUNsaWVudCA9IGZhbHNlOworc3RhdGljIGJvb2wgY2xpZW50UmVjZWl2ZWRNZXNzYWdlRnJvbUVu ZHBvaW50ID0gZmFsc2U7CisKK3N0YXRpYyBjb25zdGV4cHIgYXV0byB0ZXN0TWVzc2FnZUZyb21F bmRwb2ludCA9ICJ0ZXN0LW1lc3NhZ2UtZnJvbS1lbmRwb2ludCI7CitzdGF0aWMgY29uc3RleHBy IGF1dG8gdGVzdE1lc3NhZ2VGcm9tQ2xpZW50ID0gInRlc3QtbWVzc2FnZS1mcm9tLWNsaWVudCI7 CisKK2NsYXNzIFhQQ0VuZHBvaW50IDogcHVibGljIFdlYkNvcmU6OlhQQ0VuZHBvaW50IHsKK3By aXZhdGU6CisgICAgY29uc3QgY2hhciogeHBjRW5kcG9pbnRNZXNzYWdlTmFtZUtleSgpIGNvbnN0 IG92ZXJyaWRlCisgICAgeworICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICB9CisgICAgY29u c3QgY2hhciogeHBjRW5kcG9pbnRNZXNzYWdlTmFtZSgpIGNvbnN0IG92ZXJyaWRlCisgICAgewor ICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICB9CisgICAgY29uc3QgY2hhciogeHBjRW5kcG9p bnROYW1lS2V5KCkgY29uc3Qgb3ZlcnJpZGUKKyAgICB7CisgICAgICAgIHJldHVybiBudWxscHRy OworICAgIH0KKyAgICB2b2lkIGhhbmRsZUV2ZW50KHhwY19jb25uZWN0aW9uX3QgY29ubmVjdGlv biwgeHBjX29iamVjdF90IGV2ZW50KSBvdmVycmlkZQorICAgIHsKKyAgICAgICAgU3RyaW5nIG1l c3NhZ2VOYW1lID0geHBjX2RpY3Rpb25hcnlfZ2V0X3N0cmluZyhldmVudCwgWFBDRW5kcG9pbnQ6 OnhwY01lc3NhZ2VOYW1lS2V5KTsKKyAgICAgICAgaWYgKG1lc3NhZ2VOYW1lID09IHRlc3RNZXNz YWdlRnJvbUNsaWVudCkgeworICAgICAgICAgICAgZW5kcG9pbnRSZWNlaXZlZE1lc3NhZ2VGcm9t Q2xpZW50ID0gdHJ1ZTsKKworICAgICAgICAgICAgYXV0byBtZXNzYWdlID0gYWRvcHRPU09iamVj dCh4cGNfZGljdGlvbmFyeV9jcmVhdGUobnVsbHB0ciwgbnVsbHB0ciwgMCkpOworICAgICAgICAg ICAgeHBjX2RpY3Rpb25hcnlfc2V0X3N0cmluZyhtZXNzYWdlLmdldCgpLCBYUENFbmRwb2ludDo6 eHBjTWVzc2FnZU5hbWVLZXksIHRlc3RNZXNzYWdlRnJvbUVuZHBvaW50KTsKKyAgICAgICAgICAg IHhwY19jb25uZWN0aW9uX3NlbmRfbWVzc2FnZShjb25uZWN0aW9uLCBtZXNzYWdlLmdldCgpKTsK KyAgICAgICAgfQorICAgIH0KK307CisKK2NsYXNzIFhQQ0VuZHBvaW50Q2xpZW50IDogcHVibGlj IFdlYkNvcmU6OlhQQ0VuZHBvaW50Q2xpZW50IHsKK3ByaXZhdGU6CisgICAgdm9pZCBoYW5kbGVF dmVudCh4cGNfb2JqZWN0X3QgZXZlbnQpIG92ZXJyaWRlCisgICAgeworICAgICAgICBTdHJpbmcg bWVzc2FnZU5hbWUgPSB4cGNfZGljdGlvbmFyeV9nZXRfc3RyaW5nKGV2ZW50LCBYUENFbmRwb2lu dDo6eHBjTWVzc2FnZU5hbWVLZXkpOworICAgICAgICBpZiAobWVzc2FnZU5hbWUgPT0gdGVzdE1l c3NhZ2VGcm9tRW5kcG9pbnQpCisgICAgICAgICAgICBjbGllbnRSZWNlaXZlZE1lc3NhZ2VGcm9t RW5kcG9pbnQgPSB0cnVlOworICAgIH0KKyAgICB2b2lkIGRpZENvbm5lY3QoKSBvdmVycmlkZQor ICAgIHsKKyAgICAgICAgYXV0byBtZXNzYWdlID0gYWRvcHRPU09iamVjdCh4cGNfZGljdGlvbmFy eV9jcmVhdGUobnVsbHB0ciwgbnVsbHB0ciwgMCkpOworICAgICAgICB4cGNfZGljdGlvbmFyeV9z ZXRfc3RyaW5nKG1lc3NhZ2UuZ2V0KCksIFhQQ0VuZHBvaW50Ojp4cGNNZXNzYWdlTmFtZUtleSwg dGVzdE1lc3NhZ2VGcm9tQ2xpZW50KTsKKyAgICAgICAgeHBjX2Nvbm5lY3Rpb25fc2VuZF9tZXNz YWdlKGNvbm5lY3Rpb24oKS5nZXQoKSwgbWVzc2FnZS5nZXQoKSk7CisKKyAgICAgICAgY2xpZW50 Q29ubmVjdGVkVG9FbmRwb2ludCA9IHRydWU7CisgICAgfQorfTsKKworVEVTVChXZWJLaXQsIFhQ Q0VuZHBvaW50KQoreworICAgIFhQQ0VuZHBvaW50IHhwY0VuZHBvaW50OworICAgIFhQQ0VuZHBv aW50Q2xpZW50IHhwY0VuZHBvaW50Q2xpZW50OworCisgICAgeHBjRW5kcG9pbnRDbGllbnQuc2V0 RW5kcG9pbnQoeHBjRW5kcG9pbnQuZW5kcG9pbnQoKS5nZXQoKSk7CisKKyAgICBUZXN0V2ViS2l0 QVBJOjpVdGlsOjpydW4oJmNsaWVudENvbm5lY3RlZFRvRW5kcG9pbnQpOworICAgIFRlc3RXZWJL aXRBUEk6OlV0aWw6OnJ1bigmZW5kcG9pbnRSZWNlaXZlZE1lc3NhZ2VGcm9tQ2xpZW50KTsKKyAg ICBUZXN0V2ViS2l0QVBJOjpVdGlsOjpydW4oJmNsaWVudFJlY2VpdmVkTWVzc2FnZUZyb21FbmRw b2ludCk7Cit9Cg==