18608 2008-04-18 18:20:41 -0700 [Gtk] WebKitNetworkRequest needs to be finished 2009-10-15 05:30:04 -0700 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) PC Linux RESOLVED FIXED Gtk P2 Normal --- 1 gustavo gustavo alp christian cosimoc jmalonzo marco.barisione pclouds reinouts slomo uws+webkit xan.lopez oldest_to_newest 78200 0 gustavo 2008-04-18 18:20:41 -0700 Coming from http://trac.webkit.org/projects/webkit/wiki/HackingGtk I decided to have this as a bug report, to help track what needs to be done and to have a place to discuss issues. Currently WebKitNetworkRequest only provides a simple GObject which is able to contain a URI string; The current implementation does not use a property, only a simple gchar* in the instance struct. Since I intend to implement the rest of the API, exposing all of the properties currently present in ResourceRequest, and documenting everything with gtk-doc, I would like clarifications on if the properties in the C++ class should be mapped using proper GObject properties (what I would guess), or simple struct members, like uri is implemented today. 78201 1 20681 gustavo 2008-04-18 18:23:45 -0700 Created attachment 20681 draft patch implementing method and http_headers properties My first drafts, I'm attaching so that anybody interested can comment and guide my work on this. 79186 2 20882 gustavo 2008-04-28 18:16:44 -0700 Created attachment 20882 new draft I've moved a bit forward (attended FISL and had to catch up on work, so not a lot to show =D). I wrote some code for GtkLauncher that makes use of the WebKitNetworkRequest API, to understand it better and to serve as a test platform. I would be very grateful for comments on the directions I'm taking. I'll start working on documenting what I have already written, and then finish implementing what is left. 79258 3 20895 gustavo 2008-04-29 19:40:14 -0700 Created attachment 20895 almost complete implementation of a gobject exposing ResourceRequest I think the patch is now mostly complete, if the purpose is exposing information from ResourceRequest only. The area that does need improvement is provind a nicely parsed form_data thingy instead of only providing a gchar* for the body. The dialog in GtkLauncher exercises all of the getter methods, and serves as a nice way of testing/debugging the code. I am still wondering whether most of those should not be real properties, though, and if the changes to the WebKitNetworkRequest object are to be propagated to the original ResourceRequest object or not. gtk-doc-style documentation is still missing, as well, but I will work on it tomorrow. 79259 4 20895 gustavo 2008-04-29 19:48:13 -0700 Comment on attachment 20895 almost complete implementation of a gobject exposing ResourceRequest setting the review flag correctly 79806 5 20999 gustavo 2008-05-07 03:56:04 -0700 Created attachment 20999 Updated implementation, with some more goodies Messing around with the code answered some of my doubts. By looking at FrameLoaderClientGtk's needs, and webkitwebframe.cpp I understand that the original ResourceRequest which I'm mapping needs to be carried with WebKitNetworkRequest, and updated with the values. Currently I'm carrying a copy, though, and I update the original where it needs to be updated, such as in the dispatchWillSendRequest delegate. Some rough edges still need thought and work; a more memory efficient way of handling the internal hash table which contains the headers, only creating it when really needed, for instance. Also, we still have no implementation for ResourceResponse as WebKitNetworkResponse, so the new signal I created for webkitwebview, request-started is missing the redirectResponse argument it should have. I will write a placeholder to fix this, or perhaps even implemente WebKitNetworkResponse completely for this patch to land, if you prefer it that way. Sounds about right? 80135 6 21070 gustavo 2008-05-11 10:59:32 -0700 Created attachment 21070 proposed patch ok, so this is my proposal for landing WebKitNetworkRequest (along with an initial WebKitNetworkResponse); comments? =) 86270 7 uws+webkit 2008-07-17 14:13:37 -0700 I haven't looked at the patch, so perhaps I'm preaching to the choir here... but having object structs directly accessible is considered a very bad thing (also note the GTK+ 3.0 discussion!). Accessor methods are much more versatile. 86273 8 uws+webkit 2008-07-17 14:30:02 -0700 Please discard my last comments, the patch contains both webkit_network_request_[gs]et_uri() functions. 86290 9 gustavo 2008-07-17 17:31:43 -0700 (In reply to comment #8) > Please discard my last comments, the patch contains both > webkit_network_request_[gs]et_uri() functions. Yeah, one of the main goals I tried to keep in mind while writing that was to only make public what should be public. I am not even sure accessor functions would be required, since we have g_object_[gs]et, but since the other parts of the public API have them, I decided to follow. 86348 10 marco.barisione 2008-07-18 11:36:25 -0700 (In reply to comment #6) > ok, so this is my proposal for landing WebKitNetworkRequest (along with an > initial WebKitNetworkResponse); comments? =) I would omit request-redirected/request-started for now and add it when we have both this patch and the one to clean the frame loader signals, see bug #17066. Moreover, having two signals means that people will forget to connect to both, a single signal is better IMHO. Suggestions for the name?. Another problem is that we don't pass the object indentified by the identifier argument. >+ ResourceResponse responseCopy = resourceResponse; >+ WebKitNetworkResponse* response; >+ >+ response = webkit_network_response_new_from_resource_response(responseCopy); Initialisation should be on the same line as declaration. >struct _WebKitNetworkRequestPrivate { >+ ResourceRequest request; >+ > gchar* uri; >+ WebKitReqCachePolicy cache_policy; >+ gdouble timeout_interval; >+ gchar* main_document_uri; >+ gchar* http_method; >+ GHashTable *http_headers; >+ gboolean allow_http_cookies; >+ gchar *body; >+ gsize body_size; > }; You should always use the WebKit style for things that are not exposed in the public API. Why are you keeping in WebKitNetworkRequestPrivate both the ResourceRequest and the values (like cache_policy) that can be easily extracted from it? Maybe it makes sense for strings to avoid conversions and duplications but not for just integers. >+static WebKitReqCachePolicy cache_policy_from_resource_request(const ResourceRequest& resourceRequest) >+{ >+ ResourceRequestCachePolicy cache_policy = resourceRequest.cachePolicy(); >+ >+ switch(cache_policy) >+ { This could just be something like: static WebKitReqCachePolicy kit(ResourceRequestCachePolicy cachePolicy) { return (WebKitReqCachePolicy)cachePolicy; } Then add a comment to the public header to keep the enums in sync. >+void webkit_network_request_set_cache_policy(WebKitNetworkRequest* request, const WebKitReqCachePolicy cache_policy) >+{ Ditto, just define a core() function that casts the enum. >+ priv->http_headers = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); >+ HTTPHeaderMap headers = resourceRequest.httpHeaderFields(); >+ if (!headers.isEmpty()) { >+ HTTPHeaderMap::const_iterator end = headers.end(); >+ for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it) >+ g_hash_table_insert(priv->http_headers, (gpointer)g_strdup(it->first.utf8().data()), (gpointer)g_strdup(it->second.utf8().data())); >+ } Maybe it's better to lazily initialise the hash table only when needed. >+/** >+ * webkit_network_request_new: >+ * @uri: an already encoded URI >+ * >+ * Creates a new #WebKitNetworkRequest initialized with an URI. >+ * >+ * Returns: a new #WebKitNetworkRequest >+ */ > WebKitNetworkRequest* webkit_network_request_new(const gchar* uri) Why is this function public? Does it make sense to use it in an application? I cannot think to any use case so maybe we could think about deprecating it. What do you mean with "already encoded URI"? >+const GHashTable* webkit_network_request_get_http_headers(WebKitNetworkRequest* request) >+{ >+ g_return_val_if_fail(WEBKIT_IS_NETWORK_REQUEST(request), NULL); >+ >+ WebKitNetworkRequestPrivate* priv = request->priv; >+ return priv->http_headers; >+} The documentation is missing. Maybe it could be useful to be able to keep the hash table somewhere after calling _ref, but in this case the return value should not be const and maybe people would think that they can overwrite values directly on the hash table. What do you think? >+/** >+ * WebKitReqCachePolicy: >+ * @WEBKIT_REQ_CACHE_POLICY_NONE: invalid, marker policy >[...] >+ */ >+typedef enum >+{ >+ WEBKIT_REQ_CACHE_POLICY_NONE, I don't think we need it. Do we need all the getters and setters for headers? Like webkit_network_request_[gs]et_http_user_agent(). Probably the various things for which we have getters and setters (excluding the hash table for headers and probably also the body as it needs also the length to be usable) should also be properties. 86828 11 christian 2008-07-24 00:59:46 -0700 (In reply to comment #10) > >struct _WebKitNetworkRequestPrivate { > >+ ResourceRequest request; > >+ > > gchar* uri; > >+ WebKitReqCachePolicy cache_policy; > >+ gdouble timeout_interval; > >+ gchar* main_document_uri; > >+ gchar* http_method; > >+ GHashTable *http_headers; > >+ gboolean allow_http_cookies; > >+ gchar *body; > >+ gsize body_size; > > }; > > You should always use the WebKit style for things that are not exposed in the > public API. > > Why are you keeping in WebKitNetworkRequestPrivate both the ResourceRequest > and the values (like cache_policy) that can be easily extracted from it? > Maybe it makes sense for strings to avoid conversions and duplications > but not for just integers. I second that, It makes sense to use members directly, maybe even for strings. > >+/** > >+ * webkit_network_request_new: > >+ * @uri: an already encoded URI > >+ * > >+ * Creates a new #WebKitNetworkRequest initialized with an URI. > >+ * > >+ * Returns: a new #WebKitNetworkRequest > >+ */ > > WebKitNetworkRequest* webkit_network_request_new(const gchar* uri) > > Why is this function public? Does it make sense to use it in an application? I > cannot think to any use case so maybe we could think about deprecating it. Think of "webkit_web_frame_load_request" here. In that combinaison it seems like a very powerful interface to me. > What do you mean with "already encoded URI"? Scratch "already encoded". If it's an URI, it must be encoded, everything else is ambiguous. :) 87233 12 gustavo 2008-07-28 17:17:04 -0700 (In reply to comment #10) > Maybe it could be useful to be able to keep the hash table somewhere after > calling _ref, but in this case the return value should not be const and maybe > people would think that they can overwrite values directly on the hash table. > What do you think? I think use cases that would require keeping the headers are few enough and should be rare enough that it is better to keep the const nature of the hash table instead of making this API a bit confusing. It's a small numbers of headers to copy if needed, too. 87236 13 22531 gustavo 2008-07-28 17:38:51 -0700 Created attachment 22531 proposed patch Another go. I removed the two signals as requested, I agree it's best to discuss this with the big picture in mind. As for the name of a single, unified signal. What about something like navigation-started, since it is caused by a navigation-requested, AFAIK? 87255 14 marco.barisione 2008-07-29 03:26:25 -0700 (In reply to comment #13) > + ResourceRequest requestCopy = resourceRequest; > + WebKitNetworkRequest* request = webkit_network_request_new_from_resource_request(requestCopy); Why a copy is then the request is copied again to priv->request? > +gdouble webkit_network_request_get_timeout_interval(WebKitNetworkRequest* request) > +{ > + g_return_val_if_fail(WEBKIT_IS_NETWORK_REQUEST(request), 0.0); > + > + WebKitNetworkRequestPrivate* priv = request->priv; > + > + return (gdouble)priv->request.timeoutInterval(); > +} You don't need the cast from double to gdouble. > +const GHashTable* webkit_network_request_get_http_headers(WebKitNetworkRequest* request) > +{ > + g_return_val_if_fail(WEBKIT_IS_NETWORK_REQUEST(request), NULL); > + > + return webkit_network_request_private_get_http_headers(request); > +} Why do you have a separate webkit_network_request_private_get_http_headers? > + * For instance: if the request already has a X-Misc header with a > + * value of "go, webkit!", and we add the same X-Misc header > + * containing "go!" we will end up having a single X-Misc header with > + * a value of "go, webkit!,go!". Maybe the example would be clearer if you use a real header, like Accept-Language. > +void webkit_network_response_set_uri(WebKitNetworkResponse* response, const gchar* uri) > +{ > + g_return_if_fail(WEBKIT_IS_NETWORK_RESPONSE(response)); > + g_return_if_fail(uri); > + > + WebKitNetworkResponsePrivate* priv = response->priv; > + > + g_free(priv->uri); > + priv->uri = g_strdup(uri); > + > + /* > + * feeding back to the ResourceResponse object, which is the one actually used > + * inside WebCore > + */ > + priv->response.setUrl(KURL(String::fromUTF8(uri))); > +} g_object_notify is missing. Can a native English speaker check if the documentation is ok? 87271 15 gustavo 2008-07-29 10:00:26 -0700 (In reply to comment #14) > Why a copy is then the request is copied again to priv->request? My bad. > Why do you have a separate webkit_network_request_private_get_http_headers? I can't use get_http_headers directly because of the const qualifier. And I still need a function so that I can lazily fill the hash table. > > + priv->response.setUrl(KURL(String::fromUTF8(uri))); > > +} > > g_object_notify is missing. NetworkResponse doesn't have properties, et al yet, and I plan to finish its implementation after NetworkRequest is done. I created a skeleton just because I needed a class to provide the signal with. 87311 16 marco.barisione 2008-07-29 13:57:28 -0700 (In reply to comment #15) > > Why do you have a separate webkit_network_request_private_get_http_headers? > > I can't use get_http_headers directly because of the const qualifier. And I > still need a function so that I can lazily fill the hash table. Oh, right. > > > + priv->response.setUrl(KURL(String::fromUTF8(uri))); > > > +} > > > > g_object_notify is missing. > > NetworkResponse doesn't have properties, et al yet, and I plan to finish its > implementation after NetworkRequest is done. I created a skeleton just because > I needed a class to provide the signal with. Ehm... I didn't notice that ;) 87343 17 22545 gustavo 2008-07-29 19:07:30 -0700 Created attachment 22545 proposed patch I think I addressed all of the comments now. 87407 18 22557 gustavo 2008-07-30 11:30:47 -0700 Created attachment 22557 proposed patch Christian Dywan advised me in another bug to add 'Since' tags to the documenation of the new created public methods. I decided to add them to this patch too, and took the oportunity to do some housekeeping and make sure everything is tidied up. 89547 19 22557 eric 2008-08-27 16:07:09 -0700 Comment on attachment 22557 proposed patch Assigning to Alp for review or for re-assignment to the appropriate Gtk reviewer. Most of us don't know anything about Gtk, so it's silly for this to be in the general review queue. 103504 20 christian 2008-12-26 14:43:55 -0800 (In reply to comment #18) > Created an attachment (id=22557) [review] > proposed patch Since we plan to actually expose libSoup API now, would it make sense to expose a SoupMessage here? It looks like WebKitNetworkRequest to some extend reflects what a 'message' does. While I doubt that either one can replace the other, a 'request' might for instance contain a 'message', for things like the method, uri, body and headers. But that's only an idea, it might be less good an idea in practise. Another point is caching, we only have memory caching. It might be good to figure out what the plan is, ie. if libSoup is going to feature caching, or if we rely on a proxy server to do that, or if WebKit itself should take care of it. And maybe refrain from introducing an option unless we know what it is going to affect. 103561 21 gustavo 2008-12-27 14:47:27 -0800 (In reply to comment #20) > (In reply to comment #18) > > Created an attachment (id=22557) [review] [review] > > proposed patch > > Since we plan to actually expose libSoup API now, would it make sense to expose > a SoupMessage here? It looks like WebKitNetworkRequest to some extend reflects > what a 'message' does. While I doubt that either one can replace the other, a > 'request' might for instance contain a 'message', for things like the method, > uri, body and headers. But that's only an idea, it might be less good an idea > in practise. > > Another point is caching, we only have memory caching. It might be good to > figure out what the plan is, ie. if libSoup is going to feature caching, or if > we rely on a proxy server to do that, or if WebKit itself should take care of > it. And maybe refrain from introducing an option unless we know what it is > going to affect. > I like the idea. Though I believe that we actually need to have the Message become a member of ResourceRequest (or ResourceHandle?) itself, and not be created in ResourceHandle::startHttp. We also need to figure out how to deal with non-HTTP stuff; should we have some kind of handling for that in ResourceRequest and WebKitNetworkRequest? This could be implemented in a way that the SoupMessage will only be instantiated when a .soupMessage() accessor method is called in ResourceRequest, and the good thing is this allows our users to access the SoupMessage (or GFile, in case of a local request, which will probably force us to decide on this earlier?) which will be used by the Soup backend, at willSendRequest already. 105889 22 26755 gustavo 2009-01-15 07:06:14 -0800 Created attachment 26755 Minimal functionality addition patch I rewrote my patch so that only the minimal functionality needed to get HTTP information correctly fed back into WebKit when client code passes along a WebKitNetworkRequest it received in a signal. This allows us to make it possible for browsers such as Epihany and Midori to open links in new tabs and still get Referer, for instance, correctly sent. Internal functionality (in WebkitWebFrame) is also improved. See comments bellow http://bugzilla.gnome.org/show_bug.cgi?id=120341#c12 for more reasoning. I provide this patch now so that we can get this working sooner rather than later, and no public API is touched, so we can discuss the merits of my proposed API later. 105903 23 26759 gustavo 2009-01-15 09:02:21 -0800 Created attachment 26759 Minimal functionality addition patch Small change requested by xan to avoid having 2 returns in 4 lines ;) 106530 24 26912 gustavo 2009-01-21 16:01:29 -0800 Created attachment 26912 proof of concept, so that we can discuss exposing SoupMessage This isn't ready for reviewing yet, so I'm not bothering adding a ChangeLog entry, and am adding GtkLauncher code to test. We need to figure out how to handle modifications of SoupMessage to apply to the actual request, and document them. It seems like modifying headers of the SoupMessage in the navigation-policy-decision-requested callback doesn't affect the actual request, for instance (even if I force an update of ResourceRequest from the SoupMessage). 106554 25 christian 2009-01-21 18:42:18 -0800 (In reply to comment #24) > Created an attachment (id=26912) [review] > proof of concept, so that we can discuss exposing SoupMessage > > This isn't ready for reviewing yet, so I'm not bothering adding a ChangeLog > entry, and am adding GtkLauncher code to test. We need to figure out how to > handle modifications of SoupMessage to apply to the actual request, and > document them. It seems like modifying headers of the SoupMessage in the > navigation-policy-decision-requested callback doesn't affect the actual > request, for instance (even if I force an update of ResourceRequest from the > SoupMessage). Hm.. I would think it's intuitive to modify the message and expect changes to take effect as if one had sent the message outside of WebKit. So if we can arrange that somehow that'd be great, not sure if there is any reason against that from WebCore. And just so it's not forgotten, an according property should be nice. 106627 26 26935 gustavo 2009-01-22 11:12:46 -0800 Created attachment 26935 minimal functionality This is a reworked patch to carry a pointer to the actual ResourceRequest instead of a copy. 106632 27 26937 gustavo 2009-01-22 12:06:53 -0800 Created attachment 26937 proof of concept for exposing SoupMessage I dislike the fact that the user will have to call webkit_network_request_refresh(), but it seems to be necessary right now, because soup doesn't provide means to know when headers got changed in any way. 112492 28 28342 gustavo 2009-03-05 17:43:37 -0800 Created attachment 28342 minimal functionality Updated to current code, and fixed style issues I was able to detect myself ;). 112496 29 gustavo 2009-03-05 17:57:11 -0800 (In reply to comment #28) > Created an attachment (id=28342) [review] > minimal functionality > > Updated to current code, and fixed style issues I was able to detect myself ;). > I forgot to update the ChangeLog after updating the patch, so some functions/classes that were edited are missing the auto-generated list. I have it up-to-date on my git branch, though, and will commit the correct one, if the patch is r+'ed. 113824 30 christian 2009-03-15 08:30:25 -0700 (In reply to comment #29) > (In reply to comment #28) > > Created an attachment (id=28342) [review] [review] > > minimal functionality > > > > Updated to current code, and fixed style issues I was able to detect myself ;). > > > > I forgot to update the ChangeLog after updating the patch, so some > functions/classes that were edited are missing the auto-generated list. I have > it up-to-date on my git branch, though, and will commit the correct one, if > the patch is r+'ed. I like how the patch works, keeping the request instead of only the URI is clearly much better. 114883 31 28877 gustavo 2009-03-23 17:10:58 -0700 Created attachment 28877 minimal funcionality Tired of seeing patches using just the uri from the request, I'll try to push this and be done with it =). 114885 32 28878 gustavo 2009-03-23 17:11:54 -0700 Created attachment 28878 expose SoupMessage 114894 33 christian 2009-03-23 17:40:20 -0700 +#include <libsoup/soup.h> +#include <libsoup/soup-message.h> Does libsoup actually require this? In that case *please* file a bug against libsoup to fix the include files. =) + * Gets the #SoupMessage held and used by the given request. Notice + * that most times WebKitGTK+ gives you a #WebKitNetworkRequest in + * signals, it's for informational purposes only. If you intend to + * modify the headers or data sent in a request manually, please read + * the documentation of the signal you are handling to see if that is + * supposed to work. I think this is a bit vague. Maybe we want to reword it slightly to stress that the message can always be read but only if documented as such do we support modifications. I think if we decide to speak about supported use cases it gives the API user an idea of relibability, whereas "supposed to work" gives the impression that it may work and break in any revision: + * Gets the #SoupMessage held and used by the given request. Notice + * that the message is mainly available for informational purposes. + * If you intend to modify the headers or data sent in a request + * manually, please read the documentation of the signal you are + * handling to see if that is supported. Always allowing to at least read out any information is already powerful, so if that speeds up review, we can discuss documentation of the supported cases where modifications are allowed as a follow up. 114917 34 xan.lopez 2009-03-24 00:11:15 -0700 + ResourceRequest* resourceRequest = new ResourceRequest(KURL(String::fromUTF8(uri))); Please use the two-arg KURL ctor, see https://bugs.webkit.org/show_bug.cgi?id=23761 for rationale. 114918 35 xan.lopez 2009-03-24 00:38:51 -0700 + SoupURI *soupURI = soup_message_get_uri(m_soupMessage); + + gchar *uri = soup_uri_to_string(soupURI, FALSE); The * are all wrong :) + m_url = KURL(String::fromUTF8(uri)); two-arg ctor. + while (soup_message_headers_iter_next(&headersIter, (const gchar**)&headerName, (const gchar**)&headerValue)) { C++ style castings? + gchar *headerName = 0; + gchar *headerValue = 0; No need to initialize? And * is wrong. + SoupURI *soupURI = soup_uri_new(url().string().utf8().data()); + soup_message_set_uri(m_soupMessage, soupURI); Leaking soupURI (and * is wrong). Stupid question: is it OK to free the message in doUpdate the way you do it? Shouldn't it go in a destructor or something similar? (And as said only including <libsoup/soup.h> works) And I guess now it's too late to ask about that conversation we had about using directly the soup objects/API without any wrappers like the other ports do? 114931 36 gustavo 2009-03-24 07:07:03 -0700 (In reply to comment #33) > + * Gets the #SoupMessage held and used by the given request. Notice > + * that most times WebKitGTK+ gives you a #WebKitNetworkRequest in > + * signals, it's for informational purposes only. If you intend to > + * modify the headers or data sent in a request manually, please read > + * the documentation of the signal you are handling to see if that is > + * supposed to work. > > I think this is a bit vague. Maybe we want to reword it slightly to stress that > the message can always be read but only if documented as such do we support > modifications. I think if we decide to speak about supported use cases it gives > the API user an idea of relibability, whereas "supposed to work" gives the > impression that it may work and break in any revision: Right. I will reword this a bit. Just for completeness, like I said in our IRC conversation, modification of the soup message will probably only be supported by the yet-to-be-implemented signal that is emitted when FrameLoaderClient's willSendRequest delegate is called. 114933 37 gustavo 2009-03-24 07:10:03 -0700 (In reply to comment #35) > Stupid question: is it OK to free the message in doUpdate the way you do it? > Shouldn't it go in a destructor or something similar? It looks OK to me. The thing is the request may have been "nullified", but not destroyed, and that code block handles this case. > (And as said only including <libsoup/soup.h> works) Right, thanks! > And I guess now it's too late to ask about that conversation we had about using > directly the soup objects/API without any wrappers like the other ports do? We are already using WebKitNetworkRequest objects all over the code. It may be a good thing to have it, anyway, if we need to extend the functionality of the object to do something that would not fit in libsoup. Just building to check if the fixed up patches are OK to upload, thanks for the comments! 114934 38 28889 gustavo 2009-03-24 07:43:49 -0700 Created attachment 28889 Make our NetworkRequest object functionally complete, by making it carry the ResourceRequest it represents with it. --- WebKit/gtk/ChangeLog | 28 +++++++ WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp | 7 +- WebKit/gtk/webkit/webkitdownload.cpp | 4 +- WebKit/gtk/webkit/webkitnetworkrequest.cpp | 78 ++++++++++++++++++- WebKit/gtk/webkit/webkitprivate.h | 11 +++- WebKit/gtk/webkit/webkitwebframe.cpp | 4 +- 6 files changed, 117 insertions(+), 15 deletions(-) 114935 39 28890 gustavo 2009-03-24 07:43:56 -0700 Created attachment 28890 Expose the SoupMessage of the request through our WebKitNetworkRequest object. --- WebCore/ChangeLog | 21 +++++ WebCore/GNUmakefile.am | 1 + .../platform/network/soup/ResourceHandleSoup.cpp | 10 +-- WebCore/platform/network/soup/ResourceRequest.h | 19 ++++- .../platform/network/soup/ResourceRequestSoup.cpp | 91 ++++++++++++++++++++ WebKit/gtk/ChangeLog | 14 +++ WebKit/gtk/webkit/webkitnetworkrequest.cpp | 21 +++++ WebKit/gtk/webkit/webkitnetworkrequest.h | 4 + 8 files changed, 170 insertions(+), 11 deletions(-) 114988 40 jmalonzo 2009-03-24 12:03:18 -0700 (In reply to comment #36) > (In reply to comment #33) > > + * Gets the #SoupMessage held and used by the given request. Notice > > + * that most times WebKitGTK+ gives you a #WebKitNetworkRequest in > > + * signals, it's for informational purposes only. If you intend to > > + * modify the headers or data sent in a request manually, please read > > + * the documentation of the signal you are handling to see if that is > > + * supposed to work. > > > > I think this is a bit vague. Maybe we want to reword it slightly to stress that > > the message can always be read but only if documented as such do we support > > modifications. I think if we decide to speak about supported use cases it gives > > the API user an idea of relibability, whereas "supposed to work" gives the > > impression that it may work and break in any revision: > > Right. I will reword this a bit. Just for completeness, like I said in our IRC > conversation, modification of the soup message will probably only be supported > by the yet-to-be-implemented signal that is emitted when FrameLoaderClient's > willSendRequest delegate is called. Mac actually supports this in their API. For example the WebDataSource::resource method has the following doc: "The URL returned may be different from the original request. A WebView’s resource load delegate may modify requests by implementing webView:resource:willSendRequest:redirectResponse:fromDataSource:" 114995 41 28889 jmalonzo 2009-03-24 12:23:33 -0700 Comment on attachment 28889 Make our NetworkRequest object functionally complete, by making it > diff --git a/WebKit/gtk/webkit/webkitdownload.cpp b/WebKit/gtk/webkit/webkitdownload.cpp > index 4488304..3bceedc 100644 > --- a/WebKit/gtk/webkit/webkitdownload.cpp > +++ b/WebKit/gtk/webkit/webkitdownload.cpp > @@ -416,9 +416,7 @@ void webkit_download_start(WebKitDownload* download) > if (priv->resourceHandle) > priv->resourceHandle->setClient(priv->downloadClient); > else { > - // FIXME: Use the actual request object when WebKitNetworkRequest is finished. > - ResourceRequest request(webkit_network_request_get_uri(priv->networkRequest)); > - priv->resourceHandle = ResourceHandle::create(request, priv->downloadClient, 0, false, false, false); > + priv->resourceHandle = ResourceHandle::create(*webkit_network_request_get_core_request(priv->networkRequest), priv->downloadClient, 0, false, false, false); Should this be core(priv->networkRequest)? For objects that wrap WebCore objects, we use core/kit to get the respective objects. > > +// The mustFreeRequest variable here is used to store if the > +// ResourceRequest we are storing is owned by us or by WebCore; this > +// won't be needed when/if ResourceRequest is reference counted. > struct _WebKitNetworkRequestPrivate { > gchar* uri; Can we use CString here? WebKitWebHistoryItem uses CStrings to make memory management easier. > +ResourceRequest* webkit_network_request_get_core_request(const WebKitNetworkRequest* request) > +{ Change this to core? > + WebKitNetworkRequest* > + webkit_network_request_new_with_core_request(const WebCore::ResourceRequest& resourceRequest); > + > + WebCore::ResourceRequest* > + webkit_network_request_get_core_request(const WebKitNetworkRequest* request); > + Make this 'core'. > - // TODO: Use the ResourceRequest carried by WebKitNetworkRequest when it is implemented. > - String string = String::fromUTF8(webkit_network_request_get_uri(request)); > - coreFrame->loader()->load(ResourceRequest(KURL(KURL(), string)), false); > + coreFrame->loader()->load(const_cast<ResourceRequest&>(*webkit_network_request_get_core_request(request)), false); same - core. 115053 42 gustavo 2009-03-24 15:04:08 -0700 (In reply to comment #40) > Mac actually supports this in their API. For example the > WebDataSource::resource method has the following doc: > > "The URL returned may be different from the original request. A WebView’s > resource load delegate may modify requests by implementing > webView:resource:willSendRequest:redirectResponse:fromDataSource:" > Yep. My original patch also implemented willSendRequest as a signal, but we decided to remove it from this patch, and add it later, or through the frameloaders rework. 115059 43 gustavo 2009-03-24 15:27:51 -0700 (In reply to comment #41) > Should this be core(priv->networkRequest)? For objects that wrap WebCore > objects, we use core/kit to get the respective objects. I had written that change, but went back on it because there would be no obvious way of implementing a matching kit(). I have done it for the patch I'm about to post, though. We can think of a good way of implemementing kit() afterwards. > Can we use CString here? WebKitWebHistoryItem uses CStrings to make memory > management easier. After writing half the patch, I decided using CString wouldn't make the code cleaner at all, in my opinion, so I would prefer not changing the way it looks like right now, regarding this, is that OK with you? 115062 44 28913 gustavo 2009-03-24 15:31:03 -0700 Created attachment 28913 Make our NetworkRequest object functionally complete, by making it carry the ResourceRequest it represents with it. --- WebKit/gtk/ChangeLog | 28 +++++++ WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp | 7 +- WebKit/gtk/webkit/webkitdownload.cpp | 4 +- WebKit/gtk/webkit/webkitnetworkrequest.cpp | 78 ++++++++++++++++++- WebKit/gtk/webkit/webkitprivate.h | 11 +++- WebKit/gtk/webkit/webkitwebframe.cpp | 4 +- 6 files changed, 117 insertions(+), 15 deletions(-) 115063 45 28913 gustavo 2009-03-24 15:32:04 -0700 Comment on attachment 28913 Make our NetworkRequest object functionally complete, by making it Most comments by janm adresed. 122522 46 eric 2009-05-21 20:18:01 -0700 There has been no activity on this bug in over 2 months. Can we assume it's dead and close it? Please advise. 122524 47 eric 2009-05-21 20:22:31 -0700 janm said over IRC he would review these tonight when he gets home. 122756 48 28890 jmalonzo 2009-05-22 18:19:32 -0700 Comment on attachment 28890 Expose the SoupMessage of the request through our WebKitNetworkRequest > diff --git a/WebCore/GNUmakefile.am b/WebCore/GNUmakefile.am > index ffaf1b2..34f2d9a 100644 > --- a/WebCore/GNUmakefile.am > +++ b/WebCore/GNUmakefile.am > @@ -1839,6 +1839,7 @@ webcore_sources += \ > WebCore/platform/network/soup/DNSSoup.cpp \ > WebCore/platform/network/soup/ResourceError.h \ > WebCore/platform/network/soup/ResourceHandleSoup.cpp \ > + WebCore/platform/network/soup/ResourceRequestSoup.cpp \ Don't forget to add this in webcoregtk_sources instead. > diff --git a/WebCore/platform/network/soup/ResourceRequestSoup.cpp b/WebCore/platform/network/soup/ResourceRequestSoup.cpp > new file mode 100644 > index 0000000..088b7bd > --- /dev/null > +++ b/WebCore/platform/network/soup/ResourceRequestSoup.cpp > + > +void ResourceRequest::doUpdateResourceRequest() > +{ > + SoupURI* soupURI = soup_message_get_uri(m_soupMessage); > + > + gchar* uri = soup_uri_to_string(soupURI, FALSE); > + m_url = KURL(KURL(), String::fromUTF8(uri)); > + g_free(uri); > + > + m_httpMethod = String::fromUTF8(m_soupMessage->method); > + > + m_httpHeaderFields.clear(); We'll be losing what's already in the header fields if we clear this. Is there a reason why this should be cleared? > + > + SoupMessageHeadersIter headersIter; > + const char* headerName; > + const char* headerValue; > + > + soup_message_headers_iter_init(&headersIter, m_soupMessage->request_headers); > + while (soup_message_headers_iter_next(&headersIter, &headerName, &headerValue)) > + m_httpHeaderFields.set(String::fromUTF8(headerName), String::fromUTF8(headerValue)); > + > + m_httpBody = FormData::create(m_soupMessage->request_body->data, m_soupMessage->request_body->length); > +} what about m_allowHTTPCookies and m_alloFirstPartyForCookies? Do we need to update them too? > + > +void ResourceRequest::doUpdatePlatformRequest() > +{ > + if (isNull()) { > + if (m_soupMessage) > + g_object_unref(m_soupMessage); > + m_soupMessage = 0; > + return; > + } > + > + if (!m_soupMessage) > + m_soupMessage = soup_message_new(httpMethod().utf8().data(), url().string().utf8().data()); > + else { > + SoupURI* soupURI = soup_uri_new(url().string().utf8().data()); > + soup_message_set_uri(m_soupMessage, soupURI); > + soup_uri_free(soupURI); > + > + g_object_set(m_soupMessage, "method", httpMethod().utf8().data(), NULL); > + } > + soup_message_headers_clear(m_soupMessage->request_headers); > + > + HTTPHeaderMap headers = httpHeaderFields(); > + SoupMessageHeaders *soupHeaders = m_soupMessage->request_headers; > + if (!headers.isEmpty()) { > + HTTPHeaderMap::const_iterator end = headers.end(); > + for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it) > + soup_message_headers_append(soupHeaders, it->first.string().utf8().data(), it->second.utf8().data()); > + } Same question re updating cookies. > + > + // Body data is only handlded at ResourceHandleSoup::startHttp Is there a reason why we're doing it there? > diff --git a/WebKit/gtk/webkit/webkitnetworkrequest.cpp b/WebKit/gtk/webkit/webkitnetworkrequest.cpp > index 1e3ef2c..dc50fef 100644 > --- a/WebKit/gtk/webkit/webkitnetworkrequest.cpp > +++ b/WebKit/gtk/webkit/webkitnetworkrequest.cpp > @@ -174,4 +174,25 @@ G_CONST_RETURN gchar* webkit_network_request_get_uri(WebKitNetworkRequest* reque > return priv->uri; > } > > +/** > + * webkit_network_request_get_soup_message: Can't we just use get_message here to make the name not depend on the library we're using? The return type already specify that it's a SoupMessage so it's just making it redundant by adding _soup_ to the function name. > + * @request: a #WebKitNetworkRequest > + * > + * Obtains the #SoupMessage held and used by the given request. Notice > + * that modification of the SoupMessage of a request by signal > + * handlers is only supported where explicitly documented. Can you expound or rephrase this? I don't quite understand what the doc mean here in terms of modifying the SoupMessage. Patch is fine nevertheless. Another gtk+ reviewer needs to ACK on the API too. 122762 49 gustavo 2009-05-22 19:27:57 -0700 (In reply to comment #48) > > + WebCore/platform/network/soup/ResourceRequestSoup.cpp \ > > Don't forget to add this in webcoregtk_sources instead. OK! > > +void ResourceRequest::doUpdateResourceRequest() [...] > > + m_httpHeaderFields.clear(); > > We'll be losing what's already in the header fields if we clear this. Is there > a reason why this should be cleared? This function assumes that the ResourceRequest information is outdated and needs to be updated from the SoupMessage. There should be no case in which both are 'dirty', so clearing what is in the ResourceRequest object is the right way to go here. Having said that, no other port does it, it seems, so it may not be needed, and I'm OK with removing this call. > > + m_httpBody = FormData::create(m_soupMessage->request_body->data, m_soupMessage->request_body->length); > > +} > > what about m_allowHTTPCookies and m_alloFirstPartyForCookies? Do we need to > update them too? We don't do anything with those right now, and I'm not sure how this could be implemented. I'd prefer handling this in a later patch, if need be. > > + > > + // Body data is only handlded at ResourceHandleSoup::startHttp > > Is there a reason why we're doing it there? That's mostly me being careful for this first patch. Body data handling is kinda complex in our port, possibly involving mmaping files and stuff, I preferred leaving it where it is. I remember having a specific problem, but it's gone from my mind right now. > Can't we just use get_message here to make the name not depend on the library > we're using? The return type already specify that it's a SoupMessage so it's > just making it redundant by adding _soup_ to the function name. Sounds good to me. I have no strong feelings regarding this. > > + * Obtains the #SoupMessage held and used by the given request. Notice > > + * that modification of the SoupMessage of a request by signal > > + * handlers is only supported where explicitly documented. > > Can you expound or rephrase this? I don't quite understand what the doc mean > here in terms of modifying the SoupMessage. This is because changes to the ResourceRequest are only supported in willSendRequest. You can fetch the SoupMessage while handling stuff such as navigation-policy-decision-requested, but it's not guaranteed that your changes will do anything. So we would document, in the signal mapping willSendRequest, that you can edit the message there. 122778 50 28913 jmalonzo 2009-05-22 20:28:36 -0700 Comment on attachment 28913 Make our NetworkRequest object functionally complete, by making it As kov suggested, it would be better to grab a SoupMessage ref from ResourceRequest rather than carrying a ResourceRequest around. r- as discussed to have this patch reworked. 122779 51 28890 jmalonzo 2009-05-22 20:29:59 -0700 Comment on attachment 28890 Expose the SoupMessage of the request through our WebKitNetworkRequest Patch needs rework due to https://bugs.webkit.org/attachment.cgi?id=28913 being reworked. r- for now. 122796 52 30604 gustavo 2009-05-22 22:07:01 -0700 Created attachment 30604 Make NetworkRequest carry a reference of the SoupMessage used by ResourceRequest WebCore/ChangeLog | 18 ++++ WebCore/GNUmakefile.am | 1 + .../platform/network/soup/ResourceHandleSoup.cpp | 10 +-- WebCore/platform/network/soup/ResourceRequest.h | 19 ++++- .../platform/network/soup/ResourceRequestSoup.cpp | 93 ++++++++++++++++++++ WebKit/gtk/ChangeLog | 23 +++++ WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp | 6 +- WebKit/gtk/webkit/webkitdownload.cpp | 7 +- WebKit/gtk/webkit/webkitnetworkrequest.cpp | 44 +++++++++- WebKit/gtk/webkit/webkitprivate.h | 12 +++- WebKit/gtk/webkit/webkitwebframe.cpp | 4 +- 11 files changed, 213 insertions(+), 24 deletions(-) 122823 53 30604 jmalonzo 2009-05-23 01:09:19 -0700 Comment on attachment 30604 Make NetworkRequest carry a reference of the SoupMessage used by ResourceRequest > + ResourceRequest(SoupMessage* soupMessage) > + : ResourceRequestBase() > + , m_soupMessage(soupMessage) > + { > + } > + Would be nice if we can initialize ResourceRequestBast as ResourceRequestBase(KURL(), UseProtocolCachePolicy) > +void ResourceRequest::doUpdateResourceRequest() > +{ > + SoupURI* soupURI = soup_message_get_uri(m_soupMessage); We need to null-check m_soupMessage here just in case updatePlatformRequest hasn't been called. > + gchar* uri = soup_uri_to_string(soupURI, FALSE); > + m_url = KURL(KURL(), String::fromUTF8(uri)); > + g_free(uri); no need to create uri. Just put the call inside fromUTF8(). > + > + m_httpBody = FormData::create(m_soupMessage->request_body->data, m_soupMessage->request_body->length); > +} Can we add a FIXME for the cookies stuff to be updated once we figure out how to do that? Thanks. > + > +void ResourceRequest::doUpdatePlatformRequest() > +{ > + if (isNull()) { > + if (m_soupMessage) > + g_object_unref(m_soupMessage); > + m_soupMessage = 0; > + return; > + } > + > + if (!m_soupMessage) { > + m_soupMessage = soup_message_new(httpMethod().utf8().data(), url().string().utf8().data()); > + > + if (!m_soupMessage) > + return; > + } else { > + SoupURI* soupURI = soup_uri_new(url().string().utf8().data()); > + soup_message_set_uri(m_soupMessage, soupURI); > + soup_uri_free(soupURI); I think we can avoid initializing a soupURI here by moving soup_uri_new in the call to soup_message_set_uri(). > + > + g_object_set(m_soupMessage, "method", httpMethod().utf8().data(), NULL); > + > + soup_message_headers_clear(m_soupMessage->request_headers); > + } I think we can lose the else block since here since we only need to make sure we have a m_soupMessage before doing anything. > + > + HTTPHeaderMap headers = httpHeaderFields(); > + SoupMessageHeaders* soupHeaders = m_soupMessage->request_headers; > + if (!headers.isEmpty()) { > + HTTPHeaderMap::const_iterator end = headers.end(); > + for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it) > + soup_message_headers_append(soupHeaders, it->first.string().utf8().data(), it->second.utf8().data()); > + } > + > + // Body data is only handlded at ResourceHandleSoup::startHttp handlded -> handled. Maybe a good idea to put the rationale here why we're doing it in startHttp(). Looking good. I'm going to r- this for now until the trivial issues above are addressed. Cheers 122837 54 gustavo 2009-05-23 05:54:24 -0700 (In reply to comment #53) > (From update of attachment 30604 [review]) > > + ResourceRequest(SoupMessage* soupMessage) > > + : ResourceRequestBase() > > + , m_soupMessage(soupMessage) > > + { > > + } > > + > > Would be nice if we can initialize ResourceRequestBast as > ResourceRequestBase(KURL(), UseProtocolCachePolicy) Why? The parameter-less variant is there for this specific use case (creating a ResourceRequest from the platform network object), so I think it is the appropriate one. > > +void ResourceRequest::doUpdateResourceRequest() > > +{ > > + SoupURI* soupURI = soup_message_get_uri(m_soupMessage); > > We need to null-check m_soupMessage here just in case updatePlatformRequest > hasn't been called. Or has returned without being able to create the message for some reason. > > + gchar* uri = soup_uri_to_string(soupURI, FALSE); > > + m_url = KURL(KURL(), String::fromUTF8(uri)); > > + g_free(uri); > > no need to create uri. Just put the call inside fromUTF8(). I think we need. fromUTF8 will copy the string, so we need to free the original somehow. Perhaps we can use GOwnPtr. > Can we add a FIXME for the cookies stuff to be updated once we figure out how > to do that? Thanks. Sure. > > + SoupURI* soupURI = soup_uri_new(url().string().utf8().data()); > > + soup_message_set_uri(m_soupMessage, soupURI); > > + soup_uri_free(soupURI); > > I think we can avoid initializing a soupURI here by moving soup_uri_new in the > call to soup_message_set_uri(). Same problem as with the uri string. > I think we can lose the else block since here since we only need to make sure > we have a m_soupMessage before doing anything. Right! > handlded -> handled. Maybe a good idea to put the rationale here why we're > doing it in startHttp(). ok 122907 55 30623 gustavo 2009-05-23 21:20:38 -0700 Created attachment 30623 Make NetworkRequest carry a reference of the SoupMessage used by ResourceRequest --- WebCore/ChangeLog | 22 ++++ WebCore/GNUmakefile.am | 1 + .../platform/network/soup/ResourceHandleSoup.cpp | 42 ++++---- WebCore/platform/network/soup/ResourceRequest.h | 29 +++++- .../platform/network/soup/ResourceRequestSoup.cpp | 114 ++++++++++++++++++++ WebKit/gtk/ChangeLog | 24 ++++ WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp | 6 +- WebKit/gtk/webkit/webkitdownload.cpp | 7 +- WebKit/gtk/webkit/webkitnetworkrequest.cpp | 51 +++++++++- WebKit/gtk/webkit/webkitprivate.h | 12 ++- WebKit/gtk/webkit/webkitwebframe.cpp | 4 +- 11 files changed, 274 insertions(+), 38 deletions(-) 122908 56 30623 gustavo 2009-05-23 21:22:36 -0700 Comment on attachment 30623 Make NetworkRequest carry a reference of the SoupMessage used by One more try. Notice that most of the improved life cycle checks and safe guards are needed because the SoupMessage is not limited to being used inside ResourceHandle. We had an implicit assumption, for instance, that the message would be gone after finishedCallback, and that may not be true now. 122977 57 30634 gustavo 2009-05-24 14:08:35 -0700 Created attachment 30634 Make NetworkRequest carry a reference of the SoupMessage used by ResourceRequest --- ChangeLog | 9 ++ GNUmakefile.am | 8 +- WebCore/ChangeLog | 23 +++ WebCore/GNUmakefile.am | 1 + .../platform/network/soup/ResourceHandleSoup.cpp | 48 ++++--- WebCore/platform/network/soup/ResourceRequest.h | 32 ++++- .../platform/network/soup/ResourceRequestSoup.cpp | 142 ++++++++++++++++++++ WebKit/gtk/ChangeLog | 24 ++++ WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp | 6 +- WebKit/gtk/webkit/webkitdownload.cpp | 7 +- WebKit/gtk/webkit/webkitnetworkrequest.cpp | 51 +++++++- WebKit/gtk/webkit/webkitprivate.h | 13 ++- WebKit/gtk/webkit/webkitwebframe.cpp | 4 +- 13 files changed, 329 insertions(+), 39 deletions(-) 122978 58 30634 gustavo 2009-05-24 14:11:47 -0700 Comment on attachment 30634 Make NetworkRequest carry a reference of the SoupMessage used by This time with a simple unit test. It needs to be enhanced to use something such as a SoupServer. Using something that is not an HTTP server is no good, since that is exactly what we want to try out. 123508 59 30634 jmalonzo 2009-05-28 18:43:17 -0700 Comment on attachment 30634 Make NetworkRequest carry a reference of the SoupMessage used by > diff --git a/WebCore/platform/network/soup/ResourceRequestSoup.cpp b/WebCore/platform/network/soup/ResourceRequestSoup.cpp > +template <> void freeOwnedGPtr<SoupURI>(SoupURI* uri) > +{ > + if (uri) > + soup_uri_free(uri); Please fix the spacing here. > +using namespace std; Please move this after the include so it's more visible. > +ResourceRequest::ResourceRequest(const ResourceRequest& resourceRequest) > + : ResourceRequestBase(resourceRequest) > + , m_soupMessage(0) > +{ > + m_url = resourceRequest.url().copy(); > + m_firstPartyForCookies = resourceRequest.firstPartyForCookies().copy(); > + m_httpMethod = resourceRequest.httpMethod().copy(); > + m_httpHeaderFields.adopt(auto_ptr<CrossThreadHTTPHeaderMapData>(resourceRequest.m_httpHeaderFields.copyData().release())); Please convert this to use PassOwnPtr instead of auto_ptr. > + > + size_t encodingCount = resourceRequest.m_responseContentDispositionEncodingFallbackArray.size(); > + if (encodingCount > 0) { > + String encoding1 = resourceRequest.m_responseContentDispositionEncodingFallbackArray[0]; > + String encoding2; > + String encoding3; > + if (encodingCount > 1) { > + encoding2 = resourceRequest.m_responseContentDispositionEncodingFallbackArray[1]; > + if (encodingCount > 2) > + encoding3 = resourceRequest.m_responseContentDispositionEncodingFallbackArray[2]; > + } > + ASSERT(encodingCount <= 3); > + setResponseContentDispositionEncodingFallbackArray(encoding1, encoding2, encoding3); > + } > + if (resourceRequest.m_httpBody) > + setHTTPBody(resourceRequest.httpBody()); > + > + m_resourceRequestUpdated = true; > + m_platformRequestUpdated = false; should these be in updatePlatformRequest instead of the constructor? > +void ResourceRequest::doUpdatePlatformRequest() > +{ > + if (isNull()) { > + if (m_soupMessage) > + g_object_unref(m_soupMessage); > + m_soupMessage = 0; > + return; > + } Are we being too aggressive here? Is the call in ResourceRequest's destructor not enough? > + > + GOwnPtr<SoupURI> soupURI(soup_uri_new(url().string().utf8().data())); > + ASSERT(soupURI.get()); ASSERT(soupURI) should be enough. Looks good. 123514 60 gustavo 2009-05-28 19:38:26 -0700 > > + m_resourceRequestUpdated = true; > > + m_platformRequestUpdated = false; > > should these be in updatePlatformRequest instead of the constructor? No, these should be set in the constructor (and setters, wherever it makes sense). updatePlatformRequest, and updateResourceRequest checks for them to figure out if it should do anything at all, so setting them there is wrong. > > +void ResourceRequest::doUpdatePlatformRequest() > > +{ > > + if (isNull()) { > > + if (m_soupMessage) > > + g_object_unref(m_soupMessage); > > + m_soupMessage = 0; > > + return; > > + } > > Are we being too aggressive here? Is the call in ResourceRequest's destructor > not enough? I believe so. I checked other ports code, and they have no code dealing with this code. I can't see this case happening, from my reading ot the code, too. I'll try the code with removing this block of code for a bit to see if I spot any crashes. > > + GOwnPtr<SoupURI> soupURI(soup_uri_new(url().string().utf8().data())); > > + ASSERT(soupURI.get()); > > ASSERT(soupURI) should be enough. > > Looks good. So r=you, with PassOwnPtr, the style fixes, my clarification on the member variables initialization, the isNull() code removed, and this change? ;) Let me upload the updated patch. 123515 61 30763 gustavo 2009-05-28 19:39:35 -0700 Created attachment 30763 network request ChangeLog | 9 ++ GNUmakefile.am | 8 +- WebCore/ChangeLog | 23 ++++ WebCore/GNUmakefile.am | 1 + .../platform/network/soup/ResourceHandleSoup.cpp | 48 ++++--- WebCore/platform/network/soup/ResourceRequest.h | 32 +++++- .../platform/network/soup/ResourceRequestSoup.cpp | 135 ++++++++++++++++++++ WebKit/gtk/ChangeLog | 24 ++++ WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp | 6 +- WebKit/gtk/tests/testhttpbackend.c | 121 ++++++++++++++++++ WebKit/gtk/webkit/webkitdownload.cpp | 7 +- WebKit/gtk/webkit/webkitnetworkrequest.cpp | 51 +++++++- WebKit/gtk/webkit/webkitprivate.h | 13 ++- WebKit/gtk/webkit/webkitwebframe.cpp | 4 +- 14 files changed, 443 insertions(+), 39 deletions(-) 123516 62 30763 jmalonzo 2009-05-28 20:02:14 -0700 Comment on attachment 30763 network request Ok. r=me. 123549 63 30763 gustavo 2009-05-29 08:05:59 -0700 Comment on attachment 30763 network request Landed as r44263; I had to go back on the auto_ptr->PassOwnPtr conversion, though, since the adopt method cannot take a PassOwnPtr, and I didn't think this patch should also change that, hope that is OK. 123635 64 30763 jmalonzo 2009-05-29 15:58:52 -0700 Comment on attachment 30763 network request Clearing r+ flag so it won't appear in the commit queue. 123649 65 gustavo 2009-05-29 16:27:34 -0700 I'm closing this bug, and will open a new one for the API proposals. 20681 2008-04-18 18:23:45 -0700 2008-04-28 18:16:44 -0700 draft patch implementing method and http_headers properties webkitnetworkrequest.diff text/plain 6848 gustavo SW5kZXg6IFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAJKHJldmlzaW9uIDMy MjQwKQorKysgV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCSh3b3JraW5n IGNvcHkpCkBAIC0yNDUsNyArMjQ1LDcgQEAKICAgICAgICAgcmV0dXJuOwogCiAgICAgV2ViS2l0 V2ViVmlldyogd2ViVmlldyA9IGdldFZpZXdGcm9tRnJhbWUobV9mcmFtZSk7Ci0gICAgV2ViS2l0 TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ldyhyZXNv dXJjZVJlcXVlc3QudXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisgICAgV2ViS2l0TmV0 d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld19mcm9tX3Jl c291cmNlX3JlcXVlc3QocmVzb3VyY2VSZXF1ZXN0KTsKICAgICBXZWJLaXROYXZpZ2F0aW9uUmVz cG9uc2UgcmVzcG9uc2U7CiAKICAgICBnX3NpZ25hbF9lbWl0X2J5X25hbWUod2ViVmlldywgIm5h dmlnYXRpb24tcmVxdWVzdGVkIiwgbV9mcmFtZSwgcmVxdWVzdCwgJnJlc3BvbnNlKTsKSW5kZXg6 IHdlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gd2Via2l0L3dl YmtpdG5ldHdvcmtyZXF1ZXN0LmNwcAkocmV2aXNpb24gMzIyNDApCisrKyB3ZWJraXQvd2Via2l0 bmV0d29ya3JlcXVlc3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yMSwxMiArMjEsMjAgQEAKIAog I2luY2x1ZGUgIndlYmtpdG5ldHdvcmtyZXF1ZXN0LmgiCiAKKyNpbmNsdWRlICJQbGF0Zm9ybVN0 cmluZy5oIgorI2luY2x1ZGUgIlJlc291cmNlUmVxdWVzdC5oIgorI2luY2x1ZGUgIkNTdHJpbmcu aCIKKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKIGV4dGVybiAiQyIgewogCiBHX0RFRklO RV9UWVBFKFdlYktpdE5ldHdvcmtSZXF1ZXN0LCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0LCBHX1RZ UEVfT0JKRUNUKTsKIAogc3RydWN0IF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUgewogICAg IGdjaGFyKiB1cmk7CisgICAgZ2NoYXIqIGh0dHBfbWV0aG9kOworICAgIEdIYXNoVGFibGUgKmh0 dHBfaGVhZGVyczsKIH07CiAKICNkZWZpbmUgV0VCS0lUX05FVFdPUktfUkVRVUVTVF9HRVRfUFJJ VkFURShvYmopIChHX1RZUEVfSU5TVEFOQ0VfR0VUX1BSSVZBVEUoKG9iaiksIFdFQktJVF9UWVBF X05FVFdPUktfUkVRVUVTVCwgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKSkKQEAgLTM3LDYg KzQ1LDggQEAKICAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0 LT5wcml2OwogCiAgICAgZ19mcmVlKHByaXYtPnVyaSk7CisgICAgZ19mcmVlKHByaXYtPmh0dHBf bWV0aG9kKTsKKyAgICBnX2hhc2hfdGFibGVfZGVzdHJveShwcml2LT5odHRwX2hlYWRlcnMpOwog CiAgICAgR19PQkpFQ1RfQ0xBU1Mod2Via2l0X25ldHdvcmtfcmVxdWVzdF9wYXJlbnRfY2xhc3Mp LT5maW5hbGl6ZShvYmplY3QpOwogfQpAQCAtNTQsNiArNjQsMjYgQEAKICAgICByZXF1ZXN0LT5w cml2ID0gcHJpdjsKIH0KIAorLy8gZm9yIGludGVybmFsIHVzZSBvbmx5CitXZWJLaXROZXR3b3Jr UmVxdWVzdCogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfZnJvbV9yZXNvdXJjZV9yZXF1ZXN0 KGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0KQoreworICAgIFdlYktpdE5l dHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gV0VCS0lUX05FVFdPUktfUkVRVUVTVChnX29iamVjdF9u ZXcoV0VCS0lUX1RZUEVfTkVUV09SS19SRVFVRVNULCBOVUxMKSk7CisgICAgV2ViS2l0TmV0d29y a1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIHByaXYtPnVyaSA9 IGdfc3RyZHVwKHJlc291cmNlUmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsK KyAgICBwcml2LT5odHRwX21ldGhvZCA9IGdfc3RyZHVwKHJlc291cmNlUmVxdWVzdC5odHRwTWV0 aG9kKCkudXRmOCgpLmRhdGEoKSk7CisKKyAgICBwcml2LT5odHRwX2hlYWRlcnMgPSBnX2hhc2hf dGFibGVfbmV3X2Z1bGwoZ19zdHJfaGFzaCwgZ19zdHJfZXF1YWwsIGdfZnJlZSwgZ19mcmVlKTsK KyAgICBIVFRQSGVhZGVyTWFwIGhlYWRlcnMgPSByZXNvdXJjZVJlcXVlc3QuaHR0cEhlYWRlckZp ZWxkcygpOworICAgIGlmICghaGVhZGVycy5pc0VtcHR5KCkpIHsKKyAgICAgICAgSFRUUEhlYWRl ck1hcDo6Y29uc3RfaXRlcmF0b3IgZW5kID0gaGVhZGVycy5lbmQoKTsKKyAgICAgICAgZm9yIChI VFRQSGVhZGVyTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IGhlYWRlcnMuYmVnaW4oKTsgaXQgIT0g ZW5kOyArK2l0KQorICAgICAgICAgICAgZ19oYXNoX3RhYmxlX2luc2VydChwcml2LT5odHRwX2hl YWRlcnMsIChncG9pbnRlcilnX3N0cmR1cChpdC0+Zmlyc3QudXRmOCgpLmRhdGEoKSksIChncG9p bnRlcilnX3N0cmR1cChpdC0+c2Vjb25kLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICB9CisKKyAgICBy ZXR1cm4gcmVxdWVzdDsKK30KKwogV2ViS2l0TmV0d29ya1JlcXVlc3QqIHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfbmV3KGNvbnN0IGdjaGFyKiB1cmkpCiB7CiAgICAgZ19yZXR1cm5fdmFsX2lmX2Zh aWwodXJpLCBOVUxMKTsKQEAgLTg1LDQgKzExNSw3MyBAQAogICAgIHJldHVybiBwcml2LT51cmk7 CiB9CiAKK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9tZXRob2QoV2ViS2l0 TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX21ldGhvZCkKK3sKKyAg ICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOwor ICAgIGdfcmV0dXJuX2lmX2ZhaWwoaHR0cF9tZXRob2QpOworCisgICAgV2ViS2l0TmV0d29ya1Jl cXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIGdfZnJlZShwcml2LT5o dHRwX21ldGhvZCk7CisgICAgcHJpdi0+aHR0cF9tZXRob2QgPSBnX3N0cmR1cChodHRwX21ldGhv ZCk7CiB9CisKK2NvbnN0IGdjaGFyKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX21l dGhvZChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBnX3JldHVybl92YWxf aWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKKworICAg IFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisgICAg cmV0dXJuIHByaXYtPmh0dHBfbWV0aG9kOworfQorCitzdGF0aWMgdm9pZCBjb3B5X2hlYWRlcihj b25zdCBnY2hhcioga2V5LCBjb25zdCBnY2hhciogdmFsdWUsIGdwb2ludGVyIGRhdGEpCit7Cisg ICAgR0hhc2hUYWJsZSAqbmV3X2hhc2hfdGFibGUgPSAoR0hhc2hUYWJsZSopZGF0YTsKKworICAg IGdfaGFzaF90YWJsZV9pbnNlcnQobmV3X2hhc2hfdGFibGUsIChncG9pbnRlcilrZXksIChncG9p bnRlcil2YWx1ZSk7Cit9CisKK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9o ZWFkZXJzKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBHSGFzaFRhYmxlKiBo dHRwX2hlYWRlcnMpCit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19S RVFVRVNUKHJlcXVlc3QpKTsKKyAgICBnX3JldHVybl9pZl9mYWlsKGh0dHBfaGVhZGVycyk7CisK KyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2Owor CisgICAgZ19oYXNoX3RhYmxlX2Rlc3Ryb3kocHJpdi0+aHR0cF9oZWFkZXJzKTsKKyAgICBwcml2 LT5odHRwX2hlYWRlcnMgPSBnX2hhc2hfdGFibGVfbmV3X2Z1bGwoZ19zdHJfaGFzaCwgZ19zdHJf ZXF1YWwsIGdfZnJlZSwgZ19mcmVlKTsKKyAgICBnX2hhc2hfdGFibGVfZm9yZWFjaCgoR0hhc2hU YWJsZSopaHR0cF9oZWFkZXJzLCAoR0hGdW5jKWNvcHlfaGVhZGVyLCBwcml2LT5odHRwX2hlYWRl cnMpOworfQorCitjb25zdCBHSGFzaFRhYmxlKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9o dHRwX2hlYWRlcnMoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgZ19yZXR1 cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgTlVMTCk7 CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2 OworICAgIHJldHVybiBwcml2LT5odHRwX2hlYWRlcnM7Cit9CisKK3ZvaWQgd2Via2l0X25ldHdv cmtfcmVxdWVzdF9zZXRfaHR0cF9oZWFkZXIoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3Qs IGNvbnN0IGdjaGFyKiBodHRwX2hlYWRlciwgY29uc3QgZ2NoYXIqIHZhbHVlKQoreworICAgIGdf cmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CisgICAg Z19yZXR1cm5faWZfZmFpbChodHRwX2hlYWRlcik7CisgICAgZ19yZXR1cm5faWZfZmFpbCh2YWx1 ZSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5w cml2OworICAgIEdIYXNoVGFibGUqIGhlYWRlcnMgPSBwcml2LT5odHRwX2hlYWRlcnM7CisKKyAg ICBnX2hhc2hfdGFibGVfcmVwbGFjZShoZWFkZXJzLCBnX3N0cmR1cChodHRwX2hlYWRlciksIGdf c3RyZHVwKHZhbHVlKSk7Cit9CisKK2NvbnN0IGdjaGFyKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X2dldF9odHRwX2hlYWRlciAoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdj aGFyKiBodHRwX2hlYWRlcikKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNf TkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKKyAgICBnX3JldHVybl92YWxfaWZfZmFp bChodHRwX2hlYWRlciwgTlVMTCk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUq IHByaXYgPSByZXF1ZXN0LT5wcml2OworICAgIEdIYXNoVGFibGUqIGhlYWRlcnMgPSBwcml2LT5o dHRwX2hlYWRlcnM7CisKKyAgICByZXR1cm4gKGNvbnN0IGdjaGFyKilnX2hhc2hfdGFibGVfbG9v a3VwKGhlYWRlcnMsIChnY29uc3Rwb2ludGVyKWh0dHBfaGVhZGVyKTsKK30gICAgCisKK30KSW5k ZXg6IHdlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHdlYmtpdC93 ZWJraXRuZXR3b3JrcmVxdWVzdC5oCShyZXZpc2lvbiAzMjI0MCkKKysrIHdlYmtpdC93ZWJraXRu ZXR3b3JrcmVxdWVzdC5oCSh3b3JraW5nIGNvcHkpCkBAIC01Nyw2ICs1NywyNCBAQAogV0VCS0lU X0FQSSBjb25zdCBnY2hhcioKIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaSAoV2ViS2l0 TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOwogCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF9uZXR3 b3JrX3JlcXVlc3Rfc2V0X2h0dHBfbWV0aG9kIChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVz dCwgY29uc3QgZ2NoYXIqIGh0dHBfbWV0aG9kKTsKKworV0VCS0lUX0FQSSBjb25zdCBnY2hhcioK K3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfbWV0aG9kIChXZWJLaXROZXR3b3JrUmVx dWVzdCogcmVxdWVzdCk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X25ldHdvcmtfcmVxdWVz dF9zZXRfaHR0cF9oZWFkZXJzIChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3Qg R0hhc2hUYWJsZSogaHR0cF9oZWFkZXJzKTsKKworV0VCS0lUX0FQSSBjb25zdCBHSGFzaFRhYmxl Kgord2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9oZWFkZXJzIChXZWJLaXROZXR3b3Jr UmVxdWVzdCogcmVxdWVzdCk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X25ldHdvcmtfcmVx dWVzdF9zZXRfaHR0cF9oZWFkZXIgKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25z dCBnY2hhciogaHR0cF9oZWFkZXIsIGNvbnN0IGdjaGFyKiB2YWx1ZSk7CisKK1dFQktJVF9BUEkg Y29uc3QgZ2NoYXIqCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRlciAoV2Vi S2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX2hlYWRlcik7CisK IEdfRU5EX0RFQ0xTCiAKICNlbmRpZgpJbmRleDogd2Via2l0L3dlYmtpdHByaXZhdGUuaAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSB3ZWJraXQvd2Via2l0cHJpdmF0ZS5oCShyZXZpc2lvbiAzMjI0MCkKKysrIHdl YmtpdC93ZWJraXRwcml2YXRlLmgJKHdvcmtpbmcgY29weSkKQEAgLTEyMSw2ICsxMjEsOSBAQAog CiAgICAgV0VCS0lUX0FQSSBnY2hhcioKICAgICB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3NlbGVjdGVk X3RleHQgKFdlYktpdFdlYlZpZXcqIHdlYl92aWV3KTsKKworICAgIC8vIEZJWE1FOiBTaG91bGQg dGhpcyBiZSBtb3ZlZCB0byB3ZWJraXRuZXR3b3JrZXF1ZXN0Lmg/CisgICAgV2ViS2l0TmV0d29y a1JlcXVlc3QqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X2Zyb21fcmVzb3VyY2VfcmVxdWVz dChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCk7CiB9CiAK ICNlbmRpZgo= 20882 2008-04-28 18:16:44 -0700 2008-04-29 19:40:14 -0700 new draft network-request.diff text/plain 20425 gustavo SW5kZXg6IFdlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRHdGsuY3BwCShyZXZpc2lvbiAzMjYwMykKKysrIFdlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yNDUsNyArMjQ1LDcg QEAKICAgICAgICAgcmV0dXJuOwogCiAgICAgV2ViS2l0V2ViVmlldyogd2ViVmlldyA9IGdldFZp ZXdGcm9tRnJhbWUobV9mcmFtZSk7Ci0gICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3Qg PSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ldyhyZXNvdXJjZVJlcXVlc3QudXJsKCkuc3RyaW5n KCkudXRmOCgpLmRhdGEoKSk7CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld19mcm9tX3Jlc291cmNlX3JlcXVlc3QocmVzb3VyY2VS ZXF1ZXN0KTsKICAgICBXZWJLaXROYXZpZ2F0aW9uUmVzcG9uc2UgcmVzcG9uc2U7CiAKICAgICBn X3NpZ25hbF9lbWl0X2J5X25hbWUod2ViVmlldywgIm5hdmlnYXRpb24tcmVxdWVzdGVkIiwgbV9m cmFtZSwgcmVxdWVzdCwgJnJlc3BvbnNlKTsKSW5kZXg6IFdlYktpdC9ndGsvd2Via2l0L3dlYmtp dG5ldHdvcmtyZXF1ZXN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXRuZXR3b3JrcmVxdWVzdC5jcHAJKHJldmlzaW9uIDMyNjAzKQorKysgV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yMSwxMiArMjEs MjEgQEAKIAogI2luY2x1ZGUgIndlYmtpdG5ldHdvcmtyZXF1ZXN0LmgiCiAKKyNpbmNsdWRlICJQ bGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgIlJlc291cmNlUmVxdWVzdC5oIgorI2luY2x1ZGUg IkNTdHJpbmcuaCIKKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKIGV4dGVybiAiQyIgewog CiBHX0RFRklORV9UWVBFKFdlYktpdE5ldHdvcmtSZXF1ZXN0LCB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0LCBHX1RZUEVfT0JKRUNUKTsKIAogc3RydWN0IF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZh dGUgewogICAgIGdjaGFyKiB1cmk7CisgICAgV2ViS2l0UmVxQ2FjaGVQb2xpY3kgY2FjaGVfcG9s aWN5OworICAgIGdjaGFyKiBodHRwX21ldGhvZDsKKyAgICBHSGFzaFRhYmxlICpodHRwX2hlYWRl cnM7CiB9OwogCiAjZGVmaW5lIFdFQktJVF9ORVRXT1JLX1JFUVVFU1RfR0VUX1BSSVZBVEUob2Jq KSAoR19UWVBFX0lOU1RBTkNFX0dFVF9QUklWQVRFKChvYmopLCBXRUJLSVRfVFlQRV9ORVRXT1JL X1JFUVVFU1QsIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSkpCkBAIC0zNyw2ICs0Niw4IEBA CiAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsK IAogICAgIGdfZnJlZShwcml2LT51cmkpOworICAgIGdfZnJlZShwcml2LT5odHRwX21ldGhvZCk7 CisgICAgZ19oYXNoX3RhYmxlX2Rlc3Ryb3kocHJpdi0+aHR0cF9oZWFkZXJzKTsKIAogICAgIEdf T0JKRUNUX0NMQVNTKHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfcGFyZW50X2NsYXNzKS0+ZmluYWxp emUob2JqZWN0KTsKIH0KQEAgLTU0LDYgKzY1LDQ2IEBACiAgICAgcmVxdWVzdC0+cHJpdiA9IHBy aXY7CiB9CiAKK3N0YXRpYyBXZWJLaXRSZXFDYWNoZVBvbGljeSBjYWNoZV9wb2xpY3lfZnJvbV9y ZXNvdXJjZV9yZXF1ZXN0KGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0KQor eworICAgIFJlc291cmNlUmVxdWVzdENhY2hlUG9saWN5IGNhY2hlX3BvbGljeSA9IHJlc291cmNl UmVxdWVzdC5jYWNoZVBvbGljeSgpOworICAgIAorICAgIHN3aXRjaChjYWNoZV9wb2xpY3kpCisg ICAgICAgIHsKKyAgICAgICAgY2FzZSBVc2VQcm90b2NvbENhY2hlUG9saWN5OgorICAgICAgICAg ICAgcmV0dXJuIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX1BST1RPQ09MOworICAgICAgICBjYXNl IFJlbG9hZElnbm9yaW5nQ2FjaGVEYXRhOgorICAgICAgICAgICAgcmV0dXJuIFdFQktJVF9SRVFf Q0FDSEVfUE9MSUNZX1JFTE9BRF9JR05PUklOR19DQUNIRTsKKyAgICAgICAgY2FzZSBSZXR1cm5D YWNoZURhdGFFbHNlTG9hZDoKKyAgICAgICAgICAgIHJldHVybiBXRUJLSVRfUkVRX0NBQ0hFX1BP TElDWV9BTExPV19TVEFMRTsKKyAgICAgICAgY2FzZSBSZXR1cm5DYWNoZURhdGFEb250TG9hZDoK KyAgICAgICAgICAgIHJldHVybiBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9DQUNIRV9PTkxZOwor ICAgICAgICBkZWZhdWx0OgorICAgICAgICAgICAgcmV0dXJuIFdFQktJVF9SRVFfQ0FDSEVfUE9M SUNZX05PTkU7CisgICAgICAgIH0KK30KKworLy8gZm9yIGludGVybmFsIHVzZSBvbmx5CitXZWJL aXROZXR3b3JrUmVxdWVzdCogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfZnJvbV9yZXNvdXJj ZV9yZXF1ZXN0KGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0KQoreworICAg IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gV0VCS0lUX05FVFdPUktfUkVRVUVTVChn X29iamVjdF9uZXcoV0VCS0lUX1RZUEVfTkVUV09SS19SRVFVRVNULCBOVUxMKSk7CisgICAgV2Vi S2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIHBy aXYtPnVyaSA9IGdfc3RyZHVwKHJlc291cmNlUmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCku ZGF0YSgpKTsKKyAgICBwcml2LT5jYWNoZV9wb2xpY3kgPSBjYWNoZV9wb2xpY3lfZnJvbV9yZXNv dXJjZV9yZXF1ZXN0KHJlc291cmNlUmVxdWVzdCk7CisgICAgcHJpdi0+aHR0cF9tZXRob2QgPSBn X3N0cmR1cChyZXNvdXJjZVJlcXVlc3QuaHR0cE1ldGhvZCgpLnV0ZjgoKS5kYXRhKCkpOworCisg ICAgcHJpdi0+aHR0cF9oZWFkZXJzID0gZ19oYXNoX3RhYmxlX25ld19mdWxsKGdfc3RyX2hhc2gs IGdfc3RyX2VxdWFsLCBnX2ZyZWUsIGdfZnJlZSk7CisgICAgSFRUUEhlYWRlck1hcCBoZWFkZXJz ID0gcmVzb3VyY2VSZXF1ZXN0Lmh0dHBIZWFkZXJGaWVsZHMoKTsKKyAgICBpZiAoIWhlYWRlcnMu aXNFbXB0eSgpKSB7CisgICAgICAgIEhUVFBIZWFkZXJNYXA6OmNvbnN0X2l0ZXJhdG9yIGVuZCA9 IGhlYWRlcnMuZW5kKCk7CisgICAgICAgIGZvciAoSFRUUEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0 b3IgaXQgPSBoZWFkZXJzLmJlZ2luKCk7IGl0ICE9IGVuZDsgKytpdCkKKyAgICAgICAgICAgIGdf aGFzaF90YWJsZV9pbnNlcnQocHJpdi0+aHR0cF9oZWFkZXJzLCAoZ3BvaW50ZXIpZ19zdHJkdXAo aXQtPmZpcnN0LnV0ZjgoKS5kYXRhKCkpLCAoZ3BvaW50ZXIpZ19zdHJkdXAoaXQtPnNlY29uZC51 dGY4KCkuZGF0YSgpKSk7CisgICAgfQorCisgICAgcmV0dXJuIHJlcXVlc3Q7Cit9CisKIFdlYktp dE5ldHdvcmtSZXF1ZXN0KiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ldyhjb25zdCBnY2hhciog dXJpKQogewogICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKHVyaSwgTlVMTCk7CkBAIC04NSw0ICsx MzYsOTEgQEAKICAgICByZXR1cm4gcHJpdi0+dXJpOwogfQogCit2b2lkIHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3Rfc2V0X2NhY2hlX3BvbGljeShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwg Y29uc3QgV2ViS2l0UmVxQ2FjaGVQb2xpY3kgY2FjaGVfcG9saWN5KQoreworICAgIGdfcmV0dXJu X2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CisKKyAgICBXZWJL aXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgcHJp di0+Y2FjaGVfcG9saWN5ID0gY2FjaGVfcG9saWN5OwogfQorCitXZWJLaXRSZXFDYWNoZVBvbGlj eSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9jYWNoZV9wb2xpY3koV2ViS2l0TmV0d29ya1Jl cXVlc3QqIHJlcXVlc3QpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05F VFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfTk9ORSk7CisK KyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2Owor CisgICAgcmV0dXJuIHByaXYtPmNhY2hlX3BvbGljeTsKK30KKwordm9pZCB3ZWJraXRfbmV0d29y a19yZXF1ZXN0X3NldF9odHRwX21ldGhvZChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwg Y29uc3QgZ2NoYXIqIGh0dHBfbWV0aG9kKQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lU X0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CisgICAgZ19yZXR1cm5faWZfZmFpbChodHRw X21ldGhvZCk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1 ZXN0LT5wcml2OworCisgICAgZ19mcmVlKHByaXYtPmh0dHBfbWV0aG9kKTsKKyAgICBwcml2LT5o dHRwX21ldGhvZCA9IGdfc3RyZHVwKGh0dHBfbWV0aG9kKTsKK30KKworY29uc3QgZ2NoYXIqIHdl YmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfbWV0aG9kKFdlYktpdE5ldHdvcmtSZXF1ZXN0 KiByZXF1ZXN0KQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JL X1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2 YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKyAgICByZXR1cm4gcHJpdi0+aHR0cF9tZXRob2Q7 Cit9CisKK3N0YXRpYyB2b2lkIGNvcHlfaGVhZGVyKGNvbnN0IGdjaGFyKiBrZXksIGNvbnN0IGdj aGFyKiB2YWx1ZSwgZ3BvaW50ZXIgZGF0YSkKK3sKKyAgICBHSGFzaFRhYmxlICpuZXdfaGFzaF90 YWJsZSA9IChHSGFzaFRhYmxlKilkYXRhOworCisgICAgZ19oYXNoX3RhYmxlX2luc2VydChuZXdf aGFzaF90YWJsZSwgKGdwb2ludGVyKWtleSwgKGdwb2ludGVyKXZhbHVlKTsKK30KKwordm9pZCB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX2hlYWRlcnMoV2ViS2l0TmV0d29ya1JlcXVl c3QqIHJlcXVlc3QsIGNvbnN0IEdIYXNoVGFibGUqIGh0dHBfaGVhZGVycykKK3sKKyAgICBnX3Jl dHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworICAgIGdf cmV0dXJuX2lmX2ZhaWwoaHR0cF9oZWFkZXJzKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0 UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBnX2hhc2hfdGFibGVfZGVzdHJv eShwcml2LT5odHRwX2hlYWRlcnMpOworICAgIHByaXYtPmh0dHBfaGVhZGVycyA9IGdfaGFzaF90 YWJsZV9uZXdfZnVsbChnX3N0cl9oYXNoLCBnX3N0cl9lcXVhbCwgZ19mcmVlLCBnX2ZyZWUpOwor ICAgIGdfaGFzaF90YWJsZV9mb3JlYWNoKChHSGFzaFRhYmxlKilodHRwX2hlYWRlcnMsIChHSEZ1 bmMpY29weV9oZWFkZXIsIHByaXYtPmh0dHBfaGVhZGVycyk7Cit9CisKK2NvbnN0IEdIYXNoVGFi bGUqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfaGVhZGVycyhXZWJLaXROZXR3b3Jr UmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNf TkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1 ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisgICAgcmV0dXJuIHByaXYtPmh0dHBf aGVhZGVyczsKK30KKwordm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX2hlYWRl cihXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfaGVhZGVy LCBjb25zdCBnY2hhciogdmFsdWUpCit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNf TkVUV09SS19SRVFVRVNUKHJlcXVlc3QpKTsKKyAgICBnX3JldHVybl9pZl9mYWlsKGh0dHBfaGVh ZGVyKTsKKyAgICBnX3JldHVybl9pZl9mYWlsKHZhbHVlKTsKKworICAgIFdlYktpdE5ldHdvcmtS ZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisgICAgR0hhc2hUYWJsZSogaGVh ZGVycyA9IHByaXYtPmh0dHBfaGVhZGVyczsKKworICAgIGdfaGFzaF90YWJsZV9yZXBsYWNlKGhl YWRlcnMsIGdfc3RyZHVwKGh0dHBfaGVhZGVyKSwgZ19zdHJkdXAodmFsdWUpKTsKK30KKworY29u c3QgZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfaGVhZGVyKFdlYktpdE5l dHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciogaHR0cF9oZWFkZXIpCit7CisgICAg Z19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwg TlVMTCk7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoaHR0cF9oZWFkZXIsIE5VTEwpOworCisg ICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKyAg ICBHSGFzaFRhYmxlKiBoZWFkZXJzID0gcHJpdi0+aHR0cF9oZWFkZXJzOworCisgICAgcmV0dXJu IChjb25zdCBnY2hhciopZ19oYXNoX3RhYmxlX2xvb2t1cChoZWFkZXJzLCAoZ2NvbnN0cG9pbnRl cilodHRwX2hlYWRlcik7Cit9ICAgIAorCit9CkluZGV4OiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXRuZXR3b3JrcmVxdWVzdC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9ndGsvd2Via2l0L3dlYmtp dG5ldHdvcmtyZXF1ZXN0LmgJKHJldmlzaW9uIDMyNjAzKQorKysgV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0bmV0d29ya3JlcXVlc3QuaAkod29ya2luZyBjb3B5KQpAQCAtNDUsNiArNDUsMTUgQEAK ICAgICBHT2JqZWN0Q2xhc3MgcGFyZW50X2NsYXNzOwogfTsKIAordHlwZWRlZiBlbnVtCit7Cisg IFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX05PTkUsCisgIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZ X1BST1RPQ09MLAorICBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9SRUxPQURfSUdOT1JJTkdfQ0FD SEUsCisgIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX0FMTE9XX1NUQUxFLAorICBXRUJLSVRfUkVR X0NBQ0hFX1BPTElDWV9DQUNIRV9PTkxZLAorfSBXZWJLaXRSZXFDYWNoZVBvbGljeTsKKwogV0VC S0lUX0FQSSBHVHlwZQogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdHlwZSAodm9pZCk7CiAK QEAgLTU3LDYgKzY2LDMwIEBACiBXRUJLSVRfQVBJIGNvbnN0IGdjaGFyKgogd2Via2l0X25ldHdv cmtfcmVxdWVzdF9nZXRfdXJpIChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CiAKK1dF QktJVF9BUEkgdm9pZAord2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfY2FjaGVfcG9saWN5KFdl YktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBXZWJLaXRSZXFDYWNoZVBvbGljeSBj YWNoZV9wb2xpY3kpOworCitXRUJLSVRfQVBJIFdlYktpdFJlcUNhY2hlUG9saWN5Cit3ZWJraXRf bmV0d29ya19yZXF1ZXN0X2dldF9jYWNoZV9wb2xpY3koV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJl cXVlc3QpOworCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0 dHBfbWV0aG9kIChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0 dHBfbWV0aG9kKTsKKworV0VCS0lUX0FQSSBjb25zdCBnY2hhcioKK3dlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X2h0dHBfbWV0aG9kIChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CisK K1dFQktJVF9BUEkgdm9pZAord2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9oZWFkZXJz IChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgR0hhc2hUYWJsZSogaHR0cF9o ZWFkZXJzKTsKKworV0VCS0lUX0FQSSBjb25zdCBHSGFzaFRhYmxlKgord2Via2l0X25ldHdvcmtf cmVxdWVzdF9nZXRfaHR0cF9oZWFkZXJzIChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7 CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9oZWFk ZXIgKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciogaHR0cF9oZWFk ZXIsIGNvbnN0IGdjaGFyKiB2YWx1ZSk7CisKK1dFQktJVF9BUEkgY29uc3QgZ2NoYXIqCit3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRlciAoV2ViS2l0TmV0d29ya1JlcXVlc3Qq IHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX2hlYWRlcik7CisKIEdfRU5EX0RFQ0xTCiAKICNl bmRpZgpJbmRleDogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAkocmV2aXNpb24gMzI2MDMpCisr KyBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgJKHdvcmtpbmcgY29weSkKQEAgLTEy MSw2ICsxMjEsOSBAQAogCiAgICAgV0VCS0lUX0FQSSBnY2hhcioKICAgICB3ZWJraXRfd2ViX3Zp ZXdfZ2V0X3NlbGVjdGVkX3RleHQgKFdlYktpdFdlYlZpZXcqIHdlYl92aWV3KTsKKworICAgIC8v IEZJWE1FOiBTaG91bGQgdGhpcyBiZSBtb3ZlZCB0byB3ZWJraXRuZXR3b3JrZXF1ZXN0Lmg/Cisg ICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X2Zyb21f cmVzb3VyY2VfcmVxdWVzdChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNl UmVxdWVzdCk7CiB9CiAKICNlbmRpZgpJbmRleDogV2ViS2l0VG9vbHMvR3RrTGF1bmNoZXIvbWFp bi5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0d0a0xhdW5jaGVyL21haW4uYwkocmV2aXNp b24gMzI2MDMpCisrKyBXZWJLaXRUb29scy9HdGtMYXVuY2hlci9tYWluLmMJKHdvcmtpbmcgY29w eSkKQEAgLTM1LDYgKzM1LDE1IEBACiBzdGF0aWMgZ2ludCBsb2FkX3Byb2dyZXNzOwogc3RhdGlj IGd1aW50IHN0YXR1c19jb250ZXh0X2lkOwogCitHdGtXaWRnZXQqIGh0dHBfaW5zcGVjdF93aW5k b3c7CitHdGtXaWRnZXQqIGh0dHBfaW5zcGVjdF9yZXF1ZXN0c19saXN0OworR3RrTGlzdFN0b3Jl KiBodHRwX2luc3BlY3RfcmVxdWVzdHNfbW9kZWw7CitHdGtXaWRnZXQqIGh0dHBfaW5zcGVjdF9j YWNoZV9wb2xpY3lfbGFiZWw7CitHdGtXaWRnZXQqIGh0dHBfaW5zcGVjdF9tZXRob2RfbGFiZWw7 CitHdGtXaWRnZXQqIGh0dHBfaW5zcGVjdF9yZWZlcmVyX2xhYmVsOworR3RrV2lkZ2V0KiBodHRw X2luc3BlY3RfaGVhZGVyc19saXN0OworR3RrTGlzdFN0b3JlKiBodHRwX2luc3BlY3RfaGVhZGVy c19tb2RlbDsKKwogc3RhdGljIHZvaWQKIGFjdGl2YXRlX3VyaV9lbnRyeV9jYiAoR3RrV2lkZ2V0 KiBlbnRyeSwgZ3BvaW50ZXIgZGF0YSkKIHsKQEAgLTEwNiw3ICsxMTUsMjA2IEBACiAgICAgd2Vi a2l0X3dlYl92aWV3X2dvX2ZvcndhcmQgKHdlYl92aWV3KTsKIH0KIAorc3RhdGljIHZvaWQKK3No b3dfaHR0cF9pbnNwZWN0X3dpbmRvd19jYihHdGtXaWRnZXQqIHdpZGdldCwgZ3BvaW50ZXIgZGF0 YSkKK3sKKyAgICBndGtfZGlhbG9nX3J1biAoR1RLX0RJQUxPRyhodHRwX2luc3BlY3Rfd2luZG93 KSk7CisgICAgZ3RrX3dpZGdldF9oaWRlIChodHRwX2luc3BlY3Rfd2luZG93KTsKK30KKworc3Rh dGljIHZvaWQKK25hdmlnYXRpb25fcmVxdWVzdGVkX2NiIChXZWJLaXRXZWJWaWV3KiB3ZWJfdmll dywgV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwg Z3BvaW50ZXIgZGF0YSkKK3sKKyAgICBHdGtMaXN0U3RvcmUqIG1vZGVsID0gaHR0cF9pbnNwZWN0 X3JlcXVlc3RzX21vZGVsOworICAgIEd0a1RyZWVJdGVyIGl0ZXI7CisKKyAgICBnX29iamVjdF9y ZWYgKHJlcXVlc3QpOworCisgICAgZ3RrX2xpc3Rfc3RvcmVfYXBwZW5kKG1vZGVsLCAmaXRlcik7 CisgICAgZ3RrX2xpc3Rfc3RvcmVfc2V0KG1vZGVsLCAmaXRlciwKKyAgICAgICAgICAgICAgICAg ICAgICAgMCwgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJpIChyZXF1ZXN0KSwKKyAgICAg ICAgICAgICAgICAgICAgICAgMSwgcmVxdWVzdCwKKyAgICAgICAgICAgICAgICAgICAgICAgLTEp OworfQorCitzdGF0aWMgdm9pZCBhcHBlbmRfaGVhZGVyX3RvX2h0dHBfaW5zcGVjdF9oZWFkZXJz X21vZGVsIChnY2hhcioga2V5LCBnY2hhciogdmFsdWUsIEd0a1RyZWVTZWxlY3Rpb24qIHNlbGVj dGlvbikKK3sKKyAgICBHdGtMaXN0U3RvcmUqIG1vZGVsID0gR1RLX0xJU1RfU1RPUkUoaHR0cF9p bnNwZWN0X2hlYWRlcnNfbW9kZWwpOworICAgIEd0a1RyZWVJdGVyIGl0ZXI7CisgICAgCisgICAg Z3RrX2xpc3Rfc3RvcmVfYXBwZW5kIChtb2RlbCwgJml0ZXIpOworICAgIGd0a19saXN0X3N0b3Jl X3NldCAobW9kZWwsICZpdGVyLCAwLCBrZXksIDEsIHZhbHVlLCAtMSk7Cit9CisKK3N0YXRpYyBj b25zdCBnY2hhciogY2FjaGVfcG9saWN5X3RvX3N0cmluZyAoV2ViS2l0UmVxQ2FjaGVQb2xpY3kg Y2FjaGVfcG9saWN5KQoreworICAgIHN3aXRjaChjYWNoZV9wb2xpY3kpCisgICAgICAgIHsKKyAg ICAgICAgY2FzZSBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9QUk9UT0NPTDoKKyAgICAgICAgICAg IHJldHVybiAiTm9ybWFsIGxvYWQiOworICAgICAgICBjYXNlIFdFQktJVF9SRVFfQ0FDSEVfUE9M SUNZX1JFTE9BRF9JR05PUklOR19DQUNIRToKKyAgICAgICAgICAgIHJldHVybiAiUmVsb2FkIjsK KyAgICAgICAgY2FzZSBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9BTExPV19TVEFMRToKKyAgICAg ICAgICAgIHJldHVybiAiQWxsb3cgc3RhbGUgZGF0YSI7CisgICAgICAgIGNhc2UgV0VCS0lUX1JF UV9DQUNIRV9QT0xJQ1lfQ0FDSEVfT05MWToKKyAgICAgICAgICAgIHJldHVybiAiVXNlIGNhY2hl LCBvbmx5IjsKKyAgICAgICAgZGVmYXVsdDoKKyAgICAgICAgICAgIHJldHVybiAiTm9uZSI7Cisg ICAgICAgIH0KK30KKwordm9pZCBodHRwX2luc3BlY3RfY3Vyc29yX2NoYW5nZWRfY2IgKEd0a1Ry ZWVWaWV3KiB0cmVlX3ZpZXcsIGdwb2ludGVyIGRhdGEpCit7CisgICAgR3RrVHJlZU1vZGVsKiBt b2RlbCA9IEdUS19UUkVFX01PREVMKGh0dHBfaW5zcGVjdF9yZXF1ZXN0c19tb2RlbCk7CisgICAg R3RrVHJlZVNlbGVjdGlvbiogc2VsZWN0aW9uID0gZ3RrX3RyZWVfdmlld19nZXRfc2VsZWN0aW9u ICh0cmVlX3ZpZXcpOworICAgIEd0a1RyZWVJdGVyIGl0ZXI7CisgICAgV2ViS2l0TmV0d29ya1Jl cXVlc3QqIHJlcXVlc3Q7CisKKyAgICBpZiAoZ3RrX3RyZWVfc2VsZWN0aW9uX2dldF9zZWxlY3Rl ZCAoc2VsZWN0aW9uLCAmbW9kZWwsICZpdGVyKSkKKyAgICAgICAgeworICAgICAgICAgICAgZ3Rr X3RyZWVfbW9kZWxfZ2V0IChtb2RlbCwgJml0ZXIsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIDEsICZyZXF1ZXN0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAtMSk7 CisgICAgICAgICAgICAKKyAgICAgICAgICAgIGd0a19sYWJlbF9zZXRfdGV4dCAoR1RLX0xBQkVM KGh0dHBfaW5zcGVjdF9jYWNoZV9wb2xpY3lfbGFiZWwpLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBjYWNoZV9wb2xpY3lfdG9fc3RyaW5nICh3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X2dldF9jYWNoZV9wb2xpY3kgKHJlcXVlc3QpKSk7CisgICAgICAgICAgICBndGtfbGFiZWxfc2V0 X3RleHQgKEdUS19MQUJFTChodHRwX2luc3BlY3RfbWV0aG9kX2xhYmVsKSwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9tZXRo b2QgKHJlcXVlc3QpKTsKKyAgICAgICAgICAgIGd0a19sYWJlbF9zZXRfdGV4dCAoR1RLX0xBQkVM KGh0dHBfaW5zcGVjdF9yZWZlcmVyX2xhYmVsKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9oZWFkZXIgKHJlcXVlc3QsICJS ZWZlcmVyIikpOworCisgICAgICAgICAgICBndGtfbGlzdF9zdG9yZV9jbGVhciAoaHR0cF9pbnNw ZWN0X2hlYWRlcnNfbW9kZWwpOworICAgICAgICAgICAgZ19oYXNoX3RhYmxlX2ZvcmVhY2ggKChH SGFzaFRhYmxlKil3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRlcnMgKHJlcXVl c3QpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChHSEZ1bmMpYXBwZW5kX2hl YWRlcl90b19odHRwX2luc3BlY3RfaGVhZGVyc19tb2RlbCwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAoZ3BvaW50ZXIpc2VsZWN0aW9uKTsKKyAgICAgICAgfQorfQorCiBzdGF0 aWMgR3RrV2lkZ2V0KgorY3JlYXRlX2h0dHBfaW5zcGVjdF93aW5kb3cgKCkKK3sKKyAgICBHdGtX aWRnZXQqIHdpbmRvdyA9IGd0a19kaWFsb2dfbmV3X3dpdGhfYnV0dG9ucyAoIkhUVFAgUmVxdWVz dHMiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBHVEtfV0lORE9XKG1haW5fd2luZG93KSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgR1RLX0RJQUxPR19NT0RBTCwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR1RLX1NUT0NLX0NMT1NFLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtf UkVTUE9OU0VfREVMRVRFX0VWRU5ULAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBOVUxMKTsKKyAgICBndGtfd2luZG93X3NldF9kZWZhdWx0X3Np emUgKEdUS19XSU5ET1cod2luZG93KSwgNjQwLCA0ODApOworCisgICAgLy8gYmFzaWMgbGF5b3V0 CisgICAgR3RrV2lkZ2V0KiB2Ym94ID0gR1RLX0RJQUxPRyh3aW5kb3cpLT52Ym94OworICAgIEd0 a1dpZGdldCogcGFuZWQgPSBndGtfaHBhbmVkX25ldyAoKTsKKyAgICBndGtfYm94X3BhY2tfc3Rh cnQgKEdUS19CT1godmJveCksIHBhbmVkLCBUUlVFLCBUUlVFLCAxMik7CisgICAgZ3RrX3dpZGdl dF9zaG93KHBhbmVkKTsKKworICAgIEd0a1dpZGdldCogc2Nyb2xsZWRfd2luZG93ID0gZ3RrX3Nj cm9sbGVkX3dpbmRvd19uZXcgKE5VTEwsIE5VTEwpOworICAgIGd0a19zY3JvbGxlZF93aW5kb3df c2V0X3BvbGljeSAoR1RLX1NDUk9MTEVEX1dJTkRPVyhzY3JvbGxlZF93aW5kb3cpLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR1RLX1BPTElDWV9BVVRPTUFUSUMsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtfUE9MSUNZX0FVVE9NQVRJQyk7Cisg ICAgZ3RrX3dpZGdldF9zZXRfc2l6ZV9yZXF1ZXN0IChzY3JvbGxlZF93aW5kb3csIDIwMCwgLTEp OworICAgIGd0a19wYW5lZF9hZGQxIChHVEtfUEFORUQocGFuZWQpLCBzY3JvbGxlZF93aW5kb3cp OworICAgIGd0a193aWRnZXRfc2hvdyAoc2Nyb2xsZWRfd2luZG93KTsKKworICAgIC8vIHRoZSB0 cmVlCisgICAgaHR0cF9pbnNwZWN0X3JlcXVlc3RzX2xpc3QgPSBndGtfdHJlZV92aWV3X25ldyAo KTsKKyAgICBndGtfdHJlZV92aWV3X3NldF9oZWFkZXJzX3Zpc2libGUgKEdUS19UUkVFX1ZJRVco aHR0cF9pbnNwZWN0X3JlcXVlc3RzX2xpc3QpLCBGQUxTRSk7CisgICAgZ3RrX3RyZWVfdmlld19h cHBlbmRfY29sdW1uIChHVEtfVFJFRV9WSUVXKGh0dHBfaW5zcGVjdF9yZXF1ZXN0c19saXN0KSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGd0a190cmVlX3ZpZXdfY29sdW1uX25l d193aXRoX2F0dHJpYnV0ZXMgKCJVUkkiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ3RrX2NlbGxfcmVu ZGVyZXJfdGV4dF9uZXcoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJ0ZXh0IiwgMCwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIE5VTEwpKTsKKyAgICBnX3NpZ25hbF9jb25uZWN0KGh0dHBfaW5zcGVjdF9yZXF1 ZXN0c19saXN0LCAiY3Vyc29yLWNoYW5nZWQiLAorICAgICAgICAgICAgICAgICAgICAgR19DQUxM QkFDSyhodHRwX2luc3BlY3RfY3Vyc29yX2NoYW5nZWRfY2IpLCBOVUxMKTsKKyAgICBndGtfY29u dGFpbmVyX2FkZCAoR1RLX0NPTlRBSU5FUihzY3JvbGxlZF93aW5kb3cpLCBodHRwX2luc3BlY3Rf cmVxdWVzdHNfbGlzdCk7CisgICAgZ3RrX3dpZGdldF9zaG93IChodHRwX2luc3BlY3RfcmVxdWVz dHNfbGlzdCk7CisKKyAgICBodHRwX2luc3BlY3RfcmVxdWVzdHNfbW9kZWwgPSBndGtfbGlzdF9z dG9yZV9uZXcgKDIsIEdfVFlQRV9TVFJJTkcsIFdFQktJVF9UWVBFX05FVFdPUktfUkVRVUVTVCwg LTEpOworICAgIGd0a190cmVlX3ZpZXdfc2V0X21vZGVsIChHVEtfVFJFRV9WSUVXKGh0dHBfaW5z cGVjdF9yZXF1ZXN0c19saXN0KSwgR1RLX1RSRUVfTU9ERUwoaHR0cF9pbnNwZWN0X3JlcXVlc3Rz X21vZGVsKSk7CisKKyAgICAvLyBtb3JlIGxheW91dGluZywgZm9yIHRoZSByaWdodCBzaWRlIG9m IHRoZSB3aW5kb3cKKyAgICBHdGtXaWRnZXQqIHJ2Ym94ID0gZ3RrX3Zib3hfbmV3IChGQUxTRSwg Mik7CisgICAgZ3RrX3BhbmVkX2FkZDIgKEdUS19QQU5FRChwYW5lZCksIHJ2Ym94KTsKKyAgICBn dGtfd2lkZ2V0X3Nob3cgKHJ2Ym94KTsKKworICAgIEd0a1dpZGdldCogdGFibGUgPSBndGtfdGFi bGVfbmV3ICgzLCAyLCBUUlVFKTsKKyAgICBndGtfdGFibGVfc2V0X3Jvd19zcGFjaW5ncyAoR1RL X1RBQkxFKHRhYmxlKSwgMTIpOworICAgIGd0a19ib3hfcGFja19zdGFydCAoR1RLX0JPWChydmJv eCksIHRhYmxlLCBGQUxTRSwgRkFMU0UsIDApOworICAgIGd0a193aWRnZXRfc2hvdyAodGFibGUp OworCisgICAgLy8gZGV0YWlscyBvZiB0aGUgcmVxdWVzdAorICAgIC8vIENhY2hlIFBvbGljeQor ICAgIEd0a1dpZGdldCogbGFiZWwgPSBnX29iamVjdF9uZXcgKEdUS19UWVBFX0xBQkVMLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJsYWJlbCIsICI8Yj5DYWNoZSBQb2xp Y3k8L2I+IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAidXNlLW1hcmt1 cCIsIFRSVUUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7Cisg ICAgZ3RrX3RhYmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgbGFiZWwsIDAs IDEsIDAsIDEpOworICAgIGd0a193aWRnZXRfc2hvdyhsYWJlbCk7CisKKyAgICBodHRwX2luc3Bl Y3RfY2FjaGVfcG9saWN5X2xhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJFTCwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAibGFiZWwi LCAiIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBOVUxMKTsKKyAgICBndGtfdGFibGVfYXR0YWNoX2RlZmF1bHRzIChHVEtfVEFCTEUodGFibGUp LCBodHRwX2luc3BlY3RfY2FjaGVfcG9saWN5X2xhYmVsLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIDEsIDIsIDAsIDEpOworICAgIGd0a193aWRnZXRfc2hvdyhodHRwX2luc3BlY3Rf Y2FjaGVfcG9saWN5X2xhYmVsKTsKKworICAgIC8vIEhUVFAgbWV0aG9kCisgICAgbGFiZWwgPSBn X29iamVjdF9uZXcgKEdUS19UWVBFX0xBQkVMLAorICAgICAgICAgICAgICAgICAgICAgICAgICAi bGFiZWwiLCAiPGI+TWV0aG9kPC9iPiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICJ1c2Ut bWFya3VwIiwgVFJVRSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7CisgICAgZ3Rr X3RhYmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgbGFiZWwsIDAsIDEsIDEs IDIpOworICAgIGd0a193aWRnZXRfc2hvdyhsYWJlbCk7CisKKyAgICBodHRwX2luc3BlY3RfbWV0 aG9kX2xhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJFTCwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAibGFiZWwiLCAiIiwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMKTsKKyAgICBndGtfdGFibGVf YXR0YWNoX2RlZmF1bHRzIChHVEtfVEFCTEUodGFibGUpLCBodHRwX2luc3BlY3RfbWV0aG9kX2xh YmVsLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDEsIDIsIDEsIDIpOworICAgIGd0 a193aWRnZXRfc2hvdyhodHRwX2luc3BlY3RfbWV0aG9kX2xhYmVsKTsKKworICAgIC8vIEhUVFAg UmVmZXJlcgorICAgIGxhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJFTCwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgImxhYmVsIiwgIjxiPlJlZmVyZXI8L2I+IiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgInVzZS1tYXJrdXAiLCBUUlVFLAorICAgICAgICAgICAgICAgICAg ICAgICAgICBOVUxMKTsKKyAgICBndGtfdGFibGVfYXR0YWNoX2RlZmF1bHRzIChHVEtfVEFCTEUo dGFibGUpLCBsYWJlbCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAwLCAxLCAyLCAz KTsKKyAgICBndGtfd2lkZ2V0X3Nob3cobGFiZWwpOworCisgICAgaHR0cF9pbnNwZWN0X3JlZmVy ZXJfbGFiZWwgPSBnX29iamVjdF9uZXcgKEdUS19UWVBFX0xBQkVMLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJsYWJlbCIsICIiLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOworICAgIGd0a190YWJsZV9h dHRhY2hfZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJsZSksIGh0dHBfaW5zcGVjdF9yZWZlcmVyX2xh YmVsLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDEsIDIsIDIsIDMpOworICAgIGd0 a193aWRnZXRfc2hvdyhodHRwX2luc3BlY3RfcmVmZXJlcl9sYWJlbCk7CisKKyAgICAvLyBoZWFk ZXJzIGxpc3RpbmcKKyAgICBzY3JvbGxlZF93aW5kb3cgPSBndGtfc2Nyb2xsZWRfd2luZG93X25l dyAoTlVMTCwgTlVMTCk7CisgICAgZ3RrX3Njcm9sbGVkX3dpbmRvd19zZXRfcG9saWN5IChHVEtf U0NST0xMRURfV0lORE9XKHNjcm9sbGVkX3dpbmRvdyksIEdUS19QT0xJQ1lfQVVUT01BVElDLCBH VEtfUE9MSUNZX0FVVE9NQVRJQyk7CisgICAgZ3RrX2JveF9wYWNrX3N0YXJ0X2RlZmF1bHRzIChH VEtfQk9YKHJ2Ym94KSwgc2Nyb2xsZWRfd2luZG93KTsKKyAgICBndGtfd2lkZ2V0X3Nob3cgKHNj cm9sbGVkX3dpbmRvdyk7CisKKyAgICBodHRwX2luc3BlY3RfaGVhZGVyc19saXN0ID0gZ3RrX3Ry ZWVfdmlld19uZXcgKCk7CisgICAgZ3RrX3RyZWVfdmlld19hcHBlbmRfY29sdW1uIChHVEtfVFJF RV9WSUVXKGh0dHBfaW5zcGVjdF9oZWFkZXJzX2xpc3QpLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgZ3RrX3RyZWVfdmlld19jb2x1bW5fbmV3X3dpdGhfYXR0cmlidXRlcyAoIkhl YWRlciIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBndGtfY2VsbF9yZW5kZXJlcl90ZXh0X25ldyAoKSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICJ0ZXh0IiwgMCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpKTsK KyAgICBndGtfdHJlZV92aWV3X2FwcGVuZF9jb2x1bW4gKEdUS19UUkVFX1ZJRVcoaHR0cF9pbnNw ZWN0X2hlYWRlcnNfbGlzdCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBndGtf dHJlZV92aWV3X2NvbHVtbl9uZXdfd2l0aF9hdHRyaWJ1dGVzICgiVmFsdWUiLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgZ3RrX2NlbGxfcmVuZGVyZXJfdGV4dF9uZXcgKCksCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAidGV4dCIsIDEsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMKSk7CisgICAgZ3RrX2NvbnRhaW5l cl9hZGQgKEdUS19DT05UQUlORVIoc2Nyb2xsZWRfd2luZG93KSwgaHR0cF9pbnNwZWN0X2hlYWRl cnNfbGlzdCk7CisgICAgZ3RrX3dpZGdldF9zaG93IChodHRwX2luc3BlY3RfaGVhZGVyc19saXN0 KTsKKworICAgIGh0dHBfaW5zcGVjdF9oZWFkZXJzX21vZGVsID0gZ3RrX2xpc3Rfc3RvcmVfbmV3 ICgyLCBHX1RZUEVfU1RSSU5HLCBHX1RZUEVfU1RSSU5HKTsKKyAgICBndGtfdHJlZV92aWV3X3Nl dF9tb2RlbCAoR1RLX1RSRUVfVklFVyhodHRwX2luc3BlY3RfaGVhZGVyc19saXN0KSwgR1RLX1RS RUVfTU9ERUwoaHR0cF9pbnNwZWN0X2hlYWRlcnNfbW9kZWwpKTsKKworICAgIHJldHVybiB3aW5k b3c7Cit9CisKK3N0YXRpYyBHdGtXaWRnZXQqCiBjcmVhdGVfYnJvd3NlciAoKQogewogICAgIEd0 a1dpZGdldCogc2Nyb2xsZWRfd2luZG93ID0gZ3RrX3Njcm9sbGVkX3dpbmRvd19uZXcgKE5VTEws IE5VTEwpOwpAQCAtMTE5LDYgKzMyNyw3IEBACiAgICAgZ19zaWduYWxfY29ubmVjdCAoR19PQkpF Q1QgKHdlYl92aWV3KSwgImxvYWQtcHJvZ3Jlc3MtY2hhbmdlZCIsIEdfQ0FMTEJBQ0sgKHByb2dy ZXNzX2NoYW5nZV9jYiksIHdlYl92aWV3KTsKICAgICBnX3NpZ25hbF9jb25uZWN0IChHX09CSkVD VCAod2ViX3ZpZXcpLCAibG9hZC1jb21taXR0ZWQiLCBHX0NBTExCQUNLIChsb2FkX2NvbW1pdF9j YiksIHdlYl92aWV3KTsKICAgICBnX3NpZ25hbF9jb25uZWN0IChHX09CSkVDVCAod2ViX3ZpZXcp LCAiaG92ZXJpbmctb3Zlci1saW5rIiwgR19DQUxMQkFDSyAobGlua19ob3Zlcl9jYiksIHdlYl92 aWV3KTsKKyAgICBnX3NpZ25hbF9jb25uZWN0IChHX09CSkVDVCAod2ViX3ZpZXcpLCAibmF2aWdh dGlvbi1yZXF1ZXN0ZWQiLCBHX0NBTExCQUNLIChuYXZpZ2F0aW9uX3JlcXVlc3RlZF9jYiksIHdl Yl92aWV3KTsKIAogICAgIHJldHVybiBzY3JvbGxlZF93aW5kb3c7CiB9CkBAIC0xNTIsNiArMzYx LDExIEBACiAgICAgZ19zaWduYWxfY29ubmVjdCAoR19PQkpFQ1QgKGl0ZW0pLCAiY2xpY2tlZCIs IEdfQ0FMTEJBQ0sgKGdvX2ZvcndhcmRfY2IpLCBOVUxMKTsKICAgICBndGtfdG9vbGJhcl9pbnNl cnQgKEdUS19UT09MQkFSICh0b29sYmFyKSwgaXRlbSwgLTEpOwogCisgICAgLyogVGhlIGh0dHAg aW5zcGVjdCBidXR0b24gKi8KKyAgICBpdGVtID0gZ3RrX3Rvb2xfYnV0dG9uX25ld19mcm9tX3N0 b2NrIChHVEtfU1RPQ0tfTkVUV09SSyk7CisgICAgZ19zaWduYWxfY29ubmVjdCAoR19PQkpFQ1Qg KGl0ZW0pLCAiY2xpY2tlZCIsIEdfQ0FMTEJBQ0sgKHNob3dfaHR0cF9pbnNwZWN0X3dpbmRvd19j YiksIE5VTEwpOworICAgIGd0a190b29sYmFyX2luc2VydCAoR1RLX1RPT0xCQVIgKHRvb2xiYXIp LCBpdGVtLCAtMSk7CisKICAgICAvKiBUaGUgVVJMIGVudHJ5ICovCiAgICAgaXRlbSA9IGd0a190 b29sX2l0ZW1fbmV3ICgpOwogICAgIGd0a190b29sX2l0ZW1fc2V0X2V4cGFuZCAoaXRlbSwgVFJV RSk7CkBAIC0xOTIsNiArNDA2LDggQEAKICAgICBtYWluX3dpbmRvdyA9IGNyZWF0ZV93aW5kb3cg KCk7CiAgICAgZ3RrX2NvbnRhaW5lcl9hZGQgKEdUS19DT05UQUlORVIgKG1haW5fd2luZG93KSwg dmJveCk7CiAKKyAgICBodHRwX2luc3BlY3Rfd2luZG93ID0gY3JlYXRlX2h0dHBfaW5zcGVjdF93 aW5kb3cgKCk7CisKICAgICBnY2hhciogdXJpID0gKGdjaGFyKikgKGFyZ2MgPiAxID8gYXJndlsx XSA6ICJodHRwOi8vd3d3Lmdvb2dsZS5jb20vIik7CiAgICAgd2Via2l0X3dlYl92aWV3X29wZW4g KHdlYl92aWV3LCB1cmkpOwogCg== 20895 2008-04-29 19:40:14 -0700 2008-05-07 03:56:04 -0700 almost complete implementation of a gobject exposing ResourceRequest network-request.diff text/plain 39215 gustavo SW5kZXg6IFdlYktpdC9ndGsvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9ndGsvQ2hh bmdlTG9nCShyZXZpc2lvbiAzMjcxNCkKKysrIFdlYktpdC9ndGsvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsNDYgQEAKKzIwMDgtMDQtMjkgIEd1c3Rhdm8gTm9yb25oYSBTaWx2 YSAgPGduc0Bnbm9tZS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKwlodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTg2MDgKKwlXZWJL aXROZXR3b3JrUmVxdWVzdCBuZWVkcyB0byBiZSBmaW5pc2hlZAorCisJQWxtb3N0IGNvbXBsZXRl IEdPYmplY3QgaW1wbGVtZW50YXRpb24gZXhwb3NpbmcgUmVzb3VyY2VSZXF1ZXN0LgorCQorICAg ICAgICAqIFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcDoKKyAgICAgICAg KFdlYktpdDo6RnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTmF2aWdh dGlvbkFjdGlvbik6CisgICAgICAgICogd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcDoK KyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZmluYWxpemUpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6 Y2FjaGVfcG9saWN5X2Zyb21fcmVzb3VyY2VfcmVxdWVzdCk6CisgICAgICAgIChfV2ViS2l0TmV0 d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld19mcm9tX3Jlc291 cmNlX3JlcXVlc3QpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfY2FjaGVfcG9saWN5KToKKyAgICAgICAgKF9XZWJLaXRO ZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2NhY2hlX3Bv bGljeSk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X3NldF90aW1lb3V0X2ludGVydmFsKToKKyAgICAgICAgKF9XZWJLaXROZXR3 b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3RpbWVvdXRfaW50 ZXJ2YWwpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25l dHdvcmtfcmVxdWVzdF9zZXRfbWFpbl9kb2N1bWVudF91cmkpOgorICAgICAgICAoX1dlYktpdE5l dHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWFpbl9kb2N1 bWVudF91cmkpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0 X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9tZXRob2QpOgorICAgICAgICAoX1dlYktpdE5ldHdv cmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9tZXRob2Qp OgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6Y29weV9oZWFkZXIpOgor ICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVx dWVzdF9zZXRfaHR0cF9oZWFkZXJzKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFBy aXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfaGVhZGVycyk6CisgICAgICAg IChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3Nl dF9odHRwX2hlYWRlcik6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRlcik6CisgICAgICAgIChfV2ViS2l0 TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX2Nv bnRlbnRfdHlwZSk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2NvbnRlbnRfdHlwZSk6CisgICAgICAgIChfV2Vi S2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRw X3JlZmVyZXIpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0 X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9yZWZlcmVyKToKKyAgICAgICAgKF9XZWJLaXROZXR3 b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfdXNlcl9h Z2VudCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X2dldF9odHRwX3VzZXJfYWdlbnQpOgorICAgICAgICAoX1dlYktpdE5ldHdv cmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9hY2NlcHQp OgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtf cmVxdWVzdF9nZXRfaHR0cF9hY2NlcHQpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0 UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfYm9keSk6CisgICAgICAgIChfV2Vi S2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9ib2R5 KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3Jr X3JlcXVlc3Rfc2V0X2FsbG93X2h0dHBfY29va2llcyk6CisgICAgICAgIChfV2ViS2l0TmV0d29y a1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9hbGxvd19odHRwX2Nv b2tpZXMpOgorICAgICAgICAqIHdlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oOgorICAgICAg ICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmg6CisKIDIwMDgtMDQtMjQgIERhbiBCZXJuc3RlaW4g IDxtaXR6QGFwcGxlLmNvbT4KIAogICAgICAgICAtIGJ1aWxkIGZpeApJbmRleDogV2ViS2l0L2d0 ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAJKHJldmlz aW9uIDMyNjY2KQorKysgV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVu dEd0ay5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI0NSw3ICsyNDUsNyBAQCB2b2lkIEZyYW1lTG9h ZGVyQ2xpZW50OjpkaXNwYXRjaERlY2lkZVBvCiAgICAgICAgIHJldHVybjsKIAogICAgIFdlYktp dFdlYlZpZXcqIHdlYlZpZXcgPSBnZXRWaWV3RnJvbUZyYW1lKG1fZnJhbWUpOwotICAgIFdlYktp dE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXcocmVz b3VyY2VSZXF1ZXN0LnVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworICAgIFdlYktpdE5l dHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfZnJvbV9y ZXNvdXJjZV9yZXF1ZXN0KHJlc291cmNlUmVxdWVzdCk7CiAgICAgV2ViS2l0TmF2aWdhdGlvblJl c3BvbnNlIHJlc3BvbnNlOwogCiAgICAgZ19zaWduYWxfZW1pdF9ieV9uYW1lKHdlYlZpZXcsICJu YXZpZ2F0aW9uLXJlcXVlc3RlZCIsIG1fZnJhbWUsIHJlcXVlc3QsICZyZXNwb25zZSk7CkluZGV4 OiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwCShyZXZpc2lvbiAz MjY2NikKKysrIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcAkod29y a2luZyBjb3B5KQpAQCAtMjEsMTIgKzIxLDI1IEBACiAKICNpbmNsdWRlICJ3ZWJraXRuZXR3b3Jr cmVxdWVzdC5oIgogCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlICJSZXNv dXJjZVJlcXVlc3QuaCIKKyNpbmNsdWRlICJDU3RyaW5nLmgiCisKK3VzaW5nIG5hbWVzcGFjZSBX ZWJDb3JlOworCiBleHRlcm4gIkMiIHsKIAogR19ERUZJTkVfVFlQRShXZWJLaXROZXR3b3JrUmVx dWVzdCwgd2Via2l0X25ldHdvcmtfcmVxdWVzdCwgR19UWVBFX09CSkVDVCk7CiAKIHN0cnVjdCBf V2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlIHsKICAgICBnY2hhciogdXJpOworICAgIFdlYktp dFJlcUNhY2hlUG9saWN5IGNhY2hlX3BvbGljeTsKKyAgICBnZG91YmxlIHRpbWVvdXRfaW50ZXJ2 YWw7CisgICAgZ2NoYXIqIG1haW5fZG9jdW1lbnRfdXJpOworICAgIGdjaGFyKiBodHRwX21ldGhv ZDsKKyAgICBHSGFzaFRhYmxlICpodHRwX2hlYWRlcnM7CisgICAgZ2Jvb2xlYW4gYWxsb3dfaHR0 cF9jb29raWVzOworICAgIGdjaGFyICpib2R5OwogfTsKIAogI2RlZmluZSBXRUJLSVRfTkVUV09S S19SRVFVRVNUX0dFVF9QUklWQVRFKG9iaikgKEdfVFlQRV9JTlNUQU5DRV9HRVRfUFJJVkFURSgo b2JqKSwgV0VCS0lUX1RZUEVfTkVUV09SS19SRVFVRVNULCBXZWJLaXROZXR3b3JrUmVxdWVzdFBy aXZhdGUpKQpAQCAtMzcsNiArNTAsMTAgQEAgc3RhdGljIHZvaWQgd2Via2l0X25ldHdvcmtfcmVx dWVzdF9maW5hbAogICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVl c3QtPnByaXY7CiAKICAgICBnX2ZyZWUocHJpdi0+dXJpKTsKKyAgICBnX2ZyZWUocHJpdi0+bWFp bl9kb2N1bWVudF91cmkpOworICAgIGdfZnJlZShwcml2LT5odHRwX21ldGhvZCk7CisgICAgZ19o YXNoX3RhYmxlX2Rlc3Ryb3kocHJpdi0+aHR0cF9oZWFkZXJzKTsKKyAgICBnX2ZyZWUocHJpdi0+ Ym9keSk7CiAKICAgICBHX09CSkVDVF9DTEFTUyh3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3BhcmVu dF9jbGFzcyktPmZpbmFsaXplKG9iamVjdCk7CiB9CkBAIC01NCw2ICs3MSw1MiBAQCBzdGF0aWMg dm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2luaXQoCiAgICAgcmVxdWVzdC0+cHJpdiA9IHBy aXY7CiB9CiAKK3N0YXRpYyBXZWJLaXRSZXFDYWNoZVBvbGljeSBjYWNoZV9wb2xpY3lfZnJvbV9y ZXNvdXJjZV9yZXF1ZXN0KGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0KQor eworICAgIFJlc291cmNlUmVxdWVzdENhY2hlUG9saWN5IGNhY2hlX3BvbGljeSA9IHJlc291cmNl UmVxdWVzdC5jYWNoZVBvbGljeSgpOworICAgIAorICAgIHN3aXRjaChjYWNoZV9wb2xpY3kpCisg ICAgICAgIHsKKyAgICAgICAgY2FzZSBVc2VQcm90b2NvbENhY2hlUG9saWN5OgorICAgICAgICAg ICAgcmV0dXJuIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX1BST1RPQ09MOworICAgICAgICBjYXNl IFJlbG9hZElnbm9yaW5nQ2FjaGVEYXRhOgorICAgICAgICAgICAgcmV0dXJuIFdFQktJVF9SRVFf Q0FDSEVfUE9MSUNZX1JFTE9BRF9JR05PUklOR19DQUNIRTsKKyAgICAgICAgY2FzZSBSZXR1cm5D YWNoZURhdGFFbHNlTG9hZDoKKyAgICAgICAgICAgIHJldHVybiBXRUJLSVRfUkVRX0NBQ0hFX1BP TElDWV9BTExPV19TVEFMRTsKKyAgICAgICAgY2FzZSBSZXR1cm5DYWNoZURhdGFEb250TG9hZDoK KyAgICAgICAgICAgIHJldHVybiBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9DQUNIRV9PTkxZOwor ICAgICAgICBkZWZhdWx0OgorICAgICAgICAgICAgcmV0dXJuIFdFQktJVF9SRVFfQ0FDSEVfUE9M SUNZX05PTkU7CisgICAgICAgIH0KK30KKworLy8gZm9yIGludGVybmFsIHVzZSBvbmx5CitXZWJL aXROZXR3b3JrUmVxdWVzdCogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfZnJvbV9yZXNvdXJj ZV9yZXF1ZXN0KGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0KQoreworICAg IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gV0VCS0lUX05FVFdPUktfUkVRVUVTVChn X29iamVjdF9uZXcoV0VCS0lUX1RZUEVfTkVUV09SS19SRVFVRVNULCBOVUxMKSk7CisgICAgV2Vi S2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIHBy aXYtPnVyaSA9IGdfc3RyZHVwKHJlc291cmNlUmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCku ZGF0YSgpKTsKKyAgICBwcml2LT5jYWNoZV9wb2xpY3kgPSBjYWNoZV9wb2xpY3lfZnJvbV9yZXNv dXJjZV9yZXF1ZXN0KHJlc291cmNlUmVxdWVzdCk7CisgICAgcHJpdi0+dGltZW91dF9pbnRlcnZh bCA9IHJlc291cmNlUmVxdWVzdC50aW1lb3V0SW50ZXJ2YWwoKTsKKyAgICBwcml2LT5tYWluX2Rv Y3VtZW50X3VyaSA9IGdfc3RyZHVwKHJlc291cmNlUmVxdWVzdC5tYWluRG9jdW1lbnRVUkwoKS5z dHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKyAgICBwcml2LT5odHRwX21ldGhvZCA9IGdfc3RyZHVw KHJlc291cmNlUmVxdWVzdC5odHRwTWV0aG9kKCkudXRmOCgpLmRhdGEoKSk7CisKKyAgICBwcml2 LT5odHRwX2hlYWRlcnMgPSBnX2hhc2hfdGFibGVfbmV3X2Z1bGwoZ19zdHJfaGFzaCwgZ19zdHJf ZXF1YWwsIGdfZnJlZSwgZ19mcmVlKTsKKyAgICBIVFRQSGVhZGVyTWFwIGhlYWRlcnMgPSByZXNv dXJjZVJlcXVlc3QuaHR0cEhlYWRlckZpZWxkcygpOworICAgIGlmICghaGVhZGVycy5pc0VtcHR5 KCkpIHsKKyAgICAgICAgSFRUUEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgZW5kID0gaGVhZGVy cy5lbmQoKTsKKyAgICAgICAgZm9yIChIVFRQSGVhZGVyTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9 IGhlYWRlcnMuYmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KQorICAgICAgICAgICAgZ19oYXNoX3Rh YmxlX2luc2VydChwcml2LT5odHRwX2hlYWRlcnMsIChncG9pbnRlcilnX3N0cmR1cChpdC0+Zmly c3QudXRmOCgpLmRhdGEoKSksIChncG9pbnRlcilnX3N0cmR1cChpdC0+c2Vjb25kLnV0ZjgoKS5k YXRhKCkpKTsKKyAgICB9CisKKyAgICBpZiAoZ19hc2NpaV9zdHJjYXNlY21wIChwcml2LT5odHRw X21ldGhvZCwgIlBPU1QiKSA9PSAwKQorICAgICAgICBwcml2LT5ib2R5ID0gZ19zdHJkdXAocmVz b3VyY2VSZXF1ZXN0Lmh0dHBCb2R5KCktPmZsYXR0ZW5Ub1N0cmluZygpLnV0ZjgoKS5kYXRhKCkp OworICAgIHByaXYtPmFsbG93X2h0dHBfY29va2llcyA9IHJlc291cmNlUmVxdWVzdC5hbGxvd0hU VFBDb29raWVzKCk7CisKKyAgICByZXR1cm4gcmVxdWVzdDsKK30KKwogV2ViS2l0TmV0d29ya1Jl cXVlc3QqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3KGNvbnN0IGdjaGFyKiB1cmkpCiB7CiAg ICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwodXJpLCBOVUxMKTsKQEAgLTg1LDQgKzE0OCwyMjYgQEAg Y29uc3QgZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0XwogICAgIHJldHVybiBwcml2 LT51cmk7CiB9CiAKK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfY2FjaGVfcG9saWN5 KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBXZWJLaXRSZXFDYWNoZVBvbGlj eSBjYWNoZV9wb2xpY3kpCit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfTkVUV09S S19SRVFVRVNUKHJlcXVlc3QpKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSog cHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBwcml2LT5jYWNoZV9wb2xpY3kgPSBjYWNoZV9w b2xpY3k7Cit9CisKK1dlYktpdFJlcUNhY2hlUG9saWN5IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf Z2V0X2NhY2hlX3BvbGljeShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBn X3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBX RUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9OT05FKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0 UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICByZXR1cm4gcHJpdi0+Y2FjaGVf cG9saWN5OworfQorCit2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3RpbWVvdXRfaW50 ZXJ2YWwoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdkb3VibGUgdGltZW91 dF9pbnRlcnZhbCkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JF UVVFU1QocmVxdWVzdCkpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2 ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIHByaXYtPnRpbWVvdXRfaW50ZXJ2YWwgPSB0aW1lb3V0 X2ludGVydmFsOworfQorCitnZG91YmxlIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3RpbWVv dXRfaW50ZXJ2YWwoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgZ19yZXR1 cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgMC4wKTsK KworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7 CisKKyAgICByZXR1cm4gcHJpdi0+dGltZW91dF9pbnRlcnZhbDsKK30KKwordm9pZCB3ZWJraXRf bmV0d29ya19yZXF1ZXN0X3NldF9tYWluX2RvY3VtZW50X3VyaShXZWJLaXROZXR3b3JrUmVxdWVz dCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIG1haW5fZG9jdW1lbnRfdXJpKQoreworICAgIGdfcmV0 dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CisgICAgZ19y ZXR1cm5faWZfZmFpbChtYWluX2RvY3VtZW50X3VyaSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVx dWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgZ19mcmVlKHByaXYtPm1h aW5fZG9jdW1lbnRfdXJpKTsKKyAgICBwcml2LT5tYWluX2RvY3VtZW50X3VyaSA9IGdfc3RyZHVw KG1haW5fZG9jdW1lbnRfdXJpKTsKK30KKworY29uc3QgZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X21haW5fZG9jdW1lbnRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0 KQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1Qo cmVxdWVzdCksIE5VTEwpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2 ID0gcmVxdWVzdC0+cHJpdjsKKyAgICByZXR1cm4gcHJpdi0+bWFpbl9kb2N1bWVudF91cmk7Cit9 CisKK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9tZXRob2QoV2ViS2l0TmV0 d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX21ldGhvZCkKK3sKKyAgICBn X3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworICAg IGdfcmV0dXJuX2lmX2ZhaWwoaHR0cF9tZXRob2QpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVl c3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIGdfZnJlZShwcml2LT5odHRw X21ldGhvZCk7CisgICAgcHJpdi0+aHR0cF9tZXRob2QgPSBnX3N0cmR1cChodHRwX21ldGhvZCk7 Cit9CisKK2NvbnN0IGdjaGFyKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX21ldGhv ZChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBnX3JldHVybl92YWxfaWZf ZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKKworICAgIFdl YktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisgICAgcmV0 dXJuIHByaXYtPmh0dHBfbWV0aG9kOworfQorCitzdGF0aWMgdm9pZCBjb3B5X2hlYWRlcihjb25z dCBnY2hhcioga2V5LCBjb25zdCBnY2hhciogdmFsdWUsIGdwb2ludGVyIGRhdGEpCit7CisgICAg R0hhc2hUYWJsZSAqbmV3X2hhc2hfdGFibGUgPSAoR0hhc2hUYWJsZSopZGF0YTsKKworICAgIGdf aGFzaF90YWJsZV9pbnNlcnQobmV3X2hhc2hfdGFibGUsIChncG9pbnRlcilrZXksIChncG9pbnRl cil2YWx1ZSk7Cit9CisKK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9oZWFk ZXJzKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBHSGFzaFRhYmxlKiBodHRw X2hlYWRlcnMpCit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFV RVNUKHJlcXVlc3QpKTsKKyAgICBnX3JldHVybl9pZl9mYWlsKGh0dHBfaGVhZGVycyk7CisKKyAg ICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisg ICAgZ19oYXNoX3RhYmxlX2Rlc3Ryb3kocHJpdi0+aHR0cF9oZWFkZXJzKTsKKyAgICBwcml2LT5o dHRwX2hlYWRlcnMgPSBnX2hhc2hfdGFibGVfbmV3X2Z1bGwoZ19zdHJfaGFzaCwgZ19zdHJfZXF1 YWwsIGdfZnJlZSwgZ19mcmVlKTsKKyAgICBnX2hhc2hfdGFibGVfZm9yZWFjaCgoR0hhc2hUYWJs ZSopaHR0cF9oZWFkZXJzLCAoR0hGdW5jKWNvcHlfaGVhZGVyLCBwcml2LT5odHRwX2hlYWRlcnMp OworfQorCitjb25zdCBHSGFzaFRhYmxlKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRw X2hlYWRlcnMoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgZ19yZXR1cm5f dmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgTlVMTCk7CisK KyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2Owor ICAgIHJldHVybiBwcml2LT5odHRwX2hlYWRlcnM7Cit9CisKK3ZvaWQgd2Via2l0X25ldHdvcmtf cmVxdWVzdF9zZXRfaHR0cF9oZWFkZXIoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNv bnN0IGdjaGFyKiBodHRwX2hlYWRlciwgY29uc3QgZ2NoYXIqIHZhbHVlKQoreworICAgIGdfcmV0 dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CisgICAgZ19y ZXR1cm5faWZfZmFpbChodHRwX2hlYWRlcik7CisgICAgZ19yZXR1cm5faWZfZmFpbCh2YWx1ZSk7 CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2 OworICAgIEdIYXNoVGFibGUqIGhlYWRlcnMgPSBwcml2LT5odHRwX2hlYWRlcnM7CisKKyAgICBn X2hhc2hfdGFibGVfcmVwbGFjZShoZWFkZXJzLCBnX3N0cmR1cChodHRwX2hlYWRlciksIGdfc3Ry ZHVwKHZhbHVlKSk7Cit9CisKK2NvbnN0IGdjaGFyKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dl dF9odHRwX2hlYWRlcihXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIq IGh0dHBfaGVhZGVyKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRX T1JLX1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKGh0 dHBfaGVhZGVyLCBOVUxMKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJp diA9IHJlcXVlc3QtPnByaXY7CisgICAgR0hhc2hUYWJsZSogaGVhZGVycyA9IHByaXYtPmh0dHBf aGVhZGVyczsKKworICAgIHJldHVybiAoY29uc3QgZ2NoYXIqKWdfaGFzaF90YWJsZV9sb29rdXAo aGVhZGVycywgKGdjb25zdHBvaW50ZXIpaHR0cF9oZWFkZXIpOworfQorCit2b2lkIHdlYmtpdF9u ZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfY29udGVudF90eXBlKFdlYktpdE5ldHdvcmtSZXF1ZXN0 KiByZXF1ZXN0LCBjb25zdCBnY2hhciogaHR0cF9jb250ZW50X3R5cGUpCit7CisgICAgZ19yZXR1 cm5faWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpKTsKKyAgICBnX3Jl dHVybl9pZl9mYWlsKGh0dHBfY29udGVudF90eXBlKTsKKworICAgIHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3Rfc2V0X2h0dHBfaGVhZGVyKHJlcXVlc3QsICJDb250ZW50LVR5cGUiLCBodHRwX2NvbnRl bnRfdHlwZSk7Cit9CisKK2NvbnN0IGdjaGFyKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9o dHRwX2NvbnRlbnRfdHlwZShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBn X3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBO VUxMKTsKKworICAgIHJldHVybiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRl cihyZXF1ZXN0LCAiQ29udGVudC1UeXBlIik7Cit9CisKK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVx dWVzdF9zZXRfaHR0cF9yZWZlcmVyKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25z dCBnY2hhciogaHR0cF9yZWZlcmVyKQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lT X05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CisgICAgZ19yZXR1cm5faWZfZmFpbChodHRwX3Jl ZmVyZXIpOworCisgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9oZWFkZXIocmVx dWVzdCwgIlJlZmVyZXIiLCBodHRwX3JlZmVyZXIpOworfQorCitjb25zdCBnY2hhciogd2Via2l0 X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9yZWZlcmVyKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiBy ZXF1ZXN0KQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JF UVVFU1QocmVxdWVzdCksIE5VTEwpOworCisgICAgcmV0dXJuIHdlYmtpdF9uZXR3b3JrX3JlcXVl c3RfZ2V0X2h0dHBfaGVhZGVyKHJlcXVlc3QsICJSZWZlcmVyIik7Cit9CisKK3ZvaWQgd2Via2l0 X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF91c2VyX2FnZW50KFdlYktpdE5ldHdvcmtSZXF1ZXN0 KiByZXF1ZXN0LCBjb25zdCBnY2hhciogaHR0cF91c2VyX2FnZW50KQoreworICAgIGdfcmV0dXJu X2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CisgICAgZ19yZXR1 cm5faWZfZmFpbChodHRwX3VzZXJfYWdlbnQpOworCisgICAgd2Via2l0X25ldHdvcmtfcmVxdWVz dF9zZXRfaHR0cF9oZWFkZXIocmVxdWVzdCwgIlVzZXItQWdlbnQiLCBodHRwX3VzZXJfYWdlbnQp OworfQorCitjb25zdCBnY2hhciogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF91c2Vy X2FnZW50KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGdfcmV0dXJuX3Zh bF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOworCisg ICAgcmV0dXJuIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfaGVhZGVyKHJlcXVlc3Qs ICJVc2VyLUFnZW50Iik7Cit9CisKK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0 cF9hY2NlcHQoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRw X2FjY2VwdCkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVF U1QocmVxdWVzdCkpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwoaHR0cF9hY2NlcHQpOworCisgICAg d2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9oZWFkZXIocmVxdWVzdCwgIkFjY2VwdCIs IGh0dHBfYWNjZXB0KTsKK30KKworY29uc3QgZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf Z2V0X2h0dHBfYWNjZXB0KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGdf cmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIE5V TEwpOworCisgICAgcmV0dXJuIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfaGVhZGVy KHJlcXVlc3QsICJBY2NlcHQiKTsKK30KKwordm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3Nl dF9ib2R5KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciogYm9keSkK K3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVz dCkpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwoYm9keSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVx dWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgZ19mcmVlKHByaXYtPmJv ZHkpOworICAgIHByaXYtPmJvZHkgPSBnX3N0cmR1cChib2R5KTsKK30KKworY29uc3QgZ2NoYXIq IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2JvZHkoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJl cXVlc3QpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVR VUVTVChyZXF1ZXN0KSwgTlVMTCk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUq IHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgcmV0dXJuIChjb25zdCBnY2hhciopcHJpdi0+ Ym9keTsKK30KKwordm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9hbGxvd19odHRwX2Nv b2tpZXMoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdib29sZWFuIGFsbG93 X2h0dHBfY29va2llcykKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JL X1JFUVVFU1QocmVxdWVzdCkpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBw cml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIHByaXYtPmFsbG93X2h0dHBfY29va2llcyA9IGFs bG93X2h0dHBfY29va2llczsKK30KKworZ2Jvb2xlYW4gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9n ZXRfYWxsb3dfaHR0cF9jb29raWVzKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQorewor ICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVz dCksIEZBTFNFKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJl cXVlc3QtPnByaXY7CisKKyAgICByZXR1cm4gcHJpdi0+YWxsb3dfaHR0cF9jb29raWVzOworfQor CiB9CkluZGV4OiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmgJKHJldmlz aW9uIDMyNjY2KQorKysgV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuaAko d29ya2luZyBjb3B5KQpAQCAtNDUsNiArNDUsMTUgQEAgc3RydWN0IF9XZWJLaXROZXR3b3JrUmVx dWVzdENsYXNzIHsKICAgICBHT2JqZWN0Q2xhc3MgcGFyZW50X2NsYXNzOwogfTsKIAordHlwZWRl ZiBlbnVtCit7CisgIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX05PTkUsCisgIFdFQktJVF9SRVFf Q0FDSEVfUE9MSUNZX1BST1RPQ09MLAorICBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9SRUxPQURf SUdOT1JJTkdfQ0FDSEUsCisgIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX0FMTE9XX1NUQUxFLAor ICBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9DQUNIRV9PTkxZLAorfSBXZWJLaXRSZXFDYWNoZVBv bGljeTsKKwogV0VCS0lUX0FQSSBHVHlwZQogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdHlw ZSAodm9pZCk7CiAKQEAgLTU3LDYgKzY2LDc4IEBAIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0 X3VyaSAoV2ViS2l0TmUKIFdFQktJVF9BUEkgY29uc3QgZ2NoYXIqCiB3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X2dldF91cmkgKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKIAorV0VCS0lU X0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9jYWNoZV9wb2xpY3koV2ViS2l0 TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IFdlYktpdFJlcUNhY2hlUG9saWN5IGNhY2hl X3BvbGljeSk7CisKK1dFQktJVF9BUEkgV2ViS2l0UmVxQ2FjaGVQb2xpY3kKK3dlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfZ2V0X2NhY2hlX3BvbGljeShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVz dCk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdGltZW91 dF9pbnRlcnZhbChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2RvdWJsZSB0 aW1lb3V0X2ludGVydmFsKTsKKworV0VCS0lUX0FQSSBnZG91YmxlCit3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X2dldF90aW1lb3V0X2ludGVydmFsKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0 KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9tYWluX2Rv Y3VtZW50X3VyaShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIG1h aW5fZG9jdW1lbnRfdXJpKTsKKworV0VCS0lUX0FQSSBjb25zdCBnY2hhcioKK3dlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfZ2V0X21haW5fZG9jdW1lbnRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiBy ZXF1ZXN0KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9o dHRwX21ldGhvZCAoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBo dHRwX21ldGhvZCk7CisKK1dFQktJVF9BUEkgY29uc3QgZ2NoYXIqCit3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X2dldF9odHRwX21ldGhvZCAoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOwor CitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfaGVhZGVy cyAoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IEdIYXNoVGFibGUqIGh0dHBf aGVhZGVycyk7CisKK1dFQktJVF9BUEkgY29uc3QgR0hhc2hUYWJsZSoKK3dlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfZ2V0X2h0dHBfaGVhZGVycyAoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3Qp OworCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfaGVh ZGVyIChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfaGVh ZGVyLCBjb25zdCBnY2hhciogdmFsdWUpOworCitXRUJLSVRfQVBJIGNvbnN0IGdjaGFyKgord2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9oZWFkZXIgKFdlYktpdE5ldHdvcmtSZXF1ZXN0 KiByZXF1ZXN0LCBjb25zdCBnY2hhciogaHR0cF9oZWFkZXIpOworCitXRUJLSVRfQVBJIHZvaWQK K3dlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfY29udGVudF90eXBlKFdlYktpdE5ldHdv cmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciogaHR0cF9jb250ZW50X3R5cGUpOworCitX RUJLSVRfQVBJIGNvbnN0IGdjaGFyKgord2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9j b250ZW50X3R5cGUoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCitXRUJLSVRfQVBJ IHZvaWQKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfcmVmZXJlcihXZWJLaXROZXR3 b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfcmVmZXJlcik7CisKK1dFQktJ VF9BUEkgY29uc3QgZ2NoYXIqCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX3JlZmVy ZXIoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCitXRUJLSVRfQVBJIHZvaWQKK3dl YmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfdXNlcl9hZ2VudChXZWJLaXROZXR3b3JrUmVx dWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfdXNlcl9hZ2VudCk7CisKK1dFQktJVF9B UEkgY29uc3QgZ2NoYXIqCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX3VzZXJfYWdl bnQoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCitXRUJLSVRfQVBJIHZvaWQKK3dl YmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfYWNjZXB0KFdlYktpdE5ldHdvcmtSZXF1ZXN0 KiByZXF1ZXN0LCBjb25zdCBnY2hhciogaHR0cF9hY2NlcHQpOworCitXRUJLSVRfQVBJIGNvbnN0 IGdjaGFyKgord2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9hY2NlcHQoV2ViS2l0TmV0 d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF9uZXR3b3Jr X3JlcXVlc3Rfc2V0X2JvZHkoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdj aGFyKiBib2R5KTsKKworV0VCS0lUX0FQSSBjb25zdCBnY2hhcioKK3dlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X2JvZHkoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCitXRUJLSVRf QVBJIHZvaWQKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2FsbG93X2h0dHBfY29va2llcyhX ZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2Jvb2xlYW4gYWxsb3dfaHR0cF9j b29raWVzKTsKKworV0VCS0lUX0FQSSBnYm9vbGVhbgord2Via2l0X25ldHdvcmtfcmVxdWVzdF9n ZXRfYWxsb3dfaHR0cF9jb29raWVzKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKwog R19FTkRfREVDTFMKIAogI2VuZGlmCkluZGV4OiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2 YXRlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCShy ZXZpc2lvbiAzMjY2NikKKysrIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAkod29y a2luZyBjb3B5KQpAQCAtMTIxLDYgKzEyMSw5IEBAIGV4dGVybiAiQyIgewogCiAgICAgV0VCS0lU X0FQSSBnY2hhcioKICAgICB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3NlbGVjdGVkX3RleHQgKFdlYktp dFdlYlZpZXcqIHdlYl92aWV3KTsKKworICAgIC8vIEZJWE1FOiBTaG91bGQgdGhpcyBiZSBtb3Zl ZCB0byB3ZWJraXRuZXR3b3JrZXF1ZXN0Lmg/CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHdl YmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X2Zyb21fcmVzb3VyY2VfcmVxdWVzdChjb25zdCBXZWJD b3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCk7CiB9CiAKICNlbmRpZgpJbmRl eDogV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0NoYW5n ZUxvZwkocmV2aXNpb24gMzI3MTQpCisrKyBXZWJLaXRUb29scy9DaGFuZ2VMb2cJKHdvcmtpbmcg Y29weSkKQEAgLTEsMyArMSwyNCBAQAorMjAwOC0wNC0yOSAgR3VzdGF2byBOb3JvbmhhIFNpbHZh ICA8Z25zQGdub21lLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworCUltcGxlbWVudCBhIGRpYWxvZyB0byBzaG93IHRoZSByZXF1ZXN0cywgYXMgYSB0ZXN0IGZv ciB0aGUKKwlXZWJLaXROZXR3b3JrUmVxdWVzdCBBUEkuCisJCisgICAgICAgICogR3RrTGF1bmNo ZXIvbWFpbi5jOgorICAgICAgICAoc2hvd19odHRwX2luc3BlY3Rfd2luZG93X2NiKToKKyAgICAg ICAgKG5hdmlnYXRpb25fcmVxdWVzdGVkX2NiKToKKyAgICAgICAgKGFwcGVuZF9oZWFkZXJfdG9f aHR0cF9pbnNwZWN0X2hlYWRlcnNfbW9kZWwpOgorICAgICAgICAoY2FjaGVfcG9saWN5X3RvX3N0 cmluZyk6CisgICAgICAgIChodHRwX2luc3BlY3RfY3Vyc29yX2NoYW5nZWRfY2IpOgorICAgICAg ICAoY3JlYXRlX2h0dHBfaW5zcGVjdF93aW5kb3cpOgorICAgICAgICAoY3JlYXRlX2Jyb3dzZXIp OgorICAgICAgICAoY3JlYXRlX3Rvb2xiYXIpOgorICAgICAgICAobWFpbik6CisJQSBuZXcgZGlh bG9nIHdhcyBjcmVhdGVkLCB3aGljaCBpcyBhY2Nlc3NpYmxlIGZyb20gYSBidXR0b24gYXQgdGhl CisJbWFpbiB0b29sYmFyOyB0aGF0IGRpYWxvZyBsaXN0cyB0aGUgSFRUUCByZXF1ZXN0cyBhbmQg ZGlzcGxheXMKKwl0aGVpciBkZXRhaWxzLgorCiAyMDA4LTA0LTI5ICBBZGFtIFJvYmVuICA8YXJv YmVuQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXN0b3JlIHRoZSBiZWxvdmVkIENPTVB0cjo6b3Bl cmF0b3ImCkluZGV4OiBXZWJLaXRUb29scy9HdGtMYXVuY2hlci9tYWluLmMKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViS2l0VG9vbHMvR3RrTGF1bmNoZXIvbWFpbi5jCShyZXZpc2lvbiAzMjYwMykKKysrIFdl YktpdFRvb2xzL0d0a0xhdW5jaGVyL21haW4uYwkod29ya2luZyBjb3B5KQpAQCAtMzUsNiArMzUs MjIgQEAgc3RhdGljIGdjaGFyKiBtYWluX3RpdGxlOwogc3RhdGljIGdpbnQgbG9hZF9wcm9ncmVz czsKIHN0YXRpYyBndWludCBzdGF0dXNfY29udGV4dF9pZDsKIAorR3RrV2lkZ2V0KiBodHRwX2lu c3BlY3Rfd2luZG93OworR3RrV2lkZ2V0KiBodHRwX2luc3BlY3RfcmVxdWVzdHNfbGlzdDsKK0d0 a0xpc3RTdG9yZSogaHR0cF9pbnNwZWN0X3JlcXVlc3RzX21vZGVsOworR3RrV2lkZ2V0KiBodHRw X2luc3BlY3RfY2FjaGVfcG9saWN5X2xhYmVsOworR3RrV2lkZ2V0KiBodHRwX2luc3BlY3RfdGlt ZW91dF9pbnRlcnZhbF9sYWJlbDsKK0d0a1dpZGdldCogaHR0cF9pbnNwZWN0X21haW5fZG9jdW1l bnRfdXJpX2xhYmVsOworR3RrV2lkZ2V0KiBodHRwX2luc3BlY3RfbWV0aG9kX2xhYmVsOworR3Rr V2lkZ2V0KiBodHRwX2luc3BlY3RfY29udGVudF90eXBlX2xhYmVsOworR3RrV2lkZ2V0KiBodHRw X2luc3BlY3RfcmVmZXJlcl9sYWJlbDsKK0d0a1dpZGdldCogaHR0cF9pbnNwZWN0X3VzZXJfYWdl bnRfbGFiZWw7CitHdGtXaWRnZXQqIGh0dHBfaW5zcGVjdF9hY2NlcHRfbGFiZWw7CitHdGtXaWRn ZXQqIGh0dHBfaW5zcGVjdF9hbGxvd19odHRwX2Nvb2tpZXNfbGFiZWw7CitHdGtXaWRnZXQqIGh0 dHBfaW5zcGVjdF9oZWFkZXJzX2xpc3Q7CitHdGtXaWRnZXQqIGh0dHBfaW5zcGVjdF9ib2R5X3Rl eHRfdmlldzsKK0d0a0xpc3RTdG9yZSogaHR0cF9pbnNwZWN0X2hlYWRlcnNfbW9kZWw7CisKIHN0 YXRpYyB2b2lkCiBhY3RpdmF0ZV91cmlfZW50cnlfY2IgKEd0a1dpZGdldCogZW50cnksIGdwb2lu dGVyIGRhdGEpCiB7CkBAIC0xMDYsNiArMTIyLDM1MSBAQCBnb19mb3J3YXJkX2NiIChHdGtXaWRn ZXQqIHdpZGdldCwgZ3BvaW50CiAgICAgd2Via2l0X3dlYl92aWV3X2dvX2ZvcndhcmQgKHdlYl92 aWV3KTsKIH0KIAorc3RhdGljIHZvaWQKK3Nob3dfaHR0cF9pbnNwZWN0X3dpbmRvd19jYihHdGtX aWRnZXQqIHdpZGdldCwgZ3BvaW50ZXIgZGF0YSkKK3sKKyAgICBndGtfZGlhbG9nX3J1biAoR1RL X0RJQUxPRyhodHRwX2luc3BlY3Rfd2luZG93KSk7CisgICAgZ3RrX3dpZGdldF9oaWRlIChodHRw X2luc3BlY3Rfd2luZG93KTsKK30KKworc3RhdGljIHZvaWQKK25hdmlnYXRpb25fcmVxdWVzdGVk X2NiIChXZWJLaXRXZWJWaWV3KiB3ZWJfdmlldywgV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBXZWJL aXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgZ3BvaW50ZXIgZGF0YSkKK3sKKyAgICBHdGtMaXN0 U3RvcmUqIG1vZGVsID0gaHR0cF9pbnNwZWN0X3JlcXVlc3RzX21vZGVsOworICAgIEd0a1RyZWVJ dGVyIGl0ZXI7CisKKyAgICBnX29iamVjdF9yZWYgKHJlcXVlc3QpOworCisgICAgZ3RrX2xpc3Rf c3RvcmVfYXBwZW5kKG1vZGVsLCAmaXRlcik7CisgICAgZ3RrX2xpc3Rfc3RvcmVfc2V0KG1vZGVs LCAmaXRlciwKKyAgICAgICAgICAgICAgICAgICAgICAgMCwgd2Via2l0X25ldHdvcmtfcmVxdWVz dF9nZXRfdXJpIChyZXF1ZXN0KSwKKyAgICAgICAgICAgICAgICAgICAgICAgMSwgcmVxdWVzdCwK KyAgICAgICAgICAgICAgICAgICAgICAgLTEpOworfQorCitzdGF0aWMgdm9pZCBhcHBlbmRfaGVh ZGVyX3RvX2h0dHBfaW5zcGVjdF9oZWFkZXJzX21vZGVsIChnY2hhcioga2V5LCBnY2hhciogdmFs dWUsIEd0a1RyZWVTZWxlY3Rpb24qIHNlbGVjdGlvbikKK3sKKyAgICBHdGtMaXN0U3RvcmUqIG1v ZGVsID0gR1RLX0xJU1RfU1RPUkUoaHR0cF9pbnNwZWN0X2hlYWRlcnNfbW9kZWwpOworICAgIEd0 a1RyZWVJdGVyIGl0ZXI7CisgICAgCisgICAgZ3RrX2xpc3Rfc3RvcmVfYXBwZW5kIChtb2RlbCwg Jml0ZXIpOworICAgIGd0a19saXN0X3N0b3JlX3NldCAobW9kZWwsICZpdGVyLCAwLCBrZXksIDEs IHZhbHVlLCAtMSk7Cit9CisKK3N0YXRpYyBjb25zdCBnY2hhciogY2FjaGVfcG9saWN5X3RvX3N0 cmluZyAoV2ViS2l0UmVxQ2FjaGVQb2xpY3kgY2FjaGVfcG9saWN5KQoreworICAgIHN3aXRjaChj YWNoZV9wb2xpY3kpCisgICAgICAgIHsKKyAgICAgICAgY2FzZSBXRUJLSVRfUkVRX0NBQ0hFX1BP TElDWV9QUk9UT0NPTDoKKyAgICAgICAgICAgIHJldHVybiAiTm9ybWFsIGxvYWQiOworICAgICAg ICBjYXNlIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX1JFTE9BRF9JR05PUklOR19DQUNIRToKKyAg ICAgICAgICAgIHJldHVybiAiUmVsb2FkIjsKKyAgICAgICAgY2FzZSBXRUJLSVRfUkVRX0NBQ0hF X1BPTElDWV9BTExPV19TVEFMRToKKyAgICAgICAgICAgIHJldHVybiAiQWxsb3cgc3RhbGUgZGF0 YSI7CisgICAgICAgIGNhc2UgV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfQ0FDSEVfT05MWToKKyAg ICAgICAgICAgIHJldHVybiAiVXNlIGNhY2hlLCBvbmx5IjsKKyAgICAgICAgZGVmYXVsdDoKKyAg ICAgICAgICAgIHJldHVybiAiTm9uZSI7CisgICAgICAgIH0KK30KKwordm9pZCBodHRwX2luc3Bl Y3RfY3Vyc29yX2NoYW5nZWRfY2IgKEd0a1RyZWVWaWV3KiB0cmVlX3ZpZXcsIGdwb2ludGVyIGRh dGEpCit7CisgICAgR3RrVHJlZU1vZGVsKiBtb2RlbCA9IEdUS19UUkVFX01PREVMKGh0dHBfaW5z cGVjdF9yZXF1ZXN0c19tb2RlbCk7CisgICAgR3RrVHJlZVNlbGVjdGlvbiogc2VsZWN0aW9uID0g Z3RrX3RyZWVfdmlld19nZXRfc2VsZWN0aW9uICh0cmVlX3ZpZXcpOworICAgIEd0a1RyZWVJdGVy IGl0ZXI7CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3Q7CisKKyAgICBpZiAoZ3Rr X3RyZWVfc2VsZWN0aW9uX2dldF9zZWxlY3RlZCAoc2VsZWN0aW9uLCAmbW9kZWwsICZpdGVyKSkK KyAgICAgICAgeworICAgICAgICAgICAgZ2NoYXIqIHRtcDsKKworICAgICAgICAgICAgZ3RrX3Ry ZWVfbW9kZWxfZ2V0IChtb2RlbCwgJml0ZXIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIDEsICZyZXF1ZXN0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAtMSk7Cisg ICAgICAgICAgICAKKyAgICAgICAgICAgIGd0a19sYWJlbF9zZXRfdGV4dCAoR1RLX0xBQkVMKGh0 dHBfaW5zcGVjdF9jYWNoZV9wb2xpY3lfbGFiZWwpLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBjYWNoZV9wb2xpY3lfdG9fc3RyaW5nICh3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dl dF9jYWNoZV9wb2xpY3kgKHJlcXVlc3QpKSk7CisgICAgICAgICAgICB0bXAgPSBnX3N0cmR1cF9w cmludGYgKCIlLjJmIiwgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdGltZW91dF9pbnRlcnZh bCAocmVxdWVzdCkpOworICAgICAgICAgICAgZ3RrX2xhYmVsX3NldF90ZXh0IChHVEtfTEFCRUwo aHR0cF9pbnNwZWN0X3RpbWVvdXRfaW50ZXJ2YWxfbGFiZWwpLCB0bXApOworICAgICAgICAgICAg Z19mcmVlICh0bXApOworICAgICAgICAgICAgZ3RrX2xhYmVsX3NldF90ZXh0IChHVEtfTEFCRUwo aHR0cF9pbnNwZWN0X21haW5fZG9jdW1lbnRfdXJpX2xhYmVsKSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWFpbl9kb2N1bWVudF91 cmkgKHJlcXVlc3QpKTsKKyAgICAgICAgICAgIGd0a19sYWJlbF9zZXRfdGV4dCAoR1RLX0xBQkVM KGh0dHBfaW5zcGVjdF9tZXRob2RfbGFiZWwpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX21ldGhvZCAocmVxdWVzdCkpOwor ICAgICAgICAgICAgZ3RrX2xhYmVsX3NldF90ZXh0IChHVEtfTEFCRUwoaHR0cF9pbnNwZWN0X2Nv bnRlbnRfdHlwZV9sYWJlbCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHdlYmtp dF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfY29udGVudF90eXBlIChyZXF1ZXN0KSk7CisgICAg ICAgICAgICBndGtfbGFiZWxfc2V0X3RleHQgKEdUS19MQUJFTChodHRwX2luc3BlY3RfcmVmZXJl cl9sYWJlbCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfZ2V0X2h0dHBfcmVmZXJlciAocmVxdWVzdCkpOworICAgICAgICAgICAgZ3RrX2xh YmVsX3NldF90ZXh0IChHVEtfTEFCRUwoaHR0cF9pbnNwZWN0X3VzZXJfYWdlbnRfbGFiZWwpLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dl dF9odHRwX3VzZXJfYWdlbnQgKHJlcXVlc3QpKTsKKyAgICAgICAgICAgIGd0a19sYWJlbF9zZXRf dGV4dCAoR1RLX0xBQkVMKGh0dHBfaW5zcGVjdF9hY2NlcHRfbGFiZWwpLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2FjY2Vw dCAocmVxdWVzdCkpOworICAgICAgICAgICAgZ3RrX2xhYmVsX3NldF90ZXh0IChHVEtfTEFCRUwo aHR0cF9pbnNwZWN0X2FsbG93X2h0dHBfY29va2llc19sYWJlbCksCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2FsbG93X2h0dHBfY29v a2llcyAocmVxdWVzdCkgPyAiVHJ1ZSIgOiAiRmFsc2UiKTsKKworICAgICAgICAgICAgZ3RrX2xp c3Rfc3RvcmVfY2xlYXIgKGh0dHBfaW5zcGVjdF9oZWFkZXJzX21vZGVsKTsKKyAgICAgICAgICAg IGdfaGFzaF90YWJsZV9mb3JlYWNoICgoR0hhc2hUYWJsZSopd2Via2l0X25ldHdvcmtfcmVxdWVz dF9nZXRfaHR0cF9oZWFkZXJzIChyZXF1ZXN0KSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAoR0hGdW5jKWFwcGVuZF9oZWFkZXJfdG9faHR0cF9pbnNwZWN0X2hlYWRlcnNfbW9k ZWwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKGdwb2ludGVyKXNlbGVjdGlv bik7CisKKyAgICAgICAgICAgIEd0a1RleHRCdWZmZXIqIHRleHRfYnVmZmVyID0gZ3RrX3RleHRf dmlld19nZXRfYnVmZmVyIChHVEtfVEVYVF9WSUVXKGh0dHBfaW5zcGVjdF9ib2R5X3RleHRfdmll dykpOworICAgICAgICAgICAgR3RrVGV4dEl0ZXIgc3RhcnQsIGVuZDsKKyAgICAgICAgICAgIGd0 a190ZXh0X2J1ZmZlcl9nZXRfYm91bmRzICh0ZXh0X2J1ZmZlciwgJnN0YXJ0LCAmZW5kKTsKKyAg ICAgICAgICAgIGd0a190ZXh0X2J1ZmZlcl9kZWxldGUgKHRleHRfYnVmZmVyLCAmc3RhcnQsICZl bmQpOworCisgICAgICAgICAgICBjb25zdCBnY2hhciAqYm9keSA9IHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X2JvZHkgKHJlcXVlc3QpOworICAgICAgICAgICAgaWYgKGJvZHkpCisgICAgICAg ICAgICAgICAgZ3RrX3RleHRfYnVmZmVyX3NldF90ZXh0ICh0ZXh0X2J1ZmZlciwgYm9keSwgLTEp OworICAgICAgICB9Cit9CisKK3N0YXRpYyBHdGtXaWRnZXQqCitjcmVhdGVfaHR0cF9pbnNwZWN0 X3dpbmRvdyAoKQoreworICAgIEd0a1dpZGdldCogd2luZG93ID0gZ3RrX2RpYWxvZ19uZXdfd2l0 aF9idXR0b25zICgiSFRUUCBSZXF1ZXN0cyIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIEdUS19XSU5ET1cobWFpbl93aW5kb3cpLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtfRElBTE9H X0RFU1RST1lfV0lUSF9QQVJFTlQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIEdUS19TVE9DS19DTE9TRSwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR1RLX1JFU1BPTlNFX0RFTEVURV9FVkVO VCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg TlVMTCk7CisgICAgZ3RrX3dpbmRvd19zZXRfZGVmYXVsdF9zaXplIChHVEtfV0lORE9XKHdpbmRv dyksIDgwMCwgNjAwKTsKKworICAgIC8vIGJhc2ljIGxheW91dAorICAgIEd0a1dpZGdldCogdmJv eCA9IEdUS19ESUFMT0cod2luZG93KS0+dmJveDsKKyAgICBHdGtXaWRnZXQqIHBhbmVkID0gZ3Rr X2hwYW5lZF9uZXcgKCk7CisgICAgZ3RrX2JveF9wYWNrX3N0YXJ0IChHVEtfQk9YKHZib3gpLCBw YW5lZCwgVFJVRSwgVFJVRSwgMTIpOworICAgIGd0a193aWRnZXRfc2hvdyhwYW5lZCk7CisKKyAg ICBHdGtXaWRnZXQqIHNjcm9sbGVkX3dpbmRvdyA9IGd0a19zY3JvbGxlZF93aW5kb3dfbmV3IChO VUxMLCBOVUxMKTsKKyAgICBndGtfc2Nyb2xsZWRfd2luZG93X3NldF9wb2xpY3kgKEdUS19TQ1JP TExFRF9XSU5ET1coc2Nyb2xsZWRfd2luZG93KSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIEdUS19QT0xJQ1lfQVVUT01BVElDLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgR1RLX1BPTElDWV9BVVRPTUFUSUMpOworICAgIGd0a193aWRnZXRfc2V0X3Np emVfcmVxdWVzdCAoc2Nyb2xsZWRfd2luZG93LCAyMDAsIC0xKTsKKyAgICBndGtfcGFuZWRfYWRk MSAoR1RLX1BBTkVEKHBhbmVkKSwgc2Nyb2xsZWRfd2luZG93KTsKKyAgICBndGtfd2lkZ2V0X3No b3cgKHNjcm9sbGVkX3dpbmRvdyk7CisKKyAgICAvLyB0aGUgdHJlZQorICAgIGh0dHBfaW5zcGVj dF9yZXF1ZXN0c19saXN0ID0gZ3RrX3RyZWVfdmlld19uZXcgKCk7CisgICAgZ3RrX3RyZWVfdmll d19zZXRfaGVhZGVyc192aXNpYmxlIChHVEtfVFJFRV9WSUVXKGh0dHBfaW5zcGVjdF9yZXF1ZXN0 c19saXN0KSwgRkFMU0UpOworICAgIGd0a190cmVlX3ZpZXdfYXBwZW5kX2NvbHVtbiAoR1RLX1RS RUVfVklFVyhodHRwX2luc3BlY3RfcmVxdWVzdHNfbGlzdCksCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBndGtfdHJlZV92aWV3X2NvbHVtbl9uZXdfd2l0aF9hdHRyaWJ1dGVzICgi VVJJIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGd0a19jZWxsX3JlbmRlcmVyX3RleHRfbmV3KCksCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAidGV4dCIsIDAsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMKSk7Cisg ICAgZ19zaWduYWxfY29ubmVjdChodHRwX2luc3BlY3RfcmVxdWVzdHNfbGlzdCwgImN1cnNvci1j aGFuZ2VkIiwKKyAgICAgICAgICAgICAgICAgICAgIEdfQ0FMTEJBQ0soaHR0cF9pbnNwZWN0X2N1 cnNvcl9jaGFuZ2VkX2NiKSwgTlVMTCk7CisgICAgZ3RrX2NvbnRhaW5lcl9hZGQgKEdUS19DT05U QUlORVIoc2Nyb2xsZWRfd2luZG93KSwgaHR0cF9pbnNwZWN0X3JlcXVlc3RzX2xpc3QpOworICAg IGd0a193aWRnZXRfc2hvdyAoaHR0cF9pbnNwZWN0X3JlcXVlc3RzX2xpc3QpOworCisgICAgaHR0 cF9pbnNwZWN0X3JlcXVlc3RzX21vZGVsID0gZ3RrX2xpc3Rfc3RvcmVfbmV3ICgyLCBHX1RZUEVf U1RSSU5HLCBXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIC0xKTsKKyAgICBndGtfdHJlZV92 aWV3X3NldF9tb2RlbCAoR1RLX1RSRUVfVklFVyhodHRwX2luc3BlY3RfcmVxdWVzdHNfbGlzdCks IEdUS19UUkVFX01PREVMKGh0dHBfaW5zcGVjdF9yZXF1ZXN0c19tb2RlbCkpOworCisgICAgLy8g bW9yZSBsYXlvdXRpbmcsIGZvciB0aGUgcmlnaHQgc2lkZSBvZiB0aGUgd2luZG93CisgICAgR3Rr V2lkZ2V0KiBydmJveCA9IGd0a192Ym94X25ldyAoRkFMU0UsIDIpOworICAgIGd0a19wYW5lZF9h ZGQyIChHVEtfUEFORUQocGFuZWQpLCBydmJveCk7CisgICAgZ3RrX3dpZGdldF9zaG93IChydmJv eCk7CisKKyAgICBHdGtXaWRnZXQqIHRhYmxlID0gZ3RrX3RhYmxlX25ldyAoOCwgMiwgRkFMU0Up OworICAgIGd0a190YWJsZV9zZXRfcm93X3NwYWNpbmdzIChHVEtfVEFCTEUodGFibGUpLCAxMik7 CisgICAgZ3RrX2JveF9wYWNrX3N0YXJ0IChHVEtfQk9YKHJ2Ym94KSwgdGFibGUsIEZBTFNFLCBG QUxTRSwgMCk7CisgICAgZ3RrX3dpZGdldF9zaG93ICh0YWJsZSk7CisKKyAgICAvLyBkZXRhaWxz IG9mIHRoZSByZXF1ZXN0CisgICAgLy8gQ2FjaGUgUG9saWN5CisgICAgR3RrV2lkZ2V0KiBsYWJl bCA9IGdfb2JqZWN0X25ldyAoR1RLX1RZUEVfTEFCRUwsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgImxhYmVsIiwgIjxiPkNhY2hlIFBvbGljeTwvYj4iLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICJ1c2UtbWFya3VwIiwgVFJVRSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMKTsKKyAgICBndGtfdGFibGVfYXR0YWNo X2RlZmF1bHRzIChHVEtfVEFCTEUodGFibGUpLCBsYWJlbCwgMCwgMSwgMCwgMSk7CisgICAgZ3Rr X3dpZGdldF9zaG93KGxhYmVsKTsKKworICAgIGh0dHBfaW5zcGVjdF9jYWNoZV9wb2xpY3lfbGFi ZWwgPSBnX29iamVjdF9uZXcgKEdUS19UWVBFX0xBQkVMLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJsYWJlbCIsICIiLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJ3cmFwIiwgVFJVRSwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMKTsK KyAgICBndGtfdGFibGVfYXR0YWNoX2RlZmF1bHRzIChHVEtfVEFCTEUodGFibGUpLCBodHRwX2lu c3BlY3RfY2FjaGVfcG9saWN5X2xhYmVsLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IDEsIDIsIDAsIDEpOworICAgIGd0a193aWRnZXRfc2hvdyhodHRwX2luc3BlY3RfY2FjaGVfcG9s aWN5X2xhYmVsKTsKKworICAgIC8vIFRpbWVvdXQgSW50ZXJ2YWwKKyAgICBsYWJlbCA9IGdfb2Jq ZWN0X25ldyAoR1RLX1RZUEVfTEFCRUwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICJsYWJl bCIsICI8Yj5UaW1lb3V0IGludGVydmFsPC9iPiIsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICJ1c2UtbWFya3VwIiwgVFJVRSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7Cisg ICAgZ3RrX3RhYmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgbGFiZWwsIDAs IDEsIDEsIDIpOworICAgIGd0a193aWRnZXRfc2hvdyhsYWJlbCk7CisKKyAgICBodHRwX2luc3Bl Y3RfdGltZW91dF9pbnRlcnZhbF9sYWJlbCA9IGdfb2JqZWN0X25ldyAoR1RLX1RZUEVfTEFCRUws CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICJsYWJlbCIsICIiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAid3JhcCIsIFRSVUUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOworICAgIGd0a190YWJsZV9hdHRhY2hf ZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJsZSksIGh0dHBfaW5zcGVjdF90aW1lb3V0X2ludGVydmFs X2xhYmVsLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDEsIDIsIDEsIDIpOworICAg IGd0a193aWRnZXRfc2hvdyhodHRwX2luc3BlY3RfdGltZW91dF9pbnRlcnZhbF9sYWJlbCk7CisK KyAgICAvLyBNYWluIGRvY3VtZW50IFVSSQorICAgIGxhYmVsID0gZ19vYmplY3RfbmV3IChHVEtf VFlQRV9MQUJFTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgImxhYmVsIiwgIjxiPk1haW4g ZG9jdW1lbnQgVVJJPC9iPiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICJ1c2UtbWFya3Vw IiwgVFJVRSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7CisgICAgZ3RrX3RhYmxl X2F0dGFjaF9kZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgbGFiZWwsIDAsIDEsIDIsIDMpOwor ICAgIGd0a193aWRnZXRfc2hvdyhsYWJlbCk7CisKKyAgICBodHRwX2luc3BlY3RfbWFpbl9kb2N1 bWVudF91cmlfbGFiZWwgPSBnX29iamVjdF9uZXcgKEdUS19UWVBFX0xBQkVMLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgImxhYmVsIiwg IiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAid3JhcCIsIFRSVUUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBOVUxMKTsKKyAgICBndGtfdGFibGVfYXR0YWNoX2RlZmF1bHRz IChHVEtfVEFCTEUodGFibGUpLCBodHRwX2luc3BlY3RfbWFpbl9kb2N1bWVudF91cmlfbGFiZWws CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMSwgMiwgMiwgMyk7CisgICAgZ3RrX3dp ZGdldF9zaG93KGh0dHBfaW5zcGVjdF9tYWluX2RvY3VtZW50X3VyaV9sYWJlbCk7CisKKyAgICAv LyBIVFRQIG1ldGhvZAorICAgIGxhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJFTCwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgImxhYmVsIiwgIjxiPk1ldGhvZDwvYj4iLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAidXNlLW1hcmt1cCIsIFRSVUUsCisgICAgICAgICAgICAg ICAgICAgICAgICAgIE5VTEwpOworICAgIGd0a190YWJsZV9hdHRhY2hfZGVmYXVsdHMgKEdUS19U QUJMRSh0YWJsZSksIGxhYmVsLCAwLCAxLCAzLCA0KTsKKyAgICBndGtfd2lkZ2V0X3Nob3cobGFi ZWwpOworCisgICAgaHR0cF9pbnNwZWN0X21ldGhvZF9sYWJlbCA9IGdfb2JqZWN0X25ldyAoR1RL X1RZUEVfTEFCRUwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgImxhYmVsIiwgIiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIndyYXAiLCBUUlVFLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIE5VTEwpOworICAgIGd0a190YWJsZV9hdHRhY2hfZGVmYXVsdHMgKEdUS19UQUJM RSh0YWJsZSksIGh0dHBfaW5zcGVjdF9tZXRob2RfbGFiZWwsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgMSwgMiwgMywgNCk7CisgICAgZ3RrX3dpZGdldF9zaG93KGh0dHBfaW5zcGVj dF9tZXRob2RfbGFiZWwpOworCisgICAgLy8gSFRUUCBDb250ZW50IFR5cGUKKyAgICBsYWJlbCA9 IGdfb2JqZWN0X25ldyAoR1RLX1RZUEVfTEFCRUwsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICJsYWJlbCIsICI8Yj5Db250ZW50IFR5cGU8L2I+IiwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgInVzZS1tYXJrdXAiLCBUUlVFLAorICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMKTsK KyAgICBndGtfdGFibGVfYXR0YWNoX2RlZmF1bHRzIChHVEtfVEFCTEUodGFibGUpLCBsYWJlbCwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAwLCAxLCA0LCA1KTsKKyAgICBndGtfd2lk Z2V0X3Nob3cobGFiZWwpOworCisgICAgaHR0cF9pbnNwZWN0X2NvbnRlbnRfdHlwZV9sYWJlbCA9 IGdfb2JqZWN0X25ldyAoR1RLX1RZUEVfTEFCRUwsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgImxhYmVsIiwgIiIsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIndyYXAiLCBUUlVFLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOworICAg IGd0a190YWJsZV9hdHRhY2hfZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJsZSksIGh0dHBfaW5zcGVj dF9jb250ZW50X3R5cGVfbGFiZWwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMSwg MiwgNCwgNSk7CisgICAgZ3RrX3dpZGdldF9zaG93KGh0dHBfaW5zcGVjdF9jb250ZW50X3R5cGVf bGFiZWwpOworCisgICAgLy8gSFRUUCBSZWZlcmVyCisgICAgbGFiZWwgPSBnX29iamVjdF9uZXcg KEdUS19UWVBFX0xBQkVMLAorICAgICAgICAgICAgICAgICAgICAgICAgICAibGFiZWwiLCAiPGI+ UmVmZXJlcjwvYj4iLAorICAgICAgICAgICAgICAgICAgICAgICAgICAidXNlLW1hcmt1cCIsIFRS VUUsCisgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOworICAgIGd0a190YWJsZV9hdHRh Y2hfZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJsZSksIGxhYmVsLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIDAsIDEsIDUsIDYpOworICAgIGd0a193aWRnZXRfc2hvdyhsYWJlbCk7CisK KyAgICBodHRwX2luc3BlY3RfcmVmZXJlcl9sYWJlbCA9IGdfb2JqZWN0X25ldyAoR1RLX1RZUEVf TEFCRUwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgImxh YmVsIiwgIiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICJ3cmFwIiwgVFJVRSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBOVUxMKTsKKyAgICBndGtfdGFibGVfYXR0YWNoX2RlZmF1bHRzIChHVEtfVEFCTEUodGFi bGUpLCBodHRwX2luc3BlY3RfcmVmZXJlcl9sYWJlbCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAxLCAyLCA1LCA2KTsKKyAgICBndGtfd2lkZ2V0X3Nob3coaHR0cF9pbnNwZWN0X3Jl ZmVyZXJfbGFiZWwpOworCisgICAgLy8gSFRUUCBVc2VyIEFnZW50CisgICAgbGFiZWwgPSBnX29i amVjdF9uZXcgKEdUS19UWVBFX0xBQkVMLAorICAgICAgICAgICAgICAgICAgICAgICAgICAibGFi ZWwiLCAiPGI+VXNlciBBZ2VudDwvYj4iLAorICAgICAgICAgICAgICAgICAgICAgICAgICAidXNl LW1hcmt1cCIsIFRSVUUsCisgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOworICAgIGd0 a190YWJsZV9hdHRhY2hfZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJsZSksIGxhYmVsLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIDAsIDEsIDYsIDcpOworICAgIGd0a193aWRnZXRfc2hv dyhsYWJlbCk7CisKKyAgICBodHRwX2luc3BlY3RfdXNlcl9hZ2VudF9sYWJlbCA9IGdfb2JqZWN0 X25ldyAoR1RLX1RZUEVfTEFCRUwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICJsYWJlbCIsICIiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAid3JhcCIsIFRSVUUsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOworICAgIGd0a190YWJsZV9hdHRh Y2hfZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJsZSksIGh0dHBfaW5zcGVjdF91c2VyX2FnZW50X2xh YmVsLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDEsIDIsIDYsIDcpOworICAgIGd0 a193aWRnZXRfc2hvdyhodHRwX2luc3BlY3RfdXNlcl9hZ2VudF9sYWJlbCk7CisKKyAgICAvLyBI VFRQIEFjY2VwdAorICAgIGxhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJFTCwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgImxhYmVsIiwgIjxiPkFjY2VwdDwvYj4iLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAidXNlLW1hcmt1cCIsIFRSVUUsCisgICAgICAgICAgICAgICAg ICAgICAgICAgIE5VTEwpOworICAgIGd0a190YWJsZV9hdHRhY2hfZGVmYXVsdHMgKEdUS19UQUJM RSh0YWJsZSksIGxhYmVsLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDAsIDEsIDcs IDgpOworICAgIGd0a193aWRnZXRfc2hvdyhsYWJlbCk7CisKKyAgICBodHRwX2luc3BlY3RfYWNj ZXB0X2xhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJFTCwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAibGFiZWwiLCAiIiwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAid3JhcCIsIFRSVUUsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7CisgICAgZ3RrX3Rh YmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgaHR0cF9pbnNwZWN0X2FjY2Vw dF9sYWJlbCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxLCAyLCA3LCA4KTsKKyAg ICBndGtfd2lkZ2V0X3Nob3coaHR0cF9pbnNwZWN0X2FjY2VwdF9sYWJlbCk7CisKKyAgICAvLyBB bGxvdyBIVFRQIENvb2tpZXMKKyAgICBsYWJlbCA9IGdfb2JqZWN0X25ldyAoR1RLX1RZUEVfTEFC RUwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICJsYWJlbCIsICI8Yj5BbGxvdyBIVFRQIENv b2tpZXM8L2I+IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgInVzZS1tYXJrdXAiLCBUUlVF LAorICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMKTsKKyAgICBndGtfdGFibGVfYXR0YWNo X2RlZmF1bHRzIChHVEtfVEFCTEUodGFibGUpLCBsYWJlbCwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAwLCAxLCA4LCA5KTsKKyAgICBndGtfd2lkZ2V0X3Nob3cobGFiZWwpOworCisg ICAgaHR0cF9pbnNwZWN0X2FsbG93X2h0dHBfY29va2llc19sYWJlbCA9IGdfb2JqZWN0X25ldyAo R1RLX1RZUEVfTEFCRUwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgImxhYmVsIiwgIiIsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIndyYXAiLCBUUlVFLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOwor ICAgIGd0a190YWJsZV9hdHRhY2hfZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJsZSksIGh0dHBfaW5z cGVjdF9hbGxvd19odHRwX2Nvb2tpZXNfbGFiZWwsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgMSwgMiwgNywgOCk7CisgICAgZ3RrX3dpZGdldF9zaG93KGh0dHBfaW5zcGVjdF9hY2Nl cHRfbGFiZWwpOworCisgICAgLy8gaGVhZGVycyBsaXN0aW5nCisgICAgR3RrV2lkZ2V0KiBleHBh bmRlciA9IGd0a19leHBhbmRlcl9uZXcgKCJIZWFkZXJzLi4uIik7CisgICAgZ3RrX2JveF9wYWNr X3N0YXJ0IChHVEtfQk9YKHJ2Ym94KSwgZXhwYW5kZXIsIEZBTFNFLCBGQUxTRSwgMCk7CisgICAg Z3RrX3dpZGdldF9zaG93IChleHBhbmRlcik7CisKKyAgICBzY3JvbGxlZF93aW5kb3cgPSBndGtf c2Nyb2xsZWRfd2luZG93X25ldyAoTlVMTCwgTlVMTCk7CisgICAgZ3RrX3Njcm9sbGVkX3dpbmRv d19zZXRfcG9saWN5IChHVEtfU0NST0xMRURfV0lORE9XKHNjcm9sbGVkX3dpbmRvdyksIEdUS19Q T0xJQ1lfQVVUT01BVElDLCBHVEtfUE9MSUNZX0FVVE9NQVRJQyk7CisgICAgZ3RrX3dpZGdldF9z ZXRfc2l6ZV9yZXF1ZXN0IChzY3JvbGxlZF93aW5kb3csIC0xLCAxODApOworICAgIGd0a19jb250 YWluZXJfYWRkIChHVEtfQ09OVEFJTkVSKGV4cGFuZGVyKSwgc2Nyb2xsZWRfd2luZG93KTsKKyAg ICBndGtfd2lkZ2V0X3Nob3cgKHNjcm9sbGVkX3dpbmRvdyk7CisKKyAgICBodHRwX2luc3BlY3Rf aGVhZGVyc19saXN0ID0gZ3RrX3RyZWVfdmlld19uZXcgKCk7CisgICAgZ3RrX3RyZWVfdmlld19h cHBlbmRfY29sdW1uIChHVEtfVFJFRV9WSUVXKGh0dHBfaW5zcGVjdF9oZWFkZXJzX2xpc3QpLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ3RrX3RyZWVfdmlld19jb2x1bW5fbmV3 X3dpdGhfYXR0cmlidXRlcyAoIkhlYWRlciIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBndGtfY2VsbF9y ZW5kZXJlcl90ZXh0X25ldyAoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJ0ZXh0IiwgMCwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIE5VTEwpKTsKKyAgICBndGtfdHJlZV92aWV3X2FwcGVuZF9jb2x1bW4gKEdU S19UUkVFX1ZJRVcoaHR0cF9pbnNwZWN0X2hlYWRlcnNfbGlzdCksCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBndGtfdHJlZV92aWV3X2NvbHVtbl9uZXdfd2l0aF9hdHRyaWJ1dGVz ICgiVmFsdWUiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ3RrX2NlbGxfcmVuZGVyZXJfdGV4dF9uZXcg KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAidGV4dCIsIDEsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxM KSk7CisgICAgZ3RrX2NvbnRhaW5lcl9hZGQgKEdUS19DT05UQUlORVIoc2Nyb2xsZWRfd2luZG93 KSwgaHR0cF9pbnNwZWN0X2hlYWRlcnNfbGlzdCk7CisgICAgZ3RrX3dpZGdldF9zaG93IChodHRw X2luc3BlY3RfaGVhZGVyc19saXN0KTsKKworICAgIGh0dHBfaW5zcGVjdF9oZWFkZXJzX21vZGVs ID0gZ3RrX2xpc3Rfc3RvcmVfbmV3ICgyLCBHX1RZUEVfU1RSSU5HLCBHX1RZUEVfU1RSSU5HKTsK KyAgICBndGtfdHJlZV92aWV3X3NldF9tb2RlbCAoR1RLX1RSRUVfVklFVyhodHRwX2luc3BlY3Rf aGVhZGVyc19saXN0KSwgR1RLX1RSRUVfTU9ERUwoaHR0cF9pbnNwZWN0X2hlYWRlcnNfbW9kZWwp KTsKKworICAgIC8vIHJlcXVlc3QgYm9keQorICAgIEd0a1dpZGdldCogZnJhbWUgPSBndGtfZnJh bWVfbmV3ICgiQm9keSIpOworICAgIGd0a19ib3hfcGFja19zdGFydCAoR1RLX0JPWChydmJveCks IGZyYW1lLCBUUlVFLCBUUlVFLCAwKTsKKyAgICBndGtfd2lkZ2V0X3Nob3cgKGZyYW1lKTsKKwor ICAgIHNjcm9sbGVkX3dpbmRvdyA9IGd0a19zY3JvbGxlZF93aW5kb3dfbmV3IChOVUxMLCBOVUxM KTsKKyAgICBndGtfc2Nyb2xsZWRfd2luZG93X3NldF9wb2xpY3kgKEdUS19TQ1JPTExFRF9XSU5E T1coc2Nyb2xsZWRfd2luZG93KSwgR1RLX1BPTElDWV9BVVRPTUFUSUMsIEdUS19QT0xJQ1lfQVVU T01BVElDKTsKKyAgICBndGtfY29udGFpbmVyX2FkZCAoR1RLX0NPTlRBSU5FUihmcmFtZSksIHNj cm9sbGVkX3dpbmRvdyk7CisgICAgZ3RrX3dpZGdldF9zaG93IChzY3JvbGxlZF93aW5kb3cpOwor CisgICAgaHR0cF9pbnNwZWN0X2JvZHlfdGV4dF92aWV3ID0gZ3RrX3RleHRfdmlld19uZXcgKCk7 CisgICAgZ3RrX2NvbnRhaW5lcl9hZGQgKEdUS19DT05UQUlORVIoc2Nyb2xsZWRfd2luZG93KSwg aHR0cF9pbnNwZWN0X2JvZHlfdGV4dF92aWV3KTsKKyAgICBndGtfd2lkZ2V0X3Nob3cgKGh0dHBf aW5zcGVjdF9ib2R5X3RleHRfdmlldyk7CisKKyAgICByZXR1cm4gd2luZG93OworfQorCiBzdGF0 aWMgR3RrV2lkZ2V0KgogY3JlYXRlX2Jyb3dzZXIgKCkKIHsKQEAgLTExOSw2ICs0ODAsNyBAQCBj cmVhdGVfYnJvd3NlciAoKQogICAgIGdfc2lnbmFsX2Nvbm5lY3QgKEdfT0JKRUNUICh3ZWJfdmll dyksICJsb2FkLXByb2dyZXNzLWNoYW5nZWQiLCBHX0NBTExCQUNLIChwcm9ncmVzc19jaGFuZ2Vf Y2IpLCB3ZWJfdmlldyk7CiAgICAgZ19zaWduYWxfY29ubmVjdCAoR19PQkpFQ1QgKHdlYl92aWV3 KSwgImxvYWQtY29tbWl0dGVkIiwgR19DQUxMQkFDSyAobG9hZF9jb21taXRfY2IpLCB3ZWJfdmll dyk7CiAgICAgZ19zaWduYWxfY29ubmVjdCAoR19PQkpFQ1QgKHdlYl92aWV3KSwgImhvdmVyaW5n LW92ZXItbGluayIsIEdfQ0FMTEJBQ0sgKGxpbmtfaG92ZXJfY2IpLCB3ZWJfdmlldyk7CisgICAg Z19zaWduYWxfY29ubmVjdCAoR19PQkpFQ1QgKHdlYl92aWV3KSwgIm5hdmlnYXRpb24tcmVxdWVz dGVkIiwgR19DQUxMQkFDSyAobmF2aWdhdGlvbl9yZXF1ZXN0ZWRfY2IpLCB3ZWJfdmlldyk7CiAK ICAgICByZXR1cm4gc2Nyb2xsZWRfd2luZG93OwogfQpAQCAtMTUyLDYgKzUxNCwxMSBAQCBjcmVh dGVfdG9vbGJhciAoKQogICAgIGdfc2lnbmFsX2Nvbm5lY3QgKEdfT0JKRUNUIChpdGVtKSwgImNs aWNrZWQiLCBHX0NBTExCQUNLIChnb19mb3J3YXJkX2NiKSwgTlVMTCk7CiAgICAgZ3RrX3Rvb2xi YXJfaW5zZXJ0IChHVEtfVE9PTEJBUiAodG9vbGJhciksIGl0ZW0sIC0xKTsKIAorICAgIC8qIFRo ZSBodHRwIGluc3BlY3QgYnV0dG9uICovCisgICAgaXRlbSA9IGd0a190b29sX2J1dHRvbl9uZXdf ZnJvbV9zdG9jayAoR1RLX1NUT0NLX05FVFdPUkspOworICAgIGdfc2lnbmFsX2Nvbm5lY3QgKEdf T0JKRUNUIChpdGVtKSwgImNsaWNrZWQiLCBHX0NBTExCQUNLIChzaG93X2h0dHBfaW5zcGVjdF93 aW5kb3dfY2IpLCBOVUxMKTsKKyAgICBndGtfdG9vbGJhcl9pbnNlcnQgKEdUS19UT09MQkFSICh0 b29sYmFyKSwgaXRlbSwgLTEpOworCiAgICAgLyogVGhlIFVSTCBlbnRyeSAqLwogICAgIGl0ZW0g PSBndGtfdG9vbF9pdGVtX25ldyAoKTsKICAgICBndGtfdG9vbF9pdGVtX3NldF9leHBhbmQgKGl0 ZW0sIFRSVUUpOwpAQCAtMTkyLDYgKzU1OSw4IEBAIG1haW4gKGludCBhcmdjLCBjaGFyKiBhcmd2 W10pCiAgICAgbWFpbl93aW5kb3cgPSBjcmVhdGVfd2luZG93ICgpOwogICAgIGd0a19jb250YWlu ZXJfYWRkIChHVEtfQ09OVEFJTkVSIChtYWluX3dpbmRvdyksIHZib3gpOwogCisgICAgaHR0cF9p bnNwZWN0X3dpbmRvdyA9IGNyZWF0ZV9odHRwX2luc3BlY3Rfd2luZG93ICgpOworCiAgICAgZ2No YXIqIHVyaSA9IChnY2hhciopIChhcmdjID4gMSA/IGFyZ3ZbMV0gOiAiaHR0cDovL3d3dy5nb29n bGUuY29tLyIpOwogICAgIHdlYmtpdF93ZWJfdmlld19vcGVuICh3ZWJfdmlldywgdXJpKTsKIAo= 20999 2008-05-07 03:56:04 -0700 2008-05-11 10:59:32 -0700 Updated implementation, with some more goodies webkit-network-request.diff text/plain 46659 gustavo SW5kZXg6IFdlYktpdC9ndGsvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9ndGsvQ2hh bmdlTG9nCShyZXZpc2lvbiAzMjk1MSkKKysrIFdlYktpdC9ndGsvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsNTggQEAKKzIwMDgtMDUtMDcgIEd1c3Rhdm8gTm9yb25oYSBTaWx2 YSAgPGduc0Bnbm9tZS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKwlodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTg2MDgKKyAgICAg ICAgV2ViS2l0TmV0d29ya1JlcXVlc3QgbmVlZHMgdG8gYmUgZmluaXNoZWQKKworCUFsbW9zdCBj b21wbGV0ZSBHT2JqZWN0IGltcGxlbWVudGF0aW9uIGV4cG9zaW5nCisJUmVzb3VyY2VSZXF1ZXN0 LiBGcmFtZUxvYWRlckNsaWVudEd0ayBpcyBub3cgdXNpbmcKKwlXZWJLaXROZXR3b3JrUmVxdWVz dCB3aGVuIGl0IG5lZWRzIHRvIGRlYWwgd2l0aCByZXF1ZXN0CisJaW5mb3JtYXRpb24uIEFsc28s IHRoZSBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hXaWxsU2VuZFJlcXVlc3QKKwlwb2xpY3kg ZGVsZWdhdGUgaGFzIGJlZW4gaW1wbGVtZW50ZWQsIG1hcHBpbmcgdG8gdGhlIG5ldworCXJlcXVl c3Qtc3RhcnRlZCBzaWduYWwgaW4gV2ViS2l0V2ViVmlldy4KKworICAgICAgICAqIFdlYkNvcmVT dXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcDoKKyAgICAgICAgKFdlYktpdDo6RnJhbWVM b2FkZXJDbGllbnQ6OmRpc3BhdGNoV2lsbFNlbmRSZXF1ZXN0KToKKyAgICAgICAgKFdlYktpdDo6 RnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlvbkFjdGlv bik6CisgICAgICAgICogd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcDoKKyAgICAgICAg KF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZmlu YWxpemUpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6Y2FjaGVfcG9s aWN5X2Zyb21fcmVzb3VyY2VfcmVxdWVzdCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVl c3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld19mcm9tX3Jlc291cmNlX3JlcXVl c3QpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdv cmtfcmVxdWVzdF9nZXRfcmVzb3VyY2VfcmVxdWVzdCk6CisgICAgICAgIChfV2ViS2l0TmV0d29y a1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF91cmkpOgorICAgICAg ICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9n ZXRfdXJpKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9u ZXR3b3JrX3JlcXVlc3Rfc2V0X2NhY2hlX3BvbGljeSk6CisgICAgICAgIChfV2ViS2l0TmV0d29y a1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9jYWNoZV9wb2xpY3kp OgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtf cmVxdWVzdF9zZXRfdGltZW91dF9pbnRlcnZhbCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1Jl cXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF90aW1lb3V0X2ludGVydmFs KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3Jr X3JlcXVlc3Rfc2V0X21haW5fZG9jdW1lbnRfdXJpKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3Jr UmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X21haW5fZG9jdW1lbnRf dXJpKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3 b3JrX3JlcXVlc3Rfc2V0X2h0dHBfbWV0aG9kKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVx dWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfbWV0aG9kKToKKyAg ICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OmNvcHlfaGVhZGVyKToKKyAgICAg ICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf YWRkX2h0dHBfaGVhZGVycyk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRl Ojp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRlcnMpOgorICAgICAgICAoX1dl YktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9hZGRfaHR0 cF9oZWFkZXIpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0 X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9oZWFkZXIpOgorICAgICAgICAoX1dlYktpdE5ldHdv cmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9oZWFkZXIp OgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtf cmVxdWVzdF9zZXRfaHR0cF9jb250ZW50X3R5cGUpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtS ZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9jb250ZW50X3R5 cGUpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdv cmtfcmVxdWVzdF9zZXRfaHR0cF9yZWZlcmVyKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVx dWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfcmVmZXJlcik6Cisg ICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X3NldF9odHRwX3VzZXJfYWdlbnQpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0 UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF91c2VyX2FnZW50KToKKyAg ICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVl c3Rfc2V0X2h0dHBfYWNjZXB0KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZh dGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfYWNjZXB0KToKKyAgICAgICAgKF9X ZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2Jv ZHkpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdv cmtfcmVxdWVzdF9nZXRfYm9keSk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2 YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9hbGxvd19odHRwX2Nvb2tpZXMpOgorICAg ICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVz dF9nZXRfYWxsb3dfaHR0cF9jb29raWVzKToKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0bmV0d29y a3JlcXVlc3QuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5oOgorICAgICAgICAq IHdlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHA6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYnZp ZXcuY3BwOgorCiAyMDA4LTA1LTA2ICBDaHJpc3RpYW4gRHl3YW4gIDxjaHJpc3RpYW5AdHdvdG9h c3RzLmRlPgogCiAgICAgICAgIFJ1YmJlciBzdGFtcGVkIGJ5IEFscC4KSW5kZXg6IFdlYktpdC9n dGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCShyZXZp c2lvbiAzMjgzMSkKKysrIFdlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRHdGsuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yMDAsOSArMjAwLDE0IEBAIHZvaWQgRnJhbWVM b2FkZXJDbGllbnQ6OmRpc3BhdGNoRGlkQ2FuY2UKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQog Ci12b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaFdpbGxTZW5kUmVxdWVzdChEb2N1bWVu dExvYWRlciosIHVuc2lnbmVkIGxvbmcsIFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFJlc291cmNl UmVzcG9uc2UmKQordm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hXaWxsU2VuZFJlcXVl c3QoRG9jdW1lbnRMb2FkZXIqLCB1bnNpZ25lZCBsb25nLCBSZXNvdXJjZVJlcXVlc3QmIHJlc291 cmNlUmVxdWVzdCwgY29uc3QgUmVzb3VyY2VSZXNwb25zZSYpCiB7Ci0gICAgbm90SW1wbGVtZW50 ZWQoKTsKKyAgICBXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3ID0gZ2V0Vmlld0Zyb21GcmFtZShtX2Zy YW1lKTsKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfbmV3X2Zyb21fcmVzb3VyY2VfcmVxdWVzdChyZXNvdXJjZVJlcXVlc3QpOworCisg ICAgZ19zaWduYWxfZW1pdF9ieV9uYW1lKHdlYlZpZXcsICJyZXF1ZXN0LXN0YXJ0ZWQiLCByZXF1 ZXN0KTsKKyAgICByZXNvdXJjZVJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9y ZXNvdXJjZV9yZXF1ZXN0KHJlcXVlc3QpOworICAgIGdfb2JqZWN0X3VucmVmKHJlcXVlc3QpOwog fQogCiB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50Ojphc3NpZ25JZGVudGlmaWVyVG9Jbml0aWFsUmVx dWVzdCh1bnNpZ25lZCBsb25nIGlkZW50aWZpZXIsIERvY3VtZW50TG9hZGVyKiwgY29uc3QgUmVz b3VyY2VSZXF1ZXN0JikKQEAgLTI2OCw3ICsyNzMsOCBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50 OjpkaXNwYXRjaERlY2lkZVBvCiAgICAgICAgIHJldHVybjsKIAogICAgIFdlYktpdFdlYlZpZXcq IHdlYlZpZXcgPSBnZXRWaWV3RnJvbUZyYW1lKG1fZnJhbWUpOwotICAgIFdlYktpdE5ldHdvcmtS ZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXcocmVzb3VyY2VSZXF1 ZXN0LnVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworICAgIFJlc291cmNlUmVxdWVzdCBy ZXF1ZXN0Q29weSA9IHJlc291cmNlUmVxdWVzdDsKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCog cmVxdWVzdCA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X2Zyb21fcmVzb3VyY2VfcmVxdWVz dChyZXF1ZXN0Q29weSk7CiAgICAgV2ViS2l0TmF2aWdhdGlvblJlc3BvbnNlIHJlc3BvbnNlOwog CiAgICAgZ19zaWduYWxfZW1pdF9ieV9uYW1lKHdlYlZpZXcsICJuYXZpZ2F0aW9uLXJlcXVlc3Rl ZCIsIG1fZnJhbWUsIHJlcXVlc3QsICZyZXNwb25zZSk7CkluZGV4OiBXZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwCShyZXZpc2lvbiAzMjgzMSkKKysrIFdlYktpdC9n dGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjEs MTIgKzIxLDI3IEBACiAKICNpbmNsdWRlICJ3ZWJraXRuZXR3b3JrcmVxdWVzdC5oIgogCisjaW5j bHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlICJSZXNvdXJjZVJlcXVlc3QuaCIKKyNp bmNsdWRlICJDU3RyaW5nLmgiCisKK3VzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOworCiBleHRlcm4g IkMiIHsKIAogR19ERUZJTkVfVFlQRShXZWJLaXROZXR3b3JrUmVxdWVzdCwgd2Via2l0X25ldHdv cmtfcmVxdWVzdCwgR19UWVBFX09CSkVDVCk7CiAKIHN0cnVjdCBfV2ViS2l0TmV0d29ya1JlcXVl c3RQcml2YXRlIHsKKyAgICBSZXNvdXJjZVJlcXVlc3QgcmVxdWVzdDsKKwogICAgIGdjaGFyKiB1 cmk7CisgICAgV2ViS2l0UmVxQ2FjaGVQb2xpY3kgY2FjaGVfcG9saWN5OworICAgIGdkb3VibGUg dGltZW91dF9pbnRlcnZhbDsKKyAgICBnY2hhciogbWFpbl9kb2N1bWVudF91cmk7CisgICAgZ2No YXIqIGh0dHBfbWV0aG9kOworICAgIEdIYXNoVGFibGUgKmh0dHBfaGVhZGVyczsKKyAgICBnYm9v bGVhbiBhbGxvd19odHRwX2Nvb2tpZXM7CisgICAgZ2NoYXIgKmJvZHk7CiB9OwogCiAjZGVmaW5l IFdFQktJVF9ORVRXT1JLX1JFUVVFU1RfR0VUX1BSSVZBVEUob2JqKSAoR19UWVBFX0lOU1RBTkNF X0dFVF9QUklWQVRFKChvYmopLCBXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIFdlYktpdE5l dHdvcmtSZXF1ZXN0UHJpdmF0ZSkpCkBAIC0zNyw2ICs1MiwxMCBAQCBzdGF0aWMgdm9pZCB3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X2ZpbmFsCiAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRl KiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKIAogICAgIGdfZnJlZShwcml2LT51cmkpOworICAgIGdf ZnJlZShwcml2LT5tYWluX2RvY3VtZW50X3VyaSk7CisgICAgZ19mcmVlKHByaXYtPmh0dHBfbWV0 aG9kKTsKKyAgICBnX2hhc2hfdGFibGVfZGVzdHJveShwcml2LT5odHRwX2hlYWRlcnMpOworICAg IGdfZnJlZShwcml2LT5ib2R5KTsKIAogICAgIEdfT0JKRUNUX0NMQVNTKHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfcGFyZW50X2NsYXNzKS0+ZmluYWxpemUob2JqZWN0KTsKIH0KQEAgLTU0LDYgKzcz LDU3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfaW5pdCgKICAgICByZXF1 ZXN0LT5wcml2ID0gcHJpdjsKIH0KIAorc3RhdGljIFdlYktpdFJlcUNhY2hlUG9saWN5IGNhY2hl X3BvbGljeV9mcm9tX3Jlc291cmNlX3JlcXVlc3QoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXNv dXJjZVJlcXVlc3QpCit7CisgICAgUmVzb3VyY2VSZXF1ZXN0Q2FjaGVQb2xpY3kgY2FjaGVfcG9s aWN5ID0gcmVzb3VyY2VSZXF1ZXN0LmNhY2hlUG9saWN5KCk7CisgICAgCisgICAgc3dpdGNoKGNh Y2hlX3BvbGljeSkKKyAgICAgICAgeworICAgICAgICBjYXNlIFVzZVByb3RvY29sQ2FjaGVQb2xp Y3k6CisgICAgICAgICAgICByZXR1cm4gV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfUFJPVE9DT0w7 CisgICAgICAgIGNhc2UgUmVsb2FkSWdub3JpbmdDYWNoZURhdGE6CisgICAgICAgICAgICByZXR1 cm4gV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfUkVMT0FEX0lHTk9SSU5HX0NBQ0hFOworICAgICAg ICBjYXNlIFJldHVybkNhY2hlRGF0YUVsc2VMb2FkOgorICAgICAgICAgICAgcmV0dXJuIFdFQktJ VF9SRVFfQ0FDSEVfUE9MSUNZX0FMTE9XX1NUQUxFOworICAgICAgICBjYXNlIFJldHVybkNhY2hl RGF0YURvbnRMb2FkOgorICAgICAgICAgICAgcmV0dXJuIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZ X0NBQ0hFX09OTFk7CisgICAgICAgIGRlZmF1bHQ6CisgICAgICAgICAgICByZXR1cm4gV0VCS0lU X1JFUV9DQUNIRV9QT0xJQ1lfTk9ORTsKKyAgICAgICAgfQorfQorCisvLyBmb3IgaW50ZXJuYWwg dXNlIG9ubHkKK1dlYktpdE5ldHdvcmtSZXF1ZXN0KiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25l d19mcm9tX3Jlc291cmNlX3JlcXVlc3QoUmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3Qp Cit7CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSBXRUJLSVRfTkVUV09SS19S RVFVRVNUKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIE5VTEwpKTsK KyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2Owor CisgICAgcHJpdi0+cmVxdWVzdCA9IHJlc291cmNlUmVxdWVzdDsKKworICAgIHByaXYtPmNhY2hl X3BvbGljeSA9IGNhY2hlX3BvbGljeV9mcm9tX3Jlc291cmNlX3JlcXVlc3QocmVzb3VyY2VSZXF1 ZXN0KTsKKyAgICBwcml2LT50aW1lb3V0X2ludGVydmFsID0gcmVzb3VyY2VSZXF1ZXN0LnRpbWVv dXRJbnRlcnZhbCgpOworCisgICAgcHJpdi0+aHR0cF9oZWFkZXJzID0gZ19oYXNoX3RhYmxlX25l d19mdWxsKGdfc3RyX2hhc2gsIGdfc3RyX2VxdWFsLCBnX2ZyZWUsIGdfZnJlZSk7CisgICAgSFRU UEhlYWRlck1hcCBoZWFkZXJzID0gcmVzb3VyY2VSZXF1ZXN0Lmh0dHBIZWFkZXJGaWVsZHMoKTsK KyAgICBpZiAoIWhlYWRlcnMuaXNFbXB0eSgpKSB7CisgICAgICAgIEhUVFBIZWFkZXJNYXA6OmNv bnN0X2l0ZXJhdG9yIGVuZCA9IGhlYWRlcnMuZW5kKCk7CisgICAgICAgIGZvciAoSFRUUEhlYWRl ck1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBoZWFkZXJzLmJlZ2luKCk7IGl0ICE9IGVuZDsgKytp dCkKKyAgICAgICAgICAgIGdfaGFzaF90YWJsZV9pbnNlcnQocHJpdi0+aHR0cF9oZWFkZXJzLCAo Z3BvaW50ZXIpZ19zdHJkdXAoaXQtPmZpcnN0LnV0ZjgoKS5kYXRhKCkpLCAoZ3BvaW50ZXIpZ19z dHJkdXAoaXQtPnNlY29uZC51dGY4KCkuZGF0YSgpKSk7CisgICAgfQorCisgICAgcHJpdi0+YWxs b3dfaHR0cF9jb29raWVzID0gcmVzb3VyY2VSZXF1ZXN0LmFsbG93SFRUUENvb2tpZXMoKTsKKwor ICAgIHJldHVybiByZXF1ZXN0OworfQorCisvLyBmb3IgaW50ZXJuYWwgdXNlIG9ubHkKK1Jlc291 cmNlUmVxdWVzdCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9yZXNvdXJjZV9yZXF1ZXN0KGNv bnN0IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIFdlYktpdE5ldHdvcmtS ZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICByZXR1cm4gcHJpdi0+ cmVxdWVzdDsKK30KKwogV2ViS2l0TmV0d29ya1JlcXVlc3QqIHdlYmtpdF9uZXR3b3JrX3JlcXVl c3RfbmV3KGNvbnN0IGdjaGFyKiB1cmkpCiB7CiAgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwodXJp LCBOVUxMKTsKQEAgLTc1LDYgKzE0NSwxMCBAQCB2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf c2V0X3VyaShXZWJLCiAKICAgICBnX2ZyZWUocHJpdi0+dXJpKTsKICAgICBwcml2LT51cmkgPSBn X3N0cmR1cCh1cmkpOworCisgICAgLy8gZmVlZGluZyBiYWNrIHRvIHRoZSBSZXNvdXJjZVJlcXVl c3Qgb2JqZWN0LCB3aGljaCBpcyB0aGUgb25lIGFjdHVhbGx5IHVzZWQKKyAgICAvLyBpbnNpZGUg V2ViQ29yZQorICAgIHByaXYtPnJlcXVlc3Quc2V0VVJMKEtVUkwoU3RyaW5nOjpmcm9tVVRGOCh1 cmkpKSk7CiB9CiAKIGNvbnN0IGdjaGFyKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF91cmko V2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCkBAIC04Miw3ICsxNTYsMjk3IEBAIGNvbnN0 IGdjaGFyKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF8KICAgICBnX3JldHVybl92YWxfaWZf ZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKIAogICAgIFdl YktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisgICAgCisg ICAgaWYgKHByaXYtPnVyaSkKKyAgICAgICAgcmV0dXJuIHByaXYtPnVyaTsKKworICAgIHByaXYt PnVyaSA9IGdfc3RyZHVwKHByaXYtPnJlcXVlc3QudXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEo KSk7CiAgICAgcmV0dXJuIHByaXYtPnVyaTsKIH0KIAordm9pZCB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X3NldF9jYWNoZV9wb2xpY3koV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0 IFdlYktpdFJlcUNhY2hlUG9saWN5IGNhY2hlX3BvbGljeSkKK3sKKyAgICBnX3JldHVybl9pZl9m YWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworCisgICAgV2ViS2l0TmV0 d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIHByaXYtPmNh Y2hlX3BvbGljeSA9IGNhY2hlX3BvbGljeTsKKworICAgIFJlc291cmNlUmVxdWVzdENhY2hlUG9s aWN5IGZlZWRiYWNrOworICAgIHN3aXRjaChjYWNoZV9wb2xpY3kpCisgICAgICAgIHsKKyAgICAg ICAgY2FzZSBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9QUk9UT0NPTDoKKyAgICAgICAgICAgIGZl ZWRiYWNrID0gVXNlUHJvdG9jb2xDYWNoZVBvbGljeTsKKyAgICAgICAgY2FzZSBXRUJLSVRfUkVR X0NBQ0hFX1BPTElDWV9SRUxPQURfSUdOT1JJTkdfQ0FDSEU6CisgICAgICAgICAgICBmZWVkYmFj ayA9IFJlbG9hZElnbm9yaW5nQ2FjaGVEYXRhOworICAgICAgICBjYXNlIFdFQktJVF9SRVFfQ0FD SEVfUE9MSUNZX0FMTE9XX1NUQUxFOgorICAgICAgICAgICAgZmVlZGJhY2sgPSBSZXR1cm5DYWNo ZURhdGFFbHNlTG9hZDsKKyAgICAgICAgY2FzZSBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9DQUNI RV9PTkxZOgorICAgICAgICAgICAgZmVlZGJhY2sgPSBSZXR1cm5DYWNoZURhdGFEb250TG9hZDsK KyAgICAgICAgZGVmYXVsdDoKKyAgICAgICAgICAgIGZlZWRiYWNrID0gVXNlUHJvdG9jb2xDYWNo ZVBvbGljeTsKKyAgICAgICAgfQorICAgIHByaXYtPnJlcXVlc3Quc2V0Q2FjaGVQb2xpY3koZmVl ZGJhY2spOworCit9CisKK1dlYktpdFJlcUNhY2hlUG9saWN5IHdlYmtpdF9uZXR3b3JrX3JlcXVl c3RfZ2V0X2NhY2hlX3BvbGljeShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAg ICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3Qp LCBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9OT05FKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1 ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICByZXR1cm4gcHJpdi0+Y2Fj aGVfcG9saWN5OworfQorCit2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3RpbWVvdXRf aW50ZXJ2YWwoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdkb3VibGUgdGlt ZW91dF9pbnRlcnZhbCkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JL X1JFUVVFU1QocmVxdWVzdCkpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBw cml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIHByaXYtPnRpbWVvdXRfaW50ZXJ2YWwgPSB0aW1l b3V0X2ludGVydmFsOworCisgICAgcHJpdi0+cmVxdWVzdC5zZXRUaW1lb3V0SW50ZXJ2YWwodGlt ZW91dF9pbnRlcnZhbCk7Cit9CisKK2dkb3VibGUgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRf dGltZW91dF9pbnRlcnZhbChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBn X3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCAw LjApOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+ cHJpdjsKKworICAgIHJldHVybiBwcml2LT50aW1lb3V0X2ludGVydmFsOworfQorCit2b2lkIHdl YmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X21haW5fZG9jdW1lbnRfdXJpKFdlYktpdE5ldHdvcmtS ZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciogbWFpbl9kb2N1bWVudF91cmkpCit7CisgICAg Z19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpKTsKKyAg ICBnX3JldHVybl9pZl9mYWlsKG1haW5fZG9jdW1lbnRfdXJpKTsKKworICAgIFdlYktpdE5ldHdv cmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBnX2ZyZWUocHJp di0+bWFpbl9kb2N1bWVudF91cmkpOworICAgIHByaXYtPm1haW5fZG9jdW1lbnRfdXJpID0gZ19z dHJkdXAobWFpbl9kb2N1bWVudF91cmkpOworCisgICAgcHJpdi0+cmVxdWVzdC5zZXRNYWluRG9j dW1lbnRVUkwoS1VSTChTdHJpbmc6OmZyb21VVEY4KG1haW5fZG9jdW1lbnRfdXJpKSkpOworfQor Citjb25zdCBnY2hhciogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWFpbl9kb2N1bWVudF91 cmkoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgZ19yZXR1cm5fdmFsX2lm X2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgTlVMTCk7CisKKyAgICBX ZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAg aWYgKHByaXYtPm1haW5fZG9jdW1lbnRfdXJpKQorICAgICAgICByZXR1cm4gcHJpdi0+bWFpbl9k b2N1bWVudF91cmk7CisKKyAgICBwcml2LT5tYWluX2RvY3VtZW50X3VyaSA9IGdfc3RyZHVwKHBy aXYtPnJlcXVlc3QubWFpbkRvY3VtZW50VVJMKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7Cisg ICAgcmV0dXJuIHByaXYtPm1haW5fZG9jdW1lbnRfdXJpOworfQorCit2b2lkIHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3Rfc2V0X2h0dHBfbWV0aG9kKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0 LCBjb25zdCBnY2hhciogaHR0cF9tZXRob2QpCit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJL SVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpKTsKKyAgICBnX3JldHVybl9pZl9mYWlsKGh0 dHBfbWV0aG9kKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJl cXVlc3QtPnByaXY7CisKKyAgICBnX2ZyZWUocHJpdi0+aHR0cF9tZXRob2QpOworICAgIHByaXYt Pmh0dHBfbWV0aG9kID0gZ19zdHJkdXAoaHR0cF9tZXRob2QpOworCisgICAgcHJpdi0+cmVxdWVz dC5zZXRIVFRQTWV0aG9kKFN0cmluZzo6ZnJvbVVURjgoaHR0cF9tZXRob2QpKTsKK30KKworY29u c3QgZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfbWV0aG9kKFdlYktpdE5l dHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJ VF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOworCisgICAgV2ViS2l0TmV0d29y a1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIGlmIChwcml2LT5o dHRwX21ldGhvZCkKKyAgICAgICAgcmV0dXJuIHByaXYtPmh0dHBfbWV0aG9kOworCisgICAgcHJp di0+aHR0cF9tZXRob2QgPSBnX3N0cmR1cChwcml2LT5yZXF1ZXN0Lmh0dHBNZXRob2QoKS51dGY4 KCkuZGF0YSgpKTsKKyAgICByZXR1cm4gcHJpdi0+aHR0cF9tZXRob2Q7Cit9CisKK3N0YXRpYyB2 b2lkIGNvcHlfaGVhZGVyKGNvbnN0IGdjaGFyKiBrZXksIGNvbnN0IGdjaGFyKiB2YWx1ZSwgZ3Bv aW50ZXIgZGF0YSkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IChXZWJL aXROZXR3b3JrUmVxdWVzdCopZGF0YTsKKworICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfYWRk X2h0dHBfaGVhZGVyKHJlcXVlc3QsIGtleSwgdmFsdWUpOworfQorCit2b2lkIHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfYWRkX2h0dHBfaGVhZGVycyhXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVz dCwgY29uc3QgR0hhc2hUYWJsZSogaHR0cF9oZWFkZXJzKQoreworICAgIGdfcmV0dXJuX2lmX2Zh aWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CisgICAgZ19yZXR1cm5faWZf ZmFpbChodHRwX2hlYWRlcnMpOworCisgICAgZ19oYXNoX3RhYmxlX2ZvcmVhY2goKEdIYXNoVGFi bGUqKWh0dHBfaGVhZGVycywgKEdIRnVuYyljb3B5X2hlYWRlciwgcmVxdWVzdCk7Cit9CisKK2Nv bnN0IEdIYXNoVGFibGUqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfaGVhZGVycyhX ZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFp bChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKKworICAgIFdlYktp dE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisgICAgcmV0dXJu IHByaXYtPmh0dHBfaGVhZGVyczsKK30KKwordm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2Fk ZF9odHRwX2hlYWRlcihXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIq IGh0dHBfaGVhZGVyLCBjb25zdCBnY2hhciogdmFsdWUpCit7CisgICAgZ19yZXR1cm5faWZfZmFp bChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpKTsKKyAgICBnX3JldHVybl9pZl9m YWlsKGh0dHBfaGVhZGVyKTsKKyAgICBnX3JldHVybl9pZl9mYWlsKHZhbHVlKTsKKworICAgIFdl YktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisgICAgR0hh c2hUYWJsZSogaGFzaF90YWJsZSA9IHByaXYtPmh0dHBfaGVhZGVyczsKKyAgICBncG9pbnRlciBr ZXlfbG9va3VwOworCisgICAga2V5X2xvb2t1cCA9IGdfaGFzaF90YWJsZV9sb29rdXAoaGFzaF90 YWJsZSwgaHR0cF9oZWFkZXIpOworICAgIGlmICgha2V5X2xvb2t1cCkKKyAgICAgICAgZ19oYXNo X3RhYmxlX2luc2VydChoYXNoX3RhYmxlLCAoZ3BvaW50ZXIpZ19zdHJkdXAoaHR0cF9oZWFkZXIp LCAoZ3BvaW50ZXIpZ19zdHJkdXAodmFsdWUpKTsKKyAgICBlbHNlCisgICAgICAgIHsKKyAgICAg ICAgICAgIGdjaGFyKiBuZXdfdmFsdWUgPSBnX3N0cmR1cF9wcmludGYoIiVzLCVzIiwgKGdjaGFy KilrZXlfbG9va3VwLCB2YWx1ZSk7CisgICAgICAgICAgICBnX2hhc2hfdGFibGVfcmVwbGFjZSho YXNoX3RhYmxlLCAoZ3BvaW50ZXIpZ19zdHJkdXAoaHR0cF9oZWFkZXIpLCAoZ3BvaW50ZXIpZ19z dHJkdXAobmV3X3ZhbHVlKSk7CisgICAgICAgICAgICBnX2ZyZWUobmV3X3ZhbHVlKTsKKyAgICAg ICAgfQorCisgICAgcHJpdi0+cmVxdWVzdC5hZGRIVFRQSGVhZGVyRmllbGQoU3RyaW5nOjpmcm9t VVRGOChodHRwX2hlYWRlciksIFN0cmluZzo6ZnJvbVVURjgodmFsdWUpKTsKK30KKwordm9pZCB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX2hlYWRlcihXZWJLaXROZXR3b3JrUmVxdWVz dCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfaGVhZGVyLCBjb25zdCBnY2hhciogdmFsdWUp Cit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVl c3QpKTsKKyAgICBnX3JldHVybl9pZl9mYWlsKGh0dHBfaGVhZGVyKTsKKyAgICBnX3JldHVybl9p Zl9mYWlsKHZhbHVlKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9 IHJlcXVlc3QtPnByaXY7CisgICAgR0hhc2hUYWJsZSogaGVhZGVycyA9IHByaXYtPmh0dHBfaGVh ZGVyczsKKworICAgIGdfaGFzaF90YWJsZV9yZXBsYWNlKGhlYWRlcnMsIGdfc3RyZHVwKGh0dHBf aGVhZGVyKSwgZ19zdHJkdXAodmFsdWUpKTsKKyAgICAKKyAgICBwcml2LT5yZXF1ZXN0LnNldEhU VFBIZWFkZXJGaWVsZChTdHJpbmc6OmZyb21VVEY4KGh0dHBfaGVhZGVyKSwgU3RyaW5nOjpmcm9t VVRGOCh2YWx1ZSkpOworfQorCitjb25zdCBnY2hhciogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9n ZXRfaHR0cF9oZWFkZXIoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFy KiBodHRwX2hlYWRlcikKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVU V09SS19SRVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbCho dHRwX2hlYWRlciwgTlVMTCk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHBy aXYgPSByZXF1ZXN0LT5wcml2OworICAgIEdIYXNoVGFibGUqIGhlYWRlcnMgPSBwcml2LT5odHRw X2hlYWRlcnM7CisKKyAgICByZXR1cm4gKGNvbnN0IGdjaGFyKilnX2hhc2hfdGFibGVfbG9va3Vw KGhlYWRlcnMsIChnY29uc3Rwb2ludGVyKWh0dHBfaGVhZGVyKTsKK30KKwordm9pZCB3ZWJraXRf bmV0d29ya19yZXF1ZXN0X3NldF9odHRwX2NvbnRlbnRfdHlwZShXZWJLaXROZXR3b3JrUmVxdWVz dCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfY29udGVudF90eXBlKQoreworICAgIGdfcmV0 dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CisgICAgZ19y ZXR1cm5faWZfZmFpbChodHRwX2NvbnRlbnRfdHlwZSk7CisKKyAgICB3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X3NldF9odHRwX2hlYWRlcihyZXF1ZXN0LCAiQ29udGVudC1UeXBlIiwgaHR0cF9jb250 ZW50X3R5cGUpOworfQorCitjb25zdCBnY2hhciogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRf aHR0cF9jb250ZW50X3R5cGUoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAg Z19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwg TlVMTCk7CisKKyAgICByZXR1cm4gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9oZWFk ZXIocmVxdWVzdCwgIkNvbnRlbnQtVHlwZSIpOworfQorCit2b2lkIHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3Rfc2V0X2h0dHBfcmVmZXJlcihXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29u c3QgZ2NoYXIqIGh0dHBfcmVmZXJlcikKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9J U19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwoaHR0cF9y ZWZlcmVyKTsKKworICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfaGVhZGVyKHJl cXVlc3QsICJSZWZlcmVyIiwgaHR0cF9yZWZlcmVyKTsKK30KKworY29uc3QgZ2NoYXIqIHdlYmtp dF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfcmVmZXJlcihXZWJLaXROZXR3b3JrUmVxdWVzdCog cmVxdWVzdCkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19S RVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKKworICAgIHJldHVybiB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X2dldF9odHRwX2hlYWRlcihyZXF1ZXN0LCAiUmVmZXJlciIpOworfQorCit2b2lkIHdlYmtp dF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfdXNlcl9hZ2VudChXZWJLaXROZXR3b3JrUmVxdWVz dCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfdXNlcl9hZ2VudCkKK3sKKyAgICBnX3JldHVy bl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworICAgIGdfcmV0 dXJuX2lmX2ZhaWwoaHR0cF91c2VyX2FnZW50KTsKKworICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVl c3Rfc2V0X2h0dHBfaGVhZGVyKHJlcXVlc3QsICJVc2VyLUFnZW50IiwgaHR0cF91c2VyX2FnZW50 KTsKK30KKworY29uc3QgZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfdXNl cl9hZ2VudChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBnX3JldHVybl92 YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKKwor ICAgIHJldHVybiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRlcihyZXF1ZXN0 LCAiVXNlci1BZ2VudCIpOworfQorCit2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0 dHBfYWNjZXB0KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciogaHR0 cF9hY2NlcHQpCit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFV RVNUKHJlcXVlc3QpKTsKKyAgICBnX3JldHVybl9pZl9mYWlsKGh0dHBfYWNjZXB0KTsKKworICAg IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfaGVhZGVyKHJlcXVlc3QsICJBY2NlcHQi LCBodHRwX2FjY2VwdCk7Cit9CisKK2NvbnN0IGdjaGFyKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X2dldF9odHRwX2FjY2VwdChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBn X3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBO VUxMKTsKKworICAgIHJldHVybiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRl cihyZXF1ZXN0LCAiQWNjZXB0Iik7Cit9CisKK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9z ZXRfYm9keShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGJvZHkp Cit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVl c3QpKTsKKyAgICBnX3JldHVybl9pZl9mYWlsKGJvZHkpOworCisgICAgV2ViS2l0TmV0d29ya1Jl cXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIGdfZnJlZShwcml2LT5i b2R5KTsKKyAgICBwcml2LT5ib2R5ID0gZ19zdHJkdXAoYm9keSk7CisKKyAgICBwcml2LT5yZXF1 ZXN0LnNldEhUVFBCb2R5KEZvcm1EYXRhOjpjcmVhdGUoQ1N0cmluZyhwcml2LT5ib2R5KSkpOwor fQorCitjb25zdCBnY2hhciogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfYm9keShXZWJLaXRO ZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJL SVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKKworICAgIFdlYktpdE5ldHdv cmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBpZiAocHJpdi0+ Ym9keSkKKyAgICAgICAgcmV0dXJuIHByaXYtPmJvZHk7CisKKyAgICBpZiAoZ19hc2NpaV9zdHJj YXNlY21wICh3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX21ldGhvZChyZXF1ZXN0KSwg IlBPU1QiKSA9PSAwKQorICAgICAgICBwcml2LT5ib2R5ID0gZ19zdHJkdXAocHJpdi0+cmVxdWVz dC5odHRwQm9keSgpLT5mbGF0dGVuVG9TdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKyAgICByZXR1 cm4gcHJpdi0+Ym9keTsKK30KKwordm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9hbGxv d19odHRwX2Nvb2tpZXMoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdib29s ZWFuIGFsbG93X2h0dHBfY29va2llcykKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9J U19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQ cml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIHByaXYtPmFsbG93X2h0dHBfY29v a2llcyA9IGFsbG93X2h0dHBfY29va2llczsKKworICAgIHByaXYtPnJlcXVlc3Quc2V0QWxsb3dI VFRQQ29va2llcyhhbGxvd19odHRwX2Nvb2tpZXMpOworfQorCitnYm9vbGVhbiB3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X2dldF9hbGxvd19odHRwX2Nvb2tpZXMoV2ViS2l0TmV0d29ya1JlcXVlc3Qq IHJlcXVlc3QpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktf UkVRVUVTVChyZXF1ZXN0KSwgRkFMU0UpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2 YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIHJldHVybiBwcml2LT5hbGxvd19odHRw X2Nvb2tpZXM7Cit9CisKIH0KSW5kZXg6IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmty ZXF1ZXN0LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jl cXVlc3QuaAkocmV2aXNpb24gMzI4MzEpCisrKyBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3 b3JrcmVxdWVzdC5oCSh3b3JraW5nIGNvcHkpCkBAIC00NSw2ICs0NSwxNSBAQCBzdHJ1Y3QgX1dl YktpdE5ldHdvcmtSZXF1ZXN0Q2xhc3MgewogICAgIEdPYmplY3RDbGFzcyBwYXJlbnRfY2xhc3M7 CiB9OwogCit0eXBlZGVmIGVudW0KK3sKKyAgV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfTk9ORSwK KyAgV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfUFJPVE9DT0wsCisgIFdFQktJVF9SRVFfQ0FDSEVf UE9MSUNZX1JFTE9BRF9JR05PUklOR19DQUNIRSwKKyAgV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lf QUxMT1dfU1RBTEUsCisgIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX0NBQ0hFX09OTFksCit9IFdl YktpdFJlcUNhY2hlUG9saWN5OworCiBXRUJLSVRfQVBJIEdUeXBlCiB3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X2dldF90eXBlICh2b2lkKTsKIApAQCAtNTcsNiArNjYsODEgQEAgd2Via2l0X25ldHdv cmtfcmVxdWVzdF9zZXRfdXJpIChXZWJLaXROZQogV0VCS0lUX0FQSSBjb25zdCBnY2hhcioKIHdl YmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaSAoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVl c3QpOwogCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2NhY2hl X3BvbGljeShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgV2ViS2l0UmVxQ2Fj aGVQb2xpY3kgY2FjaGVfcG9saWN5KTsKKworV0VCS0lUX0FQSSBXZWJLaXRSZXFDYWNoZVBvbGlj eQord2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfY2FjaGVfcG9saWN5KFdlYktpdE5ldHdvcmtS ZXF1ZXN0KiByZXF1ZXN0KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X3NldF90aW1lb3V0X2ludGVydmFsKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBj b25zdCBnZG91YmxlIHRpbWVvdXRfaW50ZXJ2YWwpOworCitXRUJLSVRfQVBJIGdkb3VibGUKK3dl YmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3RpbWVvdXRfaW50ZXJ2YWwoV2ViS2l0TmV0d29ya1Jl cXVlc3QqIHJlcXVlc3QpOworCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF9uZXR3b3JrX3JlcXVl c3Rfc2V0X21haW5fZG9jdW1lbnRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBj b25zdCBnY2hhciogbWFpbl9kb2N1bWVudF91cmkpOworCitXRUJLSVRfQVBJIGNvbnN0IGdjaGFy Kgord2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWFpbl9kb2N1bWVudF91cmkoV2ViS2l0TmV0 d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF9uZXR3b3Jr X3JlcXVlc3Rfc2V0X2h0dHBfbWV0aG9kIChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwg Y29uc3QgZ2NoYXIqIGh0dHBfbWV0aG9kKTsKKworV0VCS0lUX0FQSSBjb25zdCBnY2hhcioKK3dl YmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfbWV0aG9kIChXZWJLaXROZXR3b3JrUmVxdWVz dCogcmVxdWVzdCk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X25ldHdvcmtfcmVxdWVzdF9h ZGRfaHR0cF9oZWFkZXJzIChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgR0hh c2hUYWJsZSogaHR0cF9oZWFkZXJzKTsKKworV0VCS0lUX0FQSSBjb25zdCBHSGFzaFRhYmxlKgor d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9oZWFkZXJzIChXZWJLaXROZXR3b3JrUmVx dWVzdCogcmVxdWVzdCk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X25ldHdvcmtfcmVxdWVz dF9hZGRfaHR0cF9oZWFkZXIoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdj aGFyKiBodHRwX2hlYWRlciwgY29uc3QgZ2NoYXIqIHZhbHVlKTsKKworV0VCS0lUX0FQSSB2b2lk Cit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX2hlYWRlciAoV2ViS2l0TmV0d29ya1Jl cXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX2hlYWRlciwgY29uc3QgZ2NoYXIqIHZh bHVlKTsKKworV0VCS0lUX0FQSSBjb25zdCBnY2hhcioKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf Z2V0X2h0dHBfaGVhZGVyIChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2No YXIqIGh0dHBfaGVhZGVyKTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X3NldF9odHRwX2NvbnRlbnRfdHlwZShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwg Y29uc3QgZ2NoYXIqIGh0dHBfY29udGVudF90eXBlKTsKKworV0VCS0lUX0FQSSBjb25zdCBnY2hh cioKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfY29udGVudF90eXBlKFdlYktpdE5l dHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29y a19yZXF1ZXN0X3NldF9odHRwX3JlZmVyZXIoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3Qs IGNvbnN0IGdjaGFyKiBodHRwX3JlZmVyZXIpOworCitXRUJLSVRfQVBJIGNvbnN0IGdjaGFyKgor d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9yZWZlcmVyKFdlYktpdE5ldHdvcmtSZXF1 ZXN0KiByZXF1ZXN0KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X3NldF9odHRwX3VzZXJfYWdlbnQoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0 IGdjaGFyKiBodHRwX3VzZXJfYWdlbnQpOworCitXRUJLSVRfQVBJIGNvbnN0IGdjaGFyKgord2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF91c2VyX2FnZW50KFdlYktpdE5ldHdvcmtSZXF1 ZXN0KiByZXF1ZXN0KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X3NldF9odHRwX2FjY2VwdChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2No YXIqIGh0dHBfYWNjZXB0KTsKKworV0VCS0lUX0FQSSBjb25zdCBnY2hhcioKK3dlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfZ2V0X2h0dHBfYWNjZXB0KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0 KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9ib2R5KFdl YktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciogYm9keSk7CisKK1dFQktJ VF9BUEkgY29uc3QgZ2NoYXIqCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9ib2R5KFdlYktp dE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X3NldF9hbGxvd19odHRwX2Nvb2tpZXMoV2ViS2l0TmV0d29ya1JlcXVlc3Qq IHJlcXVlc3QsIGNvbnN0IGdib29sZWFuIGFsbG93X2h0dHBfY29va2llcyk7CisKK1dFQktJVF9B UEkgZ2Jvb2xlYW4KK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2FsbG93X2h0dHBfY29va2ll cyhXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRp ZgpJbmRleDogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAkocmV2aXNpb24gMzI4MzEpCisrKyBX ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgJKHdvcmtpbmcgY29weSkKQEAgLTIyLDcg KzIyLDggQEAKICNkZWZpbmUgV0VCS0lUX1BSSVZBVEVfSAogCiAvKgotICogVGhpcyBmaWxlIGtu b3dzIHRoZSBzaGFyZWQgc2VjcmV0IG9mIFdlYktpdFdlYlZpZXcgYW5kIFdlYktpdFdlYkZyYW1l LgorICogVGhpcyBmaWxlIGtub3dzIHRoZSBzaGFyZWQgc2VjcmV0IG9mIFdlYktpdFdlYlZpZXcg YW5kIFdlYktpdFdlYkZyYW1lCisgKiBhbmQgV2ViS2l0TmV0d29ya1JlcXVlc3QuCiAgKiBUaGV5 IGFyZSB1c2luZyBXZWJDb3JlIHdoaWNoIG11c24ndCBiZSBleHBvc2VkIHRvIHRoZSBvdXRlciB3 b3JsZC4KICAqLwogCkBAIC0zOCw2ICszOSw3IEBACiAjaW5jbHVkZSAiUGFnZS5oIgogI2luY2x1 ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkZXJDbGllbnQuaCIKKyNpbmNsdWRlICJS ZXNvdXJjZVJlcXVlc3QuaCIKIAogI2luY2x1ZGUgPGdsaWIuaD4KIApAQCAtMTI0LDYgKzEyNiwx MiBAQCBleHRlcm4gIkMiIHsKIAogICAgIFdFQktJVF9BUEkgZ2NoYXIqCiAgICAgd2Via2l0X3dl Yl92aWV3X2dldF9zZWxlY3RlZF90ZXh0IChXZWJLaXRXZWJWaWV3KiB3ZWJfdmlldyk7CisKKyAg ICBXZWJLaXROZXR3b3JrUmVxdWVzdCoKKyAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld19m cm9tX3Jlc291cmNlX3JlcXVlc3QoV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJl cXVlc3QpOworCisgICAgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0CisgICAgd2Via2l0X25ldHdv cmtfcmVxdWVzdF9nZXRfcmVzb3VyY2VfcmVxdWVzdChjb25zdCBXZWJLaXROZXR3b3JrUmVxdWVz dCogcmVxdWVzdCk7CiB9CiAKICNlbmRpZgpJbmRleDogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 d2ViZnJhbWUuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZy YW1lLmNwcAkocmV2aXNpb24gMzI4MzEpCisrKyBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJm cmFtZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM1Myw5ICszNTMsNyBAQCB2b2lkIHdlYmtpdF93 ZWJfZnJhbWVfbG9hZF9yZXF1ZXN0KFdlYktpCiAgICAgRnJhbWUqIGNvcmVGcmFtZSA9IGNvcmUo ZnJhbWUpOwogICAgIEFTU0VSVChjb3JlRnJhbWUpOwogCi0gICAgLy8gVE9ETzogVXNlIHRoZSBS ZXNvdXJjZVJlcXVlc3QgY2FycmllZCBieSBXZWJLaXROZXR3b3JrUmVxdWVzdCB3aGVuIGl0IGlz IGltcGxlbWVudGVkLgotICAgIFN0cmluZyBzdHJpbmcgPSBTdHJpbmc6OmZyb21VVEY4KHdlYmtp dF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShyZXF1ZXN0KSk7Ci0gICAgY29yZUZyYW1lLT5sb2Fk ZXIoKS0+bG9hZChSZXNvdXJjZVJlcXVlc3QoS1VSTChzdHJpbmcpKSk7CisgICAgY29yZUZyYW1l LT5sb2FkZXIoKS0+bG9hZCh3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9yZXNvdXJjZV9yZXF1 ZXN0KHJlcXVlc3QpKTsKIH0KIAogLyoqCkluZGV4OiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3 ZWJ2aWV3LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3 LmNwcAkocmV2aXNpb24gMzI4MzEpCisrKyBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3 LmNwcAkod29ya2luZyBjb3B5KQpAQCAtNjcsNiArNjcsNyBAQCBlbnVtIHsKICAgICAvKiBub3Jt YWwgc2lnbmFscyAqLwogICAgIE5BVklHQVRJT05fUkVRVUVTVEVELAogICAgIFdJTkRPV19PQkpF Q1RfQ0xFQVJFRCwKKyAgICBSRVFVRVNUX1NUQVJURUQsCiAgICAgTE9BRF9TVEFSVEVELAogICAg IExPQURfQ09NTUlUVEVELAogICAgIExPQURfUFJPR1JFU1NfQ0hBTkdFRCwKQEAgLTc4MCw2ICs3 ODEsMjQgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3X2NsYXNzX2luaXQoVwogICAgICAg ICAgICAgR19UWVBFX1BPSU5URVIpOwogCiAgICAgLyoqCisgICAgICogV2ViS2l0V2ViVmlldzo6 cmVxdWVzdC1zdGFydGVkOgorICAgICAqIEB3ZWJfdmlldzogdGhlIG9iamVjdCBvbiB3aGljaCB0 aGUgc2lnbmFsIGlzIGVtaXR0ZWQKKyAgICAgKiBAcmVxdWVzdDogdGhlIHJlcXVlc3QgdGhhdCBp cyB0byBiZSBtYWRlCisgICAgICoKKyAgICAgKiBXaGVuIGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0 IGlzIGFib3V0IHRvIGJlIHNlbnQgdG8gdGhlIHNlcnZlcgorICAgICAqIHRoaXMgc2lnbmFsIGlz IGVtbWl0ZWQuCisgICAgICovCisgICAgd2Via2l0X3dlYl92aWV3X3NpZ25hbHNbTE9BRF9TVEFS VEVEXSA9IGdfc2lnbmFsX25ldygicmVxdWVzdC1zdGFydGVkIiwKKyAgICAgICAgICAgIEdfVFlQ RV9GUk9NX0NMQVNTKHdlYlZpZXdDbGFzcyksCisgICAgICAgICAgICAoR1NpZ25hbEZsYWdzKShH X1NJR05BTF9SVU5fTEFTVCB8IEdfU0lHTkFMX0FDVElPTiksCisgICAgICAgICAgICAwLAorICAg ICAgICAgICAgTlVMTCwKKyAgICAgICAgICAgIE5VTEwsCisgICAgICAgICAgICBnX2NjbG9zdXJl X21hcnNoYWxfVk9JRF9fT0JKRUNULAorICAgICAgICAgICAgR19UWVBFX05PTkUsIDEsCisgICAg ICAgICAgICBXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QpOworCisgICAgLyoqCiAgICAgICog V2ViS2l0V2ViVmlldzo6bG9hZC1zdGFydGVkOgogICAgICAqIEB3ZWJfdmlldzogdGhlIG9iamVj dCBvbiB3aGljaCB0aGUgc2lnbmFsIGlzIGVtaXR0ZWQKICAgICAgKiBAZnJhbWU6IHRoZSBmcmFt ZSBnb2luZyB0byBkbyB0aGUgbG9hZApJbmRleDogV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYktpdFRvb2xzL0NoYW5nZUxvZwkocmV2aXNpb24gMzI5NTEpCisrKyBXZWJL aXRUb29scy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwyMyBAQAorMjAwOC0w NS0wNyAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworCUltcGxlbWVudCBhIGRpYWxvZyB0byBzaG93 IHRoZSByZXF1ZXN0cywgYXMgYSB0ZXN0IGZvciB0aGUKKwlXZWJLaXROZXR3b3JrUmVxdWVzdCBB UEksIGFuZCBhbHNvIGEgaGFuZGxlciB0byB0aGUKKwlyZXF1ZXN0LXN0YXJ0ZWQgc2lnbmFsIHRv IGFkZCBhbiBhcmJpdHJhcnkgaGVhZGVyIHRvIHJlcXVlc3RzLgorCisgICAgICAgICogR3RrTGF1 bmNoZXIvbWFpbi5jOgorICAgICAgICAoc2hvd19odHRwX2luc3BlY3Rfd2luZG93X2NiKToKKyAg ICAgICAgKG5hdmlnYXRpb25fcmVxdWVzdGVkX2NiKToKKyAgICAgICAgKHJlcXVlc3Rfc3RhcnRl ZF9jYik6CisgICAgICAgIChhcHBlbmRfaGVhZGVyX3RvX2h0dHBfaW5zcGVjdF9oZWFkZXJzX21v ZGVsKToKKyAgICAgICAgKGNhY2hlX3BvbGljeV90b19zdHJpbmcpOgorICAgICAgICAoaHR0cF9p bnNwZWN0X2N1cnNvcl9jaGFuZ2VkX2NiKToKKyAgICAgICAgKGNyZWF0ZV9odHRwX2luc3BlY3Rf d2luZG93KToKKyAgICAgICAgKGNyZWF0ZV9icm93c2VyKToKKyAgICAgICAgKGNyZWF0ZV90b29s YmFyKToKKyAgICAgICAgKG1haW4pOgorCiAyMDA4LTA1LTA3ICBEYXZpZCBLaWx6ZXIgIDxkZGtp bHplckBhcHBsZS5jb20+CiAKICAgICAgICAgVXNlIEZpbGU6OkZpbmQgYW5kIEdldG9wdDo6TG9u ZyBpbiBtYWtlLWpzLXRlc3Qtd3JhcHBlcnMKSW5kZXg6IFdlYktpdFRvb2xzL0d0a0xhdW5jaGVy L21haW4uYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9HdGtMYXVuY2hlci9tYWluLmMJKHJl dmlzaW9uIDMyODMxKQorKysgV2ViS2l0VG9vbHMvR3RrTGF1bmNoZXIvbWFpbi5jCSh3b3JraW5n IGNvcHkpCkBAIC0zNSw2ICszNSwyMiBAQCBzdGF0aWMgZ2NoYXIqIG1haW5fdGl0bGU7CiBzdGF0 aWMgZ2ludCBsb2FkX3Byb2dyZXNzOwogc3RhdGljIGd1aW50IHN0YXR1c19jb250ZXh0X2lkOwog CitHdGtXaWRnZXQqIGh0dHBfaW5zcGVjdF93aW5kb3c7CitHdGtXaWRnZXQqIGh0dHBfaW5zcGVj dF9yZXF1ZXN0c19saXN0OworR3RrTGlzdFN0b3JlKiBodHRwX2luc3BlY3RfcmVxdWVzdHNfbW9k ZWw7CitHdGtXaWRnZXQqIGh0dHBfaW5zcGVjdF9jYWNoZV9wb2xpY3lfbGFiZWw7CitHdGtXaWRn ZXQqIGh0dHBfaW5zcGVjdF90aW1lb3V0X2ludGVydmFsX2xhYmVsOworR3RrV2lkZ2V0KiBodHRw X2luc3BlY3RfbWFpbl9kb2N1bWVudF91cmlfbGFiZWw7CitHdGtXaWRnZXQqIGh0dHBfaW5zcGVj dF9tZXRob2RfbGFiZWw7CitHdGtXaWRnZXQqIGh0dHBfaW5zcGVjdF9jb250ZW50X3R5cGVfbGFi ZWw7CitHdGtXaWRnZXQqIGh0dHBfaW5zcGVjdF9yZWZlcmVyX2xhYmVsOworR3RrV2lkZ2V0KiBo dHRwX2luc3BlY3RfdXNlcl9hZ2VudF9sYWJlbDsKK0d0a1dpZGdldCogaHR0cF9pbnNwZWN0X2Fj Y2VwdF9sYWJlbDsKK0d0a1dpZGdldCogaHR0cF9pbnNwZWN0X2FsbG93X2h0dHBfY29va2llc19s YWJlbDsKK0d0a1dpZGdldCogaHR0cF9pbnNwZWN0X2hlYWRlcnNfbGlzdDsKK0d0a1dpZGdldCog aHR0cF9pbnNwZWN0X2JvZHlfdGV4dF92aWV3OworR3RrTGlzdFN0b3JlKiBodHRwX2luc3BlY3Rf aGVhZGVyc19tb2RlbDsKKwogc3RhdGljIHZvaWQKIGFjdGl2YXRlX3VyaV9lbnRyeV9jYiAoR3Rr V2lkZ2V0KiBlbnRyeSwgZ3BvaW50ZXIgZGF0YSkKIHsKQEAgLTEwNiw2ICsxMjIsMzU4IEBAIGdv X2ZvcndhcmRfY2IgKEd0a1dpZGdldCogd2lkZ2V0LCBncG9pbnQKICAgICB3ZWJraXRfd2ViX3Zp ZXdfZ29fZm9yd2FyZCAod2ViX3ZpZXcpOwogfQogCitzdGF0aWMgdm9pZAorc2hvd19odHRwX2lu c3BlY3Rfd2luZG93X2NiKEd0a1dpZGdldCogd2lkZ2V0LCBncG9pbnRlciBkYXRhKQoreworICAg IGd0a19kaWFsb2dfcnVuIChHVEtfRElBTE9HKGh0dHBfaW5zcGVjdF93aW5kb3cpKTsKKyAgICBn dGtfd2lkZ2V0X2hpZGUgKGh0dHBfaW5zcGVjdF93aW5kb3cpOworfQorCitzdGF0aWMgdm9pZAor bmF2aWdhdGlvbl9yZXF1ZXN0ZWRfY2IgKFdlYktpdFdlYlZpZXcqIHdlYl92aWV3LCBXZWJLaXRX ZWJGcmFtZSogZnJhbWUsIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBncG9pbnRlciBk YXRhKQoreworICAgIEd0a0xpc3RTdG9yZSogbW9kZWwgPSBodHRwX2luc3BlY3RfcmVxdWVzdHNf bW9kZWw7CisgICAgR3RrVHJlZUl0ZXIgaXRlcjsKKworICAgIGdfb2JqZWN0X3JlZiAocmVxdWVz dCk7CisKKyAgICBndGtfbGlzdF9zdG9yZV9hcHBlbmQobW9kZWwsICZpdGVyKTsKKyAgICBndGtf bGlzdF9zdG9yZV9zZXQobW9kZWwsICZpdGVyLAorICAgICAgICAgICAgICAgICAgICAgICAwLCB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF91cmkgKHJlcXVlc3QpLAorICAgICAgICAgICAgICAg ICAgICAgICAxLCByZXF1ZXN0LAorICAgICAgICAgICAgICAgICAgICAgICAtMSk7Cit9CisKK3N0 YXRpYyB2b2lkCityZXF1ZXN0X3N0YXJ0ZWRfY2IgKFdlYktpdFdlYlZpZXcqIHdlYl92aWV3LCBX ZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgZ3BvaW50ZXIgZGF0YSkKK3sKKyAgICAvLyBj dXN0b20gaGVhZGVyLCBqdXN0IHRvIHRlc3QgaWYgdGhpcyB0aGluZyB3b3JrcworICAgIHdlYmtp dF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfaGVhZGVyIChyZXF1ZXN0LCAiWC1NaXNjIiwgImdv LCB3ZWJraXQhIik7Cit9CisKK3N0YXRpYyB2b2lkIGFwcGVuZF9oZWFkZXJfdG9faHR0cF9pbnNw ZWN0X2hlYWRlcnNfbW9kZWwgKGdjaGFyKiBrZXksIGdjaGFyKiB2YWx1ZSwgR3RrVHJlZVNlbGVj dGlvbiogc2VsZWN0aW9uKQoreworICAgIEd0a0xpc3RTdG9yZSogbW9kZWwgPSBHVEtfTElTVF9T VE9SRShodHRwX2luc3BlY3RfaGVhZGVyc19tb2RlbCk7CisgICAgR3RrVHJlZUl0ZXIgaXRlcjsK KyAgICAKKyAgICBndGtfbGlzdF9zdG9yZV9hcHBlbmQgKG1vZGVsLCAmaXRlcik7CisgICAgZ3Rr X2xpc3Rfc3RvcmVfc2V0IChtb2RlbCwgJml0ZXIsIDAsIGtleSwgMSwgdmFsdWUsIC0xKTsKK30K Kworc3RhdGljIGNvbnN0IGdjaGFyKiBjYWNoZV9wb2xpY3lfdG9fc3RyaW5nIChXZWJLaXRSZXFD YWNoZVBvbGljeSBjYWNoZV9wb2xpY3kpCit7CisgICAgc3dpdGNoKGNhY2hlX3BvbGljeSkKKyAg ICAgICAgeworICAgICAgICBjYXNlIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX1BST1RPQ09MOgor ICAgICAgICAgICAgcmV0dXJuICJOb3JtYWwgbG9hZCI7CisgICAgICAgIGNhc2UgV0VCS0lUX1JF UV9DQUNIRV9QT0xJQ1lfUkVMT0FEX0lHTk9SSU5HX0NBQ0hFOgorICAgICAgICAgICAgcmV0dXJu ICJSZWxvYWQiOworICAgICAgICBjYXNlIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX0FMTE9XX1NU QUxFOgorICAgICAgICAgICAgcmV0dXJuICJBbGxvdyBzdGFsZSBkYXRhIjsKKyAgICAgICAgY2Fz ZSBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9DQUNIRV9PTkxZOgorICAgICAgICAgICAgcmV0dXJu ICJVc2UgY2FjaGUsIG9ubHkiOworICAgICAgICBkZWZhdWx0OgorICAgICAgICAgICAgcmV0dXJu ICJOb25lIjsKKyAgICAgICAgfQorfQorCit2b2lkIGh0dHBfaW5zcGVjdF9jdXJzb3JfY2hhbmdl ZF9jYiAoR3RrVHJlZVZpZXcqIHRyZWVfdmlldywgZ3BvaW50ZXIgZGF0YSkKK3sKKyAgICBHdGtU cmVlTW9kZWwqIG1vZGVsID0gR1RLX1RSRUVfTU9ERUwoaHR0cF9pbnNwZWN0X3JlcXVlc3RzX21v ZGVsKTsKKyAgICBHdGtUcmVlU2VsZWN0aW9uKiBzZWxlY3Rpb24gPSBndGtfdHJlZV92aWV3X2dl dF9zZWxlY3Rpb24gKHRyZWVfdmlldyk7CisgICAgR3RrVHJlZUl0ZXIgaXRlcjsKKyAgICBXZWJL aXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdDsKKworICAgIGlmIChndGtfdHJlZV9zZWxlY3Rpb25f Z2V0X3NlbGVjdGVkIChzZWxlY3Rpb24sICZtb2RlbCwgJml0ZXIpKQorICAgICAgICB7CisgICAg ICAgICAgICBnY2hhciogdG1wOworCisgICAgICAgICAgICBndGtfdHJlZV9tb2RlbF9nZXQgKG1v ZGVsLCAmaXRlciwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMSwgJnJlcXVlc3Qs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC0xKTsKKyAgICAgICAgICAgIAorICAg ICAgICAgICAgZ3RrX2xhYmVsX3NldF90ZXh0IChHVEtfTEFCRUwoaHR0cF9pbnNwZWN0X2NhY2hl X3BvbGljeV9sYWJlbCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNhY2hlX3Bv bGljeV90b19zdHJpbmcgKHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2NhY2hlX3BvbGljeSAo cmVxdWVzdCkpKTsKKyAgICAgICAgICAgIHRtcCA9IGdfc3RyZHVwX3ByaW50ZiAoIiUuMmYiLCB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF90aW1lb3V0X2ludGVydmFsIChyZXF1ZXN0KSk7Cisg ICAgICAgICAgICBndGtfbGFiZWxfc2V0X3RleHQgKEdUS19MQUJFTChodHRwX2luc3BlY3RfdGlt ZW91dF9pbnRlcnZhbF9sYWJlbCksIHRtcCk7CisgICAgICAgICAgICBnX2ZyZWUgKHRtcCk7Cisg ICAgICAgICAgICBndGtfbGFiZWxfc2V0X3RleHQgKEdUS19MQUJFTChodHRwX2luc3BlY3RfbWFp bl9kb2N1bWVudF91cmlfbGFiZWwpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9tYWluX2RvY3VtZW50X3VyaSAocmVxdWVzdCkpOwor ICAgICAgICAgICAgZ3RrX2xhYmVsX3NldF90ZXh0IChHVEtfTEFCRUwoaHR0cF9pbnNwZWN0X21l dGhvZF9sYWJlbCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfZ2V0X2h0dHBfbWV0aG9kIChyZXF1ZXN0KSk7CisgICAgICAgICAgICBndGtf bGFiZWxfc2V0X3RleHQgKEdUS19MQUJFTChodHRwX2luc3BlY3RfY29udGVudF90eXBlX2xhYmVs KSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVz dF9nZXRfaHR0cF9jb250ZW50X3R5cGUgKHJlcXVlc3QpKTsKKyAgICAgICAgICAgIGd0a19sYWJl bF9zZXRfdGV4dCAoR1RLX0xBQkVMKGh0dHBfaW5zcGVjdF9yZWZlcmVyX2xhYmVsKSwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0 cF9yZWZlcmVyIChyZXF1ZXN0KSk7CisgICAgICAgICAgICBndGtfbGFiZWxfc2V0X3RleHQgKEdU S19MQUJFTChodHRwX2luc3BlY3RfdXNlcl9hZ2VudF9sYWJlbCksCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfdXNlcl9hZ2Vu dCAocmVxdWVzdCkpOworICAgICAgICAgICAgZ3RrX2xhYmVsX3NldF90ZXh0IChHVEtfTEFCRUwo aHR0cF9pbnNwZWN0X2FjY2VwdF9sYWJlbCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfYWNjZXB0IChyZXF1ZXN0KSk7Cisg ICAgICAgICAgICBndGtfbGFiZWxfc2V0X3RleHQgKEdUS19MQUJFTChodHRwX2luc3BlY3RfYWxs b3dfaHR0cF9jb29raWVzX2xhYmVsKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfYWxsb3dfaHR0cF9jb29raWVzIChyZXF1ZXN0KSA/ ICJUcnVlIiA6ICJGYWxzZSIpOworCisgICAgICAgICAgICBndGtfbGlzdF9zdG9yZV9jbGVhciAo aHR0cF9pbnNwZWN0X2hlYWRlcnNfbW9kZWwpOworICAgICAgICAgICAgZ19oYXNoX3RhYmxlX2Zv cmVhY2ggKChHSGFzaFRhYmxlKil3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRl cnMgKHJlcXVlc3QpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChHSEZ1bmMp YXBwZW5kX2hlYWRlcl90b19odHRwX2luc3BlY3RfaGVhZGVyc19tb2RlbCwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAoZ3BvaW50ZXIpc2VsZWN0aW9uKTsKKworICAgICAgICAg ICAgR3RrVGV4dEJ1ZmZlciogdGV4dF9idWZmZXIgPSBndGtfdGV4dF92aWV3X2dldF9idWZmZXIg KEdUS19URVhUX1ZJRVcoaHR0cF9pbnNwZWN0X2JvZHlfdGV4dF92aWV3KSk7CisgICAgICAgICAg ICBHdGtUZXh0SXRlciBzdGFydCwgZW5kOworICAgICAgICAgICAgZ3RrX3RleHRfYnVmZmVyX2dl dF9ib3VuZHMgKHRleHRfYnVmZmVyLCAmc3RhcnQsICZlbmQpOworICAgICAgICAgICAgZ3RrX3Rl eHRfYnVmZmVyX2RlbGV0ZSAodGV4dF9idWZmZXIsICZzdGFydCwgJmVuZCk7CisKKyAgICAgICAg ICAgIGNvbnN0IGdjaGFyICpib2R5ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfYm9keSAo cmVxdWVzdCk7CisgICAgICAgICAgICBpZiAoYm9keSkKKyAgICAgICAgICAgICAgICBndGtfdGV4 dF9idWZmZXJfc2V0X3RleHQgKHRleHRfYnVmZmVyLCBib2R5LCAtMSk7CisgICAgICAgIH0KK30K Kworc3RhdGljIEd0a1dpZGdldCoKK2NyZWF0ZV9odHRwX2luc3BlY3Rfd2luZG93ICgpCit7Cisg ICAgR3RrV2lkZ2V0KiB3aW5kb3cgPSBndGtfZGlhbG9nX25ld193aXRoX2J1dHRvbnMgKCJIVFRQ IFJlcXVlc3RzIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgR1RLX1dJTkRPVyhtYWluX3dpbmRvdyksCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdUS19ESUFMT0dfREVTVFJPWV9XSVRIX1BB UkVOVCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgR1RLX1NUT0NLX0NMT1NFLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBHVEtfUkVTUE9OU0VfREVMRVRFX0VWRU5ULAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMKTsKKyAgICBndGtf d2luZG93X3NldF9kZWZhdWx0X3NpemUgKEdUS19XSU5ET1cod2luZG93KSwgODAwLCA2MDApOwor CisgICAgLy8gYmFzaWMgbGF5b3V0CisgICAgR3RrV2lkZ2V0KiB2Ym94ID0gR1RLX0RJQUxPRyh3 aW5kb3cpLT52Ym94OworICAgIEd0a1dpZGdldCogcGFuZWQgPSBndGtfaHBhbmVkX25ldyAoKTsK KyAgICBndGtfYm94X3BhY2tfc3RhcnQgKEdUS19CT1godmJveCksIHBhbmVkLCBUUlVFLCBUUlVF LCAxMik7CisgICAgZ3RrX3dpZGdldF9zaG93KHBhbmVkKTsKKworICAgIEd0a1dpZGdldCogc2Ny b2xsZWRfd2luZG93ID0gZ3RrX3Njcm9sbGVkX3dpbmRvd19uZXcgKE5VTEwsIE5VTEwpOworICAg IGd0a19zY3JvbGxlZF93aW5kb3dfc2V0X3BvbGljeSAoR1RLX1NDUk9MTEVEX1dJTkRPVyhzY3Jv bGxlZF93aW5kb3cpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR1RLX1BP TElDWV9BVVRPTUFUSUMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtf UE9MSUNZX0FVVE9NQVRJQyk7CisgICAgZ3RrX3dpZGdldF9zZXRfc2l6ZV9yZXF1ZXN0IChzY3Jv bGxlZF93aW5kb3csIDIwMCwgLTEpOworICAgIGd0a19wYW5lZF9hZGQxIChHVEtfUEFORUQocGFu ZWQpLCBzY3JvbGxlZF93aW5kb3cpOworICAgIGd0a193aWRnZXRfc2hvdyAoc2Nyb2xsZWRfd2lu ZG93KTsKKworICAgIC8vIHRoZSB0cmVlCisgICAgaHR0cF9pbnNwZWN0X3JlcXVlc3RzX2xpc3Qg PSBndGtfdHJlZV92aWV3X25ldyAoKTsKKyAgICBndGtfdHJlZV92aWV3X3NldF9oZWFkZXJzX3Zp c2libGUgKEdUS19UUkVFX1ZJRVcoaHR0cF9pbnNwZWN0X3JlcXVlc3RzX2xpc3QpLCBGQUxTRSk7 CisgICAgZ3RrX3RyZWVfdmlld19hcHBlbmRfY29sdW1uIChHVEtfVFJFRV9WSUVXKGh0dHBfaW5z cGVjdF9yZXF1ZXN0c19saXN0KSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGd0 a190cmVlX3ZpZXdfY29sdW1uX25ld193aXRoX2F0dHJpYnV0ZXMgKCJVUkkiLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgZ3RrX2NlbGxfcmVuZGVyZXJfdGV4dF9uZXcoKSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICJ0ZXh0IiwgMCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpKTsKKyAgICBnX3NpZ25hbF9jb25u ZWN0KGh0dHBfaW5zcGVjdF9yZXF1ZXN0c19saXN0LCAiY3Vyc29yLWNoYW5nZWQiLAorICAgICAg ICAgICAgICAgICAgICAgR19DQUxMQkFDSyhodHRwX2luc3BlY3RfY3Vyc29yX2NoYW5nZWRfY2Ip LCBOVUxMKTsKKyAgICBndGtfY29udGFpbmVyX2FkZCAoR1RLX0NPTlRBSU5FUihzY3JvbGxlZF93 aW5kb3cpLCBodHRwX2luc3BlY3RfcmVxdWVzdHNfbGlzdCk7CisgICAgZ3RrX3dpZGdldF9zaG93 IChodHRwX2luc3BlY3RfcmVxdWVzdHNfbGlzdCk7CisKKyAgICBodHRwX2luc3BlY3RfcmVxdWVz dHNfbW9kZWwgPSBndGtfbGlzdF9zdG9yZV9uZXcgKDIsIEdfVFlQRV9TVFJJTkcsIFdFQktJVF9U WVBFX05FVFdPUktfUkVRVUVTVCwgLTEpOworICAgIGd0a190cmVlX3ZpZXdfc2V0X21vZGVsIChH VEtfVFJFRV9WSUVXKGh0dHBfaW5zcGVjdF9yZXF1ZXN0c19saXN0KSwgR1RLX1RSRUVfTU9ERUwo aHR0cF9pbnNwZWN0X3JlcXVlc3RzX21vZGVsKSk7CisKKyAgICAvLyBtb3JlIGxheW91dGluZywg Zm9yIHRoZSByaWdodCBzaWRlIG9mIHRoZSB3aW5kb3cKKyAgICBHdGtXaWRnZXQqIHJ2Ym94ID0g Z3RrX3Zib3hfbmV3IChGQUxTRSwgMik7CisgICAgZ3RrX3BhbmVkX2FkZDIgKEdUS19QQU5FRChw YW5lZCksIHJ2Ym94KTsKKyAgICBndGtfd2lkZ2V0X3Nob3cgKHJ2Ym94KTsKKworICAgIEd0a1dp ZGdldCogdGFibGUgPSBndGtfdGFibGVfbmV3ICg4LCAyLCBGQUxTRSk7CisgICAgZ3RrX3RhYmxl X3NldF9yb3dfc3BhY2luZ3MgKEdUS19UQUJMRSh0YWJsZSksIDEyKTsKKyAgICBndGtfYm94X3Bh Y2tfc3RhcnQgKEdUS19CT1gocnZib3gpLCB0YWJsZSwgRkFMU0UsIEZBTFNFLCAwKTsKKyAgICBn dGtfd2lkZ2V0X3Nob3cgKHRhYmxlKTsKKworICAgIC8vIGRldGFpbHMgb2YgdGhlIHJlcXVlc3QK KyAgICAvLyBDYWNoZSBQb2xpY3kKKyAgICBHdGtXaWRnZXQqIGxhYmVsID0gZ19vYmplY3RfbmV3 IChHVEtfVFlQRV9MQUJFTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAi bGFiZWwiLCAiPGI+Q2FjaGUgUG9saWN5PC9iPiIsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgInVzZS1tYXJrdXAiLCBUUlVFLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIE5VTEwpOworICAgIGd0a190YWJsZV9hdHRhY2hfZGVmYXVsdHMgKEdUS19U QUJMRSh0YWJsZSksIGxhYmVsLCAwLCAxLCAwLCAxKTsKKyAgICBndGtfd2lkZ2V0X3Nob3cobGFi ZWwpOworCisgICAgaHR0cF9pbnNwZWN0X2NhY2hlX3BvbGljeV9sYWJlbCA9IGdfb2JqZWN0X25l dyAoR1RLX1RZUEVfTEFCRUwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgImxhYmVsIiwgIiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIndyYXAiLCBUUlVFLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOworICAgIGd0a190YWJsZV9h dHRhY2hfZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJsZSksIGh0dHBfaW5zcGVjdF9jYWNoZV9wb2xp Y3lfbGFiZWwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMSwgMiwgMCwgMSk7Cisg ICAgZ3RrX3dpZGdldF9zaG93KGh0dHBfaW5zcGVjdF9jYWNoZV9wb2xpY3lfbGFiZWwpOworCisg ICAgLy8gVGltZW91dCBJbnRlcnZhbAorICAgIGxhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQ RV9MQUJFTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgImxhYmVsIiwgIjxiPlRpbWVvdXQg aW50ZXJ2YWw8L2I+IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgInVzZS1tYXJrdXAiLCBU UlVFLAorICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMKTsKKyAgICBndGtfdGFibGVfYXR0 YWNoX2RlZmF1bHRzIChHVEtfVEFCTEUodGFibGUpLCBsYWJlbCwgMCwgMSwgMSwgMik7CisgICAg Z3RrX3dpZGdldF9zaG93KGxhYmVsKTsKKworICAgIGh0dHBfaW5zcGVjdF90aW1lb3V0X2ludGVy dmFsX2xhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJFTCwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgImxhYmVsIiwgIiIsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJ3 cmFwIiwgVFJVRSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgTlVMTCk7CisgICAgZ3RrX3RhYmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RLX1RB QkxFKHRhYmxlKSwgaHR0cF9pbnNwZWN0X3RpbWVvdXRfaW50ZXJ2YWxfbGFiZWwsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgMSwgMiwgMSwgMik7CisgICAgZ3RrX3dpZGdldF9zaG93 KGh0dHBfaW5zcGVjdF90aW1lb3V0X2ludGVydmFsX2xhYmVsKTsKKworICAgIC8vIE1haW4gZG9j dW1lbnQgVVJJCisgICAgbGFiZWwgPSBnX29iamVjdF9uZXcgKEdUS19UWVBFX0xBQkVMLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAibGFiZWwiLCAiPGI+TWFpbiBkb2N1bWVudCBVUkk8L2I+ IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgInVzZS1tYXJrdXAiLCBUUlVFLAorICAgICAg ICAgICAgICAgICAgICAgICAgICBOVUxMKTsKKyAgICBndGtfdGFibGVfYXR0YWNoX2RlZmF1bHRz IChHVEtfVEFCTEUodGFibGUpLCBsYWJlbCwgMCwgMSwgMiwgMyk7CisgICAgZ3RrX3dpZGdldF9z aG93KGxhYmVsKTsKKworICAgIGh0dHBfaW5zcGVjdF9tYWluX2RvY3VtZW50X3VyaV9sYWJlbCA9 IGdfb2JqZWN0X25ldyAoR1RLX1RZUEVfTEFCRUwsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAibGFiZWwiLCAiIiwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJ3cmFwIiwgVFJV RSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIE5VTEwpOworICAgIGd0a190YWJsZV9hdHRhY2hfZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJs ZSksIGh0dHBfaW5zcGVjdF9tYWluX2RvY3VtZW50X3VyaV9sYWJlbCwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAxLCAyLCAyLCAzKTsKKyAgICBndGtfd2lkZ2V0X3Nob3coaHR0cF9p bnNwZWN0X21haW5fZG9jdW1lbnRfdXJpX2xhYmVsKTsKKworICAgIC8vIEhUVFAgbWV0aG9kCisg ICAgbGFiZWwgPSBnX29iamVjdF9uZXcgKEdUS19UWVBFX0xBQkVMLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAibGFiZWwiLCAiPGI+TWV0aG9kPC9iPiIsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICJ1c2UtbWFya3VwIiwgVFJVRSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgTlVM TCk7CisgICAgZ3RrX3RhYmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgbGFi ZWwsIDAsIDEsIDMsIDQpOworICAgIGd0a193aWRnZXRfc2hvdyhsYWJlbCk7CisKKyAgICBodHRw X2luc3BlY3RfbWV0aG9kX2xhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJFTCwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAibGFiZWwiLCAiIiwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAid3JhcCIsIFRS VUUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7 CisgICAgZ3RrX3RhYmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgaHR0cF9p bnNwZWN0X21ldGhvZF9sYWJlbCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxLCAy LCAzLCA0KTsKKyAgICBndGtfd2lkZ2V0X3Nob3coaHR0cF9pbnNwZWN0X21ldGhvZF9sYWJlbCk7 CisKKyAgICAvLyBIVFRQIENvbnRlbnQgVHlwZQorICAgIGxhYmVsID0gZ19vYmplY3RfbmV3IChH VEtfVFlQRV9MQUJFTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgImxhYmVsIiwgIjxiPkNv bnRlbnQgVHlwZTwvYj4iLAorICAgICAgICAgICAgICAgICAgICAgICAgICAidXNlLW1hcmt1cCIs IFRSVUUsCisgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOworICAgIGd0a190YWJsZV9h dHRhY2hfZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJsZSksIGxhYmVsLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIDAsIDEsIDQsIDUpOworICAgIGd0a193aWRnZXRfc2hvdyhsYWJlbCk7 CisKKyAgICBodHRwX2luc3BlY3RfY29udGVudF90eXBlX2xhYmVsID0gZ19vYmplY3RfbmV3IChH VEtfVFlQRV9MQUJFTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAibGFiZWwiLCAiIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAid3JhcCIsIFRSVUUsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7CisgICAgZ3RrX3RhYmxlX2F0dGFj aF9kZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgaHR0cF9pbnNwZWN0X2NvbnRlbnRfdHlwZV9s YWJlbCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxLCAyLCA0LCA1KTsKKyAgICBn dGtfd2lkZ2V0X3Nob3coaHR0cF9pbnNwZWN0X2NvbnRlbnRfdHlwZV9sYWJlbCk7CisKKyAgICAv LyBIVFRQIFJlZmVyZXIKKyAgICBsYWJlbCA9IGdfb2JqZWN0X25ldyAoR1RLX1RZUEVfTEFCRUws CisgICAgICAgICAgICAgICAgICAgICAgICAgICJsYWJlbCIsICI8Yj5SZWZlcmVyPC9iPiIsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICJ1c2UtbWFya3VwIiwgVFJVRSwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgTlVMTCk7CisgICAgZ3RrX3RhYmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RL X1RBQkxFKHRhYmxlKSwgbGFiZWwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMCwg MSwgNSwgNik7CisgICAgZ3RrX3dpZGdldF9zaG93KGxhYmVsKTsKKworICAgIGh0dHBfaW5zcGVj dF9yZWZlcmVyX2xhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJFTCwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAibGFiZWwiLCAiIiwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIndyYXAiLCBUUlVFLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOworICAg IGd0a190YWJsZV9hdHRhY2hfZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJsZSksIGh0dHBfaW5zcGVj dF9yZWZlcmVyX2xhYmVsLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDEsIDIsIDUs IDYpOworICAgIGd0a193aWRnZXRfc2hvdyhodHRwX2luc3BlY3RfcmVmZXJlcl9sYWJlbCk7CisK KyAgICAvLyBIVFRQIFVzZXIgQWdlbnQKKyAgICBsYWJlbCA9IGdfb2JqZWN0X25ldyAoR1RLX1RZ UEVfTEFCRUwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICJsYWJlbCIsICI8Yj5Vc2VyIEFn ZW50PC9iPiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICJ1c2UtbWFya3VwIiwgVFJVRSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7CisgICAgZ3RrX3RhYmxlX2F0dGFjaF9k ZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgbGFiZWwsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgMCwgMSwgNiwgNyk7CisgICAgZ3RrX3dpZGdldF9zaG93KGxhYmVsKTsKKworICAg IGh0dHBfaW5zcGVjdF91c2VyX2FnZW50X2xhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9M QUJFTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ImxhYmVsIiwgIiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICJ3cmFwIiwgVFJVRSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgTlVMTCk7CisgICAgZ3RrX3RhYmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RL X1RBQkxFKHRhYmxlKSwgaHR0cF9pbnNwZWN0X3VzZXJfYWdlbnRfbGFiZWwsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgMSwgMiwgNiwgNyk7CisgICAgZ3RrX3dpZGdldF9zaG93KGh0 dHBfaW5zcGVjdF91c2VyX2FnZW50X2xhYmVsKTsKKworICAgIC8vIEhUVFAgQWNjZXB0CisgICAg bGFiZWwgPSBnX29iamVjdF9uZXcgKEdUS19UWVBFX0xBQkVMLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAibGFiZWwiLCAiPGI+QWNjZXB0PC9iPiIsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICJ1c2UtbWFya3VwIiwgVFJVRSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7 CisgICAgZ3RrX3RhYmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgbGFiZWws CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMCwgMSwgNywgOCk7CisgICAgZ3RrX3dp ZGdldF9zaG93KGxhYmVsKTsKKworICAgIGh0dHBfaW5zcGVjdF9hY2NlcHRfbGFiZWwgPSBnX29i amVjdF9uZXcgKEdUS19UWVBFX0xBQkVMLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICJsYWJlbCIsICIiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICJ3cmFwIiwgVFJVRSwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBOVUxMKTsKKyAgICBndGtfdGFibGVfYXR0YWNoX2RlZmF1 bHRzIChHVEtfVEFCTEUodGFibGUpLCBodHRwX2luc3BlY3RfYWNjZXB0X2xhYmVsLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIDEsIDIsIDcsIDgpOworICAgIGd0a193aWRnZXRfc2hv dyhodHRwX2luc3BlY3RfYWNjZXB0X2xhYmVsKTsKKworICAgIC8vIEFsbG93IEhUVFAgQ29va2ll cworICAgIGxhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJFTCwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgImxhYmVsIiwgIjxiPkFsbG93IEhUVFAgQ29va2llczwvYj4iLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAidXNlLW1hcmt1cCIsIFRSVUUsCisgICAgICAgICAgICAg ICAgICAgICAgICAgIE5VTEwpOworICAgIGd0a190YWJsZV9hdHRhY2hfZGVmYXVsdHMgKEdUS19U QUJMRSh0YWJsZSksIGxhYmVsLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDAsIDEs IDgsIDkpOworICAgIGd0a193aWRnZXRfc2hvdyhsYWJlbCk7CisKKyAgICBodHRwX2luc3BlY3Rf YWxsb3dfaHR0cF9jb29raWVzX2xhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJFTCwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAibGFiZWwiLCAiIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAid3JhcCIsIFRSVUUsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7CisgICAgZ3RrX3RhYmxlX2F0 dGFjaF9kZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgaHR0cF9pbnNwZWN0X2FsbG93X2h0dHBf Y29va2llc19sYWJlbCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxLCAyLCA3LCA4 KTsKKyAgICBndGtfd2lkZ2V0X3Nob3coaHR0cF9pbnNwZWN0X2FjY2VwdF9sYWJlbCk7CisKKyAg ICAvLyBoZWFkZXJzIGxpc3RpbmcKKyAgICBHdGtXaWRnZXQqIGV4cGFuZGVyID0gZ3RrX2V4cGFu ZGVyX25ldyAoIkhlYWRlcnMuLi4iKTsKKyAgICBndGtfYm94X3BhY2tfc3RhcnQgKEdUS19CT1go cnZib3gpLCBleHBhbmRlciwgRkFMU0UsIEZBTFNFLCAwKTsKKyAgICBndGtfd2lkZ2V0X3Nob3cg KGV4cGFuZGVyKTsKKworICAgIHNjcm9sbGVkX3dpbmRvdyA9IGd0a19zY3JvbGxlZF93aW5kb3df bmV3IChOVUxMLCBOVUxMKTsKKyAgICBndGtfc2Nyb2xsZWRfd2luZG93X3NldF9wb2xpY3kgKEdU S19TQ1JPTExFRF9XSU5ET1coc2Nyb2xsZWRfd2luZG93KSwgR1RLX1BPTElDWV9BVVRPTUFUSUMs IEdUS19QT0xJQ1lfQVVUT01BVElDKTsKKyAgICBndGtfd2lkZ2V0X3NldF9zaXplX3JlcXVlc3Qg KHNjcm9sbGVkX3dpbmRvdywgLTEsIDE4MCk7CisgICAgZ3RrX2NvbnRhaW5lcl9hZGQgKEdUS19D T05UQUlORVIoZXhwYW5kZXIpLCBzY3JvbGxlZF93aW5kb3cpOworICAgIGd0a193aWRnZXRfc2hv dyAoc2Nyb2xsZWRfd2luZG93KTsKKworICAgIGh0dHBfaW5zcGVjdF9oZWFkZXJzX2xpc3QgPSBn dGtfdHJlZV92aWV3X25ldyAoKTsKKyAgICBndGtfdHJlZV92aWV3X2FwcGVuZF9jb2x1bW4gKEdU S19UUkVFX1ZJRVcoaHR0cF9pbnNwZWN0X2hlYWRlcnNfbGlzdCksCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBndGtfdHJlZV92aWV3X2NvbHVtbl9uZXdfd2l0aF9hdHRyaWJ1dGVz ICgiSGVhZGVyIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGd0a19jZWxsX3JlbmRlcmVyX3RleHRfbmV3 ICgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgInRleHQiLCAwLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTlVM TCkpOworICAgIGd0a190cmVlX3ZpZXdfYXBwZW5kX2NvbHVtbiAoR1RLX1RSRUVfVklFVyhodHRw X2luc3BlY3RfaGVhZGVyc19saXN0KSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGd0a190cmVlX3ZpZXdfY29sdW1uX25ld193aXRoX2F0dHJpYnV0ZXMgKCJWYWx1ZSIsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBndGtfY2VsbF9yZW5kZXJlcl90ZXh0X25ldyAoKSwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICJ0ZXh0IiwgMSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpKTsKKyAgICBndGtfY29u dGFpbmVyX2FkZCAoR1RLX0NPTlRBSU5FUihzY3JvbGxlZF93aW5kb3cpLCBodHRwX2luc3BlY3Rf aGVhZGVyc19saXN0KTsKKyAgICBndGtfd2lkZ2V0X3Nob3cgKGh0dHBfaW5zcGVjdF9oZWFkZXJz X2xpc3QpOworCisgICAgaHR0cF9pbnNwZWN0X2hlYWRlcnNfbW9kZWwgPSBndGtfbGlzdF9zdG9y ZV9uZXcgKDIsIEdfVFlQRV9TVFJJTkcsIEdfVFlQRV9TVFJJTkcpOworICAgIGd0a190cmVlX3Zp ZXdfc2V0X21vZGVsIChHVEtfVFJFRV9WSUVXKGh0dHBfaW5zcGVjdF9oZWFkZXJzX2xpc3QpLCBH VEtfVFJFRV9NT0RFTChodHRwX2luc3BlY3RfaGVhZGVyc19tb2RlbCkpOworCisgICAgLy8gcmVx dWVzdCBib2R5CisgICAgR3RrV2lkZ2V0KiBmcmFtZSA9IGd0a19mcmFtZV9uZXcgKCJCb2R5Iik7 CisgICAgZ3RrX2JveF9wYWNrX3N0YXJ0IChHVEtfQk9YKHJ2Ym94KSwgZnJhbWUsIFRSVUUsIFRS VUUsIDApOworICAgIGd0a193aWRnZXRfc2hvdyAoZnJhbWUpOworCisgICAgc2Nyb2xsZWRfd2lu ZG93ID0gZ3RrX3Njcm9sbGVkX3dpbmRvd19uZXcgKE5VTEwsIE5VTEwpOworICAgIGd0a19zY3Jv bGxlZF93aW5kb3dfc2V0X3BvbGljeSAoR1RLX1NDUk9MTEVEX1dJTkRPVyhzY3JvbGxlZF93aW5k b3cpLCBHVEtfUE9MSUNZX0FVVE9NQVRJQywgR1RLX1BPTElDWV9BVVRPTUFUSUMpOworICAgIGd0 a19jb250YWluZXJfYWRkIChHVEtfQ09OVEFJTkVSKGZyYW1lKSwgc2Nyb2xsZWRfd2luZG93KTsK KyAgICBndGtfd2lkZ2V0X3Nob3cgKHNjcm9sbGVkX3dpbmRvdyk7CisKKyAgICBodHRwX2luc3Bl Y3RfYm9keV90ZXh0X3ZpZXcgPSBndGtfdGV4dF92aWV3X25ldyAoKTsKKyAgICBndGtfY29udGFp bmVyX2FkZCAoR1RLX0NPTlRBSU5FUihzY3JvbGxlZF93aW5kb3cpLCBodHRwX2luc3BlY3RfYm9k eV90ZXh0X3ZpZXcpOworICAgIGd0a193aWRnZXRfc2hvdyAoaHR0cF9pbnNwZWN0X2JvZHlfdGV4 dF92aWV3KTsKKworICAgIHJldHVybiB3aW5kb3c7Cit9CisKIHN0YXRpYyBHdGtXaWRnZXQqCiBj cmVhdGVfYnJvd3NlciAoKQogewpAQCAtMTE5LDYgKzQ4Nyw4IEBAIGNyZWF0ZV9icm93c2VyICgp CiAgICAgZ19zaWduYWxfY29ubmVjdCAoR19PQkpFQ1QgKHdlYl92aWV3KSwgImxvYWQtcHJvZ3Jl c3MtY2hhbmdlZCIsIEdfQ0FMTEJBQ0sgKHByb2dyZXNzX2NoYW5nZV9jYiksIHdlYl92aWV3KTsK ICAgICBnX3NpZ25hbF9jb25uZWN0IChHX09CSkVDVCAod2ViX3ZpZXcpLCAibG9hZC1jb21taXR0 ZWQiLCBHX0NBTExCQUNLIChsb2FkX2NvbW1pdF9jYiksIHdlYl92aWV3KTsKICAgICBnX3NpZ25h bF9jb25uZWN0IChHX09CSkVDVCAod2ViX3ZpZXcpLCAiaG92ZXJpbmctb3Zlci1saW5rIiwgR19D QUxMQkFDSyAobGlua19ob3Zlcl9jYiksIHdlYl92aWV3KTsKKyAgICBnX3NpZ25hbF9jb25uZWN0 IChHX09CSkVDVCAod2ViX3ZpZXcpLCAibmF2aWdhdGlvbi1yZXF1ZXN0ZWQiLCBHX0NBTExCQUNL IChuYXZpZ2F0aW9uX3JlcXVlc3RlZF9jYiksIHdlYl92aWV3KTsKKyAgICBnX3NpZ25hbF9jb25u ZWN0IChHX09CSkVDVCAod2ViX3ZpZXcpLCAicmVxdWVzdC1zdGFydGVkIiwgR19DQUxMQkFDSyAo cmVxdWVzdF9zdGFydGVkX2NiKSwgd2ViX3ZpZXcpOwogCiAgICAgcmV0dXJuIHNjcm9sbGVkX3dp bmRvdzsKIH0KQEAgLTE1Miw2ICs1MjIsMTEgQEAgY3JlYXRlX3Rvb2xiYXIgKCkKICAgICBnX3Np Z25hbF9jb25uZWN0IChHX09CSkVDVCAoaXRlbSksICJjbGlja2VkIiwgR19DQUxMQkFDSyAoZ29f Zm9yd2FyZF9jYiksIE5VTEwpOwogICAgIGd0a190b29sYmFyX2luc2VydCAoR1RLX1RPT0xCQVIg KHRvb2xiYXIpLCBpdGVtLCAtMSk7CiAKKyAgICAvKiBUaGUgaHR0cCBpbnNwZWN0IGJ1dHRvbiAq LworICAgIGl0ZW0gPSBndGtfdG9vbF9idXR0b25fbmV3X2Zyb21fc3RvY2sgKEdUS19TVE9DS19O RVRXT1JLKTsKKyAgICBnX3NpZ25hbF9jb25uZWN0IChHX09CSkVDVCAoaXRlbSksICJjbGlja2Vk IiwgR19DQUxMQkFDSyAoc2hvd19odHRwX2luc3BlY3Rfd2luZG93X2NiKSwgTlVMTCk7CisgICAg Z3RrX3Rvb2xiYXJfaW5zZXJ0IChHVEtfVE9PTEJBUiAodG9vbGJhciksIGl0ZW0sIC0xKTsKKwog ICAgIC8qIFRoZSBVUkwgZW50cnkgKi8KICAgICBpdGVtID0gZ3RrX3Rvb2xfaXRlbV9uZXcgKCk7 CiAgICAgZ3RrX3Rvb2xfaXRlbV9zZXRfZXhwYW5kIChpdGVtLCBUUlVFKTsKQEAgLTE5Miw2ICs1 NjcsOCBAQCBtYWluIChpbnQgYXJnYywgY2hhciogYXJndltdKQogICAgIG1haW5fd2luZG93ID0g Y3JlYXRlX3dpbmRvdyAoKTsKICAgICBndGtfY29udGFpbmVyX2FkZCAoR1RLX0NPTlRBSU5FUiAo bWFpbl93aW5kb3cpLCB2Ym94KTsKIAorICAgIGh0dHBfaW5zcGVjdF93aW5kb3cgPSBjcmVhdGVf aHR0cF9pbnNwZWN0X3dpbmRvdyAoKTsKKwogICAgIGdjaGFyKiB1cmkgPSAoZ2NoYXIqKSAoYXJn YyA+IDEgPyBhcmd2WzFdIDogImh0dHA6Ly93d3cuZ29vZ2xlLmNvbS8iKTsKICAgICB3ZWJraXRf d2ViX3ZpZXdfb3BlbiAod2ViX3ZpZXcsIHVyaSk7CiAK 21070 2008-05-11 10:59:32 -0700 2008-07-28 17:38:51 -0700 proposed patch network-request-and-network-response.diff text/plain 69929 gustavo SW5kZXg6IENoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBDaGFuZ2VMb2cJKHJldmlzaW9uIDMzMDMy KQorKysgQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTEgQEAKKzIwMDgtMDUt MTEgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGduc0Bnbm9tZS5vcmc+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKwlBZGRlZCBuZXcgZmlsZSB0byB0aGUgR1RLKyBi dWlsZDogd2Via2l0bmV0d29ya3Jlc3BvbnNlLmNwcC4KKyAgICAgICAgCisJKiBHTlVtYWtlZmls ZS5hbToKKwogMjAwOC0wNS0wOSAgQW5kZXJzIENhcmxzc29uICA8YW5kZXJzY2FAYXBwbGUuY29t PgogCiAgICAgICAgIFJldmlld2VkIGJ5IE1hcmsuCkluZGV4OiBHTlVtYWtlZmlsZS5hbQo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBHTlVtYWtlZmlsZS5hbQkocmV2aXNpb24gMzMwMzIpCisrKyBHTlVtYWtlZmls ZS5hbQkod29ya2luZyBjb3B5KQpAQCAtMzEzLDYgKzMxMyw3IEBAIHdlYmtpdGd0a19oZWFkZXJz ICs9IFwKIAogd2Via2l0Z3RrX3NvdXJjZXMgKz0gXAogCVdlYktpdC9ndGsvd2Via2l0L3dlYmtp dG5ldHdvcmtyZXF1ZXN0LmNwcCBcCisJV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jl c3BvbnNlLmNwcCBcCiAJV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAgXAogCVdl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmJhY2tmb3J3YXJkbGlzdC5jcHAgXAogCVdlYktpdC9n dGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcCBcCkluZGV4OiBXZWJLaXQvZ3RrL0NoYW5nZUxv Zwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJLaXQvZ3RrL0NoYW5nZUxvZwkocmV2aXNpb24gMzMwMzIpCisr KyBXZWJLaXQvZ3RrL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDcxIEBACisy MDA4LTA1LTExICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxnbnNAZ25vbWUub3JnPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisJaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTE4NjA4CisgICAgICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0IG5l ZWRzIHRvIGJlIGZpbmlzaGVkCisKKwlHT2JqZWN0IGltcGxlbWVudGF0aW9uIGV4cG9zaW5nIFJl c291cmNlUmVxdWVzdCwgYW5kIGluaXRpYWwKKwlpbXBsZW1lbnRhdGlvbiBleHBvc2luZyBSZXNv dXJjZVJlc3BvbnNlLiBGcmFtZUxvYWRlckNsaWVudEd0ayBpcworCW5vdyB1c2luZyBXZWJLaXRO ZXR3b3JrUmVxdWVzdCB3aGVuIGl0IG5lZWRzIHRvIGRlYWwgd2l0aCByZXF1ZXN0CisJaW5mb3Jt YXRpb24uIEFsc28sIHRoZSBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hXaWxsU2VuZFJlcXVl c3QKKwlwb2xpY3kgZGVsZWdhdGUgaGFzIGJlZW4gaW1wbGVtZW50ZWQsIG1hcHBpbmcgdG8gdGhl IG5ldworCXJlcXVlc3Qtc3RhcnRlZCBhbmQgcmVxdWVzdC1yZWRpcmVjdGVkIHNpZ25hbHMgaW4g V2ViS2l0V2ViVmlldy4KKworICAgICAgICAqIENoYW5nZUxvZzoKKyAgICAgICAgKiBXZWJDb3Jl U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHA6CisgICAgICAgIChXZWJLaXQ6OkZyYW1l TG9hZGVyQ2xpZW50OjpkaXNwYXRjaFdpbGxTZW5kUmVxdWVzdCk6CisgICAgICAgIChXZWJLaXQ6 OkZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERlY2lkZVBvbGljeUZvck5hdmlnYXRpb25BY3Rp b24pOgorICAgICAgICAqIHdlYmtpdC93ZWJraXQuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0 ZGVmaW5lcy5oOgorICAgICAgICAqIHdlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHA6Cisg ICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X2ZpbmFsaXplKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OmNh Y2hlX3BvbGljeV9mcm9tX3Jlc291cmNlX3JlcXVlc3QpOgorICAgICAgICAoX1dlYktpdE5ldHdv cmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfZnJvbV9yZXNvdXJj ZV9yZXF1ZXN0KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtp dF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3Jlc291cmNlX3JlcXVlc3QpOgorICAgICAgICAoX1dlYktp dE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpKToK KyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X3VyaSk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9jYWNoZV9wb2xpY3kpOgorICAgICAgICAoX1dlYktp dE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfY2FjaGVf cG9saWN5KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9u ZXR3b3JrX3JlcXVlc3Rfc2V0X3RpbWVvdXRfaW50ZXJ2YWwpOgorICAgICAgICAoX1dlYktpdE5l dHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdGltZW91dF9p bnRlcnZhbCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRf bmV0d29ya19yZXF1ZXN0X3NldF9tYWluX2RvY3VtZW50X3VyaSk6CisgICAgICAgIChfV2ViS2l0 TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9tYWluX2Rv Y3VtZW50X3VyaSk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX21ldGhvZCk6CisgICAgICAgIChfV2ViS2l0TmV0 d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX21ldGhv ZCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjpjb3B5X2hlYWRlcik6 CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X2FkZF9odHRwX2hlYWRlcnMpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0 UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9oZWFkZXJzKToKKyAgICAg ICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf YWRkX2h0dHBfaGVhZGVyKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6 OndlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfaGVhZGVyKToKKyAgICAgICAgKF9XZWJL aXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBf aGVhZGVyKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9u ZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfY29udGVudF90eXBlKToKKyAgICAgICAgKF9XZWJLaXRO ZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfY29u dGVudF90eXBlKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtp dF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfcmVmZXJlcik6CisgICAgICAgIChfV2ViS2l0TmV0 d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX3JlZmVy ZXIpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdv cmtfcmVxdWVzdF9zZXRfaHR0cF91c2VyX2FnZW50KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3Jr UmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfdXNlcl9hZ2Vu dCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29y a19yZXF1ZXN0X3NldF9odHRwX2FjY2VwdCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVl c3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2FjY2VwdCk6CisgICAg ICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X3NldF9ib2R5KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtp dF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2JvZHkpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1 ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfYWxsb3dfaHR0cF9jb29raWVz KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfZ2V0X2FsbG93X2h0dHBfY29va2llcyk6CisgICAgICAgICogd2Via2l0L3dlYmtp dG5ldHdvcmtyZXF1ZXN0Lmg6CisgICAgICAgICogd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25z ZS5jcHA6IEFkZGVkLgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGU6Ondl YmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2ZpbmFsaXplKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3Jr UmVzcG9uc2VQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXNwb25zZV9jbGFzc19pbml0KToKKyAg ICAgICAgKF9XZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXNw b25zZV9pbml0KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlOjp3ZWJr aXRfbmV0d29ya19yZXNwb25zZV9uZXdfZnJvbV9yZXNvdXJjZV9yZXNwb25zZSk6CisgICAgICAg IChfV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVzcG9uc2Vf Z2V0X3Jlc291cmNlX3Jlc3BvbnNlKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVzcG9uc2VQ cml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXNwb25zZV9uZXcpOgorICAgICAgICAoX1dlYktpdE5l dHdvcmtSZXNwb25zZVByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX3NldF91cmkpOgor ICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3Jl c3BvbnNlX2dldF91cmkpOgorICAgICAgICAqIHdlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2Uu aDogQWRkZWQuCisgICAgICAgICogd2Via2l0L3dlYmtpdHByaXZhdGUuaDoKKyAgICAgICAgKiB3 ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwOgorICAgICAgICAqIHdlYmtpdC93ZWJraXR3ZWJ2aWV3 LmNwcDoKKwogMjAwOC0wNS0wNiAgQ2hyaXN0aWFuIER5d2FuICA8Y2hyaXN0aWFuQHR3b3RvYXN0 cy5kZT4KIAogICAgICAgICBSdWJiZXIgc3RhbXBlZCBieSBBbHAuCkluZGV4OiBXZWJLaXQvZ3Rr L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAkocmV2aXNp b24gMzMwMzIpCisrKyBXZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 R3RrLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDQsNiArNDQsOCBAQAogI2luY2x1ZGUgImtqc19w cm94eS5oIgogI2luY2x1ZGUgIndlYmtpdHdlYnZpZXcuaCIKICNpbmNsdWRlICJ3ZWJraXR3ZWJm cmFtZS5oIgorI2luY2x1ZGUgIndlYmtpdG5ldHdvcmtyZXF1ZXN0LmgiCisjaW5jbHVkZSAid2Vi a2l0bmV0d29ya3Jlc3BvbnNlLmgiCiAjaW5jbHVkZSAid2Via2l0cHJpdmF0ZS5oIgogCiAjaW5j bHVkZSA8SmF2YVNjcmlwdENvcmUvQVBJQ2FzdC5oPgpAQCAtMjAwLDkgKzIwMiwyNyBAQCB2b2lk IEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERpZENhbmNlCiAgICAgbm90SW1wbGVtZW50ZWQo KTsKIH0KIAotdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hXaWxsU2VuZFJlcXVlc3Qo RG9jdW1lbnRMb2FkZXIqLCB1bnNpZ25lZCBsb25nLCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBS ZXNvdXJjZVJlc3BvbnNlJikKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoV2lsbFNl bmRSZXF1ZXN0KERvY3VtZW50TG9hZGVyKiwgdW5zaWduZWQgbG9uZywgUmVzb3VyY2VSZXF1ZXN0 JiByZXNvdXJjZVJlcXVlc3QsIGNvbnN0IFJlc291cmNlUmVzcG9uc2UmIHJlc291cmNlUmVzcG9u c2UpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3 ID0gZ2V0Vmlld0Zyb21GcmFtZShtX2ZyYW1lKTsKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCog cmVxdWVzdCA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X2Zyb21fcmVzb3VyY2VfcmVxdWVz dChyZXNvdXJjZVJlcXVlc3QpOworCisgICAgaWYgKHJlc291cmNlUmVzcG9uc2UuaXNOdWxsKCkp CisgICAgICAgIGdfc2lnbmFsX2VtaXRfYnlfbmFtZSh3ZWJWaWV3LCAicmVxdWVzdC1zdGFydGVk IiwgcmVxdWVzdCk7CisgICAgZWxzZSB7CisgICAgICAgIFJlc291cmNlUmVzcG9uc2UgcmVzcG9u c2VDb3B5ID0gcmVzb3VyY2VSZXNwb25zZTsKKyAgICAgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNl KiByZXNwb25zZTsKKyAgICAKKyAgICAgICAgcmVzcG9uc2UgPSB3ZWJraXRfbmV0d29ya19yZXNw b25zZV9uZXdfZnJvbV9yZXNvdXJjZV9yZXNwb25zZShyZXNwb25zZUNvcHkpOworCisgICAgICAg IGdfc2lnbmFsX2VtaXRfYnlfbmFtZSh3ZWJWaWV3LCAicmVxdWVzdC1yZWRpcmVjdGVkIiwgcmVx dWVzdCwgcmVzcG9uc2UpOworCisgICAgICAgIGdfb2JqZWN0X3VucmVmKHJlc3BvbnNlKTsKKyAg ICB9CisKKyAgICAvLyBmZWVkIGJhY2sgdGhlIGNoYW5nZWQgcmVxdWVzdCB0byB0aGUgb3JpZ2lu YWwgb2JqZWN0CisgICAgcmVzb3VyY2VSZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9n ZXRfcmVzb3VyY2VfcmVxdWVzdChyZXF1ZXN0KTsKKyAgICBnX29iamVjdF91bnJlZihyZXF1ZXN0 KTsKIH0KIAogdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6YXNzaWduSWRlbnRpZmllclRvSW5pdGlh bFJlcXVlc3QodW5zaWduZWQgbG9uZyBpZGVudGlmaWVyLCBEb2N1bWVudExvYWRlciosIGNvbnN0 IFJlc291cmNlUmVxdWVzdCYpCkBAIC0yNjgsNyArMjg4LDggQEAgdm9pZCBGcmFtZUxvYWRlckNs aWVudDo6ZGlzcGF0Y2hEZWNpZGVQbwogICAgICAgICByZXR1cm47CiAKICAgICBXZWJLaXRXZWJW aWV3KiB3ZWJWaWV3ID0gZ2V0Vmlld0Zyb21GcmFtZShtX2ZyYW1lKTsKLSAgICBXZWJLaXROZXR3 b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3KHJlc291cmNl UmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKyAgICBSZXNvdXJjZVJlcXVl c3QgcmVxdWVzdENvcHkgPSByZXNvdXJjZVJlcXVlc3Q7CisgICAgV2ViS2l0TmV0d29ya1JlcXVl c3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld19mcm9tX3Jlc291cmNlX3Jl cXVlc3QocmVxdWVzdENvcHkpOwogICAgIFdlYktpdE5hdmlnYXRpb25SZXNwb25zZSByZXNwb25z ZTsKIAogICAgIGdfc2lnbmFsX2VtaXRfYnlfbmFtZSh3ZWJWaWV3LCAibmF2aWdhdGlvbi1yZXF1 ZXN0ZWQiLCBtX2ZyYW1lLCByZXF1ZXN0LCAmcmVzcG9uc2UpOwpJbmRleDogV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0LmgJ KHJldmlzaW9uIDMzMDMyKQorKysgV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0LmgJKHdvcmtpbmcg Y29weSkKQEAgLTIyLDYgKzIyLDcgQEAKIAogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRkZWZpbmVz Lmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0Lmg+CisjaW5jbHVkZSA8 d2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3 ZWJmcmFtZS5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJzZXR0aW5ncy5oPgogI2luY2x1 ZGUgPHdlYmtpdC93ZWJraXR3ZWJ2aWV3Lmg+CkluZGV4OiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXRkZWZpbmVzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZGVmaW5l cy5oCShyZXZpc2lvbiAzMzAzMikKKysrIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRlZmluZXMu aAkod29ya2luZyBjb3B5KQpAQCAtNDMsNiArNDMsOSBAQCBHX0JFR0lOX0RFQ0xTCiB0eXBlZGVm IHN0cnVjdCBfV2ViS2l0TmV0d29ya1JlcXVlc3QgV2ViS2l0TmV0d29ya1JlcXVlc3Q7CiB0eXBl ZGVmIHN0cnVjdCBfV2ViS2l0TmV0d29ya1JlcXVlc3RDbGFzcyBXZWJLaXROZXR3b3JrUmVxdWVz dENsYXNzOwogCit0eXBlZGVmIHN0cnVjdCBfV2ViS2l0TmV0d29ya1Jlc3BvbnNlIFdlYktpdE5l dHdvcmtSZXNwb25zZTsKK3R5cGVkZWYgc3RydWN0IF9XZWJLaXROZXR3b3JrUmVzcG9uc2VDbGFz cyBXZWJLaXROZXR3b3JrUmVzcG9uc2VDbGFzczsKKwogdHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFdl YkJhY2tGb3J3YXJkTGlzdCBXZWJLaXRXZWJCYWNrRm9yd2FyZExpc3Q7CiB0eXBlZGVmIHN0cnVj dCBfV2ViS2l0V2ViQmFja0ZvcndhcmRMaXN0Q2xhc3MgV2ViS2l0V2ViQmFja0ZvcndhcmRMaXN0 Q2xhc3M7CiAKSW5kZXg6IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNw cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5j cHAJKHJldmlzaW9uIDMzMDMyKQorKysgV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jl cXVlc3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yMSwxMiArMjEsMjggQEAKIAogI2luY2x1ZGUg IndlYmtpdG5ldHdvcmtyZXF1ZXN0LmgiCiAKKyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgor I2luY2x1ZGUgIlJlc291cmNlUmVxdWVzdC5oIgorI2luY2x1ZGUgIkNTdHJpbmcuaCIKKwordXNp bmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKIGV4dGVybiAiQyIgewogCiBHX0RFRklORV9UWVBFKFdl YktpdE5ldHdvcmtSZXF1ZXN0LCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0LCBHX1RZUEVfT0JKRUNU KTsKIAogc3RydWN0IF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUgeworICAgIFJlc291cmNl UmVxdWVzdCByZXF1ZXN0OworCiAgICAgZ2NoYXIqIHVyaTsKKyAgICBXZWJLaXRSZXFDYWNoZVBv bGljeSBjYWNoZV9wb2xpY3k7CisgICAgZ2RvdWJsZSB0aW1lb3V0X2ludGVydmFsOworICAgIGdj aGFyKiBtYWluX2RvY3VtZW50X3VyaTsKKyAgICBnY2hhciogaHR0cF9tZXRob2Q7CisgICAgR0hh c2hUYWJsZSAqaHR0cF9oZWFkZXJzOworICAgIGdib29sZWFuIGFsbG93X2h0dHBfY29va2llczsK KyAgICBnY2hhciAqYm9keTsKKyAgICBnc2l6ZSBib2R5X3NpemU7CiB9OwogCiAjZGVmaW5lIFdF QktJVF9ORVRXT1JLX1JFUVVFU1RfR0VUX1BSSVZBVEUob2JqKSAoR19UWVBFX0lOU1RBTkNFX0dF VF9QUklWQVRFKChvYmopLCBXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIFdlYktpdE5ldHdv cmtSZXF1ZXN0UHJpdmF0ZSkpCkBAIC0zNyw2ICs1MywxMSBAQCBzdGF0aWMgdm9pZCB3ZWJraXRf bmV0d29ya19yZXF1ZXN0X2ZpbmFsCiAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBw cml2ID0gcmVxdWVzdC0+cHJpdjsKIAogICAgIGdfZnJlZShwcml2LT51cmkpOworICAgIGdfZnJl ZShwcml2LT5tYWluX2RvY3VtZW50X3VyaSk7CisgICAgZ19mcmVlKHByaXYtPmh0dHBfbWV0aG9k KTsKKyAgICBnX2hhc2hfdGFibGVfZGVzdHJveShwcml2LT5odHRwX2hlYWRlcnMpOworICAgIGdf ZnJlZShwcml2LT5ib2R5KTsKKyAgICBwcml2LT5ib2R5X3NpemUgPSAwOwogCiAgICAgR19PQkpF Q1RfQ0xBU1Mod2Via2l0X25ldHdvcmtfcmVxdWVzdF9wYXJlbnRfY2xhc3MpLT5maW5hbGl6ZShv YmplY3QpOwogfQpAQCAtNTQsNiArNzUsNjUgQEAgc3RhdGljIHZvaWQgd2Via2l0X25ldHdvcmtf cmVxdWVzdF9pbml0KAogICAgIHJlcXVlc3QtPnByaXYgPSBwcml2OwogfQogCitzdGF0aWMgV2Vi S2l0UmVxQ2FjaGVQb2xpY3kgY2FjaGVfcG9saWN5X2Zyb21fcmVzb3VyY2VfcmVxdWVzdChjb25z dCBSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCkKK3sKKyAgICBSZXNvdXJjZVJlcXVl c3RDYWNoZVBvbGljeSBjYWNoZV9wb2xpY3kgPSByZXNvdXJjZVJlcXVlc3QuY2FjaGVQb2xpY3ko KTsKKyAgICAKKyAgICBzd2l0Y2goY2FjaGVfcG9saWN5KQorICAgICAgICB7CisgICAgICAgIGNh c2UgVXNlUHJvdG9jb2xDYWNoZVBvbGljeToKKyAgICAgICAgICAgIHJldHVybiBXRUJLSVRfUkVR X0NBQ0hFX1BPTElDWV9QUk9UT0NPTDsKKyAgICAgICAgY2FzZSBSZWxvYWRJZ25vcmluZ0NhY2hl RGF0YToKKyAgICAgICAgICAgIHJldHVybiBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9SRUxPQURf SUdOT1JJTkdfQ0FDSEU7CisgICAgICAgIGNhc2UgUmV0dXJuQ2FjaGVEYXRhRWxzZUxvYWQ6Cisg ICAgICAgICAgICByZXR1cm4gV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfQUxMT1dfQ0FDSEU7Cisg ICAgICAgIGNhc2UgUmV0dXJuQ2FjaGVEYXRhRG9udExvYWQ6CisgICAgICAgICAgICByZXR1cm4g V0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfQ0FDSEVfT05MWTsKKyAgICAgICAgZGVmYXVsdDoKKyAg ICAgICAgICAgIHJldHVybiBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9OT05FOworICAgICAgICB9 Cit9CisKKy8vIGZvciBpbnRlcm5hbCB1c2Ugb25seQorV2ViS2l0TmV0d29ya1JlcXVlc3QqIHdl YmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X2Zyb21fcmVzb3VyY2VfcmVxdWVzdChSZXNvdXJjZVJl cXVlc3QmIHJlc291cmNlUmVxdWVzdCkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVx dWVzdCA9IFdFQktJVF9ORVRXT1JLX1JFUVVFU1QoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX05F VFdPUktfUkVRVUVTVCwgTlVMTCkpOworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSog cHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBwcml2LT5yZXF1ZXN0ID0gcmVzb3VyY2VSZXF1 ZXN0OworCisgICAgcHJpdi0+Y2FjaGVfcG9saWN5ID0gY2FjaGVfcG9saWN5X2Zyb21fcmVzb3Vy Y2VfcmVxdWVzdChyZXNvdXJjZVJlcXVlc3QpOworICAgIHByaXYtPnRpbWVvdXRfaW50ZXJ2YWwg PSByZXNvdXJjZVJlcXVlc3QudGltZW91dEludGVydmFsKCk7CisKKyAgICBwcml2LT5odHRwX2hl YWRlcnMgPSBnX2hhc2hfdGFibGVfbmV3X2Z1bGwoZ19zdHJfaGFzaCwgZ19zdHJfZXF1YWwsIGdf ZnJlZSwgZ19mcmVlKTsKKyAgICBIVFRQSGVhZGVyTWFwIGhlYWRlcnMgPSByZXNvdXJjZVJlcXVl c3QuaHR0cEhlYWRlckZpZWxkcygpOworICAgIGlmICghaGVhZGVycy5pc0VtcHR5KCkpIHsKKyAg ICAgICAgSFRUUEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgZW5kID0gaGVhZGVycy5lbmQoKTsK KyAgICAgICAgZm9yIChIVFRQSGVhZGVyTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IGhlYWRlcnMu YmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KQorICAgICAgICAgICAgZ19oYXNoX3RhYmxlX2luc2Vy dChwcml2LT5odHRwX2hlYWRlcnMsIChncG9pbnRlcilnX3N0cmR1cChpdC0+Zmlyc3QudXRmOCgp LmRhdGEoKSksIChncG9pbnRlcilnX3N0cmR1cChpdC0+c2Vjb25kLnV0ZjgoKS5kYXRhKCkpKTsK KyAgICB9CisKKyAgICBwcml2LT5hbGxvd19odHRwX2Nvb2tpZXMgPSByZXNvdXJjZVJlcXVlc3Qu YWxsb3dIVFRQQ29va2llcygpOworCisgICAgcmV0dXJuIHJlcXVlc3Q7Cit9CisKKy8vIGZvciBp bnRlcm5hbCB1c2Ugb25seQorUmVzb3VyY2VSZXF1ZXN0IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf Z2V0X3Jlc291cmNlX3JlcXVlc3QoY29uc3QgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3Qp Cit7CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJp djsKKworICAgIHJldHVybiBwcml2LT5yZXF1ZXN0OworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfbmV3OgorICogQHVyaTogYW4gYWxyZWFkeSBlbmNvZGVkIFVSSQorICoKKyAq IENyZWF0ZXMgYSBuZXcgI1dlYktpdE5ldHdvcmtSZXF1ZXN0IGluaXRpYWxpemVkIHdpdGggYW4g VVJJLgorICoKKyAqIFJldHVybnM6IGEgbmV3ICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICovCiBX ZWJLaXROZXR3b3JrUmVxdWVzdCogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXcoY29uc3QgZ2No YXIqIHVyaSkKIHsKICAgICBnX3JldHVybl92YWxfaWZfZmFpbCh1cmksIE5VTEwpOwpAQCAtNjYs NiArMTQ2LDEzIEBAIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiB3ZWJraXRfbmV0d29ya19yZXEKICAg ICByZXR1cm4gcmVxdWVzdDsKIH0KIAorLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3Nl dF91cmk6CisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEB1cmk6IGFu IGFscmVhZHkgZW5jb2RlZCBVUkkKKyAqCisgKiBTZXRzIHRoZSBVUkkgaGVsZCBhbmQgdXNlZCBi eSB0aGUgZ2l2ZW4gcmVxdWVzdC4KKyAqLwogdm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3Nl dF91cmkoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiB1cmkpCiB7 CiAgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3Qp KTsKQEAgLTc1LDE0ICsxNjIsNTg5IEBAIHZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRf dXJpKFdlYksKIAogICAgIGdfZnJlZShwcml2LT51cmkpOwogICAgIHByaXYtPnVyaSA9IGdfc3Ry ZHVwKHVyaSk7CisKKyAgICAvKiAKKyAgICAgKiBmZWVkaW5nIGJhY2sgdG8gdGhlIFJlc291cmNl UmVxdWVzdCBvYmplY3QsIHdoaWNoIGlzIHRoZSBvbmUgYWN0dWFsbHkgdXNlZAorICAgICAqIGlu c2lkZSBXZWJDb3JlCisgICAgICovCisgICAgcHJpdi0+cmVxdWVzdC5zZXRVUkwoS1VSTChTdHJp bmc6OmZyb21VVEY4KHVyaSkpKTsKIH0KIAorLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X2dldF91cmk6CisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqCisgKiBH ZXRzIHRoZSBVUkkgaGVsZCBhbmQgdXNlZCBieSB0aGUgZ2l2ZW4gcmVxdWVzdC4KKyAqCisgKiBS ZXR1cm5zOiB0aGUgVVJJIGhlbGQgYW5kIHVzZWQgYnkgdGhlIGdpdmVuIHJlcXVlc3QKKyAqLwog Y29uc3QgZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShXZWJLaXROZXR3b3Jr UmVxdWVzdCogcmVxdWVzdCkKIHsKICAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNf TkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKIAogICAgIFdlYktpdE5ldHdvcmtSZXF1 ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisgICAgCisgICAgaWYgKHByaXYtPnVy aSkKKyAgICAgICAgcmV0dXJuIHByaXYtPnVyaTsKKworICAgIHByaXYtPnVyaSA9IGdfc3RyZHVw KHByaXYtPnJlcXVlc3QudXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CiAgICAgcmV0dXJu IHByaXYtPnVyaTsKIH0KIAorLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9jYWNo ZV9wb2xpY3k6CisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEBjYWNo ZV9wb2xpY3k6IGEgI1dlYktpdFJlcUNhY2hlUG9saWN5CisgKgorICogRGVmaW5lcyB0aGUgcG9s aWN5IFdlYktpdCBzaG91bGQgdXNlIHdoZW4gaGFuZGxpbmcgdGhlIHJlcXVlc3QsCisgKiBzdWNo IGFzIGlmIGl0IGlzIGFsbG93ZWQgdG8gdXNlIHRoZSBsb2NhbCBjYWNoZSwgaWYgdGhlIEhUVFAK KyAqIGNhY2hpbmcgcnVsZXMgc2hvdWxkIGJlIHVzZWQsIG9yIGlmIHdlIGFyZSBmb3JjaW5nIGEg cmVsb2FkLgorICovCit2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2NhY2hlX3BvbGlj eShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgV2ViS2l0UmVxQ2FjaGVQb2xp Y3kgY2FjaGVfcG9saWN5KQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdP UktfUkVRVUVTVChyZXF1ZXN0KSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUq IHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgcHJpdi0+Y2FjaGVfcG9saWN5ID0gY2FjaGVf cG9saWN5OworCisgICAgUmVzb3VyY2VSZXF1ZXN0Q2FjaGVQb2xpY3kgZmVlZGJhY2s7CisgICAg c3dpdGNoKGNhY2hlX3BvbGljeSkKKyAgICAgICAgeworICAgICAgICBjYXNlIFdFQktJVF9SRVFf Q0FDSEVfUE9MSUNZX1BST1RPQ09MOgorICAgICAgICAgICAgZmVlZGJhY2sgPSBVc2VQcm90b2Nv bENhY2hlUG9saWN5OworICAgICAgICBjYXNlIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX1JFTE9B RF9JR05PUklOR19DQUNIRToKKyAgICAgICAgICAgIGZlZWRiYWNrID0gUmVsb2FkSWdub3JpbmdD YWNoZURhdGE7CisgICAgICAgIGNhc2UgV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfQUxMT1dfQ0FD SEU6CisgICAgICAgICAgICBmZWVkYmFjayA9IFJldHVybkNhY2hlRGF0YUVsc2VMb2FkOworICAg ICAgICBjYXNlIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX0NBQ0hFX09OTFk6CisgICAgICAgICAg ICBmZWVkYmFjayA9IFJldHVybkNhY2hlRGF0YURvbnRMb2FkOworICAgICAgICBkZWZhdWx0Ogor ICAgICAgICAgICAgZmVlZGJhY2sgPSBVc2VQcm90b2NvbENhY2hlUG9saWN5OworICAgICAgICB9 CisgICAgcHJpdi0+cmVxdWVzdC5zZXRDYWNoZVBvbGljeShmZWVkYmFjayk7CisKK30KKworLyoq CisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9jYWNoZV9wb2xpY3k6CisgKiBAcmVxdWVz dDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqCisgKiBPYnRhaW5zIHRoZSBwb2xpY3kgV2Vi S2l0IHdvdWxkIHVzZSB3aGVuIGhhbmRsaW5nIHRoZSByZXF1ZXN0LCBzdWNoCisgKiBhcyBpZiBp dCBpcyBhbGxvd2VkIHRvIHVzZSB0aGUgbG9jYWwgY2FjaGUsIGlmIHRoZSBIVFRQIGNhY2hpbmcK KyAqIHJ1bGVzIHNob3VsZCBiZSB1c2VkLCBvciBpZiB3ZSBhcmUgZm9yY2luZyBhIHJlbG9hZC4K KyAqCisgKiBSZXR1cm5zOiBhICNXZWJLaXRSZXFDYWNoZVBvbGljeQorICovCitXZWJLaXRSZXFD YWNoZVBvbGljeSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9jYWNoZV9wb2xpY3koV2ViS2l0 TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VC S0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lf Tk9ORSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0 LT5wcml2OworCisgICAgcmV0dXJuIHByaXYtPmNhY2hlX3BvbGljeTsKK30KKworLyoqCisgKiB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF90aW1lb3V0X2ludGVydmFsOgorICogQHJlcXVlc3Q6 IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CisgKiBAdGltZW91dF9pbnRlcnZhbDogYSAjZ2RvdWJs ZQorICoKKyAqIFNldHMgaG93IG1hbnkgc2Vjb25kcyBXZWJLaXQgd291bGQgd2FpdCBmb3IgdGhl IHNlcnZlciB3aGVuCisgKiBoYW5kbGluZyB0aGUgZ2l2ZW4gcmVxdWVzdC4KKyAqLwordm9pZCB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF90aW1lb3V0X2ludGVydmFsKFdlYktpdE5ldHdvcmtS ZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnZG91YmxlIHRpbWVvdXRfaW50ZXJ2YWwpCit7CisgICAg Z19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpKTsKKwor ICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisK KyAgICBwcml2LT50aW1lb3V0X2ludGVydmFsID0gdGltZW91dF9pbnRlcnZhbDsKKworICAgIHBy aXYtPnJlcXVlc3Quc2V0VGltZW91dEludGVydmFsKHRpbWVvdXRfaW50ZXJ2YWwpOworfQorCisv KioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3RpbWVvdXRfaW50ZXJ2YWw6CisgKiBA cmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqCisgKiBHZXRzIGhvdyBtYW55IHNl Y29uZHMgV2ViS2l0IHdvdWxkIHdhaXQgZm9yIHRoZSBzZXJ2ZXIgd2hlbgorICogaGFuZGxpbmcg dGhlIGdpdmVuIHJlcXVlc3QuCisgKgorICogUmV0dXJuczogYSAjZ2RvdWJsZQorICovCitnZG91 YmxlIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3RpbWVvdXRfaW50ZXJ2YWwoV2ViS2l0TmV0 d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lU X0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgMC4wKTsKKworICAgIFdlYktpdE5ldHdvcmtS ZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICByZXR1cm4gcHJpdi0+ dGltZW91dF9pbnRlcnZhbDsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3Nl dF9tYWluX2RvY3VtZW50X3VyaQorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0 CisgKiBAbWFpbl9kb2N1bWVudF91cmk6IHRoZSBVUkkgb2YgdGhlIG1haW4gZG9jdW1lbnQKKyAq CisgKiBTZXRzIHRoZSBtYWluIGRvY3VtZW50IFVSSS4KKyAqCisgKiBUaGUgbWFpbiBkb2N1bWVu dCBpcyB0aGUgZG9jdW1lbnQgdGhhdCBpcyBiZWluZyByZW5kZXJlZDsgb3RoZXIKKyAqIGRvY3Vt ZW50cywgYmUgdGhlbSBIVE1MIHBhZ2VzLCBqYXZhc2NyaXB0IG9yIGNzcyBmaWxlcywgaW1hZ2Vz LCBhbmQKKyAqIHNvIG9uIG1heSBiZSBuZWNlc3NhcnksIGFuZCB0aGUgcmVxdWVzdHMgdGhhdCBm ZXRjaCB0aG9zZSBzaGFsbAorICogaGF2ZSB0aGlzIFVSSSBzZXQgdG8gdGhlIGRvY3VtZW50IHdo aWNoIHJlcXVpcmVzIHRoZW0uCisgKi8KK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRf bWFpbl9kb2N1bWVudF91cmkoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdj aGFyKiBtYWluX2RvY3VtZW50X3VyaSkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9J U19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwobWFpbl9k b2N1bWVudF91cmkpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0g cmVxdWVzdC0+cHJpdjsKKworICAgIGdfZnJlZShwcml2LT5tYWluX2RvY3VtZW50X3VyaSk7Cisg ICAgcHJpdi0+bWFpbl9kb2N1bWVudF91cmkgPSBnX3N0cmR1cChtYWluX2RvY3VtZW50X3VyaSk7 CisKKyAgICBwcml2LT5yZXF1ZXN0LnNldE1haW5Eb2N1bWVudFVSTChLVVJMKFN0cmluZzo6ZnJv bVVURjgobWFpbl9kb2N1bWVudF91cmkpKSk7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtf cmVxdWVzdF9nZXRfbWFpbl9kb2N1bWVudF91cmkKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3 b3JrUmVxdWVzdAorICoKKyAqIE9idGFpbnMgdGhlIG1haW4gZG9jdW1lbnQgVVJJLgorICoKKyAq IFRoZSBtYWluIGRvY3VtZW50IGlzIHRoZSBkb2N1bWVudCB0aGF0IGlzIGJlaW5nIHJlbmRlcmVk OyBvdGhlcgorICogZG9jdW1lbnRzLCBiZSB0aGVtIEhUTUwgcGFnZXMsIGphdmFzY3JpcHQgb3Ig Y3NzIGZpbGVzLCBpbWFnZXMsIGFuZAorICogc28gb24gbWF5IGJlIG5lY2Vzc2FyeSwgYW5kIHRo ZSByZXF1ZXN0cyB0aGF0IGZldGNoIHRob3NlIHNoYWxsCisgKiBoYXZlIHRoaXMgVVJJIHNldCB0 byB0aGUgZG9jdW1lbnQgd2hpY2ggcmVxdWlyZXMgdGhlbS4KKyAqCisgKiBSZXR1cm5zOiBhIHN0 cmluZyB3aXRoIHRoZSBtYWluIGRvY3VtZW50IFVSSQorICovCitjb25zdCBnY2hhciogd2Via2l0 X25ldHdvcmtfcmVxdWVzdF9nZXRfbWFpbl9kb2N1bWVudF91cmkoV2ViS2l0TmV0d29ya1JlcXVl c3QqIHJlcXVlc3QpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdP UktfUkVRVUVTVChyZXF1ZXN0KSwgTlVMTCk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFBy aXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgaWYgKHByaXYtPm1haW5fZG9jdW1l bnRfdXJpKQorICAgICAgICByZXR1cm4gcHJpdi0+bWFpbl9kb2N1bWVudF91cmk7CisKKyAgICBw cml2LT5tYWluX2RvY3VtZW50X3VyaSA9IGdfc3RyZHVwKHByaXYtPnJlcXVlc3QubWFpbkRvY3Vt ZW50VVJMKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisgICAgcmV0dXJuIHByaXYtPm1haW5f ZG9jdW1lbnRfdXJpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0 dHBfbWV0aG9kCisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEBodHRw X21ldGhvZDogdGhlIEhUVFAgbWV0aG9kCisgKgorICogRGVmaW5lcyB3aGF0IG1ldGhvZCwgc3Vj aCBhcyBHRVQsIFBPU1QsIEhFQUQsIGFuZCBzbyBvbiwgd291bGQgYmUKKyAqIHVzZWQgYnkgV2Vi S2l0IHdoZW4gdGFsa2luZyB0byB0aGUgd2Vic2VydmVyIGR1cmluZyB0aGlzIHJlcXVlc3QuCisg Ki8KK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9tZXRob2QoV2ViS2l0TmV0 d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX21ldGhvZCkKK3sKKyAgICBn X3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworICAg IGdfcmV0dXJuX2lmX2ZhaWwoaHR0cF9tZXRob2QpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVl c3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIGdfZnJlZShwcml2LT5odHRw X21ldGhvZCk7CisgICAgcHJpdi0+aHR0cF9tZXRob2QgPSBnX3N0cmR1cChodHRwX21ldGhvZCk7 CisKKyAgICBwcml2LT5yZXF1ZXN0LnNldEhUVFBNZXRob2QoU3RyaW5nOjpmcm9tVVRGOChodHRw X21ldGhvZCkpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBf bWV0aG9kCisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqCisgKiBPYnRh aW5zIHdoYXQgbWV0aG9kLCBzdWNoIGFzIEdFVCwgUE9TVCwgSEVBRCwgYW5kIHNvIG9uLCB3b3Vs ZCBiZQorICogdXNlZCBieSBXZWJLaXQgd2hlbiB0YWxraW5nIHRvIHRoZSB3ZWJzZXJ2ZXIgZHVy aW5nIHRoaXMgcmVxdWVzdC4KKyAqCisgKiBSZXR1cm5zOiBhIHN0cmluZyB3aXRoIHRoZSBuYW1l IG9mIHRoZSBtZXRob2QKKyAqLworY29uc3QgZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf Z2V0X2h0dHBfbWV0aG9kKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGdf cmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIE5V TEwpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+ cHJpdjsKKworICAgIGlmIChwcml2LT5odHRwX21ldGhvZCkKKyAgICAgICAgcmV0dXJuIHByaXYt Pmh0dHBfbWV0aG9kOworCisgICAgcHJpdi0+aHR0cF9tZXRob2QgPSBnX3N0cmR1cChwcml2LT5y ZXF1ZXN0Lmh0dHBNZXRob2QoKS51dGY4KCkuZGF0YSgpKTsKKyAgICByZXR1cm4gcHJpdi0+aHR0 cF9tZXRob2Q7Cit9CisKK3N0YXRpYyB2b2lkIGNvcHlfaGVhZGVyKGNvbnN0IGdjaGFyKiBrZXks IGNvbnN0IGdjaGFyKiB2YWx1ZSwgZ3BvaW50ZXIgZGF0YSkKK3sKKyAgICBXZWJLaXROZXR3b3Jr UmVxdWVzdCogcmVxdWVzdCA9IChXZWJLaXROZXR3b3JrUmVxdWVzdCopZGF0YTsKKworICAgIHdl YmtpdF9uZXR3b3JrX3JlcXVlc3RfYWRkX2h0dHBfaGVhZGVyKHJlcXVlc3QsIGtleSwgdmFsdWUp OworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfYWRkX2h0dHBfaGVhZGVycwor ICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CisgKiBAaHR0cF9oZWFkZXJzOiBh ICNHSGFzaFRhYmxlIHdpdGggaGVhZGVyL3ZhbHVlIHBhaXJzLCBhcyBzdHJpbmdzCisgKgorICog QWRkcyB0aGUgaGVhZGVycyBjb250YWluZWQgYnkgdGhlIGdpdmVuIGhhc2ggdGFibGUgdG8gdGhl CisgKiByZXF1ZXN0LiBTZWUgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9hZGRfaHR0cF9oZWFkZXIo KS4KKyAqLwordm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2FkZF9odHRwX2hlYWRlcnMoV2Vi S2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IEdIYXNoVGFibGUqIGh0dHBfaGVhZGVy cykKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVx dWVzdCkpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwoaHR0cF9oZWFkZXJzKTsKKworICAgIGdfaGFz aF90YWJsZV9mb3JlYWNoKChHSGFzaFRhYmxlKilodHRwX2hlYWRlcnMsIChHSEZ1bmMpY29weV9o ZWFkZXIsIHJlcXVlc3QpOworfQorCitjb25zdCBHSGFzaFRhYmxlKiB3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X2dldF9odHRwX2hlYWRlcnMoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7 CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1 ZXN0KSwgTlVMTCk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSBy ZXF1ZXN0LT5wcml2OworICAgIHJldHVybiBwcml2LT5odHRwX2hlYWRlcnM7Cit9CisKKy8qKgor ICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9hZGRfaHR0cF9oZWFkZXIKKyAqIEByZXF1ZXN0OiBh ICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICogQGh0dHBfaGVhZGVyOiBhIHN0cmluZyB3aXRoIHRo ZSBuYW1lIG9mIHRoZSBoZWFkZXIKKyAqIEB2YWx1ZTogYSBzdHJpbmcgd2l0aCB0aGUgdmFsdWUg b2YgdGhlIGhlYWRlcgorICoKKyAqIEFkZHMgdGhlIEhUVFAgaGVhZGVyIHRvIHRoZSByZXF1ZXN0 LiBIZWFkZXJzIHdoaWNoIGFscmVhZHkgZXhpc3QgaW4KKyAqIHRoZSByZXF1ZXN0IHdpbGwgaGF2 ZSB0aGVpciB2YWx1ZSBhcHBlbmRlZCB0bywgd2l0aCBhIHNlcGFyYXRlZAorICogY29tbWEuCisg KgorICogRm9yIGluc3RhbmNlOiBpZiB0aGUgcmVxdWVzdCBhbHJlYWR5IGhhcyBhIFgtTWlzYyBo ZWFkZXIgd2l0aCBhCisgKiB2YWx1ZSBvZiAiZ28sIHdlYmtpdCEiLCBhbmQgd2UgYWRkIHRoZSBz YW1lIFgtTWlzYyBoZWFkZXIKKyAqIGNvbnRhaW5pbmcgImdvISIgd2Ugd2lsbCBlbmQgdXAgaGF2 aW5nIGEgc2luZ2xlIFgtTWlzYyBoZWFkZXIgd2l0aAorICogYSB2YWx1ZSBvZiAiZ28sIHdlYmtp dCEsZ28hIi4KKyAqLwordm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2FkZF9odHRwX2hlYWRl cihXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfaGVhZGVy LCBjb25zdCBnY2hhciogdmFsdWUpCit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNf TkVUV09SS19SRVFVRVNUKHJlcXVlc3QpKTsKKyAgICBnX3JldHVybl9pZl9mYWlsKGh0dHBfaGVh ZGVyKTsKKyAgICBnX3JldHVybl9pZl9mYWlsKHZhbHVlKTsKKworICAgIFdlYktpdE5ldHdvcmtS ZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisgICAgR0hhc2hUYWJsZSogaGFz aF90YWJsZSA9IHByaXYtPmh0dHBfaGVhZGVyczsKKyAgICBncG9pbnRlciBrZXlfbG9va3VwOwor CisgICAga2V5X2xvb2t1cCA9IGdfaGFzaF90YWJsZV9sb29rdXAoaGFzaF90YWJsZSwgaHR0cF9o ZWFkZXIpOworICAgIGlmICgha2V5X2xvb2t1cCkKKyAgICAgICAgZ19oYXNoX3RhYmxlX2luc2Vy dChoYXNoX3RhYmxlLCAoZ3BvaW50ZXIpZ19zdHJkdXAoaHR0cF9oZWFkZXIpLCAoZ3BvaW50ZXIp Z19zdHJkdXAodmFsdWUpKTsKKyAgICBlbHNlIHsKKyAgICAgICAgZ2NoYXIqIG5ld192YWx1ZSA9 IGdfc3RyZHVwX3ByaW50ZigiJXMsJXMiLCAoZ2NoYXIqKWtleV9sb29rdXAsIHZhbHVlKTsKKyAg ICAgICAgZ19oYXNoX3RhYmxlX3JlcGxhY2UoaGFzaF90YWJsZSwgKGdwb2ludGVyKWdfc3RyZHVw KGh0dHBfaGVhZGVyKSwgKGdwb2ludGVyKWdfc3RyZHVwKG5ld192YWx1ZSkpOworICAgICAgICBn X2ZyZWUobmV3X3ZhbHVlKTsKKyAgICB9CisKKyAgICBwcml2LT5yZXF1ZXN0LmFkZEhUVFBIZWFk ZXJGaWVsZChTdHJpbmc6OmZyb21VVEY4KGh0dHBfaGVhZGVyKSwgU3RyaW5nOjpmcm9tVVRGOCh2 YWx1ZSkpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfaGVh ZGVyCisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEBodHRwX2hlYWRl cjogYSBzdHJpbmcgd2l0aCB0aGUgbmFtZSBvZiB0aGUgaGVhZGVyCisgKiBAdmFsdWU6IGEgc3Ry aW5nIHdpdGggdGhlIHZhbHVlIG9mIHRoZSBoZWFkZXIKKyAqCisgKiBTZXRzIHRoZSBoZWFkZXIg dG8gY29udGFpbiB0aGUgZ2l2ZW4gdmFsdWUsIGluIHRoaXMgcmVxdWVzdC4gSWYgdGhlCisgKiBo ZWFkZXIgYWxyZWFkeSBleGlzdHMgaW4gdGhlIHJlcXVlc3QgdGhlIHZhbHVlIGlzIHJlcGxhY2Vk LgorICovCit2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfaGVhZGVyKFdlYktp dE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciogaHR0cF9oZWFkZXIsIGNvbnN0 IGdjaGFyKiB2YWx1ZSkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JL X1JFUVVFU1QocmVxdWVzdCkpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwoaHR0cF9oZWFkZXIpOwor ICAgIGdfcmV0dXJuX2lmX2ZhaWwodmFsdWUpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQ cml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKyAgICBHSGFzaFRhYmxlKiBoZWFkZXJzID0g cHJpdi0+aHR0cF9oZWFkZXJzOworCisgICAgZ19oYXNoX3RhYmxlX3JlcGxhY2UoaGVhZGVycywg Z19zdHJkdXAoaHR0cF9oZWFkZXIpLCBnX3N0cmR1cCh2YWx1ZSkpOworICAgIAorICAgIHByaXYt PnJlcXVlc3Quc2V0SFRUUEhlYWRlckZpZWxkKFN0cmluZzo6ZnJvbVVURjgoaHR0cF9oZWFkZXIp LCBTdHJpbmc6OmZyb21VVEY4KHZhbHVlKSk7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtf cmVxdWVzdF9nZXRfaHR0cF9oZWFkZXIKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVx dWVzdAorICogQGh0dHBfaGVhZGVyOiB0aGUgbmFtZSBvZiB0aGUgaGVhZGVyIHdlIHdhbnQgdG8g b2J0YWluIHRoZSB2YWx1ZSBmb3IKKyAqCisgKiBHZXRzIHRoZSB2YWx1ZSBvZiB0aGUgdGhlIGhl YWRlciBpbiB0aGUgZ2l2ZW4gcmVxdWVzdC4gSWYgdGhlCisgKiBoZWFkZXIgZG9lcyBub3QgZXhp c3QgaW4gdGhlIHJlcXVlc3QgJU5VTEwgaXMgcmV0dXJuZWQuCisgKgorICogUmV0dXJuczogYSBz dHJpbmcgd2l0aCB0aGUgdmFsdWUgZm9yIHRoZSBoZWFkZXIsIG9yIE5VTEwgaWYgdGhhdAorICog aGVhZGVyIGlzIG5vdCBzZXQgZm9yIHRoZSByZXF1ZXN0CisgKi8KK2NvbnN0IGdjaGFyKiB3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRlcihXZWJLaXROZXR3b3JrUmVxdWVzdCog cmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfaGVhZGVyKQoreworICAgIGdfcmV0dXJuX3ZhbF9p Zl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOworICAgIGdf cmV0dXJuX3ZhbF9pZl9mYWlsKGh0dHBfaGVhZGVyLCBOVUxMKTsKKworICAgIFdlYktpdE5ldHdv cmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisgICAgR0hhc2hUYWJsZSog aGVhZGVycyA9IHByaXYtPmh0dHBfaGVhZGVyczsKKworICAgIHJldHVybiAoY29uc3QgZ2NoYXIq KWdfaGFzaF90YWJsZV9sb29rdXAoaGVhZGVycywgKGdjb25zdHBvaW50ZXIpaHR0cF9oZWFkZXIp OworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2NvbnRlbnRfdHlwZQor ICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CisgKiBAaHR0cF9jb250ZW50X3R5 cGU6IHRoZSBjb250ZW50IHR5cGUgZm9yIHRoZSBib2R5IG9mIHRoZSByZXF1ZXN0CisgKgorICog SWYgdGhpcyByZXF1ZXN0IGhhcyBhIGJvZHksIGkuZS4gaXQncyBhIFBPU1QgcmVxdWVzdCB3aXRo IHNvbWUgZGF0YQorICogYmVpbmcgc2VudCB0byB0aGUgc2VydmVyLCBvciBhIGZpbGUgdXBsb2Fk LCB0aGlzIGZ1bmN0aW9uIGRlZmluZXMKKyAqIHRoZSBjb250ZW50IHR5cGUgb2YgdGhlIGRhdGEg YmVpbmcgc2VudC4KKyAqCisgKiBUaGlzIGlzIHJlYWxseSBhIHNob3J0Y3V0IGZvciBjYWxsaW5n CisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX2hlYWRlcigpIHdpdGggIkNvbnRl bnQtVHlwZSIgYXMgdGhlCisgKiBoZWFkZXIgbmFtZS4KKyAqLwordm9pZCB3ZWJraXRfbmV0d29y a19yZXF1ZXN0X3NldF9odHRwX2NvbnRlbnRfdHlwZShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVx dWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfY29udGVudF90eXBlKQoreworICAgIGdfcmV0dXJuX2lm X2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CisgICAgZ19yZXR1cm5f aWZfZmFpbChodHRwX2NvbnRlbnRfdHlwZSk7CisKKyAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X3NldF9odHRwX2hlYWRlcihyZXF1ZXN0LCAiQ29udGVudC1UeXBlIiwgaHR0cF9jb250ZW50X3R5 cGUpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfY29udGVu dF90eXBlCisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqCisgKiBHZXRz IHRoZSBjb250ZW50IHR5cGUgb2YgdGhlIGJvZHkgdGhhdCBpcyBiZWluZyBzZW50IGluIHRoaXMg cmVxdWVzdC4KKyAqCisgKiBUaGlzIGlzIHJlYWxseSBhIHNob3J0Y3V0IGZvciBjYWxsaW5nCisg KiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRlcigpIHdpdGggIkNvbnRlbnQt VHlwZSIgYXMgdGhlCisgKiBoZWFkZXIgbmFtZS4KKyAqCisgKiBSZXR1cm5zOiBhIHN0cmluZyB3 aXRoIHRoZSB2YWx1ZSBvZiB0aGUgQ29udGVudC1UeXBlIGhlYWRlciBvcgorICogJU5VTEwgaWYg dGhlIHJlcXVlc3QgZG9lcyBub3QgaGF2ZSB0aGF0IGhlYWRlciBzZXQKKyAqLworY29uc3QgZ2No YXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfY29udGVudF90eXBlKFdlYktpdE5l dHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJ VF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOworCisgICAgcmV0dXJuIHdlYmtp dF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfaGVhZGVyKHJlcXVlc3QsICJDb250ZW50LVR5cGUi KTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX3JlZmVyZXIK KyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICogQGh0dHBfcmVmZXJlcjog dGhlIFVSSSB0aGF0IHJlZmVyZWQgdXMgdG8gdGhlIHJlc291cmNlIHRoZSBjdXJyZW50CisgKiBy ZXF1ZXN0IGlzIG9idGFpbmluZworICoKKyAqIFRoaXMgc2V0cyB0aGUgUmVmZXJlciBoZWFkZXIg b2YgdGhlIHJlcXVlc3QuCisgKgorICogVGhpcyBpcyByZWFsbHkgYSBzaG9ydGN1dCBmb3IgY2Fs bGluZworICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9oZWFkZXIoKSB3aXRoICJS ZWZlcmVyIiBhcyB0aGUKKyAqIGhlYWRlciBuYW1lLgorICovCit2b2lkIHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3Rfc2V0X2h0dHBfcmVmZXJlcihXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwg Y29uc3QgZ2NoYXIqIGh0dHBfcmVmZXJlcikKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJ VF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwoaHR0 cF9yZWZlcmVyKTsKKworICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfaGVhZGVy KHJlcXVlc3QsICJSZWZlcmVyIiwgaHR0cF9yZWZlcmVyKTsKK30KKworLyoqCisgKiB3ZWJraXRf bmV0d29ya19yZXF1ZXN0X2dldF9odHRwX3JlZmVyZXIKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXRO ZXR3b3JrUmVxdWVzdAorICoKKyAqIEdldHMgdGhlIHBhZ2UgdGhhdCByZWZlcmVkIHVzIHRvIHRo ZSByZXNvdXJjZSB0aGlzIHJlcXVlc3QgaXMKKyAqIHRyeWluZyB0byBvYnRhaW4uCisgKgorICog VGhpcyBpcyByZWFsbHkgYSBzaG9ydGN1dCBmb3IgY2FsbGluZworICogd2Via2l0X25ldHdvcmtf cmVxdWVzdF9nZXRfaHR0cF9oZWFkZXIoKSB3aXRoICJSZWZlcmVyIiBhcyB0aGUKKyAqIGhlYWRl ciBuYW1lLgorICoKKyAqIFJldHVybnM6IGEgc3RyaW5nIHdpdGggdGhlIHZhbHVlIG9mIHRoZSBS ZWZlcmVyIGhlYWRlciBvciAlTlVMTCBpZgorICogdGhlIHJlcXVlc3QgZG9lcyBub3QgaGF2ZSB0 aGF0IGhlYWRlciBzZXQKKyAqLworY29uc3QgZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf Z2V0X2h0dHBfcmVmZXJlcihXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBn X3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBO VUxMKTsKKworICAgIHJldHVybiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRl cihyZXF1ZXN0LCAiUmVmZXJlciIpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVl c3Rfc2V0X2h0dHBfdXNlcl9hZ2VudAorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1 ZXN0CisgKiBAaHR0cF91c2VyX2FnZW50OiB0aGUgY3VzdG9tIFVzZXItQWdlbnQgaGVhZGVyIHRo YXQgc2hvdWxkIGJlIHNlbnQKKyAqCisgKiBUaGlzIHNldHMgdGhlIFVzZXItQWdlbnQgaGVhZGVy IG9mIHRoZSByZXF1ZXN0LgorICoKKyAqIFRoaXMgaXMgcmVhbGx5IGEgc2hvcnRjdXQgZm9yIGNh bGxpbmcKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfaGVhZGVyKCkgd2l0aCAi VXNlci1BZ2VudCIgYXMgdGhlCisgKiBoZWFkZXIgbmFtZS4KKyAqLwordm9pZCB3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X3NldF9odHRwX3VzZXJfYWdlbnQoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJl cXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX3VzZXJfYWdlbnQpCit7CisgICAgZ19yZXR1cm5faWZf ZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpKTsKKyAgICBnX3JldHVybl9p Zl9mYWlsKGh0dHBfdXNlcl9hZ2VudCk7CisKKyAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3Nl dF9odHRwX2hlYWRlcihyZXF1ZXN0LCAiVXNlci1BZ2VudCIsIGh0dHBfdXNlcl9hZ2VudCk7Cit9 CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF91c2VyX2FnZW50Cisg KiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqCisgKiBHZXRzIHRoZSB1c2Vy IGFnZW50IGluZm9ybWF0aW9uIHRoYXQgaXMgYmVpbmcgc2VudCBpbiB0aGlzIHJlcXVlc3QuCisg KgorICogVGhpcyBpcyByZWFsbHkgYSBzaG9ydGN1dCBmb3IgY2FsbGluZworICogd2Via2l0X25l dHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9oZWFkZXIoKSB3aXRoICJVc2VyLUFnZW50IiBhcyB0aGUK KyAqIGhlYWRlciBuYW1lLgorICoKKyAqIFJldHVybnM6IGEgc3RyaW5nIHdpdGggdGhlIHZhbHVl IG9mIHRoZSBVc2VyLUFnZW50IGhlYWRlciBvciAlTlVMTAorICogaWYgdGhlIHJlcXVlc3QgZG9l cyBub3QgaGF2ZSB0aGF0IGhlYWRlciBzZXQKKyAqLworY29uc3QgZ2NoYXIqIHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfZ2V0X2h0dHBfdXNlcl9hZ2VudChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVx dWVzdCkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFV RVNUKHJlcXVlc3QpLCBOVUxMKTsKKworICAgIHJldHVybiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X2dldF9odHRwX2hlYWRlcihyZXF1ZXN0LCAiVXNlci1BZ2VudCIpOworfQorCisvKioKKyAqIHdl YmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfYWNjZXB0CisgKiBAcmVxdWVzdDogYSAjV2Vi S2l0TmV0d29ya1JlcXVlc3QKKyAqIEBodHRwX2FjY2VwdDogdGhlIHZhbHVlIGZvciB0aGUgQWNj ZXB0IGhlYWRlcgorICoKKyAqIFRoaXMgc2V0cyB0aGUgQWNjZXB0IGhlYWRlciBvZiB0aGUgcmVx dWVzdC4KKyAqCisgKiBUaGlzIGlzIHJlYWxseSBhIHNob3J0Y3V0IGZvciBjYWxsaW5nCisgKiB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX2hlYWRlcigpIHdpdGggIkFjY2VwdCIgYXMg dGhlCisgKiBoZWFkZXIgbmFtZS4KKyAqLwordm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3Nl dF9odHRwX2FjY2VwdChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIq IGh0dHBfYWNjZXB0KQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktf UkVRVUVTVChyZXF1ZXN0KSk7CisgICAgZ19yZXR1cm5faWZfZmFpbChodHRwX2FjY2VwdCk7CisK KyAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX2hlYWRlcihyZXF1ZXN0LCAiQWNj ZXB0IiwgaHR0cF9hY2NlcHQpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf Z2V0X2h0dHBfYWNjZXB0CisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAq CisgKiBHZXRzIHRoZSBpbmZvcm1hdGlvbiBvbiB3aGF0IGlzIGFjY2VwdGVkIHRoYXQgaXMgYmVp bmcgc2VudCBpbiB0aGlzCisgKiByZXF1ZXN0LgorICoKKyAqIFRoaXMgaXMgcmVhbGx5IGEgc2hv cnRjdXQgZm9yIGNhbGxpbmcKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfaGVh ZGVyKCkgd2l0aCAiQWNjZXB0IiBhcyB0aGUKKyAqIGhlYWRlciBuYW1lLgorICoKKyAqIFJldHVy bnM6IGEgc3RyaW5nIHdpdGggdGhlIHZhbHVlIG9mIHRoZSBBY2NlcHQgaGVhZGVyIG9yICVOVUxM IGlmCisgKiB0aGUgcmVxdWVzdCBkb2VzIG5vdCBoYXZlIHRoYXQgaGVhZGVyIHNldAorICovCitj b25zdCBnY2hhciogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9hY2NlcHQoV2ViS2l0 TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VC S0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgTlVMTCk7CisKKyAgICByZXR1cm4gd2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9oZWFkZXIocmVxdWVzdCwgIkFjY2VwdCIpOwor fQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2JvZHkKKyAqIEByZXF1ZXN0 OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICogQGJvZHk6IHRoZSBkYXRhIHRoYXQgc2hvdWxk IGJlIHNlbnQgYXMgdGhlIGJvZHkgZm9yIHRoaXMgcmVxdWVzdAorICogQGxlbmd0aDogc2l6ZSBv ZiB0aGUgZGF0YQorICoKKyAqIFNldHMgdGhlIGJvZHkgb2YgdGhlIHJlcXVlc3QgdG8gdGhlIGNv bnRlbnRzIG9mIHRoZSBnaXZlbgorICogc3RyaW5nLiBZb3Ugd2lsbCBhbHNvIHByb2JhYmx5IG5l ZWQgdG8gY2FsbAorICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaGVhZGVyKCkgdG8gc3Bl Y2lmeSB0aGUgQ29udGVudC1MZW5ndGgKKyAqIGhlYWRlci4KKyAqLwordm9pZCB3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X3NldF9ib2R5KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25z dCBnY2hhciogYm9keSwgY29uc3QgZ3NpemUgc2l6ZSkKK3sKKyAgICBnX3JldHVybl9pZl9mYWls KFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworICAgIGdfcmV0dXJuX2lmX2Zh aWwoYm9keSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1 ZXN0LT5wcml2OworCisgICAgZ19mcmVlKHByaXYtPmJvZHkpOworICAgIG1lbWNweShwcml2LT5i b2R5LCBib2R5LCBzaXplKTsKKyAgICBwcml2LT5ib2R5X3NpemUgPSBzaXplOworCisgICAgcHJp di0+cmVxdWVzdC5zZXRIVFRQQm9keShGb3JtRGF0YTo6Y3JlYXRlKChjb25zdCB2b2lkKilwcml2 LT5ib2R5LCAoc2l6ZV90KXNpemUpKTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X2dldF9ib2R5CisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEBi b2R5X3NpemU6IGEgcG9pbnRlciB0byBhICNnc2l6ZSwgb3IgJU5VTEwKKyAqCisgKiBHZXRzIHRo ZSBib2R5IG9mIHRoZSByZXF1ZXN0LiBJZiBnaXZlbiwgQGJvZHlfc2l6ZSB3aWxsIGJlIHNldCB0 bworICogdGhlIHNpemUgb2YgdGhlIGJvZHkgZGF0YS4gVGhpcyBpcyB1c2VmdWwgYmVjYXVzZSB0 aGUgYm9keSBtYXkgbm90CisgKiBiZSBhIHN0cmluZywgYW5kIG1heSBoYXZlIGEgbnVtYmVyIG9m ICdcMCcgY2hhcmFjdGVycyBhcyBwYXJ0IG9mCisgKiB0aGUgZGF0YS4KKyAqCisgKiBSZXR1cm5z OiBhIHN0cmluZyB3aXRoIHRoZSBib2R5IG9mIHRoZSByZXF1ZXN0IG9yICVOVUxMIGlmIHRoZQor ICogcmVxdWVzdCBkb2VzIG5vdCBoYXZlIGEgYm9keQorICovCitjb25zdCBnY2hhciogd2Via2l0 X25ldHdvcmtfcmVxdWVzdF9nZXRfYm9keShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwg Z3NpemUgKmJvZHlfc2l6ZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNf TkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1 ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBpZiAocHJpdi0+Ym9keSkg eworICAgICAgICAqYm9keV9zaXplID0gcHJpdi0+Ym9keV9zaXplOworICAgICAgICByZXR1cm4g cHJpdi0+Ym9keTsKKyAgICB9CisKKyAgICBpZiAoZ19hc2NpaV9zdHJjYXNlY21wICh3ZWJraXRf bmV0d29ya19yZXF1ZXN0X2dldF9odHRwX21ldGhvZChyZXF1ZXN0KSwgIlBPU1QiKSA9PSAwKSB7 CisgICAgICAgIFZlY3RvcjxjaGFyPiBkYXRhOworICAgICAgICBwcml2LT5yZXF1ZXN0Lmh0dHBC b2R5KCktPmZsYXR0ZW4oZGF0YSk7CisKKyAgICAgICAgcHJpdi0+Ym9keSA9IChnY2hhciopZ19t YWxsb2MwKGRhdGEuc2l6ZSgpKTsKKyAgICAgICAgcHJpdi0+Ym9keV9zaXplID0gZGF0YS5zaXpl KCk7CisgICAgICAgIG1lbWNweShwcml2LT5ib2R5LCBkYXRhLmRhdGEoKSwgZGF0YS5zaXplKCkp OworICAgIH0KKyAgICByZXR1cm4gcHJpdi0+Ym9keTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X3NldF9hbGxvd19odHRwX2Nvb2tpZXMKKyAqIEByZXF1ZXN0OiBhICNXZWJL aXROZXR3b3JrUmVxdWVzdAorICogQGFsbG93X2h0dHBfY29va2llczogd2hldGhlciBIVFRQIGNv b2tpZXMgc2hvdWxkIGJlIGFsbG93ZWQKKyAqCisgKiBTZXRzIHdoZXRoZXIgSFRUUCBjb29raWVz IHNob3VsZCBiZSBhbGxvd2VkIHRvIGJlIHNldCBpbiByZXNwb25zZQorICogdG8gdGhpcyByZXF1 ZXN0LgorICovCit2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2FsbG93X2h0dHBfY29v a2llcyhXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2Jvb2xlYW4gYWxsb3df aHR0cF9jb29raWVzKQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktf UkVRVUVTVChyZXF1ZXN0KSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHBy aXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgcHJpdi0+YWxsb3dfaHR0cF9jb29raWVzID0gYWxs b3dfaHR0cF9jb29raWVzOworCisgICAgcHJpdi0+cmVxdWVzdC5zZXRBbGxvd0hUVFBDb29raWVz KGFsbG93X2h0dHBfY29va2llcyk7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVxdWVz dF9nZXRfYWxsb3dfaHR0cF9jb29raWVzCisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1Jl cXVlc3QKKyAqCisgKiBPYnRhaW5zIHdoZXRoZXIgY29va2llcyBhcmUgYWxsb3dlZCBieSB0aGUg cmVxdWVzdC4KKyAqCisgKiBSZXR1cm5zOiAlVFJVRSBpZiBjb29raWVzIGFyZSBhbGxvd2VkIGlu IHJlc3BvbnNlIHRvIHRoaXMgcmVxdWVzdCwKKyAqICVGQUxTRSBvdGhlcndpc2UKKyAqLworZ2Jv b2xlYW4gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfYWxsb3dfaHR0cF9jb29raWVzKFdlYktp dE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdF QktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIEZBTFNFKTsKKworICAgIFdlYktpdE5l dHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICByZXR1cm4g cHJpdi0+YWxsb3dfaHR0cF9jb29raWVzOworfQorCiB9CkluZGV4OiBXZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9ndGsvd2Via2l0 L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmgJKHJldmlzaW9uIDMzMDMyKQorKysgV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuaAkod29ya2luZyBjb3B5KQpAQCAtNDUsNiArNDUs MjMgQEAgc3RydWN0IF9XZWJLaXROZXR3b3JrUmVxdWVzdENsYXNzIHsKICAgICBHT2JqZWN0Q2xh c3MgcGFyZW50X2NsYXNzOwogfTsKIAorLyoqCisgKiBXZWJLaXRSZXFDYWNoZVBvbGljeToKKyAq IEBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9OT05FOiBpbnZhbGlkLCBtYXJrZXIgcG9saWN5Cisg KiBAV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfUFJPVE9DT0w6IHVzZSB0aGUgSFRUUCBwcm90b2Nv bCBjYWNoaW5nIHJ1bGVzCisgKiBAV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfUkVMT0FEX0lHTk9S SU5HX0NBQ0hFOiBmb3JjZSBhIHJlbG9hZCwgaWdub3JpbmcgYW55IGNhY2hlCisgKiBAV0VCS0lU X1JFUV9DQUNIRV9QT0xJQ1lfQUxMT1dfQ0FDSEU6IHVzZSBkYXRhIGZyb20gY2FjaGUsIGlmIGF2 YWlsYWJsZSwgYW5kIGxvYWQgaXQgZnJlc2ggb3RoZXJ3aXNlCisgKiBAV0VCS0lUX1JFUV9DQUNI RV9QT0xJQ1lfQ0FDSEVfT05MWTogZm9yY2UgdXNpbmcgdGhlIGNhY2hlIG9ubHk7IHVzZWZ1bCBm b3Igb2ZmbGluZSBtb2RlcworICovCit0eXBlZGVmIGVudW0KK3sKKyAgV0VCS0lUX1JFUV9DQUNI RV9QT0xJQ1lfTk9ORSwKKyAgV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfUFJPVE9DT0wsCisgIFdF QktJVF9SRVFfQ0FDSEVfUE9MSUNZX1JFTE9BRF9JR05PUklOR19DQUNIRSwKKyAgV0VCS0lUX1JF UV9DQUNIRV9QT0xJQ1lfQUxMT1dfQ0FDSEUsCisgIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX0NB Q0hFX09OTFksCit9IFdlYktpdFJlcUNhY2hlUG9saWN5OworCiBXRUJLSVRfQVBJIEdUeXBlCiB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF90eXBlICh2b2lkKTsKIApAQCAtNTcsNiArNzQsODEg QEAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpIChXZWJLaXROZQogV0VCS0lUX0FQSSBj b25zdCBnY2hhcioKIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaSAoV2ViS2l0TmV0d29y a1JlcXVlc3QqIHJlcXVlc3QpOwogCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF9uZXR3b3JrX3Jl cXVlc3Rfc2V0X2NhY2hlX3BvbGljeShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29u c3QgV2ViS2l0UmVxQ2FjaGVQb2xpY3kgY2FjaGVfcG9saWN5KTsKKworV0VCS0lUX0FQSSBXZWJL aXRSZXFDYWNoZVBvbGljeQord2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfY2FjaGVfcG9saWN5 KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X3NldF90aW1lb3V0X2ludGVydmFsKFdlYktpdE5ldHdvcmtSZXF1 ZXN0KiByZXF1ZXN0LCBjb25zdCBnZG91YmxlIHRpbWVvdXRfaW50ZXJ2YWwpOworCitXRUJLSVRf QVBJIGdkb3VibGUKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3RpbWVvdXRfaW50ZXJ2YWwo V2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtp dF9uZXR3b3JrX3JlcXVlc3Rfc2V0X21haW5fZG9jdW1lbnRfdXJpKFdlYktpdE5ldHdvcmtSZXF1 ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciogbWFpbl9kb2N1bWVudF91cmkpOworCitXRUJLSVRf QVBJIGNvbnN0IGdjaGFyKgord2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWFpbl9kb2N1bWVu dF91cmkoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCitXRUJLSVRfQVBJIHZvaWQK K3dlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfbWV0aG9kIChXZWJLaXROZXR3b3JrUmVx dWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfbWV0aG9kKTsKKworV0VCS0lUX0FQSSBj b25zdCBnY2hhcioKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfbWV0aG9kIChXZWJL aXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X25l dHdvcmtfcmVxdWVzdF9hZGRfaHR0cF9oZWFkZXJzIChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVx dWVzdCwgY29uc3QgR0hhc2hUYWJsZSogaHR0cF9oZWFkZXJzKTsKKworV0VCS0lUX0FQSSBjb25z dCBHSGFzaFRhYmxlKgord2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9oZWFkZXJzIChX ZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0 X25ldHdvcmtfcmVxdWVzdF9hZGRfaHR0cF9oZWFkZXIoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJl cXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX2hlYWRlciwgY29uc3QgZ2NoYXIqIHZhbHVlKTsKKwor V0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX2hlYWRlciAo V2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX2hlYWRlciwg Y29uc3QgZ2NoYXIqIHZhbHVlKTsKKworV0VCS0lUX0FQSSBjb25zdCBnY2hhcioKK3dlYmtpdF9u ZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfaGVhZGVyIChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVx dWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfaGVhZGVyKTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX2NvbnRlbnRfdHlwZShXZWJLaXROZXR3b3JrUmVx dWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfY29udGVudF90eXBlKTsKKworV0VCS0lU X0FQSSBjb25zdCBnY2hhcioKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfY29udGVu dF90eXBlKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKworV0VCS0lUX0FQSSB2b2lk Cit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX3JlZmVyZXIoV2ViS2l0TmV0d29ya1Jl cXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX3JlZmVyZXIpOworCitXRUJLSVRfQVBJ IGNvbnN0IGdjaGFyKgord2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9yZWZlcmVyKFdl YktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRf bmV0d29ya19yZXF1ZXN0X3NldF9odHRwX3VzZXJfYWdlbnQoV2ViS2l0TmV0d29ya1JlcXVlc3Qq IHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX3VzZXJfYWdlbnQpOworCitXRUJLSVRfQVBJIGNv bnN0IGdjaGFyKgord2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF91c2VyX2FnZW50KFdl YktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRf bmV0d29ya19yZXF1ZXN0X3NldF9odHRwX2FjY2VwdChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVx dWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfYWNjZXB0KTsKKworV0VCS0lUX0FQSSBjb25zdCBnY2hh cioKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfYWNjZXB0KFdlYktpdE5ldHdvcmtS ZXF1ZXN0KiByZXF1ZXN0KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X3NldF9ib2R5KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciog Ym9keSwgY29uc3QgZ3NpemUgc2l6ZSk7CisKK1dFQktJVF9BUEkgY29uc3QgZ2NoYXIqCit3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X2dldF9ib2R5KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0 LCBnc2l6ZSAqYm9keV9zaXplKTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X3NldF9hbGxvd19odHRwX2Nvb2tpZXMoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVl c3QsIGNvbnN0IGdib29sZWFuIGFsbG93X2h0dHBfY29va2llcyk7CisKK1dFQktJVF9BUEkgZ2Jv b2xlYW4KK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2FsbG93X2h0dHBfY29va2llcyhXZWJL aXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZgpJbmRl eDogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuY3BwCShyZXZpc2lv biAwKQorKysgV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmNwcAkocmV2 aXNpb24gMCkKQEAgLTAsMCArMSwxNTAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDggR3Vz dGF2byBOb3JvbmhhIFNpbHZhCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7 IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0 ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVi bGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lv biAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9u LgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0 IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2 ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVy YWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhh dmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElC LiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5j LiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAt MTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2luY2x1ZGUgIndlYmtp dG5ldHdvcmtyZXNwb25zZS5oIgorCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNs dWRlICJSZXNvdXJjZVJlc3BvbnNlLmgiCisjaW5jbHVkZSAiQ1N0cmluZy5oIgorCit1c2luZyBu YW1lc3BhY2UgV2ViQ29yZTsKKworZXh0ZXJuICJDIiB7CisKK0dfREVGSU5FX1RZUEUoV2ViS2l0 TmV0d29ya1Jlc3BvbnNlLCB3ZWJraXRfbmV0d29ya19yZXNwb25zZSwgR19UWVBFX09CSkVDVCk7 CisKK3N0cnVjdCBfV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSB7CisgICAgUmVzb3VyY2VS ZXNwb25zZSByZXNwb25zZTsKKworICAgIGdjaGFyKiB1cmk7Cit9OworCisjZGVmaW5lIFdFQktJ VF9ORVRXT1JLX1JFU1BPTlNFX0dFVF9QUklWQVRFKG9iaikgKEdfVFlQRV9JTlNUQU5DRV9HRVRf UFJJVkFURSgob2JqKSwgV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSwgV2ViS2l0TmV0d29y a1Jlc3BvbnNlUHJpdmF0ZSkpCisKK3N0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNl X2ZpbmFsaXplKEdPYmplY3QqIG9iamVjdCkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2Uq IHJlc3BvbnNlID0gV0VCS0lUX05FVFdPUktfUkVTUE9OU0Uob2JqZWN0KTsKKyAgICBXZWJLaXRO ZXR3b3JrUmVzcG9uc2VQcml2YXRlKiBwcml2ID0gcmVzcG9uc2UtPnByaXY7CisKKyAgICBnX2Zy ZWUocHJpdi0+dXJpKTsKKworICAgIEdfT0JKRUNUX0NMQVNTKHdlYmtpdF9uZXR3b3JrX3Jlc3Bv bnNlX3BhcmVudF9jbGFzcyktPmZpbmFsaXplKG9iamVjdCk7Cit9CisKK3N0YXRpYyB2b2lkIHdl YmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2NsYXNzX2luaXQoV2ViS2l0TmV0d29ya1Jlc3BvbnNlQ2xh c3MqIHJlc3BvbnNlQ2xhc3MpCit7CisgICAgR19PQkpFQ1RfQ0xBU1MocmVzcG9uc2VDbGFzcykt PmZpbmFsaXplID0gd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZmluYWxpemU7CisKKyAgICBnX3R5 cGVfY2xhc3NfYWRkX3ByaXZhdGUocmVzcG9uc2VDbGFzcywgc2l6ZW9mKFdlYktpdE5ldHdvcmtS ZXNwb25zZVByaXZhdGUpKTsKK30KKworc3RhdGljIHZvaWQgd2Via2l0X25ldHdvcmtfcmVzcG9u c2VfaW5pdChXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlKQoreworICAgIFdlYktpdE5l dHdvcmtSZXNwb25zZVByaXZhdGUqIHByaXYgPSBXRUJLSVRfTkVUV09SS19SRVNQT05TRV9HRVRf UFJJVkFURShyZXNwb25zZSk7CisgICAgcmVzcG9uc2UtPnByaXYgPSBwcml2OworfQorCisKKy8v IGZvciBpbnRlcm5hbCB1c2Ugb25seQorV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiB3ZWJraXRfbmV0 d29ya19yZXNwb25zZV9uZXdfZnJvbV9yZXNvdXJjZV9yZXNwb25zZShSZXNvdXJjZVJlc3BvbnNl JiByZXNvdXJjZVJlc3BvbnNlKQoreworICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9u c2UgPSBXRUJLSVRfTkVUV09SS19SRVNQT05TRShnX29iamVjdF9uZXcoV0VCS0lUX1RZUEVfTkVU V09SS19SRVNQT05TRSwgTlVMTCkpOworICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUq IHByaXYgPSByZXNwb25zZS0+cHJpdjsKKworICAgIHByaXYtPnJlc3BvbnNlID0gcmVzb3VyY2VS ZXNwb25zZTsKKworICAgIHJldHVybiByZXNwb25zZTsKK30KKworLy8gZm9yIGludGVybmFsIHVz ZSBvbmx5CitSZXNvdXJjZVJlc3BvbnNlIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF9yZXNv dXJjZV9yZXNwb25zZShjb25zdCBXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlKQorewor ICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUqIHByaXYgPSByZXNwb25zZS0+cHJpdjsK KworICAgIHJldHVybiBwcml2LT5yZXNwb25zZTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29y a19yZXNwb25zZV9uZXc6CisgKiBAdXJpOiBhbiBhbHJlYWR5IGVuY29kZWQgVVJJCisgKgorICog Q3JlYXRlcyBhIG5ldyAjV2ViS2l0TmV0d29ya1Jlc3BvbnNlIGluaXRpYWxpemVkIHdpdGggYW4g VVJJLgorICoKKyAqIFJldHVybnM6IGEgbmV3ICNXZWJLaXROZXR3b3JrUmVzcG9uc2UKKyAqLwor V2ViS2l0TmV0d29ya1Jlc3BvbnNlKiB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9uZXcoY29uc3Qg Z2NoYXIqIHVyaSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbCh1cmksIE5VTEwpOworCisg ICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSA9IFdFQktJVF9ORVRXT1JLX1JFU1BP TlNFKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNFLCBOVUxMKSk7Cisg ICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSogcHJpdiA9IHJlc3BvbnNlLT5wcml2Owor CisgICAgcHJpdi0+dXJpID0gZ19zdHJkdXAodXJpKTsKKworICAgIHJldHVybiByZXNwb25zZTsK K30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9zZXRfdXJpOgorICogQHJlc3Bv bnNlOiBhICNXZWJLaXROZXR3b3JrUmVzcG9uc2UKKyAqIEB1cmk6IGFuIGFscmVhZHkgZW5jb2Rl ZCBVUkkKKyAqCisgKiBTZXRzIHRoZSBVUkkgaGVsZCBhbmQgdXNlZCBieSB0aGUgZ2l2ZW4gcmVz cG9uc2UuCisgKi8KK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVzcG9uc2Vfc2V0X3VyaShXZWJLaXRO ZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlLCBjb25zdCBnY2hhciogdXJpKQoreworICAgIGdfcmV0 dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVTUE9OU0UocmVzcG9uc2UpKTsKKyAgICBn X3JldHVybl9pZl9mYWlsKHVyaSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRl KiBwcml2ID0gcmVzcG9uc2UtPnByaXY7CisKKyAgICBnX2ZyZWUocHJpdi0+dXJpKTsKKyAgICBw cml2LT51cmkgPSBnX3N0cmR1cCh1cmkpOworCisgICAgLyogCisgICAgICogZmVlZGluZyBiYWNr IHRvIHRoZSBSZXNvdXJjZVJlc3BvbnNlIG9iamVjdCwgd2hpY2ggaXMgdGhlIG9uZSBhY3R1YWxs eSB1c2VkCisgICAgICogaW5zaWRlIFdlYkNvcmUKKyAgICAgKi8KKyAgICBwcml2LT5yZXNwb25z ZS5zZXRVcmwoS1VSTChTdHJpbmc6OmZyb21VVEY4KHVyaSkpKTsKK30KKworLyoqCisgKiB3ZWJr aXRfbmV0d29ya19yZXNwb25zZV9nZXRfdXJpOgorICogQHJlc3BvbnNlOiBhICNXZWJLaXROZXR3 b3JrUmVzcG9uc2UKKyAqCisgKiBHZXRzIHRoZSBVUkkgaGVsZCBhbmQgdXNlZCBieSB0aGUgZ2l2 ZW4gcmVzcG9uc2UuCisgKgorICogUmV0dXJuczogdGhlIFVSSSBoZWxkIGFuZCB1c2VkIGJ5IHRo ZSBnaXZlbiByZXNwb25zZQorICovCitjb25zdCBnY2hhciogd2Via2l0X25ldHdvcmtfcmVzcG9u c2VfZ2V0X3VyaShXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlKQoreworICAgIGdfcmV0 dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFU1BPTlNFKHJlc3BvbnNlKSwgTlVM TCk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlKiBwcml2ID0gcmVzcG9uc2Ut PnByaXY7CisgICAgCisgICAgaWYgKHByaXYtPnVyaSkKKyAgICAgICAgcmV0dXJuIHByaXYtPnVy aTsKKworICAgIHByaXYtPnVyaSA9IGdfc3RyZHVwKHByaXYtPnJlc3BvbnNlLnVybCgpLnN0cmlu ZygpLnV0ZjgoKS5kYXRhKCkpOworICAgIHJldHVybiBwcml2LT51cmk7Cit9CisKK30KSW5kZXg6 IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5oCShyZXZpc2lvbiAwKQor KysgV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmgJKHJldmlzaW9uIDAp CkBAIC0wLDAgKzEsNjMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDggR3VzdGF2byBOb3Jv bmhhIFNpbHZhCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4g cmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0 aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5 IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRo ZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAq IFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUg dXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGlt cGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2 ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBh bG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90 LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJh bmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNB LgorICovCisKKyNpZm5kZWYgV0VCS0lUX05FVFdPUktfUkVTUE9OU0VfSAorI2RlZmluZSBXRUJL SVRfTkVUV09SS19SRVNQT05TRV9ICisKKyNpbmNsdWRlIDxnbGliLW9iamVjdC5oPgorCisjaW5j bHVkZSA8d2Via2l0L3dlYmtpdGRlZmluZXMuaD4KKworR19CRUdJTl9ERUNMUworCisjZGVmaW5l IFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UgICAgICAgICAgICAod2Via2l0X25ldHdvcmtf cmVzcG9uc2VfZ2V0X3R5cGUoKSkKKyNkZWZpbmUgV0VCS0lUX05FVFdPUktfUkVTUE9OU0Uob2Jq KSAgICAgICAgICAgIChHX1RZUEVfQ0hFQ0tfSU5TVEFOQ0VfQ0FTVCgob2JqKSwgV0VCS0lUX1RZ UEVfTkVUV09SS19SRVNQT05TRSwgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKSkKKyNkZWZpbmUgV0VC S0lUX05FVFdPUktfUkVTUE9OU0VfQ0xBU1Moa2xhc3MpICAgIChHX1RZUEVfQ0hFQ0tfQ0xBU1Nf Q0FTVCgoa2xhc3MpLCAgV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSwgV2ViS2l0TmV0d29y a1Jlc3BvbnNlQ2xhc3MpKQorI2RlZmluZSBXRUJLSVRfSVNfTkVUV09SS19SRVNQT05TRShvYmop ICAgICAgICAgKEdfVFlQRV9DSEVDS19JTlNUQU5DRV9UWVBFKChvYmopLCBXRUJLSVRfVFlQRV9O RVRXT1JLX1JFU1BPTlNFKSkKKyNkZWZpbmUgV0VCS0lUX0lTX05FVFdPUktfUkVTUE9OU0VfQ0xB U1Moa2xhc3MpIChHX1RZUEVfQ0hFQ0tfQ0xBU1NfVFlQRSgoa2xhc3MpLCAgV0VCS0lUX1RZUEVf TkVUV09SS19SRVNQT05TRSkpCisjZGVmaW5lIFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFX0dFVF9D TEFTUyhvYmopICAoR19UWVBFX0lOU1RBTkNFX0dFVF9DTEFTUygob2JqKSwgIFdFQktJVF9UWVBF X05FVFdPUktfUkVTUE9OU0UsIFdlYktpdE5ldHdvcmtSZXNwb25zZUNsYXNzKSkKKwordHlwZWRl ZiBzdHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUgV2ViS2l0TmV0d29ya1Jlc3Bv bnNlUHJpdmF0ZTsKKworc3RydWN0IF9XZWJLaXROZXR3b3JrUmVzcG9uc2UgeworICAgIEdPYmpl Y3QgcGFyZW50X2luc3RhbmNlOworCisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSog cHJpdjsKK307CisKK3N0cnVjdCBfV2ViS2l0TmV0d29ya1Jlc3BvbnNlQ2xhc3MgeworICAgIEdP YmplY3RDbGFzcyBwYXJlbnRfY2xhc3M7Cit9OworCitXRUJLSVRfQVBJIEdUeXBlCit3ZWJraXRf bmV0d29ya19yZXNwb25zZV9nZXRfdHlwZSAodm9pZCk7CisKK1dFQktJVF9BUEkgV2ViS2l0TmV0 d29ya1Jlc3BvbnNlKgord2Via2l0X25ldHdvcmtfcmVzcG9uc2VfbmV3IChjb25zdCBnY2hhciog dXJpKTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXNwb25zZV9zZXRfdXJp IChXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlLCBjb25zdCBnY2hhciogdXJpKTsKKwor V0VCS0lUX0FQSSBjb25zdCBnY2hhcioKK3dlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF91cmkg KFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UpOworCisKK0dfRU5EX0RFQ0xTCisKKyNl bmRpZgpJbmRleDogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAkocmV2aXNpb24gMzMwMzIpCisr KyBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgJKHdvcmtpbmcgY29weSkKQEAgLTIy LDcgKzIyLDggQEAKICNkZWZpbmUgV0VCS0lUX1BSSVZBVEVfSAogCiAvKgotICogVGhpcyBmaWxl IGtub3dzIHRoZSBzaGFyZWQgc2VjcmV0IG9mIFdlYktpdFdlYlZpZXcgYW5kIFdlYktpdFdlYkZy YW1lLgorICogVGhpcyBmaWxlIGtub3dzIHRoZSBzaGFyZWQgc2VjcmV0IG9mIFdlYktpdFdlYlZp ZXcgYW5kIFdlYktpdFdlYkZyYW1lCisgKiBhbmQgV2ViS2l0TmV0d29ya1JlcXVlc3QuCiAgKiBU aGV5IGFyZSB1c2luZyBXZWJDb3JlIHdoaWNoIG11c24ndCBiZSBleHBvc2VkIHRvIHRoZSBvdXRl ciB3b3JsZC4KICAqLwogCkBAIC0zOCw2ICszOSw3IEBACiAjaW5jbHVkZSAiUGFnZS5oIgogI2lu Y2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkZXJDbGllbnQuaCIKKyNpbmNsdWRl ICJSZXNvdXJjZVJlcXVlc3QuaCIKIAogI2luY2x1ZGUgPGdsaWIuaD4KIApAQCAtMTIxLDYgKzEy MywxOCBAQCBleHRlcm4gIkMiIHsKIAogICAgIFdFQktJVF9BUEkgZ2NoYXIqCiAgICAgd2Via2l0 X3dlYl92aWV3X2dldF9zZWxlY3RlZF90ZXh0IChXZWJLaXRXZWJWaWV3KiB3ZWJfdmlldyk7CisK KyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCoKKyAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25l d19mcm9tX3Jlc291cmNlX3JlcXVlc3QoV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJj ZVJlcXVlc3QpOworCisgICAgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0CisgICAgd2Via2l0X25l dHdvcmtfcmVxdWVzdF9nZXRfcmVzb3VyY2VfcmVxdWVzdChjb25zdCBXZWJLaXROZXR3b3JrUmVx dWVzdCogcmVxdWVzdCk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2UqCisgICAgd2Via2l0 X25ldHdvcmtfcmVzcG9uc2VfbmV3X2Zyb21fcmVzb3VyY2VfcmVzcG9uc2UoV2ViQ29yZTo6UmVz b3VyY2VSZXNwb25zZSYgcmVzb3VyY2VSZXNwb25zZSk7CisKKyAgICBXZWJDb3JlOjpSZXNvdXJj ZVJlc3BvbnNlCisgICAgd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3Jlc291cmNlX3Jlc3Bv bnNlKGNvbnN0IFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UpOwogfQogCiAjZW5kaWYK SW5kZXg6IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAJKHJldmlzaW9uIDMzMDMyKQor KysgV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC0zNTMsOSArMzUzLDcgQEAgdm9pZCB3ZWJraXRfd2ViX2ZyYW1lX2xvYWRfcmVxdWVzdChXZWJL aQogICAgIEZyYW1lKiBjb3JlRnJhbWUgPSBjb3JlKGZyYW1lKTsKICAgICBBU1NFUlQoY29yZUZy YW1lKTsKIAotICAgIC8vIFRPRE86IFVzZSB0aGUgUmVzb3VyY2VSZXF1ZXN0IGNhcnJpZWQgYnkg V2ViS2l0TmV0d29ya1JlcXVlc3Qgd2hlbiBpdCBpcyBpbXBsZW1lbnRlZC4KLSAgICBTdHJpbmcg c3RyaW5nID0gU3RyaW5nOjpmcm9tVVRGOCh3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF91cmko cmVxdWVzdCkpOwotICAgIGNvcmVGcmFtZS0+bG9hZGVyKCktPmxvYWQoUmVzb3VyY2VSZXF1ZXN0 KEtVUkwoc3RyaW5nKSkpOworICAgIGNvcmVGcmFtZS0+bG9hZGVyKCktPmxvYWQod2Via2l0X25l dHdvcmtfcmVxdWVzdF9nZXRfcmVzb3VyY2VfcmVxdWVzdChyZXF1ZXN0KSk7CiB9CiAKIC8qKgpJ bmRleDogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAJKHJldmlzaW9uIDMzMDMyKQorKysg V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI3 LDYgKzI3LDggQEAKICNpbmNsdWRlICJ3ZWJraXRwcml2YXRlLmgiCiAjaW5jbHVkZSAid2Via2l0 d2ViYmFja2ZvcndhcmRsaXN0LmgiCiAjaW5jbHVkZSAid2Via2l0d2ViaGlzdG9yeWl0ZW0uaCIK KyNpbmNsdWRlICJ3ZWJraXRuZXR3b3JrcmVxdWVzdC5oIgorI2luY2x1ZGUgIndlYmtpdG5ldHdv cmtyZXNwb25zZS5oIgogCiAjaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIKICNpbmNsdWRlICJC YWNrRm9yd2FyZExpc3QuaCIKQEAgLTY3LDYgKzY5LDggQEAgZW51bSB7CiAgICAgLyogbm9ybWFs IHNpZ25hbHMgKi8KICAgICBOQVZJR0FUSU9OX1JFUVVFU1RFRCwKICAgICBXSU5ET1dfT0JKRUNU X0NMRUFSRUQsCisgICAgUkVRVUVTVF9TVEFSVEVELAorICAgIFJFUVVFU1RfUkVESVJFQ1RFRCwK ICAgICBMT0FEX1NUQVJURUQsCiAgICAgTE9BRF9DT01NSVRURUQsCiAgICAgTE9BRF9QUk9HUkVT U19DSEFOR0VELApAQCAtNzYzLDYgKzc2Nyw0NSBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfd2ViX3Zp ZXdfY2xhc3NfaW5pdChXCiAgICAgICAgICAgICBHX1RZUEVfUE9JTlRFUik7CiAKICAgICAvKioK KyAgICAgKiBXZWJLaXRXZWJWaWV3OjpyZXF1ZXN0LXN0YXJ0ZWQ6CisgICAgICogQHdlYl92aWV3 OiB0aGUgb2JqZWN0IG9uIHdoaWNoIHRoZSBzaWduYWwgaXMgZW1pdHRlZAorICAgICAqIEByZXF1 ZXN0OiB0aGUgcmVxdWVzdCB0aGF0IGlzIHRvIGJlIG1hZGUKKyAgICAgKgorICAgICAqIFdoZW4g YSAjV2ViS2l0TmV0d29ya1JlcXVlc3QgaXMgYWJvdXQgdG8gYmUgc2VudCB0byB0aGUgc2VydmVy CisgICAgICogdGhpcyBzaWduYWwgaXMgZW1taXRlZC4KKyAgICAgKi8KKyAgICB3ZWJraXRfd2Vi X3ZpZXdfc2lnbmFsc1tSRVFVRVNUX1NUQVJURURdID0gZ19zaWduYWxfbmV3KCJyZXF1ZXN0LXN0 YXJ0ZWQiLAorICAgICAgICAgICAgR19UWVBFX0ZST01fQ0xBU1Mod2ViVmlld0NsYXNzKSwKKyAg ICAgICAgICAgIChHU2lnbmFsRmxhZ3MpKEdfU0lHTkFMX1JVTl9MQVNUIHwgR19TSUdOQUxfQUNU SU9OKSwKKyAgICAgICAgICAgIDAsCisgICAgICAgICAgICBOVUxMLAorICAgICAgICAgICAgTlVM TCwKKyAgICAgICAgICAgIGdfY2Nsb3N1cmVfbWFyc2hhbF9WT0lEX19PQkpFQ1QsCisgICAgICAg ICAgICBHX1RZUEVfTk9ORSwgMSwKKyAgICAgICAgICAgIFdFQktJVF9UWVBFX05FVFdPUktfUkVR VUVTVCk7CisKKyAgICAvKioKKyAgICAgKiBXZWJLaXRXZWJWaWV3OjpyZXF1ZXN0LXJlZGlyZWN0 ZWQ6CisgICAgICogQHdlYl92aWV3OiB0aGUgb2JqZWN0IG9uIHdoaWNoIHRoZSBzaWduYWwgaXMg ZW1pdHRlZAorICAgICAqIEByZXF1ZXN0OiB0aGUgcmVxdWVzdCB0aGF0IGlzIHRvIGJlIG1hZGUK KyAgICAgKiBAcmVzcG9uc2U6IHRoZSByZXNwb25zZSB3aGljaCByZWRpcmVjdGVkIHRoZSBvcmln aW5hbCByZXF1ZXN0CisgICAgICoKKyAgICAgKiBXaGVuIGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0 IGlzIHNlbnQgdG8gdGhlIHNlcnZlciBidXQgaXMKKyAgICAgKiByZWRpcmVjdGVkIGJ5IHRoZSBz ZXJ2ZXIgdGhpcyBzaWduYWwgaXMgZW1taXRlZCBiZWZvcmUgdGhlIG5ldworICAgICAqIHJlcXVl c3QgaXMgbWFkZS4KKyAgICAgKi8KKyAgICB3ZWJraXRfd2ViX3ZpZXdfc2lnbmFsc1tSRVFVRVNU X1JFRElSRUNURURdID0gZ19zaWduYWxfbmV3KCJyZXF1ZXN0LXJlZGlyZWN0ZWQiLAorICAgICAg ICAgICAgR19UWVBFX0ZST01fQ0xBU1Mod2ViVmlld0NsYXNzKSwKKyAgICAgICAgICAgIChHU2ln bmFsRmxhZ3MpKEdfU0lHTkFMX1JVTl9MQVNUIHwgR19TSUdOQUxfQUNUSU9OKSwKKyAgICAgICAg ICAgIDAsCisgICAgICAgICAgICBOVUxMLAorICAgICAgICAgICAgTlVMTCwKKyAgICAgICAgICAg IHdlYmtpdF9tYXJzaGFsX1ZPSURfX09CSkVDVF9PQkpFQ1QsCisgICAgICAgICAgICBHX1RZUEVf Tk9ORSwgMiwKKyAgICAgICAgICAgIFdFQktJVF9UWVBFX05FVFdPUktfUkVRVUVTVCwKKyAgICAg ICAgICAgIFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UpOworCisgICAgLyoqCiAgICAgICog V2ViS2l0V2ViVmlldzo6bG9hZC1zdGFydGVkOgogICAgICAqIEB3ZWJfdmlldzogdGhlIG9iamVj dCBvbiB3aGljaCB0aGUgc2lnbmFsIGlzIGVtaXR0ZWQKICAgICAgKiBAZnJhbWU6IHRoZSBmcmFt ZSBnb2luZyB0byBkbyB0aGUgbG9hZApJbmRleDogV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYktpdFRvb2xzL0NoYW5nZUxvZwkocmV2aXNpb24gMzMwMzIpCisrKyBXZWJL aXRUb29scy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwyNSBAQAorMjAwOC0w NS0xMSAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworCUltcGxlbWVudCBhIGRpYWxvZyB0byBzaG93 IHRoZSByZXF1ZXN0cywgYXMgYSB0ZXN0IGZvciB0aGUKKwlXZWJLaXROZXR3b3JrUmVxdWVzdCBB UEksIGFuZCBhbHNvIGEgaGFuZGxlciB0byB0aGUKKwlyZXF1ZXN0LXN0YXJ0ZWQgc2lnbmFsIHRv IGFkZCBhbiBhcmJpdHJhcnkgaGVhZGVyIHRvIHJlcXVlc3RzLgorCisgICAgICAgICogQ2hhbmdl TG9nOgorICAgICAgICAqIEd0a0xhdW5jaGVyL21haW4uYzoKKyAgICAgICAgKHNob3dfaHR0cF9p bnNwZWN0X3dpbmRvd19jYik6CisgICAgICAgIChuYXZpZ2F0aW9uX3JlcXVlc3RlZF9jYik6Cisg ICAgICAgIChyZXF1ZXN0X3N0YXJ0ZWRfY2IpOgorICAgICAgICAocmVxdWVzdF9yZWRpcmVjdGVk X2NiKToKKyAgICAgICAgKGFwcGVuZF9oZWFkZXJfdG9faHR0cF9pbnNwZWN0X2hlYWRlcnNfbW9k ZWwpOgorICAgICAgICAoY2FjaGVfcG9saWN5X3RvX3N0cmluZyk6CisgICAgICAgIChodHRwX2lu c3BlY3RfY3Vyc29yX2NoYW5nZWRfY2IpOgorICAgICAgICAoY3JlYXRlX2h0dHBfaW5zcGVjdF93 aW5kb3cpOgorICAgICAgICAoY3JlYXRlX2Jyb3dzZXIpOgorICAgICAgICAoY3JlYXRlX3Rvb2xi YXIpOgorICAgICAgICAobWFpbik6CisKIDIwMDgtMDUtMDkgIE1hcmsgUm93ZSAgPG1yb3dlQGFw cGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBBbmRlcnMgQ2FybHNzb24uCkluZGV4OiBX ZWJLaXRUb29scy9HdGtMYXVuY2hlci9tYWluLmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMv R3RrTGF1bmNoZXIvbWFpbi5jCShyZXZpc2lvbiAzMzAzMikKKysrIFdlYktpdFRvb2xzL0d0a0xh dW5jaGVyL21haW4uYwkod29ya2luZyBjb3B5KQpAQCAtMzUsNiArMzUsMjIgQEAgc3RhdGljIGdj aGFyKiBtYWluX3RpdGxlOwogc3RhdGljIGdpbnQgbG9hZF9wcm9ncmVzczsKIHN0YXRpYyBndWlu dCBzdGF0dXNfY29udGV4dF9pZDsKIAorR3RrV2lkZ2V0KiBodHRwX2luc3BlY3Rfd2luZG93Owor R3RrV2lkZ2V0KiBodHRwX2luc3BlY3RfcmVxdWVzdHNfbGlzdDsKK0d0a0xpc3RTdG9yZSogaHR0 cF9pbnNwZWN0X3JlcXVlc3RzX21vZGVsOworR3RrV2lkZ2V0KiBodHRwX2luc3BlY3RfY2FjaGVf cG9saWN5X2xhYmVsOworR3RrV2lkZ2V0KiBodHRwX2luc3BlY3RfdGltZW91dF9pbnRlcnZhbF9s YWJlbDsKK0d0a1dpZGdldCogaHR0cF9pbnNwZWN0X21haW5fZG9jdW1lbnRfdXJpX2xhYmVsOwor R3RrV2lkZ2V0KiBodHRwX2luc3BlY3RfbWV0aG9kX2xhYmVsOworR3RrV2lkZ2V0KiBodHRwX2lu c3BlY3RfY29udGVudF90eXBlX2xhYmVsOworR3RrV2lkZ2V0KiBodHRwX2luc3BlY3RfcmVmZXJl cl9sYWJlbDsKK0d0a1dpZGdldCogaHR0cF9pbnNwZWN0X3VzZXJfYWdlbnRfbGFiZWw7CitHdGtX aWRnZXQqIGh0dHBfaW5zcGVjdF9hY2NlcHRfbGFiZWw7CitHdGtXaWRnZXQqIGh0dHBfaW5zcGVj dF9hbGxvd19odHRwX2Nvb2tpZXNfbGFiZWw7CitHdGtXaWRnZXQqIGh0dHBfaW5zcGVjdF9oZWFk ZXJzX2xpc3Q7CitHdGtXaWRnZXQqIGh0dHBfaW5zcGVjdF9ib2R5X3RleHRfdmlldzsKK0d0a0xp c3RTdG9yZSogaHR0cF9pbnNwZWN0X2hlYWRlcnNfbW9kZWw7CisKIHN0YXRpYyB2b2lkCiBhY3Rp dmF0ZV91cmlfZW50cnlfY2IgKEd0a1dpZGdldCogZW50cnksIGdwb2ludGVyIGRhdGEpCiB7CkBA IC0xMDYsNiArMTIyLDM2NyBAQCBnb19mb3J3YXJkX2NiIChHdGtXaWRnZXQqIHdpZGdldCwgZ3Bv aW50CiAgICAgd2Via2l0X3dlYl92aWV3X2dvX2ZvcndhcmQgKHdlYl92aWV3KTsKIH0KIAorc3Rh dGljIHZvaWQKK3Nob3dfaHR0cF9pbnNwZWN0X3dpbmRvd19jYihHdGtXaWRnZXQqIHdpZGdldCwg Z3BvaW50ZXIgZGF0YSkKK3sKKyAgICBndGtfZGlhbG9nX3J1biAoR1RLX0RJQUxPRyhodHRwX2lu c3BlY3Rfd2luZG93KSk7CisgICAgZ3RrX3dpZGdldF9oaWRlIChodHRwX2luc3BlY3Rfd2luZG93 KTsKK30KKworc3RhdGljIHZvaWQKK25hdmlnYXRpb25fcmVxdWVzdGVkX2NiIChXZWJLaXRXZWJW aWV3KiB3ZWJfdmlldywgV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBXZWJLaXROZXR3b3JrUmVxdWVz dCogcmVxdWVzdCwgZ3BvaW50ZXIgZGF0YSkKK3sKKyAgICBHdGtMaXN0U3RvcmUqIG1vZGVsID0g aHR0cF9pbnNwZWN0X3JlcXVlc3RzX21vZGVsOworICAgIEd0a1RyZWVJdGVyIGl0ZXI7CisKKyAg ICBnX29iamVjdF9yZWYgKHJlcXVlc3QpOworCisgICAgZ3RrX2xpc3Rfc3RvcmVfYXBwZW5kKG1v ZGVsLCAmaXRlcik7CisgICAgZ3RrX2xpc3Rfc3RvcmVfc2V0KG1vZGVsLCAmaXRlciwKKyAgICAg ICAgICAgICAgICAgICAgICAgMCwgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJpIChyZXF1 ZXN0KSwKKyAgICAgICAgICAgICAgICAgICAgICAgMSwgcmVxdWVzdCwKKyAgICAgICAgICAgICAg ICAgICAgICAgLTEpOworfQorCitzdGF0aWMgdm9pZAorcmVxdWVzdF9zdGFydGVkX2NiIChXZWJL aXRXZWJWaWV3KiB3ZWJfdmlldywgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGdwb2lu dGVyIGRhdGEpCit7CisgICAgLy8gY3VzdG9tIGhlYWRlciwganVzdCB0byB0ZXN0IGlmIHRoaXMg dGhpbmcgd29ya3MKKyAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX2hlYWRlciAo cmVxdWVzdCwgIlgtTWlzYyIsICJnbywgd2Via2l0ISIpOworfQorCitzdGF0aWMgdm9pZAorcmVx dWVzdF9yZWRpcmVjdGVkX2NiIChXZWJLaXRXZWJWaWV3KiB3ZWJfdmlldywgV2ViS2l0TmV0d29y a1JlcXVlc3QqIHJlcXVlc3QsIFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UsIGdwb2lu dGVyIGRhdGEpCit7CisgICAgZ19tZXNzYWdlKCJSZWRpcmVjdGVkISByZXNwb25zZSB1cmk6ICVz LCByZXF1ZXN0IHVyaTogJXMiLAorICAgICAgICAgICAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X2dldF91cmkgKHJlcXVlc3QpLAorICAgICAgICAgICAgICB3ZWJraXRfbmV0d29ya19yZXNwb25z ZV9nZXRfdXJpIChyZXNwb25zZSkpOworfQorCitzdGF0aWMgdm9pZCBhcHBlbmRfaGVhZGVyX3Rv X2h0dHBfaW5zcGVjdF9oZWFkZXJzX21vZGVsIChnY2hhcioga2V5LCBnY2hhciogdmFsdWUsIEd0 a1RyZWVTZWxlY3Rpb24qIHNlbGVjdGlvbikKK3sKKyAgICBHdGtMaXN0U3RvcmUqIG1vZGVsID0g R1RLX0xJU1RfU1RPUkUoaHR0cF9pbnNwZWN0X2hlYWRlcnNfbW9kZWwpOworICAgIEd0a1RyZWVJ dGVyIGl0ZXI7CisgICAgCisgICAgZ3RrX2xpc3Rfc3RvcmVfYXBwZW5kIChtb2RlbCwgJml0ZXIp OworICAgIGd0a19saXN0X3N0b3JlX3NldCAobW9kZWwsICZpdGVyLCAwLCBrZXksIDEsIHZhbHVl LCAtMSk7Cit9CisKK3N0YXRpYyBjb25zdCBnY2hhciogY2FjaGVfcG9saWN5X3RvX3N0cmluZyAo V2ViS2l0UmVxQ2FjaGVQb2xpY3kgY2FjaGVfcG9saWN5KQoreworICAgIHN3aXRjaChjYWNoZV9w b2xpY3kpCisgICAgICAgIHsKKyAgICAgICAgY2FzZSBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9Q Uk9UT0NPTDoKKyAgICAgICAgICAgIHJldHVybiAiTm9ybWFsIGxvYWQiOworICAgICAgICBjYXNl IFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX1JFTE9BRF9JR05PUklOR19DQUNIRToKKyAgICAgICAg ICAgIHJldHVybiAiUmVsb2FkIjsKKyAgICAgICAgY2FzZSBXRUJLSVRfUkVRX0NBQ0hFX1BPTElD WV9BTExPV19DQUNIRToKKyAgICAgICAgICAgIHJldHVybiAiQWxsb3cgdXNlIG9mIGNhY2hlIGRh dGEiOworICAgICAgICBjYXNlIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX0NBQ0hFX09OTFk6Cisg ICAgICAgICAgICByZXR1cm4gIlVzZSBjYWNoZSwgb25seSI7CisgICAgICAgIGRlZmF1bHQ6Cisg ICAgICAgICAgICByZXR1cm4gIk5vbmUiOworICAgICAgICB9Cit9CisKK3ZvaWQgaHR0cF9pbnNw ZWN0X2N1cnNvcl9jaGFuZ2VkX2NiIChHdGtUcmVlVmlldyogdHJlZV92aWV3LCBncG9pbnRlciBk YXRhKQoreworICAgIEd0a1RyZWVNb2RlbCogbW9kZWwgPSBHVEtfVFJFRV9NT0RFTChodHRwX2lu c3BlY3RfcmVxdWVzdHNfbW9kZWwpOworICAgIEd0a1RyZWVTZWxlY3Rpb24qIHNlbGVjdGlvbiA9 IGd0a190cmVlX3ZpZXdfZ2V0X3NlbGVjdGlvbiAodHJlZV92aWV3KTsKKyAgICBHdGtUcmVlSXRl ciBpdGVyOworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0OworCisgICAgaWYgKGd0 a190cmVlX3NlbGVjdGlvbl9nZXRfc2VsZWN0ZWQgKHNlbGVjdGlvbiwgJm1vZGVsLCAmaXRlcikp CisgICAgICAgIHsKKyAgICAgICAgICAgIGdjaGFyKiB0bXA7CisKKyAgICAgICAgICAgIGd0a190 cmVlX21vZGVsX2dldCAobW9kZWwsICZpdGVyLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAxLCAmcmVxdWVzdCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLTEpOwor ICAgICAgICAgICAgCisgICAgICAgICAgICBndGtfbGFiZWxfc2V0X3RleHQgKEdUS19MQUJFTCho dHRwX2luc3BlY3RfY2FjaGVfcG9saWN5X2xhYmVsKSwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgY2FjaGVfcG9saWN5X3RvX3N0cmluZyAod2Via2l0X25ldHdvcmtfcmVxdWVzdF9n ZXRfY2FjaGVfcG9saWN5IChyZXF1ZXN0KSkpOworICAgICAgICAgICAgdG1wID0gZ19zdHJkdXBf cHJpbnRmICgiJS4yZiIsIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3RpbWVvdXRfaW50ZXJ2 YWwgKHJlcXVlc3QpKTsKKyAgICAgICAgICAgIGd0a19sYWJlbF9zZXRfdGV4dCAoR1RLX0xBQkVM KGh0dHBfaW5zcGVjdF90aW1lb3V0X2ludGVydmFsX2xhYmVsKSwgdG1wKTsKKyAgICAgICAgICAg IGdfZnJlZSAodG1wKTsKKyAgICAgICAgICAgIGd0a19sYWJlbF9zZXRfdGV4dCAoR1RLX0xBQkVM KGh0dHBfaW5zcGVjdF9tYWluX2RvY3VtZW50X3VyaV9sYWJlbCksCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X21haW5fZG9jdW1lbnRf dXJpIChyZXF1ZXN0KSk7CisgICAgICAgICAgICBndGtfbGFiZWxfc2V0X3RleHQgKEdUS19MQUJF TChodHRwX2luc3BlY3RfbWV0aG9kX2xhYmVsKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9tZXRob2QgKHJlcXVlc3QpKTsK KyAgICAgICAgICAgIGd0a19sYWJlbF9zZXRfdGV4dCAoR1RLX0xBQkVMKGh0dHBfaW5zcGVjdF9j b250ZW50X3R5cGVfbGFiZWwpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2NvbnRlbnRfdHlwZSAocmVxdWVzdCkpOworICAg ICAgICAgICAgZ3RrX2xhYmVsX3NldF90ZXh0IChHVEtfTEFCRUwoaHR0cF9pbnNwZWN0X3JlZmVy ZXJfbGFiZWwpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB3ZWJraXRfbmV0d29y a19yZXF1ZXN0X2dldF9odHRwX3JlZmVyZXIgKHJlcXVlc3QpKTsKKyAgICAgICAgICAgIGd0a19s YWJlbF9zZXRfdGV4dCAoR1RLX0xBQkVMKGh0dHBfaW5zcGVjdF91c2VyX2FnZW50X2xhYmVsKSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9n ZXRfaHR0cF91c2VyX2FnZW50IChyZXF1ZXN0KSk7CisgICAgICAgICAgICBndGtfbGFiZWxfc2V0 X3RleHQgKEdUS19MQUJFTChodHRwX2luc3BlY3RfYWNjZXB0X2xhYmVsKSwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9hY2Nl cHQgKHJlcXVlc3QpKTsKKyAgICAgICAgICAgIGd0a19sYWJlbF9zZXRfdGV4dCAoR1RLX0xBQkVM KGh0dHBfaW5zcGVjdF9hbGxvd19odHRwX2Nvb2tpZXNfbGFiZWwpLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9hbGxvd19odHRwX2Nv b2tpZXMgKHJlcXVlc3QpID8gIlRydWUiIDogIkZhbHNlIik7CisKKyAgICAgICAgICAgIGd0a19s aXN0X3N0b3JlX2NsZWFyIChodHRwX2luc3BlY3RfaGVhZGVyc19tb2RlbCk7CisgICAgICAgICAg ICBnX2hhc2hfdGFibGVfZm9yZWFjaCAoKEdIYXNoVGFibGUqKXdlYmtpdF9uZXR3b3JrX3JlcXVl c3RfZ2V0X2h0dHBfaGVhZGVycyAocmVxdWVzdCksCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgKEdIRnVuYylhcHBlbmRfaGVhZGVyX3RvX2h0dHBfaW5zcGVjdF9oZWFkZXJzX21v ZGVsLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChncG9pbnRlcilzZWxlY3Rp b24pOworCisgICAgICAgICAgICBHdGtUZXh0QnVmZmVyKiB0ZXh0X2J1ZmZlciA9IGd0a190ZXh0 X3ZpZXdfZ2V0X2J1ZmZlciAoR1RLX1RFWFRfVklFVyhodHRwX2luc3BlY3RfYm9keV90ZXh0X3Zp ZXcpKTsKKyAgICAgICAgICAgIEd0a1RleHRJdGVyIHN0YXJ0LCBlbmQ7CisgICAgICAgICAgICBn dGtfdGV4dF9idWZmZXJfZ2V0X2JvdW5kcyAodGV4dF9idWZmZXIsICZzdGFydCwgJmVuZCk7Cisg ICAgICAgICAgICBndGtfdGV4dF9idWZmZXJfZGVsZXRlICh0ZXh0X2J1ZmZlciwgJnN0YXJ0LCAm ZW5kKTsKKworICAgICAgICAgICAgZ3NpemUgYm9keV9zaXplOworICAgICAgICAgICAgY29uc3Qg Z2NoYXIgKmJvZHkgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9ib2R5IChyZXF1ZXN0LCAm Ym9keV9zaXplKTsKKyAgICAgICAgICAgIGlmIChib2R5KQorICAgICAgICAgICAgICAgIGd0a190 ZXh0X2J1ZmZlcl9zZXRfdGV4dCAodGV4dF9idWZmZXIsIGJvZHksIChnaW50KWJvZHlfc2l6ZSk7 CisgICAgICAgIH0KK30KKworc3RhdGljIEd0a1dpZGdldCoKK2NyZWF0ZV9odHRwX2luc3BlY3Rf d2luZG93ICgpCit7CisgICAgR3RrV2lkZ2V0KiB3aW5kb3cgPSBndGtfZGlhbG9nX25ld193aXRo X2J1dHRvbnMgKCJIVFRQIFJlcXVlc3RzIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgR1RLX1dJTkRPVyhtYWluX3dpbmRvdyksCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdUS19ESUFMT0df REVTVFJPWV9XSVRIX1BBUkVOVCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgR1RLX1NUT0NLX0NMT1NFLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtfUkVTUE9OU0VfREVMRVRFX0VWRU5U LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBO VUxMKTsKKyAgICBndGtfd2luZG93X3NldF9kZWZhdWx0X3NpemUgKEdUS19XSU5ET1cod2luZG93 KSwgODAwLCA2MDApOworCisgICAgLy8gYmFzaWMgbGF5b3V0CisgICAgR3RrV2lkZ2V0KiB2Ym94 ID0gR1RLX0RJQUxPRyh3aW5kb3cpLT52Ym94OworICAgIEd0a1dpZGdldCogcGFuZWQgPSBndGtf aHBhbmVkX25ldyAoKTsKKyAgICBndGtfYm94X3BhY2tfc3RhcnQgKEdUS19CT1godmJveCksIHBh bmVkLCBUUlVFLCBUUlVFLCAxMik7CisgICAgZ3RrX3dpZGdldF9zaG93KHBhbmVkKTsKKworICAg IEd0a1dpZGdldCogc2Nyb2xsZWRfd2luZG93ID0gZ3RrX3Njcm9sbGVkX3dpbmRvd19uZXcgKE5V TEwsIE5VTEwpOworICAgIGd0a19zY3JvbGxlZF93aW5kb3dfc2V0X3BvbGljeSAoR1RLX1NDUk9M TEVEX1dJTkRPVyhzY3JvbGxlZF93aW5kb3cpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgR1RLX1BPTElDWV9BVVRPTUFUSUMsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBHVEtfUE9MSUNZX0FVVE9NQVRJQyk7CisgICAgZ3RrX3dpZGdldF9zZXRfc2l6 ZV9yZXF1ZXN0IChzY3JvbGxlZF93aW5kb3csIDIwMCwgLTEpOworICAgIGd0a19wYW5lZF9hZGQx IChHVEtfUEFORUQocGFuZWQpLCBzY3JvbGxlZF93aW5kb3cpOworICAgIGd0a193aWRnZXRfc2hv dyAoc2Nyb2xsZWRfd2luZG93KTsKKworICAgIC8vIHRoZSB0cmVlCisgICAgaHR0cF9pbnNwZWN0 X3JlcXVlc3RzX2xpc3QgPSBndGtfdHJlZV92aWV3X25ldyAoKTsKKyAgICBndGtfdHJlZV92aWV3 X3NldF9oZWFkZXJzX3Zpc2libGUgKEdUS19UUkVFX1ZJRVcoaHR0cF9pbnNwZWN0X3JlcXVlc3Rz X2xpc3QpLCBGQUxTRSk7CisgICAgZ3RrX3RyZWVfdmlld19hcHBlbmRfY29sdW1uIChHVEtfVFJF RV9WSUVXKGh0dHBfaW5zcGVjdF9yZXF1ZXN0c19saXN0KSwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGd0a190cmVlX3ZpZXdfY29sdW1uX25ld193aXRoX2F0dHJpYnV0ZXMgKCJV UkkiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgZ3RrX2NlbGxfcmVuZGVyZXJfdGV4dF9uZXcoKSwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICJ0ZXh0IiwgMCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpKTsKKyAg ICBnX3NpZ25hbF9jb25uZWN0KGh0dHBfaW5zcGVjdF9yZXF1ZXN0c19saXN0LCAiY3Vyc29yLWNo YW5nZWQiLAorICAgICAgICAgICAgICAgICAgICAgR19DQUxMQkFDSyhodHRwX2luc3BlY3RfY3Vy c29yX2NoYW5nZWRfY2IpLCBOVUxMKTsKKyAgICBndGtfY29udGFpbmVyX2FkZCAoR1RLX0NPTlRB SU5FUihzY3JvbGxlZF93aW5kb3cpLCBodHRwX2luc3BlY3RfcmVxdWVzdHNfbGlzdCk7CisgICAg Z3RrX3dpZGdldF9zaG93IChodHRwX2luc3BlY3RfcmVxdWVzdHNfbGlzdCk7CisKKyAgICBodHRw X2luc3BlY3RfcmVxdWVzdHNfbW9kZWwgPSBndGtfbGlzdF9zdG9yZV9uZXcgKDIsIEdfVFlQRV9T VFJJTkcsIFdFQktJVF9UWVBFX05FVFdPUktfUkVRVUVTVCwgLTEpOworICAgIGd0a190cmVlX3Zp ZXdfc2V0X21vZGVsIChHVEtfVFJFRV9WSUVXKGh0dHBfaW5zcGVjdF9yZXF1ZXN0c19saXN0KSwg R1RLX1RSRUVfTU9ERUwoaHR0cF9pbnNwZWN0X3JlcXVlc3RzX21vZGVsKSk7CisKKyAgICAvLyBt b3JlIGxheW91dGluZywgZm9yIHRoZSByaWdodCBzaWRlIG9mIHRoZSB3aW5kb3cKKyAgICBHdGtX aWRnZXQqIHJ2Ym94ID0gZ3RrX3Zib3hfbmV3IChGQUxTRSwgMik7CisgICAgZ3RrX3BhbmVkX2Fk ZDIgKEdUS19QQU5FRChwYW5lZCksIHJ2Ym94KTsKKyAgICBndGtfd2lkZ2V0X3Nob3cgKHJ2Ym94 KTsKKworICAgIEd0a1dpZGdldCogdGFibGUgPSBndGtfdGFibGVfbmV3ICg4LCAyLCBGQUxTRSk7 CisgICAgZ3RrX3RhYmxlX3NldF9yb3dfc3BhY2luZ3MgKEdUS19UQUJMRSh0YWJsZSksIDEyKTsK KyAgICBndGtfYm94X3BhY2tfc3RhcnQgKEdUS19CT1gocnZib3gpLCB0YWJsZSwgRkFMU0UsIEZB TFNFLCAwKTsKKyAgICBndGtfd2lkZ2V0X3Nob3cgKHRhYmxlKTsKKworICAgIC8vIGRldGFpbHMg b2YgdGhlIHJlcXVlc3QKKyAgICAvLyBDYWNoZSBQb2xpY3kKKyAgICBHdGtXaWRnZXQqIGxhYmVs ID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJFTCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAibGFiZWwiLCAiPGI+Q2FjaGUgUG9saWN5PC9iPiIsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgInVzZS1tYXJrdXAiLCBUUlVFLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOworICAgIGd0a190YWJsZV9hdHRhY2hf ZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJsZSksIGxhYmVsLCAwLCAxLCAwLCAxKTsKKyAgICBndGtf d2lkZ2V0X3Nob3cobGFiZWwpOworCisgICAgaHR0cF9pbnNwZWN0X2NhY2hlX3BvbGljeV9sYWJl bCA9IGdfb2JqZWN0X25ldyAoR1RLX1RZUEVfTEFCRUwsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgImxhYmVsIiwgIiIsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIndyYXAiLCBUUlVFLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOwor ICAgIGd0a190YWJsZV9hdHRhY2hfZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJsZSksIGh0dHBfaW5z cGVjdF9jYWNoZV9wb2xpY3lfbGFiZWwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg MSwgMiwgMCwgMSk7CisgICAgZ3RrX3dpZGdldF9zaG93KGh0dHBfaW5zcGVjdF9jYWNoZV9wb2xp Y3lfbGFiZWwpOworCisgICAgLy8gVGltZW91dCBJbnRlcnZhbAorICAgIGxhYmVsID0gZ19vYmpl Y3RfbmV3IChHVEtfVFlQRV9MQUJFTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgImxhYmVs IiwgIjxiPlRpbWVvdXQgaW50ZXJ2YWw8L2I+IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg InVzZS1tYXJrdXAiLCBUUlVFLAorICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMKTsKKyAg ICBndGtfdGFibGVfYXR0YWNoX2RlZmF1bHRzIChHVEtfVEFCTEUodGFibGUpLCBsYWJlbCwgMCwg MSwgMSwgMik7CisgICAgZ3RrX3dpZGdldF9zaG93KGxhYmVsKTsKKworICAgIGh0dHBfaW5zcGVj dF90aW1lb3V0X2ludGVydmFsX2xhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJFTCwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ImxhYmVsIiwgIiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICJ3cmFwIiwgVFJVRSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7CisgICAgZ3RrX3RhYmxlX2F0dGFjaF9k ZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgaHR0cF9pbnNwZWN0X3RpbWVvdXRfaW50ZXJ2YWxf bGFiZWwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMSwgMiwgMSwgMik7CisgICAg Z3RrX3dpZGdldF9zaG93KGh0dHBfaW5zcGVjdF90aW1lb3V0X2ludGVydmFsX2xhYmVsKTsKKwor ICAgIC8vIE1haW4gZG9jdW1lbnQgVVJJCisgICAgbGFiZWwgPSBnX29iamVjdF9uZXcgKEdUS19U WVBFX0xBQkVMLAorICAgICAgICAgICAgICAgICAgICAgICAgICAibGFiZWwiLCAiPGI+TWFpbiBk b2N1bWVudCBVUkk8L2I+IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgInVzZS1tYXJrdXAi LCBUUlVFLAorICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMKTsKKyAgICBndGtfdGFibGVf YXR0YWNoX2RlZmF1bHRzIChHVEtfVEFCTEUodGFibGUpLCBsYWJlbCwgMCwgMSwgMiwgMyk7Cisg ICAgZ3RrX3dpZGdldF9zaG93KGxhYmVsKTsKKworICAgIGh0dHBfaW5zcGVjdF9tYWluX2RvY3Vt ZW50X3VyaV9sYWJlbCA9IGdfb2JqZWN0X25ldyAoR1RLX1RZUEVfTEFCRUwsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAibGFiZWwiLCAi IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICJ3cmFwIiwgVFJVRSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIE5VTEwpOworICAgIGd0a190YWJsZV9hdHRhY2hfZGVmYXVsdHMg KEdUS19UQUJMRSh0YWJsZSksIGh0dHBfaW5zcGVjdF9tYWluX2RvY3VtZW50X3VyaV9sYWJlbCwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxLCAyLCAyLCAzKTsKKyAgICBndGtfd2lk Z2V0X3Nob3coaHR0cF9pbnNwZWN0X21haW5fZG9jdW1lbnRfdXJpX2xhYmVsKTsKKworICAgIC8v IEhUVFAgbWV0aG9kCisgICAgbGFiZWwgPSBnX29iamVjdF9uZXcgKEdUS19UWVBFX0xBQkVMLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAibGFiZWwiLCAiPGI+TWV0aG9kPC9iPiIsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICJ1c2UtbWFya3VwIiwgVFJVRSwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgTlVMTCk7CisgICAgZ3RrX3RhYmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RLX1RB QkxFKHRhYmxlKSwgbGFiZWwsIDAsIDEsIDMsIDQpOworICAgIGd0a193aWRnZXRfc2hvdyhsYWJl bCk7CisKKyAgICBodHRwX2luc3BlY3RfbWV0aG9kX2xhYmVsID0gZ19vYmplY3RfbmV3IChHVEtf VFlQRV9MQUJFTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAibGFiZWwiLCAiIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAid3JhcCIsIFRSVUUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgTlVMTCk7CisgICAgZ3RrX3RhYmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RLX1RBQkxF KHRhYmxlKSwgaHR0cF9pbnNwZWN0X21ldGhvZF9sYWJlbCwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAxLCAyLCAzLCA0KTsKKyAgICBndGtfd2lkZ2V0X3Nob3coaHR0cF9pbnNwZWN0 X21ldGhvZF9sYWJlbCk7CisKKyAgICAvLyBIVFRQIENvbnRlbnQgVHlwZQorICAgIGxhYmVsID0g Z19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJFTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ImxhYmVsIiwgIjxiPkNvbnRlbnQgVHlwZTwvYj4iLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAidXNlLW1hcmt1cCIsIFRSVUUsCisgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOwor ICAgIGd0a190YWJsZV9hdHRhY2hfZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJsZSksIGxhYmVsLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDAsIDEsIDQsIDUpOworICAgIGd0a193aWRn ZXRfc2hvdyhsYWJlbCk7CisKKyAgICBodHRwX2luc3BlY3RfY29udGVudF90eXBlX2xhYmVsID0g Z19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJFTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAibGFiZWwiLCAiIiwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAid3JhcCIsIFRSVUUsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7CisgICAg Z3RrX3RhYmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgaHR0cF9pbnNwZWN0 X2NvbnRlbnRfdHlwZV9sYWJlbCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxLCAy LCA0LCA1KTsKKyAgICBndGtfd2lkZ2V0X3Nob3coaHR0cF9pbnNwZWN0X2NvbnRlbnRfdHlwZV9s YWJlbCk7CisKKyAgICAvLyBIVFRQIFJlZmVyZXIKKyAgICBsYWJlbCA9IGdfb2JqZWN0X25ldyAo R1RLX1RZUEVfTEFCRUwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICJsYWJlbCIsICI8Yj5S ZWZlcmVyPC9iPiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICJ1c2UtbWFya3VwIiwgVFJV RSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7CisgICAgZ3RrX3RhYmxlX2F0dGFj aF9kZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgbGFiZWwsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgMCwgMSwgNSwgNik7CisgICAgZ3RrX3dpZGdldF9zaG93KGxhYmVsKTsKKwor ICAgIGh0dHBfaW5zcGVjdF9yZWZlcmVyX2xhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9M QUJFTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAibGFi ZWwiLCAiIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IndyYXAiLCBUUlVFLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIE5VTEwpOworICAgIGd0a190YWJsZV9hdHRhY2hfZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJs ZSksIGh0dHBfaW5zcGVjdF9yZWZlcmVyX2xhYmVsLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIDEsIDIsIDUsIDYpOworICAgIGd0a193aWRnZXRfc2hvdyhodHRwX2luc3BlY3RfcmVm ZXJlcl9sYWJlbCk7CisKKyAgICAvLyBIVFRQIFVzZXIgQWdlbnQKKyAgICBsYWJlbCA9IGdfb2Jq ZWN0X25ldyAoR1RLX1RZUEVfTEFCRUwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICJsYWJl bCIsICI8Yj5Vc2VyIEFnZW50PC9iPiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICJ1c2Ut bWFya3VwIiwgVFJVRSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7CisgICAgZ3Rr X3RhYmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgbGFiZWwsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgMCwgMSwgNiwgNyk7CisgICAgZ3RrX3dpZGdldF9zaG93 KGxhYmVsKTsKKworICAgIGh0dHBfaW5zcGVjdF91c2VyX2FnZW50X2xhYmVsID0gZ19vYmplY3Rf bmV3IChHVEtfVFlQRV9MQUJFTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgImxhYmVsIiwgIiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICJ3cmFwIiwgVFJVRSwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7CisgICAgZ3RrX3RhYmxlX2F0dGFj aF9kZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgaHR0cF9pbnNwZWN0X3VzZXJfYWdlbnRfbGFi ZWwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMSwgMiwgNiwgNyk7CisgICAgZ3Rr X3dpZGdldF9zaG93KGh0dHBfaW5zcGVjdF91c2VyX2FnZW50X2xhYmVsKTsKKworICAgIC8vIEhU VFAgQWNjZXB0CisgICAgbGFiZWwgPSBnX29iamVjdF9uZXcgKEdUS19UWVBFX0xBQkVMLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAibGFiZWwiLCAiPGI+QWNjZXB0PC9iPiIsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICJ1c2UtbWFya3VwIiwgVFJVRSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgTlVMTCk7CisgICAgZ3RrX3RhYmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RLX1RBQkxF KHRhYmxlKSwgbGFiZWwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMCwgMSwgNywg OCk7CisgICAgZ3RrX3dpZGdldF9zaG93KGxhYmVsKTsKKworICAgIGh0dHBfaW5zcGVjdF9hY2Nl cHRfbGFiZWwgPSBnX29iamVjdF9uZXcgKEdUS19UWVBFX0xBQkVMLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJsYWJlbCIsICIiLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJ3cmFwIiwgVFJVRSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMKTsKKyAgICBndGtfdGFi bGVfYXR0YWNoX2RlZmF1bHRzIChHVEtfVEFCTEUodGFibGUpLCBodHRwX2luc3BlY3RfYWNjZXB0 X2xhYmVsLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDEsIDIsIDcsIDgpOworICAg IGd0a193aWRnZXRfc2hvdyhodHRwX2luc3BlY3RfYWNjZXB0X2xhYmVsKTsKKworICAgIC8vIEFs bG93IEhUVFAgQ29va2llcworICAgIGxhYmVsID0gZ19vYmplY3RfbmV3IChHVEtfVFlQRV9MQUJF TCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgImxhYmVsIiwgIjxiPkFsbG93IEhUVFAgQ29v a2llczwvYj4iLAorICAgICAgICAgICAgICAgICAgICAgICAgICAidXNlLW1hcmt1cCIsIFRSVUUs CisgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOworICAgIGd0a190YWJsZV9hdHRhY2hf ZGVmYXVsdHMgKEdUS19UQUJMRSh0YWJsZSksIGxhYmVsLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIDAsIDEsIDgsIDkpOworICAgIGd0a193aWRnZXRfc2hvdyhsYWJlbCk7CisKKyAg ICBodHRwX2luc3BlY3RfYWxsb3dfaHR0cF9jb29raWVzX2xhYmVsID0gZ19vYmplY3RfbmV3IChH VEtfVFlQRV9MQUJFTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAibGFiZWwiLCAiIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAid3JhcCIsIFRSVUUsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7Cisg ICAgZ3RrX3RhYmxlX2F0dGFjaF9kZWZhdWx0cyAoR1RLX1RBQkxFKHRhYmxlKSwgaHR0cF9pbnNw ZWN0X2FsbG93X2h0dHBfY29va2llc19sYWJlbCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAxLCAyLCA3LCA4KTsKKyAgICBndGtfd2lkZ2V0X3Nob3coaHR0cF9pbnNwZWN0X2FjY2Vw dF9sYWJlbCk7CisKKyAgICAvLyBoZWFkZXJzIGxpc3RpbmcKKyAgICBHdGtXaWRnZXQqIGV4cGFu ZGVyID0gZ3RrX2V4cGFuZGVyX25ldyAoIkhlYWRlcnMuLi4iKTsKKyAgICBndGtfYm94X3BhY2tf c3RhcnQgKEdUS19CT1gocnZib3gpLCBleHBhbmRlciwgRkFMU0UsIEZBTFNFLCAwKTsKKyAgICBn dGtfd2lkZ2V0X3Nob3cgKGV4cGFuZGVyKTsKKworICAgIHNjcm9sbGVkX3dpbmRvdyA9IGd0a19z Y3JvbGxlZF93aW5kb3dfbmV3IChOVUxMLCBOVUxMKTsKKyAgICBndGtfc2Nyb2xsZWRfd2luZG93 X3NldF9wb2xpY3kgKEdUS19TQ1JPTExFRF9XSU5ET1coc2Nyb2xsZWRfd2luZG93KSwgR1RLX1BP TElDWV9BVVRPTUFUSUMsIEdUS19QT0xJQ1lfQVVUT01BVElDKTsKKyAgICBndGtfd2lkZ2V0X3Nl dF9zaXplX3JlcXVlc3QgKHNjcm9sbGVkX3dpbmRvdywgLTEsIDE4MCk7CisgICAgZ3RrX2NvbnRh aW5lcl9hZGQgKEdUS19DT05UQUlORVIoZXhwYW5kZXIpLCBzY3JvbGxlZF93aW5kb3cpOworICAg IGd0a193aWRnZXRfc2hvdyAoc2Nyb2xsZWRfd2luZG93KTsKKworICAgIGh0dHBfaW5zcGVjdF9o ZWFkZXJzX2xpc3QgPSBndGtfdHJlZV92aWV3X25ldyAoKTsKKyAgICBndGtfdHJlZV92aWV3X2Fw cGVuZF9jb2x1bW4gKEdUS19UUkVFX1ZJRVcoaHR0cF9pbnNwZWN0X2hlYWRlcnNfbGlzdCksCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBndGtfdHJlZV92aWV3X2NvbHVtbl9uZXdf d2l0aF9hdHRyaWJ1dGVzICgiSGVhZGVyIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGd0a19jZWxsX3Jl bmRlcmVyX3RleHRfbmV3ICgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgInRleHQiLCAwLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgTlVMTCkpOworICAgIGd0a190cmVlX3ZpZXdfYXBwZW5kX2NvbHVtbiAoR1RL X1RSRUVfVklFVyhodHRwX2luc3BlY3RfaGVhZGVyc19saXN0KSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGd0a190cmVlX3ZpZXdfY29sdW1uX25ld193aXRoX2F0dHJpYnV0ZXMg KCJWYWx1ZSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBndGtfY2VsbF9yZW5kZXJlcl90ZXh0X25ldyAo KSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICJ0ZXh0IiwgMSwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwp KTsKKyAgICBndGtfY29udGFpbmVyX2FkZCAoR1RLX0NPTlRBSU5FUihzY3JvbGxlZF93aW5kb3cp LCBodHRwX2luc3BlY3RfaGVhZGVyc19saXN0KTsKKyAgICBndGtfd2lkZ2V0X3Nob3cgKGh0dHBf aW5zcGVjdF9oZWFkZXJzX2xpc3QpOworCisgICAgaHR0cF9pbnNwZWN0X2hlYWRlcnNfbW9kZWwg PSBndGtfbGlzdF9zdG9yZV9uZXcgKDIsIEdfVFlQRV9TVFJJTkcsIEdfVFlQRV9TVFJJTkcpOwor ICAgIGd0a190cmVlX3ZpZXdfc2V0X21vZGVsIChHVEtfVFJFRV9WSUVXKGh0dHBfaW5zcGVjdF9o ZWFkZXJzX2xpc3QpLCBHVEtfVFJFRV9NT0RFTChodHRwX2luc3BlY3RfaGVhZGVyc19tb2RlbCkp OworCisgICAgLy8gcmVxdWVzdCBib2R5CisgICAgR3RrV2lkZ2V0KiBmcmFtZSA9IGd0a19mcmFt ZV9uZXcgKCJCb2R5Iik7CisgICAgZ3RrX2JveF9wYWNrX3N0YXJ0IChHVEtfQk9YKHJ2Ym94KSwg ZnJhbWUsIFRSVUUsIFRSVUUsIDApOworICAgIGd0a193aWRnZXRfc2hvdyAoZnJhbWUpOworCisg ICAgc2Nyb2xsZWRfd2luZG93ID0gZ3RrX3Njcm9sbGVkX3dpbmRvd19uZXcgKE5VTEwsIE5VTEwp OworICAgIGd0a19zY3JvbGxlZF93aW5kb3dfc2V0X3BvbGljeSAoR1RLX1NDUk9MTEVEX1dJTkRP VyhzY3JvbGxlZF93aW5kb3cpLCBHVEtfUE9MSUNZX0FVVE9NQVRJQywgR1RLX1BPTElDWV9BVVRP TUFUSUMpOworICAgIGd0a19jb250YWluZXJfYWRkIChHVEtfQ09OVEFJTkVSKGZyYW1lKSwgc2Ny b2xsZWRfd2luZG93KTsKKyAgICBndGtfd2lkZ2V0X3Nob3cgKHNjcm9sbGVkX3dpbmRvdyk7CisK KyAgICBodHRwX2luc3BlY3RfYm9keV90ZXh0X3ZpZXcgPSBndGtfdGV4dF92aWV3X25ldyAoKTsK KyAgICBndGtfY29udGFpbmVyX2FkZCAoR1RLX0NPTlRBSU5FUihzY3JvbGxlZF93aW5kb3cpLCBo dHRwX2luc3BlY3RfYm9keV90ZXh0X3ZpZXcpOworICAgIGd0a193aWRnZXRfc2hvdyAoaHR0cF9p bnNwZWN0X2JvZHlfdGV4dF92aWV3KTsKKworICAgIHJldHVybiB3aW5kb3c7Cit9CisKIHN0YXRp YyBHdGtXaWRnZXQqCiBjcmVhdGVfYnJvd3NlciAoKQogewpAQCAtMTE5LDYgKzQ5Niw5IEBAIGNy ZWF0ZV9icm93c2VyICgpCiAgICAgZ19zaWduYWxfY29ubmVjdCAoR19PQkpFQ1QgKHdlYl92aWV3 KSwgImxvYWQtcHJvZ3Jlc3MtY2hhbmdlZCIsIEdfQ0FMTEJBQ0sgKHByb2dyZXNzX2NoYW5nZV9j YiksIHdlYl92aWV3KTsKICAgICBnX3NpZ25hbF9jb25uZWN0IChHX09CSkVDVCAod2ViX3ZpZXcp LCAibG9hZC1jb21taXR0ZWQiLCBHX0NBTExCQUNLIChsb2FkX2NvbW1pdF9jYiksIHdlYl92aWV3 KTsKICAgICBnX3NpZ25hbF9jb25uZWN0IChHX09CSkVDVCAod2ViX3ZpZXcpLCAiaG92ZXJpbmct b3Zlci1saW5rIiwgR19DQUxMQkFDSyAobGlua19ob3Zlcl9jYiksIHdlYl92aWV3KTsKKyAgICBn X3NpZ25hbF9jb25uZWN0IChHX09CSkVDVCAod2ViX3ZpZXcpLCAibmF2aWdhdGlvbi1yZXF1ZXN0 ZWQiLCBHX0NBTExCQUNLIChuYXZpZ2F0aW9uX3JlcXVlc3RlZF9jYiksIHdlYl92aWV3KTsKKyAg ICBnX3NpZ25hbF9jb25uZWN0IChHX09CSkVDVCAod2ViX3ZpZXcpLCAicmVxdWVzdC1zdGFydGVk IiwgR19DQUxMQkFDSyAocmVxdWVzdF9zdGFydGVkX2NiKSwgd2ViX3ZpZXcpOworICAgIGdfc2ln bmFsX2Nvbm5lY3QgKEdfT0JKRUNUICh3ZWJfdmlldyksICJyZXF1ZXN0LXJlZGlyZWN0ZWQiLCBH X0NBTExCQUNLIChyZXF1ZXN0X3JlZGlyZWN0ZWRfY2IpLCB3ZWJfdmlldyk7CiAKICAgICByZXR1 cm4gc2Nyb2xsZWRfd2luZG93OwogfQpAQCAtMTUyLDYgKzUzMiwxMSBAQCBjcmVhdGVfdG9vbGJh ciAoKQogICAgIGdfc2lnbmFsX2Nvbm5lY3QgKEdfT0JKRUNUIChpdGVtKSwgImNsaWNrZWQiLCBH X0NBTExCQUNLIChnb19mb3J3YXJkX2NiKSwgTlVMTCk7CiAgICAgZ3RrX3Rvb2xiYXJfaW5zZXJ0 IChHVEtfVE9PTEJBUiAodG9vbGJhciksIGl0ZW0sIC0xKTsKIAorICAgIC8qIFRoZSBodHRwIGlu c3BlY3QgYnV0dG9uICovCisgICAgaXRlbSA9IGd0a190b29sX2J1dHRvbl9uZXdfZnJvbV9zdG9j ayAoR1RLX1NUT0NLX05FVFdPUkspOworICAgIGdfc2lnbmFsX2Nvbm5lY3QgKEdfT0JKRUNUIChp dGVtKSwgImNsaWNrZWQiLCBHX0NBTExCQUNLIChzaG93X2h0dHBfaW5zcGVjdF93aW5kb3dfY2Ip LCBOVUxMKTsKKyAgICBndGtfdG9vbGJhcl9pbnNlcnQgKEdUS19UT09MQkFSICh0b29sYmFyKSwg aXRlbSwgLTEpOworCiAgICAgLyogVGhlIFVSTCBlbnRyeSAqLwogICAgIGl0ZW0gPSBndGtfdG9v bF9pdGVtX25ldyAoKTsKICAgICBndGtfdG9vbF9pdGVtX3NldF9leHBhbmQgKGl0ZW0sIFRSVUUp OwpAQCAtMTkyLDYgKzU3Nyw4IEBAIG1haW4gKGludCBhcmdjLCBjaGFyKiBhcmd2W10pCiAgICAg bWFpbl93aW5kb3cgPSBjcmVhdGVfd2luZG93ICgpOwogICAgIGd0a19jb250YWluZXJfYWRkIChH VEtfQ09OVEFJTkVSIChtYWluX3dpbmRvdyksIHZib3gpOwogCisgICAgaHR0cF9pbnNwZWN0X3dp bmRvdyA9IGNyZWF0ZV9odHRwX2luc3BlY3Rfd2luZG93ICgpOworCiAgICAgZ2NoYXIqIHVyaSA9 IChnY2hhciopIChhcmdjID4gMSA/IGFyZ3ZbMV0gOiAiaHR0cDovL3d3dy5nb29nbGUuY29tLyIp OwogICAgIHdlYmtpdF93ZWJfdmlld19vcGVuICh3ZWJfdmlldywgdXJpKTsKIAo= 22531 2008-07-28 17:38:51 -0700 2008-07-29 19:07:30 -0700 proposed patch network-request.diff text/plain 46157 gustavo ZGlmZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0NoYW5nZUxvZwppbmRleCA5NDA4ZGViLi5jN2MxY2M2 IDEwMDY0NAotLS0gYS9DaGFuZ2VMb2cKKysrIGIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTEgQEAK KzIwMDgtMDUtMTEgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGduc0Bnbm9tZS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKwlBZGRlZCBuZXcgZmlsZSB0byB0 aGUgR1RLKyBidWlsZDogd2Via2l0bmV0d29ya3Jlc3BvbnNlLmNwcC4KKyAgICAgICAgCisJKiBH TlVtYWtlZmlsZS5hbToKKwogMjAwOC0wNi0xOCAgTWFyY28gQmFyaXNpb25lICA8bWFyY28uYmFy aXNpb25lQGNvbGxhYm9yYS5jby51az4KIAogICAgICAgICBSZXZpZXdlZCBieSBBbHAgVG9rZXIu CmRpZmYgLS1naXQgYS9HTlVtYWtlZmlsZS5hbSBiL0dOVW1ha2VmaWxlLmFtCmluZGV4IGE2YWUy OTkuLjI2YjAzN2UgMTAwNjQ0Ci0tLSBhL0dOVW1ha2VmaWxlLmFtCisrKyBiL0dOVW1ha2VmaWxl LmFtCkBAIC0zMzcsNiArMzM3LDcgQEAgd2Via2l0Z3RrX2hlYWRlcnMgKz0gXAogCiB3ZWJraXRn dGtfc291cmNlcyArPSBcCiAJV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3Qu Y3BwIFwKKwlXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuY3BwIFwKIAlX ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcCBcCiAJV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0dmVyc2lvbi5jcHAgXAogCVdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmJhY2tmb3J3 YXJkbGlzdC5jcHAgXApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQv Z3RrL0NoYW5nZUxvZwppbmRleCBmMDU3NDlmLi4wNDcwYTczIDEwMDY0NAotLS0gYS9XZWJLaXQv Z3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwpAQCAtMSwzICsxLDYwIEBA CisyMDA4LTA1LTExICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxnbnNAZ25vbWUub3JnPgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisJaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTE4NjA4CisgICAgICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0 IG5lZWRzIHRvIGJlIGZpbmlzaGVkCisKKwlHT2JqZWN0IGltcGxlbWVudGF0aW9uIGV4cG9zaW5n IFJlc291cmNlUmVxdWVzdCwgYW5kIGluaXRpYWwKKwlpbXBsZW1lbnRhdGlvbiBleHBvc2luZyBS ZXNvdXJjZVJlc3BvbnNlLiBGcmFtZUxvYWRlckNsaWVudEd0ayBpcworCW5vdyB1c2luZyBXZWJL aXROZXR3b3JrUmVxdWVzdCB3aGVuIGl0IG5lZWRzIHRvIGRlYWwgd2l0aCByZXF1ZXN0CisJaW5m b3JtYXRpb24uIAorCisgICAgICAgICogQ2hhbmdlTG9nOgorICAgICAgICAqIFdlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcDoKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2Fk ZXJDbGllbnQ6OmRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlvbkFjdGlvbik6CisgICAg ICAgICogd2Via2l0L3dlYmtpdC5oOgorICAgICAgICAqIHdlYmtpdC93ZWJraXRkZWZpbmVzLmg6 CisgICAgICAgICogd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcDoKKyAgICAgICAgKF9X ZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZmluYWxp emUpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6Y2FjaGVfcG9saWN5 X2Zyb21fcmVzb3VyY2VfcmVxdWVzdCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQ cml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld19mcm9tX3Jlc291cmNlX3JlcXVlc3Qp OgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtf cmVxdWVzdF9nZXRfcmVzb3VyY2VfcmVxdWVzdCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1Jl cXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF91cmkpOgorICAgICAgICAo X1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRf dXJpKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3 b3JrX3JlcXVlc3Rfc2V0X2NhY2hlX3BvbGljeSk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1Jl cXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9jYWNoZV9wb2xpY3kpOgor ICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVx dWVzdF9zZXRfdGltZW91dF9pbnRlcnZhbCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVl c3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF90aW1lb3V0X2ludGVydmFsKToK KyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3Jl cXVlc3Rfc2V0X21haW5fZG9jdW1lbnRfdXJpKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVx dWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X21haW5fZG9jdW1lbnRfdXJp KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3Jr X3JlcXVlc3Rfc2V0X2h0dHBfbWV0aG9kKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVz dFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfbWV0aG9kKToKKyAgICAg ICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OmNvcHlfaGVhZGVyKToKKyAgICAgICAg KF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfYWRk X2h0dHBfaGVhZGVycyk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRlcnMpOgorICAgICAgICAoX1dlYktp dE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9hZGRfaHR0cF9o ZWFkZXIpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25l dHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9oZWFkZXIpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtS ZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9oZWFkZXIpOgor ICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVx dWVzdF9zZXRfYm9keSk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9ib2R5KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3Jr UmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2FsbG93X2h0dHBfY29v a2llcyk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X2dldF9hbGxvd19odHRwX2Nvb2tpZXMpOgorICAgICAgICAqIHdlYmtpdC93 ZWJraXRuZXR3b3JrcmVxdWVzdC5oOgorICAgICAgICAqIHdlYmtpdC93ZWJraXRuZXR3b3JrcmVz cG9uc2UuY3BwOiBBZGRlZC4KKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRl Ojp3ZWJraXRfbmV0d29ya19yZXNwb25zZV9maW5hbGl6ZSk6CisgICAgICAgIChfV2ViS2l0TmV0 d29ya1Jlc3BvbnNlUHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVzcG9uc2VfY2xhc3NfaW5pdCk6 CisgICAgICAgIChfV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZTo6d2Via2l0X25ldHdvcmtf cmVzcG9uc2VfaW5pdCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZTo6 d2Via2l0X25ldHdvcmtfcmVzcG9uc2VfbmV3X2Zyb21fcmVzb3VyY2VfcmVzcG9uc2UpOgorICAg ICAgICAoX1dlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3Jlc3Bv bnNlX2dldF9yZXNvdXJjZV9yZXNwb25zZSk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1Jlc3Bv bnNlUHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVzcG9uc2VfbmV3KToKKyAgICAgICAgKF9XZWJL aXROZXR3b3JrUmVzcG9uc2VQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXNwb25zZV9zZXRfdXJp KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlOjp3ZWJraXRfbmV0d29y a19yZXNwb25zZV9nZXRfdXJpKToKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0bmV0d29ya3Jlc3Bv bnNlLmg6IEFkZGVkLgorICAgICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmg6CisgICAgICAg ICogd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2Vi dmlldy5jcHA6CisKIDIwMDgtMDctMTcgIENocmlzdGlhbiBEeXdhbiAgPGNocmlzdGlhbkB0d290 b2FzdHMuZGU+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgSG9sZ2VyIEZyZXl0aGVyLgpkaWZmIC0t Z2l0IGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAg Yi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAppbmRl eCBlYTc5ZTk5Li43YTIxMDRkIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAorKysgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcApAQCAtNDQsNiArNDQsOCBAQAogI2luY2x1ZGUgIlNj cmlwdENvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJ3ZWJraXR3ZWJ2aWV3LmgiCiAjaW5jbHVkZSAi d2Via2l0d2ViZnJhbWUuaCIKKyNpbmNsdWRlICJ3ZWJraXRuZXR3b3JrcmVxdWVzdC5oIgorI2lu Y2x1ZGUgIndlYmtpdG5ldHdvcmtyZXNwb25zZS5oIgogI2luY2x1ZGUgIndlYmtpdHByaXZhdGUu aCIKIAogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0FQSUNhc3QuaD4KQEAgLTIwMCw3ICsyMDIs NyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERpZENhbmNlbEF1dGhlbnRpY2F0 aW9uQ2hhbGxlbmdlKERvY3VtZW50TG9hZGVyKgogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAK LXZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoV2lsbFNlbmRSZXF1ZXN0KERvY3VtZW50 TG9hZGVyKiwgdW5zaWduZWQgbG9uZywgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgUmVzb3VyY2VS ZXNwb25zZSYpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaFdpbGxTZW5kUmVxdWVz dChEb2N1bWVudExvYWRlciosIHVuc2lnbmVkIGxvbmcsIFJlc291cmNlUmVxdWVzdCYgcmVzb3Vy Y2VSZXF1ZXN0LCBjb25zdCBSZXNvdXJjZVJlc3BvbnNlJiByZXNvdXJjZVJlc3BvbnNlKQogewog ICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CkBAIC0yNjgsNyArMjcwLDggQEAgdm9pZCBGcmFtZUxv YWRlckNsaWVudDo6ZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JOYXZpZ2F0aW9uQWN0aW9uKEZyYW1l UG9saWN5RnVuY3QKICAgICAgICAgcmV0dXJuOwogCiAgICAgV2ViS2l0V2ViVmlldyogd2ViVmll dyA9IGdldFZpZXdGcm9tRnJhbWUobV9mcmFtZSk7Ci0gICAgV2ViS2l0TmV0d29ya1JlcXVlc3Qq IHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ldyhyZXNvdXJjZVJlcXVlc3QudXJs KCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisgICAgUmVzb3VyY2VSZXF1ZXN0IHJlcXVlc3RD b3B5ID0gcmVzb3VyY2VSZXF1ZXN0OworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0 ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfZnJvbV9yZXNvdXJjZV9yZXF1ZXN0KHJlcXVl c3RDb3B5KTsKICAgICBXZWJLaXROYXZpZ2F0aW9uUmVzcG9uc2UgcmVzcG9uc2U7CiAKICAgICBn X3NpZ25hbF9lbWl0X2J5X25hbWUod2ViVmlldywgIm5hdmlnYXRpb24tcmVxdWVzdGVkIiwgbV9m cmFtZSwgcmVxdWVzdCwgJnJlc3BvbnNlKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0 L3dlYmtpdC5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0LmgKaW5kZXggMTBjMjE0Zi4uOTBh Y2Y4ZiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0LmgKKysrIGIvV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0LmgKQEAgLTIzLDYgKzIzLDcgQEAKICNpbmNsdWRlIDx3ZWJraXQv d2Via2l0dmVyc2lvbi5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRkZWZpbmVzLmg+CiAjaW5j bHVkZSA8d2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0Lmg+CisjaW5jbHVkZSA8d2Via2l0L3dl YmtpdG5ldHdvcmtyZXNwb25zZS5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJmcmFtZS5o PgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJzZXR0aW5ncy5oPgogI2luY2x1ZGUgPHdlYmtp dC93ZWJraXR3ZWJ2aWV3Lmg+CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRk ZWZpbmVzLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRkZWZpbmVzLmgKaW5kZXggMzg2YzNl MS4uMzM5ODFlMCAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZGVmaW5lcy5o CisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRlZmluZXMuaApAQCAtNDMsNiArNDMsOSBA QCBHX0JFR0lOX0RFQ0xTCiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0TmV0d29ya1JlcXVlc3QgV2Vi S2l0TmV0d29ya1JlcXVlc3Q7CiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0TmV0d29ya1JlcXVlc3RD bGFzcyBXZWJLaXROZXR3b3JrUmVxdWVzdENsYXNzOwogCit0eXBlZGVmIHN0cnVjdCBfV2ViS2l0 TmV0d29ya1Jlc3BvbnNlIFdlYktpdE5ldHdvcmtSZXNwb25zZTsKK3R5cGVkZWYgc3RydWN0IF9X ZWJLaXROZXR3b3JrUmVzcG9uc2VDbGFzcyBXZWJLaXROZXR3b3JrUmVzcG9uc2VDbGFzczsKKwog dHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFdlYkJhY2tGb3J3YXJkTGlzdCBXZWJLaXRXZWJCYWNrRm9y d2FyZExpc3Q7CiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0V2ViQmFja0ZvcndhcmRMaXN0Q2xhc3Mg V2ViS2l0V2ViQmFja0ZvcndhcmRMaXN0Q2xhc3M7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dG5ldHdvcmtyZXF1ZXN0LmNwcAppbmRleCBmYWIwZjg4Li40MjBiNjAwIDEwMDY0NAotLS0gYS9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKKysrIGIvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwCkBAIC0xLDUgKzEsNiBAQAogLyoKICAq IENvcHlyaWdodCAoQykgMjAwNyBIb2xnZXIgSGFucyBQZXRlciBGcmV5dGhlcgorICogQ29weXJp Z2h0IChDKSAyMDA4IEd1c3Rhdm8gTm9yb25oYSBTaWx2YQogICoKICAqIFRoaXMgbGlicmFyeSBp cyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlm eSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCkBA IC0yMCwzMCArMjEsMTcxIEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAKICNpbmNsdWRlICJ3ZWJr aXRuZXR3b3JrcmVxdWVzdC5oIgorI2luY2x1ZGUgIndlYmtpdGVudW10eXBlcy5oIgorI2luY2x1 ZGUgIndlYmtpdHByaXZhdGUuaCIKKworI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjaW5j bHVkZSAiUmVzb3VyY2VSZXF1ZXN0LmgiCisjaW5jbHVkZSAiQ1N0cmluZy5oIgorCit1c2luZyBu YW1lc3BhY2UgV2ViQ29yZTsKK3VzaW5nIG5hbWVzcGFjZSBXZWJLaXQ7CiAKIGV4dGVybiAiQyIg ewogCitlbnVtIHsKKyAgICBQUk9QXzAsCisKKyAgICBQUk9QX1VSSSwKKyAgICBQUk9QX0NBQ0hF X1BPTElDWSwKKyAgICBQUk9QX1RJTUVPVVRfSU5URVJWQUwsCisgICAgUFJPUF9NQUlOX0RPQ1VN RU5UX1VSSSwKKyAgICBQUk9QX0hUVFBfTUVUSE9ELAorICAgIFBST1BfQUxMT1dfSFRUUF9DT09L SUVTLAorfTsKKwogR19ERUZJTkVfVFlQRShXZWJLaXROZXR3b3JrUmVxdWVzdCwgd2Via2l0X25l dHdvcmtfcmVxdWVzdCwgR19UWVBFX09CSkVDVCk7CiAKIHN0cnVjdCBfV2ViS2l0TmV0d29ya1Jl cXVlc3RQcml2YXRlIHsKKyAgICBSZXNvdXJjZVJlcXVlc3QgcmVxdWVzdDsKKwogICAgIGdjaGFy KiB1cmk7CisgICAgZ2NoYXIqIG1haW5Eb2N1bWVudFVSSTsKKyAgICBnY2hhciogaHR0cE1ldGhv ZDsKKyAgICBnY2hhciAqYm9keTsKKyAgICBnc3NpemUgYm9keVNpemU7CisKKyAgICBHSGFzaFRh YmxlICpodHRwSGVhZGVyczsKIH07CiAKICNkZWZpbmUgV0VCS0lUX05FVFdPUktfUkVRVUVTVF9H RVRfUFJJVkFURShvYmopIChHX1RZUEVfSU5TVEFOQ0VfR0VUX1BSSVZBVEUoKG9iaiksIFdFQktJ VF9UWVBFX05FVFdPUktfUkVRVUVTVCwgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKSkKIAor c3RhdGljIHZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfcHJvcGVydHkoR09iamVjdCog b2JqZWN0LCBndWludCBwcm9wX2lkLCBHVmFsdWUqIHZhbHVlLCBHUGFyYW1TcGVjKiBwc3BlYykK K3sKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IFdFQktJVF9ORVRXT1JLX1JF UVVFU1Qob2JqZWN0KTsKKworICAgIHN3aXRjaChwcm9wX2lkKSB7CisgICAgY2FzZSBQUk9QX1VS SToKKyAgICAgICAgZ192YWx1ZV9zZXRfc3RyaW5nKHZhbHVlLCB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X2dldF91cmkocmVxdWVzdCkpOworICAgICAgICBicmVhazsKKyAgICBjYXNlIFBST1BfQ0FD SEVfUE9MSUNZOgorICAgICAgICBnX3ZhbHVlX3NldF9lbnVtKHZhbHVlLCB3ZWJraXRfbmV0d29y a19yZXF1ZXN0X2dldF9jYWNoZV9wb2xpY3kocmVxdWVzdCkpOworICAgICAgICBicmVhazsKKyAg ICBjYXNlIFBST1BfVElNRU9VVF9JTlRFUlZBTDoKKyAgICAgICAgZ192YWx1ZV9zZXRfZG91Ymxl KHZhbHVlLCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF90aW1lb3V0X2ludGVydmFsKHJlcXVl c3QpKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBQUk9QX01BSU5fRE9DVU1FTlRfVVJJOgor ICAgICAgICBnX3ZhbHVlX3NldF9zdHJpbmcodmFsdWUsIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf Z2V0X21haW5fZG9jdW1lbnRfdXJpKHJlcXVlc3QpKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2Fz ZSBQUk9QX0hUVFBfTUVUSE9EOgorICAgICAgICBnX3ZhbHVlX3NldF9zdHJpbmcodmFsdWUsIHdl YmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfbWV0aG9kKHJlcXVlc3QpKTsKKyAgICAgICAg YnJlYWs7CisgICAgY2FzZSBQUk9QX0FMTE9XX0hUVFBfQ09PS0lFUzoKKyAgICAgICAgZ192YWx1 ZV9zZXRfYm9vbGVhbih2YWx1ZSwgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfYWxsb3dfaHR0 cF9jb29raWVzKHJlcXVlc3QpKTsKKyAgICBkZWZhdWx0OgorICAgICAgICBHX09CSkVDVF9XQVJO X0lOVkFMSURfUFJPUEVSVFlfSUQob2JqZWN0LCBwcm9wX2lkLCBwc3BlYyk7CisgICAgfQorfQor CitzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9wcm9wZXJ0eShHT2JqZWN0 KiBvYmplY3QsIGd1aW50IHByb3BfaWQsIGNvbnN0IEdWYWx1ZSogdmFsdWUsIEdQYXJhbVNwZWMg KnBzcGVjKQoreworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gV0VCS0lUX05F VFdPUktfUkVRVUVTVChvYmplY3QpOworCisgICAgc3dpdGNoKHByb3BfaWQpIHsKKyAgICBjYXNl IFBST1BfVVJJOgorICAgICAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF91cmkocmVxdWVz dCwgZ192YWx1ZV9nZXRfc3RyaW5nKHZhbHVlKSk7CisgICAgICAgIGJyZWFrOworICAgIGNhc2Ug UFJPUF9DQUNIRV9QT0xJQ1k6CisgICAgICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2Nh Y2hlX3BvbGljeShyZXF1ZXN0LCAoV2ViS2l0UmVxQ2FjaGVQb2xpY3kpZ192YWx1ZV9nZXRfZW51 bSh2YWx1ZSkpOworICAgICAgICBicmVhazsKKyAgICBjYXNlIFBST1BfVElNRU9VVF9JTlRFUlZB TDoKKyAgICAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdGltZW91dF9pbnRlcnZhbChy ZXF1ZXN0LCBnX3ZhbHVlX2dldF9kb3VibGUodmFsdWUpKTsKKyAgICAgICAgYnJlYWs7CisgICAg Y2FzZSBQUk9QX01BSU5fRE9DVU1FTlRfVVJJOgorICAgICAgICB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X3NldF9tYWluX2RvY3VtZW50X3VyaShyZXF1ZXN0LCBnX3ZhbHVlX2dldF9zdHJpbmcodmFs dWUpKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBQUk9QX0hUVFBfTUVUSE9EOgorICAgICAg ICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX21ldGhvZChyZXF1ZXN0LCBnX3ZhbHVl X2dldF9zdHJpbmcodmFsdWUpKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBQUk9QX0FMTE9X X0hUVFBfQ09PS0lFUzoKKyAgICAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfYWxsb3df aHR0cF9jb29raWVzKHJlcXVlc3QsIGdfdmFsdWVfZ2V0X2Jvb2xlYW4odmFsdWUpKTsKKyAgICAg ICAgYnJlYWs7CisgICAgZGVmYXVsdDoKKyAgICAgICAgR19PQkpFQ1RfV0FSTl9JTlZBTElEX1BS T1BFUlRZX0lEKG9iamVjdCwgcHJvcF9pZCwgcHNwZWMpOworICAgIH0KK30KKwogc3RhdGljIHZv aWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9maW5hbGl6ZShHT2JqZWN0KiBvYmplY3QpCiB7CiAg ICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSBXRUJLSVRfTkVUV09SS19SRVFVRVNU KG9iamVjdCk7CiAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVz dC0+cHJpdjsKIAogICAgIGdfZnJlZShwcml2LT51cmkpOworICAgIGdfZnJlZShwcml2LT5tYWlu RG9jdW1lbnRVUkkpOworICAgIGdfZnJlZShwcml2LT5odHRwTWV0aG9kKTsKKyAgICBnX2ZyZWUo cHJpdi0+Ym9keSk7CisKKyAgICBpZihwcml2LT5odHRwSGVhZGVycykKKyAgICAgICAgZ19oYXNo X3RhYmxlX2Rlc3Ryb3kocHJpdi0+aHR0cEhlYWRlcnMpOwogCiAgICAgR19PQkpFQ1RfQ0xBU1Mo d2Via2l0X25ldHdvcmtfcmVxdWVzdF9wYXJlbnRfY2xhc3MpLT5maW5hbGl6ZShvYmplY3QpOwog fQogCiBzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2NsYXNzX2luaXQoV2ViS2l0 TmV0d29ya1JlcXVlc3RDbGFzcyogcmVxdWVzdENsYXNzKQogewotICAgIEdfT0JKRUNUX0NMQVNT KHJlcXVlc3RDbGFzcyktPmZpbmFsaXplID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9maW5hbGl6 ZTsKKyAgICBHT2JqZWN0Q2xhc3MqIG9iamVjdENsYXNzID0gR19PQkpFQ1RfQ0xBU1MocmVxdWVz dENsYXNzKTsKKworICAgIG9iamVjdENsYXNzLT5maW5hbGl6ZSA9IHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZmluYWxpemU7CisgICAgb2JqZWN0Q2xhc3MtPmdldF9wcm9wZXJ0eSA9IHdlYmtpdF9u ZXR3b3JrX3JlcXVlc3RfZ2V0X3Byb3BlcnR5OworICAgIG9iamVjdENsYXNzLT5zZXRfcHJvcGVy dHkgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9wcm9wZXJ0eTsKKworICAgIC8qCisgICAg ICogcHJvcGVydGllcworICAgICAqLworICAgIGdfb2JqZWN0X2NsYXNzX2luc3RhbGxfcHJvcGVy dHkob2JqZWN0Q2xhc3MsIFBST1BfVVJJLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgZ19wYXJhbV9zcGVjX3N0cmluZygidXJpIiwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIlVSSSIsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJUaGUgVVJJIGZvciB0aGlz IHJlcXVlc3QiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBOVUxMLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBXRUJLSVRfUEFSQU1fUkVBRFdSSVRFKSk7CisKKyAgICBnX29iamVj dF9jbGFzc19pbnN0YWxsX3Byb3BlcnR5KG9iamVjdENsYXNzLCBQUk9QX0NBQ0hFX1BPTElDWSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdfcGFyYW1fc3BlY19lbnVtKCJj YWNoZS1wb2xpY3kiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIkNhY2hlIFBvbGljeSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAiV2hldGhlciBhbmQgaG93IHRoaXMgcmVxdWVzdCBz aG91bGQgdXNlIGRhdGEgZnJvbSB0aGUgY2FjaGUiLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0VCS0lUX1RZUEVfUkVRX0NBQ0hFX1BPTElD WSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX1BST1RPQ09MLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0VCS0lUX1BBUkFNX1JFQURXUklURSkp OworCisgICAgZ19vYmplY3RfY2xhc3NfaW5zdGFsbF9wcm9wZXJ0eShvYmplY3RDbGFzcywgUFJP UF9USU1FT1VUX0lOVEVSVkFMLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg Z19wYXJhbV9zcGVjX2RvdWJsZSgidGltZW91dC1pbnRlcnZhbCIsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJUaW1lb3V0IEludGVydmFs IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIkhvdyBsb25nIHRvIHdhaXQgYmVmb3JlIHRoZSByZXF1ZXN0IHRpbWVzIG91dCIsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDAuMCwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg R19NQVhET1VCTEUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIDYwLjAsIC8vIHRha2VuIGZyb20gUmVzb3VyY2VSZXF1ZXN0QmFzZS5oCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdF QktJVF9QQVJBTV9SRUFEV1JJVEUpKTsKKworICAgIGdfb2JqZWN0X2NsYXNzX2luc3RhbGxfcHJv cGVydHkob2JqZWN0Q2xhc3MsIFBST1BfTUFJTl9ET0NVTUVOVF9VUkksCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBnX3BhcmFtX3NwZWNfc3RyaW5nKCJtYWluLWRvY3VtZW50 LXVyaSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICJNYWluIERvY3VtZW50IFVSSSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICJUaGUgVVJJIG9mIHRoZSBtYWluIGRvY3VtZW50 IHRoYXQgaXMgYmVpbmcgcmVuZGVyZWQiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRfUEFSQU1fUkVBRFdSSVRFKSk7 CisKKyAgICBnX29iamVjdF9jbGFzc19pbnN0YWxsX3Byb3BlcnR5KG9iamVjdENsYXNzLCBQUk9Q X0hUVFBfTUVUSE9ELAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ19wYXJh bV9zcGVjX3N0cmluZygiaHR0cC1tZXRob2QiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiSFRUUCBNZXRob2QiLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiVGhlIEhUVFAgbWV0 aG9kIHRoaXMgcmVxdWVzdCB1c2VzIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0VCS0lUX1BBUkFNX1JFQURXUklURSkpOwor CisgICAgZ19vYmplY3RfY2xhc3NfaW5zdGFsbF9wcm9wZXJ0eShvYmplY3RDbGFzcywgUFJPUF9B TExPV19IVFRQX0NPT0tJRVMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBn X3BhcmFtX3NwZWNfYm9vbGVhbigiYWxsb3ctaHR0cC1jb29raWVzIiwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJBbGxvdyBIVFRQIENv b2tpZXMiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIldoZXRoZXIgY29va2llcyBhcmUgdG8gYmUgYWxsb3dlZCBmb3IgdGhpcyByZXF1 ZXN0IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIFRSVUUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBXRUJLSVRfUEFSQU1fUkVBRFdSSVRFKSk7CiAKICAgICBnX3R5cGVfY2xh c3NfYWRkX3ByaXZhdGUocmVxdWVzdENsYXNzLCBzaXplb2YoV2ViS2l0TmV0d29ya1JlcXVlc3RQ cml2YXRlKSk7CiB9CkBAIC01NCwxOCArMTk2LDUxIEBAIHN0YXRpYyB2b2lkIHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfaW5pdChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKICAgICByZXF1 ZXN0LT5wcml2ID0gcHJpdjsKIH0KIAotV2ViS2l0TmV0d29ya1JlcXVlc3QqIHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfbmV3KGNvbnN0IGdjaGFyKiB1cmkpCisvLyBmb3IgaW50ZXJuYWwgdXNlIG9u bHkKK1dlYktpdE5ldHdvcmtSZXF1ZXN0KiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld19mcm9t X3Jlc291cmNlX3JlcXVlc3QoUmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3QpCiB7Ci0g ICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwodXJpLCBOVUxMKTsKLQogICAgIFdlYktpdE5ldHdvcmtS ZXF1ZXN0KiByZXF1ZXN0ID0gV0VCS0lUX05FVFdPUktfUkVRVUVTVChnX29iamVjdF9uZXcoV0VC S0lUX1RZUEVfTkVUV09SS19SRVFVRVNULCBOVUxMKSk7CiAgICAgV2ViS2l0TmV0d29ya1JlcXVl c3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKIAotICAgIHByaXYtPnVyaSA9IGdfc3Ry ZHVwKHVyaSk7CisgICAgcHJpdi0+cmVxdWVzdCA9IHJlc291cmNlUmVxdWVzdDsKIAogICAgIHJl dHVybiByZXF1ZXN0OwogfQogCisvLyBmb3IgaW50ZXJuYWwgdXNlIG9ubHkKK1Jlc291cmNlUmVx dWVzdCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9yZXNvdXJjZV9yZXF1ZXN0KGNvbnN0IFdl YktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0 UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICByZXR1cm4gcHJpdi0+cmVxdWVz dDsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ldzoKKyAqIEB1cmk6IGFu IFVSSQorICoKKyAqIENyZWF0ZXMgYSBuZXcgI1dlYktpdE5ldHdvcmtSZXF1ZXN0IGluaXRpYWxp emVkIHdpdGggYW4gVVJJLgorICoKKyAqIFJldHVybnM6IGEgbmV3ICNXZWJLaXROZXR3b3JrUmVx dWVzdAorICovCitXZWJLaXROZXR3b3JrUmVxdWVzdCogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9u ZXcoY29uc3QgZ2NoYXIqIHVyaSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbCh1cmksIE5V TEwpOworICAgIAorICAgIFJlc291cmNlUmVxdWVzdCByZXNvdXJjZVJlcXVlc3QgPSBSZXNvdXJj ZVJlcXVlc3QoS1VSTChTdHJpbmc6OmZyb21VVEY4KHVyaSkpKTsKKworICAgIFdlYktpdE5ldHdv cmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfZnJvbV9yZXNv dXJjZV9yZXF1ZXN0KHJlc291cmNlUmVxdWVzdCk7CisKKyAgICByZXR1cm4gcmVxdWVzdDsKK30K KworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF91cmk6CisgKiBAcmVxdWVzdDog YSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEB1cmk6IGFuIGFscmVhZHkgZW5jb2RlZCBVUkkK KyAqCisgKiBTZXRzIHRoZSBVUkkgaGVsZCBhbmQgdXNlZCBieSB0aGUgZ2l2ZW4gcmVxdWVzdC4K KyAqLwogdm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF91cmkoV2ViS2l0TmV0d29ya1Jl cXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiB1cmkpCiB7CiAgICAgZ19yZXR1cm5faWZfZmFp bChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpKTsKQEAgLTc0LDE1ICsyNDksNDI2 IEBAIHZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpKFdlYktpdE5ldHdvcmtSZXF1 ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhcioKICAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZh dGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OwogCiAgICAgZ19mcmVlKHByaXYtPnVyaSk7Ci0gICAg cHJpdi0+dXJpID0gZ19zdHJkdXAodXJpKTsKKyAgICBwcml2LT5yZXF1ZXN0LnNldFVSTChLVVJM KFN0cmluZzo6ZnJvbVVURjgodXJpKSkpOworICAgIGdfb2JqZWN0X25vdGlmeShHX09CSkVDVChy ZXF1ZXN0KSwgInVyaSIpOwogfQogCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0 X3VyaToKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICoKKyAqIEdldHMg dGhlIFVSSSBoZWxkIGFuZCB1c2VkIGJ5IHRoZSBnaXZlbiByZXF1ZXN0LgorICoKKyAqIFJldHVy bnM6IHRoZSBVUkkgaGVsZCBhbmQgdXNlZCBieSB0aGUgZ2l2ZW4gcmVxdWVzdAorICovCiBHX0NP TlNUX1JFVFVSTiBnY2hhciogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJpKFdlYktpdE5l dHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQogewogICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJ VF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOwogCiAgICAgV2ViS2l0TmV0d29y a1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIGlmIChwcml2LT51 cmkpCisgICAgICAgIHJldHVybiBwcml2LT51cmk7CisKKyAgICBwcml2LT51cmkgPSBnX3N0cmR1 cChwcml2LT5yZXF1ZXN0LnVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworICAgIHJldHVy biBwcml2LT51cmk7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfY2Fj aGVfcG9saWN5OgorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CisgKiBAY2Fj aGVfcG9saWN5OiBhICNXZWJLaXRSZXFDYWNoZVBvbGljeQorICoKKyAqIERlZmluZXMgdGhlIHBv bGljeSBXZWJLaXQgc2hvdWxkIHVzZSB3aGVuIGhhbmRsaW5nIHRoZSByZXF1ZXN0LAorICogc3Vj aCBhcyBpZiBpdCBpcyBhbGxvd2VkIHRvIHVzZSB0aGUgbG9jYWwgY2FjaGUsIGlmIHRoZSBIVFRQ CisgKiBjYWNoaW5nIHJ1bGVzIHNob3VsZCBiZSB1c2VkLCBvciBpZiB3ZSBhcmUgZm9yY2luZyBh IHJlbG9hZC4KKyAqLwordm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9jYWNoZV9wb2xp Y3koV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IFdlYktpdFJlcUNhY2hlUG9s aWN5IGNhY2hlX3BvbGljeSkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRX T1JLX1JFUVVFU1QocmVxdWVzdCkpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRl KiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIHByaXYtPnJlcXVlc3Quc2V0Q2FjaGVQb2xp Y3koY29yZShjYWNoZV9wb2xpY3kpKTsKKyAgICBnX29iamVjdF9ub3RpZnkoR19PQkpFQ1QocmVx dWVzdCksICJjYWNoZS1wb2xpY3kiKTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X2dldF9jYWNoZV9wb2xpY3k6CisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVl c3QKKyAqCisgKiBPYnRhaW5zIHRoZSBwb2xpY3kgV2ViS2l0IHdvdWxkIHVzZSB3aGVuIGhhbmRs aW5nIHRoZSByZXF1ZXN0LCBzdWNoCisgKiBhcyBpZiBpdCBpcyBhbGxvd2VkIHRvIHVzZSB0aGUg bG9jYWwgY2FjaGUsIGlmIHRoZSBIVFRQIGNhY2hpbmcKKyAqIHJ1bGVzIHNob3VsZCBiZSB1c2Vk LCBvciBpZiB3ZSBhcmUgZm9yY2luZyBhIHJlbG9hZC4KKyAqCisgKiBSZXR1cm5zOiBhICNXZWJL aXRSZXFDYWNoZVBvbGljeQorICovCitXZWJLaXRSZXFDYWNoZVBvbGljeSB3ZWJraXRfbmV0d29y a19yZXF1ZXN0X2dldF9jYWNoZV9wb2xpY3koV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3Qp Cit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChy ZXF1ZXN0KSwgV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfUFJPVE9DT0wpOworCisgICAgV2ViS2l0 TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIHJldHVy biBraXQocHJpdi0+cmVxdWVzdC5jYWNoZVBvbGljeSgpKTsKK30KKworLyoqCisgKiB3ZWJraXRf bmV0d29ya19yZXF1ZXN0X3NldF90aW1lb3V0X2ludGVydmFsOgorICogQHJlcXVlc3Q6IGEgI1dl YktpdE5ldHdvcmtSZXF1ZXN0CisgKiBAdGltZW91dF9pbnRlcnZhbDogYSAjZ2RvdWJsZQorICoK KyAqIFNldHMgaG93IG1hbnkgc2Vjb25kcyBXZWJLaXQgd291bGQgd2FpdCBmb3IgdGhlIHNlcnZl ciB3aGVuCisgKiBoYW5kbGluZyB0aGUgZ2l2ZW4gcmVxdWVzdC4KKyAqLwordm9pZCB3ZWJraXRf bmV0d29ya19yZXF1ZXN0X3NldF90aW1lb3V0X2ludGVydmFsKFdlYktpdE5ldHdvcmtSZXF1ZXN0 KiByZXF1ZXN0LCBjb25zdCBnZG91YmxlIHRpbWVvdXRfaW50ZXJ2YWwpCit7CisgICAgZ19yZXR1 cm5faWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpKTsKKworICAgIFdl YktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBw cml2LT5yZXF1ZXN0LnNldFRpbWVvdXRJbnRlcnZhbCh0aW1lb3V0X2ludGVydmFsKTsKKyAgICBn X29iamVjdF9ub3RpZnkoR19PQkpFQ1QocmVxdWVzdCksICJjYWNoZS1wb2xpY3kiKTsKK30KKwor LyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF90aW1lb3V0X2ludGVydmFsOgorICog QHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CisgKgorICogR2V0cyBob3cgbWFueSBz ZWNvbmRzIFdlYktpdCB3b3VsZCB3YWl0IGZvciB0aGUgc2VydmVyIHdoZW4KKyAqIGhhbmRsaW5n IHRoZSBnaXZlbiByZXF1ZXN0LgorICoKKyAqIFJldHVybnM6IGEgI2dkb3VibGUKKyAqLworZ2Rv dWJsZSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF90aW1lb3V0X2ludGVydmFsKFdlYktpdE5l dHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJ VF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIDAuMCk7CisKKyAgICBXZWJLaXROZXR3b3Jr UmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgcmV0dXJuIChnZG91 YmxlKXByaXYtPnJlcXVlc3QudGltZW91dEludGVydmFsKCk7Cit9CisKKy8qKgorICogd2Via2l0 X25ldHdvcmtfcmVxdWVzdF9zZXRfbWFpbl9kb2N1bWVudF91cmkKKyAqIEByZXF1ZXN0OiBhICNX ZWJLaXROZXR3b3JrUmVxdWVzdAorICogQG1haW5fZG9jdW1lbnRfdXJpOiB0aGUgVVJJIG9mIHRo ZSBtYWluIGRvY3VtZW50CisgKgorICogU2V0cyB0aGUgbWFpbiBkb2N1bWVudCBVUkkuCisgKgor ICogVGhlIG1haW4gZG9jdW1lbnQgaXMgdGhlIGRvY3VtZW50IHRoYXQgaXMgYmVpbmcgcmVuZGVy ZWQ7IG90aGVyCisgKiBkb2N1bWVudHMsIGJlIHRoZW0gSFRNTCBwYWdlcywgamF2YXNjcmlwdCBv ciBjc3MgZmlsZXMsIGltYWdlcywgYW5kCisgKiBzbyBvbiBtYXkgYmUgbmVjZXNzYXJ5LCBhbmQg dGhlIHJlcXVlc3RzIHRoYXQgZmV0Y2ggdGhvc2Ugc2hhbGwKKyAqIGhhdmUgdGhpcyBVUkkgc2V0 IHRvIHRoZSBkb2N1bWVudCB3aGljaCByZXF1aXJlcyB0aGVtLgorICovCit2b2lkIHdlYmtpdF9u ZXR3b3JrX3JlcXVlc3Rfc2V0X21haW5fZG9jdW1lbnRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0 KiByZXF1ZXN0LCBjb25zdCBnY2hhciogbWFpbl9kb2N1bWVudF91cmkpCit7CisgICAgZ19yZXR1 cm5faWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpKTsKKyAgICBnX3Jl dHVybl9pZl9mYWlsKG1haW5fZG9jdW1lbnRfdXJpKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1 ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBnX2ZyZWUocHJpdi0+bWFp bkRvY3VtZW50VVJJKTsKKyAgICBwcml2LT5yZXF1ZXN0LnNldE1haW5Eb2N1bWVudFVSTChLVVJM KFN0cmluZzo6ZnJvbVVURjgobWFpbl9kb2N1bWVudF91cmkpKSk7CisgICAgZ19vYmplY3Rfbm90 aWZ5KEdfT0JKRUNUKHJlcXVlc3QpLCAibWFpbi1kb2N1bWVudC11cmkiKTsKK30KKworLyoqCisg KiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9tYWluX2RvY3VtZW50X3VyaQorICogQHJlcXVl c3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CisgKgorICogT2J0YWlucyB0aGUgbWFpbiBkb2N1 bWVudCBVUkkuCisgKgorICogVGhlIG1haW4gZG9jdW1lbnQgaXMgdGhlIGRvY3VtZW50IHRoYXQg aXMgYmVpbmcgcmVuZGVyZWQ7IG90aGVyCisgKiBkb2N1bWVudHMsIGJlIHRoZW0gSFRNTCBwYWdl cywgamF2YXNjcmlwdCBvciBjc3MgZmlsZXMsIGltYWdlcywgYW5kCisgKiBzbyBvbiBtYXkgYmUg bmVjZXNzYXJ5LCBhbmQgdGhlIHJlcXVlc3RzIHRoYXQgZmV0Y2ggdGhvc2Ugc2hhbGwKKyAqIGhh dmUgdGhpcyBVUkkgc2V0IHRvIHRoZSBkb2N1bWVudCB3aGljaCByZXF1aXJlcyB0aGVtLgorICoK KyAqIFJldHVybnM6IGEgc3RyaW5nIHdpdGggdGhlIG1haW4gZG9jdW1lbnQgVVJJCisgKi8KK2Nv bnN0IGdjaGFyKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9tYWluX2RvY3VtZW50X3VyaShX ZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFp bChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKKworICAgIFdlYktp dE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBpZiAo cHJpdi0+dXJpKQorICAgICAgICByZXR1cm4gcHJpdi0+dXJpOworCisgICAgcHJpdi0+dXJpID0g Z19zdHJkdXAocHJpdi0+cmVxdWVzdC5tYWluRG9jdW1lbnRVUkwoKS5zdHJpbmcoKS51dGY4KCku ZGF0YSgpKTsKICAgICByZXR1cm4gcHJpdi0+dXJpOwogfQogCisvKioKKyAqIHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3Rfc2V0X2h0dHBfbWV0aG9kCisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29y a1JlcXVlc3QKKyAqIEBodHRwX21ldGhvZDogdGhlIEhUVFAgbWV0aG9kCisgKgorICogRGVmaW5l cyB3aGF0IG1ldGhvZCwgc3VjaCBhcyBHRVQsIFBPU1QsIEhFQUQsIGFuZCBzbyBvbiwgd291bGQg YmUKKyAqIHVzZWQgYnkgV2ViS2l0IHdoZW4gdGFsa2luZyB0byB0aGUgd2Vic2VydmVyIGR1cmlu ZyB0aGlzIHJlcXVlc3QuCisgKi8KK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0 cF9tZXRob2QoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRw X21ldGhvZCkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVF U1QocmVxdWVzdCkpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwoaHR0cF9tZXRob2QpOworCisgICAg V2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAg IGdfZnJlZShwcml2LT5odHRwTWV0aG9kKTsKKyAgICBwcml2LT5yZXF1ZXN0LnNldEhUVFBNZXRo b2QoU3RyaW5nOjpmcm9tVVRGOChodHRwX21ldGhvZCkpOworICAgIGdfb2JqZWN0X25vdGlmeShH X09CSkVDVChyZXF1ZXN0KSwgImh0dHAtbWV0aG9kIik7Cit9CisKKy8qKgorICogd2Via2l0X25l dHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9tZXRob2QKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3 b3JrUmVxdWVzdAorICoKKyAqIE9idGFpbnMgd2hhdCBtZXRob2QsIHN1Y2ggYXMgR0VULCBQT1NU LCBIRUFELCBhbmQgc28gb24sIHdvdWxkIGJlCisgKiB1c2VkIGJ5IFdlYktpdCB3aGVuIHRhbGtp bmcgdG8gdGhlIHdlYnNlcnZlciBkdXJpbmcgdGhpcyByZXF1ZXN0LgorICoKKyAqIFJldHVybnM6 IGEgc3RyaW5nIHdpdGggdGhlIG5hbWUgb2YgdGhlIG1ldGhvZAorICovCitjb25zdCBnY2hhciog d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9tZXRob2QoV2ViS2l0TmV0d29ya1JlcXVl c3QqIHJlcXVlc3QpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdP UktfUkVRVUVTVChyZXF1ZXN0KSwgTlVMTCk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFBy aXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgaWYgKHByaXYtPmh0dHBNZXRob2Qp CisgICAgICAgIHJldHVybiBwcml2LT5odHRwTWV0aG9kOworCisgICAgcHJpdi0+aHR0cE1ldGhv ZCA9IGdfc3RyZHVwKHByaXYtPnJlcXVlc3QuaHR0cE1ldGhvZCgpLnV0ZjgoKS5kYXRhKCkpOwor ICAgIHJldHVybiBwcml2LT5odHRwTWV0aG9kOworfQorCitzdGF0aWMgdm9pZCBjb3B5X2hlYWRl cihjb25zdCBnY2hhcioga2V5LCBjb25zdCBnY2hhciogdmFsdWUsIGdwb2ludGVyIGRhdGEpCit7 CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSAoV2ViS2l0TmV0d29ya1JlcXVl c3QqKWRhdGE7CisKKyAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2FkZF9odHRwX2hlYWRlcihy ZXF1ZXN0LCBrZXksIHZhbHVlKTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X2FkZF9odHRwX2hlYWRlcnMKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAor ICogQGh0dHBfaGVhZGVyczogYSAjR0hhc2hUYWJsZSB3aXRoIGhlYWRlci92YWx1ZSBwYWlycywg YXMgc3RyaW5ncworICoKKyAqIEFkZHMgdGhlIGhlYWRlcnMgY29udGFpbmVkIGJ5IHRoZSBnaXZl biBoYXNoIHRhYmxlIHRvIHRoZQorICogcmVxdWVzdC4gU2VlIHdlYmtpdF9uZXR3b3JrX3JlcXVl c3RfYWRkX2h0dHBfaGVhZGVyKCkuCisgKi8KK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9h ZGRfaHR0cF9oZWFkZXJzKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBHSGFz aFRhYmxlKiBodHRwX2hlYWRlcnMpCit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNf TkVUV09SS19SRVFVRVNUKHJlcXVlc3QpKTsKKyAgICBnX3JldHVybl9pZl9mYWlsKGh0dHBfaGVh ZGVycyk7CisKKyAgICBnX2hhc2hfdGFibGVfZm9yZWFjaCgoR0hhc2hUYWJsZSopaHR0cF9oZWFk ZXJzLCAoR0hGdW5jKWNvcHlfaGVhZGVyLCByZXF1ZXN0KTsKK30KKworc3RhdGljIEdIYXNoVGFi bGUqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfcHJpdmF0ZV9nZXRfaHR0cF9oZWFkZXJzKFdlYktp dE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJp dmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBpZihwcml2LT5odHRwSGVhZGVycykK KyAgICAgICAgcmV0dXJuIHByaXYtPmh0dHBIZWFkZXJzOworCisgICAgcHJpdi0+aHR0cEhlYWRl cnMgPSBnX2hhc2hfdGFibGVfbmV3X2Z1bGwoZ19zdHJfaGFzaCwgZ19zdHJfZXF1YWwsIGdfZnJl ZSwgZ19mcmVlKTsKKyAgICBIVFRQSGVhZGVyTWFwIGhlYWRlcnMgPSBwcml2LT5yZXF1ZXN0Lmh0 dHBIZWFkZXJGaWVsZHMoKTsKKyAgICBpZiAoIWhlYWRlcnMuaXNFbXB0eSgpKSB7CisgICAgICAg IEhUVFBIZWFkZXJNYXA6OmNvbnN0X2l0ZXJhdG9yIGVuZCA9IGhlYWRlcnMuZW5kKCk7CisgICAg ICAgIGZvciAoSFRUUEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBoZWFkZXJzLmJlZ2lu KCk7IGl0ICE9IGVuZDsgKytpdCkKKyAgICAgICAgICAgIGdfaGFzaF90YWJsZV9pbnNlcnQocHJp di0+aHR0cEhlYWRlcnMsIChncG9pbnRlcilnX3N0cmR1cChpdC0+Zmlyc3QudXRmOCgpLmRhdGEo KSksIChncG9pbnRlcilnX3N0cmR1cChpdC0+c2Vjb25kLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICB9 CisKKyAgICByZXR1cm4gcHJpdi0+aHR0cEhlYWRlcnM7Cit9CisKKy8qKgorICogd2Via2l0X25l dHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9oZWFkZXJzCisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0 d29ya1JlcXVlc3QKKyAqIFJldHVybnM6IGEgI0dIYXNoVGFibGUgd2l0aCB0aGUgaGVhZGVycwor ICoKKyAqIE9idGFpbnMgYSByZWFkLW9ubHkgaGFzaCB0YWJsZSB3aXRoIHRoZSBoZWFkZXJzIGZv ciB0aGUgZ2l2ZW4KKyAqICNXZWJLaXROZXR3b3JrUmVxdWVzdC4KKyAqLworY29uc3QgR0hhc2hU YWJsZSogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9oZWFkZXJzKFdlYktpdE5ldHdv cmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9J U19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOworCisgICAgcmV0dXJuIHdlYmtpdF9u ZXR3b3JrX3JlcXVlc3RfcHJpdmF0ZV9nZXRfaHR0cF9oZWFkZXJzKHJlcXVlc3QpOworfQorCisv KioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfYWRkX2h0dHBfaGVhZGVyCisgKiBAcmVxdWVz dDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEBodHRwX2hlYWRlcjogYSBzdHJpbmcgd2l0 aCB0aGUgbmFtZSBvZiB0aGUgaGVhZGVyCisgKiBAdmFsdWU6IGEgc3RyaW5nIHdpdGggdGhlIHZh bHVlIG9mIHRoZSBoZWFkZXIKKyAqCisgKiBBZGRzIHRoZSBIVFRQIGhlYWRlciB0byB0aGUgcmVx dWVzdC4gSGVhZGVycyB3aGljaCBhbHJlYWR5IGV4aXN0IGluCisgKiB0aGUgcmVxdWVzdCB3aWxs IGhhdmUgdGhlaXIgdmFsdWUgYXBwZW5kZWQgdG8sIHdpdGggYSBzZXBhcmF0ZWQKKyAqIGNvbW1h LgorICoKKyAqIEZvciBpbnN0YW5jZTogaWYgdGhlIHJlcXVlc3QgYWxyZWFkeSBoYXMgYSBYLU1p c2MgaGVhZGVyIHdpdGggYQorICogdmFsdWUgb2YgImdvLCB3ZWJraXQhIiwgYW5kIHdlIGFkZCB0 aGUgc2FtZSBYLU1pc2MgaGVhZGVyCisgKiBjb250YWluaW5nICJnbyEiIHdlIHdpbGwgZW5kIHVw IGhhdmluZyBhIHNpbmdsZSBYLU1pc2MgaGVhZGVyIHdpdGgKKyAqIGEgdmFsdWUgb2YgImdvLCB3 ZWJraXQhLGdvISIuCisgKi8KK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9hZGRfaHR0cF9o ZWFkZXIoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX2hl YWRlciwgY29uc3QgZ2NoYXIqIHZhbHVlKQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lU X0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CisgICAgZ19yZXR1cm5faWZfZmFpbChodHRw X2hlYWRlcik7CisgICAgZ19yZXR1cm5faWZfZmFpbCh2YWx1ZSk7CisKKyAgICBXZWJLaXROZXR3 b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworICAgIEdIYXNoVGFibGUq IGhhc2hfdGFibGUgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3ByaXZhdGVfZ2V0X2h0dHBfaGVh ZGVycyhyZXF1ZXN0KTsKKworICAgIGdwb2ludGVyIGtleV9sb29rdXA7CisKKyAgICBrZXlfbG9v a3VwID0gZ19oYXNoX3RhYmxlX2xvb2t1cChoYXNoX3RhYmxlLCBodHRwX2hlYWRlcik7CisgICAg aWYgKCFrZXlfbG9va3VwKQorICAgICAgICBnX2hhc2hfdGFibGVfaW5zZXJ0KGhhc2hfdGFibGUs IChncG9pbnRlcilnX3N0cmR1cChodHRwX2hlYWRlciksIChncG9pbnRlcilnX3N0cmR1cCh2YWx1 ZSkpOworICAgIGVsc2UgeworICAgICAgICBnY2hhciogbmV3X3ZhbHVlID0gZ19zdHJkdXBfcHJp bnRmKCIlcywlcyIsIChnY2hhciopa2V5X2xvb2t1cCwgdmFsdWUpOworICAgICAgICBnX2hhc2hf dGFibGVfcmVwbGFjZShoYXNoX3RhYmxlLCAoZ3BvaW50ZXIpZ19zdHJkdXAoaHR0cF9oZWFkZXIp LCAoZ3BvaW50ZXIpZ19zdHJkdXAobmV3X3ZhbHVlKSk7CisgICAgICAgIGdfZnJlZShuZXdfdmFs dWUpOworICAgIH0KKworICAgIHByaXYtPnJlcXVlc3QuYWRkSFRUUEhlYWRlckZpZWxkKFN0cmlu Zzo6ZnJvbVVURjgoaHR0cF9oZWFkZXIpLCBTdHJpbmc6OmZyb21VVEY4KHZhbHVlKSk7Cit9CisK Ky8qKgorICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9oZWFkZXIKKyAqIEByZXF1 ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICogQGh0dHBfaGVhZGVyOiBhIHN0cmluZyB3 aXRoIHRoZSBuYW1lIG9mIHRoZSBoZWFkZXIKKyAqIEB2YWx1ZTogYSBzdHJpbmcgd2l0aCB0aGUg dmFsdWUgb2YgdGhlIGhlYWRlcgorICoKKyAqIFNldHMgdGhlIGhlYWRlciB0byBjb250YWluIHRo ZSBnaXZlbiB2YWx1ZSwgaW4gdGhpcyByZXF1ZXN0LiBJZiB0aGUKKyAqIGhlYWRlciBhbHJlYWR5 IGV4aXN0cyBpbiB0aGUgcmVxdWVzdCB0aGUgdmFsdWUgaXMgcmVwbGFjZWQuCisgKi8KK3ZvaWQg d2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9oZWFkZXIoV2ViS2l0TmV0d29ya1JlcXVl c3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX2hlYWRlciwgY29uc3QgZ2NoYXIqIHZhbHVl KQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1 ZXN0KSk7CisgICAgZ19yZXR1cm5faWZfZmFpbChodHRwX2hlYWRlcik7CisgICAgZ19yZXR1cm5f aWZfZmFpbCh2YWx1ZSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYg PSByZXF1ZXN0LT5wcml2OworICAgIEdIYXNoVGFibGUqIGhlYWRlcnMgPSB3ZWJraXRfbmV0d29y a19yZXF1ZXN0X3ByaXZhdGVfZ2V0X2h0dHBfaGVhZGVycyhyZXF1ZXN0KTsKKworICAgIGdfaGFz aF90YWJsZV9yZXBsYWNlKGhlYWRlcnMsIGdfc3RyZHVwKGh0dHBfaGVhZGVyKSwgZ19zdHJkdXAo dmFsdWUpKTsKKyAgICAKKyAgICBwcml2LT5yZXF1ZXN0LnNldEhUVFBIZWFkZXJGaWVsZChTdHJp bmc6OmZyb21VVEY4KGh0dHBfaGVhZGVyKSwgU3RyaW5nOjpmcm9tVVRGOCh2YWx1ZSkpOworfQor CisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfaGVhZGVyCisgKiBAcmVx dWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEBodHRwX2hlYWRlcjogdGhlIG5hbWUg b2YgdGhlIGhlYWRlciB3ZSB3YW50IHRvIG9idGFpbiB0aGUgdmFsdWUgZm9yCisgKgorICogR2V0 cyB0aGUgdmFsdWUgb2YgdGhlIHRoZSBoZWFkZXIgaW4gdGhlIGdpdmVuIHJlcXVlc3QuIElmIHRo ZQorICogaGVhZGVyIGRvZXMgbm90IGV4aXN0IGluIHRoZSByZXF1ZXN0ICVOVUxMIGlzIHJldHVy bmVkLgorICoKKyAqIFJldHVybnM6IGEgc3RyaW5nIHdpdGggdGhlIHZhbHVlIGZvciB0aGUgaGVh ZGVyLCBvciBOVUxMIGlmIHRoYXQKKyAqIGhlYWRlciBpcyBub3Qgc2V0IGZvciB0aGUgcmVxdWVz dAorICovCitjb25zdCBnY2hhciogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9oZWFk ZXIoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX2hlYWRl cikKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNU KHJlcXVlc3QpLCBOVUxMKTsKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChodHRwX2hlYWRlciwg TlVMTCk7CisKKyAgICBHSGFzaFRhYmxlKiBoZWFkZXJzID0gd2Via2l0X25ldHdvcmtfcmVxdWVz dF9wcml2YXRlX2dldF9odHRwX2hlYWRlcnMocmVxdWVzdCk7CisKKyAgICByZXR1cm4gKGNvbnN0 IGdjaGFyKilnX2hhc2hfdGFibGVfbG9va3VwKGhlYWRlcnMsIChnY29uc3Rwb2ludGVyKWh0dHBf aGVhZGVyKTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9ib2R5Cisg KiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEBib2R5OiB0aGUgZGF0YSB0 aGF0IHNob3VsZCBiZSBzZW50IGFzIHRoZSBib2R5IGZvciB0aGlzIHJlcXVlc3QKKyAqIEBsZW5n dGg6IHNpemUgb2YgdGhlIGRhdGEKKyAqCisgKiBTZXRzIHRoZSBib2R5IG9mIHRoZSByZXF1ZXN0 IHRvIHRoZSBjb250ZW50cyBvZiB0aGUgZ2l2ZW4KKyAqIHN0cmluZy4gWW91IHdpbGwgYWxzbyBw cm9iYWJseSBuZWVkIHRvIGNhbGwKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2hlYWRl cigpIHRvIHNwZWNpZnkgdGhlIENvbnRlbnQtTGVuZ3RoCisgKiBoZWFkZXIuCisgKi8KK3ZvaWQg d2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfYm9keShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVx dWVzdCwgY29uc3QgZ2NoYXIqIGJvZHksIGNvbnN0IGdzaXplIHNpemUpCit7CisgICAgZ19yZXR1 cm5faWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpKTsKKyAgICBnX3Jl dHVybl9pZl9mYWlsKGJvZHkpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBw cml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIGdfZnJlZShwcml2LT5ib2R5KTsKKyAgICBwcml2 LT5ib2R5U2l6ZSA9IDA7CisgICAgcHJpdi0+cmVxdWVzdC5zZXRIVFRQQm9keShGb3JtRGF0YTo6 Y3JlYXRlKChjb25zdCB2b2lkKilib2R5LCAoc2l6ZV90KXNpemUpKTsKK30KKworLyoqCisgKiB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9ib2R5CisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0 d29ya1JlcXVlc3QKKyAqIEBib2R5X3NpemU6IGEgcG9pbnRlciB0byBhICNnc2l6ZSwgb3IgJU5V TEwKKyAqCisgKiBHZXRzIHRoZSBib2R5IG9mIHRoZSByZXF1ZXN0LiBJZiBnaXZlbiwgQGJvZHlf c2l6ZSB3aWxsIGJlIHNldCB0bworICogdGhlIHNpemUgb2YgdGhlIGJvZHkgZGF0YS4gVGhpcyBp cyB1c2VmdWwgYmVjYXVzZSB0aGUgYm9keSBtYXkgbm90CisgKiBiZSBhIHN0cmluZywgYW5kIG1h eSBoYXZlIGEgbnVtYmVyIG9mICdcMCcgY2hhcmFjdGVycyBhcyBwYXJ0IG9mCisgKiB0aGUgZGF0 YS4KKyAqCisgKiBSZXR1cm5zOiBhIHN0cmluZyB3aXRoIHRoZSBib2R5IG9mIHRoZSByZXF1ZXN0 IG9yICVOVUxMIGlmIHRoZQorICogcmVxdWVzdCBkb2VzIG5vdCBoYXZlIGEgYm9keQorICovCitj b25zdCBnY2hhciogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfYm9keShXZWJLaXROZXR3b3Jr UmVxdWVzdCogcmVxdWVzdCwgZ3NpemUgKmJvZHlfc2l6ZSkKK3sKKyAgICBnX3JldHVybl92YWxf aWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKKworICAg IFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAg ICBpZiAoZ19hc2NpaV9zdHJjYXNlY21wICh3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRw X21ldGhvZChyZXF1ZXN0KSwgIlBPU1QiKSA9PSAwKSB7CisgICAgICAgIGlmKCFwcml2LT5ib2R5 KSB7CisgICAgICAgICAgICBWZWN0b3I8Y2hhcj4gZGF0YTsKKyAgICAgICAgICAgIHByaXYtPnJl cXVlc3QuaHR0cEJvZHkoKS0+ZmxhdHRlbihkYXRhKTsKKyAgICAgICAgICAgIHByaXYtPmJvZHkg PSBnX3N0cmR1cChkYXRhLmRhdGEoKSk7CisgICAgICAgICAgICBwcml2LT5ib2R5U2l6ZSA9IGRh dGEuc2l6ZSgpOworICAgICAgICB9CisKKyAgICAgICAgKmJvZHlfc2l6ZSA9IHByaXYtPmJvZHlT aXplOworICAgICAgICByZXR1cm4gcHJpdi0+Ym9keTsKKyAgICB9CisKKyAgICByZXR1cm4gTlVM TDsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9hbGxvd19odHRwX2Nv b2tpZXMKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICogQGFsbG93X2h0 dHBfY29va2llczogd2hldGhlciBIVFRQIGNvb2tpZXMgc2hvdWxkIGJlIGFsbG93ZWQKKyAqCisg KiBTZXRzIHdoZXRoZXIgSFRUUCBjb29raWVzIHNob3VsZCBiZSBhbGxvd2VkIHRvIGJlIHNldCBp biByZXNwb25zZQorICogdG8gdGhpcyByZXF1ZXN0LgorICovCit2b2lkIHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3Rfc2V0X2FsbG93X2h0dHBfY29va2llcyhXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVx dWVzdCwgY29uc3QgZ2Jvb2xlYW4gYWxsb3dfaHR0cF9jb29raWVzKQoreworICAgIGdfcmV0dXJu X2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CisKKyAgICBXZWJL aXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgcHJp di0+cmVxdWVzdC5zZXRBbGxvd0hUVFBDb29raWVzKGFsbG93X2h0dHBfY29va2llcyk7CisgICAg Z19vYmplY3Rfbm90aWZ5KEdfT0JKRUNUKHJlcXVlc3QpLCAiYWxsb3ctaHR0cC1jb29raWVzIik7 Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfYWxsb3dfaHR0cF9jb29r aWVzCisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqCisgKiBPYnRhaW5z IHdoZXRoZXIgY29va2llcyBhcmUgYWxsb3dlZCBieSB0aGUgcmVxdWVzdC4KKyAqCisgKiBSZXR1 cm5zOiAlVFJVRSBpZiBjb29raWVzIGFyZSBhbGxvd2VkIGluIHJlc3BvbnNlIHRvIHRoaXMgcmVx dWVzdCwKKyAqICVGQUxTRSBvdGhlcndpc2UKKyAqLworZ2Jvb2xlYW4gd2Via2l0X25ldHdvcmtf cmVxdWVzdF9nZXRfYWxsb3dfaHR0cF9jb29raWVzKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1 ZXN0KQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVF U1QocmVxdWVzdCksIEZBTFNFKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSog cHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICByZXR1cm4gcHJpdi0+cmVxdWVzdC5hbGxvd0hU VFBDb29raWVzKCk7Cit9CisKIH0KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dG5ldHdvcmtyZXF1ZXN0LmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVz dC5oCmluZGV4IGRmYjRkNmMuLjgxMGMyNTYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0 L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0 d29ya3JlcXVlc3QuaApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDcg SG9sZ2VyIEhhbnMgUGV0ZXIgRnJleXRoZXIKKyAqIENvcHlyaWdodCAoQykgMjAwOCBHdXN0YXZv IE5vcm9uaGEgU2lsdmEKICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91 IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1z IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYwpAQCAtNDUsNiArNDYsMjkgQEAgc3Ry dWN0IF9XZWJLaXROZXR3b3JrUmVxdWVzdENsYXNzIHsKICAgICBHT2JqZWN0Q2xhc3MgcGFyZW50 X2NsYXNzOwogfTsKIAorLyogVGhlIFdlYktpdFJlcUNhY2hlUG9saWN5IGVudW0gbXVzdCBiZSBp biBzeW5jIHdpdGgKKyAqIFJlc291cmNlUmVxdWVzdENhY2hlUG9saWN5IGluIAorICogV2ViQ29y ZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlUmVxdWVzdEJhc2UuaAorICovCisvKioKKyAqIFdl YktpdFJlcUNhY2hlUG9saWN5OgorICogQFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX1BST1RPQ09M OiB1c2UgdGhlIEhUVFAgcHJvdG9jb2wgY2FjaGluZworICogcnVsZXMKKyAqIEBXRUJLSVRfUkVR X0NBQ0hFX1BPTElDWV9SRUxPQURfSUdOT1JJTkdfQ0FDSEU6IGZvcmNlIGEgcmVsb2FkLAorICog aWdub3JpbmcgYW55IGNhY2hlCisgKiBAV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfQUxMT1dfU1RB TEU6IHVzZSBkYXRhIGZyb20gY2FjaGUsIGlmCisgKiBhdmFpbGFibGUsIGV2ZW4gaWYgaXQgaXMg c3RhbGUsIGFuZCBsb2FkIGl0IGZyZXNoIG90aGVyd2lzZQorICogQFdFQktJVF9SRVFfQ0FDSEVf UE9MSUNZX0NBQ0hFX09OTFk6IGZvcmNlIHVzaW5nIHRoZSBjYWNoZSBvbmx5OworICogdXNlZnVs IGZvciBvZmZsaW5lIG1vZGVzCisgKi8KK3R5cGVkZWYgZW51bQoreworICBXRUJLSVRfUkVRX0NB Q0hFX1BPTElDWV9QUk9UT0NPTCwKKyAgV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfUkVMT0FEX0lH Tk9SSU5HX0NBQ0hFLAorICBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9BTExPV19TVEFMRSwKKyAg V0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfQ0FDSEVfT05MWSwKK30gV2ViS2l0UmVxQ2FjaGVQb2xp Y3k7CisKIFdFQktJVF9BUEkgR1R5cGUKIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3R5cGUg KHZvaWQpOwogCkBAIC01OCw2ICs4Miw1NyBAQCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF91 cmkgIChXZWJLaXROZXR3b3JrUmVxdWVzdCAqcmVxdWVzdCwKIFdFQktJVF9BUEkgR19DT05TVF9S RVRVUk4gZ2NoYXIgKgogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJpICAoV2ViS2l0TmV0 d29ya1JlcXVlc3QgKnJlcXVlc3QpOwogCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF9uZXR3b3Jr X3JlcXVlc3Rfc2V0X2NhY2hlX3BvbGljeShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwg Y29uc3QgV2ViS2l0UmVxQ2FjaGVQb2xpY3kgY2FjaGVfcG9saWN5KTsKKworV0VCS0lUX0FQSSBX ZWJLaXRSZXFDYWNoZVBvbGljeQord2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfY2FjaGVfcG9s aWN5KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKworV0VCS0lUX0FQSSB2b2lkCit3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF90aW1lb3V0X2ludGVydmFsKFdlYktpdE5ldHdvcmtS ZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnZG91YmxlIHRpbWVvdXRfaW50ZXJ2YWwpOworCitXRUJL SVRfQVBJIGdkb3VibGUKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3RpbWVvdXRfaW50ZXJ2 YWwoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCitXRUJLSVRfQVBJIHZvaWQKK3dl YmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X21haW5fZG9jdW1lbnRfdXJpKFdlYktpdE5ldHdvcmtS ZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciogbWFpbl9kb2N1bWVudF91cmkpOworCitXRUJL SVRfQVBJIGNvbnN0IGdjaGFyKgord2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWFpbl9kb2N1 bWVudF91cmkoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCitXRUJLSVRfQVBJIHZv aWQKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfbWV0aG9kIChXZWJLaXROZXR3b3Jr UmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfbWV0aG9kKTsKKworV0VCS0lUX0FQ SSBjb25zdCBnY2hhcioKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfbWV0aG9kIChX ZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0 X25ldHdvcmtfcmVxdWVzdF9hZGRfaHR0cF9oZWFkZXJzIChXZWJLaXROZXR3b3JrUmVxdWVzdCog cmVxdWVzdCwgY29uc3QgR0hhc2hUYWJsZSogaHR0cF9oZWFkZXJzKTsKKworV0VCS0lUX0FQSSBj b25zdCBHSGFzaFRhYmxlKgord2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9oZWFkZXJz IChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CisKK1dFQktJVF9BUEkgdm9pZAord2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9hZGRfaHR0cF9oZWFkZXIoV2ViS2l0TmV0d29ya1JlcXVlc3Qq IHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX2hlYWRlciwgY29uc3QgZ2NoYXIqIHZhbHVlKTsK KworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX2hlYWRl ciAoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX2hlYWRl ciwgY29uc3QgZ2NoYXIqIHZhbHVlKTsKKworV0VCS0lUX0FQSSBjb25zdCBnY2hhcioKK3dlYmtp dF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfaGVhZGVyIChXZWJLaXROZXR3b3JrUmVxdWVzdCog cmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfaGVhZGVyKTsKKworV0VCS0lUX0FQSSB2b2lkCit3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9ib2R5KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1 ZXN0LCBjb25zdCBnY2hhciogYm9keSwgY29uc3QgZ3NpemUgc2l6ZSk7CisKK1dFQktJVF9BUEkg Y29uc3QgZ2NoYXIqCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9ib2R5KFdlYktpdE5ldHdv cmtSZXF1ZXN0KiByZXF1ZXN0LCBnc2l6ZSAqYm9keV9zaXplKTsKKworV0VCS0lUX0FQSSB2b2lk Cit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9hbGxvd19odHRwX2Nvb2tpZXMoV2ViS2l0TmV0 d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdib29sZWFuIGFsbG93X2h0dHBfY29va2llcyk7 CisKK1dFQktJVF9BUEkgZ2Jvb2xlYW4KK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2FsbG93 X2h0dHBfY29va2llcyhXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CisKIEdfRU5EX0RF Q0xTCiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29y a3Jlc3BvbnNlLmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5j cHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjQ4ZjE5YQotLS0gL2Rldi9u dWxsCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5jcHAKQEAg LTAsMCArMSwxNTAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDggR3VzdGF2byBOb3Jvbmhh IFNpbHZhCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBM aWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRo aXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNl ZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxp ZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQg YSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9u ZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3 cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmts aW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgor ICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2luY2x1ZGUgIndlYmtpdG5ldHdvcmtyZXNw b25zZS5oIgorCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlICJSZXNvdXJj ZVJlc3BvbnNlLmgiCisjaW5jbHVkZSAiQ1N0cmluZy5oIgorCit1c2luZyBuYW1lc3BhY2UgV2Vi Q29yZTsKKworZXh0ZXJuICJDIiB7CisKK0dfREVGSU5FX1RZUEUoV2ViS2l0TmV0d29ya1Jlc3Bv bnNlLCB3ZWJraXRfbmV0d29ya19yZXNwb25zZSwgR19UWVBFX09CSkVDVCk7CisKK3N0cnVjdCBf V2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSB7CisgICAgUmVzb3VyY2VSZXNwb25zZSByZXNw b25zZTsKKworICAgIGdjaGFyKiB1cmk7Cit9OworCisjZGVmaW5lIFdFQktJVF9ORVRXT1JLX1JF U1BPTlNFX0dFVF9QUklWQVRFKG9iaikgKEdfVFlQRV9JTlNUQU5DRV9HRVRfUFJJVkFURSgob2Jq KSwgV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSwgV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJp dmF0ZSkpCisKK3N0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2ZpbmFsaXplKEdP YmplY3QqIG9iamVjdCkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlID0g V0VCS0lUX05FVFdPUktfUkVTUE9OU0Uob2JqZWN0KTsKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9u c2VQcml2YXRlKiBwcml2ID0gcmVzcG9uc2UtPnByaXY7CisKKyAgICBnX2ZyZWUocHJpdi0+dXJp KTsKKworICAgIEdfT0JKRUNUX0NMQVNTKHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX3BhcmVudF9j bGFzcyktPmZpbmFsaXplKG9iamVjdCk7Cit9CisKK3N0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3Jr X3Jlc3BvbnNlX2NsYXNzX2luaXQoV2ViS2l0TmV0d29ya1Jlc3BvbnNlQ2xhc3MqIHJlc3BvbnNl Q2xhc3MpCit7CisgICAgR19PQkpFQ1RfQ0xBU1MocmVzcG9uc2VDbGFzcyktPmZpbmFsaXplID0g d2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZmluYWxpemU7CisKKyAgICBnX3R5cGVfY2xhc3NfYWRk X3ByaXZhdGUocmVzcG9uc2VDbGFzcywgc2l6ZW9mKFdlYktpdE5ldHdvcmtSZXNwb25zZVByaXZh dGUpKTsKK30KKworc3RhdGljIHZvaWQgd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfaW5pdChXZWJL aXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlKQoreworICAgIFdlYktpdE5ldHdvcmtSZXNwb25z ZVByaXZhdGUqIHByaXYgPSBXRUJLSVRfTkVUV09SS19SRVNQT05TRV9HRVRfUFJJVkFURShyZXNw b25zZSk7CisgICAgcmVzcG9uc2UtPnByaXYgPSBwcml2OworfQorCisKKy8vIGZvciBpbnRlcm5h bCB1c2Ugb25seQorV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiB3ZWJraXRfbmV0d29ya19yZXNwb25z ZV9uZXdfZnJvbV9yZXNvdXJjZV9yZXNwb25zZShSZXNvdXJjZVJlc3BvbnNlJiByZXNvdXJjZVJl c3BvbnNlKQoreworICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UgPSBXRUJLSVRf TkVUV09SS19SRVNQT05TRShnX29iamVjdF9uZXcoV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05T RSwgTlVMTCkpOworICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUqIHByaXYgPSByZXNw b25zZS0+cHJpdjsKKworICAgIHByaXYtPnJlc3BvbnNlID0gcmVzb3VyY2VSZXNwb25zZTsKKwor ICAgIHJldHVybiByZXNwb25zZTsKK30KKworLy8gZm9yIGludGVybmFsIHVzZSBvbmx5CitSZXNv dXJjZVJlc3BvbnNlIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF9yZXNvdXJjZV9yZXNwb25z ZShjb25zdCBXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlKQoreworICAgIFdlYktpdE5l dHdvcmtSZXNwb25zZVByaXZhdGUqIHByaXYgPSByZXNwb25zZS0+cHJpdjsKKworICAgIHJldHVy biBwcml2LT5yZXNwb25zZTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9u ZXc6CisgKiBAdXJpOiBhbiBhbHJlYWR5IGVuY29kZWQgVVJJCisgKgorICogQ3JlYXRlcyBhIG5l dyAjV2ViS2l0TmV0d29ya1Jlc3BvbnNlIGluaXRpYWxpemVkIHdpdGggYW4gVVJJLgorICoKKyAq IFJldHVybnM6IGEgbmV3ICNXZWJLaXROZXR3b3JrUmVzcG9uc2UKKyAqLworV2ViS2l0TmV0d29y a1Jlc3BvbnNlKiB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9uZXcoY29uc3QgZ2NoYXIqIHVyaSkK K3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbCh1cmksIE5VTEwpOworCisgICAgV2ViS2l0TmV0 d29ya1Jlc3BvbnNlKiByZXNwb25zZSA9IFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKGdfb2JqZWN0 X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNFLCBOVUxMKSk7CisgICAgV2ViS2l0TmV0 d29ya1Jlc3BvbnNlUHJpdmF0ZSogcHJpdiA9IHJlc3BvbnNlLT5wcml2OworCisgICAgcHJpdi0+ dXJpID0gZ19zdHJkdXAodXJpKTsKKworICAgIHJldHVybiByZXNwb25zZTsKK30KKworLyoqCisg KiB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9zZXRfdXJpOgorICogQHJlc3BvbnNlOiBhICNXZWJL aXROZXR3b3JrUmVzcG9uc2UKKyAqIEB1cmk6IGFuIGFscmVhZHkgZW5jb2RlZCBVUkkKKyAqCisg KiBTZXRzIHRoZSBVUkkgaGVsZCBhbmQgdXNlZCBieSB0aGUgZ2l2ZW4gcmVzcG9uc2UuCisgKi8K K3ZvaWQgd2Via2l0X25ldHdvcmtfcmVzcG9uc2Vfc2V0X3VyaShXZWJLaXROZXR3b3JrUmVzcG9u c2UqIHJlc3BvbnNlLCBjb25zdCBnY2hhciogdXJpKQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwo V0VCS0lUX0lTX05FVFdPUktfUkVTUE9OU0UocmVzcG9uc2UpKTsKKyAgICBnX3JldHVybl9pZl9m YWlsKHVyaSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlKiBwcml2ID0gcmVz cG9uc2UtPnByaXY7CisKKyAgICBnX2ZyZWUocHJpdi0+dXJpKTsKKyAgICBwcml2LT51cmkgPSBn X3N0cmR1cCh1cmkpOworCisgICAgLyogCisgICAgICogZmVlZGluZyBiYWNrIHRvIHRoZSBSZXNv dXJjZVJlc3BvbnNlIG9iamVjdCwgd2hpY2ggaXMgdGhlIG9uZSBhY3R1YWxseSB1c2VkCisgICAg ICogaW5zaWRlIFdlYkNvcmUKKyAgICAgKi8KKyAgICBwcml2LT5yZXNwb25zZS5zZXRVcmwoS1VS TChTdHJpbmc6OmZyb21VVEY4KHVyaSkpKTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19y ZXNwb25zZV9nZXRfdXJpOgorICogQHJlc3BvbnNlOiBhICNXZWJLaXROZXR3b3JrUmVzcG9uc2UK KyAqCisgKiBHZXRzIHRoZSBVUkkgaGVsZCBhbmQgdXNlZCBieSB0aGUgZ2l2ZW4gcmVzcG9uc2Uu CisgKgorICogUmV0dXJuczogdGhlIFVSSSBoZWxkIGFuZCB1c2VkIGJ5IHRoZSBnaXZlbiByZXNw b25zZQorICovCitjb25zdCBnY2hhciogd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3VyaShX ZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9m YWlsKFdFQktJVF9JU19ORVRXT1JLX1JFU1BPTlNFKHJlc3BvbnNlKSwgTlVMTCk7CisKKyAgICBX ZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlKiBwcml2ID0gcmVzcG9uc2UtPnByaXY7CisgICAg CisgICAgaWYgKHByaXYtPnVyaSkKKyAgICAgICAgcmV0dXJuIHByaXYtPnVyaTsKKworICAgIHBy aXYtPnVyaSA9IGdfc3RyZHVwKHByaXYtPnJlc3BvbnNlLnVybCgpLnN0cmluZygpLnV0ZjgoKS5k YXRhKCkpOworICAgIHJldHVybiBwcml2LT51cmk7Cit9CisKK30KZGlmZiAtLWdpdCBhL1dlYktp dC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0bmV0d29ya3Jlc3BvbnNlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MC4uMzc4YThhNQotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5l dHdvcmtyZXNwb25zZS5oCkBAIC0wLDAgKzEsNjMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MDggR3VzdGF2byBOb3JvbmhhIFNpbHZhCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29m dHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2Ug YXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICog dmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2 ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0 aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRo b3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5 IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hv dWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJ TkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlv biwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEg MDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpZm5kZWYgV0VCS0lUX05FVFdPUktfUkVTUE9OU0Vf SAorI2RlZmluZSBXRUJLSVRfTkVUV09SS19SRVNQT05TRV9ICisKKyNpbmNsdWRlIDxnbGliLW9i amVjdC5oPgorCisjaW5jbHVkZSA8d2Via2l0L3dlYmtpdGRlZmluZXMuaD4KKworR19CRUdJTl9E RUNMUworCisjZGVmaW5lIFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UgICAgICAgICAgICAo d2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3R5cGUoKSkKKyNkZWZpbmUgV0VCS0lUX05FVFdP UktfUkVTUE9OU0Uob2JqKSAgICAgICAgICAgIChHX1RZUEVfQ0hFQ0tfSU5TVEFOQ0VfQ0FTVCgo b2JqKSwgV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSwgV2ViS2l0TmV0d29ya1Jlc3BvbnNl KSkKKyNkZWZpbmUgV0VCS0lUX05FVFdPUktfUkVTUE9OU0VfQ0xBU1Moa2xhc3MpICAgIChHX1RZ UEVfQ0hFQ0tfQ0xBU1NfQ0FTVCgoa2xhc3MpLCAgV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05T RSwgV2ViS2l0TmV0d29ya1Jlc3BvbnNlQ2xhc3MpKQorI2RlZmluZSBXRUJLSVRfSVNfTkVUV09S S19SRVNQT05TRShvYmopICAgICAgICAgKEdfVFlQRV9DSEVDS19JTlNUQU5DRV9UWVBFKChvYmop LCBXRUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNFKSkKKyNkZWZpbmUgV0VCS0lUX0lTX05FVFdP UktfUkVTUE9OU0VfQ0xBU1Moa2xhc3MpIChHX1RZUEVfQ0hFQ0tfQ0xBU1NfVFlQRSgoa2xhc3Mp LCAgV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSkpCisjZGVmaW5lIFdFQktJVF9ORVRXT1JL X1JFU1BPTlNFX0dFVF9DTEFTUyhvYmopICAoR19UWVBFX0lOU1RBTkNFX0dFVF9DTEFTUygob2Jq KSwgIFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UsIFdlYktpdE5ldHdvcmtSZXNwb25zZUNs YXNzKSkKKwordHlwZWRlZiBzdHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUgV2Vi S2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZTsKKworc3RydWN0IF9XZWJLaXROZXR3b3JrUmVzcG9u c2UgeworICAgIEdPYmplY3QgcGFyZW50X2luc3RhbmNlOworCisgICAgV2ViS2l0TmV0d29ya1Jl c3BvbnNlUHJpdmF0ZSogcHJpdjsKK307CisKK3N0cnVjdCBfV2ViS2l0TmV0d29ya1Jlc3BvbnNl Q2xhc3MgeworICAgIEdPYmplY3RDbGFzcyBwYXJlbnRfY2xhc3M7Cit9OworCitXRUJLSVRfQVBJ IEdUeXBlCit3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfdHlwZSAodm9pZCk7CisKK1dFQktJ VF9BUEkgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKgord2Via2l0X25ldHdvcmtfcmVzcG9uc2VfbmV3 IChjb25zdCBnY2hhciogdXJpKTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19y ZXNwb25zZV9zZXRfdXJpIChXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlLCBjb25zdCBn Y2hhciogdXJpKTsKKworV0VCS0lUX0FQSSBjb25zdCBnY2hhcioKK3dlYmtpdF9uZXR3b3JrX3Jl c3BvbnNlX2dldF91cmkgKFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UpOworCisKK0df RU5EX0RFQ0xTCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 cHJpdmF0ZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcAppbmRleCBi ZWExYWQ2Li43ODY5Zjk2IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2 YXRlLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcApAQCAtMjMs NiArMjMsNyBAQAogI2luY2x1ZGUgIkNocm9tZUNsaWVudEd0ay5oIgogI2luY2x1ZGUgIkZyYW1l TG9hZGVyLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkZXJDbGllbnRHdGsuaCIKKyNpbmNsdWRlICJS ZXNvdXJjZVJlcXVlc3QuaCIKICNpbmNsdWRlICJMb2dnaW5nLmgiCiAjaW5jbHVkZSAiTm90SW1w bGVtZW50ZWQuaCIKICNpbmNsdWRlICJQYWdlQ2FjaGUuaCIKQEAgLTgzLDYgKzg0LDE2IEBAIFdl YktpdFdlYlZpZXcqIGtpdChXZWJDb3JlOjpQYWdlKiBjb3JlUGFnZSkKICAgICByZXR1cm4gY2xp ZW50ID8gY2xpZW50LT53ZWJWaWV3KCkgOiAwOwogfQogCitSZXNvdXJjZVJlcXVlc3RDYWNoZVBv bGljeSBjb3JlKFdlYktpdFJlcUNhY2hlUG9saWN5IGNhY2hlUG9saWN5KQoreworICAgIHJldHVy biAoUmVzb3VyY2VSZXF1ZXN0Q2FjaGVQb2xpY3kpY2FjaGVQb2xpY3k7Cit9CisKK1dlYktpdFJl cUNhY2hlUG9saWN5IGtpdChSZXNvdXJjZVJlcXVlc3RDYWNoZVBvbGljeSBjYWNoZVBvbGljeSkK K3sKKyAgICByZXR1cm4gKFdlYktpdFJlcUNhY2hlUG9saWN5KWNhY2hlUG9saWN5OworfQorCiB9 IC8qKiBlbmQgbmFtZXNwYWNlIFdlYkNvcmUgKi8KIAogdm9pZCB3ZWJraXRfaW5pdCgpCmRpZmYg LS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXRwcml2YXRlLmgKaW5kZXggZWQ4MWExYy4uMDlhZThkNyAxMDA2NDQKLS0tIGEv V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0 L3dlYmtpdHByaXZhdGUuaApAQCAtMjIsNyArMjIsOCBAQAogI2RlZmluZSBXRUJLSVRfUFJJVkFU RV9ICiAKIC8qCi0gKiBUaGlzIGZpbGUga25vd3MgdGhlIHNoYXJlZCBzZWNyZXQgb2YgV2ViS2l0 V2ViVmlldyBhbmQgV2ViS2l0V2ViRnJhbWUuCisgKiBUaGlzIGZpbGUga25vd3MgdGhlIHNoYXJl ZCBzZWNyZXQgb2YgV2ViS2l0V2ViVmlldyBhbmQgV2ViS2l0V2ViRnJhbWUKKyAqIGFuZCBXZWJL aXROZXR3b3JrUmVxdWVzdC4KICAqIFRoZXkgYXJlIHVzaW5nIFdlYkNvcmUgd2hpY2ggbXVzbid0 IGJlIGV4cG9zZWQgdG8gdGhlIG91dGVyIHdvcmxkLgogICovCiAKQEAgLTMxLDYgKzMyLDcgQEAK ICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2ViZnJhbWUuaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Vi a2l0d2Vic2V0dGluZ3MuaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2ViYmFja2ZvcndhcmRs aXN0Lmg+CisjaW5jbHVkZSA8d2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0Lmg+CiAKICNpbmNs dWRlICJCYWNrRm9yd2FyZExpc3QuaCIKICNpbmNsdWRlICJIaXN0b3J5SXRlbS5oIgpAQCAtMzgs NiArNDAsNyBAQAogI2luY2x1ZGUgIlBhZ2UuaCIKICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1 ZGUgIkZyYW1lTG9hZGVyQ2xpZW50LmgiCisjaW5jbHVkZSAiUmVzb3VyY2VSZXF1ZXN0LmgiCiAK ICNpbmNsdWRlIDxnbGliLmg+CiAKQEAgLTU0LDYgKzU3LDkgQEAgbmFtZXNwYWNlIFdlYktpdCB7 CiAgICAgV2ViS2l0V2ViSGlzdG9yeUl0ZW0qIGtpdChXZWJDb3JlOjpIaXN0b3J5SXRlbSopOwog CiAgICAgV2ViQ29yZTo6QmFja0ZvcndhcmRMaXN0KiBjb3JlKFdlYktpdFdlYkJhY2tGb3J3YXJk TGlzdCopOworCisgICAgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Q2FjaGVQb2xpY3kgY29yZShX ZWJLaXRSZXFDYWNoZVBvbGljeSBjYWNoZVBvbGljeSk7CisgICAgV2ViS2l0UmVxQ2FjaGVQb2xp Y3kga2l0KFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdENhY2hlUG9saWN5IGNhY2hlUG9saWN5KTsK IH0KIAogZXh0ZXJuICJDIiB7CkBAIC0xMjMsNiArMTI5LDE4IEBAIGV4dGVybiAiQyIgewogCiAg ICAgV0VCS0lUX0FQSSBnY2hhcioKICAgICB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3NlbGVjdGVkX3Rl eHQgKFdlYktpdFdlYlZpZXcqIHdlYl92aWV3KTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0 KgorICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X2Zyb21fcmVzb3VyY2VfcmVxdWVzdChX ZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCk7CisKKyAgICBXZWJDb3Jl OjpSZXNvdXJjZVJlcXVlc3QKKyAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9yZXNvdXJj ZV9yZXF1ZXN0KGNvbnN0IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKworICAgIFdl YktpdE5ldHdvcmtSZXNwb25zZSoKKyAgICB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9uZXdfZnJv bV9yZXNvdXJjZV9yZXNwb25zZShXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlJiByZXNvdXJjZVJl c3BvbnNlKTsKKworICAgIFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UKKyAgICB3ZWJraXRfbmV0 d29ya19yZXNwb25zZV9nZXRfcmVzb3VyY2VfcmVzcG9uc2UoY29uc3QgV2ViS2l0TmV0d29ya1Jl c3BvbnNlKiByZXNwb25zZSk7CiB9CiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJh bWUuY3BwCmluZGV4IGE3ZjI3ZWYuLmI5MWEwMGQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdHdlYmZyYW1lLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJm cmFtZS5jcHAKQEAgLTM1Myw5ICszNTMsNyBAQCB2b2lkIHdlYmtpdF93ZWJfZnJhbWVfbG9hZF9y ZXF1ZXN0KFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgV2ViS2l0TmV0d29ya1JlcXVlc3QqCiAgICAg RnJhbWUqIGNvcmVGcmFtZSA9IGNvcmUoZnJhbWUpOwogICAgIEFTU0VSVChjb3JlRnJhbWUpOwog Ci0gICAgLy8gVE9ETzogVXNlIHRoZSBSZXNvdXJjZVJlcXVlc3QgY2FycmllZCBieSBXZWJLaXRO ZXR3b3JrUmVxdWVzdCB3aGVuIGl0IGlzIGltcGxlbWVudGVkLgotICAgIFN0cmluZyBzdHJpbmcg PSBTdHJpbmc6OmZyb21VVEY4KHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShyZXF1ZXN0 KSk7Ci0gICAgY29yZUZyYW1lLT5sb2FkZXIoKS0+bG9hZChSZXNvdXJjZVJlcXVlc3QoS1VSTChz dHJpbmcpKSk7CisgICAgY29yZUZyYW1lLT5sb2FkZXIoKS0+bG9hZCh3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X2dldF9yZXNvdXJjZV9yZXF1ZXN0KHJlcXVlc3QpKTsKIH0KIAogLyoqCmRpZmYgLS1n aXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcCBiL1dlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdHdlYnZpZXcuY3BwCmluZGV4IGI5ZWM2MTcuLjE4ZGEzZDUgMTAwNjQ0Ci0tLSBh L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdHdlYnZpZXcuY3BwCkBAIC0yOSw2ICsyOSw4IEBACiAjaW5jbHVkZSAid2Via2l0 cHJpdmF0ZS5oIgogI2luY2x1ZGUgIndlYmtpdHdlYmJhY2tmb3J3YXJkbGlzdC5oIgogI2luY2x1 ZGUgIndlYmtpdHdlYmhpc3RvcnlpdGVtLmgiCisjaW5jbHVkZSAid2Via2l0bmV0d29ya3JlcXVl c3QuaCIKKyNpbmNsdWRlICJ3ZWJraXRuZXR3b3JrcmVzcG9uc2UuaCIKIAogI2luY2x1ZGUgIkFY T2JqZWN0Q2FjaGUuaCIKICNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgo= 22545 2008-07-29 19:07:30 -0700 2008-07-30 11:30:47 -0700 proposed patch network-request.diff text/plain 45783 gustavo ZGlmZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0NoYW5nZUxvZwppbmRleCBkZTM2NjYzLi41N2Y2ZWE2 IDEwMDY0NAotLS0gYS9DaGFuZ2VMb2cKKysrIGIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTEgQEAK KzIwMDgtMDctMjkgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGduc0Bnbm9tZS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkZWQgbmV3IGZp bGUgdG8gdGhlIEdUSysgYnVpbGQ6IHdlYmtpdG5ldHdvcmtyZXNwb25zZS5jcHAuCisgICAgICAg IAorICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOgorCiAyMDA4LTA3LTI1ICBKYW4gTWljaGFlbCBB bG9uem8gIDxqbWFsb256b0B3ZWJraXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IE1hcmsg Um93ZS4KZGlmZiAtLWdpdCBhL0dOVW1ha2VmaWxlLmFtIGIvR05VbWFrZWZpbGUuYW0KaW5kZXgg YzVlZGNjMC4uMTkxNzU4NiAxMDA2NDQKLS0tIGEvR05VbWFrZWZpbGUuYW0KKysrIGIvR05VbWFr ZWZpbGUuYW0KQEAgLTMzNyw2ICszMzcsNyBAQCB3ZWJraXRndGtfaGVhZGVycyArPSBcCiAKIHdl YmtpdGd0a19zb3VyY2VzICs9IFwKIAlXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVx dWVzdC5jcHAgXAorCVdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5jcHAg XAogCVdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuY3BwIFwKIAlXZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXR2ZXJzaW9uLmNwcCBcCiAJV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViYmFj a2ZvcndhcmRsaXN0LmNwcCBcCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZyBiL1dl YktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4IDgwODBmZjYuLmI0NzVhZWYgMTAwNjQ0Ci0tLSBhL1dl YktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs NjAgQEAKKzIwMDgtMDUtMTEgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGduc0Bnbm9tZS5vcmc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE4NjA4CisgICAgICAgIFdlYktpdE5l dHdvcmtSZXF1ZXN0IG5lZWRzIHRvIGJlIGZpbmlzaGVkCisKKyAgICAgICAgR09iamVjdCBpbXBs ZW1lbnRhdGlvbiBleHBvc2luZyBSZXNvdXJjZVJlcXVlc3QsIGFuZCBpbml0aWFsCisgICAgICAg IGltcGxlbWVudGF0aW9uIGV4cG9zaW5nIFJlc291cmNlUmVzcG9uc2UuIEZyYW1lTG9hZGVyQ2xp ZW50R3RrIGlzCisgICAgICAgIG5vdyB1c2luZyBXZWJLaXROZXR3b3JrUmVxdWVzdCB3aGVuIGl0 IG5lZWRzIHRvIGRlYWwgd2l0aCByZXF1ZXN0CisgICAgICAgIGluZm9ybWF0aW9uLiAKKworICAg ICAgICAqIENoYW5nZUxvZzoKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNs aWVudEd0ay5jcHA6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRj aERlY2lkZVBvbGljeUZvck5hdmlnYXRpb25BY3Rpb24pOgorICAgICAgICAqIHdlYmtpdC93ZWJr aXQuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0ZGVmaW5lcy5oOgorICAgICAgICAqIHdlYmtp dC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHA6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVl c3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2ZpbmFsaXplKToKKyAgICAgICAgKF9X ZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OmNhY2hlX3BvbGljeV9mcm9tX3Jlc291cmNlX3Jl cXVlc3QpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25l dHdvcmtfcmVxdWVzdF9uZXdfZnJvbV9yZXNvdXJjZV9yZXF1ZXN0KToKKyAgICAgICAgKF9XZWJL aXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3Jlc291 cmNlX3JlcXVlc3QpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVx dWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaSk6CisgICAgICAgIChf V2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9j YWNoZV9wb2xpY3kpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfY2FjaGVfcG9saWN5KToKKyAgICAgICAgKF9XZWJLaXRO ZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3RpbWVvdXRf aW50ZXJ2YWwpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0 X25ldHdvcmtfcmVxdWVzdF9nZXRfdGltZW91dF9pbnRlcnZhbCk6CisgICAgICAgIChfV2ViS2l0 TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9tYWluX2Rv Y3VtZW50X3VyaSk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X2dldF9tYWluX2RvY3VtZW50X3VyaSk6CisgICAgICAgIChfV2Vi S2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRw X21ldGhvZCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRf bmV0d29ya19yZXF1ZXN0X2dldF9odHRwX21ldGhvZCk6CisgICAgICAgIChfV2ViS2l0TmV0d29y a1JlcXVlc3RQcml2YXRlOjpjb3B5X2hlYWRlcik6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1Jl cXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2FkZF9odHRwX2hlYWRlcnMpOgor ICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVx dWVzdF9nZXRfaHR0cF9oZWFkZXJzKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFBy aXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfYWRkX2h0dHBfaGVhZGVyKToKKyAgICAgICAg KF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0 X2h0dHBfaGVhZGVyKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6Ondl YmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfaGVhZGVyKToKKyAgICAgICAgKF9XZWJLaXRO ZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2JvZHkpOgor ICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVx dWVzdF9nZXRfYm9keSk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9hbGxvd19odHRwX2Nvb2tpZXMpOgorICAgICAgICAo X1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRf YWxsb3dfaHR0cF9jb29raWVzKToKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0bmV0d29ya3JlcXVl c3QuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmNwcDogQWRkZWQu CisgICAgICAgIChfV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZTo6d2Via2l0X25ldHdvcmtf cmVzcG9uc2VfZmluYWxpemUpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXNwb25zZVByaXZh dGU6OndlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2NsYXNzX2luaXQpOgorICAgICAgICAoX1dlYktp dE5ldHdvcmtSZXNwb25zZVByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2luaXQpOgor ICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3Jl c3BvbnNlX25ld19mcm9tX3Jlc291cmNlX3Jlc3BvbnNlKToKKyAgICAgICAgKF9XZWJLaXROZXR3 b3JrUmVzcG9uc2VQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfcmVzb3VyY2Vf cmVzcG9uc2UpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGU6OndlYmtp dF9uZXR3b3JrX3Jlc3BvbnNlX25ldyk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1Jlc3BvbnNl UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVzcG9uc2Vfc2V0X3VyaSk6CisgICAgICAgIChfV2Vi S2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3Vy aSk6CisgICAgICAgICogd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5oOiBBZGRlZC4KKyAg ICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5oOgorICAgICAgICAqIHdlYmtpdC93ZWJraXR3 ZWJmcmFtZS5jcHA6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwOgorCiAyMDA4 LTA3LTI2ICBNYXJrIFJvd2UgIDxtcm93ZUBhcHBsZS5jb20+CiAKICAgICAgICAgQnVpbGQgZml4 LiAgQ2hhbmdlcyB0byBhY2NvbW1vZGF0ZSBuZXdseSBuYW1lZC9zaWduYXR1cmVkIGxvYWRpbmcg bWV0aG9kcyBpbiBXZWJDb3JlLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50R3RrLmNwcAppbmRleCA4Y2YwODg2Li4yZjY0NzQ1IDEwMDY0NAotLS0g YS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAorKysg Yi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcApAQCAt NDQsNiArNDQsOCBAQAogI2luY2x1ZGUgIlNjcmlwdENvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJ3 ZWJraXR3ZWJ2aWV3LmgiCiAjaW5jbHVkZSAid2Via2l0d2ViZnJhbWUuaCIKKyNpbmNsdWRlICJ3 ZWJraXRuZXR3b3JrcmVxdWVzdC5oIgorI2luY2x1ZGUgIndlYmtpdG5ldHdvcmtyZXNwb25zZS5o IgogI2luY2x1ZGUgIndlYmtpdHByaXZhdGUuaCIKIAogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3Jl L0FQSUNhc3QuaD4KQEAgLTI2OCw3ICsyNzAsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50Ojpk aXNwYXRjaERlY2lkZVBvbGljeUZvck5hdmlnYXRpb25BY3Rpb24oRnJhbWVQb2xpY3lGdW5jdAog ICAgICAgICByZXR1cm47CiAKICAgICBXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3ID0gZ2V0Vmlld0Zy b21GcmFtZShtX2ZyYW1lKTsKLSAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdl YmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3KHJlc291cmNlUmVxdWVzdC51cmwoKS5zdHJpbmcoKS51 dGY4KCkuZGF0YSgpKTsKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdlYmtp dF9uZXR3b3JrX3JlcXVlc3RfbmV3X2Zyb21fcmVzb3VyY2VfcmVxdWVzdChyZXNvdXJjZVJlcXVl c3QpOwogICAgIFdlYktpdE5hdmlnYXRpb25SZXNwb25zZSByZXNwb25zZTsKIAogICAgIGdfc2ln bmFsX2VtaXRfYnlfbmFtZSh3ZWJWaWV3LCAibmF2aWdhdGlvbi1yZXF1ZXN0ZWQiLCBtX2ZyYW1l LCByZXF1ZXN0LCAmcmVzcG9uc2UpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0LmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXQuaAppbmRleCAxMGMyMTRmLi45MGFjZjhm IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXQuaAorKysgYi9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXQuaApAQCAtMjMsNiArMjMsNyBAQAogI2luY2x1ZGUgPHdlYmtpdC93ZWJr aXR2ZXJzaW9uLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdGRlZmluZXMuaD4KICNpbmNsdWRl IDx3ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuaD4KKyNpbmNsdWRlIDx3ZWJraXQvd2Via2l0 bmV0d29ya3Jlc3BvbnNlLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYmZyYW1lLmg+CiAj aW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYnNldHRpbmdzLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dl YmtpdHdlYnZpZXcuaD4KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRlZmlu ZXMuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRlZmluZXMuaAppbmRleCAzODZjM2UxLi4z Mzk4MWUwIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRkZWZpbmVzLmgKKysr IGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZGVmaW5lcy5oCkBAIC00Myw2ICs0Myw5IEBAIEdf QkVHSU5fREVDTFMKIHR5cGVkZWYgc3RydWN0IF9XZWJLaXROZXR3b3JrUmVxdWVzdCBXZWJLaXRO ZXR3b3JrUmVxdWVzdDsKIHR5cGVkZWYgc3RydWN0IF9XZWJLaXROZXR3b3JrUmVxdWVzdENsYXNz IFdlYktpdE5ldHdvcmtSZXF1ZXN0Q2xhc3M7CiAKK3R5cGVkZWYgc3RydWN0IF9XZWJLaXROZXR3 b3JrUmVzcG9uc2UgV2ViS2l0TmV0d29ya1Jlc3BvbnNlOwordHlwZWRlZiBzdHJ1Y3QgX1dlYktp dE5ldHdvcmtSZXNwb25zZUNsYXNzIFdlYktpdE5ldHdvcmtSZXNwb25zZUNsYXNzOworCiB0eXBl ZGVmIHN0cnVjdCBfV2ViS2l0V2ViQmFja0ZvcndhcmRMaXN0IFdlYktpdFdlYkJhY2tGb3J3YXJk TGlzdDsKIHR5cGVkZWYgc3RydWN0IF9XZWJLaXRXZWJCYWNrRm9yd2FyZExpc3RDbGFzcyBXZWJL aXRXZWJCYWNrRm9yd2FyZExpc3RDbGFzczsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0 d29ya3JlcXVlc3QuY3BwCmluZGV4IGZhYjBmODguLmFiMGEwMGYgMTAwNjQ0Ci0tLSBhL1dlYktp dC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcAorKysgYi9XZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKQEAgLTEsNSArMSw2IEBACiAvKgogICogQ29w eXJpZ2h0IChDKSAyMDA3IEhvbGdlciBIYW5zIFBldGVyIEZyZXl0aGVyCisgKiBDb3B5cmlnaHQg KEMpIDIwMDggR3VzdGF2byBOb3JvbmhhIFNpbHZhCiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZy ZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9kaWZ5IGl0 IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAgLTIw LDMwICsyMSwxNzEgQEAKICNpbmNsdWRlICJjb25maWcuaCIKIAogI2luY2x1ZGUgIndlYmtpdG5l dHdvcmtyZXF1ZXN0LmgiCisjaW5jbHVkZSAid2Via2l0ZW51bXR5cGVzLmgiCisjaW5jbHVkZSAi d2Via2l0cHJpdmF0ZS5oIgorCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRl ICJSZXNvdXJjZVJlcXVlc3QuaCIKKyNpbmNsdWRlICJDU3RyaW5nLmgiCisKK3VzaW5nIG5hbWVz cGFjZSBXZWJDb3JlOwordXNpbmcgbmFtZXNwYWNlIFdlYktpdDsKIAogZXh0ZXJuICJDIiB7CiAK K2VudW0geworICAgIFBST1BfMCwKKworICAgIFBST1BfVVJJLAorICAgIFBST1BfQ0FDSEVfUE9M SUNZLAorICAgIFBST1BfVElNRU9VVF9JTlRFUlZBTCwKKyAgICBQUk9QX01BSU5fRE9DVU1FTlRf VVJJLAorICAgIFBST1BfSFRUUF9NRVRIT0QsCisgICAgUFJPUF9BTExPV19IVFRQX0NPT0tJRVMs Cit9OworCiBHX0RFRklORV9UWVBFKFdlYktpdE5ldHdvcmtSZXF1ZXN0LCB3ZWJraXRfbmV0d29y a19yZXF1ZXN0LCBHX1RZUEVfT0JKRUNUKTsKIAogc3RydWN0IF9XZWJLaXROZXR3b3JrUmVxdWVz dFByaXZhdGUgeworICAgIFJlc291cmNlUmVxdWVzdCByZXF1ZXN0OworCiAgICAgZ2NoYXIqIHVy aTsKKyAgICBnY2hhciogbWFpbkRvY3VtZW50VVJJOworICAgIGdjaGFyKiBodHRwTWV0aG9kOwor ICAgIGdjaGFyICpib2R5OworICAgIGdzc2l6ZSBib2R5U2l6ZTsKKworICAgIEdIYXNoVGFibGUg Kmh0dHBIZWFkZXJzOwogfTsKIAogI2RlZmluZSBXRUJLSVRfTkVUV09SS19SRVFVRVNUX0dFVF9Q UklWQVRFKG9iaikgKEdfVFlQRV9JTlNUQU5DRV9HRVRfUFJJVkFURSgob2JqKSwgV0VCS0lUX1RZ UEVfTkVUV09SS19SRVFVRVNULCBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUpKQogCitzdGF0 aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9wcm9wZXJ0eShHT2JqZWN0KiBvYmpl Y3QsIGd1aW50IHByb3BfaWQsIEdWYWx1ZSogdmFsdWUsIEdQYXJhbVNwZWMqIHBzcGVjKQorewor ICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gV0VCS0lUX05FVFdPUktfUkVRVUVT VChvYmplY3QpOworCisgICAgc3dpdGNoKHByb3BfaWQpIHsKKyAgICBjYXNlIFBST1BfVVJJOgor ICAgICAgICBnX3ZhbHVlX3NldF9zdHJpbmcodmFsdWUsIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf Z2V0X3VyaShyZXF1ZXN0KSk7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgUFJPUF9DQUNIRV9Q T0xJQ1k6CisgICAgICAgIGdfdmFsdWVfc2V0X2VudW0odmFsdWUsIHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X2NhY2hlX3BvbGljeShyZXF1ZXN0KSk7CisgICAgICAgIGJyZWFrOworICAgIGNh c2UgUFJPUF9USU1FT1VUX0lOVEVSVkFMOgorICAgICAgICBnX3ZhbHVlX3NldF9kb3VibGUodmFs dWUsIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3RpbWVvdXRfaW50ZXJ2YWwocmVxdWVzdCkp OworICAgICAgICBicmVhazsKKyAgICBjYXNlIFBST1BfTUFJTl9ET0NVTUVOVF9VUkk6CisgICAg ICAgIGdfdmFsdWVfc2V0X3N0cmluZyh2YWx1ZSwgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRf bWFpbl9kb2N1bWVudF91cmkocmVxdWVzdCkpOworICAgICAgICBicmVhazsKKyAgICBjYXNlIFBS T1BfSFRUUF9NRVRIT0Q6CisgICAgICAgIGdfdmFsdWVfc2V0X3N0cmluZyh2YWx1ZSwgd2Via2l0 X25ldHdvcmtfcmVxdWVzdF9nZXRfaHR0cF9tZXRob2QocmVxdWVzdCkpOworICAgICAgICBicmVh azsKKyAgICBjYXNlIFBST1BfQUxMT1dfSFRUUF9DT09LSUVTOgorICAgICAgICBnX3ZhbHVlX3Nl dF9ib29sZWFuKHZhbHVlLCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9hbGxvd19odHRwX2Nv b2tpZXMocmVxdWVzdCkpOworICAgIGRlZmF1bHQ6CisgICAgICAgIEdfT0JKRUNUX1dBUk5fSU5W QUxJRF9QUk9QRVJUWV9JRChvYmplY3QsIHByb3BfaWQsIHBzcGVjKTsKKyAgICB9Cit9CisKK3N0 YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3Byb3BlcnR5KEdPYmplY3QqIG9i amVjdCwgZ3VpbnQgcHJvcF9pZCwgY29uc3QgR1ZhbHVlKiB2YWx1ZSwgR1BhcmFtU3BlYyAqcHNw ZWMpCit7CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSBXRUJLSVRfTkVUV09S S19SRVFVRVNUKG9iamVjdCk7CisKKyAgICBzd2l0Y2gocHJvcF9pZCkgeworICAgIGNhc2UgUFJP UF9VUkk6CisgICAgICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaShyZXF1ZXN0LCBn X3ZhbHVlX2dldF9zdHJpbmcodmFsdWUpKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBQUk9Q X0NBQ0hFX1BPTElDWToKKyAgICAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfY2FjaGVf cG9saWN5KHJlcXVlc3QsIChXZWJLaXRSZXFDYWNoZVBvbGljeSlnX3ZhbHVlX2dldF9lbnVtKHZh bHVlKSk7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgUFJPUF9USU1FT1VUX0lOVEVSVkFMOgor ICAgICAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF90aW1lb3V0X2ludGVydmFsKHJlcXVl c3QsIGdfdmFsdWVfZ2V0X2RvdWJsZSh2YWx1ZSkpOworICAgICAgICBicmVhazsKKyAgICBjYXNl IFBST1BfTUFJTl9ET0NVTUVOVF9VUkk6CisgICAgICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf c2V0X21haW5fZG9jdW1lbnRfdXJpKHJlcXVlc3QsIGdfdmFsdWVfZ2V0X3N0cmluZyh2YWx1ZSkp OworICAgICAgICBicmVhazsKKyAgICBjYXNlIFBST1BfSFRUUF9NRVRIT0Q6CisgICAgICAgIHdl YmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfbWV0aG9kKHJlcXVlc3QsIGdfdmFsdWVfZ2V0 X3N0cmluZyh2YWx1ZSkpOworICAgICAgICBicmVhazsKKyAgICBjYXNlIFBST1BfQUxMT1dfSFRU UF9DT09LSUVTOgorICAgICAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9hbGxvd19odHRw X2Nvb2tpZXMocmVxdWVzdCwgZ192YWx1ZV9nZXRfYm9vbGVhbih2YWx1ZSkpOworICAgICAgICBi cmVhazsKKyAgICBkZWZhdWx0OgorICAgICAgICBHX09CSkVDVF9XQVJOX0lOVkFMSURfUFJPUEVS VFlfSUQob2JqZWN0LCBwcm9wX2lkLCBwc3BlYyk7CisgICAgfQorfQorCiBzdGF0aWMgdm9pZCB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X2ZpbmFsaXplKEdPYmplY3QqIG9iamVjdCkKIHsKICAgICBX ZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IFdFQktJVF9ORVRXT1JLX1JFUVVFU1Qob2Jq ZWN0KTsKICAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5w cml2OwogCiAgICAgZ19mcmVlKHByaXYtPnVyaSk7CisgICAgZ19mcmVlKHByaXYtPm1haW5Eb2N1 bWVudFVSSSk7CisgICAgZ19mcmVlKHByaXYtPmh0dHBNZXRob2QpOworICAgIGdfZnJlZShwcml2 LT5ib2R5KTsKKworICAgIGlmKHByaXYtPmh0dHBIZWFkZXJzKQorICAgICAgICBnX2hhc2hfdGFi bGVfZGVzdHJveShwcml2LT5odHRwSGVhZGVycyk7CiAKICAgICBHX09CSkVDVF9DTEFTUyh3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X3BhcmVudF9jbGFzcyktPmZpbmFsaXplKG9iamVjdCk7CiB9CiAK IHN0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfY2xhc3NfaW5pdChXZWJLaXROZXR3 b3JrUmVxdWVzdENsYXNzKiByZXF1ZXN0Q2xhc3MpCiB7Ci0gICAgR19PQkpFQ1RfQ0xBU1MocmVx dWVzdENsYXNzKS0+ZmluYWxpemUgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2ZpbmFsaXplOwor ICAgIEdPYmplY3RDbGFzcyogb2JqZWN0Q2xhc3MgPSBHX09CSkVDVF9DTEFTUyhyZXF1ZXN0Q2xh c3MpOworCisgICAgb2JqZWN0Q2xhc3MtPmZpbmFsaXplID0gd2Via2l0X25ldHdvcmtfcmVxdWVz dF9maW5hbGl6ZTsKKyAgICBvYmplY3RDbGFzcy0+Z2V0X3Byb3BlcnR5ID0gd2Via2l0X25ldHdv cmtfcmVxdWVzdF9nZXRfcHJvcGVydHk7CisgICAgb2JqZWN0Q2xhc3MtPnNldF9wcm9wZXJ0eSA9 IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3Byb3BlcnR5OworCisgICAgLyoKKyAgICAgKiBw cm9wZXJ0aWVzCisgICAgICovCisgICAgZ19vYmplY3RfY2xhc3NfaW5zdGFsbF9wcm9wZXJ0eShv YmplY3RDbGFzcywgUFJPUF9VUkksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBnX3BhcmFtX3NwZWNfc3RyaW5nKCJ1cmkiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiVVJJIiwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIlRoZSBVUkkgZm9yIHRoaXMgcmVx dWVzdCIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIE5VTEwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIFdFQktJVF9QQVJBTV9SRUFEV1JJVEUpKTsKKworICAgIGdfb2JqZWN0X2Ns YXNzX2luc3RhbGxfcHJvcGVydHkob2JqZWN0Q2xhc3MsIFBST1BfQ0FDSEVfUE9MSUNZLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ19wYXJhbV9zcGVjX2VudW0oImNhY2hl LXBvbGljeSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAiQ2FjaGUgUG9saWN5IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICJXaGV0aGVyIGFuZCBob3cgdGhpcyByZXF1ZXN0IHNob3Vs ZCB1c2UgZGF0YSBmcm9tIHRoZSBjYWNoZSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRfVFlQRV9SRVFfQ0FDSEVfUE9MSUNZLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0VC S0lUX1JFUV9DQUNIRV9QT0xJQ1lfUFJPVE9DT0wsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRfUEFSQU1fUkVBRFdSSVRFKSk7CisK KyAgICBnX29iamVjdF9jbGFzc19pbnN0YWxsX3Byb3BlcnR5KG9iamVjdENsYXNzLCBQUk9QX1RJ TUVPVVRfSU5URVJWQUwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnX3Bh cmFtX3NwZWNfZG91YmxlKCJ0aW1lb3V0LWludGVydmFsIiwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIlRpbWVvdXQgSW50ZXJ2YWwiLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAi SG93IGxvbmcgdG8gd2FpdCBiZWZvcmUgdGhlIHJlcXVlc3QgdGltZXMgb3V0IiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMC4wLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHX01B WERPVUJMRSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgNjAuMCwgLy8gdGFrZW4gZnJvbSBSZXNvdXJjZVJlcXVlc3RCYXNlLmgKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0VCS0lU X1BBUkFNX1JFQURXUklURSkpOworCisgICAgZ19vYmplY3RfY2xhc3NfaW5zdGFsbF9wcm9wZXJ0 eShvYmplY3RDbGFzcywgUFJPUF9NQUlOX0RPQ1VNRU5UX1VSSSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGdfcGFyYW1fc3BlY19zdHJpbmcoIm1haW4tZG9jdW1lbnQtdXJp IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIk1haW4gRG9jdW1lbnQgVVJJIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIlRoZSBVUkkgb2YgdGhlIG1haW4gZG9jdW1lbnQgdGhh dCBpcyBiZWluZyByZW5kZXJlZCIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIE5VTEwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdFQktJVF9QQVJBTV9SRUFEV1JJVEUpKTsKKwor ICAgIGdfb2JqZWN0X2NsYXNzX2luc3RhbGxfcHJvcGVydHkob2JqZWN0Q2xhc3MsIFBST1BfSFRU UF9NRVRIT0QsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnX3BhcmFtX3Nw ZWNfc3RyaW5nKCJodHRwLW1ldGhvZCIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICJIVFRQIE1ldGhvZCIsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJUaGUgSFRUUCBtZXRob2Qg dGhpcyByZXF1ZXN0IHVzZXMiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBOVUxMLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRfUEFSQU1fUkVBRFdSSVRFKSk7CisKKyAg ICBnX29iamVjdF9jbGFzc19pbnN0YWxsX3Byb3BlcnR5KG9iamVjdENsYXNzLCBQUk9QX0FMTE9X X0hUVFBfQ09PS0lFUywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdfcGFy YW1fc3BlY19ib29sZWFuKCJhbGxvdy1odHRwLWNvb2tpZXMiLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIkFsbG93IEhUVFAgQ29va2ll cyIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAiV2hldGhlciBjb29raWVzIGFyZSB0byBiZSBhbGxvd2VkIGZvciB0aGlzIHJlcXVlc3Qi LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgVFJVRSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIFdFQktJVF9QQVJBTV9SRUFEV1JJVEUpKTsKIAogICAgIGdfdHlwZV9jbGFzc19h ZGRfcHJpdmF0ZShyZXF1ZXN0Q2xhc3MsIHNpemVvZihXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZh dGUpKTsKIH0KQEAgLTU0LDE4ICsxOTYsNTEgQEAgc3RhdGljIHZvaWQgd2Via2l0X25ldHdvcmtf cmVxdWVzdF9pbml0KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQogICAgIHJlcXVlc3Qt PnByaXYgPSBwcml2OwogfQogCi1XZWJLaXROZXR3b3JrUmVxdWVzdCogd2Via2l0X25ldHdvcmtf cmVxdWVzdF9uZXcoY29uc3QgZ2NoYXIqIHVyaSkKKy8vIGZvciBpbnRlcm5hbCB1c2Ugb25seQor V2ViS2l0TmV0d29ya1JlcXVlc3QqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X2Zyb21fcmVz b3VyY2VfcmVxdWVzdChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCkKIHsK LSAgICBnX3JldHVybl92YWxfaWZfZmFpbCh1cmksIE5VTEwpOwotCiAgICAgV2ViS2l0TmV0d29y a1JlcXVlc3QqIHJlcXVlc3QgPSBXRUJLSVRfTkVUV09SS19SRVFVRVNUKGdfb2JqZWN0X25ldyhX RUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIE5VTEwpKTsKICAgICBXZWJLaXROZXR3b3JrUmVx dWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OwogCi0gICAgcHJpdi0+dXJpID0gZ19z dHJkdXAodXJpKTsKKyAgICBwcml2LT5yZXF1ZXN0ID0gcmVzb3VyY2VSZXF1ZXN0OwogCiAgICAg cmV0dXJuIHJlcXVlc3Q7CiB9CiAKKy8vIGZvciBpbnRlcm5hbCB1c2Ugb25seQorUmVzb3VyY2VS ZXF1ZXN0IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3Jlc291cmNlX3JlcXVlc3QoY29uc3Qg V2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgV2ViS2l0TmV0d29ya1JlcXVl c3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIHJldHVybiBwcml2LT5yZXF1 ZXN0OworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3OgorICogQHVyaTog YW4gVVJJCisgKgorICogQ3JlYXRlcyBhIG5ldyAjV2ViS2l0TmV0d29ya1JlcXVlc3QgaW5pdGlh bGl6ZWQgd2l0aCBhbiBVUkkuCisgKgorICogUmV0dXJuczogYSBuZXcgI1dlYktpdE5ldHdvcmtS ZXF1ZXN0CisgKi8KK1dlYktpdE5ldHdvcmtSZXF1ZXN0KiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X25ldyhjb25zdCBnY2hhciogdXJpKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKHVyaSwg TlVMTCk7CisgICAgCisgICAgUmVzb3VyY2VSZXF1ZXN0IHJlc291cmNlUmVxdWVzdCA9IFJlc291 cmNlUmVxdWVzdChLVVJMKFN0cmluZzo6ZnJvbVVURjgodXJpKSkpOworCisgICAgV2ViS2l0TmV0 d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld19mcm9tX3Jl c291cmNlX3JlcXVlc3QocmVzb3VyY2VSZXF1ZXN0KTsKKworICAgIHJldHVybiByZXF1ZXN0Owor fQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaToKKyAqIEByZXF1ZXN0 OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICogQHVyaTogYW4gYWxyZWFkeSBlbmNvZGVkIFVS SQorICoKKyAqIFNldHMgdGhlIFVSSSBoZWxkIGFuZCB1c2VkIGJ5IHRoZSBnaXZlbiByZXF1ZXN0 LgorICovCiB2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaShXZWJLaXROZXR3b3Jr UmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIHVyaSkKIHsKICAgICBnX3JldHVybl9pZl9m YWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOwpAQCAtNzQsMTUgKzI0OSw0 MjYgQEAgdm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF91cmkoV2ViS2l0TmV0d29ya1Jl cXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKgogICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJp dmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CiAKICAgICBnX2ZyZWUocHJpdi0+dXJpKTsKLSAg ICBwcml2LT51cmkgPSBnX3N0cmR1cCh1cmkpOworICAgIHByaXYtPnJlcXVlc3Quc2V0VVJMKEtV UkwoU3RyaW5nOjpmcm9tVVRGOCh1cmkpKSk7CisgICAgZ19vYmplY3Rfbm90aWZ5KEdfT0JKRUNU KHJlcXVlc3QpLCAidXJpIik7CiB9CiAKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9n ZXRfdXJpOgorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CisgKgorICogR2V0 cyB0aGUgVVJJIGhlbGQgYW5kIHVzZWQgYnkgdGhlIGdpdmVuIHJlcXVlc3QuCisgKgorICogUmV0 dXJuczogdGhlIFVSSSBoZWxkIGFuZCB1c2VkIGJ5IHRoZSBnaXZlbiByZXF1ZXN0CisgKi8KIEdf Q09OU1RfUkVUVVJOIGdjaGFyKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF91cmkoV2ViS2l0 TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCiB7CiAgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VC S0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgTlVMTCk7CiAKICAgICBXZWJLaXROZXR3 b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgaWYgKHByaXYt PnVyaSkKKyAgICAgICAgcmV0dXJuIHByaXYtPnVyaTsKKworICAgIHByaXYtPnVyaSA9IGdfc3Ry ZHVwKHByaXYtPnJlcXVlc3QudXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisgICAgcmV0 dXJuIHByaXYtPnVyaTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9j YWNoZV9wb2xpY3k6CisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEBj YWNoZV9wb2xpY3k6IGEgI1dlYktpdFJlcUNhY2hlUG9saWN5CisgKgorICogRGVmaW5lcyB0aGUg cG9saWN5IFdlYktpdCBzaG91bGQgdXNlIHdoZW4gaGFuZGxpbmcgdGhlIHJlcXVlc3QsCisgKiBz dWNoIGFzIGlmIGl0IGlzIGFsbG93ZWQgdG8gdXNlIHRoZSBsb2NhbCBjYWNoZSwgaWYgdGhlIEhU VFAKKyAqIGNhY2hpbmcgcnVsZXMgc2hvdWxkIGJlIHVzZWQsIG9yIGlmIHdlIGFyZSBmb3JjaW5n IGEgcmVsb2FkLgorICovCit2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2NhY2hlX3Bv bGljeShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgV2ViS2l0UmVxQ2FjaGVQ b2xpY3kgY2FjaGVfcG9saWN5KQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05F VFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZh dGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgcHJpdi0+cmVxdWVzdC5zZXRDYWNoZVBv bGljeShjb3JlKGNhY2hlX3BvbGljeSkpOworICAgIGdfb2JqZWN0X25vdGlmeShHX09CSkVDVChy ZXF1ZXN0KSwgImNhY2hlLXBvbGljeSIpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X2NhY2hlX3BvbGljeToKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVx dWVzdAorICoKKyAqIE9idGFpbnMgdGhlIHBvbGljeSBXZWJLaXQgd291bGQgdXNlIHdoZW4gaGFu ZGxpbmcgdGhlIHJlcXVlc3QsIHN1Y2gKKyAqIGFzIGlmIGl0IGlzIGFsbG93ZWQgdG8gdXNlIHRo ZSBsb2NhbCBjYWNoZSwgaWYgdGhlIEhUVFAgY2FjaGluZworICogcnVsZXMgc2hvdWxkIGJlIHVz ZWQsIG9yIGlmIHdlIGFyZSBmb3JjaW5nIGEgcmVsb2FkLgorICoKKyAqIFJldHVybnM6IGEgI1dl YktpdFJlcUNhY2hlUG9saWN5CisgKi8KK1dlYktpdFJlcUNhY2hlUG9saWN5IHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfZ2V0X2NhY2hlX3BvbGljeShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVz dCkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNU KHJlcXVlc3QpLCBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9QUk9UT0NPTCk7CisKKyAgICBXZWJL aXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgcmV0 dXJuIGtpdChwcml2LT5yZXF1ZXN0LmNhY2hlUG9saWN5KCkpOworfQorCisvKioKKyAqIHdlYmtp dF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3RpbWVvdXRfaW50ZXJ2YWw6CisgKiBAcmVxdWVzdDogYSAj V2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEB0aW1lb3V0X2ludGVydmFsOiBhICNnZG91YmxlCisg KgorICogU2V0cyBob3cgbWFueSBzZWNvbmRzIFdlYktpdCB3b3VsZCB3YWl0IGZvciB0aGUgc2Vy dmVyIHdoZW4KKyAqIGhhbmRsaW5nIHRoZSBnaXZlbiByZXF1ZXN0LgorICovCit2b2lkIHdlYmtp dF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3RpbWVvdXRfaW50ZXJ2YWwoV2ViS2l0TmV0d29ya1JlcXVl c3QqIHJlcXVlc3QsIGNvbnN0IGdkb3VibGUgdGltZW91dF9pbnRlcnZhbCkKK3sKKyAgICBnX3Jl dHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworCisgICAg V2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAg IHByaXYtPnJlcXVlc3Quc2V0VGltZW91dEludGVydmFsKHRpbWVvdXRfaW50ZXJ2YWwpOworICAg IGdfb2JqZWN0X25vdGlmeShHX09CSkVDVChyZXF1ZXN0KSwgImNhY2hlLXBvbGljeSIpOworfQor CisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3RpbWVvdXRfaW50ZXJ2YWw6Cisg KiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqCisgKiBHZXRzIGhvdyBtYW55 IHNlY29uZHMgV2ViS2l0IHdvdWxkIHdhaXQgZm9yIHRoZSBzZXJ2ZXIgd2hlbgorICogaGFuZGxp bmcgdGhlIGdpdmVuIHJlcXVlc3QuCisgKgorICogUmV0dXJuczogYSAjZ2RvdWJsZQorICovCitn ZG91YmxlIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3RpbWVvdXRfaW50ZXJ2YWwoV2ViS2l0 TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VC S0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgMC4wKTsKKworICAgIFdlYktpdE5ldHdv cmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICByZXR1cm4gcHJp di0+cmVxdWVzdC50aW1lb3V0SW50ZXJ2YWwoKTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29y a19yZXF1ZXN0X3NldF9tYWluX2RvY3VtZW50X3VyaQorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5l dHdvcmtSZXF1ZXN0CisgKiBAbWFpbl9kb2N1bWVudF91cmk6IHRoZSBVUkkgb2YgdGhlIG1haW4g ZG9jdW1lbnQKKyAqCisgKiBTZXRzIHRoZSBtYWluIGRvY3VtZW50IFVSSS4KKyAqCisgKiBUaGUg bWFpbiBkb2N1bWVudCBpcyB0aGUgZG9jdW1lbnQgdGhhdCBpcyBiZWluZyByZW5kZXJlZDsgb3Ro ZXIKKyAqIGRvY3VtZW50cywgYmUgdGhlbSBIVE1MIHBhZ2VzLCBqYXZhc2NyaXB0IG9yIGNzcyBm aWxlcywgaW1hZ2VzLCBhbmQKKyAqIHNvIG9uIG1heSBiZSBuZWNlc3NhcnksIGFuZCB0aGUgcmVx dWVzdHMgdGhhdCBmZXRjaCB0aG9zZSBzaGFsbAorICogaGF2ZSB0aGlzIFVSSSBzZXQgdG8gdGhl IGRvY3VtZW50IHdoaWNoIHJlcXVpcmVzIHRoZW0uCisgKi8KK3ZvaWQgd2Via2l0X25ldHdvcmtf cmVxdWVzdF9zZXRfbWFpbl9kb2N1bWVudF91cmkoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVl c3QsIGNvbnN0IGdjaGFyKiBtYWluX2RvY3VtZW50X3VyaSkKK3sKKyAgICBnX3JldHVybl9pZl9m YWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworICAgIGdfcmV0dXJuX2lm X2ZhaWwobWFpbl9kb2N1bWVudF91cmkpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2 YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIGdfZnJlZShwcml2LT5tYWluRG9jdW1l bnRVUkkpOworICAgIHByaXYtPnJlcXVlc3Quc2V0TWFpbkRvY3VtZW50VVJMKEtVUkwoU3RyaW5n Ojpmcm9tVVRGOChtYWluX2RvY3VtZW50X3VyaSkpKTsKKyAgICBnX29iamVjdF9ub3RpZnkoR19P QkpFQ1QocmVxdWVzdCksICJtYWluLWRvY3VtZW50LXVyaSIpOworfQorCisvKioKKyAqIHdlYmtp dF9uZXR3b3JrX3JlcXVlc3RfZ2V0X21haW5fZG9jdW1lbnRfdXJpCisgKiBAcmVxdWVzdDogYSAj V2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqCisgKiBPYnRhaW5zIHRoZSBtYWluIGRvY3VtZW50IFVS SS4KKyAqCisgKiBUaGUgbWFpbiBkb2N1bWVudCBpcyB0aGUgZG9jdW1lbnQgdGhhdCBpcyBiZWlu ZyByZW5kZXJlZDsgb3RoZXIKKyAqIGRvY3VtZW50cywgYmUgdGhlbSBIVE1MIHBhZ2VzLCBqYXZh c2NyaXB0IG9yIGNzcyBmaWxlcywgaW1hZ2VzLCBhbmQKKyAqIHNvIG9uIG1heSBiZSBuZWNlc3Nh cnksIGFuZCB0aGUgcmVxdWVzdHMgdGhhdCBmZXRjaCB0aG9zZSBzaGFsbAorICogaGF2ZSB0aGlz IFVSSSBzZXQgdG8gdGhlIGRvY3VtZW50IHdoaWNoIHJlcXVpcmVzIHRoZW0uCisgKgorICogUmV0 dXJuczogYSBzdHJpbmcgd2l0aCB0aGUgbWFpbiBkb2N1bWVudCBVUkkKKyAqLworY29uc3QgZ2No YXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X21haW5fZG9jdW1lbnRfdXJpKFdlYktpdE5l dHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJ VF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOworCisgICAgV2ViS2l0TmV0d29y a1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIGlmIChwcml2LT51 cmkpCisgICAgICAgIHJldHVybiBwcml2LT51cmk7CisKKyAgICBwcml2LT51cmkgPSBnX3N0cmR1 cChwcml2LT5yZXF1ZXN0Lm1haW5Eb2N1bWVudFVSTCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkp OwogICAgIHJldHVybiBwcml2LT51cmk7CiB9CiAKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVx dWVzdF9zZXRfaHR0cF9tZXRob2QKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVz dAorICogQGh0dHBfbWV0aG9kOiB0aGUgSFRUUCBtZXRob2QKKyAqCisgKiBEZWZpbmVzIHdoYXQg bWV0aG9kLCBzdWNoIGFzIEdFVCwgUE9TVCwgSEVBRCwgYW5kIHNvIG9uLCB3b3VsZCBiZQorICog dXNlZCBieSBXZWJLaXQgd2hlbiB0YWxraW5nIHRvIHRoZSB3ZWJzZXJ2ZXIgZHVyaW5nIHRoaXMg cmVxdWVzdC4KKyAqLwordm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX21ldGhv ZChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0dHBfbWV0aG9k KQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1 ZXN0KSk7CisgICAgZ19yZXR1cm5faWZfZmFpbChodHRwX21ldGhvZCk7CisKKyAgICBXZWJLaXRO ZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgZ19mcmVl KHByaXYtPmh0dHBNZXRob2QpOworICAgIHByaXYtPnJlcXVlc3Quc2V0SFRUUE1ldGhvZChTdHJp bmc6OmZyb21VVEY4KGh0dHBfbWV0aG9kKSk7CisgICAgZ19vYmplY3Rfbm90aWZ5KEdfT0JKRUNU KHJlcXVlc3QpLCAiaHR0cC1tZXRob2QiKTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X2dldF9odHRwX21ldGhvZAorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1 ZXN0CisgKgorICogT2J0YWlucyB3aGF0IG1ldGhvZCwgc3VjaCBhcyBHRVQsIFBPU1QsIEhFQUQs IGFuZCBzbyBvbiwgd291bGQgYmUKKyAqIHVzZWQgYnkgV2ViS2l0IHdoZW4gdGFsa2luZyB0byB0 aGUgd2Vic2VydmVyIGR1cmluZyB0aGlzIHJlcXVlc3QuCisgKgorICogUmV0dXJuczogYSBzdHJp bmcgd2l0aCB0aGUgbmFtZSBvZiB0aGUgbWV0aG9kCisgKi8KK2NvbnN0IGdjaGFyKiB3ZWJraXRf bmV0d29ya19yZXF1ZXN0X2dldF9odHRwX21ldGhvZChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVx dWVzdCkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFV RVNUKHJlcXVlc3QpLCBOVUxMKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSog cHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBpZiAocHJpdi0+aHR0cE1ldGhvZCkKKyAgICAg ICAgcmV0dXJuIHByaXYtPmh0dHBNZXRob2Q7CisKKyAgICBwcml2LT5odHRwTWV0aG9kID0gZ19z dHJkdXAocHJpdi0+cmVxdWVzdC5odHRwTWV0aG9kKCkudXRmOCgpLmRhdGEoKSk7CisgICAgcmV0 dXJuIHByaXYtPmh0dHBNZXRob2Q7Cit9CisKK3N0YXRpYyB2b2lkIGNvcHlfaGVhZGVyKGNvbnN0 IGdjaGFyKiBrZXksIGNvbnN0IGdjaGFyKiB2YWx1ZSwgZ3BvaW50ZXIgZGF0YSkKK3sKKyAgICBX ZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IChXZWJLaXROZXR3b3JrUmVxdWVzdCopZGF0 YTsKKworICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfYWRkX2h0dHBfaGVhZGVyKHJlcXVlc3Qs IGtleSwgdmFsdWUpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfYWRkX2h0 dHBfaGVhZGVycworICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CisgKiBAaHR0 cF9oZWFkZXJzOiBhICNHSGFzaFRhYmxlIHdpdGggaGVhZGVyL3ZhbHVlIHBhaXJzLCBhcyBzdHJp bmdzCisgKgorICogQWRkcyB0aGUgaGVhZGVycyBjb250YWluZWQgYnkgdGhlIGdpdmVuIGhhc2gg dGFibGUgdG8gdGhlCisgKiByZXF1ZXN0LiBTZWUgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9hZGRf aHR0cF9oZWFkZXIoKS4KKyAqLwordm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2FkZF9odHRw X2hlYWRlcnMoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IEdIYXNoVGFibGUq IGh0dHBfaGVhZGVycykKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JL X1JFUVVFU1QocmVxdWVzdCkpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwoaHR0cF9oZWFkZXJzKTsK KworICAgIGdfaGFzaF90YWJsZV9mb3JlYWNoKChHSGFzaFRhYmxlKilodHRwX2hlYWRlcnMsIChH SEZ1bmMpY29weV9oZWFkZXIsIHJlcXVlc3QpOworfQorCitzdGF0aWMgR0hhc2hUYWJsZSogd2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9wcml2YXRlX2dldF9odHRwX2hlYWRlcnMoV2ViS2l0TmV0d29y a1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBw cml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIGlmKHByaXYtPmh0dHBIZWFkZXJzKQorICAgICAg ICByZXR1cm4gcHJpdi0+aHR0cEhlYWRlcnM7CisKKyAgICBwcml2LT5odHRwSGVhZGVycyA9IGdf aGFzaF90YWJsZV9uZXdfZnVsbChnX3N0cl9oYXNoLCBnX3N0cl9lcXVhbCwgZ19mcmVlLCBnX2Zy ZWUpOworICAgIEhUVFBIZWFkZXJNYXAgaGVhZGVycyA9IHByaXYtPnJlcXVlc3QuaHR0cEhlYWRl ckZpZWxkcygpOworICAgIGlmICghaGVhZGVycy5pc0VtcHR5KCkpIHsKKyAgICAgICAgSFRUUEhl YWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgZW5kID0gaGVhZGVycy5lbmQoKTsKKyAgICAgICAgZm9y IChIVFRQSGVhZGVyTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IGhlYWRlcnMuYmVnaW4oKTsgaXQg IT0gZW5kOyArK2l0KQorICAgICAgICAgICAgZ19oYXNoX3RhYmxlX2luc2VydChwcml2LT5odHRw SGVhZGVycywgKGdwb2ludGVyKWdfc3RyZHVwKGl0LT5maXJzdC51dGY4KCkuZGF0YSgpKSwgKGdw b2ludGVyKWdfc3RyZHVwKGl0LT5zZWNvbmQudXRmOCgpLmRhdGEoKSkpOworICAgIH0KKworICAg IHJldHVybiBwcml2LT5odHRwSGVhZGVyczsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X2dldF9odHRwX2hlYWRlcnMKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVx dWVzdAorICogUmV0dXJuczogYSAjR0hhc2hUYWJsZSB3aXRoIHRoZSBoZWFkZXJzCisgKgorICog T2J0YWlucyBhIHJlYWQtb25seSBoYXNoIHRhYmxlIHdpdGggdGhlIGhlYWRlcnMgZm9yIHRoZSBn aXZlbgorICogI1dlYktpdE5ldHdvcmtSZXF1ZXN0LgorICovCitjb25zdCBHSGFzaFRhYmxlKiB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRlcnMoV2ViS2l0TmV0d29ya1JlcXVl c3QqIHJlcXVlc3QpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdP UktfUkVRVUVTVChyZXF1ZXN0KSwgTlVMTCk7CisKKyAgICByZXR1cm4gd2Via2l0X25ldHdvcmtf cmVxdWVzdF9wcml2YXRlX2dldF9odHRwX2hlYWRlcnMocmVxdWVzdCk7Cit9CisKKy8qKgorICog d2Via2l0X25ldHdvcmtfcmVxdWVzdF9hZGRfaHR0cF9oZWFkZXIKKyAqIEByZXF1ZXN0OiBhICNX ZWJLaXROZXR3b3JrUmVxdWVzdAorICogQGh0dHBfaGVhZGVyOiBhIHN0cmluZyB3aXRoIHRoZSBu YW1lIG9mIHRoZSBoZWFkZXIKKyAqIEB2YWx1ZTogYSBzdHJpbmcgd2l0aCB0aGUgdmFsdWUgb2Yg dGhlIGhlYWRlcgorICoKKyAqIEFkZHMgdGhlIEhUVFAgaGVhZGVyIHRvIHRoZSByZXF1ZXN0LiBI ZWFkZXJzIHdoaWNoIGFscmVhZHkgZXhpc3QgaW4KKyAqIHRoZSByZXF1ZXN0IHdpbGwgaGF2ZSB0 aGVpciB2YWx1ZSBhcHBlbmRlZCB0bywgd2l0aCBhIHNlcGFyYXRlZAorICogY29tbWEuCisgKgor ICogRm9yIGluc3RhbmNlOiBpZiB0aGUgcmVxdWVzdCBhbHJlYWR5IGhhcyBhbiBBY2NlcHQtTGFu Z3VhZ2UgaGVhZGVyCisgKiB3aXRoIGEgdmFsdWUgb2YgImRhIiwgYW5kIHdlIGFkZCB0aGUgc2Ft ZSBBY2NlcHQtTGFuZ3VhZ2UgaGVhZGVyCisgKiBjb250YWluaW5nICJlbi1nYjtxPTAuOCIgd2Ug d2lsbCBlbmQgdXAgaGF2aW5nIGEgc2luZ2xlCisgKiBBY2NlcHQtTGFuZ3VhZ2UgaGVhZGVyIHdp dGggYSB2YWx1ZSBvZiAiZGEsZW4tZ2I7cT0wLjgiLgorICovCit2b2lkIHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfYWRkX2h0dHBfaGVhZGVyKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBj b25zdCBnY2hhciogaHR0cF9oZWFkZXIsIGNvbnN0IGdjaGFyKiB2YWx1ZSkKK3sKKyAgICBnX3Jl dHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworICAgIGdf cmV0dXJuX2lmX2ZhaWwoaHR0cF9oZWFkZXIpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwodmFsdWUp OworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJp djsKKyAgICBHSGFzaFRhYmxlKiBoYXNoX3RhYmxlID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9w cml2YXRlX2dldF9odHRwX2hlYWRlcnMocmVxdWVzdCk7CisKKyAgICBncG9pbnRlciBrZXlfbG9v a3VwOworCisgICAga2V5X2xvb2t1cCA9IGdfaGFzaF90YWJsZV9sb29rdXAoaGFzaF90YWJsZSwg aHR0cF9oZWFkZXIpOworICAgIGlmICgha2V5X2xvb2t1cCkKKyAgICAgICAgZ19oYXNoX3RhYmxl X2luc2VydChoYXNoX3RhYmxlLCAoZ3BvaW50ZXIpZ19zdHJkdXAoaHR0cF9oZWFkZXIpLCAoZ3Bv aW50ZXIpZ19zdHJkdXAodmFsdWUpKTsKKyAgICBlbHNlIHsKKyAgICAgICAgZ2NoYXIqIG5ld192 YWx1ZSA9IGdfc3RyZHVwX3ByaW50ZigiJXMsJXMiLCAoZ2NoYXIqKWtleV9sb29rdXAsIHZhbHVl KTsKKyAgICAgICAgZ19oYXNoX3RhYmxlX3JlcGxhY2UoaGFzaF90YWJsZSwgKGdwb2ludGVyKWdf c3RyZHVwKGh0dHBfaGVhZGVyKSwgKGdwb2ludGVyKWdfc3RyZHVwKG5ld192YWx1ZSkpOworICAg ICAgICBnX2ZyZWUobmV3X3ZhbHVlKTsKKyAgICB9CisKKyAgICBwcml2LT5yZXF1ZXN0LmFkZEhU VFBIZWFkZXJGaWVsZChTdHJpbmc6OmZyb21VVEY4KGh0dHBfaGVhZGVyKSwgU3RyaW5nOjpmcm9t VVRGOCh2YWx1ZSkpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0 dHBfaGVhZGVyCisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEBodHRw X2hlYWRlcjogYSBzdHJpbmcgd2l0aCB0aGUgbmFtZSBvZiB0aGUgaGVhZGVyCisgKiBAdmFsdWU6 IGEgc3RyaW5nIHdpdGggdGhlIHZhbHVlIG9mIHRoZSBoZWFkZXIKKyAqCisgKiBTZXRzIHRoZSBo ZWFkZXIgdG8gY29udGFpbiB0aGUgZ2l2ZW4gdmFsdWUsIGluIHRoaXMgcmVxdWVzdC4gSWYgdGhl CisgKiBoZWFkZXIgYWxyZWFkeSBleGlzdHMgaW4gdGhlIHJlcXVlc3QgdGhlIHZhbHVlIGlzIHJl cGxhY2VkLgorICovCit2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBfaGVhZGVy KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciogaHR0cF9oZWFkZXIs IGNvbnN0IGdjaGFyKiB2YWx1ZSkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19O RVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwoaHR0cF9oZWFk ZXIpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwodmFsdWUpOworCisgICAgV2ViS2l0TmV0d29ya1Jl cXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKyAgICBHSGFzaFRhYmxlKiBoZWFk ZXJzID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9wcml2YXRlX2dldF9odHRwX2hlYWRlcnMocmVx dWVzdCk7CisKKyAgICBnX2hhc2hfdGFibGVfcmVwbGFjZShoZWFkZXJzLCBnX3N0cmR1cChodHRw X2hlYWRlciksIGdfc3RyZHVwKHZhbHVlKSk7CisgICAgCisgICAgcHJpdi0+cmVxdWVzdC5zZXRI VFRQSGVhZGVyRmllbGQoU3RyaW5nOjpmcm9tVVRGOChodHRwX2hlYWRlciksIFN0cmluZzo6ZnJv bVVURjgodmFsdWUpKTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9o dHRwX2hlYWRlcgorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CisgKiBAaHR0 cF9oZWFkZXI6IHRoZSBuYW1lIG9mIHRoZSBoZWFkZXIgd2Ugd2FudCB0byBvYnRhaW4gdGhlIHZh bHVlIGZvcgorICoKKyAqIEdldHMgdGhlIHZhbHVlIG9mIHRoZSB0aGUgaGVhZGVyIGluIHRoZSBn aXZlbiByZXF1ZXN0LiBJZiB0aGUKKyAqIGhlYWRlciBkb2VzIG5vdCBleGlzdCBpbiB0aGUgcmVx dWVzdCAlTlVMTCBpcyByZXR1cm5lZC4KKyAqCisgKiBSZXR1cm5zOiBhIHN0cmluZyB3aXRoIHRo ZSB2YWx1ZSBmb3IgdGhlIGhlYWRlciwgb3IgTlVMTCBpZiB0aGF0CisgKiBoZWFkZXIgaXMgbm90 IHNldCBmb3IgdGhlIHJlcXVlc3QKKyAqLworY29uc3QgZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X2h0dHBfaGVhZGVyKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25z dCBnY2hhciogaHR0cF9oZWFkZXIpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lU X0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgTlVMTCk7CisgICAgZ19yZXR1cm5fdmFsX2lm X2ZhaWwoaHR0cF9oZWFkZXIsIE5VTEwpOworCisgICAgR0hhc2hUYWJsZSogaGVhZGVycyA9IHdl YmtpdF9uZXR3b3JrX3JlcXVlc3RfcHJpdmF0ZV9nZXRfaHR0cF9oZWFkZXJzKHJlcXVlc3QpOwor CisgICAgcmV0dXJuIChjb25zdCBnY2hhciopZ19oYXNoX3RhYmxlX2xvb2t1cChoZWFkZXJzLCAo Z2NvbnN0cG9pbnRlcilodHRwX2hlYWRlcik7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtf cmVxdWVzdF9zZXRfYm9keQorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0Cisg KiBAYm9keTogdGhlIGRhdGEgdGhhdCBzaG91bGQgYmUgc2VudCBhcyB0aGUgYm9keSBmb3IgdGhp cyByZXF1ZXN0CisgKiBAbGVuZ3RoOiBzaXplIG9mIHRoZSBkYXRhCisgKgorICogU2V0cyB0aGUg Ym9keSBvZiB0aGUgcmVxdWVzdCB0byB0aGUgY29udGVudHMgb2YgdGhlIGdpdmVuCisgKiBzdHJp bmcuIFlvdSB3aWxsIGFsc28gcHJvYmFibHkgbmVlZCB0byBjYWxsCisgKiB3ZWJraXRfbmV0d29y a19yZXF1ZXN0X3NldF9oZWFkZXIoKSB0byBzcGVjaWZ5IHRoZSBDb250ZW50LUxlbmd0aAorICog aGVhZGVyLgorICovCit2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2JvZHkoV2ViS2l0 TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBib2R5LCBjb25zdCBnc2l6ZSBz aXplKQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChy ZXF1ZXN0KSk7CisgICAgZ19yZXR1cm5faWZfZmFpbChib2R5KTsKKworICAgIFdlYktpdE5ldHdv cmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBnX2ZyZWUocHJp di0+Ym9keSk7CisgICAgcHJpdi0+Ym9keVNpemUgPSAwOworICAgIHByaXYtPnJlcXVlc3Quc2V0 SFRUUEJvZHkoRm9ybURhdGE6OmNyZWF0ZSgoY29uc3Qgdm9pZCopYm9keSwgKHNpemVfdClzaXpl KSk7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfYm9keQorICogQHJl cXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CisgKiBAYm9keV9zaXplOiBhIHBvaW50ZXIg dG8gYSAjZ3NpemUsIG9yICVOVUxMCisgKgorICogR2V0cyB0aGUgYm9keSBvZiB0aGUgcmVxdWVz dC4gSWYgZ2l2ZW4sIEBib2R5X3NpemUgd2lsbCBiZSBzZXQgdG8KKyAqIHRoZSBzaXplIG9mIHRo ZSBib2R5IGRhdGEuIFRoaXMgaXMgdXNlZnVsIGJlY2F1c2UgdGhlIGJvZHkgbWF5IG5vdAorICog YmUgYSBzdHJpbmcsIGFuZCBtYXkgaGF2ZSBhIG51bWJlciBvZiAnXDAnIGNoYXJhY3RlcnMgYXMg cGFydCBvZgorICogdGhlIGRhdGEuCisgKgorICogUmV0dXJuczogYSBzdHJpbmcgd2l0aCB0aGUg Ym9keSBvZiB0aGUgcmVxdWVzdCBvciAlTlVMTCBpZiB0aGUKKyAqIHJlcXVlc3QgZG9lcyBub3Qg aGF2ZSBhIGJvZHkKKyAqLworY29uc3QgZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0 X2JvZHkoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGdzaXplICpib2R5X3NpemUpCit7 CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1 ZXN0KSwgTlVMTCk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSBy ZXF1ZXN0LT5wcml2OworCisgICAgaWYgKGdfYXNjaWlfc3RyY2FzZWNtcCAod2Via2l0X25ldHdv cmtfcmVxdWVzdF9nZXRfaHR0cF9tZXRob2QocmVxdWVzdCksICJQT1NUIikgPT0gMCkgeworICAg ICAgICBpZighcHJpdi0+Ym9keSkgeworICAgICAgICAgICAgVmVjdG9yPGNoYXI+IGRhdGE7Cisg ICAgICAgICAgICBwcml2LT5yZXF1ZXN0Lmh0dHBCb2R5KCktPmZsYXR0ZW4oZGF0YSk7CisgICAg ICAgICAgICBwcml2LT5ib2R5ID0gZ19zdHJkdXAoZGF0YS5kYXRhKCkpOworICAgICAgICAgICAg cHJpdi0+Ym9keVNpemUgPSBkYXRhLnNpemUoKTsKKyAgICAgICAgfQorCisgICAgICAgICpib2R5 X3NpemUgPSBwcml2LT5ib2R5U2l6ZTsKKyAgICAgICAgcmV0dXJuIHByaXYtPmJvZHk7CisgICAg fQorCisgICAgcmV0dXJuIE5VTEw7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVxdWVz dF9zZXRfYWxsb3dfaHR0cF9jb29raWVzCisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1Jl cXVlc3QKKyAqIEBhbGxvd19odHRwX2Nvb2tpZXM6IHdoZXRoZXIgSFRUUCBjb29raWVzIHNob3Vs ZCBiZSBhbGxvd2VkCisgKgorICogU2V0cyB3aGV0aGVyIEhUVFAgY29va2llcyBzaG91bGQgYmUg YWxsb3dlZCB0byBiZSBzZXQgaW4gcmVzcG9uc2UKKyAqIHRvIHRoaXMgcmVxdWVzdC4KKyAqLwor dm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9hbGxvd19odHRwX2Nvb2tpZXMoV2ViS2l0 TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdib29sZWFuIGFsbG93X2h0dHBfY29va2ll cykKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVx dWVzdCkpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVz dC0+cHJpdjsKKworICAgIHByaXYtPnJlcXVlc3Quc2V0QWxsb3dIVFRQQ29va2llcyhhbGxvd19o dHRwX2Nvb2tpZXMpOworICAgIGdfb2JqZWN0X25vdGlmeShHX09CSkVDVChyZXF1ZXN0KSwgImFs bG93LWh0dHAtY29va2llcyIpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf Z2V0X2FsbG93X2h0dHBfY29va2llcworICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1 ZXN0CisgKgorICogT2J0YWlucyB3aGV0aGVyIGNvb2tpZXMgYXJlIGFsbG93ZWQgYnkgdGhlIHJl cXVlc3QuCisgKgorICogUmV0dXJuczogJVRSVUUgaWYgY29va2llcyBhcmUgYWxsb3dlZCBpbiBy ZXNwb25zZSB0byB0aGlzIHJlcXVlc3QsCisgKiAlRkFMU0Ugb3RoZXJ3aXNlCisgKi8KK2dib29s ZWFuIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2FsbG93X2h0dHBfY29va2llcyhXZWJLaXRO ZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJL SVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBGQUxTRSk7CisKKyAgICBXZWJLaXROZXR3 b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgcmV0dXJuIHBy aXYtPnJlcXVlc3QuYWxsb3dIVFRQQ29va2llcygpOworfQorCiB9CmRpZmYgLS1naXQgYS9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oIGIvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0bmV0d29ya3JlcXVlc3QuaAppbmRleCBkZmI0ZDZjLi44MTBjMjU2IDEwMDY0NAotLS0g YS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oCisrKyBiL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmgKQEAgLTEsNSArMSw2IEBACiAvKgogICog Q29weXJpZ2h0IChDKSAyMDA3IEhvbGdlciBIYW5zIFBldGVyIEZyZXl0aGVyCisgKiBDb3B5cmln aHQgKEMpIDIwMDggR3VzdGF2byBOb3JvbmhhIFNpbHZhCiAgKgogICogVGhpcyBsaWJyYXJ5IGlz IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9kaWZ5 IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAg LTQ1LDYgKzQ2LDI5IEBAIHN0cnVjdCBfV2ViS2l0TmV0d29ya1JlcXVlc3RDbGFzcyB7CiAgICAg R09iamVjdENsYXNzIHBhcmVudF9jbGFzczsKIH07CiAKKy8qIFRoZSBXZWJLaXRSZXFDYWNoZVBv bGljeSBlbnVtIG11c3QgYmUgaW4gc3luYyB3aXRoCisgKiBSZXNvdXJjZVJlcXVlc3RDYWNoZVBv bGljeSBpbiAKKyAqIFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZVJlcXVlc3RCYXNl LmgKKyAqLworLyoqCisgKiBXZWJLaXRSZXFDYWNoZVBvbGljeToKKyAqIEBXRUJLSVRfUkVRX0NB Q0hFX1BPTElDWV9QUk9UT0NPTDogdXNlIHRoZSBIVFRQIHByb3RvY29sIGNhY2hpbmcKKyAqIHJ1 bGVzCisgKiBAV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfUkVMT0FEX0lHTk9SSU5HX0NBQ0hFOiBm b3JjZSBhIHJlbG9hZCwKKyAqIGlnbm9yaW5nIGFueSBjYWNoZQorICogQFdFQktJVF9SRVFfQ0FD SEVfUE9MSUNZX0FMTE9XX1NUQUxFOiB1c2UgZGF0YSBmcm9tIGNhY2hlLCBpZgorICogYXZhaWxh YmxlLCBldmVuIGlmIGl0IGlzIHN0YWxlLCBhbmQgbG9hZCBpdCBmcmVzaCBvdGhlcndpc2UKKyAq IEBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9DQUNIRV9PTkxZOiBmb3JjZSB1c2luZyB0aGUgY2Fj aGUgb25seTsKKyAqIHVzZWZ1bCBmb3Igb2ZmbGluZSBtb2RlcworICovCit0eXBlZGVmIGVudW0K K3sKKyAgV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfUFJPVE9DT0wsCisgIFdFQktJVF9SRVFfQ0FD SEVfUE9MSUNZX1JFTE9BRF9JR05PUklOR19DQUNIRSwKKyAgV0VCS0lUX1JFUV9DQUNIRV9QT0xJ Q1lfQUxMT1dfU1RBTEUsCisgIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX0NBQ0hFX09OTFksCit9 IFdlYktpdFJlcUNhY2hlUG9saWN5OworCiBXRUJLSVRfQVBJIEdUeXBlCiB3ZWJraXRfbmV0d29y a19yZXF1ZXN0X2dldF90eXBlICh2b2lkKTsKIApAQCAtNTgsNiArODIsNTcgQEAgd2Via2l0X25l dHdvcmtfcmVxdWVzdF9zZXRfdXJpICAoV2ViS2l0TmV0d29ya1JlcXVlc3QgKnJlcXVlc3QsCiBX RUJLSVRfQVBJIEdfQ09OU1RfUkVUVVJOIGdjaGFyICoKIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf Z2V0X3VyaSAgKFdlYktpdE5ldHdvcmtSZXF1ZXN0ICpyZXF1ZXN0KTsKIAorV0VCS0lUX0FQSSB2 b2lkCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9jYWNoZV9wb2xpY3koV2ViS2l0TmV0d29y a1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IFdlYktpdFJlcUNhY2hlUG9saWN5IGNhY2hlX3BvbGlj eSk7CisKK1dFQktJVF9BUEkgV2ViS2l0UmVxQ2FjaGVQb2xpY3kKK3dlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X2NhY2hlX3BvbGljeShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CisK K1dFQktJVF9BUEkgdm9pZAord2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdGltZW91dF9pbnRl cnZhbChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2RvdWJsZSB0aW1lb3V0 X2ludGVydmFsKTsKKworV0VCS0lUX0FQSSBnZG91YmxlCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X2dldF90aW1lb3V0X2ludGVydmFsKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKwor V0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9tYWluX2RvY3VtZW50 X3VyaShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIG1haW5fZG9j dW1lbnRfdXJpKTsKKworV0VCS0lUX0FQSSBjb25zdCBnY2hhcioKK3dlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X21haW5fZG9jdW1lbnRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0 KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX21l dGhvZCAoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX21l dGhvZCk7CisKK1dFQktJVF9BUEkgY29uc3QgZ2NoYXIqCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X2dldF9odHRwX21ldGhvZCAoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCitXRUJL SVRfQVBJIHZvaWQKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfYWRkX2h0dHBfaGVhZGVycyAoV2Vi S2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IEdIYXNoVGFibGUqIGh0dHBfaGVhZGVy cyk7CisKK1dFQktJVF9BUEkgY29uc3QgR0hhc2hUYWJsZSoKK3dlYmtpdF9uZXR3b3JrX3JlcXVl c3RfZ2V0X2h0dHBfaGVhZGVycyAoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCitX RUJLSVRfQVBJIHZvaWQKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfYWRkX2h0dHBfaGVhZGVyKFdl YktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciogaHR0cF9oZWFkZXIsIGNv bnN0IGdjaGFyKiB2YWx1ZSk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X25ldHdvcmtfcmVx dWVzdF9zZXRfaHR0cF9oZWFkZXIgKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25z dCBnY2hhciogaHR0cF9oZWFkZXIsIGNvbnN0IGdjaGFyKiB2YWx1ZSk7CisKK1dFQktJVF9BUEkg Y29uc3QgZ2NoYXIqCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRlciAoV2Vi S2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX2hlYWRlcik7CisK K1dFQktJVF9BUEkgdm9pZAord2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfYm9keShXZWJLaXRO ZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGJvZHksIGNvbnN0IGdzaXplIHNp emUpOworCitXRUJLSVRfQVBJIGNvbnN0IGdjaGFyKgord2Via2l0X25ldHdvcmtfcmVxdWVzdF9n ZXRfYm9keShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgZ3NpemUgKmJvZHlfc2l6ZSk7 CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfYWxsb3dfaHR0 cF9jb29raWVzKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnYm9vbGVhbiBh bGxvd19odHRwX2Nvb2tpZXMpOworCitXRUJLSVRfQVBJIGdib29sZWFuCit3ZWJraXRfbmV0d29y a19yZXF1ZXN0X2dldF9hbGxvd19odHRwX2Nvb2tpZXMoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJl cXVlc3QpOworCiBHX0VORF9ERUNMUwogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXRuZXR3b3JrcmVzcG9uc2UuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LmY0OGYxOWEKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3 b3JrcmVzcG9uc2UuY3BwCkBAIC0wLDAgKzEsMTUwIEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDA4IEd1c3Rhdm8gTm9yb25oYSBTaWx2YQorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNv ZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRl ciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNl IGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAq IHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIg dmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUg dGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0 aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3Ig RklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFy eSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNo b3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJs aWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZ SU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1B IDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRl ICJ3ZWJraXRuZXR3b3JrcmVzcG9uc2UuaCIKKworI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgi CisjaW5jbHVkZSAiUmVzb3VyY2VSZXNwb25zZS5oIgorI2luY2x1ZGUgIkNTdHJpbmcuaCIKKwor dXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKK2V4dGVybiAiQyIgeworCitHX0RFRklORV9UWVBF KFdlYktpdE5ldHdvcmtSZXNwb25zZSwgd2Via2l0X25ldHdvcmtfcmVzcG9uc2UsIEdfVFlQRV9P QkpFQ1QpOworCitzdHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUgeworICAgIFJl c291cmNlUmVzcG9uc2UgcmVzcG9uc2U7CisKKyAgICBnY2hhciogdXJpOworfTsKKworI2RlZmlu ZSBXRUJLSVRfTkVUV09SS19SRVNQT05TRV9HRVRfUFJJVkFURShvYmopIChHX1RZUEVfSU5TVEFO Q0VfR0VUX1BSSVZBVEUoKG9iaiksIFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UsIFdlYktp dE5ldHdvcmtSZXNwb25zZVByaXZhdGUpKQorCitzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19y ZXNwb25zZV9maW5hbGl6ZShHT2JqZWN0KiBvYmplY3QpCit7CisgICAgV2ViS2l0TmV0d29ya1Jl c3BvbnNlKiByZXNwb25zZSA9IFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKG9iamVjdCk7CisgICAg V2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSogcHJpdiA9IHJlc3BvbnNlLT5wcml2OworCisg ICAgZ19mcmVlKHByaXYtPnVyaSk7CisKKyAgICBHX09CSkVDVF9DTEFTUyh3ZWJraXRfbmV0d29y a19yZXNwb25zZV9wYXJlbnRfY2xhc3MpLT5maW5hbGl6ZShvYmplY3QpOworfQorCitzdGF0aWMg dm9pZCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9jbGFzc19pbml0KFdlYktpdE5ldHdvcmtSZXNw b25zZUNsYXNzKiByZXNwb25zZUNsYXNzKQoreworICAgIEdfT0JKRUNUX0NMQVNTKHJlc3BvbnNl Q2xhc3MpLT5maW5hbGl6ZSA9IHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2ZpbmFsaXplOworCisg ICAgZ190eXBlX2NsYXNzX2FkZF9wcml2YXRlKHJlc3BvbnNlQ2xhc3MsIHNpemVvZihXZWJLaXRO ZXR3b3JrUmVzcG9uc2VQcml2YXRlKSk7Cit9CisKK3N0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3Jr X3Jlc3BvbnNlX2luaXQoV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSkKK3sKKyAgICBX ZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlKiBwcml2ID0gV0VCS0lUX05FVFdPUktfUkVTUE9O U0VfR0VUX1BSSVZBVEUocmVzcG9uc2UpOworICAgIHJlc3BvbnNlLT5wcml2ID0gcHJpdjsKK30K KworCisvLyBmb3IgaW50ZXJuYWwgdXNlIG9ubHkKK1dlYktpdE5ldHdvcmtSZXNwb25zZSogd2Vi a2l0X25ldHdvcmtfcmVzcG9uc2VfbmV3X2Zyb21fcmVzb3VyY2VfcmVzcG9uc2UoUmVzb3VyY2VS ZXNwb25zZSYgcmVzb3VyY2VSZXNwb25zZSkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2Uq IHJlc3BvbnNlID0gV0VCS0lUX05FVFdPUktfUkVTUE9OU0UoZ19vYmplY3RfbmV3KFdFQktJVF9U WVBFX05FVFdPUktfUkVTUE9OU0UsIE5VTEwpKTsKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2VQ cml2YXRlKiBwcml2ID0gcmVzcG9uc2UtPnByaXY7CisKKyAgICBwcml2LT5yZXNwb25zZSA9IHJl c291cmNlUmVzcG9uc2U7CisKKyAgICByZXR1cm4gcmVzcG9uc2U7Cit9CisKKy8vIGZvciBpbnRl cm5hbCB1c2Ugb25seQorUmVzb3VyY2VSZXNwb25zZSB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9n ZXRfcmVzb3VyY2VfcmVzcG9uc2UoY29uc3QgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25z ZSkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlKiBwcml2ID0gcmVzcG9uc2Ut PnByaXY7CisKKyAgICByZXR1cm4gcHJpdi0+cmVzcG9uc2U7Cit9CisKKy8qKgorICogd2Via2l0 X25ldHdvcmtfcmVzcG9uc2VfbmV3OgorICogQHVyaTogYW4gYWxyZWFkeSBlbmNvZGVkIFVSSQor ICoKKyAqIENyZWF0ZXMgYSBuZXcgI1dlYktpdE5ldHdvcmtSZXNwb25zZSBpbml0aWFsaXplZCB3 aXRoIGFuIFVSSS4KKyAqCisgKiBSZXR1cm5zOiBhIG5ldyAjV2ViS2l0TmV0d29ya1Jlc3BvbnNl CisgKi8KK1dlYktpdE5ldHdvcmtSZXNwb25zZSogd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfbmV3 KGNvbnN0IGdjaGFyKiB1cmkpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwodXJpLCBOVUxM KTsKKworICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UgPSBXRUJLSVRfTkVUV09S S19SRVNQT05TRShnX29iamVjdF9uZXcoV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSwgTlVM TCkpOworICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUqIHByaXYgPSByZXNwb25zZS0+ cHJpdjsKKworICAgIHByaXYtPnVyaSA9IGdfc3RyZHVwKHVyaSk7CisKKyAgICByZXR1cm4gcmVz cG9uc2U7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVzcG9uc2Vfc2V0X3VyaToKKyAq IEByZXNwb25zZTogYSAjV2ViS2l0TmV0d29ya1Jlc3BvbnNlCisgKiBAdXJpOiBhbiBhbHJlYWR5 IGVuY29kZWQgVVJJCisgKgorICogU2V0cyB0aGUgVVJJIGhlbGQgYW5kIHVzZWQgYnkgdGhlIGdp dmVuIHJlc3BvbnNlLgorICovCit2b2lkIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX3NldF91cmko V2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSwgY29uc3QgZ2NoYXIqIHVyaSkKK3sKKyAg ICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFU1BPTlNFKHJlc3BvbnNlKSk7 CisgICAgZ19yZXR1cm5faWZfZmFpbCh1cmkpOworCisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNl UHJpdmF0ZSogcHJpdiA9IHJlc3BvbnNlLT5wcml2OworCisgICAgZ19mcmVlKHByaXYtPnVyaSk7 CisgICAgcHJpdi0+dXJpID0gZ19zdHJkdXAodXJpKTsKKworICAgIC8qIAorICAgICAqIGZlZWRp bmcgYmFjayB0byB0aGUgUmVzb3VyY2VSZXNwb25zZSBvYmplY3QsIHdoaWNoIGlzIHRoZSBvbmUg YWN0dWFsbHkgdXNlZAorICAgICAqIGluc2lkZSBXZWJDb3JlCisgICAgICovCisgICAgcHJpdi0+ cmVzcG9uc2Uuc2V0VXJsKEtVUkwoU3RyaW5nOjpmcm9tVVRGOCh1cmkpKSk7Cit9CisKKy8qKgor ICogd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3VyaToKKyAqIEByZXNwb25zZTogYSAjV2Vi S2l0TmV0d29ya1Jlc3BvbnNlCisgKgorICogR2V0cyB0aGUgVVJJIGhlbGQgYW5kIHVzZWQgYnkg dGhlIGdpdmVuIHJlc3BvbnNlLgorICoKKyAqIFJldHVybnM6IHRoZSBVUkkgaGVsZCBhbmQgdXNl ZCBieSB0aGUgZ2l2ZW4gcmVzcG9uc2UKKyAqLworY29uc3QgZ2NoYXIqIHdlYmtpdF9uZXR3b3Jr X3Jlc3BvbnNlX2dldF91cmkoV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSkKK3sKKyAg ICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVNQT05TRShyZXNwb25z ZSksIE5VTEwpOworCisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSogcHJpdiA9IHJl c3BvbnNlLT5wcml2OworICAgIAorICAgIGlmIChwcml2LT51cmkpCisgICAgICAgIHJldHVybiBw cml2LT51cmk7CisKKyAgICBwcml2LT51cmkgPSBnX3N0cmR1cChwcml2LT5yZXNwb25zZS51cmwo KS5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKyAgICByZXR1cm4gcHJpdi0+dXJpOworfQorCit9 CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuaCBi L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5oCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLjM3OGE4YTUKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuaApAQCAtMCwwICsxLDYzIEBACisvKgor ICogQ29weXJpZ2h0IChDKSAyMDA4IEd1c3Rhdm8gTm9yb25oYSBTaWx2YQorICoKKyAqIFRoaXMg bGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IK KyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwg UHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3Vu ZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIg b3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VU IEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBN RVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUg dGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFp bHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExp YnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7 IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxv b3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaWZuZGVmIFdFQktJ VF9ORVRXT1JLX1JFU1BPTlNFX0gKKyNkZWZpbmUgV0VCS0lUX05FVFdPUktfUkVTUE9OU0VfSAor CisjaW5jbHVkZSA8Z2xpYi1vYmplY3QuaD4KKworI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRkZWZp bmVzLmg+CisKK0dfQkVHSU5fREVDTFMKKworI2RlZmluZSBXRUJLSVRfVFlQRV9ORVRXT1JLX1JF U1BPTlNFICAgICAgICAgICAgKHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF90eXBlKCkpCisj ZGVmaW5lIFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKG9iaikgICAgICAgICAgICAoR19UWVBFX0NI RUNLX0lOU1RBTkNFX0NBU1QoKG9iaiksIFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UsIFdl YktpdE5ldHdvcmtSZXNwb25zZSkpCisjZGVmaW5lIFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFX0NM QVNTKGtsYXNzKSAgICAoR19UWVBFX0NIRUNLX0NMQVNTX0NBU1QoKGtsYXNzKSwgIFdFQktJVF9U WVBFX05FVFdPUktfUkVTUE9OU0UsIFdlYktpdE5ldHdvcmtSZXNwb25zZUNsYXNzKSkKKyNkZWZp bmUgV0VCS0lUX0lTX05FVFdPUktfUkVTUE9OU0Uob2JqKSAgICAgICAgIChHX1RZUEVfQ0hFQ0tf SU5TVEFOQ0VfVFlQRSgob2JqKSwgV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSkpCisjZGVm aW5lIFdFQktJVF9JU19ORVRXT1JLX1JFU1BPTlNFX0NMQVNTKGtsYXNzKSAoR19UWVBFX0NIRUNL X0NMQVNTX1RZUEUoKGtsYXNzKSwgIFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UpKQorI2Rl ZmluZSBXRUJLSVRfTkVUV09SS19SRVNQT05TRV9HRVRfQ0xBU1Mob2JqKSAgKEdfVFlQRV9JTlNU QU5DRV9HRVRfQ0xBU1MoKG9iaiksICBXRUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNFLCBXZWJL aXROZXR3b3JrUmVzcG9uc2VDbGFzcykpCisKK3R5cGVkZWYgc3RydWN0IF9XZWJLaXROZXR3b3Jr UmVzcG9uc2VQcml2YXRlIFdlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGU7CisKK3N0cnVjdCBf V2ViS2l0TmV0d29ya1Jlc3BvbnNlIHsKKyAgICBHT2JqZWN0IHBhcmVudF9pbnN0YW5jZTsKKwor ICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUqIHByaXY7Cit9OworCitzdHJ1Y3QgX1dl YktpdE5ldHdvcmtSZXNwb25zZUNsYXNzIHsKKyAgICBHT2JqZWN0Q2xhc3MgcGFyZW50X2NsYXNz OworfTsKKworV0VCS0lUX0FQSSBHVHlwZQord2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3R5 cGUgKHZvaWQpOworCitXRUJLSVRfQVBJIFdlYktpdE5ldHdvcmtSZXNwb25zZSoKK3dlYmtpdF9u ZXR3b3JrX3Jlc3BvbnNlX25ldyAoY29uc3QgZ2NoYXIqIHVyaSk7CisKK1dFQktJVF9BUEkgdm9p ZAord2Via2l0X25ldHdvcmtfcmVzcG9uc2Vfc2V0X3VyaSAoV2ViS2l0TmV0d29ya1Jlc3BvbnNl KiByZXNwb25zZSwgY29uc3QgZ2NoYXIqIHVyaSk7CisKK1dFQktJVF9BUEkgY29uc3QgZ2NoYXIq Cit3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfdXJpIChXZWJLaXROZXR3b3JrUmVzcG9uc2Uq IHJlc3BvbnNlKTsKKworCitHX0VORF9ERUNMUworCisjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYktp dC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 cHJpdmF0ZS5jcHAKaW5kZXggYmVhMWFkNi4uNzg2OWY5NiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 cHJpdmF0ZS5jcHAKQEAgLTIzLDYgKzIzLDcgQEAKICNpbmNsdWRlICJDaHJvbWVDbGllbnRHdGsu aCIKICNpbmNsdWRlICJGcmFtZUxvYWRlci5oIgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyQ2xpZW50 R3RrLmgiCisjaW5jbHVkZSAiUmVzb3VyY2VSZXF1ZXN0LmgiCiAjaW5jbHVkZSAiTG9nZ2luZy5o IgogI2luY2x1ZGUgIk5vdEltcGxlbWVudGVkLmgiCiAjaW5jbHVkZSAiUGFnZUNhY2hlLmgiCkBA IC04Myw2ICs4NCwxNiBAQCBXZWJLaXRXZWJWaWV3KiBraXQoV2ViQ29yZTo6UGFnZSogY29yZVBh Z2UpCiAgICAgcmV0dXJuIGNsaWVudCA/IGNsaWVudC0+d2ViVmlldygpIDogMDsKIH0KIAorUmVz b3VyY2VSZXF1ZXN0Q2FjaGVQb2xpY3kgY29yZShXZWJLaXRSZXFDYWNoZVBvbGljeSBjYWNoZVBv bGljeSkKK3sKKyAgICByZXR1cm4gKFJlc291cmNlUmVxdWVzdENhY2hlUG9saWN5KWNhY2hlUG9s aWN5OworfQorCitXZWJLaXRSZXFDYWNoZVBvbGljeSBraXQoUmVzb3VyY2VSZXF1ZXN0Q2FjaGVQ b2xpY3kgY2FjaGVQb2xpY3kpCit7CisgICAgcmV0dXJuIChXZWJLaXRSZXFDYWNoZVBvbGljeSlj YWNoZVBvbGljeTsKK30KKwogfSAvKiogZW5kIG5hbWVzcGFjZSBXZWJDb3JlICovCiAKIHZvaWQg d2Via2l0X2luaXQoKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0 ZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCmluZGV4IGVkODFhMWMuLjEw ZTE4MWEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAorKysg Yi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKQEAgLTIyLDcgKzIyLDggQEAKICNk ZWZpbmUgV0VCS0lUX1BSSVZBVEVfSAogCiAvKgotICogVGhpcyBmaWxlIGtub3dzIHRoZSBzaGFy ZWQgc2VjcmV0IG9mIFdlYktpdFdlYlZpZXcgYW5kIFdlYktpdFdlYkZyYW1lLgorICogVGhpcyBm aWxlIGtub3dzIHRoZSBzaGFyZWQgc2VjcmV0IG9mIFdlYktpdFdlYlZpZXcgYW5kIFdlYktpdFdl YkZyYW1lCisgKiBhbmQgV2ViS2l0TmV0d29ya1JlcXVlc3QuCiAgKiBUaGV5IGFyZSB1c2luZyBX ZWJDb3JlIHdoaWNoIG11c24ndCBiZSBleHBvc2VkIHRvIHRoZSBvdXRlciB3b3JsZC4KICAqLwog CkBAIC0zMSw2ICszMiw3IEBACiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYmZyYW1lLmg+CiAj aW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYnNldHRpbmdzLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dl YmtpdHdlYmJhY2tmb3J3YXJkbGlzdC5oPgorI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRuZXR3b3Jr cmVxdWVzdC5oPgogCiAjaW5jbHVkZSAiQmFja0ZvcndhcmRMaXN0LmgiCiAjaW5jbHVkZSAiSGlz dG9yeUl0ZW0uaCIKQEAgLTM4LDYgKzQwLDcgQEAKICNpbmNsdWRlICJQYWdlLmgiCiAjaW5jbHVk ZSAiRnJhbWUuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRlckNsaWVudC5oIgorI2luY2x1ZGUgIlJl c291cmNlUmVxdWVzdC5oIgogCiAjaW5jbHVkZSA8Z2xpYi5oPgogCkBAIC01NCw2ICs1Nyw5IEBA IG5hbWVzcGFjZSBXZWJLaXQgewogICAgIFdlYktpdFdlYkhpc3RvcnlJdGVtKiBraXQoV2ViQ29y ZTo6SGlzdG9yeUl0ZW0qKTsKIAogICAgIFdlYkNvcmU6OkJhY2tGb3J3YXJkTGlzdCogY29yZShX ZWJLaXRXZWJCYWNrRm9yd2FyZExpc3QqKTsKKworICAgIFdlYkNvcmU6OlJlc291cmNlUmVxdWVz dENhY2hlUG9saWN5IGNvcmUoV2ViS2l0UmVxQ2FjaGVQb2xpY3kgY2FjaGVQb2xpY3kpOworICAg IFdlYktpdFJlcUNhY2hlUG9saWN5IGtpdChXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3RDYWNoZVBv bGljeSBjYWNoZVBvbGljeSk7CiB9CiAKIGV4dGVybiAiQyIgewpAQCAtMTIzLDYgKzEyOSwxOCBA QCBleHRlcm4gIkMiIHsKIAogICAgIFdFQktJVF9BUEkgZ2NoYXIqCiAgICAgd2Via2l0X3dlYl92 aWV3X2dldF9zZWxlY3RlZF90ZXh0IChXZWJLaXRXZWJWaWV3KiB3ZWJfdmlldyk7CisKKyAgICBX ZWJLaXROZXR3b3JrUmVxdWVzdCoKKyAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld19mcm9t X3Jlc291cmNlX3JlcXVlc3QoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJj ZVJlcXVlc3QpOworCisgICAgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0CisgICAgd2Via2l0X25l dHdvcmtfcmVxdWVzdF9nZXRfcmVzb3VyY2VfcmVxdWVzdChjb25zdCBXZWJLaXROZXR3b3JrUmVx dWVzdCogcmVxdWVzdCk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2UqCisgICAgd2Via2l0 X25ldHdvcmtfcmVzcG9uc2VfbmV3X2Zyb21fcmVzb3VyY2VfcmVzcG9uc2UoV2ViQ29yZTo6UmVz b3VyY2VSZXNwb25zZSYgcmVzb3VyY2VSZXNwb25zZSk7CisKKyAgICBXZWJDb3JlOjpSZXNvdXJj ZVJlc3BvbnNlCisgICAgd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3Jlc291cmNlX3Jlc3Bv bnNlKGNvbnN0IFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UpOwogfQogCiAjZW5kaWYK ZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcCBiL1dlYktp dC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcAppbmRleCBhN2YyN2VmLi5iOTFhMDBkIDEw MDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKKysrIGIvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCkBAIC0zNTMsOSArMzUzLDcgQEAgdm9p ZCB3ZWJraXRfd2ViX2ZyYW1lX2xvYWRfcmVxdWVzdChXZWJLaXRXZWJGcmFtZSogZnJhbWUsIFdl YktpdE5ldHdvcmtSZXF1ZXN0KgogICAgIEZyYW1lKiBjb3JlRnJhbWUgPSBjb3JlKGZyYW1lKTsK ICAgICBBU1NFUlQoY29yZUZyYW1lKTsKIAotICAgIC8vIFRPRE86IFVzZSB0aGUgUmVzb3VyY2VS ZXF1ZXN0IGNhcnJpZWQgYnkgV2ViS2l0TmV0d29ya1JlcXVlc3Qgd2hlbiBpdCBpcyBpbXBsZW1l bnRlZC4KLSAgICBTdHJpbmcgc3RyaW5nID0gU3RyaW5nOjpmcm9tVVRGOCh3ZWJraXRfbmV0d29y a19yZXF1ZXN0X2dldF91cmkocmVxdWVzdCkpOwotICAgIGNvcmVGcmFtZS0+bG9hZGVyKCktPmxv YWQoUmVzb3VyY2VSZXF1ZXN0KEtVUkwoc3RyaW5nKSkpOworICAgIGNvcmVGcmFtZS0+bG9hZGVy KCktPmxvYWQod2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfcmVzb3VyY2VfcmVxdWVzdChyZXF1 ZXN0KSk7CiB9CiAKIC8qKgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vi dmlldy5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcAppbmRleCBiOWVj NjE3Li4xOGRhM2Q1IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3 LmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcApAQCAtMjksNiAr MjksOCBAQAogI2luY2x1ZGUgIndlYmtpdHByaXZhdGUuaCIKICNpbmNsdWRlICJ3ZWJraXR3ZWJi YWNrZm9yd2FyZGxpc3QuaCIKICNpbmNsdWRlICJ3ZWJraXR3ZWJoaXN0b3J5aXRlbS5oIgorI2lu Y2x1ZGUgIndlYmtpdG5ldHdvcmtyZXF1ZXN0LmgiCisjaW5jbHVkZSAid2Via2l0bmV0d29ya3Jl c3BvbnNlLmgiCiAKICNpbmNsdWRlICJBWE9iamVjdENhY2hlLmgiCiAjaW5jbHVkZSAiTm90SW1w bGVtZW50ZWQuaCIK 22557 2008-07-30 11:30:47 -0700 2009-01-15 07:06:14 -0800 proposed patch network-request.diff text/plain 46720 gustavo ZGlmZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0NoYW5nZUxvZwppbmRleCBkZTM2NjYzLi41N2Y2ZWE2 IDEwMDY0NAotLS0gYS9DaGFuZ2VMb2cKKysrIGIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTEgQEAK KzIwMDgtMDctMjkgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGduc0Bnbm9tZS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkZWQgbmV3IGZp bGUgdG8gdGhlIEdUSysgYnVpbGQ6IHdlYmtpdG5ldHdvcmtyZXNwb25zZS5jcHAuCisgICAgICAg IAorICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOgorCiAyMDA4LTA3LTI1ICBKYW4gTWljaGFlbCBB bG9uem8gIDxqbWFsb256b0B3ZWJraXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IE1hcmsg Um93ZS4KZGlmZiAtLWdpdCBhL0dOVW1ha2VmaWxlLmFtIGIvR05VbWFrZWZpbGUuYW0KaW5kZXgg YzVlZGNjMC4uMTkxNzU4NiAxMDA2NDQKLS0tIGEvR05VbWFrZWZpbGUuYW0KKysrIGIvR05VbWFr ZWZpbGUuYW0KQEAgLTMzNyw2ICszMzcsNyBAQCB3ZWJraXRndGtfaGVhZGVycyArPSBcCiAKIHdl YmtpdGd0a19zb3VyY2VzICs9IFwKIAlXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVx dWVzdC5jcHAgXAorCVdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5jcHAg XAogCVdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuY3BwIFwKIAlXZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXR2ZXJzaW9uLmNwcCBcCiAJV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViYmFj a2ZvcndhcmRsaXN0LmNwcCBcCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZyBiL1dl YktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4IDQ2Njg1YTguLmE0N2I1OGIgMTAwNjQ0Ci0tLSBhL1dl YktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs NjAgQEAKKzIwMDgtMDUtMTEgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGduc0Bnbm9tZS5vcmc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE4NjA4CisgICAgICAgIFdlYktpdE5l dHdvcmtSZXF1ZXN0IG5lZWRzIHRvIGJlIGZpbmlzaGVkCisKKyAgICAgICAgR09iamVjdCBpbXBs ZW1lbnRhdGlvbiBleHBvc2luZyBSZXNvdXJjZVJlcXVlc3QsIGFuZCBpbml0aWFsCisgICAgICAg IGltcGxlbWVudGF0aW9uIGV4cG9zaW5nIFJlc291cmNlUmVzcG9uc2UuIEZyYW1lTG9hZGVyQ2xp ZW50R3RrIGlzCisgICAgICAgIG5vdyB1c2luZyBXZWJLaXROZXR3b3JrUmVxdWVzdCB3aGVuIGl0 IG5lZWRzIHRvIGRlYWwgd2l0aCByZXF1ZXN0CisgICAgICAgIGluZm9ybWF0aW9uLiAKKworICAg ICAgICAqIENoYW5nZUxvZzoKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNs aWVudEd0ay5jcHA6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRj aERlY2lkZVBvbGljeUZvck5hdmlnYXRpb25BY3Rpb24pOgorICAgICAgICAqIHdlYmtpdC93ZWJr aXQuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0ZGVmaW5lcy5oOgorICAgICAgICAqIHdlYmtp dC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHA6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVl c3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2ZpbmFsaXplKToKKyAgICAgICAgKF9X ZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OmNhY2hlX3BvbGljeV9mcm9tX3Jlc291cmNlX3Jl cXVlc3QpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25l dHdvcmtfcmVxdWVzdF9uZXdfZnJvbV9yZXNvdXJjZV9yZXF1ZXN0KToKKyAgICAgICAgKF9XZWJL aXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3Jlc291 cmNlX3JlcXVlc3QpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVx dWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaSk6CisgICAgICAgIChf V2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9j YWNoZV9wb2xpY3kpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfY2FjaGVfcG9saWN5KToKKyAgICAgICAgKF9XZWJLaXRO ZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3RpbWVvdXRf aW50ZXJ2YWwpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0 X25ldHdvcmtfcmVxdWVzdF9nZXRfdGltZW91dF9pbnRlcnZhbCk6CisgICAgICAgIChfV2ViS2l0 TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9tYWluX2Rv Y3VtZW50X3VyaSk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X2dldF9tYWluX2RvY3VtZW50X3VyaSk6CisgICAgICAgIChfV2Vi S2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRw X21ldGhvZCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRf bmV0d29ya19yZXF1ZXN0X2dldF9odHRwX21ldGhvZCk6CisgICAgICAgIChfV2ViS2l0TmV0d29y a1JlcXVlc3RQcml2YXRlOjpjb3B5X2hlYWRlcik6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1Jl cXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2FkZF9odHRwX2hlYWRlcnMpOgor ICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVx dWVzdF9nZXRfaHR0cF9oZWFkZXJzKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFBy aXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfYWRkX2h0dHBfaGVhZGVyKToKKyAgICAgICAg KF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0 X2h0dHBfaGVhZGVyKToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6Ondl YmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfaGVhZGVyKToKKyAgICAgICAgKF9XZWJLaXRO ZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2JvZHkpOgor ICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVx dWVzdF9nZXRfYm9keSk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9hbGxvd19odHRwX2Nvb2tpZXMpOgorICAgICAgICAo X1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRf YWxsb3dfaHR0cF9jb29raWVzKToKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0bmV0d29ya3JlcXVl c3QuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmNwcDogQWRkZWQu CisgICAgICAgIChfV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZTo6d2Via2l0X25ldHdvcmtf cmVzcG9uc2VfZmluYWxpemUpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXNwb25zZVByaXZh dGU6OndlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2NsYXNzX2luaXQpOgorICAgICAgICAoX1dlYktp dE5ldHdvcmtSZXNwb25zZVByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2luaXQpOgor ICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3Jl c3BvbnNlX25ld19mcm9tX3Jlc291cmNlX3Jlc3BvbnNlKToKKyAgICAgICAgKF9XZWJLaXROZXR3 b3JrUmVzcG9uc2VQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfcmVzb3VyY2Vf cmVzcG9uc2UpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGU6OndlYmtp dF9uZXR3b3JrX3Jlc3BvbnNlX25ldyk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1Jlc3BvbnNl UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVzcG9uc2Vfc2V0X3VyaSk6CisgICAgICAgIChfV2Vi S2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3Vy aSk6CisgICAgICAgICogd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5oOiBBZGRlZC4KKyAg ICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5oOgorICAgICAgICAqIHdlYmtpdC93ZWJraXR3 ZWJmcmFtZS5jcHA6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwOgorCiAyMDA4 LTA3LTMwICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxnbnNAZ25vbWUub3JnPgogCiAgICAgICAg IFJldmlld2VkIGJ5IFNhbS4KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwIGIvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudEd0ay5jcHAKaW5kZXggOGNmMDg4Ni4uMmY2NDc0NSAxMDA2NDQKLS0tIGEv V2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAKKysrIGIv V2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAKQEAgLTQ0 LDYgKzQ0LDggQEAKICNpbmNsdWRlICJTY3JpcHRDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAid2Vi a2l0d2Vidmlldy5oIgogI2luY2x1ZGUgIndlYmtpdHdlYmZyYW1lLmgiCisjaW5jbHVkZSAid2Vi a2l0bmV0d29ya3JlcXVlc3QuaCIKKyNpbmNsdWRlICJ3ZWJraXRuZXR3b3JrcmVzcG9uc2UuaCIK ICNpbmNsdWRlICJ3ZWJraXRwcml2YXRlLmgiCiAKICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9B UElDYXN0Lmg+CkBAIC0yNjgsNyArMjcwLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlz cGF0Y2hEZWNpZGVQb2xpY3lGb3JOYXZpZ2F0aW9uQWN0aW9uKEZyYW1lUG9saWN5RnVuY3QKICAg ICAgICAgcmV0dXJuOwogCiAgICAgV2ViS2l0V2ViVmlldyogd2ViVmlldyA9IGdldFZpZXdGcm9t RnJhbWUobV9mcmFtZSk7Ci0gICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X25ldyhyZXNvdXJjZVJlcXVlc3QudXJsKCkuc3RyaW5nKCkudXRm OCgpLmRhdGEoKSk7CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRf bmV0d29ya19yZXF1ZXN0X25ld19mcm9tX3Jlc291cmNlX3JlcXVlc3QocmVzb3VyY2VSZXF1ZXN0 KTsKICAgICBXZWJLaXROYXZpZ2F0aW9uUmVzcG9uc2UgcmVzcG9uc2U7CiAKICAgICBnX3NpZ25h bF9lbWl0X2J5X25hbWUod2ViVmlldywgIm5hdmlnYXRpb24tcmVxdWVzdGVkIiwgbV9mcmFtZSwg cmVxdWVzdCwgJnJlc3BvbnNlKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dC5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0LmgKaW5kZXggMTBjMjE0Zi4uOTBhY2Y4ZiAx MDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0LmgKKysrIGIvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0LmgKQEAgLTIzLDYgKzIzLDcgQEAKICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0 dmVyc2lvbi5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRkZWZpbmVzLmg+CiAjaW5jbHVkZSA8 d2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0Lmg+CisjaW5jbHVkZSA8d2Via2l0L3dlYmtpdG5l dHdvcmtyZXNwb25zZS5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJmcmFtZS5oPgogI2lu Y2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJzZXR0aW5ncy5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJr aXR3ZWJ2aWV3Lmg+CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRkZWZpbmVz LmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRkZWZpbmVzLmgKaW5kZXggMzg2YzNlMS4uMzM5 ODFlMCAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZGVmaW5lcy5oCisrKyBi L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRlZmluZXMuaApAQCAtNDMsNiArNDMsOSBAQCBHX0JF R0lOX0RFQ0xTCiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0TmV0d29ya1JlcXVlc3QgV2ViS2l0TmV0 d29ya1JlcXVlc3Q7CiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0TmV0d29ya1JlcXVlc3RDbGFzcyBX ZWJLaXROZXR3b3JrUmVxdWVzdENsYXNzOwogCit0eXBlZGVmIHN0cnVjdCBfV2ViS2l0TmV0d29y a1Jlc3BvbnNlIFdlYktpdE5ldHdvcmtSZXNwb25zZTsKK3R5cGVkZWYgc3RydWN0IF9XZWJLaXRO ZXR3b3JrUmVzcG9uc2VDbGFzcyBXZWJLaXROZXR3b3JrUmVzcG9uc2VDbGFzczsKKwogdHlwZWRl ZiBzdHJ1Y3QgX1dlYktpdFdlYkJhY2tGb3J3YXJkTGlzdCBXZWJLaXRXZWJCYWNrRm9yd2FyZExp c3Q7CiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0V2ViQmFja0ZvcndhcmRMaXN0Q2xhc3MgV2ViS2l0 V2ViQmFja0ZvcndhcmRMaXN0Q2xhc3M7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0 L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdv cmtyZXF1ZXN0LmNwcAppbmRleCBmYWIwZjg4Li42YzhkNzA1IDEwMDY0NAotLS0gYS9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwCkBAIC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHly aWdodCAoQykgMjAwNyBIb2xnZXIgSGFucyBQZXRlciBGcmV5dGhlcgorICogQ29weXJpZ2h0IChD KSAyMDA4IEd1c3Rhdm8gTm9yb25oYSBTaWx2YQogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVl IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlmeSBpdCB1 bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCkBAIC0yMCwz MCArMjEsMjE0IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAKICNpbmNsdWRlICJ3ZWJraXRuZXR3 b3JrcmVxdWVzdC5oIgorI2luY2x1ZGUgIndlYmtpdGVudW10eXBlcy5oIgorI2luY2x1ZGUgIndl YmtpdHByaXZhdGUuaCIKKworI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjaW5jbHVkZSAi UmVzb3VyY2VSZXF1ZXN0LmgiCisjaW5jbHVkZSAiQ1N0cmluZy5oIgorCit1c2luZyBuYW1lc3Bh Y2UgV2ViQ29yZTsKK3VzaW5nIG5hbWVzcGFjZSBXZWJLaXQ7CiAKIGV4dGVybiAiQyIgewogCitl bnVtIHsKKyAgICBQUk9QXzAsCisKKyAgICBQUk9QX1VSSSwKKyAgICBQUk9QX0NBQ0hFX1BPTElD WSwKKyAgICBQUk9QX1RJTUVPVVRfSU5URVJWQUwsCisgICAgUFJPUF9NQUlOX0RPQ1VNRU5UX1VS SSwKKyAgICBQUk9QX0hUVFBfTUVUSE9ELAorICAgIFBST1BfQUxMT1dfSFRUUF9DT09LSUVTLAor fTsKKwogR19ERUZJTkVfVFlQRShXZWJLaXROZXR3b3JrUmVxdWVzdCwgd2Via2l0X25ldHdvcmtf cmVxdWVzdCwgR19UWVBFX09CSkVDVCk7CiAKIHN0cnVjdCBfV2ViS2l0TmV0d29ya1JlcXVlc3RQ cml2YXRlIHsKKyAgICBSZXNvdXJjZVJlcXVlc3QgcmVxdWVzdDsKKwogICAgIGdjaGFyKiB1cmk7 CisgICAgZ2NoYXIqIG1haW5Eb2N1bWVudFVSSTsKKyAgICBnY2hhciogaHR0cE1ldGhvZDsKKyAg ICBnY2hhciAqYm9keTsKKyAgICBnc3NpemUgYm9keVNpemU7CisKKyAgICBHSGFzaFRhYmxlICpo dHRwSGVhZGVyczsKIH07CiAKICNkZWZpbmUgV0VCS0lUX05FVFdPUktfUkVRVUVTVF9HRVRfUFJJ VkFURShvYmopIChHX1RZUEVfSU5TVEFOQ0VfR0VUX1BSSVZBVEUoKG9iaiksIFdFQktJVF9UWVBF X05FVFdPUktfUkVRVUVTVCwgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKSkKIAorc3RhdGlj IHZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfcHJvcGVydHkoR09iamVjdCogb2JqZWN0 LCBndWludCBwcm9wX2lkLCBHVmFsdWUqIHZhbHVlLCBHUGFyYW1TcGVjKiBwc3BlYykKK3sKKyAg ICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IFdFQktJVF9ORVRXT1JLX1JFUVVFU1Qo b2JqZWN0KTsKKworICAgIHN3aXRjaChwcm9wX2lkKSB7CisgICAgY2FzZSBQUk9QX1VSSToKKyAg ICAgICAgZ192YWx1ZV9zZXRfc3RyaW5nKHZhbHVlLCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dl dF91cmkocmVxdWVzdCkpOworICAgICAgICBicmVhazsKKyAgICBjYXNlIFBST1BfQ0FDSEVfUE9M SUNZOgorICAgICAgICBnX3ZhbHVlX3NldF9lbnVtKHZhbHVlLCB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X2dldF9jYWNoZV9wb2xpY3kocmVxdWVzdCkpOworICAgICAgICBicmVhazsKKyAgICBjYXNl IFBST1BfVElNRU9VVF9JTlRFUlZBTDoKKyAgICAgICAgZ192YWx1ZV9zZXRfZG91YmxlKHZhbHVl LCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF90aW1lb3V0X2ludGVydmFsKHJlcXVlc3QpKTsK KyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBQUk9QX01BSU5fRE9DVU1FTlRfVVJJOgorICAgICAg ICBnX3ZhbHVlX3NldF9zdHJpbmcodmFsdWUsIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X21h aW5fZG9jdW1lbnRfdXJpKHJlcXVlc3QpKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBQUk9Q X0hUVFBfTUVUSE9EOgorICAgICAgICBnX3ZhbHVlX3NldF9zdHJpbmcodmFsdWUsIHdlYmtpdF9u ZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfbWV0aG9kKHJlcXVlc3QpKTsKKyAgICAgICAgYnJlYWs7 CisgICAgY2FzZSBQUk9QX0FMTE9XX0hUVFBfQ09PS0lFUzoKKyAgICAgICAgZ192YWx1ZV9zZXRf Ym9vbGVhbih2YWx1ZSwgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfYWxsb3dfaHR0cF9jb29r aWVzKHJlcXVlc3QpKTsKKyAgICBkZWZhdWx0OgorICAgICAgICBHX09CSkVDVF9XQVJOX0lOVkFM SURfUFJPUEVSVFlfSUQob2JqZWN0LCBwcm9wX2lkLCBwc3BlYyk7CisgICAgfQorfQorCitzdGF0 aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9wcm9wZXJ0eShHT2JqZWN0KiBvYmpl Y3QsIGd1aW50IHByb3BfaWQsIGNvbnN0IEdWYWx1ZSogdmFsdWUsIEdQYXJhbVNwZWMgKnBzcGVj KQoreworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gV0VCS0lUX05FVFdPUktf UkVRVUVTVChvYmplY3QpOworCisgICAgc3dpdGNoKHByb3BfaWQpIHsKKyAgICBjYXNlIFBST1Bf VVJJOgorICAgICAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF91cmkocmVxdWVzdCwgZ192 YWx1ZV9nZXRfc3RyaW5nKHZhbHVlKSk7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgUFJPUF9D QUNIRV9QT0xJQ1k6CisgICAgICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2NhY2hlX3Bv bGljeShyZXF1ZXN0LCAoV2ViS2l0UmVxQ2FjaGVQb2xpY3kpZ192YWx1ZV9nZXRfZW51bSh2YWx1 ZSkpOworICAgICAgICBicmVhazsKKyAgICBjYXNlIFBST1BfVElNRU9VVF9JTlRFUlZBTDoKKyAg ICAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdGltZW91dF9pbnRlcnZhbChyZXF1ZXN0 LCBnX3ZhbHVlX2dldF9kb3VibGUodmFsdWUpKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBQ Uk9QX01BSU5fRE9DVU1FTlRfVVJJOgorICAgICAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3Nl dF9tYWluX2RvY3VtZW50X3VyaShyZXF1ZXN0LCBnX3ZhbHVlX2dldF9zdHJpbmcodmFsdWUpKTsK KyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBQUk9QX0hUVFBfTUVUSE9EOgorICAgICAgICB3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X3NldF9odHRwX21ldGhvZChyZXF1ZXN0LCBnX3ZhbHVlX2dldF9z dHJpbmcodmFsdWUpKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBQUk9QX0FMTE9XX0hUVFBf Q09PS0lFUzoKKyAgICAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfYWxsb3dfaHR0cF9j b29raWVzKHJlcXVlc3QsIGdfdmFsdWVfZ2V0X2Jvb2xlYW4odmFsdWUpKTsKKyAgICAgICAgYnJl YWs7CisgICAgZGVmYXVsdDoKKyAgICAgICAgR19PQkpFQ1RfV0FSTl9JTlZBTElEX1BST1BFUlRZ X0lEKG9iamVjdCwgcHJvcF9pZCwgcHNwZWMpOworICAgIH0KK30KKwogc3RhdGljIHZvaWQgd2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9maW5hbGl6ZShHT2JqZWN0KiBvYmplY3QpCiB7CiAgICAgV2Vi S2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSBXRUJLSVRfTkVUV09SS19SRVFVRVNUKG9iamVj dCk7CiAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJp djsKIAogICAgIGdfZnJlZShwcml2LT51cmkpOworICAgIGdfZnJlZShwcml2LT5tYWluRG9jdW1l bnRVUkkpOworICAgIGdfZnJlZShwcml2LT5odHRwTWV0aG9kKTsKKyAgICBnX2ZyZWUocHJpdi0+ Ym9keSk7CisKKyAgICBpZihwcml2LT5odHRwSGVhZGVycykKKyAgICAgICAgZ19oYXNoX3RhYmxl X2Rlc3Ryb3kocHJpdi0+aHR0cEhlYWRlcnMpOwogCiAgICAgR19PQkpFQ1RfQ0xBU1Mod2Via2l0 X25ldHdvcmtfcmVxdWVzdF9wYXJlbnRfY2xhc3MpLT5maW5hbGl6ZShvYmplY3QpOwogfQogCiBz dGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2NsYXNzX2luaXQoV2ViS2l0TmV0d29y a1JlcXVlc3RDbGFzcyogcmVxdWVzdENsYXNzKQogewotICAgIEdfT0JKRUNUX0NMQVNTKHJlcXVl c3RDbGFzcyktPmZpbmFsaXplID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9maW5hbGl6ZTsKKyAg ICBHT2JqZWN0Q2xhc3MqIG9iamVjdENsYXNzID0gR19PQkpFQ1RfQ0xBU1MocmVxdWVzdENsYXNz KTsKKworICAgIG9iamVjdENsYXNzLT5maW5hbGl6ZSA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf ZmluYWxpemU7CisgICAgb2JqZWN0Q2xhc3MtPmdldF9wcm9wZXJ0eSA9IHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfZ2V0X3Byb3BlcnR5OworICAgIG9iamVjdENsYXNzLT5zZXRfcHJvcGVydHkgPSB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9wcm9wZXJ0eTsKKworICAgIC8qCisgICAgICogcHJv cGVydGllcworICAgICAqLworCisgICAgLyoqCisgICAgKiBXZWJLaXROZXR3b3JrUmVxdWVzdDp1 cmk6CisgICAgKgorICAgICogVGhlIFVSSSBmb3IgdGhpcyByZXF1ZXN0LgorICAgICoKKyAgICAq IFNpbmNlOiAxLjAuMgorICAgICovCisgICAgZ19vYmplY3RfY2xhc3NfaW5zdGFsbF9wcm9wZXJ0 eShvYmplY3RDbGFzcywgUFJPUF9VUkksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBnX3BhcmFtX3NwZWNfc3RyaW5nKCJ1cmkiLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiVVJJIiwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIlRoZSBVUkkgZm9yIHRoaXMg cmVxdWVzdCIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIE5VTEwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFdFQktJVF9QQVJBTV9SRUFEV1JJVEUpKTsKKworICAgIC8qKgorICAg ICogV2ViS2l0TmV0d29ya1JlcXVlc3Q6Y2FjaGUtcG9saWN5OgorICAgICoKKyAgICAqIFdoZXRo ZXIgYW5kIGhvdyB0aGlzIHJlcXVlc3Qgc2hvdWxkIHVzZSBkYXRhIGZyb20gdGhlIGNhY2hlLgor ICAgICoKKyAgICAqIFNpbmNlOiAxLjAuMgorICAgICovCisgICAgZ19vYmplY3RfY2xhc3NfaW5z dGFsbF9wcm9wZXJ0eShvYmplY3RDbGFzcywgUFJPUF9DQUNIRV9QT0xJQ1ksCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBnX3BhcmFtX3NwZWNfZW51bSgiY2FjaGUtcG9saWN5 IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICJDYWNoZSBQb2xpY3kiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIldoZXRoZXIgYW5kIGhvdyB0aGlzIHJlcXVlc3Qgc2hvdWxkIHVzZSBk YXRhIGZyb20gdGhlIGNhY2hlIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIFdFQktJVF9UWVBFX1JFUV9DQUNIRV9QT0xJQ1ksCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRfUkVR X0NBQ0hFX1BPTElDWV9QUk9UT0NPTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIFdFQktJVF9QQVJBTV9SRUFEV1JJVEUpKTsKKworICAgIC8q KgorICAgICogV2ViS2l0TmV0d29ya1JlcXVlc3Q6dGltZW91dC1pbnRlcnZhbDoKKyAgICAqCisg ICAgKiBIb3cgbG9uZyB0byB3YWl0IGJlZm9yZSB0aGUgcmVxdWVzdCB0aW1lcyBvdXQuCisgICAg KgorICAgICogU2luY2U6IDEuMC4yCisgICAgKi8KKyAgICBnX29iamVjdF9jbGFzc19pbnN0YWxs X3Byb3BlcnR5KG9iamVjdENsYXNzLCBQUk9QX1RJTUVPVVRfSU5URVJWQUwsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBnX3BhcmFtX3NwZWNfZG91YmxlKCJ0aW1lb3V0LWlu dGVydmFsIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIlRpbWVvdXQgSW50ZXJ2YWwiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiSG93IGxvbmcgdG8gd2FpdCBiZWZvcmUgdGhl IHJlcXVlc3QgdGltZXMgb3V0IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgMC4wLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBHX01BWERPVUJMRSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgNjAuMCwgLy8gdGFrZW4gZnJv bSBSZXNvdXJjZVJlcXVlc3RCYXNlLmgKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgV0VCS0lUX1BBUkFNX1JFQURXUklURSkpOworCisgICAg LyoqCisgICAgKiBXZWJLaXROZXR3b3JrUmVxdWVzdDptYWluLWRvY3VtZW50LXVyaToKKyAgICAq CisgICAgKiBUaGUgVVJJIG9mIHRoZSBtYWluIGRvY3VtZW50IHRoYXQgaXMgYmVpbmcgcmVuZGVy ZWQuCisgICAgKgorICAgICogU2luY2U6IDEuMC4yCisgICAgKi8KKyAgICBnX29iamVjdF9jbGFz c19pbnN0YWxsX3Byb3BlcnR5KG9iamVjdENsYXNzLCBQUk9QX01BSU5fRE9DVU1FTlRfVVJJLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ19wYXJhbV9zcGVjX3N0cmluZygi bWFpbi1kb2N1bWVudC11cmkiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAiTWFpbiBEb2N1bWVudCBVUkkiLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiVGhlIFVSSSBvZiB0aGUg bWFpbiBkb2N1bWVudCB0aGF0IGlzIGJlaW5nIHJlbmRlcmVkIiwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0VCS0lUX1BBUkFN X1JFQURXUklURSkpOworCisgICAgLyoqCisgICAgKiBXZWJLaXROZXR3b3JrUmVxdWVzdDpodHRw LW1ldGhvZDoKKyAgICAqCisgICAgKiBUaGUgSFRUUCBtZXRob2QgdGhpcyByZXF1ZXN0IHVzZXMu CisgICAgKgorICAgICogU2luY2U6IDEuMC4yCisgICAgKi8KKyAgICBnX29iamVjdF9jbGFzc19p bnN0YWxsX3Byb3BlcnR5KG9iamVjdENsYXNzLCBQUk9QX0hUVFBfTUVUSE9ELAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgZ19wYXJhbV9zcGVjX3N0cmluZygiaHR0cC1tZXRo b2QiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAiSFRUUCBNZXRob2QiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAiVGhlIEhUVFAgbWV0aG9kIHRoaXMgcmVxdWVzdCB1c2VzIiwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg TlVMTCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgV0VCS0lUX1BBUkFNX1JFQURXUklURSkpOworCisgICAgLyoqCisgICAgKiBXZWJLaXRO ZXR3b3JrUmVxdWVzdDphbGxvdy1odHRwLWNvb2tpZXM6CisgICAgKgorICAgICogV2hldGhlciBj b29raWVzIGFyZSB0byBiZSBhbGxvd2VkIGZvciB0aGlzIHJlcXVlc3QuCisgICAgKgorICAgICog U2luY2U6IDEuMC4yCisgICAgKi8KKyAgICBnX29iamVjdF9jbGFzc19pbnN0YWxsX3Byb3BlcnR5 KG9iamVjdENsYXNzLCBQUk9QX0FMTE9XX0hUVFBfQ09PS0lFUywKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGdfcGFyYW1fc3BlY19ib29sZWFuKCJhbGxvdy1odHRwLWNvb2tp ZXMiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIkFsbG93IEhUVFAgQ29va2llcyIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiV2hldGhlciBjb29raWVzIGFyZSB0byBiZSBh bGxvd2VkIGZvciB0aGlzIHJlcXVlc3QiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgVFJVRSwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdFQktJVF9QQVJBTV9SRUFEV1JJVEUp KTsKIAogICAgIGdfdHlwZV9jbGFzc19hZGRfcHJpdmF0ZShyZXF1ZXN0Q2xhc3MsIHNpemVvZihX ZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUpKTsKIH0KQEAgLTU0LDE4ICsyMzksNTEgQEAgc3Rh dGljIHZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9pbml0KFdlYktpdE5ldHdvcmtSZXF1ZXN0 KiByZXF1ZXN0KQogICAgIHJlcXVlc3QtPnByaXYgPSBwcml2OwogfQogCi1XZWJLaXROZXR3b3Jr UmVxdWVzdCogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXcoY29uc3QgZ2NoYXIqIHVyaSkKKy8v IGZvciBpbnRlcm5hbCB1c2Ugb25seQorV2ViS2l0TmV0d29ya1JlcXVlc3QqIHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfbmV3X2Zyb21fcmVzb3VyY2VfcmVxdWVzdChjb25zdCBSZXNvdXJjZVJlcXVl c3QmIHJlc291cmNlUmVxdWVzdCkKIHsKLSAgICBnX3JldHVybl92YWxfaWZfZmFpbCh1cmksIE5V TEwpOwotCiAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSBXRUJLSVRfTkVUV09S S19SRVFVRVNUKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIE5VTEwp KTsKICAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2 OwogCi0gICAgcHJpdi0+dXJpID0gZ19zdHJkdXAodXJpKTsKKyAgICBwcml2LT5yZXF1ZXN0ID0g cmVzb3VyY2VSZXF1ZXN0OwogCiAgICAgcmV0dXJuIHJlcXVlc3Q7CiB9CiAKKy8vIGZvciBpbnRl cm5hbCB1c2Ugb25seQorUmVzb3VyY2VSZXF1ZXN0IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0 X3Jlc291cmNlX3JlcXVlc3QoY29uc3QgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7 CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsK KworICAgIHJldHVybiBwcml2LT5yZXF1ZXN0OworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfbmV3OgorICogQHVyaTogYW4gVVJJCisgKgorICogQ3JlYXRlcyBhIG5ldyAjV2Vi S2l0TmV0d29ya1JlcXVlc3QgaW5pdGlhbGl6ZWQgd2l0aCBhbiBVUkkuCisgKgorICogUmV0dXJu czogYSBuZXcgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CisgKi8KK1dlYktpdE5ldHdvcmtSZXF1ZXN0 KiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ldyhjb25zdCBnY2hhciogdXJpKQoreworICAgIGdf cmV0dXJuX3ZhbF9pZl9mYWlsKHVyaSwgTlVMTCk7CisgICAgCisgICAgUmVzb3VyY2VSZXF1ZXN0 IHJlc291cmNlUmVxdWVzdCA9IFJlc291cmNlUmVxdWVzdChLVVJMKFN0cmluZzo6ZnJvbVVURjgo dXJpKSkpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X25ld19mcm9tX3Jlc291cmNlX3JlcXVlc3QocmVzb3VyY2VSZXF1ZXN0KTsK KworICAgIHJldHVybiByZXF1ZXN0OworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVl c3Rfc2V0X3VyaToKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICogQHVy aTogYW4gYWxyZWFkeSBlbmNvZGVkIFVSSQorICoKKyAqIFNldHMgdGhlIFVSSSBoZWxkIGFuZCB1 c2VkIGJ5IHRoZSBnaXZlbiByZXF1ZXN0LgorICovCiB2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVl c3Rfc2V0X3VyaShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIHVy aSkKIHsKICAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVx dWVzdCkpOwpAQCAtNzQsMTUgKzI5Miw0NjAgQEAgdm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X3NldF91cmkoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKgogICAg IFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CiAKICAg ICBnX2ZyZWUocHJpdi0+dXJpKTsKLSAgICBwcml2LT51cmkgPSBnX3N0cmR1cCh1cmkpOworICAg IHByaXYtPnJlcXVlc3Quc2V0VVJMKEtVUkwoU3RyaW5nOjpmcm9tVVRGOCh1cmkpKSk7CisgICAg Z19vYmplY3Rfbm90aWZ5KEdfT0JKRUNUKHJlcXVlc3QpLCAidXJpIik7CiB9CiAKKy8qKgorICog d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJpOgorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5l dHdvcmtSZXF1ZXN0CisgKgorICogR2V0cyB0aGUgVVJJIGhlbGQgYW5kIHVzZWQgYnkgdGhlIGdp dmVuIHJlcXVlc3QuCisgKgorICogUmV0dXJuczogdGhlIFVSSSBoZWxkIGFuZCB1c2VkIGJ5IHRo ZSBnaXZlbiByZXF1ZXN0CisgKi8KIEdfQ09OU1RfUkVUVVJOIGdjaGFyKiB3ZWJraXRfbmV0d29y a19yZXF1ZXN0X2dldF91cmkoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCiB7CiAgICAg Z19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwg TlVMTCk7CiAKICAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0 LT5wcml2OworCisgICAgaWYgKHByaXYtPnVyaSkKKyAgICAgICAgcmV0dXJuIHByaXYtPnVyaTsK KworICAgIHByaXYtPnVyaSA9IGdfc3RyZHVwKHByaXYtPnJlcXVlc3QudXJsKCkuc3RyaW5nKCku dXRmOCgpLmRhdGEoKSk7CiAgICAgcmV0dXJuIHByaXYtPnVyaTsKIH0KIAorLyoqCisgKiB3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X3NldF9jYWNoZV9wb2xpY3k6CisgKiBAcmVxdWVzdDogYSAjV2Vi S2l0TmV0d29ya1JlcXVlc3QKKyAqIEBjYWNoZV9wb2xpY3k6IGEgI1dlYktpdFJlcUNhY2hlUG9s aWN5CisgKgorICogRGVmaW5lcyB0aGUgcG9saWN5IFdlYktpdCBzaG91bGQgdXNlIHdoZW4gaGFu ZGxpbmcgdGhlIHJlcXVlc3QsCisgKiBzdWNoIGFzIGlmIGl0IGlzIGFsbG93ZWQgdG8gdXNlIHRo ZSBsb2NhbCBjYWNoZSwgaWYgdGhlIEhUVFAKKyAqIGNhY2hpbmcgcnVsZXMgc2hvdWxkIGJlIHVz ZWQsIG9yIGlmIHdlIGFyZSBmb3JjaW5nIGEgcmVsb2FkLgorICoKKyAqIFNpbmNlOiAxLjAuMgor ICovCit2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2NhY2hlX3BvbGljeShXZWJLaXRO ZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgV2ViS2l0UmVxQ2FjaGVQb2xpY3kgY2FjaGVf cG9saWN5KQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVT VChyZXF1ZXN0KSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSBy ZXF1ZXN0LT5wcml2OworCisgICAgcHJpdi0+cmVxdWVzdC5zZXRDYWNoZVBvbGljeShjb3JlKGNh Y2hlX3BvbGljeSkpOworICAgIGdfb2JqZWN0X25vdGlmeShHX09CSkVDVChyZXF1ZXN0KSwgImNh Y2hlLXBvbGljeSIpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2Nh Y2hlX3BvbGljeToKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICoKKyAq IE9idGFpbnMgdGhlIHBvbGljeSBXZWJLaXQgd291bGQgdXNlIHdoZW4gaGFuZGxpbmcgdGhlIHJl cXVlc3QsIHN1Y2gKKyAqIGFzIGlmIGl0IGlzIGFsbG93ZWQgdG8gdXNlIHRoZSBsb2NhbCBjYWNo ZSwgaWYgdGhlIEhUVFAgY2FjaGluZworICogcnVsZXMgc2hvdWxkIGJlIHVzZWQsIG9yIGlmIHdl IGFyZSBmb3JjaW5nIGEgcmVsb2FkLgorICoKKyAqIFJldHVybnM6IGEgI1dlYktpdFJlcUNhY2hl UG9saWN5CisgKgorICogU2luY2U6IDEuMC4yCisgKi8KK1dlYktpdFJlcUNhY2hlUG9saWN5IHdl YmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2NhY2hlX3BvbGljeShXZWJLaXROZXR3b3JrUmVxdWVz dCogcmVxdWVzdCkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09S S19SRVFVRVNUKHJlcXVlc3QpLCBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9QUk9UT0NPTCk7CisK KyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2Owor CisgICAgcmV0dXJuIGtpdChwcml2LT5yZXF1ZXN0LmNhY2hlUG9saWN5KCkpOworfQorCisvKioK KyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3RpbWVvdXRfaW50ZXJ2YWw6CisgKiBAcmVx dWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEB0aW1lb3V0X2ludGVydmFsOiBhICNn ZG91YmxlCisgKgorICogU2V0cyBob3cgbWFueSBzZWNvbmRzIFdlYktpdCB3b3VsZCB3YWl0IGZv ciB0aGUgc2VydmVyIHdoZW4KKyAqIGhhbmRsaW5nIHRoZSBnaXZlbiByZXF1ZXN0LgorICoKKyAq IFNpbmNlOiAxLjAuMgorICovCit2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3RpbWVv dXRfaW50ZXJ2YWwoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdkb3VibGUg dGltZW91dF9pbnRlcnZhbCkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRX T1JLX1JFUVVFU1QocmVxdWVzdCkpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRl KiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIHByaXYtPnJlcXVlc3Quc2V0VGltZW91dElu dGVydmFsKHRpbWVvdXRfaW50ZXJ2YWwpOworICAgIGdfb2JqZWN0X25vdGlmeShHX09CSkVDVChy ZXF1ZXN0KSwgImNhY2hlLXBvbGljeSIpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X3RpbWVvdXRfaW50ZXJ2YWw6CisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29y a1JlcXVlc3QKKyAqCisgKiBHZXRzIGhvdyBtYW55IHNlY29uZHMgV2ViS2l0IHdvdWxkIHdhaXQg Zm9yIHRoZSBzZXJ2ZXIgd2hlbgorICogaGFuZGxpbmcgdGhlIGdpdmVuIHJlcXVlc3QuCisgKgor ICogUmV0dXJuczogYSAjZ2RvdWJsZQorICoKKyAqIFNpbmNlOiAxLjAuMgorICovCitnZG91Ymxl IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3RpbWVvdXRfaW50ZXJ2YWwoV2ViS2l0TmV0d29y a1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lT X05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgMC4wKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1 ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICByZXR1cm4gcHJpdi0+cmVx dWVzdC50aW1lb3V0SW50ZXJ2YWwoKTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X3NldF9tYWluX2RvY3VtZW50X3VyaQorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtS ZXF1ZXN0CisgKiBAbWFpbl9kb2N1bWVudF91cmk6IHRoZSBVUkkgb2YgdGhlIG1haW4gZG9jdW1l bnQKKyAqCisgKiBTZXRzIHRoZSBtYWluIGRvY3VtZW50IFVSSS4KKyAqCisgKiBUaGUgbWFpbiBk b2N1bWVudCBpcyB0aGUgZG9jdW1lbnQgdGhhdCBpcyBiZWluZyByZW5kZXJlZDsgb3RoZXIKKyAq IGRvY3VtZW50cywgYmUgdGhlbSBIVE1MIHBhZ2VzLCBqYXZhc2NyaXB0IG9yIGNzcyBmaWxlcywg aW1hZ2VzLCBhbmQKKyAqIHNvIG9uIG1heSBiZSBuZWNlc3NhcnksIGFuZCB0aGUgcmVxdWVzdHMg dGhhdCBmZXRjaCB0aG9zZSBzaGFsbAorICogaGF2ZSB0aGlzIFVSSSBzZXQgdG8gdGhlIGRvY3Vt ZW50IHdoaWNoIHJlcXVpcmVzIHRoZW0uCisgKgorICogU2luY2U6IDEuMC4yCisgKi8KK3ZvaWQg d2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfbWFpbl9kb2N1bWVudF91cmkoV2ViS2l0TmV0d29y a1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBtYWluX2RvY3VtZW50X3VyaSkKK3sKKyAg ICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOwor ICAgIGdfcmV0dXJuX2lmX2ZhaWwobWFpbl9kb2N1bWVudF91cmkpOworCisgICAgV2ViS2l0TmV0 d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIGdfZnJlZShw cml2LT5tYWluRG9jdW1lbnRVUkkpOworICAgIHByaXYtPnJlcXVlc3Quc2V0TWFpbkRvY3VtZW50 VVJMKEtVUkwoU3RyaW5nOjpmcm9tVVRGOChtYWluX2RvY3VtZW50X3VyaSkpKTsKKyAgICBnX29i amVjdF9ub3RpZnkoR19PQkpFQ1QocmVxdWVzdCksICJtYWluLWRvY3VtZW50LXVyaSIpOworfQor CisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X21haW5fZG9jdW1lbnRfdXJpCisg KiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqCisgKiBPYnRhaW5zIHRoZSBt YWluIGRvY3VtZW50IFVSSS4KKyAqCisgKiBUaGUgbWFpbiBkb2N1bWVudCBpcyB0aGUgZG9jdW1l bnQgdGhhdCBpcyBiZWluZyByZW5kZXJlZDsgb3RoZXIKKyAqIGRvY3VtZW50cywgYmUgdGhlbSBI VE1MIHBhZ2VzLCBqYXZhc2NyaXB0IG9yIGNzcyBmaWxlcywgaW1hZ2VzLCBhbmQKKyAqIHNvIG9u IG1heSBiZSBuZWNlc3NhcnksIGFuZCB0aGUgcmVxdWVzdHMgdGhhdCBmZXRjaCB0aG9zZSBzaGFs bAorICogaGF2ZSB0aGlzIFVSSSBzZXQgdG8gdGhlIGRvY3VtZW50IHdoaWNoIHJlcXVpcmVzIHRo ZW0uCisgKgorICogUmV0dXJuczogYSBzdHJpbmcgd2l0aCB0aGUgbWFpbiBkb2N1bWVudCBVUkkK KyAqCisgKiBTaW5jZTogMS4wLjIKKyAqLworR19DT05TVF9SRVRVUk4gZ2NoYXIqIHdlYmtpdF9u ZXR3b3JrX3JlcXVlc3RfZ2V0X21haW5fZG9jdW1lbnRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0 KiByZXF1ZXN0KQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JL X1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2 YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIGlmIChwcml2LT51cmkpCisgICAgICAg IHJldHVybiBwcml2LT51cmk7CisKKyAgICBwcml2LT51cmkgPSBnX3N0cmR1cChwcml2LT5yZXF1 ZXN0Lm1haW5Eb2N1bWVudFVSTCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworICAgIHJldHVy biBwcml2LT51cmk7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0 cF9tZXRob2QKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICogQGh0dHBf bWV0aG9kOiB0aGUgSFRUUCBtZXRob2QKKyAqCisgKiBEZWZpbmVzIHdoYXQgbWV0aG9kLCBzdWNo IGFzIEdFVCwgUE9TVCwgSEVBRCwgYW5kIHNvIG9uLCB3b3VsZCBiZQorICogdXNlZCBieSBXZWJL aXQgd2hlbiB0YWxraW5nIHRvIHRoZSB3ZWJzZXJ2ZXIgZHVyaW5nIHRoaXMgcmVxdWVzdC4KKyAq CisgKiBTaW5jZTogMS4wLjIKKyAqLwordm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9o dHRwX21ldGhvZChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIGh0 dHBfbWV0aG9kKQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVR VUVTVChyZXF1ZXN0KSk7CisgICAgZ19yZXR1cm5faWZfZmFpbChodHRwX21ldGhvZCk7CisKKyAg ICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisg ICAgZ19mcmVlKHByaXYtPmh0dHBNZXRob2QpOworICAgIHByaXYtPnJlcXVlc3Quc2V0SFRUUE1l dGhvZChTdHJpbmc6OmZyb21VVEY4KGh0dHBfbWV0aG9kKSk7CisgICAgZ19vYmplY3Rfbm90aWZ5 KEdfT0JKRUNUKHJlcXVlc3QpLCAiaHR0cC1tZXRob2QiKTsKK30KKworLyoqCisgKiB3ZWJraXRf bmV0d29ya19yZXF1ZXN0X2dldF9odHRwX21ldGhvZAorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5l dHdvcmtSZXF1ZXN0CisgKgorICogT2J0YWlucyB3aGF0IG1ldGhvZCwgc3VjaCBhcyBHRVQsIFBP U1QsIEhFQUQsIGFuZCBzbyBvbiwgd291bGQgYmUKKyAqIHVzZWQgYnkgV2ViS2l0IHdoZW4gdGFs a2luZyB0byB0aGUgd2Vic2VydmVyIGR1cmluZyB0aGlzIHJlcXVlc3QuCisgKgorICogUmV0dXJu czogYSBzdHJpbmcgd2l0aCB0aGUgbmFtZSBvZiB0aGUgbWV0aG9kCisgKgorICogU2luY2U6IDEu MC4yCisgKi8KK0dfQ09OU1RfUkVUVVJOIGdjaGFyKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dl dF9odHRwX21ldGhvZChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBnX3Jl dHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBOVUxM KTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnBy aXY7CisKKyAgICBpZiAocHJpdi0+aHR0cE1ldGhvZCkKKyAgICAgICAgcmV0dXJuIHByaXYtPmh0 dHBNZXRob2Q7CisKKyAgICBwcml2LT5odHRwTWV0aG9kID0gZ19zdHJkdXAocHJpdi0+cmVxdWVz dC5odHRwTWV0aG9kKCkudXRmOCgpLmRhdGEoKSk7CisgICAgcmV0dXJuIHByaXYtPmh0dHBNZXRo b2Q7Cit9CisKK3N0YXRpYyB2b2lkIGNvcHlfaGVhZGVyKGNvbnN0IGdjaGFyKiBrZXksIGNvbnN0 IGdjaGFyKiB2YWx1ZSwgZ3BvaW50ZXIgZGF0YSkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVz dCogcmVxdWVzdCA9IChXZWJLaXROZXR3b3JrUmVxdWVzdCopZGF0YTsKKworICAgIHdlYmtpdF9u ZXR3b3JrX3JlcXVlc3RfYWRkX2h0dHBfaGVhZGVyKHJlcXVlc3QsIGtleSwgdmFsdWUpOworfQor CisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfYWRkX2h0dHBfaGVhZGVycworICogQHJl cXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CisgKiBAaHR0cF9oZWFkZXJzOiBhICNHSGFz aFRhYmxlIHdpdGggaGVhZGVyL3ZhbHVlIHBhaXJzLCBhcyBzdHJpbmdzCisgKgorICogQWRkcyB0 aGUgaGVhZGVycyBjb250YWluZWQgYnkgdGhlIGdpdmVuIGhhc2ggdGFibGUgdG8gdGhlCisgKiBy ZXF1ZXN0LiBTZWUgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9hZGRfaHR0cF9oZWFkZXIoKS4KKyAq CisgKiBTaW5jZTogMS4wLjIKKyAqLwordm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2FkZF9o dHRwX2hlYWRlcnMoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IEdIYXNoVGFi bGUqIGh0dHBfaGVhZGVycykKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRX T1JLX1JFUVVFU1QocmVxdWVzdCkpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwoaHR0cF9oZWFkZXJz KTsKKworICAgIGdfaGFzaF90YWJsZV9mb3JlYWNoKChHSGFzaFRhYmxlKilodHRwX2hlYWRlcnMs IChHSEZ1bmMpY29weV9oZWFkZXIsIHJlcXVlc3QpOworfQorCitzdGF0aWMgR0hhc2hUYWJsZSog d2Via2l0X25ldHdvcmtfcmVxdWVzdF9wcml2YXRlX2dldF9odHRwX2hlYWRlcnMoV2ViS2l0TmV0 d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRl KiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIGlmKHByaXYtPmh0dHBIZWFkZXJzKQorICAg ICAgICByZXR1cm4gcHJpdi0+aHR0cEhlYWRlcnM7CisKKyAgICBwcml2LT5odHRwSGVhZGVycyA9 IGdfaGFzaF90YWJsZV9uZXdfZnVsbChnX3N0cl9oYXNoLCBnX3N0cl9lcXVhbCwgZ19mcmVlLCBn X2ZyZWUpOworICAgIEhUVFBIZWFkZXJNYXAgaGVhZGVycyA9IHByaXYtPnJlcXVlc3QuaHR0cEhl YWRlckZpZWxkcygpOworICAgIGlmICghaGVhZGVycy5pc0VtcHR5KCkpIHsKKyAgICAgICAgSFRU UEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgZW5kID0gaGVhZGVycy5lbmQoKTsKKyAgICAgICAg Zm9yIChIVFRQSGVhZGVyTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IGhlYWRlcnMuYmVnaW4oKTsg aXQgIT0gZW5kOyArK2l0KQorICAgICAgICAgICAgZ19oYXNoX3RhYmxlX2luc2VydChwcml2LT5o dHRwSGVhZGVycywgKGdwb2ludGVyKWdfc3RyZHVwKGl0LT5maXJzdC51dGY4KCkuZGF0YSgpKSwg KGdwb2ludGVyKWdfc3RyZHVwKGl0LT5zZWNvbmQudXRmOCgpLmRhdGEoKSkpOworICAgIH0KKwor ICAgIHJldHVybiBwcml2LT5odHRwSGVhZGVyczsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29y a19yZXF1ZXN0X2dldF9odHRwX2hlYWRlcnMKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3Jr UmVxdWVzdAorICogUmV0dXJuczogYSAjR0hhc2hUYWJsZSB3aXRoIHRoZSBoZWFkZXJzCisgKgor ICogT2J0YWlucyBhIHJlYWQtb25seSBoYXNoIHRhYmxlIHdpdGggdGhlIGhlYWRlcnMgZm9yIHRo ZSBnaXZlbgorICogI1dlYktpdE5ldHdvcmtSZXF1ZXN0LgorICoKKyAqIFNpbmNlOiAxLjAuMgor ICovCitHX0NPTlNUX1JFVFVSTiBHSGFzaFRhYmxlKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dl dF9odHRwX2hlYWRlcnMoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgZ19y ZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgTlVM TCk7CisKKyAgICByZXR1cm4gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9wcml2YXRlX2dldF9odHRw X2hlYWRlcnMocmVxdWVzdCk7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9h ZGRfaHR0cF9oZWFkZXIKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICog QGh0dHBfaGVhZGVyOiBhIHN0cmluZyB3aXRoIHRoZSBuYW1lIG9mIHRoZSBoZWFkZXIKKyAqIEB2 YWx1ZTogYSBzdHJpbmcgd2l0aCB0aGUgdmFsdWUgb2YgdGhlIGhlYWRlcgorICoKKyAqIEFkZHMg dGhlIEhUVFAgaGVhZGVyIHRvIHRoZSByZXF1ZXN0LiBIZWFkZXJzIHdoaWNoIGFscmVhZHkgZXhp c3QgaW4KKyAqIHRoZSByZXF1ZXN0IHdpbGwgaGF2ZSB0aGVpciB2YWx1ZSBhcHBlbmRlZCB0bywg d2l0aCBhIHNlcGFyYXRlZAorICogY29tbWEuCisgKgorICogRm9yIGluc3RhbmNlOiBpZiB0aGUg cmVxdWVzdCBhbHJlYWR5IGhhcyBhbiBBY2NlcHQtTGFuZ3VhZ2UgaGVhZGVyCisgKiB3aXRoIGEg dmFsdWUgb2YgImRhIiwgYW5kIHdlIGFkZCB0aGUgc2FtZSBBY2NlcHQtTGFuZ3VhZ2UgaGVhZGVy CisgKiBjb250YWluaW5nICJlbi1nYjtxPTAuOCIgd2Ugd2lsbCBlbmQgdXAgaGF2aW5nIGEgc2lu Z2xlCisgKiBBY2NlcHQtTGFuZ3VhZ2UgaGVhZGVyIHdpdGggYSB2YWx1ZSBvZiAiZGEsZW4tZ2I7 cT0wLjgiLgorICoKKyAqIFNpbmNlOiAxLjAuMgorICovCit2b2lkIHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfYWRkX2h0dHBfaGVhZGVyKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25z dCBnY2hhciogaHR0cF9oZWFkZXIsIGNvbnN0IGdjaGFyKiB2YWx1ZSkKK3sKKyAgICBnX3JldHVy bl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworICAgIGdfcmV0 dXJuX2lmX2ZhaWwoaHR0cF9oZWFkZXIpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwodmFsdWUpOwor CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsK KyAgICBHSGFzaFRhYmxlKiBoYXNoX3RhYmxlID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9wcml2 YXRlX2dldF9odHRwX2hlYWRlcnMocmVxdWVzdCk7CisKKyAgICBncG9pbnRlciBrZXlfbG9va3Vw OworCisgICAga2V5X2xvb2t1cCA9IGdfaGFzaF90YWJsZV9sb29rdXAoaGFzaF90YWJsZSwgaHR0 cF9oZWFkZXIpOworICAgIGlmICgha2V5X2xvb2t1cCkKKyAgICAgICAgZ19oYXNoX3RhYmxlX2lu c2VydChoYXNoX3RhYmxlLCAoZ3BvaW50ZXIpZ19zdHJkdXAoaHR0cF9oZWFkZXIpLCAoZ3BvaW50 ZXIpZ19zdHJkdXAodmFsdWUpKTsKKyAgICBlbHNlIHsKKyAgICAgICAgZ2NoYXIqIG5ld192YWx1 ZSA9IGdfc3RyZHVwX3ByaW50ZigiJXMsJXMiLCAoZ2NoYXIqKWtleV9sb29rdXAsIHZhbHVlKTsK KyAgICAgICAgZ19oYXNoX3RhYmxlX3JlcGxhY2UoaGFzaF90YWJsZSwgKGdwb2ludGVyKWdfc3Ry ZHVwKGh0dHBfaGVhZGVyKSwgKGdwb2ludGVyKWdfc3RyZHVwKG5ld192YWx1ZSkpOworICAgICAg ICBnX2ZyZWUobmV3X3ZhbHVlKTsKKyAgICB9CisKKyAgICBwcml2LT5yZXF1ZXN0LmFkZEhUVFBI ZWFkZXJGaWVsZChTdHJpbmc6OmZyb21VVEY4KGh0dHBfaGVhZGVyKSwgU3RyaW5nOjpmcm9tVVRG OCh2YWx1ZSkpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X2h0dHBf aGVhZGVyCisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEBodHRwX2hl YWRlcjogYSBzdHJpbmcgd2l0aCB0aGUgbmFtZSBvZiB0aGUgaGVhZGVyCisgKiBAdmFsdWU6IGEg c3RyaW5nIHdpdGggdGhlIHZhbHVlIG9mIHRoZSBoZWFkZXIKKyAqCisgKiBTZXRzIHRoZSBoZWFk ZXIgdG8gY29udGFpbiB0aGUgZ2l2ZW4gdmFsdWUsIGluIHRoaXMgcmVxdWVzdC4gSWYgdGhlCisg KiBoZWFkZXIgYWxyZWFkeSBleGlzdHMgaW4gdGhlIHJlcXVlc3QgdGhlIHZhbHVlIGlzIHJlcGxh Y2VkLgorICoKKyAqIFNpbmNlOiAxLjAuMgorICovCit2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVl c3Rfc2V0X2h0dHBfaGVhZGVyKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBn Y2hhciogaHR0cF9oZWFkZXIsIGNvbnN0IGdjaGFyKiB2YWx1ZSkKK3sKKyAgICBnX3JldHVybl9p Zl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOworICAgIGdfcmV0dXJu X2lmX2ZhaWwoaHR0cF9oZWFkZXIpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwodmFsdWUpOworCisg ICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKyAg ICBHSGFzaFRhYmxlKiBoZWFkZXJzID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9wcml2YXRlX2dl dF9odHRwX2hlYWRlcnMocmVxdWVzdCk7CisKKyAgICBnX2hhc2hfdGFibGVfcmVwbGFjZShoZWFk ZXJzLCBnX3N0cmR1cChodHRwX2hlYWRlciksIGdfc3RyZHVwKHZhbHVlKSk7CisgICAgCisgICAg cHJpdi0+cmVxdWVzdC5zZXRIVFRQSGVhZGVyRmllbGQoU3RyaW5nOjpmcm9tVVRGOChodHRwX2hl YWRlciksIFN0cmluZzo6ZnJvbVVURjgodmFsdWUpKTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X2dldF9odHRwX2hlYWRlcgorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdv cmtSZXF1ZXN0CisgKiBAaHR0cF9oZWFkZXI6IHRoZSBuYW1lIG9mIHRoZSBoZWFkZXIgd2Ugd2Fu dCB0byBvYnRhaW4gdGhlIHZhbHVlIGZvcgorICoKKyAqIEdldHMgdGhlIHZhbHVlIG9mIHRoZSB0 aGUgaGVhZGVyIGluIHRoZSBnaXZlbiByZXF1ZXN0LiBJZiB0aGUKKyAqIGhlYWRlciBkb2VzIG5v dCBleGlzdCBpbiB0aGUgcmVxdWVzdCAlTlVMTCBpcyByZXR1cm5lZC4KKyAqCisgKiBSZXR1cm5z OiBhIHN0cmluZyB3aXRoIHRoZSB2YWx1ZSBmb3IgdGhlIGhlYWRlciwgb3IgTlVMTCBpZiB0aGF0 CisgKiBoZWFkZXIgaXMgbm90IHNldCBmb3IgdGhlIHJlcXVlc3QKKyAqCisgKiBTaW5jZTogMS4w LjIKKyAqLworR19DT05TVF9SRVRVUk4gZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0 X2h0dHBfaGVhZGVyKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciog aHR0cF9oZWFkZXIpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdP UktfUkVRVUVTVChyZXF1ZXN0KSwgTlVMTCk7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoaHR0 cF9oZWFkZXIsIE5VTEwpOworCisgICAgR0hhc2hUYWJsZSogaGVhZGVycyA9IHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfcHJpdmF0ZV9nZXRfaHR0cF9oZWFkZXJzKHJlcXVlc3QpOworCisgICAgcmV0 dXJuIChjb25zdCBnY2hhciopZ19oYXNoX3RhYmxlX2xvb2t1cChoZWFkZXJzLCAoZ2NvbnN0cG9p bnRlcilodHRwX2hlYWRlcik7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9z ZXRfYm9keQorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CisgKiBAYm9keTog dGhlIGRhdGEgdGhhdCBzaG91bGQgYmUgc2VudCBhcyB0aGUgYm9keSBmb3IgdGhpcyByZXF1ZXN0 CisgKiBAbGVuZ3RoOiBzaXplIG9mIHRoZSBkYXRhCisgKgorICogU2V0cyB0aGUgYm9keSBvZiB0 aGUgcmVxdWVzdCB0byB0aGUgY29udGVudHMgb2YgdGhlIGdpdmVuCisgKiBzdHJpbmcuIFlvdSB3 aWxsIGFsc28gcHJvYmFibHkgbmVlZCB0byBjYWxsCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X3NldF9oZWFkZXIoKSB0byBzcGVjaWZ5IHRoZSBDb250ZW50LUxlbmd0aAorICogaGVhZGVyLgor ICoKKyAqIFNpbmNlOiAxLjAuMgorICovCit2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0 X2JvZHkoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdjaGFyKiBib2R5LCBj b25zdCBnc2l6ZSBzaXplKQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdP UktfUkVRVUVTVChyZXF1ZXN0KSk7CisgICAgZ19yZXR1cm5faWZfZmFpbChib2R5KTsKKworICAg IFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAg ICBnX2ZyZWUocHJpdi0+Ym9keSk7CisgICAgcHJpdi0+Ym9keVNpemUgPSAwOworICAgIHByaXYt PnJlcXVlc3Quc2V0SFRUUEJvZHkoRm9ybURhdGE6OmNyZWF0ZSgoY29uc3Qgdm9pZCopYm9keSwg KHNpemVfdClzaXplKSk7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRf Ym9keQorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CisgKiBAYm9keV9zaXpl OiBhIHBvaW50ZXIgdG8gYSAjZ3NpemUsIG9yICVOVUxMCisgKgorICogR2V0cyB0aGUgYm9keSBv ZiB0aGUgcmVxdWVzdC4gSWYgZ2l2ZW4sIEBib2R5X3NpemUgd2lsbCBiZSBzZXQgdG8KKyAqIHRo ZSBzaXplIG9mIHRoZSBib2R5IGRhdGEuIFRoaXMgaXMgdXNlZnVsIGJlY2F1c2UgdGhlIGJvZHkg bWF5IG5vdAorICogYmUgYSBzdHJpbmcsIGFuZCBtYXkgaGF2ZSBhIG51bWJlciBvZiAnXDAnIGNo YXJhY3RlcnMgYXMgcGFydCBvZgorICogdGhlIGRhdGEuCisgKgorICogUmV0dXJuczogYSBzdHJp bmcgd2l0aCB0aGUgYm9keSBvZiB0aGUgcmVxdWVzdCBvciAlTlVMTCBpZiB0aGUKKyAqIHJlcXVl c3QgZG9lcyBub3QgaGF2ZSBhIGJvZHkKKyAqCisgKiBTaW5jZTogMS4wLjIKKyAqLworR19DT05T VF9SRVRVUk4gZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2JvZHkoV2ViS2l0TmV0 d29ya1JlcXVlc3QqIHJlcXVlc3QsIGdzaXplICpib2R5X3NpemUpCit7CisgICAgZ19yZXR1cm5f dmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgTlVMTCk7CisK KyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2Owor CisgICAgaWYgKGdfYXNjaWlfc3RyY2FzZWNtcCAod2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRf aHR0cF9tZXRob2QocmVxdWVzdCksICJQT1NUIikgPT0gMCkgeworICAgICAgICBpZighcHJpdi0+ Ym9keSkgeworICAgICAgICAgICAgVmVjdG9yPGNoYXI+IGRhdGE7CisgICAgICAgICAgICBwcml2 LT5yZXF1ZXN0Lmh0dHBCb2R5KCktPmZsYXR0ZW4oZGF0YSk7CisgICAgICAgICAgICBwcml2LT5i b2R5ID0gZ19zdHJkdXAoZGF0YS5kYXRhKCkpOworICAgICAgICAgICAgcHJpdi0+Ym9keVNpemUg PSBkYXRhLnNpemUoKTsKKyAgICAgICAgfQorCisgICAgICAgICpib2R5X3NpemUgPSBwcml2LT5i b2R5U2l6ZTsKKyAgICAgICAgcmV0dXJuIHByaXYtPmJvZHk7CisgICAgfQorCisgICAgcmV0dXJu IE5VTEw7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfYWxsb3dfaHR0 cF9jb29raWVzCisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEBhbGxv d19odHRwX2Nvb2tpZXM6IHdoZXRoZXIgSFRUUCBjb29raWVzIHNob3VsZCBiZSBhbGxvd2VkCisg KgorICogU2V0cyB3aGV0aGVyIEhUVFAgY29va2llcyBzaG91bGQgYmUgYWxsb3dlZCB0byBiZSBz ZXQgaW4gcmVzcG9uc2UKKyAqIHRvIHRoaXMgcmVxdWVzdC4KKyAqCisgKiBTaW5jZTogMS4wLjIK KyAqLwordm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF9hbGxvd19odHRwX2Nvb2tpZXMo V2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IGdib29sZWFuIGFsbG93X2h0dHBf Y29va2llcykKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVF U1QocmVxdWVzdCkpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0g cmVxdWVzdC0+cHJpdjsKKworICAgIHByaXYtPnJlcXVlc3Quc2V0QWxsb3dIVFRQQ29va2llcyhh bGxvd19odHRwX2Nvb2tpZXMpOworICAgIGdfb2JqZWN0X25vdGlmeShHX09CSkVDVChyZXF1ZXN0 KSwgImFsbG93LWh0dHAtY29va2llcyIpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X2FsbG93X2h0dHBfY29va2llcworICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdv cmtSZXF1ZXN0CisgKgorICogT2J0YWlucyB3aGV0aGVyIGNvb2tpZXMgYXJlIGFsbG93ZWQgYnkg dGhlIHJlcXVlc3QuCisgKgorICogUmV0dXJuczogJVRSVUUgaWYgY29va2llcyBhcmUgYWxsb3dl ZCBpbiByZXNwb25zZSB0byB0aGlzIHJlcXVlc3QsCisgKiAlRkFMU0Ugb3RoZXJ3aXNlCisgKgor ICogU2luY2U6IDEuMC4yCisgKi8KK2dib29sZWFuIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0 X2FsbG93X2h0dHBfY29va2llcyhXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3sKKyAg ICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNUKHJlcXVlc3Qp LCBGQUxTRSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1 ZXN0LT5wcml2OworCisgICAgcmV0dXJuIHByaXYtPnJlcXVlc3QuYWxsb3dIVFRQQ29va2llcygp OworfQorCiB9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVx dWVzdC5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuaAppbmRleCBk ZmI0ZDZjLi44MTBjMjU2IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3 b3JrcmVxdWVzdC5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0 LmgKQEAgLTEsNSArMSw2IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAyMDA3IEhvbGdlciBIYW5z IFBldGVyIEZyZXl0aGVyCisgKiBDb3B5cmlnaHQgKEMpIDIwMDggR3VzdGF2byBOb3JvbmhhIFNp bHZhCiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vcgogICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05V IExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAgLTQ1LDYgKzQ2LDI5IEBAIHN0cnVjdCBfV2ViS2l0 TmV0d29ya1JlcXVlc3RDbGFzcyB7CiAgICAgR09iamVjdENsYXNzIHBhcmVudF9jbGFzczsKIH07 CiAKKy8qIFRoZSBXZWJLaXRSZXFDYWNoZVBvbGljeSBlbnVtIG11c3QgYmUgaW4gc3luYyB3aXRo CisgKiBSZXNvdXJjZVJlcXVlc3RDYWNoZVBvbGljeSBpbiAKKyAqIFdlYkNvcmUvcGxhdGZvcm0v bmV0d29yay9SZXNvdXJjZVJlcXVlc3RCYXNlLmgKKyAqLworLyoqCisgKiBXZWJLaXRSZXFDYWNo ZVBvbGljeToKKyAqIEBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9QUk9UT0NPTDogdXNlIHRoZSBI VFRQIHByb3RvY29sIGNhY2hpbmcKKyAqIHJ1bGVzCisgKiBAV0VCS0lUX1JFUV9DQUNIRV9QT0xJ Q1lfUkVMT0FEX0lHTk9SSU5HX0NBQ0hFOiBmb3JjZSBhIHJlbG9hZCwKKyAqIGlnbm9yaW5nIGFu eSBjYWNoZQorICogQFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX0FMTE9XX1NUQUxFOiB1c2UgZGF0 YSBmcm9tIGNhY2hlLCBpZgorICogYXZhaWxhYmxlLCBldmVuIGlmIGl0IGlzIHN0YWxlLCBhbmQg bG9hZCBpdCBmcmVzaCBvdGhlcndpc2UKKyAqIEBXRUJLSVRfUkVRX0NBQ0hFX1BPTElDWV9DQUNI RV9PTkxZOiBmb3JjZSB1c2luZyB0aGUgY2FjaGUgb25seTsKKyAqIHVzZWZ1bCBmb3Igb2ZmbGlu ZSBtb2RlcworICovCit0eXBlZGVmIGVudW0KK3sKKyAgV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lf UFJPVE9DT0wsCisgIFdFQktJVF9SRVFfQ0FDSEVfUE9MSUNZX1JFTE9BRF9JR05PUklOR19DQUNI RSwKKyAgV0VCS0lUX1JFUV9DQUNIRV9QT0xJQ1lfQUxMT1dfU1RBTEUsCisgIFdFQktJVF9SRVFf Q0FDSEVfUE9MSUNZX0NBQ0hFX09OTFksCit9IFdlYktpdFJlcUNhY2hlUG9saWN5OworCiBXRUJL SVRfQVBJIEdUeXBlCiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF90eXBlICh2b2lkKTsKIApA QCAtNTgsNiArODIsNTcgQEAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpICAoV2ViS2l0 TmV0d29ya1JlcXVlc3QgKnJlcXVlc3QsCiBXRUJLSVRfQVBJIEdfQ09OU1RfUkVUVVJOIGdjaGFy ICoKIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaSAgKFdlYktpdE5ldHdvcmtSZXF1ZXN0 ICpyZXF1ZXN0KTsKIAorV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3Nl dF9jYWNoZV9wb2xpY3koV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IFdlYktp dFJlcUNhY2hlUG9saWN5IGNhY2hlX3BvbGljeSk7CisKK1dFQktJVF9BUEkgV2ViS2l0UmVxQ2Fj aGVQb2xpY3kKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2NhY2hlX3BvbGljeShXZWJLaXRO ZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X25ldHdv cmtfcmVxdWVzdF9zZXRfdGltZW91dF9pbnRlcnZhbChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVx dWVzdCwgY29uc3QgZ2RvdWJsZSB0aW1lb3V0X2ludGVydmFsKTsKKworV0VCS0lUX0FQSSBnZG91 YmxlCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF90aW1lb3V0X2ludGVydmFsKFdlYktpdE5l dHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29y a19yZXF1ZXN0X3NldF9tYWluX2RvY3VtZW50X3VyaShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVx dWVzdCwgY29uc3QgZ2NoYXIqIG1haW5fZG9jdW1lbnRfdXJpKTsKKworV0VCS0lUX0FQSSBjb25z dCBnY2hhcioKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X21haW5fZG9jdW1lbnRfdXJpKFdl YktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRf bmV0d29ya19yZXF1ZXN0X3NldF9odHRwX21ldGhvZCAoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJl cXVlc3QsIGNvbnN0IGdjaGFyKiBodHRwX21ldGhvZCk7CisKK1dFQktJVF9BUEkgY29uc3QgZ2No YXIqCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9odHRwX21ldGhvZCAoV2ViS2l0TmV0d29y a1JlcXVlc3QqIHJlcXVlc3QpOworCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfYWRkX2h0dHBfaGVhZGVycyAoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNv bnN0IEdIYXNoVGFibGUqIGh0dHBfaGVhZGVycyk7CisKK1dFQktJVF9BUEkgY29uc3QgR0hhc2hU YWJsZSoKK3dlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2h0dHBfaGVhZGVycyAoV2ViS2l0TmV0 d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfYWRkX2h0dHBfaGVhZGVyKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBj b25zdCBnY2hhciogaHR0cF9oZWFkZXIsIGNvbnN0IGdjaGFyKiB2YWx1ZSk7CisKK1dFQktJVF9B UEkgdm9pZAord2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfaHR0cF9oZWFkZXIgKFdlYktpdE5l dHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciogaHR0cF9oZWFkZXIsIGNvbnN0IGdj aGFyKiB2YWx1ZSk7CisKK1dFQktJVF9BUEkgY29uc3QgZ2NoYXIqCit3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X2dldF9odHRwX2hlYWRlciAoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIGNv bnN0IGdjaGFyKiBodHRwX2hlYWRlcik7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X25ldHdv cmtfcmVxdWVzdF9zZXRfYm9keShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3Qg Z2NoYXIqIGJvZHksIGNvbnN0IGdzaXplIHNpemUpOworCitXRUJLSVRfQVBJIGNvbnN0IGdjaGFy Kgord2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfYm9keShXZWJLaXROZXR3b3JrUmVxdWVzdCog cmVxdWVzdCwgZ3NpemUgKmJvZHlfc2l6ZSk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X25l dHdvcmtfcmVxdWVzdF9zZXRfYWxsb3dfaHR0cF9jb29raWVzKFdlYktpdE5ldHdvcmtSZXF1ZXN0 KiByZXF1ZXN0LCBjb25zdCBnYm9vbGVhbiBhbGxvd19odHRwX2Nvb2tpZXMpOworCitXRUJLSVRf QVBJIGdib29sZWFuCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9hbGxvd19odHRwX2Nvb2tp ZXMoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCiBHX0VORF9ERUNMUwogCiAjZW5k aWYKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5j cHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuY3BwCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjkyNzlmYjcKLS0tIC9kZXYvbnVsbAorKysgYi9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuY3BwCkBAIC0wLDAgKzEsMTU2 IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA4IEd1c3Rhdm8gTm9yb25oYSBTaWx2YQorICoK KyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBp dCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5 IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3Ig KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkg aXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5 IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBP U0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0 aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlz IGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAq IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwg RmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaW5j bHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRlICJ3ZWJraXRuZXR3b3JrcmVzcG9uc2UuaCIKKwor I2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjaW5jbHVkZSAiUmVzb3VyY2VSZXNwb25zZS5o IgorI2luY2x1ZGUgIkNTdHJpbmcuaCIKKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKK2V4 dGVybiAiQyIgeworCitHX0RFRklORV9UWVBFKFdlYktpdE5ldHdvcmtSZXNwb25zZSwgd2Via2l0 X25ldHdvcmtfcmVzcG9uc2UsIEdfVFlQRV9PQkpFQ1QpOworCitzdHJ1Y3QgX1dlYktpdE5ldHdv cmtSZXNwb25zZVByaXZhdGUgeworICAgIFJlc291cmNlUmVzcG9uc2UgcmVzcG9uc2U7CisKKyAg ICBnY2hhciogdXJpOworfTsKKworI2RlZmluZSBXRUJLSVRfTkVUV09SS19SRVNQT05TRV9HRVRf UFJJVkFURShvYmopIChHX1RZUEVfSU5TVEFOQ0VfR0VUX1BSSVZBVEUoKG9iaiksIFdFQktJVF9U WVBFX05FVFdPUktfUkVTUE9OU0UsIFdlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUpKQorCitz dGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9maW5hbGl6ZShHT2JqZWN0KiBvYmpl Y3QpCit7CisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSA9IFdFQktJVF9ORVRX T1JLX1JFU1BPTlNFKG9iamVjdCk7CisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSog cHJpdiA9IHJlc3BvbnNlLT5wcml2OworCisgICAgZ19mcmVlKHByaXYtPnVyaSk7CisKKyAgICBH X09CSkVDVF9DTEFTUyh3ZWJraXRfbmV0d29ya19yZXNwb25zZV9wYXJlbnRfY2xhc3MpLT5maW5h bGl6ZShvYmplY3QpOworfQorCitzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9j bGFzc19pbml0KFdlYktpdE5ldHdvcmtSZXNwb25zZUNsYXNzKiByZXNwb25zZUNsYXNzKQorewor ICAgIEdfT0JKRUNUX0NMQVNTKHJlc3BvbnNlQ2xhc3MpLT5maW5hbGl6ZSA9IHdlYmtpdF9uZXR3 b3JrX3Jlc3BvbnNlX2ZpbmFsaXplOworCisgICAgZ190eXBlX2NsYXNzX2FkZF9wcml2YXRlKHJl c3BvbnNlQ2xhc3MsIHNpemVvZihXZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlKSk7Cit9CisK K3N0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2luaXQoV2ViS2l0TmV0d29ya1Jl c3BvbnNlKiByZXNwb25zZSkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlKiBw cml2ID0gV0VCS0lUX05FVFdPUktfUkVTUE9OU0VfR0VUX1BSSVZBVEUocmVzcG9uc2UpOworICAg IHJlc3BvbnNlLT5wcml2ID0gcHJpdjsKK30KKworCisvLyBmb3IgaW50ZXJuYWwgdXNlIG9ubHkK K1dlYktpdE5ldHdvcmtSZXNwb25zZSogd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfbmV3X2Zyb21f cmVzb3VyY2VfcmVzcG9uc2UoUmVzb3VyY2VSZXNwb25zZSYgcmVzb3VyY2VSZXNwb25zZSkKK3sK KyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlID0gV0VCS0lUX05FVFdPUktfUkVT UE9OU0UoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UsIE5VTEwpKTsK KyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlKiBwcml2ID0gcmVzcG9uc2UtPnByaXY7 CisKKyAgICBwcml2LT5yZXNwb25zZSA9IHJlc291cmNlUmVzcG9uc2U7CisKKyAgICByZXR1cm4g cmVzcG9uc2U7Cit9CisKKy8vIGZvciBpbnRlcm5hbCB1c2Ugb25seQorUmVzb3VyY2VSZXNwb25z ZSB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfcmVzb3VyY2VfcmVzcG9uc2UoY29uc3QgV2Vi S2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9u c2VQcml2YXRlKiBwcml2ID0gcmVzcG9uc2UtPnByaXY7CisKKyAgICByZXR1cm4gcHJpdi0+cmVz cG9uc2U7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfbmV3OgorICogQHVy aTogYW4gYWxyZWFkeSBlbmNvZGVkIFVSSQorICoKKyAqIENyZWF0ZXMgYSBuZXcgI1dlYktpdE5l dHdvcmtSZXNwb25zZSBpbml0aWFsaXplZCB3aXRoIGFuIFVSSS4KKyAqCisgKiBSZXR1cm5zOiBh IG5ldyAjV2ViS2l0TmV0d29ya1Jlc3BvbnNlCisgKgorICogU2luY2U6IDEuMC4yCisgKi8KK1dl YktpdE5ldHdvcmtSZXNwb25zZSogd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfbmV3KGNvbnN0IGdj aGFyKiB1cmkpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwodXJpLCBOVUxMKTsKKworICAg IFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UgPSBXRUJLSVRfTkVUV09SS19SRVNQT05T RShnX29iamVjdF9uZXcoV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSwgTlVMTCkpOworICAg IFdlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUqIHByaXYgPSByZXNwb25zZS0+cHJpdjsKKwor ICAgIHByaXYtPnVyaSA9IGdfc3RyZHVwKHVyaSk7CisKKyAgICByZXR1cm4gcmVzcG9uc2U7Cit9 CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVzcG9uc2Vfc2V0X3VyaToKKyAqIEByZXNwb25z ZTogYSAjV2ViS2l0TmV0d29ya1Jlc3BvbnNlCisgKiBAdXJpOiBhbiBhbHJlYWR5IGVuY29kZWQg VVJJCisgKgorICogU2V0cyB0aGUgVVJJIGhlbGQgYW5kIHVzZWQgYnkgdGhlIGdpdmVuIHJlc3Bv bnNlLgorICoKKyAqIFNpbmNlOiAxLjAuMgorICovCit2b2lkIHdlYmtpdF9uZXR3b3JrX3Jlc3Bv bnNlX3NldF91cmkoV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSwgY29uc3QgZ2NoYXIq IHVyaSkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFU1BPTlNF KHJlc3BvbnNlKSk7CisgICAgZ19yZXR1cm5faWZfZmFpbCh1cmkpOworCisgICAgV2ViS2l0TmV0 d29ya1Jlc3BvbnNlUHJpdmF0ZSogcHJpdiA9IHJlc3BvbnNlLT5wcml2OworCisgICAgZ19mcmVl KHByaXYtPnVyaSk7CisgICAgcHJpdi0+dXJpID0gZ19zdHJkdXAodXJpKTsKKworICAgIC8qIAor ICAgICAqIGZlZWRpbmcgYmFjayB0byB0aGUgUmVzb3VyY2VSZXNwb25zZSBvYmplY3QsIHdoaWNo IGlzIHRoZSBvbmUgYWN0dWFsbHkgdXNlZAorICAgICAqIGluc2lkZSBXZWJDb3JlCisgICAgICov CisgICAgcHJpdi0+cmVzcG9uc2Uuc2V0VXJsKEtVUkwoU3RyaW5nOjpmcm9tVVRGOCh1cmkpKSk7 Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3VyaToKKyAqIEByZXNw b25zZTogYSAjV2ViS2l0TmV0d29ya1Jlc3BvbnNlCisgKgorICogR2V0cyB0aGUgVVJJIGhlbGQg YW5kIHVzZWQgYnkgdGhlIGdpdmVuIHJlc3BvbnNlLgorICoKKyAqIFJldHVybnM6IHRoZSBVUkkg aGVsZCBhbmQgdXNlZCBieSB0aGUgZ2l2ZW4gcmVzcG9uc2UKKyAqCisgKiBTaW5jZTogMS4wLjIK KyAqLworY29uc3QgZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF91cmkoV2ViS2l0 TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChX RUJLSVRfSVNfTkVUV09SS19SRVNQT05TRShyZXNwb25zZSksIE5VTEwpOworCisgICAgV2ViS2l0 TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSogcHJpdiA9IHJlc3BvbnNlLT5wcml2OworICAgIAorICAg IGlmIChwcml2LT51cmkpCisgICAgICAgIHJldHVybiBwcml2LT51cmk7CisKKyAgICBwcml2LT51 cmkgPSBnX3N0cmR1cChwcml2LT5yZXNwb25zZS51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgp KTsKKyAgICByZXR1cm4gcHJpdi0+dXJpOworfQorCit9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dG5ldHdvcmtyZXNwb25zZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjM3 OGE4YTUKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3Jr cmVzcG9uc2UuaApAQCAtMCwwICsxLDYzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA4IEd1 c3Rhdm8gTm9yb25oYSBTaWx2YQorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1 Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNp b24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lv bi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBp dCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBl dmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBo YXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJ Qi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIElu Yy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEw LTEzMDEsIFVTQS4KKyAqLworCisjaWZuZGVmIFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFX0gKKyNk ZWZpbmUgV0VCS0lUX05FVFdPUktfUkVTUE9OU0VfSAorCisjaW5jbHVkZSA8Z2xpYi1vYmplY3Qu aD4KKworI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRkZWZpbmVzLmg+CisKK0dfQkVHSU5fREVDTFMK KworI2RlZmluZSBXRUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNFICAgICAgICAgICAgKHdlYmtp dF9uZXR3b3JrX3Jlc3BvbnNlX2dldF90eXBlKCkpCisjZGVmaW5lIFdFQktJVF9ORVRXT1JLX1JF U1BPTlNFKG9iaikgICAgICAgICAgICAoR19UWVBFX0NIRUNLX0lOU1RBTkNFX0NBU1QoKG9iaiks IFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UsIFdlYktpdE5ldHdvcmtSZXNwb25zZSkpCisj ZGVmaW5lIFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFX0NMQVNTKGtsYXNzKSAgICAoR19UWVBFX0NI RUNLX0NMQVNTX0NBU1QoKGtsYXNzKSwgIFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UsIFdl YktpdE5ldHdvcmtSZXNwb25zZUNsYXNzKSkKKyNkZWZpbmUgV0VCS0lUX0lTX05FVFdPUktfUkVT UE9OU0Uob2JqKSAgICAgICAgIChHX1RZUEVfQ0hFQ0tfSU5TVEFOQ0VfVFlQRSgob2JqKSwgV0VC S0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSkpCisjZGVmaW5lIFdFQktJVF9JU19ORVRXT1JLX1JF U1BPTlNFX0NMQVNTKGtsYXNzKSAoR19UWVBFX0NIRUNLX0NMQVNTX1RZUEUoKGtsYXNzKSwgIFdF QktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UpKQorI2RlZmluZSBXRUJLSVRfTkVUV09SS19SRVNQ T05TRV9HRVRfQ0xBU1Mob2JqKSAgKEdfVFlQRV9JTlNUQU5DRV9HRVRfQ0xBU1MoKG9iaiksICBX RUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNFLCBXZWJLaXROZXR3b3JrUmVzcG9uc2VDbGFzcykp CisKK3R5cGVkZWYgc3RydWN0IF9XZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlIFdlYktpdE5l dHdvcmtSZXNwb25zZVByaXZhdGU7CisKK3N0cnVjdCBfV2ViS2l0TmV0d29ya1Jlc3BvbnNlIHsK KyAgICBHT2JqZWN0IHBhcmVudF9pbnN0YW5jZTsKKworICAgIFdlYktpdE5ldHdvcmtSZXNwb25z ZVByaXZhdGUqIHByaXY7Cit9OworCitzdHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXNwb25zZUNsYXNz IHsKKyAgICBHT2JqZWN0Q2xhc3MgcGFyZW50X2NsYXNzOworfTsKKworV0VCS0lUX0FQSSBHVHlw ZQord2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3R5cGUgKHZvaWQpOworCitXRUJLSVRfQVBJ IFdlYktpdE5ldHdvcmtSZXNwb25zZSoKK3dlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX25ldyAoY29u c3QgZ2NoYXIqIHVyaSk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X25ldHdvcmtfcmVzcG9u c2Vfc2V0X3VyaSAoV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSwgY29uc3QgZ2NoYXIq IHVyaSk7CisKK1dFQktJVF9BUEkgY29uc3QgZ2NoYXIqCit3ZWJraXRfbmV0d29ya19yZXNwb25z ZV9nZXRfdXJpIChXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlKTsKKworCitHX0VORF9E RUNMUworCisjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZh dGUuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAKaW5kZXggMzEzYmQ1 ZS4uMzZhMGQ0OCAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5j cHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAKQEAgLTIzLDYgKzIz LDcgQEAKICNpbmNsdWRlICJDaHJvbWVDbGllbnRHdGsuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRl ci5oIgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyQ2xpZW50R3RrLmgiCisjaW5jbHVkZSAiUmVzb3Vy Y2VSZXF1ZXN0LmgiCiAjaW5jbHVkZSAiTG9nZ2luZy5oIgogI2luY2x1ZGUgIk5vdEltcGxlbWVu dGVkLmgiCiAjaW5jbHVkZSAiUGFnZUNhY2hlLmgiCkBAIC04Myw2ICs4NCwxNiBAQCBXZWJLaXRX ZWJWaWV3KiBraXQoV2ViQ29yZTo6UGFnZSogY29yZVBhZ2UpCiAgICAgcmV0dXJuIGNsaWVudCA/ IGNsaWVudC0+d2ViVmlldygpIDogMDsKIH0KIAorUmVzb3VyY2VSZXF1ZXN0Q2FjaGVQb2xpY3kg Y29yZShXZWJLaXRSZXFDYWNoZVBvbGljeSBjYWNoZVBvbGljeSkKK3sKKyAgICByZXR1cm4gKFJl c291cmNlUmVxdWVzdENhY2hlUG9saWN5KWNhY2hlUG9saWN5OworfQorCitXZWJLaXRSZXFDYWNo ZVBvbGljeSBraXQoUmVzb3VyY2VSZXF1ZXN0Q2FjaGVQb2xpY3kgY2FjaGVQb2xpY3kpCit7Cisg ICAgcmV0dXJuIChXZWJLaXRSZXFDYWNoZVBvbGljeSljYWNoZVBvbGljeTsKK30KKwogfSAvKiog ZW5kIG5hbWVzcGFjZSBXZWJLaXQgKi8KIAogdm9pZCB3ZWJraXRfaW5pdCgpCmRpZmYgLS1naXQg YS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93 ZWJraXRwcml2YXRlLmgKaW5kZXggZWQ4MWExYy4uNjk1OGM2MyAxMDA2NDQKLS0tIGEvV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dHByaXZhdGUuaApAQCAtMjIsNyArMjIsOCBAQAogI2RlZmluZSBXRUJLSVRfUFJJVkFURV9ICiAK IC8qCi0gKiBUaGlzIGZpbGUga25vd3MgdGhlIHNoYXJlZCBzZWNyZXQgb2YgV2ViS2l0V2ViVmll dyBhbmQgV2ViS2l0V2ViRnJhbWUuCisgKiBUaGlzIGZpbGUga25vd3MgdGhlIHNoYXJlZCBzZWNy ZXQgb2YgV2ViS2l0V2ViVmlldywgV2ViS2l0V2ViRnJhbWUsCisgKiBhbmQgV2ViS2l0TmV0d29y a1JlcXVlc3QuCiAgKiBUaGV5IGFyZSB1c2luZyBXZWJDb3JlIHdoaWNoIG11c24ndCBiZSBleHBv c2VkIHRvIHRoZSBvdXRlciB3b3JsZC4KICAqLwogCkBAIC0zMSw2ICszMiw3IEBACiAjaW5jbHVk ZSA8d2Via2l0L3dlYmtpdHdlYmZyYW1lLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYnNl dHRpbmdzLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYmJhY2tmb3J3YXJkbGlzdC5oPgor I2luY2x1ZGUgPHdlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oPgogCiAjaW5jbHVkZSAiQmFj a0ZvcndhcmRMaXN0LmgiCiAjaW5jbHVkZSAiSGlzdG9yeUl0ZW0uaCIKQEAgLTM4LDYgKzQwLDcg QEAKICNpbmNsdWRlICJQYWdlLmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJGcmFt ZUxvYWRlckNsaWVudC5oIgorI2luY2x1ZGUgIlJlc291cmNlUmVxdWVzdC5oIgogCiAjaW5jbHVk ZSA8Z2xpYi5oPgogCkBAIC01NCw2ICs1Nyw5IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogICAgIFdl YktpdFdlYkhpc3RvcnlJdGVtKiBraXQoV2ViQ29yZTo6SGlzdG9yeUl0ZW0qKTsKIAogICAgIFdl YkNvcmU6OkJhY2tGb3J3YXJkTGlzdCogY29yZShXZWJLaXRXZWJCYWNrRm9yd2FyZExpc3QqKTsK KworICAgIFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdENhY2hlUG9saWN5IGNvcmUoV2ViS2l0UmVx Q2FjaGVQb2xpY3kgY2FjaGVQb2xpY3kpOworICAgIFdlYktpdFJlcUNhY2hlUG9saWN5IGtpdChX ZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3RDYWNoZVBvbGljeSBjYWNoZVBvbGljeSk7CiB9CiAKIGV4 dGVybiAiQyIgewpAQCAtMTEwLDYgKzExNiwxOCBAQCBleHRlcm4gIkMiIHsKICAgICBXZWJLaXRX ZWJIaXN0b3J5SXRlbSoKICAgICB3ZWJraXRfd2ViX2hpc3RvcnlfaXRlbV9uZXdfd2l0aF9jb3Jl X2l0ZW0oV2ViQ29yZTo6SGlzdG9yeUl0ZW0qKTsKIAorICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0 KgorICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X2Zyb21fcmVzb3VyY2VfcmVxdWVzdChj b25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCk7CisKKyAgICBX ZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QKKyAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9y ZXNvdXJjZV9yZXF1ZXN0KGNvbnN0IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKwor ICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZSoKKyAgICB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9u ZXdfZnJvbV9yZXNvdXJjZV9yZXNwb25zZShXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlJiByZXNv dXJjZVJlc3BvbnNlKTsKKworICAgIFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UKKyAgICB3ZWJr aXRfbmV0d29ya19yZXNwb25zZV9nZXRfcmVzb3VyY2VfcmVzcG9uc2UoY29uc3QgV2ViS2l0TmV0 d29ya1Jlc3BvbnNlKiByZXNwb25zZSk7CisKICAgICAvLyBGSVhNRTogTW92ZSB0aGVzZSB0byB3 ZWJraXR3ZWJmcmFtZS5oIG9uY2UgdGhlaXIgQVBJIGhhcyBiZWVuIGRpc2N1c3NlZC4KIAogICAg IFdFQktJVF9BUEkgR1NMaXN0KgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 d2ViZnJhbWUuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCmluZGV4 IGE3ZjI3ZWYuLmI5MWEwMGQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdl YmZyYW1lLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKQEAg LTM1Myw5ICszNTMsNyBAQCB2b2lkIHdlYmtpdF93ZWJfZnJhbWVfbG9hZF9yZXF1ZXN0KFdlYktp dFdlYkZyYW1lKiBmcmFtZSwgV2ViS2l0TmV0d29ya1JlcXVlc3QqCiAgICAgRnJhbWUqIGNvcmVG cmFtZSA9IGNvcmUoZnJhbWUpOwogICAgIEFTU0VSVChjb3JlRnJhbWUpOwogCi0gICAgLy8gVE9E TzogVXNlIHRoZSBSZXNvdXJjZVJlcXVlc3QgY2FycmllZCBieSBXZWJLaXROZXR3b3JrUmVxdWVz dCB3aGVuIGl0IGlzIGltcGxlbWVudGVkLgotICAgIFN0cmluZyBzdHJpbmcgPSBTdHJpbmc6OmZy b21VVEY4KHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShyZXF1ZXN0KSk7Ci0gICAgY29y ZUZyYW1lLT5sb2FkZXIoKS0+bG9hZChSZXNvdXJjZVJlcXVlc3QoS1VSTChzdHJpbmcpKSk7Cisg ICAgY29yZUZyYW1lLT5sb2FkZXIoKS0+bG9hZCh3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9y ZXNvdXJjZV9yZXF1ZXN0KHJlcXVlc3QpKTsKIH0KIAogLyoqCg== 26755 2009-01-15 07:06:14 -0800 2009-01-15 09:02:21 -0800 Minimal functionality addition patch 0001-network-request-minimal-functionality.patch text/plain 9421 gustavo RnJvbSA1NmU2NTQyYWI4N2FmNWJiMDE3ZmFlMGYyZmQ1ODNhZTdkMmM5ZWJhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGtvdkBrb3YuZXRpLmJy PgpEYXRlOiBUaHUsIDE1IEphbiAyMDA5IDExOjI4OjM0IC0wMjAwClN1YmplY3Q6IFtQQVRDSF0g bmV0d29yayByZXF1ZXN0IG1pbmltYWwgZnVuY3Rpb25hbGl0eQoKLS0tCiBXZWJLaXQvZ3RrL0No YW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjUgKysrKysrKysKIFdl YktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwIHwgICAgMyAr LQogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwICAgICAgICAgfCAg IDY0ICsrKysrKysrKysrKysrKysrKy0tCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRl LmggICAgICAgICAgICAgICAgICB8ICAgMTEgKysrLQogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 d2ViZnJhbWUuY3BwICAgICAgICAgICAgICAgfCAgICA0ICstCiA1IGZpbGVzIGNoYW5nZWQsIDk3 IGluc2VydGlvbnMoKyksIDEwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsv Q2hhbmdlTG9nIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKaW5kZXggN2I5NTRmNi4uZmYwNmU4ZiAx MDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2d0ay9DaGFuZ2VM b2cKQEAgLTEsMyArMSwyOCBAQAorMjAwOS0wMS0xNSAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8 Z25zQGdub21lLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBSZWZlcnMgdG8gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE4NjA4CisgICAgICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0IG5lZWRzIHRvIGJlIGZpbmlzaGVk CisKKyAgICAgICAgVGhpcyBjaGFuZ2VzZXQgaXMgY29uY2VybmVkIHdpdGggbWFraW5nIFdlYktp dE5ldHdvcmtSZXF1ZXN0IGNhcnJ5CisgICAgICAgIFJlc291cmNlUmVxdWVzdCBpbiBhZGRpdGlv biB0byBzaW1wbHkgc3RvcmluZyB0aGUgVVJJLCB3aGljaAorICAgICAgICBhbGxvd3MgdXMgdG8g Z2V0IHRoZSBmdWxsIGluZm9ybWF0aW9uIGZlZCBiYWNrIGludG8gV2ViS2l0IHdoZW4KKyAgICAg ICAgbmVlZGVkLiBGcmFtZUxvYWRlckNsaWVudEd0ayBpcyBub3cgdXNpbmcgV2ViS2l0TmV0d29y a1JlcXVlc3QKKyAgICAgICAgd2hlbiBpdCBuZWVkcyB0byBkZWFsIHdpdGggcmVxdWVzdCBpbmZv cm1hdGlvbi4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3Rr LmNwcDoKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGVjaWRl UG9saWN5Rm9yTmF2aWdhdGlvbkFjdGlvbik6CisgICAgICAgICogd2Via2l0L3dlYmtpdG5ldHdv cmtyZXF1ZXN0LmNwcDoKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6Ondl YmtpdF9uZXR3b3JrX3JlcXVlc3RfY2xhc3NfaW5pdCk6CisgICAgICAgIChfV2ViS2l0TmV0d29y a1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2NvcmVfcmVx dWVzdCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X2dldF9jb3JlX3JlcXVlc3QpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtS ZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXcpOgorICAgICAgICAoX1dl YktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJp KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfZ2V0X3VyaSk6CisgICAgICAgICogd2Via2l0L3dlYmtpdHByaXZhdGUuaDoKKyAg ICAgICAgKiB3ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwOgorCiAyMDA5LTAxLTEzICBBbGV4YW5k ZXIgVi4gQnV0ZW5rbyAgPGFsZXhAZGlnaXF1YmUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5 IEhvbGdlciBGcmV5dGhlci4KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwIGIvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudEd0ay5jcHAKaW5kZXggMWI0MTBjNy4uNjg0ZWUwYyAxMDA2NDQKLS0tIGEv V2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAKKysrIGIv V2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAKQEAgLTUw LDYgKzUwLDcgQEAKICNpbmNsdWRlICJ3ZWJraXR3ZWJmcmFtZS5oIgogI2luY2x1ZGUgIndlYmtp dHdlYm5hdmlnYXRpb25hY3Rpb24uaCIKICNpbmNsdWRlICJ3ZWJraXR3ZWJwb2xpY3lkZWNpc2lv bi5oIgorI2luY2x1ZGUgIndlYmtpdG5ldHdvcmtyZXF1ZXN0LmgiCiAjaW5jbHVkZSAid2Via2l0 cHJpdmF0ZS5oIgogCiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvQVBJQ2FzdC5oPgpAQCAtMzA3 LDcgKzMwOCw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGVjaWRlUG9saWN5 Rm9yTmF2aWdhdGlvbkFjdGlvbihGcmFtZVBvbGljeUZ1bmN0CiAgICAgICAgIHJldHVybjsKIAog ICAgIFdlYktpdFdlYlZpZXcqIHdlYlZpZXcgPSBnZXRWaWV3RnJvbUZyYW1lKG1fZnJhbWUpOwot ICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVz dF9uZXcocmVzb3VyY2VSZXF1ZXN0LnVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworICAg IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9u ZXdfd2l0aF9jb3JlX3JlcXVlc3QocmVzb3VyY2VSZXF1ZXN0KTsKICAgICBXZWJLaXROYXZpZ2F0 aW9uUmVzcG9uc2UgcmVzcG9uc2U7CiAgICAgLyoKICAgICAgKiBXZSBzdGlsbCBzdXBwb3J0IHRo ZSBkZXByZWNhdGVkIG5hdmlnYXRpb24tcmVxdWVzdGVkIHNpZ25hbCwgaWYgdGhlCmRpZmYgLS1n aXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAgYi9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKaW5kZXggM2FkOGI1ZC4uMmI0Mjdj MCAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3Bw CisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcApAQCAtMSw1 ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDcsIDIwMDggSG9sZ2VyIEhhbnMgUGV0 ZXIgRnJleXRoZXIKKyAqIENvcHlyaWdodCAoQykgMjAwOCBHdXN0YXZvIE5vcm9uaGEgU2lsdmEK ICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1 dGUgaXQgYW5kL29yCiAgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGli cmFyeSBHZW5lcmFsIFB1YmxpYwpAQCAtMjAsNiArMjEsMTEgQEAKICNpbmNsdWRlICJjb25maWcu aCIKIAogI2luY2x1ZGUgIndlYmtpdG5ldHdvcmtyZXF1ZXN0LmgiCisjaW5jbHVkZSAid2Via2l0 cHJpdmF0ZS5oIgorCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlICJSZXNv dXJjZVJlcXVlc3QuaCIKKyNpbmNsdWRlICJDU3RyaW5nLmgiCiAKIC8qKgogICogU0VDVElPTjp3 ZWJraXRuZXR3b3JrcmVxdWVzdApAQCAtMzQsMTIgKzQwLDE2IEBACiAgKgogICovCiAKK3VzaW5n IG5hbWVzcGFjZSBXZWJDb3JlOworCiBleHRlcm4gIkMiIHsKIAogR19ERUZJTkVfVFlQRShXZWJL aXROZXR3b3JrUmVxdWVzdCwgd2Via2l0X25ldHdvcmtfcmVxdWVzdCwgR19UWVBFX09CSkVDVCk7 CiAKIHN0cnVjdCBfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlIHsKICAgICBnY2hhciogdXJp OworCisgICAgUmVzb3VyY2VSZXF1ZXN0IHJlcXVlc3Q7CiB9OwogCiAjZGVmaW5lIFdFQktJVF9O RVRXT1JLX1JFUVVFU1RfR0VUX1BSSVZBVEUob2JqKSAoR19UWVBFX0lOU1RBTkNFX0dFVF9QUklW QVRFKChvYmopLCBXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIFdlYktpdE5ldHdvcmtSZXF1 ZXN0UHJpdmF0ZSkpCkBAIC01Niw3ICs2Niw5IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfZmluYWxpemUoR09iamVjdCogb2JqZWN0KQogCiBzdGF0aWMgdm9pZCB3ZWJraXRf bmV0d29ya19yZXF1ZXN0X2NsYXNzX2luaXQoV2ViS2l0TmV0d29ya1JlcXVlc3RDbGFzcyogcmVx dWVzdENsYXNzKQogewotICAgIEdfT0JKRUNUX0NMQVNTKHJlcXVlc3RDbGFzcyktPmZpbmFsaXpl ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9maW5hbGl6ZTsKKyAgICBHT2JqZWN0Q2xhc3MqIG9i amVjdENsYXNzID0gR19PQkpFQ1RfQ0xBU1MocmVxdWVzdENsYXNzKTsKKworICAgIG9iamVjdENs YXNzLT5maW5hbGl6ZSA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZmluYWxpemU7CiAKICAgICBn X3R5cGVfY2xhc3NfYWRkX3ByaXZhdGUocmVxdWVzdENsYXNzLCBzaXplb2YoV2ViS2l0TmV0d29y a1JlcXVlc3RQcml2YXRlKSk7CiB9CkBAIC02NywxOCArNzksNTEgQEAgc3RhdGljIHZvaWQgd2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9pbml0KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQog ICAgIHJlcXVlc3QtPnByaXYgPSBwcml2OwogfQogCisvLyBmb3IgaW50ZXJuYWwgdXNlIG9ubHkK K1dlYktpdE5ldHdvcmtSZXF1ZXN0KiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2Nv cmVfcmVxdWVzdChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVz dCkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IFdFQktJVF9ORVRXT1JL X1JFUVVFU1QoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX05FVFdPUktfUkVRVUVTVCwgTlVMTCkp OworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7 CisKKyAgICBwcml2LT5yZXF1ZXN0ID0gcmVzb3VyY2VSZXF1ZXN0OworCisgICAgcmV0dXJuIHJl cXVlc3Q7Cit9CisKKy8vIGZvciBpbnRlcm5hbCB1c2Ugb25seQorUmVzb3VyY2VSZXF1ZXN0IHdl YmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2NvcmVfcmVxdWVzdChjb25zdCBXZWJLaXROZXR3b3Jr UmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHBy aXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgcmV0dXJuIHByaXYtPnJlcXVlc3Q7Cit9CisKKy8q KgorICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXc6CisgKiBAdXJpOiBhbiBVUkkKKyAqCisg KiBDcmVhdGVzIGEgbmV3ICNXZWJLaXROZXR3b3JrUmVxdWVzdCBpbml0aWFsaXplZCB3aXRoIGFu IFVSSS4KKyAqCisgKiBSZXR1cm5zOiBhIG5ldyAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqLwog V2ViS2l0TmV0d29ya1JlcXVlc3QqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3KGNvbnN0IGdj aGFyKiB1cmkpCiB7CiAgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwodXJpLCBOVUxMKTsKIAotICAg IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gV0VCS0lUX05FVFdPUktfUkVRVUVTVChn X29iamVjdF9uZXcoV0VCS0lUX1RZUEVfTkVUV09SS19SRVFVRVNULCBOVUxMKSk7Ci0gICAgV2Vi S2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKyAgICBSZXNv dXJjZVJlcXVlc3QgcmVzb3VyY2VSZXF1ZXN0ID0gUmVzb3VyY2VSZXF1ZXN0KEtVUkwoU3RyaW5n Ojpmcm9tVVRGOCh1cmkpKSk7CiAKLSAgICBwcml2LT51cmkgPSBnX3N0cmR1cCh1cmkpOworICAg IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9u ZXdfd2l0aF9jb3JlX3JlcXVlc3QocmVzb3VyY2VSZXF1ZXN0KTsKIAogICAgIHJldHVybiByZXF1 ZXN0OwogfQogCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaToKKyAqIEBy ZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICogQHVyaTogYW4gVVJJCisgKgorICog U2V0cyB0aGUgVVJJIGhlbGQgYW5kIHVzZWQgYnkgdGhlIGdpdmVuIHJlcXVlc3QuCisgKi8KIHZv aWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiBy ZXF1ZXN0LCBjb25zdCBnY2hhciogdXJpKQogewogICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lU X0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CkBAIC04NywyMiArMTMyLDMxIEBAIHZvaWQg d2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1 ZXN0LCBjb25zdCBnY2hhcioKICAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYg PSByZXF1ZXN0LT5wcml2OwogCiAgICAgZ19mcmVlKHByaXYtPnVyaSk7Ci0gICAgcHJpdi0+dXJp ID0gZ19zdHJkdXAodXJpKTsKKyAgICBwcml2LT5yZXF1ZXN0LnNldFVSTChLVVJMKFN0cmluZzo6 ZnJvbVVURjgodXJpKSkpOwogfQogCiAvKioKICAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0 X3VyaToKICAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAogICoKKyAqIEdldHMg dGhlIFVSSSBoZWxkIGFuZCB1c2VkIGJ5IHRoZSBnaXZlbiByZXF1ZXN0LgorICoKICAqIFJldHVy bnM6IHRoZSB1cmkgb2YgdGhlICNXZWJLaXROZXR3b3JrUmVxdWVzdAogICoKICAqIFNpbmNlOiAx LjAuMAorICoKKyAqIFJldHVybnM6IHRoZSBVUkkgaGVsZCBhbmQgdXNlZCBieSB0aGUgZ2l2ZW4g cmVxdWVzdAogICovCiBHX0NPTlNUX1JFVFVSTiBnY2hhciogd2Via2l0X25ldHdvcmtfcmVxdWVz dF9nZXRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQogewogICAgIGdfcmV0dXJu X3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOwog CiAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsK KworICAgIGlmIChwcml2LT51cmkpCisgICAgICAgIHJldHVybiBwcml2LT51cmk7CisKKyAgICBw cml2LT51cmkgPSBnX3N0cmR1cChwcml2LT5yZXF1ZXN0LnVybCgpLnN0cmluZygpLnV0ZjgoKS5k YXRhKCkpOwogICAgIHJldHVybiBwcml2LT51cmk7CiB9CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZh dGUuaAppbmRleCBhY2U5OTZkLi4zZWQ2Y2YxIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRwcml2YXRlLmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5o CkBAIC0yMyw3ICsyMyw4IEBACiAjZGVmaW5lIFdFQktJVF9QUklWQVRFX0gKIAogLyoKLSAqIFRo aXMgZmlsZSBrbm93cyB0aGUgc2hhcmVkIHNlY3JldCBvZiBXZWJLaXRXZWJWaWV3IGFuZCBXZWJL aXRXZWJGcmFtZS4KKyAqIFRoaXMgZmlsZSBrbm93cyB0aGUgc2hhcmVkIHNlY3JldCBvZiBXZWJL aXRXZWJWaWV3LCBXZWJLaXRXZWJGcmFtZSwKKyAqIGFuZCBXZWJLaXROZXR3b3JrUmVxdWVzdC4K ICAqIFRoZXkgYXJlIHVzaW5nIFdlYkNvcmUgd2hpY2ggbXVzbid0IGJlIGV4cG9zZWQgdG8gdGhl IG91dGVyIHdvcmxkLgogICovCiAKQEAgLTM1LDYgKzM2LDcgQEAKICNpbmNsdWRlIDx3ZWJraXQv d2Via2l0d2Vic2V0dGluZ3MuaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2Vid2luZG93ZmVh dHVyZXMuaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2ViYmFja2ZvcndhcmRsaXN0Lmg+Cisj aW5jbHVkZSA8d2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0Lmg+CiAKICNpbmNsdWRlICJCYWNr Rm9yd2FyZExpc3QuaCIKICNpbmNsdWRlICJIaXN0b3J5SXRlbS5oIgpAQCAtNDMsNiArNDUsNyBA QAogI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAiSW5zcGVjdG9yQ2xpZW50R3RrLmgiCiAj aW5jbHVkZSAiRnJhbWVMb2FkZXJDbGllbnQuaCIKKyNpbmNsdWRlICJSZXNvdXJjZVJlcXVlc3Qu aCIKICNpbmNsdWRlICJXaW5kb3dGZWF0dXJlcy5oIgogCiAjaW5jbHVkZSA8Z2xpYi5oPgpAQCAt MTQ0LDYgKzE0NywxMiBAQCBleHRlcm4gIkMiIHsKICAgICB2b2lkCiAgICAgd2Via2l0X3dlYl9w b2xpY3lfZGVjaXNpb25fY2FuY2VsIChXZWJLaXRXZWJQb2xpY3lEZWNpc2lvbiogZGVjaXNpb24p OwogCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqCisgICAgd2Via2l0X25ldHdvcmtfcmVxdWVz dF9uZXdfd2l0aF9jb3JlX3JlcXVlc3QoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiBy ZXNvdXJjZVJlcXVlc3QpOworCisgICAgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0CisgICAgd2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfY29yZV9yZXF1ZXN0KGNvbnN0IFdlYktpdE5ldHdvcmtS ZXF1ZXN0KiByZXF1ZXN0KTsKKwogICAgIC8vIEZJWE1FOiBNb3ZlIHRoZXNlIHRvIHdlYmtpdHdl YmZyYW1lLmggb25jZSB0aGVpciBBUEkgaGFzIGJlZW4gZGlzY3Vzc2VkLgogCiAgICAgV0VCS0lU X0FQSSBHU0xpc3QqCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFt ZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKaW5kZXggMzhlMjNh NC4uYTZkZDc2ZiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUu Y3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcApAQCAtMzkyLDkg KzM5Miw3IEBAIHZvaWQgd2Via2l0X3dlYl9mcmFtZV9sb2FkX3JlcXVlc3QoV2ViS2l0V2ViRnJh bWUqIGZyYW1lLCBXZWJLaXROZXR3b3JrUmVxdWVzdCoKICAgICBpZiAoIWNvcmVGcmFtZSkKICAg ICAgICAgcmV0dXJuOwogCi0gICAgLy8gVE9ETzogVXNlIHRoZSBSZXNvdXJjZVJlcXVlc3QgY2Fy cmllZCBieSBXZWJLaXROZXR3b3JrUmVxdWVzdCB3aGVuIGl0IGlzIGltcGxlbWVudGVkLgotICAg IFN0cmluZyBzdHJpbmcgPSBTdHJpbmc6OmZyb21VVEY4KHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf Z2V0X3VyaShyZXF1ZXN0KSk7Ci0gICAgY29yZUZyYW1lLT5sb2FkZXIoKS0+bG9hZChSZXNvdXJj ZVJlcXVlc3QoS1VSTChzdHJpbmcpKSk7CisgICAgY29yZUZyYW1lLT5sb2FkZXIoKS0+bG9hZCh3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9jb3JlX3JlcXVlc3QocmVxdWVzdCkpOwogfQogCiAv KioKLS0gCjEuNS42LjUKCg== 26759 2009-01-15 09:02:21 -0800 2009-01-22 11:12:46 -0800 Minimal functionality addition patch 0001-network-request-minimal-functionality.patch text/plain 9406 gustavo RnJvbSAzMjEzNTkzNzYzNDMxNWI0OTNlNmVjNjg0NjUxZGExNzg3OTVjNGQ3IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGtvdkBrb3YuZXRpLmJy PgpEYXRlOiBUaHUsIDE1IEphbiAyMDA5IDExOjI4OjM0IC0wMjAwClN1YmplY3Q6IFtQQVRDSF0g bmV0d29yayByZXF1ZXN0IG1pbmltYWwgZnVuY3Rpb25hbGl0eQoKLS0tCiBXZWJLaXQvZ3RrL0No YW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjUgKysrKysrKysKIFdl YktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwIHwgICAgMyAr LQogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwICAgICAgICAgfCAg IDYzICsrKysrKysrKysrKysrKysrKy0tCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRl LmggICAgICAgICAgICAgICAgICB8ICAgMTEgKysrLQogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 d2ViZnJhbWUuY3BwICAgICAgICAgICAgICAgfCAgICA0ICstCiA1IGZpbGVzIGNoYW5nZWQsIDk2 IGluc2VydGlvbnMoKyksIDEwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsv Q2hhbmdlTG9nIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKaW5kZXggN2I5NTRmNi4uZmYwNmU4ZiAx MDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2d0ay9DaGFuZ2VM b2cKQEAgLTEsMyArMSwyOCBAQAorMjAwOS0wMS0xNSAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8 Z25zQGdub21lLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBSZWZlcnMgdG8gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE4NjA4CisgICAgICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0IG5lZWRzIHRvIGJlIGZpbmlzaGVk CisKKyAgICAgICAgVGhpcyBjaGFuZ2VzZXQgaXMgY29uY2VybmVkIHdpdGggbWFraW5nIFdlYktp dE5ldHdvcmtSZXF1ZXN0IGNhcnJ5CisgICAgICAgIFJlc291cmNlUmVxdWVzdCBpbiBhZGRpdGlv biB0byBzaW1wbHkgc3RvcmluZyB0aGUgVVJJLCB3aGljaAorICAgICAgICBhbGxvd3MgdXMgdG8g Z2V0IHRoZSBmdWxsIGluZm9ybWF0aW9uIGZlZCBiYWNrIGludG8gV2ViS2l0IHdoZW4KKyAgICAg ICAgbmVlZGVkLiBGcmFtZUxvYWRlckNsaWVudEd0ayBpcyBub3cgdXNpbmcgV2ViS2l0TmV0d29y a1JlcXVlc3QKKyAgICAgICAgd2hlbiBpdCBuZWVkcyB0byBkZWFsIHdpdGggcmVxdWVzdCBpbmZv cm1hdGlvbi4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3Rr LmNwcDoKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGVjaWRl UG9saWN5Rm9yTmF2aWdhdGlvbkFjdGlvbik6CisgICAgICAgICogd2Via2l0L3dlYmtpdG5ldHdv cmtyZXF1ZXN0LmNwcDoKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6Ondl YmtpdF9uZXR3b3JrX3JlcXVlc3RfY2xhc3NfaW5pdCk6CisgICAgICAgIChfV2ViS2l0TmV0d29y a1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2NvcmVfcmVx dWVzdCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X2dldF9jb3JlX3JlcXVlc3QpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtS ZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXcpOgorICAgICAgICAoX1dl YktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJp KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfZ2V0X3VyaSk6CisgICAgICAgICogd2Via2l0L3dlYmtpdHByaXZhdGUuaDoKKyAg ICAgICAgKiB3ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwOgorCiAyMDA5LTAxLTEzICBBbGV4YW5k ZXIgVi4gQnV0ZW5rbyAgPGFsZXhAZGlnaXF1YmUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5 IEhvbGdlciBGcmV5dGhlci4KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwIGIvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudEd0ay5jcHAKaW5kZXggMWI0MTBjNy4uNjg0ZWUwYyAxMDA2NDQKLS0tIGEv V2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAKKysrIGIv V2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAKQEAgLTUw LDYgKzUwLDcgQEAKICNpbmNsdWRlICJ3ZWJraXR3ZWJmcmFtZS5oIgogI2luY2x1ZGUgIndlYmtp dHdlYm5hdmlnYXRpb25hY3Rpb24uaCIKICNpbmNsdWRlICJ3ZWJraXR3ZWJwb2xpY3lkZWNpc2lv bi5oIgorI2luY2x1ZGUgIndlYmtpdG5ldHdvcmtyZXF1ZXN0LmgiCiAjaW5jbHVkZSAid2Via2l0 cHJpdmF0ZS5oIgogCiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvQVBJQ2FzdC5oPgpAQCAtMzA3 LDcgKzMwOCw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGVjaWRlUG9saWN5 Rm9yTmF2aWdhdGlvbkFjdGlvbihGcmFtZVBvbGljeUZ1bmN0CiAgICAgICAgIHJldHVybjsKIAog ICAgIFdlYktpdFdlYlZpZXcqIHdlYlZpZXcgPSBnZXRWaWV3RnJvbUZyYW1lKG1fZnJhbWUpOwot ICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVz dF9uZXcocmVzb3VyY2VSZXF1ZXN0LnVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworICAg IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9u ZXdfd2l0aF9jb3JlX3JlcXVlc3QocmVzb3VyY2VSZXF1ZXN0KTsKICAgICBXZWJLaXROYXZpZ2F0 aW9uUmVzcG9uc2UgcmVzcG9uc2U7CiAgICAgLyoKICAgICAgKiBXZSBzdGlsbCBzdXBwb3J0IHRo ZSBkZXByZWNhdGVkIG5hdmlnYXRpb24tcmVxdWVzdGVkIHNpZ25hbCwgaWYgdGhlCmRpZmYgLS1n aXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAgYi9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKaW5kZXggM2FkOGI1ZC4uNWZjZjI5 YiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3Bw CisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcApAQCAtMSw1 ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDcsIDIwMDggSG9sZ2VyIEhhbnMgUGV0 ZXIgRnJleXRoZXIKKyAqIENvcHlyaWdodCAoQykgMjAwOCBHdXN0YXZvIE5vcm9uaGEgU2lsdmEK ICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1 dGUgaXQgYW5kL29yCiAgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGli cmFyeSBHZW5lcmFsIFB1YmxpYwpAQCAtMjAsNiArMjEsMTEgQEAKICNpbmNsdWRlICJjb25maWcu aCIKIAogI2luY2x1ZGUgIndlYmtpdG5ldHdvcmtyZXF1ZXN0LmgiCisjaW5jbHVkZSAid2Via2l0 cHJpdmF0ZS5oIgorCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlICJSZXNv dXJjZVJlcXVlc3QuaCIKKyNpbmNsdWRlICJDU3RyaW5nLmgiCiAKIC8qKgogICogU0VDVElPTjp3 ZWJraXRuZXR3b3JrcmVxdWVzdApAQCAtMzQsMTIgKzQwLDE2IEBACiAgKgogICovCiAKK3VzaW5n IG5hbWVzcGFjZSBXZWJDb3JlOworCiBleHRlcm4gIkMiIHsKIAogR19ERUZJTkVfVFlQRShXZWJL aXROZXR3b3JrUmVxdWVzdCwgd2Via2l0X25ldHdvcmtfcmVxdWVzdCwgR19UWVBFX09CSkVDVCk7 CiAKIHN0cnVjdCBfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlIHsKICAgICBnY2hhciogdXJp OworCisgICAgUmVzb3VyY2VSZXF1ZXN0IHJlcXVlc3Q7CiB9OwogCiAjZGVmaW5lIFdFQktJVF9O RVRXT1JLX1JFUVVFU1RfR0VUX1BSSVZBVEUob2JqKSAoR19UWVBFX0lOU1RBTkNFX0dFVF9QUklW QVRFKChvYmopLCBXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIFdlYktpdE5ldHdvcmtSZXF1 ZXN0UHJpdmF0ZSkpCkBAIC01Niw3ICs2Niw5IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfZmluYWxpemUoR09iamVjdCogb2JqZWN0KQogCiBzdGF0aWMgdm9pZCB3ZWJraXRf bmV0d29ya19yZXF1ZXN0X2NsYXNzX2luaXQoV2ViS2l0TmV0d29ya1JlcXVlc3RDbGFzcyogcmVx dWVzdENsYXNzKQogewotICAgIEdfT0JKRUNUX0NMQVNTKHJlcXVlc3RDbGFzcyktPmZpbmFsaXpl ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9maW5hbGl6ZTsKKyAgICBHT2JqZWN0Q2xhc3MqIG9i amVjdENsYXNzID0gR19PQkpFQ1RfQ0xBU1MocmVxdWVzdENsYXNzKTsKKworICAgIG9iamVjdENs YXNzLT5maW5hbGl6ZSA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZmluYWxpemU7CiAKICAgICBn X3R5cGVfY2xhc3NfYWRkX3ByaXZhdGUocmVxdWVzdENsYXNzLCBzaXplb2YoV2ViS2l0TmV0d29y a1JlcXVlc3RQcml2YXRlKSk7CiB9CkBAIC02NywxOCArNzksNTEgQEAgc3RhdGljIHZvaWQgd2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9pbml0KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQog ICAgIHJlcXVlc3QtPnByaXYgPSBwcml2OwogfQogCisvLyBmb3IgaW50ZXJuYWwgdXNlIG9ubHkK K1dlYktpdE5ldHdvcmtSZXF1ZXN0KiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2Nv cmVfcmVxdWVzdChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVz dCkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IFdFQktJVF9ORVRXT1JL X1JFUVVFU1QoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX05FVFdPUktfUkVRVUVTVCwgTlVMTCkp OworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7 CisKKyAgICBwcml2LT5yZXF1ZXN0ID0gcmVzb3VyY2VSZXF1ZXN0OworCisgICAgcmV0dXJuIHJl cXVlc3Q7Cit9CisKKy8vIGZvciBpbnRlcm5hbCB1c2Ugb25seQorUmVzb3VyY2VSZXF1ZXN0IHdl YmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2NvcmVfcmVxdWVzdChjb25zdCBXZWJLaXROZXR3b3Jr UmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHBy aXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgcmV0dXJuIHByaXYtPnJlcXVlc3Q7Cit9CisKKy8q KgorICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXc6CisgKiBAdXJpOiBhbiBVUkkKKyAqCisg KiBDcmVhdGVzIGEgbmV3ICNXZWJLaXROZXR3b3JrUmVxdWVzdCBpbml0aWFsaXplZCB3aXRoIGFu IFVSSS4KKyAqCisgKiBSZXR1cm5zOiBhIG5ldyAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqLwog V2ViS2l0TmV0d29ya1JlcXVlc3QqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3KGNvbnN0IGdj aGFyKiB1cmkpCiB7CiAgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwodXJpLCBOVUxMKTsKIAotICAg IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gV0VCS0lUX05FVFdPUktfUkVRVUVTVChn X29iamVjdF9uZXcoV0VCS0lUX1RZUEVfTkVUV09SS19SRVFVRVNULCBOVUxMKSk7Ci0gICAgV2Vi S2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKyAgICBSZXNv dXJjZVJlcXVlc3QgcmVzb3VyY2VSZXF1ZXN0ID0gUmVzb3VyY2VSZXF1ZXN0KEtVUkwoU3RyaW5n Ojpmcm9tVVRGOCh1cmkpKSk7CiAKLSAgICBwcml2LT51cmkgPSBnX3N0cmR1cCh1cmkpOworICAg IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9u ZXdfd2l0aF9jb3JlX3JlcXVlc3QocmVzb3VyY2VSZXF1ZXN0KTsKIAogICAgIHJldHVybiByZXF1 ZXN0OwogfQogCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaToKKyAqIEBy ZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICogQHVyaTogYW4gVVJJCisgKgorICog U2V0cyB0aGUgVVJJIGhlbGQgYW5kIHVzZWQgYnkgdGhlIGdpdmVuIHJlcXVlc3QuCisgKi8KIHZv aWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiBy ZXF1ZXN0LCBjb25zdCBnY2hhciogdXJpKQogewogICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lU X0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CkBAIC04NywyMiArMTMyLDMwIEBAIHZvaWQg d2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1 ZXN0LCBjb25zdCBnY2hhcioKICAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYg PSByZXF1ZXN0LT5wcml2OwogCiAgICAgZ19mcmVlKHByaXYtPnVyaSk7Ci0gICAgcHJpdi0+dXJp ID0gZ19zdHJkdXAodXJpKTsKKyAgICBwcml2LT5yZXF1ZXN0LnNldFVSTChLVVJMKFN0cmluZzo6 ZnJvbVVURjgodXJpKSkpOwogfQogCiAvKioKICAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0 X3VyaToKICAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAogICoKKyAqIEdldHMg dGhlIFVSSSBoZWxkIGFuZCB1c2VkIGJ5IHRoZSBnaXZlbiByZXF1ZXN0LgorICoKICAqIFJldHVy bnM6IHRoZSB1cmkgb2YgdGhlICNXZWJLaXROZXR3b3JrUmVxdWVzdAogICoKICAqIFNpbmNlOiAx LjAuMAorICoKKyAqIFJldHVybnM6IHRoZSBVUkkgaGVsZCBhbmQgdXNlZCBieSB0aGUgZ2l2ZW4g cmVxdWVzdAogICovCiBHX0NPTlNUX1JFVFVSTiBnY2hhciogd2Via2l0X25ldHdvcmtfcmVxdWVz dF9nZXRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQogewogICAgIGdfcmV0dXJu X3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOwog CiAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsK KworICAgIGlmIChwcml2LT51cmkgPT0gTlVMTCkKKyAgICAgICAgcHJpdi0+dXJpID0gZ19zdHJk dXAocHJpdi0+cmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKwogICAgIHJl dHVybiBwcml2LT51cmk7CiB9CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dHByaXZhdGUuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAppbmRleCBhY2U5 OTZkLi4zZWQ2Y2YxIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRl LmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCkBAIC0yMyw3ICsyMyw4 IEBACiAjZGVmaW5lIFdFQktJVF9QUklWQVRFX0gKIAogLyoKLSAqIFRoaXMgZmlsZSBrbm93cyB0 aGUgc2hhcmVkIHNlY3JldCBvZiBXZWJLaXRXZWJWaWV3IGFuZCBXZWJLaXRXZWJGcmFtZS4KKyAq IFRoaXMgZmlsZSBrbm93cyB0aGUgc2hhcmVkIHNlY3JldCBvZiBXZWJLaXRXZWJWaWV3LCBXZWJL aXRXZWJGcmFtZSwKKyAqIGFuZCBXZWJLaXROZXR3b3JrUmVxdWVzdC4KICAqIFRoZXkgYXJlIHVz aW5nIFdlYkNvcmUgd2hpY2ggbXVzbid0IGJlIGV4cG9zZWQgdG8gdGhlIG91dGVyIHdvcmxkLgog ICovCiAKQEAgLTM1LDYgKzM2LDcgQEAKICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2Vic2V0dGlu Z3MuaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2Vid2luZG93ZmVhdHVyZXMuaD4KICNpbmNs dWRlIDx3ZWJraXQvd2Via2l0d2ViYmFja2ZvcndhcmRsaXN0Lmg+CisjaW5jbHVkZSA8d2Via2l0 L3dlYmtpdG5ldHdvcmtyZXF1ZXN0Lmg+CiAKICNpbmNsdWRlICJCYWNrRm9yd2FyZExpc3QuaCIK ICNpbmNsdWRlICJIaXN0b3J5SXRlbS5oIgpAQCAtNDMsNiArNDUsNyBAQAogI2luY2x1ZGUgIkZy YW1lLmgiCiAjaW5jbHVkZSAiSW5zcGVjdG9yQ2xpZW50R3RrLmgiCiAjaW5jbHVkZSAiRnJhbWVM b2FkZXJDbGllbnQuaCIKKyNpbmNsdWRlICJSZXNvdXJjZVJlcXVlc3QuaCIKICNpbmNsdWRlICJX aW5kb3dGZWF0dXJlcy5oIgogCiAjaW5jbHVkZSA8Z2xpYi5oPgpAQCAtMTQ0LDYgKzE0NywxMiBA QCBleHRlcm4gIkMiIHsKICAgICB2b2lkCiAgICAgd2Via2l0X3dlYl9wb2xpY3lfZGVjaXNpb25f Y2FuY2VsIChXZWJLaXRXZWJQb2xpY3lEZWNpc2lvbiogZGVjaXNpb24pOwogCisgICAgV2ViS2l0 TmV0d29ya1JlcXVlc3QqCisgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3Jl X3JlcXVlc3QoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3Qp OworCisgICAgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0CisgICAgd2Via2l0X25ldHdvcmtfcmVx dWVzdF9nZXRfY29yZV9yZXF1ZXN0KGNvbnN0IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0 KTsKKwogICAgIC8vIEZJWE1FOiBNb3ZlIHRoZXNlIHRvIHdlYmtpdHdlYmZyYW1lLmggb25jZSB0 aGVpciBBUEkgaGFzIGJlZW4gZGlzY3Vzc2VkLgogCiAgICAgV0VCS0lUX0FQSSBHU0xpc3QqCmRp ZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAgYi9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKaW5kZXggMzhlMjNhNC4uYTZkZDc2ZiAxMDA2 NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCisrKyBiL1dlYktp dC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcApAQCAtMzkyLDkgKzM5Miw3IEBAIHZvaWQg d2Via2l0X3dlYl9mcmFtZV9sb2FkX3JlcXVlc3QoV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBXZWJL aXROZXR3b3JrUmVxdWVzdCoKICAgICBpZiAoIWNvcmVGcmFtZSkKICAgICAgICAgcmV0dXJuOwog Ci0gICAgLy8gVE9ETzogVXNlIHRoZSBSZXNvdXJjZVJlcXVlc3QgY2FycmllZCBieSBXZWJLaXRO ZXR3b3JrUmVxdWVzdCB3aGVuIGl0IGlzIGltcGxlbWVudGVkLgotICAgIFN0cmluZyBzdHJpbmcg PSBTdHJpbmc6OmZyb21VVEY4KHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShyZXF1ZXN0 KSk7Ci0gICAgY29yZUZyYW1lLT5sb2FkZXIoKS0+bG9hZChSZXNvdXJjZVJlcXVlc3QoS1VSTChz dHJpbmcpKSk7CisgICAgY29yZUZyYW1lLT5sb2FkZXIoKS0+bG9hZCh3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X2dldF9jb3JlX3JlcXVlc3QocmVxdWVzdCkpOwogfQogCiAvKioKLS0gCjEuNS42LjUK Cg== 26912 2009-01-21 16:01:29 -0800 2009-01-22 12:06:53 -0800 proof of concept, so that we can discuss exposing SoupMessage 0001-expose-SoupMessage-in-NetworkRequest.patch text/plain 13589 gustavo RnJvbSBmMWMzNGEzYzU4YzU2ZWNjOTcxZjg3MjNkNDVhMTY1ZjAwMjNhMTEzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGtvdkBrb3YuZXRpLmJy PgpEYXRlOiBXZWQsIDIxIEphbiAyMDA5IDIxOjUyOjU5IC0wMjAwClN1YmplY3Q6IFtQQVRDSF0g ZXhwb3NlIFNvdXBNZXNzYWdlIGluIE5ldHdvcmtSZXF1ZXN0CgotLS0KIEdOVW1ha2VmaWxlLmFt ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgNiArLQogV2ViQ29yZS9H TlVtYWtlZmlsZS5hbSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIC4uLi9w bGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcCAgIHwgICAyNSArLS0t LS0KIFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdC5oICAgIHwg ICAyMSArKysrLQogLi4uL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3RTb3Vw LmNwcCAgfCAgIDk5ICsrKysrKysrKysrKysrKysrKysrCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXRuZXR3b3JrcmVxdWVzdC5jcHAgICAgICAgICB8ICAgMTkgKysrKwogV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0bmV0d29ya3JlcXVlc3QuaCAgICAgICAgICAgfCAgICA1ICsKIFdlYktpdFRvb2xz L0dOVW1ha2VmaWxlLmFtICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxMiArKy0KIFdlYktp dFRvb2xzL0d0a0xhdW5jaGVyL21haW4uYyAgICAgICAgICAgICAgICAgICAgIHwgICAxMyArKysK IDkgZmlsZXMgY2hhbmdlZCwgMTY5IGluc2VydGlvbnMoKyksIDMyIGRlbGV0aW9ucygtKQogY3Jl YXRlIG1vZGUgMTAwNjQ0IFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVx dWVzdFNvdXAuY3BwCgpkaWZmIC0tZ2l0IGEvR05VbWFrZWZpbGUuYW0gYi9HTlVtYWtlZmlsZS5h bQppbmRleCA3YWVjMDYxLi5kYjM0NjU0IDEwMDY0NAotLS0gYS9HTlVtYWtlZmlsZS5hbQorKysg Yi9HTlVtYWtlZmlsZS5hbQpAQCAtNDgxLDExICs0ODEsMTMgQEAgUHJvZ3JhbXNfVW5pdFRlc3Rz X0NGTEFHUyA9IFwKIAktTzIgXAogCSQoZ2xvYmFsX2NmbGFncykgXAogCSQoR0xJQl9DRkxBR1Mp IFwKLQkkKEdUS19DRkxBR1MpCisJJChHVEtfQ0ZMQUdTKSBcCisJJChMSUJTT1VQX0NGTEFHUykK IAogUHJvZ3JhbXNfVW5pdFRlc3RzX0xEQUREID0gXAogCWxpYndlYmtpdC0xLjAubGEgXAotCSQo R1RLX0xJQlMpCisJJChHVEtfTElCUykgXAorCSQoTElCU09VUF9MSUJTKQogCiAjIEF1dG9nZW5l cmF0ZWQgc291cmNlcwogQlVJTFRfU09VUkNFUyA6PSBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dO VW1ha2VmaWxlLmFtIGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCA3ODdjNGE0Li4yZDg0 NTY4IDEwMDY0NAotLS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05V bWFrZWZpbGUuYW0KQEAgLTE4MDAsNiArMTgwMCw3IEBAIHdlYmNvcmVfc291cmNlcyArPSBcCiAJ V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvRE5TU291cC5jcHAgXAogCVdlYkNvcmUvcGxh dGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlRXJyb3IuaCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcCBcCisJV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0U291cC5jcHAgXAogCVdlYkNvcmUvcGxhdGZvcm0v bmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdC5oIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdv cmsvc291cC9SZXNvdXJjZVJlc3BvbnNlLmgKIGVuZGlmCmRpZmYgLS1naXQgYS9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwIGIvV2ViQ29yZS9wbGF0 Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcAppbmRleCBkYTk2ODczLi4y YWJlMGU4IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJj ZUhhbmRsZVNvdXAuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlSGFuZGxlU291cC5jcHAKQEAgLTI5OSwzNSArMjk5LDEyIEBAIGJvb2wgUmVzb3VyY2VIYW5k bGU6OnN0YXJ0SHR0cChTdHJpbmcgdXJsU3RyaW5nKQogICAgICAgICB9CiAgICAgfQogCi0gICAg U291cE1lc3NhZ2UqIG1zZzsKLSAgICBtc2cgPSBzb3VwX21lc3NhZ2VfbmV3KHJlcXVlc3QoKS5o dHRwTWV0aG9kKCkudXRmOCgpLmRhdGEoKSwgdXJsU3RyaW5nLnV0ZjgoKS5kYXRhKCkpOworICAg IFNvdXBNZXNzYWdlKiBtc2cgPSByZXF1ZXN0KCkuc291cE1lc3NhZ2UoKTsKICAgICBnX3NpZ25h bF9jb25uZWN0KG1zZywgInJlc3RhcnRlZCIsIEdfQ0FMTEJBQ0socmVzdGFydGVkQ2FsbGJhY2sp LCB0aGlzKTsKIAogICAgIGdfc2lnbmFsX2Nvbm5lY3QobXNnLCAiZ290LWhlYWRlcnMiLCBHX0NB TExCQUNLKGdvdEhlYWRlcnNDYWxsYmFjayksIHRoaXMpOwogICAgIGdfc2lnbmFsX2Nvbm5lY3Qo bXNnLCAiZ290LWNodW5rIiwgR19DQUxMQkFDSyhnb3RDaHVua0NhbGxiYWNrKSwgdGhpcyk7CiAK LSAgICBIVFRQSGVhZGVyTWFwIGN1c3RvbUhlYWRlcnMgPSBkLT5tX3JlcXVlc3QuaHR0cEhlYWRl ckZpZWxkcygpOwotICAgIGlmICghY3VzdG9tSGVhZGVycy5pc0VtcHR5KCkpIHsKLSAgICAgICAg SFRUUEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgZW5kID0gY3VzdG9tSGVhZGVycy5lbmQoKTsK LSAgICAgICAgZm9yIChIVFRQSGVhZGVyTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IGN1c3RvbUhl YWRlcnMuYmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KQotICAgICAgICAgICAgc291cF9tZXNzYWdl X2hlYWRlcnNfYXBwZW5kKG1zZy0+cmVxdWVzdF9oZWFkZXJzLCBpdC0+Zmlyc3Quc3RyaW5nKCku dXRmOCgpLmRhdGEoKSwgaXQtPnNlY29uZC51dGY4KCkuZGF0YSgpKTsKLSAgICB9Ci0KLSAgICBG b3JtRGF0YSogaHR0cEJvZHkgPSBkLT5tX3JlcXVlc3QuaHR0cEJvZHkoKTsKLSAgICBpZiAoaHR0 cEJvZHkgJiYgIWh0dHBCb2R5LT5pc0VtcHR5KCkpIHsKLSAgICAgICAgLy8gTWFraW5nIGEgY29w eSBvZiB0aGUgcmVxdWVzdCBib2R5IGlzbid0IHRoZSBtb3N0IGVmZmljaWVudCB3YXkgdG8KLSAg ICAgICAgLy8gc2VyaWFsaXplIGl0LCBidXQgYnkgZmFyIHRoZSBtb3N0IHNpbXBsZS4gRGVhbGlu ZyB3aXRoIGluZGl2aWR1YWwKLSAgICAgICAgLy8gRm9ybURhdGEgZWxlbWVudHMgYW5kIHNoYXJl ZCBidWZmZXJzIHNob3VsZCBiZSBtb3JlIG1lbW9yeQotICAgICAgICAvLyBlZmZpY2llbnQuCi0g ICAgICAgIC8vCi0gICAgICAgIC8vIFRoaXMgcG9zc2libHkgaXNuJ3QgaGFuZGxpbmcgZmlsZSB1 cGxvYWRzL2F0dGFjaG1lbnRzLCBmb3Igd2hpY2gKLSAgICAgICAgLy8gc2hhcmVkIGJ1ZmZlcnMg b3Igc3RyZWFtaW5nIHNob3VsZCBkZWZpbml0ZWx5IGJlIHVzZWQuCi0gICAgICAgIFZlY3Rvcjxj aGFyPiBib2R5OwotICAgICAgICBodHRwQm9keS0+ZmxhdHRlbihib2R5KTsKLSAgICAgICAgc291 cF9tZXNzYWdlX3NldF9yZXF1ZXN0KG1zZywgZC0+bV9yZXF1ZXN0Lmh0dHBDb250ZW50VHlwZSgp LnV0ZjgoKS5kYXRhKCksCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTT1VQX01F TU9SWV9DT1BZLCBib2R5LmRhdGEoKSwgYm9keS5zaXplKCkpOwotICAgIH0KLQogICAgIGQtPm1f bXNnID0gc3RhdGljX2Nhc3Q8U291cE1lc3NhZ2UqPihnX29iamVjdF9yZWYobXNnKSk7CiAgICAg c291cF9zZXNzaW9uX3F1ZXVlX21lc3NhZ2Uoc2Vzc2lvbiwgZC0+bV9tc2csIGZpbmlzaGVkQ2Fs bGJhY2ssIHRoaXMpOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291 cC9SZXNvdXJjZVJlcXVlc3QuaCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlUmVxdWVzdC5oCmluZGV4IGVmYjEyNDAuLjE1MTk0MzIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdC5oCisrKyBiL1dlYkNvcmUvcGxh dGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdC5oCkBAIC0yNywzOCArMjcsNTUgQEAK ICNpZm5kZWYgUmVzb3VyY2VSZXF1ZXN0X2gKICNkZWZpbmUgUmVzb3VyY2VSZXF1ZXN0X2gKIAor CiAjaW5jbHVkZSAiUmVzb3VyY2VSZXF1ZXN0QmFzZS5oIgogCisjaW5jbHVkZSA8bGlic291cC9z b3VwLmg+CisjaW5jbHVkZSA8bGlic291cC9zb3VwLW1lc3NhZ2UuaD4KKwogbmFtZXNwYWNlIFdl YkNvcmUgewogCiAgICAgc3RydWN0IFJlc291cmNlUmVxdWVzdCA6IFJlc291cmNlUmVxdWVzdEJh c2UgewogCiAgICAgICAgIFJlc291cmNlUmVxdWVzdChjb25zdCBTdHJpbmcmIHVybCkKICAgICAg ICAgICAgIDogUmVzb3VyY2VSZXF1ZXN0QmFzZShLVVJMKHVybCksIFVzZVByb3RvY29sQ2FjaGVQ b2xpY3kpCisgICAgICAgICAgICAsIG1fc291cE1lc3NhZ2UoMCkKICAgICAgICAgewogICAgICAg ICB9CiAKICAgICAgICAgUmVzb3VyY2VSZXF1ZXN0KGNvbnN0IEtVUkwmIHVybCkKICAgICAgICAg ICAgIDogUmVzb3VyY2VSZXF1ZXN0QmFzZSh1cmwsIFVzZVByb3RvY29sQ2FjaGVQb2xpY3kpCisg ICAgICAgICAgICAsIG1fc291cE1lc3NhZ2UoMCkKICAgICAgICAgewogICAgICAgICB9CiAKICAg ICAgICAgUmVzb3VyY2VSZXF1ZXN0KGNvbnN0IEtVUkwmIHVybCwgY29uc3QgU3RyaW5nJiByZWZl cnJlciwgUmVzb3VyY2VSZXF1ZXN0Q2FjaGVQb2xpY3kgcG9saWN5ID0gVXNlUHJvdG9jb2xDYWNo ZVBvbGljeSkKICAgICAgICAgICAgIDogUmVzb3VyY2VSZXF1ZXN0QmFzZSh1cmwsIHBvbGljeSkK KyAgICAgICAgICAgICwgbV9zb3VwTWVzc2FnZSgwKQogICAgICAgICB7CiAgICAgICAgICAgICBz ZXRIVFRQUmVmZXJyZXIocmVmZXJyZXIpOwogICAgICAgICB9CiAKICAgICAgICAgUmVzb3VyY2VS ZXF1ZXN0KCkKICAgICAgICAgICAgIDogUmVzb3VyY2VSZXF1ZXN0QmFzZShLVVJMKCksIFVzZVBy b3RvY29sQ2FjaGVQb2xpY3kpCisgICAgICAgICAgICAsIG1fc291cE1lc3NhZ2UoMCkKKyAgICAg ICAgeworICAgICAgICB9CisKKyAgICAgICAgUmVzb3VyY2VSZXF1ZXN0KFNvdXBNZXNzYWdlKiBz b3VwTWVzc2FnZSkKKyAgICAgICAgICAgIDogUmVzb3VyY2VSZXF1ZXN0QmFzZSgpCisgICAgICAg ICAgICAsIG1fc291cE1lc3NhZ2Uoc291cE1lc3NhZ2UpCiAgICAgICAgIHsKICAgICAgICAgfQog CisgICAgICAgIFNvdXBNZXNzYWdlKiBzb3VwTWVzc2FnZSgpIGNvbnN0OworCiAgICAgcHJpdmF0 ZToKKyAgICAgICAgU291cE1lc3NhZ2UgKm1fc291cE1lc3NhZ2U7CiAgICAgICAgIGZyaWVuZCBj bGFzcyBSZXNvdXJjZVJlcXVlc3RCYXNlOwogCi0gICAgICAgIHZvaWQgZG9VcGRhdGVQbGF0Zm9y bVJlcXVlc3QoKSB7fQotICAgICAgICB2b2lkIGRvVXBkYXRlUmVzb3VyY2VSZXF1ZXN0KCkge30K KyAgICAgICAgdm9pZCBkb1VwZGF0ZVBsYXRmb3JtUmVxdWVzdCgpOworICAgICAgICB2b2lkIGRv VXBkYXRlUmVzb3VyY2VSZXF1ZXN0KCk7CiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1 ZXN0U291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVl c3RTb3VwLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44OTI4Yzc4Ci0t LSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VS ZXF1ZXN0U291cC5jcHAKQEAgLTAsMCArMSw5OSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAw OCBHdXN0YXZvIE5vcm9uaGEgU2lsdmEKKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFz IHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZl cnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVy c2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhh dCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91 dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdl bmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxk IGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExp Y2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5M SUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJ bmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjEx MC0xMzAxLCBVU0EuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAiQ1N0 cmluZy5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjaW5jbHVkZSAiUmVzb3VyY2VS ZXF1ZXN0LmgiCisKKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KKyNpbmNsdWRlIDxsaWJzb3Vw L3NvdXAtbWVzc2FnZS5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1NvdXBNZXNzYWdlKiBS ZXNvdXJjZVJlcXVlc3Q6OnNvdXBNZXNzYWdlKCkgY29uc3QKK3sKKyAgICB1cGRhdGVQbGF0Zm9y bVJlcXVlc3QoKTsKKworICAgIHJldHVybiBtX3NvdXBNZXNzYWdlOworfQorCit2b2lkIFJlc291 cmNlUmVxdWVzdDo6ZG9VcGRhdGVSZXNvdXJjZVJlcXVlc3QoKQoreworICAgIFNvdXBVUkkgKnNv dXBVUkkgPSBzb3VwX21lc3NhZ2VfZ2V0X3VyaShtX3NvdXBNZXNzYWdlKTsKKworICAgIGdjaGFy ICp1cmkgPSBzb3VwX3VyaV90b19zdHJpbmcoc291cFVSSSwgRkFMU0UpOworICAgIG1fdXJsID0g S1VSTChTdHJpbmc6OmZyb21VVEY4KHVyaSkpOworICAgIGdfZnJlZSh1cmkpOworCisgICAgbV9o dHRwTWV0aG9kID0gU3RyaW5nOjpmcm9tVVRGOChtX3NvdXBNZXNzYWdlLT5tZXRob2QpOworCisg ICAgU291cE1lc3NhZ2VIZWFkZXJzSXRlciBoZWFkZXJzSXRlcjsKKyAgICBnY2hhciAqaGVhZGVy TmFtZSA9IDA7CisgICAgZ2NoYXIgKmhlYWRlclZhbHVlID0gMDsKKworICAgIHNvdXBfbWVzc2Fn ZV9oZWFkZXJzX2l0ZXJfaW5pdCgmaGVhZGVyc0l0ZXIsIG1fc291cE1lc3NhZ2UtPnJlcXVlc3Rf aGVhZGVycyk7CisgICAgd2hpbGUgKHNvdXBfbWVzc2FnZV9oZWFkZXJzX2l0ZXJfbmV4dCgmaGVh ZGVyc0l0ZXIsIChjb25zdCBnY2hhcioqKSZoZWFkZXJOYW1lLCAoY29uc3QgZ2NoYXIqKikmaGVh ZGVyVmFsdWUpKSB7CisgICAgICAgIG1faHR0cEhlYWRlckZpZWxkcy5zZXQoU3RyaW5nOjpmcm9t VVRGOChoZWFkZXJOYW1lKSwgU3RyaW5nOjpmcm9tVVRGOChoZWFkZXJWYWx1ZSkpOworICAgIH0K KworICAgIG1faHR0cEJvZHkgPSBGb3JtRGF0YTo6Y3JlYXRlKG1fc291cE1lc3NhZ2UtPnJlcXVl c3RfYm9keS0+ZGF0YSwgbV9zb3VwTWVzc2FnZS0+cmVxdWVzdF9ib2R5LT5sZW5ndGgpOworfQor Cit2b2lkIFJlc291cmNlUmVxdWVzdDo6ZG9VcGRhdGVQbGF0Zm9ybVJlcXVlc3QoKQoreworICAg IGlmIChpc051bGwoKSkgeworICAgICAgICBpZiAobV9zb3VwTWVzc2FnZSkKKyAgICAgICAgICAg IGdfb2JqZWN0X3VucmVmKG1fc291cE1lc3NhZ2UpOworICAgICAgICBtX3NvdXBNZXNzYWdlID0g MDsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIC8vIHNvdXAgb25seSBhbGxvd3Mgc2V0 dGluZyBhIG1lc3NhZ2UncyBtZXRob2Qgb24gY3JlYXRpb24KKyAgICBpZiAoIW1fc291cE1lc3Nh Z2UgfHwgc3RyY21wKGh0dHBNZXRob2QoKS51dGY4KCkuZGF0YSgpLCBtX3NvdXBNZXNzYWdlLT5t ZXRob2QpKSB7CisgICAgICAgIGlmIChtX3NvdXBNZXNzYWdlKQorICAgICAgICAgICAgZ19vYmpl Y3RfdW5yZWYobV9zb3VwTWVzc2FnZSk7CisKKyAgICAgICAgbV9zb3VwTWVzc2FnZSA9IHNvdXBf bWVzc2FnZV9uZXcoaHR0cE1ldGhvZCgpLnV0ZjgoKS5kYXRhKCksIHVybCgpLnN0cmluZygpLnV0 ZjgoKS5kYXRhKCkpOworICAgIH0gZWxzZSB7CisgICAgICAgIFNvdXBVUkkgKnNvdXBVUkkgPSBz b3VwX3VyaV9uZXcodXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisgICAgICAgIHNvdXBf bWVzc2FnZV9zZXRfdXJpKG1fc291cE1lc3NhZ2UsIHNvdXBVUkkpOworICAgICAgICBzb3VwX21l c3NhZ2VfaGVhZGVyc19jbGVhcihtX3NvdXBNZXNzYWdlLT5yZXF1ZXN0X2hlYWRlcnMpOworICAg IH0KKworICAgIEhUVFBIZWFkZXJNYXAgaGVhZGVycyA9IGh0dHBIZWFkZXJGaWVsZHMoKTsKKyAg ICBTb3VwTWVzc2FnZUhlYWRlcnMgKnNvdXBIZWFkZXJzID0gbV9zb3VwTWVzc2FnZS0+cmVxdWVz dF9oZWFkZXJzOworICAgIGlmICghaGVhZGVycy5pc0VtcHR5KCkpIHsKKyAgICAgICAgSFRUUEhl YWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgZW5kID0gaGVhZGVycy5lbmQoKTsKKyAgICAgICAgZm9y IChIVFRQSGVhZGVyTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IGhlYWRlcnMuYmVnaW4oKTsgaXQg IT0gZW5kOyArK2l0KQorICAgICAgICAgICAgc291cF9tZXNzYWdlX2hlYWRlcnNfYXBwZW5kKHNv dXBIZWFkZXJzLCBpdC0+Zmlyc3Quc3RyaW5nKCkudXRmOCgpLmRhdGEoKSwgaXQtPnNlY29uZC51 dGY4KCkuZGF0YSgpKTsKKyAgICB9CisKKyAgICBSZWZQdHI8Rm9ybURhdGE+IGZvcm1EYXRhID0g aHR0cEJvZHkoKTsKKyAgICBpZiAoZm9ybURhdGEgJiYgIWZvcm1EYXRhLT5pc0VtcHR5KCkpIHsK KyAgICAgICAgVmVjdG9yPGNoYXI+IGRhdGE7CisgICAgICAgIGh0dHBCb2R5KCktPmZsYXR0ZW4o ZGF0YSk7CisKKyAgICAgICAgc291cF9tZXNzYWdlX3NldF9yZXF1ZXN0KG1fc291cE1lc3NhZ2Us IGh0dHBDb250ZW50VHlwZSgpLnV0ZjgoKS5kYXRhKCksCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBTT1VQX01FTU9SWV9DT1BZLCBkYXRhLmRhdGEoKSwgZGF0YS5zaXplKCkpOwor ICAgIH0KK30KKworfQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29y a3JlcXVlc3QuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3Bw CmluZGV4IDVmY2YyOWIuLjdjMDYyOTAgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdG5ldHdvcmtyZXF1ZXN0LmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3 b3JrcmVxdWVzdC5jcHAKQEAgLTE1OSw0ICsxNTksMjMgQEAgR19DT05TVF9SRVRVUk4gZ2NoYXIq IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVx dWUKICAgICByZXR1cm4gcHJpdi0+dXJpOwogfQogCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X3NvdXBfbWVzc2FnZToKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVx dWVzdAorICoKKyAqIEdldHMgdGhlICNTb3VwTWVzc2FnZSBoZWxkIGFuZCB1c2VkIGJ5IHRoZSBn aXZlbiByZXF1ZXN0LgorICoKKyAqIFJldHVybnM6IHRoZSAjU291cE1lc3NhZ2UKKyAqCisgKiBT aW5jZTogMS4xLjEKKyAqLworR19DT05TVF9SRVRVUk4gU291cE1lc3NhZ2UqIHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfZ2V0X3NvdXBfbWVzc2FnZShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVz dCkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVFVRVNU KHJlcXVlc3QpLCBOVUxMKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJp diA9IHJlcXVlc3QtPnByaXY7CisKKyAgICByZXR1cm4gcHJpdi0+cmVxdWVzdC5zb3VwTWVzc2Fn ZSgpOworfQorCiB9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3Jr cmVxdWVzdC5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuaAppbmRl eCAwMWFiOGJiLi5kY2ZkMTc2IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRu ZXR3b3JrcmVxdWVzdC5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1 ZXN0LmgKQEAgLTIxLDYgKzIxLDggQEAKICNkZWZpbmUgV0VCS0lUX05FVFdPUktfUkVRVUVTVF9I CiAKICNpbmNsdWRlIDxnbGliLW9iamVjdC5oPgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgor I2luY2x1ZGUgPGxpYnNvdXAvc291cC1tZXNzYWdlLmg+CiAKICNpbmNsdWRlIDx3ZWJraXQvd2Vi a2l0ZGVmaW5lcy5oPgogCkBAIC02NSw2ICs2Nyw5IEBAIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf c2V0X3VyaSAgKFdlYktpdE5ldHdvcmtSZXF1ZXN0ICpyZXF1ZXN0LAogV0VCS0lUX0FQSSBHX0NP TlNUX1JFVFVSTiBnY2hhciAqCiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF91cmkgIChXZWJL aXROZXR3b3JrUmVxdWVzdCAqcmVxdWVzdCk7CiAKK1dFQktJVF9BUEkgR19DT05TVF9SRVRVUk4g U291cE1lc3NhZ2UqCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9zb3VwX21lc3NhZ2UgKFdl YktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKwogR19FTkRfREVDTFMKIAogI2VuZGlmCmRp ZmYgLS1naXQgYS9XZWJLaXRUb29scy9HTlVtYWtlZmlsZS5hbSBiL1dlYktpdFRvb2xzL0dOVW1h a2VmaWxlLmFtCmluZGV4IDI2MjAwYzguLjdiYjliODMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xz L0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYktpdFRvb2xzL0dOVW1ha2VmaWxlLmFtCkBAIC0yMCwx MSArMjAsMTMgQEAgUHJvZ3JhbXNfR3RrTGF1bmNoZXJfQ0ZMQUdTID0gXAogCS1mbm8tc3RyaWN0 LWFsaWFzaW5nIFwKIAktTzIgXAogCSQoZ2xvYmFsX2NmbGFncykgXAotCSQoR1RLX0NGTEFHUykK KwkkKEdUS19DRkxBR1MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKQogCiBQcm9ncmFtc19HdGtMYXVu Y2hlcl9MREFERCA9IFwKIAlsaWJ3ZWJraXQtMS4wLmxhIFwKLQkkKEdUS19MSUJTKQorCSQoR1RL X0xJQlMpIFwKKwkkKExJQlNPVVBfTElCUykKIAogIyBEdW1wUmVuZGVyVHJlZQogUHJvZ3JhbXNf RHVtcFJlbmRlclRyZWVfQ1BQRkxBR1MgPSBcCkBAIC02NywxMyArNjksMTUgQEAgUHJvZ3JhbXNf RHVtcFJlbmRlclRyZWVfQ0ZMQUdTID0gXAogCSQoZ2xvYmFsX2NmbGFncykgXAogCSQoR0xPQkFM REVQU19DRkxBR1MpIFwKIAkkKENBSVJPX0NGTEFHUykgXAotCSQoR1RLX0NGTEFHUykKKwkkKEdU S19DRkxBR1MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKQogCiBQcm9ncmFtc19EdW1wUmVuZGVyVHJl ZV9MREFERCA9IFwKIAlsaWJ3ZWJraXQtMS4wLmxhIFwKIAkkKEdMT0JBTERFUFNfTElCUykgXAog CSQoQ0FJUk9fTElCUykgXAotCSQoR1RLX0xJQlMpCisJJChHVEtfTElCUykgXAorCSQoTElCU09V UF9MSUJTKQogCiAjIFRlc3ROZXRzY2FwZVBsdWdpbgogVGVzdE5ldHNjYXBlUGx1Z2luX2xpYnRl c3RuZXRzY2FwZXBsdWdpbl9sYV9DUFBGTEFHUyA9IFwKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xz L0d0a0xhdW5jaGVyL21haW4uYyBiL1dlYktpdFRvb2xzL0d0a0xhdW5jaGVyL21haW4uYwppbmRl eCA4ZWQyNjkwLi5kZjNmZTNmIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9HdGtMYXVuY2hlci9t YWluLmMKKysrIGIvV2ViS2l0VG9vbHMvR3RrTGF1bmNoZXIvbWFpbi5jCkBAIC0yNSw2ICsyNSw4 IEBACiAgKi8KIAogI2luY2x1ZGUgPGd0ay9ndGsuaD4KKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAu aD4KKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAtbWVzc2FnZS5oPgogI2luY2x1ZGUgPHdlYmtpdC93 ZWJraXQuaD4KIAogc3RhdGljIEd0a1dpZGdldCogbWFpbl93aW5kb3c7CkBAIC02NCw2ICs2Niwx NSBAQCBsaW5rX2hvdmVyX2NiIChXZWJLaXRXZWJWaWV3KiBwYWdlLCBjb25zdCBnY2hhciogdGl0 bGUsIGNvbnN0IGdjaGFyKiBsaW5rLCBncG9pbgogICAgICAgICBndGtfc3RhdHVzYmFyX3B1c2gg KG1haW5fc3RhdHVzYmFyLCBzdGF0dXNfY29udGV4dF9pZCwgbGluayk7CiB9CiAKK3N0YXRpYyBn Ym9vbGVhbgorbmF2aWdhdGlvbl9kZWNpc2lvbl9jYiAoV2ViS2l0V2ViVmlldyogd2ViX3ZpZXcs IFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QsIFdl YktpdFdlYk5hdmlnYXRpb25BY3Rpb24qIGFjdGlvbiwgV2ViS2l0V2ViUG9saWN5RGVjaXNpb24q IGRlY2lzaW9uKQoreworICAgIFNvdXBNZXNzYWdlKiBtc2cgPSB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X2dldF9zb3VwX21lc3NhZ2UgKHJlcXVlc3QpOworICAgIGdfbWVzc2FnZSAoIlNvdXAgbWV0 aG9kOiAlcyIsIG1zZy0+bWV0aG9kKTsKKyAgICB3ZWJraXRfd2ViX3BvbGljeV9kZWNpc2lvbl91 c2UgKGRlY2lzaW9uKTsKKyAgICByZXR1cm4gVFJVRTsKK30KKwogc3RhdGljIHZvaWQKIHRpdGxl X2NoYW5nZV9jYiAoV2ViS2l0V2ViVmlldyogd2ViX3ZpZXcsIFdlYktpdFdlYkZyYW1lKiB3ZWJf ZnJhbWUsIGNvbnN0IGdjaGFyKiB0aXRsZSwgZ3BvaW50ZXIgZGF0YSkKIHsKQEAgLTExOSw2ICsx MzAsNyBAQCBjcmVhdGVfYnJvd3NlciAoKQogICAgIGdfc2lnbmFsX2Nvbm5lY3QgKEdfT0JKRUNU ICh3ZWJfdmlldyksICJsb2FkLXByb2dyZXNzLWNoYW5nZWQiLCBHX0NBTExCQUNLIChwcm9ncmVz c19jaGFuZ2VfY2IpLCB3ZWJfdmlldyk7CiAgICAgZ19zaWduYWxfY29ubmVjdCAoR19PQkpFQ1Qg KHdlYl92aWV3KSwgImxvYWQtY29tbWl0dGVkIiwgR19DQUxMQkFDSyAobG9hZF9jb21taXRfY2Ip LCB3ZWJfdmlldyk7CiAgICAgZ19zaWduYWxfY29ubmVjdCAoR19PQkpFQ1QgKHdlYl92aWV3KSwg ImhvdmVyaW5nLW92ZXItbGluayIsIEdfQ0FMTEJBQ0sgKGxpbmtfaG92ZXJfY2IpLCB3ZWJfdmll dyk7CisgICAgZ19zaWduYWxfY29ubmVjdCAoR19PQkpFQ1QgKHdlYl92aWV3KSwgIm5hdmlnYXRp b24tcG9saWN5LWRlY2lzaW9uLXJlcXVlc3RlZCIsIEdfQ0FMTEJBQ0sgKG5hdmlnYXRpb25fZGVj aXNpb25fY2IpLCB3ZWJfdmlldyk7CiAKICAgICByZXR1cm4gc2Nyb2xsZWRfd2luZG93OwogfQpA QCAtMTgyLDYgKzE5NCw3IEBAIGNyZWF0ZV93aW5kb3cgKCkKIGludAogbWFpbiAoaW50IGFyZ2Ms IGNoYXIqIGFyZ3ZbXSkKIHsKKyAgICBnX3RocmVhZF9pbml0KE5VTEwpOwogICAgIGd0a19pbml0 ICgmYXJnYywgJmFyZ3YpOwogCiAgICAgR3RrV2lkZ2V0KiB2Ym94ID0gZ3RrX3Zib3hfbmV3IChG QUxTRSwgMCk7Ci0tIAoxLjUuNi41Cgo= 26935 2009-01-22 11:12:46 -0800 2009-03-05 17:43:37 -0800 minimal functionality 0001-network-request-minimal-functionality.patch text/plain 10107 gustavo RnJvbSBjOWY0MDA2MjI0MzY5YmYyNDc3YjIxZDE3Njk1NmJkZDZlYzJjNmRmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGtvdkBrb3YuZXRpLmJy PgpEYXRlOiBUaHUsIDE1IEphbiAyMDA5IDExOjI4OjM0IC0wMjAwClN1YmplY3Q6IFtQQVRDSF0g bmV0d29yayByZXF1ZXN0IG1pbmltYWwgZnVuY3Rpb25hbGl0eQoKLS0tCiBXZWJLaXQvZ3RrL0No YW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjUgKysrKysrCiBXZWJL aXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcCB8ICAgIDMgKy0K IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcCAgICAgICAgIHwgICA3 OCArKysrKysrKysrKysrKysrKysrLQogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5o ICAgICAgICAgICAgICAgICAgfCAgIDExICsrKy0KIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdl YmZyYW1lLmNwcCAgICAgICAgICAgICAgIHwgICAgNCArLQogNSBmaWxlcyBjaGFuZ2VkLCAxMTIg aW5zZXJ0aW9ucygrKSwgOSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL0No YW5nZUxvZyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4IDdiOTU0ZjYuLmZmMDZlOGYgMTAw NjQ0Ci0tLSBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMjggQEAKKzIwMDktMDEtMTUgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGdu c0Bnbm9tZS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgUmVmZXJzIHRvIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x ODYwOAorICAgICAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCBuZWVkcyB0byBiZSBmaW5pc2hlZAor CisgICAgICAgIFRoaXMgY2hhbmdlc2V0IGlzIGNvbmNlcm5lZCB3aXRoIG1ha2luZyBXZWJLaXRO ZXR3b3JrUmVxdWVzdCBjYXJyeQorICAgICAgICBSZXNvdXJjZVJlcXVlc3QgaW4gYWRkaXRpb24g dG8gc2ltcGx5IHN0b3JpbmcgdGhlIFVSSSwgd2hpY2gKKyAgICAgICAgYWxsb3dzIHVzIHRvIGdl dCB0aGUgZnVsbCBpbmZvcm1hdGlvbiBmZWQgYmFjayBpbnRvIFdlYktpdCB3aGVuCisgICAgICAg IG5lZWRlZC4gRnJhbWVMb2FkZXJDbGllbnRHdGsgaXMgbm93IHVzaW5nIFdlYktpdE5ldHdvcmtS ZXF1ZXN0CisgICAgICAgIHdoZW4gaXQgbmVlZHMgdG8gZGVhbCB3aXRoIHJlcXVlc3QgaW5mb3Jt YXRpb24uCisKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5j cHA6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERlY2lkZVBv bGljeUZvck5hdmlnYXRpb25BY3Rpb24pOgorICAgICAgICAqIHdlYmtpdC93ZWJraXRuZXR3b3Jr cmVxdWVzdC5jcHA6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X2NsYXNzX2luaXQpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtS ZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3JlX3JlcXVl c3QpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdv cmtfcmVxdWVzdF9nZXRfY29yZV9yZXF1ZXN0KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVx dWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3KToKKyAgICAgICAgKF9XZWJL aXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaSk6 CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X2dldF91cmkpOgorICAgICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmg6CisgICAg ICAgICogd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcDoKKwogMjAwOS0wMS0xMyAgQWxleGFuZGVy IFYuIEJ1dGVua28gIDxhbGV4QGRpZ2lxdWJlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBI b2xnZXIgRnJleXRoZXIuCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50R3RrLmNwcCBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVM b2FkZXJDbGllbnRHdGsuY3BwCmluZGV4IDFiNDEwYzcuLjY4NGVlMGMgMTAwNjQ0Ci0tLSBhL1dl YktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCisrKyBiL1dl YktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCkBAIC01MCw2 ICs1MCw3IEBACiAjaW5jbHVkZSAid2Via2l0d2ViZnJhbWUuaCIKICNpbmNsdWRlICJ3ZWJraXR3 ZWJuYXZpZ2F0aW9uYWN0aW9uLmgiCiAjaW5jbHVkZSAid2Via2l0d2VicG9saWN5ZGVjaXNpb24u aCIKKyNpbmNsdWRlICJ3ZWJraXRuZXR3b3JrcmVxdWVzdC5oIgogI2luY2x1ZGUgIndlYmtpdHBy aXZhdGUuaCIKIAogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0FQSUNhc3QuaD4KQEAgLTMwNyw3 ICszMDgsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERlY2lkZVBvbGljeUZv ck5hdmlnYXRpb25BY3Rpb24oRnJhbWVQb2xpY3lGdW5jdAogICAgICAgICByZXR1cm47CiAKICAg ICBXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3ID0gZ2V0Vmlld0Zyb21GcmFtZShtX2ZyYW1lKTsKLSAg ICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf bmV3KHJlc291cmNlUmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKyAgICBX ZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3 X3dpdGhfY29yZV9yZXF1ZXN0KHJlc291cmNlUmVxdWVzdCk7CiAgICAgV2ViS2l0TmF2aWdhdGlv blJlc3BvbnNlIHJlc3BvbnNlOwogICAgIC8qCiAgICAgICogV2Ugc3RpbGwgc3VwcG9ydCB0aGUg ZGVwcmVjYXRlZCBuYXZpZ2F0aW9uLXJlcXVlc3RlZCBzaWduYWwsIGlmIHRoZQpkaWZmIC0tZ2l0 IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwIGIvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwCmluZGV4IDNhZDhiNWQuLjE4NGQ0MDkg MTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcAor KysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKQEAgLTEsNSAr MSw2IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAyMDA3LCAyMDA4IEhvbGdlciBIYW5zIFBldGVy IEZyZXl0aGVyCisgKiBDb3B5cmlnaHQgKEMpIDIwMDggR3VzdGF2byBOb3JvbmhhIFNpbHZhCiAg KgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRl IGl0IGFuZC9vcgogICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJh cnkgR2VuZXJhbCBQdWJsaWMKQEAgLTIwLDYgKzIxLDExIEBACiAjaW5jbHVkZSAiY29uZmlnLmgi CiAKICNpbmNsdWRlICJ3ZWJraXRuZXR3b3JrcmVxdWVzdC5oIgorI2luY2x1ZGUgIndlYmtpdHBy aXZhdGUuaCIKKworI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjaW5jbHVkZSAiUmVzb3Vy Y2VSZXF1ZXN0LmgiCisjaW5jbHVkZSAiQ1N0cmluZy5oIgogCiAvKioKICAqIFNFQ1RJT046d2Vi a2l0bmV0d29ya3JlcXVlc3QKQEAgLTM0LDEyICs0MCwxNyBAQAogICoKICAqLwogCit1c2luZyBu YW1lc3BhY2UgV2ViQ29yZTsKKwogZXh0ZXJuICJDIiB7CiAKIEdfREVGSU5FX1RZUEUoV2ViS2l0 TmV0d29ya1JlcXVlc3QsIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3QsIEdfVFlQRV9PQkpFQ1QpOwog CiBzdHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSB7CiAgICAgZ2NoYXIqIHVyaTsK KworICAgIFJlc291cmNlUmVxdWVzdCogcmVxdWVzdDsKKyAgICBnYm9vbGVhbiBtdXN0X2ZyZWVf cmVxdWVzdDsKIH07CiAKICNkZWZpbmUgV0VCS0lUX05FVFdPUktfUkVRVUVTVF9HRVRfUFJJVkFU RShvYmopIChHX1RZUEVfSU5TVEFOQ0VfR0VUX1BSSVZBVEUoKG9iaiksIFdFQktJVF9UWVBFX05F VFdPUktfUkVRVUVTVCwgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKSkKQEAgLTUxLDEyICs2 MiwxNyBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2ZpbmFsaXplKEdPYmpl Y3QqIG9iamVjdCkKIAogICAgIGdfZnJlZShwcml2LT51cmkpOwogCisgICAgaWYgKHByaXYtPm11 c3RfZnJlZV9yZXF1ZXN0KQorICAgICAgICBkZWxldGUgcHJpdi0+cmVxdWVzdDsKKwogICAgIEdf T0JKRUNUX0NMQVNTKHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfcGFyZW50X2NsYXNzKS0+ZmluYWxp emUob2JqZWN0KTsKIH0KIAogc3RhdGljIHZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9jbGFz c19pbml0KFdlYktpdE5ldHdvcmtSZXF1ZXN0Q2xhc3MqIHJlcXVlc3RDbGFzcykKIHsKLSAgICBH X09CSkVDVF9DTEFTUyhyZXF1ZXN0Q2xhc3MpLT5maW5hbGl6ZSA9IHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZmluYWxpemU7CisgICAgR09iamVjdENsYXNzKiBvYmplY3RDbGFzcyA9IEdfT0JKRUNU X0NMQVNTKHJlcXVlc3RDbGFzcyk7CisKKyAgICBvYmplY3RDbGFzcy0+ZmluYWxpemUgPSB3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X2ZpbmFsaXplOwogCiAgICAgZ190eXBlX2NsYXNzX2FkZF9wcml2 YXRlKHJlcXVlc3RDbGFzcywgc2l6ZW9mKFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSkpOwog fQpAQCAtNjUsMjAgKzgxLDY2IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf aW5pdChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKIHsKICAgICBXZWJLaXROZXR3b3Jr UmVxdWVzdFByaXZhdGUqIHByaXYgPSBXRUJLSVRfTkVUV09SS19SRVFVRVNUX0dFVF9QUklWQVRF KHJlcXVlc3QpOwogICAgIHJlcXVlc3QtPnByaXYgPSBwcml2OworCisgICAgLyoKKyAgICAgKiBX ZSB1c3VhbGx5IGdldCBhIFJlc291cmNlUmVxdWVzdCB0aGF0IGlzIG93bmVkIGJ5IFdlYkNvcmUs IGFuZAorICAgICAqIHdlIG5lZWQgbm90IGNhcmUgYWJvdXQgaXRzIGxpZmV0aW1lCisgICAgICov CisgICAgcHJpdi0+bXVzdF9mcmVlX3JlcXVlc3QgPSBGQUxTRTsKIH0KIAorLy8gZm9yIGludGVy bmFsIHVzZSBvbmx5CitXZWJLaXROZXR3b3JrUmVxdWVzdCogd2Via2l0X25ldHdvcmtfcmVxdWVz dF9uZXdfd2l0aF9jb3JlX3JlcXVlc3QoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJl cXVlc3QpCit7CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSBXRUJLSVRfTkVU V09SS19SRVFVRVNUKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIE5V TEwpKTsKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5w cml2OworCisgICAgcHJpdi0+cmVxdWVzdCA9ICYoKFJlc291cmNlUmVxdWVzdCYpcmVzb3VyY2VS ZXF1ZXN0KTsKKworICAgIHJldHVybiByZXF1ZXN0OworfQorCisvLyBmb3IgaW50ZXJuYWwgdXNl IG9ubHkKK1Jlc291cmNlUmVxdWVzdCogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfY29yZV9y ZXF1ZXN0KGNvbnN0IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIFdlYktp dE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICByZXR1 cm4gcHJpdi0+cmVxdWVzdDsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25l dzoKKyAqIEB1cmk6IGFuIFVSSQorICoKKyAqIENyZWF0ZXMgYSBuZXcgI1dlYktpdE5ldHdvcmtS ZXF1ZXN0IGluaXRpYWxpemVkIHdpdGggYW4gVVJJLgorICoKKyAqIFJldHVybnM6IGEgbmV3ICNX ZWJLaXROZXR3b3JrUmVxdWVzdAorICovCiBXZWJLaXROZXR3b3JrUmVxdWVzdCogd2Via2l0X25l dHdvcmtfcmVxdWVzdF9uZXcoY29uc3QgZ2NoYXIqIHVyaSkKIHsKICAgICBnX3JldHVybl92YWxf aWZfZmFpbCh1cmksIE5VTEwpOwogCi0gICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3Qg PSBXRUJLSVRfTkVUV09SS19SRVFVRVNUKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JL X1JFUVVFU1QsIE5VTEwpKTsKKyAgICBSZXNvdXJjZVJlcXVlc3QqIHJlc291cmNlUmVxdWVzdCA9 IG5ldyBSZXNvdXJjZVJlcXVlc3QoS1VSTChTdHJpbmc6OmZyb21VVEY4KHVyaSkpKTsKKworICAg IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9u ZXdfd2l0aF9jb3JlX3JlcXVlc3QoKGNvbnN0IFJlc291cmNlUmVxdWVzdCYpKnJlc291cmNlUmVx dWVzdCk7CiAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+ cHJpdjsKIAotICAgIHByaXYtPnVyaSA9IGdfc3RyZHVwKHVyaSk7CisgICAgLyoKKyAgICAgKiBT aW5jZSB3ZSBhcmUgY3JlYXRpbmcgdGhpcyBSZXNvdXJjZVJlcXVlc3Qgb3Vyc2VsdmVzLCB3ZSB3 aWxsCisgICAgICogbmVlZCB0byBmcmVlIGl0IGluIGRpc3Bvc2UKKyAgICAgKi8KKyAgICBwcml2 LT5tdXN0X2ZyZWVfcmVxdWVzdCA9IFRSVUU7CiAKICAgICByZXR1cm4gcmVxdWVzdDsKIH0KIAor LyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF91cmk6CisgKiBAcmVxdWVzdDogYSAj V2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEB1cmk6IGFuIFVSSQorICoKKyAqIFNldHMgdGhlIFVS SSBoZWxkIGFuZCB1c2VkIGJ5IHRoZSBnaXZlbiByZXF1ZXN0LgorICovCiB2b2lkIHdlYmtpdF9u ZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29u c3QgZ2NoYXIqIHVyaSkKIHsKICAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JL X1JFUVVFU1QocmVxdWVzdCkpOwpAQCAtODcsMjIgKzE0OSwzMCBAQCB2b2lkIHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3Rfc2V0X3VyaShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3Qg Z2NoYXIqCiAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+ cHJpdjsKIAogICAgIGdfZnJlZShwcml2LT51cmkpOwotICAgIHByaXYtPnVyaSA9IGdfc3RyZHVw KHVyaSk7CisgICAgcHJpdi0+cmVxdWVzdC0+c2V0VVJMKEtVUkwoU3RyaW5nOjpmcm9tVVRGOCh1 cmkpKSk7CiB9CiAKIC8qKgogICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJpOgogICog QHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CiAgKgorICogR2V0cyB0aGUgVVJJIGhl bGQgYW5kIHVzZWQgYnkgdGhlIGdpdmVuIHJlcXVlc3QuCisgKgogICogUmV0dXJuczogdGhlIHVy aSBvZiB0aGUgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CiAgKgogICogU2luY2U6IDEuMC4wCisgKgor ICogUmV0dXJuczogdGhlIFVSSSBoZWxkIGFuZCB1c2VkIGJ5IHRoZSBnaXZlbiByZXF1ZXN0CiAg Ki8KIEdfQ09OU1RfUkVUVVJOIGdjaGFyKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF91cmko V2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCiB7CiAgICAgZ19yZXR1cm5fdmFsX2lmX2Zh aWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgTlVMTCk7CiAKICAgICBXZWJL aXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgaWYg KHByaXYtPnVyaSA9PSBOVUxMKQorICAgICAgICBwcml2LT51cmkgPSBnX3N0cmR1cChwcml2LT5y ZXF1ZXN0LT51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKwogICAgIHJldHVybiBwcml2 LT51cmk7CiB9CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUu aCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAppbmRleCBhY2U5OTZkLi5jZmIx NTQxIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKKysrIGIv V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCkBAIC0yMyw3ICsyMyw4IEBACiAjZGVm aW5lIFdFQktJVF9QUklWQVRFX0gKIAogLyoKLSAqIFRoaXMgZmlsZSBrbm93cyB0aGUgc2hhcmVk IHNlY3JldCBvZiBXZWJLaXRXZWJWaWV3IGFuZCBXZWJLaXRXZWJGcmFtZS4KKyAqIFRoaXMgZmls ZSBrbm93cyB0aGUgc2hhcmVkIHNlY3JldCBvZiBXZWJLaXRXZWJWaWV3LCBXZWJLaXRXZWJGcmFt ZSwKKyAqIGFuZCBXZWJLaXROZXR3b3JrUmVxdWVzdC4KICAqIFRoZXkgYXJlIHVzaW5nIFdlYkNv cmUgd2hpY2ggbXVzbid0IGJlIGV4cG9zZWQgdG8gdGhlIG91dGVyIHdvcmxkLgogICovCiAKQEAg LTM1LDYgKzM2LDcgQEAKICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2Vic2V0dGluZ3MuaD4KICNp bmNsdWRlIDx3ZWJraXQvd2Via2l0d2Vid2luZG93ZmVhdHVyZXMuaD4KICNpbmNsdWRlIDx3ZWJr aXQvd2Via2l0d2ViYmFja2ZvcndhcmRsaXN0Lmg+CisjaW5jbHVkZSA8d2Via2l0L3dlYmtpdG5l dHdvcmtyZXF1ZXN0Lmg+CiAKICNpbmNsdWRlICJCYWNrRm9yd2FyZExpc3QuaCIKICNpbmNsdWRl ICJIaXN0b3J5SXRlbS5oIgpAQCAtNDMsNiArNDUsNyBAQAogI2luY2x1ZGUgIkZyYW1lLmgiCiAj aW5jbHVkZSAiSW5zcGVjdG9yQ2xpZW50R3RrLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkZXJDbGll bnQuaCIKKyNpbmNsdWRlICJSZXNvdXJjZVJlcXVlc3QuaCIKICNpbmNsdWRlICJXaW5kb3dGZWF0 dXJlcy5oIgogCiAjaW5jbHVkZSA8Z2xpYi5oPgpAQCAtMTQ0LDYgKzE0NywxMiBAQCBleHRlcm4g IkMiIHsKICAgICB2b2lkCiAgICAgd2Via2l0X3dlYl9wb2xpY3lfZGVjaXNpb25fY2FuY2VsIChX ZWJLaXRXZWJQb2xpY3lEZWNpc2lvbiogZGVjaXNpb24pOwogCisgICAgV2ViS2l0TmV0d29ya1Jl cXVlc3QqCisgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3JlX3JlcXVlc3Qo Y29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3QpOworCisgICAg V2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0KgorICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0 X2NvcmVfcmVxdWVzdChjb25zdCBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CisKICAg ICAvLyBGSVhNRTogTW92ZSB0aGVzZSB0byB3ZWJraXR3ZWJmcmFtZS5oIG9uY2UgdGhlaXIgQVBJ IGhhcyBiZWVuIGRpc2N1c3NlZC4KIAogICAgIFdFQktJVF9BUEkgR1NMaXN0KgpkaWZmIC0tZ2l0 IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwIGIvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0d2ViZnJhbWUuY3BwCmluZGV4IDM4ZTIzYTQuLjUyNTFjYTQgMTAwNjQ0Ci0tLSBh L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKQEAgLTM5Miw5ICszOTIsNyBAQCB2b2lkIHdlYmtpdF93 ZWJfZnJhbWVfbG9hZF9yZXF1ZXN0KFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgV2ViS2l0TmV0d29y a1JlcXVlc3QqCiAgICAgaWYgKCFjb3JlRnJhbWUpCiAgICAgICAgIHJldHVybjsKIAotICAgIC8v IFRPRE86IFVzZSB0aGUgUmVzb3VyY2VSZXF1ZXN0IGNhcnJpZWQgYnkgV2ViS2l0TmV0d29ya1Jl cXVlc3Qgd2hlbiBpdCBpcyBpbXBsZW1lbnRlZC4KLSAgICBTdHJpbmcgc3RyaW5nID0gU3RyaW5n Ojpmcm9tVVRGOCh3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF91cmkocmVxdWVzdCkpOwotICAg IGNvcmVGcmFtZS0+bG9hZGVyKCktPmxvYWQoUmVzb3VyY2VSZXF1ZXN0KEtVUkwoc3RyaW5nKSkp OworICAgIGNvcmVGcmFtZS0+bG9hZGVyKCktPmxvYWQoKGNvbnN0IFJlc291cmNlUmVxdWVzdCYp KndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2NvcmVfcmVxdWVzdChyZXF1ZXN0KSk7CiB9CiAK IC8qKgotLSAKMS41LjYuNQoK 26937 2009-01-22 12:06:53 -0800 2009-03-23 17:11:54 -0700 proof of concept for exposing SoupMessage 0002-expose-SoupMessage-in-NetworkRequest.patch text/plain 14283 gustavo RnJvbSBlODMxNjY0ODc0ZTNlMGY4OTk2NDBiYjdkMzcyMDQ0NWQ4YjA0MzUzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGtvdkBrb3YuZXRpLmJy PgpEYXRlOiBXZWQsIDIxIEphbiAyMDA5IDIxOjUyOjU5IC0wMjAwClN1YmplY3Q6IFtQQVRDSF0g ZXhwb3NlIFNvdXBNZXNzYWdlIGluIE5ldHdvcmtSZXF1ZXN0CgotLS0KIEdOVW1ha2VmaWxlLmFt ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgNiArLQogV2ViQ29yZS9H TlVtYWtlZmlsZS5hbSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIC4uLi9w bGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcCAgIHwgICAyNSArLS0t LS0KIFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdC5oICAgIHwg ICAyMyArKysrLQogLi4uL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3RTb3Vw LmNwcCAgfCAgMTAzICsrKysrKysrKysrKysrKysrKysrCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXRuZXR3b3JrcmVxdWVzdC5jcHAgICAgICAgICB8ICAgMzcgKysrKysrKwogV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuaCAgICAgICAgICAgfCAgICA4ICsrCiBXZWJLaXRU b29scy9HTlVtYWtlZmlsZS5hbSAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTIgKystCiBX ZWJLaXRUb29scy9HdGtMYXVuY2hlci9tYWluLmMgICAgICAgICAgICAgICAgICAgICB8ICAgMTUg KysrCiA5IGZpbGVzIGNoYW5nZWQsIDE5OCBpbnNlcnRpb25zKCspLCAzMiBkZWxldGlvbnMoLSkK IGNyZWF0ZSBtb2RlIDEwMDY0NCBXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJj ZVJlcXVlc3RTb3VwLmNwcAoKZGlmZiAtLWdpdCBhL0dOVW1ha2VmaWxlLmFtIGIvR05VbWFrZWZp bGUuYW0KaW5kZXggN2FlYzA2MS4uZGIzNDY1NCAxMDA2NDQKLS0tIGEvR05VbWFrZWZpbGUuYW0K KysrIGIvR05VbWFrZWZpbGUuYW0KQEAgLTQ4MSwxMSArNDgxLDEzIEBAIFByb2dyYW1zX1VuaXRU ZXN0c19DRkxBR1MgPSBcCiAJLU8yIFwKIAkkKGdsb2JhbF9jZmxhZ3MpIFwKIAkkKEdMSUJfQ0ZM QUdTKSBcCi0JJChHVEtfQ0ZMQUdTKQorCSQoR1RLX0NGTEFHUykgXAorCSQoTElCU09VUF9DRkxB R1MpCiAKIFByb2dyYW1zX1VuaXRUZXN0c19MREFERCA9IFwKIAlsaWJ3ZWJraXQtMS4wLmxhIFwK LQkkKEdUS19MSUJTKQorCSQoR1RLX0xJQlMpIFwKKwkkKExJQlNPVVBfTElCUykKIAogIyBBdXRv Z2VuZXJhdGVkIHNvdXJjZXMKIEJVSUxUX1NPVVJDRVMgOj0gXApkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9HTlVtYWtlZmlsZS5hbSBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KaW5kZXggNzg3YzRhNC4u MmQ4NDU2OCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQorKysgYi9XZWJDb3Jl L0dOVW1ha2VmaWxlLmFtCkBAIC0xODAwLDYgKzE4MDAsNyBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0g XAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0ROU1NvdXAuY3BwIFwKIAlXZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUVycm9yLmggXAogCVdlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAgXAorCVdlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdFNvdXAuY3BwIFwKIAlXZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3QuaCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXNwb25zZS5oCiBlbmRpZgpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcCBiL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKaW5kZXggZGE5Njg3 My4uMmFiZTBlOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVz b3VyY2VIYW5kbGVTb3VwLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9S ZXNvdXJjZUhhbmRsZVNvdXAuY3BwCkBAIC0yOTksMzUgKzI5OSwxMiBAQCBib29sIFJlc291cmNl SGFuZGxlOjpzdGFydEh0dHAoU3RyaW5nIHVybFN0cmluZykKICAgICAgICAgfQogICAgIH0KIAot ICAgIFNvdXBNZXNzYWdlKiBtc2c7Ci0gICAgbXNnID0gc291cF9tZXNzYWdlX25ldyhyZXF1ZXN0 KCkuaHR0cE1ldGhvZCgpLnV0ZjgoKS5kYXRhKCksIHVybFN0cmluZy51dGY4KCkuZGF0YSgpKTsK KyAgICBTb3VwTWVzc2FnZSogbXNnID0gcmVxdWVzdCgpLnNvdXBNZXNzYWdlKCk7CiAgICAgZ19z aWduYWxfY29ubmVjdChtc2csICJyZXN0YXJ0ZWQiLCBHX0NBTExCQUNLKHJlc3RhcnRlZENhbGxi YWNrKSwgdGhpcyk7CiAKICAgICBnX3NpZ25hbF9jb25uZWN0KG1zZywgImdvdC1oZWFkZXJzIiwg R19DQUxMQkFDSyhnb3RIZWFkZXJzQ2FsbGJhY2spLCB0aGlzKTsKICAgICBnX3NpZ25hbF9jb25u ZWN0KG1zZywgImdvdC1jaHVuayIsIEdfQ0FMTEJBQ0soZ290Q2h1bmtDYWxsYmFjayksIHRoaXMp OwogCi0gICAgSFRUUEhlYWRlck1hcCBjdXN0b21IZWFkZXJzID0gZC0+bV9yZXF1ZXN0Lmh0dHBI ZWFkZXJGaWVsZHMoKTsKLSAgICBpZiAoIWN1c3RvbUhlYWRlcnMuaXNFbXB0eSgpKSB7Ci0gICAg ICAgIEhUVFBIZWFkZXJNYXA6OmNvbnN0X2l0ZXJhdG9yIGVuZCA9IGN1c3RvbUhlYWRlcnMuZW5k KCk7Ci0gICAgICAgIGZvciAoSFRUUEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBjdXN0 b21IZWFkZXJzLmJlZ2luKCk7IGl0ICE9IGVuZDsgKytpdCkKLSAgICAgICAgICAgIHNvdXBfbWVz c2FnZV9oZWFkZXJzX2FwcGVuZChtc2ctPnJlcXVlc3RfaGVhZGVycywgaXQtPmZpcnN0LnN0cmlu ZygpLnV0ZjgoKS5kYXRhKCksIGl0LT5zZWNvbmQudXRmOCgpLmRhdGEoKSk7Ci0gICAgfQotCi0g ICAgRm9ybURhdGEqIGh0dHBCb2R5ID0gZC0+bV9yZXF1ZXN0Lmh0dHBCb2R5KCk7Ci0gICAgaWYg KGh0dHBCb2R5ICYmICFodHRwQm9keS0+aXNFbXB0eSgpKSB7Ci0gICAgICAgIC8vIE1ha2luZyBh IGNvcHkgb2YgdGhlIHJlcXVlc3QgYm9keSBpc24ndCB0aGUgbW9zdCBlZmZpY2llbnQgd2F5IHRv Ci0gICAgICAgIC8vIHNlcmlhbGl6ZSBpdCwgYnV0IGJ5IGZhciB0aGUgbW9zdCBzaW1wbGUuIERl YWxpbmcgd2l0aCBpbmRpdmlkdWFsCi0gICAgICAgIC8vIEZvcm1EYXRhIGVsZW1lbnRzIGFuZCBz aGFyZWQgYnVmZmVycyBzaG91bGQgYmUgbW9yZSBtZW1vcnkKLSAgICAgICAgLy8gZWZmaWNpZW50 LgotICAgICAgICAvLwotICAgICAgICAvLyBUaGlzIHBvc3NpYmx5IGlzbid0IGhhbmRsaW5nIGZp bGUgdXBsb2Fkcy9hdHRhY2htZW50cywgZm9yIHdoaWNoCi0gICAgICAgIC8vIHNoYXJlZCBidWZm ZXJzIG9yIHN0cmVhbWluZyBzaG91bGQgZGVmaW5pdGVseSBiZSB1c2VkLgotICAgICAgICBWZWN0 b3I8Y2hhcj4gYm9keTsKLSAgICAgICAgaHR0cEJvZHktPmZsYXR0ZW4oYm9keSk7Ci0gICAgICAg IHNvdXBfbWVzc2FnZV9zZXRfcmVxdWVzdChtc2csIGQtPm1fcmVxdWVzdC5odHRwQ29udGVudFR5 cGUoKS51dGY4KCkuZGF0YSgpLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgU09V UF9NRU1PUllfQ09QWSwgYm9keS5kYXRhKCksIGJvZHkuc2l6ZSgpKTsKLSAgICB9Ci0KICAgICBk LT5tX21zZyA9IHN0YXRpY19jYXN0PFNvdXBNZXNzYWdlKj4oZ19vYmplY3RfcmVmKG1zZykpOwog ICAgIHNvdXBfc2Vzc2lvbl9xdWV1ZV9tZXNzYWdlKHNlc3Npb24sIGQtPm1fbXNnLCBmaW5pc2hl ZENhbGxiYWNrLCB0aGlzKTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L3NvdXAvUmVzb3VyY2VSZXF1ZXN0LmggYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9S ZXNvdXJjZVJlcXVlc3QuaAppbmRleCBlZmIxMjQwLi5mNmE1NGMyIDEwMDY0NAotLS0gYS9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3QuaAorKysgYi9XZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3QuaApAQCAtMjcsMzggKzI3LDU3 IEBACiAjaWZuZGVmIFJlc291cmNlUmVxdWVzdF9oCiAjZGVmaW5lIFJlc291cmNlUmVxdWVzdF9o CiAKKwogI2luY2x1ZGUgIlJlc291cmNlUmVxdWVzdEJhc2UuaCIKIAorI2luY2x1ZGUgPGxpYnNv dXAvc291cC5oPgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC1tZXNzYWdlLmg+CisKIG5hbWVzcGFj ZSBXZWJDb3JlIHsKIAogICAgIHN0cnVjdCBSZXNvdXJjZVJlcXVlc3QgOiBSZXNvdXJjZVJlcXVl c3RCYXNlIHsKIAogICAgICAgICBSZXNvdXJjZVJlcXVlc3QoY29uc3QgU3RyaW5nJiB1cmwpCiAg ICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UoS1VSTCh1cmwpLCBVc2VQcm90b2NvbENh Y2hlUG9saWN5KQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKDApCiAgICAgICAgIHsKICAg ICAgICAgfQogCiAgICAgICAgIFJlc291cmNlUmVxdWVzdChjb25zdCBLVVJMJiB1cmwpCiAgICAg ICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UodXJsLCBVc2VQcm90b2NvbENhY2hlUG9saWN5 KQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKDApCiAgICAgICAgIHsKICAgICAgICAgfQog CiAgICAgICAgIFJlc291cmNlUmVxdWVzdChjb25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmluZyYg cmVmZXJyZXIsIFJlc291cmNlUmVxdWVzdENhY2hlUG9saWN5IHBvbGljeSA9IFVzZVByb3RvY29s Q2FjaGVQb2xpY3kpCiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UodXJsLCBwb2xp Y3kpCisgICAgICAgICAgICAsIG1fc291cE1lc3NhZ2UoMCkKICAgICAgICAgewogICAgICAgICAg ICAgc2V0SFRUUFJlZmVycmVyKHJlZmVycmVyKTsKICAgICAgICAgfQogCiAgICAgICAgIFJlc291 cmNlUmVxdWVzdCgpCiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UoS1VSTCgpLCBV c2VQcm90b2NvbENhY2hlUG9saWN5KQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKDApCiAg ICAgICAgIHsKICAgICAgICAgfQogCisgICAgICAgIFJlc291cmNlUmVxdWVzdChTb3VwTWVzc2Fn ZSogc291cE1lc3NhZ2UpCisgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UoKQorICAg ICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKHNvdXBNZXNzYWdlKQorICAgICAgICB7CisgICAgICAg IH0KKworICAgICAgICBTb3VwTWVzc2FnZSogc291cE1lc3NhZ2UoKSBjb25zdDsKKworICAgICAg ICB2b2lkIHJlZnJlc2goKTsKKwogICAgIHByaXZhdGU6CisgICAgICAgIFNvdXBNZXNzYWdlICpt X3NvdXBNZXNzYWdlOwogICAgICAgICBmcmllbmQgY2xhc3MgUmVzb3VyY2VSZXF1ZXN0QmFzZTsK IAotICAgICAgICB2b2lkIGRvVXBkYXRlUGxhdGZvcm1SZXF1ZXN0KCkge30KLSAgICAgICAgdm9p ZCBkb1VwZGF0ZVJlc291cmNlUmVxdWVzdCgpIHt9CisgICAgICAgIHZvaWQgZG9VcGRhdGVQbGF0 Zm9ybVJlcXVlc3QoKTsKKyAgICAgICAgdm9pZCBkb1VwZGF0ZVJlc291cmNlUmVxdWVzdCgpOwog ICAgIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxh dGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdFNvdXAuY3BwIGIvV2ViQ29yZS9wbGF0 Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0U291cC5jcHAKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMC4uYWUxOTJmNQotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdFNvdXAuY3BwCkBAIC0wLDAgKzEs MTAzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA4IEd1c3Rhdm8gTm9yb25oYSBTaWx2YQor ICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNz ZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNv ZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBv ciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFy eSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICog YnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFu dHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVS UE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3Ig bW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2Yg dGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlz IGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAq IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwg RmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaW5j bHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRlICJDU3RyaW5nLmgiCisjaW5jbHVkZSAiUGxhdGZv cm1TdHJpbmcuaCIKKyNpbmNsdWRlICJSZXNvdXJjZVJlcXVlc3QuaCIKKworI2luY2x1ZGUgPGxp YnNvdXAvc291cC5oPgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC1tZXNzYWdlLmg+CisKK25hbWVz cGFjZSBXZWJDb3JlIHsKKworU291cE1lc3NhZ2UqIFJlc291cmNlUmVxdWVzdDo6c291cE1lc3Nh Z2UoKSBjb25zdAoreworICAgIHVwZGF0ZVBsYXRmb3JtUmVxdWVzdCgpOworCisgICAgcmV0dXJu IG1fc291cE1lc3NhZ2U7Cit9CisKK3ZvaWQgUmVzb3VyY2VSZXF1ZXN0OjpyZWZyZXNoKCkKK3sK KyAgICBtX3Jlc291cmNlUmVxdWVzdFVwZGF0ZWQgPSBmYWxzZTsKKyAgICB1cGRhdGVSZXNvdXJj ZVJlcXVlc3QoKTsKK30KKwordm9pZCBSZXNvdXJjZVJlcXVlc3Q6OmRvVXBkYXRlUmVzb3VyY2VS ZXF1ZXN0KCkKK3sKKyAgICBTb3VwVVJJICpzb3VwVVJJID0gc291cF9tZXNzYWdlX2dldF91cmko bV9zb3VwTWVzc2FnZSk7CisKKyAgICBnY2hhciAqdXJpID0gc291cF91cmlfdG9fc3RyaW5nKHNv dXBVUkksIEZBTFNFKTsKKyAgICBtX3VybCA9IEtVUkwoU3RyaW5nOjpmcm9tVVRGOCh1cmkpKTsK KyAgICBnX2ZyZWUodXJpKTsKKworICAgIG1faHR0cE1ldGhvZCA9IFN0cmluZzo6ZnJvbVVURjgo bV9zb3VwTWVzc2FnZS0+bWV0aG9kKTsKKworICAgIFNvdXBNZXNzYWdlSGVhZGVyc0l0ZXIgaGVh ZGVyc0l0ZXI7CisgICAgZ2NoYXIgKmhlYWRlck5hbWUgPSAwOworICAgIGdjaGFyICpoZWFkZXJW YWx1ZSA9IDA7CisKKyAgICBzb3VwX21lc3NhZ2VfaGVhZGVyc19pdGVyX2luaXQoJmhlYWRlcnNJ dGVyLCBtX3NvdXBNZXNzYWdlLT5yZXF1ZXN0X2hlYWRlcnMpOworICAgIHdoaWxlIChzb3VwX21l c3NhZ2VfaGVhZGVyc19pdGVyX25leHQoJmhlYWRlcnNJdGVyLCAoY29uc3QgZ2NoYXIqKikmaGVh ZGVyTmFtZSwgKGNvbnN0IGdjaGFyKiopJmhlYWRlclZhbHVlKSkgeworICAgICAgICBtX2h0dHBI ZWFkZXJGaWVsZHMuc2V0KFN0cmluZzo6ZnJvbVVURjgoaGVhZGVyTmFtZSksIFN0cmluZzo6ZnJv bVVURjgoaGVhZGVyVmFsdWUpKTsKKyAgICB9CisKKyAgICBtX2h0dHBCb2R5ID0gRm9ybURhdGE6 OmNyZWF0ZShtX3NvdXBNZXNzYWdlLT5yZXF1ZXN0X2JvZHktPmRhdGEsIG1fc291cE1lc3NhZ2Ut PnJlcXVlc3RfYm9keS0+bGVuZ3RoKTsKK30KKwordm9pZCBSZXNvdXJjZVJlcXVlc3Q6OmRvVXBk YXRlUGxhdGZvcm1SZXF1ZXN0KCkKK3sKKyAgICBpZiAoaXNOdWxsKCkpIHsKKyAgICAgICAgaWYg KG1fc291cE1lc3NhZ2UpCisgICAgICAgICAgICBnX29iamVjdF91bnJlZihtX3NvdXBNZXNzYWdl KTsKKyAgICAgICAgbV9zb3VwTWVzc2FnZSA9IDA7CisgICAgICAgIHJldHVybjsKKyAgICB9CisK KyAgICAvLyBzb3VwIG9ubHkgYWxsb3dzIHNldHRpbmcgYSBtZXNzYWdlJ3MgbWV0aG9kIG9uIGNy ZWF0aW9uCisgICAgaWYgKCFtX3NvdXBNZXNzYWdlKSB7CisgICAgICAgIG1fc291cE1lc3NhZ2Ug PSBzb3VwX21lc3NhZ2VfbmV3KGh0dHBNZXRob2QoKS51dGY4KCkuZGF0YSgpLCB1cmwoKS5zdHJp bmcoKS51dGY4KCkuZGF0YSgpKTsKKyAgICB9CisgICAgZWxzZSB7CisgICAgICAgIFNvdXBVUkkg KnNvdXBVUkkgPSBzb3VwX3VyaV9uZXcodXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7Cisg ICAgICAgIHNvdXBfbWVzc2FnZV9zZXRfdXJpKG1fc291cE1lc3NhZ2UsIHNvdXBVUkkpOworICAg IH0KKyAgICBzb3VwX21lc3NhZ2VfaGVhZGVyc19jbGVhcihtX3NvdXBNZXNzYWdlLT5yZXF1ZXN0 X2hlYWRlcnMpOworCisgICAgSFRUUEhlYWRlck1hcCBoZWFkZXJzID0gaHR0cEhlYWRlckZpZWxk cygpOworICAgIFNvdXBNZXNzYWdlSGVhZGVycyAqc291cEhlYWRlcnMgPSBtX3NvdXBNZXNzYWdl LT5yZXF1ZXN0X2hlYWRlcnM7CisgICAgaWYgKCFoZWFkZXJzLmlzRW1wdHkoKSkgeworICAgICAg ICBIVFRQSGVhZGVyTWFwOjpjb25zdF9pdGVyYXRvciBlbmQgPSBoZWFkZXJzLmVuZCgpOworICAg ICAgICBmb3IgKEhUVFBIZWFkZXJNYXA6OmNvbnN0X2l0ZXJhdG9yIGl0ID0gaGVhZGVycy5iZWdp bigpOyBpdCAhPSBlbmQ7ICsraXQpCisgICAgICAgICAgICBzb3VwX21lc3NhZ2VfaGVhZGVyc19h cHBlbmQoc291cEhlYWRlcnMsIGl0LT5maXJzdC5zdHJpbmcoKS51dGY4KCkuZGF0YSgpLCBpdC0+ c2Vjb25kLnV0ZjgoKS5kYXRhKCkpOworICAgIH0KKworICAgIFJlZlB0cjxGb3JtRGF0YT4gZm9y bURhdGEgPSBodHRwQm9keSgpOworICAgIGlmIChmb3JtRGF0YSAmJiAhZm9ybURhdGEtPmlzRW1w dHkoKSkgeworICAgICAgICBWZWN0b3I8Y2hhcj4gZGF0YTsKKyAgICAgICAgaHR0cEJvZHkoKS0+ ZmxhdHRlbihkYXRhKTsKKworICAgICAgICBzb3VwX21lc3NhZ2Vfc2V0X3JlcXVlc3QobV9zb3Vw TWVzc2FnZSwgaHR0cENvbnRlbnRUeXBlKCkudXRmOCgpLmRhdGEoKSwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIFNPVVBfTUVNT1JZX0NPUFksIGRhdGEuZGF0YSgpLCBkYXRhLnNp emUoKSk7CisgICAgfQorfQorCit9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXRuZXR3b3JrcmVxdWVzdC5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVx dWVzdC5jcHAKaW5kZXggMTg0ZDQwOS4uN2U2NzMzYyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdG5ldHdvcmtyZXF1ZXN0LmNwcApAQCAtMTc2LDQgKzE3Niw0MSBAQCBHX0NPTlNUX1JFVFVS TiBnY2hhciogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJpKFdlYktpdE5ldHdvcmtSZXF1 ZXN0KiByZXF1ZQogICAgIHJldHVybiBwcml2LT51cmk7CiB9CiAKKy8qKgorICogd2Via2l0X25l dHdvcmtfcmVxdWVzdF9nZXRfc291cF9tZXNzYWdlOgorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5l dHdvcmtSZXF1ZXN0CisgKgorICogR2V0cyB0aGUgI1NvdXBNZXNzYWdlIGhlbGQgYW5kIHVzZWQg YnkgdGhlIGdpdmVuIHJlcXVlc3QuCisgKgorICogUmV0dXJuczogdGhlICNTb3VwTWVzc2FnZQor ICoKKyAqIFNpbmNlOiAxLjEuMQorICovCitHX0NPTlNUX1JFVFVSTiBTb3VwTWVzc2FnZSogd2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfc291cF9tZXNzYWdlKFdlYktpdE5ldHdvcmtSZXF1ZXN0 KiByZXF1ZXN0KQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JL X1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2 YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIHJldHVybiBwcml2LT5yZXF1ZXN0LT5z b3VwTWVzc2FnZSgpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfcmVmcmVz aDoKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICoKKyAqIE1ha2VzIHN1 cmUgV2ViS2l0IGtub3dzIGFib3V0IGFueSBjaGFuZ2VzIG1hZGUgdG8gaXRzICNTb3VwTWVzc2Fn ZSwKKyAqIG9idGFpbmVkIGJ5IGNhbGxpbmcgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfc291 cF9tZXNzYWdlKCkuCisgKgorICogU2luY2U6IDEuMS4xCisgKi8KK3ZvaWQgd2Via2l0X25ldHdv cmtfcmVxdWVzdF9yZWZyZXNoKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAg IGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CisK KyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2Owor CisgICAgcHJpdi0+cmVxdWVzdC0+cmVmcmVzaCgpOworfQorCiB9CmRpZmYgLS1naXQgYS9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oIGIvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0bmV0d29ya3JlcXVlc3QuaAppbmRleCAwMWFiOGJiLi5kMGU2ZWRjIDEwMDY0NAotLS0g YS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oCisrKyBiL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmgKQEAgLTIxLDYgKzIxLDggQEAKICNkZWZp bmUgV0VCS0lUX05FVFdPUktfUkVRVUVTVF9ICiAKICNpbmNsdWRlIDxnbGliLW9iamVjdC5oPgor I2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC1tZXNzYWdl Lmg+CiAKICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0ZGVmaW5lcy5oPgogCkBAIC02NSw2ICs2Nywx MiBAQCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF91cmkgIChXZWJLaXROZXR3b3JrUmVxdWVz dCAqcmVxdWVzdCwKIFdFQktJVF9BUEkgR19DT05TVF9SRVRVUk4gZ2NoYXIgKgogd2Via2l0X25l dHdvcmtfcmVxdWVzdF9nZXRfdXJpICAoV2ViS2l0TmV0d29ya1JlcXVlc3QgKnJlcXVlc3QpOwog CitXRUJLSVRfQVBJIEdfQ09OU1RfUkVUVVJOIFNvdXBNZXNzYWdlKgord2Via2l0X25ldHdvcmtf cmVxdWVzdF9nZXRfc291cF9tZXNzYWdlIChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7 CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X25ldHdvcmtfcmVxdWVzdF9yZWZyZXNoICAoV2Vi S2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCiBHX0VORF9ERUNMUwogCiAjZW5kaWYKZGlm ZiAtLWdpdCBhL1dlYktpdFRvb2xzL0dOVW1ha2VmaWxlLmFtIGIvV2ViS2l0VG9vbHMvR05VbWFr ZWZpbGUuYW0KaW5kZXggMjYyMDBjOC4uN2JiOWI4MyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMv R05VbWFrZWZpbGUuYW0KKysrIGIvV2ViS2l0VG9vbHMvR05VbWFrZWZpbGUuYW0KQEAgLTIwLDEx ICsyMCwxMyBAQCBQcm9ncmFtc19HdGtMYXVuY2hlcl9DRkxBR1MgPSBcCiAJLWZuby1zdHJpY3Qt YWxpYXNpbmcgXAogCS1PMiBcCiAJJChnbG9iYWxfY2ZsYWdzKSBcCi0JJChHVEtfQ0ZMQUdTKQor CSQoR1RLX0NGTEFHUykgXAorCSQoTElCU09VUF9DRkxBR1MpCiAKIFByb2dyYW1zX0d0a0xhdW5j aGVyX0xEQUREID0gXAogCWxpYndlYmtpdC0xLjAubGEgXAotCSQoR1RLX0xJQlMpCisJJChHVEtf TElCUykgXAorCSQoTElCU09VUF9MSUJTKQogCiAjIER1bXBSZW5kZXJUcmVlCiBQcm9ncmFtc19E dW1wUmVuZGVyVHJlZV9DUFBGTEFHUyA9IFwKQEAgLTY3LDEzICs2OSwxNSBAQCBQcm9ncmFtc19E dW1wUmVuZGVyVHJlZV9DRkxBR1MgPSBcCiAJJChnbG9iYWxfY2ZsYWdzKSBcCiAJJChHTE9CQUxE RVBTX0NGTEFHUykgXAogCSQoQ0FJUk9fQ0ZMQUdTKSBcCi0JJChHVEtfQ0ZMQUdTKQorCSQoR1RL X0NGTEFHUykgXAorCSQoTElCU09VUF9DRkxBR1MpCiAKIFByb2dyYW1zX0R1bXBSZW5kZXJUcmVl X0xEQUREID0gXAogCWxpYndlYmtpdC0xLjAubGEgXAogCSQoR0xPQkFMREVQU19MSUJTKSBcCiAJ JChDQUlST19MSUJTKSBcCi0JJChHVEtfTElCUykKKwkkKEdUS19MSUJTKSBcCisJJChMSUJTT1VQ X0xJQlMpCiAKICMgVGVzdE5ldHNjYXBlUGx1Z2luCiBUZXN0TmV0c2NhcGVQbHVnaW5fbGlidGVz dG5ldHNjYXBlcGx1Z2luX2xhX0NQUEZMQUdTID0gXApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMv R3RrTGF1bmNoZXIvbWFpbi5jIGIvV2ViS2l0VG9vbHMvR3RrTGF1bmNoZXIvbWFpbi5jCmluZGV4 IDhlZDI2OTAuLjQ3MDRhYjkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0d0a0xhdW5jaGVyL21h aW4uYworKysgYi9XZWJLaXRUb29scy9HdGtMYXVuY2hlci9tYWluLmMKQEAgLTI1LDYgKzI1LDgg QEAKICAqLwogCiAjaW5jbHVkZSA8Z3RrL2d0ay5oPgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC5o PgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC1tZXNzYWdlLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dl YmtpdC5oPgogCiBzdGF0aWMgR3RrV2lkZ2V0KiBtYWluX3dpbmRvdzsKQEAgLTY0LDYgKzY2LDE3 IEBAIGxpbmtfaG92ZXJfY2IgKFdlYktpdFdlYlZpZXcqIHBhZ2UsIGNvbnN0IGdjaGFyKiB0aXRs ZSwgY29uc3QgZ2NoYXIqIGxpbmssIGdwb2luCiAgICAgICAgIGd0a19zdGF0dXNiYXJfcHVzaCAo bWFpbl9zdGF0dXNiYXIsIHN0YXR1c19jb250ZXh0X2lkLCBsaW5rKTsKIH0KIAorc3RhdGljIGdi b29sZWFuCituYXZpZ2F0aW9uX2RlY2lzaW9uX2NiIChXZWJLaXRXZWJWaWV3KiB3ZWJfdmlldywg V2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgV2Vi S2l0V2ViTmF2aWdhdGlvbkFjdGlvbiogYWN0aW9uLCBXZWJLaXRXZWJQb2xpY3lEZWNpc2lvbiog ZGVjaXNpb24pCit7CisgICAgU291cE1lc3NhZ2UqIG1zZyA9IHdlYmtpdF9uZXR3b3JrX3JlcXVl c3RfZ2V0X3NvdXBfbWVzc2FnZSAocmVxdWVzdCk7CisgICAgZ19tZXNzYWdlICgiU291cCBtZXRo b2Q6ICVzIiwgbXNnLT5tZXRob2QpOworICAgIHNvdXBfbWVzc2FnZV9oZWFkZXJzX3JlcGxhY2Ug KG1zZy0+cmVxdWVzdF9oZWFkZXJzLCAiWC1XZWJLaXQiLCAidGVzdCIpOworICAgIHdlYmtpdF9u ZXR3b3JrX3JlcXVlc3RfcmVmcmVzaCAocmVxdWVzdCk7CisgICAgd2Via2l0X3dlYl9wb2xpY3lf ZGVjaXNpb25fdXNlIChkZWNpc2lvbik7CisgICAgcmV0dXJuIFRSVUU7Cit9CisKIHN0YXRpYyB2 b2lkCiB0aXRsZV9jaGFuZ2VfY2IgKFdlYktpdFdlYlZpZXcqIHdlYl92aWV3LCBXZWJLaXRXZWJG cmFtZSogd2ViX2ZyYW1lLCBjb25zdCBnY2hhciogdGl0bGUsIGdwb2ludGVyIGRhdGEpCiB7CkBA IC0xMTksNiArMTMyLDcgQEAgY3JlYXRlX2Jyb3dzZXIgKCkKICAgICBnX3NpZ25hbF9jb25uZWN0 IChHX09CSkVDVCAod2ViX3ZpZXcpLCAibG9hZC1wcm9ncmVzcy1jaGFuZ2VkIiwgR19DQUxMQkFD SyAocHJvZ3Jlc3NfY2hhbmdlX2NiKSwgd2ViX3ZpZXcpOwogICAgIGdfc2lnbmFsX2Nvbm5lY3Qg KEdfT0JKRUNUICh3ZWJfdmlldyksICJsb2FkLWNvbW1pdHRlZCIsIEdfQ0FMTEJBQ0sgKGxvYWRf Y29tbWl0X2NiKSwgd2ViX3ZpZXcpOwogICAgIGdfc2lnbmFsX2Nvbm5lY3QgKEdfT0JKRUNUICh3 ZWJfdmlldyksICJob3ZlcmluZy1vdmVyLWxpbmsiLCBHX0NBTExCQUNLIChsaW5rX2hvdmVyX2Ni KSwgd2ViX3ZpZXcpOworICAgIGdfc2lnbmFsX2Nvbm5lY3QgKEdfT0JKRUNUICh3ZWJfdmlldyks ICJuYXZpZ2F0aW9uLXBvbGljeS1kZWNpc2lvbi1yZXF1ZXN0ZWQiLCBHX0NBTExCQUNLIChuYXZp Z2F0aW9uX2RlY2lzaW9uX2NiKSwgd2ViX3ZpZXcpOwogCiAgICAgcmV0dXJuIHNjcm9sbGVkX3dp bmRvdzsKIH0KQEAgLTE4Miw2ICsxOTYsNyBAQCBjcmVhdGVfd2luZG93ICgpCiBpbnQKIG1haW4g KGludCBhcmdjLCBjaGFyKiBhcmd2W10pCiB7CisgICAgZ190aHJlYWRfaW5pdChOVUxMKTsKICAg ICBndGtfaW5pdCAoJmFyZ2MsICZhcmd2KTsKIAogICAgIEd0a1dpZGdldCogdmJveCA9IGd0a192 Ym94X25ldyAoRkFMU0UsIDApOwotLSAKMS41LjYuNQoK 28342 2009-03-05 17:43:37 -0800 2009-03-23 17:10:58 -0700 minimal functionality 0001-network-request-minimal-functionality.patch text/plain 12375 gustavo RnJvbSA3MWJiMGQ0NGVkNGRkNjAyZGU0NmMwNDFlZDhhZGE2OTAwN2I0MTM0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGtvdkBrb3YuZXRpLmJy PgpEYXRlOiBUaHUsIDE1IEphbiAyMDA5IDExOjI4OjM0IC0wMjAwClN1YmplY3Q6IFtQQVRDSF0g bmV0d29yayByZXF1ZXN0IG1pbmltYWwgZnVuY3Rpb25hbGl0eQoKLS0tCiBXZWJLaXQvZ3RrL0No YW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjUgKysrKysrCiBXZWJL aXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcCB8ICAgIDcgKy0K IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRvd25sb2FkLmNwcCAgICAgICAgICAgICAgIHwgICAg NCArLQogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwICAgICAgICAg fCAgIDc4ICsrKysrKysrKysrKysrKysrKy0KIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZh dGUuaCAgICAgICAgICAgICAgICAgIHwgICAxMSArKystCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXR3ZWJmcmFtZS5jcHAgICAgICAgICAgICAgICB8ICAgIDQgKy0KIDYgZmlsZXMgY2hhbmdlZCwg MTE0IGluc2VydGlvbnMoKyksIDE1IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1dlYktpdC9n dGsvQ2hhbmdlTG9nIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKaW5kZXggMmJjMmU4Yi4uNzVhMmEx NCAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2d0ay9DaGFu Z2VMb2cKQEAgLTEsMyArMSwyOCBAQAorMjAwOS0wMy0wNSAgR3VzdGF2byBOb3JvbmhhIFNpbHZh ICA8Z25zQGdub21lLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTg2MDgK KyAgICAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QgbmVlZHMgdG8gYmUgZmluaXNoZWQKKworICAg ICAgICBUaGlzIGNoYW5nZXNldCBpcyBjb25jZXJuZWQgd2l0aCBtYWtpbmcgV2ViS2l0TmV0d29y a1JlcXVlc3QgY2FycnkKKyAgICAgICAgUmVzb3VyY2VSZXF1ZXN0IGluIGFkZGl0aW9uIHRvIHNp bXBseSBzdG9yaW5nIHRoZSBVUkksIHdoaWNoCisgICAgICAgIGFsbG93cyB1cyB0byBnZXQgdGhl IGZ1bGwgaW5mb3JtYXRpb24gZmVkIGJhY2sgaW50byBXZWJLaXQgd2hlbgorICAgICAgICBuZWVk ZWQuIEZyYW1lTG9hZGVyQ2xpZW50R3RrIGlzIG5vdyB1c2luZyBXZWJLaXROZXR3b3JrUmVxdWVz dAorICAgICAgICB3aGVuIGl0IG5lZWRzIHRvIGRlYWwgd2l0aCByZXF1ZXN0IGluZm9ybWF0aW9u LgorCisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwOgor ICAgICAgICAoV2ViS2l0OjpGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEZWNpZGVQb2xpY3lG b3JOYXZpZ2F0aW9uQWN0aW9uKToKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0bmV0d29ya3JlcXVl c3QuY3BwOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25l dHdvcmtfcmVxdWVzdF9jbGFzc19pbml0KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVz dFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0KToK KyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X2NvcmVfcmVxdWVzdCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQ cml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ldyk6CisgICAgICAgIChfV2ViS2l0TmV0 d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF91cmkpOgorICAg ICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVz dF9nZXRfdXJpKToKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5oOgorICAgICAgICAq IHdlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHA6CisKIDIwMDktMDMtMDIgIFhhbiBMb3BleiAgPHhh bkBnbm9tZS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTWFyayBSb3dlLgpkaWZmIC0tZ2l0 IGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAgYi9X ZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAppbmRleCAy YWIzMDU2Li43M2YwNTIzIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50R3RrLmNwcAorKysgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50R3RrLmNwcApAQCAtNTQsNiArNTQsNyBAQAogI2luY2x1ZGUgIndlYmtp dHdlYmZyYW1lLmgiCiAjaW5jbHVkZSAid2Via2l0d2VibmF2aWdhdGlvbmFjdGlvbi5oIgogI2lu Y2x1ZGUgIndlYmtpdHdlYnBvbGljeWRlY2lzaW9uLmgiCisjaW5jbHVkZSAid2Via2l0bmV0d29y a3JlcXVlc3QuaCIKICNpbmNsdWRlICJ3ZWJraXRwcml2YXRlLmgiCiAKICNpbmNsdWRlIDxKYXZh U2NyaXB0Q29yZS9BUElDYXN0Lmg+CkBAIC0yODIsNyArMjgzLDcgQEAgdm9pZCBGcmFtZUxvYWRl ckNsaWVudDo6ZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JNSU1FVHlwZShGcmFtZVBvbGljeUZ1bmN0 aW9uIHBvbGkKICAgICB9CiAKICAgICBXZWJLaXRXZWJWaWV3KiBwYWdlID0gZ2V0Vmlld0Zyb21G cmFtZShtX2ZyYW1lKTsKLSAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdlYmtp dF9uZXR3b3JrX3JlcXVlc3RfbmV3KHJlc291cmNlUmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4 KCkuZGF0YSgpKTsKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdlYmtpdF9u ZXR3b3JrX3JlcXVlc3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0KHJlc291cmNlUmVxdWVzdCk7CiAK ICAgICBXZWJLaXRXZWJQb2xpY3lEZWNpc2lvbiogcG9saWN5RGVjaXNpb24gPSB3ZWJraXRfd2Vi X3BvbGljeV9kZWNpc2lvbl9uZXcobV9mcmFtZSwgcG9saWN5RnVuY3Rpb24pOwogICAgIGlmICht X3BvbGljeURlY2lzaW9uKQpAQCAtMzMxLDcgKzMzMiw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGll bnQ6OmRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlvbkFjdGlvbihGcmFtZVBvbGljeUZ1 bmN0CiAgICAgfQogCiAgICAgV2ViS2l0V2ViVmlldyogd2ViVmlldyA9IGdldFZpZXdGcm9tRnJh bWUobV9mcmFtZSk7Ci0gICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRf bmV0d29ya19yZXF1ZXN0X25ldyhyZXNvdXJjZVJlcXVlc3QudXJsKCkuc3RyaW5nKCkudXRmOCgp LmRhdGEoKSk7CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X25ld193aXRoX2NvcmVfcmVxdWVzdChyZXNvdXJjZVJlcXVlc3QpOwogICAg IFdlYktpdE5hdmlnYXRpb25SZXNwb25zZSByZXNwb25zZTsKICAgICAvKgogICAgICAqIFdlIHN0 aWxsIHN1cHBvcnQgdGhlIGRlcHJlY2F0ZWQgbmF2aWdhdGlvbi1yZXF1ZXN0ZWQgc2lnbmFsLCBp ZiB0aGUKQEAgLTg3MCw3ICs4NzEsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpzZXRNYWlu RG9jdW1lbnRFcnJvcihEb2N1bWVudExvYWRlciosIGNvbnN0IFJlc291cmNlRXJybwogCiB2b2lk IEZyYW1lTG9hZGVyQ2xpZW50OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYg cmVxdWVzdCkKIHsKLSAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogbmV0d29ya1JlcXVlc3QgPSB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ldyhyZXF1ZXN0LnVybCgpLnN0cmluZygpLnV0ZjgoKS5k YXRhKCkpOworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiBuZXR3b3JrUmVxdWVzdCA9IHdlYmtp dF9uZXR3b3JrX3JlcXVlc3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0KHJlcXVlc3QpOwogICAgIFdl YktpdERvd25sb2FkKiBkb3dubG9hZCA9IHdlYmtpdF9kb3dubG9hZF9uZXcobmV0d29ya1JlcXVl c3QpOwogICAgIGdfb2JqZWN0X3VucmVmKG5ldHdvcmtSZXF1ZXN0KTsKIApkaWZmIC0tZ2l0IGEv V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZG93bmxvYWQuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0ZG93bmxvYWQuY3BwCmluZGV4IDVmZThjMzMuLmI1M2ViZGMgMTAwNjQ0Ci0tLSBhL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdGRvd25sb2FkLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRkb3dubG9hZC5jcHAKQEAgLTM4Nyw5ICszODcsNyBAQCB2b2lkIHdlYmtpdF9kb3du bG9hZF9zdGFydChXZWJLaXREb3dubG9hZCogZG93bmxvYWQpCiAgICAgaWYgKHByaXYtPnJlc291 cmNlSGFuZGxlKQogICAgICAgICBwcml2LT5yZXNvdXJjZUhhbmRsZS0+c2V0Q2xpZW50KHByaXYt PmRvd25sb2FkQ2xpZW50KTsKICAgICBlbHNlIHsKLSAgICAgICAgLy8gRklYTUU6IFVzZSB0aGUg YWN0dWFsIHJlcXVlc3Qgb2JqZWN0IHdoZW4gV2ViS2l0TmV0d29ya1JlcXVlc3QgaXMgZmluaXNo ZWQuCi0gICAgICAgIFJlc291cmNlUmVxdWVzdCByZXF1ZXN0KHdlYmtpdF9uZXR3b3JrX3JlcXVl c3RfZ2V0X3VyaShwcml2LT5uZXR3b3JrUmVxdWVzdCkpOwotICAgICAgICBwcml2LT5yZXNvdXJj ZUhhbmRsZSA9IFJlc291cmNlSGFuZGxlOjpjcmVhdGUocmVxdWVzdCwgcHJpdi0+ZG93bmxvYWRD bGllbnQsIDAsIGZhbHNlLCBmYWxzZSwgZmFsc2UpOworICAgICAgICBwcml2LT5yZXNvdXJjZUhh bmRsZSA9IFJlc291cmNlSGFuZGxlOjpjcmVhdGUoKndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0 X2NvcmVfcmVxdWVzdChwcml2LT5uZXR3b3JrUmVxdWVzdCksIHByaXYtPmRvd25sb2FkQ2xpZW50 LCAwLCBmYWxzZSwgZmFsc2UsIGZhbHNlKTsKICAgICB9CiAKICAgICBwcml2LT50aW1lciA9IGdf dGltZXJfbmV3KCk7CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3Jr cmVxdWVzdC5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAK aW5kZXggM2FkOGI1ZC4uZmFlZWQ4NSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0bmV0d29ya3JlcXVlc3QuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdv cmtyZXF1ZXN0LmNwcApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDcs IDIwMDggSG9sZ2VyIEhhbnMgUGV0ZXIgRnJleXRoZXIKKyAqIENvcHlyaWdodCAoQykgMjAwOSBH dXN0YXZvIE5vcm9uaGEgU2lsdmEKICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2Fy ZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgKiBtb2RpZnkgaXQgdW5kZXIgdGhl IHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYwpAQCAtMTgsOSArMTksMTMg QEAKICAqLwogCiAjaW5jbHVkZSAiY29uZmlnLmgiCi0KICNpbmNsdWRlICJ3ZWJraXRuZXR3b3Jr cmVxdWVzdC5oIgogCisjaW5jbHVkZSAiQ1N0cmluZy5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3Ry aW5nLmgiCisjaW5jbHVkZSAiUmVzb3VyY2VSZXF1ZXN0LmgiCisjaW5jbHVkZSAid2Via2l0cHJp dmF0ZS5oIgorCiAvKioKICAqIFNFQ1RJT046d2Via2l0bmV0d29ya3JlcXVlc3QKICAqIEBzaG9y dF9kZXNjcmlwdGlvbjogVGhlIHRhcmdldCBvZiBhIG5hdmlnYXRpb24gcmVxdWVzdApAQCAtMzQs MTIgKzM5LDIwIEBACiAgKgogICovCiAKK3VzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOworCiBleHRl cm4gIkMiIHsKIAogR19ERUZJTkVfVFlQRShXZWJLaXROZXR3b3JrUmVxdWVzdCwgd2Via2l0X25l dHdvcmtfcmVxdWVzdCwgR19UWVBFX09CSkVDVCk7CiAKKy8vIFRoZSBtdXN0RnJlZVJlcXVlc3Qg dmFyaWFibGUgaGVyZSBpcyB1c2VkIHRvIHN0b3JlIGlmIHRoZQorLy8gUmVzb3VyY2VSZXF1ZXN0 IHdlIGFyZSBzdG9yaW5nIGlzIG93bmVkIGJ5IHVzIG9yIGJ5IFdlYkNvcmU7IHRoaXMKKy8vIHdv bid0IGJlIG5lZWRlZCB3aGVuL2lmIFJlc291cmNlUmVxdWVzdCBpcyByZWZlcmVuY2UgY291bnRl ZC4KIHN0cnVjdCBfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlIHsKICAgICBnY2hhciogdXJp OworCisgICAgUmVzb3VyY2VSZXF1ZXN0KiByZXF1ZXN0OworICAgIGdib29sZWFuIG11c3RGcmVl UmVxdWVzdDsKIH07CiAKICNkZWZpbmUgV0VCS0lUX05FVFdPUktfUkVRVUVTVF9HRVRfUFJJVkFU RShvYmopIChHX1RZUEVfSU5TVEFOQ0VfR0VUX1BSSVZBVEUoKG9iaiksIFdFQktJVF9UWVBFX05F VFdPUktfUkVRVUVTVCwgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKSkKQEAgLTUxLDEyICs2 NCwxNyBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2ZpbmFsaXplKEdPYmpl Y3QqIG9iamVjdCkKIAogICAgIGdfZnJlZShwcml2LT51cmkpOwogCisgICAgaWYgKHByaXYtPm11 c3RGcmVlUmVxdWVzdCkKKyAgICAgICAgZGVsZXRlIHByaXYtPnJlcXVlc3Q7CisKICAgICBHX09C SkVDVF9DTEFTUyh3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3BhcmVudF9jbGFzcyktPmZpbmFsaXpl KG9iamVjdCk7CiB9CiAKIHN0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfY2xhc3Nf aW5pdChXZWJLaXROZXR3b3JrUmVxdWVzdENsYXNzKiByZXF1ZXN0Q2xhc3MpCiB7Ci0gICAgR19P QkpFQ1RfQ0xBU1MocmVxdWVzdENsYXNzKS0+ZmluYWxpemUgPSB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X2ZpbmFsaXplOworICAgIEdPYmplY3RDbGFzcyogb2JqZWN0Q2xhc3MgPSBHX09CSkVDVF9D TEFTUyhyZXF1ZXN0Q2xhc3MpOworCisgICAgb2JqZWN0Q2xhc3MtPmZpbmFsaXplID0gd2Via2l0 X25ldHdvcmtfcmVxdWVzdF9maW5hbGl6ZTsKIAogICAgIGdfdHlwZV9jbGFzc19hZGRfcHJpdmF0 ZShyZXF1ZXN0Q2xhc3MsIHNpemVvZihXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUpKTsKIH0K QEAgLTY1LDIwICs4Myw2MiBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2lu aXQoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCiB7CiAgICAgV2ViS2l0TmV0d29ya1Jl cXVlc3RQcml2YXRlKiBwcml2ID0gV0VCS0lUX05FVFdPUktfUkVRVUVTVF9HRVRfUFJJVkFURShy ZXF1ZXN0KTsKICAgICByZXF1ZXN0LT5wcml2ID0gcHJpdjsKKworICAgIC8vIFdlIHVzdWFsbHkg Z2V0IGEgUmVzb3VyY2VSZXF1ZXN0IHRoYXQgaXMgb3duZWQgYnkgV2ViQ29yZSwgYW5kCisgICAg Ly8gd2UgbmVlZCBub3QgY2FyZSBhYm91dCBpdHMgbGlmZXRpbWUKKyAgICBwcml2LT5tdXN0RnJl ZVJlcXVlc3QgPSBGQUxTRTsKK30KKworLy8gZm9yIGludGVybmFsIHVzZSBvbmx5CitXZWJLaXRO ZXR3b3JrUmVxdWVzdCogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3JlX3JlcXVl c3QoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3QpCit7CisgICAgV2ViS2l0 TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSBXRUJLSVRfTkVUV09SS19SRVFVRVNUKGdfb2JqZWN0 X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIE5VTEwpKTsKKyAgICBXZWJLaXROZXR3 b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgcHJpdi0+cmVx dWVzdCA9ICYoY29uc3RfY2FzdDxSZXNvdXJjZVJlcXVlc3QmPihyZXNvdXJjZVJlcXVlc3QpKTsK KworICAgIHJldHVybiByZXF1ZXN0OworfQorCisvLyBmb3IgaW50ZXJuYWwgdXNlIG9ubHkKK1Jl c291cmNlUmVxdWVzdCogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfY29yZV9yZXF1ZXN0KGNv bnN0IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIFdlYktpdE5ldHdvcmtS ZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICByZXR1cm4gcHJpdi0+ cmVxdWVzdDsKIH0KIAorLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ldzoKKyAqIEB1 cmk6IGFuIFVSSQorICoKKyAqIENyZWF0ZXMgYSBuZXcgI1dlYktpdE5ldHdvcmtSZXF1ZXN0IGlu aXRpYWxpemVkIHdpdGggYW4gVVJJLgorICoKKyAqIFJldHVybnM6IGEgbmV3ICNXZWJLaXROZXR3 b3JrUmVxdWVzdAorICovCiBXZWJLaXROZXR3b3JrUmVxdWVzdCogd2Via2l0X25ldHdvcmtfcmVx dWVzdF9uZXcoY29uc3QgZ2NoYXIqIHVyaSkKIHsKICAgICBnX3JldHVybl92YWxfaWZfZmFpbCh1 cmksIE5VTEwpOwogCi0gICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSBXRUJLSVRf TkVUV09SS19SRVFVRVNUKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1Qs IE5VTEwpKTsKKyAgICBSZXNvdXJjZVJlcXVlc3QqIHJlc291cmNlUmVxdWVzdCA9IG5ldyBSZXNv dXJjZVJlcXVlc3QoS1VSTChTdHJpbmc6OmZyb21VVEY4KHVyaSkpKTsKKworICAgIFdlYktpdE5l dHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9j b3JlX3JlcXVlc3QoKGNvbnN0IFJlc291cmNlUmVxdWVzdCYpKnJlc291cmNlUmVxdWVzdCk7CiAg ICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKIAot ICAgIHByaXYtPnVyaSA9IGdfc3RyZHVwKHVyaSk7CisgICAgLy8gU2luY2Ugd2UgYXJlIGNyZWF0 aW5nIHRoaXMgUmVzb3VyY2VSZXF1ZXN0IG91cnNlbHZlcywgd2Ugd2lsbAorICAgIC8vIG5lZWQg dG8gZnJlZSBpdCBpbiBkaXNwb3NlLgorICAgIHByaXYtPm11c3RGcmVlUmVxdWVzdCA9IFRSVUU7 CiAKICAgICByZXR1cm4gcmVxdWVzdDsKIH0KIAorLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X3NldF91cmk6CisgKiBAcmVxdWVzdDogYSAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIEB1 cmk6IGFuIFVSSQorICoKKyAqIFNldHMgdGhlIFVSSSBoZWxkIGFuZCB1c2VkIGJ5IHRoZSBnaXZl biByZXF1ZXN0LgorICovCiB2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaShXZWJL aXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqIHVyaSkKIHsKICAgICBnX3Jl dHVybl9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCkpOwpAQCAtODcs MjIgKzE0NywzMCBAQCB2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaShXZWJLaXRO ZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgZ2NoYXIqCiAgICAgV2ViS2l0TmV0d29ya1Jl cXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKIAogICAgIGdfZnJlZShwcml2LT51 cmkpOwotICAgIHByaXYtPnVyaSA9IGdfc3RyZHVwKHVyaSk7CisgICAgcHJpdi0+cmVxdWVzdC0+ c2V0VVJMKEtVUkwoS1VSTCgpLCBTdHJpbmc6OmZyb21VVEY4KHVyaSkpKTsKIH0KIAogLyoqCiAg KiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF91cmk6CiAgKiBAcmVxdWVzdDogYSAjV2ViS2l0 TmV0d29ya1JlcXVlc3QKICAqCisgKiBHZXRzIHRoZSBVUkkgaGVsZCBhbmQgdXNlZCBieSB0aGUg Z2l2ZW4gcmVxdWVzdC4KKyAqCiAgKiBSZXR1cm5zOiB0aGUgdXJpIG9mIHRoZSAjV2ViS2l0TmV0 d29ya1JlcXVlc3QKICAqCiAgKiBTaW5jZTogMS4wLjAKKyAqCisgKiBSZXR1cm5zOiB0aGUgVVJJ IGhlbGQgYW5kIHVzZWQgYnkgdGhlIGdpdmVuIHJlcXVlc3QKICAqLwogR19DT05TVF9SRVRVUk4g Z2NoYXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShXZWJLaXROZXR3b3JrUmVxdWVz dCogcmVxdWVzdCkKIHsKICAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09S S19SRVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKIAogICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJp dmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBpZiAocHJpdi0+dXJpID09IE5VTEwp CisgICAgICAgIHByaXYtPnVyaSA9IGdfc3RyZHVwKHByaXYtPnJlcXVlc3QtPnVybCgpLnN0cmlu ZygpLnV0ZjgoKS5kYXRhKCkpOworCiAgICAgcmV0dXJuIHByaXYtPnVyaTsKIH0KIApkaWZmIC0t Z2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oIGIvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0cHJpdmF0ZS5oCmluZGV4IDUwMzliMzkuLjE3NGE5OTcgMTAwNjQ0Ci0tLSBhL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93 ZWJraXRwcml2YXRlLmgKQEAgLTIzLDcgKzIzLDggQEAKICNkZWZpbmUgV0VCS0lUX1BSSVZBVEVf SAogCiAvKgotICogVGhpcyBmaWxlIGtub3dzIHRoZSBzaGFyZWQgc2VjcmV0IG9mIFdlYktpdFdl YlZpZXcgYW5kIFdlYktpdFdlYkZyYW1lLgorICogVGhpcyBmaWxlIGtub3dzIHRoZSBzaGFyZWQg c2VjcmV0IG9mIFdlYktpdFdlYlZpZXcsIFdlYktpdFdlYkZyYW1lLAorICogYW5kIFdlYktpdE5l dHdvcmtSZXF1ZXN0LgogICogVGhleSBhcmUgdXNpbmcgV2ViQ29yZSB3aGljaCBtdXNuJ3QgYmUg ZXhwb3NlZCB0byB0aGUgb3V0ZXIgd29ybGQuCiAgKi8KIApAQCAtMzYsNiArMzcsNyBAQAogI2lu Y2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJzZXR0aW5ncy5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJr aXR3ZWJ3aW5kb3dmZWF0dXJlcy5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJiYWNrZm9y d2FyZGxpc3QuaD4KKyNpbmNsdWRlIDx3ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuaD4KIAog I2luY2x1ZGUgIkJhY2tGb3J3YXJkTGlzdC5oIgogI2luY2x1ZGUgIkhpc3RvcnlJdGVtLmgiCkBA IC00NSw2ICs0Nyw3IEBACiAjaW5jbHVkZSAiSW5zcGVjdG9yQ2xpZW50R3RrLmgiCiAjaW5jbHVk ZSAiRnJhbWVMb2FkZXJDbGllbnQuaCIKICNpbmNsdWRlICJSZXNvdXJjZUhhbmRsZS5oIgorI2lu Y2x1ZGUgIlJlc291cmNlUmVxdWVzdC5oIgogI2luY2x1ZGUgIlJlc291cmNlUmVzcG9uc2UuaCIK ICNpbmNsdWRlICJXaW5kb3dGZWF0dXJlcy5oIgogCkBAIC0xNjQsNiArMTY3LDEyIEBAIGV4dGVy biAiQyIgewogICAgIHZvaWQKICAgICB3ZWJraXRfd2ViX3BvbGljeV9kZWNpc2lvbl9jYW5jZWwg KFdlYktpdFdlYlBvbGljeURlY2lzaW9uKiBkZWNpc2lvbik7CiAKKyAgICBXZWJLaXROZXR3b3Jr UmVxdWVzdCoKKyAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2NvcmVfcmVxdWVz dChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCk7CisKKyAg ICBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QqCisgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9n ZXRfY29yZV9yZXF1ZXN0KGNvbnN0IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKwog ICAgIC8vIEZJWE1FOiBtb3ZlIHRoaXMgZnVuY3Rpb25hbGl0eSBpbnRvIGEgJ1dlYktpdFdlYkRh dGFTb3VyY2UnIG9uY2UgaW1wbGVtZW50ZWQKICAgICBXRUJLSVRfQVBJIGdjaGFyKgogICAgIHdl YmtpdF93ZWJfZnJhbWVfZ2V0X3Jlc3BvbnNlX21pbWVfdHlwZShXZWJLaXRXZWJGcmFtZSogZnJh bWUpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwIGIv V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCmluZGV4IGUyYjEwYjYuLjYzN2Y2 NjcgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcAorKysg Yi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKQEAgLTQ0OSw5ICs0NDksNyBA QCB2b2lkIHdlYmtpdF93ZWJfZnJhbWVfbG9hZF9yZXF1ZXN0KFdlYktpdFdlYkZyYW1lKiBmcmFt ZSwgV2ViS2l0TmV0d29ya1JlcXVlc3QqCiAgICAgaWYgKCFjb3JlRnJhbWUpCiAgICAgICAgIHJl dHVybjsKIAotICAgIC8vIFRPRE86IFVzZSB0aGUgUmVzb3VyY2VSZXF1ZXN0IGNhcnJpZWQgYnkg V2ViS2l0TmV0d29ya1JlcXVlc3Qgd2hlbiBpdCBpcyBpbXBsZW1lbnRlZC4KLSAgICBTdHJpbmcg c3RyaW5nID0gU3RyaW5nOjpmcm9tVVRGOCh3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF91cmko cmVxdWVzdCkpOwotICAgIGNvcmVGcmFtZS0+bG9hZGVyKCktPmxvYWQoUmVzb3VyY2VSZXF1ZXN0 KEtVUkwoS1VSTCgpLCBzdHJpbmcpKSwgZmFsc2UpOworICAgIGNvcmVGcmFtZS0+bG9hZGVyKCkt PmxvYWQoY29uc3RfY2FzdDxSZXNvdXJjZVJlcXVlc3QmPigqd2Via2l0X25ldHdvcmtfcmVxdWVz dF9nZXRfY29yZV9yZXF1ZXN0KHJlcXVlc3QpKSwgZmFsc2UpOwogfQogCiAvKioKLS0gCjEuNi4y LnJjMAoK 28877 2009-03-23 17:10:58 -0700 2009-03-24 07:44:52 -0700 minimal funcionality 0001-Make-our-NetworkRequest-object-functionally-complete.patch text/plain 10896 gustavo RnJvbSBhZWZiMTA2YzhmYWVmYWFmYjdkNTYwODhhMzM5OGY3ZDk1ZmI5MDM0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGtvdkBrb3YuZXRpLmJy PgpEYXRlOiBNb24sIDIzIE1hciAyMDA5IDIwOjU3OjU2IC0wMzAwClN1YmplY3Q6IFtQQVRDSCAx LzJdIE1ha2Ugb3VyIE5ldHdvcmtSZXF1ZXN0IG9iamVjdCBmdW5jdGlvbmFsbHkgY29tcGxldGUs IGJ5IG1ha2luZyBpdAogY2FycnkgdGhlIFJlc291cmNlUmVxdWVzdCBpdCByZXByZXNlbnRzIHdp dGggaXQuCgotLS0KIFdlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRH dGsuY3BwIHwgICAgNyArLQogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZG93bmxvYWQuY3BwICAg ICAgICAgICAgICAgfCAgICA0ICstCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVx dWVzdC5jcHAgICAgICAgICB8ICAgNzggKysrKysrKysrKysrKysrKysrLQogV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0cHJpdmF0ZS5oICAgICAgICAgICAgICAgICAgfCAgIDExICsrKy0KIFdlYktp dC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcCAgICAgICAgICAgICAgIHwgICAgNCArLQog NSBmaWxlcyBjaGFuZ2VkLCA4OSBpbnNlcnRpb25zKCspLCAxNSBkZWxldGlvbnMoLSkKCmRpZmYg LS1naXQgYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNw cCBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCmlu ZGV4IDhlMmMwMGMuLmMwY2Y0NjMgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBv cnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCisrKyBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBv cnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCkBAIC01NCw2ICs1NCw3IEBACiAjaW5jbHVkZSAi d2Via2l0d2ViZnJhbWUuaCIKICNpbmNsdWRlICJ3ZWJraXR3ZWJuYXZpZ2F0aW9uYWN0aW9uLmgi CiAjaW5jbHVkZSAid2Via2l0d2VicG9saWN5ZGVjaXNpb24uaCIKKyNpbmNsdWRlICJ3ZWJraXRu ZXR3b3JrcmVxdWVzdC5oIgogI2luY2x1ZGUgIndlYmtpdHByaXZhdGUuaCIKIAogI2luY2x1ZGUg PEphdmFTY3JpcHRDb3JlL0FQSUNhc3QuaD4KQEAgLTI4Miw3ICsyODMsNyBAQCB2b2lkIEZyYW1l TG9hZGVyQ2xpZW50OjpkaXNwYXRjaERlY2lkZVBvbGljeUZvck1JTUVUeXBlKEZyYW1lUG9saWN5 RnVuY3Rpb24gcG9saQogICAgIH0KIAogICAgIFdlYktpdFdlYlZpZXcqIHBhZ2UgPSBnZXRWaWV3 RnJvbUZyYW1lKG1fZnJhbWUpOwotICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0g d2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXcocmVzb3VyY2VSZXF1ZXN0LnVybCgpLnN0cmluZygp LnV0ZjgoKS5kYXRhKCkpOworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3JlX3JlcXVlc3QocmVzb3VyY2VSZXF1ZXN0 KTsKIAogICAgIFdlYktpdFdlYlBvbGljeURlY2lzaW9uKiBwb2xpY3lEZWNpc2lvbiA9IHdlYmtp dF93ZWJfcG9saWN5X2RlY2lzaW9uX25ldyhtX2ZyYW1lLCBwb2xpY3lGdW5jdGlvbik7CiAgICAg aWYgKG1fcG9saWN5RGVjaXNpb24pCkBAIC0zMzEsNyArMzMyLDcgQEAgdm9pZCBGcmFtZUxvYWRl ckNsaWVudDo6ZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JOYXZpZ2F0aW9uQWN0aW9uKEZyYW1lUG9s aWN5RnVuY3QKICAgICB9CiAKICAgICBXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3ID0gZ2V0Vmlld0Zy b21GcmFtZShtX2ZyYW1lKTsKLSAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdl YmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3KHJlc291cmNlUmVxdWVzdC51cmwoKS5zdHJpbmcoKS51 dGY4KCkuZGF0YSgpKTsKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdlYmtp dF9uZXR3b3JrX3JlcXVlc3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0KHJlc291cmNlUmVxdWVzdCk7 CiAgICAgV2ViS2l0TmF2aWdhdGlvblJlc3BvbnNlIHJlc3BvbnNlOwogICAgIC8qCiAgICAgICog V2Ugc3RpbGwgc3VwcG9ydCB0aGUgZGVwcmVjYXRlZCBuYXZpZ2F0aW9uLXJlcXVlc3RlZCBzaWdu YWwsIGlmIHRoZQpAQCAtODkzLDcgKzg5NCw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnNl dE1haW5Eb2N1bWVudEVycm9yKERvY3VtZW50TG9hZGVyKiwgY29uc3QgUmVzb3VyY2VFcnJvCiAK IHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1 ZXN0JiByZXF1ZXN0KQogewotICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiBuZXR3b3JrUmVxdWVz dCA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3KHJlcXVlc3QudXJsKCkuc3RyaW5nKCkudXRm OCgpLmRhdGEoKSk7CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIG5ldHdvcmtSZXF1ZXN0ID0g d2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3JlX3JlcXVlc3QocmVxdWVzdCk7CiAg ICAgV2ViS2l0RG93bmxvYWQqIGRvd25sb2FkID0gd2Via2l0X2Rvd25sb2FkX25ldyhuZXR3b3Jr UmVxdWVzdCk7CiAgICAgZ19vYmplY3RfdW5yZWYobmV0d29ya1JlcXVlc3QpOwogCmRpZmYgLS1n aXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRkb3dubG9hZC5jcHAgYi9XZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXRkb3dubG9hZC5jcHAKaW5kZXggNDQ4ODMwNC4uM2JjZWVkYyAxMDA2NDQKLS0t IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZG93bmxvYWQuY3BwCisrKyBiL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdGRvd25sb2FkLmNwcApAQCAtNDE2LDkgKzQxNiw3IEBAIHZvaWQgd2Via2l0 X2Rvd25sb2FkX3N0YXJ0KFdlYktpdERvd25sb2FkKiBkb3dubG9hZCkKICAgICBpZiAocHJpdi0+ cmVzb3VyY2VIYW5kbGUpCiAgICAgICAgIHByaXYtPnJlc291cmNlSGFuZGxlLT5zZXRDbGllbnQo cHJpdi0+ZG93bmxvYWRDbGllbnQpOwogICAgIGVsc2UgewotICAgICAgICAvLyBGSVhNRTogVXNl IHRoZSBhY3R1YWwgcmVxdWVzdCBvYmplY3Qgd2hlbiBXZWJLaXROZXR3b3JrUmVxdWVzdCBpcyBm aW5pc2hlZC4KLSAgICAgICAgUmVzb3VyY2VSZXF1ZXN0IHJlcXVlc3Qod2Via2l0X25ldHdvcmtf cmVxdWVzdF9nZXRfdXJpKHByaXYtPm5ldHdvcmtSZXF1ZXN0KSk7Ci0gICAgICAgIHByaXYtPnJl c291cmNlSGFuZGxlID0gUmVzb3VyY2VIYW5kbGU6OmNyZWF0ZShyZXF1ZXN0LCBwcml2LT5kb3du bG9hZENsaWVudCwgMCwgZmFsc2UsIGZhbHNlLCBmYWxzZSk7CisgICAgICAgIHByaXYtPnJlc291 cmNlSGFuZGxlID0gUmVzb3VyY2VIYW5kbGU6OmNyZWF0ZSgqd2Via2l0X25ldHdvcmtfcmVxdWVz dF9nZXRfY29yZV9yZXF1ZXN0KHByaXYtPm5ldHdvcmtSZXF1ZXN0KSwgcHJpdi0+ZG93bmxvYWRD bGllbnQsIDAsIGZhbHNlLCBmYWxzZSwgZmFsc2UpOwogICAgIH0KIAogICAgIHByaXYtPnRpbWVy ID0gZ190aW1lcl9uZXcoKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5l dHdvcmtyZXF1ZXN0LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0 LmNwcAppbmRleCAzYWQ4YjVkLi5mYWVlZDg1IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 bmV0d29ya3JlcXVlc3QuY3BwCkBAIC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykg MjAwNywgMjAwOCBIb2xnZXIgSGFucyBQZXRlciBGcmV5dGhlcgorICogQ29weXJpZ2h0IChDKSAy MDA5IEd1c3Rhdm8gTm9yb25oYSBTaWx2YQogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNv ZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlmeSBpdCB1bmRl ciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCkBAIC0xOCw5ICsx OSwxMyBAQAogICovCiAKICNpbmNsdWRlICJjb25maWcuaCIKLQogI2luY2x1ZGUgIndlYmtpdG5l dHdvcmtyZXF1ZXN0LmgiCiAKKyNpbmNsdWRlICJDU3RyaW5nLmgiCisjaW5jbHVkZSAiUGxhdGZv cm1TdHJpbmcuaCIKKyNpbmNsdWRlICJSZXNvdXJjZVJlcXVlc3QuaCIKKyNpbmNsdWRlICJ3ZWJr aXRwcml2YXRlLmgiCisKIC8qKgogICogU0VDVElPTjp3ZWJraXRuZXR3b3JrcmVxdWVzdAogICog QHNob3J0X2Rlc2NyaXB0aW9uOiBUaGUgdGFyZ2V0IG9mIGEgbmF2aWdhdGlvbiByZXF1ZXN0CkBA IC0zNCwxMiArMzksMjAgQEAKICAqCiAgKi8KIAordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisK IGV4dGVybiAiQyIgewogCiBHX0RFRklORV9UWVBFKFdlYktpdE5ldHdvcmtSZXF1ZXN0LCB3ZWJr aXRfbmV0d29ya19yZXF1ZXN0LCBHX1RZUEVfT0JKRUNUKTsKIAorLy8gVGhlIG11c3RGcmVlUmVx dWVzdCB2YXJpYWJsZSBoZXJlIGlzIHVzZWQgdG8gc3RvcmUgaWYgdGhlCisvLyBSZXNvdXJjZVJl cXVlc3Qgd2UgYXJlIHN0b3JpbmcgaXMgb3duZWQgYnkgdXMgb3IgYnkgV2ViQ29yZTsgdGhpcwor Ly8gd29uJ3QgYmUgbmVlZGVkIHdoZW4vaWYgUmVzb3VyY2VSZXF1ZXN0IGlzIHJlZmVyZW5jZSBj b3VudGVkLgogc3RydWN0IF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUgewogICAgIGdjaGFy KiB1cmk7CisKKyAgICBSZXNvdXJjZVJlcXVlc3QqIHJlcXVlc3Q7CisgICAgZ2Jvb2xlYW4gbXVz dEZyZWVSZXF1ZXN0OwogfTsKIAogI2RlZmluZSBXRUJLSVRfTkVUV09SS19SRVFVRVNUX0dFVF9Q UklWQVRFKG9iaikgKEdfVFlQRV9JTlNUQU5DRV9HRVRfUFJJVkFURSgob2JqKSwgV0VCS0lUX1RZ UEVfTkVUV09SS19SRVFVRVNULCBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUpKQpAQCAtNTEs MTIgKzY0LDE3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZmluYWxpemUo R09iamVjdCogb2JqZWN0KQogCiAgICAgZ19mcmVlKHByaXYtPnVyaSk7CiAKKyAgICBpZiAocHJp di0+bXVzdEZyZWVSZXF1ZXN0KQorICAgICAgICBkZWxldGUgcHJpdi0+cmVxdWVzdDsKKwogICAg IEdfT0JKRUNUX0NMQVNTKHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfcGFyZW50X2NsYXNzKS0+Zmlu YWxpemUob2JqZWN0KTsKIH0KIAogc3RhdGljIHZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9j bGFzc19pbml0KFdlYktpdE5ldHdvcmtSZXF1ZXN0Q2xhc3MqIHJlcXVlc3RDbGFzcykKIHsKLSAg ICBHX09CSkVDVF9DTEFTUyhyZXF1ZXN0Q2xhc3MpLT5maW5hbGl6ZSA9IHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfZmluYWxpemU7CisgICAgR09iamVjdENsYXNzKiBvYmplY3RDbGFzcyA9IEdfT0JK RUNUX0NMQVNTKHJlcXVlc3RDbGFzcyk7CisKKyAgICBvYmplY3RDbGFzcy0+ZmluYWxpemUgPSB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X2ZpbmFsaXplOwogCiAgICAgZ190eXBlX2NsYXNzX2FkZF9w cml2YXRlKHJlcXVlc3RDbGFzcywgc2l6ZW9mKFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSkp OwogfQpAQCAtNjUsMjAgKzgzLDYyIEBAIHN0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVl c3RfaW5pdChXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKIHsKICAgICBXZWJLaXROZXR3 b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSBXRUJLSVRfTkVUV09SS19SRVFVRVNUX0dFVF9QUklW QVRFKHJlcXVlc3QpOwogICAgIHJlcXVlc3QtPnByaXYgPSBwcml2OworCisgICAgLy8gV2UgdXN1 YWxseSBnZXQgYSBSZXNvdXJjZVJlcXVlc3QgdGhhdCBpcyBvd25lZCBieSBXZWJDb3JlLCBhbmQK KyAgICAvLyB3ZSBuZWVkIG5vdCBjYXJlIGFib3V0IGl0cyBsaWZldGltZQorICAgIHByaXYtPm11 c3RGcmVlUmVxdWVzdCA9IEZBTFNFOworfQorCisvLyBmb3IgaW50ZXJuYWwgdXNlIG9ubHkKK1dl YktpdE5ldHdvcmtSZXF1ZXN0KiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2NvcmVf cmVxdWVzdChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCkKK3sKKyAgICBX ZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IFdFQktJVF9ORVRXT1JLX1JFUVVFU1QoZ19v YmplY3RfbmV3KFdFQktJVF9UWVBFX05FVFdPUktfUkVRVUVTVCwgTlVMTCkpOworICAgIFdlYktp dE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBwcml2 LT5yZXF1ZXN0ID0gJihjb25zdF9jYXN0PFJlc291cmNlUmVxdWVzdCY+KHJlc291cmNlUmVxdWVz dCkpOworCisgICAgcmV0dXJuIHJlcXVlc3Q7Cit9CisKKy8vIGZvciBpbnRlcm5hbCB1c2Ugb25s eQorUmVzb3VyY2VSZXF1ZXN0KiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9jb3JlX3JlcXVl c3QoY29uc3QgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgV2ViS2l0TmV0 d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIHJldHVybiBw cml2LT5yZXF1ZXN0OwogfQogCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3Ogor ICogQHVyaTogYW4gVVJJCisgKgorICogQ3JlYXRlcyBhIG5ldyAjV2ViS2l0TmV0d29ya1JlcXVl c3QgaW5pdGlhbGl6ZWQgd2l0aCBhbiBVUkkuCisgKgorICogUmV0dXJuczogYSBuZXcgI1dlYktp dE5ldHdvcmtSZXF1ZXN0CisgKi8KIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiB3ZWJraXRfbmV0d29y a19yZXF1ZXN0X25ldyhjb25zdCBnY2hhciogdXJpKQogewogICAgIGdfcmV0dXJuX3ZhbF9pZl9m YWlsKHVyaSwgTlVMTCk7CiAKLSAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IFdF QktJVF9ORVRXT1JLX1JFUVVFU1QoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX05FVFdPUktfUkVR VUVTVCwgTlVMTCkpOworICAgIFJlc291cmNlUmVxdWVzdCogcmVzb3VyY2VSZXF1ZXN0ID0gbmV3 IFJlc291cmNlUmVxdWVzdChLVVJMKFN0cmluZzo6ZnJvbVVURjgodXJpKSkpOworCisgICAgV2Vi S2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld193 aXRoX2NvcmVfcmVxdWVzdCgoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JikqcmVzb3VyY2VSZXF1ZXN0 KTsKICAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2 OwogCi0gICAgcHJpdi0+dXJpID0gZ19zdHJkdXAodXJpKTsKKyAgICAvLyBTaW5jZSB3ZSBhcmUg Y3JlYXRpbmcgdGhpcyBSZXNvdXJjZVJlcXVlc3Qgb3Vyc2VsdmVzLCB3ZSB3aWxsCisgICAgLy8g bmVlZCB0byBmcmVlIGl0IGluIGRpc3Bvc2UuCisgICAgcHJpdi0+bXVzdEZyZWVSZXF1ZXN0ID0g VFJVRTsKIAogICAgIHJldHVybiByZXF1ZXN0OwogfQogCisvKioKKyAqIHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3Rfc2V0X3VyaToKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAor ICogQHVyaTogYW4gVVJJCisgKgorICogU2V0cyB0aGUgVVJJIGhlbGQgYW5kIHVzZWQgYnkgdGhl IGdpdmVuIHJlcXVlc3QuCisgKi8KIHZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJp KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciogdXJpKQogewogICAg IGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CkBA IC04NywyMiArMTQ3LDMwIEBAIHZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpKFdl YktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhcioKICAgICBXZWJLaXROZXR3 b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OwogCiAgICAgZ19mcmVlKHBy aXYtPnVyaSk7Ci0gICAgcHJpdi0+dXJpID0gZ19zdHJkdXAodXJpKTsKKyAgICBwcml2LT5yZXF1 ZXN0LT5zZXRVUkwoS1VSTChLVVJMKCksIFN0cmluZzo6ZnJvbVVURjgodXJpKSkpOwogfQogCiAv KioKICAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaToKICAqIEByZXF1ZXN0OiBhICNX ZWJLaXROZXR3b3JrUmVxdWVzdAogICoKKyAqIEdldHMgdGhlIFVSSSBoZWxkIGFuZCB1c2VkIGJ5 IHRoZSBnaXZlbiByZXF1ZXN0LgorICoKICAqIFJldHVybnM6IHRoZSB1cmkgb2YgdGhlICNXZWJL aXROZXR3b3JrUmVxdWVzdAogICoKICAqIFNpbmNlOiAxLjAuMAorICoKKyAqIFJldHVybnM6IHRo ZSBVUkkgaGVsZCBhbmQgdXNlZCBieSB0aGUgZ2l2ZW4gcmVxdWVzdAogICovCiBHX0NPTlNUX1JF VFVSTiBnY2hhciogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJpKFdlYktpdE5ldHdvcmtS ZXF1ZXN0KiByZXF1ZXN0KQogewogICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19O RVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOwogCiAgICAgV2ViS2l0TmV0d29ya1JlcXVl c3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIGlmIChwcml2LT51cmkgPT0g TlVMTCkKKyAgICAgICAgcHJpdi0+dXJpID0gZ19zdHJkdXAocHJpdi0+cmVxdWVzdC0+dXJsKCku c3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisKICAgICByZXR1cm4gcHJpdi0+dXJpOwogfQogCmRp ZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXRwcml2YXRlLmgKaW5kZXggMGI4M2ExMS4uMDFiZDM4NCAxMDA2NDQKLS0t IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdHByaXZhdGUuaApAQCAtMjMsNyArMjMsOCBAQAogI2RlZmluZSBXRUJLSVRfUFJJ VkFURV9ICiAKIC8qCi0gKiBUaGlzIGZpbGUga25vd3MgdGhlIHNoYXJlZCBzZWNyZXQgb2YgV2Vi S2l0V2ViVmlldyBhbmQgV2ViS2l0V2ViRnJhbWUuCisgKiBUaGlzIGZpbGUga25vd3MgdGhlIHNo YXJlZCBzZWNyZXQgb2YgV2ViS2l0V2ViVmlldywgV2ViS2l0V2ViRnJhbWUsCisgKiBhbmQgV2Vi S2l0TmV0d29ya1JlcXVlc3QuCiAgKiBUaGV5IGFyZSB1c2luZyBXZWJDb3JlIHdoaWNoIG11c24n dCBiZSBleHBvc2VkIHRvIHRoZSBvdXRlciB3b3JsZC4KICAqLwogCkBAIC0zNiw2ICszNyw3IEBA CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYnNldHRpbmdzLmg+CiAjaW5jbHVkZSA8d2Via2l0 L3dlYmtpdHdlYndpbmRvd2ZlYXR1cmVzLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYmJh Y2tmb3J3YXJkbGlzdC5oPgorI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5o PgogCiAjaW5jbHVkZSAiQmFja0ZvcndhcmRMaXN0LmgiCiAjaW5jbHVkZSAiSGlzdG9yeUl0ZW0u aCIKQEAgLTQ1LDYgKzQ3LDcgQEAKICNpbmNsdWRlICJJbnNwZWN0b3JDbGllbnRHdGsuaCIKICNp bmNsdWRlICJGcmFtZUxvYWRlckNsaWVudC5oIgogI2luY2x1ZGUgIlJlc291cmNlSGFuZGxlLmgi CisjaW5jbHVkZSAiUmVzb3VyY2VSZXF1ZXN0LmgiCiAjaW5jbHVkZSAiUmVzb3VyY2VSZXNwb25z ZS5oIgogI2luY2x1ZGUgIldpbmRvd0ZlYXR1cmVzLmgiCiAKQEAgLTE2NCw2ICsxNjcsMTIgQEAg ZXh0ZXJuICJDIiB7CiAgICAgdm9pZAogICAgIHdlYmtpdF93ZWJfcG9saWN5X2RlY2lzaW9uX2Nh bmNlbCAoV2ViS2l0V2ViUG9saWN5RGVjaXNpb24qIGRlY2lzaW9uKTsKIAorICAgIFdlYktpdE5l dHdvcmtSZXF1ZXN0KgorICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X3dpdGhfY29yZV9y ZXF1ZXN0KGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0KTsK KworICAgIFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCoKKyAgICB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X2dldF9jb3JlX3JlcXVlc3QoY29uc3QgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3Qp OworCiAgICAgLy8gRklYTUU6IG1vdmUgdGhpcyBmdW5jdGlvbmFsaXR5IGludG8gYSAnV2ViS2l0 V2ViRGF0YVNvdXJjZScgb25jZSBpbXBsZW1lbnRlZAogICAgIFdFQktJVF9BUEkgZ2NoYXIqCiAg ICAgd2Via2l0X3dlYl9mcmFtZV9nZXRfcmVzcG9uc2VfbWltZV90eXBlKFdlYktpdFdlYkZyYW1l KiBmcmFtZSk7CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5j cHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKaW5kZXggZTJiMTBiNi4u NjM3ZjY2NyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3Bw CisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcApAQCAtNDQ5LDkgKzQ0 OSw3IEBAIHZvaWQgd2Via2l0X3dlYl9mcmFtZV9sb2FkX3JlcXVlc3QoV2ViS2l0V2ViRnJhbWUq IGZyYW1lLCBXZWJLaXROZXR3b3JrUmVxdWVzdCoKICAgICBpZiAoIWNvcmVGcmFtZSkKICAgICAg ICAgcmV0dXJuOwogCi0gICAgLy8gVE9ETzogVXNlIHRoZSBSZXNvdXJjZVJlcXVlc3QgY2Fycmll ZCBieSBXZWJLaXROZXR3b3JrUmVxdWVzdCB3aGVuIGl0IGlzIGltcGxlbWVudGVkLgotICAgIFN0 cmluZyBzdHJpbmcgPSBTdHJpbmc6OmZyb21VVEY4KHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0 X3VyaShyZXF1ZXN0KSk7Ci0gICAgY29yZUZyYW1lLT5sb2FkZXIoKS0+bG9hZChSZXNvdXJjZVJl cXVlc3QoS1VSTChLVVJMKCksIHN0cmluZykpLCBmYWxzZSk7CisgICAgY29yZUZyYW1lLT5sb2Fk ZXIoKS0+bG9hZChjb25zdF9jYXN0PFJlc291cmNlUmVxdWVzdCY+KCp3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X2dldF9jb3JlX3JlcXVlc3QocmVxdWVzdCkpLCBmYWxzZSk7CiB9CiAKIC8qKgotLSAK MS42LjIuMQoK 28878 2009-03-23 17:11:54 -0700 2009-03-24 07:44:58 -0700 expose SoupMessage 0002-Expose-the-SoupMessage-of-the-request-through-our-We.patch text/plain 9702 gustavo RnJvbSA4MzRmYzJjODI5YzQ1N2Q1ZWE5M2QxMGQ5Y2YzOTAzYTczZDc4YzRmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGtvdkBrb3YuZXRpLmJy PgpEYXRlOiBNb24sIDIzIE1hciAyMDA5IDIwOjU4OjU1IC0wMzAwClN1YmplY3Q6IFtQQVRDSCAy LzJdIEV4cG9zZSB0aGUgU291cE1lc3NhZ2Ugb2YgdGhlIHJlcXVlc3QgdGhyb3VnaCBvdXIgV2Vi S2l0TmV0d29ya1JlcXVlc3QKIG9iamVjdC4KCi0tLQogV2ViQ29yZS9HTlVtYWtlZmlsZS5hbSAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIC4uLi9wbGF0Zm9ybS9uZXR3b3Jr L3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcCAgIHwgICAxMCArLS0KIFdlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdC5oICAgIHwgICAyMCArKysrLQogLi4uL3Bs YXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3RTb3VwLmNwcCAgfCAgIDkyICsrKysr KysrKysrKysrKysrKysrCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5j cHAgICAgICAgICB8ICAgMjQgKysrKysKIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmty ZXF1ZXN0LmggICAgICAgICAgIHwgICAgNSArCiA2IGZpbGVzIGNoYW5nZWQsIDE0MSBpbnNlcnRp b25zKCspLCAxMSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBXZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3RTb3VwLmNwcAoKZGlmZiAtLWdpdCBhL1dl YkNvcmUvR05VbWFrZWZpbGUuYW0gYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCmluZGV4IGZmYWYx YjIuLjM0ZjJkOWEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KKysrIGIvV2Vi Q29yZS9HTlVtYWtlZmlsZS5hbQpAQCAtMTgzOSw2ICsxODM5LDcgQEAgd2ViY29yZV9zb3VyY2Vz ICs9IFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9ETlNTb3VwLmNwcCBcCiAJV2Vi Q29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VFcnJvci5oIFwKIAlXZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwIFwKKwlXZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3RTb3VwLmNwcCBcCiAJV2ViQ29yZS9w bGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0LmggXAogCVdlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVzcG9uc2UuaAogCmRpZmYgLS1naXQgYS9XZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwIGIvV2ViQ29yZS9w bGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcAppbmRleCBiMmI5ODFi Li4zNmJjMjhlIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNv dXJjZUhhbmRsZVNvdXAuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jl c291cmNlSGFuZGxlU291cC5jcHAKQEAgLTQxMiwyMSArNDEyLDEzIEBAIGJvb2wgUmVzb3VyY2VI YW5kbGU6OnN0YXJ0SHR0cChTdHJpbmcgdXJsU3RyaW5nKQogICAgIFNvdXBTZXNzaW9uKiBzZXNz aW9uID0gZGVmYXVsdFNlc3Npb24oKTsKICAgICBlbnN1cmVTZXNzaW9uSXNJbml0aWFsaXplZChz ZXNzaW9uKTsKIAotICAgIFNvdXBNZXNzYWdlKiBtc2c7Ci0gICAgbXNnID0gc291cF9tZXNzYWdl X25ldyhyZXF1ZXN0KCkuaHR0cE1ldGhvZCgpLnV0ZjgoKS5kYXRhKCksIHVybFN0cmluZy51dGY4 KCkuZGF0YSgpKTsKKyAgICBTb3VwTWVzc2FnZSogbXNnID0gcmVxdWVzdCgpLnNvdXBNZXNzYWdl KCk7CiAgICAgZ19zaWduYWxfY29ubmVjdChtc2csICJyZXN0YXJ0ZWQiLCBHX0NBTExCQUNLKHJl c3RhcnRlZENhbGxiYWNrKSwgdGhpcyk7CiAgICAgZ19zaWduYWxfY29ubmVjdChtc2csICJnb3Qt aGVhZGVycyIsIEdfQ0FMTEJBQ0soZ290SGVhZGVyc0NhbGxiYWNrKSwgdGhpcyk7CiAgICAgZ19z aWduYWxfY29ubmVjdChtc2csICJnb3QtY2h1bmsiLCBHX0NBTExCQUNLKGdvdENodW5rQ2FsbGJh Y2spLCB0aGlzKTsKIAogICAgIGdfb2JqZWN0X3NldF9kYXRhKEdfT0JKRUNUKG1zZyksICJyZXNv dXJjZUhhbmRsZSIsIHJlaW50ZXJwcmV0X2Nhc3Q8dm9pZCo+KHRoaXMpKTsKIAotICAgIEhUVFBI ZWFkZXJNYXAgY3VzdG9tSGVhZGVycyA9IGQtPm1fcmVxdWVzdC5odHRwSGVhZGVyRmllbGRzKCk7 Ci0gICAgaWYgKCFjdXN0b21IZWFkZXJzLmlzRW1wdHkoKSkgewotICAgICAgICBIVFRQSGVhZGVy TWFwOjpjb25zdF9pdGVyYXRvciBlbmQgPSBjdXN0b21IZWFkZXJzLmVuZCgpOwotICAgICAgICBm b3IgKEhUVFBIZWFkZXJNYXA6OmNvbnN0X2l0ZXJhdG9yIGl0ID0gY3VzdG9tSGVhZGVycy5iZWdp bigpOyBpdCAhPSBlbmQ7ICsraXQpCi0gICAgICAgICAgICBzb3VwX21lc3NhZ2VfaGVhZGVyc19h cHBlbmQobXNnLT5yZXF1ZXN0X2hlYWRlcnMsIGl0LT5maXJzdC5zdHJpbmcoKS51dGY4KCkuZGF0 YSgpLCBpdC0+c2Vjb25kLnV0ZjgoKS5kYXRhKCkpOwotICAgIH0KLQogICAgIEZvcm1EYXRhKiBo dHRwQm9keSA9IGQtPm1fcmVxdWVzdC5odHRwQm9keSgpOwogICAgIGlmIChodHRwQm9keSAmJiAh aHR0cEJvZHktPmlzRW1wdHkoKSkgewogICAgICAgICBzaXplX3QgbnVtRWxlbWVudHMgPSBodHRw Qm9keS0+ZWxlbWVudHMoKS5zaXplKCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25l dHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3QuaCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9z b3VwL1Jlc291cmNlUmVxdWVzdC5oCmluZGV4IGVmYjEyNDAuLmU4OWI5NTggMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdC5oCisrKyBiL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdC5oCkBAIC0yOSwzNiAr MjksNTIgQEAKIAogI2luY2x1ZGUgIlJlc291cmNlUmVxdWVzdEJhc2UuaCIKIAorI2luY2x1ZGUg PGxpYnNvdXAvc291cC5oPgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC1tZXNzYWdlLmg+CisKIG5h bWVzcGFjZSBXZWJDb3JlIHsKIAogICAgIHN0cnVjdCBSZXNvdXJjZVJlcXVlc3QgOiBSZXNvdXJj ZVJlcXVlc3RCYXNlIHsKIAogICAgICAgICBSZXNvdXJjZVJlcXVlc3QoY29uc3QgU3RyaW5nJiB1 cmwpCiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UoS1VSTCh1cmwpLCBVc2VQcm90 b2NvbENhY2hlUG9saWN5KQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKDApCiAgICAgICAg IHsKICAgICAgICAgfQogCiAgICAgICAgIFJlc291cmNlUmVxdWVzdChjb25zdCBLVVJMJiB1cmwp CiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UodXJsLCBVc2VQcm90b2NvbENhY2hl UG9saWN5KQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKDApCiAgICAgICAgIHsKICAgICAg ICAgfQogCiAgICAgICAgIFJlc291cmNlUmVxdWVzdChjb25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0 cmluZyYgcmVmZXJyZXIsIFJlc291cmNlUmVxdWVzdENhY2hlUG9saWN5IHBvbGljeSA9IFVzZVBy b3RvY29sQ2FjaGVQb2xpY3kpCiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UodXJs LCBwb2xpY3kpCisgICAgICAgICAgICAsIG1fc291cE1lc3NhZ2UoMCkKICAgICAgICAgewogICAg ICAgICAgICAgc2V0SFRUUFJlZmVycmVyKHJlZmVycmVyKTsKICAgICAgICAgfQogCiAgICAgICAg IFJlc291cmNlUmVxdWVzdCgpCiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UoS1VS TCgpLCBVc2VQcm90b2NvbENhY2hlUG9saWN5KQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdl KDApCiAgICAgICAgIHsKICAgICAgICAgfQogCisgICAgICAgIFJlc291cmNlUmVxdWVzdChTb3Vw TWVzc2FnZSogc291cE1lc3NhZ2UpCisgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2Uo KQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKHNvdXBNZXNzYWdlKQorICAgICAgICB7Cisg ICAgICAgIH0KKworICAgICAgICBTb3VwTWVzc2FnZSogc291cE1lc3NhZ2UoKSBjb25zdDsKKwog ICAgIHByaXZhdGU6CisgICAgICAgIFNvdXBNZXNzYWdlICptX3NvdXBNZXNzYWdlOwogICAgICAg ICBmcmllbmQgY2xhc3MgUmVzb3VyY2VSZXF1ZXN0QmFzZTsKIAotICAgICAgICB2b2lkIGRvVXBk YXRlUGxhdGZvcm1SZXF1ZXN0KCkge30KLSAgICAgICAgdm9pZCBkb1VwZGF0ZVJlc291cmNlUmVx dWVzdCgpIHt9CisgICAgICAgIHZvaWQgZG9VcGRhdGVQbGF0Zm9ybVJlcXVlc3QoKTsKKyAgICAg ICAgdm9pZCBkb1VwZGF0ZVJlc291cmNlUmVxdWVzdCgpOwogICAgIH07CiAKIH0gLy8gbmFtZXNw YWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jl c291cmNlUmVxdWVzdFNvdXAuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVz b3VyY2VSZXF1ZXN0U291cC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u MDM4MTE0YgotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3Vw L1Jlc291cmNlUmVxdWVzdFNvdXAuY3BwCkBAIC0wLDAgKzEsOTIgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMDkgR3VzdGF2byBOb3JvbmhhIFNpbHZhCisgKgorICogVGhpcyBsaWJyYXJ5IGlz IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5 IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICog TGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0 aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55 IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRo ZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFO VFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklM SVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAq IExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICog WW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFs IFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxl IENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3Rv biwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2lu Y2x1ZGUgIkNTdHJpbmcuaCIKKyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUg IlJlc291cmNlUmVxdWVzdC5oIgorCisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+CisjaW5jbHVk ZSA8bGlic291cC9zb3VwLW1lc3NhZ2UuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitTb3Vw TWVzc2FnZSogUmVzb3VyY2VSZXF1ZXN0Ojpzb3VwTWVzc2FnZSgpIGNvbnN0Cit7CisgICAgdXBk YXRlUGxhdGZvcm1SZXF1ZXN0KCk7CisKKyAgICByZXR1cm4gbV9zb3VwTWVzc2FnZTsKK30KKwor dm9pZCBSZXNvdXJjZVJlcXVlc3Q6OmRvVXBkYXRlUmVzb3VyY2VSZXF1ZXN0KCkKK3sKKyAgICBT b3VwVVJJICpzb3VwVVJJID0gc291cF9tZXNzYWdlX2dldF91cmkobV9zb3VwTWVzc2FnZSk7CisK KyAgICBnY2hhciAqdXJpID0gc291cF91cmlfdG9fc3RyaW5nKHNvdXBVUkksIEZBTFNFKTsKKyAg ICBtX3VybCA9IEtVUkwoU3RyaW5nOjpmcm9tVVRGOCh1cmkpKTsKKyAgICBnX2ZyZWUodXJpKTsK KworICAgIG1faHR0cE1ldGhvZCA9IFN0cmluZzo6ZnJvbVVURjgobV9zb3VwTWVzc2FnZS0+bWV0 aG9kKTsKKworICAgIG1faHR0cEhlYWRlckZpZWxkcy5jbGVhcigpOworCisgICAgU291cE1lc3Nh Z2VIZWFkZXJzSXRlciBoZWFkZXJzSXRlcjsKKyAgICBnY2hhciAqaGVhZGVyTmFtZSA9IDA7Cisg ICAgZ2NoYXIgKmhlYWRlclZhbHVlID0gMDsKKworICAgIHNvdXBfbWVzc2FnZV9oZWFkZXJzX2l0 ZXJfaW5pdCgmaGVhZGVyc0l0ZXIsIG1fc291cE1lc3NhZ2UtPnJlcXVlc3RfaGVhZGVycyk7Cisg ICAgd2hpbGUgKHNvdXBfbWVzc2FnZV9oZWFkZXJzX2l0ZXJfbmV4dCgmaGVhZGVyc0l0ZXIsIChj b25zdCBnY2hhcioqKSZoZWFkZXJOYW1lLCAoY29uc3QgZ2NoYXIqKikmaGVhZGVyVmFsdWUpKSB7 CisgICAgICAgIG1faHR0cEhlYWRlckZpZWxkcy5zZXQoU3RyaW5nOjpmcm9tVVRGOChoZWFkZXJO YW1lKSwgU3RyaW5nOjpmcm9tVVRGOChoZWFkZXJWYWx1ZSkpOworICAgIH0KKworICAgIG1faHR0 cEJvZHkgPSBGb3JtRGF0YTo6Y3JlYXRlKG1fc291cE1lc3NhZ2UtPnJlcXVlc3RfYm9keS0+ZGF0 YSwgbV9zb3VwTWVzc2FnZS0+cmVxdWVzdF9ib2R5LT5sZW5ndGgpOworfQorCit2b2lkIFJlc291 cmNlUmVxdWVzdDo6ZG9VcGRhdGVQbGF0Zm9ybVJlcXVlc3QoKQoreworICAgIGlmIChpc051bGwo KSkgeworICAgICAgICBpZiAobV9zb3VwTWVzc2FnZSkKKyAgICAgICAgICAgIGdfb2JqZWN0X3Vu cmVmKG1fc291cE1lc3NhZ2UpOworICAgICAgICBtX3NvdXBNZXNzYWdlID0gMDsKKyAgICAgICAg cmV0dXJuOworICAgIH0KKworICAgIGlmICghbV9zb3VwTWVzc2FnZSkKKyAgICAgICAgbV9zb3Vw TWVzc2FnZSA9IHNvdXBfbWVzc2FnZV9uZXcoaHR0cE1ldGhvZCgpLnV0ZjgoKS5kYXRhKCksIHVy bCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworICAgIGVsc2UgeworICAgICAgICBTb3VwVVJJ ICpzb3VwVVJJID0gc291cF91cmlfbmV3KHVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOwor ICAgICAgICBzb3VwX21lc3NhZ2Vfc2V0X3VyaShtX3NvdXBNZXNzYWdlLCBzb3VwVVJJKTsKKwor ICAgICAgICBnX29iamVjdF9zZXQobV9zb3VwTWVzc2FnZSwgIm1ldGhvZCIsIGh0dHBNZXRob2Qo KS51dGY4KCkuZGF0YSgpLCBOVUxMKTsKKyAgICB9CisgICAgc291cF9tZXNzYWdlX2hlYWRlcnNf Y2xlYXIobV9zb3VwTWVzc2FnZS0+cmVxdWVzdF9oZWFkZXJzKTsKKworICAgIEhUVFBIZWFkZXJN YXAgaGVhZGVycyA9IGh0dHBIZWFkZXJGaWVsZHMoKTsKKyAgICBTb3VwTWVzc2FnZUhlYWRlcnMg KnNvdXBIZWFkZXJzID0gbV9zb3VwTWVzc2FnZS0+cmVxdWVzdF9oZWFkZXJzOworICAgIGlmICgh aGVhZGVycy5pc0VtcHR5KCkpIHsKKyAgICAgICAgSFRUUEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0 b3IgZW5kID0gaGVhZGVycy5lbmQoKTsKKyAgICAgICAgZm9yIChIVFRQSGVhZGVyTWFwOjpjb25z dF9pdGVyYXRvciBpdCA9IGhlYWRlcnMuYmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KQorICAgICAg ICAgICAgc291cF9tZXNzYWdlX2hlYWRlcnNfYXBwZW5kKHNvdXBIZWFkZXJzLCBpdC0+Zmlyc3Qu c3RyaW5nKCkudXRmOCgpLmRhdGEoKSwgaXQtPnNlY29uZC51dGY4KCkuZGF0YSgpKTsKKyAgICB9 CisKKyAgICAvLyBCb2R5IGRhdGEgaXMgb25seSBoYW5kbGRlZCBhdCBSZXNvdXJjZUhhbmRsZVNv dXA6OnN0YXJ0SHR0cAorfQorCit9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXRuZXR3b3JrcmVxdWVzdC5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVx dWVzdC5jcHAKaW5kZXggZmFlZWQ4NS4uYzg5MTYzMyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdG5ldHdvcmtyZXF1ZXN0LmNwcApAQCAtMTc0LDQgKzE3NCwyOCBAQCBHX0NPTlNUX1JFVFVS TiBnY2hhciogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJpKFdlYktpdE5ldHdvcmtSZXF1 ZXN0KiByZXF1ZQogICAgIHJldHVybiBwcml2LT51cmk7CiB9CiAKKy8qKgorICogd2Via2l0X25l dHdvcmtfcmVxdWVzdF9nZXRfc291cF9tZXNzYWdlOgorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5l dHdvcmtSZXF1ZXN0CisgKgorICogR2V0cyB0aGUgI1NvdXBNZXNzYWdlIGhlbGQgYW5kIHVzZWQg YnkgdGhlIGdpdmVuIHJlcXVlc3QuIE5vdGljZQorICogdGhhdCBtb3N0IHRpbWVzIFdlYktpdEdU SysgZ2l2ZXMgeW91IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0IGluCisgKiBzaWduYWxzLCBpdCdz IGZvciBpbmZvcm1hdGlvbmFsIHB1cnBvc2VzIG9ubHkuIElmIHlvdSBpbnRlbmQgdG8KKyAqIG1v ZGlmeSB0aGUgaGVhZGVycyBvciBkYXRhIHNlbnQgaW4gYSByZXF1ZXN0IG1hbnVhbGx5LCBwbGVh c2UgcmVhZAorICogdGhlIGRvY3VtZW50YXRpb24gb2YgdGhlIHNpZ25hbCB5b3UgYXJlIGhhbmRs aW5nIHRvIHNlZSBpZiB0aGF0IGlzCisgKiBzdXBwb3NlZCB0byB3b3JrLgorICoKKyAqIFJldHVy bnM6IHRoZSAjU291cE1lc3NhZ2UKKyAqCisgKiBTaW5jZTogMS4xLjQKKyAqLworU291cE1lc3Nh Z2UqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3NvdXBfbWVzc2FnZShXZWJLaXROZXR3b3Jr UmVxdWVzdCogcmVxdWVzdCkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNf TkVUV09SS19SRVFVRVNUKHJlcXVlc3QpLCBOVUxMKTsKKworICAgIFdlYktpdE5ldHdvcmtSZXF1 ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICByZXR1cm4gcHJpdi0+cmVx dWVzdC0+c291cE1lc3NhZ2UoKTsKK30KKwogfQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0bmV0d29ya3JlcXVlc3QuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdv cmtyZXF1ZXN0LmgKaW5kZXggMDFhYjhiYi4uM2YwM2U2OSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93 ZWJraXRuZXR3b3JrcmVxdWVzdC5oCkBAIC0yMSw2ICsyMSw4IEBACiAjZGVmaW5lIFdFQktJVF9O RVRXT1JLX1JFUVVFU1RfSAogCiAjaW5jbHVkZSA8Z2xpYi1vYmplY3QuaD4KKyNpbmNsdWRlIDxs aWJzb3VwL3NvdXAuaD4KKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAtbWVzc2FnZS5oPgogCiAjaW5j bHVkZSA8d2Via2l0L3dlYmtpdGRlZmluZXMuaD4KIApAQCAtNjUsNiArNjcsOSBAQCB3ZWJraXRf bmV0d29ya19yZXF1ZXN0X3NldF91cmkgIChXZWJLaXROZXR3b3JrUmVxdWVzdCAqcmVxdWVzdCwK IFdFQktJVF9BUEkgR19DT05TVF9SRVRVUk4gZ2NoYXIgKgogd2Via2l0X25ldHdvcmtfcmVxdWVz dF9nZXRfdXJpICAoV2ViS2l0TmV0d29ya1JlcXVlc3QgKnJlcXVlc3QpOwogCitXRUJLSVRfQVBJ IFNvdXBNZXNzYWdlKgord2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfc291cF9tZXNzYWdlIChX ZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZgot LSAKMS42LjIuMQoK 28889 2009-03-24 07:43:49 -0700 2009-03-24 15:31:17 -0700 Make our NetworkRequest object functionally complete, by making it Make-our-NetworkRequest-object-functionally-complete-by-making-it.patch text/plain 11960 gustavo NzdkMTgwNDA1OTgyZDg3ZjIzMjk0NmIyOThhZTY4MTNmYWRhOTZkMApkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCA3OWE3MzRlLi4z OTk0YTFhIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3Rr L0NoYW5nZUxvZwpAQCAtMSwzICsxLDMxIEBACisyMDA5LTAzLTI0ICBHdXN0YXZvIE5vcm9uaGEg U2lsdmEgIDxnbnNAZ25vbWUub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x ODYwOAorICAgICAgICBbR3RrXSBXZWJLaXROZXR3b3JrUmVxdWVzdCBuZWVkcyB0byBiZSBmaW5p c2hlZAorCisgICAgICAgIE1ha2Ugb3VyIE5ldHdvcmtSZXF1ZXN0IG9iamVjdCBmdW5jdGlvbmFs bHkgY29tcGxldGUsIGJ5IG1ha2luZyBpdAorICAgICAgICBjYXJyeSB0aGUgUmVzb3VyY2VSZXF1 ZXN0IGl0IHJlcHJlc2VudHMgd2l0aCBpdC4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50R3RrLmNwcDoKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGll bnQ6OmRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTUlNRVR5cGUpOgorICAgICAgICAoV2ViS2l0OjpG cmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JOYXZpZ2F0aW9uQWN0aW9u KToKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQpOgor ICAgICAgICAqIHdlYmtpdC93ZWJraXRkb3dubG9hZC5jcHA6CisgICAgICAgIChfV2ViS2l0RG93 bmxvYWRQcml2YXRlOjp3ZWJraXRfZG93bmxvYWRfc3RhcnQpOgorICAgICAgICAqIHdlYmtpdC93 ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHA6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQ cml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2ZpbmFsaXplKToKKyAgICAgICAgKF9XZWJL aXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfY2xhc3NfaW5p dCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29y a19yZXF1ZXN0X2luaXQpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6 d2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3JlX3JlcXVlc3QpOgorICAgICAgICAo X1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRf Y29yZV9yZXF1ZXN0KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6Ondl YmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVz dFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaSk6CisgICAgICAgIChfV2Vi S2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF91cmkp OgorICAgICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmg6CisgICAgICAgICogd2Via2l0L3dl YmtpdHdlYmZyYW1lLmNwcDoKKwogMjAwOS0wMy0yMCAgSmFuIE1pY2hhZWwgQWxvbnpvICA8am1h bG9uem9AZ21haWwuY29tPgogCiAgICAgICAgIE5vdCByZXZpZXdlZC4gRml4IHN0eWxlIGlzc3Vl cyB3aXRoIG15IHByZXZpb3VzIGNvbW1pdCAocjQxODY2KSBhcwpkaWZmIC0tZ2l0IGEvV2ViS2l0 L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAgYi9XZWJLaXQvZ3Rr L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAppbmRleCA4ZTJjMDBjLi5j MGNmNDYzIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50R3RrLmNwcAorKysgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50R3RrLmNwcApAQCAtNTQsNiArNTQsNyBAQAogI2luY2x1ZGUgIndlYmtpdHdlYmZyYW1l LmgiCiAjaW5jbHVkZSAid2Via2l0d2VibmF2aWdhdGlvbmFjdGlvbi5oIgogI2luY2x1ZGUgIndl YmtpdHdlYnBvbGljeWRlY2lzaW9uLmgiCisjaW5jbHVkZSAid2Via2l0bmV0d29ya3JlcXVlc3Qu aCIKICNpbmNsdWRlICJ3ZWJraXRwcml2YXRlLmgiCiAKICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29y ZS9BUElDYXN0Lmg+CkBAIC0yODIsNyArMjgzLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6 ZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JNSU1FVHlwZShGcmFtZVBvbGljeUZ1bmN0aW9uIHBvbGkK ICAgICB9CiAKICAgICBXZWJLaXRXZWJWaWV3KiBwYWdlID0gZ2V0Vmlld0Zyb21GcmFtZShtX2Zy YW1lKTsKLSAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfbmV3KHJlc291cmNlUmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgp KTsKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0KHJlc291cmNlUmVxdWVzdCk7CiAKICAgICBXZWJL aXRXZWJQb2xpY3lEZWNpc2lvbiogcG9saWN5RGVjaXNpb24gPSB3ZWJraXRfd2ViX3BvbGljeV9k ZWNpc2lvbl9uZXcobV9mcmFtZSwgcG9saWN5RnVuY3Rpb24pOwogICAgIGlmIChtX3BvbGljeURl Y2lzaW9uKQpAQCAtMzMxLDcgKzMzMiw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3Bh dGNoRGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlvbkFjdGlvbihGcmFtZVBvbGljeUZ1bmN0CiAgICAg fQogCiAgICAgV2ViS2l0V2ViVmlldyogd2ViVmlldyA9IGdldFZpZXdGcm9tRnJhbWUobV9mcmFt ZSk7Ci0gICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X25ldyhyZXNvdXJjZVJlcXVlc3QudXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7 CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X25ld193aXRoX2NvcmVfcmVxdWVzdChyZXNvdXJjZVJlcXVlc3QpOwogICAgIFdlYktpdE5h dmlnYXRpb25SZXNwb25zZSByZXNwb25zZTsKICAgICAvKgogICAgICAqIFdlIHN0aWxsIHN1cHBv cnQgdGhlIGRlcHJlY2F0ZWQgbmF2aWdhdGlvbi1yZXF1ZXN0ZWQgc2lnbmFsLCBpZiB0aGUKQEAg LTg5Myw3ICs4OTQsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpzZXRNYWluRG9jdW1lbnRF cnJvcihEb2N1bWVudExvYWRlciosIGNvbnN0IFJlc291cmNlRXJybwogCiB2b2lkIEZyYW1lTG9h ZGVyQ2xpZW50OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkK IHsKLSAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogbmV0d29ya1JlcXVlc3QgPSB3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X25ldyhyZXF1ZXN0LnVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOwor ICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiBuZXR3b3JrUmVxdWVzdCA9IHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0KHJlcXVlc3QpOwogICAgIFdlYktpdERvd25s b2FkKiBkb3dubG9hZCA9IHdlYmtpdF9kb3dubG9hZF9uZXcobmV0d29ya1JlcXVlc3QpOwogICAg IGdfb2JqZWN0X3VucmVmKG5ldHdvcmtSZXF1ZXN0KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0ZG93bmxvYWQuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZG93 bmxvYWQuY3BwCmluZGV4IDQ0ODgzMDQuLjNiY2VlZGMgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdGRvd25sb2FkLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRk b3dubG9hZC5jcHAKQEAgLTQxNiw5ICs0MTYsNyBAQCB2b2lkIHdlYmtpdF9kb3dubG9hZF9zdGFy dChXZWJLaXREb3dubG9hZCogZG93bmxvYWQpCiAgICAgaWYgKHByaXYtPnJlc291cmNlSGFuZGxl KQogICAgICAgICBwcml2LT5yZXNvdXJjZUhhbmRsZS0+c2V0Q2xpZW50KHByaXYtPmRvd25sb2Fk Q2xpZW50KTsKICAgICBlbHNlIHsKLSAgICAgICAgLy8gRklYTUU6IFVzZSB0aGUgYWN0dWFsIHJl cXVlc3Qgb2JqZWN0IHdoZW4gV2ViS2l0TmV0d29ya1JlcXVlc3QgaXMgZmluaXNoZWQuCi0gICAg ICAgIFJlc291cmNlUmVxdWVzdCByZXF1ZXN0KHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3Vy aShwcml2LT5uZXR3b3JrUmVxdWVzdCkpOwotICAgICAgICBwcml2LT5yZXNvdXJjZUhhbmRsZSA9 IFJlc291cmNlSGFuZGxlOjpjcmVhdGUocmVxdWVzdCwgcHJpdi0+ZG93bmxvYWRDbGllbnQsIDAs IGZhbHNlLCBmYWxzZSwgZmFsc2UpOworICAgICAgICBwcml2LT5yZXNvdXJjZUhhbmRsZSA9IFJl c291cmNlSGFuZGxlOjpjcmVhdGUoKndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X2NvcmVfcmVx dWVzdChwcml2LT5uZXR3b3JrUmVxdWVzdCksIHByaXYtPmRvd25sb2FkQ2xpZW50LCAwLCBmYWxz ZSwgZmFsc2UsIGZhbHNlKTsKICAgICB9CiAKICAgICBwcml2LT50aW1lciA9IGdfdGltZXJfbmV3 KCk7CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5j cHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKaW5kZXggM2Fk OGI1ZC4uMWUzZWYyYyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29y a3JlcXVlc3QuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0 LmNwcApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDcsIDIwMDggSG9s Z2VyIEhhbnMgUGV0ZXIgRnJleXRoZXIKKyAqIENvcHlyaWdodCAoQykgMjAwOSBHdXN0YXZvIE5v cm9uaGEgU2lsdmEKICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYwpAQCAtMTgsOSArMTksMTMgQEAKICAqLwog CiAjaW5jbHVkZSAiY29uZmlnLmgiCi0KICNpbmNsdWRlICJ3ZWJraXRuZXR3b3JrcmVxdWVzdC5o IgogCisjaW5jbHVkZSAiQ1N0cmluZy5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisj aW5jbHVkZSAiUmVzb3VyY2VSZXF1ZXN0LmgiCisjaW5jbHVkZSAid2Via2l0cHJpdmF0ZS5oIgor CiAvKioKICAqIFNFQ1RJT046d2Via2l0bmV0d29ya3JlcXVlc3QKICAqIEBzaG9ydF9kZXNjcmlw dGlvbjogVGhlIHRhcmdldCBvZiBhIG5hdmlnYXRpb24gcmVxdWVzdApAQCAtMzQsMTIgKzM5LDIw IEBACiAgKgogICovCiAKK3VzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOworCiBleHRlcm4gIkMiIHsK IAogR19ERUZJTkVfVFlQRShXZWJLaXROZXR3b3JrUmVxdWVzdCwgd2Via2l0X25ldHdvcmtfcmVx dWVzdCwgR19UWVBFX09CSkVDVCk7CiAKKy8vIFRoZSBtdXN0RnJlZVJlcXVlc3QgdmFyaWFibGUg aGVyZSBpcyB1c2VkIHRvIHN0b3JlIGlmIHRoZQorLy8gUmVzb3VyY2VSZXF1ZXN0IHdlIGFyZSBz dG9yaW5nIGlzIG93bmVkIGJ5IHVzIG9yIGJ5IFdlYkNvcmU7IHRoaXMKKy8vIHdvbid0IGJlIG5l ZWRlZCB3aGVuL2lmIFJlc291cmNlUmVxdWVzdCBpcyByZWZlcmVuY2UgY291bnRlZC4KIHN0cnVj dCBfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlIHsKICAgICBnY2hhciogdXJpOworCisgICAg UmVzb3VyY2VSZXF1ZXN0KiByZXF1ZXN0OworICAgIGdib29sZWFuIG11c3RGcmVlUmVxdWVzdDsK IH07CiAKICNkZWZpbmUgV0VCS0lUX05FVFdPUktfUkVRVUVTVF9HRVRfUFJJVkFURShvYmopIChH X1RZUEVfSU5TVEFOQ0VfR0VUX1BSSVZBVEUoKG9iaiksIFdFQktJVF9UWVBFX05FVFdPUktfUkVR VUVTVCwgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKSkKQEAgLTUxLDEyICs2NCwxNyBAQCBz dGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2ZpbmFsaXplKEdPYmplY3QqIG9iamVj dCkKIAogICAgIGdfZnJlZShwcml2LT51cmkpOwogCisgICAgaWYgKHByaXYtPm11c3RGcmVlUmVx dWVzdCkKKyAgICAgICAgZGVsZXRlIHByaXYtPnJlcXVlc3Q7CisKICAgICBHX09CSkVDVF9DTEFT Uyh3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3BhcmVudF9jbGFzcyktPmZpbmFsaXplKG9iamVjdCk7 CiB9CiAKIHN0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfY2xhc3NfaW5pdChXZWJL aXROZXR3b3JrUmVxdWVzdENsYXNzKiByZXF1ZXN0Q2xhc3MpCiB7Ci0gICAgR19PQkpFQ1RfQ0xB U1MocmVxdWVzdENsYXNzKS0+ZmluYWxpemUgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2ZpbmFs aXplOworICAgIEdPYmplY3RDbGFzcyogb2JqZWN0Q2xhc3MgPSBHX09CSkVDVF9DTEFTUyhyZXF1 ZXN0Q2xhc3MpOworCisgICAgb2JqZWN0Q2xhc3MtPmZpbmFsaXplID0gd2Via2l0X25ldHdvcmtf cmVxdWVzdF9maW5hbGl6ZTsKIAogICAgIGdfdHlwZV9jbGFzc19hZGRfcHJpdmF0ZShyZXF1ZXN0 Q2xhc3MsIHNpemVvZihXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUpKTsKIH0KQEAgLTY1LDIw ICs4Myw2MiBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2luaXQoV2ViS2l0 TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCiB7CiAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2 YXRlKiBwcml2ID0gV0VCS0lUX05FVFdPUktfUkVRVUVTVF9HRVRfUFJJVkFURShyZXF1ZXN0KTsK ICAgICByZXF1ZXN0LT5wcml2ID0gcHJpdjsKKworICAgIC8vIFdlIHVzdWFsbHkgZ2V0IGEgUmVz b3VyY2VSZXF1ZXN0IHRoYXQgaXMgb3duZWQgYnkgV2ViQ29yZSwgYW5kCisgICAgLy8gd2UgbmVl ZCBub3QgY2FyZSBhYm91dCBpdHMgbGlmZXRpbWUKKyAgICBwcml2LT5tdXN0RnJlZVJlcXVlc3Qg PSBGQUxTRTsKK30KKworLy8gZm9yIGludGVybmFsIHVzZSBvbmx5CitXZWJLaXROZXR3b3JrUmVx dWVzdCogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3JlX3JlcXVlc3QoY29uc3Qg UmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3QpCit7CisgICAgV2ViS2l0TmV0d29ya1Jl cXVlc3QqIHJlcXVlc3QgPSBXRUJLSVRfTkVUV09SS19SRVFVRVNUKGdfb2JqZWN0X25ldyhXRUJL SVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIE5VTEwpKTsKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVz dFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgcHJpdi0+cmVxdWVzdCA9ICYo Y29uc3RfY2FzdDxSZXNvdXJjZVJlcXVlc3QmPihyZXNvdXJjZVJlcXVlc3QpKTsKKworICAgIHJl dHVybiByZXF1ZXN0OworfQorCisvLyBmb3IgaW50ZXJuYWwgdXNlIG9ubHkKK1Jlc291cmNlUmVx dWVzdCogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfY29yZV9yZXF1ZXN0KGNvbnN0IFdlYktp dE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJp dmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICByZXR1cm4gcHJpdi0+cmVxdWVzdDsK IH0KIAorLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ldzoKKyAqIEB1cmk6IGFuIFVS SQorICoKKyAqIENyZWF0ZXMgYSBuZXcgI1dlYktpdE5ldHdvcmtSZXF1ZXN0IGluaXRpYWxpemVk IHdpdGggYW4gVVJJLgorICoKKyAqIFJldHVybnM6IGEgbmV3ICNXZWJLaXROZXR3b3JrUmVxdWVz dAorICovCiBXZWJLaXROZXR3b3JrUmVxdWVzdCogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXco Y29uc3QgZ2NoYXIqIHVyaSkKIHsKICAgICBnX3JldHVybl92YWxfaWZfZmFpbCh1cmksIE5VTEwp OwogCi0gICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSBXRUJLSVRfTkVUV09SS19S RVFVRVNUKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIE5VTEwpKTsK KyAgICBSZXNvdXJjZVJlcXVlc3QqIHJlc291cmNlUmVxdWVzdCA9IG5ldyBSZXNvdXJjZVJlcXVl c3QoS1VSTChLVVJMKCksIFN0cmluZzo6ZnJvbVVURjgodXJpKSkpOworCisgICAgV2ViS2l0TmV0 d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2Nv cmVfcmVxdWVzdCgoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JikqcmVzb3VyY2VSZXF1ZXN0KTsKICAg ICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OwogCi0g ICAgcHJpdi0+dXJpID0gZ19zdHJkdXAodXJpKTsKKyAgICAvLyBTaW5jZSB3ZSBhcmUgY3JlYXRp bmcgdGhpcyBSZXNvdXJjZVJlcXVlc3Qgb3Vyc2VsdmVzLCB3ZSB3aWxsCisgICAgLy8gbmVlZCB0 byBmcmVlIGl0IGluIGRpc3Bvc2UuCisgICAgcHJpdi0+bXVzdEZyZWVSZXF1ZXN0ID0gVFJVRTsK IAogICAgIHJldHVybiByZXF1ZXN0OwogfQogCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVl c3Rfc2V0X3VyaToKKyAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICogQHVy aTogYW4gVVJJCisgKgorICogU2V0cyB0aGUgVVJJIGhlbGQgYW5kIHVzZWQgYnkgdGhlIGdpdmVu IHJlcXVlc3QuCisgKi8KIHZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpKFdlYktp dE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhciogdXJpKQogewogICAgIGdfcmV0 dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CkBAIC04Nywy MiArMTQ3LDMwIEBAIHZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpKFdlYktpdE5l dHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBjb25zdCBnY2hhcioKICAgICBXZWJLaXROZXR3b3JrUmVx dWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OwogCiAgICAgZ19mcmVlKHByaXYtPnVy aSk7Ci0gICAgcHJpdi0+dXJpID0gZ19zdHJkdXAodXJpKTsKKyAgICBwcml2LT5yZXF1ZXN0LT5z ZXRVUkwoS1VSTChLVVJMKCksIFN0cmluZzo6ZnJvbVVURjgodXJpKSkpOwogfQogCiAvKioKICAq IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaToKICAqIEByZXF1ZXN0OiBhICNXZWJLaXRO ZXR3b3JrUmVxdWVzdAogICoKKyAqIEdldHMgdGhlIFVSSSBoZWxkIGFuZCB1c2VkIGJ5IHRoZSBn aXZlbiByZXF1ZXN0LgorICoKICAqIFJldHVybnM6IHRoZSB1cmkgb2YgdGhlICNXZWJLaXROZXR3 b3JrUmVxdWVzdAogICoKICAqIFNpbmNlOiAxLjAuMAorICoKKyAqIFJldHVybnM6IHRoZSBVUkkg aGVsZCBhbmQgdXNlZCBieSB0aGUgZ2l2ZW4gcmVxdWVzdAogICovCiBHX0NPTlNUX1JFVFVSTiBn Y2hhciogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0 KiByZXF1ZXN0KQogewogICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JL X1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOwogCiAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2 YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKworICAgIGlmIChwcml2LT51cmkgPT0gTlVMTCkK KyAgICAgICAgcHJpdi0+dXJpID0gZ19zdHJkdXAocHJpdi0+cmVxdWVzdC0+dXJsKCkuc3RyaW5n KCkudXRmOCgpLmRhdGEoKSk7CisKICAgICByZXR1cm4gcHJpdi0+dXJpOwogfQogCmRpZmYgLS1n aXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRwcml2YXRlLmgKaW5kZXggMGI4M2ExMS4uMDFiZDM4NCAxMDA2NDQKLS0tIGEvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHByaXZhdGUuaApAQCAtMjMsNyArMjMsOCBAQAogI2RlZmluZSBXRUJLSVRfUFJJVkFURV9I CiAKIC8qCi0gKiBUaGlzIGZpbGUga25vd3MgdGhlIHNoYXJlZCBzZWNyZXQgb2YgV2ViS2l0V2Vi VmlldyBhbmQgV2ViS2l0V2ViRnJhbWUuCisgKiBUaGlzIGZpbGUga25vd3MgdGhlIHNoYXJlZCBz ZWNyZXQgb2YgV2ViS2l0V2ViVmlldywgV2ViS2l0V2ViRnJhbWUsCisgKiBhbmQgV2ViS2l0TmV0 d29ya1JlcXVlc3QuCiAgKiBUaGV5IGFyZSB1c2luZyBXZWJDb3JlIHdoaWNoIG11c24ndCBiZSBl eHBvc2VkIHRvIHRoZSBvdXRlciB3b3JsZC4KICAqLwogCkBAIC0zNiw2ICszNyw3IEBACiAjaW5j bHVkZSA8d2Via2l0L3dlYmtpdHdlYnNldHRpbmdzLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtp dHdlYndpbmRvd2ZlYXR1cmVzLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYmJhY2tmb3J3 YXJkbGlzdC5oPgorI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oPgogCiAj aW5jbHVkZSAiQmFja0ZvcndhcmRMaXN0LmgiCiAjaW5jbHVkZSAiSGlzdG9yeUl0ZW0uaCIKQEAg LTQ1LDYgKzQ3LDcgQEAKICNpbmNsdWRlICJJbnNwZWN0b3JDbGllbnRHdGsuaCIKICNpbmNsdWRl ICJGcmFtZUxvYWRlckNsaWVudC5oIgogI2luY2x1ZGUgIlJlc291cmNlSGFuZGxlLmgiCisjaW5j bHVkZSAiUmVzb3VyY2VSZXF1ZXN0LmgiCiAjaW5jbHVkZSAiUmVzb3VyY2VSZXNwb25zZS5oIgog I2luY2x1ZGUgIldpbmRvd0ZlYXR1cmVzLmgiCiAKQEAgLTE2NCw2ICsxNjcsMTIgQEAgZXh0ZXJu ICJDIiB7CiAgICAgdm9pZAogICAgIHdlYmtpdF93ZWJfcG9saWN5X2RlY2lzaW9uX2NhbmNlbCAo V2ViS2l0V2ViUG9saWN5RGVjaXNpb24qIGRlY2lzaW9uKTsKIAorICAgIFdlYktpdE5ldHdvcmtS ZXF1ZXN0KgorICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0 KGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0KTsKKworICAg IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCoKKyAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dl dF9jb3JlX3JlcXVlc3QoY29uc3QgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCiAg ICAgLy8gRklYTUU6IG1vdmUgdGhpcyBmdW5jdGlvbmFsaXR5IGludG8gYSAnV2ViS2l0V2ViRGF0 YVNvdXJjZScgb25jZSBpbXBsZW1lbnRlZAogICAgIFdFQktJVF9BUEkgZ2NoYXIqCiAgICAgd2Vi a2l0X3dlYl9mcmFtZV9nZXRfcmVzcG9uc2VfbWltZV90eXBlKFdlYktpdFdlYkZyYW1lKiBmcmFt ZSk7CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAgYi9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKaW5kZXggZTJiMTBiNi4uNjM3ZjY2 NyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCisrKyBi L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcApAQCAtNDQ5LDkgKzQ0OSw3IEBA IHZvaWQgd2Via2l0X3dlYl9mcmFtZV9sb2FkX3JlcXVlc3QoV2ViS2l0V2ViRnJhbWUqIGZyYW1l LCBXZWJLaXROZXR3b3JrUmVxdWVzdCoKICAgICBpZiAoIWNvcmVGcmFtZSkKICAgICAgICAgcmV0 dXJuOwogCi0gICAgLy8gVE9ETzogVXNlIHRoZSBSZXNvdXJjZVJlcXVlc3QgY2FycmllZCBieSBX ZWJLaXROZXR3b3JrUmVxdWVzdCB3aGVuIGl0IGlzIGltcGxlbWVudGVkLgotICAgIFN0cmluZyBz dHJpbmcgPSBTdHJpbmc6OmZyb21VVEY4KHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShy ZXF1ZXN0KSk7Ci0gICAgY29yZUZyYW1lLT5sb2FkZXIoKS0+bG9hZChSZXNvdXJjZVJlcXVlc3Qo S1VSTChLVVJMKCksIHN0cmluZykpLCBmYWxzZSk7CisgICAgY29yZUZyYW1lLT5sb2FkZXIoKS0+ bG9hZChjb25zdF9jYXN0PFJlc291cmNlUmVxdWVzdCY+KCp3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X2dldF9jb3JlX3JlcXVlc3QocmVxdWVzdCkpLCBmYWxzZSk7CiB9CiAKIC8qKgo= 28890 2009-03-24 07:43:56 -0700 2009-05-29 08:08:40 -0700 Expose the SoupMessage of the request through our WebKitNetworkRequest Expose-the-SoupMessage-of-the-request-through-our-WebKitNetworkRequest.patch text/plain 10666 gustavo NjZlMDZkNGE5NzA4NWUzODg2MzYzOWYzOTBlY2QzYjVjZTFkMmNlNgpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA1NmRjYWQ3Li40NzlkYWY4 IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpA QCAtMSwzICsxLDI0IEBACisyMDA5LTAzLTI0ICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxnbnNA Z25vbWUub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xODYwOAorICAgICAg ICBbR3RrXSBXZWJLaXROZXR3b3JrUmVxdWVzdCBuZWVkcyB0byBiZSBmaW5pc2hlZAorCisgICAg ICAgIE1ha2UgdGhlIFNvdXBNZXNzYWdlIHdlIHVzZSBhIG1lbWJlciBvZiBSZXNvdXJjZVJlcXVl c3QsIGluc3RlYWQKKyAgICAgICAgb2YgYmVpbmcgY3JlYXRlZCBpbiBzdGFydEh0dHAuIFRoaXMg YWxsb3dzIHVzIHRvIGV4cG9zZSB0aGUKKyAgICAgICAgU291cE1lc3NhZ2UgaW4gb3VyIEFQSS4K KworICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsv c291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VI YW5kbGU6OnN0YXJ0SHR0cCk6CisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlUmVxdWVzdC5oOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0OjpSZXNvdXJj ZVJlcXVlc3QpOgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVl c3RTb3VwLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3Q6OnNv dXBNZXNzYWdlKToKKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdDo6ZG9VcGRhdGVS ZXNvdXJjZVJlcXVlc3QpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Ojpkb1Vw ZGF0ZVBsYXRmb3JtUmVxdWVzdCk6CisKIDIwMDktMDMtMjMgIEFkYSBDaGFuICA8YWRhY2hhbkBh cHBsZS5jb20+CiAKICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTI0NzYyCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtIGIvV2ViQ29yZS9H TlVtYWtlZmlsZS5hbQppbmRleCBmZmFmMWIyLi4zNGYyZDlhIDEwMDY0NAotLS0gYS9XZWJDb3Jl L0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KQEAgLTE4MzksNiAr MTgzOSw3IEBAIHdlYmNvcmVfc291cmNlcyArPSBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L3NvdXAvRE5TU291cC5jcHAgXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlRXJyb3IuaCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5k bGVTb3VwLmNwcCBcCisJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1 ZXN0U291cC5jcHAgXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVx dWVzdC5oIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlc3BvbnNl LmgKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VI YW5kbGVTb3VwLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFu ZGxlU291cC5jcHAKaW5kZXggYjJiOTgxYi4uMzZiYzI4ZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9w bGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcAorKysgYi9XZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCkBAIC00MTIsMjEg KzQxMiwxMyBAQCBib29sIFJlc291cmNlSGFuZGxlOjpzdGFydEh0dHAoU3RyaW5nIHVybFN0cmlu ZykKICAgICBTb3VwU2Vzc2lvbiogc2Vzc2lvbiA9IGRlZmF1bHRTZXNzaW9uKCk7CiAgICAgZW5z dXJlU2Vzc2lvbklzSW5pdGlhbGl6ZWQoc2Vzc2lvbik7CiAKLSAgICBTb3VwTWVzc2FnZSogbXNn OwotICAgIG1zZyA9IHNvdXBfbWVzc2FnZV9uZXcocmVxdWVzdCgpLmh0dHBNZXRob2QoKS51dGY4 KCkuZGF0YSgpLCB1cmxTdHJpbmcudXRmOCgpLmRhdGEoKSk7CisgICAgU291cE1lc3NhZ2UqIG1z ZyA9IHJlcXVlc3QoKS5zb3VwTWVzc2FnZSgpOwogICAgIGdfc2lnbmFsX2Nvbm5lY3QobXNnLCAi cmVzdGFydGVkIiwgR19DQUxMQkFDSyhyZXN0YXJ0ZWRDYWxsYmFjayksIHRoaXMpOwogICAgIGdf c2lnbmFsX2Nvbm5lY3QobXNnLCAiZ290LWhlYWRlcnMiLCBHX0NBTExCQUNLKGdvdEhlYWRlcnND YWxsYmFjayksIHRoaXMpOwogICAgIGdfc2lnbmFsX2Nvbm5lY3QobXNnLCAiZ290LWNodW5rIiwg R19DQUxMQkFDSyhnb3RDaHVua0NhbGxiYWNrKSwgdGhpcyk7CiAKICAgICBnX29iamVjdF9zZXRf ZGF0YShHX09CSkVDVChtc2cpLCAicmVzb3VyY2VIYW5kbGUiLCByZWludGVycHJldF9jYXN0PHZv aWQqPih0aGlzKSk7CiAKLSAgICBIVFRQSGVhZGVyTWFwIGN1c3RvbUhlYWRlcnMgPSBkLT5tX3Jl cXVlc3QuaHR0cEhlYWRlckZpZWxkcygpOwotICAgIGlmICghY3VzdG9tSGVhZGVycy5pc0VtcHR5 KCkpIHsKLSAgICAgICAgSFRUUEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgZW5kID0gY3VzdG9t SGVhZGVycy5lbmQoKTsKLSAgICAgICAgZm9yIChIVFRQSGVhZGVyTWFwOjpjb25zdF9pdGVyYXRv ciBpdCA9IGN1c3RvbUhlYWRlcnMuYmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KQotICAgICAgICAg ICAgc291cF9tZXNzYWdlX2hlYWRlcnNfYXBwZW5kKG1zZy0+cmVxdWVzdF9oZWFkZXJzLCBpdC0+ Zmlyc3Quc3RyaW5nKCkudXRmOCgpLmRhdGEoKSwgaXQtPnNlY29uZC51dGY4KCkuZGF0YSgpKTsK LSAgICB9Ci0KICAgICBGb3JtRGF0YSogaHR0cEJvZHkgPSBkLT5tX3JlcXVlc3QuaHR0cEJvZHko KTsKICAgICBpZiAoaHR0cEJvZHkgJiYgIWh0dHBCb2R5LT5pc0VtcHR5KCkpIHsKICAgICAgICAg c2l6ZV90IG51bUVsZW1lbnRzID0gaHR0cEJvZHktPmVsZW1lbnRzKCkuc2l6ZSgpOwpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0LmggYi9X ZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3QuaAppbmRleCBlZmIx MjQwLi5hYjc4NGJiIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9S ZXNvdXJjZVJlcXVlc3QuaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNv dXJjZVJlcXVlc3QuaApAQCAtMjksMzYgKzI5LDUxIEBACiAKICNpbmNsdWRlICJSZXNvdXJjZVJl cXVlc3RCYXNlLmgiCiAKKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KKwogbmFtZXNwYWNlIFdl YkNvcmUgewogCiAgICAgc3RydWN0IFJlc291cmNlUmVxdWVzdCA6IFJlc291cmNlUmVxdWVzdEJh c2UgewogCiAgICAgICAgIFJlc291cmNlUmVxdWVzdChjb25zdCBTdHJpbmcmIHVybCkKICAgICAg ICAgICAgIDogUmVzb3VyY2VSZXF1ZXN0QmFzZShLVVJMKHVybCksIFVzZVByb3RvY29sQ2FjaGVQ b2xpY3kpCisgICAgICAgICAgICAsIG1fc291cE1lc3NhZ2UoMCkKICAgICAgICAgewogICAgICAg ICB9CiAKICAgICAgICAgUmVzb3VyY2VSZXF1ZXN0KGNvbnN0IEtVUkwmIHVybCkKICAgICAgICAg ICAgIDogUmVzb3VyY2VSZXF1ZXN0QmFzZSh1cmwsIFVzZVByb3RvY29sQ2FjaGVQb2xpY3kpCisg ICAgICAgICAgICAsIG1fc291cE1lc3NhZ2UoMCkKICAgICAgICAgewogICAgICAgICB9CiAKICAg ICAgICAgUmVzb3VyY2VSZXF1ZXN0KGNvbnN0IEtVUkwmIHVybCwgY29uc3QgU3RyaW5nJiByZWZl cnJlciwgUmVzb3VyY2VSZXF1ZXN0Q2FjaGVQb2xpY3kgcG9saWN5ID0gVXNlUHJvdG9jb2xDYWNo ZVBvbGljeSkKICAgICAgICAgICAgIDogUmVzb3VyY2VSZXF1ZXN0QmFzZSh1cmwsIHBvbGljeSkK KyAgICAgICAgICAgICwgbV9zb3VwTWVzc2FnZSgwKQogICAgICAgICB7CiAgICAgICAgICAgICBz ZXRIVFRQUmVmZXJyZXIocmVmZXJyZXIpOwogICAgICAgICB9CiAKICAgICAgICAgUmVzb3VyY2VS ZXF1ZXN0KCkKICAgICAgICAgICAgIDogUmVzb3VyY2VSZXF1ZXN0QmFzZShLVVJMKCksIFVzZVBy b3RvY29sQ2FjaGVQb2xpY3kpCisgICAgICAgICAgICAsIG1fc291cE1lc3NhZ2UoMCkKICAgICAg ICAgewogICAgICAgICB9CiAKKyAgICAgICAgUmVzb3VyY2VSZXF1ZXN0KFNvdXBNZXNzYWdlKiBz b3VwTWVzc2FnZSkKKyAgICAgICAgICAgIDogUmVzb3VyY2VSZXF1ZXN0QmFzZSgpCisgICAgICAg ICAgICAsIG1fc291cE1lc3NhZ2Uoc291cE1lc3NhZ2UpCisgICAgICAgIHsKKyAgICAgICAgfQor CisgICAgICAgIFNvdXBNZXNzYWdlKiBzb3VwTWVzc2FnZSgpIGNvbnN0OworCiAgICAgcHJpdmF0 ZToKKyAgICAgICAgU291cE1lc3NhZ2UqIG1fc291cE1lc3NhZ2U7CiAgICAgICAgIGZyaWVuZCBj bGFzcyBSZXNvdXJjZVJlcXVlc3RCYXNlOwogCi0gICAgICAgIHZvaWQgZG9VcGRhdGVQbGF0Zm9y bVJlcXVlc3QoKSB7fQotICAgICAgICB2b2lkIGRvVXBkYXRlUmVzb3VyY2VSZXF1ZXN0KCkge30K KyAgICAgICAgdm9pZCBkb1VwZGF0ZVBsYXRmb3JtUmVxdWVzdCgpOworICAgICAgICB2b2lkIGRv VXBkYXRlUmVzb3VyY2VSZXF1ZXN0KCk7CiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1 ZXN0U291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVl c3RTb3VwLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wODhiN2JkCi0t LSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VS ZXF1ZXN0U291cC5jcHAKQEAgLTAsMCArMSw5MSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAw OSBHdXN0YXZvIE5vcm9uaGEgU2lsdmEKKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFz IHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZl cnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVy c2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhh dCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91 dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdl bmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxk IGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExp Y2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5M SUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJ bmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjEx MC0xMzAxLCBVU0EuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAiQ1N0 cmluZy5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjaW5jbHVkZSAiUmVzb3VyY2VS ZXF1ZXN0LmgiCisKKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KKworbmFtZXNwYWNlIFdlYkNv cmUgeworCitTb3VwTWVzc2FnZSogUmVzb3VyY2VSZXF1ZXN0Ojpzb3VwTWVzc2FnZSgpIGNvbnN0 Cit7CisgICAgdXBkYXRlUGxhdGZvcm1SZXF1ZXN0KCk7CisKKyAgICByZXR1cm4gbV9zb3VwTWVz c2FnZTsKK30KKwordm9pZCBSZXNvdXJjZVJlcXVlc3Q6OmRvVXBkYXRlUmVzb3VyY2VSZXF1ZXN0 KCkKK3sKKyAgICBTb3VwVVJJKiBzb3VwVVJJID0gc291cF9tZXNzYWdlX2dldF91cmkobV9zb3Vw TWVzc2FnZSk7CisKKyAgICBnY2hhciogdXJpID0gc291cF91cmlfdG9fc3RyaW5nKHNvdXBVUkks IEZBTFNFKTsKKyAgICBtX3VybCA9IEtVUkwoS1VSTCgpLCBTdHJpbmc6OmZyb21VVEY4KHVyaSkp OworICAgIGdfZnJlZSh1cmkpOworCisgICAgbV9odHRwTWV0aG9kID0gU3RyaW5nOjpmcm9tVVRG OChtX3NvdXBNZXNzYWdlLT5tZXRob2QpOworCisgICAgbV9odHRwSGVhZGVyRmllbGRzLmNsZWFy KCk7CisKKyAgICBTb3VwTWVzc2FnZUhlYWRlcnNJdGVyIGhlYWRlcnNJdGVyOworICAgIGNvbnN0 IGNoYXIqIGhlYWRlck5hbWU7CisgICAgY29uc3QgY2hhciogaGVhZGVyVmFsdWU7CisKKyAgICBz b3VwX21lc3NhZ2VfaGVhZGVyc19pdGVyX2luaXQoJmhlYWRlcnNJdGVyLCBtX3NvdXBNZXNzYWdl LT5yZXF1ZXN0X2hlYWRlcnMpOworICAgIHdoaWxlIChzb3VwX21lc3NhZ2VfaGVhZGVyc19pdGVy X25leHQoJmhlYWRlcnNJdGVyLCAmaGVhZGVyTmFtZSwgJmhlYWRlclZhbHVlKSkKKyAgICAgICAg bV9odHRwSGVhZGVyRmllbGRzLnNldChTdHJpbmc6OmZyb21VVEY4KGhlYWRlck5hbWUpLCBTdHJp bmc6OmZyb21VVEY4KGhlYWRlclZhbHVlKSk7CisKKyAgICBtX2h0dHBCb2R5ID0gRm9ybURhdGE6 OmNyZWF0ZShtX3NvdXBNZXNzYWdlLT5yZXF1ZXN0X2JvZHktPmRhdGEsIG1fc291cE1lc3NhZ2Ut PnJlcXVlc3RfYm9keS0+bGVuZ3RoKTsKK30KKwordm9pZCBSZXNvdXJjZVJlcXVlc3Q6OmRvVXBk YXRlUGxhdGZvcm1SZXF1ZXN0KCkKK3sKKyAgICBpZiAoaXNOdWxsKCkpIHsKKyAgICAgICAgaWYg KG1fc291cE1lc3NhZ2UpCisgICAgICAgICAgICBnX29iamVjdF91bnJlZihtX3NvdXBNZXNzYWdl KTsKKyAgICAgICAgbV9zb3VwTWVzc2FnZSA9IDA7CisgICAgICAgIHJldHVybjsKKyAgICB9CisK KyAgICBpZiAoIW1fc291cE1lc3NhZ2UpCisgICAgICAgIG1fc291cE1lc3NhZ2UgPSBzb3VwX21l c3NhZ2VfbmV3KGh0dHBNZXRob2QoKS51dGY4KCkuZGF0YSgpLCB1cmwoKS5zdHJpbmcoKS51dGY4 KCkuZGF0YSgpKTsKKyAgICBlbHNlIHsKKyAgICAgICAgU291cFVSSSogc291cFVSSSA9IHNvdXBf dXJpX25ldyh1cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKyAgICAgICAgc291cF9tZXNz YWdlX3NldF91cmkobV9zb3VwTWVzc2FnZSwgc291cFVSSSk7CisgICAgICAgIHNvdXBfdXJpX2Zy ZWUoc291cFVSSSk7CisKKyAgICAgICAgZ19vYmplY3Rfc2V0KG1fc291cE1lc3NhZ2UsICJtZXRo b2QiLCBodHRwTWV0aG9kKCkudXRmOCgpLmRhdGEoKSwgTlVMTCk7CisgICAgfQorICAgIHNvdXBf bWVzc2FnZV9oZWFkZXJzX2NsZWFyKG1fc291cE1lc3NhZ2UtPnJlcXVlc3RfaGVhZGVycyk7CisK KyAgICBIVFRQSGVhZGVyTWFwIGhlYWRlcnMgPSBodHRwSGVhZGVyRmllbGRzKCk7CisgICAgU291 cE1lc3NhZ2VIZWFkZXJzICpzb3VwSGVhZGVycyA9IG1fc291cE1lc3NhZ2UtPnJlcXVlc3RfaGVh ZGVyczsKKyAgICBpZiAoIWhlYWRlcnMuaXNFbXB0eSgpKSB7CisgICAgICAgIEhUVFBIZWFkZXJN YXA6OmNvbnN0X2l0ZXJhdG9yIGVuZCA9IGhlYWRlcnMuZW5kKCk7CisgICAgICAgIGZvciAoSFRU UEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBoZWFkZXJzLmJlZ2luKCk7IGl0ICE9IGVu ZDsgKytpdCkKKyAgICAgICAgICAgIHNvdXBfbWVzc2FnZV9oZWFkZXJzX2FwcGVuZChzb3VwSGVh ZGVycywgaXQtPmZpcnN0LnN0cmluZygpLnV0ZjgoKS5kYXRhKCksIGl0LT5zZWNvbmQudXRmOCgp LmRhdGEoKSk7CisgICAgfQorCisgICAgLy8gQm9keSBkYXRhIGlzIG9ubHkgaGFuZGxkZWQgYXQg UmVzb3VyY2VIYW5kbGVTb3VwOjpzdGFydEh0dHAKK30KKworfQpkaWZmIC0tZ2l0IGEvV2ViS2l0 L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCAzOTk0YTFhLi41YzBi ZmNlIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3RrL0No YW5nZUxvZwpAQCAtNSw2ICs1LDIwIEBACiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0xODYwOAogICAgICAgICBbR3RrXSBXZWJLaXROZXR3b3JrUmVxdWVz dCBuZWVkcyB0byBiZSBmaW5pc2hlZAogCisgICAgICAgIEV4cG9zZSB0aGUgU291cE1lc3NhZ2Ug b2YgdGhlIHJlcXVlc3QgdGhyb3VnaCBvdXIgV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAgICAgICAg b2JqZWN0LgorCisgICAgICAgICogd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcDoKKyAg ICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVl c3RfZ2V0X3NvdXBfbWVzc2FnZSk6CisgICAgICAgICogd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1 ZXN0Lmg6CisKKzIwMDktMDMtMjQgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGduc0Bnbm9tZS5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE4NjA4CisgICAgICAgIFtHdGtd IFdlYktpdE5ldHdvcmtSZXF1ZXN0IG5lZWRzIHRvIGJlIGZpbmlzaGVkCisKICAgICAgICAgTWFr ZSBvdXIgTmV0d29ya1JlcXVlc3Qgb2JqZWN0IGZ1bmN0aW9uYWxseSBjb21wbGV0ZSwgYnkgbWFr aW5nIGl0CiAgICAgICAgIGNhcnJ5IHRoZSBSZXNvdXJjZVJlcXVlc3QgaXQgcmVwcmVzZW50cyB3 aXRoIGl0LgogCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVx dWVzdC5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKaW5k ZXggMWUzZWYyYy4uZGM1MGZlZiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 bmV0d29ya3JlcXVlc3QuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmty ZXF1ZXN0LmNwcApAQCAtMTc0LDQgKzE3NCwyNSBAQCBHX0NPTlNUX1JFVFVSTiBnY2hhciogd2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZQog ICAgIHJldHVybiBwcml2LT51cmk7CiB9CiAKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVxdWVz dF9nZXRfc291cF9tZXNzYWdlOgorICogQHJlcXVlc3Q6IGEgI1dlYktpdE5ldHdvcmtSZXF1ZXN0 CisgKgorICogT2J0YWlucyB0aGUgI1NvdXBNZXNzYWdlIGhlbGQgYW5kIHVzZWQgYnkgdGhlIGdp dmVuIHJlcXVlc3QuIE5vdGljZQorICogdGhhdCBtb2RpZmljYXRpb24gb2YgdGhlIFNvdXBNZXNz YWdlIG9mIGEgcmVxdWVzdCBieSBzaWduYWwKKyAqIGhhbmRsZXJzIGlzIG9ubHkgc3VwcG9ydGVk IHdoZXJlIGV4cGxpY2l0bHkgZG9jdW1lbnRlZC4KKyAqCisgKiBSZXR1cm5zOiB0aGUgI1NvdXBN ZXNzYWdlCisgKgorICogU2luY2U6IDEuMS40CisgKi8KK1NvdXBNZXNzYWdlKiB3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X2dldF9zb3VwX21lc3NhZ2UoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVl c3QpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVT VChyZXF1ZXN0KSwgTlVMTCk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHBy aXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgcmV0dXJuIHByaXYtPnJlcXVlc3QtPnNvdXBNZXNz YWdlKCk7Cit9CisKIH0KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdv cmtyZXF1ZXN0LmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oCmlu ZGV4IDAxYWI4YmIuLjFmYzZmY2YgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dG5ldHdvcmtyZXF1ZXN0LmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jl cXVlc3QuaApAQCAtMjEsNiArMjEsNyBAQAogI2RlZmluZSBXRUJLSVRfTkVUV09SS19SRVFVRVNU X0gKIAogI2luY2x1ZGUgPGdsaWItb2JqZWN0Lmg+CisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+ CiAKICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0ZGVmaW5lcy5oPgogCkBAIC02NSw2ICs2Niw5IEBA IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaSAgKFdlYktpdE5ldHdvcmtSZXF1ZXN0ICpy ZXF1ZXN0LAogV0VCS0lUX0FQSSBHX0NPTlNUX1JFVFVSTiBnY2hhciAqCiB3ZWJraXRfbmV0d29y a19yZXF1ZXN0X2dldF91cmkgIChXZWJLaXROZXR3b3JrUmVxdWVzdCAqcmVxdWVzdCk7CiAKK1dF QktJVF9BUEkgU291cE1lc3NhZ2UqCit3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9zb3VwX21l c3NhZ2UgKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKwogR19FTkRfREVDTFMKIAog I2VuZGlmCg== 28913 2009-03-24 15:31:03 -0700 2009-05-29 08:08:44 -0700 Make our NetworkRequest object functionally complete, by making it Make-our-NetworkRequest-object-functionally-complete-by-making-it.patch text/plain 11984 gustavo NmE3NzBmZTFiMDllNjc0MjdkNmRiZTAwNjY4YzI5MmQ2ZjJiMGY1MQpkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCA3OWE3MzRlLi4z OTk0YTFhIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3Rr L0NoYW5nZUxvZwpAQCAtMSwzICsxLDMxIEBACisyMDA5LTAzLTI0ICBHdXN0YXZvIE5vcm9uaGEg U2lsdmEgIDxnbnNAZ25vbWUub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x ODYwOAorICAgICAgICBbR3RrXSBXZWJLaXROZXR3b3JrUmVxdWVzdCBuZWVkcyB0byBiZSBmaW5p c2hlZAorCisgICAgICAgIE1ha2Ugb3VyIE5ldHdvcmtSZXF1ZXN0IG9iamVjdCBmdW5jdGlvbmFs bHkgY29tcGxldGUsIGJ5IG1ha2luZyBpdAorICAgICAgICBjYXJyeSB0aGUgUmVzb3VyY2VSZXF1 ZXN0IGl0IHJlcHJlc2VudHMgd2l0aCBpdC4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50R3RrLmNwcDoKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGll bnQ6OmRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTUlNRVR5cGUpOgorICAgICAgICAoV2ViS2l0OjpG cmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JOYXZpZ2F0aW9uQWN0aW9u KToKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQpOgor ICAgICAgICAqIHdlYmtpdC93ZWJraXRkb3dubG9hZC5jcHA6CisgICAgICAgIChfV2ViS2l0RG93 bmxvYWRQcml2YXRlOjp3ZWJraXRfZG93bmxvYWRfc3RhcnQpOgorICAgICAgICAqIHdlYmtpdC93 ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHA6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQ cml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2ZpbmFsaXplKToKKyAgICAgICAgKF9XZWJL aXROZXR3b3JrUmVxdWVzdFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3RfY2xhc3NfaW5p dCk6CisgICAgICAgIChfV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29y a19yZXF1ZXN0X2luaXQpOgorICAgICAgICAoX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6 d2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3JlX3JlcXVlc3QpOgorICAgICAgICAo X1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZTo6d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRf Y29yZV9yZXF1ZXN0KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGU6Ondl YmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3KToKKyAgICAgICAgKF9XZWJLaXROZXR3b3JrUmVxdWVz dFByaXZhdGU6OndlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaSk6CisgICAgICAgIChfV2Vi S2l0TmV0d29ya1JlcXVlc3RQcml2YXRlOjp3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF91cmkp OgorICAgICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmg6CisgICAgICAgICogd2Via2l0L3dl YmtpdHdlYmZyYW1lLmNwcDoKKwogMjAwOS0wMy0yMCAgSmFuIE1pY2hhZWwgQWxvbnpvICA8am1h bG9uem9AZ21haWwuY29tPgogCiAgICAgICAgIE5vdCByZXZpZXdlZC4gRml4IHN0eWxlIGlzc3Vl cyB3aXRoIG15IHByZXZpb3VzIGNvbW1pdCAocjQxODY2KSBhcwpkaWZmIC0tZ2l0IGEvV2ViS2l0 L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAgYi9XZWJLaXQvZ3Rr L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAppbmRleCA4ZTJjMDBjLi5j MGNmNDYzIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50R3RrLmNwcAorKysgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50R3RrLmNwcApAQCAtNTQsNiArNTQsNyBAQAogI2luY2x1ZGUgIndlYmtpdHdlYmZyYW1l LmgiCiAjaW5jbHVkZSAid2Via2l0d2VibmF2aWdhdGlvbmFjdGlvbi5oIgogI2luY2x1ZGUgIndl YmtpdHdlYnBvbGljeWRlY2lzaW9uLmgiCisjaW5jbHVkZSAid2Via2l0bmV0d29ya3JlcXVlc3Qu aCIKICNpbmNsdWRlICJ3ZWJraXRwcml2YXRlLmgiCiAKICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29y ZS9BUElDYXN0Lmg+CkBAIC0yODIsNyArMjgzLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6 ZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JNSU1FVHlwZShGcmFtZVBvbGljeUZ1bmN0aW9uIHBvbGkK ICAgICB9CiAKICAgICBXZWJLaXRXZWJWaWV3KiBwYWdlID0gZ2V0Vmlld0Zyb21GcmFtZShtX2Zy YW1lKTsKLSAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfbmV3KHJlc291cmNlUmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgp KTsKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0KHJlc291cmNlUmVxdWVzdCk7CiAKICAgICBXZWJL aXRXZWJQb2xpY3lEZWNpc2lvbiogcG9saWN5RGVjaXNpb24gPSB3ZWJraXRfd2ViX3BvbGljeV9k ZWNpc2lvbl9uZXcobV9mcmFtZSwgcG9saWN5RnVuY3Rpb24pOwogICAgIGlmIChtX3BvbGljeURl Y2lzaW9uKQpAQCAtMzMxLDcgKzMzMiw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3Bh dGNoRGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlvbkFjdGlvbihGcmFtZVBvbGljeUZ1bmN0CiAgICAg fQogCiAgICAgV2ViS2l0V2ViVmlldyogd2ViVmlldyA9IGdldFZpZXdGcm9tRnJhbWUobV9mcmFt ZSk7Ci0gICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X25ldyhyZXNvdXJjZVJlcXVlc3QudXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7 CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X25ld193aXRoX2NvcmVfcmVxdWVzdChyZXNvdXJjZVJlcXVlc3QpOwogICAgIFdlYktpdE5h dmlnYXRpb25SZXNwb25zZSByZXNwb25zZTsKICAgICAvKgogICAgICAqIFdlIHN0aWxsIHN1cHBv cnQgdGhlIGRlcHJlY2F0ZWQgbmF2aWdhdGlvbi1yZXF1ZXN0ZWQgc2lnbmFsLCBpZiB0aGUKQEAg LTg5Myw3ICs4OTQsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpzZXRNYWluRG9jdW1lbnRF cnJvcihEb2N1bWVudExvYWRlciosIGNvbnN0IFJlc291cmNlRXJybwogCiB2b2lkIEZyYW1lTG9h ZGVyQ2xpZW50OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkK IHsKLSAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogbmV0d29ya1JlcXVlc3QgPSB3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X25ldyhyZXF1ZXN0LnVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOwor ICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiBuZXR3b3JrUmVxdWVzdCA9IHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0KHJlcXVlc3QpOwogICAgIFdlYktpdERvd25s b2FkKiBkb3dubG9hZCA9IHdlYmtpdF9kb3dubG9hZF9uZXcobmV0d29ya1JlcXVlc3QpOwogICAg IGdfb2JqZWN0X3VucmVmKG5ldHdvcmtSZXF1ZXN0KTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0ZG93bmxvYWQuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZG93 bmxvYWQuY3BwCmluZGV4IDQ0ODgzMDQuLjljYzMwNzQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdGRvd25sb2FkLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRk b3dubG9hZC5jcHAKQEAgLTQxNiw5ICs0MTYsNyBAQCB2b2lkIHdlYmtpdF9kb3dubG9hZF9zdGFy dChXZWJLaXREb3dubG9hZCogZG93bmxvYWQpCiAgICAgaWYgKHByaXYtPnJlc291cmNlSGFuZGxl KQogICAgICAgICBwcml2LT5yZXNvdXJjZUhhbmRsZS0+c2V0Q2xpZW50KHByaXYtPmRvd25sb2Fk Q2xpZW50KTsKICAgICBlbHNlIHsKLSAgICAgICAgLy8gRklYTUU6IFVzZSB0aGUgYWN0dWFsIHJl cXVlc3Qgb2JqZWN0IHdoZW4gV2ViS2l0TmV0d29ya1JlcXVlc3QgaXMgZmluaXNoZWQuCi0gICAg ICAgIFJlc291cmNlUmVxdWVzdCByZXF1ZXN0KHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3Vy aShwcml2LT5uZXR3b3JrUmVxdWVzdCkpOwotICAgICAgICBwcml2LT5yZXNvdXJjZUhhbmRsZSA9 IFJlc291cmNlSGFuZGxlOjpjcmVhdGUocmVxdWVzdCwgcHJpdi0+ZG93bmxvYWRDbGllbnQsIDAs IGZhbHNlLCBmYWxzZSwgZmFsc2UpOworICAgICAgICBwcml2LT5yZXNvdXJjZUhhbmRsZSA9IFJl c291cmNlSGFuZGxlOjpjcmVhdGUoKmNvcmUocHJpdi0+bmV0d29ya1JlcXVlc3QpLCBwcml2LT5k b3dubG9hZENsaWVudCwgMCwgZmFsc2UsIGZhbHNlLCBmYWxzZSk7CiAgICAgfQogCiAgICAgcHJp di0+dGltZXIgPSBnX3RpbWVyX25ldygpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0bmV0d29ya3JlcXVlc3QuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29y a3JlcXVlc3QuY3BwCmluZGV4IDNhZDhiNWQuLjg1ZDgwOWMgMTAwNjQ0Ci0tLSBhL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKQEAgLTEsNSArMSw2IEBACiAvKgogICogQ29weXJp Z2h0IChDKSAyMDA3LCAyMDA4IEhvbGdlciBIYW5zIFBldGVyIEZyZXl0aGVyCisgKiBDb3B5cmln aHQgKEMpIDIwMDkgR3VzdGF2byBOb3JvbmhhIFNpbHZhCiAgKgogICogVGhpcyBsaWJyYXJ5IGlz IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9kaWZ5 IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAg LTE4LDkgKzE5LDEzIEBACiAgKi8KIAogI2luY2x1ZGUgImNvbmZpZy5oIgotCiAjaW5jbHVkZSAi d2Via2l0bmV0d29ya3JlcXVlc3QuaCIKIAorI2luY2x1ZGUgIkNTdHJpbmcuaCIKKyNpbmNsdWRl ICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgIlJlc291cmNlUmVxdWVzdC5oIgorI2luY2x1 ZGUgIndlYmtpdHByaXZhdGUuaCIKKwogLyoqCiAgKiBTRUNUSU9OOndlYmtpdG5ldHdvcmtyZXF1 ZXN0CiAgKiBAc2hvcnRfZGVzY3JpcHRpb246IFRoZSB0YXJnZXQgb2YgYSBuYXZpZ2F0aW9uIHJl cXVlc3QKQEAgLTM0LDEyICszOSwyMCBAQAogICoKICAqLwogCit1c2luZyBuYW1lc3BhY2UgV2Vi Q29yZTsKKwogZXh0ZXJuICJDIiB7CiAKIEdfREVGSU5FX1RZUEUoV2ViS2l0TmV0d29ya1JlcXVl c3QsIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3QsIEdfVFlQRV9PQkpFQ1QpOwogCisvLyBUaGUgbXVz dEZyZWVSZXF1ZXN0IHZhcmlhYmxlIGhlcmUgaXMgdXNlZCB0byBzdG9yZSBpZiB0aGUKKy8vIFJl c291cmNlUmVxdWVzdCB3ZSBhcmUgc3RvcmluZyBpcyBvd25lZCBieSB1cyBvciBieSBXZWJDb3Jl OyB0aGlzCisvLyB3b24ndCBiZSBuZWVkZWQgd2hlbi9pZiBSZXNvdXJjZVJlcXVlc3QgaXMgcmVm ZXJlbmNlIGNvdW50ZWQuCiBzdHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSB7CiAg ICAgZ2NoYXIqIHVyaTsKKworICAgIFJlc291cmNlUmVxdWVzdCogcmVxdWVzdDsKKyAgICBnYm9v bGVhbiBtdXN0RnJlZVJlcXVlc3Q7CiB9OwogCiAjZGVmaW5lIFdFQktJVF9ORVRXT1JLX1JFUVVF U1RfR0VUX1BSSVZBVEUob2JqKSAoR19UWVBFX0lOU1RBTkNFX0dFVF9QUklWQVRFKChvYmopLCBX RUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSkp CkBAIC01MSwxMiArNjQsMTcgQEAgc3RhdGljIHZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9m aW5hbGl6ZShHT2JqZWN0KiBvYmplY3QpCiAKICAgICBnX2ZyZWUocHJpdi0+dXJpKTsKIAorICAg IGlmIChwcml2LT5tdXN0RnJlZVJlcXVlc3QpCisgICAgICAgIGRlbGV0ZSBwcml2LT5yZXF1ZXN0 OworCiAgICAgR19PQkpFQ1RfQ0xBU1Mod2Via2l0X25ldHdvcmtfcmVxdWVzdF9wYXJlbnRfY2xh c3MpLT5maW5hbGl6ZShvYmplY3QpOwogfQogCiBzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X2NsYXNzX2luaXQoV2ViS2l0TmV0d29ya1JlcXVlc3RDbGFzcyogcmVxdWVzdENsYXNz KQogewotICAgIEdfT0JKRUNUX0NMQVNTKHJlcXVlc3RDbGFzcyktPmZpbmFsaXplID0gd2Via2l0 X25ldHdvcmtfcmVxdWVzdF9maW5hbGl6ZTsKKyAgICBHT2JqZWN0Q2xhc3MqIG9iamVjdENsYXNz ID0gR19PQkpFQ1RfQ0xBU1MocmVxdWVzdENsYXNzKTsKKworICAgIG9iamVjdENsYXNzLT5maW5h bGl6ZSA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZmluYWxpemU7CiAKICAgICBnX3R5cGVfY2xh c3NfYWRkX3ByaXZhdGUocmVxdWVzdENsYXNzLCBzaXplb2YoV2ViS2l0TmV0d29ya1JlcXVlc3RQ cml2YXRlKSk7CiB9CkBAIC02NSwyMCArODMsNTQgQEAgc3RhdGljIHZvaWQgd2Via2l0X25ldHdv cmtfcmVxdWVzdF9pbml0KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQogewogICAgIFdl YktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IFdFQktJVF9ORVRXT1JLX1JFUVVFU1Rf R0VUX1BSSVZBVEUocmVxdWVzdCk7CiAgICAgcmVxdWVzdC0+cHJpdiA9IHByaXY7CisKKyAgICAv LyBXZSB1c3VhbGx5IGdldCBhIFJlc291cmNlUmVxdWVzdCB0aGF0IGlzIG93bmVkIGJ5IFdlYkNv cmUsIGFuZAorICAgIC8vIHdlIG5lZWQgbm90IGNhcmUgYWJvdXQgaXRzIGxpZmV0aW1lCisgICAg cHJpdi0+bXVzdEZyZWVSZXF1ZXN0ID0gRkFMU0U7Cit9CisKKy8vIGZvciBpbnRlcm5hbCB1c2Ug b25seQorV2ViS2l0TmV0d29ya1JlcXVlc3QqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X3dp dGhfY29yZV9yZXF1ZXN0KGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0KQor eworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gV0VCS0lUX05FVFdPUktfUkVR VUVTVChnX29iamVjdF9uZXcoV0VCS0lUX1RZUEVfTkVUV09SS19SRVFVRVNULCBOVUxMKSk7Cisg ICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKKwor ICAgIHByaXYtPnJlcXVlc3QgPSAmKGNvbnN0X2Nhc3Q8UmVzb3VyY2VSZXF1ZXN0Jj4ocmVzb3Vy Y2VSZXF1ZXN0KSk7CisKKyAgICByZXR1cm4gcmVxdWVzdDsKIH0KIAorLyoqCisgKiB3ZWJraXRf bmV0d29ya19yZXF1ZXN0X25ldzoKKyAqIEB1cmk6IGFuIFVSSQorICoKKyAqIENyZWF0ZXMgYSBu ZXcgI1dlYktpdE5ldHdvcmtSZXF1ZXN0IGluaXRpYWxpemVkIHdpdGggYW4gVVJJLgorICoKKyAq IFJldHVybnM6IGEgbmV3ICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICovCiBXZWJLaXROZXR3b3Jr UmVxdWVzdCogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXcoY29uc3QgZ2NoYXIqIHVyaSkKIHsK ICAgICBnX3JldHVybl92YWxfaWZfZmFpbCh1cmksIE5VTEwpOwogCi0gICAgV2ViS2l0TmV0d29y a1JlcXVlc3QqIHJlcXVlc3QgPSBXRUJLSVRfTkVUV09SS19SRVFVRVNUKGdfb2JqZWN0X25ldyhX RUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIE5VTEwpKTsKKyAgICBSZXNvdXJjZVJlcXVlc3Qq IHJlc291cmNlUmVxdWVzdCA9IG5ldyBSZXNvdXJjZVJlcXVlc3QoS1VSTChLVVJMKCksIFN0cmlu Zzo6ZnJvbVVURjgodXJpKSkpOworCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3Qg PSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2NvcmVfcmVxdWVzdCgoY29uc3QgUmVz b3VyY2VSZXF1ZXN0JikqcmVzb3VyY2VSZXF1ZXN0KTsKICAgICBXZWJLaXROZXR3b3JrUmVxdWVz dFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OwogCi0gICAgcHJpdi0+dXJpID0gZ19zdHJk dXAodXJpKTsKKyAgICAvLyBTaW5jZSB3ZSBhcmUgY3JlYXRpbmcgdGhpcyBSZXNvdXJjZVJlcXVl c3Qgb3Vyc2VsdmVzLCB3ZSB3aWxsCisgICAgLy8gbmVlZCB0byBmcmVlIGl0IGluIGRpc3Bvc2Uu CisgICAgcHJpdi0+bXVzdEZyZWVSZXF1ZXN0ID0gVFJVRTsKIAogICAgIHJldHVybiByZXF1ZXN0 OwogfQogCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaToKKyAqIEByZXF1 ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICogQHVyaTogYW4gVVJJCisgKgorICogU2V0 cyB0aGUgVVJJIGhlbGQgYW5kIHVzZWQgYnkgdGhlIGdpdmVuIHJlcXVlc3QuCisgKi8KIHZvaWQg d2Via2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1 ZXN0LCBjb25zdCBnY2hhciogdXJpKQogewogICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lT X05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSk7CkBAIC04NywyMyArMTM5LDM5IEBAIHZvaWQgd2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0 LCBjb25zdCBnY2hhcioKICAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSBy ZXF1ZXN0LT5wcml2OwogCiAgICAgZ19mcmVlKHByaXYtPnVyaSk7Ci0gICAgcHJpdi0+dXJpID0g Z19zdHJkdXAodXJpKTsKKyAgICBwcml2LT5yZXF1ZXN0LT5zZXRVUkwoS1VSTChLVVJMKCksIFN0 cmluZzo6ZnJvbVVURjgodXJpKSkpOwogfQogCiAvKioKICAqIHdlYmtpdF9uZXR3b3JrX3JlcXVl c3RfZ2V0X3VyaToKICAqIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAogICoKKyAq IEdldHMgdGhlIFVSSSBoZWxkIGFuZCB1c2VkIGJ5IHRoZSBnaXZlbiByZXF1ZXN0LgorICoKICAq IFJldHVybnM6IHRoZSB1cmkgb2YgdGhlICNXZWJLaXROZXR3b3JrUmVxdWVzdAogICoKICAqIFNp bmNlOiAxLjAuMAorICoKKyAqIFJldHVybnM6IHRoZSBVUkkgaGVsZCBhbmQgdXNlZCBieSB0aGUg Z2l2ZW4gcmVxdWVzdAogICovCiBHX0NPTlNUX1JFVFVSTiBnY2hhciogd2Via2l0X25ldHdvcmtf cmVxdWVzdF9nZXRfdXJpKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQogewogICAgIGdf cmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIE5V TEwpOwogCiAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+ cHJpdjsKKworICAgIGlmIChwcml2LT51cmkgPT0gTlVMTCkKKyAgICAgICAgcHJpdi0+dXJpID0g Z19zdHJkdXAocHJpdi0+cmVxdWVzdC0+dXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisK ICAgICByZXR1cm4gcHJpdi0+dXJpOwogfQogCiB9CisKK1Jlc291cmNlUmVxdWVzdCogV2ViS2l0 Ojpjb3JlKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIFdlYktpdE5ldHdv cmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICByZXR1cm4gcHJp di0+cmVxdWVzdDsKK30KKwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJp dmF0ZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCmluZGV4IDBiODNhMTEu LjM0NDM2YTkgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAor KysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKQEAgLTIzLDcgKzIzLDggQEAK ICNkZWZpbmUgV0VCS0lUX1BSSVZBVEVfSAogCiAvKgotICogVGhpcyBmaWxlIGtub3dzIHRoZSBz aGFyZWQgc2VjcmV0IG9mIFdlYktpdFdlYlZpZXcgYW5kIFdlYktpdFdlYkZyYW1lLgorICogVGhp cyBmaWxlIGtub3dzIHRoZSBzaGFyZWQgc2VjcmV0IG9mIFdlYktpdFdlYlZpZXcsIFdlYktpdFdl YkZyYW1lLAorICogYW5kIFdlYktpdE5ldHdvcmtSZXF1ZXN0LgogICogVGhleSBhcmUgdXNpbmcg V2ViQ29yZSB3aGljaCBtdXNuJ3QgYmUgZXhwb3NlZCB0byB0aGUgb3V0ZXIgd29ybGQuCiAgKi8K IApAQCAtMzYsNiArMzcsNyBAQAogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJzZXR0aW5ncy5o PgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJ3aW5kb3dmZWF0dXJlcy5oPgogI2luY2x1ZGUg PHdlYmtpdC93ZWJraXR3ZWJiYWNrZm9yd2FyZGxpc3QuaD4KKyNpbmNsdWRlIDx3ZWJraXQvd2Vi a2l0bmV0d29ya3JlcXVlc3QuaD4KIAogI2luY2x1ZGUgIkJhY2tGb3J3YXJkTGlzdC5oIgogI2lu Y2x1ZGUgIkhpc3RvcnlJdGVtLmgiCkBAIC00NSw2ICs0Nyw3IEBACiAjaW5jbHVkZSAiSW5zcGVj dG9yQ2xpZW50R3RrLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkZXJDbGllbnQuaCIKICNpbmNsdWRl ICJSZXNvdXJjZUhhbmRsZS5oIgorI2luY2x1ZGUgIlJlc291cmNlUmVxdWVzdC5oIgogI2luY2x1 ZGUgIlJlc291cmNlUmVzcG9uc2UuaCIKICNpbmNsdWRlICJXaW5kb3dGZWF0dXJlcy5oIgogCkBA IC02OCw2ICs3MSw5IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiAgICAgV2ViS2l0V2ViTmF2aWdh dGlvblJlYXNvbiBraXQoV2ViQ29yZTo6TmF2aWdhdGlvblR5cGUgdHlwZSk7CiAgICAgV2ViQ29y ZTo6TmF2aWdhdGlvblR5cGUgY29yZShXZWJLaXRXZWJOYXZpZ2F0aW9uUmVhc29uIHJlYXNvbik7 CisKKyAgICBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QqIGNvcmUoV2ViS2l0TmV0d29ya1JlcXVl c3QqIHJlcXVlc3QpOworCiB9CiAKIGV4dGVybiAiQyIgewpAQCAtMTY0LDYgKzE3MCw5IEBAIGV4 dGVybiAiQyIgewogICAgIHZvaWQKICAgICB3ZWJraXRfd2ViX3BvbGljeV9kZWNpc2lvbl9jYW5j ZWwgKFdlYktpdFdlYlBvbGljeURlY2lzaW9uKiBkZWNpc2lvbik7CiAKKyAgICBXZWJLaXROZXR3 b3JrUmVxdWVzdCoKKyAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2NvcmVfcmVx dWVzdChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCk7CisK ICAgICAvLyBGSVhNRTogbW92ZSB0aGlzIGZ1bmN0aW9uYWxpdHkgaW50byBhICdXZWJLaXRXZWJE YXRhU291cmNlJyBvbmNlIGltcGxlbWVudGVkCiAgICAgV0VCS0lUX0FQSSBnY2hhcioKICAgICB3 ZWJraXRfd2ViX2ZyYW1lX2dldF9yZXNwb25zZV9taW1lX3R5cGUoV2ViS2l0V2ViRnJhbWUqIGZy YW1lKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcCBi L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcAppbmRleCBlMmIxMGI2Li4xYzA0 NTNmIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKKysr IGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCkBAIC00NDksOSArNDQ5LDcg QEAgdm9pZCB3ZWJraXRfd2ViX2ZyYW1lX2xvYWRfcmVxdWVzdChXZWJLaXRXZWJGcmFtZSogZnJh bWUsIFdlYktpdE5ldHdvcmtSZXF1ZXN0KgogICAgIGlmICghY29yZUZyYW1lKQogICAgICAgICBy ZXR1cm47CiAKLSAgICAvLyBUT0RPOiBVc2UgdGhlIFJlc291cmNlUmVxdWVzdCBjYXJyaWVkIGJ5 IFdlYktpdE5ldHdvcmtSZXF1ZXN0IHdoZW4gaXQgaXMgaW1wbGVtZW50ZWQuCi0gICAgU3RyaW5n IHN0cmluZyA9IFN0cmluZzo6ZnJvbVVURjgod2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJp KHJlcXVlc3QpKTsKLSAgICBjb3JlRnJhbWUtPmxvYWRlcigpLT5sb2FkKFJlc291cmNlUmVxdWVz dChLVVJMKEtVUkwoKSwgc3RyaW5nKSksIGZhbHNlKTsKKyAgICBjb3JlRnJhbWUtPmxvYWRlcigp LT5sb2FkKGNvbnN0X2Nhc3Q8UmVzb3VyY2VSZXF1ZXN0Jj4oKmNvcmUocmVxdWVzdCkpLCBmYWxz ZSk7CiB9CiAKIC8qKgo= 30604 2009-05-22 22:07:01 -0700 2009-05-29 08:08:44 -0700 Make NetworkRequest carry a reference of the SoupMessage used by ResourceRequest Make-NetworkRequest-carry-a-reference-of-the-SoupMessage-used-by-ResourceRequest.patch text/plain 17289 gustavo NTVmZmI2MGM1MDQwZTNmYTQwN2ZlYzM1NWE2YjYwODlhYTMxZjdiMgpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAwMzIzNjc2Li5lYWRlMjkw IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpA QCAtMSwzICsxLDIxIEBACisyMDA5LTA1LTIyICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxnbnNA Z25vbWUub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIE1ha2UgU291cE1lc3NhZ2UgYSBtZW1iZXIgb2YgUmVzb3VyY2VSZXF1ZXN0LCBpbnN0ZWFk IG9mIGNyZWF0aW5nCisgICAgICAgIGl0IGluIHN0YXJ0SHR0cC4gSW1wbGVtZW50IHVwZGF0aW5n IG9mIFJlc291cmNlUmVxdWVzdCBmcm9tCisgICAgICAgIFNvdXBNZXNzYWdlLCBhbmQgdmljZSB2 ZXJzYS4KKworICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOgorICAgICAgICAqIHBsYXRmb3JtL25l dHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVz b3VyY2VIYW5kbGU6OnN0YXJ0SHR0cCk6CisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9zb3Vw L1Jlc291cmNlUmVxdWVzdC5oOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0OjpS ZXNvdXJjZVJlcXVlc3QpOgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJj ZVJlcXVlc3RTb3VwLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZVJlcXVl c3Q6OnNvdXBNZXNzYWdlKToKKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdDo6ZG9V cGRhdGVSZXNvdXJjZVJlcXVlc3QpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0 Ojpkb1VwZGF0ZVBsYXRmb3JtUmVxdWVzdCk6CisKIDIwMDktMDUtMjIgIERhcmluIEFkbGVyICA8 ZGFyaW5AYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhbiBCZXJuc3RlaW4uCmRp ZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtIGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5h bQppbmRleCAzZTBmMDYzLi5hYmU3YzBhIDEwMDY0NAotLS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxl LmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KQEAgLTE4NjQsNiArMTg2NCw3IEBAIHdl YmNvcmVndGtfc291cmNlcyArPSBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvRE5T U291cC5jcHAgXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlRXJyb3Iu aCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNw cCBcCisJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0U291cC5j cHAgXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdC5oIFwK IAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlc3BvbnNlLmggXAogCVdl YkNvcmUvcGxhdGZvcm0vdGV4dC9ndGsvVGV4dEJyZWFrSXRlcmF0b3JJbnRlcm5hbElDVUd0ay5j cHAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFu ZGxlU291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRs ZVNvdXAuY3BwCmluZGV4IDdmMDEzNWEuLjY2Njc5ZGUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxh dGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKKysrIGIvV2ViQ29yZS9w bGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcApAQCAtNDY1LDIxICs0 NjUsMTMgQEAgYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRIdHRwKFN0cmluZyB1cmxTdHJpbmcp CiAgICAgU291cFNlc3Npb24qIHNlc3Npb24gPSBkZWZhdWx0U2Vzc2lvbigpOwogICAgIGVuc3Vy ZVNlc3Npb25Jc0luaXRpYWxpemVkKHNlc3Npb24pOwogCi0gICAgU291cE1lc3NhZ2UqIG1zZzsK LSAgICBtc2cgPSBzb3VwX21lc3NhZ2VfbmV3KHJlcXVlc3QoKS5odHRwTWV0aG9kKCkudXRmOCgp LmRhdGEoKSwgdXJsU3RyaW5nLnV0ZjgoKS5kYXRhKCkpOworICAgIFNvdXBNZXNzYWdlKiBtc2cg PSByZXF1ZXN0KCkuc291cE1lc3NhZ2UoKTsKICAgICBnX3NpZ25hbF9jb25uZWN0KG1zZywgInJl c3RhcnRlZCIsIEdfQ0FMTEJBQ0socmVzdGFydGVkQ2FsbGJhY2spLCB0aGlzKTsKICAgICBnX3Np Z25hbF9jb25uZWN0KG1zZywgImdvdC1oZWFkZXJzIiwgR19DQUxMQkFDSyhnb3RIZWFkZXJzQ2Fs bGJhY2spLCB0aGlzKTsKICAgICBnX3NpZ25hbF9jb25uZWN0KG1zZywgImdvdC1jaHVuayIsIEdf Q0FMTEJBQ0soZ290Q2h1bmtDYWxsYmFjayksIHRoaXMpOwogCiAgICAgZ19vYmplY3Rfc2V0X2Rh dGEoR19PQkpFQ1QobXNnKSwgInJlc291cmNlSGFuZGxlIiwgcmVpbnRlcnByZXRfY2FzdDx2b2lk Kj4odGhpcykpOwogCi0gICAgSFRUUEhlYWRlck1hcCBjdXN0b21IZWFkZXJzID0gZC0+bV9yZXF1 ZXN0Lmh0dHBIZWFkZXJGaWVsZHMoKTsKLSAgICBpZiAoIWN1c3RvbUhlYWRlcnMuaXNFbXB0eSgp KSB7Ci0gICAgICAgIEhUVFBIZWFkZXJNYXA6OmNvbnN0X2l0ZXJhdG9yIGVuZCA9IGN1c3RvbUhl YWRlcnMuZW5kKCk7Ci0gICAgICAgIGZvciAoSFRUUEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0b3Ig aXQgPSBjdXN0b21IZWFkZXJzLmJlZ2luKCk7IGl0ICE9IGVuZDsgKytpdCkKLSAgICAgICAgICAg IHNvdXBfbWVzc2FnZV9oZWFkZXJzX2FwcGVuZChtc2ctPnJlcXVlc3RfaGVhZGVycywgaXQtPmZp cnN0LnN0cmluZygpLnV0ZjgoKS5kYXRhKCksIGl0LT5zZWNvbmQudXRmOCgpLmRhdGEoKSk7Ci0g ICAgfQotCiAgICAgRm9ybURhdGEqIGh0dHBCb2R5ID0gZC0+bV9yZXF1ZXN0Lmh0dHBCb2R5KCk7 CiAgICAgaWYgKGh0dHBCb2R5ICYmICFodHRwQm9keS0+aXNFbXB0eSgpKSB7CiAgICAgICAgIHNp emVfdCBudW1FbGVtZW50cyA9IGh0dHBCb2R5LT5lbGVtZW50cygpLnNpemUoKTsKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdC5oIGIvV2Vi Q29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0LmgKaW5kZXggZWZiMTI0 MC4uYWI3ODRiYiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVz b3VyY2VSZXF1ZXN0LmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3Vy Y2VSZXF1ZXN0LmgKQEAgLTI5LDM2ICsyOSw1MSBAQAogCiAjaW5jbHVkZSAiUmVzb3VyY2VSZXF1 ZXN0QmFzZS5oIgogCisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+CisKIG5hbWVzcGFjZSBXZWJD b3JlIHsKIAogICAgIHN0cnVjdCBSZXNvdXJjZVJlcXVlc3QgOiBSZXNvdXJjZVJlcXVlc3RCYXNl IHsKIAogICAgICAgICBSZXNvdXJjZVJlcXVlc3QoY29uc3QgU3RyaW5nJiB1cmwpCiAgICAgICAg ICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UoS1VSTCh1cmwpLCBVc2VQcm90b2NvbENhY2hlUG9s aWN5KQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKDApCiAgICAgICAgIHsKICAgICAgICAg fQogCiAgICAgICAgIFJlc291cmNlUmVxdWVzdChjb25zdCBLVVJMJiB1cmwpCiAgICAgICAgICAg ICA6IFJlc291cmNlUmVxdWVzdEJhc2UodXJsLCBVc2VQcm90b2NvbENhY2hlUG9saWN5KQorICAg ICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKDApCiAgICAgICAgIHsKICAgICAgICAgfQogCiAgICAg ICAgIFJlc291cmNlUmVxdWVzdChjb25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmluZyYgcmVmZXJy ZXIsIFJlc291cmNlUmVxdWVzdENhY2hlUG9saWN5IHBvbGljeSA9IFVzZVByb3RvY29sQ2FjaGVQ b2xpY3kpCiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UodXJsLCBwb2xpY3kpCisg ICAgICAgICAgICAsIG1fc291cE1lc3NhZ2UoMCkKICAgICAgICAgewogICAgICAgICAgICAgc2V0 SFRUUFJlZmVycmVyKHJlZmVycmVyKTsKICAgICAgICAgfQogCiAgICAgICAgIFJlc291cmNlUmVx dWVzdCgpCiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UoS1VSTCgpLCBVc2VQcm90 b2NvbENhY2hlUG9saWN5KQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKDApCiAgICAgICAg IHsKICAgICAgICAgfQogCisgICAgICAgIFJlc291cmNlUmVxdWVzdChTb3VwTWVzc2FnZSogc291 cE1lc3NhZ2UpCisgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UoKQorICAgICAgICAg ICAgLCBtX3NvdXBNZXNzYWdlKHNvdXBNZXNzYWdlKQorICAgICAgICB7CisgICAgICAgIH0KKwor ICAgICAgICBTb3VwTWVzc2FnZSogc291cE1lc3NhZ2UoKSBjb25zdDsKKwogICAgIHByaXZhdGU6 CisgICAgICAgIFNvdXBNZXNzYWdlKiBtX3NvdXBNZXNzYWdlOwogICAgICAgICBmcmllbmQgY2xh c3MgUmVzb3VyY2VSZXF1ZXN0QmFzZTsKIAotICAgICAgICB2b2lkIGRvVXBkYXRlUGxhdGZvcm1S ZXF1ZXN0KCkge30KLSAgICAgICAgdm9pZCBkb1VwZGF0ZVJlc291cmNlUmVxdWVzdCgpIHt9Cisg ICAgICAgIHZvaWQgZG9VcGRhdGVQbGF0Zm9ybVJlcXVlc3QoKTsKKyAgICAgICAgdm9pZCBkb1Vw ZGF0ZVJlc291cmNlUmVxdWVzdCgpOwogICAgIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVz dFNvdXAuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0 U291cC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYmJkOTMwNAotLS0g L2Rldi9udWxsCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVx dWVzdFNvdXAuY3BwCkBAIC0wLDAgKzEsOTMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkg R3VzdGF2byBOb3JvbmhhIFNpbHZhCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdh cmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBw dWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJz aW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNp b24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQg aXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQg ZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5F U1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBo YXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElC LiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5j LiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAt MTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2luY2x1ZGUgIkNTdHJp bmcuaCIKKyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgIlJlc291cmNlUmVx dWVzdC5oIgorCisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+CisKK25hbWVzcGFjZSBXZWJDb3Jl IHsKKworU291cE1lc3NhZ2UqIFJlc291cmNlUmVxdWVzdDo6c291cE1lc3NhZ2UoKSBjb25zdAor eworICAgIHVwZGF0ZVBsYXRmb3JtUmVxdWVzdCgpOworCisgICAgcmV0dXJuIG1fc291cE1lc3Nh Z2U7Cit9CisKK3ZvaWQgUmVzb3VyY2VSZXF1ZXN0Ojpkb1VwZGF0ZVJlc291cmNlUmVxdWVzdCgp Cit7CisgICAgU291cFVSSSogc291cFVSSSA9IHNvdXBfbWVzc2FnZV9nZXRfdXJpKG1fc291cE1l c3NhZ2UpOworCisgICAgZ2NoYXIqIHVyaSA9IHNvdXBfdXJpX3RvX3N0cmluZyhzb3VwVVJJLCBG QUxTRSk7CisgICAgbV91cmwgPSBLVVJMKEtVUkwoKSwgU3RyaW5nOjpmcm9tVVRGOCh1cmkpKTsK KyAgICBnX2ZyZWUodXJpKTsKKworICAgIG1faHR0cE1ldGhvZCA9IFN0cmluZzo6ZnJvbVVURjgo bV9zb3VwTWVzc2FnZS0+bWV0aG9kKTsKKworICAgIFNvdXBNZXNzYWdlSGVhZGVyc0l0ZXIgaGVh ZGVyc0l0ZXI7CisgICAgY29uc3QgY2hhciogaGVhZGVyTmFtZTsKKyAgICBjb25zdCBjaGFyKiBo ZWFkZXJWYWx1ZTsKKworICAgIHNvdXBfbWVzc2FnZV9oZWFkZXJzX2l0ZXJfaW5pdCgmaGVhZGVy c0l0ZXIsIG1fc291cE1lc3NhZ2UtPnJlcXVlc3RfaGVhZGVycyk7CisgICAgd2hpbGUgKHNvdXBf bWVzc2FnZV9oZWFkZXJzX2l0ZXJfbmV4dCgmaGVhZGVyc0l0ZXIsICZoZWFkZXJOYW1lLCAmaGVh ZGVyVmFsdWUpKQorICAgICAgICBtX2h0dHBIZWFkZXJGaWVsZHMuc2V0KFN0cmluZzo6ZnJvbVVU RjgoaGVhZGVyTmFtZSksIFN0cmluZzo6ZnJvbVVURjgoaGVhZGVyVmFsdWUpKTsKKworICAgIG1f aHR0cEJvZHkgPSBGb3JtRGF0YTo6Y3JlYXRlKG1fc291cE1lc3NhZ2UtPnJlcXVlc3RfYm9keS0+ ZGF0YSwgbV9zb3VwTWVzc2FnZS0+cmVxdWVzdF9ib2R5LT5sZW5ndGgpOworfQorCit2b2lkIFJl c291cmNlUmVxdWVzdDo6ZG9VcGRhdGVQbGF0Zm9ybVJlcXVlc3QoKQoreworICAgIGlmIChpc051 bGwoKSkgeworICAgICAgICBpZiAobV9zb3VwTWVzc2FnZSkKKyAgICAgICAgICAgIGdfb2JqZWN0 X3VucmVmKG1fc291cE1lc3NhZ2UpOworICAgICAgICBtX3NvdXBNZXNzYWdlID0gMDsKKyAgICAg ICAgcmV0dXJuOworICAgIH0KKworICAgIGlmICghbV9zb3VwTWVzc2FnZSkgeworICAgICAgICBt X3NvdXBNZXNzYWdlID0gc291cF9tZXNzYWdlX25ldyhodHRwTWV0aG9kKCkudXRmOCgpLmRhdGEo KSwgdXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisKKyAgICAgICAgaWYgKCFtX3NvdXBN ZXNzYWdlKQorICAgICAgICAgICAgcmV0dXJuOworICAgIH0gZWxzZSB7CisgICAgICAgIFNvdXBV UkkqIHNvdXBVUkkgPSBzb3VwX3VyaV9uZXcodXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7 CisgICAgICAgIHNvdXBfbWVzc2FnZV9zZXRfdXJpKG1fc291cE1lc3NhZ2UsIHNvdXBVUkkpOwor ICAgICAgICBzb3VwX3VyaV9mcmVlKHNvdXBVUkkpOworCisgICAgICAgIGdfb2JqZWN0X3NldCht X3NvdXBNZXNzYWdlLCAibWV0aG9kIiwgaHR0cE1ldGhvZCgpLnV0ZjgoKS5kYXRhKCksIE5VTEwp OworCisgICAgICAgIHNvdXBfbWVzc2FnZV9oZWFkZXJzX2NsZWFyKG1fc291cE1lc3NhZ2UtPnJl cXVlc3RfaGVhZGVycyk7CisgICAgfQorCisgICAgSFRUUEhlYWRlck1hcCBoZWFkZXJzID0gaHR0 cEhlYWRlckZpZWxkcygpOworICAgIFNvdXBNZXNzYWdlSGVhZGVycyogc291cEhlYWRlcnMgPSBt X3NvdXBNZXNzYWdlLT5yZXF1ZXN0X2hlYWRlcnM7CisgICAgaWYgKCFoZWFkZXJzLmlzRW1wdHko KSkgeworICAgICAgICBIVFRQSGVhZGVyTWFwOjpjb25zdF9pdGVyYXRvciBlbmQgPSBoZWFkZXJz LmVuZCgpOworICAgICAgICBmb3IgKEhUVFBIZWFkZXJNYXA6OmNvbnN0X2l0ZXJhdG9yIGl0ID0g aGVhZGVycy5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpCisgICAgICAgICAgICBzb3VwX21lc3Nh Z2VfaGVhZGVyc19hcHBlbmQoc291cEhlYWRlcnMsIGl0LT5maXJzdC5zdHJpbmcoKS51dGY4KCku ZGF0YSgpLCBpdC0+c2Vjb25kLnV0ZjgoKS5kYXRhKCkpOworICAgIH0KKworICAgIC8vIEJvZHkg ZGF0YSBpcyBvbmx5IGhhbmRsZGVkIGF0IFJlc291cmNlSGFuZGxlU291cDo6c3RhcnRIdHRwCit9 CisKK30KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIvV2ViS2l0L2d0ay9DaGFu Z2VMb2cKaW5kZXggMjNmODk4Ni4uY2U5YWI0NyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9DaGFu Z2VMb2cKKysrIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKQEAgLTEsNSArMSwyOCBAQAogMjAwOS0w NS0yMiAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4KIAorICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBNYWtlIE5ldHdvcmtSZXF1ZXN0 IGNhcnJ5IGEgcmVmZXJlbmNlIG9mIHRoZSBTb3VwTWVzc2FnZSB1c2VkIGJ5CisgICAgICAgIFJl c291cmNlUmVxdWVzdCwgYW5kIHVzZSB0aGF0IHRvIGNyZWF0ZSBuZXcgUmVzb3VyY2VSZXF1ZXN0 cyB3aGVyZQorICAgICAgICBuZWVkZWQsIHNvIHRoYXQgbm8gaW5mb3JtYXRpb24gaXMgbG9zdCB3 aGlsZSBwYXNzaW5nIGFyb3VuZAorICAgICAgICBOZXR3b3JrUmVxdWVzdCBvYmplY3RzLgorCisg ICAgICAgICogV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwOgorICAgICAg ICAoV2ViS2l0OjpGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JNSU1F VHlwZSk6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERlY2lk ZVBvbGljeUZvck5hdmlnYXRpb25BY3Rpb24pOgorICAgICAgICAoV2ViS2l0OjpGcmFtZUxvYWRl ckNsaWVudDo6c3RhcnREb3dubG9hZCk6CisgICAgICAgICogd2Via2l0L3dlYmtpdGRvd25sb2Fk LmNwcDoKKyAgICAgICAgKHdlYmtpdF9kb3dubG9hZF9zdGFydCk6CisgICAgICAgICogd2Via2l0 L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcDoKKyAgICAgICAgKHdlYmtpdF9uZXR3b3JrX3JlcXVl c3RfZmluYWxpemUpOgorICAgICAgICAod2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9j b3JlX3JlcXVlc3QpOgorICAgICAgICAod2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWVzc2Fn ZSk6CisgICAgICAgICogd2Via2l0L3dlYmtpdHByaXZhdGUuaDoKKyAgICAgICAgKiB3ZWJraXQv d2Via2l0d2ViZnJhbWUuY3BwOgorICAgICAgICAod2Via2l0X3dlYl9mcmFtZV9sb2FkX3JlcXVl c3QpOgorCisyMDA5LTA1LTIyICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxnbnNAZ25vbWUub3Jn PgorCiAgICAgICAgIFJldmlld2VkIGJ5IEphbiBBbG9uem8uCiAKICAgICAgICAgSW1wcm92ZSBO ZXR3b3JrUmVxdWVzdCBkb2N1bWVudGF0aW9uLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9XZWJD b3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAgYi9XZWJLaXQvZ3RrL1dlYkNvcmVT dXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAppbmRleCA1YzA5N2ViLi45MWExMDQxIDEw MDY0NAotLS0gYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3Rr LmNwcAorKysgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3Rr LmNwcApAQCAtMzA5LDcgKzMwOSw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNo RGVjaWRlUG9saWN5Rm9yTUlNRVR5cGUoRnJhbWVQb2xpY3lGdW5jdGlvbiBwb2xpCiAgICAgfQog CiAgICAgV2ViS2l0V2ViVmlldyogcGFnZSA9IGdldFZpZXdGcm9tRnJhbWUobV9mcmFtZSk7Ci0g ICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X25ldyhyZXNvdXJjZVJlcXVlc3QudXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisgICAg V2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25l d193aXRoX2NvcmVfcmVxdWVzdChyZXNvdXJjZVJlcXVlc3QpOwogCiAgICAgV2ViS2l0V2ViUG9s aWN5RGVjaXNpb24qIHBvbGljeURlY2lzaW9uID0gd2Via2l0X3dlYl9wb2xpY3lfZGVjaXNpb25f bmV3KG1fZnJhbWUsIHBvbGljeUZ1bmN0aW9uKTsKICAgICBpZiAobV9wb2xpY3lEZWNpc2lvbikK QEAgLTQwOCw3ICs0MDgsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERlY2lk ZVBvbGljeUZvck5hdmlnYXRpb25BY3Rpb24oRnJhbWVQb2xpY3lGdW5jdAogICAgIH0KIAogICAg IFdlYktpdFdlYlZpZXcqIHdlYlZpZXcgPSBnZXRWaWV3RnJvbUZyYW1lKG1fZnJhbWUpOwotICAg IFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9u ZXcocmVzb3VyY2VSZXF1ZXN0LnVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworICAgIFdl YktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdf d2l0aF9jb3JlX3JlcXVlc3QocmVzb3VyY2VSZXF1ZXN0KTsKICAgICBXZWJLaXROYXZpZ2F0aW9u UmVzcG9uc2UgcmVzcG9uc2U7CiAgICAgLyoKICAgICAgKiBXZSBzdGlsbCBzdXBwb3J0IHRoZSBk ZXByZWNhdGVkIG5hdmlnYXRpb24tcmVxdWVzdGVkIHNpZ25hbCwgaWYgdGhlCkBAIC0xMDExLDcg KzEwMTEsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpzZXRNYWluRG9jdW1lbnRFcnJvcihE b2N1bWVudExvYWRlciosIGNvbnN0IFJlc291cmNlRXJybwogCiB2b2lkIEZyYW1lTG9hZGVyQ2xp ZW50OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKIHsKLSAg ICBXZWJLaXROZXR3b3JrUmVxdWVzdCogbmV0d29ya1JlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X25ldyhyZXF1ZXN0LnVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworICAgIFdl YktpdE5ldHdvcmtSZXF1ZXN0KiBuZXR3b3JrUmVxdWVzdCA9IHdlYmtpdF9uZXR3b3JrX3JlcXVl c3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0KHJlcXVlc3QpOwogICAgIFdlYktpdFdlYlZpZXcqIHZp ZXcgPSBnZXRWaWV3RnJvbUZyYW1lKG1fZnJhbWUpOwogCiAgICAgd2Via2l0X3dlYl92aWV3X3Jl cXVlc3RfZG93bmxvYWQodmlldywgbmV0d29ya1JlcXVlc3QpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0ZG93bmxvYWQuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 ZG93bmxvYWQuY3BwCmluZGV4IGEyOTk4ODMuLmJmZDAwMmYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdGRvd25sb2FkLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXRkb3dubG9hZC5jcHAKQEAgLTQyMSwxMSArNDIxLDggQEAgdm9pZCB3ZWJraXRfZG93bmxvYWRf c3RhcnQoV2ViS2l0RG93bmxvYWQqIGRvd25sb2FkKQogCiAgICAgaWYgKHByaXYtPnJlc291cmNl SGFuZGxlKQogICAgICAgICBwcml2LT5yZXNvdXJjZUhhbmRsZS0+c2V0Q2xpZW50KHByaXYtPmRv d25sb2FkQ2xpZW50KTsKLSAgICBlbHNlIHsKLSAgICAgICAgLy8gRklYTUU6IFVzZSB0aGUgYWN0 dWFsIHJlcXVlc3Qgb2JqZWN0IHdoZW4gV2ViS2l0TmV0d29ya1JlcXVlc3QgaXMgZmluaXNoZWQu Ci0gICAgICAgIFJlc291cmNlUmVxdWVzdCByZXF1ZXN0KHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf Z2V0X3VyaShwcml2LT5uZXR3b3JrUmVxdWVzdCkpOwotICAgICAgICBwcml2LT5yZXNvdXJjZUhh bmRsZSA9IFJlc291cmNlSGFuZGxlOjpjcmVhdGUocmVxdWVzdCwgcHJpdi0+ZG93bmxvYWRDbGll bnQsIDAsIGZhbHNlLCBmYWxzZSwgZmFsc2UpOwotICAgIH0KKyAgICBlbHNlCisgICAgICAgIHBy aXYtPnJlc291cmNlSGFuZGxlID0gUmVzb3VyY2VIYW5kbGU6OmNyZWF0ZShSZXNvdXJjZVJlcXVl c3Qod2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWVzc2FnZShwcml2LT5uZXR3b3JrUmVxdWVz dCkpLCBwcml2LT5kb3dubG9hZENsaWVudCwgMCwgZmFsc2UsIGZhbHNlLCBmYWxzZSk7CiAKICAg ICBwcml2LT50aW1lciA9IGdfdGltZXJfbmV3KCk7CiAgICAgd2Via2l0X2Rvd25sb2FkX29wZW5f c3RyZWFtX2Zvcl91cmkoZG93bmxvYWQsIHByaXYtPmRlc3RpbmF0aW9uVVJJKTsKZGlmZiAtLWdp dCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcCBiL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcAppbmRleCAyYzRlOTI2Li41YjJkZmY2 IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAK KysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwCkBAIC0xLDUg KzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwNywgMjAwOCBIb2xnZXIgSGFucyBQZXRl ciBGcmV5dGhlcgorICogQ29weXJpZ2h0IChDKSAyMDA5IEd1c3Rhdm8gTm9yb25oYSBTaWx2YQog ICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IKICAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJy YXJ5IEdlbmVyYWwgUHVibGljCkBAIC0xOCw5ICsxOSwxMiBAQAogICovCiAKICNpbmNsdWRlICJj b25maWcuaCIKLQogI2luY2x1ZGUgIndlYmtpdG5ldHdvcmtyZXF1ZXN0LmgiCiAKKyNpbmNsdWRl ICJDU3RyaW5nLmgiCisjaW5jbHVkZSAiUmVzb3VyY2VSZXF1ZXN0LmgiCisjaW5jbHVkZSAid2Vi a2l0cHJpdmF0ZS5oIgorCiAvKioKICAqIFNFQ1RJT046d2Via2l0bmV0d29ya3JlcXVlc3QKICAq IEBzaG9ydF9kZXNjcmlwdGlvbjogVGhlIHRhcmdldCBvZiBhIG5hdmlnYXRpb24gcmVxdWVzdApA QCAtMzgsNiArNDIsNyBAQCBHX0RFRklORV9UWVBFKFdlYktpdE5ldHdvcmtSZXF1ZXN0LCB3ZWJr aXRfbmV0d29ya19yZXF1ZXN0LCBHX1RZUEVfT0JKRUNUKTsKIAogc3RydWN0IF9XZWJLaXROZXR3 b3JrUmVxdWVzdFByaXZhdGUgewogICAgIGdjaGFyKiB1cmk7CisgICAgU291cE1lc3NhZ2UqIG1l c3NhZ2U7CiB9OwogCiAjZGVmaW5lIFdFQktJVF9ORVRXT1JLX1JFUVVFU1RfR0VUX1BSSVZBVEUo b2JqKSAoR19UWVBFX0lOU1RBTkNFX0dFVF9QUklWQVRFKChvYmopLCBXRUJLSVRfVFlQRV9ORVRX T1JLX1JFUVVFU1QsIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSkpCkBAIC00OSw2ICs1NCwx MSBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2ZpbmFsaXplKEdPYmplY3Qq IG9iamVjdCkKIAogICAgIGdfZnJlZShwcml2LT51cmkpOwogCisgICAgaWYgKHByaXYtPm1lc3Nh Z2UpIHsKKyAgICAgICAgZ19vYmplY3RfdW5yZWYocHJpdi0+bWVzc2FnZSk7CisgICAgICAgIHBy aXYtPm1lc3NhZ2UgPSBOVUxMOworICAgIH0KKwogICAgIEdfT0JKRUNUX0NMQVNTKHdlYmtpdF9u ZXR3b3JrX3JlcXVlc3RfcGFyZW50X2NsYXNzKS0+ZmluYWxpemUob2JqZWN0KTsKIH0KIApAQCAt NjUsNiArNzUsMjAgQEAgc3RhdGljIHZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9pbml0KFdl YktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQogICAgIHJlcXVlc3QtPnByaXYgPSBwcml2Owog fQogCisvLyBmb3IgaW50ZXJuYWwgdXNlIG9ubHkKK1dlYktpdE5ldHdvcmtSZXF1ZXN0KiB3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2NvcmVfcmVxdWVzdChjb25zdCBXZWJDb3JlOjpS ZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVx dWVzdCogcmVxdWVzdCA9IFdFQktJVF9ORVRXT1JLX1JFUVVFU1QoZ19vYmplY3RfbmV3KFdFQktJ VF9UWVBFX05FVFdPUktfUkVRVUVTVCwgTlVMTCkpOworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0 UHJpdmF0ZSogcHJpdiA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBTb3VwTWVzc2FnZSogc291cE1l c3NhZ2UgPSByZXNvdXJjZVJlcXVlc3Quc291cE1lc3NhZ2UoKTsKKyAgICBpZiAoc291cE1lc3Nh Z2UpCisgICAgICAgIHByaXYtPm1lc3NhZ2UgPSBTT1VQX01FU1NBR0UoZ19vYmplY3RfcmVmKHNv dXBNZXNzYWdlKSk7CisgICAgcHJpdi0+dXJpID0gZ19zdHJkdXAocmVzb3VyY2VSZXF1ZXN0LnVy bCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworCisgICAgcmV0dXJuIHJlcXVlc3Q7Cit9CisK IC8qKgogICogd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXc6CiAgKiBAdXJpOiBhbiBVUkkKQEAg LTExOCwzICsxNDIsMjEgQEAgR19DT05TVF9SRVRVUk4gZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X3VyaShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWUKICAgICBXZWJLaXROZXR3 b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OwogICAgIHJldHVybiBwcml2 LT51cmk7CiB9CisKKy8vIE5PVCBZRVQgQVBJOyBGb3IgaW50ZXJuYWwgdXNlIG9ubHksIGZvciBu b3cKKy8vIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3NvdXBfbWVzc2FnZToKKy8vIEByZXF1 ZXN0OiBhICNXZWJLaXROZXR3b3JrUmVxdWVzdAorLy8KKy8vIE9idGFpbnMgdGhlICNTb3VwTWVz c2FnZSBoZWxkIGFuZCB1c2VkIGJ5IHRoZSBnaXZlbiByZXF1ZXN0LiBOb3RpY2UKKy8vIHRoYXQg bW9kaWZpY2F0aW9uIG9mIHRoZSBTb3VwTWVzc2FnZSBvZiBhIHJlcXVlc3QgYnkgc2lnbmFsCisv LyBoYW5kbGVycyBpcyBvbmx5IHN1cHBvcnRlZCB3aGVyZSBleHBsaWNpdGx5IGRvY3VtZW50ZWQu CisvLworLy8gUmV0dXJuczogdGhlICNTb3VwTWVzc2FnZQorU291cE1lc3NhZ2UqIHdlYmtpdF9u ZXR3b3JrX3JlcXVlc3RfZ2V0X21lc3NhZ2UoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3Qp Cit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChy ZXF1ZXN0KSwgTlVMTCk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYg PSByZXF1ZXN0LT5wcml2OworCisgICAgcmV0dXJuIHByaXYtPm1lc3NhZ2U7Cit9CmRpZmYgLS1n aXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRwcml2YXRlLmgKaW5kZXggOTNiYjgyMC4uYzFiOTg2ZiAxMDA2NDQKLS0tIGEvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHByaXZhdGUuaApAQCAtMjMsNyArMjMsOCBAQAogI2RlZmluZSBXRUJLSVRfUFJJVkFURV9I CiAKIC8qCi0gKiBUaGlzIGZpbGUga25vd3MgdGhlIHNoYXJlZCBzZWNyZXQgb2YgV2ViS2l0V2Vi VmlldyBhbmQgV2ViS2l0V2ViRnJhbWUuCisgKiBUaGlzIGZpbGUga25vd3MgdGhlIHNoYXJlZCBz ZWNyZXQgb2YgV2ViS2l0V2ViVmlldywgV2ViS2l0V2ViRnJhbWUsCisgKiBhbmQgV2ViS2l0TmV0 d29ya1JlcXVlc3QuCiAgKiBUaGV5IGFyZSB1c2luZyBXZWJDb3JlIHdoaWNoIG11c24ndCBiZSBl eHBvc2VkIHRvIHRoZSBvdXRlciB3b3JsZC4KICAqLwogCkBAIC0zNyw2ICszOCw3IEBACiAjaW5j bHVkZSA8d2Via2l0L3dlYmtpdHdlYnNldHRpbmdzLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtp dHdlYndpbmRvd2ZlYXR1cmVzLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYmJhY2tmb3J3 YXJkbGlzdC5oPgorI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oPgogCiAj aW5jbHVkZSAiQmFja0ZvcndhcmRMaXN0LmgiCiAjaW5jbHVkZSA8ZW5jaGFudC5oPgpAQCAtNDcs MTAgKzQ5LDEyIEBACiAjaW5jbHVkZSAiSW5zcGVjdG9yQ2xpZW50R3RrLmgiCiAjaW5jbHVkZSAi RnJhbWVMb2FkZXJDbGllbnQuaCIKICNpbmNsdWRlICJSZXNvdXJjZUhhbmRsZS5oIgorI2luY2x1 ZGUgIlJlc291cmNlUmVxdWVzdC5oIgogI2luY2x1ZGUgIlJlc291cmNlUmVzcG9uc2UuaCIKICNp bmNsdWRlICJXaW5kb3dGZWF0dXJlcy5oIgogCiAjaW5jbHVkZSA8Z2xpYi5oPgorI2luY2x1ZGUg PGxpYnNvdXAvc291cC5oPgogCiBjbGFzcyBEb3dubG9hZENsaWVudDsKIApAQCAtMTgwLDYgKzE4 NCwxMiBAQCBleHRlcm4gIkMiIHsKICAgICB2b2lkCiAgICAgd2Via2l0X3dlYl9wb2xpY3lfZGVj aXNpb25fY2FuY2VsIChXZWJLaXRXZWJQb2xpY3lEZWNpc2lvbiogZGVjaXNpb24pOwogCisgICAg V2ViS2l0TmV0d29ya1JlcXVlc3QqCisgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0 aF9jb3JlX3JlcXVlc3QoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJl cXVlc3QpOworCisgICAgU291cE1lc3NhZ2UqCisgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9n ZXRfbWVzc2FnZShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CisKICAgICAvLyBGSVhN RTogbW92ZSB0aGlzIGZ1bmN0aW9uYWxpdHkgaW50byBhICdXZWJLaXRXZWJEYXRhU291cmNlJyBv bmNlIGltcGxlbWVudGVkCiAgICAgV0VCS0lUX0FQSSBnY2hhcioKICAgICB3ZWJraXRfd2ViX2Zy YW1lX2dldF9yZXNwb25zZV9taW1lX3R5cGUoV2ViS2l0V2ViRnJhbWUqIGZyYW1lKTsKZGlmZiAt LWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcCBiL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcAppbmRleCBhNzJiYjkzLi45MDAxMjEyIDEwMDY0NAot LS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKKysrIGIvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCkBAIC01MTAsOSArNTEwLDcgQEAgdm9pZCB3ZWJr aXRfd2ViX2ZyYW1lX2xvYWRfcmVxdWVzdChXZWJLaXRXZWJGcmFtZSogZnJhbWUsIFdlYktpdE5l dHdvcmtSZXF1ZXN0KgogICAgIGlmICghY29yZUZyYW1lKQogICAgICAgICByZXR1cm47CiAKLSAg ICAvLyBUT0RPOiBVc2UgdGhlIFJlc291cmNlUmVxdWVzdCBjYXJyaWVkIGJ5IFdlYktpdE5ldHdv cmtSZXF1ZXN0IHdoZW4gaXQgaXMgaW1wbGVtZW50ZWQuCi0gICAgU3RyaW5nIHN0cmluZyA9IFN0 cmluZzo6ZnJvbVVURjgod2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJpKHJlcXVlc3QpKTsK LSAgICBjb3JlRnJhbWUtPmxvYWRlcigpLT5sb2FkKFJlc291cmNlUmVxdWVzdChLVVJMKEtVUkwo KSwgc3RyaW5nKSksIGZhbHNlKTsKKyAgICBjb3JlRnJhbWUtPmxvYWRlcigpLT5sb2FkKFJlc291 cmNlUmVxdWVzdCh3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9tZXNzYWdlKHJlcXVlc3QpKSwg ZmFsc2UpOwogfQogCiAvKioK 30623 2009-05-23 21:20:38 -0700 2009-05-24 14:10:18 -0700 Make NetworkRequest carry a reference of the SoupMessage used by Make-NetworkRequest-carry-a-reference-of-the-SoupMessage-used-by.patch text/plain 23770 gustavo YjY3MDQ3NTI3MmQ4MTE0MjZlYWVkMTA0MmFlYzUwNDhlYjM2MTgwOApkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAwMzIzNjc2Li4zODIwYjYz IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpA QCAtMSwzICsxLDI1IEBACisyMDA5LTA1LTI0ICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxnbnNA Z25vbWUub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIE1ha2UgU291cE1lc3NhZ2UgYSBtZW1iZXIgb2YgUmVzb3VyY2VSZXF1ZXN0LCBpbnN0ZWFk IG9mIGNyZWF0aW5nCisgICAgICAgIGl0IGluIHN0YXJ0SHR0cC4gSW1wbGVtZW50IHVwZGF0aW5n IG9mIFJlc291cmNlUmVxdWVzdCBmcm9tCisgICAgICAgIFNvdXBNZXNzYWdlLCBhbmQgdmljZSB2 ZXJzYS4KKworICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOgorICAgICAgICAqIHBsYXRmb3JtL25l dHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVz b3VyY2VIYW5kbGU6On5SZXNvdXJjZUhhbmRsZSk6CisgICAgICAgIChXZWJDb3JlOjpnb3RIZWFk ZXJzQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0 cCk6CisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdC5oOgor ICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0OjpSZXNvdXJjZVJlcXVlc3QpOgorICAg ICAgICAoV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Ojp+UmVzb3VyY2VSZXF1ZXN0KToKKyAgICAg ICAgKiBwbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0U291cC5jcHA6IEFkZGVk LgorICAgICAgICAoV1RGOjpTb3VwVVJJKToKKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlUmVx dWVzdDo6c291cE1lc3NhZ2UpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Ojpk b1VwZGF0ZVJlc291cmNlUmVxdWVzdCk6CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZVJlcXVl c3Q6OmRvVXBkYXRlUGxhdGZvcm1SZXF1ZXN0KToKKwogMjAwOS0wNS0yMiAgRGFyaW4gQWRsZXIg IDxkYXJpbkBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFuIEJlcm5zdGVpbi4K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0gYi9XZWJDb3JlL0dOVW1ha2VmaWxl LmFtCmluZGV4IDNlMGYwNjMuLmFiZTdjMGEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvR05VbWFrZWZp bGUuYW0KKysrIGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQpAQCAtMTg2NCw2ICsxODY0LDcgQEAg d2ViY29yZWd0a19zb3VyY2VzICs9IFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9E TlNTb3VwLmNwcCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VFcnJv ci5oIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAu Y3BwIFwKKwlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3RTb3Vw LmNwcCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0Lmgg XAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVzcG9uc2UuaCBcCiAJ V2ViQ29yZS9wbGF0Zm9ybS90ZXh0L2d0ay9UZXh0QnJlYWtJdGVyYXRvckludGVybmFsSUNVR3Rr LmNwcApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VI YW5kbGVTb3VwLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFu ZGxlU291cC5jcHAKaW5kZXggN2YwMTM1YS4uYzBmYWQ2YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9w bGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcAorKysgYi9XZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCkBAIC0xMzYsNiAr MTM2LDkgQEAgUmVzb3VyY2VIYW5kbGVJbnRlcm5hbDo6flJlc291cmNlSGFuZGxlSW50ZXJuYWwo KQogCiBSZXNvdXJjZUhhbmRsZTo6flJlc291cmNlSGFuZGxlKCkKIHsKKyAgICBpZiAoZC0+bV9t c2cpCisgICAgICAgIGdfc2lnbmFsX2hhbmRsZXJzX2Rpc2Nvbm5lY3RfbWF0Y2hlZChkLT5tX21z ZywgR19TSUdOQUxfTUFUQ0hfREFUQSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIDAsIDAsIDAsIDAsIHRoaXMpOwogfQogCiBzdGF0aWMgdm9pZCBmaWxsUmVz cG9uc2VGcm9tTWVzc2FnZShTb3VwTWVzc2FnZSogbXNnLCBSZXNvdXJjZVJlc3BvbnNlKiByZXNw b25zZSkKQEAgLTI1Niw3ICsyNTksNyBAQCBzdGF0aWMgdm9pZCBnb3RIZWFkZXJzQ2FsbGJhY2so U291cE1lc3NhZ2UqIG1zZywgZ3BvaW50ZXIgZGF0YSkKICAgICAgICAgJiYgKCFjb250ZW50VHlw ZSB8fCAhZ19hc2NpaV9zdHJjYXNlY21wKGNvbnRlbnRUeXBlLCAidGV4dC9wbGFpbiIpKSkKICAg ICAgICAgcmV0dXJuOwogCi0gICAgUmVzb3VyY2VIYW5kbGUqIGhhbmRsZSA9IHN0YXRpY19jYXN0 PFJlc291cmNlSGFuZGxlKj4oZGF0YSk7CisgICAgUmVmUHRyPFJlc291cmNlSGFuZGxlPiBoYW5k bGUgPSBzdGF0aWNfY2FzdDxSZXNvdXJjZUhhbmRsZSo+KGRhdGEpOwogICAgIGlmICghaGFuZGxl KQogICAgICAgICByZXR1cm47CiAgICAgUmVzb3VyY2VIYW5kbGVJbnRlcm5hbCogZCA9IGhhbmRs ZS0+Z2V0SW50ZXJuYWwoKTsKQEAgLTI2Nyw4ICsyNzAsOCBAQCBzdGF0aWMgdm9pZCBnb3RIZWFk ZXJzQ2FsbGJhY2soU291cE1lc3NhZ2UqIG1zZywgZ3BvaW50ZXIgZGF0YSkKICAgICAgICAgcmV0 dXJuOwogCiAgICAgZmlsbFJlc3BvbnNlRnJvbU1lc3NhZ2UobXNnLCAmZC0+bV9yZXNwb25zZSk7 Ci0gICAgY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaGFuZGxlLCBkLT5tX3Jlc3BvbnNlKTsK ICAgICBkLT5tX3JlcG9ydGVkSGVhZGVycyA9IHRydWU7CisgICAgY2xpZW50LT5kaWRSZWNlaXZl UmVzcG9uc2UoaGFuZGxlLmdldCgpLCBkLT5tX3Jlc3BvbnNlKTsKIH0KIAogc3RhdGljIHZvaWQg Z290Q2h1bmtDYWxsYmFjayhTb3VwTWVzc2FnZSogbXNnLCBTb3VwQnVmZmVyKiBjaHVuaywgZ3Bv aW50ZXIgZGF0YSkKQEAgLTQ2NSwyMCArNDY4LDEyIEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0 YXJ0SHR0cChTdHJpbmcgdXJsU3RyaW5nKQogICAgIFNvdXBTZXNzaW9uKiBzZXNzaW9uID0gZGVm YXVsdFNlc3Npb24oKTsKICAgICBlbnN1cmVTZXNzaW9uSXNJbml0aWFsaXplZChzZXNzaW9uKTsK IAotICAgIFNvdXBNZXNzYWdlKiBtc2c7Ci0gICAgbXNnID0gc291cF9tZXNzYWdlX25ldyhyZXF1 ZXN0KCkuaHR0cE1ldGhvZCgpLnV0ZjgoKS5kYXRhKCksIHVybFN0cmluZy51dGY4KCkuZGF0YSgp KTsKLSAgICBnX3NpZ25hbF9jb25uZWN0KG1zZywgInJlc3RhcnRlZCIsIEdfQ0FMTEJBQ0socmVz dGFydGVkQ2FsbGJhY2spLCB0aGlzKTsKLSAgICBnX3NpZ25hbF9jb25uZWN0KG1zZywgImdvdC1o ZWFkZXJzIiwgR19DQUxMQkFDSyhnb3RIZWFkZXJzQ2FsbGJhY2spLCB0aGlzKTsKLSAgICBnX3Np Z25hbF9jb25uZWN0KG1zZywgImdvdC1jaHVuayIsIEdfQ0FMTEJBQ0soZ290Q2h1bmtDYWxsYmFj ayksIHRoaXMpOworICAgIGQtPm1fbXNnID0gc3RhdGljX2Nhc3Q8U291cE1lc3NhZ2UqPihnX29i amVjdF9yZWYocmVxdWVzdCgpLnNvdXBNZXNzYWdlKCkpKTsKKyAgICBnX3NpZ25hbF9jb25uZWN0 KGQtPm1fbXNnLCAicmVzdGFydGVkIiwgR19DQUxMQkFDSyhyZXN0YXJ0ZWRDYWxsYmFjayksIHRo aXMpOworICAgIGdfc2lnbmFsX2Nvbm5lY3QoZC0+bV9tc2csICJnb3QtaGVhZGVycyIsIEdfQ0FM TEJBQ0soZ290SGVhZGVyc0NhbGxiYWNrKSwgdGhpcyk7CisgICAgZ19zaWduYWxfY29ubmVjdChk LT5tX21zZywgImdvdC1jaHVuayIsIEdfQ0FMTEJBQ0soZ290Q2h1bmtDYWxsYmFjayksIHRoaXMp OwogCi0gICAgZ19vYmplY3Rfc2V0X2RhdGEoR19PQkpFQ1QobXNnKSwgInJlc291cmNlSGFuZGxl IiwgcmVpbnRlcnByZXRfY2FzdDx2b2lkKj4odGhpcykpOwotCi0gICAgSFRUUEhlYWRlck1hcCBj dXN0b21IZWFkZXJzID0gZC0+bV9yZXF1ZXN0Lmh0dHBIZWFkZXJGaWVsZHMoKTsKLSAgICBpZiAo IWN1c3RvbUhlYWRlcnMuaXNFbXB0eSgpKSB7Ci0gICAgICAgIEhUVFBIZWFkZXJNYXA6OmNvbnN0 X2l0ZXJhdG9yIGVuZCA9IGN1c3RvbUhlYWRlcnMuZW5kKCk7Ci0gICAgICAgIGZvciAoSFRUUEhl YWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBjdXN0b21IZWFkZXJzLmJlZ2luKCk7IGl0ICE9 IGVuZDsgKytpdCkKLSAgICAgICAgICAgIHNvdXBfbWVzc2FnZV9oZWFkZXJzX2FwcGVuZChtc2ct PnJlcXVlc3RfaGVhZGVycywgaXQtPmZpcnN0LnN0cmluZygpLnV0ZjgoKS5kYXRhKCksIGl0LT5z ZWNvbmQudXRmOCgpLmRhdGEoKSk7Ci0gICAgfQorICAgIGdfb2JqZWN0X3NldF9kYXRhKEdfT0JK RUNUKGQtPm1fbXNnKSwgInJlc291cmNlSGFuZGxlIiwgcmVpbnRlcnByZXRfY2FzdDx2b2lkKj4o dGhpcykpOwogCiAgICAgRm9ybURhdGEqIGh0dHBCb2R5ID0gZC0+bV9yZXF1ZXN0Lmh0dHBCb2R5 KCk7CiAgICAgaWYgKGh0dHBCb2R5ICYmICFodHRwQm9keS0+aXNFbXB0eSgpKSB7CkBAIC00ODgs NyArNDgzLDcgQEAgYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRIdHRwKFN0cmluZyB1cmxTdHJp bmcpCiAgICAgICAgIGlmIChudW1FbGVtZW50cyA8IDIpIHsKICAgICAgICAgICAgIFZlY3Rvcjxj aGFyPiBib2R5OwogICAgICAgICAgICAgaHR0cEJvZHktPmZsYXR0ZW4oYm9keSk7Ci0gICAgICAg ICAgICBzb3VwX21lc3NhZ2Vfc2V0X3JlcXVlc3QobXNnLCBkLT5tX3JlcXVlc3QuaHR0cENvbnRl bnRUeXBlKCkudXRmOCgpLmRhdGEoKSwKKyAgICAgICAgICAgIHNvdXBfbWVzc2FnZV9zZXRfcmVx dWVzdChkLT5tX21zZywgZC0+bV9yZXF1ZXN0Lmh0dHBDb250ZW50VHlwZSgpLnV0ZjgoKS5kYXRh KCksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgU09VUF9NRU1PUllfQ09Q WSwgYm9keS5kYXRhKCksIGJvZHkuc2l6ZSgpKTsKICAgICAgICAgfSBlbHNlIHsKICAgICAgICAg ICAgIC8qCkBAIC00OTcsMTIgKzQ5MiwxMiBAQCBib29sIFJlc291cmNlSGFuZGxlOjpzdGFydEh0 dHAoU3RyaW5nIHVybFN0cmluZykKICAgICAgICAgICAgICAqIGNvcHlpbmcgaW50byBtZW1vcnk7 IFRPRE86IHN1cHBvcnQgdXBsb2FkIG9mIG5vbi1sb2NhbAogICAgICAgICAgICAgICogKHRoaW5r IHNmdHA6Ly8pIGZpbGVzIGJ5IHVzaW5nIEdJTz8KICAgICAgICAgICAgICAqLwotICAgICAgICAg ICAgc291cF9tZXNzYWdlX2JvZHlfc2V0X2FjY3VtdWxhdGUobXNnLT5yZXF1ZXN0X2JvZHksIEZB TFNFKTsKKyAgICAgICAgICAgIHNvdXBfbWVzc2FnZV9ib2R5X3NldF9hY2N1bXVsYXRlKGQtPm1f bXNnLT5yZXF1ZXN0X2JvZHksIEZBTFNFKTsKICAgICAgICAgICAgIGZvciAoc2l6ZV90IGkgPSAw OyBpIDwgbnVtRWxlbWVudHM7IGkrKykgewogICAgICAgICAgICAgICAgIGNvbnN0IEZvcm1EYXRh RWxlbWVudCYgZWxlbWVudCA9IGh0dHBCb2R5LT5lbGVtZW50cygpW2ldOwogCiAgICAgICAgICAg ICAgICAgaWYgKGVsZW1lbnQubV90eXBlID09IEZvcm1EYXRhRWxlbWVudDo6ZGF0YSkKLSAgICAg ICAgICAgICAgICAgICAgc291cF9tZXNzYWdlX2JvZHlfYXBwZW5kKG1zZy0+cmVxdWVzdF9ib2R5 LCBTT1VQX01FTU9SWV9URU1QT1JBUlksIGVsZW1lbnQubV9kYXRhLmRhdGEoKSwgZWxlbWVudC5t X2RhdGEuc2l6ZSgpKTsKKyAgICAgICAgICAgICAgICAgICAgc291cF9tZXNzYWdlX2JvZHlfYXBw ZW5kKGQtPm1fbXNnLT5yZXF1ZXN0X2JvZHksIFNPVVBfTUVNT1JZX1RFTVBPUkFSWSwgZWxlbWVu dC5tX2RhdGEuZGF0YSgpLCBlbGVtZW50Lm1fZGF0YS5zaXplKCkpOwogICAgICAgICAgICAgICAg IGVsc2UgewogICAgICAgICAgICAgICAgICAgICAvKgogICAgICAgICAgICAgICAgICAgICAgKiBt YXBwaW5nIGZvciB1cGxvYWRlZCBmaWxlcyBjb2RlIGluc3BpcmVkIGJ5IHRlY2huaXF1ZSB1c2Vk IGluCkBAIC01MTYsMjggKzUxMSwzMSBAQCBib29sIFJlc291cmNlSGFuZGxlOjpzdGFydEh0dHAo U3RyaW5nIHVybFN0cmluZykKIAogICAgICAgICAgICAgICAgICAgICBpZiAoZXJyb3IpIHsKICAg ICAgICAgICAgICAgICAgICAgICAgIFJlc291cmNlRXJyb3IgcmVzb3VyY2VFcnJvcihnX3F1YXJr X3RvX3N0cmluZyhTT1VQX0hUVFBfRVJST1IpLAotICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIG1zZy0+c3RhdHVzX2NvZGUsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZC0+bV9tc2ctPnN0YXR1c19j b2RlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHVybFN0cmluZywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBTdHJpbmc6OmZyb21VVEY4KGVycm9yLT5tZXNzYWdlKSk7CiAgICAgICAgICAgICAg ICAgICAgICAgICBnX2Vycm9yX2ZyZWUoZXJyb3IpOwogCiAgICAgICAgICAgICAgICAgICAgICAg ICBkLT5jbGllbnQoKS0+ZGlkRmFpbCh0aGlzLCByZXNvdXJjZUVycm9yKTsKIAotICAgICAgICAg ICAgICAgICAgICAgICAgZ19vYmplY3RfdW5yZWYobXNnKTsKKyAgICAgICAgICAgICAgICAgICAg ICAgIGdfc2lnbmFsX2hhbmRsZXJzX2Rpc2Nvbm5lY3RfbWF0Y2hlZChkLT5tX21zZywgR19TSUdO QUxfTUFUQ0hfREFUQSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAwLCAwLCAwLCAwLCB0aGlzKTsKKyAgICAgICAgICAgICAgICAg ICAgICAgIGdfb2JqZWN0X3VucmVmKGQtPm1fbXNnKTsKKyAgICAgICAgICAgICAgICAgICAgICAg IGQtPm1fbXNnID0gMDsKKwogICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwog ICAgICAgICAgICAgICAgICAgICB9CiAKICAgICAgICAgICAgICAgICAgICAgU291cEJ1ZmZlciog c291cEJ1ZmZlciA9IHNvdXBfYnVmZmVyX25ld193aXRoX293bmVyKGdfbWFwcGVkX2ZpbGVfZ2V0 X2NvbnRlbnRzKGZpbGVNYXBwaW5nKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdfbWFwcGVkX2ZpbGVfZ2V0 X2xlbmd0aChmaWxlTWFwcGluZyksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmaWxlTWFwcGluZywgcmVpbnRl cnByZXRfY2FzdDxHRGVzdHJveU5vdGlmeT4oZ19tYXBwZWRfZmlsZV9mcmVlKSk7Ci0gICAgICAg ICAgICAgICAgICAgIHNvdXBfbWVzc2FnZV9ib2R5X2FwcGVuZF9idWZmZXIobXNnLT5yZXF1ZXN0 X2JvZHksIHNvdXBCdWZmZXIpOworICAgICAgICAgICAgICAgICAgICBzb3VwX21lc3NhZ2VfYm9k eV9hcHBlbmRfYnVmZmVyKGQtPm1fbXNnLT5yZXF1ZXN0X2JvZHksIHNvdXBCdWZmZXIpOwogICAg ICAgICAgICAgICAgICAgICBzb3VwX2J1ZmZlcl9mcmVlKHNvdXBCdWZmZXIpOwogICAgICAgICAg ICAgICAgIH0KICAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0KIAotICAgIGQtPm1fbXNn ID0gc3RhdGljX2Nhc3Q8U291cE1lc3NhZ2UqPihnX29iamVjdF9yZWYobXNnKSk7CiAgICAgLy8g YmFsYW5jZWQgYnkgYSBkZXJlZigpIGluIGZpbmlzaGVkQ2FsbGJhY2ssIHdoaWNoIHNob3VsZCBh bHdheXMgcnVuCiAgICAgcmVmKCk7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdC5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3Nv dXAvUmVzb3VyY2VSZXF1ZXN0LmgKaW5kZXggZWZiMTI0MC4uZjU2OTEzOCAxMDA2NDQKLS0tIGEv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0LmgKKysrIGIvV2Vi Q29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0LmgKQEAgLTI5LDM2ICsy OSw2MSBAQAogCiAjaW5jbHVkZSAiUmVzb3VyY2VSZXF1ZXN0QmFzZS5oIgogCisjaW5jbHVkZSA8 bGlic291cC9zb3VwLmg+CisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgIHN0cnVjdCBSZXNv dXJjZVJlcXVlc3QgOiBSZXNvdXJjZVJlcXVlc3RCYXNlIHsKIAogICAgICAgICBSZXNvdXJjZVJl cXVlc3QoY29uc3QgU3RyaW5nJiB1cmwpCiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJh c2UoS1VSTCh1cmwpLCBVc2VQcm90b2NvbENhY2hlUG9saWN5KQorICAgICAgICAgICAgLCBtX3Nv dXBNZXNzYWdlKDApCiAgICAgICAgIHsKICAgICAgICAgfQogCiAgICAgICAgIFJlc291cmNlUmVx dWVzdChjb25zdCBLVVJMJiB1cmwpCiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2Uo dXJsLCBVc2VQcm90b2NvbENhY2hlUG9saWN5KQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdl KDApCiAgICAgICAgIHsKICAgICAgICAgfQogCiAgICAgICAgIFJlc291cmNlUmVxdWVzdChjb25z dCBLVVJMJiB1cmwsIGNvbnN0IFN0cmluZyYgcmVmZXJyZXIsIFJlc291cmNlUmVxdWVzdENhY2hl UG9saWN5IHBvbGljeSA9IFVzZVByb3RvY29sQ2FjaGVQb2xpY3kpCiAgICAgICAgICAgICA6IFJl c291cmNlUmVxdWVzdEJhc2UodXJsLCBwb2xpY3kpCisgICAgICAgICAgICAsIG1fc291cE1lc3Nh Z2UoMCkKICAgICAgICAgewogICAgICAgICAgICAgc2V0SFRUUFJlZmVycmVyKHJlZmVycmVyKTsK ICAgICAgICAgfQogCiAgICAgICAgIFJlc291cmNlUmVxdWVzdCgpCiAgICAgICAgICAgICA6IFJl c291cmNlUmVxdWVzdEJhc2UoS1VSTCgpLCBVc2VQcm90b2NvbENhY2hlUG9saWN5KQorICAgICAg ICAgICAgLCBtX3NvdXBNZXNzYWdlKDApCisgICAgICAgIHsKKyAgICAgICAgfQorCisgICAgICAg IFJlc291cmNlUmVxdWVzdChTb3VwTWVzc2FnZSogc291cE1lc3NhZ2UpCisgICAgICAgICAgICA6 IFJlc291cmNlUmVxdWVzdEJhc2UoKQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKHNvdXBN ZXNzYWdlKQogICAgICAgICB7CisgICAgICAgICAgICAvLyBTZWUgY29tbWVudCBpbiBkb1VwZGF0 ZVBsYXRmb3JtUmVxdWVzdCgpLgorICAgICAgICAgICAgZ19vYmplY3RfcmVmKHNvdXBNZXNzYWdl KTsKICAgICAgICAgfQogCisgICAgICAgIH5SZXNvdXJjZVJlcXVlc3QoKQorICAgICAgICB7Cisg ICAgICAgICAgICBpZiAobV9zb3VwTWVzc2FnZSkgeworICAgICAgICAgICAgICAgIGdfb2JqZWN0 X3VucmVmKG1fc291cE1lc3NhZ2UpOworICAgICAgICAgICAgICAgIG1fc291cE1lc3NhZ2UgPSAw OworICAgICAgICAgICAgfQorICAgICAgICB9CisKKyAgICAgICAgU291cE1lc3NhZ2UqIHNvdXBN ZXNzYWdlKCkgY29uc3Q7CisKICAgICBwcml2YXRlOgorICAgICAgICBTb3VwTWVzc2FnZSogbV9z b3VwTWVzc2FnZTsKICAgICAgICAgZnJpZW5kIGNsYXNzIFJlc291cmNlUmVxdWVzdEJhc2U7CiAK LSAgICAgICAgdm9pZCBkb1VwZGF0ZVBsYXRmb3JtUmVxdWVzdCgpIHt9Ci0gICAgICAgIHZvaWQg ZG9VcGRhdGVSZXNvdXJjZVJlcXVlc3QoKSB7fQorICAgICAgICB2b2lkIGRvVXBkYXRlUGxhdGZv cm1SZXF1ZXN0KCk7CisgICAgICAgIHZvaWQgZG9VcGRhdGVSZXNvdXJjZVJlcXVlc3QoKTsKICAg ICB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3RTb3VwLmNwcCBiL1dlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdFNvdXAuY3BwCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAuLjI1Y2RkOTUKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3RTb3VwLmNwcApAQCAtMCwwICsxLDEx NCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBHdXN0YXZvIE5vcm9uaGEgU2lsdmEKKyAq CisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUg aXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2Vy IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3Ig KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkg aXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5 IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBP U0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1v cmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRo ZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBs aWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0 aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZp ZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2luY2x1 ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAiQ1N0cmluZy5oIgorI2luY2x1ZGUgIkdPd25QdHIu aCIKKyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgIlJlc291cmNlUmVxdWVz dC5oIgorCisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+CisKK25hbWVzcGFjZSBXVEYgeworCit0 ZW1wbGF0ZSA8PiB2b2lkIGZyZWVPd25lZEdQdHI8U291cFVSST4oU291cFVSSSogdXJpKQorewor ICAgIGlmICh1cmkpCisJc291cF91cmlfZnJlZSh1cmkpOworfQorCit9CisKK25hbWVzcGFjZSBX ZWJDb3JlIHsKKworU291cE1lc3NhZ2UqIFJlc291cmNlUmVxdWVzdDo6c291cE1lc3NhZ2UoKSBj b25zdAoreworICAgIHVwZGF0ZVBsYXRmb3JtUmVxdWVzdCgpOworCisgICAgcmV0dXJuIG1fc291 cE1lc3NhZ2U7Cit9CisKK3ZvaWQgUmVzb3VyY2VSZXF1ZXN0Ojpkb1VwZGF0ZVJlc291cmNlUmVx dWVzdCgpCit7CisgICAgaWYgKCFtX3NvdXBNZXNzYWdlKQorICAgICAgICByZXR1cm47CisKKyAg ICBTb3VwVVJJKiBzb3VwVVJJID0gc291cF9tZXNzYWdlX2dldF91cmkobV9zb3VwTWVzc2FnZSk7 CisgICAgR093blB0cjxnY2hhcj4gdXJpKHNvdXBfdXJpX3RvX3N0cmluZyhzb3VwVVJJLCBGQUxT RSkpOworICAgIG1fdXJsID0gS1VSTChLVVJMKCksIFN0cmluZzo6ZnJvbVVURjgodXJpLmdldCgp KSk7CisKKyAgICBtX2h0dHBNZXRob2QgPSBTdHJpbmc6OmZyb21VVEY4KG1fc291cE1lc3NhZ2Ut Pm1ldGhvZCk7CisKKyAgICBTb3VwTWVzc2FnZUhlYWRlcnNJdGVyIGhlYWRlcnNJdGVyOworICAg IGNvbnN0IGNoYXIqIGhlYWRlck5hbWU7CisgICAgY29uc3QgY2hhciogaGVhZGVyVmFsdWU7CisK KyAgICBzb3VwX21lc3NhZ2VfaGVhZGVyc19pdGVyX2luaXQoJmhlYWRlcnNJdGVyLCBtX3NvdXBN ZXNzYWdlLT5yZXF1ZXN0X2hlYWRlcnMpOworICAgIHdoaWxlIChzb3VwX21lc3NhZ2VfaGVhZGVy c19pdGVyX25leHQoJmhlYWRlcnNJdGVyLCAmaGVhZGVyTmFtZSwgJmhlYWRlclZhbHVlKSkKKyAg ICAgICAgbV9odHRwSGVhZGVyRmllbGRzLnNldChTdHJpbmc6OmZyb21VVEY4KGhlYWRlck5hbWUp LCBTdHJpbmc6OmZyb21VVEY4KGhlYWRlclZhbHVlKSk7CisKKyAgICBtX2h0dHBCb2R5ID0gRm9y bURhdGE6OmNyZWF0ZShtX3NvdXBNZXNzYWdlLT5yZXF1ZXN0X2JvZHktPmRhdGEsIG1fc291cE1l c3NhZ2UtPnJlcXVlc3RfYm9keS0+bGVuZ3RoKTsKKworICAgIC8vIEZJWE1FOiBtX2FsbG93SFRU UENvb2tpZXMgYW5kIG1fZmlyc3RQYXJ0eUZvckNvb2tpZXMgc2hvdWxkCisgICAgLy8gcHJvYmFi bHkgYmUgaGFuZGxlZCBoZXJlIGFuZCBvbiBkb1VwZGF0ZVBsYXRmb3JtUmVxdWVzdAorICAgIC8v IHNvbWVob3cuCit9CisKK3ZvaWQgUmVzb3VyY2VSZXF1ZXN0Ojpkb1VwZGF0ZVBsYXRmb3JtUmVx dWVzdCgpCit7CisgICAgaWYgKGlzTnVsbCgpKSB7CisgICAgICAgIGlmIChtX3NvdXBNZXNzYWdl KQorICAgICAgICAgICAgZ19vYmplY3RfdW5yZWYobV9zb3VwTWVzc2FnZSk7CisgICAgICAgIG1f c291cE1lc3NhZ2UgPSAwOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgR093blB0cjxT b3VwVVJJPiBzb3VwVVJJKHNvdXBfdXJpX25ldyh1cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgp KSk7CisgICAgQVNTRVJUKHNvdXBVUkkuZ2V0KCkpOworCisgICAgaWYgKCFtX3NvdXBNZXNzYWdl KSB7CisgICAgICAgIG1fc291cE1lc3NhZ2UgPSBzb3VwX21lc3NhZ2VfbmV3X2Zyb21fdXJpKGh0 dHBNZXRob2QoKS51dGY4KCkuZGF0YSgpLCBzb3VwVVJJLmdldCgpKTsKKyAgICAgICAgLy8gQmFs YW5jZWQgaW4gdGhlIGRlc3RydWN0b3I7IHdlIG5lZWQgdG8ga2VlcCBvdXIgb3duIHJlZiwKKyAg ICAgICAgLy8gYmVjYXVzZSBhZnRlciBxdWV1ZWluZyB0aGUgbWVzc2FnZSwgdGhlIHNlc3Npb24g b3ducyB0aGUKKyAgICAgICAgLy8gaW5pdGlhbCByZWZlcmVuY2UuCisgICAgICAgIGdfb2JqZWN0 X3JlZihtX3NvdXBNZXNzYWdlKTsKKyAgICB9IGVsc2UgeworICAgICAgICBzb3VwX21lc3NhZ2Vf c2V0X3VyaShtX3NvdXBNZXNzYWdlLCBzb3VwVVJJLmdldCgpKTsKKworICAgICAgICBnX29iamVj dF9zZXQobV9zb3VwTWVzc2FnZSwgIm1ldGhvZCIsIGh0dHBNZXRob2QoKS51dGY4KCkuZGF0YSgp LCBOVUxMKTsKKyAgICAgICAgc291cF9tZXNzYWdlX2hlYWRlcnNfY2xlYXIobV9zb3VwTWVzc2Fn ZS0+cmVxdWVzdF9oZWFkZXJzKTsKKyAgICB9CisKKyAgICBBU1NFUlQobV9zb3VwTWVzc2FnZSk7 CisKKyAgICBIVFRQSGVhZGVyTWFwIGhlYWRlcnMgPSBodHRwSGVhZGVyRmllbGRzKCk7CisgICAg U291cE1lc3NhZ2VIZWFkZXJzKiBzb3VwSGVhZGVycyA9IG1fc291cE1lc3NhZ2UtPnJlcXVlc3Rf aGVhZGVyczsKKyAgICBpZiAoIWhlYWRlcnMuaXNFbXB0eSgpKSB7CisgICAgICAgIEhUVFBIZWFk ZXJNYXA6OmNvbnN0X2l0ZXJhdG9yIGVuZCA9IGhlYWRlcnMuZW5kKCk7CisgICAgICAgIGZvciAo SFRUUEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBoZWFkZXJzLmJlZ2luKCk7IGl0ICE9 IGVuZDsgKytpdCkKKyAgICAgICAgICAgIHNvdXBfbWVzc2FnZV9oZWFkZXJzX2FwcGVuZChzb3Vw SGVhZGVycywgaXQtPmZpcnN0LnN0cmluZygpLnV0ZjgoKS5kYXRhKCksIGl0LT5zZWNvbmQudXRm OCgpLmRhdGEoKSk7CisgICAgfQorCisgICAgLy8gQm9keSBkYXRhIGlzIG9ubHkgaGFuZGxlZCBh dCBSZXNvdXJjZUhhbmRsZVNvdXA6OnN0YXJ0SHR0cCBmb3IKKyAgICAvLyBub3c7IHRoaXMgaXMg YmVjYXVzZSB0aGlzIG1heSBub3QgYmUgYSBnb29kIHBsYWNlIHRvIGdvCisgICAgLy8gb3Blbm5p bmcgYW5kIG1tYXBwaW5nIGZpbGVzLiBXZSBzaG91bGQgbWF5YmUgcmV2aXNpdCB0aGlzLgorfQor Cit9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZyBiL1dlYktpdC9ndGsvQ2hhbmdl TG9nCmluZGV4IDIzZjg5ODYuLjBhYjJlMTcgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvQ2hhbmdl TG9nCisrKyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjcgQEAKKzIwMDktMDUt MjQgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGduc0Bnbm9tZS5vcmc+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFrZSBOZXR3b3JrUmVxdWVzdCBj YXJyeSBhIHJlZmVyZW5jZSBvZiB0aGUgU291cE1lc3NhZ2UgdXNlZCBieQorICAgICAgICBSZXNv dXJjZVJlcXVlc3QsIGFuZCB1c2UgdGhhdCB0byBjcmVhdGUgbmV3IFJlc291cmNlUmVxdWVzdHMg d2hlcmUKKyAgICAgICAgbmVlZGVkLCBzbyB0aGF0IG5vIGluZm9ybWF0aW9uIGlzIGxvc3Qgd2hp bGUgcGFzc2luZyBhcm91bmQKKyAgICAgICAgTmV0d29ya1JlcXVlc3Qgb2JqZWN0cy4KKworICAg ICAgICAqIFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcDoKKyAgICAgICAg KFdlYktpdDo6RnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTUlNRVR5 cGUpOgorICAgICAgICAoV2ViS2l0OjpGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEZWNpZGVQ b2xpY3lGb3JOYXZpZ2F0aW9uQWN0aW9uKToKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJD bGllbnQ6OnN0YXJ0RG93bmxvYWQpOgorICAgICAgICAqIHdlYmtpdC93ZWJraXRkb3dubG9hZC5j cHA6CisgICAgICAgICh3ZWJraXRfZG93bmxvYWRfc3RhcnQpOgorICAgICAgICAqIHdlYmtpdC93 ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHA6CisgICAgICAgICh3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X2ZpbmFsaXplKToKKyAgICAgICAgKHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X3dpdGhfY29y ZV9yZXF1ZXN0KToKKyAgICAgICAgKHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3KToKKyAgICAg ICAgKHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X21lc3NhZ2UpOgorICAgICAgICAqIHdlYmtp dC93ZWJraXRwcml2YXRlLmg6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcDoK KyAgICAgICAgKHdlYmtpdF93ZWJfZnJhbWVfbG9hZF9yZXF1ZXN0KToKKwogMjAwOS0wNS0yMiAg R3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4KIAogICAgICAgICBSZXZpZXdl ZCBieSBKYW4gQWxvbnpvLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudEd0ay5jcHAgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1l TG9hZGVyQ2xpZW50R3RrLmNwcAppbmRleCA1YzA5N2ViLi45MWExMDQxIDEwMDY0NAotLS0gYS9X ZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAorKysgYi9X ZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcApAQCAtMzA5 LDcgKzMwOSw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGVjaWRlUG9saWN5 Rm9yTUlNRVR5cGUoRnJhbWVQb2xpY3lGdW5jdGlvbiBwb2xpCiAgICAgfQogCiAgICAgV2ViS2l0 V2ViVmlldyogcGFnZSA9IGdldFZpZXdGcm9tRnJhbWUobV9mcmFtZSk7Ci0gICAgV2ViS2l0TmV0 d29ya1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ldyhyZXNvdXJj ZVJlcXVlc3QudXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisgICAgV2ViS2l0TmV0d29y a1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2NvcmVf cmVxdWVzdChyZXNvdXJjZVJlcXVlc3QpOwogCiAgICAgV2ViS2l0V2ViUG9saWN5RGVjaXNpb24q IHBvbGljeURlY2lzaW9uID0gd2Via2l0X3dlYl9wb2xpY3lfZGVjaXNpb25fbmV3KG1fZnJhbWUs IHBvbGljeUZ1bmN0aW9uKTsKICAgICBpZiAobV9wb2xpY3lEZWNpc2lvbikKQEAgLTQwOCw3ICs0 MDgsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERlY2lkZVBvbGljeUZvck5h dmlnYXRpb25BY3Rpb24oRnJhbWVQb2xpY3lGdW5jdAogICAgIH0KIAogICAgIFdlYktpdFdlYlZp ZXcqIHdlYlZpZXcgPSBnZXRWaWV3RnJvbUZyYW1lKG1fZnJhbWUpOwotICAgIFdlYktpdE5ldHdv cmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXcocmVzb3VyY2VS ZXF1ZXN0LnVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworICAgIFdlYktpdE5ldHdvcmtS ZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3JlX3Jl cXVlc3QocmVzb3VyY2VSZXF1ZXN0KTsKICAgICBXZWJLaXROYXZpZ2F0aW9uUmVzcG9uc2UgcmVz cG9uc2U7CiAgICAgLyoKICAgICAgKiBXZSBzdGlsbCBzdXBwb3J0IHRoZSBkZXByZWNhdGVkIG5h dmlnYXRpb24tcmVxdWVzdGVkIHNpZ25hbCwgaWYgdGhlCkBAIC0xMDExLDcgKzEwMTEsNyBAQCB2 b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpzZXRNYWluRG9jdW1lbnRFcnJvcihEb2N1bWVudExvYWRl ciosIGNvbnN0IFJlc291cmNlRXJybwogCiB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpzdGFydERv d25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKIHsKLSAgICBXZWJLaXROZXR3 b3JrUmVxdWVzdCogbmV0d29ya1JlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ldyhy ZXF1ZXN0LnVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworICAgIFdlYktpdE5ldHdvcmtS ZXF1ZXN0KiBuZXR3b3JrUmVxdWVzdCA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X3dpdGhf Y29yZV9yZXF1ZXN0KHJlcXVlc3QpOwogICAgIFdlYktpdFdlYlZpZXcqIHZpZXcgPSBnZXRWaWV3 RnJvbUZyYW1lKG1fZnJhbWUpOwogCiAgICAgd2Via2l0X3dlYl92aWV3X3JlcXVlc3RfZG93bmxv YWQodmlldywgbmV0d29ya1JlcXVlc3QpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0ZG93bmxvYWQuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZG93bmxvYWQuY3Bw CmluZGV4IGEyOTk4ODMuLmJmZDAwMmYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdGRvd25sb2FkLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRkb3dubG9hZC5j cHAKQEAgLTQyMSwxMSArNDIxLDggQEAgdm9pZCB3ZWJraXRfZG93bmxvYWRfc3RhcnQoV2ViS2l0 RG93bmxvYWQqIGRvd25sb2FkKQogCiAgICAgaWYgKHByaXYtPnJlc291cmNlSGFuZGxlKQogICAg ICAgICBwcml2LT5yZXNvdXJjZUhhbmRsZS0+c2V0Q2xpZW50KHByaXYtPmRvd25sb2FkQ2xpZW50 KTsKLSAgICBlbHNlIHsKLSAgICAgICAgLy8gRklYTUU6IFVzZSB0aGUgYWN0dWFsIHJlcXVlc3Qg b2JqZWN0IHdoZW4gV2ViS2l0TmV0d29ya1JlcXVlc3QgaXMgZmluaXNoZWQuCi0gICAgICAgIFJl c291cmNlUmVxdWVzdCByZXF1ZXN0KHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShwcml2 LT5uZXR3b3JrUmVxdWVzdCkpOwotICAgICAgICBwcml2LT5yZXNvdXJjZUhhbmRsZSA9IFJlc291 cmNlSGFuZGxlOjpjcmVhdGUocmVxdWVzdCwgcHJpdi0+ZG93bmxvYWRDbGllbnQsIDAsIGZhbHNl LCBmYWxzZSwgZmFsc2UpOwotICAgIH0KKyAgICBlbHNlCisgICAgICAgIHByaXYtPnJlc291cmNl SGFuZGxlID0gUmVzb3VyY2VIYW5kbGU6OmNyZWF0ZShSZXNvdXJjZVJlcXVlc3Qod2Via2l0X25l dHdvcmtfcmVxdWVzdF9nZXRfbWVzc2FnZShwcml2LT5uZXR3b3JrUmVxdWVzdCkpLCBwcml2LT5k b3dubG9hZENsaWVudCwgMCwgZmFsc2UsIGZhbHNlLCBmYWxzZSk7CiAKICAgICBwcml2LT50aW1l ciA9IGdfdGltZXJfbmV3KCk7CiAgICAgd2Via2l0X2Rvd25sb2FkX29wZW5fc3RyZWFtX2Zvcl91 cmkoZG93bmxvYWQsIHByaXYtPmRlc3RpbmF0aW9uVVJJKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdG5ldHdvcmtyZXF1ZXN0LmNwcAppbmRleCAyYzRlOTI2Li5mZWVmM2VjIDEwMDY0NAotLS0g YS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKKysrIGIvV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwCkBAIC0xLDUgKzEsNiBAQAogLyoK ICAqIENvcHlyaWdodCAoQykgMjAwNywgMjAwOCBIb2xnZXIgSGFucyBQZXRlciBGcmV5dGhlcgor ICogQ29weXJpZ2h0IChDKSAyMDA5IEd1c3Rhdm8gTm9yb25oYSBTaWx2YQogICoKICAqIFRoaXMg bGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IK ICAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwg UHVibGljCkBAIC0xOCw5ICsxOSwxMiBAQAogICovCiAKICNpbmNsdWRlICJjb25maWcuaCIKLQog I2luY2x1ZGUgIndlYmtpdG5ldHdvcmtyZXF1ZXN0LmgiCiAKKyNpbmNsdWRlICJDU3RyaW5nLmgi CisjaW5jbHVkZSAiUmVzb3VyY2VSZXF1ZXN0LmgiCisjaW5jbHVkZSAid2Via2l0cHJpdmF0ZS5o IgorCiAvKioKICAqIFNFQ1RJT046d2Via2l0bmV0d29ya3JlcXVlc3QKICAqIEBzaG9ydF9kZXNj cmlwdGlvbjogVGhlIHRhcmdldCBvZiBhIG5hdmlnYXRpb24gcmVxdWVzdApAQCAtMzgsNiArNDIs NyBAQCBHX0RFRklORV9UWVBFKFdlYktpdE5ldHdvcmtSZXF1ZXN0LCB3ZWJraXRfbmV0d29ya19y ZXF1ZXN0LCBHX1RZUEVfT0JKRUNUKTsKIAogc3RydWN0IF9XZWJLaXROZXR3b3JrUmVxdWVzdFBy aXZhdGUgewogICAgIGdjaGFyKiB1cmk7CisgICAgU291cE1lc3NhZ2UqIG1lc3NhZ2U7CiB9Owog CiAjZGVmaW5lIFdFQktJVF9ORVRXT1JLX1JFUVVFU1RfR0VUX1BSSVZBVEUob2JqKSAoR19UWVBF X0lOU1RBTkNFX0dFVF9QUklWQVRFKChvYmopLCBXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1Qs IFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSkpCkBAIC00OSw2ICs1NCwxMSBAQCBzdGF0aWMg dm9pZCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2ZpbmFsaXplKEdPYmplY3QqIG9iamVjdCkKIAog ICAgIGdfZnJlZShwcml2LT51cmkpOwogCisgICAgaWYgKHByaXYtPm1lc3NhZ2UpIHsKKyAgICAg ICAgZ19vYmplY3RfdW5yZWYocHJpdi0+bWVzc2FnZSk7CisgICAgICAgIHByaXYtPm1lc3NhZ2Ug PSBOVUxMOworICAgIH0KKwogICAgIEdfT0JKRUNUX0NMQVNTKHdlYmtpdF9uZXR3b3JrX3JlcXVl c3RfcGFyZW50X2NsYXNzKS0+ZmluYWxpemUob2JqZWN0KTsKIH0KIApAQCAtNjUsMTMgKzc1LDI4 IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfaW5pdChXZWJLaXROZXR3b3Jr UmVxdWVzdCogcmVxdWVzdCkKICAgICByZXF1ZXN0LT5wcml2ID0gcHJpdjsKIH0KIAorLy8gZm9y IGludGVybmFsIHVzZSBvbmx5CitXZWJLaXROZXR3b3JrUmVxdWVzdCogd2Via2l0X25ldHdvcmtf cmVxdWVzdF9uZXdfd2l0aF9jb3JlX3JlcXVlc3QoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1 ZXN0JiByZXNvdXJjZVJlcXVlc3QpCit7CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVl c3QgPSBXRUJLSVRfTkVUV09SS19SRVFVRVNUKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRX T1JLX1JFUVVFU1QsIE5VTEwpKTsKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHBy aXYgPSByZXF1ZXN0LT5wcml2OworCisgICAgU291cE1lc3NhZ2UqIHNvdXBNZXNzYWdlID0gcmVz b3VyY2VSZXF1ZXN0LnNvdXBNZXNzYWdlKCk7CisgICAgaWYgKHNvdXBNZXNzYWdlKQorICAgICAg ICBwcml2LT5tZXNzYWdlID0gU09VUF9NRVNTQUdFKGdfb2JqZWN0X3JlZihzb3VwTWVzc2FnZSkp OworICAgIHByaXYtPnVyaSA9IGdfc3RyZHVwKHJlc291cmNlUmVxdWVzdC51cmwoKS5zdHJpbmco KS51dGY4KCkuZGF0YSgpKTsKKworICAgIHJldHVybiByZXF1ZXN0OworfQorCiAvKioKICAqIHdl YmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3OgogICogQHVyaTogYW4gVVJJCiAgKgogICogQ3JlYXRl cyBhIG5ldyAjV2ViS2l0TmV0d29ya1JlcXVlc3QgaW5pdGlhbGl6ZWQgd2l0aCBhbiBVUkkuCiAg KgotICogUmV0dXJuczogYSBuZXcgI1dlYktpdE5ldHdvcmtSZXF1ZXN0CisgKiBSZXR1cm5zOiBh IG5ldyAjV2ViS2l0TmV0d29ya1JlcXVlc3QsIG9yICVOVUxMIGlmIHRoZSBVUkkgaXMKKyAqIGlu dmFsaWQuCiAgKi8KIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X25ldyhjb25zdCBnY2hhciogdXJpKQogewpAQCAtODAsNiArMTA1LDEwIEBAIFdlYktpdE5ldHdv cmtSZXF1ZXN0KiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ldyhjb25zdCBnY2hhciogdXJpKQog ICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gV0VCS0lUX05FVFdPUktfUkVRVUVT VChnX29iamVjdF9uZXcoV0VCS0lUX1RZUEVfTkVUV09SS19SRVFVRVNULCBOVUxMKSk7CiAgICAg V2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKIAorICAg IHByaXYtPm1lc3NhZ2UgPSBzb3VwX21lc3NhZ2VfbmV3KCJHRVQiLCB1cmkpOworICAgIGlmICgh cHJpdi0+bWVzc2FnZSkKKyAgICAgICAgcmV0dXJuIE5VTEw7CisKICAgICBwcml2LT51cmkgPSBn X3N0cmR1cCh1cmkpOwogCiAgICAgcmV0dXJuIHJlcXVlc3Q7CkBAIC0xMTgsMyArMTQ3LDIxIEBA IEdfQ09OU1RfUkVUVVJOIGdjaGFyKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF91cmkoV2Vi S2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlCiAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRl KiBwcml2ID0gcmVxdWVzdC0+cHJpdjsKICAgICByZXR1cm4gcHJpdi0+dXJpOwogfQorCisvLyBO T1QgWUVUIEFQSTsgRm9yIGludGVybmFsIHVzZSBvbmx5LCBmb3Igbm93CisvLyB3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X2dldF9zb3VwX21lc3NhZ2U6CisvLyBAcmVxdWVzdDogYSAjV2ViS2l0TmV0 d29ya1JlcXVlc3QKKy8vCisvLyBPYnRhaW5zIHRoZSAjU291cE1lc3NhZ2UgaGVsZCBhbmQgdXNl ZCBieSB0aGUgZ2l2ZW4gcmVxdWVzdC4gTm90aWNlCisvLyB0aGF0IG1vZGlmaWNhdGlvbiBvZiB0 aGUgU291cE1lc3NhZ2Ugb2YgYSByZXF1ZXN0IGJ5IHNpZ25hbAorLy8gaGFuZGxlcnMgaXMgb25s eSBzdXBwb3J0ZWQgd2hlcmUgZXhwbGljaXRseSBkb2N1bWVudGVkLgorLy8KKy8vIFJldHVybnM6 IHRoZSAjU291cE1lc3NhZ2UKK1NvdXBNZXNzYWdlKiB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dl dF9tZXNzYWdlKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGdfcmV0dXJu X3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFUVVFU1QocmVxdWVzdCksIE5VTEwpOwor CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKiBwcml2ID0gcmVxdWVzdC0+cHJpdjsK KworICAgIHJldHVybiBwcml2LT5tZXNzYWdlOworfQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0cHJpdmF0ZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5o CmluZGV4IDkzYmI4MjAuLmMxYjk4NmYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHByaXZhdGUuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKQEAg LTIzLDcgKzIzLDggQEAKICNkZWZpbmUgV0VCS0lUX1BSSVZBVEVfSAogCiAvKgotICogVGhpcyBm aWxlIGtub3dzIHRoZSBzaGFyZWQgc2VjcmV0IG9mIFdlYktpdFdlYlZpZXcgYW5kIFdlYktpdFdl YkZyYW1lLgorICogVGhpcyBmaWxlIGtub3dzIHRoZSBzaGFyZWQgc2VjcmV0IG9mIFdlYktpdFdl YlZpZXcsIFdlYktpdFdlYkZyYW1lLAorICogYW5kIFdlYktpdE5ldHdvcmtSZXF1ZXN0LgogICog VGhleSBhcmUgdXNpbmcgV2ViQ29yZSB3aGljaCBtdXNuJ3QgYmUgZXhwb3NlZCB0byB0aGUgb3V0 ZXIgd29ybGQuCiAgKi8KIApAQCAtMzcsNiArMzgsNyBAQAogI2luY2x1ZGUgPHdlYmtpdC93ZWJr aXR3ZWJzZXR0aW5ncy5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJ3aW5kb3dmZWF0dXJl cy5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJiYWNrZm9yd2FyZGxpc3QuaD4KKyNpbmNs dWRlIDx3ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuaD4KIAogI2luY2x1ZGUgIkJhY2tGb3J3 YXJkTGlzdC5oIgogI2luY2x1ZGUgPGVuY2hhbnQuaD4KQEAgLTQ3LDEwICs0OSwxMiBAQAogI2lu Y2x1ZGUgIkluc3BlY3RvckNsaWVudEd0ay5oIgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyQ2xpZW50 LmgiCiAjaW5jbHVkZSAiUmVzb3VyY2VIYW5kbGUuaCIKKyNpbmNsdWRlICJSZXNvdXJjZVJlcXVl c3QuaCIKICNpbmNsdWRlICJSZXNvdXJjZVJlc3BvbnNlLmgiCiAjaW5jbHVkZSAiV2luZG93RmVh dHVyZXMuaCIKIAogI2luY2x1ZGUgPGdsaWIuaD4KKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4K IAogY2xhc3MgRG93bmxvYWRDbGllbnQ7CiAKQEAgLTE4MCw2ICsxODQsMTIgQEAgZXh0ZXJuICJD IiB7CiAgICAgdm9pZAogICAgIHdlYmtpdF93ZWJfcG9saWN5X2RlY2lzaW9uX2NhbmNlbCAoV2Vi S2l0V2ViUG9saWN5RGVjaXNpb24qIGRlY2lzaW9uKTsKIAorICAgIFdlYktpdE5ldHdvcmtSZXF1 ZXN0KgorICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0KGNv bnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0KTsKKworICAgIFNv dXBNZXNzYWdlKgorICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X21lc3NhZ2UoV2ViS2l0 TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOworCiAgICAgLy8gRklYTUU6IG1vdmUgdGhpcyBmdW5j dGlvbmFsaXR5IGludG8gYSAnV2ViS2l0V2ViRGF0YVNvdXJjZScgb25jZSBpbXBsZW1lbnRlZAog ICAgIFdFQktJVF9BUEkgZ2NoYXIqCiAgICAgd2Via2l0X3dlYl9mcmFtZV9nZXRfcmVzcG9uc2Vf bWltZV90eXBlKFdlYktpdFdlYkZyYW1lKiBmcmFtZSk7CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJm cmFtZS5jcHAKaW5kZXggYTcyYmI5My4uOTAwMTIxMiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdl YmZyYW1lLmNwcApAQCAtNTEwLDkgKzUxMCw3IEBAIHZvaWQgd2Via2l0X3dlYl9mcmFtZV9sb2Fk X3JlcXVlc3QoV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBXZWJLaXROZXR3b3JrUmVxdWVzdCoKICAg ICBpZiAoIWNvcmVGcmFtZSkKICAgICAgICAgcmV0dXJuOwogCi0gICAgLy8gVE9ETzogVXNlIHRo ZSBSZXNvdXJjZVJlcXVlc3QgY2FycmllZCBieSBXZWJLaXROZXR3b3JrUmVxdWVzdCB3aGVuIGl0 IGlzIGltcGxlbWVudGVkLgotICAgIFN0cmluZyBzdHJpbmcgPSBTdHJpbmc6OmZyb21VVEY4KHdl YmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShyZXF1ZXN0KSk7Ci0gICAgY29yZUZyYW1lLT5s b2FkZXIoKS0+bG9hZChSZXNvdXJjZVJlcXVlc3QoS1VSTChLVVJMKCksIHN0cmluZykpLCBmYWxz ZSk7CisgICAgY29yZUZyYW1lLT5sb2FkZXIoKS0+bG9hZChSZXNvdXJjZVJlcXVlc3Qod2Via2l0 X25ldHdvcmtfcmVxdWVzdF9nZXRfbWVzc2FnZShyZXF1ZXN0KSksIGZhbHNlKTsKIH0KIAogLyoq Cg== 30634 2009-05-24 14:08:35 -0700 2009-05-28 19:39:37 -0700 Make NetworkRequest carry a reference of the SoupMessage used by Make-NetworkRequest-carry-a-reference-of-the-SoupMessage-used-by.patch text/plain 27337 gustavo YmM0OWRjM2ZkZTNlZjRhNTQzOTZjMTdiODAzNzljY2Y4MTlhMDkwMApkaWZmIC0tZ2l0IGEvQ2hh bmdlTG9nIGIvQ2hhbmdlTG9nCmluZGV4IDdiNmYxYjEuLjQzOThiMGMgMTAwNjQ0Ci0tLSBhL0No YW5nZUxvZworKysgYi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMiBAQAorMjAwOS0wNS0yNCAgR3Vz dGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgYSB0ZXN0LWNhc2UgZm9yIG91ciBIVFRQ IGJhY2tlbmQsIGN1cnJlbnRseSBjaGVja2luZyB0aGUKKyAgICAgICAgcmVmLWNvdW50aW5nIG9m IHRoZSBTb3VwTWVzc2FnZS4KKworICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOgorCiAyMDA5LTA1 LTIyICBBbnRvbmlvIEdvbWVzICAgPGFudG9uaW8uZ29tZXNAb3BlbmJvc3NhLm9yZz4KIAogICAg ICAgICBSZXZpZXdlZCBieSBHdXN0YXZvIE5vcm9uaGEuCmRpZmYgLS1naXQgYS9HTlVtYWtlZmls ZS5hbSBiL0dOVW1ha2VmaWxlLmFtCmluZGV4IGNiNmNmMTkuLmNjNzdiZDAgMTAwNjQ0Ci0tLSBh L0dOVW1ha2VmaWxlLmFtCisrKyBiL0dOVW1ha2VmaWxlLmFtCkBAIC01MjUsMTIgKzUyNSwxOCBA QCB3ZWJraXRfdGVzdHNfbGRmbGFncyA9IFwKIAktbm8taW5zdGFsbCBcCiAJLW5vLWZhc3QtaW5z dGFsbAogCi1URVNUX1BST0dTICs9IFByb2dyYW1zL3VuaXR0ZXN0cy90ZXN0d2ViZnJhbWUgXAor VEVTVF9QUk9HUyArPSBQcm9ncmFtcy91bml0dGVzdHMvdGVzdGh0dHBiYWNrZW5kIFwKKwlQcm9n cmFtcy91bml0dGVzdHMvdGVzdHdlYmZyYW1lIFwKIAlQcm9ncmFtcy91bml0dGVzdHMvdGVzdHdl YmJhY2tmb3J3YXJkbGlzdCBcCiAJUHJvZ3JhbXMvdW5pdHRlc3RzL3Rlc3R3ZWJoaXN0b3J5aXRl bSBcCiAJUHJvZ3JhbXMvdW5pdHRlc3RzL3Rlc3Rkb3dubG9hZAogCiAjIEFkZCBhZGRpdGlvbmFs IHRlc3RzIGhlcmUKK1Byb2dyYW1zX3VuaXR0ZXN0c190ZXN0aHR0cGJhY2tlbmRfU09VUkNFUyA9 IFdlYktpdC9ndGsvdGVzdHMvdGVzdGh0dHBiYWNrZW5kLmMKK1Byb2dyYW1zX3VuaXR0ZXN0c190 ZXN0aHR0cGJhY2tlbmRfQ0ZMQUdTID0gJCh3ZWJraXRfdGVzdHNfY2ZsYWdzKQorUHJvZ3JhbXNf dW5pdHRlc3RzX3Rlc3RodHRwYmFja2VuZF9MREFERCA9ICQod2Via2l0X3Rlc3RzX2xkYWRkKQor UHJvZ3JhbXNfdW5pdHRlc3RzX3Rlc3RodHRwYmFja2VuZF9MREZMQUdTID0gJCh3ZWJraXRfdGVz dHNfbGRmbGFncykKKwogUHJvZ3JhbXNfdW5pdHRlc3RzX3Rlc3R3ZWJmcmFtZV9TT1VSQ0VTID0g V2ViS2l0L2d0ay90ZXN0cy90ZXN0d2ViZnJhbWUuYwogUHJvZ3JhbXNfdW5pdHRlc3RzX3Rlc3R3 ZWJmcmFtZV9DRkxBR1MgPSAkKHdlYmtpdF90ZXN0c19jZmxhZ3MpCiBQcm9ncmFtc191bml0dGVz dHNfdGVzdHdlYmZyYW1lX0xEQUREID0gJCh3ZWJraXRfdGVzdHNfbGRhZGQpCmRpZmYgLS1naXQg YS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDAzMjM2NzYuLjA3 ZGY3ODggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdl TG9nCkBAIC0xLDMgKzEsMjYgQEAKKzIwMDktMDUtMjQgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAg PGduc0Bnbm9tZS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgTWFrZSBTb3VwTWVzc2FnZSBhIG1lbWJlciBvZiBSZXNvdXJjZVJlcXVlc3QsIGlu c3RlYWQgb2YgY3JlYXRpbmcKKyAgICAgICAgaXQgaW4gc3RhcnRIdHRwLiBJbXBsZW1lbnQgdXBk YXRpbmcgb2YgUmVzb3VyY2VSZXF1ZXN0IGZyb20KKyAgICAgICAgU291cE1lc3NhZ2UsIGFuZCB2 aWNlIHZlcnNhLgorCisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisgICAgICAgICogcGxhdGZv cm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpSZXNvdXJjZUhhbmRsZTo6flJlc291cmNlSGFuZGxlKToKKyAgICAgICAgKFdlYkNvcmU6Omdv dEhlYWRlcnNDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZUhhbmRsZTo6c3Rh cnRIdHRwKToKKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0 Lmg6CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3Q6OlJlc291cmNlUmVxdWVzdCk6 CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3Q6On5SZXNvdXJjZVJlcXVlc3QpOgor ICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3RTb3VwLmNwcDog QWRkZWQuCisgICAgICAgIChXVEY6OlNvdXBVUkkpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3Vy Y2VSZXF1ZXN0Ojpzb3VwTWVzc2FnZSk6CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZVJlcXVl c3Q6OlJlc291cmNlUmVxdWVzdCk6CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3Q6 OmRvVXBkYXRlUmVzb3VyY2VSZXF1ZXN0KToKKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlUmVx dWVzdDo6ZG9VcGRhdGVQbGF0Zm9ybVJlcXVlc3QpOgorCiAyMDA5LTA1LTIyICBEYXJpbiBBZGxl ciAgPGRhcmluQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYW4gQmVybnN0ZWlu LgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbSBiL1dlYkNvcmUvR05VbWFrZWZp bGUuYW0KaW5kZXggM2UwZjA2My4uYWJlN2MwYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9HTlVtYWtl ZmlsZS5hbQorKysgYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCkBAIC0xODY0LDYgKzE4NjQsNyBA QCB3ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3Vw L0ROU1NvdXAuY3BwIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUVy cm9yLmggXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291 cC5jcHAgXAorCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdFNv dXAuY3BwIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3Qu aCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXNwb25zZS5oIFwK IAlXZWJDb3JlL3BsYXRmb3JtL3RleHQvZ3RrL1RleHRCcmVha0l0ZXJhdG9ySW50ZXJuYWxJQ1VH dGsuY3BwCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJj ZUhhbmRsZVNvdXAuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VI YW5kbGVTb3VwLmNwcAppbmRleCA3ZjAxMzVhLi5kOGFmMGU3IDEwMDY0NAotLS0gYS9XZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCisrKyBiL1dlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKQEAgLTEzNiw2 ICsxMzYsOSBAQCBSZXNvdXJjZUhhbmRsZUludGVybmFsOjp+UmVzb3VyY2VIYW5kbGVJbnRlcm5h bCgpCiAKIFJlc291cmNlSGFuZGxlOjp+UmVzb3VyY2VIYW5kbGUoKQogeworICAgIGlmIChkLT5t X21zZykKKyAgICAgICAgZ19zaWduYWxfaGFuZGxlcnNfZGlzY29ubmVjdF9tYXRjaGVkKGQtPm1f bXNnLCBHX1NJR05BTF9NQVRDSF9EQVRBLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgMCwgMCwgMCwgMCwgdGhpcyk7CiB9CiAKIHN0YXRpYyB2b2lkIGZpbGxS ZXNwb25zZUZyb21NZXNzYWdlKFNvdXBNZXNzYWdlKiBtc2csIFJlc291cmNlUmVzcG9uc2UqIHJl c3BvbnNlKQpAQCAtMjU2LDcgKzI1OSw3IEBAIHN0YXRpYyB2b2lkIGdvdEhlYWRlcnNDYWxsYmFj ayhTb3VwTWVzc2FnZSogbXNnLCBncG9pbnRlciBkYXRhKQogICAgICAgICAmJiAoIWNvbnRlbnRU eXBlIHx8ICFnX2FzY2lpX3N0cmNhc2VjbXAoY29udGVudFR5cGUsICJ0ZXh0L3BsYWluIikpKQog ICAgICAgICByZXR1cm47CiAKLSAgICBSZXNvdXJjZUhhbmRsZSogaGFuZGxlID0gc3RhdGljX2Nh c3Q8UmVzb3VyY2VIYW5kbGUqPihkYXRhKTsKKyAgICBSZWZQdHI8UmVzb3VyY2VIYW5kbGU+IGhh bmRsZSA9IHN0YXRpY19jYXN0PFJlc291cmNlSGFuZGxlKj4oZGF0YSk7CiAgICAgaWYgKCFoYW5k bGUpCiAgICAgICAgIHJldHVybjsKICAgICBSZXNvdXJjZUhhbmRsZUludGVybmFsKiBkID0gaGFu ZGxlLT5nZXRJbnRlcm5hbCgpOwpAQCAtMjY3LDggKzI3MCw4IEBAIHN0YXRpYyB2b2lkIGdvdEhl YWRlcnNDYWxsYmFjayhTb3VwTWVzc2FnZSogbXNnLCBncG9pbnRlciBkYXRhKQogICAgICAgICBy ZXR1cm47CiAKICAgICBmaWxsUmVzcG9uc2VGcm9tTWVzc2FnZShtc2csICZkLT5tX3Jlc3BvbnNl KTsKLSAgICBjbGllbnQtPmRpZFJlY2VpdmVSZXNwb25zZShoYW5kbGUsIGQtPm1fcmVzcG9uc2Up OwogICAgIGQtPm1fcmVwb3J0ZWRIZWFkZXJzID0gdHJ1ZTsKKyAgICBjbGllbnQtPmRpZFJlY2Vp dmVSZXNwb25zZShoYW5kbGUuZ2V0KCksIGQtPm1fcmVzcG9uc2UpOwogfQogCiBzdGF0aWMgdm9p ZCBnb3RDaHVua0NhbGxiYWNrKFNvdXBNZXNzYWdlKiBtc2csIFNvdXBCdWZmZXIqIGNodW5rLCBn cG9pbnRlciBkYXRhKQpAQCAtNDY1LDIwICs0NjgsMTIgQEAgYm9vbCBSZXNvdXJjZUhhbmRsZTo6 c3RhcnRIdHRwKFN0cmluZyB1cmxTdHJpbmcpCiAgICAgU291cFNlc3Npb24qIHNlc3Npb24gPSBk ZWZhdWx0U2Vzc2lvbigpOwogICAgIGVuc3VyZVNlc3Npb25Jc0luaXRpYWxpemVkKHNlc3Npb24p OwogCi0gICAgU291cE1lc3NhZ2UqIG1zZzsKLSAgICBtc2cgPSBzb3VwX21lc3NhZ2VfbmV3KHJl cXVlc3QoKS5odHRwTWV0aG9kKCkudXRmOCgpLmRhdGEoKSwgdXJsU3RyaW5nLnV0ZjgoKS5kYXRh KCkpOwotICAgIGdfc2lnbmFsX2Nvbm5lY3QobXNnLCAicmVzdGFydGVkIiwgR19DQUxMQkFDSyhy ZXN0YXJ0ZWRDYWxsYmFjayksIHRoaXMpOwotICAgIGdfc2lnbmFsX2Nvbm5lY3QobXNnLCAiZ290 LWhlYWRlcnMiLCBHX0NBTExCQUNLKGdvdEhlYWRlcnNDYWxsYmFjayksIHRoaXMpOwotICAgIGdf c2lnbmFsX2Nvbm5lY3QobXNnLCAiZ290LWNodW5rIiwgR19DQUxMQkFDSyhnb3RDaHVua0NhbGxi YWNrKSwgdGhpcyk7CisgICAgZC0+bV9tc2cgPSBzdGF0aWNfY2FzdDxTb3VwTWVzc2FnZSo+KGdf b2JqZWN0X3JlZihyZXF1ZXN0KCkuc291cE1lc3NhZ2UoKSkpOworICAgIGdfc2lnbmFsX2Nvbm5l Y3QoZC0+bV9tc2csICJyZXN0YXJ0ZWQiLCBHX0NBTExCQUNLKHJlc3RhcnRlZENhbGxiYWNrKSwg dGhpcyk7CisgICAgZ19zaWduYWxfY29ubmVjdChkLT5tX21zZywgImdvdC1oZWFkZXJzIiwgR19D QUxMQkFDSyhnb3RIZWFkZXJzQ2FsbGJhY2spLCB0aGlzKTsKKyAgICBnX3NpZ25hbF9jb25uZWN0 KGQtPm1fbXNnLCAiZ290LWNodW5rIiwgR19DQUxMQkFDSyhnb3RDaHVua0NhbGxiYWNrKSwgdGhp cyk7CiAKLSAgICBnX29iamVjdF9zZXRfZGF0YShHX09CSkVDVChtc2cpLCAicmVzb3VyY2VIYW5k bGUiLCByZWludGVycHJldF9jYXN0PHZvaWQqPih0aGlzKSk7Ci0KLSAgICBIVFRQSGVhZGVyTWFw IGN1c3RvbUhlYWRlcnMgPSBkLT5tX3JlcXVlc3QuaHR0cEhlYWRlckZpZWxkcygpOwotICAgIGlm ICghY3VzdG9tSGVhZGVycy5pc0VtcHR5KCkpIHsKLSAgICAgICAgSFRUUEhlYWRlck1hcDo6Y29u c3RfaXRlcmF0b3IgZW5kID0gY3VzdG9tSGVhZGVycy5lbmQoKTsKLSAgICAgICAgZm9yIChIVFRQ SGVhZGVyTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IGN1c3RvbUhlYWRlcnMuYmVnaW4oKTsgaXQg IT0gZW5kOyArK2l0KQotICAgICAgICAgICAgc291cF9tZXNzYWdlX2hlYWRlcnNfYXBwZW5kKG1z Zy0+cmVxdWVzdF9oZWFkZXJzLCBpdC0+Zmlyc3Quc3RyaW5nKCkudXRmOCgpLmRhdGEoKSwgaXQt PnNlY29uZC51dGY4KCkuZGF0YSgpKTsKLSAgICB9CisgICAgZ19vYmplY3Rfc2V0X2RhdGEoR19P QkpFQ1QoZC0+bV9tc2cpLCAicmVzb3VyY2VIYW5kbGUiLCByZWludGVycHJldF9jYXN0PHZvaWQq Pih0aGlzKSk7CiAKICAgICBGb3JtRGF0YSogaHR0cEJvZHkgPSBkLT5tX3JlcXVlc3QuaHR0cEJv ZHkoKTsKICAgICBpZiAoaHR0cEJvZHkgJiYgIWh0dHBCb2R5LT5pc0VtcHR5KCkpIHsKQEAgLTQ4 OCw3ICs0ODMsNyBAQCBib29sIFJlc291cmNlSGFuZGxlOjpzdGFydEh0dHAoU3RyaW5nIHVybFN0 cmluZykKICAgICAgICAgaWYgKG51bUVsZW1lbnRzIDwgMikgewogICAgICAgICAgICAgVmVjdG9y PGNoYXI+IGJvZHk7CiAgICAgICAgICAgICBodHRwQm9keS0+ZmxhdHRlbihib2R5KTsKLSAgICAg ICAgICAgIHNvdXBfbWVzc2FnZV9zZXRfcmVxdWVzdChtc2csIGQtPm1fcmVxdWVzdC5odHRwQ29u dGVudFR5cGUoKS51dGY4KCkuZGF0YSgpLAorICAgICAgICAgICAgc291cF9tZXNzYWdlX3NldF9y ZXF1ZXN0KGQtPm1fbXNnLCBkLT5tX3JlcXVlc3QuaHR0cENvbnRlbnRUeXBlKCkudXRmOCgpLmRh dGEoKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTT1VQX01FTU9SWV9D T1BZLCBib2R5LmRhdGEoKSwgYm9keS5zaXplKCkpOwogICAgICAgICB9IGVsc2UgewogICAgICAg ICAgICAgLyoKQEAgLTQ5NywxMiArNDkyLDEyIEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0 SHR0cChTdHJpbmcgdXJsU3RyaW5nKQogICAgICAgICAgICAgICogY29weWluZyBpbnRvIG1lbW9y eTsgVE9ETzogc3VwcG9ydCB1cGxvYWQgb2Ygbm9uLWxvY2FsCiAgICAgICAgICAgICAgKiAodGhp bmsgc2Z0cDovLykgZmlsZXMgYnkgdXNpbmcgR0lPPwogICAgICAgICAgICAgICovCi0gICAgICAg ICAgICBzb3VwX21lc3NhZ2VfYm9keV9zZXRfYWNjdW11bGF0ZShtc2ctPnJlcXVlc3RfYm9keSwg RkFMU0UpOworICAgICAgICAgICAgc291cF9tZXNzYWdlX2JvZHlfc2V0X2FjY3VtdWxhdGUoZC0+ bV9tc2ctPnJlcXVlc3RfYm9keSwgRkFMU0UpOwogICAgICAgICAgICAgZm9yIChzaXplX3QgaSA9 IDA7IGkgPCBudW1FbGVtZW50czsgaSsrKSB7CiAgICAgICAgICAgICAgICAgY29uc3QgRm9ybURh dGFFbGVtZW50JiBlbGVtZW50ID0gaHR0cEJvZHktPmVsZW1lbnRzKClbaV07CiAKICAgICAgICAg ICAgICAgICBpZiAoZWxlbWVudC5tX3R5cGUgPT0gRm9ybURhdGFFbGVtZW50OjpkYXRhKQotICAg ICAgICAgICAgICAgICAgICBzb3VwX21lc3NhZ2VfYm9keV9hcHBlbmQobXNnLT5yZXF1ZXN0X2Jv ZHksIFNPVVBfTUVNT1JZX1RFTVBPUkFSWSwgZWxlbWVudC5tX2RhdGEuZGF0YSgpLCBlbGVtZW50 Lm1fZGF0YS5zaXplKCkpOworICAgICAgICAgICAgICAgICAgICBzb3VwX21lc3NhZ2VfYm9keV9h cHBlbmQoZC0+bV9tc2ctPnJlcXVlc3RfYm9keSwgU09VUF9NRU1PUllfVEVNUE9SQVJZLCBlbGVt ZW50Lm1fZGF0YS5kYXRhKCksIGVsZW1lbnQubV9kYXRhLnNpemUoKSk7CiAgICAgICAgICAgICAg ICAgZWxzZSB7CiAgICAgICAgICAgICAgICAgICAgIC8qCiAgICAgICAgICAgICAgICAgICAgICAq IG1hcHBpbmcgZm9yIHVwbG9hZGVkIGZpbGVzIGNvZGUgaW5zcGlyZWQgYnkgdGVjaG5pcXVlIHVz ZWQgaW4KQEAgLTUxNiwyOCArNTExLDMxIEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0 cChTdHJpbmcgdXJsU3RyaW5nKQogCiAgICAgICAgICAgICAgICAgICAgIGlmIChlcnJvcikgewog ICAgICAgICAgICAgICAgICAgICAgICAgUmVzb3VyY2VFcnJvciByZXNvdXJjZUVycm9yKGdfcXVh cmtfdG9fc3RyaW5nKFNPVVBfSFRUUF9FUlJPUiksCi0gICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgbXNnLT5zdGF0dXNfY29kZSwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkLT5tX21zZy0+c3RhdHVz X2NvZGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgdXJsU3RyaW5nLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIFN0cmluZzo6ZnJvbVVURjgoZXJyb3ItPm1lc3NhZ2UpKTsKICAgICAgICAgICAg ICAgICAgICAgICAgIGdfZXJyb3JfZnJlZShlcnJvcik7CiAKICAgICAgICAgICAgICAgICAgICAg ICAgIGQtPmNsaWVudCgpLT5kaWRGYWlsKHRoaXMsIHJlc291cmNlRXJyb3IpOwogCi0gICAgICAg ICAgICAgICAgICAgICAgICBnX29iamVjdF91bnJlZihtc2cpOworICAgICAgICAgICAgICAgICAg ICAgICAgZ19zaWduYWxfaGFuZGxlcnNfZGlzY29ubmVjdF9tYXRjaGVkKGQtPm1fbXNnLCBHX1NJ R05BTF9NQVRDSF9EQVRBLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIDAsIDAsIDAsIDAsIHRoaXMpOworICAgICAgICAgICAgICAg ICAgICAgICAgZ19vYmplY3RfdW5yZWYoZC0+bV9tc2cpOworICAgICAgICAgICAgICAgICAgICAg ICAgZC0+bV9tc2cgPSAwOworCiAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7 CiAgICAgICAgICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAgICAgICAgICBTb3VwQnVmZmVy KiBzb3VwQnVmZmVyID0gc291cF9idWZmZXJfbmV3X3dpdGhfb3duZXIoZ19tYXBwZWRfZmlsZV9n ZXRfY29udGVudHMoZmlsZU1hcHBpbmcpLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ19tYXBwZWRfZmlsZV9n ZXRfbGVuZ3RoKGZpbGVNYXBwaW5nKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZpbGVNYXBwaW5nLCByZWlu dGVycHJldF9jYXN0PEdEZXN0cm95Tm90aWZ5PihnX21hcHBlZF9maWxlX2ZyZWUpKTsKLSAgICAg ICAgICAgICAgICAgICAgc291cF9tZXNzYWdlX2JvZHlfYXBwZW5kX2J1ZmZlcihtc2ctPnJlcXVl c3RfYm9keSwgc291cEJ1ZmZlcik7CisgICAgICAgICAgICAgICAgICAgIHNvdXBfbWVzc2FnZV9i b2R5X2FwcGVuZF9idWZmZXIoZC0+bV9tc2ctPnJlcXVlc3RfYm9keSwgc291cEJ1ZmZlcik7CiAg ICAgICAgICAgICAgICAgICAgIHNvdXBfYnVmZmVyX2ZyZWUoc291cEJ1ZmZlcik7CiAgICAgICAg ICAgICAgICAgfQogICAgICAgICAgICAgfQogICAgICAgICB9CiAgICAgfQogCi0gICAgZC0+bV9t c2cgPSBzdGF0aWNfY2FzdDxTb3VwTWVzc2FnZSo+KGdfb2JqZWN0X3JlZihtc2cpKTsKICAgICAv LyBiYWxhbmNlZCBieSBhIGRlcmVmKCkgaW4gZmluaXNoZWRDYWxsYmFjaywgd2hpY2ggc2hvdWxk IGFsd2F5cyBydW4KICAgICByZWYoKTsKIApAQCAtNTQ2LDYgKzU0NCwxMiBAQCBib29sIFJlc291 cmNlSGFuZGxlOjpzdGFydEh0dHAoU3RyaW5nIHVybFN0cmluZykKICAgICAvLyBsaWJzb3VwIGdl dHMgcHJvcGVyIENvbnRlbnQtRW5jb2Rpbmcgc3VwcG9ydCB3ZSB3aWxsIHdhbnQgdG8KICAgICAv LyB1c2UgaXQgaGVyZSBpbnN0ZWFkLgogICAgIHNvdXBfbWVzc2FnZV9oZWFkZXJzX3JlcGxhY2Uo ZC0+bV9tc2ctPnJlcXVlc3RfaGVhZGVycywgIkFjY2VwdC1FbmNvZGluZyIsICJpZGVudGl0eTtx PTEsICo7cT0wIik7CisKKyAgICAvLyBCYWxhbmNlZCBpbiBSZXNvdXJjZVJlcXVlc3QncyBkZXN0 cnVjdG9yOyB3ZSBuZWVkIHRvIGtlZXAgb3VyCisgICAgLy8gb3duIHJlZiwgYmVjYXVzZSBhZnRl ciBxdWV1ZWluZyB0aGUgbWVzc2FnZSwgdGhlIHNlc3Npb24gb3ducworICAgIC8vIHRoZSBpbml0 aWFsIHJlZmVyZW5jZS4gV2UgY2Fubm90IHJlZiB0aGUgbWVzc2FnZSBpbgorICAgIC8vIFJlc291 cmNlUmVxdWVzdCBiZWNhdXNlIG5vdCBhbGwgcmVxdWVzdCBvYmplY3RzIGFyZSBxdWV1ZWQuCisg ICAgZ19vYmplY3RfcmVmKGQtPm1fbXNnKTsKICAgICBzb3VwX3Nlc3Npb25fcXVldWVfbWVzc2Fn ZShzZXNzaW9uLCBkLT5tX21zZywgZmluaXNoZWRDYWxsYmFjaywgdGhpcyk7CiAKICAgICByZXR1 cm4gdHJ1ZTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlUmVxdWVzdC5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1 ZXN0LmgKaW5kZXggZWZiMTI0MC4uNjVjNDBjMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9y bS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0LmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0LmgKQEAgLTI5LDM2ICsyOSw2NCBAQAogCiAjaW5j bHVkZSAiUmVzb3VyY2VSZXF1ZXN0QmFzZS5oIgogCisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+ CisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgIHN0cnVjdCBSZXNvdXJjZVJlcXVlc3QgOiBS ZXNvdXJjZVJlcXVlc3RCYXNlIHsKIAogICAgICAgICBSZXNvdXJjZVJlcXVlc3QoY29uc3QgU3Ry aW5nJiB1cmwpCiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UoS1VSTCh1cmwpLCBV c2VQcm90b2NvbENhY2hlUG9saWN5KQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKDApCiAg ICAgICAgIHsKICAgICAgICAgfQogCiAgICAgICAgIFJlc291cmNlUmVxdWVzdChjb25zdCBLVVJM JiB1cmwpCiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UodXJsLCBVc2VQcm90b2Nv bENhY2hlUG9saWN5KQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKDApCiAgICAgICAgIHsK ICAgICAgICAgfQogCiAgICAgICAgIFJlc291cmNlUmVxdWVzdChjb25zdCBLVVJMJiB1cmwsIGNv bnN0IFN0cmluZyYgcmVmZXJyZXIsIFJlc291cmNlUmVxdWVzdENhY2hlUG9saWN5IHBvbGljeSA9 IFVzZVByb3RvY29sQ2FjaGVQb2xpY3kpCiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJh c2UodXJsLCBwb2xpY3kpCisgICAgICAgICAgICAsIG1fc291cE1lc3NhZ2UoMCkKICAgICAgICAg ewogICAgICAgICAgICAgc2V0SFRUUFJlZmVycmVyKHJlZmVycmVyKTsKICAgICAgICAgfQogCiAg ICAgICAgIFJlc291cmNlUmVxdWVzdCgpCiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJh c2UoS1VSTCgpLCBVc2VQcm90b2NvbENhY2hlUG9saWN5KQorICAgICAgICAgICAgLCBtX3NvdXBN ZXNzYWdlKDApCiAgICAgICAgIHsKICAgICAgICAgfQogCisgICAgICAgIFJlc291cmNlUmVxdWVz dChTb3VwTWVzc2FnZSogc291cE1lc3NhZ2UpCisgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVz dEJhc2UoKQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKHNvdXBNZXNzYWdlKQorICAgICAg ICB7CisgICAgICAgICAgICBnX29iamVjdF9yZWYoc291cE1lc3NhZ2UpOworICAgICAgICB9CisK KyAgICAgICAgLy8gV2UgZm9yY2UgY29waWVzIG9mIFJlc291cmNlUmVxdWVzdCB0byBjcmVhdGUg dGhlaXIgb3duCisgICAgICAgIC8vIFNvdXBNZXNzYWdlLCBpZiBuZWVkZWQuCisgICAgICAgIFJl c291cmNlUmVxdWVzdChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCk7CisK KyAgICAgICAgflJlc291cmNlUmVxdWVzdCgpCisgICAgICAgIHsKKyAgICAgICAgICAgIGlmICht X3NvdXBNZXNzYWdlKSB7CisgICAgICAgICAgICAgICAgZ19vYmplY3RfdW5yZWYobV9zb3VwTWVz c2FnZSk7CisgICAgICAgICAgICAgICAgbV9zb3VwTWVzc2FnZSA9IDA7CisgICAgICAgICAgICB9 CisgICAgICAgIH0KKworICAgICAgICBTb3VwTWVzc2FnZSogc291cE1lc3NhZ2UoKSBjb25zdDsK KwogICAgIHByaXZhdGU6CisgICAgICAgIFNvdXBNZXNzYWdlKiBtX3NvdXBNZXNzYWdlOwogICAg ICAgICBmcmllbmQgY2xhc3MgUmVzb3VyY2VSZXF1ZXN0QmFzZTsKIAotICAgICAgICB2b2lkIGRv VXBkYXRlUGxhdGZvcm1SZXF1ZXN0KCkge30KLSAgICAgICAgdm9pZCBkb1VwZGF0ZVJlc291cmNl UmVxdWVzdCgpIHt9CisgICAgICAgIHZvaWQgZG9VcGRhdGVQbGF0Zm9ybVJlcXVlc3QoKTsKKyAg ICAgICAgdm9pZCBkb1VwZGF0ZVJlc291cmNlUmVxdWVzdCgpOwogICAgIH07CiAKIH0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3Vw L1Jlc291cmNlUmVxdWVzdFNvdXAuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAv UmVzb3VyY2VSZXF1ZXN0U291cC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MC4uMTEyMTRmOAotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9z b3VwL1Jlc291cmNlUmVxdWVzdFNvdXAuY3BwCkBAIC0wLDAgKzEsMTQyIEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDA5IEd1c3Rhdm8gTm9yb25oYSBTaWx2YQorICoKKyAqIFRoaXMgbGlicmFy eSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1v ZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMK KyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247 IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24p IGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBp biB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdB UlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5U QUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05V CisgKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoK KyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUg ZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBC b3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisj aW5jbHVkZSAiUmVzb3VyY2VSZXF1ZXN0LmgiCisKKyNpbmNsdWRlICJDU3RyaW5nLmgiCisjaW5j bHVkZSAiR093blB0ci5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisKKyNpbmNsdWRl IDxsaWJzb3VwL3NvdXAuaD4KKworbmFtZXNwYWNlIFdURiB7CisKK3RlbXBsYXRlIDw+IHZvaWQg ZnJlZU93bmVkR1B0cjxTb3VwVVJJPihTb3VwVVJJKiB1cmkpCit7CisgICAgaWYgKHVyaSkKKwlz b3VwX3VyaV9mcmVlKHVyaSk7Cit9CisKK30KKwordXNpbmcgbmFtZXNwYWNlIHN0ZDsKKworbmFt ZXNwYWNlIFdlYkNvcmUgeworCitTb3VwTWVzc2FnZSogUmVzb3VyY2VSZXF1ZXN0Ojpzb3VwTWVz c2FnZSgpIGNvbnN0Cit7CisgICAgdXBkYXRlUGxhdGZvcm1SZXF1ZXN0KCk7CisKKyAgICByZXR1 cm4gbV9zb3VwTWVzc2FnZTsKK30KKworLy8gQmFzZWQgb24gUmVzb3VyY2VSZXF1ZXN0QmFzZTo6 Y29weURhdGEgYW5kIFJlc291cmNlUmVxdWVzdEJhc2U6OmFkb3B0LgorUmVzb3VyY2VSZXF1ZXN0 OjpSZXNvdXJjZVJlcXVlc3QoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3Qp CisgICAgOiBSZXNvdXJjZVJlcXVlc3RCYXNlKHJlc291cmNlUmVxdWVzdCkKKyAgICAsIG1fc291 cE1lc3NhZ2UoMCkKK3sKKyAgICBtX3VybCA9IHJlc291cmNlUmVxdWVzdC51cmwoKS5jb3B5KCk7 CisgICAgbV9maXJzdFBhcnR5Rm9yQ29va2llcyA9IHJlc291cmNlUmVxdWVzdC5maXJzdFBhcnR5 Rm9yQ29va2llcygpLmNvcHkoKTsKKyAgICBtX2h0dHBNZXRob2QgPSByZXNvdXJjZVJlcXVlc3Qu aHR0cE1ldGhvZCgpLmNvcHkoKTsKKyAgICBtX2h0dHBIZWFkZXJGaWVsZHMuYWRvcHQoYXV0b19w dHI8Q3Jvc3NUaHJlYWRIVFRQSGVhZGVyTWFwRGF0YT4ocmVzb3VyY2VSZXF1ZXN0Lm1faHR0cEhl YWRlckZpZWxkcy5jb3B5RGF0YSgpLnJlbGVhc2UoKSkpOworCisgICAgc2l6ZV90IGVuY29kaW5n Q291bnQgPSByZXNvdXJjZVJlcXVlc3QubV9yZXNwb25zZUNvbnRlbnREaXNwb3NpdGlvbkVuY29k aW5nRmFsbGJhY2tBcnJheS5zaXplKCk7CisgICAgaWYgKGVuY29kaW5nQ291bnQgPiAwKSB7Cisg ICAgICAgIFN0cmluZyBlbmNvZGluZzEgPSByZXNvdXJjZVJlcXVlc3QubV9yZXNwb25zZUNvbnRl bnREaXNwb3NpdGlvbkVuY29kaW5nRmFsbGJhY2tBcnJheVswXTsKKyAgICAgICAgU3RyaW5nIGVu Y29kaW5nMjsKKyAgICAgICAgU3RyaW5nIGVuY29kaW5nMzsKKyAgICAgICAgaWYgKGVuY29kaW5n Q291bnQgPiAxKSB7CisgICAgICAgICAgICBlbmNvZGluZzIgPSByZXNvdXJjZVJlcXVlc3QubV9y ZXNwb25zZUNvbnRlbnREaXNwb3NpdGlvbkVuY29kaW5nRmFsbGJhY2tBcnJheVsxXTsKKyAgICAg ICAgICAgIGlmIChlbmNvZGluZ0NvdW50ID4gMikKKyAgICAgICAgICAgICAgICBlbmNvZGluZzMg PSByZXNvdXJjZVJlcXVlc3QubV9yZXNwb25zZUNvbnRlbnREaXNwb3NpdGlvbkVuY29kaW5nRmFs bGJhY2tBcnJheVsyXTsKKyAgICAgICAgfQorICAgICAgICBBU1NFUlQoZW5jb2RpbmdDb3VudCA8 PSAzKTsKKyAgICAgICAgc2V0UmVzcG9uc2VDb250ZW50RGlzcG9zaXRpb25FbmNvZGluZ0ZhbGxi YWNrQXJyYXkoZW5jb2RpbmcxLCBlbmNvZGluZzIsIGVuY29kaW5nMyk7CisgICAgfQorICAgIGlm IChyZXNvdXJjZVJlcXVlc3QubV9odHRwQm9keSkKKyAgICAgICAgc2V0SFRUUEJvZHkocmVzb3Vy Y2VSZXF1ZXN0Lmh0dHBCb2R5KCkpOworCisgICAgbV9yZXNvdXJjZVJlcXVlc3RVcGRhdGVkID0g dHJ1ZTsKKyAgICBtX3BsYXRmb3JtUmVxdWVzdFVwZGF0ZWQgPSBmYWxzZTsKK30KKwordm9pZCBS ZXNvdXJjZVJlcXVlc3Q6OmRvVXBkYXRlUmVzb3VyY2VSZXF1ZXN0KCkKK3sKKyAgICBpZiAoIW1f c291cE1lc3NhZ2UpCisgICAgICAgIHJldHVybjsKKworICAgIFNvdXBVUkkqIHNvdXBVUkkgPSBz b3VwX21lc3NhZ2VfZ2V0X3VyaShtX3NvdXBNZXNzYWdlKTsKKyAgICBHT3duUHRyPGdjaGFyPiB1 cmkoc291cF91cmlfdG9fc3RyaW5nKHNvdXBVUkksIEZBTFNFKSk7CisgICAgbV91cmwgPSBLVVJM KEtVUkwoKSwgU3RyaW5nOjpmcm9tVVRGOCh1cmkuZ2V0KCkpKTsKKworICAgIG1faHR0cE1ldGhv ZCA9IFN0cmluZzo6ZnJvbVVURjgobV9zb3VwTWVzc2FnZS0+bWV0aG9kKTsKKworICAgIFNvdXBN ZXNzYWdlSGVhZGVyc0l0ZXIgaGVhZGVyc0l0ZXI7CisgICAgY29uc3QgY2hhciogaGVhZGVyTmFt ZTsKKyAgICBjb25zdCBjaGFyKiBoZWFkZXJWYWx1ZTsKKworICAgIHNvdXBfbWVzc2FnZV9oZWFk ZXJzX2l0ZXJfaW5pdCgmaGVhZGVyc0l0ZXIsIG1fc291cE1lc3NhZ2UtPnJlcXVlc3RfaGVhZGVy cyk7CisgICAgd2hpbGUgKHNvdXBfbWVzc2FnZV9oZWFkZXJzX2l0ZXJfbmV4dCgmaGVhZGVyc0l0 ZXIsICZoZWFkZXJOYW1lLCAmaGVhZGVyVmFsdWUpKQorICAgICAgICBtX2h0dHBIZWFkZXJGaWVs ZHMuc2V0KFN0cmluZzo6ZnJvbVVURjgoaGVhZGVyTmFtZSksIFN0cmluZzo6ZnJvbVVURjgoaGVh ZGVyVmFsdWUpKTsKKworICAgIG1faHR0cEJvZHkgPSBGb3JtRGF0YTo6Y3JlYXRlKG1fc291cE1l c3NhZ2UtPnJlcXVlc3RfYm9keS0+ZGF0YSwgbV9zb3VwTWVzc2FnZS0+cmVxdWVzdF9ib2R5LT5s ZW5ndGgpOworCisgICAgLy8gRklYTUU6IG1fYWxsb3dIVFRQQ29va2llcyBhbmQgbV9maXJzdFBh cnR5Rm9yQ29va2llcyBzaG91bGQKKyAgICAvLyBwcm9iYWJseSBiZSBoYW5kbGVkIGhlcmUgYW5k IG9uIGRvVXBkYXRlUGxhdGZvcm1SZXF1ZXN0CisgICAgLy8gc29tZWhvdy4KK30KKwordm9pZCBS ZXNvdXJjZVJlcXVlc3Q6OmRvVXBkYXRlUGxhdGZvcm1SZXF1ZXN0KCkKK3sKKyAgICBpZiAoaXNO dWxsKCkpIHsKKyAgICAgICAgaWYgKG1fc291cE1lc3NhZ2UpCisgICAgICAgICAgICBnX29iamVj dF91bnJlZihtX3NvdXBNZXNzYWdlKTsKKyAgICAgICAgbV9zb3VwTWVzc2FnZSA9IDA7CisgICAg ICAgIHJldHVybjsKKyAgICB9CisKKyAgICBHT3duUHRyPFNvdXBVUkk+IHNvdXBVUkkoc291cF91 cmlfbmV3KHVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBBU1NFUlQoc291cFVS SS5nZXQoKSk7CisKKyAgICBpZiAoIW1fc291cE1lc3NhZ2UpIHsKKyAgICAgICAgbV9zb3VwTWVz c2FnZSA9IHNvdXBfbWVzc2FnZV9uZXdfZnJvbV91cmkoaHR0cE1ldGhvZCgpLnV0ZjgoKS5kYXRh KCksIHNvdXBVUkkuZ2V0KCkpOworICAgIH0gZWxzZSB7CisgICAgICAgIHNvdXBfbWVzc2FnZV9z ZXRfdXJpKG1fc291cE1lc3NhZ2UsIHNvdXBVUkkuZ2V0KCkpOworCisgICAgICAgIGdfb2JqZWN0 X3NldChtX3NvdXBNZXNzYWdlLCAibWV0aG9kIiwgaHR0cE1ldGhvZCgpLnV0ZjgoKS5kYXRhKCks IE5VTEwpOworICAgICAgICBzb3VwX21lc3NhZ2VfaGVhZGVyc19jbGVhcihtX3NvdXBNZXNzYWdl LT5yZXF1ZXN0X2hlYWRlcnMpOworICAgIH0KKworICAgIEFTU0VSVChtX3NvdXBNZXNzYWdlKTsK KworICAgIEhUVFBIZWFkZXJNYXAgaGVhZGVycyA9IGh0dHBIZWFkZXJGaWVsZHMoKTsKKyAgICBT b3VwTWVzc2FnZUhlYWRlcnMqIHNvdXBIZWFkZXJzID0gbV9zb3VwTWVzc2FnZS0+cmVxdWVzdF9o ZWFkZXJzOworICAgIGlmICghaGVhZGVycy5pc0VtcHR5KCkpIHsKKyAgICAgICAgSFRUUEhlYWRl ck1hcDo6Y29uc3RfaXRlcmF0b3IgZW5kID0gaGVhZGVycy5lbmQoKTsKKyAgICAgICAgZm9yIChI VFRQSGVhZGVyTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IGhlYWRlcnMuYmVnaW4oKTsgaXQgIT0g ZW5kOyArK2l0KQorICAgICAgICAgICAgc291cF9tZXNzYWdlX2hlYWRlcnNfYXBwZW5kKHNvdXBI ZWFkZXJzLCBpdC0+Zmlyc3Quc3RyaW5nKCkudXRmOCgpLmRhdGEoKSwgaXQtPnNlY29uZC51dGY4 KCkuZGF0YSgpKTsKKyAgICB9CisKKyAgICAvLyBCb2R5IGRhdGEgaXMgb25seSBoYW5kbGVkIGF0 IFJlc291cmNlSGFuZGxlU291cDo6c3RhcnRIdHRwIGZvcgorICAgIC8vIG5vdzsgdGhpcyBpcyBi ZWNhdXNlIHRoaXMgbWF5IG5vdCBiZSBhIGdvb2QgcGxhY2UgdG8gZ28KKyAgICAvLyBvcGVubmlu ZyBhbmQgbW1hcHBpbmcgZmlsZXMuIFdlIHNob3VsZCBtYXliZSByZXZpc2l0IHRoaXMuCit9CisK K30KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIvV2ViS2l0L2d0ay9DaGFuZ2VM b2cKaW5kZXggMjNmODk4Ni4uMGFiMmUxNyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNyBAQAorMjAwOS0wNS0y NCAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBNYWtlIE5ldHdvcmtSZXF1ZXN0IGNh cnJ5IGEgcmVmZXJlbmNlIG9mIHRoZSBTb3VwTWVzc2FnZSB1c2VkIGJ5CisgICAgICAgIFJlc291 cmNlUmVxdWVzdCwgYW5kIHVzZSB0aGF0IHRvIGNyZWF0ZSBuZXcgUmVzb3VyY2VSZXF1ZXN0cyB3 aGVyZQorICAgICAgICBuZWVkZWQsIHNvIHRoYXQgbm8gaW5mb3JtYXRpb24gaXMgbG9zdCB3aGls ZSBwYXNzaW5nIGFyb3VuZAorICAgICAgICBOZXR3b3JrUmVxdWVzdCBvYmplY3RzLgorCisgICAg ICAgICogV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwOgorICAgICAgICAo V2ViS2l0OjpGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JNSU1FVHlw ZSk6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERlY2lkZVBv bGljeUZvck5hdmlnYXRpb25BY3Rpb24pOgorICAgICAgICAoV2ViS2l0OjpGcmFtZUxvYWRlckNs aWVudDo6c3RhcnREb3dubG9hZCk6CisgICAgICAgICogd2Via2l0L3dlYmtpdGRvd25sb2FkLmNw cDoKKyAgICAgICAgKHdlYmtpdF9kb3dubG9hZF9zdGFydCk6CisgICAgICAgICogd2Via2l0L3dl YmtpdG5ldHdvcmtyZXF1ZXN0LmNwcDoKKyAgICAgICAgKHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf ZmluYWxpemUpOgorICAgICAgICAod2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3Jl X3JlcXVlc3QpOgorICAgICAgICAod2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXcpOgorICAgICAg ICAod2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWVzc2FnZSk6CisgICAgICAgICogd2Via2l0 L3dlYmtpdHByaXZhdGUuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwOgor ICAgICAgICAod2Via2l0X3dlYl9mcmFtZV9sb2FkX3JlcXVlc3QpOgorCiAyMDA5LTA1LTIyICBH dXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxnbnNAZ25vbWUub3JnPgogCiAgICAgICAgIFJldmlld2Vk IGJ5IEphbiBBbG9uem8uCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50R3RrLmNwcCBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVM b2FkZXJDbGllbnRHdGsuY3BwCmluZGV4IDVjMDk3ZWIuLjkxYTEwNDEgMTAwNjQ0Ci0tLSBhL1dl YktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCisrKyBiL1dl YktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCkBAIC0zMDks NyArMzA5LDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEZWNpZGVQb2xpY3lG b3JNSU1FVHlwZShGcmFtZVBvbGljeUZ1bmN0aW9uIHBvbGkKICAgICB9CiAKICAgICBXZWJLaXRX ZWJWaWV3KiBwYWdlID0gZ2V0Vmlld0Zyb21GcmFtZShtX2ZyYW1lKTsKLSAgICBXZWJLaXROZXR3 b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3KHJlc291cmNl UmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKyAgICBXZWJLaXROZXR3b3Jr UmVxdWVzdCogcmVxdWVzdCA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X3dpdGhfY29yZV9y ZXF1ZXN0KHJlc291cmNlUmVxdWVzdCk7CiAKICAgICBXZWJLaXRXZWJQb2xpY3lEZWNpc2lvbiog cG9saWN5RGVjaXNpb24gPSB3ZWJraXRfd2ViX3BvbGljeV9kZWNpc2lvbl9uZXcobV9mcmFtZSwg cG9saWN5RnVuY3Rpb24pOwogICAgIGlmIChtX3BvbGljeURlY2lzaW9uKQpAQCAtNDA4LDcgKzQw OCw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTmF2 aWdhdGlvbkFjdGlvbihGcmFtZVBvbGljeUZ1bmN0CiAgICAgfQogCiAgICAgV2ViS2l0V2ViVmll dyogd2ViVmlldyA9IGdldFZpZXdGcm9tRnJhbWUobV9mcmFtZSk7Ci0gICAgV2ViS2l0TmV0d29y a1JlcXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ldyhyZXNvdXJjZVJl cXVlc3QudXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisgICAgV2ViS2l0TmV0d29ya1Jl cXVlc3QqIHJlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2NvcmVfcmVx dWVzdChyZXNvdXJjZVJlcXVlc3QpOwogICAgIFdlYktpdE5hdmlnYXRpb25SZXNwb25zZSByZXNw b25zZTsKICAgICAvKgogICAgICAqIFdlIHN0aWxsIHN1cHBvcnQgdGhlIGRlcHJlY2F0ZWQgbmF2 aWdhdGlvbi1yZXF1ZXN0ZWQgc2lnbmFsLCBpZiB0aGUKQEAgLTEwMTEsNyArMTAxMSw3IEBAIHZv aWQgRnJhbWVMb2FkZXJDbGllbnQ6OnNldE1haW5Eb2N1bWVudEVycm9yKERvY3VtZW50TG9hZGVy KiwgY29uc3QgUmVzb3VyY2VFcnJvCiAKIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93 bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQogewotICAgIFdlYktpdE5ldHdv cmtSZXF1ZXN0KiBuZXR3b3JrUmVxdWVzdCA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3KHJl cXVlc3QudXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisgICAgV2ViS2l0TmV0d29ya1Jl cXVlc3QqIG5ldHdvcmtSZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9j b3JlX3JlcXVlc3QocmVxdWVzdCk7CiAgICAgV2ViS2l0V2ViVmlldyogdmlldyA9IGdldFZpZXdG cm9tRnJhbWUobV9mcmFtZSk7CiAKICAgICB3ZWJraXRfd2ViX3ZpZXdfcmVxdWVzdF9kb3dubG9h ZCh2aWV3LCBuZXR3b3JrUmVxdWVzdCk7CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93 ZWJraXRkb3dubG9hZC5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRkb3dubG9hZC5jcHAK aW5kZXggYTI5OTg4My4uYmZkMDAyZiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0ZG93bmxvYWQuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRvd25sb2FkLmNw cApAQCAtNDIxLDExICs0MjEsOCBAQCB2b2lkIHdlYmtpdF9kb3dubG9hZF9zdGFydChXZWJLaXRE b3dubG9hZCogZG93bmxvYWQpCiAKICAgICBpZiAocHJpdi0+cmVzb3VyY2VIYW5kbGUpCiAgICAg ICAgIHByaXYtPnJlc291cmNlSGFuZGxlLT5zZXRDbGllbnQocHJpdi0+ZG93bmxvYWRDbGllbnQp OwotICAgIGVsc2UgewotICAgICAgICAvLyBGSVhNRTogVXNlIHRoZSBhY3R1YWwgcmVxdWVzdCBv YmplY3Qgd2hlbiBXZWJLaXROZXR3b3JrUmVxdWVzdCBpcyBmaW5pc2hlZC4KLSAgICAgICAgUmVz b3VyY2VSZXF1ZXN0IHJlcXVlc3Qod2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJpKHByaXYt Pm5ldHdvcmtSZXF1ZXN0KSk7Ci0gICAgICAgIHByaXYtPnJlc291cmNlSGFuZGxlID0gUmVzb3Vy Y2VIYW5kbGU6OmNyZWF0ZShyZXF1ZXN0LCBwcml2LT5kb3dubG9hZENsaWVudCwgMCwgZmFsc2Us IGZhbHNlLCBmYWxzZSk7Ci0gICAgfQorICAgIGVsc2UKKyAgICAgICAgcHJpdi0+cmVzb3VyY2VI YW5kbGUgPSBSZXNvdXJjZUhhbmRsZTo6Y3JlYXRlKFJlc291cmNlUmVxdWVzdCh3ZWJraXRfbmV0 d29ya19yZXF1ZXN0X2dldF9tZXNzYWdlKHByaXYtPm5ldHdvcmtSZXF1ZXN0KSksIHByaXYtPmRv d25sb2FkQ2xpZW50LCAwLCBmYWxzZSwgZmFsc2UsIGZhbHNlKTsKIAogICAgIHByaXYtPnRpbWVy ID0gZ190aW1lcl9uZXcoKTsKICAgICB3ZWJraXRfZG93bmxvYWRfb3Blbl9zdHJlYW1fZm9yX3Vy aShkb3dubG9hZCwgcHJpdi0+ZGVzdGluYXRpb25VUkkpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0bmV0d29ya3JlcXVlc3QuY3BwCmluZGV4IDJjNGU5MjYuLmZlZWYzZWMgMTAwNjQ0Ci0tLSBh L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcAorKysgYi9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKQEAgLTEsNSArMSw2IEBACiAvKgog ICogQ29weXJpZ2h0IChDKSAyMDA3LCAyMDA4IEhvbGdlciBIYW5zIFBldGVyIEZyZXl0aGVyCisg KiBDb3B5cmlnaHQgKEMpIDIwMDkgR3VzdGF2byBOb3JvbmhhIFNpbHZhCiAgKgogICogVGhpcyBs aWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgog ICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQ dWJsaWMKQEAgLTE4LDkgKzE5LDEyIEBACiAgKi8KIAogI2luY2x1ZGUgImNvbmZpZy5oIgotCiAj aW5jbHVkZSAid2Via2l0bmV0d29ya3JlcXVlc3QuaCIKIAorI2luY2x1ZGUgIkNTdHJpbmcuaCIK KyNpbmNsdWRlICJSZXNvdXJjZVJlcXVlc3QuaCIKKyNpbmNsdWRlICJ3ZWJraXRwcml2YXRlLmgi CisKIC8qKgogICogU0VDVElPTjp3ZWJraXRuZXR3b3JrcmVxdWVzdAogICogQHNob3J0X2Rlc2Ny aXB0aW9uOiBUaGUgdGFyZ2V0IG9mIGEgbmF2aWdhdGlvbiByZXF1ZXN0CkBAIC0zOCw2ICs0Miw3 IEBAIEdfREVGSU5FX1RZUEUoV2ViS2l0TmV0d29ya1JlcXVlc3QsIHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3QsIEdfVFlQRV9PQkpFQ1QpOwogCiBzdHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJp dmF0ZSB7CiAgICAgZ2NoYXIqIHVyaTsKKyAgICBTb3VwTWVzc2FnZSogbWVzc2FnZTsKIH07CiAK ICNkZWZpbmUgV0VCS0lUX05FVFdPUktfUkVRVUVTVF9HRVRfUFJJVkFURShvYmopIChHX1RZUEVf SU5TVEFOQ0VfR0VUX1BSSVZBVEUoKG9iaiksIFdFQktJVF9UWVBFX05FVFdPUktfUkVRVUVTVCwg V2ViS2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKSkKQEAgLTQ5LDYgKzU0LDExIEBAIHN0YXRpYyB2 b2lkIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZmluYWxpemUoR09iamVjdCogb2JqZWN0KQogCiAg ICAgZ19mcmVlKHByaXYtPnVyaSk7CiAKKyAgICBpZiAocHJpdi0+bWVzc2FnZSkgeworICAgICAg ICBnX29iamVjdF91bnJlZihwcml2LT5tZXNzYWdlKTsKKyAgICAgICAgcHJpdi0+bWVzc2FnZSA9 IE5VTEw7CisgICAgfQorCiAgICAgR19PQkpFQ1RfQ0xBU1Mod2Via2l0X25ldHdvcmtfcmVxdWVz dF9wYXJlbnRfY2xhc3MpLT5maW5hbGl6ZShvYmplY3QpOwogfQogCkBAIC02NSwxMyArNzUsMjgg QEAgc3RhdGljIHZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9pbml0KFdlYktpdE5ldHdvcmtS ZXF1ZXN0KiByZXF1ZXN0KQogICAgIHJlcXVlc3QtPnByaXYgPSBwcml2OwogfQogCisvLyBmb3Ig aW50ZXJuYWwgdXNlIG9ubHkKK1dlYktpdE5ldHdvcmtSZXF1ZXN0KiB3ZWJraXRfbmV0d29ya19y ZXF1ZXN0X25ld193aXRoX2NvcmVfcmVxdWVzdChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVl c3QmIHJlc291cmNlUmVxdWVzdCkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVz dCA9IFdFQktJVF9ORVRXT1JLX1JFUVVFU1QoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX05FVFdP UktfUkVRVUVTVCwgTlVMTCkpOworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJp diA9IHJlcXVlc3QtPnByaXY7CisKKyAgICBTb3VwTWVzc2FnZSogc291cE1lc3NhZ2UgPSByZXNv dXJjZVJlcXVlc3Quc291cE1lc3NhZ2UoKTsKKyAgICBpZiAoc291cE1lc3NhZ2UpCisgICAgICAg IHByaXYtPm1lc3NhZ2UgPSBTT1VQX01FU1NBR0UoZ19vYmplY3RfcmVmKHNvdXBNZXNzYWdlKSk7 CisgICAgcHJpdi0+dXJpID0gZ19zdHJkdXAocmVzb3VyY2VSZXF1ZXN0LnVybCgpLnN0cmluZygp LnV0ZjgoKS5kYXRhKCkpOworCisgICAgcmV0dXJuIHJlcXVlc3Q7Cit9CisKIC8qKgogICogd2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9uZXc6CiAgKiBAdXJpOiBhbiBVUkkKICAqCiAgKiBDcmVhdGVz IGEgbmV3ICNXZWJLaXROZXR3b3JrUmVxdWVzdCBpbml0aWFsaXplZCB3aXRoIGFuIFVSSS4KICAq Ci0gKiBSZXR1cm5zOiBhIG5ldyAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIFJldHVybnM6IGEg bmV3ICNXZWJLaXROZXR3b3JrUmVxdWVzdCwgb3IgJU5VTEwgaWYgdGhlIFVSSSBpcworICogaW52 YWxpZC4KICAqLwogV2ViS2l0TmV0d29ya1JlcXVlc3QqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf bmV3KGNvbnN0IGdjaGFyKiB1cmkpCiB7CkBAIC04MCw2ICsxMDUsMTAgQEAgV2ViS2l0TmV0d29y a1JlcXVlc3QqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3KGNvbnN0IGdjaGFyKiB1cmkpCiAg ICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSBXRUJLSVRfTkVUV09SS19SRVFVRVNU KGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIE5VTEwpKTsKICAgICBX ZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OwogCisgICAg cHJpdi0+bWVzc2FnZSA9IHNvdXBfbWVzc2FnZV9uZXcoIkdFVCIsIHVyaSk7CisgICAgaWYgKCFw cml2LT5tZXNzYWdlKQorICAgICAgICByZXR1cm4gTlVMTDsKKwogICAgIHByaXYtPnVyaSA9IGdf c3RyZHVwKHVyaSk7CiAKICAgICByZXR1cm4gcmVxdWVzdDsKQEAgLTExOCwzICsxNDcsMjEgQEAg R19DT05TVF9SRVRVUk4gZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShXZWJL aXROZXR3b3JrUmVxdWVzdCogcmVxdWUKICAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUq IHByaXYgPSByZXF1ZXN0LT5wcml2OwogICAgIHJldHVybiBwcml2LT51cmk7CiB9CisKKy8vIE5P VCBZRVQgQVBJOyBGb3IgaW50ZXJuYWwgdXNlIG9ubHksIGZvciBub3cKKy8vIHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfZ2V0X3NvdXBfbWVzc2FnZToKKy8vIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3 b3JrUmVxdWVzdAorLy8KKy8vIE9idGFpbnMgdGhlICNTb3VwTWVzc2FnZSBoZWxkIGFuZCB1c2Vk IGJ5IHRoZSBnaXZlbiByZXF1ZXN0LiBOb3RpY2UKKy8vIHRoYXQgbW9kaWZpY2F0aW9uIG9mIHRo ZSBTb3VwTWVzc2FnZSBvZiBhIHJlcXVlc3QgYnkgc2lnbmFsCisvLyBoYW5kbGVycyBpcyBvbmx5 IHN1cHBvcnRlZCB3aGVyZSBleHBsaWNpdGx5IGRvY3VtZW50ZWQuCisvLworLy8gUmV0dXJuczog dGhlICNTb3VwTWVzc2FnZQorU291cE1lc3NhZ2UqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0 X21lc3NhZ2UoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgZ19yZXR1cm5f dmFsX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgTlVMTCk7CisK KyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2Owor CisgICAgcmV0dXJuIHByaXYtPm1lc3NhZ2U7Cit9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgK aW5kZXggOTNiYjgyMC4uZDkzZjA3ZSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaApAQCAt MjMsNyArMjMsOCBAQAogI2RlZmluZSBXRUJLSVRfUFJJVkFURV9ICiAKIC8qCi0gKiBUaGlzIGZp bGUga25vd3MgdGhlIHNoYXJlZCBzZWNyZXQgb2YgV2ViS2l0V2ViVmlldyBhbmQgV2ViS2l0V2Vi RnJhbWUuCisgKiBUaGlzIGZpbGUga25vd3MgdGhlIHNoYXJlZCBzZWNyZXQgb2YgV2ViS2l0V2Vi VmlldywgV2ViS2l0V2ViRnJhbWUsCisgKiBhbmQgV2ViS2l0TmV0d29ya1JlcXVlc3QuCiAgKiBU aGV5IGFyZSB1c2luZyBXZWJDb3JlIHdoaWNoIG11c24ndCBiZSBleHBvc2VkIHRvIHRoZSBvdXRl ciB3b3JsZC4KICAqLwogCkBAIC0zNyw2ICszOCw3IEBACiAjaW5jbHVkZSA8d2Via2l0L3dlYmtp dHdlYnNldHRpbmdzLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYndpbmRvd2ZlYXR1cmVz Lmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYmJhY2tmb3J3YXJkbGlzdC5oPgorI2luY2x1 ZGUgPHdlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oPgogCiAjaW5jbHVkZSAiQmFja0Zvcndh cmRMaXN0LmgiCiAjaW5jbHVkZSA8ZW5jaGFudC5oPgpAQCAtNDcsMTAgKzQ5LDEyIEBACiAjaW5j bHVkZSAiSW5zcGVjdG9yQ2xpZW50R3RrLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkZXJDbGllbnQu aCIKICNpbmNsdWRlICJSZXNvdXJjZUhhbmRsZS5oIgorI2luY2x1ZGUgIlJlc291cmNlUmVxdWVz dC5oIgogI2luY2x1ZGUgIlJlc291cmNlUmVzcG9uc2UuaCIKICNpbmNsdWRlICJXaW5kb3dGZWF0 dXJlcy5oIgogCiAjaW5jbHVkZSA8Z2xpYi5oPgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgog CiBjbGFzcyBEb3dubG9hZENsaWVudDsKIApAQCAtMTgwLDYgKzE4NCwxMyBAQCBleHRlcm4gIkMi IHsKICAgICB2b2lkCiAgICAgd2Via2l0X3dlYl9wb2xpY3lfZGVjaXNpb25fY2FuY2VsIChXZWJL aXRXZWJQb2xpY3lEZWNpc2lvbiogZGVjaXNpb24pOwogCisgICAgV2ViS2l0TmV0d29ya1JlcXVl c3QqCisgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3JlX3JlcXVlc3QoY29u c3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3QpOworCisgICAgLy8g RklYTUU6IG1vdmUgdGhpcyB0byB3ZWJraXRuZXR3b3JrcmVxdWVzdC5oIG9uY2UgdGhlIEFQSSBp cyBhZ3JlZWQgdXBvbi4KKyAgICBXRUJLSVRfQVBJIFNvdXBNZXNzYWdlKgorICAgIHdlYmtpdF9u ZXR3b3JrX3JlcXVlc3RfZ2V0X21lc3NhZ2UoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3Qp OworCiAgICAgLy8gRklYTUU6IG1vdmUgdGhpcyBmdW5jdGlvbmFsaXR5IGludG8gYSAnV2ViS2l0 V2ViRGF0YVNvdXJjZScgb25jZSBpbXBsZW1lbnRlZAogICAgIFdFQktJVF9BUEkgZ2NoYXIqCiAg ICAgd2Via2l0X3dlYl9mcmFtZV9nZXRfcmVzcG9uc2VfbWltZV90eXBlKFdlYktpdFdlYkZyYW1l KiBmcmFtZSk7CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5j cHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKaW5kZXggYTcyYmI5My4u OTAwMTIxMiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3Bw CisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcApAQCAtNTEwLDkgKzUx MCw3IEBAIHZvaWQgd2Via2l0X3dlYl9mcmFtZV9sb2FkX3JlcXVlc3QoV2ViS2l0V2ViRnJhbWUq IGZyYW1lLCBXZWJLaXROZXR3b3JrUmVxdWVzdCoKICAgICBpZiAoIWNvcmVGcmFtZSkKICAgICAg ICAgcmV0dXJuOwogCi0gICAgLy8gVE9ETzogVXNlIHRoZSBSZXNvdXJjZVJlcXVlc3QgY2Fycmll ZCBieSBXZWJLaXROZXR3b3JrUmVxdWVzdCB3aGVuIGl0IGlzIGltcGxlbWVudGVkLgotICAgIFN0 cmluZyBzdHJpbmcgPSBTdHJpbmc6OmZyb21VVEY4KHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0 X3VyaShyZXF1ZXN0KSk7Ci0gICAgY29yZUZyYW1lLT5sb2FkZXIoKS0+bG9hZChSZXNvdXJjZVJl cXVlc3QoS1VSTChLVVJMKCksIHN0cmluZykpLCBmYWxzZSk7CisgICAgY29yZUZyYW1lLT5sb2Fk ZXIoKS0+bG9hZChSZXNvdXJjZVJlcXVlc3Qod2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWVz c2FnZShyZXF1ZXN0KSksIGZhbHNlKTsKIH0KIAogLyoqCg== 30763 2009-05-28 19:39:35 -0700 2009-05-29 15:58:52 -0700 network request network-request.patch text/plain 31552 gustavo MmVjYzIwNmM4ODI3MmNlZDkyMTI3NTUyM2IwZjMxOTIyNjE3ZDU2NwpkaWZmIC0tZ2l0IGEvQ2hh bmdlTG9nIGIvQ2hhbmdlTG9nCmluZGV4IGY1YTEzMjQuLjdhYzAyNWUgMTAwNjQ0Ci0tLSBhL0No YW5nZUxvZworKysgYi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMiBAQAorMjAwOS0wNS0yNCAgR3Vz dGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgYSB0ZXN0LWNhc2UgZm9yIG91ciBIVFRQ IGJhY2tlbmQsIGN1cnJlbnRseSBjaGVja2luZyB0aGUKKyAgICAgICAgcmVmLWNvdW50aW5nIG9m IHRoZSBTb3VwTWVzc2FnZS4KKworICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOgorCiAyMDA5LTA1 LTE5ICBYYW4gTG9wZXogIDx4bG9wZXpAaWdhbGlhLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBi eSBKYW4gQWxvbnpvIGFuZCBHdXN0YXZvIE5vcm9uaGEuCmRpZmYgLS1naXQgYS9HTlVtYWtlZmls ZS5hbSBiL0dOVW1ha2VmaWxlLmFtCmluZGV4IDc4MWIzN2YuLmM4N2VlNDkgMTAwNjQ0Ci0tLSBh L0dOVW1ha2VmaWxlLmFtCisrKyBiL0dOVW1ha2VmaWxlLmFtCkBAIC01MjMsMTMgKzUyMywxOSBA QCB3ZWJraXRfdGVzdHNfbGRmbGFncyA9IFwKIAktbm8taW5zdGFsbCBcCiAJLW5vLWZhc3QtaW5z dGFsbAogCi1URVNUX1BST0dTICs9IFByb2dyYW1zL3VuaXR0ZXN0cy90ZXN0d2ViZnJhbWUgXAor VEVTVF9QUk9HUyArPSBQcm9ncmFtcy91bml0dGVzdHMvdGVzdGh0dHBiYWNrZW5kIFwKKwlQcm9n cmFtcy91bml0dGVzdHMvdGVzdHdlYmZyYW1lIFwKIAlQcm9ncmFtcy91bml0dGVzdHMvdGVzdHdl YmJhY2tmb3J3YXJkbGlzdCBcCiAJUHJvZ3JhbXMvdW5pdHRlc3RzL3Rlc3R3ZWJoaXN0b3J5aXRl bSBcCiAJUHJvZ3JhbXMvdW5pdHRlc3RzL3Rlc3Rkb3dubG9hZCBcCiAJUHJvZ3JhbXMvdW5pdHRl c3RzL3Rlc3RhdGsKIAogIyBBZGQgYWRkaXRpb25hbCB0ZXN0cyBoZXJlCitQcm9ncmFtc191bml0 dGVzdHNfdGVzdGh0dHBiYWNrZW5kX1NPVVJDRVMgPSBXZWJLaXQvZ3RrL3Rlc3RzL3Rlc3RodHRw YmFja2VuZC5jCitQcm9ncmFtc191bml0dGVzdHNfdGVzdGh0dHBiYWNrZW5kX0NGTEFHUyA9ICQo d2Via2l0X3Rlc3RzX2NmbGFncykKK1Byb2dyYW1zX3VuaXR0ZXN0c190ZXN0aHR0cGJhY2tlbmRf TERBREQgPSAkKHdlYmtpdF90ZXN0c19sZGFkZCkKK1Byb2dyYW1zX3VuaXR0ZXN0c190ZXN0aHR0 cGJhY2tlbmRfTERGTEFHUyA9ICQod2Via2l0X3Rlc3RzX2xkZmxhZ3MpCisKIFByb2dyYW1zX3Vu aXR0ZXN0c190ZXN0d2ViZnJhbWVfU09VUkNFUyA9IFdlYktpdC9ndGsvdGVzdHMvdGVzdHdlYmZy YW1lLmMKIFByb2dyYW1zX3VuaXR0ZXN0c190ZXN0d2ViZnJhbWVfQ0ZMQUdTID0gJCh3ZWJraXRf dGVzdHNfY2ZsYWdzKQogUHJvZ3JhbXNfdW5pdHRlc3RzX3Rlc3R3ZWJmcmFtZV9MREFERCA9ICQo d2Via2l0X3Rlc3RzX2xkYWRkKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJD b3JlL0NoYW5nZUxvZwppbmRleCAxYmIzZmU1Li4yZmFjNjk4IDEwMDY0NAotLS0gYS9XZWJDb3Jl L0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2IEBACisyMDA5 LTA1LTI0ICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxnbnNAZ25vbWUub3JnPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE1ha2UgU291cE1lc3NhZ2Ug YSBtZW1iZXIgb2YgUmVzb3VyY2VSZXF1ZXN0LCBpbnN0ZWFkIG9mIGNyZWF0aW5nCisgICAgICAg IGl0IGluIHN0YXJ0SHR0cC4gSW1wbGVtZW50IHVwZGF0aW5nIG9mIFJlc291cmNlUmVxdWVzdCBm cm9tCisgICAgICAgIFNvdXBNZXNzYWdlLCBhbmQgdmljZSB2ZXJzYS4KKworICAgICAgICAqIEdO VW1ha2VmaWxlLmFtOgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhh bmRsZVNvdXAuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VIYW5kbGU6On5SZXNvdXJj ZUhhbmRsZSk6CisgICAgICAgIChXZWJDb3JlOjpnb3RIZWFkZXJzQ2FsbGJhY2spOgorICAgICAg ICAoV2ViQ29yZTo6UmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0cCk6CisgICAgICAgICogcGxhdGZv cm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdC5oOgorICAgICAgICAoV2ViQ29yZTo6UmVz b3VyY2VSZXF1ZXN0OjpSZXNvdXJjZVJlcXVlc3QpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3Vy Y2VSZXF1ZXN0Ojp+UmVzb3VyY2VSZXF1ZXN0KToKKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3Jr L3NvdXAvUmVzb3VyY2VSZXF1ZXN0U291cC5jcHA6IEFkZGVkLgorICAgICAgICAoV1RGOjpTb3Vw VVJJKToKKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdDo6c291cE1lc3NhZ2UpOgor ICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0OjpSZXNvdXJjZVJlcXVlc3QpOgorICAg ICAgICAoV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Ojpkb1VwZGF0ZVJlc291cmNlUmVxdWVzdCk6 CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3Q6OmRvVXBkYXRlUGxhdGZvcm1SZXF1 ZXN0KToKKwogMjAwOS0wNS0yOCAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z3VzdGF2by5ub3Jv bmhhQGNvbGxhYm9yYS5jby51az4KIAogICAgICAgICBSZXZpZXdlZCBieSBYYW4gTG9wZXouCmRp ZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtIGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5h bQppbmRleCA3OWQxMjRkLi44MTY4NWZiIDEwMDY0NAotLS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxl LmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KQEAgLTE4ODYsNiArMTg4Niw3IEBAIHdl YmNvcmVndGtfc291cmNlcyArPSBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvRE5T U291cC5jcHAgXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlRXJyb3Iu aCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNw cCBcCisJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0U291cC5j cHAgXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdC5oIFwK IAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlc3BvbnNlLmggXAogCVdl YkNvcmUvcGxhdGZvcm0vdGV4dC9ndGsvVGV4dEJyZWFrSXRlcmF0b3JJbnRlcm5hbElDVUd0ay5j cHAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFu ZGxlU291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRs ZVNvdXAuY3BwCmluZGV4IDY0NTU2NzEuLjRmY2QwYWYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxh dGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKKysrIGIvV2ViQ29yZS9w bGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcApAQCAtMTM2LDYgKzEz Niw5IEBAIFJlc291cmNlSGFuZGxlSW50ZXJuYWw6On5SZXNvdXJjZUhhbmRsZUludGVybmFsKCkK IAogUmVzb3VyY2VIYW5kbGU6On5SZXNvdXJjZUhhbmRsZSgpCiB7CisgICAgaWYgKGQtPm1fbXNn KQorICAgICAgICBnX3NpZ25hbF9oYW5kbGVyc19kaXNjb25uZWN0X21hdGNoZWQoZC0+bV9tc2cs IEdfU0lHTkFMX01BVENIX0RBVEEsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAwLCAwLCAwLCAwLCB0aGlzKTsKIH0KIAogc3RhdGljIHZvaWQgZmlsbFJlc3Bv bnNlRnJvbU1lc3NhZ2UoU291cE1lc3NhZ2UqIG1zZywgUmVzb3VyY2VSZXNwb25zZSogcmVzcG9u c2UpCkBAIC0yNTYsNyArMjU5LDcgQEAgc3RhdGljIHZvaWQgZ290SGVhZGVyc0NhbGxiYWNrKFNv dXBNZXNzYWdlKiBtc2csIGdwb2ludGVyIGRhdGEpCiAgICAgICAgICYmICghY29udGVudFR5cGUg fHwgIWdfYXNjaWlfc3RyY2FzZWNtcChjb250ZW50VHlwZSwgInRleHQvcGxhaW4iKSkpCiAgICAg ICAgIHJldHVybjsKIAotICAgIFJlc291cmNlSGFuZGxlKiBoYW5kbGUgPSBzdGF0aWNfY2FzdDxS ZXNvdXJjZUhhbmRsZSo+KGRhdGEpOworICAgIFJlZlB0cjxSZXNvdXJjZUhhbmRsZT4gaGFuZGxl ID0gc3RhdGljX2Nhc3Q8UmVzb3VyY2VIYW5kbGUqPihkYXRhKTsKICAgICBpZiAoIWhhbmRsZSkK ICAgICAgICAgcmV0dXJuOwogICAgIFJlc291cmNlSGFuZGxlSW50ZXJuYWwqIGQgPSBoYW5kbGUt PmdldEludGVybmFsKCk7CkBAIC0yNjcsOCArMjcwLDggQEAgc3RhdGljIHZvaWQgZ290SGVhZGVy c0NhbGxiYWNrKFNvdXBNZXNzYWdlKiBtc2csIGdwb2ludGVyIGRhdGEpCiAgICAgICAgIHJldHVy bjsKIAogICAgIGZpbGxSZXNwb25zZUZyb21NZXNzYWdlKG1zZywgJmQtPm1fcmVzcG9uc2UpOwot ICAgIGNsaWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKGhhbmRsZSwgZC0+bV9yZXNwb25zZSk7CiAg ICAgZC0+bV9yZXBvcnRlZEhlYWRlcnMgPSB0cnVlOworICAgIGNsaWVudC0+ZGlkUmVjZWl2ZVJl c3BvbnNlKGhhbmRsZS5nZXQoKSwgZC0+bV9yZXNwb25zZSk7CiB9CiAKIHN0YXRpYyB2b2lkIGdv dENodW5rQ2FsbGJhY2soU291cE1lc3NhZ2UqIG1zZywgU291cEJ1ZmZlciogY2h1bmssIGdwb2lu dGVyIGRhdGEpCkBAIC00NjUsMjAgKzQ2OCwxMiBAQCBib29sIFJlc291cmNlSGFuZGxlOjpzdGFy dEh0dHAoU3RyaW5nIHVybFN0cmluZykKICAgICBTb3VwU2Vzc2lvbiogc2Vzc2lvbiA9IGRlZmF1 bHRTZXNzaW9uKCk7CiAgICAgZW5zdXJlU2Vzc2lvbklzSW5pdGlhbGl6ZWQoc2Vzc2lvbik7CiAK LSAgICBTb3VwTWVzc2FnZSogbXNnOwotICAgIG1zZyA9IHNvdXBfbWVzc2FnZV9uZXcocmVxdWVz dCgpLmh0dHBNZXRob2QoKS51dGY4KCkuZGF0YSgpLCB1cmxTdHJpbmcudXRmOCgpLmRhdGEoKSk7 Ci0gICAgZ19zaWduYWxfY29ubmVjdChtc2csICJyZXN0YXJ0ZWQiLCBHX0NBTExCQUNLKHJlc3Rh cnRlZENhbGxiYWNrKSwgdGhpcyk7Ci0gICAgZ19zaWduYWxfY29ubmVjdChtc2csICJnb3QtaGVh ZGVycyIsIEdfQ0FMTEJBQ0soZ290SGVhZGVyc0NhbGxiYWNrKSwgdGhpcyk7Ci0gICAgZ19zaWdu YWxfY29ubmVjdChtc2csICJnb3QtY2h1bmsiLCBHX0NBTExCQUNLKGdvdENodW5rQ2FsbGJhY2sp LCB0aGlzKTsKKyAgICBkLT5tX21zZyA9IHN0YXRpY19jYXN0PFNvdXBNZXNzYWdlKj4oZ19vYmpl Y3RfcmVmKHJlcXVlc3QoKS5zb3VwTWVzc2FnZSgpKSk7CisgICAgZ19zaWduYWxfY29ubmVjdChk LT5tX21zZywgInJlc3RhcnRlZCIsIEdfQ0FMTEJBQ0socmVzdGFydGVkQ2FsbGJhY2spLCB0aGlz KTsKKyAgICBnX3NpZ25hbF9jb25uZWN0KGQtPm1fbXNnLCAiZ290LWhlYWRlcnMiLCBHX0NBTExC QUNLKGdvdEhlYWRlcnNDYWxsYmFjayksIHRoaXMpOworICAgIGdfc2lnbmFsX2Nvbm5lY3QoZC0+ bV9tc2csICJnb3QtY2h1bmsiLCBHX0NBTExCQUNLKGdvdENodW5rQ2FsbGJhY2spLCB0aGlzKTsK IAotICAgIGdfb2JqZWN0X3NldF9kYXRhKEdfT0JKRUNUKG1zZyksICJyZXNvdXJjZUhhbmRsZSIs IHJlaW50ZXJwcmV0X2Nhc3Q8dm9pZCo+KHRoaXMpKTsKLQotICAgIEhUVFBIZWFkZXJNYXAgY3Vz dG9tSGVhZGVycyA9IGQtPm1fcmVxdWVzdC5odHRwSGVhZGVyRmllbGRzKCk7Ci0gICAgaWYgKCFj dXN0b21IZWFkZXJzLmlzRW1wdHkoKSkgewotICAgICAgICBIVFRQSGVhZGVyTWFwOjpjb25zdF9p dGVyYXRvciBlbmQgPSBjdXN0b21IZWFkZXJzLmVuZCgpOwotICAgICAgICBmb3IgKEhUVFBIZWFk ZXJNYXA6OmNvbnN0X2l0ZXJhdG9yIGl0ID0gY3VzdG9tSGVhZGVycy5iZWdpbigpOyBpdCAhPSBl bmQ7ICsraXQpCi0gICAgICAgICAgICBzb3VwX21lc3NhZ2VfaGVhZGVyc19hcHBlbmQobXNnLT5y ZXF1ZXN0X2hlYWRlcnMsIGl0LT5maXJzdC5zdHJpbmcoKS51dGY4KCkuZGF0YSgpLCBpdC0+c2Vj b25kLnV0ZjgoKS5kYXRhKCkpOwotICAgIH0KKyAgICBnX29iamVjdF9zZXRfZGF0YShHX09CSkVD VChkLT5tX21zZyksICJyZXNvdXJjZUhhbmRsZSIsIHJlaW50ZXJwcmV0X2Nhc3Q8dm9pZCo+KHRo aXMpKTsKIAogICAgIEZvcm1EYXRhKiBodHRwQm9keSA9IGQtPm1fcmVxdWVzdC5odHRwQm9keSgp OwogICAgIGlmIChodHRwQm9keSAmJiAhaHR0cEJvZHktPmlzRW1wdHkoKSkgewpAQCAtNDg4LDcg KzQ4Myw3IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0cChTdHJpbmcgdXJsU3RyaW5n KQogICAgICAgICBpZiAobnVtRWxlbWVudHMgPCAyKSB7CiAgICAgICAgICAgICBWZWN0b3I8Y2hh cj4gYm9keTsKICAgICAgICAgICAgIGh0dHBCb2R5LT5mbGF0dGVuKGJvZHkpOwotICAgICAgICAg ICAgc291cF9tZXNzYWdlX3NldF9yZXF1ZXN0KG1zZywgZC0+bV9yZXF1ZXN0Lmh0dHBDb250ZW50 VHlwZSgpLnV0ZjgoKS5kYXRhKCksCisgICAgICAgICAgICBzb3VwX21lc3NhZ2Vfc2V0X3JlcXVl c3QoZC0+bV9tc2csIGQtPm1fcmVxdWVzdC5odHRwQ29udGVudFR5cGUoKS51dGY4KCkuZGF0YSgp LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFNPVVBfTUVNT1JZX0NPUFks IGJvZHkuZGF0YSgpLCBib2R5LnNpemUoKSk7CiAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAg ICAvKgpAQCAtNDk3LDEyICs0OTIsMTIgQEAgYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRIdHRw KFN0cmluZyB1cmxTdHJpbmcpCiAgICAgICAgICAgICAgKiBjb3B5aW5nIGludG8gbWVtb3J5OyBU T0RPOiBzdXBwb3J0IHVwbG9hZCBvZiBub24tbG9jYWwKICAgICAgICAgICAgICAqICh0aGluayBz ZnRwOi8vKSBmaWxlcyBieSB1c2luZyBHSU8/CiAgICAgICAgICAgICAgKi8KLSAgICAgICAgICAg IHNvdXBfbWVzc2FnZV9ib2R5X3NldF9hY2N1bXVsYXRlKG1zZy0+cmVxdWVzdF9ib2R5LCBGQUxT RSk7CisgICAgICAgICAgICBzb3VwX21lc3NhZ2VfYm9keV9zZXRfYWNjdW11bGF0ZShkLT5tX21z Zy0+cmVxdWVzdF9ib2R5LCBGQUxTRSk7CiAgICAgICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsg aSA8IG51bUVsZW1lbnRzOyBpKyspIHsKICAgICAgICAgICAgICAgICBjb25zdCBGb3JtRGF0YUVs ZW1lbnQmIGVsZW1lbnQgPSBodHRwQm9keS0+ZWxlbWVudHMoKVtpXTsKIAogICAgICAgICAgICAg ICAgIGlmIChlbGVtZW50Lm1fdHlwZSA9PSBGb3JtRGF0YUVsZW1lbnQ6OmRhdGEpCi0gICAgICAg ICAgICAgICAgICAgIHNvdXBfbWVzc2FnZV9ib2R5X2FwcGVuZChtc2ctPnJlcXVlc3RfYm9keSwg U09VUF9NRU1PUllfVEVNUE9SQVJZLCBlbGVtZW50Lm1fZGF0YS5kYXRhKCksIGVsZW1lbnQubV9k YXRhLnNpemUoKSk7CisgICAgICAgICAgICAgICAgICAgIHNvdXBfbWVzc2FnZV9ib2R5X2FwcGVu ZChkLT5tX21zZy0+cmVxdWVzdF9ib2R5LCBTT1VQX01FTU9SWV9URU1QT1JBUlksIGVsZW1lbnQu bV9kYXRhLmRhdGEoKSwgZWxlbWVudC5tX2RhdGEuc2l6ZSgpKTsKICAgICAgICAgICAgICAgICBl bHNlIHsKICAgICAgICAgICAgICAgICAgICAgLyoKICAgICAgICAgICAgICAgICAgICAgICogbWFw cGluZyBmb3IgdXBsb2FkZWQgZmlsZXMgY29kZSBpbnNwaXJlZCBieSB0ZWNobmlxdWUgdXNlZCBp bgpAQCAtNTE2LDI4ICs1MTEsMzEgQEAgYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRIdHRwKFN0 cmluZyB1cmxTdHJpbmcpCiAKICAgICAgICAgICAgICAgICAgICAgaWYgKGVycm9yKSB7CiAgICAg ICAgICAgICAgICAgICAgICAgICBSZXNvdXJjZUVycm9yIHJlc291cmNlRXJyb3IoZ19xdWFya190 b19zdHJpbmcoU09VUF9IVFRQX0VSUk9SKSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBtc2ctPnN0YXR1c19jb2RlLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGQtPm1fbXNnLT5zdGF0dXNfY29k ZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB1 cmxTdHJpbmcsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgU3RyaW5nOjpmcm9tVVRGOChlcnJvci0+bWVzc2FnZSkpOwogICAgICAgICAgICAgICAg ICAgICAgICAgZ19lcnJvcl9mcmVlKGVycm9yKTsKIAogICAgICAgICAgICAgICAgICAgICAgICAg ZC0+Y2xpZW50KCktPmRpZEZhaWwodGhpcywgcmVzb3VyY2VFcnJvcik7CiAKLSAgICAgICAgICAg ICAgICAgICAgICAgIGdfb2JqZWN0X3VucmVmKG1zZyk7CisgICAgICAgICAgICAgICAgICAgICAg ICBnX3NpZ25hbF9oYW5kbGVyc19kaXNjb25uZWN0X21hdGNoZWQoZC0+bV9tc2csIEdfU0lHTkFM X01BVENIX0RBVEEsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgMCwgMCwgMCwgMCwgdGhpcyk7CisgICAgICAgICAgICAgICAgICAg ICAgICBnX29iamVjdF91bnJlZihkLT5tX21zZyk7CisgICAgICAgICAgICAgICAgICAgICAgICBk LT5tX21zZyA9IDA7CisKICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKICAg ICAgICAgICAgICAgICAgICAgfQogCiAgICAgICAgICAgICAgICAgICAgIFNvdXBCdWZmZXIqIHNv dXBCdWZmZXIgPSBzb3VwX2J1ZmZlcl9uZXdfd2l0aF9vd25lcihnX21hcHBlZF9maWxlX2dldF9j b250ZW50cyhmaWxlTWFwcGluZyksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnX21hcHBlZF9maWxlX2dldF9s ZW5ndGgoZmlsZU1hcHBpbmcpLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZmlsZU1hcHBpbmcsIHJlaW50ZXJw cmV0X2Nhc3Q8R0Rlc3Ryb3lOb3RpZnk+KGdfbWFwcGVkX2ZpbGVfZnJlZSkpOwotICAgICAgICAg ICAgICAgICAgICBzb3VwX21lc3NhZ2VfYm9keV9hcHBlbmRfYnVmZmVyKG1zZy0+cmVxdWVzdF9i b2R5LCBzb3VwQnVmZmVyKTsKKyAgICAgICAgICAgICAgICAgICAgc291cF9tZXNzYWdlX2JvZHlf YXBwZW5kX2J1ZmZlcihkLT5tX21zZy0+cmVxdWVzdF9ib2R5LCBzb3VwQnVmZmVyKTsKICAgICAg ICAgICAgICAgICAgICAgc291cF9idWZmZXJfZnJlZShzb3VwQnVmZmVyKTsKICAgICAgICAgICAg ICAgICB9CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KICAgICB9CiAKLSAgICBkLT5tX21zZyA9 IHN0YXRpY19jYXN0PFNvdXBNZXNzYWdlKj4oZ19vYmplY3RfcmVmKG1zZykpOwogICAgIC8vIGJh bGFuY2VkIGJ5IGEgZGVyZWYoKSBpbiBmaW5pc2hlZENhbGxiYWNrLCB3aGljaCBzaG91bGQgYWx3 YXlzIHJ1bgogICAgIHJlZigpOwogCkBAIC01NDYsNiArNTQ0LDEyIEBAIGJvb2wgUmVzb3VyY2VI YW5kbGU6OnN0YXJ0SHR0cChTdHJpbmcgdXJsU3RyaW5nKQogICAgIC8vIGxpYnNvdXAgZ2V0cyBw cm9wZXIgQ29udGVudC1FbmNvZGluZyBzdXBwb3J0IHdlIHdpbGwgd2FudCB0bwogICAgIC8vIHVz ZSBpdCBoZXJlIGluc3RlYWQuCiAgICAgc291cF9tZXNzYWdlX2hlYWRlcnNfcmVwbGFjZShkLT5t X21zZy0+cmVxdWVzdF9oZWFkZXJzLCAiQWNjZXB0LUVuY29kaW5nIiwgImlkZW50aXR5Iik7CisK KyAgICAvLyBCYWxhbmNlZCBpbiBSZXNvdXJjZVJlcXVlc3QncyBkZXN0cnVjdG9yOyB3ZSBuZWVk IHRvIGtlZXAgb3VyCisgICAgLy8gb3duIHJlZiwgYmVjYXVzZSBhZnRlciBxdWV1ZWluZyB0aGUg bWVzc2FnZSwgdGhlIHNlc3Npb24gb3ducworICAgIC8vIHRoZSBpbml0aWFsIHJlZmVyZW5jZS4g V2UgY2Fubm90IHJlZiB0aGUgbWVzc2FnZSBpbgorICAgIC8vIFJlc291cmNlUmVxdWVzdCBiZWNh dXNlIG5vdCBhbGwgcmVxdWVzdCBvYmplY3RzIGFyZSBxdWV1ZWQuCisgICAgZ19vYmplY3RfcmVm KGQtPm1fbXNnKTsKICAgICBzb3VwX3Nlc3Npb25fcXVldWVfbWVzc2FnZShzZXNzaW9uLCBkLT5t X21zZywgZmluaXNoZWRDYWxsYmFjaywgdGhpcyk7CiAKICAgICByZXR1cm4gdHJ1ZTsKZGlmZiAt LWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVzdC5oIGIv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0LmgKaW5kZXggZWZi MTI0MC4uNjVjNDBjMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAv UmVzb3VyY2VSZXF1ZXN0LmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVz b3VyY2VSZXF1ZXN0LmgKQEAgLTI5LDM2ICsyOSw2NCBAQAogCiAjaW5jbHVkZSAiUmVzb3VyY2VS ZXF1ZXN0QmFzZS5oIgogCisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+CisKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIAogICAgIHN0cnVjdCBSZXNvdXJjZVJlcXVlc3QgOiBSZXNvdXJjZVJlcXVlc3RC YXNlIHsKIAogICAgICAgICBSZXNvdXJjZVJlcXVlc3QoY29uc3QgU3RyaW5nJiB1cmwpCiAgICAg ICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UoS1VSTCh1cmwpLCBVc2VQcm90b2NvbENhY2hl UG9saWN5KQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKDApCiAgICAgICAgIHsKICAgICAg ICAgfQogCiAgICAgICAgIFJlc291cmNlUmVxdWVzdChjb25zdCBLVVJMJiB1cmwpCiAgICAgICAg ICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UodXJsLCBVc2VQcm90b2NvbENhY2hlUG9saWN5KQor ICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKDApCiAgICAgICAgIHsKICAgICAgICAgfQogCiAg ICAgICAgIFJlc291cmNlUmVxdWVzdChjb25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmluZyYgcmVm ZXJyZXIsIFJlc291cmNlUmVxdWVzdENhY2hlUG9saWN5IHBvbGljeSA9IFVzZVByb3RvY29sQ2Fj aGVQb2xpY3kpCiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UodXJsLCBwb2xpY3kp CisgICAgICAgICAgICAsIG1fc291cE1lc3NhZ2UoMCkKICAgICAgICAgewogICAgICAgICAgICAg c2V0SFRUUFJlZmVycmVyKHJlZmVycmVyKTsKICAgICAgICAgfQogCiAgICAgICAgIFJlc291cmNl UmVxdWVzdCgpCiAgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UoS1VSTCgpLCBVc2VQ cm90b2NvbENhY2hlUG9saWN5KQorICAgICAgICAgICAgLCBtX3NvdXBNZXNzYWdlKDApCiAgICAg ICAgIHsKICAgICAgICAgfQogCisgICAgICAgIFJlc291cmNlUmVxdWVzdChTb3VwTWVzc2FnZSog c291cE1lc3NhZ2UpCisgICAgICAgICAgICA6IFJlc291cmNlUmVxdWVzdEJhc2UoKQorICAgICAg ICAgICAgLCBtX3NvdXBNZXNzYWdlKHNvdXBNZXNzYWdlKQorICAgICAgICB7CisgICAgICAgICAg ICBnX29iamVjdF9yZWYoc291cE1lc3NhZ2UpOworICAgICAgICB9CisKKyAgICAgICAgLy8gV2Ug Zm9yY2UgY29waWVzIG9mIFJlc291cmNlUmVxdWVzdCB0byBjcmVhdGUgdGhlaXIgb3duCisgICAg ICAgIC8vIFNvdXBNZXNzYWdlLCBpZiBuZWVkZWQuCisgICAgICAgIFJlc291cmNlUmVxdWVzdChj b25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCk7CisKKyAgICAgICAgflJlc291 cmNlUmVxdWVzdCgpCisgICAgICAgIHsKKyAgICAgICAgICAgIGlmIChtX3NvdXBNZXNzYWdlKSB7 CisgICAgICAgICAgICAgICAgZ19vYmplY3RfdW5yZWYobV9zb3VwTWVzc2FnZSk7CisgICAgICAg ICAgICAgICAgbV9zb3VwTWVzc2FnZSA9IDA7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKwor ICAgICAgICBTb3VwTWVzc2FnZSogc291cE1lc3NhZ2UoKSBjb25zdDsKKwogICAgIHByaXZhdGU6 CisgICAgICAgIFNvdXBNZXNzYWdlKiBtX3NvdXBNZXNzYWdlOwogICAgICAgICBmcmllbmQgY2xh c3MgUmVzb3VyY2VSZXF1ZXN0QmFzZTsKIAotICAgICAgICB2b2lkIGRvVXBkYXRlUGxhdGZvcm1S ZXF1ZXN0KCkge30KLSAgICAgICAgdm9pZCBkb1VwZGF0ZVJlc291cmNlUmVxdWVzdCgpIHt9Cisg ICAgICAgIHZvaWQgZG9VcGRhdGVQbGF0Zm9ybVJlcXVlc3QoKTsKKyAgICAgICAgdm9pZCBkb1Vw ZGF0ZVJlc291cmNlUmVxdWVzdCgpOwogICAgIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVz dFNvdXAuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0 U291cC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDQxMDVkYgotLS0g L2Rldi9udWxsCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVx dWVzdFNvdXAuY3BwCkBAIC0wLDAgKzEsMTM1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5 IEd1c3Rhdm8gTm9yb25oYSBTaWx2YQorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3 YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0 aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMg cHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVy c2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJz aW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0 IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0 IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQg aGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJ Qi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIElu Yy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEw LTEzMDEsIFVTQS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiUmVzb3Vy Y2VSZXF1ZXN0LmgiCisKKyNpbmNsdWRlICJDU3RyaW5nLmgiCisjaW5jbHVkZSAiR093blB0ci5o IgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisKKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAu aD4KKwordXNpbmcgbmFtZXNwYWNlIHN0ZDsKKworbmFtZXNwYWNlIFdURiB7CisKK3RlbXBsYXRl IDw+IHZvaWQgZnJlZU93bmVkR1B0cjxTb3VwVVJJPihTb3VwVVJJKiB1cmkpCit7CisgICAgaWYg KHVyaSkKKyAgICAgICAgc291cF91cmlfZnJlZSh1cmkpOworfQorCit9CisKK25hbWVzcGFjZSBX ZWJDb3JlIHsKKworU291cE1lc3NhZ2UqIFJlc291cmNlUmVxdWVzdDo6c291cE1lc3NhZ2UoKSBj b25zdAoreworICAgIHVwZGF0ZVBsYXRmb3JtUmVxdWVzdCgpOworCisgICAgcmV0dXJuIG1fc291 cE1lc3NhZ2U7Cit9CisKKy8vIEJhc2VkIG9uIFJlc291cmNlUmVxdWVzdEJhc2U6OmNvcHlEYXRh IGFuZCBSZXNvdXJjZVJlcXVlc3RCYXNlOjphZG9wdC4KK1Jlc291cmNlUmVxdWVzdDo6UmVzb3Vy Y2VSZXF1ZXN0KGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0KQorICAgIDog UmVzb3VyY2VSZXF1ZXN0QmFzZShyZXNvdXJjZVJlcXVlc3QpCisgICAgLCBtX3NvdXBNZXNzYWdl KDApCit7CisgICAgbV91cmwgPSByZXNvdXJjZVJlcXVlc3QudXJsKCkuY29weSgpOworICAgIG1f Zmlyc3RQYXJ0eUZvckNvb2tpZXMgPSByZXNvdXJjZVJlcXVlc3QuZmlyc3RQYXJ0eUZvckNvb2tp ZXMoKS5jb3B5KCk7CisgICAgbV9odHRwTWV0aG9kID0gcmVzb3VyY2VSZXF1ZXN0Lmh0dHBNZXRo b2QoKS5jb3B5KCk7CisgICAgbV9odHRwSGVhZGVyRmllbGRzLmFkb3B0KFBhc3NPd25QdHI8Q3Jv c3NUaHJlYWRIVFRQSGVhZGVyTWFwRGF0YT4ocmVzb3VyY2VSZXF1ZXN0Lm1faHR0cEhlYWRlckZp ZWxkcy5jb3B5RGF0YSgpLnJlbGVhc2UoKSkpOworCisgICAgc2l6ZV90IGVuY29kaW5nQ291bnQg PSByZXNvdXJjZVJlcXVlc3QubV9yZXNwb25zZUNvbnRlbnREaXNwb3NpdGlvbkVuY29kaW5nRmFs bGJhY2tBcnJheS5zaXplKCk7CisgICAgaWYgKGVuY29kaW5nQ291bnQgPiAwKSB7CisgICAgICAg IFN0cmluZyBlbmNvZGluZzEgPSByZXNvdXJjZVJlcXVlc3QubV9yZXNwb25zZUNvbnRlbnREaXNw b3NpdGlvbkVuY29kaW5nRmFsbGJhY2tBcnJheVswXTsKKyAgICAgICAgU3RyaW5nIGVuY29kaW5n MjsKKyAgICAgICAgU3RyaW5nIGVuY29kaW5nMzsKKyAgICAgICAgaWYgKGVuY29kaW5nQ291bnQg PiAxKSB7CisgICAgICAgICAgICBlbmNvZGluZzIgPSByZXNvdXJjZVJlcXVlc3QubV9yZXNwb25z ZUNvbnRlbnREaXNwb3NpdGlvbkVuY29kaW5nRmFsbGJhY2tBcnJheVsxXTsKKyAgICAgICAgICAg IGlmIChlbmNvZGluZ0NvdW50ID4gMikKKyAgICAgICAgICAgICAgICBlbmNvZGluZzMgPSByZXNv dXJjZVJlcXVlc3QubV9yZXNwb25zZUNvbnRlbnREaXNwb3NpdGlvbkVuY29kaW5nRmFsbGJhY2tB cnJheVsyXTsKKyAgICAgICAgfQorICAgICAgICBBU1NFUlQoZW5jb2RpbmdDb3VudCA8PSAzKTsK KyAgICAgICAgc2V0UmVzcG9uc2VDb250ZW50RGlzcG9zaXRpb25FbmNvZGluZ0ZhbGxiYWNrQXJy YXkoZW5jb2RpbmcxLCBlbmNvZGluZzIsIGVuY29kaW5nMyk7CisgICAgfQorICAgIGlmIChyZXNv dXJjZVJlcXVlc3QubV9odHRwQm9keSkKKyAgICAgICAgc2V0SFRUUEJvZHkocmVzb3VyY2VSZXF1 ZXN0Lmh0dHBCb2R5KCkpOworCisgICAgbV9yZXNvdXJjZVJlcXVlc3RVcGRhdGVkID0gdHJ1ZTsK KyAgICBtX3BsYXRmb3JtUmVxdWVzdFVwZGF0ZWQgPSBmYWxzZTsKK30KKwordm9pZCBSZXNvdXJj ZVJlcXVlc3Q6OmRvVXBkYXRlUmVzb3VyY2VSZXF1ZXN0KCkKK3sKKyAgICBpZiAoIW1fc291cE1l c3NhZ2UpCisgICAgICAgIHJldHVybjsKKworICAgIFNvdXBVUkkqIHNvdXBVUkkgPSBzb3VwX21l c3NhZ2VfZ2V0X3VyaShtX3NvdXBNZXNzYWdlKTsKKyAgICBHT3duUHRyPGdjaGFyPiB1cmkoc291 cF91cmlfdG9fc3RyaW5nKHNvdXBVUkksIEZBTFNFKSk7CisgICAgbV91cmwgPSBLVVJMKEtVUkwo KSwgU3RyaW5nOjpmcm9tVVRGOCh1cmkuZ2V0KCkpKTsKKworICAgIG1faHR0cE1ldGhvZCA9IFN0 cmluZzo6ZnJvbVVURjgobV9zb3VwTWVzc2FnZS0+bWV0aG9kKTsKKworICAgIFNvdXBNZXNzYWdl SGVhZGVyc0l0ZXIgaGVhZGVyc0l0ZXI7CisgICAgY29uc3QgY2hhciogaGVhZGVyTmFtZTsKKyAg ICBjb25zdCBjaGFyKiBoZWFkZXJWYWx1ZTsKKworICAgIHNvdXBfbWVzc2FnZV9oZWFkZXJzX2l0 ZXJfaW5pdCgmaGVhZGVyc0l0ZXIsIG1fc291cE1lc3NhZ2UtPnJlcXVlc3RfaGVhZGVycyk7Cisg ICAgd2hpbGUgKHNvdXBfbWVzc2FnZV9oZWFkZXJzX2l0ZXJfbmV4dCgmaGVhZGVyc0l0ZXIsICZo ZWFkZXJOYW1lLCAmaGVhZGVyVmFsdWUpKQorICAgICAgICBtX2h0dHBIZWFkZXJGaWVsZHMuc2V0 KFN0cmluZzo6ZnJvbVVURjgoaGVhZGVyTmFtZSksIFN0cmluZzo6ZnJvbVVURjgoaGVhZGVyVmFs dWUpKTsKKworICAgIG1faHR0cEJvZHkgPSBGb3JtRGF0YTo6Y3JlYXRlKG1fc291cE1lc3NhZ2Ut PnJlcXVlc3RfYm9keS0+ZGF0YSwgbV9zb3VwTWVzc2FnZS0+cmVxdWVzdF9ib2R5LT5sZW5ndGgp OworCisgICAgLy8gRklYTUU6IG1fYWxsb3dIVFRQQ29va2llcyBhbmQgbV9maXJzdFBhcnR5Rm9y Q29va2llcyBzaG91bGQKKyAgICAvLyBwcm9iYWJseSBiZSBoYW5kbGVkIGhlcmUgYW5kIG9uIGRv VXBkYXRlUGxhdGZvcm1SZXF1ZXN0CisgICAgLy8gc29tZWhvdy4KK30KKwordm9pZCBSZXNvdXJj ZVJlcXVlc3Q6OmRvVXBkYXRlUGxhdGZvcm1SZXF1ZXN0KCkKK3sKKyAgICBHT3duUHRyPFNvdXBV Ukk+IHNvdXBVUkkoc291cF91cmlfbmV3KHVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpKTsK KyAgICBBU1NFUlQoc291cFVSSSk7CisKKyAgICBpZiAoIW1fc291cE1lc3NhZ2UpIHsKKyAgICAg ICAgbV9zb3VwTWVzc2FnZSA9IHNvdXBfbWVzc2FnZV9uZXdfZnJvbV91cmkoaHR0cE1ldGhvZCgp LnV0ZjgoKS5kYXRhKCksIHNvdXBVUkkuZ2V0KCkpOworICAgIH0gZWxzZSB7CisgICAgICAgIHNv dXBfbWVzc2FnZV9zZXRfdXJpKG1fc291cE1lc3NhZ2UsIHNvdXBVUkkuZ2V0KCkpOworCisgICAg ICAgIGdfb2JqZWN0X3NldChtX3NvdXBNZXNzYWdlLCAibWV0aG9kIiwgaHR0cE1ldGhvZCgpLnV0 ZjgoKS5kYXRhKCksIE5VTEwpOworICAgICAgICBzb3VwX21lc3NhZ2VfaGVhZGVyc19jbGVhciht X3NvdXBNZXNzYWdlLT5yZXF1ZXN0X2hlYWRlcnMpOworICAgIH0KKworICAgIEFTU0VSVChtX3Nv dXBNZXNzYWdlKTsKKworICAgIEhUVFBIZWFkZXJNYXAgaGVhZGVycyA9IGh0dHBIZWFkZXJGaWVs ZHMoKTsKKyAgICBTb3VwTWVzc2FnZUhlYWRlcnMqIHNvdXBIZWFkZXJzID0gbV9zb3VwTWVzc2Fn ZS0+cmVxdWVzdF9oZWFkZXJzOworICAgIGlmICghaGVhZGVycy5pc0VtcHR5KCkpIHsKKyAgICAg ICAgSFRUUEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgZW5kID0gaGVhZGVycy5lbmQoKTsKKyAg ICAgICAgZm9yIChIVFRQSGVhZGVyTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IGhlYWRlcnMuYmVn aW4oKTsgaXQgIT0gZW5kOyArK2l0KQorICAgICAgICAgICAgc291cF9tZXNzYWdlX2hlYWRlcnNf YXBwZW5kKHNvdXBIZWFkZXJzLCBpdC0+Zmlyc3Quc3RyaW5nKCkudXRmOCgpLmRhdGEoKSwgaXQt PnNlY29uZC51dGY4KCkuZGF0YSgpKTsKKyAgICB9CisKKyAgICAvLyBCb2R5IGRhdGEgaXMgb25s eSBoYW5kbGVkIGF0IFJlc291cmNlSGFuZGxlU291cDo6c3RhcnRIdHRwIGZvcgorICAgIC8vIG5v dzsgdGhpcyBpcyBiZWNhdXNlIHRoaXMgbWF5IG5vdCBiZSBhIGdvb2QgcGxhY2UgdG8gZ28KKyAg ICAvLyBvcGVubmluZyBhbmQgbW1hcHBpbmcgZmlsZXMuIFdlIHNob3VsZCBtYXliZSByZXZpc2l0 IHRoaXMuCit9CisKK30KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIvV2ViS2l0 L2d0ay9DaGFuZ2VMb2cKaW5kZXggZDAwOGRhMC4uOGYxNWE1MyAxMDA2NDQKLS0tIGEvV2ViS2l0 L2d0ay9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNyBA QAorMjAwOS0wNS0yNCAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBNYWtlIE5ldHdv cmtSZXF1ZXN0IGNhcnJ5IGEgcmVmZXJlbmNlIG9mIHRoZSBTb3VwTWVzc2FnZSB1c2VkIGJ5Cisg ICAgICAgIFJlc291cmNlUmVxdWVzdCwgYW5kIHVzZSB0aGF0IHRvIGNyZWF0ZSBuZXcgUmVzb3Vy Y2VSZXF1ZXN0cyB3aGVyZQorICAgICAgICBuZWVkZWQsIHNvIHRoYXQgbm8gaW5mb3JtYXRpb24g aXMgbG9zdCB3aGlsZSBwYXNzaW5nIGFyb3VuZAorICAgICAgICBOZXR3b3JrUmVxdWVzdCBvYmpl Y3RzLgorCisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3Bw OgorICAgICAgICAoV2ViS2l0OjpGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEZWNpZGVQb2xp Y3lGb3JNSU1FVHlwZSk6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50OjpkaXNw YXRjaERlY2lkZVBvbGljeUZvck5hdmlnYXRpb25BY3Rpb24pOgorICAgICAgICAoV2ViS2l0OjpG cmFtZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9hZCk6CisgICAgICAgICogd2Via2l0L3dlYmtp dGRvd25sb2FkLmNwcDoKKyAgICAgICAgKHdlYmtpdF9kb3dubG9hZF9zdGFydCk6CisgICAgICAg ICogd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcDoKKyAgICAgICAgKHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfZmluYWxpemUpOgorICAgICAgICAod2Via2l0X25ldHdvcmtfcmVxdWVzdF9u ZXdfd2l0aF9jb3JlX3JlcXVlc3QpOgorICAgICAgICAod2Via2l0X25ldHdvcmtfcmVxdWVzdF9u ZXcpOgorICAgICAgICAod2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWVzc2FnZSk6CisgICAg ICAgICogd2Via2l0L3dlYmtpdHByaXZhdGUuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2Vi ZnJhbWUuY3BwOgorICAgICAgICAod2Via2l0X3dlYl9mcmFtZV9sb2FkX3JlcXVlc3QpOgorCiAy MDA5LTA1LTI4ICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxndXN0YXZvLm5vcm9uaGFAY29sbGFi b3JhLmNvLnVrPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFhhbiBMb3Blei4KZGlmZiAtLWdpdCBh L1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwIGIvV2Vi S2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAKaW5kZXggZGU4 YTdiMy4uZDQ3YWRkYiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudEd0ay5jcHAKKysrIGIvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudEd0ay5jcHAKQEAgLTMxMSw3ICszMTEsNyBAQCB2b2lkIEZyYW1lTG9hZGVy Q2xpZW50OjpkaXNwYXRjaERlY2lkZVBvbGljeUZvck1JTUVUeXBlKEZyYW1lUG9saWN5RnVuY3Rp b24gcG9saQogICAgIH0KIAogICAgIFdlYktpdFdlYlZpZXcqIHBhZ2UgPSBnZXRWaWV3RnJvbUZy YW1lKG1fZnJhbWUpOwotICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0 X25ldHdvcmtfcmVxdWVzdF9uZXcocmVzb3VyY2VSZXF1ZXN0LnVybCgpLnN0cmluZygpLnV0Zjgo KS5kYXRhKCkpOworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0ID0gd2Via2l0X25l dHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3JlX3JlcXVlc3QocmVzb3VyY2VSZXF1ZXN0KTsKIAog ICAgIFdlYktpdFdlYlBvbGljeURlY2lzaW9uKiBwb2xpY3lEZWNpc2lvbiA9IHdlYmtpdF93ZWJf cG9saWN5X2RlY2lzaW9uX25ldyhtX2ZyYW1lLCBwb2xpY3lGdW5jdGlvbik7CiAgICAgaWYgKG1f cG9saWN5RGVjaXNpb24pCkBAIC00MTAsNyArNDEwLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVu dDo6ZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JOYXZpZ2F0aW9uQWN0aW9uKEZyYW1lUG9saWN5RnVu Y3QKICAgICB9CiAKICAgICBXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3ID0gZ2V0Vmlld0Zyb21GcmFt ZShtX2ZyYW1lKTsKLSAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdlYmtpdF9u ZXR3b3JrX3JlcXVlc3RfbmV3KHJlc291cmNlUmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCku ZGF0YSgpKTsKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9IHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0KHJlc291cmNlUmVxdWVzdCk7CiAgICAg V2ViS2l0TmF2aWdhdGlvblJlc3BvbnNlIHJlc3BvbnNlOwogICAgIC8qCiAgICAgICogV2Ugc3Rp bGwgc3VwcG9ydCB0aGUgZGVwcmVjYXRlZCBuYXZpZ2F0aW9uLXJlcXVlc3RlZCBzaWduYWwsIGlm IHRoZQpAQCAtMTAzMSw3ICsxMDMxLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6c2V0TWFp bkRvY3VtZW50RXJyb3IoRG9jdW1lbnRMb2FkZXIqLCBjb25zdCBSZXNvdXJjZUVycm8KIAogdm9p ZCBGcmFtZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3Qm IHJlcXVlc3QpCiB7Ci0gICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIG5ldHdvcmtSZXF1ZXN0ID0g d2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXcocmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCku ZGF0YSgpKTsKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogbmV0d29ya1JlcXVlc3QgPSB3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2NvcmVfcmVxdWVzdChyZXF1ZXN0KTsKICAgICBX ZWJLaXRXZWJWaWV3KiB2aWV3ID0gZ2V0Vmlld0Zyb21GcmFtZShtX2ZyYW1lKTsKIAogICAgIHdl YmtpdF93ZWJfdmlld19yZXF1ZXN0X2Rvd25sb2FkKHZpZXcsIG5ldHdvcmtSZXF1ZXN0KTsKZGlm ZiAtLWdpdCBhL1dlYktpdC9ndGsvdGVzdHMvdGVzdGh0dHBiYWNrZW5kLmMgYi9XZWJLaXQvZ3Rr L3Rlc3RzL3Rlc3RodHRwYmFja2VuZC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLmRjMWE4YjUKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXQvZ3RrL3Rlc3RzL3Rlc3RodHRw YmFja2VuZC5jCkBAIC0wLDAgKzEsMTIxIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IEd1 c3Rhdm8gTm9yb25oYSBTaWx2YQorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1 Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNp b24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lv bi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBp dCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBl dmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBo YXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJ Qi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIElu Yy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEw LTEzMDEsIFVTQS4KKyAqLworCisjaW5jbHVkZSA8ZXJybm8uaD4KKyNpbmNsdWRlIDx1bmlzdGQu aD4KKyNpbmNsdWRlIDxnbGliLmg+CisjaW5jbHVkZSA8Z2xpYi9nc3RkaW8uaD4KKyNpbmNsdWRl IDxndGsvZ3RrLmg+CisjaW5jbHVkZSA8d2Via2l0L3dlYmtpdC5oPgorCisjaWYgR0xJQl9DSEVD S19WRVJTSU9OKDIsIDE2LCAwKSAmJiBHVEtfQ0hFQ0tfVkVSU0lPTigyLCAxNCwgMCkKKworU291 cE1lc3NhZ2UqIG1lc3NhZ2U7CisKKy8vIE5vdCB5ZXQgcHVibGljIEFQSQorU291cE1lc3NhZ2Uq IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X21lc3NhZ2UoV2ViS2l0TmV0d29ya1JlcXVlc3Qq IHJlcXVlc3QpOworCitzdGF0aWMgZ2Jvb2xlYW4gbmF2aWdhdGlvbl9wb2xpY3lfZGVjaXNpb25f cmVxdWVzdGVkX2NiKFdlYktpdFdlYlZpZXcqIHdlYl92aWV3LAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXZWJLaXRXZWJGcmFtZSogd2Vi X2ZyYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV2ViS2l0V2ViTmF2aWdhdGlv bkFjdGlvbiBhY3Rpb24sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGdwb2ludGVyIGRhdGEpCit7CisgICAgbWVzc2FnZSA9IHdlYmtpdF9u ZXR3b3JrX3JlcXVlc3RfZ2V0X21lc3NhZ2UocmVxdWVzdCk7CisKKyAgICAvKiAxIC0+IHNvdXBf bWVzc2FnZV9uZXdfZnJvbV91cmkKKyAgICAgKiAyIC0+IGdfb2JqZWN0X3JlZgorICAgICAqIDMg LT4gd2Via2l0X25ldHdvcmtfcmVxdWVzdF93aXRoX2NvcmVfcmVxdWVzdAorICAgICAqCisgICAg ICogMSwgYW5kIDIgYXJlIGNhdXNlZCBieSB0aGUgY3JlYXRpb24gb2YgdGhlIFJlc291cmNlUmVx dWVzdAorICAgICAqIG9iamVjdDsgMyBpcyBjYXVzZWQgYnkgdGhlIGVtaXNzaW9uIG9mIHRoaXMg c2lnbmFsIQorICAgICAqLworICAgIGdfYXNzZXJ0X2NtcGludChHX09CSkVDVChtZXNzYWdlKS0+ cmVmX2NvdW50LCA9PSwgMik7CisKKyAgICByZXR1cm4gRkFMU0U7Cit9CisKK3N0YXRpYyB2b2lk IGxvYWRfZmluaXNoZWRfY2IoV2ViS2l0V2ViVmlldyogd2ViX3ZpZXcsIFdlYktpdFdlYkZyYW1l KiB3ZWJfZnJhbWUsIEdNYWluTG9vcCogbG9vcCkKK3sKKyAgICAvKiAxIC0+IFJlc291cmNlUmVx dWVzdCdzCisgICAgICogMiAtPiBSZXNvdXJjZUhhbmRsZSdzIChyZWYgaW4gc3RhcnRIdHRwKQor ICAgICAqCisgICAgICogQXQgdGhpcyBwb2ludCwgYWx0aG91Z2ggdGhlIFNvdXBTZXNzaW9uIGRy b3BwZWQgaXRzIHJlZmVyZW5jZSwKKyAgICAgKiBSZXNvdXJjZUhhbmRsZSBpcyBzdGlsbCB0aGVy ZSwgYXMgaXMgdGhlIFJlc291cmNlUmVxdWVzdCwgc28gd2UKKyAgICAgKiBzdGlsbCBoYXZlIDIu CisgICAgICovCisgICAgZ19hc3NlcnRfY21waW50KEdfT0JKRUNUKG1lc3NhZ2UpLT5yZWZfY291 bnQsID09LCAxKTsKKyAgICBnX21haW5fbG9vcF9xdWl0KGxvb3ApOworfQorCitzdGF0aWMgdm9p ZCB0ZXN0X3NvdXBfbWVzc2FnZV9saWZldGltZSgpCit7CisgICAgR01haW5Mb29wKiBsb29wID0g Z19tYWluX2xvb3BfbmV3KE5VTEwsIEZBTFNFKTsKKyAgICBXZWJLaXRXZWJWaWV3KiB3ZWJfdmll dyA9IFdFQktJVF9XRUJfVklFVyh3ZWJraXRfd2ViX3ZpZXdfbmV3KCkpOworCisgICAgZ19vYmpl Y3RfcmVmX3Npbmsod2ViX3ZpZXcpOworCisgICAgZ19zaWduYWxfY29ubmVjdCh3ZWJfdmlldywg Im5hdmlnYXRpb24tcG9saWN5LWRlY2lzaW9uLXJlcXVlc3RlZCIsCisgICAgICAgICAgICAgICAg ICAgICBHX0NBTExCQUNLKG5hdmlnYXRpb25fcG9saWN5X2RlY2lzaW9uX3JlcXVlc3RlZF9jYiks CisgICAgICAgICAgICAgICAgICAgICBOVUxMKTsKKworICAgIGdfc2lnbmFsX2Nvbm5lY3Qod2Vi X3ZpZXcsICJsb2FkLWZpbmlzaGVkIiwKKyAgICAgICAgICAgICAgICAgICAgIEdfQ0FMTEJBQ0so bG9hZF9maW5pc2hlZF9jYiksCisgICAgICAgICAgICAgICAgICAgICBsb29wKTsKKworICAgIC8q IGxvYWRfdXJpIHdpbGwgdHJpZ2dlciB0aGUgbmF2aWdhdGlvbi1wb2xpY3ktZGVjaXNpb24tcmVx dWVzdGVkCisgICAgICogc2lnbmFsIGVtaXNzaW9uOworICAgICAqLworICAgIHdlYmtpdF93ZWJf dmlld19sb2FkX3VyaSh3ZWJfdmlldywgImh0dHA6Ly8xMjcuMC4wLjEvIik7CisKKyAgICAvKiB0 byB3YWl0IGZvciBsb2FkLWZpbmlzaGVkICovCisgICAgZ19tYWluX2xvb3BfcnVuKGxvb3ApOwor CisgICAgLyoga2VlcCBvdXIgb3duIHJlZmVyZW5jZSAyLT4zICovCisgICAgZ19vYmplY3RfcmVm KG1lc3NhZ2UpOworICAgIGdfYXNzZXJ0X2NtcGludChHX09CSkVDVChtZXNzYWdlKS0+cmVmX2Nv dW50LCA9PSwgMik7CisKKyAgICAvKiB0aGlzIHNob3VsZCBtYWtlIHRoZSBSZXNvdXJjZUhhbmRs ZSBhbmQgUmVzb3VyY2VSZXF1ZXN0IGdvCisgICAgICogYXdheSwgc28gd2Ugd2lsbCBnbyBkb3du IHRvIDEKKyAgICAgKi8KKyAgICB3ZWJraXRfd2ViX3ZpZXdfbG9hZF91cmkod2ViX3ZpZXcsICJh Ym91dDpibGFuayIpOworICAgIGdfb2JqZWN0X3VucmVmKHdlYl92aWV3KTsKKworICAgIGdfYXNz ZXJ0X2NtcGludChHX09CSkVDVChtZXNzYWdlKS0+cmVmX2NvdW50LCA9PSwgMSk7CisgICAgZ19v YmplY3RfdW5yZWYobWVzc2FnZSk7Cit9CisKK2ludCBtYWluKGludCBhcmdjLCBjaGFyKiogYXJn dikKK3sKKyAgICBnX3RocmVhZF9pbml0KE5VTEwpOworICAgIGd0a190ZXN0X2luaXQoJmFyZ2Ms ICZhcmd2LCBOVUxMKTsKKworICAgIGdfdGVzdF9idWdfYmFzZSgiaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvIik7CisgICAgZ190ZXN0X2FkZF9mdW5jKCIvd2Via2l0L3NvdXBtZXNzYWdlL2xpZmV0 aW1lIiwgdGVzdF9zb3VwX21lc3NhZ2VfbGlmZXRpbWUpOworICAgIHJldHVybiBnX3Rlc3RfcnVu ICgpOworfQorCisjZWxzZQoraW50IG1haW4oaW50IGFyZ2MsIGNoYXIqKiBhcmd2KQoreworICAg IGdfY3JpdGljYWwoIllvdSB3aWxsIG5lZWQgYXQgbGVhc3QgZ2xpYi0yLjE2LjAgYW5kIGd0ay0y LjE0LjAgdG8gcnVuIHRoZSB1bml0IHRlc3RzLiBEb2luZyBub3RoaW5nIG5vdy4iKTsKKyAgICBy ZXR1cm4gMDsKK30KKworI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXRkb3dubG9hZC5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRkb3dubG9hZC5jcHAKaW5k ZXggYTI5OTg4My4uYmZkMDAyZiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 ZG93bmxvYWQuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRvd25sb2FkLmNwcApA QCAtNDIxLDExICs0MjEsOCBAQCB2b2lkIHdlYmtpdF9kb3dubG9hZF9zdGFydChXZWJLaXREb3du bG9hZCogZG93bmxvYWQpCiAKICAgICBpZiAocHJpdi0+cmVzb3VyY2VIYW5kbGUpCiAgICAgICAg IHByaXYtPnJlc291cmNlSGFuZGxlLT5zZXRDbGllbnQocHJpdi0+ZG93bmxvYWRDbGllbnQpOwot ICAgIGVsc2UgewotICAgICAgICAvLyBGSVhNRTogVXNlIHRoZSBhY3R1YWwgcmVxdWVzdCBvYmpl Y3Qgd2hlbiBXZWJLaXROZXR3b3JrUmVxdWVzdCBpcyBmaW5pc2hlZC4KLSAgICAgICAgUmVzb3Vy Y2VSZXF1ZXN0IHJlcXVlc3Qod2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJpKHByaXYtPm5l dHdvcmtSZXF1ZXN0KSk7Ci0gICAgICAgIHByaXYtPnJlc291cmNlSGFuZGxlID0gUmVzb3VyY2VI YW5kbGU6OmNyZWF0ZShyZXF1ZXN0LCBwcml2LT5kb3dubG9hZENsaWVudCwgMCwgZmFsc2UsIGZh bHNlLCBmYWxzZSk7Ci0gICAgfQorICAgIGVsc2UKKyAgICAgICAgcHJpdi0+cmVzb3VyY2VIYW5k bGUgPSBSZXNvdXJjZUhhbmRsZTo6Y3JlYXRlKFJlc291cmNlUmVxdWVzdCh3ZWJraXRfbmV0d29y a19yZXF1ZXN0X2dldF9tZXNzYWdlKHByaXYtPm5ldHdvcmtSZXF1ZXN0KSksIHByaXYtPmRvd25s b2FkQ2xpZW50LCAwLCBmYWxzZSwgZmFsc2UsIGZhbHNlKTsKIAogICAgIHByaXYtPnRpbWVyID0g Z190aW1lcl9uZXcoKTsKICAgICB3ZWJraXRfZG93bmxvYWRfb3Blbl9zdHJlYW1fZm9yX3VyaShk b3dubG9hZCwgcHJpdi0+ZGVzdGluYXRpb25VUkkpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 bmV0d29ya3JlcXVlc3QuY3BwCmluZGV4IDJjNGU5MjYuLmZlZWYzZWMgMTAwNjQ0Ci0tLSBhL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcAorKysgYi9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKQEAgLTEsNSArMSw2IEBACiAvKgogICog Q29weXJpZ2h0IChDKSAyMDA3LCAyMDA4IEhvbGdlciBIYW5zIFBldGVyIEZyZXl0aGVyCisgKiBD b3B5cmlnaHQgKEMpIDIwMDkgR3VzdGF2byBOb3JvbmhhIFNpbHZhCiAgKgogICogVGhpcyBsaWJy YXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICog bW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJs aWMKQEAgLTE4LDkgKzE5LDEyIEBACiAgKi8KIAogI2luY2x1ZGUgImNvbmZpZy5oIgotCiAjaW5j bHVkZSAid2Via2l0bmV0d29ya3JlcXVlc3QuaCIKIAorI2luY2x1ZGUgIkNTdHJpbmcuaCIKKyNp bmNsdWRlICJSZXNvdXJjZVJlcXVlc3QuaCIKKyNpbmNsdWRlICJ3ZWJraXRwcml2YXRlLmgiCisK IC8qKgogICogU0VDVElPTjp3ZWJraXRuZXR3b3JrcmVxdWVzdAogICogQHNob3J0X2Rlc2NyaXB0 aW9uOiBUaGUgdGFyZ2V0IG9mIGEgbmF2aWdhdGlvbiByZXF1ZXN0CkBAIC0zOCw2ICs0Miw3IEBA IEdfREVGSU5FX1RZUEUoV2ViS2l0TmV0d29ya1JlcXVlc3QsIHdlYmtpdF9uZXR3b3JrX3JlcXVl c3QsIEdfVFlQRV9PQkpFQ1QpOwogCiBzdHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0 ZSB7CiAgICAgZ2NoYXIqIHVyaTsKKyAgICBTb3VwTWVzc2FnZSogbWVzc2FnZTsKIH07CiAKICNk ZWZpbmUgV0VCS0lUX05FVFdPUktfUkVRVUVTVF9HRVRfUFJJVkFURShvYmopIChHX1RZUEVfSU5T VEFOQ0VfR0VUX1BSSVZBVEUoKG9iaiksIFdFQktJVF9UWVBFX05FVFdPUktfUkVRVUVTVCwgV2Vi S2l0TmV0d29ya1JlcXVlc3RQcml2YXRlKSkKQEAgLTQ5LDYgKzU0LDExIEBAIHN0YXRpYyB2b2lk IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZmluYWxpemUoR09iamVjdCogb2JqZWN0KQogCiAgICAg Z19mcmVlKHByaXYtPnVyaSk7CiAKKyAgICBpZiAocHJpdi0+bWVzc2FnZSkgeworICAgICAgICBn X29iamVjdF91bnJlZihwcml2LT5tZXNzYWdlKTsKKyAgICAgICAgcHJpdi0+bWVzc2FnZSA9IE5V TEw7CisgICAgfQorCiAgICAgR19PQkpFQ1RfQ0xBU1Mod2Via2l0X25ldHdvcmtfcmVxdWVzdF9w YXJlbnRfY2xhc3MpLT5maW5hbGl6ZShvYmplY3QpOwogfQogCkBAIC02NSwxMyArNzUsMjggQEAg c3RhdGljIHZvaWQgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9pbml0KFdlYktpdE5ldHdvcmtSZXF1 ZXN0KiByZXF1ZXN0KQogICAgIHJlcXVlc3QtPnByaXYgPSBwcml2OwogfQogCisvLyBmb3IgaW50 ZXJuYWwgdXNlIG9ubHkKK1dlYktpdE5ldHdvcmtSZXF1ZXN0KiB3ZWJraXRfbmV0d29ya19yZXF1 ZXN0X25ld193aXRoX2NvcmVfcmVxdWVzdChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3Qm IHJlc291cmNlUmVxdWVzdCkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCA9 IFdFQktJVF9ORVRXT1JLX1JFUVVFU1QoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX05FVFdPUktf UkVRVUVTVCwgTlVMTCkpOworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0UHJpdmF0ZSogcHJpdiA9 IHJlcXVlc3QtPnByaXY7CisKKyAgICBTb3VwTWVzc2FnZSogc291cE1lc3NhZ2UgPSByZXNvdXJj ZVJlcXVlc3Quc291cE1lc3NhZ2UoKTsKKyAgICBpZiAoc291cE1lc3NhZ2UpCisgICAgICAgIHBy aXYtPm1lc3NhZ2UgPSBTT1VQX01FU1NBR0UoZ19vYmplY3RfcmVmKHNvdXBNZXNzYWdlKSk7Cisg ICAgcHJpdi0+dXJpID0gZ19zdHJkdXAocmVzb3VyY2VSZXF1ZXN0LnVybCgpLnN0cmluZygpLnV0 ZjgoKS5kYXRhKCkpOworCisgICAgcmV0dXJuIHJlcXVlc3Q7Cit9CisKIC8qKgogICogd2Via2l0 X25ldHdvcmtfcmVxdWVzdF9uZXc6CiAgKiBAdXJpOiBhbiBVUkkKICAqCiAgKiBDcmVhdGVzIGEg bmV3ICNXZWJLaXROZXR3b3JrUmVxdWVzdCBpbml0aWFsaXplZCB3aXRoIGFuIFVSSS4KICAqCi0g KiBSZXR1cm5zOiBhIG5ldyAjV2ViS2l0TmV0d29ya1JlcXVlc3QKKyAqIFJldHVybnM6IGEgbmV3 ICNXZWJLaXROZXR3b3JrUmVxdWVzdCwgb3IgJU5VTEwgaWYgdGhlIFVSSSBpcworICogaW52YWxp ZC4KICAqLwogV2ViS2l0TmV0d29ya1JlcXVlc3QqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3 KGNvbnN0IGdjaGFyKiB1cmkpCiB7CkBAIC04MCw2ICsxMDUsMTAgQEAgV2ViS2l0TmV0d29ya1Jl cXVlc3QqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3KGNvbnN0IGdjaGFyKiB1cmkpCiAgICAg V2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QgPSBXRUJLSVRfTkVUV09SS19SRVFVRVNUKGdf b2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsIE5VTEwpKTsKICAgICBXZWJL aXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OwogCisgICAgcHJp di0+bWVzc2FnZSA9IHNvdXBfbWVzc2FnZV9uZXcoIkdFVCIsIHVyaSk7CisgICAgaWYgKCFwcml2 LT5tZXNzYWdlKQorICAgICAgICByZXR1cm4gTlVMTDsKKwogICAgIHByaXYtPnVyaSA9IGdfc3Ry ZHVwKHVyaSk7CiAKICAgICByZXR1cm4gcmVxdWVzdDsKQEAgLTExOCwzICsxNDcsMjEgQEAgR19D T05TVF9SRVRVUk4gZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShXZWJLaXRO ZXR3b3JrUmVxdWVzdCogcmVxdWUKICAgICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHBy aXYgPSByZXF1ZXN0LT5wcml2OwogICAgIHJldHVybiBwcml2LT51cmk7CiB9CisKKy8vIE5PVCBZ RVQgQVBJOyBGb3IgaW50ZXJuYWwgdXNlIG9ubHksIGZvciBub3cKKy8vIHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfZ2V0X3NvdXBfbWVzc2FnZToKKy8vIEByZXF1ZXN0OiBhICNXZWJLaXROZXR3b3Jr UmVxdWVzdAorLy8KKy8vIE9idGFpbnMgdGhlICNTb3VwTWVzc2FnZSBoZWxkIGFuZCB1c2VkIGJ5 IHRoZSBnaXZlbiByZXF1ZXN0LiBOb3RpY2UKKy8vIHRoYXQgbW9kaWZpY2F0aW9uIG9mIHRoZSBT b3VwTWVzc2FnZSBvZiBhIHJlcXVlc3QgYnkgc2lnbmFsCisvLyBoYW5kbGVycyBpcyBvbmx5IHN1 cHBvcnRlZCB3aGVyZSBleHBsaWNpdGx5IGRvY3VtZW50ZWQuCisvLworLy8gUmV0dXJuczogdGhl ICNTb3VwTWVzc2FnZQorU291cE1lc3NhZ2UqIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X21l c3NhZ2UoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpCit7CisgICAgZ19yZXR1cm5fdmFs X2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVRVUVTVChyZXF1ZXN0KSwgTlVMTCk7CisKKyAg ICBXZWJLaXROZXR3b3JrUmVxdWVzdFByaXZhdGUqIHByaXYgPSByZXF1ZXN0LT5wcml2OworCisg ICAgcmV0dXJuIHByaXYtPm1lc3NhZ2U7Cit9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKaW5k ZXggMjY5MjRkYy4uNWI3NTUzNyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaApAQCAtMjMs NyArMjMsOCBAQAogI2RlZmluZSBXRUJLSVRfUFJJVkFURV9ICiAKIC8qCi0gKiBUaGlzIGZpbGUg a25vd3MgdGhlIHNoYXJlZCBzZWNyZXQgb2YgV2ViS2l0V2ViVmlldyBhbmQgV2ViS2l0V2ViRnJh bWUuCisgKiBUaGlzIGZpbGUga25vd3MgdGhlIHNoYXJlZCBzZWNyZXQgb2YgV2ViS2l0V2ViVmll dywgV2ViS2l0V2ViRnJhbWUsCisgKiBhbmQgV2ViS2l0TmV0d29ya1JlcXVlc3QuCiAgKiBUaGV5 IGFyZSB1c2luZyBXZWJDb3JlIHdoaWNoIG11c24ndCBiZSBleHBvc2VkIHRvIHRoZSBvdXRlciB3 b3JsZC4KICAqLwogCkBAIC0zNyw2ICszOCw3IEBACiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdl YnNldHRpbmdzLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYndpbmRvd2ZlYXR1cmVzLmg+ CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYmJhY2tmb3J3YXJkbGlzdC5oPgorI2luY2x1ZGUg PHdlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oPgogCiAjaW5jbHVkZSAiQmFja0ZvcndhcmRM aXN0LmgiCiAjaW5jbHVkZSA8ZW5jaGFudC5oPgpAQCAtNDcsMTAgKzQ5LDEyIEBACiAjaW5jbHVk ZSAiSW5zcGVjdG9yQ2xpZW50R3RrLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkZXJDbGllbnQuaCIK ICNpbmNsdWRlICJSZXNvdXJjZUhhbmRsZS5oIgorI2luY2x1ZGUgIlJlc291cmNlUmVxdWVzdC5o IgogI2luY2x1ZGUgIlJlc291cmNlUmVzcG9uc2UuaCIKICNpbmNsdWRlICJXaW5kb3dGZWF0dXJl cy5oIgogCiAjaW5jbHVkZSA8Z2xpYi5oPgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgogCiBj bGFzcyBEb3dubG9hZENsaWVudDsKIApAQCAtMTgwLDYgKzE4NCwxMyBAQCBleHRlcm4gIkMiIHsK ICAgICB2b2lkCiAgICAgd2Via2l0X3dlYl9wb2xpY3lfZGVjaXNpb25fY2FuY2VsIChXZWJLaXRX ZWJQb2xpY3lEZWNpc2lvbiogZGVjaXNpb24pOwogCisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3Qq CisgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3JlX3JlcXVlc3QoY29uc3Qg V2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3QpOworCisgICAgLy8gRklY TUU6IG1vdmUgdGhpcyB0byB3ZWJraXRuZXR3b3JrcmVxdWVzdC5oIG9uY2UgdGhlIEFQSSBpcyBh Z3JlZWQgdXBvbi4KKyAgICBXRUJLSVRfQVBJIFNvdXBNZXNzYWdlKgorICAgIHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfZ2V0X21lc3NhZ2UoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOwor CiAgICAgLy8gRklYTUU6IG1vdmUgdGhpcyBmdW5jdGlvbmFsaXR5IGludG8gYSAnV2ViS2l0V2Vi RGF0YVNvdXJjZScgb25jZSBpbXBsZW1lbnRlZAogICAgIFdFQktJVF9BUEkgZ2NoYXIqCiAgICAg d2Via2l0X3dlYl9mcmFtZV9nZXRfcmVzcG9uc2VfbWltZV90eXBlKFdlYktpdFdlYkZyYW1lKiBm cmFtZSk7CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAg Yi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKaW5kZXggYTcyYmI5My4uOTAw MTIxMiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCisr KyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcApAQCAtNTEwLDkgKzUxMCw3 IEBAIHZvaWQgd2Via2l0X3dlYl9mcmFtZV9sb2FkX3JlcXVlc3QoV2ViS2l0V2ViRnJhbWUqIGZy YW1lLCBXZWJLaXROZXR3b3JrUmVxdWVzdCoKICAgICBpZiAoIWNvcmVGcmFtZSkKICAgICAgICAg cmV0dXJuOwogCi0gICAgLy8gVE9ETzogVXNlIHRoZSBSZXNvdXJjZVJlcXVlc3QgY2FycmllZCBi eSBXZWJLaXROZXR3b3JrUmVxdWVzdCB3aGVuIGl0IGlzIGltcGxlbWVudGVkLgotICAgIFN0cmlu ZyBzdHJpbmcgPSBTdHJpbmc6OmZyb21VVEY4KHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3Vy aShyZXF1ZXN0KSk7Ci0gICAgY29yZUZyYW1lLT5sb2FkZXIoKS0+bG9hZChSZXNvdXJjZVJlcXVl c3QoS1VSTChLVVJMKCksIHN0cmluZykpLCBmYWxzZSk7CisgICAgY29yZUZyYW1lLT5sb2FkZXIo KS0+bG9hZChSZXNvdXJjZVJlcXVlc3Qod2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWVzc2Fn ZShyZXF1ZXN0KSksIGZhbHNlKTsKIH0KIAogLyoqCg==