25939 2009-05-21 10:11:29 -0700 [GTK] Text attachments in bugzilla are downloaded instead of being opened 2009-07-07 03:49:48 -0700 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) PC Linux RESOLVED FIXED P2 Normal --- 25064 1 xan.lopez gustavo abarth a.butenka christian gustavo jmalonzo oldest_to_newest 122373 0 xan.lopez 2009-05-21 10:11:29 -0700 Title says it all pretty much. One example is attachment in comment #4 here: http://bugzilla.gnome.org/show_bug.cgi?id=583180 124639 1 jmalonzo 2009-06-06 02:52:25 -0700 *** Bug 25400 has been marked as a duplicate of this bug. *** 125614 2 31233 jmalonzo 2009-06-13 06:40:39 -0700 Created attachment 31233 Don't bailout if content-type is text/plain so we can setup the headers correctly We should only bail out of the got-headers callback if the content is not modified and we don't have a content-type. At the moment we are also bailing out if content-type is text/plain, hence we don't get to setup the headers correctly for text/plain data. I've stumbled on this while trying to enable more tests in http/tests/navigation. I've also removed a couple more tests and can probably serve as tests for this patch. I've tested with the launcher and works fine and can view text/plain now :) 125621 3 zecke 2009-06-13 07:56:15 -0700 Thanks, this will allow me to use epiphany for reviewing. I will let kov review this one. 125626 4 31233 xan.lopez 2009-06-13 08:17:10 -0700 Comment on attachment 31233 Don't bailout if content-type is text/plain so we can setup the headers correctly > diff --git a/WebCore/platform/network/soup/ResourceHandleSoup.cpp b/WebCore/platform/network/soup/ResourceHandleSoup.cpp > index 6be13e2..04725b4 100644 > --- a/WebCore/platform/network/soup/ResourceHandleSoup.cpp > +++ b/WebCore/platform/network/soup/ResourceHandleSoup.cpp > @@ -151,7 +151,7 @@ static void fillResponseFromMessage(SoupMessage* msg, ResourceResponse* response > response->setHTTPHeaderField(name, value); > > GHashTable* contentTypeParameters = 0; > - String contentType = soup_message_headers_get_content_type(msg->response_headers, &contentTypeParameters); > + String contentType = String::fromUTF8(soup_message_headers_get_content_type(msg->response_headers, &contentTypeParameters)); This seems to be unrelated, and probably not needed? > > // When the server sends multiple Content-Type headers, soup will > // give us their values concatenated with commas as a separator; > @@ -255,8 +255,8 @@ static void gotHeadersCallback(SoupMessage* msg, gpointer data) > // headers; we will not do content sniffing for 304 responses, > // though, since they do not have a body. > const char* contentType = soup_message_headers_get_content_type(msg->response_headers, NULL); > - if ((msg->status_code != SOUP_STATUS_NOT_MODIFIED) > - && (!contentType || !g_ascii_strcasecmp(contentType, "text/plain"))) > + > + if (msg->status_code != SOUP_STATUS_NOT_MODIFIED && !contentType) > return; > > RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(data); If you do a git blame you'll see you are basically un-doing what kov did to fix https://bugs.webkit.org/show_bug.cgi?id=24930, so I'd say this does not seem right. 125627 5 xan.lopez 2009-06-13 08:21:42 -0700 And for what is worth, IIRC the problem with this bug was text subtypes, not text/plain itself (that's why you can see some patches in bugzilla, but not those marked as patches I think). The actual fix was something like Christian tried on bug https://bugs.webkit.org/show_bug.cgi?id=24903. 125691 6 jmalonzo 2009-06-13 16:32:24 -0700 (In reply to comment #4) > > @@ -151,7 +151,7 @@ static void fillResponseFromMessage(SoupMessage* msg, ResourceResponse* response > > response->setHTTPHeaderField(name, value); > > > > GHashTable* contentTypeParameters = 0; > > - String contentType = soup_message_headers_get_content_type(msg->response_headers, &contentTypeParameters); > > + String contentType = String::fromUTF8(soup_message_headers_get_content_type(msg->response_headers, &contentTypeParameters)); > > This seems to be unrelated, and probably not needed? I think I meant to put this in a separate patch. We have a bug https://bugs.webkit.org/show_bug.cgi?id=17432 that should avoid using String(char*) in Gtk and instead we should be using String::fromUTF8. > > > > > // When the server sends multiple Content-Type headers, soup will > > // give us their values concatenated with commas as a separator; > > @@ -255,8 +255,8 @@ static void gotHeadersCallback(SoupMessage* msg, gpointer data) > > // headers; we will not do content sniffing for 304 responses, > > // though, since they do not have a body. > > const char* contentType = soup_message_headers_get_content_type(msg->response_headers, NULL); > > - if ((msg->status_code != SOUP_STATUS_NOT_MODIFIED) > > - && (!contentType || !g_ascii_strcasecmp(contentType, "text/plain"))) > > + > > + if (msg->status_code != SOUP_STATUS_NOT_MODIFIED && !contentType) > > return; > > > > RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(data); > > If you do a git blame you'll see you are basically un-doing what kov did to fix > https://bugs.webkit.org/show_bug.cgi?id=24930, so I'd say this does not seem > right. The patch in bug #24930 comment #7 probably seemed right at that time but looking at it now, it became a blanket solution for text/plain. What we really want is to just avoid displaying content that we can't display eventhough server sends a Content-type: text-plain. And I think we can do that in navigation-requested signal right (please correct me if i'm wrong)? 125692 7 jmalonzo 2009-06-13 16:36:01 -0700 (In reply to comment #5) > And for what is worth, IIRC the problem with this bug was text subtypes, not > text/plain itself (that's why you can see some patches in bugzilla, but not > those marked as patches I think). The actual fix was something like Christian > tried on bug https://bugs.webkit.org/show_bug.cgi?id=24903. Thanks for pointing this out. I'd like to fix our issue with text/plain here and leave the media subtypes issue in bug #24903, as it's affecting some of the tests I want to run (if that's ok with you =) 125693 8 jmalonzo 2009-06-13 16:43:50 -0700 (In reply to comment #6) > > The patch in bug #24930 comment #7 probably seemed right at that time but > looking at it now, it became a blanket solution for text/plain. What we really > want is to just avoid displaying content that we can't display eventhough > server sends a Content-type: text-plain. And I think we can do that in > navigation-requested signal right (please correct me if i'm wrong)? Sorry, I meant "decide policy for mime type" handlers. 125701 9 31246 jmalonzo 2009-06-13 17:32:15 -0700 Created attachment 31246 updated patch to sniff text/plain data too - but only once we have the data Updated patch to bring back the fix in bug #24930 but only sniff once we have the data (i.e. in the got-chunk callback) and if the content-type in the header is text/plain. This also removes the blanket solution we're currently applying for text/plain. One caveat of this update is the tests I've enabled now fail. But those will be fixed once we have the text/ media subtypes issue fixed, which is discussed in a separate bug report. 125751 10 31256 jmalonzo 2009-06-14 01:22:29 -0700 Created attachment 31256 update patch with updated comments and changelog This is almost the same patch except for updated inline comments and the use of g_content_type_equals instead of g_strcasecmp. 125825 11 31256 abarth 2009-06-14 14:51:36 -0700 Comment on attachment 31256 update patch with updated comments and changelog You really shouldn't sniff from text/plain. That causes big security problems. 125826 12 abarth 2009-06-14 14:53:11 -0700 Instead, we should use the HTML 5 content sniffing algorithm. See Bug 25064. 125919 13 jmalonzo 2009-06-15 03:43:54 -0700 (In reply to comment #12) > Instead, we should use the HTML 5 content sniffing algorithm. See Bug 25064. Thanks for the review. Making it dependent on 25064. 126038 14 gustavo 2009-06-15 14:42:22 -0700 (In reply to comment #13) > (In reply to comment #12) > > Instead, we should use the HTML 5 content sniffing algorithm. See Bug 25064. > > Thanks for the review. Making it dependent on 25064. > Though by doing nothing we _are_ still sniffing text/plain. So my suggestion is this: sniff text/plain, and if the type resulting from the sniffing starts with "text/", do not change what we received (keep text/plain). If the type is something else, make it application/octet-stream. This is better than what we currently have security-wise, and gives us a simple solution while we do not get the mime types list updated, and have no HTML5 sniffing. 126076 15 abarth 2009-06-15 16:11:07 -0700 > Though by doing nothing we _are_ still sniffing text/plain. So my suggestion is > this: sniff text/plain, and if the type resulting from the sniffing starts with > "text/", do not change what we received (keep text/plain). If the type is > something else, make it application/octet-stream. That sounds like a big hack. > This is better than what we > currently have security-wise, and gives us a simple solution while we do not > get the mime types list updated, and have no HTML5 sniffing. If you're mainly concerned about text/plain <=> application/octet-stream, you can implement the text-or-binary algorithm, which is quite simple. Is there a big rush for resolving this issue? I think the best solution is to wait for Bug 25064 to be fixed. 126188 16 gustavo 2009-06-16 06:41:21 -0700 (In reply to comment #15) > > Though by doing nothing we _are_ still sniffing text/plain. So my suggestion is > > this: sniff text/plain, and if the type resulting from the sniffing starts with > > "text/", do not change what we received (keep text/plain). If the type is > > something else, make it application/octet-stream. > > That sounds like a big hack. Well, our whole sniffing code is a big hack. > > This is better than what we > > currently have security-wise, and gives us a simple solution while we do not > > get the mime types list updated, and have no HTML5 sniffing. > > If you're mainly concerned about text/plain <=> application/octet-stream, you > can implement the text-or-binary algorithm, which is quite simple. Yes, that's the main concern. Do you have a pointer on how to get this algorithm implemented? > Is there a big rush for resolving this issue? I think the best solution is to > wait for Bug 25064 to be fixed. Somewhat. We do snapshot releases quite often, and people are already using the code in preview releases of their software. If nothing else, we need to at least stop sniffing text/plain unconditionally, I think. The whole sniffing hack got written because we had no proper content sniffing in our http library, nor in webkit, and people were getting numerous download requests when, say, flash content was sent as application/octet-stream. What we need is really a quick fix that, even if not ideal, works well enough while we wait for proper sniffing to happen in either libsoup (I'm working on this), or webkit. 126243 17 abarth 2009-06-16 11:34:13 -0700 > Yes, that's the main concern. Do you have a pointer on how to get this > algorithm implemented? The algorithm is super simple. You can see it specified here: http://tools.ietf.org/html/draft-abarth-mime-sniff-01#section-4 or implemented here in the "LooksBinary" function here: http://src.chromium.org/viewvc/chrome/trunk/src/net/base/mime_sniffer.cc > Somewhat. We do snapshot releases quite often, and people are already using the > code in preview releases of their software. If nothing else, we need to at > least stop sniffing text/plain unconditionally, I think. I'd be happy to review a patch that does that. > What we need is really a quick fix that, even if not ideal, works well enough > while we wait for proper sniffing to happen in either libsoup (I'm working on > this), or webkit. Do you have a pointer to the libsoup discussion? I'd like to make sure it implements the HTML 5 algorithm. 126245 18 gustavo 2009-06-16 11:41:21 -0700 (In reply to comment #17) > > Yes, that's the main concern. Do you have a pointer on how to get this > > algorithm implemented? > > The algorithm is super simple. You can see it specified here: Thanks for the pointers! > > What we need is really a quick fix that, even if not ideal, works well enough > > while we wait for proper sniffing to happen in either libsoup (I'm working on > > this), or webkit. > > Do you have a pointer to the libsoup discussion? I'd like to make sure it > implements the HTML 5 algorithm. Implementing the HTML5 algorithm is the idea =): http://bugzilla.gnome.org/show_bug.cgi?id=572589 129703 19 32236 jmalonzo 2009-07-03 05:30:49 -0700 Created attachment 32236 remove workaround and rely on libsoup to do the sniffing 129815 20 32236 gustavo 2009-07-04 16:03:47 -0700 Comment on attachment 32236 remove workaround and rely on libsoup to do the sniffing > + Remove workarounds for content type sniffing and rely on libsoup's > + content sniffer (now that it has one). This is not enough. We need to actually add the sniffer feature to the session, and use the new signal. I have a now-outdated webkitgtk+ patch at http://bugzilla.gnome.org/show_bug.cgi?id=572589 which I was planning to update and propose for reviewing. I'll do it tomorrow, but if you'd like to beat me to it, go ahead =D. 130176 21 jmalonzo 2009-07-07 03:49:48 -0700 Fix landed in 45558. Related bug: https://bugs.webkit.org/show_bug.cgi?id=26982 31233 2009-06-13 06:40:39 -0700 2009-06-13 17:32:15 -0700 Don't bailout if content-type is text/plain so we can setup the headers correctly textplain-fix.patch text/plain 3570 jmalonzo ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA0MmFlODZiLi41YWQwMWJlIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTIgQEAKKzIwMDktMDYt MTMgIEphbiBNaWNoYWVsIEFsb256byAgPGptYWxvbnpvQHdlYmtpdC5vcmc+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRW5hYmxlIGEgY291cGxlIG9m IHRlc3RzIHRoYXQgdXNlcyBDb250ZW50LVR5cGUgdGV4dC9wbGFpbi4KKyAgICAgICAgVGhlcmUn cyBwcm9iYWJseSBtb3JlIHRoYXQgd2UgY2FuIGVuYWJsZSBidXQgdGhpcyBpcyBhIHN0YXJ0Lgor CisgICAgICAgICogcGxhdGZvcm0vZ3RrL1NraXBwZWQ6CisKIDIwMDktMDYtMTIgIEphbiBNaWNo YWVsIEFsb256byAgPGptYWxvbnpvQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkg R3VzdGF2byBOb3JvbmhhLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL1Nr aXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZAppbmRleCA0MjVhMGI4Li5i YzVkMDU0IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZAorKysg Yi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZApAQCAtMzc5Niw4ICszNzk2LDYgQEAg aHR0cC90ZXN0cy9uYXZpZ2F0aW9uL2RvY3VtZW50LWxvY2F0aW9uLWNsaWNrLXRpbWVvdXQuaHRt bAogaHR0cC90ZXN0cy9uYXZpZ2F0aW9uL2RvY3VtZW50LWxvY2F0aW9uLWNsaWNrLmh0bWwKIGh0 dHAvdGVzdHMvbmF2aWdhdGlvbi9kb2N1bWVudC1sb2NhdGlvbi1tb3VzZW92ZXIuaHRtbAogaHR0 cC90ZXN0cy9uYXZpZ2F0aW9uL25ldy13aW5kb3ctcmVkaXJlY3QtaGlzdG9yeS5odG1sCi1odHRw L3Rlc3RzL25hdmlnYXRpb24vcmVsb2FkLXN1YmZyYW1lLWZyYW1lLmh0bWwKLWh0dHAvdGVzdHMv bmF2aWdhdGlvbi9yZWxvYWQtc3ViZnJhbWUtaWZyYW1lLmh0bWwKIGh0dHAvdGVzdHMvbmF2aWdh dGlvbi9yZWxvYWQtc3ViZnJhbWUtb2JqZWN0Lmh0bWwKIGh0dHAvdGVzdHMvbmF2aWdhdGlvbi90 YXJnZXQtZnJhbWUtZnJvbS13aW5kb3cuaHRtbAogaHR0cC90ZXN0cy9wbHVnaW5zL25wYXBpLXJl c3BvbnNlLWhlYWRlcnMuaHRtbApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJD b3JlL0NoYW5nZUxvZwppbmRleCA5OGE0ZWJmLi5jNjE3MGMzIDEwMDY0NAotLS0gYS9XZWJDb3Jl L0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDA5 LTA2LTEzICBKYW4gTWljaGFlbCBBbG9uem8gIDxqbWFsb256b0B3ZWJraXQub3JnPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtHVEtdIFRleHQgYXR0 YWNobWVudHMgaW4gYnVnemlsbGEgYXJlIGRvd25sb2FkZWQgaW5zdGVhZCBvZiBiZWluZyBvcGVu ZWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI1OTM5 CisKKyAgICAgICAgV2Ugc2hvdWxkIG9ubHkgYmFpbCBvdXQgb2YgdGhlIGdvdC1oZWFkZXJzIGNh bGxiYWNrIGlmIHRoZSBjb250ZW50CisgICAgICAgIGlzIG5vdCBtb2RpZmllZCBhbmQgd2UgZG9u J3QgaGF2ZSBhIGNvbnRlbnQtdHlwZS4gQXQgdGhlIG1vbWVudAorICAgICAgICB3ZSBhcmUgYWxz byBiYWlsaW5nIG91dCBpZiBjb250ZW50LXR5cGUgaXMgdGV4dC9wbGFpbiwgaGVuY2Ugd2UKKyAg ICAgICAgZG9uJ3QgZ2V0IHRvIHNldHVwIHRoZSBoZWFkZXJzIGNvcnJlY3RseSBmb3IgdGV4dC9w bGFpbiBkYXRhLgorCisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFu ZGxlU291cC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpmaWxsUmVzcG9uc2VGcm9tTWVzc2FnZSk6 CisgICAgICAgIChXZWJDb3JlOjpnb3RIZWFkZXJzQ2FsbGJhY2spOgorCiAyMDA5LTA2LTEyICBE YXZpZCBIeWF0dCAgPGh5YXR0QGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYW4g QmVybnN0ZWluLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVz b3VyY2VIYW5kbGVTb3VwLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlSGFuZGxlU291cC5jcHAKaW5kZXggNmJlMTNlMi4uMDQ3MjViNCAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcAorKysgYi9X ZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCkBAIC0x NTEsNyArMTUxLDcgQEAgc3RhdGljIHZvaWQgZmlsbFJlc3BvbnNlRnJvbU1lc3NhZ2UoU291cE1l c3NhZ2UqIG1zZywgUmVzb3VyY2VSZXNwb25zZSogcmVzcG9uc2UKICAgICAgICAgcmVzcG9uc2Ut PnNldEhUVFBIZWFkZXJGaWVsZChuYW1lLCB2YWx1ZSk7CiAKICAgICBHSGFzaFRhYmxlKiBjb250 ZW50VHlwZVBhcmFtZXRlcnMgPSAwOwotICAgIFN0cmluZyBjb250ZW50VHlwZSA9IHNvdXBfbWVz c2FnZV9oZWFkZXJzX2dldF9jb250ZW50X3R5cGUobXNnLT5yZXNwb25zZV9oZWFkZXJzLCAmY29u dGVudFR5cGVQYXJhbWV0ZXJzKTsKKyAgICBTdHJpbmcgY29udGVudFR5cGUgPSBTdHJpbmc6OmZy b21VVEY4KHNvdXBfbWVzc2FnZV9oZWFkZXJzX2dldF9jb250ZW50X3R5cGUobXNnLT5yZXNwb25z ZV9oZWFkZXJzLCAmY29udGVudFR5cGVQYXJhbWV0ZXJzKSk7CiAKICAgICAvLyBXaGVuIHRoZSBz ZXJ2ZXIgc2VuZHMgbXVsdGlwbGUgQ29udGVudC1UeXBlIGhlYWRlcnMsIHNvdXAgd2lsbAogICAg IC8vIGdpdmUgdXMgdGhlaXIgdmFsdWVzIGNvbmNhdGVuYXRlZCB3aXRoIGNvbW1hcyBhcyBhIHNl cGFyYXRvcjsKQEAgLTI1NSw4ICsyNTUsOCBAQCBzdGF0aWMgdm9pZCBnb3RIZWFkZXJzQ2FsbGJh Y2soU291cE1lc3NhZ2UqIG1zZywgZ3BvaW50ZXIgZGF0YSkKICAgICAvLyBoZWFkZXJzOyB3ZSB3 aWxsIG5vdCBkbyBjb250ZW50IHNuaWZmaW5nIGZvciAzMDQgcmVzcG9uc2VzLAogICAgIC8vIHRo b3VnaCwgc2luY2UgdGhleSBkbyBub3QgaGF2ZSBhIGJvZHkuCiAgICAgY29uc3QgY2hhciogY29u dGVudFR5cGUgPSBzb3VwX21lc3NhZ2VfaGVhZGVyc19nZXRfY29udGVudF90eXBlKG1zZy0+cmVz cG9uc2VfaGVhZGVycywgTlVMTCk7Ci0gICAgaWYgKChtc2ctPnN0YXR1c19jb2RlICE9IFNPVVBf U1RBVFVTX05PVF9NT0RJRklFRCkKLSAgICAgICAgJiYgKCFjb250ZW50VHlwZSB8fCAhZ19hc2Np aV9zdHJjYXNlY21wKGNvbnRlbnRUeXBlLCAidGV4dC9wbGFpbiIpKSkKKworICAgIGlmIChtc2ct PnN0YXR1c19jb2RlICE9IFNPVVBfU1RBVFVTX05PVF9NT0RJRklFRCAmJiAhY29udGVudFR5cGUp CiAgICAgICAgIHJldHVybjsKIAogICAgIFJlZlB0cjxSZXNvdXJjZUhhbmRsZT4gaGFuZGxlID0g c3RhdGljX2Nhc3Q8UmVzb3VyY2VIYW5kbGUqPihkYXRhKTsK 31246 2009-06-13 17:32:15 -0700 2009-06-14 01:22:29 -0700 updated patch to sniff text/plain data too - but only once we have the data textplain-fix2.patch text/plain 2993 jmalonzo ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZjFjODRkZi4uYWNlNDFkNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAwOS0wNi0xMyAgSmFuIE1pY2hhZWwg QWxvbnpvICA8am1hbG9uem9Ad2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBbR1RLXSBUZXh0IGF0dGFjaG1lbnRzIGluIGJ1Z3ppbGxh IGFyZSBkb3dubG9hZGVkIGluc3RlYWQgb2YgYmVpbmcgb3BlbmVkCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTkzOQorCisgICAgICAgIFdlIHNob3Vs ZCBvbmx5IGJhaWwgb3V0IG9mIHRoZSBnb3QtaGVhZGVycyBjYWxsYmFjayBpZiB0aGUgY29udGVu dAorICAgICAgICBpcyBub3QgbW9kaWZpZWQgYW5kIHdlIGRvbid0IGhhdmUgYSBjb250ZW50LXR5 cGUuIEF0IHRoZSBtb21lbnQKKyAgICAgICAgd2UgYXJlIGFsc28gYmFpbGluZyBvdXQgaWYgY29u dGVudC10eXBlIGlzIHRleHQvcGxhaW4sIGhlbmNlIHdlCisgICAgICAgIGRvbid0IGdldCB0byBz ZXR1cCB0aGUgaGVhZGVycyBjb3JyZWN0bHkgZm9yIHRleHQvcGxhaW4gZGF0YS4KKworICAgICAg ICBJbiBhZGRpdGlvbiwgd2UgbW92ZSB0aGUgc25pZmZpbmcgb25jZSB3ZSBoYXZlIHRoZSBkYXRh IGFuZCBpZiB0aGUKKyAgICAgICAgY29udGVudCB0eXBlIGRldGVjdGVkIGluIHRoZSBoZWFkZXIg aXMgdGV4dC9wbGFpbiAob2YgaWYgbmlsKS4gVGhpcyBtYWtlcyBzdXJlCisgICAgICAgIHdlIGRv bid0IHJlZ3Jlc3MgdGhlIGZpeCBpbiBidWcgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTI0OTMwCisKKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3Vy Y2VIYW5kbGVTb3VwLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmdvdEhlYWRlcnNDYWxsYmFjayk6 CisgICAgICAgIChXZWJDb3JlOjpnb3RDaHVua0NhbGxiYWNrKToKKwogMjAwOS0wNi0xMyAgVmlj dG9yIFdhbmcgPHZpY3RvcndAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEVy aWMgU2VpZGVsLiAgTGFuZGVkIGJ5IEFkYW0gQmFydGguCmRpZmYgLS1naXQgYS9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwIGIvV2ViQ29yZS9wbGF0 Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcAppbmRleCA2YmUxM2UyLi4y ZTc3NjEwIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJj ZUhhbmRsZVNvdXAuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlSGFuZGxlU291cC5jcHAKQEAgLTI1NSw4ICsyNTUsOCBAQCBzdGF0aWMgdm9pZCBnb3RIZWFk ZXJzQ2FsbGJhY2soU291cE1lc3NhZ2UqIG1zZywgZ3BvaW50ZXIgZGF0YSkKICAgICAvLyBoZWFk ZXJzOyB3ZSB3aWxsIG5vdCBkbyBjb250ZW50IHNuaWZmaW5nIGZvciAzMDQgcmVzcG9uc2VzLAog ICAgIC8vIHRob3VnaCwgc2luY2UgdGhleSBkbyBub3QgaGF2ZSBhIGJvZHkuCiAgICAgY29uc3Qg Y2hhciogY29udGVudFR5cGUgPSBzb3VwX21lc3NhZ2VfaGVhZGVyc19nZXRfY29udGVudF90eXBl KG1zZy0+cmVzcG9uc2VfaGVhZGVycywgTlVMTCk7Ci0gICAgaWYgKChtc2ctPnN0YXR1c19jb2Rl ICE9IFNPVVBfU1RBVFVTX05PVF9NT0RJRklFRCkKLSAgICAgICAgJiYgKCFjb250ZW50VHlwZSB8 fCAhZ19hc2NpaV9zdHJjYXNlY21wKGNvbnRlbnRUeXBlLCAidGV4dC9wbGFpbiIpKSkKKworICAg IGlmIChtc2ctPnN0YXR1c19jb2RlICE9IFNPVVBfU1RBVFVTX05PVF9NT0RJRklFRCAmJiAhY29u dGVudFR5cGUpCiAgICAgICAgIHJldHVybjsKIAogICAgIFJlZlB0cjxSZXNvdXJjZUhhbmRsZT4g aGFuZGxlID0gc3RhdGljX2Nhc3Q8UmVzb3VyY2VIYW5kbGUqPihkYXRhKTsKQEAgLTI5MSw3ICsy OTEsMTIgQEAgc3RhdGljIHZvaWQgZ290Q2h1bmtDYWxsYmFjayhTb3VwTWVzc2FnZSogbXNnLCBT b3VwQnVmZmVyKiBjaHVuaywgZ3BvaW50ZXIgZGF0YSkKICAgICBpZiAoIWNsaWVudCkKICAgICAg ICAgcmV0dXJuOwogCi0gICAgaWYgKCFkLT5tX3JlcG9ydGVkSGVhZGVycykgeworICAgIC8vIEJ1 ZyAjMjQ5MzAgLSBTb21lIHNlcnZlcnMgc2VuZCBhIGRlZmF1bHQgQ29udGVudC1UeXBlOiB0ZXh0 L3BsYWluLiBCdXQKKyAgICAvLyBzaW5jZSB3ZSBkb24ndCB0cnVzdCBzZXJ2ZXJzIHdobyBzZW5k cyB0ZXh0L3BsYWluIGFzIHRoZSBDb250ZW50LVR5cGUsCisgICAgLy8gd2Ugc25pZmYgaXQgaGVy ZS4gV2UgYWxzbyBzbmlmZiB0aGUgY29udGVudCBpbiBjYXNlIHdlIHdlcmVuJ3QgYWJsZSB0bwor ICAgIC8vIHByb2Nlc3MgdGhlIGhlYWRlci4KKyAgICBjb25zdCBnY2hhciogaGVhZGVyQ29udGVu dFR5cGUgPSBzb3VwX21lc3NhZ2VfaGVhZGVyc19nZXRfY29udGVudF90eXBlKG1zZy0+cmVzcG9u c2VfaGVhZGVycywgTlVMTCk7CisgICAgaWYgKCFoZWFkZXJDb250ZW50VHlwZSB8fCAhZ19hc2Np aV9zdHJjYXNlY21wKGhlYWRlckNvbnRlbnRUeXBlLCAidGV4dC9wbGFpbiIpIHx8ICFkLT5tX3Jl cG9ydGVkSGVhZGVycykgewogICAgICAgICBnYm9vbGVhbiB1bmNlcnRhaW47CiAgICAgICAgIGNo YXIqIGNvbnRlbnRUeXBlID0gZ19jb250ZW50X3R5cGVfZ3Vlc3MoZC0+bV9yZXF1ZXN0LnVybCgp Lmxhc3RQYXRoQ29tcG9uZW50KCkudXRmOCgpLmRhdGEoKSwgcmVpbnRlcnByZXRfY2FzdDxjb25z dCBndWNoYXIqPihjaHVuay0+ZGF0YSksIGNodW5rLT5sZW5ndGgsICZ1bmNlcnRhaW4pOwogICAg ICAgICBzb3VwX21lc3NhZ2VfaGVhZGVyc19zZXRfY29udGVudF90eXBlKG1zZy0+cmVzcG9uc2Vf aGVhZGVycywgY29udGVudFR5cGUsIE5VTEwpOwo= 31256 2009-06-14 01:22:29 -0700 2009-07-03 05:30:49 -0700 update patch with updated comments and changelog textplain-fix2.patch text/plain 3410 jmalonzo ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MzZkMTE4Mi4uNDliZTdhMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAwOS0wNi0xNCAgSmFuIE1pY2hhZWwg QWxvbnpvICA8am1hbG9uem9Ad2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBbR1RLXSBUZXh0IGF0dGFjaG1lbnRzIGluIGJ1Z3ppbGxh IGFyZSBkb3dubG9hZGVkIGluc3RlYWQgb2YgYmVpbmcgb3BlbmVkCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTkzOQorCisgICAgICAgIFdlIHNob3Vs ZCBvbmx5IGJhaWwgb3V0IG9mIHRoZSBnb3QtaGVhZGVycyBjYWxsYmFjayBpZiB0aGUgY29udGVu dAorICAgICAgICBpcyBub3QgbW9kaWZpZWQgYW5kIHdlIGRvbid0IGhhdmUgYSBjb250ZW50LXR5 cGUuIEF0IHRoZSBtb21lbnQKKyAgICAgICAgd2UgYXJlIGFsc28gYmFpbGluZyBvdXQgaWYgY29u dGVudC10eXBlIGlzIHRleHQvcGxhaW4sIGhlbmNlIHdlCisgICAgICAgIGRvbid0IGdldCB0byBz ZXR1cCB0aGUgaGVhZGVycyBjb3JyZWN0bHkgZm9yIHRleHQvcGxhaW4gZGF0YS4KKworICAgICAg ICBUaGUgYXBwcm9hY2ggb2YgdGhpcyBwYXRjaCBpcyB0byBzZXQgdGhlIENvbnRlbnQtVHlwZSBo ZWFkZXIgYXMKKyAgICAgICAgc2VudCB0byB1cyBieSB0aGUgc2VydmVyLiBCdXQgYXMgYSBwcmVj YXV0aW9uIGFuZCB0byBtaW5pbWl6ZSBidWdzCisgICAgICAgIGxpa2UgYnVnICMyNDkzMCwgd2Ug ZG91YmxlLWNoZWNrIGRhdGEgd2l0aCBjb250ZW50LXR5cGUgb2YKKyAgICAgICAgdGV4dC9wbGFp biB0byBtYWtlIHN1cmUgdGhlIGRhdGEgaXMgd2hhdCBpdCBpcyBhcyB0aGUgc2VydmVyIHRvbGQK KyAgICAgICAgdXMuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VI YW5kbGVTb3VwLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmdvdENodW5rQ2FsbGJhY2spOgorCiAy MDA5LTA2LTEzICBQZXRlciBLYXN0aW5nICA8cGthc3RpbmdAZ29vZ2xlLmNvbT4KIAogICAgICAg ICBSZXZpZXdlZCBieSBLZXZpbiBPbGxpdmllci4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCmluZGV4IDZiZTEzZTIuLjZhYmNj ZmUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFu ZGxlU291cC5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VI YW5kbGVTb3VwLmNwcApAQCAtMjUwLDEzICsyNTAsMTAgQEAgc3RhdGljIHZvaWQgZ290SGVhZGVy c0NhbGxiYWNrKFNvdXBNZXNzYWdlKiBtc2csIGdwb2ludGVyIGRhdGEpCiAgICAgICAgIHx8IChT T1VQX1NUQVRVU19JU19SRURJUkVDVElPTihtc2ctPnN0YXR1c19jb2RlKSAmJiAobXNnLT5zdGF0 dXNfY29kZSAhPSBTT1VQX1NUQVRVU19OT1RfTU9ESUZJRUQpKSkKICAgICAgICAgcmV0dXJuOwog Ci0gICAgLy8gV2Ugc3RpbGwgZG9uJ3Qga25vdyBhbnl0aGluZyBhYm91dCBDb250ZW50LVR5cGUs IHNvIHdlIHdpbGwgdHJ5Ci0gICAgLy8gc25pZmZpbmcgdGhlIGNvbnRlbnRzIG9mIHRoZSBmaWxl LCBhbmQgdGhlbiByZXBvcnQgdGhhdCB3ZSBnb3QKLSAgICAvLyBoZWFkZXJzOyB3ZSB3aWxsIG5v dCBkbyBjb250ZW50IHNuaWZmaW5nIGZvciAzMDQgcmVzcG9uc2VzLAotICAgIC8vIHRob3VnaCwg c2luY2UgdGhleSBkbyBub3QgaGF2ZSBhIGJvZHkuCisgICAgLy8gU2V0IHRoZSBDb250ZW50LVR5 cGUgYWNjb3JkaW5nIHRvIHRoZSBoZWFkZXIgZXhjZXB0IHdoZW4gd2UgZ2V0IGEgMzA0CisgICAg Ly8gb3IgdGhlIGNvbnRlbnQtdHlwZSBpcyBlbXB0eS4gV2UgZG9uJ3QgdXBkYXRlIHRoZSBoZWFk ZXJzIGlmIGl0J3MgYSAzMDQuCiAgICAgY29uc3QgY2hhciogY29udGVudFR5cGUgPSBzb3VwX21l c3NhZ2VfaGVhZGVyc19nZXRfY29udGVudF90eXBlKG1zZy0+cmVzcG9uc2VfaGVhZGVycywgTlVM TCk7Ci0gICAgaWYgKChtc2ctPnN0YXR1c19jb2RlICE9IFNPVVBfU1RBVFVTX05PVF9NT0RJRklF RCkKLSAgICAgICAgJiYgKCFjb250ZW50VHlwZSB8fCAhZ19hc2NpaV9zdHJjYXNlY21wKGNvbnRl bnRUeXBlLCAidGV4dC9wbGFpbiIpKSkKKyAgICBpZiAobXNnLT5zdGF0dXNfY29kZSAhPSBTT1VQ X1NUQVRVU19OT1RfTU9ESUZJRUQgJiYgIWNvbnRlbnRUeXBlKQogICAgICAgICByZXR1cm47CiAK ICAgICBSZWZQdHI8UmVzb3VyY2VIYW5kbGU+IGhhbmRsZSA9IHN0YXRpY19jYXN0PFJlc291cmNl SGFuZGxlKj4oZGF0YSk7CkBAIC0yOTEsNyArMjg4LDExIEBAIHN0YXRpYyB2b2lkIGdvdENodW5r Q2FsbGJhY2soU291cE1lc3NhZ2UqIG1zZywgU291cEJ1ZmZlciogY2h1bmssIGdwb2ludGVyIGRh dGEpCiAgICAgaWYgKCFjbGllbnQpCiAgICAgICAgIHJldHVybjsKIAotICAgIGlmICghZC0+bV9y ZXBvcnRlZEhlYWRlcnMpIHsKKyAgICAvLyBCdWcgIzI0OTMwIC0gU29tZSBzZXJ2ZXJzIHNlbmQg YSBkZWZhdWx0IENvbnRlbnQtVHlwZTogdGV4dC9wbGFpbiBzbworICAgIC8vIGxldCdzIGRvdWJs ZS1jaGVjayBhbmQgc25pZmYgdGhlIGNvbnRlbnQgdG8gZGV0ZXJtaW5lIHRoZSBjb250ZW50LXR5 cGUuCisgICAgLy8gQWxzbyBzbmlmZiBpZiB3ZSB3ZXJlbid0IGFibGUgdG8gcHJvY2VzcyB0aGUg aGVhZGVycyAoaS5lLiwgbV9yZXBvcnRlZEhlYWRlcnMgPSBmYWxzZSkuCisgICAgY29uc3QgZ2No YXIqIGhlYWRlckNvbnRlbnRUeXBlID0gc291cF9tZXNzYWdlX2hlYWRlcnNfZ2V0X2NvbnRlbnRf dHlwZShtc2ctPnJlc3BvbnNlX2hlYWRlcnMsIE5VTEwpOworICAgIGlmICghaGVhZGVyQ29udGVu dFR5cGUgfHwgZ19jb250ZW50X3R5cGVfZXF1YWxzKGhlYWRlckNvbnRlbnRUeXBlLCAidGV4dC9w bGFpbiIpIHx8ICFkLT5tX3JlcG9ydGVkSGVhZGVycykgewogICAgICAgICBnYm9vbGVhbiB1bmNl cnRhaW47CiAgICAgICAgIGNoYXIqIGNvbnRlbnRUeXBlID0gZ19jb250ZW50X3R5cGVfZ3Vlc3Mo ZC0+bV9yZXF1ZXN0LnVybCgpLmxhc3RQYXRoQ29tcG9uZW50KCkudXRmOCgpLmRhdGEoKSwgcmVp bnRlcnByZXRfY2FzdDxjb25zdCBndWNoYXIqPihjaHVuay0+ZGF0YSksIGNodW5rLT5sZW5ndGgs ICZ1bmNlcnRhaW4pOwogICAgICAgICBzb3VwX21lc3NhZ2VfaGVhZGVyc19zZXRfY29udGVudF90 eXBlKG1zZy0+cmVzcG9uc2VfaGVhZGVycywgY29udGVudFR5cGUsIE5VTEwpOwo= 32236 2009-07-03 05:30:49 -0700 2009-07-04 16:03:47 -0700 remove workaround and rely on libsoup to do the sniffing textplain-fix2.patch text/plain 3025 jmalonzo ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YWNmMWMyZS4uNjM1MDVjMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAwOS0wNy0wMyAgSmFuIE1pY2hhZWwg QWxvbnpvICA8am1hbG9uem9Ad2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBbR1RLXSBUZXh0IGF0dGFjaG1lbnRzIGluIGJ1Z3ppbGxh IGFyZSBkb3dubG9hZGVkIGluc3RlYWQgb2YgYmVpbmcgb3BlbmVkCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTkzOQorCisgICAgICAgIFJlbW92ZSB3 b3JrYXJvdW5kcyBmb3IgY29udGVudCB0eXBlIHNuaWZmaW5nIGFuZCByZWx5IG9uIGxpYnNvdXAn cworICAgICAgICBjb250ZW50IHNuaWZmZXIgKG5vdyB0aGF0IGl0IGhhcyBvbmUpLgorCisgICAg ICAgICogcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpnb3RDaHVua0NhbGxiYWNrKToKKwogMjAwOS0wNy0wMiAgUGllcnJlIGQn SGVyYmVtb250ICA8cGRoZXJiZW1vbnRAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5 IFNpbW9uIEZyYXNlci4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3Vw L1Jlc291cmNlSGFuZGxlU291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9S ZXNvdXJjZUhhbmRsZVNvdXAuY3BwCmluZGV4IDZiZTEzZTIuLjMxYzRjYjAgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKKysr IGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcApA QCAtMjQ2LDE3ICsyNDYsNyBAQCBzdGF0aWMgdm9pZCBnb3RIZWFkZXJzQ2FsbGJhY2soU291cE1l c3NhZ2UqIG1zZywgZ3BvaW50ZXIgZGF0YSkKICAgICAvLyBpbnRvIFdlYkNvcmUsIGFzIG9wcG9z ZWQgdG8gb3RoZXIga2luZHMgb2YgcmVkaXJlY3Rpb25zLCB3aGljaAogICAgIC8vIGFyZSBoYW5k bGVkIGJ5IHNvdXAgZGlyZWN0bHksIHNvIHdlIHNwZWNpYWwtY2FzZSBpdCBoZXJlIGFuZCBpbgog ICAgIC8vIGdvdENodW5rLgotICAgIGlmIChTT1VQX1NUQVRVU19JU19UUkFOU1BPUlRfRVJST1Io bXNnLT5zdGF0dXNfY29kZSkKLSAgICAgICAgfHwgKFNPVVBfU1RBVFVTX0lTX1JFRElSRUNUSU9O KG1zZy0+c3RhdHVzX2NvZGUpICYmIChtc2ctPnN0YXR1c19jb2RlICE9IFNPVVBfU1RBVFVTX05P VF9NT0RJRklFRCkpKQotICAgICAgICByZXR1cm47Ci0KLSAgICAvLyBXZSBzdGlsbCBkb24ndCBr bm93IGFueXRoaW5nIGFib3V0IENvbnRlbnQtVHlwZSwgc28gd2Ugd2lsbCB0cnkKLSAgICAvLyBz bmlmZmluZyB0aGUgY29udGVudHMgb2YgdGhlIGZpbGUsIGFuZCB0aGVuIHJlcG9ydCB0aGF0IHdl IGdvdAotICAgIC8vIGhlYWRlcnM7IHdlIHdpbGwgbm90IGRvIGNvbnRlbnQgc25pZmZpbmcgZm9y IDMwNCByZXNwb25zZXMsCi0gICAgLy8gdGhvdWdoLCBzaW5jZSB0aGV5IGRvIG5vdCBoYXZlIGEg Ym9keS4KLSAgICBjb25zdCBjaGFyKiBjb250ZW50VHlwZSA9IHNvdXBfbWVzc2FnZV9oZWFkZXJz X2dldF9jb250ZW50X3R5cGUobXNnLT5yZXNwb25zZV9oZWFkZXJzLCBOVUxMKTsKLSAgICBpZiAo KG1zZy0+c3RhdHVzX2NvZGUgIT0gU09VUF9TVEFUVVNfTk9UX01PRElGSUVEKQotICAgICAgICAm JiAoIWNvbnRlbnRUeXBlIHx8ICFnX2FzY2lpX3N0cmNhc2VjbXAoY29udGVudFR5cGUsICJ0ZXh0 L3BsYWluIikpKQorICAgIGlmIChTT1VQX1NUQVRVU19JU19UUkFOU1BPUlRfRVJST1IobXNnLT5z dGF0dXNfY29kZSkgfHwgKFNPVVBfU1RBVFVTX0lTX1JFRElSRUNUSU9OKG1zZy0+c3RhdHVzX2Nv ZGUpICYmIChtc2ctPnN0YXR1c19jb2RlICE9IFNPVVBfU1RBVFVTX05PVF9NT0RJRklFRCkpKQog ICAgICAgICByZXR1cm47CiAKICAgICBSZWZQdHI8UmVzb3VyY2VIYW5kbGU+IGhhbmRsZSA9IHN0 YXRpY19jYXN0PFJlc291cmNlSGFuZGxlKj4oZGF0YSk7CkBAIC0yOTEsMjEgKzI4MSw2IEBAIHN0 YXRpYyB2b2lkIGdvdENodW5rQ2FsbGJhY2soU291cE1lc3NhZ2UqIG1zZywgU291cEJ1ZmZlciog Y2h1bmssIGdwb2ludGVyIGRhdGEpCiAgICAgaWYgKCFjbGllbnQpCiAgICAgICAgIHJldHVybjsK IAotICAgIGlmICghZC0+bV9yZXBvcnRlZEhlYWRlcnMpIHsKLSAgICAgICAgZ2Jvb2xlYW4gdW5j ZXJ0YWluOwotICAgICAgICBjaGFyKiBjb250ZW50VHlwZSA9IGdfY29udGVudF90eXBlX2d1ZXNz KGQtPm1fcmVxdWVzdC51cmwoKS5sYXN0UGF0aENvbXBvbmVudCgpLnV0ZjgoKS5kYXRhKCksIHJl aW50ZXJwcmV0X2Nhc3Q8Y29uc3QgZ3VjaGFyKj4oY2h1bmstPmRhdGEpLCBjaHVuay0+bGVuZ3Ro LCAmdW5jZXJ0YWluKTsKLSAgICAgICAgc291cF9tZXNzYWdlX2hlYWRlcnNfc2V0X2NvbnRlbnRf dHlwZShtc2ctPnJlc3BvbnNlX2hlYWRlcnMsIGNvbnRlbnRUeXBlLCBOVUxMKTsKLSAgICAgICAg Z19mcmVlKGNvbnRlbnRUeXBlKTsKLQotICAgICAgICBmaWxsUmVzcG9uc2VGcm9tTWVzc2FnZSht c2csICZkLT5tX3Jlc3BvbnNlKTsKLSAgICAgICAgY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2Uo aGFuZGxlLmdldCgpLCBkLT5tX3Jlc3BvbnNlKTsKLSAgICAgICAgZC0+bV9yZXBvcnRlZEhlYWRl cnMgPSB0cnVlOwotCi0gICAgICAgIC8vIHRoZSBkaWRSZWNlaXZlUmVzcG9uc2UgY2FsbCBhYm92 ZSBtYXkgaGF2ZSBjYW5jZWxsZWQgdGhlIHJlcXVlc3QKLSAgICAgICAgaWYgKGQtPm1fY2FuY2Vs bGVkKQotICAgICAgICAgICAgcmV0dXJuOwotICAgIH0KLQogICAgIGNsaWVudC0+ZGlkUmVjZWl2 ZURhdGEoaGFuZGxlLmdldCgpLCBjaHVuay0+ZGF0YSwgY2h1bmstPmxlbmd0aCwgZmFsc2UpOwog fQogCg==