126384 CVE-2018-11713 2014-01-02 08:11:22 -0800 [SOUP] WebSockets must use system proxy settings 2018-06-04 08:09:45 -0700 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED https://bugzilla.gnome.org/show_bug.cgi?id=792212 https://bugs.webkit.org/show_bug.cgi?id=184804 P1 Critical --- 1 dirkjan webkit-unassigned bugs-noreply cgarcia clopez csaavedra danw gustavo mcatanzaro silviapf svillar oldest_to_newest 963752 0 dirkjan 2014-01-02 08:11:22 -0800 Currently, it doesn't appear like WebSockets will work with proxies. I'd like to fix that. 963754 1 220225 dirkjan 2014-01-02 08:19:01 -0800 Created attachment 220225 Use new libsoup function to get a proxied GIOStream Here's a WIP patch. I'd like for this to get a preliminary review. It probably doesn't apply cleanly to current HEAD, but I'd like to gather some comments on the design. The patch relies on a new function in libsoup. That work is being tracked in https://bugzilla.gnome.org/show_bug.cgi?id=721343. I was advised there that extracting a GIOStream from libsoup made the most sense, which is why I also replaced the GSocketConnection in SocketStreamHandle by a GIOStream. I'm aware of the changes from bug 88094, so I'm also wondering how that would make sense to integrate. 963761 2 cgarcia 2014-01-02 08:59:18 -0800 (In reply to comment #1) > Created an attachment (id=220225) [details] > Use new libsoup function to get a proxied GIOStream This looks like a libsoup patch, you should use the GNOME bugzilla instead. > Here's a WIP patch. I'd like for this to get a preliminary review. It probably doesn't apply cleanly to current HEAD, but I'd like to gather some comments on the design. It's ok to submit WIP patches to bugzilla for early reviews, but do not set the r? flag in such case. > The patch relies on a new function in libsoup. That work is being tracked in https://bugzilla.gnome.org/show_bug.cgi?id=721343. I was advised there that extracting a GIOStream from libsoup made the most sense, which is why I also replaced the GSocketConnection in SocketStreamHandle by a GIOStream. I'm aware of the changes from bug 88094, so I'm also wondering how that would make sense to integrate. hmm, I think you submitted the libsoup patch here instead by mistake :-) 964026 3 220284 dirkjan 2014-01-02 23:50:43 -0800 Created attachment 220284 Use new libsoup function to get a proxied GIOStream 964027 4 dirkjan 2014-01-02 23:51:30 -0800 (In reply to comment #2) > This looks like a libsoup patch, you should use the GNOME bugzilla instead. Doh! You're right, of course. I've now attached the correct patch. > It's ok to submit WIP patches to bugzilla for early reviews, but do not set the r? flag in such case. Okay, sorry about that! 964082 5 220284 mrobinson 2014-01-03 06:40:38 -0800 Comment on attachment 220284 Use new libsoup function to get a proxied GIOStream View in context: https://bugs.webkit.org/attachment.cgi?id=220284&action=review > WebCore/platform/network/soup/SocketStreamHandleSoup.cpp:-94 > - if (url.protocolIs("wss")) > - g_socket_client_set_tls(socketClient.get(), TRUE); Why are you removing this code? Doesn't this break secure web sockets? > WebCore/platform/network/soup/SocketStreamHandleSoup.cpp:94 > + soup_session_proxy_connect(session, uri, connectedCallback, m_id); Is this the only change related to proxy support? > WebCore/platform/network/soup/SocketStreamHandleSoup.cpp:238 > -static void connectedCallback(GSocketClient* client, GAsyncResult* result, void* id) > +static void connectedCallback(GIOStream *iostream, GError *error, void* id) Is the GIOStream here actually a GSocketClient? If so, perhaps it would make more sense to cast it and avoid the rest of your changes. 964086 6 dirkjan 2014-01-03 06:51:36 -0800 (In reply to comment #5) > (From update of attachment 220284 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=220284&action=review > > > WebCore/platform/network/soup/SocketStreamHandleSoup.cpp:-94 > > - if (url.protocolIs("wss")) > > - g_socket_client_set_tls(socketClient.get(), TRUE); > > Why are you removing this code? Doesn't this break secure web sockets? I doesn't seem to in my testing. Before my patch, SocketStreamHandles rely on the pretty low-level GSocketClient API. By using more libsoup infrastructure, this kind of thing is handled for us. In this case, I think (but have not verified) that libsoup can figure out from the URL that TLS support is required. > > > WebCore/platform/network/soup/SocketStreamHandleSoup.cpp:94 > > + soup_session_proxy_connect(session, uri, connectedCallback, m_id); > > Is this the only change related to proxy support? Yes, this is the core of the motivating change. > > WebCore/platform/network/soup/SocketStreamHandleSoup.cpp:238 > > -static void connectedCallback(GSocketClient* client, GAsyncResult* result, void* id) > > +static void connectedCallback(GIOStream *iostream, GError *error, void* id) > > Is the GIOStream here actually a GSocketClient? If so, perhaps it would make more sense to cast it and avoid the rest of your changes. Probably! IIRC danw suggested the use of GIOStream in the soup_session_proxy_connect() API. It seems to me like maybe GSocketConnection makes more sense there. If not, then casting on the WebKit side would be fine as far as I'm concerned. 964092 7 danw 2014-01-03 07:02:54 -0800 (In reply to comment #5) > Is the GIOStream here actually a GSocketClient? If so, perhaps it would make more sense to cast it and avoid the rest of your changes. You mean "actually a GSocketConnection". And yes, it is, but the point of returning a GIOStream rather than a GSocketConnection is that you mostly don't care that it's a GSocketConnection specifically. ie, in the current code, every single place in SocketStreamHandleSoup that uses it casts it to a GIOStream first. So it makes more sense to just have it be an iostream. 964100 8 220303 dirkjan 2014-01-03 07:46:00 -0800 Created attachment 220303 Version of the patch that applies to recent WebKit SVN 1336929 9 silviapf 2017-08-09 05:41:49 -0700 Corporate networks often have machines behind a Web proxy. Is this bug going to get addressed, so websockets can be used in corporate networks? I'm particularly curious because WebRTC is about to be released in WebKit/Safari and many WebRTC applications use a websocket signalling server. 1336938 10 clopez 2017-08-09 06:13:19 -0700 (In reply to Silvia Pfeiffer from comment #9) > Corporate networks often have machines behind a Web proxy. Is this bug going > to get addressed, so websockets can be used in corporate networks? I'm > particularly curious because WebRTC is about to be released in WebKit/Safari > and many WebRTC applications use a websocket signalling server. The Mac or iOS ports of WebKit (the ones used in Safari) don't use the soup backend for network access. So this bug doesn't affect them. The libsoup network backend is only used by the GTK+ and WPE ports of WebKit, and WebRTC support on this ports is still a WIP. 1336956 11 mcatanzaro 2017-08-09 08:23:11 -0700 Oh wow, if WebKit's implementation of WebSockets does not respect GNOME's proxy settings, that's very bad. These kinds of bugs are what get people arrested or killed. Dirkjan, are you still watching your bugmail? Do you know what the status of this is? 1336959 12 mcatanzaro 2017-08-09 08:24:48 -0700 I've also considered if maybe we should be using libsoup's implementation of WebSockets rather than WebKit's implementation. I always assumed that WebKit's implementation was likely to have fewer bugs. Silly me. 1337004 13 clopez 2017-08-09 09:48:49 -0700 (In reply to Michael Catanzaro from comment #12) > I've also considered if maybe we should be using libsoup's implementation of > WebSockets rather than WebKit's implementation. I always assumed that > WebKit's implementation was likely to have fewer bugs. Silly me. Do you know something about the quality of the libsoup WebSocket implementation and/or about any project that uses it? Keep in mind _any_ implementation is going to have bugs. 1337047 14 danw 2017-08-09 11:02:23 -0700 (In reply to Carlos Alberto Lopez Perez from comment #13) > (In reply to Michael Catanzaro from comment #12) > > I've also considered if maybe we should be using libsoup's implementation of > > WebSockets rather than WebKit's implementation. I always assumed that > > WebKit's implementation was likely to have fewer bugs. Silly me. (Of course, this bug predates libsoup's WebSockets implementation.) > Do you know something about the quality of the libsoup WebSocket > implementation and/or about any project that uses it? > Keep in mind _any_ implementation is going to have bugs. The actual WebSockets implementation isn't all that complicated. The code for letting SoupSession make a (possibly-proxied) connection to a server, and then stealing that GIOStream from SoupSession to use as a websockets connection is kind of tricky, but of course, that's exactly the code that the patch here makes use of, so you'd be using it either way. (Well, the patch here is written against Dirkjan's original proposal that isn't quite how things eventually got implemented, but it would be similar.) Anyway, a handful of people are using libsoup's websockets code now, (and it was originally based on cockpit's code that had been in use for a few years before that). And I assume WebKit has some WebSockets tests anyway that would validate that it was good enough for WebKit purposes? 1337379 15 cgarcia 2017-08-10 04:14:10 -0700 (In reply to Dan Winship from comment #14) > (In reply to Carlos Alberto Lopez Perez from comment #13) > > (In reply to Michael Catanzaro from comment #12) > > > I've also considered if maybe we should be using libsoup's implementation of > > > WebSockets rather than WebKit's implementation. I always assumed that > > > WebKit's implementation was likely to have fewer bugs. Silly me. > > (Of course, this bug predates libsoup's WebSockets implementation.) Yes, that's why we don't use the libsoup one, not because it's more or less buggy, we always prefer to use libsoup (well, except in the case of the disk cache, because the webkit implementation is much better and shared with all other ports). > > Do you know something about the quality of the libsoup WebSocket > > implementation and/or about any project that uses it? > > Keep in mind _any_ implementation is going to have bugs. > > The actual WebSockets implementation isn't all that complicated. The code > for letting SoupSession make a (possibly-proxied) connection to a server, > and then stealing that GIOStream from SoupSession to use as a websockets > connection is kind of tricky, but of course, that's exactly the code that > the patch here makes use of, so you'd be using it either way. (Well, the > patch here is written against Dirkjan's original proposal that isn't quite > how things eventually got implemented, but it would be similar.) > > Anyway, a handful of people are using libsoup's websockets code now, (and it > was originally based on cockpit's code that had been in use for a few years > before that). And I assume WebKit has some WebSockets tests anyway that > would validate that it was good enough for WebKit purposes? WebSockets were added to libsoup in 2.50, IIRC, and we depend on 2.40, so we still need to fix our implementation. Then we can use libsoup, but we will have to use ifdefs. 1337384 16 dirkjan 2017-08-10 04:29:29 -0700 Michael: yeah, I'm still reading my bug mail. We've had this working in our internal WebKit fork, based on an also-forked libsoup pinned to somewhere 2.45ish. If there's interest I can try to dig out our patches. 1337424 17 mcatanzaro 2017-08-10 08:19:36 -0700 Yes we're definitely interested, thanks. 1373008 18 327158 dirkjan 2017-11-17 02:30:46 -0800 Created attachment 327158 WebKit patches for libsoup WebSockets over proxy 1373009 19 327159 dirkjan 2017-11-17 02:31:11 -0800 Created attachment 327159 libsoup patches for libsoup WebSockets over proxy 1373010 20 dirkjan 2017-11-17 02:31:58 -0800 I made a quick attempt at extracting the relevant patches from our libsoup and WebKit repositories. Hope this helps. If you have questions or something seems missing, let me know and I can have another look. 1373773 21 csaavedra 2017-11-20 07:11:43 -0800 Would you mind submitting the libsoup patches to GNOME bugzilla? Please use separate bug reports if they tackle different issues, as it seems to be the case, then we can see about getting them reviewed and in. 1373807 22 dirkjan 2017-11-20 11:03:14 -0800 See also the libsoup bug mentioned in comment 1. I have no further desire to chase these issues, so I'll leave any new work in creating libsoup bugs to others. 1385415 23 cgarcia 2018-01-03 04:45:26 -0800 If we need new libsoup API in both cases, then I think it's better to keep current impl for older soup versions and use soup web sockets for newer versions then. 1385749 24 cgarcia 2018-01-04 01:06:12 -0800 I've looked at this and we can't really use the libsoup websockets API, because WebKit already implements websockets protocol, the only platform specific part is creating a network connection to send and receive data from. That's lower level than the libsoup websockets API. We can't use soup_session_steal_connection() either, because you are expected to steal the connection when upgrading the protocol once 101 response is returned from the server. However, we need the connection before to properly send the upgrade message. So, we indeed need new API in libsoup to create a connection using ssl and proxy as with any other HTTP connection, but returning the GIOStream for the socket *before* any data is sent. 1385750 25 cgarcia 2018-01-04 01:07:18 -0800 Dirkjan, why do you need to force the tunneling in libsoup when creating a connection for the websockets? 1386085 26 330537 cgarcia 2018-01-05 00:15:53 -0800 Created attachment 330537 Patch 1386218 27 330537 mcatanzaro 2018-01-05 12:49:20 -0800 Comment on attachment 330537 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=330537&action=review Thanks for fixing this exceptionally serious issue. We definitely need to request a CVE. I can handle that. How hard would it be to extend testWebContextProxySettings in TestWebKitWebContext.cpp to test this? > Source/WebCore/platform/network/soup/SocketStreamHandleImplSoup.cpp:58 > +#if SOUP_CHECK_VERSION(2, 61, 2) I see a few different options here: (a) We could stick with what you implemented. But I suggest we do not allow web socket connections to ignore proxy settings under any circumstances, certainly not just because libsoup is too old. (b) We could ignore our usual dependency policy and require newer libsoup. This would be justified by the severity of this issue. We'd have to send a notice and apology to distributors-list and inform them of the need to update libsoup. Debian would probably refuse. Not great. (c) We could disable WebSocket support if libsoup is not new enough. This will break loads of websites. (d) We could disable WebSocket support if libsoup is not new enough *and* a system proxy is configured. Websites only break if a proxy is configured. (d) seems like the best approach to me. What do you think? If we go with (a) or (b) or (c), then we'll certainly need to be backport your new API to libsoup 2.60. But I'm OK with temporarily breaking web sockets for proxy users, so we wouldn't need to do that if we take approach (d). 1386663 28 330682 cgarcia 2018-01-08 04:28:46 -0800 Created attachment 330682 Patch with unit tests 1386667 29 cgarcia 2018-01-08 04:30:45 -0800 (In reply to Michael Catanzaro from comment #27) > Comment on attachment 330537 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=330537&action=review > > Thanks for fixing this exceptionally serious issue. > > We definitely need to request a CVE. I can handle that. > > How hard would it be to extend testWebContextProxySettings in > TestWebKitWebContext.cpp to test this? > > > Source/WebCore/platform/network/soup/SocketStreamHandleImplSoup.cpp:58 > > +#if SOUP_CHECK_VERSION(2, 61, 2) > > I see a few different options here: > > (a) We could stick with what you implemented. But I suggest we do not allow > web socket connections to ignore proxy settings under any circumstances, > certainly not just because libsoup is too old. > (b) We could ignore our usual dependency policy and require newer libsoup. > This would be justified by the severity of this issue. We'd have to send a > notice and apology to distributors-list and inform them of the need to > update libsoup. Debian would probably refuse. Not great. > (c) We could disable WebSocket support if libsoup is not new enough. This > will break loads of websites. > (d) We could disable WebSocket support if libsoup is not new enough *and* a > system proxy is configured. Websites only break if a proxy is configured. > > (d) seems like the best approach to me. What do you think? If we go with (a) > or (b) or (c), then we'll certainly need to be backport your new API to > libsoup 2.60. But I'm OK with temporarily breaking web sockets for proxy > users, so we wouldn't need to do that if we take approach (d). I don't think we should backport any new API to libsoup stable branches. I'm not sure it's possible to do d) either, there might be proxy settings that are acceptable, for example if the websockets host used is blacklisted, or if only https proxy is used. We would need to check the actual proxy settings to decide whether to allow the websocket connection or not. 1386747 30 mcatanzaro 2018-01-08 09:00:58 -0800 (In reply to Carlos Garcia Campos from comment #29) > I don't think we should backport any new API to libsoup stable branches. I'm > not sure it's possible to do d) either, there might be proxy settings that > are acceptable, We should fail safe: assume that if the user has set a proxy, no WebSockets connection should ever be attempted. > for example if the websockets host used is blacklisted, OK, in that case it really would be safe, but that seems like a very unlikely configuration. Since this is only a fallback codepath, I would not worry about this unlikely case at all. > or > if only https proxy is used. Another odd case... in that case, wss sockets should still use the https proxy settings, but I guess it's not very much of a privacy issue if no http proxy is set. I suppose it would make sense to block use of ws WebSockets only when an http proxy is set, and to block wss WebSockets only when an https proxy is set. > We would need to check the actual proxy > settings to decide whether to allow the websocket connection or not. We certainly need to check the proxy settings, but I don't think it's important to do as thorough checks as you propose. The question is: how hard is it to check the proxy settings from WebCore/platform? We really should. 1386758 31 330682 mcatanzaro 2018-01-08 09:19:41 -0800 Comment on attachment 330682 Patch with unit tests View in context: https://bugs.webkit.org/attachment.cgi?id=330682&action=review r=me because I can't find any problems with the code, and I like the new test. But I'm still concerned about not blocking WebSocket connections when a proxy is in use in the fallback codepath. > Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp:700 > + void webSockedConnected(WebSocketServerType serverType) webSocketConnected > Tools/TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.cpp:56 > +#if SOUP_CHECK_VERSION(2, 50, 0) Why do we switch to (2, 50, 0) here? What requires libsoup 2.50.0? > Tools/TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.cpp:117 > + soup_uri_free(uri); Why are you not able to use GUniquePtr<SoupURI>? > Tools/TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.h:55 > + SoupURI* m_baseURI { nullptr }; > +#if SOUP_CHECK_VERSION(2, 50, 0) > + SoupURI* m_baseWebSocketURI { nullptr }; > +#endif I'd convert these to use GUniquePtr. 1387138 32 cgarcia 2018-01-09 00:26:51 -0800 (In reply to Michael Catanzaro from comment #31) > Comment on attachment 330682 [details] > Patch with unit tests > > View in context: > https://bugs.webkit.org/attachment.cgi?id=330682&action=review > > r=me because I can't find any problems with the code, and I like the new > test. But I'm still concerned about not blocking WebSocket connections when > a proxy is in use in the fallback codepath. > > > Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp:700 > > + void webSockedConnected(WebSocketServerType serverType) > > webSocketConnected Oops. > > Tools/TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.cpp:56 > > +#if SOUP_CHECK_VERSION(2, 50, 0) > > Why do we switch to (2, 50, 0) here? What requires libsoup 2.50.0? Because this is generic code, not specific to the web sockets over proxy tests, even if it's only used by that test ATM. WebSockets API used in WebKitTestServer was added in libsoup 2.50 > > Tools/TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.cpp:117 > > + soup_uri_free(uri); > > Why are you not able to use GUniquePtr<SoupURI>? Because the unit tests don't use WebCore, only the public API and WTF. Soup smart pointers are defined in WebCore, because WTF doesn't depend on soup. > > Tools/TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.h:55 > > + SoupURI* m_baseURI { nullptr }; > > +#if SOUP_CHECK_VERSION(2, 50, 0) > > + SoupURI* m_baseWebSocketURI { nullptr }; > > +#endif > > I'd convert these to use GUniquePtr. It's not possible. 1387277 33 cgarcia 2018-01-09 08:50:02 -0800 libsoup 2.61.2 has been released so I'll have to update the ifdefs. 1396240 34 cgarcia 2018-02-05 01:02:35 -0800 Committed r228088: <https://trac.webkit.org/changeset/228088> 220225 2014-01-02 08:19:01 -0800 2014-01-02 23:50:43 -0800 Use new libsoup function to get a proxied GIOStream 721343-3-soup-session-proxy-connect.patch text/plain 7434 dirkjan Y29tbWl0IGQwM2Q5NWYzMzE3MTAwNjQxM2VmNzBlMTA5M2FiY2ZlYjM0ZjBmM2EKQXV0aG9yOiBE aXJramFuIE9jaHRtYW4gPGQub2NodG1hbkBhY3RpdmV2aWRlby5jb20+CkRhdGU6ICAgVHVlIERl YyAyNCAxNTozMToyOSAyMDEzICswMTAwCgogICAgQWRkIHNvdXBfc2Vzc2lvbl9wcm94eV9jb25u ZWN0KCkgZnVuY3Rpb24KCmRpZmYgLS1naXQgYS9saWJzb3VwL2xpYnNvdXAtMi40LnN5bSBiL2xp YnNvdXAvbGlic291cC0yLjQuc3ltCmluZGV4IGJlNGNkN2YuLjJiOWJkY2IgMTAwNjQ0Ci0tLSBh L2xpYnNvdXAvbGlic291cC0yLjQuc3ltCisrKyBiL2xpYnNvdXAvbGlic291cC0yLjQuc3ltCkBA IC0zNzksNiArMzc5LDcgQEAgc291cF9zZXNzaW9uX25ld193aXRoX29wdGlvbnMKIHNvdXBfc2Vz c2lvbl9wYXVzZV9tZXNzYWdlCiBzb3VwX3Nlc3Npb25fcHJlZmV0Y2hfZG5zCiBzb3VwX3Nlc3Np b25fcHJlcGFyZV9mb3JfdXJpCitzb3VwX3Nlc3Npb25fcHJveHlfY29ubmVjdAogc291cF9zZXNz aW9uX3F1ZXVlX21lc3NhZ2UKIHNvdXBfc2Vzc2lvbl9yZWRpcmVjdF9tZXNzYWdlCiBzb3VwX3Nl c3Npb25fcmVtb3ZlX2ZlYXR1cmUKZGlmZiAtLWdpdCBhL2xpYnNvdXAvc291cC1tZXNzYWdlLXF1 ZXVlLmggYi9saWJzb3VwL3NvdXAtbWVzc2FnZS1xdWV1ZS5oCmluZGV4IGY4NmExMjkuLjAzOWM2 NWQgMTAwNjQ0Ci0tLSBhL2xpYnNvdXAvc291cC1tZXNzYWdlLXF1ZXVlLmgKKysrIGIvbGlic291 cC9zb3VwLW1lc3NhZ2UtcXVldWUuaApAQCAtNTYsNiArNTYsNyBAQCBzdHJ1Y3QgX1NvdXBNZXNz YWdlUXVldWVJdGVtIHsKIAlndWludCByZW1vdmVkICAgICAgICAgICAgICA6IDE7CiAJZ3VpbnQg cHJpb3JpdHkgICAgICAgICAgICAgOiAzOwogCWd1aW50IHJlZl9jb3VudCAgICAgICAgICAgIDog Mjg7CisJZ3VpbnQgZm9yY2VfdHVubmVsICAgICAgICAgOiAxOwogCVNvdXBNZXNzYWdlUXVldWVJ dGVtICpwcmV2LCAqbmV4dDsKIAlTb3VwTWVzc2FnZVF1ZXVlSXRlbSAqcmVsYXRlZDsKIH07CmRp ZmYgLS1naXQgYS9saWJzb3VwL3NvdXAtc2Vzc2lvbi5jIGIvbGlic291cC9zb3VwLXNlc3Npb24u YwppbmRleCBiMzA4MWYxLi4yNWRlYmU5IDEwMDY0NAotLS0gYS9saWJzb3VwL3NvdXAtc2Vzc2lv bi5jCisrKyBiL2xpYnNvdXAvc291cC1zZXNzaW9uLmMKQEAgLTksNiArOSw3IEBACiAjaW5jbHVk ZSA8Y29uZmlnLmg+CiAjZW5kaWYKIAorI2luY2x1ZGUgPHN0ZGxpYi5oPgogI2luY2x1ZGUgPGds aWIvZ2kxOG4tbGliLmg+CiAKICNpbmNsdWRlICJzb3VwLXNlc3Npb24uaCIKQEAgLTE1NjUsMTMg KzE1NjYsMTcgQEAgdHVubmVsX2NvbXBsZXRlIChTb3VwTWVzc2FnZVF1ZXVlSXRlbSAqdHVubmVs X2l0ZW0sCiB7CiAJU291cE1lc3NhZ2VRdWV1ZUl0ZW0gKml0ZW0gPSB0dW5uZWxfaXRlbS0+cmVs YXRlZDsKIAlTb3VwU2Vzc2lvbiAqc2Vzc2lvbiA9IHR1bm5lbF9pdGVtLT5zZXNzaW9uOworCWdi b29sZWFuIGlzX3NzbDsKIAogCXNvdXBfbWVzc2FnZV9maW5pc2hlZCAodHVubmVsX2l0ZW0tPm1z Zyk7CiAJc291cF9tZXNzYWdlX3F1ZXVlX2l0ZW1fdW5yZWYgKHR1bm5lbF9pdGVtKTsKIAogCWlm IChpdGVtLT5tc2ctPnN0YXR1c19jb2RlKQogCQlpdGVtLT5zdGF0ZSA9IFNPVVBfTUVTU0FHRV9G SU5JU0hJTkc7Ci0Jc291cF9tZXNzYWdlX3NldF9odHRwc19zdGF0dXMgKGl0ZW0tPm1zZywgaXRl bS0+Y29ubik7CisKKwlnX29iamVjdF9nZXQgKEdfT0JKRUNUIChpdGVtLT5jb25uKSwgInNzbCIs ICZpc19zc2wsIE5VTEwpOworCWlmIChpc19zc2wpCisJCXNvdXBfbWVzc2FnZV9zZXRfaHR0cHNf c3RhdHVzIChpdGVtLT5tc2csIGl0ZW0tPmNvbm4pOwogCiAJaXRlbS0+ZXJyb3IgPSBlcnJvcjsK IAlpZiAoIXN0YXR1cykKQEAgLTE2MDgsNiArMTYxMyw3IEBAIHR1bm5lbF9tZXNzYWdlX2NvbXBs ZXRlZCAoU291cE1lc3NhZ2UgKm1zZywgZ3BvaW50ZXIgdXNlcl9kYXRhKQogCVNvdXBNZXNzYWdl UXVldWVJdGVtICp0dW5uZWxfaXRlbSA9IHVzZXJfZGF0YTsKIAlTb3VwTWVzc2FnZVF1ZXVlSXRl bSAqaXRlbSA9IHR1bm5lbF9pdGVtLT5yZWxhdGVkOwogCVNvdXBTZXNzaW9uICpzZXNzaW9uID0g dHVubmVsX2l0ZW0tPnNlc3Npb247CisJZ2Jvb2xlYW4gaXNfc3NsOwogCWd1aW50IHN0YXR1czsK IAogCWlmICh0dW5uZWxfaXRlbS0+c3RhdGUgPT0gU09VUF9NRVNTQUdFX1JFU1RBUlRJTkcpIHsK QEAgLTE2MzEsNiArMTYzNywxMiBAQCB0dW5uZWxfbWVzc2FnZV9jb21wbGV0ZWQgKFNvdXBNZXNz YWdlICptc2csIGdwb2ludGVyIHVzZXJfZGF0YSkKIAkJcmV0dXJuOwogCX0KIAorCWdfb2JqZWN0 X2dldCAoR19PQkpFQ1QgKGl0ZW0tPmNvbm4pLCAic3NsIiwgJmlzX3NzbCwgTlVMTCk7CisJaWYg KCFpc19zc2wpIHsKKwkJdHVubmVsX2NvbXBsZXRlICh0dW5uZWxfaXRlbSwgc3RhdHVzLCBOVUxM KTsKKwkJcmV0dXJuOworCX0KKwogCWlmICh0dW5uZWxfaXRlbS0+YXN5bmMpIHsKIAkJc291cF9j b25uZWN0aW9uX3N0YXJ0X3NzbF9hc3luYyAoaXRlbS0+Y29ubiwgaXRlbS0+Y2FuY2VsbGFibGUs CiAJCQkJCQkgdHVubmVsX2hhbmRzaGFrZV9jb21wbGV0ZSwKQEAgLTE5MDEsMTMgKzE5MTMsMjEg QEAgc291cF9zZXNzaW9uX3Byb2Nlc3NfcXVldWVfaXRlbSAoU291cFNlc3Npb24gICAgICAgICAg KnNlc3Npb24sCiAJCQlicmVhazsKIAogCQljYXNlIFNPVVBfTUVTU0FHRV9DT05ORUNURUQ6Ci0J CQlpZiAoc291cF9jb25uZWN0aW9uX2lzX3R1bm5lbGxlZCAoaXRlbS0+Y29ubikpCi0JCQkJdHVu bmVsX2Nvbm5lY3QgKGl0ZW0pOwotCQkJZWxzZQotCQkJCWl0ZW0tPnN0YXRlID0gU09VUF9NRVNT QUdFX1JFQURZOworCQkJaWYgKHNvdXBfY29ubmVjdGlvbl9pc192aWFfcHJveHkgKGl0ZW0tPmNv bm4pKSB7CisJCQkJaWYgKGl0ZW0tPmZvcmNlX3R1bm5lbCB8fCBzb3VwX2Nvbm5lY3Rpb25faXNf dHVubmVsbGVkIChpdGVtLT5jb25uKSkgeworCQkJCQl0dW5uZWxfY29ubmVjdCAoaXRlbSk7CisJ CQkJCWJyZWFrOworCQkJCX0KKwkJCX0KKwkJCWl0ZW0tPnN0YXRlID0gU09VUF9NRVNTQUdFX1JF QURZOwogCQkJYnJlYWs7CiAKIAkJY2FzZSBTT1VQX01FU1NBR0VfUkVBRFk6CisJCQlpZiAoaXRl bS0+Zm9yY2VfdHVubmVsKSB7CisJCQkJaXRlbS0+c3RhdGUgPSBTT1VQX01FU1NBR0VfRklOSVNI SU5HOworCQkJCWJyZWFrOworCQkJfQorCiAJCQlpZiAoaXRlbS0+bXNnLT5zdGF0dXNfY29kZSkg ewogCQkJCWlmIChpdGVtLT5tc2ctPnN0YXR1c19jb2RlID09IFNPVVBfU1RBVFVTX1RSWV9BR0FJ TikgewogCQkJCQlzb3VwX21lc3NhZ2VfY2xlYW51cF9yZXNwb25zZSAoaXRlbS0+bXNnKTsKQEAg LTE5NDcsMTQgKzE5NjcsMTYgQEAgc291cF9zZXNzaW9uX3Byb2Nlc3NfcXVldWVfaXRlbSAoU291 cFNlc3Npb24gICAgICAgICAgKnNlc3Npb24sCiAKIAkJY2FzZSBTT1VQX01FU1NBR0VfRklOSVNI SU5HOgogCQkJaXRlbS0+c3RhdGUgPSBTT1VQX01FU1NBR0VfRklOSVNIRUQ7Ci0JCQlzb3VwX21l c3NhZ2VfZmluaXNoZWQgKGl0ZW0tPm1zZyk7CisJCQlpZiAoaXRlbS0+Zm9yY2VfdHVubmVsKQor CQkJCXNvdXBfbWVzc2FnZV9maW5pc2hlZCAoaXRlbS0+bXNnKTsKIAkJCWlmIChpdGVtLT5zdGF0 ZSAhPSBTT1VQX01FU1NBR0VfRklOSVNIRUQpIHsKIAkJCQlnX3JldHVybl9pZl9mYWlsICghaXRl bS0+bmV3X2FwaSk7CiAJCQkJYnJlYWs7CiAJCQl9CiAKIAkJCXNvdXBfbWVzc2FnZV9xdWV1ZV9p dGVtX3JlZiAoaXRlbSk7Ci0JCQlzb3VwX3Nlc3Npb25fdW5xdWV1ZV9pdGVtIChzZXNzaW9uLCBp dGVtKTsKKwkJCWlmICghaXRlbS0+Zm9yY2VfdHVubmVsKQorCQkJCXNvdXBfc2Vzc2lvbl91bnF1 ZXVlX2l0ZW0gKHNlc3Npb24sIGl0ZW0pOwogCQkJaWYgKGl0ZW0tPmFzeW5jICYmIGl0ZW0tPmNh bGxiYWNrKQogCQkJCWl0ZW0tPmNhbGxiYWNrIChzZXNzaW9uLCBpdGVtLT5tc2csIGl0ZW0tPmNh bGxiYWNrX2RhdGEpOwogCQkJc291cF9tZXNzYWdlX3F1ZXVlX2l0ZW1fdW5yZWYgKGl0ZW0pOwpA QCAtNDU1NiwzICs0NTc4LDkyIEBAIHNvdXBfcmVxdWVzdF9lcnJvcl9xdWFyayAodm9pZCkKIAkJ ZXJyb3IgPSBnX3F1YXJrX2Zyb21fc3RhdGljX3N0cmluZyAoInNvdXBfcmVxdWVzdF9lcnJvcl9x dWFyayIpOwogCXJldHVybiBlcnJvcjsKIH0KKwordHlwZWRlZiBzdHJ1Y3QgeworCVNvdXBQcm94 aWVkQ2FsbGJhY2sgY2FsbGJhY2s7CisJZ3BvaW50ZXIgb3JpZ19kYXRhOworCVNvdXBNZXNzYWdl UXVldWVJdGVtICppdGVtOworfSBJbnRlckRhdGE7CisKK3ZvaWQgY29ubmVjdGlvbl9jYWxsYmFj ayhTb3VwU2Vzc2lvbiAqc2Vzc2lvbiwgU291cE1lc3NhZ2UgKm1zZywgZ3BvaW50ZXIgdXNlcl9k YXRhKTsKKwordm9pZCBjb25uZWN0aW9uX2NhbGxiYWNrKFNvdXBTZXNzaW9uICpzZXNzaW9uLAor CQkJCQlTb3VwTWVzc2FnZSAqbXNnLAorCQkJCQlncG9pbnRlciBpbnRlcl9kYXRhKSB7CisJSW50 ZXJEYXRhICpjYl9kYXRhOworCVNvdXBTb2NrZXQgKnNvY2s7CisJU291cFVSSSAqdXJpOworCVNv dXBTZXNzaW9uSG9zdCAqaG9zdDsKKwlHSU9TdHJlYW0gKmlvc3RyZWFtOworCUdFcnJvciAqZXJy b3I7CisJU291cENvbm5lY3Rpb24gKnNvdXBfY29ubjsKKwlTb3VwU2Vzc2lvblByaXZhdGUgKnBy aXY7CisJU291cE1lc3NhZ2VRdWV1ZUl0ZW0gKml0ZW07CisJU291cFByb3hpZWRDYWxsYmFjayB1 c2VyX2NiOworCWdwb2ludGVyIHVzZXJfZGF0YTsKKworCWNiX2RhdGEgPSAoSW50ZXJEYXRhKikg aW50ZXJfZGF0YTsKKwl1c2VyX2NiID0gY2JfZGF0YS0+Y2FsbGJhY2s7CisJdXNlcl9kYXRhID0g Y2JfZGF0YS0+b3JpZ19kYXRhOworCWl0ZW0gPSBjYl9kYXRhLT5pdGVtOworCWZyZWUoY2JfZGF0 YSk7CisKKwlzb3VwX2Nvbm4gPSBpdGVtLT5jb25uOworCWl0ZW0tPmNvbm4gPSBOVUxMOworCWVy cm9yID0gKCFzb3VwX2Nvbm4gJiYgaXRlbS0+ZXJyb3IpID8gZ19lcnJvcl9jb3B5KGl0ZW0tPmVy cm9yKSA6IE5VTEw7CisJc291cF9zZXNzaW9uX3NldF9pdGVtX2Nvbm5lY3Rpb24gKHNlc3Npb24s IGl0ZW0sIE5VTEwpOworCXNvdXBfc2Vzc2lvbl91bnF1ZXVlX2l0ZW0gKHNlc3Npb24sIGl0ZW0p OworCisJaWYgKCFzb3VwX2Nvbm4pIHsKKwkJdXNlcl9jYihOVUxMLCBlcnJvciwgdXNlcl9kYXRh KTsKKwkJcmV0dXJuOworCX0KKworCXByaXYgPSBTT1VQX1NFU1NJT05fR0VUX1BSSVZBVEUgKHNl c3Npb24pOworCXVyaSA9IHNvdXBfbWVzc2FnZV9nZXRfdXJpIChtc2cpOworCWhvc3QgPSBnZXRf aG9zdF9mb3JfdXJpIChzZXNzaW9uLCB1cmkpOworCisJZ19tdXRleF9sb2NrICgmcHJpdi0+Y29u bl9sb2NrKTsKKwlnX2hhc2hfdGFibGVfcmVtb3ZlIChwcml2LT5jb25ucywgc291cF9jb25uKTsK Kwlkcm9wX2Nvbm5lY3Rpb24gKHNlc3Npb24sIGhvc3QsIHNvdXBfY29ubik7CisJZ19tdXRleF91 bmxvY2sgKCZwcml2LT5jb25uX2xvY2spOworCisJc29jayA9IHNvdXBfY29ubmVjdGlvbl9nZXRf c29ja2V0KHNvdXBfY29ubik7CisJZ19vYmplY3Rfc2V0IChHX09CSkVDVCAoc291cF9jb25uKSwg InN0YXktY29ubmVjdGVkIiwgVFJVRSwgTlVMTCk7CisJZ19vYmplY3RfdW5yZWYgKHNvdXBfY29u bik7CisKKwlpb3N0cmVhbSA9IHNvdXBfc29ja2V0X2dldF9jb25uZWN0aW9uKHNvY2spOworCWdf b2JqZWN0X3NldCAoR19PQkpFQ1QgKHNvY2spLCAia2VlcC1jb25uZWN0aW9uIiwgVFJVRSwgTlVM TCk7CisJZ19vYmplY3RfdW5yZWYgKHNvY2spOworCisJdXNlcl9jYihpb3N0cmVhbSwgTlVMTCwg dXNlcl9kYXRhKTsKK30KKwordm9pZCBzb3VwX3Nlc3Npb25fcHJveHlfY29ubmVjdChTb3VwU2Vz c2lvbiAqc2Vzc2lvbiwKKwkJCQkJU291cFVSSSAqZGVzdGluYXRpb24sCisJCQkJCVNvdXBQcm94 aWVkQ2FsbGJhY2sgY2FsbGJhY2ssCisJCQkJCWdwb2ludGVyIHVzZXJfZGF0YSkgeworCVNvdXBN ZXNzYWdlICptc2c7CisJSW50ZXJEYXRhICppbnRlcl9kYXRhOworCVNvdXBNZXNzYWdlUXVldWVJ dGVtICppdGVtOworCisJbXNnID0gc291cF9tZXNzYWdlX25ld19mcm9tX3VyaSAoU09VUF9NRVRI T0RfSEVBRCwgZGVzdGluYXRpb24pOworCWl0ZW0gPSBzb3VwX3Nlc3Npb25fYXBwZW5kX3F1ZXVl X2l0ZW0gKHNlc3Npb24sIG1zZywgVFJVRSwgVFJVRSwKKwkJCQkJICAgICAgIE5VTEwsIE5VTEwp OworCisJaW50ZXJfZGF0YSA9IG1hbGxvYyhzaXplb2YoSW50ZXJEYXRhKSk7CisJaW50ZXJfZGF0 YS0+Y2FsbGJhY2sgPSBjYWxsYmFjazsKKwlpbnRlcl9kYXRhLT5vcmlnX2RhdGEgPSB1c2VyX2Rh dGE7CisJaW50ZXJfZGF0YS0+aXRlbSA9IGl0ZW07CisJc291cF9tZXNzYWdlX3F1ZXVlX2l0ZW1f cmVmIChpdGVtKTsKKworCWl0ZW0tPm5ld19hcGkgPSBUUlVFOworCWl0ZW0tPmZvcmNlX3R1bm5l bCA9IFRSVUU7CisJaXRlbS0+Y2FsbGJhY2sgPSBjb25uZWN0aW9uX2NhbGxiYWNrOworCWl0ZW0t PmNhbGxiYWNrX2RhdGEgPSBpbnRlcl9kYXRhOworCisJaXRlbS0+dGFzayA9IGdfdGFza19uZXcg KHNlc3Npb24sIGl0ZW0tPmNhbmNlbGxhYmxlLCBOVUxMLCBOVUxMKTsKKwlnX3Rhc2tfc2V0X3Rh c2tfZGF0YSAoaXRlbS0+dGFzaywgaXRlbSwgKEdEZXN0cm95Tm90aWZ5KSBzb3VwX21lc3NhZ2Vf cXVldWVfaXRlbV91bnJlZik7CisJZ190YXNrX3NldF9jaGVja19jYW5jZWxsYWJsZSAoaXRlbS0+ dGFzaywgRkFMU0UpOworCXNvdXBfc2Vzc2lvbl9raWNrX3F1ZXVlIChzZXNzaW9uKTsKK30KZGlm ZiAtLWdpdCBhL2xpYnNvdXAvc291cC1zZXNzaW9uLmggYi9saWJzb3VwL3NvdXAtc2Vzc2lvbi5o CmluZGV4IDY3YTU5ZWEuLjY3OGI2ZjMgMTAwNjQ0Ci0tLSBhL2xpYnNvdXAvc291cC1zZXNzaW9u LmgKKysrIGIvbGlic291cC9zb3VwLXNlc3Npb24uaApAQCAtMTk4LDYgKzE5OCwxMyBAQCBTT1VQ X0FWQUlMQUJMRV9JTl8yXzQyCiBHUXVhcmsgc291cF9yZXF1ZXN0X2Vycm9yX3F1YXJrICh2b2lk KTsKICNkZWZpbmUgU09VUF9SRVFVRVNUX0VSUk9SIHNvdXBfcmVxdWVzdF9lcnJvcl9xdWFyayAo KQogCit0eXBlZGVmIHZvaWQgKCpTb3VwUHJveGllZENhbGxiYWNrKSAoR0lPU3RyZWFtICppb3N0 cmVhbSwgR0Vycm9yICplcnJvciwgZ3BvaW50ZXIgdXNlcl9kYXRhKTsKKwordm9pZCBzb3VwX3Nl c3Npb25fcHJveHlfY29ubmVjdCAgICAgICAgICAgICAgIChTb3VwU2Vzc2lvbiAqc2Vzc2lvbiwK KwkJCQkJCVNvdXBVUkkJCQkJCSpkZXN0aW5hdGlvbiwKKwkJCQkJCVNvdXBQcm94aWVkQ2FsbGJh Y2sJCWNhbGxiYWNrLAorCQkJCQkJZ3BvaW50ZXIJCQkJdXNlcl9kYXRhKTsKKwogdHlwZWRlZiBl bnVtIHsKIAlTT1VQX1JFUVVFU1RfRVJST1JfQkFEX1VSSSwKIAlTT1VQX1JFUVVFU1RfRVJST1Jf VU5TVVBQT1JURURfVVJJX1NDSEVNRSwK 220284 2014-01-02 23:50:43 -0800 2014-01-03 07:46:18 -0800 Use new libsoup function to get a proxied GIOStream 126384-websockets-soup-proxied-wip.patch text/plain 6385 dirkjan ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1NvY2tldFN0cmVhbUhh bmRsZS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvU29ja2V0U3RyZWFtSGFuZGxl LmgKaW5kZXggYzI0NDljNy4uMzEwOTliZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL3NvdXAvU29ja2V0U3RyZWFtSGFuZGxlLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL3NvdXAvU29ja2V0U3RyZWFtSGFuZGxlLmgKQEAgLTM3LDYgKzM3LDggQEAKICNpbmNs dWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CiAKKyNp bmNsdWRlIDxnaW8vZ2lvLmg+CisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgIGNsYXNzIEF1 dGhlbnRpY2F0aW9uQ2hhbGxlbmdlOwpAQCAtNDgsNyArNTAsNyBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAgICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPFNvY2tldFN0cmVhbUhhbmRsZT4gY3JlYXRl KGNvbnN0IEtVUkwmIHVybCwgU29ja2V0U3RyZWFtSGFuZGxlQ2xpZW50KiBjbGllbnQpIHsgcmV0 dXJuIGFkb3B0UmVmKG5ldyBTb2NrZXRTdHJlYW1IYW5kbGUodXJsLCBjbGllbnQpKTsgfQogCiAg ICAgICAgIHZpcnR1YWwgflNvY2tldFN0cmVhbUhhbmRsZSgpOwotICAgICAgICB2b2lkIGNvbm5l Y3RlZChHU29ja2V0Q29ubmVjdGlvbiosIEdFcnJvciopOworICAgICAgICB2b2lkIGNvbm5lY3Rl ZChHSU9TdHJlYW0qLCBHRXJyb3IqKTsKICAgICAgICAgdm9pZCByZWFkQnl0ZXMoc2lnbmVkIGxv bmcsIEdFcnJvciopOwogICAgICAgICB2b2lkIHdyaXRlUmVhZHkoKTsKICAgICAgICAgdm9pZCog aWQoKSB7IHJldHVybiBtX2lkOyB9CkBAIC01OCw3ICs2MCw3IEBAIG5hbWVzcGFjZSBXZWJDb3Jl IHsKICAgICAgICAgdmlydHVhbCB2b2lkIHBsYXRmb3JtQ2xvc2UoKTsKIAogICAgIHByaXZhdGU6 Ci0gICAgICAgIEdSZWZQdHI8R1NvY2tldENvbm5lY3Rpb24+IG1fc29ja2V0Q29ubmVjdGlvbjsK KyAgICAgICAgR1JlZlB0cjxHSU9TdHJlYW0+IG1faW9zdHJlYW07CiAgICAgICAgIEdSZWZQdHI8 R0lucHV0U3RyZWFtPiBtX2lucHV0U3RyZWFtOwogICAgICAgICBHUmVmUHRyPEdQb2xsYWJsZU91 dHB1dFN0cmVhbT4gbV9vdXRwdXRTdHJlYW07CiAgICAgICAgIEdSZWZQdHI8R1NvdXJjZT4gbV93 cml0ZVJlYWR5U291cmNlOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3Nv dXAvU29ja2V0U3RyZWFtSGFuZGxlU291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv c291cC9Tb2NrZXRTdHJlYW1IYW5kbGVTb3VwLmNwcAppbmRleCA2ZTIxYzY0Li42ZTg1OWE2IDEw MDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Tb2NrZXRTdHJlYW1IYW5k bGVTb3VwLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Tb2NrZXRTdHJl YW1IYW5kbGVTb3VwLmNwcApAQCAtMzAsNiArMzAsNyBAQAogCiAjaW5jbHVkZSAiY29uZmlnLmgi CiAjaW5jbHVkZSAiU29ja2V0U3RyZWFtSGFuZGxlLmgiCisjaW5jbHVkZSAiUmVzb3VyY2VIYW5k bGUuaCIKIAogI2luY2x1ZGUgIktVUkwuaCIKICNpbmNsdWRlICJMb2dnaW5nLmgiCkBAIC0zNyw4 ICszOCw5IEBACiAjaW5jbHVkZSAiU29ja2V0U3RyZWFtRXJyb3IuaCIKICNpbmNsdWRlICJTb2Nr ZXRTdHJlYW1IYW5kbGVDbGllbnQuaCIKIAotI2luY2x1ZGUgPGdpby9naW8uaD4KICNpbmNsdWRl IDxnbGliLmg+CisjaW5jbHVkZSA8Z2lvL2dpby5oPgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC5o PgogCiAjaW5jbHVkZSA8d3RmL05vdEZvdW5kLmg+CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgpA QCAtNTAsNyArNTIsNyBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiAvLyBUaGVzZSBmdW5jdGlv bnMgaW1tZWRpYXRlbHkgY2FsbCB0aGUgc2ltaWxhcmx5IG5hbWVkIFNvY2tldFN0cmVhbUhhbmRs ZSBtZXRob2RzLgotc3RhdGljIHZvaWQgY29ubmVjdGVkQ2FsbGJhY2soR1NvY2tldENsaWVudCos IEdBc3luY1Jlc3VsdCosIHZvaWQqKTsKK3N0YXRpYyB2b2lkIGNvbm5lY3RlZENhbGxiYWNrKEdJ T1N0cmVhbSosIEdFcnJvciosIHZvaWQqKTsKIHN0YXRpYyB2b2lkIHJlYWRSZWFkeUNhbGxiYWNr KEdJbnB1dFN0cmVhbSosIEdBc3luY1Jlc3VsdCosIHZvaWQqKTsKIHN0YXRpYyBnYm9vbGVhbiB3 cml0ZVJlYWR5Q2FsbGJhY2soR1BvbGxhYmxlT3V0cHV0U3RyZWFtKiwgdm9pZCopOwogCkBAIC04 NCwxNiArODYsMTIgQEAgU29ja2V0U3RyZWFtSGFuZGxlOjpTb2NrZXRTdHJlYW1IYW5kbGUoY29u c3QgS1VSTCYgdXJsLCBTb2NrZXRTdHJlYW1IYW5kbGVDbGllbnQKICAgICA6IFNvY2tldFN0cmVh bUhhbmRsZUJhc2UodXJsLCBjbGllbnQpCiAgICAgLCBtX3JlYWRCdWZmZXIoMCkKIHsKLSAgICB1 bnNpZ25lZCBpbnQgcG9ydCA9IHVybC5oYXNQb3J0KCkgPyB1cmwucG9ydCgpIDogKHVybC5wcm90 b2NvbElzKCJ3c3MiKSA/IDQ0MyA6IDgwKTsKLQorICAgIEtVUkwgbnVybCA9IHVybC5jb3B5KCk7 CisgICAgbnVybC5zZXRQcm90b2NvbChudXJsLnByb3RvY29sSXMoIndzcyIpID8gImh0dHBzIiA6 ICJodHRwIik7CiAgICAgbV9pZCA9IGFjdGl2YXRlSGFuZGxlKHRoaXMpOwotICAgIEdSZWZQdHI8 R1NvY2tldENsaWVudD4gc29ja2V0Q2xpZW50ID0gYWRvcHRHUmVmKGdfc29ja2V0X2NsaWVudF9u ZXcoKSk7Ci0gICAgLy9DTE9VRFRWIERpc2FibGUgcHJveHkgcmVzb2x2aW5nIGZvciB3cyBhbmQg d3NzLgotICAgIGdfc29ja2V0X2NsaWVudF9zZXRfZW5hYmxlX3Byb3h5KHNvY2tldENsaWVudC5n ZXQoKSwgRkFMU0UpOwotICAgIGlmICh1cmwucHJvdG9jb2xJcygid3NzIikpCi0gICAgICAgIGdf c29ja2V0X2NsaWVudF9zZXRfdGxzKHNvY2tldENsaWVudC5nZXQoKSwgVFJVRSk7Ci0gICAgZ19z b2NrZXRfY2xpZW50X2Nvbm5lY3RfdG9faG9zdF9hc3luYyhzb2NrZXRDbGllbnQuZ2V0KCksIHVy bC5ob3N0KCkudXRmOCgpLmRhdGEoKSwgcG9ydCwgMCwKLSAgICAgICAgcmVpbnRlcnByZXRfY2Fz dDxHQXN5bmNSZWFkeUNhbGxiYWNrPihjb25uZWN0ZWRDYWxsYmFjayksIG1faWQpOworICAgIFNv dXBTZXNzaW9uICpzZXNzaW9uID0gUmVzb3VyY2VIYW5kbGU6OmRlZmF1bHRTZXNzaW9uKCk7Cisg ICAgU291cFVSSSAqdXJpID0gc291cF91cmlfbmV3KG51cmwuc3RyaW5nKCkudXRmOCgpLmRhdGEo KSk7CisgICAgc291cF9zZXNzaW9uX3Byb3h5X2Nvbm5lY3Qoc2Vzc2lvbiwgdXJpLCBjb25uZWN0 ZWRDYWxsYmFjaywgbV9pZCk7CiB9CiAKIFNvY2tldFN0cmVhbUhhbmRsZTo6flNvY2tldFN0cmVh bUhhbmRsZSgpCkBAIC0xMDMsMTYgKzEwMSwxNiBAQCBTb2NrZXRTdHJlYW1IYW5kbGU6On5Tb2Nr ZXRTdHJlYW1IYW5kbGUoKQogICAgIHNldENsaWVudCgwKTsKIH0KIAotdm9pZCBTb2NrZXRTdHJl YW1IYW5kbGU6OmNvbm5lY3RlZChHU29ja2V0Q29ubmVjdGlvbiogc29ja2V0Q29ubmVjdGlvbiwg R0Vycm9yKiBlcnJvcikKK3ZvaWQgU29ja2V0U3RyZWFtSGFuZGxlOjpjb25uZWN0ZWQoR0lPU3Ry ZWFtKiBpb3N0cmVhbSwgR0Vycm9yKiBlcnJvcikKIHsKICAgICBpZiAoZXJyb3IpIHsKICAgICAg ICAgbV9jbGllbnQtPmRpZEZhaWxTb2NrZXRTdHJlYW0odGhpcywgU29ja2V0U3RyZWFtRXJyb3Io ZXJyb3ItPmNvZGUsIGVycm9yLT5tZXNzYWdlKSk7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAK LSAgICBtX3NvY2tldENvbm5lY3Rpb24gPSBhZG9wdEdSZWYoc29ja2V0Q29ubmVjdGlvbik7Ci0g ICAgbV9vdXRwdXRTdHJlYW0gPSBHX1BPTExBQkxFX09VVFBVVF9TVFJFQU0oZ19pb19zdHJlYW1f Z2V0X291dHB1dF9zdHJlYW0oR19JT19TVFJFQU0obV9zb2NrZXRDb25uZWN0aW9uLmdldCgpKSkp OwotICAgIG1faW5wdXRTdHJlYW0gPSBnX2lvX3N0cmVhbV9nZXRfaW5wdXRfc3RyZWFtKEdfSU9f U1RSRUFNKG1fc29ja2V0Q29ubmVjdGlvbi5nZXQoKSkpOworICAgIG1faW9zdHJlYW0gPSBhZG9w dEdSZWYoaW9zdHJlYW0pOworICAgIG1fb3V0cHV0U3RyZWFtID0gR19QT0xMQUJMRV9PVVRQVVRf U1RSRUFNKGdfaW9fc3RyZWFtX2dldF9vdXRwdXRfc3RyZWFtKGlvc3RyZWFtKSk7CisgICAgbV9p bnB1dFN0cmVhbSA9IGdfaW9fc3RyZWFtX2dldF9pbnB1dF9zdHJlYW0oaW9zdHJlYW0pOwogCiAg ICAgbV9yZWFkQnVmZmVyID0gbmV3IGNoYXJbUkVBRF9CVUZGRVJfU0laRV07CiAgICAgZ19pbnB1 dF9zdHJlYW1fcmVhZF9hc3luYyhtX2lucHV0U3RyZWFtLmdldCgpLCBtX3JlYWRCdWZmZXIsIFJF QURfQlVGRkVSX1NJWkUsIEdfUFJJT1JJVFlfREVGQVVMVCwgMCwKQEAgLTEyMiw3ICsxMjAsNyBA QCB2b2lkIFNvY2tldFN0cmVhbUhhbmRsZTo6Y29ubmVjdGVkKEdTb2NrZXRDb25uZWN0aW9uKiBz b2NrZXRDb25uZWN0aW9uLCBHRXJyb3IqCiAgICAgUmVmUHRyPFNvY2tldFN0cmVhbUhhbmRsZT4g cHJvdGVjdCh0aGlzKTsgCiAgICAgbV9zdGF0ZSA9IE9wZW47CiAgICAgbV9jbGllbnQtPmRpZE9w ZW5Tb2NrZXRTdHJlYW0odGhpcyk7Ci0gICAgaWYgKCFtX3NvY2tldENvbm5lY3Rpb24pIC8vIENs aWVudCBjbG9zZWQgdGhlIGNvbm5lY3Rpb24uCisgICAgaWYgKCFtX2lvc3RyZWFtKSAvLyBDbGll bnQgY2xvc2VkIHRoZSBjb25uZWN0aW9uLgogICAgICAgICByZXR1cm47CiB9CiAKQEAgLTE4Mywx MiArMTgxLDEyIEBAIHZvaWQgU29ja2V0U3RyZWFtSGFuZGxlOjpwbGF0Zm9ybUNsb3NlKCkKICAg ICBkZWFjdGl2YXRlSGFuZGxlKHRoaXMpOwogICAgIHN0b3BXYWl0aW5nRm9yU29ja2V0V3JpdGFi aWxpdHkoKTsKIAotICAgIGlmIChtX3NvY2tldENvbm5lY3Rpb24pIHsKKyAgICBpZiAobV9pb3N0 cmVhbSkgewogICAgICAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7Ci0gICAgICAgIGdfaW9fc3Ry ZWFtX2Nsb3NlKEdfSU9fU1RSRUFNKG1fc29ja2V0Q29ubmVjdGlvbi5nZXQoKSksIDAsICZlcnJv ci5vdXRQdHIoKSk7CisgICAgICAgIGdfaW9fc3RyZWFtX2Nsb3NlKG1faW9zdHJlYW0uZ2V0KCks IDAsICZlcnJvci5vdXRQdHIoKSk7CiAgICAgICAgIGlmIChlcnJvcikKICAgICAgICAgICAgIG1f Y2xpZW50LT5kaWRGYWlsU29ja2V0U3RyZWFtKHRoaXMsIFNvY2tldFN0cmVhbUVycm9yKGVycm9y LT5jb2RlLCBlcnJvci0+bWVzc2FnZSkpOwotICAgICAgICBtX3NvY2tldENvbm5lY3Rpb24gPSAw OworICAgICAgICBtX2lvc3RyZWFtID0gMDsKICAgICB9CiAKICAgICBtX291dHB1dFN0cmVhbSA9 IDA7CkBAIC0yMzcsMjEgKzIzNSwxNiBAQCB2b2lkIFNvY2tldFN0cmVhbUhhbmRsZTo6c3RvcFdh aXRpbmdGb3JTb2NrZXRXcml0YWJpbGl0eSgpCiAgICAgbV93cml0ZVJlYWR5U291cmNlID0gMDsK IH0KIAotc3RhdGljIHZvaWQgY29ubmVjdGVkQ2FsbGJhY2soR1NvY2tldENsaWVudCogY2xpZW50 LCBHQXN5bmNSZXN1bHQqIHJlc3VsdCwgdm9pZCogaWQpCitzdGF0aWMgdm9pZCBjb25uZWN0ZWRD YWxsYmFjayhHSU9TdHJlYW0gKmlvc3RyZWFtLCBHRXJyb3IgKmVycm9yLCB2b2lkKiBpZCkKIHsK LSAgICAvLyBBbHdheXMgZmluaXNoIHRoZSBjb25uZWN0aW9uLCBldmVuIGlmIHRoaXMgU29ja2V0 U3RyZWFtSGFuZGxlIHdhcyBkZWFjdGl2YXRlZCBlYXJsaWVyLgotICAgIEdPd25QdHI8R0Vycm9y PiBlcnJvcjsKLSAgICBHU29ja2V0Q29ubmVjdGlvbiogc29ja2V0Q29ubmVjdGlvbiA9IGdfc29j a2V0X2NsaWVudF9jb25uZWN0X3RvX2hvc3RfZmluaXNoKGNsaWVudCwgcmVzdWx0LCAmZXJyb3Iu b3V0UHRyKCkpOwotCiAgICAgLy8gVGhlIFNvY2tldFN0cmVhbUhhbmRsZSBoYXMgYmVlbiBkZWFj dGl2YXRlZCwgc28ganVzdCBjbG9zZSB0aGUgY29ubmVjdGlvbiwgaWdub3JpbmcgZXJyb3JzLgog ICAgIFNvY2tldFN0cmVhbUhhbmRsZSogaGFuZGxlID0gZ2V0SGFuZGxlRnJvbUlkKGlkKTsKICAg ICBpZiAoIWhhbmRsZSkgewotICAgICAgICBpZiAoc29ja2V0Q29ubmVjdGlvbikKLSAgICAgICAg ICAgIGdfaW9fc3RyZWFtX2Nsb3NlKEdfSU9fU1RSRUFNKHNvY2tldENvbm5lY3Rpb24pLCAwLCAw KTsKKyAgICAgICAgaWYgKGlvc3RyZWFtKQorICAgICAgICAgICAgZ19pb19zdHJlYW1fY2xvc2Uo aW9zdHJlYW0sIDAsIDApOwogICAgICAgICByZXR1cm47CiAgICAgfQotCi0gICAgaGFuZGxlLT5j b25uZWN0ZWQoc29ja2V0Q29ubmVjdGlvbiwgZXJyb3IuZ2V0KCkpOworICAgIGhhbmRsZS0+Y29u bmVjdGVkKGlvc3RyZWFtLCBlcnJvcik7CiB9CiAKIHN0YXRpYyB2b2lkIHJlYWRSZWFkeUNhbGxi YWNrKEdJbnB1dFN0cmVhbSogc3RyZWFtLCBHQXN5bmNSZXN1bHQqIHJlc3VsdCwgdm9pZCogaWQp Cg== 220303 2014-01-03 07:46:00 -0800 2014-01-03 07:46:00 -0800 Version of the patch that applies to recent WebKit SVN 126384-websockets-soup-proxied-wip.patch text/plain 6309 dirkjan ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1NvY2tldFN0cmVhbUhh bmRsZS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvU29ja2V0U3RyZWFtSGFuZGxl LmgKaW5kZXggN2I0Y2Y0Yi4uNzhkNjk1YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL3NvdXAvU29ja2V0U3RyZWFtSGFuZGxlLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL3NvdXAvU29ja2V0U3RyZWFtSGFuZGxlLmgKQEAgLTMzLDYgKzMzLDggQEAKICNpZm5k ZWYgU29ja2V0U3RyZWFtSGFuZGxlX2gKICNkZWZpbmUgU29ja2V0U3RyZWFtSGFuZGxlX2gKIAor I2luY2x1ZGUgPGdpby9naW8uaD4KKwogI2luY2x1ZGUgIlNvY2tldFN0cmVhbUhhbmRsZUJhc2Uu aCIKICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZjb3VudGVk Lmg+CkBAIC01MCw3ICs1Miw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgc3RhdGlj IFBhc3NSZWZQdHI8U29ja2V0U3RyZWFtSGFuZGxlPiBjcmVhdGUoR1NvY2tldENvbm5lY3Rpb24q IHNvY2tldENvbm5lY3Rpb24sIFNvY2tldFN0cmVhbUhhbmRsZUNsaWVudCogY2xpZW50KSB7IHJl dHVybiBhZG9wdFJlZihuZXcgU29ja2V0U3RyZWFtSGFuZGxlKHNvY2tldENvbm5lY3Rpb24sIGNs aWVudCkpOyB9CiAKICAgICAgICAgdmlydHVhbCB+U29ja2V0U3RyZWFtSGFuZGxlKCk7Ci0gICAg ICAgIHZvaWQgY29ubmVjdGVkKEdTb2NrZXRDb25uZWN0aW9uKiwgR0Vycm9yKik7CisgICAgICAg IHZvaWQgY29ubmVjdGVkKEdJT1N0cmVhbSosIEdFcnJvciopOwogICAgICAgICB2b2lkIHJlYWRC eXRlcyhzaWduZWQgbG9uZywgR0Vycm9yKik7CiAgICAgICAgIHZvaWQgd3JpdGVSZWFkeSgpOwog ICAgICAgICB2b2lkKiBpZCgpIHsgcmV0dXJuIG1faWQ7IH0KQEAgLTYwLDcgKzYyLDcgQEAgbmFt ZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2aXJ0dWFsIHZvaWQgcGxhdGZvcm1DbG9zZSgpOwog CiAgICAgcHJpdmF0ZToKLSAgICAgICAgR1JlZlB0cjxHU29ja2V0Q29ubmVjdGlvbj4gbV9zb2Nr ZXRDb25uZWN0aW9uOworICAgICAgICBHUmVmUHRyPEdJT1N0cmVhbT4gbV9pb3N0cmVhbTsKICAg ICAgICAgR1JlZlB0cjxHSW5wdXRTdHJlYW0+IG1faW5wdXRTdHJlYW07CiAgICAgICAgIEdSZWZQ dHI8R1BvbGxhYmxlT3V0cHV0U3RyZWFtPiBtX291dHB1dFN0cmVhbTsKICAgICAgICAgR1JlZlB0 cjxHU291cmNlPiBtX3dyaXRlUmVhZHlTb3VyY2U7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvc291cC9Tb2NrZXRTdHJlYW1IYW5kbGVTb3VwLmNwcCBiL1dlYkNvcmUvcGxh dGZvcm0vbmV0d29yay9zb3VwL1NvY2tldFN0cmVhbUhhbmRsZVNvdXAuY3BwCmluZGV4IDlhYTQ3 NjMuLmIxNjlmODUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Nv Y2tldFN0cmVhbUhhbmRsZVNvdXAuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9z b3VwL1NvY2tldFN0cmVhbUhhbmRsZVNvdXAuY3BwCkBAIC0zMCw2ICszMCw3IEBACiAgKi8KIAog I2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVk ZSAiU29ja2V0U3RyZWFtSGFuZGxlLmgiCiAKICNpbmNsdWRlICJLVVJMLmgiCkBAIC00MCw2ICs0 MSw3IEBACiAKICNpbmNsdWRlIDxnaW8vZ2lvLmg+CiAjaW5jbHVkZSA8Z2xpYi5oPgorI2luY2x1 ZGUgPGxpYnNvdXAvc291cC5oPgogCiAjaW5jbHVkZSA8d3RmL05vdEZvdW5kLmg+CiAjaW5jbHVk ZSA8d3RmL1ZlY3Rvci5oPgpAQCAtNTEsNyArNTMsNyBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewog CiAvLyBUaGVzZSBmdW5jdGlvbnMgaW1tZWRpYXRlbHkgY2FsbCB0aGUgc2ltaWxhcmx5IG5hbWVk IFNvY2tldFN0cmVhbUhhbmRsZSBtZXRob2RzLgotc3RhdGljIHZvaWQgY29ubmVjdGVkQ2FsbGJh Y2soR1NvY2tldENsaWVudCosIEdBc3luY1Jlc3VsdCosIHZvaWQqKTsKK3N0YXRpYyB2b2lkIGNv bm5lY3RlZENhbGxiYWNrKEdJT1N0cmVhbSosIEdFcnJvciosIHZvaWQqKTsKIHN0YXRpYyB2b2lk IHJlYWRSZWFkeUNhbGxiYWNrKEdJbnB1dFN0cmVhbSosIEdBc3luY1Jlc3VsdCosIHZvaWQqKTsK IHN0YXRpYyBnYm9vbGVhbiB3cml0ZVJlYWR5Q2FsbGJhY2soR1BvbGxhYmxlT3V0cHV0U3RyZWFt Kiwgdm9pZCopOwogCkBAIC04NiwxNCArODgsMTIgQEAgU29ja2V0U3RyZWFtSGFuZGxlOjpTb2Nr ZXRTdHJlYW1IYW5kbGUoY29uc3QgS1VSTCYgdXJsLCBTb2NrZXRTdHJlYW1IYW5kbGVDbGllbnQK ICAgICAsIG1fcmVhZEJ1ZmZlcigwKQogewogICAgIExPRyhOZXR3b3JrLCAiU29ja2V0U3RyZWFt SGFuZGxlICVwIG5ldyBjbGllbnQgJXAiLCB0aGlzLCBtX2NsaWVudCk7Ci0gICAgdW5zaWduZWQg aW50IHBvcnQgPSB1cmwuaGFzUG9ydCgpID8gdXJsLnBvcnQoKSA6ICh1cmwucHJvdG9jb2xJcygi d3NzIikgPyA0NDMgOiA4MCk7Ci0KKyAgICBLVVJMIG51cmwgPSB1cmwuY29weSgpOworICAgIG51 cmwuc2V0UHJvdG9jb2wobnVybC5wcm90b2NvbElzKCJ3c3MiKSA/ICJodHRwcyIgOiAiaHR0cCIp OwogICAgIG1faWQgPSBhY3RpdmF0ZUhhbmRsZSh0aGlzKTsKLSAgICBHUmVmUHRyPEdTb2NrZXRD bGllbnQ+IHNvY2tldENsaWVudCA9IGFkb3B0R1JlZihnX3NvY2tldF9jbGllbnRfbmV3KCkpOwot ICAgIGlmICh1cmwucHJvdG9jb2xJcygid3NzIikpCi0gICAgICAgIGdfc29ja2V0X2NsaWVudF9z ZXRfdGxzKHNvY2tldENsaWVudC5nZXQoKSwgVFJVRSk7Ci0gICAgZ19zb2NrZXRfY2xpZW50X2Nv bm5lY3RfdG9faG9zdF9hc3luYyhzb2NrZXRDbGllbnQuZ2V0KCksIHVybC5ob3N0KCkudXRmOCgp LmRhdGEoKSwgcG9ydCwgMCwKLSAgICAgICAgcmVpbnRlcnByZXRfY2FzdDxHQXN5bmNSZWFkeUNh bGxiYWNrPihjb25uZWN0ZWRDYWxsYmFjayksIG1faWQpOworICAgIFNvdXBTZXNzaW9uICpzZXNz aW9uID0gUmVzb3VyY2VIYW5kbGU6OmRlZmF1bHRTZXNzaW9uKCk7CisgICAgU291cFVSSSAqdXJp ID0gc291cF91cmlfbmV3KG51cmwuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisgICAgc291cF9z ZXNzaW9uX3Byb3h5X2Nvbm5lY3Qoc2Vzc2lvbiwgdXJpLCBjb25uZWN0ZWRDYWxsYmFjaywgbV9p ZCk7CiB9CiAKIFNvY2tldFN0cmVhbUhhbmRsZTo6U29ja2V0U3RyZWFtSGFuZGxlKEdTb2NrZXRD b25uZWN0aW9uKiBzb2NrZXRDb25uZWN0aW9uLCBTb2NrZXRTdHJlYW1IYW5kbGVDbGllbnQqIGNs aWVudCkKQEAgLTEwNCw3ICsxMDIsNyBAQCBTb2NrZXRTdHJlYW1IYW5kbGU6OlNvY2tldFN0cmVh bUhhbmRsZShHU29ja2V0Q29ubmVjdGlvbiogc29ja2V0Q29ubmVjdGlvbiwgU29jawogewogICAg IExPRyhOZXR3b3JrLCAiU29ja2V0U3RyZWFtSGFuZGxlICVwIG5ldyBjbGllbnQgJXAiLCB0aGlz LCBtX2NsaWVudCk7CiAgICAgbV9pZCA9IGFjdGl2YXRlSGFuZGxlKHRoaXMpOwotICAgIGNvbm5l Y3RlZChzb2NrZXRDb25uZWN0aW9uLCAwKTsKKyAgICBjb25uZWN0ZWQoR19JT19TVFJFQU0oc29j a2V0Q29ubmVjdGlvbiksIDApOwogfQogCiBTb2NrZXRTdHJlYW1IYW5kbGU6On5Tb2NrZXRTdHJl YW1IYW5kbGUoKQpAQCAtMTE1LDE2ICsxMTMsMTYgQEAgU29ja2V0U3RyZWFtSGFuZGxlOjp+U29j a2V0U3RyZWFtSGFuZGxlKCkKICAgICBzZXRDbGllbnQoMCk7CiB9CiAKLXZvaWQgU29ja2V0U3Ry ZWFtSGFuZGxlOjpjb25uZWN0ZWQoR1NvY2tldENvbm5lY3Rpb24qIHNvY2tldENvbm5lY3Rpb24s IEdFcnJvciogZXJyb3IpCit2b2lkIFNvY2tldFN0cmVhbUhhbmRsZTo6Y29ubmVjdGVkKEdJT1N0 cmVhbSogaW9zdHJlYW0sIEdFcnJvciogZXJyb3IpCiB7CiAgICAgaWYgKGVycm9yKSB7CiAgICAg ICAgIG1fY2xpZW50LT5kaWRGYWlsU29ja2V0U3RyZWFtKHRoaXMsIFNvY2tldFN0cmVhbUVycm9y KGVycm9yLT5jb2RlLCBlcnJvci0+bWVzc2FnZSkpOwogICAgICAgICByZXR1cm47CiAgICAgfQog Ci0gICAgbV9zb2NrZXRDb25uZWN0aW9uID0gc29ja2V0Q29ubmVjdGlvbjsKLSAgICBtX291dHB1 dFN0cmVhbSA9IEdfUE9MTEFCTEVfT1VUUFVUX1NUUkVBTShnX2lvX3N0cmVhbV9nZXRfb3V0cHV0 X3N0cmVhbShHX0lPX1NUUkVBTShtX3NvY2tldENvbm5lY3Rpb24uZ2V0KCkpKSk7Ci0gICAgbV9p bnB1dFN0cmVhbSA9IGdfaW9fc3RyZWFtX2dldF9pbnB1dF9zdHJlYW0oR19JT19TVFJFQU0obV9z b2NrZXRDb25uZWN0aW9uLmdldCgpKSk7CisgICAgbV9pb3N0cmVhbSA9IGFkb3B0R1JlZihpb3N0 cmVhbSk7CisgICAgbV9vdXRwdXRTdHJlYW0gPSBHX1BPTExBQkxFX09VVFBVVF9TVFJFQU0oZ19p b19zdHJlYW1fZ2V0X291dHB1dF9zdHJlYW0oaW9zdHJlYW0pKTsKKyAgICBtX2lucHV0U3RyZWFt ID0gZ19pb19zdHJlYW1fZ2V0X2lucHV0X3N0cmVhbShpb3N0cmVhbSk7CiAKICAgICBtX3JlYWRC dWZmZXIgPSBuZXcgY2hhcltSRUFEX0JVRkZFUl9TSVpFXTsKICAgICBnX2lucHV0X3N0cmVhbV9y ZWFkX2FzeW5jKG1faW5wdXRTdHJlYW0uZ2V0KCksIG1fcmVhZEJ1ZmZlciwgUkVBRF9CVUZGRVJf U0laRSwgR19QUklPUklUWV9ERUZBVUxULCAwLApAQCAtMTk2LDEyICsxOTQsMTIgQEAgdm9pZCBT b2NrZXRTdHJlYW1IYW5kbGU6OnBsYXRmb3JtQ2xvc2UoKQogICAgIGRlYWN0aXZhdGVIYW5kbGUo dGhpcyk7CiAgICAgc3RvcFdhaXRpbmdGb3JTb2NrZXRXcml0YWJpbGl0eSgpOwogCi0gICAgaWYg KG1fc29ja2V0Q29ubmVjdGlvbikgeworICAgIGlmIChtX2lvc3RyZWFtKSB7CiAgICAgICAgIEdP d25QdHI8R0Vycm9yPiBlcnJvcjsKLSAgICAgICAgZ19pb19zdHJlYW1fY2xvc2UoR19JT19TVFJF QU0obV9zb2NrZXRDb25uZWN0aW9uLmdldCgpKSwgMCwgJmVycm9yLm91dFB0cigpKTsKKyAgICAg ICAgZ19pb19zdHJlYW1fY2xvc2UobV9pb3N0cmVhbS5nZXQoKSwgMCwgJmVycm9yLm91dFB0cigp KTsKICAgICAgICAgaWYgKGVycm9yKQogICAgICAgICAgICAgbV9jbGllbnQtPmRpZEZhaWxTb2Nr ZXRTdHJlYW0odGhpcywgU29ja2V0U3RyZWFtRXJyb3IoZXJyb3ItPmNvZGUsIGVycm9yLT5tZXNz YWdlKSk7Ci0gICAgICAgIG1fc29ja2V0Q29ubmVjdGlvbiA9IDA7CisgICAgICAgIG1faW9zdHJl YW0gPSAwOwogICAgIH0KIAogICAgIG1fb3V0cHV0U3RyZWFtID0gMDsKQEAgLTI1MSwyMSArMjQ5 LDE3IEBAIHZvaWQgU29ja2V0U3RyZWFtSGFuZGxlOjpzdG9wV2FpdGluZ0ZvclNvY2tldFdyaXRh YmlsaXR5KCkKICAgICBtX3dyaXRlUmVhZHlTb3VyY2UgPSAwOwogfQogCi1zdGF0aWMgdm9pZCBj b25uZWN0ZWRDYWxsYmFjayhHU29ja2V0Q2xpZW50KiBjbGllbnQsIEdBc3luY1Jlc3VsdCogcmVz dWx0LCB2b2lkKiBpZCkKK3N0YXRpYyB2b2lkIGNvbm5lY3RlZENhbGxiYWNrKEdJT1N0cmVhbSog aW9zdHJlYW0sIEdFcnJvciogZXJyb3IsIHZvaWQqIGlkKQogewotICAgIC8vIEFsd2F5cyBmaW5p c2ggdGhlIGNvbm5lY3Rpb24sIGV2ZW4gaWYgdGhpcyBTb2NrZXRTdHJlYW1IYW5kbGUgd2FzIGRl YWN0aXZhdGVkIGVhcmxpZXIuCi0gICAgR093blB0cjxHRXJyb3I+IGVycm9yOwotICAgIEdTb2Nr ZXRDb25uZWN0aW9uKiBzb2NrZXRDb25uZWN0aW9uID0gZ19zb2NrZXRfY2xpZW50X2Nvbm5lY3Rf dG9faG9zdF9maW5pc2goY2xpZW50LCByZXN1bHQsICZlcnJvci5vdXRQdHIoKSk7Ci0KICAgICAv LyBUaGUgU29ja2V0U3RyZWFtSGFuZGxlIGhhcyBiZWVuIGRlYWN0aXZhdGVkLCBzbyBqdXN0IGNs b3NlIHRoZSBjb25uZWN0aW9uLCBpZ25vcmluZyBlcnJvcnMuCiAgICAgU29ja2V0U3RyZWFtSGFu ZGxlKiBoYW5kbGUgPSBnZXRIYW5kbGVGcm9tSWQoaWQpOwogICAgIGlmICghaGFuZGxlKSB7Ci0g ICAgICAgIGlmIChzb2NrZXRDb25uZWN0aW9uKQotICAgICAgICAgICAgZ19pb19zdHJlYW1fY2xv c2UoR19JT19TVFJFQU0oc29ja2V0Q29ubmVjdGlvbiksIDAsIDApOworICAgICAgICBpZiAoaW9z dHJlYW0pCisgICAgICAgICAgICBnX2lvX3N0cmVhbV9jbG9zZShpb3N0cmVhbSwgMCwgMCk7CiAg ICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBoYW5kbGUtPmNvbm5lY3RlZChzb2NrZXRDb25u ZWN0aW9uLCBlcnJvci5nZXQoKSk7CisgICAgaGFuZGxlLT5jb25uZWN0ZWQoaW9zdHJlYW0sIGVy cm9yKTsKIH0KIAogc3RhdGljIHZvaWQgcmVhZFJlYWR5Q2FsbGJhY2soR0lucHV0U3RyZWFtKiBz dHJlYW0sIEdBc3luY1Jlc3VsdCogcmVzdWx0LCB2b2lkKiBpZCkK 327158 2017-11-17 02:30:46 -0800 2017-11-17 02:30:46 -0800 WebKit patches for libsoup WebSockets over proxy webkit-ws-proxy.patches text/plain 10004 dirkjan Y29tbWl0IGJjNzdjNGFiNjk4ZGY4MjQ1ZmI0YzEyNWFmN2JkZWYyYTQwNTZiZGQKQXV0aG9yOiBC YXMgTXVucyA8Ym11bnNAYWN0aXZldmlkZW8uY29tPgpEYXRlOiAgIFRodSBKdW4gMTkgMTM6MzI6 MTAgMjAxNCArMDIwMAoKICAgIEZpbGwgaW4gYW4gZXJyb3Igd2hlbiBzb2NrZXRoYW5kbGUgZG9l cyBub3QgaGF2ZSBhbiBpb3N0cmVhbSBvYmplY3QuCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0 Zm9ybS9uZXR3b3JrL3NvdXAvU29ja2V0U3RyZWFtSGFuZGxlU291cC5jcHAgYi9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvc291cC9Tb2NrZXRTdHJlYW1IYW5kbGVTb3VwLmNwcAppbmRleCA3NjI2 MGJjOC4uMjFhNzQ2MDAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3Vw L1NvY2tldFN0cmVhbUhhbmRsZVNvdXAuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9zb3VwL1NvY2tldFN0cmVhbUhhbmRsZVNvdXAuY3BwCkBAIC0xMjAsNiArMTIwLDEwIEBAIHZv aWQgU29ja2V0U3RyZWFtSGFuZGxlOjpjb25uZWN0ZWQoR0lPU3RyZWFtKiBpb3N0cmVhbSwgR0Vy cm9yKiBlcnJvcikKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAorICAgIGlmICghaW9zdHJlYW0p IHsKKyAgICAgICAgbV9jbGllbnQtPmRpZEZhaWxTb2NrZXRTdHJlYW0odGhpcywgU29ja2V0U3Ry ZWFtRXJyb3IoU09VUF9TVEFUVVNfSU9fRVJST1IsICJObyBpbyBzdHJlYW0gYXZhaWxhYmxlIikp OworICAgICAgICByZXR1cm47CisgICAgfQogICAgIG1faW9zdHJlYW0gPSBhZG9wdEdSZWYoaW9z dHJlYW0pOwogICAgIG1fb3V0cHV0U3RyZWFtID0gR19QT0xMQUJMRV9PVVRQVVRfU1RSRUFNKGdf aW9fc3RyZWFtX2dldF9vdXRwdXRfc3RyZWFtKGlvc3RyZWFtKSk7CiAgICAgbV9pbnB1dFN0cmVh bSA9IGdfaW9fc3RyZWFtX2dldF9pbnB1dF9zdHJlYW0oaW9zdHJlYW0pOwoKY29tbWl0IDRiZmMy MTA0ZWUyZGFjZmNkNWI4MjJlZGQ1OGNiYTVlNTc2NjMzZDYKQXV0aG9yOiBEaXJramFuIE9jaHRt YW4gPGQub2NodG1hbkBhY3RpdmV2aWRlby5jb20+CkRhdGU6ICAgVHVlIEp1biAxMCAxNDozNjo1 NCAyMDE0ICswMjAwCgogICAgQWRhcHQgdG8gbmV3IGl0ZXJhdGlvbiBvZiBsaWJzb3VwIHBhdGNo ZXMKCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Tb2NrZXRTdHJl YW1IYW5kbGVTb3VwLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1NvY2tldFN0 cmVhbUhhbmRsZVNvdXAuY3BwCmluZGV4IGIxNjlmODVhLi43NjI2MGJjOCAxMDA2NDQKLS0tIGEv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvU29ja2V0U3RyZWFtSGFuZGxlU291cC5jcHAK KysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvU29ja2V0U3RyZWFtSGFuZGxlU291 cC5jcHAKQEAgLTUzLDcgKzUzLDcgQEAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogLy8gVGhlc2Ug ZnVuY3Rpb25zIGltbWVkaWF0ZWx5IGNhbGwgdGhlIHNpbWlsYXJseSBuYW1lZCBTb2NrZXRTdHJl YW1IYW5kbGUgbWV0aG9kcy4KLXN0YXRpYyB2b2lkIGNvbm5lY3RlZENhbGxiYWNrKEdJT1N0cmVh bSosIEdFcnJvciosIHZvaWQqKTsKK3N0YXRpYyB2b2lkIGNvbm5lY3RlZENhbGxiYWNrKEdPYmpl Y3QqLCBHQXN5bmNSZXN1bHQqLCB2b2lkKik7CiBzdGF0aWMgdm9pZCByZWFkUmVhZHlDYWxsYmFj ayhHSW5wdXRTdHJlYW0qLCBHQXN5bmNSZXN1bHQqLCB2b2lkKik7CiBzdGF0aWMgZ2Jvb2xlYW4g d3JpdGVSZWFkeUNhbGxiYWNrKEdQb2xsYWJsZU91dHB1dFN0cmVhbSosIHZvaWQqKTsKIApAQCAt OTMsNyArOTMsNyBAQCBTb2NrZXRTdHJlYW1IYW5kbGU6OlNvY2tldFN0cmVhbUhhbmRsZShjb25z dCBLVVJMJiB1cmwsIFNvY2tldFN0cmVhbUhhbmRsZUNsaWVudAogICAgIG1faWQgPSBhY3RpdmF0 ZUhhbmRsZSh0aGlzKTsKICAgICBTb3VwU2Vzc2lvbiAqc2Vzc2lvbiA9IFJlc291cmNlSGFuZGxl OjpkZWZhdWx0U2Vzc2lvbigpOwogICAgIFNvdXBVUkkgKnVyaSA9IHNvdXBfdXJpX25ldyhudXJs LnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOwotICAgIHNvdXBfc2Vzc2lvbl9wcm94eV9jb25uZWN0 KHNlc3Npb24sIHVyaSwgY29ubmVjdGVkQ2FsbGJhY2ssIG1faWQpOworICAgIHNvdXBfc2Vzc2lv bl9jb25uZWN0X2FzeW5jKHNlc3Npb24sIHVyaSwgY29ubmVjdGVkQ2FsbGJhY2ssIG1faWQpOwog fQogCiBTb2NrZXRTdHJlYW1IYW5kbGU6OlNvY2tldFN0cmVhbUhhbmRsZShHU29ja2V0Q29ubmVj dGlvbiogc29ja2V0Q29ubmVjdGlvbiwgU29ja2V0U3RyZWFtSGFuZGxlQ2xpZW50KiBjbGllbnQp CkBAIC0yNDksMTcgKzI0OSwyMSBAQCB2b2lkIFNvY2tldFN0cmVhbUhhbmRsZTo6c3RvcFdhaXRp bmdGb3JTb2NrZXRXcml0YWJpbGl0eSgpCiAgICAgbV93cml0ZVJlYWR5U291cmNlID0gMDsKIH0K IAotc3RhdGljIHZvaWQgY29ubmVjdGVkQ2FsbGJhY2soR0lPU3RyZWFtKiBpb3N0cmVhbSwgR0Vy cm9yKiBlcnJvciwgdm9pZCogaWQpCitzdGF0aWMgdm9pZCBjb25uZWN0ZWRDYWxsYmFjayhHT2Jq ZWN0KiBvYmplY3QsIEdBc3luY1Jlc3VsdCogcmVzdWx0LCB2b2lkKiBpZCkKIHsKLSAgICAvLyBU aGUgU29ja2V0U3RyZWFtSGFuZGxlIGhhcyBiZWVuIGRlYWN0aXZhdGVkLCBzbyBqdXN0IGNsb3Nl IHRoZSBjb25uZWN0aW9uLCBpZ25vcmluZyBlcnJvcnMuCisgICAgR093blB0cjxHRXJyb3I+IGVy cm9yOworICAgIFNvdXBTZXNzaW9uKiBzZXNzaW9uID0gU09VUF9TRVNTSU9OKG9iamVjdCk7Cisg ICAgR0lPU3RyZWFtKiBpb3N0cmVhbSA9IHNvdXBfc2Vzc2lvbl9jb25uZWN0X2ZpbmlzaChzZXNz aW9uLCByZXN1bHQsICZlcnJvci5vdXRQdHIoKSk7CisKICAgICBTb2NrZXRTdHJlYW1IYW5kbGUq IGhhbmRsZSA9IGdldEhhbmRsZUZyb21JZChpZCk7CisgICAgLy8gVGhlIFNvY2tldFN0cmVhbUhh bmRsZSBoYXMgYmVlbiBkZWFjdGl2YXRlZCwgc28ganVzdCBjbG9zZSB0aGUgY29ubmVjdGlvbiwg aWdub3JpbmcgZXJyb3JzLgogICAgIGlmICghaGFuZGxlKSB7CiAgICAgICAgIGlmIChpb3N0cmVh bSkKICAgICAgICAgICAgIGdfaW9fc3RyZWFtX2Nsb3NlKGlvc3RyZWFtLCAwLCAwKTsKICAgICAg ICAgcmV0dXJuOwogICAgIH0KIAotICAgIGhhbmRsZS0+Y29ubmVjdGVkKGlvc3RyZWFtLCBlcnJv cik7CisgICAgaGFuZGxlLT5jb25uZWN0ZWQoaW9zdHJlYW0sIGVycm9yLmdldCgpKTsKIH0KIAog c3RhdGljIHZvaWQgcmVhZFJlYWR5Q2FsbGJhY2soR0lucHV0U3RyZWFtKiBzdHJlYW0sIEdBc3lu Y1Jlc3VsdCogcmVzdWx0LCB2b2lkKiBpZCkKCmNvbW1pdCAzMTU4ZGY0Y2RhM2E2Y2IxMDlhODM1 ZTE2OTEzOWRiZmNlNjZhZDgwCkF1dGhvcjogRGlya2phbiBPY2h0bWFuIDxkLm9jaHRtYW5AYWN0 aXZldmlkZW8uY29tPgpEYXRlOiAgIE1vbiBKYW4gNiAxNTo0ODo1NCAyMDE0ICswMTAwCgogICAg VXNlIHNvdXBfc2Vzc2lvbl9wcm94eV9jb25uZWN0KCkgdG8gZXN0YWJsaXNoIFNvY2tldFN0cmVh bXMgKGJ1ZyAxMjYzODQpLgoKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9z b3VwL1NvY2tldFN0cmVhbUhhbmRsZS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAv U29ja2V0U3RyZWFtSGFuZGxlLmgKaW5kZXggN2I0Y2Y0YmMuLjc4ZDY5NWIyIDEwMDY0NAotLS0g YS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Tb2NrZXRTdHJlYW1IYW5kbGUuaAorKysg Yi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Tb2NrZXRTdHJlYW1IYW5kbGUuaApAQCAt MzMsNiArMzMsOCBAQAogI2lmbmRlZiBTb2NrZXRTdHJlYW1IYW5kbGVfaAogI2RlZmluZSBTb2Nr ZXRTdHJlYW1IYW5kbGVfaAogCisjaW5jbHVkZSA8Z2lvL2dpby5oPgorCiAjaW5jbHVkZSA8d3Rm L2dvYmplY3QvR1JlZlB0ci5oPgogI2luY2x1ZGUgIlNvY2tldFN0cmVhbUhhbmRsZUJhc2UuaCIK ICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgpAQCAtNTAsNyArNTIsNyBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAgICAgICAgIHN0YXRpYyBQYXNzUmVmUHRyPFNvY2tldFN0cmVhbUhhbmRsZT4g Y3JlYXRlKEdTb2NrZXRDb25uZWN0aW9uKiBzb2NrZXRDb25uZWN0aW9uLCBTb2NrZXRTdHJlYW1I YW5kbGVDbGllbnQqIGNsaWVudCkgeyByZXR1cm4gYWRvcHRSZWYobmV3IFNvY2tldFN0cmVhbUhh bmRsZShzb2NrZXRDb25uZWN0aW9uLCBjbGllbnQpKTsgfQogCiAgICAgICAgIHZpcnR1YWwgflNv Y2tldFN0cmVhbUhhbmRsZSgpOwotICAgICAgICB2b2lkIGNvbm5lY3RlZChHU29ja2V0Q29ubmVj dGlvbiosIEdFcnJvciopOworICAgICAgICB2b2lkIGNvbm5lY3RlZChHSU9TdHJlYW0qLCBHRXJy b3IqKTsKICAgICAgICAgdm9pZCByZWFkQnl0ZXMoc2lnbmVkIGxvbmcsIEdFcnJvciopOwogICAg ICAgICB2b2lkIHdyaXRlUmVhZHkoKTsKICAgICAgICAgdm9pZCogaWQoKSB7IHJldHVybiBtX2lk OyB9CkBAIC02MCw3ICs2Miw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVh bCB2b2lkIHBsYXRmb3JtQ2xvc2UoKTsKIAogICAgIHByaXZhdGU6Ci0gICAgICAgIEdSZWZQdHI8 R1NvY2tldENvbm5lY3Rpb24+IG1fc29ja2V0Q29ubmVjdGlvbjsKKyAgICAgICAgR1JlZlB0cjxH SU9TdHJlYW0+IG1faW9zdHJlYW07CiAgICAgICAgIEdSZWZQdHI8R0lucHV0U3RyZWFtPiBtX2lu cHV0U3RyZWFtOwogICAgICAgICBHUmVmUHRyPEdQb2xsYWJsZU91dHB1dFN0cmVhbT4gbV9vdXRw dXRTdHJlYW07CiAgICAgICAgIEdSZWZQdHI8R1NvdXJjZT4gbV93cml0ZVJlYWR5U291cmNlOwpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvU29ja2V0U3RyZWFtSGFu ZGxlU291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Tb2NrZXRTdHJlYW1I YW5kbGVTb3VwLmNwcAppbmRleCA5YWE0NzYzNC4uYjE2OWY4NWEgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1NvY2tldFN0cmVhbUhhbmRsZVNvdXAuY3BwCisrKyBi L1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1NvY2tldFN0cmVhbUhhbmRsZVNvdXAuY3Bw CkBAIC0zMCw2ICszMCw3IEBACiAgKi8KIAogI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUg IlJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiU29ja2V0U3RyZWFtSGFuZGxlLmgiCiAKICNp bmNsdWRlICJLVVJMLmgiCkBAIC00MCw2ICs0MSw3IEBACiAKICNpbmNsdWRlIDxnaW8vZ2lvLmg+ CiAjaW5jbHVkZSA8Z2xpYi5oPgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgogCiAjaW5jbHVk ZSA8d3RmL05vdEZvdW5kLmg+CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgpAQCAtNTEsNyArNTMs NyBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiAvLyBUaGVzZSBmdW5jdGlvbnMgaW1tZWRpYXRl bHkgY2FsbCB0aGUgc2ltaWxhcmx5IG5hbWVkIFNvY2tldFN0cmVhbUhhbmRsZSBtZXRob2RzLgot c3RhdGljIHZvaWQgY29ubmVjdGVkQ2FsbGJhY2soR1NvY2tldENsaWVudCosIEdBc3luY1Jlc3Vs dCosIHZvaWQqKTsKK3N0YXRpYyB2b2lkIGNvbm5lY3RlZENhbGxiYWNrKEdJT1N0cmVhbSosIEdF cnJvciosIHZvaWQqKTsKIHN0YXRpYyB2b2lkIHJlYWRSZWFkeUNhbGxiYWNrKEdJbnB1dFN0cmVh bSosIEdBc3luY1Jlc3VsdCosIHZvaWQqKTsKIHN0YXRpYyBnYm9vbGVhbiB3cml0ZVJlYWR5Q2Fs bGJhY2soR1BvbGxhYmxlT3V0cHV0U3RyZWFtKiwgdm9pZCopOwogCkBAIC04NiwxNiArODgsMTIg QEAgU29ja2V0U3RyZWFtSGFuZGxlOjpTb2NrZXRTdHJlYW1IYW5kbGUoY29uc3QgS1VSTCYgdXJs LCBTb2NrZXRTdHJlYW1IYW5kbGVDbGllbnQKICAgICAsIG1fcmVhZEJ1ZmZlcigwKQogewogICAg IExPRyhOZXR3b3JrLCAiU29ja2V0U3RyZWFtSGFuZGxlICVwIG5ldyBjbGllbnQgJXAiLCB0aGlz LCBtX2NsaWVudCk7Ci0gICAgdW5zaWduZWQgaW50IHBvcnQgPSB1cmwuaGFzUG9ydCgpID8gdXJs LnBvcnQoKSA6ICh1cmwucHJvdG9jb2xJcygid3NzIikgPyA0NDMgOiA4MCk7Ci0KKyAgICBLVVJM IG51cmwgPSB1cmwuY29weSgpOworICAgIG51cmwuc2V0UHJvdG9jb2wobnVybC5wcm90b2NvbElz KCJ3c3MiKSA/ICJodHRwcyIgOiAiaHR0cCIpOwogICAgIG1faWQgPSBhY3RpdmF0ZUhhbmRsZSh0 aGlzKTsKLSAgICBHUmVmUHRyPEdTb2NrZXRDbGllbnQ+IHNvY2tldENsaWVudCA9IGFkb3B0R1Jl ZihnX3NvY2tldF9jbGllbnRfbmV3KCkpOwotICAgIC8vQ0xPVURUViAoVGVtcG9yYXJ5ISkgRGlz YWJsZSBwcm94eSByZXNvbHZpbmcgZm9yIHdzIGFuZCB3c3MuCi0gICAgZ19zb2NrZXRfY2xpZW50 X3NldF9lbmFibGVfcHJveHkoc29ja2V0Q2xpZW50LmdldCgpLCBGQUxTRSk7Ci0gICAgaWYgKHVy bC5wcm90b2NvbElzKCJ3c3MiKSkKLSAgICAgICAgZ19zb2NrZXRfY2xpZW50X3NldF90bHMoc29j a2V0Q2xpZW50LmdldCgpLCBUUlVFKTsKLSAgICBnX3NvY2tldF9jbGllbnRfY29ubmVjdF90b19o b3N0X2FzeW5jKHNvY2tldENsaWVudC5nZXQoKSwgdXJsLmhvc3QoKS51dGY4KCkuZGF0YSgpLCBw b3J0LCAwLAotICAgICAgICByZWludGVycHJldF9jYXN0PEdBc3luY1JlYWR5Q2FsbGJhY2s+KGNv bm5lY3RlZENhbGxiYWNrKSwgbV9pZCk7CisgICAgU291cFNlc3Npb24gKnNlc3Npb24gPSBSZXNv dXJjZUhhbmRsZTo6ZGVmYXVsdFNlc3Npb24oKTsKKyAgICBTb3VwVVJJICp1cmkgPSBzb3VwX3Vy aV9uZXcobnVybC5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKyAgICBzb3VwX3Nlc3Npb25fcHJv eHlfY29ubmVjdChzZXNzaW9uLCB1cmksIGNvbm5lY3RlZENhbGxiYWNrLCBtX2lkKTsKIH0KIAog U29ja2V0U3RyZWFtSGFuZGxlOjpTb2NrZXRTdHJlYW1IYW5kbGUoR1NvY2tldENvbm5lY3Rpb24q IHNvY2tldENvbm5lY3Rpb24sIFNvY2tldFN0cmVhbUhhbmRsZUNsaWVudCogY2xpZW50KQpAQCAt MTA0LDcgKzEwMiw3IEBAIFNvY2tldFN0cmVhbUhhbmRsZTo6U29ja2V0U3RyZWFtSGFuZGxlKEdT b2NrZXRDb25uZWN0aW9uKiBzb2NrZXRDb25uZWN0aW9uLCBTb2NrCiB7CiAgICAgTE9HKE5ldHdv cmssICJTb2NrZXRTdHJlYW1IYW5kbGUgJXAgbmV3IGNsaWVudCAlcCIsIHRoaXMsIG1fY2xpZW50 KTsKICAgICBtX2lkID0gYWN0aXZhdGVIYW5kbGUodGhpcyk7Ci0gICAgY29ubmVjdGVkKHNvY2tl dENvbm5lY3Rpb24sIDApOworICAgIGNvbm5lY3RlZChHX0lPX1NUUkVBTShzb2NrZXRDb25uZWN0 aW9uKSwgMCk7CiB9CiAKIFNvY2tldFN0cmVhbUhhbmRsZTo6flNvY2tldFN0cmVhbUhhbmRsZSgp CkBAIC0xMTUsMTYgKzExMywxNiBAQCBTb2NrZXRTdHJlYW1IYW5kbGU6On5Tb2NrZXRTdHJlYW1I YW5kbGUoKQogICAgIHNldENsaWVudCgwKTsKIH0KIAotdm9pZCBTb2NrZXRTdHJlYW1IYW5kbGU6 OmNvbm5lY3RlZChHU29ja2V0Q29ubmVjdGlvbiogc29ja2V0Q29ubmVjdGlvbiwgR0Vycm9yKiBl cnJvcikKK3ZvaWQgU29ja2V0U3RyZWFtSGFuZGxlOjpjb25uZWN0ZWQoR0lPU3RyZWFtKiBpb3N0 cmVhbSwgR0Vycm9yKiBlcnJvcikKIHsKICAgICBpZiAoZXJyb3IpIHsKICAgICAgICAgbV9jbGll bnQtPmRpZEZhaWxTb2NrZXRTdHJlYW0odGhpcywgU29ja2V0U3RyZWFtRXJyb3IoZXJyb3ItPmNv ZGUsIGVycm9yLT5tZXNzYWdlKSk7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBtX3Nv Y2tldENvbm5lY3Rpb24gPSBzb2NrZXRDb25uZWN0aW9uOwotICAgIG1fb3V0cHV0U3RyZWFtID0g R19QT0xMQUJMRV9PVVRQVVRfU1RSRUFNKGdfaW9fc3RyZWFtX2dldF9vdXRwdXRfc3RyZWFtKEdf SU9fU1RSRUFNKG1fc29ja2V0Q29ubmVjdGlvbi5nZXQoKSkpKTsKLSAgICBtX2lucHV0U3RyZWFt ID0gZ19pb19zdHJlYW1fZ2V0X2lucHV0X3N0cmVhbShHX0lPX1NUUkVBTShtX3NvY2tldENvbm5l Y3Rpb24uZ2V0KCkpKTsKKyAgICBtX2lvc3RyZWFtID0gYWRvcHRHUmVmKGlvc3RyZWFtKTsKKyAg ICBtX291dHB1dFN0cmVhbSA9IEdfUE9MTEFCTEVfT1VUUFVUX1NUUkVBTShnX2lvX3N0cmVhbV9n ZXRfb3V0cHV0X3N0cmVhbShpb3N0cmVhbSkpOworICAgIG1faW5wdXRTdHJlYW0gPSBnX2lvX3N0 cmVhbV9nZXRfaW5wdXRfc3RyZWFtKGlvc3RyZWFtKTsKIAogICAgIG1fcmVhZEJ1ZmZlciA9IG5l dyBjaGFyW1JFQURfQlVGRkVSX1NJWkVdOwogICAgIGdfaW5wdXRfc3RyZWFtX3JlYWRfYXN5bmMo bV9pbnB1dFN0cmVhbS5nZXQoKSwgbV9yZWFkQnVmZmVyLCBSRUFEX0JVRkZFUl9TSVpFLCBHX1BS SU9SSVRZX0RFRkFVTFQsIDAsCkBAIC0xOTYsMTIgKzE5NCwxMiBAQCB2b2lkIFNvY2tldFN0cmVh bUhhbmRsZTo6cGxhdGZvcm1DbG9zZSgpCiAgICAgZGVhY3RpdmF0ZUhhbmRsZSh0aGlzKTsKICAg ICBzdG9wV2FpdGluZ0ZvclNvY2tldFdyaXRhYmlsaXR5KCk7CiAKLSAgICBpZiAobV9zb2NrZXRD b25uZWN0aW9uKSB7CisgICAgaWYgKG1faW9zdHJlYW0pIHsKICAgICAgICAgR093blB0cjxHRXJy b3I+IGVycm9yOwotICAgICAgICBnX2lvX3N0cmVhbV9jbG9zZShHX0lPX1NUUkVBTShtX3NvY2tl dENvbm5lY3Rpb24uZ2V0KCkpLCAwLCAmZXJyb3Iub3V0UHRyKCkpOworICAgICAgICBnX2lvX3N0 cmVhbV9jbG9zZShtX2lvc3RyZWFtLmdldCgpLCAwLCAmZXJyb3Iub3V0UHRyKCkpOwogICAgICAg ICBpZiAoZXJyb3IpCiAgICAgICAgICAgICBtX2NsaWVudC0+ZGlkRmFpbFNvY2tldFN0cmVhbSh0 aGlzLCBTb2NrZXRTdHJlYW1FcnJvcihlcnJvci0+Y29kZSwgZXJyb3ItPm1lc3NhZ2UpKTsKLSAg ICAgICAgbV9zb2NrZXRDb25uZWN0aW9uID0gMDsKKyAgICAgICAgbV9pb3N0cmVhbSA9IDA7CiAg ICAgfQogCiAgICAgbV9vdXRwdXRTdHJlYW0gPSAwOwpAQCAtMjUxLDIxICsyNDksMTcgQEAgdm9p ZCBTb2NrZXRTdHJlYW1IYW5kbGU6OnN0b3BXYWl0aW5nRm9yU29ja2V0V3JpdGFiaWxpdHkoKQog ICAgIG1fd3JpdGVSZWFkeVNvdXJjZSA9IDA7CiB9CiAKLXN0YXRpYyB2b2lkIGNvbm5lY3RlZENh bGxiYWNrKEdTb2NrZXRDbGllbnQqIGNsaWVudCwgR0FzeW5jUmVzdWx0KiByZXN1bHQsIHZvaWQq IGlkKQorc3RhdGljIHZvaWQgY29ubmVjdGVkQ2FsbGJhY2soR0lPU3RyZWFtKiBpb3N0cmVhbSwg R0Vycm9yKiBlcnJvciwgdm9pZCogaWQpCiB7Ci0gICAgLy8gQWx3YXlzIGZpbmlzaCB0aGUgY29u bmVjdGlvbiwgZXZlbiBpZiB0aGlzIFNvY2tldFN0cmVhbUhhbmRsZSB3YXMgZGVhY3RpdmF0ZWQg ZWFybGllci4KLSAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7Ci0gICAgR1NvY2tldENvbm5lY3Rp b24qIHNvY2tldENvbm5lY3Rpb24gPSBnX3NvY2tldF9jbGllbnRfY29ubmVjdF90b19ob3N0X2Zp bmlzaChjbGllbnQsIHJlc3VsdCwgJmVycm9yLm91dFB0cigpKTsKLQogICAgIC8vIFRoZSBTb2Nr ZXRTdHJlYW1IYW5kbGUgaGFzIGJlZW4gZGVhY3RpdmF0ZWQsIHNvIGp1c3QgY2xvc2UgdGhlIGNv bm5lY3Rpb24sIGlnbm9yaW5nIGVycm9ycy4KICAgICBTb2NrZXRTdHJlYW1IYW5kbGUqIGhhbmRs ZSA9IGdldEhhbmRsZUZyb21JZChpZCk7CiAgICAgaWYgKCFoYW5kbGUpIHsKLSAgICAgICAgaWYg KHNvY2tldENvbm5lY3Rpb24pCi0gICAgICAgICAgICBnX2lvX3N0cmVhbV9jbG9zZShHX0lPX1NU UkVBTShzb2NrZXRDb25uZWN0aW9uKSwgMCwgMCk7CisgICAgICAgIGlmIChpb3N0cmVhbSkKKyAg ICAgICAgICAgIGdfaW9fc3RyZWFtX2Nsb3NlKGlvc3RyZWFtLCAwLCAwKTsKICAgICAgICAgcmV0 dXJuOwogICAgIH0KIAotICAgIGhhbmRsZS0+Y29ubmVjdGVkKHNvY2tldENvbm5lY3Rpb24sIGVy cm9yLmdldCgpKTsKKyAgICBoYW5kbGUtPmNvbm5lY3RlZChpb3N0cmVhbSwgZXJyb3IpOwogfQog CiBzdGF0aWMgdm9pZCByZWFkUmVhZHlDYWxsYmFjayhHSW5wdXRTdHJlYW0qIHN0cmVhbSwgR0Fz eW5jUmVzdWx0KiByZXN1bHQsIHZvaWQqIGlkKQo= 327159 2017-11-17 02:31:11 -0800 2017-11-17 02:31:11 -0800 libsoup patches for libsoup WebSockets over proxy libsoup-ws-proxy.patches text/plain 23005 dirkjan Y29tbWl0IDA3ZjllY2I3ZmM2NTgwMGI2ZmI5Y2NiMTZmMDZhZmViZGUzMjc5MDMKQXV0aG9yOiBE aXJramFuIE9jaHRtYW4gPGRpcmtqYW5Ab2NodG1hbi5ubD4KRGF0ZTogICBUdWUgSnVuIDE3IDEw OjQ2OjQyIDIwMTQgKzAyMDAKCiAgICBzb3VwLXNlc3Npb246IGRvbid0IHRyeSB0byBkaXNjb25u ZWN0IE5VTEwgY29ubmVjdGlvbgoKZGlmZiAtLWdpdCBhL2xpYnNvdXAvc291cC1zZXNzaW9uLmMg Yi9saWJzb3VwL3NvdXAtc2Vzc2lvbi5jCmluZGV4IDMxNjVmOTguLjlhYzUwZjAgMTAwNjQ0Ci0t LSBhL2xpYnNvdXAvc291cC1zZXNzaW9uLmMKKysrIGIvbGlic291cC9zb3VwLXNlc3Npb24uYwpA QCAtNTgwLDcgKzU4MCw3IEBAIHNldF9wcm94eV9yZXNvbHZlciAoU291cFNlc3Npb24gKnNlc3Np b24sIFNvdXBVUkkgKnVyaSwKIAkJY2hhciAqdXJpX3N0cmluZzsKIAogCQlwcml2LT5wcm94eV91 cmkgPSBzb3VwX3VyaV9jb3B5ICh1cmkpOwotCQl1cmlfc3RyaW5nID0gc291cF91cmlfdG9fc3Ry aW5nICh1cmksIEZBTFNFKTsKKwkJdXJpX3N0cmluZyA9IHNvdXBfdXJpX3RvX3N0cmluZ19pbnRl cm5hbCAodXJpLCBGQUxTRSwgVFJVRSk7CiAJCXByaXYtPnByb3h5X3Jlc29sdmVyID0gZ19zaW1w bGVfcHJveHlfcmVzb2x2ZXJfbmV3ICh1cmlfc3RyaW5nLCBOVUxMKTsKIAkJZ19mcmVlICh1cmlf c3RyaW5nKTsKIAl9IGVsc2UgaWYgKHNvdXBfcmVzb2x2ZXIpIHsKQEAgLTE1ODcsNyArMTU4Nyw3 IEBAIHR1bm5lbF9jb21wbGV0ZSAoU291cE1lc3NhZ2VRdWV1ZUl0ZW0gKnR1bm5lbF9pdGVtLAog CX0KIAogCWlmICghU09VUF9TVEFUVVNfSVNfU1VDQ0VTU0ZVTCAoc3RhdHVzKSkgewotCQlzb3Vw X2Nvbm5lY3Rpb25fZGlzY29ubmVjdCAoaXRlbS0+Y29ubik7CisJCWlmIChpdGVtLT5jb25uKSBz b3VwX2Nvbm5lY3Rpb25fZGlzY29ubmVjdCAoaXRlbS0+Y29ubik7CiAJCXNvdXBfc2Vzc2lvbl9z ZXRfaXRlbV9jb25uZWN0aW9uIChzZXNzaW9uLCBpdGVtLCBOVUxMKTsKIAkJaWYgKCFpdGVtLT5u ZXdfYXBpIHx8IGl0ZW0tPm1zZy0+c3RhdHVzX2NvZGUgPT0gMCkgewogCQkJc291cF9zZXNzaW9u X3NldF9pdGVtX3N0YXR1cyAoc2Vzc2lvbiwgaXRlbSwgc3RhdHVzLCBlcnJvcik7Cgpjb21taXQg Mzc2NmIxY2EwMGY3OTJhMzZjNmIzOTc4ODhiYzhiYTllNDVhNDRmOQpBdXRob3I6IERpcmtqYW4g T2NodG1hbiA8ZC5vY2h0bWFuQGFjdGl2ZXZpZGVvLmNvbT4KRGF0ZTogICBXZWQgQXByIDIzIDE2 OjIwOjI2IDIwMTQgKzAyMDAKCiAgICBzb3VwLXNlc3Npb246IGJ1aWxkIEdFcnJvciBvYmplY3Qg Zm9yIENPTk5FQ1QgZmFpbHVyZXMgKGJ1ZyA3Mjc0MzQpCgpkaWZmIC0tZ2l0IGEvbGlic291cC9z b3VwLXNlc3Npb24uYyBiL2xpYnNvdXAvc291cC1zZXNzaW9uLmMKaW5kZXggN2IzYWEzNy4uMzE2 NWY5OCAxMDA2NDQKLS0tIGEvbGlic291cC9zb3VwLXNlc3Npb24uYworKysgYi9saWJzb3VwL3Nv dXAtc2Vzc2lvbi5jCkBAIC0xNTgwLDYgKzE1ODAsMTIgQEAgdHVubmVsX2NvbXBsZXRlIChTb3Vw TWVzc2FnZVF1ZXVlSXRlbSAqdHVubmVsX2l0ZW0sCiAJaXRlbS0+ZXJyb3IgPSBlcnJvcjsKIAlp ZiAoIXN0YXR1cykKIAkJc3RhdHVzID0gc3RhdHVzX2Zyb21fY29ubmVjdF9lcnJvciAoaXRlbSwg ZXJyb3IpOworCisJaWYgKCFlcnJvciAmJiAhU09VUF9TVEFUVVNfSVNfU1VDQ0VTU0ZVTCAoc3Rh dHVzKSkgeworCQllcnJvciA9IGdfZXJyb3JfbmV3IChTT1VQX0hUVFBfRVJST1IsIHN0YXR1cywg c291cF9zdGF0dXNfZ2V0X3BocmFzZSAoc3RhdHVzKSk7CisJCWl0ZW0tPmVycm9yID0gZXJyb3I7 CisJfQorCiAJaWYgKCFTT1VQX1NUQVRVU19JU19TVUNDRVNTRlVMIChzdGF0dXMpKSB7CiAJCXNv dXBfY29ubmVjdGlvbl9kaXNjb25uZWN0IChpdGVtLT5jb25uKTsKIAkJc291cF9zZXNzaW9uX3Nl dF9pdGVtX2Nvbm5lY3Rpb24gKHNlc3Npb24sIGl0ZW0sIE5VTEwpOwoKY29tbWl0IDgzNzkwZDVj NThjNzdkMjBjOGUzNWYzZTI5YzlhMTUxOWFmZDZhNzcKQXV0aG9yOiBEaXJramFuIE9jaHRtYW4g PGQub2NodG1hbkBhY3RpdmV2aWRlby5jb20+CkRhdGU6ICAgVHVlIERlYyAyNCAxNTozMToyOSAy MDEzICswMTAwCgogICAgc291cC1zZXNzaW9uOiBhZGQgc291cF9zZXNzaW9uX2Nvbm5lY3R7X2Fz eW5jLF9maW5pc2h9IGZ1bmN0aW9ucyAoYnVnIDcyMTM0MykKICAgIAogICAgTmV3IGZ1bmN0aW9u IGFkZGVkIHRvIGFzeW5jaHJvbm91c2x5IGVzdGFibGlzaCBhIGNvbm5lY3Rpb24uIFRoaXMgdXNl cwogICAgc291cC1zZXNzaW9uIG1lY2hhbmljcyB0byBkbyBwcm94eS9TU0wgc3R1ZmYsIGJ1dCBy ZXR1cm5zIGFuIGVzdGFibGlzaGVkCiAgICBjb25uZWN0aW9uIHRvIHRoZSBjYWxsZXIgYXMgYSBH SU9TdHJlYW0uCgpkaWZmIC0tZ2l0IGEvbGlic291cC9saWJzb3VwLTIuNC5zeW0gYi9saWJzb3Vw L2xpYnNvdXAtMi40LnN5bQppbmRleCBiZTRjZDdmLi45NmMyZTllIDEwMDY0NAotLS0gYS9saWJz b3VwL2xpYnNvdXAtMi40LnN5bQorKysgYi9saWJzb3VwL2xpYnNvdXAtMi40LnN5bQpAQCAtMzYy LDYgKzM2Miw4IEBAIHNvdXBfc2Vzc2lvbl9hc3luY19nZXRfdHlwZQogc291cF9zZXNzaW9uX2Fz eW5jX25ldwogc291cF9zZXNzaW9uX2FzeW5jX25ld193aXRoX29wdGlvbnMKIHNvdXBfc2Vzc2lv bl9jYW5jZWxfbWVzc2FnZQorc291cF9zZXNzaW9uX2Nvbm5lY3RfYXN5bmMKK3NvdXBfc2Vzc2lv bl9jb25uZWN0X2ZpbmlzaAogc291cF9zZXNzaW9uX2ZlYXR1cmVfYWRkX2ZlYXR1cmUKIHNvdXBf c2Vzc2lvbl9mZWF0dXJlX2F0dGFjaAogc291cF9zZXNzaW9uX2ZlYXR1cmVfZGV0YWNoCmRpZmYg LS1naXQgYS9saWJzb3VwL3NvdXAtbWVzc2FnZS1xdWV1ZS5oIGIvbGlic291cC9zb3VwLW1lc3Nh Z2UtcXVldWUuaAppbmRleCBmODZhMTI5Li5lZGM0M2NkIDEwMDY0NAotLS0gYS9saWJzb3VwL3Nv dXAtbWVzc2FnZS1xdWV1ZS5oCisrKyBiL2xpYnNvdXAvc291cC1tZXNzYWdlLXF1ZXVlLmgKQEAg LTQ4LDEzICs0OCwxNCBAQCBzdHJ1Y3QgX1NvdXBNZXNzYWdlUXVldWVJdGVtIHsKIAlndWludCBu ZXdfYXBpICAgICAgICAgICA6IDE7CiAJZ3VpbnQgaW9fc3RhcnRlZCAgICAgICAgOiAxOwogCWd1 aW50IGFzeW5jICAgICAgICAgICAgIDogMTsKKwlndWludCBmb3JjZV90dW5uZWwgICAgICA6IDE7 CisJZ3VpbnQgcHJpb3JpdHkgICAgICAgICAgOiAzOwogCWd1aW50IHJlc2VuZF9jb3VudCAgICAg IDogMjg7CiAKIAlTb3VwTWVzc2FnZVF1ZXVlSXRlbVN0YXRlIHN0YXRlOwogCiAJLyo8IHByaXZh dGUgPiovCiAJZ3VpbnQgcmVtb3ZlZCAgICAgICAgICAgICAgOiAxOwotCWd1aW50IHByaW9yaXR5 ICAgICAgICAgICAgIDogMzsKIAlndWludCByZWZfY291bnQgICAgICAgICAgICA6IDI4OwogCVNv dXBNZXNzYWdlUXVldWVJdGVtICpwcmV2LCAqbmV4dDsKIAlTb3VwTWVzc2FnZVF1ZXVlSXRlbSAq cmVsYXRlZDsKZGlmZiAtLWdpdCBhL2xpYnNvdXAvc291cC1zZXNzaW9uLmMgYi9saWJzb3VwL3Nv dXAtc2Vzc2lvbi5jCmluZGV4IGIzMDgxZjEuLjdiM2FhMzcgMTAwNjQ0Ci0tLSBhL2xpYnNvdXAv c291cC1zZXNzaW9uLmMKKysrIGIvbGlic291cC9zb3VwLXNlc3Npb24uYwpAQCAtOSw2ICs5LDcg QEAKICNpbmNsdWRlIDxjb25maWcuaD4KICNlbmRpZgogCisjaW5jbHVkZSA8c3RkbGliLmg+CiAj aW5jbHVkZSA8Z2xpYi9naTE4bi1saWIuaD4KIAogI2luY2x1ZGUgInNvdXAtc2Vzc2lvbi5oIgpA QCAtMTQ5LDYgKzE1MCw4IEBAIHN0YXRpYyB2b2lkIGFzeW5jX3J1bl9xdWV1ZSAoU291cFNlc3Np b24gKnNlc3Npb24pOwogCiBzdGF0aWMgdm9pZCBhc3luY19zZW5kX3JlcXVlc3RfcnVubmluZyAo U291cFNlc3Npb24gKnNlc3Npb24sIFNvdXBNZXNzYWdlUXVldWVJdGVtICppdGVtKTsKIAorc3Rh dGljIHZvaWQgZXh0cmFjdF9jb25uZWN0aW9uIChTb3VwU2Vzc2lvbiAqc2Vzc2lvbiwgU291cE1l c3NhZ2VRdWV1ZUl0ZW0gKml0ZW0pOworCiAjZGVmaW5lIFNPVVBfU0VTU0lPTl9NQVhfQ09OTlNf REVGQVVMVCAxMAogI2RlZmluZSBTT1VQX1NFU1NJT05fTUFYX0NPTk5TX1BFUl9IT1NUX0RFRkFV TFQgMgogCkBAIC0xNTcxLDYgKzE1NzQsNyBAQCB0dW5uZWxfY29tcGxldGUgKFNvdXBNZXNzYWdl UXVldWVJdGVtICp0dW5uZWxfaXRlbSwKIAogCWlmIChpdGVtLT5tc2ctPnN0YXR1c19jb2RlKQog CQlpdGVtLT5zdGF0ZSA9IFNPVVBfTUVTU0FHRV9GSU5JU0hJTkc7CisKIAlzb3VwX21lc3NhZ2Vf c2V0X2h0dHBzX3N0YXR1cyAoaXRlbS0+bXNnLCBpdGVtLT5jb25uKTsKIAogCWl0ZW0tPmVycm9y ID0gZXJyb3I7CkBAIC0xNTc5LDggKzE1ODMsOSBAQCB0dW5uZWxfY29tcGxldGUgKFNvdXBNZXNz YWdlUXVldWVJdGVtICp0dW5uZWxfaXRlbSwKIAlpZiAoIVNPVVBfU1RBVFVTX0lTX1NVQ0NFU1NG VUwgKHN0YXR1cykpIHsKIAkJc291cF9jb25uZWN0aW9uX2Rpc2Nvbm5lY3QgKGl0ZW0tPmNvbm4p OwogCQlzb3VwX3Nlc3Npb25fc2V0X2l0ZW1fY29ubmVjdGlvbiAoc2Vzc2lvbiwgaXRlbSwgTlVM TCk7Ci0JCWlmICghaXRlbS0+bmV3X2FwaSB8fCBpdGVtLT5tc2ctPnN0YXR1c19jb2RlID09IDAp CisJCWlmICghaXRlbS0+bmV3X2FwaSB8fCBpdGVtLT5tc2ctPnN0YXR1c19jb2RlID09IDApIHsK IAkJCXNvdXBfc2Vzc2lvbl9zZXRfaXRlbV9zdGF0dXMgKHNlc3Npb24sIGl0ZW0sIHN0YXR1cywg ZXJyb3IpOworCQl9CiAJfQogCiAJaXRlbS0+c3RhdGUgPSBTT1VQX01FU1NBR0VfUkVBRFk7CkBA IC0xNjA4LDYgKzE2MTMsNyBAQCB0dW5uZWxfbWVzc2FnZV9jb21wbGV0ZWQgKFNvdXBNZXNzYWdl ICptc2csIGdwb2ludGVyIHVzZXJfZGF0YSkKIAlTb3VwTWVzc2FnZVF1ZXVlSXRlbSAqdHVubmVs X2l0ZW0gPSB1c2VyX2RhdGE7CiAJU291cE1lc3NhZ2VRdWV1ZUl0ZW0gKml0ZW0gPSB0dW5uZWxf aXRlbS0+cmVsYXRlZDsKIAlTb3VwU2Vzc2lvbiAqc2Vzc2lvbiA9IHR1bm5lbF9pdGVtLT5zZXNz aW9uOworCWdib29sZWFuIGlzX3NzbDsKIAlndWludCBzdGF0dXM7CiAKIAlpZiAodHVubmVsX2l0 ZW0tPnN0YXRlID09IFNPVVBfTUVTU0FHRV9SRVNUQVJUSU5HKSB7CkBAIC0xNjMxLDYgKzE2Mzcs MTIgQEAgdHVubmVsX21lc3NhZ2VfY29tcGxldGVkIChTb3VwTWVzc2FnZSAqbXNnLCBncG9pbnRl ciB1c2VyX2RhdGEpCiAJCXJldHVybjsKIAl9CiAKKwlnX29iamVjdF9nZXQgKEdfT0JKRUNUIChp dGVtLT5jb25uKSwgInNzbCIsICZpc19zc2wsIE5VTEwpOworCWlmICghaXNfc3NsKSB7CisJCXR1 bm5lbF9jb21wbGV0ZSAodHVubmVsX2l0ZW0sIHN0YXR1cywgTlVMTCk7CisJCXJldHVybjsKKwl9 CisKIAlpZiAodHVubmVsX2l0ZW0tPmFzeW5jKSB7CiAJCXNvdXBfY29ubmVjdGlvbl9zdGFydF9z c2xfYXN5bmMgKGl0ZW0tPmNvbm4sIGl0ZW0tPmNhbmNlbGxhYmxlLAogCQkJCQkJIHR1bm5lbF9o YW5kc2hha2VfY29tcGxldGUsCkBAIC0xOTAxLDEzICsxOTEzLDIxIEBAIHNvdXBfc2Vzc2lvbl9w cm9jZXNzX3F1ZXVlX2l0ZW0gKFNvdXBTZXNzaW9uICAgICAgICAgICpzZXNzaW9uLAogCQkJYnJl YWs7CiAKIAkJY2FzZSBTT1VQX01FU1NBR0VfQ09OTkVDVEVEOgotCQkJaWYgKHNvdXBfY29ubmVj dGlvbl9pc190dW5uZWxsZWQgKGl0ZW0tPmNvbm4pKQotCQkJCXR1bm5lbF9jb25uZWN0IChpdGVt KTsKLQkJCWVsc2UKLQkJCQlpdGVtLT5zdGF0ZSA9IFNPVVBfTUVTU0FHRV9SRUFEWTsKKwkJCWlm IChzb3VwX2Nvbm5lY3Rpb25faXNfdmlhX3Byb3h5IChpdGVtLT5jb25uKSkgeworCQkJCWlmIChp dGVtLT5mb3JjZV90dW5uZWwgfHwgc291cF9jb25uZWN0aW9uX2lzX3R1bm5lbGxlZCAoaXRlbS0+ Y29ubikpIHsKKwkJCQkJdHVubmVsX2Nvbm5lY3QgKGl0ZW0pOworCQkJCQlicmVhazsKKwkJCQl9 CisJCQl9CisJCQlpdGVtLT5zdGF0ZSA9IFNPVVBfTUVTU0FHRV9SRUFEWTsKIAkJCWJyZWFrOwog CiAJCWNhc2UgU09VUF9NRVNTQUdFX1JFQURZOgorCQkJaWYgKGl0ZW0tPmZvcmNlX3R1bm5lbCkg eworCQkJCWl0ZW0tPnN0YXRlID0gU09VUF9NRVNTQUdFX0ZJTklTSElORzsKKwkJCQlicmVhazsK KwkJCX0KKwogCQkJaWYgKGl0ZW0tPm1zZy0+c3RhdHVzX2NvZGUpIHsKIAkJCQlpZiAoaXRlbS0+ bXNnLT5zdGF0dXNfY29kZSA9PSBTT1VQX1NUQVRVU19UUllfQUdBSU4pIHsKIAkJCQkJc291cF9t ZXNzYWdlX2NsZWFudXBfcmVzcG9uc2UgKGl0ZW0tPm1zZyk7CkBAIC0xOTU0LDYgKzE5NzQsOCBA QCBzb3VwX3Nlc3Npb25fcHJvY2Vzc19xdWV1ZV9pdGVtIChTb3VwU2Vzc2lvbiAgICAgICAgICAq c2Vzc2lvbiwKIAkJCX0KIAogCQkJc291cF9tZXNzYWdlX3F1ZXVlX2l0ZW1fcmVmIChpdGVtKTsK KwkJCWlmIChpdGVtLT5mb3JjZV90dW5uZWwpCisJCQkJZXh0cmFjdF9jb25uZWN0aW9uIChzZXNz aW9uLCBpdGVtKTsKIAkJCXNvdXBfc2Vzc2lvbl91bnF1ZXVlX2l0ZW0gKHNlc3Npb24sIGl0ZW0p OwogCQkJaWYgKGl0ZW0tPmFzeW5jICYmIGl0ZW0tPmNhbGxiYWNrKQogCQkJCWl0ZW0tPmNhbGxi YWNrIChzZXNzaW9uLCBpdGVtLT5tc2csIGl0ZW0tPmNhbGxiYWNrX2RhdGEpOwpAQCAtNDU1Niwz ICs0NTc4LDkxIEBAIHNvdXBfcmVxdWVzdF9lcnJvcl9xdWFyayAodm9pZCkKIAkJZXJyb3IgPSBn X3F1YXJrX2Zyb21fc3RhdGljX3N0cmluZyAoInNvdXBfcmVxdWVzdF9lcnJvcl9xdWFyayIpOwog CXJldHVybiBlcnJvcjsKIH0KKwordm9pZCBleHRyYWN0X2Nvbm5lY3Rpb24gKFNvdXBTZXNzaW9u ICpzZXNzaW9uLCBTb3VwTWVzc2FnZVF1ZXVlSXRlbSAqaXRlbSkgeworCisJU291cFNvY2tldCAq c29jazsKKwlTb3VwVVJJICp1cmk7CisJU291cFNlc3Npb25Ib3N0ICpob3N0OworCUdJT1N0cmVh bSAqaW9zdHJlYW07CisJR0Vycm9yICplcnJvcjsKKwlTb3VwQ29ubmVjdGlvbiAqc291cF9jb25u OworCVNvdXBTZXNzaW9uUHJpdmF0ZSAqcHJpdjsKKworCXNvdXBfY29ubiA9IGl0ZW0tPmNvbm47 CisJaXRlbS0+Y29ubiA9IE5VTEw7CisJZXJyb3IgPSAoIXNvdXBfY29ubiAmJiBpdGVtLT5lcnJv cikgPyBnX2Vycm9yX2NvcHkoaXRlbS0+ZXJyb3IpIDogTlVMTDsKKwlzb3VwX3Nlc3Npb25fc2V0 X2l0ZW1fY29ubmVjdGlvbiAoc2Vzc2lvbiwgaXRlbSwgTlVMTCk7CisKKwlpZiAoIXNvdXBfY29u bikgeworCQlnX3Rhc2tfcmV0dXJuX2Vycm9yIChpdGVtLT50YXNrLCBlcnJvcik7CisJCXJldHVy bjsKKwl9CisKKwlwcml2ID0gU09VUF9TRVNTSU9OX0dFVF9QUklWQVRFIChzZXNzaW9uKTsKKwl1 cmkgPSBzb3VwX21lc3NhZ2VfZ2V0X3VyaSAoaXRlbS0+bXNnKTsKKwlob3N0ID0gZ2V0X2hvc3Rf Zm9yX3VyaSAoc2Vzc2lvbiwgdXJpKTsKKworCWdfbXV0ZXhfbG9jayAoJnByaXYtPmNvbm5fbG9j ayk7CisJZ19oYXNoX3RhYmxlX3JlbW92ZSAocHJpdi0+Y29ubnMsIHNvdXBfY29ubik7CisJZHJv cF9jb25uZWN0aW9uIChzZXNzaW9uLCBob3N0LCBzb3VwX2Nvbm4pOworCWdfbXV0ZXhfdW5sb2Nr ICgmcHJpdi0+Y29ubl9sb2NrKTsKKworCXNvY2sgPSBzb3VwX2Nvbm5lY3Rpb25fZ2V0X3NvY2tl dChzb3VwX2Nvbm4pOworCWdfb2JqZWN0X3VucmVmIChzb3VwX2Nvbm4pOworCisJaW9zdHJlYW0g PSBzb3VwX3NvY2tldF9nZXRfY29ubmVjdGlvbihzb2NrKTsKKwlnX29iamVjdF9yZWYgKGlvc3Ry ZWFtKTsKKwlnX29iamVjdF9zZXQgKEdfT0JKRUNUIChzb2NrKSwgImNsb3NlLW9uLWRpc3Bvc2Ui LCBGQUxTRSwgTlVMTCk7CisJZ19vYmplY3RfdW5yZWYgKHNvY2spOworCisJZ190YXNrX3JldHVy bl9wb2ludGVyIChpdGVtLT50YXNrLCBpb3N0cmVhbSwgZ19vYmplY3RfdW5yZWYpOworfQorCisv KioKKyAqIHNvdXBfc2Vzc2lvbl9jb25uZWN0X2ZpbmlzaDoKKyAqIEBzZXNzaW9uOiBhICNTb3Vw U2Vzc2lvbgorICogQHJlc3VsdDogdGhlICNHQXN5bmNSZXN1bHQgZnJvbSB0aGUgY29ubmVjdCBv cGVyYXRpb24KKyAqIEB1c2VyX2RhdGE6IG91dHBhcmFtIGZvciBwb3NzaWJsZSBlcnJvcnMKKyAq CisgKiBTaW5jZTogMi40NgorICovCitHSU9TdHJlYW0qIHNvdXBfc2Vzc2lvbl9jb25uZWN0X2Zp bmlzaCAoU291cFNlc3Npb24gKnNlc3Npb24sCisJCQkgICBHQXN5bmNSZXN1bHQgKnJlc3VsdCwK KwkJCSAgIEdFcnJvciAqKmVycm9yKSB7CisJZ19yZXR1cm5fdmFsX2lmX2ZhaWwgKGdfdGFza19p c192YWxpZCAocmVzdWx0LCBzZXNzaW9uKSwgTlVMTCk7CisJcmV0dXJuIGdfdGFza19wcm9wYWdh dGVfcG9pbnRlciAoIEdfVEFTSyAocmVzdWx0KSwgZXJyb3IpOworfQorCisvKioKKyAqIHNvdXBf c2Vzc2lvbl9jb25uZWN0X2FzeW5jOgorICogQHNlc3Npb246IGEgI1NvdXBTZXNzaW9uCisgKiBA ZGVzdGluYXRpb246IGEgI1NvdXBVUkkgcmVwcmVzZW50aW5nIHRoZSBVUkkvaG9zdCB0byBjb25u ZWN0IHRvCisgKiBAY2FsbGJhY2s6IGEgY2FsbGJhY2sgdG8gY2FsbCB3aGVuIHRoZSBjb25uZWN0 aW9uIGlzIGVzdGFibGlzaGVkCisgKiBAdXNlcl9kYXRhOiBkYXRhIGZvciBAY2FsbGJhY2sKKyAq CisgKiBTZXRzIHVwIGEgI1NvdXBDb25uZWN0aW9uIHRvIHRoZSBAZGVzdGluYXRpb24gYWNjb3Jk aW5nIHRvIHRoZQorICogdXN1YWwgI1NvdXBTZXNzaW9uIHByb2Nlc3MgKGkuZS4gY29tcGxldGUg d2l0aCBUTFMgYW5kIHByb3h5CisgKiBzZXR1cCkuIFRoZSByZXN1bHRpbmcgI0dJT1N0cmVhbSBp cyB0aGVuIHBhc3NlZCB0byB0aGUgY2FsbGJhY2sKKyAqIGFmdGVyIHRoZSBhc3NvY2lhdGVkICNT b3VwQ29ubmVjdGlvbiBhbmQgI1NvdXBTb2NrZXQgYXJlIGZyZWVkLgorICoKKyAqIFNpbmNlOiAy LjQ2CisgKi8KK3ZvaWQgc291cF9zZXNzaW9uX2Nvbm5lY3RfYXN5bmMgKFNvdXBTZXNzaW9uICpz ZXNzaW9uLAorCQkJICAgU291cFVSSSAqZGVzdGluYXRpb24sCisJCQkgICBHQXN5bmNSZWFkeUNh bGxiYWNrIGNhbGxiYWNrLAorCQkJICAgZ3BvaW50ZXIgdXNlcl9kYXRhKSB7CisJU291cE1lc3Nh Z2UgKm1zZzsKKwlTb3VwTWVzc2FnZVF1ZXVlSXRlbSAqaXRlbTsKKworCW1zZyA9IHNvdXBfbWVz c2FnZV9uZXdfZnJvbV91cmkgKFNPVVBfTUVUSE9EX0hFQUQsIGRlc3RpbmF0aW9uKTsKKwlpdGVt ID0gc291cF9zZXNzaW9uX2FwcGVuZF9xdWV1ZV9pdGVtIChzZXNzaW9uLCBtc2csIFRSVUUsIFRS VUUsCisJCQkJCSAgICAgICBOVUxMLCBOVUxMKTsKKwlzb3VwX21lc3NhZ2VfcXVldWVfaXRlbV9y ZWYgKGl0ZW0pOworCisJaXRlbS0+bmV3X2FwaSA9IFRSVUU7CisJaXRlbS0+Zm9yY2VfdHVubmVs ID0gVFJVRTsKKwlpdGVtLT50YXNrID0gZ190YXNrX25ldyAoc2Vzc2lvbiwgTlVMTCwgY2FsbGJh Y2ssIHVzZXJfZGF0YSk7CisJZ190YXNrX3NldF90YXNrX2RhdGEgKGl0ZW0tPnRhc2ssIGl0ZW0s IChHRGVzdHJveU5vdGlmeSkgc291cF9tZXNzYWdlX3F1ZXVlX2l0ZW1fdW5yZWYpOworCXNvdXBf c2Vzc2lvbl9raWNrX3F1ZXVlIChzZXNzaW9uKTsKK30KZGlmZiAtLWdpdCBhL2xpYnNvdXAvc291 cC1zZXNzaW9uLmggYi9saWJzb3VwL3NvdXAtc2Vzc2lvbi5oCmluZGV4IDY3YTU5ZWEuLjkzM2Nj YTggMTAwNjQ0Ci0tLSBhL2xpYnNvdXAvc291cC1zZXNzaW9uLmgKKysrIGIvbGlic291cC9zb3Vw LXNlc3Npb24uaApAQCAtMTk4LDYgKzE5OCwxNSBAQCBTT1VQX0FWQUlMQUJMRV9JTl8yXzQyCiBH UXVhcmsgc291cF9yZXF1ZXN0X2Vycm9yX3F1YXJrICh2b2lkKTsKICNkZWZpbmUgU09VUF9SRVFV RVNUX0VSUk9SIHNvdXBfcmVxdWVzdF9lcnJvcl9xdWFyayAoKQogCit2b2lkIHNvdXBfc2Vzc2lv bl9jb25uZWN0X2FzeW5jIChTb3VwU2Vzc2lvbiAqc2Vzc2lvbiwKKwkJCQkJCVNvdXBVUkkJCQkJ CSpkZXN0aW5hdGlvbiwKKwkJCQkJCUdBc3luY1JlYWR5Q2FsbGJhY2sJCWNhbGxiYWNrLAorCQkJ CQkJZ3BvaW50ZXIJCQkJdXNlcl9kYXRhKTsKKworR0lPU3RyZWFtKiBzb3VwX3Nlc3Npb25fY29u bmVjdF9maW5pc2ggKFNvdXBTZXNzaW9uICpzZXNzaW9uLAorCQkJCQkgICAgR0FzeW5jUmVzdWx0 CQkgICAgICpyZXN1bHQsCisJCQkJCSAgICBHRXJyb3IJCQkJICAgICoqZXJyb3IpOworCiB0eXBl ZGVmIGVudW0gewogCVNPVVBfUkVRVUVTVF9FUlJPUl9CQURfVVJJLAogCVNPVVBfUkVRVUVTVF9F UlJPUl9VTlNVUFBPUlRFRF9VUklfU0NIRU1FLAoKY29tbWl0IDMxYTg3ODU0N2E1MGFjYTNiM2Iz NGIxMzc2ZTUxYmI1NDZjYTI2NTAKQXV0aG9yOiBEaXJramFuIE9jaHRtYW4gPGQub2NodG1hbkBh Y3RpdmV2aWRlby5jb20+CkRhdGU6ICAgTW9uIEphbiA2IDA5OjA5OjM0IDIwMTQgKzAxMDAKCiAg ICBzb3VwLXNvY2tldDogYWRkIGZsYWcgY2xvc2Vfb25fZGlzcG9zZSB0byBTb3VwU29ja2V0Cgpk aWZmIC0tZ2l0IGEvbGlic291cC9zb3VwLW1pc2MtcHJpdmF0ZS5oIGIvbGlic291cC9zb3VwLW1p c2MtcHJpdmF0ZS5oCmluZGV4IDUwYTNiOTguLjVjNDFkNWUgMTAwNjQ0Ci0tLSBhL2xpYnNvdXAv c291cC1taXNjLXByaXZhdGUuaAorKysgYi9saWJzb3VwL3NvdXAtbWlzYy1wcml2YXRlLmgKQEAg LTQ2LDYgKzQ2LDcgQEAgR0lPU3RyZWFtICpzb3VwX3NvY2tldF9nZXRfaW9zdHJlYW0gICAoU291 cFNvY2tldCAqc29jayk7CiAKICNkZWZpbmUgU09VUF9TT0NLRVRfQ0xFQU5fRElTUE9TRSAiY2xl YW4tZGlzcG9zZSIKICNkZWZpbmUgU09VUF9TT0NLRVRfUFJPWFlfUkVTT0xWRVIgInByb3h5LXJl c29sdmVyIgorI2RlZmluZSBTT1VQX1NPQ0tFVF9DTE9TRV9PTl9ESVNQT1NFICJjbG9zZS1vbi1k aXNwb3NlIgogU291cFVSSSAqc291cF9zb2NrZXRfZ2V0X2h0dHBfcHJveHlfdXJpIChTb3VwU29j a2V0ICpzb2NrKTsKIAogLyogQXQgc29tZSBwb2ludCBpdCBtaWdodCBiZSBwb3NzaWJsZSB0byBt YXJrIGFkZGl0aW9uYWwgbWV0aG9kcwpkaWZmIC0tZ2l0IGEvbGlic291cC9zb3VwLXNvY2tldC5j IGIvbGlic291cC9zb3VwLXNvY2tldC5jCmluZGV4IGUwNzQ4ZmQuLjdiZWQ2MjQgMTAwNjQ0Ci0t LSBhL2xpYnNvdXAvc291cC1zb2NrZXQuYworKysgYi9saWJzb3VwL3NvdXAtc29ja2V0LmMKQEAg LTYwLDYgKzYwLDcgQEAgZW51bSB7CiAJUFJPUF9UTFNfQ0VSVElGSUNBVEUsCiAJUFJPUF9UTFNf RVJST1JTLAogCVBST1BfUFJPWFlfUkVTT0xWRVIsCisJUFJPUF9DTE9TRV9PTl9ESVNQT1NFLAog CiAJTEFTVF9QUk9QCiB9OwpAQCAtNzksNiArODAsNyBAQCB0eXBlZGVmIHN0cnVjdCB7CiAJZ3Vp bnQgc3NsX3N0cmljdDoxOwogCWd1aW50IHNzbF9mYWxsYmFjazoxOwogCWd1aW50IGNsZWFuX2Rp c3Bvc2U6MTsKKwlndWludCBjbG9zZV9vbl9kaXNwb3NlOjE7CiAJZ3VpbnQgdXNlX3RocmVhZF9j b250ZXh0OjE7CiAJZ3BvaW50ZXIgc3NsX2NyZWRzOwogCkBAIC0xMDMsNiArMTA1LDcgQEAgc291 cF9zb2NrZXRfaW5pdCAoU291cFNvY2tldCAqc29jaykKIAlTb3VwU29ja2V0UHJpdmF0ZSAqcHJp diA9IFNPVVBfU09DS0VUX0dFVF9QUklWQVRFIChzb2NrKTsKIAogCXByaXYtPm5vbl9ibG9ja2lu ZyA9IFRSVUU7CisJcHJpdi0+Y2xvc2Vfb25fZGlzcG9zZSA9IFRSVUU7CiAJZ19tdXRleF9pbml0 ICgmcHJpdi0+YWRkcmxvY2spOwogCWdfbXV0ZXhfaW5pdCAoJnByaXYtPmlvbG9jayk7CiB9CkBA IC0xMzYsNyArMTM5LDcgQEAgc291cF9zb2NrZXRfZmluYWxpemUgKEdPYmplY3QgKm9iamVjdCkK IAkJCWdfd2FybmluZyAoIkRpc3Bvc2luZyBzb2NrZXQgJXAgZHVyaW5nIGNvbm5lY3QiLCBvYmpl Y3QpOwogCQlnX29iamVjdF91bnJlZiAocHJpdi0+Y29ubmVjdF9jYW5jZWwpOwogCX0KLQlpZiAo cHJpdi0+Z3NvY2spIHsKKwlpZiAocHJpdi0+Z3NvY2sgJiYgcHJpdi0+Y2xvc2Vfb25fZGlzcG9z ZSkgewogCQlpZiAocHJpdi0+Y2xlYW5fZGlzcG9zZSkKIAkJCWdfd2FybmluZyAoIkRpc3Bvc2lu ZyBzb2NrZXQgJXAgd2hpbGUgc3RpbGwgY29ubmVjdGVkIiwgb2JqZWN0KTsKIAkJZGlzY29ubmVj dF9pbnRlcm5hbCAoU09VUF9TT0NLRVQgKG9iamVjdCksIFRSVUUpOwpAQCAtMjI5LDYgKzIzMiw5 IEBAIHNvdXBfc29ja2V0X3NldF9wcm9wZXJ0eSAoR09iamVjdCAqb2JqZWN0LCBndWludCBwcm9w X2lkLAogCWNhc2UgUFJPUF9DTEVBTl9ESVNQT1NFOgogCQlwcml2LT5jbGVhbl9kaXNwb3NlID0g Z192YWx1ZV9nZXRfYm9vbGVhbiAodmFsdWUpOwogCQlicmVhazsKKwljYXNlIFBST1BfQ0xPU0Vf T05fRElTUE9TRToKKwkJcHJpdi0+Y2xvc2Vfb25fZGlzcG9zZSA9IGdfdmFsdWVfZ2V0X2Jvb2xl YW4gKHZhbHVlKTsKKwkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJR19PQkpFQ1RfV0FSTl9JTlZBTElE X1BST1BFUlRZX0lEIChvYmplY3QsIHByb3BfaWQsIHBzcGVjKTsKIAkJYnJlYWs7CkBAIC0yODcs NiArMjkzLDkgQEAgc291cF9zb2NrZXRfZ2V0X3Byb3BlcnR5IChHT2JqZWN0ICpvYmplY3QsIGd1 aW50IHByb3BfaWQsCiAJY2FzZSBQUk9QX1BST1hZX1JFU09MVkVSOgogCQlnX3ZhbHVlX3NldF9v YmplY3QgKHZhbHVlLCBwcml2LT5wcm94eV9yZXNvbHZlcik7CiAJCWJyZWFrOworCWNhc2UgUFJP UF9DTE9TRV9PTl9ESVNQT1NFOgorCQlnX3ZhbHVlX3NldF9ib29sZWFuICh2YWx1ZSwgcHJpdi0+ Y2xvc2Vfb25fZGlzcG9zZSk7CisJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCUdfT0JKRUNUX1dBUk5f SU5WQUxJRF9QUk9QRVJUWV9JRCAob2JqZWN0LCBwcm9wX2lkLCBwc3BlYyk7CiAJCWJyZWFrOwpA QCAtNjI4LDYgKzYzNywxNCBAQCBzb3VwX3NvY2tldF9jbGFzc19pbml0IChTb3VwU29ja2V0Q2xh c3MgKnNvY2tldF9jbGFzcykKIAkJCQkgICAgICJHUHJveHlSZXNvbHZlciB0byB1c2UiLAogCQkJ CSAgICAgR19UWVBFX1BST1hZX1JFU09MVkVSLAogCQkJCSAgICAgR19QQVJBTV9SRUFEV1JJVEUg fCBHX1BBUkFNX0NPTlNUUlVDVF9PTkxZKSk7CisKKwlnX29iamVjdF9jbGFzc19pbnN0YWxsX3By b3BlcnR5ICgKKwkJb2JqZWN0X2NsYXNzLCBQUk9QX0NMT1NFX09OX0RJU1BPU0UsCisJCWdfcGFy YW1fc3BlY19ib29sZWFuIChTT1VQX1NPQ0tFVF9DTE9TRV9PTl9ESVNQT1NFLAorCQkJCSAgICAg IkNsb3NlIHNvY2tldCBvbiBkaXNwb3NhbCIsCisJCQkJICAgICAiV2hldGhlciB0aGUgc29ja2V0 IGlzIGNsb3NlZCBvbiBkaXNwb3NhbCIsCisJCQkJICAgICBUUlVFLAorCQkJCSAgICAgR19QQVJB TV9SRUFEV1JJVEUpKTsKIH0KIAogCgpjb21taXQgMGM5YmQ2N2I3YmM5NjRjMjQwYmE2ZjM4MDEz ZjA5ZGZkMDI2MTE0ZgpBdXRob3I6IERpcmtqYW4gT2NodG1hbiA8ZC5vY2h0bWFuQGFjdGl2ZXZp ZGVvLmNvbT4KRGF0ZTogICBNb24gSmFuIDYgMDk6MDA6MTkgMjAxNCArMDEwMAoKICAgIHNvdXAt Y29ubmVjdGlvbjogZG9uJ3QgZGlzY29ubmVjdCB0aGUgY29ubmVjdGlvbiBvbiBkaXNwb3NlCgpk aWZmIC0tZ2l0IGEvbGlic291cC9zb3VwLWNvbm5lY3Rpb24uYyBiL2xpYnNvdXAvc291cC1jb25u ZWN0aW9uLmMKaW5kZXggMmI1ZGM0OS4uNDQ2ODIxMiAxMDA2NDQKLS0tIGEvbGlic291cC9zb3Vw LWNvbm5lY3Rpb24uYworKysgYi9saWJzb3VwL3NvdXAtY29ubmVjdGlvbi5jCkBAIC05NiwxNCAr OTYsNyBAQCBzb3VwX2Nvbm5lY3Rpb25fZGlzcG9zZSAoR09iamVjdCAqb2JqZWN0KQogewogCVNv dXBDb25uZWN0aW9uICpjb25uID0gU09VUF9DT05ORUNUSU9OIChvYmplY3QpOwogCVNvdXBDb25u ZWN0aW9uUHJpdmF0ZSAqcHJpdiA9IFNPVVBfQ09OTkVDVElPTl9HRVRfUFJJVkFURSAoY29ubik7 Ci0KIAlzdG9wX2lkbGVfdGltZXIgKHByaXYpOwotCi0JaWYgKHByaXYtPnNvY2tldCkgewotCQln X3dhcm5pbmcgKCJEaXNwb3NpbmcgY29ubmVjdGlvbiB3aGlsZSBjb25uZWN0ZWQiKTsKLQkJc291 cF9jb25uZWN0aW9uX2Rpc2Nvbm5lY3QgKGNvbm4pOwotCX0KLQogCUdfT0JKRUNUX0NMQVNTIChz b3VwX2Nvbm5lY3Rpb25fcGFyZW50X2NsYXNzKS0+ZGlzcG9zZSAob2JqZWN0KTsKIH0KIAoKY29t bWl0IDJkYzQ0YWIwODU1ZTM5NGM0MjA5MGIzNDA1ZWFiZTg5MDg3MDFkNjYKQXV0aG9yOiBEaXJr amFuIE9jaHRtYW4gPGQub2NodG1hbkBhY3RpdmV2aWRlby5jb20+CkRhdGU6ICAgV2VkIEFwciAy MyAxNjoyMDoyNiAyMDE0ICswMjAwCgogICAgc291cC1zZXNzaW9uOiBidWlsZCBHRXJyb3Igb2Jq ZWN0IGZvciBDT05ORUNUIGZhaWx1cmVzIChidWcgNzI3NDM0KQoKZGlmZiAtLWdpdCBhL2xpYnNv dXAvc291cC1zZXNzaW9uLmMgYi9saWJzb3VwL3NvdXAtc2Vzc2lvbi5jCmluZGV4IDBlYjMzNGYu LmJhYmMyMmEgMTAwNjQ0Ci0tLSBhL2xpYnNvdXAvc291cC1zZXNzaW9uLmMKKysrIGIvbGlic291 cC9zb3VwLXNlc3Npb24uYwpAQCAtMTU4MCw2ICsxNTgwLDEyIEBAIHR1bm5lbF9jb21wbGV0ZSAo U291cE1lc3NhZ2VRdWV1ZUl0ZW0gKnR1bm5lbF9pdGVtLAogCWl0ZW0tPmVycm9yID0gZXJyb3I7 CiAJaWYgKCFzdGF0dXMpCiAJCXN0YXR1cyA9IHN0YXR1c19mcm9tX2Nvbm5lY3RfZXJyb3IgKGl0 ZW0sIGVycm9yKTsKKworCWlmICghZXJyb3IgJiYgIVNPVVBfU1RBVFVTX0lTX1NVQ0NFU1NGVUwg KHN0YXR1cykpIHsKKwkJZXJyb3IgPSBnX2Vycm9yX25ldyAoU09VUF9IVFRQX0VSUk9SLCBzdGF0 dXMsIHNvdXBfc3RhdHVzX2dldF9waHJhc2UgKHN0YXR1cykpOworCQlpdGVtLT5lcnJvciA9IGVy cm9yOworCX0KKwogCWlmICghU09VUF9TVEFUVVNfSVNfU1VDQ0VTU0ZVTCAoc3RhdHVzKSkgewog CQlzb3VwX2Nvbm5lY3Rpb25fZGlzY29ubmVjdCAoaXRlbS0+Y29ubik7CiAJCXNvdXBfc2Vzc2lv bl9zZXRfaXRlbV9jb25uZWN0aW9uIChzZXNzaW9uLCBpdGVtLCBOVUxMKTsKCmNvbW1pdCA3OTdl MWJjYmUyMDhkYTEzYWQzYjUxYzUwMDI4ZGUxZmU5MzNjYmEwCkF1dGhvcjogRGlya2phbiBPY2h0 bWFuIDxkLm9jaHRtYW5AYWN0aXZldmlkZW8uY29tPgpEYXRlOiAgIFR1ZSBEZWMgMjQgMTU6MzE6 MjkgMjAxMyArMDEwMAoKICAgIHNvdXAtc2Vzc2lvbjogYWRkIHNvdXBfc2Vzc2lvbl9jb25uZWN0 e19hc3luYyxfZmluaXNofSBmdW5jdGlvbnMgKGJ1ZyA3MjEzNDMpCiAgICAKICAgIE5ldyBmdW5j dGlvbiBhZGRlZCB0byBhc3luY2hyb25vdXNseSBlc3RhYmxpc2ggYSBjb25uZWN0aW9uLiBUaGlz IHVzZXMKICAgIHNvdXAtc2Vzc2lvbiBtZWNoYW5pY3MgdG8gZG8gcHJveHkvU1NMIHN0dWZmLCBi dXQgcmV0dXJucyBhbiBlc3RhYmxpc2hlZAogICAgY29ubmVjdGlvbiB0byB0aGUgY2FsbGVyIGFz IGEgR0lPU3RyZWFtLgoKZGlmZiAtLWdpdCBhL2xpYnNvdXAvbGlic291cC0yLjQuc3ltIGIvbGli c291cC9saWJzb3VwLTIuNC5zeW0KaW5kZXggYmU0Y2Q3Zi4uOTZjMmU5ZSAxMDA2NDQKLS0tIGEv bGlic291cC9saWJzb3VwLTIuNC5zeW0KKysrIGIvbGlic291cC9saWJzb3VwLTIuNC5zeW0KQEAg LTM2Miw2ICszNjIsOCBAQCBzb3VwX3Nlc3Npb25fYXN5bmNfZ2V0X3R5cGUKIHNvdXBfc2Vzc2lv bl9hc3luY19uZXcKIHNvdXBfc2Vzc2lvbl9hc3luY19uZXdfd2l0aF9vcHRpb25zCiBzb3VwX3Nl c3Npb25fY2FuY2VsX21lc3NhZ2UKK3NvdXBfc2Vzc2lvbl9jb25uZWN0X2FzeW5jCitzb3VwX3Nl c3Npb25fY29ubmVjdF9maW5pc2gKIHNvdXBfc2Vzc2lvbl9mZWF0dXJlX2FkZF9mZWF0dXJlCiBz b3VwX3Nlc3Npb25fZmVhdHVyZV9hdHRhY2gKIHNvdXBfc2Vzc2lvbl9mZWF0dXJlX2RldGFjaApk aWZmIC0tZ2l0IGEvbGlic291cC9zb3VwLW1lc3NhZ2UtcXVldWUuaCBiL2xpYnNvdXAvc291cC1t ZXNzYWdlLXF1ZXVlLmgKaW5kZXggZjg2YTEyOS4uZWRjNDNjZCAxMDA2NDQKLS0tIGEvbGlic291 cC9zb3VwLW1lc3NhZ2UtcXVldWUuaAorKysgYi9saWJzb3VwL3NvdXAtbWVzc2FnZS1xdWV1ZS5o CkBAIC00OCwxMyArNDgsMTQgQEAgc3RydWN0IF9Tb3VwTWVzc2FnZVF1ZXVlSXRlbSB7CiAJZ3Vp bnQgbmV3X2FwaSAgICAgICAgICAgOiAxOwogCWd1aW50IGlvX3N0YXJ0ZWQgICAgICAgIDogMTsK IAlndWludCBhc3luYyAgICAgICAgICAgICA6IDE7CisJZ3VpbnQgZm9yY2VfdHVubmVsICAgICAg OiAxOworCWd1aW50IHByaW9yaXR5ICAgICAgICAgIDogMzsKIAlndWludCByZXNlbmRfY291bnQg ICAgICA6IDI4OwogCiAJU291cE1lc3NhZ2VRdWV1ZUl0ZW1TdGF0ZSBzdGF0ZTsKIAogCS8qPCBw cml2YXRlID4qLwogCWd1aW50IHJlbW92ZWQgICAgICAgICAgICAgIDogMTsKLQlndWludCBwcmlv cml0eSAgICAgICAgICAgICA6IDM7CiAJZ3VpbnQgcmVmX2NvdW50ICAgICAgICAgICAgOiAyODsK IAlTb3VwTWVzc2FnZVF1ZXVlSXRlbSAqcHJldiwgKm5leHQ7CiAJU291cE1lc3NhZ2VRdWV1ZUl0 ZW0gKnJlbGF0ZWQ7CmRpZmYgLS1naXQgYS9saWJzb3VwL3NvdXAtc2Vzc2lvbi5jIGIvbGlic291 cC9zb3VwLXNlc3Npb24uYwppbmRleCAxMzI1NTRkLi4wZWIzMzRmIDEwMDY0NAotLS0gYS9saWJz b3VwL3NvdXAtc2Vzc2lvbi5jCisrKyBiL2xpYnNvdXAvc291cC1zZXNzaW9uLmMKQEAgLTksNiAr OSw3IEBACiAjaW5jbHVkZSA8Y29uZmlnLmg+CiAjZW5kaWYKIAorI2luY2x1ZGUgPHN0ZGxpYi5o PgogI2luY2x1ZGUgPGdsaWIvZ2kxOG4tbGliLmg+CiAKICNpbmNsdWRlICJzb3VwLXNlc3Npb24u aCIKQEAgLTE0OSw2ICsxNTAsOCBAQCBzdGF0aWMgdm9pZCBhc3luY19ydW5fcXVldWUgKFNvdXBT ZXNzaW9uICpzZXNzaW9uKTsKIAogc3RhdGljIHZvaWQgYXN5bmNfc2VuZF9yZXF1ZXN0X3J1bm5p bmcgKFNvdXBTZXNzaW9uICpzZXNzaW9uLCBTb3VwTWVzc2FnZVF1ZXVlSXRlbSAqaXRlbSk7CiAK K3N0YXRpYyB2b2lkIGV4dHJhY3RfY29ubmVjdGlvbiAoU291cFNlc3Npb24gKnNlc3Npb24sIFNv dXBNZXNzYWdlUXVldWVJdGVtICppdGVtKTsKKwogI2RlZmluZSBTT1VQX1NFU1NJT05fTUFYX0NP Tk5TX0RFRkFVTFQgMTAKICNkZWZpbmUgU09VUF9TRVNTSU9OX01BWF9DT05OU19QRVJfSE9TVF9E RUZBVUxUIDIKIApAQCAtMTU3MSw2ICsxNTc0LDcgQEAgdHVubmVsX2NvbXBsZXRlIChTb3VwTWVz c2FnZVF1ZXVlSXRlbSAqdHVubmVsX2l0ZW0sCiAKIAlpZiAoaXRlbS0+bXNnLT5zdGF0dXNfY29k ZSkKIAkJaXRlbS0+c3RhdGUgPSBTT1VQX01FU1NBR0VfRklOSVNISU5HOworCiAJc291cF9tZXNz YWdlX3NldF9odHRwc19zdGF0dXMgKGl0ZW0tPm1zZywgaXRlbS0+Y29ubik7CiAKIAlpdGVtLT5l cnJvciA9IGVycm9yOwpAQCAtMTU3OSw4ICsxNTgzLDkgQEAgdHVubmVsX2NvbXBsZXRlIChTb3Vw TWVzc2FnZVF1ZXVlSXRlbSAqdHVubmVsX2l0ZW0sCiAJaWYgKCFTT1VQX1NUQVRVU19JU19TVUND RVNTRlVMIChzdGF0dXMpKSB7CiAJCXNvdXBfY29ubmVjdGlvbl9kaXNjb25uZWN0IChpdGVtLT5j b25uKTsKIAkJc291cF9zZXNzaW9uX3NldF9pdGVtX2Nvbm5lY3Rpb24gKHNlc3Npb24sIGl0ZW0s IE5VTEwpOwotCQlpZiAoIWl0ZW0tPm5ld19hcGkgfHwgaXRlbS0+bXNnLT5zdGF0dXNfY29kZSA9 PSAwKQorCQlpZiAoIWl0ZW0tPm5ld19hcGkgfHwgaXRlbS0+bXNnLT5zdGF0dXNfY29kZSA9PSAw KSB7CiAJCQlzb3VwX3Nlc3Npb25fc2V0X2l0ZW1fc3RhdHVzIChzZXNzaW9uLCBpdGVtLCBzdGF0 dXMsIGVycm9yKTsKKwkJfQogCX0KIAogCWl0ZW0tPnN0YXRlID0gU09VUF9NRVNTQUdFX1JFQURZ OwpAQCAtMTYwOCw2ICsxNjEzLDcgQEAgdHVubmVsX21lc3NhZ2VfY29tcGxldGVkIChTb3VwTWVz c2FnZSAqbXNnLCBncG9pbnRlciB1c2VyX2RhdGEpCiAJU291cE1lc3NhZ2VRdWV1ZUl0ZW0gKnR1 bm5lbF9pdGVtID0gdXNlcl9kYXRhOwogCVNvdXBNZXNzYWdlUXVldWVJdGVtICppdGVtID0gdHVu bmVsX2l0ZW0tPnJlbGF0ZWQ7CiAJU291cFNlc3Npb24gKnNlc3Npb24gPSB0dW5uZWxfaXRlbS0+ c2Vzc2lvbjsKKwlnYm9vbGVhbiBpc19zc2w7CiAJZ3VpbnQgc3RhdHVzOwogCiAJaWYgKHR1bm5l bF9pdGVtLT5zdGF0ZSA9PSBTT1VQX01FU1NBR0VfUkVTVEFSVElORykgewpAQCAtMTYzMSw2ICsx NjM3LDEyIEBAIHR1bm5lbF9tZXNzYWdlX2NvbXBsZXRlZCAoU291cE1lc3NhZ2UgKm1zZywgZ3Bv aW50ZXIgdXNlcl9kYXRhKQogCQlyZXR1cm47CiAJfQogCisJZ19vYmplY3RfZ2V0IChHX09CSkVD VCAoaXRlbS0+Y29ubiksICJzc2wiLCAmaXNfc3NsLCBOVUxMKTsKKwlpZiAoIWlzX3NzbCkgewor CQl0dW5uZWxfY29tcGxldGUgKHR1bm5lbF9pdGVtLCBzdGF0dXMsIE5VTEwpOworCQlyZXR1cm47 CisJfQorCiAJaWYgKHR1bm5lbF9pdGVtLT5hc3luYykgewogCQlzb3VwX2Nvbm5lY3Rpb25fc3Rh cnRfc3NsX2FzeW5jIChpdGVtLT5jb25uLCBpdGVtLT5jYW5jZWxsYWJsZSwKIAkJCQkJCSB0dW5u ZWxfaGFuZHNoYWtlX2NvbXBsZXRlLApAQCAtMTkwMSwxMyArMTkxMywyMSBAQCBzb3VwX3Nlc3Np b25fcHJvY2Vzc19xdWV1ZV9pdGVtIChTb3VwU2Vzc2lvbiAgICAgICAgICAqc2Vzc2lvbiwKIAkJ CWJyZWFrOwogCiAJCWNhc2UgU09VUF9NRVNTQUdFX0NPTk5FQ1RFRDoKLQkJCWlmIChzb3VwX2Nv bm5lY3Rpb25faXNfdHVubmVsbGVkIChpdGVtLT5jb25uKSkKLQkJCQl0dW5uZWxfY29ubmVjdCAo aXRlbSk7Ci0JCQllbHNlCi0JCQkJaXRlbS0+c3RhdGUgPSBTT1VQX01FU1NBR0VfUkVBRFk7CisJ CQlpZiAoc291cF9jb25uZWN0aW9uX2lzX3ZpYV9wcm94eSAoaXRlbS0+Y29ubikpIHsKKwkJCQlp ZiAoaXRlbS0+Zm9yY2VfdHVubmVsIHx8IHNvdXBfY29ubmVjdGlvbl9pc190dW5uZWxsZWQgKGl0 ZW0tPmNvbm4pKSB7CisJCQkJCXR1bm5lbF9jb25uZWN0IChpdGVtKTsKKwkJCQkJYnJlYWs7CisJ CQkJfQorCQkJfQorCQkJaXRlbS0+c3RhdGUgPSBTT1VQX01FU1NBR0VfUkVBRFk7CiAJCQlicmVh azsKIAogCQljYXNlIFNPVVBfTUVTU0FHRV9SRUFEWToKKwkJCWlmIChpdGVtLT5mb3JjZV90dW5u ZWwpIHsKKwkJCQlpdGVtLT5zdGF0ZSA9IFNPVVBfTUVTU0FHRV9GSU5JU0hJTkc7CisJCQkJYnJl YWs7CisJCQl9CisKIAkJCWlmIChpdGVtLT5tc2ctPnN0YXR1c19jb2RlKSB7CiAJCQkJaWYgKGl0 ZW0tPm1zZy0+c3RhdHVzX2NvZGUgPT0gU09VUF9TVEFUVVNfVFJZX0FHQUlOKSB7CiAJCQkJCXNv dXBfbWVzc2FnZV9jbGVhbnVwX3Jlc3BvbnNlIChpdGVtLT5tc2cpOwpAQCAtMTk1NCw2ICsxOTc0 LDggQEAgc291cF9zZXNzaW9uX3Byb2Nlc3NfcXVldWVfaXRlbSAoU291cFNlc3Npb24gICAgICAg ICAgKnNlc3Npb24sCiAJCQl9CiAKIAkJCXNvdXBfbWVzc2FnZV9xdWV1ZV9pdGVtX3JlZiAoaXRl bSk7CisJCQlpZiAoaXRlbS0+Zm9yY2VfdHVubmVsKQorCQkJCWV4dHJhY3RfY29ubmVjdGlvbiAo c2Vzc2lvbiwgaXRlbSk7CiAJCQlzb3VwX3Nlc3Npb25fdW5xdWV1ZV9pdGVtIChzZXNzaW9uLCBp dGVtKTsKIAkJCWlmIChpdGVtLT5hc3luYyAmJiBpdGVtLT5jYWxsYmFjaykKIAkJCQlpdGVtLT5j YWxsYmFjayAoc2Vzc2lvbiwgaXRlbS0+bXNnLCBpdGVtLT5jYWxsYmFja19kYXRhKTsKQEAgLTQ1 NTYsMyArNDU3OCw5MSBAQCBzb3VwX3JlcXVlc3RfZXJyb3JfcXVhcmsgKHZvaWQpCiAJCWVycm9y ID0gZ19xdWFya19mcm9tX3N0YXRpY19zdHJpbmcgKCJzb3VwX3JlcXVlc3RfZXJyb3JfcXVhcmsi KTsKIAlyZXR1cm4gZXJyb3I7CiB9CisKK3ZvaWQgZXh0cmFjdF9jb25uZWN0aW9uIChTb3VwU2Vz c2lvbiAqc2Vzc2lvbiwgU291cE1lc3NhZ2VRdWV1ZUl0ZW0gKml0ZW0pIHsKKworCVNvdXBTb2Nr ZXQgKnNvY2s7CisJU291cFVSSSAqdXJpOworCVNvdXBTZXNzaW9uSG9zdCAqaG9zdDsKKwlHSU9T dHJlYW0gKmlvc3RyZWFtOworCUdFcnJvciAqZXJyb3I7CisJU291cENvbm5lY3Rpb24gKnNvdXBf Y29ubjsKKwlTb3VwU2Vzc2lvblByaXZhdGUgKnByaXY7CisKKwlzb3VwX2Nvbm4gPSBpdGVtLT5j b25uOworCWl0ZW0tPmNvbm4gPSBOVUxMOworCWVycm9yID0gKCFzb3VwX2Nvbm4gJiYgaXRlbS0+ ZXJyb3IpID8gZ19lcnJvcl9jb3B5KGl0ZW0tPmVycm9yKSA6IE5VTEw7CisJc291cF9zZXNzaW9u X3NldF9pdGVtX2Nvbm5lY3Rpb24gKHNlc3Npb24sIGl0ZW0sIE5VTEwpOworCisJaWYgKCFzb3Vw X2Nvbm4pIHsKKwkJZ190YXNrX3JldHVybl9lcnJvciAoaXRlbS0+dGFzaywgZXJyb3IpOworCQly ZXR1cm47CisJfQorCisJcHJpdiA9IFNPVVBfU0VTU0lPTl9HRVRfUFJJVkFURSAoc2Vzc2lvbik7 CisJdXJpID0gc291cF9tZXNzYWdlX2dldF91cmkgKGl0ZW0tPm1zZyk7CisJaG9zdCA9IGdldF9o b3N0X2Zvcl91cmkgKHNlc3Npb24sIHVyaSk7CisKKwlnX211dGV4X2xvY2sgKCZwcml2LT5jb25u X2xvY2spOworCWdfaGFzaF90YWJsZV9yZW1vdmUgKHByaXYtPmNvbm5zLCBzb3VwX2Nvbm4pOwor CWRyb3BfY29ubmVjdGlvbiAoc2Vzc2lvbiwgaG9zdCwgc291cF9jb25uKTsKKwlnX211dGV4X3Vu bG9jayAoJnByaXYtPmNvbm5fbG9jayk7CisKKwlzb2NrID0gc291cF9jb25uZWN0aW9uX2dldF9z b2NrZXQoc291cF9jb25uKTsKKwlnX29iamVjdF91bnJlZiAoc291cF9jb25uKTsKKworCWlvc3Ry ZWFtID0gc291cF9zb2NrZXRfZ2V0X2Nvbm5lY3Rpb24oc29jayk7CisJZ19vYmplY3RfcmVmIChp b3N0cmVhbSk7CisJZ19vYmplY3Rfc2V0IChHX09CSkVDVCAoc29jayksICJjbG9zZS1vbi1kaXNw b3NlIiwgRkFMU0UsIE5VTEwpOworCWdfb2JqZWN0X3VucmVmIChzb2NrKTsKKworCWdfdGFza19y ZXR1cm5fcG9pbnRlciAoaXRlbS0+dGFzaywgaW9zdHJlYW0sIGdfb2JqZWN0X3VucmVmKTsKK30K KworLyoqCisgKiBzb3VwX3Nlc3Npb25fY29ubmVjdF9maW5pc2g6CisgKiBAc2Vzc2lvbjogYSAj U291cFNlc3Npb24KKyAqIEByZXN1bHQ6IHRoZSAjR0FzeW5jUmVzdWx0IGZyb20gdGhlIGNvbm5l Y3Qgb3BlcmF0aW9uCisgKiBAdXNlcl9kYXRhOiBvdXRwYXJhbSBmb3IgcG9zc2libGUgZXJyb3Jz CisgKgorICogU2luY2U6IDIuNDYKKyAqLworR0lPU3RyZWFtKiBzb3VwX3Nlc3Npb25fY29ubmVj dF9maW5pc2ggKFNvdXBTZXNzaW9uICpzZXNzaW9uLAorCQkJICAgR0FzeW5jUmVzdWx0ICpyZXN1 bHQsCisJCQkgICBHRXJyb3IgKiplcnJvcikgeworCWdfcmV0dXJuX3ZhbF9pZl9mYWlsIChnX3Rh c2tfaXNfdmFsaWQgKHJlc3VsdCwgc2Vzc2lvbiksIE5VTEwpOworCXJldHVybiBnX3Rhc2tfcHJv cGFnYXRlX3BvaW50ZXIgKCBHX1RBU0sgKHJlc3VsdCksIGVycm9yKTsKK30KKworLyoqCisgKiBz b3VwX3Nlc3Npb25fY29ubmVjdF9hc3luYzoKKyAqIEBzZXNzaW9uOiBhICNTb3VwU2Vzc2lvbgor ICogQGRlc3RpbmF0aW9uOiBhICNTb3VwVVJJIHJlcHJlc2VudGluZyB0aGUgVVJJL2hvc3QgdG8g Y29ubmVjdCB0bworICogQGNhbGxiYWNrOiBhIGNhbGxiYWNrIHRvIGNhbGwgd2hlbiB0aGUgY29u bmVjdGlvbiBpcyBlc3RhYmxpc2hlZAorICogQHVzZXJfZGF0YTogZGF0YSBmb3IgQGNhbGxiYWNr CisgKgorICogU2V0cyB1cCBhICNTb3VwQ29ubmVjdGlvbiB0byB0aGUgQGRlc3RpbmF0aW9uIGFj Y29yZGluZyB0byB0aGUKKyAqIHVzdWFsICNTb3VwU2Vzc2lvbiBwcm9jZXNzIChpLmUuIGNvbXBs ZXRlIHdpdGggVExTIGFuZCBwcm94eQorICogc2V0dXApLiBUaGUgcmVzdWx0aW5nICNHSU9TdHJl YW0gaXMgdGhlbiBwYXNzZWQgdG8gdGhlIGNhbGxiYWNrCisgKiBhZnRlciB0aGUgYXNzb2NpYXRl ZCAjU291cENvbm5lY3Rpb24gYW5kICNTb3VwU29ja2V0IGFyZSBmcmVlZC4KKyAqCisgKiBTaW5j ZTogMi40NgorICovCit2b2lkIHNvdXBfc2Vzc2lvbl9jb25uZWN0X2FzeW5jIChTb3VwU2Vzc2lv biAqc2Vzc2lvbiwKKwkJCSAgIFNvdXBVUkkgKmRlc3RpbmF0aW9uLAorCQkJICAgR0FzeW5jUmVh ZHlDYWxsYmFjayBjYWxsYmFjaywKKwkJCSAgIGdwb2ludGVyIHVzZXJfZGF0YSkgeworCVNvdXBN ZXNzYWdlICptc2c7CisJU291cE1lc3NhZ2VRdWV1ZUl0ZW0gKml0ZW07CisKKwltc2cgPSBzb3Vw X21lc3NhZ2VfbmV3X2Zyb21fdXJpIChTT1VQX01FVEhPRF9IRUFELCBkZXN0aW5hdGlvbik7CisJ aXRlbSA9IHNvdXBfc2Vzc2lvbl9hcHBlbmRfcXVldWVfaXRlbSAoc2Vzc2lvbiwgbXNnLCBUUlVF LCBUUlVFLAorCQkJCQkgICAgICAgTlVMTCwgTlVMTCk7CisJc291cF9tZXNzYWdlX3F1ZXVlX2l0 ZW1fcmVmIChpdGVtKTsKKworCWl0ZW0tPm5ld19hcGkgPSBUUlVFOworCWl0ZW0tPmZvcmNlX3R1 bm5lbCA9IFRSVUU7CisJaXRlbS0+dGFzayA9IGdfdGFza19uZXcgKHNlc3Npb24sIE5VTEwsIGNh bGxiYWNrLCB1c2VyX2RhdGEpOworCWdfdGFza19zZXRfdGFza19kYXRhIChpdGVtLT50YXNrLCBp dGVtLCAoR0Rlc3Ryb3lOb3RpZnkpIHNvdXBfbWVzc2FnZV9xdWV1ZV9pdGVtX3VucmVmKTsKKwlz b3VwX3Nlc3Npb25fa2lja19xdWV1ZSAoc2Vzc2lvbik7Cit9CmRpZmYgLS1naXQgYS9saWJzb3Vw L3NvdXAtc2Vzc2lvbi5oIGIvbGlic291cC9zb3VwLXNlc3Npb24uaAppbmRleCA2N2E1OWVhLi45 MzNjY2E4IDEwMDY0NAotLS0gYS9saWJzb3VwL3NvdXAtc2Vzc2lvbi5oCisrKyBiL2xpYnNvdXAv c291cC1zZXNzaW9uLmgKQEAgLTE5OCw2ICsxOTgsMTUgQEAgU09VUF9BVkFJTEFCTEVfSU5fMl80 MgogR1F1YXJrIHNvdXBfcmVxdWVzdF9lcnJvcl9xdWFyayAodm9pZCk7CiAjZGVmaW5lIFNPVVBf UkVRVUVTVF9FUlJPUiBzb3VwX3JlcXVlc3RfZXJyb3JfcXVhcmsgKCkKIAordm9pZCBzb3VwX3Nl c3Npb25fY29ubmVjdF9hc3luYyAoU291cFNlc3Npb24gKnNlc3Npb24sCisJCQkJCQlTb3VwVVJJ CQkJCQkqZGVzdGluYXRpb24sCisJCQkJCQlHQXN5bmNSZWFkeUNhbGxiYWNrCQljYWxsYmFjaywK KwkJCQkJCWdwb2ludGVyCQkJCXVzZXJfZGF0YSk7CisKK0dJT1N0cmVhbSogc291cF9zZXNzaW9u X2Nvbm5lY3RfZmluaXNoIChTb3VwU2Vzc2lvbiAqc2Vzc2lvbiwKKwkJCQkJICAgIEdBc3luY1Jl c3VsdAkJICAgICAqcmVzdWx0LAorCQkJCQkgICAgR0Vycm9yCQkJCSAgICAqKmVycm9yKTsKKwog dHlwZWRlZiBlbnVtIHsKIAlTT1VQX1JFUVVFU1RfRVJST1JfQkFEX1VSSSwKIAlTT1VQX1JFUVVF U1RfRVJST1JfVU5TVVBQT1JURURfVVJJX1NDSEVNRSwKCg== 330537 2018-01-05 00:15:53 -0800 2018-01-08 04:28:46 -0800 Patch wk-websockets.diff text/plain 10130 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBiNDZiNGUwZjRjMi4uMjBmZTE0ZjM0MDkgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyMSBAQAorMjAxOC0wMS0wNSAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGln YWxpYS5jb20+CisKKyAgICAgICAgW1NPVVBdIFdlYlNvY2tldHMgbXVzdCB1c2Ugc3lzdGVtIHBy b3h5IHNldHRpbmdzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xMjYzODQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBVc2Ugc291cF9zZXNzaW9uX2Nvbm5lY3RfYXN5bmMoKSB3aGVuIGF2YWlsYWJsZSB0byBj cmVhdGUgdGhlIFdlYlNvY2tldHMgY29ubmVjdGlvbiBpbnN0ZWFkIG9mIEdTb2NrZXRDbGllbnQK KyAgICAgICAgZGlyZWN0bHkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL3NvdXAvU29j a2V0U3RyZWFtSGFuZGxlSW1wbC5oOgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9T b2NrZXRTdHJlYW1IYW5kbGVJbXBsU291cC5jcHA6CisgICAgICAgIChXZWJDb3JlOjp3c3NTb2Nr ZXRDbGllbnRFdmVudENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhh bmRsZUltcGw6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGVJ bXBsOjpjb25uZWN0ZWQpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxlSW1w bDo6Y29ubmVjdGVkQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFu ZGxlSW1wbDo6cGxhdGZvcm1DbG9zZSk6CisKIDIwMTgtMDEtMDQgIERldmluIFJvdXNzbyAgPHdl YmtpdEBkZXZpbnJvdXNzby5jb20+CiAKICAgICAgICAgV2ViIEluc3BlY3RvcjogcmVwbGFjZSBI VE1MQ2FudmFzRWxlbWVudCB3aXRoIENhbnZhc1JlbmRlcmluZ0NvbnRleHQgZm9yIGluc3RydW1l bnRhdGlvbiBsb2dpYwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9zb3VwL1NvY2tldFN0cmVhbUhhbmRsZUltcGwuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsvc291cC9Tb2NrZXRTdHJlYW1IYW5kbGVJbXBsLmgKaW5kZXggNTc0NDhiZWE4MjYu LmUwYThmOWQ0MmEzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L3NvdXAvU29ja2V0U3RyZWFtSGFuZGxlSW1wbC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvc291cC9Tb2NrZXRTdHJlYW1IYW5kbGVJbXBsLmgKQEAgLTQ4LDggKzQ4LDYg QEAgY2xhc3MgU29ja2V0U3RyZWFtSGFuZGxlQ2xpZW50OwogY2xhc3MgU29ja2V0U3RyZWFtSGFu ZGxlSW1wbCBmaW5hbCA6IHB1YmxpYyBTb2NrZXRTdHJlYW1IYW5kbGUgewogcHVibGljOgogICAg IHN0YXRpYyBSZWY8U29ja2V0U3RyZWFtSGFuZGxlSW1wbD4gY3JlYXRlKGNvbnN0IFVSTCYsIFNv Y2tldFN0cmVhbUhhbmRsZUNsaWVudCYsIFBBTDo6U2Vzc2lvbklELCBjb25zdCBTdHJpbmcmLCBT b3VyY2VBcHBsaWNhdGlvbkF1ZGl0VG9rZW4mJik7Ci0gICAgc3RhdGljIFJlZjxTb2NrZXRTdHJl YW1IYW5kbGU+IGNyZWF0ZShHU29ja2V0Q29ubmVjdGlvbiosIFNvY2tldFN0cmVhbUhhbmRsZUNs aWVudCYpOwotCiAgICAgdmlydHVhbCB+U29ja2V0U3RyZWFtSGFuZGxlSW1wbCgpOwogCiAgICAg dm9pZCBwbGF0Zm9ybVNlbmQoY29uc3QgY2hhciogZGF0YSwgc2l6ZV90IGxlbmd0aCwgRnVuY3Rp b248dm9pZChib29sKT4mJikgZmluYWw7CkBAIC02NCwxNiArNjIsMTYgQEAgcHJpdmF0ZToKICAg ICB2b2lkIGJlZ2luV2FpdGluZ0ZvclNvY2tldFdyaXRhYmlsaXR5KCk7CiAgICAgdm9pZCBzdG9w V2FpdGluZ0ZvclNvY2tldFdyaXRhYmlsaXR5KCk7CiAKLSAgICBzdGF0aWMgdm9pZCBjb25uZWN0 ZWRDYWxsYmFjayhHU29ja2V0Q2xpZW50KiwgR0FzeW5jUmVzdWx0KiwgU29ja2V0U3RyZWFtSGFu ZGxlSW1wbCopOworICAgIHN0YXRpYyB2b2lkIGNvbm5lY3RlZENhbGxiYWNrKEdPYmplY3QqLCBH QXN5bmNSZXN1bHQqLCBTb2NrZXRTdHJlYW1IYW5kbGVJbXBsKik7CiAgICAgc3RhdGljIHZvaWQg cmVhZFJlYWR5Q2FsbGJhY2soR0lucHV0U3RyZWFtKiwgR0FzeW5jUmVzdWx0KiwgU29ja2V0U3Ry ZWFtSGFuZGxlSW1wbCopOwogICAgIHN0YXRpYyBnYm9vbGVhbiB3cml0ZVJlYWR5Q2FsbGJhY2so R1BvbGxhYmxlT3V0cHV0U3RyZWFtKiwgU29ja2V0U3RyZWFtSGFuZGxlSW1wbCopOwogCi0gICAg dm9pZCBjb25uZWN0ZWQoR1JlZlB0cjxHU29ja2V0Q29ubmVjdGlvbj4mJik7CisgICAgdm9pZCBj b25uZWN0ZWQoR1JlZlB0cjxHSU9TdHJlYW0+JiYpOwogICAgIHZvaWQgcmVhZEJ5dGVzKGdzc2l6 ZSk7CiAgICAgdm9pZCBkaWRGYWlsKFNvY2tldFN0cmVhbUVycm9yJiYpOwogICAgIHZvaWQgd3Jp dGVSZWFkeSgpOwogCi0gICAgR1JlZlB0cjxHU29ja2V0Q29ubmVjdGlvbj4gbV9zb2NrZXRDb25u ZWN0aW9uOworICAgIEdSZWZQdHI8R0lPU3RyZWFtPiBtX3N0cmVhbTsKICAgICBHUmVmUHRyPEdJ bnB1dFN0cmVhbT4gbV9pbnB1dFN0cmVhbTsKICAgICBHUmVmUHRyPEdQb2xsYWJsZU91dHB1dFN0 cmVhbT4gbV9vdXRwdXRTdHJlYW07CiAgICAgR1JlZlB0cjxHU291cmNlPiBtX3dyaXRlUmVhZHlT b3VyY2U7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAv U29ja2V0U3RyZWFtSGFuZGxlSW1wbFNvdXAuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v bmV0d29yay9zb3VwL1NvY2tldFN0cmVhbUhhbmRsZUltcGxTb3VwLmNwcAppbmRleCAzMzc3M2Mz MjBiYS4uNmMyNTBmNDU4YTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25l dHdvcmsvc291cC9Tb2NrZXRTdHJlYW1IYW5kbGVJbXBsU291cC5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1NvY2tldFN0cmVhbUhhbmRsZUltcGxTb3VwLmNw cApAQCAtNTUsNiArNTUsMTUgQEAgc3RhdGljIGdib29sZWFuIHdzc0Nvbm5lY3Rpb25BY2NlcHRD ZXJ0aWZpY2F0ZUNhbGxiYWNrKEdUbHNDb25uZWN0aW9uKiwgR1Rsc0NlcnQKICAgICByZXR1cm4g VFJVRTsKIH0KIAorI2lmIFNPVVBfQ0hFQ0tfVkVSU0lPTigyLCA2MSwgMikKK3N0YXRpYyB2b2lk IHdzc1NvY2tldENsaWVudEV2ZW50Q2FsbGJhY2soU291cFNlc3Npb24qLCBHU29ja2V0Q2xpZW50 RXZlbnQgZXZlbnQsIEdJT1N0cmVhbSogY29ubmVjdGlvbikKK3sKKyAgICBpZiAoZXZlbnQgIT0g R19TT0NLRVRfQ0xJRU5UX1RMU19IQU5EU0hBS0lORykKKyAgICAgICAgcmV0dXJuOworCisgICAg Z19zaWduYWxfY29ubmVjdChjb25uZWN0aW9uLCAiYWNjZXB0LWNlcnRpZmljYXRlIiwgR19DQUxM QkFDSyh3c3NDb25uZWN0aW9uQWNjZXB0Q2VydGlmaWNhdGVDYWxsYmFjayksIG51bGxwdHIpOwor fQorI2Vsc2UKIHN0YXRpYyB2b2lkIHdzc1NvY2tldENsaWVudEV2ZW50Q2FsbGJhY2soR1NvY2tl dENsaWVudCosIEdTb2NrZXRDbGllbnRFdmVudCBldmVudCwgR1NvY2tldENvbm5lY3RhYmxlKiwg R0lPU3RyZWFtKiBjb25uZWN0aW9uKQogewogICAgIGlmIChldmVudCAhPSBHX1NPQ0tFVF9DTElF TlRfVExTX0hBTkRTSEFLSU5HKQpAQCAtNjIsMzIgKzcxLDQwIEBAIHN0YXRpYyB2b2lkIHdzc1Nv Y2tldENsaWVudEV2ZW50Q2FsbGJhY2soR1NvY2tldENsaWVudCosIEdTb2NrZXRDbGllbnRFdmVu dCBldmVuCiAKICAgICBnX3NpZ25hbF9jb25uZWN0KGNvbm5lY3Rpb24sICJhY2NlcHQtY2VydGlm aWNhdGUiLCBHX0NBTExCQUNLKHdzc0Nvbm5lY3Rpb25BY2NlcHRDZXJ0aWZpY2F0ZUNhbGxiYWNr KSwgbnVsbHB0cik7CiB9CisjZW5kaWYKIAotUmVmPFNvY2tldFN0cmVhbUhhbmRsZUltcGw+IFNv Y2tldFN0cmVhbUhhbmRsZUltcGw6OmNyZWF0ZShjb25zdCBVUkwmIHVybCwgU29ja2V0U3RyZWFt SGFuZGxlQ2xpZW50JiBjbGllbnQsIFBBTDo6U2Vzc2lvbklELCBjb25zdCBTdHJpbmcmLCBTb3Vy Y2VBcHBsaWNhdGlvbkF1ZGl0VG9rZW4mJikKK1JlZjxTb2NrZXRTdHJlYW1IYW5kbGVJbXBsPiBT b2NrZXRTdHJlYW1IYW5kbGVJbXBsOjpjcmVhdGUoY29uc3QgVVJMJiB1cmwsIFNvY2tldFN0cmVh bUhhbmRsZUNsaWVudCYgY2xpZW50LCBQQUw6OlNlc3Npb25JRCBzZXNzaW9uSUQsIGNvbnN0IFN0 cmluZyYsIFNvdXJjZUFwcGxpY2F0aW9uQXVkaXRUb2tlbiYmKQogewogICAgIFJlZjxTb2NrZXRT dHJlYW1IYW5kbGVJbXBsPiBzb2NrZXQgPSBhZG9wdFJlZigqbmV3IFNvY2tldFN0cmVhbUhhbmRs ZUltcGwodXJsLCBjbGllbnQpKTsKIAorICAgIC8vIEZJWE1FOiBVc2luZyBEZXByZWNhdGVkR2xv YmFsU2V0dGluZ3MgZnJvbSBoZXJlIGlzIGEgbGF5ZXJpbmcgdmlvbGF0aW9uLgorICAgIGJvb2wg YWxsb3dzQW55U1NMQ2VydGlmaWNhdGUgPSB1cmwucHJvdG9jb2xJcygid3NzIikgJiYgRGVwcmVj YXRlZEdsb2JhbFNldHRpbmdzOjphbGxvd3NBbnlTU0xDZXJ0aWZpY2F0ZSgpOworCisjaWYgU09V UF9DSEVDS19WRVJTSU9OKDIsIDYxLCAyKQorICAgIGF1dG8qIG5ldHdvcmtTdG9yYWdlU2Vzc2lv biA9IE5ldHdvcmtTdG9yYWdlU2Vzc2lvbjo6c3RvcmFnZVNlc3Npb24oc2Vzc2lvbklEKTsKKyAg ICBpZiAoIW5ldHdvcmtTdG9yYWdlU2Vzc2lvbikKKyAgICAgICAgcmV0dXJuIHNvY2tldDsKKwor ICAgIGF1dG8gdXJpID0gdXJsLmNyZWF0ZVNvdXBVUkkoKTsKKyAgICBSZWY8U29ja2V0U3RyZWFt SGFuZGxlPiBwcm90ZWN0ZWRTb2NrZXRTdHJlYW1IYW5kbGUgPSBzb2NrZXQuY29weVJlZigpOwor ICAgIHNvdXBfc2Vzc2lvbl9jb25uZWN0X2FzeW5jKG5ldHdvcmtTdG9yYWdlU2Vzc2lvbi0+Z2V0 T3JDcmVhdGVTb3VwTmV0d29ya1Nlc3Npb24oKS5zb3VwU2Vzc2lvbigpLCB1cmkuZ2V0KCksIHNv Y2tldC0+bV9jYW5jZWxsYWJsZS5nZXQoKSwKKyAgICAgICAgYWxsb3dzQW55U1NMQ2VydGlmaWNh dGUgPyByZWludGVycHJldF9jYXN0PFNvdXBTZXNzaW9uQ29ubmVjdFByb2dyZXNzQ2FsbGJhY2s+ KHdzc1NvY2tldENsaWVudEV2ZW50Q2FsbGJhY2spIDogbnVsbHB0ciwKKyAgICAgICAgcmVpbnRl cnByZXRfY2FzdDxHQXN5bmNSZWFkeUNhbGxiYWNrPihjb25uZWN0ZWRDYWxsYmFjayksICZwcm90 ZWN0ZWRTb2NrZXRTdHJlYW1IYW5kbGUubGVha1JlZigpKTsKKyNlbHNlCisgICAgVU5VU0VEX1BB UkFNKHNlc3Npb25JRCk7CiAgICAgdW5zaWduZWQgcG9ydCA9IHVybC5wb3J0KCkgPyB1cmwucG9y dCgpLnZhbHVlKCkgOiAodXJsLnByb3RvY29sSXMoIndzcyIpID8gNDQzIDogODApOwogICAgIEdS ZWZQdHI8R1NvY2tldENsaWVudD4gc29ja2V0Q2xpZW50ID0gYWRvcHRHUmVmKGdfc29ja2V0X2Ns aWVudF9uZXcoKSk7CiAgICAgaWYgKHVybC5wcm90b2NvbElzKCJ3c3MiKSkgewogICAgICAgICBn X3NvY2tldF9jbGllbnRfc2V0X3Rscyhzb2NrZXRDbGllbnQuZ2V0KCksIFRSVUUpOwotICAgICAg ICAvLyBGSVhNRTogVXNpbmcgRGVwcmVjYXRlZEdsb2JhbFNldHRpbmdzIGZyb20gaGVyZSBpcyBh IGxheWVyaW5nIHZpb2xhdGlvbi4KLSAgICAgICAgaWYgKERlcHJlY2F0ZWRHbG9iYWxTZXR0aW5n czo6YWxsb3dzQW55U1NMQ2VydGlmaWNhdGUoKSkKKyAgICAgICAgaWYgKGFsbG93c0FueVNTTENl cnRpZmljYXRlKQogICAgICAgICAgICAgZ19zaWduYWxfY29ubmVjdChzb2NrZXRDbGllbnQuZ2V0 KCksICJldmVudCIsIEdfQ0FMTEJBQ0sod3NzU29ja2V0Q2xpZW50RXZlbnRDYWxsYmFjayksIG51 bGxwdHIpOwogICAgIH0KICAgICBSZWY8U29ja2V0U3RyZWFtSGFuZGxlPiBwcm90ZWN0ZWRTb2Nr ZXRTdHJlYW1IYW5kbGUgPSBzb2NrZXQuY29weVJlZigpOwogICAgIGdfc29ja2V0X2NsaWVudF9j b25uZWN0X3RvX2hvc3RfYXN5bmMoc29ja2V0Q2xpZW50LmdldCgpLCB1cmwuaG9zdCgpLnV0Zjgo KS5kYXRhKCksIHBvcnQsIHNvY2tldC0+bV9jYW5jZWxsYWJsZS5nZXQoKSwKICAgICAgICAgcmVp bnRlcnByZXRfY2FzdDxHQXN5bmNSZWFkeUNhbGxiYWNrPihjb25uZWN0ZWRDYWxsYmFjayksICZw cm90ZWN0ZWRTb2NrZXRTdHJlYW1IYW5kbGUubGVha1JlZigpKTsKLSAgICByZXR1cm4gc29ja2V0 OwotfQotCi1SZWY8U29ja2V0U3RyZWFtSGFuZGxlPiBTb2NrZXRTdHJlYW1IYW5kbGVJbXBsOjpj cmVhdGUoR1NvY2tldENvbm5lY3Rpb24qIHNvY2tldENvbm5lY3Rpb24sIFNvY2tldFN0cmVhbUhh bmRsZUNsaWVudCYgY2xpZW50KQotewotICAgIFJlZjxTb2NrZXRTdHJlYW1IYW5kbGVJbXBsPiBz b2NrZXQgPSBhZG9wdFJlZigqbmV3IFNvY2tldFN0cmVhbUhhbmRsZUltcGwoVVJMKCksIGNsaWVu dCkpOworI2VuZGlmCiAKLSAgICBHUmVmUHRyPEdTb2NrZXRDb25uZWN0aW9uPiBjb25uZWN0aW9u ID0gc29ja2V0Q29ubmVjdGlvbjsKLSAgICBzb2NrZXQtPmNvbm5lY3RlZChXVEZNb3ZlKGNvbm5l Y3Rpb24pKTsKLSAgICByZXR1cm4gV1RGTW92ZShzb2NrZXQpOworICAgIHJldHVybiBzb2NrZXQ7 CiB9CiAKIFNvY2tldFN0cmVhbUhhbmRsZUltcGw6OlNvY2tldFN0cmVhbUhhbmRsZUltcGwoY29u c3QgVVJMJiB1cmwsIFNvY2tldFN0cmVhbUhhbmRsZUNsaWVudCYgY2xpZW50KQpAQCAtMTAyLDEx ICsxMTksMTEgQEAgU29ja2V0U3RyZWFtSGFuZGxlSW1wbDo6flNvY2tldFN0cmVhbUhhbmRsZUlt cGwoKQogICAgIExPRyhOZXR3b3JrLCAiU29ja2V0U3RyZWFtSGFuZGxlICVwIGRlbGV0ZSIsIHRo aXMpOwogfQogCi12b2lkIFNvY2tldFN0cmVhbUhhbmRsZUltcGw6OmNvbm5lY3RlZChHUmVmUHRy PEdTb2NrZXRDb25uZWN0aW9uPiYmIHNvY2tldENvbm5lY3Rpb24pCit2b2lkIFNvY2tldFN0cmVh bUhhbmRsZUltcGw6OmNvbm5lY3RlZChHUmVmUHRyPEdJT1N0cmVhbT4mJiBzdHJlYW0pCiB7Ci0g ICAgbV9zb2NrZXRDb25uZWN0aW9uID0gV1RGTW92ZShzb2NrZXRDb25uZWN0aW9uKTsKLSAgICBt X291dHB1dFN0cmVhbSA9IEdfUE9MTEFCTEVfT1VUUFVUX1NUUkVBTShnX2lvX3N0cmVhbV9nZXRf b3V0cHV0X3N0cmVhbShHX0lPX1NUUkVBTShtX3NvY2tldENvbm5lY3Rpb24uZ2V0KCkpKSk7Ci0g ICAgbV9pbnB1dFN0cmVhbSA9IGdfaW9fc3RyZWFtX2dldF9pbnB1dF9zdHJlYW0oR19JT19TVFJF QU0obV9zb2NrZXRDb25uZWN0aW9uLmdldCgpKSk7CisgICAgbV9zdHJlYW0gPSBXVEZNb3ZlKHN0 cmVhbSk7CisgICAgbV9vdXRwdXRTdHJlYW0gPSBHX1BPTExBQkxFX09VVFBVVF9TVFJFQU0oZ19p b19zdHJlYW1fZ2V0X291dHB1dF9zdHJlYW0obV9zdHJlYW0uZ2V0KCkpKTsKKyAgICBtX2lucHV0 U3RyZWFtID0gZ19pb19zdHJlYW1fZ2V0X2lucHV0X3N0cmVhbShtX3N0cmVhbS5nZXQoKSk7CiAg ICAgbV9yZWFkQnVmZmVyID0gc3RkOjptYWtlX3VuaXF1ZTxjaGFyW10+KFJFQURfQlVGRkVSX1NJ WkUpOwogCiAgICAgUmVmUHRyPFNvY2tldFN0cmVhbUhhbmRsZUltcGw+IHByb3RlY3RlZFRoaXMo dGhpcyk7CkBAIC0xMTcsMjUgKzEzNCwyOSBAQCB2b2lkIFNvY2tldFN0cmVhbUhhbmRsZUltcGw6 OmNvbm5lY3RlZChHUmVmUHRyPEdTb2NrZXRDb25uZWN0aW9uPiYmIHNvY2tldENvbm5lYwogICAg IG1fY2xpZW50LmRpZE9wZW5Tb2NrZXRTdHJlYW0oKnRoaXMpOwogfQogCi12b2lkIFNvY2tldFN0 cmVhbUhhbmRsZUltcGw6OmNvbm5lY3RlZENhbGxiYWNrKEdTb2NrZXRDbGllbnQqIGNsaWVudCwg R0FzeW5jUmVzdWx0KiByZXN1bHQsIFNvY2tldFN0cmVhbUhhbmRsZUltcGwqIGhhbmRsZSkKK3Zv aWQgU29ja2V0U3RyZWFtSGFuZGxlSW1wbDo6Y29ubmVjdGVkQ2FsbGJhY2soR09iamVjdCogb2Jq ZWN0LCBHQXN5bmNSZXN1bHQqIHJlc3VsdCwgU29ja2V0U3RyZWFtSGFuZGxlSW1wbCogaGFuZGxl KQogewogICAgIFJlZlB0cjxTb2NrZXRTdHJlYW1IYW5kbGU+IHByb3RlY3RlZFRoaXMgPSBhZG9w dFJlZihoYW5kbGUpOwogCiAgICAgLy8gQWx3YXlzIGZpbmlzaCB0aGUgY29ubmVjdGlvbiwgZXZl biBpZiB0aGlzIFNvY2tldFN0cmVhbUhhbmRsZSB3YXMgY2FuY2VsbGVkIGVhcmxpZXIuCiAgICAg R1VuaXF1ZU91dFB0cjxHRXJyb3I+IGVycm9yOwotICAgIEdSZWZQdHI8R1NvY2tldENvbm5lY3Rp b24+IHNvY2tldENvbm5lY3Rpb24gPSBhZG9wdEdSZWYoZ19zb2NrZXRfY2xpZW50X2Nvbm5lY3Rf dG9faG9zdF9maW5pc2goY2xpZW50LCByZXN1bHQsICZlcnJvci5vdXRQdHIoKSkpOworI2lmIFNP VVBfQ0hFQ0tfVkVSU0lPTigyLCA2MSwgMikKKyAgICBHUmVmUHRyPEdJT1N0cmVhbT4gc3RyZWFt ID0gYWRvcHRHUmVmKHNvdXBfc2Vzc2lvbl9jb25uZWN0X2ZpbmlzaChTT1VQX1NFU1NJT04ob2Jq ZWN0KSwgcmVzdWx0LCAmZXJyb3Iub3V0UHRyKCkpKTsKKyNlbHNlCisgICAgR1JlZlB0cjxHSU9T dHJlYW0+IHN0cmVhbSA9IGFkb3B0R1JlZihHX0lPX1NUUkVBTShnX3NvY2tldF9jbGllbnRfY29u bmVjdF90b19ob3N0X2ZpbmlzaChHX1NPQ0tFVF9DTElFTlQob2JqZWN0KSwgcmVzdWx0LCAmZXJy b3Iub3V0UHRyKCkpKSk7CisjZW5kaWYKIAogICAgIC8vIFRoZSBTb2NrZXRTdHJlYW1IYW5kbGUg aGFzIGJlZW4gY2FuY2VsbGVkLCBzbyBqdXN0IGNsb3NlIHRoZSBjb25uZWN0aW9uLCBpZ25vcmlu ZyBlcnJvcnMuCiAgICAgaWYgKGdfY2FuY2VsbGFibGVfaXNfY2FuY2VsbGVkKGhhbmRsZS0+bV9j YW5jZWxsYWJsZS5nZXQoKSkpIHsKLSAgICAgICAgaWYgKHNvY2tldENvbm5lY3Rpb24pCi0gICAg ICAgICAgICBnX2lvX3N0cmVhbV9jbG9zZShHX0lPX1NUUkVBTShzb2NrZXRDb25uZWN0aW9uLmdl dCgpKSwgbnVsbHB0ciwgbnVsbHB0cik7CisgICAgICAgIGlmIChzdHJlYW0pCisgICAgICAgICAg ICBnX2lvX3N0cmVhbV9jbG9zZShzdHJlYW0uZ2V0KCksIG51bGxwdHIsIG51bGxwdHIpOwogICAg ICAgICByZXR1cm47CiAgICAgfQogCiAgICAgaWYgKGVycm9yKQotICAgICAgICBoYW5kbGUtPmRp ZEZhaWwoU29ja2V0U3RyZWFtRXJyb3IoZXJyb3ItPmNvZGUsIFN0cmluZygpLCBlcnJvci0+bWVz c2FnZSkpOworICAgICAgICBoYW5kbGUtPmRpZEZhaWwoU29ja2V0U3RyZWFtRXJyb3IoZXJyb3It PmNvZGUsIHsgfSwgZXJyb3ItPm1lc3NhZ2UpKTsKICAgICBlbHNlCi0gICAgICAgIGhhbmRsZS0+ Y29ubmVjdGVkKFdURk1vdmUoc29ja2V0Q29ubmVjdGlvbikpOworICAgICAgICBoYW5kbGUtPmNv bm5lY3RlZChXVEZNb3ZlKHN0cmVhbSkpOwogfQogCiB2b2lkIFNvY2tldFN0cmVhbUhhbmRsZUlt cGw6OnJlYWRCeXRlcyhnc3NpemUgYnl0ZXNSZWFkKQpAQCAtMjI1LDEyICsyNDYsMTIgQEAgdm9p ZCBTb2NrZXRTdHJlYW1IYW5kbGVJbXBsOjpwbGF0Zm9ybUNsb3NlKCkKICAgICBnX2NhbmNlbGxh YmxlX2NhbmNlbChtX2NhbmNlbGxhYmxlLmdldCgpKTsKICAgICBzdG9wV2FpdGluZ0ZvclNvY2tl dFdyaXRhYmlsaXR5KCk7CiAKLSAgICBpZiAobV9zb2NrZXRDb25uZWN0aW9uKSB7CisgICAgaWYg KG1fc3RyZWFtKSB7CiAgICAgICAgIEdVbmlxdWVPdXRQdHI8R0Vycm9yPiBlcnJvcjsKLSAgICAg ICAgZ19pb19zdHJlYW1fY2xvc2UoR19JT19TVFJFQU0obV9zb2NrZXRDb25uZWN0aW9uLmdldCgp KSwgbnVsbHB0ciwgJmVycm9yLm91dFB0cigpKTsKKyAgICAgICAgZ19pb19zdHJlYW1fY2xvc2Uo bV9zdHJlYW0uZ2V0KCksIG51bGxwdHIsICZlcnJvci5vdXRQdHIoKSk7CiAgICAgICAgIGlmIChl cnJvcikKLSAgICAgICAgICAgIGRpZEZhaWwoU29ja2V0U3RyZWFtRXJyb3IoZXJyb3ItPmNvZGUs IFN0cmluZygpLCBlcnJvci0+bWVzc2FnZSkpOwotICAgICAgICBtX3NvY2tldENvbm5lY3Rpb24g PSBudWxscHRyOworICAgICAgICAgICAgZGlkRmFpbChTb2NrZXRTdHJlYW1FcnJvcihlcnJvci0+ Y29kZSwgeyB9LCBlcnJvci0+bWVzc2FnZSkpOworICAgICAgICBtX3N0cmVhbSA9IG51bGxwdHI7 CiAgICAgfQogCiAgICAgbV9vdXRwdXRTdHJlYW0gPSBudWxscHRyOwo= 330682 2018-01-08 04:28:46 -0800 2018-01-08 09:19:41 -0800 Patch with unit tests wcore-websockets-proxy.diff text/plain 19967 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA1YzM0YTExZWY0NS4uOTg0OTk4YzliN2QgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyMSBAQAorMjAxOC0wMS0wOCAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGln YWxpYS5jb20+CisKKyAgICAgICAgW1NPVVBdIFdlYlNvY2tldHMgbXVzdCB1c2Ugc3lzdGVtIHBy b3h5IHNldHRpbmdzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xMjYzODQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBVc2Ugc291cF9zZXNzaW9uX2Nvbm5lY3RfYXN5bmMoKSB3aGVuIGF2YWlsYWJsZSB0byBj cmVhdGUgdGhlIFdlYlNvY2tldHMgY29ubmVjdGlvbiBpbnN0ZWFkIG9mIEdTb2NrZXRDbGllbnQK KyAgICAgICAgZGlyZWN0bHkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL3NvdXAvU29j a2V0U3RyZWFtSGFuZGxlSW1wbC5oOgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9T b2NrZXRTdHJlYW1IYW5kbGVJbXBsU291cC5jcHA6CisgICAgICAgIChXZWJDb3JlOjp3c3NTb2Nr ZXRDbGllbnRFdmVudENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhh bmRsZUltcGw6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGVJ bXBsOjpjb25uZWN0ZWQpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxlSW1w bDo6Y29ubmVjdGVkQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFu ZGxlSW1wbDo6cGxhdGZvcm1DbG9zZSk6CisKIDIwMTgtMDEtMDggIFphbiBEb2JlcnNlayAgPHpk b2JlcnNla0BpZ2FsaWEuY29tPiBhbmQgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGln YWxpYS5jb20+CiAKICAgICAgICAgW0dTdHJlYW1lcl0gdXNlIEZhc3RNYWxsb2MtYmFzZWQgR3N0 QWxsb2NhdG9yCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3Nv dXAvU29ja2V0U3RyZWFtSGFuZGxlSW1wbC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9zb3VwL1NvY2tldFN0cmVhbUhhbmRsZUltcGwuaAppbmRleCA1NzQ0OGJlYTgyNi4uZTBh OGY5ZDQyYTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291 cC9Tb2NrZXRTdHJlYW1IYW5kbGVJbXBsLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v bmV0d29yay9zb3VwL1NvY2tldFN0cmVhbUhhbmRsZUltcGwuaApAQCAtNDgsOCArNDgsNiBAQCBj bGFzcyBTb2NrZXRTdHJlYW1IYW5kbGVDbGllbnQ7CiBjbGFzcyBTb2NrZXRTdHJlYW1IYW5kbGVJ bXBsIGZpbmFsIDogcHVibGljIFNvY2tldFN0cmVhbUhhbmRsZSB7CiBwdWJsaWM6CiAgICAgc3Rh dGljIFJlZjxTb2NrZXRTdHJlYW1IYW5kbGVJbXBsPiBjcmVhdGUoY29uc3QgVVJMJiwgU29ja2V0 U3RyZWFtSGFuZGxlQ2xpZW50JiwgUEFMOjpTZXNzaW9uSUQsIGNvbnN0IFN0cmluZyYsIFNvdXJj ZUFwcGxpY2F0aW9uQXVkaXRUb2tlbiYmKTsKLSAgICBzdGF0aWMgUmVmPFNvY2tldFN0cmVhbUhh bmRsZT4gY3JlYXRlKEdTb2NrZXRDb25uZWN0aW9uKiwgU29ja2V0U3RyZWFtSGFuZGxlQ2xpZW50 Jik7Ci0KICAgICB2aXJ0dWFsIH5Tb2NrZXRTdHJlYW1IYW5kbGVJbXBsKCk7CiAKICAgICB2b2lk IHBsYXRmb3JtU2VuZChjb25zdCBjaGFyKiBkYXRhLCBzaXplX3QgbGVuZ3RoLCBGdW5jdGlvbjx2 b2lkKGJvb2wpPiYmKSBmaW5hbDsKQEAgLTY0LDE2ICs2MiwxNiBAQCBwcml2YXRlOgogICAgIHZv aWQgYmVnaW5XYWl0aW5nRm9yU29ja2V0V3JpdGFiaWxpdHkoKTsKICAgICB2b2lkIHN0b3BXYWl0 aW5nRm9yU29ja2V0V3JpdGFiaWxpdHkoKTsKIAotICAgIHN0YXRpYyB2b2lkIGNvbm5lY3RlZENh bGxiYWNrKEdTb2NrZXRDbGllbnQqLCBHQXN5bmNSZXN1bHQqLCBTb2NrZXRTdHJlYW1IYW5kbGVJ bXBsKik7CisgICAgc3RhdGljIHZvaWQgY29ubmVjdGVkQ2FsbGJhY2soR09iamVjdCosIEdBc3lu Y1Jlc3VsdCosIFNvY2tldFN0cmVhbUhhbmRsZUltcGwqKTsKICAgICBzdGF0aWMgdm9pZCByZWFk UmVhZHlDYWxsYmFjayhHSW5wdXRTdHJlYW0qLCBHQXN5bmNSZXN1bHQqLCBTb2NrZXRTdHJlYW1I YW5kbGVJbXBsKik7CiAgICAgc3RhdGljIGdib29sZWFuIHdyaXRlUmVhZHlDYWxsYmFjayhHUG9s bGFibGVPdXRwdXRTdHJlYW0qLCBTb2NrZXRTdHJlYW1IYW5kbGVJbXBsKik7CiAKLSAgICB2b2lk IGNvbm5lY3RlZChHUmVmUHRyPEdTb2NrZXRDb25uZWN0aW9uPiYmKTsKKyAgICB2b2lkIGNvbm5l Y3RlZChHUmVmUHRyPEdJT1N0cmVhbT4mJik7CiAgICAgdm9pZCByZWFkQnl0ZXMoZ3NzaXplKTsK ICAgICB2b2lkIGRpZEZhaWwoU29ja2V0U3RyZWFtRXJyb3ImJik7CiAgICAgdm9pZCB3cml0ZVJl YWR5KCk7CiAKLSAgICBHUmVmUHRyPEdTb2NrZXRDb25uZWN0aW9uPiBtX3NvY2tldENvbm5lY3Rp b247CisgICAgR1JlZlB0cjxHSU9TdHJlYW0+IG1fc3RyZWFtOwogICAgIEdSZWZQdHI8R0lucHV0 U3RyZWFtPiBtX2lucHV0U3RyZWFtOwogICAgIEdSZWZQdHI8R1BvbGxhYmxlT3V0cHV0U3RyZWFt PiBtX291dHB1dFN0cmVhbTsKICAgICBHUmVmUHRyPEdTb3VyY2U+IG1fd3JpdGVSZWFkeVNvdXJj ZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Tb2Nr ZXRTdHJlYW1IYW5kbGVJbXBsU291cC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3 b3JrL3NvdXAvU29ja2V0U3RyZWFtSGFuZGxlSW1wbFNvdXAuY3BwCmluZGV4IDMzNzczYzMyMGJh Li42YzI1MGY0NThhOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9zb3VwL1NvY2tldFN0cmVhbUhhbmRsZUltcGxTb3VwLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvU29ja2V0U3RyZWFtSGFuZGxlSW1wbFNvdXAuY3BwCkBA IC01NSw2ICs1NSwxNSBAQCBzdGF0aWMgZ2Jvb2xlYW4gd3NzQ29ubmVjdGlvbkFjY2VwdENlcnRp ZmljYXRlQ2FsbGJhY2soR1Rsc0Nvbm5lY3Rpb24qLCBHVGxzQ2VydAogICAgIHJldHVybiBUUlVF OwogfQogCisjaWYgU09VUF9DSEVDS19WRVJTSU9OKDIsIDYxLCAyKQorc3RhdGljIHZvaWQgd3Nz U29ja2V0Q2xpZW50RXZlbnRDYWxsYmFjayhTb3VwU2Vzc2lvbiosIEdTb2NrZXRDbGllbnRFdmVu dCBldmVudCwgR0lPU3RyZWFtKiBjb25uZWN0aW9uKQoreworICAgIGlmIChldmVudCAhPSBHX1NP Q0tFVF9DTElFTlRfVExTX0hBTkRTSEFLSU5HKQorICAgICAgICByZXR1cm47CisKKyAgICBnX3Np Z25hbF9jb25uZWN0KGNvbm5lY3Rpb24sICJhY2NlcHQtY2VydGlmaWNhdGUiLCBHX0NBTExCQUNL KHdzc0Nvbm5lY3Rpb25BY2NlcHRDZXJ0aWZpY2F0ZUNhbGxiYWNrKSwgbnVsbHB0cik7Cit9Cisj ZWxzZQogc3RhdGljIHZvaWQgd3NzU29ja2V0Q2xpZW50RXZlbnRDYWxsYmFjayhHU29ja2V0Q2xp ZW50KiwgR1NvY2tldENsaWVudEV2ZW50IGV2ZW50LCBHU29ja2V0Q29ubmVjdGFibGUqLCBHSU9T dHJlYW0qIGNvbm5lY3Rpb24pCiB7CiAgICAgaWYgKGV2ZW50ICE9IEdfU09DS0VUX0NMSUVOVF9U TFNfSEFORFNIQUtJTkcpCkBAIC02MiwzMiArNzEsNDAgQEAgc3RhdGljIHZvaWQgd3NzU29ja2V0 Q2xpZW50RXZlbnRDYWxsYmFjayhHU29ja2V0Q2xpZW50KiwgR1NvY2tldENsaWVudEV2ZW50IGV2 ZW4KIAogICAgIGdfc2lnbmFsX2Nvbm5lY3QoY29ubmVjdGlvbiwgImFjY2VwdC1jZXJ0aWZpY2F0 ZSIsIEdfQ0FMTEJBQ0sod3NzQ29ubmVjdGlvbkFjY2VwdENlcnRpZmljYXRlQ2FsbGJhY2spLCBu dWxscHRyKTsKIH0KKyNlbmRpZgogCi1SZWY8U29ja2V0U3RyZWFtSGFuZGxlSW1wbD4gU29ja2V0 U3RyZWFtSGFuZGxlSW1wbDo6Y3JlYXRlKGNvbnN0IFVSTCYgdXJsLCBTb2NrZXRTdHJlYW1IYW5k bGVDbGllbnQmIGNsaWVudCwgUEFMOjpTZXNzaW9uSUQsIGNvbnN0IFN0cmluZyYsIFNvdXJjZUFw cGxpY2F0aW9uQXVkaXRUb2tlbiYmKQorUmVmPFNvY2tldFN0cmVhbUhhbmRsZUltcGw+IFNvY2tl dFN0cmVhbUhhbmRsZUltcGw6OmNyZWF0ZShjb25zdCBVUkwmIHVybCwgU29ja2V0U3RyZWFtSGFu ZGxlQ2xpZW50JiBjbGllbnQsIFBBTDo6U2Vzc2lvbklEIHNlc3Npb25JRCwgY29uc3QgU3RyaW5n JiwgU291cmNlQXBwbGljYXRpb25BdWRpdFRva2VuJiYpCiB7CiAgICAgUmVmPFNvY2tldFN0cmVh bUhhbmRsZUltcGw+IHNvY2tldCA9IGFkb3B0UmVmKCpuZXcgU29ja2V0U3RyZWFtSGFuZGxlSW1w bCh1cmwsIGNsaWVudCkpOwogCisgICAgLy8gRklYTUU6IFVzaW5nIERlcHJlY2F0ZWRHbG9iYWxT ZXR0aW5ncyBmcm9tIGhlcmUgaXMgYSBsYXllcmluZyB2aW9sYXRpb24uCisgICAgYm9vbCBhbGxv d3NBbnlTU0xDZXJ0aWZpY2F0ZSA9IHVybC5wcm90b2NvbElzKCJ3c3MiKSAmJiBEZXByZWNhdGVk R2xvYmFsU2V0dGluZ3M6OmFsbG93c0FueVNTTENlcnRpZmljYXRlKCk7CisKKyNpZiBTT1VQX0NI RUNLX1ZFUlNJT04oMiwgNjEsIDIpCisgICAgYXV0byogbmV0d29ya1N0b3JhZ2VTZXNzaW9uID0g TmV0d29ya1N0b3JhZ2VTZXNzaW9uOjpzdG9yYWdlU2Vzc2lvbihzZXNzaW9uSUQpOworICAgIGlm ICghbmV0d29ya1N0b3JhZ2VTZXNzaW9uKQorICAgICAgICByZXR1cm4gc29ja2V0OworCisgICAg YXV0byB1cmkgPSB1cmwuY3JlYXRlU291cFVSSSgpOworICAgIFJlZjxTb2NrZXRTdHJlYW1IYW5k bGU+IHByb3RlY3RlZFNvY2tldFN0cmVhbUhhbmRsZSA9IHNvY2tldC5jb3B5UmVmKCk7CisgICAg c291cF9zZXNzaW9uX2Nvbm5lY3RfYXN5bmMobmV0d29ya1N0b3JhZ2VTZXNzaW9uLT5nZXRPckNy ZWF0ZVNvdXBOZXR3b3JrU2Vzc2lvbigpLnNvdXBTZXNzaW9uKCksIHVyaS5nZXQoKSwgc29ja2V0 LT5tX2NhbmNlbGxhYmxlLmdldCgpLAorICAgICAgICBhbGxvd3NBbnlTU0xDZXJ0aWZpY2F0ZSA/ IHJlaW50ZXJwcmV0X2Nhc3Q8U291cFNlc3Npb25Db25uZWN0UHJvZ3Jlc3NDYWxsYmFjaz4od3Nz U29ja2V0Q2xpZW50RXZlbnRDYWxsYmFjaykgOiBudWxscHRyLAorICAgICAgICByZWludGVycHJl dF9jYXN0PEdBc3luY1JlYWR5Q2FsbGJhY2s+KGNvbm5lY3RlZENhbGxiYWNrKSwgJnByb3RlY3Rl ZFNvY2tldFN0cmVhbUhhbmRsZS5sZWFrUmVmKCkpOworI2Vsc2UKKyAgICBVTlVTRURfUEFSQU0o c2Vzc2lvbklEKTsKICAgICB1bnNpZ25lZCBwb3J0ID0gdXJsLnBvcnQoKSA/IHVybC5wb3J0KCku dmFsdWUoKSA6ICh1cmwucHJvdG9jb2xJcygid3NzIikgPyA0NDMgOiA4MCk7CiAgICAgR1JlZlB0 cjxHU29ja2V0Q2xpZW50PiBzb2NrZXRDbGllbnQgPSBhZG9wdEdSZWYoZ19zb2NrZXRfY2xpZW50 X25ldygpKTsKICAgICBpZiAodXJsLnByb3RvY29sSXMoIndzcyIpKSB7CiAgICAgICAgIGdfc29j a2V0X2NsaWVudF9zZXRfdGxzKHNvY2tldENsaWVudC5nZXQoKSwgVFJVRSk7Ci0gICAgICAgIC8v IEZJWE1FOiBVc2luZyBEZXByZWNhdGVkR2xvYmFsU2V0dGluZ3MgZnJvbSBoZXJlIGlzIGEgbGF5 ZXJpbmcgdmlvbGF0aW9uLgotICAgICAgICBpZiAoRGVwcmVjYXRlZEdsb2JhbFNldHRpbmdzOjph bGxvd3NBbnlTU0xDZXJ0aWZpY2F0ZSgpKQorICAgICAgICBpZiAoYWxsb3dzQW55U1NMQ2VydGlm aWNhdGUpCiAgICAgICAgICAgICBnX3NpZ25hbF9jb25uZWN0KHNvY2tldENsaWVudC5nZXQoKSwg ImV2ZW50IiwgR19DQUxMQkFDSyh3c3NTb2NrZXRDbGllbnRFdmVudENhbGxiYWNrKSwgbnVsbHB0 cik7CiAgICAgfQogICAgIFJlZjxTb2NrZXRTdHJlYW1IYW5kbGU+IHByb3RlY3RlZFNvY2tldFN0 cmVhbUhhbmRsZSA9IHNvY2tldC5jb3B5UmVmKCk7CiAgICAgZ19zb2NrZXRfY2xpZW50X2Nvbm5l Y3RfdG9faG9zdF9hc3luYyhzb2NrZXRDbGllbnQuZ2V0KCksIHVybC5ob3N0KCkudXRmOCgpLmRh dGEoKSwgcG9ydCwgc29ja2V0LT5tX2NhbmNlbGxhYmxlLmdldCgpLAogICAgICAgICByZWludGVy cHJldF9jYXN0PEdBc3luY1JlYWR5Q2FsbGJhY2s+KGNvbm5lY3RlZENhbGxiYWNrKSwgJnByb3Rl Y3RlZFNvY2tldFN0cmVhbUhhbmRsZS5sZWFrUmVmKCkpOwotICAgIHJldHVybiBzb2NrZXQ7Ci19 Ci0KLVJlZjxTb2NrZXRTdHJlYW1IYW5kbGU+IFNvY2tldFN0cmVhbUhhbmRsZUltcGw6OmNyZWF0 ZShHU29ja2V0Q29ubmVjdGlvbiogc29ja2V0Q29ubmVjdGlvbiwgU29ja2V0U3RyZWFtSGFuZGxl Q2xpZW50JiBjbGllbnQpCi17Ci0gICAgUmVmPFNvY2tldFN0cmVhbUhhbmRsZUltcGw+IHNvY2tl dCA9IGFkb3B0UmVmKCpuZXcgU29ja2V0U3RyZWFtSGFuZGxlSW1wbChVUkwoKSwgY2xpZW50KSk7 CisjZW5kaWYKIAotICAgIEdSZWZQdHI8R1NvY2tldENvbm5lY3Rpb24+IGNvbm5lY3Rpb24gPSBz b2NrZXRDb25uZWN0aW9uOwotICAgIHNvY2tldC0+Y29ubmVjdGVkKFdURk1vdmUoY29ubmVjdGlv bikpOwotICAgIHJldHVybiBXVEZNb3ZlKHNvY2tldCk7CisgICAgcmV0dXJuIHNvY2tldDsKIH0K IAogU29ja2V0U3RyZWFtSGFuZGxlSW1wbDo6U29ja2V0U3RyZWFtSGFuZGxlSW1wbChjb25zdCBV UkwmIHVybCwgU29ja2V0U3RyZWFtSGFuZGxlQ2xpZW50JiBjbGllbnQpCkBAIC0xMDIsMTEgKzEx OSwxMSBAQCBTb2NrZXRTdHJlYW1IYW5kbGVJbXBsOjp+U29ja2V0U3RyZWFtSGFuZGxlSW1wbCgp CiAgICAgTE9HKE5ldHdvcmssICJTb2NrZXRTdHJlYW1IYW5kbGUgJXAgZGVsZXRlIiwgdGhpcyk7 CiB9CiAKLXZvaWQgU29ja2V0U3RyZWFtSGFuZGxlSW1wbDo6Y29ubmVjdGVkKEdSZWZQdHI8R1Nv Y2tldENvbm5lY3Rpb24+JiYgc29ja2V0Q29ubmVjdGlvbikKK3ZvaWQgU29ja2V0U3RyZWFtSGFu ZGxlSW1wbDo6Y29ubmVjdGVkKEdSZWZQdHI8R0lPU3RyZWFtPiYmIHN0cmVhbSkKIHsKLSAgICBt X3NvY2tldENvbm5lY3Rpb24gPSBXVEZNb3ZlKHNvY2tldENvbm5lY3Rpb24pOwotICAgIG1fb3V0 cHV0U3RyZWFtID0gR19QT0xMQUJMRV9PVVRQVVRfU1RSRUFNKGdfaW9fc3RyZWFtX2dldF9vdXRw dXRfc3RyZWFtKEdfSU9fU1RSRUFNKG1fc29ja2V0Q29ubmVjdGlvbi5nZXQoKSkpKTsKLSAgICBt X2lucHV0U3RyZWFtID0gZ19pb19zdHJlYW1fZ2V0X2lucHV0X3N0cmVhbShHX0lPX1NUUkVBTSht X3NvY2tldENvbm5lY3Rpb24uZ2V0KCkpKTsKKyAgICBtX3N0cmVhbSA9IFdURk1vdmUoc3RyZWFt KTsKKyAgICBtX291dHB1dFN0cmVhbSA9IEdfUE9MTEFCTEVfT1VUUFVUX1NUUkVBTShnX2lvX3N0 cmVhbV9nZXRfb3V0cHV0X3N0cmVhbShtX3N0cmVhbS5nZXQoKSkpOworICAgIG1faW5wdXRTdHJl YW0gPSBnX2lvX3N0cmVhbV9nZXRfaW5wdXRfc3RyZWFtKG1fc3RyZWFtLmdldCgpKTsKICAgICBt X3JlYWRCdWZmZXIgPSBzdGQ6Om1ha2VfdW5pcXVlPGNoYXJbXT4oUkVBRF9CVUZGRVJfU0laRSk7 CiAKICAgICBSZWZQdHI8U29ja2V0U3RyZWFtSGFuZGxlSW1wbD4gcHJvdGVjdGVkVGhpcyh0aGlz KTsKQEAgLTExNywyNSArMTM0LDI5IEBAIHZvaWQgU29ja2V0U3RyZWFtSGFuZGxlSW1wbDo6Y29u bmVjdGVkKEdSZWZQdHI8R1NvY2tldENvbm5lY3Rpb24+JiYgc29ja2V0Q29ubmVjCiAgICAgbV9j bGllbnQuZGlkT3BlblNvY2tldFN0cmVhbSgqdGhpcyk7CiB9CiAKLXZvaWQgU29ja2V0U3RyZWFt SGFuZGxlSW1wbDo6Y29ubmVjdGVkQ2FsbGJhY2soR1NvY2tldENsaWVudCogY2xpZW50LCBHQXN5 bmNSZXN1bHQqIHJlc3VsdCwgU29ja2V0U3RyZWFtSGFuZGxlSW1wbCogaGFuZGxlKQordm9pZCBT b2NrZXRTdHJlYW1IYW5kbGVJbXBsOjpjb25uZWN0ZWRDYWxsYmFjayhHT2JqZWN0KiBvYmplY3Qs IEdBc3luY1Jlc3VsdCogcmVzdWx0LCBTb2NrZXRTdHJlYW1IYW5kbGVJbXBsKiBoYW5kbGUpCiB7 CiAgICAgUmVmUHRyPFNvY2tldFN0cmVhbUhhbmRsZT4gcHJvdGVjdGVkVGhpcyA9IGFkb3B0UmVm KGhhbmRsZSk7CiAKICAgICAvLyBBbHdheXMgZmluaXNoIHRoZSBjb25uZWN0aW9uLCBldmVuIGlm IHRoaXMgU29ja2V0U3RyZWFtSGFuZGxlIHdhcyBjYW5jZWxsZWQgZWFybGllci4KICAgICBHVW5p cXVlT3V0UHRyPEdFcnJvcj4gZXJyb3I7Ci0gICAgR1JlZlB0cjxHU29ja2V0Q29ubmVjdGlvbj4g c29ja2V0Q29ubmVjdGlvbiA9IGFkb3B0R1JlZihnX3NvY2tldF9jbGllbnRfY29ubmVjdF90b19o b3N0X2ZpbmlzaChjbGllbnQsIHJlc3VsdCwgJmVycm9yLm91dFB0cigpKSk7CisjaWYgU09VUF9D SEVDS19WRVJTSU9OKDIsIDYxLCAyKQorICAgIEdSZWZQdHI8R0lPU3RyZWFtPiBzdHJlYW0gPSBh ZG9wdEdSZWYoc291cF9zZXNzaW9uX2Nvbm5lY3RfZmluaXNoKFNPVVBfU0VTU0lPTihvYmplY3Qp LCByZXN1bHQsICZlcnJvci5vdXRQdHIoKSkpOworI2Vsc2UKKyAgICBHUmVmUHRyPEdJT1N0cmVh bT4gc3RyZWFtID0gYWRvcHRHUmVmKEdfSU9fU1RSRUFNKGdfc29ja2V0X2NsaWVudF9jb25uZWN0 X3RvX2hvc3RfZmluaXNoKEdfU09DS0VUX0NMSUVOVChvYmplY3QpLCByZXN1bHQsICZlcnJvci5v dXRQdHIoKSkpKTsKKyNlbmRpZgogCiAgICAgLy8gVGhlIFNvY2tldFN0cmVhbUhhbmRsZSBoYXMg YmVlbiBjYW5jZWxsZWQsIHNvIGp1c3QgY2xvc2UgdGhlIGNvbm5lY3Rpb24sIGlnbm9yaW5nIGVy cm9ycy4KICAgICBpZiAoZ19jYW5jZWxsYWJsZV9pc19jYW5jZWxsZWQoaGFuZGxlLT5tX2NhbmNl bGxhYmxlLmdldCgpKSkgewotICAgICAgICBpZiAoc29ja2V0Q29ubmVjdGlvbikKLSAgICAgICAg ICAgIGdfaW9fc3RyZWFtX2Nsb3NlKEdfSU9fU1RSRUFNKHNvY2tldENvbm5lY3Rpb24uZ2V0KCkp LCBudWxscHRyLCBudWxscHRyKTsKKyAgICAgICAgaWYgKHN0cmVhbSkKKyAgICAgICAgICAgIGdf aW9fc3RyZWFtX2Nsb3NlKHN0cmVhbS5nZXQoKSwgbnVsbHB0ciwgbnVsbHB0cik7CiAgICAgICAg IHJldHVybjsKICAgICB9CiAKICAgICBpZiAoZXJyb3IpCi0gICAgICAgIGhhbmRsZS0+ZGlkRmFp bChTb2NrZXRTdHJlYW1FcnJvcihlcnJvci0+Y29kZSwgU3RyaW5nKCksIGVycm9yLT5tZXNzYWdl KSk7CisgICAgICAgIGhhbmRsZS0+ZGlkRmFpbChTb2NrZXRTdHJlYW1FcnJvcihlcnJvci0+Y29k ZSwgeyB9LCBlcnJvci0+bWVzc2FnZSkpOwogICAgIGVsc2UKLSAgICAgICAgaGFuZGxlLT5jb25u ZWN0ZWQoV1RGTW92ZShzb2NrZXRDb25uZWN0aW9uKSk7CisgICAgICAgIGhhbmRsZS0+Y29ubmVj dGVkKFdURk1vdmUoc3RyZWFtKSk7CiB9CiAKIHZvaWQgU29ja2V0U3RyZWFtSGFuZGxlSW1wbDo6 cmVhZEJ5dGVzKGdzc2l6ZSBieXRlc1JlYWQpCkBAIC0yMjUsMTIgKzI0NiwxMiBAQCB2b2lkIFNv Y2tldFN0cmVhbUhhbmRsZUltcGw6OnBsYXRmb3JtQ2xvc2UoKQogICAgIGdfY2FuY2VsbGFibGVf Y2FuY2VsKG1fY2FuY2VsbGFibGUuZ2V0KCkpOwogICAgIHN0b3BXYWl0aW5nRm9yU29ja2V0V3Jp dGFiaWxpdHkoKTsKIAotICAgIGlmIChtX3NvY2tldENvbm5lY3Rpb24pIHsKKyAgICBpZiAobV9z dHJlYW0pIHsKICAgICAgICAgR1VuaXF1ZU91dFB0cjxHRXJyb3I+IGVycm9yOwotICAgICAgICBn X2lvX3N0cmVhbV9jbG9zZShHX0lPX1NUUkVBTShtX3NvY2tldENvbm5lY3Rpb24uZ2V0KCkpLCBu dWxscHRyLCAmZXJyb3Iub3V0UHRyKCkpOworICAgICAgICBnX2lvX3N0cmVhbV9jbG9zZShtX3N0 cmVhbS5nZXQoKSwgbnVsbHB0ciwgJmVycm9yLm91dFB0cigpKTsKICAgICAgICAgaWYgKGVycm9y KQotICAgICAgICAgICAgZGlkRmFpbChTb2NrZXRTdHJlYW1FcnJvcihlcnJvci0+Y29kZSwgU3Ry aW5nKCksIGVycm9yLT5tZXNzYWdlKSk7Ci0gICAgICAgIG1fc29ja2V0Q29ubmVjdGlvbiA9IG51 bGxwdHI7CisgICAgICAgICAgICBkaWRGYWlsKFNvY2tldFN0cmVhbUVycm9yKGVycm9yLT5jb2Rl LCB7IH0sIGVycm9yLT5tZXNzYWdlKSk7CisgICAgICAgIG1fc3RyZWFtID0gbnVsbHB0cjsKICAg ICB9CiAKICAgICBtX291dHB1dFN0cmVhbSA9IG51bGxwdHI7CmRpZmYgLS1naXQgYS9Ub29scy9D aGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggNzQ0ZTljYjg5NGUuLjkxODBiODg4Zjdi IDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMjkgQEAKKzIwMTgtMDEtMDggIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBp Z2FsaWEuY29tPgorCisgICAgICAgIFtTT1VQXSBXZWJTb2NrZXRzIG11c3QgdXNlIHN5c3RlbSBw cm94eSBzZXR0aW5ncworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MTI2Mzg0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgQ2hlY2sgYWxzbyBXZWJTb2NrZXRzIGluIC93ZWJraXQyL1dlYktpdFdlYkNvbnRleHQv cHJveHkuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdEdMaWIvVGVzdFdl YktpdFdlYkNvbnRleHQuY3BwOgorICAgICAgICAoUHJveHlUZXN0Ojp3ZWJTb2NrZXRQcm94eVNl cnZlckNhbGxiYWNrKToKKyAgICAgICAgKFByb3h5VGVzdDo6UHJveHlUZXN0KToKKyAgICAgICAg KFByb3h5VGVzdDo6d2ViU29ja2VkQ29ubmVjdGVkKToKKyAgICAgICAgKFByb3h5VGVzdDo6Y3Jl YXRlV2ViU29ja2V0QW5kV2FpdFVudGlsQ29ubmVjdGVkKToKKyAgICAgICAgKHdlYlNvY2tldFNl cnZlckNhbGxiYWNrKToKKyAgICAgICAgKHRlc3RXZWJDb250ZXh0UHJveHlTZXR0aW5ncyk6Cisg ICAgICAgICogVGVzdFdlYktpdEFQSS9nbGliL1dlYktpdEdMaWIvV2ViS2l0VGVzdFNlcnZlci5j cHA6CisgICAgICAgIChXZWJLaXRUZXN0U2VydmVyOjp+V2ViS2l0VGVzdFNlcnZlcik6CisgICAg ICAgIChXZWJLaXRUZXN0U2VydmVyOjphZGRXZWJTb2NrZXRIYW5kbGVyKToKKyAgICAgICAgKFdl YktpdFRlc3RTZXJ2ZXI6OnJlbW92ZVdlYlNvY2tldEhhbmRsZXIpOgorICAgICAgICAoV2ViS2l0 VGVzdFNlcnZlcjo6Z2V0V2ViU29ja2V0VVJJRm9yUGF0aCBjb25zdCk6CisgICAgICAgIChXZWJL aXRUZXN0U2VydmVyOjpnZXRVUklGb3JQYXRoIGNvbnN0KToKKyAgICAgICAgKiBUZXN0V2ViS2l0 QVBJL2dsaWIvV2ViS2l0R0xpYi9XZWJLaXRUZXN0U2VydmVyLmg6CisgICAgICAgIChXZWJLaXRU ZXN0U2VydmVyOjpiYXNlVVJJIGNvbnN0KToKKyAgICAgICAgKFdlYktpdFRlc3RTZXJ2ZXI6OmJh c2VXZWJTb2NrZXRVUkkgY29uc3QpOgorCiAyMDE4LTAxLTA3ICBTYWFtIEJhcmF0aSAgPHNiYXJh dGlAYXBwbGUuY29tPgogCiAgICAgICAgIEFkZCB0b3RhbCBleGl0cyBhbmQgdG90YWwgY29tcGls YXRpb25zIHNvcnRpbmcgbW9kZSB0byB0aGUgImZ1bGwiIGNvbW1hbmQgaW4gZGlzcGxheS1wcm9m aWxlci1vdXRwdXQKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0 R0xpYi9UZXN0V2ViS2l0V2ViQ29udGV4dC5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3Rz L1dlYktpdEdMaWIvVGVzdFdlYktpdFdlYkNvbnRleHQuY3BwCmluZGV4IDc5YjdkNmNmMGFlLi5m MTcyZGZmMDZlYyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRH TGliL1Rlc3RXZWJLaXRXZWJDb250ZXh0LmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RzL1dlYktpdEdMaWIvVGVzdFdlYktpdFdlYkNvbnRleHQuY3BwCkBAIC02NTMsNiArNjUzLDE5 IEBAIGNsYXNzIFByb3h5VGVzdCA6IHB1YmxpYyBXZWJWaWV3VGVzdCB7CiBwdWJsaWM6CiAgICAg TUFLRV9HTElCX1RFU1RfRklYVFVSRShQcm94eVRlc3QpOwogCisjaWYgU09VUF9DSEVDS19WRVJT SU9OKDIsIDYxLCAyKQorICAgIGVudW0gY2xhc3MgV2ViU29ja2V0U2VydmVyVHlwZSB7CisgICAg ICAgIFVua25vd24sCisgICAgICAgIE5vUHJveHksCisgICAgICAgIFByb3h5CisgICAgfTsKKwor ICAgIHN0YXRpYyB2b2lkIHdlYlNvY2tldFByb3h5U2VydmVyQ2FsbGJhY2soU291cFNlcnZlcios IFNvdXBXZWJzb2NrZXRDb25uZWN0aW9uKiwgY29uc3QgY2hhciogcGF0aCwgU291cENsaWVudENv bnRleHQqLCBncG9pbnRlciB1c2VyRGF0YSkKKyAgICB7CisgICAgICAgIHN0YXRpY19jYXN0PFBy b3h5VGVzdCo+KHVzZXJEYXRhKS0+d2ViU29ja2VkQ29ubmVjdGVkKFByb3h5VGVzdDo6V2ViU29j a2V0U2VydmVyVHlwZTo6UHJveHkpOworICAgIH0KKyNlbmRpZgorCiAgICAgUHJveHlUZXN0KCkK ICAgICB7CiAgICAgICAgIC8vIFRoaXMgInByb3h5IHNlcnZlciIgaXMgYWN0dWFsbHkganVzdCBh IGRpZmZlcmVudCBpbnN0YW5jZSBvZiB0aGUgbWFpbgpAQCAtNjYyLDYgKzY3NSwxMCBAQCBwdWJs aWM6CiAgICAgICAgIC8vIHdvcmssIG5vdCB3aGV0aGVyIHdlIGNhbiB3cml0ZSBhIHNvdXAgcHJv eHkgc2VydmVyLgogICAgICAgICBtX3Byb3h5U2VydmVyLnJ1bihzZXJ2ZXJDYWxsYmFjayk7CiAg ICAgICAgIGdfYXNzZXJ0KG1fcHJveHlTZXJ2ZXIuYmFzZVVSSSgpKTsKKyNpZiBTT1VQX0NIRUNL X1ZFUlNJT04oMiwgNjEsIDIpCisgICAgICAgIG1fcHJveHlTZXJ2ZXIuYWRkV2ViU29ja2V0SGFu ZGxlcih3ZWJTb2NrZXRQcm94eVNlcnZlckNhbGxiYWNrLCB0aGlzKTsKKyAgICAgICAgZ19hc3Nl cnQobV9wcm94eVNlcnZlci5iYXNlV2ViU29ja2V0VVJJKCkpOworI2VuZGlmCiAgICAgfQogCiAg ICAgQ1N0cmluZyBsb2FkVVJJQW5kR2V0TWFpblJlc291cmNlRGF0YShjb25zdCBjaGFyKiB1cmkp CkBAIC02NzksOSArNjk2LDM3IEBAIHB1YmxpYzoKICAgICAgICAgcmV0dXJuIHBvcnQ7CiAgICAg fQogCisjaWYgU09VUF9DSEVDS19WRVJTSU9OKDIsIDYxLCAyKQorICAgIHZvaWQgd2ViU29ja2Vk Q29ubmVjdGVkKFdlYlNvY2tldFNlcnZlclR5cGUgc2VydmVyVHlwZSkKKyAgICB7CisgICAgICAg IG1fd2ViU29ja2V0UmVxdWVzdFJlY2VpdmVkID0gc2VydmVyVHlwZTsKKyAgICAgICAgcXVpdE1h aW5Mb29wKCk7CisgICAgfQorCisgICAgV2ViU29ja2V0U2VydmVyVHlwZSBjcmVhdGVXZWJTb2Nr ZXRBbmRXYWl0VW50aWxDb25uZWN0ZWQoKQorICAgIHsKKyAgICAgICAgbV93ZWJTb2NrZXRSZXF1 ZXN0UmVjZWl2ZWQgPSBXZWJTb2NrZXRTZXJ2ZXJUeXBlOjpVbmtub3duOworICAgICAgICBHVW5p cXVlUHRyPGNoYXI+IGNyZWF0ZVdlYlNvY2tldChnX3N0cmR1cF9wcmludGYoInZhciB3cyA9IG5l dyBXZWJTb2NrZXQoJyVzJyk7Iiwga1NlcnZlci0+Z2V0V2ViU29ja2V0VVJJRm9yUGF0aCgiL2Zv byIpLmRhdGEoKSkpOworICAgICAgICB3ZWJraXRfd2ViX3ZpZXdfcnVuX2phdmFzY3JpcHQobV93 ZWJWaWV3LCBjcmVhdGVXZWJTb2NrZXQuZ2V0KCksIG51bGxwdHIsIG51bGxwdHIsIG51bGxwdHIp OworICAgICAgICBnX21haW5fbG9vcF9ydW4obV9tYWluTG9vcCk7CisgICAgICAgIHJldHVybiBt X3dlYlNvY2tldFJlcXVlc3RSZWNlaXZlZDsKKyAgICB9CisjZW5kaWYKKwogICAgIFdlYktpdFRl c3RTZXJ2ZXIgbV9wcm94eVNlcnZlcjsKKworI2lmIFNPVVBfQ0hFQ0tfVkVSU0lPTigyLCA2MSwg MikKKyAgICBXZWJTb2NrZXRTZXJ2ZXJUeXBlIG1fd2ViU29ja2V0UmVxdWVzdFJlY2VpdmVkIHsg V2ViU29ja2V0U2VydmVyVHlwZTo6VW5rbm93biB9OworI2VuZGlmCiB9OwogCisjaWYgU09VUF9D SEVDS19WRVJTSU9OKDIsIDYxLCAyKQorc3RhdGljIHZvaWQgd2ViU29ja2V0U2VydmVyQ2FsbGJh Y2soU291cFNlcnZlciosIFNvdXBXZWJzb2NrZXRDb25uZWN0aW9uKiwgY29uc3QgY2hhciosIFNv dXBDbGllbnRDb250ZXh0KiwgZ3BvaW50ZXIgdXNlckRhdGEpCit7CisgICAgc3RhdGljX2Nhc3Q8 UHJveHlUZXN0Kj4odXNlckRhdGEpLT53ZWJTb2NrZWRDb25uZWN0ZWQoUHJveHlUZXN0OjpXZWJT b2NrZXRTZXJ2ZXJUeXBlOjpOb1Byb3h5KTsKK30KKyNlbmRpZgorCiBzdGF0aWMgdm9pZCBlcGhl bWVyYWxWaWV3bG9hZENoYW5nZWQoV2ViS2l0V2ViVmlldyogd2ViVmlldywgV2ViS2l0TG9hZEV2 ZW50IGxvYWRFdmVudCwgV2ViVmlld1Rlc3QqIHRlc3QpCiB7CiAgICAgaWYgKGxvYWRFdmVudCAh PSBXRUJLSVRfTE9BRF9GSU5JU0hFRCkKQEAgLTY5Nyw2ICs3NDIsMTMgQEAgc3RhdGljIHZvaWQg dGVzdFdlYkNvbnRleHRQcm94eVNldHRpbmdzKFByb3h5VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRl cikKICAgICBhdXRvIG1haW5SZXNvdXJjZURhdGEgPSB0ZXN0LT5sb2FkVVJJQW5kR2V0TWFpblJl c291cmNlRGF0YShrU2VydmVyLT5nZXRVUklGb3JQYXRoKCIvZWNob1BvcnQiKS5kYXRhKCkpOwog ICAgIEFTU0VSVF9DTVBfQ1NUUklORyhtYWluUmVzb3VyY2VEYXRhLCA9PSwgc2VydmVyUG9ydEFz U3RyaW5nLmdldCgpKTsKIAorI2lmIFNPVVBfQ0hFQ0tfVkVSU0lPTigyLCA2MSwgMikKKyAgICAv LyBXZWJTb2NrZXQgcmVxdWVzdHMgc2hvdWxkIGFsc28gYmUgcmVjZWl2ZWQgYnkga1NlcnZlci4K KyAgICBrU2VydmVyLT5hZGRXZWJTb2NrZXRIYW5kbGVyKHdlYlNvY2tldFNlcnZlckNhbGxiYWNr LCB0ZXN0KTsKKyAgICBhdXRvIHNlcnZlclR5cGUgPSB0ZXN0LT5jcmVhdGVXZWJTb2NrZXRBbmRX YWl0VW50aWxDb25uZWN0ZWQoKTsKKyAgICBnX2Fzc2VydChzZXJ2ZXJUeXBlID09IFByb3h5VGVz dDo6V2ViU29ja2V0U2VydmVyVHlwZTo6Tm9Qcm94eSk7CisjZW5kaWYKKwogICAgIC8vIFNldCBk ZWZhdWx0IHByb3h5IFVSSSB0byBwb2ludCB0byBwcm94eVNlcnZlci4gUmVxdWVzdHMgdG8ga1Nl cnZlciBzaG91bGQgYmUgcmVjZWl2ZWQgYnkgcHJveHlTZXJ2ZXIgaW5zdGVhZC4KICAgICBHVW5p cXVlUHRyPGNoYXI+IHByb3h5VVJJKHNvdXBfdXJpX3RvX3N0cmluZyh0ZXN0LT5tX3Byb3h5U2Vy dmVyLmJhc2VVUkkoKSwgRkFMU0UpKTsKICAgICBXZWJLaXROZXR3b3JrUHJveHlTZXR0aW5ncyog c2V0dGluZ3MgPSB3ZWJraXRfbmV0d29ya19wcm94eV9zZXR0aW5nc19uZXcocHJveHlVUkkuZ2V0 KCksIG51bGxwdHIpOwpAQCAtNzA2LDYgKzc1OCwxMiBAQCBzdGF0aWMgdm9pZCB0ZXN0V2ViQ29u dGV4dFByb3h5U2V0dGluZ3MoUHJveHlUZXN0KiB0ZXN0LCBnY29uc3Rwb2ludGVyKQogICAgIEFT U0VSVF9DTVBfQ1NUUklORyhtYWluUmVzb3VyY2VEYXRhLCA9PSwgcHJveHlTZXJ2ZXJQb3J0QXNT dHJpbmcuZ2V0KCkpOwogICAgIHdlYmtpdF9uZXR3b3JrX3Byb3h5X3NldHRpbmdzX2ZyZWUoc2V0 dGluZ3MpOwogCisjaWYgU09VUF9DSEVDS19WRVJTSU9OKDIsIDYxLCAyKQorICAgIC8vIFdlYlNv Y2tldCByZXF1ZXN0cyBzaG91bGQgYWxzbyBiZSByZWNlaXZlZCBieSBwcm94eVNlcnZlci4KKyAg ICBzZXJ2ZXJUeXBlID0gdGVzdC0+Y3JlYXRlV2ViU29ja2V0QW5kV2FpdFVudGlsQ29ubmVjdGVk KCk7CisgICAgZ19hc3NlcnQoc2VydmVyVHlwZSA9PSBQcm94eVRlc3Q6OldlYlNvY2tldFNlcnZl clR5cGU6OlByb3h5KTsKKyNlbmRpZgorCiAgICAgLy8gUHJveHkgc2V0dGluZ3MgYWxzbyBhZmZl Y3QgZXBoZW1lcmFsIHdlYiB2aWV3cy4KICAgICBhdXRvIHdlYlZpZXcgPSBUZXN0OjphZG9wdFZp ZXcoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX1dFQl9WSUVXLAogI2lmIFBMQVRGT1JNKFdQRSkK QEAgLTc2Niw2ICs4MjQsMTAgQEAgc3RhdGljIHZvaWQgdGVzdFdlYkNvbnRleHRQcm94eVNldHRp bmdzKFByb3h5VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRlcikKICAgICB3ZWJraXRfd2ViX2NvbnRl eHRfc2V0X25ldHdvcmtfcHJveHlfc2V0dGluZ3ModGVzdC0+bV93ZWJDb250ZXh0LmdldCgpLCBX RUJLSVRfTkVUV09SS19QUk9YWV9NT0RFX0RFRkFVTFQsIG51bGxwdHIpOwogICAgIG1haW5SZXNv dXJjZURhdGEgPSB0ZXN0LT5sb2FkVVJJQW5kR2V0TWFpblJlc291cmNlRGF0YShrU2VydmVyLT5n ZXRVUklGb3JQYXRoKCIvZWNob1BvcnQiKS5kYXRhKCkpOwogICAgIEFTU0VSVF9DTVBfQ1NUUklO RyhtYWluUmVzb3VyY2VEYXRhLCA9PSwgc2VydmVyUG9ydEFzU3RyaW5nLmdldCgpKTsKKworI2lm IFNPVVBfQ0hFQ0tfVkVSU0lPTigyLCA2MSwgMikKKyAgICBrU2VydmVyLT5yZW1vdmVXZWJTb2Nr ZXRIYW5kbGVyKCk7CisjZW5kaWYKIH0KIAogdm9pZCBiZWZvcmVBbGwoKQpkaWZmIC0tZ2l0IGEv VG9vbHMvVGVzdFdlYktpdEFQSS9nbGliL1dlYktpdEdMaWIvV2ViS2l0VGVzdFNlcnZlci5jcHAg Yi9Ub29scy9UZXN0V2ViS2l0QVBJL2dsaWIvV2ViS2l0R0xpYi9XZWJLaXRUZXN0U2VydmVyLmNw cAppbmRleCBkZTk0NjZjMzlkNy4uZmQxNjIzYzlmNmMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvZ2xpYi9XZWJLaXRHTGliL1dlYktpdFRlc3RTZXJ2ZXIuY3BwCisrKyBiL1Rvb2xz L1Rlc3RXZWJLaXRBUEkvZ2xpYi9XZWJLaXRHTGliL1dlYktpdFRlc3RTZXJ2ZXIuY3BwCkBAIC01 Myw2ICs1MywxMCBAQCBXZWJLaXRUZXN0U2VydmVyOjpXZWJLaXRUZXN0U2VydmVyKFNlcnZlck9w dGlvbnMgb3B0aW9ucykKIFdlYktpdFRlc3RTZXJ2ZXI6On5XZWJLaXRUZXN0U2VydmVyKCkKIHsK ICAgICBzb3VwX3VyaV9mcmVlKG1fYmFzZVVSSSk7CisjaWYgU09VUF9DSEVDS19WRVJTSU9OKDIs IDUwLCAwKQorICAgIGlmIChtX2Jhc2VXZWJTb2NrZXRVUkkpCisgICAgICAgIHNvdXBfdXJpX2Zy ZWUobV9iYXNlV2ViU29ja2V0VVJJKTsKKyNlbmRpZgogfQogCiB2b2lkIFdlYktpdFRlc3RTZXJ2 ZXI6OnJ1bihTb3VwU2VydmVyQ2FsbGJhY2sgc2VydmVyQ2FsbGJhY2spCkBAIC02OCwxMSArNzIs NDggQEAgdm9pZCBXZWJLaXRUZXN0U2VydmVyOjpydW4oU291cFNlcnZlckNhbGxiYWNrIHNlcnZl ckNhbGxiYWNrKQogICAgIH0KIH0KIAotQ1N0cmluZyBXZWJLaXRUZXN0U2VydmVyOjpnZXRVUklG b3JQYXRoKGNvbnN0IGNoYXIqIHBhdGgpCisjaWYgU09VUF9DSEVDS19WRVJTSU9OKDIsIDUwLCAw KQordm9pZCBXZWJLaXRUZXN0U2VydmVyOjphZGRXZWJTb2NrZXRIYW5kbGVyKFNvdXBTZXJ2ZXJX ZWJzb2NrZXRDYWxsYmFjayBjYWxsYmFjaywgZ3BvaW50ZXIgdXNlckRhdGEpCiB7Ci0gICAgU291 cFVSSSogdXJpID0gc291cF91cmlfbmV3X3dpdGhfYmFzZShtX2Jhc2VVUkksIHBhdGgpOworICAg IG1fYmFzZVdlYlNvY2tldFVSSSA9IHNvdXBfdXJpX25ld193aXRoX2Jhc2UobV9iYXNlVVJJLCAi L3dlYnNvY2tldC8iKTsKKyAgICBtX2Jhc2VXZWJTb2NrZXRVUkktPnNjaGVtZSA9IG1fYmFzZVdl YlNvY2tldFVSSS0+c2NoZW1lID09IFNPVVBfVVJJX1NDSEVNRV9IVFRQID8gU09VUF9VUklfU0NI RU1FX1dTIDogU09VUF9VUklfU0NIRU1FX1dTUzsKKworICAgIGlmIChtX3F1ZXVlKSB7CisgICAg ICAgIG1fcXVldWUtPmRpc3BhdGNoKFt0aGlzLCBjYWxsYmFjaywgdXNlckRhdGFdIHsKKyAgICAg ICAgICAgIHNvdXBfc2VydmVyX2FkZF93ZWJzb2NrZXRfaGFuZGxlcihtX3NvdXBTZXJ2ZXIuZ2V0 KCksICIvd2Vic29ja2V0IiwgbnVsbHB0ciwgbnVsbHB0ciwgY2FsbGJhY2ssIHVzZXJEYXRhLCBu dWxscHRyKTsKKyAgICAgICAgfSk7CisgICAgfSBlbHNlCisgICAgICAgIHNvdXBfc2VydmVyX2Fk ZF93ZWJzb2NrZXRfaGFuZGxlcihtX3NvdXBTZXJ2ZXIuZ2V0KCksICIvd2Vic29ja2V0IiwgbnVs bHB0ciwgbnVsbHB0ciwgY2FsbGJhY2ssIHVzZXJEYXRhLCBudWxscHRyKTsKK30KKwordm9pZCBX ZWJLaXRUZXN0U2VydmVyOjpyZW1vdmVXZWJTb2NrZXRIYW5kbGVyKCkKK3sKKyAgICBzb3VwX3Vy aV9mcmVlKG1fYmFzZVdlYlNvY2tldFVSSSk7CisgICAgbV9iYXNlV2ViU29ja2V0VVJJID0gbnVs bHB0cjsKKworICAgIGlmIChtX3F1ZXVlKSB7CisgICAgICAgIG1fcXVldWUtPmRpc3BhdGNoKFt0 aGlzXSB7CisgICAgICAgICAgICBzb3VwX3NlcnZlcl9yZW1vdmVfaGFuZGxlcihtX3NvdXBTZXJ2 ZXIuZ2V0KCksICIvd2Vic29ja2V0Iik7CisgICAgICAgIH0pOworICAgIH0gZWxzZQorICAgICAg ICBzb3VwX3NlcnZlcl9yZW1vdmVfaGFuZGxlcihtX3NvdXBTZXJ2ZXIuZ2V0KCksICIvd2Vic29j a2V0Iik7Cit9CisKK0NTdHJpbmcgV2ViS2l0VGVzdFNlcnZlcjo6Z2V0V2ViU29ja2V0VVJJRm9y UGF0aChjb25zdCBjaGFyKiBwYXRoKSBjb25zdAoreworICAgIGdfYXNzZXJ0KG1fYmFzZVdlYlNv Y2tldFVSSSk7CisgICAgZ19hc3NlcnQocGF0aCAmJiAqcGF0aCA9PSAnLycpOworICAgIFNvdXBV UkkqIHVyaSA9IHNvdXBfdXJpX25ld193aXRoX2Jhc2UobV9iYXNlV2ViU29ja2V0VVJJLCBwYXRo ICsgMSk7IC8vIElnbm9yZSB0aGUgbGVhZGluZyBzbGFzaC4KICAgICBHVW5pcXVlUHRyPGdjaGFy PiB1cmlTdHJpbmcoc291cF91cmlfdG9fc3RyaW5nKHVyaSwgRkFMU0UpKTsKICAgICBzb3VwX3Vy aV9mcmVlKHVyaSk7CiAgICAgcmV0dXJuIHVyaVN0cmluZy5nZXQoKTsKIH0KKyNlbmRpZiAvLyBT T1VQX0NIRUNLX1ZFUlNJT04oMiwgNTAsIDApCiAKK0NTdHJpbmcgV2ViS2l0VGVzdFNlcnZlcjo6 Z2V0VVJJRm9yUGF0aChjb25zdCBjaGFyKiBwYXRoKSBjb25zdAoreworICAgIFNvdXBVUkkqIHVy aSA9IHNvdXBfdXJpX25ld193aXRoX2Jhc2UobV9iYXNlVVJJLCBwYXRoKTsKKyAgICBHVW5pcXVl UHRyPGdjaGFyPiB1cmlTdHJpbmcoc291cF91cmlfdG9fc3RyaW5nKHVyaSwgRkFMU0UpKTsKKyAg ICBzb3VwX3VyaV9mcmVlKHVyaSk7CisgICAgcmV0dXJuIHVyaVN0cmluZy5nZXQoKTsKK30KZGlm ZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ2xpYi9XZWJLaXRHTGliL1dlYktpdFRlc3RT ZXJ2ZXIuaCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvZ2xpYi9XZWJLaXRHTGliL1dlYktpdFRlc3RT ZXJ2ZXIuaAppbmRleCBjOTc5YTUwMDdmMS4uNjkwZjBhNzc1NmMgMTAwNjQ0Ci0tLSBhL1Rvb2xz L1Rlc3RXZWJLaXRBUEkvZ2xpYi9XZWJLaXRHTGliL1dlYktpdFRlc3RTZXJ2ZXIuaAorKysgYi9U b29scy9UZXN0V2ViS2l0QVBJL2dsaWIvV2ViS2l0R0xpYi9XZWJLaXRUZXN0U2VydmVyLmgKQEAg LTM2LDEzICszNiwyMiBAQCBwdWJsaWM6CiAgICAgV2ViS2l0VGVzdFNlcnZlcihTZXJ2ZXJPcHRp b25zID0gU2VydmVySFRUUCk7CiAgICAgdmlydHVhbCB+V2ViS2l0VGVzdFNlcnZlcigpOwogCi0g ICAgU291cFVSSSogYmFzZVVSSSgpIHsgcmV0dXJuIG1fYmFzZVVSSTsgfQotCi0gICAgQ1N0cmlu ZyBnZXRVUklGb3JQYXRoKGNvbnN0IGNoYXIqIHBhdGgpOworICAgIFNvdXBVUkkqIGJhc2VVUkko KSBjb25zdCB7IHJldHVybiBtX2Jhc2VVUkk7IH0KKyAgICBDU3RyaW5nIGdldFVSSUZvclBhdGgo Y29uc3QgY2hhciogcGF0aCkgY29uc3Q7CiAgICAgdm9pZCBydW4oU291cFNlcnZlckNhbGxiYWNr KTsKIAorI2lmIFNPVVBfQ0hFQ0tfVkVSU0lPTigyLCA1MCwgMCkKKyAgICB2b2lkIGFkZFdlYlNv Y2tldEhhbmRsZXIoU291cFNlcnZlcldlYnNvY2tldENhbGxiYWNrLCBncG9pbnRlciB1c2VyRGF0 YSk7CisgICAgdm9pZCByZW1vdmVXZWJTb2NrZXRIYW5kbGVyKCk7CisgICAgU291cFVSSSogYmFz ZVdlYlNvY2tldFVSSSgpIGNvbnN0IHsgcmV0dXJuIG1fYmFzZVdlYlNvY2tldFVSSTsgfQorICAg IENTdHJpbmcgZ2V0V2ViU29ja2V0VVJJRm9yUGF0aChjb25zdCBjaGFyKiBwYXRoKSBjb25zdDsK KyNlbmRpZgorCiBwcml2YXRlOgogICAgIEdSZWZQdHI8U291cFNlcnZlcj4gbV9zb3VwU2VydmVy OwotICAgIFNvdXBVUkkqIG1fYmFzZVVSSTsKKyAgICBTb3VwVVJJKiBtX2Jhc2VVUkkgeyBudWxs cHRyIH07CisjaWYgU09VUF9DSEVDS19WRVJTSU9OKDIsIDUwLCAwKQorICAgIFNvdXBVUkkqIG1f YmFzZVdlYlNvY2tldFVSSSB7IG51bGxwdHIgfTsKKyNlbmRpZgogICAgIFJlZlB0cjxXb3JrUXVl dWU+IG1fcXVldWU7CiB9Owo=